Why is my final vector not!= B when using slerp to interpolate from A to B

Question

I think this is just a simple case of my misunderstanding.

I have succesfully been using linear interpolation to interpolate between two many dimensional vectors, A and B, where elements of A and B are -1 .. 1

I then learned that using slerp can give better results for my task, and decided to implement it. From examples I saw, it worked as a straight drop-in for the linear interpolation method I was using.

However, I find that where element wise pairs in the two vectors A and B have a different sign, the sign of the corresponding element in the final (ie, interpolation distance is 1) vector is flipped.

I was expecting, when interpolating from A to B, that the result of the interpolation when the interpolation distance is 1.0, should be B. This is the case when using simple linear interpolation. Why is not the case when using slerp?

The task at hand is interpolation between two latent-space vectors to generate a morphing sequence of outputs from a trained GAN model (wavegan) -- Simple examples use linear interpolation and I have been able to do so succesfully, but the discussion here : https://github.com/soumith/dcgan.torch/issues/14 suggested using spherical linear interpolation. The implementation I am using of slerp is not from that discussion, but instead the python implementation from the wiki page https://en.wikipedia.org/wiki/Slerp

Answer 1

I found my answer;

It is not noted in the wikipedia page's implementation of slerp, but it flips the direction on one vector when the interpolation would not take the shortest path. I believe this is desirable when computing interpolations of quaternions for animation purposes, but was not desirable in my case.

This commented section is notable in the c++ implementation, while the comment is removed fro the python implementation;

// If the dot product is negative, slerp won't take
// the shorter path. Note that v1 and -v1 are equivalent when
// the negation is applied to all four components. Fix by 
// reversing one quaternion.
if (dot < 0.0f) {
    v1 = -v1;
    dot = -dot;
}

By removing this section I achieved the results I expected.