Subject: [Boost-commit] svn:boost r73528 - in sandbox/e_float: boost/e_float libs/e_float/src/e_float libs/e_float/src/e_float/efx libs/e_float/src/functions/constants libs/e_float/src/functions/elementary libs/e_float/test/real libs/e_float/test/real/cases
From: e_float_at_[hidden]
Date: 2011-08-04 11:12:02
Author: christopher_kormanyos
Date: 2011-08-04 11:11:59 EDT (Thu, 04 Aug 2011)
New Revision: 73528
URL: http://svn.boost.org/trac/boost/changeset/73528
Log:
- Continued progress toward compatibility with the bindings of Boost.Math.
- Added more test cases with operations with PODs.
Text files modified:
sandbox/e_float/boost/e_float/e_float_base.hpp | 21 ++-
sandbox/e_float/boost/e_float/e_float_constants.hpp | 140 ++++++++++++++-------------
sandbox/e_float/boost/e_float/e_float_efx.hpp | 6
sandbox/e_float/boost/e_float/e_float_elementary_complex.hpp | 8 -
sandbox/e_float/boost/e_float/e_float_global_math.hpp | 204 ++++++++++++++++++++++++++++++++++++---
sandbox/e_float/libs/e_float/src/e_float/e_float_base.cpp | 39 +++++++
sandbox/e_float/libs/e_float/src/e_float/efx/e_float_efx.cpp | 58 +++++-----
sandbox/e_float/libs/e_float/src/functions/constants/constants.cpp | 92 ++++++++++++++++++
sandbox/e_float/libs/e_float/src/functions/elementary/elementary_trans.cpp | 4
sandbox/e_float/libs/e_float/test/real/cases/test_case_0000z_global_ops_pod.cpp | 61 ++++++++++-
sandbox/e_float/libs/e_float/test/real/test_real.cpp | 6
11 files changed, 496 insertions(+), 143 deletions(-)
Modified: sandbox/e_float/boost/e_float/e_float_base.hpp
==============================================================================
--- sandbox/e_float/boost/e_float/e_float_base.hpp (original)
+++ sandbox/e_float/boost/e_float/e_float_base.hpp 2011-08-04 11:11:59 EDT (Thu, 04 Aug 2011)
@@ -73,13 +73,20 @@
virtual void precision(const INT32) = 0;
// Basic operations.
- virtual e_float_base& operator= (const e_float&) = 0;
- virtual e_float_base& operator+=(const e_float&) = 0;
- virtual e_float_base& operator-=(const e_float&) = 0;
- virtual e_float_base& operator*=(const e_float&) = 0;
- virtual e_float_base& operator/=(const e_float&) = 0;
- virtual e_float_base& mul_by_int(const INT32) = 0;
- virtual e_float_base& div_by_int(const INT32) = 0;
+ virtual e_float& operator= (const e_float&) = 0;
+ virtual e_float& operator+=(const e_float&) = 0;
+ virtual e_float& operator-=(const e_float&) = 0;
+ virtual e_float& operator*=(const e_float&) = 0;
+ virtual e_float& operator/=(const e_float&) = 0;
+ virtual e_float& add_unsigned_long_long(const unsigned long long) = 0;
+ virtual e_float& sub_unsigned_long_long(const unsigned long long) = 0;
+ virtual e_float& mul_unsigned_long_long(const unsigned long long) = 0;
+ virtual e_float& div_unsigned_long_long(const unsigned long long) = 0;
+
+ e_float& add_signed_long_long(const signed long long);
+ e_float& sub_signed_long_long(const signed long long);
+ e_float& mul_signed_long_long(const signed long long);
+ e_float& div_signed_long_long(const signed long long);
virtual e_float_base& calculate_inv (void) = 0;
virtual e_float_base& calculate_sqrt(void) = 0;
Modified: sandbox/e_float/boost/e_float/e_float_constants.hpp
==============================================================================
--- sandbox/e_float/boost/e_float/e_float_constants.hpp (original)
+++ sandbox/e_float/boost/e_float/e_float_constants.hpp 2011-08-04 11:11:59 EDT (Thu, 04 Aug 2011)
@@ -15,74 +15,78 @@
namespace ef
{
- const e_float& two (void);
- const e_float& three (void);
- const e_float& four (void);
- const e_float& five (void);
- const e_float& six (void);
- const e_float& seven (void);
- const e_float& eight (void);
- const e_float& nine (void);
- const e_float& ten (void);
- const e_float& twenty (void);
- const e_float& thirty (void);
- const e_float& forty (void);
- const e_float& fifty (void);
- const e_float& hundred (void);
- const e_float& two_hundred (void);
- const e_float& three_hundred(void);
- const e_float& four_hundred (void);
- const e_float& five_hundred (void);
- const e_float& thousand (void);
- const e_float& two_k (void);
- const e_float& three_k (void);
- const e_float& four_k (void);
- const e_float& five_k (void);
- const e_float& ten_k (void);
- const e_float& twenty_k (void);
- const e_float& thirty_k (void);
- const e_float& forty_k (void);
- const e_float& fifty_k (void);
- const e_float& hundred_k (void);
- const e_float& million (void);
- const e_float& ten_M (void);
- const e_float& hundred_M (void);
- const e_float& billion (void);
- const e_float& trillion (void);
- const e_float& googol (void);
- const e_float& int32max (void);
- const e_float& int32min (void);
- const e_float& int64max (void);
- const e_float& int64min (void);
- const e_float& one_minus (void);
- const e_float& tenth (void);
- const e_float& eighth (void);
- const e_float& sixteenth (void);
- const e_float& fifth (void);
- const e_float& quarter (void);
- const e_float& third (void);
- const e_float& two_third (void);
- const e_float& four_third (void);
- const e_float& three_half (void);
- const e_float& sqrt2 (void);
- const e_float& sqrt3 (void);
- const e_float& pi (void);
- const e_float& pi_half (void);
- const e_float& pi_quarter (void);
- const e_float& pi_squared (void);
- const e_float& two_pi (void);
- const e_float& sqrt_pi (void);
- const e_float& degree (void);
- const e_float& exp1 (void);
- const e_float& ln2 (void);
- const e_float& ln3 (void);
- const e_float& ln10 (void);
- const e_float& log10_2 (void);
- const e_float& golden_ratio (void);
- const e_float& euler_gamma (void);
- const e_float& catalan (void);
- const e_float& khinchin (void);
- const e_float& glaisher (void);
+ const e_float& two (void);
+ const e_float& three (void);
+ const e_float& four (void);
+ const e_float& five (void);
+ const e_float& six (void);
+ const e_float& seven (void);
+ const e_float& eight (void);
+ const e_float& nine (void);
+ const e_float& ten (void);
+ const e_float& twenty (void);
+ const e_float& thirty (void);
+ const e_float& forty (void);
+ const e_float& fifty (void);
+ const e_float& hundred (void);
+ const e_float& two_hundred (void);
+ const e_float& three_hundred (void);
+ const e_float& four_hundred (void);
+ const e_float& five_hundred (void);
+ const e_float& thousand (void);
+ const e_float& two_k (void);
+ const e_float& three_k (void);
+ const e_float& four_k (void);
+ const e_float& five_k (void);
+ const e_float& ten_k (void);
+ const e_float& twenty_k (void);
+ const e_float& thirty_k (void);
+ const e_float& forty_k (void);
+ const e_float& fifty_k (void);
+ const e_float& hundred_k (void);
+ const e_float& million (void);
+ const e_float& ten_M (void);
+ const e_float& hundred_M (void);
+ const e_float& billion (void);
+ const e_float& trillion (void);
+ const e_float& googol (void);
+ const e_float& int32max (void);
+ const e_float& int32min (void);
+ const e_float& int64max (void);
+ const e_float& int64min (void);
+ const e_float& one_minus (void);
+ const e_float& tenth (void);
+ const e_float& eighth (void);
+ const e_float& sixteenth (void);
+ const e_float& fifth (void);
+ const e_float& quarter (void);
+ const e_float& third (void);
+ const e_float& two_third (void);
+ const e_float& four_third (void);
+ const e_float& three_half (void);
+ const e_float& sqrt2 (void);
+ const e_float& sqrt3 (void);
+ const e_float& pi (void);
+ const e_float& pi_half (void);
+ const e_float& pi_quarter (void);
+ const e_float& pi_squared (void);
+ const e_float& two_pi (void);
+ const e_float& sqrt_pi (void);
+ const e_float& degree (void);
+ const e_float& exp1 (void);
+ const e_float& ln2 (void);
+ const e_float& ln3 (void);
+ const e_float& ln10 (void);
+ const e_float& log10_2 (void);
+ const e_float& golden_ratio (void);
+ const e_float& euler_gamma (void);
+ const e_float& catalan (void);
+ const e_float& khinchin (void);
+ const e_float& glaisher (void);
+ const e_float& extreme_value_skewness (void);
+ const e_float& rayleigh_skewness (void);
+ const e_float& rayleigh_kurtosis (void);
+ const e_float& rayleigh_kurtosis_excess(void);
}
#endif // _E_FLOAT_CONSTANTS_HPP_
Modified: sandbox/e_float/boost/e_float/e_float_efx.hpp
==============================================================================
--- sandbox/e_float/boost/e_float/e_float_efx.hpp (original)
+++ sandbox/e_float/boost/e_float/e_float_efx.hpp 2011-08-04 11:11:59 EDT (Thu, 04 Aug 2011)
@@ -123,8 +123,10 @@
virtual e_float& operator-=(const e_float& v);
virtual e_float& operator*=(const e_float& v);
virtual e_float& operator/=(const e_float& v);
- virtual e_float& mul_by_int(const INT32 n);
- virtual e_float& div_by_int(const INT32 n);
+ virtual e_float& add_unsigned_long_long(const unsigned long long n);
+ virtual e_float& sub_unsigned_long_long(const unsigned long long n);
+ virtual e_float& mul_unsigned_long_long(const unsigned long long n);
+ virtual e_float& div_unsigned_long_long(const unsigned long long n);
virtual e_float& calculate_inv (void);
virtual e_float& calculate_sqrt(void);
Modified: sandbox/e_float/boost/e_float/e_float_elementary_complex.hpp
==============================================================================
--- sandbox/e_float/boost/e_float/e_float_elementary_complex.hpp (original)
+++ sandbox/e_float/boost/e_float/e_float_elementary_complex.hpp 2011-08-04 11:11:59 EDT (Thu, 04 Aug 2011)
@@ -66,16 +66,10 @@
inline ef_complex operator++(ef_complex& u, int) { const ef_complex v(u); ++u; return v; }
inline ef_complex operator--(ef_complex& u, int) { const ef_complex v(u); --u; return v; }
+ // Global comparison operators
inline bool operator==(const ef_complex& u, const ef_complex& v) { return (u.real() == v.real()) && (u.imag() == v.imag()); }
inline bool operator!=(const ef_complex& u, const ef_complex& v) { return (u.real() != v.real()) || (u.imag() != v.imag()); }
- // Global comparison operators
- bool operator==(const ef_complex& u, const e_float& v);
- bool operator!=(const ef_complex& u, const e_float& v);
-
- bool operator==(const e_float& u, const ef_complex& v);
- bool operator!=(const e_float& u, const ef_complex& v);
-
// Global arithmetic operators with const ef_complex&, const e_float& and INT32
inline ef_complex operator+(const ef_complex& u, const ef_complex& v) { return ef_complex(u) += v; }
inline ef_complex operator-(const ef_complex& u, const ef_complex& v) { return ef_complex(u) -= v; }
Modified: sandbox/e_float/boost/e_float/e_float_global_math.hpp
==============================================================================
--- sandbox/e_float/boost/e_float/e_float_global_math.hpp (original)
+++ sandbox/e_float/boost/e_float/e_float_global_math.hpp 2011-08-04 11:11:59 EDT (Thu, 04 Aug 2011)
@@ -17,7 +17,7 @@
inline e_float fabs(const e_float& x) { return (x.isneg() ? e_float(x).negate() : x); }
}
- // Global operators post-increment and post-decrement
+ // Global operators post-increment and post-decrement.
inline e_float operator++(e_float& u, int) { const e_float v(u); ++u; return v; }
inline e_float operator--(e_float& u, int) { const e_float v(u); --u; return v; }
@@ -26,30 +26,196 @@
inline e_float& operator+( e_float& u) { return u; }
inline const e_float& operator+(const e_float& u) { return u; }
- // Global add/sub/mul/div of const e_float reference with const e_float reference
+ // Global add/sub/mul/div of const e_float& with const e_float&.
inline e_float operator+(const e_float& u, const e_float& v) { return e_float(u) += v; }
inline e_float operator-(const e_float& u, const e_float& v) { return e_float(u) -= v; }
inline e_float operator*(const e_float& u, const e_float& v) { return e_float(u) *= v; }
inline e_float operator/(const e_float& u, const e_float& v) { return e_float(u) /= v; }
- // Specialization for global add/sub/mul/div of const e_float reference with INT32
- inline e_float operator+(const e_float& u, const INT32 n) { return (e_float(u) += e_float(n)); }
- inline e_float operator-(const e_float& u, const INT32 n) { return (e_float(u) -= e_float(n)); }
- inline e_float operator*(const e_float& u, const INT32 n) { return e_float(u).mul_by_int(n); }
- inline e_float operator/(const e_float& u, const INT32 n) { return e_float(u).div_by_int(n); }
-
- inline e_float operator+(const INT32 n, const e_float& u) { return (e_float(n) += u); }
- inline e_float operator-(const INT32 n, const e_float& u) { return (e_float(n) -= u); }
- inline e_float operator*(const INT32 n, const e_float& u) { return (e_float(n) *= u); }
- inline e_float operator/(const INT32 n, const e_float& u) { return (e_float(n) /= u); }
-
- // Specializations of global self-add/sub/mul-div of e_float reference with INT32
- inline e_float& operator+=(e_float& u, const INT32 n) { return (u += e_float(n)); }
- inline e_float& operator-=(e_float& u, const INT32 n) { return (u -= e_float(n)); }
- inline e_float& operator*=(e_float& u, const INT32 n) { return u.mul_by_int(n); }
- inline e_float& operator/=(e_float& u, const INT32 n) { return u.div_by_int(n); }
+ // Global add/sub/mul/div of const e_float& with all built-in types.
+ inline e_float operator+(const e_float& u, const signed char n) { return e_float(u).add_signed_long_long (static_cast< signed long long>(n)); }
+ inline e_float operator+(const e_float& u, const signed short n) { return e_float(u).add_signed_long_long (static_cast< signed long long>(n)); }
+ inline e_float operator+(const e_float& u, const signed int n) { return e_float(u).add_signed_long_long (static_cast< signed long long>(n)); }
+ inline e_float operator+(const e_float& u, const signed long n) { return e_float(u).add_signed_long_long (static_cast< signed long long>(n)); }
+ inline e_float operator+(const e_float& u, const signed long long n) { return e_float(u).add_signed_long_long (static_cast< signed long long>(n)); }
+ inline e_float operator+(const e_float& u, const unsigned char n) { return e_float(u).add_unsigned_long_long(static_cast<unsigned long long>(n)); }
+ inline e_float operator+(const e_float& u, const wchar_t n) { return e_float(u).add_unsigned_long_long(static_cast<unsigned long long>(n)); }
+ inline e_float operator+(const e_float& u, const unsigned short n) { return e_float(u).add_unsigned_long_long(static_cast<unsigned long long>(n)); }
+ inline e_float operator+(const e_float& u, const unsigned int n) { return e_float(u).add_unsigned_long_long(static_cast<unsigned long long>(n)); }
+ inline e_float operator+(const e_float& u, const unsigned long n) { return e_float(u).add_unsigned_long_long(static_cast<unsigned long long>(n)); }
+ inline e_float operator+(const e_float& u, const unsigned long long n) { return e_float(u).add_unsigned_long_long(static_cast<unsigned long long>(n)); }
+ inline e_float operator+(const e_float& u, const float f) { return e_float(u) += e_float(f); }
+ inline e_float operator+(const e_float& u, const double d) { return e_float(u) += e_float(d); }
+ inline e_float operator+(const e_float& u, const long double ld) { return e_float(u) += e_float(ld); }
+
+ inline e_float operator-(const e_float& u, const signed char n) { return e_float(u).sub_signed_long_long (static_cast< signed long long>(n)); }
+ inline e_float operator-(const e_float& u, const signed short n) { return e_float(u).sub_signed_long_long (static_cast< signed long long>(n)); }
+ inline e_float operator-(const e_float& u, const signed int n) { return e_float(u).sub_signed_long_long (static_cast< signed long long>(n)); }
+ inline e_float operator-(const e_float& u, const signed long n) { return e_float(u).sub_signed_long_long (static_cast< signed long long>(n)); }
+ inline e_float operator-(const e_float& u, const signed long long n) { return e_float(u).sub_signed_long_long (static_cast< signed long long>(n)); }
+ inline e_float operator-(const e_float& u, const unsigned char n) { return e_float(u).sub_unsigned_long_long(static_cast<unsigned long long>(n)); }
+ inline e_float operator-(const e_float& u, const wchar_t n) { return e_float(u).sub_unsigned_long_long(static_cast<unsigned long long>(n)); }
+ inline e_float operator-(const e_float& u, const unsigned short n) { return e_float(u).sub_unsigned_long_long(static_cast<unsigned long long>(n)); }
+ inline e_float operator-(const e_float& u, const unsigned int n) { return e_float(u).sub_unsigned_long_long(static_cast<unsigned long long>(n)); }
+ inline e_float operator-(const e_float& u, const unsigned long n) { return e_float(u).sub_unsigned_long_long(static_cast<unsigned long long>(n)); }
+ inline e_float operator-(const e_float& u, const unsigned long long n) { return e_float(u).sub_unsigned_long_long(static_cast<unsigned long long>(n)); }
+ inline e_float operator-(const e_float& u, const float f) { return e_float(u) -= e_float(f); }
+ inline e_float operator-(const e_float& u, const double d) { return e_float(u) -= e_float(d); }
+ inline e_float operator-(const e_float& u, const long double ld) { return e_float(u) -= e_float(ld); }
+
+ inline e_float operator*(const e_float& u, const signed char n) { return e_float(u).mul_signed_long_long (static_cast< signed long long>(n)); }
+ inline e_float operator*(const e_float& u, const signed short n) { return e_float(u).mul_signed_long_long (static_cast< signed long long>(n)); }
+ inline e_float operator*(const e_float& u, const signed int n) { return e_float(u).mul_signed_long_long (static_cast< signed long long>(n)); }
+ inline e_float operator*(const e_float& u, const signed long n) { return e_float(u).mul_signed_long_long (static_cast< signed long long>(n)); }
+ inline e_float operator*(const e_float& u, const signed long long n) { return e_float(u).mul_signed_long_long (static_cast< signed long long>(n)); }
+ inline e_float operator*(const e_float& u, const unsigned char n) { return e_float(u).mul_unsigned_long_long(static_cast<unsigned long long>(n)); }
+ inline e_float operator*(const e_float& u, const wchar_t n) { return e_float(u).mul_unsigned_long_long(static_cast<unsigned long long>(n)); }
+ inline e_float operator*(const e_float& u, const unsigned short n) { return e_float(u).mul_unsigned_long_long(static_cast<unsigned long long>(n)); }
+ inline e_float operator*(const e_float& u, const unsigned int n) { return e_float(u).mul_unsigned_long_long(static_cast<unsigned long long>(n)); }
+ inline e_float operator*(const e_float& u, const unsigned long n) { return e_float(u).mul_unsigned_long_long(static_cast<unsigned long long>(n)); }
+ inline e_float operator*(const e_float& u, const unsigned long long n) { return e_float(u).mul_unsigned_long_long(static_cast<unsigned long long>(n)); }
+ inline e_float operator*(const e_float& u, const float f) { return e_float(u) *= e_float(f); }
+ inline e_float operator*(const e_float& u, const double d) { return e_float(u) *= e_float(d); }
+ inline e_float operator*(const e_float& u, const long double ld) { return e_float(u) *= e_float(ld); }
+
+ inline e_float operator/(const e_float& u, const signed char n) { return e_float(u).div_signed_long_long (static_cast< signed long long>(n)); }
+ inline e_float operator/(const e_float& u, const signed short n) { return e_float(u).div_signed_long_long (static_cast< signed long long>(n)); }
+ inline e_float operator/(const e_float& u, const signed int n) { return e_float(u).div_signed_long_long (static_cast< signed long long>(n)); }
+ inline e_float operator/(const e_float& u, const signed long n) { return e_float(u).div_signed_long_long (static_cast< signed long long>(n)); }
+ inline e_float operator/(const e_float& u, const signed long long n) { return e_float(u).div_signed_long_long (static_cast< signed long long>(n)); }
+ inline e_float operator/(const e_float& u, const unsigned char n) { return e_float(u).div_unsigned_long_long(static_cast<unsigned long long>(n)); }
+ inline e_float operator/(const e_float& u, const wchar_t n) { return e_float(u).div_unsigned_long_long(static_cast<unsigned long long>(n)); }
+ inline e_float operator/(const e_float& u, const unsigned short n) { return e_float(u).div_unsigned_long_long(static_cast<unsigned long long>(n)); }
+ inline e_float operator/(const e_float& u, const unsigned int n) { return e_float(u).div_unsigned_long_long(static_cast<unsigned long long>(n)); }
+ inline e_float operator/(const e_float& u, const unsigned long n) { return e_float(u).div_unsigned_long_long(static_cast<unsigned long long>(n)); }
+ inline e_float operator/(const e_float& u, const unsigned long long n) { return e_float(u).div_unsigned_long_long(static_cast<unsigned long long>(n)); }
+ inline e_float operator/(const e_float& u, const float f) { return e_float(u) /= e_float(f); }
+ inline e_float operator/(const e_float& u, const double d) { return e_float(u) /= e_float(d); }
+ inline e_float operator/(const e_float& u, const long double ld) { return e_float(u) /= e_float(ld); }
+
+ // Global add/sub/mul/div of all built-in types with const e_float&.
+ inline e_float operator+(const signed char n, const e_float& u) { return e_float(u).add_signed_long_long(n); }
+ inline e_float operator+(const signed short n, const e_float& u) { return e_float(u).add_signed_long_long(n); }
+ inline e_float operator+(const signed int n, const e_float& u) { return e_float(u).add_signed_long_long(n); }
+ inline e_float operator+(const signed long n, const e_float& u) { return e_float(u).add_signed_long_long(n); }
+ inline e_float operator+(const signed long long n, const e_float& u) { return e_float(u).add_signed_long_long(n); }
+ inline e_float operator+(const unsigned char n, const e_float& u) { return e_float(u).add_unsigned_long_long(n); }
+ inline e_float operator+(const wchar_t n, const e_float& u) { return e_float(u).add_unsigned_long_long(n); }
+ inline e_float operator+(const unsigned short n, const e_float& u) { return e_float(u).add_unsigned_long_long(n); }
+ inline e_float operator+(const unsigned int n, const e_float& u) { return e_float(u).add_unsigned_long_long(n); }
+ inline e_float operator+(const unsigned long n, const e_float& u) { return e_float(u).add_unsigned_long_long(n); }
+ inline e_float operator+(const unsigned long long n, const e_float& u) { return e_float(u).add_unsigned_long_long(n); }
+ inline e_float operator+(const float f, const e_float& u) { return e_float(f) += u; }
+ inline e_float operator+(const double d, const e_float& u) { return e_float(d) += u; }
+ inline e_float operator+(const long double ld, const e_float& u) { return e_float(ld) += u; }
+
+ inline e_float operator-(const signed char n, const e_float& u) { return e_float(n) -= u; }
+ inline e_float operator-(const signed short n, const e_float& u) { return e_float(n) -= u; }
+ inline e_float operator-(const signed int n, const e_float& u) { return e_float(n) -= u; }
+ inline e_float operator-(const signed long n, const e_float& u) { return e_float(n) -= u; }
+ inline e_float operator-(const signed long long n, const e_float& u) { return e_float(n) -= u; }
+ inline e_float operator-(const unsigned char n, const e_float& u) { return e_float(n) -= u; }
+ inline e_float operator-(const wchar_t n, const e_float& u) { return e_float(n) -= u; }
+ inline e_float operator-(const unsigned short n, const e_float& u) { return e_float(n) -= u; }
+ inline e_float operator-(const unsigned int n, const e_float& u) { return e_float(n) -= u; }
+ inline e_float operator-(const unsigned long n, const e_float& u) { return e_float(n) -= u; }
+ inline e_float operator-(const unsigned long long n, const e_float& u) { return e_float(n) -= u; }
+ inline e_float operator-(const float f, const e_float& u) { return e_float(f) -= u; }
+ inline e_float operator-(const double d, const e_float& u) { return e_float(d) -= u; }
+ inline e_float operator-(const long double ld, const e_float& u) { return e_float(ld) -= u; }
+
+ inline e_float operator*(const signed char n, const e_float& u) { return e_float(u).mul_signed_long_long(n); }
+ inline e_float operator*(const signed short n, const e_float& u) { return e_float(u).mul_signed_long_long(n); }
+ inline e_float operator*(const signed int n, const e_float& u) { return e_float(u).mul_signed_long_long(n); }
+ inline e_float operator*(const signed long n, const e_float& u) { return e_float(u).mul_signed_long_long(n); }
+ inline e_float operator*(const signed long long n, const e_float& u) { return e_float(u).mul_signed_long_long(n); }
+ inline e_float operator*(const unsigned char n, const e_float& u) { return e_float(u).mul_unsigned_long_long(n); }
+ inline e_float operator*(const wchar_t n, const e_float& u) { return e_float(u).mul_unsigned_long_long(n); }
+ inline e_float operator*(const unsigned short n, const e_float& u) { return e_float(u).mul_unsigned_long_long(n); }
+ inline e_float operator*(const unsigned int n, const e_float& u) { return e_float(u).mul_unsigned_long_long(n); }
+ inline e_float operator*(const unsigned long n, const e_float& u) { return e_float(u).mul_unsigned_long_long(n); }
+ inline e_float operator*(const unsigned long long n, const e_float& u) { return e_float(u).mul_unsigned_long_long(n); }
+ inline e_float operator*(const float f, const e_float& u) { return e_float(f) *= u; }
+ inline e_float operator*(const double d, const e_float& u) { return e_float(d) *= u; }
+ inline e_float operator*(const long double ld, const e_float& u) { return e_float(ld) *= u; }
+
+ inline e_float operator/(const signed char n, const e_float& u) { return e_float(n) /= u; }
+ inline e_float operator/(const signed short n, const e_float& u) { return e_float(n) /= u; }
+ inline e_float operator/(const signed int n, const e_float& u) { return e_float(n) /= u; }
+ inline e_float operator/(const signed long n, const e_float& u) { return e_float(n) /= u; }
+ inline e_float operator/(const signed long long n, const e_float& u) { return e_float(n) /= u; }
+ inline e_float operator/(const unsigned char n, const e_float& u) { return e_float(n) /= u; }
+ inline e_float operator/(const wchar_t n, const e_float& u) { return e_float(n) /= u; }
+ inline e_float operator/(const unsigned short n, const e_float& u) { return e_float(n) /= u; }
+ inline e_float operator/(const unsigned int n, const e_float& u) { return e_float(n) /= u; }
+ inline e_float operator/(const unsigned long n, const e_float& u) { return e_float(n) /= u; }
+ inline e_float operator/(const unsigned long long n, const e_float& u) { return e_float(n) /= u; }
+ inline e_float operator/(const float f, const e_float& u) { return e_float(f) /= u; }
+ inline e_float operator/(const double d, const e_float& u) { return e_float(d) /= u; }
+ inline e_float operator/(const long double ld, const e_float& u) { return e_float(ld) /= u; }
+
+ // Global self add/sub/mul/div of e_float& with all built-in types.
+ inline e_float& operator+=(e_float& u, const signed char n) { return u.add_signed_long_long(n); }
+ inline e_float& operator+=(e_float& u, const signed short n) { return u.add_signed_long_long(n); }
+ inline e_float& operator+=(e_float& u, const signed int n) { return u.add_signed_long_long(n); }
+ inline e_float& operator+=(e_float& u, const signed long n) { return u.add_signed_long_long(n); }
+ inline e_float& operator+=(e_float& u, const signed long long n) { return u.add_signed_long_long(n); }
+ inline e_float& operator+=(e_float& u, const unsigned char n) { return u.add_unsigned_long_long(n); }
+ inline e_float& operator+=(e_float& u, const wchar_t n) { return u.add_unsigned_long_long(n); }
+ inline e_float& operator+=(e_float& u, const unsigned short n) { return u.add_unsigned_long_long(n); }
+ inline e_float& operator+=(e_float& u, const unsigned int n) { return u.add_unsigned_long_long(n); }
+ inline e_float& operator+=(e_float& u, const unsigned long n) { return u.add_unsigned_long_long(n); }
+ inline e_float& operator+=(e_float& u, const unsigned long long n) { return u.add_unsigned_long_long(n); }
+ inline e_float& operator+=(e_float& u, const float f) { return u += e_float(f); }
+ inline e_float& operator+=(e_float& u, const double d) { return u += e_float(d); }
+ inline e_float& operator+=(e_float& u, const long double ld) { return u += e_float(ld); }
+
+ inline e_float& operator-=(e_float& u, const signed char n) { return u.sub_signed_long_long(n); }
+ inline e_float& operator-=(e_float& u, const signed short n) { return u.sub_signed_long_long(n); }
+ inline e_float& operator-=(e_float& u, const signed int n) { return u.sub_signed_long_long(n); }
+ inline e_float& operator-=(e_float& u, const signed long n) { return u.sub_signed_long_long(n); }
+ inline e_float& operator-=(e_float& u, const signed long long n) { return u.sub_signed_long_long(n); }
+ inline e_float& operator-=(e_float& u, const unsigned char n) { return u.sub_unsigned_long_long(n); }
+ inline e_float& operator-=(e_float& u, const wchar_t n) { return u.sub_unsigned_long_long(n); }
+ inline e_float& operator-=(e_float& u, const unsigned short n) { return u.sub_unsigned_long_long(n); }
+ inline e_float& operator-=(e_float& u, const unsigned int n) { return u.sub_unsigned_long_long(n); }
+ inline e_float& operator-=(e_float& u, const unsigned long n) { return u.sub_unsigned_long_long(n); }
+ inline e_float& operator-=(e_float& u, const unsigned long long n) { return u.sub_unsigned_long_long(n); }
+ inline e_float& operator-=(e_float& u, const float f) { return u -= e_float(f); }
+ inline e_float& operator-=(e_float& u, const double d) { return u -= e_float(d); }
+ inline e_float& operator-=(e_float& u, const long double ld) { return u -= e_float(ld); }
+
+ inline e_float& operator*=(e_float& u, const signed char n) { return u.mul_signed_long_long(n); }
+ inline e_float& operator*=(e_float& u, const signed short n) { return u.mul_signed_long_long(n); }
+ inline e_float& operator*=(e_float& u, const signed int n) { return u.mul_signed_long_long(n); }
+ inline e_float& operator*=(e_float& u, const signed long n) { return u.mul_signed_long_long(n); }
+ inline e_float& operator*=(e_float& u, const signed long long n) { return u.mul_signed_long_long(n); }
+ inline e_float& operator*=(e_float& u, const unsigned char n) { return u.mul_unsigned_long_long(n); }
+ inline e_float& operator*=(e_float& u, const wchar_t n) { return u.mul_unsigned_long_long(n); }
+ inline e_float& operator*=(e_float& u, const unsigned short n) { return u.mul_unsigned_long_long(n); }
+ inline e_float& operator*=(e_float& u, const unsigned int n) { return u.mul_unsigned_long_long(n); }
+ inline e_float& operator*=(e_float& u, const unsigned long n) { return u.mul_unsigned_long_long(n); }
+ inline e_float& operator*=(e_float& u, const unsigned long long n) { return u.mul_unsigned_long_long(n); }
+ inline e_float& operator*=(e_float& u, const float f) { return u *= e_float(f); }
+ inline e_float& operator*=(e_float& u, const double d) { return u *= e_float(d); }
+ inline e_float& operator*=(e_float& u, const long double ld) { return u *= e_float(ld); }
+
+ inline e_float& operator/=(e_float& u, const signed char n) { return u.div_signed_long_long(n); }
+ inline e_float& operator/=(e_float& u, const signed short n) { return u.div_signed_long_long(n); }
+ inline e_float& operator/=(e_float& u, const signed int n) { return u.div_signed_long_long(n); }
+ inline e_float& operator/=(e_float& u, const signed long n) { return u.div_signed_long_long(n); }
+ inline e_float& operator/=(e_float& u, const signed long long n) { return u.div_signed_long_long(n); }
+ inline e_float& operator/=(e_float& u, const unsigned char n) { return u.div_unsigned_long_long(n); }
+ inline e_float& operator/=(e_float& u, const wchar_t n) { return u.div_unsigned_long_long(n); }
+ inline e_float& operator/=(e_float& u, const unsigned short n) { return u.div_unsigned_long_long(n); }
+ inline e_float& operator/=(e_float& u, const unsigned int n) { return u.div_unsigned_long_long(n); }
+ inline e_float& operator/=(e_float& u, const unsigned long n) { return u.div_unsigned_long_long(n); }
+ inline e_float& operator/=(e_float& u, const unsigned long long n) { return u.div_unsigned_long_long(n); }
+ inline e_float& operator/=(e_float& u, const float f) { return u /= e_float(f); }
+ inline e_float& operator/=(e_float& u, const double d) { return u /= e_float(d); }
+ inline e_float& operator/=(e_float& u, const long double ld) { return u /= e_float(ld); }
- // Global comparison operators of const e_float reference with const e_float reference
+ // Global comparison operators of const e_float& with const e_float&.
inline bool operator< (const e_float& u, const e_float& v) { return (u.cmp(v) < static_cast<INT32>(0)); }
inline bool operator<=(const e_float& u, const e_float& v) { return (u.cmp(v) <= static_cast<INT32>(0)); }
inline bool operator==(const e_float& u, const e_float& v) { return (u.cmp(v) == static_cast<INT32>(0)); }
Modified: sandbox/e_float/libs/e_float/src/e_float/e_float_base.cpp
==============================================================================
--- sandbox/e_float/libs/e_float/src/e_float/e_float_base.cpp (original)
+++ sandbox/e_float/libs/e_float/src/e_float/e_float_base.cpp 2011-08-04 11:11:59 EDT (Thu, 04 Aug 2011)
@@ -33,6 +33,45 @@
return is;
}
+e_float& e_float_base::add_signed_long_long(const signed long long n)
+{
+ if(n < static_cast<signed long long>(0))
+ {
+ negate();
+ add_unsigned_long_long(static_cast<unsigned long long>(-n));
+ negate();
+ }
+ else
+ {
+ add_unsigned_long_long(static_cast<unsigned long long>(n));
+ }
+
+ return static_cast<e_float&>(*this);
+}
+
+e_float& e_float_base::sub_signed_long_long(const signed long long n)
+{
+ return add_signed_long_long(static_cast<signed long long>(-n));
+}
+
+e_float& e_float_base::mul_signed_long_long(const signed long long n)
+{
+ const bool b_neg = (n < static_cast<signed long long>(0));
+
+ mul_unsigned_long_long((!b_neg) ? static_cast<unsigned long long>(n) : static_cast<unsigned long long>(-n));
+
+ if(b_neg) { negate(); } return static_cast<e_float&>(*this);
+}
+
+e_float& e_float_base::div_signed_long_long(const signed long long n)
+{
+ const bool b_neg = (n < static_cast<signed long long>(0));
+
+ div_unsigned_long_long((!b_neg) ? static_cast<unsigned long long>(n) : static_cast<unsigned long long>(-n));
+
+ if(b_neg) { negate(); } return static_cast<e_float&>(*this);
+}
+
const std::string::size_type& e_float_base::width_of_exponent_field(void)
{
static const std::string::size_type width_of_e_n64 =
Modified: sandbox/e_float/libs/e_float/src/e_float/efx/e_float_efx.cpp
==============================================================================
--- sandbox/e_float/libs/e_float/src/e_float/efx/e_float_efx.cpp (original)
+++ sandbox/e_float/libs/e_float/src/e_float/efx/e_float_efx.cpp 2011-08-04 11:11:59 EDT (Thu, 04 Aug 2011)
@@ -238,11 +238,11 @@
if(p2 == 0) { }
else if((p2 > 0) && (p2 < 27))
{
- mul_by_int(static_cast<INT32>(1uL << p2));
+ mul_unsigned_long_long(static_cast<unsigned long long>(1uL << p2));
}
else if((p2 < 0) && (p2 > -27))
{
- div_by_int(static_cast<INT32>(1uL << -p2));
+ div_unsigned_long_long(static_cast<unsigned long long>(1uL << -p2));
}
else
{
@@ -282,11 +282,11 @@
if(p2 == 0) { }
else if((p2 > 0) && (p2 < 27))
{
- mul_by_int(static_cast<INT32>(1uL << p2));
+ mul_unsigned_long_long(static_cast<unsigned long long>(1uL << p2));
}
else if((p2 < 0) && (p2 > -27))
{
- div_by_int(static_cast<INT32>(1uL << -p2));
+ div_unsigned_long_long(static_cast<unsigned long long>(1uL << -p2));
}
else
{
@@ -330,11 +330,11 @@
if(p2 == 0) { }
else if((p2 > 0) && (p2 < 27))
{
- mul_by_int(static_cast<INT32>(1uL << p2));
+ mul_unsigned_long_long(static_cast<unsigned long long>(1uL << p2));
}
else if((p2 < 0) && (p2 > -27))
{
- div_by_int(static_cast<INT32>(1uL << -p2));
+ div_unsigned_long_long(static_cast<unsigned long long>(1uL << -p2));
}
else
{
@@ -923,19 +923,19 @@
}
}
-efx::e_float& efx::e_float::mul_by_int(const INT32 n)
+efx::e_float& efx::e_float::add_unsigned_long_long(const unsigned long long n) { return operator+=(e_float(n)); }
+efx::e_float& efx::e_float::sub_unsigned_long_long(const unsigned long long n) { return operator-=(e_float(n)); }
+
+efx::e_float& efx::e_float::mul_unsigned_long_long(const unsigned long long n)
{
- // Multiply *this with a constant signed integer.
- const bool b_n_is_neg = (n < static_cast<INT32>(0));
+ // Multiply *this with a constant unsigned long long.
// Evaluate the sign of the result.
- const bool b_result_is_neg = (neg != b_n_is_neg);
+ const bool b_neg = neg;
// Artificially set the sign of the result to be positive.
neg = false;
- const UINT32 nn = ((!b_n_is_neg) ? n : static_cast<UINT32>(-n));
-
// Handle special cases like zero, inf and NaN.
const bool b_u_is_inf = isinf();
const bool b_n_is_zero = (n == static_cast<INT32>(0));
@@ -947,8 +947,8 @@
if(b_u_is_inf)
{
- *this = ((!b_result_is_neg) ? std::numeric_limits<e_float>::infinity()
- : -std::numeric_limits<e_float>::infinity());
+ *this = ((!b_neg) ? std::numeric_limits<e_float>::infinity()
+ : -std::numeric_limits<e_float>::infinity());
return *this;
}
@@ -959,14 +959,14 @@
return (*this = ef::zero());
}
- if(nn >= static_cast<UINT32>(ef_elem_mask))
+ if(n >= static_cast<unsigned long long>(ef_elem_mask))
{
return operator*=(e_float(n));
}
- if(nn == static_cast<UINT32>(1u))
+ if(n == static_cast<unsigned long long>(1u))
{
- neg = b_result_is_neg;
+ neg = b_neg;
return *this;
}
@@ -980,6 +980,7 @@
const INT32 prec = static_cast<INT32>(prec_elem);
const INT32 jm = (std::min)(jm1, prec);
+ const UINT32 nn = static_cast<UINT32>(n);
const UINT32 carry = mul_loop_n(data.data(), nn, jm);
// Handle the carry and adjust the exponent.
@@ -999,32 +1000,28 @@
&& (*this > (std::numeric_limits<e_float>::max)())
)
{
- *this = ((!b_result_is_neg) ? std::numeric_limits<e_float>::infinity()
- : -std::numeric_limits<e_float>::infinity());
+ *this = ((!b_neg) ? std::numeric_limits<e_float>::infinity()
+ : -std::numeric_limits<e_float>::infinity());
return *this;
}
// Set the sign.
- neg = b_result_is_neg;
+ neg = b_neg;
return *this;
}
-efx::e_float& efx::e_float::div_by_int(const INT32 n)
+efx::e_float& efx::e_float::div_unsigned_long_long(const unsigned long long n)
{
- // Divide *this by a constant signed integer.
- const bool b_n_is_neg = (n < static_cast<INT32>(0));
+ // Divide *this by a constant unsigned long long.
// Evaluate the sign of the result.
- const bool b_neg = (neg != b_n_is_neg);
+ const bool b_neg = neg;
// Artificially set the sign of the result to be positive.
neg = false;
- const UINT32 nn = ((!b_n_is_neg) ? static_cast<UINT32>( n)
- : static_cast<UINT32>(-n));
-
// Handle special cases like zero, inf and NaN.
if(isnan())
{
@@ -1039,7 +1036,7 @@
return *this;
}
- if(n == static_cast<INT32>(0))
+ if(n == static_cast<unsigned long long>(0u))
{
// Divide by 0.
if(iszero())
@@ -1060,16 +1057,17 @@
return *this;
}
- if(nn >= static_cast<UINT32>(ef_elem_mask))
+ if(n >= static_cast<unsigned long long>(ef_elem_mask))
{
return operator/=(e_float(n));
}
- if(nn > static_cast<UINT32>(1u))
+ if(n > static_cast<unsigned long long>(1u))
{
// Division loop.
const INT32 jm = static_cast<INT32>(prec_elem);
+ const UINT32 nn = static_cast<UINT32>(n);
const UINT32 prev = div_loop_n(data.data(), nn, jm);
// Determine if one leading zero is in the result data.
Modified: sandbox/e_float/libs/e_float/src/functions/constants/constants.cpp
==============================================================================
--- sandbox/e_float/libs/e_float/src/functions/constants/constants.cpp (original)
+++ sandbox/e_float/libs/e_float/src/functions/constants/constants.cpp 2011-08-04 11:11:59 EDT (Thu, 04 Aug 2011)
@@ -354,3 +354,95 @@
static const e_float val(str.c_str());
return val;
}
+
+const e_float& ef::extreme_value_skewness(void)
+{
+ // 1100 digits of the extreme value distribution skewness
+ // Mathematica: N[12 Sqrt[6] Zeta[3]/Pi^3, 1101]
+ static const std::string str =
+ std::string("1.")
+ + std::string("1395470994046486574927930193898461120875997958365518247216557100852480077060706857071875468869385150")
+ + std::string("1894272048688553376986765366075828644841024041679714157616857834895702411080704529137366329462558680")
+ + std::string("2015498788776135705587959418756809080074611906006528647805347822929577145038743873949415294942796280")
+ + std::string("0895597703063466053535550338267721294164578901640163603544404938283861127819804918174973533694090594")
+ + std::string("3094963822672055237678432023017824416203652657301470473548274848068762500300316769691474974950757965")
+ + std::string("8640779777748741897542093874605477776538884083378029488863880220988107155275203245233994097178778984")
+ + std::string("3488995668362387892097897322246698071290011857605809901090220903955815127463328974447572119951192970")
+ + std::string("3684453635456559086126406960279692862247058250100678008419431185138019869693206366891639436908462809")
+ + std::string("9756051372711251054914491837034685476095423926553367264355374652153595857163724698198860485357368964")
+ + std::string("3807049634423621246870868566707915720704996296083373077647528285782964567312903914752617978405994377")
+ + std::string("9064157147206717895272199736902453130842229559980076472936976287378945035706933650987259357729800315")
+ ;
+
+ static const e_float val(str.c_str());
+ return val;
+}
+
+const e_float& ef::rayleigh_skewness(void)
+{
+ // 1100 digits of the Rayleigh distribution skewness
+ // Mathematica: N[2 Sqrt[Pi] (Pi - 3)/((4 - Pi)^(3/2)), 1100]
+ static const std::string str =
+ std::string("0.")
+ + std::string("6311106578189371381918993515442277798440422031347194976580945856929268196174737254599050270325373067")
+ + std::string("9440004726436754739597525250317640394102954301685809920213808351450851396781817932734836994829371322")
+ + std::string("5797376021347531983451654130317032832308462278373358624120822253764532674177325950686466133508511968")
+ + std::string("2389168716630349407238090652663422922072397393006683401992961569208109477307776249225072042971818671")
+ + std::string("4058887072693437217879039875871765635655476241624825389439481561152126886932506682176611183750503553")
+ + std::string("1218982627032068396407180216351425758181396562859085306247387212297187006230007438534686340210168288")
+ + std::string("8956816965453815849613622117088096547521391672977226658826566757207615552041767516828171274858145957")
+ + std::string("6137539156656005855905288420585194082284972984285863898582313048515484073396332610565441264220790791")
+ + std::string("0194897267890422924599776483890102027823328602965235306539844007677157873140562950510028206251529523")
+ + std::string("7428049693650605954398446899724157486062545281504433364675815915402937209673727753199567661561209251")
+ + std::string("4695589950526053470201635372590001578503476490223746511106018091907936826431407434894024396366284848")
+ ;
+
+ static const e_float val(str.c_str());
+ return val;
+}
+
+const e_float& ef::rayleigh_kurtosis(void)
+{
+ // 1100 digits of the Rayleigh distribution kurtosis
+ // Mathematica: N[3 - (6 Pi^2 - 24 Pi + 16)/((Pi - 4)^2), 1101]
+ static const std::string str =
+ std::string("3.")
+ + std::string("2450893006876380628486604106197544154170667317892093617713376449336790454087415905149061936867934897")
+ + std::string("7426462632766222863025885280475303127822220268263096589513724730667617861820932858778449728296659479")
+ + std::string("3509930847868156538858152415545518545531216798298547693461311645548952424632118645472682463069545526")
+ + std::string("1983053031855607397851202464589880370383506850067796236695992134911848393006954201076208202808484125")
+ + std::string("6133354144360242773961231033129953293849110813453065649115333206743995085094897184520870169529618137")
+ + std::string("1386582922293062730416145656063188572844644520145571288064202952779173502297498984505977966704775822")
+ + std::string("5618195941007999394816250555243512667729218321194759827137580052728640801190395474421829335542653964")
+ + std::string("2635117940160187084211929489404610340511995002504673867278772758560400939592040029761998053665442841")
+ + std::string("1577415214507922011979312846237719442003310251741466941617588043270228799439065296867165276320363613")
+ + std::string("8733430815475656049776923162323269916006398895573867114723876996574699420608567147551765179203903001")
+ + std::string("5455211712707351783064330032429944926162677960388580113035455983189062640894597247867450273307835796")
+ ;
+
+ static const e_float val(str.c_str());
+ return val;
+}
+
+const e_float& ef::rayleigh_kurtosis_excess(void)
+{
+ // 1100 digits of the Rayleigh distribution kurtosis excess
+ // Mathematica: N[- (6 Pi^2 - 24 Pi + 16)/((Pi - 4)^2), 1100]
+ static const std::string str =
+ std::string("0.")
+ + std::string("2450893006876380628486604106197544154170667317892093617713376449336790454087415905149061936867934897")
+ + std::string("7426462632766222863025885280475303127822220268263096589513724730667617861820932858778449728296659479")
+ + std::string("3509930847868156538858152415545518545531216798298547693461311645548952424632118645472682463069545526")
+ + std::string("1983053031855607397851202464589880370383506850067796236695992134911848393006954201076208202808484125")
+ + std::string("6133354144360242773961231033129953293849110813453065649115333206743995085094897184520870169529618137")
+ + std::string("1386582922293062730416145656063188572844644520145571288064202952779173502297498984505977966704775822")
+ + std::string("5618195941007999394816250555243512667729218321194759827137580052728640801190395474421829335542653964")
+ + std::string("2635117940160187084211929489404610340511995002504673867278772758560400939592040029761998053665442841")
+ + std::string("1577415214507922011979312846237719442003310251741466941617588043270228799439065296867165276320363613")
+ + std::string("8733430815475656049776923162323269916006398895573867114723876996574699420608567147551765179203903001")
+ + std::string("5455211712707351783064330032429944926162677960388580113035455983189062640894597247867450273307835796")
+ ;
+
+ static const e_float val(str.c_str());
+ return val;
+}
Modified: sandbox/e_float/libs/e_float/src/functions/elementary/elementary_trans.cpp
==============================================================================
--- sandbox/e_float/libs/e_float/src/functions/elementary/elementary_trans.cpp (original)
+++ sandbox/e_float/libs/e_float/src/functions/elementary/elementary_trans.cpp 2011-08-04 11:11:59 EDT (Thu, 04 Aug 2011)
@@ -772,14 +772,14 @@
{
*p_sinh = e_px;
*p_sinh -= e_mx;
- p_sinh->div_by_int(2);
+ p_sinh->div_unsigned_long_long(2u);
}
if(p_cosh)
{
*p_cosh = e_px;
*p_cosh += e_mx;
- p_cosh->div_by_int(2);
+ p_cosh->div_unsigned_long_long(2u);
}
}
Modified: sandbox/e_float/libs/e_float/test/real/cases/test_case_0000z_global_ops_pod.cpp
==============================================================================
--- sandbox/e_float/libs/e_float/test/real/cases/test_case_0000z_global_ops_pod.cpp (original)
+++ sandbox/e_float/libs/e_float/test/real/cases/test_case_0000z_global_ops_pod.cpp 2011-08-04 11:11:59 EDT (Thu, 04 Aug 2011)
@@ -14,6 +14,7 @@
#include <iomanip>
#include <e_float/e_float.hpp>
+#include <e_float/e_float_functions.hpp>
#include "../test_case_real.h"
namespace
@@ -117,15 +118,15 @@
}
};
- class TestCase_case_00009_global_ops_pod_equal : public TestCaseGlobalOpsPodBase
+ class TestCase_case_00009_global_ops_pod_equate : public TestCaseGlobalOpsPodBase
{
public:
- TestCase_case_00009_global_ops_pod_equal() { }
- virtual ~TestCase_case_00009_global_ops_pod_equal() { }
+ TestCase_case_00009_global_ops_pod_equate() { }
+ virtual ~TestCase_case_00009_global_ops_pod_equate() { }
private:
virtual const std::string& name(void) const
{
- static const std::string str("TestCase_case_00009_global_ops_pod_equal");
+ static const std::string str("TestCase_case_00009_global_ops_pod_equate");
return str;
}
virtual void e_float_test(std::vector<e_float>& data) const
@@ -155,9 +156,57 @@
}
};
- bool test_case_00009_global_ops_pod_equal(const bool b_write_output)
+ class TestCase_case_00010_global_ops_pod_operations : public TestCaseGlobalOpsPodBase
{
- return TestCase_case_00009_global_ops_pod_equal().execute(b_write_output);
+ public:
+ TestCase_case_00010_global_ops_pod_operations() { }
+ virtual ~TestCase_case_00010_global_ops_pod_operations() { }
+ private:
+ virtual const std::string& name(void) const
+ {
+ static const std::string str("TestCase_case_00010_global_ops_pod_operations");
+ return str;
+ }
+ virtual void e_float_test(std::vector<e_float>& data) const
+ {
+ data.clear();
+
+ my_test_result = true;
+
+ my_test_result &= (ef::four() == static_cast<float>(4.0f));
+ my_test_result &= (ef::four() == static_cast<double>(4.0));
+ my_test_result &= (ef::four() == static_cast<long double>(4.0));
+
+ my_test_result &= (ef::pi() > static_cast<float>(3.14f));
+ my_test_result &= (ef::pi() > static_cast<double>(3.14));
+ my_test_result &= (ef::pi() > static_cast<long double>(3.14));
+
+ my_test_result &= (static_cast<float> (0.5f) < ef::euler_gamma());
+ my_test_result &= (static_cast<double> (0.5) < ef::euler_gamma());
+ my_test_result &= (static_cast<long double>(0.5) < ef::euler_gamma());
+
+ my_test_result &= (e_float(static_cast<char>('1')) == static_cast<char>(0x31));
+ my_test_result &= (e_float(static_cast<char>('2')) > static_cast<char>('1'));
+ my_test_result &= (e_float(static_cast<char>('1')) < static_cast<char>('2'));
+ my_test_result &= (e_float(static_cast<char>('2')) <= static_cast<char>('2'));
+ my_test_result &= (e_float(static_cast<char>('2')) >= static_cast<char>('2'));
+
+ my_test_result &= (e_float("1e1000") > std::numeric_limits<unsigned long long>::max());
+ my_test_result &= (ef::zero() == 0);
+ my_test_result &= (std::numeric_limits<e_float>::epsilon() > 0);
+
+ my_test_result &= ((ef::one() * 4.0) == 4);
+ my_test_result &= ((4.0 * ef::one()) == 4);
+ }
+ };
+
+ bool test_case_00009_global_ops_pod_equate(const bool b_write_output)
+ {
+ return TestCase_case_00009_global_ops_pod_equate().execute(b_write_output);
+ }
+ bool test_case_00010_global_ops_pod_operations(const bool b_write_output)
+ {
+ return TestCase_case_00010_global_ops_pod_operations().execute(b_write_output);
}
}
}
Modified: sandbox/e_float/libs/e_float/test/real/test_real.cpp
==============================================================================
--- sandbox/e_float/libs/e_float/test/real/test_real.cpp (original)
+++ sandbox/e_float/libs/e_float/test/real/test_real.cpp 2011-08-04 11:11:59 EDT (Thu, 04 Aug 2011)
@@ -23,7 +23,8 @@
bool test_case_00006_write_os_floatfield_fixed (const bool b_write_output);
bool test_case_00007_write_os_floatfield_scientific(const bool b_write_output);
bool test_case_00008_write_os_floatfield_not_set (const bool b_write_output);
- bool test_case_00009_global_ops_pod_equal (const bool b_write_output);
+ bool test_case_00009_global_ops_pod_equate (const bool b_write_output);
+ bool test_case_00010_global_ops_pod_operations (const bool b_write_output);
bool test_case_00011_various_elem_math (const bool b_write_output);
bool test_case_00021_bernoulli (const bool b_write_output);
bool test_case_00051_factorial (const bool b_write_output);
@@ -69,7 +70,8 @@
test_ok &= test::real::test_case_00006_write_os_floatfield_fixed (b_write_output);
test_ok &= test::real::test_case_00007_write_os_floatfield_scientific(b_write_output);
test_ok &= test::real::test_case_00008_write_os_floatfield_not_set (b_write_output);
- test_ok &= test::real::test_case_00009_global_ops_pod_equal (b_write_output);
+ test_ok &= test::real::test_case_00009_global_ops_pod_equate (b_write_output);
+ test_ok &= test::real::test_case_00010_global_ops_pod_operations (b_write_output);
test_ok &= test::real::test_case_00011_various_elem_math (b_write_output);
test_ok &= test::real::test_case_00021_bernoulli (b_write_output);
test_ok &= test::real::test_case_00051_factorial (b_write_output);