Geschwindigkeit der Ausführung der Funktionen ceil(),round(),floor() - Seite 3

Neuer Kommentar
 
Nikolai Semko:

Ja, aber wenn:

dann ist das in Ordnung.

Es bleibt zu prüfen, ob es für jede beliebige Zahl x OK ist
 

A100:

void OnStart()
{
        Print( (int)(3.0001 + 0.999999999999999)); //все равно 4
        Print( floor(3.00001));                    //3
}




Das verstehe ich nicht. Wo liegt das Problem?

 
A100:
Es bleibt abzuwarten, ob es für eine beliebige Zahl x OK ist

Natürlich wird es das nicht...

Denn wenn das passiert:

double x=3;
x=x+0.1;
x=x+0.1;
x=x+0.1;
x=x+0.1;
if (x!=3.4) Print("oppps..."); // oppps...

dann sind die Fragen weder für mich noch für diese Idee.

 
Nikolai Semko:
Wo liegt das Problem?
void OnStart()
{
        double d =  16 + 0.999999999999999;
        Print( (int)(d + 0.999999999999999)); //18
        Print( (int)ceil( d ));               //17
}
 
A100:

siehe meinen vorherigen Beitrag

 
Nikolai Semko:
dann sind die Fragen weder für mich, noch für diese Idee.
floor(), ceil(), round() sind dazu da, Fragen zu vermeiden
 

Ich denke, dass all diese Fehler über den praktischen Nutzen dieser Lösung zur Beschleunigung der Rundung positiver ganzer Zahlen hinausgehen, da nur wenige Menschen eine Genauigkeit auf 16-stelliger Ebene benötigen. Und diese Fehler entstehen durch alle Arten von Überläufen auf den Punktebenen des Compilers selbst.

 
A100:
Floor(), ceil(), round() sind für diesen Zweck da - es gibt also keine Fragen

Ich verbiete Ihnen nicht, sie zu benutzen. Sie können sie gerne verwenden. Ich werde sie selbst verwenden. Wenn ich jedoch einen Algorithmus entwickle, bei dem es auf Geschwindigkeit ankommt, werde ich diese Rundungsvariante verwenden und dabei alle Nuancen dieser Methode berücksichtigen. Ich denke, es wäre für andere Programmierer nützlich, von der Existenz dieser Alternative zu erfahren. Die Diskussion ist genau das, was wir über die Feinheiten dieser Rundungsmethode wissen müssen. Ich danke Ihnen sehr dafür. Habe ich nicht Recht?

 
Nikolai Semko:

DBL_MIN undDBL_EPSILON funktionieren nicht - zu klein. Vielleicht ist es sinnvoll, 0,999999999999999999 (16 Neunen - die maximale Anzahl der Nachkommastellen in Double) zu belassen.

DBL_EPSILON hat also 16 Dezimalstellen:2,2204460492503131e-016.

In Ihrem Fall erhalten Sie tatsächlich eine, da der Unterschied nur 1e-16 beträgt, was 2 Mal weniger als Epsilon ist.

 
Alexey Navoykov:

DBL_EPSILON hat also 16 Dezimalstellen:2.2204460492503131e-016

Und in Ihrem Fall erhalten Sie tatsächlich eine, da der Unterschied nur 1e-16 beträgt, was 2 Mal weniger als Epsilon ist.


Ja, das verstehe ich, aber es funktioniert nicht. Es hat sich herausgestellt, dass es auch mit 16 Neunen nicht funktioniert (seltsam, vorher schien es zu funktionieren). Es funktioniert nur mit 15 Neunen.

double x=3;
int Y=(int)ceil(x);
Print(Y);                         // 3
Y=(int)(x+0.999999999999999); 
Print(Y);                         // 3  (15 9-ток)
Y=(int)(x+0.9999999999999999);
Print(Y);                         // 4  (16 9-ток)
Y=(int)(x+1-DBL_EPSILON);
Print(Y);                         // 4
12345678
Neuer Kommentar