Struct StaticLut 

pub struct StaticLut<const NUM_VARS: usize, const NUM_WORDS: usize> { /* private fields */ }

Fixed-size truth table representing a N-input boolean function with 2^N bits; more compact than Lut when the size is known

Implementations

impl<const NUM_VARS: usize, const NUM_WORDS: usize> StaticLut<NUM_VARS, NUM_WORDS>

pub const fn num_vars(&self) -> usize

Query the number of variables of the Lut

pub const fn num_bits(&self) -> usize

Query the number of bits in the Lut

pub const fn num_blocks(&self) -> usize

Query the number of 64-bit blocks in the Lut

pub const fn one() -> Self

Create a constant true Lut

pub const 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 count_ones(&self) -> usize

Count the number of one bits in the Lut

pub fn count_zeros(&self) -> usize

Count the number of zero bits in the Lut

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 flip_n_inplace(&mut self, mask: u32)

Flip multiple variables in a mask, as generated by canonization methods

Bit i determines if variable i should be flipped, bit num_var if the output should be flipped

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

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

pub fn permute_inplace(&mut self, perm: &[u8])

Permute the variables: f(x1, …, xi, …, xn) –> f(xp[1], …, xp[i], …, xp[n])

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) -> Self

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 flip_n(&self, mask: u32) -> Self

Flip multiple variables in a mask, as generated by canonization methods

Bit i determines if variable i should be flipped, bit num_var if the output should be flipped

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

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

pub fn permute(&self, perm: &[u8]) -> Self

Permute the variables: f(x1, …, xi, …, xn) –> f(xp[1], …, xp[i], …, xp[n])

pub fn swap_adjacent(&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; NUM_VARS])

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

pub fn is_p_canonical(&self) -> bool

Returns whether the Lut is already p-canonical

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 is_n_canonical(&self) -> bool

Returns whether the Lut is already n-canonical

pub fn npn_canonization(&self) -> (Self, [u8; NUM_VARS], 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 is_npn_canonical(&self) -> bool

Returns whether the Lut is already npn-canonical

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<NUM_VARS, NUM_WORDS>

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 is 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 is printed: 0101 instead of Lut2(0101)

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

Build a Lut from an hexadecimal string

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

Build a Lut from a binary string

Trait Implementations

impl<const NUM_VARS: usize, const NUM_WORDS: usize> Binary for StaticLut<NUM_VARS, NUM_WORDS>

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

Formats the value using the given formatter.

impl<const NUM_VARS: usize, const NUM_WORDS: usize> BitAnd<&StaticLut<NUM_VARS, NUM_WORDS>> for &StaticLut<NUM_VARS, NUM_WORDS>

type Output = StaticLut<NUM_VARS, NUM_WORDS>

The resulting type after applying the & operator.

fn bitand(self, rhs: &StaticLut<NUM_VARS, NUM_WORDS>) -> Self::Output

Performs the & operation.

impl<const NUM_VARS: usize, const NUM_WORDS: usize> BitAnd<&StaticLut<NUM_VARS, NUM_WORDS>> for StaticLut<NUM_VARS, NUM_WORDS>

type Output = StaticLut<NUM_VARS, NUM_WORDS>

The resulting type after applying the & operator.

fn bitand(self, rhs: &StaticLut<NUM_VARS, NUM_WORDS>) -> Self::Output

Performs the & operation.

impl<const NUM_VARS: usize, const NUM_WORDS: usize> BitAnd<StaticLut<NUM_VARS, NUM_WORDS>> for &StaticLut<NUM_VARS, NUM_WORDS>

type Output = StaticLut<NUM_VARS, NUM_WORDS>

The resulting type after applying the & operator.

fn bitand(self, rhs: StaticLut<NUM_VARS, NUM_WORDS>) -> Self::Output

Performs the & operation.

impl<const NUM_VARS: usize, const NUM_WORDS: usize> BitAnd for StaticLut<NUM_VARS, NUM_WORDS>

type Output = StaticLut<NUM_VARS, NUM_WORDS>

The resulting type after applying the & operator.

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

Performs the & operation.

impl<const NUM_VARS: usize, const NUM_WORDS: usize> BitAndAssign<&StaticLut<NUM_VARS, NUM_WORDS>> for StaticLut<NUM_VARS, NUM_WORDS>

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

Performs the &= operation.

impl<const NUM_VARS: usize, const NUM_WORDS: usize> BitAndAssign for StaticLut<NUM_VARS, NUM_WORDS>

fn bitand_assign(&mut self, rhs: Self)

Performs the &= operation.

impl<const NUM_VARS: usize, const NUM_WORDS: usize> BitOr<&StaticLut<NUM_VARS, NUM_WORDS>> for &StaticLut<NUM_VARS, NUM_WORDS>

type Output = StaticLut<NUM_VARS, NUM_WORDS>

The resulting type after applying the | operator.

fn bitor(self, rhs: &StaticLut<NUM_VARS, NUM_WORDS>) -> Self::Output

Performs the | operation.

impl<const NUM_VARS: usize, const NUM_WORDS: usize> BitOr<&StaticLut<NUM_VARS, NUM_WORDS>> for StaticLut<NUM_VARS, NUM_WORDS>

type Output = StaticLut<NUM_VARS, NUM_WORDS>

The resulting type after applying the | operator.

fn bitor(self, rhs: &StaticLut<NUM_VARS, NUM_WORDS>) -> Self::Output

Performs the | operation.

impl<const NUM_VARS: usize, const NUM_WORDS: usize> BitOr<StaticLut<NUM_VARS, NUM_WORDS>> for &StaticLut<NUM_VARS, NUM_WORDS>

type Output = StaticLut<NUM_VARS, NUM_WORDS>

The resulting type after applying the | operator.

fn bitor(self, rhs: StaticLut<NUM_VARS, NUM_WORDS>) -> Self::Output

Performs the | operation.

impl<const NUM_VARS: usize, const NUM_WORDS: usize> BitOr for StaticLut<NUM_VARS, NUM_WORDS>

type Output = StaticLut<NUM_VARS, NUM_WORDS>

The resulting type after applying the | operator.

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

Performs the | operation.

impl<const NUM_VARS: usize, const NUM_WORDS: usize> BitOrAssign<&StaticLut<NUM_VARS, NUM_WORDS>> for StaticLut<NUM_VARS, NUM_WORDS>

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

Performs the |= operation.

impl<const NUM_VARS: usize, const NUM_WORDS: usize> BitOrAssign for StaticLut<NUM_VARS, NUM_WORDS>

fn bitor_assign(&mut self, rhs: Self)

Performs the |= operation.

impl<const NUM_VARS: usize, const NUM_WORDS: usize> BitXor<&StaticLut<NUM_VARS, NUM_WORDS>> for &StaticLut<NUM_VARS, NUM_WORDS>

type Output = StaticLut<NUM_VARS, NUM_WORDS>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &StaticLut<NUM_VARS, NUM_WORDS>) -> Self::Output

Performs the ^ operation.

impl<const NUM_VARS: usize, const NUM_WORDS: usize> BitXor<&StaticLut<NUM_VARS, NUM_WORDS>> for StaticLut<NUM_VARS, NUM_WORDS>

type Output = StaticLut<NUM_VARS, NUM_WORDS>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &StaticLut<NUM_VARS, NUM_WORDS>) -> Self::Output

Performs the ^ operation.

impl<const NUM_VARS: usize, const NUM_WORDS: usize> BitXor<StaticLut<NUM_VARS, NUM_WORDS>> for &StaticLut<NUM_VARS, NUM_WORDS>

type Output = StaticLut<NUM_VARS, NUM_WORDS>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: StaticLut<NUM_VARS, NUM_WORDS>) -> Self::Output

Performs the ^ operation.

impl<const NUM_VARS: usize, const NUM_WORDS: usize> BitXor for StaticLut<NUM_VARS, NUM_WORDS>

type Output = StaticLut<NUM_VARS, NUM_WORDS>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<const NUM_VARS: usize, const NUM_WORDS: usize> BitXorAssign<&StaticLut<NUM_VARS, NUM_WORDS>> for StaticLut<NUM_VARS, NUM_WORDS>

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

Performs the ^= operation.

impl<const NUM_VARS: usize, const NUM_WORDS: usize> BitXorAssign for StaticLut<NUM_VARS, NUM_WORDS>

fn bitxor_assign(&mut self, rhs: Self)

Performs the ^= operation.

impl<const NUM_VARS: usize, const NUM_WORDS: usize> Clone for StaticLut<NUM_VARS, NUM_WORDS>

fn clone(&self) -> StaticLut<NUM_VARS, NUM_WORDS>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<const NUM_VARS: usize, const NUM_WORDS: usize> Debug for StaticLut<NUM_VARS, NUM_WORDS>

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

Formats the value using the given formatter.

impl<const NUM_VARS: usize, const NUM_WORDS: usize> Default for StaticLut<NUM_VARS, NUM_WORDS>

fn default() -> Self

Returns the “default value” for a type.

impl<const NUM_VARS: usize, const NUM_WORDS: usize> Display for StaticLut<NUM_VARS, NUM_WORDS>

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

Formats the value using the given formatter.

impl From<StaticLut<3, 1>> for u8

fn from(lut: Lut3) -> u8

Converts to this type from the input type.

impl From<StaticLut<4, 1>> for u16

fn from(lut: Lut4) -> u16

Converts to this type from the input type.

impl From<StaticLut<5, 1>> for u32

fn from(lut: Lut5) -> u32

Converts to this type from the input type.

impl From<StaticLut<6, 1>> for u64

fn from(lut: Lut6) -> u64

Converts to this type from the input type.

impl From<StaticLut<7, 2>> for u128

fn from(lut: Lut7) -> u128

Converts to this type from the input type.

impl<const NUM_VARS: usize, const NUM_WORDS: usize> From<StaticLut<NUM_VARS, NUM_WORDS>> for Lut

fn from(lut: StaticLut<NUM_VARS, NUM_WORDS>) -> Lut

Converts to this type from the input type.

impl<const NUM_VARS: usize, const NUM_WORDS: usize> Hash for StaticLut<NUM_VARS, NUM_WORDS>

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 NUM_VARS: usize, const NUM_WORDS: usize> LowerHex for StaticLut<NUM_VARS, NUM_WORDS>

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

Formats the value using the given formatter.

impl<const NUM_VARS: usize, const NUM_WORDS: usize> Not for &StaticLut<NUM_VARS, NUM_WORDS>

type Output = StaticLut<NUM_VARS, NUM_WORDS>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<const NUM_VARS: usize, const NUM_WORDS: usize> Not for StaticLut<NUM_VARS, NUM_WORDS>

type Output = StaticLut<NUM_VARS, NUM_WORDS>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<const NUM_VARS: usize, const NUM_WORDS: usize> Ord for StaticLut<NUM_VARS, NUM_WORDS>

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 NUM_VARS: usize, const NUM_WORDS: usize> PartialEq for StaticLut<NUM_VARS, NUM_WORDS>

fn eq(&self, other: &StaticLut<NUM_VARS, NUM_WORDS>) -> 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 NUM_VARS: usize, const NUM_WORDS: usize> PartialOrd for StaticLut<NUM_VARS, NUM_WORDS>

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 NUM_VARS: usize, const NUM_WORDS: usize> TryFrom<Lut> for StaticLut<NUM_VARS, NUM_WORDS>

type Error = ()

The type returned in the event of a conversion error.

fn try_from(lut: Lut) -> Result<Self, Self::Error>

Performs the conversion.

impl<const NUM_VARS: usize, const NUM_WORDS: usize> Copy for StaticLut<NUM_VARS, NUM_WORDS>

impl<const NUM_VARS: usize, const NUM_WORDS: usize> Eq for StaticLut<NUM_VARS, NUM_WORDS>

impl<const NUM_VARS: usize, const NUM_WORDS: usize> StructuralPartialEq for StaticLut<NUM_VARS, NUM_WORDS>