From 71e77b8c879b5884cc19eb3229c377b34f74b91d Mon Sep 17 00:00:00 2001
From: dellaert <dellaert@cc.gatech.edu>
Date: Sat, 6 Dec 2014 10:58:16 +0100
Subject: [PATCH 1/7] Compiles

---
 gtsam/geometry/tests/testCyclic.cpp | 61 ++++++++++++++++++++++-------
 1 file changed, 47 insertions(+), 14 deletions(-)

diff --git a/gtsam/geometry/tests/testCyclic.cpp b/gtsam/geometry/tests/testCyclic.cpp
index f15654b2e..bdf0c3e98 100644
--- a/gtsam/geometry/tests/testCyclic.cpp
+++ b/gtsam/geometry/tests/testCyclic.cpp
@@ -10,8 +10,8 @@
  * -------------------------------------------------------------------------- */
 
 /**
- * @file   testCyclic.cpp
- * @brief  Unit tests for cyclic group
+ * @file   Cyclic.h
+ * @brief  Cyclic group, can act on 2D vector spaces
  * @author Frank Dellaert
  **/
 
@@ -22,17 +22,21 @@ namespace gtsam {
 
 template<size_t N>
 class Cyclic {
-  size_t i_;
+  size_t i_; ///< we just use an unsigned int
 public:
-  static const Cyclic Identity = Cyclic(0);
+  /// Constructor
   Cyclic(size_t i) :
       i_(i) {
   }
+  /// Cast to size_t
+  operator size_t() const {
+    return i_;
+  }
 };
 
 namespace traits {
 template<size_t N> struct identity<Cyclic<N> > {
-  static const Cyclic<N> value = Cyclic<N>::Identity;
+  static const Cyclic<N> value;
   typedef Cyclic<N> value_type;
 };
 template<size_t N> struct group_flavor<Cyclic<N> > {
@@ -42,6 +46,27 @@ template<size_t N> struct group_flavor<Cyclic<N> > {
 
 } // \namespace gtsam
 
+/**
+ * @file   Cyclic.cpp
+ * @brief  Cyclic group implementation
+ * @author Frank Dellaert
+ **/
+
+namespace gtsam {
+
+namespace traits {
+template<size_t N>
+const Cyclic<N> identity<Cyclic<N> >::value = Cyclic<N>(0);
+} // \namespace traits
+
+} // \namespace gtsam
+
+/**
+ * @file   testCyclic.cpp
+ * @brief  Unit tests for cyclic group
+ * @author Frank Dellaert
+ **/
+
 //#include <gtsam/geometry/Cyclic.h>
 #include <gtsam/base/Testable.h>
 #include <CppUnitLite/TestHarness.h>
@@ -49,19 +74,27 @@ template<size_t N> struct group_flavor<Cyclic<N> > {
 using namespace std;
 using namespace gtsam;
 
-BOOST_CONCEPT_ASSERT((GroupConcept<Cyclic<6> >));
+typedef Cyclic<6> G;
 
-/* ************************************************************************* */
-TEST(Cyclic, Constructor) {
-Cyclic<6> g(0);
+//******************************************************************************
+TEST(Cyclic, Concept) {
+  EXPECT_LONGS_EQUAL(0,traits::identity<G>::value);
+  //BOOST_CONCEPT_ASSERT((GroupConcept<Cyclic<6> >));
 //  EXPECT(assert_equal(p1, p2));
 //  EXPECT_LONGS_EQUAL(2,offset2.size());
 }
 
-/* ************************************************************************* */
-int main() {
-TestResult tr;
-return TestRegistry::runAllTests(tr);
+//******************************************************************************
+TEST(Cyclic, Constructor) {
+  G g(0);
+//  EXPECT(assert_equal(p1, p2));
+//  EXPECT_LONGS_EQUAL(2,offset2.size());
 }
-/* ************************************************************************* */
+
+//******************************************************************************
+int main() {
+  TestResult tr;
+  return TestRegistry::runAllTests(tr);
+}
+//******************************************************************************
 

From 07ef30039a5363fe43a617f9a36b18a4bab85d3f Mon Sep 17 00:00:00 2001
From: dellaert <dellaert@cc.gatech.edu>
Date: Sat, 6 Dec 2014 11:17:54 +0100
Subject: [PATCH 2/7] structure_tag works

---
 gtsam/base/concepts.h               | 55 +++++++++++++++++------------
 gtsam/geometry/tests/testCyclic.cpp | 13 ++++---
 2 files changed, 38 insertions(+), 30 deletions(-)

diff --git a/gtsam/base/concepts.h b/gtsam/base/concepts.h
index 967a91707..393bb69b1 100644
--- a/gtsam/base/concepts.h
+++ b/gtsam/base/concepts.h
@@ -24,7 +24,7 @@ namespace traits {
  */
 //@{
 template <class T>
-struct structure_category {}; // specializations should be derived from one of the following tags
+struct structure_category; // specializations should be derived from one of the following tags
 //@}
 
 /**
@@ -92,8 +92,8 @@ namespace traits {
 
 /** @name Group Traits */
 //@{
-template <class Group> struct identity {};
-template <class Group> struct group_flavor {};
+template <class Group> struct identity;
+template <class Group> struct group_flavor;
 //@}
 
 /** @name Group Flavor Tags */
@@ -104,41 +104,50 @@ struct multiplicative_group_tag {};
 
 } // namespace traits
 
+/**
+ * Group Concept
+ */
 template<class G>
-class GroupConcept {
- public:
-  typedef G Group;
-  static const Group identity = traits::identity<G>::value;
+class Group {
+public:
 
-  BOOST_CONCEPT_USAGE(GroupConcept) {
-    BOOST_STATIC_ASSERT(boost::is_base_of<traits::group_tag,typename traits::structure_category<Group>::type>::value );
-    Group ip = inverse(p);
-    Group pq = compose(p, q);
-    Group d = between(p, q);
-    test = equal(p, q);
-    test2 = operator_usage(p, q, traits::group_flavor<Group>::type);
+  typedef typename traits::identity<G>::value_type identity_value_type;
+  typedef typename traits::group_flavor<G>::type group_flavor_tag;
+  typedef typename traits::structure_category<G>::type structure_category_tag;
+
+  BOOST_CONCEPT_USAGE(Group) {
+    e = traits::identity<G>::value;
+//    BOOST_STATIC_ASSERT(boost::is_base_of<traits::group_tag,typename traits::structure_category<Group>::type>::value );
+//    G ip = inverse(p);
+//    G pq = compose(p, q);
+//    G d = between(p, q);
+//    test = equal(p, q);
+//    test2 = operator_usage(p, q, traits::group_flavor<Group>::type);
   }
 
-  bool check_invariants(const Group& a, const Group& b) {
-    return (equal(compose(a, inverse(a)), identity))
+  bool check_invariants(const G& a, const G& b) {
+    group_flavor_tag group_flavor;
+    return (equal(compose(a, inverse(a)), e))
         && (equal(between(a, b), compose(inverse(a), b)))
         && (equal(compose(a, between(a, b)), b))
-        && operator_usage(a, b, traits::group_flavor<Group>::type);
+        && operator_usage(a, b, group_flavor);
   }
 
- private:
-  Group p,q;
+private:
+  G p, q, e;
   bool test, test2;
 
-  bool operator_usage(const Group& a, const Group& b, const traits::multiplicative_group_tag&) {
-    return equal(compose(a, b), a*b);
+  bool operator_usage(const G& a, const G& b,
+      traits::multiplicative_group_tag) {
+    return equal(compose(a, b), a * b);
 
   }
-  bool operator_usage(const Group& a, const Group& b, const traits::additive_group_tag&) {
-    return equal(compose(a, b), a+b);
+  bool operator_usage(const G& a, const G& b, traits::additive_group_tag) {
+    return equal(compose(a, b), a + b);
   }
 
 };
+
 /*
 template <class L>
 class LieGroupConcept : public GroupConcept<L>, public ManifoldConcept<L> {
diff --git a/gtsam/geometry/tests/testCyclic.cpp b/gtsam/geometry/tests/testCyclic.cpp
index bdf0c3e98..8ea678a0f 100644
--- a/gtsam/geometry/tests/testCyclic.cpp
+++ b/gtsam/geometry/tests/testCyclic.cpp
@@ -11,7 +11,7 @@
 
 /**
  * @file   Cyclic.h
- * @brief  Cyclic group, can act on 2D vector spaces
+ * @brief  Cyclic group, i.e., the integers modulo N
  * @author Frank Dellaert
  **/
 
@@ -35,6 +35,9 @@ public:
 };
 
 namespace traits {
+template<size_t N> struct structure_category<Cyclic<N> > {
+  typedef group_tag type;
+};
 template<size_t N> struct identity<Cyclic<N> > {
   static const Cyclic<N> value;
   typedef Cyclic<N> value_type;
@@ -74,21 +77,17 @@ const Cyclic<N> identity<Cyclic<N> >::value = Cyclic<N>(0);
 using namespace std;
 using namespace gtsam;
 
-typedef Cyclic<6> G;
+typedef Cyclic<6> G; // Let's use the cyclic group of order 6
 
 //******************************************************************************
 TEST(Cyclic, Concept) {
   EXPECT_LONGS_EQUAL(0,traits::identity<G>::value);
-  //BOOST_CONCEPT_ASSERT((GroupConcept<Cyclic<6> >));
-//  EXPECT(assert_equal(p1, p2));
-//  EXPECT_LONGS_EQUAL(2,offset2.size());
+  BOOST_CONCEPT_ASSERT((Group<G>));
 }
 
 //******************************************************************************
 TEST(Cyclic, Constructor) {
   G g(0);
-//  EXPECT(assert_equal(p1, p2));
-//  EXPECT_LONGS_EQUAL(2,offset2.size());
 }
 
 //******************************************************************************

From ddeb7649121942ab803ce40cba3cf2ee3b17fedf Mon Sep 17 00:00:00 2001
From: dellaert <dellaert@cc.gatech.edu>
Date: Sat, 6 Dec 2014 11:37:14 +0100
Subject: [PATCH 3/7] group::traits, and group::compose

---
 gtsam/base/concepts.h               | 172 +++++++++++++++-------------
 gtsam/geometry/tests/testCyclic.cpp |  19 ++-
 2 files changed, 109 insertions(+), 82 deletions(-)

diff --git a/gtsam/base/concepts.h b/gtsam/base/concepts.h
index 393bb69b1..6910518da 100644
--- a/gtsam/base/concepts.h
+++ b/gtsam/base/concepts.h
@@ -23,8 +23,9 @@ namespace traits {
  * @brief Associate a unique tag with each of the main GTSAM concepts
  */
 //@{
-template <class T>
-struct structure_category; // specializations should be derived from one of the following tags
+template<class T>
+struct structure_category;
+// specializations should be derived from one of the following tags
 //@}
 
 /**
@@ -32,97 +33,111 @@ struct structure_category; // specializations should be derived from one of the
  * @brief Possible values for traits::structure_category<T>::type
  */
 //@{
-struct manifold_tag {};
-struct group_tag {};
-struct lie_group_tag : public manifold_tag, public group_tag {};
-struct vector_space_tag : public lie_group_tag {};
+struct manifold_tag {
+};
+struct group_tag {
+};
+struct lie_group_tag: public manifold_tag, public group_tag {
+};
+struct vector_space_tag: public lie_group_tag {
+};
 //@}
 
-} // namespace traits
+}// namespace traits
 
 namespace traits {
 
 /** @name Manifold Traits */
 //@{
-template <class Manifold> struct TangentVector;
-template <class Manifold> struct DefaultChart;
+template<class Manifold> struct TangentVector;
+template<class Manifold> struct DefaultChart;
 //@}
 
-} // namespace traits
+}// namespace traits
 
 /*
-template<class T>
-class ManifoldConcept {
+ template<class T>
+ class ManifoldConcept {
  public:
-  typedef T Manifold;
-  typedef typename traits::TangentVector<T>::type TangentVector;
-  typedef typename traits::DefaultChart<T>::type DefaultChart;
-  static const size_t dim = traits::dimension<T>::value;
+ typedef T Manifold;
+ typedef typename traits::TangentVector<T>::type TangentVector;
+ typedef typename traits::DefaultChart<T>::type DefaultChart;
+ static const size_t dim = traits::dimension<T>::value;
 
-  BOOST_CONCEPT_USAGE(ManifoldConcept) {
-    BOOST_STATIC_ASSERT(boost::is_base_of<traits::manifold_tag, traits::structure<Manifold> >);
-    BOOST_STATIC_ASSERT(TangentVector::SizeAtCompileTime == dim);
-    // no direct usage for manifold since most usage is through a chart
-  }
+ BOOST_CONCEPT_USAGE(ManifoldConcept) {
+ BOOST_STATIC_ASSERT(boost::is_base_of<traits::manifold_tag, traits::structure<Manifold> >);
+ BOOST_STATIC_ASSERT(TangentVector::SizeAtCompileTime == dim);
+ // no direct usage for manifold since most usage is through a chart
+ }
  private:
-  Manifold p;
-  TangentVector v;
-};
+ Manifold p;
+ TangentVector v;
+ };
 
-template<class C>
-class ChartConcept {
+ template<class C>
+ class ChartConcept {
  public:
-  typedef C Chart;
-  typedef typename traits::Manifold<Chart>::type Manifold;
-  typedef typename traits::TangentVector<Manifold>::type TangentVector;
+ typedef C Chart;
+ typedef typename traits::Manifold<Chart>::type Manifold;
+ typedef typename traits::TangentVector<Manifold>::type TangentVector;
 
-  BOOST_CONCEPT_USAGE(ChartConcept) {
-    v = Chart::local(p,q); // returns local coordinates of q w.r.t. origin p
-    q = Chart::retract(p,v); // returns retracted update of p with v
-  }
+ BOOST_CONCEPT_USAGE(ChartConcept) {
+ v = Chart::local(p,q); // returns local coordinates of q w.r.t. origin p
+ q = Chart::retract(p,v); // returns retracted update of p with v
+ }
 
  private:
-  Manifold p,q;
-  TangentVector v;
+ Manifold p,q;
+ TangentVector v;
 
-};
-*/
+ };
+ */
+
+namespace group {
+
+template<typename G>
+G compose(const G&g, const G& h);
 
 namespace traits {
 
 /** @name Group Traits */
 //@{
-template <class Group> struct identity;
-template <class Group> struct group_flavor;
+template<class G> struct identity;
+template<class G> struct flavor;
 //@}
 
 /** @name Group Flavor Tags */
 //@{
-struct additive_group_tag {};
-struct multiplicative_group_tag {};
+struct additive_tag {
+};
+struct multiplicative_tag {
+};
 //@}
 
-} // namespace traits
+} // \ namespace traits
+} // \ namespace group
 
 /**
  * Group Concept
  */
-template<class G>
+template<typename G>
 class Group {
 public:
 
-  typedef typename traits::identity<G>::value_type identity_value_type;
-  typedef typename traits::group_flavor<G>::type group_flavor_tag;
   typedef typename traits::structure_category<G>::type structure_category_tag;
+  typedef typename group::traits::identity<G>::value_type identity_value_type;
+  typedef typename group::traits::flavor<G>::type group_flavor_tag;
 
   BOOST_CONCEPT_USAGE(Group) {
-    e = traits::identity<G>::value;
-//    BOOST_STATIC_ASSERT(boost::is_base_of<traits::group_tag,typename traits::structure_category<Group>::type>::value );
+    using group::compose;
+    BOOST_STATIC_ASSERT(
+        boost::is_base_of<traits::group_tag, structure_category_tag>::value);
+    e = group::traits::identity<G>::value;
+    pq = compose(p, q);
 //    G ip = inverse(p);
-//    G pq = compose(p, q);
 //    G d = between(p, q);
 //    test = equal(p, q);
-//    test2 = operator_usage(p, q, traits::group_flavor<Group>::type);
+//    test2 = operator_usage(p, q, group::traits::_flavor<Group>::type);
   }
 
   bool check_invariants(const G& a, const G& b) {
@@ -134,54 +149,53 @@ public:
   }
 
 private:
-  G p, q, e;
+  G e, p, q, pq, ip, d;
   bool test, test2;
 
   bool operator_usage(const G& a, const G& b,
-      traits::multiplicative_group_tag) {
+      group::traits::multiplicative_tag) {
     return equal(compose(a, b), a * b);
 
   }
-  bool operator_usage(const G& a, const G& b, traits::additive_group_tag) {
+  bool operator_usage(const G& a, const G& b, group::traits::additive_tag) {
     return equal(compose(a, b), a + b);
   }
 
 };
 
 /*
-template <class L>
-class LieGroupConcept : public GroupConcept<L>, public ManifoldConcept<L> {
+ template <class L>
+ class LieGroupConcept : public GroupConcept<L>, public ManifoldConcept<L> {
 
-  BOOST_CONCEPT_USAGE(LieGroupConcept) {
-    BOOST_STATIC_ASSERT(boost::is_base_of<traits::lie_group_tag, traits::structure<L> >);
-  }
-};
+ BOOST_CONCEPT_USAGE(LieGroupConcept) {
+ BOOST_STATIC_ASSERT(boost::is_base_of<traits::lie_group_tag, traits::structure<L> >);
+ }
+ };
 
-template <class V>
-class VectorSpaceConcept : public LieGroupConcept {
-  typedef typename traits::DefaultChart<V>::type Chart;
-  typedef typename GroupConcept<V>::identity identity;
+ template <class V>
+ class VectorSpaceConcept : public LieGroupConcept {
+ typedef typename traits::DefaultChart<V>::type Chart;
+ typedef typename GroupConcept<V>::identity identity;
 
-  BOOST_CONCEPT_USAGE(VectorSpaceConcept) {
-    BOOST_STATIC_ASSERT(boost::is_base_of<traits::vector_space_tag, traits::structure<L> >);
-    r = p+q;
-    r = -p;
-    r = p-q;
-  }
+ BOOST_CONCEPT_USAGE(VectorSpaceConcept) {
+ BOOST_STATIC_ASSERT(boost::is_base_of<traits::vector_space_tag, traits::structure<L> >);
+ r = p+q;
+ r = -p;
+ r = p-q;
+ }
 
-  bool check_invariants(const V& a, const V& b) {
-    return equal(compose(a, b), a+b)
-        && equal(inverse(a), -a)
-        && equal(between(a, b), b-a)
-        && equal(Chart::retract(a, b), a+b)
-        && equal(Chart::local(a, b), b-a);
-  }
+ bool check_invariants(const V& a, const V& b) {
+ return equal(compose(a, b), a+b)
+ && equal(inverse(a), -a)
+ && equal(between(a, b), b-a)
+ && equal(Chart::retract(a, b), a+b)
+ && equal(Chart::local(a, b), b-a);
+ }
 
  private:
-  V p,q,r;
-};
-*/
+ V p,q,r;
+ };
+ */
 
 } // namespace gtsam
 
-
diff --git a/gtsam/geometry/tests/testCyclic.cpp b/gtsam/geometry/tests/testCyclic.cpp
index 8ea678a0f..7bc19a2b7 100644
--- a/gtsam/geometry/tests/testCyclic.cpp
+++ b/gtsam/geometry/tests/testCyclic.cpp
@@ -35,17 +35,28 @@ public:
 };
 
 namespace traits {
+/// Define Cyclic to be a model of the Group concept
 template<size_t N> struct structure_category<Cyclic<N> > {
   typedef group_tag type;
 };
+} // \namespace traits
+
+namespace group {
+template<size_t N>
+Cyclic<N> compose(const Cyclic<N>&g, const Cyclic<N>& h);
+
+namespace traits {
+/// Define the trait that specifies Cyclic's identity element
 template<size_t N> struct identity<Cyclic<N> > {
   static const Cyclic<N> value;
   typedef Cyclic<N> value_type;
 };
-template<size_t N> struct group_flavor<Cyclic<N> > {
-  typedef additive_group_tag type;
+/// Define the trait that asserts Cyclic is an additive group
+template<size_t N> struct flavor<Cyclic<N> > {
+  typedef additive_tag type;
 };
 } // \namespace traits
+} // \namespace group
 
 } // \namespace gtsam
 
@@ -57,10 +68,12 @@ template<size_t N> struct group_flavor<Cyclic<N> > {
 
 namespace gtsam {
 
+namespace group {
 namespace traits {
 template<size_t N>
 const Cyclic<N> identity<Cyclic<N> >::value = Cyclic<N>(0);
 } // \namespace traits
+} // \namespace group
 
 } // \namespace gtsam
 
@@ -81,7 +94,7 @@ typedef Cyclic<6> G; // Let's use the cyclic group of order 6
 
 //******************************************************************************
 TEST(Cyclic, Concept) {
-  EXPECT_LONGS_EQUAL(0,traits::identity<G>::value);
+  EXPECT_LONGS_EQUAL(0, group::traits::identity<G>::value);
   BOOST_CONCEPT_ASSERT((Group<G>));
 }
 

From 5407232e367a2d25a9cdcbcd1fa2308e6ce418d4 Mon Sep 17 00:00:00 2001
From: dellaert <dellaert@cc.gatech.edu>
Date: Sat, 6 Dec 2014 11:51:44 +0100
Subject: [PATCH 4/7] between and inverse, as well as tag dispatching

---
 gtsam/base/concepts.h               | 34 +++++++++++++++++------------
 gtsam/geometry/tests/testCyclic.cpp |  6 +++++
 2 files changed, 26 insertions(+), 14 deletions(-)

diff --git a/gtsam/base/concepts.h b/gtsam/base/concepts.h
index 6910518da..d3f2fe87c 100644
--- a/gtsam/base/concepts.h
+++ b/gtsam/base/concepts.h
@@ -95,8 +95,12 @@ template<class Manifold> struct DefaultChart;
 
 namespace group {
 
-template<typename G>
-G compose(const G&g, const G& h);
+/** @name Free functions any Group needs to define */
+//@{
+template<typename G> G compose(const G&g, const G& h);
+template<typename G> G between(const G&g, const G& h);
+template<typename G> G inverse(const G&g);
+//@}
 
 namespace traits {
 
@@ -126,39 +130,41 @@ public:
 
   typedef typename traits::structure_category<G>::type structure_category_tag;
   typedef typename group::traits::identity<G>::value_type identity_value_type;
-  typedef typename group::traits::flavor<G>::type group_flavor_tag;
+  typedef typename group::traits::flavor<G>::type flavor_tag;
 
   BOOST_CONCEPT_USAGE(Group) {
     using group::compose;
+    using group::between;
+    using group::inverse;
     BOOST_STATIC_ASSERT(
         boost::is_base_of<traits::group_tag, structure_category_tag>::value);
     e = group::traits::identity<G>::value;
-    pq = compose(p, q);
-//    G ip = inverse(p);
-//    G d = between(p, q);
-//    test = equal(p, q);
-//    test2 = operator_usage(p, q, group::traits::_flavor<Group>::type);
+    d = compose(g, h);
+    d = between(g, h);
+    ig = inverse(g);
+    test = operator_usage(g, h, flavor);
+//    test2 = equal(g, h);
   }
 
   bool check_invariants(const G& a, const G& b) {
-    group_flavor_tag group_flavor;
     return (equal(compose(a, inverse(a)), e))
         && (equal(between(a, b), compose(inverse(a), b)))
         && (equal(compose(a, between(a, b)), b))
-        && operator_usage(a, b, group_flavor);
+        && operator_usage(a, b, flavor);
   }
 
 private:
-  G e, p, q, pq, ip, d;
+  flavor_tag flavor;
+  G e, g, h, gh, ig, d;
   bool test, test2;
 
   bool operator_usage(const G& a, const G& b,
       group::traits::multiplicative_tag) {
-    return equal(compose(a, b), a * b);
+    return group::compose(a, b) == a * b;
 
   }
   bool operator_usage(const G& a, const G& b, group::traits::additive_tag) {
-    return equal(compose(a, b), a + b);
+    return group::compose(a, b) == a + b;
   }
 
 };
@@ -193,7 +199,7 @@ private:
  }
 
  private:
- V p,q,r;
+ V g,q,r;
  };
  */
 
diff --git a/gtsam/geometry/tests/testCyclic.cpp b/gtsam/geometry/tests/testCyclic.cpp
index 7bc19a2b7..882d8fb1c 100644
--- a/gtsam/geometry/tests/testCyclic.cpp
+++ b/gtsam/geometry/tests/testCyclic.cpp
@@ -45,6 +45,12 @@ namespace group {
 template<size_t N>
 Cyclic<N> compose(const Cyclic<N>&g, const Cyclic<N>& h);
 
+template<size_t N>
+Cyclic<N> between(const Cyclic<N>&g, const Cyclic<N>& h);
+
+template<size_t N>
+Cyclic<N> inverse(const Cyclic<N>&g);
+
 namespace traits {
 /// Define the trait that specifies Cyclic's identity element
 template<size_t N> struct identity<Cyclic<N> > {

From 6c2b28aa8b2a1f1b268fe15802108b9a3009591d Mon Sep 17 00:00:00 2001
From: dellaert <dellaert@cc.gatech.edu>
Date: Sat, 6 Dec 2014 12:50:40 +0100
Subject: [PATCH 5/7] between tested

---
 gtsam/base/concepts.h               | 18 +++++++------
 gtsam/geometry/tests/testCyclic.cpp | 39 +++++++++++++++++++++++++----
 2 files changed, 45 insertions(+), 12 deletions(-)

diff --git a/gtsam/base/concepts.h b/gtsam/base/concepts.h
index d3f2fe87c..9011c759b 100644
--- a/gtsam/base/concepts.h
+++ b/gtsam/base/concepts.h
@@ -143,15 +143,19 @@ public:
     d = between(g, h);
     ig = inverse(g);
     test = operator_usage(g, h, flavor);
-//    test2 = equal(g, h);
   }
 
-  bool check_invariants(const G& a, const G& b) {
-    return (equal(compose(a, inverse(a)), e))
-        && (equal(between(a, b), compose(inverse(a), b)))
-        && (equal(compose(a, between(a, b)), b))
-        && operator_usage(a, b, flavor);
-  }
+// TODO: these all require default constructors :-(
+// Also, requires equal which is not required of a group
+//  Group():e(group::traits::identity<G>::value) {
+//  }
+//
+//  bool check_invariants(const G& a, const G& b) {
+//    return (equal(compose(a, inverse(a)), e))
+//        && (equal(between(a, b), compose(inverse(a), b)))
+//        && (equal(compose(a, between(a, b)), b))
+//        && operator_usage(a, b, flavor);
+//  }
 
 private:
   flavor_tag flavor;
diff --git a/gtsam/geometry/tests/testCyclic.cpp b/gtsam/geometry/tests/testCyclic.cpp
index 882d8fb1c..f46b85511 100644
--- a/gtsam/geometry/tests/testCyclic.cpp
+++ b/gtsam/geometry/tests/testCyclic.cpp
@@ -32,6 +32,10 @@ public:
   operator size_t() const {
     return i_;
   }
+  /// Addition modulo N
+  Cyclic operator+(const Cyclic& h) const {
+    return (i_+h.i_) % N;
+  }
 };
 
 namespace traits {
@@ -42,14 +46,21 @@ template<size_t N> struct structure_category<Cyclic<N> > {
 } // \namespace traits
 
 namespace group {
-template<size_t N>
-Cyclic<N> compose(const Cyclic<N>&g, const Cyclic<N>& h);
 
 template<size_t N>
-Cyclic<N> between(const Cyclic<N>&g, const Cyclic<N>& h);
+Cyclic<N> compose(const Cyclic<N>&g, const Cyclic<N>& h) {
+  return g + h;
+}
 
 template<size_t N>
-Cyclic<N> inverse(const Cyclic<N>&g);
+Cyclic<N> between(const Cyclic<N>&g, const Cyclic<N>& h) {
+  return h - g;
+}
+
+template<size_t N>
+Cyclic<N> inverse(const Cyclic<N>&g) {
+  return -g;
+}
 
 namespace traits {
 /// Define the trait that specifies Cyclic's identity element
@@ -100,8 +111,10 @@ typedef Cyclic<6> G; // Let's use the cyclic group of order 6
 
 //******************************************************************************
 TEST(Cyclic, Concept) {
-  EXPECT_LONGS_EQUAL(0, group::traits::identity<G>::value);
   BOOST_CONCEPT_ASSERT((Group<G>));
+  EXPECT_LONGS_EQUAL(0, group::traits::identity<G>::value);
+  G g(2), h(3);
+  // EXPECT(Group<G>().check_invariants(g,h))
 }
 
 //******************************************************************************
@@ -109,6 +122,22 @@ TEST(Cyclic, Constructor) {
   G g(0);
 }
 
+//******************************************************************************
+TEST(Cyclic, Compose) {
+  G e(0), g(2), h(3);
+  EXPECT_LONGS_EQUAL(5, group::compose(g,h));
+  EXPECT_LONGS_EQUAL(0, group::compose(h,h));
+  EXPECT_LONGS_EQUAL(3, group::compose(h,e));
+}
+
+//******************************************************************************
+TEST(Cyclic, Between) {
+  G g(2), h(3);
+  EXPECT_LONGS_EQUAL(1, group::between(g,h));
+  EXPECT_LONGS_EQUAL(0, group::between(g,g));
+  EXPECT_LONGS_EQUAL(0, group::between(h,h));
+}
+
 //******************************************************************************
 int main() {
   TestResult tr;

From 4d2a0aefc103070e3cc76af3fe27129dad680241 Mon Sep 17 00:00:00 2001
From: dellaert <dellaert@cc.gatech.edu>
Date: Sat, 6 Dec 2014 12:59:35 +0100
Subject: [PATCH 6/7] Group checks out !

---
 gtsam/geometry/tests/testCyclic.cpp | 52 ++++++++++++++++++++++++-----
 1 file changed, 44 insertions(+), 8 deletions(-)

diff --git a/gtsam/geometry/tests/testCyclic.cpp b/gtsam/geometry/tests/testCyclic.cpp
index f46b85511..61c700c8a 100644
--- a/gtsam/geometry/tests/testCyclic.cpp
+++ b/gtsam/geometry/tests/testCyclic.cpp
@@ -36,6 +36,14 @@ public:
   Cyclic operator+(const Cyclic& h) const {
     return (i_+h.i_) % N;
   }
+  /// Subtraction modulo N
+  Cyclic operator-(const Cyclic& h) const {
+    return (N+i_-h.i_) % N;
+  }
+  /// Inverse
+  Cyclic operator-() const {
+    return (N-i_) % N;
+  }
 };
 
 namespace traits {
@@ -124,18 +132,46 @@ TEST(Cyclic, Constructor) {
 
 //******************************************************************************
 TEST(Cyclic, Compose) {
-  G e(0), g(2), h(3);
-  EXPECT_LONGS_EQUAL(5, group::compose(g,h));
-  EXPECT_LONGS_EQUAL(0, group::compose(h,h));
-  EXPECT_LONGS_EQUAL(3, group::compose(h,e));
+  EXPECT_LONGS_EQUAL(0, group::compose(G(0),G(0)));
+  EXPECT_LONGS_EQUAL(1, group::compose(G(0),G(1)));
+  EXPECT_LONGS_EQUAL(2, group::compose(G(0),G(2)));
+  EXPECT_LONGS_EQUAL(3, group::compose(G(0),G(3)));
+  EXPECT_LONGS_EQUAL(4, group::compose(G(0),G(4)));
+  EXPECT_LONGS_EQUAL(5, group::compose(G(0),G(5)));
+
+  EXPECT_LONGS_EQUAL(2, group::compose(G(2),G(0)));
+  EXPECT_LONGS_EQUAL(3, group::compose(G(2),G(1)));
+  EXPECT_LONGS_EQUAL(4, group::compose(G(2),G(2)));
+  EXPECT_LONGS_EQUAL(5, group::compose(G(2),G(3)));
+  EXPECT_LONGS_EQUAL(0, group::compose(G(2),G(4)));
+  EXPECT_LONGS_EQUAL(1, group::compose(G(2),G(5)));
 }
 
 //******************************************************************************
 TEST(Cyclic, Between) {
-  G g(2), h(3);
-  EXPECT_LONGS_EQUAL(1, group::between(g,h));
-  EXPECT_LONGS_EQUAL(0, group::between(g,g));
-  EXPECT_LONGS_EQUAL(0, group::between(h,h));
+  EXPECT_LONGS_EQUAL(0, group::between(G(0),G(0)));
+  EXPECT_LONGS_EQUAL(1, group::between(G(0),G(1)));
+  EXPECT_LONGS_EQUAL(2, group::between(G(0),G(2)));
+  EXPECT_LONGS_EQUAL(3, group::between(G(0),G(3)));
+  EXPECT_LONGS_EQUAL(4, group::between(G(0),G(4)));
+  EXPECT_LONGS_EQUAL(5, group::between(G(0),G(5)));
+
+  EXPECT_LONGS_EQUAL(4, group::between(G(2),G(0)));
+  EXPECT_LONGS_EQUAL(5, group::between(G(2),G(1)));
+  EXPECT_LONGS_EQUAL(0, group::between(G(2),G(2)));
+  EXPECT_LONGS_EQUAL(1, group::between(G(2),G(3)));
+  EXPECT_LONGS_EQUAL(2, group::between(G(2),G(4)));
+  EXPECT_LONGS_EQUAL(3, group::between(G(2),G(5)));
+}
+
+//******************************************************************************
+TEST(Cyclic, Ivnverse) {
+  EXPECT_LONGS_EQUAL(0, group::inverse(G(0)));
+  EXPECT_LONGS_EQUAL(5, group::inverse(G(1)));
+  EXPECT_LONGS_EQUAL(4, group::inverse(G(2)));
+  EXPECT_LONGS_EQUAL(3, group::inverse(G(3)));
+  EXPECT_LONGS_EQUAL(2, group::inverse(G(4)));
+  EXPECT_LONGS_EQUAL(1, group::inverse(G(5)));
 }
 
 //******************************************************************************

From 614bfeb9d39a375a5a16904214772b9cf15684b7 Mon Sep 17 00:00:00 2001
From: dellaert <dellaert@cc.gatech.edu>
Date: Sat, 6 Dec 2014 13:11:56 +0100
Subject: [PATCH 7/7] Moved to headers

---
 gtsam/geometry/Cyclic.cpp           | 27 ++++++++
 gtsam/geometry/Cyclic.h             | 89 +++++++++++++++++++++++++++
 gtsam/geometry/tests/testCyclic.cpp | 95 +----------------------------
 3 files changed, 117 insertions(+), 94 deletions(-)
 create mode 100644 gtsam/geometry/Cyclic.cpp
 create mode 100644 gtsam/geometry/Cyclic.h

diff --git a/gtsam/geometry/Cyclic.cpp b/gtsam/geometry/Cyclic.cpp
new file mode 100644
index 000000000..2b14ec6ba
--- /dev/null
+++ b/gtsam/geometry/Cyclic.cpp
@@ -0,0 +1,27 @@
+/* ----------------------------------------------------------------------------
+
+ * GTSAM Copyright 2010, Georgia Tech Research Corporation, 
+ * Atlanta, Georgia 30332-0415
+ * All Rights Reserved
+ * Authors: Frank Dellaert, et al. (see THANKS for the full author list)
+
+ * See LICENSE for the license information
+
+ * -------------------------------------------------------------------------- */
+
+/**
+ * @file   Cyclic.cpp
+ * @brief  Cyclic group implementation
+ * @author Frank Dellaert
+ **/
+
+#include <gtsam/geometry/Cyclic.h>
+
+namespace gtsam {
+namespace group {
+namespace traits {
+
+} // \namespace traits
+} // \namespace group
+} // \namespace gtsam
+
diff --git a/gtsam/geometry/Cyclic.h b/gtsam/geometry/Cyclic.h
new file mode 100644
index 000000000..85602d12d
--- /dev/null
+++ b/gtsam/geometry/Cyclic.h
@@ -0,0 +1,89 @@
+/* ----------------------------------------------------------------------------
+
+ * GTSAM Copyright 2010, Georgia Tech Research Corporation, 
+ * Atlanta, Georgia 30332-0415
+ * All Rights Reserved
+ * Authors: Frank Dellaert, et al. (see THANKS for the full author list)
+
+ * See LICENSE for the license information
+
+ * -------------------------------------------------------------------------- */
+
+/**
+ * @file   Cyclic.h
+ * @brief  Cyclic group, i.e., the integers modulo N
+ * @author Frank Dellaert
+ **/
+
+#include <gtsam/base/concepts.h>
+#include <cstddef>
+
+namespace gtsam {
+
+template<size_t N>
+class Cyclic {
+  size_t i_; ///< we just use an unsigned int
+public:
+  /// Constructor
+  Cyclic(size_t i) :
+      i_(i) {
+  }
+  /// Cast to size_t
+  operator size_t() const {
+    return i_;
+  }
+  /// Addition modulo N
+  Cyclic operator+(const Cyclic& h) const {
+    return (i_ + h.i_) % N;
+  }
+  /// Subtraction modulo N
+  Cyclic operator-(const Cyclic& h) const {
+    return (N + i_ - h.i_) % N;
+  }
+  /// Inverse
+  Cyclic operator-() const {
+    return (N - i_) % N;
+  }
+};
+
+namespace traits {
+/// Define Cyclic to be a model of the Group concept
+template<size_t N> struct structure_category<Cyclic<N> > {
+  typedef group_tag type;
+};
+} // \namespace gtsam::traits
+
+namespace group {
+
+template<size_t N>
+Cyclic<N> compose(const Cyclic<N>&g, const Cyclic<N>& h) {
+  return g + h;
+}
+
+template<size_t N>
+Cyclic<N> between(const Cyclic<N>&g, const Cyclic<N>& h) {
+  return h - g;
+}
+
+template<size_t N>
+Cyclic<N> inverse(const Cyclic<N>&g) {
+  return -g;
+}
+
+namespace traits {
+
+/// Define the trait that specifies Cyclic's identity element
+template<size_t N> struct identity<Cyclic<N> > {
+  static const Cyclic<N> value = Cyclic<N>(0);
+  typedef Cyclic<N> value_type;
+};
+
+/// Define the trait that asserts Cyclic is an additive group
+template<size_t N> struct flavor<Cyclic<N> > {
+  typedef additive_tag type;
+};
+
+} // \namespace gtsam::group::traits
+} // \namespace gtsam::group
+} // \namespace gtsam
+
diff --git a/gtsam/geometry/tests/testCyclic.cpp b/gtsam/geometry/tests/testCyclic.cpp
index 61c700c8a..00ea2c853 100644
--- a/gtsam/geometry/tests/testCyclic.cpp
+++ b/gtsam/geometry/tests/testCyclic.cpp
@@ -9,106 +9,13 @@
 
  * -------------------------------------------------------------------------- */
 
-/**
- * @file   Cyclic.h
- * @brief  Cyclic group, i.e., the integers modulo N
- * @author Frank Dellaert
- **/
-
-#include <gtsam/base/concepts.h>
-#include <cstddef>
-
-namespace gtsam {
-
-template<size_t N>
-class Cyclic {
-  size_t i_; ///< we just use an unsigned int
-public:
-  /// Constructor
-  Cyclic(size_t i) :
-      i_(i) {
-  }
-  /// Cast to size_t
-  operator size_t() const {
-    return i_;
-  }
-  /// Addition modulo N
-  Cyclic operator+(const Cyclic& h) const {
-    return (i_+h.i_) % N;
-  }
-  /// Subtraction modulo N
-  Cyclic operator-(const Cyclic& h) const {
-    return (N+i_-h.i_) % N;
-  }
-  /// Inverse
-  Cyclic operator-() const {
-    return (N-i_) % N;
-  }
-};
-
-namespace traits {
-/// Define Cyclic to be a model of the Group concept
-template<size_t N> struct structure_category<Cyclic<N> > {
-  typedef group_tag type;
-};
-} // \namespace traits
-
-namespace group {
-
-template<size_t N>
-Cyclic<N> compose(const Cyclic<N>&g, const Cyclic<N>& h) {
-  return g + h;
-}
-
-template<size_t N>
-Cyclic<N> between(const Cyclic<N>&g, const Cyclic<N>& h) {
-  return h - g;
-}
-
-template<size_t N>
-Cyclic<N> inverse(const Cyclic<N>&g) {
-  return -g;
-}
-
-namespace traits {
-/// Define the trait that specifies Cyclic's identity element
-template<size_t N> struct identity<Cyclic<N> > {
-  static const Cyclic<N> value;
-  typedef Cyclic<N> value_type;
-};
-/// Define the trait that asserts Cyclic is an additive group
-template<size_t N> struct flavor<Cyclic<N> > {
-  typedef additive_tag type;
-};
-} // \namespace traits
-} // \namespace group
-
-} // \namespace gtsam
-
-/**
- * @file   Cyclic.cpp
- * @brief  Cyclic group implementation
- * @author Frank Dellaert
- **/
-
-namespace gtsam {
-
-namespace group {
-namespace traits {
-template<size_t N>
-const Cyclic<N> identity<Cyclic<N> >::value = Cyclic<N>(0);
-} // \namespace traits
-} // \namespace group
-
-} // \namespace gtsam
-
 /**
  * @file   testCyclic.cpp
  * @brief  Unit tests for cyclic group
  * @author Frank Dellaert
  **/
 
-//#include <gtsam/geometry/Cyclic.h>
+#include <gtsam/geometry/Cyclic.h>
 #include <gtsam/base/Testable.h>
 #include <CppUnitLite/TestHarness.h>