Struct awint::FP

pub struct FP<B> where
    B: BorrowMut<Bits>,  { /* private fields */ }

Fixed-Point generic struct for B that implement Borrow<Bits> and BorrowMut<Bits>. Adds on signedness and fixed-point information. Implements many traits if B also implements them.

In order to make many operations infallible, self.fp().unsigned_abs() and self.bw() follow an invariant that they are never greater than usize::MAX >> 2.

NOTE: B should not change the bitwidth of the underlying Bits during the lifetime of the FP struct unless the invariants are upheld. Otherwise, panics and arithmetic errors can occur. Preferably, into_b and FP::new should be used to create a fresh struct.

Implementations

impl<B> FP<B> where
    B: BorrowMut<Bits>, 

pub fn new(signed: bool, bits: B, fp: isize) -> Option<FP<B>>

Creates a fixed-point generic FP<B> from a specified signedness signed, wrapped value B, and fixed point fp. This returns None if bits.bw() or fp.unsigned_abs() are greater than usize::MAX >> 2.

pub fn into_b(self) -> B

Consumes this, returning the inner B

pub fn b(&self) -> &B

Returns a reference to the B in self

pub fn b_mut(&mut self) -> &mut B

Returns a mutable reference to the B in self

pub fn const_as_ref(&self) -> &Bits

Returns a reference to self in the form of &Bits

pub fn const_as_mut(&mut self) -> &mut Bits

Returns a reference to self in the form of &mut Bits

pub fn signed(&self) -> bool

Returns the signedness of self

pub fn sign(&self) -> Option<bool>

Returns the sign of self, returning Some(self.const_as_ref().msb()) if self.signed(), and None otherwise.

pub fn is_negative(&self) -> bool

Returns if self.signed() && self.const_as_ref().msb()

pub fn nzbw(&self) -> NonZeroUsize

Returns the bitwidth of self as a NonZeroUsize

pub fn bw(&self) -> usize

Returns the bitwidth of self as a usize

pub fn ibw(&self) -> isize

Returns the bitwidth of self as an isize

pub fn fp(&self) -> isize

Returns the fixed point of self

pub fn fp_ty(&self) -> FPType

Returns the FPType of self. Because FPType impls PartialEq, this is useful for quickly determining if two different FPs have the same fixed point type.

impl<B> FP<B> where
    B: BorrowMut<Bits>, 

These functions are associated to avoid name clashes.

Note: Adding new functions to FP is a WIP

pub fn one_assign(this: &mut FP<B>) -> Option<()>

One-assigns this. Returns None if a positive one value is not representable.

pub fn rel_sb(this: &FP<B>) -> (isize, isize)

Relative significant bit positions, determines the bit positions (inclusive) of the least and most significant bits relative to the fixed point

Note: because the msb position is one less than the bitwidth, the bitwidth is equal to the difference in the bounds plus one

pub fn utruncate_assign(this: &mut FP<B>, rhs: &FP<B>)

The same as FP::truncate_assign except it always intreprets arguments as unsigned

pub fn truncate_assign(this: &mut FP<B>, rhs: &mut FP<B>)

Truncate-assigns rhs to this. For the unsigned case, logically what this does is make this and rhs into concatenations with infinite zeros on both ends, aligns the fixed points, and copies from rhs to this. For the case of rhs.signed(), the absolute value of rhs is used for truncation to this followed by this.neg_assign(rhs.msb() && this.signed()).

pub fn outruncate_assign(this: &mut FP<B>, rhs: &FP<B>) -> (bool, bool)

The same as FP::otruncate_assign except it always intreprets arguments as unsigned

pub fn otruncate_assign(this: &mut FP<B>, rhs: &mut FP<B>) -> (bool, bool)

Overflow-truncate-assigns rhs to this. The same as FP::truncate_assign, except that a tuple of booleans is returned. The first indicates if the least significant numerical bit was truncated, and the second indicates if the most significant numerical bit was truncated. Additionally, if this.is_negative() != rhs.is_negative(), the second overflow is set.

What this means is that if transitive truncations return no overflow, then numerical value is preserved. If only FP::otruncate_assign(...).0 is true, then less significant numerical values were changed and only some kind of truncation rounding has occured to the numerical value. If FP::otruncate_assign(...).1 is true, then the numerical value could be dramatically changed.

pub fn to_vec_general(
    this: &FP<B>,
    radix: u8,
    upper: bool,
    min_integer_chars: usize,
    min_fraction_chars: usize
) -> Result<(Vec<u8, Global>, Vec<u8, Global>), SerdeError>

Creates a tuple of Vec<u8>s representing the integer and fraction parts this (sign indicators, prefixes, points, and postfixes not included). This function performs allocation. This is the inverse of ExtAwi::from_bytes_general and extends the abilities of ExtAwi::bits_to_vec_radix. Signedness and fixed point position information is taken from this. min_integer_chars specifies the minimum number of chars in the integer part, inserting leading ’0’s if there are not enough chars. min_fraction_chars works likewise for the fraction part, inserting trailing ’0’s.

use awint::prelude::*;
// note: a user may want to define their own helper functions to do
// this in one step and combine the output into one string using
// the notation they prefer.

// This creates a fixed point value of -42.1234_i32f16
// (`ExtAwi::from_str` will be able to parse this format in the future
// after more changes to `awint` are made).
let awi = ExtAwi::from_str_general(Some(true), "42", "1234", 0, 10, bw(32), 16).unwrap();
let fp_awi = FP::new(true, awi, 16).unwrap();
assert_eq!(
    // note: in many situations users will want at least 1 zero for
    // both parts so that zero parts result in "0" strings and not "",
    // so `min_..._chars` will be 1. See also
    // `FPType::unique_min_fraction_digits`.
    FP::to_str_general(&fp_awi, 10, false, 1, 1),
    Ok(("42".to_owned(), "1234".to_owned()))
);

Errors

This can only return an error if radix is not in the range 2..=36 or if resource exhaustion occurs.

pub fn to_str_general(
    this: &FP<B>,
    radix: u8,
    upper: bool,
    min_integer_chars: usize,
    min_fraction_chars: usize
) -> Result<(String, String), SerdeError>

Creates a tuple of Strings representing the integer and fraction parts of this. This does the same thing as [FP::to_vec_general] but with Strings.

Methods from Deref<Target = Bits>

pub fn nzbw(&self) -> NonZeroUsize

Returns the bitwidth as a NonZeroUsize

pub fn bw(&self) -> usize

Returns the bitwidth as a usize

pub fn len(&self) -> usize

Returns the exact number of usize digits needed to store all bits.

pub fn clear_unused_bits(&mut self)

Clears the unused bits.

pub fn u8_slice_assign(&'a mut self, buf: &[u8])

Assigns the bits of buf to self. Any bits beyond self.bw() are ignored. This function is portable across target architecture pointer sizes and endianness.

pub fn to_u8_slice(&'a self, buf: &mut [u8])

Assigns the bits of self to buf. Any corresponding bits beyond self.bw() are zeroed. This function is portable across target architecture pointer sizes and endianness.

pub fn zero_assign(&mut self)

Zero-assigns. Same as the Unsigned-minimum-value. All bits are set to 0.

pub fn umax_assign(&mut self)

Unsigned-maximum-value-assigns. All bits are set to 1.

pub fn imax_assign(&mut self)

Signed-maximum-value-assigns. All bits are set to 1, except for the most significant bit.

pub fn imin_assign(&mut self)

Signed-minimum-value-assigns. Only the most significant bit is set.

pub fn uone_assign(&mut self)

Unsigned-one-assigns. Only the least significant bit is set. The unsigned distinction is important, because a positive one value does not exist for signed integers with a bitwidth of 1.

pub fn not_assign(&mut self)

Not-assigns self

pub fn copy_assign(&mut self, rhs: &Bits) -> Option<()>

Copy-assigns the bits of rhs to self

pub fn or_assign(&mut self, rhs: &Bits) -> Option<()>

Or-assigns rhs to self

pub fn and_assign(&mut self, rhs: &Bits) -> Option<()>

And-assigns rhs to self

pub fn xor_assign(&mut self, rhs: &Bits) -> Option<()>

Xor-assigns rhs to self

pub fn range_and_assign(&mut self, range: Range<usize>) -> Option<()>

And-assigns a range of ones to self. Useful for masking. An empty or reversed range zeroes self. None is returned if range.start > self.bw() or range.end > self.bw().

pub fn usize_or_assign(&mut self, rhs: usize, shl: usize)

Or-assigns rhs to self at a position shl. Set bits of rhs that are shifted beyond the bitwidth of self are truncated.

pub fn resize_assign(&mut self, rhs: &Bits, extension: bool)

Resize-copy-assigns rhs to self. If self.bw() >= rhs.bw(), the copied value of rhs will be extended with bits set to extension. If self.bw() < rhs.bw(), the copied value of rhs will be truncated.

pub fn zero_resize_assign(&mut self, rhs: &Bits) -> bool

Zero-resize-copy-assigns rhs to self and returns overflow. This is the same as lhs.resize_assign(rhs, false), but returns true if the unsigned meaning of the integer is changed.

pub fn sign_resize_assign(&mut self, rhs: &Bits) -> bool

Sign-resize-copy-assigns rhs to self and returns overflow. This is the same as lhs.resize_assign(rhs, rhs.msb()), but returns true if the signed meaning of the integer is changed.

pub fn is_zero(&self) -> bool

If self is zero

pub fn is_umax(&self) -> bool

If self is unsigned-maximum

pub fn is_imax(&self) -> bool

If self is signed-maximum

pub fn is_imin(&self) -> bool

If self is signed-minimum

pub fn is_uone(&self) -> bool

If self is unsigned-one

pub fn const_eq(&self, rhs: &Bits) -> Option<bool>

Equality comparison, self == rhs

pub fn const_ne(&self, rhs: &Bits) -> Option<bool>

Not-equal comparison, self != rhs

pub fn ult(&self, rhs: &Bits) -> Option<bool>

Unsigned-less-than comparison, self < rhs

pub fn ule(&self, rhs: &Bits) -> Option<bool>

Unsigned-less-than-or-equal comparison, self <= rhs

pub fn ugt(&self, rhs: &Bits) -> Option<bool>

Unsigned-greater-than comparison, self > rhs

pub fn uge(&self, rhs: &Bits) -> Option<bool>

Unsigned-greater-than-or-equal comparison, self >= rhs

pub fn ilt(&self, rhs: &Bits) -> Option<bool>

Signed-less-than comparison, self < rhs

pub fn ile(&self, rhs: &Bits) -> Option<bool>

Signed-less-than-or-equal comparison, self <= rhs

pub fn igt(&self, rhs: &Bits) -> Option<bool>

Signed-greater-than comparison, self > rhs

pub fn ige(&self, rhs: &Bits) -> Option<bool>

Signed-greater-than-or-equal comparison, self >= rhs

pub fn bytes_radix_assign(
    &mut self,
    sign: Option<bool>,
    src: &[u8],
    radix: u8,
    pad0: &mut Bits,
    pad1: &mut Bits
) -> Result<(), SerdeError>

Assigns to self the integer value represented by src in the given radix. If src should be interpreted as unsigned, sign should be None, otherwise it should be set to the sign. In order for this function to be const, two scratchpads pad0 and pad1 with the same bitwidth as self must be supplied, which can be mutated by the function in arbitrary ways.

Errors

self is not mutated if an error occurs. See crate::SerdeError for error conditions. The characters 0..=9, a..=z, and A..=Z are allowed depending on the radix. The char _ is ignored, and all other chars result in an error. src cannot be empty. The value of the string must be representable in the bitwidth of self with the specified sign, otherwise an overflow error is returned.

pub fn to_bytes_radix(
    &self,
    signed: bool,
    dst: &mut [u8],
    radix: u8,
    upper: bool,
    pad: &mut Bits
) -> Result<(), SerdeError>

Assigns the [u8] representation of self to dst (sign indicators, prefixes, and postfixes not included). signed specifies if self should be interpreted as signed. radix specifies the radix, and upper specifies if letters should be uppercase. In order for this function to be const, a scratchpad pad with the same bitwidth as self must be supplied. Note that if dst.len() is more than what is needed to store the representation, the leading bytes will all be set to b’0’.

Errors

Note: If an error is returned, dst may be set to anything

This function can fail from NonEqualWidths, InvalidRadix, and Overflow (if dst cannot represent the value of self). See crate::SerdeError.

pub fn short_udivide_inplace_assign(&mut self, div: usize) -> Option<usize>

Unsigned-divides self by div, sets self to the quotient, and returns the remainder. Returns None if div == 0.

pub fn short_udivide_assign(&mut self, duo: &Bits, div: usize) -> Option<usize>

pub fn lsb(&self) -> bool

Returns the least significant bit

pub fn msb(&self) -> bool

Returns the most significant bit

pub fn lz(&self) -> usize

Returns the number of leading zero bits

pub fn tz(&self) -> usize

Returns the number of trailing zero bits

pub fn count_ones(&self) -> usize

Returns the number of set ones

pub fn field(
    &mut self,
    to: usize,
    rhs: &Bits,
    from: usize,
    width: usize
) -> Option<()>

“Fielding” bitfields with targeted copy assigns. The bitwidths of self and rhs do not have to be equal, but the inputs must collectively obey width <= self.bw() && width <= rhs.bw() && to <= (self.bw() - width) && from <= (rhs.bw() - width) or else None is returned. width can be zero, in which case this function just checks the input correctness and does not mutate self.

This function works by copying a bw sized bitfield from rhs at bitposition from and overwriting bw bits at bitposition to in self. Only the width bits in self are mutated, any bits before and after the bitfield are left unchanged.

use awint::{Bits, inlawi, InlAwi};
// As an example, two hexadecimal digits will be overwritten
// starting with the 12th digit in `y` using a bitfield with
// value 0x42u8 extracted from `x`.
let x = inlawi!(0x11142111u50);
// the underscores are just for emphasis
let mut y = inlawi!(0xfd_ec_ba9876543210u100);
// from `x` digit place 3, we copy 2 digits to `y` digit place 12.
y.field(12 * 4, &x, 3 * 4, 2 * 4);
assert_eq!(y, inlawi!(0xfd_42_ba9876543210u100));

pub fn lut(&mut self, lut: &Bits, inx: &Bits) -> Option<()>

Copy entry from lookup table. Copies a self.bw() sized bitfield from lut at bit position inx.to_usize() * self.bw(). If lut.bw() != (self.bw() * (2^inx.bw())), None will be returned.

use awint::{Bits, inlawi, InlAwi};
let mut out = inlawi!(0u10);
// lookup table consisting of 4 10-bit entries
let lut = inlawi!(4u10, 3u10, 2u10, 1u10);
// the indexer has to have a bitwidth of 2 to index 2^2 = 4 entries
let mut inx = inlawi!(0u2);

// get the third entry (this is using zero indexing)
inx.usize_assign(2);
out.lut(&lut, &inx).unwrap();
assert_eq!(out, inlawi!(3u10));

pub fn lut_set(&mut self, entry: &Bits, inx: &Bits) -> Option<()>

Set entry in lookup table. The inverse of Bits::lut, this uses entry as a bitfield to overwrite part of self at bit position inx.to_usize() * entry.bw(). If self.bw() != (entry.bw() * (2^inx.bw())), None will be returned.

pub fn short_cin_mul(&mut self, cin: usize, rhs: usize) -> usize

Assigns cin + (self * rhs) to self and returns the overflow

pub fn short_mul_add_assign(&mut self, lhs: &Bits, rhs: usize) -> Option<bool>

Add-assigns lhs * rhs to self and returns if overflow happened

pub fn mul_add_assign(&mut self, lhs: &Bits, rhs: &Bits) -> Option<()>

Multiplies lhs by rhs and add-assigns the product to self. Three operands eliminates the need for an allocating temporary.

pub fn mul_assign(&mut self, rhs: &Bits, pad: &mut Bits) -> Option<()>

Multiply-assigns self by rhs. pad is a scratchpad that will be mutated arbitrarily.

pub fn arb_umul_add_assign(&mut self, lhs: &Bits, rhs: &Bits)

Arbitrarily-unsigned-multiplies lhs by rhs and add-assigns the product to self. This function is equivalent to:

use awint::prelude::*;

fn arb_umul_assign(add: &mut Bits, lhs: &Bits, rhs: &Bits) {
    let mut resized_lhs = ExtAwi::zero(add.nzbw());
    // Note that this function is specified as unsigned,
    // because we use `zero_resize_assign`
    resized_lhs.zero_resize_assign(lhs);
    let mut resized_rhs = ExtAwi::zero(add.nzbw());
    resized_rhs.zero_resize_assign(rhs);
    add.mul_add_assign(&resized_lhs, &resized_rhs).unwrap();
}

except that it avoids allocation and is more efficient overall

pub fn arb_imul_add_assign(&mut self, lhs: &mut Bits, rhs: &mut Bits)

Arbitrarily-signed-multiplies lhs by rhs and add-assigns the product to self. duo and div are marked mutable but their values are not changed by this function.

pub fn shl_assign(&mut self, s: usize) -> Option<()>

Left-shifts-assigns by s bits. If s >= self.bw(), then None is returned and the Bits are left unchanged.

Left shifts can act as a very fast multiplication by a power of two for both the signed and unsigned interpretation of Bits.

pub fn lshr_assign(&mut self, s: usize) -> Option<()>

Logically-right-shift-assigns by s bits. If s >= self.bw(), then None is returned and the Bits are left unchanged.

Logical right shifts do not copy the sign bit, and thus can act as a very fast floored division by a power of two for the unsigned interpretation of Bits.

pub fn ashr_assign(&mut self, s: usize) -> Option<()>

Arithmetically-right-shift-assigns by s bits. If s >= self.bw(), then None is returned and the Bits are left unchanged.

Arithmetic right shifts copy the sign bit, and thus can act as a very fast floored division by a power of two for the signed interpretation of Bits.

pub fn rotl_assign(&mut self, s: usize) -> Option<()>

Left-rotate-assigns by s bits. If s >= self.bw(), then None is returned and the Bits are left unchanged.

This function is equivalent to the following:

use awint::{extawi, inlawi, Bits, ExtAwi, InlAwi};
let mut input = inlawi!(0x4321u16);
let mut output = inlawi!(0u16);
// rotate left by 4 bits or one hexadecimal digit
let shift = 4;

output.copy_assign(&input).unwrap();
// temporary clone of the input
let mut tmp = ExtAwi::from(input);
if shift != 0 {
    if shift >= input.bw() {
        panic!();
    }
    output.shl_assign(shift).unwrap();
    tmp.lshr_assign(input.bw() - shift).unwrap();
    output.or_assign(&tmp);
};

assert_eq!(output, inlawi!(0x3214u16));
let mut using_rotate = ExtAwi::from(input);
using_rotate.rotl_assign(shift).unwrap();
assert_eq!(using_rotate, extawi!(0x3214u16));

// Note that slices are typed in a little-endian order opposite of
// how integers are typed, but they still visually rotate in the
// same way. This means `Rust`s built in slice rotation is in the
// opposite direction to integers and `Bits`
let mut array = [4, 3, 2, 1];
array.rotate_left(1);
assert_eq!(array, [3, 2, 1, 4]);
assert_eq!(0x4321u16.rotate_left(4), 0x3214);
let mut x = inlawi!(0x4321u16);
x.rotl_assign(4);
// `Bits` has the preferred endianness
assert_eq!(x, inlawi!(0x3214u16));

Unlike the example above which needs cloning, this function avoids any allocation and has many optimized branches for different input sizes and shifts.

pub fn rotr_assign(&mut self, s: usize) -> Option<()>

Right-rotate-assigns by s bits. If s >= self.bw(), then None is returned and the Bits are left unchanged.

See Bits::rotl_assign for more details.

pub fn rev_assign(&mut self)

Reverse-bit-order-assigns self. The least significant bit becomes the most significant bit, the second least significant bit becomes the second most significant bit, etc.

pub fn funnel(&mut self, rhs: &Bits, s: &Bits) -> Option<()>

Funnel shift with power-of-two bitwidths. Returns None if 2*self.bw() != rhs.bw() || 2^s.bw() != self.bw(). A self.bw() sized field is assigned to self from rhs starting from the bit position s. The shift cannot overflow because of the restriction on the bitwidth of s.

pub fn usize_assign(&mut self, x: usize)

pub fn isize_assign(&mut self, x: isize)

pub fn u8_assign(&mut self, x: u8)

pub fn i8_assign(&mut self, x: i8)

pub fn u16_assign(&mut self, x: u16)

pub fn i16_assign(&mut self, x: i16)

pub fn u32_assign(&mut self, x: u32)

pub fn i32_assign(&mut self, x: i32)

pub fn u64_assign(&mut self, x: u64)

pub fn i64_assign(&mut self, x: i64)

pub fn u128_assign(&mut self, x: u128)

pub fn i128_assign(&mut self, x: i128)

pub fn bool_assign(&mut self, x: bool)

pub fn to_usize(&self) -> usize

pub fn to_isize(&self) -> isize

pub fn to_u8(&self) -> u8

pub fn to_i8(&self) -> i8

pub fn to_u16(&self) -> u16

pub fn to_i16(&self) -> i16

pub fn to_u32(&self) -> u32

pub fn to_i32(&self) -> i32

pub fn to_u64(&self) -> u64

pub fn to_i64(&self) -> i64

pub fn to_u128(&self) -> u128

pub fn to_i128(&self) -> i128

pub fn to_bool(&self) -> bool

pub fn inc_assign(&mut self, cin: bool) -> bool

Increment-assigns self with a carry-in cin and returns the carry-out bit. If cin == true then one is added to self, otherwise nothing happens. false is always returned unless self.is_umax().

pub fn dec_assign(&mut self, cin: bool) -> bool

Decrement-assigns self with a carry-in cin and returns the carry-out bit. If cin == false then one is subtracted from self, otherwise nothing happens. true is always returned unless self.is_zero().

pub fn neg_assign(&mut self, neg: bool)

Negate-assigns self if neg is true. Note that signed minimum values will overflow.

pub fn abs_assign(&mut self)

Absolute-value-assigns self. Note that signed minimum values will overflow, unless self is interpreted as unsigned after a call to this function.

pub fn add_assign(&mut self, rhs: &Bits) -> Option<()>

Add-assigns by rhs

pub fn sub_assign(&mut self, rhs: &Bits) -> Option<()>

Subtract-assigns by rhs

pub fn rsb_assign(&mut self, rhs: &Bits) -> Option<()>

Reverse-subtract-assigns by rhs. Sets self to (-self) + rhs.

pub fn neg_add_assign(&mut self, neg: bool, rhs: &Bits) -> Option<()>

Negate-add-assigns by rhs. Negates conditionally on neg.

pub fn cin_sum_assign(
    &mut self,
    cin: bool,
    lhs: &Bits,
    rhs: &Bits
) -> Option<(bool, bool)>

A general summation with carry-in cin and two inputs lhs and rhs. self is set to the sum. The unsigned overflow (equivalent to the carry-out bit) and the signed overflow is returned as a tuple. None is returned if any bitwidths do not match. If subtraction is desired, one of the operands can be negated.

Trait Implementations

impl<B> Binary for FP<B> where
    B: Binary + BorrowMut<Bits>, 

Forwards to the corresponding impl for Bits

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

Formats the value using the given formatter.

impl<B> Clone for FP<B> where
    B: Clone + BorrowMut<Bits>, 

fn clone(&self) -> FP<B>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<B> Debug for FP<B> where
    B: Debug + BorrowMut<Bits>, 

Forwards to the corresponding impl for Bits

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

Formats the value using the given formatter.

impl<B> Deref for FP<B> where
    B: BorrowMut<Bits>, 

type Target = Bits

The resulting type after dereferencing.

fn deref(&self) -> &<FP<B> as Deref>::Target

Dereferences the value.

impl<B> DerefMut for FP<B> where
    B: BorrowMut<Bits>, 

fn deref_mut(&mut self) -> &mut Bits

Mutably dereferences the value.

impl<B> Display for FP<B> where
    B: Display + BorrowMut<Bits>, 

Forwards to the corresponding impl for Bits

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

Formats the value using the given formatter.

impl<B> Hash for FP<B> where
    B: Hash + BorrowMut<Bits>, 

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

Uses the hash of self.signed(), self.fp(), and the Hash implementation on FP::into_inner(self) (not self.const_as_ref())

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

Feeds a slice of this type into the given Hasher.

impl<B> LowerHex for FP<B> where
    B: LowerHex + BorrowMut<Bits>, 

Forwards to the corresponding impl for Bits

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

Formats the value using the given formatter.

impl<B> Octal for FP<B> where
    B: Octal + BorrowMut<Bits>, 

Forwards to the corresponding impl for Bits

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

Formats the value using the given formatter.

impl<B> PartialEq<FP<B>> for FP<B> where
    B: PartialEq<B> + BorrowMut<Bits>, 

fn eq(&self, rhs: &FP<B>) -> bool

The signedness, fixed point, and PartialEq implementation on FP::into_inner(self) must all be true in order for this to return true

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

This method tests for !=.

impl<B> UpperHex for FP<B> where
    B: UpperHex + BorrowMut<Bits>, 

Forwards to the corresponding impl for Bits

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

Formats the value using the given formatter.

impl<B> Eq for FP<B> where
    B: PartialEq<B> + Eq + BorrowMut<Bits>,