模組 Targetint

module Targetint: sig .. end

目標處理器原生整數。

此模組提供針對有號 32 位元整數（在 32 位元目標平台上）或有號 64 位元整數（在 64 位元目標平台上）的操作。此整數類型與 C 編譯器中指標類型的寬度完全相同。所有算術運算均以 232 或 264 為模數，具體取決於目標架構的字組大小。

警告：此模組不穩定，是 compiler-libs 的一部分。

type t

目標整數的類型。

val zero : t

目標整數 0。

val one : t

目標整數 1。

val minus_one : t

目標整數 -1。

val neg : t -> t

一元負號。

val add : t -> t -> t

加法。

val sub : t -> t -> t

減法。

val mul : t -> t -> t

乘法。

val div : t -> t -> t

整數除法。若第二個參數為零，則引發 Division_by_zero。此除法會將其引數的實數商朝零捨入，如同 Stdlib.(/) 所指定。

val unsigned_div : t -> t -> t

與 Targetint.div 相同，不同之處在於引數和結果被解釋為無號整數。

val rem : t -> t -> t

整數餘數。若 y 不為零，則 Targetint.rem x y 的結果滿足下列屬性：Targetint.zero <= Nativeint.rem x y < Targetint.abs y 且 x = Targetint.add (Targetint.mul (Targetint.div x y) y)
                      (Targetint.rem x y)。若 y = 0，則 Targetint.rem x y 引發 Division_by_zero。

val unsigned_rem : t -> t -> t

與 Targetint.rem 相同，不同之處在於引數和結果被解釋為無號整數。

val succ : t -> t

後繼值。Targetint.succ x 為 Targetint.add x Targetint.one。

val pred : t -> t

前導值。Targetint.pred x 為 Targetint.sub x Targetint.one。

val abs : t -> t

abs x 是 x 的絕對值。在 min_int 上，此值為 min_int 本身，因此仍為負數。

val size : int

目標原生整數的大小（以位元為單位）。

val max_int : t

最大可表示的目標整數，在 32 位元平台上為 231 - 1，在 64 位元平台上為 263 - 1。

val min_int : t

最小可表示的目標整數，在 32 位元平台上為 -231，在 64 位元平台上為 -263。

val logand : t -> t -> t

位元邏輯 AND。

val logor : t -> t -> t

位元邏輯 OR。

val logxor : t -> t -> t

位元邏輯 XOR。

val lognot : t -> t

位元邏輯 NOT。

val shift_left : t -> int -> t

Targetint.shift_left x y 將 x 向左位移 y 個位元。若 y < 0 或 y >= bitsize，則結果未指定，其中 bitsize 在 32 位元平台上為 32，在 64 位元平台上為 64。

val shift_right : t -> int -> t

Targetint.shift_right x y 將 x 向右位移 y 個位元。這是算術位移：x 的正負號位元會被複製並插入到空出的位元中。若 y < 0 或 y >= bitsize，則結果未指定。

val shift_right_logical : t -> int -> t

Targetint.shift_right_logical x y 將 x 向右位移 y 個位元。這是邏輯位移：無論 x 的正負號為何，都會在空出的位元中插入零。若 y < 0 或 y >= bitsize，則結果未指定。

val of_int : int -> t

將給定的整數（類型 int）轉換為目標整數（類型 t），以目標字組大小為模數。

val of_int_exn : int -> t

將給定的整數（類型 int）轉換為目標整數（類型 t）。若轉換不精確，則會引發嚴重錯誤。

val to_int : t -> int

將給定的目標整數（類型 t）轉換為整數（類型 int）。轉換期間會遺失高位位元。

val of_float : float -> t

將給定的浮點數轉換為目標整數，捨棄小數部分（向 0 截斷）。若截斷後數字超出範圍 [Targetint.min_int, Targetint.max_int]，則轉換的結果未定義。

val to_float : t -> float

將給定的目標整數轉換為浮點數。

val of_int32 : int32 -> t

將給定的 32 位元整數（類型 int32）轉換為目標整數。

val to_int32 : t -> int32

將給定的目標整數轉換為 32 位元整數（類型 int32）。在 64 位元平台上，64 位元原生整數以 232 為模數，即遺失前 32 位元。在 32 位元平台上，轉換是精確的。

val of_int64 : int64 -> t

將給定的 64 位元整數（類型 int64）轉換為目標整數。

val to_int64 : t -> int64

將給定的目標整數轉換為 64 位元整數（類型 int64）。

val of_string : string -> t

將給定的字串轉換為目標整數。字串預設以十進位讀取，若字串分別以 0x、0o 或 0b 開頭，則以十六進位、八進位或二進位讀取。若給定的字串不是整數的有效表示法，或者所表示的整數超出類型 nativeint 中可表示的整數範圍，則會引發 Failure "int_of_string"。

val to_string : t -> string

以十進位傳回其引數的字串表示法。

val compare : t -> t -> int

目標整數的比較函式，規格與 Stdlib.compare 相同。連同類型 t，此函式 compare 允許將模組 Targetint 作為引數傳遞給函子 Set.Make 和 Map.Make。

val unsigned_compare : t -> t -> int

與 Targetint.compare 相同，不同之處在於引數被解釋為無號整數。

val equal : t -> t -> bool

目標整數的相等函式。

type repr =
| Int32 of int32
| Int64 of int64 
val repr : t -> repr

原生整數的具體表示法。

val print : Format.formatter -> t -> unit

將目標整數列印到格式化器。