[mathicgb] 371/393: Starting cleanup of interface of SigPolyBasis.hpp
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 75fdbdf66ec51ec5a1543e311e139cdbe0da8bc5
Author: Bjarke Hammersholt Roune <bjarkehr.code at gmail.com>
Date: Tue Sep 17 17:59:16 2013 +0200
Starting cleanup of interface of SigPolyBasis.hpp
---
src/mathicgb/SigPolyBasis.cpp | 88 ++++++++++++++++++++---------------------
src/mathicgb/SigPolyBasis.hpp | 60 ++++++++++++++++------------
src/mathicgb/SigSPairQueue.cpp | 6 +--
src/mathicgb/SigSPairs.cpp | 55 ++++++++++++++------------
src/mathicgb/SigSPairs.hpp | 3 ++
src/mathicgb/SignatureGB.cpp | 22 +++++------
src/mathicgb/StaticMonoMap.hpp | 8 ++--
src/mathicgb/TypicalReducer.cpp | 10 ++---
8 files changed, 134 insertions(+), 118 deletions(-)
diff --git a/src/mathicgb/SigPolyBasis.cpp b/src/mathicgb/SigPolyBasis.cpp
index 4fae906..e2e2f5c 100755
--- a/src/mathicgb/SigPolyBasis.cpp
+++ b/src/mathicgb/SigPolyBasis.cpp
@@ -12,15 +12,16 @@
MATHICGB_NAMESPACE_BEGIN
SigPolyBasis::SigPolyBasis(
- const PolyRing* R0,
+ const PolyRing& R0,
int monoLookupType,
int monTableType,
- bool preferSparseReducers):
+ bool preferSparseReducers
+):
mMonoLookupFactory
- (MonoLookup::makeFactory(R0->monoid(), monoLookupType)),
- mRatioSorted(RatioOrder(sigLeadRatio, R0->monoid())),
+ (MonoLookup::makeFactory(R0.monoid(), monoLookupType)),
+ mRatioSorted(RatioOrder(mSigLeadRatio, R0.monoid())),
mMinimalMonoLookup(mMonoLookupFactory->make(preferSparseReducers, true)),
- mBasis(*R0, mMonoLookupFactory->make(preferSparseReducers, true)),
+ mBasis(R0, mMonoLookupFactory->make(preferSparseReducers, true)),
mPreferSparseReducers(preferSparseReducers)
{
mTmp = mBasis.ring().allocMonomial();
@@ -31,13 +32,13 @@ SigPolyBasis::SigPolyBasis(
SigPolyBasis::~SigPolyBasis()
{
MATHICGB_ASSERT(mBasis.size() == mSignatures.size());
- MATHICGB_ASSERT(mBasis.size() == sigLeadRatio.size());
+ MATHICGB_ASSERT(mBasis.size() == mSigLeadRatio.size());
for (size_t i = 0; i < mBasis.size(); i++) {
- if (! mSignatures[i].isNull())
+ if (!mSignatures[i].isNull())
ring().freeMonomial(mSignatures[i]);
- if (! sigLeadRatio[i].isNull())
- ring().freeMonomial(sigLeadRatio[i]);
+ if (!mSigLeadRatio[i].isNull())
+ ring().freeMonomial(mSigLeadRatio[i]);
}
for (size_t i = 0; i < mSignatureLookup.size(); ++i)
delete mSignatureLookup[i];
@@ -71,7 +72,7 @@ void SigPolyBasis::insert(monomial sig, std::unique_ptr<Poly> f)
ratio = ring().allocMonomial();
ring().monomialDivideToNegative(sig, f->getLeadMonomial(), ratio);
}
- sigLeadRatio.push_back(ratio);
+ mSigLeadRatio.push_back(ratio);
const_monomial const lead = f->getLeadMonomial();
mBasis.insert(std::move(f));
@@ -97,7 +98,7 @@ again:
RatioSortedType::iterator prev = pos;
--prev;
prevRank = mRatioRanks[*prev];
- if (ring().monomialEQ(ratio, sigLeadRatio[*prev])) {
+ if (monoid().equal(ratio, mSigLeadRatio[*prev])) {
mRatioRanks.push_back(prevRank);
return;
}
@@ -110,7 +111,7 @@ again:
nextRank = std::numeric_limits<Rank>::max();
else {
nextRank = mRatioRanks[*next];
- if (ring().monomialEQ(ratio, sigLeadRatio[*next])) {
+ if (monoid().equal(ratio, mSigLeadRatio[*next])) {
mRatioRanks.push_back(nextRank);
return;
}
@@ -177,9 +178,9 @@ size_t SigPolyBasis::regularReducer(
MATHICGB_SLOW_ASSERT(debugValue != static_cast<size_t>(-1));
monomial m = ring().allocMonomial();
MATHICGB_SLOW_ASSERT
- (ring().monomialIsDivisibleBy(term, getLeadMonomial(reducer)));
- ring().monomialDivide(term, getLeadMonomial(reducer), m);
- ring().monomialMultTo(m, getSignature(reducer));
+ (ring().monomialIsDivisibleBy(term, leadMono(reducer)));
+ ring().monomialDivide(term, leadMono(reducer), m);
+ ring().monomialMultTo(m, signature(reducer));
MATHICGB_SLOW_ASSERT(monoid().lessThan(m, sig));
ring().freeMonomial(m);
}
@@ -194,10 +195,10 @@ size_t SigPolyBasis::regularReducerSlow(
monomial m = ring().allocMonomial();
const size_t stop = size();
for (size_t be = 0; be < stop; ++be) {
- if (!ring().monomialIsDivisibleBy(term, getLeadMonomial(be)))
+ if (!monoid().divides(leadMono(be), term))
continue;
- ring().monomialDivide(term, getLeadMonomial(be), m);
- ring().monomialMultTo(m, getSignature(be));
+ monoid().divide(leadMono(be), term, m);
+ monoid().multiplyInPlace(signature(be), m);
if (monoid().lessThan(m, sig)) {
ring().freeMonomial(m);
return be;
@@ -213,8 +214,8 @@ void SigPolyBasis::lowBaseDivisors(
size_t newGenerator) const
{
MATHICGB_ASSERT(newGenerator < size());
- const_monomial sigNew = getSignature(newGenerator);
- const size_t component = ring().monomialGetComponent(sigNew);
+ const auto sigNew = signature(newGenerator);
+ const auto component = monoid().component(sigNew);
mSignatureLookup[component]->
lowBaseDivisors(divisors, maxDivisors, newGenerator);
#ifdef MATHICGB_DEBUG
@@ -238,14 +239,13 @@ void SigPolyBasis::lowBaseDivisorsSlow(
divisors.clear();
divisors.reserve(maxDivisors + 1);
- const_monomial sigNew = getSignature(newGenerator);
+ auto sigNew = signature(newGenerator);
for (size_t i = 0; i < newGenerator; ++i) {
- const_monomial sigi = getSignature(i);
+ auto sigi = signature(i);
- if (ring().monomialGetComponent(sigi) !=
- ring().monomialGetComponent(sigNew))
+ if (monoid().component(sigi) != monoid().component(sigNew))
continue;
- if (!ring().monomialIsDivisibleBy(sigNew, sigi))
+ if (!monoid().divides(sigi, sigNew))
continue;
for (size_t j = 0; j <= divisors.size(); ++j) {
if (j == divisors.size()) {
@@ -280,8 +280,8 @@ size_t SigPolyBasis::highBaseDivisor(size_t newGenerator) const {
size_t SigPolyBasis::highBaseDivisorSlow(size_t newGenerator) const {
MATHICGB_ASSERT(newGenerator < size());
- size_t highDivisor = static_cast<size_t>(-1);
- const_monomial leadNew = getLeadMonomial(newGenerator);
+ auto highDivisor = static_cast<size_t>(-1);
+ auto leadNew = leadMono(newGenerator);
for (size_t i = 0; i < newGenerator; ++i) {
// continue if this generator would not be an improvement
// even if it does divide. This is a faster check than
@@ -289,8 +289,8 @@ size_t SigPolyBasis::highBaseDivisorSlow(size_t newGenerator) const {
if (highDivisor != static_cast<size_t>(-1) &&
ratioCompare(highDivisor, i) == LT)
continue;
- const_monomial leadi = getLeadMonomial(i);
- if (ring().monomialIsDivisibleBy(leadNew, leadi))
+ auto leadi = leadMono(i);
+ if (monoid().divides(leadi, leadNew))
highDivisor = i;
}
return highDivisor;
@@ -312,13 +312,13 @@ size_t SigPolyBasis::minimalLeadInSigSlow(const_monomial sig) const {
const int sigComponent = ring().monomialGetComponent(sig);
const size_t genCount = size();
for (size_t gen = 0; gen < genCount; ++gen) {
- if (ring().monomialGetComponent(getSignature(gen)) != sigComponent)
+ if (monoid().component(signature(gen)) != sigComponent)
continue;
- if (!ring().monomialIsDivisibleBy(sig, getSignature(gen)))
+ if (!monoid().divides(signature(gen), sig))
continue;
- ring().monomialDivide(sig, getSignature(gen), multiplier);
+ monoid().divide(signature(gen), sig, multiplier);
if (minLeadGen != static_cast<size_t>(-1)) {
- const_monomial genLead = getLeadMonomial(gen);
+ auto genLead = leadMono(gen);
const auto leadCmp = monoid().compare(minLead, multiplier, genLead);
if (leadCmp == Monoid::LessThan)
continue;
@@ -334,9 +334,9 @@ size_t SigPolyBasis::minimalLeadInSigSlow(const_monomial sig) const {
// before being multiplied into the same signature. That one
// might be more reduced as the constraint on regular reduction
// is less.
- const const_monomial minSig = getSignature(minLeadGen);
- const const_monomial genSig = getSignature(gen);
- int sigCmp = monoid().compare(minSig, genSig);
+ const auto minSig = signature(minLeadGen);
+ const auto genSig = signature(gen);
+ const auto sigCmp = monoid().compare(minSig, genSig);
// no two generators have same signature
MATHICGB_ASSERT(sigCmp != Monoid::EqualTo);
@@ -347,7 +347,7 @@ size_t SigPolyBasis::minimalLeadInSigSlow(const_monomial sig) const {
}
minLeadGen = gen;
- ring().monomialMult(multiplier, getLeadMonomial(gen), minLead);
+ monoid().multiply(multiplier, leadMono(gen), minLead);
}
ring().freeMonomial(multiplier);
ring().freeMonomial(minLead);
@@ -364,10 +364,10 @@ bool SigPolyBasis::isSingularTopReducibleSlow
const size_t genCount = size();
const_monomial polyLead = poly.getLeadMonomial();
for (size_t i = 0; i < genCount; ++i) {
- if (!ring().monomialIsDivisibleBy(polyLead, getLeadMonomial(i)))
+ if (!monoid().divides(leadMono(i), polyLead))
continue;
- ring().monomialDivide(polyLead, getLeadMonomial(i), multiplier);
- if (monoid().compare(sig, multiplier, getSignature(i)) == EQ)
+ monoid().divide(leadMono(i), polyLead, multiplier);
+ if (monoid().compare(sig, multiplier, signature(i)) == EQ)
return true;
}
ring().freeMonomial(multiplier);
@@ -427,7 +427,7 @@ size_t SigPolyBasis::getMemoryUse() const
size_t total = 0;
total += mBasis.getMemoryUse();
total += mSignatures.capacity() * sizeof(mSignatures.front());
- total += sigLeadRatio.capacity() * sizeof(sigLeadRatio.front());
+ total += mSigLeadRatio.capacity() * sizeof(mSigLeadRatio.front());
total += mRatioRanks.capacity() * sizeof(mRatioRanks.front());
total += monoLookup().getMemoryUse();
total += mMinimalMonoLookup->getMemoryUse();
@@ -448,8 +448,8 @@ size_t SigPolyBasis::ratioRank(const_monomial ratio) const {
const size_t index = size();
if (index == 0)
return 0; // any value will do as there is nothing to compare to
- std::vector<monomial>& sigLeadRatioNonConst =
- const_cast<std::vector<monomial>&>(sigLeadRatio);
+ auto& sigLeadRatioNonConst =
+ const_cast<std::vector<monomial>&>(mSigLeadRatio);
sigLeadRatioNonConst.push_back(ratio.castAwayConst());
RatioSortedType::iterator pos = mRatioSorted.lower_bound(index);
@@ -460,7 +460,7 @@ size_t SigPolyBasis::ratioRank(const_monomial ratio) const {
std::numeric_limits<Rank>::max());
return std::numeric_limits<Rank>::max();
} else {
- if (monoid().equal(ratio, getSigLeadRatio(*pos)))
+ if (monoid().equal(ratio, sigLeadRatio(*pos)))
return ratioRank(*pos);
MATHICGB_ASSERT(ratioRank(*pos) > 0);
#ifdef MATHICGB_DEBUG
diff --git a/src/mathicgb/SigPolyBasis.hpp b/src/mathicgb/SigPolyBasis.hpp
index fa6428a..0de1240 100755
--- a/src/mathicgb/SigPolyBasis.hpp
+++ b/src/mathicgb/SigPolyBasis.hpp
@@ -20,36 +20,43 @@ MATHICGB_NAMESPACE_BEGIN
class SigPolyBasis {
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 MonoProcessor<Monoid> Processor;
SigPolyBasis(
- const PolyRing* R,
+ const PolyRing& R,
int monoLookupType,
int monTableType,
bool preferSparseReducers
);
~SigPolyBasis();
- const Monoid& monoid() const {return ring().monoid();}
const PolyRing& ring() const {return mBasis.ring();}
+ const Monoid& monoid() const {return ring().monoid();}
+
const Poly& poly(size_t index) const {return mBasis.poly(index);}
size_t size() const {return mBasis.size();}
- // todo: stop using non-const version of basis() and then remove it.
- PolyBasis& basis() {return mBasis;}
const PolyBasis& basis() const {return mBasis;}
- const_monomial getLeadMonomial(size_t i) const {
- return mBasis.leadMonomial(i);
+ ConstMonoRef leadMono(size_t gen) const {
+ MATHICGB_ASSERT(gen < size());
+ return mBasis.leadMonomial(gen);
}
- coefficient getLeadCoefficient(size_t i) const {
- return mBasis.leadCoefficient(i);
+ coefficient leadCoef(size_t gen) const {
+ MATHICGB_ASSERT(gen < size());
+ return mBasis.leadCoefficient(gen);
}
- const_monomial getSigLeadRatio(size_t i) const {
- MATHICGB_ASSERT(i < size());
- return sigLeadRatio[i];
+ ConstMonoRef sigLeadRatio(size_t gen) const {
+ MATHICGB_ASSERT(gen < size());
+ return mSigLeadRatio[gen];
}
// Signifies that the module has taken on another e_i.
@@ -61,9 +68,9 @@ public:
// of ring() and f must have been allocated with new.
void insert(monomial sig, std::unique_ptr<Poly> f);
- const_monomial getSignature(size_t i) const {
- MATHICGB_ASSERT(i < size());
- return mSignatures[i];
+ ConstMonoRef signature(size_t gen) const {
+ MATHICGB_ASSERT(gen < size());
+ return mSignatures[gen];
}
// Returns the index of a basis element that regular reduces term in
@@ -162,7 +169,7 @@ private:
std::vector<monomial> mSignatures;
// the ratio signature/initial term including negative entries and module component
- std::vector<monomial> sigLeadRatio;
+ std::vector<monomial> mSigLeadRatio;
// true if giving each generator an integer id based on its
// position in a sorted order of sig-lead ratios.
@@ -198,7 +205,7 @@ inline int SigPolyBasis::ratioCompare(size_t a, size_t b) const {
if (mUseRatioRank) {
#ifdef MATHICGB_DEBUG
int const value =
- monoid().compare(getSigLeadRatio(a), getSigLeadRatio(b));
+ monoid().compare(sigLeadRatio(a), sigLeadRatio(b));
#endif
if (mRatioRanks[a] < mRatioRanks[b]) {
MATHICGB_ASSERT_NO_ASSUME(value == LT);
@@ -212,11 +219,12 @@ inline int SigPolyBasis::ratioCompare(size_t a, size_t b) const {
}
} else {
// A/a < B/b <=> A < (B/b)a
- ring().monomialDivideToNegative(getSignature(b), getLeadMonomial(b), mTmp);
- ring().monomialMultTo(mTmp, getLeadMonomial(a));
- int value = monoid().compare(getSignature(a), mTmp);
- MATHICGB_ASSERT(value ==
- monoid().compare(getSigLeadRatio(a), getSigLeadRatio(b)));
+
+ monoid().divideToNegative(signature(b), leadMono(b), mTmp);
+ monoid().multiplyInPlace(leadMono(a), mTmp);
+ const auto value = monoid().compare(signature(a), mTmp);
+ MATHICGB_ASSERT
+ (value == monoid().compare(sigLeadRatio(a), sigLeadRatio(b)));
return value;
}
}
@@ -225,7 +233,7 @@ inline int SigPolyBasis::StoredRatioCmp::compare(size_t be) const {
if (SigPolyBasis::mUseStoredRatioRank) {
#ifdef MATHICGB_DEBUG
const auto value =
- mBasis.monoid().compare(mRatio, mBasis.getSigLeadRatio(be));
+ mBasis.monoid().compare(mRatio, mBasis.sigLeadRatio(be));
#endif
SigPolyBasis::Rank otherRank = mBasis.ratioRank(be);
if (mRatioRank < otherRank) {
@@ -239,10 +247,10 @@ inline int SigPolyBasis::StoredRatioCmp::compare(size_t be) const {
return EQ;
}
} else {
- mBasis.ring().monomialMult(mRatio, mBasis.getLeadMonomial(be), mTmp);
- int value = mBasis.monoid().compare(mTmp, mBasis.getSignature(be));
- MATHICGB_ASSERT(value ==
- mBasis.monoid().compare(mRatio, mBasis.getSigLeadRatio(be)));
+ mBasis.monoid().multiply(mRatio, mBasis.leadMono(be), mTmp);
+ const auto value = mBasis.monoid().compare(mTmp, mBasis.signature(be));
+ MATHICGB_ASSERT
+ (value == mBasis.monoid().compare(mRatio, mBasis.sigLeadRatio(be)));
return value;
}
}
diff --git a/src/mathicgb/SigSPairQueue.cpp b/src/mathicgb/SigSPairQueue.cpp
index 0d6fbe2..36279ef 100755
--- a/src/mathicgb/SigSPairQueue.cpp
+++ b/src/mathicgb/SigSPairQueue.cpp
@@ -126,9 +126,9 @@ private:
if (mBasis.ratioCompare(col, row) == LT)
std::swap(col, row);
monoid().colonMultiply(
- mBasis.getLeadMonomial(col),
- mBasis.getLeadMonomial(row),
- mBasis.getSignature(col),
+ mBasis.leadMono(col),
+ mBasis.leadMono(row),
+ mBasis.signature(col),
*sig
);
}
diff --git a/src/mathicgb/SigSPairs.cpp b/src/mathicgb/SigSPairs.cpp
index c9a3060..83e3931 100755
--- a/src/mathicgb/SigSPairs.cpp
+++ b/src/mathicgb/SigSPairs.cpp
@@ -112,12 +112,18 @@ void SigSPairs::setupBaseDivisors(
// Construct a monomial in makeSPair_t2 that can be used
// to eliminate s-pairs quickly based on the s-pairs already
// eliminated for baseDivisor.
- const_monomial newSig = GB->getSignature(newGenerator);
- const_monomial newLead = GB->getLeadMonomial(newGenerator);
- const_monomial baseDivSig = GB->getSignature(bd.baseDivisor);
- const_monomial baseDivLead = GB->getLeadMonomial(bd.baseDivisor);
+ auto newSig = GB->signature(newGenerator);
+ auto newLead = GB->leadMono(newGenerator);
+ auto baseDivSig = GB->signature(bd.baseDivisor);
+ auto baseDivLead = GB->leadMono(bd.baseDivisor);
bd.baseMonomial = R->allocMonomial();
- R->mysteriousSPairMonomialRoutine(newSig, newLead, baseDivSig, baseDivLead, bd.baseMonomial);
+ R->mysteriousSPairMonomialRoutine(
+ Monoid::toOld(newSig),
+ Monoid::toOld(newLead),
+ Monoid::toOld(baseDivSig),
+ Monoid::toOld(baseDivLead),
+ bd.baseMonomial
+ );
}
divisor1.baseDivisor = static_cast<size_t>(-1);
@@ -151,9 +157,9 @@ void SigSPairs::makePreSPairs(size_t newGen)
if (!mPostponeKoszuls)
hsyz = R->allocMonomial();
- const_monomial newSig = GB->getSignature(newGen);
- const_monomial newLead = GB->getLeadMonomial(newGen);
- monomial pairSig = R->allocMonomial();
+ auto newSig = GB->signature(newGen);
+ auto newLead = GB->leadMono(newGen);
+ auto pairSig = R->allocMonomial();
if (mUseHighBaseDivisors && divisor1.baseDivisor != static_cast<size_t>(-1))
++mStats.hasLowBaseDivisor;
@@ -162,8 +168,8 @@ void SigSPairs::makePreSPairs(size_t newGen)
PreSPair result;
for (size_t oldGen = 0; oldGen < newGen; oldGen++) {
- const_monomial oldSig = GB->getSignature(oldGen);
- const_monomial oldLead = GB->getLeadMonomial(oldGen);
+ auto oldSig = GB->signature(oldGen);
+ auto oldLead = GB->leadMono(oldGen);
// Check whether this is a non-regular spair.
// 'cmp' is used below too.
@@ -199,13 +205,13 @@ void SigSPairs::makePreSPairs(size_t newGen)
if (
(divisor1.baseDivisor != oldGen && // if divisor1 is a hit
mKnownSyzygyTri.bitUnordered(divisor1.baseDivisor, oldGen) &&
- R->monomialIsDivisibleBy(divisor1.baseMonomial, oldLead))
+ monoid().divides(oldLead, divisor1.baseMonomial))
|| // or if divisor2 is a hit
(divisor2.baseDivisor != static_cast<size_t>(-1) &&
GB->ratioCompare(oldGen, divisor2.ratioLessThan) == LT &&
divisor2.baseDivisor != oldGen &&
mKnownSyzygyTri.bitUnordered(divisor2.baseDivisor, oldGen) &&
- R->monomialIsDivisibleBy(divisor2.baseMonomial, oldLead))
+ monoid().divides(oldLead, divisor2.baseMonomial))
) {
mKnownSyzygyTri.setBit(newGen, oldGen, true);
++mStats.lowBaseDivisorHits;
@@ -218,10 +224,10 @@ void SigSPairs::makePreSPairs(size_t newGen)
}
if (cmp == GT)
- R->monomialFindSignature(newLead, oldLead, newSig, pairSig);
+ monoid().colonMultiply(newLead, oldLead, newSig, pairSig);
else {
MATHICGB_ASSERT(cmp == LT);
- R->monomialFindSignature(oldLead, newLead, oldSig, pairSig);
+ monoid().colonMultiply(oldLead, newLead, oldSig, pairSig);
}
if (Hsyz->member(pairSig)) {
@@ -245,24 +251,24 @@ void SigSPairs::makePreSPairs(size_t newGen)
// add koszul syzygy to Hsyz.
MATHICGB_ASSERT(cmp == GT || cmp == LT);
if (cmp == GT)
- R->monomialMult(newSig, oldLead, hsyz);
+ monoid().multiply(newSig, oldLead, hsyz);
else
- R->monomialMult(oldSig, newLead, hsyz);
+ monoid().multiply(oldSig, newLead, hsyz);
if (Hsyz->insert(hsyz))
hsyz = R->allocMonomial();
- if (R->monomialRelativelyPrime(newLead, oldLead))
- {
- ++mStats.earlyRelativelyPrimePairs;
- continue;
- }
+ if (monoid().relativelyPrime(newLead, oldLead)) {
+ ++mStats.earlyRelativelyPrimePairs;
+ continue;
+ }
}
if (mUseSingularCriterionEarly) {
MATHICGB_ASSERT(cmp == GT || cmp == LT);
size_t const givesSig = (cmp == GT ? newGen : oldGen);
- if (GB->ratioCompare(GB->minimalLeadInSig(pairSig), givesSig) == GT &&
- !R->monomialRelativelyPrime(newLead, oldLead)) {
-
+ if (
+ GB->ratioCompare(GB->minimalLeadInSig(pairSig), givesSig) == GT &&
+ !monoid().relativelyPrime(newLead, oldLead)
+ ) {
++mStats.earlySingularCriterionPairs;
continue;
}
@@ -274,7 +280,6 @@ void SigSPairs::makePreSPairs(size_t newGen)
result.i = static_cast<BigIndex>(oldGen);
mIndexSigs.push_back(result);
++mStats.queuedPairs;
- //pairs.push_back(result);
}
R->freeMonomial(pairSig);
if (mUseBaseDivisors && ! baseDivisorMonomial.isNull())
diff --git a/src/mathicgb/SigSPairs.hpp b/src/mathicgb/SigSPairs.hpp
index 66b530b..9f4ad1a 100755
--- a/src/mathicgb/SigSPairs.hpp
+++ b/src/mathicgb/SigSPairs.hpp
@@ -86,6 +86,9 @@ public:
void setKnownSyzygy(size_t gen1, size_t gen2);
void setKnownSyzygies(std::vector<std::pair<size_t, size_t> >& pairs);
+ const PolyRing& ring() {return *R;}
+ const Monoid& monoid() {return ring().monoid();}
+
std::string name();
private:
diff --git a/src/mathicgb/SignatureGB.cpp b/src/mathicgb/SignatureGB.cpp
index 7b11eea..2483305 100755
--- a/src/mathicgb/SignatureGB.cpp
+++ b/src/mathicgb/SignatureGB.cpp
@@ -49,7 +49,7 @@ SignatureGB::SignatureGB(
stats_relativelyPrimeEliminated(0),
stats_pairsReduced(0),
stats_nsecs(0.0),
- GB(make_unique<SigPolyBasis>(R, divlookup_type, montable_type, preferSparseReducers)),
+ GB(make_unique<SigPolyBasis>(*R, divlookup_type, montable_type, preferSparseReducers)),
mKoszuls(R->monoid()),
Hsyz(ModuleMonoSet::make(R->monoid(), montable_type, basis.size(), !mPostponeKoszul)),
Hsyz2(ModuleMonoSet::make(R->monoid(), montable_type, basis.size(), !mPostponeKoszul)),
@@ -153,7 +153,7 @@ bool SignatureGB::processSPair
size_t gen = GB->minimalLeadInSig(Monoid::toOld(*sig));
MATHICGB_ASSERT(gen != static_cast<size_t>(-1));
monomial multiple = R->allocMonomial();
- monoid().divide(GB->getSignature(gen), *sig, multiple);
+ monoid().divide(GB->signature(gen), *sig, multiple);
GB->basis().usedAsStart(gen);
// reduce multiple * GB->getSignature(gen)
@@ -231,9 +231,9 @@ bool SignatureGB::step() {
if (mPostponeKoszul) {
// Relatively prime check
for (auto it = mSpairTmp.begin(); it != mSpairTmp.end(); ++it) {
- const_monomial a = GB->getLeadMonomial(it->first);
- const_monomial b = GB->getLeadMonomial(it->second);
- if (R->monomialRelativelyPrime(a, b)) {
+ auto a = GB->leadMono(it->first);
+ auto b = GB->leadMono(it->second);
+ if (monoid().relativelyPrime(a, b)) {
++stats_relativelyPrimeEliminated;
// todo: what are the correct ownership relations here?
auto ptr = sig.release();
@@ -247,9 +247,9 @@ bool SignatureGB::step() {
}
#ifdef DEBUG
for (auto it = mSpairTmp.begin(); it != mSpairTmp.end(); ++it) {
- const_monomial a = GB->getLeadMonomial(it->first);
- const_monomial b = GB->getLeadMonomial(it->second);
- MATHICGB_ASSERT(!R->monomialRelativelyPrime(a, b));
+ auto a = GB->leadMono(it->first);
+ auto b = GB->leadMono(it->second);
+ MATHICGB_ASSERT(!monoid().relativelyPrime(a, b));
}
#endif
@@ -262,10 +262,10 @@ bool SignatureGB::step() {
if (GB->ratioCompare(p.first, p.second) == LT)
std::swap(p.first, p.second);
- const_monomial greaterSig = GB->getSignature(p.first);
- const_monomial smallerLead = GB->getLeadMonomial(p.second);
+ auto greaterSig = GB->signature(p.first);
+ auto smallerLead = GB->leadMono(p.second);
monomial koszul = R->allocMonomial();
- R->monomialMult(greaterSig, smallerLead, koszul);
+ monoid().multiply(greaterSig, smallerLead, koszul);
if (Hsyz->member(koszul))
R->freeMonomial(koszul);
else
diff --git a/src/mathicgb/StaticMonoMap.hpp b/src/mathicgb/StaticMonoMap.hpp
index 4c7a0dc..ea0884e 100755
--- a/src/mathicgb/StaticMonoMap.hpp
+++ b/src/mathicgb/StaticMonoMap.hpp
@@ -230,7 +230,7 @@ public:
divisors.clear();
divisors.reserve(maxDivisors + 1);
auto wrap = lambdaWrap(proceed);
- mLookup.findAllDivisors(basis.getSignature(newGenerator), wrap);
+ mLookup.findAllDivisors(basis.signature(newGenerator), wrap);
}
size_t highBaseDivisor(
@@ -253,7 +253,7 @@ public:
return true;
};
auto wrap = lambdaWrap(proceed);
- mLookup.findAllDivisors(basis.getLeadMonomial(newGenerator), wrap);
+ mLookup.findAllDivisors(basis.leadMono(newGenerator), wrap);
return highDivisor;
}
@@ -291,8 +291,8 @@ public:
// might be more reduced as the constraint on regular reduction
// is less. Also, as no two generators have same signature, this
// ensures deterministic behavior.
- const auto minSig = basis.getSignature(minLeadGen);
- const auto genSig = basis.getSignature(entry.data());
+ const auto minSig = basis.signature(minLeadGen);
+ const auto genSig = basis.signature(entry.data());
const auto sigCmp = basis.monoid().compare(minSig, genSig);
if (basis.monoid().lessThan(genSig, minSig))
return true;
diff --git a/src/mathicgb/TypicalReducer.cpp b/src/mathicgb/TypicalReducer.cpp
index 53eb20b..9e643e2 100755
--- a/src/mathicgb/TypicalReducer.cpp
+++ b/src/mathicgb/TypicalReducer.cpp
@@ -34,7 +34,7 @@ std::unique_ptr<Poly> TypicalReducer::regularReduce(
monomial tproduct = ring.allocMonomial(mArena);
monomial u = ring.allocMonomial(mArena);
- monoid.multiply(multiple, basis.getLeadMonomial(basisElement), tproduct);
+ monoid.multiply(multiple, basis.leadMono(basisElement), tproduct);
size_t reducer = basis.regularReducer(Monoid::toOld(sig), tproduct);
if (reducer == static_cast<size_t>(-1)) {
@@ -42,13 +42,13 @@ std::unique_ptr<Poly> TypicalReducer::regularReduce(
return nullptr; // singular reduction: no regular top reduction possible
}
- ring.monomialDivide(tproduct, basis.getLeadMonomial(reducer), u);
+ monoid.divide(basis.leadMono(reducer), tproduct, u);
coefficient coef;
ring.coefficientSet(coef, 1);
insertTail(const_term(coef, Monoid::toOld(multiple)), &basis.poly(basisElement));
- MATHICGB_ASSERT(ring.coefficientIsOne(basis.getLeadCoefficient(reducer)));
+ MATHICGB_ASSERT(ring.coefficientIsOne(basis.leadCoef(reducer)));
ring.coefficientFromInt(coef, -1);
insertTail(const_term(coef, u), &basis.poly(reducer));
basis.basis().usedAsReducer(reducer);
@@ -66,8 +66,8 @@ std::unique_ptr<Poly> TypicalReducer::regularReduce(
++steps;
basis.basis().usedAsReducer(reducer);
monomial mon = ring.allocMonomial(mArena);
- ring.monomialDivide(v.monom, basis.getLeadMonomial(reducer), mon);
- ring.coefficientDivide(v.coeff, basis.getLeadCoefficient(reducer), coef);
+ monoid.divide(basis.leadMono(reducer), v.monom, mon);
+ ring.coefficientDivide(v.coeff, basis.leadCoef(reducer), coef);
ring.coefficientNegateTo(coef);
removeLeadTerm();
insertTail(const_term(coef, mon), &basis.poly(reducer));
--
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