Quaternion.hh

Go to the documentation of this file.

/*
 * Copyright (C) 2012 Open Source Robotics Foundation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
*/
#ifndef GZ_MATH_QUATERNION_HH_
#define GZ_MATH_QUATERNION_HH_
 
#include <gz/math/Helpers.hh>
#include <gz/math/Angle.hh>
#include <gz/math/Vector3.hh>
#include <gz/math/Matrix3.hh>
#include <gz/math/config.hh>
 
namespace gz::math
{
  // Inline bracket to help doxygen filtering.
  inline namespace GZ_MATH_VERSION_NAMESPACE {
  //
  template <typename T> class Matrix3;
 
  template<typename T>
  class Quaternion
  {
    public: static const Quaternion &Identity;
 
    public: static const Quaternion &Zero;
 
    public: constexpr Quaternion()
    : qw(1), qx(0), qy(0), qz(0)
    {
      // quaternion not normalized, because that breaks
      // Pose::CoordPositionAdd(...)
    }
 
    public: constexpr Quaternion(const T &_w, const T &_x, const T &_y,
                                 const T &_z)
    : qw(_w), qx(_x), qy(_y), qz(_z)
    {}
 
    public: Quaternion(const T &_roll, const T &_pitch, const T &_yaw)
    {
      this->SetFromEuler(Vector3<T>(_roll, _pitch, _yaw));
    }
 
    public: Quaternion(const Vector3<T> &_axis, const T &_angle)
    {
      this->SetFromAxisAngle(_axis, _angle);
    }
 
    public: explicit Quaternion(const Vector3<T> &_rpy)
    {
      this->SetFromEuler(_rpy);
    }
 
    public: explicit Quaternion(const Matrix3<T> &_mat)
    {
      this->SetFromMatrix(_mat);
    }
 
    public: void Invert()
    {
      this->Normalize();
      // this->qw = this->qw;
      this->qx = -this->qx;
      this->qy = -this->qy;
      this->qz = -this->qz;
    }
 
    public: inline Quaternion<T> Inverse() const
    {
      T s = 0;
      Quaternion<T> q(this->qw, this->qx, this->qy, this->qz);
 
      // use s to test if quaternion is valid
      s = q.qw * q.qw + q.qx * q.qx + q.qy * q.qy + q.qz * q.qz;
 
      if (equal<T>(s, static_cast<T>(0)))
      {
        q.qw = 1.0;
        q.qx = 0.0;
        q.qy = 0.0;
        q.qz = 0.0;
      }
      else
      {
        // deal with non-normalized quaternion
        // div by s so q * qinv = identity
        q.qw =  q.qw / s;
        q.qx = -q.qx / s;
        q.qy = -q.qy / s;
        q.qz = -q.qz / s;
      }
      return q;
    }
 
    public: Quaternion<T> Log() const
    {
      Quaternion<T> result;
      result.qw = 0.0;
 
      if (std::abs(this->qw) < 1.0)
      {
        T fAngle = acos(this->qw);
        T fSin = sin(fAngle);
        if (std::abs(fSin) >= 1e-3)
        {
          T fCoeff = fAngle/fSin;
          result.qx = fCoeff*this->qx;
          result.qy = fCoeff*this->qy;
          result.qz = fCoeff*this->qz;
          return result;
        }
      }
 
      result.qx = this->qx;
      result.qy = this->qy;
      result.qz = this->qz;
 
      return result;
    }
 
    public: Quaternion<T> Exp() const
    {
      T fAngle = sqrt(this->qx*this->qx+
          this->qy*this->qy+this->qz*this->qz);
      T fSin = sin(fAngle);
 
      Quaternion<T> result;
      result.qw = cos(fAngle);
 
      if (std::abs(fSin) >= 1e-3)
      {
        T fCoeff = fSin/fAngle;
        result.qx = fCoeff*this->qx;
        result.qy = fCoeff*this->qy;
        result.qz = fCoeff*this->qz;
      }
      else
      {
        result.qx = this->qx;
        result.qy = this->qy;
        result.qz = this->qz;
      }
 
      return result;
    }
 
    public: void Normalize()
    {
      T s = 0;
 
      s = T(sqrt(this->qw * this->qw + this->qx * this->qx +
          this->qy * this->qy + this->qz * this->qz));
 
      if (equal<T>(s, static_cast<T>(0)))
      {
        this->qw = T(1.0);
        this->qx = T(0.0);
        this->qy = T(0.0);
        this->qz = T(0.0);
      }
      else
      {
        this->qw /= s;
        this->qx /= s;
        this->qy /= s;
        this->qz /= s;
      }
    }
 
    public: Quaternion<T> Normalized() const
    {
      Quaternion<T> result = *this;
      result.Normalize();
      return result;
    }
 
    public: void SetFromAxisAngle(T _ax, T _ay, T _az, T _aa)
    {
      T l;
 
      l = _ax * _ax + _ay * _ay + _az * _az;
 
      if (equal<T>(l, static_cast<T>(0)))
      {
        this->qw = 1;
        this->qx = 0;
        this->qy = 0;
        this->qz = 0;
      }
      else
      {
        _aa *= 0.5;
        l = sin(_aa) / sqrt(l);
        this->qw = cos(_aa);
        this->qx = _ax * l;
        this->qy = _ay * l;
        this->qz = _az * l;
      }
 
      this->Normalize();
    }
 
    public: void SetFromAxisAngle(const Vector3<T> &_axis, T _a)
    {
      this->SetFromAxisAngle(_axis.X(), _axis.Y(), _axis.Z(), _a);
    }
 
    public: void Set(T _w, T _x, T _y, T _z)
    {
      this->qw = _w;
      this->qx = _x;
      this->qy = _y;
      this->qz = _z;
    }
 
    public: void SetFromEuler(const Vector3<T> &_vec)
    {
      this->SetFromEuler(_vec.X(), _vec.Y(), _vec.Z());
    }
 
    public: void SetFromEuler(T _roll, T _pitch, T _yaw)
    {
      T phi, the, psi;
 
      phi = _roll / T(2.0);
      the = _pitch / T(2.0);
      psi = _yaw / T(2.0);
 
      this->qw = T(cos(phi) * cos(the) * cos(psi) +
        sin(phi) * sin(the) * sin(psi));
      this->qx = T(sin(phi) * cos(the) * cos(psi) -
        cos(phi) * sin(the) * sin(psi));
      this->qy = T(cos(phi) * sin(the) * cos(psi) +
        sin(phi) * cos(the) * sin(psi));
      this->qz = T(cos(phi) * cos(the) * sin(psi) -
        sin(phi) * sin(the) * cos(psi));
 
      this->Normalize();
    }
 
    public: Vector3<T> Euler() const
    {
      Vector3<T> vec;
 
      T tol = static_cast<T>(1e-15);
 
      Quaternion<T> copy = *this;
      T squ;
      T sqx;
      T sqy;
      T sqz;
 
      copy.Normalize();
 
      squ = copy.qw * copy.qw;
      sqx = copy.qx * copy.qx;
      sqy = copy.qy * copy.qy;
      sqz = copy.qz * copy.qz;
 
      // Pitch
      T sarg = -2 * (copy.qx*copy.qz - copy.qw * copy.qy);
      if (sarg <= T(-1.0))
      {
        vec.Y(T(-0.5*GZ_PI));
      }
      else if (sarg >= T(1.0))
      {
        vec.Y(T(0.5*GZ_PI));
      }
      else
      {
        vec.Y(T(asin(sarg)));
      }
 
      // If the pitch angle is PI/2 or -PI/2, we can only compute
      // the sum roll + yaw.  However, any combination that gives
      // the right sum will produce the correct orientation, so we
      // set yaw = 0 and compute roll.
      // pitch angle is PI/2
      if (std::abs(sarg - 1) < tol)
      {
        vec.Z(0);
        vec.X(T(atan2(2 * (copy.qx*copy.qy - copy.qz*copy.qw),
                    squ - sqx + sqy - sqz)));
      }
      // pitch angle is -PI/2
      else if (std::abs(sarg + 1) < tol)
      {
        vec.Z(0);
        vec.X(T(atan2(-2 * (copy.qx*copy.qy - copy.qz*copy.qw),
                     squ - sqx + sqy - sqz)));
      }
      else
      {
        // Roll
        vec.X(T(atan2(2 * (copy.qy*copy.qz + copy.qw*copy.qx),
                    squ - sqx - sqy + sqz)));
 
        // Yaw
        vec.Z(T(atan2(2 * (copy.qx*copy.qy + copy.qw*copy.qz),
                    squ + sqx - sqy - sqz)));
      }
 
      return vec;
    }
 
    public: static Quaternion<T> EulerToQuaternion(const Vector3<T> &_vec)
    {
      Quaternion<T> result;
      result.SetFromEuler(_vec);
      return result;
    }
 
    public: static Quaternion<T> EulerToQuaternion(T _x, T _y, T _z)
    {
      return EulerToQuaternion(Vector3<T>(_x, _y, _z));
    }
 
    public: T Roll() const
    {
      return this->Euler().X();
    }
 
    public: T Pitch() const
    {
      return this->Euler().Y();
    }
 
    public: T Yaw() const
    {
      return this->Euler().Z();
    }
 
    public: void AxisAngle(Vector3<T> &_axis, T &_angle) const
    {
      T sqLen = this->qx*this->qx + this->qy*this->qy + this->qz*this->qz;
      if (equal<T>(sqLen, static_cast<T>(0), static_cast<T>(1e-12)))
      {
        _angle = 0.0;
        _axis.Set(1, 0, 0);
      }
      else
      {
        _angle = 2.0 * acos(this->qw);
        T invLen =  1.0 / sqrt(sqLen);
        _axis.Set(this->qx*invLen, this->qy*invLen, this->qz*invLen);
      }
    }
 
    public: void SetFromMatrix(const Matrix3<T> &_mat)
    {
      const T trace = _mat(0, 0) + _mat(1, 1) + _mat(2, 2);
      if (trace > 0.0000001)
      {
        qw = sqrt(1 + trace) / 2;
        const T s = 1.0 / (4 * qw);
        qx = (_mat(2, 1) - _mat(1, 2)) * s;
        qy = (_mat(0, 2) - _mat(2, 0)) * s;
        qz = (_mat(1, 0) - _mat(0, 1)) * s;
      }
      else if (_mat(0, 0) > _mat(1, 1) && _mat(0, 0) > _mat(2, 2))
      {
        qx = sqrt(1.0 + _mat(0, 0) - _mat(1, 1) - _mat(2, 2)) / 2;
        const T s = 1.0 / (4 * qx);
        qw = (_mat(2, 1) - _mat(1, 2)) * s;
        qy = (_mat(1, 0) + _mat(0, 1)) * s;
        qz = (_mat(0, 2) + _mat(2, 0)) * s;
      }
      else if (_mat(1, 1) > _mat(2, 2))
      {
        qy = sqrt(1.0 - _mat(0, 0) + _mat(1, 1) - _mat(2, 2)) / 2;
        const T s = 1.0 / (4 * qy);
        qw = (_mat(0, 2) - _mat(2, 0)) * s;
        qx = (_mat(0, 1) + _mat(1, 0)) * s;
        qz = (_mat(1, 2) + _mat(2, 1)) * s;
      }
      else
      {
        qz = sqrt(1.0 - _mat(0, 0) - _mat(1, 1) + _mat(2, 2)) / 2;
        const T s = 1.0 / (4 * qz);
        qw = (_mat(1, 0) - _mat(0, 1)) * s;
        qx = (_mat(0, 2) + _mat(2, 0)) * s;
        qy = (_mat(1, 2) + _mat(2, 1)) * s;
      }
    }
 
    public: void SetFrom2Axes(const Vector3<T> &_v1,
                const Vector3<T> &_v2)
    {
      // generally, we utilize the fact that a quat (w, x, y, z) represents
      // rotation of angle 2*w about axis (x, y, z)
      //
      // so we want to take get a vector half-way between no rotation and the
      // double rotation, which is
      // [ (1, (0, 0, 0)) + (_v1 dot _v2, _v1 x _v2) ] / 2
      // if _v1 and _v2 are unit quaternions
      //
      // since we normalize the result anyway, we can omit the division,
      // getting the result:
      // [ (1, (0, 0, 0)) + (_v1 dot _v2, _v1 x _v2) ].Normalized()
      //
      // if _v1 and _v2 are not normalized, the magnitude (1 + _v1 dot _v2)
      // is multiplied by k = norm(_v1)*norm(_v2)
 
      const T kCosTheta = _v1.Dot(_v2);
      const T k = sqrt(_v1.SquaredLength() * _v2.SquaredLength());
 
      if (fabs(kCosTheta/k + 1) < 1e-6)
      {
        // the vectors are opposite
        // any vector orthogonal to _v1
        Vector3<T> other;
        {
          const Vector3<T> _v1Abs(_v1.Abs());
          if (_v1Abs.X() < _v1Abs.Y())
          {
            if (_v1Abs.X() < _v1Abs.Z())
            {
              other.Set(1, 0, 0);
            }
            else
            {
              other.Set(0, 0, 1);
            }
          }
          else
          {
            if (_v1Abs.Y() < _v1Abs.Z())
            {
              other.Set(0, 1, 0);
            }
            else
            {
              other.Set(0, 0, 1);
            }
          }
        }
 
        const Vector3<T> axis(_v1.Cross(other).Normalize());
 
        qw = 0;
        qx = axis.X();
        qy = axis.Y();
        qz = axis.Z();
      }
      else
      {
        // the vectors are in general position
        const Vector3<T> axis(_v1.Cross(_v2));
        qw = kCosTheta + k;
        qx = axis.X();
        qy = axis.Y();
        qz = axis.Z();
        this->Normalize();
      }
    }
 
    public: void Scale(T _scale)
    {
      Vector3<T> axis;
      T angle;
 
      // Convert to axis-and-angle
      this->AxisAngle(axis, angle);
      angle *= _scale;
 
      this->SetFromAxisAngle(axis.X(), axis.Y(), axis.Z(), angle);
    }
 
    public: Quaternion<T> operator+(const Quaternion<T> &_qt) const
    {
      Quaternion<T> result(this->qw + _qt.qw, this->qx + _qt.qx,
                           this->qy + _qt.qy, this->qz + _qt.qz);
      return result;
    }
 
    public: Quaternion<T> operator+=(const Quaternion<T> &_qt)
    {
      *this = *this + _qt;
 
      return *this;
    }
 
    public: Quaternion<T> operator-(const Quaternion<T> &_qt) const
    {
      Quaternion<T> result(this->qw - _qt.qw, this->qx - _qt.qx,
                     this->qy - _qt.qy, this->qz - _qt.qz);
      return result;
    }
 
    public: Quaternion<T> operator-=(const Quaternion<T> &_qt)
    {
      *this = *this - _qt;
      return *this;
    }
 
    public: inline Quaternion<T> operator*(const Quaternion<T> &_q) const
            {
              return Quaternion<T>(
                this->qw*_q.qw-this->qx*_q.qx-this->qy*_q.qy-this->qz*_q.qz,
                this->qw*_q.qx+this->qx*_q.qw+this->qy*_q.qz-this->qz*_q.qy,
                this->qw*_q.qy-this->qx*_q.qz+this->qy*_q.qw+this->qz*_q.qx,
                this->qw*_q.qz+this->qx*_q.qy-this->qy*_q.qx+this->qz*_q.qw);
            }
 
    public: Quaternion<T> operator*(const T &_f) const
    {
      return Quaternion<T>(this->qw*_f, this->qx*_f,
                           this->qy*_f, this->qz*_f);
    }
 
    public: Quaternion<T> operator*=(const Quaternion<T> &_qt)
    {
      *this = *this * _qt;
      return *this;
    }
 
    public: Vector3<T> operator*(const Vector3<T> &_v) const
    {
      Vector3<T> uv, uuv;
      Vector3<T> qvec(this->qx, this->qy, this->qz);
      uv = qvec.Cross(_v);
      uuv = qvec.Cross(uv);
      uv *= (2.0f * this->qw);
      uuv *= 2.0f;
 
      return _v + uv + uuv;
    }
 
    public: bool operator==(const Quaternion<T> &_qt) const
    {
      return this->Equal(_qt, static_cast<T>(0.001));
    }
 
    public: bool operator!=(const Quaternion<T> &_qt) const
    {
      return !(*this == _qt);
    }
 
    public: Quaternion<T> operator-() const
    {
      return Quaternion<T>(-this->qw, -this->qx, -this->qy, -this->qz);
    }
 
    public: inline Vector3<T> RotateVector(const Vector3<T> &_vec) const
    {
      Quaternion<T> tmp(static_cast<T>(0),
          _vec.X(), _vec.Y(), _vec.Z());
      tmp = (*this) * (tmp * this->Inverse());
      return Vector3<T>(tmp.qx, tmp.qy, tmp.qz);
    }
 
    public: Vector3<T> RotateVectorReverse(const Vector3<T> &_vec) const
    {
      Quaternion<T> tmp(0.0, _vec.X(), _vec.Y(), _vec.Z());
 
      tmp =  this->Inverse() * (tmp * (*this));
 
      return Vector3<T>(tmp.qx, tmp.qy, tmp.qz);
    }
 
    public: bool IsFinite() const
    {
      // std::isfinite works with floating point values, need to explicit
      // cast to avoid ambiguity in vc++.
      return std::isfinite(static_cast<double>(this->qw)) &&
             std::isfinite(static_cast<double>(this->qx)) &&
             std::isfinite(static_cast<double>(this->qy)) &&
             std::isfinite(static_cast<double>(this->qz));
    }
 
    public: inline void Correct()
    {
      // std::isfinite works with floating point values, need to explicit
      // cast to avoid ambiguity in vc++.
      if (!std::isfinite(static_cast<double>(this->qx)))
        this->qx = 0;
      if (!std::isfinite(static_cast<double>(this->qy)))
        this->qy = 0;
      if (!std::isfinite(static_cast<double>(this->qz)))
        this->qz = 0;
      if (!std::isfinite(static_cast<double>(this->qw)))
        this->qw = 1;
 
      if (equal(this->qw, static_cast<T>(0)) &&
          equal(this->qx, static_cast<T>(0)) &&
          equal(this->qy, static_cast<T>(0)) &&
          equal(this->qz, static_cast<T>(0)))
      {
        this->qw = 1;
      }
    }
 
    public: Vector3<T> XAxis() const
    {
      T fTy  = 2.0f*this->qy;
      T fTz  = 2.0f*this->qz;
 
      T fTwy = fTy*this->qw;
      T fTwz = fTz*this->qw;
      T fTxy = fTy*this->qx;
      T fTxz = fTz*this->qx;
      T fTyy = fTy*this->qy;
      T fTzz = fTz*this->qz;
 
      return Vector3<T>(1.0f-(fTyy+fTzz), fTxy+fTwz, fTxz-fTwy);
    }
 
    public: Vector3<T> YAxis() const
    {
      T fTx  = 2.0f*this->qx;
      T fTy  = 2.0f*this->qy;
      T fTz  = 2.0f*this->qz;
      T fTwx = fTx*this->qw;
      T fTwz = fTz*this->qw;
      T fTxx = fTx*this->qx;
      T fTxy = fTy*this->qx;
      T fTyz = fTz*this->qy;
      T fTzz = fTz*this->qz;
 
      return Vector3<T>(fTxy-fTwz, 1.0f-(fTxx+fTzz), fTyz+fTwx);
    }
 
    public: Vector3<T> ZAxis() const
    {
      T fTx  = 2.0f*this->qx;
      T fTy  = 2.0f*this->qy;
      T fTz  = 2.0f*this->qz;
      T fTwx = fTx*this->qw;
      T fTwy = fTy*this->qw;
      T fTxx = fTx*this->qx;
      T fTxz = fTz*this->qx;
      T fTyy = fTy*this->qy;
      T fTyz = fTz*this->qy;
 
      return Vector3<T>(fTxz+fTwy, fTyz-fTwx, 1.0f-(fTxx+fTyy));
    }
 
    public: void Round(int _precision)
    {
      this->qx = precision(this->qx, _precision);
      this->qy = precision(this->qy, _precision);
      this->qz = precision(this->qz, _precision);
      this->qw = precision(this->qw, _precision);
    }
 
    public: T Dot(const Quaternion<T> &_q) const
    {
      return this->qw*_q.qw + this->qx * _q.qx +
             this->qy*_q.qy + this->qz*_q.qz;
    }
 
    public: static Quaternion<T> Squad(T _fT,
                const Quaternion<T> &_rkP, const Quaternion<T> &_rkA,
                const Quaternion<T> &_rkB, const Quaternion<T> &_rkQ,
                bool _shortestPath = false)
    {
      T fSlerpT = 2.0f*_fT*(1.0f-_fT);
      Quaternion<T> kSlerpP = Slerp(_fT, _rkP, _rkQ, _shortestPath);
      Quaternion<T> kSlerpQ = Slerp(_fT, _rkA, _rkB);
      return Slerp(fSlerpT, kSlerpP, kSlerpQ);
    }
 
    public: static Quaternion<T> Slerp(T _fT,
                const Quaternion<T> &_rkP, const Quaternion<T> &_rkQ,
                bool _shortestPath = false)
    {
      T fCos = _rkP.Dot(_rkQ);
      Quaternion<T> rkT;
 
      // Do we need to invert rotation?
      if (fCos < 0.0f && _shortestPath)
      {
        fCos = -fCos;
        rkT = -_rkQ;
      }
      else
      {
        rkT = _rkQ;
      }
 
      if (std::abs(fCos) < 1 - 1e-03)
      {
        // Standard case (slerp)
        T fSin = sqrt(1 - (fCos*fCos));
        T fAngle = atan2(fSin, fCos);
        // FIXME: should check if (std::abs(fSin) >= 1e-3)
        T fInvSin = 1.0f / fSin;
        T fCoeff0 = sin((1.0f - _fT) * fAngle) * fInvSin;
        T fCoeff1 = sin(_fT * fAngle) * fInvSin;
        return _rkP * fCoeff0 + rkT * fCoeff1;
      }
      else
      {
        // There are two situations:
        // 1. "rkP" and "rkQ" are very close (fCos ~= +1),
        // so we can do a linear interpolation safely.
        // 2. "rkP" and "rkQ" are almost inverse of each
        // other (fCos ~= -1), there
        // are an infinite number of possibilities interpolation.
        // but we haven't have method to fix this case, so just use
        // linear interpolation here.
        Quaternion<T> t = _rkP * (1.0f - _fT) + rkT * _fT;
        // taking the complement requires renormalisation
        t.Normalize();
        return t;
      }
    }
 
    public: Quaternion<T> Integrate(const Vector3<T> &_angularVelocity,
                                    const T _deltaT) const
    {
      Quaternion<T> deltaQ;
      Vector3<T> theta = _angularVelocity * _deltaT / 2;
      T thetaMagSq = theta.SquaredLength();
      T s;
      if (thetaMagSq * thetaMagSq / 24.0 < MIN_D)
      {
        deltaQ.W() = 1.0 - thetaMagSq / 2.0;
        s = 1.0 - thetaMagSq / 6.0;
      }
      else
      {
        double thetaMag = sqrt(thetaMagSq);
        deltaQ.W() = cos(thetaMag);
        s = sin(thetaMag) / thetaMag;
      }
      deltaQ.X() = theta.X() * s;
      deltaQ.Y() = theta.Y() * s;
      deltaQ.Z() = theta.Z() * s;
      return deltaQ * (*this);
    }
 
    public: inline T W() const
    {
      return this->qw;
    }
 
    public: inline T X() const
    {
      return this->qx;
    }
 
    public: inline T Y() const
    {
      return this->qy;
    }
 
    public: inline T Z() const
    {
      return this->qz;
    }
 
    public: inline T &W()
    {
      return this->qw;
    }
 
    public: inline T &X()
    {
      return this->qx;
    }
 
    public: inline T &Y()
    {
      return this->qy;
    }
 
    public: inline T &Z()
    {
      return this->qz;
    }
 
    public: inline void SetX(T _v)
    {
      this->qx = _v;
    }
 
    public: inline void SetY(T _v)
    {
      this->qy = _v;
    }
 
 
    public: inline void SetZ(T _v)
    {
      this->qz = _v;
    }
 
    public: inline void SetW(T _v)
    {
      this->qw = _v;
    }
 
    public: friend std::ostream &operator<<(std::ostream &_out,
                const gz::math::Quaternion<T> &_q)
    {
      Vector3<T> v(_q.Euler());
      _out << v;
      return _out;
    }
 
    public: friend std::istream &operator>>(std::istream &_in,
        gz::math::Quaternion<T> &_q)
    {
      Angle roll, pitch, yaw;
 
      // Skip white spaces
      _in.setf(std::ios_base::skipws);
      _in >> roll >> pitch >> yaw;
 
      if (!_in.fail())
      {
        _q.SetFromEuler(Vector3<T>(*roll, *pitch, *yaw));
      }
 
      return _in;
    }
 
    public: bool Equal(const Quaternion &_q, const T &_tol) const
    {
      return equal(this->qx, _q.qx, _tol) &&
             equal(this->qy, _q.qy, _tol) &&
             equal(this->qz, _q.qz, _tol) &&
             equal(this->qw, _q.qw, _tol);
    }
 
    private: T qw;
 
    private: T qx;
 
    private: T qy;
 
    private: T qz;
  };
 
  namespace detail {
 
    template<typename T> constexpr Quaternion<T>
    gQuaternionIdentity(1, 0, 0, 0);
 
    template<typename T> constexpr Quaternion<T>
    gQuaternionZero(0, 0, 0, 0);
 
  }  // namespace detail
 
  template<typename T> const Quaternion<T>
  &Quaternion<T>::Identity = detail::gQuaternionIdentity<T>;
 
  template<typename T> const Quaternion<T>
  &Quaternion<T>::Zero = detail::gQuaternionZero<T>;
 
  typedef Quaternion<double> Quaterniond;
 
  typedef Quaternion<float> Quaternionf;
  }  // namespace GZ_MATH_VERSION_NAMESPACE
}  // namespace gz::math
#endif  // GZ_MATH_QUATERNION_HH_