[Boost-commit] svn:boost r54855 - sandbox/numeric_adaptor/boost/numeric_adaptor

Subject: [Boost-commit] svn:boost r54855 - sandbox/numeric_adaptor/boost/numeric_adaptor
From: bruno.lalande_at_[hidden]
Date: 2009-07-10 09:40:32

Author: bruno.lalande
Date: 2009-07-10 09:40:30 EDT (Fri, 10 Jul 2009)
New Revision: 54855
URL: http://svn.boost.org/trac/boost/changeset/54855

Log:
Mathematical functions now act on policies, not on values.
Text files modified: 
   sandbox/numeric_adaptor/boost/numeric_adaptor/cln_policy.hpp      |    28 ++++++------                            
   sandbox/numeric_adaptor/boost/numeric_adaptor/default_policy.hpp  |    71 +++++++++++++++---------------          
   sandbox/numeric_adaptor/boost/numeric_adaptor/gmp_policy.hpp      |    60 ++++++++++++++-----------               
   sandbox/numeric_adaptor/boost/numeric_adaptor/ieee_policy.hpp     |    20 ++++++--                                
   sandbox/numeric_adaptor/boost/numeric_adaptor/numeric_adaptor.hpp |    92 +++++++++++++++++---------------------- 
   5 files changed, 138 insertions(+), 133 deletions(-)

Modified: sandbox/numeric_adaptor/boost/numeric_adaptor/cln_policy.hpp
==============================================================================
--- sandbox/numeric_adaptor/boost/numeric_adaptor/cln_policy.hpp	(original)
+++ sandbox/numeric_adaptor/boost/numeric_adaptor/cln_policy.hpp	2009-07-10 09:40:30 EDT (Fri, 10 Jul 2009)
@@ -49,40 +49,40 @@
         //value = cln::cl_float(atof(v.c_str()), cln::float_format(256));
     }
 
-    static inline void abs(value_type& r, value_type const& a)
+    static inline void abs(cln_policy& r, cln_policy const& a)
     {
-        r = cln::abs(a);
+        r.value = cln::abs(a.value);
     }
 
 
-    static inline void sqrt(value_type& r, value_type const& a)
+    static inline void sqrt(cln_policy& r, cln_policy const& a)
     {
-        r = cln::sqrt(a);
+        r.value = cln::sqrt(a.value);
     }
 
-    static inline void cos(value_type& r, value_type const& a)
+    static inline void cos(cln_policy& r, cln_policy const& a)
     {
-        r = cln::cos(a);
+        r.value = cln::cos(a.value);
     }
 
-    static inline void sin(value_type& r, value_type const& a)
+    static inline void sin(cln_policy& r, cln_policy const& a)
     {
-        r = cln::sin(a);
+        r.value = cln::sin(a.value);
     }
 
-    static inline void tan(value_type& r, value_type const& a)
+    static inline void tan(cln_policy& r, cln_policy const& a)
     {
-        r = cln::tan(a);
+        r.value = cln::tan(a.value);
     }
 
-    static inline void atan(value_type& r, value_type const& a)
+    static inline void atan(cln_policy& r, cln_policy const& a)
     {
-        r = cln::atan(a);
+        r.value = cln::atan(a.value);
     }
 
-    static inline void hypot(value_type& r, value_type const& a, value_type const& b)
+    static inline void hypot(cln_policy& r, cln_policy const& a, cln_policy const& b)
     {
-        r = cln::sqrt(a * a + b * b);
+        r.value = cln::sqrt(a.value * a.value + b.value * b.value);
     }
 
 

Modified: sandbox/numeric_adaptor/boost/numeric_adaptor/default_policy.hpp
==============================================================================
--- sandbox/numeric_adaptor/boost/numeric_adaptor/default_policy.hpp	(original)
+++ sandbox/numeric_adaptor/boost/numeric_adaptor/default_policy.hpp	2009-07-10 09:40:30 EDT (Fri, 10 Jul 2009)
@@ -22,8 +22,6 @@
 {
     typedef T value_type;
 
-    value_type value;
-
     // Default no initialization or pre-destruction is necessary
     static inline void init(T& value) {}
     static inline void destruct(T& value) {}
@@ -32,53 +30,53 @@
     static inline void copy(T const& source, T& dest) { dest = source; }
 
     // The default policy uses the default operators +, -, *, /
-    static inline void add(value_type& r, const value_type& a, const value_type& b)
-    { r = a + b; }
-    static inline void add(value_type& a, const value_type& b)
-    { a += b; }
-    static inline void subtract(value_type& r, const value_type& a, const value_type& b)
-    { r = a - b; }
-    static inline void subtract(value_type& a, const value_type& b)
-    { a -= b; }
-    static inline void multiply(value_type& r, const value_type& a, const value_type& b)
-    { r = a * b; }
-    static inline void multiply(value_type& a, const value_type& b)
-    { a *= b; }
-    static inline void divide(value_type& r, const value_type& a, const value_type& b)
-    { r = a / b; }
-    static inline void divide(value_type& a, const value_type& b)
-    { a /= b; }
-    static inline void neg(value_type& r, const value_type& n)
-    { r = -n; }
+    static inline void add(default_policy& r, const default_policy& a, const default_policy& b)
+    { r.value = a.value + b.value; }
+    static inline void add(default_policy& a, const default_policy& b)
+    { a.value += b.value; }
+    static inline void subtract(default_policy& r, const default_policy& a, const default_policy& b)
+    { r.value = a.value - b.value; }
+    static inline void subtract(default_policy& a, const default_policy& b)
+    { a.value -= b.value; }
+    static inline void multiply(default_policy& r, const default_policy& a, const default_policy& b)
+    { r.value = a.value * b.value; }
+    static inline void multiply(default_policy& a, const default_policy& b)
+    { a.value *= b.value; }
+    static inline void divide(default_policy& r, const default_policy& a, const default_policy& b)
+    { r.value = a.value / b.value; }
+    static inline void divide(default_policy& a, const default_policy& b)
+    { a.value /= b.value; }
+    static inline void neg(default_policy& r, const default_policy& n)
+    { r.value = -n.value; }
 
-    static inline void cos(value_type& r, value_type const& a)
+    static inline void cos(default_policy& r, default_policy const& a)
     {
-        double d = Derived::template big_numeric_cast<double>(a);
-        Derived::set(r, std::cos(d));
+        double d = Derived::template big_numeric_cast<double>(static_cast<const Derived&>(a));
+        Derived::set(r.value, std::cos(d));
     }
 
-    static inline void sin(value_type& r, value_type const& a)
+    static inline void sin(default_policy& r, default_policy const& a)
     {
-        double d = Derived::template big_numeric_cast<double>(a);
-        Derived::set(r, std::sin(d));
+        double d = Derived::template big_numeric_cast<double>(static_cast<const Derived&>(a));
+        Derived::set(r.value, std::sin(d));
     }
 
-    static inline void tan(value_type& r, value_type const& a)
+    static inline void tan(default_policy& r, default_policy const& a)
     {
-        double d = Derived::template big_numeric_cast<double>(a);
-        Derived::set(r, std::tan(d));
+        double d = Derived::template big_numeric_cast<double>(static_cast<const Derived&>(a));
+        Derived::set(r.value, std::tan(d));
     }
 
-    static inline void atan(value_type& r, value_type const& a)
+    static inline void atan(default_policy& r, default_policy const& a)
     {
-        double d = Derived::template big_numeric_cast<double>(a);
-        Derived::set(r, std::atan(d));
+        double d = Derived::template big_numeric_cast<double>(static_cast<const Derived&>(a));
+        Derived::set(r.value, std::atan(d));
     }
 
-    static inline void sqrt(value_type& r, value_type const& a)
+    static inline void sqrt(default_policy& r, default_policy const& a)
     {
-        double d = Derived::template big_numeric_cast<double>(a);
-        Derived::set(r, std::sqrt(d));
+        double d = Derived::template big_numeric_cast<double>(static_cast<const Derived&>(a));
+        Derived::set(r.value, std::sqrt(d));
     }
 
     // Default use the comparison operators
@@ -93,6 +91,9 @@
         out << std::setprecision(20) << a;
         return out.str();
     }
+
+protected:
+    value_type value;
 };
 
 

Modified: sandbox/numeric_adaptor/boost/numeric_adaptor/gmp_policy.hpp
==============================================================================
--- sandbox/numeric_adaptor/boost/numeric_adaptor/gmp_policy.hpp	(original)
+++ sandbox/numeric_adaptor/boost/numeric_adaptor/gmp_policy.hpp	2009-07-10 09:40:30 EDT (Fri, 10 Jul 2009)
@@ -51,69 +51,69 @@
 
     // TODO should we add specific overloads for function like mpf_add_ui?
 
-    static inline void add(value_type& r, value_type const& a, value_type const& b)
+    static inline void add(gmp_policy& r, gmp_policy const& a, gmp_policy const& b)
     {
-        mpf_add(r, a, b);
+        mpf_add(r.value, a.value, b.value);
     }
 
-    static inline void add(value_type& a, value_type const& b)
+    static inline void add(gmp_policy& a, gmp_policy const& b)
     {
-        mpf_add(a, a, b);
+        mpf_add(a.value, a.value, b.value);
     }
 
-    static inline void subtract(value_type& r, value_type const& a, value_type const& b)
+    static inline void subtract(gmp_policy& r, gmp_policy const& a, gmp_policy const& b)
     {
-        mpf_sub(r, a, b);
+        mpf_sub(r.value, a.value, b.value);
     }
 
-    static inline void subtract(value_type& a, value_type const& b)
+    static inline void subtract(gmp_policy& a, gmp_policy const& b)
     {
-        mpf_sub(a, a, b);
+        mpf_sub(a.value, a.value, b.value);
     }
 
-    static inline void multiply(value_type& r, value_type const& a, value_type const& b)
+    static inline void multiply(gmp_policy& r, gmp_policy const& a, gmp_policy const& b)
     {
-        mpf_mul(r, a, b);
+        mpf_mul(r.value, a.value, b.value);
     }
 
-    static inline void multiply(value_type& a, value_type const& b)
+    static inline void multiply(gmp_policy& a, gmp_policy const& b)
     {
-        mpf_mul(a, a, b);
+        mpf_mul(a.value, a.value, b.value);
     }
 
-    static inline void divide(value_type& r, value_type const& a, value_type const& b)
+    static inline void divide(gmp_policy& r, gmp_policy const& a, gmp_policy const& b)
     {
-        mpf_div(r, a, b);
+        mpf_div(r.value, a.value, b.value);
     }
 
-    static inline void divide(value_type& a, value_type const& b)
+    static inline void divide(gmp_policy& a, gmp_policy const& b)
     {
-        mpf_div(a, a, b);
+        mpf_div(a.value, a.value, b.value);
     }
 
-    static inline void neg(value_type& r, value_type const& n)
+    static inline void neg(gmp_policy& r, gmp_policy const& n)
     {
-        mpf_neg(r, n);
+        mpf_neg(r.value, n.value);
     }
 
-    static inline void abs(value_type& r, value_type const& a)
+    static inline void abs(gmp_policy& r, gmp_policy const& a)
     {
-        mpf_abs(r, a);
+        mpf_abs(r.value, a.value);
     }
 
-    static inline void sqrt(value_type& r, value_type const& a)
+    static inline void sqrt(gmp_policy& r, gmp_policy const& a)
     {
-        mpf_sqrt(r, a);
+        mpf_sqrt(r.value, a.value);
     }
 
-    static inline void hypot(value_type& r, value_type const& a, value_type const& b)
+    static inline void hypot(gmp_policy& r, gmp_policy const& a, gmp_policy const& b)
     {
-        mpf_mul(r, a, a);
+        mpf_mul(r.value, a.value, a.value);
         value_type t;
         mpf_init(t);
-        mpf_mul(t, b, b);
-        mpf_add(t, r, t);
-        mpf_sqrt(r, t);
+        mpf_mul(t, b.value, b.value);
+        mpf_add(t, r.value, t);
+        mpf_sqrt(r.value, t);
         mpf_clear(t);
     }
 
@@ -124,6 +124,12 @@
         return mpf_get_d(b);
     }
 
+    template <typename OtherType>
+    static inline OtherType big_numeric_cast(gmp_policy const& b)
+    {
+        return mpf_get_d(b.value);
+    }
+
 
     static inline std::string as_string(value_type const& a)
     {

Modified: sandbox/numeric_adaptor/boost/numeric_adaptor/ieee_policy.hpp
==============================================================================
--- sandbox/numeric_adaptor/boost/numeric_adaptor/ieee_policy.hpp	(original)
+++ sandbox/numeric_adaptor/boost/numeric_adaptor/ieee_policy.hpp	2009-07-10 09:40:30 EDT (Fri, 10 Jul 2009)
@@ -32,14 +32,18 @@
     typedef T value_type;
 
     template <typename OtherType>
-    static inline void set(value_type& value, OtherType const& v)   { value = v; } //boost::numeric_cast<T>(v); }
+    static inline void set(value_type& value, OtherType const& v)
+    { value = v; } //boost::numeric_cast<T>(v); }
 
-    static inline void set(value_type& value, std::string const& v) { value = boost::lexical_cast<T>(v); }
+    static inline void set(value_type& value, std::string const& v)
+    { value = boost::lexical_cast<T>(v); }
 
-    static inline void abs(value_type& r, value_type const& a) { r = std::abs(a); }
-    static inline void hypot(value_type& r, value_type const& a, value_type const& b)
+    static inline void abs(ieee_policy& r, ieee_policy const& a)
+    { r.value = std::abs(a.value); }
+
+    static inline void hypot(ieee_policy& r, ieee_policy const& a, ieee_policy const& b)
     {
-        r = boost::math::hypot(a, b);
+        r.value = boost::math::hypot(a.value, b.value);
     }
 
     template <typename OtherType>
@@ -47,6 +51,12 @@
     {
         return boost::numeric_cast<OtherType>(v);
     }
+
+    template <typename OtherType>
+    static inline OtherType big_numeric_cast(ieee_policy const& v)
+    {
+        return boost::numeric_cast<OtherType>(v.value);
+    }
 };
 
 

Modified: sandbox/numeric_adaptor/boost/numeric_adaptor/numeric_adaptor.hpp
==============================================================================
--- sandbox/numeric_adaptor/boost/numeric_adaptor/numeric_adaptor.hpp	(original)
+++ sandbox/numeric_adaptor/boost/numeric_adaptor/numeric_adaptor.hpp	2009-07-10 09:40:30 EDT (Fri, 10 Jul 2009)
@@ -130,15 +130,14 @@
         numeric_adaptor<Policy> const& a,
         numeric_adaptor<Policy> const& b)
     {
-        typename Policy::value_type r;
-        Policy::init(r);
-        Policy::add(r, a.value, b.value);
-        return numeric_adaptor<Policy>(r, true);
+        numeric_adaptor<Policy> r;
+        Policy::add(r, a, b);
+        return r;
     }
 
     numeric_adaptor<Policy>& operator+=(numeric_adaptor<Policy> const& other)
     {
-        Policy::add(Policy::value, other.value);
+        Policy::add(*this, other);
         return *this;
     }
 
@@ -146,15 +145,14 @@
         numeric_adaptor<Policy> const& a,
         numeric_adaptor<Policy> const& b)
     {
-        typename Policy::value_type r;
-        Policy::init(r);
-        Policy::multiply(r, a.value, b.value);
-        return numeric_adaptor<Policy>(r, true);
+        numeric_adaptor<Policy> r;
+        Policy::multiply(r, a, b);
+        return r;
     }
 
     numeric_adaptor<Policy>& operator*=(numeric_adaptor<Policy> const& other)
     {
-        Policy::multiply(Policy::value, other.value);
+        Policy::multiply(*this, other);
         return *this;
     }
 
@@ -162,15 +160,14 @@
         numeric_adaptor<Policy> const& a,
         numeric_adaptor<Policy> const& b)
     {
-        typename Policy::value_type r;
-        Policy::init(r);
-        Policy::subtract(r, a.value, b.value);
-        return numeric_adaptor<Policy>(r, true);
+        numeric_adaptor<Policy> r;
+        Policy::subtract(r, a, b);
+        return r;
     }
 
     numeric_adaptor<Policy>& operator-=(numeric_adaptor<Policy> const& other)
     {
-        Policy::subtract(Policy::value, other.value);
+        Policy::subtract(*this, other);
         return *this;
     }
 
@@ -178,24 +175,22 @@
         numeric_adaptor<Policy> const& a,
         numeric_adaptor<Policy> const& b)
     {
-        typename Policy::value_type r;
-        Policy::init(r);
-        Policy::divide(r, a.value, b.value);
-        return numeric_adaptor<Policy>(r, true);
+        numeric_adaptor<Policy> r;
+        Policy::divide(r, a, b);
+        return r;
     }
 
     numeric_adaptor<Policy>& operator/=(numeric_adaptor<Policy> const& other)
     {
-        Policy::divide(Policy::value, other.value);
+        Policy::divide(*this, other);
         return *this;
     }
 
     friend inline numeric_adaptor<Policy> operator-(numeric_adaptor<Policy> const& n)
     {
-        typename Policy::value_type r;
-        Policy::init(r);
-        Policy::neg(r, n.value);
-        return numeric_adaptor<Policy>(r, true);
+        numeric_adaptor<Policy> r;
+        Policy::neg(r, n);
+        return r;
     }
 
     // Construct from a policy-type. Bool (or any other signature changing parameter)
@@ -211,55 +206,49 @@
 template <typename Policy>
 inline numeric_adaptor<Policy> abs(numeric_adaptor<Policy> const& v)
 {
-    typename Policy::value_type r;
-    Policy::init(r);
-    Policy::abs(r, v.value);
-    return numeric_adaptor<Policy>(r, true);
+    numeric_adaptor<Policy> r;
+    Policy::abs(r, v);
+    return r;
 }
 
 template <typename Policy>
 inline numeric_adaptor<Policy> sqrt(numeric_adaptor<Policy> const& v)
 {
-    typename Policy::value_type r;
-    Policy::init(r);
-    Policy::sqrt(r, v.value);
-    return numeric_adaptor<Policy>(r, true);
+    numeric_adaptor<Policy> r;
+    Policy::sqrt(r, v);
+    return r;
 }
 
 template <typename Policy>
 inline numeric_adaptor<Policy> cos(numeric_adaptor<Policy> const& v)
 {
-    typename Policy::value_type r;
-    Policy::init(r);
-    Policy::cos(r, v.value);
-    return numeric_adaptor<Policy>(r, true);
+    numeric_adaptor<Policy> r;
+    Policy::cos(r, v);
+    return r;
 }
 
 template <typename Policy>
 inline numeric_adaptor<Policy> sin(numeric_adaptor<Policy> const& v)
 {
-    typename Policy::value_type r;
-    Policy::init(r);
-    Policy::sin(r, v.value);
-    return numeric_adaptor<Policy>(r, true);
+    numeric_adaptor<Policy> r;
+    Policy::sin(r, v);
+    return r;
 }
 
 template <typename Policy>
 inline numeric_adaptor<Policy> tan(numeric_adaptor<Policy> const& v)
 {
-    typename Policy::value_type r;
-    Policy::init(r);
-    Policy::tan(r, v.value);
-    return numeric_adaptor<Policy>(r, true);
+    numeric_adaptor<Policy> r;
+    Policy::tan(r, v);
+    return r;
 }
 
 template <typename Policy>
 inline numeric_adaptor<Policy> atan(numeric_adaptor<Policy> const& v)
 {
-    typename Policy::value_type r;
-    Policy::init(r);
-    Policy::atan(r, v.value);
-    return numeric_adaptor<Policy>(r, true);
+    numeric_adaptor<Policy> r;
+    Policy::atan(r, v);
+    return r;
 }
 
 
@@ -267,10 +256,9 @@
 inline numeric_adaptor<Policy> hypot(numeric_adaptor<Policy> const& a,
                                      numeric_adaptor<Policy> const& b)
 {
-    typename Policy::value_type r;
-    Policy::init(r);
-    Policy::hypot(r, a.value, b.value);
-    return numeric_adaptor<Policy>(r, true);
+    numeric_adaptor<Policy> r;
+    Policy::hypot(r, a, b);
+    return r;
 }