Increase precision in gammalib::str() floating point conversion functions and ad…

…d gammalib::rstrip_chars() function The gammalib::str() floating point conversion functions now make sure that no precision is lost in a string conversion (well, roughly).

Increase precision in gammalib::str() floating point conversion functions and ad…
…d gammalib::rstrip_chars() function The gammalib::str() floating point conversion functions now make sure that no precision is lost in a string conversion (well, roughly).
Jürgen Knödlseder
1 parent 94c6da34
Showing 9 changed files with 183 additions and 63 deletions
ChangeLog
NEWS
include/GTools.hpp
pyext/GTools.i
src/app/GApplicationPar.cpp
src/support/GTools.cpp
test/test_GMatrixSparse.cpp
test/test_GSupport.cpp
test/test_GVector.cpp
@@ -3,6 +3,7 @@
         * Version 1.2.0 released
         =========================
+        Increase precision of gammalib::str() floating point functions
         Add GFits::publish() methods (#1231)
         Add GVOTable class (#1231)
         Add multiplicative spectral model (#1861)
@@ -50,6 +50,7 @@ The following methods have been added:
 - GTime::last(const double& geolon)
 - GTime::now()
 - GFits::publish()
+- gammalib::rstrip_chars()
 The following methods have been removed:
 - <all classes>::eval_gradients()
@@ -187,7 +188,12 @@ or no maps (#1828).
 13. Support module
 ------------------
-None
+The gammalib::rstrip_chars() function has been added to right strip characters
+from a string.
+
+The gammalib::str() functions for single and double precision floating point
+numbers now have an increased precision so that significant digits are no
+longer lost.
 14. XML module
@@ -54,6 +54,8 @@ namespace gammalib {
     std::string              strip_whitespace(const std::string& arg);
     std::string              strip_chars(const std::string& arg,
                                          const std::string& chars);
+    std::string              rstrip_chars(const std::string& arg,
+                                          const std::string& chars);
     std::string              expand_env(const std::string& arg);
     std::string              filepath(const std::string& pathname,
                                       const std::string& filename);
@@ -41,6 +41,8 @@ namespace gammalib {
     std::string              strip_whitespace(const std::string& arg);
     std::string              strip_chars(const std::string& arg,
                                          const std::string& chars);
+    std::string              rstrip_chars(const std::string& arg,
+                                          const std::string& chars);
     std::string              expand_env(const std::string& arg);
     std::string              filepath(const std::string& pathname,
                                       const std::string& filename);
@@ -415,7 +415,7 @@ void GApplicationPar::real(const double&amp; value)
     }
     // Set value string at highest precision
-    std::string value_string = gammalib::str(value, 15);
+    std::string value_string = gammalib::str(value);
     // Strip trailing zeros
     std::string::size_type start = 0;
@@ -93,7 +93,7 @@ std::string gammalib::strip_chars(const std::string&amp; arg,
         std::string::size_type start = arg.find_first_not_of(chars);
         std::string::size_type stop  = arg.find_last_not_of(chars);
-        // Continue only is start and stop are valid
+        // Continue only if start and stop are valid
         if (start != std::string::npos && stop != std::string::npos) {
             // Continue only if stop is larger then or equal to  start
@@ -111,6 +111,37 @@ std::string gammalib::strip_chars(const std::string&amp; arg,
 /***********************************************************************//**
+ * @brief Strip trailing character from string
+ *
+ * @param[in] arg String from which character should be stripped.
+ * @param[in] chars Character(s) to be stripped.
+ * @return String with stripped characters.
+ ***************************************************************************/
+std::string gammalib::rstrip_chars(const std::string& arg,
+                                   const std::string& chars)
+{
+    // Initialise empty result string
+    std::string result;
+
+    // Continue only if argument is not empty
+    if (!arg.empty()) {
+
+        // Get stop
+        std::string::size_type stop = arg.find_last_not_of(chars);
+
+        // Continue only if stop is valid
+        if (stop != std::string::npos) {
+            result = arg.substr(0, stop+1);
+        }
+
+    } // endif: argument was not empty
+
+    // Return result
+    return result;
+}
+
+
+/***********************************************************************//**
  * @brief Expand environment variables in string
  *
  * @param[in] arg String.
@@ -447,21 +478,36 @@ std::string gammalib::str(const long long int&amp; value)
  * @brief Convert single precision value into string
  *
  * @param[in] value Single precision value to be converted into string.
- * @param[in] precision Floating point precision (optional).
+ * @param[in] precision Floating point precision.
  * @return String with single precision value.
+ *
+ * Converts a single precision value into a string. Any positive
+ * @p precision argument specifies the exact number of digits after the
+ * comma.
  ***************************************************************************/
 std::string gammalib::str(const float& value, const int& precision)
 {
+    // Allocate output stream
     std::ostringstream s_value;
+
+    // If specified then set the requested fixed point precision. Otherwise
+    // use a precision that should be sufficient for floating point values.
     if (precision > 0) {
         s_value.precision(precision);
         s_value.setf(std::ios::fixed, std::ios::floatfield);
     }
-    s_value << value;
-    if (precision > 0) {
-        s_value.unsetf(std::ios::floatfield);
+    else {
+        s_value.precision(7);
     }
-    return s_value.str();
+
+    // Put floating point value in stream
+    s_value << value;
+
+    // Convert to a string
+    std::string result = s_value.str();
+
+    // Return result
+    return result;
 }
@@ -469,21 +515,36 @@ std::string gammalib::str(const float&amp; value, const int&amp; precision)
  * @brief Convert double precision value into string
  *
  * @param[in] value Double precision value to be converted into string.
- * @param[in] precision Floating point precision (optional).
+ * @param[in] precision Floating point precision.
  * @return String with double precision value.
+ *
+ * Converts a double precision value into a string. Any positive
+ * @p precision argument specifies the exact number of digits after the
+ * comma.
  ***************************************************************************/
 std::string gammalib::str(const double& value, const int& precision)
 {
+    // Allocate output stream
     std::ostringstream s_value;
+
+    // If specified then set the requested fixed point precision. Otherwise
+    // use a precision that should be sufficient for floating point values.
     if (precision > 0) {
         s_value.precision(precision);
         s_value.setf(std::ios::fixed, std::ios::floatfield);
     }
-    s_value << value;
-    if (precision > 0) {
-        s_value.unsetf(std::ios::floatfield);
+    else {
+        s_value.precision(15);
     }
-    return s_value.str();
+
+    // Put double precision floating point value in stream
+    s_value << value;
+
+    // Convert to a string
+    std::string result = s_value.str();
+
+    // Return result
+    return result;
 }
 /***************************************************************************
  *            test_GMatrixSparse.cpp - Test sparse matrix class            *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2006-2015 by Juergen Knoedlseder                         *
+ *  copyright (C) 2006-2016 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -1277,8 +1277,7 @@ void TestGMatrixSparse::matrix_print(void)
     // Test the print method
     std::string output = m_test.print();
-    test_assert((output == reference), "Test matrix printing",
-                "Unexpected print() output:\n"+output+"\nExpected:\n"+reference);
+    test_value(output, reference);
     // Allocate big matrix
     GMatrixSparse big(30, 40);
@@ -1297,7 +1296,7 @@ void TestGMatrixSparse::matrix_print(void)
     ref_big.append(" Pending element ...........: (29,39)=68\n");
     ref_big.append(" Number of allocated cells .: 1536\n");
     ref_big.append(" Memory block size .........: 512\n");
-    ref_big.append(" Sparse matrix fill ........: 0.999167\n");
+    ref_big.append(" Sparse matrix fill ........: 0.999166666666667\n");
     ref_big.append(" Pending element ...........: 68\n");
     ref_big.append(" Fill stack size ...........: 0 (none)\n");
     ref_big.append(" 0, 1, 2, 3, 4, 5, 6, ... 33, 34, 35, 36, 37, 38, 39\n");
@@ -1318,8 +1317,7 @@ void TestGMatrixSparse::matrix_print(void)
     // Test the print method
     output = big.print();
-    test_assert((output == ref_big), "Test big matrix printing",
-                "Unexpected print() output:\n"+output+"\nExpected:\n"+ref_big);
+    test_value(output, ref_big);
     // Return
     return;
@@ -95,25 +95,25 @@ TestGSupport* TestGSupport::clone(void) const
 void TestGSupport::test_tools(void)
 {
     // Strip whitespace
-    test_assert(gammalib::strip_whitespace("  World  ") == "World",
-                "gammalib::strip_whitespace(\"  World  \")");
-    test_assert(gammalib::strip_whitespace("World  ") == "World",
-                "gammalib::strip_whitespace(\"World  \")");
-    test_assert(gammalib::strip_whitespace("  World") == "World",
-                "gammalib::strip_whitespace(\"  World\")");
+    test_value(gammalib::strip_whitespace("  World  "), "World");
+    test_value(gammalib::strip_whitespace("World  "), "World");
+    test_value(gammalib::strip_whitespace("  World"), "World");
     // Strip characters
-    test_assert(gammalib::strip_chars("xxWorldyy", "xy") == "World",
-                "gammalib::strip_chars(\"xxWorldyy\")");
-    test_assert(gammalib::strip_chars("Worldxy", "xy") == "World",
-                "gammalib::strip_chars(\"Worldxy\")");
-    test_assert(gammalib::strip_chars("xxWorld", "x") == "World",
-                "gammalib::strip_chars(\"xxWorld\")");
+    test_value(gammalib::strip_chars("xxWorldyy", "xy"), "World");
+    test_value(gammalib::strip_chars("Worldxy", "xy"), "World");
+    test_value(gammalib::strip_chars("xxWorld", "x"), "World");
+
+    // Right strip characters
+    test_value(gammalib::rstrip_chars("xxWorldyy", "xy"), "xxWorld");
+    test_value(gammalib::rstrip_chars("Worldxy", "xy"), "World");
+    test_value(gammalib::rstrip_chars("xxWorld", "x"), "xxWorld");
+    test_value(gammalib::rstrip_chars("0.0012300", "0"), "0.00123");
     // Test noun number conversion
-    test_assert(gammalib::number("World", 0) == "Worlds", "Zero Worlds");
-    test_assert(gammalib::number("World", 1) == "World", "One World");
-    test_assert(gammalib::number("World", 2) == "Worlds", "Two Worlds");
+    test_value(gammalib::number("World", 0), "Worlds");
+    test_value(gammalib::number("World", 1), "World");
+    test_value(gammalib::number("World", 2), "Worlds");
     // Test XML to string conversion
     std::string s_in  = "Hallo World, you \"are\" my 'nice' <planet> & place";
@@ -121,11 +121,9 @@ void TestGSupport::test_tools(void)
                         " &lt;planet&gt; &amp; place";
     std::string s_out;
     s_out = gammalib::str2xml(s_in);
-    test_assert(s_out == s_ref, "gammalib::str2xml()",
-                "Unexpected string \""+s_out+"\" (expected \""+s_ref+"\")");
+    test_value(s_out, s_ref);
     s_out = gammalib::xml2str(s_out);
-    test_assert(s_out == s_in, "gammalib::str2xml()",
-                "Unexpected string \""+s_out+"\" (expected \""+s_in+"\")");
+    test_value(s_out, s_in);
     // Test power law flux computations
     test_value(gammalib::plaw_energy_flux(2.0, 3.0, 2.5, -1.0), 2.5);
 /***************************************************************************
  *                   test_GVector.cpp - Test vector class                  *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2006-2013 by Juergen Knoedlseder                         *
+ *  copyright (C) 2006-2016 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -382,70 +382,121 @@ void TestGVector::arithmetics(void){
                         "|GVector| (vector norm)");
     // min(GVector)
-    test_assert(min(m_test)==1.1,"min(GVector)");
+    test_value(min(m_test), 1.1, 1e-6, "min(GVector)");
     // max(GVector)
-    test_assert(max(m_test)==5.5,"max(GVector)");
+    test_value(max(m_test), 5.5, 1e-6, "max(GVector)");
     // sum(GVector)
-    test_value(m_test[0]+m_test[1]+m_test[2]+m_test[3]+m_test[4],sum(m_test),1e-6,"sum(GVector)");
+    test_value(m_test[0]+m_test[1]+m_test[2]+m_test[3]+m_test[4],
+               sum(m_test), 1e-6, "sum(GVector)");
     // acos(GVector/10.0)
-    test_assert(acos(m_test/10.0).print()=="(1.46057, 1.34898, 1.23449, 1.1152, 0.988432)","acos(GVector/10.0)");
+    GVector test = acos(m_test/10.0);
+    for (int i = 0; i < 5; ++i) {
+        test_value(test[i], std::acos(m_test[i]/10.0));
+    }
     // acosh(GVector)
-    test_assert(acosh(m_test).print()=="(0.443568, 1.42542, 1.86328, 2.16158, 2.38953)","acosh(GVector)");
+    test = acosh(m_test);
+    for (int i = 0; i < 5; ++i) {
+        test_value(test[i], std::acosh(m_test[i]));
+    }
     // asin(GVector/10.0)
-    test_assert(asin(m_test/10.0).print()=="(0.110223, 0.221814, 0.336304, 0.455599, 0.582364)","asin(GVector/10.0)");
+    test = asin(m_test/10.0);
+    for (int i = 0; i < 5; ++i) {
+        test_value(test[i], std::asin(m_test[i]/10.0));
+    }
     // asinh(GVector/10.0)
-    test_assert(asinh(m_test/10.0).print()=="(0.109779, 0.218263, 0.324286, 0.426913, 0.52548)","asinh(GVector/10.0)");
+    test = asinh(m_test/10.0);
+    for (int i = 0; i < 5; ++i) {
+        test_value(test[i], std::asinh(m_test[i]/10.0));
+    }
     // atan(GVector/10.0)
-    test_assert(atan(m_test/10.0).print()=="(0.10956, 0.21655, 0.318748, 0.414507, 0.502843)","atan(GVector/10.0)");
+    test = atan(m_test/10.0);
+    for (int i = 0; i < 5; ++i) {
+        test_value(test[i], std::atan(m_test[i]/10.0));
+    }
     // atanh(GVector/10.0)
-    test_assert(atanh(m_test/10.0).print()=="(0.110447, 0.223656, 0.342828, 0.472231, 0.618381)","atanh(GVector/10.0)");
+    test = atanh(m_test/10.0);
+    for (int i = 0; i < 5; ++i) {
+        test_value(test[i], std::atanh(m_test[i]/10.0));
+    }
     // cos(GVector)
-    test_assert(cos(m_test).print()=="(0.453596, -0.588501, -0.98748, -0.307333, 0.70867)","cos(GVector)");
+    test = cos(m_test);
+    for (int i = 0; i < 5; ++i) {
+        test_value(test[i], std::cos(m_test[i]));
+    }
     // cosh(GVector)
-    test_assert(cosh(m_test).print()=="(1.66852, 4.56791, 13.5748, 40.7316, 122.348)","cosh(GVector)");
+    test = cosh(m_test);
+    for (int i = 0; i < 5; ++i) {
+        test_value(test[i], std::cosh(m_test[i]));
+    }
     // exp(GVector)
-    test_assert(exp(m_test).print()=="(3.00417, 9.02501, 27.1126, 81.4509, 244.692)","exp(GVector)");
+    test = exp(m_test);
+    for (int i = 0; i < 5; ++i) {
+        test_value(test[i], std::exp(m_test[i]));
+    }
     // abs(cos(m_test))
-    test_assert(abs(cos(m_test)).print()=="(0.453596, 0.588501, 0.98748, 0.307333, 0.70867)","abs(cos(m_test))");
+    test = abs(cos(m_test));
+    for (int i = 0; i < 5; ++i) {
+        test_value(test[i], std::abs(std::cos(m_test[i])));
+    }
     // log(GVector)
-    test_assert(log(m_test).print()=="(0.0953102, 0.788457, 1.19392, 1.4816, 1.70475)","log(GVector)");
+    test = log(m_test);
+    for (int i = 0; i < 5; ++i) {
+        test_value(test[i], std::log(m_test[i]));
+    }
     // log10(GVector)
-    test_assert(log10(m_test).print()=="(0.0413927, 0.342423, 0.518514, 0.643453, 0.740363)","log10(GVector)");
+    test = log10(m_test);
+    for (int i = 0; i < 5; ++i) {
+        test_value(test[i], std::log10(m_test[i]));
+    }
     // sin(GVector)
-    test_assert(sin(m_test).print()=="(0.891207, 0.808496, -0.157746, -0.951602, -0.70554)","sin(GVector)");
+    test = sin(m_test);
+    for (int i = 0; i < 5; ++i) {
+        test_value(test[i], std::sin(m_test[i]));
+    }
     // sinh(GVector)
-    test_assert(sinh(m_test).print()=="(1.33565, 4.45711, 13.5379, 40.7193, 122.344)","sinh(GVector)");
+    test = sinh(m_test);
+    for (int i = 0; i < 5; ++i) {
+        test_value(test[i], std::sinh(m_test[i]));
+    }
     // sqrt(GVector)
-    test_assert(sqrt(m_test).print()=="(1.04881, 1.48324, 1.81659, 2.09762, 2.34521)","sqrt(GVector)");
+    test = sqrt(m_test);
+    for (int i = 0; i < 5; ++i) {
+        test_value(test[i], std::sqrt(m_test[i]));
+    }
     // tan(GVector)
-    test_assert(tan(m_test).print()=="(1.96476, -1.37382, 0.159746, 3.09632, -0.995584)","tan(GVector)");
+    test = tan(m_test);
+    for (int i = 0; i < 5; ++i) {
+        test_value(test[i], std::tan(m_test[i]));
+    }
     // tanh(GVector)
-    test_assert(tanh(m_test).print()=="(0.800499, 0.975743, 0.997283, 0.999699, 0.999967)","tanh(GVector)");
+    test = tanh(m_test);
+    for (int i = 0; i < 5; ++i) {
+        test_value(test[i], std::tanh(m_test[i]));
+    }
     // Incompatible size GVector + GVector
     test_try("Incompatible size GVector + GVector:");
     try {
         m_result = m_test + m_bigger;
-
         test_try_failure();
     }
     catch (GException::vector_mismatch &e) {
@@ -459,7 +510,6 @@ void TestGVector::arithmetics(void){
     test_try("cross(a,b) (using 5-dim vectors)");
     try {
         cross(m_test,m_test);
-
         test_try_failure();
     }
     catch (GException::vector_bad_cross_dim &e) {
@@ -473,7 +523,6 @@ void TestGVector::arithmetics(void){
     test_try("cross(a,b) (using vectors with different dimension)");
     try {
         cross(m_test,m_bigger);
-
         test_try_failure();
     }
     catch (GException::vector_mismatch &e) {
@@ -492,7 +541,10 @@ void TestGVector::arithmetics(void){
         test_cross_b[1] = 1.0;
         //Test if cross == (0,0,1)
-        test_assert(cross(test_cross_a, test_cross_b)[0]==0&&cross(test_cross_a, test_cross_b)[1]==0&&cross(test_cross_a, test_cross_b)[2]==1,"Check cross(a,b) value");
+        test_assert(cross(test_cross_a, test_cross_b)[0] == 0 &&
+                    cross(test_cross_a, test_cross_b)[1] == 0 &&
+                    cross(test_cross_a, test_cross_b)[2] == 1,
+                    "Check cross(a,b) value");
         test_try_success();
     }