polybori Namespace Reference

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 reinterprets decicion diagram managers as Boolean polynomial rings, adds an ordering and variable names. More...
class	BooleSet
class	BooleSetSequence
	This class converts a BooleSet to a sequence-like structure. More...
class	BooleVariable
	This class is just a wrapper for using variables from cudd's decicion diagram. More...
class	CacheManager
class	CommutativeCacheManager
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< CCuddInterface, CacheType, ArgumentLength > >
struct	pbori_base< CCacheManBase< BoolePolyRing, CacheType, ArgumentLength > >
struct	pbori_base< CCacheManBase< boost::intrusive_ptr< CCuddCore >, 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	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	CBoundedDegreeCache
class	CBlockDegreeCache
class	CDegreeArgumentCache
class	CCheckedIdx
	This class defines CCheckedIdx. More...
class	CExtrusivePtr
	This template class defines a reimplementation of the interface from boost:intrusive_ptr, but with an additional data field. More...
class	CWeakPtr
	This class defines CWeakPtr. More...
class	CWeakPtrFacade
	This class defines CWeakPtrFacade. More...
class	invalid_tag
	This class shows, whether a property of an order is invalid. More...
class	valid_tag
	This class shows, whether a property of an order is valid. More...
struct	invert_tag< valid_tag >
struct	invert_tag< invalid_tag >
class	and_tag
	and_tag<valid_tag, valid_tag> -> valid_tag, otherwise invalid_tag. More...
struct	and_tag< valid_tag, valid_tag >
class	navigator_tag
	for iterator_category More...
class	equality_property
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
struct	cudd_error_traits
class	TransformedSequence
	This class converts a sequence-like structure when iterating. More...
class	DegLexOrder
	This class defines ordering related functions. More...
class	DegRevLexAscOrder
	This class defines ordering related functions. More...
class	CApplyNodeFacade
	This template class defines a facade as a C++ interface for applying C-style functions to C-style structs, which represent decision diagrams. It is used to wrapp functions calls to raw pointers of the nodes and the context to an C++-style object. More...
class	CCuddDDFacade
	This template class defines a facade for decision diagrams. More...
class	CDDOperations
class	CNodeCounter
	This class defines CNodeCounter. More...
class	Interpreter
class	DerefProxy
class	dict
class	tuple
class	object
class	CErrorInfo
class	PBoRiError
	This class is used for polybori's exception handling. More...
class	PBoRiGenericError
	This template class is used for polybori's exception handling. More...
class	CFactoryBase
	This base class CFactoryBase is used for currying other constructors with a BoolePolyRing. More...
class	MonomialFactory
	This base class MonomialFactory is used for currying monomial constructors with a BoolePolyRing. More...
class	PolynomialFactory
	This base class PolynomialFactory is used for currying polynomial constructors with a BoolePolyRing. More...
class	SetFactory
	This base class SetFactory is used for currying set constructors with a BoolePolyRing. More...
class	VariableIndexException
class	VariableBlock
	This class defines a VariableBlock. More...
class	VariableFactory
	This base class VariableFactory is used for currying variable constructors with a BoolePolyRing. More...
class	handle_else
class	CCuddFirstIter
	This class defines an iterator over the first minimal term of a given ZDD node. More...
class	CCuddLastIter
	This class defines an iterator over the last minimal term of a given ZDD node. More...
class	CCuddNavigator
	This class defines an iterator for navigating through then and else branches of ZDDs. More...
class	CExpGenerator
struct	pbori_base< CExpIter< NaviType, ExpType > >
class	CExpIter
struct	pbori_base< CGenericIter< OrderType, NaviType, RefType > >
class	CGenericIter
struct	pbori_base< CReverseIter< OrderType, NaviType, RefType > >
class	CReverseIter
class	CAbstractStackBase
class	CWrappedStack
class	COrderedIter
class	CGenericOrderedIter
class	CGenericOrderedIter< OrderType, NavigatorType, BooleExponent >
class	CStackSelector
class	CTermGeneratorBase__< TermType, type_tag< BooleExponent > >
class	CTermGeneratorBase__< TermType, type_tag< CTypes::size_type > >
class	CTermGeneratorBase__< TermType, type_tag< CTypes::deg_type > >
class	CTermGeneratorBase__< TermType, type_tag< BooleMonomial > >
class	CTermGeneratorBase
class	CTermGenerator
class	CTermGenerator< BooleMonomial >
class	CTermIter
	This class defines an iterator for the monomials in a Boolean polynomial. More...
struct	cached_deg
class	cached_block_deg
class	CTermStackBase
	This class defines an iterator for the monomials in a Boolean polynomial. More...
class	CTermStack
	This class defines an iterator for the monomials in a Boolean polynomial. More...
class	CReverseTermStack
	This class defines an iterator for the monomials in a Boolean polynomial in reversed lexicographicxal order. More...
class	CDegStackCore< NavigatorType, invalid_tag, Category, BaseType >
	for pure degree stacks More...
class	CDegStackCore< NavigatorType, valid_tag, Category, BaseType >
	for block stacks More...
class	CDegStackBase< NavigatorType, valid_tag, BlockProperty, BaseType >
class	CDegStackBase< NavigatorType, invalid_tag, BlockProperty, BaseType >
class	CDegTermStack
class	CBlockTermStack
class	CVariableIter
	This template class defines an iterator for monomial types. 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	UnaryOperatorTraits
class	UnaryOperatorTraits< ResultType(*)(ArgType)>
class	TransformedIterator
	This class defines the iterator of Trnasformed sequence. More...
class	LexOrder
	This class defines ordering related functions. More...
class	CLiteralCodes
	This template class defines enumerative codes for the string literals defined by the CStringLiterals class. More...
class	CStringLiteral
	This template class defines string literals corresponding to the codes enumerated in the class CLiteralCodes. More...
class	CBlockOrderingFacade
	This class implements block orderings for COrderingFacade. OrderType must inherit from COrderingFacade<OrderType>. More...
class	COrderingBase
class	COrderingFacade
	This class initialize the interface for orderings of CDynamicOrderBase for a given OrderType. OrderType must inherit from COrderingFacade<OrderType>. More...
class	COrderingTagsBase
class	CDegreeOrderingTags
class	CBlockDegreeOrderingTags
class	COrderingTags< lex_tag >
class	COrderingTags< dlex_tag >
class	COrderingTags< dp_asc_tag >
class	COrderingTags< block_dlex_tag >
class	COrderingTags< block_dp_asc_tag >
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_tag
	Marker for block orderings. More...
struct	order_traits_code< lex_tag >
struct	order_traits_code< dlex_tag >
struct	order_traits_code< dp_asc_tag >
struct	order_traits_code< block_dlex_tag >
struct	order_traits_code< block_dp_asc_tag >
class	order_traits< block_tag< BaseOrderTag > >
class	order_traits
class	lex_compare_predicate
	defines lexicographic comparison functor More...
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	CCallbackFacade
	Variant for constant non-void member functions. More...
class	CCallbackFacade< Type, void, ArgType >
	Specialized variant for constant void member functions. More...
class	CCallbackWrapper
	This template class defines a functional, which wraps operator .*, which is the callback of a dynamic member function wrt. a given object. More...
class	CCuddCore
	This class prepares the CUDD's raw decision diagram manager structure for the use with instrinsive pointers. More...
class	CCuddInterface
	This class defines a C++ interface to CUDD's decicion diagram manager. More...
class	CMemberFunctionTraitsBase
	Axuiliary class. More...
class	CMemberFunctionTraits< ResultType(Type::*)()>
class	CMemberFunctionTraits< ResultType(Type::*)() const >
class	CMemberFunctionTraits< ResultType(Type::*)(ArgType)>
class	CMemberFunctionTraits< ResultType(Type::*)(ArgType) const >
class	MemberFunctionOperator
class	CVariableNames
class	WeakRingPtr
	This class defines WeakRingPtr. More...
class	dd_operations< CCuddNavigator >
class	push_back
	Accessing .push_back(). More...
class	change_idx
class	change_assign
	Accessing .changeAssign(). More...
class	change_assign< void, pbori_traits< void >::idx_type >
class	subset1_assign
	Accessing .subset1Assign(). More...
class	subset0_assign
	Accessing .subset1Assign(). More...
class	unite_assign
	Accessing .uniteAssign(). More...
class	project_ith< 0, NLEN >
class	project_ith< 1, NLEN >
class	project_ith< 2, NLEN >
class	project_ith< 3, NLEN >
class	dummy_iterator
	An iterator which virtually does nothing. More...
class	pbori_traits< dummy_iterator >
class	integral_constant
	integral_constant<int_type, NUM>()() returns NUM of int_type, instead of possibly arguments. integral_constant<int_type, NUM, other_type>()() returns conversion of NUM of int_type to other_type. More...
class	binary_composition
	Compose a binary function with two default constructable unary functions. More...
class	symmetric_composition
	Compose a binary function with a default constructable unary function for both arguments. More...
class	maximum_iteration
	Returns maximun of given argument and previous calls. More...
class	dd_add_assign
	Defines addition operation with assignment for decision diagrams. More...
class	times_indexed_var
	Defines multiplication operation with the idx-th variable. More...
class	append_indexed_divisor
	Defines multiplication (with assignment) with the idx-th variable. More...
class	inserts
	Accessing .insert(). More...
class	inserts< void, pbori_traits< void >::idx_type >
class	insert_assign
	Accessing .insertAssign(). More...
class	insert_assign< void, pbori_traits< void >::idx_type >
class	removes
	Accessing .remove(). More...
class	removes< void, pbori_traits< void >::idx_type >
class	remove_assign
	Accessing .removeAssign(). More...
class	remove_assign< void, pbori_traits< void >::idx_type >
class	insert_second_to_list
	Insert second argument to a given list. More...
class	is_same_type< Type, Type >
class	is_same_type
	This class tests whether two types equal. More...
class	is_valid
class	on_same_type< Type, Type, ThenType, ElseType >
class	on_same_type
	This class switches betweem two types, depending on equality of types. More...
class	internal_tag
	This class marks an internal part of a procedure. More...
class	type_tag
	This class marks a given type. More...
class	hashes
class	generate_index_map
class	sizes_less
	A functional for size comparisons. More...
class	reversed_iteration_adaptor
class	navigates
class	default_value
class	constant_binder_base
class	constant_binder2nd
class	constant_binder1st
class	default_binder_base
class	default_binder2nd
class	default_binder1st
class	variable_name
	Defines generic access to variable names. More...
class	mapped_new_node
class	get_node
class	dummy_data_type
class	bounded_restricted_term
class	EliminationDegreeAdder
class	AddEliminationDegree
Namespaces
namespace	groebner
Typedefs
typedef pbori_DdManager	DdManager
typedef BoolePolyRing	Ring
	convenience aliases
typedef BoolePolynomial	Polynomial
typedef BooleVariable	Variable
typedef BooleMonomial	Monomial
typedef block_tag< dlex_tag >	block_dlex_tag
	Marker for block deg-lex ordering.
typedef block_tag< dp_asc_tag >	block_dp_asc_tag
	Marker for ascending block deg-rev-lex ordering.
Enumerations
enum	order_codes {   lp = polybori ::COrderEnums::lp, dlex = polybori ::COrderEnums::dlex, dp_asc = polybori ::COrderEnums::dp_asc, block_dlex = polybori ::COrderEnums::block_dlex,   block_dp_asc = polybori ::COrderEnums::block_dp_asc }
	copy enums for convenience More...
Functions
CTypes::ostream_type &	operator<< (CTypes::ostream_type &os, const BooleConstant &rhs)
	Stream output operator.
BooleConstant	operator+ (const BooleConstant &lhs, const BooleConstant &rhs)
BooleConstant	operator- (const BooleConstant &lhs, const BooleConstant &rhs)
BooleConstant	operator* (const BooleConstant &lhs, const BooleConstant &rhs)
BooleEnv::block_iterator	block_begin (const BooleEnv::ring_type &ring)
	please use BooleEnv::ring()
BooleEnv::block_iterator	block_end (const BooleEnv::ring_type &ring)
	Extract block data without exposing ordering stuff.
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	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.
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/ (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+ (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.
BoolePolyRing::ostream_type &	operator<< (BoolePolyRing::ostream_type &os, const BoolePolyRing &ring)
	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)
	Division.
template<class Data1, class Type1, class Data2, class Type2>
bool	operator== (const CExtrusivePtr< Data1, Type1 > &lhs, const CExtrusivePtr< Data2, Type2 > &rhs)
	Equality check.
template<class Data1, class Type1, class Data2, class Type2>
bool	operator!= (const CExtrusivePtr< Data1, Type1 > &lhs, const CExtrusivePtr< Data2, Type2 > &rhs)
	Nonequality check.
template<class Data1, class Type1, class Type2>
bool	operator== (const CExtrusivePtr< Data1, Type1 > &lhs, Type2 *rhs)
	Equality check wrt. pointer.
template<class Data1, class Type1, class Type2>
bool	operator!= (const CExtrusivePtr< Data1, Type1 > &lhs, Type2 *rhs)
	Nonequality check wrt. pointer.
template<class Type1, class Data2, class Type2>
bool	operator== (Type1 *lhs, const CExtrusivePtr< Data2, Type2 > &rhs)
	Equality check from a pointer.
template<class Type1, class Data2, class Type2>
bool	operator!= (Type1 *lhs, const CExtrusivePtr< Data2, Type2 > &rhs)
	Nonequality check from a pointer.
template<class DataType>
void	extrusive_ptr_release (const DataType &data, DdNode *ptr)
	Releasing raw pointers to decision diagrams here.
template<class DataType>
void	extrusive_ptr_add_ref (const DataType &, DdNode *ptr)
	Incrememting reference counts to raw pointers to decision diagrams.
object	eval (str expression)
object	exec (str code)
object	exec_file (str filename)
void	run (const char *code)
CCuddNavigator	explicit_navigator_cast (CCuddNavigator::pointer_type ptr)
boost::shared_ptr< COrderingBase >	get_ordering (CTypes::ordercode_type order)
template<class MemberFct>
MemberFunctionOperator< MemberFct >	member_function_operator (MemberFct func)
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>
bool	owns_one (NaviType navi)
	Test whether the empty set is included.
template<class CacheMgr, class NaviType, class SetType>
SetType	dd_modulo_monomials (const CacheMgr &cache_mgr, NaviType navi, NaviType rhs, const SetType &init)
template<class CacheMgr, class ModMonCacheMgr, class NaviType, class SetType>
SetType	dd_minimal_elements (const CacheMgr &cache_mgr, const ModMonCacheMgr &modmon_mgr, NaviType navi, const SetType &init)
	Get minimal elements with respect to inclusion.
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)
template<class ManagerType, class ReverseIterator, class MultReverseIterator, class DDBase>
DDBase	cudd_generate_multiples (const ManagerType &mgr, ReverseIterator start, ReverseIterator finish, MultReverseIterator multStart, MultReverseIterator multFinish, type_tag< DDBase >)
	temporarily (needs to be more generic) (similar fct in CCuddDDFacade.h)
template<class ManagerType, class ReverseIterator, class DDBase>
DDBase	cudd_generate_divisors (const ManagerType &mgr, ReverseIterator start, ReverseIterator finish, type_tag< DDBase >)
	temporarily (needs to be more generic) (similar fct in CCuddDDFacade.h)
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)
template<class InIter, class OutIter, class Object, class MemberFuncPtr>
OutIter	transform (InIter start, InIter finish, OutIter result, Object &obj, MemberFuncPtr func)
template<class InIter, class Object, class MemberFuncPtr>
void	for_each (InIter start, InIter finish, Object &obj, MemberFuncPtr func)
template<class InIter, class Object, class MemberFuncPtr>
void	for_each (InIter start, InIter finish, const Object &obj, MemberFuncPtr func)
template<class Type, class Type1>
const Type &	which (bool condition, const Type1 &value1, const Type &value)
template<class Type, class Type1, class Type2>
const Type &	which (bool cond1, const Type1 &value1, bool cond2, const Type2 &value2, const Type &value)
template<class Type, class Type1, class Type2, class Type3>
const Type &	which (bool cond1, const Type1 &value1, bool cond2, const Type2 &value2, bool cond3, const Type3 &value3, const Type &value)
template<class IDType, class Iterator>
bool	same_rings (const IDType &id, Iterator start, Iterator finish)
template<class Iterator>
bool	same_rings (Iterator start, Iterator finish)
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)
	Compute spoly of two polynomials.
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)
	Routine for adding all terms given by iterators.
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 MapType, class NaviType>
MapType::mapped_type	dd_long_count_step (MapType &cache, NaviType navi)
	Other routines currently at external public header file pbori_algo.h.
template<class IntType, class NaviType>
IntType	dd_long_count (NaviType navi)
	Function template for generically computing number of terms.
template<class IntType, class NaviType>
IntType	dd_long_count_without_cache (NaviType navi)
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::deg_type	dd_cached_degree (const DegreeCacher &cache, NaviType navi)
template<class DegreeCacher, class NaviType, class SizeType>
NaviType::deg_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<bool use_fast, class CacheType, class NaviType, class PolyType>
PolyType	dd_multiply (const CacheType &cache_mgr, NaviType firstNavi, NaviType secondNavi, PolyType init)
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>
PolyType	dd_multiply_recursively_monom (const CacheType &cache_mgr, NaviType monomNavi, NaviType navi, PolyType init)
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 NaviType>
NaviType	dd_get_constant (NaviType navi)
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 NaviType, class MonomIterator>
bool	dd_contains_divs_of_dec_deg (NaviType navi, MonomIterator start, MonomIterator 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 PolyType, class RingType, class MapType, class NaviType>
PolyType	substitute_variables__ (const RingType &ring, const MapType &idx2poly, NaviType navi)
template<class RingType, class MapType, class PolyType>
PolyType	substitute_variables (const RingType &ring, const MapType &idx2poly, const PolyType &poly)
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::deg_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)
FILE *	fmemopen (void *buf, size_t size, const char *opentype)
template<class CacheType, class NaviType, class DDType>
DDType	dd_lex_lead (const CacheType &cache, NaviType navi, const DDType &init)
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.

---

Typedef Documentation

typedef block_tag<dlex_tag> polybori::block_dlex_tag

Marker for block deg-lex ordering.

typedef block_tag<dp_asc_tag> polybori::block_dp_asc_tag

Marker for ascending block deg-rev-lex ordering.

typedef pbori_DdManager polybori::DdManager

typedef BooleMonomial polybori::Monomial

typedef BoolePolynomial polybori::Polynomial

typedef BoolePolyRing polybori::Ring

convenience aliases

typedef BooleVariable polybori::Variable

---

Enumeration Type Documentation

enum polybori::order_codes

copy enums for convenience

Enumerator:

lp
dlex
dp_asc
block_dlex
block_dp_asc

---

Function Documentation

template<class FunctionType, class ManagerType, class NodeType>

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

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

Referenced by polybori::dd_operations< CCuddNavigator >::diffAssign(), and polybori::dd_operations< CCuddNavigator >::uniteAssign().

template<class FunctionType, class ManagerType, class NodeType>

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

References do_get_node(), and inc_ref().

Referenced by polybori::dd_operations< CCuddNavigator >::diff().

template<class PolyType, class MapType>

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

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
	)			[inline]

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

Referenced by polybori::dd_operations< CCuddNavigator >::replacingUnite().

BooleEnv::block_iterator polybori::block_begin

(

const BooleEnv::ring_type &

ring

)

please use BooleEnv::ring()

Extract block data without exposing ordering stuff.

Extract block data without exposing ordering stuff

References polybori::BoolePolyRing::ordering().

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
	)			[inline]

Note:

: no necessary for block_dlex, only for block_dp_asc

References generic_compare_3way(), PBORI_ASSERT, and PBORI_UNLIKELY.

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
	)			[inline]

References generic_compare_3way(), and restricted_lex_compare_3way().

Referenced by polybori::CBlockOrderingFacade< polybori::BlockDegRevLexAscOrder, polybori::block_tag >::compare_terms().

BooleEnv::block_iterator polybori::block_end

(

const BooleEnv::ring_type &

ring

)

Extract block data without exposing ordering stuff.

References polybori::BoolePolyRing::ordering().

template<class Iterator, class SizeType>

Iterator polybori::bounded_max_element	(	Iterator	start,
		Iterator	finish,
		SizeType	bound
	)			[inline]

template<class CacheType, class NaviType, class MonomType>

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

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

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

template<class SetType>

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

Referenced by count_index().

template<class SetType>

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

template<class SizeType, class IdxType, class SetType>

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

Referenced by count_index().

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

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

References combine_sizes(), and count_index().

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

template<class ManagerType, class ReverseIterator, class DDBase>

DDBase polybori::cudd_generate_divisors	(	const ManagerType &	mgr,
		ReverseIterator	start,
		ReverseIterator	finish,
		type_tag< DDBase >
	)			[inline]

temporarily (needs to be more generic) (similar fct in CCuddDDFacade.h)

Todo:

Next line needs generalization

References Cudd_Deref, Cudd_RecursiveDerefZdd, Cudd_Ref, cuddUniqueInterZdd, and PBORI_PREFIX.

Referenced by polybori::BooleExponent::divisors(), and polybori::CCuddDDFacade< polybori::BoolePolyRing, polybori::BooleSet >::firstDivisors().

template<class ManagerType, class ReverseIterator, class MultReverseIterator, class DDBase>

DDBase polybori::cudd_generate_multiples	(	const ManagerType &	mgr,
		ReverseIterator	start,
		ReverseIterator	finish,
		MultReverseIterator	multStart,
		MultReverseIterator	multFinish,
		type_tag< DDBase >
	)			[inline]

temporarily (needs to be more generic) (similar fct in CCuddDDFacade.h)

Todo:

merge with extract_manager

References Cudd_Deref, Cudd_RecursiveDerefZdd, Cudd_Ref, cuddUniqueInterZdd, and PBORI_PREFIX.

Referenced by polybori::CCuddDDFacade< polybori::BoolePolyRing, polybori::BooleSet >::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
	)			[inline]

Function templates for transforming decision diagrams.

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

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
	)			[inline]

References dd_cached_block_degree().

Referenced by dd_block_degree_lead(), and polybori::CBlockOrderingFacade< polybori::BlockDegRevLexAscOrder, polybori::block_tag >::lead().

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
	)			[inline]

References dd_block_degree_lead(), dd_cached_block_degree(), and max_block_degree_on_then().

template<class DegreeCacher, class NaviType, class IdxType>

NaviType::deg_type polybori::dd_cached_block_degree	(	const DegreeCacher &	cache,
		NaviType	navi,
		IdxType	nextBlock
	)			[inline]

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

Referenced by dd_block_degree_lead(), max_block_degree_on_then(), and polybori::cached_block_deg< NavigatorType >::operator()().

template<class DegreeCacher, class NaviType, class SizeType>

NaviType::deg_type polybori::dd_cached_degree	(	const DegreeCacher &	cache,
		NaviType	navi,
		SizeType	bound
	)			[inline]

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 PBORI_ASSERT.

Referenced by dd_cached_degree(), dd_recursive_degree_lead(), dd_recursive_degree_leadexp(), max_degree_on_then(), and polybori::cached_deg< NavigatorType >::operator()().

template<class DegreeCacher, class NaviType>

NaviType::deg_type polybori::dd_cached_degree	(	const DegreeCacher &	cache,
		NaviType	navi
	)			[inline]

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

References dd_cached_degree().

Referenced by polybori::BoolePolynomial::deg(), polybori::DegRevLexAscOrder::lead(), polybori::DegLexOrder::lead(), polybori::DegRevLexAscOrder::leadExp(), and polybori::DegLexOrder::leadExp().

template<class NaviType, class MonomIterator>

bool polybori::dd_contains_divs_of_dec_deg	(	NaviType	navi,
		MonomIterator	start,
		MonomIterator	finish
	)			[inline]

Test whether a set of monomials contains all divisors of degree - 1 of a given monomial

References dd_owns(), and owns_one().

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

template<class CacheType, class NaviType, class PolyType>

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

References PBORI_ASSERT.

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

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
	)			[inline]

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
	)			[inline]

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
	)			[inline]

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

References PBORI_ASSERT.

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
	)			[inline]

References PBORI_ASSERT.

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

template<class NaviType>

NaviType polybori::dd_get_constant

(

NaviType

navi

)

[inline]

Referenced by dd_recursive_degree_lead().

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

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

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
	)			[inline]

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

)

[inline]

References dd_pair_check().

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

template<class NaviType>

bool polybori::dd_is_singleton

(

NaviType

navi

)

[inline]

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

template<class NaviType>

bool polybori::dd_is_singleton_or_pair

(

NaviType

navi

)

[inline]

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 >
	)			[inline]

Get last term (wrt. lexicographical order).

References PBORI_ASSERT, and reversed_inter_copy().

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

template<class CacheType, class NaviType, class DDType>

DDType polybori::dd_lex_lead	(	const CacheType &	cache,
		NaviType	navi,
		const DDType &	init
	)			[inline]

Referenced by polybori::LexOrder::lead().

template<class IntType, class NaviType>

IntType polybori::dd_long_count

(

NaviType

navi

)

[inline]

Function template for generically computing number of terms.

References dd_long_count_step().

template<class MapType, class NaviType>

MapType::mapped_type polybori::dd_long_count_step	(	MapType &	cache,
		NaviType	navi
	)			[inline]

Other routines currently at external public header file pbori_algo.h.

Function template

Referenced by dd_long_count().

template<class IntType, class NaviType>

IntType polybori::dd_long_count_without_cache

(

NaviType

navi

)

[inline]

template<class CacheType, class NaviType, class SetType>

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

References PBORI_ASSERT.

Referenced by apply_mapping().

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
	)			[inline]

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

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

Referenced by dd_minimal_elements().

template<class NaviType, class DDType>

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

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

References dd_minimal_elements().

template<class CacheMgr, class ModMonCacheMgr, class NaviType, class SetType>

SetType polybori::dd_minimal_elements	(	const CacheMgr &	cache_mgr,
		const ModMonCacheMgr &	modmon_mgr,
		NaviType	navi,
		const SetType &	init
	)			[inline]

Get minimal elements with respect to inclusion.

References dd_minimal_elements(), dd_modulo_monomials(), and owns_one().

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

template<class CacheMgr, class NaviType, class SetType>

SetType polybori::dd_modulo_monomials	(	const CacheMgr &	cache_mgr,
		NaviType	navi,
		NaviType	rhs,
		const SetType &	init
	)			[inline]

References owns_one(), and PBORI_ASSERT.

Referenced by dd_minimal_elements(), and polybori::groebner::mod_mon_set().

template<bool use_fast, class CacheType, class NaviType, class PolyType>

PolyType polybori::dd_multiply	(	const CacheType &	cache_mgr,
		NaviType	firstNavi,
		NaviType	secondNavi,
		PolyType	init
	)			[inline]

template<class CacheType, class NaviType, class PolyType>

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

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

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
	)			[inline]

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

template<class CacheType, class NaviType, class PolyType>

PolyType polybori::dd_multiply_recursively_monom	(	const CacheType &	cache_mgr,
		NaviType	monomNavi,
		NaviType	navi,
		PolyType	init
	)			[inline]

References PBORI_ASSERT.

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

template<class NaviType>

bool polybori::dd_on_path

(

NaviType

navi

)

[inline]

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
	)			[inline]

Referenced by dd_contains_divs_of_dec_deg(), and polybori::BooleSet::owns().

template<class NaviType, class OrderedIterator>

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

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
	)			[inline]

References dd_is_singleton().

Referenced by dd_is_pair(), and dd_is_singleton_or_pair().

template<class NaviType>

void polybori::dd_print

(

NaviType

navi

)

[inline]

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

References PBORI_PREFIX.

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
	)			[inline]

Referenced by dd_print_terms().

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
	)			[inline]

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
	)			[inline]

References dd_print_term().

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

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
	)			[inline]

References dd_cached_degree().

Referenced by dd_recursive_degree_lead().

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
	)			[inline]

caching deactivated - wrong results might pollute the cache

Todo:

fix

References dd_get_constant(), dd_recursive_degree_lead(), max_degree_on_then(), and PBORI_UNLIKELY.

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

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
	)			[inline]

References dd_cached_degree().

Referenced by dd_recursive_degree_leadexp().

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
	)			[inline]

References dd_recursive_degree_leadexp(), max_degree_on_then(), and PBORI_UNLIKELY.

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

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
	)			[inline]

Function templates for transforming decision diagrams.

Referenced by 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
	)			[inline]

Function templates for transforming decision diagrams.

References 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
	)			[inline]

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, class TerminalOperator>

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

Function templates for transforming decision diagrams.

References dd_transform().

template<class NaviType>

void polybori::dec_ref

(

const NaviType &

navi

)

[inline]

void polybori::dec_ref

(

DdNode *

node

)

[inline]

References Cudd_Deref, and PBORI_PREFIX.

template<class LhsType, class RhsType, class BinaryPredicate>

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

defines degree-lexicographic comparison

References generic_compare_3way(), and lex_compare().

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

template<class NaviType>

DdNode* polybori::do_get_node

(

const NaviType &

navi

)

[inline]

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

DdNode* polybori::do_get_node

(

DdNode *

node

)

[inline]

template<class StackType, class Iterator>

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

object polybori::eval

(

str

expression

)

[inline]

References polybori::Interpreter::globals(), and polybori::object::object().

object polybori::exec

(

str

code

)

[inline]

References polybori::Interpreter::globals(), and polybori::object::object().

object polybori::exec_file

(

str

filename

)

[inline]

References polybori::Interpreter::globals(), and polybori::object::object().

template<class ExpType, class RhsType, class ResultType>

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

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

template<class ExpType, class RhsType, class ResultType>

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

References exp_multiply().

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

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

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

CCuddNavigator polybori::explicit_navigator_cast

(

CCuddNavigator::pointer_type

ptr

)

[inline]

References polybori::CCuddNavigator::CCuddNavigator().

Referenced by polybori::CCommutativeCacheManagement< polybori::BoolePolyRing, CacheType >::find(), polybori::CCacheManBase< ManagerType, CacheType, 3 >::find(), polybori::CCacheManBase< ManagerType, CacheType, 2 >::find(), and polybori::CCacheManBase< ManagerType, CacheType, 1 >::find().

template<class DataType>

void polybori::extrusive_ptr_add_ref	(	const DataType &	,
		DdNode *	ptr
	)			[inline]

Incrememting reference counts to raw pointers to decision diagrams.

References Cudd_Ref, and PBORI_PREFIX.

Referenced by polybori::CExtrusivePtr< ring_type, node_type >::lock().

template<class DataType>

void polybori::extrusive_ptr_release	(	const DataType &	data,
		DdNode *	ptr
	)			[inline]

Releasing raw pointers to decision diagrams here.

References Cudd_RecursiveDerefZdd, and PBORI_PREFIX.

Referenced by polybori::CExtrusivePtr< ring_type, node_type >::release().

template<class HashType>

void polybori::finalize_term_hash

(

HashType &

seed

)

[inline]

Referenced by stable_first_hash_range(), and stable_term_hash().

FILE* polybori::fmemopen	(	void *	buf,
		size_t	size,
		const char *	opentype
	)

References PBORI_ASSERT.

template<class InIter, class Object, class MemberFuncPtr>

void polybori::for_each	(	InIter	start,
		InIter	finish,
		const Object &	obj,
		MemberFuncPtr	func
	)			[inline]

Referenced by polybori::CCuddInterface::CCuddInterface(), polybori::groebner::RankingVector::rerank(), polybori::groebner::ReductionStrategy::unmarkNonMinimalLeadingTerms(), and polybori::CCuddInterface::~CCuddInterface().

template<class InIter, class Object, class MemberFuncPtr>

void polybori::for_each	(	InIter	start,
		InIter	finish,
		Object &	obj,
		MemberFuncPtr	func
	)			[inline]

Referenced by polybori::groebner::GroebnerStrategy::add4ImplDelayed(), polybori::groebner::GroebnerStrategy::addHigherImplDelayedUsing4(), polybori::groebner::GroebnerStrategy::suggestPluginVariable(), and polybori::groebner::GroebnerStrategy::symmGB_F2().

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

Compute the greatest common divisor of two monomials.

References polybori::BooleMonomial::GCD().

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

Compute the greatest common divisor of two monomials.

References polybori::BooleExponent::GCD().

template<class MonomType, class PolyType>

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

References PBORI_ASSERT.

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
	)			[inline]

defines lexicographic comparison for variable indices

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

template<class MgrType>

const MgrType& polybori::get_mgr_core

(

const MgrType &

rhs

)

[inline]

boost::shared_ptr<COrderingBase> polybori::get_ordering

(

CTypes::ordercode_type

order

)

[inline]

References block_dlex, block_dp_asc, dlex, dp_asc, and lp.

Referenced by polybori::BoolePolyRing::changeOrdering().

template<class NaviType>

void polybori::inc_ref

(

const NaviType &

navi

)

[inline]

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

void polybori::inc_ref

(

DdNode *

node

)

[inline]

References Cudd_Ref, and PBORI_PREFIX.

template<class IteratorLike>

IteratorLike polybori::increment_iteratorlike

(

IteratorLike

iter

)

[inline]

template<class IteratorLike>

IteratorLike polybori::increment_iteratorlike	(	IteratorLike	iter,
		navigator_tag
	)			[inline]

template<class IteratorLike, class ForwardIteratorTag>

IteratorLike polybori::increment_iteratorlike	(	IteratorLike	iter,
		ForwardIteratorTag
	)			[inline]

template<class Iterator>

Iterator::value_type polybori::index_vector_hash	(	Iterator	start,
		Iterator	finish
	)			[inline]

template<class NaviType, class ReverseIterator, class DDOperations>

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

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
	)			[inline]

Referenced by dd_minimal_elements().

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

Compute the greatest common divisor of two monomials.

References polybori::BooleMonomial::LCM().

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

Compute the greatest common divisor of two monomials.

References polybori::BooleExponent::LCM().

template<class LhsType, class RhsType, class BinaryPredicate>

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

defines lexicographic comparison

Referenced by deg_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
	)			[inline]

defines lexicographic comparison

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,
		valid_tag	has_easy_equality_test
	)			[inline]

defines lexicographic comparison

References lex_compare_3way().

Referenced by polybori::LexOrder::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
	)			[inline]

Referenced by lex_compare().

template<class IteratorType, class SizeType>

SizeType polybori::limited_distance	(	IteratorType	start,
		IteratorType	finish,
		SizeType	limit
	)			[inline]

template<class NaviType, class LowerIterator, class ValueType>

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

Todo:

Maybe recursive caching is efficient here.

References polybori::BooleSet::change(), and PBORI_ASSERT.

Referenced by term_accumulate().

template<class PolyType, class MonomType>

PolyType polybori::mapping	(	PolyType	poly,
		MonomType	fromVars,
		MonomType	toVars
	)			[inline]

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,
		invalid_tag	non_descending
	)			[inline]

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,
		valid_tag	is_descending
	)			[inline]

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,
		invalid_tag	non_descending
	)			[inline]

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,
		valid_tag	is_descending
	)			[inline]

References dd_cached_degree().

template<class MemberFct>

MemberFunctionOperator<MemberFct> polybori::member_function_operator

(

MemberFct

func

)

[inline]

Referenced by polybori::groebner::RelatedTermsBase::unrelated_terms().

template<class NaviType, class ReverseIterator, class DDOperations>

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

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

elseTail = elseNavi;

PBORI_PREFIX(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().

template<class Type1, class Data2, class Type2>

bool polybori::operator!=	(	Type1 *	lhs,
		const CExtrusivePtr< Data2, Type2 > &	rhs
	)			[inline]

Nonequality check from a pointer.

References polybori::CExtrusivePtr< DataType, ValueType >::get().

template<class Data1, class Type1, class Type2>

bool polybori::operator!=	(	const CExtrusivePtr< Data1, Type1 > &	lhs,
		Type2 *	rhs
	)			[inline]

Nonequality check wrt. pointer.

References polybori::CExtrusivePtr< DataType, ValueType >::get().

template<class Data1, class Type1, class Data2, class Type2>

bool polybori::operator!=	(	const CExtrusivePtr< Data1, Type1 > &	lhs,
		const CExtrusivePtr< Data2, Type2 > &	rhs
	)			[inline]

Nonequality check.

References polybori::CExtrusivePtr< DataType, ValueType >::get().

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

Nonquality check (with constant lhs).

template<class RHSType>

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

Modulus monomial (division remainder).

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

Remainder of division of a polynomial by a variable.

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

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

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

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

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

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

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

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

Multiplication of a polynomial by a variable.

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

Multiplication of monomials by a polynomial.

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

Multiplication of variables by a monomial.

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

Multiplication of variables by a polynomial.

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 BooleConstant &	rhs
	)			[inline]

Multiplication of variables by a 0 or 1.

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

Multiplication of monomials.

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

Multiplication of monomials.

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

Multiplication of monomials.

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

Multiplication of monomials.

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

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

Multiplication of a polynomial by a variable with assignment.

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

Addition operation.

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

Addition operation.

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

Addition operation.

template<class RHSType>

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

Multiplication of monomials.

References polybori::BooleExponent::multiply().

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

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

Subtraction operation with constant right-hand-side.

template<class RHSType>

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

Subtraction operation.

template<class RHSType>

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

Division of monomials.

References polybori::BooleExponent::divide().

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

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

Division.

References polybori::BooleVariable::ring().

template<class RHSType>

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

Division by monomial (skipping remainder).

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

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

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

Division of monomials.

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

Division of monomials.

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

Less than comparision.

References polybori::BooleMonomial::compare().

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

Stream output operator.

References polybori::BooleSet::print().

BoolePolyRing::ostream_type& polybori::operator<<	(	BoolePolyRing::ostream_type &	os,
		const BoolePolyRing &	ring
	)			[inline]

Stream output operator.

References polybori::BoolePolyRing::print().

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

Stream output operator.

References polybori::BoolePolynomial::print().

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

Stream output operator.

References polybori::BooleExponent::print().

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

Stream output operator.

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

Less or equal than comparision.

References polybori::BooleMonomial::compare().

template<class Type1, class Data2, class Type2>

bool polybori::operator==	(	Type1 *	lhs,
		const CExtrusivePtr< Data2, Type2 > &	rhs
	)			[inline]

Equality check from a pointer.

References polybori::CExtrusivePtr< DataType, ValueType >::get().

template<class Data1, class Type1, class Type2>

bool polybori::operator==	(	const CExtrusivePtr< Data1, Type1 > &	lhs,
		Type2 *	rhs
	)			[inline]

Equality check wrt. pointer.

References polybori::CExtrusivePtr< DataType, ValueType >::get().

template<class Data1, class Type1, class Data2, class Type2>

bool polybori::operator==	(	const CExtrusivePtr< Data1, Type1 > &	lhs,
		const CExtrusivePtr< Data2, Type2 > &	rhs
	)			[inline]

Equality check.

References polybori::CExtrusivePtr< DataType, ValueType >::get().

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

Equality check (with constant lhs).

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

Greater than comparision.

References polybori::BooleMonomial::compare().

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

Greater or equal than comparision.

References polybori::BooleMonomial::compare().

template<class NaviType>

bool polybori::owns_one

(

NaviType

navi

)

[inline]

Test whether the empty set is included.

Referenced by dd_contains_divs_of_dec_deg(), dd_minimal_elements(), dd_modulo_monomials(), and polybori::BooleSet::ownsOne().

template<class MgrType, class NodeType>

NodeType polybori::pboriCudd_zddUnionXor	(	MgrType	dd,
		NodeType	P,
		NodeType	Q
	)			[inline]

References pboriCuddZddUnionXor().

Referenced by polybori::CCuddDDFacade< polybori::BoolePolyRing, polybori::BooleSet >::Xor().

template<class MgrType, class NodeType>

NodeType polybori::pboriCuddZddUnionXor	(	MgrType	zdd,
		NodeType	P,
		NodeType	Q
	)			[inline]

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 PBORI_PREFIX(cuddInt.h)

References Cudd_Deref, Cudd_RecursiveDerefZdd, Cudd_Ref, cuddCacheInsert2, cuddCacheLookup2Zdd, cuddZddGetNode, PBORI_PREFIX, and 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
	)			[inline]

Referenced by dd_minimal_elements(), and minimal_of_two_terms().

template<class MgrType, class NaviType>

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

Referenced by apply_assign_cudd_function(), and apply_replacing_cudd_function().

template<class MgrType>

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

References Cudd_RecursiveDerefZdd, and PBORI_PREFIX.

Referenced by polybori::dd_operations< CCuddNavigator >::kill(), polybori::dd_operations< CCuddNavigator >::newNodeAssign(), polybori::dd_operations< CCuddNavigator >::replace(), and polybori::dd_operations< CCuddNavigator >::replacingNode().

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
	)			[inline]

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
	)			[inline]

Function templates doing a reversed copy using intermediate storage.

Referenced by dd_last_lexicographical_term().

void polybori::run

(

const char *

code

)

[inline]

template<class Iterator>

bool polybori::same_rings	(	Iterator	start,
		Iterator	finish
	)			[inline]

template<class IDType, class Iterator>

bool polybori::same_rings	(	const IDType &	id,
		Iterator	start,
		Iterator	finish
	)			[inline]

Referenced by polybori::groebner::GroebnerStrategy::faugereStepDense().

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

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

References transform().

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

Compute spoly of two polynomials.

References polybori::BoolePolynomial::lead().

Referenced by polybori::groebner::NextSpoly::compute(), polybori::groebner::IJPairData::extract(), and polybori::groebner::nf3_short().

template<class NaviType>

std::size_t polybori::stable_first_hash_range

(

NaviType

navi

)

[inline]

Referenced by polybori::BooleMonomial::stableHash().

template<class HashType, class NaviType>

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

References finalize_term_hash().

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

template<class NaviType>

std::size_t polybori::stable_hash_range

(

NaviType

navi

)

[inline]

Referenced by stable_hash_range(), and polybori::BooleSet::stableHash().

template<class HashType, class NaviType>

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

References stable_hash_range().

template<class Iterator>

std::size_t polybori::stable_term_hash	(	Iterator	start,
		Iterator	finish
	)			[inline]

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

template<class HashType, class Iterator>

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

References finalize_term_hash().

template<class RingType, class MapType, class PolyType>

PolyType polybori::substitute_variables	(	const RingType &	ring,
		const MapType &	idx2poly,
		const PolyType &	poly
	)			[inline]

Maps a polynomial from one ring to another, using a given map old_index -> new_polynomial

template<class PolyType, class RingType, class MapType, class NaviType>

PolyType polybori::substitute_variables__	(	const RingType &	ring,
		const MapType &	idx2poly,
		NaviType	navi
	)			[inline]

Internal variant: Maps a polynomial from one ring to another, using a given map old_index -> new_polynomial

template<class InputIterator, class ValueType>

ValueType polybori::term_accumulate	(	InputIterator	first,
		InputIterator	last,
		ValueType	init
	)			[inline]

Routine for adding all terms given by iterators.

Note:

: This line always uses the active manager!

Todo:

: check correct manager

References PBORI_ASSERT, and upper_term_accumulate().

Referenced by polybori::groebner::LexHelper::sum_range(), and term_accumulate().

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
	)			[inline]

References polybori::BooleSet::change(), lower_term_accumulate(), PBORI_ASSERT, term_accumulate(), and upper_term_accumulate().

template<class InIter, class OutIter, class Object, class MemberFuncPtr>

OutIter polybori::transform	(	InIter	start,
		InIter	finish,
		OutIter	result,
		Object &	obj,
		MemberFuncPtr	func
	)			[inline]

Referenced by polybori::groebner::GroebnerStrategy::allGenerators(), polybori::BooleSetSequence::BooleSetSequence(), polybori::groebner::GroebnerStrategy::minimalize(), polybori::groebner::GroebnerStrategy::minimalizeAndTailReduce(), and special_first_transform().

template<class UpperIterator, class NaviType, class ValueType>

ValueType polybori::upper_term_accumulate	(	UpperIterator	ustart,
		UpperIterator	ufinish,
		NaviType	navi,
		ValueType	init
	)			[inline]

Referenced by term_accumulate().

template<class Type, class Type1, class Type2, class Type3>

const Type& polybori::which	(	bool	cond1,
		const Type1 &	value1,
		bool	cond2,
		const Type2 &	value2,
		bool	cond3,
		const Type3 &	value3,
		const Type &	value
	)			[inline]

Referenced by polybori::groebner::ReductionTerms::related(), and which().

template<class Type, class Type1, class Type2>

const Type& polybori::which	(	bool	cond1,
		const Type1 &	value1,
		bool	cond2,
		const Type2 &	value2,
		const Type &	value
	)			[inline]

References which().

template<class Type, class Type1>

const Type& polybori::which	(	bool	condition,
		const Type1 &	value1,
		const Type &	value
	)			[inline]

Referenced by polybori::groebner::GroebnerStrategy::addAsYouWish().