polybori.gbcore | index ../../../../lib/python2.7/dist-packages/polybori/gbcore.py

Modules

``

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

``

build_groebner_basis_doc_string()

change_order_heuristic(d)

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)

filter_newstyle_options(func, **options)

filter_oldstyle_options(**options)

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_options_from_function(f)

groebner_basis(I, **kwds)
  `Computes a Groebner basis of a given ideal I, w.r.t options.
  Options are:
  easy_linear_polynomials : True
  prot : False
  interpolation_gb : False
  modified_linear_algebra : True
  convert_with_fglm_from_ring : None
  gauss_on_linear : True
  incremental : False
  preprocessor : None
  preprocess_only : False
  ll_constants : True
  convert_with_fglm_to_ring : None
  result_to_list : True
  heuristic : True
  clean_and_restart_algorithm : False
  llfirst : False
  other_ordering_first : False
  clean_arguments : True
  implementation : 'Python'
  invert : False
  redsb : True
  fix_deg_bound : True
  eliminate_identical_variables : True
  draw_matrices : False
  full_prot : False
  fglm_bound : 40000
  minsb : True
  deg_bound : False
  llfirstonthefly : False
  unique_ideal_generator : False
  Turn off heuristic by setting heuristic=False
  Additional options come from the actual buchberger implementation.
  In case of our standard Python implementation these are the following:
  faugere : False
  linear_algebra_in_last_block : True
  selection_size : 1000
  recursion : False
  ll : False
  over_deg_bound : 0
  step_factor : 1.0
  noro : False
  lazy : True
  max_growth : 2.0
  exchange : True
  red_tail_deg_growth : True
  matrix_prefix : 'mat'
  max_generators : None
  red_tail : True
  implications : False`

if_then_else(...)
  `if_then_else( (object)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, (Ring)arg2) -> Polynomial :
  C++ signature :
  polybori::BoolePolynomial mult_fast_sim_C(std::vector<polybori::BoolePolynomial, std::allocator<polybori::BoolePolynomial> >,polybori::BoolePolyRing)`

nf3(...)
  `nf3( (ReductionStrategy)arg1, (Polynomial)arg2, (Monomial)arg3) -> Polynomial :
  C++ signature :
  polybori::BoolePolynomial nf3(polybori::groebner::ReductionStrategy,polybori::BoolePolynomial,polybori::BooleMonomial)`

other_ordering_pre(I, option_set, kwds)
  `>>> from polybori.blocks import declare_ring
  >>> r = declare_ring(['x0', 'x1', 'x2', 'x3', 'x4'], globals())
  >>> id = [x1*x3 + x1 + x2*x3 + x3 + x4, x0*x3 + x0 + x1*x2 + x2 + 1, x1*x3 + x1*x4 + x3*x4 + x4 + 1, x0*x2 + x0*x4 + x1 + x3 + x4]
  >>> groebner_basis(id)
  [1]`

owns_one_constant(I)
  `Determines whether I contains the constant one polynomial.`

parallel_reduce(...)
  `parallel_reduce( (BoolePolynomialVector)arg1, (GroebnerStrategy)arg2, (object)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)`

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, (object)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)`

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 = r.variable
  >>> variety_size_from_gb([])
  1
  >>> variety_size_from_gb([Polynomial(0, r)])
  1
  >>> variety_size_from_gb([Polynomial(1, r)])
  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
  >>> variety_size_from_gb([x(1)*x(2), x(2)*x(3)])
  5.0
  >>> mons = [Monomial([r.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)

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/genpythondoc.py'>, '_abcoll': <module '_abcoll' from '/usr/lib/python2.7/_abcoll.pyc'>, '_codecs': <module '_codecs' (built-in)>, '_collections': <module '_collections' (built-in)>, '_functools': <module '_functools' (built-in)>, '_hashlib': <module '_hashlib' from '/usr/lib/python2.7/lib-dynload/_hashlib.i386-linux-gnu.so'>, ...}
snake_pattern = <_sre.SRE_Pattern object>