¿Por qué floor() es tan lento?

Si vas a convertir el resultado de la operación floor() a un int, y si no te preocupa el desbordamiento, entonces el siguiente código es mucho más rápido que (int)floor(x):

inline int int_floor(double x)
{
  int i = (int)x; /* truncate */
  return i - ( i > x ); /* convert trunc to floor */
}

Piso y techo sin ramas (mejor utilizar la pipilina) sin comprobación de error

int f(double x)
{
    return (int) x - (x < (int) x); // as dgobbi above, needs less than for floor
}

int c(double x)
{
    return (int) x + (x > (int) x);
}

O utilizando el suelo

int c(double x)
{
    return -(f(-x));
}

Sí, floor() es extremadamente lento en todas las plataformas, ya que tiene que implementar una gran cantidad de comportamiento de la especificación fp de IEEE. Realmente no se puede usar en bucles internos.

A veces uso una macro para aproximar floor ():

#define PSEUDO_FLOOR( V ) ((V) >= 0 ? (int)(V) : (int)((V) - 1))

No se comporta exactamente como floor(): por ejemplo, floor(-1) == -1 pero PSEUDO_FLOOR(-1) == -2, pero es lo suficientemente cerca para la mayoría de los usos.

1. No hacen lo mismo. floor() es una función. Por lo tanto, usarlo incurre en una llamada a función, asignando un marco de pila, copiando parámetros y recuperando el resultado. Casting no es una llamada a una función, por lo que utiliza mecanismos más rápidos (creo que puede usar registros para procesar los valores).
2. Probablemente floor() ya está optimizado.
3. ¿Puedes exprimir más rendimiento de tu algoritmo? Tal vez cambiar filas y columnas puede ayudar? ¿Puede almacenar valores comunes en caché? ¿Están activadas todas las optimizaciones de su compilador? ¿Puedes cambiar un sistema operativo? un compilador? Perlas de programación de Jon Bentley tiene una gran revisión de posibles optimizaciones.

Ronda doble rápida

double round(double x)
{
    return double((x>=0.5)?(int(x)+1):int(x));
}

Registro de terminal

Prueba custom_1 8.3837

Test native_1 18.4989

Prueba custom_2 8.36333

Test native_2 18.5001

Prueba custom_3 8.37316

Test native_3 18.5012

Prueba

void test(char* name, double (*f)(double))
{
    int it = std::numeric_limits<int>::max();

    clock_t begin = clock();

    for(int i=0; i<it; i++)
    {
        f(double(i)/1000.0);
    }
    clock_t end = clock();

    cout << "test " << name << " " << double(end - begin) / CLOCKS_PER_SEC << endl;

}

int main(int argc, char **argv)
{

    test("custom_1",round);
    test("native_1",std::round);
    test("custom_2",round);
    test("native_2",std::round);
    test("custom_3",round);
    test("native_3",std::round);
    return 0;
}

Resultado

El tipo de fundición y el uso de su cerebro es ~3 veces más rápido que el uso de funciones nativas.