a_quaternion.cxx

Go to the documentation of this file.

#include <math.h>
#include <stdlib.h>
#include "a_quaternion.h"
 
//---------------------------------------------------------------------------
double a_quaternion::norm() const
{
        return r_*r_+i_*i_+j_*j_+k_*k_;
}
//---------------------------------------------------------------------------
double a_quaternion::abs() const
{
        return sqrt(norm());
}
//---------------------------------------------------------------------------
a_quaternion& a_quaternion::negate()
{
        r_ = -r_;
        i_ = -i_;
        j_ = -j_;
        k_ = -k_;
        return *this;
}
//---------------------------------------------------------------------------
a_quaternion& a_quaternion::conjugate()
{
        i_ = -i_;
        j_ = -j_;
        k_ = -k_;
        return *this;
}
//---------------------------------------------------------------------------
a_quaternion& a_quaternion::square()
{
        double temp = 2.*r_;
        r_ = r_*r_-(i_*i_+j_*j_+k_*k_);
        i_ *= temp;
        j_ *= temp;
        k_ *= temp;
        return *this;
}
//---------------------------------------------------------------------------
a_quaternion& a_quaternion::invert()
{
        double temp = norm();
        r_ /= temp;
        i_ /= -temp;
        j_ /= -temp;
        k_ /= -temp;
        return (*this);
}
//---------------------------------------------------------------------------
a_quaternion& a_quaternion::operator+=(const a_quaternion& b)
{
        r_ += b.r_; i_ += b.i_; j_ += b.j_; k_ += b.k_; return *this;
}
//---------------------------------------------------------------------------
a_quaternion a_quaternion::operator+(const a_quaternion& b)
{
        a_quaternion a = *this;
        return a += b;
}
//---------------------------------------------------------------------------
a_quaternion& a_quaternion::operator-=(const a_quaternion& b)
{
        r_ -= b.r_; i_ -= b.i_; j_ -= b.j_; k_ -= b.k_; return *this;
}
//---------------------------------------------------------------------------
a_quaternion a_quaternion::operator-(const a_quaternion& b)
{
        a_quaternion a = *this;
        return a -= b;
}
//---------------------------------------------------------------------------
a_quaternion& a_quaternion::operator*=(const double b)
{
        r_ *= b; i_ *= b; j_ *= b; k_ *= b; return *this;
}
//---------------------------------------------------------------------------
a_quaternion a_quaternion::operator*(const double b)
{
        a_quaternion a = *this;
        return a *= b;
}
//---------------------------------------------------------------------------
a_quaternion& a_quaternion::operator/=(const double b)
{
        r_ /= b; i_ /= b; j_ /= b; k_ /= b; return *this;
}
//---------------------------------------------------------------------------
a_quaternion a_quaternion::operator/(const double b)
{
        a_quaternion a = *this;
        return a /= b;
}
//---------------------------------------------------------------------------
a_quaternion& a_quaternion::operator*=(const a_quaternion& b)
{
        double t0 = (k_-j_)*(b.j_-b.k_);
        double t1 = (r_+i_)*(b.r_+b.i_);
        double t2 = (r_-i_)*(b.j_+b.k_);
        double t3 = (k_+j_)*(b.r_-b.i_);
        double t4 = (k_-i_)*(b.i_-b.j_);
        double t5 = (k_+i_)*(b.i_+b.j_);
        double t6 = (r_+j_)*(b.r_-b.k_);
        double t7 = (r_-j_)*(b.r_+b.k_);
        double t8 = t5+t6+t7;
        double t9 = (t4+t8)/2.;
        r_ = t0+t9-t5;
        i_ = t1+t9-t8;
        j_ = t2+t9-t7;
        k_ = t3+t9-t6;
        return *this;
}
//---------------------------------------------------------------------------
a_quaternion a_quaternion::operator*(const a_quaternion& b)
{
        a_quaternion a = *this;
        return a *= b;
}
//---------------------------------------------------------------------------
a_quaternion& a_quaternion::operator/=(const a_quaternion& b)
{
        a_quaternion temp = b;
        return (*this)*=(temp.invert());
}
//---------------------------------------------------------------------------
a_quaternion a_quaternion::operator/(const a_quaternion& b)
{
        a_quaternion a = *this;
        return a /= b;
}
//---------------------------------------------------------------------------
bool operator==(const a_quaternion& a, const a_quaternion& b)
{
        return (a.r() == b.r() && a.i() == b.i() && a.j() == b.j() && a.k() == b.k());
}
//---------------------------------------------------------------------------
bool operator!=(const a_quaternion& a, const a_quaternion& b)
{
        return !(a==b);
}
//---------------------------------------------------------------------------
a_quaternion operator-(a_quaternion& x)
{
        return x.negate();
}
//---------------------------------------------------------------------------
a_quaternion sqrt(const a_quaternion& x)
{
        std::cerr << "sqrt(const a_quaternion&) undefined because a_quaternion::sqrt() undefined." << std::endl;
        exit(1);      // Should be derived from member function.
}
//---------------------------------------------------------------------------
std::ostream& operator<<(std::ostream& o, const a_quaternion& x)
{
        return o << x.r_ << " " << x.i_ << " " << x.j_ << " " << x.k_;
}
//---------------------------------------------------------------------------
a_quaternion operator+(const a_quaternion& x, const a_quaternion& y)
{
        a_quaternion z = x;
        return z += y; // derived operator
}
//---------------------------------------------------------------------------
a_quaternion operator-(const a_quaternion& x, const a_quaternion& y)
{
        a_quaternion z = x;
        return z -= y; // derived operator
}
//---------------------------------------------------------------------------
a_quaternion operator*(const a_quaternion& x, const double y)
{
        a_quaternion z = x;
        return z *= y; // derived operator
}
//---------------------------------------------------------------------------
a_quaternion operator*(const a_quaternion& x, const a_quaternion& y)
{
        a_quaternion z = x;
        return z *= y; // derived operator
}
//---------------------------------------------------------------------------
a_quaternion operator/(const a_quaternion& x, const a_quaternion& y)
{
        a_quaternion z = x;
        return z /= y; // derived operator
}