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

 
Modules
       
copy
re
sys
warnings

 
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, opt_lazy=True, opt_red_tail=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)
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)
build_and_print_matrices(v, strat)
"old solution using PIL, the currently used implementation is done in C++
and plots the same matrices, as being calculated
build_and_print_matrices_deg_colored(v, strat)
old PIL solution using a different color for each degree
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)
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)
normal_form(poly, ideal, reduced=True)
Simple normal form computation of a polynomial  against an ideal.
>>> from polybori import declare_ring, normal_form
>>> r=declare_ring(['x','y'], globals())
>>> normal_form(x+y, [y],reduced=True)
x
>>> normal_form(x+y,[x,y])
0
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)
pkey(p)
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)
symmGB_F2_C(G, opt_exchange=True, deg_bound=1000000000000, opt_lazy=False, over_deg_bound=0, opt_red_tail=True, max_growth=2.0, step_factor=1.0, implications=False, prot=False, full_prot=False, selection_size=1000, opt_allow_recursion=False, use_noro=False, use_faugere=False, ll=False, opt_linear_algebra_in_last_block=True, max_generators=None, red_tail_deg_growth=True, modified_linear_algebra=True, matrix_prefix='', draw_matrices=False)
symmGB_F2_python(G, deg_bound=1000000000000, over_deg_bound=0, use_faugere=False, use_noro=False, opt_lazy=True, opt_red_tail=True, max_growth=2.0, step_factor=1.0, implications=False, prot=False, full_prot=False, selection_size=1000, opt_exchange=True, opt_allow_recursion=False, ll=False, opt_linear_algebra_in_last_block=True, max_generators=None, red_tail_deg_growth=True, matrix_prefix='mat', modified_linear_algebra=True, draw_matrices=False, easy_linear_polynomials=True)
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)
warn(...)
Issue a warning, or maybe ignore it or raise an exception.
zero(...)
zero() -> BooleSet :
    Constant zero of the active ring
 
    C++ signature :
        polybori::BooleSet zero()

 
Data
        block_dlex = polybori.dynamic.PyPolyBoRi.OrderCode.block_dlex
block_dp_asc = polybori.dynamic.PyPolyBoRi.OrderCode.block_dp_asc
compatibility_mode = False
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
modules = {'StringIO': <module 'StringIO' from '/usr/lib64/python2.7/StringIO.pyc'>, 'UserDict': <module 'UserDict' from '/usr/lib64/python2.7/UserDict.pyc'>, '__builtin__': <module '__builtin__' (built-in)>, '__future__': <module '__future__' from '/usr/lib64/python2.7/__future__.pyc'>, '__main__': <module '__main__' from 'doc/python/genpythondoc.py'>, '_abcoll': <module '_abcoll' from '/usr/lib64/python2.7/_abcoll.pyc'>, '_bisect': <module '_bisect' from '/usr/lib64/python2.7/lib-dynload/_bisectmodule.so'>, '_codecs': <module '_codecs' (built-in)>, '_collections': <module '_collections' from '/usr/lib64/python2.7/lib-dynload/_collectionsmodule.so'>, '_functools': <module '_functools' from '/usr/lib64/python2.7/lib-dynload/_functoolsmodule.so'>, ...}
snake_pattern = <_sre.SRE_Pattern object>