Модуль 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

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

val fdiv : int32 -> int32 -> int32

Деление с округлением вниз. fdiv x y — это действительное частное x / y, округлённое вниз до целого числа. Выполняются условия fdiv x y <= div x y <= cdiv x y и cdiv x y - fdiv x y <= 1.

Начиная с версии 5.5
Вызывает исключение Division_by_zero, если второй аргумент равен 0.

val cdiv : int32 -> int32 -> int32

Деление с округлением вверх. cdiv x y — это действительное частное x / y, округлённое вверх до целого числа. Выполняются условия fdiv x y <= div x y <= cdiv x y и cdiv x y - fdiv x y <= 1.

Начиная с версии 5.5
Вызывает исключение Division_by_zero, если второй аргумент равен 0.

val ediv : int32 -> int32 -> int32

Евклидово деление. ediv x y — это действительное частное x / y, округлённое вниз до целого числа, если y > 0, и округлённое вверх до целого числа, если y < 0. Остаток erem x y = x - ediv x y * y всегда неотрицателен. Кроме того, ediv x (-y) = - ediv x y.

Начиная с версии 5.5
Вызывает исключение Division_by_zero, если второй аргумент равен 0.

val erem : int32 -> int32 -> int32

Евклидов остаток. Если y не равно нулю, выполняются условия x = ediv x y * y + erem x y и 0 <= erem x y <= abs y - 1. Результат erem x y всегда неотрицателен, в отличие от результата rem x y, знак которого совпадает со знаком x.

Начиная с версии 5.5
Вызывает исключение Division_by_zero, если второй аргумент равен 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

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

val equal : t -> t -> bool

Функция проверки равенства для значений типа int32.

Начиная с версии 4.03

val min : t -> t -> t

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

Начиная с версии 4.13

val max : t -> t -> t

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

Начиная с версии 4.13

val popcount : t -> int

Подсчёт единичных битов, также известный как вес Хэмминга. popcount n — это количество битов со значением 1 в двоичном представлении n. Отрицательные значения n представляются в дополнительном коде.

Начиная с версии 5.5

val unsigned_bitsize : t -> int

unsigned_bitsize n — минимальное количество битов, необходимое для представления n в виде беззнакового двоичного числа. Это наименьшее целое число i от 0 до 32 включительно, для которого выполняется 0 <= n < 2{^i} (беззнаковое).

Начиная с версии 5.5

val signed_bitsize : t -> int

signed_bitsize n — минимальное количество битов, необходимое для представления n в виде знакового двоичного числа в дополнительном коде. Это наименьшее целое число i от 1 до 32 включительно, для которого выполняется -2{^i-1} <= n < 2{^i-1} (знаковое).

Начиная с версии 5.5

val leading_zeros : t -> int

leading_zeros n — количество ведущих (старших) нулевых битов в двоичном представлении n. Это целое число от 0 до 32 включительно. Если n отрицательно, leading_zeros n = 0, поскольку старший бит n равен 1. leading_zeros n = 32 тогда и только тогда, когда n = zero. Обратите внимание, что leading_zeros n + unsigned_bitsize n = 32.

Начиная с версии 5.5

val leading_sign_bits : t -> int

leading_sign_bits n — количество ведущих (старших) знаковых битов в двоичном представлении n, не считая самого знакового бита. Это целое число от 0 до 31 включительно. Для положительных значений n оно равно количеству ведущих нулевых битов минус один. Для отрицательных значений n оно равно количеству ведущих единичных битов минус один. Обратите внимание, что leading_sign_bits n + signed_bitsize n = 32.

Начиная с версии 5.5

val trailing_zeros : t -> int

trailing_zeros n — количество конечных (младших) нулевых битов в двоичном представлении n. Это целое число от 0 до 32 включительно. Это наибольшее целое число i <= 32, такое что 2{^i} делит n без остатка. Например, trailing_zeros n = 0 тогда и только тогда, когда n нечётно, а trailing_zeros n = 32 тогда и только тогда, когда n = zero.

Начиная с версии 5.5

val seeded_hash : int -> t -> int

Функция хеширования с начальным значением для 32-разрядных целых чисел, возвращающая то же значение, что и Hashtbl.seeded_hash. Эта функция позволяет передавать данный модуль в качестве аргумента функтору Hashtbl.MakeSeeded.

Начиная с версии 5.1

val hash : t -> int

Функция хеширования без начального значения для 32-разрядных целых чисел, возвращающая то же значение, что и Hashtbl.hash. Эта функция позволяет передавать данный модуль в качестве аргумента функтору Hashtbl.Make.

Начиная с версии 5.1