# Module `Stdlib.Int32`

`val div : int32 -> int32 -> int32`

Integer division. Raise

`Division_by_zero`

if the second argument is zero. This division rounds the real quotient of its arguments towards zero, as specified for`Pervasives.(/)`

.

`val rem : int32 -> int32 -> int32`

Integer remainder. If

`y`

is not zero, the result of`Int32.rem x y`

satisfies the following property:`x = Int32.add (Int32.mul (Int32.div x y) y) (Int32.rem x y)`

. If`y = 0`

,`Int32.rem x y`

raises`Division_by_zero`

.

`val shift_left : int32 -> int -> int32`

`Int32.shift_left x y`

shifts`x`

to the left by`y`

bits. The result is unspecified if`y < 0`

or`y >= 32`

.

`val shift_right : int32 -> int -> int32`

`Int32.shift_right x y`

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`

.

`val shift_right_logical : int32 -> int -> int32`

`Int32.shift_right_logical x y`

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`

.

`val to_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.

`val of_float : float -> int32`

Convert the given floating-point number to a 32-bit integer, discarding the fractional part (truncate towards 0). The result of the conversion is undefined if, after truncation, the number is outside the range [

`Int32.min_int`

,`Int32.max_int`

].

`val of_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. Raise`Failure "Int32.of_string"`

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`

.

`val of_string_opt : string -> int32 option`

Same as

`of_string`

, but return`None`

instead of raising.- since
- 4.05

`val bits_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.

`val float_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`

.

`val compare : t -> t -> int`

The comparison function for 32-bit integers, with the same specification as

`Pervasives.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`

.