Namespaces
namespace	groebner
Classes
class	BlockDegLexOrder
	This class defines ordering related functions. More...
class	BlockDegRevLexAscOrder
	This class defines ordering related functions. More...
class	BooleConstant
	This class wraps a bool value, which was not converted to a boolean polynomial or monomial yet. More...
class	BooleEnv
	This class is just a wrapper accessing global structures. More...
class	BooleExponent
	This class is just a wrapper for using variables for storing indices as interim data structure for BooleMonomial. More...
class	BooleMonomial
	This class is just a wrapper for using variables from `cudd's` decicion diagram. More...
class	BoolePolynomial
	This class wraps the underlying decicion diagram type and defines the necessary operations. More...
class	BoolePolyRing
	This class adds order-related functionality to BooleRing. More...
class	BooleSet
class	BooleVariable
	This class is just a wrapper for using variables from `cudd's` decicion diagram. More...
class	handle_else
class	CCacheTypes
struct	count_tags< CCacheTypes::divisorsof_fixedpath >
struct	increment_count_tags
class	count_tags< CCacheTypes::testwise_ternary >
class	count_tags< CCacheTypes::left_equals_right_x_branch_and_r_has_fac_x >
class	count_tags< CCacheTypes::has_factor_x_plus_y >
class	cudd_tag_number
class	CCuddLikeMgrStorage
struct	pbori_base< CCacheManBase< Cudd, CacheType, ArgumentLength > >
struct	pbori_base< CCacheManBase< CCuddInterface, CacheType, ArgumentLength > >
class	CCacheManBase< ManagerType, CacheType, 0 >
class	CCacheManBase< ManagerType, CacheType, 1 >
class	CCacheManBase< ManagerType, CacheType, 2 >
class	CCacheManBase< ManagerType, CacheType, 3 >
class	CCacheManagement
	This template class forms the base for CCommutativeCacheManagement and CacheManager. It is an interface defining find and insert on decision diagram cache. More...
class	CCommutativeCacheManagement
class	CCuddCore
	This class prepares the CUDD's raw decision diagram manager structure for the use with instrinsive pointers. More...
class	CCuddFirstIter
	This class defines an iterator over the first minimal term of a given ZDD node. More...
class	CCuddGetNode
	This class defines a functional, which generates a new decision * diagram node wrt. a given indes and two nodes. More...
class	CCuddLastIter
	This class defines an iterator over the last minimal term of a given ZDD node. More...
class	CCuddDDBase
	This template class defines a C++ interface to `CUDD's` decision diagram structure. More...
class	CCuddZDD
	This class defines a C++ interface to `CUDD's` zero-suppressed decision diagram structure. More...
class	CDDInterfaceBase
	This is the common base for the specialized template class CDDInterface. More...
class	CDDInterface
class	CDDManagerBase
	this specialization of the template class CDDManager gives an interface to Cudd-like ZDD manager (StorageType = CuddLikeManType) or a reference of the latter (StorageType = CuddLikeManType&). More...
class	CDDManager< Cudd & >
class	CDDManager< Cudd >
class	CDDManager< CCuddInterface & >
class	CDDManager< CCuddInterface >
class	CDDOperations
class	CIndexHandle
	This class defines an uses an navigator-like type for storing integer values from 0 upto nmax (number of currently active ring variables). More...
class	CIndexCacheHandle
class	CDegreeCache
class	CBlockDegreeCache
class	CDegreeArgumentCache
class	CDelayedTermIter
	This class defines extend a given PolyBoRi degree iterator. More...
class	CErrorInfo
class	CExpGenerator
struct	pbori_base< CExpIter< NaviType, ExpType > >
class	CExpIter
class	CIdxPath
class	CLiteralCodes
	This template class defines enumerative codes for the string literals defined by the CStringLiterals class. More...
class	COrderProperties
	This class determins ordering dependent properties. More...
class	CPrintOperation
	This template prints a string literal to stream as operation. More...
class	CTermGeneratorBase< TermType, type_tag< BooleExponent > >
class	CTermGeneratorBase< TermType, type_tag< CTypes::size_type > >
class	CTermGenerator
class	NoData
class	CTermGeneratorBase< TermType, type_tag< BooleMonomial > >
class	CTermGenerator< BooleMonomial >
class	CVariableIter
	This template class defines an iterator for monomial types. More...
class	CVariableNames
class	DegLexOrder
	This class defines ordering related functions. More...
class	DegRevLexAscOrder
	This class defines ordering related functions. More...
class	LexOrder
	This class defines ordering related functions. More...
class	lex_tag
	Marker for lex ordering. More...
class	dlex_tag
	Marker for deg-lex ordering. More...
class	dp_asc_tag
	Marker for ascending deg-rev-lex ordering. More...
class	block_dlex_tag
	Marker for block deg-lex ordering. More...
class	block_dp_asc_tag
	Marker for ascending block deg-rev-lex ordering. More...
class	order_traits
class	dd_operations< CTypes::dd_type::navigator >
class	COrderEnums
	This struct contains type definitions and enumerations to be used for order codes. More...
class	CErrorEnums
	This struct contains type definitions and enumerations to be used for error codes. More...
class	CCompareEnums
	This struct contains type definitions and enumerations to be used for comparisons. More...
class	CAuxTypes
	This struct contains auxiliary type definitions. More...
class	CTypes
	This struct contains type definitions to be used in library classes. More...
class	dummy_data_type
class	generic_iteration< LexOrder, Iterator >
class	generic_iteration< DegLexOrder, Iterator >
class	generic_iteration< DegRevLexAscOrder, Iterator >
class	bounded_restricted_term
class	pbori_traits
	This class contains property definitions to be used in polybori classes. More...
class	pbori_traits< void >
class	pbori_traits< int >
class	pbori_traits< unsigned int >
class	pbori_traits< long int >
class	pbori_traits< std::set< ValueType > >
class	pbori_traits< std::vector< ValueType > >
class	pbori_binary_traits< OnlyType, OnlyType >
class	pbori_binary_traits
	This class contains property definitions related to two types to be used in polybori classes. More...
struct	manager_traits< Cudd >
struct	manager_traits< Cudd * >
struct	manager_traits< DdManager * >
struct	manager_traits
struct	mgrcore_traits< Cudd >
struct	zdd_traits< ZDD >
struct	zdd_traits< CCuddZDD >
struct	cudd_error_traits
class	PBoRiError
	This class is used for polybori's exception handling. More...
class	PBoRiOutIter
	This template class defines an output iterator which interprets assignments of indices as a change of given data wrt. a given binary operation. More...
class	EliminationDegreeAdder
class	AddEliminationDegree
Functions
CTypes::ostream_type &	operator<< (CTypes::ostream_type &os, const BooleConstant &rhs)
	Stream output operator.
template<class RHSType >
BooleExponent	operator+ (const BooleExponent &lhs, const RHSType &rhs)
	Multiplication of monomials.
template<class RHSType >
BooleExponent	operator- (const BooleExponent &lhs, const RHSType &rhs)
	Division of monomials.
BooleExponent::bool_type	operator< (const BooleExponent &lhs, const BooleExponent &rhs)
	Less than comparision.
BooleExponent::bool_type	operator> (const BooleExponent &lhs, const BooleExponent &rhs)
	Greater than comparision.
BooleExponent::bool_type	operator<= (const BooleExponent &lhs, const BooleExponent &rhs)
	Less or equal than comparision.
BooleExponent::bool_type	operator>= (const BooleExponent &lhs, const BooleExponent &rhs)
	Greater or equal than comparision.
BooleExponent	GCD (const BooleExponent &lhs, const BooleExponent &rhs)
	Compute the greatest common divisor of two monomials.
BooleExponent	LCM (const BooleExponent &lhs, const BooleExponent &rhs)
	Compute the greatest common divisor of two monomials.
BooleExponent::ostream_type &	operator<< (BooleExponent::ostream_type &os, const BooleExponent &rhs)
	Stream output operator.
BooleMonomial	operator* (const BooleMonomial &lhs, const BooleMonomial &rhs)
	Multiplication of monomials.
BooleMonomial	operator* (const BooleMonomial &lhs, const BooleVariable &rhs)
	Multiplication of monomials.
BoolePolynomial	operator* (const BooleMonomial &lhs, BooleConstant rhs)
	Multiplication of monomials.
BoolePolynomial	operator* (BooleConstant lhs, const BooleMonomial &rhs)
	Multiplication of monomials.
BooleMonomial	operator/ (const BooleMonomial &lhs, const BooleMonomial &rhs)
	Division of monomials.
BooleMonomial	operator/ (const BooleMonomial &lhs, const BooleVariable &rhs)
	Division of monomials.
BooleMonomial::bool_type	operator< (const BooleMonomial &lhs, const BooleMonomial &rhs)
	Less than comparision.
BooleMonomial::bool_type	operator> (const BooleMonomial &lhs, const BooleMonomial &rhs)
	Greater than comparision.
BooleMonomial::bool_type	operator<= (const BooleMonomial &lhs, const BooleMonomial &rhs)
	Less or equal than comparision.
BooleMonomial::bool_type	operator>= (const BooleMonomial &lhs, const BooleMonomial &rhs)
	Greater or equal than comparision.
BooleMonomial	GCD (const BooleMonomial &lhs, const BooleMonomial &rhs)
	Compute the greatest common divisor of two monomials.
BooleMonomial	LCM (const BooleMonomial &lhs, const BooleMonomial &rhs)
	Compute the greatest common divisor of two monomials.
BooleMonomial::bool_type	greater_variable (BooleMonomial::idx_type lhs, BooleMonomial::idx_type rhs)
	Checks whether BooleVariable(lhs) > BooleVariable(rhs)
BoolePolynomial	operator* (const BooleVariable &lhs, const BooleConstant &rhs)
	Multiplication of variables by a 0 or 1.
BoolePolynomial	operator* (const BooleConstant &lhs, const BooleVariable &rhs)
	Multiplication of 0 or 1 by a Variable.
BoolePolynomial	operator* (const BooleVariable &lhs, const BoolePolynomial &rhs)
	Multiplication of variables by a polynomial.
BooleMonomial	operator* (const BooleVariable &lhs, const BooleMonomial &rhs)
	Multiplication of variables by a monomial.
BoolePolynomial &	operator*= (BoolePolynomial &lhs, const BooleVariable &rhs)
	Multiplication of a polynomial by a variable with assignment.
BooleMonomial	operator* (const BooleVariable &lhs, const BooleVariable &rhs)
	Multiplication of monomials by a polynomial.
BoolePolynomial	operator* (const BoolePolynomial &lhs, const BooleVariable &rhs)
	Multiplication of a polynomial by a variable.
BoolePolynomial &	operator/= (BoolePolynomial &lhs, const BooleVariable &rhs)
	Division of a polynomial by a variable (forcing monomial variant)
BoolePolynomial	operator/ (const BoolePolynomial &lhs, const BooleVariable &rhs)
	Division of a polynomial by a variable (forcing monomial variant)
BoolePolynomial	operator% (const BoolePolynomial &lhs, const BooleVariable &rhs)
	Remainder of division of a polynomial by a variable.
BoolePolynomial &	operator%= (BoolePolynomial &lhs, const BooleVariable &rhs)
	Remainder of division of a polynomial by a variable (with assignment)
BoolePolynomial	operator+ (const BoolePolynomial &lhs, const BoolePolynomial &rhs)
	Addition operation.
BoolePolynomial	operator+ (const BoolePolynomial &lhs, BooleConstant rhs)
	Addition operation.
BoolePolynomial	operator+ (BooleConstant lhs, const BoolePolynomial &rhs)
	Addition operation.
template<class RHSType >
BoolePolynomial	operator- (const BoolePolynomial &lhs, const RHSType &rhs)
	Subtraction operation.
BoolePolynomial	operator- (const BooleConstant &lhs, const BoolePolynomial &rhs)
	Subtraction operation with constant right-hand-side.
BoolePolynomial	operator* (const BoolePolynomial &lhs, const BoolePolynomial &rhs)
BoolePolynomial	operator* (const BoolePolynomial &lhs, const BooleMonomial &rhs)
BoolePolynomial	operator* (const BoolePolynomial &lhs, const BooleExponent &rhs)
BoolePolynomial	operator* (const BoolePolynomial &lhs, const BooleConstant &rhs)
BoolePolynomial	operator* (const BooleMonomial &lhs, const BoolePolynomial &rhs)
BoolePolynomial	operator* (const BooleExponent &lhs, const BoolePolynomial &rhs)
BoolePolynomial	operator* (const BooleConstant &lhs, const BoolePolynomial &rhs)
template<class RHSType >
BoolePolynomial	operator/ (const BoolePolynomial &lhs, const RHSType &rhs)
	Division by monomial (skipping remainder)
template<class RHSType >
BoolePolynomial	operator% (const BoolePolynomial &lhs, const RHSType &rhs)
	Modulus monomial (division remainder)
BoolePolynomial::bool_type	operator== (BoolePolynomial::bool_type lhs, const BoolePolynomial &rhs)
	Equality check (with constant lhs)
BoolePolynomial::bool_type	operator!= (BoolePolynomial::bool_type lhs, const BoolePolynomial &rhs)
	Nonquality check (with constant lhs)
BoolePolynomial::ostream_type &	operator<< (BoolePolynomial::ostream_type &, const BoolePolynomial &)
	Stream output operator.
BooleSet::ostream_type &	operator<< (BooleSet::ostream_type &os, const BooleSet &bset)
	Stream output operator.
BoolePolynomial	operator/ (const BooleVariable &lhs, const BooleVariable &rhs)
Cudd *	extract_manager (const Cudd &mgr)
CCuddInterface::mgrcore_ptr	extract_manager (const CCuddInterface &mgr)
template<class MgrType >
const MgrType &	extract_manager (const MgrType &mgr)
Cudd &	get_manager (Cudd *mgr)
template<class MgrType >
const MgrType &	get_manager (const MgrType &mgr)
template<class DDType >
CDDInterface< DDType > ::ostream_type &	operator<< (typename CDDInterface< DDType >::ostream_type &os, const CDDInterface< DDType > &dd)
	Stream output operator.
ZDD	fetch_diagram (const Cudd &mgr, const ZDD &rhs)
template<class MgrType , class DDType >
const DDType &	fetch_diagram (const MgrType &mgr, const DDType &rhs)
Cudd &	fetch_manager (const Cudd &mgr)
template<class MgrType >
const MgrType &	fetch_manager (const MgrType &mgr)
template<class IdxType , class SeparatorType >
CIdxPath< IdxType, SeparatorType >::ostream_type &	operator<< (typename CIdxPath< IdxType, SeparatorType >::ostream_type &os, const CIdxPath< IdxType, SeparatorType > &storage)
	Stream output operator.
template<class NaviType , class TermType , class TernaryOperator , class TerminalOperator >
TermType	dd_backward_transform (NaviType navi, TermType init, TernaryOperator newNode, TerminalOperator terminate)
	Function templates for transforming decision diagrams.
template<class NaviType , class TermType , class OutIterator , class ThenBinaryOperator , class ElseBinaryOperator , class TerminalOperator >
OutIterator	dd_transform (NaviType navi, TermType init, OutIterator result, ThenBinaryOperator then_binop, ElseBinaryOperator else_binop, TerminalOperator terminate)
	Function templates for transforming decision diagrams.
template<class NaviType , class TermType , class OutIterator , class ThenBinaryOperator , class ElseBinaryOperator , class TerminalOperator , class FirstTermOp >
OutIterator	dd_transform (NaviType navi, TermType init, OutIterator result, ThenBinaryOperator then_binop, ElseBinaryOperator else_binop, TerminalOperator terminate, FirstTermOp terminate_first)
template<class NaviType , class TermType , class OutIterator , class ThenBinaryOperator , class ElseBinaryOperator >
void	dd_transform (const NaviType &navi, const TermType &init, const OutIterator &result, const ThenBinaryOperator &then_binop, const ElseBinaryOperator &else_binop)
	Function templates for transforming decision diagrams.
template<class NaviType , class TermType , class OutIterator , class ThenBinaryOperator >
void	dd_transform (const NaviType &navi, const TermType &init, const OutIterator &result, const ThenBinaryOperator &then_binop)
	Function templates for transforming decision diagrams.
template<class InputIterator , class OutputIterator , class FirstFunction , class UnaryFunction >
OutputIterator	special_first_transform (InputIterator first, InputIterator last, OutputIterator result, UnaryFunction op, FirstFunction firstop)
template<class InputIterator , class Intermediate , class OutputIterator >
OutputIterator	reversed_inter_copy (InputIterator start, InputIterator finish, Intermediate &inter, OutputIterator output)
	Function templates doing a reversed copy using intermediate storage.
template<class NaviType >
bool	dd_on_path (NaviType navi)
template<class NaviType , class OrderedIterator >
bool	dd_owns_term_of_indices (NaviType navi, OrderedIterator start, OrderedIterator finish)
template<class NaviType , class OrderedIterator , class NodeOperation >
NaviType	dd_intersect_some_index (NaviType navi, OrderedIterator start, OrderedIterator finish, NodeOperation newNode)
template<class NaviType >
void	dd_print (NaviType navi)
	Function templates for debugging, prints dd indices and reference counts.
template<class IteratorType , class SizeType >
SizeType	limited_distance (IteratorType start, IteratorType finish, SizeType limit)
template<class NaviType , class DDType >
DDType	dd_minimal_elements (NaviType navi, DDType dd, DDType &multiples)
template<class MgrType >
const MgrType &	get_mgr_core (const MgrType &rhs)
Cudd *	get_mgr_core (const Cudd &rhs)
CCuddInterface::mgrcore_ptr	get_mgr_core (const CCuddInterface &mgr)
template<class ManagerType , class ReverseIterator , class MultReverseIterator >
manager_traits< ManagerType > ::dd_base	cudd_generate_multiples (const ManagerType &mgr, ReverseIterator start, ReverseIterator finish, MultReverseIterator multStart, MultReverseIterator multFinish)
	temporarily (needs to be more generic)
template<class ManagerType , class ReverseIterator >
manager_traits< ManagerType > ::dd_base	cudd_generate_divisors (const ManagerType &mgr, ReverseIterator start, ReverseIterator finish)
	temporarily (needs to be more generic)
template<class Iterator , class SizeType >
Iterator	bounded_max_element (Iterator start, Iterator finish, SizeType bound)
template<class LhsType , class RhsType , class BinaryPredicate >
CTypes::comp_type	generic_compare_3way (const LhsType &lhs, const RhsType &rhs, BinaryPredicate comp)
	defines lexicographic comparison for variable indices
template<class IteratorLike , class ForwardIteratorTag >
IteratorLike	increment_iteratorlike (IteratorLike iter, ForwardIteratorTag)
template<class IteratorLike >
IteratorLike	increment_iteratorlike (IteratorLike iter, navigator_tag)
template<class IteratorLike >
IteratorLike	increment_iteratorlike (IteratorLike iter)
DdNode *	pboriCuddZddUnionXor__ (DdManager , DdNode , DdNode *)
template<class MgrType , class NodeType >
NodeType	pboriCuddZddUnionXor (MgrType zdd, NodeType P, NodeType Q)
template<class MgrType , class NodeType >
NodeType	pboriCudd_zddUnionXor (MgrType dd, NodeType P, NodeType Q)
template<class NaviType >
bool	dd_is_singleton (NaviType navi)
template<class NaviType , class BooleConstant >
BooleConstant	dd_pair_check (NaviType navi, BooleConstant allowSingleton)
template<class NaviType >
bool	dd_is_singleton_or_pair (NaviType navi)
template<class NaviType >
bool	dd_is_pair (NaviType navi)
template<class SetType >
void	combine_sizes (const SetType &bset, double &init)
template<class SetType >
void	combine_sizes (const SetType &bset, typename SetType::size_type &init)
template<class SizeType , class IdxType , class NaviType , class SetType >
SizeType &	count_index (SizeType &size, IdxType idx, NaviType navi, const SetType &init)
template<class SizeType , class IdxType , class SetType >
SizeType &	count_index (SizeType &size, IdxType idx, const SetType &bset)
void	inc_ref (DdNode *node)
template<class NaviType >
void	inc_ref (const NaviType &navi)
void	dec_ref (DdNode *node)
template<class NaviType >
void	dec_ref (const NaviType &navi)
DdNode *	do_get_node (DdNode *node)
template<class NaviType >
DdNode *	do_get_node (const NaviType &navi)
template<class MgrType >
void	recursive_dec_ref (const MgrType &mgr, DdNode *node)
template<class MgrType , class NaviType >
void	recursive_dec_ref (const MgrType &mgr, const NaviType &navi)
template<class NaviType , class ReverseIterator , class DDOperations >
NaviType	indexed_term_multiples (NaviType navi, ReverseIterator idxStart, ReverseIterator idxFinish, const DDOperations &apply)
template<class NaviType >
bool	is_reducible_by (NaviType first, NaviType second)
template<class NaviType , class ReverseIterator , class DDOperations >
NaviType	minimal_of_two_terms (NaviType navi, NaviType &multiples, ReverseIterator idxStart, ReverseIterator idxFinish, const DDOperations &apply)
template<class NaviType , class SizeType , class ReverseIterator , class DDOperations >
NaviType	prepend_multiples_wrt_indices (NaviType navi, SizeType minIdx, ReverseIterator start, ReverseIterator finish, const DDOperations &apply)
template<class FunctionType , class ManagerType , class NodeType >
void	apply_assign_cudd_function (FunctionType func, ManagerType &mgr, NodeType &first, const NodeType &second)
template<class FunctionType , class ManagerType , class ResultType , class NodeType >
void	apply_replacing_cudd_function (FunctionType func, ManagerType &mgr, ResultType &newNode, const NodeType &first, const NodeType &second)
template<class FunctionType , class ManagerType , class NodeType >
NodeType	apply_cudd_function (FunctionType func, ManagerType &mgr, const NodeType &first, const NodeType &second)
template<class NaviType , class DDType2 , class ReverseIterator , class DDOperations >
NaviType	dd_minimal_elements (NaviType navi, DDType2 &multiples, ReverseIterator idxStart, ReverseIterator idxEnd, const DDOperations &apply)
BoolePolynomial	spoly (const BoolePolynomial &first, const BoolePolynomial &second)
template<class NaviType , class LowerIterator , class ValueType >
ValueType	lower_term_accumulate (NaviType navi, LowerIterator lstart, LowerIterator lfinish, ValueType init)
template<class UpperIterator , class NaviType , class ValueType >
ValueType	upper_term_accumulate (UpperIterator ustart, UpperIterator ufinish, NaviType navi, ValueType init)
template<class UpperIterator , class NaviType , class LowerIterator , class ValueType >
ValueType	term_accumulate (UpperIterator ustart, UpperIterator ufinish, NaviType navi, LowerIterator lstart, LowerIterator lfinish, ValueType init)
template<class InputIterator , class ValueType >
ValueType	term_accumulate (InputIterator first, InputIterator last, ValueType init)
template<class CacheType , class NaviType , class SetType >
SetType	dd_mapping (const CacheType &cache, NaviType navi, NaviType map, SetType init)
template<class PolyType , class MapType >
PolyType	apply_mapping (const PolyType &poly, const MapType &map)
template<class MonomType , class PolyType >
PolyType	generate_mapping (MonomType &fromVars, MonomType &toVars, PolyType init)
template<class PolyType , class MonomType >
PolyType	mapping (PolyType poly, MonomType fromVars, MonomType toVars)
template<class ValueType >
void	pbori_shared_ptr_postclean (const boost::shared_ptr< ValueType > &, const boost::shared_ptr< ValueType > &)
template<class DDType , class OutputType >
OutputType	dd_last_lexicographical_term (const DDType &dd, type_tag< OutputType >)
	Get last term (wrt. lexicographical order).
template<class HashType , class NaviType >
void	stable_hash_range (HashType &seed, NaviType navi)
template<class NaviType >
std::size_t	stable_hash_range (NaviType navi)
template<class HashType >
void	finalize_term_hash (HashType &seed)
template<class HashType , class NaviType >
void	stable_first_hash_range (HashType &seed, NaviType navi)
template<class NaviType >
std::size_t	stable_first_hash_range (NaviType navi)
template<class HashType , class Iterator >
void	stable_term_hash (HashType &seed, Iterator start, Iterator finish)
template<class Iterator >
std::size_t	stable_term_hash (Iterator start, Iterator finish)
template<class Iterator >
Iterator::value_type	index_vector_hash (Iterator start, Iterator finish)
template<class DegreeCacher , class NaviType >
NaviType::size_type	dd_cached_degree (const DegreeCacher &cache, NaviType navi)
template<class DegreeCacher , class NaviType , class SizeType >
NaviType::size_type	dd_cached_degree (const DegreeCacher &cache, NaviType navi, SizeType bound)
template<class Iterator , class NameGenerator , class Separator , class EmptySetType , class OStreamType >
void	dd_print_term (Iterator start, Iterator finish, const NameGenerator &get_name, const Separator &sep, const EmptySetType &emptyset, OStreamType &os)
template<class TermType , class NameGenerator , class Separator , class EmptySetType , class OStreamType >
void	dd_print_term (const TermType &term, const NameGenerator &get_name, const Separator &sep, const EmptySetType &emptyset, OStreamType &os)
template<class Iterator , class NameGenerator , class Separator , class InnerSeparator , class EmptySetType , class OStreamType >
void	dd_print_terms (Iterator start, Iterator finish, const NameGenerator &get_name, const Separator &sep, const InnerSeparator &innersep, const EmptySetType &emptyset, OStreamType &os)
template<class CacheType , class NaviType , class PolyType >
PolyType	dd_multiply_recursively (const CacheType &cache_mgr, NaviType firstNavi, NaviType secondNavi, PolyType init)
template<class CacheType , class NaviType , class PolyType , class MonomTag >
PolyType	dd_multiply_recursively (const CacheType &cache_mgr, NaviType monomNavi, NaviType navi, PolyType init, MonomTag monom_tag)
template<class DDGenerator , class Iterator , class NaviType , class PolyType >
PolyType	dd_multiply_recursively_exp (const DDGenerator &ddgen, Iterator start, Iterator finish, NaviType navi, PolyType init)
template<class DegCacheMgr , class NaviType , class SizeType >
bool	max_degree_on_then (const DegCacheMgr &deg_mgr, NaviType navi, SizeType degree, valid_tag is_descending)
template<class DegCacheMgr , class NaviType , class SizeType >
bool	max_degree_on_then (const DegCacheMgr &deg_mgr, NaviType navi, SizeType degree, invalid_tag non_descending)
template<class CacheType , class DegCacheMgr , class NaviType , class TermType , class SizeType , class DescendingProperty >
TermType	dd_recursive_degree_lead (const CacheType &cache_mgr, const DegCacheMgr &deg_mgr, NaviType navi, TermType init, SizeType degree, DescendingProperty prop)
template<class CacheType , class DegCacheMgr , class NaviType , class TermType , class DescendingProperty >
TermType	dd_recursive_degree_lead (const CacheType &cache_mgr, const DegCacheMgr &deg_mgr, NaviType navi, TermType init, DescendingProperty prop)
template<class CacheType , class DegCacheMgr , class NaviType , class TermType , class SizeType , class DescendingProperty >
TermType &	dd_recursive_degree_leadexp (const CacheType &cache_mgr, const DegCacheMgr &deg_mgr, NaviType navi, TermType &result, SizeType degree, DescendingProperty prop)
template<class CacheType , class DegCacheMgr , class NaviType , class TermType , class DescendingProperty >
TermType &	dd_recursive_degree_leadexp (const CacheType &cache_mgr, const DegCacheMgr &deg_mgr, NaviType navi, TermType &result, DescendingProperty prop)
template<class CacheType , class NaviType , class TermType >
TermType	dd_existential_abstraction (const CacheType &cache_mgr, NaviType varsNavi, NaviType navi, TermType init)
template<class CacheType , class NaviType , class PolyType >
PolyType	dd_divide_recursively (const CacheType &cache_mgr, NaviType navi, NaviType monomNavi, PolyType init)
template<class DDGenerator , class Iterator , class NaviType , class PolyType >
PolyType	dd_divide_recursively_exp (const DDGenerator &ddgen, NaviType navi, Iterator start, Iterator finish, PolyType init)
template<class CacheType , class NaviType , class MonomType >
MonomType	cached_used_vars (const CacheType &cache, NaviType navi, MonomType init)
template<class NaviType , class Iterator >
bool	dd_owns (NaviType navi, Iterator start, Iterator finish)
template<class CacheType , class NaviType , class DegType , class SetType >
SetType	dd_graded_part (const CacheType &cache, NaviType navi, DegType deg, SetType init)
template<class CacheManager , class NaviType , class SetType >
SetType	dd_first_divisors_of (CacheManager cache_mgr, NaviType navi, NaviType rhsNavi, SetType init)
template<class CacheType , class NaviType , class SetType >
SetType	dd_first_multiples_of (const CacheType &cache_mgr, NaviType navi, NaviType rhsNavi, SetType init)
template<class FirstIterator , class SecondIterator , class BinaryPredicate >
CTypes::comp_type	lex_compare_3way (FirstIterator start, FirstIterator finish, SecondIterator rhs_start, SecondIterator rhs_finish, BinaryPredicate idx_comp)
template<class LhsType , class RhsType , class BinaryPredicate >
CTypes::comp_type	lex_compare (const LhsType &lhs, const RhsType &rhs, BinaryPredicate idx_comp, valid_tag has_easy_equality_test)
	defines lexicographic comparison
template<class LhsType , class RhsType , class BinaryPredicate >
CTypes::comp_type	lex_compare (const LhsType &lhs, const RhsType &rhs, BinaryPredicate idx_comp, invalid_tag has_no_easy_equality_test)
	defines lexicographic comparison
template<class LhsType , class RhsType , class BinaryPredicate >
CTypes::comp_type	lex_compare (const LhsType &lhs, const RhsType &rhs, BinaryPredicate idx_comp)
	defines lexicographic comparison
template<class LhsType , class RhsType , class BinaryPredicate >
CTypes::comp_type	deg_lex_compare (const LhsType &lhs, const RhsType &rhs, BinaryPredicate idx_comp)
	defines degree-lexicographic comparison
template<class StackType , class Iterator >
void	dummy_append (StackType &stack, Iterator start, Iterator finish)
template<class DegreeCacher , class NaviType , class IdxType >
NaviType::size_type	dd_cached_block_degree (const DegreeCacher &cache, NaviType navi, IdxType nextBlock)
template<class DegCacheMgr , class NaviType , class IdxType , class SizeType >
bool	max_block_degree_on_then (const DegCacheMgr &deg_mgr, NaviType navi, IdxType next_block, SizeType degree, valid_tag is_descending)
template<class DegCacheMgr , class NaviType , class IdxType , class SizeType >
bool	max_block_degree_on_then (const DegCacheMgr &deg_mgr, NaviType navi, IdxType next_block, SizeType degree, invalid_tag non_descending)
template<class CacheType , class DegCacheMgr , class NaviType , class TermType , class Iterator , class SizeType , class DescendingProperty >
TermType	dd_block_degree_lead (const CacheType &cache_mgr, const DegCacheMgr &deg_mgr, NaviType navi, Iterator block_iter, TermType init, SizeType degree, DescendingProperty prop)
template<class CacheType , class DegCacheMgr , class NaviType , class Iterator , class TermType , class DescendingProperty >
TermType	dd_block_degree_lead (const CacheType &cache_mgr, const DegCacheMgr &deg_mgr, NaviType navi, Iterator block_iter, TermType init, DescendingProperty prop)
template<class FirstIterator , class SecondIterator , class IdxType , class BinaryPredicate >
CTypes::comp_type	restricted_lex_compare_3way (FirstIterator start, FirstIterator finish, SecondIterator rhs_start, SecondIterator rhs_finish, IdxType max_index, BinaryPredicate idx_comp)
template<class LhsIterator , class RhsIterator , class Iterator , class BinaryPredicate >
CTypes::comp_type	block_dlex_compare (LhsIterator lhsStart, LhsIterator lhsFinish, RhsIterator rhsStart, RhsIterator rhsFinish, Iterator start, Iterator finish, BinaryPredicate idx_comp)
template<class IdxType , class Iterator , class BinaryPredicate >
CTypes::comp_type	block_deg_lex_idx_compare (IdxType lhs, IdxType rhs, Iterator start, Iterator finish, BinaryPredicate idx_comp)
template<class ExpType , class RhsType , class ResultType >
void	exp_divide (const ExpType &lhs, const RhsType &rhs, ResultType &result)
template<class ExpType , class RhsIterator , class SizeType , class ResultType >
void	exp_multiply (const ExpType &lhs, RhsIterator start, RhsIterator finish, SizeType nlen, ResultType &result)
template<class ExpType , class RhsType , class ResultType >
void	exp_multiply (const ExpType &lhs, const RhsType &rhs, ResultType &result)
Prepare for the application of intrinsive pointers
void	intrusive_ptr_add_ref (CCuddCore *pCore)
	Increment reference count.
void	intrusive_ptr_release (CCuddCore *pCore)
	Release current pointer by decrementing reference counting.
Variables
BoolePolyRing	active_ring

Function Documentation

template<class FunctionType , class ManagerType , class NodeType >

void polybori::apply_assign_cudd_function	(	FunctionType	func,
		ManagerType &	mgr,
		NodeType &	first,
		const NodeType &	second
	)

References do_get_node(), inc_ref(), and recursive_dec_ref().

Referenced by polybori::dd_operations< CTypes::dd_type::navigator >::diffAssign(), and polybori::dd_operations< CTypes::dd_type::navigator >::uniteAssign().

template<class FunctionType , class ManagerType , class NodeType >

NodeType polybori::apply_cudd_function	(	FunctionType	func,
		ManagerType &	mgr,
		const NodeType &	first,
		const NodeType &	second
	)

References do_get_node(), and inc_ref().

Referenced by polybori::dd_operations< CTypes::dd_type::navigator >::diff().

template<class PolyType , class MapType >

PolyType polybori::apply_mapping	(	const PolyType &	poly,
		const MapType &	map
	)

References dd_mapping().

Referenced by mapping().

template<class FunctionType , class ManagerType , class ResultType , class NodeType >

void polybori::apply_replacing_cudd_function	(	FunctionType	func,
		ManagerType &	mgr,
		ResultType &	newNode,
		const NodeType &	first,
		const NodeType &	second
	)

References do_get_node(), inc_ref(), and recursive_dec_ref().

Referenced by polybori::dd_operations< CTypes::dd_type::navigator >::replacingUnite().

template<class IdxType , class Iterator , class BinaryPredicate >

CTypes::comp_type polybori::block_deg_lex_idx_compare	(	IdxType	lhs,
		IdxType	rhs,
		Iterator	start,
		Iterator	finish,
		BinaryPredicate	idx_comp
	)

Note:: : no necessary for block_dlex, only for block_dp_asc

References generic_compare_3way().

Referenced by polybori::BlockDegRevLexAscOrder::compare().

template<class LhsIterator , class RhsIterator , class Iterator , class BinaryPredicate >

CTypes::comp_type polybori::block_dlex_compare	(	LhsIterator	lhsStart,
		LhsIterator	lhsFinish,
		RhsIterator	rhsStart,
		RhsIterator	rhsFinish,
		Iterator	start,
		Iterator	finish,
		BinaryPredicate	idx_comp
	)

References generic_compare_3way(), and restricted_lex_compare_3way().

Referenced by polybori::BlockDegLexOrder::compare(), and polybori::BlockDegRevLexAscOrder::compare().

template<class Iterator , class SizeType >

Iterator polybori::bounded_max_element	(	Iterator	start,
		Iterator	finish,
		SizeType	bound
	)

template<class CacheType , class NaviType , class MonomType >

MonomType polybori::cached_used_vars	(	const CacheType &	cache,
		NaviType	navi,
		MonomType	init
	)

Function templates for determining the used variables of a decision diagram with the help of cache

References polybori::CDDOperations< DDType, MonomType >::getMonomial().

Referenced by polybori::CDDOperations< DDType, MonomType >::usedVariables().

template<class SetType >

void polybori::combine_sizes	(	const SetType &	bset,
		double &	init
	)

Referenced by count_index().

template<class SetType >

void polybori::combine_sizes	(	const SetType &	bset,
		typename SetType::size_type &	init
	)

template<class SizeType , class IdxType , class NaviType , class SetType >

SizeType& polybori::count_index	(	SizeType &	size,
		IdxType	idx,
		NaviType	navi,
		const SetType &	init
	)

References combine_sizes().

Referenced by count_index(), polybori::BooleSet::countIndex(), and polybori::BooleSet::countIndexDouble().

template<class SizeType , class IdxType , class SetType >

SizeType& polybori::count_index	(	SizeType &	size,
		IdxType	idx,
		const SetType &	bset
	)

References count_index().

template<class ManagerType , class ReverseIterator >

manager_traits<ManagerType>::dd_base polybori::cudd_generate_divisors	(	const ManagerType &	mgr,
		ReverseIterator	start,
		ReverseIterator	finish
	)

temporarily (needs to be more generic)

Todo:: Next line needs generalization

References get_mgr_core().

Referenced by polybori::BooleExponent::divisors(), and polybori::CDDInterface< CuddLikeZDD >::firstDivisors().

template<class ManagerType , class ReverseIterator , class MultReverseIterator >

manager_traits<ManagerType>::dd_base polybori::cudd_generate_multiples	(	const ManagerType &	mgr,
		ReverseIterator	start,
		ReverseIterator	finish,
		MultReverseIterator	multStart,
		MultReverseIterator	multFinish
	)

temporarily (needs to be more generic)

References get_mgr_core().

Referenced by polybori::CDDInterface< CuddLikeZDD >::firstMultiples(), and polybori::BooleExponent::multiples().

template<class NaviType , class TermType , class TernaryOperator , class TerminalOperator >

TermType polybori::dd_backward_transform	(	NaviType	navi,
		TermType	init,
		TernaryOperator	newNode,
		TerminalOperator	terminate
	)

Function templates for transforming decision diagrams.

Referenced by polybori::groebner::translate_indices().

template<class CacheType , class DegCacheMgr , class NaviType , class TermType , class Iterator , class SizeType , class DescendingProperty >

TermType polybori::dd_block_degree_lead	(	const CacheType &	cache_mgr,
		const DegCacheMgr &	deg_mgr,
		NaviType	navi,
		Iterator	block_iter,
		TermType	init,
		SizeType	degree,
		DescendingProperty	prop
	)

References dd_cached_block_degree(), and max_block_degree_on_then().

Referenced by dd_block_degree_lead(), polybori::BlockDegLexOrder::lead(), and polybori::BlockDegRevLexAscOrder::lead().

template<class CacheType , class DegCacheMgr , class NaviType , class Iterator , class TermType , class DescendingProperty >

TermType polybori::dd_block_degree_lead	(	const CacheType &	cache_mgr,
		const DegCacheMgr &	deg_mgr,
		NaviType	navi,
		Iterator	block_iter,
		TermType	init,
		DescendingProperty	prop
	)

References dd_block_degree_lead(), and dd_cached_block_degree().

template<class DegreeCacher , class NaviType , class IdxType >

NaviType::size_type polybori::dd_cached_block_degree	(	const DegreeCacher &	cache,
		NaviType	navi,
		IdxType	nextBlock
	)

Function templates for determining the degree of a decision diagram with the help of cache (e. g. CDegreeCache)

Referenced by dd_block_degree_lead(), and max_block_degree_on_then().

template<class DegreeCacher , class NaviType >

NaviType::size_type polybori::dd_cached_degree	(	const DegreeCacher &	cache,
		NaviType	navi
	)

Function templates for determining the degree of a decision diagram with the help of cache (e. g. CDegreeCache)

Referenced by dd_cached_degree(), dd_recursive_degree_lead(), dd_recursive_degree_leadexp(), polybori::BoolePolynomial::deg(), polybori::DegRevLexAscOrder::lead(), polybori::DegLexOrder::lead(), polybori::DegRevLexAscOrder::leadExp(), polybori::DegLexOrder::leadExp(), and max_degree_on_then().

template<class DegreeCacher , class NaviType , class SizeType >

NaviType::size_type polybori::dd_cached_degree	(	const DegreeCacher &	cache,
		NaviType	navi,
		SizeType	bound
	)

Function templates for determining the degree of a decision diagram with the help of cache (e. g. CDegreeCache) Variant *with* given upper bound Assumming that the bound is valid!

References dd_cached_degree().

template<class CacheType , class NaviType , class PolyType >

PolyType polybori::dd_divide_recursively	(	const CacheType &	cache_mgr,
		NaviType	navi,
		NaviType	monomNavi,
		PolyType	init
	)

Referenced by polybori::BoolePolynomial::operator/=().

template<class DDGenerator , class Iterator , class NaviType , class PolyType >

PolyType polybori::dd_divide_recursively_exp	(	const DDGenerator &	ddgen,
		NaviType	navi,
		Iterator	start,
		Iterator	finish,
		PolyType	init
	)

Referenced by polybori::BoolePolynomial::operator/=().

template<class CacheType , class NaviType , class TermType >

TermType polybori::dd_existential_abstraction	(	const CacheType &	cache_mgr,
		NaviType	varsNavi,
		NaviType	navi,
		TermType	init
	)

Referenced by polybori::BooleSet::existAbstract().

template<class CacheManager , class NaviType , class SetType >

SetType polybori::dd_first_divisors_of	(	CacheManager	cache_mgr,
		NaviType	navi,
		NaviType	rhsNavi,
		SetType	init
	)

dd_first_divisors_of Function templates extracting the terms of a given decision diagram contain which contains only indices from first lexicographical path in Note: Replacement for dd_intersect_some_index

Referenced by polybori::BooleSet::firstDivisorsOf().

template<class CacheType , class NaviType , class SetType >

SetType polybori::dd_first_multiples_of	(	const CacheType &	cache_mgr,
		NaviType	navi,
		NaviType	rhsNavi,
		SetType	init
	)

Referenced by polybori::BooleSet::multiplesOf().

template<class CacheType , class NaviType , class DegType , class SetType >

SetType polybori::dd_graded_part	(	const CacheType &	cache,
		NaviType	navi,
		DegType	deg,
		SetType	init
	)

Referenced by polybori::BoolePolynomial::gradedPart().

template<class NaviType , class OrderedIterator , class NodeOperation >

NaviType polybori::dd_intersect_some_index	(	NaviType	navi,
		OrderedIterator	start,
		OrderedIterator	finish,
		NodeOperation	newNode
	)

Function templates extracting the terms of a given decision diagram contain which contains only indices from the range [start, finish) Note: Returns incremented node

template<class NaviType >

bool polybori::dd_is_pair ( NaviType navi )

References dd_pair_check().

Referenced by polybori::BooleSet::isPair(), and polybori::BoolePolynomial::isPair().

template<class NaviType >

bool polybori::dd_is_singleton ( NaviType navi )

Referenced by dd_pair_check(), polybori::BooleSet::isSingleton(), and polybori::BoolePolynomial::isSingleton().

template<class NaviType >

bool polybori::dd_is_singleton_or_pair ( NaviType navi )

References dd_pair_check().

Referenced by polybori::BooleSet::isSingletonOrPair(), and polybori::BoolePolynomial::isSingletonOrPair().

template<class DDType , class OutputType >

OutputType polybori::dd_last_lexicographical_term	(	const DDType &	dd,
		type_tag< OutputType >
	)

Get last term (wrt. lexicographical order).

dd_last_lexicographical_term

References reversed_inter_copy().

Referenced by polybori::BooleSet::lastLexicographicalTerm().

template<class CacheType , class NaviType , class SetType >

SetType polybori::dd_mapping	(	const CacheType &	cache,
		NaviType	navi,
		NaviType	map,
		SetType	init
	)

Referenced by apply_mapping().

template<class NaviType , class DDType >

DDType polybori::dd_minimal_elements	(	NaviType	navi,
		DDType	dd,
		DDType &	multiples
	)

A first version Function templates extracting minimal elements of dd wrt. inclusion Assumption, navi is navigator of dd

Referenced by dd_minimal_elements(), and polybori::BooleSet::minimalElements().

template<class NaviType , class DDType2 , class ReverseIterator , class DDOperations >

NaviType polybori::dd_minimal_elements	(	NaviType	navi,
		DDType2 &	multiples,
		ReverseIterator	idxStart,
		ReverseIterator	idxEnd,
		const DDOperations &	apply
	)

A first version Function templates extracting minimal elements of dd wrt. inclusion Assumption, navi is navigator of dd

References dd_minimal_elements(), inc_ref(), indexed_term_multiples(), is_reducible_by(), minimal_of_two_terms(), and prepend_multiples_wrt_indices().

template<class CacheType , class NaviType , class PolyType >

PolyType polybori::dd_multiply_recursively	(	const CacheType &	cache_mgr,
		NaviType	firstNavi,
		NaviType	secondNavi,
		PolyType	init
	)

Referenced by dd_multiply_recursively(), and polybori::BoolePolynomial::operator*=().

template<class CacheType , class NaviType , class PolyType , class MonomTag >

PolyType polybori::dd_multiply_recursively	(	const CacheType &	cache_mgr,
		NaviType	monomNavi,
		NaviType	navi,
		PolyType	init,
		MonomTag	monom_tag
	)

References dd_multiply_recursively().

template<class DDGenerator , class Iterator , class NaviType , class PolyType >

PolyType polybori::dd_multiply_recursively_exp	(	const DDGenerator &	ddgen,
		Iterator	start,
		Iterator	finish,
		NaviType	navi,
		PolyType	init
	)

Referenced by polybori::BoolePolynomial::operator*=().

template<class NaviType >

bool polybori::dd_on_path ( NaviType navi )

Function templates for checking whether a given decision diagram node is on path

template<class NaviType , class Iterator >

bool polybori::dd_owns	(	NaviType	navi,
		Iterator	start,
		Iterator	finish
	)

Referenced by polybori::BooleSet::owns().

template<class NaviType , class OrderedIterator >

bool polybori::dd_owns_term_of_indices	(	NaviType	navi,
		OrderedIterator	start,
		OrderedIterator	finish
	)

Function templates for checking whether a given decision diagram contains paths with indices only in range [start, finish)

Referenced by polybori::BooleSet::hasTermOfVariables().

template<class NaviType , class BooleConstant >

BooleConstant polybori::dd_pair_check	(	NaviType	navi,
		BooleConstant	allowSingleton
	)

References dd_is_singleton().

Referenced by dd_is_pair(), and dd_is_singleton_or_pair().

template<class NaviType >

void polybori::dd_print ( NaviType navi )

Function templates for debugging, prints dd indices and reference counts.

template<class Iterator , class NameGenerator , class Separator , class EmptySetType , class OStreamType >

void polybori::dd_print_term	(	Iterator	start,
		Iterator	finish,
		const NameGenerator &	get_name,
		const Separator &	sep,
		const EmptySetType &	emptyset,
		OStreamType &	os
	)

Referenced by dd_print_term(), and dd_print_terms().

template<class TermType , class NameGenerator , class Separator , class EmptySetType , class OStreamType >

void polybori::dd_print_term	(	const TermType &	term,
		const NameGenerator &	get_name,
		const Separator &	sep,
		const EmptySetType &	emptyset,
		OStreamType &	os
	)

References dd_print_term().

template<class Iterator , class NameGenerator , class Separator , class InnerSeparator , class EmptySetType , class OStreamType >

void polybori::dd_print_terms	(	Iterator	start,
		Iterator	finish,
		const NameGenerator &	get_name,
		const Separator &	sep,
		const InnerSeparator &	innersep,
		const EmptySetType &	emptyset,
		OStreamType &	os
	)

References dd_print_term().

Referenced by polybori::BooleSet::print(), and polybori::BoolePolynomial::print().

template<class CacheType , class DegCacheMgr , class NaviType , class TermType , class SizeType , class DescendingProperty >

TermType polybori::dd_recursive_degree_lead	(	const CacheType &	cache_mgr,
		const DegCacheMgr &	deg_mgr,
		NaviType	navi,
		TermType	init,
		SizeType	degree,
		DescendingProperty	prop
	)

References max_degree_on_then().

Referenced by dd_recursive_degree_lead(), polybori::DegRevLexAscOrder::lead(), and polybori::DegLexOrder::lead().

template<class CacheType , class DegCacheMgr , class NaviType , class TermType , class DescendingProperty >

TermType polybori::dd_recursive_degree_lead	(	const CacheType &	cache_mgr,
		const DegCacheMgr &	deg_mgr,
		NaviType	navi,
		TermType	init,
		DescendingProperty	prop
	)

References dd_cached_degree(), and dd_recursive_degree_lead().

template<class CacheType , class DegCacheMgr , class NaviType , class TermType , class SizeType , class DescendingProperty >

TermType& polybori::dd_recursive_degree_leadexp	(	const CacheType &	cache_mgr,
		const DegCacheMgr &	deg_mgr,
		NaviType	navi,
		TermType &	result,
		SizeType	degree,
		DescendingProperty	prop
	)

References max_degree_on_then().

Referenced by dd_recursive_degree_leadexp(), polybori::DegRevLexAscOrder::leadExp(), and polybori::DegLexOrder::leadExp().

template<class CacheType , class DegCacheMgr , class NaviType , class TermType , class DescendingProperty >

TermType& polybori::dd_recursive_degree_leadexp	(	const CacheType &	cache_mgr,
		const DegCacheMgr &	deg_mgr,
		NaviType	navi,
		TermType &	result,
		DescendingProperty	prop
	)

References dd_cached_degree(), and dd_recursive_degree_leadexp().

template<class NaviType , class TermType , class OutIterator , class ThenBinaryOperator , class ElseBinaryOperator , class TerminalOperator >

OutIterator polybori::dd_transform	(	NaviType	navi,
		TermType	init,
		OutIterator	result,
		ThenBinaryOperator	then_binop,
		ElseBinaryOperator	else_binop,
		TerminalOperator	terminate
	)

Function templates for transforming decision diagrams.

Referenced by dd_transform().

template<class NaviType , class TermType , class OutIterator , class ThenBinaryOperator , class ElseBinaryOperator , class TerminalOperator , class FirstTermOp >

OutIterator polybori::dd_transform	(	NaviType	navi,
		TermType	init,
		OutIterator	result,
		ThenBinaryOperator	then_binop,
		ElseBinaryOperator	else_binop,
		TerminalOperator	terminate,
		FirstTermOp	terminate_first
	)

Function templates for transforming decision diagrams with special treatment of the leading term

References dd_transform().

template<class NaviType , class TermType , class OutIterator , class ThenBinaryOperator , class ElseBinaryOperator >

void polybori::dd_transform	(	const NaviType &	navi,
		const TermType &	init,
		const OutIterator &	result,
		const ThenBinaryOperator &	then_binop,
		const ElseBinaryOperator &	else_binop
	)

Function templates for transforming decision diagrams.

References dd_transform().

template<class NaviType , class TermType , class OutIterator , class ThenBinaryOperator >

void polybori::dd_transform	(	const NaviType &	navi,
		const TermType &	init,
		const OutIterator &	result,
		const ThenBinaryOperator &	then_binop
	)

Function templates for transforming decision diagrams.

References dd_transform().

void polybori::dec_ref ( DdNode * node ) [inline]

template<class NaviType >

void polybori::dec_ref ( const NaviType & navi ) [inline]

template<class LhsType , class RhsType , class BinaryPredicate >

CTypes::comp_type polybori::deg_lex_compare	(	const LhsType &	lhs,
		const RhsType &	rhs,
		BinaryPredicate	idx_comp
	)

defines degree-lexicographic comparison

deg_lex_compare

References generic_compare_3way(), and lex_compare().

Referenced by polybori::DegRevLexAscOrder::compare(), and polybori::DegLexOrder::compare().

DdNode* polybori::do_get_node ( DdNode * node ) [inline]

Referenced by apply_assign_cudd_function(), apply_cudd_function(), and apply_replacing_cudd_function().

template<class NaviType >

DdNode* polybori::do_get_node ( const NaviType & navi ) [inline]

template<class StackType , class Iterator >

void polybori::dummy_append	(	StackType &	stack,
		Iterator	start,
		Iterator	finish
	)

template<class ExpType , class RhsType , class ResultType >

void polybori::exp_divide	(	const ExpType &	lhs,
		const RhsType &	rhs,
		ResultType &	result
	)

Referenced by polybori::BooleExponent::divide().

template<class ExpType , class RhsIterator , class SizeType , class ResultType >

void polybori::exp_multiply	(	const ExpType &	lhs,
		RhsIterator	start,
		RhsIterator	finish,
		SizeType	nlen,
		ResultType &	result
	)

Referenced by exp_multiply(), polybori::BooleExponent::multiply(), and polybori::BooleExponent::multiplyFirst().

template<class ExpType , class RhsType , class ResultType >

void polybori::exp_multiply	(	const ExpType &	lhs,
		const RhsType &	rhs,
		ResultType &	result
	)

References exp_multiply().

Cudd* polybori::extract_manager ( const Cudd & mgr ) [inline]

CCuddInterface::mgrcore_ptr polybori::extract_manager ( const CCuddInterface & mgr ) [inline]

template<class MgrType >

const MgrType& polybori::extract_manager ( const MgrType & mgr ) [inline]

ZDD polybori::fetch_diagram	(	const Cudd &	mgr,
		const ZDD &	rhs
	)		`[inline]`

Referenced by polybori::CDDManagerBase< Cudd, Cudd >::fetchDiagram().

template<class MgrType , class DDType >

const DDType& polybori::fetch_diagram	(	const MgrType &	mgr,
		const DDType &	rhs
	)		`[inline]`

Cudd& polybori::fetch_manager ( const Cudd & mgr ) [inline]

template<class MgrType >

const MgrType& polybori::fetch_manager ( const MgrType & mgr ) [inline]

template<class HashType >

void polybori::finalize_term_hash ( HashType & seed )

Referenced by stable_first_hash_range(), and stable_term_hash().

BooleExponent polybori::GCD	(	const BooleExponent &	lhs,
		const BooleExponent &	rhs
	)		`[inline]`

Compute the greatest common divisor of two monomials.

References polybori::BooleExponent::GCD().

BooleMonomial polybori::GCD	(	const BooleMonomial &	lhs,
		const BooleMonomial &	rhs
	)		`[inline]`

Compute the greatest common divisor of two monomials.

References polybori::BooleMonomial::GCD().

template<class MonomType , class PolyType >

PolyType polybori::generate_mapping	(	MonomType &	fromVars,
		MonomType &	toVars,
		PolyType	init
	)

Referenced by mapping().

template<class LhsType , class RhsType , class BinaryPredicate >

CTypes::comp_type polybori::generic_compare_3way	(	const LhsType &	lhs,
		const RhsType &	rhs,
		BinaryPredicate	comp
	)

defines lexicographic comparison for variable indices

generic_compare_3way

Referenced by block_deg_lex_idx_compare(), block_dlex_compare(), polybori::DegRevLexAscOrder::compare(), polybori::BlockDegLexOrder::compare(), polybori::DegLexOrder::compare(), polybori::LexOrder::compare(), and deg_lex_compare().

Cudd& polybori::get_manager ( Cudd * mgr ) [inline]

Referenced by polybori::CDDInterface< CuddLikeZDD >::manager().

template<class MgrType >

const MgrType& polybori::get_manager ( const MgrType & mgr ) [inline]

template<class MgrType >

const MgrType& polybori::get_mgr_core ( const MgrType & rhs ) [inline]

Referenced by cudd_generate_divisors(), and cudd_generate_multiples().

Cudd* polybori::get_mgr_core ( const Cudd & rhs ) [inline]

CCuddInterface::mgrcore_ptr polybori::get_mgr_core ( const CCuddInterface & mgr ) [inline]

Todo:: merge with extract_manager

BooleMonomial::bool_type polybori::greater_variable	(	BooleMonomial::idx_type	lhs,
		BooleMonomial::idx_type	rhs
	)

Checks whether BooleVariable(lhs) > BooleVariable(rhs)

greater_variable

References polybori::CCompareEnums::greater_than, polybori::BooleEnv::ordering(), and PBORI_TRACE_FUNC.

void polybori::inc_ref ( DdNode * node ) [inline]

Referenced by apply_assign_cudd_function(), apply_cudd_function(), apply_replacing_cudd_function(), dd_minimal_elements(), and indexed_term_multiples().

template<class NaviType >

void polybori::inc_ref ( const NaviType & navi ) [inline]

template<class IteratorLike , class ForwardIteratorTag >

IteratorLike polybori::increment_iteratorlike	(	IteratorLike	iter,
		ForwardIteratorTag
	)

Referenced by increment_iteratorlike().

template<class IteratorLike >

IteratorLike polybori::increment_iteratorlike	(	IteratorLike	iter,
		navigator_tag
	)

template<class IteratorLike >

IteratorLike polybori::increment_iteratorlike ( IteratorLike iter )

References increment_iteratorlike().

template<class Iterator >

Iterator::value_type polybori::index_vector_hash	(	Iterator	start,
		Iterator	finish
	)

template<class NaviType , class ReverseIterator , class DDOperations >

NaviType polybori::indexed_term_multiples	(	NaviType	navi,
		ReverseIterator	idxStart,
		ReverseIterator	idxFinish,
		const DDOperations &	apply
	)

References inc_ref().

Referenced by dd_minimal_elements(), and minimal_of_two_terms().

void polybori::intrusive_ptr_add_ref ( CCuddCore * pCore ) [inline]

Increment reference count.

References polybori::CCuddCore::addRef().

void polybori::intrusive_ptr_release ( CCuddCore * pCore ) [inline]

Release current pointer by decrementing reference counting.

References polybori::CCuddCore::release().

template<class NaviType >

bool polybori::is_reducible_by	(	NaviType	first,
		NaviType	second
	)

Referenced by dd_minimal_elements().

BooleExponent polybori::LCM	(	const BooleExponent &	lhs,
		const BooleExponent &	rhs
	)		`[inline]`

Compute the greatest common divisor of two monomials.

References polybori::BooleExponent::LCM().

BooleMonomial polybori::LCM	(	const BooleMonomial &	lhs,
		const BooleMonomial &	rhs
	)		`[inline]`

Compute the greatest common divisor of two monomials.

References polybori::BooleMonomial::LCM().

template<class LhsType , class RhsType , class BinaryPredicate >

CTypes::comp_type polybori::lex_compare	(	const LhsType &	lhs,
		const RhsType &	rhs,
		BinaryPredicate	idx_comp,
		valid_tag	has_easy_equality_test
	)

defines lexicographic comparison

lex_compare

References lex_compare_3way().

Referenced by polybori::LexOrder::compare(), deg_lex_compare(), and lex_compare().

template<class LhsType , class RhsType , class BinaryPredicate >

CTypes::comp_type polybori::lex_compare	(	const LhsType &	lhs,
		const RhsType &	rhs,
		BinaryPredicate	idx_comp,
		invalid_tag	has_no_easy_equality_test
	)

defines lexicographic comparison

lex_compare

References lex_compare_3way().

template<class LhsType , class RhsType , class BinaryPredicate >

CTypes::comp_type polybori::lex_compare	(	const LhsType &	lhs,
		const RhsType &	rhs,
		BinaryPredicate	idx_comp
	)

defines lexicographic comparison

lex_compare

References lex_compare().

template<class FirstIterator , class SecondIterator , class BinaryPredicate >

CTypes::comp_type polybori::lex_compare_3way	(	FirstIterator	start,
		FirstIterator	finish,
		SecondIterator	rhs_start,
		SecondIterator	rhs_finish,
		BinaryPredicate	idx_comp
	)

Referenced by lex_compare().

template<class IteratorType , class SizeType >

SizeType polybori::limited_distance	(	IteratorType	start,
		IteratorType	finish,
		SizeType	limit
	)

template<class NaviType , class LowerIterator , class ValueType >

ValueType polybori::lower_term_accumulate	(	NaviType	navi,
		LowerIterator	lstart,
		LowerIterator	lfinish,
		ValueType	init
	)

Todo:: Maybe recursive caching is efficient here.

References polybori::BooleSet::change().

Referenced by term_accumulate().

template<class PolyType , class MonomType >

PolyType polybori::mapping	(	PolyType	poly,
		MonomType	fromVars,
		MonomType	toVars
	)

References apply_mapping(), and generate_mapping().

template<class DegCacheMgr , class NaviType , class IdxType , class SizeType >

bool polybori::max_block_degree_on_then	(	const DegCacheMgr &	deg_mgr,
		NaviType	navi,
		IdxType	next_block,
		SizeType	degree,
		valid_tag	is_descending
	)

References dd_cached_block_degree().

Referenced by dd_block_degree_lead().

template<class DegCacheMgr , class NaviType , class IdxType , class SizeType >

bool polybori::max_block_degree_on_then	(	const DegCacheMgr &	deg_mgr,
		NaviType	navi,
		IdxType	next_block,
		SizeType	degree,
		invalid_tag	non_descending
	)

References dd_cached_block_degree().

template<class DegCacheMgr , class NaviType , class SizeType >

bool polybori::max_degree_on_then	(	const DegCacheMgr &	deg_mgr,
		NaviType	navi,
		SizeType	degree,
		valid_tag	is_descending
	)

References dd_cached_degree().

Referenced by dd_recursive_degree_lead(), and dd_recursive_degree_leadexp().

template<class DegCacheMgr , class NaviType , class SizeType >

bool polybori::max_degree_on_then	(	const DegCacheMgr &	deg_mgr,
		NaviType	navi,
		SizeType	degree,
		invalid_tag	non_descending
	)

References dd_cached_degree().

template<class NaviType , class ReverseIterator , class DDOperations >

NaviType polybori::minimal_of_two_terms	(	NaviType	navi,
		NaviType &	multiples,
		ReverseIterator	idxStart,
		ReverseIterator	idxFinish,
		const DDOperations &	apply
	)

!!!!!!!!!!!!

elseTail = elseNavi;

Cudd_Ref(elseTail); 1 elseMult = elseTail;

!2 thenTail = thenNavi;

!1 thenMult= thenTail;

References indexed_term_multiples(), and prepend_multiples_wrt_indices().

Referenced by dd_minimal_elements().

BoolePolynomial::bool_type polybori::operator!=	(	BoolePolynomial::bool_type	lhs,
		const BoolePolynomial &	rhs
	)		`[inline]`

Nonquality check (with constant lhs)

BoolePolynomial polybori::operator%	(	const BoolePolynomial &	lhs,
		const BooleVariable &	rhs
	)		`[inline]`

Remainder of division of a polynomial by a variable.

template<class RHSType >

BoolePolynomial polybori::operator%	(	const BoolePolynomial &	lhs,
		const RHSType &	rhs
	)		`[inline]`

Modulus monomial (division remainder)

BoolePolynomial& polybori::operator%=	(	BoolePolynomial &	lhs,
		const BooleVariable &	rhs
	)		`[inline]`

Remainder of division of a polynomial by a variable (with assignment)

BooleMonomial polybori::operator*	(	const BooleMonomial &	lhs,
		const BooleMonomial &	rhs
	)		`[inline]`

Multiplication of monomials.

BooleMonomial polybori::operator*	(	const BooleMonomial &	lhs,
		const BooleVariable &	rhs
	)		`[inline]`

Multiplication of monomials.

BoolePolynomial polybori::operator*	(	const BooleMonomial &	lhs,
		BooleConstant	rhs
	)		`[inline]`

Multiplication of monomials.

BoolePolynomial polybori::operator*	(	BooleConstant	lhs,
		const BooleMonomial &	rhs
	)		`[inline]`

Multiplication of monomials.

BoolePolynomial polybori::operator*	(	const BooleVariable &	lhs,
		const BooleConstant &	rhs
	)		`[inline]`

Multiplication of variables by a 0 or 1.

BoolePolynomial polybori::operator*	(	const BooleConstant &	lhs,
		const BooleVariable &	rhs
	)		`[inline]`

Multiplication of 0 or 1 by a Variable.

BoolePolynomial polybori::operator*	(	const BooleVariable &	lhs,
		const BoolePolynomial &	rhs
	)		`[inline]`

Multiplication of variables by a polynomial.

BooleMonomial polybori::operator*	(	const BooleVariable &	lhs,
		const BooleMonomial &	rhs
	)		`[inline]`

Multiplication of variables by a monomial.

BooleMonomial polybori::operator*	(	const BooleVariable &	lhs,
		const BooleVariable &	rhs
	)		`[inline]`

Multiplication of monomials by a polynomial.

BoolePolynomial polybori::operator*	(	const BoolePolynomial &	lhs,
		const BooleVariable &	rhs
	)		`[inline]`

Multiplication of a polynomial by a variable.

BoolePolynomial polybori::operator*	(	const BoolePolynomial &	lhs,
		const BoolePolynomial &	rhs
	)		`[inline]`

BoolePolynomial polybori::operator*	(	const BoolePolynomial &	lhs,
		const BooleMonomial &	rhs
	)		`[inline]`

BoolePolynomial polybori::operator*	(	const BoolePolynomial &	lhs,
		const BooleExponent &	rhs
	)		`[inline]`

BoolePolynomial polybori::operator*	(	const BoolePolynomial &	lhs,
		const BooleConstant &	rhs
	)		`[inline]`

BoolePolynomial polybori::operator*	(	const BooleMonomial &	lhs,
		const BoolePolynomial &	rhs
	)		`[inline]`

BoolePolynomial polybori::operator*	(	const BooleExponent &	lhs,
		const BoolePolynomial &	rhs
	)		`[inline]`

BoolePolynomial polybori::operator*	(	const BooleConstant &	lhs,
		const BoolePolynomial &	rhs
	)		`[inline]`

BoolePolynomial& polybori::operator*=	(	BoolePolynomial &	lhs,
		const BooleVariable &	rhs
	)		`[inline]`

Multiplication of a polynomial by a variable with assignment.

template<class RHSType >

BooleExponent polybori::operator+	(	const BooleExponent &	lhs,
		const RHSType &	rhs
	)		`[inline]`

Multiplication of monomials.

References polybori::BooleExponent::multiply().

BoolePolynomial polybori::operator+	(	const BoolePolynomial &	lhs,
		const BoolePolynomial &	rhs
	)		`[inline]`

Addition operation.

BoolePolynomial polybori::operator+	(	const BoolePolynomial &	lhs,
		BooleConstant	rhs
	)		`[inline]`

Addition operation.

BoolePolynomial polybori::operator+	(	BooleConstant	lhs,
		const BoolePolynomial &	rhs
	)		`[inline]`

Addition operation.

template<class RHSType >

BooleExponent polybori::operator-	(	const BooleExponent &	lhs,
		const RHSType &	rhs
	)		`[inline]`

Division of monomials.

References polybori::BooleExponent::divide().

template<class RHSType >

BoolePolynomial polybori::operator-	(	const BoolePolynomial &	lhs,
		const RHSType &	rhs
	)		`[inline]`

Subtraction operation.

BoolePolynomial polybori::operator-	(	const BooleConstant &	lhs,
		const BoolePolynomial &	rhs
	)		`[inline]`

Subtraction operation with constant right-hand-side.

BoolePolynomial polybori::operator/	(	const BooleVariable &	lhs,
		const BooleVariable &	rhs
	)		`[inline]`

References polybori::BooleVariable::ring().

BooleMonomial polybori::operator/	(	const BooleMonomial &	lhs,
		const BooleMonomial &	rhs
	)		`[inline]`

Division of monomials.

BooleMonomial polybori::operator/	(	const BooleMonomial &	lhs,
		const BooleVariable &	rhs
	)		`[inline]`

Division of monomials.

BoolePolynomial polybori::operator/	(	const BoolePolynomial &	lhs,
		const BooleVariable &	rhs
	)		`[inline]`

Division of a polynomial by a variable (forcing monomial variant)

template<class RHSType >

BoolePolynomial polybori::operator/	(	const BoolePolynomial &	lhs,
		const RHSType &	rhs
	)		`[inline]`

Division by monomial (skipping remainder)

BoolePolynomial& polybori::operator/=	(	BoolePolynomial &	lhs,
		const BooleVariable &	rhs
	)		`[inline]`

Division of a polynomial by a variable (forcing monomial variant)

BooleExponent::bool_type polybori::operator<	(	const BooleExponent &	lhs,
		const BooleExponent &	rhs
	)		`[inline]`

Less than comparision.

References polybori::BooleExponent::compare().

BooleMonomial::bool_type polybori::operator<	(	const BooleMonomial &	lhs,
		const BooleMonomial &	rhs
	)		`[inline]`

Less than comparision.

References polybori::BooleMonomial::compare().

CTypes::ostream_type& polybori::operator<<	(	CTypes::ostream_type &	os,
		const BooleConstant &	rhs
	)		`[inline]`

Stream output operator.

template<class IdxType , class SeparatorType >

CIdxPath<IdxType, SeparatorType>::ostream_type& polybori::operator<<	(	typename CIdxPath< IdxType, SeparatorType >::ostream_type &	os,
		const CIdxPath< IdxType, SeparatorType > &	storage
	)		`[inline]`

Stream output operator.

References polybori::CIdxPath< IdxType, SeparatorType >::print().

BooleExponent::ostream_type& polybori::operator<<	(	BooleExponent::ostream_type &	os,
		const BooleExponent &	rhs
	)		`[inline]`

Stream output operator.

References polybori::BooleExponent::print().

BooleSet::ostream_type& polybori::operator<<	(	BooleSet::ostream_type &	os,
		const BooleSet &	bset
	)		`[inline]`

Stream output operator.

References polybori::BooleSet::print().

BoolePolynomial::ostream_type & polybori::operator<<	(	BoolePolynomial::ostream_type &	os,
		const BoolePolynomial &	source
	)

Stream output operator.

References polybori::BoolePolynomial::print().

template<class DDType >

CDDInterface<DDType>::ostream_type& polybori::operator<<	(	typename CDDInterface< DDType >::ostream_type &	os,
		const CDDInterface< DDType > &	dd
	)

Stream output operator.

References polybori::CDDInterface< CuddLikeZDD >::print().

BooleExponent::bool_type polybori::operator<=	(	const BooleExponent &	lhs,
		const BooleExponent &	rhs
	)		`[inline]`

Less or equal than comparision.

References polybori::BooleExponent::compare().

BooleMonomial::bool_type polybori::operator<=	(	const BooleMonomial &	lhs,
		const BooleMonomial &	rhs
	)		`[inline]`

Less or equal than comparision.

References polybori::BooleMonomial::compare().

BoolePolynomial::bool_type polybori::operator==	(	BoolePolynomial::bool_type	lhs,
		const BoolePolynomial &	rhs
	)		`[inline]`

Equality check (with constant lhs)

BooleExponent::bool_type polybori::operator>	(	const BooleExponent &	lhs,
		const BooleExponent &	rhs
	)		`[inline]`

Greater than comparision.

References polybori::BooleExponent::compare().

BooleMonomial::bool_type polybori::operator>	(	const BooleMonomial &	lhs,
		const BooleMonomial &	rhs
	)		`[inline]`

Greater than comparision.

References polybori::BooleMonomial::compare().

BooleExponent::bool_type polybori::operator>=	(	const BooleExponent &	lhs,
		const BooleExponent &	rhs
	)		`[inline]`

Greater or equal than comparision.

References polybori::BooleExponent::compare().

BooleMonomial::bool_type polybori::operator>=	(	const BooleMonomial &	lhs,
		const BooleMonomial &	rhs
	)		`[inline]`

Greater or equal than comparision.

References polybori::BooleMonomial::compare().

template<class ValueType >

void polybori::pbori_shared_ptr_postclean	(	const boost::shared_ptr< ValueType > &	,
		const boost::shared_ptr< ValueType > &
	)

template<class MgrType , class NodeType >

NodeType polybori::pboriCudd_zddUnionXor	(	MgrType	dd,
		NodeType	P,
		NodeType	Q
	)

References pboriCuddZddUnionXor().

Referenced by polybori::CDDInterface< CuddLikeZDD >::Xor().

template<class MgrType , class NodeType >

NodeType polybori::pboriCuddZddUnionXor	(	MgrType	zdd,
		NodeType	P,
		NodeType	Q
	)

The following should be made more generic

Todo:: This is still Cudd-like style, should be rewritten with PolyBoRi's cache wrapper, which would the dependency on cuddInt.h

References pboriCuddZddUnionXor__().

Referenced by pboriCudd_zddUnionXor().

DdNode * polybori::pboriCuddZddUnionXor__	(	DdManager *	,
		DdNode *	,
		DdNode *
	)

Referenced by pboriCuddZddUnionXor().

template<class NaviType , class SizeType , class ReverseIterator , class DDOperations >

NaviType polybori::prepend_multiples_wrt_indices	(	NaviType	navi,
		SizeType	minIdx,
		ReverseIterator	start,
		ReverseIterator	finish,
		const DDOperations &	apply
	)

Referenced by dd_minimal_elements(), and minimal_of_two_terms().

template<class MgrType >

void polybori::recursive_dec_ref	(	const MgrType &	mgr,
		DdNode *	node
	)		`[inline]`

Referenced by apply_assign_cudd_function(), apply_replacing_cudd_function(), polybori::dd_operations< CTypes::dd_type::navigator >::kill(), polybori::dd_operations< CTypes::dd_type::navigator >::newNodeAssign(), polybori::dd_operations< CTypes::dd_type::navigator >::replace(), and polybori::dd_operations< CTypes::dd_type::navigator >::replacingNode().

template<class MgrType , class NaviType >

void polybori::recursive_dec_ref	(	const MgrType &	mgr,
		const NaviType &	navi
	)		`[inline]`

template<class FirstIterator , class SecondIterator , class IdxType , class BinaryPredicate >

CTypes::comp_type polybori::restricted_lex_compare_3way	(	FirstIterator	start,
		FirstIterator	finish,
		SecondIterator	rhs_start,
		SecondIterator	rhs_finish,
		IdxType	max_index,
		BinaryPredicate	idx_comp
	)

Referenced by block_dlex_compare().

template<class InputIterator , class Intermediate , class OutputIterator >

OutputIterator polybori::reversed_inter_copy	(	InputIterator	start,
		InputIterator	finish,
		Intermediate &	inter,
		OutputIterator	output
	)

Function templates doing a reversed copy using intermediate storage.

Referenced by dd_last_lexicographical_term(), polybori::BoolePolynomial::firstDivisors(), and polybori::LexOrder::lead().

template<class InputIterator , class OutputIterator , class FirstFunction , class UnaryFunction >

OutputIterator polybori::special_first_transform	(	InputIterator	first,
		InputIterator	last,
		OutputIterator	result,
		UnaryFunction	op,
		FirstFunction	firstop
	)

Referenced by polybori::CIdxPath< IdxType, SeparatorType >::print().

BoolePolynomial polybori::spoly	(	const BoolePolynomial &	first,
		const BoolePolynomial &	second
	)		`[inline]`

spoly Compute spoly of two polynomials

References polybori::BoolePolynomial::lead().

Referenced by polybori::groebner::nf1(), polybori::groebner::nf2(), polybori::groebner::nf2_short(), polybori::groebner::nf3_db(), polybori::groebner::nf3_short(), polybori::groebner::nf_delaying(), and polybori::groebner::nf_delaying_exchanging().

template<class HashType , class NaviType >

void polybori::stable_first_hash_range	(	HashType &	seed,
		NaviType	navi
	)

References finalize_term_hash().

Referenced by polybori::BoolePolynomial::lmStableHash(), stable_first_hash_range(), and polybori::BooleMonomial::stableHash().

template<class NaviType >

std::size_t polybori::stable_first_hash_range ( NaviType navi )

References stable_first_hash_range().

template<class HashType , class NaviType >

void polybori::stable_hash_range	(	HashType &	seed,
		NaviType	navi
	)

Referenced by stable_hash_range(), and polybori::CDDInterface< CuddLikeZDD >::stableHash().

template<class NaviType >

std::size_t polybori::stable_hash_range ( NaviType navi )

References stable_hash_range().

template<class HashType , class Iterator >

void polybori::stable_term_hash	(	HashType &	seed,
		Iterator	start,
		Iterator	finish
	)

References finalize_term_hash().

Referenced by stable_term_hash(), and polybori::BooleExponent::stableHash().

template<class Iterator >

std::size_t polybori::stable_term_hash	(	Iterator	start,
		Iterator	finish
	)

References stable_term_hash().

template<class UpperIterator , class NaviType , class LowerIterator , class ValueType >

ValueType polybori::term_accumulate	(	UpperIterator	ustart,
		UpperIterator	ufinish,
		NaviType	navi,
		LowerIterator	lstart,
		LowerIterator	lfinish,
		ValueType	init
	)