Struct fixed::FixedI32

#[repr(transparent)]
pub struct FixedI32<Frac>(_)
 where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>;

A 32-bit fixed-point signed 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::FixedI32;
let eleven = FixedI32::<U3>::from_bits(11 << 3);
let five_half = eleven >> 1u32;
assert_eq!(eleven.to_string(), "11.0");
assert_eq!(five_half.to_string(), "5.5");

Methods

impl<Frac> FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

pub fn min_value() -> FixedI32<Frac>

Returns the smallest value that can be represented.

Examples

use fixed::frac;
type Fix = fixed::FixedI32<frac::U4>;
assert_eq!(Fix::min_value(), Fix::from_bits(i32::min_value()));

pub fn max_value() -> FixedI32<Frac>

Returns the smallest value that can be represented.

Examples

use fixed::frac;
type Fix = fixed::FixedI32<frac::U4>;
assert_eq!(Fix::max_value(), Fix::from_bits(i32::max_value()));

pub fn int_bits() -> u32

Returns the number of integer bits.

Examples

use fixed::frac;
type Fix = fixed::FixedI32<frac::U6>;
assert_eq!(Fix::int_bits(), 32 - 6);

pub fn frac_bits() -> u32

Returns the number of fractional bits.

Examples

use fixed::frac;
type Fix = fixed::FixedI32<frac::U6>;
assert_eq!(Fix::frac_bits(), 6);

pub fn from_bits(v: i32) -> FixedI32<Frac>

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

Examples

use fixed::frac;
type Fix = fixed::FixedI32<frac::U4>;
// 0010.0000 == 2
assert_eq!(Fix::from_bits(0b10_0000), 2);

pub fn to_bits(self) -> i32

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

Examples

use fixed::frac;
type Fix = fixed::FixedI32<frac::U4>;
// 2 is 0010.0000
assert_eq!(Fix::from_int(2).to_bits(), 0b10_0000);

pub fn from_fixed<F>(val: F) -> FixedI32<Frac> where     F: Fixed,

Creates a fixed-point number from another fixed-point number.

The source value does not need to have the same fixed-point type as the destination value.

This method truncates the extra fractional bits in the source value. For example, if the source type has 24 fractional bits and the destination type has 10 fractional bits, then 14 fractional bits will be truncated.

Panics

If the value is too large to fit, the method panics in debug mode. In release mode, the method may either panic or wrap the value, with the current implementation wrapping the value. It is not considered a breaking change if in the future the method panics even in release mode; if wrapping is the required behavior use wrapping_from_fixed instead.

Examples

use fixed::frac;
type Src = fixed::FixedI32<frac::U16>;
type Fix = fixed::FixedI32<frac::U4>;
// 1.75 is 1.1100, that is Src::from_bits(0b111 << (16 - 2))
// or Fix::from_bits(0b111<< (4 - 2))
let src = Src::from_bits(0b111 << (16 - 2));
let expected = Fix::from_bits(0b111 << (4 - 2));
assert_eq!(Fix::from_fixed(src), expected);
assert_eq!(Fix::from_fixed(-src), -expected);
// src >> 4 is 0.0001_1100, which for Fix is truncated to 0000.0001
assert_eq!(Fix::from_fixed(src >> 4), Fix::from_bits(1));

pub fn checked_from_fixed<F>(val: F) -> Option<FixedI32<Frac>> where     F: Fixed,

Creates a fixed-point number from another fixed-point number if it fits.

The source value does not need to have the same fixed-point type as the destination value.

This method truncates the extra fractional bits in the source value. For example, if the source type has 24 fractional bits and the destination type has 10 fractional bits, then 14 fractional bits will be truncated.

Examples

use fixed::frac;
type Src = fixed::FixedI32<frac::U16>;
type Fix = fixed::FixedI32<frac::U4>;
// 1.75 is 1.1100, that is Src::from_bits(0b111 << (16 - 2))
// or Fix::from_bits(0b111<< (4 - 2))
let src = Src::from_bits(0b111 << (16 - 2));
let expected = Fix::from_bits(0b111 << (4 - 2));
assert_eq!(Fix::checked_from_fixed(src), Some(expected));
assert_eq!(Fix::checked_from_fixed(-src), Some(-expected));
let too_large = fixed::FixedI32::<frac::U3>::max_value();
assert!(Fix::checked_from_fixed(too_large).is_none());
let too_small = fixed::FixedI32::<frac::U3>::min_value();
println!("too_small is {} and gives {:?}", too_small, Fix::checked_from_fixed(too_small));
assert!(Fix::checked_from_fixed(too_small).is_none());

pub fn saturating_from_fixed<F>(val: F) -> FixedI32<Frac> where     F: Fixed,

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

The source value does not need to have the same fixed-point type as the destination value.

This method truncates the extra fractional bits in the source value. For example, if the source type has 24 fractional bits and the destination type has 10 fractional bits, then 14 fractional bits will be truncated.

Examples

use fixed::frac;
type Src = fixed::FixedI32<frac::U16>;
type Fix = fixed::FixedI32<frac::U4>;
// 1.75 is 1.1100, that is Src::from_bits(0b111 << (16 - 2))
// or Fix::from_bits(0b111<< (4 - 2))
let src = Src::from_bits(0b111 << (16 - 2));
let expected = Fix::from_bits(0b111 << (4 - 2));
assert_eq!(Fix::saturating_from_fixed(src), expected);
assert_eq!(Fix::saturating_from_fixed(-src), -expected);
let too_large = fixed::FixedI32::<frac::U3>::max_value();
assert_eq!(Fix::saturating_from_fixed(too_large), Fix::max_value());
let too_small = fixed::FixedI32::<frac::U3>::min_value();
assert_eq!(Fix::saturating_from_fixed(too_small), Fix::min_value());

pub fn wrapping_from_fixed<F>(val: F) -> FixedI32<Frac> where     F: Fixed,

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

The source value does not need to have the same fixed-point type as the destination value.

This method truncates the extra fractional bits in the source value. For example, if the source type has 24 fractional bits and the destination type has 10 fractional bits, then 14 fractional bits will be truncated.

Examples

use fixed::frac;
type Src = fixed::FixedI32<frac::U16>;
type Fix = fixed::FixedI32<frac::U4>;
// 1.75 is 1.1100, that is Src::from_bits(0b111 << (16 - 2))
// or Fix::from_bits(0b111<< (4 - 2))
let src = Src::from_bits(0b111 << (16 - 2));
let expected = Fix::from_bits(0b111 << (4 - 2));
assert_eq!(Fix::wrapping_from_fixed(src), expected);
assert_eq!(Fix::wrapping_from_fixed(-src), -expected);
// integer 0b1101 << (32 - 7) will wrap to fixed-point 1010...
let large = fixed::FixedI32::<frac::U0>::from_bits(0b1101 << (32 - 7));
let wrapped = Fix::from_bits(0b1010 << (32 - 4));
assert_eq!(Fix::wrapping_from_fixed(large), wrapped);

pub fn overflowing_from_fixed<F>(val: F) -> (FixedI32<Frac>, bool) where     F: Fixed,

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.

Examples

use fixed::frac;
type Src = fixed::FixedI32<frac::U16>;
type Fix = fixed::FixedI32<frac::U4>;
// 1.75 is 1.1100, that is Src::from_bits(0b111 << (16 - 2))
// or Fix::from_bits(0b111<< (4 - 2))
let src = Src::from_bits(0b111 << (16 - 2));
let expected = Fix::from_bits(0b111 << (4 - 2));
assert_eq!(Fix::overflowing_from_fixed(src), (expected, false));
assert_eq!(Fix::overflowing_from_fixed(-src), (-expected, false));
// integer 0b1101 << (32 - 7) will wrap to fixed-point 1010...
let large = fixed::FixedI32::<frac::U0>::from_bits(0b1101 << (32 - 7));
let wrapped = Fix::from_bits(0b1010 << (32 - 4));
assert_eq!(Fix::overflowing_from_fixed(large), (wrapped, true));

pub fn from_int<I>(val: I) -> FixedI32<Frac> where     I: Int,

Creates a fixed-point number from an integer.

The integer value can be of type bool, i8, i16, i32, i64, i128, u8, u16, u32, u64, and u128.

Panics

If the value is too large to fit, the method panics in debug mode. In release mode, the method may either panic or wrap the value, with the current implementation wrapping the value. It is not considered a breaking change if in the future the method panics even in release mode; if wrapping is the required behavior use wrapping_from_int instead.

Examples

use fixed::frac;
type Fix = fixed::FixedI32<frac::U4>;
// 3 is 0011.0000, that is from_bits(3 << 4)
assert_eq!(Fix::from_int(3), Fix::from_bits(3 << 4));
assert_eq!(Fix::from_int(-3), Fix::from_bits(-3 << 4));

pub fn checked_from_int<I>(val: I) -> Option<FixedI32<Frac>> where     I: Int,

Creates a fixed-point number from an integer if it fits.

The integer value can be of type bool, i8, i16, i32, i64, i128, u8, u16, u32, u64, and u128.

Examples

use fixed::frac;
use std::i32;
type Fix = fixed::FixedI32<frac::U4>;
// 3 is 0011.0000, that is from_bits(3 << 4)
assert_eq!(Fix::checked_from_int(3), Some(Fix::from_bits(3 << 4)));
assert_eq!(Fix::checked_from_int(-3), Some(Fix::from_bits(-3 << 4)));
let too_large = i32::max_value();
assert!(Fix::checked_from_int(too_large).is_none());
let too_small = i32::min_value();
assert!(Fix::checked_from_int(too_small).is_none());

pub fn saturating_from_int<I>(val: I) -> FixedI32<Frac> where     I: Int,

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

The integer value can be of type bool, i8, i16, i32, i64, i128, u8, u16, u32, u64, and u128.

Examples

use fixed::frac;
use std::i32;
type Fix = fixed::FixedI32<frac::U4>;
// 3 is 0011.0000, that is from_bits(3 << 4)
assert_eq!(Fix::saturating_from_int(3), Fix::from_bits(3 << 4));
assert_eq!(Fix::saturating_from_int(-3), Fix::from_bits(-3 << 4));
let too_large = i32::max_value();
assert_eq!(Fix::saturating_from_int(too_large), Fix::max_value());
let too_small = i32::min_value();
assert_eq!(Fix::saturating_from_int(too_small), Fix::min_value());

pub fn wrapping_from_int<I>(val: I) -> FixedI32<Frac> where     I: Int,

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

The integer value can be of type bool, i8, i16, i32, i64, i128, u8, u16, u32, u64, and u128.

Examples

use fixed::frac;
type Fix = fixed::FixedI32<frac::U4>;
// 3 is 0011.0000, that is from_bits(3 << 4)
assert_eq!(Fix::wrapping_from_int(3), Fix::from_bits(3 << 4));
assert_eq!(Fix::wrapping_from_int(-3), Fix::from_bits(-3 << 4));
// integer 0b1101 << (32 - 7) will wrap to fixed-point 1010...
let large: i32 = 0b1101 << (32 - 7);
let wrapped = Fix::from_bits(0b1010 << (32 - 4));
assert_eq!(Fix::wrapping_from_int(large), wrapped);

pub fn overflowing_from_int<I>(val: I) -> (FixedI32<Frac>, bool) where     I: Int,

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 value can be of type bool, i8, i16, i32, i64, i128, u8, u16, u32, u64, and u128.

Examples

use fixed::frac;
type Fix = fixed::FixedI32<frac::U4>;
// 3 is 0011.0000, that is from_bits(3 << 4)
assert_eq!(Fix::overflowing_from_int(3), (Fix::from_bits(3 << 4), false));
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: i32 = 0b1101 << (32 - 7);
let wrapped = Fix::from_bits(0b1010 << (32 - 4));
assert_eq!(Fix::overflowing_from_int(large), (wrapped, true));

pub fn to_int(self) -> i32

Converts the fixed-point number of type FixedI32 to an integer of type i32 truncating any fractional bits.

Examples

use fixed::frac;
type Fix = fixed::FixedI32<frac::U4>;
let two_half = Fix::from_int(5) / 2;
assert_eq!(two_half.to_int(), 2);
assert_eq!((-two_half).to_int(), -3);

pub fn from_float<F>(val: F) -> FixedI32<Frac> where     F: Float,

Creates a fixed-point number from a floating-point number.

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 always panics if the value is not finite.

If the value is too large to fit, the method panics in debug mode. In release mode, the method may either panic or wrap the value, with the current implementation wrapping the value. It is not considered a breaking change if in the future the method panics even in release mode; if wrapping is the required behavior use wrapping_from_float instead.

Examples

use fixed::frac;
type Fix = fixed::FixedI32<frac::U4>;
// 1.75 is 0001.1100, that is from_bits(28)
assert_eq!(Fix::from_float(1.75f32), Fix::from_bits(28));
assert_eq!(Fix::from_float(-1.75f64), Fix::from_bits(-28));
// 1e-10 is too small for four fractional bits
assert_eq!(Fix::from_float(1e-10), Fix::from_bits(0));

pub fn checked_from_float<F>(val: F) -> Option<FixedI32<Frac>> where     F: Float,

Creates a fixed-point number from a floating-point number, or returns None if the value is not finite or 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.

Examples

use fixed::frac;
use std::f64;
type Fix = fixed::FixedI32<frac::U4>;
// 1.75 is 0001.1100, that is from_bits(28)
assert_eq!(Fix::checked_from_float(1.75f32), Some(Fix::from_bits(28)));
assert_eq!(Fix::checked_from_float(-1.75f64), Some(Fix::from_bits(-28)));
// 1e-10 is too small for four fractional bits
assert_eq!(Fix::checked_from_float(1e-10), Some(Fix::from_bits(0)));
// 2e38 is too large for FixedI32<frac::U4>
assert!(Fix::checked_from_float(2e38).is_none());
assert!(Fix::checked_from_float(f64::NEG_INFINITY).is_none());
assert!(Fix::checked_from_float(f64::NAN).is_none());

pub fn saturating_from_float<F>(val: F) -> FixedI32<Frac> where     F: Float,

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 fixed::frac;
use std::f64;
type Fix = fixed::FixedI32<frac::U4>;
// 1.75 is 0001.1100, that is from_bits(28)
assert_eq!(Fix::saturating_from_float(1.75f32), Fix::from_bits(28));
assert_eq!(Fix::saturating_from_float(-1.75f64), Fix::from_bits(-28));
// 1e-10 is too small for four fractional bits
assert_eq!(Fix::saturating_from_float(1e-10), Fix::from_bits(0));
// 2e38 is too large for FixedI32<frac::U4>
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_float<F>(val: F) -> FixedI32<Frac> where     F: Float,

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

use fixed::frac;
type Fix = fixed::FixedI32<frac::U4>;
// 1.75 is 0001.1100, that is from_bits(28)
let from_bits = Fix::from_bits(28);
assert_eq!(Fix::wrapping_from_float(1.75f32), from_bits);
assert_eq!(Fix::wrapping_from_float(-1.75f64), -from_bits);
// 1e-10 is too small for four fractional bits
assert_eq!(Fix::wrapping_from_float(1e-10), 0);
// 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_float<F>(val: F) -> (FixedI32<Frac>, bool) where     F: Float,

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

use fixed::frac;
type Fix = fixed::FixedI32<frac::U4>;
// 1.75 is 0001.1100, that is from_bits(28)
let from_bits = Fix::from_bits(28);
assert_eq!(Fix::overflowing_from_float(1.75f32), (from_bits, false));
assert_eq!(Fix::overflowing_from_float(-1.75f64), (-from_bits, false));
// 1e-10 is too small for four fractional bits
assert_eq!(Fix::overflowing_from_float(1e-10), (Fix::from_bits(0), false));
// 1.75 << (32 - 4) overflows and 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 to_float<F>(self) -> F where     F: Float,

Converts the fixed-point number to a floating-point number.

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.

Examples

use fixed::frac;
type Fix = fixed::FixedI32<frac::U4>;
// 1.75 is 0001.1100, that is from_bits(28)
assert_eq!(Fix::from_bits(28).to_float::<f32>(), 1.75f32);
assert_eq!(Fix::from_bits(-28).to_float::<f64>(), -1.75f64);

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

Returns the integer part.

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

Examples

use fixed::frac;
type Fix = fixed::FixedI32<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);
// 1101.0000
let three = Fix::from_int(3);
// 1101.1100
assert_eq!((-two_and_quarter).int(), -three);

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

Returns the fractional part.

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

Examples

use fixed::frac;
type Fix = fixed::FixedI32<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);
// 0000.1100
let three_quarters = quarter * 3;
// 1101.1100
assert_eq!((-two_and_quarter).frac(), three_quarters);

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

Rounds to the next integer towards +∞.

Panics

If the result is too large to fit, the method panics in debug mode. In release mode, the method may either panic or wrap the value, with the current implementation wrapping the value. It is not considered a breaking change if in the future the method panics even in release mode; if wrapping is the required behavior use wrapping_ceil instead.

Examples

use fixed::frac;
type Fix = fixed::FixedI32<frac::U4>;
let two_half = Fix::from_int(5) / 2;
assert_eq!(two_half.ceil(), Fix::from_int(3));
assert_eq!((-two_half).ceil(), Fix::from_int(-2));

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

Rounds to the next integer towards −∞.

Panics

If the result is too large to fit, the method panics in debug mode. In release mode, the method may either panic or wrap the value, with the current implementation wrapping the value. It is not considered a breaking change if in the future the method panics even in release mode; if wrapping is the required behavior use wrapping_floor instead.

Overflow can only occur when there are zero integer bits.

Examples

use fixed::frac;
type Fix = fixed::FixedI32<frac::U4>;
let two_half = Fix::from_int(5) / 2;
assert_eq!(two_half.floor(), Fix::from_int(2));
assert_eq!((-two_half).floor(), Fix::from_int(-3));

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

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

Panics

If the result is too large to fit, the method panics in debug mode. In release mode, the method may either panic or wrap the value, with the current implementation wrapping the value. It is not considered a breaking change if in the future the method panics even in release mode; if wrapping is the required behavior use wrapping_round instead.

Examples

use fixed::frac;
type Fix = fixed::FixedI32<frac::U4>;
let two_half = Fix::from_int(5) / 2;
assert_eq!(two_half.round(), Fix::from_int(3));
assert_eq!((-two_half).round(), Fix::from_int(-3));

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

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

Examples

use fixed::frac;
type Fix = fixed::FixedI32<frac::U4>;
let two_half = Fix::from_int(5) / 2;
assert_eq!(two_half.checked_ceil(), Some(Fix::from_int(3)));
assert_eq!((-two_half).checked_ceil(), Some(Fix::from_int(-2)));
assert!(Fix::max_value().checked_ceil().is_none());

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

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

Overflow can only occur when there are zero integer bits.

Examples

use fixed::frac;
type Fix = fixed::FixedI32<frac::U4>;
let two_half = Fix::from_int(5) / 2;
assert_eq!(two_half.checked_floor(), Some(Fix::from_int(2)));
assert_eq!((-two_half).checked_floor(), Some(Fix::from_int(-3)));
type AllFrac = fixed::FixedI32<frac::U32>;
assert!(AllFrac::min_value().checked_floor().is_none());

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

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

Examples

use fixed::frac;
type Fix = fixed::FixedI32<frac::U4>;
let two_half = Fix::from_int(5) / 2;
assert_eq!(two_half.checked_round(), Some(Fix::from_int(3)));
assert_eq!((-two_half).checked_round(), Some(Fix::from_int(-3)));
assert!(Fix::max_value().checked_round().is_none());

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

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

Examples

use fixed::frac;
type Fix = fixed::FixedI32<frac::U4>;
let two_half = Fix::from_int(5) / 2;
assert_eq!(two_half.saturating_ceil(), Fix::from_int(3));
assert_eq!((-two_half).saturating_ceil(), Fix::from_int(-2));
assert_eq!(Fix::max_value().saturating_ceil(), Fix::max_value());

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

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

Overflow can only occur when there are zero integer bits.

Examples

use fixed::frac;
type Fix = fixed::FixedI32<frac::U4>;
let two_half = Fix::from_int(5) / 2;
assert_eq!(two_half.saturating_floor(), Fix::from_int(2));
assert_eq!((-two_half).saturating_floor(), Fix::from_int(-3));
type AllFrac = fixed::FixedI32<frac::U32>;
assert_eq!(AllFrac::min_value().saturating_floor(), AllFrac::min_value());

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

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

Examples

use fixed::frac;
type Fix = fixed::FixedI32<frac::U4>;
let two_half = Fix::from_int(5) / 2;
assert_eq!(two_half.saturating_round(), Fix::from_int(3));
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) -> FixedI32<Frac>

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

Examples

use fixed::frac;
type Fix = fixed::FixedI32<frac::U4>;
let two_half = Fix::from_int(5) / 2;
assert_eq!(two_half.wrapping_ceil(), Fix::from_int(3));
assert_eq!((-two_half).wrapping_ceil(), Fix::from_int(-2));
assert_eq!(Fix::max_value().wrapping_ceil(), Fix::min_value());

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

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

Overflow can only occur when there are zero integer bits.

Examples

use fixed::frac;
type Fix = fixed::FixedI32<frac::U4>;
let two_half = Fix::from_int(5) / 2;
assert_eq!(two_half.wrapping_floor(), Fix::from_int(2));
assert_eq!((-two_half).wrapping_floor(), Fix::from_int(-3));
type AllFrac = fixed::FixedI32<frac::U32>;
assert_eq!(AllFrac::min_value().wrapping_floor(), AllFrac::from_int(0));

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

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

Examples

use fixed::frac;
type Fix = fixed::FixedI32<frac::U4>;
let two_half = Fix::from_int(5) / 2;
assert_eq!(two_half.wrapping_round(), Fix::from_int(3));
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) -> (FixedI32<Frac>, bool)

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

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

Examples

use fixed::frac;
type Fix = fixed::FixedI32<frac::U4>;
let two_half = Fix::from_int(5) / 2;
assert_eq!(two_half.overflowing_ceil(), (Fix::from_int(3), false));
assert_eq!((-two_half).overflowing_ceil(), (Fix::from_int(-2), false));
assert_eq!(Fix::max_value().overflowing_ceil(), (Fix::min_value(), true));

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

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

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

Examples

use fixed::frac;
type Fix = fixed::FixedI32<frac::U4>;
let two_half = Fix::from_int(5) / 2;
assert_eq!(two_half.overflowing_floor(), (Fix::from_int(2), false));
assert_eq!((-two_half).overflowing_floor(), (Fix::from_int(-3), false));
type AllFrac = fixed::FixedI32<frac::U32>;
assert_eq!(AllFrac::min_value().overflowing_floor(), (AllFrac::from_int(0), true));

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

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

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

Examples

use fixed::frac;
type Fix = fixed::FixedI32<frac::U4>;
let two_half = Fix::from_int(5) / 2;
assert_eq!(two_half.overflowing_round(), (Fix::from_int(3), false));
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

Returns the number of ones in the binary representation.

Examples

use fixed::frac;
type Fix = fixed::FixedI32<frac::U4>;
let f = Fix::from_bits(0b11_0010);
assert_eq!(f.count_ones(), 3);

pub fn count_zeros(self) -> u32

Returns the number of zeros in the binary representation.

Examples

use fixed::frac;
type Fix = fixed::FixedI32<frac::U4>;
let f = Fix::from_bits(!0b11_0010);
assert_eq!(f.count_zeros(), 3);

pub fn leading_zeros(self) -> u32

Returns the number of leading zeros in the binary representation.

Examples

use fixed::frac;
type Fix = fixed::FixedI32<frac::U4>;
let f = Fix::from_bits(0b10_0000);
assert_eq!(f.leading_zeros(), 32 - 6);

pub fn trailing_zeros(self) -> u32

Returns the number of trailing zeros in the binary representation.

Examples

use fixed::frac;
type Fix = fixed::FixedI32<frac::U4>;
let f = Fix::from_bits(0b10_0000);
assert_eq!(f.trailing_zeros(), 5);

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

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

Examples

use fixed::frac;
type Fix = fixed::FixedI32<frac::U4>;
let bits: i32 = (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) -> FixedI32<Frac>

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

Examples

use fixed::frac;
type Fix = fixed::FixedI32<frac::U4>;
let bits: i32 = 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<FixedI32<Frac>>

Checked negation.

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

Checked fixed-point addition.

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

Checked fixed-point subtraction.

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

Checked fixed-point multiplication.

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

Checked fixed-point division.

pub fn checked_mul_int(self, rhs: i32) -> Option<FixedI32<Frac>>

Checked fixed-point multiplication by integer.

pub fn checked_div_int(self, rhs: i32) -> Option<FixedI32<Frac>>

Checked fixed-point division by integer.

pub fn checked_rem_int(self, rhs: i32) -> Option<FixedI32<Frac>>

Checked fixed-point remainder for division by integer.

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

Checked fixed-point left shift.

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

Checked fixed-point right shift.

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

Checked absolute value.

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

Saturating fixed-point addition.

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

Saturating fixed-point subtraction.

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

Saturating fixed-point multiplication.

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

Saturating fixed-point division.

pub fn saturating_mul_int(self, rhs: i32) -> FixedI32<Frac>

Saturating fixed-point multiplication by integer.

pub fn wrapping_neg(self) -> FixedI32<Frac>

Wrapping negation.

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

Wrapping fixed-point addition.

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

Wrapping fixed-point subtraction.

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

Wrapping fixed-point multiplication.

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

Wrapping fixed-point division.

pub fn wrapping_mul_int(self, rhs: i32) -> FixedI32<Frac>

Wrapping fixed-point multiplication by integer.

pub fn wrapping_div_int(self, rhs: i32) -> FixedI32<Frac>

Wrapping fixed-point division by integer.

pub fn wrapping_rem_int(self, rhs: i32) -> FixedI32<Frac>

Wrapping fixed-point remainder for division by integer.

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

Wrapping fixed-point left shift.

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

Wrapping fixed-point right shift.

pub fn wrapping_abs(self) -> FixedI32<Frac>

Wrapping absolute value.

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

Overflowing negation.

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

Overflowing fixed-point addition.

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

Overflowing fixed-point subtraction.

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

Overflowing fixed-point multiplication.

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

Overflowing fixed-point division.

pub fn overflowing_mul_int(self, rhs: i32) -> (FixedI32<Frac>, bool)

Overflowing fixed-point multiplication by integer.

pub fn overflowing_div_int(self, rhs: i32) -> (FixedI32<Frac>, bool)

Overflowing fixed-point division by integer.

pub fn overflowing_rem_int(self, rhs: i32) -> (FixedI32<Frac>, bool)

Overflowing fixed-point remainder for division by integer.

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

Overflowing fixed-point left shift.

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

Overflowing fixed-point right shift.

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

Overflowing absolute value.

pub fn abs(self) -> FixedI32<Frac>

Returns the absolute value.

Examples

use fixed::frac;
type Fix = fixed::FixedI32<frac::U4>;
let five = Fix::from_int(5);
let minus_five = Fix::from_int(-5);
assert_eq!(five.abs(), five);
assert_eq!(minus_five.abs(), five);

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

Returns a number representing the sign of self.

Panics

This method panics:

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

Examples

use fixed::frac;
type Fix = fixed::FixedI32<frac::U4>;
assert_eq!(Fix::from_int(5).signum(), 1);
assert_eq!(Fix::from_int(0).signum(), 0);
assert_eq!(Fix::from_int(-5).signum(), -1);

pub fn is_positive(self) -> bool

Returns true if the number is > 0.

Examples

use fixed::frac;
type Fix = fixed::FixedI32<frac::U4>;
assert!(Fix::from_int(5).is_positive());
assert!(!Fix::from_int(0).is_positive());
assert!(!Fix::from_int(-5).is_positive());

pub fn is_negative(self) -> bool

Returns true if the number is < 0.

Examples

use fixed::frac;
type Fix = fixed::FixedI32<frac::U4>;
assert!(!Fix::from_int(5).is_negative());
assert!(!Fix::from_int(0).is_negative());
assert!(Fix::from_int(-5).is_negative());

pub fn to_int_ceil(self) -> i32

Deprecated since 0.2.0:

use f.ceil().to_int() instead

Converts the fixed-point number of type FixedI32 to an integer of type i32, rounding towards +∞.

pub fn to_int_floor(self) -> i32

Deprecated since 0.2.0:

use f.floor().to_int() instead

Converts the fixed-point number of type FixedI32 to an integer of type i32 rounding towards −∞.

pub fn to_int_round(self) -> i32

Deprecated since 0.2.0:

use f.round().to_int() instead

Converts the fixed-point number of type FixedI32 to an integer of type i32 rounding towards the nearest. Ties are rounded away from zero.

pub fn from_f16(val: f16) -> Option<FixedI32<Frac>>

Deprecated since 0.2.0:

replaced by checked_from_float

Creates a fixed-point number from f16.

This method has been replaced by checked_from_float.

pub fn from_f32(val: f32) -> Option<FixedI32<Frac>>

Deprecated since 0.2.0:

replaced by checked_from_float

Creates a fixed-point number from f32.

This method has been replaced by checked_from_float.

pub fn from_f64(val: f64) -> Option<FixedI32<Frac>>

Deprecated since 0.2.0:

replaced by checked_from_float

Creates a fixed-point number from f64.

This method has been replaced by checked_from_float.

pub fn to_f16(self) -> f16

Deprecated since 0.2.0:

replaced by to_float

Converts the fixed-point number to f16.

This method has been replaced by to_float.

pub fn to_f32(self) -> f32

Deprecated since 0.2.0:

replaced by to_float

Converts the fixed-point number to f32.

This method has been replaced by to_float.

pub fn to_f64(self) -> f64

Deprecated since 0.2.0:

replaced by to_float

Converts the fixed-point number to f64.

This method has been replaced by to_float.

Trait Implementations

impl<Frac> Fixed for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

impl<Frac> Copy for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

impl<Frac> Display for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

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

Formats the value using the given formatter.

impl<Frac> Debug for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

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

Formats the value using the given formatter.

impl<Frac> Sub<FixedI32<Frac>> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the - operator.

fn sub(self, rhs: FixedI32<Frac>) -> FixedI32<Frac>

Performs the - operation.

impl<'a, Frac> Sub<FixedI32<Frac>> for &'a FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the - operator.

fn sub(self, rhs: FixedI32<Frac>) -> FixedI32<Frac>

Performs the - operation.

impl<'a, Frac> Sub<&'a FixedI32<Frac>> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the - operator.

fn sub(self, rhs: &FixedI32<Frac>) -> FixedI32<Frac>

Performs the - operation.

impl<'a, 'b, Frac> Sub<&'a FixedI32<Frac>> for &'b FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the - operator.

fn sub(self, rhs: &FixedI32<Frac>) -> FixedI32<Frac>

Performs the - operation.

impl<Frac, FracRhs> PartialEq<FixedI32<FracRhs>> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,     FracRhs: Unsigned + IsLessOrEqual<U32, Output = True>,

fn eq(&self, rhs: &FixedI32<FracRhs>) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<Frac> PartialEq<i32> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

fn eq(&self, rhs: &i32) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<Frac> PartialEq<FixedI32<Frac>> for i32 where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

fn eq(&self, rhs: &FixedI32<Frac>) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<Frac> Eq for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

impl<Frac> Ord for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

fn cmp(&self, rhs: &FixedI32<Frac>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

impl<Frac, FracRhs> PartialOrd<FixedI32<FracRhs>> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,     FracRhs: Unsigned + IsLessOrEqual<U32, Output = True>,

fn partial_cmp(&self, rhs: &FixedI32<FracRhs>) -> Option<Ordering>

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

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

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

fn le(&self, rhs: &FixedI32<FracRhs>) -> bool

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

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

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

fn ge(&self, rhs: &FixedI32<FracRhs>) -> bool

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

impl<Frac> PartialOrd<i32> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

fn partial_cmp(&self, rhs: &i32) -> Option<Ordering>

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

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

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

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

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

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

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

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

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

impl<Frac> PartialOrd<FixedI32<Frac>> for i32 where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

fn partial_cmp(&self, rhs: &FixedI32<Frac>) -> Option<Ordering>

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

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

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

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

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

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

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

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

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

impl<Frac> Hash for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

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

Feeds this value into the given [Hasher].

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

Feeds a slice of this type into the given [Hasher].

impl<FracSrc, FracDst, FracMax> From<FixedI8<FracSrc>> for FixedI32<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,

fn from(src: FixedI8<FracSrc>) -> FixedI32<FracDst>

Performs the conversion.

impl<FracSrc, FracDst, FracMax> From<FixedU8<FracSrc>> for FixedI32<FracDst> where     FracSrc: Unsigned + IsLessOrEqual<U8, Output = True> + Add<<<U32 as Sub<U8>>::Output as Sub<U1>>::Output, Output = FracMax>,     FracDst: Unsigned + IsLessOrEqual<U32, Output = True> + IsGreaterOrEqual<FracSrc, Output = True> + IsLessOrEqual<FracMax, Output = True>,     FracMax: Unsigned,

fn from(src: FixedU8<FracSrc>) -> FixedI32<FracDst>

Performs the conversion.

impl<FracSrc, FracDst, FracMax> From<FixedI16<FracSrc>> for FixedI32<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,

fn from(src: FixedI16<FracSrc>) -> FixedI32<FracDst>

Performs the conversion.

impl<FracSrc, FracDst, FracMax> From<FixedU16<FracSrc>> for FixedI32<FracDst> where     FracSrc: Unsigned + IsLessOrEqual<U16, Output = True> + Add<<<U32 as Sub<U16>>::Output as Sub<U1>>::Output, Output = FracMax>,     FracDst: Unsigned + IsLessOrEqual<U32, Output = True> + IsGreaterOrEqual<FracSrc, Output = True> + IsLessOrEqual<FracMax, Output = True>,     FracMax: Unsigned,

fn from(src: FixedU16<FracSrc>) -> FixedI32<FracDst>

Performs the conversion.

impl<FracSrc, FracDst, FracMax> From<FixedI32<FracSrc>> for FixedI64<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,

fn from(src: FixedI32<FracSrc>) -> FixedI64<FracDst>

Performs the conversion.

impl<FracSrc, FracDst, FracMax> From<FixedI32<FracSrc>> for FixedI128<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,

fn from(src: FixedI32<FracSrc>) -> FixedI128<FracDst>

Performs the conversion.

impl<FracDst> From<i8> for FixedI32<FracDst> where     FracDst: Unsigned + IsLessOrEqual<U32, Output = True> + IsLessOrEqual<<U32 as Sub<U8>>::Output, Output = True>,

fn from(src: i8) -> FixedI32<FracDst>

Performs the conversion.

impl<FracDst> From<u8> for FixedI32<FracDst> where     FracDst: Unsigned + IsLessOrEqual<U32, Output = True> + IsLessOrEqual<<<U32 as Sub<U8>>::Output as Sub<U1>>::Output, Output = True>,

fn from(src: u8) -> FixedI32<FracDst>

Performs the conversion.

impl<FracDst> From<i16> for FixedI32<FracDst> where     FracDst: Unsigned + IsLessOrEqual<U32, Output = True> + IsLessOrEqual<<U32 as Sub<U16>>::Output, Output = True>,

fn from(src: i16) -> FixedI32<FracDst>

Performs the conversion.

impl<FracDst> From<u16> for FixedI32<FracDst> where     FracDst: Unsigned + IsLessOrEqual<U32, Output = True> + IsLessOrEqual<<<U32 as Sub<U16>>::Output as Sub<U1>>::Output, Output = True>,

fn from(src: u16) -> FixedI32<FracDst>

Performs the conversion.

impl From<i32> for FixedI32<U0>

fn from(src: i32) -> FixedI32<U0>

Performs the conversion.

impl<FracDst> From<bool> for FixedI32<FracDst> where     FracDst: Unsigned + IsLessOrEqual<U32, Output = True> + IsLessOrEqual<<U32 as Sub<U2>>::Output, Output = True>,

fn from(src: bool) -> FixedI32<FracDst>

Performs the conversion.

impl From<FixedI32<UTerm>> for i32

fn from(src: FixedI32<U0>) -> i32

Performs the conversion.

impl From<FixedI32<UTerm>> for i64

fn from(src: FixedI32<U0>) -> i64

Performs the conversion.

impl From<FixedI32<UTerm>> for i128

fn from(src: FixedI32<U0>) -> i128

Performs the conversion.

impl<Frac> From<FixedI32<Frac>> for f64 where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

fn from(src: FixedI32<Frac>) -> f64

Performs the conversion.

impl<Frac> Add<FixedI32<Frac>> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'a, Frac> Add<FixedI32<Frac>> for &'a FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'a, Frac> Add<&'a FixedI32<Frac>> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'a, 'b, Frac> Add<&'a FixedI32<Frac>> for &'b FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<Frac> Mul<FixedI32<Frac>> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the * operator.

fn mul(self, rhs: FixedI32<Frac>) -> FixedI32<Frac>

Performs the * operation.

impl<'a, Frac> Mul<FixedI32<Frac>> for &'a FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the * operator.

fn mul(self, rhs: FixedI32<Frac>) -> FixedI32<Frac>

Performs the * operation.

impl<'a, Frac> Mul<&'a FixedI32<Frac>> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the * operator.

fn mul(self, rhs: &FixedI32<Frac>) -> FixedI32<Frac>

Performs the * operation.

impl<'a, 'b, Frac> Mul<&'a FixedI32<Frac>> for &'b FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the * operator.

fn mul(self, rhs: &FixedI32<Frac>) -> FixedI32<Frac>

Performs the * operation.

impl<Frac> Mul<i32> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the * operator.

fn mul(self, rhs: i32) -> FixedI32<Frac>

Performs the * operation.

impl<Frac> Mul<FixedI32<Frac>> for i32 where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the * operator.

fn mul(self, rhs: FixedI32<Frac>) -> FixedI32<Frac>

Performs the * operation.

impl<'a, Frac> Mul<i32> for &'a FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the * operator.

fn mul(self, rhs: i32) -> FixedI32<Frac>

Performs the * operation.

impl<'a, Frac> Mul<&'a FixedI32<Frac>> for i32 where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the * operator.

fn mul(self, rhs: &FixedI32<Frac>) -> FixedI32<Frac>

Performs the * operation.

impl<'a, Frac> Mul<&'a i32> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the * operator.

fn mul(self, rhs: &i32) -> FixedI32<Frac>

Performs the * operation.

impl<'a, Frac> Mul<FixedI32<Frac>> for &'a i32 where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the * operator.

fn mul(self, rhs: FixedI32<Frac>) -> FixedI32<Frac>

Performs the * operation.

impl<'a, 'b, Frac> Mul<&'a i32> for &'b FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the * operator.

fn mul(self, rhs: &i32) -> FixedI32<Frac>

Performs the * operation.

impl<'a, 'b, Frac> Mul<&'a FixedI32<Frac>> for &'b i32 where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the * operator.

fn mul(self, rhs: &FixedI32<Frac>) -> FixedI32<Frac>

Performs the * operation.

impl<Frac> Div<FixedI32<Frac>> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'a, Frac> Div<FixedI32<Frac>> for &'a FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'a, Frac> Div<&'a FixedI32<Frac>> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'a, 'b, Frac> Div<&'a FixedI32<Frac>> for &'b FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<Frac> Div<i32> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'a, Frac> Div<i32> for &'a FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'a, Frac> Div<&'a i32> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'a, 'b, Frac> Div<&'a i32> for &'b FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<Frac> Rem<i32> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the % operator.

fn rem(self, rhs: i32) -> FixedI32<Frac>

Performs the % operation.

impl<'a, Frac> Rem<i32> for &'a FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the % operator.

fn rem(self, rhs: i32) -> FixedI32<Frac>

Performs the % operation.

impl<'a, Frac> Rem<&'a i32> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the % operator.

fn rem(self, rhs: &i32) -> FixedI32<Frac>

Performs the % operation.

impl<'a, 'b, Frac> Rem<&'a i32> for &'b FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the % operator.

fn rem(self, rhs: &i32) -> FixedI32<Frac>

Performs the % operation.

impl<Frac> Neg for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the - operator.

fn neg(self) -> FixedI32<Frac>

Performs the unary - operation.

impl<'a, Frac> Neg for &'a FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the - operator.

fn neg(self) -> FixedI32<Frac>

Performs the unary - operation.

impl<Frac> AddAssign<FixedI32<Frac>> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

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

Performs the += operation.

impl<'a, Frac> AddAssign<&'a FixedI32<Frac>> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

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

Performs the += operation.

impl<Frac> SubAssign<FixedI32<Frac>> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

fn sub_assign(&mut self, rhs: FixedI32<Frac>)

Performs the -= operation.

impl<'a, Frac> SubAssign<&'a FixedI32<Frac>> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

fn sub_assign(&mut self, rhs: &FixedI32<Frac>)

Performs the -= operation.

impl<Frac> MulAssign<FixedI32<Frac>> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

fn mul_assign(&mut self, rhs: FixedI32<Frac>)

Performs the *= operation.

impl<'a, Frac> MulAssign<&'a FixedI32<Frac>> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

fn mul_assign(&mut self, rhs: &FixedI32<Frac>)

Performs the *= operation.

impl<Frac> MulAssign<i32> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

fn mul_assign(&mut self, rhs: i32)

Performs the *= operation.

impl<'a, Frac> MulAssign<&'a i32> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

fn mul_assign(&mut self, rhs: &i32)

Performs the *= operation.

impl<Frac> DivAssign<FixedI32<Frac>> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

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

Performs the /= operation.

impl<'a, Frac> DivAssign<&'a FixedI32<Frac>> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

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

Performs the /= operation.

impl<Frac> DivAssign<i32> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

fn div_assign(&mut self, rhs: i32)

Performs the /= operation.

impl<'a, Frac> DivAssign<&'a i32> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

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

Performs the /= operation.

impl<Frac> RemAssign<i32> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

fn rem_assign(&mut self, rhs: i32)

Performs the %= operation.

impl<'a, Frac> RemAssign<&'a i32> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

fn rem_assign(&mut self, rhs: &i32)

Performs the %= operation.

impl<Frac> Not for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the ! operator.

fn not(self) -> FixedI32<Frac>

Performs the unary ! operation.

impl<'a, Frac> Not for &'a FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the ! operator.

fn not(self) -> FixedI32<Frac>

Performs the unary ! operation.

impl<Frac> BitAnd<FixedI32<Frac>> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the & operator.

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

Performs the & operation.

impl<'a, Frac> BitAnd<FixedI32<Frac>> for &'a FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the & operator.

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

Performs the & operation.

impl<'a, Frac> BitAnd<&'a FixedI32<Frac>> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the & operator.

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

Performs the & operation.

impl<'a, 'b, Frac> BitAnd<&'a FixedI32<Frac>> for &'b FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the & operator.

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

Performs the & operation.

impl<Frac> BitOr<FixedI32<Frac>> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the | operator.

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

Performs the | operation.

impl<'a, Frac> BitOr<FixedI32<Frac>> for &'a FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the | operator.

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

Performs the | operation.

impl<'a, Frac> BitOr<&'a FixedI32<Frac>> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the | operator.

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

Performs the | operation.

impl<'a, 'b, Frac> BitOr<&'a FixedI32<Frac>> for &'b FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the | operator.

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

Performs the | operation.

impl<Frac> BitXor<FixedI32<Frac>> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<'a, Frac> BitXor<FixedI32<Frac>> for &'a FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<'a, Frac> BitXor<&'a FixedI32<Frac>> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<'a, 'b, Frac> BitXor<&'a FixedI32<Frac>> for &'b FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<Frac> Shl<i8> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: i8) -> FixedI32<Frac>

Performs the << operation.

impl<'a, Frac> Shl<i8> for &'a FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: i8) -> FixedI32<Frac>

Performs the << operation.

impl<'a, Frac> Shl<&'a i8> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: &i8) -> FixedI32<Frac>

Performs the << operation.

impl<'a, 'b, Frac> Shl<&'a i8> for &'b FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: &i8) -> FixedI32<Frac>

Performs the << operation.

impl<Frac> Shl<i16> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: i16) -> FixedI32<Frac>

Performs the << operation.

impl<'a, Frac> Shl<i16> for &'a FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: i16) -> FixedI32<Frac>

Performs the << operation.

impl<'a, Frac> Shl<&'a i16> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: &i16) -> FixedI32<Frac>

Performs the << operation.

impl<'a, 'b, Frac> Shl<&'a i16> for &'b FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: &i16) -> FixedI32<Frac>

Performs the << operation.

impl<Frac> Shl<i32> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: i32) -> FixedI32<Frac>

Performs the << operation.

impl<'a, Frac> Shl<i32> for &'a FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: i32) -> FixedI32<Frac>

Performs the << operation.

impl<'a, Frac> Shl<&'a i32> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: &i32) -> FixedI32<Frac>

Performs the << operation.

impl<'a, 'b, Frac> Shl<&'a i32> for &'b FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: &i32) -> FixedI32<Frac>

Performs the << operation.

impl<Frac> Shl<i64> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: i64) -> FixedI32<Frac>

Performs the << operation.

impl<'a, Frac> Shl<i64> for &'a FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: i64) -> FixedI32<Frac>

Performs the << operation.

impl<'a, Frac> Shl<&'a i64> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: &i64) -> FixedI32<Frac>

Performs the << operation.

impl<'a, 'b, Frac> Shl<&'a i64> for &'b FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: &i64) -> FixedI32<Frac>

Performs the << operation.

impl<Frac> Shl<i128> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: i128) -> FixedI32<Frac>

Performs the << operation.

impl<'a, Frac> Shl<i128> for &'a FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: i128) -> FixedI32<Frac>

Performs the << operation.

impl<'a, Frac> Shl<&'a i128> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: &i128) -> FixedI32<Frac>

Performs the << operation.

impl<'a, 'b, Frac> Shl<&'a i128> for &'b FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: &i128) -> FixedI32<Frac>

Performs the << operation.

impl<Frac> Shl<isize> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: isize) -> FixedI32<Frac>

Performs the << operation.

impl<'a, Frac> Shl<isize> for &'a FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: isize) -> FixedI32<Frac>

Performs the << operation.

impl<'a, Frac> Shl<&'a isize> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: &isize) -> FixedI32<Frac>

Performs the << operation.

impl<'a, 'b, Frac> Shl<&'a isize> for &'b FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: &isize) -> FixedI32<Frac>

Performs the << operation.

impl<Frac> Shl<u8> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: u8) -> FixedI32<Frac>

Performs the << operation.

impl<'a, Frac> Shl<u8> for &'a FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: u8) -> FixedI32<Frac>

Performs the << operation.

impl<'a, Frac> Shl<&'a u8> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: &u8) -> FixedI32<Frac>

Performs the << operation.

impl<'a, 'b, Frac> Shl<&'a u8> for &'b FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: &u8) -> FixedI32<Frac>

Performs the << operation.

impl<Frac> Shl<u16> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: u16) -> FixedI32<Frac>

Performs the << operation.

impl<'a, Frac> Shl<u16> for &'a FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: u16) -> FixedI32<Frac>

Performs the << operation.

impl<'a, Frac> Shl<&'a u16> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: &u16) -> FixedI32<Frac>

Performs the << operation.

impl<'a, 'b, Frac> Shl<&'a u16> for &'b FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: &u16) -> FixedI32<Frac>

Performs the << operation.

impl<Frac> Shl<u32> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: u32) -> FixedI32<Frac>

Performs the << operation.

impl<'a, Frac> Shl<u32> for &'a FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: u32) -> FixedI32<Frac>

Performs the << operation.

impl<'a, Frac> Shl<&'a u32> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: &u32) -> FixedI32<Frac>

Performs the << operation.

impl<'a, 'b, Frac> Shl<&'a u32> for &'b FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: &u32) -> FixedI32<Frac>

Performs the << operation.

impl<Frac> Shl<u64> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: u64) -> FixedI32<Frac>

Performs the << operation.

impl<'a, Frac> Shl<u64> for &'a FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: u64) -> FixedI32<Frac>

Performs the << operation.

impl<'a, Frac> Shl<&'a u64> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: &u64) -> FixedI32<Frac>

Performs the << operation.

impl<'a, 'b, Frac> Shl<&'a u64> for &'b FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: &u64) -> FixedI32<Frac>

Performs the << operation.

impl<Frac> Shl<u128> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: u128) -> FixedI32<Frac>

Performs the << operation.

impl<'a, Frac> Shl<u128> for &'a FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: u128) -> FixedI32<Frac>

Performs the << operation.

impl<'a, Frac> Shl<&'a u128> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: &u128) -> FixedI32<Frac>

Performs the << operation.

impl<'a, 'b, Frac> Shl<&'a u128> for &'b FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: &u128) -> FixedI32<Frac>

Performs the << operation.

impl<Frac> Shl<usize> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: usize) -> FixedI32<Frac>

Performs the << operation.

impl<'a, Frac> Shl<usize> for &'a FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: usize) -> FixedI32<Frac>

Performs the << operation.

impl<'a, Frac> Shl<&'a usize> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: &usize) -> FixedI32<Frac>

Performs the << operation.

impl<'a, 'b, Frac> Shl<&'a usize> for &'b FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the << operator.

fn shl(self, rhs: &usize) -> FixedI32<Frac>

Performs the << operation.

impl<Frac> Shr<i8> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: i8) -> FixedI32<Frac>

Performs the >> operation.

impl<'a, Frac> Shr<i8> for &'a FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: i8) -> FixedI32<Frac>

Performs the >> operation.

impl<'a, Frac> Shr<&'a i8> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: &i8) -> FixedI32<Frac>

Performs the >> operation.

impl<'a, 'b, Frac> Shr<&'a i8> for &'b FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: &i8) -> FixedI32<Frac>

Performs the >> operation.

impl<Frac> Shr<i16> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: i16) -> FixedI32<Frac>

Performs the >> operation.

impl<'a, Frac> Shr<i16> for &'a FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: i16) -> FixedI32<Frac>

Performs the >> operation.

impl<'a, Frac> Shr<&'a i16> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: &i16) -> FixedI32<Frac>

Performs the >> operation.

impl<'a, 'b, Frac> Shr<&'a i16> for &'b FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: &i16) -> FixedI32<Frac>

Performs the >> operation.

impl<Frac> Shr<i32> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: i32) -> FixedI32<Frac>

Performs the >> operation.

impl<'a, Frac> Shr<i32> for &'a FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: i32) -> FixedI32<Frac>

Performs the >> operation.

impl<'a, Frac> Shr<&'a i32> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: &i32) -> FixedI32<Frac>

Performs the >> operation.

impl<'a, 'b, Frac> Shr<&'a i32> for &'b FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: &i32) -> FixedI32<Frac>

Performs the >> operation.

impl<Frac> Shr<i64> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: i64) -> FixedI32<Frac>

Performs the >> operation.

impl<'a, Frac> Shr<i64> for &'a FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: i64) -> FixedI32<Frac>

Performs the >> operation.

impl<'a, Frac> Shr<&'a i64> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: &i64) -> FixedI32<Frac>

Performs the >> operation.

impl<'a, 'b, Frac> Shr<&'a i64> for &'b FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: &i64) -> FixedI32<Frac>

Performs the >> operation.

impl<Frac> Shr<i128> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: i128) -> FixedI32<Frac>

Performs the >> operation.

impl<'a, Frac> Shr<i128> for &'a FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: i128) -> FixedI32<Frac>

Performs the >> operation.

impl<'a, Frac> Shr<&'a i128> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: &i128) -> FixedI32<Frac>

Performs the >> operation.

impl<'a, 'b, Frac> Shr<&'a i128> for &'b FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: &i128) -> FixedI32<Frac>

Performs the >> operation.

impl<Frac> Shr<isize> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: isize) -> FixedI32<Frac>

Performs the >> operation.

impl<'a, Frac> Shr<isize> for &'a FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: isize) -> FixedI32<Frac>

Performs the >> operation.

impl<'a, Frac> Shr<&'a isize> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: &isize) -> FixedI32<Frac>

Performs the >> operation.

impl<'a, 'b, Frac> Shr<&'a isize> for &'b FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: &isize) -> FixedI32<Frac>

Performs the >> operation.

impl<Frac> Shr<u8> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: u8) -> FixedI32<Frac>

Performs the >> operation.

impl<'a, Frac> Shr<u8> for &'a FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: u8) -> FixedI32<Frac>

Performs the >> operation.

impl<'a, Frac> Shr<&'a u8> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: &u8) -> FixedI32<Frac>

Performs the >> operation.

impl<'a, 'b, Frac> Shr<&'a u8> for &'b FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: &u8) -> FixedI32<Frac>

Performs the >> operation.

impl<Frac> Shr<u16> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: u16) -> FixedI32<Frac>

Performs the >> operation.

impl<'a, Frac> Shr<u16> for &'a FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: u16) -> FixedI32<Frac>

Performs the >> operation.

impl<'a, Frac> Shr<&'a u16> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: &u16) -> FixedI32<Frac>

Performs the >> operation.

impl<'a, 'b, Frac> Shr<&'a u16> for &'b FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: &u16) -> FixedI32<Frac>

Performs the >> operation.

impl<Frac> Shr<u32> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: u32) -> FixedI32<Frac>

Performs the >> operation.

impl<'a, Frac> Shr<u32> for &'a FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: u32) -> FixedI32<Frac>

Performs the >> operation.

impl<'a, Frac> Shr<&'a u32> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: &u32) -> FixedI32<Frac>

Performs the >> operation.

impl<'a, 'b, Frac> Shr<&'a u32> for &'b FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: &u32) -> FixedI32<Frac>

Performs the >> operation.

impl<Frac> Shr<u64> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: u64) -> FixedI32<Frac>

Performs the >> operation.

impl<'a, Frac> Shr<u64> for &'a FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: u64) -> FixedI32<Frac>

Performs the >> operation.

impl<'a, Frac> Shr<&'a u64> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: &u64) -> FixedI32<Frac>

Performs the >> operation.

impl<'a, 'b, Frac> Shr<&'a u64> for &'b FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: &u64) -> FixedI32<Frac>

Performs the >> operation.

impl<Frac> Shr<u128> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: u128) -> FixedI32<Frac>

Performs the >> operation.

impl<'a, Frac> Shr<u128> for &'a FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: u128) -> FixedI32<Frac>

Performs the >> operation.

impl<'a, Frac> Shr<&'a u128> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: &u128) -> FixedI32<Frac>

Performs the >> operation.

impl<'a, 'b, Frac> Shr<&'a u128> for &'b FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: &u128) -> FixedI32<Frac>

Performs the >> operation.

impl<Frac> Shr<usize> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: usize) -> FixedI32<Frac>

Performs the >> operation.

impl<'a, Frac> Shr<usize> for &'a FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: usize) -> FixedI32<Frac>

Performs the >> operation.

impl<'a, Frac> Shr<&'a usize> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: &usize) -> FixedI32<Frac>

Performs the >> operation.

impl<'a, 'b, Frac> Shr<&'a usize> for &'b FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

type Output = FixedI32<Frac>

The resulting type after applying the >> operator.

fn shr(self, rhs: &usize) -> FixedI32<Frac>

Performs the >> operation.

impl<Frac> BitAndAssign<FixedI32<Frac>> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

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

Performs the &= operation.

impl<'a, Frac> BitAndAssign<&'a FixedI32<Frac>> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

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

Performs the &= operation.

impl<Frac> BitOrAssign<FixedI32<Frac>> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

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

Performs the |= operation.

impl<'a, Frac> BitOrAssign<&'a FixedI32<Frac>> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

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

Performs the |= operation.

impl<Frac> BitXorAssign<FixedI32<Frac>> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

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

Performs the ^= operation.

impl<'a, Frac> BitXorAssign<&'a FixedI32<Frac>> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

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

Performs the ^= operation.

impl<Frac> ShlAssign<i8> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

fn shl_assign(&mut self, rhs: i8)

Performs the <<= operation.

impl<'a, Frac> ShlAssign<&'a i8> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

fn shl_assign(&mut self, rhs: &i8)

Performs the <<= operation.

impl<Frac> ShlAssign<i16> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

fn shl_assign(&mut self, rhs: i16)

Performs the <<= operation.

impl<'a, Frac> ShlAssign<&'a i16> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

fn shl_assign(&mut self, rhs: &i16)

Performs the <<= operation.

impl<Frac> ShlAssign<i32> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

fn shl_assign(&mut self, rhs: i32)

Performs the <<= operation.

impl<'a, Frac> ShlAssign<&'a i32> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

fn shl_assign(&mut self, rhs: &i32)

Performs the <<= operation.

impl<Frac> ShlAssign<i64> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

fn shl_assign(&mut self, rhs: i64)

Performs the <<= operation.

impl<'a, Frac> ShlAssign<&'a i64> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

fn shl_assign(&mut self, rhs: &i64)

Performs the <<= operation.

impl<Frac> ShlAssign<i128> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

fn shl_assign(&mut self, rhs: i128)

Performs the <<= operation.

impl<'a, Frac> ShlAssign<&'a i128> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

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

Performs the <<= operation.

impl<Frac> ShlAssign<isize> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

fn shl_assign(&mut self, rhs: isize)

Performs the <<= operation.

impl<'a, Frac> ShlAssign<&'a isize> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

fn shl_assign(&mut self, rhs: &isize)

Performs the <<= operation.

impl<Frac> ShlAssign<u8> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

fn shl_assign(&mut self, rhs: u8)

Performs the <<= operation.

impl<'a, Frac> ShlAssign<&'a u8> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

fn shl_assign(&mut self, rhs: &u8)

Performs the <<= operation.

impl<Frac> ShlAssign<u16> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

fn shl_assign(&mut self, rhs: u16)

Performs the <<= operation.

impl<'a, Frac> ShlAssign<&'a u16> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

fn shl_assign(&mut self, rhs: &u16)

Performs the <<= operation.

impl<Frac> ShlAssign<u32> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

fn shl_assign(&mut self, rhs: u32)

Performs the <<= operation.

impl<'a, Frac> ShlAssign<&'a u32> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

fn shl_assign(&mut self, rhs: &u32)

Performs the <<= operation.

impl<Frac> ShlAssign<u64> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

fn shl_assign(&mut self, rhs: u64)

Performs the <<= operation.

impl<'a, Frac> ShlAssign<&'a u64> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

fn shl_assign(&mut self, rhs: &u64)

Performs the <<= operation.

impl<Frac> ShlAssign<u128> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

fn shl_assign(&mut self, rhs: u128)

Performs the <<= operation.

impl<'a, Frac> ShlAssign<&'a u128> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

fn shl_assign(&mut self, rhs: &u128)

Performs the <<= operation.

impl<Frac> ShlAssign<usize> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

fn shl_assign(&mut self, rhs: usize)

Performs the <<= operation.

impl<'a, Frac> ShlAssign<&'a usize> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

fn shl_assign(&mut self, rhs: &usize)

Performs the <<= operation.

impl<Frac> ShrAssign<i8> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

fn shr_assign(&mut self, rhs: i8)

Performs the >>= operation.

impl<'a, Frac> ShrAssign<&'a i8> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

fn shr_assign(&mut self, rhs: &i8)

Performs the >>= operation.

impl<Frac> ShrAssign<i16> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

fn shr_assign(&mut self, rhs: i16)

Performs the >>= operation.

impl<'a, Frac> ShrAssign<&'a i16> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

fn shr_assign(&mut self, rhs: &i16)

Performs the >>= operation.

impl<Frac> ShrAssign<i32> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

fn shr_assign(&mut self, rhs: i32)

Performs the >>= operation.

impl<'a, Frac> ShrAssign<&'a i32> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

fn shr_assign(&mut self, rhs: &i32)

Performs the >>= operation.

impl<Frac> ShrAssign<i64> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

fn shr_assign(&mut self, rhs: i64)

Performs the >>= operation.

impl<'a, Frac> ShrAssign<&'a i64> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

fn shr_assign(&mut self, rhs: &i64)

Performs the >>= operation.

impl<Frac> ShrAssign<i128> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

fn shr_assign(&mut self, rhs: i128)

Performs the >>= operation.

impl<'a, Frac> ShrAssign<&'a i128> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

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

Performs the >>= operation.

impl<Frac> ShrAssign<isize> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

fn shr_assign(&mut self, rhs: isize)

Performs the >>= operation.

impl<'a, Frac> ShrAssign<&'a isize> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

fn shr_assign(&mut self, rhs: &isize)

Performs the >>= operation.

impl<Frac> ShrAssign<u8> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

fn shr_assign(&mut self, rhs: u8)

Performs the >>= operation.

impl<'a, Frac> ShrAssign<&'a u8> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

fn shr_assign(&mut self, rhs: &u8)

Performs the >>= operation.

impl<Frac> ShrAssign<u16> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

fn shr_assign(&mut self, rhs: u16)

Performs the >>= operation.

impl<'a, Frac> ShrAssign<&'a u16> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

fn shr_assign(&mut self, rhs: &u16)

Performs the >>= operation.

impl<Frac> ShrAssign<u32> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

fn shr_assign(&mut self, rhs: u32)

Performs the >>= operation.

impl<'a, Frac> ShrAssign<&'a u32> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

fn shr_assign(&mut self, rhs: &u32)

Performs the >>= operation.

impl<Frac> ShrAssign<u64> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

fn shr_assign(&mut self, rhs: u64)

Performs the >>= operation.

impl<'a, Frac> ShrAssign<&'a u64> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

fn shr_assign(&mut self, rhs: &u64)

Performs the >>= operation.

impl<Frac> ShrAssign<u128> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

fn shr_assign(&mut self, rhs: u128)

Performs the >>= operation.

impl<'a, Frac> ShrAssign<&'a u128> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

fn shr_assign(&mut self, rhs: &u128)

Performs the >>= operation.

impl<Frac> ShrAssign<usize> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

fn shr_assign(&mut self, rhs: usize)

Performs the >>= operation.

impl<'a, Frac> ShrAssign<&'a usize> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

fn shr_assign(&mut self, rhs: &usize)

Performs the >>= operation.

impl<Frac> Product<FixedI32<Frac>> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

fn product<I: Iterator<Item = FixedI32<Frac>>>(iter: I) -> FixedI32<Frac>

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

impl<'a, Frac> Product<&'a FixedI32<Frac>> for FixedI32<Frac> where     Frac: 'a + Unsigned + IsLessOrEqual<U32, Output = True>,

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

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

impl<Frac> Sum<FixedI32<Frac>> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

fn sum<I: Iterator<Item = FixedI32<Frac>>>(iter: I) -> FixedI32<Frac>

Method which takes an iterator and generates Self from the elements by "summing up" the items.

impl<'a, Frac> Sum<&'a FixedI32<Frac>> for FixedI32<Frac> where     Frac: 'a + Unsigned + IsLessOrEqual<U32, Output = True>,

fn sum<I: Iterator<Item = &'a FixedI32<Frac>>>(iter: I) -> FixedI32<Frac>

Method which takes an iterator and generates Self from the elements by "summing up" the items.

impl<Frac> Octal for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

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

Formats the value using the given formatter.

impl<Frac> Binary for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

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

Formats the value using the given formatter.

impl<Frac> LowerHex for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

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

Formats the value using the given formatter.

impl<Frac> UpperHex for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

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

Formats the value using the given formatter.

impl<Frac> Clone for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Frac> Default for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

fn default() -> FixedI32<Frac>

Returns the "default value" for a type.

impl<Frac> Serialize for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where     S: Serializer,

Serialize this value into the given Serde serializer.

impl<'de, Frac> Deserialize<'de> for FixedI32<Frac> where     Frac: Unsigned + IsLessOrEqual<U32, Output = True>,

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

Deserialize this value from the given Serde deserializer.