kitty Namespace Reference

Namespaces
namespace	detail

Classes
struct	dynamic_truth_table
struct	static_truth_table
struct	static_truth_table< NumVars, false >
struct	static_truth_table< NumVars, true >

Functions
template<typename TT, typename Fn>
TT	unary_operation (const TT &tt, Fn &&op)
	Perform bitwise unary operation on truth table.
template<typename TT, typename Fn>
TT	binary_operation (const TT &first, const TT &second, Fn &&op)
	Perform bitwise binary operation on two truth tables.
template<typename TT, typename Fn>
bool	binary_predicate (const TT &first, const TT &second, Fn &&op)
	Computes a predicate based on two truth tables.
template<typename TT, typename Fn>
void	assign_operation (TT &tt, Fn &&op)
	Assign computed values to bits.
template<typename TT, typename Fn>
void	for_each_block (const TT &tt, Fn &&op)
	Iterates through each block of a truth table.
template<typename TT, typename Fn>
void	for_each_block_reversed (const TT &tt, Fn &&op)
	Iterates through each block of a truth table in reverse order.
template<typename TT>
TT	create (unsigned num_vars)
	Creates truth table with number of variables.
template<typename TT>
void	create_nth_var (TT &tt, uint8_t var_index, bool complement=false)
	Constructs projections (single-variable functions)
template<typename TT>
TT	unary_not_if (const TT &tt, bool cond)
template<typename TT>
TT	unary_not (const TT &tt)
	Inverts all bits in a truth table.
template<typename TT>
TT	binary_and (const TT &first, const TT &second)
	Bitwise AND of two truth tables.
template<typename TT>
TT	binary_or (const TT &first, const TT &second)
	Bitwise OR of two truth tables.
template<typename TT>
void	swap_inplace (TT &tt, uint8_t var_index1, uint8_t var_index2)
	Swaps two variables in a truth table.
template<uint32_t NumVars>
void	swap_inplace (static_truth_table< NumVars, true > &tt, uint8_t var_index1, uint8_t var_index2)
template<typename TT, typename TTFrom>
void	extend_to_inplace (TT &tt, const TTFrom &from)
	Extends smaller truth table to larger one.
template<uint32_t NumVars, typename TTFrom>
static_truth_table< NumVars >	extend_to (const TTFrom &from)
	Extends smaller truth table to larger static one.
template<typename TT>
bool	has_var (const TT &tt, uint8_t var_index)
	Checks whether truth table depends on given variable index.
template<typename TT>
bool	has_var (const TT &tt, const TT &care, uint8_t var_index)
	Checks whether truth table depends on given variable index.
template<typename TT, typename TTFrom>
void	shrink_to_inplace (TT &tt, const TTFrom &from)
	Shrinks larger truth table to smaller one.
template<typename TTFrom>
dynamic_truth_table	shrink_to (const TTFrom &from, unsigned num_vars)
	Shrinks larger truth table to smaller dynamic one.
template<typename TT>
void	print_hex (const TT &tt, std::ostream &os=std::cout)
	Prints truth table in hexadecimal representation.
dynamic_truth_table	operator~ (const dynamic_truth_table &tt)
	Operator for unary_not.
template<uint32_t NumVars>
static_truth_table< NumVars >	operator~ (const static_truth_table< NumVars > &tt)
	Operator for unary_not.
dynamic_truth_table	operator& (const dynamic_truth_table &first, const dynamic_truth_table &second)
	Operator for binary_and.
template<uint32_t NumVars>
static_truth_table< NumVars >	operator& (const static_truth_table< NumVars > &first, const static_truth_table< NumVars > &second)
	Operator for binary_and.
void	operator&= (dynamic_truth_table &first, const dynamic_truth_table &second)
	Operator for binary_and and assign.
template<uint32_t NumVars>
void	operator&= (static_truth_table< NumVars > &first, const static_truth_table< NumVars > &second)
	Operator for binary_and and assign.
dynamic_truth_table	operator| (const dynamic_truth_table &first, const dynamic_truth_table &second)
	Operator for binary_or.
template<uint32_t NumVars>
static_truth_table< NumVars >	operator| (const static_truth_table< NumVars > &first, const static_truth_table< NumVars > &second)
	Operator for binary_or.
void	operator|= (dynamic_truth_table &first, const dynamic_truth_table &second)
	Operator for binary_or and assign.
template<uint32_t NumVars>
void	operator|= (static_truth_table< NumVars, true > &first, const static_truth_table< NumVars, true > &second)
	Operator for binary_or and assign.
template<uint32_t NumVars>
void	operator|= (static_truth_table< NumVars, false > &first, const static_truth_table< NumVars, false > &second)
	Operator for binary_or and assign.

Function Documentation

assign_operation()

template<typename TT, typename Fn>

void kitty::assign_operation	(	TT &	tt,
		Fn &&	op )

Assign computed values to bits.

The functor op computes bits which are assigned to the bits of the truth table.

Parameters

tt	Truth table
op	Unary operation that takes no input and returns a word (uint64_t)

Definition at line 85 of file kitty_algorithm.hpp.

{
  std::generate( tt.begin(), tt.end(), op );
  tt.mask_bits();
}

binary_and()

template<typename TT>

TT kitty::binary_and ( const TT & first, const TT & second )

inline

Bitwise AND of two truth tables.

Definition at line 48 of file kitty_operations.hpp.

{
  return binary_operation( first, second, std::bit_and<uint64_t>() );
}

Here is the call graph for this function:

Here is the caller graph for this function:

binary_operation()

template<typename TT, typename Fn>

TT kitty::binary_operation	(	const TT &	first,
		const TT &	second,
		Fn &&	op )

Perform bitwise binary operation on two truth tables.

The dimensions of first and second must match. This is ensured at compile-time for static truth tables, but at run-time for dynamic truth tables.

Parameters

first	First truth table
second	Second truth table
op	Binary operation that takes as input two words (uint64_t) and returns a word

Returns

new constructed truth table of same type and dimensions

Definition at line 46 of file kitty_algorithm.hpp.

{
  assert( first.num_vars() == second.num_vars() );
 
  TT result = first.construct();
  std::transform( first.cbegin(), first.cend(), second.cbegin(), result.begin(), op );
  result.mask_bits();
  return result;
}

Here is the caller graph for this function:

binary_or()

template<typename TT>

TT kitty::binary_or ( const TT & first, const TT & second )

inline

Bitwise OR of two truth tables.

Definition at line 55 of file kitty_operations.hpp.

{
  return binary_operation( first, second, std::bit_or<uint64_t>() );
}

Here is the call graph for this function:

Here is the caller graph for this function:

binary_predicate()

template<typename TT, typename Fn>

bool kitty::binary_predicate	(	const TT &	first,
		const TT &	second,
		Fn &&	op )

Computes a predicate based on two truth tables.

The dimensions of first and second must match. This is ensured at compile-time for static truth tables, but at run-time for dynamic truth tables.

Parameters

first	First truth table
second	Second truth table
op	Binary operation that takes as input two words (uint64_t) and returns a Boolean

Returns

true or false based on the predicate

Definition at line 69 of file kitty_algorithm.hpp.

{
  assert( first.num_vars() == second.num_vars() );
 
  return std::equal( first.begin(), first.end(), second.begin(), op );
}

create()

template<typename TT>

TT kitty::create ( unsigned num_vars )

inline

Creates truth table with number of variables.

If some truth table instance is given, one can create a truth table with the same type by calling the construct() method on it. This function helps if only the number of variables is known and the base type and uniforms the creation of static and dynamic truth tables. Note, however, that for static truth tables num_vars must be consistent to the number of variables in the truth table type.

Parameters

num_vars

Number of variables

Definition at line 32 of file kitty_constructors.hpp.

{
  (void)num_vars;
  TT tt;
  assert( tt.num_vars() == num_vars );
  return tt;
}

Here is the caller graph for this function:

create_nth_var()

template<typename TT>

void kitty::create_nth_var	(	TT &	tt,
		uint8_t	var_index,
		bool	complement = false )

Constructs projections (single-variable functions)

Parameters

tt	Truth table
var_index	Index of the variable, must be smaller than the truth table's number of variables
complement	If true, realize inverse projection

Definition at line 55 of file kitty_constructors.hpp.

{
  if ( tt.num_vars() <= 6 )
  {
    /* assign from precomputed table */
    tt._bits[0] = complement ? ~detail::projections[var_index] : detail::projections[var_index];
 
    /* mask if truth table does not require all bits */
    tt.mask_bits();
    return;
  }
 
  if ( var_index < 6 )
  {
    std::fill( std::begin( tt._bits ), std::end( tt._bits ), complement ? ~detail::projections[var_index] : detail::projections[var_index] );
  }
  else
  {
    const auto c = 1 << ( var_index - 6 );
    const auto zero = uint64_t( 0 );
    const auto one = ~zero;
    auto block = uint64_t( 0u );
 
    while ( block < tt.num_blocks() )
    {
      for ( auto i = 0; i < c; ++i )
      {
        tt._bits[block++] = complement ? one : zero;
      }
      for ( auto i = 0; i < c; ++i )
      {
        tt._bits[block++] = complement ? zero : one;
      }
    }
  }
}

Here is the call graph for this function:

extend_to()

template<uint32_t NumVars, typename TTFrom>

static_truth_table< NumVars > kitty::extend_to ( const TTFrom & from )

inline

Extends smaller truth table to larger static one.

This is an out-of-place version of extend_to_inplace that has the truth table as a return value. It only works for creating static truth tables. The template parameter NumVars must be equal or larger to the number of variables in from.

Parameters

from	Smaller truth table to copy from

Definition at line 198 of file kitty_operations.hpp.

{
  static_truth_table<NumVars> tt;
  extend_to_inplace( tt, from );
  return tt;
}

Here is the call graph for this function:

extend_to_inplace()

template<typename TT, typename TTFrom>

void kitty::extend_to_inplace	(	TT &	tt,
		const TTFrom &	from )

Extends smaller truth table to larger one.

The most significant variables will not be in the functional support of the resulting truth table, but the method is helpful to align a truth table when being used with another one.

Parameters

tt	Larger truth table to create
from	Smaller truth table to copy from

Definition at line 163 of file kitty_operations.hpp.

{
  assert( tt.num_vars() >= from.num_vars() );
 
  if ( from.num_vars() < 6 )
  {
    auto mask = *from.begin();
 
    for ( auto i = from.num_vars(); i < std::min<uint8_t>( 6, tt.num_vars() ); ++i )
    {
      mask |= ( mask << ( 1 << i ) );
    }
 
    std::fill( tt.begin(), tt.end(), mask );
  }
  else
  {
    auto it = tt.begin();
    while ( it != tt.end() )
    {
      it = std::copy( from.cbegin(), from.cend(), it );
    }
  }
}

Here is the caller graph for this function:

for_each_block()

template<typename TT, typename Fn>

void kitty::for_each_block	(	const TT &	tt,
		Fn &&	op )

Iterates through each block of a truth table.

The functor op is called for every block of the truth table.

Parameters

tt	Truth table
op	Unary operation that takes as input a word (uint64_t) and returns void

Definition at line 99 of file kitty_algorithm.hpp.

{
  std::for_each( tt.cbegin(), tt.cend(), op );
}

for_each_block_reversed()

template<typename TT, typename Fn>

void kitty::for_each_block_reversed	(	const TT &	tt,
		Fn &&	op )

Iterates through each block of a truth table in reverse order.

The functor op is called for every block of the truth table in reverse order.

Parameters

tt	Truth table
op	Unary operation that takes as input a word (uint64_t) and returns void

Definition at line 114 of file kitty_algorithm.hpp.

{
  std::for_each( tt.crbegin(), tt.crend(), op );
}

Here is the caller graph for this function:

has_var() [1/2]

template<typename TT>

bool kitty::has_var	(	const TT &	tt,
		const TT &	care,
		uint8_t	var_index )

Checks whether truth table depends on given variable index.

Parameters

tt	Truth table
care	Care set
var_index	Variable index

Definition at line 244 of file kitty_operations.hpp.

{
  assert( var_index < tt.num_vars() );
  assert( tt.num_vars() == care.num_vars() );
 
  if ( tt.num_vars() <= 6 || var_index < 6 )
  {
    auto it_tt = std::begin( tt._bits );
    auto it_care = std::begin( care._bits );
    while ( it_tt != std::end( tt._bits ) )
    {
      if ( ( ( ( *it_tt >> ( uint64_t( 1 ) << var_index ) ) ^ *it_tt ) & detail::projections_neg[var_index]
           & ( *it_care >> ( uint64_t( 1 ) << var_index ) ) & *it_care ) != 0 )
      {
        return true;
      }
      ++it_tt;
      ++it_care;
    }
 
    return false;
  }
 
  const auto step = 1 << ( var_index - 6 );
  for ( auto i = 0u; i < static_cast<uint32_t>( tt.num_blocks() ); i += 2 * step )
  {
    for ( auto j = 0; j < step; ++j )
    {
      if ( ( ( tt._bits[i + j] ^ tt._bits[i + j + step] ) & care._bits[i + j] & care._bits[i + j + step] ) != 0 )
      {
        return true;
      }
    }
  }
  return false;
}

has_var() [2/2]

template<typename TT>

bool kitty::has_var	(	const TT &	tt,
		uint8_t	var_index )

Checks whether truth table depends on given variable index.

Parameters

tt	Truth table
var_index	Variable index

Definition at line 211 of file kitty_operations.hpp.

{
  assert( var_index < tt.num_vars() );
 
  if ( tt.num_vars() <= 6 || var_index < 6 )
  {
    return std::any_of( std::begin( tt._bits ), std::end( tt._bits ),
                        [var_index]( uint64_t word )
                        { return ( ( word >> ( uint64_t( 1 ) << var_index ) ) & detail::projections_neg[var_index] ) !=
                                 ( word & detail::projections_neg[var_index] ); } );
  }
 
  const auto step = 1 << ( var_index - 6 );
  for ( auto i = 0u; i < static_cast<uint32_t>( tt.num_blocks() ); i += 2 * step )
  {
    for ( auto j = 0; j < step; ++j )
    {
      if ( tt._bits[i + j] != tt._bits[i + j + step] )
      {
        return true;
      }
    }
  }
  return false;
}

operator&() [1/2]

dynamic_truth_table kitty::operator& ( const dynamic_truth_table & first, const dynamic_truth_table & second )

inline

Operator for binary_and.

Definition at line 34 of file kitty_operators.hpp.

{
  return binary_and( first, second );
}

Here is the call graph for this function:

operator&() [2/2]

template<uint32_t NumVars>

static_truth_table< NumVars > kitty::operator& ( const static_truth_table< NumVars > & first, const static_truth_table< NumVars > & second )

inline

Operator for binary_and.

Definition at line 41 of file kitty_operators.hpp.

{
  return binary_and( first, second );
}

Here is the call graph for this function:

operator&=() [1/2]

void kitty::operator&= ( dynamic_truth_table & first, const dynamic_truth_table & second )

inline

Operator for binary_and and assign.

Definition at line 47 of file kitty_operators.hpp.

{
  first = binary_and( first, second );
}

Here is the call graph for this function:

operator&=() [2/2]

template<uint32_t NumVars>

void kitty::operator&= ( static_truth_table< NumVars > & first, const static_truth_table< NumVars > & second )

inline

Operator for binary_and and assign.

Definition at line 54 of file kitty_operators.hpp.

{
  first = binary_and( first, second );
}

Here is the call graph for this function:

operator|() [1/2]

dynamic_truth_table kitty::operator| ( const dynamic_truth_table & first, const dynamic_truth_table & second )

inline

Operator for binary_or.

Definition at line 60 of file kitty_operators.hpp.

{
  return binary_or( first, second );
}

Here is the call graph for this function:

operator|() [2/2]

template<uint32_t NumVars>

static_truth_table< NumVars > kitty::operator| ( const static_truth_table< NumVars > & first, const static_truth_table< NumVars > & second )

inline

Operator for binary_or.

Definition at line 67 of file kitty_operators.hpp.

{
  return binary_or( first, second );
}

Here is the call graph for this function:

operator|=() [1/3]

void kitty::operator|= ( dynamic_truth_table & first, const dynamic_truth_table & second )

inline

Operator for binary_or and assign.

Definition at line 73 of file kitty_operators.hpp.

{
  first = binary_or( first, second );
}

Here is the call graph for this function:

operator|=() [2/3]

template<uint32_t NumVars>

void kitty::operator|= ( static_truth_table< NumVars, false > & first, const static_truth_table< NumVars, false > & second )

inline

Operator for binary_or and assign.

Definition at line 90 of file kitty_operators.hpp.

{
  // first = binary_or( first, second );
  /* runtime improved version */
  if ( NumVars == 7 )
  {
    first._bits[0] |= second._bits[0];
    first._bits[1] |= second._bits[1];
  }
  else if ( NumVars == 8 )
  {
    first._bits[0] |= second._bits[0];
    first._bits[1] |= second._bits[1];
    first._bits[2] |= second._bits[2];
    first._bits[3] |= second._bits[3];
  }
  else if ( NumVars == 9 )
  {
    first._bits[0] |= second._bits[0];
    first._bits[1] |= second._bits[1];
    first._bits[2] |= second._bits[2];
    first._bits[3] |= second._bits[3];
    first._bits[4] |= second._bits[4];
    first._bits[5] |= second._bits[5];
    first._bits[6] |= second._bits[6];
    first._bits[7] |= second._bits[7];
  }
  else
  {
    for ( uint32_t i = 0; i < first.num_blocks(); ++i )
    {
      first._bits[i] |= second._bits[i];
    }
  }
}

operator|=() [3/3]

template<uint32_t NumVars>

void kitty::operator|= ( static_truth_table< NumVars, true > & first, const static_truth_table< NumVars, true > & second )

inline

Operator for binary_or and assign.

Definition at line 80 of file kitty_operators.hpp.

{
  // first = binary_or( first, second );
  /* runtime improved version */
  first._bits |= second._bits;
  first.mask_bits();
}

operator~() [1/2]

dynamic_truth_table kitty::operator~ ( const dynamic_truth_table & tt )

inline

Operator for unary_not.

Definition at line 21 of file kitty_operators.hpp.

{
  return unary_not( tt );
}

Here is the call graph for this function:

operator~() [2/2]

template<uint32_t NumVars>

static_truth_table< NumVars > kitty::operator~ ( const static_truth_table< NumVars > & tt )

inline

Operator for unary_not.

Definition at line 28 of file kitty_operators.hpp.

{
  return unary_not( tt );
}

Here is the call graph for this function:

print_hex()

template<typename TT>

void kitty::print_hex	(	const TT &	tt,
		std::ostream &	os = std::cout )

Prints truth table in hexadecimal representation.

The most-significant bit will be the first character of the string.

Parameters

tt	Truth table
os	Output stream

Definition at line 327 of file kitty_operations.hpp.

{
  auto const chunk_size =
      std::min<uint64_t>( tt.num_vars() <= 1 ? 1 : ( tt.num_bits() >> 2 ), 16 );
 
  for_each_block_reversed( tt, [&os, chunk_size]( uint64_t word )
                           {
    std::string chunk( chunk_size, '0' );
 
    auto it = chunk.rbegin();
    while (word && it != chunk.rend()) {
      auto hex = word & 0xf;
      if (hex < 10) {
        *it = '0' + static_cast<char>(hex);
      } else {
        *it = 'a' + static_cast<char>(hex - 10);
      }
      ++it;
      word >>= 4;
    }
    os << chunk; } );
}

Here is the call graph for this function:

shrink_to()

template<typename TTFrom>

dynamic_truth_table kitty::shrink_to ( const TTFrom & from, unsigned num_vars )

inline

Shrinks larger truth table to smaller dynamic one.

This is an out-of-place version of shrink_to that has the truth table as a return value. It only works for creating dynamic tables. The parameter num_vars must be equal or smaller to the number of variables in from.

Parameters

from	Smaller truth table to copy from

Definition at line 312 of file kitty_operations.hpp.

{
  auto tt = create<dynamic_truth_table>( num_vars );
  shrink_to_inplace( tt, from );
  return tt;
}

Here is the call graph for this function:

shrink_to_inplace()

template<typename TT, typename TTFrom>

void kitty::shrink_to_inplace	(	TT &	tt,
		const TTFrom &	from )

Shrinks larger truth table to smaller one.

The function expects that the most significant bits, which are cut off, are not in the functional support of the original function. Only then it is ensured that the resulting function is equivalent.

Parameters

tt	Smaller truth table to create
from	Larger truth table to copy from

Definition at line 291 of file kitty_operations.hpp.

{
  assert( tt.num_vars() <= from.num_vars() );
 
  std::copy( from.begin(), from.begin() + tt.num_blocks(), tt.begin() );
 
  if ( tt.num_vars() < 6 )
  {
    tt.mask_bits();
  }
}

Here is the caller graph for this function:

swap_inplace() [1/2]

template<uint32_t NumVars>

void kitty::swap_inplace ( static_truth_table< NumVars, true > & tt, uint8_t var_index1, uint8_t var_index2 )

inline

Definition at line 136 of file kitty_operations.hpp.

{
  if ( var_index1 == var_index2 )
  {
    return;
  }
 
  if ( var_index1 > var_index2 )
  {
    std::swap( var_index1, var_index2 );
  }
 
  const auto& pmask = detail::ppermutation_masks[var_index1][var_index2];
  const auto shift = ( 1 << var_index2 ) - ( 1 << var_index1 );
  tt._bits = ( tt._bits & pmask[0] ) | ( ( tt._bits & pmask[1] ) << shift ) | ( ( tt._bits & pmask[2] ) >> shift );
}

swap_inplace() [2/2]

template<typename TT>

void kitty::swap_inplace	(	TT &	tt,
		uint8_t	var_index1,
		uint8_t	var_index2 )

Swaps two variables in a truth table.

The function swaps variable var_index1 with var_index2. The function will change tt in-place. If tt should not be changed, one can use swap instead.

Parameters

tt	Truth table
var_index1	First variable
var_index2	Second variable

Definition at line 71 of file kitty_operations.hpp.

{
  if ( var_index1 == var_index2 )
  {
    return;
  }
 
  if ( var_index1 > var_index2 )
  {
    std::swap( var_index1, var_index2 );
  }
 
  if ( tt.num_vars() <= 6 )
  {
    const auto& pmask = detail::ppermutation_masks[var_index1][var_index2];
    const auto shift = ( 1 << var_index2 ) - ( 1 << var_index1 );
    tt._bits[0] = ( tt._bits[0] & pmask[0] ) | ( ( tt._bits[0] & pmask[1] ) << shift ) | ( ( tt._bits[0] & pmask[2] ) >> shift );
  }
  else if ( var_index2 <= 5 )
  {
    const auto& pmask = detail::ppermutation_masks[var_index1][var_index2];
    const auto shift = ( 1 << var_index2 ) - ( 1 << var_index1 );
    std::transform( std::begin( tt._bits ), std::end( tt._bits ), std::begin( tt._bits ),
                    [shift, &pmask]( uint64_t word )
                    {
                      return ( word & pmask[0] ) | ( ( word & pmask[1] ) << shift ) | ( ( word & pmask[2] ) >> shift );
                    } );
  }
  else if ( var_index1 <= 5 ) /* in this case, var_index2 > 5 */
  {
    const auto step = 1 << ( var_index2 - 6 );
    const auto shift = 1 << var_index1;
    auto it = std::begin( tt._bits );
    while ( it != std::end( tt._bits ) )
    {
      for ( auto i = decltype( step ){ 0 }; i < step; ++i )
      {
        const auto low_to_high = ( *( it + i ) & detail::projections[var_index1] ) >> shift;
        const auto high_to_low = ( *( it + i + step ) << shift ) & detail::projections[var_index1];
        *( it + i ) = ( *( it + i ) & ~detail::projections[var_index1] ) | high_to_low;
        *( it + i + step ) = ( *( it + i + step ) & detail::projections[var_index1] ) | low_to_high;
      }
      it += 2 * step;
    }
  }
  else
  {
    const auto step1 = 1 << ( var_index1 - 6 );
    const auto step2 = 1 << ( var_index2 - 6 );
    auto it = std::begin( tt._bits );
    while ( it != std::end( tt._bits ) )
    {
      for ( auto i = 0; i < step2; i += 2 * step1 )
      {
        for ( auto j = 0; j < step1; ++j )
        {
          std::swap( *( it + i + j + step1 ), *( it + i + j + step2 ) );
        }
      }
      it += 2 * step2;
    }
  }
}

unary_not()

template<typename TT>

TT kitty::unary_not ( const TT & tt )

inline

Inverts all bits in a truth table.

Definition at line 39 of file kitty_operations.hpp.

{
  return unary_operation( tt, []( uint64_t a )
                          { return ~a; } );
}

Here is the call graph for this function:

Here is the caller graph for this function:

unary_not_if()

template<typename TT>

TT kitty::unary_not_if ( const TT & tt, bool cond )

inline

Inverts all bits in a truth table, based on a condition

Definition at line 23 of file kitty_operations.hpp.

{
#ifdef _MSC_VER
#pragma warning( push )
#pragma warning( disable : 4146 )
#endif
  const auto mask = -static_cast<uint64_t>( cond );
#ifdef _MSC_VER
#pragma warning( pop )
#endif
  return unary_operation( tt, [mask]( uint64_t a )
                          { return a ^ mask; } );
}

Here is the call graph for this function:

unary_operation()

template<typename TT, typename Fn>

TT kitty::unary_operation	(	const TT &	tt,
		Fn &&	op )

Perform bitwise unary operation on truth table.

Parameters

tt	Truth table
op	Unary operation that takes as input a word (uint64_t) and returns a word

Returns

new constructed truth table of same type and dimensions

Definition at line 25 of file kitty_algorithm.hpp.

{
  TT result = tt.construct();
  std::transform( tt.cbegin(), tt.cend(), result.begin(), op );
  result.mask_bits();
  return result;
}

Here is the caller graph for this function: