Subject: [Boost-commit] svn:boost r73822 - in sandbox/e_float: boost/e_float libs/e_float/src/e_float libs/e_float/src/e_float/efx libs/e_float/test/real/cases
From: e_float_at_[hidden]
Date: 2011-08-16 16:00:35
Author: christopher_kormanyos
Date: 2011-08-16 16:00:34 EDT (Tue, 16 Aug 2011)
New Revision: 73822
URL: http://svn.boost.org/trac/boost/changeset/73822
Log:
- Corrected all ostream manipulations.
- Added more tests thereof.
- Worked out equality of (std::numeric_limits<e_float>::min() == 0).
- Changed std::numeric_limits<e_float>::max_digits10 to include guard digits.
Text files modified:
sandbox/e_float/boost/e_float/e_float_base.hpp | 17 -
sandbox/e_float/libs/e_float/src/e_float/e_float_base.cpp | 427 +++++++++++++++++++++++++++++----------
sandbox/e_float/libs/e_float/src/e_float/efx/e_float_efx.cpp | 22 +
sandbox/e_float/libs/e_float/test/real/cases/test_case_0000x_overflow_underflow.cpp | 6
sandbox/e_float/libs/e_float/test/real/cases/test_case_0000y_write_to_ostream.cpp | 81 ++++++-
5 files changed, 409 insertions(+), 144 deletions(-)
Modified: sandbox/e_float/boost/e_float/e_float_base.hpp
==============================================================================
--- sandbox/e_float/boost/e_float/e_float_base.hpp (original)
+++ sandbox/e_float/boost/e_float/e_float_base.hpp 2011-08-16 16:00:34 EDT (Tue, 16 Aug 2011)
@@ -184,11 +184,11 @@
static e_float my_cyl_bessel_jn(const INT32, const e_float&);
static e_float my_cyl_bessel_yn(const INT32, const e_float&);
+ static bool char_is_nonzero_predicate(const char& c) { return (c != static_cast<char>('0')); }
+
protected:
inline e_float_base();
- static bool char_is_nonzero_predicate(const char& c) { return (c != static_cast<char>('0')); }
-
// Emphasize: This template class can be used with native floating-point
// types like float, double and long double. Note: For long double,
// you need to verify that the mantissa fits in unsigned long long.
@@ -251,19 +251,6 @@
virtual INT64 get_order_exact(void) const = 0;
virtual INT64 get_order_fast(void) const = 0;
virtual void get_output_string(std::string& str, INT64& my_exp, const std::size_t number_of_digits) const = 0;
-
- static void wr_string_scientific(std::string& str,
- const INT64 my_exp,
- const std::size_t os_precision,
- const bool my_showpoint,
- const bool my_uppercase,
- const bool trim_trailing_zeros = false);
-
- static void wr_string_fixed(std::string& str,
- const INT64 my_exp,
- const std::size_t os_precision,
- const bool my_showpoint,
- const bool trim_trailing_zeros = false);
};
// Create a loud link error if the digits in the
Modified: sandbox/e_float/libs/e_float/src/e_float/e_float_base.cpp
==============================================================================
--- sandbox/e_float/libs/e_float/src/e_float/e_float_base.cpp (original)
+++ sandbox/e_float/libs/e_float/src/e_float/e_float_base.cpp 2011-08-16 16:00:34 EDT (Tue, 16 Aug 2011)
@@ -21,7 +21,27 @@
os_float_field_fixed,
os_float_field_none
}
- os_float_filed_type;
+ os_float_field_type;
+
+ void wr_string_scientific(std::string& str,
+ const INT64 my_exp,
+ const std::size_t os_precision,
+ const bool my_showpoint,
+ const bool my_uppercase,
+ const bool trim_trailing_zeros = false);
+
+ void wr_string_fixed(std::string& str,
+ const INT64 my_exp,
+ const std::size_t os_precision,
+ const bool my_showpoint,
+ const bool trim_trailing_zeros = false);
+
+ void special_handle_string_not_finite(std::string& str,
+ const e_float& f,
+ const bool my_showpos,
+ const bool my_uppercase);
+
+ void special_extend_string_to_precision(std::string& str, const std::size_t os_precision);
}
bool e_float_base::digits_match_lib_dll_is_ok;
@@ -111,38 +131,22 @@
const bool my_showpos = ((my_flags & std::ios::showpos) != static_cast<std::ios::fmtflags>(0u));
const bool my_uppercase = ((my_flags & std::ios::uppercase) != static_cast<std::ios::fmtflags>(0u));
- // Handle INF and NaN.
- if(!isfinite())
- {
- if(isinf())
- {
- if(my_uppercase)
- {
- str = ((!isneg()) ? (my_showpos ? std::string("+INF") : std::string("INF")) : std::string("-INF"));
- }
- else
- {
- str = ((!isneg()) ? (my_showpos ? std::string("+inf") : std::string("inf")) : std::string("-inf"));
- }
- }
- else
- {
- str = (my_uppercase ? std::string("NAN") : std::string("nan"));
- }
-
- return;
- }
+ // Use special handling for non-finite numbers (inf and nan).
+ if(!isfinite()) { ::special_handle_string_not_finite(str, static_cast<const e_float&>(*this), my_showpos, my_uppercase); return; }
// Get the base-10 exponent.
INT64 my_exp = get_order_exact();
// Get the output stream's precision and limit it to max_digits10.
- // Erroneous negative precision will be set to the zero.
- const std::size_t os_precision = ((os.precision() > std::streamsize(-1)) ? static_cast<std::size_t>(os.precision())
- : static_cast<std::size_t>(0u));
+ // Erroneous zero or negative precision (theoretically impossible)
+ // will be set to ostream's default precision.
+ static const std::stringstream str_default;
+ static const std::streamsize prec_default = str_default.precision();
+
+ const std::size_t os_precision = ((os.precision() <= static_cast<std::streamsize>(0)) ? static_cast<std::size_t>(prec_default) : static_cast<std::size_t>(os.precision()));
// Determine the kind of output format requested (scientific, fixed, none).
- os_float_filed_type my_float_field;
+ os_float_field_type my_float_field;
if ((my_flags & std::ios::scientific) != static_cast<std::ios::fmtflags>(0u)) { my_float_field = os_float_field_scientific; }
else if((my_flags & std::ios::fixed) != static_cast<std::ios::fmtflags>(0u)) { my_float_field = os_float_field_fixed; }
@@ -155,16 +159,17 @@
else if(my_float_field == os_float_field_fixed) { use_fixed = true; }
else // os_float_field_none
{
- if(my_exp < static_cast<INT64>(-4))
+ // Set up the range for dynamic detection of scientific notation.
+ // If the exponent is less than -4 or larger than a precision-dependent
+ // positive bound, then scientific notation is used.
+ static const INT64 neg_bound_for_scientific_neg_exp = static_cast<INT64>(-4);
+ const INT64 min_bound_for_scientific_pos_exp = (std::max)(static_cast<INT64>(os_precision), static_cast<INT64>(prec_default));
+ const INT64 pos_bound_for_scientific_pos_exp = (std::min)(static_cast<INT64>(std::numeric_limits<e_float>::digits10), min_bound_for_scientific_pos_exp);
+
+ if( (my_exp < neg_bound_for_scientific_neg_exp)
+ || (my_exp >= pos_bound_for_scientific_pos_exp)
+ )
{
- // The number is small in magnitude with a large, negative exponent.
- // Use exponential notation.
- use_scientific = true;
- }
- else if(my_exp >= (std::min)(static_cast<INT64>(std::numeric_limits<e_float>::digits10), (std::max)(static_cast<INT64>(os_precision), static_cast<INT64>(7))))
- {
- // The number is large in magnitude with a large, positive exponent.
- // Use exponential notation.
use_scientific = true;
}
else
@@ -208,6 +213,15 @@
}
}
+ // If the float field is not set, reduce the number of digits requested
+ // from e_float such that it neither exceeds the ostream's precision
+ // nor e_float's max_digits10.
+ if(my_float_field == os_float_field_none)
+ {
+ const std::size_t max_digits = (std::min)(os_precision, static_cast<std::size_t>(std::numeric_limits<e_float>::max_digits10));
+ the_number_of_digits_i_want_from_e_float = (std::min)(the_number_of_digits_i_want_from_e_float, max_digits);
+ }
+
// Extract the rounded output string with the desired number of digits.
get_output_string(str, my_exp, the_number_of_digits_i_want_from_e_float);
@@ -244,116 +258,200 @@
}
}
-void e_float_base::wr_string_scientific(std::string& str,
- const INT64 my_exp,
- const std::size_t os_precision,
- const bool my_showpoint,
- const bool my_uppercase,
- const bool trim_trailing_zeros)
+namespace
{
- if(os_precision > static_cast<std::size_t>(str.length() - 1u))
+ void special_handle_string_not_finite(std::string& str,
+ const e_float& f,
+ const bool my_showpos,
+ const bool my_uppercase)
{
- // Zero-extend the string to the given precision if necessary.
- const std::size_t n_pad = static_cast<std::size_t>(os_precision - (str.length() - 1u));
-
- str.insert(str.end(), n_pad, static_cast<char>('0'));
- }
-
- // Insert the decimal point.
- str.insert(static_cast<std::size_t>(1u), ".");
-
- // Remove all trailing zeros if necessary.
- if(trim_trailing_zeros)
- {
- const std::string::const_reverse_iterator rit_non_zero = std::find_if(str.rbegin(), str.rend(), char_is_nonzero_predicate);
-
- if(rit_non_zero != str.rbegin())
+ // Handle INF and NaN.
+ if(f.isinf())
{
- const std::size_t ofs = str.length() - std::distance<std::string::const_reverse_iterator>(str.rbegin(), rit_non_zero);
- str.erase(str.begin() + ofs, str.end());
+ if(my_uppercase)
+ {
+ str = ((!f.isneg()) ? (my_showpos ? std::string("+INF") : std::string("INF")) : std::string("-INF"));
+ }
+ else
+ {
+ str = ((!f.isneg()) ? (my_showpos ? std::string("+inf") : std::string("inf")) : std::string("-inf"));
+ }
+ }
+ else
+ {
+ str = (my_uppercase ? std::string("NAN") : std::string("nan"));
}
}
- // Remove the trailing decimal point if necessary.
- if((*(str.end() - 1u) == static_cast<char>('.')) && (!my_showpoint))
+ void wr_string_scientific(std::string& str,
+ const INT64 my_exp,
+ const std::size_t os_precision,
+ const bool my_showpoint,
+ const bool my_uppercase,
+ const bool trim_trailing_zeros)
{
- str.erase(str.end() - 1u, str.end());
- }
+ if(os_precision > static_cast<std::size_t>(str.length() - 1u))
+ {
+ // Zero-extend the string to the given precision if necessary.
+ const std::size_t n_pad = static_cast<std::size_t>(os_precision - (str.length() - 1u));
- // Append the exponent in uppercase or lower case, including its sign.
- const bool b_exp_is_neg = (my_exp < static_cast<INT64>(0));
- const UINT64 u_exp = static_cast<UINT64>(!b_exp_is_neg ? my_exp : static_cast<INT64>(-my_exp));
+ str.insert(str.end(), n_pad, static_cast<char>('0'));
+ }
- str += (my_uppercase ? "E" : "e");
- str += (b_exp_is_neg ? "-" : "+");
- std::string str_exp = Util::lexical_cast(static_cast<INT64>(u_exp));
+ // Insert the decimal point.
+ str.insert(static_cast<std::size_t>(1u), ".");
- // Format the exponent string to have a width that is an even multiple of three.
- const std::size_t str_exp_len = str_exp.length();
- const std::size_t str_exp_len_mod3 = static_cast<std::size_t>(str_exp_len % 3u);
- const std::size_t str_exp_len_pad = ((str_exp_len_mod3 != static_cast<std::size_t>(0u)) ? static_cast<std::size_t>(3u - (str_exp_len % 3u))
- : static_cast<std::size_t>(0u));
+ // Trim the trailing zeros, where the trim-characteristics depend on the showpoint flag.
+ if(trim_trailing_zeros)
+ {
+ const std::string::const_reverse_iterator rit_non_zero = std::find_if(str.rbegin(), str.rend(), e_float_base::char_is_nonzero_predicate);
- str += std::string(str_exp_len_pad, static_cast<char>('0'));
- str += str_exp;
-}
+ if(rit_non_zero != str.rbegin())
+ {
+ const std::size_t ofs = str.length() - std::distance<std::string::const_reverse_iterator>(str.rbegin(), rit_non_zero);
+ str.erase(str.begin() + ofs, str.end());
+ }
+ }
-void e_float_base::wr_string_fixed(std::string& str,
- const INT64 my_exp,
- const std::size_t os_precision,
- const bool my_showpoint,
- const bool trim_trailing_zeros)
-{
- const std::size_t str_len = str.length();
+ // Perform the final manipulations on the digits of the string.
+ if(my_showpoint)
+ {
+ if(trim_trailing_zeros) { ::special_extend_string_to_precision(str, os_precision); }
+ }
+ else
+ {
+ // Remove the trailing decimal point if necessary.
+ if(*(str.end() - 1u) == static_cast<char>('.'))
+ {
+ str.erase(str.end() - 1u, str.end());
+ }
+ }
- if(my_exp < static_cast<INT64>(0))
- {
- // The number is less than one in magnitude. Insert the decimal
- // point using "0" or "0." as well as the needed leading zeros.
- const std::size_t minus_exp_minus_one = static_cast<std::size_t>(-my_exp - 1);
- const std::string str_zero_insert((std::min)(minus_exp_minus_one, os_precision), static_cast<char>('0'));
+ // Append the exponent in uppercase or lower case, including its sign.
+ const bool b_exp_is_neg = (my_exp < static_cast<INT64>(0));
+ const UINT64 u_exp = static_cast<UINT64>(!b_exp_is_neg ? my_exp : static_cast<INT64>(-my_exp));
- str.insert(0u, "0." + str_zero_insert);
+ str += (my_uppercase ? "E" : "e");
+ str += (b_exp_is_neg ? "-" : "+");
+ std::string str_exp = Util::lexical_cast(static_cast<INT64>(u_exp));
- const INT64 n_pad = static_cast<INT64>(static_cast<INT64>(os_precision) - static_cast<INT64>(str_len + str_zero_insert.length()));
+ // Format the exponent string to have a width that is an even multiple of three.
+ const std::size_t str_exp_len = str_exp.length();
+ const std::size_t str_exp_len_mod3 = static_cast<std::size_t>(str_exp_len % 3u);
+ const std::size_t str_exp_len_pad = ((str_exp_len_mod3 != static_cast<std::size_t>(0u)) ? static_cast<std::size_t>(3u - (str_exp_len % 3u))
+ : static_cast<std::size_t>(0u));
- if(n_pad > static_cast<INT64>(0))
- {
- str.insert(str.end(), static_cast<std::size_t>(n_pad), static_cast<char>('0'));
- }
+ str += std::string(str_exp_len_pad, static_cast<char>('0'));
+ str += str_exp;
}
- else
+
+ void wr_string_fixed(std::string& str,
+ const INT64 my_exp,
+ const std::size_t os_precision,
+ const bool my_showpoint,
+ const bool trim_trailing_zeros)
{
- // Insert the decimal point.
- const std::size_t my_exp_plus_one = static_cast<std::size_t>(my_exp + 1);
+ const std::size_t input_str_len = str.length();
- str.insert(my_exp_plus_one, ".");
+ if(my_exp < static_cast<INT64>(0))
+ {
+ // The number is less than one in magnitude. Insert the decimal
+ // point using "0." as well as the needed number of leading zeros.
+ const std::size_t minus_exp_minus_one = static_cast<std::size_t>(-my_exp - 1);
+ const std::string str_zero_insert((std::min)(minus_exp_minus_one, os_precision), static_cast<char>('0'));
+
+ const INT64 n_pad = static_cast<INT64>(static_cast<INT64>(os_precision) - static_cast<INT64>(str.length() + str_zero_insert.length()));
- // Zero-extend the string to the given precision if necessary.
- const INT64 n_pad = static_cast<INT64>(os_precision) - static_cast<INT64>(static_cast<INT64>(str_len) - (my_exp + 1));
+ str.insert(0u, "0." + str_zero_insert);
- if(n_pad > static_cast<INT64>(0))
+ // Zero-extend the string to the given precision if necessary.
+ if(n_pad > static_cast<INT64>(0))
+ {
+ str.insert(str.end(), static_cast<std::size_t>(n_pad), static_cast<char>('0'));
+ }
+ }
+ else
{
- str.insert(str.end(), static_cast<std::size_t>(n_pad), static_cast<char>('0'));
+ // Insert the decimal point.
+ const std::size_t my_exp_plus_one = static_cast<std::size_t>(my_exp + 1);
+
+ // The number string is not large enough to hold the integer part of the number.
+ // Zero extend the integer part of the string.
+ if(input_str_len < my_exp_plus_one)
+ {
+ str.insert(str.end(), static_cast<std::size_t>(my_exp_plus_one- str.length()), static_cast<char>('0'));
+ }
+
+ str.insert(my_exp_plus_one, ".");
+
+ // Zero-extend the string to the given precision if necessary.
+ const INT64 n_pad = static_cast<INT64>(os_precision) - static_cast<INT64>(static_cast<INT64>(str.length() - 1u) - (my_exp + 1));
+
+ if(n_pad > static_cast<INT64>(0))
+ {
+ str.insert(str.end(), static_cast<std::size_t>(n_pad), static_cast<char>('0'));
+ }
}
- }
- // Remove all trailing zeros if necessary.
- if(trim_trailing_zeros)
- {
- const std::string::const_reverse_iterator rit_non_zero = std::find_if(str.rbegin(), str.rend(), char_is_nonzero_predicate);
+ // Trim the trailing zeros, where the trim-characteristics depend on the showpoint flag.
+ if(trim_trailing_zeros)
+ {
+ const std::string::const_reverse_iterator rit_non_zero = std::find_if(str.rbegin(), str.rend(), e_float_base::char_is_nonzero_predicate);
+
+ if(rit_non_zero != str.rbegin())
+ {
+ const std::size_t ofs = str.length() - std::distance<std::string::const_reverse_iterator>(str.rbegin(), rit_non_zero);
+ str.erase(str.begin() + ofs, str.end());
+ }
+ }
- if(rit_non_zero != str.rbegin())
+ // Perform the final manipulations on the digits of the string.
+ if(my_showpoint)
{
- const std::size_t ofs = str.length() - std::distance<std::string::const_reverse_iterator>(str.rbegin(), rit_non_zero);
- str.erase(str.begin() + ofs, str.end());
+ if(trim_trailing_zeros) { ::special_extend_string_to_precision(str, os_precision); }
+ }
+ else
+ {
+ // Remove the trailing decimal point if necessary.
+ if(*(str.end() - 1u) == static_cast<char>('.'))
+ {
+ str.erase(str.end() - 1u, str.end());
+ }
}
}
- // Remove the trailing decimal point if necessary.
- if((*(str.end() - 1u) == static_cast<char>('.')) && (!my_showpoint))
+ void special_extend_string_to_precision(std::string& str, const std::size_t os_precision)
{
- str.erase(str.end() - 1u, str.end());
+ // This is the special case of showpoint in combination with
+ // a non-fixed, non-scientific representation. The string has
+ // to be zero extended such that the total width of its entire
+ // non-zero part exactly equals the precision.
+
+ // Check if the number is less than 1.
+ if( (str.at(static_cast<std::size_t>(0u)) == static_cast<char>('0'))
+ && (str.at(static_cast<std::size_t>(1u)) == static_cast<char>('.'))
+ )
+ {
+ if(str.length() == static_cast<std::size_t>(2u))
+ {
+ // This string represents zero and needs zero extension.
+ str.insert(str.end(), os_precision, static_cast<char>('0'));
+ }
+ else
+ {
+ // This is a non-zero decimal less than 1 that needs zero extension.
+ const std::string::const_iterator it_non_zero = std::find_if(str.begin() + 2u, str.end(), e_float_base::char_is_nonzero_predicate);
+ const std::size_t len_non_zero_part = std::distance<std::string::const_iterator>(it_non_zero, str.end());
+ const std::size_t u_pad = static_cast<std::size_t>(os_precision - len_non_zero_part);
+ str.insert(str.end(), u_pad, static_cast<char>('0'));
+ }
+ }
+ else
+ {
+ // This is a number greater than or equal to 1 that needs zero extension.
+ const std::size_t u_pad = static_cast<std::size_t>(os_precision - static_cast<std::size_t>(str.length() - static_cast<std::size_t>(1u)));
+ str.insert(str.end(), u_pad, static_cast<char>('0'));
+ }
}
}
@@ -380,3 +478,102 @@
e_float e_float_base::my_riemann_zeta (const e_float&) { return std::numeric_limits<e_float>::quiet_NaN(); }
e_float e_float_base::my_cyl_bessel_jn(const INT32, const e_float&) { return std::numeric_limits<e_float>::quiet_NaN(); }
e_float e_float_base::my_cyl_bessel_yn(const INT32, const e_float&) { return std::numeric_limits<e_float>::quiet_NaN(); }
+
+/*
+#include <iostream>
+#include <array>
+#include <vector>
+#include <string>
+#include <algorithm>
+#include <iterator>
+#include <sstream>
+#include <regex>
+
+namespace
+{
+ struct regex_matcher
+ {
+ private:
+ regex_matcher();
+ const regex_matcher& operator=(const regex_matcher&);
+
+ std::match_results<std::string::const_iterator>& results;
+ const std::string& str;
+
+ public:
+ regex_matcher(std::match_results<std::string::const_iterator>& mr, const std::string& s) : results(mr), str(s) { }
+
+ regex_matcher(const regex_matcher& rxm) : results(rxm.results), str(rxm.str) { }
+
+ bool operator()(const std::regex& rx) const { return std::regex_match(str, results, rx); }
+ };
+
+ template<typename T>
+ std::string lexical_cast(const T& t)
+ {
+ std::stringstream ss;
+ ss << t;
+ return ss.str();
+ }
+}
+
+bool rd_string(const std::string& str)
+{
+ // Use regular expressions to do a preliminary parse of the input string.
+
+ // Here is the key to the upcoming regular expressions.
+ // [1] = sign(s)
+ // [2] = leading zeros
+ // [3] = mantissa
+ // [4] = dot
+ // [5] = decimal part
+ // [6] = exponent letter e or E
+ // [7] = exponent sign + or -
+ // [8] = exponent's leading zeros
+ // [9] = exponent value
+ static const std::array<std::regex, 6u> the_regs_data =
+ {{
+ std::regex("([+|-]*)([0]*)([0-9]+)([.])([0-9]*)([e|E])([+|-]*)([0]*)([0-9]+)"), // Exponent with dot, integer part required.
+ std::regex("([+|-]*)([0]*)([0-9]*)([.])([0-9]+)([e|E])([+|-]*)([0]*)([0-9]+)"), // Exponent with dot, decimal part required.
+ std::regex("([+|-]*)([0]*)([0-9]+)()()([e|E])([+|-]*)([0]*)([0-9]+)"), // Exponent no dot, integer part required.
+ std::regex("([+|-]*)([0]*)([0-9]+)([.])([0-9]*)()()()()"), // Fixed with dot, integer part required.
+ std::regex("([+|-]*)([0]*)([0-9]*)([.])([0-9]+)()()()()"), // Fixed with dot, decimal part required.
+ std::regex("([+|-]*)([0]*)([0-9]+)()()()()()()") // Fixed no dot.
+ }};
+
+ static const std::vector<std::regex> the_regs(the_regs_data.begin(), the_regs_data.end());
+
+ std::match_results<std::string::const_iterator> mr;
+
+ const std::vector<std::regex>::const_iterator it_rx = std::find_if(the_regs.begin(), the_regs.end(), ::regex_matcher(mr, str));
+
+ const bool b_match = (it_rx != the_regs.end());
+
+ (b_match ? std::cout << "Match OK: index = " << std::distance(the_regs.begin(), it_rx) << std::endl
+ : std::cout << "Match failed!" << std::endl);
+
+ for(std::match_results<std::string::const_iterator>::const_iterator it_mr = mr.begin(); it_mr != mr.end(); ++it_mr)
+ {
+ std::cout << "mr-index: " + lexical_cast(std::distance(mr.begin(), it_mr)) << ", " << *it_mr << std::endl;
+ }
+
+ std::cout << std::endl;
+
+ return b_match;
+}
+
+int main(void)
+{
+ std::string str;
+
+ for(;;)
+ {
+ std::cout << "Enter FP string: ";
+ std::cin >> str;
+
+ if(str == "exit") { break; }
+
+ static_cast<void>(rd_string(str));
+ }
+}
+*/
Modified: sandbox/e_float/libs/e_float/src/e_float/efx/e_float_efx.cpp
==============================================================================
--- sandbox/e_float/libs/e_float/src/e_float/efx/e_float_efx.cpp (original)
+++ sandbox/e_float/libs/e_float/src/e_float/efx/e_float_efx.cpp 2011-08-16 16:00:34 EDT (Tue, 16 Aug 2011)
@@ -1149,7 +1149,27 @@
{
if(fpclass == ef_finite)
{
- return ((data[0u] == static_cast<UINT32>(0u)) || (exp < std::numeric_limits<e_float>::min_exponent10));
+ bool is_leq_std_min = false;
+
+ const bool could_be_leq_std_min = (exp <= static_cast<INT64>(std::numeric_limits<e_float>::min_exponent10));
+
+ if(could_be_leq_std_min)
+ {
+ if(exp < static_cast<INT64>(std::numeric_limits<e_float>::min_exponent10))
+ {
+ is_leq_std_min = true;
+ }
+ else
+ {
+ if(data[0u] == static_cast<UINT32>(1u))
+ {
+ const array_type::const_iterator it_non_zero = std::find_if(data.begin() + 1u, data.end(), data_elem_is_non_zero_predicate);
+ if(it_non_zero == data.end()) { is_leq_std_min = true; }
+ }
+ }
+ }
+
+ return ((data[0u] == static_cast<UINT32>(0u)) || is_leq_std_min);
}
else
{
Modified: sandbox/e_float/libs/e_float/test/real/cases/test_case_0000x_overflow_underflow.cpp
==============================================================================
--- sandbox/e_float/libs/e_float/test/real/cases/test_case_0000x_overflow_underflow.cpp (original)
+++ sandbox/e_float/libs/e_float/test/real/cases/test_case_0000x_overflow_underflow.cpp 2011-08-16 16:00:34 EDT (Tue, 16 Aug 2011)
@@ -10,6 +10,7 @@
#include <boost/e_float/e_float_functions.hpp>
#include "../test_case_real.h"
+#include "../../../src/utility/util_lexical_cast.h"
namespace test
{
@@ -183,7 +184,10 @@
{
data.clear();
- e_float y = (std::numeric_limits<e_float>::min)() * static_cast<INT32>(100);
+ static const std::string str_tiny_exp = Util::lexical_cast(std::numeric_limits<e_float>::min_exponent10 + static_cast<INT64>(2));
+ static const std::string str_tiny = "1e" + str_tiny_exp;
+
+ e_float y(str_tiny);
data.push_back(y);
Modified: sandbox/e_float/libs/e_float/test/real/cases/test_case_0000y_write_to_ostream.cpp
==============================================================================
--- sandbox/e_float/libs/e_float/test/real/cases/test_case_0000y_write_to_ostream.cpp (original)
+++ sandbox/e_float/libs/e_float/test/real/cases/test_case_0000y_write_to_ostream.cpp 2011-08-16 16:00:34 EDT (Tue, 16 Aug 2011)
@@ -14,6 +14,7 @@
#include <boost/e_float/e_float_functions.hpp>
#include "../test_case_real.h"
+#include "../../../src/utility/util_lexical_cast.h"
namespace
{
@@ -64,6 +65,13 @@
return str_pi;
}
+
+ const std::size_t& default_prec(void)
+ {
+ static std::stringstream the_ss;
+ static const std::size_t the_default_prec = static_cast<std::size_t>(the_ss.precision());
+ return the_default_prec;
+ }
}
namespace test
@@ -145,7 +153,8 @@
ss << std::fixed << std::showpos << std::showpoint << std::setprecision(0) << ef::pi();
str = ss.str();
data.push_back(e_float(str));
- my_test_result &= (str == std::string("+3."));
+ std::string str_pi = std::string("+") + ::make_pi_string(::default_prec());
+ my_test_result &= (str == str_pi);
ss.clear();
ss.str("");
@@ -180,7 +189,7 @@
ss << std::fixed << std::showpos << std::showpoint << std::setprecision(std::numeric_limits<e_float>::digits10) << ef::pi();
str = ss.str();
data.push_back(e_float(str));
- std::string str_pi = ::make_pi_string(static_cast<std::size_t>(std::numeric_limits<e_float>::digits10));
+ str_pi = ::make_pi_string(static_cast<std::size_t>(std::numeric_limits<e_float>::digits10));
my_test_result &= (str == (std::string("+") + str_pi));
ss.clear();
ss.str("");
@@ -337,13 +346,55 @@
std::string str;
std::stringstream ss;
- ss << ef::million();
+ ss << ef::ten();
+ str = ss.str();
+ data.push_back(e_float(str));
+ my_test_result &= (str == std::string("10"));
+ ss.clear();
+ ss.str("");
+
+ ss << std::showpoint << ef::ten();
+ str = ss.str();
+ data.push_back(e_float(str));
+ static const std::string str_10 = std::string("10.")
+ + std::string(static_cast<std::size_t>(default_prec() - 2u), static_cast<char>('0'));
+ my_test_result &= (str == str_10);
+ ss.clear();
+ ss.str("");
+
+ ss << std::showpoint << e_float("1e1000");
str = ss.str();
data.push_back(e_float(str));
- my_test_result &= (str == std::string("1000000"));
+ static const std::string str_1e1000 = (std::string("1.")
+ + std::string(static_cast<std::size_t>(default_prec() - 1u), static_cast<char>('0')))
+ + std::string("e+001000");
+ my_test_result &= (str == str_1e1000);
ss.clear();
ss.str("");
+ ss << std::showpoint << e_float("1e" + Util::lexical_cast(default_prec()));
+ str = ss.str();
+ data.push_back(e_float(str));
+ static const std::string str_1ePrec = (std::string("1.")
+ + std::string(static_cast<std::size_t>(default_prec() - 1u), static_cast<char>('0')))
+ + (std::string("e+00")
+ + Util::lexical_cast(default_prec()));
+ my_test_result &= (str == str_1ePrec);
+ ss.clear();
+ ss.str("");
+
+ ss << std::showpoint << e_float("1e" + Util::lexical_cast(default_prec() - 1u));
+ str = ss.str();
+ data.push_back(e_float(str));
+ static const std::string str_1ePm1 = (std::string("1")
+ + std::string(static_cast<std::size_t>(default_prec() - 1u), static_cast<char>('0')))
+ + std::string(".");
+ my_test_result &= (str == str_1ePm1);
+ ss.clear();
+ ss.str("");
+
+ ss << std::noshowpoint;
+
ss << e_float(100000000000uLL); // 10^11
str = ss.str();
data.push_back(e_float(str));
@@ -354,7 +405,7 @@
ss << std::showpoint << ef::googol();
str = ss.str();
data.push_back(e_float(str));
- my_test_result &= (str == std::string("1.e+100"));
+ my_test_result &= (str == std::string("1.00000e+100"));
ss.clear();
ss.str("");
@@ -382,7 +433,7 @@
ss << std::showpoint << ef::eight();
str = ss.str();
data.push_back(e_float(str));
- my_test_result &= (str == std::string("8."));
+ my_test_result &= (str == std::string("8.00000"));
ss.clear();
ss.str("");
@@ -396,36 +447,42 @@
ss << std::noshowpos << std::noshowpoint << std::setprecision(0) << ef::pi();
str = ss.str();
data.push_back(e_float(str));
- my_test_result &= (str == std::string("3"));
+ std::string str_pi = ::make_pi_string(::default_prec() - 1u);
+ my_test_result &= (str == str_pi);
ss.clear();
ss.str("");
ss << std::noshowpos << std::noshowpoint << std::setprecision(0) << (ef::pi() * static_cast<INT32>(100));
str = ss.str();
data.push_back(e_float(str));
- my_test_result &= (str == std::string("314"));
+ str_pi = ::make_pi_string(::default_prec() - 1u);
+ str_pi.erase(str_pi.begin() + 1u, str_pi.begin() + 2u);
+ str_pi.insert(str_pi.begin() + 3u, static_cast<std::size_t>(1u), static_cast<char>('.'));
+ my_test_result &= (str == str_pi);
ss.clear();
ss.str("");
ss << std::showpos << std::showpoint << std::setprecision(1) << ef::pi();
str = ss.str();
data.push_back(e_float(str));
- my_test_result &= (str == std::string("+3.1"));
+ my_test_result &= (str == std::string("+3."));
ss.clear();
ss.str("");
ss << std::showpos << std::showpoint << std::setprecision(20) << ef::pi();
str = ss.str();
data.push_back(e_float(str));
- my_test_result &= (str == std::string("+3.14159265358979323846"));
+ my_test_result &= (str == std::string("+3.1415926535897932385"));
ss.clear();
ss.str("");
ss << std::showpos << std::showpoint << std::setprecision(1000) << ef::pi();
str = ss.str();
data.push_back(e_float(str));
- std::string str_pi = ::make_pi_string(static_cast<std::size_t>(std::numeric_limits<e_float>::max_digits10));
- my_test_result &= (str == (std::string("+") + str_pi));
+ str_pi = std::string("+") + ::make_pi_string(static_cast<std::size_t>(std::numeric_limits<e_float>::max_digits10 - 1));
+ static const std::string str_zero_fill(static_cast<std::size_t>(1000 - std::numeric_limits<e_float>::max_digits10), static_cast<char>('0'));
+ str_pi += str_zero_fill;
+ my_test_result &= (str == str_pi);
ss.clear();
ss.str("");
}