Struct BitVec 

pub struct BitVec { /* private fields */ }

An exact W-bit value, W in 1..=512.

Implementations

impl BitVec

pub fn zero(width: Width) -> Self

Zero.

pub fn one(width: Width) -> Self

One.

pub fn ones(width: Width) -> Self

All ones (-1 as a signed value).

pub fn smin(width: Width) -> Self

The most negative signed value (only the top bit set).

pub fn smax(width: Width) -> Self

The most positive signed value (every bit but the top set).

pub fn from_u64(width: Width, v: u64) -> Result<Self, ValueError>

v, which must fit in width bits as an unsigned value.

pub fn from_u128(width: Width, v: u128) -> Result<Self, ValueError>

v, which must fit in width bits as an unsigned value.

pub fn from_i128(width: Width, v: i128) -> Result<Self, ValueError>

v, which must be representable as a width-bit signed value.

pub fn wrapping_from_u64(width: Width, v: u64) -> Self

v truncated to width bits.

pub fn wrapping_from_u128(width: Width, v: u128) -> Self

v truncated to width bits.

pub fn wrapping_from_i128(width: Width, v: i128) -> Self

v in two’s complement, sign-extended or truncated to width bits.

pub fn from_limbs(width: Width, limbs: &[u64]) -> Result<Self, ValueError>

Little-endian limbs, which must not have bits set at or above width.

pub fn wrapping_from_limbs(width: Width, limbs: &[u64]) -> Self

Little-endian limbs truncated to width bits.

pub fn width(&self) -> Width

The width.

pub fn limbs(&self) -> &[u64]

The ceil(W / 64) active little-endian limbs.

pub fn to_u64(&self) -> Option<u64>

The unsigned value, if it fits in a u64.

pub fn to_u128(&self) -> Option<u128>

The unsigned value, if it fits in a u128.

pub fn to_i128(&self) -> Option<i128>

The signed (two’s-complement) value, if it fits in an i128.

pub fn bit(&self, i: u16) -> Option<bool>

Bit i, or None if i >= W.

pub fn msb(&self) -> bool

The sign (most significant) bit.

pub fn is_zero(&self) -> bool

Whether the value is zero.

pub fn is_ones(&self) -> bool

Whether every bit is set.

pub fn apply_un(op: UnOp, a: &BitVec) -> Result<BitVec, WidthError>

Applies a unary operator. The only error is Bswap at a width that is not a multiple of 8.

pub fn apply_bin( op: BinOp, a: &BitVec, b: &BitVec, ) -> Result<BitVec, WidthError>

Applies a binary operator. Both operands must have the same width.

pub fn apply_cmp( op: impl Into<CmpOpExt>, a: &BitVec, b: &BitVec, ) -> Result<bool, WidthError>

Evaluates a comparison. Both operands must have the same width.

pub fn zext(&self, to: Width) -> Result<BitVec, WidthError>

Zero extension to to, which must be at least as wide (equal width is the identity).

pub fn sext(&self, to: Width) -> Result<BitVec, WidthError>

Sign extension to to, which must be at least as wide (equal width is the identity).

pub fn trunc(&self, to: Width) -> Result<BitVec, WidthError>

The low to bits (to must not exceed the width).

pub fn extract(&self, lo: u16, len: Width) -> Result<BitVec, WidthError>

Bits [lo, lo + len).

pub fn concat(hi: &BitVec, lo: &BitVec) -> Result<BitVec, WidthError>

hi in the high bits and lo in the low bits.

pub fn select(c: &BitVec, t: &BitVec, f: &BitVec) -> Result<BitVec, WidthError>

if c { t } else { f } for a 1-bit condition.

pub fn from_bool(b: bool) -> BitVec

A 1-bit value from a boolean.

pub fn parse(s: &str) -> Result<BitVec, ParseError>

Parses <digits>:<width>, where digits are decimal (optionally negative), 0x hex or 0b binary, or the Verilog form <width>'h<hex> / 'd / 'b.

use bitwright::{BitVec, Width};
assert_eq!(BitVec::parse("0xff:8").unwrap(), BitVec::ones(Width::W8));
assert_eq!(BitVec::parse("-1:32").unwrap(), BitVec::ones(Width::W32));
assert_eq!(BitVec::parse("8'h80").unwrap(), BitVec::smin(Width::W8));

Trait Implementations

impl Clone for BitVec

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for BitVec

impl Debug for BitVec

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

Formats the value using the given formatter.

impl Display for BitVec

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

0x<hex>:<width>, the form accepted by BitVec::parse.

impl Eq for BitVec

impl FromStr for BitVec

type Err = ParseError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, ParseError>

Parses a string s to return a value of this type.

impl Hash for BitVec

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 LowerHex for BitVec

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

The value in lower-case hexadecimal, without prefix or width.

impl Ord for BitVec

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

By width, then by unsigned value. (A total order for sorting and canonical keys; use BitVec::apply_cmp for signed or unsigned comparison of same-width values.)

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.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

🔬This is a nightly-only experimental API. (clamp_to)

Restrict a value to a certain range.

impl PartialEq for BitVec

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

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for BitVec

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 StructuralPartialEq for BitVec