Struct fixed::FixedI128

#[repr(transparent)]pub struct FixedI128<Frac> { /* fields omitted */ }

A 128-bit fixed-point signed number with Frac fractional bits.

Frac is an Unsigned as provided by the typenum crate; the plan is to move to const generics in version 2 when they are supported by the Rust compiler.

Examples

use fixed::{types::extra::U3, FixedI128};
let eleven = FixedI128::<U3>::from_num(11);
assert_eq!(eleven, FixedI128::<U3>::from_bits(11 << 3));
assert_eq!(eleven, 11);
assert_eq!(eleven.to_string(), "11");
let two_point_75 = eleven / 4;
assert_eq!(two_point_75, FixedI128::<U3>::from_bits(11 << 1));
assert_eq!(two_point_75, 2.75);
assert_eq!(two_point_75.to_string(), "2.8");

Implementations

impl<Frac> FixedI128<Frac>

The implementation of items in this block is independent of the number of fractional bits Frac.

pub const MIN: FixedI128<Frac>

The smallest value that can be represented.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
assert_eq!(Fix::MIN, Fix::from_bits(i128::MIN));

pub const MAX: FixedI128<Frac>

The largest value that can be represented.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
assert_eq!(Fix::MAX, Fix::from_bits(i128::MAX));

pub const fn from_bits(bits: i128) -> FixedI128<Frac>

Creates a fixed-point number that has a bitwise representation identical to the given integer.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
// 0010.0000 == 2
assert_eq!(Fix::from_bits(0b10_0000), 2);

pub const fn to_bits(self) -> i128

Creates an integer that has a bitwise representation identical to the given fixed-point number.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
// 2 is 0010.0000
assert_eq!(Fix::from_num(2).to_bits(), 0b10_0000);

pub fn from_be_bytes(bytes: [u8; 16]) -> FixedI128<Frac>

Creates a fixed-point number from its representation as a byte array in big endian.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
assert_eq!(
    Fix::from_be_bytes([0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE, 0xF0, 0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE, 0xF0]),
    Fix::from_bits(0x1234_5678_9ABC_DEF0_1234_5678_9ABC_DEF0)
);

pub fn from_le_bytes(bytes: [u8; 16]) -> FixedI128<Frac>

Creates a fixed-point number from its representation as a byte array in little endian.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
assert_eq!(
    Fix::from_le_bytes([0xF0, 0xDE, 0xBC, 0x9A, 0x78, 0x56, 0x34, 0x12, 0xF0, 0xDE, 0xBC, 0x9A, 0x78, 0x56, 0x34, 0x12]),
    Fix::from_bits(0x1234_5678_9ABC_DEF0_1234_5678_9ABC_DEF0)
);

pub fn from_ne_bytes(bytes: [u8; 16]) -> FixedI128<Frac>

Creates a fixed-point number from its representation as a byte array in native endian.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
assert_eq!(
    if cfg!(target_endian = "big") {
        Fix::from_ne_bytes([0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE, 0xF0, 0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE, 0xF0])
    } else {
        Fix::from_ne_bytes([0xF0, 0xDE, 0xBC, 0x9A, 0x78, 0x56, 0x34, 0x12, 0xF0, 0xDE, 0xBC, 0x9A, 0x78, 0x56, 0x34, 0x12])
    },
    Fix::from_bits(0x1234_5678_9ABC_DEF0_1234_5678_9ABC_DEF0)
);

pub fn to_be_bytes(self) -> [u8; 16]

Returns the memory representation of this fixed-point number as a byte array in big-endian byte order.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
let val = Fix::from_bits(0x1234_5678_9ABC_DEF0_1234_5678_9ABC_DEF0);
assert_eq!(
    val.to_be_bytes(),
    [0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE, 0xF0, 0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE, 0xF0]
);

pub fn to_le_bytes(self) -> [u8; 16]

Returns the memory representation of this fixed-point number as a byte array in little-endian byte order.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
let val = Fix::from_bits(0x1234_5678_9ABC_DEF0_1234_5678_9ABC_DEF0);
assert_eq!(
    val.to_le_bytes(),
    [0xF0, 0xDE, 0xBC, 0x9A, 0x78, 0x56, 0x34, 0x12, 0xF0, 0xDE, 0xBC, 0x9A, 0x78, 0x56, 0x34, 0x12]
);

pub fn to_ne_bytes(self) -> [u8; 16]

Returns the memory representation of this fixed-point number as a byte array in native byte order.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
let val = Fix::from_bits(0x1234_5678_9ABC_DEF0_1234_5678_9ABC_DEF0);
assert_eq!(
    val.to_ne_bytes(),
    if cfg!(target_endian = "big") {
        [0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE, 0xF0, 0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE, 0xF0]
    } else {
        [0xF0, 0xDE, 0xBC, 0x9A, 0x78, 0x56, 0x34, 0x12, 0xF0, 0xDE, 0xBC, 0x9A, 0x78, 0x56, 0x34, 0x12]
    }
);

pub const fn count_ones(self) -> u32

Returns the number of ones in the binary representation.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
let f = Fix::from_bits(0b11_0010);
assert_eq!(f.count_ones(), 3);

pub const fn count_zeros(self) -> u32

Returns the number of zeros in the binary representation.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
let f = Fix::from_bits(!0b11_0010);
assert_eq!(f.count_zeros(), 3);

pub const fn leading_ones(self) -> u32

Returns the number of leading ones in the binary representation.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
let all_ones = !Fix::from_bits(0);
let f = all_ones - Fix::from_bits(0b10_0000);
assert_eq!(f.leading_ones(), 128 - 6);

pub const fn leading_zeros(self) -> u32

Returns the number of leading zeros in the binary representation.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
let f = Fix::from_bits(0b10_0000);
assert_eq!(f.leading_zeros(), 128 - 6);

pub const fn trailing_ones(self) -> u32

Returns the number of trailing ones in the binary representation.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
let f = Fix::from_bits(0b101_1111);
assert_eq!(f.trailing_ones(), 5);

pub const fn trailing_zeros(self) -> u32

Returns the number of trailing zeros in the binary representation.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
let f = Fix::from_bits(0b10_0000);
assert_eq!(f.trailing_zeros(), 5);

pub const fn rotate_left(self, n: u32) -> FixedI128<Frac>

Shifts to the left by n bits, wrapping the truncated bits to the right end.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
let bits: i128 = (0b111 << (128 - 3)) | 0b1010;
let rot = 0b1010111;
assert_eq!(bits.rotate_left(3), rot);
assert_eq!(Fix::from_bits(bits).rotate_left(3), Fix::from_bits(rot));

pub const fn rotate_right(self, n: u32) -> FixedI128<Frac>

Shifts to the right by n bits, wrapping the truncated bits to the left end.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
let bits: i128 = 0b1010111;
let rot = (0b111 << (128 - 3)) | 0b1010;
assert_eq!(bits.rotate_right(3), rot);
assert_eq!(Fix::from_bits(bits).rotate_right(3), Fix::from_bits(rot));

pub const fn is_positive(self) -> bool

Returns true if the number is > 0.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
assert!(Fix::from_num(5).is_positive());
assert!(!Fix::from_num(0).is_positive());
assert!(!Fix::from_num(-5).is_positive());

pub const fn is_negative(self) -> bool

Returns true if the number is < 0.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
assert!(!Fix::from_num(5).is_negative());
assert!(!Fix::from_num(0).is_negative());
assert!(Fix::from_num(-5).is_negative());

pub fn rem_euclid(self, rhs: FixedI128<Frac>) -> FixedI128<Frac>

Remainder for Euclidean division.

Panics

Panics if the divisor is zero.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
assert_eq!(Fix::from_num(7.5).rem_euclid(Fix::from_num(2)), Fix::from_num(1.5));
assert_eq!(Fix::from_num(-7.5).rem_euclid(Fix::from_num(2)), Fix::from_num(0.5));

pub const fn abs(self) -> FixedI128<Frac>

Returns the absolute value.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
let five = Fix::from_num(5);
let minus_five = Fix::from_num(-5);
assert_eq!(five.abs(), five);
assert_eq!(minus_five.abs(), five);

pub fn checked_neg(self) -> Option<FixedI128<Frac>>

Checked negation. Returns the negated value, or None on overflow.

Overflow can only occur when negating the minimum value.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
assert_eq!(Fix::from_num(5).checked_neg(), Some(Fix::from_num(-5)));
assert_eq!(Fix::MIN.checked_neg(), None);

pub fn checked_add(self, rhs: FixedI128<Frac>) -> Option<FixedI128<Frac>>

Checked addition. Returns the sum, or None on overflow.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
let one = Fix::from_num(1);
assert_eq!((Fix::MAX - one).checked_add(one), Some(Fix::MAX));
assert_eq!(Fix::MAX.checked_add(one), None);

pub fn checked_sub(self, rhs: FixedI128<Frac>) -> Option<FixedI128<Frac>>

Checked subtraction. Returns the difference, or None on overflow.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
let one = Fix::from_num(1);
assert_eq!((Fix::MIN + one).checked_sub(one), Some(Fix::MIN));
assert_eq!(Fix::MIN.checked_sub(one), None);

pub fn checked_rem(self, rhs: FixedI128<Frac>) -> Option<FixedI128<Frac>>

Checked remainder. Returns the remainder, or None if the divisor is zero.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
assert_eq!(Fix::from_num(1.5).checked_rem(Fix::from_num(1)), Some(Fix::from_num(0.5)));
assert_eq!(Fix::from_num(1.5).checked_rem(Fix::from_num(0)), None);

pub fn checked_mul_int(self, rhs: i128) -> Option<FixedI128<Frac>>

Checked multiplication by an integer. Returns the product, or None on overflow.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
assert_eq!(Fix::MAX.checked_mul_int(1), Some(Fix::MAX));
assert_eq!(Fix::MAX.checked_mul_int(2), None);

pub fn checked_div_int(self, rhs: i128) -> Option<FixedI128<Frac>>

Checked division by an integer. Returns the quotient, or None if the divisor is zero or if the division results in overflow.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
assert_eq!(Fix::MAX.checked_div_int(1), Some(Fix::MAX));
assert_eq!(Fix::from_num(1).checked_div_int(0), None);
assert_eq!(Fix::MIN.checked_div_int(-1), None);

pub fn checked_rem_euclid(self, rhs: FixedI128<Frac>) -> Option<FixedI128<Frac>>

Checked remainder for Euclidean division. Returns the remainder, or None if the divisor is zero.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
let num = Fix::from_num(7.5);
assert_eq!(num.checked_rem_euclid(Fix::from_num(2)), Some(Fix::from_num(1.5)));
assert_eq!(num.checked_rem_euclid(Fix::from_num(0)), None);
assert_eq!((-num).checked_rem_euclid(Fix::from_num(2)), Some(Fix::from_num(0.5)));

pub fn checked_shl(self, rhs: u32) -> Option<FixedI128<Frac>>

Checked shift left. Returns the shifted number, or None if rhs ≥ 128.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
assert_eq!((Fix::from_num(1) / 2).checked_shl(3), Some(Fix::from_num(4)));
assert_eq!((Fix::from_num(1) / 2).checked_shl(128), None);

pub fn checked_shr(self, rhs: u32) -> Option<FixedI128<Frac>>

Checked shift right. Returns the shifted number, or None if rhs ≥ 128.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
assert_eq!(Fix::from_num(4).checked_shr(3), Some(Fix::from_num(1) / 2));
assert_eq!(Fix::from_num(4).checked_shr(128), None);

pub fn checked_abs(self) -> Option<FixedI128<Frac>>

Checked absolute value. Returns the absolute value, or None on overflow.

Overflow can only occur when trying to find the absolute value of the minimum value.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
assert_eq!(Fix::from_num(-5).checked_abs(), Some(Fix::from_num(5)));
assert_eq!(Fix::MIN.checked_abs(), None);

pub const fn saturating_neg(self) -> FixedI128<Frac>

Saturating negation. Returns the negated value, saturating on overflow.

Overflow can only occur when negating the minimum value.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
assert_eq!(Fix::from_num(5).saturating_neg(), Fix::from_num(-5));
assert_eq!(Fix::MIN.saturating_neg(), Fix::MAX);

pub const fn saturating_add(self, rhs: FixedI128<Frac>) -> FixedI128<Frac>

Saturating addition. Returns the sum, saturating on overflow.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
assert_eq!(Fix::from_num(3).saturating_add(Fix::from_num(2)), Fix::from_num(5));
assert_eq!(Fix::MAX.saturating_add(Fix::from_num(1)), Fix::MAX);

pub const fn saturating_sub(self, rhs: FixedI128<Frac>) -> FixedI128<Frac>

Saturating subtraction. Returns the difference, saturating on overflow.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
assert_eq!(Fix::from_num(1).saturating_sub(Fix::from_num(3)), Fix::from_num(-2));
assert_eq!(Fix::MIN.saturating_sub(Fix::from_num(1)), Fix::MIN);

pub const fn saturating_mul_int(self, rhs: i128) -> FixedI128<Frac>

Saturating multiplication by an integer. Returns the product, saturating on overflow.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
assert_eq!(Fix::from_num(3).saturating_mul_int(2), Fix::from_num(6));
assert_eq!(Fix::MAX.saturating_mul_int(2), Fix::MAX);

pub const fn saturating_abs(self) -> FixedI128<Frac>

Saturating absolute value. Returns the absolute value, saturating on overflow.

Overflow can only occur when trying to find the absolute value of the minimum value.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
assert_eq!(Fix::from_num(-5).saturating_abs(), Fix::from_num(5));
assert_eq!(Fix::MIN.saturating_abs(), Fix::MAX);

pub const fn wrapping_neg(self) -> FixedI128<Frac>

Wrapping negation. Returns the negated value, wrapping on overflow.

Overflow can only occur when negating the minimum value.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
assert_eq!(Fix::from_num(5).wrapping_neg(), Fix::from_num(-5));
assert_eq!(Fix::MIN.wrapping_neg(), Fix::MIN);

pub const fn wrapping_add(self, rhs: FixedI128<Frac>) -> FixedI128<Frac>

Wrapping addition. Returns the sum, wrapping on overflow.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
let one = Fix::from_num(1);
let one_minus_bit = one - Fix::from_bits(1);
assert_eq!(Fix::from_num(3).wrapping_add(Fix::from_num(2)), Fix::from_num(5));
assert_eq!(Fix::MAX.wrapping_add(one), Fix::MIN + one_minus_bit);

pub const fn wrapping_sub(self, rhs: FixedI128<Frac>) -> FixedI128<Frac>

Wrapping subtraction. Returns the difference, wrapping on overflow.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
let one = Fix::from_num(1);
let one_minus_bit = one - Fix::from_bits(1);
assert_eq!(Fix::from_num(3).wrapping_sub(Fix::from_num(5)), Fix::from_num(-2));
assert_eq!(Fix::MIN.wrapping_sub(one), Fix::MAX - one_minus_bit);

pub const fn wrapping_mul_int(self, rhs: i128) -> FixedI128<Frac>

Wrapping multiplication by an integer. Returns the product, wrapping on overflow.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
assert_eq!(Fix::from_num(3).wrapping_mul_int(2), Fix::from_num(6));
let wrapped = Fix::from_bits(!0 << 2);
assert_eq!(Fix::MAX.wrapping_mul_int(4), wrapped);

pub fn wrapping_div_int(self, rhs: i128) -> FixedI128<Frac>

Wrapping division by an integer. Returns the quotient, wrapping on overflow.

Overflow can only occur when dividing the minimum value by −1.

Panics

Panics if the divisor is zero.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
// 1.5 is binary 1.1
let one_point_5 = Fix::from_bits(0b11 << (4 - 1));
assert_eq!(Fix::from_num(3).wrapping_div_int(2), one_point_5);
assert_eq!(Fix::MIN.wrapping_div_int(-1), Fix::MIN);

pub const fn wrapping_shl(self, rhs: u32) -> FixedI128<Frac>

Wrapping shift left. Wraps rhs if rhs ≥ 128, then shifts and returns the number.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
assert_eq!((Fix::from_num(1) / 2).wrapping_shl(3), Fix::from_num(4));
assert_eq!((Fix::from_num(1) / 2).wrapping_shl(3 + 128), Fix::from_num(4));

pub const fn wrapping_shr(self, rhs: u32) -> FixedI128<Frac>

Wrapping shift right. Wraps rhs if rhs ≥ 128, then shifts and returns the number.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
assert_eq!((Fix::from_num(4)).wrapping_shr(3), Fix::from_num(1) / 2);
assert_eq!((Fix::from_num(4)).wrapping_shr(3 + 128), Fix::from_num(1) / 2);

pub const fn wrapping_abs(self) -> FixedI128<Frac>

Wrapping absolute value. Returns the absolute value, wrapping on overflow.

Overflow can only occur when trying to find the absolute value of the minimum value.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
assert_eq!(Fix::from_num(-5).wrapping_abs(), Fix::from_num(5));
assert_eq!(Fix::MIN.wrapping_abs(), Fix::MIN);

pub const fn overflowing_neg(self) -> (FixedI128<Frac>, bool)

Overflowing negation.

Returns a tuple of the negated value and a bool indicating whether an overflow has occurred. On overflow, the wrapped value is returned.

Overflow can only occur when negating the minimum value.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
assert_eq!(Fix::from_num(5).overflowing_neg(), (Fix::from_num(-5), false));
assert_eq!(Fix::MIN.overflowing_neg(), (Fix::MIN, true));

pub const fn overflowing_add(
    self,
    rhs: FixedI128<Frac>
) -> (FixedI128<Frac>, bool)

Overflowing addition.

Returns a tuple of the sum and a bool indicating whether an overflow has occurred. On overflow, the wrapped value is returned.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
let one = Fix::from_num(1);
let one_minus_bit = one - Fix::from_bits(1);
assert_eq!(Fix::from_num(3).overflowing_add(Fix::from_num(2)), (Fix::from_num(5), false));
assert_eq!(Fix::MAX.overflowing_add(one), (Fix::MIN + one_minus_bit, true));

pub const fn overflowing_sub(
    self,
    rhs: FixedI128<Frac>
) -> (FixedI128<Frac>, bool)

Overflowing subtraction.

Returns a tuple of the difference and a bool indicating whether an overflow has occurred. On overflow, the wrapped value is returned.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
let one = Fix::from_num(1);
let one_minus_bit = one - Fix::from_bits(1);
assert_eq!(Fix::from_num(3).overflowing_sub(Fix::from_num(5)), (Fix::from_num(-2), false));
assert_eq!(Fix::MIN.overflowing_sub(one), (Fix::MAX - one_minus_bit, true));

pub const fn overflowing_mul_int(self, rhs: i128) -> (FixedI128<Frac>, bool)

Overflowing multiplication by an integer.

Returns a tuple of the product and a bool indicating whether an overflow has occurred. On overflow, the wrapped value is returned.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
assert_eq!(Fix::from_num(3).overflowing_mul_int(2), (Fix::from_num(6), false));
let wrapped = Fix::from_bits(!0 << 2);
assert_eq!(Fix::MAX.overflowing_mul_int(4), (wrapped, true));

pub fn overflowing_div_int(self, rhs: i128) -> (FixedI128<Frac>, bool)

Overflowing division by an integer.

Returns a tuple of the quotient and a bool indicating whether an overflow has occurred. On overflow, the wrapped value is returned. Overflow can only occur when dividing the minimum value by −1.

Panics

Panics if the divisor is zero.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
// 1.5 is binary 1.1
let one_point_5 = Fix::from_bits(0b11 << (4 - 1));
assert_eq!(Fix::from_num(3).overflowing_div_int(2), (one_point_5, false));
assert_eq!(Fix::MIN.overflowing_div_int(-1), (Fix::MIN, true));

pub const fn overflowing_shl(self, rhs: u32) -> (FixedI128<Frac>, bool)

Overflowing shift left.

Returns a tuple of the shifted value and a bool indicating whether an overflow has occurred. Overflow occurs when rhs ≥ 128. On overflow rhs is wrapped before the shift operation.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
assert_eq!((Fix::from_num(1) / 2).overflowing_shl(3), (Fix::from_num(4), false));
assert_eq!((Fix::from_num(1) / 2).overflowing_shl(3 + 128), (Fix::from_num(4), true));

pub const fn overflowing_shr(self, rhs: u32) -> (FixedI128<Frac>, bool)

Overflowing shift right.

Returns a tuple of the shifted value and a bool indicating whether an overflow has occurred. Overflow occurs when rhs ≥ 128. On overflow rhs is wrapped before the shift operation.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
assert_eq!((Fix::from_num(4)).overflowing_shr(3), (Fix::from_num(1) / 2, false));
assert_eq!((Fix::from_num(4)).overflowing_shr(3 + 128), (Fix::from_num(1) / 2, true));

pub const fn overflowing_abs(self) -> (FixedI128<Frac>, bool)

Overflowing absolute value.

Returns a tuple of the absolute value and a bool indicating whether an overflow has occurred. On overflow, the wrapped value is returned.

Overflow can only occur when trying to find the absolute value of the minimum value.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
assert_eq!(Fix::from_num(-5).overflowing_abs(), (Fix::from_num(5), false));
assert_eq!(Fix::MIN.overflowing_abs(), (Fix::MIN, true));

pub const fn min_value() -> FixedI128<Frac>

Deprecated since 0.5.5:

replaced by MIN

Returns the smallest value that can be represented.

pub const fn max_value() -> FixedI128<Frac>

Deprecated since 0.5.5:

replaced by MAX

Returns the largest value that can be represented.

impl<Frac: LeEqU128> FixedI128<Frac>

The implementation of items in this block depends on the number of fractional bits Frac.

pub const INT_NBITS: u32

The number of integer bits.

Examples

use fixed::{types::extra::U6, FixedI128};
type Fix = FixedI128<U6>;
assert_eq!(Fix::INT_NBITS, 128 - 6);

pub const FRAC_NBITS: u32

The number of fractional bits.

Examples

use fixed::{types::extra::U6, FixedI128};
type Fix = FixedI128<U6>;
assert_eq!(Fix::FRAC_NBITS, 6);

pub fn from_num<Src: ToFixed>(src: Src) -> FixedI128<Frac>

Creates a fixed-point number from another number.

The other number can be:

• Another fixed-point number. Any extra fractional bits are discarded, which rounds towards −∞.
• An integer of type i8, i16, i32, i64, i128, isize, u8, u16, u32, u64, u128, or usize.
• A floating-point number of type f32 or f64. If the f16 feature is enabled, it can also be of type f16 or bf16. For this conversion, the method rounds to the nearest, with ties rounding to even.
• Any other number src for which ToFixed is implemented, in which case this method returns src.to_fixed().

Panics

For floating-point numbers, panics if the value is not finite.

When debug assertions are enabled, panics if the value does not fit. When debug assertions are not enabled, the wrapped value can be returned, but it is not considered a breaking change if in the future it panics; if wrapping is required use wrapping_from_num instead.

Examples

use fixed::{types::extra::U4, types::I16F16, FixedI128};
type Fix = FixedI128<U4>;

// 1.75 is 1.11 in binary
let src = I16F16::from_bits(0b111 << (16 - 2));
assert_eq!(Fix::from_num(src), Fix::from_bits(0b111 << (4 - 2)));

assert_eq!(Fix::from_num(3i32), Fix::from_bits(3 << 4));
assert_eq!(Fix::from_num(-3i64), Fix::from_bits(-3 << 4));

assert_eq!(Fix::from_num(1.75f32), Fix::from_bits(0b111 << (4 - 2)));
assert_eq!(Fix::from_num(-1.75f64), Fix::from_bits(-0b111 << (4-2)));

pub fn to_num<Dst: FromFixed>(self) -> Dst

Converts a fixed-point number to another number.

The other number can be:

• Another fixed-point number. Any extra fractional bits are discarded, which rounds towards −∞.
• An integer of type i8, i16, i32, i64, i128, isize, u8, u16, u32, u64, u128, or usize. Any fractional bits are discarded, which rounds towards −∞.
• A floating-point number of type f32 or f64. If the f16 feature is enabled, it can also be of type f16 or bf16. For this conversion, the method rounds to the nearest, with ties rounding to even.
• Any other type Dst for which FromFixed is implemented, in which case this method returns Dst::from_fixed(self).

Panics

When debug assertions are enabled, panics if the value does not fit. When debug assertions are not enabled, the wrapped value can be returned, but it is not considered a breaking change if in the future it panics; if wrapping is required use wrapping_to_num instead.

Examples

use fixed::{types::extra::U4, types::I30F2, FixedI128};
type Fix = FixedI128<U4>;

// 1.75 is 1.11 in binary
let src = Fix::from_bits(0b111 << (4 - 2));
assert_eq!(src.to_num::<I30F2>(), I30F2::from_bits(0b111));
// src >> 2 is 0.0111, which for I30F2 is truncated to 0.01
assert_eq!((src >> 2u32).to_num::<I30F2>(), I30F2::from_bits(1));

// 2.5 is 10.1 in binary
let two_point_5 = Fix::from_bits(0b101 << (4 - 1));
assert_eq!(two_point_5.to_num::<i32>(), 2);
assert_eq!((-two_point_5).to_num::<i64>(), -3);

// 1.625 is 1.101 in binary
let one_point_625 = Fix::from_bits(0b1101 << (4 - 3));
assert_eq!(one_point_625.to_num::<f32>(), 1.625f32);
assert_eq!((-one_point_625).to_num::<f64>(), -1.625f64);

pub fn checked_from_num<Src: ToFixed>(src: Src) -> Option<FixedI128<Frac>>

Creates a fixed-point number from another number if it fits, otherwise returns None.

The other number can be:

• Another fixed-point number. Any extra fractional bits are discarded, which rounds towards −∞.
• An integer of type i8, i16, i32, i64, i128, isize, u8, u16, u32, u64, u128, or usize.
• A floating-point number of type f32 or f64. If the f16 feature is enabled, it can also be of type f16 or bf16. For this conversion, the method rounds to the nearest, with ties rounding to even.
• Any other number src for which ToFixed is implemented, in which case this method returns src.checked_to_fixed().

Examples

use fixed::{
    types::extra::{U2, U4},
    types::I16F16,
    FixedI128,
};
type Fix = FixedI128<U4>;

// 1.75 is 1.11 in binary
let src = I16F16::from_bits(0b111 << (16 - 2));
assert_eq!(Fix::checked_from_num(src), Some(Fix::from_bits(0b111 << (4 - 2))));
let too_large = FixedI128::<U2>::MAX;
assert!(Fix::checked_from_num(too_large).is_none());

assert_eq!(Fix::checked_from_num(3), Some(Fix::from_bits(3 << 4)));
let too_large = i128::MAX;
assert!(Fix::checked_from_num(too_large).is_none());
let too_small = i128::MIN;
assert!(Fix::checked_from_num(too_small).is_none());

// 1.75 is 1.11 in binary
let expected = Fix::from_bits(0b111 << (4 - 2));
assert_eq!(Fix::checked_from_num(1.75f32), Some(expected));
assert_eq!(Fix::checked_from_num(-1.75f64), Some(-expected));
assert!(Fix::checked_from_num(2e38).is_none());
assert!(Fix::checked_from_num(std::f64::NAN).is_none());

pub fn checked_to_num<Dst: FromFixed>(self) -> Option<Dst>

Converts a fixed-point number to another number if it fits, otherwise returns None.

The other number can be:

• Another fixed-point number. Any extra fractional bits are discarded, which rounds towards −∞.
• An integer of type i8, i16, i32, i64, i128, isize, u8, u16, u32, u64, u128, or usize. Any fractional bits are discarded, which rounds towards −∞.
• A floating-point number of type f32 or f64. If the f16 feature is enabled, it can also be of type f16 or bf16. For this conversion, the method rounds to the nearest, with ties rounding to even.
• Any other type Dst for which FromFixed is implemented, in which case this method returns Dst::checked_from_fixed(self).

Examples

use fixed::{
    types::extra::{U0, U4, U6},
    types::I16F16,
    FixedI128,
};
type Fix = FixedI128<U4>;

// 1.75 is 1.11 in binary
let src = Fix::from_bits(0b111 << (4 - 2));
let expected = I16F16::from_bits(0b111 << (16 - 2));
assert_eq!(src.checked_to_num::<I16F16>(), Some(expected));
type TooFewIntBits = FixedI128<U6>;
assert!(Fix::MAX.checked_to_num::<TooFewIntBits>().is_none());

// 2.5 is 10.1 in binary
let two_point_5 = Fix::from_bits(0b101 << (4 - 1));
assert_eq!(two_point_5.checked_to_num::<i32>(), Some(2));
assert_eq!((-two_point_5).checked_to_num::<i64>(), Some(-3));
type AllInt = FixedI128<U0>;
assert!(AllInt::from_bits(-1).checked_to_num::<u128>().is_none());

// 1.625 is 1.101 in binary
let one_point_625 = Fix::from_bits(0b1101 << (4 - 3));
assert_eq!(one_point_625.checked_to_num::<f32>(), Some(1.625f32));

pub fn saturating_from_num<Src: ToFixed>(src: Src) -> FixedI128<Frac>

Creates a fixed-point number from another number, saturating if it does not fit.

The other number can be:

• Another fixed-point number. Any extra fractional bits are discarded, which rounds towards −∞.
• An integer of type i8, i16, i32, i64, i128, isize, u8, u16, u32, u64, u128, or usize.
• A floating-point number of type f32 or f64. If the f16 feature is enabled, it can also be of type f16 or bf16. For this conversion, the method rounds to the nearest, with ties rounding to even.
• Any other number src for which ToFixed is implemented, in which case this method returns src.saturating_to_fixed().

Panics

This method panics if the value is a floating-point NaN.

Examples

use fixed::{
    types::extra::{U2, U4},
    types::I16F16,
    FixedI128,
};
type Fix = FixedI128<U4>;

// 1.75 is 1.11 in binary
let src = I16F16::from_bits(0b111 << (16 - 2));
assert_eq!(Fix::saturating_from_num(src), Fix::from_bits(0b111 << (4 - 2)));
let too_large = FixedI128::<U2>::MAX;
assert_eq!(Fix::saturating_from_num(too_large), Fix::MAX);

assert_eq!(Fix::saturating_from_num(3), Fix::from_bits(3 << 4));
let too_small = i128::MIN;
assert_eq!(Fix::saturating_from_num(too_small), Fix::MIN);

// 1.75 is 1.11 in binary
let expected = Fix::from_bits(0b111 << (4 - 2));
assert_eq!(Fix::saturating_from_num(1.75f32), expected);
assert_eq!(Fix::saturating_from_num(-1.75f64), -expected);
assert_eq!(Fix::saturating_from_num(2e38), Fix::MAX);
assert_eq!(Fix::saturating_from_num(std::f64::NEG_INFINITY), Fix::MIN);

pub fn saturating_to_num<Dst: FromFixed>(self) -> Dst

Converts a fixed-point number to another number, saturating the value if it does not fit.

The other number can be:

• Another fixed-point number. Any extra fractional bits are discarded, which rounds towards −∞.
• An integer of type i8, i16, i32, i64, i128, isize, u8, u16, u32, u64, u128, or usize. Any fractional bits are discarded, which rounds towards −∞.
• A floating-point number of type f32 or f64. If the f16 feature is enabled, it can also be of type f16 or bf16. For this conversion, the method rounds to the nearest, with ties rounding to even.
• Any other type Dst for which FromFixed is implemented, in which case this method returns Dst::saturating_from_fixed(self).

Examples

use fixed::{
    types::extra::{U0, U4, U6},
    types::I16F16,
    FixedI128,
};
type Fix = FixedI128<U4>;

// 1.75 is 1.11 in binary
let src = Fix::from_bits(0b111 << (4 - 2));
let expected = I16F16::from_bits(0b111 << (16 - 2));
assert_eq!(src.saturating_to_num::<I16F16>(), expected);
type TooFewIntBits = FixedI128<U6>;
let saturated = Fix::MAX.saturating_to_num::<TooFewIntBits>();
assert_eq!(saturated, TooFewIntBits::MAX);

// 2.5 is 10.1 in binary
let two_point_5 = Fix::from_bits(0b101 << (4 - 1));
assert_eq!(two_point_5.saturating_to_num::<i32>(), 2);
type AllInt = FixedI128<U0>;
assert_eq!(AllInt::from_bits(-1).saturating_to_num::<u128>(), 0);

// 1.625 is 1.101 in binary
let one_point_625 = Fix::from_bits(0b1101 << (4 - 3));
assert_eq!(one_point_625.saturating_to_num::<f32>(), 1.625f32);

pub fn wrapping_from_num<Src: ToFixed>(src: Src) -> FixedI128<Frac>

Creates a fixed-point number from another number, wrapping the value on overflow.

The other number can be:

• Another fixed-point number. Any extra fractional bits are discarded, which rounds towards −∞.
• An integer of type i8, i16, i32, i64, i128, isize, u8, u16, u32, u64, u128, or usize.
• A floating-point number of type f32 or f64. If the f16 feature is enabled, it can also be of type f16 or bf16. For this conversion, the method rounds to the nearest, with ties rounding to even.
• Any other number src for which ToFixed is implemented, in which case this method returns src.wrapping_to_fixed().

Panics

For floating-point numbers, panics if the value is not finite.

Examples

use fixed::{
    types::extra::{U0, U4},
    types::I16F16,
    FixedI128,
};
type Fix = FixedI128<U4>;

// 1.75 is 1.11 in binary
let src = I16F16::from_bits(0b111 << (16 - 2));
assert_eq!(Fix::wrapping_from_num(src), Fix::from_bits(0b111 << (4 - 2)));
// integer 0b1101 << (128 - 7) will wrap to fixed-point 1010...
let too_large = FixedI128::<U0>::from_bits(0b1101 << (128 - 7));
let wrapped = Fix::from_bits(0b1010 << (128 - 4));
assert_eq!(Fix::wrapping_from_num(too_large), wrapped);

// integer 0b1101 << (128 - 7) will wrap to fixed-point 1010...
let large: i128 = 0b1101 << (128 - 7);
let wrapped = Fix::from_bits(0b1010 << (128 - 4));
assert_eq!(Fix::wrapping_from_num(large), wrapped);

// 1.75 is 1.11 in binary
let expected = Fix::from_bits(0b111 << (4 - 2));
assert_eq!(Fix::wrapping_from_num(1.75f32), expected);
// 1.75 << (128 - 4) wraps to binary 11000...
let large = 1.75 * 2f32.powi(128 - 4);
let wrapped = Fix::from_bits(0b1100 << (128 - 4));
assert_eq!(Fix::wrapping_from_num(large), wrapped);

pub fn wrapping_to_num<Dst: FromFixed>(self) -> Dst

Converts a fixed-point number to another number, wrapping the value on overflow.

The other number can be:

• Another fixed-point number. Any extra fractional bits are discarded, which rounds towards −∞.
• An integer of type i8, i16, i32, i64, i128, isize, u8, u16, u32, u64, u128, or usize. Any fractional bits are discarded, which rounds towards −∞.
• A floating-point number of type f32 or f64. If the f16 feature is enabled, it can also be of type f16 or bf16. For this conversion, the method rounds to the nearest, with ties rounding to even.
• Any other type Dst for which FromFixed is implemented, in which case this method returns Dst::wrapping_from_fixed(self).

Examples

use fixed::{
    types::extra::{U0, U4, U6},
    types::I16F16,
    FixedI128,
};
type Fix = FixedI128<U4>;

// 1.75 is 1.11 in binary
let src = Fix::from_bits(0b111 << (4 - 2));
let expected = I16F16::from_bits(0b111 << (16 - 2));
assert_eq!(src.wrapping_to_num::<I16F16>(), expected);
type TooFewIntBits = FixedI128<U6>;
let wrapped = TooFewIntBits::from_bits(Fix::MAX.to_bits() << 2);
assert_eq!(Fix::MAX.wrapping_to_num::<TooFewIntBits>(), wrapped);

// 2.5 is 10.1 in binary
let two_point_5 = Fix::from_bits(0b101 << (4 - 1));
assert_eq!(two_point_5.wrapping_to_num::<i32>(), 2);
type AllInt = FixedI128<U0>;
assert_eq!(AllInt::from_bits(-1).wrapping_to_num::<u128>(), u128::MAX);

// 1.625 is 1.101 in binary
let one_point_625 = Fix::from_bits(0b1101 << (4 - 3));
assert_eq!(one_point_625.wrapping_to_num::<f32>(), 1.625f32);

pub fn overflowing_from_num<Src: ToFixed>(src: Src) -> (FixedI128<Frac>, bool)

Creates a fixed-point number from another number.

Returns a tuple of the fixed-point number and a bool indicating whether an overflow has occurred. On overflow, the wrapped value is returned.

The other number can be:

• Another fixed-point number. Any extra fractional bits are discarded, which rounds towards −∞.
• An integer of type i8, i16, i32, i64, i128, isize, u8, u16, u32, u64, u128, or usize.
• A floating-point number of type f32 or f64. If the f16 feature is enabled, it can also be of type f16 or bf16. For this conversion, the method rounds to the nearest, with ties rounding to even.
• Any other number src for which ToFixed is implemented, in which case this method returns src.overflowing_to_fixed().

Panics

For floating-point numbers, panics if the value is not finite.

Examples

use fixed::{
    types::extra::{U0, U4},
    types::I16F16,
    FixedI128,
};
type Fix = FixedI128<U4>;

// 1.75 is 1.11 in binary
let src = I16F16::from_bits(0b111 << (16 - 2));
let expected = Fix::from_bits(0b111 << (4 - 2));
assert_eq!(Fix::overflowing_from_num(src), (expected, false));
// integer 0b1101 << (128 - 7) will wrap to fixed-point 1010...
let too_large = FixedI128::<U0>::from_bits(0b1101 << (128 - 7));
let wrapped = Fix::from_bits(0b1010 << (128 - 4));
assert_eq!(Fix::overflowing_from_num(too_large), (wrapped, true));

assert_eq!(Fix::overflowing_from_num(3), (Fix::from_bits(3 << 4), false));
// integer 0b1101 << (128 - 7) will wrap to fixed-point 1010...
let large: i128 = 0b1101 << (128 - 7);
let wrapped = Fix::from_bits(0b1010 << (128 - 4));
assert_eq!(Fix::overflowing_from_num(large), (wrapped, true));

// 1.75 is 1.11 in binary
let expected = Fix::from_bits(0b111 << (4 - 2));
assert_eq!(Fix::overflowing_from_num(1.75f32), (expected, false));
// 1.75 << (128 - 4) wraps to binary 11000...
let large = 1.75 * 2f32.powi(128 - 4);
let wrapped = Fix::from_bits(0b1100 << (128 - 4));
assert_eq!(Fix::overflowing_from_num(large), (wrapped, true));

pub fn overflowing_to_num<Dst: FromFixed>(self) -> (Dst, bool)

Converts a fixed-point number to another number.

Returns a tuple of the number and a bool indicating whether an overflow has occurred. On overflow, the wrapped value is returned.

The other number can be:

• Another fixed-point number. Any extra fractional bits are discarded, which rounds towards −∞.
• An integer of type i8, i16, i32, i64, i128, isize, u8, u16, u32, u64, u128, or usize. Any fractional bits are discarded, which rounds towards −∞.
• A floating-point number of type f32 or f64. If the f16 feature is enabled, it can also be of type f16 or bf16. For this conversion, the method rounds to the nearest, with ties rounding to even.
• Any other type Dst for which FromFixed is implemented, in which case this method returns Dst::overflowing_from_fixed(self).

Examples

use fixed::{
    types::extra::{U0, U4, U6},
    types::I16F16,
    FixedI128,
};
type Fix = FixedI128<U4>;

// 1.75 is 1.11 in binary
let src = Fix::from_bits(0b111 << (4 - 2));
let expected = I16F16::from_bits(0b111 << (16 - 2));
assert_eq!(src.overflowing_to_num::<I16F16>(), (expected, false));
type TooFewIntBits = FixedI128<U6>;
let wrapped = TooFewIntBits::from_bits(Fix::MAX.to_bits() << 2);
assert_eq!(Fix::MAX.overflowing_to_num::<TooFewIntBits>(), (wrapped, true));

// 2.5 is 10.1 in binary
let two_point_5 = Fix::from_bits(0b101 << (4 - 1));
assert_eq!(two_point_5.overflowing_to_num::<i32>(), (2, false));
let does_not_fit = FixedI128::<U0>::from_bits(-1);
let wrapped = 1u128.wrapping_neg();
assert_eq!(does_not_fit.overflowing_to_num::<u128>(), (wrapped, true));

// 1.625 is 1.101 in binary
let one_point_625 = Fix::from_bits(0b1101 << (4 - 3));
assert_eq!(one_point_625.overflowing_to_num::<f32>(), (1.625f32, false));

pub fn from_str_binary(src: &str) -> Result<FixedI128<Frac>, ParseFixedError>

Parses a string slice containing binary digits to return a fixed-point number.

Rounding is to the nearest, with ties rounded to even.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
// 1.75 is 1.11 in binary
let f = Fix::from_str_binary("1.11");
let check = Fix::from_bits(0b111 << (4 - 2));
assert_eq!(f, Ok(check));
let neg = Fix::from_str_binary("-1.11");
assert_eq!(neg, Ok(-check));

pub fn from_str_octal(src: &str) -> Result<FixedI128<Frac>, ParseFixedError>

Parses a string slice containing octal digits to return a fixed-point number.

Rounding is to the nearest, with ties rounded to even.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
// 1.75 is 1.11 in binary, 1.6 in octal
let f = Fix::from_str_octal("1.6");
let check = Fix::from_bits(0b111 << (4 - 2));
assert_eq!(f, Ok(check));
let neg = Fix::from_str_octal("-1.6");
assert_eq!(neg, Ok(-check));

pub fn from_str_hex(src: &str) -> Result<FixedI128<Frac>, ParseFixedError>

Parses a string slice containing hexadecimal digits to return a fixed-point number.

Rounding is to the nearest, with ties rounded to even.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
// 1.75 is 1.11 in binary, 1.C in hexadecimal
let f = Fix::from_str_hex("1.C");
let check = Fix::from_bits(0b111 << (4 - 2));
assert_eq!(f, Ok(check));
let neg = Fix::from_str_hex("-1.C");
assert_eq!(neg, Ok(-check));

pub fn saturating_from_str(
    src: &str
) -> Result<FixedI128<Frac>, ParseFixedError>

Parses a string slice containing decimal digits to return a fixed-point number, saturating on overflow.

Rounding is to the nearest, with ties rounded to even.

Examples

use fixed::types::I8F8;
assert_eq!(I8F8::saturating_from_str("9999"), Ok(I8F8::MAX));
assert_eq!(I8F8::saturating_from_str("-9999"), Ok(I8F8::MIN));

pub fn saturating_from_str_binary(
    src: &str
) -> Result<FixedI128<Frac>, ParseFixedError>

Parses a string slice containing binary digits to return a fixed-point number, saturating on overflow.

Rounding is to the nearest, with ties rounded to even.

Examples

use fixed::types::I8F8;
assert_eq!(I8F8::saturating_from_str_binary("101100111000"), Ok(I8F8::MAX));
assert_eq!(I8F8::saturating_from_str_binary("-101100111000"), Ok(I8F8::MIN));

pub fn saturating_from_str_octal(
    src: &str
) -> Result<FixedI128<Frac>, ParseFixedError>

Parses a string slice containing octal digits to return a fixed-point number, saturating on overflow.

Rounding is to the nearest, with ties rounded to even.

Examples

use fixed::types::I8F8;
assert_eq!(I8F8::saturating_from_str_octal("7777"), Ok(I8F8::MAX));
assert_eq!(I8F8::saturating_from_str_octal("-7777"), Ok(I8F8::MIN));

pub fn saturating_from_str_hex(
    src: &str
) -> Result<FixedI128<Frac>, ParseFixedError>

Prases a string slice containing hexadecimal digits to return a fixed-point number, saturating on overflow.

Rounding is to the nearest, with ties rounded to even.

Examples

use fixed::types::I8F8;
assert_eq!(I8F8::saturating_from_str_hex("FFFF"), Ok(I8F8::MAX));
assert_eq!(I8F8::saturating_from_str_hex("-FFFF"), Ok(I8F8::MIN));

pub fn wrapping_from_str(src: &str) -> Result<FixedI128<Frac>, ParseFixedError>

Parses a string slice containing decimal digits to return a fixed-point number, wrapping on overflow.

Rounding is to the nearest, with ties rounded to even.

Examples

use fixed::types::I8F8;
// 9999.5 = 15.5 + 256 × n
assert_eq!(I8F8::wrapping_from_str("9999.5"), Ok(I8F8::from_num(15.5)));
assert_eq!(I8F8::wrapping_from_str("-9999.5"), Ok(I8F8::from_num(-15.5)));

pub fn wrapping_from_str_binary(
    src: &str
) -> Result<FixedI128<Frac>, ParseFixedError>

Parses a string slice containing binary digits to return a fixed-point number, wrapping on overflow.

Rounding is to the nearest, with ties rounded to even.

Examples

use fixed::types::I8F8;
let check = I8F8::from_bits(0b1110001 << (8 - 1));
assert_eq!(I8F8::wrapping_from_str_binary("101100111000.1"), Ok(check));
assert_eq!(I8F8::wrapping_from_str_binary("-101100111000.1"), Ok(-check));

pub fn wrapping_from_str_octal(
    src: &str
) -> Result<FixedI128<Frac>, ParseFixedError>

Parses a string slice containing octal digits to return a fixed-point number, wrapping on overflow.

Rounding is to the nearest, with ties rounded to even.

Examples

use fixed::types::I8F8;
let check = I8F8::from_bits(0o1654 << (8 - 3));
assert_eq!(I8F8::wrapping_from_str_octal("7165.4"), Ok(check));
assert_eq!(I8F8::wrapping_from_str_octal("-7165.4"), Ok(-check));

pub fn wrapping_from_str_hex(
    src: &str
) -> Result<FixedI128<Frac>, ParseFixedError>

Parses a string slice containing hexadecimal digits to return a fixed-point number, wrapping on overflow.

Rounding is to the nearest, with ties rounded to even.

Examples

use fixed::types::I8F8;
let check = I8F8::from_bits(0xFFE);
assert_eq!(I8F8::wrapping_from_str_hex("C0F.FE"), Ok(check));
assert_eq!(I8F8::wrapping_from_str_hex("-C0F.FE"), Ok(-check));

pub fn overflowing_from_str(
    src: &str
) -> Result<(FixedI128<Frac>, bool), ParseFixedError>

Parses a string slice containing decimal digits to return a fixed-point number.

Returns a tuple of the fixed-point number and a bool indicating whether an overflow has occurred. On overflow, the wrapped value is returned.

Rounding is to the nearest, with ties rounded to even.

Examples

use fixed::types::I8F8;
assert_eq!(I8F8::overflowing_from_str("99.5"), Ok((I8F8::from_num(99.5), false)));
// 9999.5 = 15.5 + 256 × n
assert_eq!(I8F8::overflowing_from_str("-9999.5"), Ok((I8F8::from_num(-15.5), true)));

pub fn overflowing_from_str_binary(
    src: &str
) -> Result<(FixedI128<Frac>, bool), ParseFixedError>

Parses a string slice containing binary digits to return a fixed-point number.

Returns a tuple of the fixed-point number and a bool indicating whether an overflow has occurred. On overflow, the wrapped value is returned.

Rounding is to the nearest, with ties rounded to even.

Examples

use fixed::types::I8F8;
let check = I8F8::from_bits(0b1110001 << (8 - 1));
assert_eq!(I8F8::overflowing_from_str_binary("111000.1"), Ok((check, false)));
assert_eq!(I8F8::overflowing_from_str_binary("-101100111000.1"), Ok((-check, true)));

pub fn overflowing_from_str_octal(
    src: &str
) -> Result<(FixedI128<Frac>, bool), ParseFixedError>

Parses a string slice containing octal digits to return a fixed-point number.

Returns a tuple of the fixed-point number and a bool indicating whether an overflow has occurred. On overflow, the wrapped value is returned.

Rounding is to the nearest, with ties rounded to even.

Examples

use fixed::types::I8F8;
let check = I8F8::from_bits(0o1654 << (8 - 3));
assert_eq!(I8F8::overflowing_from_str_octal("165.4"), Ok((check, false)));
assert_eq!(I8F8::overflowing_from_str_octal("-7165.4"), Ok((-check, true)));

pub fn overflowing_from_str_hex(
    src: &str
) -> Result<(FixedI128<Frac>, bool), ParseFixedError>

Parses a string slice containing hexadecimal digits to return a fixed-point number.

Returns a tuple of the fixed-point number and a bool indicating whether an overflow has occurred. On overflow, the wrapped value is returned.

Rounding is to the nearest, with ties rounded to even.

Examples

use fixed::types::I8F8;
let check = I8F8::from_bits(0xFFE);
assert_eq!(I8F8::overflowing_from_str_hex("F.FE"), Ok((check, false)));
assert_eq!(I8F8::overflowing_from_str_hex("-C0F.FE"), Ok((-check, true)));

pub fn int(self) -> FixedI128<Frac>

Returns the integer part.

Note that since the numbers are stored in two’s complement, negative numbers with non-zero fractional parts will be rounded towards −∞, except in the case where there are no integer bits, that is FixedI128<U128>, where the return value is always zero.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
// 0010.0000
let two = Fix::from_num(2);
// 0010.0100
let two_and_quarter = two + two / 8;
assert_eq!(two_and_quarter.int(), two);
// 1101.0000
let three = Fix::from_num(3);
// 1101.1100
assert_eq!((-two_and_quarter).int(), -three);

pub fn frac(self) -> FixedI128<Frac>

Returns the fractional part.

Note that since the numbers are stored in two’s complement, the returned fraction will be non-negative for negative numbers, except in the case where there are no integer bits, that is FixedI128<U128> where the return value is always equal to self.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
// 0000.0100
let quarter = Fix::from_num(1) / 4;
// 0010.0100
let two_and_quarter = quarter * 9;
assert_eq!(two_and_quarter.frac(), quarter);
// 0000.1100
let three_quarters = quarter * 3;
// 1101.1100
assert_eq!((-two_and_quarter).frac(), three_quarters);

pub fn round_to_zero(self) -> FixedI128<Frac>

Rounds to the next integer towards 0.

Note that for negative numbers, this is different from truncating/discarding the fractional bits. This is because in two’s-complement representations, the value of all the bits except for the most significant bit is positive; discarding positive bits would round towards −∞ unlike this method which rounds towards zero.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
assert_eq!(Fix::from_num(2.1).round_to_zero(), Fix::from_num(2));
assert_eq!(Fix::from_num(2.9).round_to_zero(), Fix::from_num(2));
assert_eq!(Fix::from_num(-2.1).round_to_zero(), Fix::from_num(-2));
assert_eq!(Fix::from_num(-2.9).round_to_zero(), Fix::from_num(-2));

pub fn ceil(self) -> FixedI128<Frac>

Rounds to the next integer towards +∞.

Panics

When debug assertions are enabled, panics if the result does not fit. When debug assertions are not enabled, the wrapped result can be returned, but it is not considered a breaking change if in the future it panics; if wrapping is required use wrapping_ceil instead.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
assert_eq!(Fix::from_num(2.5).ceil(), Fix::from_num(3));
assert_eq!(Fix::from_num(-2.5).ceil(), Fix::from_num(-2));

pub fn floor(self) -> FixedI128<Frac>

Rounds to the next integer towards −∞.

Panics

When debug assertions are enabled, panics if the result does not fit. When debug assertions are not enabled, the wrapped result can be returned, but it is not considered a breaking change if in the future it panics; if wrapping is required use wrapping_floor instead.

Overflow can only occur when there are zero integer bits.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
assert_eq!(Fix::from_num(2.5).floor(), Fix::from_num(2));
assert_eq!(Fix::from_num(-2.5).floor(), Fix::from_num(-3));

pub fn round(self) -> FixedI128<Frac>

Rounds to the nearest integer, with ties rounded away from zero.

Panics

When debug assertions are enabled, panics if the result does not fit. When debug assertions are not enabled, the wrapped result can be returned, but it is not considered a breaking change if in the future it panics; if wrapping is required use wrapping_round instead.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
assert_eq!(Fix::from_num(2.5).round(), Fix::from_num(3));
assert_eq!(Fix::from_num(-2.5).round(), Fix::from_num(-3));

pub fn round_ties_to_even(self) -> FixedI128<Frac>

Rounds to the nearest integer, with ties rounded to even.

Panics

When debug assertions are enabled, panics if the result does not fit. When debug assertions are not enabled, the wrapped result can be returned, but it is not considered a breaking change if in the future it panics; if wrapping is required use wrapping_round_ties_to_even instead.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
assert_eq!(Fix::from_num(2.5).round_ties_to_even(), Fix::from_num(2));
assert_eq!(Fix::from_num(3.5).round_ties_to_even(), Fix::from_num(4));

pub fn checked_ceil(self) -> Option<FixedI128<Frac>>

Checked ceil. Rounds to the next integer towards +∞, returning None on overflow.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
assert_eq!(Fix::from_num(2.5).checked_ceil(), Some(Fix::from_num(3)));
assert_eq!(Fix::from_num(-2.5).checked_ceil(), Some(Fix::from_num(-2)));
assert!(Fix::MAX.checked_ceil().is_none());

pub fn checked_floor(self) -> Option<FixedI128<Frac>>

Checked floor. Rounds to the next integer towards −∞.Returns None on overflow.

Overflow can only occur when there are zero integer bits.

Examples

use fixed::{
    types::extra::{U4, U128},
    FixedI128,
};
type Fix = FixedI128<U4>;
assert_eq!(Fix::from_num(2.5).checked_floor(), Some(Fix::from_num(2)));
assert_eq!(Fix::from_num(-2.5).checked_floor(), Some(Fix::from_num(-3)));
type AllFrac = FixedI128<U128>;
assert!(AllFrac::MIN.checked_floor().is_none());

pub fn checked_round(self) -> Option<FixedI128<Frac>>

Checked round. Rounds to the nearest integer, with ties rounded away from zero, returning None on overflow.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
assert_eq!(Fix::from_num(2.5).checked_round(), Some(Fix::from_num(3)));
assert_eq!(Fix::from_num(-2.5).checked_round(), Some(Fix::from_num(-3)));
assert!(Fix::MAX.checked_round().is_none());

pub fn checked_round_ties_to_even(self) -> Option<FixedI128<Frac>>

Checked round. Rounds to the nearest integer, with ties rounded to even, returning None on overflow.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
assert_eq!(Fix::from_num(2.5).checked_round_ties_to_even(), Some(Fix::from_num(2)));
assert_eq!(Fix::from_num(3.5).checked_round_ties_to_even(), Some(Fix::from_num(4)));
assert!(Fix::MAX.checked_round_ties_to_even().is_none());

pub fn saturating_ceil(self) -> FixedI128<Frac>

Saturating ceil. Rounds to the next integer towards +∞, saturating on overflow.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
assert_eq!(Fix::from_num(2.5).saturating_ceil(), Fix::from_num(3));
assert_eq!(Fix::from_num(-2.5).saturating_ceil(), Fix::from_num(-2));
assert_eq!(Fix::MAX.saturating_ceil(), Fix::MAX);

pub fn saturating_floor(self) -> FixedI128<Frac>

Saturating floor. Rounds to the next integer towards −∞, saturating on overflow.

Overflow can only occur when there are zero integer bits.

Examples

use fixed::{
    types::extra::{U4, U128},
    FixedI128,
};
type Fix = FixedI128<U4>;
assert_eq!(Fix::from_num(2.5).saturating_floor(), Fix::from_num(2));
assert_eq!(Fix::from_num(-2.5).saturating_floor(), Fix::from_num(-3));
type AllFrac = FixedI128<U128>;
assert_eq!(AllFrac::MIN.saturating_floor(), AllFrac::MIN);

pub fn saturating_round(self) -> FixedI128<Frac>

Saturating round. Rounds to the nearest integer, with ties rounded away from zero, and saturating on overflow.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
assert_eq!(Fix::from_num(2.5).saturating_round(), Fix::from_num(3));
assert_eq!(Fix::from_num(-2.5).saturating_round(), Fix::from_num(-3));
assert_eq!(Fix::MAX.saturating_round(), Fix::MAX);

pub fn saturating_round_ties_to_even(self) -> FixedI128<Frac>

Saturating round. Rounds to the nearest integer, with ties rounded to even, and saturating on overflow.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
assert_eq!(Fix::from_num(2.5).saturating_round_ties_to_even(), Fix::from_num(2));
assert_eq!(Fix::from_num(3.5).saturating_round_ties_to_even(), Fix::from_num(4));
assert_eq!(Fix::MAX.saturating_round_ties_to_even(), Fix::MAX);

pub fn wrapping_ceil(self) -> FixedI128<Frac>

Wrapping ceil. Rounds to the next integer towards +∞, wrapping on overflow.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
assert_eq!(Fix::from_num(2.5).wrapping_ceil(), Fix::from_num(3));
assert_eq!(Fix::from_num(-2.5).wrapping_ceil(), Fix::from_num(-2));
assert_eq!(Fix::MAX.wrapping_ceil(), Fix::MIN);

pub fn wrapping_floor(self) -> FixedI128<Frac>

Wrapping floor. Rounds to the next integer towards −∞, wrapping on overflow.

Overflow can only occur when there are zero integer bits.

Examples

use fixed::{
    types::extra::{U4, U128},
    FixedI128,
};
type Fix = FixedI128<U4>;
assert_eq!(Fix::from_num(2.5).wrapping_floor(), Fix::from_num(2));
assert_eq!(Fix::from_num(-2.5).wrapping_floor(), Fix::from_num(-3));
type AllFrac = FixedI128<U128>;
assert_eq!(AllFrac::MIN.wrapping_floor(), AllFrac::from_num(0));

pub fn wrapping_round(self) -> FixedI128<Frac>

Wrapping round. Rounds to the next integer to the nearest, with ties rounded away from zero, and wrapping on overflow.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
assert_eq!(Fix::from_num(2.5).wrapping_round(), Fix::from_num(3));
assert_eq!(Fix::from_num(-2.5).wrapping_round(), Fix::from_num(-3));
assert_eq!(Fix::MAX.wrapping_round(), Fix::MIN);

pub fn wrapping_round_ties_to_even(self) -> FixedI128<Frac>

Wrapping round. Rounds to the next integer to the nearest, with ties rounded to even, and wrapping on overflow.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
assert_eq!(Fix::from_num(2.5).wrapping_round_ties_to_even(), Fix::from_num(2));
assert_eq!(Fix::from_num(3.5).wrapping_round_ties_to_even(), Fix::from_num(4));
assert_eq!(Fix::MAX.wrapping_round_ties_to_even(), Fix::MIN);

pub fn overflowing_ceil(self) -> (FixedI128<Frac>, bool)

Overflowing ceil. Rounds to the next integer towards +∞.

Returns a tuple of the fixed-point number and a bool, indicating whether an overflow has occurred. On overflow, the wrapped value is returned.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
assert_eq!(Fix::from_num(2.5).overflowing_ceil(), (Fix::from_num(3), false));
assert_eq!(Fix::from_num(-2.5).overflowing_ceil(), (Fix::from_num(-2), false));
assert_eq!(Fix::MAX.overflowing_ceil(), (Fix::MIN, true));

pub fn overflowing_floor(self) -> (FixedI128<Frac>, bool)

Overflowing floor. Rounds to the next integer towards −∞.

Returns a tuple of the fixed-point number and a bool, indicating whether an overflow has occurred. On overflow, the wrapped value isreturned. Overflow can only occur when there are zero integer bits.

Examples

use fixed::{
    types::extra::{U4, U128},
    FixedI128,
};
type Fix = FixedI128<U4>;
assert_eq!(Fix::from_num(2.5).overflowing_floor(), (Fix::from_num(2), false));
assert_eq!(Fix::from_num(-2.5).overflowing_floor(), (Fix::from_num(-3), false));
type AllFrac = FixedI128<U128>;
assert_eq!(AllFrac::MIN.overflowing_floor(), (AllFrac::from_num(0), true));

pub fn overflowing_round(self) -> (FixedI128<Frac>, bool)

Overflowing round. Rounds to the next integer to the nearest, with ties rounded away from zero.

Returns a tuple of the fixed-point number and a bool indicating whether an overflow has occurred. On overflow, the wrapped value is returned.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
assert_eq!(Fix::from_num(2.5).overflowing_round(), (Fix::from_num(3), false));
assert_eq!(Fix::from_num(-2.5).overflowing_round(), (Fix::from_num(-3), false));
assert_eq!(Fix::MAX.overflowing_round(), (Fix::MIN, true));

pub fn overflowing_round_ties_to_even(self) -> (FixedI128<Frac>, bool)

Overflowing round. Rounds to the next integer to the nearest, with ties rounded to even.

Returns a tuple of the fixed-point number and a bool indicating whether an overflow has occurred. On overflow, the wrapped value is returned.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
assert_eq!(Fix::from_num(2.5).overflowing_round_ties_to_even(), (Fix::from_num(2), false));
assert_eq!(Fix::from_num(3.5).overflowing_round_ties_to_even(), (Fix::from_num(4), false));
assert_eq!(Fix::MAX.overflowing_round_ties_to_even(), (Fix::MIN, true));

pub fn int_log2(self) -> i32

Integer base-2 logarithm, rounded down.

Panics

Panics if the fixed-point number is ≤ 0.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
assert_eq!(Fix::from_num(4).int_log2(), 2);
assert_eq!(Fix::from_num(3.9375).int_log2(), 1);
assert_eq!(Fix::from_num(0.25).int_log2(), -2);
assert_eq!(Fix::from_num(0.1875).int_log2(), -3);

pub fn int_log10(self) -> i32

Integer base-10 logarithm, rounded down.

Panics

Panics if the fixed-point number is ≤ 0.

Examples

use fixed::{
    types::extra::{U2, U6},
    FixedI128,
};
assert_eq!(FixedI128::<U2>::from_num(10).int_log10(), 1);
assert_eq!(FixedI128::<U2>::from_num(9.75).int_log10(), 0);
assert_eq!(FixedI128::<U6>::from_num(0.109375).int_log10(), -1);
assert_eq!(FixedI128::<U6>::from_num(0.09375).int_log10(), -2);

pub fn checked_int_log2(self) -> Option<i32>

Checked integer base-2 logarithm, rounded down. Returns the logarithm or None if the fixed-point number is ≤ 0.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
assert_eq!(Fix::from_num(0).checked_int_log2(), None);
assert_eq!(Fix::from_num(4).checked_int_log2(), Some(2));
assert_eq!(Fix::from_num(3.9375).checked_int_log2(), Some(1));
assert_eq!(Fix::from_num(0.25).checked_int_log2(), Some(-2));
assert_eq!(Fix::from_num(0.1875).checked_int_log2(), Some(-3));

pub fn checked_int_log10(self) -> Option<i32>

Checked integer base-10 logarithm, rounded down. Returns the logarithm or None if the fixed-point number is ≤ 0.

Examples

use fixed::{
    types::extra::{U2, U6},
    FixedI128,
};
assert_eq!(FixedI128::<U2>::from_num(0).checked_int_log10(), None);
assert_eq!(FixedI128::<U2>::from_num(10).checked_int_log10(), Some(1));
assert_eq!(FixedI128::<U2>::from_num(9.75).checked_int_log10(), Some(0));
assert_eq!(FixedI128::<U6>::from_num(0.109375).checked_int_log10(), Some(-1));
assert_eq!(FixedI128::<U6>::from_num(0.09375).checked_int_log10(), Some(-2));

pub fn signum(self) -> FixedI128<Frac>

Returns a number representing the sign of self.

Panics

When debug assertions are enabled, this method panics

• if the value is positive and the fixed-point number has zero or one integer bits such that it cannot hold the value 1.
• if the value is negative and the fixed-point number has zero integer bits, such that it cannot hold the value −1.

When debug assertions are not enabled, the wrapped value can be returned in those cases, but it is not considered a breaking change if in the future it panics; using this method when 1 and −1 cannot be represented is almost certainly a bug.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
assert_eq!(Fix::from_num(5).signum(), 1);
assert_eq!(Fix::from_num(0).signum(), 0);
assert_eq!(Fix::from_num(-5).signum(), -1);

pub fn div_euclid(self, rhs: FixedI128<Frac>) -> FixedI128<Frac>

Euclidean division.

Panics

Panics if the divisor is zero.

When debug assertions are enabled, this method also panics if the division overflows. When debug assertions are not enabled, the wrapped value can be returned, but it is not considered a breaking change if in the future it panics; if wrapping is required use wrapping_div_euclid instead.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
assert_eq!(Fix::from_num(7.5).div_euclid(Fix::from_num(2)), Fix::from_num(3));
assert_eq!(Fix::from_num(-7.5).div_euclid(Fix::from_num(2)), Fix::from_num(-4));

pub fn div_euclid_int(self, rhs: i128) -> FixedI128<Frac>

Euclidean division by an integer.

Panics

Panics if the divisor is zero.

When debug assertions are enabled, this method also panics if the division overflows. Overflow can only occur when dividing the minimum value by −1. When debug assertions are not enabled, the wrapped value can be returned, but it is not considered a breaking change if in the future it panics; if wrapping is required use wrapping_div_euclid_int instead.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
assert_eq!(Fix::from_num(7.5).div_euclid_int(2), Fix::from_num(3));
assert_eq!(Fix::from_num(-7.5).div_euclid_int(2), Fix::from_num(-4));

pub fn rem_euclid_int(self, rhs: i128) -> FixedI128<Frac>

Remainder for Euclidean division by an integer.

Panics

Panics if the divisor is zero.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
assert_eq!(Fix::from_num(7.5).rem_euclid_int(2), Fix::from_num(1.5));
assert_eq!(Fix::from_num(-7.5).rem_euclid_int(2), Fix::from_num(0.5));

pub fn checked_signum(self) -> Option<FixedI128<Frac>>

Checked signum. Returns a number representing the sign of self, or None on overflow.

Overflow can only occur

• if the value is positive and the fixed-point number has zero or one integer bits such that it cannot hold the value 1.
• if the value is negative and the fixed-point number has zero integer bits, such that it cannot hold the value −1.

Examples

use fixed::{
    types::extra::{U4, U127, U128},
    FixedI128,
};
type Fix = FixedI128<U4>;
assert_eq!(Fix::from_num(5).checked_signum(), Some(Fix::from_num(1)));
assert_eq!(Fix::from_num(0).checked_signum(), Some(Fix::from_num(0)));
assert_eq!(Fix::from_num(-5).checked_signum(), Some(Fix::from_num(-1)));

type OneIntBit = FixedI128<U127>;
type ZeroIntBits = FixedI128<U128>;
assert_eq!(OneIntBit::from_num(0.5).checked_signum(), None);
assert_eq!(ZeroIntBits::from_num(0.25).checked_signum(), None);
assert_eq!(ZeroIntBits::from_num(-0.5).checked_signum(), None);

pub fn checked_mul(self, rhs: FixedI128<Frac>) -> Option<FixedI128<Frac>>

Checked multiplication. Returns the product, or None on overflow.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
assert_eq!(Fix::MAX.checked_mul(Fix::from_num(1)), Some(Fix::MAX));
assert_eq!(Fix::MAX.checked_mul(Fix::from_num(2)), None);

pub fn checked_div(self, rhs: FixedI128<Frac>) -> Option<FixedI128<Frac>>

Checked division. Returns the quotient, or None if the divisor is zero or on overflow.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
assert_eq!(Fix::MAX.checked_div(Fix::from_num(1)), Some(Fix::MAX));
assert_eq!(Fix::MAX.checked_div(Fix::from_num(1) / 2), None);

pub fn checked_div_euclid(self, rhs: FixedI128<Frac>) -> Option<FixedI128<Frac>>

Checked Euclidean division. Returns the quotient, or None if the divisor is zero or on overflow.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
assert_eq!(Fix::from_num(7.5).checked_div_euclid(Fix::from_num(2)), Some(Fix::from_num(3)));
assert_eq!(Fix::from_num(7.5).checked_div_euclid(Fix::from_num(0)), None);
assert_eq!(Fix::MAX.checked_div_euclid(Fix::from_num(0.25)), None);
assert_eq!(Fix::from_num(-7.5).checked_div_euclid(Fix::from_num(2)), Some(Fix::from_num(-4)));

pub fn checked_rem_int(self, rhs: i128) -> Option<FixedI128<Frac>>

Checked fixed-point remainder for division by an integer. Returns the remainder, or None if the divisor is zero.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
assert_eq!(Fix::from_num(3.75).checked_rem_int(2), Some(Fix::from_num(1.75)));
assert_eq!(Fix::from_num(3.75).checked_rem_int(0), None);
assert_eq!(Fix::from_num(-3.75).checked_rem_int(2), Some(Fix::from_num(-1.75)));

pub fn checked_div_euclid_int(self, rhs: i128) -> Option<FixedI128<Frac>>

Checked Euclidean division by an integer. Returns the quotient, or None if the divisor is zero or if the division results in overflow.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
assert_eq!(Fix::from_num(7.5).checked_div_euclid_int(2), Some(Fix::from_num(3)));
assert_eq!(Fix::from_num(7.5).checked_div_euclid_int(0), None);
assert_eq!(Fix::MIN.checked_div_euclid_int(-1), None);

pub fn checked_rem_euclid_int(self, rhs: i128) -> Option<FixedI128<Frac>>

Checked remainder for Euclidean division by an integer. Returns the remainder, or None if the divisor is zero or if the remainder results in overflow.

Examples

use fixed::{types::extra::U124, FixedI128};
type Fix = FixedI128<U124>;
assert_eq!(Fix::from_num(7.5).checked_rem_euclid_int(2), Some(Fix::from_num(1.5)));
assert_eq!(Fix::from_num(7.5).checked_rem_euclid_int(0), None);
assert_eq!(Fix::from_num(-7.5).checked_rem_euclid_int(2), Some(Fix::from_num(0.5)));
// −8 ≤ Fix < 8, so the answer 12.5 overflows
assert_eq!(Fix::from_num(-7.5).checked_rem_euclid_int(20), None);

pub fn saturating_signum(self) -> FixedI128<Frac>

Saturating signum. Returns a number representing the sign of self, saturating on overflow.

Overflow can only occur

• if the value is positive and the fixed-point number has zero or one integer bits such that it cannot hold the value 1.
• if the value is negative and the fixed-point number has zero integer bits, such that it cannot hold the value −1.

Examples

use fixed::{
    types::extra::{U4, U127, U128},
    FixedI128,
};
type Fix = FixedI128<U4>;
assert_eq!(Fix::from_num(5).saturating_signum(), 1);
assert_eq!(Fix::from_num(0).saturating_signum(), 0);
assert_eq!(Fix::from_num(-5).saturating_signum(), -1);

type OneIntBit = FixedI128<U127>;
type ZeroIntBits = FixedI128<U128>;
assert_eq!(OneIntBit::from_num(0.5).saturating_signum(), OneIntBit::MAX);
assert_eq!(ZeroIntBits::from_num(0.25).saturating_signum(), ZeroIntBits::MAX);
assert_eq!(ZeroIntBits::from_num(-0.5).saturating_signum(), ZeroIntBits::MIN);

pub fn saturating_mul(self, rhs: FixedI128<Frac>) -> FixedI128<Frac>

Saturating multiplication. Returns the product, saturating on overflow.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
assert_eq!(Fix::from_num(3).saturating_mul(Fix::from_num(2)), Fix::from_num(6));
assert_eq!(Fix::MAX.saturating_mul(Fix::from_num(2)), Fix::MAX);

pub fn saturating_div(self, rhs: FixedI128<Frac>) -> FixedI128<Frac>

Saturating division. Returns the quotient, saturating on overflow.

Panics

Panics if the divisor is zero.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
let one_half = Fix::from_num(1) / 2;
assert_eq!(Fix::from_num(1).saturating_div(Fix::from_num(2)), one_half);
assert_eq!(Fix::MAX.saturating_div(one_half), Fix::MAX);

pub fn saturating_div_euclid(self, rhs: FixedI128<Frac>) -> FixedI128<Frac>

Saturating Euclidean division. Returns the quotient, saturating on overflow.

Panics

Panics if the divisor is zero.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
assert_eq!(Fix::from_num(7.5).saturating_div_euclid(Fix::from_num(2)), Fix::from_num(3));
assert_eq!(Fix::MAX.saturating_div_euclid(Fix::from_num(0.25)), Fix::MAX);
assert_eq!(Fix::from_num(-7.5).saturating_div_euclid(Fix::from_num(2)), Fix::from_num(-4));
assert_eq!(Fix::MIN.saturating_div_euclid(Fix::from_num(0.25)), Fix::MIN);

pub fn wrapping_signum(self) -> FixedI128<Frac>

Wrapping signum. Returns a number representing the sign of self, wrapping on overflow.

Overflow can only occur

• if the value is positive and the fixed-point number has zero or one integer bits such that it cannot hold the value 1.
• if the value is negative and the fixed-point number has zero integer bits, such that it cannot hold the value −1.

Examples

use fixed::{
    types::extra::{U4, U127, U128},
    FixedI128,
};
type Fix = FixedI128<U4>;
assert_eq!(Fix::from_num(5).wrapping_signum(), 1);
assert_eq!(Fix::from_num(0).wrapping_signum(), 0);
assert_eq!(Fix::from_num(-5).wrapping_signum(), -1);

type OneIntBit = FixedI128<U127>;
type ZeroIntBits = FixedI128<U128>;
assert_eq!(OneIntBit::from_num(0.5).wrapping_signum(), -1);
assert_eq!(ZeroIntBits::from_num(0.25).wrapping_signum(), 0);
assert_eq!(ZeroIntBits::from_num(-0.5).wrapping_signum(), 0);

pub fn wrapping_mul(self, rhs: FixedI128<Frac>) -> FixedI128<Frac>

Wrapping multiplication. Returns the product, wrapping on overflow.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
assert_eq!(Fix::from_num(3).wrapping_mul(Fix::from_num(2)), Fix::from_num(6));
let wrapped = Fix::from_bits(!0 << 2);
assert_eq!(Fix::MAX.wrapping_mul(Fix::from_num(4)), wrapped);

pub fn wrapping_div(self, rhs: FixedI128<Frac>) -> FixedI128<Frac>

Wrapping division. Returns the quotient, wrapping on overflow.

Panics

Panics if the divisor is zero.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
let one_point_5 = Fix::from_bits(0b11 << (4 - 1));
assert_eq!(Fix::from_num(3).wrapping_div(Fix::from_num(2)), one_point_5);
let quarter = Fix::from_num(1) / 4;
let wrapped = Fix::from_bits(!0 << 2);
assert_eq!(Fix::MAX.wrapping_div(quarter), wrapped);

pub fn wrapping_div_euclid(self, rhs: FixedI128<Frac>) -> FixedI128<Frac>

Wrapping Euclidean division. Returns the quotient, wrapping on overflow.

Panics

Panics if the divisor is zero.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
assert_eq!(Fix::from_num(7.5).wrapping_div_euclid(Fix::from_num(2)), Fix::from_num(3));
let wrapped = Fix::MAX.wrapping_mul_int(4).round_to_zero();
assert_eq!(Fix::MAX.wrapping_div_euclid(Fix::from_num(0.25)), wrapped);

pub fn wrapping_div_euclid_int(self, rhs: i128) -> FixedI128<Frac>

Wrapping Euclidean division by an integer. Returns the quotient, wrapping on overflow.

Overflow can only occur when dividing the minimum value by −1.

Panics

Panics if the divisor is zero.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
assert_eq!(Fix::from_num(7.5).wrapping_div_euclid_int(2), Fix::from_num(3));
assert_eq!(Fix::from_num(-7.5).wrapping_div_euclid_int(2), Fix::from_num(-4));
let wrapped = Fix::MIN.round_to_zero();
assert_eq!(Fix::MIN.wrapping_div_euclid_int(-1), wrapped);

pub fn wrapping_rem_euclid_int(self, rhs: i128) -> FixedI128<Frac>

Wrapping remainder for Euclidean division by an integer. Returns the remainder, wrapping on overflow.

Note that while remainder for Euclidean division cannot be negative, the wrapped value can be negative.

Panics

Panics if the divisor is zero.

Examples

use fixed::{types::extra::U124, FixedI128};
type Fix = FixedI128<U124>;
assert_eq!(Fix::from_num(7.5).wrapping_rem_euclid_int(2), Fix::from_num(1.5));
assert_eq!(Fix::from_num(-7.5).wrapping_rem_euclid_int(2), Fix::from_num(0.5));
// −8 ≤ Fix < 8, so the answer 12.5 wraps to −3.5
assert_eq!(Fix::from_num(-7.5).wrapping_rem_euclid_int(20), Fix::from_num(-3.5));

pub fn overflowing_signum(self) -> (FixedI128<Frac>, bool)

Overflowing signum.

Returns a tuple of the signum and a bool indicating whether an overflow has occurred. On overflow, the wrapped value is returned.

Overflow can only occur

• if the value is positive and the fixed-point number has zero or one integer bits such that it cannot hold the value 1.
• if the value is negative and the fixed-point number has zero integer bits, such that it cannot hold the value −1.

Examples

use fixed::{
    types::extra::{U4, U127, U128},
    FixedI128,
};
type Fix = FixedI128<U4>;
assert_eq!(Fix::from_num(5).overflowing_signum(), (Fix::from_num(1), false));
assert_eq!(Fix::from_num(0).overflowing_signum(), (Fix::from_num(0), false));
assert_eq!(Fix::from_num(-5).overflowing_signum(), (Fix::from_num(-1), false));

type OneIntBit = FixedI128<U127>;
type ZeroIntBits = FixedI128<U128>;
assert_eq!(OneIntBit::from_num(0.5).overflowing_signum(), (OneIntBit::from_num(-1), true));
assert_eq!(ZeroIntBits::from_num(0.25).overflowing_signum(), (ZeroIntBits::from_num(0), true));
assert_eq!(ZeroIntBits::from_num(-0.5).overflowing_signum(), (ZeroIntBits::from_num(0), true));

pub fn overflowing_mul(self, rhs: FixedI128<Frac>) -> (FixedI128<Frac>, bool)

Overflowing multiplication.

Returns a tuple of the product and a bool indicating whether an overflow has occurred. On overflow, the wrapped value is returned.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
assert_eq!(Fix::from_num(3).overflowing_mul(Fix::from_num(2)), (Fix::from_num(6), false));
let wrapped = Fix::from_bits(!0 << 2);
assert_eq!(Fix::MAX.overflowing_mul(Fix::from_num(4)), (wrapped, true));

pub fn overflowing_div(self, rhs: FixedI128<Frac>) -> (FixedI128<Frac>, bool)

Overflowing division.

Returns a tuple of the quotient and a bool indicating whether an overflow has occurred. On overflow, the wrapped value is returned.

Panics

Panics if the divisor is zero.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
let one_point_5 = Fix::from_bits(0b11 << (4 - 1));
assert_eq!(Fix::from_num(3).overflowing_div(Fix::from_num(2)), (one_point_5, false));
let quarter = Fix::from_num(1) / 4;
let wrapped = Fix::from_bits(!0 << 2);
assert_eq!(Fix::MAX.overflowing_div(quarter), (wrapped, true));

pub fn overflowing_div_euclid(
    self,
    rhs: FixedI128<Frac>
) -> (FixedI128<Frac>, bool)

Overflowing Euclidean division.

Returns a tuple of the quotient and a bool indicating whether an overflow has occurred. On overflow, the wrapped value is returned.

Panics

Panics if the divisor is zero.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
let check = Fix::from_num(3);
assert_eq!(Fix::from_num(7.5).overflowing_div_euclid(Fix::from_num(2)), (check, false));
let wrapped = Fix::MAX.wrapping_mul_int(4).round_to_zero();
assert_eq!(Fix::MAX.overflowing_div_euclid(Fix::from_num(0.25)), (wrapped, true));

pub fn overflowing_div_euclid_int(self, rhs: i128) -> (FixedI128<Frac>, bool)

Overflowing Euclidean division by an integer.

Returns a tuple of the quotient and a bool indicating whether an overflow has occurred. On overflow, the wrapped value is returned. Overflow can only occur when dividing the minimum value by −1.

Panics

Panics if the divisor is zero.

Examples

use fixed::{types::extra::U4, FixedI128};
type Fix = FixedI128<U4>;
assert_eq!(Fix::from_num(7.5).overflowing_div_euclid_int(2), (Fix::from_num(3), false));
assert_eq!(Fix::from_num(-7.5).overflowing_div_euclid_int(2), (Fix::from_num(-4), false));
let wrapped = Fix::MIN.round_to_zero();
assert_eq!(Fix::MIN.overflowing_div_euclid_int(-1), (wrapped, true));

pub fn overflowing_rem_euclid_int(self, rhs: i128) -> (FixedI128<Frac>, bool)

Remainder for Euclidean division by an integer.

Returns a tuple of the remainder and a bool indicating whether an overflow has occurred. On overflow, the wrapped value is returned.

Note that while remainder for Euclidean division cannot be negative, the wrapped value can be negative.

Panics

Panics if the divisor is zero.

Examples

use fixed::{types::extra::U124, FixedI128};
type Fix = FixedI128<U124>;
assert_eq!(Fix::from_num(7.5).overflowing_rem_euclid_int(2), (Fix::from_num(1.5), false));
assert_eq!(Fix::from_num(-7.5).overflowing_rem_euclid_int(2), (Fix::from_num(0.5), false));
// −8 ≤ Fix < 8, so the answer 12.5 wraps to −3.5
assert_eq!(Fix::from_num(-7.5).overflowing_rem_euclid_int(20), (Fix::from_num(-3.5), true));

pub fn int_nbits() -> u32

Deprecated since 0.5.5:

use INT_NBITS instead

Returns the number of integer bits.

pub fn frac_nbits() -> u32

Deprecated since 0.5.5:

use FRAC_NBITS instead

Returns the number of fractional bits.

pub fn wrapping_rem_int(self, rhs: i128) -> FixedI128<Frac>

Deprecated since 0.5.3:

cannot overflow, use % or Rem::rem instead

Remainder for division by an integer.

Panics

Panics if the divisor is zero.

pub fn overflowing_rem_int(self, rhs: i128) -> (FixedI128<Frac>, bool)

Deprecated since 0.5.3:

cannot overflow, use % or Rem::rem instead

Remainder for division by an integer.

Panics

Panics if the divisor is zero.

impl<Frac: LeEqU128> FixedI128<Frac>

This block contains constants in the range 0 ≤ x < 0.5.

Examples

use fixed::{consts, types::extra::U128, FixedI128};
type Fix = FixedI128<U128>;
assert_eq!(Fix::LOG10_2, Fix::from_num(consts::LOG10_2));

pub const FRAC_1_TAU: FixedI128<Frac>

1/τ = 0.159154…

pub const FRAC_2_TAU: FixedI128<Frac>

2/τ = 0.318309…

pub const FRAC_PI_8: FixedI128<Frac>

π/8 = 0.392699…

pub const FRAC_1_PI: FixedI128<Frac>

1/π = 0.318309…

pub const LOG10_2: FixedI128<Frac>

log₁₀ 2 = 0.301029…

pub const LOG10_E: FixedI128<Frac>

log₁₀ e = 0.434294…

impl<Frac: Unsigned> FixedI128<Frac> where
    Frac: IsLessOrEqual<U127, Output = True>, 

This block contains constants in the range 0.5 ≤ x < 1.

These constants are not representable in signed fixed-point numbers with less than 1 integer bit.

Examples

use fixed::{consts, types::extra::U127, FixedI128};
type Fix = FixedI128<U127>;
assert_eq!(Fix::LN_2, Fix::from_num(consts::LN_2));
assert!(0.5 <= Fix::LN_2 && Fix::LN_2 < 1);

The following example fails to compile, since the maximum representable value with 128 fractional bits and 0 integer bits is < 0.5.

use fixed::{consts, types::extra::U128, FixedI128};
type Fix = FixedI128<U128>;
let _ = Fix::LN_2;

pub const FRAC_TAU_8: FixedI128<Frac>

τ/8 = 0.785398…

pub const FRAC_TAU_12: FixedI128<Frac>

τ/12 = 0.523598…

pub const FRAC_4_TAU: FixedI128<Frac>

4/τ = 0.636619…

pub const FRAC_PI_4: FixedI128<Frac>

π/4 = 0.785398…

pub const FRAC_PI_6: FixedI128<Frac>

π/6 = 0.523598…

pub const FRAC_2_PI: FixedI128<Frac>

2/π = 0.636619…

pub const FRAC_1_SQRT_2: FixedI128<Frac>

1/√2 = 0.707106…

pub const LN_2: FixedI128<Frac>

ln 2 = 0.693147…

pub const FRAC_1_PHI: FixedI128<Frac>

The golden ratio conjugate, Φ = 1/φ = 0.618033…

impl<Frac: Unsigned> FixedI128<Frac> where
    Frac: IsLessOrEqual<U126, Output = True>, 

This block contains constants in the range 1 ≤ x < 2.

These constants are not representable in signed fixed-point numbers with less than 2 integer bits.

Examples

use fixed::{consts, types::extra::U126, FixedI128};
type Fix = FixedI128<U126>;
assert_eq!(Fix::LOG2_E, Fix::from_num(consts::LOG2_E));
assert!(1 <= Fix::LOG2_E && Fix::LOG2_E < 2);

The following example fails to compile, since the maximum representable value with 127 fractional bits and 1 integer bit is < 1.

use fixed::{consts, types::extra::U127, FixedI128};
type Fix = FixedI128<U127>;
let _ = Fix::LOG2_E;

pub const FRAC_TAU_4: FixedI128<Frac>

τ/4 = 1.57079…

pub const FRAC_TAU_6: FixedI128<Frac>

τ/6 = 1.04719…

pub const FRAC_PI_2: FixedI128<Frac>

π/2 = 1.57079…

pub const FRAC_PI_3: FixedI128<Frac>

π/3 = 1.04719…

pub const FRAC_2_SQRT_PI: FixedI128<Frac>

2/√π = 1.12837…

pub const SQRT_2: FixedI128<Frac>

√2 = 1.41421…

pub const LOG2_E: FixedI128<Frac>

log₂ e = 1.44269…

pub const PHI: FixedI128<Frac>

The golden ratio, φ = 1.61803…

impl<Frac: Unsigned> FixedI128<Frac> where
    Frac: IsLessOrEqual<U125, Output = True>, 

This block contains constants in the range 2 ≤ x < 4.

These constants are not representable in signed fixed-point numbers with less than 3 integer bits.

Examples

use fixed::{consts, types::extra::U125, FixedI128};
type Fix = FixedI128<U125>;
assert_eq!(Fix::E, Fix::from_num(consts::E));
assert!(2 <= Fix::E && Fix::E < 4);

The following example fails to compile, since the maximum representable value with 126 fractional bits and 2 integer bits is < 2.

use fixed::{consts, types::extra::U126, FixedI128};
type Fix = FixedI128<U126>;
let _ = Fix::E;

pub const FRAC_TAU_2: FixedI128<Frac>

τ/2 = 3.14159…

pub const FRAC_TAU_3: FixedI128<Frac>

τ/3 = 2.09439…

pub const PI: FixedI128<Frac>

Archimedes’ constant, π = 3.14159…

pub const E: FixedI128<Frac>

Euler’s number, e = 2.71828…

pub const LOG2_10: FixedI128<Frac>

log₂ 10 = 3.32192…

pub const LN_10: FixedI128<Frac>

ln 10 = 2.30258…

impl<Frac: Unsigned> FixedI128<Frac> where
    Frac: IsLessOrEqual<U124, Output = True>, 

This block contains constants in the range 4 ≤ x < 8.

These constants are not representable in signed fixed-point numbers with less than 4 integer bits.

Examples

use fixed::{consts, types::extra::U124, FixedI128};
type Fix = FixedI128<U124>;
assert_eq!(Fix::TAU, Fix::from_num(consts::TAU));
assert!(4 <= Fix::TAU && Fix::TAU < 8);

The following example fails to compile, since the maximum representable value with 125 fractional bits and 3 integer bits is < 4.

use fixed::{consts, types::extra::U125, FixedI128};
type Fix = FixedI128<U125>;
let _ = Fix::TAU;

pub const TAU: FixedI128<Frac>

A turn, τ = 6.28318…

Trait Implementations

impl<'a, Frac> Add<&'a FixedI128<Frac>> for FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the + operator.

fn add(self, rhs: &FixedI128<Frac>) -> FixedI128<Frac>

Performs the + operation.

impl<'a, 'b, Frac> Add<&'a FixedI128<Frac>> for &'b FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the + operator.

fn add(self, rhs: &FixedI128<Frac>) -> FixedI128<Frac>

Performs the + operation.

impl<Frac> Add<FixedI128<Frac>> for FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the + operator.

fn add(self, rhs: FixedI128<Frac>) -> FixedI128<Frac>

Performs the + operation.

impl<'a, Frac> Add<FixedI128<Frac>> for &'a FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the + operator.

fn add(self, rhs: FixedI128<Frac>) -> FixedI128<Frac>

Performs the + operation.

impl<'a, Frac> AddAssign<&'a FixedI128<Frac>> for FixedI128<Frac>

fn add_assign(&mut self, rhs: &FixedI128<Frac>)

Performs the += operation.

impl<Frac> AddAssign<FixedI128<Frac>> for FixedI128<Frac>

fn add_assign(&mut self, rhs: FixedI128<Frac>)

Performs the += operation.

impl<Frac: LeEqU128> Binary for FixedI128<Frac>

fn fmt(&self, f: &mut Formatter) -> FmtResult

Formats the value using the given formatter.

impl<'a, Frac> BitAnd<&'a FixedI128<Frac>> for FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the & operator.

fn bitand(self, rhs: &FixedI128<Frac>) -> FixedI128<Frac>

Performs the & operation.

impl<'a, 'b, Frac> BitAnd<&'a FixedI128<Frac>> for &'b FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the & operator.

fn bitand(self, rhs: &FixedI128<Frac>) -> FixedI128<Frac>

Performs the & operation.

impl<Frac> BitAnd<FixedI128<Frac>> for FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the & operator.

fn bitand(self, rhs: FixedI128<Frac>) -> FixedI128<Frac>

Performs the & operation.

impl<'a, Frac> BitAnd<FixedI128<Frac>> for &'a FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the & operator.

fn bitand(self, rhs: FixedI128<Frac>) -> FixedI128<Frac>

Performs the & operation.

impl<'a, Frac> BitAndAssign<&'a FixedI128<Frac>> for FixedI128<Frac>

fn bitand_assign(&mut self, rhs: &FixedI128<Frac>)

Performs the &= operation.

impl<Frac> BitAndAssign<FixedI128<Frac>> for FixedI128<Frac>

fn bitand_assign(&mut self, rhs: FixedI128<Frac>)

Performs the &= operation.

impl<'a, Frac> BitOr<&'a FixedI128<Frac>> for FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the | operator.

fn bitor(self, rhs: &FixedI128<Frac>) -> FixedI128<Frac>

Performs the | operation.

impl<'a, 'b, Frac> BitOr<&'a FixedI128<Frac>> for &'b FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the | operator.

fn bitor(self, rhs: &FixedI128<Frac>) -> FixedI128<Frac>

Performs the | operation.

impl<Frac> BitOr<FixedI128<Frac>> for FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the | operator.

fn bitor(self, rhs: FixedI128<Frac>) -> FixedI128<Frac>

Performs the | operation.

impl<'a, Frac> BitOr<FixedI128<Frac>> for &'a FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the | operator.

fn bitor(self, rhs: FixedI128<Frac>) -> FixedI128<Frac>

Performs the | operation.

impl<'a, Frac> BitOrAssign<&'a FixedI128<Frac>> for FixedI128<Frac>

fn bitor_assign(&mut self, rhs: &FixedI128<Frac>)

Performs the |= operation.

impl<Frac> BitOrAssign<FixedI128<Frac>> for FixedI128<Frac>

fn bitor_assign(&mut self, rhs: FixedI128<Frac>)

Performs the |= operation.

impl<'a, Frac> BitXor<&'a FixedI128<Frac>> for FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &FixedI128<Frac>) -> FixedI128<Frac>

Performs the ^ operation.

impl<'a, 'b, Frac> BitXor<&'a FixedI128<Frac>> for &'b FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &FixedI128<Frac>) -> FixedI128<Frac>

Performs the ^ operation.

impl<Frac> BitXor<FixedI128<Frac>> for FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: FixedI128<Frac>) -> FixedI128<Frac>

Performs the ^ operation.

impl<'a, Frac> BitXor<FixedI128<Frac>> for &'a FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: FixedI128<Frac>) -> FixedI128<Frac>

Performs the ^ operation.

impl<'a, Frac> BitXorAssign<&'a FixedI128<Frac>> for FixedI128<Frac>

fn bitxor_assign(&mut self, rhs: &FixedI128<Frac>)

Performs the ^= operation.

impl<Frac> BitXorAssign<FixedI128<Frac>> for FixedI128<Frac>

fn bitxor_assign(&mut self, rhs: FixedI128<Frac>)

Performs the ^= operation.

impl<Frac: LeEqU128> Cast<FixedI128<Frac>> for bool

fn cast(self) -> FixedI128<Frac>

Casts the value.

impl<Frac: LeEqU128> Cast<FixedI128<Frac>> for i8

fn cast(self) -> FixedI128<Frac>

Casts the value.

impl<Frac: LeEqU128> Cast<FixedI128<Frac>> for u64

fn cast(self) -> FixedI128<Frac>

Casts the value.

impl<Frac: LeEqU128> Cast<FixedI128<Frac>> for u128

fn cast(self) -> FixedI128<Frac>

Casts the value.

impl<Frac: LeEqU128> Cast<FixedI128<Frac>> for usize

fn cast(self) -> FixedI128<Frac>

Casts the value.

impl<Frac: LeEqU128> Cast<FixedI128<Frac>> for f32

fn cast(self) -> FixedI128<Frac>

Casts the value.

impl<Frac: LeEqU128> Cast<FixedI128<Frac>> for f64

fn cast(self) -> FixedI128<Frac>

Casts the value.

impl<Frac: LeEqU128> Cast<FixedI128<Frac>> for f16

fn cast(self) -> FixedI128<Frac>

Casts the value.

impl<Frac: LeEqU128> Cast<FixedI128<Frac>> for bf16

fn cast(self) -> FixedI128<Frac>

Casts the value.

impl<Frac: LeEqU128> Cast<FixedI128<Frac>> for i16

fn cast(self) -> FixedI128<Frac>

Casts the value.

impl<Frac: LeEqU128> Cast<FixedI128<Frac>> for i32

fn cast(self) -> FixedI128<Frac>

Casts the value.

impl<Frac: LeEqU128> Cast<FixedI128<Frac>> for i64

fn cast(self) -> FixedI128<Frac>

Casts the value.

impl<Frac: LeEqU128> Cast<FixedI128<Frac>> for i128

fn cast(self) -> FixedI128<Frac>

Casts the value.

impl<Frac: LeEqU128> Cast<FixedI128<Frac>> for isize

fn cast(self) -> FixedI128<Frac>

Casts the value.

impl<Frac: LeEqU128> Cast<FixedI128<Frac>> for u8

fn cast(self) -> FixedI128<Frac>

Casts the value.

impl<Frac: LeEqU128> Cast<FixedI128<Frac>> for u16

fn cast(self) -> FixedI128<Frac>

Casts the value.

impl<Frac: LeEqU128> Cast<FixedI128<Frac>> for u32

fn cast(self) -> FixedI128<Frac>

Casts the value.

impl<FracSrc: LeEqU8, FracDst: LeEqU128> Cast<FixedI128<FracDst>> for FixedI8<FracSrc>

fn cast(self) -> FixedI128<FracDst>

Casts the value.

impl<FracSrc: LeEqU16, FracDst: LeEqU128> Cast<FixedI128<FracDst>> for FixedI16<FracSrc>

fn cast(self) -> FixedI128<FracDst>

Casts the value.

impl<FracSrc: LeEqU32, FracDst: LeEqU128> Cast<FixedI128<FracDst>> for FixedI32<FracSrc>

fn cast(self) -> FixedI128<FracDst>

Casts the value.

impl<FracSrc: LeEqU64, FracDst: LeEqU128> Cast<FixedI128<FracDst>> for FixedI64<FracSrc>

fn cast(self) -> FixedI128<FracDst>

Casts the value.

impl<FracSrc: LeEqU128, FracDst: LeEqU128> Cast<FixedI128<FracDst>> for FixedI128<FracSrc>

fn cast(self) -> FixedI128<FracDst>

Casts the value.

impl<FracSrc: LeEqU8, FracDst: LeEqU128> Cast<FixedI128<FracDst>> for FixedU8<FracSrc>

fn cast(self) -> FixedI128<FracDst>

Casts the value.

impl<FracSrc: LeEqU16, FracDst: LeEqU128> Cast<FixedI128<FracDst>> for FixedU16<FracSrc>

fn cast(self) -> FixedI128<FracDst>

Casts the value.

impl<FracSrc: LeEqU32, FracDst: LeEqU128> Cast<FixedI128<FracDst>> for FixedU32<FracSrc>

fn cast(self) -> FixedI128<FracDst>

Casts the value.

impl<FracSrc: LeEqU64, FracDst: LeEqU128> Cast<FixedI128<FracDst>> for FixedU64<FracSrc>

fn cast(self) -> FixedI128<FracDst>

Casts the value.

impl<FracSrc: LeEqU128, FracDst: LeEqU128> Cast<FixedI128<FracDst>> for FixedU128<FracSrc>

fn cast(self) -> FixedI128<FracDst>

Casts the value.

impl<FracSrc: LeEqU128, FracDst: LeEqU16> Cast<FixedI16<FracDst>> for FixedI128<FracSrc>

fn cast(self) -> FixedI16<FracDst>

Casts the value.

impl<FracSrc: LeEqU128, FracDst: LeEqU32> Cast<FixedI32<FracDst>> for FixedI128<FracSrc>

fn cast(self) -> FixedI32<FracDst>

Casts the value.

impl<FracSrc: LeEqU128, FracDst: LeEqU64> Cast<FixedI64<FracDst>> for FixedI128<FracSrc>

fn cast(self) -> FixedI64<FracDst>

Casts the value.

impl<FracSrc: LeEqU128, FracDst: LeEqU8> Cast<FixedI8<FracDst>> for FixedI128<FracSrc>

fn cast(self) -> FixedI8<FracDst>

Casts the value.

impl<FracSrc: LeEqU128, FracDst: LeEqU128> Cast<FixedU128<FracDst>> for FixedI128<FracSrc>

fn cast(self) -> FixedU128<FracDst>

Casts the value.

impl<FracSrc: LeEqU128, FracDst: LeEqU16> Cast<FixedU16<FracDst>> for FixedI128<FracSrc>

fn cast(self) -> FixedU16<FracDst>

Casts the value.

impl<FracSrc: LeEqU128, FracDst: LeEqU32> Cast<FixedU32<FracDst>> for FixedI128<FracSrc>

fn cast(self) -> FixedU32<FracDst>

Casts the value.

impl<FracSrc: LeEqU128, FracDst: LeEqU64> Cast<FixedU64<FracDst>> for FixedI128<FracSrc>

fn cast(self) -> FixedU64<FracDst>

Casts the value.

impl<FracSrc: LeEqU128, FracDst: LeEqU8> Cast<FixedU8<FracDst>> for FixedI128<FracSrc>

fn cast(self) -> FixedU8<FracDst>

Casts the value.

impl<Frac: LeEqU128> Cast<bf16> for FixedI128<Frac>

fn cast(self) -> bf16

Casts the value.

impl<Frac: LeEqU128> Cast<f16> for FixedI128<Frac>

fn cast(self) -> f16

Casts the value.

impl<Frac: LeEqU128> Cast<f32> for FixedI128<Frac>

fn cast(self) -> f32

Casts the value.

impl<Frac: LeEqU128> Cast<f64> for FixedI128<Frac>

fn cast(self) -> f64

Casts the value.

impl<Frac: LeEqU128> Cast<i128> for FixedI128<Frac>

fn cast(self) -> i128

Casts the value.

impl<Frac: LeEqU128> Cast<i16> for FixedI128<Frac>

fn cast(self) -> i16

Casts the value.

impl<Frac: LeEqU128> Cast<i32> for FixedI128<Frac>

fn cast(self) -> i32

Casts the value.

impl<Frac: LeEqU128> Cast<i64> for FixedI128<Frac>

fn cast(self) -> i64

Casts the value.

impl<Frac: LeEqU128> Cast<i8> for FixedI128<Frac>

fn cast(self) -> i8

Casts the value.

impl<Frac: LeEqU128> Cast<isize> for FixedI128<Frac>

fn cast(self) -> isize

Casts the value.

impl<Frac: LeEqU128> Cast<u128> for FixedI128<Frac>

fn cast(self) -> u128

Casts the value.

impl<Frac: LeEqU128> Cast<u16> for FixedI128<Frac>

fn cast(self) -> u16

Casts the value.

impl<Frac: LeEqU128> Cast<u32> for FixedI128<Frac>

fn cast(self) -> u32

Casts the value.

impl<Frac: LeEqU128> Cast<u64> for FixedI128<Frac>

fn cast(self) -> u64

Casts the value.

impl<Frac: LeEqU128> Cast<u8> for FixedI128<Frac>

fn cast(self) -> u8

Casts the value.

impl<Frac: LeEqU128> Cast<usize> for FixedI128<Frac>

fn cast(self) -> usize

Casts the value.

impl<Frac: LeEqU128> CheckedCast<FixedI128<Frac>> for bool

fn checked_cast(self) -> Option<FixedI128<Frac>>

Casts the value.

impl<Frac: LeEqU128> CheckedCast<FixedI128<Frac>> for i8

fn checked_cast(self) -> Option<FixedI128<Frac>>

Casts the value.

impl<Frac: LeEqU128> CheckedCast<FixedI128<Frac>> for u64

fn checked_cast(self) -> Option<FixedI128<Frac>>

Casts the value.

impl<Frac: LeEqU128> CheckedCast<FixedI128<Frac>> for u128

fn checked_cast(self) -> Option<FixedI128<Frac>>

Casts the value.

impl<Frac: LeEqU128> CheckedCast<FixedI128<Frac>> for usize

fn checked_cast(self) -> Option<FixedI128<Frac>>

Casts the value.

impl<Frac: LeEqU128> CheckedCast<FixedI128<Frac>> for f32

fn checked_cast(self) -> Option<FixedI128<Frac>>

Casts the value.

impl<Frac: LeEqU128> CheckedCast<FixedI128<Frac>> for f64

fn checked_cast(self) -> Option<FixedI128<Frac>>

Casts the value.

impl<Frac: LeEqU128> CheckedCast<FixedI128<Frac>> for f16

fn checked_cast(self) -> Option<FixedI128<Frac>>

Casts the value.

impl<Frac: LeEqU128> CheckedCast<FixedI128<Frac>> for bf16

fn checked_cast(self) -> Option<FixedI128<Frac>>

Casts the value.

impl<Frac: LeEqU128> CheckedCast<FixedI128<Frac>> for i16

fn checked_cast(self) -> Option<FixedI128<Frac>>

Casts the value.

impl<Frac: LeEqU128> CheckedCast<FixedI128<Frac>> for i32

fn checked_cast(self) -> Option<FixedI128<Frac>>

Casts the value.

impl<Frac: LeEqU128> CheckedCast<FixedI128<Frac>> for i64

fn checked_cast(self) -> Option<FixedI128<Frac>>

Casts the value.

impl<Frac: LeEqU128> CheckedCast<FixedI128<Frac>> for i128

fn checked_cast(self) -> Option<FixedI128<Frac>>

Casts the value.

impl<Frac: LeEqU128> CheckedCast<FixedI128<Frac>> for isize

fn checked_cast(self) -> Option<FixedI128<Frac>>

Casts the value.

impl<Frac: LeEqU128> CheckedCast<FixedI128<Frac>> for u8

fn checked_cast(self) -> Option<FixedI128<Frac>>

Casts the value.

impl<Frac: LeEqU128> CheckedCast<FixedI128<Frac>> for u16

fn checked_cast(self) -> Option<FixedI128<Frac>>

Casts the value.

impl<Frac: LeEqU128> CheckedCast<FixedI128<Frac>> for u32

fn checked_cast(self) -> Option<FixedI128<Frac>>

Casts the value.

impl<FracSrc: LeEqU8, FracDst: LeEqU128> CheckedCast<FixedI128<FracDst>> for FixedI8<FracSrc>

fn checked_cast(self) -> Option<FixedI128<FracDst>>

Casts the value.

impl<FracSrc: LeEqU16, FracDst: LeEqU128> CheckedCast<FixedI128<FracDst>> for FixedI16<FracSrc>

fn checked_cast(self) -> Option<FixedI128<FracDst>>

Casts the value.

impl<FracSrc: LeEqU32, FracDst: LeEqU128> CheckedCast<FixedI128<FracDst>> for FixedI32<FracSrc>

fn checked_cast(self) -> Option<FixedI128<FracDst>>

Casts the value.

impl<FracSrc: LeEqU64, FracDst: LeEqU128> CheckedCast<FixedI128<FracDst>> for FixedI64<FracSrc>

fn checked_cast(self) -> Option<FixedI128<FracDst>>

Casts the value.

impl<FracSrc: LeEqU128, FracDst: LeEqU128> CheckedCast<FixedI128<FracDst>> for FixedI128<FracSrc>

fn checked_cast(self) -> Option<FixedI128<FracDst>>

Casts the value.

impl<FracSrc: LeEqU8, FracDst: LeEqU128> CheckedCast<FixedI128<FracDst>> for FixedU8<FracSrc>

fn checked_cast(self) -> Option<FixedI128<FracDst>>

Casts the value.

impl<FracSrc: LeEqU16, FracDst: LeEqU128> CheckedCast<FixedI128<FracDst>> for FixedU16<FracSrc>

fn checked_cast(self) -> Option<FixedI128<FracDst>>

Casts the value.

impl<FracSrc: LeEqU32, FracDst: LeEqU128> CheckedCast<FixedI128<FracDst>> for FixedU32<FracSrc>

fn checked_cast(self) -> Option<FixedI128<FracDst>>

Casts the value.

impl<FracSrc: LeEqU64, FracDst: LeEqU128> CheckedCast<FixedI128<FracDst>> for FixedU64<FracSrc>

fn checked_cast(self) -> Option<FixedI128<FracDst>>

Casts the value.

impl<FracSrc: LeEqU128, FracDst: LeEqU128> CheckedCast<FixedI128<FracDst>> for FixedU128<FracSrc>

fn checked_cast(self) -> Option<FixedI128<FracDst>>

Casts the value.

impl<FracSrc: LeEqU128, FracDst: LeEqU16> CheckedCast<FixedI16<FracDst>> for FixedI128<FracSrc>

fn checked_cast(self) -> Option<FixedI16<FracDst>>

Casts the value.

impl<FracSrc: LeEqU128, FracDst: LeEqU32> CheckedCast<FixedI32<FracDst>> for FixedI128<FracSrc>

fn checked_cast(self) -> Option<FixedI32<FracDst>>

Casts the value.

impl<FracSrc: LeEqU128, FracDst: LeEqU64> CheckedCast<FixedI64<FracDst>> for FixedI128<FracSrc>

fn checked_cast(self) -> Option<FixedI64<FracDst>>

Casts the value.

impl<FracSrc: LeEqU128, FracDst: LeEqU8> CheckedCast<FixedI8<FracDst>> for FixedI128<FracSrc>

fn checked_cast(self) -> Option<FixedI8<FracDst>>

Casts the value.

impl<FracSrc: LeEqU128, FracDst: LeEqU128> CheckedCast<FixedU128<FracDst>> for FixedI128<FracSrc>

fn checked_cast(self) -> Option<FixedU128<FracDst>>

Casts the value.

impl<FracSrc: LeEqU128, FracDst: LeEqU16> CheckedCast<FixedU16<FracDst>> for FixedI128<FracSrc>

fn checked_cast(self) -> Option<FixedU16<FracDst>>

Casts the value.

impl<FracSrc: LeEqU128, FracDst: LeEqU32> CheckedCast<FixedU32<FracDst>> for FixedI128<FracSrc>

fn checked_cast(self) -> Option<FixedU32<FracDst>>

Casts the value.

impl<FracSrc: LeEqU128, FracDst: LeEqU64> CheckedCast<FixedU64<FracDst>> for FixedI128<FracSrc>

fn checked_cast(self) -> Option<FixedU64<FracDst>>

Casts the value.

impl<FracSrc: LeEqU128, FracDst: LeEqU8> CheckedCast<FixedU8<FracDst>> for FixedI128<FracSrc>

fn checked_cast(self) -> Option<FixedU8<FracDst>>

Casts the value.

impl<Frac: LeEqU128> CheckedCast<bf16> for FixedI128<Frac>

fn checked_cast(self) -> Option<bf16>

Casts the value.

impl<Frac: LeEqU128> CheckedCast<f16> for FixedI128<Frac>

fn checked_cast(self) -> Option<f16>

Casts the value.

impl<Frac: LeEqU128> CheckedCast<f32> for FixedI128<Frac>

fn checked_cast(self) -> Option<f32>

Casts the value.

impl<Frac: LeEqU128> CheckedCast<f64> for FixedI128<Frac>

fn checked_cast(self) -> Option<f64>

Casts the value.

impl<Frac: LeEqU128> CheckedCast<i128> for FixedI128<Frac>

fn checked_cast(self) -> Option<i128>

Casts the value.

impl<Frac: LeEqU128> CheckedCast<i16> for FixedI128<Frac>

fn checked_cast(self) -> Option<i16>

Casts the value.

impl<Frac: LeEqU128> CheckedCast<i32> for FixedI128<Frac>

fn checked_cast(self) -> Option<i32>

Casts the value.

impl<Frac: LeEqU128> CheckedCast<i64> for FixedI128<Frac>

fn checked_cast(self) -> Option<i64>

Casts the value.

impl<Frac: LeEqU128> CheckedCast<i8> for FixedI128<Frac>

fn checked_cast(self) -> Option<i8>

Casts the value.

impl<Frac: LeEqU128> CheckedCast<isize> for FixedI128<Frac>

fn checked_cast(self) -> Option<isize>

Casts the value.

impl<Frac: LeEqU128> CheckedCast<u128> for FixedI128<Frac>

fn checked_cast(self) -> Option<u128>

Casts the value.

impl<Frac: LeEqU128> CheckedCast<u16> for FixedI128<Frac>

fn checked_cast(self) -> Option<u16>

Casts the value.

impl<Frac: LeEqU128> CheckedCast<u32> for FixedI128<Frac>

fn checked_cast(self) -> Option<u32>

Casts the value.

impl<Frac: LeEqU128> CheckedCast<u64> for FixedI128<Frac>

fn checked_cast(self) -> Option<u64>

Casts the value.

impl<Frac: LeEqU128> CheckedCast<u8> for FixedI128<Frac>

fn checked_cast(self) -> Option<u8>

Casts the value.

impl<Frac: LeEqU128> CheckedCast<usize> for FixedI128<Frac>

fn checked_cast(self) -> Option<usize>

Casts the value.

impl<Frac> Clone for FixedI128<Frac>

fn clone(&self) -> FixedI128<Frac>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<Frac> Copy for FixedI128<Frac>

impl<Frac: LeEqU128> Debug for FixedI128<Frac>

fn fmt(&self, f: &mut Formatter) -> FmtResult

Formats the value using the given formatter.

impl<Frac> Default for FixedI128<Frac>

fn default() -> Self

Returns the "default value" for a type.

impl<'de, Frac: LeEqU128> Deserialize<'de> for FixedI128<Frac>

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl<Frac: LeEqU128> Display for FixedI128<Frac>

fn fmt(&self, f: &mut Formatter) -> FmtResult

Formats the value using the given formatter.

impl<'a, Frac: LeEqU128> Div<&'a FixedI128<Frac>> for FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the / operator.

fn div(self, rhs: &FixedI128<Frac>) -> FixedI128<Frac>

Performs the / operation.

impl<'a, 'b, Frac: LeEqU128> Div<&'a FixedI128<Frac>> for &'b FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the / operator.

fn div(self, rhs: &FixedI128<Frac>) -> FixedI128<Frac>

Performs the / operation.

impl<'a, Frac: LeEqU128> Div<&'a i128> for FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the / operator.

fn div(self, rhs: &i128) -> FixedI128<Frac>

Performs the / operation.

impl<'a, 'b, Frac: LeEqU128> Div<&'a i128> for &'b FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the / operator.

fn div(self, rhs: &i128) -> FixedI128<Frac>

Performs the / operation.

impl<Frac: LeEqU128> Div<FixedI128<Frac>> for FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the / operator.

fn div(self, rhs: FixedI128<Frac>) -> FixedI128<Frac>

Performs the / operation.

impl<'a, Frac: LeEqU128> Div<FixedI128<Frac>> for &'a FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the / operator.

fn div(self, rhs: FixedI128<Frac>) -> FixedI128<Frac>

Performs the / operation.

impl<Frac: LeEqU128> Div<i128> for FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the / operator.

fn div(self, rhs: i128) -> FixedI128<Frac>

Performs the / operation.

impl<'a, Frac: LeEqU128> Div<i128> for &'a FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the / operator.

fn div(self, rhs: i128) -> FixedI128<Frac>

Performs the / operation.

impl<'a, Frac: LeEqU128> DivAssign<&'a FixedI128<Frac>> for FixedI128<Frac>

fn div_assign(&mut self, rhs: &FixedI128<Frac>)

Performs the /= operation.

impl<'a, Frac: LeEqU128> DivAssign<&'a i128> for FixedI128<Frac>

fn div_assign(&mut self, rhs: &i128)

Performs the /= operation.

impl<Frac: LeEqU128> DivAssign<FixedI128<Frac>> for FixedI128<Frac>

fn div_assign(&mut self, rhs: FixedI128<Frac>)

Performs the /= operation.

impl<Frac: LeEqU128> DivAssign<i128> for FixedI128<Frac>

fn div_assign(&mut self, rhs: i128)

Performs the /= operation.

impl<Frac: LeEqU128> Eq for FixedI128<Frac>

impl<Frac: LeEqU128> Fixed for FixedI128<Frac>

type Bits = i128

The primitive integer underlying type.

type Bytes = [u8; 16]

A byte array with the same size as the type.

type Frac = Frac

The number of fractional bits.

const MIN: Self

The smallest value that can be represented.

const MAX: Self

The largest value that can be represented.

const INT_NBITS: u32

The number of integer bits.

const FRAC_NBITS: u32

The number of fractional bits.

fn from_bits(bits: Self::Bits) -> Self

Creates a fixed-point number that has a bitwise representation identical to the given integer.

fn to_bits(self) -> Self::Bits

Creates an integer that has a bitwise representation identical to the given fixed-point number.

fn from_be_bytes(bits: Self::Bytes) -> Self

Creates a fixed-point number from its representation as a byte array in big endian.

fn from_le_bytes(bits: Self::Bytes) -> Self

Creates a fixed-point number from its representation as a byte array in little endian.

fn from_ne_bytes(bits: Self::Bytes) -> Self

Creates a fixed-point number from its representation as a byte array in native endian.

fn to_be_bytes(self) -> Self::Bytes

Returns the memory representation of this fixed-point number as a byte array in big-endian byte order.

fn to_le_bytes(self) -> Self::Bytes

Returns the memory representation of this fixed-point number as a byte array in little-endian byte order.

fn to_ne_bytes(self) -> Self::Bytes

Returns the memory representation of this fixed-point number as a byte array in native byte order.

fn from_num<Src: ToFixed>(src: Src) -> Self

Creates a fixed-point number from another number.

fn to_num<Dst: FromFixed>(self) -> Dst

Converts a fixed-point number to another number.

fn checked_from_num<Src: ToFixed>(val: Src) -> Option<Self>

Creates a fixed-point number from another number if it fits, otherwise returns [None].

fn checked_to_num<Dst: FromFixed>(self) -> Option<Dst>

Converts a fixed-point number to another number if it fits, otherwise returns [None].

fn saturating_from_num<Src: ToFixed>(val: Src) -> Self

Creates a fixed-point number from another number, saturating the value if it does not fit.

fn saturating_to_num<Dst: FromFixed>(self) -> Dst

Converts a fixed-point number to another number, saturating the value if it does not fit.

fn wrapping_from_num<Src: ToFixed>(val: Src) -> Self

Creates a fixed-point number from another number, wrapping the value on overflow.

fn wrapping_to_num<Dst: FromFixed>(self) -> Dst

Converts a fixed-point number to another number, wrapping the value on overflow.

fn overflowing_from_num<Src: ToFixed>(val: Src) -> (Self, bool)

Creates a fixed-point number from another number.

fn overflowing_to_num<Dst: FromFixed>(self) -> (Dst, bool)

Converts a fixed-point number to another number.

fn from_str_binary(src: &str) -> Result<Self, ParseFixedError>

Parses a string slice containing binary digits to return a fixed-point number.

fn from_str_octal(src: &str) -> Result<Self, ParseFixedError>

Parses a string slice containing octal digits to return a fixed-point number.

fn from_str_hex(src: &str) -> Result<Self, ParseFixedError>

Parses a string slice containing hexadecimal digits to return a fixed-point number.

fn saturating_from_str(src: &str) -> Result<Self, ParseFixedError>

Parses a string slice containing decimal digits to return a fixed-point number, saturating on overflow.

fn saturating_from_str_binary(src: &str) -> Result<Self, ParseFixedError>

Parses a string slice containing binary digits to return a fixed-point number, saturating on overflow.

fn saturating_from_str_octal(src: &str) -> Result<Self, ParseFixedError>

Parses a string slice containing octal digits to return a fixed-point number, saturating on overflow.

fn saturating_from_str_hex(src: &str) -> Result<Self, ParseFixedError>

Parses a string slice containing hexadecimal digits to return a fixed-point number, saturating on overflow.

fn wrapping_from_str(src: &str) -> Result<Self, ParseFixedError>

Parses a string slice containing decimal digits to return a fixed-point number, wrapping on overflow.

fn wrapping_from_str_binary(src: &str) -> Result<Self, ParseFixedError>

Parses a string slice containing binary digits to return a fixed-point number, wrapping on overflow.

fn wrapping_from_str_octal(src: &str) -> Result<Self, ParseFixedError>

Parses a string slice containing octal digits to return a fixed-point number, wrapping on overflow.

fn wrapping_from_str_hex(src: &str) -> Result<Self, ParseFixedError>

Parses a string slice containing hexadecimal digits to return a fixed-point number, wrapping on overflow.

fn overflowing_from_str(src: &str) -> Result<(Self, bool), ParseFixedError>

Parses a string slice containing decimal digits to return a fixed-point number.

fn overflowing_from_str_binary(
    src: &str
) -> Result<(Self, bool), ParseFixedError>

Parses a string slice containing binary digits to return a fixed-point number.

fn overflowing_from_str_octal(
    src: &str
) -> Result<(Self, bool), ParseFixedError>

Parses a string slice containing octal digits to return a fixed-point number.

fn overflowing_from_str_hex(src: &str) -> Result<(Self, bool), ParseFixedError>

Parses a string slice containing hexadecimal digits to return a fixed-point number.

fn int(self) -> Self

Returns the integer part.

fn frac(self) -> Self

Returns the fractional part.

fn ceil(self) -> Self

Rounds to the next integer towards +∞.

fn floor(self) -> Self

Rounds to the next integer towards −∞.

fn round_to_zero(self) -> Self

Rounds to the next integer towards 0.

fn round(self) -> Self

Rounds to the nearest integer, with ties rounded away from zero.

fn round_ties_to_even(self) -> Self

Rounds to the nearest integer, with ties rounded to even.

fn checked_ceil(self) -> Option<Self>

Checked ceil. Rounds to the next integer towards +∞, returning [None] on overflow.

fn checked_floor(self) -> Option<Self>

Checked floor. Rounds to the next integer towards −∞, returning [None] on overflow.

fn checked_round(self) -> Option<Self>

Checked round. Rounds to the nearest integer, with ties rounded away from zero, returning [None] on overflow.

fn checked_round_ties_to_even(self) -> Option<Self>

Checked round. Rounds to the nearest integer, with ties rounded to even, returning [None] on overflow.

fn saturating_ceil(self) -> Self

Saturating ceil. Rounds to the next integer towards +∞, saturating on overflow.

fn saturating_floor(self) -> Self

Saturating floor. Rounds to the next integer towards −∞, saturating on overflow.

fn saturating_round(self) -> Self

Saturating round. Rounds to the nearest integer, with ties rounded away from zero, and saturating on overflow.

fn saturating_round_ties_to_even(self) -> Self

Saturating round. Rounds to the nearest integer, with ties rounded to_even, and saturating on overflow.

fn wrapping_ceil(self) -> Self

Wrapping ceil. Rounds to the next integer towards +∞, wrapping on overflow.

fn wrapping_floor(self) -> Self

Wrapping floor. Rounds to the next integer towards −∞, wrapping on overflow.

fn wrapping_round(self) -> Self

Wrapping round. Rounds to the next integer to the nearest, with ties rounded away from zero, and wrapping on overflow.

fn wrapping_round_ties_to_even(self) -> Self

Wrapping round. Rounds to the next integer to the nearest, with ties rounded to even, and wrapping on overflow.

fn overflowing_ceil(self) -> (Self, bool)

Overflowing ceil. Rounds to the next integer towards +∞.

fn overflowing_floor(self) -> (Self, bool)

Overflowing floor. Rounds to the next integer towards −∞.

fn overflowing_round(self) -> (Self, bool)

Overflowing round. Rounds to the next integer to the nearest, with ties rounded away from zero.

fn overflowing_round_ties_to_even(self) -> (Self, bool)

Overflowing round. Rounds to the next integer to the nearest, with ties rounded to even.

fn count_ones(self) -> u32

Returns the number of ones in the binary representation.

fn count_zeros(self) -> u32

Returns the number of zeros in the binary representation.

fn leading_ones(self) -> u32

Returns the number of leading ones in the binary representation.

fn leading_zeros(self) -> u32

Returns the number of leading zeros in the binary representation.

fn trailing_ones(self) -> u32

Returns the number of trailing ones in the binary representation.

fn trailing_zeros(self) -> u32

Returns the number of trailing zeros in the binary representation.

fn int_log2(self) -> i32

Integer base-2 logarithm, rounded down.

fn int_log10(self) -> i32

Integer base-10 logarithm, rounded down.

fn checked_int_log2(self) -> Option<i32>

Checked integer base-2 logarithm, rounded down. Returns the logarithm or [None] if the fixed-point number is ≤ 0.

fn checked_int_log10(self) -> Option<i32>

Checked integer base-10 logarithm, rounded down. Returns the logarithm or [None] if the fixed-point number is ≤ 0.

fn rotate_left(self, n: u32) -> Self

Shifts to the left by n bits, wrapping the truncated bits to the right end.

fn rotate_right(self, n: u32) -> Self

Shifts to the right by n bits, wrapping the truncated bits to the left end.

fn div_euclid(self, rhs: Self) -> Self

Euclidean division by an integer.

fn rem_euclid(self, rhs: Self) -> Self

Remainder for Euclidean division.

fn div_euclid_int(self, rhs: Self::Bits) -> Self

Euclidean division by an integer.

fn rem_euclid_int(self, rhs: Self::Bits) -> Self

Remainder for Euclidean division by an integer.

fn checked_neg(self) -> Option<Self>

Checked negation. Returns the negated value, or [None] on overflow.

fn checked_add(self, rhs: Self) -> Option<Self>

Checked addition. Returns the sum, or [None] on overflow.

fn checked_sub(self, rhs: Self) -> Option<Self>

Checked subtraction. Returns the difference, or [None] on overflow.

fn checked_mul(self, rhs: Self) -> Option<Self>

Checked multiplication. Returns the product, or [None] on overflow.

fn checked_div(self, rhs: Self) -> Option<Self>

Checked division. Returns the quotient, or [None] if the divisor is zero or on overflow.

fn checked_rem(self, rhs: Self) -> Option<Self>

Checked remainder. Returns the remainder, or [None] if the divisor is zero.

fn checked_div_euclid(self, rhs: Self) -> Option<Self>

Checked remainder for Euclidean division. Returns the remainder, or [None] if the divisor is zero or the division results in overflow.

fn checked_rem_euclid(self, rhs: Self) -> Option<Self>

Checked remainder for Euclidean division. Returns the remainder, or [None] if the divisor is zero.

fn checked_mul_int(self, rhs: Self::Bits) -> Option<Self>

Checked multiplication by an integer. Returns the product, or [None] on overflow.

fn checked_div_int(self, rhs: Self::Bits) -> Option<Self>

Checked division by an integer. Returns the quotient, or [None] if the divisor is zero or if the division results in overflow.

fn checked_rem_int(self, rhs: Self::Bits) -> Option<Self>

Checked fixed-point remainder for division by an integer. Returns the remainder, or [None] if the divisor is zero or if the division results in overflow.

fn checked_div_euclid_int(self, rhs: Self::Bits) -> Option<Self>

Checked Euclidean division by an integer. Returns the quotient, or [None] if the divisor is zero or if the division results in overflow.

fn checked_rem_euclid_int(self, rhs: Self::Bits) -> Option<Self>

Checked remainder for Euclidean division by an integer. Returns the remainder, or [None] if the divisor is zero or if the remainder results in overflow.

fn checked_shl(self, rhs: u32) -> Option<Self>

Checked shift left. Returns the shifted number, or [None] if rhs ≥ the number of bits.

fn checked_shr(self, rhs: u32) -> Option<Self>

Checked shift right. Returns the shifted number, or [None] if rhs ≥ the number of bits.

fn saturating_neg(self) -> Self

Saturated negation. Returns the negated value, saturating on overflow.

fn saturating_add(self, rhs: Self) -> Self

Saturating addition. Returns the sum, saturating on overflow.

fn saturating_sub(self, rhs: Self) -> Self

Saturating subtraction. Returns the difference, saturating on overflow.

fn saturating_mul(self, rhs: Self) -> Self

Saturating multiplication. Returns the product, saturating on overflow.

fn saturating_div(self, rhs: Self) -> Self

Saturating division. Returns the quotient, saturating on overflow.

fn saturating_div_euclid(self, rhs: Self) -> Self

Saturating Euclidean division. Returns the quotient, saturating on overflow.

fn saturating_mul_int(self, rhs: Self::Bits) -> Self

Saturating multiplication by an integer. Returns the product, saturating on overflow.

fn wrapping_neg(self) -> Self

Wrapping negation. Returns the negated value, wrapping on overflow.

fn wrapping_add(self, rhs: Self) -> Self

Wrapping addition. Returns the sum, wrapping on overflow.

fn wrapping_sub(self, rhs: Self) -> Self

Wrapping subtraction. Returns the difference, wrapping on overflow.

fn wrapping_mul(self, rhs: Self) -> Self

Wrapping multiplication. Returns the product, wrapping on overflow.

fn wrapping_div(self, rhs: Self) -> Self

Wrapping division. Returns the quotient, wrapping on overflow.

fn wrapping_div_euclid(self, rhs: Self) -> Self

Wrapping Euclidean division. Returns the quotient, wrapping on overflow.

fn wrapping_mul_int(self, rhs: Self::Bits) -> Self

Wrapping multiplication by an integer. Returns the product, wrapping on overflow.

fn wrapping_div_int(self, rhs: Self::Bits) -> Self

Wrapping division by an integer. Returns the quotient, wrapping on overflow.

fn wrapping_div_euclid_int(self, rhs: Self::Bits) -> Self

Wrapping Euclidean division by an integer. Returns the quotient, wrapping on overflow.

fn wrapping_rem_euclid_int(self, rhs: Self::Bits) -> Self

Wrapping remainder for Euclidean division by an integer. Returns the remainder, wrapping on overflow.

fn wrapping_shl(self, rhs: u32) -> Self

Wrapping shift left. Wraps rhs if rhs ≥ the number of bits, then shifts and returns the number.

fn wrapping_shr(self, rhs: u32) -> Self

Wrapping shift right. Wraps rhs if rhs ≥ the number of bits, then shifts and returns the number.

fn overflowing_neg(self) -> (Self, bool)

Overflowing negation.

fn overflowing_add(self, rhs: Self) -> (Self, bool)

Overflowing addition.

fn overflowing_sub(self, rhs: Self) -> (Self, bool)

Overflowing subtraction.

fn overflowing_mul(self, rhs: Self) -> (Self, bool)

Overflowing multiplication.

fn overflowing_div(self, rhs: Self) -> (Self, bool)

Overflowing division.

fn overflowing_div_euclid(self, rhs: Self) -> (Self, bool)

Overflowing Euclidean division.

fn overflowing_mul_int(self, rhs: Self::Bits) -> (Self, bool)

Overflowing multiplication by an integer.

fn overflowing_div_int(self, rhs: Self::Bits) -> (Self, bool)

Overflowing division by an integer.

fn overflowing_div_euclid_int(self, rhs: Self::Bits) -> (Self, bool)

Overflowing Euclidean division by an integer.

fn overflowing_rem_euclid_int(self, rhs: Self::Bits) -> (Self, bool)

Overflowing remainder for Euclidean division by an integer.

fn overflowing_shl(self, rhs: u32) -> (Self, bool)

Overflowing shift left.

fn overflowing_shr(self, rhs: u32) -> (Self, bool)

Overflowing shift right.

fn min_value() -> Self

Deprecated since 0.5.5:

replaced by MIN

Returns the smallest value that can be represented.

fn max_value() -> Self

Deprecated since 0.5.5:

replaced by MAX

Returns the largest value that can be represented.

fn int_nbits() -> u32

Deprecated since 0.5.5:

replaced by INT_NBITS

Returns the number of integer bits.

fn frac_nbits() -> u32

Deprecated since 0.5.5:

replaced by FRAC_NBITS

Returns the number of fractional bits.

fn wrapping_rem_int(self, rhs: Self::Bits) -> Self

Deprecated since 0.5.3:

cannot overflow, use % or Rem::rem instead

Remainder for division by an integer.

fn overflowing_rem_int(self, rhs: Self::Bits) -> (Self, bool)

Deprecated since 0.5.3:

cannot overflow, use % or Rem::rem instead

Remainder for division by an integer.

impl<Frac: LeEqU128> FixedOptionalFeatures for FixedI128<Frac>

impl<Frac: LeEqU128> FixedSigned for FixedI128<Frac>

fn abs(self) -> Self

Returns the absolute value.

fn signum(self) -> Self

Returns a number representing the sign of self.

fn checked_abs(self) -> Option<Self>

Checked absolute value. Returns the absolute value, or [None] on overflow.

fn checked_signum(self) -> Option<Self>

Checked signum. Returns a number representing the sign of self, or [None] on overflow.

fn saturating_abs(self) -> Self

Saturating absolute value. Returns the absolute value, saturating on overflow.

fn saturating_signum(self) -> Self

Saturating signum. Returns a number representing the sign of self, saturating on overflow.

fn wrapping_abs(self) -> Self

Wrapping absolute value. Returns the absolute value, wrapping on overflow.

fn wrapping_signum(self) -> Self

Wrapping signum. Returns a number representing the sign of self, wrapping on overflow.

fn overflowing_abs(self) -> (Self, bool)

Overflowing absolute value.

fn overflowing_signum(self) -> (Self, bool)

Overflowing signum.

fn is_positive(self) -> bool

Returns [true] if the number is > 0.

fn is_negative(self) -> bool

Returns [true] if the number is < 0.

impl From<FixedI128<UTerm>> for i128

fn from(src: FixedI128<U0>) -> Self

Converts a fixed-point number with no fractional bits to an integer.

This conversion never fails (infallible) and cannot lose any fractional bits (lossless).

impl<FracSrc: LeEqU16, FracDst: LeEqU128> From<FixedI16<FracSrc>> for FixedI128<FracDst> where
    FracSrc: IsLessOrEqual<FracDst, Output = True>,
    U16: Sub<FracSrc>,
    U128: Sub<FracDst>,
    Diff<U16, FracSrc>: IsLessOrEqual<Diff<U128, FracDst>, Output = True>, 

fn from(src: FixedI16<FracSrc>) -> Self

Converts a fixed-pint number.

This conversion never fails (infallible) and does not lose any precision (lossless).

impl<FracSrc: LeEqU32, FracDst: LeEqU128> From<FixedI32<FracSrc>> for FixedI128<FracDst> where
    FracSrc: IsLessOrEqual<FracDst, Output = True>,
    U32: Sub<FracSrc>,
    U128: Sub<FracDst>,
    Diff<U32, FracSrc>: IsLessOrEqual<Diff<U128, FracDst>, Output = True>, 

fn from(src: FixedI32<FracSrc>) -> Self

Converts a fixed-pint number.

This conversion never fails (infallible) and does not lose any precision (lossless).

impl<FracSrc: LeEqU64, FracDst: LeEqU128> From<FixedI64<FracSrc>> for FixedI128<FracDst> where
    FracSrc: IsLessOrEqual<FracDst, Output = True>,
    U64: Sub<FracSrc>,
    U128: Sub<FracDst>,
    Diff<U64, FracSrc>: IsLessOrEqual<Diff<U128, FracDst>, Output = True>, 

fn from(src: FixedI64<FracSrc>) -> Self

Converts a fixed-pint number.

This conversion never fails (infallible) and does not lose any precision (lossless).

impl<FracSrc: LeEqU8, FracDst: LeEqU128> From<FixedI8<FracSrc>> for FixedI128<FracDst> where
    FracSrc: IsLessOrEqual<FracDst, Output = True>,
    U8: Sub<FracSrc>,
    U128: Sub<FracDst>,
    Diff<U8, FracSrc>: IsLessOrEqual<Diff<U128, FracDst>, Output = True>, 

fn from(src: FixedI8<FracSrc>) -> Self

Converts a fixed-pint number.

This conversion never fails (infallible) and does not lose any precision (lossless).

impl<FracSrc: LeEqU16, FracDst: LeEqU128> From<FixedU16<FracSrc>> for FixedI128<FracDst> where
    FracSrc: IsLessOrEqual<FracDst, Output = True>,
    U16: Sub<FracSrc>,
    U127: Sub<FracDst>,
    Diff<U16, FracSrc>: IsLessOrEqual<Diff<U127, FracDst>, Output = True>, 

fn from(src: FixedU16<FracSrc>) -> Self

Converts a fixed-pint number.

This conversion never fails (infallible) and does not lose any precision (lossless).

impl<FracSrc: LeEqU32, FracDst: LeEqU128> From<FixedU32<FracSrc>> for FixedI128<FracDst> where
    FracSrc: IsLessOrEqual<FracDst, Output = True>,
    U32: Sub<FracSrc>,
    U127: Sub<FracDst>,
    Diff<U32, FracSrc>: IsLessOrEqual<Diff<U127, FracDst>, Output = True>, 

fn from(src: FixedU32<FracSrc>) -> Self

Converts a fixed-pint number.

This conversion never fails (infallible) and does not lose any precision (lossless).

impl<FracSrc: LeEqU64, FracDst: LeEqU128> From<FixedU64<FracSrc>> for FixedI128<FracDst> where
    FracSrc: IsLessOrEqual<FracDst, Output = True>,
    U64: Sub<FracSrc>,
    U127: Sub<FracDst>,
    Diff<U64, FracSrc>: IsLessOrEqual<Diff<U127, FracDst>, Output = True>, 

fn from(src: FixedU64<FracSrc>) -> Self

Converts a fixed-pint number.

This conversion never fails (infallible) and does not lose any precision (lossless).

impl<FracSrc: LeEqU8, FracDst: LeEqU128> From<FixedU8<FracSrc>> for FixedI128<FracDst> where
    FracSrc: IsLessOrEqual<FracDst, Output = True>,
    U8: Sub<FracSrc>,
    U127: Sub<FracDst>,
    Diff<U8, FracSrc>: IsLessOrEqual<Diff<U127, FracDst>, Output = True>, 

fn from(src: FixedU8<FracSrc>) -> Self

Converts a fixed-pint number.

This conversion never fails (infallible) and does not lose any precision (lossless).

impl<FracDst: LeEqU128> From<bool> for FixedI128<FracDst> where
    U127: Sub<FracDst>,
    U1: IsLessOrEqual<Diff<U127, FracDst>, Output = True>, 

fn from(src: bool) -> Self

Converts a bool to a fixed-point number.

This conversion never fails (infallible) and cannot lose any fractional bits (lossless).

impl From<i128> for FixedI128<U0>

fn from(src: i128) -> Self

Converts an integer to a fixed-point number.

This conversion never fails (infallible) and cannot lose any fractional bits (lossless).

impl<FracDst: LeEqU128> From<i16> for FixedI128<FracDst> where
    U128: Sub<FracDst>,
    U16: IsLessOrEqual<Diff<U128, FracDst>, Output = True>, 

fn from(src: i16) -> Self

Converts an integer to a fixed-point number.

This conversion never fails (infallible) and cannot lose any fractional bits, so it is actually lossless.

impl<FracDst: LeEqU128> From<i32> for FixedI128<FracDst> where
    U128: Sub<FracDst>,
    U32: IsLessOrEqual<Diff<U128, FracDst>, Output = True>, 

fn from(src: i32) -> Self

Converts an integer to a fixed-point number.

This conversion never fails (infallible) and cannot lose any fractional bits, so it is actually lossless.

impl<FracDst: LeEqU128> From<i64> for FixedI128<FracDst> where
    U128: Sub<FracDst>,
    U64: IsLessOrEqual<Diff<U128, FracDst>, Output = True>, 

fn from(src: i64) -> Self

Converts an integer to a fixed-point number.

This conversion never fails (infallible) and cannot lose any fractional bits, so it is actually lossless.

impl<FracDst: LeEqU128> From<i8> for FixedI128<FracDst> where
    U128: Sub<FracDst>,
    U8: IsLessOrEqual<Diff<U128, FracDst>, Output = True>, 

fn from(src: i8) -> Self

Converts an integer to a fixed-point number.

This conversion never fails (infallible) and cannot lose any fractional bits, so it is actually lossless.

impl<FracDst: LeEqU128> From<u16> for FixedI128<FracDst> where
    U127: Sub<FracDst>,
    U16: IsLessOrEqual<Diff<U127, FracDst>, Output = True>, 

fn from(src: u16) -> Self

Converts an integer to a fixed-point number.

This conversion never fails (infallible) and cannot lose any fractional bits, so it is actually lossless.

impl<FracDst: LeEqU128> From<u32> for FixedI128<FracDst> where
    U127: Sub<FracDst>,
    U32: IsLessOrEqual<Diff<U127, FracDst>, Output = True>, 

fn from(src: u32) -> Self

Converts an integer to a fixed-point number.

This conversion never fails (infallible) and cannot lose any fractional bits, so it is actually lossless.

impl<FracDst: LeEqU128> From<u64> for FixedI128<FracDst> where
    U127: Sub<FracDst>,
    U64: IsLessOrEqual<Diff<U127, FracDst>, Output = True>, 

fn from(src: u64) -> Self

Converts an integer to a fixed-point number.

This conversion never fails (infallible) and cannot lose any fractional bits, so it is actually lossless.

impl<FracDst: LeEqU128> From<u8> for FixedI128<FracDst> where
    U127: Sub<FracDst>,
    U8: IsLessOrEqual<Diff<U127, FracDst>, Output = True>, 

fn from(src: u8) -> Self

Converts an integer to a fixed-point number.

This conversion never fails (infallible) and cannot lose any fractional bits, so it is actually lossless.

impl<Frac: LeEqU128> FromFixed for FixedI128<Frac>

fn from_fixed<F: Fixed>(src: F) -> Self

Converts a fixed-point number.

Any extra fractional bits are discarded, which rounds towards −∞.

fn checked_from_fixed<F: Fixed>(src: F) -> Option<Self>

Converts a fixed-point number if it fits, otherwise returns None.

Any extra fractional bits are discarded, which rounds towards −∞.

fn saturating_from_fixed<F: Fixed>(src: F) -> Self

Converts a fixed-point number, saturating if it does not fit.

Any extra fractional bits are discarded, which rounds towards −∞.

fn wrapping_from_fixed<F: Fixed>(src: F) -> Self

Converts a fixed-point number, wrapping if it does not fit.

Any extra fractional bits are discarded, which rounds towards −∞.

fn overflowing_from_fixed<F: Fixed>(src: F) -> (Self, bool)

Converts a fixed-point number.

Returns a tuple of the value and a bool indicating whether an overflow has occurred. On overflow, the wrapped value is returned.

Any extra fractional bits are discarded, which rounds towards −∞.

impl<Frac: LeEqU128> FromStr for FixedI128<Frac>

type Err = ParseFixedError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string slice to return a fixed-point number.

Rounding is to the nearest, with ties rounded to even.

impl<Frac> Hash for FixedI128<Frac>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].

impl<FracSrc: LeEqU128, FracDst: LeEqU8> LosslessTryFrom<FixedI128<FracSrc>> for FixedI8<FracDst> where
    FracSrc: IsLessOrEqual<FracDst, Output = True>, 

fn lossless_try_from(src: FixedI128<FracSrc>) -> Option<Self>

Converts a fixed-pint number.

This conversion may fail (fallible) but does not lose precision (lossless).

impl<FracSrc: LeEqU128, FracDst: LeEqU16> LosslessTryFrom<FixedI128<FracSrc>> for FixedI16<FracDst> where
    FracSrc: IsLessOrEqual<FracDst, Output = True>, 

fn lossless_try_from(src: FixedI128<FracSrc>) -> Option<Self>

Converts a fixed-pint number.

This conversion may fail (fallible) but does not lose precision (lossless).

impl<FracSrc: LeEqU128, FracDst: LeEqU32> LosslessTryFrom<FixedI128<FracSrc>> for FixedI32<FracDst> where
    FracSrc: IsLessOrEqual<FracDst, Output = True>, 

fn lossless_try_from(src: FixedI128<FracSrc>) -> Option<Self>

Converts a fixed-pint number.

This conversion may fail (fallible) but does not lose precision (lossless).

impl<FracSrc: LeEqU128, FracDst: LeEqU64> LosslessTryFrom<FixedI128<FracSrc>> for FixedI64<FracDst> where
    FracSrc: IsLessOrEqual<FracDst, Output = True>, 

fn lossless_try_from(src: FixedI128<FracSrc>) -> Option<Self>

Converts a fixed-pint number.

This conversion may fail (fallible) but does not lose precision (lossless).

impl<FracSrc: LeEqU128, FracDst: LeEqU128> LosslessTryFrom<FixedI128<FracSrc>> for FixedI128<FracDst> where
    FracSrc: IsLessOrEqual<FracDst, Output = True>, 

fn lossless_try_from(src: FixedI128<FracSrc>) -> Option<Self>

Converts a fixed-pint number.

This conversion may fail (fallible) but does not lose precision (lossless).

impl<FracSrc: LeEqU128, FracDst: LeEqU8> LosslessTryFrom<FixedI128<FracSrc>> for FixedU8<FracDst> where
    FracSrc: IsLessOrEqual<FracDst, Output = True>, 

fn lossless_try_from(src: FixedI128<FracSrc>) -> Option<Self>

Converts a fixed-pint number.

This conversion may fail (fallible) but does not lose precision (lossless).

impl<FracSrc: LeEqU128, FracDst: LeEqU16> LosslessTryFrom<FixedI128<FracSrc>> for FixedU16<FracDst> where
    FracSrc: IsLessOrEqual<FracDst, Output = True>, 

fn lossless_try_from(src: FixedI128<FracSrc>) -> Option<Self>

Converts a fixed-pint number.

This conversion may fail (fallible) but does not lose precision (lossless).

impl<FracSrc: LeEqU128, FracDst: LeEqU32> LosslessTryFrom<FixedI128<FracSrc>> for FixedU32<FracDst> where
    FracSrc: IsLessOrEqual<FracDst, Output = True>, 

fn lossless_try_from(src: FixedI128<FracSrc>) -> Option<Self>

Converts a fixed-pint number.

This conversion may fail (fallible) but does not lose precision (lossless).

impl<FracSrc: LeEqU128, FracDst: LeEqU64> LosslessTryFrom<FixedI128<FracSrc>> for FixedU64<FracDst> where
    FracSrc: IsLessOrEqual<FracDst, Output = True>, 

fn lossless_try_from(src: FixedI128<FracSrc>) -> Option<Self>

Converts a fixed-pint number.

This conversion may fail (fallible) but does not lose precision (lossless).

impl<FracSrc: LeEqU128, FracDst: LeEqU128> LosslessTryFrom<FixedI128<FracSrc>> for FixedU128<FracDst> where
    FracSrc: IsLessOrEqual<FracDst, Output = True>, 

fn lossless_try_from(src: FixedI128<FracSrc>) -> Option<Self>

Converts a fixed-pint number.

This conversion may fail (fallible) but does not lose precision (lossless).

impl LosslessTryFrom<FixedI128<UTerm>> for i8

fn lossless_try_from(src: FixedI128<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI128<UTerm>> for i16

fn lossless_try_from(src: FixedI128<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI128<UTerm>> for u128

fn lossless_try_from(src: FixedI128<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI128<UTerm>> for usize

fn lossless_try_from(src: FixedI128<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI128<UTerm>> for i32

fn lossless_try_from(src: FixedI128<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI128<UTerm>> for i64

fn lossless_try_from(src: FixedI128<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI128<UTerm>> for i128

fn lossless_try_from(src: FixedI128<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI128<UTerm>> for isize

fn lossless_try_from(src: FixedI128<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI128<UTerm>> for u8

fn lossless_try_from(src: FixedI128<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI128<UTerm>> for u16

fn lossless_try_from(src: FixedI128<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI128<UTerm>> for u32

fn lossless_try_from(src: FixedI128<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI128<UTerm>> for u64

fn lossless_try_from(src: FixedI128<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl<FracSrc: LeEqU16, FracDst: LeEqU128> LosslessTryFrom<FixedI16<FracSrc>> for FixedI128<FracDst> where
    FracSrc: IsLessOrEqual<FracDst, Output = True>, 

fn lossless_try_from(src: FixedI16<FracSrc>) -> Option<Self>

Converts a fixed-pint number.

This conversion may fail (fallible) but does not lose precision (lossless).

impl<FracSrc: LeEqU32, FracDst: LeEqU128> LosslessTryFrom<FixedI32<FracSrc>> for FixedI128<FracDst> where
    FracSrc: IsLessOrEqual<FracDst, Output = True>, 

fn lossless_try_from(src: FixedI32<FracSrc>) -> Option<Self>

Converts a fixed-pint number.

This conversion may fail (fallible) but does not lose precision (lossless).

impl<FracSrc: LeEqU64, FracDst: LeEqU128> LosslessTryFrom<FixedI64<FracSrc>> for FixedI128<FracDst> where
    FracSrc: IsLessOrEqual<FracDst, Output = True>, 

fn lossless_try_from(src: FixedI64<FracSrc>) -> Option<Self>

Converts a fixed-pint number.

This conversion may fail (fallible) but does not lose precision (lossless).

impl<FracSrc: LeEqU8, FracDst: LeEqU128> LosslessTryFrom<FixedI8<FracSrc>> for FixedI128<FracDst> where
    FracSrc: IsLessOrEqual<FracDst, Output = True>, 

fn lossless_try_from(src: FixedI8<FracSrc>) -> Option<Self>

Converts a fixed-pint number.

This conversion may fail (fallible) but does not lose precision (lossless).

impl<FracSrc: LeEqU128, FracDst: LeEqU128> LosslessTryFrom<FixedU128<FracSrc>> for FixedI128<FracDst> where
    FracSrc: IsLessOrEqual<FracDst, Output = True>, 

fn lossless_try_from(src: FixedU128<FracSrc>) -> Option<Self>

Converts a fixed-pint number.

This conversion may fail (fallible) but does not lose precision (lossless).

impl<FracSrc: LeEqU16, FracDst: LeEqU128> LosslessTryFrom<FixedU16<FracSrc>> for FixedI128<FracDst> where
    FracSrc: IsLessOrEqual<FracDst, Output = True>, 

fn lossless_try_from(src: FixedU16<FracSrc>) -> Option<Self>

Converts a fixed-pint number.

This conversion may fail (fallible) but does not lose precision (lossless).

impl<FracSrc: LeEqU32, FracDst: LeEqU128> LosslessTryFrom<FixedU32<FracSrc>> for FixedI128<FracDst> where
    FracSrc: IsLessOrEqual<FracDst, Output = True>, 

fn lossless_try_from(src: FixedU32<FracSrc>) -> Option<Self>

Converts a fixed-pint number.

This conversion may fail (fallible) but does not lose precision (lossless).

impl<FracSrc: LeEqU64, FracDst: LeEqU128> LosslessTryFrom<FixedU64<FracSrc>> for FixedI128<FracDst> where
    FracSrc: IsLessOrEqual<FracDst, Output = True>, 

fn lossless_try_from(src: FixedU64<FracSrc>) -> Option<Self>

Converts a fixed-pint number.

This conversion may fail (fallible) but does not lose precision (lossless).

impl<FracSrc: LeEqU8, FracDst: LeEqU128> LosslessTryFrom<FixedU8<FracSrc>> for FixedI128<FracDst> where
    FracSrc: IsLessOrEqual<FracDst, Output = True>, 

fn lossless_try_from(src: FixedU8<FracSrc>) -> Option<Self>

Converts a fixed-pint number.

This conversion may fail (fallible) but does not lose precision (lossless).

impl<Frac: LeEqU128> LosslessTryFrom<bool> for FixedI128<Frac>

fn lossless_try_from(src: bool) -> Option<Self>

Converts an integer to a fixed-point number.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl<Frac: LeEqU128> LosslessTryFrom<f16> for FixedI128<Frac> where
    U24: IsLessOrEqual<Frac, Output = True>, 

fn lossless_try_from(src: f16) -> Option<Self>

Converts a floating-point number to a fixed-point number.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl<Frac: LeEqU128> LosslessTryFrom<i128> for FixedI128<Frac>

fn lossless_try_from(src: i128) -> Option<Self>

Converts an integer to a fixed-point number.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl<Frac: LeEqU128> LosslessTryFrom<i16> for FixedI128<Frac>

fn lossless_try_from(src: i16) -> Option<Self>

Converts an integer to a fixed-point number.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl<Frac: LeEqU128> LosslessTryFrom<i32> for FixedI128<Frac>

fn lossless_try_from(src: i32) -> Option<Self>

Converts an integer to a fixed-point number.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl<Frac: LeEqU128> LosslessTryFrom<i64> for FixedI128<Frac>

fn lossless_try_from(src: i64) -> Option<Self>

Converts an integer to a fixed-point number.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl<Frac: LeEqU128> LosslessTryFrom<i8> for FixedI128<Frac>

fn lossless_try_from(src: i8) -> Option<Self>

Converts an integer to a fixed-point number.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl<Frac: LeEqU128> LosslessTryFrom<isize> for FixedI128<Frac>

fn lossless_try_from(src: isize) -> Option<Self>

Converts an integer to a fixed-point number.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl<Frac: LeEqU128> LosslessTryFrom<u128> for FixedI128<Frac>

fn lossless_try_from(src: u128) -> Option<Self>

Converts an integer to a fixed-point number.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl<Frac: LeEqU128> LosslessTryFrom<u16> for FixedI128<Frac>

fn lossless_try_from(src: u16) -> Option<Self>

Converts an integer to a fixed-point number.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl<Frac: LeEqU128> LosslessTryFrom<u32> for FixedI128<Frac>

fn lossless_try_from(src: u32) -> Option<Self>

Converts an integer to a fixed-point number.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl<Frac: LeEqU128> LosslessTryFrom<u64> for FixedI128<Frac>

fn lossless_try_from(src: u64) -> Option<Self>

Converts an integer to a fixed-point number.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl<Frac: LeEqU128> LosslessTryFrom<u8> for FixedI128<Frac>

fn lossless_try_from(src: u8) -> Option<Self>

Converts an integer to a fixed-point number.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl<Frac: LeEqU128> LosslessTryFrom<usize> for FixedI128<Frac>

fn lossless_try_from(src: usize) -> Option<Self>

Converts an integer to a fixed-point number.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl<Frac: LeEqU128> LossyFrom<FixedI128<Frac>> for f16

fn lossy_from(src: FixedI128<Frac>) -> f16

Converts a fixed-point number to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl<Frac: LeEqU128> LossyFrom<FixedI128<Frac>> for bf16

fn lossy_from(src: FixedI128<Frac>) -> bf16

Converts a fixed-point number to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl<Frac: LeEqU128> LossyFrom<FixedI128<Frac>> for f32

fn lossy_from(src: FixedI128<Frac>) -> f32

Converts a fixed-point number to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl<Frac: LeEqU128> LossyFrom<FixedI128<Frac>> for f64

fn lossy_from(src: FixedI128<Frac>) -> f64

Converts a fixed-point number to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl<FracSrc: LeEqU128, FracDst: LeEqU8> LossyFrom<FixedI128<FracSrc>> for FixedI8<FracDst> where
    U128: Sub<FracSrc>,
    U8: Sub<FracDst>,
    Diff<U128, FracSrc>: IsLessOrEqual<Diff<U8, FracDst>, Output = True>, 

fn lossy_from(src: FixedI128<FracSrc>) -> Self

Converts a fixed-pint number.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU128, FracDst: LeEqU16> LossyFrom<FixedI128<FracSrc>> for FixedI16<FracDst> where
    U128: Sub<FracSrc>,
    U16: Sub<FracDst>,
    Diff<U128, FracSrc>: IsLessOrEqual<Diff<U16, FracDst>, Output = True>, 

fn lossy_from(src: FixedI128<FracSrc>) -> Self

Converts a fixed-pint number.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU128> LossyFrom<FixedI128<FracSrc>> for isize where
    U128: Sub<FracSrc>,
    Diff<U128, FracSrc>: IsLessOrEqual<U16, Output = True>, 

fn lossy_from(src: FixedI128<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU128, FracDst: LeEqU32> LossyFrom<FixedI128<FracSrc>> for FixedI32<FracDst> where
    U128: Sub<FracSrc>,
    U32: Sub<FracDst>,
    Diff<U128, FracSrc>: IsLessOrEqual<Diff<U32, FracDst>, Output = True>, 

fn lossy_from(src: FixedI128<FracSrc>) -> Self

Converts a fixed-pint number.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU128, FracDst: LeEqU64> LossyFrom<FixedI128<FracSrc>> for FixedI64<FracDst> where
    U128: Sub<FracSrc>,
    U64: Sub<FracDst>,
    Diff<U128, FracSrc>: IsLessOrEqual<Diff<U64, FracDst>, Output = True>, 

fn lossy_from(src: FixedI128<FracSrc>) -> Self

Converts a fixed-pint number.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU128, FracDst: LeEqU128> LossyFrom<FixedI128<FracSrc>> for FixedI128<FracDst> where
    U128: Sub<FracSrc>,
    U128: Sub<FracDst>,
    Diff<U128, FracSrc>: IsLessOrEqual<Diff<U128, FracDst>, Output = True>, 

fn lossy_from(src: FixedI128<FracSrc>) -> Self

Converts a fixed-pint number.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU128> LossyFrom<FixedI128<FracSrc>> for i8 where
    U128: Sub<FracSrc>,
    Diff<U128, FracSrc>: IsLessOrEqual<U8, Output = True>, 

fn lossy_from(src: FixedI128<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU128> LossyFrom<FixedI128<FracSrc>> for i16 where
    U128: Sub<FracSrc>,
    Diff<U128, FracSrc>: IsLessOrEqual<U16, Output = True>, 

fn lossy_from(src: FixedI128<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU128> LossyFrom<FixedI128<FracSrc>> for i32 where
    U128: Sub<FracSrc>,
    Diff<U128, FracSrc>: IsLessOrEqual<U32, Output = True>, 

fn lossy_from(src: FixedI128<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU128> LossyFrom<FixedI128<FracSrc>> for i64 where
    U128: Sub<FracSrc>,
    Diff<U128, FracSrc>: IsLessOrEqual<U64, Output = True>, 

fn lossy_from(src: FixedI128<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU128> LossyFrom<FixedI128<FracSrc>> for i128 where
    U128: Sub<FracSrc>,
    Diff<U128, FracSrc>: IsLessOrEqual<U128, Output = True>, 

fn lossy_from(src: FixedI128<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU16, FracDst: LeEqU128> LossyFrom<FixedI16<FracSrc>> for FixedI128<FracDst> where
    U16: Sub<FracSrc>,
    U128: Sub<FracDst>,
    Diff<U16, FracSrc>: IsLessOrEqual<Diff<U128, FracDst>, Output = True>, 

fn lossy_from(src: FixedI16<FracSrc>) -> Self

Converts a fixed-pint number.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU32, FracDst: LeEqU128> LossyFrom<FixedI32<FracSrc>> for FixedI128<FracDst> where
    U32: Sub<FracSrc>,
    U128: Sub<FracDst>,
    Diff<U32, FracSrc>: IsLessOrEqual<Diff<U128, FracDst>, Output = True>, 

fn lossy_from(src: FixedI32<FracSrc>) -> Self

Converts a fixed-pint number.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU64, FracDst: LeEqU128> LossyFrom<FixedI64<FracSrc>> for FixedI128<FracDst> where
    U64: Sub<FracSrc>,
    U128: Sub<FracDst>,
    Diff<U64, FracSrc>: IsLessOrEqual<Diff<U128, FracDst>, Output = True>, 

fn lossy_from(src: FixedI64<FracSrc>) -> Self

Converts a fixed-pint number.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU8, FracDst: LeEqU128> LossyFrom<FixedI8<FracSrc>> for FixedI128<FracDst> where
    U8: Sub<FracSrc>,
    U128: Sub<FracDst>,
    Diff<U8, FracSrc>: IsLessOrEqual<Diff<U128, FracDst>, Output = True>, 

fn lossy_from(src: FixedI8<FracSrc>) -> Self

Converts a fixed-pint number.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU128, FracDst: LeEqU128> LossyFrom<FixedU128<FracSrc>> for FixedI128<FracDst> where
    U128: Sub<FracSrc>,
    U127: Sub<FracDst>,
    Diff<U128, FracSrc>: IsLessOrEqual<Diff<U127, FracDst>, Output = True>, 

fn lossy_from(src: FixedU128<FracSrc>) -> Self

Converts a fixed-pint number.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU16, FracDst: LeEqU128> LossyFrom<FixedU16<FracSrc>> for FixedI128<FracDst> where
    U16: Sub<FracSrc>,
    U127: Sub<FracDst>,
    Diff<U16, FracSrc>: IsLessOrEqual<Diff<U127, FracDst>, Output = True>, 

fn lossy_from(src: FixedU16<FracSrc>) -> Self

Converts a fixed-pint number.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU32, FracDst: LeEqU128> LossyFrom<FixedU32<FracSrc>> for FixedI128<FracDst> where
    U32: Sub<FracSrc>,
    U127: Sub<FracDst>,
    Diff<U32, FracSrc>: IsLessOrEqual<Diff<U127, FracDst>, Output = True>, 

fn lossy_from(src: FixedU32<FracSrc>) -> Self

Converts a fixed-pint number.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU64, FracDst: LeEqU128> LossyFrom<FixedU64<FracSrc>> for FixedI128<FracDst> where
    U64: Sub<FracSrc>,
    U127: Sub<FracDst>,
    Diff<U64, FracSrc>: IsLessOrEqual<Diff<U127, FracDst>, Output = True>, 

fn lossy_from(src: FixedU64<FracSrc>) -> Self

Converts a fixed-pint number.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU8, FracDst: LeEqU128> LossyFrom<FixedU8<FracSrc>> for FixedI128<FracDst> where
    U8: Sub<FracSrc>,
    U127: Sub<FracDst>,
    Diff<U8, FracSrc>: IsLessOrEqual<Diff<U127, FracDst>, Output = True>, 

fn lossy_from(src: FixedU8<FracSrc>) -> Self

Converts a fixed-pint number.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl<FracDst: LeEqU128> LossyFrom<bool> for FixedI128<FracDst> where
    U127: Sub<FracDst>,
    U1: IsLessOrEqual<Diff<U127, FracDst>, Output = True>, 

fn lossy_from(src: bool) -> Self

Converts a bool to a fixed-point number.

This conversion never fails (infallible) and cannot lose any fractional bits, so it is actually lossless.

impl LossyFrom<i128> for FixedI128<U0>

fn lossy_from(src: i128) -> Self

Converts an integer to a fixed-point number.

This conversion never fails (infallible) and actually does not lose any precision (lossless).

impl<FracDst: LeEqU128> LossyFrom<i16> for FixedI128<FracDst> where
    U128: Sub<FracDst>,
    U16: IsLessOrEqual<Diff<U128, FracDst>, Output = True>, 

fn lossy_from(src: i16) -> Self

Converts an integer to a fixed-point number.

This conversion never fails (infallible) and cannot lose any fractional bits, so it is actually lossless.

impl<FracDst: LeEqU128> LossyFrom<i32> for FixedI128<FracDst> where
    U128: Sub<FracDst>,
    U32: IsLessOrEqual<Diff<U128, FracDst>, Output = True>, 

fn lossy_from(src: i32) -> Self

Converts an integer to a fixed-point number.

This conversion never fails (infallible) and cannot lose any fractional bits, so it is actually lossless.

impl<FracDst: LeEqU128> LossyFrom<i64> for FixedI128<FracDst> where
    U128: Sub<FracDst>,
    U64: IsLessOrEqual<Diff<U128, FracDst>, Output = True>, 

fn lossy_from(src: i64) -> Self

Converts an integer to a fixed-point number.

This conversion never fails (infallible) and cannot lose any fractional bits, so it is actually lossless.

impl<FracDst: LeEqU128> LossyFrom<i8> for FixedI128<FracDst> where
    U128: Sub<FracDst>,
    U8: IsLessOrEqual<Diff<U128, FracDst>, Output = True>, 

fn lossy_from(src: i8) -> Self

Converts an integer to a fixed-point number.

This conversion never fails (infallible) and cannot lose any fractional bits, so it is actually lossless.

impl<FracDst: LeEqU128> LossyFrom<u16> for FixedI128<FracDst> where
    U127: Sub<FracDst>,
    U16: IsLessOrEqual<Diff<U127, FracDst>, Output = True>, 

fn lossy_from(src: u16) -> Self

Converts an integer to a fixed-point number.

This conversion never fails (infallible) and cannot lose any fractional bits, so it is actually lossless.

impl<FracDst: LeEqU128> LossyFrom<u32> for FixedI128<FracDst> where
    U127: Sub<FracDst>,
    U32: IsLessOrEqual<Diff<U127, FracDst>, Output = True>, 

fn lossy_from(src: u32) -> Self

Converts an integer to a fixed-point number.

This conversion never fails (infallible) and cannot lose any fractional bits, so it is actually lossless.

impl<FracDst: LeEqU128> LossyFrom<u64> for FixedI128<FracDst> where
    U127: Sub<FracDst>,
    U64: IsLessOrEqual<Diff<U127, FracDst>, Output = True>, 

fn lossy_from(src: u64) -> Self

Converts an integer to a fixed-point number.

This conversion never fails (infallible) and cannot lose any fractional bits, so it is actually lossless.

impl<FracDst: LeEqU128> LossyFrom<u8> for FixedI128<FracDst> where
    U127: Sub<FracDst>,
    U8: IsLessOrEqual<Diff<U127, FracDst>, Output = True>, 

fn lossy_from(src: u8) -> Self

Converts an integer to a fixed-point number.

This conversion never fails (infallible) and cannot lose any fractional bits, so it is actually lossless.

impl<Frac: LeEqU128> LowerHex for FixedI128<Frac>

fn fmt(&self, f: &mut Formatter) -> FmtResult

Formats the value using the given formatter.

impl<'a, Frac: LeEqU128> Mul<&'a FixedI128<Frac>> for FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the * operator.

fn mul(self, rhs: &FixedI128<Frac>) -> FixedI128<Frac>

Performs the * operation.

impl<'a, 'b, Frac: LeEqU128> Mul<&'a FixedI128<Frac>> for &'b FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the * operator.

fn mul(self, rhs: &FixedI128<Frac>) -> FixedI128<Frac>

Performs the * operation.

impl<'a, Frac: LeEqU128> Mul<&'a FixedI128<Frac>> for i128

type Output = FixedI128<Frac>

The resulting type after applying the * operator.

fn mul(self, rhs: &FixedI128<Frac>) -> FixedI128<Frac>

Performs the * operation.

impl<'a, 'b, Frac: LeEqU128> Mul<&'a FixedI128<Frac>> for &'b i128

type Output = FixedI128<Frac>

The resulting type after applying the * operator.

fn mul(self, rhs: &FixedI128<Frac>) -> FixedI128<Frac>

Performs the * operation.

impl<'a, Frac: LeEqU128> Mul<&'a i128> for FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the * operator.

fn mul(self, rhs: &i128) -> FixedI128<Frac>

Performs the * operation.

impl<'a, 'b, Frac: LeEqU128> Mul<&'a i128> for &'b FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the * operator.

fn mul(self, rhs: &i128) -> FixedI128<Frac>

Performs the * operation.

impl<Frac: LeEqU128> Mul<FixedI128<Frac>> for FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the * operator.

fn mul(self, rhs: FixedI128<Frac>) -> FixedI128<Frac>

Performs the * operation.

impl<'a, Frac: LeEqU128> Mul<FixedI128<Frac>> for &'a FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the * operator.

fn mul(self, rhs: FixedI128<Frac>) -> FixedI128<Frac>

Performs the * operation.

impl<Frac: LeEqU128> Mul<FixedI128<Frac>> for i128

type Output = FixedI128<Frac>

The resulting type after applying the * operator.

fn mul(self, rhs: FixedI128<Frac>) -> FixedI128<Frac>

Performs the * operation.

impl<'a, Frac: LeEqU128> Mul<FixedI128<Frac>> for &'a i128

type Output = FixedI128<Frac>

The resulting type after applying the * operator.

fn mul(self, rhs: FixedI128<Frac>) -> FixedI128<Frac>

Performs the * operation.

impl<Frac: LeEqU128> Mul<i128> for FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the * operator.

fn mul(self, rhs: i128) -> FixedI128<Frac>

Performs the * operation.

impl<'a, Frac: LeEqU128> Mul<i128> for &'a FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the * operator.

fn mul(self, rhs: i128) -> FixedI128<Frac>

Performs the * operation.

impl<'a, Frac: LeEqU128> MulAssign<&'a FixedI128<Frac>> for FixedI128<Frac>

fn mul_assign(&mut self, rhs: &FixedI128<Frac>)

Performs the *= operation.

impl<'a, Frac: LeEqU128> MulAssign<&'a i128> for FixedI128<Frac>

fn mul_assign(&mut self, rhs: &i128)

Performs the *= operation.

impl<Frac: LeEqU128> MulAssign<FixedI128<Frac>> for FixedI128<Frac>

fn mul_assign(&mut self, rhs: FixedI128<Frac>)

Performs the *= operation.

impl<Frac: LeEqU128> MulAssign<i128> for FixedI128<Frac>

fn mul_assign(&mut self, rhs: i128)

Performs the *= operation.

impl<Frac> Neg for FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the - operator.

fn neg(self) -> FixedI128<Frac>

Performs the unary - operation.

impl<'a, Frac> Neg for &'a FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the - operator.

fn neg(self) -> FixedI128<Frac>

Performs the unary - operation.

impl<Frac> Not for FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the ! operator.

fn not(self) -> FixedI128<Frac>

Performs the unary ! operation.

impl<'a, Frac> Not for &'a FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the ! operator.

fn not(self) -> FixedI128<Frac>

Performs the unary ! operation.

impl<Frac: LeEqU128> Octal for FixedI128<Frac>

fn fmt(&self, f: &mut Formatter) -> FmtResult

Formats the value using the given formatter.

impl<Frac: LeEqU128> Ord for FixedI128<Frac>

fn cmp(&self, rhs: &FixedI128<Frac>) -> Ordering

This method returns an [Ordering] between self and other.

#[must_use]fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]fn clamp(self, min: Self, max: Self) -> Self

🔬 This is a nightly-only experimental API. (clamp)

Restrict a value to a certain interval.

impl<Frac: LeEqU128> OverflowingCast<FixedI128<Frac>> for bool

fn overflowing_cast(self) -> (FixedI128<Frac>, bool)

Casts the value.

impl<Frac: LeEqU128> OverflowingCast<FixedI128<Frac>> for i8

fn overflowing_cast(self) -> (FixedI128<Frac>, bool)

Casts the value.

impl<Frac: LeEqU128> OverflowingCast<FixedI128<Frac>> for u64

fn overflowing_cast(self) -> (FixedI128<Frac>, bool)

Casts the value.

impl<Frac: LeEqU128> OverflowingCast<FixedI128<Frac>> for u128

fn overflowing_cast(self) -> (FixedI128<Frac>, bool)

Casts the value.

impl<Frac: LeEqU128> OverflowingCast<FixedI128<Frac>> for usize

fn overflowing_cast(self) -> (FixedI128<Frac>, bool)

Casts the value.

impl<Frac: LeEqU128> OverflowingCast<FixedI128<Frac>> for f32

fn overflowing_cast(self) -> (FixedI128<Frac>, bool)

Casts the value.

impl<Frac: LeEqU128> OverflowingCast<FixedI128<Frac>> for f64

fn overflowing_cast(self) -> (FixedI128<Frac>, bool)

Casts the value.

impl<Frac: LeEqU128> OverflowingCast<FixedI128<Frac>> for f16

fn overflowing_cast(self) -> (FixedI128<Frac>, bool)

Casts the value.

impl<Frac: LeEqU128> OverflowingCast<FixedI128<Frac>> for bf16

fn overflowing_cast(self) -> (FixedI128<Frac>, bool)

Casts the value.

impl<Frac: LeEqU128> OverflowingCast<FixedI128<Frac>> for i16

fn overflowing_cast(self) -> (FixedI128<Frac>, bool)

Casts the value.

impl<Frac: LeEqU128> OverflowingCast<FixedI128<Frac>> for i32

fn overflowing_cast(self) -> (FixedI128<Frac>, bool)

Casts the value.

impl<Frac: LeEqU128> OverflowingCast<FixedI128<Frac>> for i64

fn overflowing_cast(self) -> (FixedI128<Frac>, bool)

Casts the value.

impl<Frac: LeEqU128> OverflowingCast<FixedI128<Frac>> for i128

fn overflowing_cast(self) -> (FixedI128<Frac>, bool)

Casts the value.

impl<Frac: LeEqU128> OverflowingCast<FixedI128<Frac>> for isize

fn overflowing_cast(self) -> (FixedI128<Frac>, bool)

Casts the value.

impl<Frac: LeEqU128> OverflowingCast<FixedI128<Frac>> for u8

fn overflowing_cast(self) -> (FixedI128<Frac>, bool)

Casts the value.

impl<Frac: LeEqU128> OverflowingCast<FixedI128<Frac>> for u16

fn overflowing_cast(self) -> (FixedI128<Frac>, bool)

Casts the value.

impl<Frac: LeEqU128> OverflowingCast<FixedI128<Frac>> for u32

fn overflowing_cast(self) -> (FixedI128<Frac>, bool)

Casts the value.

impl<FracSrc: LeEqU8, FracDst: LeEqU128> OverflowingCast<FixedI128<FracDst>> for FixedI8<FracSrc>

fn overflowing_cast(self) -> (FixedI128<FracDst>, bool)

Casts the value.

impl<FracSrc: LeEqU16, FracDst: LeEqU128> OverflowingCast<FixedI128<FracDst>> for FixedI16<FracSrc>

fn overflowing_cast(self) -> (FixedI128<FracDst>, bool)

Casts the value.

impl<FracSrc: LeEqU32, FracDst: LeEqU128> OverflowingCast<FixedI128<FracDst>> for FixedI32<FracSrc>

fn overflowing_cast(self) -> (FixedI128<FracDst>, bool)

Casts the value.

impl<FracSrc: LeEqU64, FracDst: LeEqU128> OverflowingCast<FixedI128<FracDst>> for FixedI64<FracSrc>

fn overflowing_cast(self) -> (FixedI128<FracDst>, bool)

Casts the value.

impl<FracSrc: LeEqU128, FracDst: LeEqU128> OverflowingCast<FixedI128<FracDst>> for FixedI128<FracSrc>

fn overflowing_cast(self) -> (FixedI128<FracDst>, bool)

Casts the value.

impl<FracSrc: LeEqU8, FracDst: LeEqU128> OverflowingCast<FixedI128<FracDst>> for FixedU8<FracSrc>

fn overflowing_cast(self) -> (FixedI128<FracDst>, bool)

Casts the value.

impl<FracSrc: LeEqU16, FracDst: LeEqU128> OverflowingCast<FixedI128<FracDst>> for FixedU16<FracSrc>

fn overflowing_cast(self) -> (FixedI128<FracDst>, bool)

Casts the value.

impl<FracSrc: LeEqU32, FracDst: LeEqU128> OverflowingCast<FixedI128<FracDst>> for FixedU32<FracSrc>

fn overflowing_cast(self) -> (FixedI128<FracDst>, bool)

Casts the value.

impl<FracSrc: LeEqU64, FracDst: LeEqU128> OverflowingCast<FixedI128<FracDst>> for FixedU64<FracSrc>

fn overflowing_cast(self) -> (FixedI128<FracDst>, bool)

Casts the value.

impl<FracSrc: LeEqU128, FracDst: LeEqU128> OverflowingCast<FixedI128<FracDst>> for FixedU128<FracSrc>

fn overflowing_cast(self) -> (FixedI128<FracDst>, bool)

Casts the value.

impl<FracSrc: LeEqU128, FracDst: LeEqU16> OverflowingCast<FixedI16<FracDst>> for FixedI128<FracSrc>

fn overflowing_cast(self) -> (FixedI16<FracDst>, bool)

Casts the value.

impl<FracSrc: LeEqU128, FracDst: LeEqU32> OverflowingCast<FixedI32<FracDst>> for FixedI128<FracSrc>

fn overflowing_cast(self) -> (FixedI32<FracDst>, bool)

Casts the value.

impl<FracSrc: LeEqU128, FracDst: LeEqU64> OverflowingCast<FixedI64<FracDst>> for FixedI128<FracSrc>

fn overflowing_cast(self) -> (FixedI64<FracDst>, bool)

Casts the value.

impl<FracSrc: LeEqU128, FracDst: LeEqU8> OverflowingCast<FixedI8<FracDst>> for FixedI128<FracSrc>

fn overflowing_cast(self) -> (FixedI8<FracDst>, bool)

Casts the value.

impl<FracSrc: LeEqU128, FracDst: LeEqU128> OverflowingCast<FixedU128<FracDst>> for FixedI128<FracSrc>

fn overflowing_cast(self) -> (FixedU128<FracDst>, bool)

Casts the value.

impl<FracSrc: LeEqU128, FracDst: LeEqU16> OverflowingCast<FixedU16<FracDst>> for FixedI128<FracSrc>

fn overflowing_cast(self) -> (FixedU16<FracDst>, bool)

Casts the value.

impl<FracSrc: LeEqU128, FracDst: LeEqU32> OverflowingCast<FixedU32<FracDst>> for FixedI128<FracSrc>

fn overflowing_cast(self) -> (FixedU32<FracDst>, bool)

Casts the value.

impl<FracSrc: LeEqU128, FracDst: LeEqU64> OverflowingCast<FixedU64<FracDst>> for FixedI128<FracSrc>

fn overflowing_cast(self) -> (FixedU64<FracDst>, bool)

Casts the value.

impl<FracSrc: LeEqU128, FracDst: LeEqU8> OverflowingCast<FixedU8<FracDst>> for FixedI128<FracSrc>

fn overflowing_cast(self) -> (FixedU8<FracDst>, bool)

Casts the value.

impl<Frac: LeEqU128> OverflowingCast<bf16> for FixedI128<Frac>

fn overflowing_cast(self) -> (bf16, bool)

Casts the value.

impl<Frac: LeEqU128> OverflowingCast<f16> for FixedI128<Frac>

fn overflowing_cast(self) -> (f16, bool)

Casts the value.

impl<Frac: LeEqU128> OverflowingCast<f32> for FixedI128<Frac>

fn overflowing_cast(self) -> (f32, bool)

Casts the value.

impl<Frac: LeEqU128> OverflowingCast<f64> for FixedI128<Frac>

fn overflowing_cast(self) -> (f64, bool)

Casts the value.

impl<Frac: LeEqU128> OverflowingCast<i128> for FixedI128<Frac>

fn overflowing_cast(self) -> (i128, bool)

Casts the value.

impl<Frac: LeEqU128> OverflowingCast<i16> for FixedI128<Frac>

fn overflowing_cast(self) -> (i16, bool)

Casts the value.

impl<Frac: LeEqU128> OverflowingCast<i32> for FixedI128<Frac>

fn overflowing_cast(self) -> (i32, bool)

Casts the value.

impl<Frac: LeEqU128> OverflowingCast<i64> for FixedI128<Frac>

fn overflowing_cast(self) -> (i64, bool)

Casts the value.

impl<Frac: LeEqU128> OverflowingCast<i8> for FixedI128<Frac>

fn overflowing_cast(self) -> (i8, bool)

Casts the value.

impl<Frac: LeEqU128> OverflowingCast<isize> for FixedI128<Frac>

fn overflowing_cast(self) -> (isize, bool)

Casts the value.

impl<Frac: LeEqU128> OverflowingCast<u128> for FixedI128<Frac>

fn overflowing_cast(self) -> (u128, bool)

Casts the value.

impl<Frac: LeEqU128> OverflowingCast<u16> for FixedI128<Frac>

fn overflowing_cast(self) -> (u16, bool)

Casts the value.

impl<Frac: LeEqU128> OverflowingCast<u32> for FixedI128<Frac>

fn overflowing_cast(self) -> (u32, bool)

Casts the value.

impl<Frac: LeEqU128> OverflowingCast<u64> for FixedI128<Frac>

fn overflowing_cast(self) -> (u64, bool)

Casts the value.

impl<Frac: LeEqU128> OverflowingCast<u8> for FixedI128<Frac>

fn overflowing_cast(self) -> (u8, bool)

Casts the value.

impl<Frac: LeEqU128> OverflowingCast<usize> for FixedI128<Frac>

fn overflowing_cast(self) -> (usize, bool)

Casts the value.

impl<Frac: LeEqU128> PartialEq<FixedI128<Frac>> for i8

fn eq(&self, rhs: &FixedI128<Frac>) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<Frac: LeEqU128> PartialEq<FixedI128<Frac>> for i16

fn eq(&self, rhs: &FixedI128<Frac>) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<Frac: LeEqU128> PartialEq<FixedI128<Frac>> for u128

fn eq(&self, rhs: &FixedI128<Frac>) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<Frac: LeEqU128> PartialEq<FixedI128<Frac>> for usize

fn eq(&self, rhs: &FixedI128<Frac>) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<Frac: LeEqU128> PartialEq<FixedI128<Frac>> for f16

fn eq(&self, rhs: &FixedI128<Frac>) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<Frac: LeEqU128> PartialEq<FixedI128<Frac>> for bf16

fn eq(&self, rhs: &FixedI128<Frac>) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<Frac: LeEqU128> PartialEq<FixedI128<Frac>> for f32

fn eq(&self, rhs: &FixedI128<Frac>) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<Frac: LeEqU128> PartialEq<FixedI128<Frac>> for f64

fn eq(&self, rhs: &FixedI128<Frac>) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<Frac: LeEqU128> PartialEq<FixedI128<Frac>> for i32

fn eq(&self, rhs: &FixedI128<Frac>) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<Frac: LeEqU128> PartialEq<FixedI128<Frac>> for i64

fn eq(&self, rhs: &FixedI128<Frac>) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<Frac: LeEqU128> PartialEq<FixedI128<Frac>> for i128

fn eq(&self, rhs: &FixedI128<Frac>) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<Frac: LeEqU128> PartialEq<FixedI128<Frac>> for isize

fn eq(&self, rhs: &FixedI128<Frac>) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<Frac: LeEqU128> PartialEq<FixedI128<Frac>> for u8

fn eq(&self, rhs: &FixedI128<Frac>) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<Frac: LeEqU128> PartialEq<FixedI128<Frac>> for u16

fn eq(&self, rhs: &FixedI128<Frac>) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<Frac: LeEqU128> PartialEq<FixedI128<Frac>> for u32

fn eq(&self, rhs: &FixedI128<Frac>) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<Frac: LeEqU128> PartialEq<FixedI128<Frac>> for u64

fn eq(&self, rhs: &FixedI128<Frac>) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<FracLhs: LeEqU8, FracRhs: LeEqU128> PartialEq<FixedI128<FracRhs>> for FixedI8<FracLhs>

fn eq(&self, rhs: &FixedI128<FracRhs>) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<FracLhs: LeEqU16, FracRhs: LeEqU128> PartialEq<FixedI128<FracRhs>> for FixedI16<FracLhs>

fn eq(&self, rhs: &FixedI128<FracRhs>) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<FracLhs: LeEqU32, FracRhs: LeEqU128> PartialEq<FixedI128<FracRhs>> for FixedI32<FracLhs>

fn eq(&self, rhs: &FixedI128<FracRhs>) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<FracLhs: LeEqU64, FracRhs: LeEqU128> PartialEq<FixedI128<FracRhs>> for FixedI64<FracLhs>

fn eq(&self, rhs: &FixedI128<FracRhs>) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<FracLhs: LeEqU128, FracRhs: LeEqU128> PartialEq<FixedI128<FracRhs>> for FixedI128<FracLhs>

fn eq(&self, rhs: &FixedI128<FracRhs>) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<FracLhs: LeEqU8, FracRhs: LeEqU128> PartialEq<FixedI128<FracRhs>> for FixedU8<FracLhs>

fn eq(&self, rhs: &FixedI128<FracRhs>) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<FracLhs: LeEqU16, FracRhs: LeEqU128> PartialEq<FixedI128<FracRhs>> for FixedU16<FracLhs>

fn eq(&self, rhs: &FixedI128<FracRhs>) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<FracLhs: LeEqU32, FracRhs: LeEqU128> PartialEq<FixedI128<FracRhs>> for FixedU32<FracLhs>

fn eq(&self, rhs: &FixedI128<FracRhs>) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<FracLhs: LeEqU64, FracRhs: LeEqU128> PartialEq<FixedI128<FracRhs>> for FixedU64<FracLhs>

fn eq(&self, rhs: &FixedI128<FracRhs>) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<FracLhs: LeEqU128, FracRhs: LeEqU128> PartialEq<FixedI128<FracRhs>> for FixedU128<FracLhs>

fn eq(&self, rhs: &FixedI128<FracRhs>) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<FracLhs: LeEqU128, FracRhs: LeEqU16> PartialEq<FixedI16<FracRhs>> for FixedI128<FracLhs>

fn eq(&self, rhs: &FixedI16<FracRhs>) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<FracLhs: LeEqU128, FracRhs: LeEqU32> PartialEq<FixedI32<FracRhs>> for FixedI128<FracLhs>

fn eq(&self, rhs: &FixedI32<FracRhs>) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<FracLhs: LeEqU128, FracRhs: LeEqU64> PartialEq<FixedI64<FracRhs>> for FixedI128<FracLhs>

fn eq(&self, rhs: &FixedI64<FracRhs>) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<FracLhs: LeEqU128, FracRhs: LeEqU8> PartialEq<FixedI8<FracRhs>> for FixedI128<FracLhs>

fn eq(&self, rhs: &FixedI8<FracRhs>) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<FracLhs: LeEqU128, FracRhs: LeEqU128> PartialEq<FixedU128<FracRhs>> for FixedI128<FracLhs>

fn eq(&self, rhs: &FixedU128<FracRhs>) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<FracLhs: LeEqU128, FracRhs: LeEqU16> PartialEq<FixedU16<FracRhs>> for FixedI128<FracLhs>

fn eq(&self, rhs: &FixedU16<FracRhs>) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<FracLhs: LeEqU128, FracRhs: LeEqU32> PartialEq<FixedU32<FracRhs>> for FixedI128<FracLhs>

fn eq(&self, rhs: &FixedU32<FracRhs>) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<FracLhs: LeEqU128, FracRhs: LeEqU64> PartialEq<FixedU64<FracRhs>> for FixedI128<FracLhs>

fn eq(&self, rhs: &FixedU64<FracRhs>) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<FracLhs: LeEqU128, FracRhs: LeEqU8> PartialEq<FixedU8<FracRhs>> for FixedI128<FracLhs>

fn eq(&self, rhs: &FixedU8<FracRhs>) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<Frac: LeEqU128> PartialEq<bf16> for FixedI128<Frac>

fn eq(&self, rhs: &bf16) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<Frac: LeEqU128> PartialEq<f16> for FixedI128<Frac>

fn eq(&self, rhs: &f16) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<Frac: LeEqU128> PartialEq<f32> for FixedI128<Frac>

fn eq(&self, rhs: &f32) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<Frac: LeEqU128> PartialEq<f64> for FixedI128<Frac>

fn eq(&self, rhs: &f64) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<Frac: LeEqU128> PartialEq<i128> for FixedI128<Frac>

fn eq(&self, rhs: &i128) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<Frac: LeEqU128> PartialEq<i16> for FixedI128<Frac>

fn eq(&self, rhs: &i16) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<Frac: LeEqU128> PartialEq<i32> for FixedI128<Frac>

fn eq(&self, rhs: &i32) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<Frac: LeEqU128> PartialEq<i64> for FixedI128<Frac>

fn eq(&self, rhs: &i64) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<Frac: LeEqU128> PartialEq<i8> for FixedI128<Frac>

fn eq(&self, rhs: &i8) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<Frac: LeEqU128> PartialEq<isize> for FixedI128<Frac>

fn eq(&self, rhs: &isize) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<Frac: LeEqU128> PartialEq<u128> for FixedI128<Frac>

fn eq(&self, rhs: &u128) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<Frac: LeEqU128> PartialEq<u16> for FixedI128<Frac>

fn eq(&self, rhs: &u16) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<Frac: LeEqU128> PartialEq<u32> for FixedI128<Frac>

fn eq(&self, rhs: &u32) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<Frac: LeEqU128> PartialEq<u64> for FixedI128<Frac>

fn eq(&self, rhs: &u64) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<Frac: LeEqU128> PartialEq<u8> for FixedI128<Frac>

fn eq(&self, rhs: &u8) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<Frac: LeEqU128> PartialEq<usize> for FixedI128<Frac>

fn eq(&self, rhs: &usize) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<Frac: LeEqU128> PartialOrd<FixedI128<Frac>> for i8

fn partial_cmp(&self, rhs: &FixedI128<Frac>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, rhs: &FixedI128<Frac>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, rhs: &FixedI128<Frac>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, rhs: &FixedI128<Frac>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, rhs: &FixedI128<Frac>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<Frac: LeEqU128> PartialOrd<FixedI128<Frac>> for i16

fn partial_cmp(&self, rhs: &FixedI128<Frac>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, rhs: &FixedI128<Frac>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, rhs: &FixedI128<Frac>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, rhs: &FixedI128<Frac>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, rhs: &FixedI128<Frac>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<Frac: LeEqU128> PartialOrd<FixedI128<Frac>> for u128

fn partial_cmp(&self, rhs: &FixedI128<Frac>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, rhs: &FixedI128<Frac>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, rhs: &FixedI128<Frac>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, rhs: &FixedI128<Frac>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, rhs: &FixedI128<Frac>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<Frac: LeEqU128> PartialOrd<FixedI128<Frac>> for usize

fn partial_cmp(&self, rhs: &FixedI128<Frac>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, rhs: &FixedI128<Frac>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, rhs: &FixedI128<Frac>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, rhs: &FixedI128<Frac>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, rhs: &FixedI128<Frac>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<Frac: LeEqU128> PartialOrd<FixedI128<Frac>> for f16

fn partial_cmp(&self, rhs: &FixedI128<Frac>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, rhs: &FixedI128<Frac>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, rhs: &FixedI128<Frac>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, rhs: &FixedI128<Frac>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, rhs: &FixedI128<Frac>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<Frac: LeEqU128> PartialOrd<FixedI128<Frac>> for bf16

fn partial_cmp(&self, rhs: &FixedI128<Frac>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, rhs: &FixedI128<Frac>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, rhs: &FixedI128<Frac>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, rhs: &FixedI128<Frac>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, rhs: &FixedI128<Frac>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<Frac: LeEqU128> PartialOrd<FixedI128<Frac>> for f32

fn partial_cmp(&self, rhs: &FixedI128<Frac>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, rhs: &FixedI128<Frac>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, rhs: &FixedI128<Frac>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, rhs: &FixedI128<Frac>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, rhs: &FixedI128<Frac>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<Frac: LeEqU128> PartialOrd<FixedI128<Frac>> for f64

fn partial_cmp(&self, rhs: &FixedI128<Frac>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, rhs: &FixedI128<Frac>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, rhs: &FixedI128<Frac>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, rhs: &FixedI128<Frac>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, rhs: &FixedI128<Frac>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<Frac: LeEqU128> PartialOrd<FixedI128<Frac>> for i32

fn partial_cmp(&self, rhs: &FixedI128<Frac>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, rhs: &FixedI128<Frac>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, rhs: &FixedI128<Frac>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, rhs: &FixedI128<Frac>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, rhs: &FixedI128<Frac>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<Frac: LeEqU128> PartialOrd<FixedI128<Frac>> for i64

fn partial_cmp(&self, rhs: &FixedI128<Frac>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, rhs: &FixedI128<Frac>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, rhs: &FixedI128<Frac>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, rhs: &FixedI128<Frac>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, rhs: &FixedI128<Frac>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<Frac: LeEqU128> PartialOrd<FixedI128<Frac>> for i128

fn partial_cmp(&self, rhs: &FixedI128<Frac>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, rhs: &FixedI128<Frac>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, rhs: &FixedI128<Frac>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, rhs: &FixedI128<Frac>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, rhs: &FixedI128<Frac>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<Frac: LeEqU128> PartialOrd<FixedI128<Frac>> for isize

fn partial_cmp(&self, rhs: &FixedI128<Frac>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, rhs: &FixedI128<Frac>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, rhs: &FixedI128<Frac>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, rhs: &FixedI128<Frac>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, rhs: &FixedI128<Frac>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<Frac: LeEqU128> PartialOrd<FixedI128<Frac>> for u8

fn partial_cmp(&self, rhs: &FixedI128<Frac>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, rhs: &FixedI128<Frac>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, rhs: &FixedI128<Frac>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, rhs: &FixedI128<Frac>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, rhs: &FixedI128<Frac>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<Frac: LeEqU128> PartialOrd<FixedI128<Frac>> for u16

fn partial_cmp(&self, rhs: &FixedI128<Frac>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, rhs: &FixedI128<Frac>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, rhs: &FixedI128<Frac>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, rhs: &FixedI128<Frac>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, rhs: &FixedI128<Frac>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<Frac: LeEqU128> PartialOrd<FixedI128<Frac>> for u32

fn partial_cmp(&self, rhs: &FixedI128<Frac>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, rhs: &FixedI128<Frac>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, rhs: &FixedI128<Frac>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, rhs: &FixedI128<Frac>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, rhs: &FixedI128<Frac>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<Frac: LeEqU128> PartialOrd<FixedI128<Frac>> for u64

fn partial_cmp(&self, rhs: &FixedI128<Frac>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, rhs: &FixedI128<Frac>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, rhs: &FixedI128<Frac>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, rhs: &FixedI128<Frac>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, rhs: &FixedI128<Frac>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<FracLhs: LeEqU8, FracRhs: LeEqU128> PartialOrd<FixedI128<FracRhs>> for FixedI8<FracLhs>

fn partial_cmp(&self, rhs: &FixedI128<FracRhs>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, rhs: &FixedI128<FracRhs>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, rhs: &FixedI128<FracRhs>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, rhs: &FixedI128<FracRhs>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, rhs: &FixedI128<FracRhs>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<FracLhs: LeEqU16, FracRhs: LeEqU128> PartialOrd<FixedI128<FracRhs>> for FixedI16<FracLhs>

fn partial_cmp(&self, rhs: &FixedI128<FracRhs>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, rhs: &FixedI128<FracRhs>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, rhs: &FixedI128<FracRhs>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, rhs: &FixedI128<FracRhs>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, rhs: &FixedI128<FracRhs>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<FracLhs: LeEqU32, FracRhs: LeEqU128> PartialOrd<FixedI128<FracRhs>> for FixedI32<FracLhs>

fn partial_cmp(&self, rhs: &FixedI128<FracRhs>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, rhs: &FixedI128<FracRhs>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, rhs: &FixedI128<FracRhs>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, rhs: &FixedI128<FracRhs>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, rhs: &FixedI128<FracRhs>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<FracLhs: LeEqU64, FracRhs: LeEqU128> PartialOrd<FixedI128<FracRhs>> for FixedI64<FracLhs>

fn partial_cmp(&self, rhs: &FixedI128<FracRhs>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, rhs: &FixedI128<FracRhs>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, rhs: &FixedI128<FracRhs>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, rhs: &FixedI128<FracRhs>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, rhs: &FixedI128<FracRhs>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<FracLhs: LeEqU128, FracRhs: LeEqU128> PartialOrd<FixedI128<FracRhs>> for FixedI128<FracLhs>

fn partial_cmp(&self, rhs: &FixedI128<FracRhs>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, rhs: &FixedI128<FracRhs>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, rhs: &FixedI128<FracRhs>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, rhs: &FixedI128<FracRhs>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, rhs: &FixedI128<FracRhs>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<FracLhs: LeEqU8, FracRhs: LeEqU128> PartialOrd<FixedI128<FracRhs>> for FixedU8<FracLhs>

fn partial_cmp(&self, rhs: &FixedI128<FracRhs>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, rhs: &FixedI128<FracRhs>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, rhs: &FixedI128<FracRhs>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, rhs: &FixedI128<FracRhs>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, rhs: &FixedI128<FracRhs>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<FracLhs: LeEqU16, FracRhs: LeEqU128> PartialOrd<FixedI128<FracRhs>> for FixedU16<FracLhs>

fn partial_cmp(&self, rhs: &FixedI128<FracRhs>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, rhs: &FixedI128<FracRhs>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, rhs: &FixedI128<FracRhs>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, rhs: &FixedI128<FracRhs>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, rhs: &FixedI128<FracRhs>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<FracLhs: LeEqU32, FracRhs: LeEqU128> PartialOrd<FixedI128<FracRhs>> for FixedU32<FracLhs>

fn partial_cmp(&self, rhs: &FixedI128<FracRhs>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, rhs: &FixedI128<FracRhs>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, rhs: &FixedI128<FracRhs>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, rhs: &FixedI128<FracRhs>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, rhs: &FixedI128<FracRhs>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<FracLhs: LeEqU64, FracRhs: LeEqU128> PartialOrd<FixedI128<FracRhs>> for FixedU64<FracLhs>

fn partial_cmp(&self, rhs: &FixedI128<FracRhs>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, rhs: &FixedI128<FracRhs>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, rhs: &FixedI128<FracRhs>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, rhs: &FixedI128<FracRhs>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, rhs: &FixedI128<FracRhs>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<FracLhs: LeEqU128, FracRhs: LeEqU128> PartialOrd<FixedI128<FracRhs>> for FixedU128<FracLhs>

fn partial_cmp(&self, rhs: &FixedI128<FracRhs>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, rhs: &FixedI128<FracRhs>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, rhs: &FixedI128<FracRhs>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, rhs: &FixedI128<FracRhs>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, rhs: &FixedI128<FracRhs>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<FracLhs: LeEqU128, FracRhs: LeEqU16> PartialOrd<FixedI16<FracRhs>> for FixedI128<FracLhs>

fn partial_cmp(&self, rhs: &FixedI16<FracRhs>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, rhs: &FixedI16<FracRhs>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, rhs: &FixedI16<FracRhs>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, rhs: &FixedI16<FracRhs>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, rhs: &FixedI16<FracRhs>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<FracLhs: LeEqU128, FracRhs: LeEqU32> PartialOrd<FixedI32<FracRhs>> for FixedI128<FracLhs>

fn partial_cmp(&self, rhs: &FixedI32<FracRhs>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, rhs: &FixedI32<FracRhs>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, rhs: &FixedI32<FracRhs>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, rhs: &FixedI32<FracRhs>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, rhs: &FixedI32<FracRhs>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<FracLhs: LeEqU128, FracRhs: LeEqU64> PartialOrd<FixedI64<FracRhs>> for FixedI128<FracLhs>

fn partial_cmp(&self, rhs: &FixedI64<FracRhs>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, rhs: &FixedI64<FracRhs>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, rhs: &FixedI64<FracRhs>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, rhs: &FixedI64<FracRhs>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, rhs: &FixedI64<FracRhs>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<FracLhs: LeEqU128, FracRhs: LeEqU8> PartialOrd<FixedI8<FracRhs>> for FixedI128<FracLhs>

fn partial_cmp(&self, rhs: &FixedI8<FracRhs>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, rhs: &FixedI8<FracRhs>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, rhs: &FixedI8<FracRhs>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, rhs: &FixedI8<FracRhs>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, rhs: &FixedI8<FracRhs>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<FracLhs: LeEqU128, FracRhs: LeEqU128> PartialOrd<FixedU128<FracRhs>> for FixedI128<FracLhs>

fn partial_cmp(&self, rhs: &FixedU128<FracRhs>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, rhs: &FixedU128<FracRhs>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, rhs: &FixedU128<FracRhs>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, rhs: &FixedU128<FracRhs>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, rhs: &FixedU128<FracRhs>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<FracLhs: LeEqU128, FracRhs: LeEqU16> PartialOrd<FixedU16<FracRhs>> for FixedI128<FracLhs>

fn partial_cmp(&self, rhs: &FixedU16<FracRhs>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, rhs: &FixedU16<FracRhs>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, rhs: &FixedU16<FracRhs>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, rhs: &FixedU16<FracRhs>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, rhs: &FixedU16<FracRhs>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<FracLhs: LeEqU128, FracRhs: LeEqU32> PartialOrd<FixedU32<FracRhs>> for FixedI128<FracLhs>

fn partial_cmp(&self, rhs: &FixedU32<FracRhs>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, rhs: &FixedU32<FracRhs>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, rhs: &FixedU32<FracRhs>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, rhs: &FixedU32<FracRhs>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, rhs: &FixedU32<FracRhs>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<FracLhs: LeEqU128, FracRhs: LeEqU64> PartialOrd<FixedU64<FracRhs>> for FixedI128<FracLhs>

fn partial_cmp(&self, rhs: &FixedU64<FracRhs>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, rhs: &FixedU64<FracRhs>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, rhs: &FixedU64<FracRhs>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, rhs: &FixedU64<FracRhs>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, rhs: &FixedU64<FracRhs>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<FracLhs: LeEqU128, FracRhs: LeEqU8> PartialOrd<FixedU8<FracRhs>> for FixedI128<FracLhs>

fn partial_cmp(&self, rhs: &FixedU8<FracRhs>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, rhs: &FixedU8<FracRhs>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, rhs: &FixedU8<FracRhs>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, rhs: &FixedU8<FracRhs>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, rhs: &FixedU8<FracRhs>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<Frac: LeEqU128> PartialOrd<bf16> for FixedI128<Frac>

fn partial_cmp(&self, rhs: &bf16) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, rhs: &bf16) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, rhs: &bf16) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, rhs: &bf16) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, rhs: &bf16) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<Frac: LeEqU128> PartialOrd<f16> for FixedI128<Frac>

fn partial_cmp(&self, rhs: &f16) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, rhs: &f16) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, rhs: &f16) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, rhs: &f16) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, rhs: &f16) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<Frac: LeEqU128> PartialOrd<f32> for FixedI128<Frac>

fn partial_cmp(&self, rhs: &f32) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, rhs: &f32) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, rhs: &f32) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, rhs: &f32) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, rhs: &f32) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<Frac: LeEqU128> PartialOrd<f64> for FixedI128<Frac>

fn partial_cmp(&self, rhs: &f64) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, rhs: &f64) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, rhs: &f64) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, rhs: &f64) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, rhs: &f64) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<Frac: LeEqU128> PartialOrd<i128> for FixedI128<Frac>

fn partial_cmp(&self, rhs: &i128) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, rhs: &i128) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, rhs: &i128) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, rhs: &i128) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, rhs: &i128) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<Frac: LeEqU128> PartialOrd<i16> for FixedI128<Frac>

fn partial_cmp(&self, rhs: &i16) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, rhs: &i16) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, rhs: &i16) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, rhs: &i16) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, rhs: &i16) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<Frac: LeEqU128> PartialOrd<i32> for FixedI128<Frac>

fn partial_cmp(&self, rhs: &i32) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, rhs: &i32) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, rhs: &i32) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, rhs: &i32) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, rhs: &i32) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<Frac: LeEqU128> PartialOrd<i64> for FixedI128<Frac>

fn partial_cmp(&self, rhs: &i64) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, rhs: &i64) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, rhs: &i64) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, rhs: &i64) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, rhs: &i64) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<Frac: LeEqU128> PartialOrd<i8> for FixedI128<Frac>

fn partial_cmp(&self, rhs: &i8) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, rhs: &i8) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, rhs: &i8) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, rhs: &i8) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, rhs: &i8) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<Frac: LeEqU128> PartialOrd<isize> for FixedI128<Frac>

fn partial_cmp(&self, rhs: &isize) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, rhs: &isize) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, rhs: &isize) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, rhs: &isize) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, rhs: &isize) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<Frac: LeEqU128> PartialOrd<u128> for FixedI128<Frac>

fn partial_cmp(&self, rhs: &u128) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, rhs: &u128) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, rhs: &u128) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, rhs: &u128) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, rhs: &u128) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<Frac: LeEqU128> PartialOrd<u16> for FixedI128<Frac>

fn partial_cmp(&self, rhs: &u16) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, rhs: &u16) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, rhs: &u16) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, rhs: &u16) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, rhs: &u16) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<Frac: LeEqU128> PartialOrd<u32> for FixedI128<Frac>

fn partial_cmp(&self, rhs: &u32) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, rhs: &u32) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, rhs: &u32) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, rhs: &u32) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, rhs: &u32) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<Frac: LeEqU128> PartialOrd<u64> for FixedI128<Frac>

fn partial_cmp(&self, rhs: &u64) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, rhs: &u64) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, rhs: &u64) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, rhs: &u64) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, rhs: &u64) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<Frac: LeEqU128> PartialOrd<u8> for FixedI128<Frac>

fn partial_cmp(&self, rhs: &u8) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, rhs: &u8) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, rhs: &u8) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, rhs: &u8) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, rhs: &u8) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<Frac: LeEqU128> PartialOrd<usize> for FixedI128<Frac>

fn partial_cmp(&self, rhs: &usize) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, rhs: &usize) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, rhs: &usize) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, rhs: &usize) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, rhs: &usize) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'a, Frac: 'a + LeEqU128> Product<&'a FixedI128<Frac>> for FixedI128<Frac>

fn product<I>(iter: I) -> FixedI128<Frac> where
    I: Iterator<Item = &'a FixedI128<Frac>>, 

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<Frac: LeEqU128> Product<FixedI128<Frac>> for FixedI128<Frac>

fn product<I>(iter: I) -> FixedI128<Frac> where
    I: Iterator<Item = FixedI128<Frac>>, 

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<'a, Frac> Rem<&'a FixedI128<Frac>> for FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the % operator.

fn rem(self, rhs: &FixedI128<Frac>) -> FixedI128<Frac>

Performs the % operation.

impl<'a, 'b, Frac> Rem<&'a FixedI128<Frac>> for &'b FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the % operator.

fn rem(self, rhs: &FixedI128<Frac>) -> FixedI128<Frac>

Performs the % operation.

impl<'a, Frac: LeEqU128> Rem<&'a i128> for FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the % operator.

fn rem(self, rhs: &i128) -> FixedI128<Frac>

Performs the % operation.

impl<'a, 'b, Frac: LeEqU128> Rem<&'a i128> for &'b FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the % operator.

fn rem(self, rhs: &i128) -> FixedI128<Frac>

Performs the % operation.

impl<Frac> Rem<FixedI128<Frac>> for FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the % operator.

fn rem(self, rhs: FixedI128<Frac>) -> FixedI128<Frac>

Performs the % operation.

impl<'a, Frac> Rem<FixedI128<Frac>> for &'a FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the % operator.

fn rem(self, rhs: FixedI128<Frac>) -> FixedI128<Frac>

Performs the % operation.

impl<Frac: LeEqU128> Rem<i128> for FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the % operator.

fn rem(self, rhs: i128) -> FixedI128<Frac>

Performs the % operation.

impl<'a, Frac: LeEqU128> Rem<i128> for &'a FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the % operator.

fn rem(self, rhs: i128) -> FixedI128<Frac>

Performs the % operation.

impl<'a, Frac> RemAssign<&'a FixedI128<Frac>> for FixedI128<Frac>

fn rem_assign(&mut self, rhs: &FixedI128<Frac>)

Performs the %= operation.

impl<'a, Frac: LeEqU128> RemAssign<&'a i128> for FixedI128<Frac>

fn rem_assign(&mut self, rhs: &i128)

Performs the %= operation.

impl<Frac> RemAssign<FixedI128<Frac>> for FixedI128<Frac>

fn rem_assign(&mut self, rhs: FixedI128<Frac>)

Performs the %= operation.

impl<Frac: LeEqU128> RemAssign<i128> for FixedI128<Frac>

fn rem_assign(&mut self, rhs: i128)

Performs the %= operation.

impl<Frac: LeEqU128> SaturatingCast<FixedI128<Frac>> for bool

fn saturating_cast(self) -> FixedI128<Frac>

Casts the value.

impl<Frac: LeEqU128> SaturatingCast<FixedI128<Frac>> for i8

fn saturating_cast(self) -> FixedI128<Frac>

Casts the value.

impl<Frac: LeEqU128> SaturatingCast<FixedI128<Frac>> for u64

fn saturating_cast(self) -> FixedI128<Frac>

Casts the value.

impl<Frac: LeEqU128> SaturatingCast<FixedI128<Frac>> for u128

fn saturating_cast(self) -> FixedI128<Frac>

Casts the value.

impl<Frac: LeEqU128> SaturatingCast<FixedI128<Frac>> for usize

fn saturating_cast(self) -> FixedI128<Frac>

Casts the value.

impl<Frac: LeEqU128> SaturatingCast<FixedI128<Frac>> for f32

fn saturating_cast(self) -> FixedI128<Frac>

Casts the value.

impl<Frac: LeEqU128> SaturatingCast<FixedI128<Frac>> for f64

fn saturating_cast(self) -> FixedI128<Frac>

Casts the value.

impl<Frac: LeEqU128> SaturatingCast<FixedI128<Frac>> for f16

fn saturating_cast(self) -> FixedI128<Frac>

Casts the value.

impl<Frac: LeEqU128> SaturatingCast<FixedI128<Frac>> for bf16

fn saturating_cast(self) -> FixedI128<Frac>

Casts the value.

impl<Frac: LeEqU128> SaturatingCast<FixedI128<Frac>> for i16

fn saturating_cast(self) -> FixedI128<Frac>

Casts the value.

impl<Frac: LeEqU128> SaturatingCast<FixedI128<Frac>> for i32

fn saturating_cast(self) -> FixedI128<Frac>

Casts the value.

impl<Frac: LeEqU128> SaturatingCast<FixedI128<Frac>> for i64

fn saturating_cast(self) -> FixedI128<Frac>

Casts the value.

impl<Frac: LeEqU128> SaturatingCast<FixedI128<Frac>> for i128

fn saturating_cast(self) -> FixedI128<Frac>

Casts the value.

impl<Frac: LeEqU128> SaturatingCast<FixedI128<Frac>> for isize

fn saturating_cast(self) -> FixedI128<Frac>

Casts the value.

impl<Frac: LeEqU128> SaturatingCast<FixedI128<Frac>> for u8

fn saturating_cast(self) -> FixedI128<Frac>

Casts the value.

impl<Frac: LeEqU128> SaturatingCast<FixedI128<Frac>> for u16

fn saturating_cast(self) -> FixedI128<Frac>

Casts the value.

impl<Frac: LeEqU128> SaturatingCast<FixedI128<Frac>> for u32

fn saturating_cast(self) -> FixedI128<Frac>

Casts the value.

impl<FracSrc: LeEqU8, FracDst: LeEqU128> SaturatingCast<FixedI128<FracDst>> for FixedI8<FracSrc>

fn saturating_cast(self) -> FixedI128<FracDst>

Casts the value.

impl<FracSrc: LeEqU16, FracDst: LeEqU128> SaturatingCast<FixedI128<FracDst>> for FixedI16<FracSrc>

fn saturating_cast(self) -> FixedI128<FracDst>

Casts the value.

impl<FracSrc: LeEqU32, FracDst: LeEqU128> SaturatingCast<FixedI128<FracDst>> for FixedI32<FracSrc>

fn saturating_cast(self) -> FixedI128<FracDst>

Casts the value.

impl<FracSrc: LeEqU64, FracDst: LeEqU128> SaturatingCast<FixedI128<FracDst>> for FixedI64<FracSrc>

fn saturating_cast(self) -> FixedI128<FracDst>

Casts the value.

impl<FracSrc: LeEqU128, FracDst: LeEqU128> SaturatingCast<FixedI128<FracDst>> for FixedI128<FracSrc>

fn saturating_cast(self) -> FixedI128<FracDst>

Casts the value.

impl<FracSrc: LeEqU8, FracDst: LeEqU128> SaturatingCast<FixedI128<FracDst>> for FixedU8<FracSrc>

fn saturating_cast(self) -> FixedI128<FracDst>

Casts the value.

impl<FracSrc: LeEqU16, FracDst: LeEqU128> SaturatingCast<FixedI128<FracDst>> for FixedU16<FracSrc>

fn saturating_cast(self) -> FixedI128<FracDst>

Casts the value.

impl<FracSrc: LeEqU32, FracDst: LeEqU128> SaturatingCast<FixedI128<FracDst>> for FixedU32<FracSrc>

fn saturating_cast(self) -> FixedI128<FracDst>

Casts the value.

impl<FracSrc: LeEqU64, FracDst: LeEqU128> SaturatingCast<FixedI128<FracDst>> for FixedU64<FracSrc>

fn saturating_cast(self) -> FixedI128<FracDst>

Casts the value.

impl<FracSrc: LeEqU128, FracDst: LeEqU128> SaturatingCast<FixedI128<FracDst>> for FixedU128<FracSrc>

fn saturating_cast(self) -> FixedI128<FracDst>

Casts the value.

impl<FracSrc: LeEqU128, FracDst: LeEqU16> SaturatingCast<FixedI16<FracDst>> for FixedI128<FracSrc>

fn saturating_cast(self) -> FixedI16<FracDst>

Casts the value.

impl<FracSrc: LeEqU128, FracDst: LeEqU32> SaturatingCast<FixedI32<FracDst>> for FixedI128<FracSrc>

fn saturating_cast(self) -> FixedI32<FracDst>

Casts the value.

impl<FracSrc: LeEqU128, FracDst: LeEqU64> SaturatingCast<FixedI64<FracDst>> for FixedI128<FracSrc>

fn saturating_cast(self) -> FixedI64<FracDst>

Casts the value.

impl<FracSrc: LeEqU128, FracDst: LeEqU8> SaturatingCast<FixedI8<FracDst>> for FixedI128<FracSrc>

fn saturating_cast(self) -> FixedI8<FracDst>

Casts the value.

impl<FracSrc: LeEqU128, FracDst: LeEqU128> SaturatingCast<FixedU128<FracDst>> for FixedI128<FracSrc>

fn saturating_cast(self) -> FixedU128<FracDst>

Casts the value.

impl<FracSrc: LeEqU128, FracDst: LeEqU16> SaturatingCast<FixedU16<FracDst>> for FixedI128<FracSrc>

fn saturating_cast(self) -> FixedU16<FracDst>

Casts the value.

impl<FracSrc: LeEqU128, FracDst: LeEqU32> SaturatingCast<FixedU32<FracDst>> for FixedI128<FracSrc>

fn saturating_cast(self) -> FixedU32<FracDst>

Casts the value.

impl<FracSrc: LeEqU128, FracDst: LeEqU64> SaturatingCast<FixedU64<FracDst>> for FixedI128<FracSrc>

fn saturating_cast(self) -> FixedU64<FracDst>

Casts the value.

impl<FracSrc: LeEqU128, FracDst: LeEqU8> SaturatingCast<FixedU8<FracDst>> for FixedI128<FracSrc>

fn saturating_cast(self) -> FixedU8<FracDst>

Casts the value.

impl<Frac: LeEqU128> SaturatingCast<bf16> for FixedI128<Frac>

fn saturating_cast(self) -> bf16

Casts the value.

impl<Frac: LeEqU128> SaturatingCast<f16> for FixedI128<Frac>

fn saturating_cast(self) -> f16

Casts the value.

impl<Frac: LeEqU128> SaturatingCast<f32> for FixedI128<Frac>

fn saturating_cast(self) -> f32

Casts the value.

impl<Frac: LeEqU128> SaturatingCast<f64> for FixedI128<Frac>

fn saturating_cast(self) -> f64

Casts the value.

impl<Frac: LeEqU128> SaturatingCast<i128> for FixedI128<Frac>

fn saturating_cast(self) -> i128

Casts the value.

impl<Frac: LeEqU128> SaturatingCast<i16> for FixedI128<Frac>

fn saturating_cast(self) -> i16

Casts the value.

impl<Frac: LeEqU128> SaturatingCast<i32> for FixedI128<Frac>

fn saturating_cast(self) -> i32

Casts the value.

impl<Frac: LeEqU128> SaturatingCast<i64> for FixedI128<Frac>

fn saturating_cast(self) -> i64

Casts the value.

impl<Frac: LeEqU128> SaturatingCast<i8> for FixedI128<Frac>

fn saturating_cast(self) -> i8

Casts the value.

impl<Frac: LeEqU128> SaturatingCast<isize> for FixedI128<Frac>

fn saturating_cast(self) -> isize

Casts the value.

impl<Frac: LeEqU128> SaturatingCast<u128> for FixedI128<Frac>

fn saturating_cast(self) -> u128

Casts the value.

impl<Frac: LeEqU128> SaturatingCast<u16> for FixedI128<Frac>

fn saturating_cast(self) -> u16

Casts the value.

impl<Frac: LeEqU128> SaturatingCast<u32> for FixedI128<Frac>

fn saturating_cast(self) -> u32

Casts the value.

impl<Frac: LeEqU128> SaturatingCast<u64> for FixedI128<Frac>

fn saturating_cast(self) -> u64

Casts the value.

impl<Frac: LeEqU128> SaturatingCast<u8> for FixedI128<Frac>

fn saturating_cast(self) -> u8

Casts the value.

impl<Frac: LeEqU128> SaturatingCast<usize> for FixedI128<Frac>

fn saturating_cast(self) -> usize

Casts the value.

impl<Frac: LeEqU128> Serialize for FixedI128<Frac>

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl<'a, Frac> Shl<&'a i128> for FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: &i128) -> FixedI128<Frac>

Performs the << operation.

impl<'a, 'b, Frac> Shl<&'a i128> for &'b FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: &i128) -> FixedI128<Frac>

Performs the << operation.

impl<'a, Frac> Shl<&'a i16> for FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: &i16) -> FixedI128<Frac>

Performs the << operation.

impl<'a, 'b, Frac> Shl<&'a i16> for &'b FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: &i16) -> FixedI128<Frac>

Performs the << operation.

impl<'a, Frac> Shl<&'a i32> for FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: &i32) -> FixedI128<Frac>

Performs the << operation.

impl<'a, 'b, Frac> Shl<&'a i32> for &'b FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: &i32) -> FixedI128<Frac>

Performs the << operation.

impl<'a, Frac> Shl<&'a i64> for FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: &i64) -> FixedI128<Frac>

Performs the << operation.

impl<'a, 'b, Frac> Shl<&'a i64> for &'b FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: &i64) -> FixedI128<Frac>

Performs the << operation.

impl<'a, Frac> Shl<&'a i8> for FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: &i8) -> FixedI128<Frac>

Performs the << operation.

impl<'a, 'b, Frac> Shl<&'a i8> for &'b FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: &i8) -> FixedI128<Frac>

Performs the << operation.

impl<'a, Frac> Shl<&'a isize> for FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: &isize) -> FixedI128<Frac>

Performs the << operation.

impl<'a, 'b, Frac> Shl<&'a isize> for &'b FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: &isize) -> FixedI128<Frac>

Performs the << operation.

impl<'a, Frac> Shl<&'a u128> for FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: &u128) -> FixedI128<Frac>

Performs the << operation.

impl<'a, 'b, Frac> Shl<&'a u128> for &'b FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: &u128) -> FixedI128<Frac>

Performs the << operation.

impl<'a, Frac> Shl<&'a u16> for FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: &u16) -> FixedI128<Frac>

Performs the << operation.

impl<'a, 'b, Frac> Shl<&'a u16> for &'b FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: &u16) -> FixedI128<Frac>

Performs the << operation.

impl<'a, Frac> Shl<&'a u32> for FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: &u32) -> FixedI128<Frac>

Performs the << operation.

impl<'a, 'b, Frac> Shl<&'a u32> for &'b FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: &u32) -> FixedI128<Frac>

Performs the << operation.

impl<'a, Frac> Shl<&'a u64> for FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: &u64) -> FixedI128<Frac>

Performs the << operation.

impl<'a, 'b, Frac> Shl<&'a u64> for &'b FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: &u64) -> FixedI128<Frac>

Performs the << operation.

impl<'a, Frac> Shl<&'a u8> for FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: &u8) -> FixedI128<Frac>

Performs the << operation.

impl<'a, 'b, Frac> Shl<&'a u8> for &'b FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: &u8) -> FixedI128<Frac>

Performs the << operation.

impl<'a, Frac> Shl<&'a usize> for FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: &usize) -> FixedI128<Frac>

Performs the << operation.

impl<'a, 'b, Frac> Shl<&'a usize> for &'b FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: &usize) -> FixedI128<Frac>

Performs the << operation.

impl<Frac> Shl<i128> for FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: i128) -> FixedI128<Frac>

Performs the << operation.

impl<'a, Frac> Shl<i128> for &'a FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: i128) -> FixedI128<Frac>

Performs the << operation.

impl<Frac> Shl<i16> for FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: i16) -> FixedI128<Frac>

Performs the << operation.

impl<'a, Frac> Shl<i16> for &'a FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: i16) -> FixedI128<Frac>

Performs the << operation.

impl<Frac> Shl<i32> for FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: i32) -> FixedI128<Frac>

Performs the << operation.

impl<'a, Frac> Shl<i32> for &'a FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: i32) -> FixedI128<Frac>

Performs the << operation.

impl<Frac> Shl<i64> for FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: i64) -> FixedI128<Frac>

Performs the << operation.

impl<'a, Frac> Shl<i64> for &'a FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: i64) -> FixedI128<Frac>

Performs the << operation.

impl<Frac> Shl<i8> for FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: i8) -> FixedI128<Frac>

Performs the << operation.

impl<'a, Frac> Shl<i8> for &'a FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: i8) -> FixedI128<Frac>

Performs the << operation.

impl<Frac> Shl<isize> for FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: isize) -> FixedI128<Frac>

Performs the << operation.

impl<'a, Frac> Shl<isize> for &'a FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: isize) -> FixedI128<Frac>

Performs the << operation.

impl<Frac> Shl<u128> for FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: u128) -> FixedI128<Frac>

Performs the << operation.

impl<'a, Frac> Shl<u128> for &'a FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: u128) -> FixedI128<Frac>

Performs the << operation.

impl<Frac> Shl<u16> for FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: u16) -> FixedI128<Frac>

Performs the << operation.

impl<'a, Frac> Shl<u16> for &'a FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: u16) -> FixedI128<Frac>

Performs the << operation.

impl<Frac> Shl<u32> for FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: u32) -> FixedI128<Frac>

Performs the << operation.

impl<'a, Frac> Shl<u32> for &'a FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: u32) -> FixedI128<Frac>

Performs the << operation.

impl<Frac> Shl<u64> for FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: u64) -> FixedI128<Frac>

Performs the << operation.

impl<'a, Frac> Shl<u64> for &'a FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: u64) -> FixedI128<Frac>

Performs the << operation.

impl<Frac> Shl<u8> for FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: u8) -> FixedI128<Frac>

Performs the << operation.

impl<'a, Frac> Shl<u8> for &'a FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: u8) -> FixedI128<Frac>

Performs the << operation.

impl<Frac> Shl<usize> for FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: usize) -> FixedI128<Frac>

Performs the << operation.

impl<'a, Frac> Shl<usize> for &'a FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: usize) -> FixedI128<Frac>

Performs the << operation.

impl<'a, Frac> ShlAssign<&'a i128> for FixedI128<Frac>

fn shl_assign(&mut self, rhs: &i128)

Performs the <<= operation.

impl<'a, Frac> ShlAssign<&'a i16> for FixedI128<Frac>

fn shl_assign(&mut self, rhs: &i16)

Performs the <<= operation.

impl<'a, Frac> ShlAssign<&'a i32> for FixedI128<Frac>

fn shl_assign(&mut self, rhs: &i32)

Performs the <<= operation.

impl<'a, Frac> ShlAssign<&'a i64> for FixedI128<Frac>

fn shl_assign(&mut self, rhs: &i64)

Performs the <<= operation.

impl<'a, Frac> ShlAssign<&'a i8> for FixedI128<Frac>

fn shl_assign(&mut self, rhs: &i8)

Performs the <<= operation.

impl<'a, Frac> ShlAssign<&'a isize> for FixedI128<Frac>

fn shl_assign(&mut self, rhs: &isize)

Performs the <<= operation.

impl<'a, Frac> ShlAssign<&'a u128> for FixedI128<Frac>

fn shl_assign(&mut self, rhs: &u128)

Performs the <<= operation.

impl<'a, Frac> ShlAssign<&'a u16> for FixedI128<Frac>

fn shl_assign(&mut self, rhs: &u16)

Performs the <<= operation.

impl<'a, Frac> ShlAssign<&'a u32> for FixedI128<Frac>

fn shl_assign(&mut self, rhs: &u32)

Performs the <<= operation.

impl<'a, Frac> ShlAssign<&'a u64> for FixedI128<Frac>

fn shl_assign(&mut self, rhs: &u64)

Performs the <<= operation.

impl<'a, Frac> ShlAssign<&'a u8> for FixedI128<Frac>

fn shl_assign(&mut self, rhs: &u8)

Performs the <<= operation.

impl<'a, Frac> ShlAssign<&'a usize> for FixedI128<Frac>

fn shl_assign(&mut self, rhs: &usize)

Performs the <<= operation.

impl<Frac> ShlAssign<i128> for FixedI128<Frac>

fn shl_assign(&mut self, rhs: i128)

Performs the <<= operation.

impl<Frac> ShlAssign<i16> for FixedI128<Frac>

fn shl_assign(&mut self, rhs: i16)

Performs the <<= operation.

impl<Frac> ShlAssign<i32> for FixedI128<Frac>

fn shl_assign(&mut self, rhs: i32)

Performs the <<= operation.

impl<Frac> ShlAssign<i64> for FixedI128<Frac>

fn shl_assign(&mut self, rhs: i64)

Performs the <<= operation.

impl<Frac> ShlAssign<i8> for FixedI128<Frac>

fn shl_assign(&mut self, rhs: i8)

Performs the <<= operation.

impl<Frac> ShlAssign<isize> for FixedI128<Frac>

fn shl_assign(&mut self, rhs: isize)

Performs the <<= operation.

impl<Frac> ShlAssign<u128> for FixedI128<Frac>

fn shl_assign(&mut self, rhs: u128)

Performs the <<= operation.

impl<Frac> ShlAssign<u16> for FixedI128<Frac>

fn shl_assign(&mut self, rhs: u16)

Performs the <<= operation.

impl<Frac> ShlAssign<u32> for FixedI128<Frac>

fn shl_assign(&mut self, rhs: u32)

Performs the <<= operation.

impl<Frac> ShlAssign<u64> for FixedI128<Frac>

fn shl_assign(&mut self, rhs: u64)

Performs the <<= operation.

impl<Frac> ShlAssign<u8> for FixedI128<Frac>

fn shl_assign(&mut self, rhs: u8)

Performs the <<= operation.

impl<Frac> ShlAssign<usize> for FixedI128<Frac>

fn shl_assign(&mut self, rhs: usize)

Performs the <<= operation.

impl<'a, Frac> Shr<&'a i128> for FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: &i128) -> FixedI128<Frac>

Performs the >> operation.

impl<'a, 'b, Frac> Shr<&'a i128> for &'b FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: &i128) -> FixedI128<Frac>

Performs the >> operation.

impl<'a, Frac> Shr<&'a i16> for FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: &i16) -> FixedI128<Frac>

Performs the >> operation.

impl<'a, 'b, Frac> Shr<&'a i16> for &'b FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: &i16) -> FixedI128<Frac>

Performs the >> operation.

impl<'a, Frac> Shr<&'a i32> for FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: &i32) -> FixedI128<Frac>

Performs the >> operation.

impl<'a, 'b, Frac> Shr<&'a i32> for &'b FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: &i32) -> FixedI128<Frac>

Performs the >> operation.

impl<'a, Frac> Shr<&'a i64> for FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: &i64) -> FixedI128<Frac>

Performs the >> operation.

impl<'a, 'b, Frac> Shr<&'a i64> for &'b FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: &i64) -> FixedI128<Frac>

Performs the >> operation.

impl<'a, Frac> Shr<&'a i8> for FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: &i8) -> FixedI128<Frac>

Performs the >> operation.

impl<'a, 'b, Frac> Shr<&'a i8> for &'b FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: &i8) -> FixedI128<Frac>

Performs the >> operation.

impl<'a, Frac> Shr<&'a isize> for FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: &isize) -> FixedI128<Frac>

Performs the >> operation.

impl<'a, 'b, Frac> Shr<&'a isize> for &'b FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: &isize) -> FixedI128<Frac>

Performs the >> operation.

impl<'a, Frac> Shr<&'a u128> for FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: &u128) -> FixedI128<Frac>

Performs the >> operation.

impl<'a, 'b, Frac> Shr<&'a u128> for &'b FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: &u128) -> FixedI128<Frac>

Performs the >> operation.

impl<'a, Frac> Shr<&'a u16> for FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: &u16) -> FixedI128<Frac>

Performs the >> operation.

impl<'a, 'b, Frac> Shr<&'a u16> for &'b FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: &u16) -> FixedI128<Frac>

Performs the >> operation.

impl<'a, Frac> Shr<&'a u32> for FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: &u32) -> FixedI128<Frac>

Performs the >> operation.

impl<'a, 'b, Frac> Shr<&'a u32> for &'b FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: &u32) -> FixedI128<Frac>

Performs the >> operation.

impl<'a, Frac> Shr<&'a u64> for FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: &u64) -> FixedI128<Frac>

Performs the >> operation.

impl<'a, 'b, Frac> Shr<&'a u64> for &'b FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: &u64) -> FixedI128<Frac>

Performs the >> operation.

impl<'a, Frac> Shr<&'a u8> for FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: &u8) -> FixedI128<Frac>

Performs the >> operation.

impl<'a, 'b, Frac> Shr<&'a u8> for &'b FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: &u8) -> FixedI128<Frac>

Performs the >> operation.

impl<'a, Frac> Shr<&'a usize> for FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: &usize) -> FixedI128<Frac>

Performs the >> operation.

impl<'a, 'b, Frac> Shr<&'a usize> for &'b FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: &usize) -> FixedI128<Frac>

Performs the >> operation.

impl<Frac> Shr<i128> for FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: i128) -> FixedI128<Frac>

Performs the >> operation.

impl<'a, Frac> Shr<i128> for &'a FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: i128) -> FixedI128<Frac>

Performs the >> operation.

impl<Frac> Shr<i16> for FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: i16) -> FixedI128<Frac>

Performs the >> operation.

impl<'a, Frac> Shr<i16> for &'a FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: i16) -> FixedI128<Frac>

Performs the >> operation.

impl<Frac> Shr<i32> for FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: i32) -> FixedI128<Frac>

Performs the >> operation.

impl<'a, Frac> Shr<i32> for &'a FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: i32) -> FixedI128<Frac>

Performs the >> operation.

impl<Frac> Shr<i64> for FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: i64) -> FixedI128<Frac>

Performs the >> operation.

impl<'a, Frac> Shr<i64> for &'a FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: i64) -> FixedI128<Frac>

Performs the >> operation.

impl<Frac> Shr<i8> for FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: i8) -> FixedI128<Frac>

Performs the >> operation.

impl<'a, Frac> Shr<i8> for &'a FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: i8) -> FixedI128<Frac>

Performs the >> operation.

impl<Frac> Shr<isize> for FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: isize) -> FixedI128<Frac>

Performs the >> operation.

impl<'a, Frac> Shr<isize> for &'a FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: isize) -> FixedI128<Frac>

Performs the >> operation.

impl<Frac> Shr<u128> for FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: u128) -> FixedI128<Frac>

Performs the >> operation.

impl<'a, Frac> Shr<u128> for &'a FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: u128) -> FixedI128<Frac>

Performs the >> operation.

impl<Frac> Shr<u16> for FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: u16) -> FixedI128<Frac>

Performs the >> operation.

impl<'a, Frac> Shr<u16> for &'a FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: u16) -> FixedI128<Frac>

Performs the >> operation.

impl<Frac> Shr<u32> for FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: u32) -> FixedI128<Frac>

Performs the >> operation.

impl<'a, Frac> Shr<u32> for &'a FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: u32) -> FixedI128<Frac>

Performs the >> operation.

impl<Frac> Shr<u64> for FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: u64) -> FixedI128<Frac>

Performs the >> operation.

impl<'a, Frac> Shr<u64> for &'a FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: u64) -> FixedI128<Frac>

Performs the >> operation.

impl<Frac> Shr<u8> for FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: u8) -> FixedI128<Frac>

Performs the >> operation.

impl<'a, Frac> Shr<u8> for &'a FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: u8) -> FixedI128<Frac>

Performs the >> operation.

impl<Frac> Shr<usize> for FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: usize) -> FixedI128<Frac>

Performs the >> operation.

impl<'a, Frac> Shr<usize> for &'a FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: usize) -> FixedI128<Frac>

Performs the >> operation.

impl<'a, Frac> ShrAssign<&'a i128> for FixedI128<Frac>

fn shr_assign(&mut self, rhs: &i128)

Performs the >>= operation.

impl<'a, Frac> ShrAssign<&'a i16> for FixedI128<Frac>

fn shr_assign(&mut self, rhs: &i16)

Performs the >>= operation.

impl<'a, Frac> ShrAssign<&'a i32> for FixedI128<Frac>

fn shr_assign(&mut self, rhs: &i32)

Performs the >>= operation.

impl<'a, Frac> ShrAssign<&'a i64> for FixedI128<Frac>

fn shr_assign(&mut self, rhs: &i64)

Performs the >>= operation.

impl<'a, Frac> ShrAssign<&'a i8> for FixedI128<Frac>

fn shr_assign(&mut self, rhs: &i8)

Performs the >>= operation.

impl<'a, Frac> ShrAssign<&'a isize> for FixedI128<Frac>

fn shr_assign(&mut self, rhs: &isize)

Performs the >>= operation.

impl<'a, Frac> ShrAssign<&'a u128> for FixedI128<Frac>

fn shr_assign(&mut self, rhs: &u128)

Performs the >>= operation.

impl<'a, Frac> ShrAssign<&'a u16> for FixedI128<Frac>

fn shr_assign(&mut self, rhs: &u16)

Performs the >>= operation.

impl<'a, Frac> ShrAssign<&'a u32> for FixedI128<Frac>

fn shr_assign(&mut self, rhs: &u32)

Performs the >>= operation.

impl<'a, Frac> ShrAssign<&'a u64> for FixedI128<Frac>

fn shr_assign(&mut self, rhs: &u64)

Performs the >>= operation.

impl<'a, Frac> ShrAssign<&'a u8> for FixedI128<Frac>

fn shr_assign(&mut self, rhs: &u8)

Performs the >>= operation.

impl<'a, Frac> ShrAssign<&'a usize> for FixedI128<Frac>

fn shr_assign(&mut self, rhs: &usize)

Performs the >>= operation.

impl<Frac> ShrAssign<i128> for FixedI128<Frac>

fn shr_assign(&mut self, rhs: i128)

Performs the >>= operation.

impl<Frac> ShrAssign<i16> for FixedI128<Frac>

fn shr_assign(&mut self, rhs: i16)

Performs the >>= operation.

impl<Frac> ShrAssign<i32> for FixedI128<Frac>

fn shr_assign(&mut self, rhs: i32)

Performs the >>= operation.

impl<Frac> ShrAssign<i64> for FixedI128<Frac>

fn shr_assign(&mut self, rhs: i64)

Performs the >>= operation.

impl<Frac> ShrAssign<i8> for FixedI128<Frac>

fn shr_assign(&mut self, rhs: i8)

Performs the >>= operation.

impl<Frac> ShrAssign<isize> for FixedI128<Frac>

fn shr_assign(&mut self, rhs: isize)

Performs the >>= operation.

impl<Frac> ShrAssign<u128> for FixedI128<Frac>

fn shr_assign(&mut self, rhs: u128)

Performs the >>= operation.

impl<Frac> ShrAssign<u16> for FixedI128<Frac>

fn shr_assign(&mut self, rhs: u16)

Performs the >>= operation.

impl<Frac> ShrAssign<u32> for FixedI128<Frac>

fn shr_assign(&mut self, rhs: u32)

Performs the >>= operation.

impl<Frac> ShrAssign<u64> for FixedI128<Frac>

fn shr_assign(&mut self, rhs: u64)

Performs the >>= operation.

impl<Frac> ShrAssign<u8> for FixedI128<Frac>

fn shr_assign(&mut self, rhs: u8)

Performs the >>= operation.

impl<Frac> ShrAssign<usize> for FixedI128<Frac>

fn shr_assign(&mut self, rhs: usize)

Performs the >>= operation.

impl<Frac: LeEqU128> StaticCast<FixedI128<Frac>> for bool

Deprecated since 0.5.6:

deprecated in az crate since 0.3.1; use case is unclear

fn static_cast(self) -> Option<FixedI128<Frac>>

Deprecated since 0.3.1:

use case is unclear

Casts if the conversion works for all source type values, otherwise returns [None].

impl<Frac: LeEqU128> StaticCast<FixedI128<Frac>> for i8

Deprecated since 0.5.6:

deprecated in az crate since 0.3.1; use case is unclear

fn static_cast(self) -> Option<FixedI128<Frac>>

Deprecated since 0.3.1:

use case is unclear

Casts if the conversion works for all source type values, otherwise returns [None].

impl<Frac: LeEqU128> StaticCast<FixedI128<Frac>> for u128

Deprecated since 0.5.6:

deprecated in az crate since 0.3.1; use case is unclear

fn static_cast(self) -> Option<FixedI128<Frac>>

Deprecated since 0.3.1:

use case is unclear

Casts if the conversion works for all source type values, otherwise returns [None].

impl<Frac: LeEqU128> StaticCast<FixedI128<Frac>> for isize

Deprecated since 0.5.6:

deprecated in az crate since 0.3.1; use case is unclear

fn static_cast(self) -> Option<FixedI128<Frac>>

Deprecated since 0.3.1:

use case is unclear

Casts if the conversion works for all source type values, otherwise returns [None].

impl<Frac: LeEqU128> StaticCast<FixedI128<Frac>> for usize

Deprecated since 0.5.6:

deprecated in az crate since 0.3.1; use case is unclear

fn static_cast(self) -> Option<FixedI128<Frac>>

Deprecated since 0.3.1:

use case is unclear

Casts if the conversion works for all source type values, otherwise returns [None].

impl<Frac: LeEqU128> StaticCast<FixedI128<Frac>> for f32

Deprecated since 0.5.6:

deprecated in az crate since 0.3.1; use case is unclear

fn static_cast(self) -> Option<FixedI128<Frac>>

Deprecated since 0.3.1:

use case is unclear

Casts if the conversion works for all source type values, otherwise returns [None].

impl<Frac: LeEqU128> StaticCast<FixedI128<Frac>> for f64

Deprecated since 0.5.6:

deprecated in az crate since 0.3.1; use case is unclear

fn static_cast(self) -> Option<FixedI128<Frac>>

Deprecated since 0.3.1:

use case is unclear

Casts if the conversion works for all source type values, otherwise returns [None].

impl<Frac: LeEqU128> StaticCast<FixedI128<Frac>> for f16

Deprecated since 0.5.6:

deprecated in az crate since 0.3.1; use case is unclear

fn static_cast(self) -> Option<FixedI128<Frac>>

Deprecated since 0.3.1:

use case is unclear

Casts if the conversion works for all source type values, otherwise returns [None].

impl<Frac: LeEqU128> StaticCast<FixedI128<Frac>> for bf16

Deprecated since 0.5.6:

deprecated in az crate since 0.3.1; use case is unclear

fn static_cast(self) -> Option<FixedI128<Frac>>

Deprecated since 0.3.1:

use case is unclear

Casts if the conversion works for all source type values, otherwise returns [None].

impl<Frac: LeEqU128> StaticCast<FixedI128<Frac>> for u8

Deprecated since 0.5.6:

deprecated in az crate since 0.3.1; use case is unclear

fn static_cast(self) -> Option<FixedI128<Frac>>

Deprecated since 0.3.1:

use case is unclear

Casts if the conversion works for all source type values, otherwise returns [None].

impl<Frac: LeEqU128> StaticCast<FixedI128<Frac>> for i16

Deprecated since 0.5.6:

deprecated in az crate since 0.3.1; use case is unclear

fn static_cast(self) -> Option<FixedI128<Frac>>

Deprecated since 0.3.1:

use case is unclear

Casts if the conversion works for all source type values, otherwise returns [None].

impl<Frac: LeEqU128> StaticCast<FixedI128<Frac>> for u16

Deprecated since 0.5.6:

deprecated in az crate since 0.3.1; use case is unclear

fn static_cast(self) -> Option<FixedI128<Frac>>

Deprecated since 0.3.1:

use case is unclear

Casts if the conversion works for all source type values, otherwise returns [None].

impl<Frac: LeEqU128> StaticCast<FixedI128<Frac>> for i32

Deprecated since 0.5.6:

deprecated in az crate since 0.3.1; use case is unclear

fn static_cast(self) -> Option<FixedI128<Frac>>

Deprecated since 0.3.1:

use case is unclear

Casts if the conversion works for all source type values, otherwise returns [None].

impl<Frac: LeEqU128> StaticCast<FixedI128<Frac>> for u32

Deprecated since 0.5.6:

deprecated in az crate since 0.3.1; use case is unclear

fn static_cast(self) -> Option<FixedI128<Frac>>

Deprecated since 0.3.1:

use case is unclear

Casts if the conversion works for all source type values, otherwise returns [None].

impl<Frac: LeEqU128> StaticCast<FixedI128<Frac>> for i64

Deprecated since 0.5.6:

deprecated in az crate since 0.3.1; use case is unclear

fn static_cast(self) -> Option<FixedI128<Frac>>

Deprecated since 0.3.1:

use case is unclear

Casts if the conversion works for all source type values, otherwise returns [None].

impl<Frac: LeEqU128> StaticCast<FixedI128<Frac>> for u64

Deprecated since 0.5.6:

deprecated in az crate since 0.3.1; use case is unclear

fn static_cast(self) -> Option<FixedI128<Frac>>

Deprecated since 0.3.1:

use case is unclear

Casts if the conversion works for all source type values, otherwise returns [None].

impl<Frac: LeEqU128> StaticCast<FixedI128<Frac>> for i128

Deprecated since 0.5.6:

deprecated in az crate since 0.3.1; use case is unclear

fn static_cast(self) -> Option<FixedI128<Frac>>

Deprecated since 0.3.1:

use case is unclear

Casts if the conversion works for all source type values, otherwise returns [None].

impl<FracSrc: LeEqU8, FracDst: LeEqU128> StaticCast<FixedI128<FracDst>> for FixedI8<FracSrc>

Deprecated since 0.5.6:

deprecated in az crate since 0.3.1; use case is unclear

fn static_cast(self) -> Option<FixedI128<FracDst>>

Deprecated since 0.3.1:

use case is unclear

Casts if the conversion works for all source type values, otherwise returns [None].

impl<FracSrc: LeEqU8, FracDst: LeEqU128> StaticCast<FixedI128<FracDst>> for FixedU8<FracSrc>

Deprecated since 0.5.6:

deprecated in az crate since 0.3.1; use case is unclear

fn static_cast(self) -> Option<FixedI128<FracDst>>

Deprecated since 0.3.1:

use case is unclear

Casts if the conversion works for all source type values, otherwise returns [None].

impl<FracSrc: LeEqU16, FracDst: LeEqU128> StaticCast<FixedI128<FracDst>> for FixedI16<FracSrc>

Deprecated since 0.5.6:

deprecated in az crate since 0.3.1; use case is unclear

fn static_cast(self) -> Option<FixedI128<FracDst>>

Deprecated since 0.3.1:

use case is unclear

Casts if the conversion works for all source type values, otherwise returns [None].

impl<FracSrc: LeEqU16, FracDst: LeEqU128> StaticCast<FixedI128<FracDst>> for FixedU16<FracSrc>

Deprecated since 0.5.6:

deprecated in az crate since 0.3.1; use case is unclear

fn static_cast(self) -> Option<FixedI128<FracDst>>

Deprecated since 0.3.1:

use case is unclear

Casts if the conversion works for all source type values, otherwise returns [None].

impl<FracSrc: LeEqU32, FracDst: LeEqU128> StaticCast<FixedI128<FracDst>> for FixedI32<FracSrc>

Deprecated since 0.5.6:

deprecated in az crate since 0.3.1; use case is unclear

fn static_cast(self) -> Option<FixedI128<FracDst>>

Deprecated since 0.3.1:

use case is unclear

Casts if the conversion works for all source type values, otherwise returns [None].

impl<FracSrc: LeEqU32, FracDst: LeEqU128> StaticCast<FixedI128<FracDst>> for FixedU32<FracSrc>

Deprecated since 0.5.6:

deprecated in az crate since 0.3.1; use case is unclear

fn static_cast(self) -> Option<FixedI128<FracDst>>

Deprecated since 0.3.1:

use case is unclear

Casts if the conversion works for all source type values, otherwise returns [None].

impl<FracSrc: LeEqU64, FracDst: LeEqU128> StaticCast<FixedI128<FracDst>> for FixedI64<FracSrc>

Deprecated since 0.5.6:

deprecated in az crate since 0.3.1; use case is unclear

fn static_cast(self) -> Option<FixedI128<FracDst>>

Deprecated since 0.3.1:

use case is unclear

Casts if the conversion works for all source type values, otherwise returns [None].

impl<FracSrc: LeEqU64, FracDst: LeEqU128> StaticCast<FixedI128<FracDst>> for FixedU64<FracSrc>

Deprecated since 0.5.6:

deprecated in az crate since 0.3.1; use case is unclear

fn static_cast(self) -> Option<FixedI128<FracDst>>

Deprecated since 0.3.1:

use case is unclear

Casts if the conversion works for all source type values, otherwise returns [None].

impl<FracSrc: LeEqU128, FracDst: LeEqU128> StaticCast<FixedI128<FracDst>> for FixedI128<FracSrc>

Deprecated since 0.5.6:

deprecated in az crate since 0.3.1; use case is unclear

fn static_cast(self) -> Option<FixedI128<FracDst>>

Deprecated since 0.3.1:

use case is unclear

Casts if the conversion works for all source type values, otherwise returns [None].

impl<FracSrc: LeEqU128, FracDst: LeEqU128> StaticCast<FixedI128<FracDst>> for FixedU128<FracSrc>

Deprecated since 0.5.6:

deprecated in az crate since 0.3.1; use case is unclear

fn static_cast(self) -> Option<FixedI128<FracDst>>

Deprecated since 0.3.1:

use case is unclear

Casts if the conversion works for all source type values, otherwise returns [None].

impl<FracSrc: LeEqU128, FracDst: LeEqU16> StaticCast<FixedI16<FracDst>> for FixedI128<FracSrc>

Deprecated since 0.5.6:

deprecated in az crate since 0.3.1; use case is unclear

fn static_cast(self) -> Option<FixedI16<FracDst>>

Deprecated since 0.3.1:

use case is unclear

Casts if the conversion works for all source type values, otherwise returns [None].

impl<FracSrc: LeEqU128, FracDst: LeEqU32> StaticCast<FixedI32<FracDst>> for FixedI128<FracSrc>

Deprecated since 0.5.6:

deprecated in az crate since 0.3.1; use case is unclear

fn static_cast(self) -> Option<FixedI32<FracDst>>

Deprecated since 0.3.1:

use case is unclear

Casts if the conversion works for all source type values, otherwise returns [None].

impl<FracSrc: LeEqU128, FracDst: LeEqU64> StaticCast<FixedI64<FracDst>> for FixedI128<FracSrc>

Deprecated since 0.5.6:

deprecated in az crate since 0.3.1; use case is unclear

fn static_cast(self) -> Option<FixedI64<FracDst>>

Deprecated since 0.3.1:

use case is unclear

Casts if the conversion works for all source type values, otherwise returns [None].

impl<FracSrc: LeEqU128, FracDst: LeEqU8> StaticCast<FixedI8<FracDst>> for FixedI128<FracSrc>

Deprecated since 0.5.6:

deprecated in az crate since 0.3.1; use case is unclear

fn static_cast(self) -> Option<FixedI8<FracDst>>

Deprecated since 0.3.1:

use case is unclear

Casts if the conversion works for all source type values, otherwise returns [None].

impl<FracSrc: LeEqU128, FracDst: LeEqU128> StaticCast<FixedU128<FracDst>> for FixedI128<FracSrc>

Deprecated since 0.5.6:

deprecated in az crate since 0.3.1; use case is unclear

fn static_cast(self) -> Option<FixedU128<FracDst>>

Deprecated since 0.3.1:

use case is unclear

Casts if the conversion works for all source type values, otherwise returns [None].

impl<FracSrc: LeEqU128, FracDst: LeEqU16> StaticCast<FixedU16<FracDst>> for FixedI128<FracSrc>

Deprecated since 0.5.6:

deprecated in az crate since 0.3.1; use case is unclear

fn static_cast(self) -> Option<FixedU16<FracDst>>

Deprecated since 0.3.1:

use case is unclear

Casts if the conversion works for all source type values, otherwise returns [None].

impl<FracSrc: LeEqU128, FracDst: LeEqU32> StaticCast<FixedU32<FracDst>> for FixedI128<FracSrc>

Deprecated since 0.5.6:

deprecated in az crate since 0.3.1; use case is unclear

fn static_cast(self) -> Option<FixedU32<FracDst>>

Deprecated since 0.3.1:

use case is unclear

Casts if the conversion works for all source type values, otherwise returns [None].

impl<FracSrc: LeEqU128, FracDst: LeEqU64> StaticCast<FixedU64<FracDst>> for FixedI128<FracSrc>

Deprecated since 0.5.6:

deprecated in az crate since 0.3.1; use case is unclear

fn static_cast(self) -> Option<FixedU64<FracDst>>

Deprecated since 0.3.1:

use case is unclear

Casts if the conversion works for all source type values, otherwise returns [None].

impl<FracSrc: LeEqU128, FracDst: LeEqU8> StaticCast<FixedU8<FracDst>> for FixedI128<FracSrc>

Deprecated since 0.5.6:

deprecated in az crate since 0.3.1; use case is unclear

fn static_cast(self) -> Option<FixedU8<FracDst>>

Deprecated since 0.3.1:

use case is unclear

Casts if the conversion works for all source type values, otherwise returns [None].

impl<Frac: LeEqU128> StaticCast<bf16> for FixedI128<Frac>

Deprecated since 0.5.6:

deprecated in az crate since 0.3.1; use case is unclear

fn static_cast(self) -> Option<bf16>

Deprecated since 0.3.1:

use case is unclear

Casts if the conversion works for all source type values, otherwise returns [None].

impl<Frac: LeEqU128> StaticCast<f16> for FixedI128<Frac>

Deprecated since 0.5.6:

deprecated in az crate since 0.3.1; use case is unclear

fn static_cast(self) -> Option<f16>

Deprecated since 0.3.1:

use case is unclear

Casts if the conversion works for all source type values, otherwise returns [None].

impl<Frac: LeEqU128> StaticCast<f32> for FixedI128<Frac>

Deprecated since 0.5.6:

deprecated in az crate since 0.3.1; use case is unclear

fn static_cast(self) -> Option<f32>

Deprecated since 0.3.1:

use case is unclear

Casts if the conversion works for all source type values, otherwise returns [None].

impl<Frac: LeEqU128> StaticCast<f64> for FixedI128<Frac>

Deprecated since 0.5.6:

deprecated in az crate since 0.3.1; use case is unclear

fn static_cast(self) -> Option<f64>

Deprecated since 0.3.1:

use case is unclear

Casts if the conversion works for all source type values, otherwise returns [None].

impl<Frac: LeEqU128> StaticCast<i128> for FixedI128<Frac>

Deprecated since 0.5.6:

deprecated in az crate since 0.3.1; use case is unclear

fn static_cast(self) -> Option<i128>

Deprecated since 0.3.1:

use case is unclear

Casts if the conversion works for all source type values, otherwise returns [None].

impl<Frac: LeEqU128> StaticCast<i16> for FixedI128<Frac>

Deprecated since 0.5.6:

deprecated in az crate since 0.3.1; use case is unclear

fn static_cast(self) -> Option<i16>

Deprecated since 0.3.1:

use case is unclear

Casts if the conversion works for all source type values, otherwise returns [None].

impl<Frac: LeEqU128> StaticCast<i32> for FixedI128<Frac>

Deprecated since 0.5.6:

deprecated in az crate since 0.3.1; use case is unclear

fn static_cast(self) -> Option<i32>

Deprecated since 0.3.1:

use case is unclear

Casts if the conversion works for all source type values, otherwise returns [None].

impl<Frac: LeEqU128> StaticCast<i64> for FixedI128<Frac>

Deprecated since 0.5.6:

deprecated in az crate since 0.3.1; use case is unclear

fn static_cast(self) -> Option<i64>

Deprecated since 0.3.1:

use case is unclear

Casts if the conversion works for all source type values, otherwise returns [None].

impl<Frac: LeEqU128> StaticCast<i8> for FixedI128<Frac>

Deprecated since 0.5.6:

deprecated in az crate since 0.3.1; use case is unclear

fn static_cast(self) -> Option<i8>

Deprecated since 0.3.1:

use case is unclear

Casts if the conversion works for all source type values, otherwise returns [None].

impl<Frac: LeEqU128> StaticCast<isize> for FixedI128<Frac>

Deprecated since 0.5.6:

deprecated in az crate since 0.3.1; use case is unclear

fn static_cast(self) -> Option<isize>

Deprecated since 0.3.1:

use case is unclear

Casts if the conversion works for all source type values, otherwise returns [None].

impl<Frac: LeEqU128> StaticCast<u128> for FixedI128<Frac>

Deprecated since 0.5.6:

deprecated in az crate since 0.3.1; use case is unclear

fn static_cast(self) -> Option<u128>

Deprecated since 0.3.1:

use case is unclear

Casts if the conversion works for all source type values, otherwise returns [None].

impl<Frac: LeEqU128> StaticCast<u16> for FixedI128<Frac>

Deprecated since 0.5.6:

deprecated in az crate since 0.3.1; use case is unclear

fn static_cast(self) -> Option<u16>

Deprecated since 0.3.1:

use case is unclear

Casts if the conversion works for all source type values, otherwise returns [None].

impl<Frac: LeEqU128> StaticCast<u32> for FixedI128<Frac>

Deprecated since 0.5.6:

deprecated in az crate since 0.3.1; use case is unclear

fn static_cast(self) -> Option<u32>

Deprecated since 0.3.1:

use case is unclear

Casts if the conversion works for all source type values, otherwise returns [None].

impl<Frac: LeEqU128> StaticCast<u64> for FixedI128<Frac>

Deprecated since 0.5.6:

deprecated in az crate since 0.3.1; use case is unclear

fn static_cast(self) -> Option<u64>

Deprecated since 0.3.1:

use case is unclear

Casts if the conversion works for all source type values, otherwise returns [None].

impl<Frac: LeEqU128> StaticCast<u8> for FixedI128<Frac>

Deprecated since 0.5.6:

deprecated in az crate since 0.3.1; use case is unclear

fn static_cast(self) -> Option<u8>

Deprecated since 0.3.1:

use case is unclear

Casts if the conversion works for all source type values, otherwise returns [None].

impl<Frac: LeEqU128> StaticCast<usize> for FixedI128<Frac>

Deprecated since 0.5.6:

deprecated in az crate since 0.3.1; use case is unclear

fn static_cast(self) -> Option<usize>

Deprecated since 0.3.1:

use case is unclear

Casts if the conversion works for all source type values, otherwise returns [None].

impl<'a, Frac> Sub<&'a FixedI128<Frac>> for FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the - operator.

fn sub(self, rhs: &FixedI128<Frac>) -> FixedI128<Frac>

Performs the - operation.

impl<'a, 'b, Frac> Sub<&'a FixedI128<Frac>> for &'b FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the - operator.

fn sub(self, rhs: &FixedI128<Frac>) -> FixedI128<Frac>

Performs the - operation.

impl<Frac> Sub<FixedI128<Frac>> for FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the - operator.

fn sub(self, rhs: FixedI128<Frac>) -> FixedI128<Frac>

Performs the - operation.

impl<'a, Frac> Sub<FixedI128<Frac>> for &'a FixedI128<Frac>

type Output = FixedI128<Frac>

The resulting type after applying the - operator.

fn sub(self, rhs: FixedI128<Frac>) -> FixedI128<Frac>

Performs the - operation.

impl<'a, Frac> SubAssign<&'a FixedI128<Frac>> for FixedI128<Frac>

fn sub_assign(&mut self, rhs: &FixedI128<Frac>)

Performs the -= operation.

impl<Frac> SubAssign<FixedI128<Frac>> for FixedI128<Frac>

fn sub_assign(&mut self, rhs: FixedI128<Frac>)

Performs the -= operation.

impl<'a, Frac: 'a> Sum<&'a FixedI128<Frac>> for FixedI128<Frac>

fn sum<I>(iter: I) -> FixedI128<Frac> where
    I: Iterator<Item = &'a FixedI128<Frac>>, 

Method which takes an iterator and generates Self from the elements by "summing up" the items.

impl<Frac> Sum<FixedI128<Frac>> for FixedI128<Frac>

fn sum<I>(iter: I) -> FixedI128<Frac> where
    I: Iterator<Item = FixedI128<Frac>>, 

Method which takes an iterator and generates Self from the elements by "summing up" the items.

impl<Frac: LeEqU128> ToFixed for FixedI128<Frac>

fn to_fixed<F: Fixed>(self) -> F

Converts a fixed-point number.

Any extra fractional bits are discarded, which rounds towards −∞.

fn checked_to_fixed<F: Fixed>(self) -> Option<F>

Converts a fixed-point number if it fits, otherwise returns None.

Any extra fractional bits are discarded, which rounds towards −∞.

fn saturating_to_fixed<F: Fixed>(self) -> F

Converts a fixed-point number, saturating if it does not fit.

Any extra fractional bits are discarded, which rounds towards −∞.

fn wrapping_to_fixed<F: Fixed>(self) -> F

Converts a fixed-point number, wrapping if it does not fit.

Any extra fractional bits are discarded, which rounds towards −∞.

fn overflowing_to_fixed<F: Fixed>(self) -> (F, bool)

Converts a fixed-point number.

Returns a tuple of the value and a bool indicating whether an overflow has occurred. On overflow, the wrapped value is returned.

Any extra fractional bits are discarded, which rounds towards −∞.

impl<Frac: LeEqU128> UpperHex for FixedI128<Frac>

fn fmt(&self, f: &mut Formatter) -> FmtResult

Formats the value using the given formatter.

impl<Frac: LeEqU128> WrappingCast<FixedI128<Frac>> for bool

fn wrapping_cast(self) -> FixedI128<Frac>

Casts the value.

impl<Frac: LeEqU128> WrappingCast<FixedI128<Frac>> for i8

fn wrapping_cast(self) -> FixedI128<Frac>

Casts the value.

impl<Frac: LeEqU128> WrappingCast<FixedI128<Frac>> for u64

fn wrapping_cast(self) -> FixedI128<Frac>

Casts the value.

impl<Frac: LeEqU128> WrappingCast<FixedI128<Frac>> for u128

fn wrapping_cast(self) -> FixedI128<Frac>

Casts the value.

impl<Frac: LeEqU128> WrappingCast<FixedI128<Frac>> for usize

fn wrapping_cast(self) -> FixedI128<Frac>

Casts the value.

impl<Frac: LeEqU128> WrappingCast<FixedI128<Frac>> for f32

fn wrapping_cast(self) -> FixedI128<Frac>

Casts the value.

impl<Frac: LeEqU128> WrappingCast<FixedI128<Frac>> for f64

fn wrapping_cast(self) -> FixedI128<Frac>

Casts the value.

impl<Frac: LeEqU128> WrappingCast<FixedI128<Frac>> for f16

fn wrapping_cast(self) -> FixedI128<Frac>

Casts the value.

impl<Frac: LeEqU128> WrappingCast<FixedI128<Frac>> for bf16

fn wrapping_cast(self) -> FixedI128<Frac>

Casts the value.

impl<Frac: LeEqU128> WrappingCast<FixedI128<Frac>> for i16

fn wrapping_cast(self) -> FixedI128<Frac>

Casts the value.

impl<Frac: LeEqU128> WrappingCast<FixedI128<Frac>> for i32

fn wrapping_cast(self) -> FixedI128<Frac>

Casts the value.

impl<Frac: LeEqU128> WrappingCast<FixedI128<Frac>> for i64

fn wrapping_cast(self) -> FixedI128<Frac>

Casts the value.

impl<Frac: LeEqU128> WrappingCast<FixedI128<Frac>> for i128

fn wrapping_cast(self) -> FixedI128<Frac>

Casts the value.

impl<Frac: LeEqU128> WrappingCast<FixedI128<Frac>> for isize

fn wrapping_cast(self) -> FixedI128<Frac>

Casts the value.

impl<Frac: LeEqU128> WrappingCast<FixedI128<Frac>> for u8

fn wrapping_cast(self) -> FixedI128<Frac>

Casts the value.

impl<Frac: LeEqU128> WrappingCast<FixedI128<Frac>> for u16

fn wrapping_cast(self) -> FixedI128<Frac>

Casts the value.

impl<Frac: LeEqU128> WrappingCast<FixedI128<Frac>> for u32

fn wrapping_cast(self) -> FixedI128<Frac>

Casts the value.

impl<FracSrc: LeEqU8, FracDst: LeEqU128> WrappingCast<FixedI128<FracDst>> for FixedI8<FracSrc>

fn wrapping_cast(self) -> FixedI128<FracDst>

Casts the value.

impl<FracSrc: LeEqU16, FracDst: LeEqU128> WrappingCast<FixedI128<FracDst>> for FixedI16<FracSrc>

fn wrapping_cast(self) -> FixedI128<FracDst>

Casts the value.

impl<FracSrc: LeEqU32, FracDst: LeEqU128> WrappingCast<FixedI128<FracDst>> for FixedI32<FracSrc>

fn wrapping_cast(self) -> FixedI128<FracDst>

Casts the value.

impl<FracSrc: LeEqU64, FracDst: LeEqU128> WrappingCast<FixedI128<FracDst>> for FixedI64<FracSrc>

fn wrapping_cast(self) -> FixedI128<FracDst>

Casts the value.

impl<FracSrc: LeEqU128, FracDst: LeEqU128> WrappingCast<FixedI128<FracDst>> for FixedI128<FracSrc>

fn wrapping_cast(self) -> FixedI128<FracDst>

Casts the value.

impl<FracSrc: LeEqU8, FracDst: LeEqU128> WrappingCast<FixedI128<FracDst>> for FixedU8<FracSrc>

fn wrapping_cast(self) -> FixedI128<FracDst>

Casts the value.

impl<FracSrc: LeEqU16, FracDst: LeEqU128> WrappingCast<FixedI128<FracDst>> for FixedU16<FracSrc>

fn wrapping_cast(self) -> FixedI128<FracDst>

Casts the value.

impl<FracSrc: LeEqU32, FracDst: LeEqU128> WrappingCast<FixedI128<FracDst>> for FixedU32<FracSrc>

fn wrapping_cast(self) -> FixedI128<FracDst>

Casts the value.

impl<FracSrc: LeEqU64, FracDst: LeEqU128> WrappingCast<FixedI128<FracDst>> for FixedU64<FracSrc>

fn wrapping_cast(self) -> FixedI128<FracDst>

Casts the value.

impl<FracSrc: LeEqU128, FracDst: LeEqU128> WrappingCast<FixedI128<FracDst>> for FixedU128<FracSrc>

fn wrapping_cast(self) -> FixedI128<FracDst>

Casts the value.

impl<FracSrc: LeEqU128, FracDst: LeEqU16> WrappingCast<FixedI16<FracDst>> for FixedI128<FracSrc>

fn wrapping_cast(self) -> FixedI16<FracDst>

Casts the value.

impl<FracSrc: LeEqU128, FracDst: LeEqU32> WrappingCast<FixedI32<FracDst>> for FixedI128<FracSrc>

fn wrapping_cast(self) -> FixedI32<FracDst>

Casts the value.

impl<FracSrc: LeEqU128, FracDst: LeEqU64> WrappingCast<FixedI64<FracDst>> for FixedI128<FracSrc>

fn wrapping_cast(self) -> FixedI64<FracDst>

Casts the value.

impl<FracSrc: LeEqU128, FracDst: LeEqU8> WrappingCast<FixedI8<FracDst>> for FixedI128<FracSrc>

fn wrapping_cast(self) -> FixedI8<FracDst>

Casts the value.

impl<FracSrc: LeEqU128, FracDst: LeEqU128> WrappingCast<FixedU128<FracDst>> for FixedI128<FracSrc>

fn wrapping_cast(self) -> FixedU128<FracDst>

Casts the value.

impl<FracSrc: LeEqU128, FracDst: LeEqU16> WrappingCast<FixedU16<FracDst>> for FixedI128<FracSrc>

fn wrapping_cast(self) -> FixedU16<FracDst>

Casts the value.

impl<FracSrc: LeEqU128, FracDst: LeEqU32> WrappingCast<FixedU32<FracDst>> for FixedI128<FracSrc>

fn wrapping_cast(self) -> FixedU32<FracDst>

Casts the value.

impl<FracSrc: LeEqU128, FracDst: LeEqU64> WrappingCast<FixedU64<FracDst>> for FixedI128<FracSrc>

fn wrapping_cast(self) -> FixedU64<FracDst>

Casts the value.

impl<FracSrc: LeEqU128, FracDst: LeEqU8> WrappingCast<FixedU8<FracDst>> for FixedI128<FracSrc>

fn wrapping_cast(self) -> FixedU8<FracDst>

Casts the value.

impl<Frac: LeEqU128> WrappingCast<bf16> for FixedI128<Frac>

fn wrapping_cast(self) -> bf16

Casts the value.

impl<Frac: LeEqU128> WrappingCast<f16> for FixedI128<Frac>

fn wrapping_cast(self) -> f16

Casts the value.

impl<Frac: LeEqU128> WrappingCast<f32> for FixedI128<Frac>

fn wrapping_cast(self) -> f32

Casts the value.

impl<Frac: LeEqU128> WrappingCast<f64> for FixedI128<Frac>

fn wrapping_cast(self) -> f64

Casts the value.

impl<Frac: LeEqU128> WrappingCast<i128> for FixedI128<Frac>

fn wrapping_cast(self) -> i128

Casts the value.

impl<Frac: LeEqU128> WrappingCast<i16> for FixedI128<Frac>

fn wrapping_cast(self) -> i16

Casts the value.

impl<Frac: LeEqU128> WrappingCast<i32> for FixedI128<Frac>

fn wrapping_cast(self) -> i32

Casts the value.

impl<Frac: LeEqU128> WrappingCast<i64> for FixedI128<Frac>

fn wrapping_cast(self) -> i64

Casts the value.

impl<Frac: LeEqU128> WrappingCast<i8> for FixedI128<Frac>

fn wrapping_cast(self) -> i8

Casts the value.

impl<Frac: LeEqU128> WrappingCast<isize> for FixedI128<Frac>

fn wrapping_cast(self) -> isize

Casts the value.

impl<Frac: LeEqU128> WrappingCast<u128> for FixedI128<Frac>

fn wrapping_cast(self) -> u128

Casts the value.

impl<Frac: LeEqU128> WrappingCast<u16> for FixedI128<Frac>

fn wrapping_cast(self) -> u16

Casts the value.

impl<Frac: LeEqU128> WrappingCast<u32> for FixedI128<Frac>

fn wrapping_cast(self) -> u32

Casts the value.

impl<Frac: LeEqU128> WrappingCast<u64> for FixedI128<Frac>

fn wrapping_cast(self) -> u64

Casts the value.

impl<Frac: LeEqU128> WrappingCast<u8> for FixedI128<Frac>

fn wrapping_cast(self) -> u8

Casts the value.

impl<Frac: LeEqU128> WrappingCast<usize> for FixedI128<Frac>

fn wrapping_cast(self) -> usize

Casts the value.