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