Struct volute::StaticLut

impl<const N: usize, const T: usize> StaticLut<N, T>

pub fn num_vars(&self) -> usize

Query the number of variables of the Lut

pub fn num_bits(&self) -> usize

Query the number of bits in the Lut

pub fn num_blocks(&self) -> usize

Query the number of 64-bit blocks in the Lut

pub fn one() -> Self

Create a constant true Lut

pub fn zero() -> Self

Create a constant false Lut

pub fn nth_var(var: usize) -> Self

Create a Lut returning the value of one of its variables

pub fn parity() -> Self

Create a Lut returning true if the number of true variables is even

pub fn majority() -> Self

Create a Lut returning true if the majority of the variables are true

pub fn threshold(k: usize) -> Self

Create a Lut returning true if at least k variables are true

pub fn equals(k: usize) -> Self

Create a Lut returning true if exactly k variables are true

pub fn symmetric(count_values: usize) -> Self

Create a Lut representing a symmetric function. Bit at position k gives the value when k variables are true

pub fn random() -> Self

Create a random Lut

pub fn value(&self, mask: usize) -> bool

Get the value of the Lut for these inputs (input bits packed in the mask)

pub fn get_bit(&self, mask: usize) -> bool

Get the value of the Lut for these inputs (input bits packed in the mask)

pub fn set_value(&mut self, mask: usize, value: bool)

Set the value of the Lut for these inputs (input bits packed in the mask)

pub fn set_bit(&mut self, mask: usize)

Set the value of the Lut for these inputs to true (input bits packed in the mask)

pub fn unset_bit(&mut self, mask: usize)

Set the value of the Lut for these inputs to false (input bits packed in the mask)

pub fn not_inplace(&mut self)

Complement the Lut in place: f(x) –> !f(x)

pub fn and_inplace(&mut self, rhs: &Self)

And two Luts in place

pub fn or_inplace(&mut self, rhs: &Self)

Or two Luts in place

pub fn xor_inplace(&mut self, rhs: &Self)

Xor two Luts in place

pub fn flip_inplace(&mut self, ind: usize)

Flip a variable in place: f(x1, … xi, … xn) –> f(x1, … !xi, … xn)

pub fn swap_inplace(&mut self, ind1: usize, ind2: usize)

Swap two variables in place: f(…, xi, …, xj, …) –> f(…, xj, …, xi, …)

pub fn swap_adjacent_inplace(&mut self, ind: usize)

Swap two adjacent variables in place: f(…, xi, x+1, …) –> f(…, xi+1, xi, …)

pub fn not(&self) -> StaticLut<N, T>

Complement the Lut: f(x) –> !f(x)

pub fn and(&self, rhs: &Self) -> Self

And two Luts

pub fn or(&self, rhs: &Self) -> Self

Or two Luts

pub fn xor(&self, rhs: &Self) -> Self

Xor two Luts

pub fn flip(&self, ind: usize) -> Self

Flip a variable: f(x1, … xi, … xn) –> f(x1, … !xi, … xn)

pub fn swap(&self, ind1: usize, ind2: usize) -> Self

Swap two variables: f(…, xi, …, xj, …) –> f(…, xj, …, xi, …)

pub fn swap_adjacent(&mut self, ind: usize) -> Self

Swap two adjacent variables: f(…, xi, x+1, …) –> f(…, xi+1, xi, …)

pub fn cofactors(&self, ind: usize) -> (Self, Self)

Obtain the two cofactors with respect to a variable

pub fn from_cofactors(c0: &Self, c1: &Self, ind: usize) -> Self

Create a Lut from its two cofactors

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

Return the internal representation as 64-bit blocks

pub fn from_blocks(blocks: &[u64]) -> Self

Create a Lut from its internal representation as 64-bit blocks

pub fn p_canonization(&self) -> (Self, [u8; N])

Find the smallest equivalent Lut up to permutation. Return the canonical representation and the input permutation to obtain it.

pub fn n_canonization(&self) -> (Self, u32)

Find the smallest equivalent Lut up to input flips and output flip. Return the canonical representation and the flips to obtain it.

pub fn npn_canonization(&self) -> (Self, [u8; N], u32)

Find the smallest equivalent Lut up to permutation, input flips and output flip. Return the canonical representation and the permutation and flips to obtain it.

pub fn top_decomposition(&self, ind: usize) -> DecompositionType

Top decomposition of the function with respect to this variable

pub fn is_pos_unate(&self, ind: usize) -> bool

Returns whether the function is positive unate

pub fn is_neg_unate(&self, ind: usize) -> bool

Returns whether the function is negative unate

pub fn all_functions() -> StaticLutIterator<N, T>

Collection of all Luts of this size

pub fn bdd_complexity(luts: &[Self]) -> usize

Compute the number of nodes in the BDD representing these functions

This function uses the natural variable order (0 to num_vars) to build the BDD. This may not be the smallest possible BDD.

pub fn to_hex_string(&self) -> String

Return the hexadecimal string representing the function

Contrary to display, nothing else in printed: a45b instead of Lut4(a45b)

pub fn to_bin_string(&self) -> String

Return the binary string representing the function

Contrary to display, nothing else in printed: 0101 instead of Lut2(0101)

pub fn from_hex_string(s: &str) -> Result<Self, ()>

Build a Lut from an hexadecimal string

Trait Implementations§

impl<const N: usize, const T: usize> Binary for StaticLut<N, T>

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

Formats the value using the given formatter.

impl<const N: usize, const T: usize> BitAnd<&StaticLut<N, T>> for &StaticLut<N, T>

type Output = StaticLut<N, T>

The resulting type after applying the & operator.

fn bitand(self, rhs: &StaticLut<N, T>) -> Self::Output

Performs the & operation. Read more

impl<const N: usize, const T: usize> BitAnd<&StaticLut<N, T>> for StaticLut<N, T>

type Output = StaticLut<N, T>

The resulting type after applying the & operator.

fn bitand(self, rhs: &StaticLut<N, T>) -> Self::Output

Performs the & operation. Read more

impl<const N: usize, const T: usize> BitAnd<StaticLut<N, T>> for &StaticLut<N, T>

type Output = StaticLut<N, T>

The resulting type after applying the & operator.

fn bitand(self, rhs: StaticLut<N, T>) -> Self::Output

Performs the & operation. Read more

impl<const N: usize, const T: usize> BitAnd for StaticLut<N, T>

type Output = StaticLut<N, T>

The resulting type after applying the & operator.

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

Performs the & operation. Read more

impl<const N: usize, const T: usize> BitAndAssign<&StaticLut<N, T>> for StaticLut<N, T>

fn bitand_assign(&mut self, rhs: &Self)

Performs the &= operation. Read more

impl<const N: usize, const T: usize> BitAndAssign for StaticLut<N, T>

fn bitand_assign(&mut self, rhs: Self)

Performs the &= operation. Read more

impl<const N: usize, const T: usize> BitOr<&StaticLut<N, T>> for &StaticLut<N, T>

type Output = StaticLut<N, T>

The resulting type after applying the | operator.

fn bitor(self, rhs: &StaticLut<N, T>) -> Self::Output

Performs the | operation. Read more

impl<const N: usize, const T: usize> BitOr<&StaticLut<N, T>> for StaticLut<N, T>

type Output = StaticLut<N, T>

The resulting type after applying the | operator.

fn bitor(self, rhs: &StaticLut<N, T>) -> Self::Output

Performs the | operation. Read more

impl<const N: usize, const T: usize> BitOr<StaticLut<N, T>> for &StaticLut<N, T>

type Output = StaticLut<N, T>

The resulting type after applying the | operator.

fn bitor(self, rhs: StaticLut<N, T>) -> Self::Output

Performs the | operation. Read more

impl<const N: usize, const T: usize> BitOr for StaticLut<N, T>

type Output = StaticLut<N, T>

The resulting type after applying the | operator.

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

Performs the | operation. Read more

impl<const N: usize, const T: usize> BitOrAssign<&StaticLut<N, T>> for StaticLut<N, T>

fn bitor_assign(&mut self, rhs: &Self)

Performs the |= operation. Read more

impl<const N: usize, const T: usize> BitOrAssign for StaticLut<N, T>

fn bitor_assign(&mut self, rhs: Self)

Performs the |= operation. Read more

impl<const N: usize, const T: usize> BitXor<&StaticLut<N, T>> for &StaticLut<N, T>

type Output = StaticLut<N, T>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &StaticLut<N, T>) -> Self::Output

Performs the ^ operation. Read more

impl<const N: usize, const T: usize> BitXor<&StaticLut<N, T>> for StaticLut<N, T>

type Output = StaticLut<N, T>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &StaticLut<N, T>) -> Self::Output

Performs the ^ operation. Read more

impl<const N: usize, const T: usize> BitXor<StaticLut<N, T>> for &StaticLut<N, T>

type Output = StaticLut<N, T>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: StaticLut<N, T>) -> Self::Output

Performs the ^ operation. Read more

impl<const N: usize, const T: usize> BitXor for StaticLut<N, T>

type Output = StaticLut<N, T>

The resulting type after applying the ^ operator.

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

Performs the ^ operation. Read more

impl<const N: usize, const T: usize> BitXorAssign<&StaticLut<N, T>> for StaticLut<N, T>

fn bitxor_assign(&mut self, rhs: &Self)

Performs the ^= operation. Read more

impl<const N: usize, const T: usize> BitXorAssign for StaticLut<N, T>

fn bitxor_assign(&mut self, rhs: Self)

Performs the ^= operation. Read more

impl<const N: usize, const T: usize> Clone for StaticLut<N, T>

fn clone(&self) -> StaticLut<N, T>

Returns a copy of the value. Read more

1.0.0 · source§

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

Performs copy-assignment from source. Read more

impl<const N: usize, const T: usize> Debug for StaticLut<N, T>

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

Formats the value using the given formatter. Read more

impl<const N: usize, const T: usize> Default for StaticLut<N, T>

fn default() -> Self

Returns the “default value” for a type. Read more

impl<const N: usize, const T: usize> Display for StaticLut<N, T>

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

Formats the value using the given formatter. Read more