Was sind die tatsächlichen min/max-Werte für float und double (C++)

Habe ich gelesen, die Empfehlungen zur Nutzung der "FLT_MIN" und "FLT_MAX" Werte für float. Immer wenn ich dies tun, codeblocks sagt mir seine

max: 3.40282 e+038
min: 1.17549 e-038

Nicht zu wissen, was damit gemeint ist ich habe versucht, um echte Werte und bekam

max: 47.2498237715
min: -34.8045265148

... aber auch diese nicht klären Dinge.

Hier ist ein snippet aus meinem code

   char c;         //reserve: 1 byte, store 1 character (-128 to 127)
   int i;          //reserve: 4 bytes, store -2147483648 to 2147483657
   short int s;    //reserve: 2 bytes, store -32768 to 32767
   float f;        //reserve: 4 bytes, store ?? - ?? (? digits)
   double d;       //reserve: 8 bytes, store ?? - ?? (? digits)
   unsigned int u; //reserve: r bytes store 0 to 4294967295

   c = 'c';
   cout << c <<" lives at " << &c <<endl;

   i = 40000;
   cout << i <<" lives at " << &i <<endl;

   s = 100;
   cout << s <<" lives at " << &s <<endl;

   f = 10.1;
   cout << f <<" lives at " << &f <<endl;

   d = 10.102;
   cout << d <<" lives at " << &d <<endl;

   u = 1723;
   cout << u <<" lives at " << &u <<endl;

In der snippet-wir können deutlich sehen, die min-max-Werte ein short-int-zum Beispiel bei -32768 - 32767. Dies sind die richtigen Werte verständlich, aber für float und int, die realen Werte nicht klar sind.

  • en.cppreference.com/w/cpp/types/numeric_limits
  • en.cppreference.com/w/cpp/types/numeric_limits
  • 10s ninja 😀 Aber ich bin nur ein ole-Mann, ya know 😉
  • Eine Frage pro Frage bitte. Siehe stellen.
  • ich verstehe nicht die Frage. seine Fragen, wie "was ist der Sinn des 42?". Die zahlen, die Sie erhalten, sind die min/max-Ergebnis von FLT_MIN/MAX...
  • Wenn Sie möchten, entfernen Sie die wissenschaftliche notation, verwenden Sie das std::fixed manipulator um den Wert zu sehen, in normaler notation.
  • Ich wieder dieses da, es war falsch gekennzeichnet als ein Duplikat einer Frage nicht eingeht, wie man die minima. Besonders für floating-point -, immer die minima unterscheidet sich von erste die Höchstwerte seit Unterscheidungen sind für die wenigsten Größenordnung normalen Wert, die wenigsten positiven Wert, mindestens endlichen Wert, und am wenigsten Wert, die von denen Verschieden sind, die in IEEE-754.
  • Dennoch, die Frage, die geteilt werden soll, indem Sie die numerischen Grenzen Fragen, die von der Adresse Fragen.

InformationsquelleAutor user9318444 | 2018-02-05
  1. 3

    Den std::numerics_limits Klasse in der <limits> - header liefert Informationen über die Eigenschaften von numerischen Typen.

    Für eine floating-point-Typ T, sind hier die größten und am wenigsten Werte darstellbar in der Art, in verschiedenem Sinne des "größten" und "geringsten." Außerdem habe ich die Werte für die gängigen IEEE 754 64-bit-Binär-Typ, das heißt double in dieser Antwort. Diese sind in absteigender Reihenfolge:

    • std::numeric_limits<T>::infinity() ist die größte Darstellbare Wert, wenn T unterstützt die Unendlichkeit. Es ist natürlich unendlich. Ob der Typ T unterstützt infinity ist gekennzeichnet durch std::numeric_limits<T>::has_infinity.

    • std::numeric_limits<T>::max() ist die größte endlichen Wert. Für double, das ist 21024-2971, etwa 1.79769•10308.

    • std::numeric_limits<T>::min() ist die kleinste positive normale Wert. Floating-point-Formate haben oft ein Intervall, in denen die Exponenten nicht kleiner werden, aber die Mantisse (fraction Teil der Reihe) darf kleiner werden, bis es null erreicht. Geht dies zu Lasten der Präzision, aber hat einige wünschenswerte mathematische-computing-Eigenschaften. min() ist der Punkt, wo diese Präzision Verlust beginnt. Für double, das ist 2-1022, etwa 2.22507•10-308.

    • std::numeric_limits<T>::denorm_min() ist der kleinste positive Wert. In der Art, die minderbegabt sind Werte, es ist subnormal. Ansonsten, es ist gleich std::numeric_limits<T>::min(). Für double, das ist 2-1074, etwa 4.94066•10-324.

    • std::numeric_limits<T>::lowest() ist der am wenigsten endlichen Wert. Es ist in der Regel eine negative Zahl ist groß in der Größe. Für double ist dies −(21024-2971), etwa -1.79769•10308.

    • Wenn std::numeric_limits<T>::has_infinity und std::numeric_limits<T>::is_signed wahr sind, dann -std::numeric_limits<T>::infinity() ist die am wenigsten Wert. Es ist, natürlich, negativ unendlich.

    Einem anderen Merkmal können Sie daran interessiert, ist:

    • std::numeric_limits<T>::digits10 ist die größte Anzahl von Dezimalstellen, so dass bei der Umwandlung dezimal-Zahl mit so vielen stellen zu T und wandelt dann zurück zu der gleichen Anzahl von Dezimalstellen wird der Ertrag der ursprünglichen Anzahl. Für double dies ist der 15.
    InformationsquelleAutor Eric Postpischil
  2. 4

    Es ist alles zu finden in numeric_limits.

    Aber VORSICHT

    Aus irgendeinem Grund mir unbekannt, std::numeric_limits<float>:min() nicht zurück die Mindest-float. Stattdessen gibt es die kleinste positive float dargestellt wird in normalisierter form. Um die minimum, Einsatz std::numeric_limits<float>::lowest(). Ich mache keine Witze. Ebenso für andere floating-point-Typen, d.h. double und long double.

    http://en.cppreference.com/w/cpp/types/numeric_limits

    • gerade diese, und es ist seltsam,
    InformationsquelleAutor Jive Dadson
  3. 2

    In Ordnung. Mit dem, was ich gelernt habe von hier (danke an alle) und den anderen teilen der Website, die ich schrieb nette kleine Zusammenfassung von den beiden nur sofern ich Laufe in ein anderes Thema wie dieses.

    In C++ gibt es zwei Möglichkeiten zum darstellen/speichern von Dezimalzahlen.

    Floats und Doubles

    Einem float speichern von Werten von:

    • -340282346638528859811704183484516925440.0000000000000000 Float niedrigsten
    • 340282346638528859811704183484516925440.0000000000000000 Float max

    Ein Doppel speichern von Werten von:

    • -179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.0000000000000000 Doppel niedrigsten

    • 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.0000000000000000 Double max

    Float-Präzision ermöglicht es, um einen Wert zu speichern von bis zu 9 Ziffern (7 echten Ziffern, +2 von dezimal zu Binär-Konvertierung)

    Double, wie der name schon sagt, speichern können Sie doppelt so viel presciosn Arsch ein float. Es können bis zu 17 Ziffern. (15 real Ziffern, +2 von dezimal zu Binär-Konvertierung)

    z.B. 

         float x = 1.426;
     double y = 8.739437;

    Decimals & Math

    Durch ein float ausführen zu können, 7 real Dezimalstellen, und doppelklicken Sie in der Lage zu tragen 15 real Dezimalstellen, die bei der Durchführung caluclations, die drucken Sie aus, eine richtige Methode benutzt werden muss.

    e.g

    gehören 

    typedef std::numeric_limits<double> dbl; 
cout.precision(dbl::max_digits10-2); //sets the precision to the *proper* amount of digits.
cout << dbl::max_digits10 <<endl; //prints 17.
double x = 12345678.312; 
double a = 12345678.244; 
//these calculations won't perform correctly be printed correctly without setting the precision.


cout << endl << x+a <<endl;

    Beispiel 2:

    typedef std::numeric_limits< float> flt;
cout.precision(flt::max_digits10-2);
cout << flt::max_digits10 <<endl;
float x =  54.122111;
float a =  11.323111;

cout << endl << x+a <<endl; /* without setting precison this outputs a different value, as well as making sure we're *limited* to 7 digits. If we were to enter another digit before the decimal point, the digits on the right would be one less, as there can only be 7. Doubles work in the same way */

    Etwa wie genau ist diese Beschreibung? Kann es sein verwendet als standard, wenn condused?

    InformationsquelleAutor user9318444
  4. 0

    In C++ können Sie die std::numeric_limits Klasse, um diese Art von Informationen.

    Wenn has_infinity ist true (die wird es im Prinzip für jede Plattform heutzutage), dann können Sie - infinity, um den Wert, die größer ist als oder gleich zu allen anderen Werten (außer NaNs). Ihre negation ergeben eine negative Unendlichkeit, und weniger als oder gleich zu allen anderen Werten (außer NaNs wieder).

    Wenn Sie möchten, endliche Werte haben, dann können Sie max, die größer als oder gleich zu allen anderen endlichen Werte, und niedrigste, das ist weniger als oder gleich zu allen anderen endlichen Werte.

    Etwas verwirrend, min tatsächlich gibt Ihnen die kleinste positive normalisierte Wert, der ist völlig out of sync mit dem, was es gibt mit der integer-Typen (danke @JiveDadson für den Hinweis).

    • Ich nicht vollständig verstehen. Mit FLT_MANT_DIG (wie viele stellen können, speichern wir in einer float) du erhältst 24, allerdings ist die nicht möglich, diese vielen zahlen. Auch, wenn floats und doubles sind unendlich, bedeutet dies, können wir speichern, wie große Werte, wie wir wollen, im inneren schwimmt? und bei std::numeric_limits::min() gibt 0.000000 - diese dosen;t Sinn machen
    • Es bezieht sich auf die Anzahl der Ziffern in die Formate radix, was in diesem Fall 2. (d.h. gibt es 24 bits in der Mantisse eines binary32 Anzahl)
    • Leider, `std::numeric_limits<T>::min()' bedeutet nicht das, was Sie denken, es ist für floating-point-T. habe ich sogar erwischt, die STL von VC++ Missbrauch.
    • So wie ich herausgefunden habe, wie viele Ziffern in float/double? und die min - /max-Wert speichern in einem?
    • Danke @JiveDadson! Ich habe ganz vergessen das versaut Verhalten.
    • Für die Dezimalstellen, die Sie wollen, digits10

    InformationsquelleAutor Simon Byrne
Schreibe einen Kommentar