## table of contents

- buster 4.05.0-11

Int32(3o) | OCamldoc | Int32(3o) |

# NAME¶

Int32 - 32-bit integers.# Module¶

Module Int32# Documentation¶

Module**Int32**:

**sig end**

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.

*val zero* : **int32**

The 32-bit integer 0.

*val one* : **int32**

The 32-bit integer 1.

*val minus_one* : **int32**

The 32-bit integer -1.

*val neg* : **int32 -> int32**

Unary negation.

*val add* : **int32 -> int32 -> int32**

Addition.

*val sub* : **int32 -> int32 -> int32**

Subtraction.

*val mul* : **int32 -> int32 -> int32**

Multiplication.

*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 succ* : **int32 -> int32**

Successor. **Int32.succ x** is **Int32.add x Int32.one**
.

*val pred* : **int32 -> int32**

Predecessor. **Int32.pred x** is **Int32.sub x Int32.one**
.

*val abs* : **int32 -> int32**

Return the absolute value of its argument.

*val max_int* : **int32**

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

*val min_int* : **int32**

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

*val logand* : **int32 -> int32 -> int32**

Bitwise logical and.

*val logor* : **int32 -> int32 -> int32**

Bitwise logical or.

*val logxor* : **int32 -> int32 -> int32**

Bitwise logical exclusive or.

*val lognot* : **int32 -> int32**

Bitwise logical negation

*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 of_int* : **int -> int32**

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

*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 to_float* : **int32 -> float**

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

*val of_string* : **string -> int32**

Convert the given string to a 32-bit integer. The string is read
in decimal (by default) or in hexadecimal, octal or binary if the string
begins with **0x** , **0o** or **0b** respectively. Raise
**Failure int_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 to_string* : **int32 -> string**

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

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

*type t* = **int32**

An alias for the type of 32-bit integers.

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

*val equal* : **t -> t -> bool**

The equal function for int32s.

**Since** 4.03.0

source: | 2019-01-25 |