Struct Posit 

pub struct Posit<const N: u32, const ES: u32, Int: Int>(/* private fields */);

A posit floating point number with N bits and ES exponent bits, using Int as its underlying type.

If Int = iX, then N must be in the range 3 ..= X, and ES must be in the range 0 .. N. If this is not the case, a compile-time error will be raised.

Type aliases are provided at the crate root for the posit types defined in the standard.

Example

// A 32-bit posit with 2-bit exponent field, represented in a 32-bit machine type.
type Foo = Posit<32, 2, i32>;
// A 6-bit posit with 1-bit exponent field, represented in an 8-bit machine type.
type Bar = Posit<6, 1, i8>;

The standard p8, p16, p32, and p64 types are simply type aliases for Posit<X, 2, iX>.

Note that Posit will have the same size (and alignment) as its Int parameter, so it’s currently not possible to create e.g. a 4-bit posit that only takes 4 bits in memory.

If the combination of parameters is invalid, the code will not compile.

type Foo = Posit<40, 2, i32>;   // N=40 too large for i32

type Bar = Posit<1, 0, i8>;     // N=1 can't be ≤ 2

type Baz = Posit<32, 33, i32>;  // ES=33 too big for N=32

Implementations

impl<const N: u32, const ES: u32, Int: Int> Posit<N, ES, Int>

pub const BITS: u32

The size of this Posit type in bits (i.e. parameter N).

Note: this is the logical size, not necessarily the size of the underlying type.

Example

assert_eq!(p16::BITS, 16);                  // Standard posit
assert_eq!(Posit::<20, 1, i32>::BITS, 20);  // Non-standard posit

pub const ES: u32

The number of exponent bits (i.e. parameter ES).

Example

assert_eq!(p16::ES, 2);                  // Standard posit
assert_eq!(Posit::<20, 1, i32>::ES, 1);  // Non-standard posit

pub const fn to_bits(self) -> Int

Return the underlying bit representation of self as a machine int. Bits higher (more significant) than the lowest N bits, if any, are set as equal to the N-1th bit (i.e. sign-extended).

Example

assert_eq!(0b00000000, p8::ZERO.to_bits());
assert_eq!(0b01000000, p8::ONE.to_bits());
assert_eq!(0b01111111, p8::MAX.to_bits());
assert_eq!(0b00000001, p8::MIN_POSITIVE.to_bits());
assert_eq!(0b11000000, p8::MINUS_ONE.to_bits());
assert_eq!(0b10000001, p8::MIN.to_bits());
assert_eq!(0b11111111, p8::MAX_NEGATIVE.to_bits());
assert_eq!(0b10000000, p8::NAR.to_bits());

pub fn from_bits(bits: Int) -> Self

Construct a posit from its raw bit representation. Bits higher (more significant) than the lowest N bits, if any, are ignored.

Example

assert_eq!(p8::from_bits(0), p8::ZERO);
assert_eq!(p8::from_bits(1), p8::MIN_POSITIVE);
assert_eq!(p8::from_bits(i8::MAX), p8::MAX);
assert_eq!(p8::from_bits(0b0_10_01_011), 2.75.round_into());
assert_eq!(p8::from_bits(0b1_110_00_01), (-0.0546875).round_into());

pub const unsafe fn from_bits_unchecked(bits: Int) -> Self

As Self::from_bits, but does not check that bits is a valid bit pattern for Self.

Safety

bits has to be a result of a Self::to_bits call, i.e. it has to be in the range -1 << (N-1) ..= 1 << (N-1) - 1, or calling this function is undefined behaviour. Note that if Int::BITS == Self::BITS this always holds.

Example

type Posit4 = Posit<4, 1, i8>;
assert_eq!(Posit4::from_bits(0b0000_0100), Posit4::ONE);
assert_eq!(Posit4::from_bits(0b1111_1000), Posit4::NAR);

but the following would not be valid as the bits are not in a valid range (i.e. not sign-extended past 4 bits).

Posit4::from_bits(0b0110_0100);  // Undefined behaviour!

impl<const N: u32, const ES: u32, Int: Int> Posit<N, ES, Int>

pub const ZERO: Self

Zero (0), the additive identity element.

pub const NAR: Self

Not-a-real (NaR).

pub const ONE: Self

One (1), the additive identity element.

pub const MINUS_ONE: Self

Negative one (-1).

pub const MAX: Self

Largest representable value, equal to -MIN.

pub const MIN: Self

Smallest representable value, equal to -MAX.

Not to be confused with the smallest absolute value, i.e. Self::MIN_POSITIVE.

pub const MIN_POSITIVE: Self

Smallest positive value, equal to -MAX_NEGATIVE.

pub const MAX_NEGATIVE: Self

Largest negative value, equal to -MIN_POSITIVE.

pub const MIN_EXP: Int

The minimum exponent; Self::MIN_POSITIVE = 2 ^{Self::MIN_EXP}.

pub const MAX_EXP: Int

The maximum exponent; Self::MAX_NEGATIVE = 2 ^{Self::MAX_EXP}.

impl<const N: u32, const ES: u32, Int: Int> Posit<N, ES, Int>

pub fn next(self) -> Self

Returns the posit value of the lexicographic successor of self’s representation.

Note that, unlike every other function of a posit, next and prior do not produce a NaR output on a NaR input.

Standard: “next”.

Example

assert_eq!(p8::round_from(1.).next(), p8::round_from(1.125));
assert_eq!(p8::round_from(128.).next(), p8::round_from(160.));
assert_eq!(p8::MAX.next(), p8::NAR);
assert_eq!(p8::NAR.next(), p8::MIN);

pub fn prior(self) -> Self

Returns the posit value of the lexicographic predecessor of self’s representation.

Note that, unlike every other function of a posit, next and prior do not produce a NaR output on a NaR input.

Standard: “prior”.

Example

assert_eq!(p8::round_from(1.).prior(), p8::round_from(0.9375));
assert_eq!(p8::round_from(128.).prior(), p8::round_from(112.));
assert_eq!(p8::MIN.prior(), p8::NAR);
assert_eq!(p8::NAR.prior(), p8::MAX);

impl<const N: u32, const ES: u32, Int: Int> Posit<N, ES, Int>

pub fn abs(self) -> Self

Return the absolute value of self.

Standard: “abs”.

Example

assert_eq!(p16::ONE.abs(), p16::MINUS_ONE.abs())

pub fn sign(self) -> Self

Return 1 if self > 0, -1 if self < 0, 0 if self == 0, and NaR if self == NaR.

Standard: “sign”.

Example

assert_eq!(p16::round_from(2).sign(), p16::round_from(1));
assert_eq!(p16::round_from(-3).sign(), p16::round_from(-1));
assert_eq!(p16::round_from(0).sign(), p16::round_from(0));
assert_eq!(p16::NAR.sign(), p16::NAR);

impl<const N: u32, const ES: u32, Int: Int> Posit<N, ES, Int>

pub fn nearest_int(self) -> Self

Returns the integer-valued posit nearest to self, and the nearest even integer-valued posit if two integers are equally near.

Standard: “nearestInt”.

Example

assert_eq!(p32::round_from(3.1).nearest_int(), p32::round_from(3));
assert_eq!(p32::round_from(3.5).nearest_int(), p32::round_from(4));
assert_eq!(p32::round_from(3.9).nearest_int(), p32::round_from(4));

pub fn floor(self) -> Self

Returns the largest integer-valued posit less than or equal to self.

Standard: “floor”.

Example

assert_eq!(p32::round_from(3.1).floor(), p32::round_from(3));
assert_eq!(p32::round_from(3.5).floor(), p32::round_from(3));
assert_eq!(p32::round_from(3.9).floor(), p32::round_from(3));

pub fn ceil(self) -> Self

Returns the smallest integer-valued posit greater than or equal to self.

Standard: “ceil”.

Example

assert_eq!(p32::round_from(3.1).ceil(), p32::round_from(4));
assert_eq!(p32::round_from(3.5).ceil(), p32::round_from(4));
assert_eq!(p32::round_from(3.9).ceil(), p32::round_from(4));

impl<const N: u32, const ES: u32, Int: Int> Posit<N, ES, Int>

pub fn convert<const N2: u32, const ES2: u32, Int2: Int>( self, ) -> Posit<N2, ES2, Int2>

Convert a posit into a different one, rounding according to the standard.

If the source and target types have the same ES (i.e. ES == ES2), such as is the case with the standard types, this is especially fast. This enables easy and seamless mixed-precision arithmetic.

Examples

let pi: p64 = core::f64::consts::PI.round_into();
let two: p8 = 2.round_into();
let tau: p64 = pi * two.convert();
assert_eq!(tau, core::f64::consts::TAU.round_into())

Trait Implementations

impl<const N: u32, const ES: u32, Int: Int> Add<&Posit<N, ES, Int>> for &Posit<N, ES, Int>

type Output = Posit<N, ES, Int>

The resulting type after applying the + operator.

fn add(self, rhs: &Posit<N, ES, Int>) -> Self::Output

Performs the + operation.

impl<const N: u32, const ES: u32, Int: Int> Add<&Posit<N, ES, Int>> for Posit<N, ES, Int>

type Output = Posit<N, ES, Int>

The resulting type after applying the + operator.

fn add(self, rhs: &Self) -> Self::Output

Performs the + operation.

impl<const N: u32, const ES: u32, Int: Int> Add<Posit<N, ES, Int>> for &Posit<N, ES, Int>

type Output = Posit<N, ES, Int>

The resulting type after applying the + operator.

fn add(self, rhs: Posit<N, ES, Int>) -> Self::Output

Performs the + operation.

impl<const N: u32, const ES: u32, Int: Int> Add for Posit<N, ES, Int>

type Output = Posit<N, ES, Int>

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl<const N: u32, const ES: u32, Int: Int> AddAssign<&Posit<N, ES, Int>> for Posit<N, ES, Int>

fn add_assign(&mut self, rhs: &Posit<N, ES, Int>)

Performs the += operation.

impl<const N: u32, const ES: u32, Int: Int, const SIZE: usize> AddAssign<&Posit<N, ES, Int>> for Quire<N, ES, SIZE>

fn add_assign(&mut self, rhs: &Posit<N, ES, Int>)

Standard: “qAddP”.

Example

let mut quire = q16::from(p16::ONE);
quire += p16::round_from(0.42);
assert_eq!(p16::round_from(1.42), (&quire).round_into())

impl<const N: u32, const ES: u32, Int: Int, const SIZE: usize> AddAssign<Posit<N, ES, Int>> for Quire<N, ES, SIZE>

fn add_assign(&mut self, rhs: Posit<N, ES, Int>)

Standard: “qAddP”.

Example

let mut quire = q16::from(p16::ONE);
quire += p16::round_from(0.42);
assert_eq!(p16::round_from(1.42), (&quire).round_into())

impl<const N: u32, const ES: u32, Int: Int> AddAssign for Posit<N, ES, Int>

fn add_assign(&mut self, rhs: Posit<N, ES, Int>)

Performs the += operation.

impl<const N: u32, const ES: u32, Int: Int> Clone for Posit<N, ES, Int>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<const N: u32, const ES: u32, Int: Int> Debug for Posit<N, ES, Int>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<const N: u32, const ES: u32, Int: Int> Default for Posit<N, ES, Int>

fn default() -> Self

Returns the “default value” for a type.

impl<const N: u32, const ES: u32, Int: Int> Div<&Posit<N, ES, Int>> for &Posit<N, ES, Int>

type Output = Posit<N, ES, Int>

The resulting type after applying the / operator.

fn div(self, rhs: &Posit<N, ES, Int>) -> Self::Output

Performs the / operation.

impl<const N: u32, const ES: u32, Int: Int> Div<&Posit<N, ES, Int>> for Posit<N, ES, Int>

type Output = Posit<N, ES, Int>

The resulting type after applying the / operator.

fn div(self, rhs: &Self) -> Self::Output

Performs the / operation.

impl<const N: u32, const ES: u32, Int: Int> Div<Posit<N, ES, Int>> for &Posit<N, ES, Int>

type Output = Posit<N, ES, Int>

The resulting type after applying the / operator.

fn div(self, rhs: Posit<N, ES, Int>) -> Self::Output

Performs the / operation.

impl<const N: u32, const ES: u32, Int: Int> Div for Posit<N, ES, Int>

type Output = Posit<N, ES, Int>

The resulting type after applying the / operator.

fn div(self, rhs: Self) -> Self::Output

Performs the / operation.

impl<const N: u32, const ES: u32, Int: Int> DivAssign<&Posit<N, ES, Int>> for Posit<N, ES, Int>

fn div_assign(&mut self, rhs: &Posit<N, ES, Int>)

Performs the /= operation.

impl<const N: u32, const ES: u32, Int: Int> DivAssign for Posit<N, ES, Int>

fn div_assign(&mut self, rhs: Posit<N, ES, Int>)

Performs the /= operation.

impl<const N: u32, const ES: u32, Int: Int, const SIZE: usize> From<Posit<N, ES, Int>> for Quire<N, ES, SIZE>

fn from(value: Posit<N, ES, Int>) -> Self

Create a quire from a posit value.

Standard: “pToQ”.

Example

let posit = p16::round_from(123);
let quire = q16::from(posit);

impl<const N: u32, const ES: u32, Int: Int> Hash for Posit<N, ES, Int>

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

Feeds this value into the given Hasher.

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

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<const N: u32, const ES: u32, Int: Int> Mul<&Posit<N, ES, Int>> for &Posit<N, ES, Int>

type Output = Posit<N, ES, Int>

The resulting type after applying the * operator.

fn mul(self, rhs: &Posit<N, ES, Int>) -> Self::Output

Performs the * operation.

impl<const N: u32, const ES: u32, Int: Int> Mul<&Posit<N, ES, Int>> for Posit<N, ES, Int>

type Output = Posit<N, ES, Int>

The resulting type after applying the * operator.

fn mul(self, rhs: &Self) -> Self::Output

Performs the * operation.

impl<const N: u32, const ES: u32, Int: Int> Mul<Posit<N, ES, Int>> for &Posit<N, ES, Int>

type Output = Posit<N, ES, Int>

The resulting type after applying the * operator.

fn mul(self, rhs: Posit<N, ES, Int>) -> Self::Output

Performs the * operation.

impl<const N: u32, const ES: u32, Int: Int> Mul for Posit<N, ES, Int>

type Output = Posit<N, ES, Int>

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self::Output

Performs the * operation.

impl<const N: u32, const ES: u32, Int: Int> MulAssign<&Posit<N, ES, Int>> for Posit<N, ES, Int>

fn mul_assign(&mut self, rhs: &Posit<N, ES, Int>)

Performs the *= operation.

impl<const N: u32, const ES: u32, Int: Int> MulAssign for Posit<N, ES, Int>

fn mul_assign(&mut self, rhs: Posit<N, ES, Int>)

Performs the *= operation.

impl<const N: u32, const ES: u32, Int: Int> Neg for &Posit<N, ES, Int>

fn neg(self) -> Self::Output

Standard: “negate”.

Example

assert_eq!(-p16::round_from(3), p16::round_from(-3));
assert_eq!(-p16::MAX, p16::MIN);

type Output = Posit<N, ES, Int>

The resulting type after applying the - operator.

impl<const N: u32, const ES: u32, Int: Int> Neg for Posit<N, ES, Int>

fn neg(self) -> Self::Output

Standard: “negate”.

Example

assert_eq!(-p16::round_from(3), p16::round_from(-3));
assert_eq!(-p16::MAX, p16::MIN);

type Output = Posit<N, ES, Int>

The resulting type after applying the - operator.

impl<const N: u32, const ES: u32, Int: Int> Ord for Posit<N, ES, Int>

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

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

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<const N: u32, const ES: u32, Int: Int> PartialEq for Posit<N, ES, Int>

Note that, unlike IEEE floats, NaR is equal to itself (and different from any other value).

Example

assert!(p32::NAR == p32::NAR);
assert!(f32::NAN != f32::NAN);

assert!(p32::NAR != 3.round_into());
assert!(f32::NAN != 3.);

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<const N: u32, const ES: u32, Int: Int> PartialOrd for Posit<N, ES, Int>

Note that, unlike IEEE floats, posits have a total order (i.e. implement Ord). NaR is always smaller than any other value, and equal to itself.

Example

assert_eq!(p32::NAR.partial_cmp(&p32::NAR), Some(Ordering::Equal));
assert_eq!(f32::NAN.partial_cmp(&f32::NAN), None);

assert!(p32::NAR < p32::round_from(-3));
assert!(!(f32::NAN < -3.) && !(f32::NAN >= -3.));

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

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

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

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

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

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

impl<const N: u32, const ES: u32, Int: Int, const SIZE: usize> RoundFrom<&Quire<N, ES, SIZE>> for Posit<N, ES, Int>

fn round_from(value: &Quire<N, ES, SIZE>) -> Self

Round a quire back to a posit. This is the final step to do after a series of calculations in the quire, and the only step that actually rounds.

Standard: “qToP”.

Example

let mut quire = q16::from(p16::MAX);
quire += p16::round_from(0.1);
quire -= p16::MAX;
let result: p16 = (&quire).round_into();
assert_eq!(result, p16::round_from(0.1))

impl<const N: u32, const ES: u32, Int: Int> RoundFrom<Posit<N, ES, Int>> for f32

fn round_from(value: Posit<N, ES, Int>) -> Self

Convert a Posit into an f32, rounding according to the standard:

• If the value is 0, the result is +0.0.
• If the value is NaR, the result is a quiet NaN.
• Otherwise, the posit value is rounded to a float (if necessary) using the “roundTiesToEven” rule in the IEEE 754 standard (in short: underflow to ±0, overflow to ±∞, otherwise round to nearest, in case of a tie round to nearest even bit pattern).

impl<const N: u32, const ES: u32, Int: Int> RoundFrom<Posit<N, ES, Int>> for f64

fn round_from(value: Posit<N, ES, Int>) -> Self

Convert a Posit into an f64, rounding according to the standard:

• If the value is 0, the result is +0.0.
• If the value is NaR, the result is a quiet NaN.
• Otherwise, the posit value is rounded to a float (if necessary) using the “roundTiesToEven” rule in the IEEE 754 standard (in short: underflow to ±0, overflow to ±∞, otherwise round to nearest, in case of a tie round to nearest even bit pattern).

impl<const N: u32, const ES: u32, Int: Int> RoundFrom<Posit<N, ES, Int>> for i128

fn round_from(value: Posit<N, ES, Int>) -> Self

Convert a Posit into an i128, rounding according to the standard:

• If the value is NaR, or if overflows the target type, then it converts to i128::MIN (i.e. the value where the most significant bit is 1 and the rest are 0).
• Otherwise, it returns the nearest integer to value, rounding ties to even.

impl<const N: u32, const ES: u32, Int: Int> RoundFrom<Posit<N, ES, Int>> for i16

fn round_from(value: Posit<N, ES, Int>) -> Self

Convert a Posit into an i16, rounding according to the standard:

• If the value is NaR, or if overflows the target type, then it converts to i16::MIN (i.e. the value where the most significant bit is 1 and the rest are 0).
• Otherwise, it returns the nearest integer to value, rounding ties to even.

impl<const N: u32, const ES: u32, Int: Int> RoundFrom<Posit<N, ES, Int>> for i32

fn round_from(value: Posit<N, ES, Int>) -> Self

Convert a Posit into an i32, rounding according to the standard:

• If the value is NaR, or if overflows the target type, then it converts to i32::MIN (i.e. the value where the most significant bit is 1 and the rest are 0).
• Otherwise, it returns the nearest integer to value, rounding ties to even.

impl<const N: u32, const ES: u32, Int: Int> RoundFrom<Posit<N, ES, Int>> for i64

fn round_from(value: Posit<N, ES, Int>) -> Self

Convert a Posit into an i64, rounding according to the standard:

• If the value is NaR, or if overflows the target type, then it converts to i64::MIN (i.e. the value where the most significant bit is 1 and the rest are 0).
• Otherwise, it returns the nearest integer to value, rounding ties to even.

impl<const N: u32, const ES: u32, Int: Int> RoundFrom<Posit<N, ES, Int>> for i8

fn round_from(value: Posit<N, ES, Int>) -> Self

Convert a Posit into an i8, rounding according to the standard:

• If the value is NaR, or if overflows the target type, then it converts to i8::MIN (i.e. the value where the most significant bit is 1 and the rest are 0).
• Otherwise, it returns the nearest integer to value, rounding ties to even.

impl<const N: u32, const ES: u32, Int: Int> RoundFrom<f32> for Posit<N, ES, Int>

fn round_from(value: f32) -> Self

Convert an f32 into a Posit, rounding according to the standard:

• If the value is any infinity or any NaN, it converts to NaR.
• Otherwise, the float value is rounded (if necessary).

impl<const N: u32, const ES: u32, Int: Int> RoundFrom<f64> for Posit<N, ES, Int>

fn round_from(value: f64) -> Self

Convert an f64 into a Posit, rounding according to the standard:

• If the value is any infinity or any NaN, it converts to NaR.
• Otherwise, the float value is rounded (if necessary).

impl<const N: u32, const ES: u32, Int: Int> RoundFrom<i128> for Posit<N, ES, Int>

fn round_from(value: i128) -> Self

Convert an i128 into a Posit, rounding according to the standard:

• If the value is i128::MIN (i.e. the value where the most significant bit is 1 and the rest are 0), it converts to NaR.
• Otherwise, the integer value is rounded (if necessary).

impl<const N: u32, const ES: u32, Int: Int> RoundFrom<i16> for Posit<N, ES, Int>

fn round_from(value: i16) -> Self

Convert an i16 into a Posit, rounding according to the standard:

• If the value is i16::MIN (i.e. the value where the most significant bit is 1 and the rest are 0), it converts to NaR.
• Otherwise, the integer value is rounded (if necessary).

impl<const N: u32, const ES: u32, Int: Int> RoundFrom<i32> for Posit<N, ES, Int>

fn round_from(value: i32) -> Self

Convert an i32 into a Posit, rounding according to the standard:

• If the value is i32::MIN (i.e. the value where the most significant bit is 1 and the rest are 0), it converts to NaR.
• Otherwise, the integer value is rounded (if necessary).

impl<const N: u32, const ES: u32, Int: Int> RoundFrom<i64> for Posit<N, ES, Int>

fn round_from(value: i64) -> Self

Convert an i64 into a Posit, rounding according to the standard:

• If the value is i64::MIN (i.e. the value where the most significant bit is 1 and the rest are 0), it converts to NaR.
• Otherwise, the integer value is rounded (if necessary).

impl<const N: u32, const ES: u32, Int: Int> RoundFrom<i8> for Posit<N, ES, Int>

fn round_from(value: i8) -> Self

Convert an i8 into a Posit, rounding according to the standard:

• If the value is i8::MIN (i.e. the value where the most significant bit is 1 and the rest are 0), it converts to NaR.
• Otherwise, the integer value is rounded (if necessary).

impl<const N: u32, const ES: u32, Int: Int> Sub<&Posit<N, ES, Int>> for &Posit<N, ES, Int>

type Output = Posit<N, ES, Int>

The resulting type after applying the - operator.

fn sub(self, rhs: &Posit<N, ES, Int>) -> Self::Output

Performs the - operation.

impl<const N: u32, const ES: u32, Int: Int> Sub<&Posit<N, ES, Int>> for Posit<N, ES, Int>

type Output = Posit<N, ES, Int>

The resulting type after applying the - operator.

fn sub(self, rhs: &Self) -> Self::Output

Performs the - operation.

impl<const N: u32, const ES: u32, Int: Int> Sub<Posit<N, ES, Int>> for &Posit<N, ES, Int>

type Output = Posit<N, ES, Int>

The resulting type after applying the - operator.

fn sub(self, rhs: Posit<N, ES, Int>) -> Self::Output

Performs the - operation.

impl<const N: u32, const ES: u32, Int: Int> Sub for Posit<N, ES, Int>

type Output = Posit<N, ES, Int>

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl<const N: u32, const ES: u32, Int: Int> SubAssign<&Posit<N, ES, Int>> for Posit<N, ES, Int>

fn sub_assign(&mut self, rhs: &Posit<N, ES, Int>)

Performs the -= operation.

impl<const N: u32, const ES: u32, Int: Int, const SIZE: usize> SubAssign<&Posit<N, ES, Int>> for Quire<N, ES, SIZE>

fn sub_assign(&mut self, rhs: &Posit<N, ES, Int>)

Standard: “qSubP”.

Example

let mut quire = q16::from(p16::ONE);
quire -= p16::round_from(0.42);
assert_eq!(p16::round_from(0.58), (&quire).round_into())

impl<const N: u32, const ES: u32, Int: Int, const SIZE: usize> SubAssign<Posit<N, ES, Int>> for Quire<N, ES, SIZE>

fn sub_assign(&mut self, rhs: Posit<N, ES, Int>)

Standard: “qSubP”.

Example

let mut quire = q16::from(p16::ONE);
quire -= p16::round_from(0.42);
assert_eq!(p16::round_from(0.58), (&quire).round_into())

impl<const N: u32, const ES: u32, Int: Int> SubAssign for Posit<N, ES, Int>

fn sub_assign(&mut self, rhs: Posit<N, ES, Int>)

Performs the -= operation.

impl<const N: u32, const ES: u32, Int: Int> Copy for Posit<N, ES, Int>

impl<const N: u32, const ES: u32, Int: Int> Eq for Posit<N, ES, Int>