[mathicgb] 300/393: Added support in MonoMonoid for comparing components before, after or in-between gradings, rather than only at the end.
Doug Torrance
dtorrance-guest at moszumanska.debian.org
Fri Apr 3 15:59:25 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 28908de61ea018822315d06305f1ad13f7d5e37f
Author: Bjarke Hammersholt Roune <bjarkehr.code at gmail.com>
Date: Mon Apr 29 17:21:08 2013 +0200
Added support in MonoMonoid for comparing components before, after or in-between gradings, rather than only at the end.
---
examples/hyclic8-101-trimmed.ideal | 0
src/mathicgb/Basis.cpp | 6 +-
src/mathicgb/Basis.hpp | 2 +-
src/mathicgb/BuchbergerAlg.cpp | 7 +-
src/mathicgb/F4Reducer.cpp | 2 +-
src/mathicgb/LogDomain.hpp | 15 ++--
src/mathicgb/MonoMonoid.hpp | 156 ++++++++++++++++++++++++-------------
src/mathicgb/MonoOrder.hpp | 52 ++++++++++---
src/mathicgb/MonoProcessor.hpp | 2 -
src/mathicgb/PolyRing.cpp | 9 ++-
src/mathicgb/PolyRing.hpp | 4 +-
src/mathicgb/SPairs.cpp | 14 +++-
src/mathicgb/SPairs.hpp | 17 ++--
src/mathicgb/io-util.cpp | 2 +-
src/test/MonoMonoid.cpp | 20 +++--
src/test/gb-test.cpp | 14 ++--
src/test/ideals.cpp | 20 ++++-
src/test/ideals.hpp | 3 +-
src/test/poly-test.cpp | 2 +-
19 files changed, 230 insertions(+), 117 deletions(-)
diff --git a/examples/hyclic8-101-trimmed.ideal b/examples/hyclic8-101-trimmed.ideal
old mode 100644
new mode 100755
diff --git a/src/mathicgb/Basis.cpp b/src/mathicgb/Basis.cpp
index 771bd12..11788e5 100755
--- a/src/mathicgb/Basis.cpp
+++ b/src/mathicgb/Basis.cpp
@@ -43,7 +43,7 @@ void Basis::sort(FreeModuleOrder& order) {
std::unique_ptr<Basis> Basis::parse(std::istream& in)
{
- PolyRing *R = PolyRing::read(in); // todo: fix this leak
+ PolyRing* R = PolyRing::read(in).first; // todo: fix this leak
size_t npolys;
in >> npolys;
auto result = make_unique<Basis>(*R);
@@ -57,9 +57,9 @@ std::unique_ptr<Basis> Basis::parse(std::istream& in)
return result;
}
-void Basis::display(std::ostream& out, bool printComponent) const
+void Basis::display(std::ostream& out, bool printComponent, bool componentIncreasingDesired) const
{
- mRing.write(out);
+ mRing.write(out, componentIncreasingDesired);
out << '\n' << mGenerators.size() << '\n';
for (size_t i = 0; i < mGenerators.size(); ++i) {
mGenerators[i]->display(out, printComponent);
diff --git a/src/mathicgb/Basis.hpp b/src/mathicgb/Basis.hpp
index 70b66ba..c01db6d 100755
--- a/src/mathicgb/Basis.hpp
+++ b/src/mathicgb/Basis.hpp
@@ -23,7 +23,7 @@ public:
static std::unique_ptr<Basis> parse(std::istream &i);
/// inverse operation to parse().
- void display(std::ostream &o, bool print_comp) const;
+ void display(std::ostream &o, bool print_comp, bool componentIncreasingDesired) const;
const PolyRing& ring() const { return mRing; }
diff --git a/src/mathicgb/BuchbergerAlg.cpp b/src/mathicgb/BuchbergerAlg.cpp
index 1abdab3..c086d6a 100755
--- a/src/mathicgb/BuchbergerAlg.cpp
+++ b/src/mathicgb/BuchbergerAlg.cpp
@@ -6,8 +6,8 @@
#include <iostream>
MATHICGB_DEFINE_LOG_DOMAIN(
- F4SPairDegree,
- "Displays the degree of the S-pairs being considered in F4 Reducers"
+ SPairDegree,
+ "Displays the degree of the S-pairs being considered in Buchberger's algorithm."
);
BuchbergerAlg::BuchbergerAlg(
@@ -258,7 +258,8 @@ void BuchbergerAlg::step() {
std::vector<std::unique_ptr<Poly>> reduced;
// w is the negative of the degree of the lcm's of the chosen spairs
- MATHICGB_LOG(F4SPairDegree) << std::endl << spairGroup.size() << " pairs in degree " << -w;
+ MATHICGB_LOG(SPairDegree) <<
+ spairGroup.size() << " pairs in degree " << -w << std::endl;
mReducer.classicReduceSPolySet(spairGroup, mBasis, reduced);
diff --git a/src/mathicgb/F4Reducer.cpp b/src/mathicgb/F4Reducer.cpp
index 680d5f0..edfefed 100755
--- a/src/mathicgb/F4Reducer.cpp
+++ b/src/mathicgb/F4Reducer.cpp
@@ -38,7 +38,7 @@ MATHICGB_DEFINE_LOG_ALIAS(
MATHICGB_DEFINE_LOG_ALIAS(
"F4",
"F4MatrixSizes,F4MatrixBuild,F4MatrixBuild2,"
- "F4SPairDegree,F4MatReduceTop,F4RedBottomRight"
+ "F4MatReduceTop,F4RedBottomRight"
);
F4Reducer::F4Reducer(const PolyRing& ring, Type type):
diff --git a/src/mathicgb/LogDomain.hpp b/src/mathicgb/LogDomain.hpp
index 2146aed..8e4156f 100755
--- a/src/mathicgb/LogDomain.hpp
+++ b/src/mathicgb/LogDomain.hpp
@@ -196,7 +196,9 @@ namespace LogDomainInternal {
return r;
}
template<class L, class T>
- void operator+(LambdaRunner<L> runner, T&& lambda) {lambda(runner.log);}
+ void operator+(LambdaRunner<L> runner, T&& lambda) {
+ lambda(runner.log, runner.log.stream());
+ }
struct LogAliasRegisterer {
LogAliasRegisterer(const char* alias, const char* of);
@@ -268,20 +270,21 @@ namespace LogDomainInternal {
#define MATHICGB_LOGGER_TYPE(DOMAIN) ::logs::Type##DOMAIN
/// Runs the code in the following scope delimited by braces {} if the
-/// indicated logger is enabled for streaming - otherwise does nothing.
-/// Within the following scope there is a local reference variable log
-/// that refers to the indicated logger.
+/// indicated logger is enabled for streaming - otherwise does
+/// nothing. Within the following scope there is a local reference
+/// variable log that refers to the indicated logger and a local
+/// reference variable stream that refers to log.stream().
///
/// Example:
/// MATHICGB_IF_STREAM_LOG(MyDomain) {
/// std::string msg;
/// expensiveFunction(msg);
-/// log << msg;
+/// stream << msg; // or log.stream() << msg;
/// }
#define MATHICGB_IF_STREAM_LOG(DOMAIN) \
if (MATHICGB_LOGGER(DOMAIN).streamEnabled()) \
LogDomainInternal::lambdaRunner(MATHICGB_LOGGER(DOMAIN)) + \
- [&](MATHICGB_LOGGER_TYPE(DOMAIN)& log)
+ [&](MATHICGB_LOGGER_TYPE(DOMAIN)& log, std::ostream& stream)
/// Display information to the log using <<.
/// If domain is not enabled and stream enabled then the log message is not
diff --git a/src/mathicgb/MonoMonoid.hpp b/src/mathicgb/MonoMonoid.hpp
index cfcd03f..c7e7dbc 100755
--- a/src/mathicgb/MonoMonoid.hpp
+++ b/src/mathicgb/MonoMonoid.hpp
@@ -63,8 +63,14 @@ namespace MonoMonoidInternal {
mOrderIsTotalDegreeRevLex
(order.baseOrder() == Order::RevLexBaseOrder && order.isTotalDegree()),
mLexBaseOrder(order.baseOrder() == Order::LexBaseOrder),
- mGradings(mOrderIsTotalDegreeRevLex ? Gradings() : makeGradings(order))
- {}
+ mGradings(makeGradings(order)),
+ mComponentGradingIndex(
+ order.componentGradingIndex() == Order::ComponentAfterBaseOrder ?
+ Order::ComponentAfterBaseOrder :
+ order.gradingCount() - 1 - order.componentGradingIndex()
+ )
+ {
+ }
VarIndex varCount() const {return mVarCount;}
VarIndex gradingCount() const {return mGradingCount;}
@@ -73,7 +79,7 @@ namespace MonoMonoidInternal {
VarIndex orderIndexEnd() const {return mOrderIndexEnd;}
VarIndex orderIndexBegin() const {return mOrderIndexBegin;}
VarIndex hashIndex() const {return mOrderIndexEnd;}
-
+ VarIndex componentGradingIndex() const {return mComponentGradingIndex;}
protected:
typedef std::vector<Exponent> HashCoefficients;
@@ -173,6 +179,7 @@ namespace MonoMonoidInternal {
const VarIndex mOrderIndexBegin;
const VarIndex mOrderIndexEnd;
const VarIndex mEntryCount;
+ const VarIndex mComponentGradingIndex;
/// Take dot product of exponents with this vector to get hash value.
const HashCoefficients mHashCoefficients;
@@ -314,31 +321,21 @@ public:
template<class E2, bool HC2, bool SH2, bool SO2>
static MonoMonoid create(const MonoMonoid<E2, HC2, SH2, SO2>& monoid) {
std::vector<Exponent> gradings(monoid.varCount(), 1);
- if (!monoid.orderIsTotalDegreeRevLex()) {
- gradings = monoid.gradings();
- reverseGradings(monoid.varCount(), gradings);
- if (monoid.isLexBaseOrder())
- negateGradings(gradings);
-/*
- gradings.resize(monoid.gradings().size());
- for (VarIndex grading = 0; grading < monoid.gradingCount(); ++grading) {
- for (VarIndex var = 0; var < monoid.varCount(); ++var) {
- auto w = monoid.gradings()[monoid.gradingsOppositeRowIndex(grading, var)];
- if (!monoid.isLexBaseOrder())
- w = -w;
- gradings[monoid.gradingsIndex(grading, var)] = w;
- }
- }
-*/
- }
+ gradings = monoid.gradings();
+ reverseGradings(monoid.varCount(), gradings);
+ if (!monoid.isLexBaseOrder())
+ negateGradings(gradings);
Order order(monoid.varCount(), std::move(gradings),
monoid.isLexBaseOrder() ?
Order::LexBaseOrder : Order::RevLexBaseOrder);
return MonoMonoid(order);
}
- static MonoMonoid readMonoid(std::istream& in);
- void printMonoid(std::ostream& out) const;
+ /// The second component of the return pair indicates whether it is
+ /// desired that i>j => e_i > e_j.
+ static std::pair<MonoMonoid, bool> readMonoid(std::istream& in);
+ void printMonoid
+ (const bool componentIncreasingDesired, std::ostream& out) const;
bool operator==(const MonoMonoid& monoid) const {
return this == &monoid;
@@ -853,6 +850,7 @@ public:
const auto oldComponent = component;
component = newComponent;
updateHashComponent(oldComponent, newComponent, mono);
+ updateOrderComponent(newComponent, mono);
MATHICGB_ASSERT(debugValid(mono));
}
@@ -1450,6 +1448,8 @@ private:
friend class MonoVector;
friend class MonoPool;
+ typedef typename Base::Gradings Gradings;
+
bool debugAssertValid() const {
#ifdef MATHICGB_DEBUG
// ** Order checks
@@ -1465,12 +1465,18 @@ private:
MATHICGB_ASSERT(isLexBaseOrder() || varCount() == 0 || gradingCount() >= 1);
+ MATHICGB_ASSERT(gradings().size() == gradingCount() * varCount());
if (orderIsTotalDegreeRevLex()) {
MATHICGB_ASSERT(!isLexBaseOrder());
- MATHICGB_ASSERT(gradings().empty());
MATHICGB_ASSERT(gradingCount() == 1);
- } else {
- MATHICGB_ASSERT(gradings().size() == gradingCount() * varCount());
+ }
+
+ if (componentGradingIndex() != Order::ComponentAfterBaseOrder) {
+ MATHICGB_ASSERT(componentGradingIndex() < gradingCount());
+ for (VarIndex var = 0; var < varCount(); ++var) {
+ const auto index = gradingsIndex(componentGradingIndex(), var);
+ MATHICGB_ASSERT(gradings()[index] == 0);
+ }
}
// ** Hash checks
@@ -1582,11 +1588,9 @@ private:
return;
MATHICGB_ASSERT(var < varCount());
- if (orderIsTotalDegreeRevLex()) {
- MATHICGB_ASSERT(!isLexBaseOrder());
- MATHICGB_ASSERT(gradingCount() == 1);
+ if (orderIsTotalDegreeRevLex())
rawPtr(mono)[orderIndexBegin()] -= newExponent - oldExponent;
- } else {
+ else {
MATHICGB_ASSERT(gradings().size() == gradingCount() * varCount());
const auto degrees = ptr(mono, orderIndexBegin());
for (VarIndex grading = 0; grading < gradingCount(); ++grading) {
@@ -1597,6 +1601,11 @@ private:
MATHICGB_ASSERT(debugOrderValid(mono));
}
+ void updateOrderComponent(const VarIndex newComponent, MonoRef mono) const {
+ if (componentGradingIndex() != Order::ComponentAfterBaseOrder)
+ ptr(mono, orderIndexBegin())[componentGradingIndex()] = newComponent;
+ }
+
Exponent computeDegree(ConstMonoRef mono, VarIndex grading) const {
MATHICGB_ASSERT(grading < gradingCount());
@@ -1605,7 +1614,9 @@ private:
MATHICGB_ASSERT(grading == 0);
for (auto var = 0; var < varCount(); ++var)
degree -= exponent(mono, var);
- } else {
+ } else if (HasComponent && componentGradingIndex() == grading)
+ return component(mono);
+ else {
MATHICGB_ASSERT(gradings().size() == gradingCount() * varCount());
for (auto var = 0; var < varCount(); ++var) {
const auto index = gradingsIndex(grading, var);
@@ -1701,6 +1712,7 @@ private:
using Base::orderIsTotalDegreeRevLex;
using Base::gradings;
using Base::isLexBaseOrder;
+ using Base::componentGradingIndex;
VarIndex entriesIndexBegin() const {return 0;}
VarIndex entriesIndexEnd() const {return entryCount();}
@@ -1729,7 +1741,9 @@ namespace MonoMonoidHelper {
}
template<class E, bool HC, bool SH, bool SO>
-auto MonoMonoid<E, HC, SH, SO>::readMonoid(std::istream& in) -> MonoMonoid {
+auto MonoMonoid<E, HC, SH, SO>::readMonoid(std::istream& in) ->
+ std::pair<MonoMonoid, bool>
+{
using MonoMonoidHelper::unchar;
VarIndex varCount;
in >> varCount;
@@ -1753,48 +1767,78 @@ auto MonoMonoid<E, HC, SH, SO>::readMonoid(std::istream& in) -> MonoMonoid {
VarIndex gradingCount;
in >> gradingCount;
- const size_t weightCount = static_cast<size_t>(varCount) * gradingCount;
- std::vector<Exponent> gradings(weightCount);
- for (size_t w = 0; w < weightCount; ++w) {
- typename unchar<Exponent>::type e;
- in >> e;
- gradings[w] = static_cast<Exponent>(e);
+ Gradings gradings(static_cast<size_t>(varCount) * gradingCount);
+ bool componentIncreasingDesired = true;
+ auto componentCompareIndex = Order::ComponentAfterBaseOrder;
+ size_t w = 0;
+ for (VarIndex grading = 0; grading < gradingCount; ++grading) {
+ char c;
+ in >> c;
+ in.unget();
+ if (!std::isdigit(c)) {
+ std::string str;
+ in >> str;
+ if (str == "component")
+ componentIncreasingDesired = true;
+ else if (str == "revcomponent")
+ componentIncreasingDesired = false;
+ else
+ mathic::reportError
+ ("Expected component or revcomponent but read \"" + str + "\".");
+ if (!HasComponent)
+ mathic::reportError
+ ("Cannot specify component comparison for non-modules.");
+ if (componentCompareIndex != Order::ComponentAfterBaseOrder)
+ mathic::reportError("Component must be considered at most once.");
+ componentCompareIndex = grading;
+ w += varCount;
+ } else {
+ for (VarIndex i = 0; i < varCount; ++i, ++w) {
+ typename unchar<Exponent>::type e;
+ in >> e;
+ gradings[w] = static_cast<Exponent>(e);
+ }
+ }
}
+ MATHICGB_ASSERT(w == gradings.size());
Order order(
varCount,
std::move(gradings),
lexBaseOrder ? Order::LexBaseOrder : Order::RevLexBaseOrder,
- Order::ComponentAfterBaseOrder
+ componentCompareIndex
);
- return MonoMonoid(order);
+ return std::make_pair(MonoMonoid(order), componentIncreasingDesired);
}
template<class E, bool HC, bool SH, bool SO>
-void MonoMonoid<E, HC, SH, SO>::printMonoid(std::ostream& out) const {
+void MonoMonoid<E, HC, SH, SO>::printMonoid(
+ const bool componentIncreasingDesired,
+ std::ostream& out
+) const {
using MonoMonoidHelper::unchar;
typedef typename unchar<Exponent>::type UncharredExponent;
out << varCount() << '\n'
<< (isLexBaseOrder() ? "lex" : "revlex")
<< ' ' << gradingCount() << '\n';
- if (orderIsTotalDegreeRevLex()) {
- MATHICGB_ASSERT(!isLexBaseOrder());
- MATHICGB_ASSERT(gradings().empty());
- for (VarIndex var = 0; var < varCount(); ++var)
- out << " 1";
- out << '\n';
- } else {
- MATHICGB_ASSERT(gradings().size() == gradingCount() * varCount());
- for (VarIndex grading = 0; grading < gradingCount(); ++grading) {
- for (VarIndex var = 0; var < varCount(); ++var) {
- auto w = gradings()[gradingsOppositeRowIndex(grading, var)];
- if (!isLexBaseOrder())
- w = -w;
- out << ' ' << static_cast<UncharredExponent>(w);
- }
- out << '\n';
+ MATHICGB_ASSERT(gradings().size() == gradingCount() * varCount());
+ for (VarIndex grading = 0; grading < gradingCount(); ++grading) {
+ if (
+ HasComponent &&
+ grading == gradingCount() - 1 - componentGradingIndex()
+ ) {
+ out << (componentIncreasingDesired ? " component\n" : " revcomponent\n");
+ continue;
}
+
+ for (VarIndex var = 0; var < varCount(); ++var) {
+ auto w = gradings()[gradingsOppositeRowIndex(grading, var)];
+ if (!isLexBaseOrder())
+ w = -w;
+ out << ' ' << static_cast<UncharredExponent>(w);
+ }
+ out << '\n';
}
}
diff --git a/src/mathicgb/MonoOrder.hpp b/src/mathicgb/MonoOrder.hpp
index c46674d..7045110 100755
--- a/src/mathicgb/MonoOrder.hpp
+++ b/src/mathicgb/MonoOrder.hpp
@@ -2,6 +2,7 @@
#define MATHICGB_MONO_ORDER_GUARD
#include <vector>
+#include <algorithm>
/// Class used to describe an monomial order or a module monomial
/// order. Use this class to construct a monoid. The monoid does the
@@ -18,6 +19,7 @@ class MonoOrder {
public:
typedef W Weight;
typedef size_t VarIndex;
+ typedef std::vector<Weight> Gradings;
static const size_t ComponentAfterBaseOrder = static_cast<size_t>(-1);
@@ -37,9 +39,10 @@ public:
const size_t componentBefore = ComponentAfterBaseOrder
):
mVarCount(varCount),
- mGradings(varCount, 1),
+ mGradings
+ (addComponentGrading(Gradings(varCount, 1), varCount, componentBefore)),
mBaseOrder(baseOrder),
- mComponentBefore(ComponentAfterBaseOrder)
+ mComponentGradingIndex(componentBefore)
{}
/// The specified base order is graded by the gradings matrix.
@@ -76,17 +79,27 @@ public:
/// will return false.
MonoOrder(
const VarIndex varCount,
- std::vector<Weight>&& gradings,
+ Gradings&& gradings,
const BaseOrder baseOrder = RevLexBaseOrder,
const size_t componentBefore = ComponentAfterBaseOrder
):
mVarCount(varCount),
mGradings(std::move(gradings)),
mBaseOrder(baseOrder),
- mComponentBefore(componentBefore)
- {}
+ mComponentGradingIndex(componentBefore)
+ {
+#ifdef MATHCGB_DEBUG
+ if (componentBefore != ComponentAfterBaseOrder) {
+ for (VarIndex var = 0; var < varCount(); ++var) {
+ MATHICGB_ASSERT(mGradings[var] == 0);
+ }
+ }
+#endif
+ }
- const VarIndex varCount() const {return mVarCount;}
+ VarIndex varCount() const {return mVarCount;}
+
+ VarIndex componentGradingIndex() const {return mComponentGradingIndex;}
/// Returns the number of rows in the grading vector.
size_t gradingCount() const {
@@ -94,7 +107,7 @@ public:
}
/// Returns the grading matrix in row-major layout.
- const std::vector<Weight>& gradings() const {return mGradings;}
+ const Gradings& gradings() const {return mGradings;}
/// Returns true if the grading matrix is a single row of 1's.
bool isTotalDegree() const {
@@ -140,12 +153,27 @@ public:
}
private:
+ static Gradings addComponentGrading(
+ Gradings&& gradings,
+ const VarIndex varCount,
+ const VarIndex componentBefore
+ ) {
+ if (componentBefore == ComponentAfterBaseOrder)
+ return std::move(gradings);
+ MATHICGB_ASSERT(componentBefore <= varCount);
+ gradings.resize(gradings.size() + varCount);
+ const auto newRow = gradings.begin() + varCount * componentBefore;
+ std::copy_n(newRow, varCount, newRow + varCount);
+ std::fill_n(newRow, varCount, static_cast<Weight>(0));
+ return std::move(gradings);
+ }
+
bool debugAssertValid() {
#ifdef MATHICGB_DEBUG
MATHICGB_ASSERT(mGradings.size() == gradingCount() * varCount());
MATHICGB_ASSERT(
- mComponentBefore == ComponentAfterBaseOrder ||
- mComponentBefore <= gradingCount()
+ mComponentGradingIndex == ComponentAfterBaseOrder ||
+ mComponentGradingIndex < gradingCount()
);
MATHICGB_ASSERT(
mBaseOrder == LexBaseOrder ||
@@ -154,16 +182,16 @@ private:
if (varCount() == 0) {
MATHICGB_ASSERT(mGradings.empty());
MATHICGB_ASSERT(baseOrder() == RevLexBaseOrder());
- MATHICGB_ASSERT(mComponentBefore == ComponentAfterBaseOrder);
+ MATHICGB_ASSERT(mComponentGradingIndex == ComponentAfterBaseOrder);
}
#endif
return true;
}
const VarIndex mVarCount;
- const std::vector<Weight> mGradings;
+ const Gradings mGradings;
const BaseOrder mBaseOrder;
- const size_t mComponentBefore;
+ const size_t mComponentGradingIndex;
};
#endif
diff --git a/src/mathicgb/MonoProcessor.hpp b/src/mathicgb/MonoProcessor.hpp
index 0881764..2cc0416 100755
--- a/src/mathicgb/MonoProcessor.hpp
+++ b/src/mathicgb/MonoProcessor.hpp
@@ -32,9 +32,7 @@ public:
):
mMonoid(monoid),
mComponentsAscendingDesired(componentsAscendingDesired),
- //mComponentsAscendingDesired(order.componentsAscendingDesired),
mComponentCount(componentCount),
- //mComponentCount(order.componentCount()),
mModuleAdjustmentsMemory(std::move(moduleAdjustments))
{
MATHICGB_ASSERT(mModuleAdjustmentsMemory.monoid() == this->monoid());
diff --git a/src/mathicgb/PolyRing.cpp b/src/mathicgb/PolyRing.cpp
index 7a206b2..e07aed6 100755
--- a/src/mathicgb/PolyRing.cpp
+++ b/src/mathicgb/PolyRing.cpp
@@ -228,19 +228,20 @@ void PolyRing::printMonomialFrobbyM2Format(std::ostream& out, ConstMonomial m) c
out << '1';
}
-PolyRing *PolyRing::read(std::istream &i)
+std::pair<PolyRing*, bool> PolyRing::read(std::istream &i)
{
int64 characInt;
coefficient charac;
i >> characInt;
charac = static_cast<exponent>(characInt);
- return new PolyRing(charac, Monoid::readMonoid(i));
+ auto p = Monoid::readMonoid(i);
+ return std::make_pair(new PolyRing(charac, std::move(p.first)), p.second);
}
-void PolyRing::write(std::ostream &o) const
+void PolyRing::write(std::ostream &o, bool componentIncreasingDesired) const
{
o << charac() << ' ';
- monoid().printMonoid(o);
+ monoid().printMonoid(componentIncreasingDesired, o);
}
// Local Variables:
diff --git a/src/mathicgb/PolyRing.hpp b/src/mathicgb/PolyRing.hpp
index 15005dc..66547d7 100755
--- a/src/mathicgb/PolyRing.hpp
+++ b/src/mathicgb/PolyRing.hpp
@@ -219,8 +219,8 @@ public:
// const std::vector<int> °s,
// const std::string &monorder);
- static PolyRing *read(std::istream &i);
- void write(std::ostream &o) const;
+ static std::pair<PolyRing*, bool> read(std::istream &i);
+ void write(std::ostream &o, bool componentIncreasingDesired) const;
// Format for ring
// <char> <mNumVars> <deg1> ... <deg_n> <monorder>
diff --git a/src/mathicgb/SPairs.cpp b/src/mathicgb/SPairs.cpp
index 5ae9637..576fa2a 100755
--- a/src/mathicgb/SPairs.cpp
+++ b/src/mathicgb/SPairs.cpp
@@ -17,11 +17,14 @@ MATHICGB_DEFINE_LOG_DOMAIN_WITH_DEFAULTS(
0, 0, 1
);
-MATHICGB_DEFINE_LOG_ALIAS(
- "SPairs",
- "SPairEarly,SPairLate"
+MATHICGB_DEFINE_LOG_DOMAIN(
+ SPairLcm,
+ "Displays the lcm of the S-pairs being considered in Buchberger's algorithm."
);
+MATHICGB_DEFINE_LOG_ALIAS("SPairs", "SPairEarly,SPairLate");
+MATHICGB_DEFINE_LOG_ALIAS("SPairsDetail", "SPairs,SPairDegree,SPairLcm");
+
SPairs::SPairs(const PolyBasis& basis, bool preferSparseSPairs):
mMonoid(basis.ring().monoid()),
mOrderMonoid(OrderMonoid::create(mMonoid)),
@@ -85,6 +88,11 @@ std::pair<size_t, size_t> SPairs::pop(exponent& w) {
break;
mQueue.pop();
mEliminated.setBit(p.first, p.second, true);
+ MATHICGB_IF_STREAM_LOG(SPairLcm) {
+ stream << "Scheduling S-pair with lcm ";
+ bareMonoid().printM2(lcm, stream);
+ stream << '.' << std::endl;
+ };
return p;
}
return std::make_pair(static_cast<size_t>(-1), static_cast<size_t>(-1));
diff --git a/src/mathicgb/SPairs.hpp b/src/mathicgb/SPairs.hpp
index 05ed93f..c37b373 100755
--- a/src/mathicgb/SPairs.hpp
+++ b/src/mathicgb/SPairs.hpp
@@ -173,24 +173,25 @@ private:
mPreferSparseSPairs(preferSparseSPairs) {}
typedef OrderMonoid::Mono PairData;
- void computePairData(size_t col, size_t row, OrderMonoid::MonoRef m) const;
+ void computePairData
+ (size_t col, size_t row, OrderMonoid::MonoRef m) const;
- typedef bool CompareResult;
- bool compare(
+ typedef bool CompareResult;
+ bool compare(
size_t colA, size_t rowA, OrderMonoid::ConstMonoRef a,
size_t colB, size_t rowB, OrderMonoid::ConstMonoRef b
- ) const {
+ ) const {
const auto cmp = orderMonoid().compare(a, b);
if (cmp == GT)
return true;
if (cmp == LT)
return false;
-
+
const bool aRetired = mBasis.retired(rowA) || mBasis.retired(colA);
const bool bRetired = mBasis.retired(rowB) || mBasis.retired(colB);
if (aRetired || bRetired)
return !bRetired;
-
+
if (mPreferSparseSPairs) {
const auto termCountA =
mBasis.basisElement(colA).termCount() +
@@ -204,8 +205,8 @@ private:
return false;
}
return colA + rowA > colB + rowB;
- }
- bool cmpLessThan(bool v) const {return v;}
+ }
+ bool cmpLessThan(bool v) const {return v;}
// The following methods are not required of a configuration.
OrderMonoid::Mono allocPairData() {return orderMonoid().alloc();}
diff --git a/src/mathicgb/io-util.cpp b/src/mathicgb/io-util.cpp
index 4cbe770..40388a9 100755
--- a/src/mathicgb/io-util.cpp
+++ b/src/mathicgb/io-util.cpp
@@ -42,7 +42,7 @@ std::unique_ptr<Basis> basisParseFromString(std::string str)
std::unique_ptr<PolyRing> ringFromString(std::string ringinfo)
{
std::stringstream ifil(ringinfo);
- return std::unique_ptr<PolyRing>(PolyRing::read(ifil));
+ return std::unique_ptr<PolyRing>(PolyRing::read(ifil).first);
}
Monomial stringToMonomial(const PolyRing *R, std::string mon)
diff --git a/src/test/MonoMonoid.cpp b/src/test/MonoMonoid.cpp
index 28bb218..7cb2a26 100755
--- a/src/test/MonoMonoid.cpp
+++ b/src/test/MonoMonoid.cpp
@@ -207,13 +207,14 @@ TYPED_TEST(Monoid, ReadWriteMonoid) {
continue;
std::istringstream in(str);
- const auto m = Monoid::readMonoid(in);
- ASSERT_EQ(varCount, m.varCount());
- ASSERT_EQ(gradingCount, m.gradingCount());
-
+ const auto p = Monoid::readMonoid(in);
+ const auto& m = p.first;
+
std::ostringstream out;
- m.printMonoid(out);
+ m.printMonoid(p.second, out);
ASSERT_EQ(outStr, out.str());
+ ASSERT_EQ(varCount, m.varCount());
+ ASSERT_EQ(gradingCount, m.gradingCount());
}
};
check("0 0\n", "0\nrevlex 0\n", 0, 0);
@@ -227,6 +228,15 @@ TYPED_TEST(Monoid, ReadWriteMonoid) {
check("1 lex 2 3 4", "1\nlex 2\n 3\n 4\n", 1, 2);
check("2 lex 2 3 4 5 6", "2\nlex 2\n 3 4\n 5 6\n", 2, 2);
check("4 lex 1 1 1 1 1", "4\nlex 1\n 1 1 1 1\n", 4, 1);
+
+ if (Monoid::HasComponent) {
+ check("2 2\n component\n 5 6\n", "2\nrevlex 2\n component\n 5 6\n", 2, 2);
+ check
+ ("2 2\n 3 4\n revcomponent\n","2\nrevlex 2\n 3 4\n revcomponent\n", 2, 2);
+ check("0 lex 1 component", "0\nlex 0\n", 0, 0);
+ check("1 lex 1 revcomponent", "1\nlex 1\n revcomponent\n", 1, 1);
+ check("5 lex 1 revcomponent", "5\nlex 1\n revcomponent\n", 5, 1);
+ }
}
TYPED_TEST(Monoid, MonoPool) {
diff --git a/src/test/gb-test.cpp b/src/test/gb-test.cpp
index 6a6e9b0..b98066e 100755
--- a/src/test/gb-test.cpp
+++ b/src/test/gb-test.cpp
@@ -348,37 +348,37 @@ TEST(GB, weispfennig97_0_5) {
}
TEST(GB, gerdt93_0_1) {
- testGB(1, gerdt93_ideal, gerdt93_gb_strat0_free1,
+ testGB(1, gerdt93Ideal(), gerdt93_gb_strat0_free1,
gerdt93_syzygies_strat0_free1, gerdt93_initial_strat0_free1, 9);
}
TEST(GB, gerdt93_0_2) {
- testGB(2, gerdt93_ideal, gerdt93_gb_strat0_free2,
+ testGB(2, gerdt93Ideal(), gerdt93_gb_strat0_free2,
gerdt93_syzygies_strat0_free2, gerdt93_initial_strat0_free2, 7);
}
TEST(GB, gerdt93_0_3) {
- testGB(3, gerdt93_ideal, gerdt93_gb_strat0_free3,
+ testGB(3, gerdt93Ideal(), gerdt93_gb_strat0_free3,
gerdt93_syzygies_strat0_free3, gerdt93_initial_strat0_free3, 9);
}
TEST(GB, gerdt93_0_4) {
- testGB(4, gerdt93_ideal, gerdt93_gb_strat0_free4,
+ testGB(4, gerdt93Ideal(), gerdt93_gb_strat0_free4,
gerdt93_syzygies_strat0_free4, gerdt93_initial_strat0_free4, 7);
}
TEST(GB, gerdt93_0_5) {
- testGB(5, gerdt93_ideal, gerdt93_gb_strat0_free5,
+ testGB(5, gerdt93Ideal(), gerdt93_gb_strat0_free5,
gerdt93_syzygies_strat0_free5, gerdt93_initial_strat0_free5, 7);
}
TEST(GB, gerdt93_0_6) {
- testGB(6, gerdt93_ideal, gerdt93_gb_strat0_free6,
+ testGB(6, gerdt93Ideal(), gerdt93_gb_strat0_free6,
gerdt93_syzygies_strat0_free6, gerdt93_initial_strat0_free6, 7);
}
TEST(GB, gerdt93_0_7) {
- testGB(7, gerdt93_ideal, gerdt93_gb_strat0_free7,
+ testGB(7, gerdt93IdealComponentFirst(false), gerdt93_gb_strat0_free7,
gerdt93_syzygies_strat0_free7, gerdt93_initial_strat0_free7, 9);
}
diff --git a/src/test/ideals.cpp b/src/test/ideals.cpp
index dbb8fb8..b2e6f68 100755
--- a/src/test/ideals.cpp
+++ b/src/test/ideals.cpp
@@ -1,6 +1,8 @@
#include "mathicgb/stdinc.h"
#include "test/ideals.hpp"
+#include <sstream>
+
const char* idealSmall =
"32003 6 \
1 1 1 1 1 1 1 \
@@ -148,13 +150,29 @@ const char* weispfennig97_syzygies_strat0_free5 =
const char* weispfennig97_initial_strat0_free5 =
" b4\n a2b2c\n a3b2\n a4d2\n b3c4\n ab3c3\n a2bc3d2\n a3c3d2\n ab3c2d2\n a3bc4\n a3bd5\n a2c5d2\n ab2c4d2\n a2b3d5\n b2c6d2\n abc6d2\n a2c4d5\n bc8d2\n ac6d5\n abc5d5\n bc7d5\n c9d5\n";
-const char* gerdt93_ideal =
+std::string gerdt93Ideal() {
+ return
"7583 6 1 1 1 1 1 1 1\n\
3\n\
ab-b2-4bc+ae\n\
a2c-6bc2+a2f\n\
a3+b2c-a2d\n\
";
+}
+
+std::string gerdt93IdealComponentFirst(bool componentIncreasing) {
+ std::ostringstream out;
+ out << "7583 6 ";
+ if (componentIncreasing)
+ out << "2 component 1 1 1 1 1 1\n";
+ else
+ out << "2 revcomponent 1 1 1 1 1 1\n";
+ out << "3\n"
+ " ab-b2-4bc+ae\n"
+ " a2c-6bc2+a2f\n"
+ " a3+b2c-a2d\n";
+ return out.str();
+}
const char* gerdt93_gb_strat0_free1 = "\
0 <0> ab-b2-4bc+ae\n\
diff --git a/src/test/ideals.hpp b/src/test/ideals.hpp
index 089ada9..d79a0cb 100755
--- a/src/test/ideals.hpp
+++ b/src/test/ideals.hpp
@@ -25,7 +25,8 @@ extern const char* weispfennig97_syzygies_strat0_free5;
extern const char* weispfennig97_initial_strat0_free5;
// gerdt93
-extern const char* gerdt93_ideal;
+std::string gerdt93Ideal();
+std::string gerdt93IdealComponentFirst(bool componentIncreasing);
extern const char* gerdt93_gb_strat0_free1;
extern const char* gerdt93_syzygies_strat0_free1;
diff --git a/src/test/poly-test.cpp b/src/test/poly-test.cpp
index 928d505..5bfc255 100755
--- a/src/test/poly-test.cpp
+++ b/src/test/poly-test.cpp
@@ -47,7 +47,7 @@ TEST(PolyRing, read) {
std::stringstream o;
std::string ringinfo = "32003 6\n1 1 1 1 1 1";
std::unique_ptr<PolyRing> R(ringFromString(ringinfo));
- R->write(o);
+ R->write(o, true);
EXPECT_EQ("32003 6\nrevlex 1\n 1 1 1 1 1 1\n", o.str());
}
--
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