[mathicgb] 261/393: Moved support for reading in rings from PolyRing to MonoMonoid as well as other things moved there.
Doug Torrance
dtorrance-guest at moszumanska.debian.org
Fri Apr 3 15:59:15 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 d2913b2ef838f03585de9bf5d280edddfa3092ad
Author: Bjarke Hammersholt Roune <bjarkehr.code at gmail.com>
Date: Tue Apr 16 16:46:53 2013 -0400
Moved support for reading in rings from PolyRing to MonoMonoid as well as other things moved there.
---
src/mathicgb/MTArray.cpp | 2 -
src/mathicgb/MonoMonoid.hpp | 56 ++++++++++++++++++++-
src/mathicgb/PolyHashTable.cpp | 2 -
src/mathicgb/PolyRing.cpp | 110 ++++++++++-------------------------------
src/mathicgb/PolyRing.hpp | 16 ++----
5 files changed, 87 insertions(+), 99 deletions(-)
diff --git a/src/mathicgb/MTArray.cpp b/src/mathicgb/MTArray.cpp
old mode 100644
new mode 100755
index 697abe0..cc409d2
--- a/src/mathicgb/MTArray.cpp
+++ b/src/mathicgb/MTArray.cpp
@@ -138,8 +138,6 @@ template <typename MT>
void MTArrayT<MT>::printFrobbyM2Format
(std::ostream& out, size_t component) const
{
- R->printRingFrobbyM2Format(out);
-
MATHICGB_ASSERT(component < tables.size());
T* p = tables[component];
MATHICGB_ASSERT(p != 0);
diff --git a/src/mathicgb/MonoMonoid.hpp b/src/mathicgb/MonoMonoid.hpp
index dd8ca36..13bc62b 100755
--- a/src/mathicgb/MonoMonoid.hpp
+++ b/src/mathicgb/MonoMonoid.hpp
@@ -232,6 +232,9 @@ public:
MATHICGB_ASSERT(debugAssertValid());
}
+ static MonoMonoid readMonoid(std::istream& in);
+ void printMonoid(std::ostream& out) const;
+
bool operator==(const MonoMonoid& monoid) const {
return this == &monoid;
}
@@ -757,7 +760,8 @@ public:
MATHICGB_ASSERT(debugValid(quo));
}
- // Set out to (colonBy : colonNum) * mult.
+ /// Set out to (colonBy : colonNum) * mult.
+ /// @todo: test
void colonMultiply(
ConstMonoRef colonBy,
ConstMonoRef colonNum,
@@ -780,6 +784,16 @@ public:
setHash(out);
}
+ /// Returns the number of variables that divide mono.
+ /// @todo: test
+ VarIndex sizeOfSupport(ConstMonoRef mono) const {
+ VarIndex count = 0;
+ for (VarIndex var = 0; var < varCount(); ++var)
+ if (exponent(mono, var) != 0)
+ ++count;
+ return count;
+ }
+
/// Sets aColonB to a:b and bColonA to b:a.
void colons(
ConstMonoRef a,
@@ -1542,6 +1556,46 @@ namespace MonoMonoidHelper {
}
template<class E, bool HC, bool SH, bool SO>
+auto MonoMonoid<E, HC, SH, SO>::readMonoid(std::istream& in) -> MonoMonoid {
+ using MonoMonoidHelper::unchar;
+ VarIndex varCount;
+ in >> varCount;
+
+ 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);
+ }
+ return MonoMonoid(varCount, gradings);
+}
+
+template<class E, bool HC, bool SH, bool SO>
+void MonoMonoid<E, HC, SH, SO>::printMonoid(std::ostream& out) const {
+ out << varCount() << ' ' << gradingCount() << '\n';
+ if (mGradingIsTotalDegree) {
+ MATHICGB_ASSERT(mGradings.empty());
+ for (VarIndex var = 0; var < varCount(); ++var)
+ out << " 1";
+ out << '\n';
+ } else {
+ MATHICGB_ASSERT(mGradings.size() == gradingCount() * varCount());
+ for (VarIndex grading = 0; grading < gradingCount(); ++grading) {
+ const auto offset = static_cast<size_t>(grading) * varCount();
+ for (VarIndex var = 0; var < varCount(); ++var) {
+ MATHICGB_ASSERT(offset + var < mGradings.size());
+ out << ' ' << mGradings[offset + var];
+ }
+ out << '\n';
+ }
+ }
+}
+
+template<class E, bool HC, bool SH, bool SO>
void MonoMonoid<E, HC, SH, SO>::parseM2(std::istream& in, MonoRef mono) const {
using MonoMonoidHelper::unchar;
// todo: signal error on exponent overflow
diff --git a/src/mathicgb/PolyHashTable.cpp b/src/mathicgb/PolyHashTable.cpp
index 2083995..075ea25 100755
--- a/src/mathicgb/PolyHashTable.cpp
+++ b/src/mathicgb/PolyHashTable.cpp
@@ -400,8 +400,6 @@ void PolyHashTable::dump(int level) const
value << "\n";
extra << "\n";
- mRing.displayHashValues();
-
name << "# resets:\n";
value << mic::ColumnPrinter::commafy(mStats.n_resets) << '\n';
extra << '\n';
diff --git a/src/mathicgb/PolyRing.cpp b/src/mathicgb/PolyRing.cpp
index 1e09955..1d423b9 100755
--- a/src/mathicgb/PolyRing.cpp
+++ b/src/mathicgb/PolyRing.cpp
@@ -15,13 +15,25 @@ bool PolyRing::hashValid(const_monomial m) const {
return monomialHashValue(m) == computeHashValue(m);
}
+PolyRing::PolyRing(const Field& field, const Monoid& monoid):
+ mCharac(field.charac()),
+ mNumWeights(monoid.gradingCount()),
+ mTopIndex(monoid.varCount() + mNumWeights),
+ mHashIndex(monoid.varCount() + mNumWeights + 1),
+ mMaxMonomialSize(monoid.varCount() + mNumWeights + 2),
+ mMaxMonomialByteSize(mMaxMonomialSize * sizeof(exponent)),
+ mMonomialPool(mMaxMonomialByteSize),
+ mMonoid(monoid),
+ mField(field)
+{
+}
+
PolyRing::PolyRing(
coefficient p0,
int nvars,
const std::vector<exponent>& weights
):
mCharac(p0),
- mNumVars(nvars),
mNumWeights(nvars == 0 ? 0 : weights.size() / nvars),
mTopIndex(nvars + mNumWeights),
mHashIndex(nvars + mNumWeights + 1),
@@ -31,21 +43,12 @@ PolyRing::PolyRing(
mMonoid(nvars, weights),
mField(p0)
{
- mWeights.resize(weights.size());
- for (size_t i = 0; i < weights.size(); ++i)
- mWeights[i] = -weights[i];
-
- resetCoefficientStats();
- srand(0);
- for (size_t i=0; i<mNumVars; i++)
- mHashVals.push_back(static_cast<HashValue>(rand()));
}
PolyRing::PolyRing(coefficient p0,
int nvars,
int nweights)
: mCharac(p0),
- mNumVars(nvars),
mNumWeights(nweights),
mTopIndex(nvars + nweights),
mHashIndex(nvars + nweights + 1),
@@ -55,23 +58,6 @@ PolyRing::PolyRing(coefficient p0,
mMonoid(nvars),
mField(p0)
{
- MATHICGB_ASSERT(nweights == 1);
-
- // set weights to the default value -1
- mWeights.resize(mNumVars * mNumWeights);
- std::fill(mWeights.begin(), mWeights.end(), static_cast<exponent>(-1));
-
- resetCoefficientStats();
- srand(0);
- for (size_t i=0; i<mNumVars; i++)
- mHashVals.push_back(static_cast<HashValue>(rand()));
-}
-
-void PolyRing::displayHashValues() const
-{
- std::cerr << "hash values: " << std::endl;
- for (size_t i=0; i<mNumVars; i++)
- std::cerr << " " << mHashVals[i] << std::endl;
}
void PolyRing::resetCoefficientStats() const
@@ -107,17 +93,13 @@ int PolyRing::monomialCompare(ConstMonomial sig, ConstMonomial m2, ConstMonomial
void PolyRing::monomialSetIdentity(Monomial& result) const
{
- for (size_t i = 0; i <= mTopIndex; ++i)
- result[i] = 0;
- result[mHashIndex] = static_cast<HashValue>(0);
+ monoid().setIdentity(result);
}
void PolyRing::monomialEi(size_t i, Monomial &result) const
{
- for (size_t j=mTopIndex; j != static_cast<size_t>(-1); --j)
- result[j] = 0;
- *result = static_cast<exponent>(i); // todo: handle overflow or change representation
- result[mHashIndex] = static_cast<HashValue>(i); // todo: handle overflow or change representation
+ monoid().setIdentity(result);
+ monoid().setComponent(i, result);
}
void PolyRing::monomialMultTo(Monomial &a, ConstMonomial b) const
@@ -129,8 +111,7 @@ void PolyRing::monomialMultTo(Monomial &a, ConstMonomial b) const
void PolyRing::monomialCopy(ConstMonomial a,
Monomial& result) const
{
- for (size_t i = mHashIndex; i != static_cast<size_t>(-1); --i)
- result[i] = a[i];
+ monoid().copy(a, result);
}
void PolyRing::monomialQuotientAndMult(ConstMonomial a,
@@ -138,14 +119,7 @@ void PolyRing::monomialQuotientAndMult(ConstMonomial a,
ConstMonomial c,
Monomial& result) const
{
- // result is set to (a:b) * c. It is not assumed that b divides a.
- for (size_t i = 0; i <= mNumVars; ++i)
- {
- result[i] = c[i];
- auto cmp = a[i] - b[i];
- if (cmp > 0) result[i] += cmp;
- }
- setWeightsAndHash(result);
+ monoid().colonMultiply(b, a, c, result);
}
void PolyRing::monomialFindSignature(ConstMonomial v1,
@@ -158,11 +132,7 @@ void PolyRing::monomialFindSignature(ConstMonomial v1,
size_t PolyRing::monomialSizeOfSupport(ConstMonomial m) const
{
- size_t support = 0;
- for (size_t i = 1; i <= mNumVars; ++i)
- if (m[i] != 0)
- ++support;
- return support;
+ return monoid().sizeOfSupport(m);
}
void PolyRing::mysteriousSPairMonomialRoutine(ConstMonomial newSig,
@@ -172,8 +142,7 @@ void PolyRing::mysteriousSPairMonomialRoutine(ConstMonomial newSig,
Monomial result) const
{
result[0] = 0; // set component
-
- for (size_t i = 1; i <= mNumVars; ++i) {
+ for (size_t i = 1; i <= varCount(); ++i) {
exponent x = newSig[i] - baseDivSig[i] + baseDivLead[i];
if (newLead[i] <= x)
x = std::numeric_limits<exponent>::max();
@@ -189,6 +158,7 @@ void PolyRing::mysteriousSPairMonomialRoutine(ConstMonomial newSig,
void PolyRing::monomialParse(std::istream &i,
Monomial& result) const
{
+// monoid().parseM2(i, result);
// first initialize result:
for (size_t j=0; j<mMaxMonomialSize; j++) result[j] = 0;
@@ -238,7 +208,7 @@ void PolyRing::monomialDisplay(std::ostream &o,
// print_one: only is consulted in print_comp is false.
bool printed_any = false;
- for (size_t i=0; i<mNumVars; i++) {
+ for (size_t i=0; i< varCount(); i++) {
if (a[i+1] != 0) {
printed_any = true;
if (i <= 25)
@@ -263,7 +233,7 @@ void PolyRing::monomialDisplay(FILE* file,
const unsigned int letterCount = 26;
MATHICGB_ASSERT(getNumVars() <= 2 * letterCount);
bool printedAny = false;
- for (size_t var = 0; var < mNumVars; ++var) {
+ for (size_t var = 0; var < varCount(); ++var) {
exponent e = monomialExponent(mono, var);
if (e == 0)
continue;
@@ -286,7 +256,7 @@ void PolyRing::monomialDisplay(FILE* file,
void PolyRing::printMonomialFrobbyM2Format(std::ostream& out, ConstMonomial m) const {
out << " ";
bool isOne = true;
- for (size_t i = 0; i < mNumVars; ++i) {
+ for (size_t i = 0; i < varCount(); ++i) {
const auto e = m[i + 1];
if (e == 0)
continue;
@@ -300,45 +270,19 @@ void PolyRing::printMonomialFrobbyM2Format(std::ostream& out, ConstMonomial m) c
out << '1';
}
-void PolyRing::printRingFrobbyM2Format(std::ostream& out) const {
- out << "R = QQ[";
- for (size_t i = 0; i < mNumVars; ++i)
- out << (i == 0 ? "" : ", ") << 'x' << (i + 1);
- out << "];\n";
-}
-
PolyRing *PolyRing::read(std::istream &i)
{
int64 characInt;
coefficient charac;
- int mNumVars, mNumWeights;
-
i >> characInt;
charac = static_cast<exponent>(characInt);
- i >> mNumVars;
- i >> mNumWeights;
- MATHICGB_ASSERT(mNumWeights == 1);
-
- std::vector<exponent> weights(mNumWeights);
- int wtlen = mNumVars * mNumWeights;
- weights.resize(wtlen);
- for (int j=0; j < mNumVars * mNumWeights; j++) {
- int64 aInt;
- i >> aInt;
- weights[j] = static_cast<exponent>(aInt);
- }
- return new PolyRing(charac, mNumVars, weights);
+ return new PolyRing(charac, Monoid::readMonoid(i));
}
void PolyRing::write(std::ostream &o) const
{
- o << mCharac << " " << mNumVars << " " << mNumWeights << std::endl;
- auto wts = &mWeights[0];
- for (size_t i = 0; i < mNumWeights; ++i) {
- for (size_t j = 0; j < mNumVars; ++j)
- o << " " << - *wts++;
- o << std::endl;
- }
+ o << charac() << ' ';
+ monoid().printMonoid(o);
}
// Local Variables:
diff --git a/src/mathicgb/PolyRing.hpp b/src/mathicgb/PolyRing.hpp
index 84c3fea..c523b0d 100755
--- a/src/mathicgb/PolyRing.hpp
+++ b/src/mathicgb/PolyRing.hpp
@@ -202,6 +202,7 @@ public:
PolyRing(coefficient charac, int nvars, const std::vector<exponent>& weights);
PolyRing(coefficient charac, int nvars, int nweights);
+ PolyRing(const Field& field, const Monoid& monoid);
~PolyRing() {}
size_t getMemoryUse() const {
@@ -210,7 +211,8 @@ public:
}
coefficient charac() const { return mCharac; }
- size_t getNumVars() const { return mNumVars; }
+ size_t getNumVars() const { return varCount();}
+ size_t varCount() const {return monoid().varCount();}
// const std::vector<int> °s,
// const std::string &monorder);
@@ -219,8 +221,6 @@ public:
// Format for ring
// <char> <mNumVars> <deg1> ... <deg_n> <monorder>
- void printRingFrobbyM2Format(std::ostream& out) const;
-
// Allocate a monomial from an arena A
// This monomial may only be freed if no other elements that were allocated
// later are live on A. In this case, use freeMonomial(A,m) to free 'm'.
@@ -309,8 +309,6 @@ public:
size_t maxMonomialSize() const { return mMaxMonomialSize; }
- void displayHashValues() const;
-
size_t monomialHashIndex() const { return mHashIndex; }
///////////////////////////////////////////
@@ -423,9 +421,7 @@ public:
/// Returns the hash of the product of a and b.
HashValue monomialHashOfProduct(ConstMonomial a, ConstMonomial b) const {
- return static_cast<exponent>(
- static_cast<HashValue>(a[mHashIndex]) +
- static_cast<HashValue>(b[mHashIndex]));
+ return monoid().hashOfProduct(a, b);
}
void monomialCopy(ConstMonomial a, Monomial &result) const;
@@ -496,13 +492,11 @@ private:
inline HashValue computeHashValue(const_monomial a1) const;
coefficient mCharac; // p=mCharac: ring is ZZ/p
- size_t mNumVars;
- size_t mNumWeights; // stored as negative of weight vectors
+ size_t mNumWeights;
size_t mTopIndex;
size_t mHashIndex; // 1 more than mTopIndex. Where the has value is stored.
size_t mMaxMonomialSize;
size_t mMaxMonomialByteSize;
- std::vector<exponent> mWeights; // 0..mNumWeights * mNumVars - 1.
std::vector<HashValue> mHashVals; // one for each variable 0..mNumVars-1
// stored as weightvec1 weightvec2 ...
--
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