[mathicgb] 372/393: Moved interface of SigPolyBasis 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 75df7aa473558dabc454fe2623e303381b3f9198
Author: Bjarke Hammersholt Roune <bjarkehr.code at gmail.com>
Date: Tue Sep 17 18:26:59 2013 +0200
Moved interface of SigPolyBasis to using MonoMonoid.
---
src/mathicgb/MonoMonoid.hpp | 2 +-
src/mathicgb/SigPolyBasis.cpp | 71 +++++++++++++++++++++--------------------
src/mathicgb/SigPolyBasis.hpp | 21 ++++++------
src/mathicgb/SignatureGB.cpp | 26 +++++++--------
src/mathicgb/StaticMonoMap.hpp | 3 +-
src/mathicgb/TypicalReducer.cpp | 4 +--
6 files changed, 62 insertions(+), 65 deletions(-)
diff --git a/src/mathicgb/MonoMonoid.hpp b/src/mathicgb/MonoMonoid.hpp
index ff7d22c..0f7980b 100755
--- a/src/mathicgb/MonoMonoid.hpp
+++ b/src/mathicgb/MonoMonoid.hpp
@@ -1177,7 +1177,7 @@ public:
freeRaw(*mono);
}
- bool fromPool(ConstMonoRef mono) const {mPool.fromPool(mono);}
+ bool fromPool(ConstMonoRef mono) const {return mPool.fromPool(mono);}
// *** Classes for holding and referring to monomials
diff --git a/src/mathicgb/SigPolyBasis.cpp b/src/mathicgb/SigPolyBasis.cpp
index e2e2f5c..06b456a 100755
--- a/src/mathicgb/SigPolyBasis.cpp
+++ b/src/mathicgb/SigPolyBasis.cpp
@@ -53,25 +53,24 @@ void SigPolyBasis::addComponent() {
mSignatureLookup.back() = lookup.release(); // only release after alloc
}
-void SigPolyBasis::insert(monomial sig, std::unique_ptr<Poly> f)
-{
- MATHICGB_ASSERT(f.get() != 0);
+void SigPolyBasis::insert(Mono ownedSig, std::unique_ptr<Poly> f) {
+ MATHICGB_ASSERT(f.get() != nullptr);
+ MATHICGB_ASSERT(!f->isZero());
MATHICGB_ASSERT(f->getLeadCoefficient() != 0);
- // This assert really should work. todo: why doesn't it?
- //MATHICGB_ASSERT(sig.isNull() || ring().fromPool(sig));
- const size_t index = mSignatures.size();
+ MATHICGB_ASSERT(!ownedSig.isNull());
+ MATHICGB_ASSERT(monoid().fromPool(*ownedSig));
- mSignatures.push_back(sig);
+ const size_t index = mSignatures.size();
+ mSignatures.push_back(Monoid::toOld(*ownedSig.release()));
+ auto sig = mSignatures.back();
- monomial ratio = 0;
- if (!sig.isNull()) {
- const size_t component = ring().monomialGetComponent(sig);
- MATHICGB_ASSERT(component < mSignatureLookup.size());
- mSignatureLookup[component]->insert(sig, index);
-
- ratio = ring().allocMonomial();
- ring().monomialDivideToNegative(sig, f->getLeadMonomial(), ratio);
- }
+ const size_t component = ring().monomialGetComponent(sig);
+ MATHICGB_ASSERT(component < mSignatureLookup.size());
+ mSignatureLookup[component]->insert(sig, index);
+
+ auto ratio = ring().allocMonomial();
+ ring().monomialDivideToNegative(sig, f->getLeadMonomial(), ratio);
+
mSigLeadRatio.push_back(ratio);
const_monomial const lead = f->getLeadMonomial();
@@ -166,8 +165,8 @@ again:
}
size_t SigPolyBasis::regularReducer(
- const_monomial sig,
- const_monomial term
+ ConstMonoRef sig,
+ ConstMonoRef term
) const {
size_t reducer = monoLookup().regularReducer(sig, term);
#ifdef MATHICGB_SLOW_DEBUG
@@ -189,8 +188,8 @@ size_t SigPolyBasis::regularReducer(
}
size_t SigPolyBasis::regularReducerSlow(
- const_monomial sig,
- const_monomial term
+ ConstMonoRef sig,
+ ConstMonoRef term
) const {
monomial m = ring().allocMonomial();
const size_t stop = size();
@@ -296,20 +295,19 @@ size_t SigPolyBasis::highBaseDivisorSlow(size_t newGenerator) const {
return highDivisor;
}
-size_t SigPolyBasis::minimalLeadInSig(const_monomial sig) const {
- MATHICGB_ASSERT(! sig.isNull() );
- const size_t component = ring().monomialGetComponent(sig);
- const size_t minLeadGen = mSignatureLookup[component]->minimalLeadInSig(sig);
+size_t SigPolyBasis::minimalLeadInSig(ConstMonoRef sig) const {
+ const auto component = monoid().component(sig);
+ const auto minLeadGen = mSignatureLookup[component]->minimalLeadInSig(sig);
MATHICGB_ASSERT(minLeadGen == minimalLeadInSigSlow(sig));
return minLeadGen;
}
-size_t SigPolyBasis::minimalLeadInSigSlow(const_monomial sig) const {
+size_t SigPolyBasis::minimalLeadInSigSlow(ConstMonoRef sig) const {
monomial multiplier = ring().allocMonomial();
monomial minLead = ring().allocMonomial();
size_t minLeadGen = static_cast<size_t>(-1);
- const int sigComponent = ring().monomialGetComponent(sig);
+ const auto sigComponent = monoid().component(sig);
const size_t genCount = size();
for (size_t gen = 0; gen < genCount; ++gen) {
if (monoid().component(signature(gen)) != sigComponent)
@@ -354,9 +352,10 @@ size_t SigPolyBasis::minimalLeadInSigSlow(const_monomial sig) const {
return minLeadGen;
}
-bool SigPolyBasis::isSingularTopReducibleSlow
-(const Poly& poly, const_monomial sig) const {
- MATHICGB_ASSERT( ! sig.isNull() );
+bool SigPolyBasis::isSingularTopReducibleSlow(
+ const Poly& poly,
+ ConstMonoRef sig
+) const {
if (poly.isZero())
return false;
@@ -475,14 +474,16 @@ size_t SigPolyBasis::ratioRank(const_monomial ratio) const {
}
SigPolyBasis::StoredRatioCmp::StoredRatioCmp(
- const_monomial numerator,
- const_monomial denominator,
- const SigPolyBasis& basis):
+ ConstMonoRef numerator,
+ ConstMonoRef denominator,
+ const SigPolyBasis& basis
+):
mBasis(basis)
{
- const PolyRing& ring = basis.ring();
- mRatio = ring.allocMonomial();
- ring.monomialDivideToNegative(numerator, denominator, mRatio);
+ const auto& monoid = basis.ring().monoid();
+ mRatio = Monoid::toOld(*monoid.alloc().release());
+
+ monoid.divideToNegative(denominator, numerator, mRatio);
if (SigPolyBasis::mUseRatioRank) {
mRatioRank = basis.ratioRank(mRatio);
diff --git a/src/mathicgb/SigPolyBasis.hpp b/src/mathicgb/SigPolyBasis.hpp
index 0de1240..86e9b6f 100755
--- a/src/mathicgb/SigPolyBasis.hpp
+++ b/src/mathicgb/SigPolyBasis.hpp
@@ -65,8 +65,8 @@ public:
void addComponent();
// Takes over ownership of sig and f. sig must come from the pool
- // of ring() and f must have been allocated with new.
- void insert(monomial sig, std::unique_ptr<Poly> f);
+ // of ring().
+ void insert(Mono sig, std::unique_ptr<Poly> f);
ConstMonoRef signature(size_t gen) const {
MATHICGB_ASSERT(gen < size());
@@ -77,7 +77,7 @@ public:
// signature sig. Returns -1 if no such element exists. A basis element
// u is a regular reducer if leadTerm(u) divides term
// and (term / leadTerm(u)) * signature(u) < sig.
- size_t regularReducer(const_monomial sig, const_monomial term) const;
+ size_t regularReducer(ConstMonoRef sig, ConstMonoRef term) const;
// Uses the functionality in the divisor finder for
// computing up to maxDivisors low ratio base divisors.
@@ -85,7 +85,8 @@ public:
void lowBaseDivisors(
std::vector<size_t>& divisors,
size_t maxDivisors,
- size_t newGenerator) const;
+ size_t newGenerator
+ ) const;
// Uses the functionality in the divisor finder for
// computing a high base divisor. Returns the index
@@ -94,7 +95,7 @@ public:
// Find the basis element g_i whose signature S divides sig
// such that (S/sig)g_i has minimal leading term. Returns i.
- size_t minimalLeadInSig(const_monomial sig) const;
+ size_t minimalLeadInSig(ConstMonoRef sig) const;
// Returns true if poly can be singular reduced in signature sig.
// In other words, returns true if there is a basis element with
@@ -102,7 +103,7 @@ public:
// of poly and such that N/M*S == sig. This is slow because it is
// currently only used for asserts - implement a fast version if
// that changes.
- bool isSingularTopReducibleSlow(const Poly& poly, const_monomial sig) const;
+ bool isSingularTopReducibleSlow(const Poly& poly, ConstMonoRef sig) const;
void display(std::ostream& out) const;
void displayFancy(std::ostream& out, const Processor& processor) const;
@@ -121,8 +122,8 @@ public:
// Stores the ratio numerator/denominator and prepares it for comparing
// to the sig/lead ratios in basis.
StoredRatioCmp(
- const_monomial numerator,
- const_monomial denominator,
+ ConstMonoRef numerator,
+ ConstMonoRef denominator,
const SigPolyBasis& basis);
~StoredRatioCmp();
@@ -141,8 +142,8 @@ public:
private:
// Slow versions use simpler code. Used to check results in debug mode.
- size_t regularReducerSlow(const_monomial sig, const_monomial term) const;
- size_t minimalLeadInSigSlow(const_monomial sig) const;
+ size_t regularReducerSlow(ConstMonoRef sig, ConstMonoRef term) const;
+ size_t minimalLeadInSigSlow(ConstMonoRef sig) const;
size_t highBaseDivisorSlow(size_t newGenerator) const;
void lowBaseDivisorsSlow(
std::vector<size_t>& divisors,
diff --git a/src/mathicgb/SignatureGB.cpp b/src/mathicgb/SignatureGB.cpp
index 2483305..f1cc259 100755
--- a/src/mathicgb/SignatureGB.cpp
+++ b/src/mathicgb/SignatureGB.cpp
@@ -67,18 +67,16 @@ SignatureGB::SignatureGB(
GB->addComponent();
for (Component i = 0; i < componentCount; i++) {
- Poly *g = new Poly(*R);
+ auto g = make_unique<Poly>(*R);
basis.getPoly(i)->copy(*g);
g->makeMonic();
- monomial sig = 0;
- sig = R->allocMonomial();
- R->monomialEi(i, sig);
- mProcessor->preprocess(sig);
- {
- std::unique_ptr<Poly> autoG(g);
- GB->insert(sig, std::move(autoG));
- }
+ auto sig = monoid().alloc();
+ monoid().setIdentity(*sig);
+ monoid().setComponent(i, *sig);
+ mProcessor->preprocess(*sig);
+
+ GB->insert(std::move(sig), std::move(g));
}
// Populate SP
@@ -107,7 +105,7 @@ void SignatureGB::computeGrobnerBasis()
if (Hsyz->member(*sig))
++syzygySigs;
else
- GB->minimalLeadInSig(Monoid::toOld(*sig));
+ GB->minimalLeadInSig(*sig);
}
const double syzygyRatio = static_cast<double>(syzygySigs) / sigs;
std::cerr << "*** Early exit statistics ***\n"
@@ -150,7 +148,7 @@ bool SignatureGB::processSPair
MATHICGB_ASSERT(!pairs.empty());
// the module term to reduce is multiple * GB->getSignature(gen)
- size_t gen = GB->minimalLeadInSig(Monoid::toOld(*sig));
+ size_t gen = GB->minimalLeadInSig(*sig);
MATHICGB_ASSERT(gen != static_cast<size_t>(-1));
monomial multiple = R->allocMonomial();
monoid().divide(GB->signature(gen), *sig, multiple);
@@ -176,11 +174,9 @@ bool SignatureGB::processSPair
}
// new basis element
- MATHICGB_ASSERT(!GB->isSingularTopReducibleSlow(*f, Monoid::toOld(*sig)));
+ MATHICGB_ASSERT(!GB->isSingularTopReducibleSlow(*f, *sig));
- // todo: what are the correct ownership relations here?
- auto ptr = sig.release();
- GB->insert(Monoid::toOld(*ptr), std::move(f));
+ GB->insert(std::move(sig), std::move(f));
MATHICGB_LOG(SigSPairFinal) << " s-reduced to new basis element.\n";
diff --git a/src/mathicgb/StaticMonoMap.hpp b/src/mathicgb/StaticMonoMap.hpp
index ea0884e..92b3b9d 100755
--- a/src/mathicgb/StaticMonoMap.hpp
+++ b/src/mathicgb/StaticMonoMap.hpp
@@ -168,8 +168,7 @@ public:
const SigPolyBasis& sigBasis,
const bool preferSparseReducers
) const {
- SigPolyBasis::StoredRatioCmp ratioCmp
- (Monoid::toOld(sig), Monoid::toOld(mono), sigBasis);
+ SigPolyBasis::StoredRatioCmp ratioCmp(sig, mono, sigBasis);
const auto& basis = sigBasis.basis();
auto reducer = size_t(-1);
diff --git a/src/mathicgb/TypicalReducer.cpp b/src/mathicgb/TypicalReducer.cpp
index 9e643e2..1651e1a 100755
--- a/src/mathicgb/TypicalReducer.cpp
+++ b/src/mathicgb/TypicalReducer.cpp
@@ -36,7 +36,7 @@ std::unique_ptr<Poly> TypicalReducer::regularReduce(
monomial u = ring.allocMonomial(mArena);
monoid.multiply(multiple, basis.leadMono(basisElement), tproduct);
- size_t reducer = basis.regularReducer(Monoid::toOld(sig), tproduct);
+ auto reducer = basis.regularReducer(sig, tproduct);
if (reducer == static_cast<size_t>(-1)) {
mArena.freeAllAllocs();
return nullptr; // singular reduction: no regular top reduction possible
@@ -58,7 +58,7 @@ std::unique_ptr<Poly> TypicalReducer::regularReduce(
unsigned long long steps = 2; // number of steps in this reduction
for (const_term v; leadTerm(v);) {
MATHICGB_ASSERT(v.coeff != 0);
- reducer = basis.regularReducer(Monoid::toOld(sig), v.monom);
+ reducer = basis.regularReducer(sig, v.monom);
if (reducer == static_cast<size_t>(-1)) { // no reducer found
result->appendTerm(v.coeff, v.monom);
removeLeadTerm();
--
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