Detailed Description

Models the Quaternion representation of rotations.

FGQuaternion is a representation of an arbitrary rotation through a quaternion. It has vector properties. This class also contains access functions to the euler angle representation of rotations and access to transformation matrices for 3D vectors. Transformations and euler angles are therefore computed once they are requested for the first time. Then they are cached for later usage as long as the class is not accessed trough a nonconst member function.

Note: The order of rotations used in this class corresponds to a 3-2-1 sequence, or Y-P-R, or Z-Y-X, if you prefer.

See also: Cooke, Zyda, Pratt, and McGhee, "NPSNET: Flight Simulation Dynamic Modeling Using Quaternions", Presence, Vol. 1, No. 4, pp. 404-420 Naval Postgraduate School, January 1994; D. M. Henderson, "Euler Angles, Quaternions, and Transformation Matrices", JSC 12960, July 1977; Richard E. McFarland, "A Standard Kinematic Model for Flight Simulation at NASA-Ames", NASA CR-2497, January 1975; Barnes W. McCormick, "Aerodynamics, Aeronautics, and Flight Mechanics", Wiley & Sons, 1979 ISBN 0-471-03032-5; Bernard Etkin, "Dynamics of Flight, Stability and Control", Wiley & Sons, 1982 ISBN 0-471-08936-2

Author: Mathias Froehlich, extended FGColumnVector4 originally by Tony Peden and Jon Berndt

Definition at line 86 of file FGQuaternion.h.

#include <FGQuaternion.h>

Inheritance diagram for FGQuaternion:

Collaboration diagram for FGQuaternion:

Public Member Functions
	FGQuaternion ()
	Default initializer. More...

	FGQuaternion (const FGMatrix33 &m)
	Initializer by matrix. More...

	FGQuaternion (const FGQuaternion &q)
	Copy constructor. More...

	FGQuaternion (double angle, const FGColumnVector3 &axis)
	Initializer by a rotation axis and an angle. More...

	FGQuaternion (double phi, double tht, double psi)
	Initializer by euler angles. More...

	FGQuaternion (FGColumnVector3 vOrient)
	Initializer by euler angle vector. More...

	FGQuaternion (int idx, double angle)
	Initializer by one euler angle. More...

	~FGQuaternion ()
	Destructor.

FGQuaternion	Conjugate (void) const
	Conjugate of the quaternion. More...

std::string	Dump (const std::string &delimiter) const

double &	Entry (unsigned int idx)
	Write access the entries of the vector. More...

double	Entry (unsigned int idx) const
	Read access the entries of the vector. More...

double	GetCosEuler (int i) const
	Retrieves cosine of the given euler angle. More...

double	GetEuler (int i) const
	Retrieves the Euler angles. More...

const FGColumnVector3 &	GetEuler (void) const
	Retrieves the Euler angles. More...

double	GetEulerDeg (int i) const
	Retrieves the Euler angles. More...

const FGColumnVector3	GetEulerDeg (void) const
	Retrieves the Euler angle vector. More...

FGQuaternion	GetQDot (const FGColumnVector3 &PQR) const
	Quaternion derivative for given angular rates. More...

double	GetSinEuler (int i) const
	Retrieves sine of the given euler angle. More...

const FGMatrix33 &	GetT (void) const
	Transformation matrix. More...

const FGMatrix33 &	GetTInv (void) const
	Backward transformation matrix. More...

FGQuaternion	Inverse (void) const
	Inverse of the quaternion. More...

double	Magnitude (void) const
	Length of the vector. More...

void	Normalize (void)
	Normalize. More...

	operator FGMatrix33 () const
	Conversion from Quat to Matrix.

bool	operator!= (const FGQuaternion &q) const
	Comparison operator "!=". More...

double &	operator() (unsigned int idx)
	Write access the entries of the vector. More...

double	operator() (unsigned int idx) const
	Read access the entries of the vector. More...

FGQuaternion	operator* (const FGQuaternion &q) const
	Arithmetic operator "*". More...

const FGQuaternion &	operator*= (const FGQuaternion &q)
	Arithmetic operator "*=". More...

const FGQuaternion &	operator*= (double scalar)
	Arithmetic operator "*=". More...

FGQuaternion	operator+ (const FGQuaternion &q) const
	Arithmetic operator "+". More...

const FGQuaternion &	operator+= (const FGQuaternion &q)

FGQuaternion	operator- (const FGQuaternion &q) const
	Arithmetic operator "-". More...

const FGQuaternion &	operator-= (const FGQuaternion &q)
	Arithmetic operator "-=". More...

const FGQuaternion &	operator/= (double scalar)
	Arithmetic operator "/=". More...

const FGQuaternion &	operator= (const FGQuaternion &q)
	Assignment operator "=". More...

bool	operator== (const FGQuaternion &q) const
	Comparison operator "==". More...

double	SqrMagnitude (void) const
	Square of the length of the vector. More...

Public Member Functions inherited from FGJSBBase
	FGJSBBase ()
	Constructor for FGJSBBase.

virtual	~FGJSBBase ()
	Destructor for FGJSBBase.

void	PutMessage (const Message &msg)
	Places a Message structure on the Message queue. More...

void	PutMessage (const std::string &text)
	Creates a message with the given text and places it on the queue. More...

void	PutMessage (const std::string &text, bool bVal)
	Creates a message with the given text and boolean value and places it on the queue. More...

void	PutMessage (const std::string &text, int iVal)
	Creates a message with the given text and integer value and places it on the queue. More...

void	PutMessage (const std::string &text, double dVal)
	Creates a message with the given text and double value and places it on the queue. More...

int	SomeMessages (void) const
	Reads the message on the queue (but does not delete it). More...

void	ProcessMessage (void)
	Reads the message on the queue and removes it from the queue. More...

Message *	ProcessNextMessage (void)
	Reads the next message on the queue and removes it from the queue. More...

void	disableHighLighting (void)
	Disables highlighting in the console output.

Static Public Member Functions
static FGQuaternion	zero (void)
	Zero quaternion vector. More...

Static Public Member Functions inherited from FGJSBBase
static const std::string &	GetVersion (void)
	Returns the version number of JSBSim. More...

static constexpr double	KelvinToFahrenheit (double kelvin)
	Converts from degrees Kelvin to degrees Fahrenheit. More...

static constexpr double	CelsiusToRankine (double celsius)
	Converts from degrees Celsius to degrees Rankine. More...

static constexpr double	RankineToCelsius (double rankine)
	Converts from degrees Rankine to degrees Celsius. More...

static constexpr double	KelvinToRankine (double kelvin)
	Converts from degrees Kelvin to degrees Rankine. More...

static constexpr double	RankineToKelvin (double rankine)
	Converts from degrees Rankine to degrees Kelvin. More...

static constexpr double	FahrenheitToCelsius (double fahrenheit)
	Converts from degrees Fahrenheit to degrees Celsius. More...

static constexpr double	CelsiusToFahrenheit (double celsius)
	Converts from degrees Celsius to degrees Fahrenheit. More...

static constexpr double	CelsiusToKelvin (double celsius)
	Converts from degrees Celsius to degrees Kelvin. More...

static constexpr double	KelvinToCelsius (double kelvin)
	Converts from degrees Kelvin to degrees Celsius. More...

static constexpr double	FeetToMeters (double measure)
	Converts from feet to meters. More...

static double	PitotTotalPressure (double mach, double p)
	Compute the total pressure in front of the Pitot tube. More...

static double	MachFromImpactPressure (double qc, double p)
	Compute the Mach number from the differential pressure (qc) and the static pressure. More...

static double	VcalibratedFromMach (double mach, double p)
	Calculate the calibrated airspeed from the Mach number. More...

static double	MachFromVcalibrated (double vcas, double p)
	Calculate the Mach number from the calibrated airspeed.Based on the formulas in the US Air Force Aircraft Performance Flight Testing Manual (AFFTC-TIH-99-01). More...

static bool	EqualToRoundoff (double a, double b)
	Finite precision comparison. More...

static bool	EqualToRoundoff (float a, float b)
	Finite precision comparison. More...

static bool	EqualToRoundoff (float a, double b)
	Finite precision comparison. More...

static bool	EqualToRoundoff (double a, float b)
	Finite precision comparison. More...

static constexpr double	Constrain (double min, double value, double max)
	Constrain a value between a minimum and a maximum value.

static constexpr double	sign (double num)

static double	GaussianRandomNumber (void)

Friends
FGQuaternion	operator* (double, const FGQuaternion &)
	Scalar multiplication. More...

FGQuaternion	QExp (const FGColumnVector3 &omega)
	Quaternion exponential. More...

Additional Inherited Members
Public Types inherited from FGJSBBase
enum	{ eL = 1, eM, eN }
	Moments L, M, N.

enum	{ eP = 1, eQ, eR }
	Rates P, Q, R.

enum	{ eU = 1, eV, eW }
	Velocities U, V, W.

enum	{ eX = 1, eY, eZ }
	Positions X, Y, Z.

enum	{ ePhi = 1, eTht, ePsi }
	Euler angles Phi, Theta, Psi.

enum	{ eDrag = 1, eSide, eLift }
	Stability axis forces, Drag, Side force, Lift.

enum	{ eRoll = 1, ePitch, eYaw }
	Local frame orientation Roll, Pitch, Yaw.

enum	{ eNorth = 1, eEast, eDown }
	Local frame position North, East, Down.

enum	{ eLat = 1, eLong, eRad }
	Locations Radius, Latitude, Longitude.

enum	{ inNone = 0, inDegrees, inRadians, inMeters, inFeet }
	Conversion specifiers.

Static Public Attributes inherited from FGJSBBase
static char	highint [5] = {27, '[', '1', 'm', '\0' }
	highlights text

static char	halfint [5] = {27, '[', '2', 'm', '\0' }
	low intensity text

static char	normint [6] = {27, '[', '2', '2', 'm', '\0' }
	normal intensity text

static char	reset [5] = {27, '[', '0', 'm', '\0' }
	resets text properties

static char	underon [5] = {27, '[', '4', 'm', '\0' }
	underlines text

static char	underoff [6] = {27, '[', '2', '4', 'm', '\0' }
	underline off

static char	fgblue [6] = {27, '[', '3', '4', 'm', '\0' }
	blue text

static char	fgcyan [6] = {27, '[', '3', '6', 'm', '\0' }
	cyan text

static char	fgred [6] = {27, '[', '3', '1', 'm', '\0' }
	red text

static char	fggreen [6] = {27, '[', '3', '2', 'm', '\0' }
	green text

static char	fgdef [6] = {27, '[', '3', '9', 'm', '\0' }
	default text

static short	debug_lvl = 1

Static Protected Member Functions inherited from FGJSBBase
static std::string	CreateIndexedPropertyName (const std::string &Property, int index)

Static Protected Attributes inherited from FGJSBBase
static Message	localMsg

static std::queue< Message >	Messages

static unsigned int	messageId = 0

static constexpr double	radtodeg = 180. / M_PI

static constexpr double	degtorad = M_PI / 180.

static constexpr double	hptoftlbssec = 550.0

static constexpr double	psftoinhg = 0.014138

static constexpr double	psftopa = 47.88

static constexpr double	ktstofps = 1.68781

static constexpr double	fpstokts = 1.0 / ktstofps

static constexpr double	inchtoft = 1.0/12.0

static constexpr double	fttom = 0.3048

static constexpr double	m3toft3 = 1.0/(fttomfttomfttom)

static constexpr double	in3tom3 = inchtoftinchtoftinchtoft/m3toft3

static constexpr double	inhgtopa = 3386.38

static constexpr double	slugtolb = 32.174049
	Note that definition of lbtoslug by the inverse of slugtolb and not to a different constant you can also get from some tables will make lbtoslug*slugtolb == 1 up to the magnitude of roundoff. More...

static constexpr double	lbtoslug = 1.0/slugtolb

static constexpr double	kgtolb = 2.20462

static constexpr double	kgtoslug = 0.06852168

static const std::string	needed_cfg_version = "2.0"

static const std::string	JSBSim_version = JSBSIM_VERSION " " __DATE__ " " __TIME__

static int	gaussian_random_number_phase = 0

Constructor & Destructor Documentation

◆ FGQuaternion() [1/7]

FGQuaternion ( )

inline

Default initializer.

Default initializer, initializes the class with the identity rotation.

Definition at line 90 of file FGQuaternion.h.

                  : mCacheValid(false) {
     data[0] = 1.0;
     data[1] = data[2] = data[3] = 0.0;
   }

Here is the caller graph for this function:

◆ FGQuaternion() [2/7]

FGQuaternion ( const FGQuaternion & q )

Copy constructor.

Copy constructor, initializes the quaternion.

Parameters

q	a constant reference to another FGQuaternion instance

Definition at line 64 of file FGQuaternion.cpp.

                                                 : mCacheValid(q.mCacheValid)
 {
   data[0] = q(1);
   data[1] = q(2);
   data[2] = q(3);
   data[3] = q(4);
   if (mCacheValid) {
     mT = q.mT;
     mTInv = q.mTInv;
     mEulerAngles = q.mEulerAngles;
     mEulerSines = q.mEulerSines;
     mEulerCosines = q.mEulerCosines;
   }
 }

◆ FGQuaternion() [3/7]

FGQuaternion	(	double	phi,
		double	tht,
		double	psi
	)

Initializer by euler angles.

Initialize the quaternion with the euler angles.

Parameters

phi	The euler X axis (roll) angle in radians
tht	The euler Y axis (attitude) angle in radians
psi	The euler Z axis (heading) angle in radians

Definition at line 82 of file FGQuaternion.cpp.

                                                             : mCacheValid(false)
 {
   InitializeFromEulerAngles(phi, tht, psi);
 }

◆ FGQuaternion() [4/7]

FGQuaternion ( FGColumnVector3 vOrient )

Initializer by euler angle vector.

Initialize the quaternion with the euler angle vector.

Parameters

vOrient The euler axis angle vector in radians (phi, tht, psi)

Definition at line 89 of file FGQuaternion.cpp.

                                                  : mCacheValid(false)
 {
   double phi = vOrient(ePhi);
   double tht = vOrient(eTht);
   double psi = vOrient(ePsi);
  
   InitializeFromEulerAngles(phi, tht, psi);
 }

◆ FGQuaternion() [5/7]

FGQuaternion	(	int	idx,
		double	angle
	)

inline

Initializer by one euler angle.

Initialize the quaternion with the single euler angle where its index is given in the first argument.

Parameters

idx	Index of the euler angle to initialize
angle	The euler angle in radians

Definition at line 117 of file FGQuaternion.h.

     : mCacheValid(false) {
  
     double angle2 = 0.5*angle;
  
     double Sangle2 = sin(angle2);
     double Cangle2 = cos(angle2);
  
     if (idx == ePhi) {
       data[0] = Cangle2;
       data[1] = Sangle2;
       data[2] = 0.0;
       data[3] = 0.0;
  
     } else if (idx == eTht) {
       data[0] = Cangle2;
       data[1] = 0.0;
       data[2] = Sangle2;
       data[3] = 0.0;
  
     } else {
       data[0] = Cangle2;
       data[1] = 0.0;
       data[2] = 0.0;
       data[3] = Sangle2;
  
     }
   }

◆ FGQuaternion() [6/7]

FGQuaternion	(	double	angle,
		const FGColumnVector3 &	axis
	)

inline

Initializer by a rotation axis and an angle.

Initialize the quaternion to represent the rotation around a given angle and an arbitrary axis.

Parameters

angle	The angle in radians
axis	The rotation axis

Definition at line 152 of file FGQuaternion.h.

     : mCacheValid(false) {
  
     double angle2 = 0.5 * angle;
  
     double length = axis.Magnitude();
     double Sangle2 = sin(angle2) / length;
     double Cangle2 = cos(angle2);
  
     data[0] = Cangle2;
     data[1] = Sangle2 * axis(1);
     data[2] = Sangle2 * axis(2);
     data[3] = Sangle2 * axis(3);
   }

Here is the call graph for this function:

◆ FGQuaternion() [7/7]

FGQuaternion ( const FGMatrix33 & m )

Initializer by matrix.

Initialize the quaternion with the matrix representing a transform from one frame to another using the standard aerospace sequence, Yaw-Pitch-Roll (3-2-1).

Parameters

m	the rotation matrix

Definition at line 139 of file FGQuaternion.cpp.

                                               : mCacheValid(false)
 {
   data[0] = 0.50*sqrt(1.0 + m(1,1) + m(2,2) + m(3,3));
   double t = 0.25/data[0];
   data[1] = t*(m(2,3) - m(3,2));
   data[2] = t*(m(3,1) - m(1,3));
   data[3] = t*(m(1,2) - m(2,1));
  
   Normalize();
 }

Here is the call graph for this function:

Member Function Documentation

◆ Conjugate()

FGQuaternion Conjugate ( void ) const

inline

Conjugate of the quaternion.

Compute and return the conjugate of the quaternion. This one is equal to the inverse iff the quaternion is normalized.

Definition at line 450 of file FGQuaternion.h.

                                      {
     return FGQuaternion( data[0], -data[1], -data[2], -data[3] );
   }

Here is the call graph for this function:

◆ Entry() [1/2]

double& Entry ( unsigned int idx )

inline

Write access the entries of the vector.

Parameters

idx	the component index.

Return a reference to the vector entry at the given index. Indices are counted starting with 1.

This function is just a shortcut for the double& operator()(unsigned int idx) function. It is used internally to access the elements in a more convenient way.

Note that the index given in the argument is unchecked.

Definition at line 300 of file FGQuaternion.h.

                                   {
     mCacheValid = false;
    return data[idx-1];
   }

◆ Entry() [2/2]

double Entry ( unsigned int idx ) const

inline

Read access the entries of the vector.

Parameters

idx	the component index.

Return the value of the matrix entry at the given index. Indices are counted starting with 1.

This function is just a shortcut for the double operator()(unsigned int idx) const function. It is used internally to access the elements in a more convenient way.

Note that the index given in the argument is unchecked.

Definition at line 285 of file FGQuaternion.h.

285 { return data[idx-1]; }

◆ GetCosEuler()

double GetCosEuler ( int i ) const

inline

Retrieves cosine of the given euler angle.

Returns: the sine of the Euler angle theta (pitch attitude) corresponding to this quaternion rotation.

Definition at line 245 of file FGQuaternion.h.

                                   {
     ComputeDerived();
     return mEulerCosines(i);
   }

Here is the caller graph for this function:

◆ GetEuler() [1/2]

double GetEuler ( int i ) const

inline

Retrieves the Euler angles.

Parameters

i	the Euler angle index. units radians.

Returns: a reference to the i-th euler angles corresponding to this quaternion rotation.

Definition at line 210 of file FGQuaternion.h.

                                {
     ComputeDerived();
     return mEulerAngles(i);
   }

◆ GetEuler() [2/2]

const FGColumnVector3& GetEuler ( void ) const

inline

Retrieves the Euler angles.

Returns: a reference to the triad of Euler angles corresponding to this quaternion rotation. units radians

Definition at line 199 of file FGQuaternion.h.

                                               {
     ComputeDerived();
     return mEulerAngles;
   }

Here is the caller graph for this function:

◆ GetEulerDeg() [1/2]

double GetEulerDeg ( int i ) const

inline

Retrieves the Euler angles.

Parameters

i	the Euler angle index.

Returns: a reference to the i-th euler angles corresponding to this quaternion rotation. units degrees

Definition at line 220 of file FGQuaternion.h.

                                   {
     ComputeDerived();
     return radtodeg*mEulerAngles(i);
   }

Here is the caller graph for this function:

◆ GetEulerDeg() [2/2]

const FGColumnVector3 GetEulerDeg ( void ) const

inline

Retrieves the Euler angle vector.

Returns: an Euler angle column vector corresponding to this quaternion rotation. units degrees

Definition at line 229 of file FGQuaternion.h.

                                                 {
     ComputeDerived();
     return radtodeg*mEulerAngles;
   }

◆ GetQDot()

FGQuaternion GetQDot ( const FGColumnVector3 & PQR ) const

Quaternion derivative for given angular rates.

Returns the derivative of the quaternion corresponding to the angular velocities PQR.

Computes the quaternion derivative which results from the given angular velocities

Parameters

PQR	a constant reference to a rotation rate vector

Returns: the quaternion derivative

See also: Stevens and Lewis, "Aircraft Control and Simulation", Second Edition, Equation 1.3-36.

See Stevens and Lewis, "Aircraft Control and Simulation", Second Edition, Equation 1.3-36. Also see Jack Kuipers, "Quaternions and Rotation Sequences", Equation 11.12.

Definition at line 158 of file FGQuaternion.cpp.

 {
   return FGQuaternion(
     -0.5*( data[1]*PQR(eP) + data[2]*PQR(eQ) + data[3]*PQR(eR)),
      0.5*( data[0]*PQR(eP) - data[3]*PQR(eQ) + data[2]*PQR(eR)),
      0.5*( data[3]*PQR(eP) + data[0]*PQR(eQ) - data[1]*PQR(eR)),
      0.5*(-data[2]*PQR(eP) + data[1]*PQR(eQ) + data[0]*PQR(eR))
   );
 }

Here is the call graph for this function:

◆ GetSinEuler()

double GetSinEuler ( int i ) const

inline

Retrieves sine of the given euler angle.

Returns: the sine of the Euler angle theta (pitch attitude) corresponding to this quaternion rotation.

Definition at line 237 of file FGQuaternion.h.

                                   {
     ComputeDerived();
     return mEulerSines(i);
   }

Here is the caller graph for this function:

◆ GetT()

const FGMatrix33& GetT ( void ) const

inline

Transformation matrix.

Returns: a reference to the transformation/rotation matrix corresponding to this quaternion rotation.

Definition at line 188 of file FGQuaternion.h.

188 { ComputeDerived(); return mT; }

Here is the caller graph for this function:

◆ GetTInv()

const FGMatrix33& GetTInv ( void ) const

inline

Backward transformation matrix.

Returns: a reference to the inverse transformation/rotation matrix corresponding to this quaternion rotation.

Definition at line 193 of file FGQuaternion.h.

193 { ComputeDerived(); return mTInv; }

Here is the caller graph for this function:

◆ Inverse()

FGQuaternion Inverse ( void ) const

inline

Inverse of the quaternion.

Compute and return the inverse of the quaternion so that the orientation represented with *this multiplied with the returned value is equal to the identity orientation.

Definition at line 436 of file FGQuaternion.h.

                                    {
     double norm = SqrMagnitude();
     if (norm == 0.0)
       return *this;
     double rNorm = 1.0/norm;
     return FGQuaternion( data[0]*rNorm, -data[1]*rNorm,
                          -data[2]*rNorm, -data[3]*rNorm );
   }

Here is the call graph for this function:

◆ Magnitude()

double Magnitude ( void ) const

inline

Length of the vector.

Compute and return the euclidean norm of this vector.

Definition at line 460 of file FGQuaternion.h.

460 { return sqrt(SqrMagnitude()); }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Normalize()

void Normalize ( void )

Normalize.

Normalize the vector to have the Magnitude() == 1.0. If the vector is equal to zero it is left untouched.

Definition at line 170 of file FGQuaternion.cpp.

 {
   // Note: this does not touch the cache since it does not change the orientation
   double norm = Magnitude();
   if (norm == 0.0 || fabs(norm - 1.000) < 1e-10) return;
  
   double rnorm = 1.0/norm;
  
   data[0] *= rnorm;
   data[1] *= rnorm;
   data[2] *= rnorm;
   data[3] *= rnorm;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ operator!=()

bool operator!= ( const FGQuaternion & q ) const

inline

Comparison operator "!=".

Parameters

q	a quaternion reference

Returns: true if both quaternions do not represent the same rotation.

Definition at line 343 of file FGQuaternion.h.

343 { return ! operator==(q); }

Here is the call graph for this function:

◆ operator()() [1/2]

double& operator() ( unsigned int idx )

inline

Write access the entries of the vector.

Parameters

idx	the component index.

Return a reference to the vector entry at the given index. Indices are counted starting with 1.

Note that the index given in the argument is unchecked.

Definition at line 270 of file FGQuaternion.h.

270 { mCacheValid = false; return data[idx-1]; }

◆ operator()() [2/2]

double operator() ( unsigned int idx ) const

inline

Read access the entries of the vector.

Parameters

idx	the component index.

Return the value of the matrix entry at the given index. Indices are counted starting with 1.

Note that the index given in the argument is unchecked.

Definition at line 259 of file FGQuaternion.h.

259 { return data[idx-1]; }

◆ operator*()

FGQuaternion operator* ( const FGQuaternion & q ) const

inline

Arithmetic operator "*".

Multiplication of two quaternions is like performing successive rotations.

Parameters

q	a quaternion to be multiplied.

Returns: a quaternion representing Q, where Q = Q * q.

Definition at line 406 of file FGQuaternion.h.

                                                       {
     return FGQuaternion(data[0]*q.data[0]-data[1]*q.data[1]-data[2]*q.data[2]-data[3]*q.data[3],
                         data[0]*q.data[1]+data[1]*q.data[0]+data[2]*q.data[3]-data[3]*q.data[2],
                         data[0]*q.data[2]-data[1]*q.data[3]+data[2]*q.data[0]+data[3]*q.data[1],
                         data[0]*q.data[3]+data[1]*q.data[2]-data[2]*q.data[1]+data[3]*q.data[0]);
   }

Here is the call graph for this function:

◆ operator*=() [1/2]

const FGQuaternion& operator*= ( const FGQuaternion & q )

inline

Arithmetic operator "*=".

Multiplication of two quaternions is like performing successive rotations.

Parameters

q	a quaternion to be multiplied.

Returns: a quaternion reference representing Q, where Q = Q * q.

Definition at line 417 of file FGQuaternion.h.

                                                         {
     double q0 = data[0]*q.data[0]-data[1]*q.data[1]-data[2]*q.data[2]-data[3]*q.data[3];
     double q1 = data[0]*q.data[1]+data[1]*q.data[0]+data[2]*q.data[3]-data[3]*q.data[2];
     double q2 = data[0]*q.data[2]-data[1]*q.data[3]+data[2]*q.data[0]+data[3]*q.data[1];
     double q3 = data[0]*q.data[3]+data[1]*q.data[2]-data[2]*q.data[1]+data[3]*q.data[0];
     data[0] = q0;
     data[1] = q1;
     data[2] = q2;
     data[3] = q3;
     mCacheValid = false;
     return *this;
   }

◆ operator*=() [2/2]

const FGQuaternion& operator*= ( double scalar )

inline

Arithmetic operator "*=".

Parameters

scalar a multiplicative value.

Returns: a quaternion reference representing Q, where Q = Q * scalar.

Definition at line 370 of file FGQuaternion.h.

                                                 {
     data[0] *= scalar;
     data[1] *= scalar;
     data[2] *= scalar;
     data[3] *= scalar;
     mCacheValid = false;
     return *this;
   }

Here is the caller graph for this function:

◆ operator+()

FGQuaternion operator+ ( const FGQuaternion & q ) const

inline

Arithmetic operator "+".

Parameters

q	a quaternion to be summed.

Returns: a quaternion representing Q, where Q = Q + q.

Definition at line 389 of file FGQuaternion.h.

                                                       {
     return FGQuaternion(data[0]+q.data[0], data[1]+q.data[1],
                         data[2]+q.data[2], data[3]+q.data[3]);
   }

Here is the call graph for this function:

◆ operator-()

FGQuaternion operator- ( const FGQuaternion & q ) const

inline

Arithmetic operator "-".

Parameters

q	a quaternion to be subtracted.

Returns: a quaternion representing Q, where Q = Q - q.

Definition at line 397 of file FGQuaternion.h.

                                                       {
     return FGQuaternion(data[0]-q.data[0], data[1]-q.data[1],
                         data[2]-q.data[2], data[3]-q.data[3]);
   }

Here is the call graph for this function:

◆ operator-=()

const FGQuaternion& operator-= ( const FGQuaternion & q )

inline

Arithmetic operator "-=".

Parameters

q	a quaternion reference.

Returns: a quaternion reference representing Q, where Q = Q - q.

Definition at line 357 of file FGQuaternion.h.

                                                         {
     // Copy the master values ...
     data[0] -= q.data[0];
     data[1] -= q.data[1];
     data[2] -= q.data[2];
     data[3] -= q.data[3];
     mCacheValid = false;
     return *this;
   }

◆ operator/=()

const FGQuaternion& operator/= ( double scalar )

inline

Arithmetic operator "/=".

Parameters

scalar a divisor value.

Returns: a quaternion reference representing Q, where Q = Q / scalar.

Definition at line 382 of file FGQuaternion.h.

                                                 {
     return operator*=(1.0/scalar);
   }

Here is the call graph for this function:

◆ operator=()

const FGQuaternion& operator= ( const FGQuaternion & q )

inline

Assignment operator "=".

Assign the value of q to the current object. Cached values are conserved.

Parameters

q	reference to an FGQuaternion instance

Returns: reference to a quaternion object

Definition at line 310 of file FGQuaternion.h.

                                                        {
     // Copy the master values ...
     data[0] = q.data[0];
     data[1] = q.data[1];
     data[2] = q.data[2];
     data[3] = q.data[3];
     ComputeDerived();
     // .. and copy the derived values if they are valid
     mCacheValid = q.mCacheValid;
     if (mCacheValid) {
         mT = q.mT;
         mTInv = q.mTInv;
         mEulerAngles = q.mEulerAngles;
         mEulerSines = q.mEulerSines;
         mEulerCosines = q.mEulerCosines;
     }
     return *this;
   }

◆ operator==()

bool operator== ( const FGQuaternion & q ) const

inline

Comparison operator "==".

Parameters

q	a quaternion reference

Returns: true if both quaternions represent the same rotation.

Definition at line 335 of file FGQuaternion.h.

                                                {
     return data[0] == q.data[0] && data[1] == q.data[1]
       && data[2] == q.data[2] && data[3] == q.data[3];
   }

Here is the caller graph for this function:

◆ SqrMagnitude()

double SqrMagnitude ( void ) const

inline

Square of the length of the vector.

Compute and return the square of the euclidean norm of this vector.

Definition at line 466 of file FGQuaternion.h.

                                   {
     return  data[0]*data[0] + data[1]*data[1]
           + data[2]*data[2] + data[3]*data[3];
   }

Here is the caller graph for this function:

◆ zero()

static FGQuaternion zero ( void )

inlinestatic

Zero quaternion vector.

Does not represent any orientation. Useful for initialization of increments

Definition at line 480 of file FGQuaternion.h.

480 { return FGQuaternion( 0.0, 0.0, 0.0, 0.0 ); }

Here is the call graph for this function:

Friends And Related Function Documentation

◆ operator*

FGQuaternion operator*	(	double	scalar,
		const FGQuaternion &	q
	)

friend

Scalar multiplication.

Parameters

scalar	scalar value to multiply with.
q	Vector to multiply.

Multiply the Vector with a scalar value.

Definition at line 539 of file FGQuaternion.h.

                                                                     {
   return FGQuaternion(scalar*q.data[0], scalar*q.data[1], scalar*q.data[2], scalar*q.data[3]);
 }

◆ QExp

FGQuaternion QExp ( const FGColumnVector3 & omega )

friend

Quaternion exponential.

Parameters

omega rotation velocity Calculate the unit quaternion which is the result of the exponentiation of the vector 'omega'.

Definition at line 548 of file FGQuaternion.h.

                                                        {
   FGQuaternion qexp;
   double angle = omega.Magnitude();
   double sina_a = angle > 0.0 ? sin(angle)/angle : 1.0;
  
   qexp.data[0] = cos(angle);
   qexp.data[1] = omega(1) * sina_a;
   qexp.data[2] = omega(2) * sina_a;
   qexp.data[3] = omega(3) * sina_a;
  
   return qexp;
 }

The documentation for this class was generated from the following files:

Detailed Description

Public Member Functions

Static Public Member Functions

Friends

Additional Inherited Members

Constructor & Destructor Documentation

◆ FGQuaternion() [1/7]

◆ FGQuaternion() [2/7]

◆ FGQuaternion() [3/7]

◆ FGQuaternion() [4/7]

◆ FGQuaternion() [5/7]

◆ FGQuaternion() [6/7]

◆ FGQuaternion() [7/7]

Member Function Documentation

◆ Conjugate()

◆ Entry() [1/2]

◆ Entry() [2/2]

◆ GetCosEuler()

◆ GetEuler() [1/2]

◆ GetEuler() [2/2]

◆ GetEulerDeg() [1/2]

◆ GetEulerDeg() [2/2]

◆ GetQDot()

◆ GetSinEuler()

◆ GetT()

◆ GetTInv()

◆ Inverse()

◆ Magnitude()

◆ Normalize()

◆ operator!=()

◆ operator()() [1/2]

◆ operator()() [2/2]

◆ operator*()

◆ operator*=() [1/2]

◆ operator*=() [2/2]

◆ operator+()

◆ operator-()

◆ operator-=()

◆ operator/=()

◆ operator=()

◆ operator==()

◆ SqrMagnitude()

◆ zero()

Friends And Related Function Documentation

◆ operator*

◆ QExp