Struct volute::Lut

pub struct Lut { /* private fields */ }

Arbitrary-size truth table

Implementations

impl Lut

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(num_vars: usize) -> Lut

Create a constant true Lut

pub fn zero(num_vars: usize) -> Lut

Create a constant false Lut

pub fn nth_var(num_vars: usize, var: usize) -> Lut

Create a Lut returning the value of one of its variables

pub fn parity(num_vars: usize) -> Lut

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

pub fn majority(num_vars: usize) -> Lut

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

pub fn threshold(num_vars: usize, k: usize) -> Lut

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

pub fn equals(num_vars: usize, k: usize) -> Lut

Create a Lut returning true if exactly k variables are true

pub fn symmetric(num_vars: usize, count_values: usize) -> Lut

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

pub fn random(num_vars: usize) -> Lut

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

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

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

And two Luts

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

Or two Luts

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

Xor two Luts

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

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

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

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

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

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(num_vars: usize, blocks: &[u64]) -> Self

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

pub fn p_canonization(&self) -> (Self, Vec<u8>)

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, Vec<u8>, 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(num_vars: usize) -> LutIterator

Collection of all Luts of a given size

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

Compute the number of nodes in the BDD representing these functions

Equivalent functions (up to output complementation) are represented by the same BDD node. The natural variable order (0 to num_vars) is used: smaller BDDs may be possible with another ordering.

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(num_vars: usize, s: &str) -> Result<Self, ()>

Build a Lut from an hexadecimal string

Trait Implementations

impl Binary for Lut

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

Formats the value using the given formatter.

impl BitAnd<&Lut> for &Lut

type Output = Lut

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<&Lut> for Lut

type Output = Lut

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<Lut> for &Lut

type Output = Lut

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd for Lut

type Output = Lut

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAndAssign<&Lut> for Lut

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

Performs the &= operation.

impl BitAndAssign for Lut

fn bitand_assign(&mut self, rhs: Lut)

Performs the &= operation.

impl BitOr<&Lut> for &Lut

type Output = Lut

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<&Lut> for Lut

type Output = Lut

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<Lut> for &Lut

type Output = Lut

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr for Lut

type Output = Lut

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOrAssign<&Lut> for Lut

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

Performs the |= operation.

impl BitOrAssign for Lut

fn bitor_assign(&mut self, rhs: Lut)

Performs the |= operation.

impl BitXor<&Lut> for &Lut

type Output = Lut

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<&Lut> for Lut

type Output = Lut

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<Lut> for &Lut

type Output = Lut

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor for Lut

type Output = Lut

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXorAssign<&Lut> for Lut

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

Performs the ^= operation.

impl BitXorAssign for Lut

fn bitxor_assign(&mut self, rhs: Lut)

Performs the ^= operation.

impl Clone for Lut

fn clone(&self) -> Lut

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Lut

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

Formats the value using the given formatter.

impl Default for Lut

fn default() -> Self

Returns the “default value” for a type.

impl Display for Lut

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

Formats the value using the given formatter.

impl From<&Esop> for Lut

fn from(value: &Esop) -> Self

Converts to this type from the input type.

impl From<&Lut> for Esop

fn from(value: &Lut) -> Self

Obtain the canonical Esop representation, with only positive cubes

impl From<&Lut> for Sop

fn from(value: &Lut) -> Self

Converts to this type from the input type.

impl From<&Soes> for Lut

fn from(value: &Soes) -> Self

Converts to this type from the input type.

impl From<&Sop> for Lut

fn from(value: &Sop) -> Self

Converts to this type from the input type.

impl From<Esop> for Lut

fn from(value: Esop) -> Self

Converts to this type from the input type.

impl From<Lut> for Esop

fn from(value: Lut) -> Self

Converts to this type from the input type.

impl From<Lut> for Sop

fn from(value: Lut) -> Self

Converts to this type from the input type.

impl From<Soes> for Lut

fn from(value: Soes) -> Self

Converts to this type from the input type.

impl From<Sop> for Lut

fn from(value: Sop) -> Self

Converts to this type from the input type.

impl<const N: usize, const T: usize> From<StaticLut<N, T>> for Lut

fn from(lut: StaticLut<N, T>) -> Lut

Converts to this type from the input type.

impl Hash for Lut

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 Lut

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

Formats the value using the given formatter.

impl Not for &Lut

type Output = Lut

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl Not for Lut

type Output = Lut

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl Ord for Lut

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 + PartialOrd,

Restrict a value to a certain interval.

impl PartialEq for Lut

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for Lut

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<const N: usize, const T: usize> TryFrom<Lut> for StaticLut<N, T>

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 Eq for Lut

impl StructuralEq for Lut

impl StructuralPartialEq for Lut