containers
Library
Module
Module type
Parameter
Class
Class type
include module type of struct include Nativeint end
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.(/)
.
Integer remainder. If y
is not zero, the result of Nativeint.rem x y
satisfies the following properties: Nativeint.zero <= Nativeint.rem x y < Nativeint.abs y
and x = Nativeint.add (Nativeint.mul (Nativeint.div x y) y)
(Nativeint.rem x y)
. If y = 0
, Nativeint.rem x y
raises Division_by_zero
.
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.
The greatest representable native integer, either 231 - 1 on a 32-bit platform, or 263 - 1 on a 64-bit platform.
The smallest representable native integer, either -231 on a 32-bit platform, or -263 on a 64-bit platform.
Nativeint.shift_left x y
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.
Nativeint.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 >= bitsize
.
Nativeint.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 >= bitsize
.
Convert the given integer (type int
) to a native integer (type nativeint
).
Convert the given native integer (type nativeint
) to an integer (type int
). The high-order bit is lost during the conversion.
Convert the given floating-point number to a native integer, discarding the fractional part (truncate towards 0). The result of the conversion is undefined if, after truncation, the number is outside the range [Nativeint.min_int
, Nativeint.max_int
].
Convert the given native integer to a 32-bit integer (type int32
). On 64-bit platforms, the 64-bit native integer is taken modulo 232, i.e. the top 32 bits are lost. On 32-bit platforms, the conversion is exact.
The comparison function for native integers, with the same specification as Pervasives.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
.
val hash : t -> int
hash x
computes the hash of x
. Like Stdlib
.abs(to_intx).
val sign : t -> int
sign x
return 0
if x = 0
, -1
if x < 0
and 1
if x > 0
. Same as compare x zero
.
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.
floor_div x n
is integer division rounding towards negative infinity. It satisfies x = m * floor_div x n + rem x n
.
type 'a printer = Format.formatter -> 'a -> unit
type 'a random_gen = Random.State.t -> 'a
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.
range i j
iterates on integers from i
to j
included . It works both for decreasing and increasing ranges.
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]
.
val random : t -> t random_gen
val random_small : t random_gen
val random_range : t -> t -> t random_gen
Conversion
val of_string : string -> t option
of_string s
is the safe version of of_string_exn
. Like of_string_exn
, but return None
instead of raising.
val of_string_exn : string -> t
of_string_exn s
converts the given string s
into a native integer. Alias to Nativeint.of_string
. 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*CCNativeint.max_int+1]
. If the input exceeds CCNativeint.max_int
it is converted to the signed integer CCInt64.min_int + input - CCNativeint.max_int - 1
.
Raise Failure "Nativeint.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 nativeint
.
val to_string_binary : t -> string
to_string_binary x
returns the string representation of the integer x
, in binary.
Printing
Infix Operators
module Infix : sig ... end
include module type of Infix
x / y
is the integer quotient of x
and y
. Integer division. Raise Division_by_zero
if the second argument y
is zero. This division rounds the real quotient of its arguments towards zero, as specified for Stdlib
.(/).
x mod y
is the integer remainder of x / y
. If y <> zero
, the result of x mod y
satisfies the following properties: zero <= x mod y < abs y
and x = ((x / y) * y) + (x mod y)
. If y = 0
, x mod y
raises Division_by_zero
.
x lsl y
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.
x lsr 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 >= bitsize
.
x asr 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 >= bitsize
.