The C++ classes `Quaternion<double>`, `Quaternion<double>`, and `Quaternion<float>`
represent floating-point quaternions of the form *z* = *a* + *ib* + *jc* + *kd*.
The symbols *i*, *j*, and *k* follow the multiplication rules
*i*^{2} =
*j*^{2} =
*k*^{2} =
*ijk* = -1. Consequently, multiplication is not commutative.

Throughout this document, the variable *z* is used to represent `*this`
object. The template variable `T` represents the field of the coefficients.

- Constructors
- Constants
- Real-Valued Functions
- Quaternion-Valued Functions
- Squares and Inverses
- Rotations
- Powers
- Exponential and Logarithmic Functions
- Trigonometric and Hyperbolic Functions (and their Inverses)
- Special Functions
- Integer-Value Functions
- Horner's Rule
- Binary Arithmetic Operators
- Unary Arithmetic Operators
- Assignment Operators
- Auto Increment and Auto Decrement Operators
- Binary Boolean Operators
- Query Functions
- Static Factory Functions
- Stream Operators

There are two constructors

Quaternion( T a = 0 ); Quaternion( T a, T b, T c, T d );

which create the quaternion *a* + 0i + 0j + 0k and *a* + *ib* + *jc* + *kd*, respectively.

There are five static constants defined in each class:

ZERO | 0 |

ONE | 1 |

I | i |

J | j |

K | k |

The constants may be accessed through the array `UNITS[4] = {ONE, I, J, K}`.

Each of the real-valued member functions has the prototype
`T f() const;`
and has a corresponding procedural function `T f( const Quaternion<T> );`.

real |
imag_i |
imag_j |
imag_k |
csgn |

abs |
norm |
abs_imag |
norm_imag |
arg |

Descriptions of each of the functions follow:

`real`- Return the real component ℜ(
*z*) =*a*. `imag_i`- Return the imaginary component ℑ
_{i}(*z*) =*b*. `imag_j`- Return the imaginary component ℑ
_{j}(*z*) =*c*. `imag_k`- Return the imaginary component ℑ
_{k}(*z*) =*d*. `csgn`- Return 0 if
*z*= 0, 1 if*a*≥ +0, and -1 if*a*≤ -0. `abs`- Return |
*z*| = (*a*^{2}+*b*^{2}+*c*^{2}+*d*^{2})^{½}unless either component is infinity, in which case, it always returns ∞. `norm`- Return |
*z*|^{2}=*a*^{2}+*b*^{2}+*c*^{2}+*d*^{2}unless any component is infinity, in which case, it always returns ∞. `abs_imag`- Return |ℑ(
*z*)| = |*ib*+*jc*+*kd*|. `norm_imag`- Return |ℑ(
*z*)|^{2}=*b*^{2}+*c*^{2}+*d*^{2}. `arg`- Return the argument of the quaternion arg(
*z*) = atan2( |ℑ(*z*)|, ℜ(*z*) ).

The function `T operator [](int n) const` returns the coefficient of
the unit `UNITS[n]` for *n* = 0, 1, 2, and 3.

Each of these quaternion-valued member functions has the prototype
`Quaternion<T> f() const;`
and has a corresponding procedural function `Quaternion<T> f( const Quaternion<T> );`.

imag |
conj |
signum |

Descriptions of each of the functions follow:

`imag`- Return the quaternion 0 +
*ib*+*jc*+*kd*. `cong`- Return the quaternion
*a*−*ib*+*jc*+*kd*. `signum`- Return the quaternion
*z*/|*z*| given*z*≠ 0. If*z*= 0, then*z*is returned.

Each of the square, square root, and inverse member functions has the prototype
`Quaternion<T> f() const;`
and has a corresponding procedural function `Quaternion<T> f( const Quaternion<T> );`.

sqr |
sqrt |
inverse |

Descriptions of each of the functions follow:

`sqr`- Calculate
*z*^{2}. `sqrt`- Calculate the square root of
*z*(that is,*z*^{½}). `inverse`- Calculate the inverse of
*z*(that is,*z*^{-1}).

The member function
`Quaternion<T> rotate( const Quaternion<T> w ) const;` and its associated procedural function
`Quaternion<T> rotate( const Quaternion<T> z, const Quaternion<T> w )`
calculates *wzw*^{*}. If *w* has unit length and
*z* is an imaginary quaternion, then this member function returns
vector *z* rotated 2 arg(*w*) radians
around the line defined by ℑ(*w*).

The power function is overloaded with two prototypes:

Quaternion<T> pow( T ) |
Quaternion<T> pow( Quaternion<T> ) |

Each of the exponential and logarithmic member functions has the prototype `Quaternion<T> f() const;`
and has a corresponding procedural function `Quaternion<T> f( const Quaternion<T> );`.

exp |
log |
log10 |

Descriptions of each of the functions follow:

`exp`- Calculate
*e*^{z}. `log`- Calculate the natural logarithm ln(
*z*). `log10`- Calculate the base-10 logarithm log
_{10}(*z*).

Each of the trigonometric, hyperbolic, inverse trigonometric, and inverse hyperbolic
member functions has the prototype `Quaternion<T> f() const;`
and has a corresponding procedural function `Quaternion<T> f( const Quaternion<T> );`.

sin |
cos |
tan |
sec |
csc |
cot |

sinh |
cosh |
tanh |
sech |
csch |
coth |

asin |
acos |
atan |
asec |
acsc |
acot |

asinh |
acosh |
atanh |
asech |
acsch |
acoth |

For example, the `sin` function calculates the result
of *z* − *z*^{3}/3! + *z*^{5}/5! − *z*^{7}/7! + *z*^{9}/9! − *z*^{11}/11! + ⋅⋅⋅ by using the formula

Bessel functions of the first kind, J_{n}(*z*) are implemented for integer values of *n*.
The prototype of the member function is `Quaternion<T> bessel_J( int ) const;`
and there is the corresponding procedural function
`Quaternion<T> bessel_J( int, const Quaternion<T>) const;`.

Because the coefficients of the Taylor series for Bessel functions of the first kind are real, this function is well defined even for the non-commutative quaternions.

Each of the integer-valued member functions has the prototype `Quaternion<T> f() const;`
and has a corresponding procedural function `Quaternion<T> f( const Quaternion<T> );`.

floor |
ceil |

In both cases, the floor and ceiling, respectively, are calculated for each component.

The polynomial
*v*_{0}*z*^{n − 1} +
*v*_{1}*z*^{n − 2} +
*v*_{2}*z*^{n − 3} + ⋅⋅⋅
*v*_{n − 3}*z*^{2} +
*v*_{n − 2}*z* +
*v*_{n − 1} may be
calculated efficiently using Horner's rule. The array `v` of *n* entries
may be of type `T *`. The lack of commutativity dictates that the polynomial is not
well defined from quaternionic coefficients, hence the coefficients are restricted
to real values.

Quaternion<T> horner( T * v, unsigned int n );

The Newton polynomial with offsets:
*v*_{0}(*z* − c_{n − 1})(*z* − c_{n − 2})⋅⋅⋅(*z* − c_{3})(*z* − c_{2})(*z* − c_{1}) +

*v*_{1}(*z* − c_{n − 1})(*z* − c_{n − 2})⋅⋅⋅(*z* − c_{3})(*z* − c_{2}) +

*v*_{2}(*z* − c_{n − 1})(*z* − c_{n − 2})⋅⋅⋅(*z* − c_{3}) + ⋅⋅⋅ +

*v*_{n − 3}(*z* − c_{n − 1})(*z* − c_{n − 2}) +

*v*_{n − 2}(*z* − c_{n − 1}) +

*v*_{n − 1} may also be
calculated efficiently using Horner's rule. The arrays `v` and `c` of *n* entries
must be of type `T *`.

Quaternion<T> horner( T * v, T * c, unsigned int n );

Similarly, due to commutativity, the coefficients and the offsets must be restricted to real values.

Corresponding to each of this functions is a procedural function which takes the variable
`z` as a first argument.

All binary arithmetic operators `operator ⋅` have the following prototypes:

+ |
- |
* |
/ |

Note that *z*/*w* is defined as *zw*^{-1}.

The unary arithmetic operator `operator -` has the prototype
`operator - ( const Quaternion<T> & )` and returns
the negative of the quaternion.

The assignment operators `operator ⋅` have the prototypes
`operator ⋅ ( const Quaternion<T> & )` and
`operator ⋅ ( T )` and appropriately modifies and returns this
quaternion. The operations are:

= |
+= |
-= |
*= |
/= |

The auto increment and auto decrement operators work on the real part of the quaternion.

All binary Boolean operators have the following prototypes:

== |
!= |

Descriptions of each of the functions follow:

`operator ==`- Returns
`true`if all components return true under`==`. `operator !=`- Returns
`true`if any components return true under`!=`.

Each of the following member functions has the prototype `bool f() const;` and
returns a value based on the components of this quaternion.

is_imaginary |
is_inf |
is_nan |
is_neg_inf |

is_pos_inf |
is_real |
is_real_inf |
is_zero |

Descriptions of each of the functions follow:

`is_imaginary`- Returns
`true`if this quaternion has a zero real component (of the form 0 +*ib*+*jc*+*kd*) and`false`otherwise. `is_inf`- Returns
`true`if any component of this is one of either +∞ or -∞ and`false`otherwise. `is_nan`- Returns
`true`if any component of this is`NaN`and`false`otherwise. `is_neg_inf`- Returns
`true`if this quaternion is -∞ + 0i + 0j + 0k and`false`otherwise. `is_pos_inf`- Returns
`true`if this quaternion is ∞ + 0i + 0j + 0k and`false`otherwise. `is_real`- Returns
`true`if this quaternion has a zero imaginary component (of the form*a*+ 0*i*+ 0j + 0k) and`false`otherwise. `is_real_inf`- Returns
`true`if this quaternion is either +∞ + 0i + 0j + 0k or -∞ + 0i + 0j + 0k and`false`otherwise. `is_zero`- Returns
`true`if this quaternion is 0 + 0i + 0j + 0k and`false`otherwise.

Each of the following static factory functions has the prototype `static Quaternion<T> f() const;`
and returns a random quaternion according to the following definitions:

`random`*r*_{1}+ i*r*_{2}+ j*r*_{3}+ k*r*_{4}`random_real`*r*_{1}+ 0i + 0j + 0k`random_imag`- 0 + i
*r*_{1}+ j*r*_{3}+ k*r*_{4}

where *r*_{k} is a random real value.

The stream operators have been overloaded to print and read quaternions.