Struct fixed::FixedI64 [−][src]
#[repr(transparent)]pub struct FixedI64<Frac> { /* fields omitted */ }
A 64-bit signed number with Frac
fractional bits.
The number has 64 bits, of which f = Frac
are fractional
bits and 64 − f are integer bits. The value x can lie
in the range −263/2f ≤ x < 263/2f. The difference between successive
numbers is constant throughout the range: Δ = 1/2f.
When f = 0, Δ = 1 and the fixed-point number behaves like an i64
with the value lying in the range −263 ≤ x < 263. When f = 64,
Δ = 1/264 and the value lies in the range −1/2 ≤ x < 1/2.
Frac
is an Unsigned
as provided by the typenum crate; the plan is to
to have a major version 2 with const generics instead when the Rust compiler
support for them is powerful enough.
Examples
use fixed::{types::extra::U3, FixedI64}; let eleven = FixedI64::<U3>::from_num(11); assert_eq!(eleven, FixedI64::<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, FixedI64::<U3>::from_bits(11 << 1)); assert_eq!(two_point_75, 2.75); assert_eq!(two_point_75.to_string(), "2.8");
Implementations
impl<Frac> FixedI64<Frac>
[src]
The implementation of items in this block is independent
of the number of fractional bits Frac
.
pub const ZERO: FixedI64<Frac>
[src]
Zero.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::ZERO, Fix::from_bits(0));
pub const DELTA: FixedI64<Frac>
[src]
The difference between any two successive representable numbers, Δ.
If the number has f = Frac
fractional bits, then
Δ = 1/2f.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::DELTA, Fix::from_bits(1)); // binary 0.0001 is decimal 0.0625 assert_eq!(Fix::DELTA, 0.0625);
pub const MIN: FixedI64<Frac>
[src]
The smallest value that can be represented.
If the number has f = Frac
fractional bits,
then the minimum is −263/2f.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::MIN, Fix::from_bits(i64::MIN));
pub const MAX: FixedI64<Frac>
[src]
The largest value that can be represented.
If the number has f = Frac
fractional bits, then the maximum is
(263 − 1)/2f.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::MAX, Fix::from_bits(i64::MAX));
pub const IS_SIGNED: bool
[src]
true
because the FixedI64
type is signed.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert!(Fix::IS_SIGNED);
pub const fn from_bits(bits: i64) -> FixedI64<Frac>
[src]
Creates a fixed-point number that has a bitwise representation identical to the given integer.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; // 0010.0000 == 2 assert_eq!(Fix::from_bits(0b10_0000), 2);
pub const fn to_bits(self) -> i64
[src]
Creates an integer that has a bitwise representation identical to the given fixed-point number.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; // 2 is 0010.0000 assert_eq!(Fix::from_num(2).to_bits(), 0b10_0000);
pub const fn from_be(f: FixedI64<Frac>) -> FixedI64<Frac>
[src]
Converts a fixed-point number from big endian to the target’s endianness.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; let f = Fix::from_bits(0x1234_5678_9ABC_DE0F); if cfg!(target_endian = "big") { assert_eq!(Fix::from_be(f), f); } else { assert_eq!(Fix::from_be(f), f.swap_bytes()); }
pub const fn from_le(f: FixedI64<Frac>) -> FixedI64<Frac>
[src]
Converts a fixed-point number from little endian to the target’s endianness.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; let f = Fix::from_bits(0x1234_5678_9ABC_DE0F); if cfg!(target_endian = "little") { assert_eq!(Fix::from_le(f), f); } else { assert_eq!(Fix::from_le(f), f.swap_bytes()); }
pub const fn to_be(self) -> FixedI64<Frac>
[src]
Converts self
to big endian from the target’s endianness.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; let f = Fix::from_bits(0x1234_5678_9ABC_DE0F); if cfg!(target_endian = "big") { assert_eq!(f.to_be(), f); } else { assert_eq!(f.to_be(), f.swap_bytes()); }
pub const fn to_le(self) -> FixedI64<Frac>
[src]
Converts self
to little endian from the target’s endianness.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; let f = Fix::from_bits(0x1234_5678_9ABC_DE0F); if cfg!(target_endian = "little") { assert_eq!(f.to_le(), f); } else { assert_eq!(f.to_le(), f.swap_bytes()); }
pub const fn swap_bytes(self) -> FixedI64<Frac>
[src]
Reverses the byte order of the fixed-point number.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; let f = Fix::from_bits(0x1234_5678_9ABC_DE0F); let swapped = Fix::from_bits(0x0FDE_BC9A_7856_3412); assert_eq!(f.swap_bytes(), swapped);
pub const fn from_be_bytes(bytes: [u8; 8]) -> FixedI64<Frac>
[src]
Creates a fixed-point number from its representation as a byte array in big endian.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!( Fix::from_be_bytes([0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE, 0x0F]), Fix::from_bits(0x1234_5678_9ABC_DE0F) );
pub const fn from_le_bytes(bytes: [u8; 8]) -> FixedI64<Frac>
[src]
Creates a fixed-point number from its representation as a byte array in little endian.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!( Fix::from_le_bytes([0x0F, 0xDE, 0xBC, 0x9A, 0x78, 0x56, 0x34, 0x12]), Fix::from_bits(0x1234_5678_9ABC_DE0F) );
pub const fn from_ne_bytes(bytes: [u8; 8]) -> FixedI64<Frac>
[src]
Creates a fixed-point number from its representation as a byte array in native endian.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!( if cfg!(target_endian = "big") { Fix::from_ne_bytes([0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE, 0x0F]) } else { Fix::from_ne_bytes([0x0F, 0xDE, 0xBC, 0x9A, 0x78, 0x56, 0x34, 0x12]) }, Fix::from_bits(0x1234_5678_9ABC_DE0F) );
pub const fn to_be_bytes(self) -> [u8; 8]
[src]
Returns the memory representation of this fixed-point number as a byte array in big-endian byte order.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; let val = Fix::from_bits(0x1234_5678_9ABC_DE0F); assert_eq!( val.to_be_bytes(), [0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE, 0x0F] );
pub const fn to_le_bytes(self) -> [u8; 8]
[src]
Returns the memory representation of this fixed-point number as a byte array in little-endian byte order.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; let val = Fix::from_bits(0x1234_5678_9ABC_DE0F); assert_eq!( val.to_le_bytes(), [0x0F, 0xDE, 0xBC, 0x9A, 0x78, 0x56, 0x34, 0x12] );
pub const fn to_ne_bytes(self) -> [u8; 8]
[src]
Returns the memory representation of this fixed-point number as a byte array in native byte order.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; let val = Fix::from_bits(0x1234_5678_9ABC_DE0F); assert_eq!( val.to_ne_bytes(), if cfg!(target_endian = "big") { [0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE, 0x0F] } else { [0x0F, 0xDE, 0xBC, 0x9A, 0x78, 0x56, 0x34, 0x12] } );
pub const fn count_ones(self) -> u32
[src]
Returns the number of ones in the binary representation.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<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, FixedI64}; type Fix = FixedI64<U4>; let f = Fix::from_bits(!0b11_0010); assert_eq!(f.count_zeros(), 3);
pub const fn leading_ones(self) -> u32
[src]
Returns the number of leading ones in the binary representation.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; let all_ones = !Fix::ZERO; let f = all_ones - Fix::from_bits(0b10_0000); assert_eq!(f.leading_ones(), 64 - 6);
pub const fn leading_zeros(self) -> u32
[src]
Returns the number of leading zeros in the binary representation.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; let f = Fix::from_bits(0b10_0000); assert_eq!(f.leading_zeros(), 64 - 6);
pub const fn trailing_ones(self) -> u32
[src]
Returns the number of trailing ones in the binary representation.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; let f = Fix::from_bits(0b101_1111); assert_eq!(f.trailing_ones(), 5);
pub const fn trailing_zeros(self) -> u32
[src]
Returns the number of trailing zeros in the binary representation.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; let f = Fix::from_bits(0b10_0000); assert_eq!(f.trailing_zeros(), 5);
pub const fn signed_bits(self) -> u32
[src]
Returns the number of bits required to represent the value.
The number of bits required includes an initial one for negative numbers, and an initial zero for non-negative numbers.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(-3).signed_bits(), 7); // “_101.0000” assert_eq!(Fix::from_num(-1).signed_bits(), 5); // “___1.0000” assert_eq!(Fix::from_num(-0.0625).signed_bits(), 1); // “____.___1” assert_eq!(Fix::from_num(0).signed_bits(), 1); // “____.___0” assert_eq!(Fix::from_num(0.0625).signed_bits(), 2); // “____.__01” assert_eq!(Fix::from_num(1).signed_bits(), 6); // “__01.0000” assert_eq!(Fix::from_num(3).signed_bits(), 7); // “_011.0000”
#[must_use = "this returns the result of the operation, without modifying the original"]pub const fn reverse_bits(self) -> FixedI64<Frac>
[src]
Reverses the order of the bits of the fixed-point number.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; let bits = 0x1234_5678_9ABC_DE0F_i64; let rev_bits = bits.reverse_bits(); assert_eq!(Fix::from_bits(bits).reverse_bits(), Fix::from_bits(rev_bits));
#[must_use = "this returns the result of the operation, without modifying the original"]pub const fn rotate_left(self, n: u32) -> FixedI64<Frac>
[src]
Shifts to the left by n
bits, wrapping the
truncated bits to the right end.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; let bits: i64 = (0b111 << (64 - 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));
#[must_use = "this returns the result of the operation, without modifying the original"]pub const fn rotate_right(self, n: u32) -> FixedI64<Frac>
[src]
Shifts to the right by n
bits, wrapping the
truncated bits to the left end.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; let bits: i64 = 0b1010111; let rot = (0b111 << (64 - 3)) | 0b1010; assert_eq!(bits.rotate_right(3), rot); assert_eq!(Fix::from_bits(bits).rotate_right(3), Fix::from_bits(rot));
pub const fn is_positive(self) -> bool
[src]
Returns true
if the number is > 0.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert!(Fix::from_num(5).is_positive()); assert!(!Fix::ZERO.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, FixedI64}; type Fix = FixedI64<U4>; assert!(!Fix::from_num(5).is_negative()); assert!(!Fix::ZERO.is_negative()); assert!(Fix::from_num(-5).is_negative());
#[must_use = "this returns the result of the operation, without modifying the original"]pub fn wide_mul<RhsFrac>(
self,
rhs: FixedI64<RhsFrac>
) -> FixedI128<Sum<Frac, RhsFrac>> where
Frac: Add<RhsFrac>,
[src]
self,
rhs: FixedI64<RhsFrac>
) -> FixedI128<Sum<Frac, RhsFrac>> where
Frac: Add<RhsFrac>,
Multiplies two fixed-point numbers and returns a wider type to retain all precision.
If self
has f fractional bits and 64 − f
integer bits, and rhs
has g fractional bits and 64 − g integer bits, then the returned fixed-point number will
have f + g fractional bits and 128 − f − g integer bits.
Examples
use fixed::{ types::extra::{U2, U4}, FixedI64, }; // decimal: 1.25 × 1.0625 = 1.328_125 // binary: 1.01 × 1.0001 == 1.010101 let a = FixedI64::<U2>::from_num(1.25); let b = FixedI64::<U4>::from_num(1.0625); assert_eq!(a.wide_mul(b), 1.328_125);
#[must_use = "this returns the result of the operation, without modifying the original"]pub fn mul_add<MulFrac: LeEqU64>(
self,
mul: FixedI64<MulFrac>,
add: FixedI64<Frac>
) -> FixedI64<Frac>
[src]
self,
mul: FixedI64<MulFrac>,
add: FixedI64<Frac>
) -> FixedI64<Frac>
Multiply and add. Returns self
× mul
+ add
.
For some cases, the product self
× mul
would overflow
on its own, but the final result self
× mul
+ add
is representable; in
these cases this method returns the correct result without overflow.
The mul
parameter can have a fixed-point type like
self
but with a different number of fractional bits.
Panics
When debug assertions are enabled, this method panics if the result
overflows. When debug assertions are not enabled, the wrapped value
can be returned, but it is not considered a breaking change if in the
future it panics; if wrapping is required use wrapping_mul_add
instead.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!( Fix::from_num(4).mul_add(Fix::from_num(0.5), Fix::from_num(3)), Fix::from_num(5) ); // MAX × 1.5 − MAX = MAX / 2, which does not overflow assert_eq!(Fix::MAX.mul_add(Fix::from_num(1.5), -Fix::MAX), Fix::MAX / 2);
#[must_use = "this returns the result of the operation, without modifying the original"]pub const fn rem_euclid(self, rhs: FixedI64<Frac>) -> FixedI64<Frac>
[src]
Remainder for Euclidean division.
Panics
Panics if the divisor is zero.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(7.5).rem_euclid(Fix::from_num(2)), Fix::from_num(1.5)); assert_eq!(Fix::from_num(-7.5).rem_euclid(Fix::from_num(2)), Fix::from_num(0.5));
pub const fn abs(self) -> FixedI64<Frac>
[src]
Returns the absolute value.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<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 const fn unsigned_abs(self) -> FixedU64<Frac>
[src]
Returns the absolute value using an unsigned type without any wrapping or panicking.
Examples
use fixed::{types::extra::U4, FixedI64, FixedU64}; type Fix = FixedI64<U4>; type UFix = FixedU64<U4>; assert_eq!(Fix::from_num(-5).unsigned_abs(), UFix::from_num(5)); // min_as_unsigned has only highest bit set let min_as_unsigned = UFix::ONE << (UFix::INT_NBITS - 1); assert_eq!(Fix::MIN.unsigned_abs(), min_as_unsigned);
#[must_use = "this returns the result of the operation, without modifying the original"]pub const fn mean(self, other: FixedI64<Frac>) -> FixedI64<Frac>
[src]
Returns the mean of self
and other
.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(3).mean(Fix::from_num(4)), Fix::from_num(3.5)); assert_eq!(Fix::from_num(-3).mean(Fix::from_num(4)), Fix::from_num(0.5));
pub const fn const_not(self) -> FixedI64<Frac>
[src]
Bitwise NOT. Usable in constant context.
This is equivalent to the !
operator and
Not::not
, but
can also be used in constant context. Unless required in constant
context, use the operator or trait instead.
Planned deprecation
This method will be deprecated when the !
operator and the
Not
trait are usable in constant context.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; const A: Fix = Fix::from_bits(0x3E); const NOT_A: Fix = A.const_not(); assert_eq!(NOT_A, !A);
#[must_use = "this returns the result of the operation, without modifying the original"]pub const fn const_bitand(self, rhs: FixedI64<Frac>) -> FixedI64<Frac>
[src]
Bitwise AND. Usable in constant context.
This is equivalent to the &
operator and
BitAnd::bitand
,
but can also be used in constant context. Unless required in constant
context, use the operator or trait instead.
Planned deprecation
This method will be deprecated when the &
operator and the
BitAnd
trait are usable in constant context.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; const A: Fix = Fix::from_bits(0x3E); const B: Fix = Fix::from_bits(0x55); const A_BITAND_B: Fix = A.const_bitand(B); assert_eq!(A_BITAND_B, A & B);
#[must_use = "this returns the result of the operation, without modifying the original"]pub const fn const_bitor(self, rhs: FixedI64<Frac>) -> FixedI64<Frac>
[src]
Bitwise OR. Usable in constant context.
This is equivalent to the |
operator and
BitOr::bitor
,
but can also be used in constant context. Unless required in constant
context, use the operator or trait instead.
Planned deprecation
This method will be deprecated when the |
operator and the
BitOr
trait are usable in constant context.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; const A: Fix = Fix::from_bits(0x3E); const B: Fix = Fix::from_bits(0x55); const A_BITOR_B: Fix = A.const_bitor(B); assert_eq!(A_BITOR_B, A | B);
#[must_use = "this returns the result of the operation, without modifying the original"]pub const fn const_bitxor(self, rhs: FixedI64<Frac>) -> FixedI64<Frac>
[src]
Bitwise XOR. Usable in constant context.
This is equivalent to the ^
operator and
BitXor::bitxor
,
but can also be used in constant context. Unless required in constant
context, use the operator or trait instead.
Planned deprecation
This method will be deprecated when the ^
operator and the
BitXor
trait are usable in constant context.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; const A: Fix = Fix::from_bits(0x3E); const B: Fix = Fix::from_bits(0x55); const A_BITXOR_B: Fix = A.const_bitxor(B); assert_eq!(A_BITXOR_B, A ^ B);
pub const fn checked_neg(self) -> Option<FixedI64<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, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(5).checked_neg(), Some(Fix::from_num(-5))); assert_eq!(Fix::MIN.checked_neg(), None);
#[must_use = "this returns the result of the operation, without modifying the original"]pub const fn checked_add(self, rhs: FixedI64<Frac>) -> Option<FixedI64<Frac>>
[src]
Checked addition. Returns the sum, or None
on overflow.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!((Fix::MAX - Fix::ONE).checked_add(Fix::ONE), Some(Fix::MAX)); assert_eq!(Fix::MAX.checked_add(Fix::ONE), None);
#[must_use = "this returns the result of the operation, without modifying the original"]pub const fn checked_sub(self, rhs: FixedI64<Frac>) -> Option<FixedI64<Frac>>
[src]
Checked subtraction. Returns the difference, or None
on overflow.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!((Fix::MIN + Fix::ONE).checked_sub(Fix::ONE), Some(Fix::MIN)); assert_eq!(Fix::MIN.checked_sub(Fix::ONE), None);
#[must_use = "this returns the result of the operation, without modifying the original"]pub const fn checked_rem(self, rhs: FixedI64<Frac>) -> Option<FixedI64<Frac>>
[src]
Checked remainder. Returns the remainder, or None
if
the divisor is zero.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(1.5).checked_rem(Fix::ONE), Some(Fix::from_num(0.5))); assert_eq!(Fix::from_num(1.5).checked_rem(Fix::ZERO), None);
#[must_use = "this returns the result of the operation, without modifying the original"]pub fn checked_mul_add<MulFrac: LeEqU64>(
self,
mul: FixedI64<MulFrac>,
add: FixedI64<Frac>
) -> Option<FixedI64<Frac>>
[src]
self,
mul: FixedI64<MulFrac>,
add: FixedI64<Frac>
) -> Option<FixedI64<Frac>>
Checked multiply and add.
Returns self
× mul
+ add
, or None
on overflow.
For some cases, the product self
× mul
would overflow
on its own, but the final result self
× mul
+ add
is representable; in
these cases this method returns the correct result without overflow.
The mul
parameter can have a fixed-point type like
self
but with a different number of fractional bits.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!( Fix::from_num(4).checked_mul_add(Fix::from_num(0.5), Fix::from_num(3)), Some(Fix::from_num(5)) ); assert_eq!(Fix::MAX.checked_mul_add(Fix::ONE, Fix::ZERO), Some(Fix::MAX)); assert_eq!(Fix::MAX.checked_mul_add(Fix::ONE, Fix::DELTA), None); // MAX × 1.5 − MAX = MAX / 2, which does not overflow assert_eq!(Fix::MAX.checked_mul_add(Fix::from_num(1.5), -Fix::MAX), Some(Fix::MAX / 2));
#[must_use = "this returns the result of the operation, without modifying the original"]pub const fn checked_mul_int(self, rhs: i64) -> Option<FixedI64<Frac>>
[src]
Checked multiplication by an integer. Returns the
product, or None
on overflow.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::MAX.checked_mul_int(1), Some(Fix::MAX)); assert_eq!(Fix::MAX.checked_mul_int(2), None);
#[must_use = "this returns the result of the operation, without modifying the original"]pub const fn checked_div_int(self, rhs: i64) -> Option<FixedI64<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, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::MAX.checked_div_int(1), Some(Fix::MAX)); assert_eq!(Fix::ONE.checked_div_int(0), None); assert_eq!(Fix::MIN.checked_div_int(-1), None);
#[must_use = "this returns the result of the operation, without modifying the original"]pub const fn checked_rem_euclid(
self,
rhs: FixedI64<Frac>
) -> Option<FixedI64<Frac>>
[src]
self,
rhs: FixedI64<Frac>
) -> Option<FixedI64<Frac>>
Checked remainder for Euclidean division. Returns the
remainder, or None
if the divisor is zero.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; let num = Fix::from_num(7.5); assert_eq!(num.checked_rem_euclid(Fix::from_num(2)), Some(Fix::from_num(1.5))); assert_eq!(num.checked_rem_euclid(Fix::ZERO), None); assert_eq!((-num).checked_rem_euclid(Fix::from_num(2)), Some(Fix::from_num(0.5)));
#[must_use = "this returns the result of the operation, without modifying the original"]pub const fn checked_shl(self, rhs: u32) -> Option<FixedI64<Frac>>
[src]
Checked shift left. Returns the shifted number,
or None
if rhs
≥ 64.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!((Fix::ONE / 2).checked_shl(3), Some(Fix::from_num(4))); assert_eq!((Fix::ONE / 2).checked_shl(64), None);
#[must_use = "this returns the result of the operation, without modifying the original"]pub const fn checked_shr(self, rhs: u32) -> Option<FixedI64<Frac>>
[src]
Checked shift right. Returns the shifted number,
or None
if rhs
≥ 64.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(4).checked_shr(3), Some(Fix::ONE / 2)); assert_eq!(Fix::from_num(4).checked_shr(64), None);
pub const fn checked_abs(self) -> Option<FixedI64<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, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(-5).checked_abs(), Some(Fix::from_num(5))); assert_eq!(Fix::MIN.checked_abs(), None);
pub const fn saturating_neg(self) -> FixedI64<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, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(5).saturating_neg(), Fix::from_num(-5)); assert_eq!(Fix::MIN.saturating_neg(), Fix::MAX);
#[must_use = "this returns the result of the operation, without modifying the original"]pub const fn saturating_add(self, rhs: FixedI64<Frac>) -> FixedI64<Frac>
[src]
Saturating addition. Returns the sum, saturating on overflow.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(3).saturating_add(Fix::from_num(2)), Fix::from_num(5)); assert_eq!(Fix::MAX.saturating_add(Fix::ONE), Fix::MAX);
#[must_use = "this returns the result of the operation, without modifying the original"]pub const fn saturating_sub(self, rhs: FixedI64<Frac>) -> FixedI64<Frac>
[src]
Saturating subtraction. Returns the difference, saturating on overflow.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::ONE.saturating_sub(Fix::from_num(3)), Fix::from_num(-2)); assert_eq!(Fix::MIN.saturating_sub(Fix::ONE), Fix::MIN);
#[must_use = "this returns the result of the operation, without modifying the original"]pub fn saturating_mul_add<MulFrac: LeEqU64>(
self,
mul: FixedI64<MulFrac>,
add: FixedI64<Frac>
) -> FixedI64<Frac>
[src]
self,
mul: FixedI64<MulFrac>,
add: FixedI64<Frac>
) -> FixedI64<Frac>
Saturating multiply and add.
Returns self
× mul
+ add
, saturating on overflow.
For some cases, the product self
× mul
would overflow
on its own, but the final result self
× mul
+ add
is representable; in
these cases this method returns the correct result without overflow.
The mul
parameter can have a fixed-point type like
self
but with a different number of fractional bits.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!( Fix::from_num(4).saturating_mul_add(Fix::from_num(0.5), Fix::from_num(3)), Fix::from_num(5) ); let half_max = Fix::MAX / 2; assert_eq!(half_max.saturating_mul_add(Fix::from_num(3), half_max), Fix::MAX); assert_eq!(half_max.saturating_mul_add(Fix::from_num(-5), half_max), Fix::MIN); // MAX × 1.5 − MAX = MAX / 2, which does not overflow assert_eq!(Fix::MAX.saturating_mul_add(Fix::from_num(1.5), -Fix::MAX), half_max);
#[must_use = "this returns the result of the operation, without modifying the original"]pub const fn saturating_mul_int(self, rhs: i64) -> FixedI64<Frac>
[src]
Saturating multiplication by an integer. Returns the product, saturating on overflow.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(3).saturating_mul_int(2), Fix::from_num(6)); assert_eq!(Fix::MAX.saturating_mul_int(2), Fix::MAX);
pub const fn saturating_abs(self) -> FixedI64<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, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(-5).saturating_abs(), Fix::from_num(5)); assert_eq!(Fix::MIN.saturating_abs(), Fix::MAX);
pub const fn wrapping_neg(self) -> FixedI64<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, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(5).wrapping_neg(), Fix::from_num(-5)); assert_eq!(Fix::MIN.wrapping_neg(), Fix::MIN);
#[must_use = "this returns the result of the operation, without modifying the original"]pub const fn wrapping_add(self, rhs: FixedI64<Frac>) -> FixedI64<Frac>
[src]
Wrapping addition. Returns the sum, wrapping on overflow.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; let one_minus_delta = Fix::ONE - Fix::DELTA; assert_eq!(Fix::from_num(3).wrapping_add(Fix::from_num(2)), Fix::from_num(5)); assert_eq!(Fix::MAX.wrapping_add(Fix::ONE), Fix::MIN + one_minus_delta);
#[must_use = "this returns the result of the operation, without modifying the original"]pub const fn wrapping_sub(self, rhs: FixedI64<Frac>) -> FixedI64<Frac>
[src]
Wrapping subtraction. Returns the difference, wrapping on overflow.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; let one_minus_delta = Fix::ONE - Fix::DELTA; assert_eq!(Fix::from_num(3).wrapping_sub(Fix::from_num(5)), Fix::from_num(-2)); assert_eq!(Fix::MIN.wrapping_sub(Fix::ONE), Fix::MAX - one_minus_delta);
#[must_use = "this returns the result of the operation, without modifying the original"]pub fn wrapping_mul_add<MulFrac: LeEqU64>(
self,
mul: FixedI64<MulFrac>,
add: FixedI64<Frac>
) -> FixedI64<Frac>
[src]
self,
mul: FixedI64<MulFrac>,
add: FixedI64<Frac>
) -> FixedI64<Frac>
Wrapping multiply and add.
Returns self
× mul
+ add
, wrapping on overflow.
The mul
parameter can have a fixed-point type like
self
but with a different number of fractional bits.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!( Fix::from_num(4).wrapping_mul_add(Fix::from_num(0.5), Fix::from_num(3)), Fix::from_num(5) ); assert_eq!(Fix::MAX.wrapping_mul_add(Fix::ONE, Fix::from_num(0)), Fix::MAX); assert_eq!(Fix::MAX.wrapping_mul_add(Fix::ONE, Fix::from_bits(1)), Fix::MIN); let wrapped = Fix::MAX.wrapping_mul_int(4); assert_eq!(Fix::MAX.wrapping_mul_add(Fix::from_num(3), Fix::MAX), wrapped);
#[must_use = "this returns the result of the operation, without modifying the original"]pub const fn wrapping_mul_int(self, rhs: i64) -> FixedI64<Frac>
[src]
Wrapping multiplication by an integer. Returns the product, wrapping on overflow.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(3).wrapping_mul_int(2), Fix::from_num(6)); let wrapped = Fix::from_bits(!0 << 2); assert_eq!(Fix::MAX.wrapping_mul_int(4), wrapped);
#[must_use = "this returns the result of the operation, without modifying the original"]pub const fn wrapping_div_int(self, rhs: i64) -> FixedI64<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, FixedI64}; type Fix = FixedI64<U4>; // 1.5 is binary 1.1 let one_point_5 = Fix::from_bits(0b11 << (4 - 1)); assert_eq!(Fix::from_num(3).wrapping_div_int(2), one_point_5); assert_eq!(Fix::MIN.wrapping_div_int(-1), Fix::MIN);
#[must_use = "this returns the result of the operation, without modifying the original"]pub const fn wrapping_shl(self, rhs: u32) -> FixedI64<Frac>
[src]
Wrapping shift left. Wraps rhs
if rhs
≥ 64,
then shifts and returns the number.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!((Fix::ONE / 2).wrapping_shl(3), Fix::from_num(4)); assert_eq!((Fix::ONE / 2).wrapping_shl(3 + 64), Fix::from_num(4));
#[must_use = "this returns the result of the operation, without modifying the original"]pub const fn wrapping_shr(self, rhs: u32) -> FixedI64<Frac>
[src]
Wrapping shift right. Wraps rhs
if rhs
≥ 64,
then shifts and returns the number.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!((Fix::from_num(4)).wrapping_shr(3), Fix::ONE / 2); assert_eq!((Fix::from_num(4)).wrapping_shr(3 + 64), Fix::ONE / 2);
pub const fn wrapping_abs(self) -> FixedI64<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, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(-5).wrapping_abs(), Fix::from_num(5)); assert_eq!(Fix::MIN.wrapping_abs(), Fix::MIN);
pub fn unwrapped_neg(self) -> FixedI64<Frac>
[src]
Unwrapped negation. Returns the negated value, panicking on overflow.
Overflow can only occur when negating the minimum value.
Panics
Panics if the result does not fit.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(5).unwrapped_neg(), Fix::from_num(-5));
The following panics because of overflow.
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; let _overflow = Fix::MIN.unwrapped_neg();
#[must_use = "this returns the result of the operation, without modifying the original"]pub fn unwrapped_add(self, rhs: FixedI64<Frac>) -> FixedI64<Frac>
[src]
Unwrapped addition. Returns the sum, panicking on overflow.
Panics
Panics if the result does not fit.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(3).unwrapped_add(Fix::from_num(2)), Fix::from_num(5));
The following panics because of overflow.
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; let _overflow = Fix::MAX.unwrapped_add(Fix::DELTA);
#[must_use = "this returns the result of the operation, without modifying the original"]pub fn unwrapped_sub(self, rhs: FixedI64<Frac>) -> FixedI64<Frac>
[src]
Unwrapped subtraction. Returns the difference, panicking on overflow.
Panics
Panics if the result does not fit.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(3).unwrapped_sub(Fix::from_num(5)), Fix::from_num(-2));
The following panics because of overflow.
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; let _overflow = Fix::MIN.unwrapped_sub(Fix::DELTA);
#[must_use = "this returns the result of the operation, without modifying the original"]pub const fn unwrapped_rem(self, rhs: FixedI64<Frac>) -> FixedI64<Frac>
[src]
Unwrapped remainder. Returns the remainder, panicking if the divisor is zero.
Panics
Panics if the divisor is zero.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(1.5).unwrapped_rem(Fix::ONE), Fix::from_num(0.5));
The following panics because the divisor is zero.
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; let _divisor_is_zero = Fix::from_num(1.5).unwrapped_rem(Fix::ZERO);
#[must_use = "this returns the result of the operation, without modifying the original"]pub fn unwrapped_mul_add<MulFrac: LeEqU64>(
self,
mul: FixedI64<MulFrac>,
add: FixedI64<Frac>
) -> FixedI64<Frac>
[src]
self,
mul: FixedI64<MulFrac>,
add: FixedI64<Frac>
) -> FixedI64<Frac>
Unwrapped multiply and add.
Returns self
× mul
+ add
, panicking on overflow.
For some cases, the product self
× mul
would overflow
on its own, but the final result self
× mul
+ add
is representable; in
these cases this method returns the correct result without overflow.
The mul
parameter can have a fixed-point type like
self
but with a different number of fractional bits.
Panics
Panics if the result does not fit.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!( Fix::from_num(4).unwrapped_mul_add(Fix::from_num(0.5), Fix::from_num(3)), Fix::from_num(5) ); // MAX × 1.5 − MAX = MAX / 2, which does not overflow assert_eq!(Fix::MAX.unwrapped_mul_add(Fix::from_num(1.5), -Fix::MAX), Fix::MAX / 2);
The following panics because of overflow.
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; let _overflow = Fix::MAX.unwrapped_mul_add(Fix::ONE, Fix::DELTA);
#[must_use = "this returns the result of the operation, without modifying the original"]pub fn unwrapped_mul_int(self, rhs: i64) -> FixedI64<Frac>
[src]
Unwrapped multiplication by an integer. Returns the product, panicking on overflow.
Panics
Panics if the result does not fit.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(3).unwrapped_mul_int(2), Fix::from_num(6));
The following panics because of overflow.
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; let _overflow = Fix::MAX.unwrapped_mul_int(4);
#[must_use = "this returns the result of the operation, without modifying the original"]pub const fn unwrapped_div_int(self, rhs: i64) -> FixedI64<Frac>
[src]
Unwrapped division by an integer. Returns the quotient, panicking on overflow.
Overflow can only occur when dividing the minimum value by −1.
Panics
Panics if the divisor is zero or if the division results in overflow.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; // 1.5 is binary 1.1 let one_point_5 = Fix::from_bits(0b11 << (4 - 1)); assert_eq!(Fix::from_num(3).unwrapped_div_int(2), one_point_5);
The following panics because the divisor is zero.
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; let _divisor_is_zero = Fix::from_num(3).unwrapped_div_int(0);
The following panics because of overflow.
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; let _overflow = Fix::MIN.unwrapped_div_int(-1);
#[must_use = "this returns the result of the operation, without modifying the original"]pub const fn unwrapped_rem_euclid(self, rhs: FixedI64<Frac>) -> FixedI64<Frac>
[src]
Unwrapped remainder for Euclidean division. Returns the remainder, panicking if the divisor is zero.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; let num = Fix::from_num(7.5); assert_eq!(num.unwrapped_rem_euclid(Fix::from_num(2)), Fix::from_num(1.5));
The following panics because the divisor is zero.
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; let _divisor_is_zero = Fix::from_num(3).unwrapped_rem_euclid(Fix::ZERO);
#[must_use = "this returns the result of the operation, without modifying the original"]pub fn unwrapped_shl(self, rhs: u32) -> FixedI64<Frac>
[src]
Unwrapped shift left. Panics if rhs
≥ 64.
Panics
Panics if rhs
≥ 64.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!((Fix::ONE / 2).unwrapped_shl(3), Fix::from_num(4));
The following panics because of overflow.
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; let _overflow = Fix::ONE.unwrapped_shl(64);
#[must_use = "this returns the result of the operation, without modifying the original"]pub fn unwrapped_shr(self, rhs: u32) -> FixedI64<Frac>
[src]
Unwrapped shift right. Panics if rhs
≥ 64.
Panics
Panics if rhs
≥ 64.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!((Fix::from_num(4)).unwrapped_shr(3), Fix::ONE / 2);
The following panics because of overflow.
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; let _overflow = Fix::ONE.unwrapped_shr(64);
pub fn unwrapped_abs(self) -> FixedI64<Frac>
[src]
Unwrapped absolute value. Returns the absolute value, panicking on overflow.
Overflow can only occur when trying to find the absolute value of the minimum value.
Panics
Panics if the result does not fit.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(-5).unwrapped_abs(), Fix::from_num(5));
The following panics because of overflow.
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; let _overflow = Fix::MIN.unwrapped_abs();
pub const fn overflowing_neg(self) -> (FixedI64<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, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(5).overflowing_neg(), (Fix::from_num(-5), false)); assert_eq!(Fix::MIN.overflowing_neg(), (Fix::MIN, true));
#[must_use = "this returns the result of the operation, without modifying the original"]pub const fn overflowing_add(
self,
rhs: FixedI64<Frac>
) -> (FixedI64<Frac>, bool)
[src]
self,
rhs: FixedI64<Frac>
) -> (FixedI64<Frac>, bool)
Overflowing addition.
Returns a tuple of the sum and a bool
indicating whether an
overflow has occurred. On overflow, the wrapped value is returned.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; let one_minus_delta = Fix::ONE - Fix::DELTA; assert_eq!(Fix::from_num(3).overflowing_add(Fix::from_num(2)), (Fix::from_num(5), false)); assert_eq!(Fix::MAX.overflowing_add(Fix::ONE), (Fix::MIN + one_minus_delta, true));
#[must_use = "this returns the result of the operation, without modifying the original"]pub const fn overflowing_sub(
self,
rhs: FixedI64<Frac>
) -> (FixedI64<Frac>, bool)
[src]
self,
rhs: FixedI64<Frac>
) -> (FixedI64<Frac>, bool)
Overflowing subtraction.
Returns a tuple of the difference and a bool
indicating whether an
overflow has occurred. On overflow, the wrapped value is returned.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; let one_minus_delta = Fix::ONE - Fix::DELTA; assert_eq!(Fix::from_num(3).overflowing_sub(Fix::from_num(5)), (Fix::from_num(-2), false)); assert_eq!(Fix::MIN.overflowing_sub(Fix::ONE), (Fix::MAX - one_minus_delta, true));
#[must_use = "this returns the result of the operation, without modifying the original"]pub fn overflowing_mul_add<MulFrac: LeEqU64>(
self,
mul: FixedI64<MulFrac>,
add: FixedI64<Frac>
) -> (FixedI64<Frac>, bool)
[src]
self,
mul: FixedI64<MulFrac>,
add: FixedI64<Frac>
) -> (FixedI64<Frac>, bool)
Overflowing multiply and add.
Returns a tuple of self
× mul
+ add
and a bool
indicating
whether an overflow has occurred. On overflow, the wrapped value is
returned.
For some cases, the product self
× mul
would overflow
on its own, but the final result self
× mul
+ add
is representable; in
these cases this method returns the correct result without overflow.
The mul
parameter can have a fixed-point type like
self
but with a different number of fractional bits.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!( Fix::MAX.overflowing_mul_add(Fix::ONE, Fix::ZERO), (Fix::MAX, false) ); assert_eq!( Fix::MAX.overflowing_mul_add(Fix::ONE, Fix::DELTA), (Fix::MIN, true) ); assert_eq!( Fix::MAX.overflowing_mul_add(Fix::from_num(3), Fix::MAX), Fix::MAX.overflowing_mul_int(4) ); // MAX × 1.5 − MAX = MAX / 2, which does not overflow assert_eq!( Fix::MAX.overflowing_mul_add(Fix::from_num(1.5), -Fix::MAX), (Fix::MAX / 2, false) );
#[must_use = "this returns the result of the operation, without modifying the original"]pub const fn overflowing_mul_int(self, rhs: i64) -> (FixedI64<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, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(3).overflowing_mul_int(2), (Fix::from_num(6), false)); let wrapped = Fix::from_bits(!0 << 2); assert_eq!(Fix::MAX.overflowing_mul_int(4), (wrapped, true));
#[must_use = "this returns the result of the operation, without modifying the original"]pub const fn overflowing_div_int(self, rhs: i64) -> (FixedI64<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, FixedI64}; type Fix = FixedI64<U4>; // 1.5 is binary 1.1 let one_point_5 = Fix::from_bits(0b11 << (4 - 1)); assert_eq!(Fix::from_num(3).overflowing_div_int(2), (one_point_5, false)); assert_eq!(Fix::MIN.overflowing_div_int(-1), (Fix::MIN, true));
#[must_use = "this returns the result of the operation, without modifying the original"]pub const fn overflowing_shl(self, rhs: u32) -> (FixedI64<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
≥ 64.
On overflow rhs
is wrapped before the shift operation.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!((Fix::ONE / 2).overflowing_shl(3), (Fix::from_num(4), false)); assert_eq!((Fix::ONE / 2).overflowing_shl(3 + 64), (Fix::from_num(4), true));
#[must_use = "this returns the result of the operation, without modifying the original"]pub const fn overflowing_shr(self, rhs: u32) -> (FixedI64<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
≥ 64.
On overflow rhs
is wrapped before the shift operation.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!((Fix::from_num(4)).overflowing_shr(3), (Fix::ONE / 2, false)); assert_eq!((Fix::from_num(4)).overflowing_shr(3 + 64), (Fix::ONE / 2, true));
pub const fn overflowing_abs(self) -> (FixedI64<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, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(-5).overflowing_abs(), (Fix::from_num(5), false)); assert_eq!(Fix::MIN.overflowing_abs(), (Fix::MIN, true));
impl<Frac: LeEqU64> FixedI64<Frac>
[src]
The implementation of items in this block depends on the
number of fractional bits Frac
.
pub const INT_NBITS: u32
[src]
The number of integer bits.
Examples
use fixed::{types::extra::U6, FixedI64}; type Fix = FixedI64<U6>; assert_eq!(Fix::INT_NBITS, 64 - 6);
pub const FRAC_NBITS: u32
[src]
The number of fractional bits.
Examples
use fixed::{types::extra::U6, FixedI64}; type Fix = FixedI64<U6>; assert_eq!(Fix::FRAC_NBITS, 6);
pub fn from_num<Src: ToFixed>(src: Src) -> FixedI64<Frac>
[src]
Creates a fixed-point number from another number.
The other number can be:
- Another fixed-point number. Any extra fractional bits are discarded, which rounds towards −∞.
- An integer of type
i8
,i16
,i32
,i64
,i128
,isize
,u8
,u16
,u32
,u64
,u128
, orusize
. - A floating-point number of type
f16
,bf16
,f32
,f64
orF128Bits
. For this conversion, the method rounds to the nearest, with ties rounding to even. - Any other number
src
for whichToFixed
is implemented, in which case this method returnssrc.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, FixedI64}; type Fix = FixedI64<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 discarded, which rounds towards −∞.
- An integer of type
i8
,i16
,i32
,i64
,i128
,isize
,u8
,u16
,u32
,u64
,u128
, orusize
. Any fractional bits are discarded, which rounds towards −∞. - A floating-point number of type
f16
,bf16
,f32
,f64
orF128Bits
. For this conversion, the method rounds to the nearest, with ties rounding to even. - Any other type
Dst
for whichFromFixed
is implemented, in which case this method returnsDst::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, FixedI64}; type Fix = FixedI64<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(0b1)); // 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<FixedI64<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 discarded, which rounds towards −∞.
- An integer of type
i8
,i16
,i32
,i64
,i128
,isize
,u8
,u16
,u32
,u64
,u128
, orusize
. - A floating-point number of type
f16
,bf16
,f32
,f64
orF128Bits
. For this conversion, the method rounds to the nearest, with ties rounding to even. - Any other number
src
for whichToFixed
is implemented, in which case this method returnssrc.checked_to_fixed()
.
Examples
use fixed::{ types::extra::{U2, U4}, types::I16F16, FixedI64, }; type Fix = FixedI64<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 = FixedI64::<U2>::MAX; assert!(Fix::checked_from_num(too_large).is_none()); assert_eq!(Fix::checked_from_num(3), Some(Fix::from_bits(3 << 4))); let too_large = i64::MAX; assert!(Fix::checked_from_num(too_large).is_none()); let too_small = i64::MIN; assert!(Fix::checked_from_num(too_small).is_none()); // 1.75 is 1.11 in binary let expected = Fix::from_bits(0b111 << (4 - 2)); assert_eq!(Fix::checked_from_num(1.75f32), Some(expected)); assert_eq!(Fix::checked_from_num(-1.75f64), Some(-expected)); assert!(Fix::checked_from_num(2e38).is_none()); assert!(Fix::checked_from_num(std::f64::NAN).is_none());
pub fn checked_to_num<Dst: FromFixed>(self) -> Option<Dst>
[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 discarded, which rounds towards −∞.
- An integer of type
i8
,i16
,i32
,i64
,i128
,isize
,u8
,u16
,u32
,u64
,u128
, orusize
. Any fractional bits are discarded, which rounds towards −∞. - A floating-point number of type
f16
,bf16
,f32
,f64
orF128Bits
. For this conversion, the method rounds to the nearest, with ties rounding to even. - Any other type
Dst
for whichFromFixed
is implemented, in which case this method returnsDst::checked_from_fixed(self)
.
Examples
use fixed::{ types::extra::{U0, U4, U6}, types::I16F16, FixedI64, }; type Fix = FixedI64<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 = FixedI64<U6>; assert!(Fix::MAX.checked_to_num::<TooFewIntBits>().is_none()); // 2.5 is 10.1 in binary let two_point_5 = Fix::from_bits(0b101 << (4 - 1)); assert_eq!(two_point_5.checked_to_num::<i32>(), Some(2)); assert_eq!((-two_point_5).checked_to_num::<i64>(), Some(-3)); type AllInt = FixedI64<U0>; assert!(AllInt::from_bits(-1).checked_to_num::<u64>().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) -> FixedI64<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 discarded, which rounds towards −∞.
- An integer of type
i8
,i16
,i32
,i64
,i128
,isize
,u8
,u16
,u32
,u64
,u128
, orusize
. - A floating-point number of type
f16
,bf16
,f32
,f64
orF128Bits
. For this conversion, the method rounds to the nearest, with ties rounding to even. - Any other number
src
for whichToFixed
is implemented, in which case this method returnssrc.saturating_to_fixed()
.
Panics
This method panics if the value is a floating-point NaN.
Examples
use fixed::{ types::extra::{U2, U4}, types::I16F16, FixedI64, }; type Fix = FixedI64<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 = FixedI64::<U2>::MAX; assert_eq!(Fix::saturating_from_num(too_large), Fix::MAX); assert_eq!(Fix::saturating_from_num(3), Fix::from_bits(3 << 4)); let too_small = i64::MIN; assert_eq!(Fix::saturating_from_num(too_small), Fix::MIN); // 1.75 is 1.11 in binary let expected = Fix::from_bits(0b111 << (4 - 2)); assert_eq!(Fix::saturating_from_num(1.75f32), expected); assert_eq!(Fix::saturating_from_num(-1.75f64), -expected); assert_eq!(Fix::saturating_from_num(2e38), Fix::MAX); assert_eq!(Fix::saturating_from_num(std::f64::NEG_INFINITY), Fix::MIN);
pub fn saturating_to_num<Dst: FromFixed>(self) -> Dst
[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 discarded, which rounds towards −∞.
- An integer of type
i8
,i16
,i32
,i64
,i128
,isize
,u8
,u16
,u32
,u64
,u128
, orusize
. Any fractional bits are discarded, which rounds towards −∞. - A floating-point number of type
f16
,bf16
,f32
,f64
orF128Bits
. For this conversion, the method rounds to the nearest, with ties rounding to even. - Any other type
Dst
for whichFromFixed
is implemented, in which case this method returnsDst::saturating_from_fixed(self)
.
Examples
use fixed::{ types::extra::{U0, U4, U6}, types::I16F16, FixedI64, }; type Fix = FixedI64<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 = FixedI64<U6>; let saturated = Fix::MAX.saturating_to_num::<TooFewIntBits>(); assert_eq!(saturated, TooFewIntBits::MAX); // 2.5 is 10.1 in binary let two_point_5 = Fix::from_bits(0b101 << (4 - 1)); assert_eq!(two_point_5.saturating_to_num::<i32>(), 2); type AllInt = FixedI64<U0>; assert_eq!(AllInt::from_bits(-1).saturating_to_num::<u64>(), 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) -> FixedI64<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 discarded, which rounds towards −∞.
- An integer of type
i8
,i16
,i32
,i64
,i128
,isize
,u8
,u16
,u32
,u64
,u128
, orusize
. - A floating-point number of type
f16
,bf16
,f32
,f64
orF128Bits
. For this conversion, the method rounds to the nearest, with ties rounding to even. - Any other number
src
for whichToFixed
is implemented, in which case this method returnssrc.wrapping_to_fixed()
.
Panics
For floating-point numbers, panics if the value is not finite.
Examples
use fixed::{ types::extra::{U0, U4}, types::I16F16, FixedI64, }; type Fix = FixedI64<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 << (64 - 7) will wrap to fixed-point 1010... let too_large = FixedI64::<U0>::from_bits(0b1101 << (64 - 7)); let wrapped = Fix::from_bits(0b1010 << (64 - 4)); assert_eq!(Fix::wrapping_from_num(too_large), wrapped); // integer 0b1101 << (64 - 7) will wrap to fixed-point 1010... let large: i64 = 0b1101 << (64 - 7); let wrapped = Fix::from_bits(0b1010 << (64 - 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 << (64 - 4) wraps to binary 11000... let large = 1.75 * 2f32.powi(64 - 4); let wrapped = Fix::from_bits(0b1100 << (64 - 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 discarded, which rounds towards −∞.
- An integer of type
i8
,i16
,i32
,i64
,i128
,isize
,u8
,u16
,u32
,u64
,u128
, orusize
. Any fractional bits are discarded, which rounds towards −∞. - A floating-point number of type
f16
,bf16
,f32
,f64
orF128Bits
. For this conversion, the method rounds to the nearest, with ties rounding to even. - Any other type
Dst
for whichFromFixed
is implemented, in which case this method returnsDst::wrapping_from_fixed(self)
.
Examples
use fixed::{ types::extra::{U0, U4, U6}, types::I16F16, FixedI64, }; type Fix = FixedI64<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 = FixedI64<U6>; let wrapped = TooFewIntBits::from_bits(Fix::MAX.to_bits() << 2); assert_eq!(Fix::MAX.wrapping_to_num::<TooFewIntBits>(), wrapped); // 2.5 is 10.1 in binary let two_point_5 = Fix::from_bits(0b101 << (4 - 1)); assert_eq!(two_point_5.wrapping_to_num::<i32>(), 2); type AllInt = FixedI64<U0>; assert_eq!(AllInt::from_bits(-1).wrapping_to_num::<u64>(), u64::MAX); // 1.625 is 1.101 in binary let one_point_625 = Fix::from_bits(0b1101 << (4 - 3)); assert_eq!(one_point_625.wrapping_to_num::<f32>(), 1.625f32);
pub fn unwrapped_from_num<Src: ToFixed>(src: Src) -> FixedI64<Frac>
[src]
Creates a fixed-point number from another number, panicking on overflow.
The other number can be:
- Another fixed-point number. Any extra fractional bits are discarded, which rounds towards −∞.
- An integer of type
i8
,i16
,i32
,i64
,i128
,isize
,u8
,u16
,u32
,u64
,u128
, orusize
. - A floating-point number of type
f16
,bf16
,f32
,f64
orF128Bits
. For this conversion, the method rounds to the nearest, with ties rounding to even. - Any other number
src
for whichToFixed
is implemented, in which case this method returnssrc.unwrapped_to_fixed()
.
Panics
Panics if the value does not fit.
For floating-point numbers, also panics if the value is not finite.
Examples
use fixed::{ types::{extra::U4, I16F16}, FixedI64, }; type Fix = FixedI64<U4>; // 1.75 is 1.11 in binary let src = I16F16::from_bits(0b111 << (16 - 2)); assert_eq!(Fix::unwrapped_from_num(src), Fix::from_bits(0b111 << (4 - 2)));
The following panics because of overflow.
use fixed::{ types::extra::{U0, U4}, FixedI64, }; type Fix = FixedI64<U4>; let too_large = FixedI64::<U0>::from_bits(0b1101 << (64 - 7)); let _overflow = Fix::unwrapped_from_num(too_large);
pub fn unwrapped_to_num<Dst: FromFixed>(self) -> Dst
[src]
Converts a fixed-point number to another number, panicking on overflow.
The other number can be:
- Another fixed-point number. Any extra fractional bits are discarded, which rounds towards −∞.
- An integer of type
i8
,i16
,i32
,i64
,i128
,isize
,u8
,u16
,u32
,u64
,u128
, orusize
. Any fractional bits are discarded, which rounds towards −∞. - A floating-point number of type
f16
,bf16
,f32
,f64
orF128Bits
. For this conversion, the method rounds to the nearest, with ties rounding to even. - Any other type
Dst
for whichFromFixed
is implemented, in which case this method returnsDst::unwrapped_from_fixed(self)
.
Panics
Panics if the value does not fit.
Examples
use fixed::{ types::{extra::U4, I16F16}, FixedI64, }; type Fix = FixedI64<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.unwrapped_to_num::<I16F16>(), expected);
The following panics because of overflow.
use fixed::{ types::extra::{U4, U6}, FixedI64, }; type Fix = FixedI64<U4>; type TooFewIntBits = FixedI64<U6>; let _overflow = Fix::MAX.unwrapped_to_num::<TooFewIntBits>();
pub fn overflowing_from_num<Src: ToFixed>(src: Src) -> (FixedI64<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 discarded, which rounds towards −∞.
- An integer of type
i8
,i16
,i32
,i64
,i128
,isize
,u8
,u16
,u32
,u64
,u128
, orusize
. - A floating-point number of type
f16
,bf16
,f32
,f64
orF128Bits
. For this conversion, the method rounds to the nearest, with ties rounding to even. - Any other number
src
for whichToFixed
is implemented, in which case this method returnssrc.overflowing_to_fixed()
.
Panics
For floating-point numbers, panics if the value is not finite.
Examples
use fixed::{ types::extra::{U0, U4}, types::I16F16, FixedI64, }; type Fix = FixedI64<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 << (64 - 7) will wrap to fixed-point 1010... let too_large = FixedI64::<U0>::from_bits(0b1101 << (64 - 7)); let wrapped = Fix::from_bits(0b1010 << (64 - 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 << (64 - 7) will wrap to fixed-point 1010... let large: i64 = 0b1101 << (64 - 7); let wrapped = Fix::from_bits(0b1010 << (64 - 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 << (64 - 4) wraps to binary 11000... let large = 1.75 * 2f32.powi(64 - 4); let wrapped = Fix::from_bits(0b1100 << (64 - 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 discarded, which rounds towards −∞.
- An integer of type
i8
,i16
,i32
,i64
,i128
,isize
,u8
,u16
,u32
,u64
,u128
, orusize
. Any fractional bits are discarded, which rounds towards −∞. - A floating-point number of type
f16
,bf16
,f32
,f64
orF128Bits
. For this conversion, the method rounds to the nearest, with ties rounding to even. - Any other type
Dst
for whichFromFixed
is implemented, in which case this method returnsDst::overflowing_from_fixed(self)
.
Examples
use fixed::{ types::extra::{U0, U4, U6}, types::I16F16, FixedI64, }; type Fix = FixedI64<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 = FixedI64<U6>; let wrapped = TooFewIntBits::from_bits(Fix::MAX.to_bits() << 2); assert_eq!(Fix::MAX.overflowing_to_num::<TooFewIntBits>(), (wrapped, true)); // 2.5 is 10.1 in binary let two_point_5 = Fix::from_bits(0b101 << (4 - 1)); assert_eq!(two_point_5.overflowing_to_num::<i32>(), (2, false)); let does_not_fit = FixedI64::<U0>::from_bits(-1); let wrapped = 1u64.wrapping_neg(); assert_eq!(does_not_fit.overflowing_to_num::<u64>(), (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<FixedI64<Frac>, ParseFixedError>
[src]
Parses a string slice containing binary digits to return a fixed-point number.
Rounding is to the nearest, with ties rounded to even.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<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<FixedI64<Frac>, ParseFixedError>
[src]
Parses a string slice containing octal digits to return a fixed-point number.
Rounding is to the nearest, with ties rounded to even.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<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<FixedI64<Frac>, ParseFixedError>
[src]
Parses a string slice containing hexadecimal digits to return a fixed-point number.
Rounding is to the nearest, with ties rounded to even.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<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<FixedI64<Frac>, ParseFixedError>
[src]
Parses a string slice containing decimal digits to return a fixed-point number, saturating on overflow.
Rounding is to the nearest, with ties rounded to even.
Examples
use fixed::types::I8F8; assert_eq!(I8F8::saturating_from_str("9999"), Ok(I8F8::MAX)); assert_eq!(I8F8::saturating_from_str("-9999"), Ok(I8F8::MIN));
pub fn saturating_from_str_binary(
src: &str
) -> Result<FixedI64<Frac>, ParseFixedError>
[src]
src: &str
) -> Result<FixedI64<Frac>, ParseFixedError>
Parses a string slice containing binary digits to return a fixed-point number, saturating on overflow.
Rounding is to the nearest, with ties rounded to even.
Examples
use fixed::types::I8F8; assert_eq!(I8F8::saturating_from_str_binary("101100111000"), Ok(I8F8::MAX)); assert_eq!(I8F8::saturating_from_str_binary("-101100111000"), Ok(I8F8::MIN));
pub fn saturating_from_str_octal(
src: &str
) -> Result<FixedI64<Frac>, ParseFixedError>
[src]
src: &str
) -> Result<FixedI64<Frac>, ParseFixedError>
Parses a string slice containing octal digits to return a fixed-point number, saturating on overflow.
Rounding is to the nearest, with ties rounded to even.
Examples
use fixed::types::I8F8; assert_eq!(I8F8::saturating_from_str_octal("7777"), Ok(I8F8::MAX)); assert_eq!(I8F8::saturating_from_str_octal("-7777"), Ok(I8F8::MIN));
pub fn saturating_from_str_hex(
src: &str
) -> Result<FixedI64<Frac>, ParseFixedError>
[src]
src: &str
) -> Result<FixedI64<Frac>, ParseFixedError>
Prases a string slice containing hexadecimal digits to return a fixed-point number, saturating on overflow.
Rounding is to the nearest, with ties rounded to even.
Examples
use fixed::types::I8F8; assert_eq!(I8F8::saturating_from_str_hex("FFFF"), Ok(I8F8::MAX)); assert_eq!(I8F8::saturating_from_str_hex("-FFFF"), Ok(I8F8::MIN));
pub fn wrapping_from_str(src: &str) -> Result<FixedI64<Frac>, ParseFixedError>
[src]
Parses a string slice containing decimal digits to return a fixed-point number, wrapping on overflow.
Rounding is to the nearest, with ties rounded to even.
Examples
use fixed::types::I8F8; // 9999.5 = 15.5 + 256 × n assert_eq!(I8F8::wrapping_from_str("9999.5"), Ok(I8F8::from_num(15.5))); assert_eq!(I8F8::wrapping_from_str("-9999.5"), Ok(I8F8::from_num(-15.5)));
pub fn wrapping_from_str_binary(
src: &str
) -> Result<FixedI64<Frac>, ParseFixedError>
[src]
src: &str
) -> Result<FixedI64<Frac>, ParseFixedError>
Parses a string slice containing binary digits to return a fixed-point number, wrapping on overflow.
Rounding is to the nearest, with ties rounded to even.
Examples
use fixed::types::I8F8; let check = I8F8::from_bits(0b1110001 << (8 - 1)); assert_eq!(I8F8::wrapping_from_str_binary("101100111000.1"), Ok(check)); assert_eq!(I8F8::wrapping_from_str_binary("-101100111000.1"), Ok(-check));
pub fn wrapping_from_str_octal(
src: &str
) -> Result<FixedI64<Frac>, ParseFixedError>
[src]
src: &str
) -> Result<FixedI64<Frac>, ParseFixedError>
Parses a string slice containing octal digits to return a fixed-point number, wrapping on overflow.
Rounding is to the nearest, with ties rounded to even.
Examples
use fixed::types::I8F8; let check = I8F8::from_bits(0o1654 << (8 - 3)); assert_eq!(I8F8::wrapping_from_str_octal("7165.4"), Ok(check)); assert_eq!(I8F8::wrapping_from_str_octal("-7165.4"), Ok(-check));
pub fn wrapping_from_str_hex(
src: &str
) -> Result<FixedI64<Frac>, ParseFixedError>
[src]
src: &str
) -> Result<FixedI64<Frac>, ParseFixedError>
Parses a string slice containing hexadecimal digits to return a fixed-point number, wrapping on overflow.
Rounding is to the nearest, with ties rounded to even.
Examples
use fixed::types::I8F8; let check = I8F8::from_bits(0xFFE); assert_eq!(I8F8::wrapping_from_str_hex("C0F.FE"), Ok(check)); assert_eq!(I8F8::wrapping_from_str_hex("-C0F.FE"), Ok(-check));
pub fn overflowing_from_str(
src: &str
) -> Result<(FixedI64<Frac>, bool), ParseFixedError>
[src]
src: &str
) -> Result<(FixedI64<Frac>, bool), ParseFixedError>
Parses a string slice containing decimal digits to return a fixed-point number.
Returns a tuple of the fixed-point number and a bool
indicating
whether an overflow has occurred. On overflow, the wrapped value is
returned.
Rounding is to the nearest, with ties rounded to even.
Examples
use fixed::types::I8F8; assert_eq!(I8F8::overflowing_from_str("99.5"), Ok((I8F8::from_num(99.5), false))); // 9999.5 = 15.5 + 256 × n assert_eq!(I8F8::overflowing_from_str("-9999.5"), Ok((I8F8::from_num(-15.5), true)));
pub fn overflowing_from_str_binary(
src: &str
) -> Result<(FixedI64<Frac>, bool), ParseFixedError>
[src]
src: &str
) -> Result<(FixedI64<Frac>, bool), ParseFixedError>
Parses a string slice containing binary digits to return a fixed-point number.
Returns a tuple of the fixed-point number and a bool
indicating
whether an overflow has occurred. On overflow, the wrapped value is
returned.
Rounding is to the nearest, with ties rounded to even.
Examples
use fixed::types::I8F8; let check = I8F8::from_bits(0b1110001 << (8 - 1)); assert_eq!(I8F8::overflowing_from_str_binary("111000.1"), Ok((check, false))); assert_eq!(I8F8::overflowing_from_str_binary("-101100111000.1"), Ok((-check, true)));
pub fn overflowing_from_str_octal(
src: &str
) -> Result<(FixedI64<Frac>, bool), ParseFixedError>
[src]
src: &str
) -> Result<(FixedI64<Frac>, bool), ParseFixedError>
Parses a string slice containing octal digits to return a fixed-point number.
Returns a tuple of the fixed-point number and a bool
indicating
whether an overflow has occurred. On overflow, the wrapped value is
returned.
Rounding is to the nearest, with ties rounded to even.
Examples
use fixed::types::I8F8; let check = I8F8::from_bits(0o1654 << (8 - 3)); assert_eq!(I8F8::overflowing_from_str_octal("165.4"), Ok((check, false))); assert_eq!(I8F8::overflowing_from_str_octal("-7165.4"), Ok((-check, true)));
pub fn overflowing_from_str_hex(
src: &str
) -> Result<(FixedI64<Frac>, bool), ParseFixedError>
[src]
src: &str
) -> Result<(FixedI64<Frac>, bool), ParseFixedError>
Parses a string slice containing hexadecimal digits to return a fixed-point number.
Returns a tuple of the fixed-point number and a bool
indicating
whether an overflow has occurred. On overflow, the wrapped value is
returned.
Rounding is to the nearest, with ties rounded to even.
Examples
use fixed::types::I8F8; let check = I8F8::from_bits(0xFFE); assert_eq!(I8F8::overflowing_from_str_hex("F.FE"), Ok((check, false))); assert_eq!(I8F8::overflowing_from_str_hex("-C0F.FE"), Ok((-check, true)));
pub fn int(self) -> FixedI64<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 FixedI64<U64>
, where the return value is always zero.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<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) -> FixedI64<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
FixedI64<U64>
where the return value is always equal to
self
.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; // 0000.0100 let quarter = Fix::ONE / 4; // 0010.0100 let two_and_quarter = quarter * 9; assert_eq!(two_and_quarter.frac(), quarter); // 0000.1100 let three_quarters = quarter * 3; // 1101.1100 assert_eq!((-two_and_quarter).frac(), three_quarters);
pub fn round_to_zero(self) -> FixedI64<Frac>
[src]
Rounds to the next integer towards 0.
Note that for negative numbers, this is different from truncating/discarding the fractional bits. This is because in two’s-complement representations, the value of all the bits except for the most significant bit is positive; discarding positive bits would round towards −∞ unlike this method which rounds towards zero.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(2.1).round_to_zero(), Fix::from_num(2)); assert_eq!(Fix::from_num(2.9).round_to_zero(), Fix::from_num(2)); assert_eq!(Fix::from_num(-2.1).round_to_zero(), Fix::from_num(-2)); assert_eq!(Fix::from_num(-2.9).round_to_zero(), Fix::from_num(-2));
pub fn ceil(self) -> FixedI64<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, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(2.5).ceil(), Fix::from_num(3)); assert_eq!(Fix::from_num(-2.5).ceil(), Fix::from_num(-2));
pub fn floor(self) -> FixedI64<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, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(2.5).floor(), Fix::from_num(2)); assert_eq!(Fix::from_num(-2.5).floor(), Fix::from_num(-3));
pub fn round(self) -> FixedI64<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, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(2.5).round(), Fix::from_num(3)); assert_eq!(Fix::from_num(-2.5).round(), Fix::from_num(-3));
pub fn round_ties_to_even(self) -> FixedI64<Frac>
[src]
Rounds to the nearest integer, with ties rounded to even.
Panics
When debug assertions are enabled, panics if the result does not fit.
When debug assertions are not enabled, the wrapped result can be
returned, but it is not considered a breaking change if in the future
it panics; if wrapping is required use wrapping_round_ties_to_even
instead.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(2.5).round_ties_to_even(), Fix::from_num(2)); assert_eq!(Fix::from_num(3.5).round_ties_to_even(), Fix::from_num(4));
pub fn checked_ceil(self) -> Option<FixedI64<Frac>>
[src]
Checked ceil. Rounds to the next integer towards +∞,
returning None
on overflow.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(2.5).checked_ceil(), Some(Fix::from_num(3))); assert_eq!(Fix::from_num(-2.5).checked_ceil(), Some(Fix::from_num(-2))); assert!(Fix::MAX.checked_ceil().is_none());
pub fn checked_floor(self) -> Option<FixedI64<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, U64}, FixedI64, }; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(2.5).checked_floor(), Some(Fix::from_num(2))); assert_eq!(Fix::from_num(-2.5).checked_floor(), Some(Fix::from_num(-3))); type AllFrac = FixedI64<U64>; assert!(AllFrac::MIN.checked_floor().is_none());
pub fn checked_round(self) -> Option<FixedI64<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, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(2.5).checked_round(), Some(Fix::from_num(3))); assert_eq!(Fix::from_num(-2.5).checked_round(), Some(Fix::from_num(-3))); assert!(Fix::MAX.checked_round().is_none());
pub fn checked_round_ties_to_even(self) -> Option<FixedI64<Frac>>
[src]
Checked round. Rounds to the nearest integer, with ties
rounded to even, returning None
on overflow.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(2.5).checked_round_ties_to_even(), Some(Fix::from_num(2))); assert_eq!(Fix::from_num(3.5).checked_round_ties_to_even(), Some(Fix::from_num(4))); assert!(Fix::MAX.checked_round_ties_to_even().is_none());
pub fn saturating_ceil(self) -> FixedI64<Frac>
[src]
Saturating ceil. Rounds to the next integer towards +∞, saturating on overflow.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(2.5).saturating_ceil(), Fix::from_num(3)); assert_eq!(Fix::from_num(-2.5).saturating_ceil(), Fix::from_num(-2)); assert_eq!(Fix::MAX.saturating_ceil(), Fix::MAX);
pub fn saturating_floor(self) -> FixedI64<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, U64}, FixedI64, }; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(2.5).saturating_floor(), Fix::from_num(2)); assert_eq!(Fix::from_num(-2.5).saturating_floor(), Fix::from_num(-3)); type AllFrac = FixedI64<U64>; assert_eq!(AllFrac::MIN.saturating_floor(), AllFrac::MIN);
pub fn saturating_round(self) -> FixedI64<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, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(2.5).saturating_round(), Fix::from_num(3)); assert_eq!(Fix::from_num(-2.5).saturating_round(), Fix::from_num(-3)); assert_eq!(Fix::MAX.saturating_round(), Fix::MAX);
pub fn saturating_round_ties_to_even(self) -> FixedI64<Frac>
[src]
Saturating round. Rounds to the nearest integer, with ties rounded to even, and saturating on overflow.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(2.5).saturating_round_ties_to_even(), Fix::from_num(2)); assert_eq!(Fix::from_num(3.5).saturating_round_ties_to_even(), Fix::from_num(4)); assert_eq!(Fix::MAX.saturating_round_ties_to_even(), Fix::MAX);
pub fn wrapping_ceil(self) -> FixedI64<Frac>
[src]
Wrapping ceil. Rounds to the next integer towards +∞, wrapping on overflow.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(2.5).wrapping_ceil(), Fix::from_num(3)); assert_eq!(Fix::from_num(-2.5).wrapping_ceil(), Fix::from_num(-2)); assert_eq!(Fix::MAX.wrapping_ceil(), Fix::MIN);
pub fn wrapping_floor(self) -> FixedI64<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, U64}, FixedI64, }; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(2.5).wrapping_floor(), Fix::from_num(2)); assert_eq!(Fix::from_num(-2.5).wrapping_floor(), Fix::from_num(-3)); type AllFrac = FixedI64<U64>; assert_eq!(AllFrac::MIN.wrapping_floor(), AllFrac::ZERO);
pub fn wrapping_round(self) -> FixedI64<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, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(2.5).wrapping_round(), Fix::from_num(3)); assert_eq!(Fix::from_num(-2.5).wrapping_round(), Fix::from_num(-3)); assert_eq!(Fix::MAX.wrapping_round(), Fix::MIN);
pub fn wrapping_round_ties_to_even(self) -> FixedI64<Frac>
[src]
Wrapping round. Rounds to the next integer to the nearest, with ties rounded to even, and wrapping on overflow.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(2.5).wrapping_round_ties_to_even(), Fix::from_num(2)); assert_eq!(Fix::from_num(3.5).wrapping_round_ties_to_even(), Fix::from_num(4)); assert_eq!(Fix::MAX.wrapping_round_ties_to_even(), Fix::MIN);
pub fn unwrapped_ceil(self) -> FixedI64<Frac>
[src]
Unwrapped ceil. Rounds to the next integer towards +∞, panicking on overflow.
Panics
Panics if the result does not fit.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(2.5).unwrapped_ceil(), Fix::from_num(3)); assert_eq!(Fix::from_num(-2.5).unwrapped_ceil(), Fix::from_num(-2));
The following panics because of overflow.
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; let _overflow = Fix::MAX.unwrapped_ceil();
pub fn unwrapped_floor(self) -> FixedI64<Frac>
[src]
Unwrapped floor. Rounds to the next integer towards −∞, panicking on overflow.
Overflow can only occur when there are zero integer bits.
Panics
Panics if the result does not fit.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(2.5).unwrapped_floor(), Fix::from_num(2)); assert_eq!(Fix::from_num(-2.5).unwrapped_floor(), Fix::from_num(-3));
The following panics because of overflow.
use fixed::{types::extra::U64, FixedI64}; type AllFrac = FixedI64<U64>; let _overflow = AllFrac::MIN.unwrapped_floor();
pub fn unwrapped_round(self) -> FixedI64<Frac>
[src]
Unwrapped round. Rounds to the next integer to the nearest, with ties rounded away from zero, and panicking on overflow.
Panics
Panics if the result does not fit.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(2.5).unwrapped_round(), Fix::from_num(3)); assert_eq!(Fix::from_num(-2.5).unwrapped_round(), Fix::from_num(-3));
The following panics because of overflow.
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; let _overflow = Fix::MAX.unwrapped_round();
pub fn unwrapped_round_ties_to_even(self) -> FixedI64<Frac>
[src]
Unwrapped round. Rounds to the next integer to the nearest, with ties rounded to even, and panicking on overflow.
Panics
Panics if the result does not fit.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(2.5).unwrapped_round_ties_to_even(), Fix::from_num(2)); assert_eq!(Fix::from_num(3.5).unwrapped_round_ties_to_even(), Fix::from_num(4));
The following panics because of overflow.
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; let _overflow = Fix::MAX.unwrapped_round_ties_to_even();
pub fn overflowing_ceil(self) -> (FixedI64<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, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(2.5).overflowing_ceil(), (Fix::from_num(3), false)); assert_eq!(Fix::from_num(-2.5).overflowing_ceil(), (Fix::from_num(-2), false)); assert_eq!(Fix::MAX.overflowing_ceil(), (Fix::MIN, true));
pub fn overflowing_floor(self) -> (FixedI64<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, U64}, FixedI64, }; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(2.5).overflowing_floor(), (Fix::from_num(2), false)); assert_eq!(Fix::from_num(-2.5).overflowing_floor(), (Fix::from_num(-3), false)); type AllFrac = FixedI64<U64>; assert_eq!(AllFrac::MIN.overflowing_floor(), (AllFrac::ZERO, true));
pub fn overflowing_round(self) -> (FixedI64<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, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(2.5).overflowing_round(), (Fix::from_num(3), false)); assert_eq!(Fix::from_num(-2.5).overflowing_round(), (Fix::from_num(-3), false)); assert_eq!(Fix::MAX.overflowing_round(), (Fix::MIN, true));
pub fn overflowing_round_ties_to_even(self) -> (FixedI64<Frac>, bool)
[src]
Overflowing round. Rounds to the next integer to the nearest, with ties rounded to even.
Returns a tuple of the fixed-point number and a bool
indicating
whether an overflow has occurred. On overflow, the wrapped value is
returned.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(2.5).overflowing_round_ties_to_even(), (Fix::from_num(2), false)); assert_eq!(Fix::from_num(3.5).overflowing_round_ties_to_even(), (Fix::from_num(4), false)); assert_eq!(Fix::MAX.overflowing_round_ties_to_even(), (Fix::MIN, true));
pub fn int_log2(self) -> i32
[src]
Integer base-2 logarithm, rounded down.
Panics
Panics if the fixed-point number is ≤ 0.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(4).int_log2(), 2); assert_eq!(Fix::from_num(3.9375).int_log2(), 1); assert_eq!(Fix::from_num(0.25).int_log2(), -2); assert_eq!(Fix::from_num(0.1875).int_log2(), -3);
pub fn int_log10(self) -> i32
[src]
Integer base-10 logarithm, rounded down.
Panics
Panics if the fixed-point number is ≤ 0.
Examples
use fixed::{ types::extra::{U2, U6}, FixedI64, }; assert_eq!(FixedI64::<U2>::from_num(10).int_log10(), 1); assert_eq!(FixedI64::<U2>::from_num(9.75).int_log10(), 0); assert_eq!(FixedI64::<U6>::from_num(0.109375).int_log10(), -1); assert_eq!(FixedI64::<U6>::from_num(0.09375).int_log10(), -2);
pub fn checked_int_log2(self) -> Option<i32>
[src]
Checked integer base-2 logarithm, rounded down.
Returns the logarithm or None
if the fixed-point number is
≤ 0.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::ZERO.checked_int_log2(), None); assert_eq!(Fix::from_num(4).checked_int_log2(), Some(2)); assert_eq!(Fix::from_num(3.9375).checked_int_log2(), Some(1)); assert_eq!(Fix::from_num(0.25).checked_int_log2(), Some(-2)); assert_eq!(Fix::from_num(0.1875).checked_int_log2(), Some(-3));
pub fn checked_int_log10(self) -> Option<i32>
[src]
Checked integer base-10 logarithm, rounded down.
Returns the logarithm or None
if the fixed-point number is
≤ 0.
Examples
use fixed::{ types::extra::{U2, U6}, FixedI64, }; assert_eq!(FixedI64::<U2>::ZERO.checked_int_log10(), None); assert_eq!(FixedI64::<U2>::from_num(10).checked_int_log10(), Some(1)); assert_eq!(FixedI64::<U2>::from_num(9.75).checked_int_log10(), Some(0)); assert_eq!(FixedI64::<U6>::from_num(0.109375).checked_int_log10(), Some(-1)); assert_eq!(FixedI64::<U6>::from_num(0.09375).checked_int_log10(), Some(-2));
pub fn signum(self) -> FixedI64<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, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(5).signum(), 1); assert_eq!(Fix::ZERO.signum(), 0); assert_eq!(Fix::from_num(-5).signum(), -1);
pub fn recip(self) -> FixedI64<Frac>
[src]
Returns the reciprocal (inverse) of the fixed-point number, 1/self
.
Panics
Panics if the fixed-point number is zero.
When debug assertions are enabled, this method also panics if the
reciprocal overflows. When debug assertions are not enabled, the
wrapped value can be returned, but it is not considered a breaking
change if in the future it panics; if wrapping is required use
wrapping_recip
instead.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(2).recip(), Fix::from_num(0.5));
#[must_use = "this returns the result of the operation, without modifying the original"]pub fn div_euclid(self, rhs: FixedI64<Frac>) -> FixedI64<Frac>
[src]
Euclidean division.
Panics
Panics if the divisor is zero.
When debug assertions are enabled, this method also panics if the
division overflows. When debug assertions are not enabled, the wrapped
value can be returned, but it is not considered a breaking change if
in the future it panics; if wrapping is required use
wrapping_div_euclid
instead.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(7.5).div_euclid(Fix::from_num(2)), Fix::from_num(3)); assert_eq!(Fix::from_num(-7.5).div_euclid(Fix::from_num(2)), Fix::from_num(-4));
#[must_use = "this returns the result of the operation, without modifying the original"]pub fn div_euclid_int(self, rhs: i64) -> FixedI64<Frac>
[src]
Euclidean division by an integer.
Panics
Panics if the divisor is zero.
When debug assertions are enabled, this method
also panics if the division overflows. Overflow can only occur when
dividing the minimum value by −1. When debug assertions are not
enabled, the wrapped value can be returned, but it is not considered a
breaking change if in the future it panics; if wrapping is required
use wrapping_div_euclid_int
instead.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(7.5).div_euclid_int(2), Fix::from_num(3)); assert_eq!(Fix::from_num(-7.5).div_euclid_int(2), Fix::from_num(-4));
pub fn mul_acc<AFrac: LeEqU64, BFrac: LeEqU64>(
&mut self,
a: FixedI64<AFrac>,
b: FixedI64<BFrac>
)
[src]
&mut self,
a: FixedI64<AFrac>,
b: FixedI64<BFrac>
)
Multiply and accumulate. Adds (a
× b
) to self
.
For some cases, the product a
× b
would overflow on its
own, but the final result self
+ a
× b
is representable; in these cases
this method saves the correct result without overflow.
The a
and b
parameters can have a fixed-point type like
self
but with a different number of fractional bits.
Panics
When debug assertions are enabled, this method panics if the result
overflows. When debug assertions are not enabled, the wrapped value
can be returned, but it is not considered a breaking change if in the
future it panics; if wrapping is required use wrapping_mul_acc
instead.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; let mut acc = Fix::from_num(3); acc.mul_acc(Fix::from_num(4), Fix::from_num(0.5)); assert_eq!(acc, 5); // MAX × 1.5 − MAX = MAX / 2, which does not overflow acc = -Fix::MAX; acc.mul_acc(Fix::MAX, Fix::from_num(1.5)); assert_eq!(acc, Fix::MAX / 2);
#[must_use = "this returns the result of the operation, without modifying the original"]pub fn rem_euclid_int(self, rhs: i64) -> FixedI64<Frac>
[src]
Remainder for Euclidean division by an integer.
Panics
Panics if the divisor is zero.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(7.5).rem_euclid_int(2), Fix::from_num(1.5)); assert_eq!(Fix::from_num(-7.5).rem_euclid_int(2), Fix::from_num(0.5));
pub fn checked_signum(self) -> Option<FixedI64<Frac>>
[src]
Checked signum. Returns a number representing the
sign of self
, or None
on overflow.
Overflow can only occur
- if the value is positive and the fixed-point number has zero or one integer bits such that it cannot hold the value 1.
- if the value is negative and the fixed-point number has zero integer bits, such that it cannot hold the value −1.
Examples
use fixed::{ types::extra::{U4, U63, U64}, FixedI64, }; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(5).checked_signum(), Some(Fix::ONE)); assert_eq!(Fix::ZERO.checked_signum(), Some(Fix::ZERO)); assert_eq!(Fix::from_num(-5).checked_signum(), Some(Fix::from_num(-1))); type OneIntBit = FixedI64<U63>; type ZeroIntBits = FixedI64<U64>; assert_eq!(OneIntBit::from_num(0.5).checked_signum(), None); assert_eq!(ZeroIntBits::from_num(0.25).checked_signum(), None); assert_eq!(ZeroIntBits::from_num(-0.5).checked_signum(), None);
#[must_use = "this returns the result of the operation, without modifying the original"]pub fn checked_mul(self, rhs: FixedI64<Frac>) -> Option<FixedI64<Frac>>
[src]
Checked multiplication. Returns the product, or None
on overflow.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::MAX.checked_mul(Fix::ONE), Some(Fix::MAX)); assert_eq!(Fix::MAX.checked_mul(Fix::from_num(2)), None);
#[must_use = "this returns the result of the operation, without modifying the original"]pub fn checked_div(self, rhs: FixedI64<Frac>) -> Option<FixedI64<Frac>>
[src]
Checked division. Returns the quotient, or None
if
the divisor is zero or on overflow.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::MAX.checked_div(Fix::ONE), Some(Fix::MAX)); assert_eq!(Fix::MAX.checked_div(Fix::ONE / 2), None);
pub fn checked_recip(self) -> Option<FixedI64<Frac>>
[src]
Checked reciprocal. Returns the reciprocal, or
None
if self
is zero or on overflow.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(2).checked_recip(), Some(Fix::from_num(0.5))); assert_eq!(Fix::ZERO.checked_recip(), None);
#[must_use = "this returns the result of the operation, without modifying the original"]pub fn checked_div_euclid(self, rhs: FixedI64<Frac>) -> Option<FixedI64<Frac>>
[src]
Checked Euclidean division. Returns the quotient, or
None
if the divisor is zero or on overflow.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(7.5).checked_div_euclid(Fix::from_num(2)), Some(Fix::from_num(3))); assert_eq!(Fix::from_num(7.5).checked_div_euclid(Fix::ZERO), None); assert_eq!(Fix::MAX.checked_div_euclid(Fix::from_num(0.25)), None); assert_eq!(Fix::from_num(-7.5).checked_div_euclid(Fix::from_num(2)), Some(Fix::from_num(-4)));
#[must_use = "this `Option` may be a `None` variant indicating overflow, which should be handled"]pub fn checked_mul_acc<AFrac: LeEqU64, BFrac: LeEqU64>(
&mut self,
a: FixedI64<AFrac>,
b: FixedI64<BFrac>
) -> Option<()>
[src]
&mut self,
a: FixedI64<AFrac>,
b: FixedI64<BFrac>
) -> Option<()>
Checked multiply and accumulate. Adds (a
× b
) to self
,
or returns None
on overflow.
Like all other checked methods, this method wraps the successful return value in
an Option
. Since the unchecked mul_acc
method does not return a value,
which is equivalent to returning ()
, this method wraps ()
into Some(())
on success.
When overflow occurs, self
is not modified and retains its previous value.
For some cases, the product a
× b
would overflow on its
own, but the final result self
+ a
× b
is representable; in these cases
this method saves the correct result without overflow.
The a
and b
parameters can have a fixed-point type like
self
but with a different number of fractional bits.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; let mut acc = Fix::from_num(3); let check = acc.checked_mul_acc(Fix::from_num(4), Fix::from_num(0.5)); assert_eq!(check, Some(())); assert_eq!(acc, 5); acc = Fix::DELTA; let check = acc.checked_mul_acc(Fix::MAX, Fix::ONE); assert_eq!(check, None); // acc is unchanged on error assert_eq!(acc, Fix::DELTA); // MAX × 1.5 − MAX = MAX / 2, which does not overflow acc = -Fix::MAX; let check = acc.checked_mul_acc(Fix::MAX, Fix::from_num(1.5)); assert_eq!(check, Some(())); assert_eq!(acc, Fix::MAX / 2);
#[must_use = "this returns the result of the operation, without modifying the original"]pub fn checked_rem_int(self, rhs: i64) -> Option<FixedI64<Frac>>
[src]
Checked fixed-point remainder for division by an integer.
Returns the remainder, or None
if the divisor is zero.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(3.75).checked_rem_int(2), Some(Fix::from_num(1.75))); assert_eq!(Fix::from_num(3.75).checked_rem_int(0), None); assert_eq!(Fix::from_num(-3.75).checked_rem_int(2), Some(Fix::from_num(-1.75)));
#[must_use = "this returns the result of the operation, without modifying the original"]pub fn checked_div_euclid_int(self, rhs: i64) -> Option<FixedI64<Frac>>
[src]
Checked Euclidean division by an integer. Returns the
quotient, or None
if the divisor is zero or if the division results in overflow.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(7.5).checked_div_euclid_int(2), Some(Fix::from_num(3))); assert_eq!(Fix::from_num(7.5).checked_div_euclid_int(0), None); assert_eq!(Fix::MIN.checked_div_euclid_int(-1), None);
#[must_use = "this returns the result of the operation, without modifying the original"]pub fn checked_rem_euclid_int(self, rhs: i64) -> Option<FixedI64<Frac>>
[src]
Checked remainder for Euclidean division by an integer.
Returns the remainder, or None
if the divisor is zero or if the remainder results in overflow.
Examples
use fixed::{types::extra::U60, FixedI64}; type Fix = FixedI64<U60>; assert_eq!(Fix::from_num(7.5).checked_rem_euclid_int(2), Some(Fix::from_num(1.5))); assert_eq!(Fix::from_num(7.5).checked_rem_euclid_int(0), None); assert_eq!(Fix::from_num(-7.5).checked_rem_euclid_int(2), Some(Fix::from_num(0.5))); // −8 ≤ Fix < 8, so the answer 12.5 overflows assert_eq!(Fix::from_num(-7.5).checked_rem_euclid_int(20), None);
pub fn saturating_signum(self) -> FixedI64<Frac>
[src]
Saturating signum. Returns a number representing
the sign of self
, saturating on overflow.
Overflow can only occur
- if the value is positive and the fixed-point number has zero or one integer bits such that it cannot hold the value 1.
- if the value is negative and the fixed-point number has zero integer bits, such that it cannot hold the value −1.
Examples
use fixed::{ types::extra::{U4, U63, U64}, FixedI64, }; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(5).saturating_signum(), 1); assert_eq!(Fix::ZERO.saturating_signum(), 0); assert_eq!(Fix::from_num(-5).saturating_signum(), -1); type OneIntBit = FixedI64<U63>; type ZeroIntBits = FixedI64<U64>; assert_eq!(OneIntBit::from_num(0.5).saturating_signum(), OneIntBit::MAX); assert_eq!(ZeroIntBits::from_num(0.25).saturating_signum(), ZeroIntBits::MAX); assert_eq!(ZeroIntBits::from_num(-0.5).saturating_signum(), ZeroIntBits::MIN);
#[must_use = "this returns the result of the operation, without modifying the original"]pub fn saturating_mul(self, rhs: FixedI64<Frac>) -> FixedI64<Frac>
[src]
Saturating multiplication. Returns the product, saturating on overflow.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(3).saturating_mul(Fix::from_num(2)), Fix::from_num(6)); assert_eq!(Fix::MAX.saturating_mul(Fix::from_num(2)), Fix::MAX);
#[must_use = "this returns the result of the operation, without modifying the original"]pub fn saturating_div(self, rhs: FixedI64<Frac>) -> FixedI64<Frac>
[src]
Saturating division. Returns the quotient, saturating on overflow.
Panics
Panics if the divisor is zero.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; let one_half = Fix::ONE / 2; assert_eq!(Fix::ONE.saturating_div(Fix::from_num(2)), one_half); assert_eq!(Fix::MAX.saturating_div(one_half), Fix::MAX);
pub fn saturating_recip(self) -> FixedI64<Frac>
[src]
Saturating reciprocal. Returns the reciprocal, saturating on overflow.
Panics
Panics if the fixed-point number is zero.
Examples
use fixed::{types::extra::U63, FixedI64}; // only one integer bit type Fix = FixedI64<U63>; assert_eq!(Fix::from_num(0.25).saturating_recip(), Fix::MAX); assert_eq!(Fix::from_num(-0.25).saturating_recip(), Fix::MIN);
#[must_use = "this returns the result of the operation, without modifying the original"]pub fn saturating_div_euclid(self, rhs: FixedI64<Frac>) -> FixedI64<Frac>
[src]
Saturating Euclidean division. Returns the quotient, saturating on overflow.
Panics
Panics if the divisor is zero.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(7.5).saturating_div_euclid(Fix::from_num(2)), Fix::from_num(3)); assert_eq!(Fix::MAX.saturating_div_euclid(Fix::from_num(0.25)), Fix::MAX); assert_eq!(Fix::from_num(-7.5).saturating_div_euclid(Fix::from_num(2)), Fix::from_num(-4)); assert_eq!(Fix::MIN.saturating_div_euclid(Fix::from_num(0.25)), Fix::MIN);
#[must_use = "this returns the result of the operation, without modifying the original"]pub fn saturating_div_euclid_int(self, rhs: i64) -> FixedI64<Frac>
[src]
Saturating Euclidean division by an integer. Returns the quotient, saturating 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, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(7.5).saturating_div_euclid_int(2), Fix::from_num(3)); assert_eq!(Fix::from_num(-7.5).saturating_div_euclid_int(2), Fix::from_num(-4)); assert_eq!(Fix::MIN.saturating_div_euclid_int(-1), Fix::MAX);
pub fn saturating_mul_acc<AFrac: LeEqU64, BFrac: LeEqU64>(
&mut self,
a: FixedI64<AFrac>,
b: FixedI64<BFrac>
)
[src]
&mut self,
a: FixedI64<AFrac>,
b: FixedI64<BFrac>
)
Saturating multiply and accumulate. Adds (a
× b
) to self
,
saturating on overflow.
For some cases, the product a
× b
would overflow on its
own, but the final result self
+ a
× b
is representable; in these cases
this method saves the correct result without overflow.
The a
and b
parameters can have a fixed-point type like
self
but with a different number of fractional bits.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; let mut acc = Fix::from_num(3); acc.saturating_mul_acc(Fix::from_num(4), Fix::from_num(0.5)); assert_eq!(acc, 5); acc = Fix::MAX / 2; acc.saturating_mul_acc(Fix::MAX / 2, Fix::from_num(3)); assert_eq!(acc, Fix::MAX); // MAX × 1.5 − MAX = MAX / 2, which does not overflow acc = -Fix::MAX; acc.saturating_mul_acc(Fix::MAX, Fix::from_num(1.5)); assert_eq!(acc, Fix::MAX / 2);
#[must_use = "this returns the result of the operation, without modifying the original"]pub fn saturating_rem_euclid_int(self, rhs: i64) -> FixedI64<Frac>
[src]
Saturating remainder for Euclidean division by an integer. Returns the remainder, saturating on overflow.
Panics
Panics if the divisor is zero.
Examples
use fixed::{types::extra::U60, FixedI64}; type Fix = FixedI64<U60>; assert_eq!(Fix::from_num(7.5).saturating_rem_euclid_int(2), Fix::from_num(1.5)); assert_eq!(Fix::from_num(-7.5).saturating_rem_euclid_int(2), Fix::from_num(0.5)); // −8 ≤ Fix < 8, so the answer 12.5 saturates assert_eq!(Fix::from_num(-7.5).saturating_rem_euclid_int(20), Fix::MAX);
pub fn wrapping_signum(self) -> FixedI64<Frac>
[src]
Wrapping signum. Returns a number representing
the sign of self
, wrapping on overflow.
Overflow can only occur
- if the value is positive and the fixed-point number has zero or one integer bits such that it cannot hold the value 1.
- if the value is negative and the fixed-point number has zero integer bits, such that it cannot hold the value −1.
Examples
use fixed::{ types::extra::{U4, U63, U64}, FixedI64, }; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(5).wrapping_signum(), 1); assert_eq!(Fix::ZERO.wrapping_signum(), 0); assert_eq!(Fix::from_num(-5).wrapping_signum(), -1); type OneIntBit = FixedI64<U63>; type ZeroIntBits = FixedI64<U64>; assert_eq!(OneIntBit::from_num(0.5).wrapping_signum(), -1); assert_eq!(ZeroIntBits::from_num(0.25).wrapping_signum(), 0); assert_eq!(ZeroIntBits::from_num(-0.5).wrapping_signum(), 0);
#[must_use = "this returns the result of the operation, without modifying the original"]pub fn wrapping_mul(self, rhs: FixedI64<Frac>) -> FixedI64<Frac>
[src]
Wrapping multiplication. Returns the product, wrapping on overflow.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(3).wrapping_mul(Fix::from_num(2)), Fix::from_num(6)); let wrapped = Fix::from_bits(!0 << 2); assert_eq!(Fix::MAX.wrapping_mul(Fix::from_num(4)), wrapped);
#[must_use = "this returns the result of the operation, without modifying the original"]pub fn wrapping_div(self, rhs: FixedI64<Frac>) -> FixedI64<Frac>
[src]
Wrapping division. Returns the quotient, wrapping on overflow.
Panics
Panics if the divisor is zero.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<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::ONE / 4; let wrapped = Fix::from_bits(!0 << 2); assert_eq!(Fix::MAX.wrapping_div(quarter), wrapped);
pub fn wrapping_recip(self) -> FixedI64<Frac>
[src]
Wrapping reciprocal. Returns the reciprocal, wrapping on overflow.
Panics
Panics if the fixed-point number is zero.
Examples
use fixed::{types::extra::U63, FixedI64}; // only one integer bit type Fix = FixedI64<U63>; assert_eq!(Fix::from_num(0.25).wrapping_recip(), Fix::ZERO);
#[must_use = "this returns the result of the operation, without modifying the original"]pub fn wrapping_div_euclid(self, rhs: FixedI64<Frac>) -> FixedI64<Frac>
[src]
Wrapping Euclidean division. Returns the quotient, wrapping on overflow.
Panics
Panics if the divisor is zero.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(7.5).wrapping_div_euclid(Fix::from_num(2)), Fix::from_num(3)); let wrapped = Fix::MAX.wrapping_mul_int(4).round_to_zero(); assert_eq!(Fix::MAX.wrapping_div_euclid(Fix::from_num(0.25)), wrapped);
#[must_use = "this returns the result of the operation, without modifying the original"]pub fn wrapping_div_euclid_int(self, rhs: i64) -> FixedI64<Frac>
[src]
Wrapping Euclidean division by an integer. Returns the quotient, wrapping on overflow.
Overflow can only occur when dividing the minimum value by −1.
Panics
Panics if the divisor is zero.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(7.5).wrapping_div_euclid_int(2), Fix::from_num(3)); assert_eq!(Fix::from_num(-7.5).wrapping_div_euclid_int(2), Fix::from_num(-4)); let wrapped = Fix::MIN.round_to_zero(); assert_eq!(Fix::MIN.wrapping_div_euclid_int(-1), wrapped);
pub fn wrapping_mul_acc<AFrac: LeEqU64, BFrac: LeEqU64>(
&mut self,
a: FixedI64<AFrac>,
b: FixedI64<BFrac>
)
[src]
&mut self,
a: FixedI64<AFrac>,
b: FixedI64<BFrac>
)
Wrapping multiply and accumulate. Adds (a
× b
) to self
,
wrapping on overflow.
The a
and b
parameters can have a fixed-point type like
self
but with a different number of fractional bits.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; let mut acc = Fix::from_num(3); acc.wrapping_mul_acc(Fix::from_num(4), Fix::from_num(0.5)); assert_eq!(acc, 5); acc = Fix::MAX; acc.wrapping_mul_acc(Fix::MAX, Fix::from_num(3)); assert_eq!(acc, Fix::MAX.wrapping_mul_int(4));
#[must_use = "this returns the result of the operation, without modifying the original"]pub fn wrapping_rem_euclid_int(self, rhs: i64) -> FixedI64<Frac>
[src]
Wrapping remainder for Euclidean division by an integer. Returns the remainder, wrapping on overflow.
Note that while remainder for Euclidean division cannot be negative, the wrapped value can be negative.
Panics
Panics if the divisor is zero.
Examples
use fixed::{types::extra::U60, FixedI64}; type Fix = FixedI64<U60>; assert_eq!(Fix::from_num(7.5).wrapping_rem_euclid_int(2), Fix::from_num(1.5)); assert_eq!(Fix::from_num(-7.5).wrapping_rem_euclid_int(2), Fix::from_num(0.5)); // −8 ≤ Fix < 8, so the answer 12.5 wraps to −3.5 assert_eq!(Fix::from_num(-7.5).wrapping_rem_euclid_int(20), Fix::from_num(-3.5));
pub fn unwrapped_signum(self) -> FixedI64<Frac>
[src]
Unwrapped signum. Returns a number representing
the sign of self
, panicking on overflow.
Overflow can only occur
- if the value is positive and the fixed-point number has zero or one integer bits such that it cannot hold the value 1.
- if the value is negative and the fixed-point number has zero integer bits, such that it cannot hold the value −1.
Panics
Panics if the result does not fit.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(5).unwrapped_signum(), 1); assert_eq!(Fix::ZERO.unwrapped_signum(), 0); assert_eq!(Fix::from_num(-5).unwrapped_signum(), -1);
The following panics because of overflow.
use fixed::{types::extra::U63, FixedI64}; type OneIntBit = FixedI64<U63>; let _overflow = OneIntBit::from_num(0.5).unwrapped_signum();
#[must_use = "this returns the result of the operation, without modifying the original"]pub fn unwrapped_mul(self, rhs: FixedI64<Frac>) -> FixedI64<Frac>
[src]
Unwrapped multiplication. Returns the product, panicking on overflow.
Panics
Panics if the result does not fit.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(3).unwrapped_mul(Fix::from_num(2)), Fix::from_num(6));
The following panics because of overflow.
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; let _overflow = Fix::MAX.unwrapped_mul(Fix::from_num(4));
#[must_use = "this returns the result of the operation, without modifying the original"]pub fn unwrapped_div(self, rhs: FixedI64<Frac>) -> FixedI64<Frac>
[src]
Unwrapped division. Returns the quotient, panicking on overflow.
Panics
Panics if the divisor is zero or if the division results in overflow.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; let one_point_5 = Fix::from_bits(0b11 << (4 - 1)); assert_eq!(Fix::from_num(3).unwrapped_div(Fix::from_num(2)), one_point_5);
The following panics because of overflow.
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; let quarter = Fix::ONE / 4; let _overflow = Fix::MAX.unwrapped_div(quarter);
pub fn unwrapped_recip(self) -> FixedI64<Frac>
[src]
Unwrapped reciprocal. Returns the reciprocal, panicking on overflow.
Panics
Panics if the fixed-point number is zero or on overflow.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(0.25).unwrapped_recip(), Fix::from_num(4));
#[must_use = "this returns the result of the operation, without modifying the original"]pub fn unwrapped_div_euclid(self, rhs: FixedI64<Frac>) -> FixedI64<Frac>
[src]
Unwrapped Euclidean division. Returns the quotient, panicking on overflow.
Panics
Panics if the divisor is zero or if the division results in overflow.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(7.5).unwrapped_div_euclid(Fix::from_num(2)), Fix::from_num(3));
The following panics because of overflow.
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; let _overflow = Fix::MAX.unwrapped_div_euclid(Fix::from_num(0.25));
pub fn unwrapped_mul_acc<AFrac: LeEqU64, BFrac: LeEqU64>(
&mut self,
a: FixedI64<AFrac>,
b: FixedI64<BFrac>
)
[src]
&mut self,
a: FixedI64<AFrac>,
b: FixedI64<BFrac>
)
Unwrapped multiply and accumulate. Adds (a
× b
) to self
,
panicking on overflow.
For some cases, the product a
× b
would overflow on its
own, but the final result self
+ a
× b
is representable; in these cases
this method saves the correct result without overflow.
The a
and b
parameters can have a fixed-point type like
self
but with a different number of fractional bits.
Panics
Panics if the result does not fit.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; let mut acc = Fix::from_num(3); acc.unwrapped_mul_acc(Fix::from_num(4), Fix::from_num(0.5)); assert_eq!(acc, 5); // MAX × 1.5 − MAX = MAX / 2, which does not overflow acc = -Fix::MAX; acc.unwrapped_mul_acc(Fix::MAX, Fix::from_num(1.5)); assert_eq!(acc, Fix::MAX / 2);
The following panics because of overflow.
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; let mut acc = Fix::DELTA; acc.unwrapped_mul_acc(Fix::MAX, Fix::ONE);
#[must_use = "this returns the result of the operation, without modifying the original"]pub fn unwrapped_rem_int(self, rhs: i64) -> FixedI64<Frac>
[src]
Unwrapped fixed-point remainder for division by an integer. Returns the remainder, panicking if the divisor is zero.
Panics
Panics if the divisor is zero.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(3.75).unwrapped_rem_int(2), Fix::from_num(1.75));
The following panics because the divisor is zero.
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; let _divisor_is_zero = Fix::from_num(3.75).unwrapped_rem_int(0);
#[must_use = "this returns the result of the operation, without modifying the original"]pub fn unwrapped_div_euclid_int(self, rhs: i64) -> FixedI64<Frac>
[src]
Unwrapped Euclidean division by an integer. Returns the quotient, panicking on overflow.
Overflow can only occur when dividing the minimum value by −1.
Panics
Panics if the divisor is zero or if the division results in overflow.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(7.5).unwrapped_div_euclid_int(2), Fix::from_num(3)); assert_eq!(Fix::from_num(-7.5).unwrapped_div_euclid_int(2), Fix::from_num(-4));
The following panics because of overflow.
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; let _overflow = Fix::MIN.unwrapped_div_euclid_int(-1);
#[must_use = "this returns the result of the operation, without modifying the original"]pub fn unwrapped_rem_euclid_int(self, rhs: i64) -> FixedI64<Frac>
[src]
Unwrapped remainder for Euclidean division by an integer. Returns the remainder, panicking on overflow.
Note that while remainder for Euclidean division cannot be negative, the wrapped value can be negative.
Panics
Panics if the divisor is zero or if the division results in overflow.
Examples
use fixed::{types::extra::U60, FixedI64}; type Fix = FixedI64<U60>; assert_eq!(Fix::from_num(7.5).unwrapped_rem_euclid_int(2), Fix::from_num(1.5)); assert_eq!(Fix::from_num(-7.5).unwrapped_rem_euclid_int(2), Fix::from_num(0.5));
The following panics because of overflow.
use fixed::{types::extra::U60, FixedI64}; type Fix = FixedI64<U60>; // −8 ≤ Fix < 8, so the answer 12.5 overflows let _overflow = Fix::from_num(-7.5).unwrapped_rem_euclid_int(20);
pub fn overflowing_signum(self) -> (FixedI64<Frac>, bool)
[src]
Overflowing signum.
Returns a tuple of the signum and a bool
indicating whether an
overflow has occurred. On overflow, the wrapped value is returned.
Overflow can only occur
- if the value is positive and the fixed-point number has zero or one integer bits such that it cannot hold the value 1.
- if the value is negative and the fixed-point number has zero integer bits, such that it cannot hold the value −1.
Examples
use fixed::{ types::extra::{U4, U63, U64}, FixedI64, }; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(5).overflowing_signum(), (Fix::ONE, false)); assert_eq!(Fix::ZERO.overflowing_signum(), (Fix::ZERO, false)); assert_eq!(Fix::from_num(-5).overflowing_signum(), (Fix::from_num(-1), false)); type OneIntBit = FixedI64<U63>; type ZeroIntBits = FixedI64<U64>; assert_eq!(OneIntBit::from_num(0.5).overflowing_signum(), (OneIntBit::from_num(-1), true)); assert_eq!(ZeroIntBits::from_num(0.25).overflowing_signum(), (ZeroIntBits::ZERO, true)); assert_eq!(ZeroIntBits::from_num(-0.5).overflowing_signum(), (ZeroIntBits::ZERO, true));
#[must_use = "this returns the result of the operation, without modifying the original"]pub fn overflowing_mul(self, rhs: FixedI64<Frac>) -> (FixedI64<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, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(3).overflowing_mul(Fix::from_num(2)), (Fix::from_num(6), false)); let wrapped = Fix::from_bits(!0 << 2); assert_eq!(Fix::MAX.overflowing_mul(Fix::from_num(4)), (wrapped, true));
#[must_use = "this returns the result of the operation, without modifying the original"]pub fn overflowing_div(self, rhs: FixedI64<Frac>) -> (FixedI64<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, FixedI64}; type Fix = FixedI64<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::ONE / 4; let wrapped = Fix::from_bits(!0 << 2); assert_eq!(Fix::MAX.overflowing_div(quarter), (wrapped, true));
pub fn overflowing_recip(self) -> (FixedI64<Frac>, bool)
[src]
Overflowing reciprocal.
Returns a tuple of the reciprocal and a bool
indicating whether
an overflow has occurred. On overflow, the wrapped value is returned.
Panics
Panics if the fixed-point number is zero.
Examples
use fixed::{ types::extra::{U4, U63}, FixedI64, }; type Fix = FixedI64<U4>; // only one integer bit type Small = FixedI64<U63>; assert_eq!(Fix::from_num(0.25).overflowing_recip(), (Fix::from_num(4), false)); assert_eq!(Small::from_num(0.25).overflowing_recip(), (Small::ZERO, true));
#[must_use = "this returns the result of the operation, without modifying the original"]pub fn overflowing_div_euclid(
self,
rhs: FixedI64<Frac>
) -> (FixedI64<Frac>, bool)
[src]
self,
rhs: FixedI64<Frac>
) -> (FixedI64<Frac>, bool)
Overflowing Euclidean division.
Returns a tuple of the quotient and a bool
indicating whether an
overflow has occurred. On overflow, the wrapped value is returned.
Panics
Panics if the divisor is zero.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; let check = Fix::from_num(3); assert_eq!(Fix::from_num(7.5).overflowing_div_euclid(Fix::from_num(2)), (check, false)); let wrapped = Fix::MAX.wrapping_mul_int(4).round_to_zero(); assert_eq!(Fix::MAX.overflowing_div_euclid(Fix::from_num(0.25)), (wrapped, true));
#[must_use = "this returns the result of the operation, without modifying the original"]pub fn overflowing_div_euclid_int(self, rhs: i64) -> (FixedI64<Frac>, bool)
[src]
Overflowing Euclidean division by an integer.
Returns a tuple of the quotient and a bool
indicating whether an overflow has
occurred. On overflow, the wrapped value is returned. Overflow can
only occur when dividing the minimum value by −1.
Panics
Panics if the divisor is zero.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::from_num(7.5).overflowing_div_euclid_int(2), (Fix::from_num(3), false)); assert_eq!(Fix::from_num(-7.5).overflowing_div_euclid_int(2), (Fix::from_num(-4), false)); let wrapped = Fix::MIN.round_to_zero(); assert_eq!(Fix::MIN.overflowing_div_euclid_int(-1), (wrapped, true));
#[must_use = "this returns whether overflow occurs; use `wrapping_mul_acc` if the flag is not needed"]pub fn overflowing_mul_acc<AFrac: LeEqU64, BFrac: LeEqU64>(
&mut self,
a: FixedI64<AFrac>,
b: FixedI64<BFrac>
) -> bool
[src]
&mut self,
a: FixedI64<AFrac>,
b: FixedI64<BFrac>
) -> bool
Overflowing multiply and accumulate. Adds (a
× b
) to self
,
wrapping and returning true
if overflow occurs.
For some cases, the product a
× b
would overflow on its
own, but the final result self
+ a
× b
is representable; in these cases
this method saves the correct result without overflow.
The a
and b
parameters can have a fixed-point type like
self
but with a different number of fractional bits.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; let mut acc = Fix::from_num(3); assert!(!acc.overflowing_mul_acc(Fix::from_num(4), Fix::from_num(0.5))); assert_eq!(acc, 5); acc = Fix::MAX; assert!(acc.overflowing_mul_acc(Fix::MAX, Fix::from_num(3))); assert_eq!(acc, Fix::MAX.wrapping_mul_int(4)); // MAX × 1.5 − MAX = MAX / 2, which does not overflow acc = -Fix::MAX; assert!(!acc.overflowing_mul_acc(Fix::MAX, Fix::from_num(1.5))); assert_eq!(acc, Fix::MAX / 2);
#[must_use = "this returns the result of the operation, without modifying the original"]pub fn overflowing_rem_euclid_int(self, rhs: i64) -> (FixedI64<Frac>, bool)
[src]
Remainder for Euclidean division by an integer.
Returns a tuple of the remainder and a bool
indicating whether an overflow has
occurred. On overflow, the wrapped value is returned.
Note that while remainder for Euclidean division cannot be negative, the wrapped value can be negative.
Panics
Panics if the divisor is zero.
Examples
use fixed::{types::extra::U60, FixedI64}; type Fix = FixedI64<U60>; assert_eq!(Fix::from_num(7.5).overflowing_rem_euclid_int(2), (Fix::from_num(1.5), false)); assert_eq!(Fix::from_num(-7.5).overflowing_rem_euclid_int(2), (Fix::from_num(0.5), false)); // −8 ≤ Fix < 8, so the answer 12.5 wraps to −3.5 assert_eq!(Fix::from_num(-7.5).overflowing_rem_euclid_int(20), (Fix::from_num(-3.5), true));
impl<Frac: LeEqU64> FixedI64<Frac>
[src]
This block contains constants in the range 0 < x < 0.5.
Examples
use fixed::{consts, types::extra::U64, FixedI64}; type Fix = FixedI64<U64>; assert_eq!(Fix::LOG10_2, Fix::from_num(consts::LOG10_2));
pub const FRAC_1_TAU: FixedI64<Frac>
[src]
1/τ = 0.159154…
pub const FRAC_2_TAU: FixedI64<Frac>
[src]
2/τ = 0.318309…
pub const FRAC_PI_8: FixedI64<Frac>
[src]
π/8 = 0.392699…
pub const FRAC_1_PI: FixedI64<Frac>
[src]
1/π = 0.318309…
pub const LOG10_2: FixedI64<Frac>
[src]
log10 2 = 0.301029…
pub const LOG10_E: FixedI64<Frac>
[src]
log10 e = 0.434294…
impl<Frac: Unsigned> FixedI64<Frac> where
Frac: IsLessOrEqual<U63, Output = True>,
[src]
Frac: IsLessOrEqual<U63, Output = True>,
This block contains constants in the range 0.5 ≤ x < 1.
These constants are not representable in signed fixed-point numbers with less than 1 integer bit.
Examples
use fixed::{consts, types::extra::U63, FixedI64}; type Fix = FixedI64<U63>; assert_eq!(Fix::LN_2, Fix::from_num(consts::LN_2)); assert!(0.5 <= Fix::LN_2 && Fix::LN_2 < 1);
The following example fails to compile, since the maximum representable value with 64 fractional bits and 0 integer bits is < 0.5.
use fixed::{consts, types::extra::U64, FixedI64}; type Fix = FixedI64<U64>; let _ = Fix::LN_2;
pub const FRAC_TAU_8: FixedI64<Frac>
[src]
τ/8 = 0.785398…
pub const FRAC_TAU_12: FixedI64<Frac>
[src]
τ/12 = 0.523598…
pub const FRAC_4_TAU: FixedI64<Frac>
[src]
4/τ = 0.636619…
pub const FRAC_PI_4: FixedI64<Frac>
[src]
π/4 = 0.785398…
pub const FRAC_PI_6: FixedI64<Frac>
[src]
π/6 = 0.523598…
pub const FRAC_2_PI: FixedI64<Frac>
[src]
2/π = 0.636619…
pub const FRAC_1_SQRT_PI: FixedI64<Frac>
[src]
1/√π = 0.564189…
pub const FRAC_1_SQRT_2: FixedI64<Frac>
[src]
1/√2 = 0.707106…
pub const FRAC_1_SQRT_3: FixedI64<Frac>
[src]
1/√3 = 0.577350…
pub const LN_2: FixedI64<Frac>
[src]
ln 2 = 0.693147…
pub const FRAC_1_PHI: FixedI64<Frac>
[src]
The golden ratio conjugate, Φ = 1/φ = 0.618033…
pub const GAMMA: FixedI64<Frac>
[src]
The Euler-Mascheroni constant, γ = 0.577215…
pub const CATALAN: FixedI64<Frac>
[src]
Catalan’s constant = 0.915965…
impl<Frac: Unsigned> FixedI64<Frac> where
Frac: IsLessOrEqual<U62, Output = True>,
[src]
Frac: IsLessOrEqual<U62, Output = True>,
This block contains constants in the range 1 ≤ x < 2.
These constants are not representable in signed fixed-point numbers with less than 2 integer bits.
Examples
use fixed::{consts, types::extra::U62, FixedI64}; type Fix = FixedI64<U62>; assert_eq!(Fix::LOG2_E, Fix::from_num(consts::LOG2_E)); assert!(1 <= Fix::LOG2_E && Fix::LOG2_E < 2);
The following example fails to compile, since the maximum representable value with 63 fractional bits and 1 integer bit is < 1.
use fixed::{consts, types::extra::U63, FixedI64}; type Fix = FixedI64<U63>; let _ = Fix::LOG2_E;
pub const ONE: FixedI64<Frac>
[src]
One.
Examples
use fixed::{types::extra::U4, FixedI64}; type Fix = FixedI64<U4>; assert_eq!(Fix::ONE, Fix::from_num(1));
pub const FRAC_TAU_4: FixedI64<Frac>
[src]
τ/4 = 1.57079…
pub const FRAC_TAU_6: FixedI64<Frac>
[src]
τ/6 = 1.04719…
pub const FRAC_PI_2: FixedI64<Frac>
[src]
π/2 = 1.57079…
pub const FRAC_PI_3: FixedI64<Frac>
[src]
π/3 = 1.04719…
pub const SQRT_PI: FixedI64<Frac>
[src]
√π = 1.77245…
pub const FRAC_2_SQRT_PI: FixedI64<Frac>
[src]
2/√π = 1.12837…
pub const SQRT_2: FixedI64<Frac>
[src]
√2 = 1.41421…
pub const SQRT_3: FixedI64<Frac>
[src]
√3 = 1.73205…
pub const SQRT_E: FixedI64<Frac>
[src]
√e = 1.64872…
pub const LOG2_E: FixedI64<Frac>
[src]
log2 e = 1.44269…
pub const PHI: FixedI64<Frac>
[src]
The golden ratio, φ = 1.61803…
pub const SQRT_PHI: FixedI64<Frac>
[src]
√φ = 1.27201…
impl<Frac: Unsigned> FixedI64<Frac> where
Frac: IsLessOrEqual<U61, Output = True>,
[src]
Frac: IsLessOrEqual<U61, Output = True>,
This block contains constants in the range 2 ≤ x < 4.
These constants are not representable in signed fixed-point numbers with less than 3 integer bits.
Examples
use fixed::{consts, types::extra::U61, FixedI64}; type Fix = FixedI64<U61>; assert_eq!(Fix::E, Fix::from_num(consts::E)); assert!(2 <= Fix::E && Fix::E < 4);
The following example fails to compile, since the maximum representable value with 62 fractional bits and 2 integer bits is < 2.
use fixed::{consts, types::extra::U62, FixedI64}; type Fix = FixedI64<U62>; let _ = Fix::E;
pub const FRAC_TAU_2: FixedI64<Frac>
[src]
τ/2 = 3.14159…
pub const FRAC_TAU_3: FixedI64<Frac>
[src]
τ/3 = 2.09439…
pub const PI: FixedI64<Frac>
[src]
Archimedes’ constant, π = 3.14159…
pub const E: FixedI64<Frac>
[src]
Euler’s number, e = 2.71828…
pub const LOG2_10: FixedI64<Frac>
[src]
log2 10 = 3.32192…
pub const LN_10: FixedI64<Frac>
[src]
ln 10 = 2.30258…
impl<Frac: Unsigned> FixedI64<Frac> where
Frac: IsLessOrEqual<U60, Output = True>,
[src]
Frac: IsLessOrEqual<U60, Output = True>,
This block contains constants in the range 4 ≤ x < 8.
These constants are not representable in signed fixed-point numbers with less than 4 integer bits.
Examples
use fixed::{consts, types::extra::U60, FixedI64}; type Fix = FixedI64<U60>; assert_eq!(Fix::TAU, Fix::from_num(consts::TAU)); assert!(4 <= Fix::TAU && Fix::TAU < 8);
The following example fails to compile, since the maximum representable value with 61 fractional bits and 3 integer bits is < 4.
use fixed::{consts, types::extra::U61, FixedI64}; type Fix = FixedI64<U61>; let _ = Fix::TAU;
Trait Implementations
impl<Frac> Add<&'_ FixedI64<Frac>> for FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the +
operator.
fn add(self, rhs: &FixedI64<Frac>) -> FixedI64<Frac>
[src]
impl<Frac> Add<&'_ FixedI64<Frac>> for &FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the +
operator.
fn add(self, rhs: &FixedI64<Frac>) -> FixedI64<Frac>
[src]
impl<Frac> Add<FixedI64<Frac>> for FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the +
operator.
fn add(self, rhs: FixedI64<Frac>) -> FixedI64<Frac>
[src]
impl<Frac> Add<FixedI64<Frac>> for &FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the +
operator.
fn add(self, rhs: FixedI64<Frac>) -> FixedI64<Frac>
[src]
impl<Frac> AddAssign<&'_ FixedI64<Frac>> for FixedI64<Frac>
[src]
fn add_assign(&mut self, rhs: &FixedI64<Frac>)
[src]
impl<Frac> AddAssign<FixedI64<Frac>> for FixedI64<Frac>
[src]
fn add_assign(&mut self, rhs: FixedI64<Frac>)
[src]
impl<Frac: LeEqU64> Binary for FixedI64<Frac>
[src]
impl<Frac> BitAnd<&'_ FixedI64<Frac>> for FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the &
operator.
fn bitand(self, rhs: &FixedI64<Frac>) -> FixedI64<Frac>
[src]
impl<Frac> BitAnd<&'_ FixedI64<Frac>> for &FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the &
operator.
fn bitand(self, rhs: &FixedI64<Frac>) -> FixedI64<Frac>
[src]
impl<Frac> BitAnd<FixedI64<Frac>> for FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the &
operator.
fn bitand(self, rhs: FixedI64<Frac>) -> FixedI64<Frac>
[src]
impl<Frac> BitAnd<FixedI64<Frac>> for &FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the &
operator.
fn bitand(self, rhs: FixedI64<Frac>) -> FixedI64<Frac>
[src]
impl<Frac> BitAndAssign<&'_ FixedI64<Frac>> for FixedI64<Frac>
[src]
fn bitand_assign(&mut self, rhs: &FixedI64<Frac>)
[src]
impl<Frac> BitAndAssign<FixedI64<Frac>> for FixedI64<Frac>
[src]
fn bitand_assign(&mut self, rhs: FixedI64<Frac>)
[src]
impl<Frac> BitOr<&'_ FixedI64<Frac>> for FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the |
operator.
fn bitor(self, rhs: &FixedI64<Frac>) -> FixedI64<Frac>
[src]
impl<Frac> BitOr<&'_ FixedI64<Frac>> for &FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the |
operator.
fn bitor(self, rhs: &FixedI64<Frac>) -> FixedI64<Frac>
[src]
impl<Frac> BitOr<FixedI64<Frac>> for FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the |
operator.
fn bitor(self, rhs: FixedI64<Frac>) -> FixedI64<Frac>
[src]
impl<Frac> BitOr<FixedI64<Frac>> for &FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the |
operator.
fn bitor(self, rhs: FixedI64<Frac>) -> FixedI64<Frac>
[src]
impl<Frac> BitOrAssign<&'_ FixedI64<Frac>> for FixedI64<Frac>
[src]
fn bitor_assign(&mut self, rhs: &FixedI64<Frac>)
[src]
impl<Frac> BitOrAssign<FixedI64<Frac>> for FixedI64<Frac>
[src]
fn bitor_assign(&mut self, rhs: FixedI64<Frac>)
[src]
impl<Frac> BitXor<&'_ FixedI64<Frac>> for FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: &FixedI64<Frac>) -> FixedI64<Frac>
[src]
impl<Frac> BitXor<&'_ FixedI64<Frac>> for &FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: &FixedI64<Frac>) -> FixedI64<Frac>
[src]
impl<Frac> BitXor<FixedI64<Frac>> for FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: FixedI64<Frac>) -> FixedI64<Frac>
[src]
impl<Frac> BitXor<FixedI64<Frac>> for &FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: FixedI64<Frac>) -> FixedI64<Frac>
[src]
impl<Frac> BitXorAssign<&'_ FixedI64<Frac>> for FixedI64<Frac>
[src]
fn bitxor_assign(&mut self, rhs: &FixedI64<Frac>)
[src]
impl<Frac> BitXorAssign<FixedI64<Frac>> for FixedI64<Frac>
[src]
fn bitxor_assign(&mut self, rhs: FixedI64<Frac>)
[src]
impl<Frac> Bounded for FixedI64<Frac>
[src]
impl<Frac: LeEqU64> Cast<F128Bits> for FixedI64<Frac>
[src]
impl<FracSrc: LeEqU64, FracDst: LeEqU128> Cast<FixedI128<FracDst>> for FixedI64<FracSrc>
[src]
impl<FracSrc: LeEqU64, FracDst: LeEqU16> Cast<FixedI16<FracDst>> for FixedI64<FracSrc>
[src]
impl<FracSrc: LeEqU64, FracDst: LeEqU32> Cast<FixedI32<FracDst>> for FixedI64<FracSrc>
[src]
impl<Frac: LeEqU64> Cast<FixedI64<Frac>> for F128Bits
[src]
impl<FracSrc: LeEqU8, FracDst: LeEqU64> Cast<FixedI64<FracDst>> for FixedI8<FracSrc>
[src]
impl<FracSrc: LeEqU16, FracDst: LeEqU64> Cast<FixedI64<FracDst>> for FixedI16<FracSrc>
[src]
impl<FracSrc: LeEqU32, FracDst: LeEqU64> Cast<FixedI64<FracDst>> for FixedI32<FracSrc>
[src]
impl<FracSrc: LeEqU64, FracDst: LeEqU64> Cast<FixedI64<FracDst>> for FixedI64<FracSrc>
[src]
impl<FracSrc: LeEqU128, FracDst: LeEqU64> Cast<FixedI64<FracDst>> for FixedI128<FracSrc>
[src]
impl<FracSrc: LeEqU8, FracDst: LeEqU64> Cast<FixedI64<FracDst>> for FixedU8<FracSrc>
[src]
impl<FracSrc: LeEqU16, FracDst: LeEqU64> Cast<FixedI64<FracDst>> for FixedU16<FracSrc>
[src]
impl<FracSrc: LeEqU32, FracDst: LeEqU64> Cast<FixedI64<FracDst>> for FixedU32<FracSrc>
[src]
impl<FracSrc: LeEqU64, FracDst: LeEqU64> Cast<FixedI64<FracDst>> for FixedU64<FracSrc>
[src]
impl<FracSrc: LeEqU128, FracDst: LeEqU64> Cast<FixedI64<FracDst>> for FixedU128<FracSrc>
[src]
impl<FracSrc: LeEqU64, FracDst: LeEqU8> Cast<FixedI8<FracDst>> for FixedI64<FracSrc>
[src]
impl<FracSrc: LeEqU64, FracDst: LeEqU128> Cast<FixedU128<FracDst>> for FixedI64<FracSrc>
[src]
impl<FracSrc: LeEqU64, FracDst: LeEqU16> Cast<FixedU16<FracDst>> for FixedI64<FracSrc>
[src]
impl<FracSrc: LeEqU64, FracDst: LeEqU32> Cast<FixedU32<FracDst>> for FixedI64<FracSrc>
[src]
impl<FracSrc: LeEqU64, FracDst: LeEqU64> Cast<FixedU64<FracDst>> for FixedI64<FracSrc>
[src]
impl<FracSrc: LeEqU64, FracDst: LeEqU8> Cast<FixedU8<FracDst>> for FixedI64<FracSrc>
[src]
impl<Frac: LeEqU64> Cast<bf16> for FixedI64<Frac>
[src]
impl<Frac: LeEqU64> Cast<f16> for FixedI64<Frac>
[src]
impl<Frac: LeEqU64> Cast<f32> for FixedI64<Frac>
[src]
impl<Frac: LeEqU64> Cast<f64> for FixedI64<Frac>
[src]
impl<Frac: LeEqU64> Cast<i128> for FixedI64<Frac>
[src]
impl<Frac: LeEqU64> Cast<i16> for FixedI64<Frac>
[src]
impl<Frac: LeEqU64> Cast<i32> for FixedI64<Frac>
[src]
impl<Frac: LeEqU64> Cast<i64> for FixedI64<Frac>
[src]
impl<Frac: LeEqU64> Cast<i8> for FixedI64<Frac>
[src]
impl<Frac: LeEqU64> Cast<isize> for FixedI64<Frac>
[src]
impl<Frac: LeEqU64> Cast<u128> for FixedI64<Frac>
[src]
impl<Frac: LeEqU64> Cast<u16> for FixedI64<Frac>
[src]
impl<Frac: LeEqU64> Cast<u32> for FixedI64<Frac>
[src]
impl<Frac: LeEqU64> Cast<u64> for FixedI64<Frac>
[src]
impl<Frac: LeEqU64> Cast<u8> for FixedI64<Frac>
[src]
impl<Frac: LeEqU64> Cast<usize> for FixedI64<Frac>
[src]
impl<Frac> CheckedAdd for FixedI64<Frac>
[src]
fn checked_add(&self, v: &Self) -> Option<Self>
[src]
impl<Frac: LeEqU64> CheckedCast<F128Bits> for FixedI64<Frac>
[src]
fn checked_cast(self) -> Option<F128Bits>
[src]
impl<FracSrc: LeEqU64, FracDst: LeEqU128> CheckedCast<FixedI128<FracDst>> for FixedI64<FracSrc>
[src]
fn checked_cast(self) -> Option<FixedI128<FracDst>>
[src]
impl<FracSrc: LeEqU64, FracDst: LeEqU16> CheckedCast<FixedI16<FracDst>> for FixedI64<FracSrc>
[src]
fn checked_cast(self) -> Option<FixedI16<FracDst>>
[src]
impl<FracSrc: LeEqU64, FracDst: LeEqU32> CheckedCast<FixedI32<FracDst>> for FixedI64<FracSrc>
[src]
fn checked_cast(self) -> Option<FixedI32<FracDst>>
[src]
impl<Frac: LeEqU64> CheckedCast<FixedI64<Frac>> for F128Bits
[src]
fn checked_cast(self) -> Option<FixedI64<Frac>>
[src]
impl<FracSrc: LeEqU8, FracDst: LeEqU64> CheckedCast<FixedI64<FracDst>> for FixedI8<FracSrc>
[src]
fn checked_cast(self) -> Option<FixedI64<FracDst>>
[src]
impl<FracSrc: LeEqU16, FracDst: LeEqU64> CheckedCast<FixedI64<FracDst>> for FixedI16<FracSrc>
[src]
fn checked_cast(self) -> Option<FixedI64<FracDst>>
[src]
impl<FracSrc: LeEqU32, FracDst: LeEqU64> CheckedCast<FixedI64<FracDst>> for FixedI32<FracSrc>
[src]
fn checked_cast(self) -> Option<FixedI64<FracDst>>
[src]
impl<FracSrc: LeEqU64, FracDst: LeEqU64> CheckedCast<FixedI64<FracDst>> for FixedI64<FracSrc>
[src]
fn checked_cast(self) -> Option<FixedI64<FracDst>>
[src]
impl<FracSrc: LeEqU128, FracDst: LeEqU64> CheckedCast<FixedI64<FracDst>> for FixedI128<FracSrc>
[src]
fn checked_cast(self) -> Option<FixedI64<FracDst>>
[src]
impl<FracSrc: LeEqU8, FracDst: LeEqU64> CheckedCast<FixedI64<FracDst>> for FixedU8<FracSrc>
[src]
fn checked_cast(self) -> Option<FixedI64<FracDst>>
[src]
impl<FracSrc: LeEqU16, FracDst: LeEqU64> CheckedCast<FixedI64<FracDst>> for FixedU16<FracSrc>
[src]
fn checked_cast(self) -> Option<FixedI64<FracDst>>
[src]
impl<FracSrc: LeEqU32, FracDst: LeEqU64> CheckedCast<FixedI64<FracDst>> for FixedU32<FracSrc>
[src]
fn checked_cast(self) -> Option<FixedI64<FracDst>>
[src]
impl<FracSrc: LeEqU64, FracDst: LeEqU64> CheckedCast<FixedI64<FracDst>> for FixedU64<FracSrc>
[src]
fn checked_cast(self) -> Option<FixedI64<FracDst>>
[src]
impl<FracSrc: LeEqU128, FracDst: LeEqU64> CheckedCast<FixedI64<FracDst>> for FixedU128<FracSrc>
[src]
fn checked_cast(self) -> Option<FixedI64<FracDst>>
[src]
impl<FracSrc: LeEqU64, FracDst: LeEqU8> CheckedCast<FixedI8<FracDst>> for FixedI64<FracSrc>
[src]
fn checked_cast(self) -> Option<FixedI8<FracDst>>
[src]
impl<FracSrc: LeEqU64, FracDst: LeEqU128> CheckedCast<FixedU128<FracDst>> for FixedI64<FracSrc>
[src]
fn checked_cast(self) -> Option<FixedU128<FracDst>>
[src]
impl<FracSrc: LeEqU64, FracDst: LeEqU16> CheckedCast<FixedU16<FracDst>> for FixedI64<FracSrc>
[src]
fn checked_cast(self) -> Option<FixedU16<FracDst>>
[src]
impl<FracSrc: LeEqU64, FracDst: LeEqU32> CheckedCast<FixedU32<FracDst>> for FixedI64<FracSrc>
[src]
fn checked_cast(self) -> Option<FixedU32<FracDst>>
[src]
impl<FracSrc: LeEqU64, FracDst: LeEqU64> CheckedCast<FixedU64<FracDst>> for FixedI64<FracSrc>
[src]
fn checked_cast(self) -> Option<FixedU64<FracDst>>
[src]
impl<FracSrc: LeEqU64, FracDst: LeEqU8> CheckedCast<FixedU8<FracDst>> for FixedI64<FracSrc>
[src]
fn checked_cast(self) -> Option<FixedU8<FracDst>>
[src]
impl<Frac: LeEqU64> CheckedCast<bf16> for FixedI64<Frac>
[src]
fn checked_cast(self) -> Option<bf16>
[src]
impl<Frac: LeEqU64> CheckedCast<f16> for FixedI64<Frac>
[src]
fn checked_cast(self) -> Option<f16>
[src]
impl<Frac: LeEqU64> CheckedCast<f32> for FixedI64<Frac>
[src]
fn checked_cast(self) -> Option<f32>
[src]
impl<Frac: LeEqU64> CheckedCast<f64> for FixedI64<Frac>
[src]
fn checked_cast(self) -> Option<f64>
[src]
impl<Frac: LeEqU64> CheckedCast<i128> for FixedI64<Frac>
[src]
fn checked_cast(self) -> Option<i128>
[src]
impl<Frac: LeEqU64> CheckedCast<i16> for FixedI64<Frac>
[src]
fn checked_cast(self) -> Option<i16>
[src]
impl<Frac: LeEqU64> CheckedCast<i32> for FixedI64<Frac>
[src]
fn checked_cast(self) -> Option<i32>
[src]
impl<Frac: LeEqU64> CheckedCast<i64> for FixedI64<Frac>
[src]
fn checked_cast(self) -> Option<i64>
[src]
impl<Frac: LeEqU64> CheckedCast<i8> for FixedI64<Frac>
[src]
fn checked_cast(self) -> Option<i8>
[src]
impl<Frac: LeEqU64> CheckedCast<isize> for FixedI64<Frac>
[src]
fn checked_cast(self) -> Option<isize>
[src]
impl<Frac: LeEqU64> CheckedCast<u128> for FixedI64<Frac>
[src]
fn checked_cast(self) -> Option<u128>
[src]
impl<Frac: LeEqU64> CheckedCast<u16> for FixedI64<Frac>
[src]
fn checked_cast(self) -> Option<u16>
[src]
impl<Frac: LeEqU64> CheckedCast<u32> for FixedI64<Frac>
[src]
fn checked_cast(self) -> Option<u32>
[src]
impl<Frac: LeEqU64> CheckedCast<u64> for FixedI64<Frac>
[src]
fn checked_cast(self) -> Option<u64>
[src]
impl<Frac: LeEqU64> CheckedCast<u8> for FixedI64<Frac>
[src]
fn checked_cast(self) -> Option<u8>
[src]
impl<Frac: LeEqU64> CheckedCast<usize> for FixedI64<Frac>
[src]
fn checked_cast(self) -> Option<usize>
[src]
impl<Frac: LeEqU64> CheckedDiv for FixedI64<Frac>
[src]
fn checked_div(&self, v: &Self) -> Option<Self>
[src]
impl<Frac: LeEqU64> CheckedMul for FixedI64<Frac>
[src]
fn checked_mul(&self, v: &Self) -> Option<Self>
[src]
impl<Frac> CheckedNeg for FixedI64<Frac>
[src]
fn checked_neg(&self) -> Option<Self>
[src]
impl<Frac> CheckedRem for FixedI64<Frac>
[src]
fn checked_rem(&self, v: &Self) -> Option<Self>
[src]
impl<Frac> CheckedShl for FixedI64<Frac>
[src]
fn checked_shl(&self, rhs: u32) -> Option<Self>
[src]
impl<Frac> CheckedShr for FixedI64<Frac>
[src]
fn checked_shr(&self, rhs: u32) -> Option<Self>
[src]
impl<Frac> CheckedSub for FixedI64<Frac>
[src]
fn checked_sub(&self, v: &Self) -> Option<Self>
[src]
impl<Frac> Clone for FixedI64<Frac>
[src]
impl<Frac> Copy for FixedI64<Frac>
[src]
impl<Frac: LeEqU64> Debug for FixedI64<Frac>
[src]
impl<Frac> Default for FixedI64<Frac>
[src]
impl<'de, Frac: LeEqU64> Deserialize<'de> for FixedI64<Frac>
[src]
fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>
[src]
impl<Frac: LeEqU64> Display for FixedI64<Frac>
[src]
impl<Frac: LeEqU64> Div<&'_ FixedI64<Frac>> for FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the /
operator.
fn div(self, rhs: &FixedI64<Frac>) -> FixedI64<Frac>
[src]
impl<Frac: LeEqU64> Div<&'_ FixedI64<Frac>> for &FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the /
operator.
fn div(self, rhs: &FixedI64<Frac>) -> FixedI64<Frac>
[src]
impl<Frac: LeEqU64> Div<&'_ i64> for FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the /
operator.
fn div(self, rhs: &i64) -> FixedI64<Frac>
[src]
impl<Frac: LeEqU64> Div<&'_ i64> for &FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the /
operator.
fn div(self, rhs: &i64) -> FixedI64<Frac>
[src]
impl<Frac: LeEqU64> Div<FixedI64<Frac>> for FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the /
operator.
fn div(self, rhs: FixedI64<Frac>) -> FixedI64<Frac>
[src]
impl<Frac: LeEqU64> Div<FixedI64<Frac>> for &FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the /
operator.
fn div(self, rhs: FixedI64<Frac>) -> FixedI64<Frac>
[src]
impl<Frac: LeEqU64> Div<i64> for FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the /
operator.
fn div(self, rhs: i64) -> FixedI64<Frac>
[src]
impl<Frac: LeEqU64> Div<i64> for &FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the /
operator.
fn div(self, rhs: i64) -> FixedI64<Frac>
[src]
impl<Frac: LeEqU64> DivAssign<&'_ FixedI64<Frac>> for FixedI64<Frac>
[src]
fn div_assign(&mut self, rhs: &FixedI64<Frac>)
[src]
impl<Frac: LeEqU64> DivAssign<&'_ i64> for FixedI64<Frac>
[src]
fn div_assign(&mut self, rhs: &i64)
[src]
impl<Frac: LeEqU64> DivAssign<FixedI64<Frac>> for FixedI64<Frac>
[src]
fn div_assign(&mut self, rhs: FixedI64<Frac>)
[src]
impl<Frac: LeEqU64> DivAssign<i64> for FixedI64<Frac>
[src]
fn div_assign(&mut self, rhs: i64)
[src]
impl<Frac: LeEqU64> Eq for FixedI64<Frac>
[src]
impl<Frac: LeEqU64> Fixed for FixedI64<Frac>
[src]
type Bits = i64
The primitive integer underlying type.
type Bytes = [u8; 8]
A byte array with the same size as the type.
type Frac = Frac
The number of fractional bits. Read more
const ZERO: Self
[src]
const DELTA: Self
[src]
const MIN: Self
[src]
const MAX: Self
[src]
const IS_SIGNED: bool
[src]
const INT_NBITS: u32
[src]
const FRAC_NBITS: u32
[src]
fn from_bits(bits: Self::Bits) -> Self
[src]
fn to_bits(self) -> Self::Bits
[src]
fn from_be(fixed: Self) -> Self
[src]
fn from_le(fixed: Self) -> Self
[src]
fn to_be(self) -> Self
[src]
fn to_le(self) -> Self
[src]
fn swap_bytes(self) -> Self
[src]
fn from_be_bytes(bits: Self::Bytes) -> Self
[src]
fn from_le_bytes(bits: Self::Bytes) -> Self
[src]
fn from_ne_bytes(bits: Self::Bytes) -> Self
[src]
fn to_be_bytes(self) -> Self::Bytes
[src]
fn to_le_bytes(self) -> Self::Bytes
[src]
fn to_ne_bytes(self) -> Self::Bytes
[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 unwrapped_from_num<Src: ToFixed>(val: Src) -> Self
[src]
fn unwrapped_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]
src: &str
) -> Result<(Self, bool), ParseFixedError>
fn overflowing_from_str_octal(
src: &str
) -> Result<(Self, bool), ParseFixedError>
[src]
src: &str
) -> Result<(Self, bool), ParseFixedError>
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_to_zero(self) -> Self
[src]
fn round(self) -> Self
[src]
fn round_ties_to_even(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 checked_round_ties_to_even(self) -> Option<Self>
[src]
fn saturating_ceil(self) -> Self
[src]
fn saturating_floor(self) -> Self
[src]
fn saturating_round(self) -> Self
[src]
fn saturating_round_ties_to_even(self) -> Self
[src]
fn wrapping_ceil(self) -> Self
[src]
fn wrapping_floor(self) -> Self
[src]
fn wrapping_round(self) -> Self
[src]
fn wrapping_round_ties_to_even(self) -> Self
[src]
fn unwrapped_ceil(self) -> Self
[src]
fn unwrapped_floor(self) -> Self
[src]
fn unwrapped_round(self) -> Self
[src]
fn unwrapped_round_ties_to_even(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 overflowing_round_ties_to_even(self) -> (Self, bool)
[src]
fn count_ones(self) -> u32
[src]
fn count_zeros(self) -> u32
[src]
fn leading_ones(self) -> u32
[src]
fn leading_zeros(self) -> u32
[src]
fn trailing_ones(self) -> u32
[src]
fn trailing_zeros(self) -> u32
[src]
fn int_log2(self) -> i32
[src]
fn int_log10(self) -> i32
[src]
fn checked_int_log2(self) -> Option<i32>
[src]
fn checked_int_log10(self) -> Option<i32>
[src]
fn reverse_bits(self) -> Self
[src]
fn rotate_left(self, n: u32) -> Self
[src]
fn rotate_right(self, n: u32) -> Self
[src]
fn mean(self, other: Self) -> Self
[src]
fn recip(self) -> Self
[src]
fn mul_add(self, mul: Self, add: Self) -> Self
[src]
fn mul_acc(&mut self, a: Self, b: Self)
[src]
fn div_euclid(self, rhs: Self) -> Self
[src]
fn rem_euclid(self, rhs: Self) -> Self
[src]
fn div_euclid_int(self, rhs: Self::Bits) -> Self
[src]
fn rem_euclid_int(self, rhs: Self::Bits) -> Self
[src]
fn checked_neg(self) -> Option<Self>
[src]
fn checked_add(self, rhs: Self) -> Option<Self>
[src]
fn checked_sub(self, rhs: Self) -> Option<Self>
[src]
fn checked_mul(self, rhs: Self) -> Option<Self>
[src]
fn checked_div(self, rhs: Self) -> Option<Self>
[src]
fn checked_rem(self, rhs: Self) -> Option<Self>
[src]
fn checked_recip(self) -> Option<Self>
[src]
fn checked_mul_add(self, mul: Self, add: Self) -> Option<Self>
[src]
fn checked_mul_acc(&mut self, a: Self, b: Self) -> Option<()>
[src]
fn checked_div_euclid(self, rhs: Self) -> Option<Self>
[src]
fn checked_rem_euclid(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_div_euclid_int(self, rhs: Self::Bits) -> Option<Self>
[src]
fn checked_rem_euclid_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_recip(self) -> Self
[src]
fn saturating_mul_add(self, mul: Self, add: Self) -> Self
[src]
fn saturating_mul_acc(&mut self, a: Self, b: Self)
[src]
fn saturating_div_euclid(self, rhs: Self) -> Self
[src]
fn saturating_mul_int(self, rhs: Self::Bits) -> Self
[src]
fn saturating_div_euclid_int(self, rhs: Self::Bits) -> Self
[src]
fn saturating_rem_euclid_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_recip(self) -> Self
[src]
fn wrapping_mul_add(self, mul: Self, add: Self) -> Self
[src]
fn wrapping_mul_acc(&mut self, a: Self, b: Self)
[src]
fn wrapping_div_euclid(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_div_euclid_int(self, rhs: Self::Bits) -> Self
[src]
fn wrapping_rem_euclid_int(self, rhs: Self::Bits) -> Self
[src]
fn wrapping_shl(self, rhs: u32) -> Self
[src]
fn wrapping_shr(self, rhs: u32) -> Self
[src]
fn unwrapped_neg(self) -> Self
[src]
fn unwrapped_add(self, rhs: Self) -> Self
[src]
fn unwrapped_sub(self, rhs: Self) -> Self
[src]
fn unwrapped_mul(self, rhs: Self) -> Self
[src]
fn unwrapped_div(self, rhs: Self) -> Self
[src]
fn unwrapped_rem(self, rhs: Self) -> Self
[src]
fn unwrapped_recip(self) -> Self
[src]
fn unwrapped_mul_add(self, mul: Self, add: Self) -> Self
[src]
fn unwrapped_mul_acc(&mut self, a: Self, b: Self)
[src]
fn unwrapped_div_euclid(self, rhs: Self) -> Self
[src]
fn unwrapped_rem_euclid(self, rhs: Self) -> Self
[src]
fn unwrapped_mul_int(self, rhs: Self::Bits) -> Self
[src]
fn unwrapped_div_int(self, rhs: Self::Bits) -> Self
[src]
fn unwrapped_rem_int(self, rhs: Self::Bits) -> Self
[src]
fn unwrapped_div_euclid_int(self, rhs: Self::Bits) -> Self
[src]
fn unwrapped_rem_euclid_int(self, rhs: Self::Bits) -> Self
[src]
fn unwrapped_shl(self, rhs: u32) -> Self
[src]
fn unwrapped_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_recip(self) -> (Self, bool)
[src]
fn overflowing_mul_add(self, mul: Self, add: Self) -> (Self, bool)
[src]
fn overflowing_mul_acc(&mut self, a: Self, b: Self) -> bool
[src]
fn overflowing_div_euclid(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_div_euclid_int(self, rhs: Self::Bits) -> (Self, bool)
[src]
fn overflowing_rem_euclid_int(self, rhs: Self::Bits) -> (Self, bool)
[src]
fn overflowing_shl(self, rhs: u32) -> (Self, bool)
[src]
fn overflowing_shr(self, rhs: u32) -> (Self, bool)
[src]
impl<Frac: LeEqU64> FixedOptionalFeatures for FixedI64<Frac>
[src]
impl<Frac: LeEqU64> FixedSigned for FixedI64<Frac>
[src]
type Unsigned = FixedU64<Frac>
An unsigned fixed-point number type with the same number of
integer and fractional bits as Self
. Read more
fn signed_bits(self) -> u32
[src]
fn abs(self) -> Self
[src]
fn unsigned_abs(self) -> Self::Unsigned
[src]
fn signum(self) -> Self
[src]
fn checked_abs(self) -> Option<Self>
[src]
fn checked_signum(self) -> Option<Self>
[src]
fn saturating_abs(self) -> Self
[src]
fn saturating_signum(self) -> Self
[src]
fn wrapping_abs(self) -> Self
[src]
fn wrapping_signum(self) -> Self
[src]
fn unwrapped_abs(self) -> Self
[src]
fn unwrapped_signum(self) -> Self
[src]
fn overflowing_abs(self) -> (Self, bool)
[src]
fn overflowing_signum(self) -> (Self, bool)
[src]
fn is_positive(self) -> bool
[src]
fn is_negative(self) -> bool
[src]
impl<Frac: LeEqU64> FloatConst for FixedI64<Frac>
[src]
fn E() -> Self
[src]
fn FRAC_1_PI() -> Self
[src]
fn FRAC_1_SQRT_2() -> Self
[src]
fn FRAC_2_PI() -> Self
[src]
fn FRAC_2_SQRT_PI() -> Self
[src]
fn FRAC_PI_2() -> Self
[src]
fn FRAC_PI_3() -> Self
[src]
fn FRAC_PI_4() -> Self
[src]
fn FRAC_PI_6() -> Self
[src]
fn FRAC_PI_8() -> Self
[src]
fn LN_10() -> Self
[src]
fn LN_2() -> Self
[src]
fn LOG10_E() -> Self
[src]
fn LOG2_E() -> Self
[src]
fn PI() -> Self
[src]
fn SQRT_2() -> Self
[src]
fn TAU() -> Self
[src]
fn LOG10_2() -> Self
[src]
fn LOG2_10() -> Self
[src]
impl<FracSrc: LeEqU16, FracDst: LeEqU64> From<FixedI16<FracSrc>> for FixedI64<FracDst> where
FracSrc: IsLessOrEqual<FracDst, Output = True>,
U16: Sub<FracSrc>,
U64: Sub<FracDst>,
Diff<U16, FracSrc>: IsLessOrEqual<Diff<U64, FracDst>, Output = True>,
[src]
FracSrc: IsLessOrEqual<FracDst, Output = True>,
U16: Sub<FracSrc>,
U64: Sub<FracDst>,
Diff<U16, FracSrc>: IsLessOrEqual<Diff<U64, FracDst>, Output = True>,
fn from(src: FixedI16<FracSrc>) -> Self
[src]
Converts a fixed-pint number.
This conversion never fails (infallible) and does not lose any precision (lossless).
impl<FracSrc: LeEqU32, FracDst: LeEqU64> From<FixedI32<FracSrc>> for FixedI64<FracDst> where
FracSrc: IsLessOrEqual<FracDst, Output = True>,
U32: Sub<FracSrc>,
U64: Sub<FracDst>,
Diff<U32, FracSrc>: IsLessOrEqual<Diff<U64, FracDst>, Output = True>,
[src]
FracSrc: IsLessOrEqual<FracDst, Output = True>,
U32: Sub<FracSrc>,
U64: Sub<FracDst>,
Diff<U32, FracSrc>: IsLessOrEqual<Diff<U64, FracDst>, Output = True>,
fn from(src: FixedI32<FracSrc>) -> Self
[src]
Converts a fixed-pint number.
This conversion never fails (infallible) and does not lose any precision (lossless).
impl<Frac: LeEqU64> From<FixedI64<Frac>> for F128Bits
[src]
fn from(src: FixedI64<Frac>) -> F128Bits
[src]
Converts a fixed-point number to a floating-point number.
This conversion never fails (infallible) and does not lose any precision (lossless).
impl<FracSrc: LeEqU64, FracDst: LeEqU128> From<FixedI64<FracSrc>> for FixedI128<FracDst> where
FracSrc: IsLessOrEqual<FracDst, Output = True>,
U64: Sub<FracSrc>,
U128: Sub<FracDst>,
Diff<U64, FracSrc>: IsLessOrEqual<Diff<U128, FracDst>, Output = True>,
[src]
FracSrc: IsLessOrEqual<FracDst, Output = True>,
U64: Sub<FracSrc>,
U128: Sub<FracDst>,
Diff<U64, FracSrc>: IsLessOrEqual<Diff<U128, FracDst>, Output = True>,
fn from(src: FixedI64<FracSrc>) -> Self
[src]
Converts a fixed-pint number.
This conversion never fails (infallible) and does not lose any precision (lossless).
impl<FracSrc: LeEqU8, FracDst: LeEqU64> From<FixedI8<FracSrc>> for FixedI64<FracDst> where
FracSrc: IsLessOrEqual<FracDst, Output = True>,
U8: Sub<FracSrc>,
U64: Sub<FracDst>,
Diff<U8, FracSrc>: IsLessOrEqual<Diff<U64, FracDst>, Output = True>,
[src]
FracSrc: IsLessOrEqual<FracDst, Output = True>,
U8: Sub<FracSrc>,
U64: Sub<FracDst>,
Diff<U8, FracSrc>: IsLessOrEqual<Diff<U64, FracDst>, Output = True>,
fn from(src: FixedI8<FracSrc>) -> Self
[src]
Converts a fixed-pint number.
This conversion never fails (infallible) and does not lose any precision (lossless).
impl<FracSrc: LeEqU16, FracDst: LeEqU64> From<FixedU16<FracSrc>> for FixedI64<FracDst> where
FracSrc: IsLessOrEqual<FracDst, Output = True>,
U16: Sub<FracSrc>,
U63: Sub<FracDst>,
Diff<U16, FracSrc>: IsLessOrEqual<Diff<U63, FracDst>, Output = True>,
[src]
FracSrc: IsLessOrEqual<FracDst, Output = True>,
U16: Sub<FracSrc>,
U63: Sub<FracDst>,
Diff<U16, FracSrc>: IsLessOrEqual<Diff<U63, FracDst>, Output = True>,
fn from(src: FixedU16<FracSrc>) -> Self
[src]
Converts a fixed-pint number.
This conversion never fails (infallible) and does not lose any precision (lossless).
impl<FracSrc: LeEqU32, FracDst: LeEqU64> From<FixedU32<FracSrc>> for FixedI64<FracDst> where
FracSrc: IsLessOrEqual<FracDst, Output = True>,
U32: Sub<FracSrc>,
U63: Sub<FracDst>,
Diff<U32, FracSrc>: IsLessOrEqual<Diff<U63, FracDst>, Output = True>,
[src]
FracSrc: IsLessOrEqual<FracDst, Output = True>,
U32: Sub<FracSrc>,
U63: Sub<FracDst>,
Diff<U32, FracSrc>: IsLessOrEqual<Diff<U63, FracDst>, Output = True>,
fn from(src: FixedU32<FracSrc>) -> Self
[src]
Converts a fixed-pint number.
This conversion never fails (infallible) and does not lose any precision (lossless).
impl<FracSrc: LeEqU8, FracDst: LeEqU64> From<FixedU8<FracSrc>> for FixedI64<FracDst> where
FracSrc: IsLessOrEqual<FracDst, Output = True>,
U8: Sub<FracSrc>,
U63: Sub<FracDst>,
Diff<U8, FracSrc>: IsLessOrEqual<Diff<U63, FracDst>, Output = True>,
[src]
FracSrc: IsLessOrEqual<FracDst, Output = True>,
U8: Sub<FracSrc>,
U63: Sub<FracDst>,
Diff<U8, FracSrc>: IsLessOrEqual<Diff<U63, FracDst>, Output = True>,
fn from(src: FixedU8<FracSrc>) -> Self
[src]
Converts a fixed-pint number.
This conversion never fails (infallible) and does not lose any precision (lossless).
impl<FracDst: LeEqU64> From<bool> for FixedI64<FracDst> where
U63: Sub<FracDst>,
U1: IsLessOrEqual<Diff<U63, FracDst>, Output = True>,
[src]
U63: Sub<FracDst>,
U1: IsLessOrEqual<Diff<U63, FracDst>, Output = True>,
fn from(src: bool) -> Self
[src]
Converts a bool
to a fixed-point number.
This conversion never fails (infallible) and cannot lose any fractional bits (lossless).
impl<FracDst: LeEqU64> From<i16> for FixedI64<FracDst> where
U64: Sub<FracDst>,
U16: IsLessOrEqual<Diff<U64, FracDst>, Output = True>,
[src]
U64: Sub<FracDst>,
U16: IsLessOrEqual<Diff<U64, FracDst>, Output = True>,
fn from(src: i16) -> Self
[src]
Converts an integer to a fixed-point number.
This conversion never fails (infallible) and cannot lose any fractional bits, so it is actually lossless.
impl<FracDst: LeEqU64> From<i32> for FixedI64<FracDst> where
U64: Sub<FracDst>,
U32: IsLessOrEqual<Diff<U64, FracDst>, Output = True>,
[src]
U64: Sub<FracDst>,
U32: IsLessOrEqual<Diff<U64, FracDst>, Output = True>,
fn from(src: i32) -> Self
[src]
Converts an integer to a fixed-point number.
This conversion never fails (infallible) and cannot lose any fractional bits, so it is actually lossless.
impl From<i64> for FixedI64<U0>
[src]
fn from(src: i64) -> Self
[src]
Converts an integer to a fixed-point number.
This conversion never fails (infallible) and cannot lose any fractional bits (lossless).
impl<FracDst: LeEqU64> From<i8> for FixedI64<FracDst> where
U64: Sub<FracDst>,
U8: IsLessOrEqual<Diff<U64, FracDst>, Output = True>,
[src]
U64: Sub<FracDst>,
U8: IsLessOrEqual<Diff<U64, FracDst>, Output = True>,
fn from(src: i8) -> Self
[src]
Converts an integer to a fixed-point number.
This conversion never fails (infallible) and cannot lose any fractional bits, so it is actually lossless.
impl<FracDst: LeEqU64> From<u16> for FixedI64<FracDst> where
U63: Sub<FracDst>,
U16: IsLessOrEqual<Diff<U63, FracDst>, Output = True>,
[src]
U63: Sub<FracDst>,
U16: IsLessOrEqual<Diff<U63, FracDst>, Output = True>,
fn from(src: u16) -> Self
[src]
Converts an integer to a fixed-point number.
This conversion never fails (infallible) and cannot lose any fractional bits, so it is actually lossless.
impl<FracDst: LeEqU64> From<u32> for FixedI64<FracDst> where
U63: Sub<FracDst>,
U32: IsLessOrEqual<Diff<U63, FracDst>, Output = True>,
[src]
U63: Sub<FracDst>,
U32: IsLessOrEqual<Diff<U63, FracDst>, Output = True>,
fn from(src: u32) -> Self
[src]
Converts an integer to a fixed-point number.
This conversion never fails (infallible) and cannot lose any fractional bits, so it is actually lossless.
impl<FracDst: LeEqU64> From<u8> for FixedI64<FracDst> where
U63: Sub<FracDst>,
U8: IsLessOrEqual<Diff<U63, FracDst>, Output = True>,
[src]
U63: Sub<FracDst>,
U8: IsLessOrEqual<Diff<U63, FracDst>, Output = True>,
fn from(src: u8) -> Self
[src]
Converts an integer to a fixed-point number.
This conversion never fails (infallible) and cannot lose any fractional bits, so it is actually lossless.
impl<Frac: LeEqU64> FromFixed for FixedI64<Frac>
[src]
fn from_fixed<F: Fixed>(src: F) -> Self
[src]
Converts a fixed-point number.
Any extra fractional bits are discarded, which rounds towards −∞.
Panics
When debug assertions are enabled, panics if the value
does not fit. When debug assertions are not enabled,
the wrapped value can be returned, but it is not
considered a breaking change if in the future it
panics; if wrapping is required use
wrapping_from_fixed
instead.
fn checked_from_fixed<F: Fixed>(src: F) -> Option<Self>
[src]
Converts a fixed-point number if it fits, otherwise returns None
.
Any extra fractional bits are discarded, which rounds towards −∞.
fn saturating_from_fixed<F: Fixed>(src: F) -> Self
[src]
Converts a fixed-point number, saturating if it does not fit.
Any extra fractional bits are discarded, which rounds towards −∞.
fn wrapping_from_fixed<F: Fixed>(src: F) -> Self
[src]
Converts a fixed-point number, wrapping if it does not fit.
Any extra fractional bits are discarded, which rounds towards −∞.
fn overflowing_from_fixed<F: Fixed>(src: F) -> (Self, bool)
[src]
Converts a fixed-point number.
Returns a tuple of the value and a bool
indicating whether an overflow has occurred. On
overflow, the wrapped value is returned.
Any extra fractional bits are discarded, which rounds towards −∞.
fn unwrapped_from_fixed<F: Fixed>(src: F) -> Self
[src]
Converts a fixed-point number, panicking if it does not fit.
Any extra fractional bits are discarded, which rounds towards −∞.
Panics
Panics if the value does not fit, even when debug assertions are not enabled.
impl<Frac: LeEqU64> FromPrimitive for FixedI64<Frac>
[src]
fn from_i64(n: i64) -> Option<Self>
[src]
fn from_u64(n: u64) -> Option<Self>
[src]
fn from_isize(n: isize) -> Option<Self>
[src]
fn from_i8(n: i8) -> Option<Self>
[src]
fn from_i16(n: i16) -> Option<Self>
[src]
fn from_i32(n: i32) -> Option<Self>
[src]
fn from_i128(n: i128) -> Option<Self>
[src]
fn from_usize(n: usize) -> Option<Self>
[src]
fn from_u8(n: u8) -> Option<Self>
[src]
fn from_u16(n: u16) -> Option<Self>
[src]
fn from_u32(n: u32) -> Option<Self>
[src]
fn from_u128(n: u128) -> Option<Self>
[src]
fn from_f32(n: f32) -> Option<Self>
[src]
fn from_f64(n: f64) -> Option<Self>
[src]
impl<Frac: LeEqU64> FromStr for FixedI64<Frac>
[src]
type Err = ParseFixedError
The associated error which can be returned from parsing.
fn from_str(s: &str) -> Result<Self, Self::Err>
[src]
Parses a string slice to return a fixed-point number.
Rounding is to the nearest, with ties rounded to even.
impl<Frac> Hash for FixedI64<Frac>
[src]
fn hash<H: Hasher>(&self, state: &mut H)
[src]
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
impl<Frac: LeEqU64> Inv for FixedI64<Frac>
[src]
impl<FracSrc: LeEqU128, FracDst: LeEqU64> LosslessTryFrom<FixedI128<FracSrc>> for FixedI64<FracDst> where
FracSrc: IsLessOrEqual<FracDst, Output = True>,
[src]
FracSrc: IsLessOrEqual<FracDst, Output = True>,
fn lossless_try_from(src: FixedI128<FracSrc>) -> Option<Self>
[src]
Converts a fixed-pint number.
This conversion may fail (fallible) but does not lose precision (lossless).
impl<FracSrc: LeEqU16, FracDst: LeEqU64> LosslessTryFrom<FixedI16<FracSrc>> for FixedI64<FracDst> where
FracSrc: IsLessOrEqual<FracDst, Output = True>,
[src]
FracSrc: IsLessOrEqual<FracDst, Output = True>,
fn lossless_try_from(src: FixedI16<FracSrc>) -> Option<Self>
[src]
Converts a fixed-pint number.
This conversion may fail (fallible) but does not lose precision (lossless).
impl<FracSrc: LeEqU32, FracDst: LeEqU64> LosslessTryFrom<FixedI32<FracSrc>> for FixedI64<FracDst> where
FracSrc: IsLessOrEqual<FracDst, Output = True>,
[src]
FracSrc: IsLessOrEqual<FracDst, Output = True>,
fn lossless_try_from(src: FixedI32<FracSrc>) -> Option<Self>
[src]
Converts a fixed-pint number.
This conversion may fail (fallible) but does not lose precision (lossless).
impl<Frac: LeEqU64> LosslessTryFrom<FixedI64<Frac>> for F128Bits
[src]
fn lossless_try_from(src: FixedI64<Frac>) -> Option<F128Bits>
[src]
Converts a fixed-point number to a floating-point number.
This conversion actually never fails (infallible) but does not lose any precision (lossless).
impl<FracSrc: LeEqU64, FracDst: LeEqU8> LosslessTryFrom<FixedI64<FracSrc>> for FixedI8<FracDst> where
FracSrc: IsLessOrEqual<FracDst, Output = True>,
[src]
FracSrc: IsLessOrEqual<FracDst, Output = True>,
fn lossless_try_from(src: FixedI64<FracSrc>) -> Option<Self>
[src]
Converts a fixed-pint number.
This conversion may fail (fallible) but does not lose precision (lossless).
impl<FracSrc: LeEqU64, FracDst: LeEqU16> LosslessTryFrom<FixedI64<FracSrc>> for FixedI16<FracDst> where
FracSrc: IsLessOrEqual<FracDst, Output = True>,
[src]
FracSrc: IsLessOrEqual<FracDst, Output = True>,
fn lossless_try_from(src: FixedI64<FracSrc>) -> Option<Self>
[src]
Converts a fixed-pint number.
This conversion may fail (fallible) but does not lose precision (lossless).
impl<FracSrc: LeEqU64, FracDst: LeEqU32> LosslessTryFrom<FixedI64<FracSrc>> for FixedI32<FracDst> where
FracSrc: IsLessOrEqual<FracDst, Output = True>,
[src]
FracSrc: IsLessOrEqual<FracDst, Output = True>,
fn lossless_try_from(src: FixedI64<FracSrc>) -> Option<Self>
[src]
Converts a fixed-pint number.
This conversion may fail (fallible) but does not lose precision (lossless).
impl<FracSrc: LeEqU64, FracDst: LeEqU64> LosslessTryFrom<FixedI64<FracSrc>> for FixedI64<FracDst> where
FracSrc: IsLessOrEqual<FracDst, Output = True>,
[src]
FracSrc: IsLessOrEqual<FracDst, Output = True>,
fn lossless_try_from(src: FixedI64<FracSrc>) -> Option<Self>
[src]
Converts a fixed-pint number.
This conversion may fail (fallible) but does not lose precision (lossless).
impl<FracSrc: LeEqU64, FracDst: LeEqU128> LosslessTryFrom<FixedI64<FracSrc>> for FixedI128<FracDst> where
FracSrc: IsLessOrEqual<FracDst, Output = True>,
[src]
FracSrc: IsLessOrEqual<FracDst, Output = True>,
fn lossless_try_from(src: FixedI64<FracSrc>) -> Option<Self>
[src]
Converts a fixed-pint number.
This conversion may fail (fallible) but does not lose precision (lossless).
impl<FracSrc: LeEqU64, FracDst: LeEqU8> LosslessTryFrom<FixedI64<FracSrc>> for FixedU8<FracDst> where
FracSrc: IsLessOrEqual<FracDst, Output = True>,
[src]
FracSrc: IsLessOrEqual<FracDst, Output = True>,
fn lossless_try_from(src: FixedI64<FracSrc>) -> Option<Self>
[src]
Converts a fixed-pint number.
This conversion may fail (fallible) but does not lose precision (lossless).
impl<FracSrc: LeEqU64, FracDst: LeEqU16> LosslessTryFrom<FixedI64<FracSrc>> for FixedU16<FracDst> where
FracSrc: IsLessOrEqual<FracDst, Output = True>,
[src]
FracSrc: IsLessOrEqual<FracDst, Output = True>,
fn lossless_try_from(src: FixedI64<FracSrc>) -> Option<Self>
[src]
Converts a fixed-pint number.
This conversion may fail (fallible) but does not lose precision (lossless).
impl<FracSrc: LeEqU64, FracDst: LeEqU32> LosslessTryFrom<FixedI64<FracSrc>> for FixedU32<FracDst> where
FracSrc: IsLessOrEqual<FracDst, Output = True>,
[src]
FracSrc: IsLessOrEqual<FracDst, Output = True>,
fn lossless_try_from(src: FixedI64<FracSrc>) -> Option<Self>
[src]
Converts a fixed-pint number.
This conversion may fail (fallible) but does not lose precision (lossless).
impl<FracSrc: LeEqU64, FracDst: LeEqU64> LosslessTryFrom<FixedI64<FracSrc>> for FixedU64<FracDst> where
FracSrc: IsLessOrEqual<FracDst, Output = True>,
[src]
FracSrc: IsLessOrEqual<FracDst, Output = True>,
fn lossless_try_from(src: FixedI64<FracSrc>) -> Option<Self>
[src]
Converts a fixed-pint number.
This conversion may fail (fallible) but does not lose precision (lossless).
impl<FracSrc: LeEqU64, FracDst: LeEqU128> LosslessTryFrom<FixedI64<FracSrc>> for FixedU128<FracDst> where
FracSrc: IsLessOrEqual<FracDst, Output = True>,
[src]
FracSrc: IsLessOrEqual<FracDst, Output = True>,
fn lossless_try_from(src: FixedI64<FracSrc>) -> Option<Self>
[src]
Converts a fixed-pint number.
This conversion may fail (fallible) but does not lose precision (lossless).
impl LosslessTryFrom<FixedI64<UTerm>> for i8
[src]
fn lossless_try_from(src: FixedI64<U0>) -> Option<Self>
[src]
Converts a fixed-point number to an integer.
This conversion may fail (fallible) but cannot lose any fractional bits (lossless).
impl LosslessTryFrom<FixedI64<UTerm>> for i16
[src]
fn lossless_try_from(src: FixedI64<U0>) -> Option<Self>
[src]
Converts a fixed-point number to an integer.
This conversion may fail (fallible) but cannot lose any fractional bits (lossless).
impl LosslessTryFrom<FixedI64<UTerm>> for u128
[src]
fn lossless_try_from(src: FixedI64<U0>) -> Option<Self>
[src]
Converts a fixed-point number to an integer.
This conversion may fail (fallible) but cannot lose any fractional bits (lossless).
impl LosslessTryFrom<FixedI64<UTerm>> for usize
[src]
fn lossless_try_from(src: FixedI64<U0>) -> Option<Self>
[src]
Converts a fixed-point number to an integer.
This conversion may fail (fallible) but cannot lose any fractional bits (lossless).
impl LosslessTryFrom<FixedI64<UTerm>> for i32
[src]
fn lossless_try_from(src: FixedI64<U0>) -> Option<Self>
[src]
Converts a fixed-point number to an integer.
This conversion may fail (fallible) but cannot lose any fractional bits (lossless).
impl LosslessTryFrom<FixedI64<UTerm>> for i64
[src]
fn lossless_try_from(src: FixedI64<U0>) -> Option<Self>
[src]
Converts a fixed-point number to an integer.
This conversion may fail (fallible) but cannot lose any fractional bits (lossless).
impl LosslessTryFrom<FixedI64<UTerm>> for i128
[src]
fn lossless_try_from(src: FixedI64<U0>) -> Option<Self>
[src]
Converts a fixed-point number to an integer.
This conversion may fail (fallible) but cannot lose any fractional bits (lossless).
impl LosslessTryFrom<FixedI64<UTerm>> for isize
[src]
fn lossless_try_from(src: FixedI64<U0>) -> Option<Self>
[src]
Converts a fixed-point number to an integer.
This conversion may fail (fallible) but cannot lose any fractional bits (lossless).
impl LosslessTryFrom<FixedI64<UTerm>> for u8
[src]
fn lossless_try_from(src: FixedI64<U0>) -> Option<Self>
[src]
Converts a fixed-point number to an integer.
This conversion may fail (fallible) but cannot lose any fractional bits (lossless).
impl LosslessTryFrom<FixedI64<UTerm>> for u16
[src]
fn lossless_try_from(src: FixedI64<U0>) -> Option<Self>
[src]
Converts a fixed-point number to an integer.
This conversion may fail (fallible) but cannot lose any fractional bits (lossless).
impl LosslessTryFrom<FixedI64<UTerm>> for u32
[src]
fn lossless_try_from(src: FixedI64<U0>) -> Option<Self>
[src]
Converts a fixed-point number to an integer.
This conversion may fail (fallible) but cannot lose any fractional bits (lossless).
impl LosslessTryFrom<FixedI64<UTerm>> for u64
[src]
fn lossless_try_from(src: FixedI64<U0>) -> Option<Self>
[src]
Converts a fixed-point number to an integer.
This conversion may fail (fallible) but cannot lose any fractional bits (lossless).
impl<FracSrc: LeEqU8, FracDst: LeEqU64> LosslessTryFrom<FixedI8<FracSrc>> for FixedI64<FracDst> where
FracSrc: IsLessOrEqual<FracDst, Output = True>,
[src]
FracSrc: IsLessOrEqual<FracDst, Output = True>,
fn lossless_try_from(src: FixedI8<FracSrc>) -> Option<Self>
[src]
Converts a fixed-pint number.
This conversion may fail (fallible) but does not lose precision (lossless).
impl<FracSrc: LeEqU128, FracDst: LeEqU64> LosslessTryFrom<FixedU128<FracSrc>> for FixedI64<FracDst> where
FracSrc: IsLessOrEqual<FracDst, Output = True>,
[src]
FracSrc: IsLessOrEqual<FracDst, Output = True>,
fn lossless_try_from(src: FixedU128<FracSrc>) -> Option<Self>
[src]
Converts a fixed-pint number.
This conversion may fail (fallible) but does not lose precision (lossless).
impl<FracSrc: LeEqU16, FracDst: LeEqU64> LosslessTryFrom<FixedU16<FracSrc>> for FixedI64<FracDst> where
FracSrc: IsLessOrEqual<FracDst, Output = True>,
[src]
FracSrc: IsLessOrEqual<FracDst, Output = True>,
fn lossless_try_from(src: FixedU16<FracSrc>) -> Option<Self>
[src]
Converts a fixed-pint number.
This conversion may fail (fallible) but does not lose precision (lossless).
impl<FracSrc: LeEqU32, FracDst: LeEqU64> LosslessTryFrom<FixedU32<FracSrc>> for FixedI64<FracDst> where
FracSrc: IsLessOrEqual<FracDst, Output = True>,
[src]
FracSrc: IsLessOrEqual<FracDst, Output = True>,
fn lossless_try_from(src: FixedU32<FracSrc>) -> Option<Self>
[src]
Converts a fixed-pint number.
This conversion may fail (fallible) but does not lose precision (lossless).
impl<FracSrc: LeEqU64, FracDst: LeEqU64> LosslessTryFrom<FixedU64<FracSrc>> for FixedI64<FracDst> where
FracSrc: IsLessOrEqual<FracDst, Output = True>,
[src]
FracSrc: IsLessOrEqual<FracDst, Output = True>,
fn lossless_try_from(src: FixedU64<FracSrc>) -> Option<Self>
[src]
Converts a fixed-pint number.
This conversion may fail (fallible) but does not lose precision (lossless).
impl<FracSrc: LeEqU8, FracDst: LeEqU64> LosslessTryFrom<FixedU8<FracSrc>> for FixedI64<FracDst> where
FracSrc: IsLessOrEqual<FracDst, Output = True>,
[src]
FracSrc: IsLessOrEqual<FracDst, Output = True>,
fn lossless_try_from(src: FixedU8<FracSrc>) -> Option<Self>
[src]
Converts a fixed-pint number.
This conversion may fail (fallible) but does not lose precision (lossless).
impl<Frac: LeEqU64> LosslessTryFrom<bool> for FixedI64<Frac>
[src]
fn lossless_try_from(src: bool) -> Option<Self>
[src]
Converts an integer to a fixed-point number.
This conversion may fail (fallible) but cannot lose any fractional bits (lossless).
impl<Frac: LeEqU64> LosslessTryFrom<f16> for FixedI64<Frac> where
U24: IsLessOrEqual<Frac, Output = True>,
[src]
U24: IsLessOrEqual<Frac, Output = True>,
fn lossless_try_from(src: f16) -> Option<Self>
[src]
Converts a floating-point number to a fixed-point number.
This conversion may fail (fallible) but cannot lose any fractional bits (lossless).
impl<Frac: LeEqU64> LosslessTryFrom<i128> for FixedI64<Frac>
[src]
fn lossless_try_from(src: i128) -> Option<Self>
[src]
Converts an integer to a fixed-point number.
This conversion may fail (fallible) but cannot lose any fractional bits (lossless).
impl<Frac: LeEqU64> LosslessTryFrom<i16> for FixedI64<Frac>
[src]
fn lossless_try_from(src: i16) -> Option<Self>
[src]
Converts an integer to a fixed-point number.
This conversion may fail (fallible) but cannot lose any fractional bits (lossless).
impl<Frac: LeEqU64> LosslessTryFrom<i32> for FixedI64<Frac>
[src]
fn lossless_try_from(src: i32) -> Option<Self>
[src]
Converts an integer to a fixed-point number.
This conversion may fail (fallible) but cannot lose any fractional bits (lossless).
impl<Frac: LeEqU64> LosslessTryFrom<i64> for FixedI64<Frac>
[src]
fn lossless_try_from(src: i64) -> Option<Self>
[src]
Converts an integer to a fixed-point number.
This conversion may fail (fallible) but cannot lose any fractional bits (lossless).
impl<Frac: LeEqU64> LosslessTryFrom<i8> for FixedI64<Frac>
[src]
fn lossless_try_from(src: i8) -> Option<Self>
[src]
Converts an integer to a fixed-point number.
This conversion may fail (fallible) but cannot lose any fractional bits (lossless).
impl<Frac: LeEqU64> LosslessTryFrom<isize> for FixedI64<Frac>
[src]
fn lossless_try_from(src: isize) -> Option<Self>
[src]
Converts an integer to a fixed-point number.
This conversion may fail (fallible) but cannot lose any fractional bits (lossless).
impl<Frac: LeEqU64> LosslessTryFrom<u128> for FixedI64<Frac>
[src]
fn lossless_try_from(src: u128) -> Option<Self>
[src]
Converts an integer to a fixed-point number.
This conversion may fail (fallible) but cannot lose any fractional bits (lossless).
impl<Frac: LeEqU64> LosslessTryFrom<u16> for FixedI64<Frac>
[src]
fn lossless_try_from(src: u16) -> Option<Self>
[src]
Converts an integer to a fixed-point number.
This conversion may fail (fallible) but cannot lose any fractional bits (lossless).
impl<Frac: LeEqU64> LosslessTryFrom<u32> for FixedI64<Frac>
[src]
fn lossless_try_from(src: u32) -> Option<Self>
[src]
Converts an integer to a fixed-point number.
This conversion may fail (fallible) but cannot lose any fractional bits (lossless).
impl<Frac: LeEqU64> LosslessTryFrom<u64> for FixedI64<Frac>
[src]
fn lossless_try_from(src: u64) -> Option<Self>
[src]
Converts an integer to a fixed-point number.
This conversion may fail (fallible) but cannot lose any fractional bits (lossless).
impl<Frac: LeEqU64> LosslessTryFrom<u8> for FixedI64<Frac>
[src]
fn lossless_try_from(src: u8) -> Option<Self>
[src]
Converts an integer to a fixed-point number.
This conversion may fail (fallible) but cannot lose any fractional bits (lossless).
impl<Frac: LeEqU64> LosslessTryFrom<usize> for FixedI64<Frac>
[src]
fn lossless_try_from(src: usize) -> Option<Self>
[src]
Converts an integer to a fixed-point number.
This conversion may fail (fallible) but cannot lose any fractional bits (lossless).
impl<FracSrc: LeEqU128, FracDst: LeEqU64> LossyFrom<FixedI128<FracSrc>> for FixedI64<FracDst> where
U128: Sub<FracSrc>,
U64: Sub<FracDst>,
Diff<U128, FracSrc>: IsLessOrEqual<Diff<U64, FracDst>, Output = True>,
[src]
U128: Sub<FracSrc>,
U64: Sub<FracDst>,
Diff<U128, FracSrc>: IsLessOrEqual<Diff<U64, FracDst>, Output = True>,
fn lossy_from(src: FixedI128<FracSrc>) -> Self
[src]
Converts a fixed-pint number.
This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.
impl<FracSrc: LeEqU16, FracDst: LeEqU64> LossyFrom<FixedI16<FracSrc>> for FixedI64<FracDst> where
U16: Sub<FracSrc>,
U64: Sub<FracDst>,
Diff<U16, FracSrc>: IsLessOrEqual<Diff<U64, FracDst>, Output = True>,
[src]
U16: Sub<FracSrc>,
U64: Sub<FracDst>,
Diff<U16, FracSrc>: IsLessOrEqual<Diff<U64, FracDst>, Output = True>,
fn lossy_from(src: FixedI16<FracSrc>) -> Self
[src]
Converts a fixed-pint number.
This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.
impl<FracSrc: LeEqU32, FracDst: LeEqU64> LossyFrom<FixedI32<FracSrc>> for FixedI64<FracDst> where
U32: Sub<FracSrc>,
U64: Sub<FracDst>,
Diff<U32, FracSrc>: IsLessOrEqual<Diff<U64, FracDst>, Output = True>,
[src]
U32: Sub<FracSrc>,
U64: Sub<FracDst>,
Diff<U32, FracSrc>: IsLessOrEqual<Diff<U64, FracDst>, Output = True>,
fn lossy_from(src: FixedI32<FracSrc>) -> Self
[src]
Converts a fixed-pint number.
This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.
impl<Frac: LeEqU64> LossyFrom<FixedI64<Frac>> for f16
[src]
fn lossy_from(src: FixedI64<Frac>) -> f16
[src]
Converts a fixed-point number to a floating-point number.
This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.
impl<Frac: LeEqU64> LossyFrom<FixedI64<Frac>> for bf16
[src]
fn lossy_from(src: FixedI64<Frac>) -> bf16
[src]
Converts a fixed-point number to a floating-point number.
This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.
impl<Frac: LeEqU64> LossyFrom<FixedI64<Frac>> for f32
[src]
fn lossy_from(src: FixedI64<Frac>) -> f32
[src]
Converts a fixed-point number to a floating-point number.
This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.
impl<Frac: LeEqU64> LossyFrom<FixedI64<Frac>> for f64
[src]
fn lossy_from(src: FixedI64<Frac>) -> f64
[src]
Converts a fixed-point number to a floating-point number.
This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.
impl<Frac: LeEqU64> LossyFrom<FixedI64<Frac>> for F128Bits
[src]
fn lossy_from(src: FixedI64<Frac>) -> F128Bits
[src]
Converts a fixed-point number to a floating-point number.
This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.
impl<FracSrc: LeEqU64, FracDst: LeEqU8> LossyFrom<FixedI64<FracSrc>> for FixedI8<FracDst> where
U64: Sub<FracSrc>,
U8: Sub<FracDst>,
Diff<U64, FracSrc>: IsLessOrEqual<Diff<U8, FracDst>, Output = True>,
[src]
U64: Sub<FracSrc>,
U8: Sub<FracDst>,
Diff<U64, FracSrc>: IsLessOrEqual<Diff<U8, FracDst>, Output = True>,
fn lossy_from(src: FixedI64<FracSrc>) -> Self
[src]
Converts a fixed-pint number.
This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.
impl<FracSrc: LeEqU64, FracDst: LeEqU16> LossyFrom<FixedI64<FracSrc>> for FixedI16<FracDst> where
U64: Sub<FracSrc>,
U16: Sub<FracDst>,
Diff<U64, FracSrc>: IsLessOrEqual<Diff<U16, FracDst>, Output = True>,
[src]
U64: Sub<FracSrc>,
U16: Sub<FracDst>,
Diff<U64, FracSrc>: IsLessOrEqual<Diff<U16, FracDst>, Output = True>,
fn lossy_from(src: FixedI64<FracSrc>) -> Self
[src]
Converts a fixed-pint number.
This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.
impl<FracSrc: LeEqU64> LossyFrom<FixedI64<FracSrc>> for isize where
U64: Sub<FracSrc>,
Diff<U64, FracSrc>: IsLessOrEqual<U16, Output = True>,
[src]
U64: Sub<FracSrc>,
Diff<U64, FracSrc>: IsLessOrEqual<U16, Output = True>,
fn lossy_from(src: FixedI64<FracSrc>) -> Self
[src]
Converts a fixed-point number to an integer.
This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.
impl<FracSrc: 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]
U64: Sub<FracSrc>,
U32: Sub<FracDst>,
Diff<U64, FracSrc>: IsLessOrEqual<Diff<U32, FracDst>, Output = True>,
fn lossy_from(src: FixedI64<FracSrc>) -> Self
[src]
Converts a fixed-pint number.
This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.
impl<FracSrc: LeEqU64, FracDst: LeEqU64> LossyFrom<FixedI64<FracSrc>> for FixedI64<FracDst> where
U64: Sub<FracSrc>,
U64: Sub<FracDst>,
Diff<U64, FracSrc>: IsLessOrEqual<Diff<U64, FracDst>, Output = True>,
[src]
U64: Sub<FracSrc>,
U64: Sub<FracDst>,
Diff<U64, FracSrc>: IsLessOrEqual<Diff<U64, FracDst>, Output = True>,
fn lossy_from(src: FixedI64<FracSrc>) -> Self
[src]
Converts a fixed-pint number.
This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.
impl<FracSrc: LeEqU64, FracDst: LeEqU128> LossyFrom<FixedI64<FracSrc>> for FixedI128<FracDst> where
U64: Sub<FracSrc>,
U128: Sub<FracDst>,
Diff<U64, FracSrc>: IsLessOrEqual<Diff<U128, FracDst>, Output = True>,
[src]
U64: Sub<FracSrc>,
U128: Sub<FracDst>,
Diff<U64, FracSrc>: IsLessOrEqual<Diff<U128, FracDst>, Output = True>,
fn lossy_from(src: FixedI64<FracSrc>) -> Self
[src]
Converts a fixed-pint number.
This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.
impl<FracSrc: LeEqU64> LossyFrom<FixedI64<FracSrc>> for i8 where
U64: Sub<FracSrc>,
Diff<U64, FracSrc>: IsLessOrEqual<U8, Output = True>,
[src]
U64: Sub<FracSrc>,
Diff<U64, FracSrc>: IsLessOrEqual<U8, Output = True>,
fn lossy_from(src: FixedI64<FracSrc>) -> Self
[src]
Converts a fixed-point number to an integer.
This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.
impl<FracSrc: LeEqU64> LossyFrom<FixedI64<FracSrc>> for i16 where
U64: Sub<FracSrc>,
Diff<U64, FracSrc>: IsLessOrEqual<U16, Output = True>,
[src]
U64: Sub<FracSrc>,
Diff<U64, FracSrc>: IsLessOrEqual<U16, Output = True>,
fn lossy_from(src: FixedI64<FracSrc>) -> Self
[src]
Converts a fixed-point number to an integer.
This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.
impl<FracSrc: LeEqU64> LossyFrom<FixedI64<FracSrc>> for i32 where
U64: Sub<FracSrc>,
Diff<U64, FracSrc>: IsLessOrEqual<U32, Output = True>,
[src]
U64: Sub<FracSrc>,
Diff<U64, FracSrc>: IsLessOrEqual<U32, Output = True>,
fn lossy_from(src: FixedI64<FracSrc>) -> Self
[src]
Converts a fixed-point number to an integer.
This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.
impl<FracSrc: LeEqU64> LossyFrom<FixedI64<FracSrc>> for i64 where
U64: Sub<FracSrc>,
Diff<U64, FracSrc>: IsLessOrEqual<U64, Output = True>,
[src]
U64: Sub<FracSrc>,
Diff<U64, FracSrc>: IsLessOrEqual<U64, Output = True>,
fn lossy_from(src: FixedI64<FracSrc>) -> Self
[src]
Converts a fixed-point number to an integer.
This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.
impl<FracSrc: LeEqU64> LossyFrom<FixedI64<FracSrc>> for i128 where
U64: Sub<FracSrc>,
Diff<U64, FracSrc>: IsLessOrEqual<U128, Output = True>,
[src]
U64: Sub<FracSrc>,
Diff<U64, FracSrc>: IsLessOrEqual<U128, Output = True>,
fn lossy_from(src: FixedI64<FracSrc>) -> Self
[src]
Converts a fixed-point number to an integer.
This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.
impl<FracSrc: LeEqU8, FracDst: LeEqU64> LossyFrom<FixedI8<FracSrc>> for FixedI64<FracDst> where
U8: Sub<FracSrc>,
U64: Sub<FracDst>,
Diff<U8, FracSrc>: IsLessOrEqual<Diff<U64, FracDst>, Output = True>,
[src]
U8: Sub<FracSrc>,
U64: Sub<FracDst>,
Diff<U8, FracSrc>: IsLessOrEqual<Diff<U64, FracDst>, Output = True>,
fn lossy_from(src: FixedI8<FracSrc>) -> Self
[src]
Converts a fixed-pint number.
This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.
impl<FracSrc: LeEqU128, FracDst: LeEqU64> LossyFrom<FixedU128<FracSrc>> for FixedI64<FracDst> where
U128: Sub<FracSrc>,
U63: Sub<FracDst>,
Diff<U128, FracSrc>: IsLessOrEqual<Diff<U63, FracDst>, Output = True>,
[src]
U128: Sub<FracSrc>,
U63: Sub<FracDst>,
Diff<U128, FracSrc>: IsLessOrEqual<Diff<U63, FracDst>, Output = True>,
fn lossy_from(src: FixedU128<FracSrc>) -> Self
[src]
Converts a fixed-pint number.
This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.
impl<FracSrc: LeEqU16, FracDst: LeEqU64> LossyFrom<FixedU16<FracSrc>> for FixedI64<FracDst> where
U16: Sub<FracSrc>,
U63: Sub<FracDst>,
Diff<U16, FracSrc>: IsLessOrEqual<Diff<U63, FracDst>, Output = True>,
[src]
U16: Sub<FracSrc>,
U63: Sub<FracDst>,
Diff<U16, FracSrc>: IsLessOrEqual<Diff<U63, FracDst>, Output = True>,
fn lossy_from(src: FixedU16<FracSrc>) -> Self
[src]
Converts a fixed-pint number.
This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.
impl<FracSrc: LeEqU32, FracDst: LeEqU64> LossyFrom<FixedU32<FracSrc>> for FixedI64<FracDst> where
U32: Sub<FracSrc>,
U63: Sub<FracDst>,
Diff<U32, FracSrc>: IsLessOrEqual<Diff<U63, FracDst>, Output = True>,
[src]
U32: Sub<FracSrc>,
U63: Sub<FracDst>,
Diff<U32, FracSrc>: IsLessOrEqual<Diff<U63, FracDst>, Output = True>,
fn lossy_from(src: FixedU32<FracSrc>) -> Self
[src]
Converts a fixed-pint number.
This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.
impl<FracSrc: LeEqU64, FracDst: LeEqU64> LossyFrom<FixedU64<FracSrc>> for FixedI64<FracDst> where
U64: Sub<FracSrc>,
U63: Sub<FracDst>,
Diff<U64, FracSrc>: IsLessOrEqual<Diff<U63, FracDst>, Output = True>,
[src]
U64: Sub<FracSrc>,
U63: Sub<FracDst>,
Diff<U64, FracSrc>: IsLessOrEqual<Diff<U63, FracDst>, Output = True>,
fn lossy_from(src: FixedU64<FracSrc>) -> Self
[src]
Converts a fixed-pint number.
This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.
impl<FracSrc: LeEqU8, FracDst: LeEqU64> LossyFrom<FixedU8<FracSrc>> for FixedI64<FracDst> where
U8: Sub<FracSrc>,
U63: Sub<FracDst>,
Diff<U8, FracSrc>: IsLessOrEqual<Diff<U63, FracDst>, Output = True>,
[src]
U8: Sub<FracSrc>,
U63: Sub<FracDst>,
Diff<U8, FracSrc>: IsLessOrEqual<Diff<U63, FracDst>, Output = True>,
fn lossy_from(src: FixedU8<FracSrc>) -> Self
[src]
Converts a fixed-pint number.
This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.
impl<FracDst: LeEqU64> LossyFrom<bool> for FixedI64<FracDst> where
U63: Sub<FracDst>,
U1: IsLessOrEqual<Diff<U63, FracDst>, Output = True>,
[src]
U63: Sub<FracDst>,
U1: IsLessOrEqual<Diff<U63, FracDst>, Output = True>,
fn lossy_from(src: bool) -> Self
[src]
Converts a bool
to a fixed-point number.
This conversion never fails (infallible) and cannot lose any fractional bits, so it is actually lossless.
impl<FracDst: LeEqU64> LossyFrom<i16> for FixedI64<FracDst> where
U64: Sub<FracDst>,
U16: IsLessOrEqual<Diff<U64, FracDst>, Output = True>,
[src]
U64: Sub<FracDst>,
U16: IsLessOrEqual<Diff<U64, FracDst>, Output = True>,
fn lossy_from(src: i16) -> Self
[src]
Converts an integer to a fixed-point number.
This conversion never fails (infallible) and cannot lose any fractional bits, so it is actually lossless.
impl<FracDst: LeEqU64> LossyFrom<i32> for FixedI64<FracDst> where
U64: Sub<FracDst>,
U32: IsLessOrEqual<Diff<U64, FracDst>, Output = True>,
[src]
U64: Sub<FracDst>,
U32: IsLessOrEqual<Diff<U64, FracDst>, Output = True>,
fn lossy_from(src: i32) -> Self
[src]
Converts an integer to a fixed-point number.
This conversion never fails (infallible) and cannot lose any fractional bits, so it is actually lossless.
impl LossyFrom<i64> for FixedI64<U0>
[src]
fn lossy_from(src: i64) -> Self
[src]
Converts an integer to a fixed-point number.
This conversion never fails (infallible) and actually does not lose any precision (lossless).
impl<FracDst: LeEqU64> LossyFrom<i8> for FixedI64<FracDst> where
U64: Sub<FracDst>,
U8: IsLessOrEqual<Diff<U64, FracDst>, Output = True>,
[src]
U64: Sub<FracDst>,
U8: IsLessOrEqual<Diff<U64, FracDst>, Output = True>,
fn lossy_from(src: i8) -> Self
[src]
Converts an integer to a fixed-point number.
This conversion never fails (infallible) and cannot lose any fractional bits, so it is actually lossless.
impl<FracDst: LeEqU64> LossyFrom<u16> for FixedI64<FracDst> where
U63: Sub<FracDst>,
U16: IsLessOrEqual<Diff<U63, FracDst>, Output = True>,
[src]
U63: Sub<FracDst>,
U16: IsLessOrEqual<Diff<U63, FracDst>, Output = True>,
fn lossy_from(src: u16) -> Self
[src]
Converts an integer to a fixed-point number.
This conversion never fails (infallible) and cannot lose any fractional bits, so it is actually lossless.
impl<FracDst: LeEqU64> LossyFrom<u32> for FixedI64<FracDst> where
U63: Sub<FracDst>,
U32: IsLessOrEqual<Diff<U63, FracDst>, Output = True>,
[src]
U63: Sub<FracDst>,
U32: IsLessOrEqual<Diff<U63, FracDst>, Output = True>,
fn lossy_from(src: u32) -> Self
[src]
Converts an integer to a fixed-point number.
This conversion never fails (infallible) and cannot lose any fractional bits, so it is actually lossless.
impl<FracDst: LeEqU64> LossyFrom<u8> for FixedI64<FracDst> where
U63: Sub<FracDst>,
U8: IsLessOrEqual<Diff<U63, FracDst>, Output = True>,
[src]
U63: Sub<FracDst>,
U8: IsLessOrEqual<Diff<U63, FracDst>, Output = True>,
fn lossy_from(src: u8) -> Self
[src]
Converts an integer to a fixed-point number.
This conversion never fails (infallible) and cannot lose any fractional bits, so it is actually lossless.
impl<Frac: LeEqU64> LowerHex for FixedI64<Frac>
[src]
impl<Frac: LeEqU64> Mul<&'_ FixedI64<Frac>> for FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the *
operator.
fn mul(self, rhs: &FixedI64<Frac>) -> FixedI64<Frac>
[src]
impl<Frac: LeEqU64> Mul<&'_ FixedI64<Frac>> for &FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the *
operator.
fn mul(self, rhs: &FixedI64<Frac>) -> FixedI64<Frac>
[src]
impl<Frac: LeEqU64> Mul<&'_ i64> for FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the *
operator.
fn mul(self, rhs: &i64) -> FixedI64<Frac>
[src]
impl<Frac: LeEqU64> Mul<&'_ i64> for &FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the *
operator.
fn mul(self, rhs: &i64) -> FixedI64<Frac>
[src]
impl<Frac: LeEqU64> Mul<FixedI64<Frac>> for FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the *
operator.
fn mul(self, rhs: FixedI64<Frac>) -> FixedI64<Frac>
[src]
impl<Frac: LeEqU64> Mul<FixedI64<Frac>> for &FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the *
operator.
fn mul(self, rhs: FixedI64<Frac>) -> FixedI64<Frac>
[src]
impl<Frac: LeEqU64> Mul<i64> for FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the *
operator.
fn mul(self, rhs: i64) -> FixedI64<Frac>
[src]
impl<Frac: LeEqU64> Mul<i64> for &FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the *
operator.
fn mul(self, rhs: i64) -> FixedI64<Frac>
[src]
impl<Frac, MulFrac: LeEqU64> MulAdd<FixedI64<MulFrac>, FixedI64<Frac>> for FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the fused multiply-add.
fn mul_add(self, a: FixedI64<MulFrac>, b: FixedI64<Frac>) -> FixedI64<Frac>
[src]
impl<Frac, MulFrac: LeEqU64> MulAddAssign<FixedI64<MulFrac>, FixedI64<Frac>> for FixedI64<Frac>
[src]
fn mul_add_assign(&mut self, a: FixedI64<MulFrac>, b: FixedI64<Frac>)
[src]
impl<Frac, RhsFrac: LeEqU64> MulAssign<&'_ FixedI64<RhsFrac>> for FixedI64<Frac>
[src]
fn mul_assign(&mut self, rhs: &FixedI64<RhsFrac>)
[src]
impl<Frac: LeEqU64> MulAssign<&'_ i64> for FixedI64<Frac>
[src]
fn mul_assign(&mut self, rhs: &i64)
[src]
impl<Frac, RhsFrac: LeEqU64> MulAssign<FixedI64<RhsFrac>> for FixedI64<Frac>
[src]
fn mul_assign(&mut self, rhs: FixedI64<RhsFrac>)
[src]
impl<Frac: LeEqU64> MulAssign<i64> for FixedI64<Frac>
[src]
fn mul_assign(&mut self, rhs: i64)
[src]
impl<Frac> Neg for FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the -
operator.
fn neg(self) -> FixedI64<Frac>
[src]
impl<Frac> Neg for &FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the -
operator.
fn neg(self) -> FixedI64<Frac>
[src]
impl<Frac> Not for FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the !
operator.
fn not(self) -> FixedI64<Frac>
[src]
impl<Frac> Not for &FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the !
operator.
fn not(self) -> FixedI64<Frac>
[src]
impl<Frac: LeEqU64> Num for FixedI64<Frac> where
Frac: IsLessOrEqual<U62, Output = True>,
[src]
Frac: IsLessOrEqual<U62, Output = True>,
type FromStrRadixErr = RadixParseFixedError
fn from_str_radix(str: &str, radix: u32) -> Result<Self, Self::FromStrRadixErr>
[src]
impl<Frac: LeEqU64> Octal for FixedI64<Frac>
[src]
impl<Frac: LeEqU64> One for FixedI64<Frac> where
Frac: IsLessOrEqual<U62, Output = True>,
[src]
Frac: IsLessOrEqual<U62, Output = True>,
fn one() -> Self
[src]
pub fn set_one(&mut self)
[src]
pub fn is_one(&self) -> bool where
Self: PartialEq<Self>,
[src]
Self: PartialEq<Self>,
impl<Frac: LeEqU64> Ord for FixedI64<Frac>
[src]
fn cmp(&self, rhs: &FixedI64<Frac>) -> Ordering
[src]
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<Frac> OverflowingAdd for FixedI64<Frac>
[src]
impl<Frac: LeEqU64> OverflowingCast<F128Bits> for FixedI64<Frac>
[src]
impl<FracSrc: LeEqU64, FracDst: LeEqU128> OverflowingCast<FixedI128<FracDst>> for FixedI64<FracSrc>
[src]
impl<FracSrc: LeEqU64, FracDst: LeEqU16> OverflowingCast<FixedI16<FracDst>> for FixedI64<FracSrc>
[src]
impl<FracSrc: LeEqU64, FracDst: LeEqU32> OverflowingCast<FixedI32<FracDst>> for FixedI64<FracSrc>
[src]
impl<Frac: LeEqU64> OverflowingCast<FixedI64<Frac>> for F128Bits
[src]
impl<FracSrc: LeEqU8, FracDst: LeEqU64> OverflowingCast<FixedI64<FracDst>> for FixedI8<FracSrc>
[src]
impl<FracSrc: LeEqU16, FracDst: LeEqU64> OverflowingCast<FixedI64<FracDst>> for FixedI16<FracSrc>
[src]
impl<FracSrc: LeEqU32, FracDst: LeEqU64> OverflowingCast<FixedI64<FracDst>> for FixedI32<FracSrc>
[src]
impl<FracSrc: LeEqU64, FracDst: LeEqU64> OverflowingCast<FixedI64<FracDst>> for FixedI64<FracSrc>
[src]
impl<FracSrc: LeEqU128, FracDst: LeEqU64> OverflowingCast<FixedI64<FracDst>> for FixedI128<FracSrc>
[src]
impl<FracSrc: LeEqU8, FracDst: LeEqU64> OverflowingCast<FixedI64<FracDst>> for FixedU8<FracSrc>
[src]
impl<FracSrc: LeEqU16, FracDst: LeEqU64> OverflowingCast<FixedI64<FracDst>> for FixedU16<FracSrc>
[src]
impl<FracSrc: LeEqU32, FracDst: LeEqU64> OverflowingCast<FixedI64<FracDst>> for FixedU32<FracSrc>
[src]
impl<FracSrc: LeEqU64, FracDst: LeEqU64> OverflowingCast<FixedI64<FracDst>> for FixedU64<FracSrc>
[src]
impl<FracSrc: LeEqU128, FracDst: LeEqU64> OverflowingCast<FixedI64<FracDst>> for FixedU128<FracSrc>
[src]
impl<FracSrc: LeEqU64, FracDst: LeEqU8> OverflowingCast<FixedI8<FracDst>> for FixedI64<FracSrc>
[src]
impl<FracSrc: LeEqU64, FracDst: LeEqU128> OverflowingCast<FixedU128<FracDst>> for FixedI64<FracSrc>
[src]
impl<FracSrc: LeEqU64, FracDst: LeEqU16> OverflowingCast<FixedU16<FracDst>> for FixedI64<FracSrc>
[src]
impl<FracSrc: LeEqU64, FracDst: LeEqU32> OverflowingCast<FixedU32<FracDst>> for FixedI64<FracSrc>
[src]
impl<FracSrc: LeEqU64, FracDst: LeEqU64> OverflowingCast<FixedU64<FracDst>> for FixedI64<FracSrc>
[src]
impl<FracSrc: LeEqU64, FracDst: LeEqU8> OverflowingCast<FixedU8<FracDst>> for FixedI64<FracSrc>
[src]
impl<Frac: LeEqU64> OverflowingCast<bf16> for FixedI64<Frac>
[src]
impl<Frac: LeEqU64> OverflowingCast<f16> for FixedI64<Frac>
[src]
impl<Frac: LeEqU64> OverflowingCast<f32> for FixedI64<Frac>
[src]
impl<Frac: LeEqU64> OverflowingCast<f64> for FixedI64<Frac>
[src]
impl<Frac: LeEqU64> OverflowingCast<i128> for FixedI64<Frac>
[src]
impl<Frac: LeEqU64> OverflowingCast<i16> for FixedI64<Frac>
[src]
impl<Frac: LeEqU64> OverflowingCast<i32> for FixedI64<Frac>
[src]
impl<Frac: LeEqU64> OverflowingCast<i64> for FixedI64<Frac>
[src]
impl<Frac: LeEqU64> OverflowingCast<i8> for FixedI64<Frac>
[src]
impl<Frac: LeEqU64> OverflowingCast<isize> for FixedI64<Frac>
[src]
impl<Frac: LeEqU64> OverflowingCast<u128> for FixedI64<Frac>
[src]
impl<Frac: LeEqU64> OverflowingCast<u16> for FixedI64<Frac>
[src]
impl<Frac: LeEqU64> OverflowingCast<u32> for FixedI64<Frac>
[src]
impl<Frac: LeEqU64> OverflowingCast<u64> for FixedI64<Frac>
[src]
impl<Frac: LeEqU64> OverflowingCast<u8> for FixedI64<Frac>
[src]
impl<Frac: LeEqU64> OverflowingCast<usize> for FixedI64<Frac>
[src]
impl<Frac: LeEqU64> OverflowingMul for FixedI64<Frac>
[src]
impl<Frac> OverflowingSub for FixedI64<Frac>
[src]
impl<Frac: LeEqU64> PartialEq<F128Bits> for FixedI64<Frac>
[src]
impl<FracLhs: LeEqU64, FracRhs: LeEqU128> PartialEq<FixedI128<FracRhs>> for FixedI64<FracLhs>
[src]
fn eq(&self, rhs: &FixedI128<FracRhs>) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<FracLhs: LeEqU64, FracRhs: LeEqU16> PartialEq<FixedI16<FracRhs>> for FixedI64<FracLhs>
[src]
fn eq(&self, rhs: &FixedI16<FracRhs>) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<FracLhs: LeEqU64, FracRhs: LeEqU32> PartialEq<FixedI32<FracRhs>> for FixedI64<FracLhs>
[src]
fn eq(&self, rhs: &FixedI32<FracRhs>) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<Frac: LeEqU64> PartialEq<FixedI64<Frac>> for F128Bits
[src]
fn eq(&self, rhs: &FixedI64<Frac>) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<FracLhs: LeEqU8, FracRhs: LeEqU64> PartialEq<FixedI64<FracRhs>> for FixedI8<FracLhs>
[src]
fn eq(&self, rhs: &FixedI64<FracRhs>) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<FracLhs: LeEqU16, FracRhs: LeEqU64> PartialEq<FixedI64<FracRhs>> for FixedI16<FracLhs>
[src]
fn eq(&self, rhs: &FixedI64<FracRhs>) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<FracLhs: LeEqU32, FracRhs: LeEqU64> PartialEq<FixedI64<FracRhs>> for FixedI32<FracLhs>
[src]
fn eq(&self, rhs: &FixedI64<FracRhs>) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<FracLhs: LeEqU64, FracRhs: LeEqU64> PartialEq<FixedI64<FracRhs>> for FixedI64<FracLhs>
[src]
fn eq(&self, rhs: &FixedI64<FracRhs>) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<FracLhs: LeEqU128, FracRhs: LeEqU64> PartialEq<FixedI64<FracRhs>> for FixedI128<FracLhs>
[src]
fn eq(&self, rhs: &FixedI64<FracRhs>) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<FracLhs: LeEqU8, FracRhs: LeEqU64> PartialEq<FixedI64<FracRhs>> for FixedU8<FracLhs>
[src]
fn eq(&self, rhs: &FixedI64<FracRhs>) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<FracLhs: LeEqU16, FracRhs: LeEqU64> PartialEq<FixedI64<FracRhs>> for FixedU16<FracLhs>
[src]
fn eq(&self, rhs: &FixedI64<FracRhs>) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<FracLhs: LeEqU32, FracRhs: LeEqU64> PartialEq<FixedI64<FracRhs>> for FixedU32<FracLhs>
[src]
fn eq(&self, rhs: &FixedI64<FracRhs>) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<FracLhs: LeEqU64, FracRhs: LeEqU64> PartialEq<FixedI64<FracRhs>> for FixedU64<FracLhs>
[src]
fn eq(&self, rhs: &FixedI64<FracRhs>) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<FracLhs: LeEqU128, FracRhs: LeEqU64> PartialEq<FixedI64<FracRhs>> for FixedU128<FracLhs>
[src]
fn eq(&self, rhs: &FixedI64<FracRhs>) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<FracLhs: LeEqU64, FracRhs: LeEqU8> PartialEq<FixedI8<FracRhs>> for FixedI64<FracLhs>
[src]
fn eq(&self, rhs: &FixedI8<FracRhs>) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<FracLhs: LeEqU64, FracRhs: LeEqU128> PartialEq<FixedU128<FracRhs>> for FixedI64<FracLhs>
[src]
fn eq(&self, rhs: &FixedU128<FracRhs>) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<FracLhs: LeEqU64, FracRhs: LeEqU16> PartialEq<FixedU16<FracRhs>> for FixedI64<FracLhs>
[src]
fn eq(&self, rhs: &FixedU16<FracRhs>) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<FracLhs: LeEqU64, FracRhs: LeEqU32> PartialEq<FixedU32<FracRhs>> for FixedI64<FracLhs>
[src]
fn eq(&self, rhs: &FixedU32<FracRhs>) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<FracLhs: LeEqU64, FracRhs: LeEqU64> PartialEq<FixedU64<FracRhs>> for FixedI64<FracLhs>
[src]
fn eq(&self, rhs: &FixedU64<FracRhs>) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<FracLhs: LeEqU64, FracRhs: LeEqU8> PartialEq<FixedU8<FracRhs>> for FixedI64<FracLhs>
[src]
fn eq(&self, rhs: &FixedU8<FracRhs>) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<Frac: LeEqU64> PartialEq<bf16> for FixedI64<Frac>
[src]
impl<Frac: LeEqU64> PartialEq<f16> for FixedI64<Frac>
[src]
impl<Frac: LeEqU64> PartialEq<f32> for FixedI64<Frac>
[src]
impl<Frac: LeEqU64> PartialEq<f64> for FixedI64<Frac>
[src]
impl<Frac: LeEqU64> PartialEq<i128> for FixedI64<Frac>
[src]
impl<Frac: LeEqU64> PartialEq<i16> for FixedI64<Frac>
[src]
impl<Frac: LeEqU64> PartialEq<i32> for FixedI64<Frac>
[src]
impl<Frac: LeEqU64> PartialEq<i64> for FixedI64<Frac>
[src]
impl<Frac: LeEqU64> PartialEq<i8> for FixedI64<Frac>
[src]
impl<Frac: LeEqU64> PartialEq<isize> for FixedI64<Frac>
[src]
impl<Frac: LeEqU64> PartialEq<u128> for FixedI64<Frac>
[src]
impl<Frac: LeEqU64> PartialEq<u16> for FixedI64<Frac>
[src]
impl<Frac: LeEqU64> PartialEq<u32> for FixedI64<Frac>
[src]
impl<Frac: LeEqU64> PartialEq<u64> for FixedI64<Frac>
[src]
impl<Frac: LeEqU64> PartialEq<u8> for FixedI64<Frac>
[src]
impl<Frac: LeEqU64> PartialEq<usize> for FixedI64<Frac>
[src]
impl<Frac: LeEqU64> PartialOrd<F128Bits> for FixedI64<Frac>
[src]
fn partial_cmp(&self, rhs: &F128Bits) -> Option<Ordering>
[src]
fn lt(&self, rhs: &F128Bits) -> bool
[src]
fn le(&self, rhs: &F128Bits) -> bool
[src]
fn gt(&self, rhs: &F128Bits) -> bool
[src]
fn ge(&self, rhs: &F128Bits) -> bool
[src]
impl<FracLhs: LeEqU64, FracRhs: LeEqU128> PartialOrd<FixedI128<FracRhs>> for FixedI64<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: LeEqU64, FracRhs: LeEqU16> PartialOrd<FixedI16<FracRhs>> for FixedI64<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: 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<Frac: LeEqU64> PartialOrd<FixedI64<Frac>> for F128Bits
[src]
fn partial_cmp(&self, rhs: &FixedI64<Frac>) -> Option<Ordering>
[src]
fn lt(&self, rhs: &FixedI64<Frac>) -> bool
[src]
fn le(&self, rhs: &FixedI64<Frac>) -> bool
[src]
fn gt(&self, rhs: &FixedI64<Frac>) -> bool
[src]
fn ge(&self, rhs: &FixedI64<Frac>) -> bool
[src]
impl<FracLhs: LeEqU8, FracRhs: LeEqU64> PartialOrd<FixedI64<FracRhs>> for FixedI8<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: LeEqU16, FracRhs: LeEqU64> PartialOrd<FixedI64<FracRhs>> for FixedI16<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: 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: LeEqU64, FracRhs: LeEqU64> PartialOrd<FixedI64<FracRhs>> for FixedI64<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: LeEqU128, FracRhs: LeEqU64> PartialOrd<FixedI64<FracRhs>> for FixedI128<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: LeEqU8, FracRhs: LeEqU64> PartialOrd<FixedI64<FracRhs>> for FixedU8<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: LeEqU16, FracRhs: LeEqU64> PartialOrd<FixedI64<FracRhs>> for FixedU16<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: LeEqU64> PartialOrd<FixedI64<FracRhs>> for FixedU32<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: LeEqU64, FracRhs: LeEqU64> PartialOrd<FixedI64<FracRhs>> for FixedU64<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: LeEqU128, FracRhs: LeEqU64> PartialOrd<FixedI64<FracRhs>> for FixedU128<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: LeEqU64, FracRhs: LeEqU8> PartialOrd<FixedI8<FracRhs>> for FixedI64<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: LeEqU64, FracRhs: LeEqU128> PartialOrd<FixedU128<FracRhs>> for FixedI64<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<FracLhs: LeEqU64, FracRhs: LeEqU16> PartialOrd<FixedU16<FracRhs>> for FixedI64<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: LeEqU64, FracRhs: LeEqU32> PartialOrd<FixedU32<FracRhs>> for FixedI64<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: LeEqU64, FracRhs: LeEqU64> PartialOrd<FixedU64<FracRhs>> for FixedI64<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: LeEqU64, FracRhs: LeEqU8> PartialOrd<FixedU8<FracRhs>> for FixedI64<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<Frac: LeEqU64> PartialOrd<bf16> for FixedI64<Frac>
[src]
fn partial_cmp(&self, rhs: &bf16) -> Option<Ordering>
[src]
fn lt(&self, rhs: &bf16) -> bool
[src]
fn le(&self, rhs: &bf16) -> bool
[src]
fn gt(&self, rhs: &bf16) -> bool
[src]
fn ge(&self, rhs: &bf16) -> bool
[src]
impl<Frac: LeEqU64> PartialOrd<f16> for FixedI64<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: LeEqU64> PartialOrd<f32> for FixedI64<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: LeEqU64> PartialOrd<f64> for FixedI64<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: LeEqU64> PartialOrd<i128> for FixedI64<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: LeEqU64> PartialOrd<i16> for FixedI64<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: LeEqU64> PartialOrd<i32> for FixedI64<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: LeEqU64> PartialOrd<i64> for FixedI64<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: LeEqU64> PartialOrd<i8> for FixedI64<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: LeEqU64> PartialOrd<isize> for FixedI64<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: LeEqU64> PartialOrd<u128> for FixedI64<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: LeEqU64> PartialOrd<u16> for FixedI64<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: LeEqU64> PartialOrd<u32> for FixedI64<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: LeEqU64> PartialOrd<u64> for FixedI64<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: LeEqU64> PartialOrd<u8> for FixedI64<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: LeEqU64> PartialOrd<usize> for FixedI64<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<'a, Frac: 'a + LeEqU64> Product<&'a FixedI64<Frac>> for FixedI64<Frac>
[src]
impl<Frac: LeEqU64> Product<FixedI64<Frac>> for FixedI64<Frac>
[src]
impl<Frac> Rem<&'_ FixedI64<Frac>> for FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the %
operator.
fn rem(self, rhs: &FixedI64<Frac>) -> FixedI64<Frac>
[src]
impl<Frac> Rem<&'_ FixedI64<Frac>> for &FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the %
operator.
fn rem(self, rhs: &FixedI64<Frac>) -> FixedI64<Frac>
[src]
impl<Frac: LeEqU64> Rem<&'_ i64> for FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the %
operator.
fn rem(self, rhs: &i64) -> FixedI64<Frac>
[src]
impl<Frac: LeEqU64> Rem<&'_ i64> for &FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the %
operator.
fn rem(self, rhs: &i64) -> FixedI64<Frac>
[src]
impl<Frac> Rem<FixedI64<Frac>> for FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the %
operator.
fn rem(self, rhs: FixedI64<Frac>) -> FixedI64<Frac>
[src]
impl<Frac> Rem<FixedI64<Frac>> for &FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the %
operator.
fn rem(self, rhs: FixedI64<Frac>) -> FixedI64<Frac>
[src]
impl<Frac: LeEqU64> Rem<i64> for FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the %
operator.
fn rem(self, rhs: i64) -> FixedI64<Frac>
[src]
impl<Frac: LeEqU64> Rem<i64> for &FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the %
operator.
fn rem(self, rhs: i64) -> FixedI64<Frac>
[src]
impl<Frac> RemAssign<&'_ FixedI64<Frac>> for FixedI64<Frac>
[src]
fn rem_assign(&mut self, rhs: &FixedI64<Frac>)
[src]
impl<Frac: LeEqU64> RemAssign<&'_ i64> for FixedI64<Frac>
[src]
fn rem_assign(&mut self, rhs: &i64)
[src]
impl<Frac> RemAssign<FixedI64<Frac>> for FixedI64<Frac>
[src]
fn rem_assign(&mut self, rhs: FixedI64<Frac>)
[src]
impl<Frac: LeEqU64> RemAssign<i64> for FixedI64<Frac>
[src]
fn rem_assign(&mut self, rhs: i64)
[src]
impl<Frac> SaturatingAdd for FixedI64<Frac>
[src]
fn saturating_add(&self, v: &Self) -> Self
[src]
impl<Frac: LeEqU64> SaturatingCast<F128Bits> for FixedI64<Frac>
[src]
fn saturating_cast(self) -> F128Bits
[src]
impl<FracSrc: LeEqU64, FracDst: LeEqU128> SaturatingCast<FixedI128<FracDst>> for FixedI64<FracSrc>
[src]
fn saturating_cast(self) -> FixedI128<FracDst>
[src]
impl<FracSrc: LeEqU64, FracDst: LeEqU16> SaturatingCast<FixedI16<FracDst>> for FixedI64<FracSrc>
[src]
fn saturating_cast(self) -> FixedI16<FracDst>
[src]
impl<FracSrc: LeEqU64, FracDst: LeEqU32> SaturatingCast<FixedI32<FracDst>> for FixedI64<FracSrc>
[src]
fn saturating_cast(self) -> FixedI32<FracDst>
[src]
impl<Frac: LeEqU64> SaturatingCast<FixedI64<Frac>> for F128Bits
[src]
fn saturating_cast(self) -> FixedI64<Frac>
[src]
impl<FracSrc: LeEqU8, FracDst: LeEqU64> SaturatingCast<FixedI64<FracDst>> for FixedI8<FracSrc>
[src]
fn saturating_cast(self) -> FixedI64<FracDst>
[src]
impl<FracSrc: LeEqU16, FracDst: LeEqU64> SaturatingCast<FixedI64<FracDst>> for FixedI16<FracSrc>
[src]
fn saturating_cast(self) -> FixedI64<FracDst>
[src]
impl<FracSrc: LeEqU32, FracDst: LeEqU64> SaturatingCast<FixedI64<FracDst>> for FixedI32<FracSrc>
[src]
fn saturating_cast(self) -> FixedI64<FracDst>
[src]
impl<FracSrc: LeEqU64, FracDst: LeEqU64> SaturatingCast<FixedI64<FracDst>> for FixedI64<FracSrc>
[src]
fn saturating_cast(self) -> FixedI64<FracDst>
[src]
impl<FracSrc: LeEqU128, FracDst: LeEqU64> SaturatingCast<FixedI64<FracDst>> for FixedI128<FracSrc>
[src]
fn saturating_cast(self) -> FixedI64<FracDst>
[src]
impl<FracSrc: LeEqU8, FracDst: LeEqU64> SaturatingCast<FixedI64<FracDst>> for FixedU8<FracSrc>
[src]
fn saturating_cast(self) -> FixedI64<FracDst>
[src]
impl<FracSrc: LeEqU16, FracDst: LeEqU64> SaturatingCast<FixedI64<FracDst>> for FixedU16<FracSrc>
[src]
fn saturating_cast(self) -> FixedI64<FracDst>
[src]
impl<FracSrc: LeEqU32, FracDst: LeEqU64> SaturatingCast<FixedI64<FracDst>> for FixedU32<FracSrc>
[src]
fn saturating_cast(self) -> FixedI64<FracDst>
[src]
impl<FracSrc: LeEqU64, FracDst: LeEqU64> SaturatingCast<FixedI64<FracDst>> for FixedU64<FracSrc>
[src]
fn saturating_cast(self) -> FixedI64<FracDst>
[src]
impl<FracSrc: LeEqU128, FracDst: LeEqU64> SaturatingCast<FixedI64<FracDst>> for FixedU128<FracSrc>
[src]
fn saturating_cast(self) -> FixedI64<FracDst>
[src]
impl<FracSrc: LeEqU64, FracDst: LeEqU8> SaturatingCast<FixedI8<FracDst>> for FixedI64<FracSrc>
[src]
fn saturating_cast(self) -> FixedI8<FracDst>
[src]
impl<FracSrc: LeEqU64, FracDst: LeEqU128> SaturatingCast<FixedU128<FracDst>> for FixedI64<FracSrc>
[src]
fn saturating_cast(self) -> FixedU128<FracDst>
[src]
impl<FracSrc: LeEqU64, FracDst: LeEqU16> SaturatingCast<FixedU16<FracDst>> for FixedI64<FracSrc>
[src]
fn saturating_cast(self) -> FixedU16<FracDst>
[src]
impl<FracSrc: LeEqU64, FracDst: LeEqU32> SaturatingCast<FixedU32<FracDst>> for FixedI64<FracSrc>
[src]
fn saturating_cast(self) -> FixedU32<FracDst>
[src]
impl<FracSrc: LeEqU64, FracDst: LeEqU64> SaturatingCast<FixedU64<FracDst>> for FixedI64<FracSrc>
[src]
fn saturating_cast(self) -> FixedU64<FracDst>
[src]
impl<FracSrc: LeEqU64, FracDst: LeEqU8> SaturatingCast<FixedU8<FracDst>> for FixedI64<FracSrc>
[src]
fn saturating_cast(self) -> FixedU8<FracDst>
[src]
impl<Frac: LeEqU64> SaturatingCast<bf16> for FixedI64<Frac>
[src]
fn saturating_cast(self) -> bf16
[src]
impl<Frac: LeEqU64> SaturatingCast<f16> for FixedI64<Frac>
[src]
fn saturating_cast(self) -> f16
[src]
impl<Frac: LeEqU64> SaturatingCast<f32> for FixedI64<Frac>
[src]
fn saturating_cast(self) -> f32
[src]
impl<Frac: LeEqU64> SaturatingCast<f64> for FixedI64<Frac>
[src]
fn saturating_cast(self) -> f64
[src]
impl<Frac: LeEqU64> SaturatingCast<i128> for FixedI64<Frac>
[src]
fn saturating_cast(self) -> i128
[src]
impl<Frac: LeEqU64> SaturatingCast<i16> for FixedI64<Frac>
[src]
fn saturating_cast(self) -> i16
[src]
impl<Frac: LeEqU64> SaturatingCast<i32> for FixedI64<Frac>
[src]
fn saturating_cast(self) -> i32
[src]
impl<Frac: LeEqU64> SaturatingCast<i64> for FixedI64<Frac>
[src]
fn saturating_cast(self) -> i64
[src]
impl<Frac: LeEqU64> SaturatingCast<i8> for FixedI64<Frac>
[src]
fn saturating_cast(self) -> i8
[src]
impl<Frac: LeEqU64> SaturatingCast<isize> for FixedI64<Frac>
[src]
fn saturating_cast(self) -> isize
[src]
impl<Frac: LeEqU64> SaturatingCast<u128> for FixedI64<Frac>
[src]
fn saturating_cast(self) -> u128
[src]
impl<Frac: LeEqU64> SaturatingCast<u16> for FixedI64<Frac>
[src]
fn saturating_cast(self) -> u16
[src]
impl<Frac: LeEqU64> SaturatingCast<u32> for FixedI64<Frac>
[src]
fn saturating_cast(self) -> u32
[src]
impl<Frac: LeEqU64> SaturatingCast<u64> for FixedI64<Frac>
[src]
fn saturating_cast(self) -> u64
[src]
impl<Frac: LeEqU64> SaturatingCast<u8> for FixedI64<Frac>
[src]
fn saturating_cast(self) -> u8
[src]
impl<Frac: LeEqU64> SaturatingCast<usize> for FixedI64<Frac>
[src]
fn saturating_cast(self) -> usize
[src]
impl<Frac: LeEqU64> SaturatingMul for FixedI64<Frac>
[src]
fn saturating_mul(&self, v: &Self) -> Self
[src]
impl<Frac> SaturatingSub for FixedI64<Frac>
[src]
fn saturating_sub(&self, v: &Self) -> Self
[src]
impl<Frac: LeEqU64> Serialize for FixedI64<Frac>
[src]
impl<Frac> Shl<&'_ i128> for FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: &i128) -> FixedI64<Frac>
[src]
impl<Frac> Shl<&'_ i128> for &FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: &i128) -> FixedI64<Frac>
[src]
impl<Frac> Shl<&'_ i16> for FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: &i16) -> FixedI64<Frac>
[src]
impl<Frac> Shl<&'_ i16> for &FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: &i16) -> FixedI64<Frac>
[src]
impl<Frac> Shl<&'_ i32> for FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: &i32) -> FixedI64<Frac>
[src]
impl<Frac> Shl<&'_ i32> for &FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: &i32) -> FixedI64<Frac>
[src]
impl<Frac> Shl<&'_ i64> for FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: &i64) -> FixedI64<Frac>
[src]
impl<Frac> Shl<&'_ i64> for &FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: &i64) -> FixedI64<Frac>
[src]
impl<Frac> Shl<&'_ i8> for FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: &i8) -> FixedI64<Frac>
[src]
impl<Frac> Shl<&'_ i8> for &FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: &i8) -> FixedI64<Frac>
[src]
impl<Frac> Shl<&'_ isize> for FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: &isize) -> FixedI64<Frac>
[src]
impl<Frac> Shl<&'_ isize> for &FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: &isize) -> FixedI64<Frac>
[src]
impl<Frac> Shl<&'_ u128> for FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: &u128) -> FixedI64<Frac>
[src]
impl<Frac> Shl<&'_ u128> for &FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: &u128) -> FixedI64<Frac>
[src]
impl<Frac> Shl<&'_ u16> for FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: &u16) -> FixedI64<Frac>
[src]
impl<Frac> Shl<&'_ u16> for &FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: &u16) -> FixedI64<Frac>
[src]
impl<Frac> Shl<&'_ u32> for FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: &u32) -> FixedI64<Frac>
[src]
impl<Frac> Shl<&'_ u32> for &FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: &u32) -> FixedI64<Frac>
[src]
impl<Frac> Shl<&'_ u64> for FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: &u64) -> FixedI64<Frac>
[src]
impl<Frac> Shl<&'_ u64> for &FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: &u64) -> FixedI64<Frac>
[src]
impl<Frac> Shl<&'_ u8> for FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: &u8) -> FixedI64<Frac>
[src]
impl<Frac> Shl<&'_ u8> for &FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: &u8) -> FixedI64<Frac>
[src]
impl<Frac> Shl<&'_ usize> for FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: &usize) -> FixedI64<Frac>
[src]
impl<Frac> Shl<&'_ usize> for &FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: &usize) -> FixedI64<Frac>
[src]
impl<Frac> Shl<i128> for FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: i128) -> FixedI64<Frac>
[src]
impl<Frac> Shl<i128> for &FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: i128) -> FixedI64<Frac>
[src]
impl<Frac> Shl<i16> for FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: i16) -> FixedI64<Frac>
[src]
impl<Frac> Shl<i16> for &FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: i16) -> FixedI64<Frac>
[src]
impl<Frac> Shl<i32> for FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: i32) -> FixedI64<Frac>
[src]
impl<Frac> Shl<i32> for &FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: i32) -> FixedI64<Frac>
[src]
impl<Frac> Shl<i64> for FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: i64) -> FixedI64<Frac>
[src]
impl<Frac> Shl<i64> for &FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: i64) -> FixedI64<Frac>
[src]
impl<Frac> Shl<i8> for FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: i8) -> FixedI64<Frac>
[src]
impl<Frac> Shl<i8> for &FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: i8) -> FixedI64<Frac>
[src]
impl<Frac> Shl<isize> for FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: isize) -> FixedI64<Frac>
[src]
impl<Frac> Shl<isize> for &FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: isize) -> FixedI64<Frac>
[src]
impl<Frac> Shl<u128> for FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: u128) -> FixedI64<Frac>
[src]
impl<Frac> Shl<u128> for &FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: u128) -> FixedI64<Frac>
[src]
impl<Frac> Shl<u16> for FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: u16) -> FixedI64<Frac>
[src]
impl<Frac> Shl<u16> for &FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: u16) -> FixedI64<Frac>
[src]
impl<Frac> Shl<u32> for FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: u32) -> FixedI64<Frac>
[src]
impl<Frac> Shl<u32> for &FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: u32) -> FixedI64<Frac>
[src]
impl<Frac> Shl<u64> for FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: u64) -> FixedI64<Frac>
[src]
impl<Frac> Shl<u64> for &FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: u64) -> FixedI64<Frac>
[src]
impl<Frac> Shl<u8> for FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: u8) -> FixedI64<Frac>
[src]
impl<Frac> Shl<u8> for &FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: u8) -> FixedI64<Frac>
[src]
impl<Frac> Shl<usize> for FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: usize) -> FixedI64<Frac>
[src]
impl<Frac> Shl<usize> for &FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the <<
operator.
fn shl(self, rhs: usize) -> FixedI64<Frac>
[src]
impl<Frac> ShlAssign<&'_ i128> for FixedI64<Frac>
[src]
fn shl_assign(&mut self, rhs: &i128)
[src]
impl<Frac> ShlAssign<&'_ i16> for FixedI64<Frac>
[src]
fn shl_assign(&mut self, rhs: &i16)
[src]
impl<Frac> ShlAssign<&'_ i32> for FixedI64<Frac>
[src]
fn shl_assign(&mut self, rhs: &i32)
[src]
impl<Frac> ShlAssign<&'_ i64> for FixedI64<Frac>
[src]
fn shl_assign(&mut self, rhs: &i64)
[src]
impl<Frac> ShlAssign<&'_ i8> for FixedI64<Frac>
[src]
fn shl_assign(&mut self, rhs: &i8)
[src]
impl<Frac> ShlAssign<&'_ isize> for FixedI64<Frac>
[src]
fn shl_assign(&mut self, rhs: &isize)
[src]
impl<Frac> ShlAssign<&'_ u128> for FixedI64<Frac>
[src]
fn shl_assign(&mut self, rhs: &u128)
[src]
impl<Frac> ShlAssign<&'_ u16> for FixedI64<Frac>
[src]
fn shl_assign(&mut self, rhs: &u16)
[src]
impl<Frac> ShlAssign<&'_ u32> for FixedI64<Frac>
[src]
fn shl_assign(&mut self, rhs: &u32)
[src]
impl<Frac> ShlAssign<&'_ u64> for FixedI64<Frac>
[src]
fn shl_assign(&mut self, rhs: &u64)
[src]
impl<Frac> ShlAssign<&'_ u8> for FixedI64<Frac>
[src]
fn shl_assign(&mut self, rhs: &u8)
[src]
impl<Frac> ShlAssign<&'_ usize> for FixedI64<Frac>
[src]
fn shl_assign(&mut self, rhs: &usize)
[src]
impl<Frac> ShlAssign<i128> for FixedI64<Frac>
[src]
fn shl_assign(&mut self, rhs: i128)
[src]
impl<Frac> ShlAssign<i16> for FixedI64<Frac>
[src]
fn shl_assign(&mut self, rhs: i16)
[src]
impl<Frac> ShlAssign<i32> for FixedI64<Frac>
[src]
fn shl_assign(&mut self, rhs: i32)
[src]
impl<Frac> ShlAssign<i64> for FixedI64<Frac>
[src]
fn shl_assign(&mut self, rhs: i64)
[src]
impl<Frac> ShlAssign<i8> for FixedI64<Frac>
[src]
fn shl_assign(&mut self, rhs: i8)
[src]
impl<Frac> ShlAssign<isize> for FixedI64<Frac>
[src]
fn shl_assign(&mut self, rhs: isize)
[src]
impl<Frac> ShlAssign<u128> for FixedI64<Frac>
[src]
fn shl_assign(&mut self, rhs: u128)
[src]
impl<Frac> ShlAssign<u16> for FixedI64<Frac>
[src]
fn shl_assign(&mut self, rhs: u16)
[src]
impl<Frac> ShlAssign<u32> for FixedI64<Frac>
[src]
fn shl_assign(&mut self, rhs: u32)
[src]
impl<Frac> ShlAssign<u64> for FixedI64<Frac>
[src]
fn shl_assign(&mut self, rhs: u64)
[src]
impl<Frac> ShlAssign<u8> for FixedI64<Frac>
[src]
fn shl_assign(&mut self, rhs: u8)
[src]
impl<Frac> ShlAssign<usize> for FixedI64<Frac>
[src]
fn shl_assign(&mut self, rhs: usize)
[src]
impl<Frac> Shr<&'_ i128> for FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: &i128) -> FixedI64<Frac>
[src]
impl<Frac> Shr<&'_ i128> for &FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: &i128) -> FixedI64<Frac>
[src]
impl<Frac> Shr<&'_ i16> for FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: &i16) -> FixedI64<Frac>
[src]
impl<Frac> Shr<&'_ i16> for &FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: &i16) -> FixedI64<Frac>
[src]
impl<Frac> Shr<&'_ i32> for FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: &i32) -> FixedI64<Frac>
[src]
impl<Frac> Shr<&'_ i32> for &FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: &i32) -> FixedI64<Frac>
[src]
impl<Frac> Shr<&'_ i64> for FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: &i64) -> FixedI64<Frac>
[src]
impl<Frac> Shr<&'_ i64> for &FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: &i64) -> FixedI64<Frac>
[src]
impl<Frac> Shr<&'_ i8> for FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: &i8) -> FixedI64<Frac>
[src]
impl<Frac> Shr<&'_ i8> for &FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: &i8) -> FixedI64<Frac>
[src]
impl<Frac> Shr<&'_ isize> for FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: &isize) -> FixedI64<Frac>
[src]
impl<Frac> Shr<&'_ isize> for &FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: &isize) -> FixedI64<Frac>
[src]
impl<Frac> Shr<&'_ u128> for FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: &u128) -> FixedI64<Frac>
[src]
impl<Frac> Shr<&'_ u128> for &FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: &u128) -> FixedI64<Frac>
[src]
impl<Frac> Shr<&'_ u16> for FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: &u16) -> FixedI64<Frac>
[src]
impl<Frac> Shr<&'_ u16> for &FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: &u16) -> FixedI64<Frac>
[src]
impl<Frac> Shr<&'_ u32> for FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: &u32) -> FixedI64<Frac>
[src]
impl<Frac> Shr<&'_ u32> for &FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: &u32) -> FixedI64<Frac>
[src]
impl<Frac> Shr<&'_ u64> for FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: &u64) -> FixedI64<Frac>
[src]
impl<Frac> Shr<&'_ u64> for &FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: &u64) -> FixedI64<Frac>
[src]
impl<Frac> Shr<&'_ u8> for FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: &u8) -> FixedI64<Frac>
[src]
impl<Frac> Shr<&'_ u8> for &FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: &u8) -> FixedI64<Frac>
[src]
impl<Frac> Shr<&'_ usize> for FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: &usize) -> FixedI64<Frac>
[src]
impl<Frac> Shr<&'_ usize> for &FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: &usize) -> FixedI64<Frac>
[src]
impl<Frac> Shr<i128> for FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: i128) -> FixedI64<Frac>
[src]
impl<Frac> Shr<i128> for &FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: i128) -> FixedI64<Frac>
[src]
impl<Frac> Shr<i16> for FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: i16) -> FixedI64<Frac>
[src]
impl<Frac> Shr<i16> for &FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: i16) -> FixedI64<Frac>
[src]
impl<Frac> Shr<i32> for FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: i32) -> FixedI64<Frac>
[src]
impl<Frac> Shr<i32> for &FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: i32) -> FixedI64<Frac>
[src]
impl<Frac> Shr<i64> for FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: i64) -> FixedI64<Frac>
[src]
impl<Frac> Shr<i64> for &FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: i64) -> FixedI64<Frac>
[src]
impl<Frac> Shr<i8> for FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: i8) -> FixedI64<Frac>
[src]
impl<Frac> Shr<i8> for &FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: i8) -> FixedI64<Frac>
[src]
impl<Frac> Shr<isize> for FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: isize) -> FixedI64<Frac>
[src]
impl<Frac> Shr<isize> for &FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: isize) -> FixedI64<Frac>
[src]
impl<Frac> Shr<u128> for FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: u128) -> FixedI64<Frac>
[src]
impl<Frac> Shr<u128> for &FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: u128) -> FixedI64<Frac>
[src]
impl<Frac> Shr<u16> for FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: u16) -> FixedI64<Frac>
[src]
impl<Frac> Shr<u16> for &FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: u16) -> FixedI64<Frac>
[src]
impl<Frac> Shr<u32> for FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: u32) -> FixedI64<Frac>
[src]
impl<Frac> Shr<u32> for &FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: u32) -> FixedI64<Frac>
[src]
impl<Frac> Shr<u64> for FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: u64) -> FixedI64<Frac>
[src]
impl<Frac> Shr<u64> for &FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: u64) -> FixedI64<Frac>
[src]
impl<Frac> Shr<u8> for FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: u8) -> FixedI64<Frac>
[src]
impl<Frac> Shr<u8> for &FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: u8) -> FixedI64<Frac>
[src]
impl<Frac> Shr<usize> for FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: usize) -> FixedI64<Frac>
[src]
impl<Frac> Shr<usize> for &FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the >>
operator.
fn shr(self, rhs: usize) -> FixedI64<Frac>
[src]
impl<Frac> ShrAssign<&'_ i128> for FixedI64<Frac>
[src]
fn shr_assign(&mut self, rhs: &i128)
[src]
impl<Frac> ShrAssign<&'_ i16> for FixedI64<Frac>
[src]
fn shr_assign(&mut self, rhs: &i16)
[src]
impl<Frac> ShrAssign<&'_ i32> for FixedI64<Frac>
[src]
fn shr_assign(&mut self, rhs: &i32)
[src]
impl<Frac> ShrAssign<&'_ i64> for FixedI64<Frac>
[src]
fn shr_assign(&mut self, rhs: &i64)
[src]
impl<Frac> ShrAssign<&'_ i8> for FixedI64<Frac>
[src]
fn shr_assign(&mut self, rhs: &i8)
[src]
impl<Frac> ShrAssign<&'_ isize> for FixedI64<Frac>
[src]
fn shr_assign(&mut self, rhs: &isize)
[src]
impl<Frac> ShrAssign<&'_ u128> for FixedI64<Frac>
[src]
fn shr_assign(&mut self, rhs: &u128)
[src]
impl<Frac> ShrAssign<&'_ u16> for FixedI64<Frac>
[src]
fn shr_assign(&mut self, rhs: &u16)
[src]
impl<Frac> ShrAssign<&'_ u32> for FixedI64<Frac>
[src]
fn shr_assign(&mut self, rhs: &u32)
[src]
impl<Frac> ShrAssign<&'_ u64> for FixedI64<Frac>
[src]
fn shr_assign(&mut self, rhs: &u64)
[src]
impl<Frac> ShrAssign<&'_ u8> for FixedI64<Frac>
[src]
fn shr_assign(&mut self, rhs: &u8)
[src]
impl<Frac> ShrAssign<&'_ usize> for FixedI64<Frac>
[src]
fn shr_assign(&mut self, rhs: &usize)
[src]
impl<Frac> ShrAssign<i128> for FixedI64<Frac>
[src]
fn shr_assign(&mut self, rhs: i128)
[src]
impl<Frac> ShrAssign<i16> for FixedI64<Frac>
[src]
fn shr_assign(&mut self, rhs: i16)
[src]
impl<Frac> ShrAssign<i32> for FixedI64<Frac>
[src]
fn shr_assign(&mut self, rhs: i32)
[src]
impl<Frac> ShrAssign<i64> for FixedI64<Frac>
[src]
fn shr_assign(&mut self, rhs: i64)
[src]
impl<Frac> ShrAssign<i8> for FixedI64<Frac>
[src]
fn shr_assign(&mut self, rhs: i8)
[src]
impl<Frac> ShrAssign<isize> for FixedI64<Frac>
[src]
fn shr_assign(&mut self, rhs: isize)
[src]
impl<Frac> ShrAssign<u128> for FixedI64<Frac>
[src]
fn shr_assign(&mut self, rhs: u128)
[src]
impl<Frac> ShrAssign<u16> for FixedI64<Frac>
[src]
fn shr_assign(&mut self, rhs: u16)
[src]
impl<Frac> ShrAssign<u32> for FixedI64<Frac>
[src]
fn shr_assign(&mut self, rhs: u32)
[src]
impl<Frac> ShrAssign<u64> for FixedI64<Frac>
[src]
fn shr_assign(&mut self, rhs: u64)
[src]
impl<Frac> ShrAssign<u8> for FixedI64<Frac>
[src]
fn shr_assign(&mut self, rhs: u8)
[src]
impl<Frac> ShrAssign<usize> for FixedI64<Frac>
[src]
fn shr_assign(&mut self, rhs: usize)
[src]
impl<Frac: LeEqU64> Signed for FixedI64<Frac> where
Frac: IsLessOrEqual<U62, Output = True>,
[src]
Frac: IsLessOrEqual<U62, Output = True>,
fn abs(&self) -> Self
[src]
fn abs_sub(&self, other: &Self) -> Self
[src]
fn signum(&self) -> Self
[src]
fn is_positive(&self) -> bool
[src]
fn is_negative(&self) -> bool
[src]
impl<Frac> Sub<&'_ FixedI64<Frac>> for FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the -
operator.
fn sub(self, rhs: &FixedI64<Frac>) -> FixedI64<Frac>
[src]
impl<Frac> Sub<&'_ FixedI64<Frac>> for &FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the -
operator.
fn sub(self, rhs: &FixedI64<Frac>) -> FixedI64<Frac>
[src]
impl<Frac> Sub<FixedI64<Frac>> for FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the -
operator.
fn sub(self, rhs: FixedI64<Frac>) -> FixedI64<Frac>
[src]
impl<Frac> Sub<FixedI64<Frac>> for &FixedI64<Frac>
[src]
type Output = FixedI64<Frac>
The resulting type after applying the -
operator.
fn sub(self, rhs: FixedI64<Frac>) -> FixedI64<Frac>
[src]
impl<Frac> SubAssign<&'_ FixedI64<Frac>> for FixedI64<Frac>
[src]
fn sub_assign(&mut self, rhs: &FixedI64<Frac>)
[src]
impl<Frac> SubAssign<FixedI64<Frac>> for FixedI64<Frac>
[src]
fn sub_assign(&mut self, rhs: FixedI64<Frac>)
[src]
impl<'a, Frac: 'a> Sum<&'a FixedI64<Frac>> for FixedI64<Frac>
[src]
impl<Frac> Sum<FixedI64<Frac>> for FixedI64<Frac>
[src]
impl<Frac: LeEqU64> ToFixed for FixedI64<Frac>
[src]
fn to_fixed<F: Fixed>(self) -> F
[src]
Converts a fixed-point number.
Any extra fractional bits are discarded, which rounds towards −∞.
Panics
When debug assertions are enabled, panics if the value
does not fit. When debug assertions are not enabled,
the wrapped value can be returned, but it is not
considered a breaking change if in the future it
panics; if wrapping is required use
wrapping_to_fixed
instead.
fn checked_to_fixed<F: Fixed>(self) -> Option<F>
[src]
Converts a fixed-point number if it fits, otherwise returns None
.
Any extra fractional bits are discarded, which rounds towards −∞.
fn saturating_to_fixed<F: Fixed>(self) -> F
[src]
Converts a fixed-point number, saturating if it does not fit.
Any extra fractional bits are discarded, which rounds towards −∞.
fn wrapping_to_fixed<F: Fixed>(self) -> F
[src]
Converts a fixed-point number, wrapping if it does not fit.
Any extra fractional bits are discarded, which rounds towards −∞.
fn overflowing_to_fixed<F: Fixed>(self) -> (F, bool)
[src]
Converts a fixed-point number.
Returns a tuple of the value and a bool
indicating whether an overflow has occurred. On
overflow, the wrapped value is returned.
Any extra fractional bits are discarded, which rounds towards −∞.
fn unwrapped_to_fixed<F: Fixed>(self) -> F
[src]
Converts a fixed-point number, panicking if it does not fit.
Any extra fractional bits are discarded, which rounds towards −∞.
Panics
Panics if the value does not fit, even when debug assertions are not enabled.
impl<Frac: LeEqU64> ToPrimitive for FixedI64<Frac>
[src]
fn to_i64(&self) -> Option<i64>
[src]
fn to_u64(&self) -> Option<u64>
[src]
fn to_isize(&self) -> Option<isize>
[src]
fn to_i8(&self) -> Option<i8>
[src]
fn to_i16(&self) -> Option<i16>
[src]
fn to_i32(&self) -> Option<i32>
[src]
fn to_i128(&self) -> Option<i128>
[src]
fn to_usize(&self) -> Option<usize>
[src]
fn to_u8(&self) -> Option<u8>
[src]
fn to_u16(&self) -> Option<u16>
[src]
fn to_u32(&self) -> Option<u32>
[src]
fn to_u128(&self) -> Option<u128>
[src]
fn to_f32(&self) -> Option<f32>
[src]
fn to_f64(&self) -> Option<f64>
[src]
impl<Frac: LeEqU64> UnwrappedCast<F128Bits> for FixedI64<Frac>
[src]
fn unwrapped_cast(self) -> F128Bits
[src]
impl<FracSrc: LeEqU64, FracDst: LeEqU128> UnwrappedCast<FixedI128<FracDst>> for FixedI64<FracSrc>
[src]
fn unwrapped_cast(self) -> FixedI128<FracDst>
[src]
impl<FracSrc: LeEqU64, FracDst: LeEqU16> UnwrappedCast<FixedI16<FracDst>> for FixedI64<FracSrc>
[src]
fn unwrapped_cast(self) -> FixedI16<FracDst>
[src]
impl<FracSrc: LeEqU64, FracDst: LeEqU32> UnwrappedCast<FixedI32<FracDst>> for FixedI64<FracSrc>
[src]
fn unwrapped_cast(self) -> FixedI32<FracDst>
[src]
impl<Frac: LeEqU64> UnwrappedCast<FixedI64<Frac>> for F128Bits
[src]
fn unwrapped_cast(self) -> FixedI64<Frac>
[src]
impl<FracSrc: LeEqU8, FracDst: LeEqU64> UnwrappedCast<FixedI64<FracDst>> for FixedI8<FracSrc>
[src]
fn unwrapped_cast(self) -> FixedI64<FracDst>
[src]
impl<FracSrc: LeEqU16, FracDst: LeEqU64> UnwrappedCast<FixedI64<FracDst>> for FixedI16<FracSrc>
[src]
fn unwrapped_cast(self) -> FixedI64<FracDst>
[src]
impl<FracSrc: LeEqU32, FracDst: LeEqU64> UnwrappedCast<FixedI64<FracDst>> for FixedI32<FracSrc>
[src]
fn unwrapped_cast(self) -> FixedI64<FracDst>
[src]
impl<FracSrc: LeEqU64, FracDst: LeEqU64> UnwrappedCast<FixedI64<FracDst>> for FixedI64<FracSrc>
[src]
fn unwrapped_cast(self) -> FixedI64<FracDst>
[src]
impl<FracSrc: LeEqU128, FracDst: LeEqU64> UnwrappedCast<FixedI64<FracDst>> for FixedI128<FracSrc>
[src]
fn unwrapped_cast(self) -> FixedI64<FracDst>
[src]
impl<FracSrc: LeEqU8, FracDst: LeEqU64> UnwrappedCast<FixedI64<FracDst>> for FixedU8<FracSrc>
[src]
fn unwrapped_cast(self) -> FixedI64<FracDst>
[src]
impl<FracSrc: LeEqU16, FracDst: LeEqU64> UnwrappedCast<FixedI64<FracDst>> for FixedU16<FracSrc>
[src]
fn unwrapped_cast(self) -> FixedI64<FracDst>
[src]
impl<FracSrc: LeEqU32, FracDst: LeEqU64> UnwrappedCast<FixedI64<FracDst>> for FixedU32<FracSrc>
[src]
fn unwrapped_cast(self) -> FixedI64<FracDst>
[src]
impl<FracSrc: LeEqU64, FracDst: LeEqU64> UnwrappedCast<FixedI64<FracDst>> for FixedU64<FracSrc>
[src]
fn unwrapped_cast(self) -> FixedI64<FracDst>
[src]
impl<FracSrc: LeEqU128, FracDst: LeEqU64> UnwrappedCast<FixedI64<FracDst>> for FixedU128<FracSrc>
[src]
fn unwrapped_cast(self) -> FixedI64<FracDst>
[src]
impl<FracSrc: LeEqU64, FracDst: LeEqU8> UnwrappedCast<FixedI8<FracDst>> for FixedI64<FracSrc>
[src]
fn unwrapped_cast(self) -> FixedI8<FracDst>
[src]
impl<FracSrc: LeEqU64, FracDst: LeEqU128> UnwrappedCast<FixedU128<FracDst>> for FixedI64<FracSrc>
[src]
fn unwrapped_cast(self) -> FixedU128<FracDst>
[src]
impl<FracSrc: LeEqU64, FracDst: LeEqU16> UnwrappedCast<FixedU16<FracDst>> for FixedI64<FracSrc>
[src]
fn unwrapped_cast(self) -> FixedU16<FracDst>
[src]
impl<FracSrc: LeEqU64, FracDst: LeEqU32> UnwrappedCast<FixedU32<FracDst>> for FixedI64<FracSrc>
[src]
fn unwrapped_cast(self) -> FixedU32<FracDst>
[src]
impl<FracSrc: LeEqU64, FracDst: LeEqU64> UnwrappedCast<FixedU64<FracDst>> for FixedI64<FracSrc>
[src]
fn unwrapped_cast(self) -> FixedU64<FracDst>
[src]
impl<FracSrc: LeEqU64, FracDst: LeEqU8> UnwrappedCast<FixedU8<FracDst>> for FixedI64<FracSrc>
[src]
fn unwrapped_cast(self) -> FixedU8<FracDst>
[src]
impl<Frac: LeEqU64> UnwrappedCast<bf16> for FixedI64<Frac>
[src]
fn unwrapped_cast(self) -> bf16
[src]
impl<Frac: LeEqU64> UnwrappedCast<f16> for FixedI64<Frac>
[src]
fn unwrapped_cast(self) -> f16
[src]
impl<Frac: LeEqU64> UnwrappedCast<f32> for FixedI64<Frac>
[src]
fn unwrapped_cast(self) -> f32
[src]
impl<Frac: LeEqU64> UnwrappedCast<f64> for FixedI64<Frac>
[src]
fn unwrapped_cast(self) -> f64
[src]
impl<Frac: LeEqU64> UnwrappedCast<i128> for FixedI64<Frac>
[src]
fn unwrapped_cast(self) -> i128
[src]
impl<Frac: LeEqU64> UnwrappedCast<i16> for FixedI64<Frac>
[src]
fn unwrapped_cast(self) -> i16
[src]
impl<Frac: LeEqU64> UnwrappedCast<i32> for FixedI64<Frac>
[src]
fn unwrapped_cast(self) -> i32
[src]
impl<Frac: LeEqU64> UnwrappedCast<i64> for FixedI64<Frac>
[src]
fn unwrapped_cast(self) -> i64
[src]
impl<Frac: LeEqU64> UnwrappedCast<i8> for FixedI64<Frac>
[src]
fn unwrapped_cast(self) -> i8
[src]
impl<Frac: LeEqU64> UnwrappedCast<isize> for FixedI64<Frac>
[src]
fn unwrapped_cast(self) -> isize
[src]
impl<Frac: LeEqU64> UnwrappedCast<u128> for FixedI64<Frac>
[src]
fn unwrapped_cast(self) -> u128
[src]
impl<Frac: LeEqU64> UnwrappedCast<u16> for FixedI64<Frac>
[src]
fn unwrapped_cast(self) -> u16
[src]
impl<Frac: LeEqU64> UnwrappedCast<u32> for FixedI64<Frac>
[src]
fn unwrapped_cast(self) -> u32
[src]
impl<Frac: LeEqU64> UnwrappedCast<u64> for FixedI64<Frac>
[src]
fn unwrapped_cast(self) -> u64
[src]
impl<Frac: LeEqU64> UnwrappedCast<u8> for FixedI64<Frac>
[src]
fn unwrapped_cast(self) -> u8
[src]
impl<Frac: LeEqU64> UnwrappedCast<usize> for FixedI64<Frac>
[src]
fn unwrapped_cast(self) -> usize
[src]
impl<Frac: LeEqU64> UpperHex for FixedI64<Frac>
[src]
impl<Frac> WrappingAdd for FixedI64<Frac>
[src]
fn wrapping_add(&self, v: &Self) -> Self
[src]
impl<Frac: LeEqU64> WrappingCast<F128Bits> for FixedI64<Frac>
[src]
fn wrapping_cast(self) -> F128Bits
[src]
impl<FracSrc: LeEqU64, FracDst: LeEqU128> WrappingCast<FixedI128<FracDst>> for FixedI64<FracSrc>
[src]
fn wrapping_cast(self) -> FixedI128<FracDst>
[src]
impl<FracSrc: LeEqU64, FracDst: LeEqU16> WrappingCast<FixedI16<FracDst>> for FixedI64<FracSrc>
[src]
fn wrapping_cast(self) -> FixedI16<FracDst>
[src]
impl<FracSrc: LeEqU64, FracDst: LeEqU32> WrappingCast<FixedI32<FracDst>> for FixedI64<FracSrc>
[src]
fn wrapping_cast(self) -> FixedI32<FracDst>
[src]
impl<Frac: LeEqU64> WrappingCast<FixedI64<Frac>> for F128Bits
[src]
fn wrapping_cast(self) -> FixedI64<Frac>
[src]
impl<FracSrc: LeEqU8, FracDst: LeEqU64> WrappingCast<FixedI64<FracDst>> for FixedI8<FracSrc>
[src]
fn wrapping_cast(self) -> FixedI64<FracDst>
[src]
impl<FracSrc: LeEqU16, FracDst: LeEqU64> WrappingCast<FixedI64<FracDst>> for FixedI16<FracSrc>
[src]
fn wrapping_cast(self) -> FixedI64<FracDst>
[src]
impl<FracSrc: LeEqU32, FracDst: LeEqU64> WrappingCast<FixedI64<FracDst>> for FixedI32<FracSrc>
[src]
fn wrapping_cast(self) -> FixedI64<FracDst>
[src]
impl<FracSrc: LeEqU64, FracDst: LeEqU64> WrappingCast<FixedI64<FracDst>> for FixedI64<FracSrc>
[src]
fn wrapping_cast(self) -> FixedI64<FracDst>
[src]
impl<FracSrc: LeEqU128, FracDst: LeEqU64> WrappingCast<FixedI64<FracDst>> for FixedI128<FracSrc>
[src]
fn wrapping_cast(self) -> FixedI64<FracDst>
[src]
impl<FracSrc: LeEqU8, FracDst: LeEqU64> WrappingCast<FixedI64<FracDst>> for FixedU8<FracSrc>
[src]
fn wrapping_cast(self) -> FixedI64<FracDst>
[src]
impl<FracSrc: LeEqU16, FracDst: LeEqU64> WrappingCast<FixedI64<FracDst>> for FixedU16<FracSrc>
[src]
fn wrapping_cast(self) -> FixedI64<FracDst>
[src]
impl<FracSrc: LeEqU32, FracDst: LeEqU64> WrappingCast<FixedI64<FracDst>> for FixedU32<FracSrc>
[src]
fn wrapping_cast(self) -> FixedI64<FracDst>
[src]
impl<FracSrc: LeEqU64, FracDst: LeEqU64> WrappingCast<FixedI64<FracDst>> for FixedU64<FracSrc>
[src]
fn wrapping_cast(self) -> FixedI64<FracDst>
[src]
impl<FracSrc: LeEqU128, FracDst: LeEqU64> WrappingCast<FixedI64<FracDst>> for FixedU128<FracSrc>
[src]
fn wrapping_cast(self) -> FixedI64<FracDst>
[src]
impl<FracSrc: LeEqU64, FracDst: LeEqU8> WrappingCast<FixedI8<FracDst>> for FixedI64<FracSrc>
[src]
fn wrapping_cast(self) -> FixedI8<FracDst>
[src]
impl<FracSrc: LeEqU64, FracDst: LeEqU128> WrappingCast<FixedU128<FracDst>> for FixedI64<FracSrc>
[src]
fn wrapping_cast(self) -> FixedU128<FracDst>
[src]
impl<FracSrc: LeEqU64, FracDst: LeEqU16> WrappingCast<FixedU16<FracDst>> for FixedI64<FracSrc>
[src]
fn wrapping_cast(self) -> FixedU16<FracDst>
[src]
impl<FracSrc: LeEqU64, FracDst: LeEqU32> WrappingCast<FixedU32<FracDst>> for FixedI64<FracSrc>
[src]
fn wrapping_cast(self) -> FixedU32<FracDst>
[src]
impl<FracSrc: LeEqU64, FracDst: LeEqU64> WrappingCast<FixedU64<FracDst>> for FixedI64<FracSrc>
[src]
fn wrapping_cast(self) -> FixedU64<FracDst>
[src]
impl<FracSrc: LeEqU64, FracDst: LeEqU8> WrappingCast<FixedU8<FracDst>> for FixedI64<FracSrc>
[src]
fn wrapping_cast(self) -> FixedU8<FracDst>
[src]
impl<Frac: LeEqU64> WrappingCast<bf16> for FixedI64<Frac>
[src]
fn wrapping_cast(self) -> bf16
[src]
impl<Frac: LeEqU64> WrappingCast<f16> for FixedI64<Frac>
[src]
fn wrapping_cast(self) -> f16
[src]
impl<Frac: LeEqU64> WrappingCast<f32> for FixedI64<Frac>
[src]
fn wrapping_cast(self) -> f32
[src]
impl<Frac: LeEqU64> WrappingCast<f64> for FixedI64<Frac>
[src]
fn wrapping_cast(self) -> f64
[src]
impl<Frac: LeEqU64> WrappingCast<i128> for FixedI64<Frac>
[src]
fn wrapping_cast(self) -> i128
[src]
impl<Frac: LeEqU64> WrappingCast<i16> for FixedI64<Frac>
[src]
fn wrapping_cast(self) -> i16
[src]
impl<Frac: LeEqU64> WrappingCast<i32> for FixedI64<Frac>
[src]
fn wrapping_cast(self) -> i32
[src]
impl<Frac: LeEqU64> WrappingCast<i64> for FixedI64<Frac>
[src]
fn wrapping_cast(self) -> i64
[src]
impl<Frac: LeEqU64> WrappingCast<i8> for FixedI64<Frac>
[src]
fn wrapping_cast(self) -> i8
[src]
impl<Frac: LeEqU64> WrappingCast<isize> for FixedI64<Frac>
[src]
fn wrapping_cast(self) -> isize
[src]
impl<Frac: LeEqU64> WrappingCast<u128> for FixedI64<Frac>
[src]
fn wrapping_cast(self) -> u128
[src]
impl<Frac: LeEqU64> WrappingCast<u16> for FixedI64<Frac>
[src]
fn wrapping_cast(self) -> u16
[src]
impl<Frac: LeEqU64> WrappingCast<u32> for FixedI64<Frac>
[src]
fn wrapping_cast(self) -> u32
[src]
impl<Frac: LeEqU64> WrappingCast<u64> for FixedI64<Frac>
[src]
fn wrapping_cast(self) -> u64
[src]
impl<Frac: LeEqU64> WrappingCast<u8> for FixedI64<Frac>
[src]
fn wrapping_cast(self) -> u8
[src]
impl<Frac: LeEqU64> WrappingCast<usize> for FixedI64<Frac>
[src]
fn wrapping_cast(self) -> usize
[src]
impl<Frac: LeEqU64> WrappingMul for FixedI64<Frac>
[src]
fn wrapping_mul(&self, v: &Self) -> Self
[src]
impl<Frac> WrappingNeg for FixedI64<Frac>
[src]
fn wrapping_neg(&self) -> Self
[src]
impl<Frac> WrappingShl for FixedI64<Frac>
[src]
fn wrapping_shl(&self, rhs: u32) -> Self
[src]
impl<Frac> WrappingShr for FixedI64<Frac>
[src]
fn wrapping_shr(&self, rhs: u32) -> Self
[src]
impl<Frac> WrappingSub for FixedI64<Frac>
[src]
fn wrapping_sub(&self, v: &Self) -> Self
[src]
impl<Frac> Zero for FixedI64<Frac>
[src]
Auto Trait Implementations
impl<Frac> RefUnwindSafe for FixedI64<Frac> where
Frac: RefUnwindSafe,
Frac: RefUnwindSafe,
impl<Frac> Send for FixedI64<Frac> where
Frac: Send,
Frac: Send,
impl<Frac> Sync for FixedI64<Frac> where
Frac: Sync,
Frac: Sync,
impl<Frac> Unpin for FixedI64<Frac> where
Frac: Unpin,
Frac: Unpin,
impl<Frac> UnwindSafe for FixedI64<Frac> where
Frac: UnwindSafe,
Frac: UnwindSafe,
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Az for T
[src]
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> CheckedAs for T
[src]
pub fn checked_as<Dst>(self) -> Option<Dst> where
T: CheckedCast<Dst>,
[src]
T: CheckedCast<Dst>,
impl<T> DeserializeOwned for T where
T: for<'de> Deserialize<'de>,
[src]
T: for<'de> Deserialize<'de>,
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<Src, Dst> LosslessTryInto<Dst> for Src where
Dst: LosslessTryFrom<Src>,
[src]
Dst: LosslessTryFrom<Src>,
pub fn lossless_try_into(Self) -> Option<Dst>
[src]
impl<Src, Dst> LossyInto<Dst> for Src where
Dst: LossyFrom<Src>,
[src]
Dst: LossyFrom<Src>,
pub fn lossy_into(Self) -> Dst
[src]
impl<T> NumAssign for T where
T: Num + NumAssignOps<T>,
[src]
T: Num + NumAssignOps<T>,
impl<T, Rhs> NumAssignOps<Rhs> for T where
T: AddAssign<Rhs> + SubAssign<Rhs> + MulAssign<Rhs> + DivAssign<Rhs> + RemAssign<Rhs>,
[src]
T: AddAssign<Rhs> + SubAssign<Rhs> + MulAssign<Rhs> + DivAssign<Rhs> + RemAssign<Rhs>,
impl<T> NumAssignRef for T where
T: NumAssign + for<'r> NumAssignOps<&'r T>,
[src]
T: NumAssign + for<'r> NumAssignOps<&'r T>,
impl<T, Rhs, Output> NumOps<Rhs, Output> for T where
T: Sub<Rhs, Output = Output> + Mul<Rhs, Output = Output> + Div<Rhs, Output = Output> + Add<Rhs, Output = Output> + Rem<Rhs, Output = Output>,
[src]
T: Sub<Rhs, Output = Output> + Mul<Rhs, Output = Output> + Div<Rhs, Output = Output> + Add<Rhs, Output = Output> + Rem<Rhs, Output = Output>,
impl<T> NumRef for T where
T: Num + for<'r> NumOps<&'r T, T>,
[src]
T: Num + for<'r> NumOps<&'r T, T>,
impl<T> OverflowingAs for T
[src]
pub fn overflowing_as<Dst>(self) -> (Dst, bool) where
T: OverflowingCast<Dst>,
[src]
T: OverflowingCast<Dst>,
impl<T, Base> RefNum<Base> for T where
T: NumOps<Base, Base> + for<'r> NumOps<&'r Base, Base>,
[src]
T: NumOps<Base, Base> + for<'r> NumOps<&'r Base, Base>,
impl<T> Same<T> for T
[src]
type Output = T
Should always be Self
impl<T> SaturatingAs for T
[src]
pub fn saturating_as<Dst>(self) -> Dst where
T: SaturatingCast<Dst>,
[src]
T: SaturatingCast<Dst>,
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
pub fn to_owned(&self) -> T
[src]
pub fn clone_into(&self, target: &mut T)
[src]
impl<T> ToString for T where
T: Display + ?Sized,
[src]
T: Display + ?Sized,
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
[src]
impl<T> UnwrappedAs for T
[src]
pub fn unwrapped_as<Dst>(self) -> Dst where
T: UnwrappedCast<Dst>,
[src]
T: UnwrappedCast<Dst>,
impl<T> WrappingAs for T
[src]
pub fn wrapping_as<Dst>(self) -> Dst where
T: WrappingCast<Dst>,
[src]
T: WrappingCast<Dst>,