Request: methods for fractional add of vector and fractional application of quaternion

Related to (but not the same as) slerp, I need a method for scaling just the angle of a quaternion by a given factor, allowing for a single (non-slerp) quaternion to be applied to a given fractional amount. The code I have to do this is:

private static Quaterniond scaleQuatRotation(Quaterniond quat, double frac) {
    AxisAngle4d axisAngle = new AxisAngle4d(quat);
    double angle = axisAngle.angle;
    if (angle > Math.PI) {
        angle -= 2.0 * Math.PI;
    }
    return new Quaterniond(new AxisAngle4d(angle * frac, axisAngle.x, axisAngle.y, axisAngle.z));
}

However it would be more efficient to compute this internally to JOML, supplying a “fractional multiplication” method that scales the angle of a second quaternion when multiplying by a first quaternion, e.g.

prevRotation.mul(newRotation, frac, new Quaterniond())

Similarly I need a method that adds a fractionally scaled vector:

private static Vector3d addScaledVector(Vector3d vec1,Vector3d vec2, double frac) {
    return vec1.add(vec2.mul(frac, new Vector3d()), new Vector3d());
}

but it would be more efficient to compute this internally to JOML using an API like

prevVec.add(newVec, frac, new Vector3d())

These methods are important for a range of interpolation tasks.

[httpdigest]

I am not sure that approximating sqrt is worth it. Assuming that the JIT lowers a (float) sqrt() to an x86 SQRTSS instruction, then this (on Skylake) has the same operation latency as DIVSS (which would be needed for the approximation itself). In addition, we also need the comparison (which branch prediction can probably predict well when normalizing often).

Latency tables: https://www.agner.org/optimize/instruction_tables.pdf

[lukehutch]

Thanks for the pointer. I see that sqrt is not yet approximated, and there is no entry in the Math class for inverse sqrt. The inverse sqrt trick I linked above is very useful for quaternions when you normalize after every operation, since it is highly optimal when the magnitude of the result is already close to 1.0.