quaternion.h

Go to the documentation of this file.

#ifndef _DLR_QUATERNION_H_
#define _DLR_QUATERNION_H_

namespace dlr {

  namespace numeric {
    
    class Quaternion {
    public:

      Quaternion() 
        : m_s(1.0), m_i(0.0), m_j(0.0), m_k(0.0), m_isNormalized(true) {}

      Quaternion(double s, double i, double j, double k,
                 bool isNormalized=false) 
        : m_s(s), m_i(i), m_j(j), m_k(k), m_isNormalized(isNormalized) {}

      Quaternion(const Quaternion &source) :
        m_s(source.m_s), m_i(source.m_i), m_j(source.m_j), m_k(source.m_k),
        m_isNormalized(source.m_isNormalized) {}

      virtual
      inline
      ~Quaternion() {}

      inline
      double
      s() const { return m_s; };

      inline
      double
      i() const { return m_i; };

      inline
      double
      j() const { return m_j; };

      inline
      double
      k() const { return m_k; };

      inline
      void
      setValue(double s, double i, double j, double k) {
        m_s = s; m_i = i; m_j = j; m_k = k; m_isNormalized = false;
      }

      void
      normalize();

      inline
      Quaternion&
      operator=(const Quaternion &source) {
        setValue(source.m_s, source.m_i, source.m_j, source.m_k);
        m_isNormalized = source.m_isNormalized;
        return *this;
      }
    
    private:
      // Components of the quaternion are listed in order.
      double m_s;
      double m_i;
      double m_j;
      double m_k;

      // A flag to avoid repeatedly re-normalizing.
      bool m_isNormalized;
    };

    /* ======================= Non-member functions ===================== */

    inline
    Quaternion
    conjugate(const Quaternion& source) {
      return Quaternion(source.s(), -(source.i()), -(source.j()), -(source.k()));
    }
  
  } // namespace numeric

} // namespace dlr


/* ======= Declarations to maintain compatibility with legacy code. ======= */

namespace dlr {

  using numeric::Quaternion;

} // namespace dlr

#endif // #ifndef _DLR_QUATERNION_H_

---