[mathicgb] 289/393: Simplified interface and implementation of FreeModuleOrder.
Doug Torrance
dtorrance-guest at moszumanska.debian.org
Fri Apr 3 15:59:22 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 191e6d1fdbb3437f04a8428f0db240d0aa09cb27
Author: Bjarke Hammersholt Roune <bjarkehr.code at gmail.com>
Date: Thu Apr 18 19:00:25 2013 -0400
Simplified interface and implementation of FreeModuleOrder.
---
src/mathicgb/BuchbergerAlg.cpp | 2 +-
src/mathicgb/FreeModuleOrder.cpp | 131 ++++++++++-----------------------------
src/mathicgb/FreeModuleOrder.hpp | 12 +---
src/mathicgb/PairTriangle.cpp | 2 +-
src/mathicgb/SignatureGB.cpp | 2 +-
src/test/F4MatrixBuilder.cpp | 2 +-
src/test/FreeModuleOrderTest.cpp | 4 +-
src/test/QuadMatrixBuilder.cpp | 2 +-
8 files changed, 42 insertions(+), 115 deletions(-)
diff --git a/src/mathicgb/BuchbergerAlg.cpp b/src/mathicgb/BuchbergerAlg.cpp
index 3217b6d..23648b0 100755
--- a/src/mathicgb/BuchbergerAlg.cpp
+++ b/src/mathicgb/BuchbergerAlg.cpp
@@ -24,7 +24,7 @@ BuchbergerAlg::BuchbergerAlg(
mUseAutoTopReduction(true),
mUseAutoTailReduction(false),
mRing(*ideal.getPolyRing()),
- mOrder(FreeModuleOrder::makeOrder(orderType, &ideal)),
+ mOrder(FreeModuleOrder::makeOrder(orderType, *ideal.getPolyRing())),
mReducer(reducer),
mBasis(mRing, *mOrder, DivisorLookup::makeFactory(
*ideal.getPolyRing(),
diff --git a/src/mathicgb/FreeModuleOrder.cpp b/src/mathicgb/FreeModuleOrder.cpp
index 2dd9c71..38a85eb 100755
--- a/src/mathicgb/FreeModuleOrder.cpp
+++ b/src/mathicgb/FreeModuleOrder.cpp
@@ -4,7 +4,6 @@
#include "FreeModuleOrder.hpp"
#include "Poly.hpp"
-#include "Ideal.hpp"
#include "SigSPairQueue.hpp"
#include "GroebnerBasis.hpp"
#include "PolyRing.hpp"
@@ -24,14 +23,13 @@
// ** Utility objects
namespace {
- // Comparer for scrambled signatures
template<class Cmp>
- class ScrambledComparer {
+ class Comparer {
public:
- ScrambledComparer(const Cmp& cmp): mCmp(cmp), mComparisons(0) {}
+ Comparer(const Cmp& cmp): mCmp(cmp), mComparisons(0) {}
bool operator()(const PreSPair& a, const PreSPair& b) const {
++mComparisons;
- return mCmp.scrambledLessThan(a.signature, b.signature);
+ return mCmp.signatureCompare(a.signature, b.signature) == LT;
}
size_t comparisons() const {return mComparisons;}
private:
@@ -88,13 +86,12 @@ namespace {
(mBasis.getLeadMonomial(col),
mBasis.getLeadMonomial(row),
mBasis.getSignature(col), sig);
- mCmp.scrambleSignatureForFastComparison(sig);
}
typedef bool CompareResult;
bool compare(int colA, int rowA, const_monomial a,
int colB, int rowB, const_monomial b) const {
- return mCmp.scrambledLessThan(b, a);
+ return mCmp.signatureCompare(b, a) == LT;
}
bool cmpLessThan(bool v) const {return v;}
@@ -125,7 +122,6 @@ namespace {
mPairQueue.pop();
} while
(!mPairQueue.empty() && ring().monomialEQ(mPairQueue.topPairData(), sig));
- comparer().unscrambleSignature(sig);
return sig;
}
@@ -136,7 +132,6 @@ namespace {
MATHICGB_ASSERT(pairs[i].i < columnCount());
mPairQueue.configuration().computePairData
(columnCount(), pairs[i].i, tmp);
- comparer().unscrambleSignature(tmp);
MATHICGB_ASSERT(ring().monomialEQ(tmp, pairs[i].signature));
}
ring().freeMonomial(tmp);
@@ -147,8 +142,7 @@ namespace {
("Too large basis element index in constructing S-pairs.");
// sort and insert new column
- ScrambledComparer<Cmp> cmp(comparer());
- comparer().scrambleSignaturesForFastComparison(pairs);
+ Comparer<Cmp> cmp(comparer());
std::sort(pairs.begin(), pairs.end(), cmp);
//mPreComparisons += cmp.comparisons();
//order().destructiveSort(pairs);
@@ -222,7 +216,7 @@ namespace mathic {
template<class Cmp>
class ConcreteOrder : public FreeModuleOrder {
public:
- ConcreteOrder(Cmp cmp): mCmp(cmp), mComparisons(0), mPreComparisons(0) {}
+ ConcreteOrder(const PolyRing& ring): mCmp(ring), mComparisons(0), mPreComparisons(0) {}
virtual ~ConcreteOrder() {}
virtual int signatureCompare(const_monomial sigA, const_monomial sigB) const {
@@ -239,17 +233,12 @@ public:
return mCmp.signatureCompare(sigA, monoB, sigB);
}
- virtual void sortAndScrambleSignatures(std::vector<PreSPair>& pairs) const {
- ScrambledComparer<Cmp> cmp(mCmp);
- mCmp.scrambleSignaturesForFastComparison(pairs);
+ virtual void sortSignatures(std::vector<PreSPair>& pairs) const {
+ Comparer<Cmp> cmp(mCmp);
std::sort(pairs.begin(), pairs.end(), cmp);
mPreComparisons += cmp.comparisons();
}
- virtual void appendBasisElement(const_monomial m) {
- mCmp.appendBasisElement(m);
- }
-
virtual std::string description() const {
return mCmp.description();
}
@@ -281,26 +270,17 @@ private:
// also applies to component, which is considered last.
class OrderA {
public:
- OrderA(const PolyRing* ring): mRing(ring) {}
+ OrderA(const PolyRing& ring): mRing(&ring) {}
int signatureCompare(const_monomial sigA, const_monomial sigB) const {
return mRing->monomialCompare(sigA, sigB);
}
- void scrambleSignatureForFastComparison(monomial sig) const {}
- void scrambleSignaturesForFastComparison(std::vector<PreSPair>& pairs) const {}
- bool scrambledLessThan(const_monomial sigA, const_monomial sigB) const {
- return mRing->monomialLT(sigA, sigB);
- }
- void unscrambleSignature(monomial sig) const {}
-
int signatureCompare(const_monomial sigA,
const_monomial monoB, const_monomial sigB) const {
return mRing->monomialCompare(sigA, monoB, sigB);
}
- void appendBasisElement(const_monomial) {}
-
char const* description() const {return "GrevLex IndexDown";}
private:
@@ -310,37 +290,20 @@ private:
class OrderC
{
public:
- OrderC(const Ideal* I):
- mRing(I->getPolyRing()),
- topindex(I->getPolyRing()->maxMonomialSize() - 2)
+ OrderC(const PolyRing& ring):
+ mRing(&ring), topindex(ring.maxMonomialSize() - 2)
{}
- void appendBasisElement(const_monomial m) {}
-
- void scrambleSignatureForFastComparison(monomial sig) const {}
- void scrambleSignaturesForFastComparison(std::vector<PreSPair>& pairs) const {}
- bool scrambledLessThan(const_monomial a, const_monomial b) const {
- return signatureCompare(a, b) == LT;
- }
- void unscrambleSignature(monomial sig) const {}
-
int signatureCompare(const_monomial sig, const_monomial sig2) const {
- int da = - sig[topindex];
- int db = -sig2[topindex];
- if (da > db) return GT;
- if (db > da) return LT;
- int cmp = *sig - *sig2;
+ const auto d = sig[topindex] - sig2[topindex];
+ if (d < 0) return GT;
+ if (d > 0) return LT;
+
+ const auto cmp = *sig - *sig2;
if (cmp < 0) return GT;
if (cmp > 0) return LT;
- auto a = sig;
- auto b = sig2;
- for (size_t i = topindex; i >= 1; i--) {
- int cmp = a[i] - b[i];
- if (cmp != 0)
- return cmp < 0 ? GT : LT;
- }
- return EQ;
+ return mRing->monomialCompare(sig, sig2);
}
int signatureCompare(
@@ -348,24 +311,15 @@ public:
const_monomial m2,
const_monomial sig2
) const {
- int da = - sig[topindex];
- int db = - m2[topindex];
- db += -sig2[topindex];
- if (da > db) return GT;
- if (db > da) return LT;
- int cmp = *sig - *sig2;
+ const auto d = sig[topindex] - (m2[topindex] + sig2[topindex]);
+ if (d < 0) return GT;
+ if (d > 0) return LT;
+
+ const auto cmp = *sig - *sig2;
if (cmp < 0) return GT;
if (cmp > 0) return LT;
- auto a = sig;
- auto b = sig2;
- for (size_t i = topindex; i >= 1; i--)
- {
- int cmp = a[i] - b[i] - m2[i];
- if (cmp < 0) return GT;
- if (cmp > 0) return LT;
- }
- return EQ;
+ return mRing->monomialCompare(sig, m2, sig2);
}
char const* description() const {return "DegreeUp IndexDown GrevLex";}
@@ -384,44 +338,23 @@ private:
class OrderE
{
public:
- OrderE(Ideal const* I):
- mRing(I->getPolyRing()),
- topindex(mRing->maxMonomialSize() - 2)
+ OrderE(const PolyRing& ring):
+ mRing(&ring), topindex(ring.maxMonomialSize() - 2)
{}
- void appendBasisElement(const_monomial m) {}
-
int signatureCompare(const_monomial a, const_monomial b) const {
if (*a != *b)
return *a < *b ? GT : LT;
- for (size_t i = topindex; i >= 1; i--) {
- int cmp = a[i] - b[i];
- if (cmp != 0)
- return cmp < 0 ? GT : LT;
- }
- return EQ;
+ return mRing->monomialCompare(a, b);
}
- void scrambleSignatureForFastComparison(monomial sig) const {}
- void scrambleSignaturesForFastComparison(std::vector<PreSPair>& pairs) const {}
- inline bool scrambledLessThan(const_monomial a, const_monomial b) const {
- return signatureCompare(a,b) == LT;
- }
- void unscrambleSignature(monomial sig) const {}
-
int signatureCompare(const_monomial a, const_monomial m2, const_monomial b) const {
int cmp = *a - *b;
if (cmp != 0) {
if (cmp < 0) return GT;
if (cmp > 0) return LT;
}
-
- for (size_t i = topindex; i >= 1; i--) {
- int cmp = a[i] - b[i] - m2[i];
- if (cmp < 0) return GT;
- if (cmp > 0) return LT;
- }
- return EQ;
+ return mRing->monomialCompare(a, m2, b);
}
virtual char const* description() const {
@@ -445,7 +378,7 @@ void FreeModuleOrder::displayOrderTypes(std::ostream &o)
o << " 7 IndexDown SchreyerGrevLex" << std::endl;
}
-std::unique_ptr<FreeModuleOrder> FreeModuleOrder::makeOrder(FreeModuleOrderType type, const Ideal* I)
+std::unique_ptr<FreeModuleOrder> FreeModuleOrder::makeOrder(FreeModuleOrderType type, const PolyRing& ring)
{
if (type == 0)
type = 1; // Set the default
@@ -454,15 +387,15 @@ std::unique_ptr<FreeModuleOrder> FreeModuleOrder::makeOrder(FreeModuleOrderType
case 4:
case 5:
case 1:
- return make_unique<ConcreteOrder<OrderA>>(OrderA(I->getPolyRing()));
+ return make_unique<ConcreteOrder<OrderA>>(ring);
case 2:
case 3:
- return make_unique<ConcreteOrder<OrderC>>(OrderC(I));
+ return make_unique<ConcreteOrder<OrderC>>(ring);
case 6:
case 7:
- return make_unique<ConcreteOrder<OrderE>>(OrderE(I));
+ return make_unique<ConcreteOrder<OrderE>>(ring);
default: break;
}
@@ -470,7 +403,7 @@ std::unique_ptr<FreeModuleOrder> FreeModuleOrder::makeOrder(FreeModuleOrderType
std::cerr << "unknown free module order type" << std::endl;
std::cerr << "possible orders are: " << std::endl;
for (size_t i = 1; i <= 7; ++i) {
- auto order = makeOrder(static_cast<FreeModuleOrderType>(i), I);
+ auto order = makeOrder(static_cast<FreeModuleOrderType>(i), ring);
std::cerr << " " << i << ": " << order->description() << std::endl;
}
exit(1);
diff --git a/src/mathicgb/FreeModuleOrder.hpp b/src/mathicgb/FreeModuleOrder.hpp
index f4fa3c5..115e49f 100755
--- a/src/mathicgb/FreeModuleOrder.hpp
+++ b/src/mathicgb/FreeModuleOrder.hpp
@@ -7,7 +7,6 @@
#include "SigSPairQueue.hpp"
class PolyRing;
-class Ideal;
class GroebnerBasis;
class SigSPairQueue;
typedef int FreeModuleOrderType;
@@ -28,13 +27,8 @@ public:
const_monomial sig2
) const = 0;
- // Sorts in ascending order of signature. May alter the signatures,
- // so do not use them after calling this method other than to free them.
- virtual void sortAndScrambleSignatures(std::vector<PreSPair>& pairs) const = 0;
-
- // You must use this method to inform the order when a
- // new basis element has been added.
- virtual void appendBasisElement(const_monomial m) = 0;
+ // Sorts in ascending order of signature.
+ virtual void sortSignatures(std::vector<PreSPair>& pairs) const = 0;
virtual void getStats(size_t& comparisons, size_t& preComparisons) const = 0;
@@ -44,7 +38,7 @@ public:
createSigSPairQueue(GroebnerBasis const& basis) const = 0;
/// @todo: We need at least an enum to make this clearer
- static std::unique_ptr<FreeModuleOrder> makeOrder(FreeModuleOrderType type, const Ideal* I);
+ static std::unique_ptr<FreeModuleOrder> makeOrder(FreeModuleOrderType type, const PolyRing& ring);
static void displayOrderTypes(std::ostream &o);
diff --git a/src/mathicgb/PairTriangle.cpp b/src/mathicgb/PairTriangle.cpp
index a8470ca..86119bc 100755
--- a/src/mathicgb/PairTriangle.cpp
+++ b/src/mathicgb/PairTriangle.cpp
@@ -64,7 +64,7 @@ namespace {
}
void PairTriangle::endColumn() {
- mOrder.sortAndScrambleSignatures(mPrePairs);
+ mOrder.sortSignatures(mPrePairs);
typedef IndexIterator<std::vector<PreSPair>::const_iterator> Iter;
mPairQueue.addColumnDescending
(Iter(mPrePairs.begin()), Iter(mPrePairs.end()));
diff --git a/src/mathicgb/SignatureGB.cpp b/src/mathicgb/SignatureGB.cpp
index 2fc2afe..b008787 100755
--- a/src/mathicgb/SignatureGB.cpp
+++ b/src/mathicgb/SignatureGB.cpp
@@ -27,7 +27,7 @@ SignatureGB::SignatureGB(
mBreakAfter(0),
mPrintInterval(0),
R(ideal.getPolyRing()),
- F(FreeModuleOrder::makeOrder(typ, &ideal)),
+ F(FreeModuleOrder::makeOrder(typ, *ideal.getPolyRing())),
mPostponeKoszul(postponeKoszul),
mUseBaseDivisors(useBaseDivisors),
stats_sPairSignaturesDone(0),
diff --git a/src/test/F4MatrixBuilder.cpp b/src/test/F4MatrixBuilder.cpp
index d41acb6..5cff0b4 100755
--- a/src/test/F4MatrixBuilder.cpp
+++ b/src/test/F4MatrixBuilder.cpp
@@ -22,7 +22,7 @@ namespace {
BuilderMaker():
mRing(ringFromString("101 6 1\n1 1 1 1 1 1")),
mIdeal(*mRing),
- mOrder(FreeModuleOrder::makeOrder(1, &mIdeal)),
+ mOrder(FreeModuleOrder::makeOrder(1, *mIdeal.getPolyRing())),
mBasis(*mRing, *mOrder, DivisorLookup::makeFactory(*mRing, 1)->create(true, true)) {
}
diff --git a/src/test/FreeModuleOrderTest.cpp b/src/test/FreeModuleOrderTest.cpp
index 40e941f..997c88b 100755
--- a/src/test/FreeModuleOrderTest.cpp
+++ b/src/test/FreeModuleOrderTest.cpp
@@ -44,8 +44,8 @@ void runTest(
MATHICGB_ASSERT(sigs.size() == pairs.size());
std::unique_ptr<FreeModuleOrder> order
- (FreeModuleOrder::makeOrder(orderType, ideal.get()));
- order->sortAndScrambleSignatures(pairs);
+ (FreeModuleOrder::makeOrder(orderType, *ideal->getPolyRing()));
+ order->sortSignatures(pairs);
for (size_t i = 0; i < pairs.size(); ++i) {
ring->freeMonomial(pairs[i].signature);
pairs[i].signature = sigs[pairs[i].i];
diff --git a/src/test/QuadMatrixBuilder.cpp b/src/test/QuadMatrixBuilder.cpp
index aa6f21b..82cff74 100755
--- a/src/test/QuadMatrixBuilder.cpp
+++ b/src/test/QuadMatrixBuilder.cpp
@@ -149,7 +149,7 @@ TEST(QuadMatrixBuilder, SortColumns) {
// construct builder and reverse lex order
std::unique_ptr<PolyRing> ring(ringFromString("32003 6 1\n1 1 1 1 1 1"));
Ideal ideal(*ring);
- std::unique_ptr<FreeModuleOrder> order(FreeModuleOrder::makeOrder(1, &ideal));
+ std::unique_ptr<FreeModuleOrder> order(FreeModuleOrder::makeOrder(1, *ideal.getPolyRing()));
// one row top, no rows bottom, no columns
{
--
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