Provided by: ocaml-man_4.08.1-8_all #### NAME

```       Int - Integer values.

```

#### Module

```       Module   Int

```

#### Documentation

```       Module Int
: sig end

Integer values.

Integers  are  Sys.int_size  bits  wide  and  use  two's  complement  representation.  All
operations are taken modulo 2^ Sys.int_size . They do not fail on overflow.

Since 4.08

Integers
type t = int

The type for integer values.

val zero : int

zero is the integer 0 .

val one : int

one is the integer 1 .

val minus_one : int

minus_one is the integer -1 .

val neg : int -> int

neg x is ~-x .

val add : int -> int -> int

val sub : int -> int -> int

sub x y is the subtraction x - y .

val mul : int -> int -> int

mul x y is the multiplication x * y .

val div : int -> int -> int

div x y is the division x / y . See (/) for details.

val rem : int -> int -> int

rem x y is the remainder x mod y . See (mod) for details.

val succ : int -> int

succ x is add x 1 .

val pred : int -> int

pred x is sub x 1 .

val abs : int -> int

abs x is the absolute value of x . That is x if x is positive and neg x if x is  negative.
Warning. This may be negative if the argument is Int.min_int .

val max_int : int

max_int is the greatest representable integer, 2{^[Sys.int_size - 1]} - 1 .

val min_int : int

min_int is the smallest representable integer, -2{^[Sys.int_size - 1]} .

val logand : int -> int -> int

logand x y is the bitwise logical and of x and y .

val logor : int -> int -> int

logor x y is the bitwise logical or of x and y .

val logxor : int -> int -> int

logxor x y is the bitwise logical exclusive or of x and y .

val lognot : int -> int

lognot x is the bitwise logical negation of x .

val shift_left : int -> int -> int

shift_left  x  n shifts x to the left by n bits. The result is unspecified if n < 0 or n >
Sys.int_size .

val shift_right : int -> int -> int

shift_right x n shifts x to the right by n bits. This is an arithmetic shift: the sign bit
of x is replicated and inserted in the vacated bits. The result is unspecified if n < 0 or
n > Sys.int_size .

val shift_right_logical : int -> int -> int

shift_right x n shifts x to the right by n bits. This  is  a  logical  shift:  zeroes  are
inserted  in the vacated bits regardless of the sign of x . The result is unspecified if n
< 0 or n > Sys.int_size .

Predicates and comparisons
val equal : int -> int -> bool

equal x y is true iff x = y .

val compare : int -> int -> int

compare x y is compare x y but more efficient.

Converting
val to_float : int -> float

to_float x is x as a floating point number.

val of_float : float -> int

of_float x truncates x to an integer. The result is unspecified if the argument is nan  or
falls outside the range of representable integers.

val to_string : int -> string

to_string x is the written representation of x in decimal.
```