[mathicgb] 257/393: Fixed an assert error by removing stuff out of PolyRing.
Doug Torrance
dtorrance-guest at moszumanska.debian.org
Fri Apr 3 15:59:14 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 dbe3b93f645083ba7a16fe31333d17055d59ca75
Author: Bjarke Hammersholt Roune <bjarkehr.code at gmail.com>
Date: Tue Apr 16 14:08:42 2013 -0400
Fixed an assert error by removing stuff out of PolyRing.
---
src/mathicgb/MonoMonoid.hpp | 23 ++++++++++++++++
src/mathicgb/PolyRing.cpp | 65 +++------------------------------------------
src/mathicgb/PolyRing.hpp | 22 ++-------------
src/test/poly-test.cpp | 23 ++++++++--------
4 files changed, 40 insertions(+), 93 deletions(-)
diff --git a/src/mathicgb/MonoMonoid.hpp b/src/mathicgb/MonoMonoid.hpp
index 5c17713..43d6f17 100755
--- a/src/mathicgb/MonoMonoid.hpp
+++ b/src/mathicgb/MonoMonoid.hpp
@@ -756,6 +756,29 @@ public:
MATHICGB_ASSERT(debugValid(quo));
}
+ // Set out to (colonBy : colonNum) * mult.
+ void colonMultiply(
+ ConstMonoRef colonBy,
+ ConstMonoRef colonNum,
+ ConstMonoRef mult,
+ MonoRef out
+ ) const {
+ // todo: consider what happens with exponent overflow here
+ if (HasComponent) {
+ MATHICGB_ASSERT(component(colonBy) == component(colonNum));
+ access(out, componentIndex()) = component(mult);
+ }
+ for (auto i = exponentsIndexBegin(); i != exponentsIndexEnd(); ++i) {
+ const auto colon = access(colonNum, i) - access(colonBy, i);
+ auto result = access(mult, i);
+ if (colon > 0)
+ result += colon;
+ access(out, i) = result;
+ }
+ setOrderData(out);
+ setHash(out);
+ }
+
/// Sets aColonB to a:b and bColonA to b:a.
void colons(
ConstMonoRef a,
diff --git a/src/mathicgb/PolyRing.cpp b/src/mathicgb/PolyRing.cpp
index 8a67e33..1e09955 100755
--- a/src/mathicgb/PolyRing.cpp
+++ b/src/mathicgb/PolyRing.cpp
@@ -22,23 +22,17 @@ PolyRing::PolyRing(
):
mCharac(p0),
mNumVars(nvars),
- mNumWeights(1),
+ mNumWeights(nvars == 0 ? 0 : weights.size() / nvars),
mTopIndex(nvars + mNumWeights),
mHashIndex(nvars + mNumWeights + 1),
mMaxMonomialSize(nvars + mNumWeights + 2),
mMaxMonomialByteSize(mMaxMonomialSize * sizeof(exponent)),
mMonomialPool(mMaxMonomialByteSize),
- mTotalDegreeGradedOnly(false),
mMonoid(nvars, weights),
mField(p0)
{
- MATHICGB_ASSERT(weights.size() == nvars);
- mTotalDegreeGradedOnly = true;
- for (size_t i = 0; i < nvars; ++i)
- if (weights[i] != 1)
- mTotalDegreeGradedOnly = false;
- mWeights.resize(nvars);
- for (size_t i = 0; i < nvars; ++i)
+ mWeights.resize(weights.size());
+ for (size_t i = 0; i < weights.size(); ++i)
mWeights[i] = -weights[i];
resetCoefficientStats();
@@ -58,7 +52,6 @@ PolyRing::PolyRing(coefficient p0,
mMaxMonomialSize(nvars + nweights + 2),
mMaxMonomialByteSize(mMaxMonomialSize * sizeof(exponent)),
mMonomialPool(mMaxMonomialByteSize),
- mTotalDegreeGradedOnly(nweights == 1),
mMonoid(nvars),
mField(p0)
{
@@ -100,21 +93,6 @@ void PolyRing::setWeightsAndHash(Monomial& a1) const
setHashOnly(a1);
}
-bool PolyRing::weightsCorrect(ConstMonomial a1) const
-{
- exponent const *a = a1.mValue;
- ++a;
- auto wts = &mWeights[0];
- for (size_t i = 0; i < mNumWeights; ++i) {
- exponent result = 0;
- for (size_t j = 0; j < mNumVars; ++j)
- result += *wts++ * a[j];
- if (a[mNumVars + i] != result)
- return false;
- }
- return true;
-}
-
int PolyRing::monomialCompare(ConstMonomial sig, ConstMonomial m2, ConstMonomial sig2) const
// returns LT, EQ, or GT, depending on sig ? (m2 * sig2).
{
@@ -175,32 +153,7 @@ void PolyRing::monomialFindSignature(ConstMonomial v1,
ConstMonomial u1,
Monomial& t1) const
{
- // t1 := (v2:v1) u1
- *t1 = *u1.mValue;
- if (mTotalDegreeGradedOnly) {
- MATHICGB_ASSERT(mNumWeights == 1);
- exponent weight = 0;
- for (size_t i = 1; i <= mNumVars; ++i) {
- MATHICGB_ASSERT(mWeights[i - 1] == -1);
- if (v1[i] < v2[i])
- weight -= t1[i] = u1[i] + v2[i] - v1[i];
- else
- weight -= t1[i] = u1[i];
- }
-#ifdef MATHICGB_DEBUG
- setWeightsOnly(t1);
- MATHICGB_ASSERT(t1[mNumVars + 1] == weight);
-#endif
- t1[mNumVars + 1] = weight;
- } else {
- for (size_t i = 1; i <= mNumVars; ++i) {
- if (v1[i] < v2[i])
- t1[i] = u1[i] + v2[i] - v1[i];
- else
- t1[i] = u1[i];
- }
- setWeightsOnly(t1);
- }
+ monoid().colonMultiply(v1, v2, u1, t1);
}
size_t PolyRing::monomialSizeOfSupport(ConstMonomial m) const
@@ -212,16 +165,6 @@ size_t PolyRing::monomialSizeOfSupport(ConstMonomial m) const
return support;
}
-void PolyRing::monomialGreatestCommonDivisor(ConstMonomial a,
- ConstMonomial b,
- Monomial& g) const
-{
- *g = 0;
- for (size_t i = 1; i <= mNumVars; ++i)
- g[i] = std::min(a[i], b[i]);
- setWeightsOnly(g);
-}
-
void PolyRing::mysteriousSPairMonomialRoutine(ConstMonomial newSig,
ConstMonomial newLead,
ConstMonomial baseDivSig,
diff --git a/src/mathicgb/PolyRing.hpp b/src/mathicgb/PolyRing.hpp
index a192659..84c3fea 100755
--- a/src/mathicgb/PolyRing.hpp
+++ b/src/mathicgb/PolyRing.hpp
@@ -353,8 +353,6 @@ public:
bool hashValid(const_monomial m) const;
- bool weightsCorrect(ConstMonomial a) const;
-
// returns LT, EQ, or GT, depending on sig ? (m2 * sig2).
int monomialCompare(ConstMonomial a,
ConstMonomial b) const;
@@ -449,10 +447,6 @@ public:
size_t monomialSizeOfSupport(ConstMonomial m) const;
- void monomialGreatestCommonDivisor(ConstMonomial a,
- ConstMonomial b,
- Monomial& g) const;
-
inline void monomialLeastCommonMultiple(ConstMonomial a,
ConstMonomial b,
Monomial& l) const;
@@ -516,8 +510,6 @@ private:
mutable memt::BufferPool mMonomialPool;
mutable coefficientStats mStats;
- bool mTotalDegreeGradedOnly;
-
Monoid mMonoid;
Field mField;
};
@@ -577,16 +569,7 @@ inline void PolyRing::monomialMult(ConstMonomial a,
inline void PolyRing::setWeightsOnly(Monomial& a1) const
{
- exponent *a = a1.unsafeGetRepresentation();
- a++;
- auto wts = mWeights.data();
- for (size_t i = 0; i < mNumWeights; ++i)
- {
- exponent result = 0;
- for (size_t j = 0; j < mNumVars; ++j)
- result += *wts++ * a[j];
- a[mNumVars+i] = result;
- }
+ monoid().setOrderData(a1);
}
inline HashValue PolyRing::computeHashValue(const_monomial a1) const {
@@ -595,8 +578,7 @@ inline HashValue PolyRing::computeHashValue(const_monomial a1) const {
inline void PolyRing::setHashOnly(Monomial& a1) const
{
- exponent* a = a1.unsafeGetRepresentation();
- a[mHashIndex] = computeHashValue(a1);
+ monoid().setHash(a1);
}
inline int PolyRing::monomialCompare(ConstMonomial a, ConstMonomial b) const
diff --git a/src/test/poly-test.cpp b/src/test/poly-test.cpp
index 0795583..9fc1863 100755
--- a/src/test/poly-test.cpp
+++ b/src/test/poly-test.cpp
@@ -234,12 +234,9 @@ void testMonomialOps(const PolyRing* R, std::string s1, std::string s2)
Monomial m2 = stringToMonomial(R, s2);
Monomial m3 = stringToMonomial(R, "abcdef<0>");
- // m1 * m2 == lcm(m1,m2) * gcd(m1,m2)
-
+
Monomial m4 = R->allocMonomial();
Monomial lcm = R->allocMonomial();
- Monomial gcd = R->allocMonomial();
- Monomial m7 = R->allocMonomial();
Monomial m8 = R->allocMonomial();
Monomial m1a = R->allocMonomial();
Monomial m2a = R->allocMonomial();
@@ -248,10 +245,6 @@ void testMonomialOps(const PolyRing* R, std::string s1, std::string s2)
R->monomialMult(m1,m2,m4);
R->monomialLeastCommonMultiple(m1,m2,lcm);
- R->monomialGreatestCommonDivisor(m1,m2,gcd);
-
- R->monomialMult(lcm,gcd,m7);
- EXPECT_TRUE(R->monomialEQ(m4, m7));
// lcm(m1,m2)/m1, lcm(m1,m2)/m2: relatively prime
EXPECT_TRUE(R->monomialIsDivisibleBy(lcm, m1));
@@ -267,9 +260,6 @@ void testMonomialOps(const PolyRing* R, std::string s1, std::string s2)
EXPECT_TRUE(R->monomialEQ(m1, m1b));
EXPECT_TRUE(R->monomialEQ(m2, m2b));
- EXPECT_TRUE(R->monomialIsDivisibleBy(lcm,gcd));
- R->monomialDivide(lcm,gcd,m8);
-
size_t supp1 = R->monomialSizeOfSupport(m1a);
size_t supp2 = R->monomialSizeOfSupport(m2a);
size_t supp = R->monomialSizeOfSupport(m8);
@@ -615,9 +605,18 @@ bool test_find_signatures(const PolyRing *R,
monomial y2 = new int[R->maxMonomialSize()];
monomial v1v2 = new int[R->maxMonomialSize()];
monomial x1g = new int[R->maxMonomialSize()];
+ monomial p = new int[R->maxMonomialSize()];
+ monomial m = new int[R->maxMonomialSize()];
+
+
R->monomialFindSignature(v1,v2,u1,t1);
R->monomialFindSignature(v2,v1,u2,t2);
- R->monomialGreatestCommonDivisor(v1, v2, g);
+
+ R->monomialMult(v1, v2, p);
+ R->monomialLeastCommonMultiple(v1, v2, m);
+ R->monomialDivide(p, m, g);
+ //R->monomialGreatestCommonDivisor(v1, v2, g);
+
// check that v1*t1 == v2*t2
// v1*v2 == g * (v1*t1)
R->monomialDivide(t1,u1,y1);
--
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