[mathicgb] 208/393: Minor cleanup to MonoMonoid and added product 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 f6e9bbbd3aefa4984fad3422840580626022c03a
Author: Bjarke Hammersholt Roune <bjarkehr.code at gmail.com>
Date:   Fri Mar 29 13:39:27 2013 +0100

    Minor cleanup to MonoMonoid and added product along with tests.
---
 src/mathicgb/MonoMonoid.hpp | 49 ++++++++++++++++++++++-----------------------
 src/test/MonoMonoid.cpp     | 46 +++++++++++++++++++++++++++++++++++++++++-
 2 files changed, 69 insertions(+), 26 deletions(-)

diff --git a/src/mathicgb/MonoMonoid.hpp b/src/mathicgb/MonoMonoid.hpp
index bb3a14a..0ccaa02 100755
--- a/src/mathicgb/MonoMonoid.hpp
+++ b/src/mathicgb/MonoMonoid.hpp
@@ -17,15 +17,6 @@
 /// TODO: support grading and comparison.
 template<class E>
 class MonoMonoid {
-private:
-  friend class Mono;
-  friend class MonoRef;
-  friend class ConstMonoRef;
-  friend class MonoPtr;
-  friend class ConstMonoPtr;
-  friend class MonoVector;
-  friend class MonoPool;
-
 public:
   static_assert(std::numeric_limits<E>::is_signed, "");
 
@@ -157,6 +148,10 @@ public:
     return static_cast<HashValue>(access(mono, hashIndex()));
   }
 
+  bool equal(ConstMonoRef a, ConstMonoRef b) const {
+    return std::equal(begin(a), end(a), begin(b));
+  }
+
   /// Returns the hash of the product of a and b.
   HashValue hashOfProduct(ConstMonoRef a, ConstMonoRef b) const {
     // See computeHash() for an explanation of all the casts.
@@ -165,10 +160,6 @@ public:
     return static_cast<HashValue>(static_cast<Exponent>(hashA + hashB));
   }
 
-  bool equal(ConstMonoRef a, ConstMonoRef b) const {
-    return std::equal(begin(a), end(a), begin(b));
-  }
-
   /// Returns true if all the exponents of mono are zero. In other
   /// words, returns true if mono is the identity for multiplication
   /// of monomials.
@@ -232,6 +223,17 @@ public:
     MATHICGB_ASSERT(debugValid(mono));
   }
 
+  void multiply(ConstMonoRef a, ConstMonoRef b, MonoRef prod) const {
+    MATHICGB_ASSERT(debugValid(a));
+    MATHICGB_ASSERT(debugValid(b));
+
+    for (auto i = 0; i < entryCount(); ++i)
+      access(prod, i) = access(a, i) + access(b, i);
+
+    MATHICGB_ASSERT(hashOfProduct(a, b) == hash(prod));
+    MATHICGB_ASSERT(debugValid(prod));
+  }
+
   /// 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
@@ -344,9 +346,6 @@ public:
 
   private:
     friend class MonoMonoid;
-    friend class MonoVector;
-    friend class MonoPtr;
-    friend class ConstMonoRef;
 
     const Exponent* internalRawPtr() const {return mMono;}
     ConstMonoPtr(const Exponent* mono): mMono(mono) {}
@@ -356,10 +355,6 @@ public:
 
   class MonoPtr {
   public:
-    friend class Mono;
-    friend class MonoRef;
-    friend class MonoVector;
-    friend class MonoPool;
     MonoPtr(): mMono(0) {}
     MonoPtr(const MonoPtr& mono): mMono(mono.mMono) {}
     // todo: xxx
@@ -417,11 +412,9 @@ public:
     }
 
   private:
-    friend class MonoMonoid;
-
     Mono(const Mono&); // not available
     void operator=(const Mono&); // not available
-    friend class MonoPool;
+    friend class MonoMonoid;
 
     Mono(const MonoPtr mono, MonoPool& pool):
       mMono(mono), mPool(&pool) {}
@@ -441,7 +434,6 @@ public:
   private:
     void operator=(const MonoRef&); // not available
     friend class MonoMonoid;
-    friend class MonoPtr;
 
     MonoRef(MonoPtr mono): mMono(mono) {}
     Exponent* internalRawPtr() const {return rawPtr(mMono);}
@@ -460,7 +452,6 @@ public:
   private:
     void operator=(const MonoRef&); // not available
     friend class MonoMonoid;
-    friend class ConstMonoPtr;
 
     ConstMonoRef(ConstMonoPtr mono): mMono(mono) {}
     const Exponent* internalRawPtr() const {return rawPtr(mMono);}
@@ -672,6 +663,14 @@ public:
 
 
 private:
+  friend class Mono;
+  friend class MonoRef;
+  friend class ConstMonoRef;
+  friend class MonoPtr;
+  friend class ConstMonoPtr;
+  friend class MonoVector;
+  friend class MonoPool;
+
   bool debugValid(ConstMonoRef mono) const {
     MATHICGB_ASSERT(debugOrderValid(mono));
     MATHICGB_ASSERT(debugHashValid(mono));
diff --git a/src/test/MonoMonoid.cpp b/src/test/MonoMonoid.cpp
index 7d209e7..3d3f024 100755
--- a/src/test/MonoMonoid.cpp
+++ b/src/test/MonoMonoid.cpp
@@ -308,9 +308,53 @@ TEST(MonoMonoid, ParsePrintM2) {
   ASSERT_EQ(v, v2);
 }
 
+TEST(MonoMonoid, Product) {
+  typedef MonoMonoid<int32> Monoid;
+  Monoid m(49);
+  Monoid::MonoPool pool(m);
+  auto mono = pool.alloc();
+  auto checkProd = [&](const char* str) {
+    auto v = parseVector(m, str);
+    MATHICGB_ASSERT(v.size() == 3);
+    const auto& a = v.front();
+    const auto& b = *++v.begin();
+    const auto& c = v.back();
+    ASSERT_EQ(m.hashOfProduct(a, b), m.hash(c));
+    ASSERT_EQ(m.hashOfProduct(a, b), m.hashOfProduct(b, a));
+
+    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);
+    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))
+      ASSERT_TRUE(m.lessThan(b, mono));
+    else
+      ASSERT_TRUE(m.compare(b, mono) == Monoid::EqualTo);
+
+    if (!m.isIdentity(b))
+      ASSERT_TRUE(m.lessThan(a, mono));
+    else
+      ASSERT_TRUE(m.compare(a, mono) == Monoid::EqualTo);
+  };
+  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");
+}
+
 TEST(MonoMonoid, Order) {
   typedef MonoMonoid<int32> Monoid;
-  Monoid m(100);
+  Monoid m(52);
   auto v = parseVector(m, "1 Z A z c b a c2 bc ac b2 ab a2 c3 abc b3 a3");
 
   for (auto greater = v.begin(); greater != v.end(); ++greater) {

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