Velocidade de execução das funções ceil(),round(),floor() - página 2

Novo comentário
 
pavlick_:

Por que você não se lança ao longo do tempo? Embora você também possa transbordar, mas é muito mais fácil de transbordar Int.


É claro, você pode jogar por muito tempo, se necessário.

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

x=3;

y=3; y=4;

 
Nikolai Semko:

É claro que você pode demorar muito, se for necessário.

Então você está fazendo propaganda de uma maneira, ela será copiada estupidamente. Geralmente, não se pode lançar assim sem nenhum cheque, é a UB:

Quando um valor finito do tipo flutuante real é convertido em um tipo inteiro diferente de _Bool, a parte fracionada é descartada (ou seja, o valor é truncado em direção a zero). Se o valor da parte integral não puder ser representado pelo tipo inteiro, o comportamento é indefinido.
Talvez ele venda o depósito, talvez ele faça outra coisa))
 
pavlick_ :

Portanto, você está anunciando de uma maneira, será copiado sem rodeios. Não se pode lançar assim sem verificar, é a UB:

Talvez o depósito se venda, e talvez faça algo mais ))))).

Não estou fazendo propaganda de nada. Estou compartilhando uma idéia. É para isso que serve este fórum e discussão.

 
Dmitry Fedoseev:

x=3;

y=3; y=4;


Certo! obrigado. Vou ter que ver o que posso fazer em relação ao teto.

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

Dmitry Fedoseev:

x=3;

y=3; y=4;

como uma opção, embora não muito bonita, mas a velocidade é a mesma:

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

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

como uma opção, embora não muito agradável, mas a velocidade é a mesma:

Então provavelmente seria melhor: x + 1 - DBL_MIN. Ou x + 1 -DBL_EPSILON. Ainda não verifiquei,experimentei.

Oh, e quanto aos números negativos? Deve ser diferente para o teto e o piso

 
Alexey Navoykov:

Então provavelmente seria melhor: x + 1 - DBL_MIN. Ou x + 1 -DBL_EPSILON. Ainda não verifiquei,experimentei.

Oh, e quanto aos números negativos? Deve ser diferente para o teto e o piso

DBL_MIN eDBL_EPSILON não funcionam - eles são muito pequenos. Talvez faça sentido deixá-lo em 0,999999999999999999 (16 noves - o número máximo de pontos decimais em dobro)

Sim, você está certo - deve haver um algoritmo diferente para números negativos. Obrigado! Farei um acréscimo no primeiro posto.

Quem está interessado - pode pensar em como resolver o problema com números negativos. Eu pessoalmente não estou interessado, pois todos os meus problemas estão relacionados a números positivos.

 
Nikolai Semko:

Provavelmente faz sentido deixar 0,99999999999999999999 (16 noves - o número máximo de casas decimais em dobro)

void OnStart()
{
        Print((int)(3.0 + 0.9999999999999999));
}
Você verificou o resultado?
 

A100:

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


Sim, mas se:

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

então está tudo bem. Milagres do compilador. :))

12345678
Novo comentário