[mathicgb] 374/393: Changed PolyBasis to use 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 b16590d875aec101cbc55d64872149162b2530c9
Author: Bjarke Hammersholt Roune <bjarkehr.code at gmail.com>
Date: Tue Sep 17 19:33:08 2013 +0200
Changed PolyBasis to use MonoMonoid.
---
src/mathicgb/F4MatrixBuilder.cpp | 2 +-
src/mathicgb/F4MatrixBuilder2.cpp | 2 +-
src/mathicgb/PolyBasis.cpp | 31 ++++++-----
src/mathicgb/PolyBasis.hpp | 109 ++++++++++++++++++++------------------
src/mathicgb/SPairs.cpp | 60 ++++++++++-----------
src/mathicgb/SigPolyBasis.hpp | 6 ++-
src/mathicgb/TypicalReducer.cpp | 7 +--
7 files changed, 112 insertions(+), 105 deletions(-)
diff --git a/src/mathicgb/F4MatrixBuilder.cpp b/src/mathicgb/F4MatrixBuilder.cpp
index 94b3ce2..38bcfb0 100755
--- a/src/mathicgb/F4MatrixBuilder.cpp
+++ b/src/mathicgb/F4MatrixBuilder.cpp
@@ -246,7 +246,7 @@ auto F4MatrixBuilder::createColumn(
mathic::reportError("Monomial exponent overflow in F4MatrixBuilder.");
// look for a reducer of mTmp
- const size_t reducerIndex = mBasis.classicReducer(Monoid::toOld(*mTmp));
+ const size_t reducerIndex = mBasis.classicReducer(*mTmp);
const bool insertLeft = (reducerIndex != static_cast<size_t>(-1));
// Create the new left or right column
diff --git a/src/mathicgb/F4MatrixBuilder2.cpp b/src/mathicgb/F4MatrixBuilder2.cpp
index ad1025a..713f129 100755
--- a/src/mathicgb/F4MatrixBuilder2.cpp
+++ b/src/mathicgb/F4MatrixBuilder2.cpp
@@ -317,7 +317,7 @@ public:
mathic::reportError("Monomial exponent overflow in F4MatrixBuilder2.");
// look for a reducer of mTmp
- const size_t reducerIndex = mBasis.classicReducer(Monoid::toOld(*mTmp.ptr()));
+ const size_t reducerIndex = mBasis.classicReducer(*mTmp);
const bool insertLeft = (reducerIndex != static_cast<size_t>(-1));
// Create the new left or right column
diff --git a/src/mathicgb/PolyBasis.cpp b/src/mathicgb/PolyBasis.cpp
index 4781ece..feda5fd 100755
--- a/src/mathicgb/PolyBasis.cpp
+++ b/src/mathicgb/PolyBasis.cpp
@@ -34,7 +34,7 @@ std::unique_ptr<Basis> PolyBasis::initialIdeal() const {
for (size_t gen = 0; gen != basisSize; ++gen) {
if (!retired(gen) && leadMinimal(gen)) {
std::unique_ptr<Poly> p(new Poly(mRing));
- p->appendTerm(1, leadMonomial(gen));
+ p->appendTerm(1, leadMono(gen));
basis->insert(std::move(p));
}
}
@@ -89,7 +89,7 @@ void PolyBasis::insert(std::unique_ptr<Poly> poly) {
std::unique_ptr<Poly> PolyBasis::retire(size_t index) {
MATHICGB_ASSERT(index < size());
MATHICGB_ASSERT(!retired(index));
- mMonoLookup->remove(leadMonomial(index));
+ mMonoLookup->remove(leadMono(index));
std::unique_ptr<Poly> poly(mEntries[index].poly);
mEntries[index].poly = 0;
mEntries[index].retired = true;
@@ -104,29 +104,28 @@ std::unique_ptr<Basis> PolyBasis::toBasisAndRetireAll() {
return basis;
}
-size_t PolyBasis::divisor(const_monomial mon) const {
- size_t index = monoLookup().divisor(mon);
+size_t PolyBasis::divisor(ConstMonoRef mono) const {
+ size_t index = monoLookup().divisor(mono);
MATHICGB_ASSERT((index == static_cast<size_t>(-1)) ==
- (divisorSlow(mon) == static_cast<size_t>(-1)));
+ (divisorSlow(mono) == static_cast<size_t>(-1)));
MATHICGB_ASSERT(index == static_cast<size_t>(-1) ||
- ring().monomialIsDivisibleBy(mon, leadMonomial(index)));
+ monoid().divides(leadMono(index), mono));
return index;
}
-size_t PolyBasis::classicReducer(const_monomial mon) const {
- return monoLookup().classicReducer(mon);
- size_t index = monoLookup().classicReducer(mon);
+size_t PolyBasis::classicReducer(ConstMonoRef mono) const {
+ const auto index = monoLookup().classicReducer(mono);
MATHICGB_ASSERT((index == static_cast<size_t>(-1)) ==
- (divisorSlow(mon) == static_cast<size_t>(-1)));
+ (divisorSlow(mono) == static_cast<size_t>(-1)));
MATHICGB_ASSERT(index == static_cast<size_t>(-1) ||
- ring().monomialIsDivisibleBy(mon, leadMonomial(index)));
+ monoid().divides(leadMono(index), mono));
return index;
}
-size_t PolyBasis::divisorSlow(const_monomial mon) const {
+size_t PolyBasis::divisorSlow(ConstMonoRef mono) const {
const size_t stop = size();
for (size_t i = 0; i != stop; ++i)
- if (!retired(i) && ring().monomialIsDivisibleBy(mon, leadMonomial(i)))
+ if (!retired(i) && monoid().divides(leadMono(i), mono))
return i;
return static_cast<size_t>(-1);
}
@@ -134,14 +133,14 @@ size_t PolyBasis::divisorSlow(const_monomial mon) const {
bool PolyBasis::leadMinimalSlow(size_t index) const {
MATHICGB_ASSERT(index < size());
MATHICGB_ASSERT(!retired(index));
- const_monomial const lead = leadMonomial(index);
+ const auto lead = leadMono(index);
EntryCIter const skip = mEntries.begin() + index;
EntryCIter const stop = mEntries.end();
for (EntryCIter it = mEntries.begin(); it != stop; ++it) {
if (it->retired)
continue;
- const_monomial const itLead = it->poly->getLeadMonomial();
- if (ring().monomialIsDivisibleBy(lead, itLead) && it != skip)
+ const auto itLead = it->poly->getLeadMonomial();
+ if (monoid().divides(itLead, lead) && it != skip)
return false;
}
return true;
diff --git a/src/mathicgb/PolyBasis.hpp b/src/mathicgb/PolyBasis.hpp
index bb734be..d0694ca 100755
--- a/src/mathicgb/PolyBasis.hpp
+++ b/src/mathicgb/PolyBasis.hpp
@@ -13,69 +13,70 @@ MATHICGB_NAMESPACE_BEGIN
class PolyRing;
class Basis;
+/// Stores a basis of polynomials. Designed for use in Groebner basis
+/// algorithms.
class PolyBasis {
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;
- // Ring must live for as long as this object.
PolyBasis(
const PolyRing& ring,
std::unique_ptr<MonoLookup> monoLookup
);
- // Deletes the Poly's stored in the basis.
~PolyBasis();
- // Returns the initial monomial basis of the basis.
+ /// Returns a basis of the initial ideal.
std::unique_ptr<Basis> initialIdeal() const;
- // Inserts a polynomial into the basis at index size().
- // Lead monomials must be unique among basis elements.
- // So the index is size() - 1 afterwards since size() will increase by 1.
+ /// Inserts a polynomial into the basis at index size() - or index size() - 1
+ /// after calling, since size() will increase by one.
+ /// Lead monomials must be unique among basis elements.
void insert(std::unique_ptr<Poly> poly);
- // Returns the index of a basis element whose lead term divides mon.
- // Returns -1 if there is no such basis element.
- size_t divisor(const_monomial mon) const;
+ /// Returns the index of a basis element whose lead term divides mon.
+ /// Returns -1 if there is no such basis element.
+ size_t divisor(ConstMonoRef mon) const;
- // As divisor(mon), but if there is more than one divisor then the divisor
- // is chosen according to some notion of which reducer is better.
- size_t classicReducer(const_monomial mon) const;
+ /// As divisor(mon), but if there is more than one divisor then the divisor
+ /// is chosen according to some notion of which reducer is better.
+ size_t classicReducer(ConstMonoRef mon) const;
- // As the non-slow version, but uses simpler and slower code.
- size_t divisorSlow(const_monomial mon) const;
-
- // Replaces basis element at index with the given new value. The lead
- // term of the new polynomial must be the same as the previous one.
- // This is useful for auto-tail-reduction.
+ /// Replaces basis element at index with the given new polynomial. The lead
+ /// term of the new polynomial must be the same as the previous one.
+ /// This is useful for auto-tail-reduction.
void replaceSameLeadTerm(size_t index, std::unique_ptr<Poly> newValue) {
MATHICGB_ASSERT(index < size());
MATHICGB_ASSERT(!retired(index));
- MATHICGB_ASSERT(newValue.get() != 0);
+ MATHICGB_ASSERT(newValue.get() != nullptr);
MATHICGB_ASSERT(!newValue->isZero());
- MATHICGB_ASSERT(mRing.monomialEQ
- (leadMonomial(index), newValue->getLeadMonomial()));
- mMonoLookup->remove(leadMonomial(index));
+ MATHICGB_ASSERT
+ (monoid().equal(leadMono(index), newValue->getLeadMonomial()));
+ mMonoLookup->remove(leadMono(index));
delete mEntries[index].poly;
mEntries[index].poly = newValue.release();
- mMonoLookup->insert(leadMonomial(index), index);
- MATHICGB_ASSERT(mEntries[index].poly != 0);
+ mMonoLookup->insert(leadMono(index), index);
+ MATHICGB_ASSERT(mEntries[index].poly != nullptr);
}
- // Returns the number of basis elements, including retired elements.
+ /// Returns the number of basis elements, including retired elements.
size_t size() const {return mEntries.size();}
- // Returns the ambient polynomial ring of the polynomials in the basis.
const PolyRing& ring() const {return mRing;}
-
const Monoid& monoid() const {return ring().monoid();}
- // Returns a data structure containing the lead monomial of each lead
- // monomial.
+ /// Returns a data structure containing the lead monomial of each basis
+ /// element.
const MonoLookup& monoLookup() const {return *mMonoLookup;}
- // Retires the basis element at index, which frees the memory associated
- // to it, including the basis element polynomial, and marks it as retired.
+ /// Retires the basis element at index, which returns ownership of the
+ /// polynomial to the caller and frees most resources associated to
+ /// that basis elements.
std::unique_ptr<Poly> retire(size_t index);
/// Returns an basis containing all non-retired basis elements and
@@ -83,42 +84,44 @@ public:
/// retirement is that this way no polynomials need be copied.
std::unique_ptr<Basis> toBasisAndRetireAll();
- // Returns true of the basis element at index has been retired.
+ /// Returns true if the basis element at index has been retired.
bool retired(size_t index) const {
MATHICGB_ASSERT(index < size());
return mEntries[index].retired;
}
- // Returns the basis element polynomial at index.
+ /// Returns the basis element polynomial at index.
Poly& poly(size_t index) {
MATHICGB_ASSERT(index < size());
MATHICGB_ASSERT(!retired(index));
return *mEntries[index].poly;
}
- // Returns the basis element polynomial at index.
+ /// Returns the basis element polynomial at index.
const Poly& poly(size_t index) const {
MATHICGB_ASSERT(index < size());
MATHICGB_ASSERT(!retired(index));
return *mEntries[index].poly;
}
- const_monomial leadMonomial(size_t index) const {
+ /// Returns the lead monomial of poly(index).
+ ConstMonoRef leadMono(size_t index) const {
MATHICGB_ASSERT(index < size());
MATHICGB_ASSERT(!retired(index));
return poly(index).getLeadMonomial();
}
- coefficient leadCoefficient(size_t index) const {
+ /// Returns the lead coefficient of poly(index).
+ coefficient leadCoef(size_t index) const {
MATHICGB_ASSERT(index < size());
MATHICGB_ASSERT(!retired(index));
return poly(index).getLeadCoefficient();
}
- // Returns true if the leading monomial of the basis element at index is not
- // divisible by the lead monomial of any other basis element. Lead
- // monomials are required to be unique among basis elements, so the case
- // of several equal lead monomials does not occur.
+ /// Returns true if the leading monomial of the basis element at index is not
+ /// divisible by the lead monomial of any other basis element. Lead
+ /// monomials are required to be unique among basis elements, so the case
+ /// of several equal lead monomials does not occur.
bool leadMinimal(size_t index) const {
MATHICGB_ASSERT(index < size());
MATHICGB_ASSERT(!retired(index));
@@ -126,36 +129,37 @@ public:
return mEntries[index].leadMinimal;
}
- // Returns true if m is not divisible by the lead monomial of any
- // basis element. Equality counts as divisibility.
+ /// Returns true if the lead monomial of poly is not divisible by the
+ /// lead monomial of any basis element. Equality counts as divisibility.
bool leadMinimal(const Poly& poly) const {
MATHICGB_ASSERT(&poly != 0);
return mMonoLookup->divisor(poly.getLeadMonomial()) !=
static_cast<size_t>(-1);
}
- // Returns the number of basis elements with minimal lead monomial.
+ /// Returns the number of basis elements with minimal lead monomial.
size_t minimalLeadCount() const;
- // Returns the index of the basis element of maximal index
- // whose lead monomial is minimal.
+ /// Returns the index of the basis element of maximal index
+ /// whose lead monomial is minimal.
size_t maxIndexMinimalLead() const;
- // Returns the basis element polynomial at index.
+ /// Returns the basis element polynomial at index.
const Poly& basisElement(size_t index) const {
MATHICGB_ASSERT(index < size());
MATHICGB_ASSERT(!retired(index));
return *mEntries[index].poly;
}
- // Returns the number of monomials across all the basis elements.
- // Monomials that appear in more than one basis element are counted more
- // than once.
+ /// Returns the number of monomials across all the basis elements.
+ /// Monomials that appear in more than one basis element are counted more
+ /// than once.
size_t monomialCount() const;
- // Returns how many bytes has been allocated by this object.
+ /// Returns how many bytes has been allocated by this object.
size_t getMemoryUse() const;
+
void usedAsStart(size_t index) const {
MATHICGB_ASSERT(index < size());
++mEntries[index].usedAsStartCount;
@@ -165,7 +169,7 @@ public:
MATHICGB_ASSERT(index < size());
return mEntries[index].usedAsStartCount;
}
-
+
void usedAsReducer(size_t index) const {
MATHICGB_ASSERT(index < size());
++mEntries[index].usedAsReducerCount;
@@ -195,10 +199,11 @@ public:
MATHICGB_ASSERT(index < size());
return mEntries[index].nonSignatureReducerCount;
}
-
+
private:
// Slow versions use simpler code. Used to check results in debug mode.
bool leadMinimalSlow(size_t index) const;
+ size_t divisorSlow(ConstMonoRef mon) const;
class Entry {
public:
diff --git a/src/mathicgb/SPairs.cpp b/src/mathicgb/SPairs.cpp
index 25f38ea..0f2c18f 100755
--- a/src/mathicgb/SPairs.cpp
+++ b/src/mathicgb/SPairs.cpp
@@ -55,8 +55,8 @@ std::pair<size_t, size_t> SPairs::pop() {
mQueue.pop();
MATHICGB_ASSERT(bareMonoid().isLcm(
- monoid(), mBasis.leadMonomial(p.first),
- monoid(), mBasis.leadMonomial(p.second),
+ monoid(), mBasis.leadMono(p.first),
+ monoid(), mBasis.leadMono(p.second),
*lcm
));
if (!advancedBuchbergerLcmCriterion(p.first, p.second, *lcm)) {
@@ -81,8 +81,8 @@ std::pair<size_t, size_t> SPairs::pop(exponent& w) {
bareMonoid().copy(orderMonoid(), *mQueue.topPairData(), *lcm);
MATHICGB_ASSERT(bareMonoid().isLcm(
- monoid(), mBasis.leadMonomial(p.first),
- monoid(), mBasis.leadMonomial(p.second),
+ monoid(), mBasis.leadMono(p.first),
+ monoid(), mBasis.leadMono(p.second),
*lcm
));
if (advancedBuchbergerLcmCriterion(p.first, p.second, *lcm))
@@ -160,7 +160,7 @@ void SPairs::addPairsAssumeAutoReduce(
}
RecordIndexes indexes(newGen, mEliminated, toRetireAndReduce);
- mBasis.monoLookup().multiples(mBasis.leadMonomial(newGen), indexes);
+ mBasis.monoLookup().multiples(mBasis.leadMono(newGen), indexes);
}
addPairs(newGen);
}
@@ -227,12 +227,12 @@ void SPairs::addPairs(size_t newGen) {
prePairMonos.reserve(newGen);
prePairs.reserve(newGen);
- auto newLead = mBasis.leadMonomial(newGen);
+ auto newLead = mBasis.leadMono(newGen);
auto lcm = mBareMonoid.alloc();
for (size_t oldGen = 0; oldGen < newGen; ++oldGen) {
if (mBasis.retired(oldGen))
continue;
- auto oldLead = mBasis.leadMonomial(oldGen);
+ auto oldLead = mBasis.leadMono(oldGen);
if (monoid().relativelyPrime(newLead, oldLead)) {
++mStats.relativelyPrimeHits;
mEliminated.setBit(newGen, oldGen, true);
@@ -274,7 +274,7 @@ bool SPairs::simpleBuchbergerLcmCriterion(
MATHICGB_ASSERT(!mBasis.retired(a));
MATHICGB_ASSERT(!mBasis.retired(b));
MATHICGB_ASSERT(bareMonoid().isLcm
- (monoid(), mBasis.leadMonomial(a), monoid(), mBasis.leadMonomial(b), lcmAB)
+ (monoid(), mBasis.leadMono(a), monoid(), mBasis.leadMono(b), lcmAB)
);
MATHICGB_ASSERT(mEliminated.columnCount() == mBasis.size());
@@ -299,7 +299,7 @@ bool SPairs::simpleBuchbergerLcmCriterion(
MATHICGB_ASSERT(index < mBasis.size());
MATHICGB_ASSERT(!applies()); // should have stopped search in this case
MATHICGB_ASSERT
- (mBareMonoid.divides(mMonoid, mBasis.leadMonomial(index), mLcmAB));
+ (mBareMonoid.divides(mMonoid, mBasis.leadMono(index), mLcmAB));
if (index == mA || index == mB)
return true;
mAlmostApplies = true;
@@ -309,9 +309,9 @@ bool SPairs::simpleBuchbergerLcmCriterion(
// exists i such that b[i] > a[i] && b[i] > c[i] <=>
// exists i such that b[i] > max(a[i], c[i]) <=>
// b does not divide lcm(a[i], c[i])
- auto leadA = mBasis.leadMonomial(mA);
- auto leadB = mBasis.leadMonomial(mB);
- auto leadC = mBasis.leadMonomial(index);
+ auto leadA = mBasis.leadMono(mA);
+ auto leadB = mBasis.leadMono(mB);
+ auto leadC = mBasis.leadMono(index);
if (
!mSPairs.eliminated(index, mA) &&
mMonoid.dividesLcm(leadB, leadC, leadA)
@@ -375,7 +375,7 @@ bool SPairs::simpleBuchbergerLcmCriterion(
!applies &&
!mBasis.retired(cacheB) &&
mBareMonoid.divides
- (monoid(), mBasis.leadMonomial(cacheB), criterion.lcmAB())
+ (monoid(), mBasis.leadMono(cacheB), criterion.lcmAB())
)
applies = !criterion.Criterion::proceed(cacheB);
@@ -384,7 +384,7 @@ bool SPairs::simpleBuchbergerLcmCriterion(
!applies &&
!mBasis.retired(cacheA) &&
mBareMonoid.divides
- (monoid(), mBasis.leadMonomial(cacheA), criterion.lcmAB())
+ (monoid(), mBasis.leadMono(cacheA), criterion.lcmAB())
) {
applies = !criterion.Criterion::proceed(cacheA);
if (applies)
@@ -437,8 +437,8 @@ bool SPairs::simpleBuchbergerLcmCriterionSlow(size_t a, size_t b) const {
auto lcmAB = bareMonoid().alloc();
auto lcm = bareMonoid().alloc();
bareMonoid().lcm(
- monoid(), mBasis.leadMonomial(a),
- monoid(), mBasis.leadMonomial(b),
+ monoid(), mBasis.leadMono(a),
+ monoid(), mBasis.leadMono(b),
*lcmAB
);
size_t stop = mBasis.size();
@@ -446,14 +446,14 @@ bool SPairs::simpleBuchbergerLcmCriterionSlow(size_t a, size_t b) const {
for (; i < stop; ++i) {
if (mBasis.retired(i))
continue;
- if (!bareMonoid().divides(monoid(), mBasis.leadMonomial(i), *lcmAB))
+ if (!bareMonoid().divides(monoid(), mBasis.leadMono(i), *lcmAB))
continue;
if (i == a || i == b)
continue;
if (!eliminated(i, a)) {
bareMonoid().lcm(
- monoid(), mBasis.leadMonomial(a),
- monoid(), mBasis.leadMonomial(i),
+ monoid(), mBasis.leadMono(a),
+ monoid(), mBasis.leadMono(i),
*lcm
);
if (bareMonoid().equal(*lcmAB, *lcm))
@@ -462,8 +462,8 @@ bool SPairs::simpleBuchbergerLcmCriterionSlow(size_t a, size_t b) const {
if (!eliminated(i, b)) {
bareMonoid().lcm(
- monoid(), mBasis.leadMonomial(b),
- monoid(), mBasis.leadMonomial(i),
+ monoid(), mBasis.leadMono(b),
+ monoid(), mBasis.leadMono(i),
*lcm
);
if (bareMonoid().equal(*lcmAB, *lcm))
@@ -482,7 +482,7 @@ bool SPairs::advancedBuchbergerLcmCriterion(
MATHICGB_ASSERT(a != b);
MATHICGB_ASSERT(mEliminated.columnCount() == mBasis.size());
MATHICGB_ASSERT(bareMonoid().isLcm
- (monoid(), mBasis.leadMonomial(a), monoid(), mBasis.leadMonomial(b), lcmAB)
+ (monoid(), mBasis.leadMono(a), monoid(), mBasis.leadMono(b), lcmAB)
);
mStats.late = true;
@@ -548,7 +548,7 @@ bool SPairs::advancedBuchbergerLcmCriterion(
todo.pop_back();
// loop through all potential edges (currentIndex, otherIndex)
- auto currentLead = mBasis.leadMonomial(currentIndex);
+ auto currentLead = mBasis.leadMono(currentIndex);
for (Graph::iterator other = graph.begin(); other != graphEnd; ++other) {
Connection const otherConnect = other->second;
if (currentConnect == otherConnect)
@@ -556,7 +556,7 @@ bool SPairs::advancedBuchbergerLcmCriterion(
size_t const otherIndex = other->first;
MATHICGB_ASSERT(otherIndex != currentIndex);
- auto const otherLead = mBasis.leadMonomial(otherIndex);
+ auto const otherLead = mBasis.leadMono(otherIndex);
// Note that
// lcm(c,d) != lcmAB <=>
// exists i such that max(c[i], d[i]) < lcmAB[i] <=>
@@ -599,7 +599,7 @@ bool SPairs::advancedBuchbergerLcmCriterionSlow(size_t a, size_t b) const {
auto lcmAB = monoid().alloc();
auto lcm = monoid().alloc();
- monoid().lcm(mBasis.leadMonomial(a), mBasis.leadMonomial(b), lcmAB);
+ monoid().lcm(mBasis.leadMono(a), mBasis.leadMono(b), lcmAB);
size_t stop = mBasis.size();
// *** Build the graph vertices
@@ -611,7 +611,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.leadMono(i), *lcmAB))
continue;
Connection con = NotConnected;
if (i == a) {
@@ -635,14 +635,14 @@ bool SPairs::advancedBuchbergerLcmCriterionSlow(size_t a, size_t b) const {
MATHICGB_ASSERT(node.second != NotConnected);
// loop through all potential edges (node.first, i)
- ConstMonoRef leadNode = mBasis.leadMonomial(node.first);
+ ConstMonoRef leadNode = mBasis.leadMono(node.first);
for (size_t i = 0; i < graph.size(); ++i) {
if (node.second == graph[i].second)
continue;
MATHICGB_ASSERT(graph[i].first != node.first);
const size_t other = graph[i].first;
- auto const leadOther = mBasis.leadMonomial(other);
+ auto const leadOther = mBasis.leadMono(other);
monoid().lcm(leadNode, leadOther, lcm);
if (!eliminated(node.first, other) && monoid().equal(*lcm, *lcmAB))
continue; // not an edge in G
@@ -686,8 +686,8 @@ void SPairs::QueueConfiguration::computePairData(
// todo: do something special here?
return; //return false;
}
- Monoid::ConstMonoRef leadA = mBasis.leadMonomial(a);
- Monoid::ConstMonoRef leadB = mBasis.leadMonomial(b);
+ Monoid::ConstMonoRef leadA = mBasis.leadMono(a);
+ Monoid::ConstMonoRef leadB = mBasis.leadMono(b);
orderMonoid().lcm(monoid(), leadA, monoid(), leadB, orderBy);
return; //todo: return true;
}
diff --git a/src/mathicgb/SigPolyBasis.hpp b/src/mathicgb/SigPolyBasis.hpp
index 10dd7aa..46d48ef 100755
--- a/src/mathicgb/SigPolyBasis.hpp
+++ b/src/mathicgb/SigPolyBasis.hpp
@@ -17,6 +17,8 @@ MATHICGB_NAMESPACE_BEGIN
#define MATHICGB_USE_RATIO_RANK true
#endif
+/// Stores a basis of polynomials that each have a signature. Designed for
+/// use in signature Groebner basis algorithms.
class SigPolyBasis {
public:
typedef PolyRing::Monoid Monoid;
@@ -46,12 +48,12 @@ public:
ConstMonoRef leadMono(size_t gen) const {
MATHICGB_ASSERT(gen < size());
- return mBasis.leadMonomial(gen);
+ return mBasis.leadMono(gen);
}
coefficient leadCoef(size_t gen) const {
MATHICGB_ASSERT(gen < size());
- return mBasis.leadCoefficient(gen);
+ return mBasis.leadCoef(gen);
}
ConstMonoRef sigLeadRatio(size_t gen) const {
diff --git a/src/mathicgb/TypicalReducer.cpp b/src/mathicgb/TypicalReducer.cpp
index 1651e1a..97b6bce 100755
--- a/src/mathicgb/TypicalReducer.cpp
+++ b/src/mathicgb/TypicalReducer.cpp
@@ -163,7 +163,8 @@ void TypicalReducer::setMemoryQuantum(size_t quantum) {
std::unique_ptr<Poly> TypicalReducer::classicReduce
(std::unique_ptr<Poly> result, const PolyBasis& basis) {
- const PolyRing& ring = basis.ring();
+ const auto& ring = basis.ring();
+ const auto& monoid = ring.monoid();
MATHICGB_ASSERT(&result->ring() == &ring);
if (tracingLevel > 100)
@@ -190,8 +191,8 @@ std::unique_ptr<Poly> TypicalReducer::classicReduce
++steps;
basis.usedAsReducer(reducer);
monomial mon = ring.allocMonomial(mArena);
- ring.monomialDivide(v.monom, basis.leadMonomial(reducer), mon);
- ring.coefficientDivide(v.coeff, basis.leadCoefficient(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