Come si formatta un valore in virgola mobile in modo che non usi mai la notazione esponenziale né abbia zeri finali?

Question

In base allo ios_base manipulators, ho fondamentalmente la scelta tra defaultfloat e fixed durante la formattazione di numeri in virgola mobile senza notazione esponenziale (con numeri decimali).

Tuttavia, voglio scegliere il maximum precision che produrrebbe un sacco zeri finali per fixed per molti numeri (ad esempio 1.), ma evitare di mai usare la notazione esponente. Se impostato su defaultfloat, sembrerà a destra la maggior parte del del tempo, a meno che il valore sia davvero molto piccolo, ma non lo sia 0.. In questo caso, la rappresentazione predefinita passa alla notazione scientifica da sola, che interrompe il destinatario dell'output formattato (poiché non ha idea di cosa significa 2.22045e-16.

Quindi, come posso avere la mia torta e mangiarla, anche io ? Cioè, non esponente notazione senza zeri trascinamento inutili

---

_{. Nota: non ho testare l'effetto della bandiera defaultfloat, dato che il mio gcc non sembra di attuare tale bandiera (ancora), ma presumo che sia l'impostazione predefinita che si applica senza utilizzare alcun flag. Ho controllato lo fixed, che si comporta come previsto.}

Answer 1

Dal momento non sembra essere un modo corretto per farlo con lo stdlib, ecco il mio wrapper.

template <typename T> 
    struct FpFormat { 
    template <typename Stream> 
    static Stream& setfmt(Stream& str) { 
     return str; 
    } 
    template <typename String> 
    static String const& untrail(String const& str) { 
     return str; 
    } 
    }; 
    template <typename T> 
    struct FpFormatFloats { 
    template <typename Stream> 
    static auto setfmt(Stream& str) -> decltype(str << std::fixed << std::setprecision(std::numeric_limits<T>::digits10)) { 
     return str << std::fixed << std::setprecision(std::numeric_limits<T>::digits10); 
    } 
    template <typename String> 
    static String untrail(String str) { 
     if (str.find('.') == String::npos) 
     return str; 
     return ([](String s){ 
     return String(s.begin(),s.begin()+((s.back() == '.')?(s.size()-1):s.size())); 
     })(str.substr(0,(str+"0").find_last_not_of('0')+1)); 
    } 
    }; 
    template <> struct FpFormat<float> : FpFormatFloats<float> {}; 
    template <> struct FpFormat<double> : FpFormatFloats<double> {}; 
    template <> struct FpFormat<long double> : FpFormatFloats<long double> {}; 

    template <typename T> 
    std::string toString(T x) { 
    std::stringstream str; 
    FpFormat<T>::setfmt(str) << x; 
    return FpFormat<T>::untrail(str.str()); 
    } 

Answer 2

Non esiste una formattazione incorporata che faccia questo per voi. È possibile produrre il proprio formattatore da zero o scriverne uno che elabora la stringa per rimuovere gli zero finali non necessari.

Per esempio si potrebbe fare usando la sostituzione regex:

#include <iomanip> 
#include <iostream> 
#include <sstream> 
#include <regex> 

// not thoroughly tested 
std::string format(double d, int precision = 100) { 
    std::stringstream ss; 
    ss << std::fixed << std::setprecision(precision); 
    ss << d; 

    return std::regex_replace(
     std::regex_replace(ss.str(), std::regex(R"((-?\d*\.\d*?)0*$)"), "$1"), 
     std::regex(R"(\.$)"), ""); 
} 

int main() { 
    std::cout << format(-1) << '\n'; 
    std::cout << format(1e20) << '\n'; 
    std::cout << format(1e-20) << '\n'; 
    std::cout << format(2.22045e-16) << '\n'; 
} 

Pur utilizzando un'espressione regolare non è probabilmente una soluzione particolarmente efficiente.

Answer 3

Un metodo semplice sarebbe qualcosa di simile a questo:

std::string float2string(double f) 
{ 
    std::stringstream ss; 

    ss << std::fixed << std::setprecision(122) << f; // 122 is LARGE, but you may find that really tiny or really large numbers still don't work out... 

    std::string s = ss.str(); 

    std::string::size_type len = s.length(); 

    int zeros = 0; 
    while(len > 1 && s[--len] == '0') 
     zeros++; 
    if (s[len] == '.') // remove final '.' if number ends with '.' 
     zeros++; 
    s.resize(s.length()-zeros); 


    return s; 
} 

ho dato qualche test. Il problema più grande è che dà un enorme numero di decimali per alcuni numeri, e cose del genere 0,05 esce come 0.05000000000000000277555756156289135105907917022705078125 e 0.7 diventa: 0.05000000000000000277555756156289135105907917022705078125

Ecco perché non è un ' "esatta" numero in forma binaria.

Penso che la soluzione sia calcolare approssimativamente quante cifre si desidera nel risultato, prendendo il numero di cifre intere (o di piano (log (f)/log (10) +1)) e quindi sottraendo quel numero da una costante, ad esempio 17, che è il numero di cifre che puoi aspettarti da un doppio. Quindi rimuovere gli zeri in eccesso.

Lascio che per il momento, come ho avuto qualche altre cose da fare che avrei dovuto iniziare un po 'di tempo fa ...;)