polybori Namespace Reference

## Namespaces

| groebner

## Classes

class | AddEliminationDegree
class | and_tag
| and_tag<valid_tag, valid_tag> -> valid_tag, otherwise invalid_tag. More...
struct | and_tag< valid_tag, valid_tag >
class | append_indexed_divisor
| Defines multiplication (with assignment) with the idx-th variable. More...
class | binary_composition
| Compose a binary function with two default constructable unary functions. More...
class | block_tag
| Marker for block orderings. More...
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 | bounded_restricted_term
class | CAbstractStackBase
class | cached_block_deg
struct | cached_deg
class | CacheManager
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 | CAuxTypes
| This struct contains auxiliary type definitions. More...
class | CBlockDegreeCache
class | CBlockDegreeOrderingTags
class | CBlockOrderingFacade
| This class implements block orderings for COrderingFacade. OrderType must inherit from COrderingFacade<OrderType>. More...
class | CBlockTermStack
class | CBoundedDegreeCache
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 | CCacheManBase
| This template forms the base for CCacheManagement. It implements routines for finding and inserting results into the cache. More...
class | CCacheManBase< ManagerType, CacheType, 0 >
class | CCacheManBase< ManagerType, CacheType, 1 >
class | CCacheManBase< ManagerType, CacheType, 2 >
class | CCacheManBase< ManagerType, CacheType, 3 >
class | CCacheTypes
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 | CCheckedIdx
| This class defines CCheckedIdx. More...
class | CCommutativeCacheManagement
class | CCompareEnums
| This struct contains type definitions and enumerations to be used for comparisons. More...
class | CCuddCore
| This class prepares the CUDD's raw decision diagram manager structure for the use with instrinsive pointers. More...
class | CCuddDDFacade
| This template class defines a facade for decision diagrams. More...
class | CCuddFirstIter
| This class defines an iterator over the first minimal term of a given ZDD node. More...
class | CCuddInterface
| This class defines a C++ interface to `CUDD's` decicion diagram manager. More...
class | CCuddLastIter
| This class defines an iterator over the last minimal term of a given ZDD node. More...
class | CCuddLikeMgrStorage
class | CCuddNavigator
| This class defines an iterator for navigating through then and else branches of ZDDs. More...
class | CDDOperations
class | CDegreeArgumentCache
class | CDegreeCache
class | CDegreeOrderingTags
class | CDegStackBase
class | CDegStackBase< NavigatorType, invalid_tag, BlockProperty, BaseType >
class | CDegStackBase< NavigatorType, valid_tag, BlockProperty, BaseType >
class | CDegStackCore
class | CDegStackCore< NavigatorType, invalid_tag, Category, BaseType >
| for pure degree stacks More...
class | CDegStackCore< NavigatorType, valid_tag, Category, BaseType >
| for block stacks More...
class | CDegTermStack
class | CDelayedTermIter
class | CErrorEnums
| This struct contains type definitions and enumerations to be used for error codes. More...
class | CErrorInfo
class | CExpGenerator
class | CExpIter
class | CExtrusivePtr
| This template class defines a reimplementation of the interface from boost:intrusive_ptr, but with an additional data field. More...
class | CFactoryBase
| This base class CFactoryBase is used for currying other constructors with a BoolePolyRing. More...
class | CGenericIter
class | CGenericOrderedIter
class | CGenericOrderedIter< OrderType, NavigatorType, BooleExponent >
class | change_assign
| Accessing .changeAssign() More...
class | change_assign< void, pbori_traits< void >::idx_type >
class | change_idx
class | CIndexCacheHandle
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 | CIndirectIter
class | CLiteralCodes
| This template class defines enumerative codes for the string literals defined by the CStringLiterals class. More...
class | CMemberFunctionTraits
| This template class defines related types for member function pointer. More...
class | CMemberFunctionTraits< ResultType(Type::*)() const >
class | CMemberFunctionTraits< ResultType(Type::*)()>
class | CMemberFunctionTraits< ResultType(Type::*)(ArgType) const >
class | CMemberFunctionTraits< ResultType(Type::*)(ArgType)>
class | CMemberFunctionTraitsBase
| Axuiliary class. More...
class | CNodeCounter
| This class defines CNodeCounter. More...
class | CommutativeCacheManager
class | constant_binder1st
class | constant_binder2nd
class | constant_binder_base
class | COrderedIter
class | COrderEnums
| This struct contains type definitions and enumerations to be used for order codes. 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 | COrderingTags
| This tempalte class is base for classes which define ordering tags and properties. More...
class | COrderingTags< block_dlex_tag >
class | COrderingTags< block_dp_asc_tag >
class | COrderingTags< dlex_tag >
class | COrderingTags< dp_asc_tag >
class | COrderingTags< lex_tag >
class | COrderingTagsBase
struct | count_tags
struct | count_tags< CCacheTypes::divisorsof_fixedpath >
class | count_tags< CCacheTypes::has_factor_x_plus_y >
class | count_tags< CCacheTypes::left_equals_right_x_branch_and_r_has_fac_x >
class | count_tags< CCacheTypes::testwise_ternary >
class | CReverseIter
class | CReverseTermStack
| This class defines an iterator for the monomials in a Boolean polynomial in reversed lexicographicxal order. More...
class | CStackSelector
class | CStringLiteral
| This template class defines string literals corresponding to the codes enumerated in the class CLiteralCodes. More...
class | CTermGenerator
class | CTermGenerator< BooleMonomial >
class | CTermGeneratorBase
class | CTermGeneratorBase__
class | CTermGeneratorBase__< TermType, type_tag< BooleExponent > >
class | CTermGeneratorBase__< TermType, type_tag< BooleMonomial > >
class | CTermGeneratorBase__< TermType, type_tag< CTypes::deg_type > >
class | CTermGeneratorBase__< TermType, type_tag< CTypes::size_type > >
class | CTermIter
| 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 | CTermStackBase
| This class defines an iterator for the monomials in a Boolean polynomial. More...
class | CTypes
| This struct contains type definitions to be used in library classes. More...
struct | cudd_error_traits
class | cudd_tag_number
class | CVariableIter
| This template class defines an iterator for monomial types. More...
class | CVariableNames
class | CWeakPtr
| Forward declaration of friend. More...
class | CWeakPtrFacade
| This class defines CWeakPtrFacade. More...
class | CWrappedStack
class | dd_add_assign
| Defines addition operation with assignment for decision diagrams. More...
class | dd_operations
class | dd_operations< CCuddNavigator >
class | default_binder1st
class | default_binder2nd
class | default_binder_base
class | default_value
class | DegLexOrder
| This class defines ordering related functions. More...
class | DegRevLexAscOrder
| This class defines ordering related functions. More...
class | DerefProxy
class | dict
class | dlex_tag
| Marker for deg-lex ordering. More...
class | dp_asc_tag
| Marker for ascending deg-rev-lex ordering. More...
class | dummy_data_type
class | dummy_iterator
| An iterator which virtually does nothing. More...
class | EliminationDegreeAdder
class | equality_property
class | generate_index_map
class | generic_iteration
class | get_node
class | handle_else
class | hashes
struct | increment_count_tags
class | insert_assign
| Accessing .insertAssign() More...
class | insert_assign< void, pbori_traits< void >::idx_type >
class | insert_second_to_list
| Insert second argument to a given list. More...
class | inserts
| Accessing .insert() More...
class | inserts< void, pbori_traits< void >::idx_type >
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 | internal_tag
| This class marks an internal part of a procedure. More...
class | Interpreter
class | invalid_tag
| This class shows, whether a property of an order is invalid. More...
class | invert_tag
| Changes valid_tag -> invalid_tag and vice versa. More...
struct | invert_tag< invalid_tag >
struct | invert_tag< valid_tag >
class | is_same_type
| This class tests whether two types equal. More...
class | is_same_type< Type, Type >
class | is_valid
class | lex_compare_predicate
| defines lexicographic comparison functor More...
class | lex_tag
| Marker for lex ordering. More...
class | LexOrder
| This class defines ordering related functions. More...
struct | manager_traits
class | mapped_new_node
class | maximum_iteration
| Returns maximun of given argument and previous calls. More...
class | MemberFunctionOperator
class | MonomialFactory
| This base class MonomialFactory is used for currying monomial constructors with a BoolePolyRing. More...
class | navigates
class | navigator_tag
| for iterator_category More...
class | object
class | on_same_type
| This class switches betweem two types, depending on equality of types. More...
class | on_same_type< Type, Type, ThenType, ElseType >
class | order_traits
class | order_traits< block_tag< BaseOrderTag > >
struct | order_traits_code
struct | order_traits_code< block_dlex_tag >
struct | order_traits_code< block_dp_asc_tag >
struct | order_traits_code< dlex_tag >
struct | order_traits_code< dp_asc_tag >
struct | order_traits_code< lex_tag >
struct | pbori_base
struct | pbori_base< CCacheManBase< BoolePolyRing, CacheType, ArgumentLength > >
struct | pbori_base< CCacheManBase< boost::intrusive_ptr< CCuddCore >, CacheType, ArgumentLength > >
struct | pbori_base< CCacheManBase< CCuddInterface, CacheType, ArgumentLength > >
struct | pbori_base< CExpIter< NaviType, ExpType > >
struct | pbori_base< CGenericIter< OrderType, NaviType, RefType > >
struct | pbori_base< CReverseIter< OrderType, NaviType, RefType > >
class | pbori_binary_traits
| This class contains property definitions related to two types to be used in polybori classes. More...
class | pbori_binary_traits< OnlyType, OnlyType >
class | pbori_traits
| This class contains property definitions to be used in polybori classes. More...
class | pbori_traits< dummy_iterator >
class | pbori_traits< int >
class | pbori_traits< long int >
class | pbori_traits< std::set< ValueType > >
class | pbori_traits< std::vector< ValueType > >
class | pbori_traits< unsigned int >
class | pbori_traits< void >
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 | 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 | PolynomialFactory
| This base class PolynomialFactory is used for currying polynomial constructors with a BoolePolyRing. More...
class | project_ith
| Accessing ith of n arguments (ITH = 0 returns default value of first type) More...
class | project_ith< 0, NLEN >
class | project_ith< 1, NLEN >
class | project_ith< 2, NLEN >
class | project_ith< 3, NLEN >
class | push_back
| Accessing .push_back() More...
class | remove_assign
| Accessing .removeAssign() More...
class | remove_assign< void, pbori_traits< void >::idx_type >
class | removes
| Accessing .remove() More...
class | removes< void, pbori_traits< void >::idx_type >
class | reversed_iteration_adaptor
class | SetFactory
| This base class SetFactory is used for currying set constructors with a BoolePolyRing. More...
class | sizes_less
| A functional for size comparisons. More...
class | subset0_assign
| Accessing .subset1Assign() More...
class | subset1_assign
| Accessing .subset1Assign() More...
class | symmetric_composition
| Compose a binary function with a default constructable unary function for both arguments. More...
class | times_indexed_var
| Defines multiplication operation with the idx-th variable. More...
class | TransformedIterator
| This class defines the iterator of Trnasformed sequence. More...
class | TransformedSequence
| This class converts a sequence-like structure when iterating. More...
class | tuple
class | type_tag
| This class marks a given type. More...
class | UnaryOperatorTraits
class | UnaryOperatorTraits< ResultType(*)(ArgType)>
class | unite_assign
| Accessing .uniteAssign() More...
class | valid_tag
| This class shows, whether a property of an order is valid. More...
class | variable_name
| Defines generic access to variable names. More...
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 | VariableIndexException
class | WeakRingPtr
| This class defines WeakRingPtr. More...

## Typedefs

typedef pbori_DdManager | DdManager
typedef BoolePolyRing | Ring
| convenience aliases More...
typedef BoolePolynomial | Polynomial
typedef BooleVariable | Variable
typedef BooleMonomial | Monomial
typedef block_tag< dlex_tag > | block_dlex_tag
| Marker for block deg-lex ordering. More...
typedef block_tag< dp_asc_tag > | block_dp_asc_tag
| Marker for ascending block deg-rev-lex ordering. More...

## 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. More...
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() More...
BooleEnv::block_iterator | block_end (const BooleEnv::ring_type &ring)
| Extract block data without exposing ordering stuff. More...
template<class RHSType >
BooleExponent | operator+ (const BooleExponent &lhs, const RHSType &rhs)
| Multiplication of monomials. More...
template<class RHSType >
BooleExponent | operator- (const BooleExponent &lhs, const RHSType &rhs)
| Division of monomials. More...
BooleExponent | GCD (const BooleExponent &lhs, const BooleExponent &rhs)
| Compute the greatest common divisor of two monomials. More...
BooleExponent | LCM (const BooleExponent &lhs, const BooleExponent &rhs)
| Compute the greatest common divisor of two monomials. More...
BooleExponent::ostream_type & | operator<< (BooleExponent::ostream_type &os, const BooleExponent &rhs)
| Stream output operator. More...
BooleMonomial | operator* (const BooleMonomial &lhs, const BooleMonomial &rhs)
| Multiplication of monomials. More...
BooleMonomial | operator* (const BooleMonomial &lhs, const BooleVariable &rhs)
| Multiplication of monomials. More...
BoolePolynomial | operator* (const BooleMonomial &lhs, BooleConstant rhs)
| Multiplication of monomials. More...
BoolePolynomial | operator* (BooleConstant lhs, const BooleMonomial &rhs)
| Multiplication of monomials. More...
BooleMonomial | operator/ (const BooleMonomial &lhs, const BooleMonomial &rhs)
| Division of monomials. More...
BooleMonomial | operator/ (const BooleMonomial &lhs, const BooleVariable &rhs)
| Division of monomials. More...
BooleMonomial::bool_type | operator< (const BooleMonomial &lhs, const BooleMonomial &rhs)
| Less than comparision. More...
BooleMonomial::bool_type | operator> (const BooleMonomial &lhs, const BooleMonomial &rhs)
| Greater than comparision. More...
BooleMonomial::bool_type | operator<= (const BooleMonomial &lhs, const BooleMonomial &rhs)
| Less or equal than comparision. More...
BooleMonomial::bool_type | operator>= (const BooleMonomial &lhs, const BooleMonomial &rhs)
| Greater or equal than comparision. More...
BooleMonomial | GCD (const BooleMonomial &lhs, const BooleMonomial &rhs)
| Compute the greatest common divisor of two monomials. More...
BooleMonomial | LCM (const BooleMonomial &lhs, const BooleMonomial &rhs)
| Compute the greatest common divisor of two monomials. More...
BoolePolynomial | operator* (const BooleVariable &lhs, const BooleConstant &rhs)
| Multiplication of variables by a 0 or 1. More...
BoolePolynomial | operator* (const BooleConstant &lhs, const BooleVariable &rhs)
| Multiplication of 0 or 1 by a Variable. More...
BoolePolynomial | operator* (const BooleVariable &lhs, const BoolePolynomial &rhs)
| Multiplication of variables by a polynomial. More...
BooleMonomial | operator* (const BooleVariable &lhs, const BooleMonomial &rhs)
| Multiplication of variables by a monomial. More...
BoolePolynomial & | operator*= (BoolePolynomial &lhs, const BooleVariable &rhs)
| Multiplication of a polynomial by a variable with assignment. More...
BooleMonomial | operator* (const BooleVariable &lhs, const BooleVariable &rhs)
| Multiplication of monomials by a polynomial. More...
BoolePolynomial | operator* (const BoolePolynomial &lhs, const BooleVariable &rhs)
| Multiplication of a polynomial by a variable. More...
BoolePolynomial | operator/ (const BoolePolynomial &lhs, const BooleVariable &rhs)
| Division of a polynomial by a variable (forcing monomial variant) More...
BoolePolynomial | operator% (const BoolePolynomial &lhs, const BooleVariable &rhs)
| Remainder of division of a polynomial by a variable. More...
BoolePolynomial | operator+ (const BoolePolynomial &lhs, const BoolePolynomial &rhs)
| Addition operation. More...
BoolePolynomial | operator+ (const BoolePolynomial &lhs, BooleConstant rhs)
| Addition operation. More...
BoolePolynomial | operator+ (BooleConstant lhs, const BoolePolynomial &rhs)
| Addition operation. More...
template<class RHSType >
BoolePolynomial | operator- (const BoolePolynomial &lhs, const RHSType &rhs)
| Subtraction operation. More...
BoolePolynomial | operator- (const BooleConstant &lhs, const BoolePolynomial &rhs)
| Subtraction operation with constant right-hand-side. More...
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) More...
template<class RHSType >
BoolePolynomial | operator% (const BoolePolynomial &lhs, const RHSType &rhs)
| Modulus monomial (division remainder) More...
BoolePolynomial::bool_type | operator== (BoolePolynomial::bool_type lhs, const BoolePolynomial &rhs)
| Equality check (with constant lhs) More...
BoolePolynomial::bool_type | operator!= (BoolePolynomial::bool_type lhs, const BoolePolynomial &rhs)
| Nonquality check (with constant lhs) More...
BoolePolynomial::ostream_type & | operator<< (BoolePolynomial::ostream_type &, const BoolePolynomial &)
| Stream output operator. More...
BoolePolyRing::ostream_type & | operator<< (BoolePolyRing::ostream_type &os, const BoolePolyRing &ring)
| Stream output operator. More...
BooleSet::ostream_type & | operator<< (BooleSet::ostream_type &os, const BooleSet &bset)
| Stream output operator. More...
BoolePolynomial | operator/ (const BooleVariable &lhs, const BooleVariable &rhs)
| Division. More...
template<class Data1 , class Type1 , class Data2 , class Type2 >
bool | operator== (const CExtrusivePtr< Data1, Type1 > &lhs, const CExtrusivePtr< Data2, Type2 > &rhs)
| Equality check. More...
template<class Data1 , class Type1 , class Data2 , class Type2 >
bool | operator!= (const CExtrusivePtr< Data1, Type1 > &lhs, const CExtrusivePtr< Data2, Type2 > &rhs)
| Nonequality check. More...
template<class Data1 , class Type1 , class Type2 >
bool | operator== (const CExtrusivePtr< Data1, Type1 > &lhs, Type2 *rhs)
| Equality check wrt. pointer. More...
template<class Data1 , class Type1 , class Type2 >
bool | operator!= (const CExtrusivePtr< Data1, Type1 > &lhs, Type2 *rhs)
| Nonequality check wrt. pointer. More...
template<class Type1 , class Data2 , class Type2 >
bool | operator== (Type1 *lhs, const CExtrusivePtr< Data2, Type2 > &rhs)
| Equality check from a pointer. More...
template<class Type1 , class Data2 , class Type2 >
bool | operator!= (Type1 *lhs, const CExtrusivePtr< Data2, Type2 > &rhs)
| Nonequality check from a pointer. More...
template<class DataType >
void | extrusive_ptr_release (const DataType &data, DdNode *ptr)
| Releasing raw pointers to decision diagrams here. More...
template<class DataType >
void | extrusive_ptr_add_ref (const DataType &, DdNode *ptr)
| Incrememting reference counts to raw pointers to decision diagrams. More...
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. More...
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. More...
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. More...
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. More...
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. More...
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. More...
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. More...
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. More...
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) More...
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) More...
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 More...
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. More...
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. More...
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. More...
template<class IntType , class NaviType >
IntType | dd_long_count (NaviType navi)
| Function template for generically computing number of terms. More...
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). More...
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 More...
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 More...
template<class LhsType , class RhsType , class BinaryPredicate >
CTypes::comp_type | lex_compare (const LhsType &lhs, const RhsType &rhs, BinaryPredicate idx_comp)
| defines lexicographic comparison More...
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 More...
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. More...
void | intrusive_ptr_release (CCuddCore *pCore)
| Release current pointer by decrementing reference counting. More...

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

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

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

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< 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::COrderingBase::blockBegin(), and 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
| ) |  |

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

References generic_compare_3way(), and restricted_lex_compare_3way().

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

BooleEnv::block_iterator polybori::block_end | ( | const BooleEnv::ring_type & | ring | ) |

Extract block data without exposing ordering stuff.

References polybori::COrderingBase::blockEnd(), and polybori::BoolePolyRing::ordering().

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

template<class SetType >

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

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

References combine_sizes(), and count_index().

Referenced by 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
| ) |  |

Referenced by count_index().

template<class ManagerType , class ReverseIterator , class DDBase >

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

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< BoolePolyRing, 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< BoolePolyRing, 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
| ) |  |

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_block_degree_lead(), dd_cached_block_degree(), and max_block_degree_on_then().

Referenced by polybori::CBlockOrderingFacade< BlockDegRevLexAscOrder, block_dp_asc_tag >::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_cached_block_degree().

Referenced by dd_block_degree_lead().

template<class DegreeCacher , class NaviType , class IdxType >

NaviType::deg_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(), max_block_degree_on_then(), and polybori::cached_block_deg< navigator >::operator()().

template<class DegreeCacher , class NaviType >

NaviType::deg_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)

References dd_cached_degree().

Referenced by polybori::BoolePolynomial::deg(), polybori::DegRevLexAscOrder::lead(), polybori::DegLexOrder::lead(), polybori::DegRevLexAscOrder::leadExp(), polybori::DegLexOrder::leadExp(), and polybori::cached_deg< navigator >::operator()().

template<class DegreeCacher , class NaviType , class SizeType >

NaviType::deg_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 PBORI_ASSERT.

Referenced by dd_cached_degree(), dd_recursive_degree_lead(), dd_recursive_degree_leadexp(), and max_degree_on_then().

template<class NaviType , class MonomIterator >

bool polybori::dd_contains_divs_of_dec_deg | ( | NaviType | navi,
|  | MonomIterator | start,
|  | MonomIterator | finish
| ) |  |

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

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

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

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

References PBORI_ASSERT.

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

template<class NaviType >

NaviType polybori::dd_get_constant | ( | NaviType | navi | ) |

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

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

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

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

References PBORI_ASSERT.

Referenced by apply_mapping().

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

Get minimal elements with respect to inclusion.

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

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

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

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 inc_ref(), indexed_term_multiples(), is_reducible_by(), minimal_of_two_terms(), and prepend_multiples_wrt_indices().

template<class CacheMgr , class NaviType , class SetType >

SetType polybori::dd_modulo_monomials | ( | const CacheMgr & | cache_mgr,
|  | NaviType | navi,
|  | NaviType | rhs,
|  | const SetType & | init
| ) |  |

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

template<class CacheType , class NaviType , class PolyType >

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

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

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

References PBORI_ASSERT.

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

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.

References PBORI_PREFIX.

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

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

Referenced by dd_print_terms().

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

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_lead | ( | const CacheType & | cache_mgr,
|  | const DegCacheMgr & | deg_mgr,
|  | NaviType | navi,
|  | TermType | init,
|  | DescendingProperty | prop
| ) |  |

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_leadexp | ( | const CacheType & | cache_mgr,
|  | const DegCacheMgr & | deg_mgr,
|  | NaviType | navi,
|  | TermType & | result,
|  | SizeType | degree,
|  | DescendingProperty | prop
| ) |  |

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

Referenced by 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().

Referenced by 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.

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

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.

Referenced by dd_transform().

void polybori::dec_ref | ( | DdNode * | node | ) |

inline

References Cudd_Deref, and PBORI_PREFIX.

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

References generic_compare_3way(), and lex_compare().

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

DdNode* polybori::do_get_node | ( | DdNode * | node | ) |

inline

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

template<class StackType , class Iterator >

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

object polybori::eval | ( | str | expression | ) |

inline

object polybori::exec | ( | str | code | ) |

inline

object polybori::exec_file | ( | str | filename | ) |

inline

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

CCuddNavigator polybori::explicit_navigator_cast | ( | CCuddNavigator::pointer_type | ptr | ) |

inline

Referenced by polybori::CCacheManBase< ManagerType, CacheType, 1 >::find(), polybori::CCacheManBase< ManagerType, CacheType, 2 >::find(), polybori::CCacheManBase< ManagerType, CacheType, 3 >::find(), and polybori::CCommutativeCacheManagement< BoolePolyRing, CacheType >::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 | ) |

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,
|  | Object & | obj,
|  | MemberFuncPtr | func
| ) |  |

inline

Referenced by polybori::groebner::GroebnerStrategy::add4ImplDelayed(), polybori::groebner::GroebnerStrategy::addHigherImplDelayedUsing4(), polybori::CCuddInterface::CCuddInterface(), polybori::groebner::RankingVector::rerank(), polybori::groebner::GroebnerStrategy::suggestPluginVariable(), polybori::groebner::GroebnerStrategy::symmGB_F2(), polybori::groebner::ReductionStrategy::unmarkNonMinimalLeadingTerms(), and polybori::CCuddInterface::~CCuddInterface().

template<class InIter , class Object , class MemberFuncPtr >

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

inline

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

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

defines lexicographic comparison for variable indices

Referenced by block_deg_lex_idx_compare(), block_dlex_compare(), polybori::DegRevLexAscOrder::compare(), polybori::BlockDegLexOrder::compare(), polybori::LexOrder::compare(), polybori::DegLexOrder::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().

void polybori::inc_ref | ( | DdNode * | node | ) |

inline

References Cudd_Ref, and PBORI_PREFIX.

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

template<class IteratorLike , class ForwardIteratorTag >

IteratorLike polybori::increment_iteratorlike | ( | IteratorLike | iter,
|  | ForwardIteratorTag |
| ) |  |

template<class IteratorLike >

IteratorLike polybori::increment_iteratorlike | ( | IteratorLike | iter,
|  | navigator_tag |
| ) |  |

template<class IteratorLike >

IteratorLike polybori::increment_iteratorlike | ( | IteratorLike | iter | ) |

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

References lex_compare_3way().

Referenced by polybori::LexOrder::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

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

Referenced by deg_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(), and PBORI_ASSERT.

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

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

Referenced by dd_block_degree_lead().

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

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

Referenced by dd_recursive_degree_lead(), and dd_recursive_degree_leadexp().

template<class MemberFct >

MemberFunctionOperator<MemberFct> polybori::member_function_operator | ( | MemberFct | func | ) |

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

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

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

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

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)

BooleConstant polybori::operator* | ( | const BooleConstant & | lhs,
|  | const BooleConstant & | rhs
| ) |  |

inline

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.

BoolePolynomial polybori::operator+ | ( | const BoolePolynomial & | lhs,
|  | const BoolePolynomial & | rhs
| ) |  |

inline

Addition operation.

BooleConstant polybori::operator+ | ( | const BooleConstant & | lhs,
|  | const BooleConstant & | rhs
| ) |  |

inline

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,
|  | BooleConstant | rhs
| ) |  |

inline

Addition operation.

BoolePolynomial polybori::operator+ | ( | BooleConstant | lhs,
|  | const BoolePolynomial & | rhs
| ) |  |

inline

Addition operation.

BooleConstant polybori::operator- | ( | const BooleConstant & | lhs,
|  | const BooleConstant & | rhs
| ) |  |

inline

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

Division.

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)

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.

BoolePolyRing::ostream_type& polybori::operator<< | ( | BoolePolyRing::ostream_type & | os,
|  | const BoolePolyRing & | ring
| ) |  |

inline

Stream output operator.

References polybori::BoolePolyRing::print().

BooleSet::ostream_type& polybori::operator<< | ( | BooleSet::ostream_type & | os,
|  | const BooleSet & | bset
| ) |  |

inline

Stream output operator.

References polybori::BooleSet::print().

BooleExponent::ostream_type& polybori::operator<< | ( | BooleExponent::ostream_type & | os,
|  | const BooleExponent & | rhs
| ) |  |

inline

Stream output operator.

References polybori::BooleExponent::print().

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

Stream output operator.

References polybori::BoolePolynomial::print().

BooleMonomial::bool_type polybori::operator<= | ( | const BooleMonomial & | lhs,
|  | const BooleMonomial & | rhs
| ) |  |

inline

Less or equal than comparision.

References polybori::BooleMonomial::compare().

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

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

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

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

References pboriCuddZddUnionXor().

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

Referenced by dd_minimal_elements(), and minimal_of_two_terms().

template<class MgrType >

void polybori::recursive_dec_ref | ( | const MgrType & | mgr,
|  | DdNode * | node
| ) |  |

inline

References Cudd_RecursiveDerefZdd, and PBORI_PREFIX.

template<class MgrType , class NaviType >

void polybori::recursive_dec_ref | ( | const MgrType & | mgr,
|  | const NaviType & | navi
| ) |  |

inline

Referenced by apply_assign_cudd_function(), apply_replacing_cudd_function(), 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
| ) |  |

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

void polybori::run | ( | const char * | code | ) |

inline

template<class IDType , class Iterator >

bool polybori::same_rings | ( | const IDType & | id,
|  | Iterator | start,
|  | Iterator | finish
| ) |  |

template<class Iterator >

bool polybori::same_rings | ( | Iterator | start,
|  | Iterator | finish
| ) |  |

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

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

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 HashType , class NaviType >

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

References finalize_term_hash().

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

template<class NaviType >

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

template<class HashType , class NaviType >

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

References stable_hash_range().

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

template<class NaviType >

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

Referenced by 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 polybori::BooleExponent::stableHash().

template<class Iterator >

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

template<class RingType , class MapType , class PolyType >

PolyType polybori::substitute_variables | ( | const RingType & | ring,
|  | const MapType & | idx2poly,
|  | const PolyType & | poly
| ) |  |

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

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

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

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

Referenced by polybori::groebner::LexHelper::sum_range().

template<class InputIterator , class ValueType >

ValueType polybori::term_accumulate | ( | InputIterator | first,
|  | InputIterator | last,
|  | ValueType | init
| ) |  |

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

Referenced by term_accumulate().

template<class Type , class Type1 >

const Type& polybori::which | ( | bool | condition,
|  | const Type1 & | value1,
|  | const Type & | value
| ) |  |

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

template<class Type , class Type1 , class Type2 >

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

References which().

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

Referenced by which().