Примитивный тип i64

64-битное целое число со знаком.

Константы

КонстантаЗначениеОписаниеВерсияПример
MIN-9_223_372_036_854_775_808i64Наименьшее значение, которое может быть представлено этим целочисленным типом (−2^63).1.43.0assert_eq!(i64::MIN, -9223372036854775808);
MAX9_223_372_036_854_775_807i64Наибольшее значение, которое может быть представлено этим целочисленным типом (2^63 − 1).1.43.0assert_eq!(i64::MAX, 9223372036854775807);
BITS64u32Размер этого целочисленного типа в битах.1.53.0assert_eq!(i64::BITS, 64);

Методы

Битовая манипуляция и представление

МетодОписаниеКонстантностьВерсияПример
count_ones(self) -> u32Возвращает количество единиц в двоичном представлении self.1.32.01.0.0let n = 0b100_0000i64; assert_eq!(n.count_ones(), 1);
count_zeros(self) -> u32Возвращает количество нулей в двоичном представлении self.1.32.01.0.0assert_eq!(i64::MAX.count_zeros(), 1);
leading_zeros(self) -> u32Возвращает количество ведущих нулей в двоичном представлении self.1.32.01.0.0let n = -1i64; assert_eq!(n.leading_zeros(), 0);
trailing_zeros(self) -> u32Возвращает количество завершающих нулей в двоичном представлении self.1.32.01.0.0let n = -4i64; assert_eq!(n.trailing_zeros(), 2);
leading_ones(self) -> u32Возвращает количество ведущих единиц в двоичном представлении self.1.46.01.46.0let n = -1i64; assert_eq!(n.leading_ones(), 64);
trailing_ones(self) -> u32Возвращает количество завершающих единиц в двоичном представлении self.1.46.01.46.0let n = 3i64; assert_eq!(n.trailing_ones(), 2);
isolate_highest_one(self) -> i64Возвращает self с установленным только самым старшим битом, или 0, если вход равен 0. (экспериментальный)-Nightlylet n: i64 = 0b_01100100; assert_eq!(n.isolate_highest_one(), 0b_01000000);
isolate_lowest_one(self) -> i64Возвращает self с установленным только самым младшим битом, или 0, если вход равен 0. (экспериментальный)-Nightlylet n: i64 = 0b_01100100; assert_eq!(n.isolate_lowest_one(), 0b_00000100);
highest_one(self) -> Option<u32>Возвращает индекс самого старшего бита, установленного в единицу, или None, если self равен 0. (экспериментальный)-Nightlyassert_eq!(0b1_0000_i64.highest_one(), Some(4));
lowest_one(self) -> Option<u32>Возвращает индекс самого младшего бита, установленного в единицу, или None, если self равен 0. (экспериментальный)-Nightlyassert_eq!(0b1_0000_i64.lowest_one(), Some(4));
cast_unsigned(self) -> u64Возвращает битовый шаблон self, переинтерпретированный как целое число без знака того же размера.1.87.01.87.0let n = -1i64; assert_eq!(n.cast_unsigned(), u64::MAX);
rotate_left(self, n: u32) -> i64Сдвигает биты влево на указанное количество n, перенося усечённые биты в конец результирующего целого числа.1.32.01.0.0let n = 0xaa00000000006e1i64; let m = 0x6e10aa; assert_eq!(n.rotate_left(12), m);
rotate_right(self, n: u32) -> i64Сдвигает биты вправо на указанное количество n, перенося усечённые биты в начало результирующего целого числа.1.32.01.0.0let n = 0x6e10aai64; let m = 0xaa00000000006e1; assert_eq!(n.rotate_right(12), m);
swap_bytes(self) -> i64Обращает порядок байтов целого числа.1.32.01.0.0let n = 0x1234567890123456i64; assert_eq!(n.swap_bytes(), 0x5634129078563412);
reverse_bits(self) -> i64Обращает порядок битов в целом числе.1.37.01.37.0let n = 0x1234567890123456i64; assert_eq!(n.reverse_bits(), 0x6a2c48091e6a2c48);
from_be(x: i64) -> i64Преобразует целое число из формата big endian в порядок байтов целевой платформы.1.32.01.0.0let n = 0x1Ai64; if cfg!(target_endian = "big") { assert_eq!(i64::from_be(n), n) } else { assert_eq!(i64::from_be(n), n.swap_bytes()) }
from_le(x: i64) -> i64Преобразует целое число из формата little endian в порядок байтов целевой платформы.1.32.01.0.0let n = 0x1Ai64; if cfg!(target_endian = "little") { assert_eq!(i64::from_le(n), n) } else { assert_eq!(i64::from_le(n), n.swap_bytes()) }
to_be(self) -> i64Преобразует self в формат big endian из порядка байтов целевой платформы.1.32.01.0.0let n = 0x1Ai64; if cfg!(target_endian = "big") { assert_eq!(n.to_be(), n) } else { assert_eq!(n.to_be(), n.swap_bytes()) }
to_le(self) -> i64Преобразует self в формат little endian из порядка байтов целевой платформы.1.32.01.0.0let n = 0x1Ai64; if cfg!(target_endian = "little") { assert_eq!(n.to_le(), n) } else { assert_eq!(n.to_le(), n.swap_bytes()) }

Проверенные (Checked) арифметические операции

Возвращают Option<i64>, где None указывает на переполнение или деление на ноль.

МетодОписаниеКонстантностьВерсияПример
checked_add(self, rhs: i64) -> Option<i64>Проверенное целочисленное сложение. Вычисляет self + rhs.1.47.01.0.0assert_eq!((i64::MAX - 2).checked_add(1), Some(i64::MAX - 1));
checked_add_unsigned(self, rhs: u64) -> Option<i64>Проверенное сложение с целым числом без знака. Вычисляет self + rhs.1.66.01.66.0assert_eq!(1i64.checked_add_unsigned(2), Some(3));
checked_sub(self, rhs: i64) -> Option<i64>Проверенное целочисленное вычитание. Вычисляет self - rhs.1.47.01.0.0assert_eq!((i64::MIN + 2).checked_sub(1), Some(i64::MIN + 1));
checked_sub_unsigned(self, rhs: u64) -> Option<i64>Проверенное вычитание с целым числом без знака. Вычисляет self - rhs.1.66.01.66.0assert_eq!(1i64.checked_sub_unsigned(2), Some(-1));
checked_mul(self, rhs: i64) -> Option<i64>Проверенное целочисленное умножение. Вычисляет self * rhs.1.47.01.0.0assert_eq!(i64::MAX.checked_mul(1), Some(i64::MAX));
checked_div(self, rhs: i64) -> Option<i64>Проверенное целочисленное деление. Вычисляет self / rhs.1.52.01.0.0assert_eq!((i64::MIN + 1).checked_div(-1), Some(9223372036854775807));
checked_div_euclid(self, rhs: i64) -> Option<i64>Проверенное евклидово деление. Вычисляет self.div_euclid(rhs).1.52.01.38.0assert_eq!((i64::MIN + 1).checked_div_euclid(-1), Some(9223372036854775807));
checked_div_exact(self, rhs: i64) -> Option<i64>Проверенное целочисленное деление без остатка. Вычисляет self / rhs. (экспериментальный)-Nightlyassert_eq!((i64::MIN + 1).checked_div_exact(-1), Some(9223372036854775807));
checked_rem(self, rhs: i64) -> Option<i64>Проверенный целочисленный остаток. Вычисляет self % rhs.1.52.01.7.0assert_eq!(5i64.checked_rem(2), Some(1));
checked_rem_euclid(self, rhs: i64) -> Option<i64>Проверенный евклидов остаток. Вычисляет self.rem_euclid(rhs).1.52.01.38.0assert_eq!(5i64.checked_rem_euclid(2), Some(1));
checked_neg(self) -> Option<i64>Проверенное отрицание. Вычисляет -self.1.47.01.7.0assert_eq!(5i64.checked_neg(), Some(-5));
checked_shl(self, rhs: u32) -> Option<i64>Проверенный сдвиг влево. Вычисляет self << rhs.1.47.01.7.0assert_eq!(0x1i64.checked_shl(4), Some(0x10));
checked_shr(self, rhs: u32) -> Option<i64>Проверенный сдвиг вправо. Вычисляет self >> rhs.1.47.01.7.0assert_eq!(0x10i64.checked_shr(4), Some(0x1));
checked_abs(self) -> Option<i64>Проверенное абсолютное значение. Вычисляет self.abs().1.47.01.13.0assert_eq!((-5i64).checked_abs(), Some(5));
checked_pow(self, exp: u32) -> Option<i64>Проверенное возведение в степень. Вычисляет self.pow(exp).1.50.01.34.0assert_eq!(8i64.checked_pow(2), Some(64));
checked_isqrt(self) -> Option<i64>Возвращает квадратный корень числа, округлённый вниз. Возвращает None, если self отрицательно.1.84.01.84.0assert_eq!(10i64.checked_isqrt(), Some(3));
checked_next_multiple_of(self, rhs: i64) -> Option<i64>Если rhs положительно, вычисляет наименьшее значение, большее или равное self, кратное rhs. Если rhs отрицательно, вычисляет наибольшее значение, меньшее или равное self, кратное rhs. Возвращает None, если rhs равен нулю или операция приведёт к переполнению. (экспериментальный)-Nightlyassert_eq!(16_i64.checked_next_multiple_of(8), Some(16));
checked_ilog(self, base: i64) -> Option<u32>Возвращает логарифм числа по произвольному основанию, округлённый вниз. Возвращает None, если число отрицательно или равно нулю, или если основание меньше 2.1.67.01.67.0assert_eq!(5i64.checked_ilog(5), Some(1));
checked_ilog2(self) -> Option<u32>Возвращает логарифм числа по основанию 2, округлённый вниз. Возвращает None, если число отрицательно или равно нулю.1.67.01.67.0assert_eq!(2i64.checked_ilog2(), Some(1));
checked_ilog10(self) -> Option<u32>Возвращает логарифм числа по основанию 10, округлённый вниз. Возвращает None, если число отрицательно или равно нулю.1.67.01.67.0assert_eq!(10i64.checked_ilog10(), Some(1));

Строгие (Strict) арифметические операции

Вызывают панику при переполнении или недопустимых операциях.

МетодОписаниеКонстантностьВерсияПример
strict_add(self, rhs: i64) -> i64Строгое целочисленное сложение. Вычисляет self + rhs.1.91.01.91.0assert_eq!((i64::MAX - 2).strict_add(1), i64::MAX - 1);
strict_add_unsigned(self, rhs: u64) -> i64Строгое сложение с целым числом без знака. Вычисляет self + rhs.1.91.01.91.0assert_eq!(1i64.strict_add_unsigned(2), 3);
strict_sub(self, rhs: i64) -> i64Строгое целочисленное вычитание. Вычисляет self - rhs.1.91.01.91.0assert_eq!((i64::MIN + 2).strict_sub(1), i64::MIN + 1);
strict_sub_unsigned(self, rhs: u64) -> i64Строгое вычитание с целым числом без знака. Вычисляет self - rhs.1.91.01.91.0assert_eq!(1i64.strict_sub_unsigned(2), -1);
strict_mul(self, rhs: i64) -> i64Строгое целочисленное умножение. Вычисляет self * rhs.1.91.01.91.0assert_eq!(i64::MAX.strict_mul(1), i64::MAX);
strict_div(self, rhs: i64) -> i64Строгое целочисленное деление. Вычисляет self / rhs.1.91.01.91.0assert_eq!((i64::MIN + 1).strict_div(-1), 9223372036854775807);
strict_div_euclid(self, rhs: i64) -> i64Строгое евклидово деление. Вычисляет self.div_euclid(rhs).1.91.01.91.0assert_eq!((i64::MIN + 1).strict_div_euclid(-1), 9223372036854775807);
strict_rem(self, rhs: i64) -> i64Строгий целочисленный остаток. Вычисляет self % rhs.1.91.01.91.0assert_eq!(5i64.strict_rem(2), 1);
strict_rem_euclid(self, rhs: i64) -> i64Строгий евклидов остаток. Вычисляет self.rem_euclid(rhs).1.91.01.91.0assert_eq!(5i64.strict_rem_euclid(2), 1);
strict_neg(self) -> i64Строгое отрицание. Вычисляет -self.1.91.01.91.0assert_eq!(5i64.strict_neg(), -5);
strict_shl(self, rhs: u32) -> i64Строгий сдвиг влево. Вычисляет self << rhs.1.91.01.91.0assert_eq!(0x1i64.strict_shl(4), 0x10);
strict_shr(self, rhs: u32) -> i64Строгий сдвиг вправо. Вычисляет self >> rhs.1.91.01.91.0assert_eq!(0x10i64.strict_shr(4), 0x1);
strict_abs(self) -> i64Строгое абсолютное значение. Вычисляет self.abs().1.91.01.91.0assert_eq!((-5i64).strict_abs(), 5);
strict_pow(self, exp: u32) -> i64Строгое возведение в степень. Вычисляет self.pow(exp).1.91.01.91.0assert_eq!(8i64.strict_pow(2), 64);

Непроверенные (Unchecked) арифметические операции

Небезопасные операции, предполагающие отсутствие переполнения.

МетодОписаниеКонстантностьВерсияПример
unchecked_add(self, rhs: i64) -> i64Непроверенное целочисленное сложение. Вычисляет self + rhs.1.79.01.79.0unsafe { assert_eq!(5i64.unchecked_add(2), 7); }
unchecked_sub(self, rhs: i64) -> i64Непроверенное целочисленное вычитание. Вычисляет self - rhs.1.79.01.79.0unsafe { assert_eq!(5i64.unchecked_sub(2), 3); }
unchecked_mul(self, rhs: i64) -> i64Непроверенное целочисленное умножение. Вычисляет self * rhs.1.79.01.79.0unsafe { assert_eq!(5i64.unchecked_mul(2), 10); }
unchecked_div_exact(self, rhs: i64) -> i64Непроверенное целочисленное деление без остатка. Вычисляет self / rhs. (экспериментальный)-Nightlyunsafe { assert_eq!(64i64.unchecked_div_exact(2), 32); }
unchecked_neg(self) -> i64Непроверенное отрицание. Вычисляет -self. (экспериментальный)-Nightlyunsafe { assert_eq!(5i64.unchecked_neg(), -5); }
unchecked_shl(self, rhs: u32) -> i64Непроверенный сдвиг влево. Вычисляет self << rhs. (экспериментальный)-Nightlyunsafe { assert_eq!(0x1i64.unchecked_shl(4), 0x10); }
unchecked_shl_exact(self, rhs: u32) -> i64Непроверенный точный сдвиг влево. Вычисляет self << rhs. (экспериментальный)-Nightlyunsafe { assert_eq!(0x1i64.unchecked_shl_exact(4), 0x10); }
unchecked_shr(self, rhs: u32) -> i64Непроверенный сдвиг вправо. Вычисляет self >> rhs. (экспериментальный)-Nightlyunsafe { assert_eq!(0x10i64.unchecked_shr(4), 0x1); }
unchecked_shr_exact(self, rhs: u32) -> i64Непроверенный точный сдвиг вправо. Вычисляет self >> rhs. (экспериментальный)-Nightlyunsafe { assert_eq!(0x10i64.unchecked_shr_exact(4), 0x1); }

Насыщающая (Saturating) арифметика

Операции, которые насыщаются на границах типа вместо переполнения.

МетодОписаниеКонстантностьВерсияПример
saturating_add(self, rhs: i64) -> i64Насыщающее целочисленное сложение. Вычисляет self + rhs.1.47.01.0.0assert_eq!(100i64.saturating_add(1), 101);
saturating_add_unsigned(self, rhs: u64) -> i64Насыщающее сложение с целым числом без знака. Вычисляет self + rhs.1.66.01.66.0assert_eq!(1i64.saturating_add_unsigned(2), 3);
saturating_sub(self, rhs: i64) -> i64Насыщающее целочисленное вычитание. Вычисляет self - rhs.1.47.01.0.0assert_eq!(100i64.saturating_sub(127), -27);
saturating_sub_unsigned(self, rhs: u64) -> i64Насыщающее вычитание с целым числом без знака. Вычисляет self - rhs.1.66.01.66.0assert_eq!(100i64.saturating_sub_unsigned(127), -27);
saturating_neg(self) -> i64Насыщающее целочисленное отрицание. Вычисляет -self.1.47.01.45.0assert_eq!(100i64.saturating_neg(), -100);
saturating_abs(self) -> i64Насыщающее абсолютное значение. Вычисляет self.abs().1.47.01.45.0assert_eq!(100i64.saturating_abs(), 100);
saturating_mul(self, rhs: i64) -> i64Насыщающее целочисленное умножение. Вычисляет self * rhs.1.47.01.7.0assert_eq!(10i64.saturating_mul(12), 120);
saturating_div(self, rhs: i64) -> i64Насыщающее целочисленное деление. Вычисляет self / rhs.1.58.01.58.0assert_eq!(5i64.saturating_div(2), 2);
saturating_pow(self, exp: u32) -> i64Насыщающее целочисленное возведение в степень. Вычисляет self.pow(exp).1.50.01.34.0assert_eq!((-4i64).saturating_pow(3), -64);

Циклическая (Wrapping) арифметика

Операции, которые циклически оборачиваются на границах типа.

МетодОписаниеКонстантностьВерсияПример
wrapping_add(self, rhs: i64) -> i64Циклическое (модулярное) сложение. Вычисляет self + rhs.1.32.01.0.0assert_eq!(100i64.wrapping_add(27), 127);
wrapping_add_unsigned(self, rhs: u64) -> i64Циклическое сложение с целым числом без знака. Вычисляет self + rhs.1.66.01.66.0assert_eq!(100i64.wrapping_add_unsigned(27), 127);
wrapping_sub(self, rhs: i64) -> i64Циклическое (модулярное) вычитание. Вычисляет self - rhs.1.32.01.0.0assert_eq!(0i64.wrapping_sub(127), -127);
wrapping_sub_unsigned(self, rhs: u64) -> i64Циклическое вычитание с целым числом без знака. Вычисляет self - rhs.1.66.01.66.0assert_eq!(0i64.wrapping_sub_unsigned(127), -127);
wrapping_mul(self, rhs: i64) -> i64Циклическое (модулярное) умножение. Вычисляет self * rhs.1.32.01.0.0assert_eq!(10i64.wrapping_mul(12), 120);
wrapping_div(self, rhs: i64) -> i64Циклическое (модулярное) деление. Вычисляет self / rhs.1.52.01.2.0assert_eq!(100i64.wrapping_div(10), 10);
wrapping_div_euclid(self, rhs: i64) -> i64Циклическое евклидово деление. Вычисляет self.div_euclid(rhs).1.52.01.38.0assert_eq!(100i64.wrapping_div_euclid(10), 10);
wrapping_rem(self, rhs: i64) -> i64Циклический (модулярный) остаток. Вычисляет self % rhs.1.52.01.2.0assert_eq!(100i64.wrapping_rem(10), 0);
wrapping_rem_euclid(self, rhs: i64) -> i64Циклический евклидов остаток. Вычисляет self.rem_euclid(rhs).1.52.01.38.0assert_eq!(100i64.wrapping_rem_euclid(10), 0);
wrapping_neg(self) -> i64Циклическое (модулярное) отрицание. Вычисляет -self.1.32.01.2.0assert_eq!(100i64.wrapping_neg(), -100);
wrapping_shl(self, rhs: u32) -> i64Безопасный битовый сдвиг влево; даёт self << mask(rhs).1.32.01.2.0assert_eq!((-1i64).wrapping_shl(7), -128);
wrapping_shr(self, rhs: u32) -> i64Безопасный битовый сдвиг вправо; даёт self >> mask(rhs).1.32.01.2.0assert_eq!((-128i64).wrapping_shr(7), -1);
wrapping_abs(self) -> i64Циклическое (модулярное) абсолютное значение. Вычисляет self.abs().1.32.01.13.0assert_eq!(100i64.wrapping_abs(), 100);
wrapping_pow(self, exp: u32) -> i64Циклическое (модулярное) возведение в степень. Вычисляет self.pow(exp).1.50.01.34.0assert_eq!(3i64.wrapping_pow(4), 81);
unsigned_abs(self) -> u64Вычисляет абсолютное значение self без циклического оборачивания или паники.1.51.01.51.0assert_eq!(100i64.unsigned_abs(), 100u64);

Операции с переполнением (Overflowing)

Возвращают кортеж (i64, bool), где bool указывает на наличие переполнения.

МетодОписаниеКонстантностьВерсияПример
overflowing_add(self, rhs: i64) -> (i64, bool)Вычисляет self + rhs.1.32.01.7.0assert_eq!(5i64.overflowing_add(2), (7, false));
carrying_add(self, rhs: i64, carry: bool) -> (i64, bool)Вычисляет self + rhs + carry и проверяет переполнение. (экспериментальный)-Nightlylet (sum1, overflow) = a1.carrying_add(b1, carry1);
overflowing_add_unsigned(self, rhs: u64) -> (i64, bool)Вычисляет self + rhs с беззнаковым rhs.1.66.01.66.0assert_eq!(1i64.overflowing_add_unsigned(2), (3, false));
overflowing_sub(self, rhs: i64) -> (i64, bool)Вычисляет self - rhs.1.32.01.7.0assert_eq!(5i64.overflowing_sub(2), (3, false));
borrowing_sub(self, rhs: i64, borrow: bool) -> (i64, bool)Вычисляет self − rhs − borrow и проверяет переполнение. (экспериментальный)-Nightlylet (diff1, overflow) = a1.borrowing_sub(b1, borrow1);
overflowing_sub_unsigned(self, rhs: u64) -> (i64, bool)Вычисляет self - rhs с беззнаковым rhs.1.66.01.66.0assert_eq!(1i64.overflowing_sub_unsigned(2), (-1, false));
overflowing_mul(self, rhs: i64) -> (i64, bool)Вычисляет умножение self и rhs.1.32.01.7.0assert_eq!(5i64.overflowing_mul(2), (10, false));
widening_mul(self, rhs: i64) -> (u64, i64)Вычисляет полное произведение self * rhs без возможности переполнения. (экспериментальный)-Nightlyassert_eq!(5i32.widening_mul(-2), (4294967286, -1));
carrying_mul(self, rhs: i64, carry: i64) -> (u64, i64)Вычисляет "полное умножение" self * rhs + carry без возможности переполнения. (экспериментальный)-Nightlyassert_eq!(5i32.carrying_mul(-2, 0), (4294967286, -1));
carrying_mul_add(self, rhs: i64, carry: i64, add: i64) -> (u64, i64)Вычисляет "полное умножение" self * rhs + carry + add без возможности переполнения. (экспериментальный)-Nightlyassert_eq!(5i32.carrying_mul_add(-2, 0, 0), (4294967286, -1));
overflowing_div(self, rhs: i64) -> (i64, bool)Вычисляет делитель, когда self делится на rhs.1.52.01.7.0assert_eq!(5i64.overflowing_div(2), (2, false));
overflowing_div_euclid(self, rhs: i64) -> (i64, bool)Вычисляет частное евклидова деления self.div_euclid(rhs).1.52.01.38.0assert_eq!(5i64.overflowing_div_euclid(2), (2, false));
overflowing_rem(self, rhs: i64) -> (i64, bool)Вычисляет остаток от деления self на rhs.1.52.01.7.0assert_eq!(5i64.overflowing_rem(2), (1, false));
overflowing_rem_euclid(self, rhs: i64) -> (i64, bool)Переполняющий евклидов остаток. Вычисляет self.rem_euclid(rhs).1.52.01.38.0assert_eq!(5i64.overflowing_rem_euclid(2), (1, false));
overflowing_neg(self) -> (i64, bool)Отрицает self, с переполнением, если это равно минимальному значению.1.32.01.7.0assert_eq!(2i64.overflowing_neg(), (-2, false));
overflowing_shl(self, rhs: u32) -> (i64, bool)Сдвигает self влево на rhs бит.1.32.01.7.0assert_eq!(0x1i64.overflowing_shl(4), (0x10, false));
overflowing_shr(self, rhs: u32) -> (i64, bool)Сдвигает self вправо на rhs бит.1.32.01.7.0assert_eq!(0x10i64.overflowing_shr(4), (0x1, false));
overflowing_abs(self) -> (i64, bool)Вычисляет абсолютное значение self.1.32.01.13.0assert_eq!(10i64.overflowing_abs(), (10, false));
overflowing_pow(self, exp: u32) -> (i64, bool)Возводит self в степень exp, используя возведение в квадрат.1.50.01.34.0assert_eq!(3i64.overflowing_pow(4), (81, false));

Прочие арифметические операции

МетодОписаниеКонстантностьВерсияПример
pow(self, exp: u32) -> i64Возводит self в степень exp, используя возведение в квадрат.1.50.01.0.0assert_eq!(2i64.pow(5), 32);
isqrt(self) -> i64Возвращает квадратный корень числа, округлённый вниз.1.84.01.84.0assert_eq!(10i64.isqrt(), 3);
div_euclid(self, rhs: i64) -> i64Вычисляет частное евклидова деления self на rhs.1.52.01.38.0let a: i64 = 7; assert_eq!(a.div_euclid(4), 1);
rem_euclid(self, rhs: i64) -> i64Вычисляет наименьший неотрицательный остаток от деления self на rhs.1.52.01.38.0let a: i64 = 7; assert_eq!(a.rem_euclid(4), 3);
div_floor(self, rhs: i64) -> i64Вычисляет частное от деления self на rhs, округляя результат в сторону отрицательной бесконечности. (экспериментальный)-Nightlyassert_eq!(8i64.div_floor(3), 2);
div_ceil(self, rhs: i64) -> i64Вычисляет частное от деления self на rhs, округляя результат в сторону положительной бесконечности. (экспериментальный)-Nightlyassert_eq!(8i64.div_ceil(3), 3);
next_multiple_of(self, rhs: i64) -> i64Если rhs положительно, вычисляет наименьшее значение, большее или равное self, кратное rhs. Если rhs отрицательно, вычисляет наибольшее значение, меньшее или равное self, кратное rhs. (экспериментальный)-Nightlyassert_eq!(23_i64.next_multiple_of(8), 24);
ilog(self, base: i64) -> u32Возвращает логарифм числа по произвольному основанию, округлённый вниз.1.67.01.67.0assert_eq!(5i64.ilog(5), 1);
ilog2(self) -> u32Возвращает логарифм числа по основанию 2, округлённый вниз.1.67.01.67.0assert_eq!(2i64.ilog2(), 1);
ilog10(self) -> u32Возвращает логарифм числа по основанию 10, округлённый вниз.1.67.01.67.0assert_eq!(10i64.ilog10(), 1);
abs(self) -> i64Вычисляет абсолютное значение self.1.32.01.0.0assert_eq!(10i64.abs(), 10);
abs_diff(self, other: i64) -> u64Вычисляет абсолютную разницу между self и other.1.60.01.60.0assert_eq!(100i64.abs_diff(80), 20u64);
signum(self) -> i64Возвращает число, представляющее знак self.1.47.01.0.0assert_eq!(10i64.signum(), 1);
is_positive(self) -> boolВозвращает true, если self положительно, и false, если число равно нулю или отрицательно.1.32.01.0.0assert!(10i64.is_positive());
is_negative(self) -> boolВозвращает true, если self отрицательно, и false, если число равно нулю или положительно.1.32.01.0.0assert!((-10i64).is_negative());
div_exact(self, rhs: i64) -> Option<i64>Целочисленное деление без остатка. Вычисляет self / rhs. Возвращает None, если self % rhs != 0. (экспериментальный)-Nightlyassert_eq!(64i64.div_exact(2), Some(32));
shl_exact(self, rhs: u32) -> Option<i64>Точный сдвиг влево. Вычисляет self << rhs, если это можно обратить без потерь. (экспериментальный)-Nightlyassert_eq!(0x1i64.shl_exact(4), Some(0x10));
shr_exact(self, rhs: u32) -> Option<i64>Точный сдвиг вправо. Вычисляет self >> rhs, если это можно обратить без потерь. (экспериментальный)-Nightlyassert_eq!(0x10i64.shr_exact(4), Some(0x1));
unbounded_shl(self, rhs: u32) -> i64Неограниченный сдвиг влево. Вычисляет self << rhs, без ограничения значения rhs.1.87.01.87.0assert_eq!(0x1i64.unbounded_shl(4), 0x10);
unbounded_shr(self, rhs: u32) -> i64Неограниченный сдвиг вправо. Вычисляет self >> rhs, без ограничения значения rhs.1.87.01.87.0assert_eq!(0x10i64.unbounded_shr(4), 0x1);
midpoint(self, rhs: i64) -> i64Вычисляет среднюю точку (среднее арифметическое) между self и rhs.1.87.01.87.0assert_eq!(0i64.midpoint(4), 2);

Преобразования в/из байтов

МетодОписаниеКонстантностьВерсияПример
to_be_bytes(self) -> [u8; 8]Возвращает представление этого целого числа в памяти в виде массива байтов в порядке big-endian (сетевом).1.44.01.32.0let bytes = 0x1234567890123456i64.to_be_bytes(); assert_eq!(bytes, [0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56]);
to_le_bytes(self) -> [u8; 8]Возвращает представление этого целого числа в памяти в виде массива байтов в порядке little-endian.1.44.01.32.0let bytes = 0x1234567890123456i64.to_le_bytes(); assert_eq!(bytes, [0x56, 0x34, 0x12, 0x90, 0x78, 0x56, 0x34, 0x12]);
to_ne_bytes(self) -> [u8; 8]Возвращает представление этого целого числа в памяти в виде массива байтов в порядке байтов целевой платформы.1.44.01.32.0let bytes = 0x1234567890123456i64.to_ne_bytes(); assert_eq!(bytes, if cfg!(target_endian = "big") { [0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56] } else { [0x56, 0x34, 0x12, 0x90, 0x78, 0x56, 0x34, 0x12] });
from_be_bytes(bytes: [u8; 8]) -> i64Создаёт целочисленное значение из его представления в виде массива байтов в порядке big-endian.1.44.01.32.0let value = i64::from_be_bytes([0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56]); assert_eq!(value, 0x1234567890123456);
from_le_bytes(bytes: [u8; 8]) -> i64Создаёт целочисленное значение из его представления в виде массива байтов в порядке little-endian.1.44.01.32.0let value = i64::from_le_bytes([0x56, 0x34, 0x12, 0x90, 0x78, 0x56, 0x34, 0x12]); assert_eq!(value, 0x1234567890123456);
from_ne_bytes(bytes: [u8; 8]) -> i64Создаёт целочисленное значение из его представления в памяти в виде массива байтов в порядке байтов целевой платформы.1.44.01.32.0let value = i64::from_ne_bytes(if cfg!(target_endian = "big") { [0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56] } else { [0x56, 0x34, 0x12, 0x90, 0x78, 0x56, 0x34, 0x12] }); assert_eq!(value, 0x1234567890123456);

Разбор из строк и ASCII

МетодОписаниеКонстантностьВерсияПример
from_str_radix(src: &str, radix: u32) -> Result<i64, ParseIntError>Разбирает целое число из строкового среза с цифрами в заданной системе счисления.1.82.01.0.0assert_eq!(i64::from_str_radix("A", 16), Ok(10));
from_ascii(src: &[u8]) -> Result<i64, ParseIntError>Разбирает целое число из среза ASCII-байтов с десятичными цифрами. (экспериментальный)-Nightlyassert_eq!(i64::from_ascii(b"+10"), Ok(10));
from_ascii_radix(src: &[u8], radix: u32) -> Result<i64, ParseIntError>Разбирает целое число из среза ASCII-байтов с цифрами в заданной системе счисления. (экспериментальный)-Nightlyassert_eq!(i64::from_ascii_radix(b"A", 16), Ok(10));

Форматирование

МетодОписаниеКонстантностьВерсияПример
format_into(self, buf: &mut NumBuffer<i64>) -> &strПозволяет записать целое число (в знаковом десятичном формате) в переменную buf типа NumBuffer, передаваемую по изменяемой ссылке. (экспериментальный)-Nightlyuse core::fmt::NumBuffer; let n = 0i64; let mut buf = NumBuffer::new(); assert_eq!(n.format_into(&mut buf), "0");

Устаревшие методы

МетодОписаниеКонстантностьВерсияПримечание
min_value() -> i64Возвращает наименьшее значение, которое может быть представлено этим целочисленным типом.1.32.01.0.0Устарело. Вместо этого следует использовать i64::MIN.
max_value() -> i64Возвращает наибольшее значение, которое может быть представлено этим целочисленным типом.1.32.01.0.0Устарело. Вместо этого следует использовать i64::MAX.