123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990 |
- [/macro definitions specific to octonions]
- [def __R ['[*R]]]
- [def __C ['[*C]]]
- [def __H ['[*H]]]
- [def __O ['[*O]]]
- [def __R3 ['[*'''R<superscript>3</superscript>''']]]
- [def __R4 ['[*'''R<superscript>4</superscript>''']]]
- [def __octulple ('''α,β,γ,δ,ε,ζ,η,θ''')]
- [def __oct_formula ['[^o = '''α + βi + γj + δk + εe' + ζi' + ηj' + θk' ''']]]
- [def __oct_complex_formula ['[^o = ('''α + βi) + (γ + δi)j + (ε + ζi)e' + (η - θi)j' ''']]]
- [def __oct_quat_formula ['[^o = ('''α + βi + γj + δk) + (ε + ζi + ηj - θj)e' ''']]]
- [def __oct_not_equal ['[^x(yz) '''≠''' (xy)z]]]
- [mathpart octonions Octonions]
- [section:oct_overview Overview]
- Octonions, like [link quaternions quaternions], are a relative of complex numbers.
- Octonions see some use in theoretical physics.
- In practical terms, an octonion is simply an octuple of real numbers __octulple,
- which we can write in the form __oct_formula, where ['[^i]], ['[^j]] and ['[^k]]
- are the same objects as for quaternions, and ['[^e']], ['[^i']], ['[^j']] and ['[^k']]
- are distinct objects which play essentially the same kind of role as ['[^i]] (or ['[^j]] or ['[^k]]).
- Addition and a multiplication is defined on the set of octonions,
- which generalize their quaternionic counterparts. The main novelty this time
- is that [*the multiplication is not only not commutative, is now not even
- associative] (i.e. there are octonions ['[^x]], ['[^y]] and ['[^z]] such that __oct_not_equal).
- A way of remembering things is by using the following multiplication table:
- [$../octonion/graphics/octonion_blurb17.jpeg]
- Octonions (and their kin) are described in far more details in this other
- [@../quaternion/TQE.pdf document] (with [@../quaternion/TQE_EA.pdf errata and addenda]).
- Some traditional constructs, such as the exponential, carry over without too
- much change into the realms of octonions, but other, such as taking a square root,
- do not (the fact that the exponential has a closed form is a result of the
- author, but the fact that the exponential exists at all for octonions is known
- since quite a long time ago).
- [endsect] [/section:oct_overview Overview]
- [section:oct_header Header File]
- The interface and implementation are both supplied by the header file
- [@../../../../boost/math/octonion.hpp octonion.hpp].
- [endsect]
- [section:oct_synopsis Synopsis]
- namespace boost{ namespace math{
- template<typename T> class ``[link math_toolkit.octonion octonion]``;
- template<> class ``[link math_toolkit.oct_specialization octonion<float>]``;
- template<> class ``[link math_octonion_double octonion<double>]``;
- template<> class ``[link math_octonion_long_double octonion<long double>]``;
- // operators
- template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_addition_operators operator +]`` (T const & lhs, octonion<T> const & rhs);
- template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_addition_operators operator +]`` (octonion<T> const & lhs, T const & rhs);
- template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_addition_operators operator +]`` (::std::complex<T> const & lhs, octonion<T> const & rhs);
- template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_addition_operators operator +]`` (octonion<T> const & lhs, ::std::complex<T> const & rhs);
- 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);
- 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);
- template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_addition_operators operator +]`` (octonion<T> const & lhs, octonion<T> const & rhs);
- template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_subtraction_operators operator -]`` (T const & lhs, octonion<T> const & rhs);
- template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_subtraction_operators operator -]`` (octonion<T> const & lhs, T const & rhs);
- template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_subtraction_operators operator -]`` (::std::complex<T> const & lhs, octonion<T> const & rhs);
- template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_subtraction_operators operator -]`` (octonion<T> const & lhs, ::std::complex<T> const & rhs);
- 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);
- 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);
- template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_subtraction_operators operator -]`` (octonion<T> const & lhs, octonion<T> const & rhs);
- template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_multiplication_operators operator *]`` (T const & lhs, octonion<T> const & rhs);
- template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_multiplication_operators operator *]`` (octonion<T> const & lhs, T const & rhs);
- template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_multiplication_operators operator *]`` (::std::complex<T> const & lhs, octonion<T> const & rhs);
- template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_multiplication_operators operator *]`` (octonion<T> const & lhs, ::std::complex<T> const & rhs);
- 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);
- 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);
- template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_multiplication_operators operator *]`` (octonion<T> const & lhs, octonion<T> const & rhs);
- template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_division_operators operator /]`` (T const & lhs, octonion<T> const & rhs);
- template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_division_operators operator /]`` (octonion<T> const & lhs, T const & rhs);
- template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_division_operators operator /]`` (::std::complex<T> const & lhs, octonion<T> const & rhs);
- template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_division_operators operator /]`` (octonion<T> const & lhs, ::std::complex<T> const & rhs);
- 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);
- 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);
- template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.binary_division_operators operator /]`` (octonion<T> const & lhs, octonion<T> const & rhs);
- template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.unary_plus_and_minus_operators operator +]`` (octonion<T> const & o);
- template<typename T> octonion<T> ``[link math_toolkit.oct_non_mem.unary_plus_and_minus_operators operator -]`` (octonion<T> const & o);
- template<typename T> bool ``[link math_toolkit.oct_non_mem.binary_equality_operators operator ==]`` (T const & lhs, octonion<T> const & rhs);
- template<typename T> bool ``[link math_toolkit.oct_non_mem.binary_equality_operators operator ==]`` (octonion<T> const & lhs, T const & rhs);
- template<typename T> bool ``[link math_toolkit.oct_non_mem.binary_equality_operators operator ==]`` (::std::complex<T> const & lhs, octonion<T> const & rhs);
- template<typename T> bool ``[link math_toolkit.oct_non_mem.binary_equality_operators operator ==]`` (octonion<T> const & lhs, ::std::complex<T> const & rhs);
- template<typename T> bool ``[link math_toolkit.oct_non_mem.binary_equality_operators operator ==]`` (::boost::math::quaternion<T> const & lhs, octonion<T> const & rhs);
- template<typename T> bool ``[link math_toolkit.oct_non_mem.binary_equality_operators operator ==]`` (octonion<T> const & lhs, ::boost::math::quaternion<T> const & rhs);
- template<typename T> bool ``[link math_toolkit.oct_non_mem.binary_equality_operators operator ==]`` (octonion<T> const & lhs, octonion<T> const & rhs);
- template<typename T> bool ``[link math_toolkit.oct_non_mem.binary_inequality_operators operator !=]`` (T const & lhs, octonion<T> const & rhs);
- template<typename T> bool ``[link math_toolkit.oct_non_mem.binary_inequality_operators operator !=]`` (octonion<T> const & lhs, T const & rhs);
- template<typename T> bool ``[link math_toolkit.oct_non_mem.binary_inequality_operators operator !=]`` (::std::complex<T> const & lhs, octonion<T> const & rhs);
- template<typename T> bool ``[link math_toolkit.oct_non_mem.binary_inequality_operators operator !=]`` (octonion<T> const & lhs, ::std::complex<T> const & rhs);
- template<typename T> bool ``[link math_toolkit.oct_non_mem.binary_inequality_operators operator !=]`` (::boost::math::quaternion<T> const & lhs, octonion<T> const & rhs);
- template<typename T> bool ``[link math_toolkit.oct_non_mem.binary_inequality_operators operator !=]`` (octonion<T> const & lhs, ::boost::math::quaternion<T> const & rhs);
- template<typename T> bool ``[link math_toolkit.oct_non_mem.binary_inequality_operators operator !=]`` (octonion<T> const & lhs, octonion<T> const & rhs);
- template<typename T, typename charT, class traits>
- ::std::basic_istream<charT,traits> & ``[link math_toolkit.oct_non_mem.stream_extractor operator >>]`` (::std::basic_istream<charT,traits> & is, octonion<T> & o);
- template<typename T, typename charT, class traits>
- ::std::basic_ostream<charT,traits> & ``[link math_toolkit.oct_non_mem.stream_inserter operator <<]`` (::std::basic_ostream<charT,traits> & os, octonion<T> const & o);
- // values
- template<typename T> T ``[link math_toolkit.oct_value_ops.real_and_unreal real]``(octonion<T> const & o);
- template<typename T> octonion<T> ``[link math_toolkit.oct_value_ops.real_and_unreal unreal]``(octonion<T> const & o);
- template<typename T> T ``[link math_toolkit.oct_value_ops.sup sup]``(octonion<T> const & o);
- template<typename T> T ``[link math_toolkit.oct_value_ops.l1 l1]``(octonion<T>const & o);
- template<typename T> T ``[link math_toolkit.oct_value_ops.abs abs]``(octonion<T> const & o);
- template<typename T> T ``[link math_toolkit.oct_value_ops.norm norm]``(octonion<T>const & o);
- template<typename T> octonion<T> ``[link math_toolkit.oct_value_ops.conj conj]``(octonion<T> const & o);
- 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);
- 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);
- 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);
- // transcendentals
- template<typename T> octonion<T> ``[link math_toolkit.oct_trans.exp exp]``(octonion<T> const & o);
- template<typename T> octonion<T> ``[link math_toolkit.oct_trans.cos cos]``(octonion<T> const & o);
- template<typename T> octonion<T> ``[link math_toolkit.oct_trans.sin sin]``(octonion<T> const & o);
- template<typename T> octonion<T> ``[link math_toolkit.oct_trans.tan tan]``(octonion<T> const & o);
- template<typename T> octonion<T> ``[link math_toolkit.oct_trans.cosh cosh]``(octonion<T> const & o);
- template<typename T> octonion<T> ``[link math_toolkit.oct_trans.sinh sinh]``(octonion<T> const & o);
- template<typename T> octonion<T> ``[link math_toolkit.oct_trans.tanh tanh]``(octonion<T> const & o);
- template<typename T> octonion<T> ``[link math_toolkit.oct_trans.pow pow]``(octonion<T> const & o, int n);
- } } // namespaces
- [endsect] [/section:oct_header Header File]
- [section:octonion Template Class octonion]
- namespace boost{ namespace math {
- template<typename T>
- class octonion
- {
- public:
- typedef T value_type;
- 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());
- 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>());
- 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>());
- template<typename X>
- explicit ``[link math_toolkit.oct_mem_fun.constructors octonion]``(octonion<X> const & a_recopier);
- T ``[link math_toolkit.oct_mem_fun.real_and_unreal_parts real]``() const;
- octonion<T> ``[link math_toolkit.oct_mem_fun.real_and_unreal_parts unreal]``() const;
- T ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_1]``() const;
- T ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_2]``() const;
- T ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_3]``() const;
- T ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_4]``() const;
- T ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_5]``() const;
- T ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_6]``() const;
- T ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_7]``() const;
- T ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_8]``() const;
- ::std::complex<T> ``[link math_toolkit.oct_mem_fun.individual_complex_components C_component_1]``() const;
- ::std::complex<T> ``[link math_toolkit.oct_mem_fun.individual_complex_components C_component_2]``() const;
- ::std::complex<T> ``[link math_toolkit.oct_mem_fun.individual_complex_components C_component_3]``() const;
- ::std::complex<T> ``[link math_toolkit.oct_mem_fun.individual_complex_components C_component_4]``() const;
- ::boost::math::quaternion<T> ``[link math_toolkit.oct_mem_fun.individual_quaternion_components H_component_1]``() const;
- ::boost::math::quaternion<T> ``[link math_toolkit.oct_mem_fun.individual_quaternion_components H_component_2]``() const;
- octonion<T> & ``[link math_toolkit.oct_mem_fun.assignment_operators operator =]`` (octonion<T> const & a_affecter);
- template<typename X>
- octonion<T> & ``[link math_toolkit.oct_mem_fun.assignment_operators operator =]`` (octonion<X> const & a_affecter);
- octonion<T> & ``[link math_toolkit.oct_mem_fun.assignment_operators operator =]`` (T const & a_affecter);
- octonion<T> & ``[link math_toolkit.oct_mem_fun.assignment_operators operator =]`` (::std::complex<T> const & a_affecter);
- octonion<T> & ``[link math_toolkit.oct_mem_fun.assignment_operators operator =]`` (::boost::math::quaternion<T> const & a_affecter);
- octonion<T> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator +=]`` (T const & rhs);
- octonion<T> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator +=]`` (::std::complex<T> const & rhs);
- octonion<T> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator +=]`` (::boost::math::quaternion<T> const & rhs);
- template<typename X>
- octonion<T> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator +=]`` (octonion<X> const & rhs);
- octonion<T> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator -=]`` (T const & rhs);
- octonion<T> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator -=]`` (::std::complex<T> const & rhs);
- octonion<T> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator -=]`` (::boost::math::quaternion<T> const & rhs);
- template<typename X>
- octonion<T> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator -=]`` (octonion<X> const & rhs);
- octonion<T> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator *=]`` (T const & rhs);
- octonion<T> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator *=]`` (::std::complex<T> const & rhs);
- octonion<T> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator *=]`` (::boost::math::quaternion<T> const & rhs);
- template<typename X>
- octonion<T> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator *=]`` (octonion<X> const & rhs);
- octonion<T> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator /=]`` (T const & rhs);
- octonion<T> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator /=]`` (::std::complex<T> const & rhs);
- octonion<T> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator /=]`` (::boost::math::quaternion<T> const & rhs);
- template<typename X>
- octonion<T> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator /=]`` (octonion<X> const & rhs);
- };
- } } // namespaces
- [endsect] [/section:octonion Template Class octonion]
- [section:oct_specialization Octonion Specializations]
- namespace boost{ namespace math{
- template<>
- class octonion<float>
- {
- public:
- typedef float value_type;
- 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);
- 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>());
- 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>());
- explicit ``[link math_toolkit.oct_mem_fun.constructors octonion]``(octonion<double> const & a_recopier);
- explicit ``[link math_toolkit.oct_mem_fun.constructors octonion]``(octonion<long double> const & a_recopier);
- float ``[link math_toolkit.oct_mem_fun.real_and_unreal_parts real]``() const;
- octonion<float> ``[link math_toolkit.oct_mem_fun.real_and_unreal_parts unreal]``() const;
- float ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_1]``() const;
- float ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_2]``() const;
- float ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_3]``() const;
- float ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_4]``() const;
- float ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_5]``() const;
- float ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_6]``() const;
- float ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_7]``() const;
- float ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_8]``() const;
- ::std::complex<float> ``[link math_toolkit.oct_mem_fun.individual_complex_components C_component_1]``() const;
- ::std::complex<float> ``[link math_toolkit.oct_mem_fun.individual_complex_components C_component_2]``() const;
- ::std::complex<float> ``[link math_toolkit.oct_mem_fun.individual_complex_components C_component_3]``() const;
- ::std::complex<float> ``[link math_toolkit.oct_mem_fun.individual_complex_components C_component_4]``() const;
- ::boost::math::quaternion<float> ``[link math_toolkit.oct_mem_fun.individual_quaternion_components H_component_1]``() const;
- ::boost::math::quaternion<float> ``[link math_toolkit.oct_mem_fun.individual_quaternion_components H_component_2]``() const;
- octonion<float> & ``[link math_toolkit.oct_mem_fun.assignment_operators operator =]`` (octonion<float> const & a_affecter);
- template<typename X>
- octonion<float> & ``[link math_toolkit.oct_mem_fun.assignment_operators operator =]`` (octonion<X> const & a_affecter);
- octonion<float> & ``[link math_toolkit.oct_mem_fun.assignment_operators operator =]`` (float const & a_affecter);
- octonion<float> & ``[link math_toolkit.oct_mem_fun.assignment_operators operator =]`` (::std::complex<float> const & a_affecter);
- octonion<float> & ``[link math_toolkit.oct_mem_fun.assignment_operators operator =]`` (::boost::math::quaternion<float> const & a_affecter);
- octonion<float> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator +=]`` (float const & rhs);
- octonion<float> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator +=]`` (::std::complex<float> const & rhs);
- octonion<float> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator +=]`` (::boost::math::quaternion<float> const & rhs);
- template<typename X>
- octonion<float> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator +=]`` (octonion<X> const & rhs);
- octonion<float> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator -=]`` (float const & rhs);
- octonion<float> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator -=]`` (::std::complex<float> const & rhs);
- octonion<float> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator -=]`` (::boost::math::quaternion<float> const & rhs);
- template<typename X>
- octonion<float> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator -=]`` (octonion<X> const & rhs);
- octonion<float> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator *=]`` (float const & rhs);
- octonion<float> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator *=]`` (::std::complex<float> const & rhs);
- octonion<float> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator *=]`` (::boost::math::quaternion<float> const & rhs);
- template<typename X>
- octonion<float> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator *=]`` (octonion<X> const & rhs);
- octonion<float> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator /=]`` (float const & rhs);
- octonion<float> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator /=]`` (::std::complex<float> const & rhs);
- octonion<float> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator /=]`` (::boost::math::quaternion<float> const & rhs);
- template<typename X>
- octonion<float> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator /=]`` (octonion<X> const & rhs);
- };
- [#math_octonion_double]
- template<>
- class octonion<double>
- {
- public:
- typedef double value_type;
- 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);
- 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>());
- 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>());
- explicit ``[link math_toolkit.oct_mem_fun.constructors octonion]``(octonion<float> const & a_recopier);
- explicit ``[link math_toolkit.oct_mem_fun.constructors octonion]``(octonion<long double> const & a_recopier);
- double ``[link math_toolkit.oct_mem_fun.real_and_unreal_parts real]``() const;
- octonion<double> ``[link math_toolkit.oct_mem_fun.real_and_unreal_parts unreal]``() const;
- double ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_1]``() const;
- double ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_2]``() const;
- double ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_3]``() const;
- double ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_4]``() const;
- double ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_5]``() const;
- double ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_6]``() const;
- double ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_7]``() const;
- double ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_8]``() const;
- ::std::complex<double> ``[link math_toolkit.oct_mem_fun.individual_complex_components C_component_1]``() const;
- ::std::complex<double> ``[link math_toolkit.oct_mem_fun.individual_complex_components C_component_2]``() const;
- ::std::complex<double> ``[link math_toolkit.oct_mem_fun.individual_complex_components C_component_3]``() const;
- ::std::complex<double> ``[link math_toolkit.oct_mem_fun.individual_complex_components C_component_4]``() const;
- ::boost::math::quaternion<double> ``[link math_toolkit.oct_mem_fun.individual_quaternion_components H_component_1]``() const;
- ::boost::math::quaternion<double> ``[link math_toolkit.oct_mem_fun.individual_quaternion_components H_component_2]``() const;
- octonion<double> & ``[link math_toolkit.oct_mem_fun.assignment_operators operator =]`` (octonion<double> const & a_affecter);
- template<typename X>
- octonion<double> & ``[link math_toolkit.oct_mem_fun.assignment_operators operator =]`` (octonion<X> const & a_affecter);
- octonion<double> & ``[link math_toolkit.oct_mem_fun.assignment_operators operator =]`` (double const & a_affecter);
- octonion<double> & ``[link math_toolkit.oct_mem_fun.assignment_operators operator =]`` (::std::complex<double> const & a_affecter);
- octonion<double> & ``[link math_toolkit.oct_mem_fun.assignment_operators operator =]`` (::boost::math::quaternion<double> const & a_affecter);
- octonion<double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator +=]`` (double const & rhs);
- octonion<double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator +=]`` (::std::complex<double> const & rhs);
- octonion<double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator +=]`` (::boost::math::quaternion<double> const & rhs);
- template<typename X>
- octonion<double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator +=]`` (octonion<X> const & rhs);
- octonion<double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator -=]`` (double const & rhs);
- octonion<double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator -=]`` (::std::complex<double> const & rhs);
- octonion<double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator -=]`` (::boost::math::quaternion<double> const & rhs);
- template<typename X>
- octonion<double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator -=]`` (octonion<X> const & rhs);
- octonion<double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator *=]`` (double const & rhs);
- octonion<double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator *=]`` (::std::complex<double> const & rhs);
- octonion<double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator *=]`` (::boost::math::quaternion<double> const & rhs);
- template<typename X>
- octonion<double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator *=]`` (octonion<X> const & rhs);
- octonion<double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator /=]`` (double const & rhs);
- octonion<double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator /=]`` (::std::complex<double> const & rhs);
- octonion<double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator /=]`` (::boost::math::quaternion<double> const & rhs);
- template<typename X>
- octonion<double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator /=]`` (octonion<X> const & rhs);
- };
- [#math_octonion_long_double]
- template<>
- class octonion<long double>
- {
- public:
- typedef long double value_type;
- 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);
- 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>());
- 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>());
- explicit ``[link math_toolkit.oct_mem_fun.constructors octonion]``(octonion<float> const & a_recopier);
- explicit ``[link math_toolkit.oct_mem_fun.constructors octonion]``(octonion<double> const & a_recopier);
- long double ``[link math_toolkit.oct_mem_fun.real_and_unreal_parts real]``() const;
- octonion<long double> ``[link math_toolkit.oct_mem_fun.real_and_unreal_parts unreal]``() const;
- long double ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_1]``() const;
- long double ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_2]``() const;
- long double ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_3]``() const;
- long double ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_4]``() const;
- long double ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_5]``() const;
- long double ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_6]``() const;
- long double ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_7]``() const;
- long double ``[link math_toolkit.oct_mem_fun.individual_real_components R_component_8]``() const;
- ::std::complex<long double> ``[link math_toolkit.oct_mem_fun.individual_complex_components C_component_1]``() const;
- ::std::complex<long double> ``[link math_toolkit.oct_mem_fun.individual_complex_components C_component_2]``() const;
- ::std::complex<long double> ``[link math_toolkit.oct_mem_fun.individual_complex_components C_component_3]``() const;
- ::std::complex<long double> ``[link math_toolkit.oct_mem_fun.individual_complex_components C_component_4]``() const;
- ::boost::math::quaternion<long double> ``[link math_toolkit.oct_mem_fun.individual_quaternion_components H_component_1]``() const;
- ::boost::math::quaternion<long double> ``[link math_toolkit.oct_mem_fun.individual_quaternion_components H_component_2]``() const;
- octonion<long double> & ``[link math_toolkit.oct_mem_fun.assignment_operators operator =]`` (octonion<long double> const & a_affecter);
- template<typename X>
- octonion<long double> & ``[link math_toolkit.oct_mem_fun.assignment_operators operator =]`` (octonion<X> const & a_affecter);
- octonion<long double> & ``[link math_toolkit.oct_mem_fun.assignment_operators operator =]`` (long double const & a_affecter);
- octonion<long double> & ``[link math_toolkit.oct_mem_fun.assignment_operators operator =]`` (::std::complex<long double> const & a_affecter);
- octonion<long double> & ``[link math_toolkit.oct_mem_fun.assignment_operators operator =]`` (::boost::math::quaternion<long double> const & a_affecter);
- octonion<long double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator +=]`` (long double const & rhs);
- octonion<long double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator +=]`` (::std::complex<long double> const & rhs);
- octonion<long double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator +=]`` (::boost::math::quaternion<long double> const & rhs);
- template<typename X>
- octonion<long double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator +=]`` (octonion<X> const & rhs);
- octonion<long double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator -=]`` (long double const & rhs);
- octonion<long double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator -=]`` (::std::complex<long double> const & rhs);
- octonion<long double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator -=]`` (::boost::math::quaternion<long double> const & rhs);
- template<typename X>
- octonion<long double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator -=]`` (octonion<X> const & rhs);
- octonion<long double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator *=]`` (long double const & rhs);
- octonion<long double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator *=]`` (::std::complex<long double> const & rhs);
- octonion<long double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator *=]`` (::boost::math::quaternion<long double> const & rhs);
- template<typename X>
- octonion<long double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator *=]`` (octonion<X> const & rhs);
- octonion<long double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator /=]`` (long double const & rhs);
- octonion<long double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator /=]`` (::std::complex<long double> const & rhs);
- octonion<long double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator /=]`` (::boost::math::quaternion<long double> const & rhs);
- template<typename X>
- octonion<long double> & ``[link math_toolkit.oct_mem_fun.other_member_operators operator /=]`` (octonion<X> const & rhs);
- };
- } } // namespaces
- [endsect] [/section:oct_specialization Octonion Specializations]
- [section:oct_typedefs Octonion Member Typedefs]
- [*value_type]
- Template version:
- typedef T value_type;
- Float specialization version:
- typedef float value_type;
- Double specialization version:
- typedef double value_type;
- Long double specialization version:
- typedef long double value_type;
- These provide easy access to the type the template is built upon.
- [endsect] [/section:oct_typedefs Octonion Member Typedefs]
- [section:oct_mem_fun Octonion Member Functions]
- [h3 Constructors]
- Template version:
- explicit octonion(T const & requested_a = T(), T const & requested_b = T(), T const & requested_c = T(), T const & requested_d = T(), T const & requested_e = T(), T const & requested_f = T(), T const & requested_g = T(), T const & requested_h = T());
- explicit octonion(::std::complex<T> const & z0, ::std::complex<T> const & z1 = ::std::complex<T>(), ::std::complex<T> const & z2 = ::std::complex<T>(), ::std::complex<T> const & z3 = ::std::complex<T>());
- explicit octonion(::boost::math::quaternion<T> const & q0, ::boost::math::quaternion<T> const & q1 = ::boost::math::quaternion<T>());
- template<typename X>
- explicit octonion(octonion<X> const & a_recopier);
- Float specialization version:
- explicit octonion(float const & requested_a = 0.0f, float const & requested_b = 0.0f, float const & requested_c = 0.0f, float const & requested_d = 0.0f, float const & requested_e = 0.0f, float const & requested_f = 0.0f, float const & requested_g = 0.0f, float const & requested_h = 0.0f);
- explicit octonion(::std::complex<float> const & z0, ::std::complex<float> const & z1 = ::std::complex<float>(), ::std::complex<float> const & z2 = ::std::complex<float>(), ::std::complex<float> const & z3 = ::std::complex<float>());
- explicit octonion(::boost::math::quaternion<float> const & q0, ::boost::math::quaternion<float> const & q1 = ::boost::math::quaternion<float>());
- explicit octonion(octonion<double> const & a_recopier);
- explicit octonion(octonion<long double> const & a_recopier);
- Double specialization version:
- explicit octonion(double const & requested_a = 0.0, double const & requested_b = 0.0, double const & requested_c = 0.0, double const & requested_d = 0.0, double const & requested_e = 0.0, double const & requested_f = 0.0, double const & requested_g = 0.0, double const & requested_h = 0.0);
- explicit octonion(::std::complex<double> const & z0, ::std::complex<double> const & z1 = ::std::complex<double>(), ::std::complex<double> const & z2 = ::std::complex<double>(), ::std::complex<double> const & z3 = ::std::complex<double>());
- explicit octonion(::boost::math::quaternion<double> const & q0, ::boost::math::quaternion<double> const & q1 = ::boost::math::quaternion<double>());
- explicit octonion(octonion<float> const & a_recopier);
- explicit octonion(octonion<long double> const & a_recopier);
- Long double specialization version:
- explicit octonion(long double const & requested_a = 0.0L, long double const & requested_b = 0.0L, long double const & requested_c = 0.0L, long double const & requested_d = 0.0L, long double const & requested_e = 0.0L, long double const & requested_f = 0.0L, long double const & requested_g = 0.0L, long double const & requested_h = 0.0L);
- explicit octonion( ::std::complex<long double> const & z0, ::std::complex<long double> const & z1 = ::std::complex<long double>(), ::std::complex<long double> const & z2 = ::std::complex<long double>(), ::std::complex<long double> const & z3 = ::std::complex<long double>());
- explicit octonion(::boost::math::quaternion<long double> const & q0, ::boost::math::quaternion<long double> const & q1 = ::boost::math::quaternion<long double>());
- explicit octonion(octonion<float> const & a_recopier);
- explicit octonion(octonion<double> const & a_recopier);
- A default constructor is provided for each form, which initializes each component
- to the default values for their type (i.e. zero for floating numbers).
- This constructor can also accept one to eight base type arguments.
- A constructor is also provided to build octonions from one to four complex numbers
- sharing the same base type, and another taking one or two quaternions
- sharing the same base type. The unspecialized template also sports a
- templarized copy constructor, while the specialized forms have copy
- constructors from the other two specializations, which are explicit
- when a risk of precision loss exists. For the unspecialized form,
- the base type's constructors must not throw.
- Destructors and untemplated copy constructors (from the same type)
- are provided by the compiler. Converting copy constructors make use
- of a templated helper function in a "detail" subnamespace.
- [h3 Other member functions]
- [h4 Real and Unreal Parts]
- T real() const;
- octonion<T> unreal() const;
- Like complex number, octonions do have a meaningful notion of "real part",
- but unlike them there is no meaningful notion of "imaginary part".
- Instead there is an "unreal part" which itself is a octonion,
- and usually nothing simpler (as opposed to the complex number case).
- These are returned by the first two functions.
- [h4 Individual Real Components]
- T R_component_1() const;
- T R_component_2() const;
- T R_component_3() const;
- T R_component_4() const;
- T R_component_5() const;
- T R_component_6() const;
- T R_component_7() const;
- T R_component_8() const;
- A octonion having eight real components, these are returned by
- these eight functions. Hence real and R_component_1 return the same value.
- [h4 Individual Complex Components]
- ::std::complex<T> C_component_1() const;
- ::std::complex<T> C_component_2() const;
- ::std::complex<T> C_component_3() const;
- ::std::complex<T> C_component_4() const;
- A octonion likewise has four complex components. Actually, octonions
- are indeed a (left) vector field over the complexes, but beware, as
- for any octonion __oct_formula we also have __oct_complex_formula
- (note the [*minus] sign in the last factor).
- What the C_component_n functions return, however, are the complexes
- which could be used to build the octonion using the constructor, and
- [*not] the components of the octonion on the basis ['[^(1, j, e', j')]].
- [h4 Individual Quaternion Components]
- ::boost::math::quaternion<T> H_component_1() const;
- ::boost::math::quaternion<T> H_component_2() const;
- Likewise, for any octonion __oct_formula we also have __oct_quat_formula, though there
- is no meaningful vector-space-like structure based on the quaternions.
- What the H_component_n functions return are the quaternions which
- could be used to build the octonion using the constructor.
- [h3 Octonion Member Operators]
- [h4 Assignment Operators]
- octonion<T> & operator = (octonion<T> const & a_affecter);
- template<typename X>
- octonion<T> & operator = (octonion<X> const & a_affecter);
- octonion<T> & operator = (T const & a_affecter);
- octonion<T> & operator = (::std::complex<T> const & a_affecter);
- octonion<T> & operator = (::boost::math::quaternion<T> const & a_affecter);
- These perform the expected assignment, with type modification if
- necessary (for instance, assigning from a base type will set the
- real part to that value, and all other components to zero).
- For the unspecialized form, the base type's assignment operators must not throw.
- [h4 Other Member Operators]
- octonion<T> & operator += (T const & rhs)
- octonion<T> & operator += (::std::complex<T> const & rhs);
- octonion<T> & operator += (::boost::math::quaternion<T> const & rhs);
- template<typename X>
- octonion<T> & operator += (octonion<X> const & rhs);
- These perform the mathematical operation `(*this)+rhs` and store the result in
- `*this`. The unspecialized form has exception guards, which the specialized
- forms do not, so as to insure exception safety. For the unspecialized form,
- the base type's assignment operators must not throw.
- octonion<T> & operator -= (T const & rhs)
- octonion<T> & operator -= (::std::complex<T> const & rhs);
- octonion<T> & operator -= (::boost::math::quaternion<T> const & rhs);
- template<typename X>
- octonion<T> & operator -= (octonion<X> const & rhs);
- These perform the mathematical operation `(*this)-rhs` and store the result
- in `*this`. The unspecialized form has exception guards, which the
- specialized forms do not, so as to insure exception safety.
- For the unspecialized form, the base type's assignment operators must not throw.
- octonion<T> & operator *= (T const & rhs)
- octonion<T> & operator *= (::std::complex<T> const & rhs);
- octonion<T> & operator *= (::boost::math::quaternion<T> const & rhs);
- template<typename X>
- octonion<T> & operator *= (octonion<X> const & rhs);
- These perform the mathematical operation `(*this)*rhs` in this order
- (order is important as multiplication is not commutative for octonions)
- and store the result in `*this`. The unspecialized form has exception guards,
- which the specialized forms do not, so as to insure exception safety.
- For the unspecialized form, the base type's assignment operators must
- not throw. Also, for clarity's sake, you should always group the
- factors in a multiplication by groups of two, as the multiplication is
- not even associative on the octonions (though there are of course cases
- where this does not matter, it usually does).
- octonion<T> & operator /= (T const & rhs)
- octonion<T> & operator /= (::std::complex<T> const & rhs);
- octonion<T> & operator /= (::boost::math::quaternion<T> const & rhs);
- template<typename X>
- octonion<T> & operator /= (octonion<X> const & rhs);
- These perform the mathematical operation `(*this)*inverse_of(rhs)`
- in this order (order is important as multiplication is not commutative
- for octonions) and store the result in `*this`. The unspecialized form
- has exception guards, which the specialized forms do not, so as to
- insure exception safety. For the unspecialized form, the base
- type's assignment operators must not throw. As for the multiplication,
- remember to group any two factors using parenthesis.
- [endsect] [/section:oct_mem_fun Octonion Member Functions]
- [section:oct_non_mem Octonion Non-Member Operators]
- [h4 Unary Plus and Minus Operators]
- template<typename T> octonion<T> operator + (octonion<T> const & o);
- This unary operator simply returns o.
- template<typename T> octonion<T> operator - (octonion<T> const & o);
- This unary operator returns the opposite of o.
- [h4 Binary Addition Operators]
- template<typename T> octonion<T> operator + (T const & lhs, octonion<T> const & rhs);
- template<typename T> octonion<T> operator + (octonion<T> const & lhs, T const & rhs);
- template<typename T> octonion<T> operator + (::std::complex<T> const & lhs, octonion<T> const & rhs);
- template<typename T> octonion<T> operator + (octonion<T> const & lhs, ::std::complex<T> const & rhs);
- template<typename T> octonion<T> operator + (::boost::math::quaternion<T> const & lhs, octonion<T> const & rhs);
- template<typename T> octonion<T> operator + (octonion<T> const & lhs, ::boost::math::quaternion<T> const & rhs);
- template<typename T> octonion<T> operator + (octonion<T> const & lhs, octonion<T> const & rhs);
- These operators return `octonion<T>(lhs) += rhs`.
- [h4 Binary Subtraction Operators]
- template<typename T> octonion<T> operator - (T const & lhs, octonion<T> const & rhs);
- template<typename T> octonion<T> operator - (octonion<T> const & lhs, T const & rhs);
- template<typename T> octonion<T> operator - (::std::complex<T> const & lhs, octonion<T> const & rhs);
- template<typename T> octonion<T> operator - (octonion<T> const & lhs, ::std::complex<T> const & rhs);
- template<typename T> octonion<T> operator - (::boost::math::quaternion<T> const & lhs, octonion<T> const & rhs);
- template<typename T> octonion<T> operator - (octonion<T> const & lhs, ::boost::math::quaternion<T> const & rhs);
- template<typename T> octonion<T> operator - (octonion<T> const & lhs, octonion<T> const & rhs);
- These operators return `octonion<T>(lhs) -= rhs`.
- [h4 Binary Multiplication Operators]
- template<typename T> octonion<T> operator * (T const & lhs, octonion<T> const & rhs);
- template<typename T> octonion<T> operator * (octonion<T> const & lhs, T const & rhs);
- template<typename T> octonion<T> operator * (::std::complex<T> const & lhs, octonion<T> const & rhs);
- template<typename T> octonion<T> operator * (octonion<T> const & lhs, ::std::complex<T> const & rhs);
- template<typename T> octonion<T> operator * (::boost::math::quaternion<T> const & lhs, octonion<T> const & rhs);
- template<typename T> octonion<T> operator * (octonion<T> const & lhs, ::boost::math::quaternion<T> const & rhs);
- template<typename T> octonion<T> operator * (octonion<T> const & lhs, octonion<T> const & rhs);
- These operators return `octonion<T>(lhs) *= rhs`.
- [h4 Binary Division Operators]
- template<typename T> octonion<T> operator / (T const & lhs, octonion<T> const & rhs);
- template<typename T> octonion<T> operator / (octonion<T> const & lhs, T const & rhs);
- template<typename T> octonion<T> operator / (::std::complex<T> const & lhs, octonion<T> const & rhs);
- template<typename T> octonion<T> operator / (octonion<T> const & lhs, ::std::complex<T> const & rhs);
- template<typename T> octonion<T> operator / (::boost::math::quaternion<T> const & lhs, octonion<T> const & rhs);
- template<typename T> octonion<T> operator / (octonion<T> const & lhs, ::boost::math::quaternion<T> const & rhs);
- template<typename T> octonion<T> operator / (octonion<T> const & lhs, octonion<T> const & rhs);
- These operators return `octonion<T>(lhs) /= rhs`. It is of course still an
- error to divide by zero...
- [h4 Binary Equality Operators]
- template<typename T> bool operator == (T const & lhs, octonion<T> const & rhs);
- template<typename T> bool operator == (octonion<T> const & lhs, T const & rhs);
- template<typename T> bool operator == (::std::complex<T> const & lhs, octonion<T> const & rhs);
- template<typename T> bool operator == (octonion<T> const & lhs, ::std::complex<T> const & rhs);
- template<typename T> bool operator == (::boost::math::quaternion<T> const & lhs, octonion<T> const & rhs);
- template<typename T> bool operator == (octonion<T> const & lhs, ::boost::math::quaternion<T> const & rhs);
- template<typename T> bool operator == (octonion<T> const & lhs, octonion<T> const & rhs);
- These return true if and only if the four components of `octonion<T>(lhs)`
- are equal to their counterparts in `octonion<T>(rhs)`. As with any
- floating-type entity, this is essentially meaningless.
- [h4 Binary Inequality Operators]
- template<typename T> bool operator != (T const & lhs, octonion<T> const & rhs);
- template<typename T> bool operator != (octonion<T> const & lhs, T const & rhs);
- template<typename T> bool operator != (::std::complex<T> const & lhs, octonion<T> const & rhs);
- template<typename T> bool operator != (octonion<T> const & lhs, ::std::complex<T> const & rhs);
- template<typename T> bool operator != (::boost::math::quaternion<T> const & lhs, octonion<T> const & rhs);
- template<typename T> bool operator != (octonion<T> const & lhs, ::boost::math::quaternion<T> const & rhs);
- template<typename T> bool operator != (octonion<T> const & lhs, octonion<T> const & rhs);
- These return true if and only if `octonion<T>(lhs) == octonion<T>(rhs)`
- is false. As with any floating-type entity, this is essentially meaningless.
- [h4 Stream Extractor]
- template<typename T, typename charT, class traits>
- ::std::basic_istream<charT,traits> & operator >> (::std::basic_istream<charT,traits> & is, octonion<T> & o);
- Extracts an octonion `o`. We accept any format which seems reasonable.
- However, since this leads to a great many ambiguities, decisions were made
- to lift these. In case of doubt, stick to lists of reals.
- The input values must be convertible to T. If bad input is encountered,
- calls `is.setstate(ios::failbit)` (which may throw `ios::failure` (27.4.5.3)).
- Returns `is`.
- [h4 Stream Inserter]
- template<typename T, typename charT, class traits>
- ::std::basic_ostream<charT,traits> & operator << (::std::basic_ostream<charT,traits> & os, octonion<T> const & o);
- Inserts the octonion `o` onto the stream `os` as if it were implemented as follows:
- template<typename T, typename charT, class traits>
- ::std::basic_ostream<charT,traits> & operator << ( ::std::basic_ostream<charT,traits> & os,
- octonion<T> const & o)
- {
- ::std::basic_ostringstream<charT,traits> s;
- s.flags(os.flags());
- s.imbue(os.getloc());
- s.precision(os.precision());
- s << '(' << o.R_component_1() << ','
- << o.R_component_2() << ','
- << o.R_component_3() << ','
- << o.R_component_4() << ','
- << o.R_component_5() << ','
- << o.R_component_6() << ','
- << o.R_component_7() << ','
- << o.R_component_8() << ')';
- return os << s.str();
- }
- [endsect] [/section:oct_non_mem Octonion Non-Member Operators]
- [section:oct_value_ops Octonion Value Operations]
- [h4 Real and Unreal]
- template<typename T> T real(octonion<T> const & o);
- template<typename T> octonion<T> unreal(octonion<T> const & o);
- These return `o.real()` and `o.unreal()` respectively.
- [h4 conj]
- template<typename T> octonion<T> conj(octonion<T> const & o);
- This returns the conjugate of the octonion.
- [h4 sup]
- template<typename T> T sup(octonion<T> const & o);
- This return the sup norm (the greatest among
- `abs(o.R_component_1())...abs(o.R_component_8()))` of the octonion.
- [h4 l1]
- template<typename T> T l1(octonion<T> const & o);
- This return the l1 norm (`abs(o.R_component_1())+...+abs(o.R_component_8())`)
- of the octonion.
- [h4 abs]
- template<typename T> T abs(octonion<T> const & o);
- This return the magnitude (Euclidian norm) of the octonion.
- [h4 norm]
- template<typename T> T norm(octonion<T>const & o);
- This return the (Cayley) norm of the octonion. The term "norm" might
- be confusing, as most people associate it with the Euclidian norm
- (and quadratic functionals). For this version of (the mathematical
- objects known as) octonions, the Euclidian norm (also known as
- magnitude) is the square root of the Cayley norm.
- [endsect] [/section:oct_value_ops Octonion Value Operations]
- [section:oct_create Octonion Creation Functions]
- 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);
- 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);
- 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);
- These build octonions in a way similar to the way polar builds
- complex numbers, as there is no strict equivalent to
- polar coordinates for octonions.
- `spherical` is a simple transposition of `polar`, it takes as inputs a
- (positive) magnitude and a point on the hypersphere, given
- by three angles. The first of these, ['theta] has a natural range of
- -pi to +pi, and the other two have natural ranges of
- -pi/2 to +pi/2 (as is the case with the usual spherical
- coordinates in __R3). Due to the many symmetries and periodicities,
- nothing untoward happens if the magnitude is negative or the angles are
- outside their natural ranges. The expected degeneracies (a magnitude of
- zero ignores the angles settings...) do happen however.
- `cylindrical` is likewise a simple transposition of the usual
- cylindrical coordinates in __R3, which in turn is another derivative of
- planar polar coordinates. The first two inputs are the polar
- coordinates of the first __C component of the octonion. The third and
- fourth inputs are placed into the third and fourth __R components of the
- octonion, respectively.
- `multipolar` is yet another simple generalization of polar coordinates.
- This time, both __C components of the octonion are given in polar coordinates.
- In this version of our implementation of octonions, there is no
- analogue of the complex value operation arg as the situation is
- somewhat more complicated.
- [endsect] [/section:oct_create Octonion Creation Functions]
- [section:oct_trans Octonions Transcendentals]
- There is no `log` or `sqrt` provided for octonions in this implementation,
- and `pow` is likewise restricted to integral powers of the exponent.
- There are several reasons to this: on the one hand, the equivalent of
- analytic continuation for octonions ("branch cuts") remains to be
- investigated thoroughly (by me, at any rate...), and we wish to avoid
- the nonsense introduced in the standard by exponentiations of
- complexes by complexes (which is well defined, but not in the standard...).
- Talking of nonsense, saying that `pow(0,0)` is "implementation defined" is
- just plain brain-dead...
- We do, however provide several transcendentals, chief among which is
- the exponential. That it allows for a "closed formula" is a result
- of the author (the existence and definition of the exponential, on the
- octonions among others, on the other hand, is a few centuries old).
- Basically, any converging power series with real coefficients which
- allows for a closed formula in __C can be transposed to __O. More
- transcendentals of this type could be added in a further revision upon
- request. It should be noted that it is these functions which force the
- dependency upon the
- [@../../../../boost/math/special_functions/sinc.hpp boost/math/special_functions/sinc.hpp]
- and the
- [@../../../../boost/math/special_functions/sinhc.hpp boost/math/special_functions/sinhc.hpp]
- headers.
- [h4 exp]
- template<typename T>
- octonion<T> exp(octonion<T> const & o);
- Computes the exponential of the octonion.
- [h4 cos]
- template<typename T>
- octonion<T> cos(octonion<T> const & o);
- Computes the cosine of the octonion
- [h4 sin]
- template<typename T>
- octonion<T> sin(octonion<T> const & o);
- Computes the sine of the octonion.
- [h4 tan]
- template<typename T>
- octonion<T> tan(octonion<T> const & o);
- Computes the tangent of the octonion.
- [h4 cosh]
- template<typename T>
- octonion<T> cosh(octonion<T> const & o);
- Computes the hyperbolic cosine of the octonion.
- [h4 sinh]
- template<typename T>
- octonion<T> sinh(octonion<T> const & o);
- Computes the hyperbolic sine of the octonion.
- [h4 tanh]
- template<typename T>
- octonion<T> tanh(octonion<T> const & o);
- Computes the hyperbolic tangent of the octonion.
- [h4 pow]
- template<typename T>
- octonion<T> pow(octonion<T> const & o, int n);
- Computes the n-th power of the octonion q.
- [endsect]
- [section:oct_tests Test Program]
- The [@../../test/octonion_test.cpp octonion_test.cpp]
- test program tests octonions specialisations for float, double and long double
- ([@../octonion/output.txt sample output]).
- If you define the symbol BOOST_OCTONION_TEST_VERBOSE, you will get additional
- output ([@../octonion/output_more.txt verbose output]); this will
- only be helpfull if you enable message output at the same time, of course
- (by uncommenting the relevant line in the test or by adding --log_level=messages
- to your command line,...). In that case, and if you are running interactively,
- you may in addition define the symbol BOOST_INTERACTIVE_TEST_INPUT_ITERATOR to
- interactively test the input operator with input of your choice from the
- standard input (instead of hard-coding it in the test).
- [endsect] [/section:oct_trans Octonions Transcendentals]
- [section:acknowledgements Acknowledgements]
- The mathematical text has been typeset with
- [@http://www.nisus-soft.com/ Nisus Writer].
- Jens Maurer has helped with portability and standard adherence, and was the
- Review Manager for this library. More acknowledgements in the
- History section. Thank you to all who contributed to the discussion about this library.
- [endsect] [/section:acknowledgements Acknowledgements]
- [section:oct_history History]
- * 1.5.9 - 13/5/2013: Incorporated into Boost.Math.
- * 1.5.8 - 17/12/2005: Converted documentation to Quickbook Format.
- * 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>.
- * 1.5.6 - 15/10/2002: Gcc2.95.x and stlport on linux compatibility by Alkis Evlogimenos (alkis@routescience.com).
- * 1.5.5 - 27/09/2002: Microsoft VCPP 7 compatibility, by Michael Stevens (michael@acfr.usyd.edu.au); requires the /Za compiler option.
- * 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.
- * 1.5.3 - 01/02/2002: bugfix and Gcc 2.95.3 compatibility by Douglas Gregor (gregod@cs.rpi.edu).
- * 1.5.2 - 07/07/2001: introduced namespace math.
- * 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.
- * 1.5.0 - 23/03/2001: boostification, inlining of all operators except input, output and pow, fixed exception safety of some members (template version).
- * 1.4.0 - 09/01/2001: added tan and tanh.
- * 1.3.1 - 08/01/2001: cosmetic fixes.
- * 1.3.0 - 12/07/2000: pow now uses Maarten Hilferink's (mhilferink@tip.nl) algorithm.
- * 1.2.0 - 25/05/2000: fixed the division operators and output; changed many signatures.
- * 1.1.0 - 23/05/2000: changed sinc into sinc_pi; added sin, cos, sinh, cosh.
- * 1.0.0 - 10/08/1999: first public version.
- [endsect] [/section:oct_history History]
- [section:oct_todo To Do]
- * Improve testing.
- * Rewrite input operators using Spirit (creates a dependency).
- * Put in place an Expression Template mechanism (perhaps borrowing from uBlas).
- [endsect] [/section:oct_todo To Do]
- [endmathpart]
- [/
- Copyright 1999, 2005, 2013 Hubert Holin.
- Distributed under the Boost Software License, Version 1.0.
- (See accompanying file LICENSE_1_0.txt or copy at
- http://www.boost.org/LICENSE_1_0.txt).
- ]
|