¿Es seguro multiplicar un flotante/doble por 0.5 en lugar de dividir por 2 en C# y C++?

Question

Básicamente para cosas como esta (no código real):

for(int i = 0; i < 1000000000; ++i) 
{ 
    Vert v0 = mesh.polygons[i].edges[0].vert0; 
    Vert v1 = mesh.polygons[i].edges[0].vert1; 

    Vector3 center = (v0.pos + v1.pos)/2; 
} 

v0.pos es de tipo Vector3<float, float, float>, pero podría ser Vector3<double, double, double>.

¿Es seguro acaba de hacer ?:

Vector3 center = (v0.pos + v1.pos) * 0.5; 

Esto podría parecer como la optimización prematura, pero esto tiene que ser lo más rápido posible que se pidió a los mil millones de puntos (nube de puntos).

Answer 1

No es un C++ experto, por cualquier medio, pero en C#, hacer esto:

var a = new Func<float, float, double>((float f1, float f2) => (f1 + f2) * 0.5); 
var b = new Func<float, float, double>((float f1, float f2) => (f1 + f2)/2); 

genera IL que en los anteriores:

1. Carga los argumentos
2. los añade (produciendo una single)
3. Convierte el resultado en un doble
4. Carga el doble argumento (0.5)
5. Multiplica (produciendo un doble)
6. devuelve el resultado

y el segundo

1. Carga los argumentos
2. los añade (produciendo un solo)
3. Carga el número entero constante (2)
4. Divide (produciendo una sola, porque single/integer produce una sola)
5. convierte el resultado a un doble
6. devuelve el resultado

se me ocurre que el primero será probable es que tenga una mayor precisión debido a la multiplicación se realiza en 2 dobles, lo que resulta en doble precisión, mientras que en el segundo el la división se realiza en un solo que se eleva a la doble (pero aún así solo tendrá la precisión del sencillo).

Esto me lleva a cabo:

Console.Out.WriteLine(((double)1) * ((double)1/3)); 
Console.Out.WriteLine((1)/((float)3)); 

produce:

0.333333333333333 
0.3333333 

Así, 'seguro', tal vez, si perder precisiónganando precisión adicional es aceptable.