rigidBodyKinematics

Numerical scope and representation limits

These limits apply to the C rigid-body kinematics routines, the corresponding Python and Numba functions, and the Rust bindings to C. Angles are in radians; Euler parameters are scalar-first unit quaternions. Supply valid rotation matrices and normalized quaternions: the routines do not generally validate or normalize their inputs.

The library uses ordinary double-precision attitude formulas and supports zero and small rotations through analytic limits where appropriate. It does not guarantee accurate finite results for every finite floating-point input. Very large coordinates or rates can overflow intermediate products, and extremely small components can underflow. No common exception or non-finite output convention is guaranteed outside this numerical scope.

Modified Rodrigues parameters (MRPs): normally maintain a norm at or below one using MRPswitch(sigma, 1.0). Modest values above one remain supported, including during shadow switching. Conversions retain their documented branches: MRP2EP can return a negative quaternion scalar and MRP2PRV can return an angle above pi. MRPshadow always requests the other set; its zero-input shadow is singular, whereas MRPswitch leaves zero unchanged.
Gibbs vectors (classical Rodrigues parameters): the representation is singular at a half-turn. Use quaternions or MRPs when a calculation approaches that attitude. This also applies when addition or subtraction produces a half-turn, or when converting unit-norm MRPs to Gibbs vectors. Near these singularities, cancellation can make a small denominator numerically zero; an accurately resolved finite result is not guaranteed.
Principal rotation vectors (PRVs): prefer the principal representation with angle at most pi when accumulating rotations. The conversion functions retain their existing angle branches and do not automatically reduce every result to this interval. The forward PRV rate map is singular at nonzero full turns; its zero-angle singularity is removable and is handled analytically.
Euler angles: at a conversion singularity the third angle is set to zero and the observable combined rotation is recovered in the first angle. This preserves the attitude but does not make the Euler rate map nonsingular.

Angle wrapping supports multiple revolutions, but cannot recover angular detail already lost to rounding in a very large input. The library does not impose a new magnitude cutoff or silently switch representations in rate calculations. Choose a well-conditioned representation before evaluating its derivatives; an attitude shadow switch also changes the coordinate derivatives.

For Python and Numba input-container and compiled-call requirements, see RigidBodyKinematicsNumba.

Functions

void addEP(double *b1, double *b2, double *result)

void addEuler121(double *e1, double *e2, double *result)

Compose successive (1-2-1) rotations, including singular attitudes.

Note

At a singularity, the third angle is zero.

Parameters:

e1 – First Euler angle vector [rad].
e2 – Second Euler angle vector [rad].
result – Output Euler angle vector [rad].

void addEuler123(double *e1, double *e2, double *result)

void addEuler131(double *e1, double *e2, double *result)

Compose successive (1-3-1) rotations, including singular attitudes.

Note

At a singularity, the third angle is zero.

Parameters:

e1 – First Euler angle vector [rad].
e2 – Second Euler angle vector [rad].
result – Output Euler angle vector [rad].

void addEuler132(double *e1, double *e2, double *result)

void addEuler212(double *e1, double *e2, double *result)

Compose successive (2-1-2) rotations, including singular attitudes.

Note

At a singularity, the third angle is zero.

Parameters:

e1 – First Euler angle vector [rad].
e2 – Second Euler angle vector [rad].
result – Output Euler angle vector [rad].

void addEuler213(double *e1, double *e2, double *result)

void addEuler231(double *e1, double *e2, double *result)

void addEuler232(double *e1, double *e2, double *result)

Compose successive (2-3-2) rotations, including singular attitudes.

Note

At a singularity, the third angle is zero.

Parameters:

e1 – First Euler angle vector [rad].
e2 – Second Euler angle vector [rad].
result – Output Euler angle vector [rad].

void addEuler312(double *e1, double *e2, double *result)

void addEuler313(double *e1, double *e2, double *result)

Compose successive (3-1-3) rotations, including singular attitudes.

Note

At a singularity, the third angle is zero.

Parameters:

e1 – First Euler angle vector [rad].
e2 – Second Euler angle vector [rad].
result – Output Euler angle vector [rad].

void addEuler321(double *e1, double *e2, double *result)

void addEuler323(double *e1, double *e2, double *result)

Compose successive (3-2-3) rotations, including singular attitudes.

Note

At a singularity, the third angle is zero.

Parameters:

e1 – First Euler angle vector [rad].
e2 – Second Euler angle vector [rad].
result – Output Euler angle vector [rad].

void addGibbs(double *q1, double *q2, double *result)

Return the Gibbs vector for successive rotations q1 and q2.

Parameters:

q1 – First Gibbs vector [-].
q2 – Second Gibbs vector [-].
result – Output composed Gibbs vector [-].

void addMRP(double *q1, double *q2, double *result)

Return the bounded MRP set for successive rotations q1 and q2.

Parameters:

q1 – First MRP vector [-].
q2 – Second MRP vector [-].
result – Output MRP vector with norm at most one [-].

void addPRV(double *q1, double *q2, double *result)

Compose two successive principal rotation vectors.

Note

Opposite input vectors return zero; other results retain the composed quaternion’s angle branch.

Parameters:

qq1 – First rotation vector [rad].
qq2 – Second rotation vector [rad].
result – Output composed rotation vector [rad].

void BinvEP(double *q, double B[3][4])

void BinvEuler121(double *q, double B[3][3])

void BinvEuler123(double *q, double B[3][3])

void BinvEuler131(double *q, double B[3][3])

void BinvEuler132(double *q, double B[3][3])

void BinvEuler212(double *q, double B[3][3])

void BinvEuler213(double *q, double B[3][3])

void BinvEuler231(double *q, double B[3][3])

void BinvEuler232(double *q, double B[3][3])

void BinvEuler312(double *q, double B[3][3])

void BinvEuler313(double *q, double B[3][3])

void BinvEuler321(double *q, double B[3][3])

void BinvEuler323(double *q, double B[3][3])

void BinvGibbs(double *q, double B[3][3])

Return the inverse Gibbs rate matrix, with angular velocity w = 2 B dq/dt.

Parameters:

q – Gibbs vector [-].
B – Output 3-by-3 inverse rate matrix [-].

void BinvMRP(double *q, double B[3][3])

Return the inverse MRP rate matrix, with angular velocity w = 4 B dq/dt.

Parameters:

q – Modified Rodrigues parameters [-].
B – Output 3-by-3 inverse rate matrix [-].

void BinvPRV(double *q, double B[3][3])

Map the rotation-vector derivative to angular velocity.

Note

The zero-attitude limit is identity; small angles use series expansions.

Parameters:

q – Principal rotation vector [rad].
B – Output 3-by-3 kinematic matrix.

void BmatEP(double *q, double B[4][3])

void BmatEuler121(double *q, double B[3][3])

void BmatEuler131(double *q, double B[3][3])

void BmatEuler123(double *q, double B[3][3])

void BmatEuler132(double *q, double B[3][3])

void BmatEuler212(double *q, double B[3][3])

void BmatEuler213(double *q, double B[3][3])

void BmatEuler231(double *q, double B[3][3])

void BmatEuler232(double *q, double B[3][3])

void BmatEuler312(double *q, double B[3][3])

void BmatEuler313(double *q, double B[3][3])

void BmatEuler321(double *q, double B[3][3])

void BmatEuler323(double *q, double B[3][3])

void BmatGibbs(double *q, double B[3][3])

void BmatMRP(double *q, double B[3][3])

Return the MRP rate matrix satisfying dq/dt = B * omega / 4.

Parameters:

q – Input MRP vector [-].
B – Output rate matrix [-].

void BdotmatMRP(double *q, double *dq, double B[3][3])

Return the time derivative of the MRP rate matrix.

Parameters:

q – Input MRP vector [-].
dq – Input MRP time derivative [1/s].
B – Output matrix time derivative [1/s].

void BmatPRV(double *q, double B[3][3])

Map angular velocity to the rotation-vector derivative.

Note

The zero-attitude limit is identity; small angles use series expansions.

Parameters:

q – Principal rotation vector [rad].
B – Output 3-by-3 kinematic matrix.

void C2EP(double C[3][3], double b[4])

void C2Euler121(double C[3][3], double *q)

Convert a DCM to the (1-2-1) Euler angle set.

Note

At a singularity, the third angle is zero and the first angle carries the observable combined rotation.

Parameters:

C – Input direction cosine matrix.
q – Output Euler angles [rad].

void C2Euler123(double C[3][3], double *q)

Convert a DCM to the (1-2-3) Euler angle set.

Note

At a singularity, the third angle is zero and the first angle carries the observable combined rotation.

Parameters:

C – Input direction cosine matrix.
q – Output Euler angles [rad].

void C2Euler131(double C[3][3], double *q)

Convert a DCM to the (1-3-1) Euler angle set.

Note

At a singularity, the third angle is zero and the first angle carries the observable combined rotation.

Parameters:

C – Input direction cosine matrix.
q – Output Euler angles [rad].

void C2Euler132(double C[3][3], double *q)

Convert a DCM to the (1-3-2) Euler angle set.

Note

At a singularity, the third angle is zero and the first angle carries the observable combined rotation.

Parameters:

C – Input direction cosine matrix.
q – Output Euler angles [rad].

void C2Euler212(double C[3][3], double *q)

Convert a DCM to the (2-1-2) Euler angle set.

Note

At a singularity, the third angle is zero and the first angle carries the observable combined rotation.

Parameters:

C – Input direction cosine matrix.
q – Output Euler angles [rad].

void C2Euler213(double C[3][3], double *q)

Convert a DCM to the (2-1-3) Euler angle set.

Note

At a singularity, the third angle is zero and the first angle carries the observable combined rotation.

Parameters:

C – Input direction cosine matrix.
q – Output Euler angles [rad].

void C2Euler231(double C[3][3], double *q)

Convert a DCM to the (2-3-1) Euler angle set.

Note

At a singularity, the third angle is zero and the first angle carries the observable combined rotation.

Parameters:

C – Input direction cosine matrix.
q – Output Euler angles [rad].

void C2Euler232(double C[3][3], double *q)

Convert a DCM to the (2-3-2) Euler angle set.

Note

At a singularity, the third angle is zero and the first angle carries the observable combined rotation.

Parameters:

C – Input direction cosine matrix.
q – Output Euler angles [rad].

void C2Euler312(double C[3][3], double *q)

Convert a DCM to the (3-1-2) Euler angle set.

Note

At a singularity, the third angle is zero and the first angle carries the observable combined rotation.

Parameters:

C – Input direction cosine matrix.
q – Output Euler angles [rad].

void C2Euler313(double C[3][3], double *q)

Convert a DCM to the (3-1-3) Euler angle set.

Note

At a singularity, the third angle is zero and the first angle carries the observable combined rotation.

Parameters:

C – Input direction cosine matrix.
q – Output Euler angles [rad].

void C2Euler321(double C[3][3], double *q)

Convert a DCM to the (3-2-1) Euler angle set.

Note

At a singularity, the third angle is zero and the first angle carries the observable combined rotation.

Parameters:

C – Input direction cosine matrix.
q – Output Euler angles [rad].

void C2Euler323(double C[3][3], double *q)

Convert a DCM to the (3-2-3) Euler angle set.

Note

At a singularity, the third angle is zero and the first angle carries the observable combined rotation.

Parameters:

C – Input direction cosine matrix.
q – Output Euler angles [rad].

void C2Gibbs(double C[3][3], double *q)

void C2MRP(double C[3][3], double *q)

void C2PRV(double C[3][3], double *q)

Convert a DCM to a principal rotation vector.

Parameters:

C – Input 3-by-3 direction cosine matrix.
q – Output rotation vector [rad], with magnitude in [0, pi].

void dEP(double *q, double *w, double *dq)

void dEuler121(double *q, double *w, double *dq)

void dEuler123(double *q, double *w, double *dq)

void dEuler131(double *q, double *w, double *dq)

void dEuler132(double *q, double *w, double *dq)

void dEuler212(double *q, double *w, double *dq)

void dEuler213(double *q, double *w, double *dq)

void dEuler231(double *q, double *w, double *dq)

void dEuler232(double *q, double *w, double *dq)

void dEuler312(double *q, double *w, double *dq)

void dEuler313(double *q, double *w, double *dq)

void dEuler321(double *q, double *w, double *dq)

void dEuler323(double *q, double *w, double *dq)

void dGibbs(double *q, double *w, double *dq)

Map angular velocity to the Gibbs vector derivative.

Parameters:

q – Dimensionless Gibbs vector.
w – Body angular velocity in radians per second.
dq – Gibbs time derivative in inverse seconds.

void dMRP(double *q, double *w, double *dq)

Map angular velocity to the MRP time derivative.

Parameters:

q – Dimensionless MRP vector.
w – Body angular velocity in radians per second.
dq – MRP time derivative in inverse seconds.

void dMRP2Omega(double *q, double *dq, double *w)

Recover angular velocity from the MRP time derivative.

Parameters:

q – Dimensionless MRP vector.
dq – MRP time derivative in inverse seconds.
w – Body angular velocity in radians per second.

void ddMRP(double *q, double *dq, double *w, double *dw, double *ddq)

Map angular acceleration to the MRP second derivative.

Parameters:

q – Dimensionless MRP vector.
dq – MRP time derivative in inverse seconds.
w – Body angular velocity in radians per second.
dw – Body angular acceleration in radians per second squared.
ddq – MRP second derivative in inverse seconds squared.

void ddMRP2dOmega(double *q, double *dq, double *ddq, double *dw)

Recover angular acceleration from MRP derivatives.

Parameters:

q – Dimensionless MRP vector.
dq – MRP time derivative in inverse seconds.
ddq – MRP second derivative in inverse seconds squared.
dw – Body angular acceleration in radians per second squared.

void dPRV(double *q, double *w, double *dq)

Map angular velocity to the principal rotation vector derivative.

Parameters:

q – Principal rotation vector [rad].
w – Body angular velocity [rad/s].
dq – Output rotation vector derivative [rad/s].

void elem2PRV(double *r, double *q)

void EP2C(double *q, double C[3][3])

void EP2Euler121(double *q, double *e)

Convert Euler parameters to the (1-2-1) Euler angle set.

Note

At a singularity, the third angle is zero and the first angle carries the observable combined rotation.

Parameters:

q – Input scalar-first unit quaternion.
e – Output Euler angles [rad].

void EP2Euler123(double *q, double *e)

Convert Euler parameters to the (1-2-3) Euler angle set.

Note

At a singularity, the third angle is zero and the first angle carries the observable combined rotation.

Parameters:

q – Input scalar-first unit quaternion.
e – Output Euler angles [rad].

void EP2Euler131(double *q, double *e)

Convert Euler parameters to the (1-3-1) Euler angle set.

Note

At a singularity, the third angle is zero and the first angle carries the observable combined rotation.

Parameters:

q – Input scalar-first unit quaternion.
e – Output Euler angles [rad].

void EP2Euler132(double *q, double *e)

Convert Euler parameters to the (1-3-2) Euler angle set.

Note

At a singularity, the third angle is zero and the first angle carries the observable combined rotation.

Parameters:

q – Input scalar-first unit quaternion.
e – Output Euler angles [rad].

void EP2Euler212(double *q, double *e)

Convert Euler parameters to the (2-1-2) Euler angle set.

Note

At a singularity, the third angle is zero and the first angle carries the observable combined rotation.

Parameters:

q – Input scalar-first unit quaternion.
e – Output Euler angles [rad].

void EP2Euler213(double *q, double *e)

Convert Euler parameters to the (2-1-3) Euler angle set.

Note

At a singularity, the third angle is zero and the first angle carries the observable combined rotation.

Parameters:

q – Input scalar-first unit quaternion.
e – Output Euler angles [rad].

void EP2Euler231(double *q, double *e)

Convert Euler parameters to the (2-3-1) Euler angle set.

Note

At a singularity, the third angle is zero and the first angle carries the observable combined rotation.

Parameters:

q – Input scalar-first unit quaternion.
e – Output Euler angles [rad].

void EP2Euler232(double *q, double *e)

Convert Euler parameters to the (2-3-2) Euler angle set.

Note

At a singularity, the third angle is zero and the first angle carries the observable combined rotation.

Parameters:

q – Input scalar-first unit quaternion.
e – Output Euler angles [rad].

void EP2Euler312(double *q, double *e)

Convert Euler parameters to the (3-1-2) Euler angle set.

Note

At a singularity, the third angle is zero and the first angle carries the observable combined rotation.

Parameters:

q – Input scalar-first unit quaternion.
e – Output Euler angles [rad].

void EP2Euler313(double *q, double *e)

Convert Euler parameters to the (3-1-3) Euler angle set.

Note

At a singularity, the third angle is zero and the first angle carries the observable combined rotation.

Parameters:

q – Input scalar-first unit quaternion.
e – Output Euler angles [rad].

void EP2Euler321(double *q, double *e)

Convert Euler parameters to the (3-2-1) Euler angle set.

Note

At a singularity, the third angle is zero and the first angle carries the observable combined rotation.

Parameters:

q – Input scalar-first unit quaternion.
e – Output Euler angles [rad].

void EP2Euler323(double *q, double *e)

Convert Euler parameters to the (3-2-3) Euler angle set.

Note

At a singularity, the third angle is zero and the first angle carries the observable combined rotation.

Parameters:

q – Input scalar-first unit quaternion.
e – Output Euler angles [rad].

void EP2Gibbs(double *q1, double *q)

void EP2MRP(double *q1, double *q)

void EP2PRV(double *q1, double *q)

Convert Euler parameters to a principal rotation vector.

Note

Both identity quaternions return zero. A negative scalar component retains the rotation branch with angle greater than pi.

Parameters:

q1 – Unit quaternion, scalar component first.
q – Output rotation vector [rad].

void Euler1(double x, double m[3][3])

void Euler2(double x, double m[3][3])

void Euler3(double x, double m[3][3])

void Euler1212C(double *q, double C[3][3])

void Euler1212EP(double *e, double *q)

void Euler1212Gibbs(double *e, double *q)

void Euler1212MRP(double *e, double *q)

void Euler1212PRV(double *e, double *q)

void Euler1232C(double *q, double C[3][3])

void Euler1232EP(double *e, double *q)

void Euler1232Gibbs(double *e, double *q)

void Euler1232MRP(double *e, double *q)

void Euler1232PRV(double *e, double *q)

void Euler1312C(double *q, double C[3][3])

void Euler1312EP(double *e, double *q)

void Euler1312Gibbs(double *e, double *q)

void Euler1312MRP(double *e, double *q)

void Euler1312PRV(double *e, double *q)

void Euler1322C(double *q, double C[3][3])

void Euler1322EP(double *e, double *q)

void Euler1322Gibbs(double *e, double *q)

void Euler1322MRP(double *e, double *q)

void Euler1322PRV(double *e, double *q)

void Euler2122C(double *q, double C[3][3])

void Euler2122EP(double *e, double *q)

void Euler2122Gibbs(double *e, double *q)

void Euler2122MRP(double *e, double *q)

void Euler2122PRV(double *e, double *q)

void Euler2132C(double *q, double C[3][3])

void Euler2132EP(double *e, double *q)

void Euler2132Gibbs(double *e, double *q)

void Euler2132MRP(double *e, double *q)

void Euler2132PRV(double *e, double *q)

void Euler2312C(double *q, double C[3][3])

void Euler2312EP(double *e, double *q)

void Euler2312Gibbs(double *e, double *q)

void Euler2312MRP(double *e, double *q)

void Euler2312PRV(double *e, double *q)

void Euler2322C(double *q, double C[3][3])

void Euler2322EP(double *e, double *q)

void Euler2322Gibbs(double *e, double *q)

void Euler2322MRP(double *e, double *q)

void Euler2322PRV(double *e, double *q)

void Euler3122C(double *q, double C[3][3])

void Euler3122EP(double *e, double *q)

void Euler3122Gibbs(double *e, double *q)

void Euler3122MRP(double *e, double *q)

void Euler3122PRV(double *e, double *q)

void Euler3132C(double *q, double C[3][3])

void Euler3132EP(double *e, double *q)

void Euler3132Gibbs(double *e, double *q)

void Euler3132MRP(double *e, double *q)

void Euler3132PRV(double *e, double *q)

void Euler3212C(double *q, double C[3][3])

void Euler3212EP(double *e, double *q)

void Euler3212Gibbs(double *e, double *q)

void Euler3212MRP(double *e, double *q)

void Euler3212PRV(double *e, double *q)

void Euler3232C(double *q, double C[3][3])

void Euler3232EP(double *e, double *q)

void Euler3232Gibbs(double *e, double *q)

void Euler3232MRP(double *e, double *q)

void Euler3232PRV(double *e, double *q)

void Gibbs2C(double *q, double C[3][3])

Convert a Gibbs vector to a direction cosine matrix.

Parameters:

q – Input three-component Gibbs vector [-].
C – Output 3-by-3 direction cosine matrix [-].

void Gibbs2EP(double *q1, double *q)

Convert a Gibbs vector to Euler parameters.

Note

Input and output may share storage if the buffer holds four doubles.

Parameters:

q1 – Input three-component Gibbs vector [-].
q – Output scalar-first unit quaternion with a positive scalar component [-].

void Gibbs2Euler121(double *q, double *e)

void Gibbs2Euler123(double *q, double *e)

void Gibbs2Euler131(double *q, double *e)

void Gibbs2Euler132(double *q, double *e)

void Gibbs2Euler212(double *q, double *e)

void Gibbs2Euler213(double *q, double *e)

void Gibbs2Euler231(double *q, double *e)

void Gibbs2Euler232(double *q, double *e)

void Gibbs2Euler312(double *q, double *e)

void Gibbs2Euler313(double *q, double *e)

void Gibbs2Euler321(double *q, double *e)

void Gibbs2Euler323(double *q, double *e)

void Gibbs2MRP(double *q1, double *q)

Convert a Gibbs vector to modified Rodrigues parameters.

Parameters:

q1 – Input three-component Gibbs vector [-].
q – Output three-component MRP vector with norm at most one [-].

void Gibbs2PRV(double *q1, double *q)

Convert a Gibbs vector to a principal rotation vector.

Parameters:

q1 – Input Gibbs vector.
q – Output rotation vector [rad]. Small nonzero rotations are retained.

void MRP2C(double *q, double C[3][3])

Convert modified Rodrigues parameters to a direction cosine matrix.

Parameters:

q – Input three-component MRP vector [-].
C – Output 3-by-3 direction cosine matrix [-].

void MRP2EP(double *q1, double *q)

Convert modified Rodrigues parameters to Euler parameters.

Note

Input and output may share storage if the buffer holds four doubles.

Parameters:

q1 – Input three-component MRP vector [-].
q – Output scalar-first unit quaternion [-].

void MRP2Euler121(double *q, double *e)

void MRP2Euler123(double *q, double *e)

void MRP2Euler131(double *q, double *e)

void MRP2Euler132(double *q, double *e)

void MRP2Euler212(double *q, double *e)

void MRP2Euler213(double *q, double *e)

void MRP2Euler231(double *q, double *e)

void MRP2Euler232(double *q, double *e)

void MRP2Euler312(double *q, double *e)

void MRP2Euler313(double *q, double *e)

void MRP2Euler321(double *q, double *e)

void MRP2Euler323(double *q, double *e)

void MRP2Gibbs(double *q1, double *q)

Convert modified Rodrigues parameters to a Gibbs vector.

Parameters:

q1 – Input MRP vector [-].
q – Output Gibbs vector [-].

void MRP2PRV(double *q1, double *q)

Convert modified Rodrigues parameters to a principal rotation vector.

Parameters:

q1 – Input modified Rodrigues parameters.
q – Output rotation vector [rad]. Small nonzero rotations are retained.

void MRPswitch(double *q, double s2, double *s)

Switch to the shadow MRP set only above the norm threshold.

Parameters:

q – Input MRP vector [-].
s2 – MRP norm threshold, interpreted by magnitude [-].
s – Output MRP vector, unchanged at or below the threshold [-].

void MRPshadow(double *qIn, double *qOut)

Return the shadow set of a nonzero MRP vector.

Parameters:

qIn – Input MRP vector [-].
qOut – Output shadow MRP vector [-]. May alias qIn.

double wrapToPi(double x)

Wrap an angle with any number of revolutions to the interval [-pi, pi].

Note

Exact half-turn remainders and zero retain the input sign.

Parameters:: x – Input angle [rad].
Returns:: Equivalent angle [rad], or NaN for non-finite inputs.

void PRV2C(double *q, double C[3][3])

Convert a principal rotation vector to a DCM.

Parameters:

q – Input rotation vector [rad].
C – Output 3-by-3 direction cosine matrix.

void PRV2elem(double *r, double *q)

Convert a rotation vector to its angle and unit axis.

Note

Only an exactly zero vector returns an all-zero element set.

Parameters:

r – Input rotation vector [rad].
q – Output angle [rad] followed by the unit axis.

void PRV2EP(double *q0, double *q)

void PRV2Euler121(double *q, double *e)

void PRV2Euler123(double *q, double *e)

void PRV2Euler131(double *q, double *e)

void PRV2Euler132(double *q, double *e)

void PRV2Euler212(double *q, double *e)

void PRV2Euler213(double *q, double *e)

void PRV2Euler231(double *q, double *e)

void PRV2Euler232(double *q, double *e)

void PRV2Euler312(double *q, double *e)

void PRV2Euler313(double *q, double *e)

void PRV2Euler321(double *q, double *e)

void PRV2Euler323(double *q, double *e)

void PRV2Gibbs(double *q0, double *q)

void PRV2MRP(double *q0, double *q)

void subEP(double *b1, double *b2, double *q)

void subEuler121(double *e, double *e1, double *e2)

Return the relative (1-2-1) rotation from e1 to e.

Note

At a singularity, the third angle is zero.

Parameters:

e – Final Euler angle vector [rad].
e1 – Reference Euler angle vector [rad].
e2 – Output relative Euler angle vector [rad].

void subEuler123(double *e, double *e1, double *e2)

void subEuler131(double *e, double *e1, double *e2)

Return the relative (1-3-1) rotation from e1 to e.

Note

At a singularity, the third angle is zero.

Parameters:

e – Final Euler angle vector [rad].
e1 – Reference Euler angle vector [rad].
e2 – Output relative Euler angle vector [rad].

void subEuler132(double *e, double *e1, double *e2)

void subEuler212(double *e, double *e1, double *e2)

Return the relative (2-1-2) rotation from e1 to e.

Note

At a singularity, the third angle is zero.

Parameters:

e – Final Euler angle vector [rad].
e1 – Reference Euler angle vector [rad].
e2 – Output relative Euler angle vector [rad].

void subEuler213(double *e, double *e1, double *e2)

void subEuler231(double *e, double *e1, double *e2)

void subEuler232(double *e, double *e1, double *e2)

Return the relative (2-3-2) rotation from e1 to e.

Note

At a singularity, the third angle is zero.

Parameters:

e – Final Euler angle vector [rad].
e1 – Reference Euler angle vector [rad].
e2 – Output relative Euler angle vector [rad].

void subEuler312(double *e, double *e1, double *e2)

void subEuler313(double *e, double *e1, double *e2)

Return the relative (3-1-3) rotation from e1 to e.

Note

At a singularity, the third angle is zero.

Parameters:

e – Final Euler angle vector [rad].
e1 – Reference Euler angle vector [rad].
e2 – Output relative Euler angle vector [rad].

void subEuler321(double *e, double *e1, double *e2)

void subEuler323(double *e, double *e1, double *e2)

Return the relative (3-2-3) rotation from e1 to e.

Note

At a singularity, the third angle is zero.

Parameters:

e – Final Euler angle vector [rad].
e1 – Reference Euler angle vector [rad].
e2 – Output relative Euler angle vector [rad].

void subGibbs(double *q1, double *q2, double *q)

Return the relative Gibbs vector from q2 to q1.

Parameters:

q1 – Final Gibbs vector [-].
q2 – Reference Gibbs vector [-].
q – Output relative Gibbs vector [-].

void subMRP(double *q1, double *q2, double *q)

Return the bounded relative MRP set from q2 to q1.

Parameters:

q1 – Final MRP vector [-].
q2 – Reference MRP vector [-].
q – Output relative MRP vector with norm at most one [-].

void subPRV(double *q10, double *q20, double *q)

Return the relative principal rotation vector from q20 to q10.

Note

Equal input vectors return zero; other results retain the relative quaternion’s angle branch.

Parameters:

q10 – Final rotation vector [rad].
q20 – Reference rotation vector [rad].
q – Output relative rotation vector [rad].

void Mi(double angle, int axis, double C[3][3])

void tilde(double *v, double mat[3][3])