Eigen::QuaternionBase< Derived > Class Template Reference

Base class for quaternion expressions. More...

#include <Quaternion.h>

Inheritance diagram for Eigen::QuaternionBase< Derived >:

Public Types
enum	{ Flags = Eigen::internal::traits<Derived>::Flags }
typedef RotationBase< Derived, 3 >	Base
typedef internal::traits< Derived >::Scalar	Scalar
typedef NumTraits< Scalar >::Real	RealScalar
typedef internal::traits< Derived >::Coefficients	Coefficients
typedef Coefficients::CoeffReturnType	CoeffReturnType
typedef std::conditional_t< bool(internal::traits< Derived >::Flags &LvalueBit), Scalar &, CoeffReturnType >	NonConstCoeffReturnType
typedef Matrix< Scalar, 3, 1 >	Vector3
typedef Matrix< Scalar, 3, 3 >	Matrix3
typedef AngleAxis< Scalar >	AngleAxisType
Public Types inherited from Eigen::RotationBase< Derived, 3 >
enum
typedef internal::traits< Derived >::Scalar	Scalar
typedef Matrix< Scalar, Dim, Dim >	RotationMatrixType
typedef Matrix< Scalar, Dim, 1 >	VectorType

Public Member Functions
EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR CoeffReturnType	x () const
EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR CoeffReturnType	y () const
EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR CoeffReturnType	z () const
EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR CoeffReturnType	w () const
EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR NonConstCoeffReturnType	x ()
EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR NonConstCoeffReturnType	y ()
EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR NonConstCoeffReturnType	z ()
EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR NonConstCoeffReturnType	w ()
EIGEN_DEVICE_FUNC const VectorBlock< const Coefficients, 3 >	vec () const
EIGEN_DEVICE_FUNC VectorBlock< Coefficients, 3 >	vec ()
EIGEN_DEVICE_FUNC const internal::traits< Derived >::Coefficients &	coeffs () const
EIGEN_DEVICE_FUNC internal::traits< Derived >::Coefficients &	coeffs ()
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE QuaternionBase< Derived > &	operator= (const QuaternionBase< Derived > &other)
template<class OtherDerived >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived &	operator= (const QuaternionBase< OtherDerived > &other)
EIGEN_DEVICE_FUNC Derived &	operator= (const AngleAxisType &aa)
template<class OtherDerived >
EIGEN_DEVICE_FUNC Derived &	operator= (const MatrixBase< OtherDerived > &m)
EIGEN_DEVICE_FUNC QuaternionBase &	setIdentity ()
EIGEN_DEVICE_FUNC Scalar	squaredNorm () const
EIGEN_DEVICE_FUNC Scalar	norm () const
EIGEN_DEVICE_FUNC void	normalize ()
EIGEN_DEVICE_FUNC Quaternion< Scalar >	normalized () const
template<class OtherDerived >
EIGEN_DEVICE_FUNC Scalar	dot (const QuaternionBase< OtherDerived > &other) const
template<class OtherDerived >
EIGEN_DEVICE_FUNC Scalar	angularDistance (const QuaternionBase< OtherDerived > &other) const
EIGEN_DEVICE_FUNC Matrix3	toRotationMatrix () const
template<typename Derived1 , typename Derived2 >
EIGEN_DEVICE_FUNC Derived &	setFromTwoVectors (const MatrixBase< Derived1 > &a, const MatrixBase< Derived2 > &b)
template<class OtherDerived >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Quaternion< Scalar >	operator* (const QuaternionBase< OtherDerived > &q) const
template<class OtherDerived >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived &	operator*= (const QuaternionBase< OtherDerived > &q)
EIGEN_DEVICE_FUNC Quaternion< Scalar >	inverse () const
EIGEN_DEVICE_FUNC Quaternion< Scalar >	conjugate () const
template<class OtherDerived >
EIGEN_DEVICE_FUNC Quaternion< Scalar >	slerp (const Scalar &t, const QuaternionBase< OtherDerived > &other) const
template<class OtherDerived >
EIGEN_DEVICE_FUNC bool	operator== (const QuaternionBase< OtherDerived > &other) const
template<class OtherDerived >
EIGEN_DEVICE_FUNC bool	operator!= (const QuaternionBase< OtherDerived > &other) const
template<class OtherDerived >
EIGEN_DEVICE_FUNC bool	isApprox (const QuaternionBase< OtherDerived > &other, const RealScalar &prec=NumTraits< Scalar >::dummy_precision()) const
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Vector3	_transformVector (const Vector3 &v) const
template<typename NewScalarType >
EIGEN_DEVICE_FUNC std::enable_if_t< internal::is_same< Scalar, NewScalarType >::value, const Derived & >	cast () const
template<typename NewScalarType >
EIGEN_DEVICE_FUNC std::enable_if_t<!internal::is_same< Scalar, NewScalarType >::value, Quaternion< NewScalarType > >	cast () const
template<class OtherDerived >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Quaternion< typename internal::traits< Derived >::Scalar >	operator* (const QuaternionBase< OtherDerived > &other) const
template<class MatrixDerived >
EIGEN_DEVICE_FUNC Derived &	operator= (const MatrixBase< MatrixDerived > &xpr)
template<class OtherDerived >
EIGEN_DEVICE_FUNC internal::traits< Derived >::Scalar	angularDistance (const QuaternionBase< OtherDerived > &other) const
template<class OtherDerived >
EIGEN_DEVICE_FUNC Quaternion< typename internal::traits< Derived >::Scalar >	slerp (const Scalar &t, const QuaternionBase< OtherDerived > &other) const
Public Member Functions inherited from Eigen::RotationBase< Derived, 3 >
EIGEN_DEVICE_FUNC const Derived &	derived () const
EIGEN_DEVICE_FUNC Derived &	derived ()
EIGEN_DEVICE_FUNC RotationMatrixType	toRotationMatrix () const
EIGEN_DEVICE_FUNC RotationMatrixType	matrix () const
EIGEN_DEVICE_FUNC Derived	inverse () const
EIGEN_DEVICE_FUNC Transform< Scalar, Dim, Isometry >	operator* (const Translation< Scalar, Dim > &t) const
EIGEN_DEVICE_FUNC RotationMatrixType	operator* (const UniformScaling< Scalar > &s) const
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE internal::rotation_base_generic_product_selector< Derived, OtherDerived, OtherDerived::IsVectorAtCompileTime >::ReturnType	operator* (const EigenBase< OtherDerived > &e) const
EIGEN_DEVICE_FUNC Transform< Scalar, Dim, Mode >	operator* (const Transform< Scalar, Dim, Mode, Options > &t) const
EIGEN_DEVICE_FUNC VectorType	_transformVector (const OtherVectorType &v) const

Static Public Member Functions
static EIGEN_DEVICE_FUNC Quaternion< Scalar >	Identity ()

Friends
std::ostream &	operator<< (std::ostream &s, const QuaternionBase< Derived > &q)

Detailed Description

template<class Derived>
class Eigen::QuaternionBase< Derived >

Base class for quaternion expressions.

\geometry_module

Template Parameters

Derived

derived type (CRTP)

See also

class Quaternion

Member Typedef Documentation

AngleAxisType

template<class Derived >

typedef AngleAxis<Scalar> Eigen::QuaternionBase< Derived >::AngleAxisType

the equivalent angle-axis type

Base

template<class Derived >

typedef RotationBase<Derived, 3> Eigen::QuaternionBase< Derived >::Base

Coefficients

template<class Derived >

typedef internal::traits<Derived>::Coefficients Eigen::QuaternionBase< Derived >::Coefficients

CoeffReturnType

template<class Derived >

typedef Coefficients::CoeffReturnType Eigen::QuaternionBase< Derived >::CoeffReturnType

Matrix3

template<class Derived >

typedef Matrix<Scalar, 3, 3> Eigen::QuaternionBase< Derived >::Matrix3

the equivalent rotation matrix type

NonConstCoeffReturnType

template<class Derived >

typedef std::conditional_t<bool(internal::traits<Derived>::Flags& LvalueBit), Scalar&, CoeffReturnType> Eigen::QuaternionBase< Derived >::NonConstCoeffReturnType

RealScalar

template<class Derived >

typedef NumTraits<Scalar>::Real Eigen::QuaternionBase< Derived >::RealScalar

Scalar

template<class Derived >

typedef internal::traits<Derived>::Scalar Eigen::QuaternionBase< Derived >::Scalar

Vector3

template<class Derived >

typedef Matrix<Scalar, 3, 1> Eigen::QuaternionBase< Derived >::Vector3

the type of a 3D vector

Member Enumeration Documentation

anonymous enum

template<class Derived >

anonymous enum

Enumerator
Flags

{ Flags = Eigen::internal::traits<Derived>::Flags };

Member Function Documentation

_transformVector()

template<class Derived >

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE QuaternionBase< Derived >::Vector3 Eigen::QuaternionBase< Derived >::_transformVector

(

const Vector3 &

v

)

const

return the result vector of v through the rotation

Rotation of a vector by a quaternion.

Remarks

If the quaternion is used to rotate several points (>1) then it is much more efficient to first convert it to a 3x3 Matrix. Comparison of the operation cost for n transformations:

• Quaternion2: 30n
• Via a Matrix3: 24 + 15n

                                                                {
  // Note that this algorithm comes from the optimization by hand
  // of the conversion to a Matrix followed by a Matrix/Vector product.
  // It appears to be much faster than the common algorithm found
  // in the literature (30 versus 39 flops). It also requires two
  // Vector3 as temporaries.
  Vector3 uv = this->vec().cross(v);
  uv += uv;
  return v + this->w() * uv + this->vec().cross(uv);
}

References v, and w.

angularDistance() [1/2]

template<class Derived >

template<class OtherDerived >

EIGEN_DEVICE_FUNC Scalar Eigen::QuaternionBase< Derived >::angularDistance

(

const QuaternionBase< OtherDerived > &

other

)

const

angularDistance() [2/2]

template<class Derived >

template<class OtherDerived >

EIGEN_DEVICE_FUNC internal::traits<Derived>::Scalar Eigen::QuaternionBase< Derived >::angularDistance ( const QuaternionBase< OtherDerived > &  other ) const

inline

Returns

the angle (in radian) between two rotations

See also

dot()

                                                     {
  EIGEN_USING_STD(atan2)
  Quaternion<Scalar> d = (*this) * other.conjugate();
  return Scalar(2) * atan2(d.vec().norm(), numext::abs(d.w()));
}

References Eigen::numext::abs(), Eigen::atan2(), Eigen::QuaternionBase< Derived >::conjugate(), EIGEN_USING_STD, Eigen::QuaternionBase< Derived >::vec(), and Eigen::QuaternionBase< Derived >::w().

cast() [1/2]

template<class Derived >

template<typename NewScalarType >

EIGEN_DEVICE_FUNC std::enable_if_t<internal::is_same<Scalar, NewScalarType>::value, const Derived&> Eigen::QuaternionBase< Derived >::cast ( ) const

inline

            {
    return derived();
  }

References Eigen::RotationBase< Derived, 3 >::derived().

cast() [2/2]

template<class Derived >

template<typename NewScalarType >

EIGEN_DEVICE_FUNC std::enable_if_t<!internal::is_same<Scalar, NewScalarType>::value, Quaternion<NewScalarType> > Eigen::QuaternionBase< Derived >::cast ( ) const

inline

               {
    return Quaternion<NewScalarType>(coeffs().template cast<NewScalarType>());
  }

References Eigen::QuaternionBase< Derived >::coeffs().

coeffs() [1/2]

template<class Derived >

EIGEN_DEVICE_FUNC internal::traits<Derived>::Coefficients& Eigen::QuaternionBase< Derived >::coeffs ( )

inline

Returns

a vector expression of the coefficients (x,y,z,w)

{ return derived().coeffs(); }

References Eigen::RotationBase< Derived, 3 >::derived().

coeffs() [2/2]

template<class Derived >

EIGEN_DEVICE_FUNC const internal::traits<Derived>::Coefficients& Eigen::QuaternionBase< Derived >::coeffs ( ) const

inline

Returns

a read-only vector expression of the coefficients (x,y,z,w)

                                                                                              {
    return derived().coeffs();
  }

References Eigen::RotationBase< Derived, 3 >::derived().

Referenced by Eigen::QuaternionBase< Derived >::cast(), Eigen::QuaternionBase< Derived >::dot(), Eigen::QuaternionBase< Derived >::isApprox(), Eigen::QuaternionBase< Derived >::norm(), Eigen::QuaternionBase< Derived >::normalize(), Eigen::QuaternionBase< Derived >::normalized(), Eigen::QuaternionBase< Derived >::operator!=(), Eigen::QuaternionBase< Derived >::operator=(), Eigen::QuaternionBase< Derived >::operator==(), Eigen::internal::quat_product< Architecture::Target, Derived, OtherDerived, float >::run(), Eigen::QuaternionBase< Derived >::setIdentity(), Eigen::QuaternionBase< Derived >::slerp(), Eigen::QuaternionBase< Derived >::squaredNorm(), and Eigen::QuaternionBase< Derived >::vec().

conjugate()

template<class Derived >

EIGEN_DEVICE_FUNC Quaternion< typename internal::traits< Derived >::Scalar > Eigen::QuaternionBase< Derived >::conjugate ( void  ) const

inline

Returns

the conjugated quaternion

the conjugate of the *this which is equal to the multiplicative inverse if the quaternion is normalized. The conjugate of a quaternion represents the opposite rotation.

See also

Quaternion2::inverse()

          {
  return internal::quat_conj<Architecture::Target, Derived, typename internal::traits<Derived>::Scalar>::run(*this);
}

References Eigen::run().

Referenced by Eigen::QuaternionBase< Derived >::angularDistance().

dot()

template<class Derived >

template<class OtherDerived >

EIGEN_DEVICE_FUNC Scalar Eigen::QuaternionBase< Derived >::dot ( const QuaternionBase< OtherDerived > &  other ) const

inline

Returns

the dot product of *this and other Geometrically speaking, the dot product of two unit quaternions corresponds to the cosine of half the angle between the two rotations.

See also

angularDistance()

                                                                                       {
    return coeffs().dot(other.coeffs());
  }

References Eigen::QuaternionBase< Derived >::coeffs().

Identity()

template<class Derived >

static EIGEN_DEVICE_FUNC Quaternion<Scalar> Eigen::QuaternionBase< Derived >::Identity ( )

inlinestatic

Returns

a quaternion representing an identity rotation

See also

MatrixBase::Identity()

                                                                {
    return Quaternion<Scalar>(Scalar(1), Scalar(0), Scalar(0), Scalar(0));
  }

inverse()

template<class Derived >

EIGEN_DEVICE_FUNC Quaternion< typename internal::traits< Derived >::Scalar > Eigen::QuaternionBase< Derived >::inverse

inline

Returns

the quaternion describing the inverse rotation

the multiplicative inverse of *this Note that in most cases, i.e., if you simply want the opposite rotation, and/or the quaternion is normalized, then it is enough to use the conjugate.

See also

QuaternionBase::conjugate()

          {
  // FIXME should this function be called multiplicativeInverse and conjugate() be called inverse() or opposite()  ??
  Scalar n2 = this->squaredNorm();
  if (n2 > Scalar(0))
    return Quaternion<Scalar>(conjugate().coeffs() / n2);
  else {
    // return an invalid result to flag the error
    return Quaternion<Scalar>(Coefficients::Zero());
  }
}

References oomph::PseudoSolidHelper::Zero.

isApprox()

template<class Derived >

template<class OtherDerived >

EIGEN_DEVICE_FUNC bool Eigen::QuaternionBase< Derived >::isApprox ( const QuaternionBase< OtherDerived > &  other, const RealScalar &  prec = NumTraits<Scalar>::dummy_precision()  ) const

inline

Returns

true if *this is approximately equal to other, within the precision determined by prec.

See also

MatrixBase::isApprox()

                                                                                                     {
    return coeffs().isApprox(other.coeffs(), prec);
  }

References Eigen::QuaternionBase< Derived >::coeffs().

norm()

template<class Derived >

EIGEN_DEVICE_FUNC Scalar Eigen::QuaternionBase< Derived >::norm ( ) const

inline

Returns

the norm of the quaternion's coefficients

See also

QuaternionBase::squaredNorm(), MatrixBase::norm()

{ return coeffs().norm(); }

References Eigen::QuaternionBase< Derived >::coeffs().

normalize()

template<class Derived >

EIGEN_DEVICE_FUNC void Eigen::QuaternionBase< Derived >::normalize ( void  )

inline

Normalizes the quaternion *this

See also

normalized(), MatrixBase::normalize()

{ coeffs().normalize(); }

References Eigen::QuaternionBase< Derived >::coeffs().

normalized()

template<class Derived >

EIGEN_DEVICE_FUNC Quaternion<Scalar> Eigen::QuaternionBase< Derived >::normalized ( ) const

inline

Returns

a normalized copy of *this

See also

normalize(), MatrixBase::normalized()

{ return Quaternion<Scalar>(coeffs().normalized()); }

References Eigen::QuaternionBase< Derived >::coeffs(), and Eigen::QuaternionBase< Derived >::normalized().

Referenced by Eigen::QuaternionBase< Derived >::normalized().

operator!=()

template<class Derived >

template<class OtherDerived >

EIGEN_DEVICE_FUNC bool Eigen::QuaternionBase< Derived >::operator!= ( const QuaternionBase< OtherDerived > &  other ) const

inline

Returns

true if at least one pair of coefficients of *this and other are not exactly equal to each other.

Warning

When using floating point scalar values you probably should rather use a fuzzy comparison such as isApprox()

See also

isApprox(), operator==

                                                                                            {
    return coeffs() != other.coeffs();
  }

References Eigen::QuaternionBase< Derived >::coeffs().

operator*() [1/2]

template<class Derived >

template<class OtherDerived >

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Quaternion<typename internal::traits<Derived>::Scalar> Eigen::QuaternionBase< Derived >::operator*

(

const QuaternionBase< OtherDerived > &

other

)

const

Returns

the concatenation of two rotations as a quaternion-quaternion product

                                                                                  {
  EIGEN_STATIC_ASSERT(
      (internal::is_same<typename Derived::Scalar, typename OtherDerived::Scalar>::value),
      YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
  return internal::quat_product<Architecture::Target, Derived, OtherDerived,
                                typename internal::traits<Derived>::Scalar>::run(*this, other);
}

References EIGEN_STATIC_ASSERT, Eigen::run(), and Eigen::Architecture::Target.

operator*() [2/2]

template<class Derived >

template<class OtherDerived >

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Quaternion<Scalar> Eigen::QuaternionBase< Derived >::operator*

(

const QuaternionBase< OtherDerived > &

q

)

const

operator*=()

template<class Derived >

template<class OtherDerived >

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived & Eigen::QuaternionBase< Derived >::operator*=

(

const QuaternionBase< OtherDerived > &

other

)

See also

operator*(Quaternion)

                                               {
  derived() = derived() * other.derived();
  return derived();
}

References Eigen::RotationBase< Derived, Dim_ >::derived().

operator=() [1/5]

template<class Derived >

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived & Eigen::QuaternionBase< Derived >::operator=

(

const AngleAxisType &

aa

)

Set *this from an angle-axis aa and returns a reference to *this

                                                                                                         {
  EIGEN_USING_STD(cos)
  EIGEN_USING_STD(sin)
  Scalar ha = Scalar(0.5) * aa.angle();  // Scalar(0.5) to suppress precision loss warnings
  this->w() = cos(ha);
  this->vec() = sin(ha) * aa.axis();
  return derived();
}

References Eigen::AngleAxis< Scalar_ >::angle(), Eigen::AngleAxis< Scalar_ >::axis(), cos(), EIGEN_USING_STD, sin(), and w.

operator=() [2/5]

template<class Derived >

template<class MatrixDerived >

EIGEN_DEVICE_FUNC Derived& Eigen::QuaternionBase< Derived >::operator= ( const MatrixBase< MatrixDerived > &  xpr )

inline

Set *this from the expression xpr:

• if xpr is a 4x1 vector, then xpr is assumed to be a quaternion
• if xpr is a 3x3 matrix, then xpr is assumed to be rotation matrix and xpr is converted to a quaternion

                                                                                                         {
  EIGEN_STATIC_ASSERT(
      (internal::is_same<typename Derived::Scalar, typename MatrixDerived::Scalar>::value),
      YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
  internal::quaternionbase_assign_impl<MatrixDerived>::run(*this, xpr.derived());
  return derived();
}

References EIGEN_STATIC_ASSERT, and run().

operator=() [3/5]

template<class Derived >

template<class OtherDerived >

EIGEN_DEVICE_FUNC Derived& Eigen::QuaternionBase< Derived >::operator=

(

const MatrixBase< OtherDerived > &

m

)

operator=() [4/5]

template<class Derived >

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE QuaternionBase< Derived > & Eigen::QuaternionBase< Derived >::operator=

(

const QuaternionBase< Derived > &

other

)

                                          {
  coeffs() = other.coeffs();
  return derived();
}

References Eigen::QuaternionBase< Derived >::coeffs().

operator=() [5/5]

template<class Derived >

template<class OtherDerived >

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived & Eigen::QuaternionBase< Derived >::operator=

(

const QuaternionBase< OtherDerived > &

other

)

                                               {
  coeffs() = other.coeffs();
  return derived();
}

References Eigen::QuaternionBase< Derived >::coeffs().

operator==()

template<class Derived >

template<class OtherDerived >

EIGEN_DEVICE_FUNC bool Eigen::QuaternionBase< Derived >::operator== ( const QuaternionBase< OtherDerived > &  other ) const

inline

Returns

true if each coefficients of *this and other are all exactly equal.

Warning

When using floating point scalar values you probably should rather use a fuzzy comparison such as isApprox()

See also

isApprox(), operator!=

                                                                                            {
    return coeffs() == other.coeffs();
  }

References Eigen::QuaternionBase< Derived >::coeffs().

setFromTwoVectors()

template<class Derived >

template<typename Derived1 , typename Derived2 >

EIGEN_DEVICE_FUNC Derived & Eigen::QuaternionBase< Derived >::setFromTwoVectors ( const MatrixBase< Derived1 > &  a, const MatrixBase< Derived2 > &  b  )

inline

Returns

the quaternion which transform a into b through a rotation

Sets *this to be a quaternion representing a rotation between the two arbitrary vectors a and b. In other words, the built rotation represent a rotation sending the line of direction a to the line of direction b, both lines passing through the origin.

Returns

a reference to *this.

Note that the two input vectors do not have to be normalized, and do not need to have the same norm.

                                                                                                            {
  EIGEN_USING_STD(sqrt)
  Vector3 v0 = a.normalized();
  Vector3 v1 = b.normalized();
  Scalar c = v1.dot(v0);
 
  // if dot == -1, vectors are nearly opposites
  // => accurately compute the rotation axis by computing the
  //    intersection of the two planes. This is done by solving:
  //       x^T v0 = 0
  //       x^T v1 = 0
  //    under the constraint:
  //       ||x|| = 1
  //    which yields a singular value problem
  if (c < Scalar(-1) + NumTraits<Scalar>::dummy_precision()) {
    c = numext::maxi(c, Scalar(-1));
    Matrix<Scalar, 2, 3> m;
    m << v0.transpose(), v1.transpose();
    JacobiSVD<Matrix<Scalar, 2, 3>, ComputeFullV> svd(m);
    Vector3 axis = svd.matrixV().col(2);
 
    Scalar w2 = (Scalar(1) + c) * Scalar(0.5);
    this->w() = sqrt(w2);
    this->vec() = axis * sqrt(Scalar(1) - w2);
    return derived();
  }
  Vector3 axis = v0.cross(v1);
  Scalar s = sqrt((Scalar(1) + c) * Scalar(2));
  Scalar invs = Scalar(1) / s;
  this->vec() = axis * invs;
  this->w() = s * Scalar(0.5);
 
  return derived();
}

References a, b, calibrate::c, Eigen::ComputeFullV, EIGEN_USING_STD, m, Eigen::numext::maxi(), s, sqrt(), svd(), v1(), and w.

Referenced by Eigen::Quaternion< Scalar_, Options_ >::FromTwoVectors().

setIdentity()

template<class Derived >

EIGEN_DEVICE_FUNC QuaternionBase& Eigen::QuaternionBase< Derived >::setIdentity ( )

inline

See also

QuaternionBase::Identity(), MatrixBase::setIdentity()

                                                         {
    coeffs() << Scalar(0), Scalar(0), Scalar(0), Scalar(1);
    return *this;
  }

References Eigen::QuaternionBase< Derived >::coeffs().

Referenced by main().

slerp() [1/2]

template<class Derived >

template<class OtherDerived >

EIGEN_DEVICE_FUNC Quaternion<Scalar> Eigen::QuaternionBase< Derived >::slerp	(	const Scalar &	t,
		const QuaternionBase< OtherDerived > &	other
	)		const

slerp() [2/2]

template<class Derived >

template<class OtherDerived >

EIGEN_DEVICE_FUNC Quaternion<typename internal::traits<Derived>::Scalar> Eigen::QuaternionBase< Derived >::slerp	(	const Scalar &	t,
		const QuaternionBase< OtherDerived > &	other
	)		const

Returns

the spherical linear interpolation between the two quaternions *this and other at the parameter t in [0;1].

This represents an interpolation for a constant motion between *this and other, see also http://en.wikipedia.org/wiki/Slerp.

                                                                      {
  EIGEN_USING_STD(acos)
  EIGEN_USING_STD(sin)
  const Scalar one = Scalar(1) - NumTraits<Scalar>::epsilon();
  Scalar d = this->dot(other);
  Scalar absD = numext::abs(d);
 
  Scalar scale0;
  Scalar scale1;
 
  if (absD >= one) {
    scale0 = Scalar(1) - t;
    scale1 = t;
  } else {
    // theta is the angle between the 2 quaternions
    Scalar theta = acos(absD);
    Scalar sinTheta = sin(theta);
 
    scale0 = sin((Scalar(1) - t) * theta) / sinTheta;
    scale1 = sin((t * theta)) / sinTheta;
  }
  if (d < Scalar(0)) scale1 = -scale1;
 
  return Quaternion<Scalar>(scale0 * coeffs() + scale1 * other.coeffs());
}

References Eigen::numext::abs(), acos(), Eigen::QuaternionBase< Derived >::coeffs(), dot(), EIGEN_USING_STD, oomph::SarahBL::epsilon, sin(), plotPSD::t, and BiharmonicTestFunctions2::theta.

squaredNorm()

template<class Derived >

EIGEN_DEVICE_FUNC Scalar Eigen::QuaternionBase< Derived >::squaredNorm ( ) const

inline

Returns

the squared norm of the quaternion's coefficients

See also

QuaternionBase::norm(), MatrixBase::squaredNorm()

{ return coeffs().squaredNorm(); }

References Eigen::QuaternionBase< Derived >::coeffs().

toRotationMatrix()

template<class Derived >

EIGEN_DEVICE_FUNC QuaternionBase< Derived >::Matrix3 Eigen::QuaternionBase< Derived >::toRotationMatrix ( void  ) const

inline

Returns

an equivalent 3x3 rotation matrix

Convert the quaternion to a 3x3 rotation matrix. The quaternion is required to be normalized, otherwise the result is undefined.

                {
  // NOTE if inlined, then gcc 4.2 and 4.4 get rid of the temporary (not gcc 4.3 !!)
  // if not inlined then the cost of the return by value is huge ~ +35%,
  // however, not inlining this function is an order of magnitude slower, so
  // it has to be inlined, and so the return by value is not an issue
  Matrix3 res;
 
  const Scalar tx = Scalar(2) * this->x();
  const Scalar ty = Scalar(2) * this->y();
  const Scalar tz = Scalar(2) * this->z();
  const Scalar twx = tx * this->w();
  const Scalar twy = ty * this->w();
  const Scalar twz = tz * this->w();
  const Scalar txx = tx * this->x();
  const Scalar txy = ty * this->x();
  const Scalar txz = tz * this->x();
  const Scalar tyy = ty * this->y();
  const Scalar tyz = tz * this->y();
  const Scalar tzz = tz * this->z();
 
  res.coeffRef(0, 0) = Scalar(1) - (tyy + tzz);
  res.coeffRef(0, 1) = txy - twz;
  res.coeffRef(0, 2) = txz + twy;
  res.coeffRef(1, 0) = txy + twz;
  res.coeffRef(1, 1) = Scalar(1) - (txx + tzz);
  res.coeffRef(1, 2) = tyz - twx;
  res.coeffRef(2, 0) = txz - twy;
  res.coeffRef(2, 1) = tyz + twx;
  res.coeffRef(2, 2) = Scalar(1) - (txx + tyy);
 
  return res;
}

References res, w, plotDoE::x, and y.

Referenced by Eigen::EulerAngles< Scalar_, _System >::toRotationMatrix().

vec() [1/2]

template<class Derived >

EIGEN_DEVICE_FUNC VectorBlock<Coefficients, 3> Eigen::QuaternionBase< Derived >::vec ( )

inline

Returns

a vector expression of the imaginary part (x,y,z)

{ return coeffs().template head<3>(); }

References Eigen::QuaternionBase< Derived >::coeffs().

vec() [2/2]

template<class Derived >

EIGEN_DEVICE_FUNC const VectorBlock<const Coefficients, 3> Eigen::QuaternionBase< Derived >::vec ( ) const

inline

Returns

a read-only vector expression of the imaginary part (x,y,z)

{ return coeffs().template head<3>(); }

References Eigen::QuaternionBase< Derived >::coeffs().

Referenced by Eigen::QuaternionBase< Derived >::angularDistance().

w() [1/2]

template<class Derived >

EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR NonConstCoeffReturnType Eigen::QuaternionBase< Derived >::w ( )

inline

Returns

a reference to the w coefficient (if Derived is a non-const lvalue)

{ return this->derived().coeffs().w(); }

References Eigen::RotationBase< Derived, 3 >::derived().

w() [2/2]

template<class Derived >

EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR CoeffReturnType Eigen::QuaternionBase< Derived >::w ( ) const

inline

Returns

the w coefficient

{ return this->derived().coeffs().coeff(3); }

References Eigen::RotationBase< Derived, 3 >::derived().

Referenced by Eigen::QuaternionBase< Derived >::angularDistance().

x() [1/2]

template<class Derived >

EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR NonConstCoeffReturnType Eigen::QuaternionBase< Derived >::x ( )

inline

Returns

a reference to the x coefficient (if Derived is a non-const lvalue)

{ return this->derived().coeffs().x(); }

References Eigen::RotationBase< Derived, 3 >::derived().

x() [2/2]

template<class Derived >

EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR CoeffReturnType Eigen::QuaternionBase< Derived >::x ( ) const

inline

Returns

the x coefficient

{ return this->derived().coeffs().coeff(0); }

References Eigen::RotationBase< Derived, 3 >::derived().

y() [1/2]

template<class Derived >

EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR NonConstCoeffReturnType Eigen::QuaternionBase< Derived >::y ( )

inline

Returns

a reference to the y coefficient (if Derived is a non-const lvalue)

{ return this->derived().coeffs().y(); }

References Eigen::RotationBase< Derived, 3 >::derived().

y() [2/2]

template<class Derived >

EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR CoeffReturnType Eigen::QuaternionBase< Derived >::y ( ) const

inline

Returns

the y coefficient

{ return this->derived().coeffs().coeff(1); }

References Eigen::RotationBase< Derived, 3 >::derived().

z() [1/2]

template<class Derived >

EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR NonConstCoeffReturnType Eigen::QuaternionBase< Derived >::z ( )

inline

Returns

a reference to the z coefficient (if Derived is a non-const lvalue)

{ return this->derived().coeffs().z(); }

References Eigen::RotationBase< Derived, 3 >::derived().

z() [2/2]

template<class Derived >

EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR CoeffReturnType Eigen::QuaternionBase< Derived >::z ( ) const

inline

Returns

the z coefficient

{ return this->derived().coeffs().coeff(2); }

References Eigen::RotationBase< Derived, 3 >::derived().

Friends And Related Function Documentation

operator<<

template<class Derived >

std::ostream& operator<< ( std::ostream &  s, const QuaternionBase< Derived > &  q  )

friend

                                                                                 {
    s << q.x() << "i + " << q.y() << "j + " << q.z() << "k"
      << " + " << q.w();
    return s;
  }

---

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

• ForwardDeclarations.h
• Eigen/Eigen/src/Geometry/Quaternion.h