[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