You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and dots ('.'), can be up to 35 characters long. Letters must be lowercase.
333 lines
16 KiB
333 lines
16 KiB
// Copyright (c) 2001-2011 Hartmut Kaiser |
|
// |
|
// 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_0.txt) |
|
|
|
#if !defined(BOOST_SPIRIT_KARMA_REAL_POLICIES_MAR_02_2007_0936AM) |
|
#define BOOST_SPIRIT_KARMA_REAL_POLICIES_MAR_02_2007_0936AM |
|
|
|
#if defined(_MSC_VER) |
|
#pragma once |
|
#endif |
|
|
|
#include <boost/config/no_tr1/cmath.hpp> |
|
#include <boost/math/special_functions/fpclassify.hpp> |
|
#include <boost/type_traits/remove_const.hpp> |
|
|
|
#include <boost/spirit/home/support/char_class.hpp> |
|
#include <boost/spirit/home/karma/generator.hpp> |
|
#include <boost/spirit/home/karma/char.hpp> |
|
#include <boost/spirit/home/karma/numeric/int.hpp> |
|
#include <boost/spirit/home/karma/numeric/detail/real_utils.hpp> |
|
|
|
#include <boost/mpl/bool.hpp> |
|
|
|
namespace boost { namespace spirit { namespace karma |
|
{ |
|
/////////////////////////////////////////////////////////////////////////// |
|
// |
|
// real_policies, if you need special handling of your floating |
|
// point numbers, just overload this policy class and use it as a template |
|
// parameter to the karma::real_generator floating point specifier: |
|
// |
|
// template <typename T> |
|
// struct scientific_policy : karma::real_policies<T> |
|
// { |
|
// // we want the numbers always to be in scientific format |
|
// static int floatfield(T n) { return fmtflags::scientific; } |
|
// }; |
|
// |
|
// typedef |
|
// karma::real_generator<double, scientific_policy<double> > |
|
// science_type; |
|
// |
|
// karma::generate(sink, science_type(), 1.0); // will output: 1.0e00 |
|
// |
|
/////////////////////////////////////////////////////////////////////////// |
|
template <typename T> |
|
struct real_policies |
|
{ |
|
/////////////////////////////////////////////////////////////////////// |
|
// Expose the data type the generator is targeted at |
|
/////////////////////////////////////////////////////////////////////// |
|
typedef T value_type; |
|
|
|
/////////////////////////////////////////////////////////////////////// |
|
// By default the policy doesn't require any special iterator |
|
// functionality. The floating point generator exposes its properties |
|
// from here, so this needs to be updated in case other properties |
|
// need to be implemented. |
|
/////////////////////////////////////////////////////////////////////// |
|
typedef mpl::int_<generator_properties::no_properties> properties; |
|
|
|
/////////////////////////////////////////////////////////////////////// |
|
// Specifies, which representation type to use during output |
|
// generation. |
|
/////////////////////////////////////////////////////////////////////// |
|
struct fmtflags |
|
{ |
|
enum { |
|
scientific = 0, // Generate floating-point values in scientific |
|
// format (with an exponent field). |
|
fixed = 1 // Generate floating-point values in fixed-point |
|
// format (with no exponent field). |
|
}; |
|
}; |
|
|
|
/////////////////////////////////////////////////////////////////////// |
|
// This is the main function used to generate the output for a |
|
// floating point number. It is called by the real generator in order |
|
// to perform the conversion. In theory all of the work can be |
|
// implemented here, but it is the easiest to use existing |
|
// functionality provided by the type specified by the template |
|
// parameter `Inserter`. |
|
// |
|
// sink: the output iterator to use for generation |
|
// n: the floating point number to convert |
|
// p: the instance of the policy type used to instantiate this |
|
// floating point generator. |
|
/////////////////////////////////////////////////////////////////////// |
|
template <typename Inserter, typename OutputIterator, typename Policies> |
|
static bool |
|
call (OutputIterator& sink, T n, Policies const& p) |
|
{ |
|
return Inserter::call_n(sink, n, p); |
|
} |
|
|
|
/////////////////////////////////////////////////////////////////////// |
|
// The default behavior is to not to require generating a sign. If |
|
// 'force_sign()' returns true, then all generated numbers will |
|
// have a sign ('+' or '-', zeros will have a space instead of a sign) |
|
// |
|
// n The floating point number to output. This can be used to |
|
// adjust the required behavior depending on the value of |
|
// this number. |
|
/////////////////////////////////////////////////////////////////////// |
|
static bool force_sign(T) |
|
{ |
|
return false; |
|
} |
|
|
|
/////////////////////////////////////////////////////////////////////// |
|
// Return whether trailing zero digits have to be emitted in the |
|
// fractional part of the output. If set, this flag instructs the |
|
// floating point generator to emit trailing zeros up to the required |
|
// precision digits (as returned by the precision() function). |
|
// |
|
// n The floating point number to output. This can be used to |
|
// adjust the required behavior depending on the value of |
|
// this number. |
|
/////////////////////////////////////////////////////////////////////// |
|
static bool trailing_zeros(T) |
|
{ |
|
// the default behavior is not to generate trailing zeros |
|
return false; |
|
} |
|
|
|
/////////////////////////////////////////////////////////////////////// |
|
// Decide, which representation type to use in the generated output. |
|
// |
|
// By default all numbers having an absolute value of zero or in |
|
// between 0.001 and 100000 will be generated using the fixed format, |
|
// all others will be generated using the scientific representation. |
|
// |
|
// The function trailing_zeros() can be used to force the output of |
|
// trailing zeros in the fractional part up to the number of digits |
|
// returned by the precision() member function. The default is not to |
|
// generate the trailing zeros. |
|
// |
|
// n The floating point number to output. This can be used to |
|
// adjust the formatting flags depending on the value of |
|
// this number. |
|
/////////////////////////////////////////////////////////////////////// |
|
static int floatfield(T n) |
|
{ |
|
if (traits::test_zero(n)) |
|
return fmtflags::fixed; |
|
|
|
T abs_n = traits::get_absolute_value(n); |
|
return (abs_n >= 1e5 || abs_n < 1e-3) |
|
? fmtflags::scientific : fmtflags::fixed; |
|
} |
|
|
|
/////////////////////////////////////////////////////////////////////// |
|
// Return the maximum number of decimal digits to generate in the |
|
// fractional part of the output. |
|
// |
|
// n The floating point number to output. This can be used to |
|
// adjust the required precision depending on the value of |
|
// this number. If the trailing zeros flag is specified the |
|
// fractional part of the output will be 'filled' with |
|
// zeros, if appropriate |
|
// |
|
// Note: If the trailing_zeros flag is not in effect additional |
|
// comments apply. See the comment for the fraction_part() |
|
// function below. Moreover, this precision will be limited |
|
// to the value of std::numeric_limits<T>::digits10 + 1 |
|
/////////////////////////////////////////////////////////////////////// |
|
static unsigned precision(T) |
|
{ |
|
// by default, generate max. 3 fractional digits |
|
return 3; |
|
} |
|
|
|
/////////////////////////////////////////////////////////////////////// |
|
// Generate the integer part of the number. |
|
// |
|
// sink The output iterator to use for generation |
|
// n The absolute value of the integer part of the floating |
|
// point number to convert (always non-negative). |
|
// sign The sign of the overall floating point number to |
|
// convert. |
|
// force_sign Whether a sign has to be generated even for |
|
// non-negative numbers |
|
/////////////////////////////////////////////////////////////////////// |
|
template <typename OutputIterator> |
|
static bool integer_part (OutputIterator& sink, T n, bool sign |
|
, bool force_sign) |
|
{ |
|
return sign_inserter::call( |
|
sink, traits::test_zero(n), sign, force_sign) && |
|
int_inserter<10>::call(sink, n); |
|
} |
|
|
|
/////////////////////////////////////////////////////////////////////// |
|
// Generate the decimal point. |
|
// |
|
// sink The output iterator to use for generation |
|
// n The fractional part of the floating point number to |
|
// convert. Note that this number is scaled such, that |
|
// it represents the number of units which correspond |
|
// to the value returned from the precision() function |
|
// earlier. I.e. a fractional part of 0.01234 is |
|
// represented as 1234 when the 'Precision' is 5. |
|
// precision The number of digits to emit as returned by the |
|
// function 'precision()' above |
|
// |
|
// This is given to allow to decide, whether a decimal point |
|
// has to be generated at all. |
|
// |
|
// Note: If the trailing_zeros flag is not in effect additional |
|
// comments apply. See the comment for the fraction_part() |
|
// function below. |
|
/////////////////////////////////////////////////////////////////////// |
|
template <typename OutputIterator> |
|
static bool dot (OutputIterator& sink, T /*n*/, unsigned /*precision*/) |
|
{ |
|
return char_inserter<>::call(sink, '.'); // generate the dot by default |
|
} |
|
|
|
/////////////////////////////////////////////////////////////////////// |
|
// Generate the fractional part of the number. |
|
// |
|
// sink The output iterator to use for generation |
|
// n The fractional part of the floating point number to |
|
// convert. This number is scaled such, that it represents |
|
// the number of units which correspond to the 'Precision'. |
|
// I.e. a fractional part of 0.01234 is represented as 1234 |
|
// when the 'precision_' parameter is 5. |
|
// precision_ The corrected number of digits to emit (see note |
|
// below) |
|
// precision The number of digits to emit as returned by the |
|
// function 'precision()' above |
|
// |
|
// Note: If trailing_zeros() does not return true the 'precision_' |
|
// parameter will have been corrected from the value the |
|
// precision() function returned earlier (defining the maximal |
|
// number of fractional digits) in the sense, that it takes into |
|
// account trailing zeros. I.e. a floating point number 0.0123 |
|
// and a value of 5 returned from precision() will result in: |
|
// |
|
// trailing_zeros is not specified: |
|
// n 123 |
|
// precision_ 4 |
|
// |
|
// trailing_zeros is specified: |
|
// n 1230 |
|
// precision_ 5 |
|
// |
|
/////////////////////////////////////////////////////////////////////// |
|
template <typename OutputIterator> |
|
static bool fraction_part (OutputIterator& sink, T n |
|
, unsigned precision_, unsigned precision) |
|
{ |
|
// allow for ADL to find the correct overload for floor and log10 |
|
using namespace std; |
|
|
|
// The following is equivalent to: |
|
// generate(sink, right_align(precision, '0')[ulong], n); |
|
// but it's spelled out to avoid inter-modular dependencies. |
|
|
|
typename remove_const<T>::type digits = |
|
(traits::test_zero(n) ? 0 : floor(log10(n))) + 1; |
|
bool r = true; |
|
for (/**/; r && digits < precision_; digits = digits + 1) |
|
r = char_inserter<>::call(sink, '0'); |
|
if (precision && r) |
|
r = int_inserter<10>::call(sink, n); |
|
return r; |
|
} |
|
|
|
/////////////////////////////////////////////////////////////////////// |
|
// Generate the exponential part of the number (this is called only |
|
// if the floatfield() function returned the 'scientific' flag). |
|
// |
|
// sink The output iterator to use for generation |
|
// n The (signed) exponential part of the floating point |
|
// number to convert. |
|
// |
|
// The Tag template parameter is either of the type unused_type or |
|
// describes the character class and conversion to be applied to any |
|
// output possibly influenced by either the lower[...] or upper[...] |
|
// directives. |
|
/////////////////////////////////////////////////////////////////////// |
|
template <typename CharEncoding, typename Tag, typename OutputIterator> |
|
static bool exponent (OutputIterator& sink, long n) |
|
{ |
|
long abs_n = traits::get_absolute_value(n); |
|
bool r = char_inserter<CharEncoding, Tag>::call(sink, 'e') && |
|
sign_inserter::call(sink, traits::test_zero(n) |
|
, traits::test_negative(n), false); |
|
|
|
// the C99 Standard requires at least two digits in the exponent |
|
if (r && abs_n < 10) |
|
r = char_inserter<CharEncoding, Tag>::call(sink, '0'); |
|
return r && int_inserter<10>::call(sink, abs_n); |
|
} |
|
|
|
/////////////////////////////////////////////////////////////////////// |
|
// Print the textual representations for non-normal floats (NaN and |
|
// Inf) |
|
// |
|
// sink The output iterator to use for generation |
|
// n The (signed) floating point number to convert. |
|
// force_sign Whether a sign has to be generated even for |
|
// non-negative numbers |
|
// |
|
// The Tag template parameter is either of the type unused_type or |
|
// describes the character class and conversion to be applied to any |
|
// output possibly influenced by either the lower[...] or upper[...] |
|
// directives. |
|
// |
|
// Note: These functions get called only if fpclassify() returned |
|
// FP_INFINITY or FP_NAN. |
|
/////////////////////////////////////////////////////////////////////// |
|
template <typename CharEncoding, typename Tag, typename OutputIterator> |
|
static bool nan (OutputIterator& sink, T n, bool force_sign) |
|
{ |
|
return sign_inserter::call( |
|
sink, false, traits::test_negative(n), force_sign) && |
|
string_inserter<CharEncoding, Tag>::call(sink, "nan"); |
|
} |
|
|
|
template <typename CharEncoding, typename Tag, typename OutputIterator> |
|
static bool inf (OutputIterator& sink, T n, bool force_sign) |
|
{ |
|
return sign_inserter::call( |
|
sink, false, traits::test_negative(n), force_sign) && |
|
string_inserter<CharEncoding, Tag>::call(sink, "inf"); |
|
} |
|
}; |
|
}}} |
|
|
|
#endif // defined(BOOST_SPIRIT_KARMA_REAL_POLICIES_MAR_02_2007_0936AM)
|
|
|