Module CCInt

Basic Int functions

include module type of CCShimsInt_

Documentation for the standard Int module

include Stdlib.Int
type t = int
val zero : int
val one : int
val minus_one : int
val neg : int -> int
val add : int -> int -> int
val sub : int -> int -> int
val mul : int -> int -> int
val div : int -> int -> int
val rem : int -> int -> int
val succ : int -> int
val pred : int -> int
val abs : int -> int
val max_int : int
val min_int : int
val logand : int -> int -> int
val logor : int -> int -> int
val logxor : int -> int -> int
val lognot : int -> int
val shift_left : int -> int -> int
val shift_right : int -> int -> int
val shift_right_logical : int -> int -> int
val equal : int -> int -> bool
val compare : int -> int -> int
val to_float : int -> float
val of_float : float -> int
val to_string : int -> string
type t = int
val zero : t

zero is the integer 0.

since
3.0
val one : t

one is the integer 1.

since
3.0
val minus_one : t

minus_one is the integer -1.

since
3.0
val add : t -> t -> t

add x y is x + y.

since
3.0
val sub : t -> t -> t

sub x y is x - y.

since
3.0
val mul : t -> t -> t

mul x y is x * y.

since
3.0
val div : t -> t -> t

div x y is x / y

since
3.0
val succ : t -> t

succ x is x + 1.

since
3.0
val pred : t -> t

pred x is x - 1.

since
3.0
val abs : t -> t

abs x is the absolute value of x. It is x if x is positive and neg x otherwise.

since
3.0
val max_int : t

max_int is the maximum integer.

since
3.0
val min_int : t

min_int is the minimum integer.

since
3.0
val compare : t -> t -> int

compare x y is the comparison function for integers with the same specification as Stdlib.compare.

val equal : t -> t -> bool

equal x y is true iff x and y are equal. Equality function for integers.

val hash : t -> int

hash x computes the hash of x.

val sign : t -> int

sign x return 0 if x = 0, -1 if x < 0 and 1 if x > 0. Same as compare x 0.

val neg : t -> t

neg x is - x. Unary negation.

since
0.5
val pow : t -> t -> t

pow base exponent returns base raised to the power of exponent. pow x y = x^y for positive integers x and y. Raises Invalid_argument if x = y = 0 or y < 0.

since
0.11
val floor_div : t -> t -> t

floor_div x n is integer division rounding towards negative infinity. It satisfies x = m * floor_div x n + rem x n.

since
1.2
val rem : t -> t -> t

rem x n is the remainder of dividing x by n, with the same sign as n.

since
1.2
type 'a printer = Stdlib.Format.formatter -> 'a -> unit
type 'a random_gen = Stdlib.Random.State.t -> 'a
type 'a iter = ('a -> unit) -> unit
val random : int -> t random_gen
val random_small : t random_gen
val random_range : int -> int -> t random_gen
val pp : t printer

pp ppf x prints the integer x on ppf.

val to_float : t -> float

to_float is the same as float_of_int

since
3.0
val of_float : float -> t

to_float is the same as int_of_float

since
3.0
val to_string : t -> string

to_string x returns the string representation of the integer x, in signed decimal.

since
0.13
val of_string : string -> t option

of_string s converts the given string s into an integer. Safe version of of_string_exn.

since
0.13
val of_string_exn : string -> t

of_string_exn s converts the given string s to an integer. Alias to int_of_string.

raises Failure

in case of failure.

since
3.0
val of_float : float -> t

of_float x converts the given floating-point number x to an integer. Alias to int_of_float.

since
3.0
val pp_binary : t printer

pp_binary ppf x prints x on ppf. Print as "0b00101010".

since
0.20
val to_string_binary : t -> string

to_string_binary x returns the string representation of the integer x, in binary.

since
0.20
val min : t -> t -> t

min x y returns the minimum of the two integers x and y.

since
0.17
val max : t -> t -> t

max x y returns the maximum of the two integers x and y.

since
0.17
val range_by : step:t -> t -> t -> t iter

range_by ~step i j iterates on integers from i to j included, where the difference between successive elements is step. Use a negative step for a decreasing list.

raises Invalid_argument

if step=0.

since
1.2
val range : t -> t -> t iter

range i j iterates on integers from i to j included . It works both for decreasing and increasing ranges.

since
1.2
val range' : t -> t -> t iter

range' i j is like range but the second bound j is excluded. For instance range' 0 5 = Iter.of_list [0;1;2;3;4].

since
1.2
val popcount : t -> int

Number of bits set to 1

since
3.0
val logand : t -> t -> t

logand is the same as (land).

since
3.0
val logor : t -> t -> t

logand is the same as (lor).

since
3.0
val logxor : t -> t -> t

logxor is the same as (lxor).

since
3.0
val lognot : t -> t

logand is the same as lnot.

since
3.0
val shift_left : t -> int -> t

shift_left is the same as (lsl).

since
3.0
val shift_right : t -> int -> t

shift_right is the same as (asr).

since
3.0
val shift_right_logical : t -> int -> t

shift_right_logical is the same as (lsr).

since
3.0

Infix Operators

since
0.17
module Infix : sig ... end
include module type of Infix
val (=) : t -> t -> bool
since
0.17
val (<>) : t -> t -> bool
since
0.17
val (<) : t -> t -> bool
since
0.17
val (>) : t -> t -> bool
since
0.17
val (<=) : t -> t -> bool
since
0.17
val (>=) : t -> t -> bool
since
0.17
val (--) : t -> t -> t iter

Alias to range.

since
1.2
val (--^) : t -> t -> t iter

Alias to range'.

since
1.2
val (+) : t -> t -> t
since
2.1
val (-) : t -> t -> t
since
2.1
val (~-) : t -> t
since
2.1
val (*) : t -> t -> t
since
2.1
val (/) : t -> t -> t
since
2.1
val (**) : t -> t -> t
since
2.4
val (mod) : t -> t -> t
since
2.1
val (land) : t -> t -> t
since
2.1
val (lor) : t -> t -> t
since
2.1
val (lxor) : t -> t -> t
since
2.1
val (lnot) : t -> t
since
2.1
val (lsl) : t -> int -> t
since
2.1
val (lsr) : t -> int -> t
since
2.1
val (asr) : t -> int -> t
since
2.1