[−][src]Struct fixed::FixedU32
A 32-bit fixed-point unsigned integer with Frac
fractional bits.
Currently Frac
is an Unsigned
as provided by the
typenum crate; it is planned to move to const generics when they
are implemented by the Rust compiler.
Examples
use fixed::frac::U3; use fixed::FixedU32; let eleven = FixedU32::<U3>::from_int(11); assert_eq!(eleven, FixedU32::<U3>::from_bits(11 << 3)); assert_eq!(eleven, 11); assert_eq!(eleven.to_string(), "11.0"); let two_point_75 = eleven / 4; assert_eq!(two_point_75, FixedU32::<U3>::from_bits(11 << 1)); assert_eq!(two_point_75, 2.75); assert_eq!(two_point_75.to_string(), "2.8");
Methods
impl<Frac> FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
pub fn min_value() -> FixedU32<Frac>
[src]
Returns the smallest value that can be represented.
Examples
type Fix = fixed::FixedU32<fixed::frac::U4>; assert_eq!(Fix::min_value(), Fix::from_bits(u32::min_value()));
pub fn max_value() -> FixedU32<Frac>
[src]
Returns the largest value that can be represented.
Examples
type Fix = fixed::FixedU32<fixed::frac::U4>; assert_eq!(Fix::max_value(), Fix::from_bits(u32::max_value()));
pub fn int_nbits() -> u32
[src]
Returns the number of integer bits.
Examples
type Fix = fixed::FixedU32<fixed::frac::U6>; assert_eq!(Fix::int_nbits(), 32 - 6);
pub fn frac_nbits() -> u32
[src]
Returns the number of fractional bits.
Examples
type Fix = fixed::FixedU32<fixed::frac::U6>; assert_eq!(Fix::frac_nbits(), 6);
pub fn from_bits(bits: u32) -> FixedU32<Frac>
[src]
Creates a fixed-point number that has a bitwise representation identical to the given integer.
Examples
type Fix = fixed::FixedU32<fixed::frac::U4>; // 0010.0000 == 2 assert_eq!(Fix::from_bits(0b10_0000), 2);
pub fn to_bits(self) -> u32
[src]
Creates an integer that has a bitwise representation identical to the given fixed-point number.
Examples
type Fix = fixed::FixedU32<fixed::frac::U4>; // 2 is 0010.0000 assert_eq!(Fix::from_int(2).to_bits(), 0b10_0000);
pub fn from_fixed<F: Fixed>(val: F) -> FixedU32<Frac>
[src]
Creates a fixed-point number from another fixed-point number which can have a different type.
Any extra fractional bits are truncated.
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_from_fixed
instead.
Examples
type Src = fixed::FixedI32<fixed::frac::U16>; type Dst = fixed::FixedU32<fixed::frac::U4>; // 1.75 is 1.11 in binary let src = Src::from_bits(0b111 << (16 - 2)); assert_eq!(Dst::from_fixed(src), Dst::from_bits(0b111 << (4 - 2))); // src >> 4 is 0.000111, which for Dst is truncated to 0.0001 assert_eq!(Dst::from_fixed(src >> 4), Dst::from_bits(1));
pub fn to_fixed<F: Fixed>(self) -> F
[src]
Converts a fixed-point number to another fixed-point number which can have a different type.
Any extra fractional bits are truncated.
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_fixed
instead.
Examples
type Src = fixed::FixedU32<fixed::frac::U6>; type Dst = fixed::FixedI32<fixed::frac::U4>; // 1.75 is 1.11 in binary let src = Src::from_bits(0b111 << (6 - 2)); assert_eq!(src.to_fixed::<Dst>(), Dst::from_bits(0b111 << (4 - 2))); // src >> 4 is 0.000111, which for Dst is truncated to 0.0001 assert_eq!((src >> 4u32).to_fixed::<Dst>(), Dst::from_bits(1));
pub fn from_int<I: Int>(val: I) -> FixedU32<Frac>
[src]
Creates a fixed-point number from an integer.
The integer can be of type i8
, i16
, i32
, i64
,
i128
, isize
, u8
, u16
, u32
, u64
, u128
, and
usize
.
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_from_int
instead.
Examples
type Fix = fixed::FixedU32<fixed::frac::U4>; assert_eq!(Fix::from_int(3i32), Fix::from_bits(3 << 4)); assert_eq!(Fix::from_int(3i64), Fix::from_bits(3 << 4));
pub fn to_int<I: Int>(self) -> I
[src]
Converts a fixed-point number to an integer.
The integer can be of type i8
, i16
, i32
, i64
,
i128
, isize
, u8
, u16
, u32
, u64
, u128
, and
usize
.
Any fractional bits are truncated.
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_int
instead.
Examples
type Fix = fixed::FixedU32<fixed::frac::U4>; let two_point_5 = Fix::from_int(5) / 2; assert_eq!(two_point_5.to_int::<i32>(), 2); assert_eq!(two_point_5.to_int::<i64>(), 2);
pub fn from_float<F: Float>(val: F) -> FixedU32<Frac>
[src]
Creates a fixed-point number from a floating-point number.
The floating-point number can be of type f32
or f64
. If the
f16
feature is enabled, it can also be of type f16
.
This method rounds to the nearest, with ties rounding to even.
Panics
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_float
instead.
Examples
type Fix = fixed::FixedU32<fixed::frac::U4>; // 1.75 is 1.11 in binary assert_eq!(Fix::from_float(1.75f32), Fix::from_bits(0b111 << (4 - 2))); assert_eq!(Fix::from_float(1.75f64), Fix::from_bits(0b111 << (4-2)));
pub fn to_float<F: Float>(self) -> F
[src]
Converts a fixed-point number to a floating-point number.
The floating-point number can be of type f32
or f64
.
If the f16
feature is enabled, it can also be of type f16
.
This method rounds to the nearest, with ties rounding to even.
Examples
type Fix = fixed::FixedU32<fixed::frac::U4>; // 1.625 is 1.101 in binary assert_eq!(Fix::from_bits(0b1101 << (4 - 3)).to_float::<f32>(), 1.625f32); assert_eq!(Fix::from_bits(0b1101 << (4 - 3)).to_float::<f64>(), 1.625f64); let max_fixed = fixed::FixedU128::<fixed::frac::U0>::max_value(); assert_eq!(max_fixed.to_float::<f32>(), std::f32::INFINITY);
pub fn checked_from_fixed<F: Fixed>(val: F) -> Option<FixedU32<Frac>>
[src]
Creates a fixed-point number from another fixed-point
number if it fits, otherwise returns None
.
Any extra fractional bits are truncated.
Examples
type Src = fixed::FixedI32<fixed::frac::U16>; type Dst = fixed::FixedU32<fixed::frac::U4>; // 1.75 is 1.11 in binary let src = Src::from_bits(0b111 << (16 - 2)); assert_eq!(Dst::checked_from_fixed(src), Some(Dst::from_bits(0b111 << (4 - 2)))); let too_large = fixed::FixedU32::<fixed::frac::U2>::max_value(); assert!(Dst::checked_from_fixed(too_large).is_none());
pub fn checked_to_fixed<F: Fixed>(self) -> Option<F>
[src]
Converts a fixed-point number to another fixed-point
number if it fits, otherwise returns None
.
Any extra fractional bits are truncated.
Examples
type Src = fixed::FixedU32<fixed::frac::U4>; type Dst = fixed::FixedI32<fixed::frac::U16>; // 1.75 is 1.11 in binary let src = Src::from_bits(0b111 << (4 - 2)); let expected = Dst::from_bits(0b111 << (16 - 2)); assert_eq!(src.checked_to_fixed::<Dst>(), Some(expected)); type TooFewIntBits = fixed::FixedU32<fixed::frac::U6>; assert!(Src::max_value().checked_to_fixed::<TooFewIntBits>().is_none());
pub fn checked_from_int<I: Int>(val: I) -> Option<FixedU32<Frac>>
[src]
Creates a fixed-point number from an integer if it fits,
otherwise returns None
.
The integer can be of type i8
, i16
, i32
, i64
,
i128
, isize
, u8
, u16
, u32
, u64
, u128
, and
usize
.
Examples
type Fix = fixed::FixedU32<fixed::frac::U4>; assert_eq!(Fix::checked_from_int(3), Some(Fix::from_bits(3 << 4))); let too_large = u32::max_value(); assert!(Fix::checked_from_int(too_large).is_none()); let too_small = -1; assert!(Fix::checked_from_int(too_small).is_none());
pub fn checked_to_int<I: Int>(self) -> Option<I>
[src]
Converts a fixed-point number to an integer if it fits,
otherwise returns None
.
The integer can be of type i8
, i16
, i32
, i64
,
i128
, isize
, u8
, u16
, u32
, u64
, u128
, and
usize
.
Any fractional bits are truncated.
Examples
type Fix = fixed::FixedU32<fixed::frac::U4>; let two_point_5 = Fix::from_int(5) / 2; assert_eq!(two_point_5.checked_to_int::<i32>(), Some(2)); assert_eq!(two_point_5.checked_to_int::<i64>(), Some(2)); type AllInt = fixed::FixedU32<fixed::frac::U0>; assert!(AllInt::max_value().checked_to_int::<i32>().is_none());
pub fn checked_from_float<F: Float>(val: F) -> Option<FixedU32<Frac>>
[src]
Creates a fixed-point number from a floating-point number
if it fits, otherwise returns None
.
The floating-point number can be of type f32
or f64
. If the
f16
feature is enabled, it can also be of type f16
.
This method rounds to the nearest, with ties rounding to even.
Examples
type Fix = fixed::FixedU32<fixed::frac::U4>; // 1.75 is 1.11 in binary let expected = Fix::from_bits(0b111 << (4 - 2)); assert_eq!(Fix::checked_from_float(1.75f32), Some(expected)); assert_eq!(Fix::checked_from_float(1.75f64), Some(expected)); assert!(Fix::checked_from_float(2e38).is_none()); assert!(Fix::checked_from_float(std::f64::NAN).is_none());
pub fn saturating_from_fixed<F: Fixed>(val: F) -> FixedU32<Frac>
[src]
Creates a fixed-point number from another fixed-point number, saturating the value if it does not fit.
Any extra fractional bits are truncated.
Examples
type Src = fixed::FixedI32<fixed::frac::U16>; type Dst = fixed::FixedU32<fixed::frac::U4>; // 1.75 is 1.11 in binary let src = Src::from_bits(0b111 << (16 - 2)); assert_eq!(Dst::saturating_from_fixed(src), Dst::from_bits(0b111 << (4 - 2))); let too_large = fixed::FixedU32::<fixed::frac::U2>::max_value(); assert_eq!(Dst::saturating_from_fixed(too_large), Dst::max_value()); let too_small = Src::from_bits(-1); assert_eq!(Dst::saturating_from_fixed(too_small), Dst::min_value());
pub fn saturating_to_fixed<F: Fixed>(self) -> F
[src]
Converts a fixed-point number to another fixed-point number, saturating the value if it does not fit.
Any extra fractional bits are truncated.
Examples
type Src = fixed::FixedU32<fixed::frac::U4>; type Dst = fixed::FixedI32<fixed::frac::U16>; // 1.75 is 1.11 in binary let src = Src::from_bits(0b111 << (4 - 2)); assert_eq!(src.saturating_to_fixed::<Dst>(), Dst::from_bits(0b111 << (16 - 2))); type TooFewIntBits = fixed::FixedU32<fixed::frac::U6>; let saturated = Src::max_value().saturating_to_fixed::<TooFewIntBits>(); assert_eq!(saturated, TooFewIntBits::max_value());
pub fn saturating_from_int<I: Int>(val: I) -> FixedU32<Frac>
[src]
Creates a fixed-point number from an integer, saturating the value if it does not fit.
The integer can be of type i8
, i16
, i32
, i64
,
i128
, isize
, u8
, u16
, u32
, u64
, u128
, and
usize
.
Examples
type Fix = fixed::FixedU32<fixed::frac::U4>; assert_eq!(Fix::saturating_from_int(3), Fix::from_bits(3 << 4)); let too_large = u32::max_value(); assert_eq!(Fix::saturating_from_int(too_large), Fix::max_value()); let too_small = -1; assert_eq!(Fix::saturating_from_int(too_small), Fix::min_value());
pub fn saturating_to_int<I: Int>(self) -> I
[src]
Converts a fixed-point number to an integer, saturating the value if it does not fit.
The integer can be of type i8
, i16
, i32
, i64
,
i128
, isize
, u8
, u16
, u32
, u64
, u128
, and
usize
.
Any fractional bits are truncated.
Examples
type Fix = fixed::FixedU32<fixed::frac::U4>; let two_point_5 = Fix::from_int(5) / 2; assert_eq!(two_point_5.saturating_to_int::<i32>(), 2); assert_eq!(two_point_5.saturating_to_int::<i64>(), 2); type AllInt = fixed::FixedU32<fixed::frac::U0>; assert_eq!(AllInt::max_value().saturating_to_int::<i32>(), i32::max_value());
pub fn saturating_from_float<F: Float>(val: F) -> FixedU32<Frac>
[src]
Creates a fixed-point number from a floating-point number, saturating the value if it does not fit.
The floating-point value can be of type f32
or f64
.
If the f16
feature is enabled, it can also be of type f16
.
This method rounds to the nearest, with ties rounding to even.
Panics
This method panics if the value is NaN.
Examples
use std::f64; type Fix = fixed::FixedU32<fixed::frac::U4>; // 1.625 is 1.101 in binary let one_point_625 = Fix::from_bits(0b1101 << (4 - 3)); assert_eq!(Fix::saturating_from_float(1.625f32), one_point_625); assert_eq!(Fix::saturating_from_float(2e38), Fix::max_value()); assert_eq!(Fix::saturating_from_float(f64::NEG_INFINITY), Fix::min_value());
pub fn wrapping_from_fixed<F: Fixed>(val: F) -> FixedU32<Frac>
[src]
Creates a fixed-point number from another fixed-point number, wrapping the value on overflow.
Any extra fractional bits are truncated.
Examples
type Src = fixed::FixedI32<fixed::frac::U16>; type Dst = fixed::FixedU32<fixed::frac::U4>; // 1.75 is 1.11 in binary let src = Src::from_bits(0b111 << (16 - 2)); let expected = Dst::from_bits(0b111 << (4 - 2)); assert_eq!(Dst::wrapping_from_fixed(src), expected); // integer 0b1101 << (32 - 7) will wrap to fixed-point 1010... let too_large = fixed::FixedU32::<fixed::frac::U0>::from_bits(0b1101 << (32 - 7)); let wrapped = Dst::from_bits(0b1010 << (32 - 4)); assert_eq!(Dst::wrapping_from_fixed(too_large), wrapped);
pub fn wrapping_to_fixed<F: Fixed>(self) -> F
[src]
Converts a fixed-point number to another fixed-point number, wrapping the value on overflow.
Any extra fractional bits are truncated.
Examples
type Src = fixed::FixedU32<fixed::frac::U4>; type Dst = fixed::FixedI32<fixed::frac::U16>; // 1.75 is 1.11 in binary let src = Src::from_bits(0b111 << (4 - 2)); let expected = Dst::from_bits(0b111 << (16 - 2)); assert_eq!(Dst::wrapping_from_fixed(src), expected); type TooFewIntBits = fixed::FixedU32<fixed::frac::U6>; let wrapped = TooFewIntBits::from_bits(Src::max_value().to_bits() << 2); assert_eq!(Src::max_value().wrapping_to_fixed::<TooFewIntBits>(), wrapped);
pub fn wrapping_from_int<I: Int>(val: I) -> FixedU32<Frac>
[src]
Creates a fixed-point number from an integer, wrapping the value on overflow.
The integer can be of type i8
, i16
, i32
, i64
,
i128
, isize
, u8
, u16
, u32
, u64
, u128
, and
usize
.
Examples
type Fix = fixed::FixedU32<fixed::frac::U4>; assert_eq!(Fix::wrapping_from_int(3), Fix::from_bits(3 << 4)); // integer 0b1101 << (32 - 7) will wrap to fixed-point 1010... let large: u32 = 0b1101 << (32 - 7); let wrapped = Fix::from_bits(0b1010 << (32 - 4)); assert_eq!(Fix::wrapping_from_int(large), wrapped);
pub fn wrapping_to_int<I: Int>(self) -> I
[src]
Converts a fixed-point number to an integer, wrapping the value on overflow.
The integer can be of type i8
, i16
, i32
, i64
,
i128
, isize
, u8
, u16
, u32
, u64
, u128
, and
usize
.
Any fractional bits are truncated.
Examples
type Fix = fixed::FixedU32<fixed::frac::U4>; let two_point_5 = Fix::from_int(5) / 2; assert_eq!(two_point_5.wrapping_to_int::<i32>(), 2); assert_eq!(two_point_5.wrapping_to_int::<i64>(), 2); type AllInt = fixed::FixedU32<fixed::frac::U0>; assert_eq!(AllInt::max_value().wrapping_to_int::<i32>(), -1);
pub fn wrapping_from_float<F: Float>(val: F) -> FixedU32<Frac>
[src]
Creates a fixed-point number from a floating-point number, wrapping the value on overflow.
The floating-point value can be of type f32
or f64
.
If the f16
feature is enabled, it can also be of type f16
.
This method rounds to the nearest, with ties rounding to even.
Panics
This method panics if the value is not finite.
Examples
type Fix = fixed::FixedU32<fixed::frac::U4>; // 1.75 is 1.11 in binary let from_bits = Fix::from_bits(0b111 << (4 - 2)); assert_eq!(Fix::wrapping_from_float(1.75f32), from_bits); assert_eq!(Fix::wrapping_from_float(1.75f64), from_bits); // 1.75 << (32 - 4) wraps to binary 11000... let large = 1.75 * 2f32.powi(32 - 4); let wrapped = Fix::from_bits(0b1100 << (32 - 4)); assert_eq!(Fix::wrapping_from_float(large), wrapped);
pub fn overflowing_from_fixed<F: Fixed>(val: F) -> (FixedU32<Frac>, bool)
[src]
Creates a fixed-point number from another 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.
Any extra fractional bits are truncated.
Examples
type Src = fixed::FixedI32<fixed::frac::U16>; type Dst = fixed::FixedU32<fixed::frac::U4>; // 1.75 is 1.11 in binary let src = Src::from_bits(0b111 << (16 - 2)); let expected = Dst::from_bits(0b111 << (4 - 2)); assert_eq!(Dst::overflowing_from_fixed(src), (expected, false)); // integer 0b1101 << (32 - 7) will wrap to fixed-point 1010... let too_large = fixed::FixedU32::<fixed::frac::U0>::from_bits(0b1101 << (32 - 7)); let wrapped = Dst::from_bits(0b1010 << (32 - 4)); assert_eq!(Dst::overflowing_from_fixed(too_large), (wrapped, true));
pub fn overflowing_to_fixed<F: Fixed>(self) -> (F, bool)
[src]
Converts a fixed-point number to another 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.
Any extra fractional bits are truncated.
Examples
type Src = fixed::FixedU32<fixed::frac::U4>; type Dst = fixed::FixedI32<fixed::frac::U16>; // 1.75 is 1.11 in binary let src = Src::from_bits(0b111 << (4 - 2)); let expected = Dst::from_bits(0b111 << (16 - 2)); assert_eq!(Dst::overflowing_from_fixed(src), (expected, false)); type TooFewIntBits = fixed::FixedU32<fixed::frac::U6>; let wrapped = TooFewIntBits::from_bits(Src::max_value().to_bits() << 2); assert_eq!(Src::max_value().overflowing_to_fixed::<TooFewIntBits>(), (wrapped, true));
pub fn overflowing_from_int<I: Int>(val: I) -> (FixedU32<Frac>, bool)
[src]
Creates a fixed-point number from an integer.
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 integer can be of type i8
, i16
, i32
, i64
,
i128
, isize
, u8
, u16
, u32
, u64
, u128
, and
usize
.
Examples
type Fix = fixed::FixedU32<fixed::frac::U4>; assert_eq!(Fix::overflowing_from_int(3), (Fix::from_bits(3 << 4), false)); // integer 0b1101 << (32 - 7) will wrap to fixed-point 1010... let large: u32 = 0b1101 << (32 - 7); let wrapped = Fix::from_bits(0b1010 << (32 - 4)); assert_eq!(Fix::overflowing_from_int(large), (wrapped, true));
pub fn overflowing_to_int<I: Int>(self) -> (I, bool)
[src]
Converts a fixed-point number to an integer.
Returns a tuple of the integer and a bool
indicating whether an
overflow has occurred. On overflow, the wrapped value is returned.
The integer can be of type i8
, i16
, i32
, i64
,
i128
, isize
, u8
, u16
, u32
, u64
, u128
, and
usize
.
Any fractional bits are truncated.
Examples
type Fix = fixed::FixedU32<fixed::frac::U4>; let two_point_5 = Fix::from_int(5) / 2; assert_eq!(two_point_5.overflowing_to_int::<i32>(), (2, false)); assert_eq!(two_point_5.overflowing_to_int::<i64>(), (2, false)); let does_not_fit = fixed::FixedU32::<fixed::frac::U0>::max_value(); let wrapped = -1i32; assert_eq!(does_not_fit.overflowing_to_int::<i32>(), (wrapped, true));
pub fn overflowing_from_float<F: Float>(val: F) -> (FixedU32<Frac>, bool)
[src]
Creates a fixed-point number from a floating-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.
The floating-point value can be of type f32
or f64
.
If the f16
feature is enabled, it can also be of type f16
.
This method rounds to the nearest, with ties rounding to even.
Panics
This method panics if the value is not finite.
Examples
type Fix = fixed::FixedU32<fixed::frac::U4>; // 1.75 is 1.11 in binary let from_bits = Fix::from_bits(0b111 << (4 - 2)); assert_eq!(Fix::overflowing_from_float(1.75f32), (from_bits, false)); assert_eq!(Fix::overflowing_from_float(1.75f64), (from_bits, false)); // 1.75 << (32 - 4) wraps to binary 11000... let large = 1.75 * 2f32.powi(32 - 4); let wrapped = Fix::from_bits(0b1100 << (32 - 4)); assert_eq!(Fix::overflowing_from_float(large), (wrapped, true));
pub fn int(self) -> FixedU32<Frac>
[src]
Returns the integer part.
Examples
type Fix = fixed::FixedU32<fixed::frac::U4>; // 0010.0000 let two = Fix::from_int(2); // 0010.0100 let two_and_quarter = two + two / 8; assert_eq!(two_and_quarter.int(), two);
pub fn frac(self) -> FixedU32<Frac>
[src]
Returns the fractional part.
Examples
type Fix = fixed::FixedU32<fixed::frac::U4>; // 0000.0100 let quarter = Fix::from_int(1) / 4; // 0010.0100 let two_and_quarter = quarter * 9; assert_eq!(two_and_quarter.frac(), quarter);
pub fn ceil(self) -> FixedU32<Frac>
[src]
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
type Fix = fixed::FixedU32<fixed::frac::U4>; let two_half = Fix::from_int(5) / 2; assert_eq!(two_half.ceil(), Fix::from_int(3));
pub fn floor(self) -> FixedU32<Frac>
[src]
Rounds to the next integer towards −∞.
Examples
type Fix = fixed::FixedU32<fixed::frac::U4>; let two_half = Fix::from_int(5) / 2; assert_eq!(two_half.floor(), Fix::from_int(2));
pub fn round(self) -> FixedU32<Frac>
[src]
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
type Fix = fixed::FixedU32<fixed::frac::U4>; let two_half = Fix::from_int(5) / 2; assert_eq!(two_half.round(), Fix::from_int(3));
pub fn checked_ceil(self) -> Option<FixedU32<Frac>>
[src]
Checked ceil. Rounds to the next integer towards +∞,
returning None
on overflow.
Examples
type Fix = fixed::FixedU32<fixed::frac::U4>; let two_half = Fix::from_int(5) / 2; assert_eq!(two_half.checked_ceil(), Some(Fix::from_int(3))); assert!(Fix::max_value().checked_ceil().is_none());
pub fn checked_floor(self) -> Option<FixedU32<Frac>>
[src]
Checked floor. Rounds to the next integer towards −∞.Always returns Some
for unsigned values.
Examples
type Fix = fixed::FixedU32<fixed::frac::U4>; let two_half = Fix::from_int(5) / 2; assert_eq!(two_half.checked_floor(), Some(Fix::from_int(2)));
pub fn checked_round(self) -> Option<FixedU32<Frac>>
[src]
Checked round. Rounds to the nearest integer, with ties
rounded away from zero, returning None
on overflow.
Examples
type Fix = fixed::FixedU32<fixed::frac::U4>; let two_half = Fix::from_int(5) / 2; assert_eq!(two_half.checked_round(), Some(Fix::from_int(3))); assert!(Fix::max_value().checked_round().is_none());
pub fn saturating_ceil(self) -> FixedU32<Frac>
[src]
Saturating ceil. Rounds to the next integer towards +∞, saturating on overflow.
Examples
type Fix = fixed::FixedU32<fixed::frac::U4>; let two_half = Fix::from_int(5) / 2; assert_eq!(two_half.saturating_ceil(), Fix::from_int(3)); assert_eq!(Fix::max_value().saturating_ceil(), Fix::max_value());
pub fn saturating_floor(self) -> FixedU32<Frac>
[src]
Saturating floor. Rounds to the next integer towards −∞. Cannot overflow for unsigned values.
Examples
type Fix = fixed::FixedU32<fixed::frac::U4>; let two_half = Fix::from_int(5) / 2; assert_eq!(two_half.saturating_floor(), Fix::from_int(2));
pub fn saturating_round(self) -> FixedU32<Frac>
[src]
Saturating round. Rounds to the nearest integer, with ties rounded away from zero, and saturating on overflow.
Examples
type Fix = fixed::FixedU32<fixed::frac::U4>; let two_half = Fix::from_int(5) / 2; assert_eq!(two_half.saturating_round(), Fix::from_int(3)); assert_eq!(Fix::max_value().saturating_round(), Fix::max_value());
pub fn wrapping_ceil(self) -> FixedU32<Frac>
[src]
Wrapping ceil. Rounds to the next integer towards +∞, wrapping on overflow.
Examples
type Fix = fixed::FixedU32<fixed::frac::U4>; let two_half = Fix::from_int(5) / 2; assert_eq!(two_half.wrapping_ceil(), Fix::from_int(3)); assert_eq!(Fix::max_value().wrapping_ceil(), Fix::min_value());
pub fn wrapping_floor(self) -> FixedU32<Frac>
[src]
Wrapping floor. Rounds to the next integer towards −∞. Cannot overflow for unsigned values.
Examples
type Fix = fixed::FixedU32<fixed::frac::U4>; let two_half = Fix::from_int(5) / 2; assert_eq!(two_half.wrapping_floor(), Fix::from_int(2));
pub fn wrapping_round(self) -> FixedU32<Frac>
[src]
Wrapping round. Rounds to the next integer to the nearest, with ties rounded away from zero, and wrapping on overflow.
Examples
type Fix = fixed::FixedU32<fixed::frac::U4>; let two_half = Fix::from_int(5) / 2; assert_eq!(two_half.wrapping_round(), Fix::from_int(3)); assert_eq!(Fix::max_value().wrapping_round(), Fix::min_value());
pub fn overflowing_ceil(self) -> (FixedU32<Frac>, bool)
[src]
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
type Fix = fixed::FixedU32<fixed::frac::U4>; let two_half = Fix::from_int(5) / 2; assert_eq!(two_half.overflowing_ceil(), (Fix::from_int(3), false)); assert_eq!(Fix::max_value().overflowing_ceil(), (Fix::min_value(), true));
pub fn overflowing_floor(self) -> (FixedU32<Frac>, bool)
[src]
Overflowing floor. Rounds to the next integer towards −∞.
Returns a tuple of the fixed-point number and
false
.
Examples
type Fix = fixed::FixedU32<fixed::frac::U4>; let two_half = Fix::from_int(5) / 2; assert_eq!(two_half.overflowing_floor(), (Fix::from_int(2), false));
pub fn overflowing_round(self) -> (FixedU32<Frac>, bool)
[src]
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
type Fix = fixed::FixedU32<fixed::frac::U4>; let two_half = Fix::from_int(5) / 2; assert_eq!(two_half.overflowing_round(), (Fix::from_int(3), false)); assert_eq!(Fix::max_value().overflowing_round(), (Fix::min_value(), true));
pub fn count_ones(self) -> u32
[src]
Returns the number of ones in the binary representation.
Examples
type Fix = fixed::FixedU32<fixed::frac::U4>; let f = Fix::from_bits(0b11_0010); assert_eq!(f.count_ones(), 3);
pub fn count_zeros(self) -> u32
[src]
Returns the number of zeros in the binary representation.
Examples
type Fix = fixed::FixedU32<fixed::frac::U4>; let f = Fix::from_bits(!0b11_0010); assert_eq!(f.count_zeros(), 3);
pub fn leading_zeros(self) -> u32
[src]
Returns the number of leading zeros in the binary representation.
Examples
type Fix = fixed::FixedU32<fixed::frac::U4>; let f = Fix::from_bits(0b10_0000); assert_eq!(f.leading_zeros(), 32 - 6);
pub fn trailing_zeros(self) -> u32
[src]
Returns the number of trailing zeros in the binary representation.
Examples
type Fix = fixed::FixedU32<fixed::frac::U4>; let f = Fix::from_bits(0b10_0000); assert_eq!(f.trailing_zeros(), 5);
pub fn rotate_left(self, n: u32) -> FixedU32<Frac>
[src]
Shifts to the left by n bits, wrapping the truncated bits to the right end.
Examples
type Fix = fixed::FixedU32<fixed::frac::U4>; let bits: u32 = (0b111 << (32 - 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 fn rotate_right(self, n: u32) -> FixedU32<Frac>
[src]
Shifts to the right by n bits, wrapping the truncated bits to the left end.
Examples
type Fix = fixed::FixedU32<fixed::frac::U4>; let bits: u32 = 0b1010111; let rot = (0b111 << (32 - 3)) | 0b1010; assert_eq!(bits.rotate_right(3), rot); assert_eq!(Fix::from_bits(bits).rotate_right(3), Fix::from_bits(rot));
pub fn checked_neg(self) -> Option<FixedU32<Frac>>
[src]
Checked negation. Returns the negated value, or None
on overflow.
Only zero can be negated without overflow.
Examples
type Fix = fixed::FixedU32<fixed::frac::U4>; assert_eq!(Fix::from_int(0).checked_neg(), Some(Fix::from_int(0))); assert_eq!(Fix::from_int(5).checked_neg(), None);
pub fn checked_add(self, rhs: FixedU32<Frac>) -> Option<FixedU32<Frac>>
[src]
Checked addition. Returns the sum, or None
on overflow.
Examples
type Fix = fixed::FixedU32<fixed::frac::U4>; let one = Fix::from_int(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: FixedU32<Frac>) -> Option<FixedU32<Frac>>
[src]
Checked subtraction. Returns the difference, or None
on overflow.
Examples
type Fix = fixed::FixedU32<fixed::frac::U4>; let one = Fix::from_int(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_mul(self, rhs: FixedU32<Frac>) -> Option<FixedU32<Frac>>
[src]
Checked multiplication. Returns the product, or None
on overflow.
Examples
type Fix = fixed::FixedU32<fixed::frac::U4>; assert_eq!(Fix::max_value().checked_mul(Fix::from_int(1)), Some(Fix::max_value())); assert_eq!(Fix::max_value().checked_mul(Fix::from_int(2)), None);
pub fn checked_div(self, rhs: FixedU32<Frac>) -> Option<FixedU32<Frac>>
[src]
Checked division. Returns the quotient, or None
if
the divisor is zero or on overflow.
Examples
type Fix = fixed::FixedU32<fixed::frac::U4>; assert_eq!(Fix::max_value().checked_div(Fix::from_int(1)), Some(Fix::max_value())); assert_eq!(Fix::max_value().checked_div(Fix::from_int(1) / 2), None);
pub fn checked_mul_int(self, rhs: u32) -> Option<FixedU32<Frac>>
[src]
Checked multiplication by an integer. Returns the
product, or None
on overflow.
Examples
type Fix = fixed::FixedU32<fixed::frac::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: u32) -> Option<FixedU32<Frac>>
[src]
Checked division by an integer. Returns the quotient, or
None
if the divisor is zero.
Examples
type Fix = fixed::FixedU32<fixed::frac::U4>; assert_eq!(Fix::max_value().checked_div_int(1), Some(Fix::max_value())); assert_eq!(Fix::from_int(1).checked_div_int(0), None);
pub fn checked_rem_int(self, rhs: u32) -> Option<FixedU32<Frac>>
[src]
Checked fixed-point remainder for division by an integer.
Returns the remainder, or None
if the divisor is zero.
Examples
type Fix = fixed::FixedU32<fixed::frac::U4>; // binary 1.0101 / 8 = binary 0.0010 remainder 0.0101 assert_eq!(Fix::from_bits(0b10101).checked_rem_int(8), Some(Fix::from_bits(0b101))); assert_eq!(Fix::from_int(1).checked_rem_int(0), None);
pub fn checked_shl(self, rhs: u32) -> Option<FixedU32<Frac>>
[src]
Checked shift left. Returns the shifted number, or None
if rhs
≥ 32.
Examples
type Fix = fixed::FixedU32<fixed::frac::U4>; assert_eq!((Fix::from_int(1) / 2).checked_shl(3), Some(Fix::from_int(4))); assert_eq!((Fix::from_int(1) / 2).checked_shl(32), None);
pub fn checked_shr(self, rhs: u32) -> Option<FixedU32<Frac>>
[src]
Checked shift right. Returns the shifted number, or None
if rhs
≥ 32.
Examples
type Fix = fixed::FixedU32<fixed::frac::U4>; assert_eq!(Fix::from_int(4).checked_shr(3), Some(Fix::from_int(1) / 2)); assert_eq!(Fix::from_int(4).checked_shr(32), None);
pub fn saturating_neg(self) -> FixedU32<Frac>
[src]
Saturating negation. Returns the negated value, saturating on overflow.
This method always returns zero.
Examples
type Fix = fixed::FixedU32<fixed::frac::U4>; assert_eq!(Fix::from_int(0).saturating_neg(), Fix::from_int(0)); assert_eq!(Fix::from_int(5).saturating_neg(), Fix::from_int(0));
pub fn saturating_add(self, rhs: FixedU32<Frac>) -> FixedU32<Frac>
[src]
Saturating addition. Returns the sum, saturating on overflow.
Examples
type Fix = fixed::FixedU32<fixed::frac::U4>; assert_eq!(Fix::from_int(3).saturating_add(Fix::from_int(2)), Fix::from_int(5)); assert_eq!(Fix::max_value().saturating_add(Fix::from_int(1)), Fix::max_value());
pub fn saturating_sub(self, rhs: FixedU32<Frac>) -> FixedU32<Frac>
[src]
Saturating subtraction. Returns the difference, saturating on overflow.
Examples
type Fix = fixed::FixedU32<fixed::frac::U4>; assert_eq!(Fix::from_int(5).saturating_sub(Fix::from_int(3)), Fix::from_int(2)); assert_eq!(Fix::from_int(0).saturating_sub(Fix::from_int(1)), Fix::from_int(0));
pub fn saturating_mul(self, rhs: FixedU32<Frac>) -> FixedU32<Frac>
[src]
Saturating multiplication. Returns the product, saturating on overflow.
Examples
type Fix = fixed::FixedU32<fixed::frac::U4>; assert_eq!(Fix::from_int(3).saturating_mul(Fix::from_int(2)), Fix::from_int(6)); assert_eq!(Fix::max_value().saturating_mul(Fix::from_int(2)), Fix::max_value());
pub fn saturating_div(self, rhs: FixedU32<Frac>) -> FixedU32<Frac>
[src]
Saturating division. Returns the quotient, saturating on overflow.
Panics
Panics if the divisor is zero.
Examples
type Fix = fixed::FixedU32<fixed::frac::U4>; let one_half = Fix::from_int(1) / 2; assert_eq!(Fix::from_int(1).saturating_div(Fix::from_int(2)), one_half); assert_eq!(Fix::max_value().saturating_div(one_half), Fix::max_value());
pub fn saturating_mul_int(self, rhs: u32) -> FixedU32<Frac>
[src]
Saturating multiplication by an integer. Returns the product, saturating on overflow.
Examples
type Fix = fixed::FixedU32<fixed::frac::U4>; assert_eq!(Fix::from_int(3).saturating_mul_int(2), Fix::from_int(6)); assert_eq!(Fix::max_value().saturating_mul_int(2), Fix::max_value());
pub fn wrapping_neg(self) -> FixedU32<Frac>
[src]
Wrapping negation. Returns the negated value, wrapping on overflow.
Only zero can be negated without overflow.
Examples
type Fix = fixed::FixedU32<fixed::frac::U4>; assert_eq!(Fix::from_int(0).wrapping_neg(), Fix::from_int(0)); assert_eq!(Fix::from_int(5).wrapping_neg(), Fix::wrapping_from_int(-5)); let neg_five_bits = !Fix::from_int(5).to_bits() + 1; assert_eq!(Fix::from_int(5).wrapping_neg(), Fix::from_bits(neg_five_bits));
pub fn wrapping_add(self, rhs: FixedU32<Frac>) -> FixedU32<Frac>
[src]
Wrapping addition. Returns the sum, wrapping on overflow.
Examples
type Fix = fixed::FixedU32<fixed::frac::U4>; let one = Fix::from_int(1); let one_minus_bit = one - Fix::from_bits(1); assert_eq!(Fix::from_int(3).wrapping_add(Fix::from_int(2)), Fix::from_int(5)); assert_eq!(Fix::max_value().wrapping_add(one), one_minus_bit);
pub fn wrapping_sub(self, rhs: FixedU32<Frac>) -> FixedU32<Frac>
[src]
Wrapping subtraction. Returns the difference, wrapping on overflow.
Examples
type Fix = fixed::FixedU32<fixed::frac::U4>; let one = Fix::from_int(1); let one_minus_bit = one - Fix::from_bits(1); assert_eq!(Fix::from_int(5).wrapping_sub(Fix::from_int(3)), Fix::from_int(2)); assert_eq!(Fix::from_int(0).wrapping_sub(one), Fix::max_value() - one_minus_bit);
pub fn wrapping_mul(self, rhs: FixedU32<Frac>) -> FixedU32<Frac>
[src]
Wrapping multiplication. Returns the product, wrapping on overflow.
Examples
type Fix = fixed::FixedU32<fixed::frac::U4>; assert_eq!(Fix::from_int(3).wrapping_mul(Fix::from_int(2)), Fix::from_int(6)); let wrapped = Fix::from_bits(!0 << 2); assert_eq!(Fix::max_value().wrapping_mul(Fix::from_int(4)), wrapped);
pub fn wrapping_div(self, rhs: FixedU32<Frac>) -> FixedU32<Frac>
[src]
Wrapping division. Returns the quotient, wrapping on overflow.
Panics
Panics if the divisor is zero.
Examples
type Fix = fixed::FixedU32<fixed::frac::U4>; let one_point_5 = Fix::from_bits(0b11 << (4 - 1)); assert_eq!(Fix::from_int(3).wrapping_div(Fix::from_int(2)), one_point_5); let quarter = Fix::from_int(1) / 4; let wrapped = Fix::from_bits(!0 << 2); assert_eq!(Fix::max_value().wrapping_div(quarter), wrapped);
pub fn wrapping_mul_int(self, rhs: u32) -> FixedU32<Frac>
[src]
Wrapping multiplication by an integer. Returns the product, wrapping on overflow.
Examples
type Fix = fixed::FixedU32<fixed::frac::U4>; assert_eq!(Fix::from_int(3).wrapping_mul_int(2), Fix::from_int(6)); let wrapped = Fix::from_bits(!0 << 2); assert_eq!(Fix::max_value().wrapping_mul_int(4), wrapped);
pub fn wrapping_div_int(self, rhs: u32) -> FixedU32<Frac>
[src]
Wrapping division by an integer. Returns the quotient.
Can never overflow for unsigned values.
Panics
Panics if the divisor is zero.
Examples
type Fix = fixed::FixedU32<fixed::frac::U4>; // 1.5 is binary 1.1 let one_point_5 = Fix::from_bits(0b11 << (4 - 1)); assert_eq!(Fix::from_int(3).wrapping_div_int(2), one_point_5);
pub fn wrapping_rem_int(self, rhs: u32) -> FixedU32<Frac>
[src]
Wrapping fixed-point remainder for division by an integer. Returns the remainder.
Can never overflow for unsigned values.
Panics
Panics if the divisor is zero.
Examples
type Fix = fixed::FixedU32<fixed::frac::U4>; // binary 1.0101 / 8 = binary 0.0010 remainder 0.0101 assert_eq!(Fix::from_bits(0b10101).wrapping_rem_int(8), Fix::from_bits(0b101));
pub fn wrapping_shl(self, rhs: u32) -> FixedU32<Frac>
[src]
Wrapping shift left. Wraps rhs
if rhs
≥ 32, then shifts and returns the number.
Examples
type Fix = fixed::FixedU32<fixed::frac::U4>; assert_eq!((Fix::from_int(1) / 2).wrapping_shl(3), Fix::from_int(4)); assert_eq!((Fix::from_int(1) / 2).wrapping_shl(3 + 32), Fix::from_int(4));
pub fn wrapping_shr(self, rhs: u32) -> FixedU32<Frac>
[src]
Wrapping shift right. Wraps rhs
if rhs
≥ 32, then shifts and returns the number.
Examples
type Fix = fixed::FixedU32<fixed::frac::U4>; assert_eq!((Fix::from_int(4)).wrapping_shr(3), Fix::from_int(1) / 2); assert_eq!((Fix::from_int(4)).wrapping_shr(3 + 32), Fix::from_int(1) / 2);
pub fn overflowing_neg(self) -> (FixedU32<Frac>, bool)
[src]
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
type Fix = fixed::FixedU32<fixed::frac::U4>; assert_eq!(Fix::from_int(0).overflowing_neg(), (Fix::from_int(0), false)); assert_eq!(Fix::from_int(5).overflowing_neg(), Fix::overflowing_from_int(-5)); let neg_five_bits = !Fix::from_int(5).to_bits() + 1; assert_eq!(Fix::from_int(5).overflowing_neg(), (Fix::from_bits(neg_five_bits), true));
pub fn overflowing_add(self, rhs: FixedU32<Frac>) -> (FixedU32<Frac>, bool)
[src]
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
type Fix = fixed::FixedU32<fixed::frac::U4>; let one = Fix::from_int(1); let one_minus_bit = one - Fix::from_bits(1); assert_eq!(Fix::from_int(3).overflowing_add(Fix::from_int(2)), (Fix::from_int(5), false)); assert_eq!(Fix::max_value().overflowing_add(one), (one_minus_bit, true));
pub fn overflowing_sub(self, rhs: FixedU32<Frac>) -> (FixedU32<Frac>, bool)
[src]
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
type Fix = fixed::FixedU32<fixed::frac::U4>; let one = Fix::from_int(1); let one_minus_bit = one - Fix::from_bits(1); assert_eq!(Fix::from_int(5).overflowing_sub(Fix::from_int(3)), (Fix::from_int(2), false)); assert_eq!(Fix::from_int(0).overflowing_sub(one), (Fix::max_value() - one_minus_bit, true));
pub fn overflowing_mul(self, rhs: FixedU32<Frac>) -> (FixedU32<Frac>, bool)
[src]
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
type Fix = fixed::FixedU32<fixed::frac::U4>; assert_eq!(Fix::from_int(3).overflowing_mul(Fix::from_int(2)), (Fix::from_int(6), false)); let wrapped = Fix::from_bits(!0 << 2); assert_eq!(Fix::max_value().overflowing_mul(Fix::from_int(4)), (wrapped, true));
pub fn overflowing_div(self, rhs: FixedU32<Frac>) -> (FixedU32<Frac>, bool)
[src]
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
type Fix = fixed::FixedU32<fixed::frac::U4>; let one_point_5 = Fix::from_bits(0b11 << (4 - 1)); assert_eq!(Fix::from_int(3).overflowing_div(Fix::from_int(2)), (one_point_5, false)); let quarter = Fix::from_int(1) / 4; let wrapped = Fix::from_bits(!0 << 2); assert_eq!(Fix::max_value().overflowing_div(quarter), (wrapped, true));
pub fn overflowing_mul_int(self, rhs: u32) -> (FixedU32<Frac>, bool)
[src]
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
type Fix = fixed::FixedU32<fixed::frac::U4>; assert_eq!(Fix::from_int(3).overflowing_mul_int(2), (Fix::from_int(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: u32) -> (FixedU32<Frac>, bool)
[src]
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
type Fix = fixed::FixedU32<fixed::frac::U4>; // 1.5 is binary 1.1 let one_point_5 = Fix::from_bits(0b11 << (4 - 1)); assert_eq!(Fix::from_int(3).overflowing_div_int(2), (one_point_5, false));
pub fn overflowing_rem_int(self, rhs: u32) -> (FixedU32<Frac>, bool)
[src]
Overflowing fixed-point remainder for division by an integer.
Returns a tuple of the remainder and false
, as the division can never overflow for unsigned values.
Panics
Panics if the divisor is zero.
Examples
type Fix = fixed::FixedU32<fixed::frac::U4>; // binary 1.0101 / 8 = binary 0.0010 remainder 0.0101 assert_eq!(Fix::from_bits(0b10101).overflowing_rem_int(8), (Fix::from_bits(0b101), false));
pub fn overflowing_shl(self, rhs: u32) -> (FixedU32<Frac>, bool)
[src]
Overflowing shift left.
Returns a tuple of the shifted value and a bool
indicating whether
an overflow has occurred. Overflow occurs when rhs
≥ 32. On overflow rhs
is wrapped before the shift operation.
Examples
type Fix = fixed::FixedU32<fixed::frac::U4>; assert_eq!((Fix::from_int(1) / 2).overflowing_shl(3), (Fix::from_int(4), false)); assert_eq!((Fix::from_int(1) / 2).overflowing_shl(3 + 32), (Fix::from_int(4), true));
pub fn overflowing_shr(self, rhs: u32) -> (FixedU32<Frac>, bool)
[src]
Overflowing shift right.
Returns a tuple of the shifted value and a bool
indicating whether
an overflow has occurred. Overflow occurs when rhs
≥ 32. On overflow rhs
is wrapped before the shift operation.
Examples
type Fix = fixed::FixedU32<fixed::frac::U4>; assert_eq!((Fix::from_int(4)).overflowing_shr(3), (Fix::from_int(1) / 2, false)); assert_eq!((Fix::from_int(4)).overflowing_shr(3 + 32), (Fix::from_int(1) / 2, true));
pub fn is_power_of_two(self) -> bool
[src]
Returns true
if the fixed-point number is
2k for some integer k.
Examples
type Fix = fixed::FixedU32<fixed::frac::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!(!three_eights.is_power_of_two()); assert!(half.is_power_of_two());
pub fn next_power_of_two(self) -> FixedU32<Frac>
[src]
Returns the smallest power of two ≥ self
.
Panics
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.
Examples
type Fix = fixed::FixedU32<fixed::frac::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_next_power_of_two(self) -> Option<FixedU32<Frac>>
[src]
Returns the smallest power of two ≥ self
, or
None
if the next power of two is too large to represent.
Examples
type Fix = fixed::FixedU32<fixed::frac::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());
Trait Implementations
impl<Frac> Fixed for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
impl<Frac> Fixed for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Bits = u32
The primitive integer underlying type.
fn min_value() -> Self
[src]
fn max_value() -> Self
[src]
fn int_nbits() -> u32
[src]
fn frac_nbits() -> u32
[src]
fn from_bits(bits: Self::Bits) -> Self
[src]
fn to_bits(self) -> Self::Bits
[src]
fn from_int<I: Int>(val: I) -> Self
[src]
fn to_int<I: Int>(self) -> I
[src]
fn from_float<F: Float>(val: F) -> Self
[src]
fn to_float<F: Float>(self) -> F
[src]
fn checked_from_int<I: Int>(val: I) -> Option<Self>
[src]
fn checked_to_int<I: Int>(self) -> Option<I>
[src]
fn checked_from_float<F: Float>(val: F) -> Option<Self>
[src]
fn saturating_from_int<I: Int>(val: I) -> Self
[src]
fn saturating_to_int<I: Int>(self) -> I
[src]
fn saturating_from_float<F: Float>(val: F) -> Self
[src]
fn wrapping_from_int<I: Int>(val: I) -> Self
[src]
fn wrapping_to_int<I: Int>(self) -> I
[src]
fn wrapping_from_float<F: Float>(val: F) -> Self
[src]
fn overflowing_from_int<I: Int>(val: I) -> (Self, bool)
[src]
fn overflowing_to_int<I: Int>(self) -> (I, bool)
[src]
fn overflowing_from_float<F: Float>(val: F) -> (Self, bool)
[src]
fn int(self) -> Self
[src]
fn frac(self) -> Self
[src]
fn ceil(self) -> Self
[src]
fn floor(self) -> Self
[src]
fn round(self) -> Self
[src]
fn checked_ceil(self) -> Option<Self>
[src]
fn checked_floor(self) -> Option<Self>
[src]
fn checked_round(self) -> Option<Self>
[src]
fn saturating_ceil(self) -> Self
[src]
fn saturating_floor(self) -> Self
[src]
fn saturating_round(self) -> Self
[src]
fn wrapping_ceil(self) -> Self
[src]
fn wrapping_floor(self) -> Self
[src]
fn wrapping_round(self) -> Self
[src]
fn overflowing_ceil(self) -> (Self, bool)
[src]
fn overflowing_floor(self) -> (Self, bool)
[src]
fn overflowing_round(self) -> (Self, bool)
[src]
fn count_ones(self) -> u32
[src]
fn count_zeros(self) -> u32
[src]
fn leading_zeros(self) -> u32
[src]
fn trailing_zeros(self) -> u32
[src]
fn rotate_left(self, n: u32) -> Self
[src]
fn rotate_right(self, n: u32) -> Self
[src]
fn mul_int(self, rhs: Self::Bits) -> Self
[src]
fn div_int(self, rhs: Self::Bits) -> Self
[src]
fn rem_int(self, rhs: Self::Bits) -> Self
[src]
fn checked_neg(self) -> Option<Self>
[src]
fn checked_add(self, rhs: Self) -> Option<Self>
[src]
fn checked_sub(self, rhs: Self) -> Option<Self>
[src]
fn checked_mul(self, rhs: Self) -> Option<Self>
[src]
fn checked_div(self, rhs: Self) -> Option<Self>
[src]
fn checked_mul_int(self, rhs: Self::Bits) -> Option<Self>
[src]
fn checked_div_int(self, rhs: Self::Bits) -> Option<Self>
[src]
fn checked_rem_int(self, rhs: Self::Bits) -> Option<Self>
[src]
fn checked_shl(self, rhs: u32) -> Option<Self>
[src]
fn checked_shr(self, rhs: u32) -> Option<Self>
[src]
fn saturating_neg(self) -> Self
[src]
fn saturating_add(self, rhs: Self) -> Self
[src]
fn saturating_sub(self, rhs: Self) -> Self
[src]
fn saturating_mul(self, rhs: Self) -> Self
[src]
fn saturating_div(self, rhs: Self) -> Self
[src]
fn saturating_mul_int(self, rhs: Self::Bits) -> Self
[src]
fn wrapping_neg(self) -> Self
[src]
fn wrapping_add(self, rhs: Self) -> Self
[src]
fn wrapping_sub(self, rhs: Self) -> Self
[src]
fn wrapping_mul(self, rhs: Self) -> Self
[src]
fn wrapping_div(self, rhs: Self) -> Self
[src]
fn wrapping_mul_int(self, rhs: Self::Bits) -> Self
[src]
fn wrapping_div_int(self, rhs: Self::Bits) -> Self
[src]
fn wrapping_rem_int(self, rhs: Self::Bits) -> Self
[src]
fn wrapping_shl(self, rhs: u32) -> Self
[src]
fn wrapping_shr(self, rhs: u32) -> Self
[src]
fn overflowing_neg(self) -> (Self, bool)
[src]
fn overflowing_add(self, rhs: Self) -> (Self, bool)
[src]
fn overflowing_sub(self, rhs: Self) -> (Self, bool)
[src]
fn overflowing_mul(self, rhs: Self) -> (Self, bool)
[src]
fn overflowing_div(self, rhs: Self) -> (Self, bool)
[src]
fn overflowing_mul_int(self, rhs: Self::Bits) -> (Self, bool)
[src]
fn overflowing_div_int(self, rhs: Self::Bits) -> (Self, bool)
[src]
fn overflowing_rem_int(self, rhs: Self::Bits) -> (Self, bool)
[src]
fn overflowing_shl(self, rhs: u32) -> (Self, bool)
[src]
fn overflowing_shr(self, rhs: u32) -> (Self, bool)
[src]
impl<Frac> FixedUnsigned for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn is_power_of_two(self) -> bool
[src]
fn next_power_of_two(self) -> Self
[src]
fn checked_next_power_of_two(self) -> Option<Self>
[src]
impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedU8<FracSrc>> for FixedU32<FracDst> where
FracSrc: Unsigned + IsLessOrEqual<U8, Output = True> + Add<U32, Output = FracSrcP>,
FracDst: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U8, Output = FracDstP>,
FracSrcP: Unsigned,
FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>,
[src]
FracSrc: Unsigned + IsLessOrEqual<U8, Output = True> + Add<U32, Output = FracSrcP>,
FracDst: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U8, Output = FracDstP>,
FracSrcP: Unsigned,
FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>,
fn lossy_from(src: FixedU8<FracSrc>) -> FixedU32<FracDst>
[src]
impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedU16<FracSrc>> for FixedU32<FracDst> where
FracSrc: Unsigned + IsLessOrEqual<U16, Output = True> + Add<U32, Output = FracSrcP>,
FracDst: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U16, Output = FracDstP>,
FracSrcP: Unsigned,
FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>,
[src]
FracSrc: Unsigned + IsLessOrEqual<U16, Output = True> + Add<U32, Output = FracSrcP>,
FracDst: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U16, Output = FracDstP>,
FracSrcP: Unsigned,
FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>,
fn lossy_from(src: FixedU16<FracSrc>) -> FixedU32<FracDst>
[src]
impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedU32<FracSrc>> for FixedU8<FracDst> where
FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U8, Output = FracSrcP>,
FracDst: Unsigned + IsLessOrEqual<U8, Output = True> + Add<U32, Output = FracDstP>,
FracSrcP: Unsigned,
FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>,
[src]
FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U8, Output = FracSrcP>,
FracDst: Unsigned + IsLessOrEqual<U8, Output = True> + Add<U32, Output = FracDstP>,
FracSrcP: Unsigned,
FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>,
fn lossy_from(src: FixedU32<FracSrc>) -> FixedU8<FracDst>
[src]
impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedU32<FracSrc>> for FixedI8<FracDst> where
FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U8, Output = FracSrcP>,
FracDst: Unsigned + IsLessOrEqual<U8, Output = True> + Add<<U32 as Add<U1>>::Output, Output = FracDstP>,
FracSrcP: Unsigned,
FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>,
[src]
FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U8, Output = FracSrcP>,
FracDst: Unsigned + IsLessOrEqual<U8, Output = True> + Add<<U32 as Add<U1>>::Output, Output = FracDstP>,
FracSrcP: Unsigned,
FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>,
fn lossy_from(src: FixedU32<FracSrc>) -> FixedI8<FracDst>
[src]
impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedU32<FracSrc>> for FixedU16<FracDst> where
FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U16, Output = FracSrcP>,
FracDst: Unsigned + IsLessOrEqual<U16, Output = True> + Add<U32, Output = FracDstP>,
FracSrcP: Unsigned,
FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>,
[src]
FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U16, Output = FracSrcP>,
FracDst: Unsigned + IsLessOrEqual<U16, Output = True> + Add<U32, Output = FracDstP>,
FracSrcP: Unsigned,
FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>,
fn lossy_from(src: FixedU32<FracSrc>) -> FixedU16<FracDst>
[src]
impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedU32<FracSrc>> for FixedI16<FracDst> where
FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U16, Output = FracSrcP>,
FracDst: Unsigned + IsLessOrEqual<U16, Output = True> + Add<<U32 as Add<U1>>::Output, Output = FracDstP>,
FracSrcP: Unsigned,
FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>,
[src]
FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U16, Output = FracSrcP>,
FracDst: Unsigned + IsLessOrEqual<U16, Output = True> + Add<<U32 as Add<U1>>::Output, Output = FracDstP>,
FracSrcP: Unsigned,
FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>,
fn lossy_from(src: FixedU32<FracSrc>) -> FixedI16<FracDst>
[src]
impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedU32<FracSrc>> for FixedU32<FracDst> where
FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U32, Output = FracSrcP>,
FracDst: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U32, Output = FracDstP>,
FracSrcP: Unsigned,
FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>,
[src]
FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U32, Output = FracSrcP>,
FracDst: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U32, Output = FracDstP>,
FracSrcP: Unsigned,
FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>,
fn lossy_from(src: FixedU32<FracSrc>) -> FixedU32<FracDst>
[src]
impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedU32<FracSrc>> for FixedI32<FracDst> where
FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U32, Output = FracSrcP>,
FracDst: Unsigned + IsLessOrEqual<U32, Output = True> + Add<<U32 as Add<U1>>::Output, Output = FracDstP>,
FracSrcP: Unsigned,
FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>,
[src]
FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U32, Output = FracSrcP>,
FracDst: Unsigned + IsLessOrEqual<U32, Output = True> + Add<<U32 as Add<U1>>::Output, Output = FracDstP>,
FracSrcP: Unsigned,
FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>,
fn lossy_from(src: FixedU32<FracSrc>) -> FixedI32<FracDst>
[src]
impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedU32<FracSrc>> for FixedU64<FracDst> where
FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U64, Output = FracSrcP>,
FracDst: Unsigned + IsLessOrEqual<U64, Output = True> + Add<U32, Output = FracDstP>,
FracSrcP: Unsigned,
FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>,
[src]
FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U64, Output = FracSrcP>,
FracDst: Unsigned + IsLessOrEqual<U64, Output = True> + Add<U32, Output = FracDstP>,
FracSrcP: Unsigned,
FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>,
fn lossy_from(src: FixedU32<FracSrc>) -> FixedU64<FracDst>
[src]
impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedU32<FracSrc>> for FixedI64<FracDst> where
FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U64, Output = FracSrcP>,
FracDst: Unsigned + IsLessOrEqual<U64, Output = True> + Add<<U32 as Add<U1>>::Output, Output = FracDstP>,
FracSrcP: Unsigned,
FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>,
[src]
FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U64, Output = FracSrcP>,
FracDst: Unsigned + IsLessOrEqual<U64, Output = True> + Add<<U32 as Add<U1>>::Output, Output = FracDstP>,
FracSrcP: Unsigned,
FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>,
fn lossy_from(src: FixedU32<FracSrc>) -> FixedI64<FracDst>
[src]
impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedU32<FracSrc>> for FixedU128<FracDst> where
FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U128, Output = FracSrcP>,
FracDst: Unsigned + IsLessOrEqual<U128, Output = True> + Add<U32, Output = FracDstP>,
FracSrcP: Unsigned,
FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>,
[src]
FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U128, Output = FracSrcP>,
FracDst: Unsigned + IsLessOrEqual<U128, Output = True> + Add<U32, Output = FracDstP>,
FracSrcP: Unsigned,
FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>,
fn lossy_from(src: FixedU32<FracSrc>) -> FixedU128<FracDst>
[src]
impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedU32<FracSrc>> for FixedI128<FracDst> where
FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U128, Output = FracSrcP>,
FracDst: Unsigned + IsLessOrEqual<U128, Output = True> + Add<<U32 as Add<U1>>::Output, Output = FracDstP>,
FracSrcP: Unsigned,
FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>,
[src]
FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U128, Output = FracSrcP>,
FracDst: Unsigned + IsLessOrEqual<U128, Output = True> + Add<<U32 as Add<U1>>::Output, Output = FracDstP>,
FracSrcP: Unsigned,
FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>,
fn lossy_from(src: FixedU32<FracSrc>) -> FixedI128<FracDst>
[src]
impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedU64<FracSrc>> for FixedU32<FracDst> where
FracSrc: Unsigned + IsLessOrEqual<U64, Output = True> + Add<U32, Output = FracSrcP>,
FracDst: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U64, Output = FracDstP>,
FracSrcP: Unsigned,
FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>,
[src]
FracSrc: Unsigned + IsLessOrEqual<U64, Output = True> + Add<U32, Output = FracSrcP>,
FracDst: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U64, Output = FracDstP>,
FracSrcP: Unsigned,
FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>,
fn lossy_from(src: FixedU64<FracSrc>) -> FixedU32<FracDst>
[src]
impl<FracSrc, FracDst, FracSrcP, FracDstP> LossyFrom<FixedU128<FracSrc>> for FixedU32<FracDst> where
FracSrc: Unsigned + IsLessOrEqual<U128, Output = True> + Add<U32, Output = FracSrcP>,
FracDst: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U128, Output = FracDstP>,
FracSrcP: Unsigned,
FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>,
[src]
FracSrc: Unsigned + IsLessOrEqual<U128, Output = True> + Add<U32, Output = FracSrcP>,
FracDst: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U128, Output = FracDstP>,
FracSrcP: Unsigned,
FracDstP: Unsigned + IsLessOrEqual<FracSrcP, Output = True>,
fn lossy_from(src: FixedU128<FracSrc>) -> FixedU32<FracDst>
[src]
impl<FracDst> LossyFrom<u8> for FixedU32<FracDst> where
FracDst: Unsigned + IsLessOrEqual<U32, Output = True> + IsLessOrEqual<<U32 as Sub<U8>>::Output, Output = True>,
[src]
FracDst: Unsigned + IsLessOrEqual<U32, Output = True> + IsLessOrEqual<<U32 as Sub<U8>>::Output, Output = True>,
fn lossy_from(src: u8) -> FixedU32<FracDst>
[src]
impl<FracDst> LossyFrom<u16> for FixedU32<FracDst> where
FracDst: Unsigned + IsLessOrEqual<U32, Output = True> + IsLessOrEqual<<U32 as Sub<U16>>::Output, Output = True>,
[src]
FracDst: Unsigned + IsLessOrEqual<U32, Output = True> + IsLessOrEqual<<U32 as Sub<U16>>::Output, Output = True>,
fn lossy_from(src: u16) -> FixedU32<FracDst>
[src]
impl LossyFrom<u32> for FixedU32<U0>
[src]
fn lossy_from(src: u32) -> FixedU32<U0>
[src]
impl<FracSrc, FracSrcP> LossyFrom<FixedU32<FracSrc>> for u8 where
FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U8, Output = FracSrcP>,
FracSrcP: Unsigned,
U32: IsLessOrEqual<FracSrcP, Output = True>,
[src]
FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U8, Output = FracSrcP>,
FracSrcP: Unsigned,
U32: IsLessOrEqual<FracSrcP, Output = True>,
fn lossy_from(src: FixedU32<FracSrc>) -> u8
[src]
impl<FracSrc, FracSrcP> LossyFrom<FixedU32<FracSrc>> for i8 where
FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U8, Output = FracSrcP>,
FracSrcP: Unsigned,
<U32 as Add<U1>>::Output: IsLessOrEqual<FracSrcP, Output = True>,
[src]
FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U8, Output = FracSrcP>,
FracSrcP: Unsigned,
<U32 as Add<U1>>::Output: IsLessOrEqual<FracSrcP, Output = True>,
fn lossy_from(src: FixedU32<FracSrc>) -> i8
[src]
impl<FracSrc, FracSrcP> LossyFrom<FixedU32<FracSrc>> for u16 where
FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U16, Output = FracSrcP>,
FracSrcP: Unsigned,
U32: IsLessOrEqual<FracSrcP, Output = True>,
[src]
FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U16, Output = FracSrcP>,
FracSrcP: Unsigned,
U32: IsLessOrEqual<FracSrcP, Output = True>,
fn lossy_from(src: FixedU32<FracSrc>) -> u16
[src]
impl<FracSrc, FracSrcP> LossyFrom<FixedU32<FracSrc>> for i16 where
FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U16, Output = FracSrcP>,
FracSrcP: Unsigned,
<U32 as Add<U1>>::Output: IsLessOrEqual<FracSrcP, Output = True>,
[src]
FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U16, Output = FracSrcP>,
FracSrcP: Unsigned,
<U32 as Add<U1>>::Output: IsLessOrEqual<FracSrcP, Output = True>,
fn lossy_from(src: FixedU32<FracSrc>) -> i16
[src]
impl<FracSrc, FracSrcP> LossyFrom<FixedU32<FracSrc>> for u32 where
FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U32, Output = FracSrcP>,
FracSrcP: Unsigned,
U32: IsLessOrEqual<FracSrcP, Output = True>,
[src]
FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U32, Output = FracSrcP>,
FracSrcP: Unsigned,
U32: IsLessOrEqual<FracSrcP, Output = True>,
fn lossy_from(src: FixedU32<FracSrc>) -> u32
[src]
impl<FracSrc, FracSrcP> LossyFrom<FixedU32<FracSrc>> for i32 where
FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U32, Output = FracSrcP>,
FracSrcP: Unsigned,
<U32 as Add<U1>>::Output: IsLessOrEqual<FracSrcP, Output = True>,
[src]
FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U32, Output = FracSrcP>,
FracSrcP: Unsigned,
<U32 as Add<U1>>::Output: IsLessOrEqual<FracSrcP, Output = True>,
fn lossy_from(src: FixedU32<FracSrc>) -> i32
[src]
impl<FracSrc, FracSrcP> LossyFrom<FixedU32<FracSrc>> for u64 where
FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U64, Output = FracSrcP>,
FracSrcP: Unsigned,
U32: IsLessOrEqual<FracSrcP, Output = True>,
[src]
FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U64, Output = FracSrcP>,
FracSrcP: Unsigned,
U32: IsLessOrEqual<FracSrcP, Output = True>,
fn lossy_from(src: FixedU32<FracSrc>) -> u64
[src]
impl<FracSrc, FracSrcP> LossyFrom<FixedU32<FracSrc>> for i64 where
FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U64, Output = FracSrcP>,
FracSrcP: Unsigned,
<U32 as Add<U1>>::Output: IsLessOrEqual<FracSrcP, Output = True>,
[src]
FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U64, Output = FracSrcP>,
FracSrcP: Unsigned,
<U32 as Add<U1>>::Output: IsLessOrEqual<FracSrcP, Output = True>,
fn lossy_from(src: FixedU32<FracSrc>) -> i64
[src]
impl<FracSrc, FracSrcP> LossyFrom<FixedU32<FracSrc>> for u128 where
FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U128, Output = FracSrcP>,
FracSrcP: Unsigned,
U32: IsLessOrEqual<FracSrcP, Output = True>,
[src]
FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U128, Output = FracSrcP>,
FracSrcP: Unsigned,
U32: IsLessOrEqual<FracSrcP, Output = True>,
fn lossy_from(src: FixedU32<FracSrc>) -> u128
[src]
impl<FracSrc, FracSrcP> LossyFrom<FixedU32<FracSrc>> for i128 where
FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U128, Output = FracSrcP>,
FracSrcP: Unsigned,
<U32 as Add<U1>>::Output: IsLessOrEqual<FracSrcP, Output = True>,
[src]
FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U128, Output = FracSrcP>,
FracSrcP: Unsigned,
<U32 as Add<U1>>::Output: IsLessOrEqual<FracSrcP, Output = True>,
fn lossy_from(src: FixedU32<FracSrc>) -> i128
[src]
impl<FracSrc, FracSrcP> LossyFrom<FixedU32<FracSrc>> for usize where
FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U16, Output = FracSrcP>,
FracSrcP: Unsigned,
U32: IsLessOrEqual<FracSrcP, Output = True>,
[src]
FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U16, Output = FracSrcP>,
FracSrcP: Unsigned,
U32: IsLessOrEqual<FracSrcP, Output = True>,
fn lossy_from(src: FixedU32<FracSrc>) -> usize
[src]
impl<FracSrc, FracSrcP> LossyFrom<FixedU32<FracSrc>> for isize where
FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U16, Output = FracSrcP>,
FracSrcP: Unsigned,
<U32 as Add<U1>>::Output: IsLessOrEqual<FracSrcP, Output = True>,
[src]
FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<U16, Output = FracSrcP>,
FracSrcP: Unsigned,
<U32 as Add<U1>>::Output: IsLessOrEqual<FracSrcP, Output = True>,
fn lossy_from(src: FixedU32<FracSrc>) -> isize
[src]
impl<Frac> LossyFrom<FixedU32<Frac>> for f16 where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn lossy_from(src: FixedU32<Frac>) -> f16
[src]
impl<Frac> LossyFrom<FixedU32<Frac>> for f32 where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn lossy_from(src: FixedU32<Frac>) -> f32
[src]
impl<Frac> LossyFrom<FixedU32<Frac>> for f64 where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn lossy_from(src: FixedU32<Frac>) -> f64
[src]
impl<Frac> FromFixed for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn from_fixed<F: Fixed>(val: F) -> Self
[src]
fn checked_from_fixed<F: Fixed>(val: F) -> Option<Self>
[src]
fn saturating_from_fixed<F: Fixed>(val: F) -> Self
[src]
fn wrapping_from_fixed<F: Fixed>(val: F) -> Self
[src]
fn overflowing_from_fixed<F: Fixed>(val: F) -> (Self, bool)
[src]
impl<Frac> ToFixed for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn to_fixed<F: Fixed>(self) -> F
[src]
fn checked_to_fixed<F: Fixed>(self) -> Option<F>
[src]
fn saturating_to_fixed<F: Fixed>(self) -> F
[src]
fn wrapping_to_fixed<F: Fixed>(self) -> F
[src]
fn overflowing_to_fixed<F: Fixed>(self) -> (F, bool)
[src]
impl<Frac> FixedOptionalFeatures for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
impl<Frac> Debug for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
impl<Frac> Display for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
impl<FracLhs, FracRhs> PartialEq<FixedU32<FracRhs>> for FixedI8<FracLhs> where
FracLhs: Unsigned + IsLessOrEqual<U8, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
FracLhs: Unsigned + IsLessOrEqual<U8, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U32, Output = True>,
fn eq(&self, rhs: &FixedU32<FracRhs>) -> bool
[src]
#[must_use]
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl<FracLhs, FracRhs> PartialEq<FixedU32<FracRhs>> for FixedI16<FracLhs> where
FracLhs: Unsigned + IsLessOrEqual<U16, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
FracLhs: Unsigned + IsLessOrEqual<U16, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U32, Output = True>,
fn eq(&self, rhs: &FixedU32<FracRhs>) -> bool
[src]
#[must_use]
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl<FracLhs, FracRhs> PartialEq<FixedU32<FracRhs>> for FixedI32<FracLhs> where
FracLhs: Unsigned + IsLessOrEqual<U32, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
FracLhs: Unsigned + IsLessOrEqual<U32, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U32, Output = True>,
fn eq(&self, rhs: &FixedU32<FracRhs>) -> bool
[src]
#[must_use]
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl<FracLhs, FracRhs> PartialEq<FixedU32<FracRhs>> for FixedI64<FracLhs> where
FracLhs: Unsigned + IsLessOrEqual<U64, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
FracLhs: Unsigned + IsLessOrEqual<U64, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U32, Output = True>,
fn eq(&self, rhs: &FixedU32<FracRhs>) -> bool
[src]
#[must_use]
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl<FracLhs, FracRhs> PartialEq<FixedU32<FracRhs>> for FixedI128<FracLhs> where
FracLhs: Unsigned + IsLessOrEqual<U128, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
FracLhs: Unsigned + IsLessOrEqual<U128, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U32, Output = True>,
fn eq(&self, rhs: &FixedU32<FracRhs>) -> bool
[src]
#[must_use]
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl<FracLhs, FracRhs> PartialEq<FixedU32<FracRhs>> for FixedU8<FracLhs> where
FracLhs: Unsigned + IsLessOrEqual<U8, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
FracLhs: Unsigned + IsLessOrEqual<U8, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U32, Output = True>,
fn eq(&self, rhs: &FixedU32<FracRhs>) -> bool
[src]
#[must_use]
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl<FracLhs, FracRhs> PartialEq<FixedU32<FracRhs>> for FixedU16<FracLhs> where
FracLhs: Unsigned + IsLessOrEqual<U16, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
FracLhs: Unsigned + IsLessOrEqual<U16, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U32, Output = True>,
fn eq(&self, rhs: &FixedU32<FracRhs>) -> bool
[src]
#[must_use]
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl<FracLhs, FracRhs> PartialEq<FixedI8<FracRhs>> for FixedU32<FracLhs> where
FracLhs: Unsigned + IsLessOrEqual<U32, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U8, Output = True>,
[src]
FracLhs: Unsigned + IsLessOrEqual<U32, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U8, Output = True>,
fn eq(&self, rhs: &FixedI8<FracRhs>) -> bool
[src]
#[must_use]
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl<FracLhs, FracRhs> PartialEq<FixedI16<FracRhs>> for FixedU32<FracLhs> where
FracLhs: Unsigned + IsLessOrEqual<U32, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U16, Output = True>,
[src]
FracLhs: Unsigned + IsLessOrEqual<U32, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U16, Output = True>,
fn eq(&self, rhs: &FixedI16<FracRhs>) -> bool
[src]
#[must_use]
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl<FracLhs, FracRhs> PartialEq<FixedI32<FracRhs>> for FixedU32<FracLhs> where
FracLhs: Unsigned + IsLessOrEqual<U32, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
FracLhs: Unsigned + IsLessOrEqual<U32, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U32, Output = True>,
fn eq(&self, rhs: &FixedI32<FracRhs>) -> bool
[src]
#[must_use]
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl<FracLhs, FracRhs> PartialEq<FixedI64<FracRhs>> for FixedU32<FracLhs> where
FracLhs: Unsigned + IsLessOrEqual<U32, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U64, Output = True>,
[src]
FracLhs: Unsigned + IsLessOrEqual<U32, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U64, Output = True>,
fn eq(&self, rhs: &FixedI64<FracRhs>) -> bool
[src]
#[must_use]
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl<FracLhs, FracRhs> PartialEq<FixedI128<FracRhs>> for FixedU32<FracLhs> where
FracLhs: Unsigned + IsLessOrEqual<U32, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U128, Output = True>,
[src]
FracLhs: Unsigned + IsLessOrEqual<U32, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U128, Output = True>,
fn eq(&self, rhs: &FixedI128<FracRhs>) -> bool
[src]
#[must_use]
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl<FracLhs, FracRhs> PartialEq<FixedU8<FracRhs>> for FixedU32<FracLhs> where
FracLhs: Unsigned + IsLessOrEqual<U32, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U8, Output = True>,
[src]
FracLhs: Unsigned + IsLessOrEqual<U32, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U8, Output = True>,
fn eq(&self, rhs: &FixedU8<FracRhs>) -> bool
[src]
#[must_use]
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl<FracLhs, FracRhs> PartialEq<FixedU16<FracRhs>> for FixedU32<FracLhs> where
FracLhs: Unsigned + IsLessOrEqual<U32, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U16, Output = True>,
[src]
FracLhs: Unsigned + IsLessOrEqual<U32, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U16, Output = True>,
fn eq(&self, rhs: &FixedU16<FracRhs>) -> bool
[src]
#[must_use]
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl<FracLhs, FracRhs> PartialEq<FixedU32<FracRhs>> for FixedU32<FracLhs> where
FracLhs: Unsigned + IsLessOrEqual<U32, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
FracLhs: Unsigned + IsLessOrEqual<U32, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U32, Output = True>,
fn eq(&self, rhs: &FixedU32<FracRhs>) -> bool
[src]
#[must_use]
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl<FracLhs, FracRhs> PartialEq<FixedU64<FracRhs>> for FixedU32<FracLhs> where
FracLhs: Unsigned + IsLessOrEqual<U32, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U64, Output = True>,
[src]
FracLhs: Unsigned + IsLessOrEqual<U32, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U64, Output = True>,
fn eq(&self, rhs: &FixedU64<FracRhs>) -> bool
[src]
#[must_use]
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl<FracLhs, FracRhs> PartialEq<FixedU128<FracRhs>> for FixedU32<FracLhs> where
FracLhs: Unsigned + IsLessOrEqual<U32, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U128, Output = True>,
[src]
FracLhs: Unsigned + IsLessOrEqual<U32, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U128, Output = True>,
fn eq(&self, rhs: &FixedU128<FracRhs>) -> bool
[src]
#[must_use]
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl<Frac> PartialEq<i8> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn eq(&self, rhs: &i8) -> bool
[src]
#[must_use]
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl<Frac> PartialEq<FixedU32<Frac>> for i8 where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn eq(&self, rhs: &FixedU32<Frac>) -> bool
[src]
#[must_use]
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl<Frac> PartialEq<i16> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn eq(&self, rhs: &i16) -> bool
[src]
#[must_use]
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl<Frac> PartialEq<FixedU32<Frac>> for i16 where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn eq(&self, rhs: &FixedU32<Frac>) -> bool
[src]
#[must_use]
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl<Frac> PartialEq<i32> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn eq(&self, rhs: &i32) -> bool
[src]
#[must_use]
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl<Frac> PartialEq<FixedU32<Frac>> for i32 where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn eq(&self, rhs: &FixedU32<Frac>) -> bool
[src]
#[must_use]
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl<Frac> PartialEq<i64> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn eq(&self, rhs: &i64) -> bool
[src]
#[must_use]
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl<Frac> PartialEq<FixedU32<Frac>> for i64 where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn eq(&self, rhs: &FixedU32<Frac>) -> bool
[src]
#[must_use]
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl<Frac> PartialEq<i128> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn eq(&self, rhs: &i128) -> bool
[src]
#[must_use]
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl<Frac> PartialEq<FixedU32<Frac>> for i128 where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn eq(&self, rhs: &FixedU32<Frac>) -> bool
[src]
#[must_use]
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl<Frac> PartialEq<isize> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn eq(&self, rhs: &isize) -> bool
[src]
#[must_use]
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl<Frac> PartialEq<FixedU32<Frac>> for isize where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn eq(&self, rhs: &FixedU32<Frac>) -> bool
[src]
#[must_use]
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl<Frac> PartialEq<u8> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn eq(&self, rhs: &u8) -> bool
[src]
#[must_use]
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl<Frac> PartialEq<FixedU32<Frac>> for u8 where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn eq(&self, rhs: &FixedU32<Frac>) -> bool
[src]
#[must_use]
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl<Frac> PartialEq<u16> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn eq(&self, rhs: &u16) -> bool
[src]
#[must_use]
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl<Frac> PartialEq<FixedU32<Frac>> for u16 where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn eq(&self, rhs: &FixedU32<Frac>) -> bool
[src]
#[must_use]
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl<Frac> PartialEq<u32> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn eq(&self, rhs: &u32) -> bool
[src]
#[must_use]
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl<Frac> PartialEq<FixedU32<Frac>> for u32 where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn eq(&self, rhs: &FixedU32<Frac>) -> bool
[src]
#[must_use]
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl<Frac> PartialEq<u64> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn eq(&self, rhs: &u64) -> bool
[src]
#[must_use]
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl<Frac> PartialEq<FixedU32<Frac>> for u64 where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn eq(&self, rhs: &FixedU32<Frac>) -> bool
[src]
#[must_use]
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl<Frac> PartialEq<u128> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn eq(&self, rhs: &u128) -> bool
[src]
#[must_use]
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl<Frac> PartialEq<FixedU32<Frac>> for u128 where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn eq(&self, rhs: &FixedU32<Frac>) -> bool
[src]
#[must_use]
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl<Frac> PartialEq<usize> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn eq(&self, rhs: &usize) -> bool
[src]
#[must_use]
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl<Frac> PartialEq<FixedU32<Frac>> for usize where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn eq(&self, rhs: &FixedU32<Frac>) -> bool
[src]
#[must_use]
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl<Frac> PartialEq<f16> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn eq(&self, rhs: &f16) -> bool
[src]
#[must_use]
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl<Frac> PartialEq<FixedU32<Frac>> for f16 where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn eq(&self, rhs: &FixedU32<Frac>) -> bool
[src]
#[must_use]
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl<Frac> PartialEq<f32> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn eq(&self, rhs: &f32) -> bool
[src]
#[must_use]
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl<Frac> PartialEq<FixedU32<Frac>> for f32 where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn eq(&self, rhs: &FixedU32<Frac>) -> bool
[src]
#[must_use]
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl<Frac> PartialEq<f64> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn eq(&self, rhs: &f64) -> bool
[src]
#[must_use]
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl<Frac> PartialEq<FixedU32<Frac>> for f64 where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn eq(&self, rhs: &FixedU32<Frac>) -> bool
[src]
#[must_use]
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl<FracLhs, FracRhs> PartialEq<FixedU32<FracRhs>> for FixedU64<FracLhs> where
FracLhs: Unsigned + IsLessOrEqual<U64, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
FracLhs: Unsigned + IsLessOrEqual<U64, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U32, Output = True>,
fn eq(&self, rhs: &FixedU32<FracRhs>) -> bool
[src]
#[must_use]
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl<FracLhs, FracRhs> PartialEq<FixedU32<FracRhs>> for FixedU128<FracLhs> where
FracLhs: Unsigned + IsLessOrEqual<U128, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
FracLhs: Unsigned + IsLessOrEqual<U128, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U32, Output = True>,
fn eq(&self, rhs: &FixedU32<FracRhs>) -> bool
[src]
#[must_use]
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl<Frac> Eq for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
impl<Frac> Ord for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn cmp(&self, rhs: &FixedU32<Frac>) -> Ordering
[src]
fn max(self, other: Self) -> Self
1.21.0[src]
Compares and returns the maximum of two values. Read more
fn min(self, other: Self) -> Self
1.21.0[src]
Compares and returns the minimum of two values. Read more
fn clamp(self, min: Self, max: Self) -> Self
[src]
clamp
)Restrict a value to a certain interval. Read more
impl<FracLhs, FracRhs> PartialOrd<FixedU32<FracRhs>> for FixedI8<FracLhs> where
FracLhs: Unsigned + IsLessOrEqual<U8, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
FracLhs: Unsigned + IsLessOrEqual<U8, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U32, Output = True>,
fn partial_cmp(&self, rhs: &FixedU32<FracRhs>) -> Option<Ordering>
[src]
fn lt(&self, rhs: &FixedU32<FracRhs>) -> bool
[src]
fn le(&self, rhs: &FixedU32<FracRhs>) -> bool
[src]
fn gt(&self, rhs: &FixedU32<FracRhs>) -> bool
[src]
fn ge(&self, rhs: &FixedU32<FracRhs>) -> bool
[src]
impl<FracLhs, FracRhs> PartialOrd<FixedU32<FracRhs>> for FixedI16<FracLhs> where
FracLhs: Unsigned + IsLessOrEqual<U16, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
FracLhs: Unsigned + IsLessOrEqual<U16, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U32, Output = True>,
fn partial_cmp(&self, rhs: &FixedU32<FracRhs>) -> Option<Ordering>
[src]
fn lt(&self, rhs: &FixedU32<FracRhs>) -> bool
[src]
fn le(&self, rhs: &FixedU32<FracRhs>) -> bool
[src]
fn gt(&self, rhs: &FixedU32<FracRhs>) -> bool
[src]
fn ge(&self, rhs: &FixedU32<FracRhs>) -> bool
[src]
impl<FracLhs, FracRhs> PartialOrd<FixedU32<FracRhs>> for FixedI32<FracLhs> where
FracLhs: Unsigned + IsLessOrEqual<U32, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
FracLhs: Unsigned + IsLessOrEqual<U32, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U32, Output = True>,
fn partial_cmp(&self, rhs: &FixedU32<FracRhs>) -> Option<Ordering>
[src]
fn lt(&self, rhs: &FixedU32<FracRhs>) -> bool
[src]
fn le(&self, rhs: &FixedU32<FracRhs>) -> bool
[src]
fn gt(&self, rhs: &FixedU32<FracRhs>) -> bool
[src]
fn ge(&self, rhs: &FixedU32<FracRhs>) -> bool
[src]
impl<FracLhs, FracRhs> PartialOrd<FixedU32<FracRhs>> for FixedI64<FracLhs> where
FracLhs: Unsigned + IsLessOrEqual<U64, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
FracLhs: Unsigned + IsLessOrEqual<U64, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U32, Output = True>,
fn partial_cmp(&self, rhs: &FixedU32<FracRhs>) -> Option<Ordering>
[src]
fn lt(&self, rhs: &FixedU32<FracRhs>) -> bool
[src]
fn le(&self, rhs: &FixedU32<FracRhs>) -> bool
[src]
fn gt(&self, rhs: &FixedU32<FracRhs>) -> bool
[src]
fn ge(&self, rhs: &FixedU32<FracRhs>) -> bool
[src]
impl<FracLhs, FracRhs> PartialOrd<FixedU32<FracRhs>> for FixedI128<FracLhs> where
FracLhs: Unsigned + IsLessOrEqual<U128, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
FracLhs: Unsigned + IsLessOrEqual<U128, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U32, Output = True>,
fn partial_cmp(&self, rhs: &FixedU32<FracRhs>) -> Option<Ordering>
[src]
fn lt(&self, rhs: &FixedU32<FracRhs>) -> bool
[src]
fn le(&self, rhs: &FixedU32<FracRhs>) -> bool
[src]
fn gt(&self, rhs: &FixedU32<FracRhs>) -> bool
[src]
fn ge(&self, rhs: &FixedU32<FracRhs>) -> bool
[src]
impl<FracLhs, FracRhs> PartialOrd<FixedU32<FracRhs>> for FixedU8<FracLhs> where
FracLhs: Unsigned + IsLessOrEqual<U8, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
FracLhs: Unsigned + IsLessOrEqual<U8, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U32, Output = True>,
fn partial_cmp(&self, rhs: &FixedU32<FracRhs>) -> Option<Ordering>
[src]
fn lt(&self, rhs: &FixedU32<FracRhs>) -> bool
[src]
fn le(&self, rhs: &FixedU32<FracRhs>) -> bool
[src]
fn gt(&self, rhs: &FixedU32<FracRhs>) -> bool
[src]
fn ge(&self, rhs: &FixedU32<FracRhs>) -> bool
[src]
impl<FracLhs, FracRhs> PartialOrd<FixedU32<FracRhs>> for FixedU16<FracLhs> where
FracLhs: Unsigned + IsLessOrEqual<U16, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
FracLhs: Unsigned + IsLessOrEqual<U16, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U32, Output = True>,
fn partial_cmp(&self, rhs: &FixedU32<FracRhs>) -> Option<Ordering>
[src]
fn lt(&self, rhs: &FixedU32<FracRhs>) -> bool
[src]
fn le(&self, rhs: &FixedU32<FracRhs>) -> bool
[src]
fn gt(&self, rhs: &FixedU32<FracRhs>) -> bool
[src]
fn ge(&self, rhs: &FixedU32<FracRhs>) -> bool
[src]
impl<FracLhs, FracRhs> PartialOrd<FixedI8<FracRhs>> for FixedU32<FracLhs> where
FracLhs: Unsigned + IsLessOrEqual<U32, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U8, Output = True>,
[src]
FracLhs: Unsigned + IsLessOrEqual<U32, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U8, Output = True>,
fn partial_cmp(&self, rhs: &FixedI8<FracRhs>) -> Option<Ordering>
[src]
fn lt(&self, rhs: &FixedI8<FracRhs>) -> bool
[src]
fn le(&self, rhs: &FixedI8<FracRhs>) -> bool
[src]
fn gt(&self, rhs: &FixedI8<FracRhs>) -> bool
[src]
fn ge(&self, rhs: &FixedI8<FracRhs>) -> bool
[src]
impl<FracLhs, FracRhs> PartialOrd<FixedI16<FracRhs>> for FixedU32<FracLhs> where
FracLhs: Unsigned + IsLessOrEqual<U32, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U16, Output = True>,
[src]
FracLhs: Unsigned + IsLessOrEqual<U32, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U16, Output = True>,
fn partial_cmp(&self, rhs: &FixedI16<FracRhs>) -> Option<Ordering>
[src]
fn lt(&self, rhs: &FixedI16<FracRhs>) -> bool
[src]
fn le(&self, rhs: &FixedI16<FracRhs>) -> bool
[src]
fn gt(&self, rhs: &FixedI16<FracRhs>) -> bool
[src]
fn ge(&self, rhs: &FixedI16<FracRhs>) -> bool
[src]
impl<FracLhs, FracRhs> PartialOrd<FixedI32<FracRhs>> for FixedU32<FracLhs> where
FracLhs: Unsigned + IsLessOrEqual<U32, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
FracLhs: Unsigned + IsLessOrEqual<U32, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U32, Output = True>,
fn partial_cmp(&self, rhs: &FixedI32<FracRhs>) -> Option<Ordering>
[src]
fn lt(&self, rhs: &FixedI32<FracRhs>) -> bool
[src]
fn le(&self, rhs: &FixedI32<FracRhs>) -> bool
[src]
fn gt(&self, rhs: &FixedI32<FracRhs>) -> bool
[src]
fn ge(&self, rhs: &FixedI32<FracRhs>) -> bool
[src]
impl<FracLhs, FracRhs> PartialOrd<FixedI64<FracRhs>> for FixedU32<FracLhs> where
FracLhs: Unsigned + IsLessOrEqual<U32, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U64, Output = True>,
[src]
FracLhs: Unsigned + IsLessOrEqual<U32, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U64, Output = True>,
fn partial_cmp(&self, rhs: &FixedI64<FracRhs>) -> Option<Ordering>
[src]
fn lt(&self, rhs: &FixedI64<FracRhs>) -> bool
[src]
fn le(&self, rhs: &FixedI64<FracRhs>) -> bool
[src]
fn gt(&self, rhs: &FixedI64<FracRhs>) -> bool
[src]
fn ge(&self, rhs: &FixedI64<FracRhs>) -> bool
[src]
impl<FracLhs, FracRhs> PartialOrd<FixedI128<FracRhs>> for FixedU32<FracLhs> where
FracLhs: Unsigned + IsLessOrEqual<U32, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U128, Output = True>,
[src]
FracLhs: Unsigned + IsLessOrEqual<U32, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U128, Output = True>,
fn partial_cmp(&self, rhs: &FixedI128<FracRhs>) -> Option<Ordering>
[src]
fn lt(&self, rhs: &FixedI128<FracRhs>) -> bool
[src]
fn le(&self, rhs: &FixedI128<FracRhs>) -> bool
[src]
fn gt(&self, rhs: &FixedI128<FracRhs>) -> bool
[src]
fn ge(&self, rhs: &FixedI128<FracRhs>) -> bool
[src]
impl<FracLhs, FracRhs> PartialOrd<FixedU8<FracRhs>> for FixedU32<FracLhs> where
FracLhs: Unsigned + IsLessOrEqual<U32, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U8, Output = True>,
[src]
FracLhs: Unsigned + IsLessOrEqual<U32, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U8, Output = True>,
fn partial_cmp(&self, rhs: &FixedU8<FracRhs>) -> Option<Ordering>
[src]
fn lt(&self, rhs: &FixedU8<FracRhs>) -> bool
[src]
fn le(&self, rhs: &FixedU8<FracRhs>) -> bool
[src]
fn gt(&self, rhs: &FixedU8<FracRhs>) -> bool
[src]
fn ge(&self, rhs: &FixedU8<FracRhs>) -> bool
[src]
impl<FracLhs, FracRhs> PartialOrd<FixedU16<FracRhs>> for FixedU32<FracLhs> where
FracLhs: Unsigned + IsLessOrEqual<U32, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U16, Output = True>,
[src]
FracLhs: Unsigned + IsLessOrEqual<U32, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U16, Output = True>,
fn partial_cmp(&self, rhs: &FixedU16<FracRhs>) -> Option<Ordering>
[src]
fn lt(&self, rhs: &FixedU16<FracRhs>) -> bool
[src]
fn le(&self, rhs: &FixedU16<FracRhs>) -> bool
[src]
fn gt(&self, rhs: &FixedU16<FracRhs>) -> bool
[src]
fn ge(&self, rhs: &FixedU16<FracRhs>) -> bool
[src]
impl<FracLhs, FracRhs> PartialOrd<FixedU32<FracRhs>> for FixedU32<FracLhs> where
FracLhs: Unsigned + IsLessOrEqual<U32, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
FracLhs: Unsigned + IsLessOrEqual<U32, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U32, Output = True>,
fn partial_cmp(&self, rhs: &FixedU32<FracRhs>) -> Option<Ordering>
[src]
fn lt(&self, rhs: &FixedU32<FracRhs>) -> bool
[src]
fn le(&self, rhs: &FixedU32<FracRhs>) -> bool
[src]
fn gt(&self, rhs: &FixedU32<FracRhs>) -> bool
[src]
fn ge(&self, rhs: &FixedU32<FracRhs>) -> bool
[src]
impl<FracLhs, FracRhs> PartialOrd<FixedU64<FracRhs>> for FixedU32<FracLhs> where
FracLhs: Unsigned + IsLessOrEqual<U32, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U64, Output = True>,
[src]
FracLhs: Unsigned + IsLessOrEqual<U32, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U64, Output = True>,
fn partial_cmp(&self, rhs: &FixedU64<FracRhs>) -> Option<Ordering>
[src]
fn lt(&self, rhs: &FixedU64<FracRhs>) -> bool
[src]
fn le(&self, rhs: &FixedU64<FracRhs>) -> bool
[src]
fn gt(&self, rhs: &FixedU64<FracRhs>) -> bool
[src]
fn ge(&self, rhs: &FixedU64<FracRhs>) -> bool
[src]
impl<FracLhs, FracRhs> PartialOrd<FixedU128<FracRhs>> for FixedU32<FracLhs> where
FracLhs: Unsigned + IsLessOrEqual<U32, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U128, Output = True>,
[src]
FracLhs: Unsigned + IsLessOrEqual<U32, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U128, Output = True>,
fn partial_cmp(&self, rhs: &FixedU128<FracRhs>) -> Option<Ordering>
[src]
fn lt(&self, rhs: &FixedU128<FracRhs>) -> bool
[src]
fn le(&self, rhs: &FixedU128<FracRhs>) -> bool
[src]
fn gt(&self, rhs: &FixedU128<FracRhs>) -> bool
[src]
fn ge(&self, rhs: &FixedU128<FracRhs>) -> bool
[src]
impl<Frac> PartialOrd<i8> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn partial_cmp(&self, rhs: &i8) -> Option<Ordering>
[src]
fn lt(&self, rhs: &i8) -> bool
[src]
fn le(&self, rhs: &i8) -> bool
[src]
fn gt(&self, rhs: &i8) -> bool
[src]
fn ge(&self, rhs: &i8) -> bool
[src]
impl<Frac> PartialOrd<FixedU32<Frac>> for i8 where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn partial_cmp(&self, rhs: &FixedU32<Frac>) -> Option<Ordering>
[src]
fn lt(&self, rhs: &FixedU32<Frac>) -> bool
[src]
fn le(&self, rhs: &FixedU32<Frac>) -> bool
[src]
fn gt(&self, rhs: &FixedU32<Frac>) -> bool
[src]
fn ge(&self, rhs: &FixedU32<Frac>) -> bool
[src]
impl<Frac> PartialOrd<i16> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn partial_cmp(&self, rhs: &i16) -> Option<Ordering>
[src]
fn lt(&self, rhs: &i16) -> bool
[src]
fn le(&self, rhs: &i16) -> bool
[src]
fn gt(&self, rhs: &i16) -> bool
[src]
fn ge(&self, rhs: &i16) -> bool
[src]
impl<Frac> PartialOrd<FixedU32<Frac>> for i16 where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn partial_cmp(&self, rhs: &FixedU32<Frac>) -> Option<Ordering>
[src]
fn lt(&self, rhs: &FixedU32<Frac>) -> bool
[src]
fn le(&self, rhs: &FixedU32<Frac>) -> bool
[src]
fn gt(&self, rhs: &FixedU32<Frac>) -> bool
[src]
fn ge(&self, rhs: &FixedU32<Frac>) -> bool
[src]
impl<Frac> PartialOrd<i32> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn partial_cmp(&self, rhs: &i32) -> Option<Ordering>
[src]
fn lt(&self, rhs: &i32) -> bool
[src]
fn le(&self, rhs: &i32) -> bool
[src]
fn gt(&self, rhs: &i32) -> bool
[src]
fn ge(&self, rhs: &i32) -> bool
[src]
impl<Frac> PartialOrd<FixedU32<Frac>> for i32 where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn partial_cmp(&self, rhs: &FixedU32<Frac>) -> Option<Ordering>
[src]
fn lt(&self, rhs: &FixedU32<Frac>) -> bool
[src]
fn le(&self, rhs: &FixedU32<Frac>) -> bool
[src]
fn gt(&self, rhs: &FixedU32<Frac>) -> bool
[src]
fn ge(&self, rhs: &FixedU32<Frac>) -> bool
[src]
impl<Frac> PartialOrd<i64> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn partial_cmp(&self, rhs: &i64) -> Option<Ordering>
[src]
fn lt(&self, rhs: &i64) -> bool
[src]
fn le(&self, rhs: &i64) -> bool
[src]
fn gt(&self, rhs: &i64) -> bool
[src]
fn ge(&self, rhs: &i64) -> bool
[src]
impl<Frac> PartialOrd<FixedU32<Frac>> for i64 where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn partial_cmp(&self, rhs: &FixedU32<Frac>) -> Option<Ordering>
[src]
fn lt(&self, rhs: &FixedU32<Frac>) -> bool
[src]
fn le(&self, rhs: &FixedU32<Frac>) -> bool
[src]
fn gt(&self, rhs: &FixedU32<Frac>) -> bool
[src]
fn ge(&self, rhs: &FixedU32<Frac>) -> bool
[src]
impl<Frac> PartialOrd<i128> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn partial_cmp(&self, rhs: &i128) -> Option<Ordering>
[src]
fn lt(&self, rhs: &i128) -> bool
[src]
fn le(&self, rhs: &i128) -> bool
[src]
fn gt(&self, rhs: &i128) -> bool
[src]
fn ge(&self, rhs: &i128) -> bool
[src]
impl<Frac> PartialOrd<FixedU32<Frac>> for i128 where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn partial_cmp(&self, rhs: &FixedU32<Frac>) -> Option<Ordering>
[src]
fn lt(&self, rhs: &FixedU32<Frac>) -> bool
[src]
fn le(&self, rhs: &FixedU32<Frac>) -> bool
[src]
fn gt(&self, rhs: &FixedU32<Frac>) -> bool
[src]
fn ge(&self, rhs: &FixedU32<Frac>) -> bool
[src]
impl<Frac> PartialOrd<isize> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn partial_cmp(&self, rhs: &isize) -> Option<Ordering>
[src]
fn lt(&self, rhs: &isize) -> bool
[src]
fn le(&self, rhs: &isize) -> bool
[src]
fn gt(&self, rhs: &isize) -> bool
[src]
fn ge(&self, rhs: &isize) -> bool
[src]
impl<Frac> PartialOrd<FixedU32<Frac>> for isize where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn partial_cmp(&self, rhs: &FixedU32<Frac>) -> Option<Ordering>
[src]
fn lt(&self, rhs: &FixedU32<Frac>) -> bool
[src]
fn le(&self, rhs: &FixedU32<Frac>) -> bool
[src]
fn gt(&self, rhs: &FixedU32<Frac>) -> bool
[src]
fn ge(&self, rhs: &FixedU32<Frac>) -> bool
[src]
impl<Frac> PartialOrd<u8> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn partial_cmp(&self, rhs: &u8) -> Option<Ordering>
[src]
fn lt(&self, rhs: &u8) -> bool
[src]
fn le(&self, rhs: &u8) -> bool
[src]
fn gt(&self, rhs: &u8) -> bool
[src]
fn ge(&self, rhs: &u8) -> bool
[src]
impl<Frac> PartialOrd<FixedU32<Frac>> for u8 where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn partial_cmp(&self, rhs: &FixedU32<Frac>) -> Option<Ordering>
[src]
fn lt(&self, rhs: &FixedU32<Frac>) -> bool
[src]
fn le(&self, rhs: &FixedU32<Frac>) -> bool
[src]
fn gt(&self, rhs: &FixedU32<Frac>) -> bool
[src]
fn ge(&self, rhs: &FixedU32<Frac>) -> bool
[src]
impl<Frac> PartialOrd<u16> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn partial_cmp(&self, rhs: &u16) -> Option<Ordering>
[src]
fn lt(&self, rhs: &u16) -> bool
[src]
fn le(&self, rhs: &u16) -> bool
[src]
fn gt(&self, rhs: &u16) -> bool
[src]
fn ge(&self, rhs: &u16) -> bool
[src]
impl<Frac> PartialOrd<FixedU32<Frac>> for u16 where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn partial_cmp(&self, rhs: &FixedU32<Frac>) -> Option<Ordering>
[src]
fn lt(&self, rhs: &FixedU32<Frac>) -> bool
[src]
fn le(&self, rhs: &FixedU32<Frac>) -> bool
[src]
fn gt(&self, rhs: &FixedU32<Frac>) -> bool
[src]
fn ge(&self, rhs: &FixedU32<Frac>) -> bool
[src]
impl<Frac> PartialOrd<u32> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn partial_cmp(&self, rhs: &u32) -> Option<Ordering>
[src]
fn lt(&self, rhs: &u32) -> bool
[src]
fn le(&self, rhs: &u32) -> bool
[src]
fn gt(&self, rhs: &u32) -> bool
[src]
fn ge(&self, rhs: &u32) -> bool
[src]
impl<Frac> PartialOrd<FixedU32<Frac>> for u32 where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn partial_cmp(&self, rhs: &FixedU32<Frac>) -> Option<Ordering>
[src]
fn lt(&self, rhs: &FixedU32<Frac>) -> bool
[src]
fn le(&self, rhs: &FixedU32<Frac>) -> bool
[src]
fn gt(&self, rhs: &FixedU32<Frac>) -> bool
[src]
fn ge(&self, rhs: &FixedU32<Frac>) -> bool
[src]
impl<Frac> PartialOrd<u64> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn partial_cmp(&self, rhs: &u64) -> Option<Ordering>
[src]
fn lt(&self, rhs: &u64) -> bool
[src]
fn le(&self, rhs: &u64) -> bool
[src]
fn gt(&self, rhs: &u64) -> bool
[src]
fn ge(&self, rhs: &u64) -> bool
[src]
impl<Frac> PartialOrd<FixedU32<Frac>> for u64 where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn partial_cmp(&self, rhs: &FixedU32<Frac>) -> Option<Ordering>
[src]
fn lt(&self, rhs: &FixedU32<Frac>) -> bool
[src]
fn le(&self, rhs: &FixedU32<Frac>) -> bool
[src]
fn gt(&self, rhs: &FixedU32<Frac>) -> bool
[src]
fn ge(&self, rhs: &FixedU32<Frac>) -> bool
[src]
impl<Frac> PartialOrd<u128> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn partial_cmp(&self, rhs: &u128) -> Option<Ordering>
[src]
fn lt(&self, rhs: &u128) -> bool
[src]
fn le(&self, rhs: &u128) -> bool
[src]
fn gt(&self, rhs: &u128) -> bool
[src]
fn ge(&self, rhs: &u128) -> bool
[src]
impl<Frac> PartialOrd<FixedU32<Frac>> for u128 where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn partial_cmp(&self, rhs: &FixedU32<Frac>) -> Option<Ordering>
[src]
fn lt(&self, rhs: &FixedU32<Frac>) -> bool
[src]
fn le(&self, rhs: &FixedU32<Frac>) -> bool
[src]
fn gt(&self, rhs: &FixedU32<Frac>) -> bool
[src]
fn ge(&self, rhs: &FixedU32<Frac>) -> bool
[src]
impl<Frac> PartialOrd<usize> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn partial_cmp(&self, rhs: &usize) -> Option<Ordering>
[src]
fn lt(&self, rhs: &usize) -> bool
[src]
fn le(&self, rhs: &usize) -> bool
[src]
fn gt(&self, rhs: &usize) -> bool
[src]
fn ge(&self, rhs: &usize) -> bool
[src]
impl<Frac> PartialOrd<FixedU32<Frac>> for usize where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn partial_cmp(&self, rhs: &FixedU32<Frac>) -> Option<Ordering>
[src]
fn lt(&self, rhs: &FixedU32<Frac>) -> bool
[src]
fn le(&self, rhs: &FixedU32<Frac>) -> bool
[src]
fn gt(&self, rhs: &FixedU32<Frac>) -> bool
[src]
fn ge(&self, rhs: &FixedU32<Frac>) -> bool
[src]
impl<Frac> PartialOrd<f16> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn partial_cmp(&self, rhs: &f16) -> Option<Ordering>
[src]
fn lt(&self, rhs: &f16) -> bool
[src]
fn le(&self, rhs: &f16) -> bool
[src]
fn gt(&self, rhs: &f16) -> bool
[src]
fn ge(&self, rhs: &f16) -> bool
[src]
impl<Frac> PartialOrd<FixedU32<Frac>> for f16 where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn partial_cmp(&self, rhs: &FixedU32<Frac>) -> Option<Ordering>
[src]
fn lt(&self, rhs: &FixedU32<Frac>) -> bool
[src]
fn le(&self, rhs: &FixedU32<Frac>) -> bool
[src]
fn gt(&self, rhs: &FixedU32<Frac>) -> bool
[src]
fn ge(&self, rhs: &FixedU32<Frac>) -> bool
[src]
impl<Frac> PartialOrd<f32> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn partial_cmp(&self, rhs: &f32) -> Option<Ordering>
[src]
fn lt(&self, rhs: &f32) -> bool
[src]
fn le(&self, rhs: &f32) -> bool
[src]
fn gt(&self, rhs: &f32) -> bool
[src]
fn ge(&self, rhs: &f32) -> bool
[src]
impl<Frac> PartialOrd<FixedU32<Frac>> for f32 where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn partial_cmp(&self, rhs: &FixedU32<Frac>) -> Option<Ordering>
[src]
fn lt(&self, rhs: &FixedU32<Frac>) -> bool
[src]
fn le(&self, rhs: &FixedU32<Frac>) -> bool
[src]
fn gt(&self, rhs: &FixedU32<Frac>) -> bool
[src]
fn ge(&self, rhs: &FixedU32<Frac>) -> bool
[src]
impl<Frac> PartialOrd<f64> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn partial_cmp(&self, rhs: &f64) -> Option<Ordering>
[src]
fn lt(&self, rhs: &f64) -> bool
[src]
fn le(&self, rhs: &f64) -> bool
[src]
fn gt(&self, rhs: &f64) -> bool
[src]
fn ge(&self, rhs: &f64) -> bool
[src]
impl<Frac> PartialOrd<FixedU32<Frac>> for f64 where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn partial_cmp(&self, rhs: &FixedU32<Frac>) -> Option<Ordering>
[src]
fn lt(&self, rhs: &FixedU32<Frac>) -> bool
[src]
fn le(&self, rhs: &FixedU32<Frac>) -> bool
[src]
fn gt(&self, rhs: &FixedU32<Frac>) -> bool
[src]
fn ge(&self, rhs: &FixedU32<Frac>) -> bool
[src]
impl<FracLhs, FracRhs> PartialOrd<FixedU32<FracRhs>> for FixedU64<FracLhs> where
FracLhs: Unsigned + IsLessOrEqual<U64, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
FracLhs: Unsigned + IsLessOrEqual<U64, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U32, Output = True>,
fn partial_cmp(&self, rhs: &FixedU32<FracRhs>) -> Option<Ordering>
[src]
fn lt(&self, rhs: &FixedU32<FracRhs>) -> bool
[src]
fn le(&self, rhs: &FixedU32<FracRhs>) -> bool
[src]
fn gt(&self, rhs: &FixedU32<FracRhs>) -> bool
[src]
fn ge(&self, rhs: &FixedU32<FracRhs>) -> bool
[src]
impl<FracLhs, FracRhs> PartialOrd<FixedU32<FracRhs>> for FixedU128<FracLhs> where
FracLhs: Unsigned + IsLessOrEqual<U128, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
FracLhs: Unsigned + IsLessOrEqual<U128, Output = True>,
FracRhs: Unsigned + IsLessOrEqual<U32, Output = True>,
fn partial_cmp(&self, rhs: &FixedU32<FracRhs>) -> Option<Ordering>
[src]
fn lt(&self, rhs: &FixedU32<FracRhs>) -> bool
[src]
fn le(&self, rhs: &FixedU32<FracRhs>) -> bool
[src]
fn gt(&self, rhs: &FixedU32<FracRhs>) -> bool
[src]
fn ge(&self, rhs: &FixedU32<FracRhs>) -> bool
[src]
impl<Frac> Add<FixedU32<Frac>> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the +
operator.
fn add(self, rhs: FixedU32<Frac>) -> FixedU32<Frac>
[src]
impl<'a, Frac> Add<FixedU32<Frac>> for &'a FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the +
operator.
fn add(self, rhs: FixedU32<Frac>) -> FixedU32<Frac>
[src]
impl<'a, Frac> Add<&'a FixedU32<Frac>> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the +
operator.
fn add(self, rhs: &FixedU32<Frac>) -> FixedU32<Frac>
[src]
impl<'a, 'b, Frac> Add<&'a FixedU32<Frac>> for &'b FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the +
operator.
fn add(self, rhs: &FixedU32<Frac>) -> FixedU32<Frac>
[src]
impl<Frac> Sub<FixedU32<Frac>> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the -
operator.
fn sub(self, rhs: FixedU32<Frac>) -> FixedU32<Frac>
[src]
impl<'a, Frac> Sub<FixedU32<Frac>> for &'a FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the -
operator.
fn sub(self, rhs: FixedU32<Frac>) -> FixedU32<Frac>
[src]
impl<'a, Frac> Sub<&'a FixedU32<Frac>> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the -
operator.
fn sub(self, rhs: &FixedU32<Frac>) -> FixedU32<Frac>
[src]
impl<'a, 'b, Frac> Sub<&'a FixedU32<Frac>> for &'b FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the -
operator.
fn sub(self, rhs: &FixedU32<Frac>) -> FixedU32<Frac>
[src]
impl<Frac> Mul<FixedU32<Frac>> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the *
operator.
fn mul(self, rhs: FixedU32<Frac>) -> FixedU32<Frac>
[src]
impl<'a, Frac> Mul<FixedU32<Frac>> for &'a FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the *
operator.
fn mul(self, rhs: FixedU32<Frac>) -> FixedU32<Frac>
[src]
impl<'a, Frac> Mul<&'a FixedU32<Frac>> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the *
operator.
fn mul(self, rhs: &FixedU32<Frac>) -> FixedU32<Frac>
[src]
impl<'a, 'b, Frac> Mul<&'a FixedU32<Frac>> for &'b FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the *
operator.
fn mul(self, rhs: &FixedU32<Frac>) -> FixedU32<Frac>
[src]
impl<Frac> Mul<u32> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the *
operator.
fn mul(self, rhs: u32) -> FixedU32<Frac>
[src]
impl<Frac> Mul<FixedU32<Frac>> for u32 where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the *
operator.
fn mul(self, rhs: FixedU32<Frac>) -> FixedU32<Frac>
[src]
impl<'a, Frac> Mul<u32> for &'a FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the *
operator.
fn mul(self, rhs: u32) -> FixedU32<Frac>
[src]
impl<'a, Frac> Mul<&'a FixedU32<Frac>> for u32 where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the *
operator.
fn mul(self, rhs: &FixedU32<Frac>) -> FixedU32<Frac>
[src]
impl<'a, Frac> Mul<&'a u32> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the *
operator.
fn mul(self, rhs: &u32) -> FixedU32<Frac>
[src]
impl<'a, Frac> Mul<FixedU32<Frac>> for &'a u32 where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the *
operator.
fn mul(self, rhs: FixedU32<Frac>) -> FixedU32<Frac>
[src]
impl<'a, 'b, Frac> Mul<&'a u32> for &'b FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the *
operator.
fn mul(self, rhs: &u32) -> FixedU32<Frac>
[src]
impl<'a, 'b, Frac> Mul<&'a FixedU32<Frac>> for &'b u32 where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the *
operator.
fn mul(self, rhs: &FixedU32<Frac>) -> FixedU32<Frac>
[src]
impl<Frac> Div<FixedU32<Frac>> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the /
operator.
fn div(self, rhs: FixedU32<Frac>) -> FixedU32<Frac>
[src]
impl<'a, Frac> Div<FixedU32<Frac>> for &'a FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the /
operator.
fn div(self, rhs: FixedU32<Frac>) -> FixedU32<Frac>
[src]
impl<'a, Frac> Div<&'a FixedU32<Frac>> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the /
operator.
fn div(self, rhs: &FixedU32<Frac>) -> FixedU32<Frac>
[src]
impl<'a, 'b, Frac> Div<&'a FixedU32<Frac>> for &'b FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the /
operator.
fn div(self, rhs: &FixedU32<Frac>) -> FixedU32<Frac>
[src]
impl<Frac> Div<u32> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the /
operator.
fn div(self, rhs: u32) -> FixedU32<Frac>
[src]
impl<'a, Frac> Div<u32> for &'a FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the /
operator.
fn div(self, rhs: u32) -> FixedU32<Frac>
[src]
impl<'a, Frac> Div<&'a u32> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the /
operator.
fn div(self, rhs: &u32) -> FixedU32<Frac>
[src]
impl<'a, 'b, Frac> Div<&'a u32> for &'b FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the /
operator.
fn div(self, rhs: &u32) -> FixedU32<Frac>
[src]
impl<Frac> Rem<u32> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the %
operator.
fn rem(self, rhs: u32) -> FixedU32<Frac>
[src]
impl<'a, Frac> Rem<u32> for &'a FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the %
operator.
fn rem(self, rhs: u32) -> FixedU32<Frac>
[src]
impl<'a, Frac> Rem<&'a u32> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the %
operator.
fn rem(self, rhs: &u32) -> FixedU32<Frac>
[src]
impl<'a, 'b, Frac> Rem<&'a u32> for &'b FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the %
operator.
fn rem(self, rhs: &u32) -> FixedU32<Frac>
[src]
impl<Frac> AddAssign<FixedU32<Frac>> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn add_assign(&mut self, rhs: FixedU32<Frac>)
[src]
impl<'a, Frac> AddAssign<&'a FixedU32<Frac>> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn add_assign(&mut self, rhs: &FixedU32<Frac>)
[src]
impl<Frac> SubAssign<FixedU32<Frac>> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn sub_assign(&mut self, rhs: FixedU32<Frac>)
[src]
impl<'a, Frac> SubAssign<&'a FixedU32<Frac>> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn sub_assign(&mut self, rhs: &FixedU32<Frac>)
[src]
impl<Frac> MulAssign<FixedU32<Frac>> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn mul_assign(&mut self, rhs: FixedU32<Frac>)
[src]
impl<'a, Frac> MulAssign<&'a FixedU32<Frac>> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn mul_assign(&mut self, rhs: &FixedU32<Frac>)
[src]
impl<Frac> MulAssign<u32> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn mul_assign(&mut self, rhs: u32)
[src]
impl<'a, Frac> MulAssign<&'a u32> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn mul_assign(&mut self, rhs: &u32)
[src]
impl<Frac> DivAssign<FixedU32<Frac>> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn div_assign(&mut self, rhs: FixedU32<Frac>)
[src]
impl<'a, Frac> DivAssign<&'a FixedU32<Frac>> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn div_assign(&mut self, rhs: &FixedU32<Frac>)
[src]
impl<Frac> DivAssign<u32> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn div_assign(&mut self, rhs: u32)
[src]
impl<'a, Frac> DivAssign<&'a u32> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn div_assign(&mut self, rhs: &u32)
[src]
impl<Frac> RemAssign<u32> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn rem_assign(&mut self, rhs: u32)
[src]
impl<'a, Frac> RemAssign<&'a u32> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn rem_assign(&mut self, rhs: &u32)
[src]
impl<Frac> Not for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the !
operator.
fn not(self) -> FixedU32<Frac>
[src]
impl<'a, Frac> Not for &'a FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the !
operator.
fn not(self) -> FixedU32<Frac>
[src]
impl<Frac> BitAnd<FixedU32<Frac>> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the &
operator.
fn bitand(self, rhs: FixedU32<Frac>) -> FixedU32<Frac>
[src]
impl<'a, Frac> BitAnd<FixedU32<Frac>> for &'a FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the &
operator.
fn bitand(self, rhs: FixedU32<Frac>) -> FixedU32<Frac>
[src]
impl<'a, Frac> BitAnd<&'a FixedU32<Frac>> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the &
operator.
fn bitand(self, rhs: &FixedU32<Frac>) -> FixedU32<Frac>
[src]
impl<'a, 'b, Frac> BitAnd<&'a FixedU32<Frac>> for &'b FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the &
operator.
fn bitand(self, rhs: &FixedU32<Frac>) -> FixedU32<Frac>
[src]
impl<Frac> BitOr<FixedU32<Frac>> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the |
operator.
fn bitor(self, rhs: FixedU32<Frac>) -> FixedU32<Frac>
[src]
impl<'a, Frac> BitOr<FixedU32<Frac>> for &'a FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the |
operator.
fn bitor(self, rhs: FixedU32<Frac>) -> FixedU32<Frac>
[src]
impl<'a, Frac> BitOr<&'a FixedU32<Frac>> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the |
operator.
fn bitor(self, rhs: &FixedU32<Frac>) -> FixedU32<Frac>
[src]
impl<'a, 'b, Frac> BitOr<&'a FixedU32<Frac>> for &'b FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the |
operator.
fn bitor(self, rhs: &FixedU32<Frac>) -> FixedU32<Frac>
[src]
impl<Frac> BitXor<FixedU32<Frac>> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: FixedU32<Frac>) -> FixedU32<Frac>
[src]
impl<'a, Frac> BitXor<FixedU32<Frac>> for &'a FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: FixedU32<Frac>) -> FixedU32<Frac>
[src]
impl<'a, Frac> BitXor<&'a FixedU32<Frac>> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: &FixedU32<Frac>) -> FixedU32<Frac>
[src]
impl<'a, 'b, Frac> BitXor<&'a FixedU32<Frac>> for &'b FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: &FixedU32<Frac>) -> FixedU32<Frac>
[src]
impl<Frac> Shl<i8> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: i8) -> FixedU32<Frac>
[src]
impl<'a, Frac> Shl<i8> for &'a FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: i8) -> FixedU32<Frac>
[src]
impl<'a, Frac> Shl<&'a i8> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: &i8) -> FixedU32<Frac>
[src]
impl<'a, 'b, Frac> Shl<&'a i8> for &'b FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: &i8) -> FixedU32<Frac>
[src]
impl<Frac> Shl<i16> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: i16) -> FixedU32<Frac>
[src]
impl<'a, Frac> Shl<i16> for &'a FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: i16) -> FixedU32<Frac>
[src]
impl<'a, Frac> Shl<&'a i16> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: &i16) -> FixedU32<Frac>
[src]
impl<'a, 'b, Frac> Shl<&'a i16> for &'b FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: &i16) -> FixedU32<Frac>
[src]
impl<Frac> Shl<i32> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: i32) -> FixedU32<Frac>
[src]
impl<'a, Frac> Shl<i32> for &'a FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: i32) -> FixedU32<Frac>
[src]
impl<'a, Frac> Shl<&'a i32> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: &i32) -> FixedU32<Frac>
[src]
impl<'a, 'b, Frac> Shl<&'a i32> for &'b FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: &i32) -> FixedU32<Frac>
[src]
impl<Frac> Shl<i64> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: i64) -> FixedU32<Frac>
[src]
impl<'a, Frac> Shl<i64> for &'a FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: i64) -> FixedU32<Frac>
[src]
impl<'a, Frac> Shl<&'a i64> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: &i64) -> FixedU32<Frac>
[src]
impl<'a, 'b, Frac> Shl<&'a i64> for &'b FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: &i64) -> FixedU32<Frac>
[src]
impl<Frac> Shl<i128> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: i128) -> FixedU32<Frac>
[src]
impl<'a, Frac> Shl<i128> for &'a FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: i128) -> FixedU32<Frac>
[src]
impl<'a, Frac> Shl<&'a i128> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: &i128) -> FixedU32<Frac>
[src]
impl<'a, 'b, Frac> Shl<&'a i128> for &'b FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: &i128) -> FixedU32<Frac>
[src]
impl<Frac> Shl<isize> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: isize) -> FixedU32<Frac>
[src]
impl<'a, Frac> Shl<isize> for &'a FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: isize) -> FixedU32<Frac>
[src]
impl<'a, Frac> Shl<&'a isize> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: &isize) -> FixedU32<Frac>
[src]
impl<'a, 'b, Frac> Shl<&'a isize> for &'b FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: &isize) -> FixedU32<Frac>
[src]
impl<Frac> Shl<u8> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: u8) -> FixedU32<Frac>
[src]
impl<'a, Frac> Shl<u8> for &'a FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: u8) -> FixedU32<Frac>
[src]
impl<'a, Frac> Shl<&'a u8> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: &u8) -> FixedU32<Frac>
[src]
impl<'a, 'b, Frac> Shl<&'a u8> for &'b FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: &u8) -> FixedU32<Frac>
[src]
impl<Frac> Shl<u16> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: u16) -> FixedU32<Frac>
[src]
impl<'a, Frac> Shl<u16> for &'a FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: u16) -> FixedU32<Frac>
[src]
impl<'a, Frac> Shl<&'a u16> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: &u16) -> FixedU32<Frac>
[src]
impl<'a, 'b, Frac> Shl<&'a u16> for &'b FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: &u16) -> FixedU32<Frac>
[src]
impl<Frac> Shl<u32> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: u32) -> FixedU32<Frac>
[src]
impl<'a, Frac> Shl<u32> for &'a FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: u32) -> FixedU32<Frac>
[src]
impl<'a, Frac> Shl<&'a u32> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: &u32) -> FixedU32<Frac>
[src]
impl<'a, 'b, Frac> Shl<&'a u32> for &'b FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: &u32) -> FixedU32<Frac>
[src]
impl<Frac> Shl<u64> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: u64) -> FixedU32<Frac>
[src]
impl<'a, Frac> Shl<u64> for &'a FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: u64) -> FixedU32<Frac>
[src]
impl<'a, Frac> Shl<&'a u64> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: &u64) -> FixedU32<Frac>
[src]
impl<'a, 'b, Frac> Shl<&'a u64> for &'b FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: &u64) -> FixedU32<Frac>
[src]
impl<Frac> Shl<u128> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: u128) -> FixedU32<Frac>
[src]
impl<'a, Frac> Shl<u128> for &'a FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: u128) -> FixedU32<Frac>
[src]
impl<'a, Frac> Shl<&'a u128> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: &u128) -> FixedU32<Frac>
[src]
impl<'a, 'b, Frac> Shl<&'a u128> for &'b FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: &u128) -> FixedU32<Frac>
[src]
impl<Frac> Shl<usize> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: usize) -> FixedU32<Frac>
[src]
impl<'a, Frac> Shl<usize> for &'a FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: usize) -> FixedU32<Frac>
[src]
impl<'a, Frac> Shl<&'a usize> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: &usize) -> FixedU32<Frac>
[src]
impl<'a, 'b, Frac> Shl<&'a usize> for &'b FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: &usize) -> FixedU32<Frac>
[src]
impl<Frac> Shr<i8> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: i8) -> FixedU32<Frac>
[src]
impl<'a, Frac> Shr<i8> for &'a FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: i8) -> FixedU32<Frac>
[src]
impl<'a, Frac> Shr<&'a i8> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: &i8) -> FixedU32<Frac>
[src]
impl<'a, 'b, Frac> Shr<&'a i8> for &'b FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: &i8) -> FixedU32<Frac>
[src]
impl<Frac> Shr<i16> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: i16) -> FixedU32<Frac>
[src]
impl<'a, Frac> Shr<i16> for &'a FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: i16) -> FixedU32<Frac>
[src]
impl<'a, Frac> Shr<&'a i16> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: &i16) -> FixedU32<Frac>
[src]
impl<'a, 'b, Frac> Shr<&'a i16> for &'b FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: &i16) -> FixedU32<Frac>
[src]
impl<Frac> Shr<i32> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: i32) -> FixedU32<Frac>
[src]
impl<'a, Frac> Shr<i32> for &'a FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: i32) -> FixedU32<Frac>
[src]
impl<'a, Frac> Shr<&'a i32> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: &i32) -> FixedU32<Frac>
[src]
impl<'a, 'b, Frac> Shr<&'a i32> for &'b FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: &i32) -> FixedU32<Frac>
[src]
impl<Frac> Shr<i64> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: i64) -> FixedU32<Frac>
[src]
impl<'a, Frac> Shr<i64> for &'a FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: i64) -> FixedU32<Frac>
[src]
impl<'a, Frac> Shr<&'a i64> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: &i64) -> FixedU32<Frac>
[src]
impl<'a, 'b, Frac> Shr<&'a i64> for &'b FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: &i64) -> FixedU32<Frac>
[src]
impl<Frac> Shr<i128> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: i128) -> FixedU32<Frac>
[src]
impl<'a, Frac> Shr<i128> for &'a FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: i128) -> FixedU32<Frac>
[src]
impl<'a, Frac> Shr<&'a i128> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: &i128) -> FixedU32<Frac>
[src]
impl<'a, 'b, Frac> Shr<&'a i128> for &'b FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: &i128) -> FixedU32<Frac>
[src]
impl<Frac> Shr<isize> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: isize) -> FixedU32<Frac>
[src]
impl<'a, Frac> Shr<isize> for &'a FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: isize) -> FixedU32<Frac>
[src]
impl<'a, Frac> Shr<&'a isize> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: &isize) -> FixedU32<Frac>
[src]
impl<'a, 'b, Frac> Shr<&'a isize> for &'b FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: &isize) -> FixedU32<Frac>
[src]
impl<Frac> Shr<u8> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: u8) -> FixedU32<Frac>
[src]
impl<'a, Frac> Shr<u8> for &'a FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: u8) -> FixedU32<Frac>
[src]
impl<'a, Frac> Shr<&'a u8> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: &u8) -> FixedU32<Frac>
[src]
impl<'a, 'b, Frac> Shr<&'a u8> for &'b FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: &u8) -> FixedU32<Frac>
[src]
impl<Frac> Shr<u16> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: u16) -> FixedU32<Frac>
[src]
impl<'a, Frac> Shr<u16> for &'a FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: u16) -> FixedU32<Frac>
[src]
impl<'a, Frac> Shr<&'a u16> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: &u16) -> FixedU32<Frac>
[src]
impl<'a, 'b, Frac> Shr<&'a u16> for &'b FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: &u16) -> FixedU32<Frac>
[src]
impl<Frac> Shr<u32> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: u32) -> FixedU32<Frac>
[src]
impl<'a, Frac> Shr<u32> for &'a FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: u32) -> FixedU32<Frac>
[src]
impl<'a, Frac> Shr<&'a u32> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: &u32) -> FixedU32<Frac>
[src]
impl<'a, 'b, Frac> Shr<&'a u32> for &'b FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: &u32) -> FixedU32<Frac>
[src]
impl<Frac> Shr<u64> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: u64) -> FixedU32<Frac>
[src]
impl<'a, Frac> Shr<u64> for &'a FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: u64) -> FixedU32<Frac>
[src]
impl<'a, Frac> Shr<&'a u64> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: &u64) -> FixedU32<Frac>
[src]
impl<'a, 'b, Frac> Shr<&'a u64> for &'b FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: &u64) -> FixedU32<Frac>
[src]
impl<Frac> Shr<u128> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: u128) -> FixedU32<Frac>
[src]
impl<'a, Frac> Shr<u128> for &'a FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: u128) -> FixedU32<Frac>
[src]
impl<'a, Frac> Shr<&'a u128> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: &u128) -> FixedU32<Frac>
[src]
impl<'a, 'b, Frac> Shr<&'a u128> for &'b FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: &u128) -> FixedU32<Frac>
[src]
impl<Frac> Shr<usize> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: usize) -> FixedU32<Frac>
[src]
impl<'a, Frac> Shr<usize> for &'a FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: usize) -> FixedU32<Frac>
[src]
impl<'a, Frac> Shr<&'a usize> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: &usize) -> FixedU32<Frac>
[src]
impl<'a, 'b, Frac> Shr<&'a usize> for &'b FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
type Output = FixedU32<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: &usize) -> FixedU32<Frac>
[src]
impl<Frac> BitAndAssign<FixedU32<Frac>> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn bitand_assign(&mut self, rhs: FixedU32<Frac>)
[src]
impl<'a, Frac> BitAndAssign<&'a FixedU32<Frac>> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn bitand_assign(&mut self, rhs: &FixedU32<Frac>)
[src]
impl<Frac> BitOrAssign<FixedU32<Frac>> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn bitor_assign(&mut self, rhs: FixedU32<Frac>)
[src]
impl<'a, Frac> BitOrAssign<&'a FixedU32<Frac>> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn bitor_assign(&mut self, rhs: &FixedU32<Frac>)
[src]
impl<Frac> BitXorAssign<FixedU32<Frac>> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn bitxor_assign(&mut self, rhs: FixedU32<Frac>)
[src]
impl<'a, Frac> BitXorAssign<&'a FixedU32<Frac>> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn bitxor_assign(&mut self, rhs: &FixedU32<Frac>)
[src]
impl<Frac> ShlAssign<i8> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn shl_assign(&mut self, rhs: i8)
[src]
impl<'a, Frac> ShlAssign<&'a i8> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn shl_assign(&mut self, rhs: &i8)
[src]
impl<Frac> ShlAssign<i16> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn shl_assign(&mut self, rhs: i16)
[src]
impl<'a, Frac> ShlAssign<&'a i16> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn shl_assign(&mut self, rhs: &i16)
[src]
impl<Frac> ShlAssign<i32> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn shl_assign(&mut self, rhs: i32)
[src]
impl<'a, Frac> ShlAssign<&'a i32> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn shl_assign(&mut self, rhs: &i32)
[src]
impl<Frac> ShlAssign<i64> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn shl_assign(&mut self, rhs: i64)
[src]
impl<'a, Frac> ShlAssign<&'a i64> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn shl_assign(&mut self, rhs: &i64)
[src]
impl<Frac> ShlAssign<i128> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn shl_assign(&mut self, rhs: i128)
[src]
impl<'a, Frac> ShlAssign<&'a i128> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn shl_assign(&mut self, rhs: &i128)
[src]
impl<Frac> ShlAssign<isize> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn shl_assign(&mut self, rhs: isize)
[src]
impl<'a, Frac> ShlAssign<&'a isize> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn shl_assign(&mut self, rhs: &isize)
[src]
impl<Frac> ShlAssign<u8> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn shl_assign(&mut self, rhs: u8)
[src]
impl<'a, Frac> ShlAssign<&'a u8> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn shl_assign(&mut self, rhs: &u8)
[src]
impl<Frac> ShlAssign<u16> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn shl_assign(&mut self, rhs: u16)
[src]
impl<'a, Frac> ShlAssign<&'a u16> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn shl_assign(&mut self, rhs: &u16)
[src]
impl<Frac> ShlAssign<u32> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn shl_assign(&mut self, rhs: u32)
[src]
impl<'a, Frac> ShlAssign<&'a u32> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn shl_assign(&mut self, rhs: &u32)
[src]
impl<Frac> ShlAssign<u64> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn shl_assign(&mut self, rhs: u64)
[src]
impl<'a, Frac> ShlAssign<&'a u64> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn shl_assign(&mut self, rhs: &u64)
[src]
impl<Frac> ShlAssign<u128> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn shl_assign(&mut self, rhs: u128)
[src]
impl<'a, Frac> ShlAssign<&'a u128> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn shl_assign(&mut self, rhs: &u128)
[src]
impl<Frac> ShlAssign<usize> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn shl_assign(&mut self, rhs: usize)
[src]
impl<'a, Frac> ShlAssign<&'a usize> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn shl_assign(&mut self, rhs: &usize)
[src]
impl<Frac> ShrAssign<i8> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn shr_assign(&mut self, rhs: i8)
[src]
impl<'a, Frac> ShrAssign<&'a i8> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn shr_assign(&mut self, rhs: &i8)
[src]
impl<Frac> ShrAssign<i16> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn shr_assign(&mut self, rhs: i16)
[src]
impl<'a, Frac> ShrAssign<&'a i16> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn shr_assign(&mut self, rhs: &i16)
[src]
impl<Frac> ShrAssign<i32> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn shr_assign(&mut self, rhs: i32)
[src]
impl<'a, Frac> ShrAssign<&'a i32> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn shr_assign(&mut self, rhs: &i32)
[src]
impl<Frac> ShrAssign<i64> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn shr_assign(&mut self, rhs: i64)
[src]
impl<'a, Frac> ShrAssign<&'a i64> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn shr_assign(&mut self, rhs: &i64)
[src]
impl<Frac> ShrAssign<i128> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn shr_assign(&mut self, rhs: i128)
[src]
impl<'a, Frac> ShrAssign<&'a i128> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn shr_assign(&mut self, rhs: &i128)
[src]
impl<Frac> ShrAssign<isize> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn shr_assign(&mut self, rhs: isize)
[src]
impl<'a, Frac> ShrAssign<&'a isize> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn shr_assign(&mut self, rhs: &isize)
[src]
impl<Frac> ShrAssign<u8> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn shr_assign(&mut self, rhs: u8)
[src]
impl<'a, Frac> ShrAssign<&'a u8> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn shr_assign(&mut self, rhs: &u8)
[src]
impl<Frac> ShrAssign<u16> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn shr_assign(&mut self, rhs: u16)
[src]
impl<'a, Frac> ShrAssign<&'a u16> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn shr_assign(&mut self, rhs: &u16)
[src]
impl<Frac> ShrAssign<u32> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn shr_assign(&mut self, rhs: u32)
[src]
impl<'a, Frac> ShrAssign<&'a u32> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn shr_assign(&mut self, rhs: &u32)
[src]
impl<Frac> ShrAssign<u64> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn shr_assign(&mut self, rhs: u64)
[src]
impl<'a, Frac> ShrAssign<&'a u64> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn shr_assign(&mut self, rhs: &u64)
[src]
impl<Frac> ShrAssign<u128> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn shr_assign(&mut self, rhs: u128)
[src]
impl<'a, Frac> ShrAssign<&'a u128> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn shr_assign(&mut self, rhs: &u128)
[src]
impl<Frac> ShrAssign<usize> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn shr_assign(&mut self, rhs: usize)
[src]
impl<'a, Frac> ShrAssign<&'a usize> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn shr_assign(&mut self, rhs: &usize)
[src]
impl<Frac> Hash for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn hash<H: Hasher>(&self, state: &mut H)
[src]
fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
Feeds a slice of this type into the given [Hasher
]. Read more
impl<Frac> Copy for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
impl<Frac> Sum<FixedU32<Frac>> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
impl<'a, Frac> Sum<&'a FixedU32<Frac>> for FixedU32<Frac> where
Frac: 'a + Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: 'a + Unsigned + IsLessOrEqual<U32, Output = True>,
impl<Frac> Product<FixedU32<Frac>> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
impl<'a, Frac> Product<&'a FixedU32<Frac>> for FixedU32<Frac> where
Frac: 'a + Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: 'a + Unsigned + IsLessOrEqual<U32, Output = True>,
impl<FracSrc, FracDst, FracMax> From<FixedU8<FracSrc>> for FixedU32<FracDst> where
FracSrc: Unsigned + IsLessOrEqual<U8, Output = True> + Add<<U32 as Sub<U8>>::Output, Output = FracMax>,
FracDst: Unsigned + IsLessOrEqual<U32, Output = True> + IsGreaterOrEqual<FracSrc, Output = True> + IsLessOrEqual<FracMax, Output = True>,
FracMax: Unsigned,
[src]
FracSrc: Unsigned + IsLessOrEqual<U8, Output = True> + Add<<U32 as Sub<U8>>::Output, Output = FracMax>,
FracDst: Unsigned + IsLessOrEqual<U32, Output = True> + IsGreaterOrEqual<FracSrc, Output = True> + IsLessOrEqual<FracMax, Output = True>,
FracMax: Unsigned,
impl<FracSrc, FracDst, FracMax> From<FixedU16<FracSrc>> for FixedU32<FracDst> where
FracSrc: Unsigned + IsLessOrEqual<U16, Output = True> + Add<<U32 as Sub<U16>>::Output, Output = FracMax>,
FracDst: Unsigned + IsLessOrEqual<U32, Output = True> + IsGreaterOrEqual<FracSrc, Output = True> + IsLessOrEqual<FracMax, Output = True>,
FracMax: Unsigned,
[src]
FracSrc: Unsigned + IsLessOrEqual<U16, Output = True> + Add<<U32 as Sub<U16>>::Output, Output = FracMax>,
FracDst: Unsigned + IsLessOrEqual<U32, Output = True> + IsGreaterOrEqual<FracSrc, Output = True> + IsLessOrEqual<FracMax, Output = True>,
FracMax: Unsigned,
impl<FracSrc, FracDst, FracMax> From<FixedU32<FracSrc>> for FixedU64<FracDst> where
FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<<U64 as Sub<U32>>::Output, Output = FracMax>,
FracDst: Unsigned + IsLessOrEqual<U64, Output = True> + IsGreaterOrEqual<FracSrc, Output = True> + IsLessOrEqual<FracMax, Output = True>,
FracMax: Unsigned,
[src]
FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<<U64 as Sub<U32>>::Output, Output = FracMax>,
FracDst: Unsigned + IsLessOrEqual<U64, Output = True> + IsGreaterOrEqual<FracSrc, Output = True> + IsLessOrEqual<FracMax, Output = True>,
FracMax: Unsigned,
impl<FracSrc, FracDst, FracMax> From<FixedU32<FracSrc>> for FixedI64<FracDst> where
FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<<<U64 as Sub<U32>>::Output as Sub<U1>>::Output, Output = FracMax>,
FracDst: Unsigned + IsLessOrEqual<U64, Output = True> + IsGreaterOrEqual<FracSrc, Output = True> + IsLessOrEqual<FracMax, Output = True>,
FracMax: Unsigned,
[src]
FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<<<U64 as Sub<U32>>::Output as Sub<U1>>::Output, Output = FracMax>,
FracDst: Unsigned + IsLessOrEqual<U64, Output = True> + IsGreaterOrEqual<FracSrc, Output = True> + IsLessOrEqual<FracMax, Output = True>,
FracMax: Unsigned,
impl<FracSrc, FracDst, FracMax> From<FixedU32<FracSrc>> for FixedU128<FracDst> where
FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<<U128 as Sub<U32>>::Output, Output = FracMax>,
FracDst: Unsigned + IsLessOrEqual<U128, Output = True> + IsGreaterOrEqual<FracSrc, Output = True> + IsLessOrEqual<FracMax, Output = True>,
FracMax: Unsigned,
[src]
FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<<U128 as Sub<U32>>::Output, Output = FracMax>,
FracDst: Unsigned + IsLessOrEqual<U128, Output = True> + IsGreaterOrEqual<FracSrc, Output = True> + IsLessOrEqual<FracMax, Output = True>,
FracMax: Unsigned,
impl<FracSrc, FracDst, FracMax> From<FixedU32<FracSrc>> for FixedI128<FracDst> where
FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<<<U128 as Sub<U32>>::Output as Sub<U1>>::Output, Output = FracMax>,
FracDst: Unsigned + IsLessOrEqual<U128, Output = True> + IsGreaterOrEqual<FracSrc, Output = True> + IsLessOrEqual<FracMax, Output = True>,
FracMax: Unsigned,
[src]
FracSrc: Unsigned + IsLessOrEqual<U32, Output = True> + Add<<<U128 as Sub<U32>>::Output as Sub<U1>>::Output, Output = FracMax>,
FracDst: Unsigned + IsLessOrEqual<U128, Output = True> + IsGreaterOrEqual<FracSrc, Output = True> + IsLessOrEqual<FracMax, Output = True>,
FracMax: Unsigned,
impl<FracDst> From<u8> for FixedU32<FracDst> where
FracDst: Unsigned + IsLessOrEqual<U32, Output = True> + IsLessOrEqual<<U32 as Sub<U8>>::Output, Output = True>,
[src]
FracDst: Unsigned + IsLessOrEqual<U32, Output = True> + IsLessOrEqual<<U32 as Sub<U8>>::Output, Output = True>,
impl<FracDst> From<u16> for FixedU32<FracDst> where
FracDst: Unsigned + IsLessOrEqual<U32, Output = True> + IsLessOrEqual<<U32 as Sub<U16>>::Output, Output = True>,
[src]
FracDst: Unsigned + IsLessOrEqual<U32, Output = True> + IsLessOrEqual<<U32 as Sub<U16>>::Output, Output = True>,
impl From<u32> for FixedU32<U0>
[src]
impl<FracDst> From<bool> for FixedU32<FracDst> where
FracDst: Unsigned + IsLessOrEqual<U32, Output = True> + IsLessOrEqual<<U32 as Sub<U1>>::Output, Output = True>,
[src]
FracDst: Unsigned + IsLessOrEqual<U32, Output = True> + IsLessOrEqual<<U32 as Sub<U1>>::Output, Output = True>,
impl From<FixedU32<UTerm>> for u32
[src]
impl From<FixedU32<UTerm>> for u64
[src]
impl From<FixedU32<UTerm>> for i64
[src]
impl From<FixedU32<UTerm>> for u128
[src]
impl From<FixedU32<UTerm>> for i128
[src]
impl<Frac> From<FixedU32<Frac>> for f64 where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
impl<Frac> Octal for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
impl<Frac> Binary for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
impl<Frac> LowerHex for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
impl<Frac> UpperHex for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
impl<Frac> Clone for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn clone(&self) -> FixedU32<Frac>
[src]
fn clone_from(&mut self, source: &Self)
1.0.0[src]
Performs copy-assignment from source
. Read more
impl<Frac> Default for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
impl<Frac> Serialize for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
impl<'de, Frac> Deserialize<'de> for FixedU32<Frac> where
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
[src]
Frac: Unsigned + IsLessOrEqual<U32, Output = True>,
fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>
[src]
Auto Trait Implementations
impl<Frac> Unpin for FixedU32<Frac> where
Frac: Unpin,
Frac: Unpin,
impl<Frac> Sync for FixedU32<Frac> where
Frac: Sync,
Frac: Sync,
impl<Frac> Send for FixedU32<Frac> where
Frac: Send,
Frac: Send,
Blanket Implementations
impl<Src, Dst> LossyInto<Dst> for Src where
Dst: LossyFrom<Src>,
[src]
Dst: LossyFrom<Src>,
fn lossy_into(Self) -> Dst
[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> From<T> for T
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
[src]
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Same<T> for T
[src]
type Output = T
Should always be Self
impl<T> DeserializeOwned for T where
T: Deserialize<'de>,
[src]
T: Deserialize<'de>,