Namespaces | Classes | Functions | Variables

polybori Namespace Reference

Namespaces

namespace  groebner

Classes

class  BlockDegLexOrder
 This class defines ordering related functions. More...
class  BlockDegRevLexAscOrder
 This class defines ordering related functions. More...
class  BooleConstant
 This class wraps a bool value, which was not converted to a boolean polynomial or monomial yet. More...
class  BooleEnv
 This class is just a wrapper accessing global structures. More...
class  BooleExponent
 This class is just a wrapper for using variables for storing indices as interim data structure for BooleMonomial. More...
class  BooleMonomial
 This class is just a wrapper for using variables from cudd's decicion diagram. More...
class  BoolePolynomial
 This class wraps the underlying decicion diagram type and defines the necessary operations. More...
class  BoolePolyRing
 This class adds order-related functionality to BooleRing. More...
class  BooleRing
 This class is just a wrapper for reinterpreting decicion diagram managers as Boolean polynomial rings. More...
class  BooleSet
class  BooleVariable
 This class is just a wrapper for using variables from cudd's decicion diagram. More...
class  CacheManager
class  CommutativeCacheManager
class  handle_else
class  CCacheTypes
struct  count_tags< CCacheTypes::divisorsof_fixedpath >
struct  increment_count_tags
class  count_tags< CCacheTypes::testwise_ternary >
class  count_tags< CCacheTypes::left_equals_right_x_branch_and_r_has_fac_x >
class  count_tags< CCacheTypes::has_factor_x_plus_y >
class  cudd_tag_number
class  CCuddLikeMgrStorage
struct  pbori_base< CCacheManBase< Cudd, CacheType, ArgumentLength > >
struct  pbori_base< CCacheManBase< CCuddInterface, CacheType, ArgumentLength > >
class  CCacheManBase< ManagerType, CacheType, 0 >
class  CCacheManBase< ManagerType, CacheType, 1 >
class  CCacheManBase< ManagerType, CacheType, 2 >
class  CCacheManBase< ManagerType, CacheType, 3 >
class  CCacheManagement
 This template class forms the base for CCommutativeCacheManagement and CacheManager. It is an interface defining find and insert on decision diagram cache. More...
class  CCommutativeCacheManagement
class  CCuddCore
 This class prepares the CUDD's raw decision diagram manager structure for the use with instrinsive pointers. More...
class  CCuddFirstIter
 This class defines an iterator over the first minimal term of a given ZDD node. More...
class  CCuddGetNode
 This class defines a functional, which generates a new decision * diagram node wrt. a given indes and two nodes. More...
class  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  CCuddNavigator
 This class defines an iterator for navigating through then and else branches of ZDDs. More...
class  CCuddDDBase
 This template class defines a C++ interface to CUDD's decision diagram structure. More...
class  CCuddZDD
 This class defines a C++ interface to CUDD's zero-suppressed decision diagram structure. More...
class  CDDInterfaceBase
 This is the common base for the specialized template class CDDInterface. More...
class  CDDInterface
class  CDDManagerBase
 this specialization of the template class CDDManager gives an interface to Cudd-like ZDD manager (StorageType = CuddLikeManType) or a reference of the latter (StorageType = CuddLikeManType&). More...
class  CDDManager< Cudd & >
class  CDDManager< Cudd >
class  CDDManager< CCuddInterface & >
class  CDDManager< CCuddInterface >
class  CDDOperations
class  CIndexHandle
 This class defines an uses an navigator-like type for storing integer values from 0 upto nmax (number of currently active ring variables). More...
class  CIndexCacheHandle
class  CDegreeCache
class  CBlockDegreeCache
class  CDegreeArgumentCache
class  CDelayedTermIter
 This class defines extend a given PolyBoRi degree iterator. More...
class  CErrorInfo
class  CExpGenerator
struct  pbori_base< CExpIter< NaviType, ExpType > >
class  CExpIter
struct  pbori_base< CGenericIter< OrderType, NaviType, RefType > >
class  CGenericIter
class  CGenericIter< OrderType, NaviType, BooleMonomial >
class  CIdxPath
class  CIdxVariable
class  CLiteralCodes
 This template class defines enumerative codes for the string literals defined by the CStringLiterals class. More...
class  COrderBase
 This class defines ordering related functions. More...
class  CAbstractStackBase
class  CWrappedStack
class  COrderedIter
class  CGenericOrderedIter
class  CGenericOrderedIter< OrderType, NavigatorType, BooleExponent >
class  COrderProperties
 This class determins ordering dependent properties. More...
class  CPrintOperation
 This template prints a string literal to stream as operation. More...
class  CRestrictedIter
class  CStackSelector
class  CStringLiteral
 This template class defines string literals corresponding to the codes enumerated in the class CLiteralCodes. More...
class  CTermGeneratorBase< TermType, type_tag< BooleExponent > >
class  CTermGeneratorBase< TermType, type_tag< CTypes::size_type > >
class  CTermGeneratorBase< TermType, type_tag< CTypes::deg_type > >
class  CTermGenerator
class  NoData
class  CTermGeneratorBase< TermType, type_tag< BooleMonomial > >
class  CTermGenerator< BooleMonomial >
class  CTermIter
 This class defines an iterator for the monomials in a Boolean polynomial. More...
struct  cached_deg
class  cached_block_deg
class  CTermStackBase
 This class defines an iterator for the monomials in a Boolean polynomial. More...
class  CTermStack
 This class defines an iterator for the monomials in a Boolean polynomial. More...
class  CDegStackCore< NavigatorType, invalid_tag, Category, BaseType >
 for pure degree stacks More...
class  CDegStackCore< NavigatorType, valid_tag, Category, BaseType >
 for block stacks More...
class  CDegStackBase< NavigatorType, valid_tag, BlockProperty, BaseType >
class  CDegStackBase< NavigatorType, invalid_tag, BlockProperty, BaseType >
class  CDegTermStack
class  CBlockTermStack
class  CVariableIter
 This template class defines an iterator for monomial types. More...
class  CVariableNames
class  DegLexOrder
 This class defines ordering related functions. More...
class  DegRevLexAscOrder
 This class defines ordering related functions. More...
class  LexOrder
 This class defines ordering related functions. More...
class  lex_tag
 Marker for lex ordering. More...
class  dlex_tag
 Marker for deg-lex ordering. More...
class  dp_asc_tag
 Marker for ascending deg-rev-lex ordering. More...
class  block_dlex_tag
 Marker for block deg-lex ordering. More...
class  block_dp_asc_tag
 Marker for ascending block deg-rev-lex ordering. More...
class  order_traits
class  CDynamicOrderBase
 This class initialize the interface for runtime-switchable orderings. More...
class  CDynamicOrder
 This class initialize the interface for orderings of CDynamicOrderBase. More...
class  dd_operations< CTypes::dd_type::navigator >
class  COrderEnums
 This struct contains type definitions and enumerations to be used for order codes. More...
class  CErrorEnums
 This struct contains type definitions and enumerations to be used for error codes. More...
class  CCompareEnums
 This struct contains type definitions and enumerations to be used for comparisons. More...
class  CAuxTypes
 This struct contains auxiliary type definitions. More...
class  CTypes
 This struct contains type definitions to be used in library classes. More...
class  push_back
 Accessing .push_back(). More...
class  change_idx
class  change_assign
 Accessing .changeAssign(). More...
class  change_assign< void, pbori_traits< void >::idx_type >
class  subset1_assign
 Accessing .subset1Assign(). More...
class  subset0_assign
 Accessing .subset1Assign(). More...
class  unite_assign
 Accessing .uniteAssign(). More...
class  project_ith< 0, NLEN >
class  project_ith< 1, NLEN >
class  project_ith< 2, NLEN >
class  project_ith< 3, NLEN >
class  dummy_iterator
 An iterator which virtually does nothing. More...
class  pbori_traits< dummy_iterator >
class  integral_constant
 integral_constant<int_type, NUM>()() returns NUM of int_type, instead of possibly arguments. integral_constant<int_type, NUM, other_type>()() returns conversion of NUM of int_type to other_type. More...
class  binary_composition
 Compose a binary function with two default constructable unary functions. More...
class  symmetric_composition
 Compose a binary function with a default constructable unary function for both arguments. More...
class  maximum_iteration
 Returns maximun of given argument and previous calls. More...
class  dd_add_assign
 Defines addition operation with assignment for decision diagrams. More...
class  times_indexed_var
 Defines multiplication operation with the idx-th variable. More...
class  append_indexed_divisor
 Defines multiplication (with assignment) with the idx-th variable. More...
class  inserts
 Accessing .insert(). More...
class  inserts< void, pbori_traits< void >::idx_type >
class  insert_assign
 Accessing .insertAssign(). More...
class  insert_assign< void, pbori_traits< void >::idx_type >
class  removes
 Accessing .remove(). More...
class  removes< void, pbori_traits< void >::idx_type >
class  remove_assign
 Accessing .removeAssign(). More...
class  remove_assign< void, pbori_traits< void >::idx_type >
class  insert_second_to_list
 Insert second argument to a given list. More...
class  is_same_type< Type, Type >
class  is_same_type
 This class tests whether two types equal. More...
class  on_same_type< Type, Type, ThenType, ElseType >
class  on_same_type
 This class switches betweem two types, depending on equality of types. More...
class  internal_tag
 This class marks an internal part of a procedure. More...
class  type_tag
 This class marks a given type. More...
class  hashes
class  lm_hashes
class  generate_index_map
class  sizes_less
 A functional for size comparisons. More...
class  reversed_iteration_adaptor
class  navigates
class  default_value
class  constant_binder_base
class  constant_binder2nd
class  constant_binder1st
class  default_binder_base
class  default_binder2nd
class  default_binder1st
class  variable_name
 Defines generic access to variable names. More...
class  mapped_new_node
class  get_node
struct  handle_error
struct  handle_error< 0 >
class  lex_compare_predicate
 defines lexicographic comparison functor More...
class  dummy_data_type
class  bounded_restricted_term
class  invalid_tag
 This class shows, whether a property of an order is invalid. More...
class  valid_tag
 This class shows, whether a property of an order is valid. More...
class  navigator_tag
 for iterator_category More...
class  equality_property
class  pbori_traits
 This class contains property definitions to be used in polybori classes. More...
class  pbori_traits< void >
class  pbori_traits< int >
class  pbori_traits< unsigned int >
class  pbori_traits< long int >
class  pbori_traits< std::set< ValueType > >
class  pbori_traits< std::vector< ValueType > >
class  pbori_binary_traits< OnlyType, OnlyType >
class  pbori_binary_traits
 This class contains property definitions related to two types to be used in polybori classes. More...
struct  manager_traits< Cudd >
struct  manager_traits< Cudd * >
struct  manager_traits< DdManager * >
struct  manager_traits
struct  mgrcore_traits< Cudd >
struct  zdd_traits< ZDD >
struct  zdd_traits< CCuddZDD >
struct  cudd_error_traits
class  PBoRiError
 This class is used for polybori's exception handling. More...
class  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  EliminationDegreeAdder
class  AddEliminationDegree

Functions

CTypes::ostream_typeoperator<< (CTypes::ostream_type &os, const BooleConstant &rhs)
 Stream output operator.
template<class RHSType >
BooleExponent operator+ (const BooleExponent &lhs, const RHSType &rhs)
 Multiplication of monomials.
template<class RHSType >
BooleExponent operator- (const BooleExponent &lhs, const RHSType &rhs)
 Division of monomials.
BooleExponent::bool_type operator< (const BooleExponent &lhs, const BooleExponent &rhs)
 Less than comparision.
BooleExponent::bool_type operator> (const BooleExponent &lhs, const BooleExponent &rhs)
 Greater than comparision.
BooleExponent::bool_type operator<= (const BooleExponent &lhs, const BooleExponent &rhs)
 Less or equal than comparision.
BooleExponent::bool_type operator>= (const BooleExponent &lhs, const BooleExponent &rhs)
 Greater or equal than comparision.
BooleExponent GCD (const BooleExponent &lhs, const BooleExponent &rhs)
 Compute the greatest common divisor of two monomials.
BooleExponent LCM (const BooleExponent &lhs, const BooleExponent &rhs)
 Compute the greatest common divisor of two monomials.
BooleExponent::ostream_typeoperator<< (BooleExponent::ostream_type &os, const BooleExponent &rhs)
 Stream output operator.
BooleMonomial operator* (const BooleMonomial &lhs, const BooleMonomial &rhs)
 Multiplication of monomials.
BooleMonomial operator* (const BooleMonomial &lhs, const BooleVariable &rhs)
 Multiplication of monomials.
BoolePolynomial operator* (const BooleMonomial &lhs, BooleConstant rhs)
 Multiplication of monomials.
BoolePolynomial operator* (BooleConstant lhs, const BooleMonomial &rhs)
 Multiplication of monomials.
BooleMonomial operator/ (const BooleMonomial &lhs, const BooleMonomial &rhs)
 Division of monomials.
BooleMonomial operator/ (const BooleMonomial &lhs, const BooleVariable &rhs)
 Division of monomials.
BooleMonomial::bool_type operator< (const BooleMonomial &lhs, const BooleMonomial &rhs)
 Less than comparision.
BooleMonomial::bool_type operator> (const BooleMonomial &lhs, const BooleMonomial &rhs)
 Greater than comparision.
BooleMonomial::bool_type operator<= (const BooleMonomial &lhs, const BooleMonomial &rhs)
 Less or equal than comparision.
BooleMonomial::bool_type operator>= (const BooleMonomial &lhs, const BooleMonomial &rhs)
 Greater or equal than comparision.
BooleMonomial GCD (const BooleMonomial &lhs, const BooleMonomial &rhs)
 Compute the greatest common divisor of two monomials.
BooleMonomial LCM (const BooleMonomial &lhs, const BooleMonomial &rhs)
 Compute the greatest common divisor of two monomials.
BooleMonomial::bool_type greater_variable (BooleMonomial::idx_type lhs, BooleMonomial::idx_type rhs)
 Checks whether BooleVariable(lhs) > BooleVariable(rhs).
BoolePolynomial operator* (const BooleVariable &lhs, const BooleConstant &rhs)
 Multiplication of variables by a 0 or 1.
BoolePolynomial operator* (const BooleConstant &lhs, const BooleVariable &rhs)
 Multiplication of 0 or 1 by a Variable.
BoolePolynomial operator* (const BooleVariable &lhs, const BoolePolynomial &rhs)
 Multiplication of variables by a polynomial.
BooleMonomial operator* (const BooleVariable &lhs, const BooleMonomial &rhs)
 Multiplication of variables by a monomial.
BoolePolynomialoperator*= (BoolePolynomial &lhs, const BooleVariable &rhs)
 Multiplication of a polynomial by a variable with assignment.
BooleMonomial operator* (const BooleVariable &lhs, const BooleVariable &rhs)
 Multiplication of monomials by a polynomial.
BoolePolynomial operator* (const BoolePolynomial &lhs, const BooleVariable &rhs)
 Multiplication of a polynomial by a variable.
BoolePolynomialoperator/= (BoolePolynomial &lhs, const BooleVariable &rhs)
 Division of a polynomial by a variable (forcing monomial variant).
BoolePolynomial operator/ (const BoolePolynomial &lhs, const BooleVariable &rhs)
 Division of a polynomial by a variable (forcing monomial variant).
BoolePolynomial operator% (const BoolePolynomial &lhs, const BooleVariable &rhs)
 Remainder of division of a polynomial by a variable.
BoolePolynomialoperator%= (BoolePolynomial &lhs, const BooleVariable &rhs)
 Remainder of division of a polynomial by a variable (with assignment).
BoolePolynomial operator+ (const BoolePolynomial &lhs, const BoolePolynomial &rhs)
 Addition operation.
BoolePolynomial operator+ (const BoolePolynomial &lhs, BooleConstant rhs)
 Addition operation.
BoolePolynomial operator+ (BooleConstant lhs, const BoolePolynomial &rhs)
 Addition operation.
template<class RHSType >
BoolePolynomial operator- (const BoolePolynomial &lhs, const RHSType &rhs)
 Subtraction operation.
BoolePolynomial operator- (const BooleConstant &lhs, const BoolePolynomial &rhs)
 Subtraction operation with constant right-hand-side.
BoolePolynomial operator* (const BoolePolynomial &lhs, const BoolePolynomial &rhs)
BoolePolynomial operator* (const BoolePolynomial &lhs, const BooleMonomial &rhs)
BoolePolynomial operator* (const BoolePolynomial &lhs, const BooleExponent &rhs)
BoolePolynomial operator* (const BoolePolynomial &lhs, const BooleConstant &rhs)
BoolePolynomial operator* (const BooleMonomial &lhs, const BoolePolynomial &rhs)
BoolePolynomial operator* (const BooleExponent &lhs, const BoolePolynomial &rhs)
BoolePolynomial operator* (const BooleConstant &lhs, const BoolePolynomial &rhs)
template<class RHSType >
BoolePolynomial operator/ (const BoolePolynomial &lhs, const RHSType &rhs)
 Division by monomial (skipping remainder).
template<class RHSType >
BoolePolynomial operator% (const BoolePolynomial &lhs, const RHSType &rhs)
 Modulus monomial (division remainder).
BoolePolynomial::bool_type operator== (BoolePolynomial::bool_type lhs, const BoolePolynomial &rhs)
 Equality check (with constant lhs).
BoolePolynomial::bool_type operator!= (BoolePolynomial::bool_type lhs, const BoolePolynomial &rhs)
 Nonquality check (with constant lhs).
BoolePolynomial::ostream_typeoperator<< (BoolePolynomial::ostream_type &, const BoolePolynomial &)
 Stream output operator.
BooleSet::ostream_typeoperator<< (BooleSet::ostream_type &os, const BooleSet &bset)
 Stream output operator.
BoolePolynomial operator/ (const BooleVariable &lhs, const BooleVariable &rhs)
CCuddNavigator explicit_navigator_cast (CCuddNavigator::pointer_type ptr)
Cudd * extract_manager (const Cudd &mgr)
CCuddInterface::mgrcore_ptr extract_manager (const CCuddInterface &mgr)
template<class MgrType >
const MgrType & extract_manager (const MgrType &mgr)
Cudd & get_manager (Cudd *mgr)
template<class MgrType >
const MgrType & get_manager (const MgrType &mgr)
template<class DDType >
CDDInterface< DDType >
::ostream_type & 
operator<< (typename CDDInterface< DDType >::ostream_type &os, const CDDInterface< DDType > &dd)
 Stream output operator.
ZDD fetch_diagram (const Cudd &mgr, const ZDD &rhs)
template<class MgrType , class DDType >
const DDType & fetch_diagram (const MgrType &mgr, const DDType &rhs)
Cudd & fetch_manager (const Cudd &mgr)
template<class MgrType >
const MgrType & fetch_manager (const MgrType &mgr)
template<class IdxType , class SeparatorType >
CIdxPath< IdxType,
SeparatorType >::ostream_type & 
operator<< (typename CIdxPath< IdxType, SeparatorType >::ostream_type &os, const CIdxPath< IdxType, SeparatorType > &storage)
 Stream output operator.
template<class IdxType , class VarNameLit , class VarHeadLit , class VarTailLit >
CIdxVariable< IdxType,
VarNameLit, VarHeadLit,
VarTailLit >::ostream_type & 
operator<< (typename CIdxVariable< IdxType, VarNameLit, VarHeadLit, VarTailLit >::ostream_type &os, const CIdxVariable< IdxType, VarNameLit, VarHeadLit, VarTailLit > &storage)
 Stream output operator.
template<class IdxType , class OrderType >
bool lie_in_same_block (IdxType, IdxType, const OrderType &, invalid_tag)
template<class IdxType , class OrderType >
bool lie_in_same_block (IdxType first, IdxType second, const OrderType &order, valid_tag)
template<class NaviType , class TermType , class TernaryOperator , class TerminalOperator >
TermType dd_backward_transform (NaviType navi, TermType init, TernaryOperator newNode, TerminalOperator terminate)
 Function templates for transforming decision diagrams.
template<class NaviType , class TermType , class OutIterator , class ThenBinaryOperator , class ElseBinaryOperator , class TerminalOperator >
OutIterator dd_transform (NaviType navi, TermType init, OutIterator result, ThenBinaryOperator then_binop, ElseBinaryOperator else_binop, TerminalOperator terminate)
 Function templates for transforming decision diagrams.
template<class NaviType , class TermType , class OutIterator , class ThenBinaryOperator , class ElseBinaryOperator , class TerminalOperator , class FirstTermOp >
OutIterator dd_transform (NaviType navi, TermType init, OutIterator result, ThenBinaryOperator then_binop, ElseBinaryOperator else_binop, TerminalOperator terminate, FirstTermOp terminate_first)
template<class NaviType , class TermType , class OutIterator , class ThenBinaryOperator , class ElseBinaryOperator >
void dd_transform (const NaviType &navi, const TermType &init, const OutIterator &result, const ThenBinaryOperator &then_binop, const ElseBinaryOperator &else_binop)
 Function templates for transforming decision diagrams.
template<class NaviType , class TermType , class OutIterator , class ThenBinaryOperator >
void dd_transform (const NaviType &navi, const TermType &init, const OutIterator &result, const ThenBinaryOperator &then_binop)
 Function templates for transforming decision diagrams.
template<class InputIterator , class OutputIterator , class FirstFunction , class UnaryFunction >
OutputIterator special_first_transform (InputIterator first, InputIterator last, OutputIterator result, UnaryFunction op, FirstFunction firstop)
template<class InputIterator , class Intermediate , class OutputIterator >
OutputIterator reversed_inter_copy (InputIterator start, InputIterator finish, Intermediate &inter, OutputIterator output)
 Function templates doing a reversed copy using intermediate storage.
template<class NaviType >
bool dd_on_path (NaviType navi)
template<class NaviType , class OrderedIterator >
bool dd_owns_term_of_indices (NaviType navi, OrderedIterator start, OrderedIterator finish)
template<class NaviType , class OrderedIterator , class NodeOperation >
NaviType dd_intersect_some_index (NaviType navi, OrderedIterator start, OrderedIterator finish, NodeOperation newNode)
template<class NaviType >
void dd_print (NaviType navi)
 Function templates for debugging, prints dd indices and reference counts.
template<class IteratorType , class SizeType >
SizeType limited_distance (IteratorType start, IteratorType finish, SizeType limit)
template<class NaviType , class DDType >
DDType dd_minimal_elements (NaviType navi, DDType dd, DDType &multiples)
template<class MgrType >
const MgrType & get_mgr_core (const MgrType &rhs)
Cudd * get_mgr_core (const Cudd &rhs)
CCuddInterface::mgrcore_ptr get_mgr_core (const CCuddInterface &mgr)
template<class ManagerType , class ReverseIterator , class MultReverseIterator >
manager_traits< ManagerType >
::dd_base 
cudd_generate_multiples (const ManagerType &mgr, ReverseIterator start, ReverseIterator finish, MultReverseIterator multStart, MultReverseIterator multFinish)
 temporarily (needs to be more generic)
template<class ManagerType , class ReverseIterator >
manager_traits< ManagerType >
::dd_base 
cudd_generate_divisors (const ManagerType &mgr, ReverseIterator start, ReverseIterator finish)
 temporarily (needs to be more generic)
template<class Iterator , class SizeType >
Iterator bounded_max_element (Iterator start, Iterator finish, SizeType bound)
template<class LhsType , class RhsType , class BinaryPredicate >
CTypes::comp_type generic_compare_3way (const LhsType &lhs, const RhsType &rhs, BinaryPredicate comp)
 defines lexicographic comparison for variable indices
template<class IteratorLike , class ForwardIteratorTag >
IteratorLike increment_iteratorlike (IteratorLike iter, ForwardIteratorTag)
template<class IteratorLike >
IteratorLike increment_iteratorlike (IteratorLike iter, navigator_tag)
template<class IteratorLike >
IteratorLike increment_iteratorlike (IteratorLike iter)
DdNode * pboriCuddZddUnionXor__ (DdManager *, DdNode *, DdNode *)
template<class MgrType , class NodeType >
NodeType pboriCuddZddUnionXor (MgrType zdd, NodeType P, NodeType Q)
template<class MgrType , class NodeType >
NodeType pboriCudd_zddUnionXor (MgrType dd, NodeType P, NodeType Q)
template<class NaviType >
bool dd_is_singleton (NaviType navi)
template<class NaviType , class BooleConstant >
BooleConstant dd_pair_check (NaviType navi, BooleConstant allowSingleton)
template<class NaviType >
bool dd_is_singleton_or_pair (NaviType navi)
template<class NaviType >
bool dd_is_pair (NaviType navi)
template<class SetType >
void combine_sizes (const SetType &bset, double &init)
template<class SetType >
void combine_sizes (const SetType &bset, typename SetType::size_type &init)
template<class SizeType , class IdxType , class NaviType , class SetType >
SizeType & count_index (SizeType &size, IdxType idx, NaviType navi, const SetType &init)
template<class SizeType , class IdxType , class SetType >
SizeType & count_index (SizeType &size, IdxType idx, const SetType &bset)
void inc_ref (DdNode *node)
template<class NaviType >
void inc_ref (const NaviType &navi)
void dec_ref (DdNode *node)
template<class NaviType >
void dec_ref (const NaviType &navi)
DdNode * do_get_node (DdNode *node)
template<class NaviType >
DdNode * do_get_node (const NaviType &navi)
template<class MgrType >
void recursive_dec_ref (const MgrType &mgr, DdNode *node)
template<class MgrType , class NaviType >
void recursive_dec_ref (const MgrType &mgr, const NaviType &navi)
template<class NaviType , class ReverseIterator , class DDOperations >
NaviType indexed_term_multiples (NaviType navi, ReverseIterator idxStart, ReverseIterator idxFinish, const DDOperations &apply)
template<class NaviType >
bool is_reducible_by (NaviType first, NaviType second)
template<class NaviType , class ReverseIterator , class DDOperations >
NaviType minimal_of_two_terms (NaviType navi, NaviType &multiples, ReverseIterator idxStart, ReverseIterator idxFinish, const DDOperations &apply)
template<class NaviType , class SizeType , class ReverseIterator , class DDOperations >
NaviType prepend_multiples_wrt_indices (NaviType navi, SizeType minIdx, ReverseIterator start, ReverseIterator finish, const DDOperations &apply)
template<class FunctionType , class ManagerType , class NodeType >
void apply_assign_cudd_function (FunctionType func, ManagerType &mgr, NodeType &first, const NodeType &second)
template<class FunctionType , class ManagerType , class ResultType , class NodeType >
void apply_replacing_cudd_function (FunctionType func, ManagerType &mgr, ResultType &newNode, const NodeType &first, const NodeType &second)
template<class FunctionType , class ManagerType , class NodeType >
NodeType apply_cudd_function (FunctionType func, ManagerType &mgr, const NodeType &first, const NodeType &second)
template<class NaviType , class DDType2 , class ReverseIterator , class DDOperations >
NaviType dd_minimal_elements (NaviType navi, DDType2 &multiples, ReverseIterator idxStart, ReverseIterator idxEnd, const DDOperations &apply)
BoolePolynomial spoly (const BoolePolynomial &first, const BoolePolynomial &second)
 Compute spoly of two polynomials.
template<class NaviType , class LowerIterator , class ValueType >
ValueType lower_term_accumulate (NaviType navi, LowerIterator lstart, LowerIterator lfinish, ValueType init)
template<class UpperIterator , class NaviType , class ValueType >
ValueType upper_term_accumulate (UpperIterator ustart, UpperIterator ufinish, NaviType navi, ValueType init)
template<class UpperIterator , class NaviType , class LowerIterator , class ValueType >
ValueType term_accumulate (UpperIterator ustart, UpperIterator ufinish, NaviType navi, LowerIterator lstart, LowerIterator lfinish, ValueType init)
template<class InputIterator , class ValueType >
ValueType term_accumulate (InputIterator first, InputIterator last, ValueType init)
 Routine for adding all terms given by iterators.
template<class CacheType , class NaviType , class SetType >
SetType dd_mapping (const CacheType &cache, NaviType navi, NaviType map, SetType init)
template<class PolyType , class MapType >
PolyType apply_mapping (const PolyType &poly, const MapType &map)
template<class MonomType , class PolyType >
PolyType generate_mapping (MonomType &fromVars, MonomType &toVars, PolyType init)
template<class PolyType , class MonomType >
PolyType mapping (PolyType poly, MonomType fromVars, MonomType toVars)
template<class ValueType >
void pbori_shared_ptr_postclean (const boost::shared_ptr< ValueType > &, const boost::shared_ptr< ValueType > &)
boost::shared_ptr
< CDynamicOrderBase
get_ordering (CTypes::ordercode_type order)
template<class DDType , class OutputType >
OutputType dd_last_lexicographical_term (const DDType &dd, type_tag< OutputType >)
 Get last term (wrt. lexicographical order).
template<class HashType , class NaviType >
void stable_hash_range (HashType &seed, NaviType navi)
template<class NaviType >
std::size_t stable_hash_range (NaviType navi)
template<class HashType >
void finalize_term_hash (HashType &seed)
template<class HashType , class NaviType >
void stable_first_hash_range (HashType &seed, NaviType navi)
template<class NaviType >
std::size_t stable_first_hash_range (NaviType navi)
template<class HashType , class Iterator >
void stable_term_hash (HashType &seed, Iterator start, Iterator finish)
template<class Iterator >
std::size_t stable_term_hash (Iterator start, Iterator finish)
template<class Iterator >
Iterator::value_type index_vector_hash (Iterator start, Iterator finish)
template<class DegreeCacher , class NaviType >
NaviType::deg_type dd_cached_degree (const DegreeCacher &cache, NaviType navi)
template<class DegreeCacher , class NaviType , class SizeType >
NaviType::deg_type dd_cached_degree (const DegreeCacher &cache, NaviType navi, SizeType bound)
template<class Iterator , class NameGenerator , class Separator , class EmptySetType , class OStreamType >
void dd_print_term (Iterator start, Iterator finish, const NameGenerator &get_name, const Separator &sep, const EmptySetType &emptyset, OStreamType &os)
template<class TermType , class NameGenerator , class Separator , class EmptySetType , class OStreamType >
void dd_print_term (const TermType &term, const NameGenerator &get_name, const Separator &sep, const EmptySetType &emptyset, OStreamType &os)
template<class Iterator , class NameGenerator , class Separator , class InnerSeparator , class EmptySetType , class OStreamType >
void dd_print_terms (Iterator start, Iterator finish, const NameGenerator &get_name, const Separator &sep, const InnerSeparator &innersep, const EmptySetType &emptyset, OStreamType &os)
template<class CacheType , class NaviType , class PolyType >
PolyType dd_multiply_recursively (const CacheType &cache_mgr, NaviType firstNavi, NaviType secondNavi, PolyType init)
template<class CacheType , class NaviType , class PolyType , class MonomTag >
PolyType dd_multiply_recursively (const CacheType &cache_mgr, NaviType monomNavi, NaviType navi, PolyType init, MonomTag monom_tag)
template<class DDGenerator , class Iterator , class NaviType , class PolyType >
PolyType dd_multiply_recursively_exp (const DDGenerator &ddgen, Iterator start, Iterator finish, NaviType navi, PolyType init)
template<class DegCacheMgr , class NaviType , class SizeType >
bool max_degree_on_then (const DegCacheMgr &deg_mgr, NaviType navi, SizeType degree, valid_tag is_descending)
template<class DegCacheMgr , class NaviType , class SizeType >
bool max_degree_on_then (const DegCacheMgr &deg_mgr, NaviType navi, SizeType degree, invalid_tag non_descending)
template<class CacheType , class DegCacheMgr , class NaviType , class TermType , class SizeType , class DescendingProperty >
TermType dd_recursive_degree_lead (const CacheType &cache_mgr, const DegCacheMgr &deg_mgr, NaviType navi, TermType init, SizeType degree, DescendingProperty prop)
template<class CacheType , class DegCacheMgr , class NaviType , class TermType , class DescendingProperty >
TermType dd_recursive_degree_lead (const CacheType &cache_mgr, const DegCacheMgr &deg_mgr, NaviType navi, TermType init, DescendingProperty prop)
template<class CacheType , class DegCacheMgr , class NaviType , class TermType , class SizeType , class DescendingProperty >
TermType & dd_recursive_degree_leadexp (const CacheType &cache_mgr, const DegCacheMgr &deg_mgr, NaviType navi, TermType &result, SizeType degree, DescendingProperty prop)
template<class CacheType , class DegCacheMgr , class NaviType , class TermType , class DescendingProperty >
TermType & dd_recursive_degree_leadexp (const CacheType &cache_mgr, const DegCacheMgr &deg_mgr, NaviType navi, TermType &result, DescendingProperty prop)
template<class CacheType , class NaviType , class TermType >
TermType dd_existential_abstraction (const CacheType &cache_mgr, NaviType varsNavi, NaviType navi, TermType init)
template<class CacheType , class NaviType , class PolyType >
PolyType dd_divide_recursively (const CacheType &cache_mgr, NaviType navi, NaviType monomNavi, PolyType init)
template<class DDGenerator , class Iterator , class NaviType , class PolyType >
PolyType dd_divide_recursively_exp (const DDGenerator &ddgen, NaviType navi, Iterator start, Iterator finish, PolyType init)
template<class CacheType , class NaviType , class MonomType >
MonomType cached_used_vars (const CacheType &cache, NaviType navi, MonomType init)
template<class NaviType , class Iterator >
bool dd_owns (NaviType navi, Iterator start, Iterator finish)
template<class CacheType , class NaviType , class DegType , class SetType >
SetType dd_graded_part (const CacheType &cache, NaviType navi, DegType deg, SetType init)
template<class CacheManager , class NaviType , class SetType >
SetType dd_first_divisors_of (CacheManager cache_mgr, NaviType navi, NaviType rhsNavi, SetType init)
template<class CacheType , class NaviType , class SetType >
SetType dd_first_multiples_of (const CacheType &cache_mgr, NaviType navi, NaviType rhsNavi, SetType init)
template<class FirstIterator , class SecondIterator , class BinaryPredicate >
CTypes::comp_type lex_compare_3way (FirstIterator start, FirstIterator finish, SecondIterator rhs_start, SecondIterator rhs_finish, BinaryPredicate idx_comp)
template<class LhsType , class RhsType , class BinaryPredicate >
CTypes::comp_type lex_compare (const LhsType &lhs, const RhsType &rhs, BinaryPredicate idx_comp, valid_tag has_easy_equality_test)
 defines lexicographic comparison
template<class LhsType , class RhsType , class BinaryPredicate >
CTypes::comp_type lex_compare (const LhsType &lhs, const RhsType &rhs, BinaryPredicate idx_comp, invalid_tag has_no_easy_equality_test)
 defines lexicographic comparison
template<class LhsType , class RhsType , class BinaryPredicate >
CTypes::comp_type lex_compare (const LhsType &lhs, const RhsType &rhs, BinaryPredicate idx_comp)
 defines lexicographic comparison
template<class LhsType , class RhsType , class BinaryPredicate >
CTypes::comp_type deg_lex_compare (const LhsType &lhs, const RhsType &rhs, BinaryPredicate idx_comp)
 defines degree-lexicographic comparison
template<class StackType , class Iterator >
void dummy_append (StackType &stack, Iterator start, Iterator finish)
template<class DegreeCacher , class NaviType , class IdxType >
NaviType::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)
Prepare for the application of intrinsive pointers

void intrusive_ptr_add_ref (CCuddCore *pCore)
 Increment reference count.
void intrusive_ptr_release (CCuddCore *pCore)
 Release current pointer by decrementing reference counting.

Variables

BoolePolyRing active_ring

Function Documentation

template<class FunctionType , class ManagerType , class NodeType >
void polybori::apply_assign_cudd_function ( FunctionType  func,
ManagerType &  mgr,
NodeType &  first,
const NodeType &  second 
)
template<class FunctionType , class ManagerType , class NodeType >
NodeType polybori::apply_cudd_function ( FunctionType  func,
ManagerType &  mgr,
const NodeType &  first,
const NodeType &  second 
)
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 
)
template<class IdxType , class Iterator , class BinaryPredicate >
CTypes::comp_type polybori::block_deg_lex_idx_compare ( IdxType  lhs,
IdxType  rhs,
Iterator  start,
Iterator  finish,
BinaryPredicate  idx_comp 
)
Note:
: no necessary for block_dlex, only for block_dp_asc

References generic_compare_3way().

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

template<class LhsIterator , class RhsIterator , class Iterator , class BinaryPredicate >
CTypes::comp_type polybori::block_dlex_compare ( LhsIterator  lhsStart,
LhsIterator  lhsFinish,
RhsIterator  rhsStart,
RhsIterator  rhsFinish,
Iterator  start,
Iterator  finish,
BinaryPredicate  idx_comp 
)
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

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

template<class SetType >
void polybori::combine_sizes ( const SetType &  bset,
typename SetType::size_type &  init 
)
template<class SetType >
void polybori::combine_sizes ( const SetType &  bset,
double &  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().

Referenced by count_index().

template<class SizeType , class IdxType , class SetType >
SizeType& polybori::count_index ( SizeType &  size,
IdxType  idx,
const SetType &  bset 
)

References count_index().

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

temporarily (needs to be more generic)

Todo:
Next line needs generalization

References get_mgr_core().

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

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

temporarily (needs to be more generic)

References get_mgr_core().

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

template<class NaviType , class TermType , class TernaryOperator , class TerminalOperator >
TermType polybori::dd_backward_transform ( NaviType  navi,
TermType  init,
TernaryOperator  newNode,
TerminalOperator  terminate 
)

Function templates for transforming decision diagrams.

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

template<class DegreeCacher , class NaviType >
NaviType::deg_type polybori::dd_cached_degree ( const DegreeCacher &  cache,
NaviType  navi 
)
template<class CacheType , class NaviType , class PolyType >
PolyType polybori::dd_divide_recursively ( const CacheType &  cache_mgr,
NaviType  navi,
NaviType  monomNavi,
PolyType  init 
)
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 
)
template<class CacheType , class NaviType , class TermType >
TermType polybori::dd_existential_abstraction ( const CacheType &  cache_mgr,
NaviType  varsNavi,
NaviType  navi,
TermType  init 
)
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

template<class CacheType , class NaviType , class SetType >
SetType polybori::dd_first_multiples_of ( const CacheType &  cache_mgr,
NaviType  navi,
NaviType  rhsNavi,
SetType  init 
)
template<class CacheType , class NaviType , class DegType , class SetType >
SetType polybori::dd_graded_part ( const CacheType &  cache,
NaviType  navi,
DegType  deg,
SetType  init 
)
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  ) 
template<class NaviType >
bool polybori::dd_is_singleton ( NaviType  navi  ) 
template<class NaviType >
bool polybori::dd_is_singleton_or_pair ( NaviType  navi  ) 
template<class DDType , class OutputType >
OutputType polybori::dd_last_lexicographical_term ( const DDType &  dd,
type_tag< OutputType >   
)

Get last term (wrt. lexicographical order).

References reversed_inter_copy().

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

template<class CacheType , class NaviType , class SetType >
SetType polybori::dd_mapping ( const CacheType &  cache,
NaviType  navi,
NaviType  map,
SetType  init 
)

Referenced by apply_mapping().

template<class NaviType , class DDType >
DDType polybori::dd_minimal_elements ( NaviType  navi,
DDType  dd,
DDType &  multiples 
)

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

Referenced by dd_minimal_elements().

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

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

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

template<class CacheType , class NaviType , class PolyType , class MonomTag >
PolyType polybori::dd_multiply_recursively ( const CacheType &  cache_mgr,
NaviType  monomNavi,
NaviType  navi,
PolyType  init,
MonomTag  monom_tag 
)
template<class CacheType , class NaviType , class PolyType >
PolyType polybori::dd_multiply_recursively ( const CacheType &  cache_mgr,
NaviType  firstNavi,
NaviType  secondNavi,
PolyType  init 
)
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 
)
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 
)
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)

template<class NaviType , class BooleConstant >
BooleConstant polybori::dd_pair_check ( NaviType  navi,
BooleConstant  allowSingleton 
)

References dd_is_singleton().

Referenced by dd_is_pair(), and dd_is_singleton_or_pair().

template<class NaviType >
void polybori::dd_print ( NaviType  navi  ) 

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

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

Referenced by dd_print_term(), and dd_print_terms().

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

References dd_print_term().

template<class Iterator , class NameGenerator , class Separator , class InnerSeparator , class EmptySetType , class OStreamType >
void polybori::dd_print_terms ( Iterator  start,
Iterator  finish,
const NameGenerator &  get_name,
const Separator &  sep,
const InnerSeparator &  innersep,
const EmptySetType &  emptyset,
OStreamType &  os 
)
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 
)
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 
)
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 
)
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 
)
template<class NaviType , class TermType , class OutIterator , class ThenBinaryOperator >
void polybori::dd_transform ( const NaviType &  navi,
const TermType &  init,
const OutIterator &  result,
const ThenBinaryOperator &  then_binop 
)

Function templates for transforming decision diagrams.

References dd_transform().

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

Function templates for transforming decision diagrams.

Referenced by dd_transform().

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

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

References dd_transform().

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

Function templates for transforming decision diagrams.

References dd_transform().

void polybori::dec_ref ( DdNode *  node  )  [inline]
template<class NaviType >
void polybori::dec_ref ( const NaviType &  navi  )  [inline]
template<class LhsType , class RhsType , class BinaryPredicate >
CTypes::comp_type polybori::deg_lex_compare ( const LhsType &  lhs,
const RhsType &  rhs,
BinaryPredicate  idx_comp 
)

defines degree-lexicographic comparison

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]
template<class StackType , class Iterator >
void polybori::dummy_append ( StackType &  stack,
Iterator  start,
Iterator  finish 
)
template<class ExpType , class RhsType , class ResultType >
void polybori::exp_divide ( const ExpType &  lhs,
const RhsType &  rhs,
ResultType &  result 
)
template<class ExpType , class RhsIterator , class SizeType , class ResultType >
void polybori::exp_multiply ( const ExpType &  lhs,
RhsIterator  start,
RhsIterator  finish,
SizeType  nlen,
ResultType &  result 
)
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]
Cudd* polybori::extract_manager ( const Cudd &  mgr  )  [inline]
CCuddInterface::mgrcore_ptr polybori::extract_manager ( const CCuddInterface &  mgr  )  [inline]
template<class MgrType >
const MgrType& polybori::extract_manager ( const MgrType &  mgr  )  [inline]
template<class MgrType , class DDType >
const DDType& polybori::fetch_diagram ( const MgrType &  mgr,
const DDType &  rhs 
) [inline]
ZDD polybori::fetch_diagram ( const Cudd &  mgr,
const ZDD &  rhs 
) [inline]
Cudd& polybori::fetch_manager ( const Cudd &  mgr  )  [inline]
template<class MgrType >
const MgrType& polybori::fetch_manager ( const MgrType &  mgr  )  [inline]
template<class HashType >
void polybori::finalize_term_hash ( HashType &  seed  ) 
BooleMonomial polybori::GCD ( const BooleMonomial &  lhs,
const BooleMonomial &  rhs 
) [inline]

Compute the greatest common divisor of two monomials.

References polybori::BooleMonomial::GCD().

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

Compute the greatest common divisor of two monomials.

References polybori::BooleExponent::GCD().

template<class MonomType , class PolyType >
PolyType polybori::generate_mapping ( MonomType &  fromVars,
MonomType &  toVars,
PolyType  init 
)

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 
)
template<class MgrType >
const MgrType& polybori::get_manager ( const MgrType &  mgr  )  [inline]
Cudd& polybori::get_manager ( Cudd *  mgr  )  [inline]
template<class MgrType >
const MgrType& polybori::get_mgr_core ( const MgrType &  rhs  )  [inline]
CCuddInterface::mgrcore_ptr polybori::get_mgr_core ( const CCuddInterface &  mgr  )  [inline]
Todo:
merge with extract_manager

References polybori::CCuddInterface::managerCore().

Cudd* polybori::get_mgr_core ( const Cudd &  rhs  )  [inline]
boost::shared_ptr< CDynamicOrderBase > polybori::get_ordering ( CTypes::ordercode_type  order  )  [inline]
BooleMonomial::bool_type polybori::greater_variable ( BooleMonomial::idx_type  lhs,
BooleMonomial::idx_type  rhs 
)

Checks whether BooleVariable(lhs) > BooleVariable(rhs).

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

void polybori::inc_ref ( DdNode *  node  )  [inline]
template<class NaviType >
void polybori::inc_ref ( const NaviType &  navi  )  [inline]
template<class IteratorLike , class ForwardIteratorTag >
IteratorLike polybori::increment_iteratorlike ( IteratorLike  iter,
ForwardIteratorTag   
)

Referenced by increment_iteratorlike().

template<class IteratorLike >
IteratorLike polybori::increment_iteratorlike ( IteratorLike  iter,
navigator_tag   
)
template<class IteratorLike >
IteratorLike polybori::increment_iteratorlike ( IteratorLike  iter  ) 
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(), deg_lex_compare(), and lex_compare().

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

defines lexicographic comparison

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

References lex_compare().

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

Referenced by lex_compare().

template<class IdxType , class OrderType >
bool polybori::lie_in_same_block ( IdxType  first,
IdxType  second,
const OrderType &  order,
valid_tag   
)
template<class IdxType , class OrderType >
bool polybori::lie_in_same_block ( IdxType  ,
IdxType  ,
const OrderType &  ,
invalid_tag   
)
template<class IteratorType , class SizeType >
SizeType polybori::limited_distance ( IteratorType  start,
IteratorType  finish,
SizeType  limit 
)
template<class NaviType , class LowerIterator , class ValueType >
ValueType polybori::lower_term_accumulate ( NaviType  navi,
LowerIterator  lstart,
LowerIterator  lfinish,
ValueType  init 
)

Todo:
Maybe recursive caching is efficient here.

References polybori::BooleSet::change().

Referenced by term_accumulate().

template<class PolyType , class MonomType >
PolyType polybori::mapping ( PolyType  poly,
MonomType  fromVars,
MonomType  toVars 
)
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 
)
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 
)
template<class DegCacheMgr , class NaviType , class SizeType >
bool polybori::max_degree_on_then ( const DegCacheMgr &  deg_mgr,
NaviType  navi,
SizeType  degree,
invalid_tag  non_descending 
)

References dd_cached_degree().

template<class DegCacheMgr , class NaviType , class SizeType >
bool polybori::max_degree_on_then ( const DegCacheMgr &  deg_mgr,
NaviType  navi,
SizeType  degree,
valid_tag  is_descending 
)
template<class NaviType , class ReverseIterator , class DDOperations >
NaviType polybori::minimal_of_two_terms ( NaviType  navi,
NaviType &  multiples,
ReverseIterator  idxStart,
ReverseIterator  idxFinish,
const DDOperations &  apply 
)

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

elseTail = elseNavi;

Cudd_Ref(elseTail); 1 elseMult = elseTail;

!2 thenTail = thenNavi;

!1 thenMult= thenTail;

References indexed_term_multiples(), and prepend_multiples_wrt_indices().

Referenced by dd_minimal_elements().

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

Nonquality check (with constant lhs).

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

Remainder of division of a polynomial by a variable.

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

Modulus monomial (division remainder).

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

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

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

Multiplication of monomials by a polynomial.

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

Multiplication of monomials.

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

Multiplication of a polynomial by a variable.

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

Multiplication of variables by a 0 or 1.

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

Multiplication of monomials.

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

Multiplication of 0 or 1 by a Variable.

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

Multiplication of monomials.

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

Multiplication of variables by a monomial.

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

Multiplication of variables by a polynomial.

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

Multiplication of monomials.

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

Multiplication of a polynomial by a variable with assignment.

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

Multiplication of monomials.

References polybori::BooleExponent::multiply().

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

Addition operation.

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

Addition operation.

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

Addition operation.

template<class RHSType >
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.

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

Division of monomials.

References polybori::BooleExponent::divide().

BoolePolynomial polybori::operator/ ( const BooleVariable &  lhs,
const BooleVariable &  rhs 
) [inline]
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.

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

Division by monomial (skipping remainder).

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

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

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

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

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

Less than comparision.

References polybori::BooleExponent::compare().

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

Less than comparision.

References polybori::BooleMonomial::compare().

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

Stream output operator.

References polybori::BooleExponent::print().

template<class IdxType , class VarNameLit , class VarHeadLit , class VarTailLit >
CIdxVariable<IdxType, VarNameLit, VarHeadLit, VarTailLit>::ostream_type& polybori::operator<< ( typename CIdxVariable< IdxType, VarNameLit, VarHeadLit, VarTailLit >::ostream_type &  os,
const CIdxVariable< IdxType, VarNameLit, VarHeadLit, VarTailLit > &  storage 
) [inline]

Stream output operator.

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

Stream output operator.

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

Stream output operator.

References polybori::BoolePolynomial::print().

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

Stream output operator.

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

Stream output operator.

References polybori::BooleSet::print().

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

Stream output operator.

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

Less or equal than comparision.

References polybori::BooleExponent::compare().

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

Less or equal than comparision.

References polybori::BooleMonomial::compare().

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

Equality check (with constant lhs).

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

Greater than comparision.

References polybori::BooleExponent::compare().

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

Greater than comparision.

References polybori::BooleMonomial::compare().

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

Greater or equal than comparision.

References polybori::BooleExponent::compare().

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

Greater or equal than comparision.

References polybori::BooleMonomial::compare().

template<class ValueType >
void polybori::pbori_shared_ptr_postclean ( const boost::shared_ptr< ValueType > &  ,
const boost::shared_ptr< ValueType > &   
)
template<class MgrType , class NodeType >
NodeType polybori::pboriCudd_zddUnionXor ( MgrType  dd,
NodeType  P,
NodeType  Q 
)
template<class MgrType , class NodeType >
NodeType polybori::pboriCuddZddUnionXor ( MgrType  zdd,
NodeType  P,
NodeType  Q 
)

The following should be made more generic

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

References pboriCuddZddUnionXor__().

Referenced by pboriCudd_zddUnionXor().

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

Referenced by pboriCuddZddUnionXor().

template<class NaviType , class SizeType , class ReverseIterator , class DDOperations >
NaviType polybori::prepend_multiples_wrt_indices ( NaviType  navi,
SizeType  minIdx,
ReverseIterator  start,
ReverseIterator  finish,
const DDOperations &  apply 
)
template<class MgrType >
void polybori::recursive_dec_ref ( const MgrType &  mgr,
DdNode *  node 
) [inline]
template<class MgrType , class NaviType >
void polybori::recursive_dec_ref ( const MgrType &  mgr,
const NaviType &  navi 
) [inline]
template<class FirstIterator , class SecondIterator , class IdxType , class BinaryPredicate >
CTypes::comp_type polybori::restricted_lex_compare_3way ( FirstIterator  start,
FirstIterator  finish,
SecondIterator  rhs_start,
SecondIterator  rhs_finish,
IdxType  max_index,
BinaryPredicate  idx_comp 
)

Referenced by block_dlex_compare().

template<class InputIterator , class Intermediate , class OutputIterator >
OutputIterator polybori::reversed_inter_copy ( InputIterator  start,
InputIterator  finish,
Intermediate &  inter,
OutputIterator  output 
)

Function templates doing a reversed copy using intermediate storage.

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

template<class InputIterator , class OutputIterator , class FirstFunction , class UnaryFunction >
OutputIterator polybori::special_first_transform ( InputIterator  first,
InputIterator  last,
OutputIterator  result,
UnaryFunction  op,
FirstFunction  firstop 
)
BoolePolynomial polybori::spoly ( const BoolePolynomial &  first,
const BoolePolynomial &  second 
) [inline]

Compute spoly of two polynomials.

References polybori::BoolePolynomial::lead().

Referenced by polybori::groebner::IJPairData::extract(), and polybori::groebner::nf3_db().

template<class HashType , class NaviType >
void polybori::stable_first_hash_range ( HashType &  seed,
NaviType  navi 
)
template<class NaviType >
std::size_t polybori::stable_first_hash_range ( NaviType  navi  ) 
template<class NaviType >
std::size_t polybori::stable_hash_range ( NaviType  navi  ) 

References stable_hash_range().

template<class HashType , class NaviType >
void polybori::stable_hash_range ( HashType &  seed,
NaviType  navi 
)
template<class Iterator >
std::size_t polybori::stable_term_hash ( Iterator  start,
Iterator  finish 
)

References stable_term_hash().

template<class HashType , class Iterator >
void polybori::stable_term_hash ( HashType &  seed,
Iterator  start,
Iterator  finish 
)
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 
)
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 term_accumulate(), and upper_term_accumulate().

template<class UpperIterator , class NaviType , class ValueType >
ValueType polybori::upper_term_accumulate ( UpperIterator  ustart,
UpperIterator  ufinish,
NaviType  navi,
ValueType  init 
)

Referenced by term_accumulate().


Variable Documentation