From bb30ce0a091d6b180ee4cbf2853bdac9969665f0 Mon Sep 17 00:00:00 2001
From: "Jeremy W. Murphy" <jeremy.william.murphy@gmail.com>
Date: Mon, 2 May 2016 22:08:49 +1000
Subject: [PATCH 1/9] Initial thoughts on an algebraic traits facility.

---
 include/boost/math/algebraic_traits.hpp | 141 ++++++++++++++++++++++++++++++++
 1 file changed, 141 insertions(+)
 create mode 100644 include/boost/math/algebraic_traits.hpp

diff --git a/include/boost/math/algebraic_traits.hpp b/include/boost/math/algebraic_traits.hpp
new file mode 100644
index 000000000..f954976c4
--- /dev/null
+++ b/include/boost/math/algebraic_traits.hpp
@@ -0,0 +1,141 @@
+//  (C) Copyright Jeremy William Murphy 2016.
+
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_MATH_ALGEBRAIC_TRAITS
+#define BOOST_MATH_ALGEBRAIC_TRAITS
+
+#include <boost/config.hpp>
+#include <boost/core/enable_if.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/logical.hpp>
+#include <boost/type_traits/is_integral.hpp>
+#include <boost/type_traits/is_floating_point.hpp>
+
+#include <limits>
+#include <functional>
+#include <string>
+
+namespace boost {
+namespace detail {
+    
+struct algebraic_traits_base
+{
+    BOOST_STATIC_CONSTANT(bool, is_specialized = false);
+};
+
+} // detail
+
+
+template <template <typename> class BinaryOperation, typename T, typename Enable = void>
+struct algebraic_traits : public detail::algebraic_traits_base
+{
+    // To provide default implementations or not?
+};
+
+
+// associativity
+
+template <template <typename> class BinaryOperation, typename T, typename Enable = void>
+struct algebraic_traits_associativity
+{};
+
+
+template <template <typename> class BinaryOperation, typename T>
+struct algebraic_traits_associativity<BinaryOperation, T, 
+typename enable_if< typename mpl::or_<is_integral<T>, mpl::bool_<std::numeric_limits<T>::is_exact> >::type >::type >
+{
+    BOOST_STATIC_CONSTEXPR
+    bool is_associative() { return true; }
+};
+
+
+template <template <typename> class BinaryOperation, typename T>
+struct algebraic_traits_associativity<BinaryOperation, T, 
+typename enable_if< typename mpl::or_<is_floating_point<T>, mpl::bool_<!std::numeric_limits<T>::is_exact> >::type >::type >
+{
+    BOOST_STATIC_CONSTEXPR
+    bool is_associative() { return false; }
+};
+
+
+// commutativity
+
+template <template <typename> class BinaryOperation, typename T, typename Enable = void>
+struct algebraic_traits : public detail::algebraic_traits_base
+{
+    // To provide default implementations or not?
+};
+
+
+// associativity
+
+template <template <typename> class BinaryOperation, typename T, typename Enable = void>
+struct algebraic_traits_commutativity
+{};
+
+
+template <typename T>
+struct algebraic_traits_commutativity<std::plus, T>
+{
+    BOOST_STATIC_CONSTEXPR
+    bool is_commutative() { return true; }
+};
+
+
+template <>
+struct algebraic_traits_commutativity<std::plus, std::string>
+{
+    BOOST_STATIC_CONSTEXPR
+    bool is_commutative() { return false; }
+};
+
+
+//  multiplication
+
+template <typename T>
+struct algebraic_traits< std::multiplies, T >
+{
+    BOOST_STATIC_CONSTEXPR
+    T zero_element() { return T(0); }
+    
+    BOOST_STATIC_CONSTEXPR
+    T identity_element() { return T(1); }
+};
+
+
+
+// What makes a type associative in programming: exactness?
+
+
+//  plus
+
+template <typename T>
+struct algebraic_traits<std::plus, T> : public algebraic_traits_commutativity<std::plus, T>, public algebraic_traits_associativity<std::plus, T>
+{
+    BOOST_STATIC_CONSTEXPR
+    T identity_element() { return T(0); }
+};
+
+
+template <>
+struct algebraic_traits<std::plus, std::string>
+{
+    // TODO: Can be constexpr?
+    BOOST_STATIC_CONSTEXPR
+    std::string identity_element() { return std::string(); }
+    
+    BOOST_STATIC_CONSTEXPR
+    bool is_commutative() { return false; }
+
+    BOOST_STATIC_CONSTEXPR
+    bool is_associative() { return true; }
+};
+
+
+
+} // boost
+
+#endif

From a89c8c8feea4870d05b202b3b0a289cd50297913 Mon Sep 17 00:00:00 2001
From: "Jeremy W. Murphy" <jeremy.william.murphy@gmail.com>
Date: Tue, 3 May 2016 22:44:50 +1000
Subject: [PATCH 2/9] Put algebraic traits into math namespace.

---
 include/boost/math/algebraic_traits.hpp | 11 +++--------
 1 file changed, 3 insertions(+), 8 deletions(-)

diff --git a/include/boost/math/algebraic_traits.hpp b/include/boost/math/algebraic_traits.hpp
index f954976c4..6f714ff18 100644
--- a/include/boost/math/algebraic_traits.hpp
+++ b/include/boost/math/algebraic_traits.hpp
@@ -19,6 +19,7 @@
 #include <string>
 
 namespace boost {
+namespace math {
 namespace detail {
     
 struct algebraic_traits_base
@@ -63,12 +64,6 @@ typename enable_if< typename mpl::or_<is_floating_point<T>, mpl::bool_<!std::num
 
 // commutativity
 
-template <template <typename> class BinaryOperation, typename T, typename Enable = void>
-struct algebraic_traits : public detail::algebraic_traits_base
-{
-    // To provide default implementations or not?
-};
-
 
 // associativity
 
@@ -123,7 +118,7 @@ struct algebraic_traits<std::plus, T> : public algebraic_traits_commutativity<st
 template <>
 struct algebraic_traits<std::plus, std::string>
 {
-    // TODO: Can be constexpr?
+    // TODO: Can be constexpr? String literal in C++14?
     BOOST_STATIC_CONSTEXPR
     std::string identity_element() { return std::string(); }
     
@@ -135,7 +130,7 @@ struct algebraic_traits<std::plus, std::string>
 };
 
 
-
+} // math
 } // boost
 
 #endif

From 9c2ba0e875272c350dca8f1b4f1fbd1c77305db5 Mon Sep 17 00:00:00 2001
From: "Jeremy W. Murphy" <jeremy.william.murphy@gmail.com>
Date: Tue, 3 May 2016 22:45:34 +1000
Subject: [PATCH 3/9] gcd_range using accumulate_if.

---
 include/boost/math/common_factor_rt.hpp | 27 +++++++++++++++++++++++++++
 test/test_gcd.cpp                       | 12 ++++++++++++
 2 files changed, 39 insertions(+)

diff --git a/include/boost/math/common_factor_rt.hpp b/include/boost/math/common_factor_rt.hpp
index 10a92ebf5..ee672f8f1 100644
--- a/include/boost/math/common_factor_rt.hpp
+++ b/include/boost/math/common_factor_rt.hpp
@@ -20,7 +20,9 @@
 #include <boost/config.hpp>  // for BOOST_NESTED_TEMPLATE, etc.
 #include <boost/limits.hpp>  // for std::numeric_limits
 #include <climits>           // for CHAR_MIN
+#include <iterator>
 #include <boost/detail/workaround.hpp>
+#include <boost/math/algebraic_traits.hpp>
 
 #ifdef BOOST_MSVC
 #pragma warning(push)
@@ -435,6 +437,31 @@ gcd
     return solver( a, b );
 }
 
+template <typename T>
+struct algebraic_traits<gcd_evaluator, T>
+{
+    BOOST_STATIC_CONSTEXPR
+    T zero_element() { return T(1); }
+    
+    BOOST_STATIC_CONSTEXPR
+    bool is_commutative() { return true; }
+    
+    BOOST_STATIC_CONSTEXPR
+    bool is_associative() { return true; }
+};
+
+
+template <typename I>
+std::pair<typename std::iterator_traits<I>::value_type, I>
+gcd_range(I first, I last)
+{
+    BOOST_ASSERT(first != last);
+    typedef typename std::iterator_traits<I>::value_type T;
+    I second = first;
+    second++;
+    return accumulate_if(second, last, *first, gcd_evaluator<T>());
+}
+
 template < typename IntegerType >
 inline
 IntegerType
diff --git a/test/test_gcd.cpp b/test/test_gcd.cpp
index 1e8992e93..1af693b6e 100644
--- a/test/test_gcd.cpp
+++ b/test/test_gcd.cpp
@@ -15,6 +15,9 @@
 #include <boost/multiprecision/cpp_int.hpp>
 #include <boost/multiprecision/cpp_bin_float.hpp>
 #include <boost/multiprecision/cpp_dec_float.hpp>
+
+#include <boost/math/algorithm.hpp>
+
 #include <utility>
 
 
@@ -46,3 +49,12 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_unsigned, T, unsigned_integral_test_types)
     a = boost::math::gcd(static_cast<T>(1836311903), static_cast<T>(2971215073)); // 46th and 47th Fibonacci numbers. 47th is prime.
     BOOST_CHECK_EQUAL(a, static_cast<T>(1));
 }
+
+
+BOOST_AUTO_TEST_CASE_TEMPLATE(test_gcd_range, T, unsigned_integral_test_types)
+{
+    boost::array<T, 7> const foo = {32, 24, 17, 19, 23, 33, 25};
+    std::pair<T, T const *> bar = boost::math::gcd_range(foo.begin(), foo.end());
+    BOOST_CHECK_EQUAL(bar.first, T(1));
+    BOOST_CHECK_EQUAL(bar.second, foo.begin() + 3);
+}

From e3a6ed164904acdf9edbe93e8afeafc6d99c9ff5 Mon Sep 17 00:00:00 2001
From: "Jeremy W. Murphy" <jeremy.william.murphy@gmail.com>
Date: Tue, 3 May 2016 22:51:27 +1000
Subject: [PATCH 4/9] Add is_specialized = true to specializations.

---
 include/boost/math/algebraic_traits.hpp | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/include/boost/math/algebraic_traits.hpp b/include/boost/math/algebraic_traits.hpp
index 6f714ff18..9cd192100 100644
--- a/include/boost/math/algebraic_traits.hpp
+++ b/include/boost/math/algebraic_traits.hpp
@@ -93,6 +93,8 @@ struct algebraic_traits_commutativity<std::plus, std::string>
 template <typename T>
 struct algebraic_traits< std::multiplies, T >
 {
+    BOOST_STATIC_CONSTANT(bool, is_specialized = true);
+    
     BOOST_STATIC_CONSTEXPR
     T zero_element() { return T(0); }
     
@@ -107,9 +109,12 @@ struct algebraic_traits< std::multiplies, T >
 
 //  plus
 
+// The inefficient way to multiply inherit?
 template <typename T>
 struct algebraic_traits<std::plus, T> : public algebraic_traits_commutativity<std::plus, T>, public algebraic_traits_associativity<std::plus, T>
 {
+    BOOST_STATIC_CONSTANT(bool, is_specialized = true);
+
     BOOST_STATIC_CONSTEXPR
     T identity_element() { return T(0); }
 };
@@ -118,6 +123,8 @@ struct algebraic_traits<std::plus, T> : public algebraic_traits_commutativity<st
 template <>
 struct algebraic_traits<std::plus, std::string>
 {
+    BOOST_STATIC_CONSTANT(bool, is_specialized = true);
+
     // TODO: Can be constexpr? String literal in C++14?
     BOOST_STATIC_CONSTEXPR
     std::string identity_element() { return std::string(); }

From 0141010c873ddbc358f0fd10f14c26a5dc7e7f6e Mon Sep 17 00:00:00 2001
From: "Jeremy W. Murphy" <jeremy.william.murphy@gmail.com>
Date: Tue, 3 May 2016 22:54:06 +1000
Subject: [PATCH 5/9] accumulate_if: algorithm to terminate loop early on zero
 element.

---
 include/boost/math/algorithm.hpp | 62 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 62 insertions(+)
 create mode 100644 include/boost/math/algorithm.hpp

diff --git a/include/boost/math/algorithm.hpp b/include/boost/math/algorithm.hpp
new file mode 100644
index 000000000..ee76dc16c
--- /dev/null
+++ b/include/boost/math/algorithm.hpp
@@ -0,0 +1,62 @@
+//  (C) Copyright Jeremy William Murphy 2016.
+
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_MATH_ALGORITHM
+#define BOOST_MATH_ALGORITHM
+
+#include <boost/math/algebraic_traits.hpp>
+#include <boost/concept/assert.hpp>
+#include <boost/concept_check.hpp>
+#include <boost/bind.hpp>
+
+#include <functional>
+#include <numeric>
+#include <utility>
+
+namespace boost {
+namespace math {
+    namespace detail
+    {
+        struct not_equal_to_zero
+        {
+            typedef bool result_type;
+            
+            // Slightly awkward.
+            template <template <typename> class Op, typename T>
+            bool operator()(Op<T> const &, T const &x) const
+            {
+                return x != algebraic_traits<Op, T>::zero_element();
+            }
+        };
+    }
+    
+    
+    template<typename I, typename T, typename BinaryOperation, typename Predicate>
+    inline std::pair<T, I>
+    accumulate_if(I first, I last, T init, BinaryOperation op, Predicate p)
+    {
+        BOOST_CONCEPT_ASSERT((InputIterator<I>));
+        
+        for (; first != last && p(init); ++first )
+            init = op ( init, *first );
+        return std::make_pair(init, first);
+    }
+    
+
+    template<typename I, typename T, typename BinaryOperation>
+    inline std::pair<T, I>
+    accumulate_if(I first, I last, T init, BinaryOperation op)
+    {
+        using boost::placeholders::_1;
+        
+        detail::not_equal_to_zero const pred;
+        return accumulate_if(first, last, init, op, bind(pred, op, _1));
+    }
+} // math
+} // boost
+
+#endif
+

From 8507d1a3e7bcda35fed7a2e19c212c214297eea3 Mon Sep 17 00:00:00 2001
From: "Jeremy W. Murphy" <jeremy.william.murphy@gmail.com>
Date: Fri, 6 May 2016 07:14:28 +1000
Subject: [PATCH 6/9] Comment on purpose and scope.

---
 include/boost/math/algebraic_traits.hpp | 37 +++++++++++++++++++++++++++++++++
 1 file changed, 37 insertions(+)

diff --git a/include/boost/math/algebraic_traits.hpp b/include/boost/math/algebraic_traits.hpp
index 9cd192100..6449a0c5f 100644
--- a/include/boost/math/algebraic_traits.hpp
+++ b/include/boost/math/algebraic_traits.hpp
@@ -18,6 +18,43 @@
 #include <functional>
 #include <string>
 
+/*                                      PURPOSE
+ * 
+ * A facility to provide convenient access to algebraic traits of types.
+ * 
+ * For example:
+ * 
+ *      algebraic_traits<std::multiplies, int>::zero_element() -> 0
+ *      algebraic_traits<std::multiplies, int>::identity_element() -> 1
+ *      algebraic_traits<std::plus, std::string>::identity_element() -> ""
+ * 
+ *      algebraic_traits<std::multiplies, int>::is_associative() -> true
+ *      algebraic_traits<std::multiplies, double>::is_associative() -> false
+ *      algebraic_traits<std::plus, std::string>::is_associative() -> true
+ *      algebraic_traits<std::multiplies, double>::is_commutative() -> true
+ *      algebraic_traits<std::plus, std::string>::is_commutative() -> false
+ * 
+ * Or alternatively:
+ * 
+ *      std::multiplies<int> op1;
+ *      std::multiplies<double> op2;
+ *      std::plus<std::string> op3;
+ *      algebraic_traits::zero_element(op1) -> 0
+ *      algebraic_traits::zero_element(op2) -> 0.0
+ *      algebraic_traits::zero_element(op3) -> ""
+ * 
+ * 
+ * Properties to consider:
+ * 
+ * Medial
+ * Distributive
+ * Commutative
+ * Idempotent
+ * Associative
+ * Unital
+ * Cancellative
+ */
+
 namespace boost {
 namespace math {
 namespace detail {

From 797c467b47e6f22445858cd3f34d92de75c939a1 Mon Sep 17 00:00:00 2001
From: "Jeremy W. Murphy" <jeremy.william.murphy@gmail.com>
Date: Sat, 7 May 2016 10:38:41 +1000
Subject: [PATCH 7/9] Remove unnecessary include.

---
 test/test_gcd.cpp | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/test/test_gcd.cpp b/test/test_gcd.cpp
index 1af693b6e..70d6c6cd6 100644
--- a/test/test_gcd.cpp
+++ b/test/test_gcd.cpp
@@ -15,9 +15,6 @@
 #include <boost/multiprecision/cpp_int.hpp>
 #include <boost/multiprecision/cpp_bin_float.hpp>
 #include <boost/multiprecision/cpp_dec_float.hpp>
-
-#include <boost/math/algorithm.hpp>
-
 #include <utility>
 
 

From 3a79c2422e56d4cead1224b98f40feab055f9317 Mon Sep 17 00:00:00 2001
From: "Jeremy W. Murphy" <jeremy.william.murphy@gmail.com>
Date: Wed, 29 Jun 2016 18:27:29 +1000
Subject: [PATCH 8/9] [gcd] Simplify gcd_range.

---
 include/boost/math/common_factor_rt.hpp | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/include/boost/math/common_factor_rt.hpp b/include/boost/math/common_factor_rt.hpp
index 327f0dfa7..0680e7e21 100644
--- a/include/boost/math/common_factor_rt.hpp
+++ b/include/boost/math/common_factor_rt.hpp
@@ -432,9 +432,8 @@ gcd_range(I first, I last)
 {
     BOOST_ASSERT(first != last);
     typedef typename std::iterator_traits<I>::value_type T;
-    I second = first;
-    second++;
-    return accumulate_if(second, last, *first, gcd_evaluator<T>());
+    I const init(first++);
+    return accumulate_if(first, last, *init, gcd_evaluator<T>());
 }
 
 }  // namespace math

From b94fc45d91e96ab325f58887d8a1193cb5972870 Mon Sep 17 00:00:00 2001
From: "Jeremy W. Murphy" <jeremy.william.murphy@gmail.com>
Date: Thu, 30 Jun 2016 14:45:13 +1000
Subject: [PATCH 9/9] Fix typo in comments.

---
 include/boost/math/algebraic_traits.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/boost/math/algebraic_traits.hpp b/include/boost/math/algebraic_traits.hpp
index 6449a0c5f..9b3578317 100644
--- a/include/boost/math/algebraic_traits.hpp
+++ b/include/boost/math/algebraic_traits.hpp
@@ -41,7 +41,7 @@
  *      std::plus<std::string> op3;
  *      algebraic_traits::zero_element(op1) -> 0
  *      algebraic_traits::zero_element(op2) -> 0.0
- *      algebraic_traits::zero_element(op3) -> ""
+ *      algebraic_traits::identity_element(op3) -> ""
  * 
  * 
  * Properties to consider: