[Boost-commit] svn:boost r73475 - in sandbox/e_float/libs/e_float: src/e_float/efx test/real/cases

Subject: [Boost-commit] svn:boost r73475 - in sandbox/e_float/libs/e_float: src/e_float/efx test/real/cases
From: e_float_at_[hidden]
Date: 2011-08-01 10:15:49

Author: christopher_kormanyos
Date: 2011-08-01 10:15:48 EDT (Mon, 01 Aug 2011)
New Revision: 73475
URL: http://svn.boost.org/trac/boost/changeset/73475

Log:
- Added ostream-write handling for std::setw(...), std::setfill(...), std::left, std::right, std::internal.
Text files modified: 
   sandbox/e_float/libs/e_float/src/e_float/efx/e_float_efx.cpp                      |   170 +++++++++++++++++---------------------- 
   sandbox/e_float/libs/e_float/test/real/cases/test_case_0000y_write_to_ostream.cpp |    24 ++++                                    
   2 files changed, 96 insertions(+), 98 deletions(-)

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-01 10:15:48 EDT (Mon, 01 Aug 2011)
@@ -43,9 +43,9 @@
   os_float_filed_type;
 
   // Emphasize: This template class can be used with native floating-point
-  // types like float, double and 10-byte long double. It will need to be
-  // extended for 16-byte long double because the mantissa will no longer
-  // fit in UINT64.
+  // types like float, double and 10-byte long double. Note: It would need
+  // to be extended for 16-byte long double because the mantissa would
+  // no longer fit in UINT64.
   template<typename native_float_type>
   class native_float_parts : private Util::noncopyable
   {
@@ -1236,7 +1236,7 @@
 
   std::stringstream ss;
 
-  ss << std::setprecision(static_cast<std::streamsize>(std::numeric_limits<double>::digits10 + 3))
+  ss << std::setprecision(static_cast<std::streamsize>(std::numeric_limits<double>::max_digits10 + 1))
      << std::scientific
      << *this;
 
@@ -1436,52 +1436,6 @@
   return val;
 }
 
-void efx::e_float::round_output_string(std::string& str, INT64& my_exp, const std::size_t number_of_digits)
-{
-  // Cut the output to the size of the precision.
-  if(str.length() > number_of_digits)
-  {
-    // Get the digit after the last needed digit for rounding
-    const UINT32 round = static_cast<UINT32>(static_cast<UINT32>(str.at(number_of_digits)) - static_cast<UINT32>('0'));
-
-    // Truncate the string
-    str = str.substr(static_cast<std::size_t>(0u), number_of_digits);
-
-    if(round >= static_cast<UINT32>(5u))
-    {
-      std::size_t ix = static_cast<std::size_t>(str.length() - 1u);
-
-      // Every trailing 9 must be rounded up
-      while(ix && (static_cast<INT32>(str.at(ix)) - static_cast<INT32>('0') == static_cast<INT32>(9)))
-      {
-        str.at(ix) = static_cast<char>('0');
-        --ix;
-      }
-
-      if(!ix)
-      {
-        // There were nothing but trailing nines.
-        if(static_cast<INT32>(static_cast<INT32>(str.at(ix)) - static_cast<INT32>(0x30)) == static_cast<INT32>(9))
-        {
-          // Increment up to the next order and adjust exponent.
-          str.at(ix) = static_cast<char>('1');
-          ++my_exp;
-        }
-        else
-        {
-          // Round up this digit
-          ++str.at(ix);
-        }
-      }
-      else
-      {
-        // Round up last digit.
-        ++str[ix];
-      }
-    }
-  }
-}
-
 void efx::e_float::wr_string(std::string& str, std::ostream& os) const
 {
   // Handle INF and NaN.
@@ -1513,34 +1467,19 @@
                                                                             : static_cast<std::size_t>(0u));
 
   // Assess the format flags.
-  const std::ios::fmtflags f = os.flags();
+  const std::ios::fmtflags my_flags = os.flags();
 
   os_float_filed_type my_float_field;
 
-  if((f & std::ios::scientific) != static_cast<std::ios::fmtflags>(0u))
-  {
-    my_float_field = os_float_field_scientific;
-  }
-  else if((f & std::ios::fixed) != static_cast<std::ios::fmtflags>(0u))
-  {
-    my_float_field = os_float_field_fixed;
-  }
-  else
-  {
-    my_float_field = os_float_field_none;
-  }
+  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; }
+  else { my_float_field = os_float_field_none; }
 
   bool use_scientific = false;
   bool use_fixed = false;
 
-  if(my_float_field == os_float_field_scientific)
-  {
-    use_scientific = true;
-  }
-  else if(my_float_field == os_float_field_fixed)
-  {
-    use_fixed = true;
-  }
+  if     (my_float_field == os_float_field_scientific) { use_scientific = true; }
+  else if(my_float_field == os_float_field_fixed)      { use_fixed = true; }
   else // os_float_field_none
   {
     if(my_exp < static_cast<INT64>(-4))
@@ -1600,41 +1539,82 @@
   round_output_string(str, my_exp, the_number_of_digits_i_want_from_e_float);
 
   // Obtain additional format information.
-  const bool my_uppercase  = ((f & std::ios::uppercase)  != static_cast<std::ios::fmtflags>(0u));
-  const bool my_showpos    = ((f & std::ios::showpos)    != static_cast<std::ios::fmtflags>(0u));
-  const bool my_showpoint  = ((f & std::ios::showpoint)  != static_cast<std::ios::fmtflags>(0u));
+  const bool my_uppercase  = ((my_flags & std::ios::uppercase)  != static_cast<std::ios::fmtflags>(0u));
+  const bool my_showpos    = ((my_flags & std::ios::showpos)    != static_cast<std::ios::fmtflags>(0u));
+  const bool my_showpoint  = ((my_flags & std::ios::showpoint)  != static_cast<std::ios::fmtflags>(0u));
 
   // Write the output string in the desired format.
-  if(my_float_field == os_float_field_scientific)
-  {
-    wr_string_scientific(str, my_exp, os_precision, my_showpoint, my_uppercase);
-  }
-  else if(my_float_field == os_float_field_fixed)
-  {
-    wr_string_fixed(str, my_exp, os_precision, my_showpoint);
-  }
+  if     (my_float_field == os_float_field_scientific) { wr_string_scientific(str, my_exp, os_precision, my_showpoint, my_uppercase); }
+  else if(my_float_field == os_float_field_fixed)      { wr_string_fixed(str, my_exp, os_precision, my_showpoint); }
   else // os_float_field_none
   {
-    if(use_scientific)
-    {
-      wr_string_scientific(str, my_exp, os_precision, my_showpoint, my_uppercase, true);
-    }
-    else // use_fixed
-    {
-      wr_string_fixed(str, my_exp, os_precision, my_showpoint, true);
-    }
+    (use_scientific ? wr_string_scientific(str, my_exp, os_precision, my_showpoint, my_uppercase, true)
+                    : wr_string_fixed(str, my_exp, os_precision, my_showpoint, true));
   }
 
   // Append the sign.
-  if(isneg())
+  if     (isneg())    { str.insert(static_cast<std::size_t>(0u), "-"); }
+  else if(my_showpos) { str.insert(static_cast<std::size_t>(0u), "+"); }
+
+  // Handle std::setw(...), std::setfill(...), std::left, std::right, std::internal.
+  const std::size_t my_width = ((os.width() >= static_cast<std::streamsize>(0)) ? static_cast<std::size_t>(os.width())
+                                                                                : static_cast<std::size_t>(0u));
+
+  if(my_width > str.length())
   {
-    str.insert(static_cast<std::size_t>(0u), "-");
+    // Get the number of fill characters.
+    const std::size_t n_fill = static_cast<std::size_t>(my_width - str.length());
+
+    // Left-justify is the exception, std::right and std::internal justify right.
+    const bool my_left = ((my_flags & std::ios::left)  != static_cast<std::ios::fmtflags>(0u));
+
+    // Justify left or right and insert the fill characters.
+    str.insert((my_left ? str.end() : str.begin()), n_fill, os.fill());
   }
-  else
+}
+
+void efx::e_float::round_output_string(std::string& str, INT64& my_exp, const std::size_t number_of_digits)
+{
+  // Cut the output to the size of the precision.
+  if(str.length() > number_of_digits)
   {
-    if(my_showpos)
+    // Get the digit after the last needed digit for rounding
+    const UINT32 round = static_cast<UINT32>(static_cast<UINT32>(str.at(number_of_digits)) - static_cast<UINT32>('0'));
+
+    // Truncate the string
+    str = str.substr(static_cast<std::size_t>(0u), number_of_digits);
+
+    if(round >= static_cast<UINT32>(5u))
     {
-      str.insert(static_cast<std::size_t>(0u), "+");
+      std::size_t ix = static_cast<std::size_t>(str.length() - 1u);
+
+      // Every trailing 9 must be rounded up
+      while(ix && (static_cast<INT32>(str.at(ix)) - static_cast<INT32>('0') == static_cast<INT32>(9)))
+      {
+        str.at(ix) = static_cast<char>('0');
+        --ix;
+      }
+
+      if(!ix)
+      {
+        // There were nothing but trailing nines.
+        if(static_cast<INT32>(static_cast<INT32>(str.at(ix)) - static_cast<INT32>(0x30)) == static_cast<INT32>(9))
+        {
+          // Increment up to the next order and adjust exponent.
+          str.at(ix) = static_cast<char>('1');
+          ++my_exp;
+        }
+        else
+        {
+          // Round up this digit
+          ++str.at(ix);
+        }
+      }
+      else
+      {
+        // Round up last digit.
+        ++str[ix];
+      }
     }
   }
 }

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-01 10:15:48 EDT (Mon, 01 Aug 2011)
@@ -197,22 +197,40 @@
         ss << std::fixed << std::showpos << std::showpoint << std::setprecision(29) << ef::pi() / e_float("1e10");
         str = ss.str();
         data.push_back(e_float(str));
-        str_pi = ::make_pi_string(static_cast<std::size_t>(19));
+        str_pi = ::make_pi_string(static_cast<std::size_t>(19u));
         str_pi.erase(str_pi.begin() + 1u);
         my_test_result &= (str == (std::string("+0.") + (std::string(9u, static_cast<char>('0')) + str_pi)));
         ss.clear();
         ss.str("");
 
-        // Note negative sign.
+        // Note the negative sign.
         ss << std::fixed << std::showpos << std::showpoint << std::setprecision(19) << -ef::pi() * e_float("1e10");
         str = ss.str();
         data.push_back(e_float(str));
-        str_pi = ::make_pi_string(static_cast<std::size_t>(29));
+        str_pi = ::make_pi_string(static_cast<std::size_t>(29u));
         str_pi.erase(str_pi.begin() + 1u);
         str_pi.insert(str_pi.begin() + 11u, 1u, static_cast<char>('.'));
         my_test_result &= (str == (std::string("-") + str_pi));
         ss.clear();
         ss.str("");
+
+        // Test right-justify and fill.
+        ss << std::fixed << std::noshowpos << std::showpoint << std::setprecision(20) << std::setw(100) << std::setfill(static_cast<char>('$')) << ef::pi();
+        str = ss.str();
+        data.push_back(e_float(str));
+        static const std::string str_dollar(static_cast<std::size_t>(78u), static_cast<char>('$'));
+        my_test_result &= (str == (str_dollar + std::string("3.14159265358979323846")));
+        ss.clear();
+        ss.str("");
+
+        // Test left-justify and fill.
+        ss << std::fixed << std::noshowpos << std::showpoint << std::setprecision(20) << std::setw(100) << std::setfill(static_cast<char>('*')) << std::left << ef::pi();
+        str = ss.str();
+        data.push_back(e_float(str));
+        static const std::string str_star(static_cast<std::size_t>(78u), static_cast<char>('*'));
+        my_test_result &= (str == (std::string("3.14159265358979323846") + str_star));
+        ss.clear();
+        ss.str("");
       }
     };