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

 
Modules
       
polybori.aes
re
sys
warnings

 
Classes
       
__builtin__.object
HeuristicalFunction

 
class HeuristicalFunction(__builtin__.object)
     Methods defined here:
__call__(self, *args, **kwds)
__init__(self, f, heuristic_function)

Data descriptors defined here:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
Functions
       
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)
change_order_heuristic(d)
change_ordering(...)
change_ordering( (int)arg1) -> None :
 
    C++ signature :
        void change_ordering(int)
clean_polys(I)
clean_polys_pre(I)
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)
easy_linear_polynomials_pre(I)
eliminate_identical_variables_pre(I, prot)
fix_deg_bound_post(I, state)
gauss_on_linear_pre(I, prot)
gb_with_pre_post_option(option, pre=None, post=None, if_not_option=(), default=False)
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()
groebner_basis(I, **kwds)
Computes a Groebner basis of a given ideal I, w.r.t options.
Options are:
faugere  :  False
interpolation_gb  :  False
convert_with_fglm_from_ring  :  None
linear_algebra_in_last_block  :  True
selection_size  :  1000
incremental  :  False
preprocess_only  :  False
heuristic  :  True
clean_arguments  :  True
implementation  :  'Python'
recursion  :  False
ll  :  False
prot  :  False
fix_deg_bound  :  True
eliminate_identical_variables  :  True
step_factor  :  1
noro  :  False
easy_linear_polynomials  :  True
lazy  :  True
max_growth  :  2.0
exchange  :  True
red_tail_deg_growth  :  True
matrix_prefix  :  'matrix'
red_tail  :  True
gauss_on_linear  :  True
modified_linear_algebra  :  True
ll_constants  :  True
result_to_list  :  True
aes  :  False
clean_and_restart_algorithm  :  False
llfirst  :  False
other_ordering_first  :  False
deg_bound  :  False
redsb  :  True
implications  :  False
draw_matrices  :  False
full_prot  :  False
minsb  :  True
invert  :  False
llfirstonthefly  :  False
unique_ideal_generator  :  False
Turn off heuristic by setting heuristic=False
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)
incremental_pre(I, prot, kwds)
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)
interpolation_gb_heuristic(d)
invert_all(I)
invert_all_post(I, state)
invert_all_pre(I)
linear_algebra_heuristic(d)
ll_constants_post(I, state)
ll_constants_pre(I)
ll_heuristic(d)
ll_is_good(I)
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)
llfirst_post(I, state, prot, kwds)
llfirst_pre(I, prot)
llfirstonthefly_pre(I, prot)
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)
minsb_post(I, state)
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()
other_ordering_pre(I, option_set, kwds)
owns_one_constant(I)
Determines whether I contains the constant one polynomial.
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)
redsb_post(I, state)
result_to_list_post(I, state)
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)
time(...)
time() -> floating point number
 
Return the current time in seconds since the Epoch.
Fractions of a second may be present if the system clock provides them.
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> >)
trivial_heuristic(d)
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)
variety_size_from_gb(I)
>>> r=Ring(100)
>>> x=Variable
>>> variety_size_from_gb([])
1
>>> variety_size_from_gb([0])
1
>>> variety_size_from_gb([1])
0.0
>>> variety_size_from_gb([x(1)])
1.0
>>> variety_size_from_gb([x(1), x(2)])
1.0
>>> variety_size_from_gb([x(1), x(2)*x(3)])
3.0
>>> variety_size_from_gb([x(1), x(1)*x(4), x(2)*x(3)])
6.0
>>> mons = [Monomial([Variable(i) for i in xrange(100) if i!=j])        for j in xrange(100)]
>>> variety_size_from_gb(mons)
1.2676506002282294e+30
want_interpolation_gb(G)
warn(...)
Issue a warning, or maybe ignore it or raise an exception.
with_heuristic(heuristic_function)
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/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'>, ...}
snake_pattern = <_sre.SRE_Pattern object>