Create two quaternions with the following interpretation:

a = quaternion([45,0,0],'eulerd','ZYX','frame');
c = quaternion([-45,0,0],'eulerd','ZYX','frame');

Call slerp with the quaternions a and c and specify an interpolation coefficient of 0.5.

interpolationCoefficient = 0.5;

b = slerp(a,c,interpolationCoefficient);

The output of slerp, b, represents an average rotation of a and c. To verify, convert b to Euler angles in degrees.

averageRotation = eulerd(b,'ZYX','frame')

averageRotation = 1×3

     0     0     0

The interpolation coefficient is specified as a normalized value between 0 and 1, inclusive. An interpolation coefficient of 0 corresponds to the a quaternion, and an interpolation coefficient of 1 corresponds to the c quaternion. Call slerp with coefficients 0 and 1 to confirm.

b = slerp(a,c,[0,1]);
eulerd(b,'ZYX','frame')

ans = 2×3

   45.0000         0         0
  -45.0000         0         0

You can create smooth paths between quaternions by specifying arrays of equally spaced interpolation coefficients.

path = 0:0.1:1;

interpolatedQuaternions = slerp(a,c,path);

For quaternions that represent rotation only about a single axis, specifying interpolation coefficients as equally spaced results in quaternions equally spaced in Euler angles. Convert interpolatedQuaternions to Euler angles and verify that the difference between the angles in the path is constant.

k = eulerd(interpolatedQuaternions,'ZYX','frame');
abc = abs(diff(k))

abc = 10×3

    9.0000         0         0
    9.0000         0         0
    9.0000         0         0
    9.0000         0         0
    9.0000         0         0
    9.0000         0         0
    9.0000         0         0
    9.0000         0         0
    9.0000         0         0
    9.0000         0         0

Alternatively, you can use the dist function to verify that the distance between the interpolated quaternions is consistent. The dist function returns angular distance in radians; convert to degrees for easy comparison.

def = rad2deg(dist(interpolatedQuaternions(2:end),interpolatedQuaternions(1:end-1)))

def = 1×10

    9.0000    9.0000    9.0000    9.0000    9.0000    9.0000    9.0000    9.0000    9.0000    9.0000

The SLERP algorithm interpolates along a great circle path connecting two quaternions. This example shows how the SLERP algorithm minimizes the great circle path.

Define three quaternions:

q0 = ones(1,'quaternion');

q179 = quaternion([179,0,0],'eulerd','ZYX','frame');

q180 = quaternion([180,0,0],'eulerd','ZYX','frame');

q181 = quaternion([181,0,0],'eulerd','ZYX','frame');

Use slerp to interpolate between q0 and the three quaternion rotations. Specify that the paths are traveled in 10 steps.

T = linspace(0,1,10);

q179path = slerp(q0,q179,T);
q180path = slerp(q0,q180,T);
q181path = slerp(q0,q181,T);

Plot each path in terms of Euler angles in degrees.

q179pathEuler = eulerd(q179path,'ZYX','frame');
q180pathEuler = eulerd(q180path,'ZYX','frame');
q181pathEuler = eulerd(q181path,'ZYX','frame');

plot(T,q179pathEuler(:,1),'bo', ...
     T,q180pathEuler(:,1),'r*', ...
     T,q181pathEuler(:,1),'gd');
legend('Path to 179 degrees', ...
       'Path to 180 degrees', ...
       'Path to 181 degrees')
xlabel('Interpolation Coefficient')
ylabel('Z-Axis Rotation (Degrees)')

The path between q0 and q179 is clockwise to minimize the great circle distance. The path between q0 and q181 is counterclockwise to minimize the great circle distance. The path between q0 and q180 can be either clockwise or counterclockwise, depending on numerical rounding.