| |
- from_fast_pickable(l, r=None)
- from_fast_pickable(l) undoes the operation to_fast_pickable. The first argument is an object created by to_fast_pickable.
For the specified format, see the documentation of to_fast_pickable.
The second argument is ring, in which this polynomial should be created.
INPUT:
see OUTPUT of to_fast_pickable
OUTPUT:
a list of Boolean polynomials
EXAMPLES:
>>> from polybori.PyPolyBoRi import Ring, Variable
>>> r=Ring(1000)
>>> x=Variable
>>> from_fast_pickable([[1], []])
[1]
>>> from_fast_pickable([[0], []])
[0]
>>> from_fast_pickable([[2], [(0, 1, 0)]])
[x(0)]
>>> from_fast_pickable([[2], [(1, 1, 0)]])
[x(1)]
>>> from_fast_pickable([[2], [(0, 1, 1)]])
[x(0) + 1]
>>> from_fast_pickable([[2], [(0, 3, 0), (1, 1, 0)]])
[x(0)*x(1)]
>>> from_fast_pickable([[2], [(0, 3, 3), (1, 1, 0)]])
[x(0)*x(1) + x(1)]
>>> from_fast_pickable([[2], [(0, 3, 4), (1, 1, 0), (2, 1, 0)]])
[x(0)*x(1) + x(2)]
>>> from_fast_pickable([[2, 0, 1, 4], [(0, 3, 0), (1, 1, 0), (3, 1, 0)]])
[x(0)*x(1), 0, 1, x(3)]
- global_ring(...)
- global_ring() -> Ring :
C++ signature :
polybori::BoolePolyRing {lvalue} global_ring()
- groebner_basis_first_finished(I, *l)
- INPUT:
- I ideal
- l: keyword dictionaries, which will be keyword arguments to groebner_basis.
OUTPUT:
- tries to compute groebner_basis(I, **kwd) for kwd in l
- returns the result of the first terminated computation
EXAMPLES:
>>> from polybori.PyPolyBoRi import Ring, Variable
>>> r=Ring(1000)
>>> x=Variable
>>> groebner_basis_first_finished([x(1)*x(2)+x(2)+x(1)],dict(heuristic=True), dict(heuristic=False))
[x(1), x(2)]
- 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)
- to_fast_pickable(l)
- to_fast_pickable(l) converts a list of polynomials into a builtin Python value, which is fast pickable and compact.
INPUT:
- a list of Boolean polynomials
OUTPUT:
It is converted to a tuple consisting of
- codes referring to the polynomials
- list of conversions of nodes.
The nodes are sorted, that
n occurs before n.else_branch(), n.then_branch()
Nodes are only listed, if they are not constant.
A node is converted in this way:
0 -> 0
1 -> 1
if_then_else(v,t,e) -> (v, index of then branch +2, index of else branch +2)
The shift of +2 is for the constant values implicitly contained in the list.
Each code c refers to the c-2-th position in the conversion list, if c >=2, else to
the corresponding Boolean constant if c in {0, 1}
EXAMPLES:
>>> from polybori.PyPolyBoRi import Ring, Variable
>>> r=Ring(1000)
>>> x=Variable
>>> to_fast_pickable([Polynomial(1)])
[[1], []]
>>> to_fast_pickable([Polynomial(0)])
[[0], []]
>>> to_fast_pickable([x(0)])
[[2], [(0, 1, 0)]]
>>> to_fast_pickable([x(0)*x(1)+x(1)])
[[2], [(0, 3, 3), (1, 1, 0)]]
>>> to_fast_pickable([x(1)])
[[2], [(1, 1, 0)]]
>>> to_fast_pickable([x(0)+1])
[[2], [(0, 1, 1)]]
>>> to_fast_pickable([x(0)*x(1)])
[[2], [(0, 3, 0), (1, 1, 0)]]
>>> to_fast_pickable([x(0)*x(1)+x(1)])
[[2], [(0, 3, 3), (1, 1, 0)]]
>>> to_fast_pickable([x(0)*x(1)+x(2)])
[[2], [(0, 3, 4), (1, 1, 0), (2, 1, 0)]]
>>> p=x(5)*x(23) + x(5)*x(24)*x(59) + x(5) + x(6)*x(23)*x(89) + x(6)*x(60)*x(89) + x(23) + x(24)*x(89) + x(24) + x(60)*x(89) + x(89) + 1
>>> from_fast_pickable(to_fast_pickable([p]))==[p]
True
>>> to_fast_pickable([x(0)*x(1), Polynomial(0), Polynomial(1), x(3)])
[[2, 0, 1, 4], [(0, 3, 0), (1, 1, 0), (3, 1, 0)]]
|