[mathicgb] 369/393: Moved several classes closer to using MonoMonoid.

Doug Torrance dtorrance-guest at moszumanska.debian.org
Fri Apr 3 15:59:36 UTC 2015


This is an automated email from the git hooks/post-receive script.

dtorrance-guest pushed a commit to branch upstream
in repository mathicgb.

commit 90087766613cb0b3aaa3923a2bd503926989db3d
Author: Bjarke Hammersholt Roune <bjarkehr.code at gmail.com>
Date:   Tue Sep 17 17:00:44 2013 +0200

    Moved several classes closer to using MonoMonoid.
---
 src/mathicgb/F4MatrixBuilder.cpp   |  2 +-
 src/mathicgb/F4MatrixBuilder2.cpp  |  9 +++-
 src/mathicgb/MathicIO.hpp          |  2 +-
 src/mathicgb/MonoMonoid.hpp        |  8 ++++
 src/mathicgb/QuadMatrixBuilder.cpp | 90 +++++++++++++++++++-------------------
 src/mathicgb/QuadMatrixBuilder.hpp | 20 +++++----
 src/mathicgb/SPairs.cpp            | 42 +++++++++---------
 src/mathicgb/SPairs.hpp            |  8 ++--
 src/mathicgb/SigSPairQueue.cpp     | 64 +++++++++++++++------------
 src/mathicgb/SigSPairQueue.hpp     |  9 +++-
 src/mathicgb/SigSPairs.cpp         |  4 +-
 src/mathicgb/SigSPairs.hpp         |  9 +++-
 src/mathicgb/SignatureGB.cpp       | 57 +++++++++++++-----------
 src/mathicgb/SignatureGB.hpp       |  3 +-
 src/test/MathicIO.cpp              | 16 +++----
 src/test/MonoMonoid.cpp            | 56 +++++++++++++++---------
 16 files changed, 229 insertions(+), 170 deletions(-)

diff --git a/src/mathicgb/F4MatrixBuilder.cpp b/src/mathicgb/F4MatrixBuilder.cpp
index fd0796d..94b3ce2 100755
--- a/src/mathicgb/F4MatrixBuilder.cpp
+++ b/src/mathicgb/F4MatrixBuilder.cpp
@@ -242,7 +242,7 @@ auto F4MatrixBuilder::createColumn(
 
   // The column really does not exist, so we need to create it
   monoid().multiply(monoA, monoB, mTmp);
-  if (!monoid().hasAmpleCapacity(mTmp))
+  if (!monoid().hasAmpleCapacity(*mTmp))
     mathic::reportError("Monomial exponent overflow in F4MatrixBuilder.");
 
   // look for a reducer of mTmp
diff --git a/src/mathicgb/F4MatrixBuilder2.cpp b/src/mathicgb/F4MatrixBuilder2.cpp
index dcd4f40..ad1025a 100755
--- a/src/mathicgb/F4MatrixBuilder2.cpp
+++ b/src/mathicgb/F4MatrixBuilder2.cpp
@@ -20,6 +20,13 @@ MATHICGB_NAMESPACE_BEGIN
 
 class F4MatrixBuilder2::Builder {
 public:
+  typedef PolyRing::Monoid Monoid;
+  typedef Monoid::Mono Mono;
+  typedef Monoid::MonoRef MonoRef;
+  typedef Monoid::ConstMonoRef ConstMonoRef;
+  typedef Monoid::MonoPtr MonoPtr;
+  typedef Monoid::ConstMonoPtr ConstMonoPtr;
+
   typedef SparseMatrix::ColIndex ColIndex;
   typedef SparseMatrix::Scalar Scalar;
   typedef MonomialMap<ColIndex> Map;
@@ -306,7 +313,7 @@ public:
 
     // The column really does not exist, so we need to create it
     monoid().multiply(monoA, monoB, mTmp);
-    if (!monoid().hasAmpleCapacity(mTmp))
+    if (!monoid().hasAmpleCapacity(*mTmp))
       mathic::reportError("Monomial exponent overflow in F4MatrixBuilder2.");
 
     // look for a reducer of mTmp
diff --git a/src/mathicgb/MathicIO.hpp b/src/mathicgb/MathicIO.hpp
index 8dd2f39..c7980a0 100755
--- a/src/mathicgb/MathicIO.hpp
+++ b/src/mathicgb/MathicIO.hpp
@@ -385,7 +385,7 @@ Poly MathicIO<M, BF>::readPoly(
     if (!p.isZero() && !in.peekSign())
       in.expect('+', '-');
     readTerm(ring, readComponent, coef, mono, in);
-    p.appendTerm(coef.value(), mono);
+    p.appendTerm(coef.value(), Monoid::toOld(*mono));
   } while (!in.peekWhite() && !in.matchEOF());
   return std::move(p);
 }
diff --git a/src/mathicgb/MonoMonoid.hpp b/src/mathicgb/MonoMonoid.hpp
index a1b65d0..ff7d22c 100755
--- a/src/mathicgb/MonoMonoid.hpp
+++ b/src/mathicgb/MonoMonoid.hpp
@@ -1314,6 +1314,7 @@ public:
     }
 
     operator MonoPtr() const {return ptr();}
+    operator ConstMonoPtr() const {return ptr();}
 
     /// @todo: Get rid of this as soon as all code has been migrated
     /// to observe the ptr/ref distinction. Kill it with fire!
@@ -1322,6 +1323,13 @@ public:
       return *mMono;
     }
 
+    /// @todo: Get rid of this as soon as all code has been migrated
+    /// to observe the ptr/ref distinction. Kill it with fire!
+    operator ConstMonoRef() const {
+      MATHICGB_ASSERT(!isNull());
+      return *mMono;
+    }
+
   private:
     friend class MonoMonoid;
 
diff --git a/src/mathicgb/QuadMatrixBuilder.cpp b/src/mathicgb/QuadMatrixBuilder.cpp
index 805e868..a058c8e 100755
--- a/src/mathicgb/QuadMatrixBuilder.cpp
+++ b/src/mathicgb/QuadMatrixBuilder.cpp
@@ -4,6 +4,7 @@
 #include "QuadMatrixBuilder.hpp"
 
 #include "QuadMatrix.hpp"
+#include "ScopeExit.hpp"
 #include <mathic.h>
 #include <sstream>
 
@@ -41,15 +42,15 @@ namespace {
   /// purpose of this function is to avoid code duplication. It is a            
   /// template in order to avoid referring to private types of
   /// QuadMatrixBuilder.
-  template<class ToMono, class ToCol>
+  template<class ToMono, class ToCol, class Monoid>
   std::pair<QuadMatrixBuilder::LeftRightColIndex, ConstMonomial>
   createCol(
-    const_monomial mono,
+    typename Monoid::ConstMonoRef mono,
     SparseMatrix& top,
     SparseMatrix& bottom,
     ToMono& toMonomial,
     ToCol& toCol,
-    const PolyRing& ring,
+    const Monoid& monoid,
     const bool left
   ) {
     MATHICGB_ASSERT(typename ToCol::Reader(toCol).find(mono).first == 0);
@@ -59,59 +60,60 @@ namespace {
     if (colCount == std::numeric_limits<QuadMatrixBuilder::ColIndex>::max())
       throw std::overflow_error("Too many columns in QuadMatrixBuilder");
 
-    // allocate memory in toMonomial now to avoid bad_alloc later
+    // allocate memory in toMonomial now to ensure no bad_alloc later
     toMonomial.emplace_back(nullptr);
-    monomial copied = ring.allocMonomial();
-    ring.monomialCopy(mono, copied);
-    std::pair<QuadMatrixBuilder::LeftRightColIndex, ConstMonomial> p;
-    try {
-      auto inserted = toCol.insert(std::make_pair(
-          copied, QuadMatrixBuilder::LeftRightColIndex(colCount, left))
-      );
-      MATHICGB_ASSERT(inserted.second);
-      MATHICGB_ASSERT(inserted.first.first != 0);
-      auto p(inserted.first);
-      toMonomial.back() = copied;
-
-      MATHICGB_ASSERT(ring.monoid().equalHintTrue(copied, *p.second));
-      MATHICGB_ASSERT(*p.first == QuadMatrixBuilder::LeftRightColIndex(colCount, left));
-
-      auto ptr = const_cast<exponent*>(Monoid::toOld(*p.second));
-      return std::make_pair(*p.first, ptr);
-    } catch (...) {
-      toMonomial.pop_back();
-      ring.freeMonomial(copied);
-      throw;
-    }
+    MATHICGB_SCOPE_EXIT(toMonomialGuard) {toMonomial.pop_back();};
+    auto copied = monoid.alloc();
+    monoid.copy(mono, copied);
+    auto inserted = toCol.insert(
+      std::make_pair(
+        copied.ptr(),
+        QuadMatrixBuilder::LeftRightColIndex(colCount, left)
+      )
+    );
+    MATHICGB_ASSERT(inserted.second);
+    MATHICGB_ASSERT(inserted.first.first != 0);
+    auto p(inserted.first);
+    toMonomial.back() = copied;
+
+    MATHICGB_ASSERT(monoid.equalHintTrue(*copied, *p.second));
+    MATHICGB_ASSERT(*p.first == QuadMatrixBuilder::LeftRightColIndex(colCount, left));
+
+    auto ptr = const_cast<exponent*>(Monoid::toOld(*p.second));
+    toMonomialGuard.dismiss();
+    copied.release();
+    return std::make_pair(*p.first, ptr);
   }
 }
 
 std::pair<QuadMatrixBuilder::LeftRightColIndex, ConstMonomial>
 QuadMatrixBuilder::createColumnLeft(
-  const_monomial monomialToBeCopied
+  ConstMonoRef monomialToBeCopied
 ) {
-  return createCol
-    (monomialToBeCopied,
-     mTopLeft,
-     mBottomLeft,
-     mMonomialsLeft,
-     mMonomialToCol,
-     ring(),
-     true);
+  return createCol(
+    monomialToBeCopied,
+    mTopLeft,
+    mBottomLeft,
+    mMonomialsLeft,
+    mMonomialToCol,
+    monoid(),
+    true
+  );
 }
 
 std::pair<QuadMatrixBuilder::LeftRightColIndex, ConstMonomial>
 QuadMatrixBuilder::createColumnRight(
-  const_monomial monomialToBeCopied
+  ConstMonoRef monomialToBeCopied
 ) {
-  return createCol
-    (monomialToBeCopied,
-     mTopRight,
-     mBottomRight,
-     mMonomialsRight,
-     mMonomialToCol,
-     ring(),
-     false);
+  return createCol(
+    monomialToBeCopied,
+    mTopRight,
+    mBottomRight,
+    mMonomialsRight,
+    mMonomialToCol,
+    monoid(),
+    false
+  );
 }
 
 QuadMatrix QuadMatrixBuilder::buildMatrixAndClear() {
diff --git a/src/mathicgb/QuadMatrixBuilder.hpp b/src/mathicgb/QuadMatrixBuilder.hpp
index 4d3c634..c623e02 100755
--- a/src/mathicgb/QuadMatrixBuilder.hpp
+++ b/src/mathicgb/QuadMatrixBuilder.hpp
@@ -22,7 +22,7 @@ class QuadMatrix;
 /// swapped out - it only follows the builder pattern in that it is a
 /// class that allows step-wise construction of a final product.
 class QuadMatrixBuilder {
- public:
+public:
   typedef PolyRing::Monoid Monoid;
   typedef Monoid::Mono Mono;
   typedef Monoid::MonoRef MonoRef;
@@ -42,6 +42,7 @@ class QuadMatrixBuilder {
   public:
     LeftRightColIndex():
       mRawIndex(std::numeric_limits<ColIndex>::max()), mLeft(false) {}
+
     LeftRightColIndex(ColIndex index, bool left):
       mRawIndex(index), mLeft(left)
     {}
@@ -169,17 +170,17 @@ class QuadMatrixBuilder {
   // and to avoid the need for the client to immediately construct a
   // LeftRightColIndex based on the return value.
 
-  /** Creates a new column associated to the monomial
-    monomialToBeCopied to the left matrices. There must not already
-    exist a column for this monomial on the left or on the right. */
+  /// Creates a new column associated to the monomial
+  /// monomialToBeCopied to the left matrices. There must not already
+  /// exist a column for this monomial on the left or on the right.
   std::pair<QuadMatrixBuilder::LeftRightColIndex, ConstMonomial>
-  createColumnLeft(const_monomial monomialToBeCopied);
+  createColumnLeft(ConstMonoRef monomialToBeCopied);
 
-  /** Creates a new column associated to the monomial monomialToBeCopied
-    to the right matrices. There must not already exist a column for
-    this monomial on the left or on the right. */
+  /// Creates a new column associated to the monomial monomialToBeCopied
+  /// to the right matrices. There must not already exist a column for
+  /// this monomial on the left or on the right.
   std::pair<QuadMatrixBuilder::LeftRightColIndex, ConstMonomial>
-  createColumnRight(const_monomial monomialToBeCopied);
+  createColumnRight(ConstMonoRef monomialToBeCopied);
 
   // *** Querying columns
 
@@ -189,6 +190,7 @@ class QuadMatrixBuilder {
   const SparseMatrix& bottomRight() const {return mBottomRight;}
 
   const PolyRing& ring() const {return mMonomialToCol.ring();}
+  const Monoid& monoid() const {return ring().monoid();}
 
   /// Returns the built matrix and sets the builder to a state
   /// with no columns and no rows.
diff --git a/src/mathicgb/SPairs.cpp b/src/mathicgb/SPairs.cpp
index 3dd4d04..57e2a41 100755
--- a/src/mathicgb/SPairs.cpp
+++ b/src/mathicgb/SPairs.cpp
@@ -51,15 +51,15 @@ std::pair<size_t, size_t> SPairs::pop() {
       continue;
     }
     auto lcm = bareMonoid().alloc(); // todo: just keep one around instead
-    bareMonoid().copy(orderMonoid(), mQueue.topPairData(), lcm);
+    bareMonoid().copy(orderMonoid(), *mQueue.topPairData(), *lcm);
     mQueue.pop();
 
     MATHICGB_ASSERT(bareMonoid().isLcm(
       monoid(), mBasis.leadMonomial(p.first),
       monoid(), mBasis.leadMonomial(p.second),
-      lcm
+      *lcm
     ));
-    if (!advancedBuchbergerLcmCriterion(p.first, p.second, lcm)) {
+    if (!advancedBuchbergerLcmCriterion(p.first, p.second, *lcm)) {
       mEliminated.setBit(p.first, p.second, true);
       return p;
     }
@@ -78,25 +78,25 @@ std::pair<size_t, size_t> SPairs::pop(exponent& w) {
     if (mBasis.retired(p.first) || mBasis.retired(p.second))
       continue;
     auto lcm = bareMonoid().alloc(); // todo: just keep one around instead
-    bareMonoid().copy(orderMonoid(), mQueue.topPairData(), lcm);
+    bareMonoid().copy(orderMonoid(), *mQueue.topPairData(), *lcm);
 
     MATHICGB_ASSERT(bareMonoid().isLcm(
       monoid(), mBasis.leadMonomial(p.first),
       monoid(), mBasis.leadMonomial(p.second),
-      lcm
+      *lcm
     ));
-    if (advancedBuchbergerLcmCriterion(p.first, p.second, lcm))
+    if (advancedBuchbergerLcmCriterion(p.first, p.second, *lcm))
       continue;
     if (w == 0)
-      w = bareMonoid().degree(lcm);
-    else if (w != bareMonoid().degree(lcm))
+      w = bareMonoid().degree(*lcm);
+    else if (w != bareMonoid().degree(*lcm))
       break;
     mQueue.pop();
     mEliminated.setBit(p.first, p.second, true);
     MATHICGB_IF_STREAM_LOG(SPairLcm) {
       stream << "Scheduling S-pair with lcm ";
       MathicIO<BareMonoid>().writeMonomial
-        (bareMonoid(), BareMonoid::HasComponent, lcm, stream);
+        (bareMonoid(), BareMonoid::HasComponent, *lcm, stream);
       stream << '.' << std::endl;
     };
     return p;
@@ -239,13 +239,13 @@ void SPairs::addPairs(size_t newGen) {
       mEliminated.setBit(newGen, oldGen, true);
       continue;
     }
-    mBareMonoid.lcm(monoid(), newLead, monoid(), oldLead, lcm);
-    if (simpleBuchbergerLcmCriterion(newGen, oldGen, lcm)) {
+    mBareMonoid.lcm(monoid(), newLead, monoid(), oldLead, *lcm);
+    if (simpleBuchbergerLcmCriterion(newGen, oldGen, *lcm)) {
       mEliminated.setBit(newGen, oldGen, true);
       continue;
     }
 
-    prePairMonos.push_back(bareMonoid(), lcm);
+    prePairMonos.push_back(bareMonoid(), *lcm);
     prePairs.emplace_back
       (prePairMonos.back().ptr(), static_cast<Queue::Index>(oldGen));
   }
@@ -254,7 +254,7 @@ void SPairs::addPairs(size_t newGen) {
     [&](const PrePair& a, const PrePair& b)
   {
     return mQueue.configuration().compare
-      (b.second, newGen, *b.first, a.second, newGen, *a.first);
+      (b.second, newGen, b.first, a.second, newGen, a.first);
   });
   mQueue.addColumnDescending
 	(makeSecondIterator(prePairs.begin()), makeSecondIterator(prePairs.end()));
@@ -436,14 +436,14 @@ bool SPairs::simpleBuchbergerLcmCriterionSlow(size_t a, size_t b) const {
   bareMonoid().lcm(
     monoid(), mBasis.leadMonomial(a),
     monoid(), mBasis.leadMonomial(b),
-    lcmAB
+    *lcmAB
   );
   size_t stop = mBasis.size();
   size_t i = 0;
   for (; i < stop; ++i) {
     if (mBasis.retired(i))
       continue;
-    if (!bareMonoid().divides(monoid(), mBasis.leadMonomial(i), lcmAB))
+    if (!bareMonoid().divides(monoid(), mBasis.leadMonomial(i), *lcmAB))
       continue;
     if (i == a || i == b)
       continue;
@@ -451,9 +451,9 @@ bool SPairs::simpleBuchbergerLcmCriterionSlow(size_t a, size_t b) const {
       bareMonoid().lcm(
         monoid(), mBasis.leadMonomial(a),
         monoid(), mBasis.leadMonomial(i),
-        lcm
+        *lcm
       );
-      if (bareMonoid().equal(lcmAB, lcm))
+      if (bareMonoid().equal(*lcmAB, *lcm))
         continue;
     }
 
@@ -461,9 +461,9 @@ bool SPairs::simpleBuchbergerLcmCriterionSlow(size_t a, size_t b) const {
       bareMonoid().lcm(
         monoid(), mBasis.leadMonomial(b),
         monoid(), mBasis.leadMonomial(i),
-        lcm
+        *lcm
       );
-      if (bareMonoid().equal(lcmAB, lcm))
+      if (bareMonoid().equal(*lcmAB, *lcm))
         continue;
     }
     break;
@@ -608,7 +608,7 @@ bool SPairs::advancedBuchbergerLcmCriterionSlow(size_t a, size_t b) const {
   for (size_t i = 0; i != stop; ++i) {
     if (mBasis.retired(i))
       continue;
-    if (!monoid().divides(mBasis.leadMonomial(i), lcmAB))
+    if (!monoid().divides(mBasis.leadMonomial(i), *lcmAB))
       continue;
     Connection con = NotConnected;
     if (i == a) {
@@ -641,7 +641,7 @@ bool SPairs::advancedBuchbergerLcmCriterionSlow(size_t a, size_t b) const {
 
       const_monomial const leadOther = mBasis.leadMonomial(other);
       monoid().lcm(leadNode, leadOther, lcm);
-      if (!eliminated(node.first, other) && monoid().equal(lcm, lcmAB))
+      if (!eliminated(node.first, other) && monoid().equal(*lcm, *lcmAB))
         continue; // not an edge in G
       
       if (graph[i].second == NotConnected) {
diff --git a/src/mathicgb/SPairs.hpp b/src/mathicgb/SPairs.hpp
index bbd911b..8bfef5d 100755
--- a/src/mathicgb/SPairs.hpp
+++ b/src/mathicgb/SPairs.hpp
@@ -182,10 +182,10 @@ private:
 
     typedef bool CompareResult;
     bool compare(
-      size_t colA, size_t rowA, OrderMonoid::ConstMonoRef a,
-      size_t colB, size_t rowB, OrderMonoid::ConstMonoRef b
-      ) const {
-      const auto cmp = orderMonoid().compare(a, b);
+      size_t colA, size_t rowA, OrderMonoid::ConstMonoPtr a,
+      size_t colB, size_t rowB, OrderMonoid::ConstMonoPtr b
+    ) const {
+      const auto cmp = orderMonoid().compare(*a, *b);
       if (cmp == GT)
         return true;
       if (cmp == LT)
diff --git a/src/mathicgb/SigSPairQueue.cpp b/src/mathicgb/SigSPairQueue.cpp
index 1e894e8..0d6fbe2 100755
--- a/src/mathicgb/SigSPairQueue.cpp
+++ b/src/mathicgb/SigSPairQueue.cpp
@@ -16,7 +16,7 @@ namespace {
 
     Comparer(const Monoid& monoid): mMonoid(monoid) {}
     bool operator()(const PreSPair& a, const PreSPair& b) const {
-      return mMonoid.lessThan(a.signature, b.signature);
+      return mMonoid.lessThan(*a.signature, *b.signature);
     }
   private:
     const Monoid& mMonoid;
@@ -57,30 +57,33 @@ public:
   ConcreteSigSPairQueue(SigPolyBasis const& basis):
   mPairQueue(Configuration(basis)) {}
 
-  virtual monomial popSignature(Pairs& pairs) {
+  virtual Mono popSignature(Pairs& pairs) {
     pairs.clear();
     if (mPairQueue.empty())
       return 0;
-    monomial sig = ring().allocMonomial();
-    ring().monomialCopy(mPairQueue.topPairData(), sig);
+    auto sig = monoid().alloc();
+    monoid().copy(*mPairQueue.topPairData(), *sig);
     do {
       pairs.push_back(mPairQueue.topPair());
       mPairQueue.pop();
-    } while
-        (!mPairQueue.empty() && ring().monomialEQ(mPairQueue.topPairData(), sig));
+    } while (
+      !mPairQueue.empty() &&
+      monoid().equal(*mPairQueue.topPairData(), *sig)
+    );
     return sig;
   }
 
   virtual void pushPairs(size_t pairWith, IndexSigs& pairs) {
 #ifdef DEBUG
-    monomial tmp = ring().allocMonomial();
-    for (size_t i = 0; i < pairs.size(); ++i) {
-      MATHICGB_ASSERT(pairs[i].i < columnCount());
-      mPairQueue.configuration().computePairData
-        (columnCount(), pairs[i].i, tmp);
-      MATHICGB_ASSERT(ring().monomialEQ(tmp, pairs[i].signature));
+    {
+      auto tmp = monoid().alloc();
+      for (size_t i = 0; i < pairs.size(); ++i) {
+        MATHICGB_ASSERT(pairs[i].i < columnCount());
+        mPairQueue.configuration().computePairData
+          (columnCount(), pairs[i].i, tmp.ptr());
+        MATHICGB_ASSERT(monoid().equal(*tmp, *pairs[i].signature));
+      }
     }
-    ring().freeMonomial(tmp);
 #endif
 
     if (columnCount() >= std::numeric_limits<BigIndex>::max())
@@ -94,9 +97,8 @@ public:
     mPairQueue.addColumnDescending(Iter(pairs.begin()), Iter(pairs.end()));
     
     // free signatures
-    std::vector<PreSPair>::iterator end = pairs.end();
-    for (std::vector<PreSPair>::iterator it = pairs.begin(); it != end; ++it)
-      ring().freeMonomial(it->signature);
+    for (auto& spair : pairs)
+      monoid().freeRaw(spair.signature);
     pairs.clear();
   }
   
@@ -117,26 +119,30 @@ private:
   public:
     Configuration(SigPolyBasis const& basis): mBasis(basis) {}
 
-    typedef monomial PairData;
-    void computePairData(size_t col, size_t row, monomial sig) {
+    typedef MonoPtr PairData;
+    void computePairData(size_t col, size_t row, PairData sig) {
       MATHICGB_ASSERT(mBasis.ratioCompare(col, row) != EQ);
       // ensure that ratio(col) > ratio(row)
       if (mBasis.ratioCompare(col, row) == LT)
         std::swap(col, row);
-      mBasis.ring().monomialFindSignature
-        (mBasis.getLeadMonomial(col),
-         mBasis.getLeadMonomial(row),
-         mBasis.getSignature(col), sig);
+      monoid().colonMultiply(
+        mBasis.getLeadMonomial(col),
+        mBasis.getLeadMonomial(row),
+        mBasis.getSignature(col),
+        *sig
+      );
     }
 
     typedef bool CompareResult;
-    bool compare(int colA, int rowA, const_monomial a,
-                 int colB, int rowB, const_monomial b) const {
-      return mBasis.ring().monoid().lessThan(b, a);
+    bool compare(int colA, int rowA, PairData a,
+                 int colB, int rowB, PairData b) const {
+      return mBasis.ring().monoid().lessThan(*b, *a);
     }
     bool cmpLessThan(bool v) const {return v;}
 
     SigPolyBasis const& basis() const {return mBasis;}
+    const PolyRing& ring() const {return basis().ring();}
+    const Monoid& monoid() const {return ring().monoid();}
 
   private:
     SigPolyBasis const& mBasis;
@@ -147,7 +153,9 @@ private:
   const SigPolyBasis& basis() const {
     return mPairQueue.configuration().basis();
   }
-  PolyRing const& ring() const {return basis().ring();}
+
+  const PolyRing& ring() const {return basis().ring();}
+  const Monoid& monoid() const {return ring().monoid();}
 
   mathic::PairQueue<Configuration> mPairQueue;
   friend struct
@@ -195,9 +203,9 @@ namespace mathic {
         Index row,
         mgb::ConcreteSigSPairQueue::Configuration& conf
       ) {
-        MATHICGB_ASSERT(pd != 0);
+        MATHICGB_ASSERT(pd != nullptr);
         MATHICGB_ASSERT(col > row);
-        conf.basis().ring().freeMonomial(*pd);
+        conf.monoid().freeRaw(*pd);
       }
     };
   }
diff --git a/src/mathicgb/SigSPairQueue.hpp b/src/mathicgb/SigSPairQueue.hpp
index f745633..651ce8b 100755
--- a/src/mathicgb/SigSPairQueue.hpp
+++ b/src/mathicgb/SigSPairQueue.hpp
@@ -14,7 +14,7 @@ typedef unsigned int BigIndex;
 
 struct PreSPair {
   BigIndex i;
-  monomial signature;
+  PolyRing::Monoid::MonoPtr signature;
 };
 
 class SigPolyBasis;
@@ -26,6 +26,11 @@ class SigPolyBasis;
 class SigSPairQueue {
 public:
   typedef PolyRing::Monoid Monoid;
+  typedef Monoid::Mono Mono;
+  typedef Monoid::MonoRef MonoRef;
+  typedef Monoid::ConstMonoRef ConstMonoRef;
+  typedef Monoid::MonoPtr MonoPtr;
+  typedef Monoid::ConstMonoPtr ConstMonoPtr;
 
   virtual ~SigSPairQueue();
 
@@ -41,7 +46,7 @@ public:
   //
   // This class does not have an empty() method on purpose - you are
   // supposed to call this method until it returns null.
-  virtual monomial popSignature(Pairs& pairs) = 0;
+  virtual Mono popSignature(Pairs& pairs) = 0;
 
   // If (x, sig) is an element of pairsConsumed then (pairWith, x) is
   // added to the queue. sig must be the signature of the S-pair
diff --git a/src/mathicgb/SigSPairs.cpp b/src/mathicgb/SigSPairs.cpp
index 4b7e2f1..253dc83 100755
--- a/src/mathicgb/SigSPairs.cpp
+++ b/src/mathicgb/SigSPairs.cpp
@@ -42,8 +42,8 @@ void SigSPairs::newSyzygy(const_monomial sig) {
   MATHICGB_ASSERT(Hsyz->member(sig));
 }
 
-monomial SigSPairs::popSignature(PairContainer& pairs) {
-  monomial sig = mQueue->popSignature(pairs);
+auto SigSPairs::popSignature(PairContainer& pairs) -> Mono {
+  auto sig = mQueue->popSignature(pairs);
   if (!sig.isNull()) {
     size_t const pairCount = pairs.size();
     mStats.spairsFinal += pairCount;
diff --git a/src/mathicgb/SigSPairs.hpp b/src/mathicgb/SigSPairs.hpp
index e3e9ce3..6fd5bfb 100755
--- a/src/mathicgb/SigSPairs.hpp
+++ b/src/mathicgb/SigSPairs.hpp
@@ -22,6 +22,13 @@ class Reducer;
 class SigSPairs
 {
 public:
+  typedef PolyRing::Monoid Monoid;
+  typedef Monoid::Mono Mono;
+  typedef Monoid::MonoRef MonoRef;
+  typedef Monoid::ConstMonoRef ConstMonoRef;
+  typedef Monoid::MonoPtr MonoPtr;
+  typedef Monoid::ConstMonoPtr ConstMonoPtr;
+
   SigSPairs(
     const PolyRing *R0,
     const SigPolyBasis *GB0,
@@ -34,7 +41,7 @@ public:
   ~SigSPairs();
 
   typedef std::vector<std::pair<size_t, size_t> > PairContainer;
-  monomial popSignature(PairContainer& pairs);
+  Mono popSignature(PairContainer& pairs);
 
   // fills in all the S-pairs with i.
   void newPairs(size_t i);
diff --git a/src/mathicgb/SignatureGB.cpp b/src/mathicgb/SignatureGB.cpp
index 283b9a5..9cf1f2a 100755
--- a/src/mathicgb/SignatureGB.cpp
+++ b/src/mathicgb/SignatureGB.cpp
@@ -100,15 +100,14 @@ void SignatureGB::computeGrobnerBasis()
       size_t sigs = 0;
       size_t syzygySigs = 0;
       while (true) {
-        monomial sig = SP->popSignature(mSpairTmp);
+        auto sig = SP->popSignature(mSpairTmp);
         if (sig.isNull())
           break;
         ++sigs;
-        if (Hsyz->member(sig))
+        if (Hsyz->member(*sig))
           ++syzygySigs;
         else
-          GB->minimalLeadInSig(sig);
-        R->freeMonomial(sig);
+          GB->minimalLeadInSig(Monoid::toOld(*sig));
       }
       const double syzygyRatio = static_cast<double>(syzygySigs) / sigs;
       std::cerr << "*** Early exit statistics ***\n"
@@ -146,39 +145,43 @@ void SignatureGB::computeGrobnerBasis()
 }
 
 bool SignatureGB::processSPair
-  (monomial sig, const SigSPairs::PairContainer& pairs)
+  (Mono sig, const SigSPairs::PairContainer& pairs)
 {
   MATHICGB_ASSERT(!pairs.empty());
 
   // the module term to reduce is multiple * GB->getSignature(gen)
-  size_t gen = GB->minimalLeadInSig(sig);
+  size_t gen = GB->minimalLeadInSig(Monoid::toOld(*sig));
   MATHICGB_ASSERT(gen != static_cast<size_t>(-1));
   monomial multiple = R->allocMonomial();
-  R->monomialDivide(sig, GB->getSignature(gen), multiple);
+  monoid().divide(GB->getSignature(gen), *sig, multiple);
   GB->basis().usedAsStart(gen);
 
   // reduce multiple * GB->getSignature(gen)
-  auto f = reducer->regularReduce(sig, multiple, gen, *GB);
+  auto f = reducer->regularReduce(*sig, multiple, gen, *GB);
 
   R->freeMonomial(multiple);
 
   if (f == nullptr) { // singular reduction
-    R->freeMonomial(sig);
     MATHICGB_LOG(SigSPairFinal) << "   eliminated by singular criterion.\n";
     return true;
   }
 
   if (f->isZero()) { // reduction to zero
-    Hsyz->insert(sig);
-    SP->newSyzygy(sig);
+    // todo: what are the correct ownership relations here?
+    auto ptr = sig.release();
+    Hsyz->insert(*ptr);
+    SP->newSyzygy(Monoid::toOld(*ptr));
     SP->setKnownSyzygies(mSpairTmp);
     MATHICGB_LOG(SigSPairFinal) << "   s-reduced to zero.\n";
     return false;
   }
 
   // new basis element
-  MATHICGB_ASSERT(!GB->isSingularTopReducibleSlow(*f, sig));
-  GB->insert(sig, std::move(f));
+  MATHICGB_ASSERT(!GB->isSingularTopReducibleSlow(*f, Monoid::toOld(*sig)));
+
+  // todo: what are the correct ownership relations here?
+  auto ptr = sig.release();
+  GB->insert(Monoid::toOld(*ptr), std::move(f));
 
   MATHICGB_LOG(SigSPairFinal) << "   s-reduced to new basis element.\n";
 
@@ -192,9 +195,8 @@ bool SignatureGB::processSPair
   return true;
 }
 
-bool SignatureGB::step()
-{
-  monomial sig = SP->popSignature(mSpairTmp);
+bool SignatureGB::step() {
+  auto sig = SP->popSignature(mSpairTmp);
   if (sig.isNull())
     return false;
   ++stats_sPairSignaturesDone;
@@ -202,26 +204,27 @@ bool SignatureGB::step()
 
   MATHICGB_IF_STREAM_LOG(SigSPairFinal) {
     stream << "Final processing of signature ";
-    R->monomialDisplay(stream, sig);
+    R->monomialDisplay(stream, Monoid::toOld(*sig));
     stream << '\n';
   };
 
-  if (Hsyz->member(sig)) {
+  if (Hsyz->member(*sig)) {
     ++stats_SignatureCriterionLate;
     SP->setKnownSyzygies(mSpairTmp);
-    R->freeMonomial(sig);
     MATHICGB_LOG(SigSPairFinal) << "   eliminated by signature criterion.\n";
     return true;
   }
 
-  while (!mKoszuls.empty() && R->monoid().lessThan(mKoszuls.top(), sig))
+  while (!mKoszuls.empty() && R->monoid().lessThan(mKoszuls.top(), *sig))
     mKoszuls.pop();
   
-  if (!mKoszuls.empty() && R->monoid().equal(mKoszuls.top(), sig)) {
+  if (!mKoszuls.empty() && R->monoid().equal(mKoszuls.top(), *sig)) {
     ++stats_koszulEliminated;
     // This signature is of a syzygy that is not in Hsyz, so add it
-    Hsyz->insert(sig);
-    SP->newSyzygy(sig);
+    // todo: what are the correct ownership relations here?
+    auto ptr = sig.release();
+    Hsyz->insert(*ptr);
+    SP->newSyzygy(Monoid::toOld(*ptr));
     SP->setKnownSyzygies(mSpairTmp);
     MATHICGB_LOG(SigSPairFinal) << "   eliminated by Koszul criterion.\n";
     return true;
@@ -234,8 +237,10 @@ bool SignatureGB::step()
       const_monomial b = GB->getLeadMonomial(it->second);
       if (R->monomialRelativelyPrime(a, b)) {
         ++stats_relativelyPrimeEliminated;
-        Hsyz->insert(sig);
-        SP->newSyzygy(sig);
+        // todo: what are the correct ownership relations here?
+        auto ptr = sig.release();
+        Hsyz->insert(*ptr);
+        SP->newSyzygy(Monoid::toOld(*ptr));
         SP->setKnownSyzygies(mSpairTmp);
         MATHICGB_LOG(SigSPairFinal) <<
           "   eliminated by relatively prime criterion.\n";
@@ -253,7 +258,7 @@ bool SignatureGB::step()
 
   // Reduce the pair
   ++stats_pairsReduced;
-  if (!processSPair(sig, mSpairTmp) || !mPostponeKoszul)
+  if (!processSPair(std::move(sig), mSpairTmp) || !mPostponeKoszul)
     return true;
   for (auto it = mSpairTmp.begin(); it != mSpairTmp.end(); ++it) {
     std::pair<size_t, size_t> p = *it;
diff --git a/src/mathicgb/SignatureGB.hpp b/src/mathicgb/SignatureGB.hpp
index d7f800e..9e44dab 100755
--- a/src/mathicgb/SignatureGB.hpp
+++ b/src/mathicgb/SignatureGB.hpp
@@ -20,6 +20,7 @@ class SigSPairs;
 class SignatureGB {
 public:
   typedef PolyRing::Monoid Monoid;
+  typedef Monoid::Mono Mono;
   typedef Monoid::ConstMonoRef ConstMonoRef;
   typedef Monoid::ConstMonoPtr ConstMonoPtr;
   typedef Monoid::MonoVector MonoVector;
@@ -67,7 +68,7 @@ private:
 
 
 
-  bool processSPair(monomial sig, const SigSPairs::PairContainer& pairs);
+  bool processSPair(Mono sig, const SigSPairs::PairContainer& pairs);
   bool step();
 
   const PolyRing *R;
diff --git a/src/test/MathicIO.cpp b/src/test/MathicIO.cpp
index 5159497..5e65def 100755
--- a/src/test/MathicIO.cpp
+++ b/src/test/MathicIO.cpp
@@ -90,21 +90,21 @@ TEST(MathicIO, ReadWriteMonomial) {
     // read monomial from string
     auto monoRead = m.alloc();
     Scanner in(str);
-    MathicIO<>().readMonomial(m, doComponent, monoRead, in);
+    MathicIO<>().readMonomial(m, doComponent, *monoRead, in);
 
     // directly make monomial
     auto monoSet = m.alloc();
     if (var1 != -1)
-      m.setExponent(var1, exp1, monoSet);
+      m.setExponent(var1, exp1, *monoSet);
     if (var2 != -1)
-      m.setExponent(var2, exp2, monoSet);
+      m.setExponent(var2, exp2, *monoSet);
     if (doComponent)
-      m.setComponent(component, monoSet);
-    ASSERT_TRUE(m.equal(monoRead, monoSet)) << "Str: " << str;
+      m.setComponent(component, *monoSet);
+    ASSERT_TRUE(m.equal(*monoRead, *monoSet)) << "Str: " << str;
 
     // print monomial
     std::ostringstream out;
-    MathicIO<>().writeMonomial(m, doComponent, monoRead, out);
+    MathicIO<>().writeMonomial(m, doComponent, *monoRead, out);
     const auto correctStr = canonicalStr == 0 ? str : canonicalStr;
     ASSERT_EQ(correctStr, out.str());
   };
@@ -224,13 +224,13 @@ TEST(MathicIO, ReadWriteTerm) {
       auto monoRead = m.alloc();
       Coefficient readCoef = f.zero();
       Scanner in(str);
-      MathicIO<>().readTerm(ring, doComponent, readCoef, monoRead, in);
+      MathicIO<>().readTerm(ring, doComponent, readCoef, *monoRead, in);
       
       ASSERT_EQ(coef, readCoef.value());
 
       // print monomial
       std::ostringstream out;
-      MathicIO<>().writeTerm(ring, doComponent, readCoef, monoRead, out);
+      MathicIO<>().writeTerm(ring, doComponent, readCoef, *monoRead, out);
       const auto correctStr = outStr == 0 ? inStr : outStr;
       ASSERT_EQ(correctStr, out.str());
     }
diff --git a/src/test/MonoMonoid.cpp b/src/test/MonoMonoid.cpp
index c9a4676..b261570 100755
--- a/src/test/MonoMonoid.cpp
+++ b/src/test/MonoMonoid.cpp
@@ -266,12 +266,12 @@ TYPED_TEST(Monoids, MonoPool) {
       pool.alloc();
       pool.free(pool.alloc());
       auto m1 = pool.alloc();
-      ASSERT_TRUE(monoid.isIdentity(m1));
+      ASSERT_TRUE(monoid.isIdentity(*m1));
       auto m2 = pool.alloc();
-      ASSERT_TRUE(monoid.isIdentity(m2));
+      ASSERT_TRUE(monoid.isIdentity(*m2));
       for (VarIndex var = 0; var < varCount; ++var) {
-        monoid.setExponent(var, 1, m1);
-        monoid.setExponent(var, 1, m2);
+        monoid.setExponent(var, 1, *m1);
+        monoid.setExponent(var, 1, *m2);
       }
       if (i > 10) {
         using std::swap;
@@ -285,7 +285,7 @@ TYPED_TEST(Monoids, MonoPool) {
     int i = 0;
     do {
       MATHICGB_ASSERT(!monos[i].isNull());
-      ASSERT_FALSE(monoid.isIdentity(monos[i]));
+      ASSERT_FALSE(monoid.isIdentity(*monos[i]));
       pool.free(std::move(monos[i]));
       ASSERT_TRUE(monos[i].isNull());
       pool.free(std::move(monos[i]));
@@ -300,13 +300,13 @@ TYPED_TEST(Monoids, MonoPool) {
 
     for (int i = 0; i < count; ++i) {
       monos[i] = pool.alloc();
-      ASSERT_TRUE(monoid.isIdentity(monos[i]));
+      ASSERT_TRUE(monoid.isIdentity(*monos[i]));
       for (VarIndex var = 0; var < varCount; ++var)
-        monoid.setExponent(var, expect(i, var, varCount), monos[i]);
+        monoid.setExponent(var, expect(i, var, varCount), *monos[i]);
     }
     for (int i = 0; i < count; ++i) {
       for (VarIndex var = 0; var < varCount; ++var) {
-        ASSERT_EQ(expect(i, var, varCount), monoid.exponent(monos[i], var));
+        ASSERT_EQ(expect(i, var, varCount), monoid.exponent(*monos[i], var));
       }
     }
     // everything should be free'd now. Let's do all that again.
@@ -403,7 +403,8 @@ TYPED_TEST(Monoids, MultiplyDivide) {
   typedef TypeParam Monoid;
   Monoid m(49);
   typename Monoid::MonoPool pool(m);
-  auto mono = pool.alloc();
+  auto monoOwner = pool.alloc();
+  auto mono = *monoOwner;
   auto check = [&](const char* const str, const bool component) -> void {
     if (component && !Monoid::HasComponent)
       return;
@@ -528,8 +529,10 @@ TYPED_TEST(Monoids, LcmColon) {
   Monoid mNonConst(49);
   auto& m = mNonConst;
   typename Monoid::MonoPool pool(m);
-  auto mono = pool.alloc();
-  auto mono2 = pool.alloc();
+  auto monoOwner = pool.alloc();
+  auto mono = *monoOwner;
+  auto mono2Owner = pool.alloc();
+  auto mono2 = *mono2Owner;
   auto check = [&](const char* const str, const bool component) -> void {
     if (component && !Monoid::HasComponent)
       return;
@@ -791,7 +794,8 @@ TYPED_TEST(Monoids, HasAmpleCapacityTotalDegree) {
       ASSERT_EQ(varCount, m.varCount());
 
       typename Monoid::MonoPool p(m);
-      auto mono = p.alloc();
+      auto monoOwner = p.alloc();
+      auto mono = *monoOwner;
       const auto last = m.varCount() - 1;
       const auto max = std::numeric_limits<Exponent>::max() / 2;
 
@@ -841,15 +845,25 @@ TYPED_TEST(Monoids, CopyEqualConversion) {
     Monoid some(Monoid::create(none));
     MonoidAll all(MonoidAll::create(some));
 
-    auto none1 = none.alloc();
-    auto none2 = none.alloc();
-    auto none3 = none.alloc();
-    auto some1 = some.alloc();
-    auto some2 = some.alloc();
-    auto some3 = some.alloc();
-    auto all1 = all.alloc();
-    auto all2 = all.alloc();
-    auto all3 = all.alloc();
+    auto none1Owner = none.alloc();
+    auto none2Owner = none.alloc();
+    auto none3Owner = none.alloc();
+    auto some1Owner = some.alloc();
+    auto some2Owner = some.alloc();
+    auto some3Owner = some.alloc();
+    auto all1Owner = all.alloc();
+    auto all2Owner = all.alloc();
+    auto all3Owner = all.alloc();
+
+    auto none1 = *none1Owner;
+    auto none2 = *none2Owner;
+    auto none3 = *none3Owner;
+    auto some1 = *some1Owner;
+    auto some2 = *some2Owner;
+    auto some3 = *some3Owner;
+    auto all1 = *all1Owner;
+    auto all2 = *all2Owner;
+    auto all3 = *all3Owner;
 
     none.setExponent(0, 1, none1);
     none.setExponent(varCount / 2, 2, none1);

-- 
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/debian-science/packages/mathicgb.git



More information about the debian-science-commits mailing list