Velocità di esecuzione delle funzioni ceil(),round(),floor() - pagina 2

Nuovo commento
 
pavlick_:

Perché non lanci alla lunga? Anche se si può anche traboccare, ma è molto più facile traboccare Int.


Naturalmente, puoi lanciare a lungo se ne hai bisogno.

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

x=3;

y=3; y=4;

 
Nikolai Semko:

Naturalmente, puoi andare lungo se ne hai bisogno.

Quindi stai pubblicizzando un modo, sarà copiato stupidamente. In generale, non si può lanciare così senza controlli, è UB:

Quando un valore finito di tipo floating reale viene convertito in un tipo intero diverso da _Bool, la parte frazionaria viene scartata (cioè, il valore viene troncato verso lo zero). Se il valore della parte integrale non può essere rappresentato dal tipo intero, il comportamento è indefinito.
Forse venderà il deposito, forse farà qualcos'altro ))
 
pavlick_ :

Quindi, se si pubblicizza un modo, verrà copiato senza mezzi termini. Non si può lanciare così senza controllare, è UB:

Forse il deposito si esaurirà, e forse farà qualcos'altro ))).

Non sto pubblicizzando nulla. Sto condividendo un'idea. Ecco a cosa serve questo forum e questa discussione.

 
Dmitry Fedoseev:

x=3;

y=3; y=4;


Giusto! Grazie, dovrò vedere cosa posso fare con il soffitto.

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

Dmitry Fedoseev:

x=3;

y=3; y=4;

come opzione, anche se non molto bella, ma la velocità è la stessa:

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

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

come opzione, anche se non è molto bello, ma la velocità è la stessa:

Allora sarebbe probabilmente meglio: x + 1 - DBL_MIN. Oppure x + 1 -DBL_EPSILON. Nonho controllato, prova.

Oh, e che dire dei numeri negativi? Dovrebbe essere diverso per il soffitto e il pavimento

 
Alexey Navoykov:

Allora sarebbe probabilmente meglio: x + 1 - DBL_MIN. Oppure x + 1 -DBL_EPSILON. Nonho controllato, prova.

Oh, e che dire dei numeri negativi? Deve essere diverso per il soffitto e il pavimento

DBL_MIN eDBL_EPSILON non funzionano - sono troppo piccoli. Forse ha senso lasciarlo a 0,99999999999999999999 (16 nove - il numero massimo di punti decimali nel doppio)

Sì, hai ragione - ci deve essere un algoritmo diverso per i numeri negativi. Grazie! Farò un'aggiunta nel primo post.

Chi è interessato - può pensare a come risolvere il problema con i numeri negativi. Personalmente non sono interessato, poiché tutti i miei problemi sono legati ai numeri positivi.

 
Nikolai Semko:

Probabilmente ha senso lasciare 0,9999999999999999999999 (16 nove - il numero massimo di posti decimali in doppio)

void OnStart()
{
        Print((int)(3.0 + 0.9999999999999999));
}
Avete controllato il risultato?
 

A100:

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


Sì, ma se:

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

allora va bene. Miracoli del compilatore. :))

12345678
Nuovo commento