[mathicgb] 349/393: Improved logging for signature algorithm a bit, made schreyer ordering the default for text input on the command line and did a bit of code cleanup.
Doug Torrance
dtorrance-guest at moszumanska.debian.org
Fri Apr 3 15:59:33 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 0d439fddcbbeec4136c32db66880fecadde48c07
Author: Bjarke Hammersholt Roune <bjarkehr.code at gmail.com>
Date: Fri Aug 30 18:36:37 2013 +0200
Improved logging for signature algorithm a bit, made schreyer ordering the default for text input on the command line and did a bit of code cleanup.
---
src/mathicgb/F4Reducer.cpp | 4 +-
src/mathicgb/F4Reducer.hpp | 2 +-
src/mathicgb/MathicIO.hpp | 2 +-
src/mathicgb/Reducer.hpp | 2 +-
src/mathicgb/SigPolyBasis.cpp | 64 +++++++++++----------
src/mathicgb/SigPolyBasis.hpp | 8 +--
src/mathicgb/SignatureGB.cpp | 123 +++++++++++++++++++---------------------
src/mathicgb/TypicalReducer.cpp | 6 +-
src/mathicgb/TypicalReducer.hpp | 29 +++++-----
9 files changed, 121 insertions(+), 119 deletions(-)
diff --git a/src/mathicgb/F4Reducer.cpp b/src/mathicgb/F4Reducer.cpp
index 503b902..023b914 100755
--- a/src/mathicgb/F4Reducer.cpp
+++ b/src/mathicgb/F4Reducer.cpp
@@ -236,7 +236,7 @@ void F4Reducer::classicReducePolySet
mRing.freeMonomial(*it);
}
-Poly* F4Reducer::regularReduce(
+std::unique_ptr<Poly> F4Reducer::regularReduce(
const_monomial sig,
const_monomial multiple,
size_t basisElement,
@@ -248,7 +248,7 @@ Poly* F4Reducer::regularReduce(
auto p = mFallback->regularReduce(sig, multiple, basisElement, basis);
mSigStats = mFallback->sigStats();
mClassicStats = mFallback->classicStats();
- return std::move(p);
+ return p;
}
void F4Reducer::setMemoryQuantum(size_t quantum) {
diff --git a/src/mathicgb/F4Reducer.hpp b/src/mathicgb/F4Reducer.hpp
index 47bb4df..8915a6d 100755
--- a/src/mathicgb/F4Reducer.hpp
+++ b/src/mathicgb/F4Reducer.hpp
@@ -49,7 +49,7 @@ public:
std::vector<std::unique_ptr<Poly> >& reducedOut
);
- virtual Poly* regularReduce(
+ virtual std::unique_ptr<Poly> regularReduce(
const_monomial sig,
const_monomial multiple,
size_t basisElement,
diff --git a/src/mathicgb/MathicIO.hpp b/src/mathicgb/MathicIO.hpp
index 8dd2f39..e26aaae 100755
--- a/src/mathicgb/MathicIO.hpp
+++ b/src/mathicgb/MathicIO.hpp
@@ -249,7 +249,7 @@ auto MathicIO<M, BF>::readOrder(
const bool withComponent,
Scanner& in
) -> Order {
- const bool schreyering = in.match("schreyer");
+ const bool schreyering = in.match("schreyer") || !in.match("noschreyer");
bool lexBaseOrder = !in.match("revlex") && in.match("lex");
auto gradingCount = in.readInteger<VarIndex>();
diff --git a/src/mathicgb/Reducer.hpp b/src/mathicgb/Reducer.hpp
index ba41a05..ddb21f0 100755
--- a/src/mathicgb/Reducer.hpp
+++ b/src/mathicgb/Reducer.hpp
@@ -65,7 +65,7 @@ public:
basis elements in basis. Returns null (0) if multiple*basisElement
is not regular top reducible -- this indicates a singular
reduction. */
- virtual Poly* regularReduce(
+ virtual std::unique_ptr<Poly> regularReduce(
const_monomial sig,
const_monomial multiple,
size_t basisElement,
diff --git a/src/mathicgb/SigPolyBasis.cpp b/src/mathicgb/SigPolyBasis.cpp
index 5d7dccc..4fae906 100755
--- a/src/mathicgb/SigPolyBasis.cpp
+++ b/src/mathicgb/SigPolyBasis.cpp
@@ -4,6 +4,7 @@
#include "SigPolyBasis.hpp"
#include "Poly.hpp"
+#include <mathic.h>
#include <limits>
#include <iostream>
#include <iomanip>
@@ -373,41 +374,46 @@ bool SigPolyBasis::isSingularTopReducibleSlow
return false;
}
-void SigPolyBasis::display(std::ostream &o) const
-{
- for (size_t i = 0; i<mBasis.size(); i++)
- {
- o << i << " ";
- if (! mSignatures[i].isNull())
- ring().monomialDisplay(o, mSignatures[i]);
- if (!mBasis.retired(i)) {
- o << " ";
- mBasis.poly(i).display(o, false); // don't display component
- }
- o << std::endl;
- }
-}
-
-void SigPolyBasis::displayBrief(std::ostream &o) const
-{
- for (size_t i = 0; i<mBasis.size(); i++)
- {
- o << std::setw(4) << i << " ";
- o << std::setw(4) << mBasis.usedAsStartCount(i) << " ";
- o << std::setw(6) << mBasis.usedAsReducerCount(i) << " ";
- o << std::setw(6) << mBasis.wasPossibleReducerCount(i) << " ";
- o << std::setw(6) << mBasis.wasNonSignatureReducerCount(i) << " ";
- o << std::setw(6) << mBasis.poly(i).nTerms() << " ";
+void SigPolyBasis::display(std::ostream& o) const {
+ for (size_t i = 0; i < mBasis.size(); i++) {
+ o << i << " ";
+ if (!mSignatures[i].isNull())
ring().monomialDisplay(o, mSignatures[i]);
+ if (!mBasis.retired(i)) {
o << " ";
- ring().monomialDisplay(o, mBasis.leadMonomial(i));
- o << std::endl;
+ mBasis.poly(i).display(o, false); // don't display component
}
+ o << std::endl;
+ }
}
-void SigPolyBasis::dump() const
+void SigPolyBasis::displayFancy
+ (std::ostream& out, const Processor& processor) const
{
- display(std::cerr);
+ mathic::ColumnPrinter pr;
+ auto& indexOut = pr.addColumn(false) << "Index\n";
+ auto& sigOut = pr.addColumn(false) << "sig\n";
+ auto& polyOut = pr.addColumn() << "poly\n";
+ pr.repeatToEndOfLine('-');
+
+ auto sig = monoid().alloc();
+ for (size_t i = 0; i < mBasis.size(); i++) {
+ indexOut << i << '\n';
+
+ if (!mSignatures[i].isNull()) {
+ monoid().copy(mSignatures[i], sig);
+ processor.postprocess(sig);
+ ring().monomialDisplay(sigOut, Monoid::toOld(*sig.ptr()));
+ }
+ sigOut << '\n';
+
+ if (mBasis.retired(i))
+ polyOut << "retired";
+ else
+ mBasis.poly(i).display(polyOut, false);
+ polyOut << '\n';
+ }
+ out << pr;
}
void SigPolyBasis::postprocess(const MonoProcessor<PolyRing::Monoid>& processor) {
diff --git a/src/mathicgb/SigPolyBasis.hpp b/src/mathicgb/SigPolyBasis.hpp
index 6feab69..fa6428a 100755
--- a/src/mathicgb/SigPolyBasis.hpp
+++ b/src/mathicgb/SigPolyBasis.hpp
@@ -20,6 +20,7 @@ MATHICGB_NAMESPACE_BEGIN
class SigPolyBasis {
public:
typedef PolyRing::Monoid Monoid;
+ typedef MonoProcessor<Monoid> Processor;
SigPolyBasis(
const PolyRing* R,
@@ -96,9 +97,8 @@ public:
// that changes.
bool isSingularTopReducibleSlow(const Poly& poly, const_monomial sig) const;
- void display(std::ostream &o) const;
- void displayBrief(std::ostream &o) const;
- void dump() const;
+ void display(std::ostream& out) const;
+ void displayFancy(std::ostream& out, const Processor& processor) const;
size_t getMemoryUse() const;
// Compares the signature/lead ratio of basis element a to basis element b
@@ -107,7 +107,7 @@ public:
/// Post processes all signatures. This currently breaks all sorts
/// of internal invariants - it's supposed to be a temporary hack.
- void postprocess(const MonoProcessor<PolyRing::Monoid>& processor);
+ void postprocess(const Processor& processor);
class StoredRatioCmp {
public:
diff --git a/src/mathicgb/SignatureGB.cpp b/src/mathicgb/SignatureGB.cpp
index b9b62dd..597c3f0 100755
--- a/src/mathicgb/SignatureGB.cpp
+++ b/src/mathicgb/SignatureGB.cpp
@@ -8,9 +8,20 @@
#include "SigSPairs.hpp"
#include "PolyHeap.hpp"
#include "ModuleMonoSet.hpp"
+#include "LogDomain.hpp"
#include <mathic.h>
#include <limits>
+MATHICGB_DEFINE_LOG_DOMAIN(
+ SigBasisChanged,
+ "Show the signature basis after each change."
+);
+
+MATHICGB_DEFINE_LOG_DOMAIN(
+ SigSPairFinal,
+ "Show the outcome of final processing for S-pairs."
+);
+
MATHICGB_NAMESPACE_BEGIN
int tracingLevel = 0;
@@ -148,48 +159,37 @@ bool SignatureGB::processSPair
GB->basis().usedAsStart(gen);
// reduce multiple * GB->getSignature(gen)
- Poly* f = reducer->regularReduce(sig, multiple, gen, *GB);
+ auto f = reducer->regularReduce(sig, multiple, gen, *GB);
R->freeMonomial(multiple);
- if (f == 0) { // singular reduction
- MATHICGB_ASSERT(f == 0);
- if (tracingLevel >= 7)
- std::cerr << "singular reduction" << std::endl;
+ if (f == nullptr) { // singular reduction
R->freeMonomial(sig);
+ MATHICGB_LOG(SigSPairFinal) << " eliminated by singular criterion.\n";
return true;
}
- MATHICGB_ASSERT(f != 0);
if (f->isZero()) { // reduction to zero
- if (tracingLevel >= 7)
- std::cerr << "zero reduction" << std::endl;
Hsyz->insert(sig);
SP->newSyzygy(sig);
SP->setKnownSyzygies(mSpairTmp);
- delete f;
+ MATHICGB_LOG(SigSPairFinal) << " s-reduced to zero.\n";
return false;
}
// new basis element
MATHICGB_ASSERT(!GB->isSingularTopReducibleSlow(*f, sig));
- {
- std::unique_ptr<Poly> uniqueF(f);
- GB->insert(sig, std::move(uniqueF));
- }
+ GB->insert(sig, std::move(f));
+
+ MATHICGB_LOG(SigSPairFinal) << " s-reduced to new basis element.\n";
+
+ MATHICGB_IF_STREAM_LOG(SigBasisChanged) {
+ stream << "New signature basis element. The basis is now:\n";
+ GB->displayFancy(stream, *mProcessor);
+ };
+
SP->newPairs(GB->size()-1);
- if (tracingLevel >= 1) {
- std::cerr << "New GB element." << std::endl;
- size_t r = GB->size()-1;
- std::cerr << "gb" << r << ": ";
- R->monomialDisplay(std::cerr, GB->getSignature(r));
- std::cerr << " ";
- R->monomialDisplay(std::cerr, GB->poly(r).getLeadMonomial());
- std::cerr << std::endl;
- if (tracingLevel >= 7)
- GB->dump();
- }
return true;
}
@@ -201,58 +201,51 @@ bool SignatureGB::step()
++stats_sPairSignaturesDone;
stats_sPairsDone += mSpairTmp.size();
- if (tracingLevel >= 3) {
- std::cerr << "doing signature ";
- R->monomialDisplay(std::cerr, sig);
- std::cerr << std::endl;
- }
+ MATHICGB_IF_STREAM_LOG(SigSPairFinal) {
+ stream << "Final processing of signature ";
+ R->monomialDisplay(stream, sig);
+ stream << '\n';
+ };
if (Hsyz->member(sig)) {
++stats_SignatureCriterionLate;
SP->setKnownSyzygies(mSpairTmp);
- if (tracingLevel >= 3)
- std::cerr << "eliminated as in syzygy module" << std::endl;
R->freeMonomial(sig);
+ MATHICGB_LOG(SigSPairFinal) << " eliminated by signature criterion.\n";
return true;
}
- // Not a known syzygy
-
while (!mKoszuls.empty() && R->monoid().lessThan(mKoszuls.top(), sig))
- {
- mKoszuls.pop();
- }
-
- 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);
- SP->setKnownSyzygies(mSpairTmp);
- return true;
- }
+ mKoszuls.pop();
+
+ 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);
+ SP->setKnownSyzygies(mSpairTmp);
+ MATHICGB_LOG(SigSPairFinal) << " eliminated by Koszul criterion.\n";
+ return true;
+ }
- typedef std::vector<std::pair<size_t, size_t> >::const_iterator iter;
- if (mPostponeKoszul)
- {
- // Relatively prime check
- for (iter 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))
- {
- ++stats_relativelyPrimeEliminated;
- Hsyz->insert(sig);
- SP->newSyzygy(sig);
- SP->setKnownSyzygies(mSpairTmp);
- return true;
- }
- }
+ 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)) {
+ ++stats_relativelyPrimeEliminated;
+ Hsyz->insert(sig);
+ SP->newSyzygy(sig);
+ SP->setKnownSyzygies(mSpairTmp);
+ MATHICGB_LOG(SigSPairFinal) <<
+ " eliminated by relatively prime criterion.\n";
+ return true;
+ }
}
+ }
#ifdef DEBUG
- for (iter it = mSpairTmp.begin(); it != mSpairTmp.end(); ++it) {
+ 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));
@@ -263,7 +256,7 @@ bool SignatureGB::step()
++stats_pairsReduced;
if (!processSPair(sig, mSpairTmp) || !mPostponeKoszul)
return true;
- for (iter it = mSpairTmp.begin(); it != mSpairTmp.end(); ++it) {
+ for (auto it = mSpairTmp.begin(); it != mSpairTmp.end(); ++it) {
std::pair<size_t, size_t> p = *it;
if (GB->ratioCompare(p.first, p.second) == LT)
std::swap(p.first, p.second);
diff --git a/src/mathicgb/TypicalReducer.cpp b/src/mathicgb/TypicalReducer.cpp
index ad10d23..9c7212f 100755
--- a/src/mathicgb/TypicalReducer.cpp
+++ b/src/mathicgb/TypicalReducer.cpp
@@ -23,7 +23,7 @@ size_t TypicalReducer::getMemoryUse() const {
return mArena.getMemoryUse();
}
-Poly* TypicalReducer::regularReduce(
+std::unique_ptr<Poly> TypicalReducer::regularReduce(
const_monomial sig,
const_monomial multiple,
size_t basisElement,
@@ -40,7 +40,7 @@ Poly* TypicalReducer::regularReduce(
if (reducer == static_cast<size_t>(-1)) {
++mSigStats.singularReductions;
mArena.freeAllAllocs();
- return 0; // singular reduction: no regular top reduction possible
+ return nullptr; // singular reduction: no regular top reduction possible
}
ring.monomialDivide(tproduct, basis.getLeadMonomial(reducer), u);
@@ -54,7 +54,7 @@ Poly* TypicalReducer::regularReduce(
insertTail(const_term(coef, u), &basis.poly(reducer));
basis.basis().usedAsReducer(reducer);
- Poly* result = new Poly(ring);
+ auto result = make_unique<Poly>(ring);
unsigned long long steps = 2; // number of steps in this reduction
for (const_term v; leadTerm(v);) {
diff --git a/src/mathicgb/TypicalReducer.hpp b/src/mathicgb/TypicalReducer.hpp
index 27b55a6..19a1228 100755
--- a/src/mathicgb/TypicalReducer.hpp
+++ b/src/mathicgb/TypicalReducer.hpp
@@ -25,30 +25,33 @@ class TypicalReducer : public Reducer {
public:
virtual unsigned int preferredSetSize() const;
- virtual Poly* regularReduce(
+ virtual std::unique_ptr<Poly> regularReduce(
const_monomial sig,
const_monomial multiple,
size_t basisElement,
- const SigPolyBasis& basis);
+ const SigPolyBasis& basis
+ );
virtual std::unique_ptr<Poly> classicReduce
- (const Poly& poly, const PolyBasis& basis);
+ (const Poly& poly, const PolyBasis& basis);
virtual std::unique_ptr<Poly> classicTailReduce
- (const Poly& poly, const PolyBasis& basis);
+ (const Poly& poly, const PolyBasis& basis);
virtual std::unique_ptr<Poly> classicReduceSPoly
(const Poly& a, const Poly& b, const PolyBasis& basis);
- virtual void classicReduceSPolySet
- (std::vector<std::pair<size_t, size_t> >& spairs,
- const PolyBasis& basis,
- std::vector<std::unique_ptr<Poly> >& reducedOut);
-
- virtual void classicReducePolySet
- (const std::vector<std::unique_ptr<Poly> >& polys,
- const PolyBasis& basis,
- std::vector<std::unique_ptr<Poly> >& reducedOut);
+ virtual void classicReduceSPolySet(
+ std::vector<std::pair<size_t, size_t> >& spairs,
+ const PolyBasis& basis,
+ std::vector<std::unique_ptr<Poly> >& reducedOut
+ );
+
+ virtual void classicReducePolySet(
+ const std::vector<std::unique_ptr<Poly> >& polys,
+ const PolyBasis& basis,
+ std::vector<std::unique_ptr<Poly> >& reducedOut
+ );
virtual void setMemoryQuantum(size_t quantum);
--
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