Changeset 7589:15d46848c593

Timestamp:

11/13/07 13:52:22 (6 years ago)

Author:

Burcin Erocal <burcin@…>

Branch:

default

Message:

More PolyBoRi?.

Files:

• c_lib/include/ccobject.h (modified) (1 diff)
• c_lib/include/pb_wrap.h (modified) (1 diff)
• sage/libs/polybori/decl.pxi (modified) (6 diffs)
• sage/rings/polynomial/polybori.pxd (modified) (2 diffs)
• sage/rings/polynomial/polybori.pyx (modified) (12 diffs)

c_lib/include/ccobject.h

@@ -51 +51 @@
 }
 
+/* Construct with three parameters */
+template <class T, class P, class R, class Q>
+T* Construct_ppp(void* mem, const P &d, const R &e, const Q &f){
+  return new(mem) T(d, e, f);
+}
+
 /* Destruct */
 template <class T>

c_lib/include/pb_wrap.h

@@ -3 +3 @@
 #include "nf.h"
 #include "ccobject.h"
+
+// M4RI 
+#define PACKED 1
+#include "M4RI/packedmatrix.h"
+#include "M4RI/grayflex.h"
+
 #include <sstream>
 #include <vector>

sage/libs/polybori/decl.pxi

@@ -38 +38 @@
 
     ctypedef struct PBRing "BoolePolyRing":
+        bint (* isDegreeOrder)()
         int (* nVariables)()
         PBDD (* variable)(int n)
@@ -48 +49 @@
         int (* next "operator++")()
         int (* hash)()
+
+    ctypedef struct PBVar "BooleVariable":
+        int (* index)()
+        bint (* is_equal "operator==")(PBVar right)
+
+    PBVar* PBVar_construct_int "Construct_p<BooleVariable, int>" \
+        (void *mem, int ind)
+
+    PBVar* PBVar_construct_pbvar "Construct_p<BooleVariable, BooleVariable>" \
+        (void *mem, PBVar v)
 
     ctypedef struct PBMonom "BooleMonomial":
@@ -63 +74 @@
     PBMonom* PBMonom_construct_pbmonom \
             "Construct_p<BooleMonomial, BooleMonomial>" (void *mem, PBMonom m)
+    PBMonom* PBMonom_construct_pbvar \
+            "Construct_p<BooleMonomial, BooleVariable>" (void *mem, PBVar m)
     PBMonom* PBMonom_construct_dd \
             "Construct_p<BoolePolynomial, BooleMonomial::dd_type>" (void *mem, PBDD m)
@@ -195 +208 @@
         PBPolyVector (* minimalize)()
         PBPolyVector (* minimalizeAndTailReduce)()
+        PBPolyVector (* faugereStepDense)(PBPolyVector v)
 
     int (* pairs_top_sugar)(GBStrategy strat)
@@ -211 +225 @@
     void GBStrategy_destruct "Destruct<GroebnerStrategy>"(GBStrategy *mem)
 
+    PBRing get_current_ring "BoolePolyRing::ring"()
 
     PBSet pb_recursively_insert "recursively_insert"(PBNavigator p, 
@@ -225 +240 @@
         (PBPolyVector inp, GBStrategy strat, int average_steps, double delay_f)
 
+    void pb_set_variable_name "BoolePolyRing::setRingVariableName" \
+        (int idx, char* varname) 
+
+    #M4RI initialization
+    void buildAllCodes()
+    void setupPackingMasks()

sage/rings/polynomial/polybori.pxd

@@ -25 +25 @@
 cdef class BooleanMonomial(MonoidElement):
     cdef PBMonom _M
+    cdef BooleanPolynomial _add_c_impl(BooleanMonomial left, BooleanMonomial right)
 
 cdef class BooleanMonomialIterator:
@@ -51 +52 @@
     cdef PBPolyVectorIter _iter
     cdef PBPolyVector _obj
+
+cdef class VariableBlock_base:
+    cdef int size
+    cdef int start_index
+    cdef int offset
+    cdef public object __name__
+
+cdef class BooleVariable:
+    cdef PBVar _V

sage/rings/polynomial/polybori.pyx

@@ -207 +207 @@
         return self._M.deg()
 
+    def __len__(BooleanMonomial self):
+        return self._M.deg()
+
     def __iter__(self):
         return new_BMI_from_PBMonomIter(self._M, self._M.begin())
@@ -216 +219 @@
         return m
 
+    cdef BooleanPolynomial _add_c_impl(BooleanMonomial left, BooleanMonomial right):
+        cdef BooleanPolynomial res
+        res = new_BP_from_PBMonom( (<BooleanMonomial>left)._parent._ring, \
+                                        (<BooleanMonomial>left)._M)
+        res._P.iadd_PBMonom((<BooleanMonomial>right)._M)
+        return res
+
     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))
+        if PY_TYPE_CHECK(self, BooleanMonomial) and \
+            PY_TYPE_CHECK(right, BooleanMonomial) and \
+            (<BooleanMonomial>self)._parent._ring is \
+                (<BooleanMonomial>right)._parent._ring:
+            return (<BooleanMonomial>self)._add_c_impl(right)
+
+        if PY_TYPE_CHECK(self, BooleanMonomial) and right == 1:
+            return (<BooleanMonomial>self)._add_c_impl(\
+                (<BooleanMonomial>self)._parent())
+
+        if self == 1 and PY_TYPE_CHECK(right, BooleanMonomial):
+            return (<BooleanMonomial>right)._add_c_impl(\
+                (<BooleanMonomial>right)._parent())
         
 
@@ -241 +254 @@
     cdef BooleanMonomial m = new_BM(parent)
     PBMonom_construct_pbmonom(&m._M,juice)
+    return m
+
+cdef inline BooleanMonomial new_BM_from_PBVar(parent, PBVar juice): 
+    cdef BooleanMonomial m = new_BM(parent)
+    PBMonom_construct_pbvar(&m._M,juice)
     return m
 
@@ -537 +555 @@
         PBSet_destruct(&self._S)
 
+    def __call__(self):
+        return self
+
     def empty(self):
         return self._S.emptiness()
@@ -567 +588 @@
     s = <BooleSet>PY_NEW(BooleSet)
     s._S = juice
+    return s
+
+cdef inline BooleSet new_BS_from_PBDD(PBDD juice):
+    """
+    Construct a new BooleSet
+    """
+    cdef BooleSet s
+    s = <BooleSet>PY_NEW(BooleSet)
+    PBSet_construct_dd(&s._S, juice)
     return s
 
@@ -707 +737 @@
         return self._S.containsOne()
 
+    def faugereStepDense(self, BooleanPolynomialVector v):
+        return new_BPV_from_PBPolyVector(self._parent, 
+                                    self._S.faugereStepDense(v._vec))
+
     def minimalize(self):
-        cdef PBPolyVector v = self._S.minimalize()
-        return new_BPVI_from_PBPolyVectorIter(self._parent, v, v.begin())
+        return new_BPV_from_PBPolyVector(self._parent, self._S.minimalize())
 
     def minimalizeAndTailReduce(self):
-        cdef PBPolyVector v = self._S.minimalizeAndTailReduce()
-        return new_BPVI_from_PBPolyVectorIter(self._parent, v, v.begin())
+        return new_BPV_from_PBPolyVector(self._parent, 
+                                    self._S.minimalizeAndTailReduce())
 
     def npairs(self):
@@ -772 +805 @@
         if name is 'optRedTailInLastBlock':
             return self._S.optRedTailInLastBlock,
-        if name is 'reduceByTailReduced':
+        if name is 'redByReduced':
             return self._S.reduceByTailReduced
         if name is 'monomials':
@@ -822 +855 @@
         elif name is 'optRedTailInLastBlock':
             self._S.optRedTailInLastBlock = val
-        elif name is 'reduceByTailReduced':
+        elif name is 'redByReduced':
             self._S.reduceByTailReduced = val
         else:
@@ -835 +868 @@
     n._N = juice
     return n
+
+cdef class BooleVariable:
+    def index(self):
+        return self._V.index()
+
+    def is_equal(self, BooleVariable other):
+        return self._V.is_equal(other._V)
+
+cdef inline BooleVariable new_BV_from_PBVar(PBVar juice):
+    """
+    Construct a new BooleVariable
+    """
+    cdef BooleVariable n
+    n = <BooleVariable>PY_NEW(BooleVariable)
+    n._V = juice
+    return n
+
+cdef inline BooleVariable new_BV_from_int(int juice):
+    """
+    Construct a new BooleVariable
+    """
+    cdef BooleVariable n
+    n = <BooleVariable>PY_NEW(BooleVariable)
+    PBVar_construct_int(&n._V, juice)
+    return n
+
+cdef class VariableBlock_base:
+    def __init__(self, size, start_index, offset):
+        self.size = size
+        self.start_index = start_index
+        self.offset = offset
+
+cdef class VariableBlockTrue(VariableBlock_base):
+    def __init__(self, size, start_index, offset):
+        VariableBlock_base.__init__(self, size, start_index, offset)
+
+    def __call__(self, int i):
+        cdef PBVar v
+        PBVar_construct_int(&v, self.offset+self.start_index+self.size-1-i)
+        return new_BM_from_PBVar(get_cring()._monom_monoid, v)
+
+cdef class VariableBlockFalse(VariableBlock_base):
+    def __init__(self, size, start_index, offset):
+        VariableBlock_base.__init__(self, size, start_index, offset)
+
+    def __call__(self, int i):
+        cdef PBVar v
+        PBVar_construct_int(&v, i-self.start_index+self.offset)
+        return new_BM_from_PBVar(get_cring()._monom_monoid, v)
+
+def VariableBlock(size, start_index, offset, reverse):
+    if reverse:
+        return VariableBlockFalse(size, start_index, offset)
+    else:
+        return VariableBlockTrue(size, start_index, offset)
+
+def init_M4RI():
+    buildAllCodes()
+    setupPackingMasks()
 
 def recursively_insert(CCuddNavigator n, int ind, CCuddNavigator m):
@@ -862 +954 @@
 
 def change_ordering(order):
+    global cur_ring
     pb_change_ordering(order)
+    cur_ring._R = get_current_ring()
 
 def parallel_reduce(BooleanPolynomialVector inp, GroebnerStrategy strat, \
@@ -869 +963 @@
         pb_parallel_reduce(inp._vec, strat._S, average_steps, delay_f))
     
+def have_degree_order(): 
+    global cur_ring 
+    return cur_ring._R.isDegreeOrder() 
+
+def set_variable_name( i, s):
+    pb_set_variable_name(i, s)
+
 cdef BooleanPolynomialRing cur_ring
 ring_callbacks = []
@@ -885 +986 @@
     global ring_callbacks
     ring_callbacks.append(func)
+
+init_M4RI()