ceph/src/boost/libs/math/doc/octonion/math-octonion.qbk

   1
   2 [def __R ['[*R]]]
   3 [def __C ['[*C]]]
   4 [def __H ['[*H]]]
   5 [def __O ['[*O]]]
   6 [def __R3 ['[*'''R<superscript>3</superscript>''']]]
   7 [def __R4 ['[*'''R<superscript>4</superscript>''']]]
   8 [def __octulple ('''&#x03B1;,&#x03B2;,&#x03B3;,&#x03B4;,&#x03B5;,&#x03B6;,&#x03B7;,&#x03B8;''')]
   9 [def __oct_formula ['[^o = '''&#x03B1; + &#x03B2;i + &#x03B3;j + &#x03B4;k + &#x03B5;e' + &#x03B6;i' + &#x03B7;j' + &#x03B8;k' ''']]]
  10 [def __oct_complex_formula ['[^o = ('''&#x03B1; + &#x03B2;i) + (&#x03B3; + &#x03B4;i)j + (&#x03B5; + &#x03B6;i)e' + (&#x03B7; - &#x03B8;i)j' ''']]]
  11 [def __oct_quat_formula ['[^o = ('''&#x03B1; + &#x03B2;i + &#x03B3;j + &#x03B4;k) + (&#x03B5; + &#x03B6;i + &#x03B7;j - &#x03B8;j)e' ''']]]
  12 [def __oct_not_equal ['[^x(yz) '''&#x2260;''' (xy)z]]]
  13
  14 [mathpart octonions Octonions]
  15
  16 [section:oct_overview Overview]
  17
  18 Octonions, like [link quaternions quaternions], are a relative of complex numbers.
  19
  20 Octonions see some use in theoretical physics.
  21
  22 In practical terms, an octonion is simply an octuple of real numbers __octulple,
  23 which we can write in the form __oct_formula, where ['[^i]], ['[^j]] and ['[^k]]
  24 are the same objects as for quaternions, and ['[^e']], ['[^i']], ['[^j']] and ['[^k']]
  25 are distinct objects which play essentially the same kind of role as ['[^i]] (or ['[^j]] or ['[^k]]).
  26
  27 Addition and a multiplication is defined on the set of octonions,
  28 which generalize their quaternionic counterparts. The main novelty this time
  29 is that [*the multiplication is not only not commutative, is now not even
  30 associative] (i.e. there are octonions ['[^x]], ['[^y]] and ['[^z]] such that __oct_not_equal).
  31 A way of remembering things is by using the following multiplication table:
  32
  33 [$../octonion/graphics/octonion_blurb17.jpeg]
  34
  35 Octonions (and their kin) are described in far more details in this other
  36 [@../quaternion/TQE.pdf document]
  37 (with [@../quaternion/TQE_EA.pdf errata and addenda]).
  38
  39 Some traditional constructs, such as the exponential, carry over without too
  40 much change into the realms of octonions, but other, such as taking a square root,
  41 do not (the fact that the exponential has a closed form is a result of the
  42 author, but the fact that the exponential exists at all for octonions is known
  43 since quite a long time ago).
  44
  45 [endsect]
  46
  47 [section:oct_header Header File]
  48
  49 The interface and implementation are both supplied by the header file
  50 [@../../../../boost/math/octonion.hpp octonion.hpp].
  51
  52 [endsect]
  53
  54 [section:oct_synopsis Synopsis]
  55
  56    namespace boost{ namespace math{
  57
  58    template<typename T> class ``[link math_toolkit.octonion octonion]``;
  59    template<>           class ``[link math_toolkit.oct_specialization octonion<float>]``;
  60    template<>           class ``[link math_octonion_double octonion<double>]``;
  61    template<>           class ``[link math_octonion_long_double octonion<long double>]``;
  62
  63    // operators
  64
  65    template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_addition_operators operator +]`` (T const & lhs, octonion<T> const & rhs);
  66    template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_addition_operators operator +]`` (octonion<T> const & lhs, T const & rhs);
  67    template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_addition_operators operator +]`` (::std::complex<T> const & lhs, octonion<T> const & rhs);
  68    template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_addition_operators operator +]`` (octonion<T> const & lhs, ::std::complex<T> const & rhs);
  69    template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_addition_operators operator +]`` (::boost::math::quaternion<T> const & lhs, octonion<T> const & rhs);
  70    template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_addition_operators operator +]`` (octonion<T> const & lhs, ::boost::math::quaternion<T> const & rhs);
  71    template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_addition_operators operator +]`` (octonion<T> const & lhs, octonion<T> const & rhs);
  72
  73    template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_subtraction_operators operator -]`` (T const & lhs, octonion<T> const & rhs);
  74    template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_subtraction_operators operator -]`` (octonion<T> const & lhs, T const & rhs);
  75    template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_subtraction_operators operator -]`` (::std::complex<T> const & lhs, octonion<T> const & rhs);
  76    template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_subtraction_operators operator -]`` (octonion<T> const & lhs, ::std::complex<T> const & rhs);
  77    template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_subtraction_operators operator -]`` (::boost::math::quaternion<T> const & lhs, octonion<T> const & rhs);
  78    template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_subtraction_operators operator -]`` (octonion<T> const & lhs, ::boost::math::quaternion<T> const & rhs);
  79    template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_subtraction_operators operator -]`` (octonion<T> const & lhs, octonion<T> const & rhs);
  80
  81    template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_multiplication_operators operator *]`` (T const & lhs, octonion<T> const & rhs);
  82    template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_multiplication_operators operator *]`` (octonion<T> const & lhs, T const & rhs);
  83    template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_multiplication_operators operator *]`` (::std::complex<T> const & lhs, octonion<T> const & rhs);
  84    template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_multiplication_operators operator *]`` (octonion<T> const & lhs, ::std::complex<T> const & rhs);
  85    template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_multiplication_operators operator *]`` (::boost::math::quaternion<T> const & lhs, octonion<T> const & rhs);
  86    template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_multiplication_operators operator *]`` (octonion<T> const & lhs, ::boost::math::quaternion<T> const & rhs);
  87    template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_multiplication_operators operator *]`` (octonion<T> const & lhs, octonion<T> const & rhs);
  88
  89    template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_division_operators operator /]`` (T const & lhs, octonion<T> const & rhs);
  90    template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_division_operators operator /]`` (octonion<T> const & lhs, T const & rhs);
  91    template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_division_operators operator /]`` (::std::complex<T> const & lhs, octonion<T> const & rhs);
  92    template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_division_operators operator /]`` (octonion<T> const & lhs, ::std::complex<T> const & rhs);
  93    template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_division_operators operator /]`` (::boost::math::quaternion<T> const & lhs, octonion<T> const & rhs);
  94    template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_division_operators operator /]`` (octonion<T> const & lhs, ::boost::math::quaternion<T> const & rhs);
  95    template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_division_operators operator /]`` (octonion<T> const & lhs, octonion<T> const & rhs);
  96
  97    template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.unary_plus_and_minus_operators operator +]`` (octonion<T> const & o);
  98    template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.unary_plus_and_minus_operators operator -]`` (octonion<T> const & o);
  99
 100    template<typename T> bool ``[link math_toolkit.oct_non_mem.binary_equality_operators operator ==]`` (T const & lhs, octonion<T> const & rhs);
 101    template<typename T> bool ``[link math_toolkit.oct_non_mem.binary_equality_operators operator ==]`` (octonion<T> const & lhs, T const & rhs);
 102    template<typename T> bool ``[link math_toolkit.oct_non_mem.binary_equality_operators operator ==]`` (::std::complex<T> const & lhs, octonion<T> const & rhs);
 103    template<typename T> bool ``[link math_toolkit.oct_non_mem.binary_equality_operators operator ==]`` (octonion<T> const & lhs, ::std::complex<T> const & rhs);
 104    template<typename T> bool ``[link math_toolkit.oct_non_mem.binary_equality_operators operator ==]`` (::boost::math::quaternion<T> const & lhs, octonion<T> const & rhs);
 105    template<typename T> bool ``[link math_toolkit.oct_non_mem.binary_equality_operators operator ==]`` (octonion<T> const & lhs, ::boost::math::quaternion<T> const & rhs);
 106    template<typename T> bool ``[link math_toolkit.oct_non_mem.binary_equality_operators operator ==]`` (octonion<T> const & lhs, octonion<T> const & rhs);
 107
 108    template<typename T> bool ``[link math_toolkit.oct_non_mem.binary_inequality_operators operator !=]`` (T const & lhs, octonion<T> const & rhs);
 109    template<typename T> bool ``[link math_toolkit.oct_non_mem.binary_inequality_operators operator !=]`` (octonion<T> const & lhs, T const & rhs);
 110    template<typename T> bool ``[link math_toolkit.oct_non_mem.binary_inequality_operators operator !=]`` (::std::complex<T> const & lhs, octonion<T> const & rhs);
 111    template<typename T> bool ``[link math_toolkit.oct_non_mem.binary_inequality_operators operator !=]`` (octonion<T> const & lhs, ::std::complex<T> const & rhs);
 112    template<typename T> bool ``[link math_toolkit.oct_non_mem.binary_inequality_operators operator !=]`` (::boost::math::quaternion<T> const & lhs, octonion<T> const & rhs);
 113    template<typename T> bool ``[link math_toolkit.oct_non_mem.binary_inequality_operators operator !=]`` (octonion<T> const & lhs, ::boost::math::quaternion<T> const & rhs);
 114    template<typename T> bool ``[link math_toolkit.oct_non_mem.binary_inequality_operators operator !=]`` (octonion<T> const & lhs, octonion<T> const & rhs);
 115
 116    template<typename T, typename charT, class traits>
 117    ::std::basic_istream<charT,traits> & ``[link math_toolkit.oct_non_mem.stream_extractor operator >>]`` (::std::basic_istream<charT,traits> & is, octonion<T> & o);
 118
 119    template<typename T, typename charT, class traits>
 120    ::std::basic_ostream<charT,traits> & ``[link math_toolkit.oct_non_mem.stream_inserter operator <<]`` (::std::basic_ostream<charT,traits> & os, octonion<T> const & o);
 121
 122    // values
 123
 124    template<typename T> T           ``[link math_toolkit.oct_value_ops.real_and_unreal real]``(octonion<T> const & o);
 125    template<typename T> octonion<T> ``[link math_toolkit.oct_value_ops.real_and_unreal unreal]``(octonion<T> const & o);
 126
 127    template<typename T> T           ``[link math_toolkit.oct_value_ops.sup sup]``(octonion<T> const & o);
 128    template<typename T> T           ``[link math_toolkit.oct_value_ops.l1 l1]``(octonion<T>const & o);
 129    template<typename T> T           ``[link math_toolkit.oct_value_ops.abs abs]``(octonion<T> const & o);
 130    template<typename T> T           ``[link math_toolkit.oct_value_ops.norm norm]``(octonion<T>const  & o);
 131    template<typename T> octonion<T> ``[link math_toolkit.oct_value_ops.conj conj]``(octonion<T> const & o);
 132
 133    template<typename T> octonion<T> ``[link math_toolkit.oct_create spherical]``(T const & rho, T const & theta, T const & phi1, T const & phi2, T const & phi3, T const & phi4, T const & phi5, T const & phi6);
 134    template<typename T> octonion<T> ``[link math_toolkit.oct_create multipolar]``(T const & rho1, T const & theta1, T const & rho2, T const & theta2, T const & rho3, T const & theta3, T const & rho4, T const & theta4);
 135    template<typename T> octonion<T> ``[link math_toolkit.oct_create cylindrical]``(T const & r, T const & angle, T const & h1, T const & h2, T const & h3, T const & h4, T const & h5, T const & h6);
 136
 137    // transcendentals
 138
 139    template<typename T> octonion<T> ``[link math_toolkit.oct_trans.exp exp]``(octonion<T> const & o);
 140    template<typename T> octonion<T> ``[link math_toolkit.oct_trans.cos cos]``(octonion<T> const & o);
 141    template<typename T> octonion<T> ``[link math_toolkit.oct_trans.sin sin]``(octonion<T> const & o);
 142    template<typename T> octonion<T> ``[link math_toolkit.oct_trans.tan tan]``(octonion<T> const & o);
 143    template<typename T> octonion<T> ``[link math_toolkit.oct_trans.cosh cosh]``(octonion<T> const & o);
 144    template<typename T> octonion<T> ``[link math_toolkit.oct_trans.sinh sinh]``(octonion<T> const & o);
 145    template<typename T> octonion<T> ``[link math_toolkit.oct_trans.tanh tanh]``(octonion<T> const & o);
 146
 147    template<typename T> octonion<T> ``[link math_toolkit.oct_trans.pow pow]``(octonion<T> const & o, int n);
 148
 149    }  } // namespaces
 150
 151 [endsect]
 152
 153 [section:octonion Template Class octonion]
 154
 155    namespace boost{ namespace math {
 156
 157    template<typename T>
 158    class octonion
 159    {
 160    public:
 161       typedef T value_type;
 162
 163       explicit  ``[link math_toolkit.oct_mem_fun.constructors 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());
 164       explicit  ``[link math_toolkit.oct_mem_fun.constructors 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>());
 165       explicit  ``[link math_toolkit.oct_mem_fun.constructors octonion]``(::boost::math::quaternion<T> const & q0, ::boost::math::quaternion<T> const & q1 = ::boost::math::quaternion<T>());
 166       template<typename X>
 167       explicit  ``[link math_toolkit.oct_mem_fun.constructors octonion]``(octonion<X> const & a_recopier);
 168
 169       T                             ``[link math_toolkit.oct_mem_fun.real_and_unreal_parts real]``() const;
 170       octonion<T>                   ``[link math_toolkit.oct_mem_fun.real_and_unreal_parts unreal]``() const;
 171
 172       T                             ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_1]``() const;
 173       T                             ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_2]``() const;
 174       T                             ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_3]``() const;
 175       T                             ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_4]``() const;
 176       T                             ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_5]``() const;
 177       T                             ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_6]``() const;
 178       T                             ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_7]``() const;
 179       T                             ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_8]``() const;
 180
 181       ::std::complex<T>             ``[link math_toolkit.oct_mem_fun.individual_complex_components C_component_1]``() const;
 182       ::std::complex<T>             ``[link math_toolkit.oct_mem_fun.individual_complex_components C_component_2]``() const;
 183       ::std::complex<T>             ``[link math_toolkit.oct_mem_fun.individual_complex_components C_component_3]``() const;
 184       ::std::complex<T>             ``[link math_toolkit.oct_mem_fun.individual_complex_components C_component_4]``() const;
 185
 186       ::boost::math::quaternion<T>  ``[link math_toolkit.oct_mem_fun.individual_quaternion_components H_component_1]``() const;
 187       ::boost::math::quaternion<T>  ``[link math_toolkit.oct_mem_fun.individual_quaternion_components H_component_2]``() const;
 188
 189       octonion<T> & ``[link math_toolkit.oct_mem_fun.assignment_operators operator =]`` (octonion<T> const  & a_affecter);
 190       template<typename X>
 191       octonion<T> & ``[link math_toolkit.oct_mem_fun.assignment_operators operator =]`` (octonion<X> const  & a_affecter);
 192       octonion<T> & ``[link math_toolkit.oct_mem_fun.assignment_operators operator =]`` (T const  & a_affecter);
 193       octonion<T> & ``[link math_toolkit.oct_mem_fun.assignment_operators operator =]`` (::std::complex<T> const & a_affecter);
 194       octonion<T> & ``[link math_toolkit.oct_mem_fun.assignment_operators operator =]`` (::boost::math::quaternion<T> const & a_affecter);
 195
 196       octonion<T> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator +=]`` (T const & rhs);
 197       octonion<T> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator +=]`` (::std::complex<T> const & rhs);
 198       octonion<T> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator +=]`` (::boost::math::quaternion<T> const & rhs);
 199       template<typename X>
 200       octonion<T> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator +=]`` (octonion<X> const & rhs);
 201
 202       octonion<T> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator -=]`` (T const & rhs);
 203       octonion<T> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator -=]`` (::std::complex<T> const & rhs);
 204       octonion<T> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator -=]`` (::boost::math::quaternion<T> const & rhs);
 205       template<typename X>
 206       octonion<T> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator -=]`` (octonion<X> const & rhs);
 207
 208       octonion<T> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator *=]`` (T const & rhs);
 209       octonion<T> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator *=]`` (::std::complex<T> const & rhs);
 210       octonion<T> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator *=]`` (::boost::math::quaternion<T> const & rhs);
 211       template<typename X>
 212       octonion<T> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator *=]`` (octonion<X> const & rhs);
 213
 214       octonion<T> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator /=]`` (T const & rhs);
 215       octonion<T> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator /=]`` (::std::complex<T> const & rhs);
 216       octonion<T> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator /=]`` (::boost::math::quaternion<T> const & rhs);
 217       template<typename X>
 218       octonion<T> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator /=]`` (octonion<X> const & rhs);
 219    };
 220
 221    } } // namespaces
 222
 223 [endsect]
 224
 225 [section:oct_specialization Octonion Specializations]
 226
 227    namespace boost{ namespace math{
 228
 229    template<>
 230    class octonion<float>
 231    {
 232    public:
 233       typedef float value_type;
 234
 235       explicit  ``[link math_toolkit.oct_mem_fun.constructors 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);
 236       explicit  ``[link math_toolkit.oct_mem_fun.constructors 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>());
 237       explicit  ``[link math_toolkit.oct_mem_fun.constructors octonion]``(::boost::math::quaternion<float> const & q0, ::boost::math::quaternion<float> const & q1 = ::boost::math::quaternion<float>());
 238       explicit  ``[link math_toolkit.oct_mem_fun.constructors octonion]``(octonion<double> const & a_recopier);
 239       explicit  ``[link math_toolkit.oct_mem_fun.constructors octonion]``(octonion<long double> const & a_recopier);
 240
 241       float                             ``[link math_toolkit.oct_mem_fun.real_and_unreal_parts real]``() const;
 242       octonion<float>                   ``[link math_toolkit.oct_mem_fun.real_and_unreal_parts unreal]``() const;
 243
 244       float                             ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_1]``() const;
 245       float                             ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_2]``() const;
 246       float                             ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_3]``() const;
 247       float                             ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_4]``() const;
 248       float                             ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_5]``() const;
 249       float                             ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_6]``() const;
 250       float                             ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_7]``() const;
 251       float                             ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_8]``() const;
 252
 253       ::std::complex<float>             ``[link math_toolkit.oct_mem_fun.individual_complex_components C_component_1]``() const;
 254       ::std::complex<float>             ``[link math_toolkit.oct_mem_fun.individual_complex_components C_component_2]``() const;
 255       ::std::complex<float>             ``[link math_toolkit.oct_mem_fun.individual_complex_components C_component_3]``() const;
 256       ::std::complex<float>             ``[link math_toolkit.oct_mem_fun.individual_complex_components C_component_4]``() const;
 257
 258       ::boost::math::quaternion<float>  ``[link math_toolkit.oct_mem_fun.individual_quaternion_components H_component_1]``() const;
 259       ::boost::math::quaternion<float>  ``[link math_toolkit.oct_mem_fun.individual_quaternion_components H_component_2]``() const;
 260
 261       octonion<float> & ``[link math_toolkit.oct_mem_fun.assignment_operators operator =]`` (octonion<float> const  & a_affecter);
 262       template<typename X>
 263       octonion<float> & ``[link math_toolkit.oct_mem_fun.assignment_operators operator =]`` (octonion<X> const  & a_affecter);
 264       octonion<float> & ``[link math_toolkit.oct_mem_fun.assignment_operators operator =]`` (float const  & a_affecter);
 265       octonion<float> & ``[link math_toolkit.oct_mem_fun.assignment_operators operator =]`` (::std::complex<float> const & a_affecter);
 266       octonion<float> & ``[link math_toolkit.oct_mem_fun.assignment_operators operator =]`` (::boost::math::quaternion<float> const & a_affecter);
 267
 268       octonion<float> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator +=]`` (float const & rhs);
 269       octonion<float> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator +=]`` (::std::complex<float> const & rhs);
 270       octonion<float> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator +=]`` (::boost::math::quaternion<float> const & rhs);
 271       template<typename X>
 272       octonion<float> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator +=]`` (octonion<X> const & rhs);
 273
 274       octonion<float> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator -=]`` (float const & rhs);
 275       octonion<float> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator -=]`` (::std::complex<float> const & rhs);
 276       octonion<float> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator -=]`` (::boost::math::quaternion<float> const & rhs);
 277       template<typename X>
 278       octonion<float> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator -=]`` (octonion<X> const & rhs);
 279
 280       octonion<float> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator *=]`` (float const & rhs);
 281       octonion<float> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator *=]`` (::std::complex<float> const & rhs);
 282       octonion<float> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator *=]`` (::boost::math::quaternion<float> const & rhs);
 283       template<typename X>
 284       octonion<float> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator *=]`` (octonion<X> const & rhs);
 285
 286       octonion<float> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator /=]`` (float const & rhs);
 287       octonion<float> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator /=]`` (::std::complex<float> const & rhs);
 288       octonion<float> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator /=]`` (::boost::math::quaternion<float> const & rhs);
 289       template<typename X>
 290       octonion<float> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator /=]`` (octonion<X> const & rhs);
 291    };
 292
 293 [#math_octonion_double]
 294
 295    template<>
 296    class octonion<double>
 297    {
 298    public:
 299       typedef double value_type;
 300
 301       explicit  ``[link math_toolkit.oct_mem_fun.constructors 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);
 302       explicit  ``[link math_toolkit.oct_mem_fun.constructors 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>());
 303       explicit  ``[link math_toolkit.oct_mem_fun.constructors octonion]``(::boost::math::quaternion<double> const & q0, ::boost::math::quaternion<double> const & q1 = ::boost::math::quaternion<double>());
 304       explicit  ``[link math_toolkit.oct_mem_fun.constructors octonion]``(octonion<float> const & a_recopier);
 305       explicit  ``[link math_toolkit.oct_mem_fun.constructors octonion]``(octonion<long double> const & a_recopier);
 306
 307       double                             ``[link math_toolkit.oct_mem_fun.real_and_unreal_parts real]``() const;
 308       octonion<double>                   ``[link math_toolkit.oct_mem_fun.real_and_unreal_parts unreal]``() const;
 309
 310       double                             ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_1]``() const;
 311       double                             ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_2]``() const;
 312       double                             ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_3]``() const;
 313       double                             ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_4]``() const;
 314       double                             ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_5]``() const;
 315       double                             ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_6]``() const;
 316       double                             ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_7]``() const;
 317       double                             ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_8]``() const;
 318
 319       ::std::complex<double>             ``[link math_toolkit.oct_mem_fun.individual_complex_components C_component_1]``() const;
 320       ::std::complex<double>             ``[link math_toolkit.oct_mem_fun.individual_complex_components C_component_2]``() const;
 321       ::std::complex<double>             ``[link math_toolkit.oct_mem_fun.individual_complex_components C_component_3]``() const;
 322       ::std::complex<double>             ``[link math_toolkit.oct_mem_fun.individual_complex_components C_component_4]``() const;
 323
 324       ::boost::math::quaternion<double>  ``[link math_toolkit.oct_mem_fun.individual_quaternion_components H_component_1]``() const;
 325       ::boost::math::quaternion<double>  ``[link math_toolkit.oct_mem_fun.individual_quaternion_components H_component_2]``() const;
 326
 327       octonion<double> & ``[link math_toolkit.oct_mem_fun.assignment_operators operator =]`` (octonion<double> const  & a_affecter);
 328       template<typename X>
 329       octonion<double> & ``[link math_toolkit.oct_mem_fun.assignment_operators operator =]`` (octonion<X> const  & a_affecter);
 330       octonion<double> & ``[link math_toolkit.oct_mem_fun.assignment_operators operator =]`` (double const  & a_affecter);
 331       octonion<double> & ``[link math_toolkit.oct_mem_fun.assignment_operators operator =]`` (::std::complex<double> const & a_affecter);
 332       octonion<double> & ``[link math_toolkit.oct_mem_fun.assignment_operators operator =]`` (::boost::math::quaternion<double> const & a_affecter);
 333
 334       octonion<double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator +=]`` (double const & rhs);
 335       octonion<double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator +=]`` (::std::complex<double> const & rhs);
 336       octonion<double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator +=]`` (::boost::math::quaternion<double> const & rhs);
 337       template<typename X>
 338       octonion<double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator +=]`` (octonion<X> const & rhs);
 339
 340       octonion<double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator -=]`` (double const & rhs);
 341       octonion<double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator -=]`` (::std::complex<double> const & rhs);
 342       octonion<double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator -=]`` (::boost::math::quaternion<double> const & rhs);
 343       template<typename X>
 344       octonion<double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator -=]`` (octonion<X> const & rhs);
 345
 346       octonion<double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator *=]`` (double const & rhs);
 347       octonion<double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator *=]`` (::std::complex<double> const & rhs);
 348       octonion<double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator *=]`` (::boost::math::quaternion<double> const & rhs);
 349       template<typename X>
 350       octonion<double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator *=]`` (octonion<X> const & rhs);
 351
 352       octonion<double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator /=]`` (double const & rhs);
 353       octonion<double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator /=]`` (::std::complex<double> const & rhs);
 354       octonion<double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator /=]`` (::boost::math::quaternion<double> const & rhs);
 355       template<typename X>
 356       octonion<double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator /=]`` (octonion<X> const & rhs);
 357    };
 358
 359 [#math_octonion_long_double]
 360
 361    template<>
 362    class octonion<long double>
 363    {
 364    public:
 365       typedef long double value_type;
 366
 367       explicit   ``[link math_toolkit.oct_mem_fun.constructors 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);
 368       explicit   ``[link math_toolkit.oct_mem_fun.constructors 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>());
 369       explicit   ``[link math_toolkit.oct_mem_fun.constructors octonion]``( ::boost::math::quaternion<long double> const & q0, ::boost::math::quaternion<long double> const & z1 = ::boost::math::quaternion<long double>());
 370       explicit   ``[link math_toolkit.oct_mem_fun.constructors octonion]``(octonion<float> const & a_recopier);
 371       explicit   ``[link math_toolkit.oct_mem_fun.constructors octonion]``(octonion<double> const & a_recopier);
 372
 373       long double                             ``[link math_toolkit.oct_mem_fun.real_and_unreal_parts real]``() const;
 374       octonion<long double>                   ``[link math_toolkit.oct_mem_fun.real_and_unreal_parts unreal]``() const;
 375
 376       long double                             ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_1]``() const;
 377       long double                             ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_2]``() const;
 378       long double                             ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_3]``() const;
 379       long double                             ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_4]``() const;
 380       long double                             ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_5]``() const;
 381       long double                             ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_6]``() const;
 382       long double                             ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_7]``() const;
 383       long double                             ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_8]``() const;
 384
 385       ::std::complex<long double>             ``[link math_toolkit.oct_mem_fun.individual_complex_components C_component_1]``() const;
 386       ::std::complex<long double>             ``[link math_toolkit.oct_mem_fun.individual_complex_components C_component_2]``() const;
 387       ::std::complex<long double>             ``[link math_toolkit.oct_mem_fun.individual_complex_components C_component_3]``() const;
 388       ::std::complex<long double>             ``[link math_toolkit.oct_mem_fun.individual_complex_components C_component_4]``() const;
 389
 390       ::boost::math::quaternion<long double>  ``[link math_toolkit.oct_mem_fun.individual_quaternion_components H_component_1]``() const;
 391       ::boost::math::quaternion<long double>  ``[link math_toolkit.oct_mem_fun.individual_quaternion_components H_component_2]``() const;
 392
 393       octonion<long double> & ``[link math_toolkit.oct_mem_fun.assignment_operators operator =]`` (octonion<long double> const  & a_affecter);
 394       template<typename X>
 395       octonion<long double> & ``[link math_toolkit.oct_mem_fun.assignment_operators operator =]`` (octonion<X> const  & a_affecter);
 396       octonion<long double> & ``[link math_toolkit.oct_mem_fun.assignment_operators operator =]`` (long double const  & a_affecter);
 397       octonion<long double> & ``[link math_toolkit.oct_mem_fun.assignment_operators operator =]`` (::std::complex<long double> const & a_affecter);
 398       octonion<long double> & ``[link math_toolkit.oct_mem_fun.assignment_operators operator =]`` (::boost::math::quaternion<long double> const & a_affecter);
 399
 400       octonion<long double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator +=]`` (long double const & rhs);
 401       octonion<long double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator +=]`` (::std::complex<long double> const & rhs);
 402       octonion<long double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator +=]`` (::boost::math::quaternion<long double> const & rhs);
 403       template<typename X>
 404       octonion<long double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator +=]`` (octonion<X> const & rhs);
 405
 406       octonion<long double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator -=]`` (long double const & rhs);
 407       octonion<long double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator -=]`` (::std::complex<long double> const & rhs);
 408       octonion<long double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator -=]`` (::boost::math::quaternion<long double> const & rhs);
 409       template<typename X>
 410       octonion<long double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator -=]`` (octonion<X> const & rhs);
 411
 412       octonion<long double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator *=]`` (long double const & rhs);
 413       octonion<long double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator *=]`` (::std::complex<long double> const & rhs);
 414       octonion<long double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator *=]`` (::boost::math::quaternion<long double> const & rhs);
 415       template<typename X>
 416       octonion<long double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator *=]`` (octonion<X> const & rhs);
 417
 418       octonion<long double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator /=]`` (long double const & rhs);
 419       octonion<long double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator /=]`` (::std::complex<long double> const & rhs);
 420       octonion<long double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator /=]`` (::boost::math::quaternion<long double> const & rhs);
 421       template<typename X>
 422       octonion<long double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator /=]`` (octonion<X> const & rhs);
 423    };
 424
 425    } } // namespaces
 426
 427 [endsect]
 428
 429 [section:oct_typedefs Octonion Member Typedefs]
 430
 431 [*value_type]
 432
 433 Template version:
 434
 435    typedef T value_type;
 436
 437 Float specialization version:
 438
 439    typedef float value_type;
 440
 441 Double specialization version:
 442
 443    typedef double value_type;
 444
 445 Long double specialization version:
 446
 447    typedef long double value_type;
 448
 449 These provide easy acces to the type the template is built upon.
 450
 451 [endsect]
 452
 453 [section:oct_mem_fun Octonion Member Functions]
 454
 455 [h3 Constructors]
 456
 457 Template version:
 458
 459    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());
 460    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>());
 461    explicit  octonion(::boost::math::quaternion<T> const & q0, ::boost::math::quaternion<T> const & q1 = ::boost::math::quaternion<T>());
 462    template<typename X>
 463    explicit octonion(octonion<X> const & a_recopier);
 464
 465 Float specialization version:
 466
 467    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);
 468    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>());
 469    explicit  octonion(::boost::math::quaternion<float> const & q0, ::boost::math::quaternion<float> const & q1 = ::boost::math::quaternion<float>());
 470    explicit  octonion(octonion<double> const & a_recopier);
 471    explicit  octonion(octonion<long double> const & a_recopier);
 472
 473 Double specialization version:
 474
 475    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);
 476    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>());
 477    explicit  octonion(::boost::math::quaternion<double> const & q0, ::boost::math::quaternion<double> const & q1 = ::boost::math::quaternion<double>());
 478    explicit  octonion(octonion<float> const & a_recopier);
 479    explicit  octonion(octonion<long double> const & a_recopier);
 480
 481 Long double specialization version:
 482
 483    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);
 484    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>());
 485    explicit  octonion(::boost::math::quaternion<long double> const & q0, ::boost::math::quaternion<long double> const & q1 = ::boost::math::quaternion<long double>());
 486    explicit  octonion(octonion<float> const & a_recopier);
 487    explicit  octonion(octonion<double> const & a_recopier);
 488
 489 A default constructor is provided for each form, which initializes each component
 490 to the default values for their type (i.e. zero for floating numbers).
 491 This constructor can also accept one to eight base type arguments.
 492 A constructor is also provided to build octonions from one to four complex numbers
 493 sharing the same base type, and another taking one or two quaternions
 494 sharing the same base type. The unspecialized template also sports a
 495 templarized copy constructor, while the specialized forms have copy
 496 constructors from the other two specializations, which are explicit
 497 when a risk of precision loss exists. For the unspecialized form,
 498 the base type's constructors must not throw.
 499
 500 Destructors and untemplated copy constructors (from the same type)
 501 are provided by the compiler. Converting copy constructors make use
 502 of a templated helper function in a "detail" subnamespace.
 503
 504 [h3 Other member functions]
 505
 506 [h4 Real and Unreal Parts]
 507
 508    T            real()   const;
 509    octonion<T>  unreal() const;
 510
 511 Like complex number, octonions do have a meaningful notion of "real part",
 512 but unlike them there is no meaningful notion of "imaginary part".
 513 Instead there is an "unreal part" which itself is a octonion,
 514 and usually nothing simpler (as opposed to the complex number case).
 515 These are returned by the first two functions.
 516
 517 [h4 Individual Real Components]
 518
 519    T   R_component_1() const;
 520    T   R_component_2() const;
 521    T   R_component_3() const;
 522    T   R_component_4() const;
 523    T   R_component_5() const;
 524    T   R_component_6() const;
 525    T   R_component_7() const;
 526    T   R_component_8() const;
 527
 528 A octonion having eight real components, these are returned by
 529 these eight functions. Hence real and R_component_1 return the same value.
 530
 531 [h4 Individual Complex Components]
 532
 533    ::std::complex<T> C_component_1() const;
 534    ::std::complex<T> C_component_2() const;
 535    ::std::complex<T> C_component_3() const;
 536    ::std::complex<T> C_component_4() const;
 537
 538 A octonion likewise has four complex components. Actually, octonions
 539 are indeed a (left) vector field over the complexes, but beware, as
 540 for any octonion __oct_formula we also have __oct_complex_formula
 541 (note the [*minus] sign in the last factor).
 542 What the C_component_n functions return, however, are the complexes
 543 which could be used to build the octonion using the constructor, and
 544 [*not] the components of the octonion on the basis ['[^(1, j, e', j')]].
 545
 546 [h4 Individual Quaternion Components]
 547
 548    ::boost::math::quaternion<T> H_component_1() const;
 549    ::boost::math::quaternion<T> H_component_2() const;
 550
 551 Likewise, for any octonion __oct_formula we also have __oct_quat_formula, though there
 552 is no meaningful vector-space-like structure based on the quaternions.
 553 What the H_component_n functions return are the quaternions which
 554 could be used to build the octonion using the constructor.
 555
 556 [h3 Octonion Member Operators]
 557 [h4 Assignment Operators]
 558
 559    octonion<T> & operator = (octonion<T> const & a_affecter);
 560    template<typename X>
 561    octonion<T> & operator = (octonion<X> const & a_affecter);
 562    octonion<T> & operator = (T const & a_affecter);
 563    octonion<T> & operator = (::std::complex<T> const & a_affecter);
 564    octonion<T> & operator = (::boost::math::quaternion<T> const & a_affecter);
 565
 566 These perform the expected assignment, with type modification if
 567 necessary (for instance, assigning from a base type will set the
 568 real part to that value, and all other components to zero).
 569 For the unspecialized form, the base type's assignment operators must not throw.
 570
 571 [h4 Other Member Operators]
 572
 573    octonion<T> & operator += (T const & rhs)
 574    octonion<T> & operator += (::std::complex<T> const & rhs);
 575    octonion<T> & operator += (::boost::math::quaternion<T> const & rhs);
 576    template<typename X>
 577    octonion<T> & operator += (octonion<X> const & rhs);
 578
 579 These perform the mathematical operation `(*this)+rhs` and store the result in
 580 `*this`. The unspecialized form has exception guards, which the specialized
 581 forms do not, so as to insure exception safety. For the unspecialized form,
 582 the base type's assignment operators must not throw.
 583
 584    octonion<T> & operator -= (T const & rhs)
 585    octonion<T> & operator -= (::std::complex<T> const & rhs);
 586    octonion<T> & operator -= (::boost::math::quaternion<T> const & rhs);
 587    template<typename X>
 588    octonion<T> & operator -= (octonion<X> const & rhs);
 589
 590 These perform the mathematical operation `(*this)-rhs` and store the result
 591 in `*this`. The unspecialized form has exception guards, which the
 592 specialized forms do not, so as to insure exception safety.
 593 For the unspecialized form, the base type's assignment operators must not throw.
 594
 595    octonion<T> & operator *= (T const & rhs)
 596    octonion<T> & operator *= (::std::complex<T> const & rhs);
 597    octonion<T> & operator *= (::boost::math::quaternion<T> const & rhs);
 598    template<typename X>
 599    octonion<T> & operator *= (octonion<X> const & rhs);
 600
 601 These perform the mathematical operation `(*this)*rhs` in this order
 602 (order is important as multiplication is not commutative for octonions)
 603 and store the result in `*this`. The unspecialized form has exception guards,
 604 which the specialized forms do not, so as to insure exception safety.
 605 For the unspecialized form, the base type's assignment operators must
 606 not throw. Also, for clarity's sake, you should always group the
 607 factors in a multiplication by groups of two, as the multiplication is
 608 not even associative on the octonions (though there are of course cases
 609 where this does not matter, it usually does).
 610
 611    octonion<T> & operator /= (T const & rhs)
 612    octonion<T> & operator /= (::std::complex<T> const & rhs);
 613    octonion<T> & operator /= (::boost::math::quaternion<T> const & rhs);
 614    template<typename X>
 615    octonion<T> & operator /= (octonion<X> const & rhs);
 616
 617 These perform the mathematical operation `(*this)*inverse_of(rhs)`
 618 in this order (order is important as multiplication is not commutative
 619 for octonions) and store the result in `*this`. The unspecialized form
 620 has exception guards, which the specialized forms do not, so as to
 621 insure exception safety. For the unspecialized form, the base
 622 type's assignment operators must not throw. As for the multiplication,
 623 remember to group any two factors using parenthesis.
 624
 625 [endsect]
 626
 627 [section:oct_non_mem Octonion Non-Member Operators]
 628
 629 [h4 Unary Plus and Minus Operators]
 630
 631    template<typename T> octonion<T> operator + (octonion<T> const & o);
 632
 633 This unary operator simply returns o.
 634
 635    template<typename T> octonion<T> operator - (octonion<T> const & o);
 636
 637 This unary operator returns the opposite of o.
 638
 639 [h4 Binary Addition Operators]
 640
 641    template<typename T> octonion<T> operator + (T const & lhs, octonion<T> const & rhs);
 642    template<typename T> octonion<T> operator + (octonion<T> const & lhs, T const & rhs);
 643    template<typename T> octonion<T> operator + (::std::complex<T> const & lhs, octonion<T> const & rhs);
 644    template<typename T> octonion<T> operator + (octonion<T> const & lhs, ::std::complex<T> const & rhs);
 645    template<typename T> octonion<T> operator + (::boost::math::quaternion<T> const & lhs, octonion<T> const & rhs);
 646    template<typename T> octonion<T> operator + (octonion<T> const & lhs, ::boost::math::quaternion<T> const & rhs);
 647    template<typename T> octonion<T> operator + (octonion<T> const & lhs, octonion<T> const & rhs);
 648
 649 These operators return `octonion<T>(lhs) += rhs`.
 650
 651 [h4 Binary Subtraction Operators]
 652
 653    template<typename T> octonion<T> operator - (T const & lhs, octonion<T> const & rhs);
 654    template<typename T> octonion<T> operator - (octonion<T> const & lhs, T const & rhs);
 655    template<typename T> octonion<T> operator - (::std::complex<T> const & lhs, octonion<T> const & rhs);
 656    template<typename T> octonion<T> operator - (octonion<T> const & lhs, ::std::complex<T> const & rhs);
 657    template<typename T> octonion<T> operator - (::boost::math::quaternion<T> const & lhs, octonion<T> const & rhs);
 658    template<typename T> octonion<T> operator - (octonion<T> const & lhs, ::boost::math::quaternion<T> const & rhs);
 659    template<typename T> octonion<T> operator - (octonion<T> const & lhs, octonion<T> const & rhs);
 660
 661 These operators return `octonion<T>(lhs) -= rhs`.
 662
 663 [h4 Binary Multiplication Operators]
 664
 665    template<typename T> octonion<T> operator * (T const & lhs, octonion<T> const & rhs);
 666    template<typename T> octonion<T> operator * (octonion<T> const & lhs, T const & rhs);
 667    template<typename T> octonion<T> operator * (::std::complex<T> const & lhs, octonion<T> const & rhs);
 668    template<typename T> octonion<T> operator * (octonion<T> const & lhs, ::std::complex<T> const & rhs);
 669    template<typename T> octonion<T> operator * (::boost::math::quaternion<T> const & lhs, octonion<T> const & rhs);
 670    template<typename T> octonion<T> operator * (octonion<T> const & lhs, ::boost::math::quaternion<T> const & rhs);
 671    template<typename T> octonion<T> operator * (octonion<T> const & lhs, octonion<T> const & rhs);
 672
 673 These operators return `octonion<T>(lhs) *= rhs`.
 674
 675 [h4 Binary Division Operators]
 676
 677    template<typename T> octonion<T> operator / (T const & lhs, octonion<T> const & rhs);
 678    template<typename T> octonion<T> operator / (octonion<T> const & lhs, T const & rhs);
 679    template<typename T> octonion<T> operator / (::std::complex<T> const & lhs, octonion<T> const & rhs);
 680    template<typename T> octonion<T> operator / (octonion<T> const & lhs, ::std::complex<T> const & rhs);
 681    template<typename T> octonion<T> operator / (::boost::math::quaternion<T> const & lhs, octonion<T> const & rhs);
 682    template<typename T> octonion<T> operator / (octonion<T> const & lhs, ::boost::math::quaternion<T> const & rhs);
 683    template<typename T> octonion<T> operator / (octonion<T> const & lhs, octonion<T> const & rhs);
 684
 685 These operators return `octonion<T>(lhs) /= rhs`. It is of course still an
 686 error to divide by zero...
 687
 688 [h4 Binary Equality Operators]
 689
 690    template<typename T> bool operator == (T const & lhs, octonion<T> const & rhs);
 691    template<typename T> bool operator == (octonion<T> const & lhs, T const & rhs);
 692    template<typename T> bool operator == (::std::complex<T> const & lhs, octonion<T> const & rhs);
 693    template<typename T> bool operator == (octonion<T> const & lhs, ::std::complex<T> const & rhs);
 694    template<typename T> bool operator == (::boost::math::quaternion<T> const & lhs, octonion<T> const & rhs);
 695    template<typename T> bool operator == (octonion<T> const & lhs, ::boost::math::quaternion<T> const & rhs);
 696    template<typename T> bool operator == (octonion<T> const & lhs, octonion<T> const & rhs);
 697
 698 These return true if and only if the four components of `octonion<T>(lhs)`
 699 are equal to their counterparts in `octonion<T>(rhs)`. As with any
 700 floating-type entity, this is essentially meaningless.
 701
 702 [h4 Binary Inequality Operators]
 703
 704    template<typename T> bool operator != (T const & lhs, octonion<T> const & rhs);
 705    template<typename T> bool operator != (octonion<T> const & lhs, T const & rhs);
 706    template<typename T> bool operator != (::std::complex<T> const & lhs, octonion<T> const & rhs);
 707    template<typename T> bool operator != (octonion<T> const & lhs, ::std::complex<T> const & rhs);
 708    template<typename T> bool operator != (::boost::math::quaternion<T> const & lhs, octonion<T> const & rhs);
 709    template<typename T> bool operator != (octonion<T> const & lhs, ::boost::math::quaternion<T> const & rhs);
 710    template<typename T> bool operator != (octonion<T> const & lhs, octonion<T> const & rhs);
 711
 712 These return true if and only if `octonion<T>(lhs) == octonion<T>(rhs)`
 713 is false. As with any floating-type entity, this is essentially meaningless.
 714
 715 [h4 Stream Extractor]
 716
 717    template<typename T, typename charT, class traits>
 718    ::std::basic_istream<charT,traits> & operator >> (::std::basic_istream<charT,traits> & is, octonion<T> & o);
 719
 720 Extracts an octonion `o`. We accept any format which seems reasonable.
 721 However, since this leads to a great many ambiguities, decisions were made
 722 to lift these. In case of doubt, stick to lists of reals.
 723
 724 The input values must be convertible to T. If bad input is encountered,
 725 calls `is.setstate(ios::failbit)` (which may throw `ios::failure` (27.4.5.3)).
 726
 727 Returns `is`.
 728
 729 [h4 Stream Inserter]
 730
 731    template<typename T, typename charT, class traits>
 732    ::std::basic_ostream<charT,traits> & operator << (::std::basic_ostream<charT,traits> & os, octonion<T> const & o);
 733
 734 Inserts the octonion `o` onto the stream `os` as if it were implemented as follows:
 735
 736    template<typename T, typename charT, class traits>
 737    ::std::basic_ostream<charT,traits> & operator << ( ::std::basic_ostream<charT,traits> & os,
 738    octonion<T> const & o)
 739    {
 740       ::std::basic_ostringstream<charT,traits> s;
 741
 742       s.flags(os.flags());
 743       s.imbue(os.getloc());
 744       s.precision(os.precision());
 745
 746       s << '(' << o.R_component_1() << ','
 747          << o.R_component_2() << ','
 748          << o.R_component_3() << ','
 749          << o.R_component_4() << ','
 750          << o.R_component_5() << ','
 751          << o.R_component_6() << ','
 752          << o.R_component_7() << ','
 753          << o.R_component_8() << ')';
 754
 755       return os << s.str();
 756    }
 757
 758 [endsect]
 759
 760 [section:oct_value_ops Octonion Value Operations]
 761
 762 [h4 Real and Unreal]
 763
 764    template<typename T> T  real(octonion<T> const & o);
 765    template<typename T> octonion<T> unreal(octonion<T> const & o);
 766
 767 These return `o.real()` and `o.unreal()` respectively.
 768
 769 [h4 conj]
 770
 771    template<typename T> octonion<T> conj(octonion<T> const & o);
 772
 773 This returns the conjugate of the octonion.
 774
 775 [h4 sup]
 776
 777    template<typename T> T   sup(octonion<T> const & o);
 778
 779 This return the sup norm (the greatest among
 780 `abs(o.R_component_1())...abs(o.R_component_8()))` of the octonion.
 781
 782 [h4 l1]
 783
 784    template<typename T> T   l1(octonion<T> const & o);
 785
 786 This return the l1 norm (`abs(o.R_component_1())+...+abs(o.R_component_8())`)
 787 of the octonion.
 788
 789 [h4 abs]
 790
 791    template<typename T> T   abs(octonion<T> const & o);
 792
 793 This return the magnitude (Euclidian norm) of the octonion.
 794
 795 [h4 norm]
 796
 797    template<typename T> T  norm(octonion<T>const  & o);
 798
 799 This return the (Cayley) norm of the octonion. The term "norm" might
 800 be confusing, as most people associate it with the Euclidian norm
 801 (and quadratic functionals). For this version of (the mathematical
 802 objects known as) octonions, the Euclidian norm (also known as
 803 magnitude) is the square root of the Cayley norm.
 804
 805 [endsect]
 806
 807 [section:oct_create Octonion Creation Functions]
 808
 809    template<typename T> octonion<T> spherical(T const & rho, T const & theta, T const & phi1, T const & phi2, T const & phi3, T const & phi4, T const & phi5, T const & phi6);
 810    template<typename T> octonion<T> multipolar(T const & rho1, T const & theta1, T const & rho2, T const & theta2, T const & rho3, T const & theta3, T const & rho4, T const & theta4);
 811    template<typename T> octonion<T> cylindrical(T const & r, T const & angle, T const & h1, T const & h2, T const & h3, T const & h4, T const & h5, T const & h6);
 812
 813 These build octonions in a way similar to the way polar builds
 814 complex numbers, as there is no strict equivalent to
 815 polar coordinates for octonions.
 816
 817 `spherical` is a simple transposition of `polar`, it takes as inputs a
 818 (positive) magnitude and a point on the hypersphere, given
 819 by three angles. The first of these, ['theta] has a natural range of
 820 -pi to +pi, and the other two have natural ranges of
 821 -pi/2 to +pi/2 (as is the case with the usual spherical
 822 coordinates in __R3). Due to the many symmetries and periodicities,
 823 nothing untoward happens if the magnitude is negative or the angles are
 824 outside their natural ranges. The expected degeneracies (a magnitude of
 825 zero ignores the angles settings...) do happen however.
 826
 827 `cylindrical` is likewise a simple transposition of the usual
 828 cylindrical coordinates in __R3, which in turn is another derivative of
 829 planar polar coordinates. The first two inputs are the polar
 830 coordinates of the first __C component of the octonion. The third and
 831 fourth inputs are placed into the third and fourth __R components of the
 832 octonion, respectively.
 833
 834 `multipolar` is yet another simple generalization of polar coordinates.
 835 This time, both __C components of the octonion are given in polar coordinates.
 836
 837 In this version of our implementation of octonions, there is no
 838 analogue of the complex value operation arg as the situation is
 839 somewhat more complicated.
 840
 841 [endsect]
 842
 843 [section:oct_trans Octonions Transcendentals]
 844
 845 There is no `log` or `sqrt` provided for octonions in this implementation,
 846 and `pow` is likewise restricted to integral powers of the exponent.
 847 There are several reasons to this: on the one hand, the equivalent of
 848 analytic continuation for octonions ("branch cuts") remains to be
 849 investigated thoroughly (by me, at any rate...), and we wish to avoid
 850 the nonsense introduced in the standard by exponentiations of
 851 complexes by complexes (which is well defined, but not in the standard...).
 852 Talking of nonsense, saying that `pow(0,0)` is "implementation defined" is
 853 just plain brain-dead...
 854
 855 We do, however provide several transcendentals, chief among which is
 856 the exponential. That it allows for a "closed formula" is a result
 857 of the author (the existence and definition of the exponential, on the
 858 octonions among others, on the other hand, is a few centuries old).
 859 Basically, any converging power series with real coefficients which
 860 allows for a closed formula in __C can be transposed to __O. More
 861 transcendentals of this type could be added in a further revision upon
 862 request. It should be noted that it is these functions which force the
 863 dependency upon the
 864 [@../../../../boost/math/special_functions/sinc.hpp boost/math/special_functions/sinc.hpp]
 865 and the
 866 [@../../../../boost/math/special_functions/sinhc.hpp boost/math/special_functions/sinhc.hpp]
 867 headers.
 868
 869 [h4 exp]
 870
 871    template<typename T>
 872    octonion<T> exp(octonion<T> const & o);
 873
 874 Computes the exponential of the octonion.
 875
 876 [h4 cos]
 877
 878    template<typename T>
 879    octonion<T> cos(octonion<T> const & o);
 880
 881 Computes the cosine of the octonion
 882
 883 [h4 sin]
 884
 885    template<typename T>
 886    octonion<T> sin(octonion<T> const & o);
 887
 888 Computes the sine of the octonion.
 889
 890 [h4 tan]
 891
 892    template<typename T>
 893    octonion<T> tan(octonion<T> const & o);
 894
 895 Computes the tangent of the octonion.
 896
 897 [h4 cosh]
 898
 899    template<typename T>
 900    octonion<T> cosh(octonion<T> const & o);
 901
 902 Computes the hyperbolic cosine of the octonion.
 903
 904 [h4 sinh]
 905
 906    template<typename T>
 907    octonion<T> sinh(octonion<T> const & o);
 908
 909 Computes the hyperbolic sine of the octonion.
 910
 911 [h4 tanh]
 912
 913    template<typename T>
 914    octonion<T> tanh(octonion<T> const & o);
 915
 916 Computes the hyperbolic tangent of the octonion.
 917
 918 [h4 pow]
 919
 920    template<typename T>
 921    octonion<T>  pow(octonion<T> const & o, int n);
 922
 923 Computes the n-th power of the octonion q.
 924
 925 [endsect]
 926
 927 [section:oct_tests Test Program]
 928
 929 The [@../../test/octonion_test.cpp octonion_test.cpp]
 930 test program tests octonions specialisations for float, double and long double
 931 ([@../octonion/output.txt sample output]).
 932
 933 If you define the symbol BOOST_OCTONION_TEST_VERBOSE, you will get additional
 934 output ([@../octonion/output_more.txt verbose output]); this will
 935 only be helpfull if you enable message output at the same time, of course
 936 (by uncommenting the relevant line in the test or by adding --log_level=messages
 937 to your command line,...). In that case, and if you are running interactively,
 938 you may in addition define the symbol BOOST_INTERACTIVE_TEST_INPUT_ITERATOR to
 939 interactively test the input operator with input of your choice from the
 940 standard input (instead of hard-coding it in the test).
 941
 942 [endsect]
 943
 944 [section:acknowledgements Acknowledgements]
 945
 946 The mathematical text has been typeset with
 947 [@http://www.nisus-soft.com/ Nisus Writer].
 948 Jens Maurer has helped with portability and standard adherence, and was the
 949 Review Manager for this library. More acknowledgements in the
 950 History section. Thank you to all who contributed to the discussion about this library.
 951
 952 [endsect]
 953
 954 [section:oct_history History]
 955
 956 * 1.5.9 - 13/5/2013:  Incorporated into Boost.Math.
 957 * 1.5.8 - 17/12/2005: Converted documentation to Quickbook Format.
 958 * 1.5.7 - 25/02/2003: transitionned to the unit test framework; <boost/config.hpp> now included by the library header (rather than the test files), via <boost/math/quaternion.hpp>.
 959 * 1.5.6 - 15/10/2002: Gcc2.95.x and stlport on linux compatibility by Alkis Evlogimenos (alkis@routescience.com).
 960 * 1.5.5 - 27/09/2002: Microsoft VCPP 7 compatibility, by Michael Stevens (michael@acfr.usyd.edu.au); requires the /Za compiler option.
 961 * 1.5.4 - 19/09/2002: fixed problem with multiple inclusion (in different translation units); attempt at an improved compatibility with Microsoft compilers, by Michael Stevens (michael@acfr.usyd.edu.au) and Fredrik Blomqvist; other compatibility fixes.
 962 * 1.5.3 - 01/02/2002: bugfix and Gcc 2.95.3 compatibility by Douglas Gregor (gregod@cs.rpi.edu).
 963 * 1.5.2 - 07/07/2001: introduced namespace math.
 964 * 1.5.1 - 07/06/2001: (end of Boost review) now includes <boost/math/special_functions/sinc.hpp> and <boost/math/special_functions/sinhc.hpp> instead of <boost/special_functions.hpp>; corrected bug in sin (Daryle Walker); removed check for self-assignment (Gary Powel); made converting functions explicit (Gary Powel); added overflow guards for division operators and abs (Peter Schmitteckert); added sup and l1; used Vesa Karvonen's CPP metaprograming technique to simplify code.
 965 * 1.5.0 - 23/03/2001: boostification, inlining of all operators except input, output and pow, fixed exception safety of some members (template version).
 966 * 1.4.0 - 09/01/2001: added tan and tanh.
 967 * 1.3.1 - 08/01/2001: cosmetic fixes.
 968 * 1.3.0 - 12/07/2000: pow now uses Maarten Hilferink's (mhilferink@tip.nl) algorithm.
 969 * 1.2.0 - 25/05/2000: fixed the division operators and output; changed many signatures.
 970 * 1.1.0 - 23/05/2000: changed sinc into sinc_pi; added sin, cos, sinh, cosh.
 971 * 1.0.0 - 10/08/1999: first public version.
 972
 973 [endsect]
 974
 975 [section:oct_todo To Do]
 976
 977 * Improve testing.
 978 * Rewrite input operatore using Spirit (creates a dependency).
 979 * Put in place an Expression Template mechanism (perhaps borrowing from uBlas).
 980
 981 [endsect]
 982
 983 [endmathpart]
 984
 985
 986 [/
 987 Copyright 1999, 2005, 2013 Hubert Holin.
 988 Distributed under the Boost Software License, Version 1.0.
 989 (See accompanying file LICENSE_1_0.txt or copy at
 990 http://www.boost.org/LICENSE_1_0.txt).
 991 ]