[hist] Always use maximum floating point precision in GetExpFormula

In #18194, an optional parameter to `TFormula::GetExpFormula()` was
introduced, which can be used to customize the precision when putting
parameters into the jitted code.

However, I don't see the reason why wouldn't like to always print the
floating point numbers with maximum precision, which is suggested in
this commit.

This is achieved using modern C++ functions, which are also not
respecting the users locale setting, but instead use the classic C
locale by default, which is what we need when generating code.

Follows up on #18194 (and its partial revert #18216).

Closes #17225.

Replaces #17327.

Author: guitargeek

hist/hist/inc/TFormula.h

@@ -248,7 +248,7 @@ class TFormula : public TNamed
 #ifdef R__HAS_VECCORE
    ROOT::Double_v EvalParVec(const ROOT::Double_v *x, const Double_t *params = nullptr) const;
 #endif
-   TString        GetExpFormula(Option_t *option = "", const char *fl_format = "%g") const;
+   TString        GetExpFormula(Option_t *option = "") const;
    TString        GetGradientFormula() const;
    TString        GetHessianFormula() const;
    TString        GetUniqueFuncName() const {

hist/hist/src/TFormula.cxx

@@ -23,12 +23,14 @@
 #include "ROOT/StringUtils.hxx"
 
 #include <array>
+#include <functional>
+#include <iomanip>
 #include <iostream>
+#include <limits>
 #include <memory>
-#include <unordered_map>
-#include <functional>
 #include <set>
 #include <sstream>
+#include <unordered_map>
 
 using std::map, std::pair, std::make_pair, std::list, std::max, std::string;
 
@@ -39,6 +41,17 @@ using std::map, std::pair, std::make_pair, std::list, std::max, std::string;
 
 ClassImp(TFormula);
 
+namespace {
+
+std::string doubleToString(double val)
+{
+   std::stringstream ss;
+   ss << std::setprecision(std::numeric_limits<double>::max_digits10) << val;
+   return ss.str();
+}
+
+} // namespace
+
 /** \class TFormula  TFormula.h "inc/TFormula.h"
     \ingroup Hist
     The Formula class
@@ -2341,8 +2354,7 @@ void TFormula::ProcessFormula(TString &formula)
          map<TString, Double_t>::iterator constIt = fConsts.find(fun.GetName());
          if (constIt != fConsts.end()) {
             TString pattern = TString::Format("{%s}", fun.GetName());
-            TString value = TString::Format("%lf", (*constIt).second);
-            formula.ReplaceAll(pattern, value);
+            formula.ReplaceAll(pattern, doubleToString(constIt->second));
             fun.fFound = true;
             // std::cout << "constant with name " << fun.GetName() << " is found " << std::endl;
             continue;
@@ -3606,12 +3618,8 @@ void TFormula::ReInitializeEvalMethod() {
 ///  - If option = "P" replace the parameter names with their values
 ///  - If option = "CLING" return the actual expression used to build the function  passed to cling
 ///  - If option = "CLINGP" replace in the CLING expression the parameter with their values
-///  @param fl_format specifies the printf floating point precision when option
-///  contains "p". Default is `%g` (6 decimals). If you need more precision,
-///  change e.g. to `%.9f`, or `%a` for a lossless representation.
-///  @see https://cplusplus.com/reference/cstdio/printf/
 
-TString TFormula::GetExpFormula(Option_t *option, const char *fl_format) const
+TString TFormula::GetExpFormula(Option_t *option) const
 {
    TString opt(option);
    if (opt.IsNull() || TestBit(TFormula::kLambda) ) return fFormula;
@@ -3647,9 +3655,10 @@ TString TFormula::GetExpFormula(Option_t *option, const char *fl_format) const
             TString parNumbName = clingFormula(i+2,j-i-2);
             int parNumber = parNumbName.Atoi();
             assert(parNumber < fNpar);
-            TString replacement = TString::Format(fl_format, GetParameter(parNumber));
-            clingFormula.Replace(i,j-i+1, replacement );
-            i += replacement.Length();
+            std::stringstream ss;
+            std::string replacement = doubleToString(GetParameter(parNumber));
+            clingFormula.Replace(i,j-i+1, replacement);
+            i += replacement.size();
          }
          i++;
       }
@@ -3669,9 +3678,10 @@ TString TFormula::GetExpFormula(Option_t *option, const char *fl_format) const
                return expFormula;
             }
             TString parName = expFormula(i+1,j-i-1);
-            TString replacement = TString::Format(fl_format, GetParameter(parName));
-            expFormula.Replace(i,j-i+1, replacement );
-            i += replacement.Length();
+            std::stringstream ss;
+            std::string replacement = doubleToString(GetParameter(parName));
+            expFormula.Replace(i,j-i+1, replacement);
+            i += replacement.size();
          }
          i++;
       }

test/TFormulaParsingTests.h

@@ -308,7 +308,7 @@ bool test16()  {
    // test GetExpFormula
    TFormula f("f","[2] + [0]*x + [1]*x*x");
    f.SetParameters(1,2,3);
-   return (f.GetExpFormula("CLING P", "%f") == TString("3.000000+1.000000*x[0]+2.000000*x[0]*x[0] "));
+   return (f.GetExpFormula("CLING P") == TString("3+1*x[0]+2*x[0]*x[0] "));
 }
 
 bool test17() {