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 = 0;
std::streamsize org_digits = digits;
BOOST_ASSERT(digits > 0);
int fpt = eval_fpclassify(b);
if(fpt == (int)FP_ZERO)
{
result = "0";
iszero = true;
}
else if(fpt == (int)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 == (int)FP_NAN)
{
return "nan";
}
else
{
//
// Start by figuring out the exponent:
//
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);
if(-expon > std::numeric_limits<number<Backend> >::max_exponent10 - 3)
{
int e = -expon / 2;
Backend t2;
eval_pow(t2, ten, e);
eval_multiply(t, t2, b);
eval_multiply(t, t2);
if(expon & 1)
eval_multiply(t, ten);
}
else
{
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;
//
// Adjust the number of digits required based on formatting options:
//
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;
//
// Extract the digits one at a time:
//
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.rbegin() - '0') & 1)
{
round_string_up_at(result, result.size() - 1, expon);
}
}
else if(cdigit >= 5)
{
round_string_up_at(result, result.size() - 1, expon);
}
}
}
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(static_cast<std::string::size_type>(0), 1, '-');
format_float_string(result, expon, org_digits, f, iszero);
return result;
}
