Question

Basically for things like this (not real code):

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 is of type Vector3<float, float, float>, but could be Vector3<double, double, double>.

Is it safe to just do?:

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

This might seem like premature optimization but this has to be as fast as possible that will be called on billions of points (point clouds).

Answer 1

Not a C++ expert by any means, but in C#, doing this:

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);

generates IL that in the former:

1. Loads the arguments
2. Adds them (producing a single)
3. Converts the result to a double
4. Loads the double argument (0.5)
5. Multiplies (producing a double)
6. Returns the result

and the latter

1. Loads the arguments
2. Adds them (producing a single)
3. Loads the constant integer (2)
4. Divides (producing a single, because single / integer produces a single)
5. Converts the result to a double
6. Returns the result

It strikes me that the former will likely have higher precision because the multiplication is performed on 2 doubles, resulting in double precision, whereas in the latter the division is performed on a single which is upcast to a double (but still only will have the precision of the single).

This bears me out:

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

produces:

0.333333333333333
0.3333333

So, ‘safe’, maybe, if losing precision gaining extra precision is ok.