Targetint
Target processor-native integers.
This module provides operations on the type of signed 32-bit integers (on 32-bit target platforms) or signed 64-bit integers (on 64-bit target platforms). This integer type has exactly the same width as that of a pointer type in the C compiler. All arithmetic operations over are taken modulo 232 or 264 depending on the word size of the target architecture.
Warning: this module is unstable and part of compiler-libs.
val zero : t
The target integer 0.
val one : t
The target integer 1.
val minus_one : t
The target integer -1.
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 Stdlib.(/)
.
Same as div
, except that arguments and result are interpreted as unsigned integers.
Integer remainder. If y
is not zero, the result of Targetint.rem x y
satisfies the following properties: Targetint.zero <= Nativeint.rem x y < Targetint.abs y
and x = Targetint.add (Targetint.mul (Targetint.div x y) y)
(Targetint.rem x y)
. If y = 0
, Targetint.rem x y
raises Division_by_zero
.
Same as rem
, except that arguments and result are interpreted as unsigned integers.
val max_int : t
The greatest representable target integer, either 231 - 1 on a 32-bit platform, or 263 - 1 on a 64-bit platform.
val min_int : t
The smallest representable target integer, either -231 on a 32-bit platform, or -263 on a 64-bit platform.
Targetint.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.
Targetint.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
.
Targetint.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
.
val of_int : int -> t
Convert the given integer (type int
) to a target integer (type t
), module the target word size.
val of_int_exn : int -> t
Convert the given integer (type int
) to a target integer (type t
). Raises a fatal error if the conversion is not exact.
val to_int : t -> int
Convert the given target integer (type t
) to an integer (type int
). The high-order bit is lost during the conversion.
val of_float : float -> t
Convert the given floating-point number to a target integer, discarding the fractional part (truncate towards 0). The result of the conversion is undefined if, after truncation, the number is outside the range [Targetint.min_int
, Targetint.max_int
].
val to_float : t -> float
Convert the given target integer to a floating-point number.
val of_int32 : int32 -> t
Convert the given 32-bit integer (type int32
) to a target integer.
val to_int32 : t -> int32
Convert the given target 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.
val of_int64 : int64 -> t
Convert the given 64-bit integer (type int64
) to a target integer.
val to_int64 : t -> int64
Convert the given target integer to a 64-bit integer (type int64
).
val of_string : string -> t
Convert the given string to a target 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 nativeint
.
val to_string : t -> string
Return the string representation of its argument, in decimal.
The comparison function for target integers, with the same specification as Stdlib.compare
. Along with the type t
, this function compare
allows the module Targetint
to be passed as argument to the functors Set
.Make and Map
.Make.
Same as compare
, except that arguments are interpreted as unsigned integers.
val print : Format.formatter -> t -> unit
Print a target integer to a formatter.