Модуль 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-битные целые числа.

Since 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-битные целые числа.

Since 4.08

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.

Since 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 вместо возбуждения исключения.

Since 4.05

val to_string : int32 -> string

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

val bits_of_float : float -> int32

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

val float_of_bits : int32 -> float

Возвращает число с плавающей запятой, внутреннее представление которого согласно расположению битов формата с плавающей запятой 'single' 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-битные целые числа.

Since 4.08

val equal : t -> t -> bool

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

Since 4.03

val min : t -> t -> t

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

Since 4.13

val max : t -> t -> t

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

Since 4.13

val seeded_hash : int -> t -> int

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

Since 5.1

val hash : t -> int

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

Since 5.1