[RF] Rewrite variable printing with std::stringstream

This ensures that RooFit printouts will be independent of the locale
setting.

Here is my little script to test this:

```Python
import locale

def check_numeric_locale():

    locale.setlocale(locale.LC_ALL, "")

    # Get the active numeric locale
    current = locale.setlocale(locale.LC_NUMERIC)
    print(f"Active LC_NUMERIC: {current}")

    # Format a floating point number according to this locale
    number = 12345.67
    formatted = locale.format_string("%.2f", number, grouping=True)
    print(f"Formatted number: {formatted}")

    # Show what decimal point is being used
    conv = locale.localeconv()
    print(f"Decimal point: {conv['decimal_point']}")
    print(f"Thousands separator: {conv['thousands_sep']}")

if __name__ == "__main__":
    check_numeric_locale()

    import ROOT

    print(ROOT.std.stod("3.33"))

    x = ROOT.RooRealVar("x", "x", 3.12, -10., 10.)
    x.setError(1.23)

    print(x.format(4, ""))

    ROOT.RooRealVar.printScientific(True)

    x.writeToStream(ROOT.std.cout, False)

    x.writeToStream(ROOT.std.cout, True)
```

Author: guitargeek

roofit/histfactory/src/HistoToWorkspaceFactoryFast.cxx

@@ -68,6 +68,8 @@
 #include "RooStats/HistFactory/HistFactoryException.h"
 
 #include <algorithm>
+#include <fstream>
+#include <iomanip>
 #include <memory>
 #include <utility>
 
@@ -694,26 +696,28 @@ RooArgList HistoToWorkspaceFactoryFast::createObservables(const TH1 *hist, RooWo
 
   void HistoToWorkspaceFactoryFast::PrintCovarianceMatrix(RooFitResult* result, RooArgSet* params, string filename){
 
-    FILE* covFile = fopen ((filename).c_str(),"w");
-    fprintf(covFile," ") ;
+    std::ofstream covFile(filename);
+
+    covFile << " ";
     for (auto const *myargi : static_range_cast<RooRealVar *>(*params)) {
       if(myargi->isConstant()) continue;
-      fprintf(covFile," & %s",  myargi->GetName());
+      covFile << " & " << myargi->GetName();
     }
-    fprintf(covFile,"\\\\ \\hline \n" );
+    covFile << "\\\\ \\hline \n";
     for (auto const *myargi : static_range_cast<RooRealVar *>(*params)) {
       if(myargi->isConstant()) continue;
-      fprintf(covFile,"%s", myargi->GetName());
+      covFile << myargi->GetName();
       for (auto const *myargj : static_range_cast<RooRealVar *>(*params)) {
         if(myargj->isConstant()) continue;
         std::cout << myargi->GetName() << "," << myargj->GetName();
-        fprintf(covFile, " & %.2f", result->correlation(*myargi, *myargj));
+        double corr = result->correlation(*myargi, *myargj);
+        covFile << " & " << std::fixed << std::setprecision(2) << corr;
       }
       std::cout << std::endl;
-      fprintf(covFile, " \\\\\n");
+      covFile << " \\\\\n";
     }
-    fclose(covFile);
 
+    covFile.close();
   }
 
 

roofit/roofitcore/inc/RooRealVar.h

@@ -147,8 +147,6 @@ class RooRealVar : public RooAbsRealLValue {
   void attachToVStore(RooVectorDataStore& vstore) override ;
   void fillTreeBranch(TTree& t) override ;
 
-  double chopAt(double what, Int_t where) const ;
-
   double _error;      ///< Symmetric error associated with current value
   double _asymErrLo ; ///< Low side of asymmetric error associated with current value
   double _asymErrHi ; ///< High side of asymmetric error associated with current value

roofit/roofitcore/src/RooRealVar.cxx

@@ -44,7 +44,8 @@ or integrals to sub ranges. The range without any name is used as default range.
 #include "TTree.h"
 #include "TBuffer.h"
 #include "TBranch.h"
-#include "snprintf.h"
+
+#include <iomanip>
 
 using std::endl, std::ostream, std::istream;
 
@@ -753,63 +754,63 @@ bool RooRealVar::readFromStream(istream& is, bool compact, bool verbose)
 ////////////////////////////////////////////////////////////////////////////////
 /// Write object contents to given stream
 
-void RooRealVar::writeToStream(ostream& os, bool compact) const
+void RooRealVar::writeToStream(ostream &os, bool compact) const
 {
-  if (compact) {
-    // Write value only
-    os << getVal() ;
-  } else {
+   if (compact) {
+      // Write value only
+      os << getVal();
+      return;
+   }
+
+   // Write value with error (if not zero)
+   if (_printScientific) {
+      std::stringstream text;
 
-    // Write value with error (if not zero)
-    if (_printScientific) {
-      char fmtVal[16];
-      char fmtErr[16];
-      snprintf(fmtVal,16,"%%.%de",_printSigDigits) ;
-      snprintf(fmtErr,16,"%%.%de",(_printSigDigits+1)/2) ;
-      if (_value>=0) os << " " ;
-      os << Form(fmtVal,_value) ;
+      int nDigitsVal = _printSigDigits;
+      int nDigitsErr = (_printSigDigits + 1) / 2;
 
+      text << std::scientific;
+
+      if (_value >= 0)
+         text << " ";
+      text << std::setprecision(nDigitsVal) << _value;
+
+      text << std::setprecision(nDigitsErr) << " +/- ";
       if (hasAsymError()) {
-   os << " +/- (" << Form(fmtErr,getAsymErrorLo())
-      << ", " << Form(fmtErr,getAsymErrorHi()) << ")" ;
-      } else  if (hasError()) {
-   os << " +/- " << Form(fmtErr,getError()) ;
+         text << "(" << getAsymErrorLo() << ", " << getAsymErrorHi() << ")";
+      } else if (hasError()) {
+         text << getError();
       }
 
-      os << " " ;
-    } else {
-      os << format(_printSigDigits,"EFA") << " " ;
-    }
+      os << text.str() << " ";
+   } else {
+      os << format(_printSigDigits, "EFA") << " ";
+   }
 
-    // Append limits if not constants
-    if (isConstant()) {
-      os << "C " ;
-    }
+   // Append limits if not constants
+   if (isConstant()) {
+      os << "C ";
+   }
 
-    // Append fit limits
-    os << "L(" ;
-    if(hasMin()) {
-      os << getMin();
-    }
-    else {
-      os << "-INF";
-    }
-    if(hasMax()) {
-      os << " - " << getMax() ;
-    }
-    else {
-      os << " - +INF";
-    }
-    os << ") " ;
+   // Append fit limits
+   if (hasMin()) {
+      os << "L(" << getMin();
+   } else {
+      os << "L(-INF";
+   }
+   if (hasMax()) {
+      os << " - " << getMax() << ") ";
+   } else {
+      os << " - +INF) ";
+   }
 
-    if (getBins()!=100) {
-      os << "B(" << getBins() << ") " ;
-    }
+   if (getBins() != 100) {
+      os << "B(" << getBins() << ") ";
+   }
 
-    // Add comment with unit, if unit exists
-    if (!_unit.IsNull())
-      os << "// [" << getUnit() << "]" ;
-  }
+   // Add comment with unit, if unit exists
+   if (!_unit.IsNull())
+      os << "// [" << getUnit() << "]";
 }
 
 
@@ -1010,107 +1011,71 @@ std::string RooRealVar::format(Int_t sigDigits, const char *options) const
   Int_t leadingDigitErr= (Int_t)floor(log10(std::abs(_error+1e-10)));
   Int_t whereVal= leadingDigitVal - sigDigits + 1;
   Int_t whereErr= leadingDigitErr - sigDigits + 1;
-  char fmtVal[16];
-  char fmtErr[16];
 
   if (_value<0) whereVal -= 1 ;
-  snprintf(fmtVal,16,"%%.%df", whereVal < 0 ? -whereVal : 0);
-  snprintf(fmtErr,16,"%%.%df", whereErr < 0 ? -whereErr : 0);
-  std::string text;
-  if(latexMode) text += "$";
+  int nDigitsVal = whereVal < 0 ? -whereVal : 0;
+  int nDigitsErr = whereErr < 0 ? -whereErr : 0;
+
+  std::stringstream text;
+
+  if(latexMode) text << "$";
   // begin the string with "<name> = " if requested
   if(showName || showTitle) {
     if (latexTableMode && latexVerbatimName) {
-      text += "\\verb+";
+      text << "\\verb+";
     }
-    text += label;
-    if (latexVerbatimName) text += "+";
+    text << label;
+    if (latexVerbatimName) text << "+";
 
     if (!latexTableMode) {
-      text += " = ";
+      text << " = ";
     } else {
-      text += " $ & $ ";
+      text << " $ & $ ";
     }
   }
 
   // Add leading space if value is positive
-  if (_value>=0) text += " ";
+  if (_value>=0) text << " ";
 
   // append our value if requested
-  char buffer[256];
+  text << std::fixed;
   if(!hideValue) {
-    chopAt(_value, whereVal);
-    snprintf(buffer, 256,fmtVal, _value);
-    text += buffer;
+    text << std::setprecision(nDigitsVal) << _value;
   }
+  text << std::setprecision(nDigitsErr); // we only print errors from now on
 
   // append our error if requested and this variable is not constant
   if(hasError(false) && showError && !(asymError && hasAsymError(false))) {
     if(tlatexMode) {
-      text += " #pm ";
+      text << " #pm " << getError();
     }
     else {
-      text += latexMode ? "\\pm " : " +/- ";
+      text << (latexMode ? "\\pm " : " +/- ") << getError();
     }
-    snprintf(buffer, 256,fmtErr, getError());
-    text += buffer;
   }
 
   if (asymError && hasAsymError() && showError) {
     if(tlatexMode) {
-      text += " #pm _{";
-      snprintf(buffer, 256,fmtErr, getAsymErrorLo());
-      text += buffer;
-      text += "}^{+";
-      snprintf(buffer, 256,fmtErr, getAsymErrorHi());
-      text += buffer;
-      text += "}";
+      text << " #pm _{" << getAsymErrorLo() << "}^{+" << getAsymErrorHi() << "}";
     }
     else if(latexMode) {
-      text += "\\pm _{";
-      snprintf(buffer, 256,fmtErr, getAsymErrorLo());
-      text += buffer;
-      text += "}^{+";
-      snprintf(buffer, 256,fmtErr, getAsymErrorHi());
-      text += buffer;
-      text += "}";
+      text << "\\pm _{" << getAsymErrorLo() << "}^{+" << getAsymErrorHi() << "}";
     }
     else {
-      text += " +/-  (";
-      snprintf(buffer, 256, fmtErr, getAsymErrorLo());
-      text += buffer;
-      text += ", ";
-      snprintf(buffer, 256, fmtErr, getAsymErrorHi());
-      text += buffer;
-      text += ")";
+      text << " +/-  (" << getAsymErrorLo() << ", " << getAsymErrorHi() << ")";
     }
 
   }
 
   // append our units if requested
   if(!_unit.IsNull() && showUnit) {
-    text += ' ';
-    text += _unit;
+    text << ' ' << _unit;
   }
-  if(latexMode) text += "$";
-  return text;
+  if(latexMode) text << "$";
+  return text.str();
 }
 
 
-
-////////////////////////////////////////////////////////////////////////////////
-/// Utility to calculate number of decimals to show
-/// based on magnitude of error
-
-double RooRealVar::chopAt(double what, Int_t where) const
-{
-  double scale= pow(10.0,where);
-  Int_t trunc= (Int_t)floor(what/scale + 0.5);
-  return (double)trunc*scale;
-}
-
-
-
 ////////////////////////////////////////////////////////////////////////////////
 /// Overload RooAbsReal::attachToTree to also attach
 /// branches for errors  and/or asymmetric errors