構造函數

模板版本:

explicit  octonion(T const & requested_a = T(), T const & requested_b = T(), T const & requested_c = T(), T const & requested_d = T(), T const & requested_e = T(), T const & requested_f = T(), T const & requested_g = T(), T const & requested_h = T());
explicit  octonion(::std::complex<T> const & z0, ::std::complex<T> const & z1 = ::std::complex<T>(), ::std::complex<T> const & z2 = ::std::complex<T>(), ::std::complex<T> const & z3 = ::std::complex<T>());
explicit  octonion(::boost::math::quaternion<T> const & q0, ::boost::math::quaternion<T> const & q1 = ::boost::math::quaternion<T>());
template<typename X> 
explicit octonion(octonion<X> const & a_recopier);

單精度浮點數特化版本:

explicit  octonion(float const & requested_a = 0.0f, float const & requested_b = 0.0f, float const & requested_c = 0.0f, float const & requested_d = 0.0f, float const & requested_e = 0.0f, float const & requested_f = 0.0f, float const & requested_g = 0.0f, float const & requested_h = 0.0f);
explicit  octonion(::std::complex<float> const & z0, ::std::complex<float> const & z1 = ::std::complex<float>(), ::std::complex<float> const & z2 = ::std::complex<float>(), ::std::complex<float> const & z3 = ::std::complex<float>());
explicit  octonion(::boost::math::quaternion<float> const & q0, ::boost::math::quaternion<float> const & q1 = ::boost::math::quaternion<float>());
explicit  octonion(octonion<double> const & a_recopier); 
explicit  octonion(octonion<long double> const & a_recopier);

雙精度浮點數特化版本:

explicit  octonion(double const & requested_a = 0.0, double const & requested_b = 0.0, double const & requested_c = 0.0, double const & requested_d = 0.0, double const & requested_e = 0.0, double const & requested_f = 0.0, double const & requested_g = 0.0, double const & requested_h = 0.0);
explicit  octonion(::std::complex<double> const & z0, ::std::complex<double> const & z1 = ::std::complex<double>(), ::std::complex<double> const & z2 = ::std::complex<double>(), ::std::complex<double> const & z3 = ::std::complex<double>());
explicit  octonion(::boost::math::quaternion<double> const & q0, ::boost::math::quaternion<double> const & q1 = ::boost::math::quaternion<double>());
explicit  octonion(octonion<float> const & a_recopier);
explicit  octonion(octonion<long double> const & a_recopier);

長雙精度浮點數特化版本:

explicit  octonion(long double const & requested_a = 0.0L, long double const & requested_b = 0.0L, long double const & requested_c = 0.0L, long double const & requested_d = 0.0L, long double const & requested_e = 0.0L, long double const & requested_f = 0.0L, long double const & requested_g = 0.0L, long double const & requested_h = 0.0L);
explicit  octonion( ::std::complex<long double> const & z0, ::std::complex<long double> const & z1 = ::std::complex<long double>(), ::std::complex<long double> const & z2 = ::std::complex<long double>(), ::std::complex<long double> const & z3 = ::std::complex<long double>());
explicit  octonion(::boost::math::quaternion<long double> const & q0, ::boost::math::quaternion<long double> const & q1 = ::boost::math::quaternion<long double>());
explicit  octonion(octonion<float> const & a_recopier);
explicit  octonion(octonion<double> const & a_recopier);

每一種形式都提供了缺省構造函數,將每一個成員初始化為它所屬類型的缺省值(即. 浮點數初始化為0). .這個構造函數也可以接受 1 到 8 個基本類型的實參 . 提供了一個可以接受 1 到 4 個基於同一基本類型的複數實參的構造函數, 提供了另一個可以接受 1 到 2 個基於同一種基本類型的四元數實參的構造函數. 未特化的模板提供了一個模板化的拷貝構造函數, 而特化形式的模板類有使用另處兩種特化形式的拷貝構造函數 (譯注：作者的意思是說，一共有三種形式的特化：float , double , long double ， 對於float 形式的特化，它有一個基於 double 特化 的 explicit octonion(octonion <double> const & a_recopier); 拷貝構造函數 和一個 基於 long double 特化的 octonion(octonion <long double> const & a_recopier); 拷貝構造函數， 其它的兩種特化形式 double , long double 也有類似於 float 的基於其它兩種特化的拷貝構造函數), 這些拷貝構造函數是 explicit 的為了防止存在精度丟失的風險 （譯注：防止編譯器進行隱式的類型轉換時存在的精度丟失）. 對於沒有特化的類模板，基類型(譯注:作者在這裡是指實例化模板的類型) 的構造函數禁止拋出異常.

析構函數和未模板化的拷貝構造函數(同一種類型)由編譯器提供. 具有轉換作用的拷貝構造函數使用子名字空間中的一個模板化的輔助函數.

其它的成員函數

實部和非實部

T            real()   const;
octonion<T>  unreal() const;

就像複數一樣, 八元數有一個有意義的 "實部"概念, 但是不像複數，八元數並沒有一個有意義的 "虛部"概念. 取而代之的是八元數中有一個"非實部"的概念， 非實部本身也是一個八元數, 並且通常不能再簡化 (這一點與複數相反). 這些實部和非實部由最開始的兩個函數返回.

單獨的實部構成

T   R_component_1() const;
T   R_component_2() const;
T   R_component_3() const;
T   R_component_4() const;
T   R_component_5() const;
T   R_component_6() const;
T   R_component_7() const;
T   R_component_8() const;

一個八元數有8個實部, 這些實部通過這8個函數返回. 因此成員函數 real 和 成員函數 R_component_1 返回同樣的值.

單獨的複數構成

::std::complex<T> C_component_1() const;
::std::complex<T> C_component_2() const;
::std::complex<T> C_component_3() const;
::std::complex<T> C_component_4() const;

一個八元數億乎有4個複數成員. 事實上, 真正的八元數一個在複數之上的向量場, 但是請注意, 對於任意的八元數 o = α + βi + γj + δk + εe' + ζi' + ηj' + θk' 我們仍然有以下形式 o = (α + βi) + (γ + δi)j + (ε + ζi)e' + (η - θi)j' (注意 最後一個因式中的減號 ). C_component_n functions 所返回的, 無論如何, 都是用在這個八元數構造函數中用來構造這個八元數的複數, 而 不是 而不是以 (1, j, e', j')為基礎的八元數的組成部分.

單獨的四元數構造

::boost::math::quaternion<T> H_component_1() const;
::boost::math::quaternion<T> H_component_2() const;

類似地, 對於任意的八元數 o = α + βi + γj + δk + εe' + ζi' + ηj' + θk' 我們也有 o = (α + βi + γj + δk) + (ε + ζi + ηj - θj)e'這種形式, 雖然沒有基於四元數的有意義的「類似於向量空間」的結構. H_component_n 返回的是用在這個八元數的構造函數中用於構造這個八元數的四元數.

八元數成員運算符

賦值運算符

octonion<T> & operator = (octonion<T> const & a_affecter);
template<typename X> 
octonion<T> & operator = (octonion<X> const & a_affecter);
octonion<T> & operator = (T const & a_affecter);
octonion<T> & operator = (::std::complex<T> const & a_affecter);
octonion<T> & operator = (::boost::math::quaternion<T> const & a_affecter);

這些操作符進行預期的賦值操作, 如果有必要的話會伴有類型調整 (例如, 從一個基類型 (譯注：用於將一個類模板實例化為一個模板類的類型) 進行賦值將會把實部賦為那個值, 而所有其它的成員將會被設為0). 對於沒有特化的形式, 基類型的賦值操作禁止拋出異常.

其它的成員操作符

octonion<T> & operator += (T const & rhs)
octonion<T> & operator += (::std::complex<T> const & rhs);
octonion<T> & operator += (::boost::math::quaternion<T> const & rhs);
template<typename X> 
octonion<T> & operator += (octonion<X> const & rhs);

這些+= 操作符進行 (*this)+rhs 的數學運算 並且將結果存放在 *this中. 未特化的形式有異常保護, 但是特化的形式沒有異常保護, 以便確保異常安全 (譯注：作者的意思是這樣的，因為特化的形式是針對 float , double , long double 進行的，我們知道，這三種類型的 數值在進行賦值操作時是不會拋出異常的，所以作都就沒有對這個特化形式設置異常保護，但是對於沒有特化的形式， 作者設置了異常保護，這是因為，對於沒有特化的形式，用戶可能使用自定義的「具有數值特性的類」來實例化這個八元數 類模板而生成一個模板類，在這種情況下，庫的作者不能確保用戶實例化這個類模板的用戶自定義類型的賦值操作一定不會拋出 異常，所以，作者就對於這些未特化的形式設置了異常保護以確保異常安全性). 對於未特化的形式, 基類型的賦值操作禁止拋出異常.

octonion<T> & operator -= (T const & rhs)
octonion<T> & operator -= (::std::complex<T> const & rhs);
octonion<T> & operator -= (::boost::math::quaternion<T> const & rhs);
template<typename X> 
octonion<T> & operator -= (octonion<X> const & rhs);

這些-=操作符進行 (*this)-rhs之中 的數學運算 並且將結果存放在 *this. 未特化的形式有異常保護, 但是特化的形式沒有異常保護, 以便確保異常安全. 對於未特化的形式， 基類型的賦值操作禁止拋出異常.

octonion<T> & operator *= (T const & rhs)
octonion<T> & operator *= (::std::complex<T> const & rhs);
octonion<T> & operator *= (::boost::math::quaternion<T> const & rhs);
template<typename X> 
octonion<T> & operator *= (octonion<X> const & rhs);

這些*=運算符進行依照這種順序的(*this)*rhs 的數學計算(順序很重要，因為八元數的乘法並不滿足可交換性) 並且將計算結果存放在*this之中. 未特化的形式有異常保護, 但是特化的版本沒有, 以便確保異常安全. . 對於未特化的形式, 基類型的賦值操作禁止拋出異常. 同時, 出於清楚的目的, 你應當將乘法運算中的每兩個因子組合為一組來對乘法運算進行分組, 因為對於八元數，乘法操作甚至是不可結合的 （雖然在有一些情況下這一點無關緊要,但是有時這一點還是很重要的).

octonion<T> & operator /= (T const & rhs)
octonion<T> & operator /= (::std::complex<T> const & rhs);
octonion<T> & operator /= (::boost::math::quaternion<T> const & rhs);
template<typename X> 
octonion<T> & operator /= (octonion<X> const & rhs);

這些/=運算符進行依照這種順序的 (*this)*inverse_of(rhs) 數學計算(順序很重要，因為八元數的乘法並不滿足可交換性 （ 譯注:這句話初看起來很矛盾,除法運算中的順序為什麼會受到 乘法運算中的「不可交換性」的影響呢，實際上是這樣的，作者是將八元數的除法運算轉化為了八元數的乘法運算， (*this)*inverse_of(rhs) ，因為八元數乘法是不滿足交換律的，所以，八元數中的除法的順序很重要) ) 並且將計算結果存放在 *this之中. 未特化的形式有異常保護, 但是特化的版本沒有, 以便確保異常安全. 對於未特化的形式, 基類型的賦值操作禁止拋出異常. 與乘法運算一樣, 記住使用括號將任意兩個因子進行分組.