#[repr(transparent)]pub struct FixedU32<Frac> { /* private fields */ }
Expand description
A 32-bit unsigned number with Frac
fractional bits.
The number has 32 bits, of which f = Frac
are
fractional bits and 32 − f are integer bits.
The value x can lie in the range 0 ≤ x < 232/2f. The difference between successive
numbers is constant throughout the range: Δ = 1/2f.
For FixedU32<U0>
, f = 0 and
Δ = 1, and the fixed-point number behaves like a u32
with the value lying in the range 0 ≤ x < 232. For FixedU32<U32>
,
f = 32 and
Δ = 1/232, and the value lies in the
range 0 ≤ x < 1.
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.
FixedU32<Frac>
has the same size, alignment and ABI as u32
;
it is #[repr(transparent)]
with u32
as the only non-zero-sized field.
Examples
use fixed::{types::extra::U3, FixedU32};
let eleven = FixedU32::<U3>::from_num(11);
assert_eq!(eleven, FixedU32::<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, FixedU32::<U3>::from_bits(11 << 1));
assert_eq!(two_point_75, 2.75);
assert_eq!(two_point_75.to_string(), "2.8");
Implementations
The implementation of items in this block is independent
of the number of fractional bits Frac
.
Zero.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
assert_eq!(Fix::ZERO, Fix::from_bits(0));
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, FixedU32};
type Fix = FixedU32<U4>;
assert_eq!(Fix::DELTA, Fix::from_bits(1));
// binary 0.0001 is decimal 0.0625
assert_eq!(Fix::DELTA, 0.0625);
The smallest value that can be represented.
The minimum of unsigned numbers is 0.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
assert_eq!(Fix::MIN, Fix::from_bits(u32::MIN));
The largest value that can be represented.
If the number has f = Frac
fractional bits, then the maximum is
(232 − 1)/2f.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
assert_eq!(Fix::MAX, Fix::from_bits(u32::MAX));
Creates a fixed-point number that has a bitwise representation identical to the given integer.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
// 0010.0000 == 2
assert_eq!(Fix::from_bits(0b10_0000), 2);
Creates an integer that has a bitwise representation identical to the given fixed-point number.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
// 2 is 0010.0000
assert_eq!(Fix::from_num(2).to_bits(), 0b10_0000);
Converts a fixed-point number from big endian to the target’s endianness.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
let f = Fix::from_bits(0x1234_5678);
if cfg!(target_endian = "big") {
assert_eq!(Fix::from_be(f), f);
} else {
assert_eq!(Fix::from_be(f), f.swap_bytes());
}
Converts a fixed-point number from little endian to the target’s endianness.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
let f = Fix::from_bits(0x1234_5678);
if cfg!(target_endian = "little") {
assert_eq!(Fix::from_le(f), f);
} else {
assert_eq!(Fix::from_le(f), f.swap_bytes());
}
Converts self
to big endian from the target’s endianness.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
let f = Fix::from_bits(0x1234_5678);
if cfg!(target_endian = "big") {
assert_eq!(f.to_be(), f);
} else {
assert_eq!(f.to_be(), f.swap_bytes());
}
Converts self
to little endian from the target’s endianness.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
let f = Fix::from_bits(0x1234_5678);
if cfg!(target_endian = "little") {
assert_eq!(f.to_le(), f);
} else {
assert_eq!(f.to_le(), f.swap_bytes());
}
Reverses the byte order of the fixed-point number.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
let f = Fix::from_bits(0x1234_5678);
let swapped = Fix::from_bits(0x7856_3412);
assert_eq!(f.swap_bytes(), swapped);
Creates a fixed-point number from its representation as a byte array in big endian.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
assert_eq!(
Fix::from_be_bytes([0x12, 0x34, 0x56, 0x78]),
Fix::from_bits(0x1234_5678)
);
Creates a fixed-point number from its representation as a byte array in little endian.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
assert_eq!(
Fix::from_le_bytes([0x78, 0x56, 0x34, 0x12]),
Fix::from_bits(0x1234_5678)
);
Creates a fixed-point number from its representation as a byte array in native endian.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
assert_eq!(
if cfg!(target_endian = "big") {
Fix::from_ne_bytes([0x12, 0x34, 0x56, 0x78])
} else {
Fix::from_ne_bytes([0x78, 0x56, 0x34, 0x12])
},
Fix::from_bits(0x1234_5678)
);
Returns the memory representation of this fixed-point number as a byte array in big-endian byte order.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
let val = Fix::from_bits(0x1234_5678);
assert_eq!(
val.to_be_bytes(),
[0x12, 0x34, 0x56, 0x78]
);
Returns the memory representation of this fixed-point number as a byte array in little-endian byte order.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
let val = Fix::from_bits(0x1234_5678);
assert_eq!(
val.to_le_bytes(),
[0x78, 0x56, 0x34, 0x12]
);
Returns the memory representation of this fixed-point number as a byte array in native byte order.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
let val = Fix::from_bits(0x1234_5678);
assert_eq!(
val.to_ne_bytes(),
if cfg!(target_endian = "big") {
[0x12, 0x34, 0x56, 0x78]
} else {
[0x78, 0x56, 0x34, 0x12]
}
);
Returns the number of ones in the binary representation.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
let f = Fix::from_bits(0b11_0010);
assert_eq!(f.count_ones(), 3);
Returns the number of zeros in the binary representation.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
let f = Fix::from_bits(!0b11_0010);
assert_eq!(f.count_zeros(), 3);
Returns the number of leading ones in the binary representation.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
let all_ones = !Fix::ZERO;
let f = all_ones - Fix::from_bits(0b10_0000);
assert_eq!(f.leading_ones(), 32 - 6);
Returns the number of leading zeros in the binary representation.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
let f = Fix::from_bits(0b10_0000);
assert_eq!(f.leading_zeros(), 32 - 6);
Returns the number of trailing ones in the binary representation.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
let f = Fix::from_bits(0b101_1111);
assert_eq!(f.trailing_ones(), 5);
Returns the number of trailing zeros in the binary representation.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
let f = Fix::from_bits(0b10_0000);
assert_eq!(f.trailing_zeros(), 5);
Returns the number of bits required to represent the value.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
assert_eq!(Fix::from_num(0).significant_bits(), 0); // “____.____”
assert_eq!(Fix::from_num(0.0625).significant_bits(), 1); // “____.___1”
assert_eq!(Fix::from_num(1).significant_bits(), 5); // “___1.0000”
assert_eq!(Fix::from_num(3).significant_bits(), 6); // “__11.0000”
Reverses the order of the bits of the fixed-point number.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
let bits = 0x1234_5678_u32;
let rev_bits = bits.reverse_bits();
assert_eq!(Fix::from_bits(bits).reverse_bits(), Fix::from_bits(rev_bits));
Shifts to the left by n
bits, wrapping the
truncated bits to the right end.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
let bits: u32 = (0b111 << (32 - 3)) | 0b1010;
let rot = 0b1010111;
assert_eq!(bits.rotate_left(3), rot);
assert_eq!(Fix::from_bits(bits).rotate_left(3), Fix::from_bits(rot));
Shifts to the right by n
bits, wrapping the
truncated bits to the left end.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
let bits: u32 = 0b1010111;
let rot = (0b111 << (32 - 3)) | 0b1010;
assert_eq!(bits.rotate_right(3), rot);
assert_eq!(Fix::from_bits(bits).rotate_right(3), Fix::from_bits(rot));
Returns true
if the fixed-point number is
2k for some integer k.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
// 3/8 is 0.0110
let three_eights = Fix::from_bits(0b0110);
// 1/2 is 0.1000
let half = Fix::from_bits(0b1000);
assert!(!three_eights.is_power_of_two());
assert!(half.is_power_of_two());
Multiplies two fixed-point numbers and returns a wider type to retain all precision.
If self
has f fractional bits and 32 − f
integer bits, and rhs
has g fractional bits and 32 − g integer bits, then the returned fixed-point number will
have f + g fractional bits and 64 − f − g integer bits.
Examples
use fixed::{
types::extra::{U2, U4},
FixedU32,
};
// decimal: 1.25 × 1.0625 = 1.328_125
// binary: 1.01 × 1.0001 == 1.010101
let a = FixedU32::<U2>::from_num(1.25);
let b = FixedU32::<U4>::from_num(1.0625);
assert_eq!(a.wide_mul(b), 1.328_125);
Divides two fixed-point numbers and returns a wider type to retain more precision.
If self
has f fractional bits
and 32 − f integer bits, and rhs
has
g fractional bits and 32 − g integer
bits, then the returned fixed-point number will
have 32 + f − g fractional
bits and 32 − f + g integer
bits.
Panics
Panics if the divisor is zero.
Examples
use fixed::{
types::extra::{U3, U5, U30},
FixedU32, FixedU64,
};
// decimal: 4.625 / 0.03125 = 148
// binary: 100.101 / 0.00001 == 10010100
let a = FixedU32::<U3>::from_num(4.625);
let b = FixedU32::<U5>::from_num(0.03125);
let ans: FixedU64<U30> = a.wide_div(b);
assert_eq!(ans, 148);
Multiply and add. Returns self
× mul
+ add
.
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, FixedU32};
type Fix = FixedU32<U4>;
assert_eq!(
Fix::from_num(4).mul_add(Fix::from_num(0.5), Fix::from_num(3)),
Fix::from_num(5)
);
Returns the distance from self
to other
.
The distance is the absolute value of the difference.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
assert_eq!(Fix::ONE.dist(Fix::from_num(5)), Fix::from_num(4));
Returns the mean of self
and other
.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
assert_eq!(Fix::from_num(3).mean(Fix::from_num(4)), Fix::from_num(3.5));
Inverse linear interpolation between start
and end
.
The computed value can have a fixed-point type like self
but with a different
number of fractional bits.
Returns
(self
− start
) / (end
− start
).
This is 0 when self
= start
, and 1 when self
= end
.
Panics
Panics when start
= end
.
When debug assertions are enabled, this method also 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_inv_lerp
instead.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
let start = Fix::from_num(2);
let end = Fix::from_num(3.5);
assert_eq!(Fix::from_num(2).inv_lerp::<U4>(start, end), 0);
assert_eq!(Fix::from_num(2.75).inv_lerp::<U4>(start, end), 0.5);
assert_eq!(Fix::from_num(3.5).inv_lerp::<U4>(start, end), 1);
assert_eq!(Fix::from_num(5).inv_lerp::<U4>(start, end), 2);
Returns the highest one in the binary
representation, or zero if self
is zero.
If self
> 0, the highest one is equal to the largest power of two
that is ≤ self
.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
assert_eq!(Fix::from_bits(0b11_0010).highest_one(), Fix::from_bits(0b10_0000));
assert_eq!(Fix::from_num(0.3).highest_one(), Fix::from_num(0.25));
assert_eq!(Fix::from_num(4).highest_one(), Fix::from_num(4));
assert_eq!(Fix::from_num(6.5).highest_one(), Fix::from_num(4));
assert_eq!(Fix::ZERO.highest_one(), Fix::ZERO);
Returns the smallest power of two that is ≥ self
.
Panics
When debug assertions are enabled, panics if the next power of two is
too large to represent. When debug assertions are not enabled, zero
can be returned, but it is not considered a breaking change if in the
future it panics; if this is not desirable use
checked_next_power_of_two
instead.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
assert_eq!(Fix::from_bits(0b11_0010).next_power_of_two(), Fix::from_bits(0b100_0000));
assert_eq!(Fix::from_num(0.3).next_power_of_two(), Fix::from_num(0.5));
assert_eq!(Fix::from_num(4).next_power_of_two(), Fix::from_num(4));
assert_eq!(Fix::from_num(6.5).next_power_of_two(), Fix::from_num(8));
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, FixedU32};
type Fix = FixedU32<U4>;
const A: Fix = Fix::from_bits(0x3E);
const NOT_A: Fix = A.const_not();
assert_eq!(NOT_A, !A);
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, FixedU32};
type Fix = FixedU32<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);
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, FixedU32};
type Fix = FixedU32<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);
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, FixedU32};
type Fix = FixedU32<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);
Checked multiply and add.
Returns self
× mul
+ add
, or None
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, FixedU32};
type Fix = FixedU32<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);
Checked remainder for Euclidean division. Returns the
remainder, or None
if the divisor is zero.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<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);
Checked distance. Returns the distance from self
to other
.
The distance is the absolute value of the difference.
Can never overflow for unsigned types.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
assert_eq!(Fix::ONE.checked_dist(Fix::from_num(5)), Some(Fix::from_num(4)));
assert_eq!(Fix::ZERO.checked_dist(Fix::MAX), Some(Fix::MAX));
Checked inverse linear interpolation between start
and end
.
Returns None
on overflow or when start
= end
.
The computed value can have a fixed-point type like self
but with a different
number of fractional bits.
Returns
(self
− start
) / (end
− start
).
This is 0 when self
= start
, and 1 when self
= end
.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
let two = Fix::from_num(2);
let four = Fix::from_num(4);
assert_eq!(Fix::from_num(3).checked_inv_lerp::<U4>(two, four), Some(Fix::from_num(0.5)));
assert_eq!(Fix::from_num(2).checked_inv_lerp::<U4>(two, two), None);
assert_eq!(Fix::MAX.checked_inv_lerp::<U4>(Fix::ZERO, Fix::from_num(0.5)), None);
Returns the smallest power of two that is ≥ self
, or
None
if the next power of two is too large to represent.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
// 3/8 is 0.0110
let three_eights = Fix::from_bits(0b0110);
// 1/2 is 0.1000
let half = Fix::from_bits(0b1000);
assert_eq!(three_eights.checked_next_power_of_two(), Some(half));
assert!(Fix::MAX.checked_next_power_of_two().is_none());
Saturating negation. Returns the negated value, saturating on overflow.
This method always returns zero.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
assert_eq!(Fix::ZERO.saturating_neg(), Fix::from_num(0));
assert_eq!(Fix::from_num(5).saturating_neg(), Fix::ZERO);
Saturating addition. Returns the sum, saturating on overflow.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<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);
Saturating subtraction. Returns the difference, saturating on overflow.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
assert_eq!(Fix::from_num(5).saturating_sub(Fix::from_num(3)), Fix::from_num(2));
assert_eq!(Fix::ZERO.saturating_sub(Fix::ONE), Fix::ZERO);
Saturating multiply and add.
Returns self
× mul
+ add
, saturating 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, FixedU32};
type Fix = FixedU32<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);
Saturating multiplication by an integer. Returns the product, saturating on overflow.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<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);
Saturating distance. Returns the distance from self
to other
.
The distance is the absolute value of the difference.
Can never overflow for unsigned types.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
assert_eq!(Fix::ONE.saturating_dist(Fix::from_num(5)), Fix::from_num(4));
assert_eq!(Fix::ZERO.saturating_dist(Fix::MAX), Fix::MAX);
Inverse linear interpolation between start
and end
,
saturating on overflow.
The computed value can have a fixed-point type like self
but with a different
number of fractional bits.
Returns
(self
− start
) / (end
− start
).
This is 0 when self
= start
, and 1 when self
= end
.
Panics
Panics when start
= end
.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
let two = Fix::from_num(2);
let four = Fix::from_num(4);
assert_eq!(Fix::from_num(3).saturating_inv_lerp::<U4>(two, four), 0.5);
assert_eq!(Fix::MAX.saturating_inv_lerp::<U4>(Fix::ZERO, Fix::from_num(0.5)), Fix::MAX);
assert_eq!(Fix::MAX.saturating_inv_lerp::<U4>(Fix::from_num(0.5), Fix::ZERO), Fix::MIN);
Wrapping negation. Returns the negated value, wrapping on overflow.
Only zero can be negated without overflow.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
assert_eq!(Fix::ZERO.wrapping_neg(), Fix::from_num(0));
assert_eq!(Fix::from_num(5).wrapping_neg(), Fix::wrapping_from_num(-5));
let neg_five_bits = !Fix::from_num(5).to_bits() + 1;
assert_eq!(Fix::from_num(5).wrapping_neg(), Fix::from_bits(neg_five_bits));
Wrapping addition. Returns the sum, wrapping on overflow.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<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), one_minus_delta);
Wrapping subtraction. Returns the difference, wrapping on overflow.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
let one_minus_delta = Fix::ONE - Fix::DELTA;
assert_eq!(Fix::from_num(5).wrapping_sub(Fix::from_num(3)), Fix::from_num(2));
assert_eq!(Fix::ZERO.wrapping_sub(Fix::ONE), Fix::MAX - one_minus_delta);
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, FixedU32};
type Fix = FixedU32<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);
Wrapping multiplication by an integer. Returns the product, wrapping on overflow.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<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);
Wrapping division by an integer. Returns the quotient.
Can never overflow for unsigned values.
Panics
Panics if the divisor is zero.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<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);
Wrapping shift left. Wraps rhs
if rhs
≥ 32,
then shifts and returns the number.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
assert_eq!((Fix::ONE / 2).wrapping_shl(3), Fix::from_num(4));
assert_eq!((Fix::ONE / 2).wrapping_shl(3 + 32), Fix::from_num(4));
Wrapping shift right. Wraps rhs
if rhs
≥ 32,
then shifts and returns the number.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
assert_eq!((Fix::from_num(4)).wrapping_shr(3), Fix::ONE / 2);
assert_eq!((Fix::from_num(4)).wrapping_shr(3 + 32), Fix::ONE / 2);
Wrapping distance. Returns the distance from self
to other
.
The distance is the absolute value of the difference.
Can never overflow for unsigned types.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
assert_eq!(Fix::ONE.wrapping_dist(Fix::from_num(5)), Fix::from_num(4));
assert_eq!(Fix::ZERO.wrapping_dist(Fix::MAX), Fix::MAX);
Inverse linear interpolation between start
and end
,
wrapping on overflow.
The computed value can have a fixed-point type like self
but with a different
number of fractional bits.
Returns
(self
− start
) / (end
− start
).
This is 0 when self
= start
, and 1 when self
= end
.
Panics
Panics when start
= end
.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
let two = Fix::from_num(2);
let four = Fix::from_num(4);
assert_eq!(Fix::from_num(3).wrapping_inv_lerp::<U4>(two, four), 0.5);
assert_eq!(
Fix::MAX.wrapping_inv_lerp::<U4>(Fix::ZERO, Fix::from_num(0.5)),
Fix::MAX.wrapping_mul_int(2)
);
Returns the smallest power of two that is ≥ self
,
wrapping to 0 if the next power of two is too large to represent.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
// 3/8 is 0.0110
let three_eights = Fix::from_bits(0b0110);
// 1/2 is 0.1000
let half = Fix::from_bits(0b1000);
assert_eq!(three_eights.wrapping_next_power_of_two(), half);
assert_eq!(Fix::MAX.wrapping_next_power_of_two(), 0);
Unwrapped negation. Returns the negated value, panicking on overflow.
Only zero can be negated without overflow.
Panics
Panics if the result does not fit.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
assert_eq!(Fix::ZERO.unwrapped_neg(), Fix::ZERO);
The following panics because of overflow.
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
let _overflow = Fix::from_num(5).unwrapped_neg();
Unwrapped addition. Returns the sum, panicking on overflow.
Panics
Panics if the result does not fit.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<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, FixedU32};
type Fix = FixedU32<U4>;
let _overflow = Fix::MAX.unwrapped_add(Fix::DELTA);
Unwrapped subtraction. Returns the difference, panicking on overflow.
Panics
Panics if the result does not fit.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
assert_eq!(Fix::from_num(5).unwrapped_sub(Fix::from_num(3)), Fix::from_num(2));
The following panics because of overflow.
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
let _overflow = Fix::MIN.unwrapped_sub(Fix::DELTA);
Unwrapped remainder. Returns the remainder, panicking if the divisor is zero.
Panics
Panics if the divisor is zero.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<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, FixedU32};
type Fix = FixedU32<U4>;
let _divisor_is_zero = Fix::from_num(1.5).unwrapped_rem(Fix::ZERO);
Unwrapped multiply and add.
Returns self
× mul
+ add
, panicking on 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, FixedU32};
type Fix = FixedU32<U4>;
assert_eq!(
Fix::from_num(4).unwrapped_mul_add(Fix::from_num(0.5), Fix::from_num(3)),
Fix::from_num(5)
);
The following panics because of overflow.
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
let _overflow = Fix::MAX.unwrapped_mul_add(Fix::ONE, Fix::DELTA);
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, FixedU32};
type Fix = FixedU32<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, FixedU32};
type Fix = FixedU32<U4>;
let _overflow = Fix::MAX.unwrapped_mul_int(4);
Unwrapped division by an integer. Returns the quotient.
Can never overflow for unsigned values.
Panics
Panics if the divisor is zero.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<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, FixedU32};
type Fix = FixedU32<U4>;
let _divisor_is_zero = Fix::from_num(3).unwrapped_div_int(0);
Unwrapped remainder for Euclidean division. Returns the remainder, panicking if the divisor is zero.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<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, FixedU32};
type Fix = FixedU32<U4>;
let _divisor_is_zero = Fix::from_num(3).unwrapped_rem_euclid(Fix::ZERO);
Unwrapped shift left. Panics if rhs
≥ 32.
Panics
Panics if rhs
≥ 32.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
assert_eq!((Fix::ONE / 2).unwrapped_shl(3), Fix::from_num(4));
The following panics because of overflow.
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
let _overflow = Fix::ONE.unwrapped_shl(32);
Unwrapped shift right. Panics if rhs
≥ 32.
Panics
Panics if rhs
≥ 32.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
assert_eq!((Fix::from_num(4)).unwrapped_shr(3), Fix::ONE / 2);
The following panics because of overflow.
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
let _overflow = Fix::ONE.unwrapped_shr(32);
Unwrapped distance. Returns the distance from self
to other
.
The distance is the absolute value of the difference.
Can never overflow for unsigned types.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
assert_eq!(Fix::ONE.unwrapped_dist(Fix::from_num(5)), Fix::from_num(4));
assert_eq!(Fix::ZERO.unwrapped_dist(Fix::MAX), Fix::MAX);
Inverse linear interpolation between start
and end
,
panicking on overflow.
The computed value can have a fixed-point type like self
but with a different
number of fractional bits.
Returns
(self
− start
) / (end
− start
).
This is 0 when self
= start
, and 1 when self
= end
.
Panics
Panics when start
= end
or when the results overflows.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
let two = Fix::from_num(2);
let four = Fix::from_num(4);
assert_eq!(Fix::from_num(3).unwrapped_inv_lerp::<U4>(two, four), 0.5);
The following panics because start
= end
.
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
let two = Fix::from_num(2);
let _zero_range = two.unwrapped_inv_lerp::<U4>(two, two);
The following panics because of overflow.
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
let _overflow = Fix::MAX.unwrapped_inv_lerp::<U4>(Fix::ZERO, Fix::from_num(0.5));
Returns the smallest power of two that is ≥ self
,
panicking if the next power of two is too large to represent.
Panics
Panics if the result does not fit.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
// 3/8 is 0.0110
let three_eights = Fix::from_bits(0b0110);
// 1/2 is 0.1000
let half = Fix::from_bits(0b1000);
assert_eq!(three_eights.unwrapped_next_power_of_two(), half);
The following panics because of overflow.
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
let _overflow = Fix::MAX.unwrapped_next_power_of_two();
Overflowing negation.
Returns a tuple of the negated value and a bool
indicating whether
an overflow has occurred. On overflow, the wrapped value is returned.
Only zero can be negated without overflow.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
assert_eq!(Fix::ZERO.overflowing_neg(), (Fix::ZERO, false));
assert_eq!(Fix::from_num(5).overflowing_neg(), Fix::overflowing_from_num(-5));
let neg_five_bits = !Fix::from_num(5).to_bits() + 1;
assert_eq!(Fix::from_num(5).overflowing_neg(), (Fix::from_bits(neg_five_bits), true));
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, FixedU32};
type Fix = FixedU32<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), (one_minus_delta, true));
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, FixedU32};
type Fix = FixedU32<U4>;
let one_minus_delta = Fix::ONE - Fix::DELTA;
assert_eq!(Fix::from_num(5).overflowing_sub(Fix::from_num(3)), (Fix::from_num(2), false));
assert_eq!(Fix::ZERO.overflowing_sub(Fix::ONE), (Fix::MAX - one_minus_delta, true));
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.
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, FixedU32};
type Fix = FixedU32<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)
);
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, FixedU32};
type Fix = FixedU32<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));
Overflowing division by an integer.
Returns a tuple of the quotient and false
, as the division can never overflow for unsigned values.
Panics
Panics if the divisor is zero.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<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));
Overflowing shift left.
Returns a tuple of the shifted value and a bool
indicating whether
an overflow has occurred. Overflow occurs when rhs
≥ 32.
On overflow rhs
is wrapped before the shift operation.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
assert_eq!((Fix::ONE / 2).overflowing_shl(3), (Fix::from_num(4), false));
assert_eq!((Fix::ONE / 2).overflowing_shl(3 + 32), (Fix::from_num(4), true));
Overflowing shift right.
Returns a tuple of the shifted value and a bool
indicating whether
an overflow has occurred. Overflow occurs when rhs
≥ 32.
On overflow rhs
is wrapped before the shift operation.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
assert_eq!((Fix::from_num(4)).overflowing_shr(3), (Fix::ONE / 2, false));
assert_eq!((Fix::from_num(4)).overflowing_shr(3 + 32), (Fix::ONE / 2, true));
Overflowing distance.
Returns a tuple of the distance from self
to other
and false
, as overflow can never happen for unsigned types.
The distance is the absolute value of the difference.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
assert_eq!(
Fix::ONE.overflowing_dist(Fix::from_num(5)),
(Fix::from_num(4), false)
);
assert_eq!(
Fix::ZERO.overflowing_dist(Fix::MAX),
(Fix::MAX, false)
);
Overflowing inverse linear interpolation between start
and end
.
Returns a tuple of the result and a bool
indicationg whether an overflow
has occurred. On overflow, the wrapped value is returned.
The computed value can have a fixed-point type like self
but with a different
number of fractional bits.
Computes
(self
− start
) / (end
− start
).
This is 0 when self
= start
, and 1 when self
= end
.
Panics
Panics when start
= end
.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
let two = Fix::from_num(2);
let four = Fix::from_num(4);
assert_eq!(
Fix::from_num(3).overflowing_inv_lerp::<U4>(two, four),
(Fix::from_num(0.5), false)
);
assert_eq!(
Fix::MAX.overflowing_inv_lerp::<U4>(Fix::ZERO, Fix::from_num(0.5)),
(Fix::MAX.wrapping_mul_int(2), true)
);
The implementation of items in this block depends on the
number of fractional bits Frac
.
The number of integer bits.
Examples
use fixed::{types::extra::U6, FixedU32};
type Fix = FixedU32<U6>;
assert_eq!(Fix::INT_NBITS, 32 - 6);
The number of fractional bits.
Examples
use fixed::{types::extra::U6, FixedU32};
type Fix = FixedU32<U6>;
assert_eq!(Fix::FRAC_NBITS, 6);
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, FixedU32};
type Fix = FixedU32<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)));
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, FixedU32};
type Fix = FixedU32<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>(), 2);
// 1.625 is 1.101 in binary
let one_point_625 = Fix::from_bits(0b1101 << (4 - 3));
assert_eq!(one_point_625.to_num::<f32>(), 1.625f32);
assert_eq!(one_point_625.to_num::<f64>(), 1.625f64);
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,
FixedU32,
};
type Fix = FixedU32<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 = FixedU32::<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 = u32::MAX;
assert!(Fix::checked_from_num(too_large).is_none());
let too_small = -1;
assert!(Fix::checked_from_num(too_small).is_none());
// 1.75 is 1.11 in binary
let expected = Fix::from_bits(0b111 << (4 - 2));
assert_eq!(Fix::checked_from_num(1.75f32), Some(expected));
assert_eq!(Fix::checked_from_num(1.75f64), Some(expected));
assert!(Fix::checked_from_num(2e38).is_none());
assert!(Fix::checked_from_num(std::f64::NAN).is_none());
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,
FixedU32,
};
type Fix = FixedU32<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 = FixedU32<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(2));
type AllInt = FixedU32<U0>;
assert!(AllInt::MAX.checked_to_num::<i32>().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));
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,
FixedU32,
};
type Fix = FixedU32<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 = FixedU32::<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 = -1;
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);
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,
FixedU32,
};
type Fix = FixedU32<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 = FixedU32<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 = FixedU32<U0>;
assert_eq!(AllInt::MAX.saturating_to_num::<i32>(), i32::MAX);
// 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);
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,
FixedU32,
};
type Fix = FixedU32<U4>;
// 1.75 is 1.11 in binary
let src = I16F16::from_bits(0b111 << (16 - 2));
assert_eq!(Fix::wrapping_from_num(src), Fix::from_bits(0b111 << (4 - 2)));
// integer 0b1101 << (32 - 7) will wrap to fixed-point 1010...
let too_large = FixedU32::<U0>::from_bits(0b1101 << (32 - 7));
let wrapped = Fix::from_bits(0b1010 << (32 - 4));
assert_eq!(Fix::wrapping_from_num(too_large), wrapped);
// integer 0b1101 << (32 - 7) will wrap to fixed-point 1010...
let large: u32 = 0b1101 << (32 - 7);
let wrapped = Fix::from_bits(0b1010 << (32 - 4));
assert_eq!(Fix::wrapping_from_num(large), wrapped);
// 1.75 is 1.11 in binary
let expected = Fix::from_bits(0b111 << (4 - 2));
assert_eq!(Fix::wrapping_from_num(1.75f32), expected);
// 1.75 << (32 - 4) wraps to binary 11000...
let large = 1.75 * 2f32.powi(32 - 4);
let wrapped = Fix::from_bits(0b1100 << (32 - 4));
assert_eq!(Fix::wrapping_from_num(large), wrapped);
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,
FixedU32,
};
type Fix = FixedU32<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 = FixedU32<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 = FixedU32<U0>;
assert_eq!(AllInt::MAX.wrapping_to_num::<i32>(), -1);
// 1.625 is 1.101 in binary
let one_point_625 = Fix::from_bits(0b1101 << (4 - 3));
assert_eq!(one_point_625.wrapping_to_num::<f32>(), 1.625f32);
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},
FixedU32,
};
type Fix = FixedU32<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},
FixedU32,
};
type Fix = FixedU32<U4>;
let too_large = FixedU32::<U0>::from_bits(0b1101 << (32 - 7));
let _overflow = Fix::unwrapped_from_num(too_large);
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},
FixedU32,
};
type Fix = FixedU32<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},
FixedU32,
};
type Fix = FixedU32<U4>;
type TooFewIntBits = FixedU32<U6>;
let _overflow = Fix::MAX.unwrapped_to_num::<TooFewIntBits>();
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,
FixedU32,
};
type Fix = FixedU32<U4>;
// 1.75 is 1.11 in binary
let src = I16F16::from_bits(0b111 << (16 - 2));
let expected = Fix::from_bits(0b111 << (4 - 2));
assert_eq!(Fix::overflowing_from_num(src), (expected, false));
// integer 0b1101 << (32 - 7) will wrap to fixed-point 1010...
let too_large = FixedU32::<U0>::from_bits(0b1101 << (32 - 7));
let wrapped = Fix::from_bits(0b1010 << (32 - 4));
assert_eq!(Fix::overflowing_from_num(too_large), (wrapped, true));
assert_eq!(Fix::overflowing_from_num(3), (Fix::from_bits(3 << 4), false));
// integer 0b1101 << (32 - 7) will wrap to fixed-point 1010...
let large: u32 = 0b1101 << (32 - 7);
let wrapped = Fix::from_bits(0b1010 << (32 - 4));
assert_eq!(Fix::overflowing_from_num(large), (wrapped, true));
// 1.75 is 1.11 in binary
let expected = Fix::from_bits(0b111 << (4 - 2));
assert_eq!(Fix::overflowing_from_num(1.75f32), (expected, false));
// 1.75 << (32 - 4) wraps to binary 11000...
let large = 1.75 * 2f32.powi(32 - 4);
let wrapped = Fix::from_bits(0b1100 << (32 - 4));
assert_eq!(Fix::overflowing_from_num(large), (wrapped, true));
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,
FixedU32,
};
type Fix = FixedU32<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 = FixedU32<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 = FixedU32::<U0>::MAX;
let wrapped = -1i32;
assert_eq!(does_not_fit.overflowing_to_num::<i32>(), (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));
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, FixedU32};
type Fix = FixedU32<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));
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, FixedU32};
type Fix = FixedU32<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));
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, FixedU32};
type Fix = FixedU32<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));
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::U8F8;
assert_eq!(U8F8::saturating_from_str("9999"), Ok(U8F8::MAX));
assert_eq!(U8F8::saturating_from_str("-1"), Ok(U8F8::ZERO));
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::U8F8;
assert_eq!(U8F8::saturating_from_str_binary("101100111000"), Ok(U8F8::MAX));
assert_eq!(U8F8::saturating_from_str_binary("-1"), Ok(U8F8::ZERO));
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::U8F8;
assert_eq!(U8F8::saturating_from_str_octal("7777"), Ok(U8F8::MAX));
assert_eq!(U8F8::saturating_from_str_octal("-1"), Ok(U8F8::ZERO));
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::U8F8;
assert_eq!(U8F8::saturating_from_str_hex("FFFF"), Ok(U8F8::MAX));
assert_eq!(U8F8::saturating_from_str_hex("-1"), Ok(U8F8::ZERO));
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::U8F8;
// 9999.5 = 15.5 + 256 × n
assert_eq!(U8F8::wrapping_from_str("9999.5"), Ok(U8F8::from_num(15.5)));
assert_eq!(U8F8::wrapping_from_str("-9999.5"), Ok(U8F8::from_num(240.5)));
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::U8F8;
let check = U8F8::from_bits(0b1110001 << (8 - 1));
assert_eq!(U8F8::wrapping_from_str_binary("101100111000.1"), Ok(check));
assert_eq!(U8F8::wrapping_from_str_binary("-101100111000.1"), Ok(check.wrapping_neg()));
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::U8F8;
let check = U8F8::from_bits(0o1654 << (8 - 3));
assert_eq!(U8F8::wrapping_from_str_octal("7165.4"), Ok(check));
assert_eq!(U8F8::wrapping_from_str_octal("-7165.4"), Ok(check.wrapping_neg()));
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::U8F8;
let check = U8F8::from_bits(0xFFE);
assert_eq!(U8F8::wrapping_from_str_hex("C0F.FE"), Ok(check));
assert_eq!(U8F8::wrapping_from_str_hex("-C0F.FE"), Ok(check.wrapping_neg()));
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::U8F8;
assert_eq!(U8F8::overflowing_from_str("99.5"), Ok((U8F8::from_num(99.5), false)));
// 9999.5 = 15.5 + 256 × n
assert_eq!(U8F8::overflowing_from_str("9999.5"), Ok((U8F8::from_num(15.5), true)));
pub fn overflowing_from_str_binary(
src: &str
) -> Result<(FixedU32<Frac>, bool), ParseFixedError>
pub fn overflowing_from_str_binary(
src: &str
) -> Result<(FixedU32<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::U8F8;
let check = U8F8::from_bits(0b1110001 << (8 - 1));
assert_eq!(U8F8::overflowing_from_str_binary("111000.1"), Ok((check, false)));
assert_eq!(U8F8::overflowing_from_str_binary("101100111000.1"), Ok((check, true)));
pub fn overflowing_from_str_octal(
src: &str
) -> Result<(FixedU32<Frac>, bool), ParseFixedError>
pub fn overflowing_from_str_octal(
src: &str
) -> Result<(FixedU32<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::U8F8;
let check = U8F8::from_bits(0o1654 << (8 - 3));
assert_eq!(U8F8::overflowing_from_str_octal("165.4"), Ok((check, false)));
assert_eq!(U8F8::overflowing_from_str_octal("7165.4"), Ok((check, true)));
pub fn overflowing_from_str_hex(
src: &str
) -> Result<(FixedU32<Frac>, bool), ParseFixedError>
pub fn overflowing_from_str_hex(
src: &str
) -> Result<(FixedU32<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::U8F8;
let check = U8F8::from_bits(0xFFE);
assert_eq!(U8F8::overflowing_from_str_hex("F.FE"), Ok((check, false)));
assert_eq!(U8F8::overflowing_from_str_hex("C0F.FE"), Ok((check, true)));
Returns the fractional part.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
// 0000.0100
let quarter = Fix::ONE / 4;
// 0010.0100
let two_and_quarter = quarter * 9;
assert_eq!(two_and_quarter.frac(), quarter);
Rounds to the next integer towards 0.
Note that for unsigned numbers, this is equivalent to floor
.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<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));
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, FixedU32};
type Fix = FixedU32<U4>;
assert_eq!(Fix::from_num(2.5).ceil(), Fix::from_num(3));
Rounds to the next integer towards −∞.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
assert_eq!(Fix::from_num(2.5).floor(), Fix::from_num(2));
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, FixedU32};
type Fix = FixedU32<U4>;
assert_eq!(Fix::from_num(2.5).round(), Fix::from_num(3));
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, FixedU32};
type Fix = FixedU32<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));
Checked round. Rounds to the nearest integer, with ties
rounded to even, returning None
on overflow.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<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());
Saturating ceil. Rounds to the next integer towards +∞, saturating on overflow.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
assert_eq!(Fix::from_num(2.5).saturating_ceil(), Fix::from_num(3));
assert_eq!(Fix::MAX.saturating_ceil(), Fix::MAX);
Saturating floor. Rounds to the next integer towards −∞. Cannot overflow for unsigned values.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
assert_eq!(Fix::from_num(2.5).saturating_floor(), Fix::from_num(2));
Saturating round. Rounds to the nearest integer, with ties rounded away from zero, and saturating on overflow.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
assert_eq!(Fix::from_num(2.5).saturating_round(), Fix::from_num(3));
assert_eq!(Fix::MAX.saturating_round(), Fix::MAX);
Saturating round. Rounds to the nearest integer, with ties rounded to even, and saturating on overflow.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<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);
Wrapping ceil. Rounds to the next integer towards +∞, wrapping on overflow.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
assert_eq!(Fix::from_num(2.5).wrapping_ceil(), Fix::from_num(3));
assert_eq!(Fix::MAX.wrapping_ceil(), Fix::MIN);
Wrapping floor. Rounds to the next integer towards −∞. Cannot overflow for unsigned values.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
assert_eq!(Fix::from_num(2.5).wrapping_floor(), Fix::from_num(2));
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, FixedU32};
type Fix = FixedU32<U4>;
assert_eq!(Fix::from_num(2.5).wrapping_round(), Fix::from_num(3));
assert_eq!(Fix::MAX.wrapping_round(), Fix::MIN);
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, FixedU32};
type Fix = FixedU32<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);
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, FixedU32};
type Fix = FixedU32<U4>;
assert_eq!(Fix::from_num(2.5).unwrapped_ceil(), Fix::from_num(3));
The following panics because of overflow.
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
let _overflow = Fix::MAX.unwrapped_ceil();
Unwrapped floor. Rounds to the next integer towards −∞. Cannot overflow for unsigned values.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
assert_eq!(Fix::from_num(2.5).unwrapped_floor(), Fix::from_num(2));
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, FixedU32};
type Fix = FixedU32<U4>;
assert_eq!(Fix::from_num(2.5).unwrapped_round(), Fix::from_num(3));
The following panics because of overflow.
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
let _overflow = Fix::MAX.unwrapped_round();
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, FixedU32};
type Fix = FixedU32<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, FixedU32};
type Fix = FixedU32<U4>;
let _overflow = Fix::MAX.unwrapped_round_ties_to_even();
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, FixedU32};
type Fix = FixedU32<U4>;
assert_eq!(Fix::from_num(2.5).overflowing_ceil(), (Fix::from_num(3), false));
assert_eq!(Fix::MAX.overflowing_ceil(), (Fix::MIN, true));
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, FixedU32};
type Fix = FixedU32<U4>;
assert_eq!(Fix::from_num(2.5).overflowing_round(), (Fix::from_num(3), false));
assert_eq!(Fix::MAX.overflowing_round(), (Fix::MIN, true));
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, FixedU32};
type Fix = FixedU32<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));
Integer base-2 logarithm, rounded down.
Panics
Panics if the fixed-point number is zero.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<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);
Integer base-10 logarithm, rounded down.
Panics
Panics if the fixed-point number is zero.
Examples
use fixed::{
types::extra::{U2, U6},
FixedU32,
};
assert_eq!(FixedU32::<U2>::from_num(10).int_log10(), 1);
assert_eq!(FixedU32::<U2>::from_num(9.75).int_log10(), 0);
assert_eq!(FixedU32::<U6>::from_num(0.109375).int_log10(), -1);
assert_eq!(FixedU32::<U6>::from_num(0.09375).int_log10(), -2);
Checked integer base-2 logarithm, rounded down.
Returns the logarithm or None
if the fixed-point number is
zero.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<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));
Checked integer base-10 logarithm, rounded down.
Returns the logarithm or None
if the fixed-point number is
zero.
Examples
use fixed::{
types::extra::{U2, U6},
FixedU32,
};
assert_eq!(FixedU32::<U2>::ZERO.checked_int_log10(), None);
assert_eq!(FixedU32::<U2>::from_num(10).checked_int_log10(), Some(1));
assert_eq!(FixedU32::<U2>::from_num(9.75).checked_int_log10(), Some(0));
assert_eq!(FixedU32::<U6>::from_num(0.109375).checked_int_log10(), Some(-1));
assert_eq!(FixedU32::<U6>::from_num(0.09375).checked_int_log10(), Some(-2));
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, FixedU32};
type Fix = FixedU32<U4>;
assert_eq!(Fix::from_num(2).recip(), Fix::from_num(0.5));
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, FixedU32};
type Fix = FixedU32<U4>;
assert_eq!(Fix::from_num(7.5).div_euclid(Fix::from_num(2)), Fix::from_num(3));
Multiply and accumulate. Adds (a
× b
) to self
.
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, FixedU32};
type Fix = FixedU32<U4>;
let mut acc = Fix::from_num(3);
acc.mul_acc(Fix::from_num(4), Fix::from_num(0.5));
assert_eq!(acc, 5);
Linear interpolation between start
and end
.
Returns
start
+ self
× (end
− start
). This
is start
when self
= 0, end
when self
= 1, and
linear interpolation for all other values of self
. Linear extrapolation is
performed if self
is not in the range 0 ≤ x ≤ 1.
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_lerp
instead.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
let start = Fix::from_num(2);
let end = Fix::from_num(3.5);
assert_eq!(Fix::from_num(0.0).lerp(start, end), 2);
assert_eq!(Fix::from_num(0.5).lerp(start, end), 2.75);
assert_eq!(Fix::from_num(1.0).lerp(start, end), 3.5);
assert_eq!(Fix::from_num(2.0).lerp(start, end), 5);
Checked Euclidean division. Returns the quotient, or
None
if the divisor is zero or on overflow.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<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);
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.
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, FixedU32};
type Fix = FixedU32<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);
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, FixedU32};
type Fix = FixedU32<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);
Checked Euclidean division by an integer. Returns the
quotient, or None
if the divisor is zero.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<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);
Checked remainder for Euclidean division by an integer.
Returns the remainder, or None
if the divisor is zero.
Examples
use fixed::{types::extra::U28, FixedU32};
type Fix = FixedU32<U28>;
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);
Checked linear interpolation between start
and end
. Returns
None
on overflow.
The interpolted value is
start
+ self
× (end
− start
). This
is start
when self
= 0, end
when self
= 1, and
linear interpolation for all other values of self
. Linear extrapolation is
performed if self
is not in the range 0 ≤ x ≤ 1.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
assert_eq!(Fix::from_num(0.5).checked_lerp(Fix::ZERO, Fix::MAX), Some(Fix::MAX / 2));
assert_eq!(Fix::from_num(1.5).checked_lerp(Fix::ZERO, Fix::MAX), None);
Saturating multiplication. Returns the product, saturating on overflow.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<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);
Saturating division. Returns the quotient, saturating on overflow.
Panics
Panics if the divisor is zero.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<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);
Saturating Euclidean division. Returns the quotient, saturating on overflow.
Panics
Panics if the divisor is zero.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<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);
Saturating multiply and accumulate. Adds (a
× b
) to self
,
saturating 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, FixedU32};
type Fix = FixedU32<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);
Saturating remainder for Euclidean division by an integer. Returns the remainder.
Can never overflow for unsigned values.
Panics
Panics if the divisor is zero.
Examples
use fixed::{types::extra::U28, FixedU32};
type Fix = FixedU32<U28>;
assert_eq!(Fix::from_num(7.5).saturating_rem_euclid_int(2), Fix::from_num(1.5));
pub fn saturating_lerp<RangeFrac>(
self,
start: FixedU32<RangeFrac>,
end: FixedU32<RangeFrac>
) -> FixedU32<RangeFrac>
pub fn saturating_lerp<RangeFrac>(
self,
start: FixedU32<RangeFrac>,
end: FixedU32<RangeFrac>
) -> FixedU32<RangeFrac>
Linear interpolation between start
and end
, saturating on
overflow.
The interpolated value is
start
+ self
× (end
− start
). This
is start
when self
= 0, end
when self
= 1, and
linear interpolation for all other values of self
. Linear extrapolation is
performed if self
is not in the range 0 ≤ x ≤ 1.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
assert_eq!(Fix::from_num(0.5).saturating_lerp(Fix::ZERO, Fix::MAX), Fix::MAX / 2);
assert_eq!(Fix::from_num(1.5).saturating_lerp(Fix::ZERO, Fix::MAX), Fix::MAX);
assert_eq!(Fix::from_num(3.0).saturating_lerp(Fix::MAX, Fix::ZERO), Fix::ZERO);
Wrapping multiplication. Returns the product, wrapping on overflow.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<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);
Wrapping division. Returns the quotient, wrapping on overflow.
Panics
Panics if the divisor is zero.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<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);
Wrapping Euclidean division. Returns the quotient, wrapping on overflow.
Panics
Panics if the divisor is zero.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<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);
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, FixedU32};
type Fix = FixedU32<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));
Wrapping remainder for Euclidean division by an integer. Returns the remainder.
Can never overflow for unsigned values.
Panics
Panics if the divisor is zero.
Examples
use fixed::{types::extra::U28, FixedU32};
type Fix = FixedU32<U28>;
assert_eq!(Fix::from_num(7.5).wrapping_rem_euclid_int(2), Fix::from_num(1.5));
pub fn wrapping_lerp<RangeFrac>(
self,
start: FixedU32<RangeFrac>,
end: FixedU32<RangeFrac>
) -> FixedU32<RangeFrac>
pub fn wrapping_lerp<RangeFrac>(
self,
start: FixedU32<RangeFrac>,
end: FixedU32<RangeFrac>
) -> FixedU32<RangeFrac>
Linear interpolation between start
and end
, wrapping on
overflow.
The interpolated value is
start
+ self
× (end
− start
). This
is start
when self
= 0, end
when self
= 1, and
linear interpolation for all other values of self
. Linear extrapolation is
performed if self
is not in the range 0 ≤ x ≤ 1.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
assert_eq!(Fix::from_num(0.5).wrapping_lerp(Fix::ZERO, Fix::MAX), Fix::MAX / 2);
assert_eq!(
Fix::from_num(1.5).wrapping_lerp(Fix::ZERO, Fix::MAX),
Fix::MAX.wrapping_add(Fix::MAX / 2)
);
Unwrapped multiplication. Returns the product, panicking on overflow.
Panics
Panics if the result does not fit.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<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, FixedU32};
type Fix = FixedU32<U4>;
let _overflow = Fix::MAX.unwrapped_mul(Fix::from_num(4));
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, FixedU32};
type Fix = FixedU32<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, FixedU32};
type Fix = FixedU32<U4>;
let quarter = Fix::ONE / 4;
let _overflow = Fix::MAX.unwrapped_div(quarter);
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, FixedU32};
type Fix = FixedU32<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, FixedU32};
type Fix = FixedU32<U4>;
let _overflow = Fix::MAX.unwrapped_div_euclid(Fix::from_num(0.25));
Unwrapped multiply and accumulate. Adds (a
× b
) to self
,
panicking on 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, FixedU32};
type Fix = FixedU32<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);
The following panics because of overflow.
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
let mut acc = Fix::DELTA;
acc.unwrapped_mul_acc(Fix::MAX, Fix::ONE);
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, FixedU32};
type Fix = FixedU32<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, FixedU32};
type Fix = FixedU32<U4>;
let _divisor_is_zero = Fix::from_num(3.75).unwrapped_rem_int(0);
Unwrapped remainder for Euclidean division by an integer. Returns the remainder.
Can never overflow for unsigned values.
Panics
Panics if the divisor is zero.
Examples
use fixed::{types::extra::U28, FixedU32};
type Fix = FixedU32<U28>;
assert_eq!(Fix::from_num(7.5).unwrapped_rem_euclid_int(2), Fix::from_num(1.5));
pub fn unwrapped_lerp<RangeFrac>(
self,
start: FixedU32<RangeFrac>,
end: FixedU32<RangeFrac>
) -> FixedU32<RangeFrac>
pub fn unwrapped_lerp<RangeFrac>(
self,
start: FixedU32<RangeFrac>,
end: FixedU32<RangeFrac>
) -> FixedU32<RangeFrac>
Linear interpolation between start
and end
, panicking on
overflow.
The interpolated value is
start
+ self
× (end
− start
). This
is start
when self
= 0, end
when self
= 1, and
linear interpolation for all other values of self
. Linear extrapolation is
performed if self
is not in the range 0 ≤ x ≤ 1.
Panics
Panics if the result overflows.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
assert_eq!(Fix::from_num(0.5).unwrapped_lerp(Fix::ZERO, Fix::MAX), Fix::MAX / 2);
The following panics because of overflow.
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
let _overflow = Fix::from_num(1.5).unwrapped_lerp(Fix::ZERO, Fix::MAX);
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, FixedU32};
type Fix = FixedU32<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));
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, FixedU32};
type Fix = FixedU32<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));
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, U31},
FixedU32,
};
type Fix = FixedU32<U4>;
// only one integer bit
type Small = FixedU32<U31>;
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));
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, FixedU32};
type Fix = FixedU32<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));
Overflowing Euclidean division by an integer.
Returns a tuple of the quotient and false
, as the division can never overflow for unsigned values.
Panics
Panics if the divisor is zero.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
assert_eq!(Fix::from_num(7.5).overflowing_div_euclid_int(2), (Fix::from_num(3), false));
Overflowing multiply and accumulate. Adds (a
× b
) to self
,
wrapping and returning true
if overflow occurs.
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, FixedU32};
type Fix = FixedU32<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));
Remainder for Euclidean division by an integer.
Returns a tuple of the remainder and false
, as this can never overflow for unsigned values.
Panics
Panics if the divisor is zero.
Examples
use fixed::{types::extra::U28, FixedU32};
type Fix = FixedU32<U28>;
assert_eq!(Fix::from_num(7.5).overflowing_rem_euclid_int(2), (Fix::from_num(1.5), false));
Overflowing linear interpolation between start
and end
.
Returns a tuple of the result and a bool
indicationg whether an overflow
has occurred. On overflow, the wrapped value is returned.
The interpolated value is
start
+ self
× (end
− start
). This
is start
when self
= 0, end
when self
= 1, and
linear interpolation for all other values of self
. Linear extrapolation is
performed if self
is not in the range 0 ≤ x ≤ 1.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
assert_eq!(
Fix::from_num(0.5).overflowing_lerp(Fix::ZERO, Fix::MAX),
(Fix::MAX / 2, false)
);
assert_eq!(
Fix::from_num(1.5).overflowing_lerp(Fix::ZERO, Fix::MAX),
(Fix::MAX.wrapping_add(Fix::MAX / 2), true)
);
This block contains constants in the range 0 < x < 0.5.
Examples
use fixed::{consts, types::extra::U32, FixedU32};
type Fix = FixedU32<U32>;
assert_eq!(Fix::LOG10_2, Fix::from_num(consts::LOG10_2));
1/τ = 0.159154…
2/τ = 0.318309…
This block contains constants in the range 0.5 ≤ x < 1.
Examples
use fixed::{consts, types::extra::U32, FixedU32};
type Fix = FixedU32<U32>;
assert_eq!(Fix::LN_2, Fix::from_num(consts::LN_2));
assert!(0.5 <= Fix::LN_2 && Fix::LN_2 < 1);
τ/8 = 0.785398…
τ/12 = 0.523598…
4/τ = 0.636619…
1/√π = 0.564189…
1/√2 = 0.707106…
1/√3 = 0.577350…
The golden ratio conjugate, Φ = 1/φ = 0.618033…
This block contains constants in the range 1 ≤ x < 2.
These constants are not representable in unsigned fixed-point numbers with less than 1 integer bit.
Examples
use fixed::{consts, types::extra::U31, FixedU32};
type Fix = FixedU32<U31>;
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 32 fractional bits and 0 integer bits is < 1.
use fixed::{consts, types::extra::U32, FixedU32};
type Fix = FixedU32<U32>;
let _ = Fix::LOG2_E;
One.
Examples
use fixed::{types::extra::U4, FixedU32};
type Fix = FixedU32<U4>;
assert_eq!(Fix::ONE, Fix::from_num(1));
τ/4 = 1.57079…
τ/6 = 1.04719…
2/√π = 1.12837…
This block contains constants in the range 2 ≤ x < 4.
These constants are not representable in unsigned fixed-point numbers with less than 2 integer bits.
Examples
use fixed::{consts, types::extra::U30, FixedU32};
type Fix = FixedU32<U30>;
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 31 fractional bits and 1 integer bit is < 2.
use fixed::{consts, types::extra::U31, FixedU32};
type Fix = FixedU32<U31>;
let _ = Fix::E;
τ/2 = 3.14159…
τ/3 = 2.09439…
This block contains constants in the range 4 ≤ x < 8.
These constants are not representable in unsigned fixed-point numbers with less than 3 integer bits.
Examples
use fixed::{consts, types::extra::U29, FixedU32};
type Fix = FixedU32<U29>;
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 30 fractional bits and 2 integer bits is < 4.
use fixed::{consts, types::extra::U30, FixedU32};
type Fix = FixedU32<U30>;
let _ = Fix::TAU;
Trait Implementations
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Adds two numbers, checking for overflow. If overflow happens, None
is
returned. Read more
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Divides two numbers, checking for underflow, overflow and division by
zero. If any of that happens, None
is returned. Read more
Multiplies two numbers, checking for underflow or overflow. If underflow
or overflow happens, None
is returned. Read more
Negates a number, returning None
for results that can’t be represented, like signed MIN
values that can’t be positive, or non-zero unsigned values that can’t be negative. Read more
Finds the remainder of dividing two numbers, checking for underflow, overflow and division
by zero. If any of that happens, None
is returned. Read more
Checked shift left. Computes self << rhs
, returning None
if rhs
is larger than or equal to the number of bits in self
. Read more
Checked shift right. Computes self >> rhs
, returning None
if rhs
is larger than or equal to the number of bits in self
. Read more
Subtracts two numbers, checking for underflow. If underflow happens,
None
is returned. Read more
Deserialize this value from the given Serde deserializer. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
type NonZeroBits = NonZeroU32
type NonZeroBits = NonZeroU32
type Frac = Frac
type Frac = Frac
The number of fractional bits as a compile-time Unsigned
as provided
by the typenum crate. Read more
An unsigned fixed-point number type with the same number of integer and
fractional bits as Self
. Read more
An unsigned fixed-point number type with the same number of integer and
fractional bits as Self
. Read more
The difference between any two successive representable numbers, Δ. Read more
The number of fractional bits. Read more
Creates a fixed-point number that has a bitwise representation identical to the given integer. Read more
Creates an integer that has a bitwise representation identical to the given fixed-point number. Read more
Converts a fixed-point number from big endian to the target’s endianness. Read more
Converts a fixed-point number from little endian to the target’s endianness. Read more
Converts this fixed-point number to big endian from the target’s endianness. Read more
Converts this fixed-point number to little endian from the target’s endianness. Read more
Reverses the byte order of the fixed-point number. Read more
Creates a fixed-point number from its representation as a byte array in big endian. Read more
Creates a fixed-point number from its representation as a byte array in little endian. Read more
Creates a fixed-point number from its representation as a byte array in native endian. Read more
Returns the memory representation of this fixed-point number as a byte array in big-endian byte order. Read more
Returns the memory representation of this fixed-point number as a byte array in little-endian byte order. Read more
Returns the memory representation of this fixed-point number as a byte array in native byte order. Read more
Creates a fixed-point number from another number. Read more
Converts a fixed-point number to another number. Read more
Creates a fixed-point number from another number, saturating the value if it does not fit. Read more
Converts a fixed-point number to another number, saturating the value if it does not fit. Read more
Creates a fixed-point number from another number, wrapping the value on overflow. Read more
Converts a fixed-point number to another number, wrapping the value on overflow. Read more
Creates a fixed-point number from another number, panicking on overflow. Read more
Converts a fixed-point number to another number, panicking on overflow. Read more
Creates a fixed-point number from another number. Read more
Converts a fixed-point number to another number. Read more
Parses a string slice containing binary digits to return a fixed-point number. Read more
Parses a string slice containing octal digits to return a fixed-point number. Read more
Parses a string slice containing hexadecimal digits to return a fixed-point number. Read more
Parses a string slice containing decimal digits to return a fixed-point number, saturating on overflow. Read more
Parses a string slice containing binary digits to return a fixed-point number, saturating on overflow. Read more
Parses a string slice containing octal digits to return a fixed-point number, saturating on overflow. Read more
Parses a string slice containing hexadecimal digits to return a fixed-point number, saturating on overflow. Read more
Parses a string slice containing decimal digits to return a fixed-point number, wrapping on overflow. Read more
Parses a string slice containing binary digits to return a fixed-point number, wrapping on overflow. Read more
Parses a string slice containing octal digits to return a fixed-point number, wrapping on overflow. Read more
Parses a string slice containing hexadecimal digits to return a fixed-point number, wrapping on overflow. Read more
Parses a string slice containing decimal digits to return a fixed-point number. Read more
Parses a string slice containing binary digits to return a fixed-point number. Read more
Parses a string slice containing octal digits to return a fixed-point number. Read more
Parses a string slice containing hexadecimal digits to return a fixed-point number. Read more
Rounds to the next integer towards 0. Read more
Rounds to the nearest integer, with ties rounded away from zero. Read more
Rounds to the nearest integer, with ties rounded to even. Read more
Saturating ceil. Rounds to the next integer towards +∞, saturating on overflow. Read more
Saturating floor. Rounds to the next integer towards −∞, saturating on overflow. Read more
Saturating round. Rounds to the nearest integer, with ties rounded away from zero, and saturating on overflow. Read more
Saturating round. Rounds to the nearest integer, with ties rounded to_even, and saturating on overflow. Read more
Wrapping ceil. Rounds to the next integer towards +∞, wrapping on overflow. Read more
Wrapping floor. Rounds to the next integer towards −∞, wrapping on overflow. Read more
Wrapping round. Rounds to the next integer to the nearest, with ties rounded away from zero, and wrapping on overflow. Read more
Wrapping round. Rounds to the next integer to the nearest, with ties rounded to even, and wrapping on overflow. Read more
Unwrapped ceil. Rounds to the next integer towards +∞, panicking on overflow. Read more
Unwrapped floor. Rounds to the next integer towards −∞, panicking on overflow. Read more
Unwrapped round. Rounds to the next integer to the nearest, with ties rounded away from zero, and panicking on overflow. Read more
Unwrapped round. Rounds to the next integer to the nearest, with ties rounded to even, and panicking on overflow. Read more
Overflowing ceil. Rounds to the next integer towards +∞. Read more
Overflowing floor. Rounds to the next integer towards −∞. Read more
Overflowing round. Rounds to the next integer to the nearest, with ties rounded away from zero. Read more
Overflowing round. Rounds to the next integer to the nearest, with ties rounded to even. Read more
Returns the number of ones in the binary representation. Read more
Returns the number of zeros in the binary representation. Read more
Returns the number of leading ones in the binary representation. Read more
Returns the number of leading zeros in the binary representation. Read more
Returns the number of trailing ones in the binary representation. Read more
Returns the number of trailing zeros in the binary representation. Read more
Reverses the order of the bits of the fixed-point number. Read more
Shifts to the left by n
bits, wrapping the truncated bits to the right end. Read more
Shifts to the right by n
bits, wrapping the truncated bits to the left end. Read more
Multiply and add. Returns self
× mul
+ add
. Read more
Multiply and accumulate. Adds (a
× b
) to self
. Read more
Euclidean division by an integer. Read more
Remainder for Euclidean division. Read more
Euclidean division by an integer. Read more
Remainder for Euclidean division by an integer. Read more
Linear interpolation between start
and end
. Read more
Inverse linear interpolation between start
and end
. Read more
Saturated negation. Returns the negated value, saturating on overflow. Read more
Saturating addition. Returns the sum, saturating on overflow. Read more
Saturating subtraction. Returns the difference, saturating on overflow. Read more
Saturating multiplication. Returns the product, saturating on overflow. Read more
Saturating division. Returns the quotient, saturating on overflow. Read more
Saturating reciprocal. Read more
Saturating multiply and add. Returns self
× mul
+ add
, saturating on overflow. Read more
Saturating multiply and add. Adds (a
× b
) to self
, saturating on overflow. Read more
Saturating Euclidean division. Returns the quotient, saturating on overflow. Read more
Saturating multiplication by an integer. Returns the product, saturating on overflow. Read more
Saturating Euclidean division by an integer. Returns the quotient, saturating on overflow. Read more
Saturating remainder for Euclidean division by an integer. Returns the remainder, saturating on overflow. Read more
Saturating distance. Returns the distance from self
to other
,
saturating on overflow. Read more
Linear interpolation between start
and end
, saturating on overflow. Read more
Inverse linear interpolation between start
and end
, saturating on overflow. Read more
Wrapping negation. Returns the negated value, wrapping on overflow. Read more
Wrapping addition. Returns the sum, wrapping on overflow. Read more
Wrapping subtraction. Returns the difference, wrapping on overflow. Read more
Wrapping multiplication. Returns the product, wrapping on overflow. Read more
Wrapping division. Returns the quotient, wrapping on overflow. Read more
Wrapping reciprocal. Read more
Wrapping multiply and add. Returns self
× mul
+ add
, wrapping on overflow. Read more
Wrapping multiply and accumulate. Adds (a
× b
) to self
, wrapping on overflow. Read more
Wrapping Euclidean division. Returns the quotient, wrapping on overflow. Read more
Wrapping multiplication by an integer. Returns the product, wrapping on overflow. Read more
Wrapping division by an integer. Returns the quotient, wrapping on overflow. Read more
Wrapping Euclidean division by an integer. Returns the quotient, wrapping on overflow. Read more
Wrapping remainder for Euclidean division by an integer. Returns the remainder, wrapping on overflow. Read more
Wrapping shift left. Wraps rhs
if rhs
≥ the number of
bits, then shifts and returns the number. Read more
Wrapping shift right. Wraps rhs
if rhs
≥ the number of
bits, then shifts and returns the number. Read more
Wrapping distance. Returns the distance from self
to other
, wrapping
on overflow. Read more
Linear interpolation between start
and end
, wrapping on overflow. Read more
Inverse linear interpolation between start
and end
, wrapping on
overflow. Read more
Unwrapped negation. Returns the negated value, panicking on overflow. Read more
Unwrapped addition. Returns the sum, panicking on overflow. Read more
Unwrapped subtraction. Returns the difference, panicking on overflow. Read more
Unwrapped multiplication. Returns the product, panicking on overflow. Read more
Unwrapped division. Returns the quotient, panicking on overflow. Read more
Unwrapped remainder. Returns the quotient, panicking if the divisor is zero. Read more
Unwrapped reciprocal. Returns reciprocal, panicking on overflow. Read more
Unwrapped multiply and add. Returns self
× mul
+ add
, panicking on overflow. Read more
Unwrapped multiply and accumulate. Adds (a
× b
) to self
, panicking on overflow. Read more
Unwrapped Euclidean division. Returns the quotient, panicking on overflow. Read more
Unwrapped remainder for Euclidean division. Returns the remainder, panicking if the divisor is zero. Read more
Unwrapped multiplication by an integer. Returns the product, panicking on overflow. Read more
Unwrapped division by an integer. Returns the quotient, panicking on overflow. Read more
Unwrapped remainder for division by an integer. Returns the remainder, panicking if the divisor is zero. Read more
Unwrapped Euclidean division by an integer. Returns the quotient, panicking on overflow. Read more
Unwrapped remainder for Euclidean division by an integer. Returns the remainder, panicking on overflow. Read more
Unwrapped shift left. Panics if rhs
≥ the number of bits. Read more
Unwrapped shift right. Panics if rhs
≥ the number of bits. Read more
Unwrapped distance. Returns the distance from self
to other
,
panicking on overflow. Read more
Linear interpolation between start
and end
, panicking on overflow. Read more
Inverse linear interpolation between start
and end
, panicking on overflow. Read more
Overflowing multiply and add. Read more
Overflowing Euclidean division. Read more
Overflowing multiplication by an integer. Read more
Overflowing division by an integer. Read more
Overflowing Euclidean division by an integer. Read more
Overflowing remainder for Euclidean division by an integer. Read more
Overflowing linear interpolation between start
and end
. Read more
Overflowing inverse linear interpolation between start
and end
. Read more
Returns a reference to self
as FixedSigned
if the type is signed,
or None
if it is unsigned. Read more
Returns a reference to self
as FixedUnsigned
if the type is
unsigned, or None
if it is signed. Read more
Returns a mutable reference to self
as FixedSigned
if the type is
signed, or None
if it is unsigned. Read more
Returns a mutable reference to self
as FixedUnsigned
if the type
is unsigned, or None
if it is signed. Read more
Returns the number of bits required to represent the value. Read more
Returns the highest one in the binary representation, or zero
if self
is zero. Read more
Returns the smallest power of two that is ≥ self
. Read more
Returns the smallest power of two that is ≥ self
, wrapping
to 0 if the next power of two is too large to represent. Read more
Returns the smallest power of two that is ≥ self
, panicking
if the next power of two is too large to represent. Read more
Return 1.0 / sqrt(2.0)
.
Return 2.0 / sqrt(π)
.
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.
Converts a fixed-point number if it fits, otherwise returns None
.
Any extra fractional bits are discarded, which rounds towards −∞.
Converts a fixed-point number, saturating if it does not fit.
Any extra fractional bits are discarded, which rounds towards −∞.
Converts a fixed-point number, wrapping if it does not fit.
Any extra fractional bits are discarded, which rounds towards −∞.
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.
Converts an i64
to return an optional value of this type. If the
value cannot be represented by this type, then None
is returned. Read more
Converts an u64
to return an optional value of this type. If the
value cannot be represented by this type, then None
is returned. Read more
Converts an isize
to return an optional value of this type. If the
value cannot be represented by this type, then None
is returned. Read more
Converts an i8
to return an optional value of this type. If the
value cannot be represented by this type, then None
is returned. Read more
Converts an i16
to return an optional value of this type. If the
value cannot be represented by this type, then None
is returned. Read more
Converts an i32
to return an optional value of this type. If the
value cannot be represented by this type, then None
is returned. Read more
Converts an i128
to return an optional value of this type. If the
value cannot be represented by this type, then None
is returned. Read more
Converts a usize
to return an optional value of this type. If the
value cannot be represented by this type, then None
is returned. Read more
Converts an u8
to return an optional value of this type. If the
value cannot be represented by this type, then None
is returned. Read more
Converts an u16
to return an optional value of this type. If the
value cannot be represented by this type, then None
is returned. Read more
Converts an u32
to return an optional value of this type. If the
value cannot be represented by this type, then None
is returned. Read more
Converts an u128
to return an optional value of this type. If the
value cannot be represented by this type, then None
is returned. Read more
Converts a f32
to return an optional value of this type. If the
value cannot be represented by this type, then None
is returned. Read more
impl<FracSrc: LeEqU128, FracDst: LeEqU32> LosslessTryFrom<FixedI128<FracSrc>> for FixedU32<FracDst> where
FracSrc: IsLessOrEqual<FracDst, Output = True>,
impl<FracSrc: LeEqU128, FracDst: LeEqU32> LosslessTryFrom<FixedI128<FracSrc>> for FixedU32<FracDst> where
FracSrc: IsLessOrEqual<FracDst, Output = True>,
Converts a fixed-pint number.
This conversion may fail (fallible) but does not lose precision (lossless).
impl<FracSrc: LeEqU16, FracDst: LeEqU32> LosslessTryFrom<FixedI16<FracSrc>> for FixedU32<FracDst> where
FracSrc: IsLessOrEqual<FracDst, Output = True>,
impl<FracSrc: LeEqU16, FracDst: LeEqU32> LosslessTryFrom<FixedI16<FracSrc>> for FixedU32<FracDst> where
FracSrc: IsLessOrEqual<FracDst, Output = True>,
Converts a fixed-pint number.
This conversion may fail (fallible) but does not lose precision (lossless).
impl<FracSrc: LeEqU32, FracDst: LeEqU32> LosslessTryFrom<FixedI32<FracSrc>> for FixedU32<FracDst> where
FracSrc: IsLessOrEqual<FracDst, Output = True>,
impl<FracSrc: LeEqU32, FracDst: LeEqU32> LosslessTryFrom<FixedI32<FracSrc>> for FixedU32<FracDst> where
FracSrc: IsLessOrEqual<FracDst, Output = True>,
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>,
impl<FracSrc: LeEqU64, FracDst: LeEqU32> LosslessTryFrom<FixedI64<FracSrc>> for FixedU32<FracDst> where
FracSrc: IsLessOrEqual<FracDst, Output = True>,
Converts a fixed-pint number.
This conversion may fail (fallible) but does not lose precision (lossless).
impl<FracSrc: LeEqU8, FracDst: LeEqU32> LosslessTryFrom<FixedI8<FracSrc>> for FixedU32<FracDst> where
FracSrc: IsLessOrEqual<FracDst, Output = True>,
impl<FracSrc: LeEqU8, FracDst: LeEqU32> LosslessTryFrom<FixedI8<FracSrc>> for FixedU32<FracDst> where
FracSrc: IsLessOrEqual<FracDst, Output = True>,
Converts a fixed-pint number.
This conversion may fail (fallible) but does not lose precision (lossless).
impl<FracSrc: LeEqU128, FracDst: LeEqU32> LosslessTryFrom<FixedU128<FracSrc>> for FixedU32<FracDst> where
FracSrc: IsLessOrEqual<FracDst, Output = True>,
impl<FracSrc: LeEqU128, FracDst: LeEqU32> LosslessTryFrom<FixedU128<FracSrc>> for FixedU32<FracDst> where
FracSrc: IsLessOrEqual<FracDst, Output = True>,
Converts a fixed-pint number.
This conversion may fail (fallible) but does not lose precision (lossless).
impl<FracSrc: LeEqU16, FracDst: LeEqU32> LosslessTryFrom<FixedU16<FracSrc>> for FixedU32<FracDst> where
FracSrc: IsLessOrEqual<FracDst, Output = True>,
impl<FracSrc: LeEqU16, FracDst: LeEqU32> LosslessTryFrom<FixedU16<FracSrc>> for FixedU32<FracDst> where
FracSrc: IsLessOrEqual<FracDst, Output = True>,
Converts a fixed-pint number.
This conversion may fail (fallible) but does not lose precision (lossless).
Converts a fixed-point number to a floating-point number.
This conversion actually never fails (infallible) but does not lose any precision (lossless).
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: LeEqU32, FracDst: LeEqU8> LosslessTryFrom<FixedU32<FracSrc>> for FixedI8<FracDst> where
FracSrc: IsLessOrEqual<FracDst, Output = True>,
impl<FracSrc: LeEqU32, FracDst: LeEqU8> LosslessTryFrom<FixedU32<FracSrc>> for FixedI8<FracDst> where
FracSrc: IsLessOrEqual<FracDst, Output = True>,
Converts a fixed-pint number.
This conversion may fail (fallible) but does not lose precision (lossless).
impl<FracSrc: LeEqU32, FracDst: LeEqU16> LosslessTryFrom<FixedU32<FracSrc>> for FixedI16<FracDst> where
FracSrc: IsLessOrEqual<FracDst, Output = True>,
impl<FracSrc: LeEqU32, FracDst: LeEqU16> LosslessTryFrom<FixedU32<FracSrc>> for FixedI16<FracDst> where
FracSrc: IsLessOrEqual<FracDst, Output = True>,
Converts a fixed-pint number.
This conversion may fail (fallible) but does not lose precision (lossless).
impl<FracSrc: LeEqU32, FracDst: LeEqU32> LosslessTryFrom<FixedU32<FracSrc>> for FixedI32<FracDst> where
FracSrc: IsLessOrEqual<FracDst, Output = True>,
impl<FracSrc: LeEqU32, FracDst: LeEqU32> LosslessTryFrom<FixedU32<FracSrc>> for FixedI32<FracDst> where
FracSrc: IsLessOrEqual<FracDst, Output = True>,
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>,
impl<FracSrc: LeEqU32, FracDst: LeEqU64> LosslessTryFrom<FixedU32<FracSrc>> for FixedI64<FracDst> where
FracSrc: IsLessOrEqual<FracDst, Output = True>,
Converts a fixed-pint number.
This conversion may fail (fallible) but does not lose precision (lossless).
impl<FracSrc: LeEqU32, FracDst: LeEqU128> LosslessTryFrom<FixedU32<FracSrc>> for FixedI128<FracDst> where
FracSrc: IsLessOrEqual<FracDst, Output = True>,
impl<FracSrc: LeEqU32, FracDst: LeEqU128> LosslessTryFrom<FixedU32<FracSrc>> for FixedI128<FracDst> where
FracSrc: IsLessOrEqual<FracDst, Output = True>,
Converts a fixed-pint number.
This conversion may fail (fallible) but does not lose precision (lossless).
impl<FracSrc: LeEqU32, FracDst: LeEqU8> LosslessTryFrom<FixedU32<FracSrc>> for FixedU8<FracDst> where
FracSrc: IsLessOrEqual<FracDst, Output = True>,
impl<FracSrc: LeEqU32, FracDst: LeEqU8> LosslessTryFrom<FixedU32<FracSrc>> for FixedU8<FracDst> where
FracSrc: IsLessOrEqual<FracDst, Output = True>,
Converts a fixed-pint number.
This conversion may fail (fallible) but does not lose precision (lossless).
impl<FracSrc: LeEqU32, FracDst: LeEqU16> LosslessTryFrom<FixedU32<FracSrc>> for FixedU16<FracDst> where
FracSrc: IsLessOrEqual<FracDst, Output = True>,
impl<FracSrc: LeEqU32, FracDst: LeEqU16> LosslessTryFrom<FixedU32<FracSrc>> for FixedU16<FracDst> where
FracSrc: IsLessOrEqual<FracDst, Output = True>,
Converts a fixed-pint number.
This conversion may fail (fallible) but does not lose precision (lossless).
impl<FracSrc: LeEqU32, FracDst: LeEqU32> LosslessTryFrom<FixedU32<FracSrc>> for FixedU32<FracDst> where
FracSrc: IsLessOrEqual<FracDst, Output = True>,
impl<FracSrc: LeEqU32, FracDst: LeEqU32> LosslessTryFrom<FixedU32<FracSrc>> for FixedU32<FracDst> where
FracSrc: IsLessOrEqual<FracDst, Output = True>,
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 FixedU64<FracDst> where
FracSrc: IsLessOrEqual<FracDst, Output = True>,
impl<FracSrc: LeEqU32, FracDst: LeEqU64> LosslessTryFrom<FixedU32<FracSrc>> for FixedU64<FracDst> where
FracSrc: IsLessOrEqual<FracDst, Output = True>,
Converts a fixed-pint number.
This conversion may fail (fallible) but does not lose precision (lossless).
impl<FracSrc: LeEqU32, FracDst: LeEqU128> LosslessTryFrom<FixedU32<FracSrc>> for FixedU128<FracDst> where
FracSrc: IsLessOrEqual<FracDst, Output = True>,
impl<FracSrc: LeEqU32, FracDst: LeEqU128> LosslessTryFrom<FixedU32<FracSrc>> for FixedU128<FracDst> where
FracSrc: IsLessOrEqual<FracDst, Output = True>,
Converts a fixed-pint number.
This conversion may fail (fallible) but does not lose precision (lossless).
Converts a fixed-point number to an integer.
This conversion may fail (fallible) but cannot lose any fractional bits (lossless).
Converts a fixed-point number to an integer.
This conversion may fail (fallible) but cannot lose any fractional bits (lossless).
Converts a fixed-point number to an integer.
This conversion may fail (fallible) but cannot lose any fractional bits (lossless).
Converts a fixed-point number to an integer.
This conversion may fail (fallible) but cannot lose any fractional bits (lossless).
Converts a fixed-point number to an integer.
This conversion may fail (fallible) but cannot lose any fractional bits (lossless).
Converts a fixed-point number to an integer.
This conversion may fail (fallible) but cannot lose any fractional bits (lossless).
Converts a fixed-point number to an integer.
This conversion may fail (fallible) but cannot lose any fractional bits (lossless).
Converts a fixed-point number to an integer.
This conversion may fail (fallible) but cannot lose any fractional bits (lossless).
Converts a fixed-point number to an integer.
This conversion may fail (fallible) but cannot lose any fractional bits (lossless).
Converts a fixed-point number to an integer.
This conversion may fail (fallible) but cannot lose any fractional bits (lossless).
Converts a fixed-point number to an integer.
This conversion may fail (fallible) but cannot lose any fractional bits (lossless).
Converts a fixed-point number to an integer.
This conversion may fail (fallible) but cannot lose any fractional bits (lossless).
impl<FracSrc: LeEqU64, FracDst: LeEqU32> LosslessTryFrom<FixedU64<FracSrc>> for FixedU32<FracDst> where
FracSrc: IsLessOrEqual<FracDst, Output = True>,
impl<FracSrc: LeEqU64, FracDst: LeEqU32> LosslessTryFrom<FixedU64<FracSrc>> for FixedU32<FracDst> where
FracSrc: IsLessOrEqual<FracDst, Output = True>,
Converts a fixed-pint number.
This conversion may fail (fallible) but does not lose precision (lossless).
impl<FracSrc: LeEqU8, FracDst: LeEqU32> LosslessTryFrom<FixedU8<FracSrc>> for FixedU32<FracDst> where
FracSrc: IsLessOrEqual<FracDst, Output = True>,
impl<FracSrc: LeEqU8, FracDst: LeEqU32> LosslessTryFrom<FixedU8<FracSrc>> for FixedU32<FracDst> where
FracSrc: IsLessOrEqual<FracDst, Output = True>,
Converts a fixed-pint number.
This conversion may fail (fallible) but does not lose precision (lossless).
Converts an integer to a fixed-point number.
This conversion may fail (fallible) but cannot lose any fractional bits (lossless).
Converts an integer to a fixed-point number.
This conversion may fail (fallible) but cannot lose any fractional bits (lossless).
Converts an integer to a fixed-point number.
This conversion may fail (fallible) but cannot lose any fractional bits (lossless).
Converts an integer to a fixed-point number.
This conversion may fail (fallible) but cannot lose any fractional bits (lossless).
Converts an integer to a fixed-point number.
This conversion may fail (fallible) but cannot lose any fractional bits (lossless).
Converts an integer to a fixed-point number.
This conversion may fail (fallible) but cannot lose any fractional bits (lossless).
Converts an integer to a fixed-point number.
This conversion may fail (fallible) but cannot lose any fractional bits (lossless).
Converts an integer to a fixed-point number.
This conversion may fail (fallible) but cannot lose any fractional bits (lossless).
Converts an integer to a fixed-point number.
This conversion may fail (fallible) but cannot lose any fractional bits (lossless).
Converts an integer to a fixed-point number.
This conversion may fail (fallible) but cannot lose any fractional bits (lossless).
Converts an integer to a fixed-point number.
This conversion may fail (fallible) but cannot lose any fractional bits (lossless).
Converts an integer to a fixed-point number.
This conversion may fail (fallible) but cannot lose any fractional bits (lossless).
Converts an integer to a fixed-point number.
This conversion may fail (fallible) but cannot lose any fractional bits (lossless).
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 −∞.
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 −∞.
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.
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.
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.
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.
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.
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 −∞.
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 −∞.
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 −∞.
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 −∞.
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 −∞.
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 −∞.
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 −∞.
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 −∞.
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 −∞.
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 −∞.
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 −∞.
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 −∞.
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 −∞.
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 −∞.
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 −∞.
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 −∞.
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 −∞.
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 −∞.
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 −∞.
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 −∞.
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 −∞.
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 −∞.
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 −∞.
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 −∞.
Converts a bool
to a fixed-point number.
This conversion never fails (infallible) and cannot lose any fractional bits, so it is actually lossless.
Converts an integer to a fixed-point number.
This conversion never fails (infallible) and cannot lose any fractional bits, so it is actually lossless.
Converts an integer to a fixed-point number.
This conversion never fails (infallible) and actually does not lose any precision (lossless).
Converts an integer to a fixed-point number.
This conversion never fails (infallible) and cannot lose any fractional bits, so it is actually lossless.
Performs the fused multiply-add operation.
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Convert from a string and radix (typically 2..=36
). Read more
This method returns an ordering between self
and other
values if one exists. Read more
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
This method returns an ordering between self
and other
values if one exists. Read more
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
This method returns an ordering between self
and other
values if one exists. Read more
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
This method returns an ordering between self
and other
values if one exists. Read more
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
This method returns an ordering between self
and other
values if one exists. Read more
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
This method returns an ordering between self
and other
values if one exists. Read more
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
This method returns an ordering between self
and other
values if one exists. Read more
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
This method returns an ordering between self
and other
values if one exists. Read more
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
This method returns an ordering between self
and other
values if one exists. Read more
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
This method returns an ordering between self
and other
values if one exists. Read more
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
This method returns an ordering between self
and other
values if one exists. Read more
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
This method returns an ordering between self
and other
values if one exists. Read more
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
This method returns an ordering between self
and other
values if one exists. Read more
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
This method returns an ordering between self
and other
values if one exists. Read more
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
This method returns an ordering between self
and other
values if one exists. Read more
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
This method returns an ordering between self
and other
values if one exists. Read more
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
This method returns an ordering between self
and other
values if one exists. Read more
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
This method returns an ordering between self
and other
values if one exists. Read more
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
This method returns an ordering between self
and other
values if one exists. Read more
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
This method returns an ordering between self
and other
values if one exists. Read more
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
This method returns an ordering between self
and other
values if one exists. Read more
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
This method returns an ordering between self
and other
values if one exists. Read more
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
This method returns an ordering between self
and other
values if one exists. Read more
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
This method returns an ordering between self
and other
values if one exists. Read more
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
This method returns an ordering between self
and other
values if one exists. Read more
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
This method returns an ordering between self
and other
values if one exists. Read more
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
This method returns an ordering between self
and other
values if one exists. Read more
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
This method returns an ordering between self
and other
values if one exists. Read more
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
This method returns an ordering between self
and other
values if one exists. Read more
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
This method returns an ordering between self
and other
values if one exists. Read more
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
This method returns an ordering between self
and other
values if one exists. Read more
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
This method returns an ordering between self
and other
values if one exists. Read more
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
This method returns an ordering between self
and other
values if one exists. Read more
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
This method returns an ordering between self
and other
values if one exists. Read more
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
This method returns an ordering between self
and other
values if one exists. Read more
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
This method returns an ordering between self
and other
values if one exists. Read more
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
This method returns an ordering between self
and other
values if one exists. Read more
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
This method returns an ordering between self
and other
values if one exists. Read more
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
This method returns an ordering between self
and other
values if one exists. Read more
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
This method returns an ordering between self
and other
values if one exists. Read more
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
This method returns an ordering between self
and other
values if one exists. Read more
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
This method returns an ordering between self
and other
values if one exists. Read more
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
This method returns an ordering between self
and other
values if one exists. Read more
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
This method returns an ordering between self
and other
values if one exists. Read more
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
This method returns an ordering between self
and other
values if one exists. Read more
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
This method returns an ordering between self
and other
values if one exists. Read more
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
This method returns an ordering between self
and other
values if one exists. Read more
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
This method returns an ordering between self
and other
values if one exists. Read more
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
This method returns an ordering between self
and other
values if one exists. Read more
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
This method returns an ordering between self
and other
values if one exists. Read more
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
This method returns an ordering between self
and other
values if one exists. Read more
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
This method returns an ordering between self
and other
values if one exists. Read more
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
This method returns an ordering between self
and other
values if one exists. Read more
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Saturating addition. Computes self + other
, saturating at the relevant high or low boundary of
the type. Read more
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Saturating multiplication. Computes self * other
, saturating at the relevant high or low boundary of
the type. Read more
Saturating subtraction. Computes self - other
, saturating at the relevant high or low boundary of
the type. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
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.
Converts a fixed-point number if it fits, otherwise returns None
.
Any extra fractional bits are discarded, which rounds towards −∞.
Converts a fixed-point number, saturating if it does not fit.
Any extra fractional bits are discarded, which rounds towards −∞.
Converts a fixed-point number, wrapping if it does not fit.
Any extra fractional bits are discarded, which rounds towards −∞.
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.
Converts the value of self
to an i64
. If the value cannot be
represented by an i64
, then None
is returned. Read more
Converts the value of self
to a u64
. If the value cannot be
represented by a u64
, then None
is returned. Read more
Converts the value of self
to an isize
. If the value cannot be
represented by an isize
, then None
is returned. Read more
Converts the value of self
to an i8
. If the value cannot be
represented by an i8
, then None
is returned. Read more
Converts the value of self
to an i16
. If the value cannot be
represented by an i16
, then None
is returned. Read more
Converts the value of self
to an i32
. If the value cannot be
represented by an i32
, then None
is returned. Read more
Converts the value of self
to an i128
. If the value cannot be
represented by an i128
(i64
under the default implementation), then
None
is returned. Read more
Converts the value of self
to a usize
. If the value cannot be
represented by a usize
, then None
is returned. Read more
Converts the value of self
to a u8
. If the value cannot be
represented by a u8
, then None
is returned. Read more
Converts the value of self
to a u16
. If the value cannot be
represented by a u16
, then None
is returned. Read more
Converts the value of self
to a u32
. If the value cannot be
represented by a u32
, then None
is returned. Read more
Converts the value of self
to a u128
. If the value cannot be
represented by a u128
(u64
under the default implementation), then
None
is returned. Read more
Converts the value of self
to an f32
. Overflows may map to positive
or negative inifinity, otherwise None
is returned if the value cannot
be represented by an f32
. Read more
Convert a reference to the inner type into a reference to the wrapper type. Read more
Convert a mutable reference to the inner type into a mutable reference to the wrapper type. Read more
Convert a slice to the inner type into a slice to the wrapper type.
fn wrap_slice_mut(s: &mut [Inner]) -> &mut [Self]ⓘ
fn wrap_slice_mut(s: &mut [Inner]) -> &mut [Self]ⓘ
Convert a mutable slice to the inner type into a mutable slice to the wrapper type. Read more
Convert a reference to the wrapper type into a reference to the inner type. Read more
Convert a mutable reference to the wrapper type into a mutable reference to the inner type. Read more
Convert a slice to the wrapped type into a slice to the inner type.
Convert a reference to the inner type into a reference to the wrapper type. Read more
Convert a mutable reference to the inner type into a mutable reference to the wrapper type. Read more
Convert a slice to the inner type into a slice to the wrapper type.
fn wrap_slice_mut(s: &mut [Inner]) -> &mut [Self]ⓘ
fn wrap_slice_mut(s: &mut [Inner]) -> &mut [Self]ⓘ
Convert a mutable slice to the inner type into a mutable slice to the wrapper type. Read more
Convert a reference to the wrapper type into a reference to the inner type. Read more
Convert a mutable reference to the wrapper type into a mutable reference to the inner type. Read more
Convert a slice to the wrapped type into a slice to the inner type.
Convert a reference to the inner type into a reference to the wrapper type. Read more
Convert a mutable reference to the inner type into a mutable reference to the wrapper type. Read more
Convert a slice to the inner type into a slice to the wrapper type.
fn wrap_slice_mut(s: &mut [Inner]) -> &mut [Self]ⓘ
fn wrap_slice_mut(s: &mut [Inner]) -> &mut [Self]ⓘ
Convert a mutable slice to the inner type into a mutable slice to the wrapper type. Read more
Convert a reference to the wrapper type into a reference to the inner type. Read more
Convert a mutable reference to the wrapper type into a mutable reference to the inner type. Read more
Convert a slice to the wrapped type into a slice to the inner type.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Wrapping (modular) addition. Computes self + other
, wrapping around at the boundary of
the type. Read more
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Wrapping (modular) multiplication. Computes self * other
, wrapping around at the boundary
of the type. Read more
Wrapping (modular) negation. Computes -self
,
wrapping around at the boundary of the type. Read more
Panic-free bitwise shift-left; yields self << mask(rhs)
,
where mask
removes any high order bits of rhs
that would
cause the shift to exceed the bitwidth of the type. Read more
Panic-free bitwise shift-right; yields self >> mask(rhs)
,
where mask
removes any high order bits of rhs
that would
cause the shift to exceed the bitwidth of the type. Read more
Wrapping (modular) subtraction. Computes self - other
, wrapping around at the boundary
of the type. Read more
Auto Trait Implementations
impl<Frac> RefUnwindSafe for FixedU32<Frac> where
Frac: RefUnwindSafe,
impl<Frac> UnwindSafe for FixedU32<Frac> where
Frac: UnwindSafe,
Blanket Implementations
Mutably borrows from an owned value. Read more
Casts the value.
Casts the value.
Performs the conversion.
Performs the conversion.
Casts the value.
OverflowingCasts the value.
Casts the value.
Casts the value.
Casts the value.
UnwrappedCasts the value.
Casts the value.
WrappingCasts the value.