|
|
Boost-Commit : |
Subject: [Boost-commit] svn:boost r83856 - in trunk: boost/multiprecision boost/multiprecision/detail libs/multiprecision/config libs/multiprecision/test libs/multiprecision/test/math/instances
From: john_at_[hidden]
Date: 2013-04-12 05:01:22
Author: johnmaddock
Date: 2013-04-12 05:01:20 EDT (Fri, 12 Apr 2013)
New Revision: 83856
URL: http://svn.boost.org/trac/boost/changeset/83856
Log:
Initial Intel C++ _Quad support in float128.
Added:
trunk/boost/multiprecision/detail/float_string_cvt.hpp (contents, props changed)
trunk/libs/multiprecision/config/has_intel_quad.cpp (contents, props changed)
Text files modified:
trunk/boost/multiprecision/float128.hpp | 116 +++++++++++++++++++++++++++++++++------
trunk/libs/multiprecision/config/Jamfile.v2 | 5 +
trunk/libs/multiprecision/test/Jamfile.v2 | 41 ++++++++++++++
trunk/libs/multiprecision/test/math/instances/Jamfile.v2 | 11 ++-
trunk/libs/multiprecision/test/test_arithmetic_cpp_dec_float_1.cpp | 2
trunk/libs/multiprecision/test/test_arithmetic_float_128.cpp | 2
6 files changed, 151 insertions(+), 26 deletions(-)
Added: trunk/boost/multiprecision/detail/float_string_cvt.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/multiprecision/detail/float_string_cvt.hpp 2013-04-12 05:01:20 EDT (Fri, 12 Apr 2013)
@@ -0,0 +1,250 @@
+///////////////////////////////////////////////////////////////
+// Copyright 2013 John Maddock. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_
+
+#ifndef BOOST_MP_FLOAT_STRING_CVT_HPP
+#define BOOST_MP_FLOAT_STRING_CVT_HPP
+
+#include <cctype>
+
+namespace boost{ namespace multiprecision{ namespace detail{
+
+inline void round_string_up_at(std::string& s, int pos)
+{
+ if(pos < 0)
+ {
+ s.insert(0, 1, '1');
+ }
+ else if(s[pos] == '9')
+ {
+ s[pos] = '0';
+ round_string_up_at(s, pos - 1);
+ }
+ else
+ {
+ ++s[pos];
+ }
+}
+
+template <class Backend>
+std::string convert_to_string(Backend b, std::streamsize digits, std::ios_base::fmtflags f)
+{
+ using default_ops::eval_log10;
+ using default_ops::eval_floor;
+ using default_ops::eval_pow;
+ using default_ops::eval_convert_to;
+ using default_ops::eval_multiply;
+ using default_ops::eval_divide;
+ using default_ops::eval_subtract;
+ using default_ops::eval_fpclassify;
+
+ typedef typename mpl::front<typename Backend::unsigned_types>::type ui_type;
+ typedef typename Backend::exponent_type exponent_type;
+
+ std::string result;
+ bool iszero = false;
+ bool isneg = false;
+ exponent_type expon;
+ std::streamsize org_digits = digits;
+ BOOST_ASSERT(digits > 0);
+
+ int fpt = eval_fpclassify(b);
+
+ if(fpt == FP_ZERO)
+ {
+ result = "0";
+ iszero = true;
+ }
+ else if(fpt == FP_INFINITE)
+ {
+ if(b.compare(ui_type(0)) < 0)
+ return "-inf";
+ else
+ return ((f & std::ios_base::showpos) == std::ios_base::showpos) ? "+inf" : "inf";
+ }
+ else if(fpt == FP_NAN)
+ {
+ return "nan";
+ }
+ else
+ {
+ isneg = b.compare(ui_type(0)) < 0;
+ if(isneg)
+ b.negate();
+ Backend t;
+ Backend ten;
+ ten = ui_type(10);
+
+ eval_log10(t, b);
+ eval_floor(t, t);
+ eval_convert_to(&expon, t);
+ eval_pow(t, ten, -expon);
+ eval_multiply(t, b);
+ //
+ // Make sure we're between [1,10) and adjust if not:
+ //
+ if(t.compare(ui_type(1)) < 0)
+ {
+ eval_multiply(t, ui_type(10));
+ --expon;
+ }
+ else if(t.compare(ui_type(10)) >= 0)
+ {
+ eval_divide(t, ui_type(10));
+ ++expon;
+ }
+ Backend digit;
+ ui_type cdigit;
+ if(((f & std::ios_base::fixed) == std::ios_base::fixed) && (expon != -1))
+ digits += expon + 1;
+ if((f & std::ios_base::scientific) == std::ios_base::scientific)
+ ++digits;
+ for(unsigned i = 0; i < digits; ++i)
+ {
+ eval_floor(digit, t);
+ eval_convert_to(&cdigit, digit);
+ result += static_cast<char>('0' + cdigit);
+ eval_subtract(t, digit);
+ eval_multiply(t, ten);
+ }
+ //
+ // Possibly round result:
+ //
+ if(digits >= 0)
+ {
+ eval_floor(digit, t);
+ eval_convert_to(&cdigit, digit);
+ eval_subtract(t, digit);
+ if((cdigit == 5) && (t.compare(ui_type(0)) == 0))
+ {
+ // Bankers rounding:
+ if((result.back() - '0') & 1)
+ {
+ round_string_up_at(result, result.size() - 1);
+ }
+ }
+ else if(cdigit >= 5)
+ {
+ round_string_up_at(result, result.size() - 1);
+ }
+ }
+ }
+ while((result.size() > digits) && result.size())
+ {
+ // We may get here as a result of rounding...
+ if(result.size() > 1)
+ result.erase(result.size() - 1);
+ else
+ {
+ if(expon > 0)
+ --expon; // so we put less padding in the result.
+ else
+ ++expon;
+ ++digits;
+ }
+ }
+ BOOST_ASSERT(org_digits >= 0);
+ if(isneg)
+ result.insert(0, 1, '-');
+ format_float_string(result, expon, org_digits, f, iszero);
+
+ return result;
+}
+
+template <class Backend>
+void convert_from_string(Backend& b, const char* p)
+{
+ using default_ops::eval_multiply;
+ using default_ops::eval_add;
+ using default_ops::eval_pow;
+ using default_ops::eval_divide;
+
+ typedef typename mpl::front<typename Backend::unsigned_types>::type ui_type;
+ b = ui_type(0);
+ if(!p || (*p == 0))
+ return;
+
+ bool is_neg = false;
+ bool is_neg_expon = false;
+ static const ui_type ten = ui_type(10);
+ typename Backend::exponent_type expon = 0;
+
+ if(*p == '+') ++p;
+ else if(*p == '-')
+ {
+ is_neg = true;
+ ++p;
+ }
+ if((std::strcmp(p, "nan") == 0) || (std::strcmp(p, "NaN") == 0) || (std::strcmp(p, "NAN") == 0))
+ {
+ eval_divide(b, ui_type(0));
+ if(is_neg)
+ b.negate();
+ return;
+ }
+ if((std::strcmp(p, "inf") == 0) || (std::strcmp(p, "Inf") == 0) || (std::strcmp(p, "INF") == 0))
+ {
+ b = ui_type(1);
+ eval_divide(b, ui_type(0));
+ if(is_neg)
+ b.negate();
+ return;
+ }
+ while(std::isdigit(*p))
+ {
+ eval_multiply(b, ten);
+ eval_add(b, ui_type(*p - '0'));
+ ++p;
+ }
+ if(*p == '.')
+ {
+ ++p;
+ while(std::isdigit(*p))
+ {
+ eval_multiply(b, ten);
+ eval_add(b, ui_type(*p - '0'));
+ ++p;
+ --expon;
+ }
+ }
+ if((*p == 'e') || (*p == 'E'))
+ {
+ ++p;
+ if(*p == '+') ++p;
+ else if(*p == '-')
+ {
+ is_neg_expon = true;
+ ++p;
+ }
+ typename Backend::exponent_type e2 = 0;
+ while(std::isdigit(*p))
+ {
+ e2 *= 10;
+ e2 += (*p - '0');
+ ++p;
+ }
+ if(is_neg_expon)
+ e2 = -e2;
+ expon += e2;
+ }
+ if(expon)
+ {
+ // scale by 10^expon:
+ Backend t;
+ t = ten;
+ eval_pow(t, t, expon);
+ eval_multiply(b, t);
+ }
+ if(is_neg)
+ b.negate();
+ if(*p)
+ {
+ // Unexpected input in string:
+ BOOST_THROW_EXCEPTION(std::runtime_error("Unexpected characters in string being interpreted as a float128."));
+ }
+}
+
+}}} // namespaces
+
+#endif
Modified: trunk/boost/multiprecision/float128.hpp
==============================================================================
--- trunk/boost/multiprecision/float128.hpp (original)
+++ trunk/boost/multiprecision/float128.hpp 2013-04-12 05:01:20 EDT (Fri, 12 Apr 2013)
@@ -6,12 +6,80 @@
#ifndef BOOST_MP_FLOAT128_HPP
#define BOOST_MP_FLOAT128_HPP
+#include <boost/config.hpp>
+#include <boost/multiprecision/number.hpp>
+
+
+#ifndef BOOST_INTEL
+
extern "C" {
#include <quadmath.h>
}
-#include <boost/multiprecision/number.hpp>
-#include <boost/scoped_array.hpp>
+#else
+
+#include <boost/multiprecision/detail/float_string_cvt.hpp>
+
+typedef _Quad __float128;
+
+extern "C" {
+_Quad __ldexpq(_Quad, int);
+_Quad __frexpq(_Quad, int*);
+_Quad __fabsq(_Quad);
+_Quad __floorq(_Quad);
+_Quad __ceilq(_Quad);
+_Quad __sqrtq(_Quad);
+_Quad __truncq(_Quad);
+_Quad __expq(_Quad);
+_Quad __powq(_Quad, _Quad);
+_Quad __logq(_Quad);
+_Quad __log10q(_Quad);
+_Quad __sinq(_Quad);
+_Quad __cosq(_Quad);
+_Quad __tanq(_Quad);
+_Quad __asinq(_Quad);
+_Quad __acosq(_Quad);
+_Quad __atanq(_Quad);
+_Quad __sinhq(_Quad);
+_Quad __coshq(_Quad);
+_Quad __tanhq(_Quad);
+_Quad __fmodq(_Quad, _Quad);
+_Quad __atan2q(_Quad, _Quad);
+
+#define ldexpq __ldexpq
+#define frexpq __frexpq
+#define fabsq __fabsq
+#define floorq __floorq
+#define ceilq __ceilq
+#define sqrtq __sqrtq
+#define truncq __truncq
+#define expq __expq
+#define powq __powq
+#define logq __logq
+#define log10q __log10q
+#define sinq __sinq
+#define cosq __cosq
+#define tanq __tanq
+#define asinq __asinq
+#define acosq __acosq
+#define atanq __atanq
+#define sinhq __sinhq
+#define coshq __coshq
+#define tanhq __tanhq
+#define fmodq __fmodq
+#define atan2q __atan2q
+}
+
+inline _Quad isnanq(_Quad v)
+{
+ return v != v;
+}
+inline _Quad isinfq(_Quad v)
+{
+ return __fabsq(v) > 1.18973149535723176508575932662800702e4932Q;
+}
+
+#endif
namespace boost{
namespace multiprecision{
@@ -35,7 +103,7 @@
struct float128_backend
{
typedef mpl::list<signed char, short, int, long, long long> signed_types;
- typedef mpl::list<unsigned char, unsigned short,
+ typedef mpl::list<unsigned char, unsigned short,
unsigned int, unsigned long, unsigned long long> unsigned_types;
typedef mpl::list<float, double, long double> float_types;
typedef int exponent_type;
@@ -45,7 +113,7 @@
public:
float128_backend() : m_value(0) {}
float128_backend(const float128_backend& o) : m_value(o.m_value) {}
- float128_backend& operator = (const float128_backend& o)
+ float128_backend& operator = (const float128_backend& o)
{
m_value = o.m_value;
return *this;
@@ -61,12 +129,16 @@
}
float128_backend& operator = (const char* s)
{
+#ifndef BOOST_INTEL
char* p_end;
m_value = strtoflt128(s, &p_end);
if(p_end - s != (std::ptrdiff_t)std::strlen(s))
{
BOOST_THROW_EXCEPTION(std::runtime_error("Unable to interpret input string as a floating point value"));
}
+#else
+ detail::convert_from_string(*this, s);
+#endif
return *this;
}
void swap(float128_backend& o)
@@ -75,8 +147,8 @@
}
std::string str(std::streamsize digits, std::ios_base::fmtflags f)const
{
+#ifndef BOOST_INTEL
char buf[100];
- boost::scoped_array<char> buf2;
std::string format = "%";
if(f & std::ios_base::showpos)
format += "+";
@@ -107,6 +179,9 @@
return &buf2[0];
}
return buf;
+#else
+ return detail::convert_to_string(*this, digits ? digits : 37, f);
+#endif
}
void negate()
{
@@ -270,19 +345,19 @@
inline void eval_trunc(float128_backend& result, const float128_backend& arg)
{
- if(isnanq(arg.value()) || isinf(arg.value()))
+ if(isnanq(arg.value()) || isinfq(arg.value()))
{
result = boost::math::policies::raise_rounding_error(
- "boost::multiprecision::trunc<%1%>(%1%)", 0,
- number<float128_backend, et_off>(arg),
- number<float128_backend, et_off>(arg),
+ "boost::multiprecision::trunc<%1%>(%1%)", 0,
+ number<float128_backend, et_off>(arg),
+ number<float128_backend, et_off>(arg),
boost::math::policies::policy<>()).backend();
return;
}
result.value() = truncq(arg.value());
}
/*
-//
+//
// This doesn't actually work... rely on our own default version instead.
//
inline void eval_round(float128_backend& result, const float128_backend& arg)
@@ -290,15 +365,16 @@
if(isnanq(arg.value()) || isinf(arg.value()))
{
result = boost::math::policies::raise_rounding_error(
- "boost::multiprecision::trunc<%1%>(%1%)", 0,
- number<float128_backend, et_off>(arg),
- number<float128_backend, et_off>(arg),
+ "boost::multiprecision::trunc<%1%>(%1%)", 0,
+ number<float128_backend, et_off>(arg),
+ number<float128_backend, et_off>(arg),
boost::math::policies::policy<>()).backend();
return;
}
result.value() = roundq(arg.value());
}
*/
+
inline void eval_exp(float128_backend& result, const float128_backend& arg)
{
result.value() = expq(arg.value());
@@ -372,21 +448,21 @@
typedef boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> number_type;
public:
BOOST_STATIC_CONSTEXPR bool is_specialized = true;
- static number_type (min)() BOOST_NOEXCEPT { return FLT128_MIN; }
- static number_type (max)() BOOST_NOEXCEPT { return FLT128_MAX; }
+ static number_type (min)() BOOST_NOEXCEPT { return 3.36210314311209350626267781732175260e-4932Q; }
+ static number_type (max)() BOOST_NOEXCEPT { return 1.18973149535723176508575932662800702e4932Q; }
static number_type lowest() BOOST_NOEXCEPT { return -(max)(); }
- BOOST_STATIC_CONSTEXPR int digits = FLT128_MANT_DIG;
- BOOST_STATIC_CONSTEXPR int digits10 = 33;
+ BOOST_STATIC_CONSTEXPR int digits = 113;
+ BOOST_STATIC_CONSTEXPR int digits10 = 34;
BOOST_STATIC_CONSTEXPR int max_digits10 = 36;
BOOST_STATIC_CONSTEXPR bool is_signed = true;
BOOST_STATIC_CONSTEXPR bool is_integer = false;
BOOST_STATIC_CONSTEXPR bool is_exact = false;
BOOST_STATIC_CONSTEXPR int radix = 2;
- static number_type epsilon() { return FLT128_EPSILON; }
+ static number_type epsilon() { return 1.92592994438723585305597794258492732e-34Q; }
static number_type round_error() { return 0; }
- BOOST_STATIC_CONSTEXPR int min_exponent = FLT128_MIN_EXP;
+ BOOST_STATIC_CONSTEXPR int min_exponent = -16381;
BOOST_STATIC_CONSTEXPR int min_exponent10 = min_exponent * 301L / 1000L;
- BOOST_STATIC_CONSTEXPR int max_exponent = FLT128_MAX_EXP;
+ BOOST_STATIC_CONSTEXPR int max_exponent = 16384;
BOOST_STATIC_CONSTEXPR int max_exponent10 = max_exponent * 301L / 1000L;
BOOST_STATIC_CONSTEXPR bool has_infinity = true;
BOOST_STATIC_CONSTEXPR bool has_quiet_NaN = true;
Modified: trunk/libs/multiprecision/config/Jamfile.v2
==============================================================================
--- trunk/libs/multiprecision/config/Jamfile.v2 (original)
+++ trunk/libs/multiprecision/config/Jamfile.v2 2013-04-12 05:01:20 EDT (Fri, 12 Apr 2013)
@@ -50,10 +50,15 @@
obj has_tommath : has_tommath.cpp :
<include>$(tommath_path) ;
exe has_float128 : has_float128.cpp quadmath ;
+exe has_intel_quad : has_intel_quad.cpp : <cxxflags>-Qoption,cpp,--extended_float_type ;
explicit has_gmp ;
explicit has_mpfr ;
explicit has_mpfi ;
explicit has_tommath ;
explicit has_float128 ;
+explicit has_intel_quad ;
+
+
+
Added: trunk/libs/multiprecision/config/has_intel_quad.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/multiprecision/config/has_intel_quad.cpp 2013-04-12 05:01:20 EDT (Fri, 12 Apr 2013)
@@ -0,0 +1,16 @@
+// Copyright John Maddock 2013.
+// 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)
+
+extern "C" _Quad __fabs(_Quad);
+
+int main()
+{
+ _Quad f = -2.0Q;
+ f = __fabsq(f);
+
+ return 0;
+}
+
+
Modified: trunk/libs/multiprecision/test/Jamfile.v2
==============================================================================
--- trunk/libs/multiprecision/test/Jamfile.v2 (original)
+++ trunk/libs/multiprecision/test/Jamfile.v2 2013-04-12 05:01:20 EDT (Fri, 12 Apr 2013)
@@ -108,6 +108,7 @@
run test_arithmetic_mpfi_50.cpp mpfi mpfr gmp : : : [ check-target-builds ../config//has_mpfi : : <build>no ] ;
run test_arithmetic_float_128.cpp quadmath : : : [ check-target-builds ../config//has_float128 : : <build>no ] ;
+run test_arithmetic_float_128.cpp : : : [ check-target-builds ../config//has_intel_quad : <cxxflags>-Qoption,cpp,--extended_float_type : <build>no ] : test_arithmetic_intel_quad ;
run test_numeric_limits.cpp
: # command line
@@ -202,6 +203,13 @@
<define>TEST_FLOAT128
[ check-target-builds ../config//has_float128 : : <build>no ]
: test_numeric_limits_float128 ;
+run test_numeric_limits.cpp
+ : # command line
+ : # input files
+ : # requirements
+ <define>TEST_FLOAT128
+ [ check-target-builds ../config//has_intel_quad : <cxxflags>-Qoption,cpp,--extended_float_type : <build>no ]
+ : test_numeric_limits_intel_quad ;
for local source in test_exp.cpp test_log.cpp test_pow.cpp test_sinh.cpp test_sqrt.cpp test_cosh.cpp test_tanh.cpp test_sin.cpp test_cos.cpp test_tan.cpp test_asin.cpp test_acos.cpp test_atan.cpp test_round.cpp test_fpclassify.cpp
{
@@ -239,6 +247,13 @@
[ check-target-builds ../config//has_float128 : : <build>no ]
<define>TEST_FLOAT128
: $(source:B)_float128 ;
+ run $(source)
+ : # command line
+ : # input files
+ : # requirements
+ [ check-target-builds ../config//has_intel_quad : <cxxflags>-Qoption,cpp,--extended_float_type : <build>no ]
+ <define>TEST_FLOAT128
+ : $(source:B)_intel_quad ;
}
run test_gmp_conversions.cpp gmp
@@ -354,6 +369,14 @@
release # Otherwise runtime is slow
[ check-target-builds ../config//has_float128 : : <build>no ]
: test_float_io_float128 ;
+run test_float_io.cpp
+ : # command line
+ : # input files
+ : # requirements
+ <define>TEST_FLOAT128
+ release # Otherwise runtime is slow
+ [ check-target-builds ../config//has_intel_quad : <cxxflags>-Qoption,cpp,--extended_float_type : <build>no ]
+ : test_float_io_intel_quad ;
run test_int_io.cpp $(TOMMATH)
: # command line
@@ -590,6 +613,20 @@
<toolset>msvc:<cxxflags>-bigobj
release
: $(source:B)_float128 ;
+ run $(source)
+ /boost/test//boost_unit_test_framework/<link>static
+ /boost/regex//boost_regex/<link>static
+ math/instances//test_instances_intel_quad/<link>static
+ : # command line
+ : # input files
+ : # requirements
+ [ check-target-builds ../config//has_intel_quad : <cxxflags>-Qoption,cpp,--extended_float_type : <build>no ]
+ <optimization>speed
+ <define>TEST_FLOAT128
+ <define>BOOST_ALL_NO_LIB
+ <toolset>msvc:<cxxflags>-bigobj
+ release
+ : $(source:B)_intel_quad ;
}
}
@@ -677,3 +714,7 @@
}
+
+
+
+
Modified: trunk/libs/multiprecision/test/math/instances/Jamfile.v2
==============================================================================
--- trunk/libs/multiprecision/test/math/instances/Jamfile.v2 (original)
+++ trunk/libs/multiprecision/test/math/instances/Jamfile.v2 2013-04-12 05:01:20 EDT (Fri, 12 Apr 2013)
@@ -40,7 +40,7 @@
lib mpfi : : <search>$(gmp_path) <search>$(mpfr_path) <search>$(mpfr_path)/build.vc10/lib/Win32/Debug <search>$(mpfi_path) <search>$(mpfi_path)/src ;
lib quadmath ;
-rule generate_objs ( suffix : variant_count : build_opts ? )
+rule generate_objs ( suffix : variant_count : build_opts * )
{
local result ;
switch $(variant_count)
@@ -65,13 +65,16 @@
return $(result) ;
}
-lib test_instances_mpf : [ generate_objs "_mpf" : 4 : <define>TEST_MPF_50 ] : [ check-target-builds ../config//has_gmp : : <build>no ] ;
-lib test_instances_mpfr : [ generate_objs "_mpfr" : 3 : <define>TEST_MPFR_50 ] : [ check-target-builds ../config//has_mpfr : : <build>no ] ;
+lib test_instances_mpf : [ generate_objs "_mpf" : 4 : <define>TEST_MPF_50 ] : [ check-target-builds ../../../config//has_gmp : : <build>no ] ;
+lib test_instances_mpfr : [ generate_objs "_mpfr" : 3 : <define>TEST_MPFR_50 ] : [ check-target-builds ../../../config//has_mpfr : : <build>no ] ;
lib test_instances_cpp_dec_float : [ generate_objs "_cpp_dec_float" : 3 : <define>TEST_CPP_DEC_FLOAT ] : ;
-lib test_instances_float128 : [ generate_objs "_float128" : 1 : <define>TEST_FLOAT128 ] : [ check-target-builds ../config//has_float128 : : <build>no ] ;
+lib test_instances_float128 : [ generate_objs "_float128" : 1 : <define>TEST_FLOAT128 ] : [ check-target-builds ../../../config//has_float128 : : <build>no ] ;
+lib test_instances_intel_quad : [ generate_objs "_intel_quad" : 1 : <define>TEST_FLOAT128 <cxxflags>-Qoption,cpp,--extended_float_type ] : [ check-target-builds ../../../config//has_intel_quad : <cxxflags>-Qoption,cpp,--extended_float_type : <build>no ] ;
explicit test_instances_mpf ;
explicit test_instances_mpfr ;
explicit test_instances_cpp_dec_float ;
explicit test_instances_float128 ;
+explicit test_instances_intel_quad ;
+
Modified: trunk/libs/multiprecision/test/test_arithmetic_cpp_dec_float_1.cpp
==============================================================================
--- trunk/libs/multiprecision/test/test_arithmetic_cpp_dec_float_1.cpp (original)
+++ trunk/libs/multiprecision/test/test_arithmetic_cpp_dec_float_1.cpp 2013-04-12 05:01:20 EDT (Fri, 12 Apr 2013)
@@ -20,6 +20,6 @@
int main()
{
test<boost::multiprecision::cpp_dec_float_50>();
- return 0;
+ return boost::report_errors();
}
Modified: trunk/libs/multiprecision/test/test_arithmetic_float_128.cpp
==============================================================================
--- trunk/libs/multiprecision/test/test_arithmetic_float_128.cpp (original)
+++ trunk/libs/multiprecision/test/test_arithmetic_float_128.cpp 2013-04-12 05:01:20 EDT (Fri, 12 Apr 2013)
@@ -14,6 +14,6 @@
int main()
{
test<boost::multiprecision::float128>();
- return 0;
+ 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