|
|
Boost-Commit : |
Subject: [Boost-commit] svn:boost r74223 - in sandbox/e_float: boost/e_float libs/e_float/example libs/e_float/src/e_float/efx libs/e_float/src/e_float/gmp libs/e_float/src/e_float/mpfr libs/e_float/src/functions/constants libs/e_float/src/functions/elementary libs/e_float/src/functions/gamma libs/e_float/src/functions/integer libs/e_float/src/functions/zeta libs/e_float/src/generic_functions/constants libs/e_float/src/generic_functions/elementary libs/e_float/src/utility libs/e_float/test
From: e_float_at_[hidden]
Date: 2011-09-04 12:09:58
Author: christopher_kormanyos
Date: 2011-09-04 12:09:54 EDT (Sun, 04 Sep 2011)
New Revision: 74223
URL: http://svn.boost.org/trac/boost/changeset/74223
Log:
- Reduced the plethora of #include files in the boost/e_float directory.
- Initial stage: Remove file content and consolidate.
Text files modified:
sandbox/e_float/boost/e_float/e_float.hpp | 486 +++++++++++++++++++++++++++++++++++++++
sandbox/e_float/boost/e_float/e_float_complex.hpp | 234 +++++++++++++++++++
sandbox/e_float/boost/e_float/e_float_constants.hpp | 85 ------
sandbox/e_float/boost/e_float/e_float_elementary.hpp | 4
sandbox/e_float/boost/e_float/e_float_elementary_complex.hpp | 278 ----------------------
sandbox/e_float/boost/e_float/e_float_elementary_math.hpp | 88 -------
sandbox/e_float/boost/e_float/e_float_elementary_trans.hpp | 52 ----
sandbox/e_float/boost/e_float/e_float_functions.hpp | 279 ++++++++++++++++++++++
sandbox/e_float/boost/e_float/e_float_gamma.hpp | 23 -
sandbox/e_float/boost/e_float/e_float_global_math.hpp | 435 -----------------------------------
sandbox/e_float/boost/e_float/e_float_integer.hpp | 10
sandbox/e_float/boost/e_float/e_float_limits.hpp | 56 ----
sandbox/e_float/boost/e_float/e_float_prime.hpp | 9
sandbox/e_float/boost/e_float/e_float_zeta.hpp | 14 -
sandbox/e_float/libs/e_float/example/examples.h | 3
sandbox/e_float/libs/e_float/src/e_float/efx/e_float_efx.cpp | 4
sandbox/e_float/libs/e_float/src/e_float/gmp/e_float_gmp.cpp | 4
sandbox/e_float/libs/e_float/src/e_float/mpfr/e_float_mpfr.cpp | 4
sandbox/e_float/libs/e_float/src/functions/constants/constants.cpp | 4
sandbox/e_float/libs/e_float/src/functions/elementary/elementary_complex.cpp | 6
sandbox/e_float/libs/e_float/src/functions/elementary/elementary_hyper_g.cpp | 5
sandbox/e_float/libs/e_float/src/functions/elementary/elementary_math.cpp | 3
sandbox/e_float/libs/e_float/src/functions/elementary/elementary_trans.cpp | 4
sandbox/e_float/libs/e_float/src/functions/elementary/elementary_trig.cpp | 4
sandbox/e_float/libs/e_float/src/functions/gamma/factorial.cpp | 4
sandbox/e_float/libs/e_float/src/functions/gamma/factorial2.cpp | 4
sandbox/e_float/libs/e_float/src/functions/gamma/gamma.cpp | 6
sandbox/e_float/libs/e_float/src/functions/gamma/gamma_util.cpp | 5
sandbox/e_float/libs/e_float/src/functions/gamma/pochhammer.cpp | 4
sandbox/e_float/libs/e_float/src/functions/integer/bernoulli_b.cpp | 6
sandbox/e_float/libs/e_float/src/functions/integer/prime.cpp | 4
sandbox/e_float/libs/e_float/src/functions/integer/prime_factor.cpp | 4
sandbox/e_float/libs/e_float/src/functions/zeta/zeta.cpp | 10
sandbox/e_float/libs/e_float/src/generic_functions/constants/generic_functions_constants.h | 2
sandbox/e_float/libs/e_float/src/generic_functions/elementary/generic_functions_elementary.h | 3
sandbox/e_float/libs/e_float/src/utility/util_power_j_pow_x.cpp | 7
sandbox/e_float/libs/e_float/src/utility/util_power_j_pow_x.h | 2
sandbox/e_float/libs/e_float/test/test_case_base.h | 3
38 files changed, 1015 insertions(+), 1143 deletions(-)
Modified: sandbox/e_float/boost/e_float/e_float.hpp
==============================================================================
--- sandbox/e_float/boost/e_float/e_float.hpp (original)
+++ sandbox/e_float/boost/e_float/e_float.hpp 2011-09-04 12:09:54 EDT (Sun, 04 Sep 2011)
@@ -11,6 +11,8 @@
#ifndef _E_FLOAT_HPP_
#define _E_FLOAT_HPP_
+ #include <limits>
+
// Select the e_float back-end big-number type
// by defining E_FLOAT_TYPE_xxx, for example,
// as a compiler defined preprocessor macro.
@@ -25,7 +27,487 @@
#error e_float type undefined!
#endif
- #include <boost/e_float/e_float_global_math.hpp>
- #include <boost/e_float/e_float_limits.hpp>
+ namespace ef
+ {
+ const e_float& zero (void);
+ const e_float& one (void);
+ const e_float& half (void);
+ const e_float& value_min(void);
+ const e_float& value_max(void);
+ const e_float& value_eps(void);
+ const e_float& value_inf(void);
+ const e_float& value_nan(void);
+ }
+
+ // Specialization of std::numeric_limits<e_float>.
+ namespace std
+ {
+ template <> class numeric_limits<e_float>
+ {
+ public:
+ static const bool is_specialized = true;
+ static const bool is_signed = true;
+ static const bool is_integer = false;
+ static const bool is_exact = false;
+ static const bool is_bounded = true;
+ static const bool is_modulo = false;
+ static const bool is_iec559 = false;
+ static const int digits = e_float::ef_digits;
+ static const int digits10 = e_float::ef_digits10;
+ static const int max_digits10 = e_float::ef_max_digits10;
+ static const INT64 min_exponent = e_float::ef_min_exp; // Type differs from int.
+ static const INT64 min_exponent10 = e_float::ef_min_exp10; // Type differs from int.
+ static const INT64 max_exponent = e_float::ef_max_exp; // Type differs from int.
+ static const INT64 max_exponent10 = e_float::ef_max_exp10; // Type differs from int.
+ static const int radix = e_float::ef_radix;
+ static const std::float_round_style round_style = std::round_to_nearest;
+ static const bool has_infinity = true;
+ static const bool has_quiet_NaN = true;
+ static const bool has_signaling_NaN = false;
+ static const std::float_denorm_style has_denorm = std::denorm_absent;
+ static const bool has_denorm_loss = false;
+ static const bool traps = false;
+ static const bool tinyness_before = false;
+
+ static const e_float& (min) (void) throw() { return ef::value_min(); }
+ static const e_float& (max) (void) throw() { return ef::value_max(); }
+ static const e_float& lowest (void) throw() { return ef::zero(); }
+ static const e_float& epsilon (void) throw() { return ef::value_eps(); }
+ static const e_float& round_error (void) throw() { return ef::half(); }
+ static const e_float& infinity (void) throw() { return ef::value_inf(); }
+ static const e_float& quiet_NaN (void) throw() { return ef::value_nan(); }
+ static const e_float& signaling_NaN(void) throw() { return ef::zero(); }
+ static const e_float& denorm_min (void) throw() { return ef::zero(); }
+ };
+ }
+
+ // 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; }
+
+ // Global unary operators of e_float reference.
+ inline e_float operator-(const e_float& u) { return e_float(u).negate(); }
+ 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& 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; }
+
+ // Global add/sub/mul/div of const e_float& with all built-in types.
+ inline e_float operator+(const e_float& u, const char n) { return ((!std::numeric_limits<char>::is_signed) ? e_float(u).add_unsigned_long_long(static_cast<unsigned long long>(n)) : e_float(u).add_signed_long_long(static_cast<signed long long>(n))); }
+ 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 ((!std::numeric_limits<wchar_t>::is_signed) ? e_float(u).add_unsigned_long_long(static_cast<unsigned long long>(n)) : e_float(u).add_signed_long_long(static_cast<signed 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 char n) { return ((!std::numeric_limits<char>::is_signed) ? e_float(u).sub_unsigned_long_long(static_cast<unsigned long long>(n)) : e_float(u).sub_signed_long_long(static_cast<signed long long>(n))); }
+ 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 ((!std::numeric_limits<wchar_t>::is_signed) ? e_float(u).sub_unsigned_long_long(static_cast<unsigned long long>(n)) : e_float(u).sub_signed_long_long(static_cast<signed 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 char n) { return ((!std::numeric_limits<char>::is_signed) ? e_float(u).mul_unsigned_long_long(static_cast<unsigned long long>(n)) : e_float(u).mul_signed_long_long(static_cast<signed long long>(n))); }
+ 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 ((!std::numeric_limits<wchar_t>::is_signed) ? e_float(u).mul_unsigned_long_long(static_cast<unsigned long long>(n)) : e_float(u).mul_signed_long_long(static_cast<signed 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 char n) { return ((!std::numeric_limits<char>::is_signed) ? e_float(u).div_unsigned_long_long(static_cast<unsigned long long>(n)) : e_float(u).div_signed_long_long(static_cast<signed long long>(n))); }
+ 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 ((!std::numeric_limits<wchar_t>::is_signed) ? e_float(u).div_unsigned_long_long(static_cast<unsigned long long>(n)) : e_float(u).div_signed_long_long(static_cast<signed 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 char n, const e_float& u) { return ((!std::numeric_limits<char>::is_signed) ? e_float(u).add_unsigned_long_long(n) : e_float(u).add_signed_long_long(n)); }
+ 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 ((!std::numeric_limits<wchar_t>::is_signed) ? e_float(u).add_unsigned_long_long(n) : e_float(u).add_signed_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 char n, const e_float& u) { return e_float(n) -= 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 char n, const e_float& u) { return ((!std::numeric_limits<char>::is_signed) ? e_float(u).mul_unsigned_long_long(n) : e_float(u).mul_signed_long_long(n)); }
+ 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 ((!std::numeric_limits<wchar_t>::is_signed) ? e_float(u).mul_unsigned_long_long(n) : e_float(u).mul_signed_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 char n, const e_float& u) { return e_float(n) /= 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 char n) { return ((!std::numeric_limits<char>::is_signed) ? u.add_unsigned_long_long(static_cast<unsigned long long>(n)) : u.add_signed_long_long(static_cast<signed long long>(n))); }
+ 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 ((!std::numeric_limits<wchar_t>::is_signed) ? u.add_unsigned_long_long(static_cast<unsigned long long>(n)) : u.add_signed_long_long(static_cast<signed 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 ((!std::numeric_limits<char>::is_signed) ? u.sub_unsigned_long_long(static_cast<unsigned long long>(n)) : u.sub_signed_long_long(static_cast<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 ((!std::numeric_limits<wchar_t>::is_signed) ? u.sub_unsigned_long_long(static_cast<unsigned long long>(n)) : u.sub_signed_long_long(static_cast<signed 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 char n) { return ((!std::numeric_limits<char>::is_signed) ? u.mul_unsigned_long_long(static_cast<unsigned long long>(n)) : u.mul_signed_long_long(static_cast<signed long long>(n))); }
+ 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 ((!std::numeric_limits<wchar_t>::is_signed) ? u.mul_unsigned_long_long(static_cast<unsigned long long>(n)) : u.mul_signed_long_long(static_cast<signed 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 char n) { return ((!std::numeric_limits<char>::is_signed) ? u.div_unsigned_long_long(static_cast<unsigned long long>(n)) : u.div_signed_long_long(static_cast<signed long long>(n))); }
+ 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 ((!std::numeric_limits<wchar_t>::is_signed) ? u.div_unsigned_long_long(static_cast<unsigned long long>(n)) : u.div_signed_long_long(static_cast<signed 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& 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)); }
+ 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)); }
+
+ // Global comparison operators of const e_float& with all built-in types.
+ inline bool operator< (const e_float& u, const char v) { return (u.cmp(e_float(v)) < static_cast<INT32>(0)); }
+ inline bool operator<=(const e_float& u, const char v) { return (u.cmp(e_float(v)) <= static_cast<INT32>(0)); }
+ inline bool operator==(const e_float& u, const char v) { return (u.cmp(e_float(v)) == static_cast<INT32>(0)); }
+ inline bool operator!=(const e_float& u, const char v) { return (u.cmp(e_float(v)) != static_cast<INT32>(0)); }
+ inline bool operator>=(const e_float& u, const char v) { return (u.cmp(e_float(v)) >= static_cast<INT32>(0)); }
+ inline bool operator> (const e_float& u, const char v) { return (u.cmp(e_float(v)) > static_cast<INT32>(0)); }
+
+ inline bool operator< (const e_float& u, const wchar_t v) { return (u.cmp(e_float(v)) < static_cast<INT32>(0)); }
+ inline bool operator<=(const e_float& u, const wchar_t v) { return (u.cmp(e_float(v)) <= static_cast<INT32>(0)); }
+ inline bool operator==(const e_float& u, const wchar_t v) { return (u.cmp(e_float(v)) == static_cast<INT32>(0)); }
+ inline bool operator!=(const e_float& u, const wchar_t v) { return (u.cmp(e_float(v)) != static_cast<INT32>(0)); }
+ inline bool operator>=(const e_float& u, const wchar_t v) { return (u.cmp(e_float(v)) >= static_cast<INT32>(0)); }
+ inline bool operator> (const e_float& u, const wchar_t v) { return (u.cmp(e_float(v)) > static_cast<INT32>(0)); }
+
+ inline bool operator< (const e_float& u, const signed char v) { return (u.cmp(e_float(v)) < static_cast<INT32>(0)); }
+ inline bool operator<=(const e_float& u, const signed char v) { return (u.cmp(e_float(v)) <= static_cast<INT32>(0)); }
+ inline bool operator==(const e_float& u, const signed char v) { return (u.cmp(e_float(v)) == static_cast<INT32>(0)); }
+ inline bool operator!=(const e_float& u, const signed char v) { return (u.cmp(e_float(v)) != static_cast<INT32>(0)); }
+ inline bool operator>=(const e_float& u, const signed char v) { return (u.cmp(e_float(v)) >= static_cast<INT32>(0)); }
+ inline bool operator> (const e_float& u, const signed char v) { return (u.cmp(e_float(v)) > static_cast<INT32>(0)); }
+
+ inline bool operator< (const e_float& u, const signed short v) { return (u.cmp(e_float(v)) < static_cast<INT32>(0)); }
+ inline bool operator<=(const e_float& u, const signed short v) { return (u.cmp(e_float(v)) <= static_cast<INT32>(0)); }
+ inline bool operator==(const e_float& u, const signed short v) { return (u.cmp(e_float(v)) == static_cast<INT32>(0)); }
+ inline bool operator!=(const e_float& u, const signed short v) { return (u.cmp(e_float(v)) != static_cast<INT32>(0)); }
+ inline bool operator>=(const e_float& u, const signed short v) { return (u.cmp(e_float(v)) >= static_cast<INT32>(0)); }
+ inline bool operator> (const e_float& u, const signed short v) { return (u.cmp(e_float(v)) > static_cast<INT32>(0)); }
+
+ inline bool operator< (const e_float& u, const signed int v) { return (u.cmp(e_float(v)) < static_cast<INT32>(0)); }
+ inline bool operator<=(const e_float& u, const signed int v) { return (u.cmp(e_float(v)) <= static_cast<INT32>(0)); }
+ inline bool operator==(const e_float& u, const signed int v) { return (u.cmp(e_float(v)) == static_cast<INT32>(0)); }
+ inline bool operator!=(const e_float& u, const signed int v) { return (u.cmp(e_float(v)) != static_cast<INT32>(0)); }
+ inline bool operator>=(const e_float& u, const signed int v) { return (u.cmp(e_float(v)) >= static_cast<INT32>(0)); }
+ inline bool operator> (const e_float& u, const signed int v) { return (u.cmp(e_float(v)) > static_cast<INT32>(0)); }
+
+ inline bool operator< (const e_float& u, const signed long v) { return (u.cmp(e_float(v)) < static_cast<INT32>(0)); }
+ inline bool operator<=(const e_float& u, const signed long v) { return (u.cmp(e_float(v)) <= static_cast<INT32>(0)); }
+ inline bool operator==(const e_float& u, const signed long v) { return (u.cmp(e_float(v)) == static_cast<INT32>(0)); }
+ inline bool operator!=(const e_float& u, const signed long v) { return (u.cmp(e_float(v)) != static_cast<INT32>(0)); }
+ inline bool operator>=(const e_float& u, const signed long v) { return (u.cmp(e_float(v)) >= static_cast<INT32>(0)); }
+ inline bool operator> (const e_float& u, const signed long v) { return (u.cmp(e_float(v)) > static_cast<INT32>(0)); }
+
+ inline bool operator< (const e_float& u, const signed long long v) { return (u.cmp(e_float(v)) < static_cast<INT32>(0)); }
+ inline bool operator<=(const e_float& u, const signed long long v) { return (u.cmp(e_float(v)) <= static_cast<INT32>(0)); }
+ inline bool operator==(const e_float& u, const signed long long v) { return (u.cmp(e_float(v)) == static_cast<INT32>(0)); }
+ inline bool operator!=(const e_float& u, const signed long long v) { return (u.cmp(e_float(v)) != static_cast<INT32>(0)); }
+ inline bool operator>=(const e_float& u, const signed long long v) { return (u.cmp(e_float(v)) >= static_cast<INT32>(0)); }
+ inline bool operator> (const e_float& u, const signed long long v) { return (u.cmp(e_float(v)) > static_cast<INT32>(0)); }
+
+ inline bool operator< (const e_float& u, const unsigned char v) { return (u.cmp(e_float(v)) < static_cast<INT32>(0)); }
+ inline bool operator<=(const e_float& u, const unsigned char v) { return (u.cmp(e_float(v)) <= static_cast<INT32>(0)); }
+ inline bool operator==(const e_float& u, const unsigned char v) { return (u.cmp(e_float(v)) == static_cast<INT32>(0)); }
+ inline bool operator!=(const e_float& u, const unsigned char v) { return (u.cmp(e_float(v)) != static_cast<INT32>(0)); }
+ inline bool operator>=(const e_float& u, const unsigned char v) { return (u.cmp(e_float(v)) >= static_cast<INT32>(0)); }
+ inline bool operator> (const e_float& u, const unsigned char v) { return (u.cmp(e_float(v)) > static_cast<INT32>(0)); }
+
+ inline bool operator< (const e_float& u, const unsigned short v) { return (u.cmp(e_float(v)) < static_cast<INT32>(0)); }
+ inline bool operator<=(const e_float& u, const unsigned short v) { return (u.cmp(e_float(v)) <= static_cast<INT32>(0)); }
+ inline bool operator==(const e_float& u, const unsigned short v) { return (u.cmp(e_float(v)) == static_cast<INT32>(0)); }
+ inline bool operator!=(const e_float& u, const unsigned short v) { return (u.cmp(e_float(v)) != static_cast<INT32>(0)); }
+ inline bool operator>=(const e_float& u, const unsigned short v) { return (u.cmp(e_float(v)) >= static_cast<INT32>(0)); }
+ inline bool operator> (const e_float& u, const unsigned short v) { return (u.cmp(e_float(v)) > static_cast<INT32>(0)); }
+
+ inline bool operator< (const e_float& u, const unsigned int v) { return (u.cmp(e_float(v)) < static_cast<INT32>(0)); }
+ inline bool operator<=(const e_float& u, const unsigned int v) { return (u.cmp(e_float(v)) <= static_cast<INT32>(0)); }
+ inline bool operator==(const e_float& u, const unsigned int v) { return (u.cmp(e_float(v)) == static_cast<INT32>(0)); }
+ inline bool operator!=(const e_float& u, const unsigned int v) { return (u.cmp(e_float(v)) != static_cast<INT32>(0)); }
+ inline bool operator>=(const e_float& u, const unsigned int v) { return (u.cmp(e_float(v)) >= static_cast<INT32>(0)); }
+ inline bool operator> (const e_float& u, const unsigned int v) { return (u.cmp(e_float(v)) > static_cast<INT32>(0)); }
+
+ inline bool operator< (const e_float& u, const unsigned long v) { return (u.cmp(e_float(v)) < static_cast<INT32>(0)); }
+ inline bool operator<=(const e_float& u, const unsigned long v) { return (u.cmp(e_float(v)) <= static_cast<INT32>(0)); }
+ inline bool operator==(const e_float& u, const unsigned long v) { return (u.cmp(e_float(v)) == static_cast<INT32>(0)); }
+ inline bool operator!=(const e_float& u, const unsigned long v) { return (u.cmp(e_float(v)) != static_cast<INT32>(0)); }
+ inline bool operator>=(const e_float& u, const unsigned long v) { return (u.cmp(e_float(v)) >= static_cast<INT32>(0)); }
+ inline bool operator> (const e_float& u, const unsigned long v) { return (u.cmp(e_float(v)) > static_cast<INT32>(0)); }
+
+ inline bool operator< (const e_float& u, const unsigned long long v) { return (u.cmp(e_float(v)) < static_cast<INT32>(0)); }
+ inline bool operator<=(const e_float& u, const unsigned long long v) { return (u.cmp(e_float(v)) <= static_cast<INT32>(0)); }
+ inline bool operator==(const e_float& u, const unsigned long long v) { return (u.cmp(e_float(v)) == static_cast<INT32>(0)); }
+ inline bool operator!=(const e_float& u, const unsigned long long v) { return (u.cmp(e_float(v)) != static_cast<INT32>(0)); }
+ inline bool operator>=(const e_float& u, const unsigned long long v) { return (u.cmp(e_float(v)) >= static_cast<INT32>(0)); }
+ inline bool operator> (const e_float& u, const unsigned long long v) { return (u.cmp(e_float(v)) > static_cast<INT32>(0)); }
+
+ inline bool operator< (const e_float& u, const float v) { return (u.cmp(e_float(v)) < static_cast<INT32>(0)); }
+ inline bool operator<=(const e_float& u, const float v) { return (u.cmp(e_float(v)) <= static_cast<INT32>(0)); }
+ inline bool operator==(const e_float& u, const float v) { return (u.cmp(e_float(v)) == static_cast<INT32>(0)); }
+ inline bool operator!=(const e_float& u, const float v) { return (u.cmp(e_float(v)) != static_cast<INT32>(0)); }
+ inline bool operator>=(const e_float& u, const float v) { return (u.cmp(e_float(v)) >= static_cast<INT32>(0)); }
+ inline bool operator> (const e_float& u, const float v) { return (u.cmp(e_float(v)) > static_cast<INT32>(0)); }
+
+ inline bool operator< (const e_float& u, const double v) { return (u.cmp(e_float(v)) < static_cast<INT32>(0)); }
+ inline bool operator<=(const e_float& u, const double v) { return (u.cmp(e_float(v)) <= static_cast<INT32>(0)); }
+ inline bool operator==(const e_float& u, const double v) { return (u.cmp(e_float(v)) == static_cast<INT32>(0)); }
+ inline bool operator!=(const e_float& u, const double v) { return (u.cmp(e_float(v)) != static_cast<INT32>(0)); }
+ inline bool operator>=(const e_float& u, const double v) { return (u.cmp(e_float(v)) >= static_cast<INT32>(0)); }
+ inline bool operator> (const e_float& u, const double v) { return (u.cmp(e_float(v)) > static_cast<INT32>(0)); }
+
+ inline bool operator< (const e_float& u, const long double v) { return (u.cmp(e_float(v)) < static_cast<INT32>(0)); }
+ inline bool operator<=(const e_float& u, const long double v) { return (u.cmp(e_float(v)) <= static_cast<INT32>(0)); }
+ inline bool operator==(const e_float& u, const long double v) { return (u.cmp(e_float(v)) == static_cast<INT32>(0)); }
+ inline bool operator!=(const e_float& u, const long double v) { return (u.cmp(e_float(v)) != static_cast<INT32>(0)); }
+ inline bool operator>=(const e_float& u, const long double v) { return (u.cmp(e_float(v)) >= static_cast<INT32>(0)); }
+ inline bool operator> (const e_float& u, const long double v) { return (u.cmp(e_float(v)) > static_cast<INT32>(0)); }
+
+ // Global comparison operators of all built-in types with const e_float&.
+ inline bool operator< (const char u, const e_float& v) { return (e_float(u).cmp(v) < static_cast<INT32>(0)); }
+ inline bool operator<=(const char u, const e_float& v) { return (e_float(u).cmp(v) <= static_cast<INT32>(0)); }
+ inline bool operator==(const char u, const e_float& v) { return (e_float(u).cmp(v) == static_cast<INT32>(0)); }
+ inline bool operator!=(const char u, const e_float& v) { return (e_float(u).cmp(v) != static_cast<INT32>(0)); }
+ inline bool operator>=(const char u, const e_float& v) { return (e_float(u).cmp(v) >= static_cast<INT32>(0)); }
+ inline bool operator> (const char u, const e_float& v) { return (e_float(u).cmp(v) > static_cast<INT32>(0)); }
+
+ inline bool operator< (const wchar_t u, const e_float& v) { return (e_float(u).cmp(v) < static_cast<INT32>(0)); }
+ inline bool operator<=(const wchar_t u, const e_float& v) { return (e_float(u).cmp(v) <= static_cast<INT32>(0)); }
+ inline bool operator==(const wchar_t u, const e_float& v) { return (e_float(u).cmp(v) == static_cast<INT32>(0)); }
+ inline bool operator!=(const wchar_t u, const e_float& v) { return (e_float(u).cmp(v) != static_cast<INT32>(0)); }
+ inline bool operator>=(const wchar_t u, const e_float& v) { return (e_float(u).cmp(v) >= static_cast<INT32>(0)); }
+ inline bool operator> (const wchar_t u, const e_float& v) { return (e_float(u).cmp(v) > static_cast<INT32>(0)); }
+
+ inline bool operator< (const signed char u, const e_float& v) { return (e_float(u).cmp(v) < static_cast<INT32>(0)); }
+ inline bool operator<=(const signed char u, const e_float& v) { return (e_float(u).cmp(v) <= static_cast<INT32>(0)); }
+ inline bool operator==(const signed char u, const e_float& v) { return (e_float(u).cmp(v) == static_cast<INT32>(0)); }
+ inline bool operator!=(const signed char u, const e_float& v) { return (e_float(u).cmp(v) != static_cast<INT32>(0)); }
+ inline bool operator>=(const signed char u, const e_float& v) { return (e_float(u).cmp(v) >= static_cast<INT32>(0)); }
+ inline bool operator> (const signed char u, const e_float& v) { return (e_float(u).cmp(v) > static_cast<INT32>(0)); }
+
+ inline bool operator< (const signed short u, const e_float& v) { return (e_float(u).cmp(v) < static_cast<INT32>(0)); }
+ inline bool operator<=(const signed short u, const e_float& v) { return (e_float(u).cmp(v) <= static_cast<INT32>(0)); }
+ inline bool operator==(const signed short u, const e_float& v) { return (e_float(u).cmp(v) == static_cast<INT32>(0)); }
+ inline bool operator!=(const signed short u, const e_float& v) { return (e_float(u).cmp(v) != static_cast<INT32>(0)); }
+ inline bool operator>=(const signed short u, const e_float& v) { return (e_float(u).cmp(v) >= static_cast<INT32>(0)); }
+ inline bool operator> (const signed short u, const e_float& v) { return (e_float(u).cmp(v) > static_cast<INT32>(0)); }
+
+ inline bool operator< (const signed int u, const e_float& v) { return (e_float(u).cmp(v) < static_cast<INT32>(0)); }
+ inline bool operator<=(const signed int u, const e_float& v) { return (e_float(u).cmp(v) <= static_cast<INT32>(0)); }
+ inline bool operator==(const signed int u, const e_float& v) { return (e_float(u).cmp(v) == static_cast<INT32>(0)); }
+ inline bool operator!=(const signed int u, const e_float& v) { return (e_float(u).cmp(v) != static_cast<INT32>(0)); }
+ inline bool operator>=(const signed int u, const e_float& v) { return (e_float(u).cmp(v) >= static_cast<INT32>(0)); }
+ inline bool operator> (const signed int u, const e_float& v) { return (e_float(u).cmp(v) > static_cast<INT32>(0)); }
+
+ inline bool operator< (const signed long u, const e_float& v) { return (e_float(u).cmp(v) < static_cast<INT32>(0)); }
+ inline bool operator<=(const signed long u, const e_float& v) { return (e_float(u).cmp(v) <= static_cast<INT32>(0)); }
+ inline bool operator==(const signed long u, const e_float& v) { return (e_float(u).cmp(v) == static_cast<INT32>(0)); }
+ inline bool operator!=(const signed long u, const e_float& v) { return (e_float(u).cmp(v) != static_cast<INT32>(0)); }
+ inline bool operator>=(const signed long u, const e_float& v) { return (e_float(u).cmp(v) >= static_cast<INT32>(0)); }
+ inline bool operator> (const signed long u, const e_float& v) { return (e_float(u).cmp(v) > static_cast<INT32>(0)); }
+
+ inline bool operator< (const signed long long u, const e_float& v) { return (e_float(u).cmp(v) < static_cast<INT32>(0)); }
+ inline bool operator<=(const signed long long u, const e_float& v) { return (e_float(u).cmp(v) <= static_cast<INT32>(0)); }
+ inline bool operator==(const signed long long u, const e_float& v) { return (e_float(u).cmp(v) == static_cast<INT32>(0)); }
+ inline bool operator!=(const signed long long u, const e_float& v) { return (e_float(u).cmp(v) != static_cast<INT32>(0)); }
+ inline bool operator>=(const signed long long u, const e_float& v) { return (e_float(u).cmp(v) >= static_cast<INT32>(0)); }
+ inline bool operator> (const signed long long u, const e_float& v) { return (e_float(u).cmp(v) > static_cast<INT32>(0)); }
+
+ inline bool operator< (const unsigned char u, const e_float& v) { return (e_float(u).cmp(v) < static_cast<INT32>(0)); }
+ inline bool operator<=(const unsigned char u, const e_float& v) { return (e_float(u).cmp(v) <= static_cast<INT32>(0)); }
+ inline bool operator==(const unsigned char u, const e_float& v) { return (e_float(u).cmp(v) == static_cast<INT32>(0)); }
+ inline bool operator!=(const unsigned char u, const e_float& v) { return (e_float(u).cmp(v) != static_cast<INT32>(0)); }
+ inline bool operator>=(const unsigned char u, const e_float& v) { return (e_float(u).cmp(v) >= static_cast<INT32>(0)); }
+ inline bool operator> (const unsigned char u, const e_float& v) { return (e_float(u).cmp(v) > static_cast<INT32>(0)); }
+
+ inline bool operator< (const unsigned short u, const e_float& v) { return (e_float(u).cmp(v) < static_cast<INT32>(0)); }
+ inline bool operator<=(const unsigned short u, const e_float& v) { return (e_float(u).cmp(v) <= static_cast<INT32>(0)); }
+ inline bool operator==(const unsigned short u, const e_float& v) { return (e_float(u).cmp(v) == static_cast<INT32>(0)); }
+ inline bool operator!=(const unsigned short u, const e_float& v) { return (e_float(u).cmp(v) != static_cast<INT32>(0)); }
+ inline bool operator>=(const unsigned short u, const e_float& v) { return (e_float(u).cmp(v) >= static_cast<INT32>(0)); }
+ inline bool operator> (const unsigned short u, const e_float& v) { return (e_float(u).cmp(v) > static_cast<INT32>(0)); }
+
+ inline bool operator< (const unsigned int u, const e_float& v) { return (e_float(u).cmp(v) < static_cast<INT32>(0)); }
+ inline bool operator<=(const unsigned int u, const e_float& v) { return (e_float(u).cmp(v) <= static_cast<INT32>(0)); }
+ inline bool operator==(const unsigned int u, const e_float& v) { return (e_float(u).cmp(v) == static_cast<INT32>(0)); }
+ inline bool operator!=(const unsigned int u, const e_float& v) { return (e_float(u).cmp(v) != static_cast<INT32>(0)); }
+ inline bool operator>=(const unsigned int u, const e_float& v) { return (e_float(u).cmp(v) >= static_cast<INT32>(0)); }
+ inline bool operator> (const unsigned int u, const e_float& v) { return (e_float(u).cmp(v) > static_cast<INT32>(0)); }
+
+ inline bool operator< (const unsigned long u, const e_float& v) { return (e_float(u).cmp(v) < static_cast<INT32>(0)); }
+ inline bool operator<=(const unsigned long u, const e_float& v) { return (e_float(u).cmp(v) <= static_cast<INT32>(0)); }
+ inline bool operator==(const unsigned long u, const e_float& v) { return (e_float(u).cmp(v) == static_cast<INT32>(0)); }
+ inline bool operator!=(const unsigned long u, const e_float& v) { return (e_float(u).cmp(v) != static_cast<INT32>(0)); }
+ inline bool operator>=(const unsigned long u, const e_float& v) { return (e_float(u).cmp(v) >= static_cast<INT32>(0)); }
+ inline bool operator> (const unsigned long u, const e_float& v) { return (e_float(u).cmp(v) > static_cast<INT32>(0)); }
+
+ inline bool operator< (const unsigned long long u, const e_float& v) { return (e_float(u).cmp(v) < static_cast<INT32>(0)); }
+ inline bool operator<=(const unsigned long long u, const e_float& v) { return (e_float(u).cmp(v) <= static_cast<INT32>(0)); }
+ inline bool operator==(const unsigned long long u, const e_float& v) { return (e_float(u).cmp(v) == static_cast<INT32>(0)); }
+ inline bool operator!=(const unsigned long long u, const e_float& v) { return (e_float(u).cmp(v) != static_cast<INT32>(0)); }
+ inline bool operator>=(const unsigned long long u, const e_float& v) { return (e_float(u).cmp(v) >= static_cast<INT32>(0)); }
+ inline bool operator> (const unsigned long long u, const e_float& v) { return (e_float(u).cmp(v) > static_cast<INT32>(0)); }
+
+ inline bool operator< (const float u, const e_float& v) { return (e_float(u).cmp(v) < static_cast<INT32>(0)); }
+ inline bool operator<=(const float u, const e_float& v) { return (e_float(u).cmp(v) <= static_cast<INT32>(0)); }
+ inline bool operator==(const float u, const e_float& v) { return (e_float(u).cmp(v) == static_cast<INT32>(0)); }
+ inline bool operator!=(const float u, const e_float& v) { return (e_float(u).cmp(v) != static_cast<INT32>(0)); }
+ inline bool operator>=(const float u, const e_float& v) { return (e_float(u).cmp(v) >= static_cast<INT32>(0)); }
+ inline bool operator> (const float u, const e_float& v) { return (e_float(u).cmp(v) > static_cast<INT32>(0)); }
+
+ inline bool operator< (const double u, const e_float& v) { return (e_float(u).cmp(v) < static_cast<INT32>(0)); }
+ inline bool operator<=(const double u, const e_float& v) { return (e_float(u).cmp(v) <= static_cast<INT32>(0)); }
+ inline bool operator==(const double u, const e_float& v) { return (e_float(u).cmp(v) == static_cast<INT32>(0)); }
+ inline bool operator!=(const double u, const e_float& v) { return (e_float(u).cmp(v) != static_cast<INT32>(0)); }
+ inline bool operator>=(const double u, const e_float& v) { return (e_float(u).cmp(v) >= static_cast<INT32>(0)); }
+ inline bool operator> (const double u, const e_float& v) { return (e_float(u).cmp(v) > static_cast<INT32>(0)); }
+
+ inline bool operator< (const long double u, const e_float& v) { return (e_float(u).cmp(v) < static_cast<INT32>(0)); }
+ inline bool operator<=(const long double u, const e_float& v) { return (e_float(u).cmp(v) <= static_cast<INT32>(0)); }
+ inline bool operator==(const long double u, const e_float& v) { return (e_float(u).cmp(v) == static_cast<INT32>(0)); }
+ inline bool operator!=(const long double u, const e_float& v) { return (e_float(u).cmp(v) != static_cast<INT32>(0)); }
+ inline bool operator>=(const long double u, const e_float& v) { return (e_float(u).cmp(v) >= static_cast<INT32>(0)); }
+ inline bool operator> (const long double u, const e_float& v) { return (e_float(u).cmp(v) > static_cast<INT32>(0)); }
#endif // _E_FLOAT_HPP_
Modified: sandbox/e_float/boost/e_float/e_float_complex.hpp
==============================================================================
--- sandbox/e_float/boost/e_float/e_float_complex.hpp (original)
+++ sandbox/e_float/boost/e_float/e_float_complex.hpp 2011-09-04 12:09:54 EDT (Sun, 04 Sep 2011)
@@ -11,6 +11,8 @@
#ifndef _E_FLOAT_COMPLEX_HPP_
#define _E_FLOAT_COMPLEX_HPP_
+ #include <complex>
+
#include <boost/e_float/e_float.hpp>
// A separate complex class for e_float has been created. Even though
@@ -242,4 +244,236 @@
inline std::ostream& operator<<(std::ostream& os, const ef_complex& z) { return os << '(' << z.real() << ',' << z.imag() << ')'; }
+ // Global unary operators of e_float reference.
+ inline ef_complex operator-(const ef_complex& u) { return ef_complex(-u.real(), -u.imag()); }
+ inline ef_complex& operator+( ef_complex& u) { return u; }
+ inline const ef_complex& operator+(const ef_complex& u) { return u; }
+
+ // Global operators post-increment and post-decrement
+ 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 arithmetic operators with const ef_complex& and const ef_complex&.
+ 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; }
+ 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; }
+
+ // Global arithmetic operators with const ef_complex& and const e_float&.
+ inline ef_complex operator+(const ef_complex& u, const e_float& v) { return ef_complex(u.real() + v, u.imag()); }
+ inline ef_complex operator-(const ef_complex& u, const e_float& v) { return ef_complex(u.real() - v, u.imag()); }
+ inline ef_complex operator*(const ef_complex& u, const e_float& v) { return ef_complex(u.real() * v, u.imag() * v); }
+ inline ef_complex operator/(const ef_complex& u, const e_float& v) { return ef_complex(u.real() / v, u.imag() / v); }
+
+ // Global arithmetic operators with const e_float& and const ef_complex&.
+ inline ef_complex operator+(const e_float& u, const ef_complex& v) { return ef_complex(u + v.real(), v.imag()); }
+ inline ef_complex operator-(const e_float& u, const ef_complex& v) { return ef_complex(u - v.real(), -v.imag()); }
+ inline ef_complex operator*(const e_float& u, const ef_complex& v) { return ef_complex(u * v.real(), u * v.imag()); }
+ inline ef_complex operator/(const e_float& u, const ef_complex& v) { const e_float v_norm = v.norm(); return ef_complex((u * v.real()) / v_norm, (-u * v.imag()) / v_norm); }
+
+ // Global add/sub/mul/div of const ef_complex& with all built-in types.
+ inline ef_complex operator+(const ef_complex& z, const char n) { return ef_complex(z.real() + n, z.imag()); }
+ inline ef_complex operator+(const ef_complex& z, const signed char n) { return ef_complex(z.real() + n, z.imag()); }
+ inline ef_complex operator+(const ef_complex& z, const signed short n) { return ef_complex(z.real() + n, z.imag()); }
+ inline ef_complex operator+(const ef_complex& z, const signed int n) { return ef_complex(z.real() + n, z.imag()); }
+ inline ef_complex operator+(const ef_complex& z, const signed long n) { return ef_complex(z.real() + n, z.imag()); }
+ inline ef_complex operator+(const ef_complex& z, const signed long long n) { return ef_complex(z.real() + n, z.imag()); }
+ inline ef_complex operator+(const ef_complex& z, const unsigned char n) { return ef_complex(z.real() + n, z.imag()); }
+ inline ef_complex operator+(const ef_complex& z, const wchar_t n) { return ef_complex(z.real() + n, z.imag()); }
+ inline ef_complex operator+(const ef_complex& z, const unsigned short n) { return ef_complex(z.real() + n, z.imag()); }
+ inline ef_complex operator+(const ef_complex& z, const unsigned int n) { return ef_complex(z.real() + n, z.imag()); }
+ inline ef_complex operator+(const ef_complex& z, const unsigned long n) { return ef_complex(z.real() + n, z.imag()); }
+ inline ef_complex operator+(const ef_complex& z, const unsigned long long n) { return ef_complex(z.real() + n, z.imag()); }
+ inline ef_complex operator+(const ef_complex& z, const float f) { return ef_complex(z.real() + f, z.imag()); }
+ inline ef_complex operator+(const ef_complex& z, const double d) { return ef_complex(z.real() + d, z.imag()); }
+ inline ef_complex operator+(const ef_complex& z, const long double ld) { return ef_complex(z.real() + ld, z.imag()); }
+
+ inline ef_complex operator-(const ef_complex& z, const char n) { return ef_complex(z.real() - n, z.imag()); }
+ inline ef_complex operator-(const ef_complex& z, const signed char n) { return ef_complex(z.real() - n, z.imag()); }
+ inline ef_complex operator-(const ef_complex& z, const signed short n) { return ef_complex(z.real() - n, z.imag()); }
+ inline ef_complex operator-(const ef_complex& z, const signed int n) { return ef_complex(z.real() - n, z.imag()); }
+ inline ef_complex operator-(const ef_complex& z, const signed long n) { return ef_complex(z.real() - n, z.imag()); }
+ inline ef_complex operator-(const ef_complex& z, const signed long long n) { return ef_complex(z.real() - n, z.imag()); }
+ inline ef_complex operator-(const ef_complex& z, const unsigned char n) { return ef_complex(z.real() - n, z.imag()); }
+ inline ef_complex operator-(const ef_complex& z, const wchar_t n) { return ef_complex(z.real() - n, z.imag()); }
+ inline ef_complex operator-(const ef_complex& z, const unsigned short n) { return ef_complex(z.real() - n, z.imag()); }
+ inline ef_complex operator-(const ef_complex& z, const unsigned int n) { return ef_complex(z.real() - n, z.imag()); }
+ inline ef_complex operator-(const ef_complex& z, const unsigned long n) { return ef_complex(z.real() - n, z.imag()); }
+ inline ef_complex operator-(const ef_complex& z, const unsigned long long n) { return ef_complex(z.real() - n, z.imag()); }
+ inline ef_complex operator-(const ef_complex& z, const float f) { return ef_complex(z.real() - f, z.imag()); }
+ inline ef_complex operator-(const ef_complex& z, const double d) { return ef_complex(z.real() - d, z.imag()); }
+ inline ef_complex operator-(const ef_complex& z, const long double ld) { return ef_complex(z.real() - ld, z.imag()); }
+
+ inline ef_complex operator*(const ef_complex& z, const char n) { return ef_complex(z.real() * n, z.imag() * n); }
+ inline ef_complex operator*(const ef_complex& z, const signed char n) { return ef_complex(z.real() * n, z.imag() * n); }
+ inline ef_complex operator*(const ef_complex& z, const signed short n) { return ef_complex(z.real() * n, z.imag() * n); }
+ inline ef_complex operator*(const ef_complex& z, const signed int n) { return ef_complex(z.real() * n, z.imag() * n); }
+ inline ef_complex operator*(const ef_complex& z, const signed long n) { return ef_complex(z.real() * n, z.imag() * n); }
+ inline ef_complex operator*(const ef_complex& z, const signed long long n) { return ef_complex(z.real() * n, z.imag() * n); }
+ inline ef_complex operator*(const ef_complex& z, const unsigned char n) { return ef_complex(z.real() * n, z.imag() * n); }
+ inline ef_complex operator*(const ef_complex& z, const wchar_t n) { return ef_complex(z.real() * n, z.imag() * n); }
+ inline ef_complex operator*(const ef_complex& z, const unsigned short n) { return ef_complex(z.real() * n, z.imag() * n); }
+ inline ef_complex operator*(const ef_complex& z, const unsigned int n) { return ef_complex(z.real() * n, z.imag() * n); }
+ inline ef_complex operator*(const ef_complex& z, const unsigned long n) { return ef_complex(z.real() * n, z.imag() * n); }
+ inline ef_complex operator*(const ef_complex& z, const unsigned long long n) { return ef_complex(z.real() * n, z.imag() * n); }
+ inline ef_complex operator*(const ef_complex& z, const float f) { return ef_complex(z.real() * f, z.imag() * f); }
+ inline ef_complex operator*(const ef_complex& z, const double d) { return ef_complex(z.real() * d, z.imag() * d); }
+ inline ef_complex operator*(const ef_complex& z, const long double ld) { return ef_complex(z.real() * ld, z.imag() * ld); }
+
+ inline ef_complex operator/(const ef_complex& z, const char n) { return ef_complex(z.real() / n, z.imag() / n); }
+ inline ef_complex operator/(const ef_complex& z, const signed char n) { return ef_complex(z.real() / n, z.imag() / n); }
+ inline ef_complex operator/(const ef_complex& z, const signed short n) { return ef_complex(z.real() / n, z.imag() / n); }
+ inline ef_complex operator/(const ef_complex& z, const signed int n) { return ef_complex(z.real() / n, z.imag() / n); }
+ inline ef_complex operator/(const ef_complex& z, const signed long n) { return ef_complex(z.real() / n, z.imag() / n); }
+ inline ef_complex operator/(const ef_complex& z, const signed long long n) { return ef_complex(z.real() / n, z.imag() / n); }
+ inline ef_complex operator/(const ef_complex& z, const unsigned char n) { return ef_complex(z.real() / n, z.imag() / n); }
+ inline ef_complex operator/(const ef_complex& z, const wchar_t n) { return ef_complex(z.real() / n, z.imag() / n); }
+ inline ef_complex operator/(const ef_complex& z, const unsigned short n) { return ef_complex(z.real() / n, z.imag() / n); }
+ inline ef_complex operator/(const ef_complex& z, const unsigned int n) { return ef_complex(z.real() / n, z.imag() / n); }
+ inline ef_complex operator/(const ef_complex& z, const unsigned long n) { return ef_complex(z.real() / n, z.imag() / n); }
+ inline ef_complex operator/(const ef_complex& z, const unsigned long long n) { return ef_complex(z.real() / n, z.imag() / n); }
+ inline ef_complex operator/(const ef_complex& z, const float f) { return ef_complex(z.real() / f, z.imag() / f); }
+ inline ef_complex operator/(const ef_complex& z, const double d) { return ef_complex(z.real() / d, z.imag() / d); }
+ inline ef_complex operator/(const ef_complex& z, const long double ld) { return ef_complex(z.real() / ld, z.imag() / ld); }
+
+ // Global add/sub/mul/div of all built-in types with const ef_complex&.
+ inline ef_complex operator+(const char n, const ef_complex& v) { return ef_complex(v.real() + n, v.imag()); }
+ inline ef_complex operator+(const signed char n, const ef_complex& v) { return ef_complex(v.real() + n, v.imag()); }
+ inline ef_complex operator+(const signed short n, const ef_complex& v) { return ef_complex(v.real() + n, v.imag()); }
+ inline ef_complex operator+(const signed int n, const ef_complex& v) { return ef_complex(v.real() + n, v.imag()); }
+ inline ef_complex operator+(const signed long n, const ef_complex& v) { return ef_complex(v.real() + n, v.imag()); }
+ inline ef_complex operator+(const signed long long n, const ef_complex& v) { return ef_complex(v.real() + n, v.imag()); }
+ inline ef_complex operator+(const unsigned char n, const ef_complex& v) { return ef_complex(v.real() + n, v.imag()); }
+ inline ef_complex operator+(const wchar_t n, const ef_complex& v) { return ef_complex(v.real() + n, v.imag()); }
+ inline ef_complex operator+(const unsigned short n, const ef_complex& v) { return ef_complex(v.real() + n, v.imag()); }
+ inline ef_complex operator+(const unsigned int n, const ef_complex& v) { return ef_complex(v.real() + n, v.imag()); }
+ inline ef_complex operator+(const unsigned long n, const ef_complex& v) { return ef_complex(v.real() + n, v.imag()); }
+ inline ef_complex operator+(const unsigned long long n, const ef_complex& v) { return ef_complex(v.real() + n, v.imag()); }
+ inline ef_complex operator+(const float f, const ef_complex& v) { return ef_complex(v.real() + f, v.imag() + f); }
+ inline ef_complex operator+(const double d, const ef_complex& v) { return ef_complex(v.real() + d, v.imag() + d); }
+ inline ef_complex operator+(const long double ld, const ef_complex& v) { return ef_complex(v.real() + ld, v.imag() + ld); }
+
+ inline ef_complex operator-(const char n, const ef_complex& v) { return ef_complex(n - v.real(), -v.imag()); }
+ inline ef_complex operator-(const signed char n, const ef_complex& v) { return ef_complex(n - v.real(), -v.imag()); }
+ inline ef_complex operator-(const signed short n, const ef_complex& v) { return ef_complex(n - v.real(), -v.imag()); }
+ inline ef_complex operator-(const signed int n, const ef_complex& v) { return ef_complex(n - v.real(), -v.imag()); }
+ inline ef_complex operator-(const signed long n, const ef_complex& v) { return ef_complex(n - v.real(), -v.imag()); }
+ inline ef_complex operator-(const signed long long n, const ef_complex& v) { return ef_complex(n - v.real(), -v.imag()); }
+ inline ef_complex operator-(const unsigned char n, const ef_complex& v) { return ef_complex(n - v.real(), -v.imag()); }
+ inline ef_complex operator-(const wchar_t n, const ef_complex& v) { return ef_complex(n - v.real(), -v.imag()); }
+ inline ef_complex operator-(const unsigned short n, const ef_complex& v) { return ef_complex(n - v.real(), -v.imag()); }
+ inline ef_complex operator-(const unsigned int n, const ef_complex& v) { return ef_complex(n - v.real(), -v.imag()); }
+ inline ef_complex operator-(const unsigned long n, const ef_complex& v) { return ef_complex(n - v.real(), -v.imag()); }
+ inline ef_complex operator-(const unsigned long long n, const ef_complex& v) { return ef_complex(n - v.real(), -v.imag()); }
+ inline ef_complex operator-(const float f, const ef_complex& v) { return ef_complex(f - v.real(), -v.imag()); }
+ inline ef_complex operator-(const double d, const ef_complex& v) { return ef_complex(d - v.real(), -v.imag()); }
+ inline ef_complex operator-(const long double ld, const ef_complex& v) { return ef_complex(ld - v.real(), -v.imag()); }
+
+ inline ef_complex operator*(const char n, const ef_complex& v) { return ef_complex(v.real() * n, v.imag() * n); }
+ inline ef_complex operator*(const signed char n, const ef_complex& v) { return ef_complex(v.real() * n, v.imag() * n); }
+ inline ef_complex operator*(const signed short n, const ef_complex& v) { return ef_complex(v.real() * n, v.imag() * n); }
+ inline ef_complex operator*(const signed int n, const ef_complex& v) { return ef_complex(v.real() * n, v.imag() * n); }
+ inline ef_complex operator*(const signed long n, const ef_complex& v) { return ef_complex(v.real() * n, v.imag() * n); }
+ inline ef_complex operator*(const signed long long n, const ef_complex& v) { return ef_complex(v.real() * n, v.imag() * n); }
+ inline ef_complex operator*(const unsigned char n, const ef_complex& v) { return ef_complex(v.real() * n, v.imag() * n); }
+ inline ef_complex operator*(const wchar_t n, const ef_complex& v) { return ef_complex(v.real() * n, v.imag() * n); }
+ inline ef_complex operator*(const unsigned short n, const ef_complex& v) { return ef_complex(v.real() * n, v.imag() * n); }
+ inline ef_complex operator*(const unsigned int n, const ef_complex& v) { return ef_complex(v.real() * n, v.imag() * n); }
+ inline ef_complex operator*(const unsigned long n, const ef_complex& v) { return ef_complex(v.real() * n, v.imag() * n); }
+ inline ef_complex operator*(const unsigned long long n, const ef_complex& v) { return ef_complex(v.real() * n, v.imag() * n); }
+ inline ef_complex operator*(const float f, const ef_complex& v) { return ef_complex(v.real() * f, v.imag() * f); }
+ inline ef_complex operator*(const double d, const ef_complex& v) { return ef_complex(v.real() * d, v.imag() * d); }
+ inline ef_complex operator*(const long double ld, const ef_complex& v) { return ef_complex(v.real() * ld, v.imag() * ld); }
+
+ inline ef_complex operator/(const char n, const ef_complex& v) { const e_float v_norm = v.norm(); return ef_complex((n * v.real()) / v_norm, -(n * v.imag()) / v_norm); }
+ inline ef_complex operator/(const signed char n, const ef_complex& v) { const e_float v_norm = v.norm(); return ef_complex((n * v.real()) / v_norm, -(n * v.imag()) / v_norm); }
+ inline ef_complex operator/(const signed short n, const ef_complex& v) { const e_float v_norm = v.norm(); return ef_complex((n * v.real()) / v_norm, -(n * v.imag()) / v_norm); }
+ inline ef_complex operator/(const signed int n, const ef_complex& v) { const e_float v_norm = v.norm(); return ef_complex((n * v.real()) / v_norm, -(n * v.imag()) / v_norm); }
+ inline ef_complex operator/(const signed long n, const ef_complex& v) { const e_float v_norm = v.norm(); return ef_complex((n * v.real()) / v_norm, -(n * v.imag()) / v_norm); }
+ inline ef_complex operator/(const signed long long n, const ef_complex& v) { const e_float v_norm = v.norm(); return ef_complex((n * v.real()) / v_norm, -(n * v.imag()) / v_norm); }
+ inline ef_complex operator/(const unsigned char n, const ef_complex& v) { const e_float v_norm = v.norm(); return ef_complex((n * v.real()) / v_norm, -(n * v.imag()) / v_norm); }
+ inline ef_complex operator/(const wchar_t n, const ef_complex& v) { const e_float v_norm = v.norm(); return ef_complex((n * v.real()) / v_norm, -(n * v.imag()) / v_norm); }
+ inline ef_complex operator/(const unsigned short n, const ef_complex& v) { const e_float v_norm = v.norm(); return ef_complex((n * v.real()) / v_norm, -(n * v.imag()) / v_norm); }
+ inline ef_complex operator/(const unsigned int n, const ef_complex& v) { const e_float v_norm = v.norm(); return ef_complex((n * v.real()) / v_norm, -(n * v.imag()) / v_norm); }
+ inline ef_complex operator/(const unsigned long n, const ef_complex& v) { const e_float v_norm = v.norm(); return ef_complex((n * v.real()) / v_norm, -(n * v.imag()) / v_norm); }
+ inline ef_complex operator/(const unsigned long long n, const ef_complex& v) { const e_float v_norm = v.norm(); return ef_complex((n * v.real()) / v_norm, -(n * v.imag()) / v_norm); }
+ inline ef_complex operator/(const float f, const ef_complex& v) { const e_float v_norm = v.norm(); return ef_complex((f * v.real()) / v_norm, -(f * v.imag()) / v_norm); }
+ inline ef_complex operator/(const double d, const ef_complex& v) { const e_float v_norm = v.norm(); return ef_complex((d * v.real()) / v_norm, -(d * v.imag()) / v_norm); }
+ inline ef_complex operator/(const long double ld, const ef_complex& v) { const e_float v_norm = v.norm(); return ef_complex((ld * v.real()) / v_norm, -(ld * v.imag()) / v_norm); }
+
+ // Global self add/sub/mul/div of ef_complex& with all built-in types.
+ inline ef_complex& operator+=(ef_complex& z, const char n) { z.Re += n; return z; }
+ inline ef_complex& operator+=(ef_complex& z, const signed char n) { z.Re += n; return z; }
+ inline ef_complex& operator+=(ef_complex& z, const signed short n) { z.Re += n; return z; }
+ inline ef_complex& operator+=(ef_complex& z, const signed int n) { z.Re += n; return z; }
+ inline ef_complex& operator+=(ef_complex& z, const signed long n) { z.Re += n; return z; }
+ inline ef_complex& operator+=(ef_complex& z, const signed long long n) { z.Re += n; return z; }
+ inline ef_complex& operator+=(ef_complex& z, const unsigned char n) { z.Re += n; return z; }
+ inline ef_complex& operator+=(ef_complex& z, const wchar_t n) { z.Re += n; return z; }
+ inline ef_complex& operator+=(ef_complex& z, const unsigned short n) { z.Re += n; return z; }
+ inline ef_complex& operator+=(ef_complex& z, const unsigned int n) { z.Re += n; return z; }
+ inline ef_complex& operator+=(ef_complex& z, const unsigned long n) { z.Re += n; return z; }
+ inline ef_complex& operator+=(ef_complex& z, const unsigned long long n) { z.Re += n; return z; }
+ inline ef_complex& operator+=(ef_complex& z, const float f) { z.Re += f; return z; }
+ inline ef_complex& operator+=(ef_complex& z, const double d) { z.Re += d; return z; }
+ inline ef_complex& operator+=(ef_complex& z, const long double ld) { z.Re += ld; return z; }
+
+ inline ef_complex& operator-=(ef_complex& z, const char n) { z.Re -= n; return z; }
+ inline ef_complex& operator-=(ef_complex& z, const signed char n) { z.Re -= n; return z; }
+ inline ef_complex& operator-=(ef_complex& z, const signed short n) { z.Re -= n; return z; }
+ inline ef_complex& operator-=(ef_complex& z, const signed int n) { z.Re -= n; return z; }
+ inline ef_complex& operator-=(ef_complex& z, const signed long n) { z.Re -= n; return z; }
+ inline ef_complex& operator-=(ef_complex& z, const signed long long n) { z.Re -= n; return z; }
+ inline ef_complex& operator-=(ef_complex& z, const unsigned char n) { z.Re -= n; return z; }
+ inline ef_complex& operator-=(ef_complex& z, const wchar_t n) { z.Re -= n; return z; }
+ inline ef_complex& operator-=(ef_complex& z, const unsigned short n) { z.Re -= n; return z; }
+ inline ef_complex& operator-=(ef_complex& z, const unsigned int n) { z.Re -= n; return z; }
+ inline ef_complex& operator-=(ef_complex& z, const unsigned long n) { z.Re -= n; return z; }
+ inline ef_complex& operator-=(ef_complex& z, const unsigned long long n) { z.Re -= n; return z; }
+ inline ef_complex& operator-=(ef_complex& z, const float f) { z.Re -= f; return z; }
+ inline ef_complex& operator-=(ef_complex& z, const double d) { z.Re -= d; return z; }
+ inline ef_complex& operator-=(ef_complex& z, const long double ld) { z.Re -= ld; return z; }
+
+ inline ef_complex& operator*=(ef_complex& z, const char n) { z.Re *= n; z.Im *= n; return z; }
+ inline ef_complex& operator*=(ef_complex& z, const signed char n) { z.Re *= n; z.Im *= n; return z; }
+ inline ef_complex& operator*=(ef_complex& z, const signed short n) { z.Re *= n; z.Im *= n; return z; }
+ inline ef_complex& operator*=(ef_complex& z, const signed int n) { z.Re *= n; z.Im *= n; return z; }
+ inline ef_complex& operator*=(ef_complex& z, const signed long n) { z.Re *= n; z.Im *= n; return z; }
+ inline ef_complex& operator*=(ef_complex& z, const signed long long n) { z.Re *= n; z.Im *= n; return z; }
+ inline ef_complex& operator*=(ef_complex& z, const unsigned char n) { z.Re *= n; z.Im *= n; return z; }
+ inline ef_complex& operator*=(ef_complex& z, const wchar_t n) { z.Re *= n; z.Im *= n; return z; }
+ inline ef_complex& operator*=(ef_complex& z, const unsigned short n) { z.Re *= n; z.Im *= n; return z; }
+ inline ef_complex& operator*=(ef_complex& z, const unsigned int n) { z.Re *= n; z.Im *= n; return z; }
+ inline ef_complex& operator*=(ef_complex& z, const unsigned long n) { z.Re *= n; z.Im *= n; return z; }
+ inline ef_complex& operator*=(ef_complex& z, const unsigned long long n) { z.Re *= n; z.Im *= n; return z; }
+ inline ef_complex& operator*=(ef_complex& z, const float f) { z.Re *= f; z.Im *= f; return z; }
+ inline ef_complex& operator*=(ef_complex& z, const double d) { z.Re *= d; z.Im *= d; return z; }
+ inline ef_complex& operator*=(ef_complex& z, const long double ld) { z.Re *= ld; z.Im *= ld; return z; }
+
+ inline ef_complex& operator/=(ef_complex& z, const char n) { z.Re /= n; z.Im /= n; return z; }
+ inline ef_complex& operator/=(ef_complex& z, const signed char n) { z.Re /= n; z.Im /= n; return z; }
+ inline ef_complex& operator/=(ef_complex& z, const signed short n) { z.Re /= n; z.Im /= n; return z; }
+ inline ef_complex& operator/=(ef_complex& z, const signed int n) { z.Re /= n; z.Im /= n; return z; }
+ inline ef_complex& operator/=(ef_complex& z, const signed long n) { z.Re /= n; z.Im /= n; return z; }
+ inline ef_complex& operator/=(ef_complex& z, const signed long long n) { z.Re /= n; z.Im /= n; return z; }
+ inline ef_complex& operator/=(ef_complex& z, const unsigned char n) { z.Re /= n; z.Im /= n; return z; }
+ inline ef_complex& operator/=(ef_complex& z, const wchar_t n) { z.Re /= n; z.Im /= n; return z; }
+ inline ef_complex& operator/=(ef_complex& z, const unsigned short n) { z.Re /= n; z.Im /= n; return z; }
+ inline ef_complex& operator/=(ef_complex& z, const unsigned int n) { z.Re /= n; z.Im /= n; return z; }
+ inline ef_complex& operator/=(ef_complex& z, const unsigned long n) { z.Re /= n; z.Im /= n; return z; }
+ inline ef_complex& operator/=(ef_complex& z, const unsigned long long n) { z.Re /= n; z.Im /= n; return z; }
+ inline ef_complex& operator/=(ef_complex& z, const float f) { z.Re /= f; z.Im /= f; return z; }
+ inline ef_complex& operator/=(ef_complex& z, const double d) { z.Re /= d; z.Im /= d; return z; }
+ inline ef_complex& operator/=(ef_complex& z, const long double ld) { z.Re /= ld; z.Im /= ld; return z; }
+
+ // Global self add/sub/mul/div of ef_complex& with const e_float&.
+ inline ef_complex& operator+=(ef_complex& z, const e_float& v) { z.Re += v; return z; }
+ inline ef_complex& operator-=(ef_complex& z, const e_float& v) { z.Re -= v; return z; }
+ inline ef_complex& operator*=(ef_complex& z, const e_float& v) { z.Re *= v; z.Im *= v; return z; }
+ inline ef_complex& operator/=(ef_complex& z, const e_float& v) { z.Re /= v; z.Im /= v; return z; }
+
#endif // _E_FLOAT_COMPLEX_HPP_
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-09-04 12:09:54 EDT (Sun, 04 Sep 2011)
@@ -11,89 +11,4 @@
#ifndef _E_FLOAT_CONSTANTS_HPP_
#define _E_FLOAT_CONSTANTS_HPP_
- #include <boost/e_float/e_float.hpp>
-
- 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& int64_min (void);
- const e_float& int64_max (void);
- const e_float& int32_min (void);
- const e_float& int32_max (void);
- const e_float& unsigned_long_long_max (void);
- const e_float& signed_long_long_max (void);
- const e_float& signed_long_long_min (void);
- const e_float& double_min (void);
- const e_float& double_max (void);
- const e_float& long_double_min (void);
- const e_float& long_double_max (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_elementary.hpp
==============================================================================
--- sandbox/e_float/boost/e_float/e_float_elementary.hpp (original)
+++ sandbox/e_float/boost/e_float/e_float_elementary.hpp 2011-09-04 12:09:54 EDT (Sun, 04 Sep 2011)
@@ -11,8 +11,4 @@
#ifndef _E_FLOAT_ELEMENTARY_HPP_
#define _E_FLOAT_ELEMENTARY_HPP_
- #include <boost/e_float/e_float_elementary_complex.hpp>
- #include <boost/e_float/e_float_elementary_math.hpp>
- #include <boost/e_float/e_float_elementary_trans.hpp>
-
#endif // _E_FLOAT_ELEMENTARY_HPP_
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-09-04 12:09:54 EDT (Sun, 04 Sep 2011)
@@ -11,282 +11,4 @@
#ifndef _E_FLOAT_ELEMENTARY_COMPLEX_HPP_
#define _E_FLOAT_ELEMENTARY_COMPLEX_HPP_
- #include <complex>
-
- #include <boost/e_float/e_float_complex.hpp>
-
- namespace efz
- {
- std::complex<double> to_double(const ef_complex& z);
-
- inline e_float norm(const ef_complex& z) { return z.norm(); }
- e_float abs (const ef_complex& z);
- e_float arg (const ef_complex& z);
- inline e_float real(const ef_complex& z) { return z.real(); }
- inline e_float imag(const ef_complex& z) { return z.imag(); }
-
- inline ef_complex conj(const ef_complex& z) { return ef_complex(z.real(), -z.imag()); }
- inline ef_complex iz (const ef_complex& z) { const e_float tmp(z.real()); return ef_complex(-z.imag(), tmp); }
-
- ef_complex polar (const e_float& mod, const e_float& arg);
- ef_complex sin (const ef_complex& z);
- ef_complex cos (const ef_complex& z);
- ef_complex tan (const ef_complex& z);
- void sincos (const ef_complex& z, ef_complex* const p_sin, ef_complex* const p_cos);
- ef_complex csc (const ef_complex& z);
- ef_complex sec (const ef_complex& z);
- ef_complex cot (const ef_complex& z);
- ef_complex asin (const ef_complex& z);
- ef_complex acos (const ef_complex& z);
- ef_complex atan (const ef_complex& z);
- ef_complex inv (const ef_complex& z);
- ef_complex sqrt (const ef_complex& z);
- ef_complex exp (const ef_complex& z);
- ef_complex log (const ef_complex& z);
- ef_complex log10 (const ef_complex& z);
- ef_complex loga (const ef_complex& a, const ef_complex& z);
- ef_complex pown (const ef_complex& z, const INT64 p);
- ef_complex pow (const ef_complex& z, const ef_complex& a);
- ef_complex rootn (const ef_complex& z, const INT32 p);
- ef_complex sinh (const ef_complex& z);
- ef_complex cosh (const ef_complex& z);
- ef_complex tanh (const ef_complex& z);
- void sinhcosh(const ef_complex& z, ef_complex* const p_sinh, ef_complex* const p_cosh);
- ef_complex asinh (const ef_complex& z);
- ef_complex acosh (const ef_complex& z);
- ef_complex atanh (const ef_complex& z);
- }
-
- // Global unary operators of e_float reference.
- inline ef_complex operator-(const ef_complex& u) { return ef_complex(-u.real(), -u.imag()); }
- inline ef_complex& operator+( ef_complex& u) { return u; }
- inline const ef_complex& operator+(const ef_complex& u) { return u; }
-
- // Global operators post-increment and post-decrement
- 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 arithmetic operators with const ef_complex& and const ef_complex&.
- 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; }
- 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; }
-
- // Global arithmetic operators with const ef_complex& and const e_float&.
- inline ef_complex operator+(const ef_complex& u, const e_float& v) { return ef_complex(u.real() + v, u.imag()); }
- inline ef_complex operator-(const ef_complex& u, const e_float& v) { return ef_complex(u.real() - v, u.imag()); }
- inline ef_complex operator*(const ef_complex& u, const e_float& v) { return ef_complex(u.real() * v, u.imag() * v); }
- inline ef_complex operator/(const ef_complex& u, const e_float& v) { return ef_complex(u.real() / v, u.imag() / v); }
-
- // Global arithmetic operators with const e_float& and const ef_complex&.
- inline ef_complex operator+(const e_float& u, const ef_complex& v) { return ef_complex(u + v.real(), v.imag()); }
- inline ef_complex operator-(const e_float& u, const ef_complex& v) { return ef_complex(u - v.real(), -v.imag()); }
- inline ef_complex operator*(const e_float& u, const ef_complex& v) { return ef_complex(u * v.real(), u * v.imag()); }
- inline ef_complex operator/(const e_float& u, const ef_complex& v) { const e_float v_norm = v.norm(); return ef_complex((u * v.real()) / v_norm, (-u * v.imag()) / v_norm); }
-
- // Global add/sub/mul/div of const ef_complex& with all built-in types.
- inline ef_complex operator+(const ef_complex& z, const char n) { return ef_complex(z.real() + n, z.imag()); }
- inline ef_complex operator+(const ef_complex& z, const signed char n) { return ef_complex(z.real() + n, z.imag()); }
- inline ef_complex operator+(const ef_complex& z, const signed short n) { return ef_complex(z.real() + n, z.imag()); }
- inline ef_complex operator+(const ef_complex& z, const signed int n) { return ef_complex(z.real() + n, z.imag()); }
- inline ef_complex operator+(const ef_complex& z, const signed long n) { return ef_complex(z.real() + n, z.imag()); }
- inline ef_complex operator+(const ef_complex& z, const signed long long n) { return ef_complex(z.real() + n, z.imag()); }
- inline ef_complex operator+(const ef_complex& z, const unsigned char n) { return ef_complex(z.real() + n, z.imag()); }
- inline ef_complex operator+(const ef_complex& z, const wchar_t n) { return ef_complex(z.real() + n, z.imag()); }
- inline ef_complex operator+(const ef_complex& z, const unsigned short n) { return ef_complex(z.real() + n, z.imag()); }
- inline ef_complex operator+(const ef_complex& z, const unsigned int n) { return ef_complex(z.real() + n, z.imag()); }
- inline ef_complex operator+(const ef_complex& z, const unsigned long n) { return ef_complex(z.real() + n, z.imag()); }
- inline ef_complex operator+(const ef_complex& z, const unsigned long long n) { return ef_complex(z.real() + n, z.imag()); }
- inline ef_complex operator+(const ef_complex& z, const float f) { return ef_complex(z.real() + f, z.imag()); }
- inline ef_complex operator+(const ef_complex& z, const double d) { return ef_complex(z.real() + d, z.imag()); }
- inline ef_complex operator+(const ef_complex& z, const long double ld) { return ef_complex(z.real() + ld, z.imag()); }
-
- inline ef_complex operator-(const ef_complex& z, const char n) { return ef_complex(z.real() - n, z.imag()); }
- inline ef_complex operator-(const ef_complex& z, const signed char n) { return ef_complex(z.real() - n, z.imag()); }
- inline ef_complex operator-(const ef_complex& z, const signed short n) { return ef_complex(z.real() - n, z.imag()); }
- inline ef_complex operator-(const ef_complex& z, const signed int n) { return ef_complex(z.real() - n, z.imag()); }
- inline ef_complex operator-(const ef_complex& z, const signed long n) { return ef_complex(z.real() - n, z.imag()); }
- inline ef_complex operator-(const ef_complex& z, const signed long long n) { return ef_complex(z.real() - n, z.imag()); }
- inline ef_complex operator-(const ef_complex& z, const unsigned char n) { return ef_complex(z.real() - n, z.imag()); }
- inline ef_complex operator-(const ef_complex& z, const wchar_t n) { return ef_complex(z.real() - n, z.imag()); }
- inline ef_complex operator-(const ef_complex& z, const unsigned short n) { return ef_complex(z.real() - n, z.imag()); }
- inline ef_complex operator-(const ef_complex& z, const unsigned int n) { return ef_complex(z.real() - n, z.imag()); }
- inline ef_complex operator-(const ef_complex& z, const unsigned long n) { return ef_complex(z.real() - n, z.imag()); }
- inline ef_complex operator-(const ef_complex& z, const unsigned long long n) { return ef_complex(z.real() - n, z.imag()); }
- inline ef_complex operator-(const ef_complex& z, const float f) { return ef_complex(z.real() - f, z.imag()); }
- inline ef_complex operator-(const ef_complex& z, const double d) { return ef_complex(z.real() - d, z.imag()); }
- inline ef_complex operator-(const ef_complex& z, const long double ld) { return ef_complex(z.real() - ld, z.imag()); }
-
- inline ef_complex operator*(const ef_complex& z, const char n) { return ef_complex(z.real() * n, z.imag() * n); }
- inline ef_complex operator*(const ef_complex& z, const signed char n) { return ef_complex(z.real() * n, z.imag() * n); }
- inline ef_complex operator*(const ef_complex& z, const signed short n) { return ef_complex(z.real() * n, z.imag() * n); }
- inline ef_complex operator*(const ef_complex& z, const signed int n) { return ef_complex(z.real() * n, z.imag() * n); }
- inline ef_complex operator*(const ef_complex& z, const signed long n) { return ef_complex(z.real() * n, z.imag() * n); }
- inline ef_complex operator*(const ef_complex& z, const signed long long n) { return ef_complex(z.real() * n, z.imag() * n); }
- inline ef_complex operator*(const ef_complex& z, const unsigned char n) { return ef_complex(z.real() * n, z.imag() * n); }
- inline ef_complex operator*(const ef_complex& z, const wchar_t n) { return ef_complex(z.real() * n, z.imag() * n); }
- inline ef_complex operator*(const ef_complex& z, const unsigned short n) { return ef_complex(z.real() * n, z.imag() * n); }
- inline ef_complex operator*(const ef_complex& z, const unsigned int n) { return ef_complex(z.real() * n, z.imag() * n); }
- inline ef_complex operator*(const ef_complex& z, const unsigned long n) { return ef_complex(z.real() * n, z.imag() * n); }
- inline ef_complex operator*(const ef_complex& z, const unsigned long long n) { return ef_complex(z.real() * n, z.imag() * n); }
- inline ef_complex operator*(const ef_complex& z, const float f) { return ef_complex(z.real() * f, z.imag() * f); }
- inline ef_complex operator*(const ef_complex& z, const double d) { return ef_complex(z.real() * d, z.imag() * d); }
- inline ef_complex operator*(const ef_complex& z, const long double ld) { return ef_complex(z.real() * ld, z.imag() * ld); }
-
- inline ef_complex operator/(const ef_complex& z, const char n) { return ef_complex(z.real() / n, z.imag() / n); }
- inline ef_complex operator/(const ef_complex& z, const signed char n) { return ef_complex(z.real() / n, z.imag() / n); }
- inline ef_complex operator/(const ef_complex& z, const signed short n) { return ef_complex(z.real() / n, z.imag() / n); }
- inline ef_complex operator/(const ef_complex& z, const signed int n) { return ef_complex(z.real() / n, z.imag() / n); }
- inline ef_complex operator/(const ef_complex& z, const signed long n) { return ef_complex(z.real() / n, z.imag() / n); }
- inline ef_complex operator/(const ef_complex& z, const signed long long n) { return ef_complex(z.real() / n, z.imag() / n); }
- inline ef_complex operator/(const ef_complex& z, const unsigned char n) { return ef_complex(z.real() / n, z.imag() / n); }
- inline ef_complex operator/(const ef_complex& z, const wchar_t n) { return ef_complex(z.real() / n, z.imag() / n); }
- inline ef_complex operator/(const ef_complex& z, const unsigned short n) { return ef_complex(z.real() / n, z.imag() / n); }
- inline ef_complex operator/(const ef_complex& z, const unsigned int n) { return ef_complex(z.real() / n, z.imag() / n); }
- inline ef_complex operator/(const ef_complex& z, const unsigned long n) { return ef_complex(z.real() / n, z.imag() / n); }
- inline ef_complex operator/(const ef_complex& z, const unsigned long long n) { return ef_complex(z.real() / n, z.imag() / n); }
- inline ef_complex operator/(const ef_complex& z, const float f) { return ef_complex(z.real() / f, z.imag() / f); }
- inline ef_complex operator/(const ef_complex& z, const double d) { return ef_complex(z.real() / d, z.imag() / d); }
- inline ef_complex operator/(const ef_complex& z, const long double ld) { return ef_complex(z.real() / ld, z.imag() / ld); }
-
- // Global add/sub/mul/div of all built-in types with const ef_complex&.
- inline ef_complex operator+(const char n, const ef_complex& v) { return ef_complex(v.real() + n, v.imag()); }
- inline ef_complex operator+(const signed char n, const ef_complex& v) { return ef_complex(v.real() + n, v.imag()); }
- inline ef_complex operator+(const signed short n, const ef_complex& v) { return ef_complex(v.real() + n, v.imag()); }
- inline ef_complex operator+(const signed int n, const ef_complex& v) { return ef_complex(v.real() + n, v.imag()); }
- inline ef_complex operator+(const signed long n, const ef_complex& v) { return ef_complex(v.real() + n, v.imag()); }
- inline ef_complex operator+(const signed long long n, const ef_complex& v) { return ef_complex(v.real() + n, v.imag()); }
- inline ef_complex operator+(const unsigned char n, const ef_complex& v) { return ef_complex(v.real() + n, v.imag()); }
- inline ef_complex operator+(const wchar_t n, const ef_complex& v) { return ef_complex(v.real() + n, v.imag()); }
- inline ef_complex operator+(const unsigned short n, const ef_complex& v) { return ef_complex(v.real() + n, v.imag()); }
- inline ef_complex operator+(const unsigned int n, const ef_complex& v) { return ef_complex(v.real() + n, v.imag()); }
- inline ef_complex operator+(const unsigned long n, const ef_complex& v) { return ef_complex(v.real() + n, v.imag()); }
- inline ef_complex operator+(const unsigned long long n, const ef_complex& v) { return ef_complex(v.real() + n, v.imag()); }
- inline ef_complex operator+(const float f, const ef_complex& v) { return ef_complex(v.real() + f, v.imag() + f); }
- inline ef_complex operator+(const double d, const ef_complex& v) { return ef_complex(v.real() + d, v.imag() + d); }
- inline ef_complex operator+(const long double ld, const ef_complex& v) { return ef_complex(v.real() + ld, v.imag() + ld); }
-
- inline ef_complex operator-(const char n, const ef_complex& v) { return ef_complex(n - v.real(), -v.imag()); }
- inline ef_complex operator-(const signed char n, const ef_complex& v) { return ef_complex(n - v.real(), -v.imag()); }
- inline ef_complex operator-(const signed short n, const ef_complex& v) { return ef_complex(n - v.real(), -v.imag()); }
- inline ef_complex operator-(const signed int n, const ef_complex& v) { return ef_complex(n - v.real(), -v.imag()); }
- inline ef_complex operator-(const signed long n, const ef_complex& v) { return ef_complex(n - v.real(), -v.imag()); }
- inline ef_complex operator-(const signed long long n, const ef_complex& v) { return ef_complex(n - v.real(), -v.imag()); }
- inline ef_complex operator-(const unsigned char n, const ef_complex& v) { return ef_complex(n - v.real(), -v.imag()); }
- inline ef_complex operator-(const wchar_t n, const ef_complex& v) { return ef_complex(n - v.real(), -v.imag()); }
- inline ef_complex operator-(const unsigned short n, const ef_complex& v) { return ef_complex(n - v.real(), -v.imag()); }
- inline ef_complex operator-(const unsigned int n, const ef_complex& v) { return ef_complex(n - v.real(), -v.imag()); }
- inline ef_complex operator-(const unsigned long n, const ef_complex& v) { return ef_complex(n - v.real(), -v.imag()); }
- inline ef_complex operator-(const unsigned long long n, const ef_complex& v) { return ef_complex(n - v.real(), -v.imag()); }
- inline ef_complex operator-(const float f, const ef_complex& v) { return ef_complex(f - v.real(), -v.imag()); }
- inline ef_complex operator-(const double d, const ef_complex& v) { return ef_complex(d - v.real(), -v.imag()); }
- inline ef_complex operator-(const long double ld, const ef_complex& v) { return ef_complex(ld - v.real(), -v.imag()); }
-
- inline ef_complex operator*(const char n, const ef_complex& v) { return ef_complex(v.real() * n, v.imag() * n); }
- inline ef_complex operator*(const signed char n, const ef_complex& v) { return ef_complex(v.real() * n, v.imag() * n); }
- inline ef_complex operator*(const signed short n, const ef_complex& v) { return ef_complex(v.real() * n, v.imag() * n); }
- inline ef_complex operator*(const signed int n, const ef_complex& v) { return ef_complex(v.real() * n, v.imag() * n); }
- inline ef_complex operator*(const signed long n, const ef_complex& v) { return ef_complex(v.real() * n, v.imag() * n); }
- inline ef_complex operator*(const signed long long n, const ef_complex& v) { return ef_complex(v.real() * n, v.imag() * n); }
- inline ef_complex operator*(const unsigned char n, const ef_complex& v) { return ef_complex(v.real() * n, v.imag() * n); }
- inline ef_complex operator*(const wchar_t n, const ef_complex& v) { return ef_complex(v.real() * n, v.imag() * n); }
- inline ef_complex operator*(const unsigned short n, const ef_complex& v) { return ef_complex(v.real() * n, v.imag() * n); }
- inline ef_complex operator*(const unsigned int n, const ef_complex& v) { return ef_complex(v.real() * n, v.imag() * n); }
- inline ef_complex operator*(const unsigned long n, const ef_complex& v) { return ef_complex(v.real() * n, v.imag() * n); }
- inline ef_complex operator*(const unsigned long long n, const ef_complex& v) { return ef_complex(v.real() * n, v.imag() * n); }
- inline ef_complex operator*(const float f, const ef_complex& v) { return ef_complex(v.real() * f, v.imag() * f); }
- inline ef_complex operator*(const double d, const ef_complex& v) { return ef_complex(v.real() * d, v.imag() * d); }
- inline ef_complex operator*(const long double ld, const ef_complex& v) { return ef_complex(v.real() * ld, v.imag() * ld); }
-
- inline ef_complex operator/(const char n, const ef_complex& v) { const e_float v_norm = v.norm(); return ef_complex((n * v.real()) / v_norm, -(n * v.imag()) / v_norm); }
- inline ef_complex operator/(const signed char n, const ef_complex& v) { const e_float v_norm = v.norm(); return ef_complex((n * v.real()) / v_norm, -(n * v.imag()) / v_norm); }
- inline ef_complex operator/(const signed short n, const ef_complex& v) { const e_float v_norm = v.norm(); return ef_complex((n * v.real()) / v_norm, -(n * v.imag()) / v_norm); }
- inline ef_complex operator/(const signed int n, const ef_complex& v) { const e_float v_norm = v.norm(); return ef_complex((n * v.real()) / v_norm, -(n * v.imag()) / v_norm); }
- inline ef_complex operator/(const signed long n, const ef_complex& v) { const e_float v_norm = v.norm(); return ef_complex((n * v.real()) / v_norm, -(n * v.imag()) / v_norm); }
- inline ef_complex operator/(const signed long long n, const ef_complex& v) { const e_float v_norm = v.norm(); return ef_complex((n * v.real()) / v_norm, -(n * v.imag()) / v_norm); }
- inline ef_complex operator/(const unsigned char n, const ef_complex& v) { const e_float v_norm = v.norm(); return ef_complex((n * v.real()) / v_norm, -(n * v.imag()) / v_norm); }
- inline ef_complex operator/(const wchar_t n, const ef_complex& v) { const e_float v_norm = v.norm(); return ef_complex((n * v.real()) / v_norm, -(n * v.imag()) / v_norm); }
- inline ef_complex operator/(const unsigned short n, const ef_complex& v) { const e_float v_norm = v.norm(); return ef_complex((n * v.real()) / v_norm, -(n * v.imag()) / v_norm); }
- inline ef_complex operator/(const unsigned int n, const ef_complex& v) { const e_float v_norm = v.norm(); return ef_complex((n * v.real()) / v_norm, -(n * v.imag()) / v_norm); }
- inline ef_complex operator/(const unsigned long n, const ef_complex& v) { const e_float v_norm = v.norm(); return ef_complex((n * v.real()) / v_norm, -(n * v.imag()) / v_norm); }
- inline ef_complex operator/(const unsigned long long n, const ef_complex& v) { const e_float v_norm = v.norm(); return ef_complex((n * v.real()) / v_norm, -(n * v.imag()) / v_norm); }
- inline ef_complex operator/(const float f, const ef_complex& v) { const e_float v_norm = v.norm(); return ef_complex((f * v.real()) / v_norm, -(f * v.imag()) / v_norm); }
- inline ef_complex operator/(const double d, const ef_complex& v) { const e_float v_norm = v.norm(); return ef_complex((d * v.real()) / v_norm, -(d * v.imag()) / v_norm); }
- inline ef_complex operator/(const long double ld, const ef_complex& v) { const e_float v_norm = v.norm(); return ef_complex((ld * v.real()) / v_norm, -(ld * v.imag()) / v_norm); }
-
- // Global self add/sub/mul/div of ef_complex& with all built-in types.
- inline ef_complex& operator+=(ef_complex& z, const char n) { z.Re += n; return z; }
- inline ef_complex& operator+=(ef_complex& z, const signed char n) { z.Re += n; return z; }
- inline ef_complex& operator+=(ef_complex& z, const signed short n) { z.Re += n; return z; }
- inline ef_complex& operator+=(ef_complex& z, const signed int n) { z.Re += n; return z; }
- inline ef_complex& operator+=(ef_complex& z, const signed long n) { z.Re += n; return z; }
- inline ef_complex& operator+=(ef_complex& z, const signed long long n) { z.Re += n; return z; }
- inline ef_complex& operator+=(ef_complex& z, const unsigned char n) { z.Re += n; return z; }
- inline ef_complex& operator+=(ef_complex& z, const wchar_t n) { z.Re += n; return z; }
- inline ef_complex& operator+=(ef_complex& z, const unsigned short n) { z.Re += n; return z; }
- inline ef_complex& operator+=(ef_complex& z, const unsigned int n) { z.Re += n; return z; }
- inline ef_complex& operator+=(ef_complex& z, const unsigned long n) { z.Re += n; return z; }
- inline ef_complex& operator+=(ef_complex& z, const unsigned long long n) { z.Re += n; return z; }
- inline ef_complex& operator+=(ef_complex& z, const float f) { z.Re += f; return z; }
- inline ef_complex& operator+=(ef_complex& z, const double d) { z.Re += d; return z; }
- inline ef_complex& operator+=(ef_complex& z, const long double ld) { z.Re += ld; return z; }
-
- inline ef_complex& operator-=(ef_complex& z, const char n) { z.Re -= n; return z; }
- inline ef_complex& operator-=(ef_complex& z, const signed char n) { z.Re -= n; return z; }
- inline ef_complex& operator-=(ef_complex& z, const signed short n) { z.Re -= n; return z; }
- inline ef_complex& operator-=(ef_complex& z, const signed int n) { z.Re -= n; return z; }
- inline ef_complex& operator-=(ef_complex& z, const signed long n) { z.Re -= n; return z; }
- inline ef_complex& operator-=(ef_complex& z, const signed long long n) { z.Re -= n; return z; }
- inline ef_complex& operator-=(ef_complex& z, const unsigned char n) { z.Re -= n; return z; }
- inline ef_complex& operator-=(ef_complex& z, const wchar_t n) { z.Re -= n; return z; }
- inline ef_complex& operator-=(ef_complex& z, const unsigned short n) { z.Re -= n; return z; }
- inline ef_complex& operator-=(ef_complex& z, const unsigned int n) { z.Re -= n; return z; }
- inline ef_complex& operator-=(ef_complex& z, const unsigned long n) { z.Re -= n; return z; }
- inline ef_complex& operator-=(ef_complex& z, const unsigned long long n) { z.Re -= n; return z; }
- inline ef_complex& operator-=(ef_complex& z, const float f) { z.Re -= f; return z; }
- inline ef_complex& operator-=(ef_complex& z, const double d) { z.Re -= d; return z; }
- inline ef_complex& operator-=(ef_complex& z, const long double ld) { z.Re -= ld; return z; }
-
- inline ef_complex& operator*=(ef_complex& z, const char n) { z.Re *= n; z.Im *= n; return z; }
- inline ef_complex& operator*=(ef_complex& z, const signed char n) { z.Re *= n; z.Im *= n; return z; }
- inline ef_complex& operator*=(ef_complex& z, const signed short n) { z.Re *= n; z.Im *= n; return z; }
- inline ef_complex& operator*=(ef_complex& z, const signed int n) { z.Re *= n; z.Im *= n; return z; }
- inline ef_complex& operator*=(ef_complex& z, const signed long n) { z.Re *= n; z.Im *= n; return z; }
- inline ef_complex& operator*=(ef_complex& z, const signed long long n) { z.Re *= n; z.Im *= n; return z; }
- inline ef_complex& operator*=(ef_complex& z, const unsigned char n) { z.Re *= n; z.Im *= n; return z; }
- inline ef_complex& operator*=(ef_complex& z, const wchar_t n) { z.Re *= n; z.Im *= n; return z; }
- inline ef_complex& operator*=(ef_complex& z, const unsigned short n) { z.Re *= n; z.Im *= n; return z; }
- inline ef_complex& operator*=(ef_complex& z, const unsigned int n) { z.Re *= n; z.Im *= n; return z; }
- inline ef_complex& operator*=(ef_complex& z, const unsigned long n) { z.Re *= n; z.Im *= n; return z; }
- inline ef_complex& operator*=(ef_complex& z, const unsigned long long n) { z.Re *= n; z.Im *= n; return z; }
- inline ef_complex& operator*=(ef_complex& z, const float f) { z.Re *= f; z.Im *= f; return z; }
- inline ef_complex& operator*=(ef_complex& z, const double d) { z.Re *= d; z.Im *= d; return z; }
- inline ef_complex& operator*=(ef_complex& z, const long double ld) { z.Re *= ld; z.Im *= ld; return z; }
-
- inline ef_complex& operator/=(ef_complex& z, const char n) { z.Re /= n; z.Im /= n; return z; }
- inline ef_complex& operator/=(ef_complex& z, const signed char n) { z.Re /= n; z.Im /= n; return z; }
- inline ef_complex& operator/=(ef_complex& z, const signed short n) { z.Re /= n; z.Im /= n; return z; }
- inline ef_complex& operator/=(ef_complex& z, const signed int n) { z.Re /= n; z.Im /= n; return z; }
- inline ef_complex& operator/=(ef_complex& z, const signed long n) { z.Re /= n; z.Im /= n; return z; }
- inline ef_complex& operator/=(ef_complex& z, const signed long long n) { z.Re /= n; z.Im /= n; return z; }
- inline ef_complex& operator/=(ef_complex& z, const unsigned char n) { z.Re /= n; z.Im /= n; return z; }
- inline ef_complex& operator/=(ef_complex& z, const wchar_t n) { z.Re /= n; z.Im /= n; return z; }
- inline ef_complex& operator/=(ef_complex& z, const unsigned short n) { z.Re /= n; z.Im /= n; return z; }
- inline ef_complex& operator/=(ef_complex& z, const unsigned int n) { z.Re /= n; z.Im /= n; return z; }
- inline ef_complex& operator/=(ef_complex& z, const unsigned long n) { z.Re /= n; z.Im /= n; return z; }
- inline ef_complex& operator/=(ef_complex& z, const unsigned long long n) { z.Re /= n; z.Im /= n; return z; }
- inline ef_complex& operator/=(ef_complex& z, const float f) { z.Re /= f; z.Im /= f; return z; }
- inline ef_complex& operator/=(ef_complex& z, const double d) { z.Re /= d; z.Im /= d; return z; }
- inline ef_complex& operator/=(ef_complex& z, const long double ld) { z.Re /= ld; z.Im /= ld; return z; }
-
- // Global self add/sub/mul/div of ef_complex& with const e_float&.
- inline ef_complex& operator+=(ef_complex& z, const e_float& v) { z.Re += v; return z; }
- inline ef_complex& operator-=(ef_complex& z, const e_float& v) { z.Re -= v; return z; }
- inline ef_complex& operator*=(ef_complex& z, const e_float& v) { z.Re *= v; z.Im *= v; return z; }
- inline ef_complex& operator/=(ef_complex& z, const e_float& v) { z.Re /= v; z.Im /= v; return z; }
-
#endif // _E_FLOAT_ELEMENTARY_COMPLEX_HPP_
Modified: sandbox/e_float/boost/e_float/e_float_elementary_math.hpp
==============================================================================
--- sandbox/e_float/boost/e_float/e_float_elementary_math.hpp (original)
+++ sandbox/e_float/boost/e_float/e_float_elementary_math.hpp 2011-09-04 12:09:54 EDT (Sun, 04 Sep 2011)
@@ -11,92 +11,4 @@
#ifndef _E_FLOAT_ELEMENTARY_MATH_HPP_
#define _E_FLOAT_ELEMENTARY_MATH_HPP_
- #include <limits>
-
- class ef_complex;
-
- namespace ef
- {
- inline INT32 max_iteration(void) { return static_cast<INT32>(10000); }
-
- e_float floor(const e_float& x);
- e_float ceil (const e_float& x);
- INT32 sgn (const e_float& x);
- e_float ldexp(const e_float& v, int e);
- e_float frexp(const e_float& v, int* expon);
- e_float fmod (const e_float& v1, const e_float& v2);
-
- bool isnan(const double x);
- inline bool isnan(const e_float& x) { return x.isnan(); }
- inline bool isnan(const ef_complex& z) { return z.isnan(); }
-
- bool isfinite(const double x);
- inline bool isfinite(const e_float& x) { return x.isfinite(); }
- inline bool isfinite(const ef_complex& z) { return z.isfinite(); }
-
- bool isinf(const double x);
- inline bool isinf(const e_float& x) { return x.isinf(); }
- inline bool isinf(const ef_complex& z) { return z.isinf(); }
-
- inline bool isneg(const double x) { return (x < 0.0); }
- inline bool isneg(const e_float& x) { return x.isneg(); }
- inline bool isneg(const ef_complex& z) { return z.isneg(); }
-
- inline e_float abs (const e_float& x) { return ef::fabs(x); }
- inline e_float real(const e_float& x) { return x; }
- inline e_float imag(const e_float&) { return ef::zero(); }
-
- inline bool ispos(const double x) { return !isneg(x); }
- inline bool ispos(const e_float& x) { return !x.isneg(); }
- inline bool ispos(const ef_complex& z) { return !z.isneg(); }
-
- bool isint(const double x);
- inline bool isint(const e_float& x) { return x.isint(); }
- inline bool isint(const ef_complex& z) { return z.isint(); }
-
- inline bool isone(const double x) { return (::fabs(1.0 - x) < (std::numeric_limits<double>::min)() * 2); }
- inline bool isone(const e_float& x) { return x.isone(); }
- inline bool isone(const ef_complex& z) { return z.isone(); }
-
- inline bool iszero(const double x) { return (::fabs(x) < (std::numeric_limits<double>::min)() * 2); }
- inline bool iszero(const e_float& x) { return x.iszero(); }
- inline bool iszero(const ef_complex& z) { return z.iszero(); }
-
- e_float integer_part(const e_float& x);
- e_float decimal_part(const e_float& x);
-
- void to_parts(const e_float& x, double& mantissa, INT64& exponent);
-
- inline double to_double(const double& x) { return x; }
- double to_double(const e_float& x);
- double to_double(const ef_complex& z);
-
- inline INT64 order_of(const double x) { return static_cast<INT64>(static_cast<INT32>(::log10(x))); }
- inline INT64 order_of(const e_float& x) { return x.order(); }
-
- INT64 to_int64(const double x);
- INT64 to_int64(const e_float& x);
- INT64 to_int64(const ef_complex& z);
-
- INT32 to_int32(const double x);
- INT32 to_int32(const e_float& x);
- INT32 to_int32(const ef_complex& z);
-
- bool small_arg(const double x);
- bool small_arg(const e_float& x);
- bool small_arg(const ef_complex& z);
-
- bool large_arg(const double x);
- bool large_arg(const e_float& x);
- bool large_arg(const ef_complex& z);
-
- bool near_one(const double x);
- bool near_one(const e_float& x);
- bool near_one(const ef_complex& z);
-
- bool near_int(const double x);
- bool near_int(const e_float& x);
- bool near_int(const ef_complex& z);
- }
-
#endif // _E_FLOAT_ELEMENTARY_MATH_HPP_
Modified: sandbox/e_float/boost/e_float/e_float_elementary_trans.hpp
==============================================================================
--- sandbox/e_float/boost/e_float/e_float_elementary_trans.hpp (original)
+++ sandbox/e_float/boost/e_float/e_float_elementary_trans.hpp 2011-09-04 12:09:54 EDT (Sun, 04 Sep 2011)
@@ -11,56 +11,4 @@
#ifndef _E_FLOAT_ELEMENTARY_TRANS_HPP_
#define _E_FLOAT_ELEMENTARY_TRANS_HPP_
- #include <deque>
-
- namespace ef
- {
- e_float pow2 (const INT64 p);
- e_float pown (const e_float& x, const INT64 p);
- e_float inv (const e_float& x);
- e_float sqrt (const e_float& x);
- e_float cbrt (const e_float& x);
- e_float rootn (const e_float& x, const INT32 p);
- e_float exp (const e_float& x);
- e_float log (const e_float& x);
- e_float log10 (const e_float& x);
- e_float loga (const e_float& a, const e_float& x);
- e_float log1p (const e_float& x);
- e_float log1p1m2(const e_float& x);
- e_float pow (const e_float& x, const e_float& a);
- void sinhcosh(const e_float& x, e_float* const p_sin, e_float* const p_cos);
- e_float sinh (const e_float& x);
- e_float cosh (const e_float& x);
- e_float tanh (const e_float& x);
- e_float asinh (const e_float& x);
- e_float acosh (const e_float& x);
- e_float atanh (const e_float& x);
- }
-
- namespace ef
- {
- void sincos (const e_float& x, e_float* const p_sin, e_float* const p_cos);
- e_float sin (const e_float& x);
- e_float cos (const e_float& x);
- e_float tan (const e_float& x);
- e_float csc (const e_float& x);
- e_float sec (const e_float& x);
- e_float cot (const e_float& x);
- e_float asin (const e_float& x);
- e_float acos (const e_float& x);
- e_float atan (const e_float& x);
- e_float atan2 (const e_float& y, const e_float& x);
- }
-
- namespace ef
- {
- e_float hyp0F0(const e_float& x);
- e_float hyp0F1(const e_float& b, const e_float& x);
- e_float hyp1F0(const e_float& a, const e_float& x);
- e_float hyp1F1(const e_float& a, const e_float& b, const e_float& x);
- e_float hyp2F0(const e_float& a, const e_float& b, const e_float& x);
- e_float hyp2F1(const e_float& a, const e_float& b, const e_float& c, const e_float& x);
- e_float hypPFQ(const std::deque<e_float>& a, const std::deque<e_float>& b, const e_float& x);
- }
-
#endif // _E_FLOAT_ELEMENTARY_TRANS_HPP_
Modified: sandbox/e_float/boost/e_float/e_float_functions.hpp
==============================================================================
--- sandbox/e_float/boost/e_float/e_float_functions.hpp (original)
+++ sandbox/e_float/boost/e_float/e_float_functions.hpp 2011-09-04 12:09:54 EDT (Sun, 04 Sep 2011)
@@ -11,12 +11,279 @@
#ifndef _E_FLOAT_FUNCTIONS_HPP_
#define _E_FLOAT_FUNCTIONS_HPP_
+ #include <vector>
+ #include <deque>
+
+ #include <boost/e_float/e_float.hpp>
#include <boost/e_float/e_float_complex.hpp>
- #include <boost/e_float/e_float_constants.hpp>
- #include <boost/e_float/e_float_integer.hpp>
- #include <boost/e_float/e_float_prime.hpp>
- #include <boost/e_float/e_float_elementary.hpp>
- #include <boost/e_float/e_float_gamma.hpp>
- #include <boost/e_float/e_float_zeta.hpp>
+
+ namespace ef
+ {
+ inline INT32 max_iteration(void) { return static_cast<INT32>(10000); }
+ inline INT64 tol (void) { return static_cast<INT64>(e_float::ef_max_digits10); }
+ inline e_float fabs(const e_float& x) { return (x.isneg() ? e_float(x).negate() : x); }
+
+ e_float floor(const e_float& x);
+ e_float ceil (const e_float& x);
+ INT32 sgn (const e_float& x);
+ e_float ldexp(const e_float& v, int e);
+ e_float frexp(const e_float& v, int* expon);
+ e_float fmod (const e_float& v1, const e_float& v2);
+
+ bool isnan(const double x);
+ inline bool isnan(const e_float& x) { return x.isnan(); }
+ inline bool isnan(const ef_complex& z) { return z.isnan(); }
+
+ bool isfinite(const double x);
+ inline bool isfinite(const e_float& x) { return x.isfinite(); }
+ inline bool isfinite(const ef_complex& z) { return z.isfinite(); }
+
+ bool isinf(const double x);
+ inline bool isinf(const e_float& x) { return x.isinf(); }
+ inline bool isinf(const ef_complex& z) { return z.isinf(); }
+
+ inline bool isneg(const double x) { return (x < 0.0); }
+ inline bool isneg(const e_float& x) { return x.isneg(); }
+ inline bool isneg(const ef_complex& z) { return z.isneg(); }
+
+ inline e_float abs (const e_float& x) { return ef::fabs(x); }
+ inline e_float real(const e_float& x) { return x; }
+ inline e_float imag(const e_float&) { return ef::zero(); }
+
+ inline bool ispos(const double x) { return !isneg(x); }
+ inline bool ispos(const e_float& x) { return !x.isneg(); }
+ inline bool ispos(const ef_complex& z) { return !z.isneg(); }
+
+ bool isint(const double x);
+ inline bool isint(const e_float& x) { return x.isint(); }
+ inline bool isint(const ef_complex& z) { return z.isint(); }
+
+ inline bool isone(const double x) { return (::fabs(1.0 - x) < (std::numeric_limits<double>::min)() * 2); }
+ inline bool isone(const e_float& x) { return x.isone(); }
+ inline bool isone(const ef_complex& z) { return z.isone(); }
+
+ inline bool iszero(const double x) { return (::fabs(x) < (std::numeric_limits<double>::min)() * 2); }
+ inline bool iszero(const e_float& x) { return x.iszero(); }
+ inline bool iszero(const ef_complex& z) { return z.iszero(); }
+
+ e_float integer_part(const e_float& x);
+ e_float decimal_part(const e_float& x);
+
+ void to_parts(const e_float& x, double& mantissa, INT64& exponent);
+
+ inline double to_double(const double& x) { return x; }
+ double to_double(const e_float& x);
+ double to_double(const ef_complex& z);
+
+ inline INT64 order_of(const double x) { return static_cast<INT64>(static_cast<INT32>(::log10(x))); }
+ inline INT64 order_of(const e_float& x) { return x.order(); }
+
+ INT64 to_int64(const double x);
+ INT64 to_int64(const e_float& x);
+ INT64 to_int64(const ef_complex& z);
+
+ INT32 to_int32(const double x);
+ INT32 to_int32(const e_float& x);
+ INT32 to_int32(const ef_complex& z);
+
+ bool small_arg(const double x);
+ bool small_arg(const e_float& x);
+ bool small_arg(const ef_complex& z);
+
+ bool large_arg(const double x);
+ bool large_arg(const e_float& x);
+ bool large_arg(const ef_complex& z);
+
+ bool near_one(const double x);
+ bool near_one(const e_float& x);
+ bool near_one(const ef_complex& z);
+
+ bool near_int(const double x);
+ bool near_int(const e_float& x);
+ bool near_int(const ef_complex& z);
+
+ 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& int64_min (void);
+ const e_float& int64_max (void);
+ const e_float& int32_min (void);
+ const e_float& int32_max (void);
+ const e_float& unsigned_long_long_max (void);
+ const e_float& signed_long_long_max (void);
+ const e_float& signed_long_long_min (void);
+ const e_float& double_min (void);
+ const e_float& double_max (void);
+ const e_float& long_double_min (void);
+ const e_float& long_double_max (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);
+
+ e_float pow2 (const INT64 p);
+ e_float pown (const e_float& x, const INT64 p);
+ e_float inv (const e_float& x);
+ e_float sqrt (const e_float& x);
+ e_float cbrt (const e_float& x);
+ e_float rootn (const e_float& x, const INT32 p);
+ e_float exp (const e_float& x);
+ e_float log (const e_float& x);
+ e_float log10 (const e_float& x);
+ e_float loga (const e_float& a, const e_float& x);
+ e_float log1p (const e_float& x);
+ e_float log1p1m2(const e_float& x);
+ e_float pow (const e_float& x, const e_float& a);
+ void sincos (const e_float& x, e_float* const p_sin, e_float* const p_cos);
+ e_float sin (const e_float& x);
+ e_float cos (const e_float& x);
+ e_float tan (const e_float& x);
+ e_float csc (const e_float& x);
+ e_float sec (const e_float& x);
+ e_float cot (const e_float& x);
+ e_float asin (const e_float& x);
+ e_float acos (const e_float& x);
+ e_float atan (const e_float& x);
+ e_float atan2 (const e_float& y, const e_float& x);
+ void sinhcosh(const e_float& x, e_float* const p_sin, e_float* const p_cos);
+ e_float sinh (const e_float& x);
+ e_float cosh (const e_float& x);
+ e_float tanh (const e_float& x);
+ e_float asinh (const e_float& x);
+ e_float acosh (const e_float& x);
+ e_float atanh (const e_float& x);
+
+ e_float hyp0F0(const e_float& x);
+ e_float hyp0F1(const e_float& b, const e_float& x);
+ e_float hyp1F0(const e_float& a, const e_float& x);
+ e_float hyp1F1(const e_float& a, const e_float& b, const e_float& x);
+ e_float hyp2F0(const e_float& a, const e_float& b, const e_float& x);
+ e_float hyp2F1(const e_float& a, const e_float& b, const e_float& c, const e_float& x);
+ e_float hypPFQ(const std::deque<e_float>& a, const std::deque<e_float>& b, const e_float& x);
+
+ e_float gamma (const e_float& x);
+ e_float gamma_near_n (const INT32 n, const e_float& x);
+ e_float factorial (const UINT32 n);
+ e_float factorial2 (const INT32 n);
+ e_float binomial (const UINT32 n, const UINT32 k);
+ e_float binomial (const UINT32 n, const e_float& y);
+ e_float binomial (const e_float& x, const UINT32 k);
+ e_float binomial (const e_float& x, const e_float& y);
+ e_float pochhammer (const e_float& x, const UINT32 n);
+ e_float pochhammer (const e_float& x, const e_float& a);
+ e_float bernoulli (const UINT32 n);
+ void bernoulli_table(std::vector<e_float>& bn, const UINT32 n);
+ void prime (const UINT32 n, std::deque<UINT32>& primes);
+ e_float riemann_zeta (const INT32 n);
+ e_float riemann_zeta (const e_float& s);
+ }
+
+ namespace efz
+ {
+ std::complex<double> to_double(const ef_complex& z);
+
+ inline e_float norm(const ef_complex& z) { return z.norm(); }
+ e_float abs (const ef_complex& z);
+ e_float arg (const ef_complex& z);
+ inline e_float real(const ef_complex& z) { return z.real(); }
+ inline e_float imag(const ef_complex& z) { return z.imag(); }
+
+ inline ef_complex conj(const ef_complex& z) { return ef_complex(z.real(), -z.imag()); }
+ inline ef_complex iz (const ef_complex& z) { const e_float tmp(z.real()); return ef_complex(-z.imag(), tmp); }
+
+ ef_complex polar (const e_float& mod, const e_float& arg);
+ ef_complex sin (const ef_complex& z);
+ ef_complex cos (const ef_complex& z);
+ ef_complex tan (const ef_complex& z);
+ void sincos (const ef_complex& z, ef_complex* const p_sin, ef_complex* const p_cos);
+ ef_complex csc (const ef_complex& z);
+ ef_complex sec (const ef_complex& z);
+ ef_complex cot (const ef_complex& z);
+ ef_complex asin (const ef_complex& z);
+ ef_complex acos (const ef_complex& z);
+ ef_complex atan (const ef_complex& z);
+ ef_complex inv (const ef_complex& z);
+ ef_complex sqrt (const ef_complex& z);
+ ef_complex exp (const ef_complex& z);
+ ef_complex log (const ef_complex& z);
+ ef_complex log10 (const ef_complex& z);
+ ef_complex loga (const ef_complex& a, const ef_complex& z);
+ ef_complex pown (const ef_complex& z, const INT64 p);
+ ef_complex pow (const ef_complex& z, const ef_complex& a);
+ ef_complex rootn (const ef_complex& z, const INT32 p);
+ ef_complex sinh (const ef_complex& z);
+ ef_complex cosh (const ef_complex& z);
+ ef_complex tanh (const ef_complex& z);
+ void sinhcosh(const ef_complex& z, ef_complex* const p_sinh, ef_complex* const p_cosh);
+ ef_complex asinh (const ef_complex& z);
+ ef_complex acosh (const ef_complex& z);
+ ef_complex atanh (const ef_complex& z);
+
+ ef_complex gamma (const ef_complex& z);
+ ef_complex pochhammer (const ef_complex& z, const UINT32 n);
+ ef_complex pochhammer (const ef_complex& z, const ef_complex& a);
+ ef_complex riemann_zeta(const ef_complex& s);
+ }
#endif // _E_FLOAT_FUNCTIONS_HPP_
Modified: sandbox/e_float/boost/e_float/e_float_gamma.hpp
==============================================================================
--- sandbox/e_float/boost/e_float/e_float_gamma.hpp (original)
+++ sandbox/e_float/boost/e_float/e_float_gamma.hpp 2011-09-04 12:09:54 EDT (Sun, 04 Sep 2011)
@@ -11,27 +11,4 @@
#ifndef _E_FLOAT_GAMMA_HPP_
#define _E_FLOAT_GAMMA_HPP_
- #include <boost/e_float/e_float_complex.hpp>
-
- namespace ef
- {
- e_float gamma (const e_float& x);
- e_float gamma_near_n (const INT32 n, const e_float& x);
- e_float factorial (const UINT32 n);
- e_float factorial2 (const INT32 n);
- e_float binomial (const UINT32 n, const UINT32 k);
- e_float binomial (const UINT32 n, const e_float& y);
- e_float binomial (const e_float& x, const UINT32 k);
- e_float binomial (const e_float& x, const e_float& y);
- e_float pochhammer (const e_float& x, const UINT32 n);
- e_float pochhammer (const e_float& x, const e_float& a);
- }
-
- namespace efz
- {
- ef_complex gamma (const ef_complex& z);
- ef_complex pochhammer (const ef_complex& z, const UINT32 n);
- ef_complex pochhammer (const ef_complex& z, const ef_complex& a);
- }
-
#endif // _E_FLOAT_GAMMA_HPP_
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-09-04 12:09:54 EDT (Sun, 04 Sep 2011)
@@ -11,439 +11,4 @@
#ifndef _E_FLOAT_GLOBAL_MATH_HPP_
#define _E_FLOAT_GLOBAL_MATH_HPP_
- namespace ef
- {
- inline INT64 tol(void) { return static_cast<INT64>(e_float::ef_max_digits10); }
- inline e_float fabs(const e_float& x) { return (x.isneg() ? e_float(x).negate() : x); }
- }
-
- // 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; }
-
- // Global unary operators of e_float reference.
- inline e_float operator-(const e_float& u) { return e_float(u).negate(); }
- 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& 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; }
-
- // Global add/sub/mul/div of const e_float& with all built-in types.
- inline e_float operator+(const e_float& u, const char n) { return ((!std::numeric_limits<char>::is_signed) ? e_float(u).add_unsigned_long_long(static_cast<unsigned long long>(n)) : e_float(u).add_signed_long_long(static_cast<signed long long>(n))); }
- 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 ((!std::numeric_limits<wchar_t>::is_signed) ? e_float(u).add_unsigned_long_long(static_cast<unsigned long long>(n)) : e_float(u).add_signed_long_long(static_cast<signed 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 char n) { return ((!std::numeric_limits<char>::is_signed) ? e_float(u).sub_unsigned_long_long(static_cast<unsigned long long>(n)) : e_float(u).sub_signed_long_long(static_cast<signed long long>(n))); }
- 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 ((!std::numeric_limits<wchar_t>::is_signed) ? e_float(u).sub_unsigned_long_long(static_cast<unsigned long long>(n)) : e_float(u).sub_signed_long_long(static_cast<signed 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 char n) { return ((!std::numeric_limits<char>::is_signed) ? e_float(u).mul_unsigned_long_long(static_cast<unsigned long long>(n)) : e_float(u).mul_signed_long_long(static_cast<signed long long>(n))); }
- 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 ((!std::numeric_limits<wchar_t>::is_signed) ? e_float(u).mul_unsigned_long_long(static_cast<unsigned long long>(n)) : e_float(u).mul_signed_long_long(static_cast<signed 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 char n) { return ((!std::numeric_limits<char>::is_signed) ? e_float(u).div_unsigned_long_long(static_cast<unsigned long long>(n)) : e_float(u).div_signed_long_long(static_cast<signed long long>(n))); }
- 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 ((!std::numeric_limits<wchar_t>::is_signed) ? e_float(u).div_unsigned_long_long(static_cast<unsigned long long>(n)) : e_float(u).div_signed_long_long(static_cast<signed 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 char n, const e_float& u) { return ((!std::numeric_limits<char>::is_signed) ? e_float(u).add_unsigned_long_long(n) : e_float(u).add_signed_long_long(n)); }
- 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 ((!std::numeric_limits<wchar_t>::is_signed) ? e_float(u).add_unsigned_long_long(n) : e_float(u).add_signed_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 char n, const e_float& u) { return e_float(n) -= 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 char n, const e_float& u) { return ((!std::numeric_limits<char>::is_signed) ? e_float(u).mul_unsigned_long_long(n) : e_float(u).mul_signed_long_long(n)); }
- 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 ((!std::numeric_limits<wchar_t>::is_signed) ? e_float(u).mul_unsigned_long_long(n) : e_float(u).mul_signed_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 char n, const e_float& u) { return e_float(n) /= 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 char n) { return ((!std::numeric_limits<char>::is_signed) ? u.add_unsigned_long_long(static_cast<unsigned long long>(n)) : u.add_signed_long_long(static_cast<signed long long>(n))); }
- 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 ((!std::numeric_limits<wchar_t>::is_signed) ? u.add_unsigned_long_long(static_cast<unsigned long long>(n)) : u.add_signed_long_long(static_cast<signed 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 ((!std::numeric_limits<char>::is_signed) ? u.sub_unsigned_long_long(static_cast<unsigned long long>(n)) : u.sub_signed_long_long(static_cast<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 ((!std::numeric_limits<wchar_t>::is_signed) ? u.sub_unsigned_long_long(static_cast<unsigned long long>(n)) : u.sub_signed_long_long(static_cast<signed 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 char n) { return ((!std::numeric_limits<char>::is_signed) ? u.mul_unsigned_long_long(static_cast<unsigned long long>(n)) : u.mul_signed_long_long(static_cast<signed long long>(n))); }
- 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 ((!std::numeric_limits<wchar_t>::is_signed) ? u.mul_unsigned_long_long(static_cast<unsigned long long>(n)) : u.mul_signed_long_long(static_cast<signed 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 char n) { return ((!std::numeric_limits<char>::is_signed) ? u.div_unsigned_long_long(static_cast<unsigned long long>(n)) : u.div_signed_long_long(static_cast<signed long long>(n))); }
- 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 ((!std::numeric_limits<wchar_t>::is_signed) ? u.div_unsigned_long_long(static_cast<unsigned long long>(n)) : u.div_signed_long_long(static_cast<signed 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& 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)); }
- 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)); }
-
- // Global comparison operators of const e_float& with all built-in types.
- inline bool operator< (const e_float& u, const char v) { return (u.cmp(e_float(v)) < static_cast<INT32>(0)); }
- inline bool operator<=(const e_float& u, const char v) { return (u.cmp(e_float(v)) <= static_cast<INT32>(0)); }
- inline bool operator==(const e_float& u, const char v) { return (u.cmp(e_float(v)) == static_cast<INT32>(0)); }
- inline bool operator!=(const e_float& u, const char v) { return (u.cmp(e_float(v)) != static_cast<INT32>(0)); }
- inline bool operator>=(const e_float& u, const char v) { return (u.cmp(e_float(v)) >= static_cast<INT32>(0)); }
- inline bool operator> (const e_float& u, const char v) { return (u.cmp(e_float(v)) > static_cast<INT32>(0)); }
-
- inline bool operator< (const e_float& u, const wchar_t v) { return (u.cmp(e_float(v)) < static_cast<INT32>(0)); }
- inline bool operator<=(const e_float& u, const wchar_t v) { return (u.cmp(e_float(v)) <= static_cast<INT32>(0)); }
- inline bool operator==(const e_float& u, const wchar_t v) { return (u.cmp(e_float(v)) == static_cast<INT32>(0)); }
- inline bool operator!=(const e_float& u, const wchar_t v) { return (u.cmp(e_float(v)) != static_cast<INT32>(0)); }
- inline bool operator>=(const e_float& u, const wchar_t v) { return (u.cmp(e_float(v)) >= static_cast<INT32>(0)); }
- inline bool operator> (const e_float& u, const wchar_t v) { return (u.cmp(e_float(v)) > static_cast<INT32>(0)); }
-
- inline bool operator< (const e_float& u, const signed char v) { return (u.cmp(e_float(v)) < static_cast<INT32>(0)); }
- inline bool operator<=(const e_float& u, const signed char v) { return (u.cmp(e_float(v)) <= static_cast<INT32>(0)); }
- inline bool operator==(const e_float& u, const signed char v) { return (u.cmp(e_float(v)) == static_cast<INT32>(0)); }
- inline bool operator!=(const e_float& u, const signed char v) { return (u.cmp(e_float(v)) != static_cast<INT32>(0)); }
- inline bool operator>=(const e_float& u, const signed char v) { return (u.cmp(e_float(v)) >= static_cast<INT32>(0)); }
- inline bool operator> (const e_float& u, const signed char v) { return (u.cmp(e_float(v)) > static_cast<INT32>(0)); }
-
- inline bool operator< (const e_float& u, const signed short v) { return (u.cmp(e_float(v)) < static_cast<INT32>(0)); }
- inline bool operator<=(const e_float& u, const signed short v) { return (u.cmp(e_float(v)) <= static_cast<INT32>(0)); }
- inline bool operator==(const e_float& u, const signed short v) { return (u.cmp(e_float(v)) == static_cast<INT32>(0)); }
- inline bool operator!=(const e_float& u, const signed short v) { return (u.cmp(e_float(v)) != static_cast<INT32>(0)); }
- inline bool operator>=(const e_float& u, const signed short v) { return (u.cmp(e_float(v)) >= static_cast<INT32>(0)); }
- inline bool operator> (const e_float& u, const signed short v) { return (u.cmp(e_float(v)) > static_cast<INT32>(0)); }
-
- inline bool operator< (const e_float& u, const signed int v) { return (u.cmp(e_float(v)) < static_cast<INT32>(0)); }
- inline bool operator<=(const e_float& u, const signed int v) { return (u.cmp(e_float(v)) <= static_cast<INT32>(0)); }
- inline bool operator==(const e_float& u, const signed int v) { return (u.cmp(e_float(v)) == static_cast<INT32>(0)); }
- inline bool operator!=(const e_float& u, const signed int v) { return (u.cmp(e_float(v)) != static_cast<INT32>(0)); }
- inline bool operator>=(const e_float& u, const signed int v) { return (u.cmp(e_float(v)) >= static_cast<INT32>(0)); }
- inline bool operator> (const e_float& u, const signed int v) { return (u.cmp(e_float(v)) > static_cast<INT32>(0)); }
-
- inline bool operator< (const e_float& u, const signed long v) { return (u.cmp(e_float(v)) < static_cast<INT32>(0)); }
- inline bool operator<=(const e_float& u, const signed long v) { return (u.cmp(e_float(v)) <= static_cast<INT32>(0)); }
- inline bool operator==(const e_float& u, const signed long v) { return (u.cmp(e_float(v)) == static_cast<INT32>(0)); }
- inline bool operator!=(const e_float& u, const signed long v) { return (u.cmp(e_float(v)) != static_cast<INT32>(0)); }
- inline bool operator>=(const e_float& u, const signed long v) { return (u.cmp(e_float(v)) >= static_cast<INT32>(0)); }
- inline bool operator> (const e_float& u, const signed long v) { return (u.cmp(e_float(v)) > static_cast<INT32>(0)); }
-
- inline bool operator< (const e_float& u, const signed long long v) { return (u.cmp(e_float(v)) < static_cast<INT32>(0)); }
- inline bool operator<=(const e_float& u, const signed long long v) { return (u.cmp(e_float(v)) <= static_cast<INT32>(0)); }
- inline bool operator==(const e_float& u, const signed long long v) { return (u.cmp(e_float(v)) == static_cast<INT32>(0)); }
- inline bool operator!=(const e_float& u, const signed long long v) { return (u.cmp(e_float(v)) != static_cast<INT32>(0)); }
- inline bool operator>=(const e_float& u, const signed long long v) { return (u.cmp(e_float(v)) >= static_cast<INT32>(0)); }
- inline bool operator> (const e_float& u, const signed long long v) { return (u.cmp(e_float(v)) > static_cast<INT32>(0)); }
-
- inline bool operator< (const e_float& u, const unsigned char v) { return (u.cmp(e_float(v)) < static_cast<INT32>(0)); }
- inline bool operator<=(const e_float& u, const unsigned char v) { return (u.cmp(e_float(v)) <= static_cast<INT32>(0)); }
- inline bool operator==(const e_float& u, const unsigned char v) { return (u.cmp(e_float(v)) == static_cast<INT32>(0)); }
- inline bool operator!=(const e_float& u, const unsigned char v) { return (u.cmp(e_float(v)) != static_cast<INT32>(0)); }
- inline bool operator>=(const e_float& u, const unsigned char v) { return (u.cmp(e_float(v)) >= static_cast<INT32>(0)); }
- inline bool operator> (const e_float& u, const unsigned char v) { return (u.cmp(e_float(v)) > static_cast<INT32>(0)); }
-
- inline bool operator< (const e_float& u, const unsigned short v) { return (u.cmp(e_float(v)) < static_cast<INT32>(0)); }
- inline bool operator<=(const e_float& u, const unsigned short v) { return (u.cmp(e_float(v)) <= static_cast<INT32>(0)); }
- inline bool operator==(const e_float& u, const unsigned short v) { return (u.cmp(e_float(v)) == static_cast<INT32>(0)); }
- inline bool operator!=(const e_float& u, const unsigned short v) { return (u.cmp(e_float(v)) != static_cast<INT32>(0)); }
- inline bool operator>=(const e_float& u, const unsigned short v) { return (u.cmp(e_float(v)) >= static_cast<INT32>(0)); }
- inline bool operator> (const e_float& u, const unsigned short v) { return (u.cmp(e_float(v)) > static_cast<INT32>(0)); }
-
- inline bool operator< (const e_float& u, const unsigned int v) { return (u.cmp(e_float(v)) < static_cast<INT32>(0)); }
- inline bool operator<=(const e_float& u, const unsigned int v) { return (u.cmp(e_float(v)) <= static_cast<INT32>(0)); }
- inline bool operator==(const e_float& u, const unsigned int v) { return (u.cmp(e_float(v)) == static_cast<INT32>(0)); }
- inline bool operator!=(const e_float& u, const unsigned int v) { return (u.cmp(e_float(v)) != static_cast<INT32>(0)); }
- inline bool operator>=(const e_float& u, const unsigned int v) { return (u.cmp(e_float(v)) >= static_cast<INT32>(0)); }
- inline bool operator> (const e_float& u, const unsigned int v) { return (u.cmp(e_float(v)) > static_cast<INT32>(0)); }
-
- inline bool operator< (const e_float& u, const unsigned long v) { return (u.cmp(e_float(v)) < static_cast<INT32>(0)); }
- inline bool operator<=(const e_float& u, const unsigned long v) { return (u.cmp(e_float(v)) <= static_cast<INT32>(0)); }
- inline bool operator==(const e_float& u, const unsigned long v) { return (u.cmp(e_float(v)) == static_cast<INT32>(0)); }
- inline bool operator!=(const e_float& u, const unsigned long v) { return (u.cmp(e_float(v)) != static_cast<INT32>(0)); }
- inline bool operator>=(const e_float& u, const unsigned long v) { return (u.cmp(e_float(v)) >= static_cast<INT32>(0)); }
- inline bool operator> (const e_float& u, const unsigned long v) { return (u.cmp(e_float(v)) > static_cast<INT32>(0)); }
-
- inline bool operator< (const e_float& u, const unsigned long long v) { return (u.cmp(e_float(v)) < static_cast<INT32>(0)); }
- inline bool operator<=(const e_float& u, const unsigned long long v) { return (u.cmp(e_float(v)) <= static_cast<INT32>(0)); }
- inline bool operator==(const e_float& u, const unsigned long long v) { return (u.cmp(e_float(v)) == static_cast<INT32>(0)); }
- inline bool operator!=(const e_float& u, const unsigned long long v) { return (u.cmp(e_float(v)) != static_cast<INT32>(0)); }
- inline bool operator>=(const e_float& u, const unsigned long long v) { return (u.cmp(e_float(v)) >= static_cast<INT32>(0)); }
- inline bool operator> (const e_float& u, const unsigned long long v) { return (u.cmp(e_float(v)) > static_cast<INT32>(0)); }
-
- inline bool operator< (const e_float& u, const float v) { return (u.cmp(e_float(v)) < static_cast<INT32>(0)); }
- inline bool operator<=(const e_float& u, const float v) { return (u.cmp(e_float(v)) <= static_cast<INT32>(0)); }
- inline bool operator==(const e_float& u, const float v) { return (u.cmp(e_float(v)) == static_cast<INT32>(0)); }
- inline bool operator!=(const e_float& u, const float v) { return (u.cmp(e_float(v)) != static_cast<INT32>(0)); }
- inline bool operator>=(const e_float& u, const float v) { return (u.cmp(e_float(v)) >= static_cast<INT32>(0)); }
- inline bool operator> (const e_float& u, const float v) { return (u.cmp(e_float(v)) > static_cast<INT32>(0)); }
-
- inline bool operator< (const e_float& u, const double v) { return (u.cmp(e_float(v)) < static_cast<INT32>(0)); }
- inline bool operator<=(const e_float& u, const double v) { return (u.cmp(e_float(v)) <= static_cast<INT32>(0)); }
- inline bool operator==(const e_float& u, const double v) { return (u.cmp(e_float(v)) == static_cast<INT32>(0)); }
- inline bool operator!=(const e_float& u, const double v) { return (u.cmp(e_float(v)) != static_cast<INT32>(0)); }
- inline bool operator>=(const e_float& u, const double v) { return (u.cmp(e_float(v)) >= static_cast<INT32>(0)); }
- inline bool operator> (const e_float& u, const double v) { return (u.cmp(e_float(v)) > static_cast<INT32>(0)); }
-
- inline bool operator< (const e_float& u, const long double v) { return (u.cmp(e_float(v)) < static_cast<INT32>(0)); }
- inline bool operator<=(const e_float& u, const long double v) { return (u.cmp(e_float(v)) <= static_cast<INT32>(0)); }
- inline bool operator==(const e_float& u, const long double v) { return (u.cmp(e_float(v)) == static_cast<INT32>(0)); }
- inline bool operator!=(const e_float& u, const long double v) { return (u.cmp(e_float(v)) != static_cast<INT32>(0)); }
- inline bool operator>=(const e_float& u, const long double v) { return (u.cmp(e_float(v)) >= static_cast<INT32>(0)); }
- inline bool operator> (const e_float& u, const long double v) { return (u.cmp(e_float(v)) > static_cast<INT32>(0)); }
-
- // Global comparison operators of all built-in types with const e_float&.
- inline bool operator< (const char u, const e_float& v) { return (e_float(u).cmp(v) < static_cast<INT32>(0)); }
- inline bool operator<=(const char u, const e_float& v) { return (e_float(u).cmp(v) <= static_cast<INT32>(0)); }
- inline bool operator==(const char u, const e_float& v) { return (e_float(u).cmp(v) == static_cast<INT32>(0)); }
- inline bool operator!=(const char u, const e_float& v) { return (e_float(u).cmp(v) != static_cast<INT32>(0)); }
- inline bool operator>=(const char u, const e_float& v) { return (e_float(u).cmp(v) >= static_cast<INT32>(0)); }
- inline bool operator> (const char u, const e_float& v) { return (e_float(u).cmp(v) > static_cast<INT32>(0)); }
-
- inline bool operator< (const wchar_t u, const e_float& v) { return (e_float(u).cmp(v) < static_cast<INT32>(0)); }
- inline bool operator<=(const wchar_t u, const e_float& v) { return (e_float(u).cmp(v) <= static_cast<INT32>(0)); }
- inline bool operator==(const wchar_t u, const e_float& v) { return (e_float(u).cmp(v) == static_cast<INT32>(0)); }
- inline bool operator!=(const wchar_t u, const e_float& v) { return (e_float(u).cmp(v) != static_cast<INT32>(0)); }
- inline bool operator>=(const wchar_t u, const e_float& v) { return (e_float(u).cmp(v) >= static_cast<INT32>(0)); }
- inline bool operator> (const wchar_t u, const e_float& v) { return (e_float(u).cmp(v) > static_cast<INT32>(0)); }
-
- inline bool operator< (const signed char u, const e_float& v) { return (e_float(u).cmp(v) < static_cast<INT32>(0)); }
- inline bool operator<=(const signed char u, const e_float& v) { return (e_float(u).cmp(v) <= static_cast<INT32>(0)); }
- inline bool operator==(const signed char u, const e_float& v) { return (e_float(u).cmp(v) == static_cast<INT32>(0)); }
- inline bool operator!=(const signed char u, const e_float& v) { return (e_float(u).cmp(v) != static_cast<INT32>(0)); }
- inline bool operator>=(const signed char u, const e_float& v) { return (e_float(u).cmp(v) >= static_cast<INT32>(0)); }
- inline bool operator> (const signed char u, const e_float& v) { return (e_float(u).cmp(v) > static_cast<INT32>(0)); }
-
- inline bool operator< (const signed short u, const e_float& v) { return (e_float(u).cmp(v) < static_cast<INT32>(0)); }
- inline bool operator<=(const signed short u, const e_float& v) { return (e_float(u).cmp(v) <= static_cast<INT32>(0)); }
- inline bool operator==(const signed short u, const e_float& v) { return (e_float(u).cmp(v) == static_cast<INT32>(0)); }
- inline bool operator!=(const signed short u, const e_float& v) { return (e_float(u).cmp(v) != static_cast<INT32>(0)); }
- inline bool operator>=(const signed short u, const e_float& v) { return (e_float(u).cmp(v) >= static_cast<INT32>(0)); }
- inline bool operator> (const signed short u, const e_float& v) { return (e_float(u).cmp(v) > static_cast<INT32>(0)); }
-
- inline bool operator< (const signed int u, const e_float& v) { return (e_float(u).cmp(v) < static_cast<INT32>(0)); }
- inline bool operator<=(const signed int u, const e_float& v) { return (e_float(u).cmp(v) <= static_cast<INT32>(0)); }
- inline bool operator==(const signed int u, const e_float& v) { return (e_float(u).cmp(v) == static_cast<INT32>(0)); }
- inline bool operator!=(const signed int u, const e_float& v) { return (e_float(u).cmp(v) != static_cast<INT32>(0)); }
- inline bool operator>=(const signed int u, const e_float& v) { return (e_float(u).cmp(v) >= static_cast<INT32>(0)); }
- inline bool operator> (const signed int u, const e_float& v) { return (e_float(u).cmp(v) > static_cast<INT32>(0)); }
-
- inline bool operator< (const signed long u, const e_float& v) { return (e_float(u).cmp(v) < static_cast<INT32>(0)); }
- inline bool operator<=(const signed long u, const e_float& v) { return (e_float(u).cmp(v) <= static_cast<INT32>(0)); }
- inline bool operator==(const signed long u, const e_float& v) { return (e_float(u).cmp(v) == static_cast<INT32>(0)); }
- inline bool operator!=(const signed long u, const e_float& v) { return (e_float(u).cmp(v) != static_cast<INT32>(0)); }
- inline bool operator>=(const signed long u, const e_float& v) { return (e_float(u).cmp(v) >= static_cast<INT32>(0)); }
- inline bool operator> (const signed long u, const e_float& v) { return (e_float(u).cmp(v) > static_cast<INT32>(0)); }
-
- inline bool operator< (const signed long long u, const e_float& v) { return (e_float(u).cmp(v) < static_cast<INT32>(0)); }
- inline bool operator<=(const signed long long u, const e_float& v) { return (e_float(u).cmp(v) <= static_cast<INT32>(0)); }
- inline bool operator==(const signed long long u, const e_float& v) { return (e_float(u).cmp(v) == static_cast<INT32>(0)); }
- inline bool operator!=(const signed long long u, const e_float& v) { return (e_float(u).cmp(v) != static_cast<INT32>(0)); }
- inline bool operator>=(const signed long long u, const e_float& v) { return (e_float(u).cmp(v) >= static_cast<INT32>(0)); }
- inline bool operator> (const signed long long u, const e_float& v) { return (e_float(u).cmp(v) > static_cast<INT32>(0)); }
-
- inline bool operator< (const unsigned char u, const e_float& v) { return (e_float(u).cmp(v) < static_cast<INT32>(0)); }
- inline bool operator<=(const unsigned char u, const e_float& v) { return (e_float(u).cmp(v) <= static_cast<INT32>(0)); }
- inline bool operator==(const unsigned char u, const e_float& v) { return (e_float(u).cmp(v) == static_cast<INT32>(0)); }
- inline bool operator!=(const unsigned char u, const e_float& v) { return (e_float(u).cmp(v) != static_cast<INT32>(0)); }
- inline bool operator>=(const unsigned char u, const e_float& v) { return (e_float(u).cmp(v) >= static_cast<INT32>(0)); }
- inline bool operator> (const unsigned char u, const e_float& v) { return (e_float(u).cmp(v) > static_cast<INT32>(0)); }
-
- inline bool operator< (const unsigned short u, const e_float& v) { return (e_float(u).cmp(v) < static_cast<INT32>(0)); }
- inline bool operator<=(const unsigned short u, const e_float& v) { return (e_float(u).cmp(v) <= static_cast<INT32>(0)); }
- inline bool operator==(const unsigned short u, const e_float& v) { return (e_float(u).cmp(v) == static_cast<INT32>(0)); }
- inline bool operator!=(const unsigned short u, const e_float& v) { return (e_float(u).cmp(v) != static_cast<INT32>(0)); }
- inline bool operator>=(const unsigned short u, const e_float& v) { return (e_float(u).cmp(v) >= static_cast<INT32>(0)); }
- inline bool operator> (const unsigned short u, const e_float& v) { return (e_float(u).cmp(v) > static_cast<INT32>(0)); }
-
- inline bool operator< (const unsigned int u, const e_float& v) { return (e_float(u).cmp(v) < static_cast<INT32>(0)); }
- inline bool operator<=(const unsigned int u, const e_float& v) { return (e_float(u).cmp(v) <= static_cast<INT32>(0)); }
- inline bool operator==(const unsigned int u, const e_float& v) { return (e_float(u).cmp(v) == static_cast<INT32>(0)); }
- inline bool operator!=(const unsigned int u, const e_float& v) { return (e_float(u).cmp(v) != static_cast<INT32>(0)); }
- inline bool operator>=(const unsigned int u, const e_float& v) { return (e_float(u).cmp(v) >= static_cast<INT32>(0)); }
- inline bool operator> (const unsigned int u, const e_float& v) { return (e_float(u).cmp(v) > static_cast<INT32>(0)); }
-
- inline bool operator< (const unsigned long u, const e_float& v) { return (e_float(u).cmp(v) < static_cast<INT32>(0)); }
- inline bool operator<=(const unsigned long u, const e_float& v) { return (e_float(u).cmp(v) <= static_cast<INT32>(0)); }
- inline bool operator==(const unsigned long u, const e_float& v) { return (e_float(u).cmp(v) == static_cast<INT32>(0)); }
- inline bool operator!=(const unsigned long u, const e_float& v) { return (e_float(u).cmp(v) != static_cast<INT32>(0)); }
- inline bool operator>=(const unsigned long u, const e_float& v) { return (e_float(u).cmp(v) >= static_cast<INT32>(0)); }
- inline bool operator> (const unsigned long u, const e_float& v) { return (e_float(u).cmp(v) > static_cast<INT32>(0)); }
-
- inline bool operator< (const unsigned long long u, const e_float& v) { return (e_float(u).cmp(v) < static_cast<INT32>(0)); }
- inline bool operator<=(const unsigned long long u, const e_float& v) { return (e_float(u).cmp(v) <= static_cast<INT32>(0)); }
- inline bool operator==(const unsigned long long u, const e_float& v) { return (e_float(u).cmp(v) == static_cast<INT32>(0)); }
- inline bool operator!=(const unsigned long long u, const e_float& v) { return (e_float(u).cmp(v) != static_cast<INT32>(0)); }
- inline bool operator>=(const unsigned long long u, const e_float& v) { return (e_float(u).cmp(v) >= static_cast<INT32>(0)); }
- inline bool operator> (const unsigned long long u, const e_float& v) { return (e_float(u).cmp(v) > static_cast<INT32>(0)); }
-
- inline bool operator< (const float u, const e_float& v) { return (e_float(u).cmp(v) < static_cast<INT32>(0)); }
- inline bool operator<=(const float u, const e_float& v) { return (e_float(u).cmp(v) <= static_cast<INT32>(0)); }
- inline bool operator==(const float u, const e_float& v) { return (e_float(u).cmp(v) == static_cast<INT32>(0)); }
- inline bool operator!=(const float u, const e_float& v) { return (e_float(u).cmp(v) != static_cast<INT32>(0)); }
- inline bool operator>=(const float u, const e_float& v) { return (e_float(u).cmp(v) >= static_cast<INT32>(0)); }
- inline bool operator> (const float u, const e_float& v) { return (e_float(u).cmp(v) > static_cast<INT32>(0)); }
-
- inline bool operator< (const double u, const e_float& v) { return (e_float(u).cmp(v) < static_cast<INT32>(0)); }
- inline bool operator<=(const double u, const e_float& v) { return (e_float(u).cmp(v) <= static_cast<INT32>(0)); }
- inline bool operator==(const double u, const e_float& v) { return (e_float(u).cmp(v) == static_cast<INT32>(0)); }
- inline bool operator!=(const double u, const e_float& v) { return (e_float(u).cmp(v) != static_cast<INT32>(0)); }
- inline bool operator>=(const double u, const e_float& v) { return (e_float(u).cmp(v) >= static_cast<INT32>(0)); }
- inline bool operator> (const double u, const e_float& v) { return (e_float(u).cmp(v) > static_cast<INT32>(0)); }
-
- inline bool operator< (const long double u, const e_float& v) { return (e_float(u).cmp(v) < static_cast<INT32>(0)); }
- inline bool operator<=(const long double u, const e_float& v) { return (e_float(u).cmp(v) <= static_cast<INT32>(0)); }
- inline bool operator==(const long double u, const e_float& v) { return (e_float(u).cmp(v) == static_cast<INT32>(0)); }
- inline bool operator!=(const long double u, const e_float& v) { return (e_float(u).cmp(v) != static_cast<INT32>(0)); }
- inline bool operator>=(const long double u, const e_float& v) { return (e_float(u).cmp(v) >= static_cast<INT32>(0)); }
- inline bool operator> (const long double u, const e_float& v) { return (e_float(u).cmp(v) > static_cast<INT32>(0)); }
-
#endif // _E_FLOAT_GLOBAL_MATH_HPP_
Modified: sandbox/e_float/boost/e_float/e_float_integer.hpp
==============================================================================
--- sandbox/e_float/boost/e_float/e_float_integer.hpp (original)
+++ sandbox/e_float/boost/e_float/e_float_integer.hpp 2011-09-04 12:09:54 EDT (Sun, 04 Sep 2011)
@@ -11,14 +11,4 @@
#ifndef _E_FLOAT_INTEGER_HPP_
#define _E_FLOAT_INTEGER_HPP_
- #include <vector>
-
- #include <boost/e_float/e_float.hpp>
-
- namespace ef
- {
- e_float bernoulli (const UINT32 n);
- void bernoulli_table(std::vector<e_float>& bn, const UINT32 n);
- }
-
#endif // _E_FLOAT_INTEGER_HPP_
Modified: sandbox/e_float/boost/e_float/e_float_limits.hpp
==============================================================================
--- sandbox/e_float/boost/e_float/e_float_limits.hpp (original)
+++ sandbox/e_float/boost/e_float/e_float_limits.hpp 2011-09-04 12:09:54 EDT (Sun, 04 Sep 2011)
@@ -11,60 +11,4 @@
#ifndef _E_FLOAT_LIMITS_HPP_
#define _E_FLOAT_LIMITS_HPP_
- #include <limits>
-
- namespace ef
- {
- const e_float& zero (void);
- const e_float& one (void);
- const e_float& half (void);
- const e_float& value_min(void);
- const e_float& value_max(void);
- const e_float& value_eps(void);
- const e_float& value_inf(void);
- const e_float& value_nan(void);
- }
-
- // Specialization of std::numeric_limits<e_float>.
- namespace std
- {
- template <> class numeric_limits<e_float>
- {
- public:
- static const bool is_specialized = true;
- static const bool is_signed = true;
- static const bool is_integer = false;
- static const bool is_exact = false;
- static const bool is_bounded = true;
- static const bool is_modulo = false;
- static const bool is_iec559 = false;
- static const int digits = e_float::ef_digits;
- static const int digits10 = e_float::ef_digits10;
- static const int max_digits10 = e_float::ef_max_digits10;
- static const INT64 min_exponent = e_float::ef_min_exp; // Type differs from int.
- static const INT64 min_exponent10 = e_float::ef_min_exp10; // Type differs from int.
- static const INT64 max_exponent = e_float::ef_max_exp; // Type differs from int.
- static const INT64 max_exponent10 = e_float::ef_max_exp10; // Type differs from int.
- static const int radix = e_float::ef_radix;
- static const std::float_round_style round_style = std::round_to_nearest;
- static const bool has_infinity = true;
- static const bool has_quiet_NaN = true;
- static const bool has_signaling_NaN = false;
- static const std::float_denorm_style has_denorm = std::denorm_absent;
- static const bool has_denorm_loss = false;
- static const bool traps = false;
- static const bool tinyness_before = false;
-
- static const e_float& (min) (void) throw() { return ef::value_min(); }
- static const e_float& (max) (void) throw() { return ef::value_max(); }
- static const e_float& lowest (void) throw() { return ef::zero(); }
- static const e_float& epsilon (void) throw() { return ef::value_eps(); }
- static const e_float& round_error (void) throw() { return ef::half(); }
- static const e_float& infinity (void) throw() { return ef::value_inf(); }
- static const e_float& quiet_NaN (void) throw() { return ef::value_nan(); }
- static const e_float& signaling_NaN(void) throw() { return ef::zero(); }
- static const e_float& denorm_min (void) throw() { return ef::zero(); }
- };
- }
-
#endif // _E_FLOAT_LIMITS_HPP_
Modified: sandbox/e_float/boost/e_float/e_float_prime.hpp
==============================================================================
--- sandbox/e_float/boost/e_float/e_float_prime.hpp (original)
+++ sandbox/e_float/boost/e_float/e_float_prime.hpp 2011-09-04 12:09:54 EDT (Sun, 04 Sep 2011)
@@ -11,13 +11,4 @@
#ifndef _E_FLOAT_PRIME_HPP_
#define _E_FLOAT_PRIME_HPP_
- #include <deque>
-
- #include <boost/e_float/e_float.hpp>
-
- namespace ef
- {
- void prime(const UINT32 n, std::deque<UINT32>& primes);
- }
-
#endif // _PRIME_2008_09_11_H_
Modified: sandbox/e_float/boost/e_float/e_float_zeta.hpp
==============================================================================
--- sandbox/e_float/boost/e_float/e_float_zeta.hpp (original)
+++ sandbox/e_float/boost/e_float/e_float_zeta.hpp 2011-09-04 12:09:54 EDT (Sun, 04 Sep 2011)
@@ -11,18 +11,4 @@
#ifndef _E_FLOAT_ZETA_HPP_
#define _E_FLOAT_ZETA_HPP_
- #include <boost/e_float/e_float.hpp>
- #include <boost/e_float/e_float_complex.hpp>
-
- namespace ef
- {
- e_float riemann_zeta(const INT32 n);
- e_float riemann_zeta(const e_float& s);
- }
-
- namespace efz
- {
- ef_complex riemann_zeta(const ef_complex& s);
- }
-
#endif // _E_FLOAT_ZETA_HPP_
Modified: sandbox/e_float/libs/e_float/example/examples.h
==============================================================================
--- sandbox/e_float/libs/e_float/example/examples.h (original)
+++ sandbox/e_float/libs/e_float/example/examples.h 2011-09-04 12:09:54 EDT (Sun, 04 Sep 2011)
@@ -11,8 +11,7 @@
#ifndef _EXAMPLES_2010_01_02_H_
#define _EXAMPLES_2010_01_02_H_
- #include <boost/e_float/e_float.hpp>
- #include <boost/e_float/e_float_complex.hpp>
+ #include <boost/e_float/e_float_functions.hpp>
namespace examples
{
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-09-04 12:09:54 EDT (Sun, 04 Sep 2011)
@@ -25,9 +25,7 @@
#include <cmath>
#include <utility>
-#include <boost/e_float/e_float.hpp>
-#include <boost/e_float/e_float_constants.hpp>
-#include <boost/e_float/e_float_elementary.hpp>
+#include <boost/e_float/e_float_functions.hpp>
#include "../../utility/util_lexical_cast.h"
#include "../../utility/util_numeric_cast.h"
Modified: sandbox/e_float/libs/e_float/src/e_float/gmp/e_float_gmp.cpp
==============================================================================
--- sandbox/e_float/libs/e_float/src/e_float/gmp/e_float_gmp.cpp (original)
+++ sandbox/e_float/libs/e_float/src/e_float/gmp/e_float_gmp.cpp 2011-09-04 12:09:54 EDT (Sun, 04 Sep 2011)
@@ -14,9 +14,7 @@
#include <algorithm>
#include <cfloat>
-#include <boost/e_float/e_float.hpp>
-#include <boost/e_float/e_float_constants.hpp>
-#include <boost/e_float/e_float_elementary.hpp>
+#include <boost/e_float/e_float_functions.hpp>
#include "e_float_gmp_protos.h"
#include "../../utility/util_lexical_cast.h"
Modified: sandbox/e_float/libs/e_float/src/e_float/mpfr/e_float_mpfr.cpp
==============================================================================
--- sandbox/e_float/libs/e_float/src/e_float/mpfr/e_float_mpfr.cpp (original)
+++ sandbox/e_float/libs/e_float/src/e_float/mpfr/e_float_mpfr.cpp 2011-09-04 12:09:54 EDT (Sun, 04 Sep 2011)
@@ -13,9 +13,7 @@
#include <cstdio>
#include <cstdarg>
-#include <boost/e_float/e_float.hpp>
-#include <boost/e_float/e_float_constants.hpp>
-#include <boost/e_float/e_float_elementary.hpp>
+#include <boost/e_float/e_float_functions.hpp>
#include "e_float_mpfr_protos.h"
#include "../../utility/util_lexical_cast.h"
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-09-04 12:09:54 EDT (Sun, 04 Sep 2011)
@@ -8,9 +8,7 @@
// "Algorithm 910: A Portable C++ Multiple-Precision System for Special-Function Calculations",
// in ACM TOMS, {VOL 37, ISSUE 4, (February 2011)} (C) ACM, 2011. http://doi.acm.org/10.1145/1916461.1916469
-#include <boost/e_float/e_float.hpp>
-#include <boost/e_float/e_float_elementary_trans.hpp>
-#include <boost/e_float/e_float_constants.hpp>
+#include <boost/e_float/e_float_functions.hpp>
const e_float& ef::two (void) { static const e_float val( 2u); return val; }
const e_float& ef::three (void) { static const e_float val( 3u); return val; }
Modified: sandbox/e_float/libs/e_float/src/functions/elementary/elementary_complex.cpp
==============================================================================
--- sandbox/e_float/libs/e_float/src/functions/elementary/elementary_complex.cpp (original)
+++ sandbox/e_float/libs/e_float/src/functions/elementary/elementary_complex.cpp 2011-09-04 12:09:54 EDT (Sun, 04 Sep 2011)
@@ -8,11 +8,7 @@
// "Algorithm 910: A Portable C++ Multiple-Precision System for Special-Function Calculations",
// in ACM TOMS, {VOL 37, ISSUE 4, (February 2011)} (C) ACM, 2011. http://doi.acm.org/10.1145/1916461.1916469
-#include <boost/e_float/e_float_complex.hpp>
-#include <boost/e_float/e_float_constants.hpp>
-#include <boost/e_float/e_float_elementary_complex.hpp>
-#include <boost/e_float/e_float_elementary_math.hpp>
-#include <boost/e_float/e_float_elementary_trans.hpp>
+#include <boost/e_float/e_float_functions.hpp>
#include "../../utility/util_power_x_pow_n.h"
Modified: sandbox/e_float/libs/e_float/src/functions/elementary/elementary_hyper_g.cpp
==============================================================================
--- sandbox/e_float/libs/e_float/src/functions/elementary/elementary_hyper_g.cpp (original)
+++ sandbox/e_float/libs/e_float/src/functions/elementary/elementary_hyper_g.cpp 2011-09-04 12:09:54 EDT (Sun, 04 Sep 2011)
@@ -8,14 +8,11 @@
// "Algorithm 910: A Portable C++ Multiple-Precision System for Special-Function Calculations",
// in ACM TOMS, {VOL 37, ISSUE 4, (February 2011)} (C) ACM, 2011. http://doi.acm.org/10.1145/1916461.1916469
-#include <vector>
#include <algorithm>
#include <numeric>
#include <functional>
-#include <boost/e_float/e_float.hpp>
-#include <boost/e_float/e_float_constants.hpp>
-#include <boost/e_float/e_float_elementary.hpp>
+#include <boost/e_float/e_float_functions.hpp>
e_float ef::hyp0F0(const e_float& x)
{
Modified: sandbox/e_float/libs/e_float/src/functions/elementary/elementary_math.cpp
==============================================================================
--- sandbox/e_float/libs/e_float/src/functions/elementary/elementary_math.cpp (original)
+++ sandbox/e_float/libs/e_float/src/functions/elementary/elementary_math.cpp 2011-09-04 12:09:54 EDT (Sun, 04 Sep 2011)
@@ -8,8 +8,7 @@
// "Algorithm 910: A Portable C++ Multiple-Precision System for Special-Function Calculations",
// in ACM TOMS, {VOL 37, ISSUE 4, (February 2011)} (C) ACM, 2011. http://doi.acm.org/10.1145/1916461.1916469
-#include <boost/e_float/e_float_complex.hpp>
-#include <boost/e_float/e_float_elementary.hpp>
+#include <boost/e_float/e_float_functions.hpp>
#if defined(__GNUC__)
static inline int _isnan (double x) { return std::isnan <double>(x); }
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-09-04 12:09:54 EDT (Sun, 04 Sep 2011)
@@ -12,9 +12,7 @@
#include <numeric>
#include <map>
-#include <boost/e_float/e_float.hpp>
-#include <boost/e_float/e_float_constants.hpp>
-#include <boost/e_float/e_float_elementary.hpp>
+#include <boost/e_float/e_float_functions.hpp>
#include "../../utility/util_lexical_cast.h"
#include "../../utility/util_power_x_pow_n.h"
Modified: sandbox/e_float/libs/e_float/src/functions/elementary/elementary_trig.cpp
==============================================================================
--- sandbox/e_float/libs/e_float/src/functions/elementary/elementary_trig.cpp (original)
+++ sandbox/e_float/libs/e_float/src/functions/elementary/elementary_trig.cpp 2011-09-04 12:09:54 EDT (Sun, 04 Sep 2011)
@@ -19,9 +19,7 @@
//
// *****************************************************************************
-#include <boost/e_float/e_float.hpp>
-#include <boost/e_float/e_float_constants.hpp>
-#include <boost/e_float/e_float_elementary.hpp>
+#include <boost/e_float/e_float_functions.hpp>
e_float ef::sin(const e_float& x)
{
Modified: sandbox/e_float/libs/e_float/src/functions/gamma/factorial.cpp
==============================================================================
--- sandbox/e_float/libs/e_float/src/functions/gamma/factorial.cpp (original)
+++ sandbox/e_float/libs/e_float/src/functions/gamma/factorial.cpp 2011-09-04 12:09:54 EDT (Sun, 04 Sep 2011)
@@ -9,9 +9,7 @@
// in ACM TOMS, {VOL 37, ISSUE 4, (February 2011)} (C) ACM, 2011. http://doi.acm.org/10.1145/1916461.1916469
#include <boost/e_float/e_float.hpp>
-#include <boost/e_float/e_float_constants.hpp>
-#include <boost/e_float/e_float_elementary.hpp>
-#include <boost/e_float/e_float_gamma.hpp>
+#include <boost/e_float/e_float_functions.hpp>
#include "../tables/tables.h"
Modified: sandbox/e_float/libs/e_float/src/functions/gamma/factorial2.cpp
==============================================================================
--- sandbox/e_float/libs/e_float/src/functions/gamma/factorial2.cpp (original)
+++ sandbox/e_float/libs/e_float/src/functions/gamma/factorial2.cpp 2011-09-04 12:09:54 EDT (Sun, 04 Sep 2011)
@@ -8,9 +8,7 @@
// "Algorithm 910: A Portable C++ Multiple-Precision System for Special-Function Calculations",
// in ACM TOMS, {VOL 37, ISSUE 4, (February 2011)} (C) ACM, 2011. http://doi.acm.org/10.1145/1916461.1916469
-#include <boost/e_float/e_float_complex.hpp>
-#include <boost/e_float/e_float_elementary.hpp>
-#include <boost/e_float/e_float_gamma.hpp>
+#include <boost/e_float/e_float_functions.hpp>
#include "../tables/tables.h"
Modified: sandbox/e_float/libs/e_float/src/functions/gamma/gamma.cpp
==============================================================================
--- sandbox/e_float/libs/e_float/src/functions/gamma/gamma.cpp (original)
+++ sandbox/e_float/libs/e_float/src/functions/gamma/gamma.cpp 2011-09-04 12:09:54 EDT (Sun, 04 Sep 2011)
@@ -10,11 +10,7 @@
#include <numeric>
-#include <boost/e_float/e_float_complex.hpp>
-#include <boost/e_float/e_float_constants.hpp>
-#include <boost/e_float/e_float_elementary.hpp>
-#include <boost/e_float/e_float_integer.hpp>
-#include <boost/e_float/e_float_gamma.hpp>
+#include <boost/e_float/e_float_functions.hpp>
#include "../tables/tables.h"
#include "../../utility/util_coefficient_expansion.h"
Modified: sandbox/e_float/libs/e_float/src/functions/gamma/gamma_util.cpp
==============================================================================
--- sandbox/e_float/libs/e_float/src/functions/gamma/gamma_util.cpp (original)
+++ sandbox/e_float/libs/e_float/src/functions/gamma/gamma_util.cpp 2011-09-04 12:09:54 EDT (Sun, 04 Sep 2011)
@@ -8,10 +8,7 @@
// "Algorithm 910: A Portable C++ Multiple-Precision System for Special-Function Calculations",
// in ACM TOMS, {VOL 37, ISSUE 4, (February 2011)} (C) ACM, 2011. http://doi.acm.org/10.1145/1916461.1916469
-#include <boost/e_float/e_float.hpp>
-#include <boost/e_float/e_float_constants.hpp>
-#include <boost/e_float/e_float_elementary.hpp>
-#include <boost/e_float/e_float_gamma.hpp>
+#include <boost/e_float/e_float_functions.hpp>
#include "gamma_util.h"
void GammaUtil::GammaOfPlusXMinusX(const e_float& x, e_float& gamma_plus_x, e_float& gamma_minus_x)
Modified: sandbox/e_float/libs/e_float/src/functions/gamma/pochhammer.cpp
==============================================================================
--- sandbox/e_float/libs/e_float/src/functions/gamma/pochhammer.cpp (original)
+++ sandbox/e_float/libs/e_float/src/functions/gamma/pochhammer.cpp 2011-09-04 12:09:54 EDT (Sun, 04 Sep 2011)
@@ -8,9 +8,7 @@
// "Algorithm 910: A Portable C++ Multiple-Precision System for Special-Function Calculations",
// in ACM TOMS, {VOL 37, ISSUE 4, (February 2011)} (C) ACM, 2011. http://doi.acm.org/10.1145/1916461.1916469
-#include <boost/e_float/e_float_complex.hpp>
-#include <boost/e_float/e_float_elementary.hpp>
-#include <boost/e_float/e_float_gamma.hpp>
+#include <boost/e_float/e_float_functions.hpp>
namespace Pochhammer_Series
{
Modified: sandbox/e_float/libs/e_float/src/functions/integer/bernoulli_b.cpp
==============================================================================
--- sandbox/e_float/libs/e_float/src/functions/integer/bernoulli_b.cpp (original)
+++ sandbox/e_float/libs/e_float/src/functions/integer/bernoulli_b.cpp 2011-09-04 12:09:54 EDT (Sun, 04 Sep 2011)
@@ -8,11 +8,7 @@
// "Algorithm 910: A Portable C++ Multiple-Precision System for Special-Function Calculations",
// in ACM TOMS, {VOL 37, ISSUE 4, (February 2011)} (C) ACM, 2011. http://doi.acm.org/10.1145/1916461.1916469
-#include <boost/e_float/e_float.hpp>
-#include <boost/e_float/e_float_constants.hpp>
-#include <boost/e_float/e_float_elementary.hpp>
-#include <boost/e_float/e_float_integer.hpp>
-#include <boost/e_float/e_float_gamma.hpp>
+#include <boost/e_float/e_float_functions.hpp>
#include "../tables/tables.h"
Modified: sandbox/e_float/libs/e_float/src/functions/integer/prime.cpp
==============================================================================
--- sandbox/e_float/libs/e_float/src/functions/integer/prime.cpp (original)
+++ sandbox/e_float/libs/e_float/src/functions/integer/prime.cpp 2011-09-04 12:09:54 EDT (Sun, 04 Sep 2011)
@@ -8,17 +8,15 @@
// "Algorithm 910: A Portable C++ Multiple-Precision System for Special-Function Calculations",
// in ACM TOMS, {VOL 37, ISSUE 4, (February 2011)} (C) ACM, 2011. http://doi.acm.org/10.1145/1916461.1916469
-#include <vector>
#include <algorithm>
-#include <boost/e_float/e_float_prime.hpp>
+#include <boost/e_float/e_float_functions.hpp>
namespace Primes
{
struct Inserter
{
private:
-
mutable UINT32 count;
mutable std::back_insert_iterator<std::deque<UINT32> > it;
Modified: sandbox/e_float/libs/e_float/src/functions/integer/prime_factor.cpp
==============================================================================
--- sandbox/e_float/libs/e_float/src/functions/integer/prime_factor.cpp (original)
+++ sandbox/e_float/libs/e_float/src/functions/integer/prime_factor.cpp 2011-09-04 12:09:54 EDT (Sun, 04 Sep 2011)
@@ -8,11 +8,9 @@
// "Algorithm 910: A Portable C++ Multiple-Precision System for Special-Function Calculations",
// in ACM TOMS, {VOL 37, ISSUE 4, (February 2011)} (C) ACM, 2011. http://doi.acm.org/10.1145/1916461.1916469
-#include <vector>
#include <algorithm>
-#include <boost/e_float/e_float_prime.hpp>
-
+#include <boost/e_float/e_float_functions.hpp>
#include "prime_factors.h"
namespace Primes
Modified: sandbox/e_float/libs/e_float/src/functions/zeta/zeta.cpp
==============================================================================
--- sandbox/e_float/libs/e_float/src/functions/zeta/zeta.cpp (original)
+++ sandbox/e_float/libs/e_float/src/functions/zeta/zeta.cpp 2011-09-04 12:09:54 EDT (Sun, 04 Sep 2011)
@@ -10,15 +10,7 @@
#include <algorithm>
-#include <boost/e_float/e_float.hpp>
-
-#include <boost/e_float/e_float_complex.hpp>
-#include <boost/e_float/e_float_constants.hpp>
-#include <boost/e_float/e_float_elementary.hpp>
-#include <boost/e_float/e_float_integer.hpp>
-#include <boost/e_float/e_float_gamma.hpp>
-#include <boost/e_float/e_float_prime.hpp>
-#include <boost/e_float/e_float_zeta.hpp>
+#include <boost/e_float/e_float_functions.hpp>
#include "../tables/tables.h"
#include "../../utility/util_power_j_pow_x.h"
Modified: sandbox/e_float/libs/e_float/src/generic_functions/constants/generic_functions_constants.h
==============================================================================
--- sandbox/e_float/libs/e_float/src/generic_functions/constants/generic_functions_constants.h (original)
+++ sandbox/e_float/libs/e_float/src/generic_functions/constants/generic_functions_constants.h 2011-09-04 12:09:54 EDT (Sun, 04 Sep 2011)
@@ -11,7 +11,7 @@
#ifndef _GENERIC_FUNCTIONS_CONSTANTS_2011_06_18_H_
#define _GENERIC_FUNCTIONS_CONSTANTS_2011_06_18_H_
- #include <boost/e_float/e_float_constants.hpp>
+ #include <boost/e_float/e_float_functions.hpp>
namespace generic_functions
{
Modified: sandbox/e_float/libs/e_float/src/generic_functions/elementary/generic_functions_elementary.h
==============================================================================
--- sandbox/e_float/libs/e_float/src/generic_functions/elementary/generic_functions_elementary.h (original)
+++ sandbox/e_float/libs/e_float/src/generic_functions/elementary/generic_functions_elementary.h 2011-09-04 12:09:54 EDT (Sun, 04 Sep 2011)
@@ -12,10 +12,9 @@
#define _GENERIC_FUNCTIONS_ELEMENTARY_2011_06_18_H_
#include <cmath>
- #include <limits>
#include <regex>
- #include <boost/e_float/e_float_elementary.hpp>
+ #include <boost/e_float/e_float_functions.hpp>
namespace generic_functions
{
Modified: sandbox/e_float/libs/e_float/src/utility/util_power_j_pow_x.cpp
==============================================================================
--- sandbox/e_float/libs/e_float/src/utility/util_power_j_pow_x.cpp (original)
+++ sandbox/e_float/libs/e_float/src/utility/util_power_j_pow_x.cpp 2011-09-04 12:09:54 EDT (Sun, 04 Sep 2011)
@@ -8,12 +8,7 @@
// "Algorithm 910: A Portable C++ Multiple-Precision System for Special-Function Calculations",
// in ACM TOMS, {VOL 37, ISSUE 4, (February 2011)} (C) ACM, 2011. http://doi.acm.org/10.1145/1916461.1916469
-#include <deque>
-
-#include <boost/e_float/e_float_complex.hpp>
-#include <boost/e_float/e_float_prime.hpp>
-#include <boost/e_float/e_float_constants.hpp>
-#include <boost/e_float/e_float_elementary.hpp>
+#include <boost/e_float/e_float_functions.hpp>
#include "../functions/integer/prime_factors.h"
#include "util_point.h"
Modified: sandbox/e_float/libs/e_float/src/utility/util_power_j_pow_x.h
==============================================================================
--- sandbox/e_float/libs/e_float/src/utility/util_power_j_pow_x.h (original)
+++ sandbox/e_float/libs/e_float/src/utility/util_power_j_pow_x.h 2011-09-04 12:09:54 EDT (Sun, 04 Sep 2011)
@@ -13,7 +13,7 @@
#include <map>
- #include <boost/e_float/e_float_complex.hpp>
+ #include <boost/e_float/e_float_functions.hpp>
namespace Util
{
Modified: sandbox/e_float/libs/e_float/test/test_case_base.h
==============================================================================
--- sandbox/e_float/libs/e_float/test/test_case_base.h (original)
+++ sandbox/e_float/libs/e_float/test/test_case_base.h 2011-09-04 12:09:54 EDT (Sun, 04 Sep 2011)
@@ -12,14 +12,13 @@
#define _TEST_CASE_BASE_2009_11_12_H_
#include <string>
- #include <vector>
#include <fstream>
#include <iomanip>
#include <algorithm>
#include <iterator>
- #include <boost/e_float/e_float_complex.hpp>
+ #include <boost/e_float/e_float_functions.hpp>
#include "../src/utility/util_noncopyable.h"
namespace test
Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk