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

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.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.0

val of_float : float -> int64

Преобразует данное число с плавающей точкой в 64-битное целое число, отбрасывая дробную часть (обрезание к 0). Если усеченное число с плавающей точкой находится вне диапазона [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

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

val float_of_bits : int64 -> float

Возвращает число с плавающей точкой, внутреннее представление которого в соответствии с битовой структурой «двойного формата» числа с плавающей точкой 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.0

val equal : t -> t -> bool

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

С тех пор как 4.03.0

val min : t -> t -> t

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

С тех пор как 4.13.0

val max : t -> t -> t

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

С тех пор как 4.13.0