#[repr(C)]pub struct InlAwi<const BW: usize, const LEN: usize> { /* private fields */ }
Expand description
An arbitrary width integer with const generic bitwidth that can be stored inline on the stack like an array.
NOTE: Ideally, you could just type
let _: InlAwi<100> = InlAwi<100>::zero();
if you wanted to specify and
construct an InlAwi
type with bitwidth 100. However, Rust’s lack of custom
DST support and const generics limitations makes this currently impossible.
The two const generic parameters of an InlAwi
are part of a workaround for
this. Typing out a
let _: InlAwi<BW, LEN> = InlAwi<BW, LEN>::zero()
should not be
done directly because it is non-portable and relies on unstable internal
details. Instead, you should use
let _: inlawi_ty!(100) = inlawi!(0u100);
or let _ = <inlawi_ty!(100)>::zero();
using macros from the awint_macros
crate.
See the crate level documentation of awint_macros
for more macros and
information.
This struct implements Deref<Target = Bits>
, see the main documentation of
Bits for more. There are also some allocating functions that
only ExtAwi
and Awi
implement.
use awint::{cc, inlawi, inlawi_ty, Bits, InlAwi};
fn example(mut lhs: &mut Bits, rhs: &Bits) {
// `InlAwi` stored on the stack does no allocation
let mut tmp = inlawi!(0i100);
tmp.mul_add_(lhs, rhs).unwrap();
cc!(tmp; lhs).unwrap();
}
let val: inlawi_ty!(100) = {
let mut x = inlawi!(123i100);
let y = inlawi!(2i100);
x.neg_(true);
example(&mut x, &y);
x
};
let x: &Bits = &val;
assert_eq!(x, inlawi!(-246i100).as_ref());
// note: see README because this is broken on some nightlies
// only needed if you are trying to use in `const` contexts
#![feature(const_trait_impl)]
#![feature(const_mut_refs)]
#![feature(const_option)]
use awint::{cc, inlawi, inlawi_ty, Bits, InlAwi};
const fn const_example(mut lhs: &mut Bits, rhs: &Bits) {
// `InlAwi` stored on the stack does no allocation
let mut tmp = inlawi!(0i100);
tmp.mul_add_(lhs, rhs).unwrap();
cc!(tmp; lhs).unwrap();
}
// Because `InlAwi`'s construction functions are `const`, we can make full
// use of `Bits` `const` abilities
const AWI: inlawi_ty!(100) = {
let mut x = inlawi!(123i100);
let y = inlawi!(2i100);
x.neg_(true);
const_example(&mut x, &y);
x
};
const X: &'static Bits = &AWI;
assert_eq!(X, inlawi!(-246i100).as_ref());
Implementations§
source§impl<'a, const BW: usize, const LEN: usize> InlAwi<BW, LEN>
impl<'a, const BW: usize, const LEN: usize> InlAwi<BW, LEN>
sourcepub fn const_nzbw() -> NonZero<usize>
pub fn const_nzbw() -> NonZero<usize>
Returns the bitwidth of this type of InlAwi
as a NonZeroUsize
sourcepub fn nzbw(&self) -> NonZero<usize>
pub fn nzbw(&self) -> NonZero<usize>
The same as Self::const_nzbw()
except that it takes &self
, this
exists to help with macros
sourcepub fn bw(&self) -> usize
pub fn bw(&self) -> usize
The same as Self::const_bw()
except that it takes &self
, this exists
to help with macros
sourcepub fn total_digits(&self) -> usize
pub fn total_digits(&self) -> usize
Returns the exact number of Digit
s needed to store all bits.
source§impl InlAwi<8, awint_core::::data::inlawi::{impl#17}::{constant#1}>
impl InlAwi<8, awint_core::::data::inlawi::{impl#17}::{constant#1}>
source§impl InlAwi<16, awint_core::::data::inlawi::{impl#18}::{constant#1}>
impl InlAwi<16, awint_core::::data::inlawi::{impl#18}::{constant#1}>
source§impl InlAwi<32, awint_core::::data::inlawi::{impl#19}::{constant#1}>
impl InlAwi<32, awint_core::::data::inlawi::{impl#19}::{constant#1}>
source§impl InlAwi<64, awint_core::::data::inlawi::{impl#20}::{constant#1}>
impl InlAwi<64, awint_core::::data::inlawi::{impl#20}::{constant#1}>
source§impl InlAwi<128, awint_core::::data::inlawi::{impl#21}::{constant#1}>
impl InlAwi<128, awint_core::::data::inlawi::{impl#21}::{constant#1}>
source§impl InlAwi<awint_core::::data::inlawi::UsizeInlAwi::{constant#0}, awint_core::::data::inlawi::UsizeInlAwi::{constant#1}>
impl InlAwi<awint_core::::data::inlawi::UsizeInlAwi::{constant#0}, awint_core::::data::inlawi::UsizeInlAwi::{constant#1}>
sourcepub fn from_usize(
x: usize
) -> InlAwi<awint_core::::data::inlawi::UsizeInlAwi::{constant#0}, awint_core::::data::inlawi::UsizeInlAwi::{constant#1}>
pub fn from_usize( x: usize ) -> InlAwi<awint_core::::data::inlawi::UsizeInlAwi::{constant#0}, awint_core::::data::inlawi::UsizeInlAwi::{constant#1}>
Creates an InlAwi
with the same bitwidth and bits as the integer
sourcepub fn from_isize(
x: isize
) -> InlAwi<awint_core::::data::inlawi::UsizeInlAwi::{constant#0}, awint_core::::data::inlawi::UsizeInlAwi::{constant#1}>
pub fn from_isize( x: isize ) -> InlAwi<awint_core::::data::inlawi::UsizeInlAwi::{constant#0}, awint_core::::data::inlawi::UsizeInlAwi::{constant#1}>
Creates an InlAwi
with the same bitwidth and bits as the integer
source§impl InlAwi<awint_core::::data::inlawi::DigitInlAwi::{constant#0}, awint_core::::data::inlawi::DigitInlAwi::{constant#1}>
impl InlAwi<awint_core::::data::inlawi::DigitInlAwi::{constant#0}, awint_core::::data::inlawi::DigitInlAwi::{constant#1}>
sourcepub fn from_digit(
x: usize
) -> InlAwi<awint_core::::data::inlawi::DigitInlAwi::{constant#0}, awint_core::::data::inlawi::DigitInlAwi::{constant#1}>
pub fn from_digit( x: usize ) -> InlAwi<awint_core::::data::inlawi::DigitInlAwi::{constant#0}, awint_core::::data::inlawi::DigitInlAwi::{constant#1}>
Creates an InlAwi
with the same bitwidth and bits as Digit
Methods from Deref<Target = Bits>§
sourcepub fn u8_slice_(&'a mut self, buf: &[u8])
pub fn u8_slice_(&'a mut self, buf: &[u8])
Assigns the bits of buf
to self
. If (buf.len() * 8) > self.bw()
then the corresponding bits in buf
beyond self.bw()
are ignored. If
(buf.len() * 8) < self.bw()
then the rest of the bits in self
are
zeroed. This function is portable across target architecture pointer
sizes and endianness.
sourcepub fn to_u8_slice(&'a self, buf: &mut [u8])
pub fn to_u8_slice(&'a self, buf: &mut [u8])
Assigns the bits of self
to buf
. If (buf.len() * 8) > self.bw()
then the corresponding bits in buf
beyond self.bw()
are zeroed. If
(buf.len() * 8) < self.bw()
then the bits of self
beyond the buffer
do nothing. This function is portable across target architecture
pointer sizes and endianness.
sourcepub fn zero_(&mut self)
pub fn zero_(&mut self)
Zero-assigns. Same as the Unsigned-minimum-value. All bits are set to 0.
sourcepub fn imax_(&mut self)
pub fn imax_(&mut self)
Signed-maximum-value-assigns. All bits are set to 1, except for the most significant bit.
sourcepub fn uone_(&mut self)
pub fn uone_(&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.
sourcepub fn range_or_(&mut self, range: Range<usize>) -> Option<()>
pub fn range_or_(&mut self, range: Range<usize>) -> Option<()>
Or-assigns a range of ones to self
. An empty or reversed range does
nothing to self
. None
is returned if range.start > self.bw()
or range.end > self.bw()
.
sourcepub fn range_and_(&mut self, range: Range<usize>) -> Option<()>
pub fn range_and_(&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()
.
sourcepub fn range_xor_(&mut self, range: Range<usize>) -> Option<()>
pub fn range_xor_(&mut self, range: Range<usize>) -> Option<()>
Xor-assigns a range of ones to self
. An empty or reversed range does
nothing to self
. None
is returned if range.start > self.bw()
or range.end > self.bw()
.
sourcepub fn digit_or_(&mut self, rhs: usize, shl: usize)
pub fn digit_or_(&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.
sourcepub fn resize_(&mut self, rhs: &Bits, extension: bool)
pub fn resize_(&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.
sourcepub fn zero_resize_(&mut self, rhs: &Bits) -> bool
pub fn zero_resize_(&mut self, rhs: &Bits) -> bool
Zero-resize-copy-assigns rhs
to self
and returns overflow. This is
the same as lhs.resize_(rhs, false)
, but returns true
if the
unsigned meaning of the integer is changed.
sourcepub fn sign_resize_(&mut self, rhs: &Bits) -> bool
pub fn sign_resize_(&mut self, rhs: &Bits) -> bool
Sign-resize-copy-assigns rhs
to self
and returns overflow. This is
the same as lhs.resize_(rhs, rhs.msb())
, but returns true
if
the signed meaning of the integer is changed.
sourcepub fn ule(&self, rhs: &Bits) -> Option<bool>
pub fn ule(&self, rhs: &Bits) -> Option<bool>
Unsigned-less-than-or-equal comparison, self <= rhs
sourcepub fn uge(&self, rhs: &Bits) -> Option<bool>
pub fn uge(&self, rhs: &Bits) -> Option<bool>
Unsigned-greater-than-or-equal comparison, self >= rhs
sourcepub fn ile(&self, rhs: &Bits) -> Option<bool>
pub fn ile(&self, rhs: &Bits) -> Option<bool>
Signed-less-than-or-equal comparison, self <= rhs
sourcepub fn ige(&self, rhs: &Bits) -> Option<bool>
pub fn ige(&self, rhs: &Bits) -> Option<bool>
Signed-greater-than-or-equal comparison, self >= rhs
sourcepub fn total_cmp(&self, rhs: &Bits) -> Ordering
pub fn total_cmp(&self, rhs: &Bits) -> Ordering
Total ordering over bitstrings, including differentiation between
differing bitwidths of self
and rhs
. This orders first on bitwidth
and then on unsigned value.
sourcepub fn bytes_radix_(
&mut self,
sign: Option<bool>,
src: &[u8],
radix: u8,
pad0: &mut Bits,
pad1: &mut Bits
) -> Result<(), SerdeError>
pub fn bytes_radix_( &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.
sourcepub fn to_bytes_radix(
&self,
signed: bool,
dst: &mut [u8],
radix: u8,
upper: bool,
pad: &mut Bits
) -> Result<(), SerdeError>
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.
sourcepub fn digit_udivide_inplace_(&mut self, div: usize) -> Option<usize>
pub fn digit_udivide_inplace_(&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 digit_udivide_(&mut self, duo: &Bits, div: usize) -> Option<usize>
sourcepub fn get(&self, inx: usize) -> Option<bool>
pub fn get(&self, inx: usize) -> Option<bool>
Gets the bit at inx
bits from the least significant bit, returning
None
if inx >= self.bw()
sourcepub fn set(&mut self, inx: usize, bit: bool) -> Option<()>
pub fn set(&mut self, inx: usize, bit: bool) -> Option<()>
Sets the bit at inx
bits from the least significant bit, returning
None
if inx >= self.bw()
sourcepub fn count_ones(&self) -> usize
pub fn count_ones(&self) -> usize
Returns the number of set ones
sourcepub fn field(
&mut self,
to: usize,
rhs: &Bits,
from: usize,
width: usize
) -> Option<()>
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 width
sized bitfield from rhs
at
bitposition from
and overwriting width
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::{inlawi, Bits, 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));
sourcepub fn field_to(&mut self, to: usize, rhs: &Bits, width: usize) -> Option<()>
pub fn field_to(&mut self, to: usize, rhs: &Bits, width: usize) -> Option<()>
A specialization of Bits::field with from
set to 0.
sourcepub fn field_from(
&mut self,
rhs: &Bits,
from: usize,
width: usize
) -> Option<()>
pub fn field_from( &mut self, rhs: &Bits, from: usize, width: usize ) -> Option<()>
A specialization of Bits::field with to
set to 0.
sourcepub fn field_width(&mut self, rhs: &Bits, width: usize) -> Option<()>
pub fn field_width(&mut self, rhs: &Bits, width: usize) -> Option<()>
A specialization of Bits::field with to
and from
set to 0.
sourcepub fn field_bit(&mut self, to: usize, rhs: &Bits, from: usize) -> Option<()>
pub fn field_bit(&mut self, to: usize, rhs: &Bits, from: usize) -> Option<()>
A specialization of Bits::field with width
set to 1.
sourcepub fn lut_(&mut self, lut: &Bits, inx: &Bits) -> Option<()>
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::{inlawi, Bits, 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_(2);
out.lut_(&lut, &inx).unwrap();
assert_eq!(out, inlawi!(3u10));
sourcepub fn lut_set(&mut self, entry: &Bits, inx: &Bits) -> Option<()>
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.
sourcepub fn mux_(&mut self, rhs: &Bits, b: bool) -> Option<()>
pub fn mux_(&mut self, rhs: &Bits, b: bool) -> Option<()>
Multiplex by conditionally copy-assigning rhs
to self
if b
sourcepub fn repeat_(&mut self, rhs: &Bits)
pub fn repeat_(&mut self, rhs: &Bits)
Repeat-assigns self
by rhs
. This is logically equivalent to
concatenating an infinite number of rhs
bit strings together, then
resize-assigning to self
.
sourcepub fn digit_cin_mul_(&mut self, cin: usize, rhs: usize) -> usize
pub fn digit_cin_mul_(&mut self, cin: usize, rhs: usize) -> usize
Assigns cin + (self * rhs)
to self
and returns the overflow
sourcepub fn digit_mul_add_(&mut self, lhs: &Bits, rhs: usize) -> Option<bool>
pub fn digit_mul_add_(&mut self, lhs: &Bits, rhs: usize) -> Option<bool>
Add-assigns lhs * rhs
to self
and returns if overflow happened
sourcepub fn mul_add_(&mut self, lhs: &Bits, rhs: &Bits) -> Option<()>
pub fn mul_add_(&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.
sourcepub fn mul_(&mut self, rhs: &Bits, pad: &mut Bits) -> Option<()>
pub fn mul_(&mut self, rhs: &Bits, pad: &mut Bits) -> Option<()>
Multiply-assigns self
by rhs
. pad
is a scratchpad that will be
mutated arbitrarily.
sourcepub fn arb_umul_add_(&mut self, lhs: &Bits, rhs: &Bits)
pub fn arb_umul_add_(&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::awi::*;
fn arb_umul_(add: &mut Bits, lhs: &Bits, rhs: &Bits) {
let mut resized_lhs = Awi::zero(add.nzbw());
// Note that this function is specified as unsigned,
// because we use `zero_resize_`
resized_lhs.zero_resize_(lhs);
let mut resized_rhs = Awi::zero(add.nzbw());
resized_rhs.zero_resize_(rhs);
add.mul_add_(&resized_lhs, &resized_rhs).unwrap();
}
except that it avoids allocation and is more efficient overall
sourcepub fn arb_imul_add_(&mut self, lhs: &mut Bits, rhs: &mut Bits)
pub fn arb_imul_add_(&mut self, lhs: &mut Bits, rhs: &mut Bits)
Arbitrarily-signed-multiplies lhs
by rhs
and add-assigns the product
to self
. Has the same behavior as Bits::arb_umul_add_ except that is
interprets the arguments as signed. lhs
and rhs
are marked
mutable but their values are not changed by this function.
sourcepub fn shl_(&mut self, s: usize) -> Option<()>
pub fn shl_(&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
.
sourcepub fn lshr_(&mut self, s: usize) -> Option<()>
pub fn lshr_(&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
.
sourcepub fn ashr_(&mut self, s: usize) -> Option<()>
pub fn ashr_(&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
.
sourcepub fn rotl_(&mut self, s: usize) -> Option<()>
pub fn rotl_(&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::awi::*;
let mut input = inlawi!(0x4321u16);
let mut output = inlawi!(0u16);
// rotate left by 4 bits or one hexadecimal digit
let shift = 4;
// temporary clone of the input
let mut tmp = Awi::from(input);
cc!(input; output).unwrap();
if shift != 0 {
if shift >= input.bw() {
// the actual function would return `None`
panic!();
}
output.shl_(shift).unwrap();
tmp.lshr_(input.bw() - shift).unwrap();
output.or_(&tmp);
};
assert_eq!(output, inlawi!(0x3214u16));
let mut using_rotate = Awi::from(input);
using_rotate.rotl_(shift).unwrap();
assert_eq!(using_rotate, awi!(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_(4).unwrap();
// `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.
sourcepub fn rotr_(&mut self, s: usize) -> Option<()>
pub fn rotr_(&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_ for more details.
sourcepub fn rev_(&mut self)
pub fn rev_(&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.
sourcepub fn funnel_(&mut self, rhs: &Bits, s: &Bits) -> Option<()>
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
.
use awint::awi::*;
let mut lhs = inlawi!(0xffff_ffffu32);
let mut rhs = inlawi!(0xfedc_ba98_7654_3210u64);
// `lhs.bw()` must be a power of two, `s.bw()` here is
// `log_2(32) == 5`. The value of `s` is set to what bit
// of `rhs` should be the starting bit for `lhs`.
let mut s = inlawi!(12u5);
lhs.funnel_(&rhs, &s).unwrap();
assert_eq!(lhs, inlawi!(0xa9876543_u32))
pub fn u8_(&mut self, x: u8)
pub fn i8_(&mut self, x: i8)
pub fn u16_(&mut self, x: u16)
pub fn i16_(&mut self, x: i16)
pub fn u32_(&mut self, x: u32)
pub fn i32_(&mut self, x: i32)
pub fn u64_(&mut self, x: u64)
pub fn i64_(&mut self, x: i64)
pub fn u128_(&mut self, x: u128)
pub fn i128_(&mut self, x: i128)
pub fn usize_(&mut self, x: usize)
pub fn isize_(&mut self, x: isize)
pub fn bool_(&mut self, x: bool)
pub fn digit_(&mut self, x: usize)
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_usize(&self) -> usize
pub fn to_isize(&self) -> isize
pub fn to_bool(&self) -> bool
pub fn to_digit(&self) -> usize
sourcepub fn inc_(&mut self, cin: bool) -> bool
pub fn inc_(&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()
.
sourcepub fn dec_(&mut self, cin: bool) -> bool
pub fn dec_(&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()
.
sourcepub fn neg_(&mut self, neg: bool)
pub fn neg_(&mut self, neg: bool)
Negate-assigns self
if neg
is true. Note that signed minimum values
will overflow.
sourcepub fn abs_(&mut self)
pub fn abs_(&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.
sourcepub fn rsb_(&mut self, rhs: &Bits) -> Option<()>
pub fn rsb_(&mut self, rhs: &Bits) -> Option<()>
Reverse-subtract-assigns by rhs
. Sets self
to (-self) + rhs
.
sourcepub fn neg_add_(&mut self, neg: bool, rhs: &Bits) -> Option<()>
pub fn neg_add_(&mut self, neg: bool, rhs: &Bits) -> Option<()>
Negate-add-assigns by rhs
. Negates conditionally on neg
.
sourcepub fn cin_sum_(
&mut self,
cin: bool,
lhs: &Bits,
rhs: &Bits
) -> Option<(bool, bool)>
pub fn cin_sum_( &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§
source§impl<const BW: usize, const LEN: usize> BorrowMut<Bits> for InlAwi<BW, LEN>
impl<const BW: usize, const LEN: usize> BorrowMut<Bits> for InlAwi<BW, LEN>
source§fn borrow_mut(&mut self) -> &mut Bits
fn borrow_mut(&mut self) -> &mut Bits
source§impl<const BW: usize, const LEN: usize> From<InlAwi<BW, LEN>> for Awi
impl<const BW: usize, const LEN: usize> From<InlAwi<BW, LEN>> for Awi
Creates an Awi
from copying an InlAwi
source§impl<const BW: usize, const LEN: usize> From<InlAwi<BW, LEN>> for ExtAwi
impl<const BW: usize, const LEN: usize> From<InlAwi<BW, LEN>> for ExtAwi
Creates an ExtAwi
from copying an InlAwi
source§impl From<isize> for InlAwi<awint_core::::data::inlawi::UsizeInlAwi::{constant#0}, awint_core::::data::inlawi::UsizeInlAwi::{constant#1}>
impl From<isize> for InlAwi<awint_core::::data::inlawi::UsizeInlAwi::{constant#0}, awint_core::::data::inlawi::UsizeInlAwi::{constant#1}>
source§impl From<usize> for InlAwi<awint_core::::data::inlawi::UsizeInlAwi::{constant#0}, awint_core::::data::inlawi::UsizeInlAwi::{constant#1}>
impl From<usize> for InlAwi<awint_core::::data::inlawi::UsizeInlAwi::{constant#0}, awint_core::::data::inlawi::UsizeInlAwi::{constant#1}>
source§impl<const BW: usize, const LEN: usize> PartialEq for InlAwi<BW, LEN>
impl<const BW: usize, const LEN: usize> PartialEq for InlAwi<BW, LEN>
If self
and other
have unmatching bit widths, false
will be returned.
impl<const BW: usize, const LEN: usize> Copy for InlAwi<BW, LEN>
impl<const BW: usize, const LEN: usize> Eq for InlAwi<BW, LEN>
If self
and other
have unmatching bit widths, false
will be returned.
impl<const BW: usize, const LEN: usize> Send for InlAwi<BW, LEN>
InlAwi
is safe to send between threads since it does not own
aliasing memory and has no reference counting mechanism like Rc
.
impl<const BW: usize, const LEN: usize> Sync for InlAwi<BW, LEN>
InlAwi
is safe to share between threads since it does not own
aliasing memory and has no mutable internal state like Cell
or RefCell
.