|
|
Boost-Commit : |
Subject: [Boost-commit] svn:boost r75707 - in sandbox/big_number: boost/multiprecision boost/multiprecision/detail libs/multiprecision/test
From: john_at_[hidden]
Date: 2011-11-28 04:13:16
Author: johnmaddock
Date: 2011-11-28 04:13:12 EST (Mon, 28 Nov 2011)
New Revision: 75707
URL: http://svn.boost.org/trac/boost/changeset/75707
Log:
Fix float IO and add test.
Added:
sandbox/big_number/libs/multiprecision/test/test_float_io.cpp (contents, props changed)
Text files modified:
sandbox/big_number/boost/multiprecision/cpp_float.hpp | 54 +++++++++++++++++++++++++++---
sandbox/big_number/boost/multiprecision/detail/mp_number_base.hpp | 59 +++++++++++++++++++++++++++++---
sandbox/big_number/boost/multiprecision/gmp.hpp | 67 ++++++++++++++++++++++++++++++++++---
sandbox/big_number/boost/multiprecision/mpfr.hpp | 71 +++++++++++++++++++++++++++++++++++----
sandbox/big_number/libs/multiprecision/test/Jamfile.v2 | 27 ++++++++++++++-
5 files changed, 249 insertions(+), 29 deletions(-)
Modified: sandbox/big_number/boost/multiprecision/cpp_float.hpp
==============================================================================
--- sandbox/big_number/boost/multiprecision/cpp_float.hpp (original)
+++ sandbox/big_number/boost/multiprecision/cpp_float.hpp 2011-11-28 04:13:12 EST (Mon, 28 Nov 2011)
@@ -1642,6 +1642,7 @@
std::string cpp_float<Digits10>::str(std::streamsize number_of_digits, std::ios_base::fmtflags f) const
{
std::string str;
+ std::streamsize org_digits(number_of_digits);
boost::int64_t my_exp = order();
if(number_of_digits == 0)
number_of_digits = cpp_float_max_digits10;
@@ -1669,19 +1670,21 @@
str += ss.str();
}
+ bool have_leading_zeros = false;
if(number_of_digits == 0)
{
// We only get here if the output format is "fixed" and we just need to
- // round the first digit.
- str.insert(0, 1, '0');
- ++number_of_digits;
+ // round the first non-zero digit.
+ number_of_digits -= my_exp + 1; // reset to original value
+ str.insert(0, std::string::size_type(number_of_digits), '0');
+ have_leading_zeros = true;
}
if(number_of_digits < 0)
{
str = "0";
if(isneg())
str.insert(0, 1, '-');
- boost::multiprecision::detail::format_float_string(str, 0, number_of_digits - my_exp - 1, f);
+ boost::multiprecision::detail::format_float_string(str, 0, number_of_digits - my_exp - 1, f, this->iszero());
return str;
}
else
@@ -1692,10 +1695,37 @@
// Get the digit after the last needed digit for rounding
const boost::uint32_t round = static_cast<boost::uint32_t>(static_cast<boost::uint32_t>(str[static_cast<std::string::size_type>(number_of_digits)]) - static_cast<boost::uint32_t>('0'));
+ bool need_round_up = round >= 5u;
+
+ if(round == 5u)
+ {
+ const boost::uint32_t ix = static_cast<boost::uint32_t>(static_cast<boost::uint32_t>(str[static_cast<std::string::size_type>(number_of_digits - 1)]) - static_cast<boost::uint32_t>('0'));
+ if((ix & 1u) == 0)
+ {
+ // We have an even digit followed by a 5, so we might not actually need to round up
+ // if all the remaining digits are zero:
+ if(str.find_first_not_of('0', static_cast<std::string::size_type>(number_of_digits + 1)) == std::string::npos)
+ {
+ bool all_zeros = true;
+ // No none-zero trailing digits in the string, now check whatever parts we didn't convert to the string:
+ for(std::size_t i = number_of_elements; i < data.size(); i++)
+ {
+ if(data[i])
+ {
+ all_zeros = false;
+ break;
+ }
+ }
+ if(all_zeros)
+ need_round_up = false; // tie break - round to even.
+ }
+ }
+ }
+
// Truncate the string
str.erase(static_cast<std::string::size_type>(number_of_digits));
- if(round >= static_cast<boost::uint32_t>(5u))
+ if(need_round_up)
{
std::size_t ix = static_cast<std::size_t>(str.length() - 1u);
@@ -1729,9 +1759,21 @@
}
}
}
+ if(have_leading_zeros)
+ {
+ // We need to take the zeros back out again, and correct the exponent
+ // if we rounded up:
+ if(str[std::string::size_type(number_of_digits - 1)] != '0')
+ {
+ ++my_exp;
+ str.erase(0, std::string::size_type(number_of_digits - 1));
+ }
+ else
+ str.erase(0, std::string::size_type(number_of_digits));
+ }
if(isneg())
str.insert(0, 1, '-');
- boost::multiprecision::detail::format_float_string(str, my_exp, number_of_digits, f);
+ boost::multiprecision::detail::format_float_string(str, my_exp, org_digits, f, this->iszero());
return str;
}
Modified: sandbox/big_number/boost/multiprecision/detail/mp_number_base.hpp
==============================================================================
--- sandbox/big_number/boost/multiprecision/detail/mp_number_base.hpp (original)
+++ sandbox/big_number/boost/multiprecision/detail/mp_number_base.hpp 2011-11-28 04:13:12 EST (Mon, 28 Nov 2011)
@@ -348,15 +348,16 @@
#ifndef BOOST_MP_MIN_EXPONENT_DIGITS
#ifdef _MSC_VER
-# define BOOST_MP_MIN_EXPONENT_DIGITS 3
+# define BOOST_MP_MIN_EXPONENT_DIGITS 2
#else
# define BOOST_MP_MIN_EXPONENT_DIGITS 2
#endif
#endif
template <class S>
-void format_float_string(S& str, long long my_exp, std::streamsize digits, std::ios_base::fmtflags f)
+void format_float_string(S& str, long long my_exp, std::streamsize digits, std::ios_base::fmtflags f, bool iszero)
{
+ typedef typename S::size_type size_type;
bool scientific = (f & std::ios_base::scientific) == std::ios_base::scientific;
bool fixed = (f & std::ios_base::fixed) == std::ios_base::fixed;
bool showpoint = (f & std::ios_base::showpoint) == std::ios_base::showpoint;
@@ -367,6 +368,39 @@
if(neg)
str.erase(0, 1);
+ if(digits == 0)
+ {
+ digits = (std::max)(str.size(), size_type(16));
+ }
+
+ if(iszero || str.empty() || (str.find_first_not_of('0') == S::npos))
+ {
+ // We will be printing zero, even though the value might not
+ // actually be zero (it just may have been rounded to zero).
+ str = "0";
+ if(scientific || fixed)
+ {
+ str.append(1, '.');
+ str.append(size_type(digits), '0');
+ if(scientific)
+ str.append("e+00");
+ }
+ else
+ {
+ if(showpoint)
+ {
+ str.append(1, '.');
+ if(digits > 1)
+ str.append(size_type(digits - 1), '0');
+ }
+ }
+ if(neg)
+ str.insert(0, 1, '-');
+ else if(showpos)
+ str.insert(0, 1, '+');
+ return;
+ }
+
if(!fixed && !scientific && !showpoint)
{
//
@@ -380,13 +414,15 @@
if(str.empty())
str = '0';
}
- else
+ else if(!fixed || (my_exp >= 0))
{
//
// Pad out the end with zero's if we need to:
//
std::streamsize chars = str.size();
chars = digits - chars;
+ if(scientific)
+ ++chars;
if(chars > 0)
{
str.append(static_cast<std::string::size_type>(chars), '0');
@@ -399,14 +435,14 @@
{
// Just pad out the end with zeros:
str.append(static_cast<std::string::size_type>(1 + my_exp - str.size()), '0');
- if(showpoint)
+ if(showpoint || fixed)
str.append(".");
}
- else if(my_exp + 1 != str.size())
+ else if(my_exp + 1 < str.size())
{
if(my_exp < 0)
{
- str.insert(0, static_cast<std::string::size_type>(-1-my_exp), '0');
+ str.insert(0, static_cast<std::string::size_type>(-1 - my_exp), '0');
str.insert(0, "0.");
}
else
@@ -415,8 +451,17 @@
str.insert(static_cast<std::string::size_type>(my_exp + 1), 1, '.');
}
}
- else if(showpoint)
+ else if(showpoint || fixed) // we have exactly the digits we require to left of the point
str += ".";
+
+ if(fixed)
+ {
+ // We may need to add trailing zeros:
+ std::streamsize l = str.find('.') + 1;
+ l = digits - (str.size() - l);
+ if(l > 0)
+ str.append(size_type(l), '0');
+ }
}
else
{
Modified: sandbox/big_number/boost/multiprecision/gmp.hpp
==============================================================================
--- sandbox/big_number/boost/multiprecision/gmp.hpp (original)
+++ sandbox/big_number/boost/multiprecision/gmp.hpp 2011-11-28 04:13:12 EST (Mon, 28 Nov 2011)
@@ -163,8 +163,9 @@
{
bool scientific = (f & std::ios_base::scientific) == std::ios_base::scientific;
bool fixed = (f & std::ios_base::fixed) == std::ios_base::fixed;
+ std::streamsize org_digits(digits);
- if(scientific)
+ if(scientific && digits)
++digits;
std::string result;
@@ -178,25 +179,79 @@
{
e = 0;
result = "0";
- if(fixed)
+ if(fixed && digits)
++digits;
}
else
{
- const char* ps = mpf_get_str (0, &e, 10, static_cast<std::size_t>(digits), m_data);
+ char* ps = mpf_get_str (0, &e, 10, static_cast<std::size_t>(digits), m_data);
--e; // To match with what our formatter expects.
if(fixed && e != -1)
{
// Oops we actually need a different number of digits to what we asked for:
(*free_func_ptr)((void*)ps, std::strlen(ps) + 1);
digits += e + 1;
- ps = mpf_get_str (0, &e, 10, static_cast<std::size_t>(digits), m_data);
- --e; // To match with what our formatter expects.
+ if(digits == 0)
+ {
+ // We need to get *all* the digits and then possibly round up,
+ // we end up with either "0" or "1" as the result.
+ ps = mpf_get_str (0, &e, 10, 0, m_data);
+ --e;
+ unsigned offset = *ps == '-' ? 1 : 0;
+ if(ps[offset] > '5')
+ {
+ ++e;
+ ps[offset] = '1';
+ ps[offset + 1] = 0;
+ }
+ else if(ps[offset] == '5')
+ {
+ unsigned i = offset + 1;
+ bool round_up = false;
+ while(ps[i] != 0)
+ {
+ if(ps[i] != '0')
+ {
+ round_up = true;
+ break;
+ }
+ }
+ if(round_up)
+ {
+ ++e;
+ ps[offset] = '1';
+ ps[offset + 1] = 0;
+ }
+ else
+ {
+ ps[offset] = '0';
+ ps[offset + 1] = 0;
+ }
+ }
+ else
+ {
+ ps[offset] = '0';
+ ps[offset + 1] = 0;
+ }
+ }
+ else if(digits > 0)
+ {
+ ps = mpf_get_str (0, &e, 10, static_cast<std::size_t>(digits), m_data);
+ --e; // To match with what our formatter expects.
+ }
+ else
+ {
+ ps = mpf_get_str (0, &e, 10, 1, m_data);
+ --e;
+ unsigned offset = *ps == '-' ? 1 : 0;
+ ps[offset] = '0';
+ ps[offset + 1] = 0;
+ }
}
result = ps;
(*free_func_ptr)((void*)ps, std::strlen(ps) + 1);
}
- boost::multiprecision::detail::format_float_string(result, e, digits, f);
+ boost::multiprecision::detail::format_float_string(result, e, org_digits, f, mpf_sgn(m_data) == 0);
return result;
}
~gmp_float_imp()
Modified: sandbox/big_number/boost/multiprecision/mpfr.hpp
==============================================================================
--- sandbox/big_number/boost/multiprecision/mpfr.hpp (original)
+++ sandbox/big_number/boost/multiprecision/mpfr.hpp 2011-11-28 04:13:12 EST (Mon, 28 Nov 2011)
@@ -161,7 +161,9 @@
bool scientific = (f & std::ios_base::scientific) == std::ios_base::scientific;
bool fixed = (f & std::ios_base::fixed) == std::ios_base::fixed;
- if(scientific)
+ std::streamsize org_digits(digits);
+
+ if(scientific && digits)
++digits;
std::string result;
@@ -170,8 +172,6 @@
{
e = 0;
result = "0";
- if(fixed)
- ++digits;
}
else
{
@@ -182,13 +182,68 @@
// Oops we actually need a different number of digits to what we asked for:
mpfr_free_str(ps);
digits += e + 1;
- ps = ps = mpfr_get_str (0, &e, 10, static_cast<std::size_t>(digits), m_data, GMP_RNDN);
- --e; // To match with what our formatter expects.
+ if(digits == 0)
+ {
+ // We need to get *all* the digits and then possibly round up,
+ // we end up with either "0" or "1" as the result.
+ ps = mpfr_get_str (0, &e, 10, 0, m_data, GMP_RNDN);
+ --e;
+ unsigned offset = *ps == '-' ? 1 : 0;
+ if(ps[offset] > '5')
+ {
+ ++e;
+ ps[offset] = '1';
+ ps[offset + 1] = 0;
+ }
+ else if(ps[offset] == '5')
+ {
+ unsigned i = offset + 1;
+ bool round_up = false;
+ while(ps[i] != 0)
+ {
+ if(ps[i] != '0')
+ {
+ round_up = true;
+ break;
+ }
+ }
+ if(round_up)
+ {
+ ++e;
+ ps[offset] = '1';
+ ps[offset + 1] = 0;
+ }
+ else
+ {
+ ps[offset] = '0';
+ ps[offset + 1] = 0;
+ }
+ }
+ else
+ {
+ ps[offset] = '0';
+ ps[offset + 1] = 0;
+ }
+ }
+ else if(digits > 0)
+ {
+ ps = mpfr_get_str (0, &e, 10, static_cast<std::size_t>(digits), m_data, GMP_RNDN);
+ --e; // To match with what our formatter expects.
+ }
+ else
+ {
+ ps = mpfr_get_str (0, &e, 10, 1, m_data, GMP_RNDN);
+ --e;
+ unsigned offset = *ps == '-' ? 1 : 0;
+ ps[offset] = '0';
+ ps[offset + 1] = 0;
+ }
}
- result = ps;
- mpfr_free_str(ps);
+ result = ps ? ps : "0";
+ if(ps)
+ mpfr_free_str(ps);
}
- boost::multiprecision::detail::format_float_string(result, e, digits, f);
+ boost::multiprecision::detail::format_float_string(result, e, org_digits, f, 0 != mpfr_zero_p(m_data));
return result;
}
~mpfr_float_imp()
Modified: sandbox/big_number/libs/multiprecision/test/Jamfile.v2
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/Jamfile.v2 (original)
+++ sandbox/big_number/libs/multiprecision/test/Jamfile.v2 2011-11-28 04:13:12 EST (Mon, 28 Nov 2011)
@@ -579,8 +579,31 @@
: # input files
: # requirements
<define>TEST_CPP_FLOAT
- [ check-target-builds ../config//has_mpfr : : <build>no ]
: test_fpclassify_cpp_float ;
-run test_test.cpp ;
\ No newline at end of file
+run test_test.cpp ;
+
+run test_float_io.cpp
+ : # command line
+ : # input files
+ : # requirements
+ <define>TEST_CPP_FLOAT
+ : test_float_io_cpp_float ;
+
+run test_float_io.cpp gmp
+ : # command line
+ : # input files
+ : # requirements
+ <define>TEST_MPF_50
+ [ check-target-builds ../config//has_gmp : : <build>no ]
+ : test_float_io_mpf ;
+
+run test_float_io.cpp mpfr gmp
+ : # command line
+ : # input files
+ : # requirements
+ <define>TEST_MPFR_50
+ [ check-target-builds ../config//has_mpfr : : <build>no ]
+ : test_float_io_mpfr ;
+
Added: sandbox/big_number/libs/multiprecision/test/test_float_io.cpp
==============================================================================
--- (empty file)
+++ sandbox/big_number/libs/multiprecision/test/test_float_io.cpp 2011-11-28 04:13:12 EST (Mon, 28 Nov 2011)
@@ -0,0 +1,181 @@
+// Copyright John Maddock 2011.
+
+// Use, modification and distribution are subject to the
+// Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt
+// or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifdef _MSC_VER
+# define _SCL_SECURE_NO_WARNINGS
+#endif
+
+#if !defined(TEST_MPF_50) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR_50)
+# define TEST_MPF_50
+# define TEST_CPP_FLOAT
+# define TEST_MPFR_50
+
+#ifdef _MSC_VER
+#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
+#endif
+#ifdef __GNUC__
+#pragma warning "CAUTION!!: No backend type specified so testing everything.... this will take some time!!"
+#endif
+
+#endif
+
+#if defined(TEST_MPF_50)
+#include <boost/multiprecision/gmp.hpp>
+#endif
+#if defined(TEST_MPFR_50)
+#include <boost/multiprecision/mpfr.hpp>
+#endif
+#ifdef TEST_CPP_FLOAT
+#include <boost/multiprecision/cpp_float.hpp>
+#endif
+
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/array.hpp>
+#include <iostream>
+#include <iomanip>
+
+#if defined(TEST_MPF_50)
+template <unsigned N>
+bool is_mpf(const boost::multiprecision::mp_number<boost::multiprecision::gmp_float<N> >&)
+{ return true; }
+#endif
+template <class T>
+bool is_mpf(const T&) { return false; }
+
+bool is_bankers_rounding_error(const std::string& s, const char* expect)
+{
+ // This check isn't foolproof: that would require *much* more sofisticated code!!!
+ std::string::size_type l = std::strlen(expect);
+ if(l != s.size())
+ return false;
+ std::string::size_type len = s.find('e');
+ if(len == std::string::npos)
+ len = l - 1;
+ else
+ --len;
+ if(s.compare(0, len, expect, len))
+ return false;
+ if(s[len] != expect[len] + 1)
+ return false;
+ return true;
+}
+
+void print_flags(std::ios_base::fmtflags f)
+{
+ std::cout << "Formatting flags were: ";
+ if(f & std::ios_base::scientific)
+ std::cout << "scientific ";
+ if(f & std::ios_base::fixed)
+ std::cout << "fixed ";
+ if(f & std::ios_base::showpoint)
+ std::cout << "showpoint ";
+ if(f & std::ios_base::showpos)
+ std::cout << "showpos ";
+ std::cout << std::endl;
+}
+
+
+template <class T>
+void test()
+{
+ typedef T mp_t;
+ boost::array<std::ios_base::fmtflags, 9> f =
+ {{
+ std::ios_base::fmtflags(0), std::ios_base::showpoint, std::ios_base::showpos, std::ios_base::scientific, std::ios_base::scientific|std::ios_base::showpos,
+ std::ios_base::scientific|std::ios_base::showpoint, std::ios_base::fixed, std::ios_base::fixed|std::ios_base::showpoint,
+ std::ios_base::fixed|std::ios_base::showpos
+ }};
+
+ boost::array<boost::array<const char*, 13 * 9>, 40> string_data = {{
+#include "libs/multiprecision/string_data.ipp"
+ }};
+
+ double num = 123456789.0;
+ double denom = 1;
+ double val = num;
+ for(unsigned j = 0; j < 40; ++j)
+ {
+ unsigned col = 0;
+ for(unsigned prec = 1; prec < 14; ++prec)
+ {
+ for(unsigned i = 0; i < f.size(); ++i, ++col)
+ {
+ std::stringstream ss;
+ ss.precision(prec);
+ ss.flags(f[i]);
+ ss << mp_t(val);
+ const char* expect = string_data[j][col];
+ if(ss.str() != expect)
+ {
+ if(is_mpf(mp_t()) && is_bankers_rounding_error(ss.str(), expect))
+ {
+ std::cout << "Ignoring bankers-rounding error with GMP mp_f.\n";
+ }
+ else
+ {
+ std::cout << std::setprecision(20) << "Testing value " << val << std::endl;
+ print_flags(f[i]);
+ std::cout << "Precision is: " << prec << std::endl;
+ std::cout << "Got: " << ss.str() << std::endl;
+ std::cout << "Expected: " << expect << std::endl;
+ ++boost::detail::test_errors();
+ mp_t(val).str(prec, f[i]); // for debugging
+ }
+ }
+ }
+ }
+ num = -num;
+ if(j & 1)
+ denom *= 8;
+ val = num / denom;
+ }
+
+ boost::array<const char*, 13 * 9> zeros =
+ {{ "0", "0.", "+0", "0.0e+00", "+0.0e+00", "0.0e+00", "0.0", "0.0", "+0.0", "0", "0.0", "+0", "0.00e+00", "+0.00e+00", "0.00e+00", "0.00", "0.00", "+0.00", "0", "0.00", "+0", "0.000e+00", "+0.000e+00", "0.000e+00", "0.000", "0.000", "+0.000", "0", "0.000", "+0", "0.0000e+00", "+0.0000e+00", "0.0000e+00", "0.0000", "0.0000", "+0.0000", "0", "0.0000", "+0", "0.00000e+00", "+0.00000e+00", "0.00000e+00", "0.00000", "0.00000", "+0.00000", "0", "0.00000", "+0", "0.000000e+00", "+0.000000e+00", "0.000000e+00", "0.000000", "0.000000", "+0.000000", "0", "0.000000", "+0", "0.0000000e+00", "+0.0000000e+00", "0.0000000e+00", "0.0000000", "0.0000000", "+0.0000000", "0", "0.0000000", "+0", "0.00000000e+00", "+0.00000000e+00", "0.00000000e+00", "0.00000000", "0.00000000", "+0.00000000", "0", "0.00000000", "+0", "0.000000000e+00", "+0.000000000e+00", "0.000000000e+00", "0.000000000", "0.000000000", "+0.000000000", "0", "0.000000000", "+0", "0.0000000000e+00", "+0.0000000000e+00", "0.0000000000e+00", "0.0000000000",
"0.0000000000", "+0.0000000000", "0", "0.0000000000", "+0", "0.00000000000e+00", "+0.00000000000e+00", "0.00000000000e+00", "0.00000000000", "0.00000000000", "+0.00000000000", "0", "0.00000000000", "+0", "0.000000000000e+00", "+0.000000000000e+00", "0.000000000000e+00", "0.000000000000", "0.000000000000", "+0.000000000000", "0", "0.000000000000", "+0", "0.0000000000000e+00", "+0.0000000000000e+00", "0.0000000000000e+00", "0.0000000000000", "0.0000000000000", "+0.0000000000000" }};
+
+ unsigned col = 0;
+ val = 0;
+ for(unsigned prec = 1; prec < 14; ++prec)
+ {
+ for(unsigned i = 0; i < f.size(); ++i, ++col)
+ {
+ std::stringstream ss;
+ ss.precision(prec);
+ ss.flags(f[i]);
+ ss << mp_t(val);
+ const char* expect = zeros[col];
+ if(ss.str() != expect)
+ {
+ std::cout << std::setprecision(20) << "Testing value " << val << std::endl;
+ print_flags(f[i]);
+ std::cout << "Precision is: " << prec << std::endl;
+ std::cout << "Got: " << ss.str() << std::endl;
+ std::cout << "Expected: " << expect << std::endl;
+ ++boost::detail::test_errors();
+ mp_t(val).str(prec, f[i]); // for debugging
+ }
+ }
+ }
+}
+
+int main()
+{
+#ifdef TEST_MPFR_50
+ test<boost::multiprecision::mpfr_float_50>();
+ test<boost::multiprecision::mpfr_float_100>();
+#endif
+#ifdef TEST_CPP_FLOAT
+ test<boost::multiprecision::cpp_float_50>();
+ test<boost::multiprecision::cpp_float_100>();
+#endif
+#ifdef TEST_MPF_50
+ test<boost::multiprecision::mpf_float_50>();
+ test<boost::multiprecision::mpf_float_100>();
+#endif
+ return boost::report_errors();
+}
+
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