Модуль Int32

module Int32: sig .. end

32-битные целые числа.

Этот модуль предоставляет операции над типом int32 знаковыми 32-битными целыми числами. В отличие от встроенного типа int, тип int32 гарантированно имеет ширину ровно 32 бита на всех платформах. Все арифметические операции над int32 выполняются по модулю 2³².

Примечание по производительности: значения типа int32 занимают больше места в памяти, чем значения типа int, и арифметические операции над int32 обычно медленнее, чем над int. Используйте int32 только в том случае, если приложение требует точной 32-битной арифметики.

Литералы для 32-битных целых чисел имеют суффикс l:

      let zero: int32 = 0l
      let one: int32 = 1l
      let m_one: int32 = -1l

val zero : int32

32-битное целое число 0.

val one : int32

32-битное целое число 1.

val minus_one : int32

32-битное целое число -1.

val neg : int32 -> int32

Унарное отрицание.

val add : int32 -> int32 -> int32

Сложение.

val sub : int32 -> int32 -> int32

Вычитание.

val mul : int32 -> int32 -> int32

Умножение.

val div : int32 -> int32 -> int32

Целочисленное деление. Это деление округляет действительное частное своих аргументов к нулю, как указано для (/).

Возбуждает Division_by_zero если второй аргумент равен нулю.

val unsigned_div : int32 -> int32 -> int32

То же, что и Int32.div, за исключением того, что аргументы и результат интерпретируются как беззнаковые 32-битные целые числа.

С тех пор как 4.08.0

val rem : int32 -> int32 -> int32

Целочисленный остаток. Если y не равен нулю, результат Int32.rem x y удовлетворяет следующему свойству: x = Int32.add (Int32.mul (Int32.div x y) y) (Int32.rem x y). Если y = 0, Int32.rem x y вызывает Division_by_zero.

val unsigned_rem : int32 -> int32 -> int32

То же, что и Int32.rem, за исключением того, что аргументы и результат интерпретируются как беззнаковые 32-битные целые числа.

С тех пор как 4.08.0

val succ : int32 -> int32

Преемник. Int32.succ x это Int32.add x Int32.one.

val pred : int32 -> int32

Предшественник. Int32.pred x это Int32.sub x Int32.one.

val abs : int32 -> int32

abs x — абсолютное значение x. На min_int это min_int само по себе и, следовательно, остается отрицательным.

val max_int : int32

Наибольшее представимое 32-битное целое число, 2³¹ - 1.

val min_int : int32

Наименьшее представимое 32-битное целое число, -2³¹.

val logand : int32 -> int32 -> int32

Побитовое логическое И.

val logor : int32 -> int32 -> int32

Побитовое логическое ИЛИ.

val logxor : int32 -> int32 -> int32

Побитовое логическое исключающее ИЛИ.

val lognot : int32 -> int32

Побитовое логическое отрицание.

val shift_left : int32 -> int -> int32

Int32.shift_left x y сдвигает x влево на y бит. Результат не определён, если y < 0 или y >= 32.

val shift_right : int32 -> int -> int32

Int32.shift_right x y сдвигает x вправо на y бит. Это арифметический сдвиг: бит знака x дублируется и вставляется в освободившиеся биты. Результат не определён, если y < 0 или y >= 32.

val shift_right_logical : int32 -> int -> int32

Int32.shift_right_logical x y сдвигает x вправо на y бит. Это логический сдвиг: нули вставляются в освободившиеся биты независимо от знака x . Результат не определён, если y < 0 или y >= 32.

val of_int : int -> int32

Преобразует данное целое число (тип int) в 32-битное целое число (тип int32). На 64-битных платформах аргумент берётся по модулю 2³².

val to_int : int32 -> int

Преобразует данное 32-битное целое число (тип int32) в целое число (тип int). На 32-битных платформах 32-битное целое число берется по модулю 2³¹, то есть старший бит теряется при преобразовании. На 64-битных платформах преобразование точное.

val unsigned_to_int : int32 -> int option

То же, что и Int32.to_int, но интерпретирует аргумент как беззнаковое целое число. Возвращает None если беззнаковое значение аргумента не помещается в int.

С тех пор как 4.08.0

val of_float : float -> int32

Преобразует данное число с плавающей точкой в 32-битное целое число, отбрасывая дробную часть (округление к 0). Если полученное целое число находится вне диапазона [Int32.min_int, Int32.max_int], исключение не генерируется, и возвращается неопределённое, зависящее от платформы, целое число.

val to_float : int32 -> float

Преобразует данное 32-битное целое число в число с плавающей точкой.

val of_string : string -> int32

Преобразует данную строку в 32-битное целое число. Строка читается в десятичном формате (по умолчанию, или если строка начинается с 0u) или в шестнадцатеричном, восьмеричном или двоичном формате, если строка начинается с 0x, 0o или 0b соответственно.

Префикс 0u читает входное значение как беззнаковое целое число в диапазоне [0, 2*Int32.max_int+1]. Если входное значение превышает Int32.max_int, оно преобразуется в знаковое целое число Int32.min_int + input - Int32.max_int - 1.

Символ _ (подчеркивание) может встречаться в строке где угодно и игнорируется.

Возбуждает Failure если заданная строка не является допустимым представлением целого числа или если представленное целое число выходит за пределы диапазона целых чисел, представимых в типе int32.

val of_string_opt : string -> int32 option

То же, что и of_string, но возвращает None вместо возбуждения исключения.

С тех пор как 4.05

val to_string : int32 -> string

Возвращает строковое представление своего аргумента в знаковом десятичном формате.

val bits_of_float : float -> int32

Возвращает внутреннее представление данного числа с плавающей точкой в соответствии с битовым представлением «формата с плавающей точкой одиночной точности» IEEE 754. Бит 31 результата представляет знак числа с плавающей точкой; биты с 30 по 23 представляют (смещённый) экспоненту; биты с 22 по 0 представляют мантиссу.

val float_of_bits : int32 -> float

Возвращает число с плавающей точкой, внутреннее представление которого, в соответствии с битовым представлением «формата с плавающей точкой одиночной точности» IEEE 754, — данное int32.

type t = int32

Псевдоним для типа 32-битных целых чисел.

val compare : t -> t -> int

Функция сравнения для 32-битных целых чисел с тем же спецификацией, что и compare. Вместе с типом t, эта функция compare позволяет модулю Int32 передаваться как аргумент функторам Set.Make и Map.Make.

val unsigned_compare : t -> t -> int

То же, что и Int32.compare, за исключением того, что аргументы интерпретируются как беззнаковые 32-битные целые числа.

С тех пор как 4.08.0

val equal : t -> t -> bool

Функция равенства для int32.

С тех пор как 4.03.0

val min : t -> t -> t

Возвращает меньшее из двух аргументов.

С тех пор как 4.13.0

val max : t -> t -> t

Возвращает большее из двух аргументов.

С тех пор как 4.13.0