Модуль Int64

module Int64: sig .. end

64-разрядные целые числа.

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

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

Литералы 64-разрядных целых чисел оканчиваются на L:

      let zero: int64 = 0L
      let one: int64 = 1L
      let m_one: int64 = -1L

val zero : int64

64-разрядное целое число 0.

val one : int64

64-разрядное целое число 1.

val minus_one : int64

64-разрядное целое число -1.

val neg : int64 -> int64

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

val add : int64 -> int64 -> int64

Сложение.

val sub : int64 -> int64 -> int64

Вычитание.

val mul : int64 -> int64 -> int64

Умножение.

val div : int64 -> int64 -> int64

Целочисленное деление.

Вызывает исключение Division_by_zero, если второй аргумент равен нулю. При этом делении действительное частное аргументов округляется к нулю, как указано для (/).

val unsigned_div : int64 -> int64 -> int64

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

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

val rem : int64 -> int64 -> int64

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

val unsigned_rem : int64 -> int64 -> int64

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

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

val fdiv : int64 -> int64 -> int64

Деление с округлением вниз. 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 : int64 -> int64 -> int64

Деление с округлением вверх. 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 : int64 -> int64 -> int64

Евклидово деление. 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 : int64 -> int64 -> int64

Евклидов остаток. Если 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 : int64 -> int64

Преемник. Int64.succ x равен Int64.add x Int64.one.

val pred : int64 -> int64

Предшественник. Int64.pred x равен Int64.sub x Int64.one.

val abs : int64 -> int64

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

val max_int : int64

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

val min_int : int64

Наименьшее представимое 64-разрядное целое число, -2⁶³.

val logand : int64 -> int64 -> int64

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

val logor : int64 -> int64 -> int64

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

val logxor : int64 -> int64 -> int64

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

val lognot : int64 -> int64

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

val shift_left : int64 -> int -> int64

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

val shift_right : int64 -> int -> int64

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

val shift_right_logical : int64 -> int -> int64

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

val of_int : int -> int64

Преобразовать заданное целое число (тип int) в 64-разрядное целое число (тип int64).

val to_int : int64 -> int

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

val unsigned_to_int : int64 -> int option

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

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

val of_float : float -> int64

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

val to_float : int64 -> float

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

val of_int32 : int32 -> int64

Преобразовать заданное 32-разрядное целое число (тип int32) в 64-разрядное целое число (тип int64).

val to_int32 : int64 -> int32

Преобразовать заданное 64-разрядное целое число (тип int64) в 32-разрядное целое число (тип int32). 64-разрядное целое число берётся по модулю 2³², то есть при преобразовании теряются 32 старших бита.

val of_nativeint : nativeint -> int64

Преобразовать заданное машинное целое число (тип nativeint) в 64-разрядное целое число (тип int64).

val to_nativeint : int64 -> nativeint

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

val of_string : string -> int64

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

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

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

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

val of_string_opt : string -> int64 option

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

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

val to_string : int64 -> string

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

val bits_of_float : float -> int64

Вернуть внутреннее представление заданного числа с плавающей точкой в соответствии с расположением битов формата «double» IEEE 754. Бит 63 результата обозначает знак числа с плавающей точкой; биты с 62 по 52 — смещённый порядок; биты с 51 по 0 — мантиссу.

val float_of_bits : int64 -> float

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

type t = int64

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

val compare : t -> t -> int

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

val unsigned_compare : t -> t -> int

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

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

val equal : t -> t -> bool

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

Начиная с версии 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 до 64 включительно, для которого выполняется 0 <= n < 2{^i} (беззнаковое).

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

val signed_bitsize : t -> int

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

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

val leading_zeros : t -> int

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

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

val leading_sign_bits : t -> int

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

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

val trailing_zeros : t -> int

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

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

val seeded_hash : int -> t -> int

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

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

val hash : t -> int

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

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