polybori.nf
index
../../../../lib/python2.7/site-packages/polybori/nf.py

 
Modules
       
copy
sys

 
Classes
       
exceptions.Exception(exceptions.BaseException)
GeneratorLimitExceeded

 
class GeneratorLimitExceeded(exceptions.Exception)
    docstring for GeneratorLimitExceeded
 
 
Method resolution order:
GeneratorLimitExceeded
exceptions.Exception
exceptions.BaseException
__builtin__.object

Methods defined here:
__init__(self, strat)

Data descriptors defined here:
__weakref__
list of weak references to the object (if defined)

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

Methods inherited from exceptions.BaseException:
__delattr__(...)
x.__delattr__('name') <==> del x.name
__getattribute__(...)
x.__getattribute__('name') <==> x.name
__getitem__(...)
x.__getitem__(y) <==> x[y]
__getslice__(...)
x.__getslice__(i, j) <==> x[i:j]
 
Use of negative indices is not supported.
__reduce__(...)
__repr__(...)
x.__repr__() <==> repr(x)
__setattr__(...)
x.__setattr__('name', value) <==> x.name = value
__setstate__(...)
__str__(...)
x.__str__() <==> str(x)
__unicode__(...)

Data descriptors inherited from exceptions.BaseException:
__dict__
args
message

 
Functions
       
GPS(G, vars_start, vars_end)
GPS_with_non_binary_proof_path(G, proof_path, deg_bound, over_deg_bound)
GPS_with_proof_path(G, proof_path, deg_bound, over_deg_bound)
GPS_with_suggestions(G, deg_bound, over_deg_bound, optLazy=True, optRedTail=True, initial_bb=True)
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)
build_and_print_matrices(v, strat)
build_and_print_matrices_deg_colored(v, strat)
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_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_redsb(...)
ll_red_nf_redsb( (Polynomial)arg1, (BooleSet)arg2) -> Polynomial :
 
    C++ signature :
        polybori::BoolePolynomial ll_red_nf_redsb(polybori::BoolePolynomial,polybori::BooleSet)
lm_tuple(f)
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> >)
myspoly(f, g)
only for the profiler to be noticed
nf3(...)
nf3( (GroebnerStrategy)arg1, (Polynomial)arg2, (Monomial)arg3) -> Polynomial :
 
    C++ signature :
        polybori::BoolePolynomial nf3(polybori::groebner::GroebnerStrategy,polybori::BoolePolynomial,polybori::BooleMonomial)
noro_step(polys, strat)
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)
pkey(p)
print_ring_info(...)
print_ring_info() -> None :
 
    C++ signature :
        void print_ring_info()
product_criterion(f, g)
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)
sum_terms(terms)
symmGB_F2_C(G, optExchange=True, deg_bound=1000000000000L, optLazy=False, over_deg_bound=0, optRedTail=True, max_growth=2.0, step_factor=1.0, implications=False, prot=False, full_prot=False, selection_size=1000, optAllowRecursion=False, use_noro=False, use_faugere=False, ll=False, optLinearAlgebraInLastBlock=True, max_generators=None)
symmGB_F2_python(G, deg_bound=1000000000000L, over_deg_bound=0, use_faugere=False, use_noro=False, optLazy=True, optRedTail=True, max_growth=2.0, step_factor=1.0, implications=False, prot=False, full_prot=False, selection_size=1000, optExchange=True, optAllowRecursion=False, ll=False, optLinearAlgebraInLastBlock=True, max_generators=None)
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> >)
update_cache2(h, cache)
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()

 
Data
        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
k = 4
lp = polybori.dynamic.PyPolyBoRi.OrderCode.lp
mat_counter = 0
matrix_prefix = 'hfe30_'
modules = {'StringIO': <module 'StringIO' from '/usr/lib/python2.7/StringIO.pyc'>, 'UserDict': <module 'UserDict' from '/usr/lib/python2.7/UserDict.pyc'>, '__builtin__': <module '__builtin__' (built-in)>, '__future__': <module '__future__' from '/usr/lib/python2.7/__future__.pyc'>, '__main__': <module '__main__' from 'doc/python/genpythondoc.py'>, '_abcoll': <module '_abcoll' from '/usr/lib/python2.7/_abcoll.pyc'>, '_bisect': <module '_bisect' from '/usr/lib/python2.7/lib-dynload/_bisectmodule.so'>, '_codecs': <module '_codecs' (built-in)>, '_collections': <module '_collections' from '/usr/lib/python2.7/lib-dynload/_collectionsmodule.so'>, '_functools': <module '_functools' from '/usr/lib/python2.7/lib-dynload/_functoolsmodule.so'>, ...}
print_matrices = False