[mathicgb] 376/393: Further clean-up on Poly.
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 6257483e96a5ad392f5fb26ba670b9db8e6a9047
Author: Bjarke Hammersholt Roune <bjarkehr.code at gmail.com>
Date: Wed Sep 18 15:25:22 2013 +0200
Further clean-up on Poly.
---
src/mathicgb.cpp | 6 +-
src/mathicgb/Basis.cpp | 2 +-
src/mathicgb/ClassicGBAlg.cpp | 16 ++--
src/mathicgb/F4MatrixBuilder.cpp | 47 +++++-----
src/mathicgb/F4MatrixBuilder2.cpp | 49 +++++------
src/mathicgb/MathicIO.hpp | 6 +-
src/mathicgb/MonoMonoid.hpp | 2 +-
src/mathicgb/MonoProcessor.hpp | 2 +-
src/mathicgb/Poly.cpp | 170 +++++++++---------------------------
src/mathicgb/Poly.hpp | 179 ++++++++++++++++----------------------
src/mathicgb/PolyBasis.cpp | 8 +-
src/mathicgb/PolyBasis.hpp | 8 +-
src/mathicgb/PolyRing.hpp | 6 +-
src/mathicgb/ReducerDedup.cpp | 8 +-
src/mathicgb/ReducerHash.cpp | 5 +-
src/mathicgb/ReducerHashPack.cpp | 8 +-
src/mathicgb/ReducerNoDedup.cpp | 8 +-
src/mathicgb/ReducerPack.cpp | 8 +-
src/mathicgb/ReducerPackDedup.cpp | 12 +--
src/mathicgb/SigPolyBasis.cpp | 8 +-
src/mathicgb/SparseMatrix.cpp | 2 +-
src/mathicgb/TypicalReducer.cpp | 18 ++--
src/mathicgb/TypicalReducer.hpp | 2 +-
src/test/F4MatrixBuilder.cpp | 8 +-
src/test/F4MatrixReducer.cpp | 7 +-
src/test/QuadMatrixBuilder.cpp | 19 ++--
src/test/poly-test.cpp | 7 +-
27 files changed, 253 insertions(+), 368 deletions(-)
diff --git a/src/mathicgb.cpp b/src/mathicgb.cpp
index e32993d..a9c78e3 100755
--- a/src/mathicgb.cpp
+++ b/src/mathicgb.cpp
@@ -720,7 +720,7 @@ void GroebnerInputIdealStream::appendTermDone(Coefficient coefficient) {
// @todo: do this directly into the polynomial instead of copying a second
// time.
mPimpl->ring.monomialSetExternalExponents(mPimpl->monomial, mExponents);
- mPimpl->poly.appendTerm(coefficient, mPimpl->monomial);
+ mPimpl->poly.append(coefficient, mPimpl->monomial);
MATHICGB_ASSERT(debugAssertValid());
}
@@ -815,11 +815,11 @@ namespace mgbi {
MATHICGB_ASSERT(term < p.termCount());
MATHICGB_ASSERT(p.ring().monoid() == monoid);
- const auto& from = p.monomialAt(term);
+ const auto& from = p.mono(term);
auto to = mPimpl->tmpTerm.get();
for (VarIndex var = 0; var < monoid.varCount(); ++var)
to[var] = monoid.externalExponent(from, var);
- return std::make_pair(p.coefficientAt(term), to);
+ return std::make_pair(p.coef(term), to);
}
}
diff --git a/src/mathicgb/Basis.cpp b/src/mathicgb/Basis.cpp
index fce129b..8be6435 100755
--- a/src/mathicgb/Basis.cpp
+++ b/src/mathicgb/Basis.cpp
@@ -25,7 +25,7 @@ void Basis::sort() {
const std::unique_ptr<Poly>& a,
const std::unique_ptr<Poly>& b
) {
- return monoid.lessThan(a->getLeadMonomial(), b->getLeadMonomial());
+ return monoid.lessThan(a->leadMono(), b->leadMono());
};
std::sort(mGenerators.begin(), mGenerators.end(), cmp);
}
diff --git a/src/mathicgb/ClassicGBAlg.cpp b/src/mathicgb/ClassicGBAlg.cpp
index b30b0d0..0626b04 100755
--- a/src/mathicgb/ClassicGBAlg.cpp
+++ b/src/mathicgb/ClassicGBAlg.cpp
@@ -62,7 +62,7 @@ void ClassicGBAlg::insertPolys
MATHICGB_ASSERT(it->get() != 0);
if ((*it)->isZero())
continue;
- if (mBasis.divisor((*it)->getLeadMonomial()) != static_cast<size_t>(-1)) {
+ if (mBasis.divisor((*it)->leadMono()) != static_cast<size_t>(-1)) {
*it = mReducer.classicReduce(**it, mBasis);
if ((*it)->isZero())
continue;
@@ -94,7 +94,7 @@ void ClassicGBAlg::insertPolys
// We check for a divisor from mBasis because a new reducer
// might have been added since we did the reduction or perhaps a
// non-reduced polynomial was passed in.
- if (mBasis.divisor((*it)->getLeadMonomial()) != static_cast<size_t>(-1))
+ if (mBasis.divisor((*it)->leadMono()) != static_cast<size_t>(-1))
toReduce.push_back(std::move(*it));
else {
mBasis.insert(std::move(*it));
@@ -126,7 +126,7 @@ void ClassicGBAlg::insertReducedPoly(
MATHICGB_ASSERT(polyToInsert.get() != 0);
if (polyToInsert->isZero())
return;
- MATHICGB_ASSERT(mBasis.divisor(polyToInsert->getLeadMonomial()) ==
+ MATHICGB_ASSERT(mBasis.divisor(polyToInsert->leadMono()) ==
static_cast<size_t>(-1));
if (tracingLevel > 20) {
@@ -136,7 +136,7 @@ void ClassicGBAlg::insertReducedPoly(
std::cerr << std::endl;
} else {
mRing.printMonomialFrobbyM2Format
- (std::cerr, polyToInsert->getLeadMonomial());
+ (std::cerr, Monoid::toOld(polyToInsert->leadMono()));
if (polyToInsert->termCount() > 1)
std::cerr << " + [...]";
std::cerr << std::endl;
@@ -172,7 +172,7 @@ void ClassicGBAlg::insertReducedPoly(
"inserting reduced poly with lead term "
<< std::endl;
mRing.printMonomialFrobbyM2Format
- (std::cerr, reduced->getLeadMonomial());
+ (std::cerr, Monoid::toOld(reduced->leadMono()));
std::cerr << '\n';
}
}
@@ -291,14 +291,14 @@ void ClassicGBAlg::step() {
const auto aEnd = a->end();
for (auto aIt = a->begin(); aIt != aEnd; ++aIt, ++bIt) {
const auto monoCmp =
- mRing.monomialCompare(aIt.getMonomial(), bIt.getMonomial());
+ mRing.monoid().compare(aIt.mono(), bIt.mono());
if (monoCmp == LT)
return true;
if (monoCmp == GT)
return false;
- if (aIt.getCoefficient() < bIt.getCoefficient())
+ if (aIt.coef() < bIt.coef())
return true;
- if (aIt.getCoefficient() > bIt.getCoefficient())
+ if (aIt.coef() > bIt.coef())
return false;
}
return false;
diff --git a/src/mathicgb/F4MatrixBuilder.cpp b/src/mathicgb/F4MatrixBuilder.cpp
index 38bcfb0..4feefc1 100755
--- a/src/mathicgb/F4MatrixBuilder.cpp
+++ b/src/mathicgb/F4MatrixBuilder.cpp
@@ -102,7 +102,7 @@ void F4MatrixBuilder::addPolynomialToMatrix
return;
auto desiredLead = monoid().alloc();
- monoid().multiply(poly.getLeadMonomial(), multiple, desiredLead);
+ monoid().multiply(poly.leadMono(), multiple, desiredLead);
RowTask task = {};
task.addToTop = false;
task.poly = &poly;
@@ -159,8 +159,8 @@ void F4MatrixBuilder::buildMatrixAndClear(QuadMatrix& matrix) {
if (task.sPairPoly != 0) {
MATHICGB_ASSERT(!task.addToTop);
monoid().colons(
- poly.getLeadMonomial(),
- task.sPairPoly->getLeadMonomial(),
+ poly.leadMono(),
+ task.sPairPoly->leadMono(),
data.tmp2,
data.tmp1
);
@@ -171,7 +171,7 @@ void F4MatrixBuilder::buildMatrixAndClear(QuadMatrix& matrix) {
if (task.desiredLead == nullptr)
monoid().setIdentity(data.tmp1);
else
- monoid().divide(poly.getLeadMonomial(), *task.desiredLead, data.tmp1);
+ monoid().divide(poly.leadMono(), *task.desiredLead, data.tmp1);
if (task.addToTop)
appendRowTop(data.tmp1, *task.poly, builder, feeder);
else
@@ -289,13 +289,13 @@ updateReader:
// changes inside the loop.
const ColReader reader(mMap);
for (; it != end; ++it) {
- const auto col = reader.findProduct(it.getMonomial(), multiple);
+ const auto col = reader.findProduct(it.mono(), multiple);
if (col.first == 0) {
- createColumn(it.getMonomial(), multiple, feeder);
+ createColumn(it.mono(), multiple, feeder);
goto updateReader;
}
- const auto origScalar = it.getCoefficient();
+ const auto origScalar = it.coef();
MATHICGB_ASSERT(origScalar != 0);
const auto maybeNegated =
negate ? ring().coefficientNegateNonZero(origScalar) : origScalar;
@@ -316,30 +316,29 @@ void F4MatrixBuilder::appendRowTop(
auto it = poly.begin();
const auto end = poly.end();
- if ((std::distance(it, end) % 2) == 1) {
+ if ((poly.termCount() % 2) == 1) {
ColReader reader(mMap);
const auto col = findOrCreateColumn
- (it.getMonomial(), multiple, reader, feeder);
- MATHICGB_ASSERT(it.getCoefficient() < std::numeric_limits<Scalar>::max());
- MATHICGB_ASSERT(it.getCoefficient());
+ (it.mono(), multiple, reader, feeder);
+ MATHICGB_ASSERT(it.coef() < std::numeric_limits<Scalar>::max());
+ MATHICGB_ASSERT(it.coef());
builder.appendEntryTop
- (col.first, static_cast<Scalar>(it.getCoefficient()));
+ (col.first, static_cast<Scalar>(it.coef()));
++it;
}
updateReader:
ColReader colMap(mMap);
- MATHICGB_ASSERT((std::distance(it, end) % 2) == 0);
while (it != end) {
- MATHICGB_ASSERT(it.getCoefficient() < std::numeric_limits<Scalar>::max());
- MATHICGB_ASSERT(it.getCoefficient() != 0);
- const auto scalar1 = static_cast<Scalar>(it.getCoefficient());
+ MATHICGB_ASSERT(it.coef() < std::numeric_limits<Scalar>::max());
+ MATHICGB_ASSERT(it.coef() != 0);
+ const auto scalar1 = static_cast<Scalar>(it.coef());
const auto mono1 = it.mono();
auto it2 = it;
++it2;
- MATHICGB_ASSERT(it2.getCoefficient() < std::numeric_limits<Scalar>::max());
- MATHICGB_ASSERT(it2.getCoefficient() != 0);
- const auto scalar2 = static_cast<Scalar>(it2.getCoefficient());
+ MATHICGB_ASSERT(it2.coef() < std::numeric_limits<Scalar>::max());
+ MATHICGB_ASSERT(it2.coef() != 0);
+ const auto scalar2 = static_cast<Scalar>(it2.coef());
const auto mono2 = it2.mono();
const auto colPair = colMap.findTwoProducts(mono1, mono2, multiple);
@@ -372,7 +371,7 @@ void F4MatrixBuilder::appendRowBottom(
Poly::const_iterator endB = sPairPoly.end();
// skip leading terms since they cancel
- MATHICGB_ASSERT(itA.getCoefficient() == itB.getCoefficient());
+ MATHICGB_ASSERT(itA.coef() == itB.coef());
++itA;
++itB;
@@ -396,17 +395,17 @@ void F4MatrixBuilder::appendRowBottom(
coefficient coeff = 0;
LeftRightColIndex col;
const auto colA = findOrCreateColumn
- (itA.getMonomial(), mulA, colMap, feeder);
+ (itA.mono(), mulA, colMap, feeder);
const auto colB = findOrCreateColumn
- (itB.getMonomial(), mulB, colMap, feeder);
+ (itB.mono(), mulB, colMap, feeder);
const auto cmp = monoid().compare(colA.second, colB.second);
if (cmp != LT) {
- coeff = itA.getCoefficient();
+ coeff = itA.coef();
col = colA.first;
++itA;
}
if (cmp != GT) {
- coeff = ring().coefficientSubtract(coeff, itB.getCoefficient());
+ coeff = ring().coefficientSubtract(coeff, itB.coef());
col = colB.first;
++itB;
}
diff --git a/src/mathicgb/F4MatrixBuilder2.cpp b/src/mathicgb/F4MatrixBuilder2.cpp
index 713f129..87e9bad 100755
--- a/src/mathicgb/F4MatrixBuilder2.cpp
+++ b/src/mathicgb/F4MatrixBuilder2.cpp
@@ -183,8 +183,8 @@ public:
if (task.sPairPoly != 0) {
monoid().colons(
- poly.getLeadMonomial(),
- task.sPairPoly->getLeadMonomial(),
+ poly.leadMono(),
+ task.sPairPoly->leadMono(),
data.tmp2,
data.tmp1
);
@@ -195,7 +195,7 @@ public:
if (task.desiredLead == nullptr)
monoid().setIdentity(data.tmp1);
else
- monoid().divide(poly.getLeadMonomial(), *task.desiredLead, data.tmp1);
+ monoid().divide(poly.leadMono(), *task.desiredLead, data.tmp1);
appendRow(data.tmp1, *task.poly, data.block, feeder);
});
MATHICGB_ASSERT(!threadData.empty()); // as tasks empty causes early return
@@ -348,7 +348,7 @@ public:
) {
const auto begin = poly.begin();
const auto end = poly.end();
- const auto count = static_cast<size_t>(std::distance(begin, end));
+ const auto count = poly.termCount();
MATHICGB_ASSERT(count < std::numeric_limits<ColIndex>::max());
auto indices = block.makeRowWithTheseScalars(poly);
@@ -356,27 +356,26 @@ public:
if ((count % 2) == 1) {
ColReader reader(mMap);
const auto col = findOrCreateColumn
- (it.getMonomial(), multiple, reader, feeder);
- MATHICGB_ASSERT(it.getCoefficient() < std::numeric_limits<Scalar>::max());
- MATHICGB_ASSERT(it.getCoefficient());
+ (it.mono(), multiple, reader, feeder);
+ MATHICGB_ASSERT(it.coef() < std::numeric_limits<Scalar>::max());
+ MATHICGB_ASSERT(it.coef() != 0);
*indices = col.first;
++indices;
++it;
}
updateReader:
ColReader colMap(mMap);
- MATHICGB_ASSERT((std::distance(it, end) % 2) == 0);
while (it != end) {
- MATHICGB_ASSERT(it.getCoefficient() < std::numeric_limits<Scalar>::max());
- MATHICGB_ASSERT(it.getCoefficient() != 0);
- const auto scalar1 = static_cast<Scalar>(it.getCoefficient());
+ MATHICGB_ASSERT(it.coef() < std::numeric_limits<Scalar>::max());
+ MATHICGB_ASSERT(it.coef() != 0);
+ const auto scalar1 = static_cast<Scalar>(it.coef());
const auto mono1 = it.mono();
auto it2 = it;
++it2;
- MATHICGB_ASSERT(it2.getCoefficient() < std::numeric_limits<Scalar>::max());
- MATHICGB_ASSERT(it2.getCoefficient() != 0);
- const auto scalar2 = static_cast<Scalar>(it2.getCoefficient());
+ MATHICGB_ASSERT(it2.coef() < std::numeric_limits<Scalar>::max());
+ MATHICGB_ASSERT(it2.coef() != 0);
+ const auto scalar2 = static_cast<Scalar>(it2.coef());
const auto mono2 = it2.mono();
const auto colPair = colMap.findTwoProducts(mono1, mono2, multiple);
@@ -414,7 +413,7 @@ public:
const auto endB = sPairPoly.end();
// skip leading terms since they cancel
- MATHICGB_ASSERT(itA.getCoefficient() == itB.getCoefficient());
+ MATHICGB_ASSERT(itA.coef() == itB.coef());
++itA;
++itB;
@@ -432,20 +431,20 @@ public:
auto mulB = sPairMultiply;
while (itB != endB && itA != endA) {
const auto colA = findOrCreateColumn
- (itA.getMonomial(), mulA, colMap, feeder);
+ (itA.mono(), mulA, colMap, feeder);
const auto colB = findOrCreateColumn
- (itB.getMonomial(), mulB, colMap, feeder);
+ (itB.mono(), mulB, colMap, feeder);
const auto cmp = monoid().compare(colA.second, colB.second);
coefficient coeff = 0;
ColIndex col;
if (cmp != LT) {
- coeff = itA.getCoefficient();
+ coeff = itA.coef();
col = colA.first;
++itA;
}
if (cmp != GT) {
- coeff = ring().coefficientSubtract(coeff, itB.getCoefficient());
+ coeff = ring().coefficientSubtract(coeff, itB.coef());
col = colB.first;
++itB;
}
@@ -458,15 +457,15 @@ public:
for (; itA != endA; ++itA) {
const auto colA = findOrCreateColumn
- (itA.getMonomial(), mulA, colMap, feeder);
+ (itA.mono(), mulA, colMap, feeder);
*row.first++ = colA.first;
- *row.second++ = static_cast<Scalar>(itA.getCoefficient());
+ *row.second++ = static_cast<Scalar>(itA.coef());
}
for (; itB != endB; ++itB) {
const auto colB = findOrCreateColumn
- (itB.getMonomial(), mulB, colMap, feeder);
- const auto negative = ring().coefficientNegate(itB.getCoefficient());
+ (itB.mono(), mulB, colMap, feeder);
+ const auto negative = ring().coefficientNegate(itB.coef());
*row.first = colB.first;
++row.first;
*row.second = static_cast<Scalar>(negative);
@@ -553,7 +552,7 @@ void F4MatrixBuilder2::addSPolynomialToMatrix(
MATHICGB_ASSERT(polyB.isMonic());
auto desiredLead = monoid().alloc();
- monoid().lcm(polyA.getLeadMonomial(), polyB.getLeadMonomial(), *desiredLead);
+ monoid().lcm(polyA.leadMono(), polyB.leadMono(), *desiredLead);
RowTask task = {desiredLead.release(), &polyA, &polyB};
mTodo.push_back(task);
}
@@ -575,7 +574,7 @@ void F4MatrixBuilder2::addPolynomialToMatrix(
return;
auto desiredLead = monoid().alloc();
- monoid().multiply(poly.getLeadMonomial(), multiple, desiredLead);
+ monoid().multiply(poly.leadMono(), multiple, desiredLead);
RowTask task = {desiredLead.release(), &poly, nullptr};
mTodo.push_back(task);
}
diff --git a/src/mathicgb/MathicIO.hpp b/src/mathicgb/MathicIO.hpp
index c7980a0..23449d6 100755
--- a/src/mathicgb/MathicIO.hpp
+++ b/src/mathicgb/MathicIO.hpp
@@ -385,7 +385,7 @@ Poly MathicIO<M, BF>::readPoly(
if (!p.isZero() && !in.peekSign())
in.expect('+', '-');
readTerm(ring, readComponent, coef, mono, in);
- p.appendTerm(coef.value(), Monoid::toOld(*mono));
+ p.append(coef.value(), *mono);
} while (!in.peekWhite() && !in.matchEOF());
return std::move(p);
}
@@ -408,8 +408,8 @@ void MathicIO<M, BF>::writePoly(
writeTerm(
poly.ring(),
writeComponent,
- poly.ring().field().toElement(it.getCoefficient()),
- it.getMonomial(),
+ poly.ring().field().toElement(it.coef()),
+ it.mono(),
out
);
}
diff --git a/src/mathicgb/MonoMonoid.hpp b/src/mathicgb/MonoMonoid.hpp
index 0f7980b..fa57d1d 100755
--- a/src/mathicgb/MonoMonoid.hpp
+++ b/src/mathicgb/MonoMonoid.hpp
@@ -1449,7 +1449,7 @@ public:
class const_iterator {
public:
typedef std::forward_iterator_tag iterator_category;
- typedef ConstMonoPtr value_type;
+ typedef ConstMonoRef value_type;
const_iterator(): mIt(), mEntriesPerMono(0) {}
const_iterator(const const_iterator& it):
diff --git a/src/mathicgb/MonoProcessor.hpp b/src/mathicgb/MonoProcessor.hpp
index c973a1f..7bef45c 100755
--- a/src/mathicgb/MonoProcessor.hpp
+++ b/src/mathicgb/MonoProcessor.hpp
@@ -48,7 +48,7 @@ public:
void setSchreyerMultipliers(const Basis& basis) {
MonoVector schreyer(monoid());
for (size_t gen = 0; gen < basis.size(); ++gen)
- schreyer.push_back(basis.getPoly(gen)->getLeadMonomial());
+ schreyer.push_back(basis.getPoly(gen)->leadMono());
setSchreyerMultipliers(std::move(schreyer));
}
diff --git a/src/mathicgb/Poly.cpp b/src/mathicgb/Poly.cpp
index 264a1a8..2d4b1af 100755
--- a/src/mathicgb/Poly.cpp
+++ b/src/mathicgb/Poly.cpp
@@ -9,14 +9,6 @@
MATHICGB_NAMESPACE_BEGIN
-// Format for input/output:
-// #terms term1 term2 ...
-// each term: coeff monom
-// each coeff: int
-// each monom: len v1 e1 v2 e2 ... vr er
-// where len = r
-// MAJOR ASSUMPTION: the monomials are ordered in descending order!!
-
Poly& Poly::operator=(Poly&& poly) {
MATHICGB_ASSERT(&ring() == &poly.ring());
coeffs = std::move(poly.coeffs);
@@ -25,156 +17,85 @@ Poly& Poly::operator=(Poly&& poly) {
}
void Poly::sortTermsDescending() {
- struct Cmp {
- public:
- Cmp(const Poly& poly): mPoly(poly) {}
-
- bool operator()(size_t a, size_t b) {
- MATHICGB_ASSERT(a < mPoly.termCount());
- MATHICGB_ASSERT(b < mPoly.termCount());
- return mPoly.ring().monomialLT(mPoly.monomialAt(b), mPoly.monomialAt(a));
- }
-
- private:
- const Poly& mPoly;
- };
-
const size_t count = termCount();
std::vector<size_t> ordered(count);
for (size_t i = 0; i < count; ++i)
ordered[i] = i;
- std::sort(ordered.begin(), ordered.end(), Cmp(*this));
+ auto cmp = [&](size_t a, size_t b) {
+ MATHICGB_ASSERT(a < termCount());
+ MATHICGB_ASSERT(b < termCount());
+ return monoid().lessThan(mono(b), mono(a));
+ };
+ std::sort(ordered.begin(), ordered.end(), cmp);
Poly poly(ring());
for (size_t i = 0; i < count; ++i)
- poly.appendTerm(coefficientAt(ordered[i]), monomialAt(ordered[i]));
+ poly.append(coef(ordered[i]), mono(ordered[i]));
*this = std::move(poly);
MATHICGB_ASSERT(termsAreInDescendingOrder());
}
-monomial Poly::monomialAt(size_t index) {
+auto Poly::mono(size_t index) -> MonoRef {
MATHICGB_ASSERT(index < termCount());
- return &monoms[index * ring().maxMonomialSize()];
+ return Monoid::toRef(&monoms[index * ring().maxMonomialSize()]);
}
-const_monomial Poly::monomialAt(size_t index) const {
+auto Poly::mono(size_t index) const -> ConstMonoRef {
MATHICGB_ASSERT(index < termCount());
- return &monoms[index * ring().maxMonomialSize()];
+ return Monoid::toRef(&monoms[index * ring().maxMonomialSize()]);
}
-coefficient& Poly::coefficientAt(size_t index) {
+coefficient& Poly::coef(size_t index) {
MATHICGB_ASSERT(index < termCount());
return coeffs[index];
}
-const coefficient Poly::coefficientAt(size_t index) const {
+coefficient Poly::coef(size_t index) const {
MATHICGB_ASSERT(index < termCount());
return coeffs[index];
}
-void Poly::append(iterator &first, iterator &last)
-{
- for ( ; first != last; ++first)
- appendTerm(first.getCoefficient(), first.getMonomial());
-}
-
-/*Poly *Poly::copy() const
-{
- Poly *const_this = const_cast<Poly *>(this);
- Poly *result = new Poly(*R);
- iterator a = const_this->begin();
- iterator b = const_this->end();
- result->append(a,b);
- return result;
-}*/
-
-void Poly::multByCoefficient(coefficient c)
-{
- for (std::vector<coefficient>::iterator i = coeffs.begin(); i != coeffs.end(); i++)
- ring().coefficientMultTo(*i, c);
-}
-
bool Poly::isMonic() const {
- return !isZero() && ring().coefficientIsOne(getLeadCoefficient());
+ return !isZero() && ring().coefficientIsOne(leadCoef());
}
void Poly::makeMonic() {
if (isZero())
return;
- coefficient c = getLeadCoefficient();
+ coefficient c = leadCoef();
if (ring().coefficientIsOne(c))
return;
ring().coefficientReciprocalTo(c);
for (auto i = coeffs.begin(); i != coeffs.end(); i++)
ring().coefficientMultTo(*i, c);
- MATHICGB_ASSERT(ring().coefficientIsOne(getLeadCoefficient()));
+ MATHICGB_ASSERT(ring().coefficientIsOne(leadCoef()));
}
bool operator==(const Poly &a, const Poly &b)
{
- const auto& ring = a.ring();
if (&a.ring() != &b.ring())
return false;
if (a.termCount() != b.termCount())
return false;
- Poly::const_iterator a1 = a.begin();
- Poly::const_iterator b1 = b.begin();
- for ( ; a1 != a.end(); ++a1, ++b1)
- {
- if (a1.getCoefficient() != b1.getCoefficient())
- return false;
- if (!ring.monomialEQ(a1.getMonomial(), b1.getMonomial()))
- return false;
- }
+ const auto& ring = a.ring();
+ auto a1 = a.begin();
+ auto b1 = b.begin();
+ for (; a1 != a.end(); ++a1, ++b1) {
+ if (a1.coef() != b1.coef())
+ return false;
+ if (!ring.monoid().equal(a1.mono(), b1.mono()))
+ return false;
+ }
return true;
}
-const_monomial Poly::backMonomial() const {
+const_monomial Poly::backMono() const {
MATHICGB_ASSERT(begin() != end());
return &(monoms.front()) + ring().maxMonomialSize() * (termCount() - 1);
}
-void Poly::multByTerm(coefficient a, const_monomial m)
-{
- size_t p = 0;
- exponent * n = &monoms[0];
- iterator j = end();
-
- for (iterator i = begin(); i != j; ++i, ++p, n += ring().maxMonomialSize())
- {
- monomial nmon = n;
- ring().coefficientMultTo(coeffs[p], a);
- ring().monomialMultTo(nmon, m); // changes the monomial pointed to by n.
- }
-}
-
-void Poly::multByMonomial(const_monomial m)
-{
- size_t p = 0;
- exponent * n = &monoms[0];
- iterator j = end();
-
- for (iterator i = begin(); i != j; ++i, ++p, n += ring().maxMonomialSize())
- {
- monomial nmon = n;
- ring().monomialMultTo(nmon, m); // changes the monomial pointed to by n.
- }
-}
-
-/*void Poly::dump() const
-{
- std::cout << "coeffs: ";
- for (unsigned i=0; i<coeffs.size(); i++)
- std::cout << " " << coeffs[i];
- std::cout << std::endl;
- std::cout << "monoms: ";
- for (unsigned int i=0; i<monoms.size(); i++)
- std::cout << " " << monoms[i];
- std::cout << std::endl;
-}*/
-
void Poly::parseDoNotOrder(std::istream& i)
{
if (i.peek() == '0') {
@@ -229,15 +150,15 @@ void Poly::parse(std::istream& in) {
void Poly::display(std::ostream& out, const bool printComponent) const
{
- const coefficient p = ring().charac();
- const coefficient maxPositive = (p + 1) / 2; // half rounded up
+ const auto p = ring().charac();
+ const auto maxPositive = (p + 1) / 2; // half rounded up
if (isZero()) {
out << "0";
return;
}
- for (const_iterator i = begin(); i != end(); ++i) {
- coefficient coef = i.getCoefficient();
+ for (auto i = begin(); i != end(); ++i) {
+ auto coef = i.coef();
if (coef > maxPositive) {
out << "-";
ring().coefficientNegateTo(coef);
@@ -245,7 +166,7 @@ void Poly::display(std::ostream& out, const bool printComponent) const
out << '+';
if (coef != 1)
out << coef;
- ring().monomialDisplay(out, i.getMonomial(), printComponent, coef == 1);
+ ring().monomialDisplay(out, Monoid::toOld(i.mono()), printComponent, coef == 1);
}
}
@@ -257,10 +178,10 @@ void Poly::display(FILE* file, bool printComponent) const
}
const auto characteristic = ring().charac();
- const coefficient maxPositiveCoefficient = (characteristic + 1) / 2;
+ const auto maxPositiveCoefficient = (characteristic + 1) / 2;
bool firstTerm = true;
for (auto it = begin(); it != end(); ++it) {
- coefficient coef = it.getCoefficient();
+ auto coef = it.coef();
if (coef > maxPositiveCoefficient) {
coef = characteristic - coef;
fputc('-', file);
@@ -271,13 +192,12 @@ void Poly::display(FILE* file, bool printComponent) const
printOne = false;
fprintf(file, "%li", (long)coef);
}
- ring().monomialDisplay(file, it.getMonomial(), printComponent, printOne);
+ ring().monomialDisplay(file, Monoid::toOld(it.mono()), printComponent, printOne);
firstTerm = false;
}
}
-size_t Poly::getMemoryUse() const
-{
+size_t Poly::getMemoryUse() const {
size_t total = sizeof(const PolyRing *);
total += sizeof(coefficient) * coeffs.capacity();
total += sizeof(int) * monoms.capacity();
@@ -305,18 +225,14 @@ void Poly::reserve(size_t spaceForThisManyTerms) {
}
bool Poly::termsAreInDescendingOrder() const {
- if (isZero())
- return true;
-
- auto stop = end();
- auto it = begin();
- auto previous = it;
- ++it;
- while (it != stop) {
- if (ring().monomialCompare(previous.getMonomial(), it.getMonomial()) == LT)
- return false;
- previous = it;
- ++it;
+ if (!isZero()) {
+ auto prev = leadMono().ptr();
+ MonoRange range = {++monoBegin(), monoEnd()};
+ for (const auto& mono : range) {
+ if (monoid().lessThan(*prev, mono))
+ return false;
+ prev = mono.ptr();
+ }
}
return true;
}
diff --git a/src/mathicgb/Poly.hpp b/src/mathicgb/Poly.hpp
index 663134a..1f53554 100755
--- a/src/mathicgb/Poly.hpp
+++ b/src/mathicgb/Poly.hpp
@@ -21,7 +21,7 @@ public:
typedef Monoid::MonoPtr MonoPtr;
typedef Monoid::ConstMonoPtr ConstMonoPtr;
- Poly(const PolyRing& ring) : mRing(ring) {}
+ Poly(const PolyRing& ring): mRing(ring) {}
void parse(std::istream &i); // reads into this, sorts terms
void parseDoNotOrder(std::istream &i); // reads into this, does not sort terms
@@ -29,43 +29,29 @@ public:
void display(std::ostream& out, bool printComponent = true) const;
void see(bool print_comp) const;
- class iterator {
- // only for const objects...
- size_t monsize;
- std::vector<coefficient>::iterator ic;
- std::vector<exponent>::iterator im;
- friend class Poly;
-
- iterator(Poly& f) : monsize(f.ring().maxMonomialSize()), ic(f.coeffs.begin()), im(f.monoms.begin()) {}
- iterator(Poly& f,int) : ic(f.coeffs.end()), im() {}
+ class const_iterator {
public:
typedef std::random_access_iterator_tag iterator_category;
- typedef std::pair<coefficient, const const_monomial> value_type;
+ typedef std::pair<const coefficient, const const_monomial> value_type;
typedef ptrdiff_t difference_type;
typedef value_type* pointer; // todo: is this OK?
- typedef std::pair<coefficient&, const const_monomial> reference;
-
- iterator() {}
- iterator operator++() { ++ic; im += monsize; return *this; }
- coefficient &getCoefficient() const { return *ic; }
- monomial getMonomial() const { return &*im; }
- MonoRef mono() const {return getMonomial();}
- size_t operator-(const iterator &b) const { return ic - b.ic; }
- friend bool operator==(const iterator &a, const iterator &b);
- friend bool operator!=(const iterator &a, const iterator &b);
- reference operator*() const {
- return std::pair<coefficient&, monomial>(getCoefficient(), getMonomial());
- }
- const_term term() const {
- const_term t;
- t.monom = getMonomial();
- t.coeff = getCoefficient();
+ typedef std::pair<const coefficient&, const const_monomial> reference;
+
+ const_iterator() {}
+ const_iterator& operator++() { ++ic; im += monsize; return *this; }
+
+ coefficient coef() const {return *ic;}
+ ConstMonoRef mono() const {return Monoid::toRef(&*im);}
+
+ friend bool operator==(const const_iterator &a, const const_iterator &b);
+ friend bool operator!=(const const_iterator &a, const const_iterator &b);
+
+ NewConstTerm operator*() const {
+ NewConstTerm t = {coef(), mono()};
return t;
}
- };
- class const_iterator {
- // only for const objects...
+ private:
size_t monsize;
std::vector<coefficient>::const_iterator ic;
std::vector<exponent>::const_iterator im;
@@ -73,84 +59,91 @@ public:
const_iterator(const Poly& f) : monsize(f.ring().maxMonomialSize()), ic(f.coeffs.begin()), im(f.monoms.begin()) {}
const_iterator(const Poly& f,int) : ic(f.coeffs.end()), im() {}
+ };
+
+ const_iterator begin() const { return const_iterator(*this); }
+ const_iterator end() const { return const_iterator(*this,1); }
+
+ class MonoIterator {
+ size_t monsize;
+ std::vector<coefficient>::const_iterator ic;
+ std::vector<exponent>::const_iterator im;
+ friend class Poly;
+
+ MonoIterator(const Poly& f) : monsize(f.ring().maxMonomialSize()), ic(f.coeffs.begin()), im(f.monoms.begin()) {}
+ MonoIterator(const Poly& f,int) : ic(f.coeffs.end()), im(f.monoms.end()) {}
+
public:
- typedef std::random_access_iterator_tag iterator_category;
- typedef std::pair<const coefficient, const const_monomial> value_type;
+ typedef std::forward_iterator_tag iterator_category;
+ typedef ConstMonoRef value_type;
typedef ptrdiff_t difference_type;
- typedef value_type* pointer; // todo: is this OK?
- typedef std::pair<const coefficient&, const const_monomial> reference;
+ typedef value_type* pointer;
+ typedef ConstMonoRef reference;
+
+ MonoIterator() {}
+ MonoIterator operator++() { ++ic; im += monsize; return *this; }
+ bool operator==(const MonoIterator& it) const {return im == it.im;}
+ bool operator!=(const MonoIterator& it) const {return im != it.im;}
+ const value_type operator*() const {return Monoid::toRef(&*im);}
+ };
- const_iterator() {}
- const_iterator operator++() { ++ic; im += monsize; return *this; }
- coefficient getCoefficient() const { return *ic; }
- const_monomial getMonomial() const { return &*im; }
- ConstMonoRef mono() const {return getMonomial();}
- size_t operator-(const const_iterator &b) const { return ic - b.ic; }
- friend bool operator==(const const_iterator &a, const const_iterator &b);
- friend bool operator!=(const const_iterator &a, const const_iterator &b);
- const value_type operator*() const {
- return std::pair<coefficient, const_monomial>
- (getCoefficient(), getMonomial());
- }
- NewConstTerm term() const {
- NewConstTerm t;
- t.mono = getMonomial();
- t.coef = getCoefficient();
- return t;
- }
+ MonoIterator monoBegin() const { return MonoIterator(*this); }
+ MonoIterator monoEnd() const { return MonoIterator(*this,1); }
+ struct MonoRange {
+ MonoIterator mBegin;
+ const MonoIterator mEnd;
+ MonoIterator begin() {return mBegin;}
+ MonoIterator end() {return mEnd;}
};
+ MonoRange monoRange() const {
+ MonoRange range = {monoBegin(), monoEnd()};
+ return range;
+ }
+ /// Orders terms in descending order.
void sortTermsDescending();
- void append(iterator &first, iterator &last);
- // Insert [first, last) onto the end of this.
- // This invalidates iterators on this.
+ /// Returns the coefficient of the given term.
+ coefficient& coef(size_t index);
- //Poly *copy() const;
+ /// Returns the coefficient of the given term.
+ coefficient coef(size_t index) const;
- // Cannot call this monomial() since that is already a type :-(
- monomial monomialAt(size_t index);
- const_monomial monomialAt(size_t index) const;
- coefficient& coefficientAt(size_t index);
- const coefficient coefficientAt(size_t index) const;
+ /// Returns the monomial of the given term.
+ MonoRef mono(size_t index);
- /// all iterators are invalid after this
- void appendTerm(coefficient a, const_monomial m);
- void appendTerm(coefficient a, PolyRing::Monoid::ConstMonoRef m);
+ /// Returns the monomial of the given term.
+ ConstMonoRef mono(size_t index) const;
- /// Hint that space for termCount terms is going to be needed so the internal
- /// storage should be expanded to fit that many terms.
- void reserve(size_t spaceForThisManyTerms);
+ /// Returns the coefficient of the leading term.
+ coefficient leadCoef() const {return coef(0);}
- const_iterator begin() const { return const_iterator(*this); }
- const_iterator end() const { return const_iterator(*this,1); }
- const_monomial backMonomial() const;
+ /// Returns the monomial of the leading term.
+ ConstMonoRef leadMono() const {return mono(0);}
- iterator begin() { return iterator(*this); }
- iterator end() { return iterator(*this,1); }
+ /// Returns the monomial of the last term.
+ const_monomial backMono() const;
- const coefficient* coefficientBegin() const {return coeffs.data();}
+ /// Appends the given term as the last term in the polynomial.
+ void append(coefficient coef, ConstMonoRef mono);
+
+ /// Hint that space for termCount terms is going to be needed. This serves
+ /// the same purpose as std::vector<>::reserve.
+ void reserve(size_t termCount);
- void multByTerm(coefficient a, const_monomial m);
- void multByMonomial(const_monomial m);
- void multByCoefficient(coefficient a);
+ const coefficient* coefficientBegin() const {return coeffs.data();}
void makeMonic();
bool isMonic() const;
- const_monomial getLeadMonomial() const { return &(monoms[0]); }
- const_coefficient getLeadCoefficient() const { return coeffs[0]; }
- exponent getLeadComponent() const { return ring().monomialGetComponent(&(monoms[0])); }
bool isZero() const { return coeffs.empty(); }
- //size_t nTerms() const { return coeffs.size(); } /// @todo: deprecated
size_t termCount() const {return coeffs.size();}
size_t getMemoryUse() const;
void setToZero();
- //void copy(Poly &result) const;
Poly& operator=(const Poly& poly) {return *this = Poly(poly);}
Poly& operator=(Poly&& poly);
@@ -159,8 +152,6 @@ public:
const PolyRing& ring() const {return mRing;}
const Monoid& monoid() const {return ring().monoid();}
- //void dump() const; // used for debugging
-
bool termsAreInDescendingOrder() const;
private:
@@ -171,15 +162,6 @@ private:
std::ostream& operator<<(std::ostream& out, const Poly& p);
-inline bool operator==(const Poly::iterator &a, const Poly::iterator &b)
-{
- return a.ic == b.ic;
-}
-inline bool operator!=(const Poly::iterator &a, const Poly::iterator &b)
-{
- return a.ic != b.ic;
-}
-
inline bool operator==(const Poly::const_iterator &a, const Poly::const_iterator &b)
{
return a.ic == b.ic;
@@ -189,16 +171,7 @@ inline bool operator!=(const Poly::const_iterator &a, const Poly::const_iterator
return a.ic != b.ic;
}
-inline void Poly::appendTerm(coefficient a, const_monomial m)
-{
- // the monomial will be copied on.
- coeffs.push_back(a);
- size_t len = ring().maxMonomialSize();
- exponent const * e = m.unsafeGetRepresentation();
- monoms.insert(monoms.end(), e, e + len);
-}
-
-inline void Poly::appendTerm(coefficient a, PolyRing::Monoid::ConstMonoRef m) {
+inline void Poly::append(coefficient a, ConstMonoRef m) {
coeffs.push_back(a);
size_t len = ring().maxMonomialSize();
auto& monoid = ring().monoid();
diff --git a/src/mathicgb/PolyBasis.cpp b/src/mathicgb/PolyBasis.cpp
index 6a579b7..73b84ea 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, leadMono(gen));
+ p->append(1, leadMono(gen));
basis->insert(std::move(p));
}
}
@@ -48,13 +48,13 @@ void PolyBasis::insert(std::unique_ptr<Poly> poly) {
poly->makeMonic();
const size_t index = size();
EntryIter const stop = mEntries.end();
- const_monomial const lead = poly->getLeadMonomial();
+ const auto lead = poly->leadMono();
#ifdef DEBUG
// lead monomials must be unique among basis elements
for (EntryIter it = mEntries.begin(); it != stop; ++it) {
if (it->retired)
continue;
- MATHICGB_ASSERT(!ring().monomialEQ(lead, it->poly->getLeadMonomial()));
+ MATHICGB_ASSERT(!monoid().equal(lead, it->poly->leadMono()));
}
#endif
@@ -139,7 +139,7 @@ bool PolyBasis::leadMinimalSlow(size_t index) const {
for (EntryCIter it = mEntries.begin(); it != stop; ++it) {
if (it->retired)
continue;
- const auto itLead = it->poly->getLeadMonomial();
+ const auto itLead = it->poly->leadMono();
if (monoid().divides(itLead, lead) && it != skip)
return false;
}
diff --git a/src/mathicgb/PolyBasis.hpp b/src/mathicgb/PolyBasis.hpp
index d0694ca..fe75b68 100755
--- a/src/mathicgb/PolyBasis.hpp
+++ b/src/mathicgb/PolyBasis.hpp
@@ -56,7 +56,7 @@ public:
MATHICGB_ASSERT(newValue.get() != nullptr);
MATHICGB_ASSERT(!newValue->isZero());
MATHICGB_ASSERT
- (monoid().equal(leadMono(index), newValue->getLeadMonomial()));
+ (monoid().equal(leadMono(index), newValue->leadMono()));
mMonoLookup->remove(leadMono(index));
delete mEntries[index].poly;
mEntries[index].poly = newValue.release();
@@ -108,14 +108,14 @@ public:
ConstMonoRef leadMono(size_t index) const {
MATHICGB_ASSERT(index < size());
MATHICGB_ASSERT(!retired(index));
- return poly(index).getLeadMonomial();
+ return poly(index).leadMono();
}
/// 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();
+ return poly(index).leadCoef();
}
/// Returns true if the leading monomial of the basis element at index is not
@@ -133,7 +133,7 @@ public:
/// 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()) !=
+ return mMonoLookup->divisor(poly.leadMono()) !=
static_cast<size_t>(-1);
}
diff --git a/src/mathicgb/PolyRing.hpp b/src/mathicgb/PolyRing.hpp
index 5fe70de..54e6907 100755
--- a/src/mathicgb/PolyRing.hpp
+++ b/src/mathicgb/PolyRing.hpp
@@ -196,16 +196,16 @@ typedef MonoMonoid<exponent>::ConstMonoPtr ConstMonomial;
#endif
struct NewConstTerm {
- MonoMonoid<exponent>::ConstMonoPtr mono;
coefficient coef;
+ MonoMonoid<exponent>::ConstMonoPtr mono;
};
struct NewTerm {
- MonoMonoid<exponent>::MonoPtr mono;
coefficient coef;
+ MonoMonoid<exponent>::MonoPtr mono;
operator NewConstTerm() const {
- NewConstTerm t = {mono, coef};
+ NewConstTerm t = {coef, mono};
return t;
}
};
diff --git a/src/mathicgb/ReducerDedup.cpp b/src/mathicgb/ReducerDedup.cpp
index 6ba8060..475d7db 100644
--- a/src/mathicgb/ReducerDedup.cpp
+++ b/src/mathicgb/ReducerDedup.cpp
@@ -85,8 +85,8 @@ void ReducerDedup<Q>::insertTail(NewConstTerm multiple, const Poly& poly) {
for (++it; it != end; ++it) {
NewTerm t;
t.mono = mRing.monoid().alloc().release();
- mRing.monoid().multiply(*multiple.mono, it.getMonomial(), *t.mono);
- mRing.coefficientMult(multiple.coef, it.getCoefficient(), t.coef);
+ mRing.monoid().multiply(*multiple.mono, it.mono(), *t.mono);
+ mRing.coefficientMult(multiple.coef, it.coef(), t.coef);
mQueue.push(t);
}
}
@@ -99,8 +99,8 @@ void ReducerDedup<Q>::insert(ConstMonoRef multiple, const Poly& poly) {
const auto end = poly.end();
for (auto it = poly.begin(); it != end; ++it) {
- NewTerm t = {mRing.monoid().alloc().release(), it.getCoefficient()};
- mRing.monoid().multiply(multiple, it.getMonomial(), *t.mono);
+ NewTerm t = {it.coef(), mRing.monoid().alloc().release()};
+ mRing.monoid().multiply(multiple, it.mono(), *t.mono);
mQueue.push(t);
}
}
diff --git a/src/mathicgb/ReducerHash.cpp b/src/mathicgb/ReducerHash.cpp
index 1159de2..858e71e 100644
--- a/src/mathicgb/ReducerHash.cpp
+++ b/src/mathicgb/ReducerHash.cpp
@@ -71,7 +71,7 @@ void ReducerHash<Q>::insertTail(NewConstTerm multiplier, const Poly& f) {
auto it = f.begin();
const auto end = f.end();
for (++it; it != end; ++it) {
- auto p = mHashTable.insertProduct(it.term(), multiplier);
+ auto p = mHashTable.insertProduct(*it, multiplier);
if (p.second)
mNodesTmp.emplace_back(p.first);
}
@@ -84,8 +84,7 @@ void ReducerHash<Q>::insert(ConstMonoRef multiplier, const Poly& f) {
mNodesTmp.clear();
const auto end = f.end();
for (auto it = f.begin(); it != end; ++it) {
- auto p = mHashTable.insertProduct
- (it.getMonomial(), multiplier, it.getCoefficient());
+ auto p = mHashTable.insertProduct(it.mono(), multiplier, it.coef());
if (p.second)
mNodesTmp.emplace_back(p.first);
}
diff --git a/src/mathicgb/ReducerHashPack.cpp b/src/mathicgb/ReducerHashPack.cpp
index 8497d75..1606cf1 100644
--- a/src/mathicgb/ReducerHashPack.cpp
+++ b/src/mathicgb/ReducerHashPack.cpp
@@ -107,7 +107,7 @@ void ReducerHashPack<Q>::insert(ConstMonoRef multiple, const Poly& poly) {
MATHICGB_ASSERT(&poly.ring() == &mRing);
if (poly.isZero())
return;
- NewConstTerm termMultiple = {multiple.ptr(), 1};
+ NewConstTerm termMultiple = {1, multiple.ptr()};
insertEntry(new (mPool.alloc()) MultipleWithPos(poly, termMultiple));
}
@@ -174,8 +174,7 @@ void ReducerHashPack<Q>::removeLeadTerm() {
break;
}
- const auto p = mHashTable.insertProduct
- (entry->multiple, entry->pos.term());
+ const auto p = mHashTable.insertProduct(entry->multiple, *entry->pos);
if (p.second) {
entry->node = p.first;
mQueue.decreaseTop(entry);
@@ -188,8 +187,7 @@ template<template<typename> class Q>
void ReducerHashPack<Q>::insertEntry(MultipleWithPos* entry) {
MATHICGB_ASSERT(entry != 0);
for (; entry->pos != entry->end; ++entry->pos) {
- const auto p = mHashTable.insertProduct
- (entry->multiple, entry->pos.term());
+ const auto p = mHashTable.insertProduct(entry->multiple, *entry->pos);
if (p.second) {
entry->node = p.first;
mQueue.push(entry);
diff --git a/src/mathicgb/ReducerNoDedup.cpp b/src/mathicgb/ReducerNoDedup.cpp
index 14637cf..215bc14 100644
--- a/src/mathicgb/ReducerNoDedup.cpp
+++ b/src/mathicgb/ReducerNoDedup.cpp
@@ -81,8 +81,8 @@ void ReducerNoDedup<Q>::insertTail(NewConstTerm multiple, const Poly& poly) {
for (++it; it != end; ++it) {
NewTerm t;
t.mono = mRing.allocMonomial();
- mRing.monoid().multiply(*multiple.mono, it.getMonomial(), *t.mono);
- mRing.coefficientMult(multiple.coef, it.getCoefficient(), t.coef);
+ mRing.monoid().multiply(*multiple.mono, it.mono(), *t.mono);
+ mRing.coefficientMult(multiple.coef, it.coef(), t.coef);
mQueue.push(t);
}
}
@@ -95,8 +95,8 @@ void ReducerNoDedup<Q>::insert(ConstMonoRef multiple, const Poly& poly) {
const auto end = poly.end();
for (auto it = poly.begin(); it != end; ++it) {
- NewTerm t = {mRing.monoid().alloc().release(), it.getCoefficient()};
- mRing.monoid().multiply(multiple, it.getMonomial(), *t.mono);
+ NewTerm t = {it.coef(), mRing.monoid().alloc().release()};
+ mRing.monoid().multiply(multiple, it.mono(), *t.mono);
mQueue.push(t);
}
}
diff --git a/src/mathicgb/ReducerPack.cpp b/src/mathicgb/ReducerPack.cpp
index 12583e5..99a245f 100644
--- a/src/mathicgb/ReducerPack.cpp
+++ b/src/mathicgb/ReducerPack.cpp
@@ -90,7 +90,7 @@ private:
template<template<typename> class Q>
void ReducerPack<Q>::insertTail(NewConstTerm multiple, const Poly& poly)
{
- if (poly.nTerms() <= 1)
+ if (poly.termCount() <= 1)
return;
mLeadTermKnown = false;
@@ -108,7 +108,7 @@ void ReducerPack<Q>::insert(ConstMonoRef multiple, const Poly& poly)
return;
mLeadTermKnown = false;
- NewConstTerm termMultiple = {multiple.ptr(), 1};
+ NewConstTerm termMultiple = {1, multiple.ptr()};
auto entry = new (mPool.alloc()) MultipleWithPos(poly, termMultiple);
entry->computeCurrent(poly.ring());
mQueue.push(entry);
@@ -130,13 +130,13 @@ ReducerPack<Q>::MultipleWithPos::MultipleWithPos(
template<template<typename> class Q>
void ReducerPack<Q>::MultipleWithPos::computeCurrent(const PolyRing& ring) {
- ring.monoid().multiply(*multiple.mono, pos.getMonomial(), *current);
+ ring.monoid().multiply(*multiple.mono, pos.mono(), *current);
}
template<template<typename> class Q>
void ReducerPack<Q>::MultipleWithPos::currentCoefficient
(const PolyRing& ring, coefficient& coeff) {
- ring.coefficientMult(multiple.coef, pos.getCoefficient(), coeff);
+ ring.coefficientMult(multiple.coef, pos.coef(), coeff);
}
template<template<typename> class Q>
diff --git a/src/mathicgb/ReducerPackDedup.cpp b/src/mathicgb/ReducerPackDedup.cpp
index 17d4db7..74cada2 100644
--- a/src/mathicgb/ReducerPackDedup.cpp
+++ b/src/mathicgb/ReducerPackDedup.cpp
@@ -55,11 +55,11 @@ private:
NewTerm multiple;
// invariant: current is the monomial product of multiple.monom
- // and pos.getMonomial().
+ // and pos.mono().
MonoPtr current;
// Ensures the invariant, so sets current to the product of
- // multiple.monom and pos.getMonomial().
+ // multiple.monom and pos.mono().
void computeCurrent(const PolyRing& ring);
void currentCoefficient(const PolyRing& ring, Coefficient& coeff);
void addCurrentCoefficient(const PolyRing& ring, Coefficient& coeff);
@@ -133,7 +133,7 @@ void ReducerPackDedup<Q>::insert(ConstMonoRef multiple, const Poly& poly) {
return;
mLeadTermKnown = false;
- NewConstTerm termMultiple = {multiple.ptr(), 1};
+ NewConstTerm termMultiple = {1, multiple.ptr()};
auto entry = new (mPool.alloc()) MultipleWithPos(poly, termMultiple);
entry->computeCurrent(poly.ring());
mQueue.push(entry);
@@ -158,7 +158,7 @@ template<template<typename> class Q>
void ReducerPackDedup<Q>::MultipleWithPos::computeCurrent(
const PolyRing& ring
) {
- ring.monoid().multiply(*multiple.mono, pos.getMonomial(), *current);
+ ring.monoid().multiply(*multiple.mono, pos.mono(), *current);
}
template<template<typename> class Q>
@@ -166,7 +166,7 @@ void ReducerPackDedup<Q>::MultipleWithPos::currentCoefficient(
const PolyRing& ring,
Coefficient& coef
) {
- ring.coefficientMult(multiple.coef, pos.getCoefficient(), coef);
+ ring.coefficientMult(multiple.coef, pos.coef(), coef);
}
template<template<typename> class Q>
@@ -175,7 +175,7 @@ void ReducerPackDedup<Q>::MultipleWithPos::addCurrentCoefficient(
Coefficient& coeff
) {
Coefficient tmp;
- ring.coefficientMult(multiple.coef, pos.getCoefficient(), tmp);
+ ring.coefficientMult(multiple.coef, pos.coef(), tmp);
ring.coefficientAddTo(coeff, tmp);
}
diff --git a/src/mathicgb/SigPolyBasis.cpp b/src/mathicgb/SigPolyBasis.cpp
index 1349446..1d40719 100755
--- a/src/mathicgb/SigPolyBasis.cpp
+++ b/src/mathicgb/SigPolyBasis.cpp
@@ -57,7 +57,7 @@ void SigPolyBasis::addComponent() {
void SigPolyBasis::insert(Mono ownedSig, std::unique_ptr<Poly> f) {
MATHICGB_ASSERT(f.get() != nullptr);
MATHICGB_ASSERT(!f->isZero());
- MATHICGB_ASSERT(f->getLeadCoefficient() != 0);
+ MATHICGB_ASSERT(f->leadCoef() != 0);
MATHICGB_ASSERT(!ownedSig.isNull());
MATHICGB_ASSERT(monoid().fromPool(*ownedSig));
@@ -70,11 +70,11 @@ void SigPolyBasis::insert(Mono ownedSig, std::unique_ptr<Poly> f) {
mSignatureLookup[component]->insert(sig, index);
auto ratio = ring().allocMonomial();
- monoid().divideToNegative(f->getLeadMonomial(), sig, ratio);
+ monoid().divideToNegative(f->leadMono(), sig, ratio);
mSigLeadRatio.push_back(ratio);
- const_monomial const lead = f->getLeadMonomial();
+ const auto lead = f->leadMono();
mBasis.insert(std::move(f));
if (mBasis.leadMinimal(mBasis.size() - 1)) {
mMinimalMonoLookup->removeMultiples(lead);
@@ -362,7 +362,7 @@ bool SigPolyBasis::isSingularTopReducibleSlow(
monomial multiplier = ring().allocMonomial();
const size_t genCount = size();
- const_monomial polyLead = poly.getLeadMonomial();
+ const auto polyLead = poly.leadMono();
for (size_t i = 0; i < genCount; ++i) {
if (!monoid().divides(leadMono(i), polyLead))
continue;
diff --git a/src/mathicgb/SparseMatrix.cpp b/src/mathicgb/SparseMatrix.cpp
index 7801475..fe4afce 100755
--- a/src/mathicgb/SparseMatrix.cpp
+++ b/src/mathicgb/SparseMatrix.cpp
@@ -42,7 +42,7 @@ void SparseMatrix::rowToPolynomial(
for (auto it = rowBegin(row); it != end; ++it) {
MATHICGB_ASSERT(it.index() < colMonomials.size());
if (it.scalar() != 0)
- poly.appendTerm(it.scalar(), Monoid::toOld(*colMonomials[it.index()]));
+ poly.append(it.scalar(), *colMonomials[it.index()]);
}
MATHICGB_ASSERT(poly.termsAreInDescendingOrder());
}
diff --git a/src/mathicgb/TypicalReducer.cpp b/src/mathicgb/TypicalReducer.cpp
index 97b6bce..9a11701 100755
--- a/src/mathicgb/TypicalReducer.cpp
+++ b/src/mathicgb/TypicalReducer.cpp
@@ -60,7 +60,7 @@ std::unique_ptr<Poly> TypicalReducer::regularReduce(
MATHICGB_ASSERT(v.coeff != 0);
reducer = basis.regularReducer(sig, v.monom);
if (reducer == static_cast<size_t>(-1)) { // no reducer found
- result->appendTerm(v.coeff, v.monom);
+ result->append(v.coeff, v.monom);
removeLeadTerm();
} else { // reduce by reducer
++steps;
@@ -97,7 +97,7 @@ std::unique_ptr<Poly> TypicalReducer::classicTailReduce(const Poly& poly, const
insertTail(identity, &poly);
std::unique_ptr<Poly> result(new Poly(basis.ring()));
- result->appendTerm(poly.getLeadCoefficient(), poly.getLeadMonomial());
+ result->append(poly.leadCoef(), poly.leadMono());
return classicReduce(std::move(result), basis);
}
@@ -107,22 +107,22 @@ std::unique_ptr<Poly> TypicalReducer::classicReduceSPoly(
const Poly& b,
const PolyBasis& basis
) {
- const PolyRing& ring = basis.ring();
+ const auto& ring = basis.ring();
+ const auto& monoid = basis.ring().monoid();
monomial lcm = ring.allocMonomial();
- ring.monomialLeastCommonMultiple
- (a.getLeadMonomial(), b.getLeadMonomial(), lcm);
+ monoid.lcm(a.leadMono(), b.leadMono(), lcm);
// insert tail of multiple of a
monomial multiple1 = ring.allocMonomial();
- ring.monomialDivide(lcm, a.getLeadMonomial(), multiple1);
+ monoid.divide(a.leadMono(), lcm, multiple1);
coefficient plusOne;
ring.coefficientSet(plusOne, 1);
insertTail(const_term(plusOne, multiple1), &a);
// insert tail of multiple of b
monomial multiple2 = ring.allocMonomial();
- ring.monomialDivide(lcm, b.getLeadMonomial(), multiple2);
+ monoid.divide(b.leadMono(), lcm, multiple2);
coefficient minusOne = plusOne;
ring.coefficientNegateTo(minusOne);
insertTail(const_term(minusOne, multiple2), &b);
@@ -183,9 +183,9 @@ std::unique_ptr<Poly> TypicalReducer::classicReduce
if (reducer == static_cast<size_t>(-1)) { // no reducer found
MATHICGB_ASSERT(
result->isZero() ||
- basis.monoid().lessThan(v.monom, result->backMonomial())
+ basis.monoid().lessThan(v.monom, result->backMono())
);
- result->appendTerm(v.coeff, v.monom);
+ result->append(v.coeff, v.monom);
removeLeadTerm();
} else { // reduce by reducer
++steps;
diff --git a/src/mathicgb/TypicalReducer.hpp b/src/mathicgb/TypicalReducer.hpp
index 5e6c1fb..0189c09 100755
--- a/src/mathicgb/TypicalReducer.hpp
+++ b/src/mathicgb/TypicalReducer.hpp
@@ -60,7 +60,7 @@ protected:
// out sub-steps in the reduction.
virtual void insertTail(const_term multiplier, const Poly* f) {
MATHICGB_ASSERT(f != 0);
- NewConstTerm t = {multiplier.monom, multiplier.coeff};
+ NewConstTerm t = {multiplier.coeff, multiplier.monom};
insertTail(t, *f);
}
diff --git a/src/test/F4MatrixBuilder.cpp b/src/test/F4MatrixBuilder.cpp
index 9b24100..f502298 100755
--- a/src/test/F4MatrixBuilder.cpp
+++ b/src/test/F4MatrixBuilder.cpp
@@ -108,7 +108,7 @@ TEST(F4MatrixBuilder, OneByOne) {
BuilderMaker maker;
const Poly& p = maker.addBasisElement("a");
F4MatrixBuilder& builder = maker.create();
- builder.addPolynomialToMatrix(p.getLeadMonomial(), p);
+ builder.addPolynomialToMatrix(p.leadMono(), p);
QuadMatrix qm(builder.ring());
builder.buildMatrixAndClear(qm);
const char* str =
@@ -134,14 +134,14 @@ TEST(F4MatrixBuilder, DirectReducers) {
{
std::istringstream in("a3<0>+b2+c+d");
p1.parse(in);
- builder.addPolynomialToMatrix(p1.getLeadMonomial(), p1);
+ builder.addPolynomialToMatrix(p1.leadMono(), p1);
}
Poly p2(builder.ring());
{
std::istringstream in("a3<0>+2b2+3c+4d");
p2.parse(in);
- builder.addPolynomialToMatrix(p2.getLeadMonomial(), p2);
+ builder.addPolynomialToMatrix(p2.leadMono(), p2);
}
QuadMatrix qm(builder.ring());
@@ -167,7 +167,7 @@ TEST(F4MatrixBuilder, IteratedReducer) {
const Poly& p1 = maker.addBasisElement("a4-a3");
const Poly& p2 = maker.addBasisElement("a-1");
F4MatrixBuilder& builder = maker.create();
- builder.addPolynomialToMatrix(p1.getLeadMonomial(), p2);
+ builder.addPolynomialToMatrix(p1.leadMono(), p2);
QuadMatrix qm(builder.ring());
builder.buildMatrixAndClear(qm);
const char* str =
diff --git a/src/test/F4MatrixReducer.cpp b/src/test/F4MatrixReducer.cpp
index 00b18b7..bd53a3f 100755
--- a/src/test/F4MatrixReducer.cpp
+++ b/src/test/F4MatrixReducer.cpp
@@ -20,12 +20,11 @@ TEST(F4MatrixReducer, Reduce) {
std::istringstream in("a4+a3+a2+a1+b5+b4+b3+b2+b1");
p.parse(in);
size_t count = 0;
- for (Poly::iterator it = p.begin(); it != p.end(); ++it) {
- monomial mono = it.getMonomial();
+ for (auto it = p.begin(); it != p.end(); ++it) {
if (count < 4)
- m.leftColumnMonomials.push_back(mono);
+ m.leftColumnMonomials.push_back(it.mono());
else
- m.rightColumnMonomials.push_back(mono);
+ m.rightColumnMonomials.push_back(it.mono());
++count;
}
diff --git a/src/test/QuadMatrixBuilder.cpp b/src/test/QuadMatrixBuilder.cpp
index 5c7f146..7bf57f5 100755
--- a/src/test/QuadMatrixBuilder.cpp
+++ b/src/test/QuadMatrixBuilder.cpp
@@ -38,9 +38,9 @@ namespace {
std::istringstream in(left);
p.parseDoNotOrder(in);
size_t colCount = 0;
- for (Poly::iterator it = p.begin(); it != p.end(); ++it) {
+ for (auto it = p.begin(); it != p.end(); ++it) {
QuadMatrixBuilder::LeftRightColIndex lrCol =
- b.createColumnLeft(it.getMonomial()).first;
+ b.createColumnLeft(it.mono()).first;
ASSERT_TRUE(lrCol.left());
ASSERT_FALSE(lrCol.right());
auto col = lrCol.leftIndex();
@@ -54,9 +54,9 @@ namespace {
std::istringstream in(right);
p.parseDoNotOrder(in);
size_t colCount = 0;
- for (Poly::iterator it = p.begin(); it != p.end(); ++it) {
+ for (auto it = p.begin(); it != p.end(); ++it) {
QuadMatrixBuilder::LeftRightColIndex lrCol =
- b.createColumnRight(it.getMonomial()).first;
+ b.createColumnRight(it.mono()).first;
ASSERT_TRUE(lrCol.right());
ASSERT_FALSE(lrCol.left());
auto col = lrCol.rightIndex();
@@ -143,15 +143,16 @@ TEST(QuadMatrixBuilder, ColumnQuery) {
std::istringstream in
("10a<1>+11<0>+20b<0>+21c<0>+22bc<0>+30ab<0>+30e<0>+10a<1>");
p.parseDoNotOrder(in);
- for (Poly::iterator it = p.begin(); it != p.end(); ++it) {
+ for (auto it = p.begin(); it != p.end(); ++it) {
const QuadMatrixBuilder::LeftRightColIndex* col =
- MonomialMap<QuadMatrixBuilder::LeftRightColIndex>::Reader(map).find(it.getMonomial()).first;
- if (it.getCoefficient() / 10 == 3)
+ MonomialMap<QuadMatrixBuilder::LeftRightColIndex>::Reader(map).
+ find(it.mono()).first;
+ if (it.coef() / 10 == 3)
ASSERT_EQ(col, static_cast<void*>(0));
else {
ASSERT_TRUE(col != static_cast<void*>(0));
- ASSERT_EQ(it.getCoefficient() % 10, col->index());
- if (it.getCoefficient() / 10 == 2)
+ ASSERT_EQ(it.coef() % 10, col->index());
+ if (it.coef() / 10 == 2)
ASSERT_TRUE(col->right());
else
ASSERT_TRUE(col->left());
diff --git a/src/test/poly-test.cpp b/src/test/poly-test.cpp
index 6f44966..ec11eee 100755
--- a/src/test/poly-test.cpp
+++ b/src/test/poly-test.cpp
@@ -636,9 +636,10 @@ TEST(Poly,lead) {
// This also tests Poly::iterator, Poly::read, Poly::write
std::unique_ptr<Basis> I = basisParseFromString(ideal1);
std::unique_ptr<const PolyRing> R(I->getPolyRing());
+ const auto& monoid = R->monoid();
monomial lm = stringToMonomial(R.get(), "ab");
- EXPECT_TRUE(R->monomialEQ(lm, I->getPoly(0)->getLeadMonomial()));
- EXPECT_EQ(1, I->getPoly(0)->getLeadCoefficient());
- EXPECT_EQ(0, I->getPoly(0)->getLeadComponent());
+ EXPECT_TRUE(monoid.equal(lm, I->getPoly(0)->leadMono()));
+ EXPECT_EQ(1, I->getPoly(0)->leadCoef());
+ EXPECT_EQ(0, monoid.component(I->getPoly(0)->leadMono()));
R->freeMonomial(lm);
}
--
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