module Targetint:sig..end
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.
type t
val zero : tval one : tval minus_one : tval neg : t -> tval add : t -> t -> tval sub : t -> t -> tval mul : t -> t -> tval div : t -> t -> tDivision_by_zero if the second
argument is zero. This division rounds the real quotient of
its arguments towards zero, as specified for (/).val rem : t -> t -> ty 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.val succ : t -> tTargetint.succ x is Targetint.add x Targetint.one.val pred : t -> tTargetint.pred x is Targetint.sub x Targetint.one.val abs : t -> tval size : intval max_int : tval min_int : tval logand : t -> t -> tval logor : t -> t -> tval logxor : t -> t -> tval lognot : t -> tval shift_left : t -> int -> tTargetint.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.val shift_right : t -> int -> tTargetint.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.val shift_right_logical : t -> int -> tTargetint.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 -> tint) to a target integer
(type t), module the target word size.val of_int_exn : int -> tint) to a target integer
(type t). Raises a fatal error if the conversion is not exact.val to_int : t -> intt) to an
integer (type int). The high-order bit is lost during
the conversion.val of_float : float -> tTargetint.min_int, Targetint.max_int].val to_float : t -> floatval of_int32 : int32 -> tint32)
to a target integer.val to_int32 : t -> int32int32). 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 -> tint64)
to a target integer.val to_int64 : t -> int64int64).val of_string : string -> t0x, 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 -> stringval compare : t -> t -> intcompare. 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.val equal : t -> t -> booltype repr =
| |
Int32 of |
| |
Int64 of |
val repr : t -> repr