[mathicgb] 209/393: Added division and divisibility code to MonoMonoid along with tests.

[Doug Torrance]

This is an automated email from the git hooks/post-receive script.

dtorrance-guest pushed a commit to branch upstream
in repository mathicgb.

commit 5211880cf477782a103235ae911ced5c986ea1e7
Author: Bjarke Hammersholt Roune <bjarkehr.code at gmail.com>
Date:   Fri Mar 29 14:30:49 2013 +0100

    Added division and divisibility code to MonoMonoid along with tests.
---
 src/mathicgb/MonoMonoid.hpp | 40 ++++++++++++++++++++++++++++
 src/test/MonoMonoid.cpp     | 64 ++++++++++++++++++++++++++++++++++-----------
 2 files changed, 89 insertions(+), 15 deletions(-)

diff --git a/src/mathicgb/MonoMonoid.hpp b/src/mathicgb/MonoMonoid.hpp
index 0ccaa02..db7182d 100755
--- a/src/mathicgb/MonoMonoid.hpp
+++ b/src/mathicgb/MonoMonoid.hpp
@@ -167,6 +167,14 @@ public:
     return std::all_of(begin(mono), end(mono), [](Exponent e) {return e == 0;});
   }
 
+  /// Returns true if a divides b. Equal monomials divide each other.
+  bool divides(ConstMonoRef a, ConstMonoRef b) const {
+    for (auto var = 0; var < varCount(); ++var)
+      if (exponent(a, var) > exponent(b, var))
+	return false;
+    return true;
+  }
+
   // Graded reverse lexicographic order. The grading is total degree.
   CompareResult compare(ConstMonoRef a, ConstMonoRef b) const {
     MATHICGB_ASSERT(debugOrderValid(a));
@@ -234,6 +242,38 @@ public:
     MATHICGB_ASSERT(debugValid(prod));
   }
 
+  void multiplyInPlace(ConstMonoRef a, MonoRef prod) const {
+    MATHICGB_ASSERT(debugValid(a));
+    MATHICGB_ASSERT(debugValid(prod));
+
+    for (auto i = 0; i < entryCount(); ++i)
+      access(prod, i) += access(a, i);
+
+    MATHICGB_ASSERT(debugValid(prod));      
+  }
+
+  void divide(ConstMonoRef by, ConstMonoRef num, MonoRef quo) const {
+    MATHICGB_ASSERT(divides(by, num));
+    MATHICGB_ASSERT(debugValid(num));
+    MATHICGB_ASSERT(debugValid(by));
+
+    for (auto i = 0; i < entryCount(); ++i)
+      access(quo, i) = access(num, i) - access(by, i);
+
+    MATHICGB_ASSERT(debugValid(quo));
+  }
+
+  void divideInPlace(ConstMonoRef by, MonoRef num) const {
+    MATHICGB_ASSERT(divides(by, num));
+    MATHICGB_ASSERT(debugValid(by));
+    MATHICGB_ASSERT(debugValid(num));
+
+    for (auto i = 0; i < entryCount(); ++i)
+      access(num, i) -= access(by, i);
+
+    MATHICGB_ASSERT(debugValid(num));
+  }
+
   /// Parses a monomial out of a string. Valid examples: 1 abc a2bc
   /// aA. Variable names are case sensitive. Whitespace terminates the
   /// parse as does any other character that is not a letter or a
diff --git a/src/test/MonoMonoid.cpp b/src/test/MonoMonoid.cpp
index 3d3f024..ee167dc 100755
--- a/src/test/MonoMonoid.cpp
+++ b/src/test/MonoMonoid.cpp
@@ -308,12 +308,12 @@ TEST(MonoMonoid, ParsePrintM2) {
   ASSERT_EQ(v, v2);
 }
 
-TEST(MonoMonoid, Product) {
+TEST(MonoMonoid, MultiplyDivide) {
   typedef MonoMonoid<int32> Monoid;
   Monoid m(49);
   Monoid::MonoPool pool(m);
   auto mono = pool.alloc();
-  auto checkProd = [&](const char* str) {
+  auto check = [&](const char* str) {
     auto v = parseVector(m, str);
     MATHICGB_ASSERT(v.size() == 3);
     const auto& a = v.front();
@@ -322,34 +322,68 @@ TEST(MonoMonoid, Product) {
     ASSERT_EQ(m.hashOfProduct(a, b), m.hash(c));
     ASSERT_EQ(m.hashOfProduct(a, b), m.hashOfProduct(b, a));
 
+    // a*b == c using multiply
     m.multiply(a, b, mono);
     ASSERT_TRUE(m.equal(c, mono));
     ASSERT_TRUE(m.compare(c, mono) == Monoid::EqualTo);
     ASSERT_EQ(m.hash(c), m.hash(mono));
 
-    m.multiply(b, a, mono);
+    // c/a == b using divide
+    m.divide(a, c, mono);
+    ASSERT_TRUE(m.equal(b, mono));
+    ASSERT_TRUE(m.compare(b, mono) == Monoid::EqualTo);
+    ASSERT_EQ(m.hash(b), m.hash(mono));
+
+    // c/b == a using divideInPlace
+    m.copy(c, mono);
+    m.divideInPlace(b, mono);
+    ASSERT_TRUE(m.equal(a, mono));
+    ASSERT_TRUE(m.compare(a, mono) == Monoid::EqualTo);
+    ASSERT_EQ(m.hash(a), m.hash(mono));
+
+    // a*b == c using multiplyInPlace
+    m.copy(a, mono);
+    m.multiplyInPlace(b, mono);
     ASSERT_TRUE(m.equal(c, mono));
     ASSERT_TRUE(m.compare(c, mono) == Monoid::EqualTo);
     ASSERT_EQ(m.hash(c), m.hash(mono));
 
-    if (!m.isIdentity(a))
+    // check properties that mono=a*b should have
+    ASSERT_TRUE(m.divides(mono, c));
+    ASSERT_TRUE(m.divides(c, mono));
+    ASSERT_TRUE(m.divides(a, mono));
+    ASSERT_TRUE(m.divides(b, mono));
+
+    if (!m.isIdentity(a)) {
       ASSERT_TRUE(m.lessThan(b, mono));
-    else
+      ASSERT_FALSE(m.lessThan(mono, b));
+      ASSERT_TRUE(m.compare(mono, b) == Monoid::GreaterThan);
+      ASSERT_FALSE(m.divides(mono, b));
+    } else {
+      ASSERT_TRUE(m.equal(b, mono));
       ASSERT_TRUE(m.compare(b, mono) == Monoid::EqualTo);
+      ASSERT_TRUE(m.divides(mono, b));
+    }
 
-    if (!m.isIdentity(b))
+    if (!m.isIdentity(b)) {
       ASSERT_TRUE(m.lessThan(a, mono));
-    else
+      ASSERT_FALSE(m.lessThan(mono, a));
+      ASSERT_TRUE(m.compare(mono, a) == Monoid::GreaterThan);
+      ASSERT_FALSE(m.divides(mono, a));
+    } else {
+      ASSERT_TRUE(m.equal(a, mono));
       ASSERT_TRUE(m.compare(a, mono) == Monoid::EqualTo);
+      ASSERT_TRUE(m.divides(mono, a));
+    }
   };
-  checkProd("1 1 1");
-  checkProd("a 1 a");
-  checkProd("1 Vx Vx");
-  checkProd("aV bx abxV");
-  checkProd("a a2 a3");
-  checkProd("V V2 V3");
-  checkProd("arlgh svug arlg2hsvu");
-  checkProd("abcdefghiV ab2c3d4e5f6g7h8i9V11 a2b3c4d5e6f7g8h9i10V12");
+  check("1 1 1");
+  check("a 1 a");
+  check("1 Vx Vx");
+  check("aV bx abxV");
+  check("a a2 a3");
+  check("V V2 V3");
+  check("arlgh svug arlg2hsvu");
+  check("abcdefghiV ab2c3d4e5f6g7h8i9V11 a2b3c4d5e6f7g8h9i10V12");
 }
 
 TEST(MonoMonoid, Order) {

-- 
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/debian-science/packages/mathicgb.git