logo
Free, unlimited AI code reviews that run on commit
git-lrc git-lrc GitHub Install Now We'd appreciate a star git-lrc - Free, unlimited AI code reviews that run on commit | Product Hunt git-lrc - Free, unlimited AI code reviews that run on commit | Product Hunt

Int32 - 32-bit integers.

Documentation

       Module Int32
        : sigend

       32-bit integers.

       This  module  provides  operations  on the type int32 of signed 32-bit integers.  Unlike the built-in int
       type, the type int32 is guaranteed to be exactly 32-bit wide on all platforms.  All arithmetic operations
       over int32 are taken modulo 2^32.

       Performance notice: values of type int32 occupy  more  memory  space  than  values  of  type  int  ,  and
       arithmetic  operations  on  int32  are  generally  slower  than  those  on int .  Use int32 only when the
       application requires exact 32-bit arithmetic.

       Literals for 32-bit integers are suffixed by l:
             letzero:int32=0lletone:int32=1lletm_one:int32=-1lvalzero : int32

       The 32-bit integer 0.

       valone : int32

       The 32-bit integer 1.

       valminus_one : int32

       The 32-bit integer -1.

       valneg : int32->int32

       Unary negation.

       valadd : int32->int32->int32

       Addition.

       valsub : int32->int32->int32

       Subtraction.

       valmul : int32->int32->int32

       Multiplication.

       valdiv : int32->int32->int32

       Integer division. This division rounds the real quotient of its arguments towards zero, as specified  for
       (/) .

       RaisesDivision_by_zero if the second argument is zero.

       valunsigned_div : int32->int32->int32

       Same as Int32.div , except that arguments and result are interpreted as     unsigned 32-bit integers.

       Since 4.08

       valrem : int32->int32->int32

       Integer  remainder.   If y is not zero, the result of Int32.remxy satisfies the following property: x=Int32.add(Int32.mul(Int32.divxy)y)(Int32.remxy)  .   If  y=0  ,  Int32.remxy  raises
       Division_by_zero .

       valunsigned_rem : int32->int32->int32

       Same as Int32.rem , except that arguments and result are interpreted as     unsigned 32-bit integers.

       Since 4.08

       valsucc : int32->int32

       Successor.  Int32.succx is Int32.addxInt32.one .

       valpred : int32->int32

       Predecessor.  Int32.predx is Int32.subxInt32.one .

       valabs : int32->int32absx is the absolute value of x . On min_int this is min_int itself and thus remains negative.

       valmax_int : int32

       The greatest representable 32-bit integer, 2^31 - 1.

       valmin_int : int32

       The smallest representable 32-bit integer, -2^31.

       vallogand : int32->int32->int32

       Bitwise logical and.

       vallogor : int32->int32->int32

       Bitwise logical or.

       vallogxor : int32->int32->int32

       Bitwise logical exclusive or.

       vallognot : int32->int32

       Bitwise logical negation.

       valshift_left : int32->int->int32Int32.shift_leftxy shifts x to the left by y bits.  The result is unspecified if y<0 or y>=32 .

       valshift_right : int32->int->int32Int32.shift_rightxy shifts x to the right by y bits.  This is an arithmetic shift: the sign bit of x is
       replicated and inserted in the vacated bits.  The result is unspecified if y<0 or y>=32 .

       valshift_right_logical : int32->int->int32Int32.shift_right_logicalxy  shifts  x  to  the right by y bits.  This is a logical shift: zeroes are
       inserted in the vacated bits regardless of the sign of x .  The result is unspecified if y<0 or y>=32
       .

       valof_int : int->int32

       Convert the given integer (type int ) to a 32-bit  integer  (type  int32  ).  On  64-bit  platforms,  the
       argument is taken modulo 2^32.

       valto_int : int32->int

       Convert  the  given  32-bit  integer  (type  int32 ) to an integer (type int ).  On 32-bit platforms, the
       32-bit integer is taken modulo 2^31, i.e. the high-order bit is lost during the  conversion.   On  64-bit
       platforms, the conversion is exact.

       valunsigned_to_int : int32->intoption

       Same  as Int32.to_int , but interprets the argument as an unsigned integer.  Returns None if the unsigned
       value of the argument cannot fit into an int .

       Since 4.08

       valof_float : float->int32

       Convert the given floating-point number to a 32-bit integer, discarding  the  fractional  part  (truncate
       towards  0).  If the truncated floating-point number is outside the range [ Int32.min_int , Int32.max_int
       ], no exception is raised, and an unspecified, platform-dependent integer is returned.

       valto_float : int32->float

       Convert the given 32-bit integer to a floating-point number.

       valof_string : string->int32

       Convert the given string to a 32-bit integer.  The string is read in  decimal  (by  default,  or  if  the
       string  begins  with  0u  )  or  in  hexadecimal, octal or binary if the string begins with 0x , 0o or 0b
       respectively.

       The 0u prefix reads the input as an unsigned integer in the range [0,2*Int32.max_int+1] .  If the  input
       exceeds Int32.max_int it is converted to the signed integer Int32.min_int+input-Int32.max_int-1 .

       The _ (underscore) character can appear anywhere in the string and is ignored.

       RaisesFailure  if  the  given  string  is  not  a valid representation of an integer, or if the integer
       represented exceeds the range of integers representable in type int32 .

       valof_string_opt : string->int32option

       Same as of_string , but return None instead of raising.

       Since 4.05

       valto_string : int32->string

       Return the string representation of its argument, in signed decimal.

       valbits_of_float : float->int32

       Return the internal representation of the given float according to the IEEE  754  floating-point  'single
       format'  bit  layout.  Bit 31 of the result represents the sign of the float; bits 30 to 23 represent the
       (biased) exponent; bits 22 to 0 represent the mantissa.

       valfloat_of_bits : int32->float

       Return the floating-point number whose internal representation, according to the IEEE 754  floating-point
       'single format' bit layout, is the given int32 .

       typet = int32

       An alias for the type of 32-bit integers.

       valcompare : t->t->int

       The  comparison  function  for  32-bit integers, with the same specification as compare .  Along with the
       type t , this function compare allows the module Int32 to be passed as argument to the functors  Set.Make
       and Map.Make .

       valunsigned_compare : t->t->int

       Same as Int32.compare , except that arguments are interpreted as unsigned 32-bit integers.

       Since 4.08

       valequal : t->t->bool

       The equal function for int32s.

       Since 4.03

       valmin : t->t->t

       Return the smaller of the two arguments.

       Since 4.13

       valmax : t->t->t

       Return the greater of the two arguments.

       Since 4.13

       valseeded_hash : int->t->int

       A seeded hash function for 32-bit ints, with the same output value as Hashtbl.seeded_hash . This function
       allows this module to be passed as argument to the functor Hashtbl.MakeSeeded .

       Since 5.1

       valhash : t->int

       An  unseeded  hash  function  for 32-bit ints, with the same output value as Hashtbl.hash . This function
       allows this module to be passed as argument to the functor Hashtbl.Make .

       Since 5.1

OCamldoc                                           2025-06-12                                          Int32(3o)

Module

       Module   Int32

Name

       Int32 - 32-bit integers.

See Also