Changeset 7588:cfcfa40e45e2

Timestamp:

11/11/07 13:02:05 (6 years ago)

Author:

Burcin Erocal <burcin@…>

Branch:

default

Message:

More PolyBoRi? wrappers.

Files:

• c_lib/include/pb_wrap.h (modified) (1 diff)
• sage/libs/polybori/decl.pxi (modified) (5 diffs)
• sage/rings/polynomial/polybori.pxd (modified) (1 diff)
• sage/rings/polynomial/polybori.pyx (modified) (7 diffs)

c_lib/include/pb_wrap.h

@@ -4 +4 @@
 #include "ccobject.h"
 #include <sstream>
+#include <vector>
 
 USING_NAMESPACE_PBORI
 USING_NAMESPACE_PBORIGB
 
+BoolePolynomial get_ith_gen(const GroebnerStrategy& strat, int i){
+    return strat.generators[i].p;
+}
+
+static int pairs_top_sugar(const GroebnerStrategy& strat){
+    if (strat.pairs.pairSetEmpty())
+        return -1;
+    else
+        return (strat.pairs.queue.top().sugar);
+}
+
+static std::vector<BoolePolynomial> someNextDegreeSpolys(GroebnerStrategy& strat, int n){
+    std::vector<BoolePolynomial> res;
+    assert(!(strat.pairs.pairSetEmpty()));
+    strat.pairs.cleanTopByChainCriterion();
+    deg_type deg=strat.pairs.queue.top().sugar;
+
+    while((!(strat.pairs.pairSetEmpty())) && \
+                (strat.pairs.queue.top().sugar<=deg) && (res.size()<n)){
+        assert(strat.pairs.queue.top().sugar==deg);
+        res.push_back(strat.nextSpoly());
+        strat.pairs.cleanTopByChainCriterion();
+    }
+    return res;
+}
+

sage/libs/polybori/decl.pxi

@@ -18 +18 @@
         PBNavigator (* elseBranch) ()
         int (* value "operator*")()
+        bint (* isConstant)()
+        bint (* isTerminated)()
 
     # non-allocating versions
@@ -99 +101 @@
         int (* lmDeg)()
         int (* length)()
+        int (* eliminationLength)()
         bint (* isZero)()
         bint (* isOne)()
@@ -110 +113 @@
         PBPolyIter (* orderedEnd)()
         void (* iadd "operator+=")(PBPoly right)
+        void (* iadd_PBMonom "operator+=")(PBMonom right)
         void (* imul "operator*=")(PBPoly right)
         void (* imul_monom "operator*=")(PBMonom right)
-
+        bint (* is_equal "operator==")(PBPoly right)
 
     # non-allocating versions
@@ -137 +141 @@
     object PBPoly_to_str "_to_PyString<BoolePolynomial>"(PBPoly *p)
 
-    ctypedef struct PBPoly_vector "std::vector<BoolePolynomial>":
+    ctypedef struct PBPolyVectorIter \
+            "std::vector<BoolePolynomial>::iterator ":
+        PBPoly (* value "operator*")()
+        int (* next "operator++")()
+
+    bint PBPolyVectorIter_equal "operator=="(PBPolyVectorIter lhs, \
+            PBPolyVectorIter rhs)
+
+    ctypedef struct PBPolyVector "std::vector<BoolePolynomial>":
         int (* size)()
         PBPoly (* get "operator[]")(int)
-
-    ctypedef struct GBStrategy "struct GroebnerStrategy":
+        PBPolyVectorIter (* begin)()
+        PBPolyVectorIter (* end)()
+        void (* push_back)(PBPoly val)
+
+    PBPolyVector* PBPolyVector_construct \
+            "Construct< std::vector<BoolePolynomial> >"(void *mem)
+    void PBPolyVector_destruct "Destruct< std::vector<BoolePolynomial> >"\
+            (PBPolyVector *mem)
+
+    ctypedef struct GBStrategy "GroebnerStrategy":
+        bint reduceByTailReduced
+        bint enabledLog
+        unsigned int reductionSteps
+        int normalForms
+        int currentDegree
+        int chainCriterions
+        int variableChainCriterions
+        int easyProductCriterions
+        int extendedProductCriterions
+        int averageLength
+        bint optRedTail
+        bint optLazy
+        bint optLL
+        bint optDelayNonMinimals
+        bint optBrutalReductions
+        bint optExchange
+        bint optAllowRecursion
+        bint optRedTailDegGrowth
+        bint optStepBounded
+        bint optLinearAlgebraInLastBlock
+        bint optRedTailInLastBlock 
+        PBSet monomials
+        PBSet llReductor
+        bint (* containsOne)()
+        int (* addGenerator)(PBPoly, bint is_impl)
         void (* addGeneratorDelayed)(PBPoly)
+        void (* addAsYouWish)(PBPoly)
         void (* symmGB_F2)()
-        PBPoly_vector (* minimalize)()
+        void (* cleanTopByChainCriterion "pairs.cleanTopByChainCriterion")()
+        int (* nGenerators "generators.size")()
+        int (* npairs "pairs.queue.size")()
+        PBPolyVector (* minimalize)()
+        PBPolyVector (* minimalizeAndTailReduce)()
+
+    int (* pairs_top_sugar)(GBStrategy strat)
+    PBPolyVector (* someNextDegreeSpolys)(GBStrategy strat, int n)
+
+    PBPoly GB_get_ith_gen "get_ith_gen" (GBStrategy strat, int i)
 
     # non-allocating versions
     GBStrategy* GBStrategy_construct "Construct<GroebnerStrategy>"(void *mem)
+    GBStrategy* GBStrategy_construct_gbstrategy \
+            "Construct_p<GroebnerStrategy, GroebnerStrategy>" \
+            (void *mem, GBStrategy strat)
+    PBPoly* PBPoly_construct_dd \
+            "Construct_p<BoolePolynomial, BoolePolyRing::dd_type>" \
+            (void *mem, PBDD d)
     void GBStrategy_destruct "Destruct<GroebnerStrategy>"(GBStrategy *mem)
 
@@ -158 +219 @@
 
     PBSet pb_mod_mon_set "mod_mon_set"(PBSet as, PBSet vs)
+
+    void pb_change_ordering "BoolePolyRing::changeOrdering" (ordercodes c)
+
+    PBPolyVector pb_parallel_reduce "parallel_reduce" \
+        (PBPolyVector inp, GBStrategy strat, int average_steps, double delay_f)
+

sage/rings/polynomial/polybori.pxd

@@ -38 +38 @@
     cdef BooleSet _obj
     cdef BooleanPolynomialRing _ring
+
+cdef class GroebnerStrategy:
+    cdef GBStrategy _S
+    cdef BooleanPolynomialRing _parent
+
+cdef class BooleanPolynomialVector:
+    cdef PBPolyVector _vec
+    cdef BooleanPolynomialRing _parent
+
+cdef class BooleanPolynomialVectorIterator:
+    cdef BooleanPolynomialRing _parent
+    cdef PBPolyVectorIter _iter
+    cdef PBPolyVector _obj

sage/rings/polynomial/polybori.pyx

@@ -210 +210 @@
         return new_BMI_from_PBMonomIter(self._M, self._M.begin())
 
-    def _mul_c_impl(left, MonoidElement right):
+    cdef MonoidElement _mul_c_impl(left, MonoidElement right):
         cdef BooleanMonomial m = new_BM_from_PBMonom(\
                 (<BooleanMonomial>left)._parent, (<BooleanMonomial>left)._M)
         m._M.imul( (<BooleanMonomial>right)._M )
         return m
+
+    def __add__(self, right):
+        cdef BooleanPolynomial res
+        if PY_TYPE_CHECK(right, BooleanMonomial):
+            res = new_BP_from_PBMonom( (<BooleanMonomial>self)._parent._ring, \
+                                            (<BooleanMonomial>self)._M)
+            res._P.iadd_PBMonom((<BooleanMonomial>right)._M)
+            return res
+        else:
+            #FIXME
+            raise NotImplementedError, "Adding %s and %s is not supported." % \
+                                            (type(self), type(right))
+        
 
 cdef inline BooleanMonomial new_BM(parent):
@@ -292 +305 @@
         p._P.imul( (<BooleanPolynomial>right)._P )
         return p
-
+    
+    def is_equal(self, BooleanPolynomial right):
+        #FIXME: change this to replace == operator
+        return self._P.is_equal(right._P)
+    
     def __iter__(self):
         return new_BPI_from_PBPolyIter(self, self._P.orderedBegin())
@@ -356 +373 @@
         return new_BM_from_PBMonom(self._parent._monom_monoid, self._P.usedVariables())
 
+    def elimination_length(self):
+        return self._P.eliminationLength()
+
     def __len__(self):
         return self._P.length()
@@ -365 +385 @@
         if name == 'diagram':
             return new_DD_from_PBDD(self._P.diagram())
+        elif name == 'deg':
+            return self.total_degree
+        elif name == 'elength':
+            return self.elimination_length
         elif name == 'lead':
             return self.lm
@@ -414 +438 @@
     cdef PBPoly t
     cdef BooleanPolynomial p, r
-    cdef PBPoly_vector vec
+    cdef PBPolyVector vec
     cdef GBStrategy strat
 
@@ -585 +609 @@
         return new_CN_from_PBNavigator(self._N.thenBranch())
 
+    def constant(self):
+        return self._N.isConstant()
+
+    def terminalOne(self):
+        return self._N.isTerminated()
+
+cdef class BooleanPolynomialVector:
+    def __init__(self):
+        PBPolyVector_construct(&self._vec) 
+        self._parent = get_cring()
+
+    def __dealloc__(self):
+        PBPolyVector_destruct(&self._vec)
+
+    def __iter__(self):
+        #return new_BPVI_from_PBPolyVectorIter(self._parent, self._vec, 
+        #    self._vec.begin())
+        return BooleanPolynomialVectorIterator(self._parent, self)
+
+    def __len__(self):
+        return self._vec.size()
+
+    def __getitem__(self, ind):
+        return new_BP_from_PBPoly(self._parent, self._vec.get(ind))
+
+    def append(self, BooleanPolynomial poly):
+        self._vec.push_back(poly._P)
+
+cdef inline BooleanPolynomialVector new_BPV_from_PBPolyVector(\
+        BooleanPolynomialRing parent, PBPolyVector juice):
+    cdef BooleanPolynomialVector m
+    m = <BooleanPolynomialVector>PY_NEW(BooleanPolynomialVector)
+    m._vec = juice
+    m._parent = parent
+    return m
+
+cdef class BooleanPolynomialVectorIterator:
+    def __init__(self, BooleanPolynomialRing parent, 
+                                    BooleanPolynomialVector vector):
+        self._parent = parent
+        self._obj = vector._vec
+        self._iter = self._obj.begin()
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        cdef PBPoly val
+        if PBPolyVectorIter_equal(self._iter, self._obj.end()):
+            raise StopIteration
+
+        val = self._iter.value()
+        self._iter.next()
+        return new_BP_from_PBPoly(self._parent, val)
+
+cdef inline BooleanPolynomialVectorIterator new_BPVI_from_PBPolyVectorIter(\
+        BooleanPolynomialRing parent, PBPolyVector juice, PBPolyVectorIter itr):
+    """
+    Construct a new BooleanMonomialIterator
+    """
+    cdef BooleanPolynomialVectorIterator m
+    m = <BooleanPolynomialVectorIterator>PY_NEW(BooleanPolynomialVectorIterator)
+    m._obj = juice
+    m._iter = itr
+    m._parent = parent
+    return m
+
+
+cdef class GroebnerStrategy:
+    def __init__(self, param = None):
+        self._parent = get_cring()
+        if PY_TYPE_CHECK(param, GroebnerStrategy):
+            GBStrategy_construct_gbstrategy(&self._S, 
+                    (<GroebnerStrategy>param)._S)
+        else: 
+            GBStrategy_construct(&self._S)
+
+    def __dealloc__(self):
+        GBStrategy_destruct(&self._S)
+
+    def addGeneratorDelayed(self, BooleanPolynomial p):
+        self._S.addGeneratorDelayed(p._P)
+
+    def addGenerator(self, BooleanPolynomial p, bint is_impl=False):
+        return self._S.addGenerator(p._P, is_impl)
+
+    def addAsYouWish(self, BooleanPolynomial p):
+        self._S.addAsYouWish(p._P)
+
+    def cleanTopByChainCriterion(self):
+        self._S.cleanTopByChainCriterion()
+
+    def symmGB_F2(self):
+        self._S.symmGB_F2()
+
+    def containsOne(self):
+        return self._S.containsOne()
+
+    def minimalize(self):
+        cdef PBPolyVector v = self._S.minimalize()
+        return new_BPVI_from_PBPolyVectorIter(self._parent, v, v.begin())
+
+    def minimalizeAndTailReduce(self):
+        cdef PBPolyVector v = self._S.minimalizeAndTailReduce()
+        return new_BPVI_from_PBPolyVectorIter(self._parent, v, v.begin())
+
+    def npairs(self):
+        return self._S.npairs()
+
+    def topSugar(self):
+        return pairs_top_sugar(self._S)
+
+    def someSpolysInNextDegree(self, n):
+        cdef PBPolyVector v = someNextDegreeSpolys(self._S, n)
+        return new_BPV_from_PBPolyVector(self._parent, v)
+
+    def __len__(self):
+        return self._S.nGenerators()
+
+    def __getitem__(self, int i):
+        return new_BP_from_PBPoly(self._parent, GB_get_ith_gen(self._S, i))
+
+    def __getattr__(self, name):
+        if name is 'enabledLog':
+            return self._S.enabledLog
+        if name is 'reductionSteps':
+            return self._S.reductionSteps
+        if name is 'normalForms':
+            return self._S.normalForms
+        if name is 'currentDegree':
+            return self._S.currentDegree
+        if name is 'chainCriterions':
+            return self._S.chainCriterions
+        if name is 'variableChainCriterions':
+            return self._S.variableChainCriterions
+        if name is 'easyProductCriterions':
+            return self._S.easyProductCriterions
+        if name is 'extendedProductCriterions':
+            return self._S.extendedProductCriterions
+        if name is 'averageLength':
+            return self._S.averageLength
+        if name is 'optRedTail':
+            return self._S.optRedTail
+        if name is 'optLazy':
+            return self._S.optLazy
+        if name is 'optLL':
+            return self._S.optLL
+        if name is 'optDelayNonMinimals':
+            return self._S.optDelayNonMinimals
+        if name is 'optBrutalReductions':
+            return self._S.optBrutalReductions
+        if name is 'optExchange':
+            return self._S.optExchange
+        if name is 'optAllowRecursion':
+            return self._S.optAllowRecursion
+        if name is 'optRedTailDegGrowth':
+            return self._S.optRedTailDegGrowth
+        if name is 'optStepBounded':
+            return self._S.optStepBounded
+        if name is 'optLinearAlgebraInLastBlock':
+            return self._S.optLinearAlgebraInLastBlock
+        if name is 'optRedTailInLastBlock':
+            return self._S.optRedTailInLastBlock,
+        if name is 'reduceByTailReduced':
+            return self._S.reduceByTailReduced
+        if name is 'monomials':
+            return new_BS_from_PBSet(self._S.monomials)
+        if name is 'llReductor':
+            return new_BS_from_PBSet(self._S.llReductor)
+        else:
+            raise AttributeError, name 
+        
+    def __setattr__(self, name, val):
+        if name is 'enabledLog':
+            self._S.enabledLog = val
+        elif name is 'reductionSteps':
+            self._S.reductionSteps = val
+        elif name is 'normalForms':
+            self._S.normalForms = val
+        elif name is 'currentDegree':
+            self._S.currentDegree = val
+        elif name is 'chainCriterions':
+            self._S.chainCriterions = val
+        elif name is 'variableChainCriterions':
+            self._S.variableChainCriterions = val
+        elif name is 'easyProductCriterions':
+            self._S.easyProductCriterions = val
+        elif name is 'extendedProductCriterions':
+            self._S.extendedProductCriterions = val
+        elif name is 'averageLength':
+            self._S.averageLength = val
+        elif name == 'optRedTail':
+            self._S.optRedTail = val
+        elif name is 'optLazy':
+            self._S.optLazy = val
+        elif name is 'optLL':
+            self._S.optLL = val
+        elif name is 'optDelayNonMinimals':
+            self._S.optDelayNonMinimals = val
+        elif name is 'optBrutalReductions':
+            self._S.optBrutalReductions = val
+        elif name is 'optExchange':
+            self._S.optExchange = val
+        elif name is 'optAllowRecursion':
+            self._S.optAllowRecursion = val
+        elif name is 'optRedTailDegGrowth':
+            self._S.optRedTailDegGrowth = val
+        elif name is 'optStepBounded':
+            self._S.optStepBounded = val
+        elif name is 'optLinearAlgebraInLastBlock':
+            self._S.optLinearAlgebraInLastBlock = val
+        elif name is 'optRedTailInLastBlock':
+            self._S.optRedTailInLastBlock = val
+        elif name is 'reduceByTailReduced':
+            self._S.reduceByTailReduced = val
+        else:
+            raise AttributeError, name 
+
 cdef inline CCuddNavigator new_CN_from_PBNavigator(PBNavigator juice):
     """
@@ -615 +857 @@
     return new_BS_from_PBSet(b)
 
+def get_order_code():
+    R = get_cring()
+    return (<BooleanPolynomialRing>R)._R.getOrderCode()
+
+def change_ordering(order):
+    pb_change_ordering(order)
+
+def parallel_reduce(BooleanPolynomialVector inp, GroebnerStrategy strat, \
+                                    int average_steps, double delay_f):
+    return new_BPV_from_PBPolyVector(inp._parent, \
+        pb_parallel_reduce(inp._vec, strat._S, average_steps, delay_f))
+    
 cdef BooleanPolynomialRing cur_ring
 ring_callbacks = []