[−][src]Struct fixed::FixedI32

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

A 32-bit fixed-point signed number 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::{types::extra::U3, FixedI32};
let eleven = FixedI32::<U3>::from_num(11);
assert_eq!(eleven, FixedI32::<U3>::from_bits(11 << 3));
assert_eq!(eleven, 11);
assert_eq!(eleven.to_string(), "11");
let two_point_75 = eleven / 4;
assert_eq!(two_point_75, FixedI32::<U3>::from_bits(11 << 1));
assert_eq!(two_point_75, 2.75);
assert_eq!(two_point_75.to_string(), "2.8");

Methods

`impl<Frac> FixedI32<Frac>`[src]

`pub const fn min_value() -> FixedI32<Frac>`[src]

Returns the smallest value that can be represented.

Examples

use fixed::{types::extra::U4, FixedI32};
type Fix = FixedI32<U4>;
assert_eq!(Fix::min_value(), Fix::from_bits(i32::min_value()));

`pub const fn max_value() -> FixedI32<Frac>`[src]

Returns the largest value that can be represented.

Examples

use fixed::{types::extra::U4, FixedI32};
type Fix = FixedI32<U4>;
assert_eq!(Fix::max_value(), Fix::from_bits(i32::max_value()));

`pub const fn from_bits(bits: i32) -> FixedI32<Frac>`[src]

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

Examples

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

`pub const fn to_bits(self) -> i32`[src]

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

Examples

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

`pub const fn count_ones(self) -> u32`[src]

Returns the number of ones in the binary representation.

Examples

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

`pub const fn count_zeros(self) -> u32`[src]

Returns the number of zeros in the binary representation.

Examples

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

`pub const fn leading_zeros(self) -> u32`[src]

Returns the number of leading zeros in the binary representation.

Examples

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

`pub const fn trailing_zeros(self) -> u32`[src]

Returns the number of trailing zeros in the binary representation.

Examples

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

`pub const fn rotate_left(self, n: u32) -> FixedI32<Frac>`[src]

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

Examples

use fixed::{types::extra::U4, FixedI32};
type Fix = FixedI32<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 const fn rotate_right(self, n: u32) -> FixedI32<Frac>`[src]

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

Examples

use fixed::{types::extra::U4, FixedI32};
type Fix = FixedI32<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 abs(self) -> FixedI32<Frac>`[src]

Returns the absolute value.

Examples

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

`pub fn checked_neg(self) -> Option<FixedI32<Frac>>`[src]

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

Overflow can only occur when negating the minimum value.

Examples

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

`pub fn checked_add(self, rhs: FixedI32<Frac>) -> Option<FixedI32<Frac>>`[src]

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

Examples

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

`pub fn checked_sub(self, rhs: FixedI32<Frac>) -> Option<FixedI32<Frac>>`[src]

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

Examples

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

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

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

Examples

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

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

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

Examples

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

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

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

Examples

use fixed::{types::extra::U4, FixedI32};
type Fix = FixedI32<U4>;
// binary 1.0101 / 8 = binary 0.0010 remainder 0.0101
assert_eq!(Fix::from_bits(0b10101).checked_rem_int(8), Some(Fix::from_bits(0b101)));
assert_eq!(Fix::from_num(1).checked_rem_int(0), None);
assert_eq!(Fix::min_value().checked_rem_int(-1), None);

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

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

Examples

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

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

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

Examples

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

`pub fn checked_abs(self) -> Option<FixedI32<Frac>>`[src]

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

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

Examples

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

`pub fn saturating_neg(self) -> FixedI32<Frac>`[src]

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

Overflow can only occur when negating the minimum value.

Examples

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

`pub fn saturating_add(self, rhs: FixedI32<Frac>) -> FixedI32<Frac>`[src]

Saturating addition. Returns the sum, saturating on overflow.

Examples

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

`pub fn saturating_sub(self, rhs: FixedI32<Frac>) -> FixedI32<Frac>`[src]

Saturating subtraction. Returns the difference, saturating on overflow.

Examples

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

`pub fn saturating_mul_int(self, rhs: i32) -> FixedI32<Frac>`[src]

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

Examples

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

`pub fn saturating_abs(self) -> FixedI32<Frac>`[src]

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

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

Examples

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

`pub const fn wrapping_neg(self) -> FixedI32<Frac>`[src]

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

Overflow can only occur when negating the minimum value.

Examples

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

`pub const fn wrapping_add(self, rhs: FixedI32<Frac>) -> FixedI32<Frac>`[src]

Wrapping addition. Returns the sum, wrapping on overflow.

Examples

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

`pub const fn wrapping_sub(self, rhs: FixedI32<Frac>) -> FixedI32<Frac>`[src]

Wrapping subtraction. Returns the difference, wrapping on overflow.

Examples

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

`pub const fn wrapping_mul_int(self, rhs: i32) -> FixedI32<Frac>`[src]

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

Examples

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

`pub fn wrapping_div_int(self, rhs: i32) -> FixedI32<Frac>`[src]

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

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

Panics

Panics if the divisor is zero.

Examples

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

`pub fn wrapping_rem_int(self, rhs: i32) -> FixedI32<Frac>`[src]

Wrapping fixed-point remainder for division by an integer. Returns the remainder, wrapping on overflow.

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

Panics

Panics if the divisor is zero.

Examples

use fixed::{types::extra::U4, FixedI32};
type Fix = FixedI32<U4>;
// binary 1.0101 / 8 = binary 0.0010 remainder 0.0101
assert_eq!(Fix::from_bits(0b10101).wrapping_rem_int(8), Fix::from_bits(0b101));
assert_eq!(Fix::min_value().wrapping_rem_int(-1), 0);

`pub const fn wrapping_shl(self, rhs: u32) -> FixedI32<Frac>`[src]

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

Examples

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

`pub const fn wrapping_shr(self, rhs: u32) -> FixedI32<Frac>`[src]

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

Examples

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

`pub fn wrapping_abs(self) -> FixedI32<Frac>`[src]

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

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

Examples

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

`pub const fn overflowing_neg(self) -> (FixedI32<Frac>, bool)`[src]

Overflowing negation.

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

Overflow can only occur when negating the minimum value.

Examples

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

`pub const fn overflowing_add( self, rhs: FixedI32<Frac> ) -> (FixedI32<Frac>, bool)`[src]

Overflowing addition.

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

Examples

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

`pub const fn overflowing_sub( self, rhs: FixedI32<Frac> ) -> (FixedI32<Frac>, bool)`[src]

Overflowing subtraction.

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

Examples

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

`pub const fn overflowing_mul_int(self, rhs: i32) -> (FixedI32<Frac>, bool)`[src]

Overflowing multiplication by an integer.

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

Examples

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

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

Overflowing division by an integer.

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

Panics

Panics if the divisor is zero.

Examples

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

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

Overflowing fixed-point remainder for division by an integer.

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

Panics

Panics if the divisor is zero.

Examples

use fixed::{types::extra::U4, FixedI32};
type Fix = FixedI32<U4>;
// binary 1.0101 / 8 = binary 0.0010 remainder 0.0101
assert_eq!(Fix::from_bits(0b10101).overflowing_rem_int(8), (Fix::from_bits(0b101), false));
assert_eq!(Fix::min_value().overflowing_rem_int(-1), (Fix::from_num(0), true));

`pub const fn overflowing_shl(self, rhs: u32) -> (FixedI32<Frac>, bool)`[src]

Overflowing shift left.

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

Examples

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

`pub const fn overflowing_shr(self, rhs: u32) -> (FixedI32<Frac>, bool)`[src]

Overflowing shift right.

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

Examples

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

`pub fn overflowing_abs(self) -> (FixedI32<Frac>, bool)`[src]

Overflowing absolute value.

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

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

Examples

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

`pub const fn is_positive(self) -> bool`[src]

Returns true if the number is > 0.

Examples

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

`pub const fn is_negative(self) -> bool`[src]

Returns true if the number is < 0.

Examples

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

`impl<Frac: LeEqU32> FixedI32<Frac>`[src]

`pub const INT_NBITS: u32`[src]

The number of integer bits.

Examples

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

`pub const FRAC_NBITS: u32`[src]

The number of fractional bits.

Examples

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

`pub fn int_nbits() -> u32`[src]

Returns the number of integer bits.

Examples

use fixed::{types::extra::U6, FixedI32};
type Fix = FixedI32<U6>;
assert_eq!(Fix::int_nbits(), 32 - 6);

`pub fn frac_nbits() -> u32`[src]

Returns the number of fractional bits.

Examples

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

`pub fn from_num<Src: ToFixed>(src: Src) -> FixedI32<Frac>`[src]

Creates a fixed-point number from another number.

The other number can be:

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

Panics

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

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

Examples

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

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

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

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

`pub fn to_num<Dst: FromFixed>(self) -> Dst`[src]

Converts a fixed-point number to another number.

The other number can be:

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

Panics

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

Examples

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

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

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

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

`pub fn checked_from_num<Src: ToFixed>(src: Src) -> Option<FixedI32<Frac>>`[src]

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

The other number can be:

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

Examples

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

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

assert_eq!(Fix::checked_from_num(3), Some(Fix::from_bits(3 << 4)));
let too_large = i32::max_value();
assert!(Fix::checked_from_num(too_large).is_none());
let too_small = i32::min_value();
assert!(Fix::checked_from_num(too_small).is_none());

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

`pub fn checked_to_num<Dst: FromFixed>(self) -> Option<Dst>`[src]

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

The other number can be:

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

Examples

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

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

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

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

`pub fn saturating_from_num<Src: ToFixed>(src: Src) -> FixedI32<Frac>`[src]

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

The other number can be:

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

Panics

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

Examples

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

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

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

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

`pub fn saturating_to_num<Dst: FromFixed>(self) -> Dst`[src]

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

The other number can be:

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

Examples

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

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

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

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

`pub fn wrapping_from_num<Src: ToFixed>(src: Src) -> FixedI32<Frac>`[src]

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

The other number can be:

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

Panics

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

Examples

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

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

// 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_num(large), wrapped);

// 1.75 is 1.11 in binary
let expected = Fix::from_bits(0b111 << (4 - 2));
assert_eq!(Fix::wrapping_from_num(1.75f32), expected);
// 1.75 << (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_num(large), wrapped);

`pub fn wrapping_to_num<Dst: FromFixed>(self) -> Dst`[src]

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

The other number can be:

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

Examples

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

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

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

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

`pub fn overflowing_from_num<Src: ToFixed>(src: Src) -> (FixedI32<Frac>, bool)`[src]

Creates a fixed-point number from another number.

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

The other number can be:

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

Panics

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

Examples

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

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

assert_eq!(Fix::overflowing_from_num(3), (Fix::from_bits(3 << 4), false));
// integer 0b1101 << (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_num(large), (wrapped, true));

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

`pub fn overflowing_to_num<Dst: FromFixed>(self) -> (Dst, bool)`[src]

Converts a fixed-point number to another number.

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

The other number can be:

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

Examples

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

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

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

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

`pub fn from_str_binary(src: &str) -> Result<FixedI32<Frac>, ParseFixedError>`[src]

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

Examples

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

`pub fn from_str_octal(src: &str) -> Result<FixedI32<Frac>, ParseFixedError>`[src]

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

Examples

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

`pub fn from_str_hex(src: &str) -> Result<FixedI32<Frac>, ParseFixedError>`[src]

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

Examples

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

`pub fn saturating_from_str(src: &str) -> Result<FixedI32<Frac>, ParseFixedError>`[src]

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

Examples

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

`pub fn saturating_from_str_binary( src: &str ) -> Result<FixedI32<Frac>, ParseFixedError>`[src]

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

Examples

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

`pub fn saturating_from_str_octal( src: &str ) -> Result<FixedI32<Frac>, ParseFixedError>`[src]

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

Examples

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

`pub fn saturating_from_str_hex( src: &str ) -> Result<FixedI32<Frac>, ParseFixedError>`[src]

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

Examples

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

`pub fn wrapping_from_str(src: &str) -> Result<FixedI32<Frac>, ParseFixedError>`[src]

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

Examples

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

`pub fn wrapping_from_str_binary( src: &str ) -> Result<FixedI32<Frac>, ParseFixedError>`[src]

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

Examples

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

`pub fn wrapping_from_str_octal( src: &str ) -> Result<FixedI32<Frac>, ParseFixedError>`[src]

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

Examples

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

`pub fn wrapping_from_str_hex( src: &str ) -> Result<FixedI32<Frac>, ParseFixedError>`[src]

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

Examples

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

`pub fn overflowing_from_str( src: &str ) -> Result<(FixedI32<Frac>, bool), ParseFixedError>`[src]

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

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

Examples

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

`pub fn overflowing_from_str_binary( src: &str ) -> Result<(FixedI32<Frac>, bool), ParseFixedError>`[src]

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

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

Examples

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

`pub fn overflowing_from_str_octal( src: &str ) -> Result<(FixedI32<Frac>, bool), ParseFixedError>`[src]

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

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

Examples

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

`pub fn overflowing_from_str_hex( src: &str ) -> Result<(FixedI32<Frac>, bool), ParseFixedError>`[src]

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

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

Examples

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

`pub fn int(self) -> FixedI32<Frac>`[src]

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::{types::extra::U4, FixedI32};
type Fix = FixedI32<U4>;
// 0010.0000
let two = Fix::from_num(2);
// 0010.0100
let two_and_quarter = two + two / 8;
assert_eq!(two_and_quarter.int(), two);
// 1101.0000
let three = Fix::from_num(3);
// 1101.1100
assert_eq!((-two_and_quarter).int(), -three);

`pub fn frac(self) -> FixedI32<Frac>`[src]

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::{types::extra::U4, FixedI32};
type Fix = FixedI32<U4>;
// 0000.0100
let quarter = Fix::from_num(1) / 4;
// 0010.0100
let two_and_quarter = quarter * 9;
assert_eq!(two_and_quarter.frac(), quarter);
// 0000.1100
let three_quarters = quarter * 3;
// 1101.1100
assert_eq!((-two_and_quarter).frac(), three_quarters);

`pub fn ceil(self) -> FixedI32<Frac>`[src]

Rounds to the next integer towards +∞.

Panics

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

Examples

use fixed::{types::extra::U4, FixedI32};
type Fix = FixedI32<U4>;
let two_half = Fix::from_num(5) / 2;
assert_eq!(two_half.ceil(), Fix::from_num(3));
assert_eq!((-two_half).ceil(), Fix::from_num(-2));

`pub fn floor(self) -> FixedI32<Frac>`[src]

Rounds to the next integer towards −∞.

Panics

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

Overflow can only occur when there are zero integer bits.

Examples

use fixed::{types::extra::U4, FixedI32};
type Fix = FixedI32<U4>;
let two_half = Fix::from_num(5) / 2;
assert_eq!(two_half.floor(), Fix::from_num(2));
assert_eq!((-two_half).floor(), Fix::from_num(-3));

`pub fn round(self) -> FixedI32<Frac>`[src]

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

Panics

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

Examples

use fixed::{types::extra::U4, FixedI32};
type Fix = FixedI32<U4>;
let two_half = Fix::from_num(5) / 2;
assert_eq!(two_half.round(), Fix::from_num(3));
assert_eq!((-two_half).round(), Fix::from_num(-3));

`pub fn checked_ceil(self) -> Option<FixedI32<Frac>>`[src]

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

Examples

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

`pub fn checked_floor(self) -> Option<FixedI32<Frac>>`[src]

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

Overflow can only occur when there are zero integer bits.

Examples

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

`pub fn checked_round(self) -> Option<FixedI32<Frac>>`[src]

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

Examples

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

`pub fn saturating_ceil(self) -> FixedI32<Frac>`[src]

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

Examples

use fixed::{types::extra::U4, FixedI32};
type Fix = FixedI32<U4>;
let two_half = Fix::from_num(5) / 2;
assert_eq!(two_half.saturating_ceil(), Fix::from_num(3));
assert_eq!((-two_half).saturating_ceil(), Fix::from_num(-2));
assert_eq!(Fix::max_value().saturating_ceil(), Fix::max_value());

`pub fn saturating_floor(self) -> FixedI32<Frac>`[src]

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

Overflow can only occur when there are zero integer bits.

Examples

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

`pub fn saturating_round(self) -> FixedI32<Frac>`[src]

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

Examples

use fixed::{types::extra::U4, FixedI32};
type Fix = FixedI32<U4>;
let two_half = Fix::from_num(5) / 2;
assert_eq!(two_half.saturating_round(), Fix::from_num(3));
assert_eq!((-two_half).saturating_round(), Fix::from_num(-3));
assert_eq!(Fix::max_value().saturating_round(), Fix::max_value());

`pub fn wrapping_ceil(self) -> FixedI32<Frac>`[src]

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

Examples

use fixed::{types::extra::U4, FixedI32};
type Fix = FixedI32<U4>;
let two_half = Fix::from_num(5) / 2;
assert_eq!(two_half.wrapping_ceil(), Fix::from_num(3));
assert_eq!((-two_half).wrapping_ceil(), Fix::from_num(-2));
assert_eq!(Fix::max_value().wrapping_ceil(), Fix::min_value());

`pub fn wrapping_floor(self) -> FixedI32<Frac>`[src]

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

Overflow can only occur when there are zero integer bits.

Examples

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

`pub fn wrapping_round(self) -> FixedI32<Frac>`[src]

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

Examples

use fixed::{types::extra::U4, FixedI32};
type Fix = FixedI32<U4>;
let two_half = Fix::from_num(5) / 2;
assert_eq!(two_half.wrapping_round(), Fix::from_num(3));
assert_eq!((-two_half).wrapping_round(), Fix::from_num(-3));
assert_eq!(Fix::max_value().wrapping_round(), Fix::min_value());

`pub fn overflowing_ceil(self) -> (FixedI32<Frac>, bool)`[src]

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

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

Examples

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

`pub fn overflowing_floor(self) -> (FixedI32<Frac>, bool)`[src]

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

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

Examples

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

`pub fn overflowing_round(self) -> (FixedI32<Frac>, bool)`[src]

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

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

Examples

use fixed::{types::extra::U4, FixedI32};
type Fix = FixedI32<U4>;
let two_half = Fix::from_num(5) / 2;
assert_eq!(two_half.overflowing_round(), (Fix::from_num(3), false));
assert_eq!((-two_half).overflowing_round(), (Fix::from_num(-3), false));
assert_eq!(Fix::max_value().overflowing_round(), (Fix::min_value(), true));

`pub fn signum(self) -> FixedI32<Frac>`[src]

Returns a number representing the sign of self.

Panics

When debug assertions are enabled, this method panics

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

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

Examples

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

`pub fn checked_mul(self, rhs: FixedI32<Frac>) -> Option<FixedI32<Frac>>`[src]

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

Examples

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

`pub fn checked_div(self, rhs: FixedI32<Frac>) -> Option<FixedI32<Frac>>`[src]

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

Examples

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

`pub fn saturating_mul(self, rhs: FixedI32<Frac>) -> FixedI32<Frac>`[src]

Saturating multiplication. Returns the product, saturating on overflow.

Examples

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

`pub fn saturating_div(self, rhs: FixedI32<Frac>) -> FixedI32<Frac>`[src]

Saturating division. Returns the quotient, saturating on overflow.

Panics

Panics if the divisor is zero.

Examples

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

`pub fn wrapping_mul(self, rhs: FixedI32<Frac>) -> FixedI32<Frac>`[src]

Wrapping multiplication. Returns the product, wrapping on overflow.

Examples

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

`pub fn wrapping_div(self, rhs: FixedI32<Frac>) -> FixedI32<Frac>`[src]

Wrapping division. Returns the quotient, wrapping on overflow.

Panics

Panics if the divisor is zero.

Examples

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

`pub fn overflowing_mul(self, rhs: FixedI32<Frac>) -> (FixedI32<Frac>, bool)`[src]

Overflowing multiplication.

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

Examples

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

`pub fn overflowing_div(self, rhs: FixedI32<Frac>) -> (FixedI32<Frac>, bool)`[src]

Overflowing division.

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

Panics

Panics if the divisor is zero.

Examples

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

`pub fn from_fixed<Src: ToFixed>(src: Src) -> FixedI32<Frac>`[src]

Deprecated since 0.4.2:

replaced by from_num

Creates a fixed-point number from another number.

`pub fn to_fixed<Dst: FromFixed>(self) -> Dst`[src]

Deprecated since 0.4.2:

replaced by to_num

Converts a fixed-point number to another number.

`pub fn from_int<Src: ToFixed>(src: Src) -> FixedI32<Frac>`[src]

Deprecated since 0.4.2:

replaced by from_num

Creates a fixed-point number from another number.

`pub fn to_int<Dst: FromFixed>(self) -> Dst`[src]

Deprecated since 0.4.2:

replaced by to_num

Converts a fixed-point number to another number.

`pub fn from_float<Src: ToFixed>(src: Src) -> FixedI32<Frac>`[src]

Deprecated since 0.4.2:

replaced by from_num

Creates a fixed-point number from another number.

`pub fn to_float<Dst: FromFixed>(self) -> Dst`[src]

Deprecated since 0.4.2:

replaced by to_num

Converts a fixed-point number to another number.

`pub fn checked_from_fixed<Src: ToFixed>(src: Src) -> Option<FixedI32<Frac>>`[src]

Deprecated since 0.4.2:

replaced by checked_from_num

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

`pub fn checked_to_fixed<Dst: FromFixed>(self) -> Option<Dst>`[src]

Deprecated since 0.4.2:

replaced by checked_to_num

Converts a fixed-point number to another number if it fits.

`pub fn checked_from_int<Src: ToFixed>(src: Src) -> Option<FixedI32<Frac>>`[src]

Deprecated since 0.4.2:

replaced by checked_from_num

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

`pub fn checked_to_int<Dst: FromFixed>(self) -> Option<Dst>`[src]

Deprecated since 0.4.2:

replaced by checked_to_num

Converts a fixed-point number to another number if it fits.

`pub fn checked_from_float<Src: ToFixed>(src: Src) -> Option<FixedI32<Frac>>`[src]

Deprecated since 0.4.2:

replaced by checked_from_num

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

`pub fn saturating_from_fixed<Src: ToFixed>(src: Src) -> FixedI32<Frac>`[src]

Deprecated since 0.4.2:

replaced by saturating_from_num

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

`pub fn saturating_to_fixed<Dst: FromFixed>(self) -> Dst`[src]

Deprecated since 0.4.2:

replaced by saturating_to_num

Converts a fixed-point number to another number if it fits.

`pub fn saturating_from_int<Src: ToFixed>(src: Src) -> FixedI32<Frac>`[src]

Deprecated since 0.4.2:

replaced by saturating_from_num

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

`pub fn saturating_to_int<Dst: FromFixed>(self) -> Dst`[src]

Deprecated since 0.4.2:

replaced by saturating_to_num

Converts a fixed-point number to another number if it fits.

`pub fn saturating_from_float<Src: ToFixed>(src: Src) -> FixedI32<Frac>`[src]

Deprecated since 0.4.2:

replaced by saturating_from_num

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

`pub fn wrapping_from_fixed<Src: ToFixed>(src: Src) -> FixedI32<Frac>`[src]

Deprecated since 0.4.2:

replaced by wrapping_from_num

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

`pub fn wrapping_to_fixed<Dst: FromFixed>(self) -> Dst`[src]

Deprecated since 0.4.2:

replaced by wrapping_to_num

Converts a fixed-point number to another number if it fits.

`pub fn wrapping_from_int<Src: ToFixed>(src: Src) -> FixedI32<Frac>`[src]

Deprecated since 0.4.2:

replaced by wrapping_from_num

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

`pub fn wrapping_to_int<Dst: FromFixed>(self) -> Dst`[src]

Deprecated since 0.4.2:

replaced by wrapping_to_num

Converts a fixed-point number to another number if it fits.

`pub fn wrapping_from_float<Src: ToFixed>(src: Src) -> FixedI32<Frac>`[src]

Deprecated since 0.4.2:

replaced by wrapping_from_num

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

`pub fn overflowing_from_fixed<Src: ToFixed>(src: Src) -> (FixedI32<Frac>, bool)`[src]

Deprecated since 0.4.2:

replaced by overflowing_from_num

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

`pub fn overflowing_to_fixed<Dst: FromFixed>(self) -> (Dst, bool)`[src]

Deprecated since 0.4.2:

replaced by overflowing_to_num

Converts a fixed-point number to another number if it fits.

`pub fn overflowing_from_int<Src: ToFixed>(src: Src) -> (FixedI32<Frac>, bool)`[src]

Deprecated since 0.4.2:

replaced by overflowing_from_num

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

`pub fn overflowing_to_int<Dst: FromFixed>(self) -> (Dst, bool)`[src]

Deprecated since 0.4.2:

replaced by overflowing_to_num

Converts a fixed-point number to another number if it fits.

`pub fn overflowing_from_float<Src: ToFixed>(src: Src) -> (FixedI32<Frac>, bool)`[src]

Deprecated since 0.4.2:

replaced by overflowing_from_num

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

Trait Implementations

`impl<Frac: LeEqU32> Fixed for FixedI32<Frac>`[src]

`type Bits = i32`

The primitive integer underlying type.

`fn min_value() -> Self`[src]

`fn max_value() -> Self`[src]

`fn int_nbits() -> u32`[src]

`fn frac_nbits() -> u32`[src]

`fn from_bits(bits: Self::Bits) -> Self`[src]

`fn to_bits(self) -> Self::Bits`[src]

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

`fn to_num<Dst: FromFixed>(self) -> Dst`[src]

`fn checked_from_num<Src: ToFixed>(val: Src) -> Option<Self>`[src]

`fn checked_to_num<Dst: FromFixed>(self) -> Option<Dst>`[src]

`fn saturating_from_num<Src: ToFixed>(val: Src) -> Self`[src]

`fn saturating_to_num<Dst: FromFixed>(self) -> Dst`[src]

`fn wrapping_from_num<Src: ToFixed>(val: Src) -> Self`[src]

`fn wrapping_to_num<Dst: FromFixed>(self) -> Dst`[src]

`fn overflowing_from_num<Src: ToFixed>(val: Src) -> (Self, bool)`[src]

`fn overflowing_to_num<Dst: FromFixed>(self) -> (Dst, bool)`[src]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

`fn int(self) -> Self`[src]

`fn frac(self) -> Self`[src]

`fn ceil(self) -> Self`[src]

`fn floor(self) -> Self`[src]

`fn round(self) -> Self`[src]

`fn checked_ceil(self) -> Option<Self>`[src]

`fn checked_floor(self) -> Option<Self>`[src]

`fn checked_round(self) -> Option<Self>`[src]

`fn saturating_ceil(self) -> Self`[src]

`fn saturating_floor(self) -> Self`[src]

`fn saturating_round(self) -> Self`[src]

`fn wrapping_ceil(self) -> Self`[src]

`fn wrapping_floor(self) -> Self`[src]

`fn wrapping_round(self) -> Self`[src]

`fn overflowing_ceil(self) -> (Self, bool)`[src]

`fn overflowing_floor(self) -> (Self, bool)`[src]

`fn overflowing_round(self) -> (Self, bool)`[src]

`fn count_ones(self) -> u32`[src]

`fn count_zeros(self) -> u32`[src]

`fn leading_zeros(self) -> u32`[src]

`fn trailing_zeros(self) -> u32`[src]

`fn rotate_left(self, n: u32) -> Self`[src]

`fn rotate_right(self, n: u32) -> Self`[src]

`fn checked_neg(self) -> Option<Self>`[src]

`fn checked_add(self, rhs: Self) -> Option<Self>`[src]

`fn checked_sub(self, rhs: Self) -> Option<Self>`[src]

`fn checked_mul(self, rhs: Self) -> Option<Self>`[src]

`fn checked_div(self, rhs: Self) -> Option<Self>`[src]

`fn checked_mul_int(self, rhs: Self::Bits) -> Option<Self>`[src]

`fn checked_div_int(self, rhs: Self::Bits) -> Option<Self>`[src]

`fn checked_rem_int(self, rhs: Self::Bits) -> Option<Self>`[src]

`fn checked_shl(self, rhs: u32) -> Option<Self>`[src]

`fn checked_shr(self, rhs: u32) -> Option<Self>`[src]

`fn saturating_neg(self) -> Self`[src]

`fn saturating_add(self, rhs: Self) -> Self`[src]

`fn saturating_sub(self, rhs: Self) -> Self`[src]

`fn saturating_mul(self, rhs: Self) -> Self`[src]

`fn saturating_div(self, rhs: Self) -> Self`[src]

`fn saturating_mul_int(self, rhs: Self::Bits) -> Self`[src]

`fn wrapping_neg(self) -> Self`[src]

`fn wrapping_add(self, rhs: Self) -> Self`[src]

`fn wrapping_sub(self, rhs: Self) -> Self`[src]

`fn wrapping_mul(self, rhs: Self) -> Self`[src]

`fn wrapping_div(self, rhs: Self) -> Self`[src]

`fn wrapping_mul_int(self, rhs: Self::Bits) -> Self`[src]

`fn wrapping_div_int(self, rhs: Self::Bits) -> Self`[src]

`fn wrapping_rem_int(self, rhs: Self::Bits) -> Self`[src]

`fn wrapping_shl(self, rhs: u32) -> Self`[src]

`fn wrapping_shr(self, rhs: u32) -> Self`[src]

`fn overflowing_neg(self) -> (Self, bool)`[src]

`fn overflowing_add(self, rhs: Self) -> (Self, bool)`[src]

`fn overflowing_sub(self, rhs: Self) -> (Self, bool)`[src]

`fn overflowing_mul(self, rhs: Self) -> (Self, bool)`[src]

`fn overflowing_div(self, rhs: Self) -> (Self, bool)`[src]

`fn overflowing_mul_int(self, rhs: Self::Bits) -> (Self, bool)`[src]

`fn overflowing_div_int(self, rhs: Self::Bits) -> (Self, bool)`[src]

`fn overflowing_rem_int(self, rhs: Self::Bits) -> (Self, bool)`[src]

`fn overflowing_shl(self, rhs: u32) -> (Self, bool)`[src]

`fn overflowing_shr(self, rhs: u32) -> (Self, bool)`[src]

`fn mul_int(self, rhs: Self::Bits) -> Self`[src]

Deprecated since 0.4.1:

use lhs * rhs instead of lhs.mul_int(rhs)

Multiplication by an integer.

`fn div_int(self, rhs: Self::Bits) -> Self`[src]

Deprecated since 0.4.1:

use lhs / rhs instead of lhs.div_int(rhs)

Division by an integer.

`fn rem_int(self, rhs: Self::Bits) -> Self`[src]

Deprecated since 0.4.1:

use lhs % rhs instead of lhs.rem_int(rhs)

Remainder for division by an integer.

`fn from_int<Src: ToFixed>(src: Src) -> Self`[src]

Deprecated since 0.4.2:

replaced by from_num

Creates a fixed-point number from another number.

`fn to_int<Dst: FromFixed>(self) -> Dst`[src]

Deprecated since 0.4.2:

replaced by to_num

Converts a fixed-point number to another number.

`fn from_float<Src: ToFixed>(src: Src) -> Self`[src]

Deprecated since 0.4.2:

replaced by from_num

Creates a fixed-point number from another number.

`fn to_float<Dst: FromFixed>(self) -> Dst`[src]

Deprecated since 0.4.2:

replaced by to_num

Converts a fixed-point number to another number.

`fn checked_from_int<Src: ToFixed>(src: Src) -> Option<Self>`[src]

Deprecated since 0.4.2:

replaced by checked_from_num

Creates a fixed-point number from another number.

`fn checked_to_int<Dst: FromFixed>(self) -> Option<Dst>`[src]

Deprecated since 0.4.2:

replaced by checked_to_num

Converts a fixed-point number to another number.

`fn checked_from_float<Src: ToFixed>(src: Src) -> Option<Self>`[src]

Deprecated since 0.4.2:

replaced by checked_from_num

Creates a fixed-point number from another number.

`fn saturating_from_int<Src: ToFixed>(src: Src) -> Self`[src]

Deprecated since 0.4.2:

replaced by saturating_from_num

Creates a fixed-point number from another number.

`fn saturating_to_int<Dst: FromFixed>(self) -> Dst`[src]

Deprecated since 0.4.2:

replaced by saturating_to_num

Converts a fixed-point number to another number.

`fn saturating_from_float<Src: ToFixed>(src: Src) -> Self`[src]

Deprecated since 0.4.2:

replaced by saturating_from_num

Creates a fixed-point number from another number.

`fn wrapping_from_int<Src: ToFixed>(src: Src) -> Self`[src]

Deprecated since 0.4.2:

replaced by wrapping_from_num

Creates a fixed-point number from another number.

`fn wrapping_to_int<Dst: FromFixed>(self) -> Dst`[src]

Deprecated since 0.4.2:

replaced by wrapping_to_num

Converts a fixed-point number to another number.

`fn wrapping_from_float<Src: ToFixed>(src: Src) -> Self`[src]

Deprecated since 0.4.2:

replaced by wrapping_from_num

Creates a fixed-point number from another number.

`fn overflowing_from_int<Src: ToFixed>(src: Src) -> (Self, bool)`[src]

Deprecated since 0.4.2:

replaced by overflowing_from_num

Creates a fixed-point number from another number.

`fn overflowing_to_int<Dst: FromFixed>(self) -> (Dst, bool)`[src]

Deprecated since 0.4.2:

replaced by overflowing_to_num

Converts a fixed-point number to another number.

`fn overflowing_from_float<Src: ToFixed>(src: Src) -> (Self, bool)`[src]

Deprecated since 0.4.2:

replaced by overflowing_from_num

Creates a fixed-point number from another number.

`impl<Frac: LeEqU32> FixedSigned for FixedI32<Frac>`[src]

`fn abs(self) -> Self`[src]

`fn signum(self) -> Self`[src]

`fn checked_abs(self) -> Option<Self>`[src]

`fn saturating_abs(self) -> Self`[src]

`fn wrapping_abs(self) -> Self`[src]

`fn overflowing_abs(self) -> (Self, bool)`[src]

`fn is_positive(self) -> bool`[src]

`fn is_negative(self) -> bool`[src]

`impl<FracSrc: LeEqU8, FracDst: LeEqU32> LossyFrom<FixedI8<FracSrc>> for FixedI32<FracDst> where U8: Sub<FracSrc>, U32: Sub<FracDst>, Diff<U8, FracSrc>: IsLessOrEqual<Diff<U32, FracDst>, Output = True>,` [src]

`fn lossy_from(src: FixedI8<FracSrc>) -> Self`[src]

`impl<FracSrc: LeEqU8, FracDst: LeEqU32> LossyFrom<FixedU8<FracSrc>> for FixedI32<FracDst> where U8: Sub<FracSrc>, U31: Sub<FracDst>, Diff<U8, FracSrc>: IsLessOrEqual<Diff<U31, FracDst>, Output = True>,` [src]

`fn lossy_from(src: FixedU8<FracSrc>) -> Self`[src]

`impl<FracSrc: LeEqU16, FracDst: LeEqU32> LossyFrom<FixedI16<FracSrc>> for FixedI32<FracDst> where U16: Sub<FracSrc>, U32: Sub<FracDst>, Diff<U16, FracSrc>: IsLessOrEqual<Diff<U32, FracDst>, Output = True>,` [src]

`fn lossy_from(src: FixedI16<FracSrc>) -> Self`[src]

`impl<FracSrc: LeEqU16, FracDst: LeEqU32> LossyFrom<FixedU16<FracSrc>> for FixedI32<FracDst> where U16: Sub<FracSrc>, U31: Sub<FracDst>, Diff<U16, FracSrc>: IsLessOrEqual<Diff<U31, FracDst>, Output = True>,` [src]

`fn lossy_from(src: FixedU16<FracSrc>) -> Self`[src]

`impl<FracSrc: LeEqU32, FracDst: LeEqU8> LossyFrom<FixedI32<FracSrc>> for FixedI8<FracDst> where U32: Sub<FracSrc>, U8: Sub<FracDst>, Diff<U32, FracSrc>: IsLessOrEqual<Diff<U8, FracDst>, Output = True>,` [src]

`fn lossy_from(src: FixedI32<FracSrc>) -> Self`[src]

`impl<FracSrc: LeEqU32, FracDst: LeEqU16> LossyFrom<FixedI32<FracSrc>> for FixedI16<FracDst> where U32: Sub<FracSrc>, U16: Sub<FracDst>, Diff<U32, FracSrc>: IsLessOrEqual<Diff<U16, FracDst>, Output = True>,` [src]

`fn lossy_from(src: FixedI32<FracSrc>) -> Self`[src]

`impl<FracSrc: LeEqU32, FracDst: LeEqU32> LossyFrom<FixedI32<FracSrc>> for FixedI32<FracDst> where U32: Sub<FracSrc>, U32: Sub<FracDst>, Diff<U32, FracSrc>: IsLessOrEqual<Diff<U32, FracDst>, Output = True>,` [src]

`fn lossy_from(src: FixedI32<FracSrc>) -> Self`[src]

`impl<FracSrc: LeEqU32, FracDst: LeEqU32> LossyFrom<FixedU32<FracSrc>> for FixedI32<FracDst> where U32: Sub<FracSrc>, U31: Sub<FracDst>, Diff<U32, FracSrc>: IsLessOrEqual<Diff<U31, FracDst>, Output = True>,` [src]

`fn lossy_from(src: FixedU32<FracSrc>) -> Self`[src]

`impl<FracSrc: LeEqU32, FracDst: LeEqU64> LossyFrom<FixedI32<FracSrc>> for FixedI64<FracDst> where U32: Sub<FracSrc>, U64: Sub<FracDst>, Diff<U32, FracSrc>: IsLessOrEqual<Diff<U64, FracDst>, Output = True>,` [src]

`fn lossy_from(src: FixedI32<FracSrc>) -> Self`[src]

`impl<FracSrc: LeEqU32, FracDst: LeEqU128> LossyFrom<FixedI32<FracSrc>> for FixedI128<FracDst> where U32: Sub<FracSrc>, U128: Sub<FracDst>, Diff<U32, FracSrc>: IsLessOrEqual<Diff<U128, FracDst>, Output = True>,` [src]

`fn lossy_from(src: FixedI32<FracSrc>) -> Self`[src]

`impl<FracSrc: LeEqU64, FracDst: LeEqU32> LossyFrom<FixedI64<FracSrc>> for FixedI32<FracDst> where U64: Sub<FracSrc>, U32: Sub<FracDst>, Diff<U64, FracSrc>: IsLessOrEqual<Diff<U32, FracDst>, Output = True>,` [src]

`fn lossy_from(src: FixedI64<FracSrc>) -> Self`[src]

`impl<FracSrc: LeEqU64, FracDst: LeEqU32> LossyFrom<FixedU64<FracSrc>> for FixedI32<FracDst> where U64: Sub<FracSrc>, U31: Sub<FracDst>, Diff<U64, FracSrc>: IsLessOrEqual<Diff<U31, FracDst>, Output = True>,` [src]

`fn lossy_from(src: FixedU64<FracSrc>) -> Self`[src]

`impl<FracSrc: LeEqU128, FracDst: LeEqU32> LossyFrom<FixedI128<FracSrc>> for FixedI32<FracDst> where U128: Sub<FracSrc>, U32: Sub<FracDst>, Diff<U128, FracSrc>: IsLessOrEqual<Diff<U32, FracDst>, Output = True>,` [src]

`fn lossy_from(src: FixedI128<FracSrc>) -> Self`[src]

`impl<FracSrc: LeEqU128, FracDst: LeEqU32> LossyFrom<FixedU128<FracSrc>> for FixedI32<FracDst> where U128: Sub<FracSrc>, U31: Sub<FracDst>, Diff<U128, FracSrc>: IsLessOrEqual<Diff<U31, FracDst>, Output = True>,` [src]

`fn lossy_from(src: FixedU128<FracSrc>) -> Self`[src]

`impl<FracDst: LeEqU32> LossyFrom<i8> for FixedI32<FracDst> where U32: Sub<FracDst>, U8: IsLessOrEqual<Diff<U32, FracDst>, Output = True>,` [src]

`fn lossy_from(src: i8) -> Self`[src]

`impl<FracDst: LeEqU32> LossyFrom<u8> for FixedI32<FracDst> where U31: Sub<FracDst>, U8: IsLessOrEqual<Diff<U31, FracDst>, Output = True>,` [src]

`fn lossy_from(src: u8) -> Self`[src]

`impl<FracDst: LeEqU32> LossyFrom<i16> for FixedI32<FracDst> where U32: Sub<FracDst>, U16: IsLessOrEqual<Diff<U32, FracDst>, Output = True>,` [src]

`fn lossy_from(src: i16) -> Self`[src]

`impl<FracDst: LeEqU32> LossyFrom<u16> for FixedI32<FracDst> where U31: Sub<FracDst>, U16: IsLessOrEqual<Diff<U31, FracDst>, Output = True>,` [src]

`fn lossy_from(src: u16) -> Self`[src]

`impl LossyFrom<i32> for FixedI32<U0>`[src]

`fn lossy_from(src: i32) -> Self`[src]

`impl<FracDst: LeEqU32> LossyFrom<bool> for FixedI32<FracDst> where U31: Sub<FracDst>, U1: IsLessOrEqual<Diff<U31, FracDst>, Output = True>,` [src]

`fn lossy_from(src: bool) -> Self`[src]

`impl<FracSrc: LeEqU32> LossyFrom<FixedI32<FracSrc>> for i8 where U32: Sub<FracSrc>, Diff<U32, FracSrc>: IsLessOrEqual<U8, Output = True>,` [src]

`fn lossy_from(src: FixedI32<FracSrc>) -> Self`[src]

`impl<FracSrc: LeEqU32> LossyFrom<FixedI32<FracSrc>> for i16 where U32: Sub<FracSrc>, Diff<U32, FracSrc>: IsLessOrEqual<U16, Output = True>,` [src]

`fn lossy_from(src: FixedI32<FracSrc>) -> Self`[src]

`impl<FracSrc: LeEqU32> LossyFrom<FixedI32<FracSrc>> for i32 where U32: Sub<FracSrc>, Diff<U32, FracSrc>: IsLessOrEqual<U32, Output = True>,` [src]

`fn lossy_from(src: FixedI32<FracSrc>) -> Self`[src]

`impl<FracSrc: LeEqU32> LossyFrom<FixedI32<FracSrc>> for i64 where U32: Sub<FracSrc>, Diff<U32, FracSrc>: IsLessOrEqual<U64, Output = True>,` [src]

`fn lossy_from(src: FixedI32<FracSrc>) -> Self`[src]

`impl<FracSrc: LeEqU32> LossyFrom<FixedI32<FracSrc>> for i128 where U32: Sub<FracSrc>, Diff<U32, FracSrc>: IsLessOrEqual<U128, Output = True>,` [src]

`fn lossy_from(src: FixedI32<FracSrc>) -> Self`[src]

`impl<FracSrc: LeEqU32> LossyFrom<FixedI32<FracSrc>> for isize where U32: Sub<FracSrc>, Diff<U32, FracSrc>: IsLessOrEqual<U16, Output = True>,` [src]

`fn lossy_from(src: FixedI32<FracSrc>) -> Self`[src]

`impl<Frac: LeEqU32> LossyFrom<FixedI32<Frac>> for f16`[src]

`fn lossy_from(src: FixedI32<Frac>) -> f16`[src]

`impl<Frac: LeEqU32> LossyFrom<FixedI32<Frac>> for f32`[src]

`fn lossy_from(src: FixedI32<Frac>) -> f32`[src]

`impl<Frac: LeEqU32> LossyFrom<FixedI32<Frac>> for f64`[src]

`fn lossy_from(src: FixedI32<Frac>) -> f64`[src]

`impl<Frac: LeEqU32> FromFixed for FixedI32<Frac>`[src]

`fn from_fixed<F: Fixed>(src: F) -> Self`[src]

`fn checked_from_fixed<F: Fixed>(src: F) -> Option<Self>`[src]

`fn saturating_from_fixed<F: Fixed>(src: F) -> Self`[src]

`fn wrapping_from_fixed<F: Fixed>(src: F) -> Self`[src]

`fn overflowing_from_fixed<F: Fixed>(src: F) -> (Self, bool)`[src]

`impl<Frac: LeEqU32> ToFixed for FixedI32<Frac>`[src]

`fn to_fixed<F: Fixed>(self) -> F`[src]

`fn checked_to_fixed<F: Fixed>(self) -> Option<F>`[src]

`fn saturating_to_fixed<F: Fixed>(self) -> F`[src]

`fn wrapping_to_fixed<F: Fixed>(self) -> F`[src]

`fn overflowing_to_fixed<F: Fixed>(self) -> (F, bool)`[src]

`impl<Frac: LeEqU32> FixedOptionalFeatures for FixedI32<Frac>`[src]

`impl<Frac: LeEqU32> Debug for FixedI32<Frac>`[src]

`fn fmt(&self, f: &mut Formatter) -> FmtResult`[src]

`impl<Frac: LeEqU32> Display for FixedI32<Frac>`[src]

`fn fmt(&self, f: &mut Formatter) -> FmtResult`[src]

`impl<Frac: LeEqU32> Rem<i32> for FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the % operator.

`fn rem(self, rhs: i32) -> FixedI32<Frac>`[src]

`impl<'a, Frac: LeEqU32> Rem<i32> for &'a FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the % operator.

`fn rem(self, rhs: i32) -> FixedI32<Frac>`[src]

`impl<'a, Frac: LeEqU32> Rem<&'a i32> for FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the % operator.

`fn rem(self, rhs: &i32) -> FixedI32<Frac>`[src]

`impl<'a, 'b, Frac: LeEqU32> Rem<&'a i32> for &'b FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the % operator.

`fn rem(self, rhs: &i32) -> FixedI32<Frac>`[src]

`impl<FracLhs: LeEqU8, FracRhs: LeEqU32> PartialEq<FixedI32<FracRhs>> for FixedI8<FracLhs>`[src]

`fn eq(&self, rhs: &FixedI32<FracRhs>) -> bool`[src]

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

This method tests for !=.

`impl<FracLhs: LeEqU16, FracRhs: LeEqU32> PartialEq<FixedI32<FracRhs>> for FixedI16<FracLhs>`[src]

`fn eq(&self, rhs: &FixedI32<FracRhs>) -> bool`[src]

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

This method tests for !=.

`impl<FracLhs: LeEqU32, FracRhs: LeEqU8> PartialEq<FixedI8<FracRhs>> for FixedI32<FracLhs>`[src]

`fn eq(&self, rhs: &FixedI8<FracRhs>) -> bool`[src]

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

This method tests for !=.

`impl<FracLhs: LeEqU32, FracRhs: LeEqU16> PartialEq<FixedI16<FracRhs>> for FixedI32<FracLhs>`[src]

`fn eq(&self, rhs: &FixedI16<FracRhs>) -> bool`[src]

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

This method tests for !=.

`impl<FracLhs: LeEqU32, FracRhs: LeEqU32> PartialEq<FixedI32<FracRhs>> for FixedI32<FracLhs>`[src]

`fn eq(&self, rhs: &FixedI32<FracRhs>) -> bool`[src]

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

This method tests for !=.

`impl<FracLhs: LeEqU32, FracRhs: LeEqU64> PartialEq<FixedI64<FracRhs>> for FixedI32<FracLhs>`[src]

`fn eq(&self, rhs: &FixedI64<FracRhs>) -> bool`[src]

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

This method tests for !=.

`impl<FracLhs: LeEqU32, FracRhs: LeEqU128> PartialEq<FixedI128<FracRhs>> for FixedI32<FracLhs>`[src]

`fn eq(&self, rhs: &FixedI128<FracRhs>) -> bool`[src]

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

This method tests for !=.

`impl<FracLhs: LeEqU32, FracRhs: LeEqU8> PartialEq<FixedU8<FracRhs>> for FixedI32<FracLhs>`[src]

`fn eq(&self, rhs: &FixedU8<FracRhs>) -> bool`[src]

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

This method tests for !=.

`impl<FracLhs: LeEqU32, FracRhs: LeEqU16> PartialEq<FixedU16<FracRhs>> for FixedI32<FracLhs>`[src]

`fn eq(&self, rhs: &FixedU16<FracRhs>) -> bool`[src]

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

This method tests for !=.

`impl<FracLhs: LeEqU32, FracRhs: LeEqU32> PartialEq<FixedU32<FracRhs>> for FixedI32<FracLhs>`[src]

`fn eq(&self, rhs: &FixedU32<FracRhs>) -> bool`[src]

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

This method tests for !=.

`impl<FracLhs: LeEqU32, FracRhs: LeEqU64> PartialEq<FixedU64<FracRhs>> for FixedI32<FracLhs>`[src]

`fn eq(&self, rhs: &FixedU64<FracRhs>) -> bool`[src]

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

This method tests for !=.

`impl<FracLhs: LeEqU32, FracRhs: LeEqU128> PartialEq<FixedU128<FracRhs>> for FixedI32<FracLhs>`[src]

`fn eq(&self, rhs: &FixedU128<FracRhs>) -> bool`[src]

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

This method tests for !=.

`impl<Frac: LeEqU32> PartialEq<i8> for FixedI32<Frac>`[src]

`fn eq(&self, rhs: &i8) -> bool`[src]

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

This method tests for !=.

`impl<Frac: LeEqU32> PartialEq<FixedI32<Frac>> for i8`[src]

`fn eq(&self, rhs: &FixedI32<Frac>) -> bool`[src]

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

This method tests for !=.

`impl<Frac: LeEqU32> PartialEq<i16> for FixedI32<Frac>`[src]

`fn eq(&self, rhs: &i16) -> bool`[src]

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

This method tests for !=.

`impl<Frac: LeEqU32> PartialEq<FixedI32<Frac>> for i16`[src]

`fn eq(&self, rhs: &FixedI32<Frac>) -> bool`[src]

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

This method tests for !=.

`impl<Frac: LeEqU32> PartialEq<i32> for FixedI32<Frac>`[src]

`fn eq(&self, rhs: &i32) -> bool`[src]

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

This method tests for !=.

`impl<Frac: LeEqU32> PartialEq<FixedI32<Frac>> for i32`[src]

`fn eq(&self, rhs: &FixedI32<Frac>) -> bool`[src]

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

This method tests for !=.

`impl<Frac: LeEqU32> PartialEq<i64> for FixedI32<Frac>`[src]

`fn eq(&self, rhs: &i64) -> bool`[src]

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

This method tests for !=.

`impl<Frac: LeEqU32> PartialEq<FixedI32<Frac>> for i64`[src]

`fn eq(&self, rhs: &FixedI32<Frac>) -> bool`[src]

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

This method tests for !=.

`impl<Frac: LeEqU32> PartialEq<i128> for FixedI32<Frac>`[src]

`fn eq(&self, rhs: &i128) -> bool`[src]

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

This method tests for !=.

`impl<Frac: LeEqU32> PartialEq<FixedI32<Frac>> for i128`[src]

`fn eq(&self, rhs: &FixedI32<Frac>) -> bool`[src]

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

This method tests for !=.

`impl<Frac: LeEqU32> PartialEq<isize> for FixedI32<Frac>`[src]

`fn eq(&self, rhs: &isize) -> bool`[src]

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

This method tests for !=.

`impl<Frac: LeEqU32> PartialEq<FixedI32<Frac>> for isize`[src]

`fn eq(&self, rhs: &FixedI32<Frac>) -> bool`[src]

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

This method tests for !=.

`impl<Frac: LeEqU32> PartialEq<u8> for FixedI32<Frac>`[src]

`fn eq(&self, rhs: &u8) -> bool`[src]

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

This method tests for !=.

`impl<Frac: LeEqU32> PartialEq<FixedI32<Frac>> for u8`[src]

`fn eq(&self, rhs: &FixedI32<Frac>) -> bool`[src]

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

This method tests for !=.

`impl<Frac: LeEqU32> PartialEq<u16> for FixedI32<Frac>`[src]

`fn eq(&self, rhs: &u16) -> bool`[src]

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

This method tests for !=.

`impl<Frac: LeEqU32> PartialEq<FixedI32<Frac>> for u16`[src]

`fn eq(&self, rhs: &FixedI32<Frac>) -> bool`[src]

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

This method tests for !=.

`impl<Frac: LeEqU32> PartialEq<u32> for FixedI32<Frac>`[src]

`fn eq(&self, rhs: &u32) -> bool`[src]

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

This method tests for !=.

`impl<Frac: LeEqU32> PartialEq<FixedI32<Frac>> for u32`[src]

`fn eq(&self, rhs: &FixedI32<Frac>) -> bool`[src]

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

This method tests for !=.

`impl<Frac: LeEqU32> PartialEq<u64> for FixedI32<Frac>`[src]

`fn eq(&self, rhs: &u64) -> bool`[src]

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

This method tests for !=.

`impl<Frac: LeEqU32> PartialEq<FixedI32<Frac>> for u64`[src]

`fn eq(&self, rhs: &FixedI32<Frac>) -> bool`[src]

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

This method tests for !=.

`impl<Frac: LeEqU32> PartialEq<u128> for FixedI32<Frac>`[src]

`fn eq(&self, rhs: &u128) -> bool`[src]

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

This method tests for !=.

`impl<Frac: LeEqU32> PartialEq<FixedI32<Frac>> for u128`[src]

`fn eq(&self, rhs: &FixedI32<Frac>) -> bool`[src]

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

This method tests for !=.

`impl<Frac: LeEqU32> PartialEq<usize> for FixedI32<Frac>`[src]

`fn eq(&self, rhs: &usize) -> bool`[src]

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

This method tests for !=.

`impl<Frac: LeEqU32> PartialEq<FixedI32<Frac>> for usize`[src]

`fn eq(&self, rhs: &FixedI32<Frac>) -> bool`[src]

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

This method tests for !=.

`impl<Frac: LeEqU32> PartialEq<f16> for FixedI32<Frac>`[src]

`fn eq(&self, rhs: &f16) -> bool`[src]

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

This method tests for !=.

`impl<Frac: LeEqU32> PartialEq<FixedI32<Frac>> for f16`[src]

`fn eq(&self, rhs: &FixedI32<Frac>) -> bool`[src]

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

This method tests for !=.

`impl<Frac: LeEqU32> PartialEq<f32> for FixedI32<Frac>`[src]

`fn eq(&self, rhs: &f32) -> bool`[src]

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

This method tests for !=.

`impl<Frac: LeEqU32> PartialEq<FixedI32<Frac>> for f32`[src]

`fn eq(&self, rhs: &FixedI32<Frac>) -> bool`[src]

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

This method tests for !=.

`impl<Frac: LeEqU32> PartialEq<f64> for FixedI32<Frac>`[src]

`fn eq(&self, rhs: &f64) -> bool`[src]

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

This method tests for !=.

`impl<Frac: LeEqU32> PartialEq<FixedI32<Frac>> for f64`[src]

`fn eq(&self, rhs: &FixedI32<Frac>) -> bool`[src]

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

This method tests for !=.

`impl<FracLhs: LeEqU64, FracRhs: LeEqU32> PartialEq<FixedI32<FracRhs>> for FixedI64<FracLhs>`[src]

`fn eq(&self, rhs: &FixedI32<FracRhs>) -> bool`[src]

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

This method tests for !=.

`impl<FracLhs: LeEqU128, FracRhs: LeEqU32> PartialEq<FixedI32<FracRhs>> for FixedI128<FracLhs>`[src]

`fn eq(&self, rhs: &FixedI32<FracRhs>) -> bool`[src]

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

This method tests for !=.

`impl<FracLhs: LeEqU8, FracRhs: LeEqU32> PartialEq<FixedI32<FracRhs>> for FixedU8<FracLhs>`[src]

`fn eq(&self, rhs: &FixedI32<FracRhs>) -> bool`[src]

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

This method tests for !=.

`impl<FracLhs: LeEqU16, FracRhs: LeEqU32> PartialEq<FixedI32<FracRhs>> for FixedU16<FracLhs>`[src]

`fn eq(&self, rhs: &FixedI32<FracRhs>) -> bool`[src]

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

This method tests for !=.

`impl<FracLhs: LeEqU32, FracRhs: LeEqU32> PartialEq<FixedI32<FracRhs>> for FixedU32<FracLhs>`[src]

`fn eq(&self, rhs: &FixedI32<FracRhs>) -> bool`[src]

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

This method tests for !=.

`impl<FracLhs: LeEqU64, FracRhs: LeEqU32> PartialEq<FixedI32<FracRhs>> for FixedU64<FracLhs>`[src]

`fn eq(&self, rhs: &FixedI32<FracRhs>) -> bool`[src]

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

This method tests for !=.

`impl<FracLhs: LeEqU128, FracRhs: LeEqU32> PartialEq<FixedI32<FracRhs>> for FixedU128<FracLhs>`[src]

`fn eq(&self, rhs: &FixedI32<FracRhs>) -> bool`[src]

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

This method tests for !=.

`impl<Frac: LeEqU32> Eq for FixedI32<Frac>`[src]

`impl<Frac: LeEqU32> Ord for FixedI32<Frac>`[src]

`fn cmp(&self, rhs: &FixedI32<Frac>) -> Ordering`[src]

`fn max(self, other: Self) -> Self`1.21.0[src]

Compares and returns the maximum of two values. Read more

`fn min(self, other: Self) -> Self`1.21.0[src]

Compares and returns the minimum of two values. Read more

`fn clamp(self, min: Self, max: Self) -> Self`[src]

🔬 This is a nightly-only experimental API. (clamp)

Restrict a value to a certain interval. Read more

`impl<FracLhs: LeEqU8, FracRhs: LeEqU32> PartialOrd<FixedI32<FracRhs>> for FixedI8<FracLhs>`[src]

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

`fn lt(&self, rhs: &FixedI32<FracRhs>) -> bool`[src]

`fn le(&self, rhs: &FixedI32<FracRhs>) -> bool`[src]

`fn gt(&self, rhs: &FixedI32<FracRhs>) -> bool`[src]

`fn ge(&self, rhs: &FixedI32<FracRhs>) -> bool`[src]

`impl<FracLhs: LeEqU16, FracRhs: LeEqU32> PartialOrd<FixedI32<FracRhs>> for FixedI16<FracLhs>`[src]

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

`fn lt(&self, rhs: &FixedI32<FracRhs>) -> bool`[src]

`fn le(&self, rhs: &FixedI32<FracRhs>) -> bool`[src]

`fn gt(&self, rhs: &FixedI32<FracRhs>) -> bool`[src]

`fn ge(&self, rhs: &FixedI32<FracRhs>) -> bool`[src]

`impl<FracLhs: LeEqU32, FracRhs: LeEqU8> PartialOrd<FixedI8<FracRhs>> for FixedI32<FracLhs>`[src]

`fn partial_cmp(&self, rhs: &FixedI8<FracRhs>) -> Option<Ordering>`[src]

`fn lt(&self, rhs: &FixedI8<FracRhs>) -> bool`[src]

`fn le(&self, rhs: &FixedI8<FracRhs>) -> bool`[src]

`fn gt(&self, rhs: &FixedI8<FracRhs>) -> bool`[src]

`fn ge(&self, rhs: &FixedI8<FracRhs>) -> bool`[src]

`impl<FracLhs: LeEqU32, FracRhs: LeEqU16> PartialOrd<FixedI16<FracRhs>> for FixedI32<FracLhs>`[src]

`fn partial_cmp(&self, rhs: &FixedI16<FracRhs>) -> Option<Ordering>`[src]

`fn lt(&self, rhs: &FixedI16<FracRhs>) -> bool`[src]

`fn le(&self, rhs: &FixedI16<FracRhs>) -> bool`[src]

`fn gt(&self, rhs: &FixedI16<FracRhs>) -> bool`[src]

`fn ge(&self, rhs: &FixedI16<FracRhs>) -> bool`[src]

`impl<FracLhs: LeEqU32, FracRhs: LeEqU32> PartialOrd<FixedI32<FracRhs>> for FixedI32<FracLhs>`[src]

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

`fn lt(&self, rhs: &FixedI32<FracRhs>) -> bool`[src]

`fn le(&self, rhs: &FixedI32<FracRhs>) -> bool`[src]

`fn gt(&self, rhs: &FixedI32<FracRhs>) -> bool`[src]

`fn ge(&self, rhs: &FixedI32<FracRhs>) -> bool`[src]

`impl<FracLhs: LeEqU32, FracRhs: LeEqU64> PartialOrd<FixedI64<FracRhs>> for FixedI32<FracLhs>`[src]

`fn partial_cmp(&self, rhs: &FixedI64<FracRhs>) -> Option<Ordering>`[src]

`fn lt(&self, rhs: &FixedI64<FracRhs>) -> bool`[src]

`fn le(&self, rhs: &FixedI64<FracRhs>) -> bool`[src]

`fn gt(&self, rhs: &FixedI64<FracRhs>) -> bool`[src]

`fn ge(&self, rhs: &FixedI64<FracRhs>) -> bool`[src]

`impl<FracLhs: LeEqU32, FracRhs: LeEqU128> PartialOrd<FixedI128<FracRhs>> for FixedI32<FracLhs>`[src]

`fn partial_cmp(&self, rhs: &FixedI128<FracRhs>) -> Option<Ordering>`[src]

`fn lt(&self, rhs: &FixedI128<FracRhs>) -> bool`[src]

`fn le(&self, rhs: &FixedI128<FracRhs>) -> bool`[src]

`fn gt(&self, rhs: &FixedI128<FracRhs>) -> bool`[src]

`fn ge(&self, rhs: &FixedI128<FracRhs>) -> bool`[src]

`impl<FracLhs: LeEqU32, FracRhs: LeEqU8> PartialOrd<FixedU8<FracRhs>> for FixedI32<FracLhs>`[src]

`fn partial_cmp(&self, rhs: &FixedU8<FracRhs>) -> Option<Ordering>`[src]

`fn lt(&self, rhs: &FixedU8<FracRhs>) -> bool`[src]

`fn le(&self, rhs: &FixedU8<FracRhs>) -> bool`[src]

`fn gt(&self, rhs: &FixedU8<FracRhs>) -> bool`[src]

`fn ge(&self, rhs: &FixedU8<FracRhs>) -> bool`[src]

`impl<FracLhs: LeEqU32, FracRhs: LeEqU16> PartialOrd<FixedU16<FracRhs>> for FixedI32<FracLhs>`[src]

`fn partial_cmp(&self, rhs: &FixedU16<FracRhs>) -> Option<Ordering>`[src]

`fn lt(&self, rhs: &FixedU16<FracRhs>) -> bool`[src]

`fn le(&self, rhs: &FixedU16<FracRhs>) -> bool`[src]

`fn gt(&self, rhs: &FixedU16<FracRhs>) -> bool`[src]

`fn ge(&self, rhs: &FixedU16<FracRhs>) -> bool`[src]

`impl<FracLhs: LeEqU32, FracRhs: LeEqU32> PartialOrd<FixedU32<FracRhs>> for FixedI32<FracLhs>`[src]

`fn partial_cmp(&self, rhs: &FixedU32<FracRhs>) -> Option<Ordering>`[src]

`fn lt(&self, rhs: &FixedU32<FracRhs>) -> bool`[src]

`fn le(&self, rhs: &FixedU32<FracRhs>) -> bool`[src]

`fn gt(&self, rhs: &FixedU32<FracRhs>) -> bool`[src]

`fn ge(&self, rhs: &FixedU32<FracRhs>) -> bool`[src]

`impl<FracLhs: LeEqU32, FracRhs: LeEqU64> PartialOrd<FixedU64<FracRhs>> for FixedI32<FracLhs>`[src]

`fn partial_cmp(&self, rhs: &FixedU64<FracRhs>) -> Option<Ordering>`[src]

`fn lt(&self, rhs: &FixedU64<FracRhs>) -> bool`[src]

`fn le(&self, rhs: &FixedU64<FracRhs>) -> bool`[src]

`fn gt(&self, rhs: &FixedU64<FracRhs>) -> bool`[src]

`fn ge(&self, rhs: &FixedU64<FracRhs>) -> bool`[src]

`impl<FracLhs: LeEqU32, FracRhs: LeEqU128> PartialOrd<FixedU128<FracRhs>> for FixedI32<FracLhs>`[src]

`fn partial_cmp(&self, rhs: &FixedU128<FracRhs>) -> Option<Ordering>`[src]

`fn lt(&self, rhs: &FixedU128<FracRhs>) -> bool`[src]

`fn le(&self, rhs: &FixedU128<FracRhs>) -> bool`[src]

`fn gt(&self, rhs: &FixedU128<FracRhs>) -> bool`[src]

`fn ge(&self, rhs: &FixedU128<FracRhs>) -> bool`[src]

`impl<Frac: LeEqU32> PartialOrd<i8> for FixedI32<Frac>`[src]

`fn partial_cmp(&self, rhs: &i8) -> Option<Ordering>`[src]

`fn lt(&self, rhs: &i8) -> bool`[src]

`fn le(&self, rhs: &i8) -> bool`[src]

`fn gt(&self, rhs: &i8) -> bool`[src]

`fn ge(&self, rhs: &i8) -> bool`[src]

`impl<Frac: LeEqU32> PartialOrd<FixedI32<Frac>> for i8`[src]

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

`fn lt(&self, rhs: &FixedI32<Frac>) -> bool`[src]

`fn le(&self, rhs: &FixedI32<Frac>) -> bool`[src]

`fn gt(&self, rhs: &FixedI32<Frac>) -> bool`[src]

`fn ge(&self, rhs: &FixedI32<Frac>) -> bool`[src]

`impl<Frac: LeEqU32> PartialOrd<i16> for FixedI32<Frac>`[src]

`fn partial_cmp(&self, rhs: &i16) -> Option<Ordering>`[src]

`fn lt(&self, rhs: &i16) -> bool`[src]

`fn le(&self, rhs: &i16) -> bool`[src]

`fn gt(&self, rhs: &i16) -> bool`[src]

`fn ge(&self, rhs: &i16) -> bool`[src]

`impl<Frac: LeEqU32> PartialOrd<FixedI32<Frac>> for i16`[src]

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

`fn lt(&self, rhs: &FixedI32<Frac>) -> bool`[src]

`fn le(&self, rhs: &FixedI32<Frac>) -> bool`[src]

`fn gt(&self, rhs: &FixedI32<Frac>) -> bool`[src]

`fn ge(&self, rhs: &FixedI32<Frac>) -> bool`[src]

`impl<Frac: LeEqU32> PartialOrd<i32> for FixedI32<Frac>`[src]

`fn partial_cmp(&self, rhs: &i32) -> Option<Ordering>`[src]

`fn lt(&self, rhs: &i32) -> bool`[src]

`fn le(&self, rhs: &i32) -> bool`[src]

`fn gt(&self, rhs: &i32) -> bool`[src]

`fn ge(&self, rhs: &i32) -> bool`[src]

`impl<Frac: LeEqU32> PartialOrd<FixedI32<Frac>> for i32`[src]

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

`fn lt(&self, rhs: &FixedI32<Frac>) -> bool`[src]

`fn le(&self, rhs: &FixedI32<Frac>) -> bool`[src]

`fn gt(&self, rhs: &FixedI32<Frac>) -> bool`[src]

`fn ge(&self, rhs: &FixedI32<Frac>) -> bool`[src]

`impl<Frac: LeEqU32> PartialOrd<i64> for FixedI32<Frac>`[src]

`fn partial_cmp(&self, rhs: &i64) -> Option<Ordering>`[src]

`fn lt(&self, rhs: &i64) -> bool`[src]

`fn le(&self, rhs: &i64) -> bool`[src]

`fn gt(&self, rhs: &i64) -> bool`[src]

`fn ge(&self, rhs: &i64) -> bool`[src]

`impl<Frac: LeEqU32> PartialOrd<FixedI32<Frac>> for i64`[src]

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

`fn lt(&self, rhs: &FixedI32<Frac>) -> bool`[src]

`fn le(&self, rhs: &FixedI32<Frac>) -> bool`[src]

`fn gt(&self, rhs: &FixedI32<Frac>) -> bool`[src]

`fn ge(&self, rhs: &FixedI32<Frac>) -> bool`[src]

`impl<Frac: LeEqU32> PartialOrd<i128> for FixedI32<Frac>`[src]

`fn partial_cmp(&self, rhs: &i128) -> Option<Ordering>`[src]

`fn lt(&self, rhs: &i128) -> bool`[src]

`fn le(&self, rhs: &i128) -> bool`[src]

`fn gt(&self, rhs: &i128) -> bool`[src]

`fn ge(&self, rhs: &i128) -> bool`[src]

`impl<Frac: LeEqU32> PartialOrd<FixedI32<Frac>> for i128`[src]

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

`fn lt(&self, rhs: &FixedI32<Frac>) -> bool`[src]

`fn le(&self, rhs: &FixedI32<Frac>) -> bool`[src]

`fn gt(&self, rhs: &FixedI32<Frac>) -> bool`[src]

`fn ge(&self, rhs: &FixedI32<Frac>) -> bool`[src]

`impl<Frac: LeEqU32> PartialOrd<isize> for FixedI32<Frac>`[src]

`fn partial_cmp(&self, rhs: &isize) -> Option<Ordering>`[src]

`fn lt(&self, rhs: &isize) -> bool`[src]

`fn le(&self, rhs: &isize) -> bool`[src]

`fn gt(&self, rhs: &isize) -> bool`[src]

`fn ge(&self, rhs: &isize) -> bool`[src]

`impl<Frac: LeEqU32> PartialOrd<FixedI32<Frac>> for isize`[src]

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

`fn lt(&self, rhs: &FixedI32<Frac>) -> bool`[src]

`fn le(&self, rhs: &FixedI32<Frac>) -> bool`[src]

`fn gt(&self, rhs: &FixedI32<Frac>) -> bool`[src]

`fn ge(&self, rhs: &FixedI32<Frac>) -> bool`[src]

`impl<Frac: LeEqU32> PartialOrd<u8> for FixedI32<Frac>`[src]

`fn partial_cmp(&self, rhs: &u8) -> Option<Ordering>`[src]

`fn lt(&self, rhs: &u8) -> bool`[src]

`fn le(&self, rhs: &u8) -> bool`[src]

`fn gt(&self, rhs: &u8) -> bool`[src]

`fn ge(&self, rhs: &u8) -> bool`[src]

`impl<Frac: LeEqU32> PartialOrd<FixedI32<Frac>> for u8`[src]

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

`fn lt(&self, rhs: &FixedI32<Frac>) -> bool`[src]

`fn le(&self, rhs: &FixedI32<Frac>) -> bool`[src]

`fn gt(&self, rhs: &FixedI32<Frac>) -> bool`[src]

`fn ge(&self, rhs: &FixedI32<Frac>) -> bool`[src]

`impl<Frac: LeEqU32> PartialOrd<u16> for FixedI32<Frac>`[src]

`fn partial_cmp(&self, rhs: &u16) -> Option<Ordering>`[src]

`fn lt(&self, rhs: &u16) -> bool`[src]

`fn le(&self, rhs: &u16) -> bool`[src]

`fn gt(&self, rhs: &u16) -> bool`[src]

`fn ge(&self, rhs: &u16) -> bool`[src]

`impl<Frac: LeEqU32> PartialOrd<FixedI32<Frac>> for u16`[src]

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

`fn lt(&self, rhs: &FixedI32<Frac>) -> bool`[src]

`fn le(&self, rhs: &FixedI32<Frac>) -> bool`[src]

`fn gt(&self, rhs: &FixedI32<Frac>) -> bool`[src]

`fn ge(&self, rhs: &FixedI32<Frac>) -> bool`[src]

`impl<Frac: LeEqU32> PartialOrd<u32> for FixedI32<Frac>`[src]

`fn partial_cmp(&self, rhs: &u32) -> Option<Ordering>`[src]

`fn lt(&self, rhs: &u32) -> bool`[src]

`fn le(&self, rhs: &u32) -> bool`[src]

`fn gt(&self, rhs: &u32) -> bool`[src]

`fn ge(&self, rhs: &u32) -> bool`[src]

`impl<Frac: LeEqU32> PartialOrd<FixedI32<Frac>> for u32`[src]

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

`fn lt(&self, rhs: &FixedI32<Frac>) -> bool`[src]

`fn le(&self, rhs: &FixedI32<Frac>) -> bool`[src]

`fn gt(&self, rhs: &FixedI32<Frac>) -> bool`[src]

`fn ge(&self, rhs: &FixedI32<Frac>) -> bool`[src]

`impl<Frac: LeEqU32> PartialOrd<u64> for FixedI32<Frac>`[src]

`fn partial_cmp(&self, rhs: &u64) -> Option<Ordering>`[src]

`fn lt(&self, rhs: &u64) -> bool`[src]

`fn le(&self, rhs: &u64) -> bool`[src]

`fn gt(&self, rhs: &u64) -> bool`[src]

`fn ge(&self, rhs: &u64) -> bool`[src]

`impl<Frac: LeEqU32> PartialOrd<FixedI32<Frac>> for u64`[src]

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

`fn lt(&self, rhs: &FixedI32<Frac>) -> bool`[src]

`fn le(&self, rhs: &FixedI32<Frac>) -> bool`[src]

`fn gt(&self, rhs: &FixedI32<Frac>) -> bool`[src]

`fn ge(&self, rhs: &FixedI32<Frac>) -> bool`[src]

`impl<Frac: LeEqU32> PartialOrd<u128> for FixedI32<Frac>`[src]

`fn partial_cmp(&self, rhs: &u128) -> Option<Ordering>`[src]

`fn lt(&self, rhs: &u128) -> bool`[src]

`fn le(&self, rhs: &u128) -> bool`[src]

`fn gt(&self, rhs: &u128) -> bool`[src]

`fn ge(&self, rhs: &u128) -> bool`[src]

`impl<Frac: LeEqU32> PartialOrd<FixedI32<Frac>> for u128`[src]

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

`fn lt(&self, rhs: &FixedI32<Frac>) -> bool`[src]

`fn le(&self, rhs: &FixedI32<Frac>) -> bool`[src]

`fn gt(&self, rhs: &FixedI32<Frac>) -> bool`[src]

`fn ge(&self, rhs: &FixedI32<Frac>) -> bool`[src]

`impl<Frac: LeEqU32> PartialOrd<usize> for FixedI32<Frac>`[src]

`fn partial_cmp(&self, rhs: &usize) -> Option<Ordering>`[src]

`fn lt(&self, rhs: &usize) -> bool`[src]

`fn le(&self, rhs: &usize) -> bool`[src]

`fn gt(&self, rhs: &usize) -> bool`[src]

`fn ge(&self, rhs: &usize) -> bool`[src]

`impl<Frac: LeEqU32> PartialOrd<FixedI32<Frac>> for usize`[src]

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

`fn lt(&self, rhs: &FixedI32<Frac>) -> bool`[src]

`fn le(&self, rhs: &FixedI32<Frac>) -> bool`[src]

`fn gt(&self, rhs: &FixedI32<Frac>) -> bool`[src]

`fn ge(&self, rhs: &FixedI32<Frac>) -> bool`[src]

`impl<Frac: LeEqU32> PartialOrd<f16> for FixedI32<Frac>`[src]

`fn partial_cmp(&self, rhs: &f16) -> Option<Ordering>`[src]

`fn lt(&self, rhs: &f16) -> bool`[src]

`fn le(&self, rhs: &f16) -> bool`[src]

`fn gt(&self, rhs: &f16) -> bool`[src]

`fn ge(&self, rhs: &f16) -> bool`[src]

`impl<Frac: LeEqU32> PartialOrd<FixedI32<Frac>> for f16`[src]

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

`fn lt(&self, rhs: &FixedI32<Frac>) -> bool`[src]

`fn le(&self, rhs: &FixedI32<Frac>) -> bool`[src]

`fn gt(&self, rhs: &FixedI32<Frac>) -> bool`[src]

`fn ge(&self, rhs: &FixedI32<Frac>) -> bool`[src]

`impl<Frac: LeEqU32> PartialOrd<f32> for FixedI32<Frac>`[src]

`fn partial_cmp(&self, rhs: &f32) -> Option<Ordering>`[src]

`fn lt(&self, rhs: &f32) -> bool`[src]

`fn le(&self, rhs: &f32) -> bool`[src]

`fn gt(&self, rhs: &f32) -> bool`[src]

`fn ge(&self, rhs: &f32) -> bool`[src]

`impl<Frac: LeEqU32> PartialOrd<FixedI32<Frac>> for f32`[src]

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

`fn lt(&self, rhs: &FixedI32<Frac>) -> bool`[src]

`fn le(&self, rhs: &FixedI32<Frac>) -> bool`[src]

`fn gt(&self, rhs: &FixedI32<Frac>) -> bool`[src]

`fn ge(&self, rhs: &FixedI32<Frac>) -> bool`[src]

`impl<Frac: LeEqU32> PartialOrd<f64> for FixedI32<Frac>`[src]

`fn partial_cmp(&self, rhs: &f64) -> Option<Ordering>`[src]

`fn lt(&self, rhs: &f64) -> bool`[src]

`fn le(&self, rhs: &f64) -> bool`[src]

`fn gt(&self, rhs: &f64) -> bool`[src]

`fn ge(&self, rhs: &f64) -> bool`[src]

`impl<Frac: LeEqU32> PartialOrd<FixedI32<Frac>> for f64`[src]

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

`fn lt(&self, rhs: &FixedI32<Frac>) -> bool`[src]

`fn le(&self, rhs: &FixedI32<Frac>) -> bool`[src]

`fn gt(&self, rhs: &FixedI32<Frac>) -> bool`[src]

`fn ge(&self, rhs: &FixedI32<Frac>) -> bool`[src]

`impl<FracLhs: LeEqU64, FracRhs: LeEqU32> PartialOrd<FixedI32<FracRhs>> for FixedI64<FracLhs>`[src]

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

`fn lt(&self, rhs: &FixedI32<FracRhs>) -> bool`[src]

`fn le(&self, rhs: &FixedI32<FracRhs>) -> bool`[src]

`fn gt(&self, rhs: &FixedI32<FracRhs>) -> bool`[src]

`fn ge(&self, rhs: &FixedI32<FracRhs>) -> bool`[src]

`impl<FracLhs: LeEqU128, FracRhs: LeEqU32> PartialOrd<FixedI32<FracRhs>> for FixedI128<FracLhs>`[src]

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

`fn lt(&self, rhs: &FixedI32<FracRhs>) -> bool`[src]

`fn le(&self, rhs: &FixedI32<FracRhs>) -> bool`[src]

`fn gt(&self, rhs: &FixedI32<FracRhs>) -> bool`[src]

`fn ge(&self, rhs: &FixedI32<FracRhs>) -> bool`[src]

`impl<FracLhs: LeEqU8, FracRhs: LeEqU32> PartialOrd<FixedI32<FracRhs>> for FixedU8<FracLhs>`[src]

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

`fn lt(&self, rhs: &FixedI32<FracRhs>) -> bool`[src]

`fn le(&self, rhs: &FixedI32<FracRhs>) -> bool`[src]

`fn gt(&self, rhs: &FixedI32<FracRhs>) -> bool`[src]

`fn ge(&self, rhs: &FixedI32<FracRhs>) -> bool`[src]

`impl<FracLhs: LeEqU16, FracRhs: LeEqU32> PartialOrd<FixedI32<FracRhs>> for FixedU16<FracLhs>`[src]

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

`fn lt(&self, rhs: &FixedI32<FracRhs>) -> bool`[src]

`fn le(&self, rhs: &FixedI32<FracRhs>) -> bool`[src]

`fn gt(&self, rhs: &FixedI32<FracRhs>) -> bool`[src]

`fn ge(&self, rhs: &FixedI32<FracRhs>) -> bool`[src]

`impl<FracLhs: LeEqU32, FracRhs: LeEqU32> PartialOrd<FixedI32<FracRhs>> for FixedU32<FracLhs>`[src]

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

`fn lt(&self, rhs: &FixedI32<FracRhs>) -> bool`[src]

`fn le(&self, rhs: &FixedI32<FracRhs>) -> bool`[src]

`fn gt(&self, rhs: &FixedI32<FracRhs>) -> bool`[src]

`fn ge(&self, rhs: &FixedI32<FracRhs>) -> bool`[src]

`impl<FracLhs: LeEqU64, FracRhs: LeEqU32> PartialOrd<FixedI32<FracRhs>> for FixedU64<FracLhs>`[src]

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

`fn lt(&self, rhs: &FixedI32<FracRhs>) -> bool`[src]

`fn le(&self, rhs: &FixedI32<FracRhs>) -> bool`[src]

`fn gt(&self, rhs: &FixedI32<FracRhs>) -> bool`[src]

`fn ge(&self, rhs: &FixedI32<FracRhs>) -> bool`[src]

`impl<FracLhs: LeEqU128, FracRhs: LeEqU32> PartialOrd<FixedI32<FracRhs>> for FixedU128<FracLhs>`[src]

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

`fn lt(&self, rhs: &FixedI32<FracRhs>) -> bool`[src]

`fn le(&self, rhs: &FixedI32<FracRhs>) -> bool`[src]

`fn gt(&self, rhs: &FixedI32<FracRhs>) -> bool`[src]

`fn ge(&self, rhs: &FixedI32<FracRhs>) -> bool`[src]

`impl<Frac: LeEqU32> FromStr for FixedI32<Frac>`[src]

`type Err = ParseFixedError`

The associated error which can be returned from parsing.

`fn from_str(s: &str) -> Result<Self, Self::Err>`[src]

`impl<Frac: LeEqU32> Add<FixedI32<Frac>> for FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the + operator.

`fn add(self, rhs: FixedI32<Frac>) -> FixedI32<Frac>`[src]

`impl<'a, Frac: LeEqU32> Add<FixedI32<Frac>> for &'a FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the + operator.

`fn add(self, rhs: FixedI32<Frac>) -> FixedI32<Frac>`[src]

`impl<'a, Frac: LeEqU32> Add<&'a FixedI32<Frac>> for FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the + operator.

`fn add(self, rhs: &FixedI32<Frac>) -> FixedI32<Frac>`[src]

`impl<'a, 'b, Frac: LeEqU32> Add<&'a FixedI32<Frac>> for &'b FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the + operator.

`fn add(self, rhs: &FixedI32<Frac>) -> FixedI32<Frac>`[src]

`impl<Frac: LeEqU32> Sub<FixedI32<Frac>> for FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the - operator.

`fn sub(self, rhs: FixedI32<Frac>) -> FixedI32<Frac>`[src]

`impl<'a, Frac: LeEqU32> Sub<FixedI32<Frac>> for &'a FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the - operator.

`fn sub(self, rhs: FixedI32<Frac>) -> FixedI32<Frac>`[src]

`impl<'a, Frac: LeEqU32> Sub<&'a FixedI32<Frac>> for FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the - operator.

`fn sub(self, rhs: &FixedI32<Frac>) -> FixedI32<Frac>`[src]

`impl<'a, 'b, Frac: LeEqU32> Sub<&'a FixedI32<Frac>> for &'b FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the - operator.

`fn sub(self, rhs: &FixedI32<Frac>) -> FixedI32<Frac>`[src]

`impl<Frac: LeEqU32> Mul<FixedI32<Frac>> for FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the * operator.

`fn mul(self, rhs: FixedI32<Frac>) -> FixedI32<Frac>`[src]

`impl<'a, Frac: LeEqU32> Mul<FixedI32<Frac>> for &'a FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the * operator.

`fn mul(self, rhs: FixedI32<Frac>) -> FixedI32<Frac>`[src]

`impl<'a, Frac: LeEqU32> Mul<&'a FixedI32<Frac>> for FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the * operator.

`fn mul(self, rhs: &FixedI32<Frac>) -> FixedI32<Frac>`[src]

`impl<'a, 'b, Frac: LeEqU32> Mul<&'a FixedI32<Frac>> for &'b FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the * operator.

`fn mul(self, rhs: &FixedI32<Frac>) -> FixedI32<Frac>`[src]

`impl<Frac: LeEqU32> Mul<i32> for FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the * operator.

`fn mul(self, rhs: i32) -> FixedI32<Frac>`[src]

`impl<Frac: LeEqU32> Mul<FixedI32<Frac>> for i32`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the * operator.

`fn mul(self, rhs: FixedI32<Frac>) -> FixedI32<Frac>`[src]

`impl<'a, Frac: LeEqU32> Mul<i32> for &'a FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the * operator.

`fn mul(self, rhs: i32) -> FixedI32<Frac>`[src]

`impl<'a, Frac: LeEqU32> Mul<&'a FixedI32<Frac>> for i32`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the * operator.

`fn mul(self, rhs: &FixedI32<Frac>) -> FixedI32<Frac>`[src]

`impl<'a, Frac: LeEqU32> Mul<&'a i32> for FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the * operator.

`fn mul(self, rhs: &i32) -> FixedI32<Frac>`[src]

`impl<'a, Frac: LeEqU32> Mul<FixedI32<Frac>> for &'a i32`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the * operator.

`fn mul(self, rhs: FixedI32<Frac>) -> FixedI32<Frac>`[src]

`impl<'a, 'b, Frac: LeEqU32> Mul<&'a i32> for &'b FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the * operator.

`fn mul(self, rhs: &i32) -> FixedI32<Frac>`[src]

`impl<'a, 'b, Frac: LeEqU32> Mul<&'a FixedI32<Frac>> for &'b i32`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the * operator.

`fn mul(self, rhs: &FixedI32<Frac>) -> FixedI32<Frac>`[src]

`impl<Frac: LeEqU32> Div<FixedI32<Frac>> for FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the / operator.

`fn div(self, rhs: FixedI32<Frac>) -> FixedI32<Frac>`[src]

`impl<'a, Frac: LeEqU32> Div<FixedI32<Frac>> for &'a FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the / operator.

`fn div(self, rhs: FixedI32<Frac>) -> FixedI32<Frac>`[src]

`impl<'a, Frac: LeEqU32> Div<&'a FixedI32<Frac>> for FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the / operator.

`fn div(self, rhs: &FixedI32<Frac>) -> FixedI32<Frac>`[src]

`impl<'a, 'b, Frac: LeEqU32> Div<&'a FixedI32<Frac>> for &'b FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the / operator.

`fn div(self, rhs: &FixedI32<Frac>) -> FixedI32<Frac>`[src]

`impl<Frac: LeEqU32> Div<i32> for FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the / operator.

`fn div(self, rhs: i32) -> FixedI32<Frac>`[src]

`impl<'a, Frac: LeEqU32> Div<i32> for &'a FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the / operator.

`fn div(self, rhs: i32) -> FixedI32<Frac>`[src]

`impl<'a, Frac: LeEqU32> Div<&'a i32> for FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the / operator.

`fn div(self, rhs: &i32) -> FixedI32<Frac>`[src]

`impl<'a, 'b, Frac: LeEqU32> Div<&'a i32> for &'b FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the / operator.

`fn div(self, rhs: &i32) -> FixedI32<Frac>`[src]

`impl<Frac: LeEqU32> Neg for FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the - operator.

`fn neg(self) -> FixedI32<Frac>`[src]

`impl<'a, Frac: LeEqU32> Neg for &'a FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the - operator.

`fn neg(self) -> FixedI32<Frac>`[src]

`impl<Frac: LeEqU32> AddAssign<FixedI32<Frac>> for FixedI32<Frac>`[src]

`fn add_assign(&mut self, rhs: FixedI32<Frac>)`[src]

`impl<'a, Frac: LeEqU32> AddAssign<&'a FixedI32<Frac>> for FixedI32<Frac>`[src]

`fn add_assign(&mut self, rhs: &FixedI32<Frac>)`[src]

`impl<Frac: LeEqU32> SubAssign<FixedI32<Frac>> for FixedI32<Frac>`[src]

`fn sub_assign(&mut self, rhs: FixedI32<Frac>)`[src]

`impl<'a, Frac: LeEqU32> SubAssign<&'a FixedI32<Frac>> for FixedI32<Frac>`[src]

`fn sub_assign(&mut self, rhs: &FixedI32<Frac>)`[src]

`impl<Frac: LeEqU32> MulAssign<FixedI32<Frac>> for FixedI32<Frac>`[src]

`fn mul_assign(&mut self, rhs: FixedI32<Frac>)`[src]

`impl<'a, Frac: LeEqU32> MulAssign<&'a FixedI32<Frac>> for FixedI32<Frac>`[src]

`fn mul_assign(&mut self, rhs: &FixedI32<Frac>)`[src]

`impl<Frac: LeEqU32> MulAssign<i32> for FixedI32<Frac>`[src]

`fn mul_assign(&mut self, rhs: i32)`[src]

`impl<'a, Frac: LeEqU32> MulAssign<&'a i32> for FixedI32<Frac>`[src]

`fn mul_assign(&mut self, rhs: &i32)`[src]

`impl<Frac: LeEqU32> DivAssign<FixedI32<Frac>> for FixedI32<Frac>`[src]

`fn div_assign(&mut self, rhs: FixedI32<Frac>)`[src]

`impl<'a, Frac: LeEqU32> DivAssign<&'a FixedI32<Frac>> for FixedI32<Frac>`[src]

`fn div_assign(&mut self, rhs: &FixedI32<Frac>)`[src]

`impl<Frac: LeEqU32> DivAssign<i32> for FixedI32<Frac>`[src]

`fn div_assign(&mut self, rhs: i32)`[src]

`impl<'a, Frac: LeEqU32> DivAssign<&'a i32> for FixedI32<Frac>`[src]

`fn div_assign(&mut self, rhs: &i32)`[src]

`impl<Frac: LeEqU32> RemAssign<i32> for FixedI32<Frac>`[src]

`fn rem_assign(&mut self, rhs: i32)`[src]

`impl<'a, Frac: LeEqU32> RemAssign<&'a i32> for FixedI32<Frac>`[src]

`fn rem_assign(&mut self, rhs: &i32)`[src]

`impl<Frac: LeEqU32> Not for FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the ! operator.

`fn not(self) -> FixedI32<Frac>`[src]

`impl<'a, Frac: LeEqU32> Not for &'a FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the ! operator.

`fn not(self) -> FixedI32<Frac>`[src]

`impl<Frac: LeEqU32> BitAnd<FixedI32<Frac>> for FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the & operator.

`fn bitand(self, rhs: FixedI32<Frac>) -> FixedI32<Frac>`[src]

`impl<'a, Frac: LeEqU32> BitAnd<FixedI32<Frac>> for &'a FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the & operator.

`fn bitand(self, rhs: FixedI32<Frac>) -> FixedI32<Frac>`[src]

`impl<'a, Frac: LeEqU32> BitAnd<&'a FixedI32<Frac>> for FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the & operator.

`fn bitand(self, rhs: &FixedI32<Frac>) -> FixedI32<Frac>`[src]

`impl<'a, 'b, Frac: LeEqU32> BitAnd<&'a FixedI32<Frac>> for &'b FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the & operator.

`fn bitand(self, rhs: &FixedI32<Frac>) -> FixedI32<Frac>`[src]

`impl<Frac: LeEqU32> BitOr<FixedI32<Frac>> for FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the | operator.

`fn bitor(self, rhs: FixedI32<Frac>) -> FixedI32<Frac>`[src]

`impl<'a, Frac: LeEqU32> BitOr<FixedI32<Frac>> for &'a FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the | operator.

`fn bitor(self, rhs: FixedI32<Frac>) -> FixedI32<Frac>`[src]

`impl<'a, Frac: LeEqU32> BitOr<&'a FixedI32<Frac>> for FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the | operator.

`fn bitor(self, rhs: &FixedI32<Frac>) -> FixedI32<Frac>`[src]

`impl<'a, 'b, Frac: LeEqU32> BitOr<&'a FixedI32<Frac>> for &'b FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the | operator.

`fn bitor(self, rhs: &FixedI32<Frac>) -> FixedI32<Frac>`[src]

`impl<Frac: LeEqU32> BitXor<FixedI32<Frac>> for FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the ^ operator.

`fn bitxor(self, rhs: FixedI32<Frac>) -> FixedI32<Frac>`[src]

`impl<'a, Frac: LeEqU32> BitXor<FixedI32<Frac>> for &'a FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the ^ operator.

`fn bitxor(self, rhs: FixedI32<Frac>) -> FixedI32<Frac>`[src]

`impl<'a, Frac: LeEqU32> BitXor<&'a FixedI32<Frac>> for FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the ^ operator.

`fn bitxor(self, rhs: &FixedI32<Frac>) -> FixedI32<Frac>`[src]

`impl<'a, 'b, Frac: LeEqU32> BitXor<&'a FixedI32<Frac>> for &'b FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the ^ operator.

`fn bitxor(self, rhs: &FixedI32<Frac>) -> FixedI32<Frac>`[src]

`impl<Frac: LeEqU32> Shl<i8> for FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the << operator.

`fn shl(self, rhs: i8) -> FixedI32<Frac>`[src]

`impl<'a, Frac: LeEqU32> Shl<i8> for &'a FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the << operator.

`fn shl(self, rhs: i8) -> FixedI32<Frac>`[src]

`impl<'a, Frac: LeEqU32> Shl<&'a i8> for FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the << operator.

`fn shl(self, rhs: &i8) -> FixedI32<Frac>`[src]

`impl<'a, 'b, Frac: LeEqU32> Shl<&'a i8> for &'b FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the << operator.

`fn shl(self, rhs: &i8) -> FixedI32<Frac>`[src]

`impl<Frac: LeEqU32> Shl<i16> for FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the << operator.

`fn shl(self, rhs: i16) -> FixedI32<Frac>`[src]

`impl<'a, Frac: LeEqU32> Shl<i16> for &'a FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the << operator.

`fn shl(self, rhs: i16) -> FixedI32<Frac>`[src]

`impl<'a, Frac: LeEqU32> Shl<&'a i16> for FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the << operator.

`fn shl(self, rhs: &i16) -> FixedI32<Frac>`[src]

`impl<'a, 'b, Frac: LeEqU32> Shl<&'a i16> for &'b FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the << operator.

`fn shl(self, rhs: &i16) -> FixedI32<Frac>`[src]

`impl<Frac: LeEqU32> Shl<i32> for FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the << operator.

`fn shl(self, rhs: i32) -> FixedI32<Frac>`[src]

`impl<'a, Frac: LeEqU32> Shl<i32> for &'a FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the << operator.

`fn shl(self, rhs: i32) -> FixedI32<Frac>`[src]

`impl<'a, Frac: LeEqU32> Shl<&'a i32> for FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the << operator.

`fn shl(self, rhs: &i32) -> FixedI32<Frac>`[src]

`impl<'a, 'b, Frac: LeEqU32> Shl<&'a i32> for &'b FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the << operator.

`fn shl(self, rhs: &i32) -> FixedI32<Frac>`[src]

`impl<Frac: LeEqU32> Shl<i64> for FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the << operator.

`fn shl(self, rhs: i64) -> FixedI32<Frac>`[src]

`impl<'a, Frac: LeEqU32> Shl<i64> for &'a FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the << operator.

`fn shl(self, rhs: i64) -> FixedI32<Frac>`[src]

`impl<'a, Frac: LeEqU32> Shl<&'a i64> for FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the << operator.

`fn shl(self, rhs: &i64) -> FixedI32<Frac>`[src]

`impl<'a, 'b, Frac: LeEqU32> Shl<&'a i64> for &'b FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the << operator.

`fn shl(self, rhs: &i64) -> FixedI32<Frac>`[src]

`impl<Frac: LeEqU32> Shl<i128> for FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the << operator.

`fn shl(self, rhs: i128) -> FixedI32<Frac>`[src]

`impl<'a, Frac: LeEqU32> Shl<i128> for &'a FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the << operator.

`fn shl(self, rhs: i128) -> FixedI32<Frac>`[src]

`impl<'a, Frac: LeEqU32> Shl<&'a i128> for FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the << operator.

`fn shl(self, rhs: &i128) -> FixedI32<Frac>`[src]

`impl<'a, 'b, Frac: LeEqU32> Shl<&'a i128> for &'b FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the << operator.

`fn shl(self, rhs: &i128) -> FixedI32<Frac>`[src]

`impl<Frac: LeEqU32> Shl<isize> for FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the << operator.

`fn shl(self, rhs: isize) -> FixedI32<Frac>`[src]

`impl<'a, Frac: LeEqU32> Shl<isize> for &'a FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the << operator.

`fn shl(self, rhs: isize) -> FixedI32<Frac>`[src]

`impl<'a, Frac: LeEqU32> Shl<&'a isize> for FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the << operator.

`fn shl(self, rhs: &isize) -> FixedI32<Frac>`[src]

`impl<'a, 'b, Frac: LeEqU32> Shl<&'a isize> for &'b FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the << operator.

`fn shl(self, rhs: &isize) -> FixedI32<Frac>`[src]

`impl<Frac: LeEqU32> Shl<u8> for FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the << operator.

`fn shl(self, rhs: u8) -> FixedI32<Frac>`[src]

`impl<'a, Frac: LeEqU32> Shl<u8> for &'a FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the << operator.

`fn shl(self, rhs: u8) -> FixedI32<Frac>`[src]

`impl<'a, Frac: LeEqU32> Shl<&'a u8> for FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the << operator.

`fn shl(self, rhs: &u8) -> FixedI32<Frac>`[src]

`impl<'a, 'b, Frac: LeEqU32> Shl<&'a u8> for &'b FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the << operator.

`fn shl(self, rhs: &u8) -> FixedI32<Frac>`[src]

`impl<Frac: LeEqU32> Shl<u16> for FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the << operator.

`fn shl(self, rhs: u16) -> FixedI32<Frac>`[src]

`impl<'a, Frac: LeEqU32> Shl<u16> for &'a FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the << operator.

`fn shl(self, rhs: u16) -> FixedI32<Frac>`[src]

`impl<'a, Frac: LeEqU32> Shl<&'a u16> for FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the << operator.

`fn shl(self, rhs: &u16) -> FixedI32<Frac>`[src]

`impl<'a, 'b, Frac: LeEqU32> Shl<&'a u16> for &'b FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the << operator.

`fn shl(self, rhs: &u16) -> FixedI32<Frac>`[src]

`impl<Frac: LeEqU32> Shl<u32> for FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the << operator.

`fn shl(self, rhs: u32) -> FixedI32<Frac>`[src]

`impl<'a, Frac: LeEqU32> Shl<u32> for &'a FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the << operator.

`fn shl(self, rhs: u32) -> FixedI32<Frac>`[src]

`impl<'a, Frac: LeEqU32> Shl<&'a u32> for FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the << operator.

`fn shl(self, rhs: &u32) -> FixedI32<Frac>`[src]

`impl<'a, 'b, Frac: LeEqU32> Shl<&'a u32> for &'b FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the << operator.

`fn shl(self, rhs: &u32) -> FixedI32<Frac>`[src]

`impl<Frac: LeEqU32> Shl<u64> for FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the << operator.

`fn shl(self, rhs: u64) -> FixedI32<Frac>`[src]

`impl<'a, Frac: LeEqU32> Shl<u64> for &'a FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the << operator.

`fn shl(self, rhs: u64) -> FixedI32<Frac>`[src]

`impl<'a, Frac: LeEqU32> Shl<&'a u64> for FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the << operator.

`fn shl(self, rhs: &u64) -> FixedI32<Frac>`[src]

`impl<'a, 'b, Frac: LeEqU32> Shl<&'a u64> for &'b FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the << operator.

`fn shl(self, rhs: &u64) -> FixedI32<Frac>`[src]

`impl<Frac: LeEqU32> Shl<u128> for FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the << operator.

`fn shl(self, rhs: u128) -> FixedI32<Frac>`[src]

`impl<'a, Frac: LeEqU32> Shl<u128> for &'a FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the << operator.

`fn shl(self, rhs: u128) -> FixedI32<Frac>`[src]

`impl<'a, Frac: LeEqU32> Shl<&'a u128> for FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the << operator.

`fn shl(self, rhs: &u128) -> FixedI32<Frac>`[src]

`impl<'a, 'b, Frac: LeEqU32> Shl<&'a u128> for &'b FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the << operator.

`fn shl(self, rhs: &u128) -> FixedI32<Frac>`[src]

`impl<Frac: LeEqU32> Shl<usize> for FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the << operator.

`fn shl(self, rhs: usize) -> FixedI32<Frac>`[src]

`impl<'a, Frac: LeEqU32> Shl<usize> for &'a FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the << operator.

`fn shl(self, rhs: usize) -> FixedI32<Frac>`[src]

`impl<'a, Frac: LeEqU32> Shl<&'a usize> for FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the << operator.

`fn shl(self, rhs: &usize) -> FixedI32<Frac>`[src]

`impl<'a, 'b, Frac: LeEqU32> Shl<&'a usize> for &'b FixedI32<Frac>`[src]

`type Output = FixedI32<Frac>`

The resulting type after applying the << operator.