Struct substrate_fixed::FixedU16

impl<Frac> FixedU16<Frac>

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

Returns the smallest value that can be represented.

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

Returns the largest value that can be represented.

pub const fn from_bits(bits: u16) -> FixedU16<Frac>

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

pub const fn to_bits(self) -> u16

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

pub fn from_be_bytes(bytes: [u8; 2]) -> FixedU16<Frac>

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

pub fn from_le_bytes(bytes: [u8; 2]) -> FixedU16<Frac>

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

pub fn from_ne_bytes(bytes: [u8; 2]) -> FixedU16<Frac>

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

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

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

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

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

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

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

pub const fn count_ones(self) -> u32

Returns the number of ones in the binary representation.

pub const fn count_zeros(self) -> u32

Returns the number of zeros in the binary representation.

pub const fn leading_zeros(self) -> u32

Returns the number of leading zeros in the binary representation.

pub const fn trailing_zeros(self) -> u32

Returns the number of trailing zeros in the binary representation.

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

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

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

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

pub const fn is_power_of_two(self) -> bool

Returns true if the fixed-point number is 2^k for some integer k.

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

Remainder for Euclidean division.

pub fn next_power_of_two(self) -> FixedU16<Frac>

Returns the smallest power of two that is ≥ self.

When debug assertions are enabled, panics if the next power of two is too large to represent. When debug assertions are not enabled, zero can be returned, but it is not considered a breaking change if in the future it panics; if this is not desirable use checked_next_power_of_two instead.

Examples

use substrate_fixed::{types::extra::U4, FixedU16};
type Fix = FixedU16<U4>;
// 3/8 is 0.0110
let three_eights = Fix::from_bits(0b0110);
// 1/2 is 0.1000
let half = Fix::from_bits(0b1000);
assert_eq!(three_eights.next_power_of_two(), half);
assert_eq!(half.next_power_of_two(), half);

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

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

Only zero can be negated without overflow.

Examples

use substrate_fixed::{types::extra::U4, FixedU16};
type Fix = FixedU16<U4>;
assert_eq!(Fix::from_num(0).checked_neg(), Some(Fix::from_num(0)));
assert_eq!(Fix::from_num(5).checked_neg(), None);

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

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

Examples

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

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

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

Examples

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

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

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

Examples

use substrate_fixed::{types::extra::U4, FixedU16};
type Fix = FixedU16<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: u16) -> Option<FixedU16<Frac>>

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

Examples

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

pub fn checked_div_int(self, rhs: u16) -> Option<FixedU16<Frac>>

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

Examples

use substrate_fixed::{types::extra::U4, FixedU16};
type Fix = FixedU16<U4>;
assert_eq!(Fix::max_value().checked_div_int(1), Some(Fix::max_value()));
assert_eq!(Fix::from_num(1).checked_div_int(0), None);

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

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

Examples

use substrate_fixed::{types::extra::U4, FixedU16};
type Fix = FixedU16<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);

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

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

Examples

use substrate_fixed::{types::extra::U4, FixedU16};
type Fix = FixedU16<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(16), None);

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

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

Examples

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

pub fn checked_next_power_of_two(self) -> Option<FixedU16<Frac>>

Returns the smallest power of two that is ≥ self, or None if the next power of two is too large to represent.

Examples

use substrate_fixed::{types::extra::U4, FixedU16};
type Fix = FixedU16<U4>;
// 3/8 is 0.0110
let three_eights = Fix::from_bits(0b0110);
// 1/2 is 0.1000
let half = Fix::from_bits(0b1000);
assert_eq!(three_eights.checked_next_power_of_two(), Some(half));
assert!(Fix::max_value().checked_next_power_of_two().is_none());

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

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

This method always returns zero.

Examples

use substrate_fixed::{types::extra::U4, FixedU16};
type Fix = FixedU16<U4>;
assert_eq!(Fix::from_num(0).saturating_neg(), Fix::from_num(0));
assert_eq!(Fix::from_num(5).saturating_neg(), Fix::from_num(0));

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

Saturating addition. Returns the sum, saturating on overflow.

Examples

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

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

Saturating subtraction. Returns the difference, saturating on overflow.

Examples

use substrate_fixed::{types::extra::U4, FixedU16};
type Fix = FixedU16<U4>;
assert_eq!(Fix::from_num(5).saturating_sub(Fix::from_num(3)), Fix::from_num(2));
assert_eq!(Fix::from_num(0).saturating_sub(Fix::from_num(1)), Fix::from_num(0));

pub const fn saturating_mul_int(self, rhs: u16) -> FixedU16<Frac>

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

Examples

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

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

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

Only zero can be negated without overflow.

Examples

use substrate_fixed::{types::extra::U4, FixedU16};
type Fix = FixedU16<U4>;
assert_eq!(Fix::from_num(0).wrapping_neg(), Fix::from_num(0));
assert_eq!(Fix::from_num(5).wrapping_neg(), Fix::wrapping_from_num(-5));
let neg_five_bits = !Fix::from_num(5).to_bits() + 1;
assert_eq!(Fix::from_num(5).wrapping_neg(), Fix::from_bits(neg_five_bits));

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

Wrapping addition. Returns the sum, wrapping on overflow.

Examples

use substrate_fixed::{types::extra::U4, FixedU16};
type Fix = FixedU16<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_value().wrapping_add(one), one_minus_bit);

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

Wrapping subtraction. Returns the difference, wrapping on overflow.

Examples

use substrate_fixed::{types::extra::U4, FixedU16};
type Fix = FixedU16<U4>;
let one = Fix::from_num(1);
let one_minus_bit = one - Fix::from_bits(1);
assert_eq!(Fix::from_num(5).wrapping_sub(Fix::from_num(3)), Fix::from_num(2));
assert_eq!(Fix::from_num(0).wrapping_sub(one), Fix::max_value() - one_minus_bit);

pub const fn wrapping_mul_int(self, rhs: u16) -> FixedU16<Frac>

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

Examples

use substrate_fixed::{types::extra::U4, FixedU16};
type Fix = FixedU16<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_value().wrapping_mul_int(4), wrapped);

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.

Only zero can be negated without overflow.

Examples

use substrate_fixed::{types::extra::U4, FixedU16};
type Fix = FixedU16<U4>;
assert_eq!(Fix::from_num(0).overflowing_neg(), (Fix::from_num(0), false));
assert_eq!(Fix::from_num(5).overflowing_neg(), Fix::overflowing_from_num(-5));
let neg_five_bits = !Fix::from_num(5).to_bits() + 1;
assert_eq!(Fix::from_num(5).overflowing_neg(), (Fix::from_bits(neg_five_bits), true));

pub const fn overflowing_add( self, rhs: FixedU16<Frac> ) -> (FixedU16<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 substrate_fixed::{types::extra::U4, FixedU16};
type Fix = FixedU16<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_value().overflowing_add(one), (one_minus_bit, true));

pub const fn overflowing_sub( self, rhs: FixedU16<Frac> ) -> (FixedU16<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 substrate_fixed::{types::extra::U4, FixedU16};
type Fix = FixedU16<U4>;
let one = Fix::from_num(1);
let one_minus_bit = one - Fix::from_bits(1);
assert_eq!(Fix::from_num(5).overflowing_sub(Fix::from_num(3)), (Fix::from_num(2), false));
assert_eq!(Fix::from_num(0).overflowing_sub(one), (Fix::max_value() - one_minus_bit, true));

pub const fn overflowing_mul_int(self, rhs: u16) -> (FixedU16<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 substrate_fixed::{types::extra::U4, FixedU16};
type Fix = FixedU16<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_value().overflowing_mul_int(4), (wrapped, true));

pub fn overflowing_div_int(self, rhs: u16) -> (FixedU16<Frac>, bool)

Overflowing division by an integer.

Returns a tuple of the quotient and false, as the division can never overflow for unsigned values.

Panics

Panics if the divisor is zero.

Examples

use substrate_fixed::{types::extra::U4, FixedU16};
type Fix = FixedU16<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));

pub const fn overflowing_shl(self, rhs: u32) -> (FixedU16<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 ≥ 16. On overflow rhs is wrapped before the shift operation.

Examples

use substrate_fixed::{types::extra::U4, FixedU16};
type Fix = FixedU16<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 + 16), (Fix::from_num(4), true));

pub const fn overflowing_shr(self, rhs: u32) -> (FixedU16<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 ≥ 16. On overflow rhs is wrapped before the shift operation.

Examples

use substrate_fixed::{types::extra::U4, FixedU16};
type Fix = FixedU16<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 + 16), (Fix::from_num(1) / 2, true));

use substrate_fixed::{types::extra::U6, FixedU16};
type Fix = FixedU16<U6>;
assert_eq!(Fix::frac_nbits(), 6);

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

Creates a fixed-point number from another number.

The other number can be:

Another fixed-point number. Any extra fractional bits are truncated.
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 substrate_fixed::{types::extra::U4, types::I16F16, FixedU16};
type Fix = FixedU16<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 truncated.
An integer of type i8, i16, i32, i64, i128, isize, u8, u16, u32, u64, u128, or usize. Any fractional bits are truncated.
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 substrate_fixed::{types::extra::U4, types::I30F2, FixedU16};
type Fix = FixedU16<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>(), 2);

// 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<FixedU16<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 truncated.
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 substrate_fixed::{
    types::extra::{U2, U4},
    types::I16F16,
    FixedU16,
};
type Fix = FixedU16<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 = FixedU16::<U2>::max_value();
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 = u16::max_value();
assert!(Fix::checked_from_num(too_large).is_none());
let too_small = -1;
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 truncated.
An integer of type i8, i16, i32, i64, i128, isize, u8, u16, u32, u64, u128, or usize. Any fractional bits are truncated.
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 substrate_fixed::{
    types::extra::{U0, U4, U6},
    types::I16F16,
    FixedU16,
};
type Fix = FixedU16<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 = FixedU16<U6>;
assert!(Fix::max_value().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(2));
type AllInt = FixedU16<U0>;
assert!(AllInt::max_value().checked_to_num::<i16>().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) -> FixedU16<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 truncated.
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 substrate_fixed::{
    types::extra::{U2, U4},
    types::I16F16,
    FixedU16,
};
type Fix = FixedU16<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 = FixedU16::<U2>::max_value();
assert_eq!(Fix::saturating_from_num(too_large), Fix::max_value());

assert_eq!(Fix::saturating_from_num(3), Fix::from_bits(3 << 4));
let too_small = -1;
assert_eq!(Fix::saturating_from_num(too_small), Fix::min_value());

// 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_value());
assert_eq!(Fix::saturating_from_num(std::f64::NEG_INFINITY), Fix::min_value());

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 truncated.
An integer of type i8, i16, i32, i64, i128, isize, u8, u16, u32, u64, u128, or usize. Any fractional bits are truncated.
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 substrate_fixed::{
    types::extra::{U0, U4, U6},
    types::I16F16,
    FixedU16,
};
type Fix = FixedU16<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 = FixedU16<U6>;
let saturated = Fix::max_value().saturating_to_num::<TooFewIntBits>();
assert_eq!(saturated, TooFewIntBits::max_value());

// 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 = FixedU16<U0>;
assert_eq!(AllInt::max_value().saturating_to_num::<i16>(), i16::max_value());

// 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) -> FixedU16<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 truncated.
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 substrate_fixed::{
    types::extra::{U0, U4},
    types::I16F16,
    FixedU16,
};
type Fix = FixedU16<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 << (16 - 7) will wrap to fixed-point 1010...
let too_large = FixedU16::<U0>::from_bits(0b1101 << (16 - 7));
let wrapped = Fix::from_bits(0b1010 << (16 - 4));
assert_eq!(Fix::wrapping_from_num(too_large), wrapped);

// integer 0b1101 << (16 - 7) will wrap to fixed-point 1010...
let large: u16 = 0b1101 << (16 - 7);
let wrapped = Fix::from_bits(0b1010 << (16 - 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 << (16 - 4) wraps to binary 11000...
let large = 1.75 * 2f32.powi(16 - 4);
let wrapped = Fix::from_bits(0b1100 << (16 - 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 truncated.
An integer of type i8, i16, i32, i64, i128, isize, u8, u16, u32, u64, u128, or usize. Any fractional bits are truncated.
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 substrate_fixed::{
    types::extra::{U0, U4, U6},
    types::I16F16,
    FixedU16,
};
type Fix = FixedU16<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 = FixedU16<U6>;
let wrapped = TooFewIntBits::from_bits(Fix::max_value().to_bits() << 2);
assert_eq!(Fix::max_value().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 = FixedU16<U0>;
assert_eq!(AllInt::max_value().wrapping_to_num::<i16>(), -1);

// 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) -> (FixedU16<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 truncated.
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 substrate_fixed::{
    types::extra::{U0, U4},
    types::I16F16,
    FixedU16,
};
type Fix = FixedU16<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 << (16 - 7) will wrap to fixed-point 1010...
let too_large = FixedU16::<U0>::from_bits(0b1101 << (16 - 7));
let wrapped = Fix::from_bits(0b1010 << (16 - 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 << (16 - 7) will wrap to fixed-point 1010...
let large: u16 = 0b1101 << (16 - 7);
let wrapped = Fix::from_bits(0b1010 << (16 - 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 << (16 - 4) wraps to binary 11000...
let large = 1.75 * 2f32.powi(16 - 4);
let wrapped = Fix::from_bits(0b1100 << (16 - 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 truncated.
An integer of type i8, i16, i32, i64, i128, isize, u8, u16, u32, u64, u128, or usize. Any fractional bits are truncated.
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 substrate_fixed::{
    types::extra::{U0, U4, U6},
    types::I16F16,
    FixedU16,
};
type Fix = FixedU16<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 = FixedU16<U6>;
let wrapped = TooFewIntBits::from_bits(Fix::max_value().to_bits() << 2);
assert_eq!(Fix::max_value().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 = FixedU16::<U0>::max_value();
let wrapped = -1i16;
assert_eq!(does_not_fit.overflowing_to_num::<i16>(), (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<FixedU16<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 substrate_fixed::{types::extra::U4, FixedU16};
type Fix = FixedU16<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));

pub fn from_str_octal(src: &str) -> Result<FixedU16<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 substrate_fixed::{types::extra::U4, FixedU16};
type Fix = FixedU16<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));

pub fn from_str_hex(src: &str) -> Result<FixedU16<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 substrate_fixed::{types::extra::U4, FixedU16};
type Fix = FixedU16<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));

pub fn saturating_from_str(src: &str) -> Result<FixedU16<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 substrate_fixed::types::U8F8;
assert_eq!(U8F8::saturating_from_str("9999"), Ok(U8F8::max_value()));
assert_eq!(U8F8::saturating_from_str("-1"), Ok(U8F8::from_num(0)));

pub fn saturating_from_str_binary( src: &str ) -> Result<FixedU16<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 substrate_fixed::types::U8F8;
assert_eq!(U8F8::saturating_from_str_binary("101100111000"), Ok(U8F8::max_value()));
assert_eq!(U8F8::saturating_from_str_binary("-1"), Ok(U8F8::from_num(0)));

pub fn saturating_from_str_octal( src: &str ) -> Result<FixedU16<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 substrate_fixed::types::U8F8;
assert_eq!(U8F8::saturating_from_str_octal("7777"), Ok(U8F8::max_value()));
assert_eq!(U8F8::saturating_from_str_octal("-1"), Ok(U8F8::from_num(0)));

pub fn saturating_from_str_hex( src: &str ) -> Result<FixedU16<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 substrate_fixed::types::U8F8;
assert_eq!(U8F8::saturating_from_str_hex("FFFF"), Ok(U8F8::max_value()));
assert_eq!(U8F8::saturating_from_str_hex("-1"), Ok(U8F8::from_num(0)));

pub fn wrapping_from_str(src: &str) -> Result<FixedU16<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 substrate_fixed::types::U8F8;
// 9999.5 = 15.5 + 256 × n
assert_eq!(U8F8::wrapping_from_str("9999.5"), Ok(U8F8::from_num(15.5)));
assert_eq!(U8F8::wrapping_from_str("-9999.5"), Ok(U8F8::from_num(240.5)));

pub fn wrapping_from_str_binary( src: &str ) -> Result<FixedU16<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 substrate_fixed::types::U8F8;
let check = U8F8::from_bits(0b1110001 << (8 - 1));
assert_eq!(U8F8::wrapping_from_str_binary("101100111000.1"), Ok(check));
assert_eq!(U8F8::wrapping_from_str_binary("-101100111000.1"), Ok(check.wrapping_neg()));

pub fn wrapping_from_str_octal( src: &str ) -> Result<FixedU16<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 substrate_fixed::types::U8F8;
let check = U8F8::from_bits(0o1654 << (8 - 3));
assert_eq!(U8F8::wrapping_from_str_octal("7165.4"), Ok(check));
assert_eq!(U8F8::wrapping_from_str_octal("-7165.4"), Ok(check.wrapping_neg()));

pub fn wrapping_from_str_hex( src: &str ) -> Result<FixedU16<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 substrate_fixed::types::U8F8;
let check = U8F8::from_bits(0xFFE);
assert_eq!(U8F8::wrapping_from_str_hex("C0F.FE"), Ok(check));
assert_eq!(U8F8::wrapping_from_str_hex("-C0F.FE"), Ok(check.wrapping_neg()));

pub fn overflowing_from_str( src: &str ) -> Result<(FixedU16<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 substrate_fixed::types::U8F8;
assert_eq!(U8F8::overflowing_from_str("99.5"), Ok((U8F8::from_num(99.5), false)));
// 9999.5 = 15.5 + 256 × n
assert_eq!(U8F8::overflowing_from_str("9999.5"), Ok((U8F8::from_num(15.5), true)));

pub fn overflowing_from_str_binary( src: &str ) -> Result<(FixedU16<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 substrate_fixed::types::U8F8;
let check = U8F8::from_bits(0b1110001 << (8 - 1));
assert_eq!(U8F8::overflowing_from_str_binary("111000.1"), Ok((check, false)));
assert_eq!(U8F8::overflowing_from_str_binary("101100111000.1"), Ok((check, true)));

pub fn overflowing_from_str_octal( src: &str ) -> Result<(FixedU16<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 substrate_fixed::types::U8F8;
let check = U8F8::from_bits(0o1654 << (8 - 3));
assert_eq!(U8F8::overflowing_from_str_octal("165.4"), Ok((check, false)));
assert_eq!(U8F8::overflowing_from_str_octal("7165.4"), Ok((check, true)));

pub fn overflowing_from_str_hex( src: &str ) -> Result<(FixedU16<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 substrate_fixed::types::U8F8;
let check = U8F8::from_bits(0xFFE);
assert_eq!(U8F8::overflowing_from_str_hex("F.FE"), Ok((check, false)));
assert_eq!(U8F8::overflowing_from_str_hex("C0F.FE"), Ok((check, true)));

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

Returns the integer part.

Note that for unsigned numbers, this is equivalent to floor.

Examples

use substrate_fixed::{types::extra::U4, FixedU16};
type Fix = FixedU16<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);

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

Returns the fractional part.

Examples

use substrate_fixed::{types::extra::U4, FixedU16};
type Fix = FixedU16<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);

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

Rounds to the next integer towards 0.

Note that for unsigned numbers, this is equivalent to floor.

Examples

use substrate_fixed::{types::extra::U4, FixedU16};
type Fix = FixedU16<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));

pub fn ceil(self) -> FixedU16<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 substrate_fixed::{types::extra::U4, FixedU16};
type Fix = FixedU16<U4>;
assert_eq!(Fix::from_num(2.5).ceil(), Fix::from_num(3));

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

Rounds to the next integer towards −∞.

Examples

use substrate_fixed::{types::extra::U4, FixedU16};
type Fix = FixedU16<U4>;
assert_eq!(Fix::from_num(2.5).floor(), Fix::from_num(2));

pub fn round(self) -> FixedU16<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 substrate_fixed::{types::extra::U4, FixedU16};
type Fix = FixedU16<U4>;
assert_eq!(Fix::from_num(2.5).round(), Fix::from_num(3));

use substrate_fixed::{types::extra::U4, FixedU16};
type Fix = FixedU16<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_value().wrapping_round_ties_to_even(), Fix::min_value());

pub fn overflowing_ceil(self) -> (FixedU16<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 substrate_fixed::{types::extra::U4, FixedU16};
type Fix = FixedU16<U4>;
assert_eq!(Fix::from_num(2.5).overflowing_ceil(), (Fix::from_num(3), false));
assert_eq!(Fix::max_value().overflowing_ceil(), (Fix::min_value(), true));

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

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

Returns a tuple of the fixed-point number and false.

Examples

use substrate_fixed::{types::extra::U4, FixedU16};
type Fix = FixedU16<U4>;
assert_eq!(Fix::from_num(2.5).overflowing_floor(), (Fix::from_num(2), false));

pub fn overflowing_round(self) -> (FixedU16<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 substrate_fixed::{types::extra::U4, FixedU16};
type Fix = FixedU16<U4>;
assert_eq!(Fix::from_num(2.5).overflowing_round(), (Fix::from_num(3), false));
assert_eq!(Fix::max_value().overflowing_round(), (Fix::min_value(), true));

pub fn overflowing_round_ties_to_even(self) -> (FixedU16<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 substrate_fixed::{types::extra::U4, FixedU16};
type Fix = FixedU16<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_value().overflowing_round_ties_to_even(), (Fix::min_value(), true));

pub fn div_euclid(self, rhs: FixedU16<Frac>) -> FixedU16<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 substrate_fixed::{types::extra::U4, FixedU16};
type Fix = FixedU16<U4>;
assert_eq!(Fix::from_num(7.5).div_euclid(Fix::from_num(2)), Fix::from_num(3));

pub fn div_euclid_int(self, rhs: u16) -> FixedU16<Frac>

Euclidean division by an integer.

Panics

Panics if the divisor is zero.

Examples

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

pub fn rem_euclid_int(self, rhs: u16) -> FixedU16<Frac>

Remainder for Euclidean division by an integer.

Panics

Panics if the divisor is zero.

Examples

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

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

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

Examples

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

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

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

Examples

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

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

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

Examples

use substrate_fixed::{types::extra::U4, FixedU16};
type Fix = FixedU16<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_value().checked_div_euclid(Fix::from_num(0.25)), None);

pub fn checked_rem_int(self, rhs: u16) -> Option<FixedU16<Frac>>

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

Examples

use substrate_fixed::{types::extra::U4, FixedU16};
type Fix = FixedU16<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);

pub fn checked_div_euclid_int(self, rhs: u16) -> Option<FixedU16<Frac>>

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

Examples

use substrate_fixed::{types::extra::U4, FixedU16};
type Fix = FixedU16<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);

pub fn checked_rem_euclid_int(self, rhs: u16) -> Option<FixedU16<Frac>>

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

Examples

use substrate_fixed::{types::extra::U12, FixedU16};
type Fix = FixedU16<U12>;
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);

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

Saturating multiplication. Returns the product, saturating on overflow.

Examples

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

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

Saturating division. Returns the quotient, saturating on overflow.

Panics

Panics if the divisor is zero.

Examples

use substrate_fixed::{types::extra::U4, FixedU16};
type Fix = FixedU16<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_value().saturating_div(one_half), Fix::max_value());

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

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

Panics

Panics if the divisor is zero.

Examples

use substrate_fixed::{types::extra::U4, FixedU16};
type Fix = FixedU16<U4>;
assert_eq!(Fix::from_num(7.5).saturating_div_euclid(Fix::from_num(2)), Fix::from_num(3));
assert_eq!(Fix::max_value().saturating_div_euclid(Fix::from_num(0.25)), Fix::max_value());

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

Wrapping multiplication. Returns the product, wrapping on overflow.

Examples

use substrate_fixed::{types::extra::U4, FixedU16};
type Fix = FixedU16<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_value().wrapping_mul(Fix::from_num(4)), wrapped);

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

Wrapping division. Returns the quotient, wrapping on overflow.

Panics

Panics if the divisor is zero.

Examples

use substrate_fixed::{types::extra::U4, FixedU16};
type Fix = FixedU16<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_value().wrapping_div(quarter), wrapped);

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

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

Panics

Panics if the divisor is zero.

Examples

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

pub fn wrapping_div_euclid_int(self, rhs: u16) -> FixedU16<Frac>

Wrapping Euclidean division by an integer. Returns the quotient.

Can never overflow for unsigned values.

Panics

Panics if the divisor is zero.

Examples

use substrate_fixed::{types::extra::U4, FixedU16};
type Fix = FixedU16<U4>;
assert_eq!(Fix::from_num(7.5).wrapping_div_euclid_int(2), Fix::from_num(3));

pub fn wrapping_rem_euclid_int(self, rhs: u16) -> FixedU16<Frac>

Wrapping remainder for Euclidean division by an integer. Returns the remainder.

Can never overflow for unsigned values.

Panics

Panics if the divisor is zero.

Examples

use substrate_fixed::{types::extra::U12, FixedU16};
type Fix = FixedU16<U12>;
assert_eq!(Fix::from_num(7.5).wrapping_rem_euclid_int(2), Fix::from_num(1.5));

pub fn overflowing_mul(self, rhs: FixedU16<Frac>) -> (FixedU16<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 substrate_fixed::{types::extra::U4, FixedU16};
type Fix = FixedU16<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_value().overflowing_mul(Fix::from_num(4)), (wrapped, true));

pub fn overflowing_div(self, rhs: FixedU16<Frac>) -> (FixedU16<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 substrate_fixed::{types::extra::U4, FixedU16};
type Fix = FixedU16<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_value().overflowing_div(quarter), (wrapped, true));

pub fn overflowing_div_euclid( self, rhs: FixedU16<Frac> ) -> (FixedU16<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 substrate_fixed::{types::extra::U4, FixedU16};
type Fix = FixedU16<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_value().wrapping_mul_int(4).round_to_zero();
assert_eq!(Fix::max_value().overflowing_div_euclid(Fix::from_num(0.25)), (wrapped, true));

pub fn overflowing_div_euclid_int(self, rhs: u16) -> (FixedU16<Frac>, bool)

Overflowing Euclidean division by an integer.

Returns a tuple of the quotient and false, as the division can never overflow for unsigned values.

Panics

Panics if the divisor is zero.

Examples

use substrate_fixed::{types::extra::U4, FixedU16};
type Fix = FixedU16<U4>;
assert_eq!(Fix::from_num(7.5).overflowing_div_euclid_int(2), (Fix::from_num(3), false));

pub fn overflowing_rem_euclid_int(self, rhs: u16) -> (FixedU16<Frac>, bool)

Remainder for Euclidean division by an integer.

Returns a tuple of the remainder and false, as this can never overflow for unsigned values.

Panics

Panics if the divisor is zero.

Examples

use substrate_fixed::{types::extra::U12, FixedU16};
type Fix = FixedU16<U12>;
assert_eq!(Fix::from_num(7.5).overflowing_rem_euclid_int(2), (Fix::from_num(1.5), false));

pub fn wrapping_rem_int(self, rhs: u16) -> FixedU16<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: u16) -> (FixedU16<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.

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

Performs the += operation. Read more

Performs the &= operation. Read more

Performs the |= operation. Read more

fn skip(input: &mut I) -> Result<(), Error>where I: Input,

Attempt to skip the encoded value from input. Read more

fn encode(&self) -> Vec<u8>

Convert self to an owned vector.

fn using_encoded<R, F>(&self, f: F) -> Rwhere F: FnOnce(&[u8]) -> R,

Convert self to a slice and then invoke the given closure with it.

fn encoded_size(&self) -> usize

Calculates the encoded size. Read more

fn is_power_of_two(self) -> bool

Returns true if the fixed-point number is 2^k for some integer k.

fn next_power_of_two(self) -> Self

Returns the smallest power of two that is ≥ self.

fn checked_next_power_of_two(self) -> Option<Self>

Returns the smallest power of two that is ≥ self, or None if the next power of two is too large to represent.

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

impl<Frac: LeEqU16> FromStr for FixedU16<Frac>

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.

type Err = ParseFixedError

The associated error which can be returned from parsing.

impl<Frac> Hash for FixedU16<Frac>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher. Read more

1.3.0 · source§

fn hash_slice<H>(data: &[Self], state: &mut H)where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher. Read more

impl<Frac> Not for FixedU16<Frac>

type Output = FixedU16<Frac>

The resulting type after applying the ! operator.

Compares and returns the maximum of two values. Read more

1.21.0 · source§

fn min(self, other: Self) -> Selfwhere Self: Sized,

This method returns an ordering between self and other values if one exists. Read more

fn lt(&self, rhs: &FixedI128<FracRhs>) -> bool

This method tests less than (for self and other) and is used by the < operator. Read more

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. Read more

fn gt(&self, rhs: &FixedI128<FracRhs>) -> bool

This method tests greater than (for self and other) and is used by the > operator. Read more

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. Read more

This method returns an ordering between self and other values if one exists. Read more

fn lt(&self, rhs: &FixedI8<FracRhs>) -> bool

This method tests less than (for self and other) and is used by the < operator. Read more

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. Read more

fn gt(&self, rhs: &FixedI8<FracRhs>) -> bool

This method tests greater than (for self and other) and is used by the > operator. Read more

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. Read more

This method returns an ordering between self and other values if one exists. Read more

fn lt(&self, rhs: &FixedU16<Frac>) -> bool

This method tests less than (for self and other) and is used by the < operator. Read more

fn le(&self, rhs: &FixedU16<Frac>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more

fn gt(&self, rhs: &FixedU16<Frac>) -> bool

This method tests greater than (for self and other) and is used by the > operator. Read more

fn ge(&self, rhs: &FixedU16<Frac>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more

This method returns an ordering between self and other values if one exists. Read more

fn lt(&self, rhs: &FixedU16<Frac>) -> bool

This method tests less than (for self and other) and is used by the < operator. Read more

fn le(&self, rhs: &FixedU16<Frac>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more

fn gt(&self, rhs: &FixedU16<Frac>) -> bool

This method tests greater than (for self and other) and is used by the > operator. Read more

fn ge(&self, rhs: &FixedU16<Frac>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more

This method returns an ordering between self and other values if one exists. Read more

fn lt(&self, rhs: &FixedU16<Frac>) -> bool

This method tests less than (for self and other) and is used by the < operator. Read more

fn le(&self, rhs: &FixedU16<Frac>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more

fn gt(&self, rhs: &FixedU16<Frac>) -> bool

This method tests greater than (for self and other) and is used by the > operator. Read more

fn ge(&self, rhs: &FixedU16<Frac>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more

This method returns an ordering between self and other values if one exists. Read more

fn lt(&self, rhs: &FixedU16<Frac>) -> bool

This method tests less than (for self and other) and is used by the < operator. Read more

fn le(&self, rhs: &FixedU16<Frac>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more

fn gt(&self, rhs: &FixedU16<Frac>) -> bool

This method tests greater than (for self and other) and is used by the > operator. Read more

fn ge(&self, rhs: &FixedU16<Frac>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more

This method returns an ordering between self and other values if one exists. Read more

fn lt(&self, rhs: &FixedU16<FracRhs>) -> bool

This method tests less than (for self and other) and is used by the < operator. Read more

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. Read more

fn gt(&self, rhs: &FixedU16<FracRhs>) -> bool

This method tests greater than (for self and other) and is used by the > operator. Read more

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. Read more

This method returns an ordering between self and other values if one exists. Read more

fn lt(&self, rhs: &FixedU16<FracRhs>) -> bool

This method tests less than (for self and other) and is used by the < operator. Read more

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. Read more

fn gt(&self, rhs: &FixedU16<FracRhs>) -> bool

This method tests greater than (for self and other) and is used by the > operator. Read more

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. Read more

This method returns an ordering between self and other values if one exists. Read more

fn lt(&self, rhs: &FixedU32<FracRhs>) -> bool

This method tests less than (for self and other) and is used by the < operator. Read more

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. Read more

fn gt(&self, rhs: &FixedU32<FracRhs>) -> bool

This method tests greater than (for self and other) and is used by the > operator. Read more

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. Read more

This method returns an ordering between self and other values if one exists. Read more

fn lt(&self, rhs: &f16) -> bool

This method tests less than (for self and other) and is used by the < operator. Read more

fn le(&self, rhs: &f16) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more

fn gt(&self, rhs: &f16) -> bool

This method tests greater than (for self and other) and is used by the > operator. Read more

fn ge(&self, rhs: &f16) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more

This method returns an ordering between self and other values if one exists. Read more

fn lt(&self, rhs: &i16) -> bool

This method tests less than (for self and other) and is used by the < operator. Read more

fn le(&self, rhs: &i16) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more

fn gt(&self, rhs: &i16) -> bool

This method tests greater than (for self and other) and is used by the > operator. Read more

fn ge(&self, rhs: &i16) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more

This method returns an ordering between self and other values if one exists. Read more

fn lt(&self, rhs: &isize) -> bool

This method tests less than (for self and other) and is used by the < operator. Read more

fn le(&self, rhs: &isize) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more

fn gt(&self, rhs: &isize) -> bool

This method tests greater than (for self and other) and is used by the > operator. Read more

fn ge(&self, rhs: &isize) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more

This method returns an ordering between self and other values if one exists. Read more

fn lt(&self, rhs: &u64) -> bool

This method tests less than (for self and other) and is used by the < operator. Read more

fn le(&self, rhs: &u64) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more

fn gt(&self, rhs: &u64) -> bool

This method tests greater than (for self and other) and is used by the > operator. Read more

fn ge(&self, rhs: &u64) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more

fn product(iter: I) -> FixedU16<Frac>where I: Iterator<Item = &'a FixedU16<Frac>>,

Method which takes an iterator and generates Self from the elements by multiplying the items.

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

impl<Frac> TypeInfo for FixedU16<Frac>where PhantomData<Frac>: TypeInfo + 'static, Frac: TypeInfo + 'static,

type Identity = FixedU16<Frac>

impl<Frac: LeEqU16> FixedOptionalFeatures for FixedU16<Frac>

fn decode_with_depth_limit(limit: u32, input: &mut I) -> Result<T, Error>where I: Input,

Decode Self with the given maximum recursion depth and advance input by the number of bytes consumed. Read more

impl<T> From<T> for T

fn from(t: T) -> T

Returns the argument unchanged.

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

Performs the conversion.

impl<T, U> TryInto for Twhere U: TryFrom<T>,

type Error = >::Error

The type returned in the event of a conversion error.

fn try_into(self) -> Result<U, >::Error>

Performs the conversion.

impl<T> WrappingAs for T

fn wrapping_as<Dst>(self) -> Dstwhere T: WrappingCast<Dst>,

Casts the value.