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

Neuer Kommentar
 
pavlick_:

Warum wirfst du nicht in die Länge? Man kann es zwar auch überlaufen lassen, aber es ist viel einfacher, Int zu überlaufen.


Natürlich können Sie bei Bedarf auch weit werfen.

  
y=ceil(x);  -> y=(int)(x+1);

x=3;

y=3; y=4;

 
Nikolai Semko:

Natürlich können Sie bei Bedarf auch long gehen.

Du machst also Werbung für einen Weg, der dummerweise kopiert werden wird. In der Regel kann man diesen Zauber nicht ohne Kontrolle anwenden, er ist UB:

Wenn ein endlicher Wert vom Typ Real Floating in einen Integer-Typ außer _Bool konvertiert wird, wird der Nachkommaanteil verworfen (d.h. der Wert wird gegen Null abgeschnitten). Wenn der Wert des integralen Teils nicht durch den Ganzzahltyp dargestellt werden kann, ist das Verhalten undefiniert.
Vielleicht verkauft er die Anzahlung, vielleicht macht er etwas anderes ))
 
pavlick_ :

Wenn Sie also für eine Methode werben, wird sie stumpf kopiert werden. Man kann nicht einfach so werfen, ohne nachzusehen, das ist UB:

Vielleicht wird die Kaution ausverkauft, und vielleicht etwas anderes tun ))).

Ich mache keine Werbung für irgendetwas. Ich teile eine Idee. Dafür ist dieses Forum und diese Diskussion gedacht.

 
Dmitry Fedoseev:

x=3;

y=3; y=4;


Richtig! Danke. Ich werde mal sehen, was ich mit der Decke machen kann.

  
y=ceil(x);  -> y=(int)(x+1);

Dmitry Fedoseev:

x=3;

y=3; y=4;

als Option, wenn auch nicht sehr schön, aber die Geschwindigkeit ist die gleiche:

y=ceil(x);  -> y=(int)(x+0.999999999999999);
#define _ceil(x)  (int)((x)+0.999999999999999)

double x=3;
int y=_ceil(x);
 
Nikolai Semko:

als Option, wenn auch nicht sehr schön, aber die Geschwindigkeit ist die gleiche:

Dann wäre es wahrscheinlich besser: x + 1 - DBL_MIN. Oder x + 1 -DBL_EPSILON. Ich habe es nicht überprüft, versuchen Sie es.

Oh, und was ist mit negativen Zahlen? Sie sollte für Decke und Boden unterschiedlich sein

 
Alexey Navoykov:

Dann wäre es wahrscheinlich besser: x + 1 - DBL_MIN. Oder x + 1 -DBL_EPSILON. Ich habe es nicht überprüft, versuchen Sie es.

Oh, und was ist mit negativen Zahlen? Sie muss für Decke und Boden unterschiedlich sein

DBL_MIN undDBL_EPSILON funktionieren nicht - sie sind zu klein. Vielleicht ist es sinnvoll, es bei 0,9999999999999999 zu belassen (16 Neunen - die maximale Anzahl von Dezimalstellen in Double)

Ja, Sie haben Recht - für negative Zahlen muss es einen anderen Algorithmus geben. Ich danke Ihnen! Ich werde im ersten Beitrag eine Ergänzung vornehmen.

Wer Interesse hat, kann sich überlegen, wie man das Problem mit negativen Zahlen lösen kann. Ich persönlich bin daran nicht interessiert, da alle meine Probleme mit positiven Zahlen zu tun haben.

 
Nikolai Semko:

Es ist wahrscheinlich sinnvoll, 0.99999999999999999999 (16 Neunen - die maximale Anzahl von Dezimalstellen in Double) zu belassen.

void OnStart()
{
        Print((int)(3.0 + 0.9999999999999999));
}
Haben Sie das Ergebnis überprüft?
 

A100:

void OnStart()
{
        Print( (int)(3 + 0.9999999999999999));
}


Ja, aber wenn:

x=3;
int Y=(int)ceil(x);
Print(Y);
Y=(int)(x+0.999999999999999);
Print(Y);

dann ist das in Ordnung. Die Wunder des Compilers. :))

12345678
Neuer Kommentar