Unary Plus

template<typename T>
quaternion<T> operator + (quaternion<T> const & q);

This unary operator simply returns q.

Unary Minus

template<typename T>
quaternion<T> operator - (quaternion<T> const & q);

This unary operator returns the opposite of q.

Binary Addition Operators

template<typename T> quaternion<T> operator + (T const & lhs, quaternion<T> const & rhs);
template<typename T> quaternion<T> operator + (quaternion<T> const & lhs, T const & rhs);
template<typename T> quaternion<T> operator + (::std::complex<T> const & lhs, quaternion<T> const & rhs);
template<typename T> quaternion<T> operator + (quaternion<T> const & lhs, ::std::complex<T> const & rhs);
template<typename T> quaternion<T> operator + (quaternion<T> const & lhs, quaternion<T> const & rhs);

These operators return quaternion<T>(lhs) += rhs.

Binary Subtraction Operators

template<typename T> quaternion<T> operator - (T const & lhs, quaternion<T> const & rhs);
template<typename T> quaternion<T> operator - (quaternion<T> const & lhs, T const & rhs);
template<typename T> quaternion<T> operator - (::std::complex<T> const & lhs, quaternion<T> const & rhs);
template<typename T> quaternion<T> operator - (quaternion<T> const & lhs, ::std::complex<T> const & rhs);
template<typename T> quaternion<T> operator - (quaternion<T> const & lhs, quaternion<T> const & rhs);

These operators return quaternion<T>(lhs) -= rhs.

Binary Multiplication Operators

template<typename T> quaternion<T> operator * (T const & lhs, quaternion<T> const & rhs);
template<typename T> quaternion<T> operator * (quaternion<T> const & lhs, T const & rhs);
template<typename T> quaternion<T> operator * (::std::complex<T> const & lhs, quaternion<T> const & rhs);
template<typename T> quaternion<T> operator * (quaternion<T> const & lhs, ::std::complex<T> const & rhs);
template<typename T> quaternion<T> operator * (quaternion<T> const & lhs, quaternion<T> const & rhs);

These operators return quaternion<T>(lhs) *= rhs.

Binary Division Operators

template<typename T> quaternion<T> operator / (T const & lhs, quaternion<T> const & rhs);
template<typename T> quaternion<T> operator / (quaternion<T> const & lhs, T const & rhs);
template<typename T> quaternion<T> operator / (::std::complex<T> const & lhs, quaternion<T> const & rhs);
template<typename T> quaternion<T> operator / (quaternion<T> const & lhs, ::std::complex<T> const & rhs);
template<typename T> quaternion<T> operator / (quaternion<T> const & lhs, quaternion<T> const & rhs);

These operators return quaternion<T>(lhs) /= rhs. It is of course still an error to divide by zero...

Equality Operators

template<typename T> bool  operator == (T const & lhs, quaternion<T> const & rhs);
template<typename T> bool  operator == (quaternion<T> const & lhs, T const & rhs);
template<typename T> bool  operator == (::std::complex<T> const & lhs, quaternion<T> const & rhs);
template<typename T> bool  operator == (quaternion<T> const & lhs, ::std::complex<T> const & rhs);
template<typename T> bool  operator == (quaternion<T> const & lhs, quaternion<T> const & rhs);

These return true if and only if the four components of quaternion<T>(lhs) are equal to their counterparts in quaternion<T>(rhs). As with any floating-type entity, this is essentially meaningless.

Inequality Operators

template<typename T> bool  operator != (T const & lhs, quaternion<T> const & rhs);
template<typename T> bool  operator != (quaternion<T> const & lhs, T const & rhs);
template<typename T> bool  operator != (::std::complex<T> const & lhs, quaternion<T> const & rhs);
template<typename T> bool  operator != (quaternion<T> const & lhs, ::std::complex<T> const & rhs);
template<typename T> bool  operator != (quaternion<T> const & lhs, quaternion<T> const & rhs);

These return true if and only if quaternion<T>(lhs) == quaternion<T>(rhs) is false. As with any floating-type entity, this is essentially meaningless.

Stream Extractor

template<typename T, typename charT, class traits>
::std::basic_istream<charT,traits>& operator >> (::std::basic_istream<charT,traits> & is, quaternion<T> & q);

Extracts a quaternion q of one of the following forms (with a, b, c and d of type T):

a (a), (a,b), (a,b,c), (a,b,c,d) (a,(c)), (a,(c,d)), ((a)), ((a),c), ((a),(c)), ((a),(c,d)), ((a,b)), ((a,b),c), ((a,b),(c)), ((a,b),(c,d))

The input values must be convertible to T. If bad input is encountered, calls is.setstate(ios::failbit) (which may throw ios::failure (27.4.5.3)).

Returns: is.

The rationale for the list of accepted formats is that either we have a list of up to four reals, or else we have a couple of complex numbers, and in that case if it formatted as a proper complex number, then it should be accepted. Thus potential ambiguities are lifted (for instance (a,b) is (a,b,0,0) and not (a,0,b,0), i.e. it is parsed as a list of two real numbers and not two complex numbers which happen to have imaginary parts equal to zero).

Stream Inserter

template<typename T, typename charT, class traits>
::std::basic_ostream<charT,traits>& operator << (::std::basic_ostream<charT,traits> & os, quaternion<T> const & q);

Inserts the quaternion q onto the stream os as if it were implemented as follows:

template<typename T, typename charT, class traits>
::std::basic_ostream<charT,traits>& operator << (
               ::std::basic_ostream<charT,traits> & os,
               quaternion<T> const & q)
{
   ::std::basic_ostringstream<charT,traits>  s;

   s.flags(os.flags());
   s.imbue(os.getloc());
   s.precision(os.precision());

   s << '(' << q.R_component_1() << ','
            << q.R_component_2() << ','
            << q.R_component_3() << ','
            << q.R_component_4() << ')';

   return os << s.str();
}