polybori.dynamic.PyPolyBoRi
index
../../../../lib64/python2.7/site-packages/polybori/dynamic/PyPolyBoRi.so

 
Classes
       
Boost.Python.enum(__builtin__.int)
OrderCode
Boost.Python.instance(__builtin__.object)
BooleConstant
BoolePolynomialVector
BooleSet
CCuddNavigator
FGLMStrategy
GroebnerStrategy
IntVector
Monomial
PolyEntry
PolyEntryVector
ReductionStrategy
Polynomial
Ring
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)
    Vector of BoolePolynomials
 
 
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 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)
Constructor of the class BooleSet (constructs a BooleSet from a CCuddNavigator
   arg    : of type polybori.dynamic.PyPolyBoRi.CCuddNavigator
   second : of type polybori.dynamic.PyPolyBoRi.BooleRing
__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 long __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)
__reversed__(...)
__reversed__( (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::CReverseIter<polybori::LexOrder, polybori::CCuddNavigator, polybori::BooleMonomial> > __reversed__(boost::python::back_reference<polybori::BooleSet&>)
__str__(...)
__str__( (BooleSet)arg1) -> str :
 
    C++ signature :
        boost::python::str __str__(polybori::BooleSet)
cartesian_product(...)
cartesian_product( (BooleSet)arg1, (BooleSet)arg2) -> BooleSet :
    Cartesian product
 
    C++ signature :
        polybori::BooleSet cartesian_product(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)
divisors_of(...)
divisors_of( (BooleSet)arg1, (Monomial)arg2) -> BooleSet :
    Compute intersection with divisors of the right-hand side term
 
    C++ signature :
        polybori::BooleSet divisors_of(polybori::BooleSet {lvalue},polybori::BooleMonomial)
empty(...)
empty( (BooleSet)arg1) -> bool :
    Check, whether BooleSet is empty
 
    C++ signature :
        bool empty(polybori::BooleSet {lvalue})
exist_abstract(...)
exist_abstract( (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 exist_abstract(polybori::BooleSet {lvalue},polybori::BooleMonomial)
include_divisors(...)
include_divisors( (BooleSet)arg1) -> BooleSet :
 
    C++ signature :
        polybori::BooleSet include_divisors(polybori::BooleSet)
intersect(...)
intersect( (BooleSet)arg1, (BooleSet)arg2) -> BooleSet :
    Set intersection
 
    C++ signature :
        polybori::BooleSet intersect(polybori::BooleSet {lvalue},polybori::BooleSet)
minimal_elements(...)
minimal_elements( (BooleSet)arg1) -> BooleSet :
    Get minimal elements with respect to inclusion
 
    C++ signature :
        polybori::BooleSet minimal_elements(polybori::BooleSet {lvalue})
multiples_of(...)
multiples_of( (BooleSet)arg1, (Monomial)arg2) -> BooleSet :
    Compute intersection with multiples of the right-hand side term
 
    C++ signature :
        polybori::BooleSet multiples_of(polybori::BooleSet {lvalue},polybori::BooleMonomial)
n_nodes(...)
n_nodes( (BooleSet)arg1) -> int :
    Number of nodes of the underlying ZDD
 
    C++ signature :
        unsigned long n_nodes(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) -> Ring :
    Get corresponding ring
 
    C++ signature :
        polybori::BoolePolyRing ring(polybori::BooleSet {lvalue})
set(...)
set( (BooleSet)arg1) -> BooleSet :
 
    C++ signature :
        polybori::BooleSet set(polybori::BooleSet)
size_double(...)
size_double( (BooleSet)arg1) -> float :
    Number of elements as double floating point number.
 
    C++ signature :
        double size_double(polybori::BooleSet {lvalue})
stable_hash(...)
stable_hash( (BooleSet)arg1) -> int :
    Reproducible hash code
 
    C++ signature :
        unsigned long stable_hash(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__ = 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 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})
else_branch(...)
else_branch( (CCuddNavigator)arg1) -> CCuddNavigator :
    Following else-edge of thr root node
 
    C++ signature :
        polybori::CCuddNavigator else_branch(polybori::CCuddNavigator)
terminal_one(...)
terminal_one( (CCuddNavigator)arg1) -> bool :
    Check for terminal 1
 
    C++ signature :
        bool terminal_one(polybori::CCuddNavigator {lvalue})
then_branch(...)
then_branch( (CCuddNavigator)arg1) -> CCuddNavigator :
    Following then-edge of thr root node
 
    C++ signature :
        polybori::CCuddNavigator then_branch(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 :
    Index of the current node
 
    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 FGLMStrategy(Boost.Python.instance)
    
Method resolution order:
FGLMStrategy
Boost.Python.instance
__builtin__.object

Methods defined here:
__init__(...)
__init__( (object)arg1) -> None :
 
    C++ signature :
        void __init__(_object*)
 
__init__( (object)arg1) -> None :
 
    C++ signature :
        void __init__(_object*)
 
__init__( (object)arg1, (Ring)arg2, (Ring)arg3, (BoolePolynomialVector)arg4) -> None :
 
    C++ signature :
        void __init__(_object*,polybori::BoolePolyRing,polybori::BoolePolyRing,std::vector<polybori::BoolePolynomial, std::allocator<polybori::BoolePolynomial> >)
__reduce__ = (...)
main(...)
main( (FGLMStrategy)arg1) -> BoolePolynomialVector :
 
    C++ signature :
        std::vector<polybori::BoolePolynomial, std::allocator<polybori::BoolePolynomial> > main(polybori::groebner::FGLMStrategy {lvalue})

Data and other attributes defined here:
__instance_size__ = 896

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__ = (...)
add_as_you_wish(...)
add_as_you_wish( (GroebnerStrategy)arg1, (Polynomial)arg2) -> None :
 
    C++ signature :
        void add_as_you_wish(polybori::groebner::GroebnerStrategy {lvalue},polybori::BoolePolynomial)
add_generator(...)
add_generator( (GroebnerStrategy)arg1, (Polynomial)arg2) -> None :
 
    C++ signature :
        void add_generator(polybori::groebner::GroebnerStrategy {lvalue},polybori::BoolePolynomial)
add_generator_delayed(...)
add_generator_delayed( (GroebnerStrategy)arg1, (Polynomial)arg2) -> None :
 
    C++ signature :
        void add_generator_delayed(polybori::groebner::GroebnerStrategy {lvalue},polybori::BoolePolynomial)
all_generators(...)
all_generators( (GroebnerStrategy)arg1) -> BoolePolynomialVector :
 
    C++ signature :
        std::vector<polybori::BoolePolynomial, std::allocator<polybori::BoolePolynomial> > all_generators(polybori::groebner::GroebnerStrategy {lvalue})
clean_top_by_chain_criterion(...)
clean_top_by_chain_criterion( (GroebnerStrategy)arg1) -> None :
 
    C++ signature :
        void clean_top_by_chain_criterion(polybori::groebner::GroebnerStrategy {lvalue})
contains_one(...)
contains_one( (GroebnerStrategy)arg1) -> bool :
 
    C++ signature :
        bool contains_one(polybori::groebner::GroebnerStrategy)
faugere_step_dense(...)
faugere_step_dense( (GroebnerStrategy)arg1, (BoolePolynomialVector)arg2) -> BoolePolynomialVector :
 
    C++ signature :
        std::vector<polybori::BoolePolynomial, std::allocator<polybori::BoolePolynomial> > faugere_step_dense(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)
ll_reduce_all(...)
ll_reduce_all( (GroebnerStrategy)arg1) -> None :
 
    C++ signature :
        void ll_reduce_all(polybori::groebner::GroebnerStrategy {lvalue})
minimalize(...)
minimalize( (GroebnerStrategy)arg1) -> BoolePolynomialVector :
 
    C++ signature :
        std::vector<polybori::BoolePolynomial, std::allocator<polybori::BoolePolynomial> > minimalize(polybori::groebner::GroebnerStrategy {lvalue})
minimalize_and_tail_reduce(...)
minimalize_and_tail_reduce( (GroebnerStrategy)arg1) -> BoolePolynomialVector :
 
    C++ signature :
        std::vector<polybori::BoolePolynomial, std::allocator<polybori::BoolePolynomial> > minimalize_and_tail_reduce(polybori::groebner::GroebnerStrategy {lvalue})
next_spoly(...)
next_spoly( (GroebnerStrategy)arg1) -> Polynomial :
 
    C++ signature :
        polybori::BoolePolynomial next_spoly(polybori::groebner::GroebnerStrategy {lvalue})
nf(...)
nf( (GroebnerStrategy)arg1, (Polynomial)arg2) -> Polynomial :
 
    C++ signature :
        polybori::BoolePolynomial nf(polybori::groebner::GroebnerStrategy {lvalue},polybori::BoolePolynomial)
noro_step(...)
noro_step( (GroebnerStrategy)arg1, (BoolePolynomialVector)arg2) -> BoolePolynomialVector :
 
    C++ signature :
        std::vector<polybori::BoolePolynomial, std::allocator<polybori::BoolePolynomial> > noro_step(polybori::groebner::GroebnerStrategy {lvalue},std::vector<polybori::BoolePolynomial, std::allocator<polybori::BoolePolynomial> >)
npairs(...)
npairs( (GroebnerStrategy)arg1) -> int :
 
    C++ signature :
        int npairs(polybori::groebner::GroebnerStrategy)
red_tail(...)
red_tail( (GroebnerStrategy)arg1, (Polynomial)arg2) -> Polynomial :
 
    C++ signature :
        polybori::BoolePolynomial red_tail(polybori::groebner::GroebnerStrategy {lvalue},polybori::BoolePolynomial)
select(...)
select( (GroebnerStrategy)arg1, (Monomial)arg2) -> int :
 
    C++ signature :
        int select(polybori::groebner::GroebnerStrategy,polybori::BooleMonomial)
some_spolys_in_next_degree(...)
some_spolys_in_next_degree( (GroebnerStrategy)arg1, (int)arg2) -> BoolePolynomialVector :
 
    C++ signature :
        std::vector<polybori::BoolePolynomial, std::allocator<polybori::BoolePolynomial> > some_spolys_in_next_degree(polybori::groebner::GroebnerStrategy {lvalue},int)
suggest_plugin_variable(...)
suggest_plugin_variable( (GroebnerStrategy)arg1) -> int :
 
    C++ signature :
        int suggest_plugin_variable(polybori::groebner::GroebnerStrategy {lvalue})
symmGB_F2(...)
symmGB_F2( (GroebnerStrategy)arg1) -> None :
 
    C++ signature :
        void symmGB_F2(polybori::groebner::GroebnerStrategy {lvalue})
top_sugar(...)
top_sugar( (GroebnerStrategy)arg1) -> int :
 
    C++ signature :
        int top_sugar(polybori::groebner::GroebnerStrategy)
variable_has_value(...)
variable_has_value( (GroebnerStrategy)arg1, (int)arg2) -> bool :
 
    C++ signature :
        bool variable_has_value(polybori::groebner::GroebnerStrategy {lvalue},int)

Data descriptors defined here:
chain_criterions
easy_product_criterions
enabled_log
extended_product_criterions
matrix_prefix
opt_allow_recursion
opt_draw_matrices
opt_exchange
opt_lazy
opt_linear_algebra_in_last_block
opt_modified_linear_algebra
opt_red_by_reduced
reduction_strategy
variable_chain_criterions

Data and other attributes defined here:
__instance_size__ = 472

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)
    Vector of Integers
 
 
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)
__init__ = monomial_new_init(self, arg=None)
Constructor of the class Monomial
Constructs a Monomial from
  - Monomial
  - Variable
  - sequence of variables
__le__(...)
__le__( (Monomial)arg1, (Monomial)arg2) -> object :
 
    C++ signature :
        _object* __le__(polybori::BooleMonomial {lvalue},polybori::BooleMonomial)
__len__(...)
__len__( (Monomial)arg1) -> int :
    Constant one function
 
    C++ signature :
        int __len__(polybori::BooleMonomial)
__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 :
        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})
gcd(...)
gcd( (Monomial)arg1, (Monomial)arg2) -> Monomial :
 
    C++ signature :
        polybori::BooleMonomial gcd(polybori::BooleMonomial {lvalue},polybori::BooleMonomial)
has_constant_part(...)
has_constant_part( (Polynomial)arg1) -> bool :
 
    C++ signature :
        bool has_constant_part(polybori::BoolePolynomial)
lead(...)
lead( (Polynomial)arg1) -> Monomial :
 
    C++ signature :
        polybori::BooleMonomial lead(polybori::BoolePolynomial)
lead_deg(...)
lead_deg( (Polynomial)arg1) -> int :
 
    C++ signature :
        int lead_deg(polybori::BoolePolynomial)
lex_lead(...)
lex_lead( (Polynomial)arg1) -> Monomial :
 
    C++ signature :
        polybori::BooleMonomial lex_lead(polybori::BoolePolynomial)
lex_lead_deg(...)
lex_lead_deg( (Polynomial)arg1) -> int :
 
    C++ signature :
        int lex_lead_deg(polybori::BoolePolynomial)
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)
navigation(...)
navigation( (Polynomial)arg1) -> CCuddNavigator :
 
    C++ signature :
        polybori::CCuddNavigator navigation(polybori::BoolePolynomial)
reducible_by(...)
reducible_by( (Monomial)arg1, (Monomial)arg2) -> bool :
    Test for reducibility
 
    C++ signature :
        bool reducible_by(polybori::BooleMonomial {lvalue},polybori::BooleMonomial)
ring(...)
ring( (Monomial)arg1) -> Ring :
    Get corresponding ring
 
    C++ signature :
        polybori::BoolePolyRing ring(polybori::BooleMonomial {lvalue})
set(...)
set( (Monomial)arg1) -> BooleSet :
    Convert to BooleSet
 
    C++ signature :
        polybori::BooleSet set(polybori::BooleMonomial {lvalue})
stable_hash(...)
stable_hash( (Monomial)arg1) -> int :
    Reproducible hash code
 
    C++ signature :
        unsigned long stable_hash(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&>)
vars_as_monomial(...)
vars_as_monomial( (Monomial)arg1) -> Monomial :
    Variables occurring in Polynomial
 
    C++ signature :
        polybori::BooleMonomial vars_as_monomial(polybori::BooleMonomial)

Data and other attributes defined here:
__instance_size__ = 56

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 PolyEntry(Boost.Python.instance)
    Entry with polynomial and statistical information
 
 
Method resolution order:
PolyEntry
Boost.Python.instance
__builtin__.object

Methods defined here:
__init__(...)
__init__( (object)arg1) -> None :
 
    C++ signature :
        void __init__(_object*)
 
__init__( (object)arg1, (Polynomial)arg2) -> None :
 
    C++ signature :
        void __init__(_object*,polybori::BoolePolynomial)
__reduce__ = (...)
ecart(...)
ecart( (PolyEntry)arg1) -> int :
 
    C++ signature :
        int ecart(polybori::groebner::PolyEntry {lvalue})
recompute_information(...)
recompute_information( (PolyEntry)arg1) -> None :
 
    C++ signature :
        void recompute_information(polybori::groebner::PolyEntry {lvalue})

Data descriptors defined here:
deg
gcd_of_terms
lead
lead_deg
length
minimal
p
tail
weighted_length

Data and other attributes defined here:
__instance_size__ = 448

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 PolyEntryVector(Boost.Python.instance)
    
Method resolution order:
PolyEntryVector
Boost.Python.instance
__builtin__.object

Methods defined here:
__contains__(...)
__contains__( (PolyEntryVector)arg1, (object)arg2) -> bool :
 
    C++ signature :
        bool __contains__(std::vector<polybori::groebner::PolyEntry, std::allocator<polybori::groebner::PolyEntry> > {lvalue},_object*)
__delitem__(...)
__delitem__( (PolyEntryVector)arg1, (object)arg2) -> None :
 
    C++ signature :
        void __delitem__(std::vector<polybori::groebner::PolyEntry, std::allocator<polybori::groebner::PolyEntry> > {lvalue},_object*)
__getitem__(...)
__getitem__( (object)arg1, (object)arg2) -> object :
 
    C++ signature :
        boost::python::api::object __getitem__(boost::python::back_reference<std::vector<polybori::groebner::PolyEntry, std::allocator<polybori::groebner::PolyEntry> >&>,_object*)
__init__(...)
__init__( (object)arg1) -> None :
 
    C++ signature :
        void __init__(_object*)
__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::groebner::PolyEntry*, std::vector<polybori::groebner::PolyEntry, std::allocator<polybori::groebner::PolyEntry> > > > __iter__(boost::python::back_reference<std::vector<polybori::groebner::PolyEntry, std::allocator<polybori::groebner::PolyEntry> >&>)
__len__(...)
__len__( (PolyEntryVector)arg1) -> int :
 
    C++ signature :
        unsigned long __len__(std::vector<polybori::groebner::PolyEntry, std::allocator<polybori::groebner::PolyEntry> > {lvalue})
__reduce__ = (...)
__setitem__(...)
__setitem__( (PolyEntryVector)arg1, (object)arg2, (object)arg3) -> None :
 
    C++ signature :
        void __setitem__(std::vector<polybori::groebner::PolyEntry, std::allocator<polybori::groebner::PolyEntry> > {lvalue},_object*,_object*)
append(...)
append( (PolyEntryVector)arg1, (object)arg2) -> None :
 
    C++ signature :
        void append(std::vector<polybori::groebner::PolyEntry, std::allocator<polybori::groebner::PolyEntry> > {lvalue},boost::python::api::object)
extend(...)
extend( (PolyEntryVector)arg1, (object)arg2) -> None :
 
    C++ signature :
        void extend(std::vector<polybori::groebner::PolyEntry, std::allocator<polybori::groebner::PolyEntry> > {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 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)
__cmp__(...)
__cmp__( (Polynomial)arg1, (Polynomial)arg2) -> int :
    Comparison of Boolean polynomials
 
    C++ signature :
        short __cmp__(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})
__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, (Ring)arg3) -> None :
 
    C++ signature :
        void __init__(_object*,polybori::CCuddNavigator,polybori::BoolePolyRing)
 
__init__( (object)arg1, (int)arg2, (Ring)arg3) -> None :
 
    C++ signature :
        void __init__(_object*,int,polybori::BoolePolyRing)
 
__init__( (object)arg1, (BooleSet)arg2) -> None :
 
    C++ signature :
        void __init__(_object*,polybori::BooleSet)
 
__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)
__len__(...)
__len__( (Polynomial)arg1) -> int :
    Number of terms
 
    C++ signature :
        unsigned long __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 :
        int deg(polybori::BoolePolynomial {lvalue})
elength(...)
elength( (Polynomial)arg1) -> int :
    Elimination length
 
    C++ signature :
        unsigned long elength(polybori::BoolePolynomial {lvalue})
first_reducible_by(...)
first_reducible_by( (Polynomial)arg1, (Polynomial)arg2) -> bool :
 
    C++ signature :
        bool first_reducible_by(polybori::BoolePolynomial {lvalue},polybori::BoolePolynomial)
graded_part(...)
graded_part( (Polynomial)arg1, (int)arg2) -> Polynomial :
    Get part of given degree
 
    C++ signature :
        polybori::BoolePolynomial graded_part(polybori::BoolePolynomial {lvalue},int)
has_constant_part(...)
has_constant_part( (Polynomial)arg1) -> bool :
    Check, whether Polynomials owns constant term
 
    C++ signature :
        bool has_constant_part(polybori::BoolePolynomial {lvalue})
is_one(...)
is_one( (Polynomial)arg1) -> bool :
    Test if Polynomial one
 
    C++ signature :
        bool is_one(polybori::BoolePolynomial {lvalue})
is_zero(...)
is_zero( (Polynomial)arg1) -> bool :
    Test if Polynomial is zero
 
    C++ signature :
        bool is_zero(polybori::BoolePolynomial {lvalue})
lead(...)
lead( (Polynomial)arg1) -> Monomial :
    Leading term with respect to current ordering
 
    C++ signature :
        polybori::BooleMonomial lead(polybori::BoolePolynomial {lvalue})
lead_deg(...)
lead_deg( (Polynomial)arg1) -> int :
    Degree of the leading term
 
    C++ signature :
        int lead_deg(polybori::BoolePolynomial {lvalue})
lead_divisors(...)
lead_divisors( (Polynomial)arg1) -> BooleSet :
    Divisors of leading term
 
    C++ signature :
        polybori::BooleSet lead_divisors(polybori::BoolePolynomial {lvalue})
lex_lead(...)
lex_lead( (Polynomial)arg1) -> Monomial :
    Lexicographical leading term
 
    C++ signature :
        polybori::BooleMonomial lex_lead(polybori::BoolePolynomial {lvalue})
lex_lead_deg(...)
lex_lead_deg( (Polynomial)arg1) -> int :
    Degree of the lexicographical leading term
 
    C++ signature :
        int lex_lead_deg(polybori::BoolePolynomial {lvalue})
map_every_x_to_x_plus_one(...)
map_every_x_to_x_plus_one( (Polynomial)arg1) -> Polynomial :
    Replace every variable x by x + 1
 
    C++ signature :
        polybori::BoolePolynomial map_every_x_to_x_plus_one(polybori::BoolePolynomial)
multiply_fast(...)
multiply_fast( (Polynomial)arg1, (Polynomial)arg2) -> Polynomial :
 
    C++ signature :
        polybori::BoolePolynomial multiply_fast(polybori::BoolePolynomial,polybori::BoolePolynomial)
multiply_traditionally(...)
multiply_traditionally( (Polynomial)arg1, (Polynomial)arg2) -> Polynomial :
 
    C++ signature :
        polybori::BoolePolynomial multiply_traditionally(polybori::BoolePolynomial,polybori::BoolePolynomial)
n_nodes(...)
n_nodes( (Polynomial)arg1) -> int :
    Number of diagram nodes in the underlying ZDD structure
 
    C++ signature :
        unsigned long n_nodes(polybori::BoolePolynomial {lvalue})
n_variables(...)
n_variables( (Polynomial)arg1) -> int :
    Number of variables occurring in Polynomial
 
    C++ signature :
        unsigned long n_variables(polybori::BoolePolynomial {lvalue})
navigation(...)
navigation( (Polynomial)arg1) -> CCuddNavigator :
    Navigate through underlying ZDD structure
 
    C++ signature :
        polybori::CCuddNavigator navigation(polybori::BoolePolynomial {lvalue})
ring(...)
ring( (Polynomial)arg1) -> Ring :
    Get corresponding ring
 
    C++ signature :
        polybori::BoolePolyRing ring(polybori::BoolePolynomial {lvalue})
set(...)
set( (Polynomial)arg1) -> BooleSet :
    Convert to BooleSet
 
    C++ signature :
        polybori::BooleSet set(polybori::BoolePolynomial {lvalue})
stable_hash(...)
stable_hash( (Polynomial)arg1) -> int :
    Reproducible hash code
 
    C++ signature :
        unsigned long stable_hash(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&>)
total_degree(...)
total_degree( (Polynomial)arg1) -> int :
    Total Polynomial degree
 
    C++ signature :
        int total_degree(polybori::BoolePolynomial {lvalue})
translate_indices(...)
translate_indices( (Polynomial)arg1, (IntVector)arg2) -> Polynomial :
 
    C++ signature :
        polybori::BoolePolynomial translate_indices(polybori::BoolePolynomial,std::vector<int, std::allocator<int> >)
vars_as_monomial(...)
vars_as_monomial( (Polynomial)arg1) -> Monomial :
    Variables occurring in Polynomial
 
    C++ signature :
        polybori::BooleMonomial vars_as_monomial(polybori::BoolePolynomial {lvalue})
zeros_in(...)
zeros_in( (Polynomial)arg1, (BooleSet)arg2) -> BooleSet :
    Get BooleSet representing the zeros of the Polynomial
 
    C++ signature :
        polybori::BooleSet zeros_in(polybori::BoolePolynomial,polybori::BooleSet)

Data and other attributes defined here:
__instance_size__ = 48

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 ReductionStrategy(PolyEntryVector)
    
Method resolution order:
ReductionStrategy
PolyEntryVector
Boost.Python.instance
__builtin__.object

Methods defined here:
__init__(...)
__init__( (object)arg1) -> None :
 
    C++ signature :
        void __init__(_object*)
 
__init__( (object)arg1) -> None :
 
    C++ signature :
        void __init__(_object*)
__reduce__ = (...)
add_generator(...)
add_generator( (ReductionStrategy)arg1, (Polynomial)arg2) -> None :
 
    C++ signature :
        void add_generator(polybori::groebner::ReductionStrategy {lvalue},polybori::BoolePolynomial)
can_rewrite(...)
can_rewrite( (ReductionStrategy)arg1, (Polynomial)arg2) -> bool :
 
    C++ signature :
        bool can_rewrite(polybori::groebner::ReductionStrategy {lvalue},polybori::BoolePolynomial)
cheap_reductions(...)
cheap_reductions( (ReductionStrategy)arg1, (Polynomial)arg2) -> Polynomial :
 
    C++ signature :
        polybori::BoolePolynomial cheap_reductions(polybori::groebner::ReductionStrategy,polybori::BoolePolynomial)
head_normal_form(...)
head_normal_form( (ReductionStrategy)arg1, (Polynomial)arg2) -> Polynomial :
 
    C++ signature :
        polybori::BoolePolynomial head_normal_form(polybori::groebner::ReductionStrategy {lvalue},polybori::BoolePolynomial)
nf(...)
nf( (ReductionStrategy)arg1, (Polynomial)arg2) -> Polynomial :
 
    C++ signature :
        polybori::BoolePolynomial nf(polybori::groebner::ReductionStrategy {lvalue},polybori::BoolePolynomial)
reduced_normal_form(...)
reduced_normal_form( (ReductionStrategy)arg1, (Polynomial)arg2) -> Polynomial :
 
    C++ signature :
        polybori::BoolePolynomial reduced_normal_form(polybori::groebner::ReductionStrategy {lvalue},polybori::BoolePolynomial)

Data descriptors defined here:
leading_terms
minimal_leading_terms
monomials
opt_brutal_reductions
opt_ll
opt_red_tail
opt_red_tail_deg_growth

Data and other attributes defined here:
__instance_size__ = 312

Methods inherited from PolyEntryVector:
__contains__(...)
__contains__( (PolyEntryVector)arg1, (object)arg2) -> bool :
 
    C++ signature :
        bool __contains__(std::vector<polybori::groebner::PolyEntry, std::allocator<polybori::groebner::PolyEntry> > {lvalue},_object*)
__delitem__(...)
__delitem__( (PolyEntryVector)arg1, (object)arg2) -> None :
 
    C++ signature :
        void __delitem__(std::vector<polybori::groebner::PolyEntry, std::allocator<polybori::groebner::PolyEntry> > {lvalue},_object*)
__getitem__(...)
__getitem__( (object)arg1, (object)arg2) -> object :
 
    C++ signature :
        boost::python::api::object __getitem__(boost::python::back_reference<std::vector<polybori::groebner::PolyEntry, std::allocator<polybori::groebner::PolyEntry> >&>,_object*)
__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::groebner::PolyEntry*, std::vector<polybori::groebner::PolyEntry, std::allocator<polybori::groebner::PolyEntry> > > > __iter__(boost::python::back_reference<std::vector<polybori::groebner::PolyEntry, std::allocator<polybori::groebner::PolyEntry> >&>)
__len__(...)
__len__( (PolyEntryVector)arg1) -> int :
 
    C++ signature :
        unsigned long __len__(std::vector<polybori::groebner::PolyEntry, std::allocator<polybori::groebner::PolyEntry> > {lvalue})
__setitem__(...)
__setitem__( (PolyEntryVector)arg1, (object)arg2, (object)arg3) -> None :
 
    C++ signature :
        void __setitem__(std::vector<polybori::groebner::PolyEntry, std::allocator<polybori::groebner::PolyEntry> > {lvalue},_object*,_object*)
append(...)
append( (PolyEntryVector)arg1, (object)arg2) -> None :
 
    C++ signature :
        void append(std::vector<polybori::groebner::PolyEntry, std::allocator<polybori::groebner::PolyEntry> > {lvalue},boost::python::api::object)
extend(...)
extend( (PolyEntryVector)arg1, (object)arg2) -> None :
 
    C++ signature :
        void extend(std::vector<polybori::groebner::PolyEntry, std::allocator<polybori::groebner::PolyEntry> > {lvalue},boost::python::api::object)

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(Boost.Python.instance)
    Boolean polynomial ring
 
 
Method resolution order:
Ring
Boost.Python.instance
__builtin__.object

Methods defined here:
__hash__(...)
__hash__( (Ring)arg1) -> int :
 
    C++ signature :
        unsigned long __hash__(polybori::BoolePolyRing {lvalue})
__init__(...)
__init__( (object)arg1) -> None :
 
    C++ signature :
        void __init__(_object*)
 
__init__( (object)arg1, (int)arg2) -> None :
 
    C++ signature :
        void __init__(_object*,unsigned long)
 
__init__( (object)arg1, (Ring)arg2) -> None :
 
    C++ signature :
        void __init__(_object*,polybori::BoolePolyRing)
 
__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 long,int)
__reduce__ = (...)
clone(...)
clone( (Ring)arg1) -> Ring :
    copies also variable name vector in a     new one, so somewhat deeper copy function
 
    C++ signature :
        polybori::BoolePolyRing clone(polybori::BoolePolyRing {lvalue})
coerce(...)
coerce( (Ring)arg1, (Polynomial)arg2) -> Polynomial :
    Map polynomial in this ring, if possible.
 
    C++ signature :
        polybori::BoolePolynomial coerce(polybori::BoolePolyRing,polybori::BoolePolynomial)
n_variables(...)
n_variables( (Ring)arg1) -> int :
    Number of ring variables
 
    C++ signature :
        unsigned long n_variables(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__ = 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 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 :
        unsigned long __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)
has_constant_part(...)
has_constant_part( (Polynomial)arg1) -> bool :
 
    C++ signature :
        bool has_constant_part(polybori::BoolePolynomial)
index(...)
index( (Variable)arg1) -> int :
    Variable position in the ring
 
    C++ signature :
        int index(polybori::BooleVariable {lvalue})
lead(...)
lead( (Polynomial)arg1) -> Monomial :
 
    C++ signature :
        polybori::BooleMonomial lead(polybori::BoolePolynomial)
lead_deg(...)
lead_deg( (Polynomial)arg1) -> int :
 
    C++ signature :
        int lead_deg(polybori::BoolePolynomial)
lex_lead(...)
lex_lead( (Polynomial)arg1) -> Monomial :
 
    C++ signature :
        polybori::BooleMonomial lex_lead(polybori::BoolePolynomial)
lex_lead_deg(...)
lex_lead_deg( (Polynomial)arg1) -> int :
 
    C++ signature :
        int lex_lead_deg(polybori::BoolePolynomial)
navigation(...)
navigation( (Polynomial)arg1) -> CCuddNavigator :
 
    C++ signature :
        polybori::CCuddNavigator navigation(polybori::BoolePolynomial)
ring(...)
ring( (Variable)arg1) -> Ring :
    Get corresponding ring
 
    C++ signature :
        polybori::BoolePolyRing ring(polybori::BooleVariable {lvalue})
set(...)
set( (Variable)arg1) -> BooleSet :
    Convert to BooleSet
 
    C++ signature :
        polybori::BooleSet set(polybori::BooleVariable {lvalue})
stable_hash(...)
stable_hash( (Monomial)arg1) -> int :
    Reproducible hash code
 
    C++ signature :
        unsigned long stable_hash(polybori::BooleMonomial {lvalue})
vars_as_monomial(...)
vars_as_monomial( (Variable)arg1) -> Monomial :
    Variables occurring in Polynomial
 
    C++ signature :
        polybori::BooleMonomial vars_as_monomial(polybori::BooleVariable)

Data and other attributes defined here:
__instance_size__ = 56

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 the index of the start of the 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)
easy_linear_factors(...)
easy_linear_factors( (Polynomial)arg1) -> BoolePolynomialVector :
 
    C++ signature :
        std::vector<polybori::BoolePolynomial, std::allocator<polybori::BoolePolynomial> > easy_linear_factors(polybori::BoolePolynomial)
gauss_on_polys(...)
gauss_on_polys( (BoolePolynomialVector)arg1) -> BoolePolynomialVector :
 
    C++ signature :
        std::vector<polybori::BoolePolynomial, std::allocator<polybori::BoolePolynomial> > gauss_on_polys(std::vector<polybori::BoolePolynomial, std::allocator<polybori::BoolePolynomial> >)
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_noredsb(...)
ll_red_nf_noredsb( (Polynomial)arg1, (BooleSet)arg2) -> Polynomial :
 
    C++ signature :
        polybori::BoolePolynomial ll_red_nf_noredsb(polybori::BoolePolynomial,polybori::BooleSet)
ll_red_nf_noredsb_single_recursive_call(...)
ll_red_nf_noredsb_single_recursive_call( (Polynomial)arg1, (BooleSet)arg2) -> Polynomial :
 
    C++ signature :
        polybori::BoolePolynomial ll_red_nf_noredsb_single_recursive_call(polybori::BoolePolynomial,polybori::BooleSet)
ll_red_nf_redsb(...)
ll_red_nf_redsb( (Polynomial)arg1, (BooleSet)arg2) -> Polynomial :
 
    C++ signature :
        polybori::BoolePolynomial ll_red_nf_redsb(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( (ReductionStrategy)arg1, (Polynomial)arg2, (Monomial)arg3) -> Polynomial :
 
    C++ signature :
        polybori::BoolePolynomial nf3(polybori::groebner::ReductionStrategy,polybori::BoolePolynomial,polybori::BooleMonomial)
number_of_variables(...)
number_of_variables() -> int :
    Number of variables in the active ring
 
    C++ signature :
        unsigned long number_of_variables()
one(...)
one() -> BooleSet :
    Constant one of the active ring
 
    C++ signature :
        polybori::BooleSet 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_random_seed(...)
set_random_seed( (int)arg1) -> None :
 
    C++ signature :
        void set_random_seed(unsigned int)
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)
substitute_variables(...)
substitute_variables( (Ring)arg1, (BoolePolynomialVector)arg2, (Polynomial)arg3) -> Polynomial :
 
    C++ signature :
        polybori::BoolePolynomial substitute_variables(polybori::BoolePolyRing,std::vector<polybori::BoolePolynomial, std::allocator<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_lex_reversed(...)
test_iterate_lex_reversed( (Polynomial)arg1) -> int :
 
    C++ signature :
        unsigned long test_iterate_lex_reversed(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() -> BooleSet :
    Constant zero of the active ring
 
    C++ signature :
        polybori::BooleSet zero()