polybori.blocks
index
../../../../lib/python2.7/dist-packages/polybori/blocks.py

 
Modules
       
sys

 
Classes
       
__builtin__.object
AlternatingBlock
AdderBlock
Block
HigherOrderBlock
IfThen
InOutBlock
MacroBlock
MultiBlock
PrefixedDictProxy

 
class AdderBlock(AlternatingBlock)
    
Method resolution order:
AdderBlock
AlternatingBlock
__builtin__.object

Methods defined here:
__init__(self, adder_bits, sums='s', carries='c', input1='a', input2='b', start_index=0)
implement(self, equations)
register(self, start, context)

Methods inherited from AlternatingBlock:
__getitem__(self, i)
__iter__(self)
__len__(self)

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

 
class AlternatingBlock(__builtin__.object)
    The Alternating Block class is used for doing tricky variable schemes,where base names vary, e.g. a(0),b(0),a(1),b(1),a(2),b(2)
 
  Methods defined here:
__getitem__(self, i)
__init__(self, var_names, size_per_variable, start_index=0, reverse=False)
__iter__(self)
__len__(self)
register(self, start, context)

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

 
class Block(__builtin__.object)
    The block class represents a block of variables <var_name>(start_index,...,start_index+size-1), it is the preferred block type for simple one-dimensional variable sets
 
  Methods defined here:
__getitem__(self, i)
__init__(self, var_name, size, start_index=0, reverse=False)
__iter__(self)
__len__(self)
register(self, start, context)

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

 
class HigherOrderBlock(__builtin__.object)
    HigherOrderBlocks are multidimensional blocks of variables, for each dimension a seperate start_index and size can be specified
 
  Methods defined here:
__getitem__(self, i)
__init__(self, var_name, size_tuple, start_index_tuple=None, reverse=False)
__iter__(self)
__len__(self)
register(self, start, context)

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

 
class IfThen(__builtin__.object)
     Methods defined here:
__init__(self, ifpart, thenpart, supposed_to_be_valid=True)
__str__(self)

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

 
class InOutBlock(__builtin__.object)
     Methods defined here:
__getitem__(self, i)
__init__(self, out_size, in_size, output='out', input='in', in_start_index=0, out_start_index=0, out_reverse=False, in_reverse=False)
__iter__(self)
__len__(self)
register(self, start, context)

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

 
class MacroBlock(__builtin__.object)
     Methods defined here:
__getitem__(self, i)
__init__(self, prefix)
__iter__(self)
__len__(self)
connect(self, combinations)
declare(self, blocks)
implement(self, equations)
register(self, start, context)
resolve(self, localname)

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

 
class MultiBlock(__builtin__.object)
     Methods defined here:
__getitem__(self, i)
__init__(self, sizes=[], var_names=['v'], start_indices=[], reverses=[])
__iter__(self)
__len__(self)
register(self, start, context)

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

 
class PrefixedDictProxy(__builtin__.object)
    docstring for PrefixedDictProxy
 
  Methods defined here:
__getitem__(self, k)
__init__(self, wrapped, prefix)
__setitem__(self, k, v)

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)
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)
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)
declare_block_scheme(blocks, context)
declare_ring(blocks, context)
Declare Ring is the preferred function to create a ring and declare a variable scheme, 
the number of variables is automatically determined,
usually you pass globals() as context argument to store the ring and the variable mapping.
Example
declare_ring([Block("x",10),Block("y",5)],globals())
gives  a ring with x(0..9),y(0..4) and registers the ring as r, 
and the variable blocks x and y in the context dictionary globals(), which consists of the global variables of the python module
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(i, t, supposed_to_be_valid=True)
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(...)
ll_red_nf( (Polynomial)arg1, (BooleSet)arg2) -> Polynomial :
 
    C++ signature :
        polybori::BoolePolynomial ll_red_nf(polybori::BoolePolynomial,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)
main()
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( (GroebnerStrategy)arg1, (Polynomial)arg2, (Monomial)arg3) -> Polynomial :
 
    C++ signature :
        polybori::BoolePolynomial nf3(polybori::groebner::GroebnerStrategy,polybori::BoolePolynomial,polybori::BooleMonomial)
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)
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_names_decorator(method)
set_variable_name(...)
set_variable_name( (int)arg1, (str)arg2) -> None :
 
    C++ signature :
        void set_variable_name(int,char const*)
shift(f, i)
spoly(...)
spoly( (Polynomial)arg1, (Polynomial)arg2) -> Polynomial :
    Compute s-Polynomial between two Polynomials
 
    C++ signature :
        polybori::BoolePolynomial spoly(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_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() -> 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
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'>, '_codecs': <module '_codecs' (built-in)>, '_collections': <module '_collections' (built-in)>, '_hashlib': <module '_hashlib' from '/usr/lib/python2.7/lib-dynload/_hashlib.arm-linux-gnueabihf.so'>, '_heapq': <module '_heapq' (built-in)>, ...}