BoolePolynomial.h
Go to the documentation of this file.
// -*- c++ -*-
//*****************************************************************************
//*****************************************************************************
#ifndef polybori_BoolePolynomial_h_
#define polybori_BoolePolynomial_h_
// include standard definitions
#include <vector>
// get standard map functionality
#include <map>
// get standard algorithmic functionalites
#include <algorithm>
#include <polybori/BoolePolyRing.h>
// include definition of sets of Boolean variables
#include <polybori/routines/pbori_func.h>
#include <polybori/common/tags.h>
#include <polybori/BooleSet.h>
#include <polybori/iterators/CTermIter.h>
#include <polybori/iterators/CGenericIter.h>
#include <polybori/iterators/CBidirectTermIter.h>
#include <polybori/BooleConstant.h>
BEGIN_NAMESPACE_PBORI
// forward declarations
class LexOrder;
class DegLexOrder;
class DegRevLexAscOrder;
class BlockDegLexOrder;
class BlockDegRevLexAscOrder;
class BooleMonomial;
class BooleVariable;
class BooleExponent;
template <class IteratorType, class MonomType>
class CIndirectIter;
template <class IteratorType, class MonomType>
class COrderedIter;
//template<class, class, class, class> class CGenericIter;
template<class, class, class, class> class CDelayedTermIter;
template<class OrderType, class NavigatorType, class MonomType>
class CGenericIter;
template<class NavigatorType, class ExpType>
class CExpIter;
class BoolePolynomial;
BoolePolynomial
operator+(const BoolePolynomial& lhs, const BoolePolynomial& rhs);
class BoolePolynomial:
public CAuxTypes{
public:
friend class BooleMonomial;
//-------------------------------------------------------------------------
// types definitions
//-------------------------------------------------------------------------
typedef BoolePolynomial self;
typedef BooleSet dd_type;
typedef CTypes::ostream_type ostream_type;
typedef dd_type::first_iterator first_iterator;
typedef dd_type::navigator navigator;
typedef BooleMonomial monom_type;
typedef BooleVariable var_type;
typedef BooleExponent exp_type;
typedef BooleConstant constant_type;
typedef BoolePolyRing ring_type;
typedef CTypes::comp_type comp_type;
typedef
binary_composition< std::plus<size_type>,
project_ith<1>, integral_constant<size_type, 1> >
increment_type;
typedef
binary_composition< std::minus<size_type>,
project_ith<1>, integral_constant<size_type, 1> >
decrement_type;
// typedef COrderedIter<exp_type> ordered_exp_iterator;
typedef COrderedIter<navigator, exp_type> ordered_exp_iterator;
// typedef COrderedIter<monom_type> ordered_iterator;
typedef COrderedIter<navigator, monom_type> ordered_iterator;
typedef CGenericIter<LexOrder, navigator, monom_type> lex_iterator;
typedef CGenericIter<DegLexOrder, navigator, monom_type> dlex_iterator;
typedef CGenericIter<DegRevLexAscOrder, navigator, monom_type>
dp_asc_iterator;
typedef CGenericIter<BlockDegLexOrder, navigator, monom_type>
block_dlex_iterator;
typedef CGenericIter<BlockDegRevLexAscOrder, navigator, monom_type>
block_dp_asc_iterator;
typedef CGenericIter<LexOrder, navigator, exp_type> lex_exp_iterator;
typedef CGenericIter<DegLexOrder, navigator, exp_type> dlex_exp_iterator;
typedef CGenericIter<DegRevLexAscOrder, navigator, exp_type>
dp_asc_exp_iterator;
typedef CGenericIter<BlockDegLexOrder, navigator, exp_type>
block_dlex_exp_iterator;
typedef CGenericIter<BlockDegRevLexAscOrder, navigator, exp_type>
block_dp_asc_exp_iterator;
typedef lex_iterator const_iterator;
typedef CExpIter<navigator, exp_type> exp_iterator;
typedef CGenericIter<LexOrder, navigator, deg_type> deg_iterator;
typedef std::vector<monom_type> termlist_type;
typedef dd_type::easy_equality_property easy_equality_property;
typedef BooleSet set_type;
typedef std::map<self, idx_type, symmetric_composition<
std::less<navigator>, navigates<self> > > idx_map_type;
typedef std::map<self, std::vector<self>, symmetric_composition<
std::less<navigator>, navigates<self> > > poly_vec_map_type;
//-------------------------------------------------------------------------
// constructors and destructor
//-------------------------------------------------------------------------
// BoolePolynomial();
// explicit BoolePolynomial(constant_type);
BoolePolynomial(const ring_type& ring):
m_dd(ring.zero() ) { }
BoolePolynomial(constant_type isOne, const ring_type& ring):
m_dd(isOne? ring.one(): ring.zero() ) { }
BoolePolynomial(const dd_type& rhs): m_dd(rhs) {}
// BoolePolynomial(const set_type& rhs): m_dd(rhs.diagram()) {}
BoolePolynomial(const exp_type&, const ring_type&);
BoolePolynomial(const navigator& rhs, const ring_type& ring):
m_dd(ring, rhs) {
PBORI_ASSERT(rhs.isValid());
}
~BoolePolynomial() {}
//-------------------------------------------------------------------------
// operators and member functions
//-------------------------------------------------------------------------
// self& operator=(const self& rhs) {
// return m_dd = rhs.m_dd;
// }
self& operator=(constant_type rhs) {
return (*this) = self(rhs, ring());
}
const self& operator-() const { return *this; }
self& operator+=(const self&);
self& operator+=(constant_type rhs) {
//return *this = (self(*this) + (rhs).generate(*this));
if (rhs) (*this) = (*this + ring().one());
return *this;
}
template <class RHSType>
self& operator-=(const RHSType& rhs) { return operator+=(rhs); }
self& operator*=(const monom_type&);
self& operator*=(const exp_type&);
self& operator*=(const self&);
self& operator*=(constant_type rhs) {
if (!rhs) *this = ring().zero();
return *this;
}
self& operator/=(const var_type&);
self& operator/=(const monom_type&);
self& operator/=(const exp_type&);
self& operator/=(const self& rhs);
self& operator/=(constant_type rhs);
self& operator%=(const var_type&);
self& operator%=(const monom_type&);
self& operator%=(const self& rhs) {
return (*this) -= (self(rhs) *= (self(*this) /= rhs));
}
self& operator%=(constant_type rhs) { return (*this) /= (!rhs); }
bool_type operator==(const self& rhs) const { return (m_dd == rhs.m_dd); }
bool_type operator!=(const self& rhs) const { return (m_dd != rhs.m_dd); }
bool_type operator==(constant_type rhs) const {
return ( rhs? isOne(): isZero() );
}
bool_type operator!=(constant_type rhs) const {
//return ( rhs? (!(isOne())): (!(isZero())) );
return (!(*this==rhs));
}
bool_type isZero() const { return m_dd.isZero(); }
bool_type isOne() const { return m_dd.isOne(); }
bool_type isConstant() const { return m_dd.isConstant(); }
bool_type hasConstantPart() const { return m_dd.ownsOne(); }
bool_type firstReducibleBy(const self&) const;
monom_type lead() const;
monom_type lexLead() const;
monom_type boundedLead(deg_type bound) const;
exp_type leadExp() const;
exp_type boundedLeadExp(deg_type bound) const;
set_type leadDivisors() const { return leadFirst().firstDivisors(); };
hash_type hash() const { return m_dd.hash(); }
hash_type stableHash() const { return m_dd.stableHash(); }
hash_type leadStableHash() const;
deg_type deg() const;
deg_type leadDeg() const;
deg_type lexLeadDeg() const;
deg_type totalDeg() const;
deg_type leadTotalDeg() const;
self gradedPart(deg_type deg) const;
size_type nNodes() const;
size_type nUsedVariables() const;
monom_type usedVariables() const;
exp_type usedVariablesExp() const;
size_type length() const;
ostream_type& print(ostream_type&) const;
const_iterator begin() const;
const_iterator end() const;
exp_iterator expBegin() const;
exp_iterator expEnd() const;
first_iterator firstBegin() const;
first_iterator firstEnd() const;
monom_type firstTerm() const;
deg_iterator degBegin() const;
deg_iterator degEnd() const;
ordered_iterator orderedBegin() const;
ordered_iterator orderedEnd() const;
ordered_exp_iterator orderedExpBegin() const;
ordered_exp_iterator orderedExpEnd() const;
lex_iterator genericBegin(lex_tag) const;
lex_iterator genericEnd(lex_tag) const;
dlex_iterator genericBegin(dlex_tag) const;
dlex_iterator genericEnd(dlex_tag) const;
dp_asc_iterator genericBegin(dp_asc_tag) const;
dp_asc_iterator genericEnd(dp_asc_tag) const;
block_dlex_iterator genericBegin(block_dlex_tag) const;
block_dlex_iterator genericEnd(block_dlex_tag) const;
block_dp_asc_iterator genericBegin(block_dp_asc_tag) const;
block_dp_asc_iterator genericEnd(block_dp_asc_tag) const;
lex_exp_iterator genericExpBegin(lex_tag) const;
lex_exp_iterator genericExpEnd(lex_tag) const;
dlex_exp_iterator genericExpBegin(dlex_tag) const;
dlex_exp_iterator genericExpEnd(dlex_tag) const;
dp_asc_exp_iterator genericExpBegin(dp_asc_tag) const;
dp_asc_exp_iterator genericExpEnd(dp_asc_tag) const;
block_dlex_exp_iterator genericExpBegin(block_dlex_tag) const;
block_dlex_exp_iterator genericExpEnd(block_dlex_tag) const;
block_dp_asc_exp_iterator genericExpBegin(block_dp_asc_tag) const;
block_dp_asc_exp_iterator genericExpEnd(block_dp_asc_tag) const;
navigator navigation() const { return m_dd.navigation(); }
navigator endOfNavigation() const { return navigator(); }
dd_type copyDiagram(){ return diagram(); }
operator set_type() const { return set(); };
size_type eliminationLength() const;
size_type eliminationLengthWithDegBound(deg_type garantied_deg_bound) const;
void fetchTerms(termlist_type&) const;
termlist_type terms() const;
const dd_type& diagram() const { return m_dd; }
set_type set() const { return m_dd; }
bool_type isSingleton() const { return dd_is_singleton(navigation()); }
bool_type isSingletonOrPair() const {
return dd_is_singleton_or_pair(navigation());
}
bool_type isPair() const { return dd_is_pair(navigation()); }
const ring_type& ring() const { return m_dd.ring(); }
comp_type compare(const self&) const;
bool_type inSingleBlock() const;
protected:
dd_type& internalDiagram() { return m_dd; }
self leadFirst() const;
set_type firstDivisors() const;
private:
dd_type m_dd;
};
inline BoolePolynomial
operator+(const BoolePolynomial& lhs, const BoolePolynomial& rhs) {
return BoolePolynomial(lhs) += rhs;
}
inline BoolePolynomial
operator+(const BoolePolynomial& lhs, BooleConstant rhs) {
return BoolePolynomial(lhs) += (rhs);
//return BoolePolynomial(lhs) += BoolePolynomial(rhs);
}
inline BoolePolynomial
operator+(BooleConstant lhs, const BoolePolynomial& rhs) {
return BoolePolynomial(rhs) += (lhs);
}
template <class RHSType>
inline BoolePolynomial
operator-(const BoolePolynomial& lhs, const RHSType& rhs) {
return BoolePolynomial(lhs) -= rhs;
}
inline BoolePolynomial
operator-(const BooleConstant& lhs, const BoolePolynomial& rhs) {
return -(BoolePolynomial(rhs) -= lhs);
}
#define PBORI_RHS_MULT(type) inline BoolePolynomial \
operator*(const BoolePolynomial& lhs, const type& rhs) { \
return BoolePolynomial(lhs) *= rhs; }
PBORI_RHS_MULT(BoolePolynomial)
PBORI_RHS_MULT(BooleMonomial)
PBORI_RHS_MULT(BooleExponent)
PBORI_RHS_MULT(BooleConstant)
#undef PBORI_RHS_MULT
#define PBORI_LHS_MULT(type) inline BoolePolynomial \
operator*(const type& lhs, const BoolePolynomial& rhs) { return rhs * lhs; }
PBORI_LHS_MULT(BooleMonomial)
PBORI_LHS_MULT(BooleExponent)
PBORI_LHS_MULT(BooleConstant)
#undef PBORI_LHS_MULT
template <class RHSType>
inline BoolePolynomial
operator/(const BoolePolynomial& lhs, const RHSType& rhs){
return BoolePolynomial(lhs) /= rhs;
}
template <class RHSType>
inline BoolePolynomial
operator%(const BoolePolynomial& lhs, const RHSType& rhs){
return BoolePolynomial(lhs) %= rhs;
}
inline BoolePolynomial::bool_type
operator==(BoolePolynomial::bool_type lhs, const BoolePolynomial& rhs) {
return (rhs == lhs);
}
inline BoolePolynomial::bool_type
operator!=(BoolePolynomial::bool_type lhs, const BoolePolynomial& rhs) {
return (rhs != lhs);
}
BoolePolynomial::ostream_type&
operator<<(BoolePolynomial::ostream_type&, const BoolePolynomial&);
// tests whether polynomial can be reduced by rhs
inline BoolePolynomial::bool_type
BoolePolynomial::firstReducibleBy(const self& rhs) const {
if( rhs.isOne() )
return true;
if( isZero() )
return rhs.isZero();
return std::includes(firstBegin(), firstEnd(),
rhs.firstBegin(), rhs.firstEnd());
}
END_NAMESPACE_PBORI
#endif // of polybori_BoolePolynomial_h_
polybori::BoolePolynomial::lex_exp_iterator
CGenericIter< LexOrder, navigator, exp_type > lex_exp_iterator
Definition: BoolePolynomial.h:167
polybori::BoolePolynomial::block_dp_asc_exp_iterator
CGenericIter< BlockDegRevLexAscOrder, navigator, exp_type > block_dp_asc_exp_iterator
Definition: BoolePolynomial.h:174
polybori::BoolePolynomial::operator!=
bool_type operator!=(constant_type rhs) const
Definition: BoolePolynomial.h:287
polybori::BoolePolynomial::isSingleton
bool_type isSingleton() const
Test, whether we have one term only.
Definition: BoolePolynomial.h:467
polybori::BoolePolynomial::operator==
bool_type operator==(const self &rhs) const
Definition: BoolePolynomial.h:282
polybori::BoolePolynomial::isPair
bool_type isPair() const
Test, whether we have two terms only.
Definition: BoolePolynomial.h:475
polybori::BoolePolynomial::BoolePolynomial
BoolePolynomial(const ring_type &ring)
Default constructor.
Definition: BoolePolynomial.h:212
polybori::BooleExponent
This class is just a wrapper for using variables for storing indices as interim data structure for Bo...
Definition: BooleExponent.h:34
polybori::BoolePolynomial::navigation
navigator navigation() const
Navigate through structure.
Definition: BoolePolynomial.h:441
END_NAMESPACE_PBORI
#define END_NAMESPACE_PBORI
Finish project's namespace.
Definition: pbori_defs.h:77
polybori::dd_is_pair
bool dd_is_pair(NaviType navi)
Definition: pbori_algo.h:805
polybori::BoolePolynomial::ring_type
BoolePolyRing ring_type
Type for Boolean polynomial rings (without ordering)
Definition: BoolePolynomial.h:127
polybori::BoolePolynomial::lex_iterator
CGenericIter< LexOrder, navigator, monom_type > lex_iterator
Definition: BoolePolynomial.h:156
polybori::BoolePolynomial::isOne
bool_type isOne() const
Check whether polynomial is constant one.
Definition: BoolePolynomial.h:297
polybori::BoolePolynomial::BoolePolynomial
BoolePolynomial(const navigator &rhs, const ring_type &ring)
Construct polynomial from navigator.
Definition: BoolePolynomial.h:229
polybori::BoolePolynomial::stableHash
hash_type stableHash() const
Get hash value, which is reproducible.
Definition: BoolePolynomial.h:334
BEGIN_NAMESPACE_PBORI
#define BEGIN_NAMESPACE_PBORI
Start project's namespace.
Definition: pbori_defs.h:74
polybori::BoolePolynomial::easy_equality_property
dd_type::easy_equality_property easy_equality_property
The property whether the equality check is easy is inherited from dd_type.
Definition: BoolePolynomial.h:190
CTermIter.h
polybori::BoolePolynomial::operator%=
self & operator%=(constant_type rhs)
Definition: BoolePolynomial.h:277
polybori::BoolePolynomial::operator==
bool_type operator==(constant_type rhs) const
Definition: BoolePolynomial.h:284
PBORI_RHS_MULT
#define PBORI_RHS_MULT(type)
Multiplication with other left-hand side type.
Definition: BoolePolynomial.h:539
polybori::dlex_tag
Marker for deg-lex ordering.
Definition: order_tags.h:32
polybori::BoolePolynomial::isConstant
bool_type isConstant() const
Check whether polynomial is zero or one.
Definition: BoolePolynomial.h:300
polybori::BoolePolynomial::dd_type
BooleSet dd_type
Definition: BoolePolynomial.h:102
polybori::BoolePolynomial::increment_type
binary_composition< std::plus< size_type >, project_ith< 1 >, integral_constant< size_type, 1 > > increment_type
Incrementation functional type.
Definition: BoolePolynomial.h:136
polybori::groebner::deg_type
int deg_type
Definition: groebner_defs.h:42
polybori::BoolePolynomial::ring
const ring_type & ring() const
Access ring, where this belongs to.
Definition: BoolePolynomial.h:478
polybori::BoolePolynomial::first_iterator
dd_type::first_iterator first_iterator
Iterator type for iterating over indices of the leading term.
Definition: BoolePolynomial.h:107
polybori::BoolePolynomial::hasConstantPart
bool_type hasConstantPart() const
Check whether polynomial has term one.
Definition: BoolePolynomial.h:303
polybori::project_ith
Accessing ith of n arguments (ITH = 0 returns default value of first type)
Definition: pbori_func.h:144
polybori::CAuxTypes::comp_type
short int comp_type
Type for comparisons.
Definition: pbori_defs.h:237
BooleSet.h
polybori::lex_tag
Marker for lex ordering.
Definition: order_tags.h:27
polybori::BoolePolynomial::operator*=
self & operator*=(constant_type rhs)
Definition: BoolePolynomial.h:263
polybori::BoolePolynomial::set
set_type set() const
Get corresponding subset of of the powerset over all variables.
Definition: BoolePolynomial.h:464
polybori::BoolePolynomial::dlex_exp_iterator
CGenericIter< DegLexOrder, navigator, exp_type > dlex_exp_iterator
Definition: BoolePolynomial.h:168
polybori::BoolePolyRing
This class reinterprets decicion diagram managers as Boolean polynomial rings, adds an ordering and v...
Definition: BoolePolyRing.h:40
polybori::BoolePolynomial::comp_type
CTypes::comp_type comp_type
Type for result of polynomial comparisons.
Definition: BoolePolynomial.h:130
polybori::BoolePolynomial::dlex_iterator
CGenericIter< DegLexOrder, navigator, monom_type > dlex_iterator
Definition: BoolePolynomial.h:158
polybori::navigates
Definition: pbori_func.h:722
pbori_func.h
polybori::CAuxTypes
This struct contains auxiliary type definitions.
Definition: pbori_defs.h:210
polybori::integral_constant
integral_constant<int_type, NUM>()() returns NUM of int_type, instead of possibly arguments...
Definition: pbori_func.h:263
polybori::BoolePolynomial::block_dlex_iterator
CGenericIter< BlockDegLexOrder, navigator, monom_type > block_dlex_iterator
Definition: BoolePolynomial.h:163
polybori::BoolePolynomial::const_iterator
lex_iterator const_iterator
Iterator type for iterating over all monomials.
Definition: BoolePolynomial.h:178
polybori::operator%
BoolePolynomial operator%(const BoolePolynomial &lhs, const RHSType &rhs)
Modulus monomial (division remainder)
Definition: BoolePolynomial.h:572
polybori::CAuxTypes::ostream_type
std::ostream ostream_type
Type for out-stream.
Definition: pbori_defs.h:246
BooleConstant.h
polybori::operator<<
BoolePolynomial::ostream_type & operator<<(BoolePolynomial::ostream_type &, const BoolePolynomial &)
Stream output operator.
Definition: BoolePolynomial.cc:744
polybori::operator==
BoolePolynomial::bool_type operator==(BoolePolynomial::bool_type lhs, const BoolePolynomial &rhs)
Equality check (with constant lhs)
Definition: BoolePolynomial.h:579
polybori::BoolePolynomial
This class wraps the underlying decicion diagram type and defines the necessary operations.
Definition: BoolePolynomial.h:85
polybori::CAuxTypes::hash_type
std::size_t hash_type
Type for hashing.
Definition: pbori_defs.h:231
polybori::COrderedIter
Definition: BoolePolynomial.h:63
polybori::BoolePolynomial::diagram
const dd_type & diagram() const
Read-only access to internal decision diagramm structure.
Definition: BoolePolynomial.h:461
polybori::BoolePolynomial::poly_vec_map_type
std::map< self, std::vector< self >, symmetric_composition< std::less< navigator >, navigates< self > > > poly_vec_map_type
Definition: BoolePolynomial.h:199
polybori::dd_is_singleton
bool dd_is_singleton(NaviType navi)
Definition: pbori_algo.h:770
polybori::BoolePolynomial::var_type
BooleVariable var_type
Fix type for treatment of monomials.
Definition: BoolePolynomial.h:118
CBidirectTermIter.h
polybori::BoolePolynomial::block_dlex_exp_iterator
CGenericIter< BlockDegLexOrder, navigator, exp_type > block_dlex_exp_iterator
Definition: BoolePolynomial.h:172
polybori::BoolePolynomial::isSingletonOrPair
bool_type isSingletonOrPair() const
Test, whether we have one or two terms only.
Definition: BoolePolynomial.h:470
polybori::BoolePolynomial::ostream_type
CTypes::ostream_type ostream_type
Definition: BoolePolynomial.h:103
polybori::CCuddDDFacade::firstDivisors
diagram_type firstDivisors() const
Get decison diagram representing the divisors of the first term.
Definition: CCuddDDFacade.h:445
PBORI_LHS_MULT
#define PBORI_LHS_MULT(type)
Multiplication with other left-hand side type.
Definition: BoolePolynomial.h:552
polybori::BoolePolynomial::termlist_type
std::vector< monom_type > termlist_type
Type for lists of terms.
Definition: BoolePolynomial.h:187
polybori::BoolePolynomial::decrement_type
binary_composition< std::minus< size_type >, project_ith< 1 >, integral_constant< size_type, 1 > > decrement_type
Decrementation functional type.
Definition: BoolePolynomial.h:142
polybori::BoolePolynomial::set_type
BooleSet set_type
Type for sets of Boolean variables.
Definition: BoolePolynomial.h:193
polybori::operator-
BoolePolynomial operator-(const BooleConstant &lhs, const BoolePolynomial &rhs)
Subtraction operation with constant right-hand-side.
Definition: BoolePolynomial.h:532
PBORI_ASSERT
#define PBORI_ASSERT(arg)
Definition: pbori_defs.h:118
polybori::BoolePolynomial::constant_type
BooleConstant constant_type
Type for wrapping integer and bool values.
Definition: BoolePolynomial.h:124
polybori::BoolePolynomial::endOfNavigation
navigator endOfNavigation() const
End of navigation marker.
Definition: BoolePolynomial.h:444
polybori::operator+
BoolePolynomial operator+(BooleConstant lhs, const BoolePolynomial &rhs)
Addition operation.
Definition: BoolePolynomial.h:517
polybori::symmetric_composition
Compose a binary function with a default constructable unary function for both arguments.
Definition: pbori_func.h:325
polybori::operator/
BoolePolynomial operator/(const BoolePolynomial &lhs, const RHSType &rhs)
Division by monomial (skipping remainder)
Definition: BoolePolynomial.h:565
polybori::BoolePolynomial::ordered_exp_iterator
COrderedIter< navigator, exp_type > ordered_exp_iterator
Iterator type for iterating over all exponents in ordering order.
Definition: BoolePolynomial.h:148
polybori::BoolePolynomial::idx_map_type
std::map< self, idx_type, symmetric_composition< std::less< navigator >, navigates< self > > > idx_map_type
Type for index maps.
Definition: BoolePolynomial.h:197
polybori::BoolePolynomial::block_dp_asc_iterator
CGenericIter< BlockDegRevLexAscOrder, navigator, monom_type > block_dp_asc_iterator
Definition: BoolePolynomial.h:165
polybori::CCuddFirstIter
This class defines an iterator over the first minimal term of a given ZDD node.
Definition: CCuddFirstIter.h:35
polybori::binary_composition
Compose a binary function with two default constructable unary functions.
Definition: pbori_func.h:274
polybori::BoolePolynomial::operator=
self & operator=(constant_type rhs)
Definition: BoolePolynomial.h:245
polybori::CDelayedTermIter
Definition: BoolePolynomial.h:67
CGenericIter.h
polybori::BoolePolynomial::operator%=
self & operator%=(const self &rhs)
Definition: BoolePolynomial.h:274
polybori::CGenericIter
Definition: BoolePolynomial.h:70
polybori::BoolePolynomial::internalDiagram
dd_type & internalDiagram()
Access to internal decision diagramm structure.
Definition: BoolePolynomial.h:488
polybori::BoolePolynomial::leadDivisors
set_type leadDivisors() const
Get all divisors of the leading term.
Definition: BoolePolynomial.h:328
BoolePolyRing.h
polybori::dp_asc_tag
Marker for ascending deg-rev-lex ordering.
Definition: order_tags.h:37
polybori::block_tag
Marker for block orderings.
Definition: order_tags.h:43
polybori::operator*=
BoolePolynomial & operator*=(BoolePolynomial &lhs, const BooleVariable &rhs)
Multiplication of a polynomial by a variable with assignment.
Definition: BooleMonomial.h:366
polybori::BoolePolynomial::hash
hash_type hash() const
Get unique hash value (may change from run to run)
Definition: BoolePolynomial.h:331
polybori::BoolePolynomial::operator+=
self & operator+=(constant_type rhs)
Definition: BoolePolynomial.h:252
polybori::BoolePolynomial::dp_asc_exp_iterator
CGenericIter< DegRevLexAscOrder, navigator, exp_type > dp_asc_exp_iterator
Definition: BoolePolynomial.h:170
polybori::BoolePolynomial::navigator
dd_type::navigator navigator
Iterator-like type for navigating through diagram structure.
Definition: BoolePolynomial.h:110
polybori::BoolePolynomial::isZero
bool_type isZero() const
Check whether polynomial is constant zero.
Definition: BoolePolynomial.h:294
polybori::BoolePolynomial::operator-
const self & operator-() const
Definition: BoolePolynomial.h:250
polybori::groebner::idx_type
polybori::CTypes::idx_type idx_type
Definition: groebner_defs.h:44
polybori::BoolePolynomial::monom_type
BooleMonomial monom_type
Fix type for treatment of monomials.
Definition: BoolePolynomial.h:115
tags.h
polybori::BoolePolynomial::~BoolePolynomial
~BoolePolynomial()
Destructor.
Definition: BoolePolynomial.h:235
polybori::BoolePolynomial::deg_iterator
CGenericIter< LexOrder, navigator, deg_type > deg_iterator
Iterator type for iterating all monomials (dereferencing to degree)
Definition: BoolePolynomial.h:184
polybori::CCuddNavigator::isValid
bool_type isValid() const
Check whether *this is not the default iterator self() (NULL pointer)
Definition: CCuddNavigator.h:125
polybori::operator!=
BoolePolynomial::bool_type operator!=(BoolePolynomial::bool_type lhs, const BoolePolynomial &rhs)
Nonquality check (with constant lhs)
Definition: BoolePolynomial.h:586
polybori::BoolePolynomial::dp_asc_iterator
CGenericIter< DegRevLexAscOrder, navigator, monom_type > dp_asc_iterator
Definition: BoolePolynomial.h:160
polybori::CCuddNavigator
This class defines an iterator for navigating through then and else branches of ZDDs.
Definition: CCuddNavigator.h:36
polybori::BooleSet
Definition: BooleSet.h:57
polybori::dd_is_singleton_or_pair
bool dd_is_singleton_or_pair(NaviType navi)
Definition: pbori_algo.h:798
polybori::BooleConstant
This class wraps a bool value, which was not converted to a boolean polynomial or monomial yet...
Definition: BooleConstant.h:40
polybori::BooleMonomial
This class is just a wrapper for using variables from cudd's decicion diagram.
Definition: BooleMonomial.h:50
polybori::CIndirectIter
Definition: BoolePolynomial.h:60
polybori::CAuxTypes::bool_type
bool bool_type
Type for standard true/false statements.
Definition: pbori_defs.h:216
polybori::BoolePolynomial::operator-=
self & operator-=(const RHSType &rhs)
Definition: BoolePolynomial.h:259
polybori::BoolePolynomial::BoolePolynomial
BoolePolynomial(constant_type isOne, const ring_type &ring)
Construct polynomial in given ring from a constant value 0 or 1.
Definition: BoolePolynomial.h:216
polybori::BooleVariable
This class is just a wrapper for using variables from cudd's decicion diagram.
Definition: BooleVariable.h:39
polybori::BoolePolynomial::exp_iterator
CExpIter< navigator, exp_type > exp_iterator
Iterator type for iterating all exponent vectors.
Definition: BoolePolynomial.h:181
polybori::BoolePolynomial::ordered_iterator
COrderedIter< navigator, monom_type > ordered_iterator
Iterator type for iterating over all monomials in ordering order.
Definition: BoolePolynomial.h:152
polybori::BoolePolynomial::BoolePolynomial
BoolePolynomial(const dd_type &rhs)
Construct polynomial from decision diagram.
Definition: BoolePolynomial.h:220
polybori::valid_tag
This class shows, whether a property of an order is valid.
Definition: tags.h:32
polybori::BoolePolynomial::exp_type
BooleExponent exp_type
Fix type for treatment of exponent vectors.
Definition: BoolePolynomial.h:121
polybori::BoolePolynomial::operator!=
bool_type operator!=(const self &rhs) const
Definition: BoolePolynomial.h:283
polybori::CExpIter
Definition: BoolePolynomial.h:73
polybori::BoolePolynomial::copyDiagram
dd_type copyDiagram()
gives a copy of the diagram
Definition: BoolePolynomial.h:447