Struct swar::Bits4

pub struct Bits4<N>(pub N);

This is used when every 4 bits is a number stored in parallel.

Methods

impl Bits4<u128>

pub fn from_element(e: u128) -> Self

Spread a single value out to each element. Must be able to fit.

use swar::*;

assert_eq!(Bits4::from_element(0b0110), Bits4(0x6666_6666_6666_6666_6666_6666_6666_6666));

pub fn any(self) -> Self

If any bit is set in each element, sets the element to 1, else 0.

use swar::*;

let input = Bits4(0xE_0u128);
let output = Bits4(0x1_0u128);
assert_eq!(input.any(), output);

pub fn union(left: Bits8<u128>, right: Bits8<u128>) -> Self

Takes two inputs that have half-sized elements and compresses them into half the space and puts them in the left and right sides of this.

use swar::*;

let input = Bits4(0xFEED_FACE_CAFE_BEEF_FEED_FACE_CAFE_BEEF);
let (left, right) = input.halve();
let output = Bits4::union(left, right);
assert_eq!(input, output);

pub fn squash(self) -> Bits2<u128>

Squashes half-sized elements into half-sized spaces to the right and fills the left half of the number with zeros.

This is the same as union(0, n).

pub fn count_ones(self) -> u32

pub fn pack_ones(self) -> Bits8<u128>

Sqishes all the bits to the right in each 8-bit segment.

use swar::*;

let input = Bits4(0b1111_1111);
let out = Bits8(0b11111111);
assert_eq!(input.pack_ones(), out, "got {:08b} expected {:08b}", input.pack_ones().0, out.0);

let input = Bits4(0b0111_0001);
let out = Bits8(0b00001111);
assert_eq!(input.pack_ones(), out, "got {:08b} expected {:08b}", input.pack_ones().0, out.0);

let input = Bits4(0b1111_0000);
let out = Bits8(0b0000_1111);
assert_eq!(input.pack_ones(), out, "got {:08b} expected {:08b}", input.pack_ones().0, out.0);

let input = Bits4(0b0011_0001);
let out = Bits8(0b0000_0111);
assert_eq!(input.pack_ones(), out, "got {:08b} expected {:08b}", input.pack_ones().0, out.0);

let input = Bits4(0b0011_0011);
let out = Bits8(0b00001111);
assert_eq!(input.pack_ones(), out, "got {:08b} expected {:08b}", input.pack_ones().0, out.0);

pub fn sum_weight(self) -> u128

pub fn sum_weight2(self) -> Bits8<u128>

pub fn minhwd(self, other: Self) -> Self

This computes the minimum hamming weight distance from hamming weights.

use swar::*;

for a in 0u128..=4 {
    for b in 0u128..=4 {
        let aa = Bits4(a | a << 4);
        let bb = Bits4(b | b << 4);
        let out = aa.minhwd(bb);
        let diff = (a as i128 - b as i128).abs() as u128;
        let expected = Bits4(diff | diff << 4);
        assert_eq!(out, expected, "got hamming distances {:08b} expected {:08b} ({:04b}, {:04b})", out.0, expected.0, a, b);
    }
}

pub fn split(self) -> (Bits8<u128>, Bits8<u128>)

pub fn halve(self) -> (Bits8<u128>, Bits8<u128>)

Takes the left and right sides and spreads them out so that the bits in each element are spread out into twice the amount of space.

use swar::*;

let input = Bits4(0xABCD << 64 | 0xDEAD);
let (left, right) = input.halve();
assert_eq!(left, Bits8(0x0A0B_0C0D));
assert_eq!(right, Bits8(0x0D0E_0A0D));

Trait Implementations

impl<N: PartialEq> PartialEq<Bits4<N>> for Bits4<N>

fn eq(&self, other: &Bits4<N>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Bits4<N>) -> bool

This method tests for !=.

impl<N: Eq> Eq for Bits4<N>

impl<N: Clone> Clone for Bits4<N>

fn clone(&self) -> Bits4<N>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<N: Copy> Copy for Bits4<N>

impl<N: Debug> Debug for Bits4<N>

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

Formats the value using the given formatter.

impl Add<Bits4<u128>> for Bits4<u128>

Note that you are responsible for dealing with overflow. Try to avoid overflow or use the split() method to add in two halves. You can use split() on the result to get the carry bits.

type Output = Self

The resulting type after applying the + operator.

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

Performs the + operation.

impl BitAnd<u128> for Bits4<u128>

type Output = Self

The resulting type after applying the & operator.

fn bitand(self, rhs: u128) -> Self

Performs the & operation.

impl Shr<u32> for Bits4<u128>

type Output = Self

The resulting type after applying the >> operator.

fn shr(self, rhs: u32) -> Self

Performs the >> operation.