Nativeint - Processor-native integers.

       Module Nativeint
        : sigend

       Processor-native integers.

       This  module provides operations on the type nativeint of signed 32-bit integers (on 32-bit platforms) or
       signed 64-bit integers (on 64-bit platforms).  This integer type has exactly the same width as that of  a
       pointer  type  in the C compiler.  All arithmetic operations over nativeint are taken modulo 2^32 or 2^64
       depending on the word size of the architecture.

       Performance notice: values of type nativeint occupy more memory space than  values  of  type  int  ,  and
       arithmetic  operations on nativeint are generally slower than those on int .  Use nativeint only when the
       application requires the extra bit of precision over the int type.

       Literals for native integers are suffixed by n:
            letzero:nativeint=0nletone:nativeint=1nletm_one:nativeint=-1nvalzero : nativeint

       The native integer 0.

       valone : nativeint

       The native integer 1.

       valminus_one : nativeint

       The native integer -1.

       valneg : nativeint->nativeint

       Unary negation.

       valadd : nativeint->nativeint->nativeint

       Addition.

       valsub : nativeint->nativeint->nativeint

       Subtraction.

       valmul : nativeint->nativeint->nativeint

       Multiplication.

       valdiv : nativeint->nativeint->nativeint

       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 : nativeint->nativeint->nativeint

       Same as Nativeint.div , except that arguments and result are interpreted as     unsigned native integers.

       Since 4.08

       valrem : nativeint->nativeint->nativeint

       Integer remainder.  If y is not zero, the result of Nativeint.remxy satisfies the following properties:
       Nativeint.zero<=Nativeint.remxy<Nativeint.absy and x=Nativeint.add(Nativeint.mul(Nativeint.divxy)y)(Nativeint.remxy) .  If y=0 , Nativeint.remxy raises Division_by_zero .

       valunsigned_rem : nativeint->nativeint->nativeint

       Same as Nativeint.rem , except that arguments and result are interpreted as     unsigned native integers.

       Since 4.08

       valsucc : nativeint->nativeint

       Successor.  Nativeint.succx is Nativeint.addxNativeint.one .

       valpred : nativeint->nativeint

       Predecessor.  Nativeint.predx is Nativeint.subxNativeint.one .

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

       valsize : int

       The  size  in  bits  of a native integer.  This is equal to 32 on a 32-bit platform and to 64 on a 64-bit
       platform.

       valmax_int : nativeint

       The greatest representable native integer, either 2^31 - 1 on a 32-bit platform, or 2^63 - 1 on a  64-bit
       platform.

       valmin_int : nativeint

       The  smallest  representable  native  integer,  either  -2^31  on a 32-bit platform, or -2^63 on a 64-bit
       platform.

       vallogand : nativeint->nativeint->nativeint

       Bitwise logical and.

       vallogor : nativeint->nativeint->nativeint

       Bitwise logical or.

       vallogxor : nativeint->nativeint->nativeint

       Bitwise logical exclusive or.

       vallognot : nativeint->nativeint

       Bitwise logical negation.

       valshift_left : nativeint->int->nativeintNativeint.shift_leftxy shifts x to the left by y bits.  The result is unspecified if y<0  or  y>=bitsize , where bitsize is 32 on a 32-bit platform and 64 on a 64-bit platform.

       valshift_right : nativeint->int->nativeintNativeint.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>=bitsize .

       valshift_right_logical : nativeint->int->nativeintNativeint.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>=bitsize .

       valof_int : int->nativeint

       Convert the given integer (type int ) to a native integer (type nativeint ).

       valto_int : nativeint->int

       Convert the given native integer (type nativeint ) to an integer (type int ).  The high-order bit is lost
       during the conversion.

       valunsigned_to_int : nativeint->intoption

       Same as Nativeint.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->nativeint

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

       valto_float : nativeint->float

       Convert the given native integer to a floating-point number.

       valof_int32 : int32->nativeint

       Convert the given 32-bit integer (type int32 ) to a native integer.

       valto_int32 : nativeint->int32

       Convert  the  given  native  integer  to a 32-bit integer (type int32 ).  On 64-bit platforms, the 64-bit
       native integer is taken modulo 2^32, i.e. the top 32 bits are lost.  On 32-bit platforms, the  conversion
       is exact.

       valof_string : string->nativeint

       Convert  the  given  string  to  a  native 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*Nativeint.max_int+1] .  If the
       input exceeds  Nativeint.max_int  it  is  converted  to  the  signed  integer  Int64.min_int+input-Nativeint.max_int-1 .

       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 nativeint .

       valof_string_opt : string->nativeintoption

       Same as of_string , but return None instead of raising.

       Since 4.05

       valto_string : nativeint->string

       Return the string representation of its argument, in decimal.

       typet = nativeint

       An alias for the type of native integers.

       valcompare : t->t->int

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

       valunsigned_compare : t->t->int

       Same as Nativeint.compare , except that arguments are interpreted as unsigned native integers.

       Since 4.08

       valequal : t->t->bool

       The equal function for native ints.

       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 native 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 native 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                                      Nativeint(3o)

       Module   Nativeint

       Nativeint - Processor-native integers.