polybori.blocks
index
../../../../lib/python2.6/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(...)
C++ signature:
VariableBlock(int, int, int, bool) -> boost::python::api::object
add_up_polynomials(...)
C++ signature:
add_up_polynomials(std::vector<polybori::BoolePolynomial, std::allocator<polybori::BoolePolynomial> >) -> polybori::BoolePolynomial
append_ring_block(...)
Append integer, which marks start of next block (for block orderings)
C++ signature:
    append_ring_block(int) -> void*
change_ordering(...)
C++ signature:
change_ordering(int) -> void*
contained_vars(...)
C++ signature:
contained_vars(polybori::BooleSet) -> polybori::BooleSet
count_double(...)
C++ signature:
count_double(polybori::BooleSet) -> double
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(...)
C++ signature:
get_order_code(void) -> int
global_ring(...)
C++ signature:
global_ring(void) -> polybori::BoolePolyRing
have_degree_order(...)
Determines, whether ring ordering is a degree ordering
C++ signature:
    have_degree_order(void) -> bool
if_then(i, t, supposed_to_be_valid=True)
if_then_else(...)
if-then else operator
C++ signature:
    if_then_else(int, polybori::BooleSet, polybori::BooleSet) -> polybori::BooleSet
 
if-then else operator
C++ signature:
    if_then_else(polybori::BooleVariable, polybori::BooleSet, polybori::BooleSet) -> polybori::BooleSet
interpolate(...)
C++ signature:
interpolate(polybori::BooleSet, polybori::BooleSet) -> polybori::BoolePolynomial
interpolate_smallest_lex(...)
C++ signature:
interpolate_smallest_lex(polybori::BooleSet, polybori::BooleSet) -> polybori::BoolePolynomial
ll_red_nf(...)
C++ signature:
ll_red_nf(polybori::BoolePolynomial, polybori::BooleSet) -> polybori::BoolePolynomial
ll_red_nf_noredsb(...)
C++ signature:
ll_red_nf_noredsb(polybori::BoolePolynomial, polybori::BooleSet) -> polybori::BoolePolynomial
main()
map_every_x_to_x_plus_one(...)
C++ signature:
map_every_x_to_x_plus_one(polybori::BoolePolynomial) -> polybori::BoolePolynomial
mapping(...)
C++ signature:
mapping(polybori::BoolePolynomial, polybori::BooleMonomial, polybori::BooleMonomial) -> polybori::BoolePolynomial
mod_mon_set(...)
C++ signature:
    mod_mon_set(polybori::BooleSet, polybori::BooleSet) -> polybori::BooleSet
C++ signature:
    mod_mon_set(polybori::BooleSet, polybori::BooleSet) -> polybori::BooleSet
mod_var_set(...)
C++ signature:
mod_var_set(polybori::BooleSet, polybori::BooleSet) -> polybori::BooleSet
mult_fast_sim_C(...)
C++ signature:
mult_fast_sim_C(std::vector<polybori::BoolePolynomial, std::allocator<polybori::BoolePolynomial> >) -> polybori::BoolePolynomial
nf3(...)
C++ signature:
nf3(polybori::groebner::GroebnerStrategy, polybori::BoolePolynomial, polybori::BooleMonomial) -> polybori::BoolePolynomial
number_of_variables(...)
Number of variables in the active ring
C++ signature:
    number_of_variables(void) -> unsigned int
one(...)
Constant one of the active ring
C++ signature:
    one(void) -> polybori::CDDInterface<polybori::CCuddZDD>
parallel_reduce(...)
C++ signature:
parallel_reduce(std::vector<polybori::BoolePolynomial, std::allocator<polybori::BoolePolynomial> >, polybori::groebner::GroebnerStrategy {lvalue}, int, double) -> std::vector<polybori::BoolePolynomial, std::allocator<polybori::BoolePolynomial> >
print_ring_info(...)
C++ signature:
print_ring_info(void) -> void*
random_set(...)
C++ signature:
random_set(polybori::BooleMonomial, unsigned int) -> polybori::BooleSet
recursively_insert(...)
C++ signature:
recursively_insert(polybori::CCuddNavigator, int, polybori::BooleSet) -> polybori::BooleSet
set_names_decorator(method)
set_variable_name(...)
C++ signature:
set_variable_name(int, char const*) -> void*
shift(f, i)
spoly(...)
Compute s-Polynomial between two Polynomials
C++ signature:
    spoly(polybori::BoolePolynomial, polybori::BoolePolynomial) -> polybori::BoolePolynomial
test_iterate_lex(...)
C++ signature:
test_iterate_lex(polybori::BoolePolynomial {lvalue}) -> unsigned long
test_iterate_ordered(...)
C++ signature:
test_iterate_ordered(polybori::BoolePolynomial {lvalue}) -> unsigned long
test_iterate_reference_ordered(...)
C++ signature:
test_iterate_reference_ordered(polybori::BoolePolynomial {lvalue}) -> unsigned long
testvalidstrat(...)
C++ signature:
testvalidstrat(polybori::groebner::GroebnerStrategy) -> void*
top_index(...)
C++ signature:
top_index(polybori::BooleSet) -> int
translate_indices(...)
C++ signature:
translate_indices(polybori::BoolePolynomial, std::vector<int, std::allocator<int> >) -> polybori::BoolePolynomial
variety_lex_groebner_basis(...)
C++ signature:
variety_lex_groebner_basis(polybori::BooleSet, polybori::BooleMonomial) -> std::vector<polybori::BoolePolynomial, std::allocator<polybori::BoolePolynomial> >
variety_lex_leading_terms(...)
C++ signature:
variety_lex_leading_terms(polybori::BooleSet, polybori::BooleMonomial) -> polybori::BooleSet
zero(...)
Constant zero of the active ring
C++ signature:
    zero(void) -> polybori::CDDInterface<polybori::CCuddZDD>

 
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.6/StringIO.pyc'>, 'UserDict': <module 'UserDict' from '/usr/lib/python2.6/UserDict.pyc'>, '__builtin__': <module '__builtin__' (built-in)>, '__future__': <module '__future__' from '/usr/lib/python2.6/__future__.pyc'>, '__main__': <module '__main__' from 'doc/python/genpythondoc.py'>, '_abcoll': <module '_abcoll' from '/usr/lib/python2.6/_abcoll.pyc'>, '_codecs': <module '_codecs' (built-in)>, '_collections': <module '_collections' (built-in)>, '_random': <module '_random' (built-in)>, '_sre': <module '_sre' (built-in)>, ...}