polybori.dynamic.PyPolyBoRi
index
../../../../lib/python2.7/dist-packages/polybori/dynamic/PyPolyBoRi.so

 
Classes
       
Boost.Python.enum(__builtin__.int)
OrderCode
Boost.Python.instance(__builtin__.object)
BooleConstant
BoolePolynomialVector
BooleRing
Ring
BooleSet
CCuddNavigator
GroebnerStrategy
IntVector
Monomial
Polynomial
Variable
VariableBlockFalse
VariableBlockTrue

 
class BooleConstant(Boost.Python.instance)
    Boolean constant value
 
 
Method resolution order:
BooleConstant
Boost.Python.instance
__builtin__.object

Methods defined here:
__init__(...)
__init__( (object)arg1) -> None :
 
    C++ signature :
        void __init__(_object*)
 
__init__( (object)arg1, (BooleConstant)arg2) -> None :
 
    C++ signature :
        void __init__(_object*,polybori::BooleConstant)
 
__init__( (object)arg1, (int)arg2) -> None :
    Convert integer to Boolean value
 
    C++ signature :
        void __init__(_object*,int)
 
__init__( (object)arg1, (bool)arg2) -> None :
    Convert bool to Boolean value
 
    C++ signature :
        void __init__(_object*,bool)
__reduce__ = (...)
__repr__(...)
__repr__( (BooleConstant)arg1) -> str :
 
    C++ signature :
        boost::python::str __repr__(polybori::BooleConstant)
__str__(...)
__str__( (BooleConstant)arg1) -> str :
 
    C++ signature :
        boost::python::str __str__(polybori::BooleConstant)

Data and other attributes defined here:
__instance_size__ = 24

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

Data and other attributes inherited from Boost.Python.instance:
__new__ = <built-in method __new__ of Boost.Python.class object>
T.__new__(S, ...) -> a new object with type S, a subtype of T

 
class BoolePolynomialVector(Boost.Python.instance)
    
Method resolution order:
BoolePolynomialVector
Boost.Python.instance
__builtin__.object

Methods defined here:
__contains__(...)
__contains__( (BoolePolynomialVector)arg1, (object)arg2) -> bool :
 
    C++ signature :
        bool __contains__(std::vector<polybori::BoolePolynomial, std::allocator<polybori::BoolePolynomial> > {lvalue},_object*)
__delitem__(...)
__delitem__( (BoolePolynomialVector)arg1, (object)arg2) -> None :
 
    C++ signature :
        void __delitem__(std::vector<polybori::BoolePolynomial, std::allocator<polybori::BoolePolynomial> > {lvalue},_object*)
__eq__(...)
__eq__( (BoolePolynomialVector)arg1, (BoolePolynomialVector)arg2) -> object :
 
    C++ signature :
        _object* __eq__(std::vector<polybori::BoolePolynomial, std::allocator<polybori::BoolePolynomial> > {lvalue},std::vector<polybori::BoolePolynomial, std::allocator<polybori::BoolePolynomial> >)
__getitem__(...)
__getitem__( (object)arg1, (object)arg2) -> object :
 
    C++ signature :
        boost::python::api::object __getitem__(boost::python::back_reference<std::vector<polybori::BoolePolynomial, std::allocator<polybori::BoolePolynomial> >&>,_object*)
__init__ = init(self, iteratable=None)
__iter__(...)
__iter__( (object)arg1) -> object :
 
    C++ signature :
        boost::python::objects::iterator_range<boost::python::return_internal_reference<1ul, boost::python::default_call_policies>, __gnu_cxx::__normal_iterator<polybori::BoolePolynomial*, std::vector<polybori::BoolePolynomial, std::allocator<polybori::BoolePolynomial> > > > __iter__(boost::python::back_reference<std::vector<polybori::BoolePolynomial, std::allocator<polybori::BoolePolynomial> >&>)
__len__(...)
__len__( (BoolePolynomialVector)arg1) -> int :
 
    C++ signature :
        unsigned long __len__(std::vector<polybori::BoolePolynomial, std::allocator<polybori::BoolePolynomial> > {lvalue})
__reduce__ = (...)
__setitem__(...)
__setitem__( (BoolePolynomialVector)arg1, (object)arg2, (object)arg3) -> None :
 
    C++ signature :
        void __setitem__(std::vector<polybori::BoolePolynomial, std::allocator<polybori::BoolePolynomial> > {lvalue},_object*,_object*)
append(...)
append( (BoolePolynomialVector)arg1, (object)arg2) -> None :
 
    C++ signature :
        void append(std::vector<polybori::BoolePolynomial, std::allocator<polybori::BoolePolynomial> > {lvalue},boost::python::api::object)
extend(...)
extend( (BoolePolynomialVector)arg1, (object)arg2) -> None :
 
    C++ signature :
        void extend(std::vector<polybori::BoolePolynomial, std::allocator<polybori::BoolePolynomial> > {lvalue},boost::python::api::object)

Data and other attributes defined here:
__instance_size__ = 40

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

Data and other attributes inherited from Boost.Python.instance:
__new__ = <built-in method __new__ of Boost.Python.class object>
T.__new__(S, ...) -> a new object with type S, a subtype of T

 
class BooleRing(Boost.Python.instance)
    Boolean ring
 
 
Method resolution order:
BooleRing
Boost.Python.instance
__builtin__.object

Methods defined here:
__init__(...)
__init__( (object)arg1) -> None :
 
    C++ signature :
        void __init__(_object*)
 
__init__( (object)arg1, (int)arg2) -> None :
 
    C++ signature :
        void __init__(_object*,unsigned int)
__reduce__ = (...)

Data and other attributes defined here:
__instance_size__ = 24

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

Data and other attributes inherited from Boost.Python.instance:
__new__ = <built-in method __new__ of Boost.Python.class object>
T.__new__(S, ...) -> a new object with type S, a subtype of T

 
class BooleSet(Boost.Python.instance)
    Represents set of Boolean terms
 
 
Method resolution order:
BooleSet
Boost.Python.instance
__builtin__.object

Methods defined here:
__contains__(...)
__contains__( (BooleSet)arg1, (Monomial)arg2) -> bool :
    Check whether a term is included in BooleSet
 
    C++ signature :
        bool __contains__(polybori::BooleSet {lvalue},polybori::BooleMonomial)
__eq__(...)
__eq__( (BooleSet)arg1, (BooleSet)arg2) -> object :
 
    C++ signature :
        _object* __eq__(polybori::BooleSet {lvalue},polybori::BooleSet)
__hash__(...)
__hash__( (BooleSet)arg1) -> int :
    Fast hash code, based on the pointer to the underlying ZDD node. 
    It may vary from runtime to runtime.
 
    C++ signature :
        unsigned long __hash__(polybori::BooleSet {lvalue})
__init__ = booleset_new_init(self, arg=None, second=None)
__iter__(...)
__iter__( (object)arg1) -> object :
 
    C++ signature :
        boost::python::objects::iterator_range<boost::python::return_value_policy<boost::python::return_by_value, boost::python::default_call_policies>, polybori::CGenericIter<polybori::LexOrder, polybori::CCuddNavigator, polybori::BooleMonomial> > __iter__(boost::python::back_reference<polybori::BooleSet&>)
__len__(...)
__len__( (BooleSet)arg1) -> int :
 
    C++ signature :
        unsigned int __len__(polybori::BooleSet {lvalue})
__mod__(...)
__mod__( (BooleSet)arg1, (BooleSet)arg2) -> BooleSet :
 
    C++ signature :
        polybori::BooleSet __mod__(polybori::BooleSet,polybori::BooleSet)
__reduce__ = (...)
__repr__(...)
__repr__( (BooleSet)arg1) -> str :
 
    C++ signature :
        boost::python::str __repr__(polybori::BooleSet)
__str__(...)
__str__( (BooleSet)arg1) -> str :
 
    C++ signature :
        boost::python::str __str__(polybori::BooleSet)
cartesianProduct(...)
cartesianProduct( (BooleSet)arg1, (BooleSet)arg2) -> BooleSet :
    Cartesian product
 
    C++ signature :
        polybori::BooleSet cartesianProduct(polybori::BooleSet {lvalue},polybori::BooleSet)
change(...)
change( (BooleSet)arg1, (int)arg2) -> BooleSet :
    Substitute variable of given index by its complement
 
    C++ signature :
        polybori::BooleSet change(polybori::BooleSet {lvalue},int)
diff(...)
diff( (BooleSet)arg1, (BooleSet)arg2) -> BooleSet :
    Set difference
 
    C++ signature :
        polybori::BooleSet diff(polybori::BooleSet {lvalue},polybori::BooleSet)
divide(...)
divide( (BooleSet)arg1, (Monomial)arg2) -> BooleSet :
    Set division by a given term
 
    C++ signature :
        polybori::BooleSet divide(polybori::BooleSet {lvalue},polybori::BooleMonomial)
divisorsOf(...)
divisorsOf( (BooleSet)arg1, (Monomial)arg2) -> BooleSet :
    Compute intersection with divisors of the right-hand side term
 
    C++ signature :
        polybori::BooleSet divisorsOf(polybori::BooleSet {lvalue},polybori::BooleMonomial)
empty(...)
empty( (BooleSet)arg1) -> bool :
    Check, whether BooleSet is empty
 
    C++ signature :
        bool empty(polybori::BooleSet {lvalue})
existAbstract(...)
existAbstract( (BooleSet)arg1, (Monomial)arg2) -> BooleSet :
    a.existsAbstract(m) returns a BooleSet, where every term t is included, where exists n such that n*m=t*m and n is element of a
 
    C++ signature :
        polybori::BooleSet existAbstract(polybori::BooleSet {lvalue},polybori::BooleMonomial)
includeDivisors(...)
includeDivisors( (BooleSet)arg1) -> BooleSet :
 
    C++ signature :
        polybori::BooleSet includeDivisors(polybori::BooleSet)
intersect(...)
intersect( (BooleSet)arg1, (BooleSet)arg2) -> BooleSet :
    Set intersection
 
    C++ signature :
        polybori::BooleSet intersect(polybori::BooleSet {lvalue},polybori::BooleSet)
minimalElements(...)
minimalElements( (BooleSet)arg1) -> BooleSet :
    Get minimal elements with respect to inclusion
 
    C++ signature :
        polybori::BooleSet minimalElements(polybori::BooleSet)
multiplesOf(...)
multiplesOf( (BooleSet)arg1, (Monomial)arg2) -> BooleSet :
    Compute intersection with multiples of the right-hand side term
 
    C++ signature :
        polybori::BooleSet multiplesOf(polybori::BooleSet {lvalue},polybori::BooleMonomial)
nNodes(...)
nNodes( (BooleSet)arg1) -> int :
    Number of nodes of the underlying ZDD
 
    C++ signature :
        unsigned int nNodes(polybori::BooleSet {lvalue})
nSupport(...)
nSupport( (BooleSet)arg1) -> int :
 
    C++ signature :
        unsigned int nSupport(polybori::BooleSet {lvalue})
navigation(...)
navigation( (BooleSet)arg1) -> CCuddNavigator :
    Navigate through underlying ZDD structure
 
    C++ signature :
        polybori::CCuddNavigator navigation(polybori::BooleSet {lvalue})
ring(...)
ring( (BooleSet)arg1) -> BooleRing :
    Get corresponding ring
 
    C++ signature :
        polybori::BooleRing ring(polybori::BooleSet {lvalue})
set(...)
set( (BooleSet)arg1) -> BooleSet :
 
    C++ signature :
        polybori::BooleSet set(polybori::BooleSet)
sizeDouble(...)
sizeDouble( (BooleSet)arg1) -> float :
    Number of elements as double floating point number.
 
    C++ signature :
        double sizeDouble(polybori::BooleSet {lvalue})
stableHash(...)
stableHash( (BooleSet)arg1) -> int :
    Reproducible hash code
 
    C++ signature :
        unsigned long stableHash(polybori::BooleSet {lvalue})
subset0(...)
subset0( (BooleSet)arg1, (int)arg2) -> BooleSet :
    Returns BooleSet, where the nodes corresponding to Variables of given index is replaced by its else-branch
 
    C++ signature :
        polybori::BooleSet subset0(polybori::BooleSet {lvalue},int)
subset1(...)
subset1( (BooleSet)arg1, (int)arg2) -> BooleSet :
    Returns BooleSet, where the nodes corresponding to Variables of given index is replaced by its then-branch
 
    C++ signature :
        polybori::BooleSet subset1(polybori::BooleSet {lvalue},int)
union(...)
union( (BooleSet)arg1, (BooleSet)arg2) -> BooleSet :
    Set union
 
    C++ signature :
        polybori::BooleSet union(polybori::BooleSet {lvalue},polybori::BooleSet)
vars(...)
vars( (BooleSet)arg1) -> Monomial :
    Variables occurring in BooleSet
 
    C++ signature :
        polybori::BooleMonomial vars(polybori::BooleSet {lvalue})

Data and other attributes defined here:
__instance_size__ = 32

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

Data and other attributes inherited from Boost.Python.instance:
__new__ = <built-in method __new__ of Boost.Python.class object>
T.__new__(S, ...) -> a new object with type S, a subtype of T

 
class CCuddNavigator(Boost.Python.instance)
    
Method resolution order:
CCuddNavigator
Boost.Python.instance
__builtin__.object

Methods defined here:
__eq__(...)
__eq__( (CCuddNavigator)arg1, (CCuddNavigator)arg2) -> object :
 
    C++ signature :
        _object* __eq__(polybori::CCuddNavigator {lvalue},polybori::CCuddNavigator)
__hash__(...)
__hash__( (CCuddNavigator)arg1) -> int :
    Fast hash code, based on the pointer to the underlying ZDD node. 
    It may vary from runtime to runtime.
 
    C++ signature :
        unsigned long __hash__(polybori::CCuddNavigator {lvalue})
__init__(...)
__init__( (object)arg1) -> None :
 
    C++ signature :
        void __init__(_object*)
 
__init__( (object)arg1) -> None :
 
    C++ signature :
        void __init__(_object*)
 
__init__( (object)arg1, (CCuddNavigator)arg2) -> None :
    Iterator-like object, which allows to navigate through ZDD-based data structures,
 
    C++ signature :
        void __init__(_object*,polybori::CCuddNavigator)
__ne__(...)
__ne__( (CCuddNavigator)arg1, (CCuddNavigator)arg2) -> object :
 
    C++ signature :
        _object* __ne__(polybori::CCuddNavigator {lvalue},polybori::CCuddNavigator)
__reduce__ = (...)
constant(...)
constant( (CCuddNavigator)arg1) -> bool :
    Terminal node test
 
    C++ signature :
        bool constant(polybori::CCuddNavigator {lvalue})
elseBranch(...)
elseBranch( (CCuddNavigator)arg1) -> CCuddNavigator :
    Following else-edge of thr root node
 
    C++ signature :
        polybori::CCuddNavigator elseBranch(polybori::CCuddNavigator)
terminalOne(...)
terminalOne( (CCuddNavigator)arg1) -> bool :
    Check for terminal 1
 
    C++ signature :
        bool terminalOne(polybori::CCuddNavigator {lvalue})
thenBranch(...)
thenBranch( (CCuddNavigator)arg1) -> CCuddNavigator :
    Following then-edge of thr root node
 
    C++ signature :
        polybori::CCuddNavigator thenBranch(polybori::CCuddNavigator)
valid(...)
valid( (CCuddNavigator)arg1) -> bool :
    If navigator is constant, this checks for terminal one
 
    C++ signature :
        bool valid(polybori::CCuddNavigator {lvalue})
value(...)
value( (CCuddNavigator)arg1) -> int :
 
    C++ signature :
        int value(polybori::CCuddNavigator)

Data and other attributes defined here:
__instance_size__ = 24

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

Data and other attributes inherited from Boost.Python.instance:
__new__ = <built-in method __new__ of Boost.Python.class object>
T.__new__(S, ...) -> a new object with type S, a subtype of T

 
class GroebnerStrategy(Boost.Python.instance)
    
Method resolution order:
GroebnerStrategy
Boost.Python.instance
__builtin__.object

Methods defined here:
__getitem__(...)
__getitem__( (GroebnerStrategy)arg1, (int)arg2) -> Polynomial :
 
    C++ signature :
        polybori::BoolePolynomial __getitem__(polybori::groebner::GroebnerStrategy,int)
 
__getitem__( (GroebnerStrategy)arg1, (Monomial)arg2) -> Polynomial :
 
    C++ signature :
        polybori::BoolePolynomial __getitem__(polybori::groebner::GroebnerStrategy,polybori::BooleMonomial)
__init__(...)
__init__( (object)arg1) -> None :
 
    C++ signature :
        void __init__(_object*)
 
__init__( (object)arg1) -> None :
 
    C++ signature :
        void __init__(_object*)
 
__init__( (object)arg1, (GroebnerStrategy)arg2) -> None :
 
    C++ signature :
        void __init__(_object*,polybori::groebner::GroebnerStrategy)
__iter__(...)
__iter__( (object)arg1) -> object :
 
    C++ signature :
        boost::python::objects::iterator_range<boost::python::return_value_policy<boost::python::return_by_value, boost::python::default_call_policies>, StrategyIterator> __iter__(boost::python::back_reference<polybori::groebner::GroebnerStrategy const&>)
__len__(...)
__len__( (GroebnerStrategy)arg1) -> int :
 
    C++ signature :
        int __len__(polybori::groebner::GroebnerStrategy)
__reduce__ = (...)
addAsYouWish(...)
addAsYouWish( (GroebnerStrategy)arg1, (Polynomial)arg2) -> None :
 
    C++ signature :
        void addAsYouWish(polybori::groebner::GroebnerStrategy {lvalue},polybori::BoolePolynomial)
addGenerator(...)
addGenerator( (GroebnerStrategy)arg1, (Polynomial)arg2) -> None :
 
    C++ signature :
        void addGenerator(polybori::groebner::GroebnerStrategy {lvalue},polybori::BoolePolynomial)
addGeneratorDelayed(...)
addGeneratorDelayed( (GroebnerStrategy)arg1, (Polynomial)arg2) -> None :
 
    C++ signature :
        void addGeneratorDelayed(polybori::groebner::GroebnerStrategy {lvalue},polybori::BoolePolynomial)
allGenerators(...)
allGenerators( (GroebnerStrategy)arg1) -> BoolePolynomialVector :
 
    C++ signature :
        std::vector<polybori::BoolePolynomial, std::allocator<polybori::BoolePolynomial> > allGenerators(polybori::groebner::GroebnerStrategy {lvalue})
allSpolysInNextDegree(...)
allSpolysInNextDegree( (GroebnerStrategy)arg1) -> BoolePolynomialVector :
 
    C++ signature :
        std::vector<polybori::BoolePolynomial, std::allocator<polybori::BoolePolynomial> > allSpolysInNextDegree(polybori::groebner::GroebnerStrategy {lvalue})
canRewrite(...)
canRewrite( (GroebnerStrategy)arg1, (Polynomial)arg2) -> bool :
 
    C++ signature :
        bool canRewrite(polybori::groebner::GroebnerStrategy {lvalue},polybori::BoolePolynomial)
cleanTopByChainCriterion(...)
cleanTopByChainCriterion( (GroebnerStrategy)arg1) -> None :
 
    C++ signature :
        void cleanTopByChainCriterion(polybori::groebner::GroebnerStrategy {lvalue})
containsOne(...)
containsOne( (GroebnerStrategy)arg1) -> bool :
 
    C++ signature :
        bool containsOne(polybori::groebner::GroebnerStrategy)
faugereStepDense(...)
faugereStepDense( (GroebnerStrategy)arg1, (BoolePolynomialVector)arg2) -> BoolePolynomialVector :
 
    C++ signature :
        std::vector<polybori::BoolePolynomial, std::allocator<polybori::BoolePolynomial> > faugereStepDense(polybori::groebner::GroebnerStrategy {lvalue},std::vector<polybori::BoolePolynomial, std::allocator<polybori::BoolePolynomial> >)
implications(...)
implications( (GroebnerStrategy)arg1, (int)arg2) -> None :
 
    C++ signature :
        void implications(polybori::groebner::GroebnerStrategy {lvalue},int)
llReduceAll(...)
llReduceAll( (GroebnerStrategy)arg1) -> None :
 
    C++ signature :
        void llReduceAll(polybori::groebner::GroebnerStrategy {lvalue})
minimalize(...)
minimalize( (GroebnerStrategy)arg1) -> BoolePolynomialVector :
 
    C++ signature :
        std::vector<polybori::BoolePolynomial, std::allocator<polybori::BoolePolynomial> > minimalize(polybori::groebner::GroebnerStrategy {lvalue})
minimalizeAndTailReduce(...)
minimalizeAndTailReduce( (GroebnerStrategy)arg1) -> BoolePolynomialVector :
 
    C++ signature :
        std::vector<polybori::BoolePolynomial, std::allocator<polybori::BoolePolynomial> > minimalizeAndTailReduce(polybori::groebner::GroebnerStrategy {lvalue})
nextSpoly(...)
nextSpoly( (GroebnerStrategy)arg1) -> Polynomial :
 
    C++ signature :
        polybori::BoolePolynomial nextSpoly(polybori::groebner::GroebnerStrategy {lvalue})
nf(...)
nf( (GroebnerStrategy)arg1, (Polynomial)arg2) -> Polynomial :
 
    C++ signature :
        polybori::BoolePolynomial nf(polybori::groebner::GroebnerStrategy {lvalue},polybori::BoolePolynomial)
noroStep(...)
noroStep( (GroebnerStrategy)arg1, (BoolePolynomialVector)arg2) -> BoolePolynomialVector :
 
    C++ signature :
        std::vector<polybori::BoolePolynomial, std::allocator<polybori::BoolePolynomial> > noroStep(polybori::groebner::GroebnerStrategy {lvalue},std::vector<polybori::BoolePolynomial, std::allocator<polybori::BoolePolynomial> >)
npairs(...)
npairs( (GroebnerStrategy)arg1) -> int :
 
    C++ signature :
        int npairs(polybori::groebner::GroebnerStrategy)
redTail(...)
redTail( (GroebnerStrategy)arg1, (Polynomial)arg2) -> Polynomial :
 
    C++ signature :
        polybori::BoolePolynomial redTail(polybori::groebner::GroebnerStrategy {lvalue},polybori::BoolePolynomial)
select(...)
select( (GroebnerStrategy)arg1, (Monomial)arg2) -> int :
 
    C++ signature :
        int select(polybori::groebner::GroebnerStrategy,polybori::BooleMonomial)
smallSpolysInNextDegree(...)
smallSpolysInNextDegree( (GroebnerStrategy)arg1, (float)arg2, (int)arg3) -> BoolePolynomialVector :
 
    C++ signature :
        std::vector<polybori::BoolePolynomial, std::allocator<polybori::BoolePolynomial> > smallSpolysInNextDegree(polybori::groebner::GroebnerStrategy {lvalue},double,int)
someSpolysInNextDegree(...)
someSpolysInNextDegree( (GroebnerStrategy)arg1, (int)arg2) -> BoolePolynomialVector :
 
    C++ signature :
        std::vector<polybori::BoolePolynomial, std::allocator<polybori::BoolePolynomial> > someSpolysInNextDegree(polybori::groebner::GroebnerStrategy {lvalue},int)
suggestPluginVariable(...)
suggestPluginVariable( (GroebnerStrategy)arg1) -> int :
 
    C++ signature :
        int suggestPluginVariable(polybori::groebner::GroebnerStrategy {lvalue})
symmGB_F2(...)
symmGB_F2( (GroebnerStrategy)arg1) -> None :
 
    C++ signature :
        void symmGB_F2(polybori::groebner::GroebnerStrategy {lvalue})
toStdOut(...)
toStdOut( (GroebnerStrategy)arg1) -> None :
 
    C++ signature :
        void toStdOut(polybori::groebner::GroebnerStrategy {lvalue})
topSugar(...)
topSugar( (GroebnerStrategy)arg1) -> int :
 
    C++ signature :
        int topSugar(polybori::groebner::GroebnerStrategy)
variableHasValue(...)
variableHasValue( (GroebnerStrategy)arg1, (int)arg2) -> bool :
 
    C++ signature :
        bool variableHasValue(polybori::groebner::GroebnerStrategy {lvalue},int)

Data descriptors defined here:
chainCriterions
easyProductCriterions
enabledLog
extendedProductCriterions
leadingTerms
llReductor
minimalLeadingTerms
monomials
optAllowRecursion
optBrutalReductions
optExchange
optLL
optLazy
optLinearAlgebraInLastBlock
optRedByReduced
optRedTail
optRedTailDegGrowth
variableChainCriterions

Data and other attributes defined here:
__instance_size__ = 408

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

Data and other attributes inherited from Boost.Python.instance:
__new__ = <built-in method __new__ of Boost.Python.class object>
T.__new__(S, ...) -> a new object with type S, a subtype of T

 
class IntVector(Boost.Python.instance)
    
Method resolution order:
IntVector
Boost.Python.instance
__builtin__.object

Methods defined here:
__contains__(...)
__contains__( (IntVector)arg1, (object)arg2) -> bool :
 
    C++ signature :
        bool __contains__(std::vector<int, std::allocator<int> > {lvalue},_object*)
__delitem__(...)
__delitem__( (IntVector)arg1, (object)arg2) -> None :
 
    C++ signature :
        void __delitem__(std::vector<int, std::allocator<int> > {lvalue},_object*)
__eq__(...)
__eq__( (IntVector)arg1, (IntVector)arg2) -> object :
 
    C++ signature :
        _object* __eq__(std::vector<int, std::allocator<int> > {lvalue},std::vector<int, std::allocator<int> >)
__getitem__(...)
__getitem__( (object)arg1, (object)arg2) -> object :
 
    C++ signature :
        boost::python::api::object __getitem__(boost::python::back_reference<std::vector<int, std::allocator<int> >&>,_object*)
__init__ = init(self, iteratable=None)
__iter__(...)
__iter__( (object)arg1) -> object :
 
    C++ signature :
        boost::python::objects::iterator_range<boost::python::return_value_policy<boost::python::return_by_value, boost::python::default_call_policies>, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > > __iter__(boost::python::back_reference<std::vector<int, std::allocator<int> >&>)
__len__(...)
__len__( (IntVector)arg1) -> int :
 
    C++ signature :
        unsigned long __len__(std::vector<int, std::allocator<int> > {lvalue})
__reduce__ = (...)
__setitem__(...)
__setitem__( (IntVector)arg1, (object)arg2, (object)arg3) -> None :
 
    C++ signature :
        void __setitem__(std::vector<int, std::allocator<int> > {lvalue},_object*,_object*)
append(...)
append( (IntVector)arg1, (object)arg2) -> None :
 
    C++ signature :
        void append(std::vector<int, std::allocator<int> > {lvalue},boost::python::api::object)
extend(...)
extend( (IntVector)arg1, (object)arg2) -> None :
 
    C++ signature :
        void extend(std::vector<int, std::allocator<int> > {lvalue},boost::python::api::object)

Data and other attributes defined here:
__instance_size__ = 40

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

Data and other attributes inherited from Boost.Python.instance:
__new__ = <built-in method __new__ of Boost.Python.class object>
T.__new__(S, ...) -> a new object with type S, a subtype of T

 
class Monomial(Boost.Python.instance)
    Boolean monomial
 
 
Method resolution order:
Monomial
Boost.Python.instance
__builtin__.object

Methods defined here:
__add__(...)
__add__( (Monomial)arg1, (Monomial)arg2) -> object :
 
    C++ signature :
        _object* __add__(polybori::BooleMonomial {lvalue},polybori::BooleMonomial)
 
__add__( (Monomial)arg1, (int)arg2) -> object :
 
    C++ signature :
        _object* __add__(polybori::BooleMonomial {lvalue},int)
 
__add__( (Monomial)arg1, (Variable)arg2) -> object :
 
    C++ signature :
        _object* __add__(polybori::BooleMonomial {lvalue},polybori::BooleVariable)
__div__ = monomial_python_div(self, arg)
__eq__(...)
__eq__( (Monomial)arg1, (int)arg2) -> object :
 
    C++ signature :
        _object* __eq__(polybori::BooleMonomial {lvalue},int)
 
__eq__( (Monomial)arg1, (Monomial)arg2) -> object :
 
    C++ signature :
        _object* __eq__(polybori::BooleMonomial {lvalue},polybori::BooleMonomial)
 
__eq__( (Monomial)arg1, (bool)arg2) -> object :
 
    C++ signature :
        _object* __eq__(polybori::BooleMonomial {lvalue},bool)
__ge__(...)
__ge__( (Monomial)arg1, (Monomial)arg2) -> object :
 
    C++ signature :
        _object* __ge__(polybori::BooleMonomial {lvalue},polybori::BooleMonomial)
__gt__(...)
__gt__( (Monomial)arg1, (Monomial)arg2) -> object :
 
    C++ signature :
        _object* __gt__(polybori::BooleMonomial {lvalue},polybori::BooleMonomial)
__hash__(...)
__hash__( (Monomial)arg1) -> int :
    Fast hash code, based on the pointer to the underlying ZDD node. 
    It may vary from runtime to runtime.
 
    C++ signature :
        unsigned long __hash__(polybori::BooleMonomial {lvalue})
__idiv__(...)
__idiv__( (object)arg1, (Monomial)arg2) -> object :
 
    C++ signature :
        _object* __idiv__(boost::python::back_reference<polybori::BooleMonomial&>,polybori::BooleMonomial)
__imul__(...)
__imul__( (object)arg1, (Monomial)arg2) -> object :
 
    C++ signature :
        _object* __imul__(boost::python::back_reference<polybori::BooleMonomial&>,polybori::BooleMonomial)
__init__ = monomial_new_init(self, arg=None)
__le__(...)
__le__( (Monomial)arg1, (Monomial)arg2) -> object :
 
    C++ signature :
        _object* __le__(polybori::BooleMonomial {lvalue},polybori::BooleMonomial)
__len__(...)
__len__( (Monomial)arg1) -> int :
    Equivalent to deg
 
    C++ signature :
        unsigned int __len__(polybori::BooleMonomial {lvalue})
__lt__(...)
__lt__( (Monomial)arg1, (Monomial)arg2) -> object :
 
    C++ signature :
        _object* __lt__(polybori::BooleMonomial {lvalue},polybori::BooleMonomial)
__mul__(...)
__mul__( (Monomial)arg1, (int)arg2) -> object :
 
    C++ signature :
        _object* __mul__(polybori::BooleMonomial {lvalue},int)
 
__mul__( (Monomial)arg1, (Monomial)arg2) -> object :
 
    C++ signature :
        _object* __mul__(polybori::BooleMonomial {lvalue},polybori::BooleMonomial)
 
__mul__( (Monomial)arg1, (int)arg2) -> object :
 
    C++ signature :
        _object* __mul__(polybori::BooleMonomial {lvalue},int)
__ne__(...)
__ne__( (Monomial)arg1, (int)arg2) -> object :
 
    C++ signature :
        _object* __ne__(polybori::BooleMonomial {lvalue},int)
 
__ne__( (Monomial)arg1, (Monomial)arg2) -> object :
 
    C++ signature :
        _object* __ne__(polybori::BooleMonomial {lvalue},polybori::BooleMonomial)
 
__ne__( (Monomial)arg1, (bool)arg2) -> object :
 
    C++ signature :
        _object* __ne__(polybori::BooleMonomial {lvalue},bool)
__pow__(...)
__pow__( (Monomial)arg1, (int)arg2) -> Monomial :
 
    C++ signature :
        polybori::BooleMonomial __pow__(polybori::BooleMonomial,int)
__radd__(...)
__radd__( (Monomial)arg1, (int)arg2) -> object :
 
    C++ signature :
        _object* __radd__(polybori::BooleMonomial {lvalue},int)
 
__radd__( (Monomial)arg1, (Variable)arg2) -> object :
 
    C++ signature :
        _object* __radd__(polybori::BooleMonomial {lvalue},polybori::BooleVariable)
__reduce__ = (...)
__repr__(...)
__repr__( (Monomial)arg1) -> str :
 
    C++ signature :
        boost::python::str __repr__(polybori::BooleMonomial)
__rmul__(...)
__rmul__( (Monomial)arg1, (int)arg2) -> object :
 
    C++ signature :
        _object* __rmul__(polybori::BooleMonomial {lvalue},int)
 
__rmul__( (Monomial)arg1, (int)arg2) -> object :
 
    C++ signature :
        _object* __rmul__(polybori::BooleMonomial {lvalue},int)
__rsub__(...)
__rsub__( (Monomial)arg1, (int)arg2) -> object :
 
    C++ signature :
        _object* __rsub__(polybori::BooleMonomial {lvalue},int)
 
__rsub__( (Monomial)arg1, (Variable)arg2) -> object :
 
    C++ signature :
        _object* __rsub__(polybori::BooleMonomial {lvalue},polybori::BooleVariable)
__str__(...)
__str__( (Monomial)arg1) -> str :
 
    C++ signature :
        boost::python::str __str__(polybori::BooleMonomial)
__sub__(...)
__sub__( (Monomial)arg1, (Variable)arg2) -> object :
 
    C++ signature :
        _object* __sub__(polybori::BooleMonomial {lvalue},polybori::BooleVariable)
deg(...)
deg( (Monomial)arg1) -> int :
    Degree of the monomial
 
    C++ signature :
        unsigned int deg(polybori::BooleMonomial {lvalue})
divisors(...)
divisors( (Monomial)arg1) -> BooleSet :
    Return Boolean set consisting of all divisors of the monomial
 
    C++ signature :
        polybori::BooleSet divisors(polybori::BooleMonomial {lvalue})
multiples(...)
multiples( (Monomial)arg1, (Monomial)arg2) -> BooleSet :
    Return Boolean set consisting of all multiples of the monomial
 
    C++ signature :
        polybori::BooleSet multiples(polybori::BooleMonomial {lvalue},polybori::BooleMonomial)
reducibleBy(...)
reducibleBy( (Monomial)arg1, (Monomial)arg2) -> bool :
    Test for reducibility
 
    C++ signature :
        bool reducibleBy(polybori::BooleMonomial {lvalue},polybori::BooleMonomial)
ring(...)
ring( (Monomial)arg1) -> BooleRing :
    Get corresponding ring
 
    C++ signature :
        polybori::BooleRing ring(polybori::BooleMonomial {lvalue})
set(...)
set( (Monomial)arg1) -> BooleSet :
    Convert to BooleSet
 
    C++ signature :
        polybori::BooleSet set(polybori::BooleMonomial {lvalue})
stableHash(...)
stableHash( (Monomial)arg1) -> int :
    Reproducible hash code
 
    C++ signature :
        unsigned long stableHash(polybori::BooleMonomial {lvalue})
variables(...)
variables( (object)arg1) -> object :
 
    C++ signature :
        boost::python::objects::iterator_range<boost::python::return_value_policy<boost::python::return_by_value, boost::python::default_call_policies>, polybori::CVariableIter<polybori::CCuddFirstIter, polybori::BooleVariable> > variables(boost::python::back_reference<polybori::BooleMonomial&>)
varsAsMonomial(...)
varsAsMonomial( (Monomial)arg1) -> Monomial :
    Variables occurring in Polynomial
 
    C++ signature :
        polybori::BooleMonomial varsAsMonomial(polybori::BooleMonomial)

Data and other attributes defined here:
__instance_size__ = 32

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

Data and other attributes inherited from Boost.Python.instance:
__new__ = <built-in method __new__ of Boost.Python.class object>
T.__new__(S, ...) -> a new object with type S, a subtype of T

 
class OrderCode(Boost.Python.enum)
    
Method resolution order:
OrderCode
Boost.Python.enum
__builtin__.int
__builtin__.object

Data and other attributes defined here:
block_dlex = polybori.dynamic.PyPolyBoRi.OrderCode.block_dlex
block_dp_asc = polybori.dynamic.PyPolyBoRi.OrderCode.block_dp_asc
dlex = polybori.dynamic.PyPolyBoRi.OrderCode.dlex
dp_asc = polybori.dynamic.PyPolyBoRi.OrderCode.dp_asc
lp = polybori.dynamic.PyPolyBoRi.OrderCode.lp
names = {'block_dlex': polybori.dynamic.PyPolyBoRi.OrderCode.block_dlex, 'block_dp_asc': polybori.dynamic.PyPolyBoRi.OrderCode.block_dp_asc, 'dlex': polybori.dynamic.PyPolyBoRi.OrderCode.dlex, 'dp_asc': polybori.dynamic.PyPolyBoRi.OrderCode.dp_asc, 'lp': polybori.dynamic.PyPolyBoRi.OrderCode.lp}
values = {0: polybori.dynamic.PyPolyBoRi.OrderCode.lp, 1: polybori.dynamic.PyPolyBoRi.OrderCode.dlex, 2: polybori.dynamic.PyPolyBoRi.OrderCode.dp_asc, 3: polybori.dynamic.PyPolyBoRi.OrderCode.block_dlex, 4: polybori.dynamic.PyPolyBoRi.OrderCode.block_dp_asc}

Methods inherited from Boost.Python.enum:
__repr__(...)
x.__repr__() <==> repr(x)
__str__(...)
x.__str__() <==> str(x)

Data descriptors inherited from Boost.Python.enum:
name

Methods inherited from __builtin__.int:
__abs__(...)
x.__abs__() <==> abs(x)
__add__(...)
x.__add__(y) <==> x+y
__and__(...)
x.__and__(y) <==> x&y
__cmp__(...)
x.__cmp__(y) <==> cmp(x,y)
__coerce__(...)
x.__coerce__(y) <==> coerce(x, y)
__div__(...)
x.__div__(y) <==> x/y
__divmod__(...)
x.__divmod__(y) <==> divmod(x, y)
__float__(...)
x.__float__() <==> float(x)
__floordiv__(...)
x.__floordiv__(y) <==> x//y
__format__(...)
__getattribute__(...)
x.__getattribute__('name') <==> x.name
__getnewargs__(...)
__hash__(...)
x.__hash__() <==> hash(x)
__hex__(...)
x.__hex__() <==> hex(x)
__index__(...)
x[y:z] <==> x[y.__index__():z.__index__()]
__int__(...)
x.__int__() <==> int(x)
__invert__(...)
x.__invert__() <==> ~x
__long__(...)
x.__long__() <==> long(x)
__lshift__(...)
x.__lshift__(y) <==> x<<y
__mod__(...)
x.__mod__(y) <==> x%y
__mul__(...)
x.__mul__(y) <==> x*y
__neg__(...)
x.__neg__() <==> -x
__nonzero__(...)
x.__nonzero__() <==> x != 0
__oct__(...)
x.__oct__() <==> oct(x)
__or__(...)
x.__or__(y) <==> x|y
__pos__(...)
x.__pos__() <==> +x
__pow__(...)
x.__pow__(y[, z]) <==> pow(x, y[, z])
__radd__(...)
x.__radd__(y) <==> y+x
__rand__(...)
x.__rand__(y) <==> y&x
__rdiv__(...)
x.__rdiv__(y) <==> y/x
__rdivmod__(...)
x.__rdivmod__(y) <==> divmod(y, x)
__rfloordiv__(...)
x.__rfloordiv__(y) <==> y//x
__rlshift__(...)
x.__rlshift__(y) <==> y<<x
__rmod__(...)
x.__rmod__(y) <==> y%x
__rmul__(...)
x.__rmul__(y) <==> y*x
__ror__(...)
x.__ror__(y) <==> y|x
__rpow__(...)
y.__rpow__(x[, z]) <==> pow(x, y[, z])
__rrshift__(...)
x.__rrshift__(y) <==> y>>x
__rshift__(...)
x.__rshift__(y) <==> x>>y
__rsub__(...)
x.__rsub__(y) <==> y-x
__rtruediv__(...)
x.__rtruediv__(y) <==> y/x
__rxor__(...)
x.__rxor__(y) <==> y^x
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__trunc__(...)
Truncating an Integral returns itself.
__xor__(...)
x.__xor__(y) <==> x^y
bit_length(...)
int.bit_length() -> int
 
Number of bits necessary to represent self in binary.
>>> bin(37)
'0b100101'
>>> (37).bit_length()
6
conjugate(...)
Returns self, the complex conjugate of any int.

Data descriptors inherited from __builtin__.int:
denominator
the denominator of a rational number in lowest terms
imag
the imaginary part of a complex number
numerator
the numerator of a rational number in lowest terms
real
the real part of a complex number

Data and other attributes inherited from __builtin__.int:
__new__ = <built-in method __new__ of type object>
T.__new__(S, ...) -> a new object with type S, a subtype of T

 
class Polynomial(Boost.Python.instance)
    Construct a BoolePolynomial object   in the given Boolean polynomial ring.
 
 
Method resolution order:
Polynomial
Boost.Python.instance
__builtin__.object

Methods defined here:
__add__(...)
__add__( (Polynomial)arg1, (Variable)arg2) -> object :
 
    C++ signature :
        _object* __add__(polybori::BoolePolynomial {lvalue},polybori::BooleVariable)
 
__add__( (Polynomial)arg1, (Monomial)arg2) -> object :
 
    C++ signature :
        _object* __add__(polybori::BoolePolynomial {lvalue},polybori::BooleMonomial)
 
__add__( (Polynomial)arg1, (int)arg2) -> object :
 
    C++ signature :
        _object* __add__(polybori::BoolePolynomial {lvalue},int)
 
__add__( (Polynomial)arg1, (Variable)arg2) -> object :
 
    C++ signature :
        _object* __add__(polybori::BoolePolynomial {lvalue},polybori::BooleVariable)
 
__add__( (Polynomial)arg1, (Polynomial)arg2) -> object :
 
    C++ signature :
        _object* __add__(polybori::BoolePolynomial {lvalue},polybori::BoolePolynomial)
__div__(...)
__div__( (Polynomial)arg1, (int)arg2) -> object :
 
    C++ signature :
        _object* __div__(polybori::BoolePolynomial {lvalue},int)
 
__div__( (Polynomial)arg1, (Monomial)arg2) -> object :
 
    C++ signature :
        _object* __div__(polybori::BoolePolynomial {lvalue},polybori::BooleMonomial)
 
__div__( (Polynomial)arg1, (Polynomial)arg2) -> object :
 
    C++ signature :
        _object* __div__(polybori::BoolePolynomial {lvalue},polybori::BoolePolynomial)
__eq__(...)
__eq__( (Polynomial)arg1, (Polynomial)arg2) -> object :
 
    C++ signature :
        _object* __eq__(polybori::BoolePolynomial {lvalue},polybori::BoolePolynomial)
 
__eq__( (Polynomial)arg1, (int)arg2) -> object :
 
    C++ signature :
        _object* __eq__(polybori::BoolePolynomial {lvalue},int)
 
__eq__( (Polynomial)arg1, (bool)arg2) -> object :
 
    C++ signature :
        _object* __eq__(polybori::BoolePolynomial {lvalue},bool)
__hash__(...)
__hash__( (Polynomial)arg1) -> int :
    Fast hash code, based on the pointer to the underlying ZDD node. 
    It may vary from runtime to runtime.
 
    C++ signature :
        unsigned long __hash__(polybori::BoolePolynomial {lvalue})
__iadd__(...)
__iadd__( (object)arg1, (Polynomial)arg2) -> object :
 
    C++ signature :
        _object* __iadd__(boost::python::back_reference<polybori::BoolePolynomial&>,polybori::BoolePolynomial)
 
__iadd__( (object)arg1, (Variable)arg2) -> object :
 
    C++ signature :
        _object* __iadd__(boost::python::back_reference<polybori::BoolePolynomial&>,polybori::BooleVariable)
 
__iadd__( (object)arg1, (Monomial)arg2) -> object :
 
    C++ signature :
        _object* __iadd__(boost::python::back_reference<polybori::BoolePolynomial&>,polybori::BooleMonomial)
 
__iadd__( (object)arg1, (int)arg2) -> object :
 
    C++ signature :
        _object* __iadd__(boost::python::back_reference<polybori::BoolePolynomial&>,int)
__imul__(...)
__imul__( (object)arg1, (Polynomial)arg2) -> object :
 
    C++ signature :
        _object* __imul__(boost::python::back_reference<polybori::BoolePolynomial&>,polybori::BoolePolynomial)
 
__imul__( (object)arg1, (Monomial)arg2) -> object :
 
    C++ signature :
        _object* __imul__(boost::python::back_reference<polybori::BoolePolynomial&>,polybori::BooleMonomial)
 
__imul__( (object)arg1, (Monomial)arg2) -> object :
 
    C++ signature :
        _object* __imul__(boost::python::back_reference<polybori::BoolePolynomial&>,polybori::BooleMonomial)
 
__imul__( (object)arg1, (Variable)arg2) -> object :
 
    C++ signature :
        _object* __imul__(boost::python::back_reference<polybori::BoolePolynomial&>,polybori::BooleVariable)
__init__(...)
__init__( (object)arg1) -> None :
 
    C++ signature :
        void __init__(_object*)
 
__init__( (object)arg1) -> None :
 
    C++ signature :
        void __init__(_object*)
 
__init__( (object)arg1, (Polynomial)arg2) -> None :
 
    C++ signature :
        void __init__(_object*,polybori::BoolePolynomial)
 
__init__( (object)arg1, (CCuddNavigator)arg2, (BooleRing)arg3) -> None :
 
    C++ signature :
        void __init__(_object*,polybori::CCuddNavigator,polybori::BooleRing)
 
__init__( (object)arg1, (int)arg2, (BooleRing)arg3) -> None :
 
    C++ signature :
        void __init__(_object*,int,polybori::BooleRing)
 
__init__( (object)arg1, (object)arg2) -> None :
 
    C++ signature :
        void __init__(_object*,polybori::CDDInterface<polybori::CCuddZDD>)
 
__init__( (object)arg1, (Variable)arg2) -> None :
 
    C++ signature :
        void __init__(_object*,polybori::BooleVariable)
 
__init__( (object)arg1, (Monomial)arg2) -> None :
 
    C++ signature :
        void __init__(_object*,polybori::BooleMonomial)
 
__init__( (object)arg1, (bool)arg2) -> None :
 
    C++ signature :
        void __init__(_object*,bool)
 
__init__( (object)arg1, (int)arg2) -> None :
 
    C++ signature :
        void __init__(_object*,int)
__isub__(...)
__isub__( (object)arg1, (Polynomial)arg2) -> object :
 
    C++ signature :
        _object* __isub__(boost::python::back_reference<polybori::BoolePolynomial&>,polybori::BoolePolynomial)
 
__isub__( (object)arg1, (Variable)arg2) -> object :
 
    C++ signature :
        _object* __isub__(boost::python::back_reference<polybori::BoolePolynomial&>,polybori::BooleVariable)
 
__isub__( (object)arg1, (Monomial)arg2) -> object :
 
    C++ signature :
        _object* __isub__(boost::python::back_reference<polybori::BoolePolynomial&>,polybori::BooleMonomial)
 
__isub__( (object)arg1, (int)arg2) -> object :
 
    C++ signature :
        _object* __isub__(boost::python::back_reference<polybori::BoolePolynomial&>,int)
__len__(...)
__len__( (Polynomial)arg1) -> int :
    Number of terms
 
    C++ signature :
        unsigned int __len__(polybori::BoolePolynomial {lvalue})
__mod__(...)
__mod__( (Polynomial)arg1, (Variable)arg2) -> object :
 
    C++ signature :
        _object* __mod__(polybori::BoolePolynomial {lvalue},polybori::BooleVariable)
 
__mod__( (Polynomial)arg1, (Monomial)arg2) -> object :
 
    C++ signature :
        _object* __mod__(polybori::BoolePolynomial {lvalue},polybori::BooleMonomial)
 
__mod__( (Polynomial)arg1, (Polynomial)arg2) -> object :
 
    C++ signature :
        _object* __mod__(polybori::BoolePolynomial {lvalue},polybori::BoolePolynomial)
__mul__(...)
__mul__( (Polynomial)arg1, (Monomial)arg2) -> object :
 
    C++ signature :
        _object* __mul__(polybori::BoolePolynomial {lvalue},polybori::BooleMonomial)
 
__mul__( (Polynomial)arg1, (Polynomial)arg2) -> object :
 
    C++ signature :
        _object* __mul__(polybori::BoolePolynomial {lvalue},polybori::BoolePolynomial)
 
__mul__( (Polynomial)arg1, (Variable)arg2) -> object :
 
    C++ signature :
        _object* __mul__(polybori::BoolePolynomial {lvalue},polybori::BooleVariable)
__ne__(...)
__ne__( (Polynomial)arg1, (int)arg2) -> object :
 
    C++ signature :
        _object* __ne__(polybori::BoolePolynomial {lvalue},int)
 
__ne__( (Polynomial)arg1, (Polynomial)arg2) -> object :
 
    C++ signature :
        _object* __ne__(polybori::BoolePolynomial {lvalue},polybori::BoolePolynomial)
 
__ne__( (Polynomial)arg1, (bool)arg2) -> object :
 
    C++ signature :
        _object* __ne__(polybori::BoolePolynomial {lvalue},bool)
__pow__(...)
__pow__( (Polynomial)arg1, (int)arg2) -> Polynomial :
 
    C++ signature :
        polybori::BoolePolynomial __pow__(polybori::BoolePolynomial,int)
__radd__(...)
__radd__( (Polynomial)arg1, (Variable)arg2) -> object :
 
    C++ signature :
        _object* __radd__(polybori::BoolePolynomial {lvalue},polybori::BooleVariable)
 
__radd__( (Polynomial)arg1, (Monomial)arg2) -> object :
 
    C++ signature :
        _object* __radd__(polybori::BoolePolynomial {lvalue},polybori::BooleMonomial)
 
__radd__( (Polynomial)arg1, (int)arg2) -> object :
 
    C++ signature :
        _object* __radd__(polybori::BoolePolynomial {lvalue},int)
__reduce__ = (...)
__repr__(...)
__repr__( (Polynomial)arg1) -> str :
 
    C++ signature :
        boost::python::str __repr__(polybori::BoolePolynomial)
__rmul__(...)
__rmul__( (Polynomial)arg1, (Monomial)arg2) -> object :
 
    C++ signature :
        _object* __rmul__(polybori::BoolePolynomial {lvalue},polybori::BooleMonomial)
__rsub__(...)
__rsub__( (Polynomial)arg1, (Variable)arg2) -> object :
 
    C++ signature :
        _object* __rsub__(polybori::BoolePolynomial {lvalue},polybori::BooleVariable)
 
__rsub__( (Polynomial)arg1, (Monomial)arg2) -> object :
 
    C++ signature :
        _object* __rsub__(polybori::BoolePolynomial {lvalue},polybori::BooleMonomial)
 
__rsub__( (Polynomial)arg1, (int)arg2) -> object :
 
    C++ signature :
        _object* __rsub__(polybori::BoolePolynomial {lvalue},int)
__str__(...)
__str__( (Polynomial)arg1) -> str :
 
    C++ signature :
        boost::python::str __str__(polybori::BoolePolynomial)
__sub__(...)
__sub__( (Polynomial)arg1, (Variable)arg2) -> object :
 
    C++ signature :
        _object* __sub__(polybori::BoolePolynomial {lvalue},polybori::BooleVariable)
 
__sub__( (Polynomial)arg1, (Monomial)arg2) -> object :
 
    C++ signature :
        _object* __sub__(polybori::BoolePolynomial {lvalue},polybori::BooleMonomial)
 
__sub__( (Polynomial)arg1, (int)arg2) -> object :
 
    C++ signature :
        _object* __sub__(polybori::BoolePolynomial {lvalue},int)
 
__sub__( (Polynomial)arg1, (Variable)arg2) -> object :
 
    C++ signature :
        _object* __sub__(polybori::BoolePolynomial {lvalue},polybori::BooleVariable)
 
__sub__( (Polynomial)arg1, (Polynomial)arg2) -> object :
 
    C++ signature :
        _object* __sub__(polybori::BoolePolynomial {lvalue},polybori::BoolePolynomial)
constant(...)
constant( (Polynomial)arg1) -> bool :
    Test, whether Polynomial os constant
 
    C++ signature :
        bool constant(polybori::BoolePolynomial {lvalue})
deg(...)
deg( (Polynomial)arg1) -> int :
    Polynomial degree
 
    C++ signature :
        unsigned int deg(polybori::BoolePolynomial {lvalue})
elength(...)
elength( (Polynomial)arg1) -> int :
    Elimination length
 
    C++ signature :
        unsigned int elength(polybori::BoolePolynomial {lvalue})
firstTerm(...)
firstTerm( (Polynomial)arg1) -> Monomial :
    First lexicographical term
 
    C++ signature :
        polybori::BooleMonomial firstTerm(polybori::BoolePolynomial {lvalue})
gradedPart(...)
gradedPart( (Polynomial)arg1, (int)arg2) -> Polynomial :
    Get part of given degree
 
    C++ signature :
        polybori::BoolePolynomial gradedPart(polybori::BoolePolynomial {lvalue},unsigned int)
hasConstantPart(...)
hasConstantPart( (Polynomial)arg1) -> bool :
    Check, whether Polynomials owns constant term
 
    C++ signature :
        bool hasConstantPart(polybori::BoolePolynomial {lvalue})
isOne(...)
isOne( (Polynomial)arg1) -> bool :
    Test if Polynomial one
 
    C++ signature :
        bool isOne(polybori::BoolePolynomial {lvalue})
isZero(...)
isZero( (Polynomial)arg1) -> bool :
    Test if Polynomial is zero
 
    C++ signature :
        bool isZero(polybori::BoolePolynomial {lvalue})
lead(...)
lead( (Polynomial)arg1) -> Monomial :
    Leading term with respect to current ordering
 
    C++ signature :
        polybori::BooleMonomial lead(polybori::BoolePolynomial {lvalue})
lexLead(...)
lexLead( (Polynomial)arg1) -> Monomial :
    Lexicographical leading term
 
    C++ signature :
        polybori::BooleMonomial lexLead(polybori::BoolePolynomial {lvalue})
lexLmDeg(...)
lexLmDeg( (Polynomial)arg1) -> int :
    Degree of the lexicographical leading term
 
    C++ signature :
        unsigned int lexLmDeg(polybori::BoolePolynomial {lvalue})
lmDeg(...)
lmDeg( (Polynomial)arg1) -> int :
    Degree of the leading term
 
    C++ signature :
        unsigned int lmDeg(polybori::BoolePolynomial {lvalue})
lmDivisors(...)
lmDivisors( (Polynomial)arg1) -> BooleSet :
    Divisors of leading term
 
    C++ signature :
        polybori::BooleSet lmDivisors(polybori::BoolePolynomial {lvalue})
mapEveryXToXPlusOne(...)
mapEveryXToXPlusOne( (Polynomial)arg1) -> Polynomial :
    Replace every variable x by x + 1
 
    C++ signature :
        polybori::BoolePolynomial mapEveryXToXPlusOne(polybori::BoolePolynomial)
nNodes(...)
nNodes( (Polynomial)arg1) -> int :
    Number of diagram nodes in the underlying ZDD structure
 
    C++ signature :
        unsigned int nNodes(polybori::BoolePolynomial {lvalue})
nVars(...)
nVars( (Polynomial)arg1) -> int :
    Number of variables occurring in Polynomial
 
    C++ signature :
        unsigned int nVars(polybori::BoolePolynomial {lvalue})
navigation(...)
navigation( (Polynomial)arg1) -> CCuddNavigator :
    Navigate through underlying ZDD structure
 
    C++ signature :
        polybori::CCuddNavigator navigation(polybori::BoolePolynomial {lvalue})
plot(...)
plot( (Polynomial)arg1, (str)arg2) -> None :
 
    C++ signature :
        void plot(polybori::BoolePolynomial,char const*)
reducibleBy(...)
reducibleBy( (Polynomial)arg1, (Polynomial)arg2) -> bool :
 
    C++ signature :
        bool reducibleBy(polybori::BoolePolynomial {lvalue},polybori::BoolePolynomial)
ring(...)
ring( (Polynomial)arg1) -> BooleRing :
    Get corresponding ring
 
    C++ signature :
        polybori::BooleRing ring(polybori::BoolePolynomial {lvalue})
set(...)
set( (Polynomial)arg1) -> BooleSet :
    Convert to BooleSet
 
    C++ signature :
        polybori::BooleSet set(polybori::BoolePolynomial {lvalue})
stableHash(...)
stableHash( (Polynomial)arg1) -> int :
    Reproducible hash code
 
    C++ signature :
        unsigned long stableHash(polybori::BoolePolynomial {lvalue})
terms(...)
terms( (object)arg1) -> object :
 
    C++ signature :
        boost::python::objects::iterator_range<boost::python::return_value_policy<boost::python::return_by_value, boost::python::default_call_policies>, polybori::COrderedIter<polybori::CCuddNavigator, polybori::BooleMonomial> > terms(boost::python::back_reference<polybori::BoolePolynomial&>)
toStdOut(...)
toStdOut( (Polynomial)arg1) -> None :
 
    C++ signature :
        void toStdOut(polybori::BoolePolynomial)
totalDegree(...)
totalDegree( (Polynomial)arg1) -> int :
    Total Polynomial degree
 
    C++ signature :
        unsigned int totalDegree(polybori::BoolePolynomial {lvalue})
varsAsMonomial(...)
varsAsMonomial( (Polynomial)arg1) -> Monomial :
    Variables occurring in Polynomial
 
    C++ signature :
        polybori::BooleMonomial varsAsMonomial(polybori::BoolePolynomial {lvalue})
zerosIn(...)
zerosIn( (Polynomial)arg1, (BooleSet)arg2) -> BooleSet :
    Get BooleSet representing the zeros of the Polynomial
 
    C++ signature :
        polybori::BooleSet zerosIn(polybori::BoolePolynomial,polybori::BooleSet)

Data and other attributes defined here:
__instance_size__ = 32

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

Data and other attributes inherited from Boost.Python.instance:
__new__ = <built-in method __new__ of Boost.Python.class object>
T.__new__(S, ...) -> a new object with type S, a subtype of T

 
class Ring(BooleRing)
    Boolean polynomial ring
 
 
Method resolution order:
Ring
BooleRing
Boost.Python.instance
__builtin__.object

Methods defined here:
__init__(...)
__init__( (object)arg1) -> None :
 
    C++ signature :
        void __init__(_object*)
 
__init__( (object)arg1, (int)arg2) -> None :
 
    C++ signature :
        void __init__(_object*,unsigned int)
 
__init__( (object)arg1, (int)arg2, (int)arg3) -> None :
    Construct a Boolean polynomial ring with the following parameters:
                n -- number of variables (integer)
                order -- term ordering (optinal), one of the following values 
                    lp: lexicographical ordering (default)
                    dlex: degree lexicographical ordering
                    dp_asc: degree reverse lexicographical ordering with inverted variable order
                    block_dp_asc: Block ordering with blocks consisting of dp_asc
                    block_dlex: Block ordering with blocks consisting of dlex
    
 
    C++ signature :
        void __init__(_object*,unsigned int,int)
__reduce__ = (...)
nVars(...)
nVars( (Ring)arg1) -> int :
    Number of ring variables
 
    C++ signature :
        unsigned int nVars(polybori::BoolePolyRing {lvalue})
one(...)
one( (Ring)arg1) -> Polynomial :
    Polynomial one
 
    C++ signature :
        polybori::BoolePolynomial one(polybori::BoolePolyRing)
set(...)
set( (Ring)arg1) -> None :
    Activate current Ring
 
    C++ signature :
        void set(polybori::BoolePolyRing {lvalue})
var(...)
var( (Ring)arg1, (int)arg2) -> Polynomial :
    i-th ring Variable
 
    C++ signature :
        polybori::BoolePolynomial var(polybori::BoolePolyRing,int)
zero(...)
zero( (Ring)arg1) -> Polynomial :
    Polynomial zero
 
    C++ signature :
        polybori::BoolePolynomial zero(polybori::BoolePolyRing)

Data and other attributes defined here:
__instance_size__ = 40

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

Data and other attributes inherited from Boost.Python.instance:
__new__ = <built-in method __new__ of Boost.Python.class object>
T.__new__(S, ...) -> a new object with type S, a subtype of T

 
class Variable(Boost.Python.instance)
    Boolean Variable
 
 
Method resolution order:
Variable
Boost.Python.instance
__builtin__.object

Methods defined here:
__add__(...)
__add__( (Variable)arg1, (Variable)arg2) -> object :
 
    C++ signature :
        _object* __add__(polybori::BooleVariable {lvalue},polybori::BooleVariable)
 
__add__( (Variable)arg1, (int)arg2) -> object :
 
    C++ signature :
        _object* __add__(polybori::BooleVariable {lvalue},int)
__div__ = variable_python_div(self, arg)
__eq__(...)
__eq__( (Variable)arg1, (Variable)arg2) -> object :
 
    C++ signature :
        _object* __eq__(polybori::BooleVariable {lvalue},polybori::BooleVariable)
__ge__(...)
__ge__( (Variable)arg1, (Variable)arg2) -> object :
 
    C++ signature :
        _object* __ge__(polybori::BooleVariable {lvalue},polybori::BooleVariable)
__gt__(...)
__gt__( (Variable)arg1, (Variable)arg2) -> object :
 
    C++ signature :
        _object* __gt__(polybori::BooleVariable {lvalue},polybori::BooleVariable)
__hash__(...)
__hash__( (Variable)arg1) -> int :
 
    C++ signature :
        int __hash__(polybori::BooleVariable {lvalue})
__init__(...)
__init__( (object)arg1) -> None :
 
    C++ signature :
        void __init__(_object*)
 
__init__( (object)arg1, (Variable)arg2) -> None :
 
    C++ signature :
        void __init__(_object*,polybori::BooleVariable)
 
__init__( (object)arg1, (int)arg2) -> None :
    Get Variable of given index
 
    C++ signature :
        void __init__(_object*,int)
__le__(...)
__le__( (Variable)arg1, (Variable)arg2) -> object :
 
    C++ signature :
        _object* __le__(polybori::BooleVariable {lvalue},polybori::BooleVariable)
__lt__(...)
__lt__( (Variable)arg1, (Variable)arg2) -> object :
 
    C++ signature :
        _object* __lt__(polybori::BooleVariable {lvalue},polybori::BooleVariable)
__mul__(...)
__mul__( (Variable)arg1, (Variable)arg2) -> object :
 
    C++ signature :
        _object* __mul__(polybori::BooleVariable {lvalue},polybori::BooleVariable)
 
__mul__( (Variable)arg1, (Monomial)arg2) -> object :
 
    C++ signature :
        _object* __mul__(polybori::BooleVariable {lvalue},polybori::BooleMonomial)
 
__mul__( (Variable)arg1, (int)arg2) -> object :
 
    C++ signature :
        _object* __mul__(polybori::BooleVariable {lvalue},int)
__pow__(...)
__pow__( (Variable)arg1, (int)arg2) -> Monomial :
 
    C++ signature :
        polybori::BooleMonomial __pow__(polybori::BooleVariable,int)
__radd__(...)
__radd__( (Variable)arg1, (int)arg2) -> object :
 
    C++ signature :
        _object* __radd__(polybori::BooleVariable {lvalue},int)
__reduce__ = (...)
__repr__(...)
__repr__( (Variable)arg1) -> str :
 
    C++ signature :
        boost::python::str __repr__(polybori::BooleVariable)
__rmul__(...)
__rmul__( (Variable)arg1, (Monomial)arg2) -> object :
 
    C++ signature :
        _object* __rmul__(polybori::BooleVariable {lvalue},polybori::BooleMonomial)
 
__rmul__( (Variable)arg1, (int)arg2) -> object :
 
    C++ signature :
        _object* __rmul__(polybori::BooleVariable {lvalue},int)
__str__(...)
__str__( (Variable)arg1) -> str :
 
    C++ signature :
        boost::python::str __str__(polybori::BooleVariable)
index(...)
index( (Variable)arg1) -> int :
    Variable position in the ring
 
    C++ signature :
        int index(polybori::BooleVariable {lvalue})
ring(...)
ring( (Variable)arg1) -> BooleRing :
    Get corresponding ring
 
    C++ signature :
        polybori::BooleRing ring(polybori::BooleVariable {lvalue})
set(...)
set( (Variable)arg1) -> BooleSet :
    Convert to BooleSet
 
    C++ signature :
        polybori::BooleSet set(polybori::BooleVariable {lvalue})
toStdOut(...)
toStdOut( (Variable)arg1) -> None :
 
    C++ signature :
        void toStdOut(polybori::BooleVariable)
varsAsMonomial(...)
varsAsMonomial( (Variable)arg1) -> Monomial :
    Variables occurring in Polynomial
 
    C++ signature :
        polybori::BooleMonomial varsAsMonomial(polybori::BooleVariable)

Data and other attributes defined here:
__instance_size__ = 32

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

Data and other attributes inherited from Boost.Python.instance:
__new__ = <built-in method __new__ of Boost.Python.class object>
T.__new__(S, ...) -> a new object with type S, a subtype of T

 
class VariableBlockFalse(Boost.Python.instance)
    
Method resolution order:
VariableBlockFalse
Boost.Python.instance
__builtin__.object

Methods defined here:
__call__(...)
__call__( (VariableBlockFalse)arg1, (int)arg2) -> Variable :
 
    C++ signature :
        polybori::BooleVariable __call__(VariableBlock<false> {lvalue},int)
__init__(...)
__init__( (object)arg1) -> None :
 
    C++ signature :
        void __init__(_object*)
 
__init__( (object)arg1, (VariableBlockFalse)arg2) -> None :
 
    C++ signature :
        void __init__(_object*,VariableBlock<false>)
 
__init__( (object)arg1, (int)arg2, (int)arg3, (int)arg4) -> None :
 
    C++ signature :
        void __init__(_object*,int,int,int)
__reduce__ = (...)

Data and other attributes defined here:
__instance_size__ = 32

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

Data and other attributes inherited from Boost.Python.instance:
__new__ = <built-in method __new__ of Boost.Python.class object>
T.__new__(S, ...) -> a new object with type S, a subtype of T

 
class VariableBlockTrue(Boost.Python.instance)
    
Method resolution order:
VariableBlockTrue
Boost.Python.instance
__builtin__.object

Methods defined here:
__call__(...)
__call__( (VariableBlockTrue)arg1, (int)arg2) -> Variable :
 
    C++ signature :
        polybori::BooleVariable __call__(VariableBlock<true> {lvalue},int)
__init__(...)
__init__( (object)arg1) -> None :
 
    C++ signature :
        void __init__(_object*)
 
__init__( (object)arg1, (VariableBlockTrue)arg2) -> None :
 
    C++ signature :
        void __init__(_object*,VariableBlock<true>)
 
__init__( (object)arg1, (int)arg2, (int)arg3, (int)arg4) -> None :
 
    C++ signature :
        void __init__(_object*,int,int,int)
__reduce__ = (...)

Data and other attributes defined here:
__instance_size__ = 32

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

Data and other attributes inherited from Boost.Python.instance:
__new__ = <built-in method __new__ of Boost.Python.class object>
T.__new__(S, ...) -> a new object with type S, a subtype of T

 
Functions
       
VariableBlock(...)
VariableBlock( (int)arg1, (int)arg2, (int)arg3, (bool)arg4) -> object :
 
    C++ signature :
        boost::python::api::object VariableBlock(int,int,int,bool)
add_up_polynomials(...)
add_up_polynomials( (BoolePolynomialVector)arg1) -> Polynomial :
 
    C++ signature :
        polybori::BoolePolynomial add_up_polynomials(std::vector<polybori::BoolePolynomial, std::allocator<polybori::BoolePolynomial> >)
append_ring_block(...)
append_ring_block( (int)arg1) -> None :
    Append integer, which marks start of next block (for block orderings)
 
    C++ signature :
        void append_ring_block(int)
change_ordering(...)
change_ordering( (int)arg1) -> None :
 
    C++ signature :
        void change_ordering(int)
contained_vars(...)
contained_vars( (BooleSet)arg1) -> BooleSet :
 
    C++ signature :
        polybori::BooleSet contained_vars(polybori::BooleSet)
count_double(...)
count_double( (BooleSet)arg1) -> float :
 
    C++ signature :
        double count_double(polybori::BooleSet)
get_order_code(...)
get_order_code() -> int :
 
    C++ signature :
        int get_order_code()
global_ring(...)
global_ring() -> Ring :
 
    C++ signature :
        polybori::BoolePolyRing {lvalue} global_ring()
have_degree_order(...)
have_degree_order() -> bool :
    Determines, whether ring ordering is a degree ordering
 
    C++ signature :
        bool have_degree_order()
if_then_else(...)
if_then_else( (int)arg1, (BooleSet)arg2, (BooleSet)arg3) -> BooleSet :
    if-then else operator
 
    C++ signature :
        polybori::BooleSet if_then_else(int,polybori::BooleSet,polybori::BooleSet)
 
if_then_else( (Variable)arg1, (BooleSet)arg2, (BooleSet)arg3) -> BooleSet :
    if-then else operator
 
    C++ signature :
        polybori::BooleSet if_then_else(polybori::BooleVariable,polybori::BooleSet,polybori::BooleSet)
interpolate(...)
interpolate( (BooleSet)arg1, (BooleSet)arg2) -> Polynomial :
 
    C++ signature :
        polybori::BoolePolynomial interpolate(polybori::BooleSet,polybori::BooleSet)
interpolate_smallest_lex(...)
interpolate_smallest_lex( (BooleSet)arg1, (BooleSet)arg2) -> Polynomial :
 
    C++ signature :
        polybori::BoolePolynomial interpolate_smallest_lex(polybori::BooleSet,polybori::BooleSet)
ll_red_nf(...)
ll_red_nf( (Polynomial)arg1, (BooleSet)arg2) -> Polynomial :
 
    C++ signature :
        polybori::BoolePolynomial ll_red_nf(polybori::BoolePolynomial,polybori::BooleSet)
ll_red_nf_noredsb(...)
ll_red_nf_noredsb( (Polynomial)arg1, (BooleSet)arg2) -> Polynomial :
 
    C++ signature :
        polybori::BoolePolynomial ll_red_nf_noredsb(polybori::BoolePolynomial,polybori::BooleSet)
map_every_x_to_x_plus_one(...)
map_every_x_to_x_plus_one( (Polynomial)arg1) -> Polynomial :
 
    C++ signature :
        polybori::BoolePolynomial map_every_x_to_x_plus_one(polybori::BoolePolynomial)
mapping(...)
mapping( (Polynomial)arg1, (Monomial)arg2, (Monomial)arg3) -> Polynomial :
 
    C++ signature :
        polybori::BoolePolynomial mapping(polybori::BoolePolynomial,polybori::BooleMonomial,polybori::BooleMonomial)
mod_mon_set(...)
mod_mon_set( (BooleSet)arg1, (BooleSet)arg2) -> BooleSet :
 
    C++ signature :
        polybori::BooleSet mod_mon_set(polybori::BooleSet,polybori::BooleSet)
 
mod_mon_set( (BooleSet)arg1, (BooleSet)arg2) -> BooleSet :
 
    C++ signature :
        polybori::BooleSet mod_mon_set(polybori::BooleSet,polybori::BooleSet)
mod_var_set(...)
mod_var_set( (BooleSet)arg1, (BooleSet)arg2) -> BooleSet :
 
    C++ signature :
        polybori::BooleSet mod_var_set(polybori::BooleSet,polybori::BooleSet)
mult_fast_sim_C(...)
mult_fast_sim_C( (BoolePolynomialVector)arg1) -> Polynomial :
 
    C++ signature :
        polybori::BoolePolynomial mult_fast_sim_C(std::vector<polybori::BoolePolynomial, std::allocator<polybori::BoolePolynomial> >)
nf3(...)
nf3( (GroebnerStrategy)arg1, (Polynomial)arg2, (Monomial)arg3) -> Polynomial :
 
    C++ signature :
        polybori::BoolePolynomial nf3(polybori::groebner::GroebnerStrategy,polybori::BoolePolynomial,polybori::BooleMonomial)
number_of_variables(...)
number_of_variables() -> int :
    Number of variables in the active ring
 
    C++ signature :
        unsigned int number_of_variables()
one(...)
one() -> object :
    Constant one of the active ring
 
    C++ signature :
        polybori::CDDInterface<polybori::CCuddZDD> one()
parallel_reduce(...)
parallel_reduce( (BoolePolynomialVector)arg1, (GroebnerStrategy)arg2, (int)arg3, (float)arg4) -> BoolePolynomialVector :
 
    C++ signature :
        std::vector<polybori::BoolePolynomial, std::allocator<polybori::BoolePolynomial> > parallel_reduce(std::vector<polybori::BoolePolynomial, std::allocator<polybori::BoolePolynomial> >,polybori::groebner::GroebnerStrategy {lvalue},int,double)
print_ring_info(...)
print_ring_info() -> None :
 
    C++ signature :
        void print_ring_info()
random_set(...)
random_set( (Monomial)arg1, (int)arg2) -> BooleSet :
 
    C++ signature :
        polybori::BooleSet random_set(polybori::BooleMonomial,unsigned int)
recursively_insert(...)
recursively_insert( (CCuddNavigator)arg1, (int)arg2, (BooleSet)arg3) -> BooleSet :
 
    C++ signature :
        polybori::BooleSet recursively_insert(polybori::CCuddNavigator,int,polybori::BooleSet)
set_variable_name(...)
set_variable_name( (int)arg1, (str)arg2) -> None :
 
    C++ signature :
        void set_variable_name(int,char const*)
spoly(...)
spoly( (Polynomial)arg1, (Polynomial)arg2) -> Polynomial :
    Compute s-Polynomial between two Polynomials
 
    C++ signature :
        polybori::BoolePolynomial spoly(polybori::BoolePolynomial,polybori::BoolePolynomial)
test_iterate_lex(...)
test_iterate_lex( (Polynomial)arg1) -> int :
 
    C++ signature :
        unsigned long test_iterate_lex(polybori::BoolePolynomial {lvalue})
test_iterate_ordered(...)
test_iterate_ordered( (Polynomial)arg1) -> int :
 
    C++ signature :
        unsigned long test_iterate_ordered(polybori::BoolePolynomial {lvalue})
test_iterate_reference_ordered(...)
test_iterate_reference_ordered( (Polynomial)arg1) -> int :
 
    C++ signature :
        unsigned long test_iterate_reference_ordered(polybori::BoolePolynomial {lvalue})
testvalidstrat(...)
testvalidstrat( (GroebnerStrategy)arg1) -> None :
 
    C++ signature :
        void testvalidstrat(polybori::groebner::GroebnerStrategy)
top_index(...)
top_index( (BooleSet)arg1) -> int :
 
    C++ signature :
        int top_index(polybori::BooleSet)
translate_indices(...)
translate_indices( (Polynomial)arg1, (IntVector)arg2) -> Polynomial :
 
    C++ signature :
        polybori::BoolePolynomial translate_indices(polybori::BoolePolynomial,std::vector<int, std::allocator<int> >)
variety_lex_groebner_basis(...)
variety_lex_groebner_basis( (BooleSet)arg1, (Monomial)arg2) -> BoolePolynomialVector :
 
    C++ signature :
        std::vector<polybori::BoolePolynomial, std::allocator<polybori::BoolePolynomial> > variety_lex_groebner_basis(polybori::BooleSet,polybori::BooleMonomial)
variety_lex_leading_terms(...)
variety_lex_leading_terms( (BooleSet)arg1, (Monomial)arg2) -> BooleSet :
 
    C++ signature :
        polybori::BooleSet variety_lex_leading_terms(polybori::BooleSet,polybori::BooleMonomial)
zero(...)
zero() -> object :
    Constant zero of the active ring
 
    C++ signature :
        polybori::CDDInterface<polybori::CCuddZDD> zero()