| [article Boost.Quaternions |
| [quickbook 1.3] |
| [copyright 2001-2003 Hubert Holin] |
| [purpose Quaternions] |
| [license |
| 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 http://www.boost.org/LICENSE_1_0.txt]) |
| ] |
| [authors [Holin, Hubert]] |
| [category math] |
| [last-revision $Date: 2006-12-29 11:08:32 +0000 (Fri, 29 Dec 2006) $] |
| ] |
| |
| [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 __quadrulple ('''α,β,γ,δ''')] |
| [def __quat_formula ['[^q = '''α + βi + γj + δk''']]] |
| [def __quat_complex_formula ['[^q = ('''α + βi) + (γ + δi)j''' ]]] |
| [def __not_equal ['[^xy '''≠''' yx]]] |
| |
| [def __asinh [link boost_quaternions.math_special_functions.asinh asinh]] |
| [def __acosh [link boost_quaternions.math_special_functions.acosh acosh]] |
| [def __atanh [link boost_quaternions.math_special_functions.atanh atanh]] |
| [def __sinc_pi [link boost_quaternions.math_special_functions.sinc_pi sinc_pi]] |
| [def __sinhc_pi [link boost_quaternions.math_special_functions.sinhc_pi sinhc_pi]] |
| |
| [def __log1p [link boost_quaternions.math_special_functions.log1p log1p]] |
| [def __expm1 [link boost_quaternions.math_special_functions.expm1 expm1]] |
| [def __hypot [link boost_quaternions.math_special_functions.hypot hypot]] |
| |
| This manual is also available in |
| [@http://svn.boost.org/svn/boost/sandbox/pdf/math/release/quaternion.pdf |
| printer friendly PDF format]. |
| |
| |
| [section Quaternions] |
| |
| [section Overview] |
| |
| Quaternions are a relative of complex numbers. |
| |
| Quaternions are in fact part of a small hierarchy of structures built |
| upon the real numbers, which comprise only the set of real numbers |
| (traditionally named __R), the set of complex numbers (traditionally named __C), |
| the set of quaternions (traditionally named __H) and the set of octonions |
| (traditionally named __O), which possess interesting mathematical properties |
| (chief among which is the fact that they are ['division algebras], |
| ['i.e.] where the following property is true: if ['[^y]] is an element of that |
| algebra and is [*not equal to zero], then ['[^yx = yx']], where ['[^x]] and ['[^x']] |
| denote elements of that algebra, implies that ['[^x = x']]). |
| Each member of the hierarchy is a super-set of the former. |
| |
| One of the most important aspects of quaternions is that they provide an |
| efficient way to parameterize rotations in __R3 (the usual three-dimensional space) |
| and __R4. |
| |
| In practical terms, a quaternion is simply a quadruple of real numbers __quadrulple, |
| which we can write in the form __quat_formula, where ['[^i]] is the same object as for complex numbers, |
| and ['[^j]] and ['[^k]] are distinct objects which play essentially the same kind of role as ['[^i]]. |
| |
| An addition and a multiplication is defined on the set of quaternions, |
| which generalize their real and complex counterparts. The main novelty |
| here is that [*the multiplication is not commutative] (i.e. there are |
| quaternions ['[^x]] and ['[^y]] such that __not_equal). A good mnemotechnical way of remembering |
| things is by using the formula ['[^i*i = j*j = k*k = -1]]. |
| |
| Quaternions (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 quaternions, but other, such as taking |
| a square root, do not. |
| |
| [endsect] |
| |
| [section Header File] |
| |
| The interface and implementation are both supplied by the header file |
| [@../../../../../boost/math/quaternion.hpp quaternion.hpp]. |
| |
| [endsect] |
| |
| [section Synopsis] |
| |
| namespace boost{ namespace math{ |
| |
| template<typename T> class ``[link boost_quaternions.quaternions.quat quaternion]``; |
| template<> class ``[link boost_quaternions.quaternions.spec quaternion<float>]``; |
| template<> class ``[link boost_quaternions.quaternion_double quaternion<double>]``; |
| template<> class ``[link boost_quaternions.quaternion_long_double quaternion<long double>]``; |
| |
| // operators |
| template<typename T> quaternion<T> ``[link boost_quaternions.quaternions.non_mem.binary_addition_operators operator +]`` (T const & lhs, quaternion<T> const & rhs); |
| template<typename T> quaternion<T> ``[link boost_quaternions.quaternions.non_mem.binary_addition_operators operator +]`` (quaternion<T> const & lhs, T const & rhs); |
| template<typename T> quaternion<T> ``[link boost_quaternions.quaternions.non_mem.binary_addition_operators operator +]`` (::std::complex<T> const & lhs, quaternion<T> const & rhs); |
| template<typename T> quaternion<T> ``[link boost_quaternions.quaternions.non_mem.binary_addition_operators operator +]`` (quaternion<T> const & lhs, ::std::complex<T> const & rhs); |
| template<typename T> quaternion<T> ``[link boost_quaternions.quaternions.non_mem.binary_addition_operators operator +]`` (quaternion<T> const & lhs, quaternion<T> const & rhs); |
| |
| template<typename T> quaternion<T> ``[link boost_quaternions.quaternions.non_mem.binary_subtraction_operators operator -]`` (T const & lhs, quaternion<T> const & rhs); |
| template<typename T> quaternion<T> ``[link boost_quaternions.quaternions.non_mem.binary_subtraction_operators operator -]`` (quaternion<T> const & lhs, T const & rhs); |
| template<typename T> quaternion<T> ``[link boost_quaternions.quaternions.non_mem.binary_subtraction_operators operator -]`` (::std::complex<T> const & lhs, quaternion<T> const & rhs); |
| template<typename T> quaternion<T> ``[link boost_quaternions.quaternions.non_mem.binary_subtraction_operators operator -]`` (quaternion<T> const & lhs, ::std::complex<T> const & rhs); |
| template<typename T> quaternion<T> ``[link boost_quaternions.quaternions.non_mem.binary_subtraction_operators operator -]`` (quaternion<T> const & lhs, quaternion<T> const & rhs); |
| |
| template<typename T> quaternion<T> ``[link boost_quaternions.quaternions.non_mem.binary_multiplication_operators operator *]`` (T const & lhs, quaternion<T> const & rhs); |
| template<typename T> quaternion<T> ``[link boost_quaternions.quaternions.non_mem.binary_multiplication_operators operator *]`` (quaternion<T> const & lhs, T const & rhs); |
| template<typename T> quaternion<T> ``[link boost_quaternions.quaternions.non_mem.binary_multiplication_operators operator *]`` (::std::complex<T> const & lhs, quaternion<T> const & rhs); |
| template<typename T> quaternion<T> ``[link boost_quaternions.quaternions.non_mem.binary_multiplication_operators operator *]`` (quaternion<T> const & lhs, ::std::complex<T> const & rhs); |
| template<typename T> quaternion<T> ``[link boost_quaternions.quaternions.non_mem.binary_multiplication_operators operator *]`` (quaternion<T> const & lhs, quaternion<T> const & rhs); |
| |
| template<typename T> quaternion<T> ``[link boost_quaternions.quaternions.non_mem.binary_division_operators operator /]`` (T const & lhs, quaternion<T> const & rhs); |
| template<typename T> quaternion<T> ``[link boost_quaternions.quaternions.non_mem.binary_division_operators operator /]`` (quaternion<T> const & lhs, T const & rhs); |
| template<typename T> quaternion<T> ``[link boost_quaternions.quaternions.non_mem.binary_division_operators operator /]`` (::std::complex<T> const & lhs, quaternion<T> const & rhs); |
| template<typename T> quaternion<T> ``[link boost_quaternions.quaternions.non_mem.binary_division_operators operator /]`` (quaternion<T> const & lhs, ::std::complex<T> const & rhs); |
| template<typename T> quaternion<T> ``[link boost_quaternions.quaternions.non_mem.binary_division_operators operator /]`` (quaternion<T> const & lhs, quaternion<T> const & rhs); |
| |
| template<typename T> quaternion<T> ``[link boost_quaternions.quaternions.non_mem.unary_plus operator +]`` (quaternion<T> const & q); |
| template<typename T> quaternion<T> ``[link boost_quaternions.quaternions.non_mem.unary_minus operator -]`` (quaternion<T> const & q); |
| |
| template<typename T> bool ``[link boost_quaternions.quaternions.non_mem.equality_operators operator ==]`` (T const & lhs, quaternion<T> const & rhs); |
| template<typename T> bool ``[link boost_quaternions.quaternions.non_mem.equality_operators operator ==]`` (quaternion<T> const & lhs, T const & rhs); |
| template<typename T> bool ``[link boost_quaternions.quaternions.non_mem.equality_operators operator ==]`` (::std::complex<T> const & lhs, quaternion<T> const & rhs); |
| template<typename T> bool ``[link boost_quaternions.quaternions.non_mem.equality_operators operator ==]`` (quaternion<T> const & lhs, ::std::complex<T> const & rhs); |
| template<typename T> bool ``[link boost_quaternions.quaternions.non_mem.equality_operators operator ==]`` (quaternion<T> const & lhs, quaternion<T> const & rhs); |
| |
| template<typename T> bool ``[link boost_quaternions.quaternions.non_mem.inequality_operators operator !=]`` (T const & lhs, quaternion<T> const & rhs); |
| template<typename T> bool ``[link boost_quaternions.quaternions.non_mem.inequality_operators operator !=]`` (quaternion<T> const & lhs, T const & rhs); |
| template<typename T> bool ``[link boost_quaternions.quaternions.non_mem.inequality_operators operator !=]`` (::std::complex<T> const & lhs, quaternion<T> const & rhs); |
| template<typename T> bool ``[link boost_quaternions.quaternions.non_mem.inequality_operators operator !=]`` (quaternion<T> const & lhs, ::std::complex<T> const & rhs); |
| template<typename T> bool ``[link boost_quaternions.quaternions.non_mem.inequality_operators operator !=]`` (quaternion<T> const & lhs, quaternion<T> const & rhs); |
| |
| template<typename T, typename charT, class traits> |
| ::std::basic_istream<charT,traits>& ``[link boost_quaternions.quaternions.non_mem.stream_extractor operator >>]`` (::std::basic_istream<charT,traits> & is, quaternion<T> & q); |
| |
| template<typename T, typename charT, class traits> |
| ::std::basic_ostream<charT,traits>& operator ``[link boost_quaternions.quaternions.non_mem.stream_inserter operator <<]`` (::std::basic_ostream<charT,traits> & os, quaternion<T> const & q); |
| |
| // values |
| template<typename T> T ``[link boost_quaternions.quaternions.value_op.real_and_unreal real]``(quaternion<T> const & q); |
| template<typename T> quaternion<T> ``[link boost_quaternions.quaternions.value_op.real_and_unreal unreal]``(quaternion<T> const & q); |
| |
| template<typename T> T ``[link boost_quaternions.quaternions.value_op.sup sup]``(quaternion<T> const & q); |
| template<typename T> T ``[link boost_quaternions.quaternions.value_op.l1 l1]``(quaternion<T> const & q); |
| template<typename T> T ``[link boost_quaternions.quaternions.value_op.abs abs]``(quaternion<T> const & q); |
| template<typename T> T ``[link boost_quaternions.quaternions.value_op.norm norm]``(quaternion<T>const & q); |
| template<typename T> quaternion<T> ``[link boost_quaternions.quaternions.value_op.conj conj]``(quaternion<T> const & q); |
| |
| template<typename T> quaternion<T> ``[link boost_quaternions.quaternions.creation_spherical spherical]``(T const & rho, T const & theta, T const & phi1, T const & phi2); |
| template<typename T> quaternion<T> ``[link boost_quaternions.quaternions.creation_semipolar semipolar]``(T const & rho, T const & alpha, T const & theta1, T const & theta2); |
| template<typename T> quaternion<T> ``[link boost_quaternions.quaternions.creation_multipolar multipolar]``(T const & rho1, T const & theta1, T const & rho2, T const & theta2); |
| template<typename T> quaternion<T> ``[link boost_quaternions.quaternions.creation_cylindrospherical cylindrospherical]``(T const & t, T const & radius, T const & longitude, T const & latitude); |
| template<typename T> quaternion<T> ``[link boost_quaternions.quaternions.creation_cylindrical cylindrical]``(T const & r, T const & angle, T const & h1, T const & h2); |
| |
| // transcendentals |
| template<typename T> quaternion<T> ``[link boost_quaternions.quaternions.trans.exp exp]``(quaternion<T> const & q); |
| template<typename T> quaternion<T> ``[link boost_quaternions.quaternions.trans.cos cos]``(quaternion<T> const & q); |
| template<typename T> quaternion<T> ``[link boost_quaternions.quaternions.trans.sin sin]``(quaternion<T> const & q); |
| template<typename T> quaternion<T> ``[link boost_quaternions.quaternions.trans.tan tan]``(quaternion<T> const & q); |
| template<typename T> quaternion<T> ``[link boost_quaternions.quaternions.trans.cosh cosh]``(quaternion<T> const & q); |
| template<typename T> quaternion<T> ``[link boost_quaternions.quaternions.trans.sinh sinh]``(quaternion<T> const & q); |
| template<typename T> quaternion<T> ``[link boost_quaternions.quaternions.trans.tanh tanh]``(quaternion<T> const & q); |
| template<typename T> quaternion<T> ``[link boost_quaternions.quaternions.trans.pow pow]``(quaternion<T> const & q, int n); |
| |
| } // namespace math |
| } // namespace boost |
| |
| [endsect] |
| |
| [section:quat Template Class quaternion] |
| |
| namespace boost{ namespace math{ |
| |
| template<typename T> |
| class quaternion |
| { |
| public: |
| |
| typedef T ``[link boost_quaternions.quaternions.mem_typedef value_type]``; |
| |
| explicit ``[link boost_quaternions.quaternions.mem_fun.constructors quaternion]``(T const & requested_a = T(), T const & requested_b = T(), T const & requested_c = T(), T const & requested_d = T()); |
| explicit ``[link boost_quaternions.quaternions.mem_fun.constructors quaternion]``(::std::complex<T> const & z0, ::std::complex<T> const & z1 = ::std::complex<T>()); |
| template<typename X> |
| explicit ``[link boost_quaternions.quaternions.mem_fun.constructors quaternion]``(quaternion<X> const & a_recopier); |
| |
| T ``[link boost_quaternions.quaternions.mem_fun.real_and_unreal_parts real]``() const; |
| quaternion<T> ``[link boost_quaternions.quaternions.mem_fun.real_and_unreal_parts unreal]``() const; |
| T ``[link boost_quaternions.quaternions.mem_fun.individual_real_components R_component_1]``() const; |
| T ``[link boost_quaternions.quaternions.mem_fun.individual_real_components R_component_2]``() const; |
| T ``[link boost_quaternions.quaternions.mem_fun.individual_real_components R_component_3]``() const; |
| T ``[link boost_quaternions.quaternions.mem_fun.individual_real_components R_component_4]``() const; |
| ::std::complex<T> ``[link boost_quaternions.quaternions.mem_fun.individual_complex__components C_component_1]``() const; |
| ::std::complex<T> ``[link boost_quaternions.quaternions.mem_fun.individual_complex__components C_component_2]``() const; |
| |
| quaternion<T>& ``[link boost_quaternions.quaternions.mem_fun.assignment_operators operator = ]``(quaternion<T> const & a_affecter); |
| template<typename X> |
| quaternion<T>& ``[link boost_quaternions.quaternions.mem_fun.assignment_operators operator = ]``(quaternion<X> const & a_affecter); |
| quaternion<T>& ``[link boost_quaternions.quaternions.mem_fun.assignment_operators operator = ]``(T const & a_affecter); |
| quaternion<T>& ``[link boost_quaternions.quaternions.mem_fun.assignment_operators operator = ]``(::std::complex<T> const & a_affecter); |
| |
| quaternion<T>& ``[link boost_quaternions.quaternions.mem_fun.addition_operators operator += ]``(T const & rhs); |
| quaternion<T>& ``[link boost_quaternions.quaternions.mem_fun.addition_operators operator += ]``(::std::complex<T> const & rhs); |
| template<typename X> |
| quaternion<T>& ``[link boost_quaternions.quaternions.mem_fun.addition_operators operator += ]``(quaternion<X> const & rhs); |
| |
| quaternion<T>& ``[link boost_quaternions.quaternions.mem_fun.subtraction_operators operator -= ]``(T const & rhs); |
| quaternion<T>& ``[link boost_quaternions.quaternions.mem_fun.subtraction_operators operator -= ]``(::std::complex<T> const & rhs); |
| template<typename X> |
| quaternion<T>& ``[link boost_quaternions.quaternions.mem_fun.subtraction_operators operator -= ]``(quaternion<X> const & rhs); |
| |
| quaternion<T>& ``[link boost_quaternions.quaternions.mem_fun.multiplication_operators operator *= ]``(T const & rhs); |
| quaternion<T>& ``[link boost_quaternions.quaternions.mem_fun.multiplication_operators operator *= ]``(::std::complex<T> const & rhs); |
| template<typename X> |
| quaternion<T>& ``[link boost_quaternions.quaternions.mem_fun.multiplication_operators operator *= ]``(quaternion<X> const & rhs); |
| |
| quaternion<T>& ``[link boost_quaternions.quaternions.mem_fun.division_operators operator /= ]``(T const & rhs); |
| quaternion<T>& ``[link boost_quaternions.quaternions.mem_fun.division_operators operator /= ]``(::std::complex<T> const & rhs); |
| template<typename X> |
| quaternion<T>& ``[link boost_quaternions.quaternions.mem_fun.division_operators operator /= ]``(quaternion<X> const & rhs); |
| }; |
| |
| } // namespace math |
| } // namespace boost |
| |
| [endsect] |
| |
| [section:spec Quaternion Specializations] |
| |
| namespace boost{ namespace math{ |
| |
| template<> |
| class quaternion<float> |
| { |
| public: |
| typedef float ``[link boost_quaternions.quaternions.mem_typedef value_type]``; |
| |
| explicit ``[link boost_quaternions.quaternions.mem_fun.constructors quaternion]``(float const & requested_a = 0.0f, float const & requested_b = 0.0f, float const & requested_c = 0.0f, float const & requested_d = 0.0f); |
| explicit ``[link boost_quaternions.quaternions.mem_fun.constructors quaternion]``(::std::complex<float> const & z0, ::std::complex<float> const & z1 = ::std::complex<float>()); |
| explicit ``[link boost_quaternions.quaternions.mem_fun.constructors quaternion]``(quaternion<double> const & a_recopier); |
| explicit ``[link boost_quaternions.quaternions.mem_fun.constructors quaternion]``(quaternion<long double> const & a_recopier); |
| |
| float ``[link boost_quaternions.quaternions.mem_fun.real_and_unreal_parts real]``() const; |
| quaternion<float> ``[link boost_quaternions.quaternions.mem_fun.real_and_unreal_parts unreal]``() const; |
| float ``[link boost_quaternions.quaternions.mem_fun.individual_real_components R_component_1]``() const; |
| float ``[link boost_quaternions.quaternions.mem_fun.individual_real_components R_component_2]``() const; |
| float ``[link boost_quaternions.quaternions.mem_fun.individual_real_components R_component_3]``() const; |
| float ``[link boost_quaternions.quaternions.mem_fun.individual_real_components R_component_4]``() const; |
| ::std::complex<float> ``[link boost_quaternions.quaternions.mem_fun.individual_complex__components C_component_1]``() const; |
| ::std::complex<float> ``[link boost_quaternions.quaternions.mem_fun.individual_complex__components C_component_2]``() const; |
| |
| quaternion<float>& ``[link boost_quaternions.quaternions.mem_fun.assignment_operators operator = ]``(quaternion<float> const & a_affecter); |
| template<typename X> |
| quaternion<float>& ``[link boost_quaternions.quaternions.mem_fun.assignment_operators operator = ]``(quaternion<X> const & a_affecter); |
| quaternion<float>& ``[link boost_quaternions.quaternions.mem_fun.assignment_operators operator = ]``(float const & a_affecter); |
| quaternion<float>& ``[link boost_quaternions.quaternions.mem_fun.assignment_operators operator = ]``(::std::complex<float> const & a_affecter); |
| |
| quaternion<float>& ``[link boost_quaternions.quaternions.mem_fun.addition_operators operator += ]``(float const & rhs); |
| quaternion<float>& ``[link boost_quaternions.quaternions.mem_fun.addition_operators operator += ]``(::std::complex<float> const & rhs); |
| template<typename X> |
| quaternion<float>& ``[link boost_quaternions.quaternions.mem_fun.addition_operators operator += ]``(quaternion<X> const & rhs); |
| |
| quaternion<float>& ``[link boost_quaternions.quaternions.mem_fun.subtraction_operators operator -= ]``(float const & rhs); |
| quaternion<float>& ``[link boost_quaternions.quaternions.mem_fun.subtraction_operators operator -= ]``(::std::complex<float> const & rhs); |
| template<typename X> |
| quaternion<float>& ``[link boost_quaternions.quaternions.mem_fun.subtraction_operators operator -= ]``(quaternion<X> const & rhs); |
| |
| quaternion<float>& ``[link boost_quaternions.quaternions.mem_fun.multiplication_operators operator *= ]``(float const & rhs); |
| quaternion<float>& ``[link boost_quaternions.quaternions.mem_fun.multiplication_operators operator *= ]``(::std::complex<float> const & rhs); |
| template<typename X> |
| quaternion<float>& ``[link boost_quaternions.quaternions.mem_fun.multiplication_operators operator *= ]``(quaternion<X> const & rhs); |
| |
| quaternion<float>& ``[link boost_quaternions.quaternions.mem_fun.division_operators operator /= ]``(float const & rhs); |
| quaternion<float>& ``[link boost_quaternions.quaternions.mem_fun.division_operators operator /= ]``(::std::complex<float> const & rhs); |
| template<typename X> |
| quaternion<float>& ``[link boost_quaternions.quaternions.mem_fun.division_operators operator /= ]``(quaternion<X> const & rhs); |
| }; |
| |
| [#boost_quaternions.quaternion_double] |
| |
| template<> |
| class quaternion<double> |
| { |
| public: |
| typedef double ``[link boost_quaternions.quaternions.mem_typedef value_type]``; |
| |
| explicit ``[link boost_quaternions.quaternions.mem_fun.constructors quaternion]``(double const & requested_a = 0.0, double const & requested_b = 0.0, double const & requested_c = 0.0, double const & requested_d = 0.0); |
| explicit ``[link boost_quaternions.quaternions.mem_fun.constructors quaternion]``(::std::complex<double> const & z0, ::std::complex<double> const & z1 = ::std::complex<double>()); |
| explicit ``[link boost_quaternions.quaternions.mem_fun.constructors quaternion]``(quaternion<float> const & a_recopier); |
| explicit ``[link boost_quaternions.quaternions.mem_fun.constructors quaternion]``(quaternion<long double> const & a_recopier); |
| |
| double ``[link boost_quaternions.quaternions.mem_fun.real_and_unreal_parts real]``() const; |
| quaternion<double> ``[link boost_quaternions.quaternions.mem_fun.real_and_unreal_parts unreal]``() const; |
| double ``[link boost_quaternions.quaternions.mem_fun.individual_real_components R_component_1]``() const; |
| double ``[link boost_quaternions.quaternions.mem_fun.individual_real_components R_component_2]``() const; |
| double ``[link boost_quaternions.quaternions.mem_fun.individual_real_components R_component_3]``() const; |
| double ``[link boost_quaternions.quaternions.mem_fun.individual_real_components R_component_4]``() const; |
| ::std::complex<double> ``[link boost_quaternions.quaternions.mem_fun.individual_complex__components C_component_1]``() const; |
| ::std::complex<double> ``[link boost_quaternions.quaternions.mem_fun.individual_complex__components C_component_2]``() const; |
| |
| quaternion<double>& ``[link boost_quaternions.quaternions.mem_fun.assignment_operators operator = ]``(quaternion<double> const & a_affecter); |
| template<typename X> |
| quaternion<double>& ``[link boost_quaternions.quaternions.mem_fun.assignment_operators operator = ]``(quaternion<X> const & a_affecter); |
| quaternion<double>& ``[link boost_quaternions.quaternions.mem_fun.assignment_operators operator = ]``(double const & a_affecter); |
| quaternion<double>& ``[link boost_quaternions.quaternions.mem_fun.assignment_operators operator = ]``(::std::complex<double> const & a_affecter); |
| |
| quaternion<double>& ``[link boost_quaternions.quaternions.mem_fun.addition_operators operator += ]``(double const & rhs); |
| quaternion<double>& ``[link boost_quaternions.quaternions.mem_fun.addition_operators operator += ]``(::std::complex<double> const & rhs); |
| template<typename X> |
| quaternion<double>& ``[link boost_quaternions.quaternions.mem_fun.addition_operators operator += ]``(quaternion<X> const & rhs); |
| |
| quaternion<double>& ``[link boost_quaternions.quaternions.mem_fun.subtraction_operators operator -= ]``(double const & rhs); |
| quaternion<double>& ``[link boost_quaternions.quaternions.mem_fun.subtraction_operators operator -= ]``(::std::complex<double> const & rhs); |
| template<typename X> |
| quaternion<double>& ``[link boost_quaternions.quaternions.mem_fun.subtraction_operators operator -= ]``(quaternion<X> const & rhs); |
| |
| quaternion<double>& ``[link boost_quaternions.quaternions.mem_fun.multiplication_operators operator *= ]``(double const & rhs); |
| quaternion<double>& ``[link boost_quaternions.quaternions.mem_fun.multiplication_operators operator *= ]``(::std::complex<double> const & rhs); |
| template<typename X> |
| quaternion<double>& ``[link boost_quaternions.quaternions.mem_fun.multiplication_operators operator *= ]``(quaternion<X> const & rhs); |
| |
| quaternion<double>& ``[link boost_quaternions.quaternions.mem_fun.division_operators operator /= ]``(double const & rhs); |
| quaternion<double>& ``[link boost_quaternions.quaternions.mem_fun.division_operators operator /= ]``(::std::complex<double> const & rhs); |
| template<typename X> |
| quaternion<double>& ``[link boost_quaternions.quaternions.mem_fun.division_operators operator /= ]``(quaternion<X> const & rhs); |
| }; |
| |
| [#boost_quaternions.quaternion_long_double] |
| |
| template<> |
| class quaternion<long double> |
| { |
| public: |
| typedef long double ``[link boost_quaternions.quaternions.mem_typedef value_type]``; |
| |
| explicit ``[link boost_quaternions.quaternions.mem_fun.constructors quaternion]``(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); |
| explicit ``[link boost_quaternions.quaternions.mem_fun.constructors quaternion]``(::std::complex<long double> const & z0, ::std::complex<long double> const & z1 = ::std::complex<long double>()); |
| explicit ``[link boost_quaternions.quaternions.mem_fun.constructors quaternion]``(quaternion<float> const & a_recopier); |
| explicit ``[link boost_quaternions.quaternions.mem_fun.constructors quaternion]``(quaternion<double> const & a_recopier); |
| |
| long double ``[link boost_quaternions.quaternions.mem_fun.real_and_unreal_parts real]``() const; |
| quaternion<long double> ``[link boost_quaternions.quaternions.mem_fun.real_and_unreal_parts unreal]``() const; |
| long double ``[link boost_quaternions.quaternions.mem_fun.individual_real_components R_component_1]``() const; |
| long double ``[link boost_quaternions.quaternions.mem_fun.individual_real_components R_component_2]``() const; |
| long double ``[link boost_quaternions.quaternions.mem_fun.individual_real_components R_component_3]``() const; |
| long double ``[link boost_quaternions.quaternions.mem_fun.individual_real_components R_component_4]``() const; |
| ::std::complex<long double> ``[link boost_quaternions.quaternions.mem_fun.individual_complex__components C_component_1]``() const; |
| ::std::complex<long double> ``[link boost_quaternions.quaternions.mem_fun.individual_complex__components C_component_2]``() const; |
| |
| quaternion<long double>& ``[link boost_quaternions.quaternions.mem_fun.assignment_operators operator = ]``(quaternion<long double> const & a_affecter); |
| template<typename X> |
| quaternion<long double>& ``[link boost_quaternions.quaternions.mem_fun.assignment_operators operator = ]``(quaternion<X> const & a_affecter); |
| quaternion<long double>& ``[link boost_quaternions.quaternions.mem_fun.assignment_operators operator = ]``(long double const & a_affecter); |
| quaternion<long double>& ``[link boost_quaternions.quaternions.mem_fun.assignment_operators operator = ]``(::std::complex<long double> const & a_affecter); |
| |
| quaternion<long double>& ``[link boost_quaternions.quaternions.mem_fun.addition_operators operator += ]``(long double const & rhs); |
| quaternion<long double>& ``[link boost_quaternions.quaternions.mem_fun.addition_operators operator += ]``(::std::complex<long double> const & rhs); |
| template<typename X> |
| quaternion<long double>& ``[link boost_quaternions.quaternions.mem_fun.addition_operators operator += ]``(quaternion<X> const & rhs); |
| |
| quaternion<long double>& ``[link boost_quaternions.quaternions.mem_fun.subtraction_operators operator -= ]``(long double const & rhs); |
| quaternion<long double>& ``[link boost_quaternions.quaternions.mem_fun.subtraction_operators operator -= ]``(::std::complex<long double> const & rhs); |
| template<typename X> |
| quaternion<long double>& ``[link boost_quaternions.quaternions.mem_fun.subtraction_operators operator -= ]``(quaternion<X> const & rhs); |
| |
| quaternion<long double>& ``[link boost_quaternions.quaternions.mem_fun.multiplication_operators operator *= ]``(long double const & rhs); |
| quaternion<long double>& ``[link boost_quaternions.quaternions.mem_fun.multiplication_operators operator *= ]``(::std::complex<long double> const & rhs); |
| template<typename X> |
| quaternion<long double>& ``[link boost_quaternions.quaternions.mem_fun.multiplication_operators operator *= ]``(quaternion<X> const & rhs); |
| |
| quaternion<long double>& ``[link boost_quaternions.quaternions.mem_fun.division_operators operator /= ]``(long double const & rhs); |
| quaternion<long double>& ``[link boost_quaternions.quaternions.mem_fun.division_operators operator /= ]``(::std::complex<long double> const & rhs); |
| template<typename X> |
| quaternion<long double>& ``[link boost_quaternions.quaternions.mem_fun.division_operators operator /= ]``(quaternion<X> const & rhs); |
| }; |
| |
| } // namespace math |
| } // namespace boost |
| |
| [endsect] |
| |
| [section:mem_typedef Quaternion 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 acces to the type the template is built upon. |
| |
| [endsect] |
| |
| [section:mem_fun Quaternion Member Functions] |
| [h3 Constructors] |
| |
| Template version: |
| |
| explicit quaternion(T const & requested_a = T(), T const & requested_b = T(), T const & requested_c = T(), T const & requested_d = T()); |
| explicit quaternion(::std::complex<T> const & z0, ::std::complex<T> const & z1 = ::std::complex<T>()); |
| template<typename X> |
| explicit quaternion(quaternion<X> const & a_recopier); |
| |
| Float specialization version: |
| |
| explicit quaternion(float const & requested_a = 0.0f, float const & requested_b = 0.0f, float const & requested_c = 0.0f, float const & requested_d = 0.0f); |
| explicit quaternion(::std::complex<float> const & z0,::std::complex<float> const & z1 = ::std::complex<float>()); |
| explicit quaternion(quaternion<double> const & a_recopier); |
| explicit quaternion(quaternion<long double> const & a_recopier); |
| |
| Double specialization version: |
| |
| explicit quaternion(double const & requested_a = 0.0, double const & requested_b = 0.0, double const & requested_c = 0.0, double const & requested_d = 0.0); |
| explicit quaternion(::std::complex<double> const & z0, ::std::complex<double> const & z1 = ::std::complex<double>()); |
| explicit quaternion(quaternion<float> const & a_recopier); |
| explicit quaternion(quaternion<long double> const & a_recopier); |
| |
| Long double specialization version: |
| |
| explicit quaternion(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); |
| explicit quaternion( ::std::complex<long double> const & z0, ::std::complex<long double> const & z1 = ::std::complex<long double>()); |
| explicit quaternion(quaternion<float> const & a_recopier); |
| explicit quaternion(quaternion<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 four base type arguments. A constructor is also provided to |
| build quaternions from one or two complex numbers 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; |
| quaternion<T> unreal() const; |
| |
| Like complex number, quaternions 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 quaternion, |
| 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; |
| |
| A quaternion having four real components, these are returned by these four |
| 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; |
| |
| A quaternion likewise has two complex components, and as we have seen above, |
| for any quaternion __quat_formula we also have __quat_complex_formula. These functions return them. |
| The real part of `q.C_component_1()` is the same as `q.real()`. |
| |
| [h3 Quaternion Member Operators] |
| [h4 Assignment Operators] |
| |
| quaternion<T>& operator = (quaternion<T> const & a_affecter); |
| template<typename X> |
| quaternion<T>& operator = (quaternion<X> const& a_affecter); |
| quaternion<T>& operator = (T const& a_affecter); |
| quaternion<T>& operator = (::std::complex<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 Addition Operators] |
| |
| quaternion<T>& operator += (T const & rhs) |
| quaternion<T>& operator += (::std::complex<T> const & rhs); |
| template<typename X> |
| quaternion<T>& operator += (quaternion<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. |
| |
| [h4 Subtraction Operators] |
| |
| quaternion<T>& operator -= (T const & rhs) |
| quaternion<T>& operator -= (::std::complex<T> const & rhs); |
| template<typename X> |
| quaternion<T>& operator -= (quaternion<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. |
| |
| [h4 Multiplication Operators] |
| |
| quaternion<T>& operator *= (T const & rhs) |
| quaternion<T>& operator *= (::std::complex<T> const & rhs); |
| template<typename X> |
| quaternion<T>& operator *= (quaternion<X> const & rhs); |
| |
| These perform the mathematical operation `(*this)*rhs` [*in this order] |
| (order is important as multiplication is not commutative for quaternions) |
| 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. |
| |
| [h4 Division Operators] |
| |
| quaternion<T>& operator /= (T const & rhs) |
| quaternion<T>& operator /= (::std::complex<T> const & rhs); |
| template<typename X> |
| quaternion<T>& operator /= (quaternion<X> const & rhs); |
| |
| These perform the mathematical operation `(*this)*inverse_of(rhs)` [*in this |
| order] (order is important as multiplication is not commutative for quaternions) |
| 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. |
| |
| [endsect] |
| [section:non_mem Quaternion Non-Member Operators] |
| |
| [h4 Unary Plus] |
| |
| template<typename T> |
| quaternion<T> operator + (quaternion<T> const & q); |
| |
| This unary operator simply returns q. |
| |
| [h4 Unary Minus] |
| |
| template<typename T> |
| quaternion<T> operator - (quaternion<T> const & q); |
| |
| This unary operator returns the opposite of q. |
| |
| [h4 Binary Addition Operators] |
| |
| template<typename T> quaternion<T> operator + (T const & lhs, quaternion<T> const & rhs); |
| template<typename T> quaternion<T> operator + (quaternion<T> const & lhs, T const & rhs); |
| template<typename T> quaternion<T> operator + (::std::complex<T> const & lhs, quaternion<T> const & rhs); |
| template<typename T> quaternion<T> operator + (quaternion<T> const & lhs, ::std::complex<T> const & rhs); |
| template<typename T> quaternion<T> operator + (quaternion<T> const & lhs, quaternion<T> const & rhs); |
| |
| These operators return `quaternion<T>(lhs) += rhs`. |
| |
| [h4 Binary Subtraction Operators] |
| |
| template<typename T> quaternion<T> operator - (T const & lhs, quaternion<T> const & rhs); |
| template<typename T> quaternion<T> operator - (quaternion<T> const & lhs, T const & rhs); |
| template<typename T> quaternion<T> operator - (::std::complex<T> const & lhs, quaternion<T> const & rhs); |
| template<typename T> quaternion<T> operator - (quaternion<T> const & lhs, ::std::complex<T> const & rhs); |
| template<typename T> quaternion<T> operator - (quaternion<T> const & lhs, quaternion<T> const & rhs); |
| |
| These operators return `quaternion<T>(lhs) -= rhs`. |
| |
| [h4 Binary Multiplication Operators] |
| |
| template<typename T> quaternion<T> operator * (T const & lhs, quaternion<T> const & rhs); |
| template<typename T> quaternion<T> operator * (quaternion<T> const & lhs, T const & rhs); |
| template<typename T> quaternion<T> operator * (::std::complex<T> const & lhs, quaternion<T> const & rhs); |
| template<typename T> quaternion<T> operator * (quaternion<T> const & lhs, ::std::complex<T> const & rhs); |
| template<typename T> quaternion<T> operator * (quaternion<T> const & lhs, quaternion<T> const & rhs); |
| |
| These operators return `quaternion<T>(lhs) *= rhs`. |
| |
| [h4 Binary Division Operators] |
| |
| template<typename T> quaternion<T> operator / (T const & lhs, quaternion<T> const & rhs); |
| template<typename T> quaternion<T> operator / (quaternion<T> const & lhs, T const & rhs); |
| template<typename T> quaternion<T> operator / (::std::complex<T> const & lhs, quaternion<T> const & rhs); |
| template<typename T> quaternion<T> operator / (quaternion<T> const & lhs, ::std::complex<T> const & rhs); |
| template<typename T> quaternion<T> operator / (quaternion<T> const & lhs, quaternion<T> const & rhs); |
| |
| These operators return `quaternion<T>(lhs) /= rhs`. It is of course still an |
| error to divide by zero... |
| |
| [h4 Equality Operators] |
| |
| template<typename T> bool operator == (T const & lhs, quaternion<T> const & rhs); |
| template<typename T> bool operator == (quaternion<T> const & lhs, T const & rhs); |
| template<typename T> bool operator == (::std::complex<T> const & lhs, quaternion<T> const & rhs); |
| template<typename T> bool operator == (quaternion<T> const & lhs, ::std::complex<T> const & rhs); |
| template<typename T> bool operator == (quaternion<T> const & lhs, quaternion<T> const & rhs); |
| |
| These return true if and only if the four components of `quaternion<T>(lhs)` |
| are equal to their counterparts in `quaternion<T>(rhs)`. As with any |
| floating-type entity, this is essentially meaningless. |
| |
| [h4 Inequality Operators] |
| |
| template<typename T> bool operator != (T const & lhs, quaternion<T> const & rhs); |
| template<typename T> bool operator != (quaternion<T> const & lhs, T const & rhs); |
| template<typename T> bool operator != (::std::complex<T> const & lhs, quaternion<T> const & rhs); |
| template<typename T> bool operator != (quaternion<T> const & lhs, ::std::complex<T> const & rhs); |
| template<typename T> bool operator != (quaternion<T> const & lhs, quaternion<T> const & rhs); |
| |
| These return true if and only if `quaternion<T>(lhs) == quaternion<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, quaternion<T> & q); |
| |
| Extracts a quaternion q of one of the following forms |
| (with a, b, c and d of type `T`): |
| |
| [^a (a), (a,b), (a,b,c), (a,b,c,d) (a,(c)), (a,(c,d)), ((a)), ((a),c), ((a),(c)), ((a),(c,d)), ((a,b)), ((a,b),c), ((a,b),(c)), ((a,b),(c,d))] |
| |
| 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`. |
| |
| The rationale for the list of accepted formats is that either we have a |
| list of up to four reals, or else we have a couple of complex numbers, |
| and in that case if it formated as a proper complex number, then it should |
| be accepted. Thus potential ambiguities are lifted (for instance (a,b) is |
| (a,b,0,0) and not (a,0,b,0), i.e. it is parsed as a list of two real numbers |
| and not two complex numbers which happen to have imaginary parts equal to zero). |
| |
| [h4 Stream Inserter] |
| |
| template<typename T, typename charT, class traits> |
| ::std::basic_ostream<charT,traits>& operator << (::std::basic_ostream<charT,traits> & os, quaternion<T> const & q); |
| |
| Inserts the quaternion q 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, |
| quaternion<T> const & q) |
| { |
| ::std::basic_ostringstream<charT,traits> s; |
| |
| s.flags(os.flags()); |
| s.imbue(os.getloc()); |
| s.precision(os.precision()); |
| |
| s << '(' << q.R_component_1() << ',' |
| << q.R_component_2() << ',' |
| << q.R_component_3() << ',' |
| << q.R_component_4() << ')'; |
| |
| return os << s.str(); |
| } |
| |
| [endsect] |
| |
| [section:value_op Quaternion Value Operations] |
| |
| [h4 real and unreal] |
| |
| template<typename T> T real(quaternion<T> const & q); |
| template<typename T> quaternion<T> unreal(quaternion<T> const & q); |
| |
| These return `q.real()` and `q.unreal()` respectively. |
| |
| [h4 conj] |
| |
| template<typename T> quaternion<T> conj(quaternion<T> const & q); |
| |
| This returns the conjugate of the quaternion. |
| |
| [h4 sup] |
| |
| template<typename T> T sup(quaternion<T> const & q); |
| |
| This return the sup norm (the greatest among |
| `abs(q.R_component_1())...abs(q.R_component_4()))` of the quaternion. |
| |
| [h4 l1] |
| |
| template<typename T> T l1(quaternion<T> const & q); |
| |
| This return the l1 norm `(abs(q.R_component_1())+...+abs(q.R_component_4()))` |
| of the quaternion. |
| |
| [h4 abs] |
| |
| template<typename T> T abs(quaternion<T> const & q); |
| |
| This return the magnitude (Euclidian norm) of the quaternion. |
| |
| [h4 norm] |
| |
| template<typename T> T norm(quaternion<T>const & q); |
| |
| This return the (Cayley) norm of the quaternion. |
| 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) quaternions, the Euclidian norm |
| (also known as magnitude) is the square root of the Cayley norm. |
| |
| [endsect] |
| |
| [section:create Quaternion Creation Functions] |
| |
| template<typename T> quaternion<T> spherical(T const & rho, T const & theta, T const & phi1, T const & phi2); |
| template<typename T> quaternion<T> semipolar(T const & rho, T const & alpha, T const & theta1, T const & theta2); |
| template<typename T> quaternion<T> multipolar(T const & rho1, T const & theta1, T const & rho2, T const & theta2); |
| template<typename T> quaternion<T> cylindrospherical(T const & t, T const & radius, T const & longitude, T const & latitude); |
| template<typename T> quaternion<T> cylindrical(T const & r, T const & angle, T const & h1, T const & h2); |
| |
| These build quaternions in a way similar to the way polar builds complex |
| numbers, as there is no strict equivalent to polar coordinates for quaternions. |
| |
| [#boost_quaternions.quaternions.creation_spherical] `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. |
| |
| [#boost_quaternions.quaternions.creation_cylindrical] `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 quaternion. The third and fourth inputs |
| are placed into the third and fourth __R components of the quaternion, |
| respectively. |
| |
| [#boost_quaternions.quaternions.creation_multipolar] `multipolar` is yet another simple generalization of polar coordinates. |
| This time, both __C components of the quaternion are given in polar coordinates. |
| |
| [#boost_quaternions.quaternions.creation_cylindrospherical] `cylindrospherical` is specific to quaternions. It is often interesting to |
| consider __H as the cartesian product of __R by __R3 (the quaternionic |
| multiplication as then a special form, as given here). This function |
| therefore builds a quaternion from this representation, with the __R3 |
| component given in usual __R3 spherical coordinates. |
| |
| [#boost_quaternions.quaternions.creation_semipolar] `semipolar` is another generator which is specific to quaternions. |
| It takes as a first input the magnitude of the quaternion, as a |
| second input an angle in the range `0` to `+pi/2` such that magnitudes |
| of the first two __C components of the quaternion are the product of the |
| first input and the sine and cosine of this angle, respectively, and finally |
| as third and fourth inputs angles in the range `-pi/2` to `+pi/2` which |
| represent the arguments of the first and second __C components of |
| the quaternion, respectively. As usual, nothing untoward happens if |
| what should be magnitudes are negative numbers or angles are out of their |
| natural ranges, as symmetries and periodicities kick in. |
| |
| In this version of our implementation of quaternions, there is no |
| analogue of the complex value operation `arg` as the situation is |
| somewhat more complicated. Unit quaternions are linked both to |
| rotations in __R3 and in __R4, and the correspondences are not too complicated, |
| but there is currently a lack of standard (de facto or de jure) matrix |
| library with which the conversions could work. This should be remedied in |
| a further revision. In the mean time, an example of how this could be |
| done is presented here for |
| [@../../../quaternion/HSO3.hpp __R3], and here for |
| [@../../../quaternion/HSO4.hpp __R4] |
| ([@../../../quaternion/HSO3SO4.cpp example test file]). |
| |
| [endsect] |
| |
| [section:trans Quaternion Transcendentals] |
| |
| There is no `log` or `sqrt` provided for quaternions 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 quaternions ("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. This author claims the complete proof of the "closed formula" |
| as his own, as well as its independant invention (there are claims to prior |
| invention of the formula, such as one by Professor Shoemake, and it is |
| possible that the formula had been known a couple of centuries back, but in |
| absence of bibliographical reference, the matter is pending, awaiting further |
| investigation; on the other hand, the definition and existence of the |
| exponential on the quaternions, is of course a fact known for a very long time). |
| Basically, any converging power series with real coefficients which allows for a |
| closed formula in __C can be transposed to __H. 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> quaternion<T> exp(quaternion<T> const & q); |
| |
| Computes the exponential of the quaternion. |
| |
| [h4 cos] |
| |
| template<typename T> quaternion<T> cos(quaternion<T> const & q); |
| |
| Computes the cosine of the quaternion |
| |
| [h4 sin] |
| |
| template<typename T> quaternion<T> sin(quaternion<T> const & q); |
| |
| Computes the sine of the quaternion. |
| |
| [h4 tan] |
| |
| template<typename T> quaternion<T> tan(quaternion<T> const & q); |
| |
| Computes the tangent of the quaternion. |
| |
| [h4 cosh] |
| |
| template<typename T> quaternion<T> cosh(quaternion<T> const & q); |
| |
| Computes the hyperbolic cosine of the quaternion. |
| |
| [h4 sinh] |
| |
| template<typename T> quaternion<T> sinh(quaternion<T> const & q); |
| |
| Computes the hyperbolic sine of the quaternion. |
| |
| [h4 tanh] |
| |
| template<typename T> quaternion<T> tanh(quaternion<T> const & q); |
| |
| Computes the hyperbolic tangent of the quaternion. |
| |
| [h4 pow] |
| |
| template<typename T> quaternion<T> pow(quaternion<T> const & q, int n); |
| |
| Computes the n-th power of the quaternion q. |
| |
| [endsect] |
| |
| [section Test Program] |
| |
| The [@../../../quaternion/quaternion_test.cpp quaternion_test.cpp] |
| test program tests quaternions specializations for float, double and long double |
| ([@../../../quaternion/output.txt sample output], with message output |
| enabled). |
| |
| If you define the symbol boost_quaternions_TEST_VERBOSE, you will get |
| additional output ([@../../../quaternion/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:exp The Quaternionic Exponential] |
| |
| Please refer to the following PDF's: |
| |
| *[@../../../quaternion/TQE.pdf The Quaternionic Exponential (and beyond)] |
| *[@../../../quaternion/TQE_EA.pdf The Quaternionic Exponential (and beyond) ERRATA & ADDENDA] |
| |
| [endsect] |
| |
| [section 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 discution about this library. |
| |
| [endsect] |
| |
| [section History] |
| |
| * 1.5.8 - 17/12/2005: Converted documentation to Quickbook Format. |
| * 1.5.7 - 24/02/2003: transitionned to the unit test framework; <boost/config.hpp> now included by the library header (rather than the test files). |
| * 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 - 26/03/2001: boostification, inlining of all operators except input, output and pow, fixed exception safety of some members (template version) and output operator, added spherical, semipolar, multipolar, cylindrospherical and cylindrical. |
| * 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 To Do] |
| |
| * Improve testing. |
| * Rewrite input operatore using Spirit (creates a dependency). |
| * Put in place an Expression Template mechanism (perhaps borrowing from uBlas). |
| * Use uBlas for the link with rotations (and move from the |
| [@../../../quaternion/HSO3SO4.cpp example] |
| implementation to an efficient one). |
| |
| [endsect] |
| [endsect] |