Struct fixed::Wrapping

source ·

#[repr(transparent)]
pub struct Wrapping<F>(pub F);

Expand description

Provides intentionally wrapped arithmetic on fixed-point numbers.

The underlying value can be retrieved through the .0 index.

§Examples

use fixed::{types::I16F16, Wrapping};
let max = Wrapping(I16F16::MAX);
let delta = Wrapping(I16F16::DELTA);
assert_eq!(I16F16::MIN, (max + delta).0);

Tuple Fields§

§0: F

Implementations§

source §

use fixed::{types::I16F16, Wrapping};
let bytes = if cfg!(target_endian = "big") {
    [0x12, 0x34, 0x56, 0x78]
} else {
    [0x78, 0x56, 0x34, 0x12]
};
assert_eq!(
    Wrapping::<I16F16>::from_bits(0x1234_5678).to_ne_bytes(),
    bytes
);

source

pub fn from_num<Src: ToFixed>(src: Src) -> Wrapping<F>

Wrapping conversion from another number.

The other number can be:

A 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, or usize.
A floating-point number of type half::f16, half::bf16, f32, f64 or F128. For this conversion, the method rounds to the nearest, with ties rounding to even.
Any other number src for which ToFixed is implemented, in which case this method returns Wrapping(src.wrapping_to_fixed()).

See also FixedI32::wrapping_from_num and FixedU32::wrapping_from_num.

§Panics

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

§Examples

use fixed::{
    types::{I4F4, I16F16},
    Wrapping,
};

// 0x1234.5678 wraps into 0x4.5
let src = I16F16::from_bits(0x1234_5678);
let dst = Wrapping::<I4F4>::from_num(src);
assert_eq!(dst, Wrapping(I4F4::from_bits(0x45)));

// 0x1234 wraps into 0x4.0
let src_int = 0x1234_i32;
let dst_int = Wrapping::<I4F4>::from_num(src_int);
assert_eq!(dst_int, Wrapping(I4F4::from_bits(0x40)));

// 129.75 wrapped into 1.75 (binary 1.1100)
let src_float = 129.75;
let dst_float = Wrapping::<I4F4>::from_num(src_float);
assert_eq!(dst_float, Wrapping(I4F4::from_bits(0b11100)));

source

pub fn to_num<Dst: FromFixed>(self) -> Dst

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, or usize. Any fractional bits are discarded, which rounds towards −∞.
A floating-point number of type half::f16, half::bf16, f32, f64 or F128. For this conversion, the method rounds to the nearest, with ties rounding to even.
Any other type Dst for which FromFixed is implemented, in which case this method returns Dst::wrapping_from_fixed(self.0).

See also FixedI32::wrapping_to_num and FixedU32::wrapping_to_num.

§Examples

use fixed::{
    types::{I16F16, I2F6, I4F4},
    Wrapping,
};

// conversion that fits
let src = Wrapping(I4F4::from_num(1.75));
let expected = I16F16::from_num(1.75);
assert_eq!(src.to_num::<I16F16>(), expected);

// conversion that wraps
let src = Wrapping(I4F4::MAX);
let wrapped = I2F6::from_bits(I2F6::MAX.to_bits() << 2);
assert_eq!(src.to_num::<I2F6>(), wrapped);

source

pub fn from_str_binary(src: &str) -> Result<Wrapping<F>, ParseFixedError>

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

Rounding is to the nearest, with ties rounded to even.

See also FixedI32::wrapping_from_str_binary and FixedU32::wrapping_from_str_binary.

§Examples

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

source

pub fn from_str_octal(src: &str) -> Result<Wrapping<F>, ParseFixedError>

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

Rounding is to the nearest, with ties rounded to even.

See also FixedI32::wrapping_from_str_octal and FixedU32::wrapping_from_str_octal.

§Examples

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

source

pub fn from_str_hex(src: &str) -> Result<Wrapping<F>, ParseFixedError>

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

Rounding is to the nearest, with ties rounded to even.

See also FixedI32::wrapping_from_str_hex and FixedU32::wrapping_from_str_hex.

§Examples

use fixed::{types::I8F8, Wrapping};
let check = Wrapping(I8F8::from_bits(0xFFE));
assert_eq!(Wrapping::<I8F8>::from_str_hex("C0F.FE"), Ok(check));

source

pub fn int(self) -> Wrapping<F>

Returns the integer part.

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

See also FixedI32::int and FixedU32::int.

§Examples

use fixed::{types::I16F16, Wrapping};
assert_eq!(Wrapping(I16F16::from_num(12.25)).int(), Wrapping(I16F16::from_num(12)));
assert_eq!(Wrapping(I16F16::from_num(-12.25)).int(), Wrapping(I16F16::from_num(-13)));

source

pub fn frac(self) -> Wrapping<F>

Returns the fractional part.

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

See also FixedI32::frac and FixedU32::frac.

§Examples

use fixed::{types::I16F16, Wrapping};
assert_eq!(Wrapping(I16F16::from_num(12.25)).frac(), Wrapping(I16F16::from_num(0.25)));
assert_eq!(Wrapping(I16F16::from_num(-12.25)).frac(), Wrapping(I16F16::from_num(0.75)));

source

pub fn round_to_zero(self) -> Wrapping<F>

Rounds to the next integer towards 0.

See also FixedI32::round_to_zero and FixedU32::round_to_zero.

§Examples

use fixed::{types::I16F16, Wrapping};
let three = Wrapping(I16F16::from_num(3));
assert_eq!(Wrapping(I16F16::from_num(3.9)).round_to_zero(), three);
assert_eq!(Wrapping(I16F16::from_num(-3.9)).round_to_zero(), -three);

source

pub fn ceil(self) -> Wrapping<F>

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

See also FixedI32::wrapping_ceil and FixedU32::wrapping_ceil.

§Examples

use fixed::{types::I16F16, Wrapping};
let two_half = Wrapping(I16F16::from_num(5) / 2);
assert_eq!(two_half.ceil(), Wrapping(I16F16::from_num(3)));
assert_eq!(Wrapping(I16F16::MAX).ceil(), Wrapping(I16F16::MIN));

source

pub fn floor(self) -> Wrapping<F>

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

Overflow can only occur for signed numbers with zero integer bits.

See also FixedI32::wrapping_floor and FixedU32::wrapping_floor.

§Examples

use fixed::{
    types::{I0F32, I16F16},
    Wrapping,
};
let two_half = Wrapping(I16F16::from_num(5) / 2);
assert_eq!(two_half.floor(), Wrapping(I16F16::from_num(2)));
assert_eq!(Wrapping(I0F32::MIN).floor(), Wrapping(I0F32::ZERO));

source

pub fn round(self) -> Wrapping<F>

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

See also FixedI32::wrapping_round and FixedU32::wrapping_round.

§Examples

use fixed::{types::I16F16, Wrapping};
let two_half = Wrapping(I16F16::from_num(5) / 2);
assert_eq!(two_half.round(), Wrapping(I16F16::from_num(3)));
assert_eq!((-two_half).round(), Wrapping(I16F16::from_num(-3)));
assert_eq!(Wrapping(I16F16::MAX).round(), Wrapping(I16F16::MIN));

source

pub fn round_ties_even(self) -> Wrapping<F>

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

See also FixedI32::wrapping_round_ties_even and FixedU32::wrapping_round_ties_even.

§Examples

use fixed::{types::I16F16, Wrapping};
let two_half = Wrapping(I16F16::from_num(2.5));
assert_eq!(two_half.round_ties_even(), Wrapping(I16F16::from_num(2)));
let three_half = Wrapping(I16F16::from_num(3.5));
assert_eq!(three_half.round_ties_even(), Wrapping(I16F16::from_num(4)));
let max = Wrapping(I16F16::MAX);
assert_eq!(max.round_ties_even(), Wrapping(I16F16::MIN));

source

pub fn count_ones(self) -> u32

Returns the number of ones in the binary representation.

See also FixedI32::count_ones and FixedU32::count_ones.

§Examples

use fixed::{types::I16F16, Wrapping};
let w = Wrapping(I16F16::from_bits(0x00FF_FF00));
assert_eq!(w.count_ones(), w.0.count_ones());

source

pub fn count_zeros(self) -> u32

Returns the number of zeros in the binary representation.

See also FixedI32::count_zeros and FixedU32::count_zeros.

§Examples

use fixed::{types::I16F16, Wrapping};
let w = Wrapping(I16F16::from_bits(0x00FF_FF00));
assert_eq!(w.count_zeros(), w.0.count_zeros());

source

pub fn leading_ones(self) -> u32

Returns the number of leading ones in the binary representation.

See also FixedI32::leading_ones and FixedU32::leading_ones.

§Examples

use fixed::{types::U16F16, Wrapping};
let w = Wrapping(U16F16::from_bits(0xFF00_00FF));
assert_eq!(w.leading_ones(), w.0.leading_ones());

source

pub fn leading_zeros(self) -> u32

Returns the number of leading zeros in the binary representation.

See also FixedI32::leading_zeros and FixedU32::leading_zeros.

§Examples

use fixed::{types::I16F16, Wrapping};
let w = Wrapping(I16F16::from_bits(0x00FF_FF00));
assert_eq!(w.leading_zeros(), w.0.leading_zeros());

source

pub fn trailing_ones(self) -> u32

Returns the number of trailing ones in the binary representation.

See also FixedI32::trailing_ones and FixedU32::trailing_ones.

§Examples

use fixed::{types::U16F16, Wrapping};
let w = Wrapping(U16F16::from_bits(0xFF00_00FF));
assert_eq!(w.trailing_ones(), w.0.trailing_ones());

source

pub fn trailing_zeros(self) -> u32

Returns the number of trailing zeros in the binary representation.

See also FixedI32::trailing_zeros and FixedU32::trailing_zeros.

§Examples

use fixed::{types::I16F16, Wrapping};
let w = Wrapping(I16F16::from_bits(0x00FF_FF00));
assert_eq!(w.trailing_zeros(), w.0.trailing_zeros());

source

pub fn sqrt(self) -> Self

Returns the square root.

See also FixedI32::wrapping_sqrt and FixedU32::wrapping_sqrt.

§Panics

Panics if the number is negative.

§Examples

use fixed::{types::I0F32, Wrapping};
assert_eq!(Wrapping(I0F32::lit("0b0.0001")).sqrt().0, I0F32::lit("0b0.01"));

// This method handles the overflow corner case.
let w = Wrapping(I0F32::from_num(0.25));
assert_eq!(w.sqrt().0, -0.5);

§Examples

use fixed::{types::I8F24, Wrapping};
let quarter = Wrapping(I8F24::from_num(0.25));
let frac_1_512 = Wrapping(I8F24::ONE / 512);
assert_eq!(quarter.recip(), Wrapping(I8F24::from_num(4)));
assert_eq!(frac_1_512.recip(), Wrapping(I8F24::ZERO));

source

pub fn next_multiple_of(self, other: Wrapping<F>) -> Wrapping<F>

Returns the next multiple of other.

See also FixedI32::wrapping_next_multiple_of and FixedU32::wrapping_next_multiple_of.

§Panics

Panics if other is zero.

§Examples

use fixed::{types::I16F16, Wrapping};
let one_point_5 = Wrapping::<I16F16>::from_num(1.5);
let four = Wrapping::<I16F16>::from_num(4);
let four_point_5 = Wrapping::<I16F16>::from_num(4.5);
assert_eq!(four.next_multiple_of(one_point_5), four_point_5);

let max = Wrapping::<I16F16>::MAX;
let max_minus_delta = max - Wrapping::<I16F16>::DELTA;
assert_eq!(max.next_multiple_of(max_minus_delta), max_minus_delta * 2);

source

pub fn mul_add(self, mul: Wrapping<F>, add: Wrapping<F>) -> Wrapping<F>

Multiply and add. Returns self × mul + add.

See also FixedI32::wrapping_mul_add and FixedU32::wrapping_mul_add.

§Examples

use fixed::{types::I16F16, Wrapping};
let half = Wrapping(I16F16::from_num(0.5));
let three = Wrapping(I16F16::from_num(3));
let four = Wrapping(I16F16::from_num(4));
let max = Wrapping(I16F16::MAX);
assert_eq!(three.mul_add(half, four), Wrapping(I16F16::from_num(5.5)));
assert_eq!(max.mul_add(three, max), max * 4);

source

pub fn add_prod(self, a: Wrapping<F>, b: Wrapping<F>) -> Wrapping<F>

Adds self to the product a × b.

See also FixedI32::wrapping_add_prod and FixedU32::wrapping_add_prod.

§Examples

use fixed::{types::I16F16, Wrapping};
let half = Wrapping(I16F16::from_num(0.5));
let three = Wrapping(I16F16::from_num(3));
let four = Wrapping(I16F16::from_num(4));
let max = Wrapping(I16F16::MAX);
assert_eq!(four.add_prod(three, half), Wrapping(I16F16::from_num(5.5)));
assert_eq!(max.add_prod(max, three), max * 4);

source

pub fn mul_acc(&mut self, a: Wrapping<F>, b: Wrapping<F>)

Multiply and accumulate. Adds (a × b) to self.

See also FixedI32::wrapping_mul_acc and FixedU32::wrapping_mul_acc.

§Examples

use fixed::{types::I16F16, Wrapping};
let mut acc = Wrapping(I16F16::from_num(3));
acc.mul_acc(Wrapping(I16F16::from_num(4)), Wrapping(I16F16::from_num(0.5)));
assert_eq!(acc, Wrapping(I16F16::from_num(5)));

acc = Wrapping(I16F16::MAX);
acc.mul_acc(Wrapping(I16F16::MAX), Wrapping(I16F16::from_num(3)));
assert_eq!(acc, Wrapping(I16F16::MAX) * 4);

source

pub fn div_euclid(self, divisor: Wrapping<F>) -> Wrapping<F>

Euclidean division.

See also FixedI32::wrapping_div_euclid and FixedU32::wrapping_div_euclid.

§Panics

Panics if the divisor is zero.

§Examples

use fixed::{types::I16F16, Wrapping};
let num = Wrapping(I16F16::from_num(7.5));
let den = Wrapping(I16F16::from_num(2));
assert_eq!(num.div_euclid(den), Wrapping(I16F16::from_num(3)));
let quarter = Wrapping(I16F16::from_num(0.25));
let check = (Wrapping(I16F16::MAX) * 4i32).round_to_zero();
assert_eq!(Wrapping(I16F16::MAX).div_euclid(quarter), check);

source

pub fn rem_euclid(self, divisor: Wrapping<F>) -> Wrapping<F>

Remainder for Euclidean division.

See also FixedI32::rem_euclid and FixedU32::rem_euclid.

§Panics

Panics if the divisor is zero.

§Examples

use fixed::{types::I16F16, Wrapping};
let num = Wrapping(I16F16::from_num(7.5));
let den = Wrapping(I16F16::from_num(2));
assert_eq!(num.rem_euclid(den), Wrapping(I16F16::from_num(1.5)));
assert_eq!((-num).rem_euclid(den), Wrapping(I16F16::from_num(0.5)));

source

pub fn div_euclid_int(self, divisor: F::Bits) -> Wrapping<F>

Euclidean division by an integer.

See also FixedI32::wrapping_div_euclid_int and FixedU32::wrapping_div_euclid_int.

§Panics

Panics if the divisor is zero.

§Examples

use fixed::{types::I16F16, Wrapping};
let num = Wrapping(I16F16::from_num(7.5));
assert_eq!(num.div_euclid_int(2), Wrapping(I16F16::from_num(3)));
let min = Wrapping(I16F16::MIN);
assert_eq!(min.div_euclid_int(-1), min);

source

pub fn rem_euclid_int(self, divisor: F::Bits) -> Wrapping<F>

Remainder for Euclidean division.

See also FixedI32::wrapping_rem_euclid_int and FixedU32::wrapping_rem_euclid_int.

§Panics

Panics if the divisor is zero.

§Examples

use fixed::{types::I16F16, Wrapping};
let num = Wrapping(I16F16::from_num(7.5));
assert_eq!(num.rem_euclid_int(2), Wrapping(I16F16::from_num(1.5)));
assert_eq!((-num).rem_euclid_int(2), Wrapping(I16F16::from_num(0.5)));

source

pub fn lerp(self, start: Wrapping<F>, end: Wrapping<F>) -> Wrapping<F>

Linear interpolation between start and end.

See also FixedI32::wrapping_lerp and FixedU32::wrapping_lerp.

§Examples

use fixed::{types::I16F16, Wrapping};
type Wr = Wrapping<I16F16>;
assert_eq!(Wr::from_num(0.5).lerp(Wr::ZERO, Wr::MAX), Wr::MAX / 2);
assert_eq!(Wr::from_num(1.5).lerp(Wr::ZERO, Wr::MAX), Wr::MAX + Wr::MAX / 2);

source

pub fn inv_lerp(self, start: Wrapping<F>, end: Wrapping<F>) -> Wrapping<F>

Inverse linear interpolation between start and end.

See also FixedI32::wrapping_inv_lerp and FixedU32::wrapping_inv_lerp.

§Examples

use fixed::{types::I16F16, Wrapping};
type Wr = Wrapping<I16F16>;
assert_eq!(
    Wr::from_num(25).inv_lerp(Wr::from_num(20), Wr::from_num(40)),
    Wr::from_num(0.25)
);

source

pub fn round_ties_to_even(self) -> Wrapping<F>

👎Deprecated since 1.28.0: renamed to round_ties_even

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

source §

impl<F: FixedSigned> Wrapping<F>

source

pub fn signed_bits(self) -> u32

Returns the number of bits required to represent the value.

The number of bits required includes an initial one for negative numbers, and an initial zero for non-negative numbers.

§Examples

use fixed::{types::I4F4, Wrapping};
assert_eq!(Wrapping(I4F4::from_num(-3)).signed_bits(), 7);      // “_101.0000”
assert_eq!(Wrapping(I4F4::from_num(-1)).signed_bits(), 5);      // “___1.0000”
assert_eq!(Wrapping(I4F4::from_num(-0.0625)).signed_bits(), 1); // “____.___1”
assert_eq!(Wrapping(I4F4::from_num(0)).signed_bits(), 1);       // “____.___0”
assert_eq!(Wrapping(I4F4::from_num(0.0625)).signed_bits(), 2);  // “____.__01”
assert_eq!(Wrapping(I4F4::from_num(1)).signed_bits(), 6);       // “__01.0000”
assert_eq!(Wrapping(I4F4::from_num(3)).signed_bits(), 7);       // “_011.0000”

source

pub fn is_positive(self) -> bool

Returns true if the number is > 0.

§Examples

use fixed::{types::I16F16, Wrapping};
assert!(Wrapping(I16F16::from_num(4.3)).is_positive());
assert!(!Wrapping(I16F16::ZERO).is_positive());
assert!(!Wrapping(I16F16::from_num(-4.3)).is_positive());

source

pub fn is_negative(self) -> bool

Returns true if the number is < 0.

§Examples

use fixed::{types::I16F16, Wrapping};
assert!(!Wrapping(I16F16::from_num(4.3)).is_negative());
assert!(!Wrapping(I16F16::ZERO).is_negative());
assert!(Wrapping(I16F16::from_num(-4.3)).is_negative());

source

pub fn abs(self) -> Wrapping<F>

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

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

§Examples

use fixed::{types::I16F16, Wrapping};
assert_eq!(Wrapping(I16F16::from_num(-5)).abs(), Wrapping(I16F16::from_num(5)));
assert_eq!(Wrapping(I16F16::MIN).abs(), Wrapping(I16F16::MIN));

source

pub fn signum(self) -> Wrapping<F>

Returns a number representing the sign of self.

§Warning

Using this method when 1 and −1 cannot be represented is almost certainly a bug, however, this is allowed and gives the following wrapped results.

When there are no integer bits, for example for the type Wrapping<I0F16>, the return value is always zero.
When there is one integer bit, for example for the type Wrapping<I1F15>, the return value is zero when self is zero, and −1 otherwise. This means that for a positive number, −1 is returned, because +1 does not fit and is wrapped to −1.

§Examples

use fixed::{
    types::{I0F32, I1F31, I16F16},
    Wrapping,
};
assert_eq!(Wrapping(<I16F16>::from_num(-3.9)).signum(), Wrapping(I16F16::NEG_ONE));
assert_eq!(Wrapping(<I16F16>::ZERO).signum(), Wrapping(I16F16::ZERO));
assert_eq!(Wrapping(<I16F16>::from_num(3.9)).signum(), Wrapping(I16F16::ONE));

assert_eq!(Wrapping(<I1F31>::from_num(0.5)).signum(), Wrapping(I1F31::NEG_ONE));
assert_eq!(Wrapping(<I0F32>::from_num(0.25)).signum(), Wrapping(I0F32::ZERO));
assert_eq!(Wrapping(<I0F32>::from_num(-0.5)).signum(), Wrapping(I0F32::ZERO));

source

pub fn add_unsigned(self, rhs: F::Unsigned) -> Wrapping<F>

Addition with an unsigned fixed-point number.

See also FixedI32::wrapping_add_unsigned.

§Examples

use fixed::{
    types::{I16F16, U16F16},
    Wrapping,
};
assert_eq!(
    Wrapping::<I16F16>::from_num(-5).add_unsigned(U16F16::from_num(3)),
    Wrapping::<I16F16>::from_num(-2)
);
assert_eq!(
    Wrapping::<I16F16>::ZERO.add_unsigned(U16F16::MAX),
    -Wrapping::<I16F16>::DELTA
);

source

pub fn sub_unsigned(self, rhs: F::Unsigned) -> Wrapping<F>

Subtraction with an unsigned fixed-point number.

See also FixedI32::wrapping_sub_unsigned.

§Examples

use fixed::{
    types::{I16F16, U16F16},
    Wrapping,
};
assert_eq!(
    Wrapping::<I16F16>::from_num(3).sub_unsigned(U16F16::from_num(5)),
    Wrapping::<I16F16>::from_num(-2)
);
assert_eq!(
    Wrapping::<I16F16>::ZERO.sub_unsigned(U16F16::MAX),
    Wrapping::<I16F16>::DELTA
);

source §

impl<F: FixedUnsigned> Wrapping<F>

source

pub fn significant_bits(self) -> u32

Returns the number of bits required to represent the value.

§Examples

use fixed::{types::U4F4, Wrapping};
assert_eq!(Wrapping(U4F4::from_num(0)).significant_bits(), 0);      // “____.____”
assert_eq!(Wrapping(U4F4::from_num(0.0625)).significant_bits(), 1); // “____.___1”
assert_eq!(Wrapping(U4F4::from_num(1)).significant_bits(), 5);      // “___1.0000”
assert_eq!(Wrapping(U4F4::from_num(3)).significant_bits(), 6);      // “__11.0000”

source

pub fn is_power_of_two(self) -> bool

Returns true if the fixed-point number is 2^k for some integer k.

§Examples

use fixed::{types::U16F16, Wrapping};
assert!(Wrapping(U16F16::from_num(0.5)).is_power_of_two());
assert!(Wrapping(U16F16::from_num(4)).is_power_of_two());
assert!(!Wrapping(U16F16::from_num(5)).is_power_of_two());

source

pub fn highest_one(self) -> Wrapping<F>

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::U16F16, Wrapping};
type T = Wrapping<U16F16>;
assert_eq!(T::from_bits(0b11_0010).highest_one(), T::from_bits(0b10_0000));
assert_eq!(T::from_num(0.3).highest_one(), T::from_num(0.25));
assert_eq!(T::from_num(4).highest_one(), T::from_num(4));
assert_eq!(T::from_num(6.5).highest_one(), T::from_num(4));
assert_eq!(T::ZERO.highest_one(), T::ZERO);

source

pub fn next_power_of_two(self) -> Wrapping<F>

Returns the smallest power of two that is ≥ self.

If the next power of two is too large to fit, it is wrapped to zero.

See also FixedU32::wrapping_next_power_of_two.

§Examples

use fixed::{types::U16F16, Wrapping};
type T = Wrapping<U16F16>;
assert_eq!(T::from_bits(0b11_0010).next_power_of_two(), T::from_bits(0b100_0000));
assert_eq!(T::from_num(0.3).next_power_of_two(), T::from_num(0.5));
assert_eq!(T::from_num(4).next_power_of_two(), T::from_num(4));
assert_eq!(T::from_num(6.5).next_power_of_two(), T::from_num(8));
// if the next power of two is too large, it is wrapped to zero
assert_eq!(T::MAX.next_power_of_two(), T::ZERO);

source

pub fn add_signed(self, rhs: F::Signed) -> Wrapping<F>

Addition with an signed fixed-point number.

See also FixedU32::wrapping_add_signed.

§Examples

use fixed::{
    types::{I16F16, U16F16},
    Wrapping,
};
assert_eq!(
    Wrapping::<U16F16>::from_num(5).add_signed(I16F16::from_num(-3)),
    Wrapping::<U16F16>::from_num(2)
);
assert_eq!(
    Wrapping::<U16F16>::ZERO.add_signed(-I16F16::DELTA),
    Wrapping::<U16F16>::MAX
);

source

pub fn sub_signed(self, rhs: F::Signed) -> Wrapping<F>

Subtraction with an signed fixed-point number.

See also FixedU32::wrapping_sub_signed.

§Examples

use fixed::{
    types::{I16F16, U16F16},
    Wrapping,
};
assert_eq!(
    Wrapping::<U16F16>::from_num(5).sub_signed(I16F16::from_num(-3)),
    Wrapping::<U16F16>::from_num(8)
);
assert_eq!(
    Wrapping::<U16F16>::ZERO.sub_signed(I16F16::DELTA),
    Wrapping::<U16F16>::MAX
);

The primitive integer type with an identical representation to this type. Read more

source §

const MAX_VALUE: i64 = 9_223_372_036_854_775_807i64

The upper inclusive bound for valid instances of this type.

source §

const MIN_VALUE: i64 = -9_223_372_036_854_775_808i64

The lower inclusive bound for valid instances of this type.

source §

fn from_integer(value: Self::Int) -> Option<Self>

If value is within the range for valid instances of this type, returns Some(converted_value), otherwise, returns None. Read more

source §

fn into_integer(self) -> Self::Int

Perform the conversion from C into the underlying integral type. This mostly exists otherwise generic code would need unsafe for the value as integer Read more

source §

The primitive integer type with an identical representation to this type. Read more

source §

const MAX_VALUE: u32 = 4_294_967_295u32

The upper inclusive bound for valid instances of this type.

source §

const MIN_VALUE: u32 = 0u32

The lower inclusive bound for valid instances of this type.

source §

fn from_integer(value: Self::Int) -> Option<Self>

If value is within the range for valid instances of this type, returns Some(converted_value), otherwise, returns None. Read more

source §

fn into_integer(self) -> Self::Int

Perform the conversion from C into the underlying integral type. This mostly exists otherwise generic code would need unsafe for the value as integer Read more

source §