|
|
Boost-Commit : |
Subject: [Boost-commit] svn:boost r84267 - sandbox/math/libs/math/doc/quaternion
From: pbristow_at_[hidden]
Date: 2013-05-13 06:38:27
Author: pbristow
Date: 2013-05-13 06:38:26 EDT (Mon, 13 May 2013)
New Revision: 84267
URL: http://svn.boost.org/trac/boost/changeset/84267
Log:
Added licence info.
Text files modified:
sandbox/math/libs/math/doc/quaternion/math-quaternion.qbk | 526 ++++++++++++++++++++-------------------
1 files changed, 269 insertions(+), 257 deletions(-)
Modified: sandbox/math/libs/math/doc/quaternion/math-quaternion.qbk
==============================================================================
--- sandbox/math/libs/math/doc/quaternion/math-quaternion.qbk (original)
+++ sandbox/math/libs/math/doc/quaternion/math-quaternion.qbk 2013-05-13 06:38:26 EDT (Mon, 13 May 2013)
@@ -15,44 +15,44 @@
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']]).
+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)
+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,
+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
+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]
+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
+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 Header File]
-The interface and implementation are both supplied by the header file
+The interface and implementation are both supplied by the header file
[@../../../../boost/math/quaternion.hpp quaternion.hpp].
[endsect]
@@ -60,11 +60,11 @@
[section:synopsis Synopsis]
namespace boost{ namespace math{
-
+
template<typename T> class ``[link math_toolkit.quat quaternion]``;
template<> class ``[link math_toolkit.spec quaternion<float>]``;
- template<> class ``[link math_quaternion_double quaternion<double>]``;
- template<> class ``[link math_quaternion_long_double quaternion<long double>]``;
+ template<> class ``[link math_quaternion_double quaternion<double>]``;
+ template<> class ``[link math_quaternion_long_double quaternion<long double>]``;
// operators
template<typename T> quaternion<T> ``[link math_toolkit.non_mem.binary_addition_operators operator +]`` (T const & lhs, quaternion<T> const & rhs);
@@ -89,10 +89,10 @@
template<typename T> quaternion<T> ``[link math_toolkit.non_mem.binary_division_operators operator /]`` (quaternion<T> const & lhs, T const & rhs);
template<typename T> quaternion<T> ``[link math_toolkit.non_mem.binary_division_operators operator /]`` (::std::complex<T> const & lhs, quaternion<T> const & rhs);
template<typename T> quaternion<T> ``[link math_toolkit.non_mem.binary_division_operators operator /]`` (quaternion<T> const & lhs, ::std::complex<T> const & rhs);
- template<typename T> quaternion<T> ``[link math_toolkit.non_mem.binary_division_operators operator /]`` (quaternion<T> const & lhs, quaternion<T> const & rhs);
+ template<typename T> quaternion<T> ``[link math_toolkit.non_mem.binary_division_operators operator /]`` (quaternion<T> const & lhs, quaternion<T> const & rhs);
template<typename T> quaternion<T> ``[link math_toolkit.non_mem.unary_plus operator +]`` (quaternion<T> const & q);
- template<typename T> quaternion<T> ``[link math_toolkit.non_mem.unary_minus operator -]`` (quaternion<T> const & q);
+ template<typename T> quaternion<T> ``[link math_toolkit.non_mem.unary_minus operator -]`` (quaternion<T> const & q);
template<typename T> bool ``[link math_toolkit.non_mem.equality_operators operator ==]`` (T const & lhs, quaternion<T> const & rhs);
template<typename T> bool ``[link math_toolkit.non_mem.equality_operators operator ==]`` (quaternion<T> const & lhs, T const & rhs);
@@ -104,7 +104,7 @@
template<typename T> bool ``[link math_toolkit.non_mem.inequality_operators operator !=]`` (quaternion<T> const & lhs, T const & rhs);
template<typename T> bool ``[link math_toolkit.non_mem.inequality_operators operator !=]`` (::std::complex<T> const & lhs, quaternion<T> const & rhs);
template<typename T> bool ``[link math_toolkit.non_mem.inequality_operators operator !=]`` (quaternion<T> const & lhs, ::std::complex<T> const & rhs);
- template<typename T> bool ``[link math_toolkit.non_mem.inequality_operators operator !=]`` (quaternion<T> const & lhs, quaternion<T> const & rhs);
+ template<typename T> bool ``[link math_toolkit.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 math_toolkit.non_mem.stream_extractor operator >>]`` (::std::basic_istream<charT,traits> & is, quaternion<T> & q);
@@ -113,40 +113,40 @@
::std::basic_ostream<charT,traits>& operator ``[link math_toolkit.non_mem.stream_inserter operator <<]`` (::std::basic_ostream<charT,traits> & os, quaternion<T> const & q);
// values
- template<typename T> T ``[link math_toolkit.value_op.real_and_unreal real]``(quaternion<T> const & q);
- template<typename T> quaternion<T> ``[link math_toolkit.value_op.real_and_unreal unreal]``(quaternion<T> const & q);
+ template<typename T> T ``[link math_toolkit.value_op.real_and_unreal real]``(quaternion<T> const & q);
+ template<typename T> quaternion<T> ``[link math_toolkit.value_op.real_and_unreal unreal]``(quaternion<T> const & q);
- template<typename T> T ``[link math_toolkit.value_op.sup sup]``(quaternion<T> const & q);
- template<typename T> T ``[link math_toolkit.value_op.l1 l1]``(quaternion<T> const & q);
- template<typename T> T ``[link math_toolkit.value_op.abs abs]``(quaternion<T> const & q);
- template<typename T> T ``[link math_toolkit.value_op.norm norm]``(quaternion<T>const & q);
- template<typename T> quaternion<T> ``[link math_toolkit.value_op.conj conj]``(quaternion<T> const & q);
-
- template<typename T> quaternion<T> ``[link math_quaternions.creation_spherical]``(T const & rho, T const & theta, T const & phi1, T const & phi2);
- template<typename T> quaternion<T> ``[link math_quaternions.creation_semipolar semipolar]``(T const & rho, T const & alpha, T const & theta1, T const & theta2);
- template<typename T> quaternion<T> ``[link math_quaternions.creation_multipolar multipolar]``(T const & rho1, T const & theta1, T const & rho2, T const & theta2);
- template<typename T> quaternion<T> ``[link math_quaternions.creation_cylindrospherical cylindrospherical]``(T const & t, T const & radius, T const & longitude, T const & latitude);
- template<typename T> quaternion<T> ``[link math_quaternions.creation_cylindrical cylindrical]``(T const & r, T const & angle, T const & h1, T const & h2);
+ template<typename T> T ``[link math_toolkit.value_op.sup sup]``(quaternion<T> const & q);
+ template<typename T> T ``[link math_toolkit.value_op.l1 l1]``(quaternion<T> const & q);
+ template<typename T> T ``[link math_toolkit.value_op.abs abs]``(quaternion<T> const & q);
+ template<typename T> T ``[link math_toolkit.value_op.norm norm]``(quaternion<T>const & q);
+ template<typename T> quaternion<T> ``[link math_toolkit.value_op.conj conj]``(quaternion<T> const & q);
+
+ template<typename T> quaternion<T> ``[link math_quaternions.creation_spherical]``(T const & rho, T const & theta, T const & phi1, T const & phi2);
+ template<typename T> quaternion<T> ``[link math_quaternions.creation_semipolar semipolar]``(T const & rho, T const & alpha, T const & theta1, T const & theta2);
+ template<typename T> quaternion<T> ``[link math_quaternions.creation_multipolar multipolar]``(T const & rho1, T const & theta1, T const & rho2, T const & theta2);
+ template<typename T> quaternion<T> ``[link math_quaternions.creation_cylindrospherical cylindrospherical]``(T const & t, T const & radius, T const & longitude, T const & latitude);
+ template<typename T> quaternion<T> ``[link math_quaternions.creation_cylindrical cylindrical]``(T const & r, T const & angle, T const & h1, T const & h2);
// transcendentals
- template<typename T> quaternion<T> ``[link math_toolkit.trans.exp exp]``(quaternion<T> const & q);
- template<typename T> quaternion<T> ``[link math_toolkit.trans.cos cos]``(quaternion<T> const & q);
- template<typename T> quaternion<T> ``[link math_toolkit.trans.sin sin]``(quaternion<T> const & q);
- template<typename T> quaternion<T> ``[link math_toolkit.trans.tan tan]``(quaternion<T> const & q);
- template<typename T> quaternion<T> ``[link math_toolkit.trans.cosh cosh]``(quaternion<T> const & q);
- template<typename T> quaternion<T> ``[link math_toolkit.trans.sinh sinh]``(quaternion<T> const & q);
- template<typename T> quaternion<T> ``[link math_toolkit.trans.tanh tanh]``(quaternion<T> const & q);
- template<typename T> quaternion<T> ``[link math_toolkit.trans.pow pow]``(quaternion<T> const & q, int n);
+ template<typename T> quaternion<T> ``[link math_toolkit.trans.exp exp]``(quaternion<T> const & q);
+ template<typename T> quaternion<T> ``[link math_toolkit.trans.cos cos]``(quaternion<T> const & q);
+ template<typename T> quaternion<T> ``[link math_toolkit.trans.sin sin]``(quaternion<T> const & q);
+ template<typename T> quaternion<T> ``[link math_toolkit.trans.tan tan]``(quaternion<T> const & q);
+ template<typename T> quaternion<T> ``[link math_toolkit.trans.cosh cosh]``(quaternion<T> const & q);
+ template<typename T> quaternion<T> ``[link math_toolkit.trans.sinh sinh]``(quaternion<T> const & q);
+ template<typename T> quaternion<T> ``[link math_toolkit.trans.tanh tanh]``(quaternion<T> const & q);
+ template<typename T> quaternion<T> ``[link math_toolkit.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
{
@@ -156,7 +156,7 @@
explicit ``[link math_toolkit.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 math_toolkit.mem_fun.constructors quaternion]``(::std::complex<T> const & z0, ::std::complex<T> const & z1 = ::std::complex<T>());
- template<typename X>
+ template<typename X>
explicit ``[link math_toolkit.mem_fun.constructors quaternion]``(quaternion<X> const & a_recopier);
T ``[link math_toolkit.mem_fun.real_and_unreal_parts real]``() const;
@@ -169,7 +169,7 @@
::std::complex<T> ``[link math_toolkit.mem_fun.individual_complex_components C_component_2]``() const;
quaternion<T>& ``[link math_toolkit.mem_fun.assignment_operators operator = ]``(quaternion<T> const & a_affecter);
- template<typename X>
+ template<typename X>
quaternion<T>& ``[link math_toolkit.mem_fun.assignment_operators operator = ]``(quaternion<X> const & a_affecter);
quaternion<T>& ``[link math_toolkit.mem_fun.assignment_operators operator = ]``(T const & a_affecter);
quaternion<T>& ``[link math_toolkit.mem_fun.assignment_operators operator = ]``(::std::complex<T> const & a_affecter);
@@ -197,7 +197,7 @@
} // namespace math
} // namespace boost
-
+
[endsect]
[section:spec Quaternion Specializations]
@@ -209,12 +209,12 @@
{
public:
typedef float ``[link math_toolkit.mem_typedef value_type]``;
-
+
explicit ``[link math_toolkit.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 math_toolkit.mem_fun.constructors quaternion]``(::std::complex<float> const & z0, ::std::complex<float> const & z1 = ::std::complex<float>());
explicit ``[link math_toolkit.mem_fun.constructors quaternion]``(quaternion<double> const & a_recopier);
explicit ``[link math_toolkit.mem_fun.constructors quaternion]``(quaternion<long double> const & a_recopier);
-
+
float ``[link math_toolkit.mem_fun.real_and_unreal_parts real]``() const;
quaternion<float> ``[link math_toolkit.mem_fun.real_and_unreal_parts unreal]``() const;
float ``[link math_toolkit.mem_fun.individual_real_components R_component_1]``() const;
@@ -225,7 +225,7 @@
::std::complex<float> ``[link math_toolkit.mem_fun.individual_complex_components C_component_2]``() const;
quaternion<float>& ``[link math_toolkit.mem_fun.assignment_operators operator = ]``(quaternion<float> const & a_affecter);
- template<typename X>
+ template<typename X>
quaternion<float>& ``[link math_toolkit.mem_fun.assignment_operators operator = ]``(quaternion<X> const & a_affecter);
quaternion<float>& ``[link math_toolkit.mem_fun.assignment_operators operator = ]``(float const & a_affecter);
quaternion<float>& ``[link math_toolkit.mem_fun.assignment_operators operator = ]``(::std::complex<float> const & a_affecter);
@@ -250,7 +250,7 @@
template<typename X>
quaternion<float>& ``[link math_toolkit.mem_fun.division_operators operator /= ]``(quaternion<X> const & rhs);
};
-
+
[#math_quaternion_double]
template<>
@@ -258,12 +258,12 @@
{
public:
typedef double ``[link math_toolkit.mem_typedef value_type]``;
-
+
explicit ``[link math_toolkit.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 math_toolkit.mem_fun.constructors quaternion]``(::std::complex<double> const & z0, ::std::complex<double> const & z1 = ::std::complex<double>());
explicit ``[link math_toolkit.mem_fun.constructors quaternion]``(quaternion<float> const & a_recopier);
explicit ``[link math_toolkit.mem_fun.constructors quaternion]``(quaternion<long double> const & a_recopier);
-
+
double ``[link math_toolkit.mem_fun.real_and_unreal_parts real]``() const;
quaternion<double> ``[link math_toolkit.mem_fun.real_and_unreal_parts unreal]``() const;
double ``[link math_toolkit.mem_fun.individual_real_components R_component_1]``() const;
@@ -274,7 +274,7 @@
::std::complex<double> ``[link math_toolkit.mem_fun.individual_complex_components C_component_2]``() const;
quaternion<double>& ``[link math_toolkit.mem_fun.assignment_operators operator = ]``(quaternion<double> const & a_affecter);
- template<typename X>
+ template<typename X>
quaternion<double>& ``[link math_toolkit.mem_fun.assignment_operators operator = ]``(quaternion<X> const & a_affecter);
quaternion<double>& ``[link math_toolkit.mem_fun.assignment_operators operator = ]``(double const & a_affecter);
quaternion<double>& ``[link math_toolkit.mem_fun.assignment_operators operator = ]``(::std::complex<double> const & a_affecter);
@@ -307,12 +307,12 @@
{
public:
typedef long double ``[link math_toolkit.mem_typedef value_type]``;
-
+
explicit ``[link math_toolkit.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 math_toolkit.mem_fun.constructors quaternion]``(::std::complex<long double> const & z0, ::std::complex<long double> const & z1 = ::std::complex<long double>());
explicit ``[link math_toolkit.mem_fun.constructors quaternion]``(quaternion<float> const & a_recopier);
explicit ``[link math_toolkit.mem_fun.constructors quaternion]``(quaternion<double> const & a_recopier);
-
+
long double ``[link math_toolkit.mem_fun.real_and_unreal_parts real]``() const;
quaternion<long double> ``[link math_toolkit.mem_fun.real_and_unreal_parts unreal]``() const;
long double ``[link math_toolkit.mem_fun.individual_real_components R_component_1]``() const;
@@ -323,7 +323,7 @@
::std::complex<long double> ``[link math_toolkit.mem_fun.individual_complex_components C_component_2]``() const;
quaternion<long double>& ``[link math_toolkit.mem_fun.assignment_operators operator = ]``(quaternion<long double> const & a_affecter);
- template<typename X>
+ template<typename X>
quaternion<long double>& ``[link math_toolkit.mem_fun.assignment_operators operator = ]``(quaternion<X> const & a_affecter);
quaternion<long double>& ``[link math_toolkit.mem_fun.assignment_operators operator = ]``(long double const & a_affecter);
quaternion<long double>& ``[link math_toolkit.mem_fun.assignment_operators operator = ]``(::std::complex<long double> const & a_affecter);
@@ -351,7 +351,7 @@
} // namespace math
} // namespace boost
-
+
[endsect]
[section:mem_typedef Quaternion Member Typedefs]
@@ -392,7 +392,7 @@
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<double> const & a_recopier);
explicit quaternion(quaternion<long double> const & a_recopier);
Double specialization version:
@@ -405,23 +405,23 @@
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( ::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
+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
+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]
@@ -430,10 +430,10 @@
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).
+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]
@@ -443,81 +443,81 @@
T R_component_3() const;
T R_component_4() const;
-A quaternion having four real components, these are returned by these four
+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;
+ ::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.
+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>
+ 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,
+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>
+ 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,
+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>
+ 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
+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>
+ 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.
+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>
+ 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.
+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]
@@ -525,7 +525,7 @@
[h4 Unary Plus]
- template<typename T>
+ template<typename T>
quaternion<T> operator + (quaternion<T> const & q);
This unary operator simply returns q.
@@ -539,66 +539,66 @@
[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);
+ 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);
+ 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);
+ 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);
+ 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
+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);
+ 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
+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);
+ 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
+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]
@@ -606,21 +606,21 @@
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
+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,
+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
+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]
@@ -631,11 +631,11 @@
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>& operator << (
::std::basic_ostream<charT,traits> & os,
quaternion<T> const & q)
{
- ::std::basic_ostringstream<charT,traits> s;
+ ::std::basic_ostringstream<charT,traits> s;
s.flags(os.flags());
s.imbue(os.getloc());
@@ -648,189 +648,189 @@
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);
+ 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);
+ 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);
+template<typename T> T sup(quaternion<T> const & q);
-This return the sup norm (the greatest among
+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);
+ 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);
+ 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);
+ 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
+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);
+ 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
+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.
-[#math_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
+[#math_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.
-[#math_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,
+[#math_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.
-[#math_quaternions.creation_multipolar] `multipolar` is yet another simple generalization of polar coordinates.
+[#math_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.
-[#math_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
+[#math_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.
-[#math_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
+[#math_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]
+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
+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
+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);
+ 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);
+ 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);
+ 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);
+ 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);
+ 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);
+ 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);
+ 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);
+ template<typename T> quaternion<T> pow(quaternion<T> const & q, int n);
Computes the n-th power of the quaternion q.
@@ -838,19 +838,19 @@
[section:tests 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
+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 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
+If you define the symbol 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]
@@ -866,16 +866,17 @@
[section:acknowledgement 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.
+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 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 - 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_at_[hidden]).
@@ -890,7 +891,7 @@
* 1.3.0 - 12/07/2000: pow now uses Maarten Hilferink's (mhilferink_at_[hidden]) 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.
+* 1.0.0 - 10/08/1999: first public version.
[endsect]
[section:todo To Do]
@@ -898,9 +899,20 @@
* 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).
-
+* Use uBlas for the link with rotations (and move from the
+[@../../quaternion/HSO3SO4.cpp example]
+implementation to an efficient one).
+
[endsect]
[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).
+]
+
+
+
+
Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk