Struct Signed

pub struct Signed<const L: u32>(/* private fields */);

Signed bitvector.

The number of bits is specified in the generic parameter L. Signed bitvectors support bitwise operations and wrapping-arithmetic operations. Arithmetic bit extension is also possible (the sign bit is copied into any bits above it). Signed bitvectors be converted into Unsigned or Bitvector.

Currently, it is not possible to create signed bitvectors directly, only convert into them.

Trait Implementations

impl<const L: u32> Add for Signed<L>

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

Performs wrapping addition.

type Output = Signed<L>

The resulting type after applying the + operator.

impl<const L: u32> BitAnd for Signed<L>

fn bitand(self, rhs: Signed<L>) -> Self::Output

Performs bitwise AND.

type Output = Signed<L>

The resulting type after applying the & operator.

impl<const L: u32> BitOr for Signed<L>

fn bitor(self, rhs: Signed<L>) -> Self::Output

Performs bitwise OR.

type Output = Signed<L>

The resulting type after applying the | operator.

impl<const L: u32> BitXor for Signed<L>

fn bitxor(self, rhs: Signed<L>) -> Self::Output

Performs bitwise XOR.

type Output = Signed<L>

The resulting type after applying the ^ operator.

impl<const L: u32> Clone for Signed<L>

fn clone(&self) -> Signed<L>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<const L: u32> Debug for Signed<L>

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

Formats the value using the given formatter.

impl<const L: u32> Div for Signed<L>

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

Performs wrapping signed division.

This behaves as Rust wrapping_div, where the result of MIN / -1, which would be unrepresentable -MIN, is wrapped to MIN.

Panics

Panics if rhs is zero.

type Output = Signed<L>

The resulting type after applying the / operator.

impl<const L: u32, const X: u32> Ext<X> for Signed<L>

fn ext(self) -> Self::Output

Extends or narrows the bit-vector.

If an extension is performed, the upper bits are the copy of the original sign bit.

type Output = Signed<X>

impl<const L: u32> From<Bitvector<L>> for Signed<L>

fn from(value: Bitvector<L>) -> Self

Adds signedness information to Bitvector.

impl<const L: u32> From<Signed<L>> for Bitvector<L>

fn from(value: Signed<L>) -> Self

Drops the signedness information from Signed.

impl<const L: u32> From<Signed<L>> for Unsigned<L>

fn from(value: Signed<L>) -> Self

Converts the signedness information from Signed to Unsigned.

impl<const L: u32> From<Unsigned<L>> for Signed<L>

fn from(value: Unsigned<L>) -> Self

Converts the signedness information from Unsigned to Signed.

impl<const L: u32> Hash for Signed<L>

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 L: u32> Mul for Signed<L>

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

Performs wrapping multiplication.

type Output = Signed<L>

The resulting type after applying the * operator.

impl<const L: u32> Not for Signed<L>

fn not(self) -> Self::Output

Performs bitwise NOT.

type Output = Signed<L>

The resulting type after applying the ! operator.

impl<const L: u32> Ord for Signed<L>

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 L: u32> PartialEq for Signed<L>

fn eq(&self, other: &Signed<L>) -> 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 L: u32> PartialOrd for Signed<L>

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 L: u32> Rem for Signed<L>

fn rem(self, rhs: Signed<L>) -> Self::Output

Performs wrapping signed division.

This behaves as Rust wrapping_rem, where the result of MIN % -1, is defined as 0.

Panics

Panics if rhs is zero.

type Output = Signed<L>

The resulting type after applying the % operator.

impl<const L: u32> Shl for Signed<L>

fn shl(self, rhs: Signed<L>) -> Self::Output

Performs a left shift.

Unlike a right shift, where the behaviour is dependent on signedness, the left shift has the same behaviour: shifted-out bits on the left are discarded and zeros are shifted in on the right.

The right-hand side operand is interpreted as unsigned and if it is equal or greater to the bit-width, the result is all-zeros, as in Rust unbounded_shl. It is planned to restrict the bit-width in the future so that this edge case can never occur.

Note that this means that shifting left with a negative right operand produces an all-zeros value.

type Output = Signed<L>

The resulting type after applying the << operator.

impl<const L: u32> Shr for Signed<L>

fn shr(self, rhs: Signed<L>) -> Self::Output

Performs an arithmetic right shift.

The right-hand side operand is interpreted as unsigned and if it is equal or greater to the bit-width, the result is all-zeros or all-ones depending on the original sign bit, as in Rust unbounded_shr on signed primitives. It is planned to restrict the bit-width in the future so that this edge case can never occur.

Note that this means that shifting right with a negative right operand produces an all-zeros or all-ones value, depending on the original sign bit.

type Output = Signed<L>

The resulting type after applying the >> operator.

impl<const L: u32> Sub for Signed<L>

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

Performs wrapping subtraction.

type Output = Signed<L>

The resulting type after applying the - operator.

impl<const L: u32> Copy for Signed<L>

impl<const L: u32> Eq for Signed<L>

impl<const L: u32> StructuralPartialEq for Signed<L>