|
|
Boost-Commit : |
Subject: [Boost-commit] svn:boost r84268 - sandbox/math/libs/math/doc/octonion
From: pbristow_at_[hidden]
Date: 2013-05-13 06:41:14
Author: pbristow
Date: 2013-05-13 06:41:13 EDT (Mon, 13 May 2013)
New Revision: 84268
URL: http://svn.boost.org/trac/boost/changeset/84268
Log:
Added licence info.
Text files modified:
sandbox/math/libs/math/doc/octonion/math-octonion.qbk | 359 ++++++++++++++++++++-------------------
1 files changed, 184 insertions(+), 175 deletions(-)
Modified: sandbox/math/libs/math/doc/octonion/math-octonion.qbk
==============================================================================
--- sandbox/math/libs/math/doc/octonion/math-octonion.qbk (original)
+++ sandbox/math/libs/math/doc/octonion/math-octonion.qbk 2013-05-13 06:41:13 EDT (Mon, 13 May 2013)
@@ -19,34 +19,34 @@
Octonions see some use in theoretical physics.
-In practical terms, an octonion is simply an octuple of real numbers __octulple,
-which we can write in the form __oct_formula, where ['[^i]], ['[^j]] and ['[^k]]
-are the same objects as for quaternions, and ['[^e']], ['[^i']], ['[^j']] and ['[^k']]
+In practical terms, an octonion is simply an octuple of real numbers __octulple,
+which we can write in the form __oct_formula, where ['[^i]], ['[^j]] and ['[^k]]
+are the same objects as for quaternions, and ['[^e']], ['[^i']], ['[^j']] and ['[^k']]
are distinct objects which play essentially the same kind of role as ['[^i]] (or ['[^j]] or ['[^k]]).
-Addition and a multiplication is defined on the set of octonions,
-which generalize their quaternionic counterparts. The main novelty this time
-is that [*the multiplication is not only not commutative, is now not even
-associative] (i.e. there are octonions ['[^x]], ['[^y]] and ['[^z]] such that __oct_not_equal).
+Addition and a multiplication is defined on the set of octonions,
+which generalize their quaternionic counterparts. The main novelty this time
+is that [*the multiplication is not only not commutative, is now not even
+associative] (i.e. there are octonions ['[^x]], ['[^y]] and ['[^z]] such that __oct_not_equal).
A way of remembering things is by using the following multiplication table:
[$../../../octonion/graphics/octonion_blurb17.jpeg]
-Octonions (and their kin) are described in far more details in this other
-[@../../quaternion/TQE.pdf document]
+Octonions (and their kin) are described in far more details in this other
+[@../../quaternion/TQE.pdf document]
(with [@../../quaternion/TQE_EA.pdf errata and addenda]).
-Some traditional constructs, such as the exponential, carry over without too
-much change into the realms of octonions, but other, such as taking a square root,
-do not (the fact that the exponential has a closed form is a result of the
-author, but the fact that the exponential exists at all for octonions is known
+Some traditional constructs, such as the exponential, carry over without too
+much change into the realms of octonions, but other, such as taking a square root,
+do not (the fact that the exponential has a closed form is a result of the
+author, but the fact that the exponential exists at all for octonions is known
since quite a long time ago).
[endsect]
[section: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/octonion.hpp octonion.hpp].
[endsect]
@@ -57,8 +57,8 @@
template<typename T> class ``[link math_toolkit.octonion octonion]``;
template<> class ``[link math_toolkit.oct_specialization octonion<float>]``;
- template<> class ``[link math_octonion_double octonion<double>]``;
- template<> class ``[link math_octonion_long_double octonion<long double>]``;
+ template<> class ``[link math_octonion_double octonion<double>]``;
+ template<> class ``[link math_octonion_long_double octonion<long double>]``;
// operators
@@ -92,10 +92,10 @@
template<typename T> octonion<T> ``[link math_toolkit.non_mem0.binary_division_operators operator /]`` (octonion<T> const & lhs, ::std::complex<T> const & rhs);
template<typename T> octonion<T> ``[link math_toolkit.non_mem0.binary_division_operators operator /]`` (::boost::math::quaternion<T> const & lhs, octonion<T> const & rhs);
template<typename T> octonion<T> ``[link math_toolkit.non_mem0.binary_division_operators operator /]`` (octonion<T> const & lhs, ::boost::math::quaternion<T> const & rhs);
- template<typename T> octonion<T> ``[link math_toolkit.non_mem0.binary_division_operators operator /]`` (octonion<T> const & lhs, octonion<T> const & rhs);
+ template<typename T> octonion<T> ``[link math_toolkit.non_mem0.binary_division_operators operator /]`` (octonion<T> const & lhs, octonion<T> const & rhs);
template<typename T> octonion<T> ``[link math_toolkit.non_mem0.unary_plus_and_minus_operators operator +]`` (octonion<T> const & o);
- template<typename T> octonion<T> ``[link math_toolkit.non_mem0.unary_plus_and_minus_operators operator -]`` (octonion<T> const & o);
+ template<typename T> octonion<T> ``[link math_toolkit.non_mem0.unary_plus_and_minus_operators operator -]`` (octonion<T> const & o);
template<typename T> bool ``[link math_toolkit.non_mem0.binary_equality_operators operator ==]`` (T const & lhs, octonion<T> const & rhs);
template<typename T> bool ``[link math_toolkit.non_mem0.binary_equality_operators operator ==]`` (octonion<T> const & lhs, T const & rhs);
@@ -111,7 +111,7 @@
template<typename T> bool ``[link math_toolkit.non_mem0.binary_inequality_operators operator !=]`` (octonion<T> const & lhs, ::std::complex<T> const & rhs);
template<typename T> bool ``[link math_toolkit.non_mem0.binary_inequality_operators operator !=]`` (::boost::math::quaternion<T> const & lhs, octonion<T> const & rhs);
template<typename T> bool ``[link math_toolkit.non_mem0.binary_inequality_operators operator !=]`` (octonion<T> const & lhs, ::boost::math::quaternion<T> const & rhs);
- template<typename T> bool ``[link math_toolkit.non_mem0.binary_inequality_operators operator !=]`` (octonion<T> const & lhs, octonion<T> const & rhs);
+ template<typename T> bool ``[link math_toolkit.non_mem0.binary_inequality_operators operator !=]`` (octonion<T> const & lhs, octonion<T> const & rhs);
template<typename T, typename charT, class traits>
::std::basic_istream<charT,traits> & ``[link math_toolkit.non_mem0.stream_extractor operator >>]`` (::std::basic_istream<charT,traits> & is, octonion<T> & o);
@@ -125,7 +125,7 @@
template<typename T> octonion<T> ``[link math_toolkit.oct_value_ops.real_and_unreal unreal]``(octonion<T> const & o);
template<typename T> T ``[link math_toolkit.oct_value_ops.sup sup]``(octonion<T> const & o);
- template<typename T> T ``[link math_toolkit.oct_value_ops.l1 l1]``(octonion<T>const & o);
+ template<typename T> T ``[link math_toolkit.oct_value_ops.l1 l1]``(octonion<T>const & o);
template<typename T> T ``[link math_toolkit.oct_value_ops.abs abs]``(octonion<T> const & o);
template<typename T> T ``[link math_toolkit.oct_value_ops.norm norm]``(octonion<T>const & o);
template<typename T> octonion<T> ``[link math_toolkit.oct_value_ops.conj conj]``(octonion<T> const & o);
@@ -147,13 +147,13 @@
template<typename T> octonion<T> ``[link math_toolkit.oct_trans.pow pow]``(octonion<T> const & o, int n);
} } // namespaces
-
+
[endsect]
[section:octonion Template Class octonion]
namespace boost{ namespace math {
-
+
template<typename T>
class octonion
{
@@ -163,7 +163,7 @@
explicit ``[link math_toolkit.mem_fun0.constructors octonion]``(T const & requested_a = T(), T const & requested_b = T(), T const & requested_c = T(), T const & requested_d = T(), T const & requested_e = T(), T const & requested_f = T(), T const & requested_g = T(), T const & requested_h = T());
explicit ``[link math_toolkit.mem_fun0.constructors octonion]``(::std::complex<T> const & z0, ::std::complex<T> const & z1 = ::std::complex<T>(), ::std::complex<T> const & z2 = ::std::complex<T>(), ::std::complex<T> const & z3 = ::std::complex<T>());
explicit ``[link math_toolkit.mem_fun0.constructors octonion]``(::boost::math::quaternion<T> const & q0, ::boost::math::quaternion<T> const & q1 = ::boost::math::quaternion<T>());
- template<typename X>
+ template<typename X>
explicit ``[link math_toolkit.mem_fun0.constructors octonion]``(octonion<X> const & a_recopier);
T ``[link math_toolkit.mem_fun0.real_and_unreal_parts real]``() const;
@@ -187,7 +187,7 @@
::boost::math::quaternion<T> ``[link math_toolkit.mem_fun0.individual_quaternion_components H_component_2]``() const;
octonion<T> & ``[link math_toolkit.mem_fun0.assignment_operators operator =]`` (octonion<T> const & a_affecter);
- template<typename X>
+ template<typename X>
octonion<T> & ``[link math_toolkit.mem_fun0.assignment_operators operator =]`` (octonion<X> const & a_affecter);
octonion<T> & ``[link math_toolkit.mem_fun0.assignment_operators operator =]`` (T const & a_affecter);
octonion<T> & ``[link math_toolkit.mem_fun0.assignment_operators operator =]`` (::std::complex<T> const & a_affecter);
@@ -196,36 +196,36 @@
octonion<T> & ``[link math_toolkit.mem_fun0.other_member_operators operator +=]`` (T const & rhs);
octonion<T> & ``[link math_toolkit.mem_fun0.other_member_operators operator +=]`` (::std::complex<T> const & rhs);
octonion<T> & ``[link math_toolkit.mem_fun0.other_member_operators operator +=]`` (::boost::math::quaternion<T> const & rhs);
- template<typename X>
+ template<typename X>
octonion<T> & ``[link math_toolkit.mem_fun0.other_member_operators operator +=]`` (octonion<X> const & rhs);
octonion<T> & ``[link math_toolkit.mem_fun0.other_member_operators operator -=]`` (T const & rhs);
octonion<T> & ``[link math_toolkit.mem_fun0.other_member_operators operator -=]`` (::std::complex<T> const & rhs);
octonion<T> & ``[link math_toolkit.mem_fun0.other_member_operators operator -=]`` (::boost::math::quaternion<T> const & rhs);
- template<typename X>
+ template<typename X>
octonion<T> & ``[link math_toolkit.mem_fun0.other_member_operators operator -=]`` (octonion<X> const & rhs);
octonion<T> & ``[link math_toolkit.mem_fun0.other_member_operators operator *=]`` (T const & rhs);
octonion<T> & ``[link math_toolkit.mem_fun0.other_member_operators operator *=]`` (::std::complex<T> const & rhs);
octonion<T> & ``[link math_toolkit.mem_fun0.other_member_operators operator *=]`` (::boost::math::quaternion<T> const & rhs);
- template<typename X>
+ template<typename X>
octonion<T> & ``[link math_toolkit.mem_fun0.other_member_operators operator *=]`` (octonion<X> const & rhs);
octonion<T> & ``[link math_toolkit.mem_fun0.other_member_operators operator /=]`` (T const & rhs);
octonion<T> & ``[link math_toolkit.mem_fun0.other_member_operators operator /=]`` (::std::complex<T> const & rhs);
octonion<T> & ``[link math_toolkit.mem_fun0.other_member_operators operator /=]`` (::boost::math::quaternion<T> const & rhs);
- template<typename X>
+ template<typename X>
octonion<T> & ``[link math_toolkit.mem_fun0.other_member_operators operator /=]`` (octonion<X> const & rhs);
};
} } // namespaces
-
+
[endsect]
[section:oct_specialization Octonion Specializations]
namespace boost{ namespace math{
-
+
template<>
class octonion<float>
{
@@ -259,7 +259,7 @@
::boost::math::quaternion<float> ``[link math_toolkit.mem_fun0.individual_quaternion_components H_component_2]``() const;
octonion<float> & ``[link math_toolkit.mem_fun0.assignment_operators operator =]`` (octonion<float> const & a_affecter);
- template<typename X>
+ template<typename X>
octonion<float> & ``[link math_toolkit.mem_fun0.assignment_operators operator =]`` (octonion<X> const & a_affecter);
octonion<float> & ``[link math_toolkit.mem_fun0.assignment_operators operator =]`` (float const & a_affecter);
octonion<float> & ``[link math_toolkit.mem_fun0.assignment_operators operator =]`` (::std::complex<float> const & a_affecter);
@@ -268,25 +268,25 @@
octonion<float> & ``[link math_toolkit.mem_fun0.other_member_operators operator +=]`` (float const & rhs);
octonion<float> & ``[link math_toolkit.mem_fun0.other_member_operators operator +=]`` (::std::complex<float> const & rhs);
octonion<float> & ``[link math_toolkit.mem_fun0.other_member_operators operator +=]`` (::boost::math::quaternion<float> const & rhs);
- template<typename X>
+ template<typename X>
octonion<float> & ``[link math_toolkit.mem_fun0.other_member_operators operator +=]`` (octonion<X> const & rhs);
octonion<float> & ``[link math_toolkit.mem_fun0.other_member_operators operator -=]`` (float const & rhs);
octonion<float> & ``[link math_toolkit.mem_fun0.other_member_operators operator -=]`` (::std::complex<float> const & rhs);
octonion<float> & ``[link math_toolkit.mem_fun0.other_member_operators operator -=]`` (::boost::math::quaternion<float> const & rhs);
- template<typename X>
+ template<typename X>
octonion<float> & ``[link math_toolkit.mem_fun0.other_member_operators operator -=]`` (octonion<X> const & rhs);
octonion<float> & ``[link math_toolkit.mem_fun0.other_member_operators operator *=]`` (float const & rhs);
octonion<float> & ``[link math_toolkit.mem_fun0.other_member_operators operator *=]`` (::std::complex<float> const & rhs);
octonion<float> & ``[link math_toolkit.mem_fun0.other_member_operators operator *=]`` (::boost::math::quaternion<float> const & rhs);
- template<typename X>
+ template<typename X>
octonion<float> & ``[link math_toolkit.mem_fun0.other_member_operators operator *=]`` (octonion<X> const & rhs);
octonion<float> & ``[link math_toolkit.mem_fun0.other_member_operators operator /=]`` (float const & rhs);
octonion<float> & ``[link math_toolkit.mem_fun0.other_member_operators operator /=]`` (::std::complex<float> const & rhs);
octonion<float> & ``[link math_toolkit.mem_fun0.other_member_operators operator /=]`` (::boost::math::quaternion<float> const & rhs);
- template<typename X>
+ template<typename X>
octonion<float> & ``[link math_toolkit.mem_fun0.other_member_operators operator /=]`` (octonion<X> const & rhs);
};
@@ -325,7 +325,7 @@
::boost::math::quaternion<double> ``[link math_toolkit.mem_fun0.individual_quaternion_components H_component_2]``() const;
octonion<double> & ``[link math_toolkit.mem_fun0.assignment_operators operator =]`` (octonion<double> const & a_affecter);
- template<typename X>
+ template<typename X>
octonion<double> & ``[link math_toolkit.mem_fun0.assignment_operators operator =]`` (octonion<X> const & a_affecter);
octonion<double> & ``[link math_toolkit.mem_fun0.assignment_operators operator =]`` (double const & a_affecter);
octonion<double> & ``[link math_toolkit.mem_fun0.assignment_operators operator =]`` (::std::complex<double> const & a_affecter);
@@ -334,25 +334,25 @@
octonion<double> & ``[link math_toolkit.mem_fun0.other_member_operators operator +=]`` (double const & rhs);
octonion<double> & ``[link math_toolkit.mem_fun0.other_member_operators operator +=]`` (::std::complex<double> const & rhs);
octonion<double> & ``[link math_toolkit.mem_fun0.other_member_operators operator +=]`` (::boost::math::quaternion<double> const & rhs);
- template<typename X>
+ template<typename X>
octonion<double> & ``[link math_toolkit.mem_fun0.other_member_operators operator +=]`` (octonion<X> const & rhs);
octonion<double> & ``[link math_toolkit.mem_fun0.other_member_operators operator -=]`` (double const & rhs);
octonion<double> & ``[link math_toolkit.mem_fun0.other_member_operators operator -=]`` (::std::complex<double> const & rhs);
octonion<double> & ``[link math_toolkit.mem_fun0.other_member_operators operator -=]`` (::boost::math::quaternion<double> const & rhs);
- template<typename X>
+ template<typename X>
octonion<double> & ``[link math_toolkit.mem_fun0.other_member_operators operator -=]`` (octonion<X> const & rhs);
octonion<double> & ``[link math_toolkit.mem_fun0.other_member_operators operator *=]`` (double const & rhs);
octonion<double> & ``[link math_toolkit.mem_fun0.other_member_operators operator *=]`` (::std::complex<double> const & rhs);
octonion<double> & ``[link math_toolkit.mem_fun0.other_member_operators operator *=]`` (::boost::math::quaternion<double> const & rhs);
- template<typename X>
+ template<typename X>
octonion<double> & ``[link math_toolkit.mem_fun0.other_member_operators operator *=]`` (octonion<X> const & rhs);
octonion<double> & ``[link math_toolkit.mem_fun0.other_member_operators operator /=]`` (double const & rhs);
octonion<double> & ``[link math_toolkit.mem_fun0.other_member_operators operator /=]`` (::std::complex<double> const & rhs);
octonion<double> & ``[link math_toolkit.mem_fun0.other_member_operators operator /=]`` (::boost::math::quaternion<double> const & rhs);
- template<typename X>
+ template<typename X>
octonion<double> & ``[link math_toolkit.mem_fun0.other_member_operators operator /=]`` (octonion<X> const & rhs);
};
@@ -391,7 +391,7 @@
::boost::math::quaternion<long double> ``[link math_toolkit.mem_fun0.individual_quaternion_components H_component_2]``() const;
octonion<long double> & ``[link math_toolkit.mem_fun0.assignment_operators operator =]`` (octonion<long double> const & a_affecter);
- template<typename X>
+ template<typename X>
octonion<long double> & ``[link math_toolkit.mem_fun0.assignment_operators operator =]`` (octonion<X> const & a_affecter);
octonion<long double> & ``[link math_toolkit.mem_fun0.assignment_operators operator =]`` (long double const & a_affecter);
octonion<long double> & ``[link math_toolkit.mem_fun0.assignment_operators operator =]`` (::std::complex<long double> const & a_affecter);
@@ -400,30 +400,30 @@
octonion<long double> & ``[link math_toolkit.mem_fun0.other_member_operators operator +=]`` (long double const & rhs);
octonion<long double> & ``[link math_toolkit.mem_fun0.other_member_operators operator +=]`` (::std::complex<long double> const & rhs);
octonion<long double> & ``[link math_toolkit.mem_fun0.other_member_operators operator +=]`` (::boost::math::quaternion<long double> const & rhs);
- template<typename X>
+ template<typename X>
octonion<long double> & ``[link math_toolkit.mem_fun0.other_member_operators operator +=]`` (octonion<X> const & rhs);
octonion<long double> & ``[link math_toolkit.mem_fun0.other_member_operators operator -=]`` (long double const & rhs);
octonion<long double> & ``[link math_toolkit.mem_fun0.other_member_operators operator -=]`` (::std::complex<long double> const & rhs);
octonion<long double> & ``[link math_toolkit.mem_fun0.other_member_operators operator -=]`` (::boost::math::quaternion<long double> const & rhs);
- template<typename X>
+ template<typename X>
octonion<long double> & ``[link math_toolkit.mem_fun0.other_member_operators operator -=]`` (octonion<X> const & rhs);
octonion<long double> & ``[link math_toolkit.mem_fun0.other_member_operators operator *=]`` (long double const & rhs);
octonion<long double> & ``[link math_toolkit.mem_fun0.other_member_operators operator *=]`` (::std::complex<long double> const & rhs);
octonion<long double> & ``[link math_toolkit.mem_fun0.other_member_operators operator *=]`` (::boost::math::quaternion<long double> const & rhs);
- template<typename X>
+ template<typename X>
octonion<long double> & ``[link math_toolkit.mem_fun0.other_member_operators operator *=]`` (octonion<X> const & rhs);
octonion<long double> & ``[link math_toolkit.mem_fun0.other_member_operators operator /=]`` (long double const & rhs);
octonion<long double> & ``[link math_toolkit.mem_fun0.other_member_operators operator /=]`` (::std::complex<long double> const & rhs);
octonion<long double> & ``[link math_toolkit.mem_fun0.other_member_operators operator /=]`` (::boost::math::quaternion<long double> const & rhs);
- template<typename X>
+ template<typename X>
octonion<long double> & ``[link math_toolkit.mem_fun0.other_member_operators operator /=]`` (octonion<X> const & rhs);
};
} } // namespaces
-
+
[endsect]
[section:oct_typedefs Octonion Member Typedefs]
@@ -437,7 +437,7 @@
Float specialization version:
typedef float value_type;
-
+
Double specialization version:
typedef double value_type;
@@ -459,7 +459,7 @@
explicit octonion(T const & requested_a = T(), T const & requested_b = T(), T const & requested_c = T(), T const & requested_d = T(), T const & requested_e = T(), T const & requested_f = T(), T const & requested_g = T(), T const & requested_h = T());
explicit octonion(::std::complex<T> const & z0, ::std::complex<T> const & z1 = ::std::complex<T>(), ::std::complex<T> const & z2 = ::std::complex<T>(), ::std::complex<T> const & z3 = ::std::complex<T>());
explicit octonion(::boost::math::quaternion<T> const & q0, ::boost::math::quaternion<T> const & q1 = ::boost::math::quaternion<T>());
- template<typename X>
+ template<typename X>
explicit octonion(octonion<X> const & a_recopier);
Float specialization version:
@@ -467,7 +467,7 @@
explicit octonion(float const & requested_a = 0.0f, float const & requested_b = 0.0f, float const & requested_c = 0.0f, float const & requested_d = 0.0f, float const & requested_e = 0.0f, float const & requested_f = 0.0f, float const & requested_g = 0.0f, float const & requested_h = 0.0f);
explicit octonion(::std::complex<float> const & z0, ::std::complex<float> const & z1 = ::std::complex<float>(), ::std::complex<float> const & z2 = ::std::complex<float>(), ::std::complex<float> const & z3 = ::std::complex<float>());
explicit octonion(::boost::math::quaternion<float> const & q0, ::boost::math::quaternion<float> const & q1 = ::boost::math::quaternion<float>());
- explicit octonion(octonion<double> const & a_recopier);
+ explicit octonion(octonion<double> const & a_recopier);
explicit octonion(octonion<long double> const & a_recopier);
Double specialization version:
@@ -486,19 +486,19 @@
explicit octonion(octonion<float> const & a_recopier);
explicit octonion(octonion<double> const & a_recopier);
-A default constructor is provided for each form, which initializes each component
-to the default values for their type (i.e. zero for floating numbers).
-This constructor can also accept one to eight base type arguments.
-A constructor is also provided to build octonions from one to four complex numbers
+A default constructor is provided for each form, which initializes each component
+to the default values for their type (i.e. zero for floating numbers).
+This constructor can also accept one to eight base type arguments.
+A constructor is also provided to build octonions from one to four complex numbers
sharing the same base type, and another taking one or two quaternions
-sharing the same base type. The unspecialized template also sports a
-templarized copy constructor, while the specialized forms have copy
-constructors from the other two specializations, which are explicit
-when a risk of precision loss exists. For the unspecialized form,
+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
+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]
@@ -508,10 +508,10 @@
T real() const;
octonion<T> unreal() const;
-Like complex number, octonions do have a meaningful notion of "real part",
-but unlike them there is no meaningful notion of "imaginary part".
-Instead there is an "unreal part" which itself is a octonion,
-and usually nothing simpler (as opposed to the complex number case).
+Like complex number, octonions do have a meaningful notion of "real part",
+but unlike them there is no meaningful notion of "imaginary part".
+Instead there is an "unreal part" which itself is a octonion,
+and usually nothing simpler (as opposed to the complex number case).
These are returned by the first two functions.
[h4 Individual Real Components]
@@ -525,7 +525,7 @@
T R_component_7() const;
T R_component_8() const;
-A octonion having eight real components, these are returned by
+A octonion having eight real components, these are returned by
these eight functions. Hence real and R_component_1 return the same value.
[h4 Individual Complex Components]
@@ -535,12 +535,12 @@
::std::complex<T> C_component_3() const;
::std::complex<T> C_component_4() const;
-A octonion likewise has four complex components. Actually, octonions
-are indeed a (left) vector field over the complexes, but beware, as
-for any octonion __oct_formula we also have __oct_complex_formula
-(note the [*minus] sign in the last factor).
-What the C_component_n functions return, however, are the complexes
-which could be used to build the octonion using the constructor, and
+A octonion likewise has four complex components. Actually, octonions
+are indeed a (left) vector field over the complexes, but beware, as
+for any octonion __oct_formula we also have __oct_complex_formula
+(note the [*minus] sign in the last factor).
+What the C_component_n functions return, however, are the complexes
+which could be used to build the octonion using the constructor, and
[*not] the components of the octonion on the basis ['[^(1, j, e', j')]].
[h4 Individual Quaternion Components]
@@ -548,24 +548,24 @@
::boost::math::quaternion<T> H_component_1() const;
::boost::math::quaternion<T> H_component_2() const;
-Likewise, for any octonion __oct_formula we also have __oct_quat_formula, though there
-is no meaningful vector-space-like structure based on the quaternions.
-What the H_component_n functions return are the quaternions which
+Likewise, for any octonion __oct_formula we also have __oct_quat_formula, though there
+is no meaningful vector-space-like structure based on the quaternions.
+What the H_component_n functions return are the quaternions which
could be used to build the octonion using the constructor.
[h3 Octonion Member Operators]
[h4 Assignment Operators]
octonion<T> & operator = (octonion<T> const & a_affecter);
- template<typename X>
+ template<typename X>
octonion<T> & operator = (octonion<X> const & a_affecter);
octonion<T> & operator = (T const & a_affecter);
octonion<T> & operator = (::std::complex<T> const & a_affecter);
octonion<T> & operator = (::boost::math::quaternion<T> const & a_affecter);
-These perform the expected assignment, with type modification if
-necessary (for instance, assigning from a base type will set the
-real part to that value, and all other components to zero).
+These perform the expected assignment, with type modification if
+necessary (for instance, assigning from a base type will set the
+real part to that value, and all other components to zero).
For the unspecialized form, the base type's assignment operators must not throw.
[h4 Other Member Operators]
@@ -573,53 +573,53 @@
octonion<T> & operator += (T const & rhs)
octonion<T> & operator += (::std::complex<T> const & rhs);
octonion<T> & operator += (::boost::math::quaternion<T> const & rhs);
- template<typename X>
+ template<typename X>
octonion<T> & operator += (octonion<X> const & rhs);
-These perform the mathematical operation `(*this)+rhs` and store the result in
-`*this`. The unspecialized form has exception guards, which the specialized
-forms do not, so as to insure exception safety. For the unspecialized form,
+These perform the mathematical operation `(*this)+rhs` and store the result in
+`*this`. The unspecialized form has exception guards, which the specialized
+forms do not, so as to insure exception safety. For the unspecialized form,
the base type's assignment operators must not throw.
octonion<T> & operator -= (T const & rhs)
octonion<T> & operator -= (::std::complex<T> const & rhs);
octonion<T> & operator -= (::boost::math::quaternion<T> const & rhs);
- template<typename X>
+ template<typename X>
octonion<T> & operator -= (octonion<X> const & rhs);
-These perform the mathematical operation `(*this)-rhs` and store the result
-in `*this`. The unspecialized form has exception guards, which the
-specialized forms do not, so as to insure exception safety.
+These perform the mathematical operation `(*this)-rhs` and store the result
+in `*this`. The unspecialized form has exception guards, which the
+specialized forms do not, so as to insure exception safety.
For the unspecialized form, the base type's assignment operators must not throw.
octonion<T> & operator *= (T const & rhs)
octonion<T> & operator *= (::std::complex<T> const & rhs);
octonion<T> & operator *= (::boost::math::quaternion<T> const & rhs);
- template<typename X>
+ template<typename X>
octonion<T> & operator *= (octonion<X> const & rhs);
-These perform the mathematical operation `(*this)*rhs` in this order
-(order is important as multiplication is not commutative for octonions)
-and store the result in `*this`. The unspecialized form has exception guards,
-which the specialized forms do not, so as to insure exception safety.
-For the unspecialized form, the base type's assignment operators must
-not throw. Also, for clarity's sake, you should always group the
-factors in a multiplication by groups of two, as the multiplication is
-not even associative on the octonions (though there are of course cases
+These perform the mathematical operation `(*this)*rhs` in this order
+(order is important as multiplication is not commutative for octonions)
+and store the result in `*this`. The unspecialized form has exception guards,
+which the specialized forms do not, so as to insure exception safety.
+For the unspecialized form, the base type's assignment operators must
+not throw. Also, for clarity's sake, you should always group the
+factors in a multiplication by groups of two, as the multiplication is
+not even associative on the octonions (though there are of course cases
where this does not matter, it usually does).
octonion<T> & operator /= (T const & rhs)
octonion<T> & operator /= (::std::complex<T> const & rhs);
octonion<T> & operator /= (::boost::math::quaternion<T> const & rhs);
- template<typename X>
+ template<typename X>
octonion<T> & operator /= (octonion<X> const & rhs);
-These perform the mathematical operation `(*this)*inverse_of(rhs)`
-in this order (order is important as multiplication is not commutative
-for octonions) and store the result in `*this`. The unspecialized form
-has exception guards, which the specialized forms do not, so as to
-insure exception safety. For the unspecialized form, the base
-type's assignment operators must not throw. As for the multiplication,
+These perform the mathematical operation `(*this)*inverse_of(rhs)`
+in this order (order is important as multiplication is not commutative
+for octonions) and store the result in `*this`. The unspecialized form
+has exception guards, which the specialized forms do not, so as to
+insure exception safety. For the unspecialized form, the base
+type's assignment operators must not throw. As for the multiplication,
remember to group any two factors using parenthesis.
[endsect]
@@ -682,7 +682,7 @@
template<typename T> octonion<T> operator / (octonion<T> const & lhs, ::boost::math::quaternion<T> const & rhs);
template<typename T> octonion<T> operator / (octonion<T> const & lhs, octonion<T> const & rhs);
-These operators return `octonion<T>(lhs) /= rhs`. It is of course still an
+These operators return `octonion<T>(lhs) /= rhs`. It is of course still an
error to divide by zero...
[h4 Binary Equality Operators]
@@ -695,8 +695,8 @@
template<typename T> bool operator == (octonion<T> const & lhs, ::boost::math::quaternion<T> const & rhs);
template<typename T> bool operator == (octonion<T> const & lhs, octonion<T> const & rhs);
-These return true if and only if the four components of `octonion<T>(lhs)`
-are equal to their counterparts in `octonion<T>(rhs)`. As with any
+These return true if and only if the four components of `octonion<T>(lhs)`
+are equal to their counterparts in `octonion<T>(rhs)`. As with any
floating-type entity, this is essentially meaningless.
[h4 Binary Inequality Operators]
@@ -709,7 +709,7 @@
template<typename T> bool operator != (octonion<T> const & lhs, ::boost::math::quaternion<T> const & rhs);
template<typename T> bool operator != (octonion<T> const & lhs, octonion<T> const & rhs);
-These return true if and only if `octonion<T>(lhs) == octonion<T>(rhs)`
+These return true if and only if `octonion<T>(lhs) == octonion<T>(rhs)`
is false. As with any floating-type entity, this is essentially meaningless.
[h4 Stream Extractor]
@@ -717,11 +717,11 @@
template<typename T, typename charT, class traits>
::std::basic_istream<charT,traits> & operator >> (::std::basic_istream<charT,traits> & is, octonion<T> & o);
-Extracts an octonion `o`. We accept any format which seems reasonable.
-However, since this leads to a great many ambiguities, decisions were made
+Extracts an octonion `o`. We accept any format which seems reasonable.
+However, since this leads to a great many ambiguities, decisions were made
to lift these. In case of doubt, stick to lists of reals.
-The input values must be convertible to T. If bad input is encountered,
+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`.
@@ -754,7 +754,7 @@
return os << s.str();
}
-
+
[endsect]
[section:oct_value_ops Octonion Value Operations]
@@ -776,14 +776,14 @@
template<typename T> T sup(octonion<T> const & o);
-This return the sup norm (the greatest among
+This return the sup norm (the greatest among
`abs(o.R_component_1())...abs(o.R_component_8()))` of the octonion.
[h4 l1]
template<typename T> T l1(octonion<T> const & o);
-This return the l1 norm (`abs(o.R_component_1())+...+abs(o.R_component_8())`)
+This return the l1 norm (`abs(o.R_component_1())+...+abs(o.R_component_8())`)
of the octonion.
[h4 abs]
@@ -796,10 +796,10 @@
template<typename T> T norm(octonion<T>const & o);
-This return the (Cayley) norm of the octonion. The term "norm" might
-be confusing, as most people associate it with the Euclidian norm
-(and quadratic functionals). For this version of (the mathematical
-objects known as) octonions, the Euclidian norm (also known as
+This return the (Cayley) norm of the octonion. The term "norm" might
+be confusing, as most people associate it with the Euclidian norm
+(and quadratic functionals). For this version of (the mathematical
+objects known as) octonions, the Euclidian norm (also known as
magnitude) is the square root of the Cayley norm.
[endsect]
@@ -810,114 +810,114 @@
template<typename T> octonion<T> multipolar(T const & rho1, T const & theta1, T const & rho2, T const & theta2, T const & rho3, T const & theta3, T const & rho4, T const & theta4);
template<typename T> octonion<T> cylindrical(T const & r, T const & angle, T const & h1, T const & h2, T const & h3, T const & h4, T const & h5, T const & h6);
-These build octonions in a way similar to the way polar builds
-complex numbers, as there is no strict equivalent to
+These build octonions in a way similar to the way polar builds
+complex numbers, as there is no strict equivalent to
polar coordinates for octonions.
-`spherical` is a simple transposition of `polar`, it takes as inputs a
-(positive) magnitude and a point on the hypersphere, given
-by three angles. The first of these, ['theta] has a natural range of
--pi to +pi, and the other two have natural ranges of
--pi/2 to +pi/2 (as is the case with the usual spherical
-coordinates in __R3). Due to the many symmetries and periodicities,
-nothing untoward happens if the magnitude is negative or the angles are
-outside their natural ranges. The expected degeneracies (a magnitude of
+`spherical` is a simple transposition of `polar`, it takes as inputs a
+(positive) magnitude and a point on the hypersphere, given
+by three angles. The first of these, ['theta] has a natural range of
+-pi to +pi, and the other two have natural ranges of
+-pi/2 to +pi/2 (as is the case with the usual spherical
+coordinates in __R3). Due to the many symmetries and periodicities,
+nothing untoward happens if the magnitude is negative or the angles are
+outside their natural ranges. The expected degeneracies (a magnitude of
zero ignores the angles settings...) do happen however.
-`cylindrical` is likewise a simple transposition of the usual
-cylindrical coordinates in __R3, which in turn is another derivative of
-planar polar coordinates. The first two inputs are the polar
-coordinates of the first __C component of the octonion. The third and
-fourth inputs are placed into the third and fourth __R components of the
+`cylindrical` is likewise a simple transposition of the usual
+cylindrical coordinates in __R3, which in turn is another derivative of
+planar polar coordinates. The first two inputs are the polar
+coordinates of the first __C component of the octonion. The third and
+fourth inputs are placed into the third and fourth __R components of the
octonion, respectively.
-`multipolar` is yet another simple generalization of polar coordinates.
+`multipolar` is yet another simple generalization of polar coordinates.
This time, both __C components of the octonion are given in polar coordinates.
-In this version of our implementation of octonions, there is no
-analogue of the complex value operation arg as the situation is
+In this version of our implementation of octonions, there is no
+analogue of the complex value operation arg as the situation is
somewhat more complicated.
[endsect]
[section:oct_trans Octonions Transcendentals]
-There is no `log` or `sqrt` provided for octonions in this implementation,
-and `pow` is likewise restricted to integral powers of the exponent.
-There are several reasons to this: on the one hand, the equivalent of
-analytic continuation for octonions ("branch cuts") remains to be
-investigated thoroughly (by me, at any rate...), and we wish to avoid
-the nonsense introduced in the standard by exponentiations of
-complexes by complexes (which is well defined, but not in the standard...).
-Talking of nonsense, saying that `pow(0,0)` is "implementation defined" is
+There is no `log` or `sqrt` provided for octonions in this implementation,
+and `pow` is likewise restricted to integral powers of the exponent.
+There are several reasons to this: on the one hand, the equivalent of
+analytic continuation for octonions ("branch cuts") remains to be
+investigated thoroughly (by me, at any rate...), and we wish to avoid
+the nonsense introduced in the standard by exponentiations of
+complexes by complexes (which is well defined, but not in the standard...).
+Talking of nonsense, saying that `pow(0,0)` is "implementation defined" is
just plain brain-dead...
-We do, however provide several transcendentals, chief among which is
-the exponential. That it allows for a "closed formula" is a result
-of the author (the existence and definition of the exponential, on the
-octonions among others, on the other hand, is a few centuries old).
-Basically, any converging power series with real coefficients which
-allows for a closed formula in __C can be transposed to __O. More
-transcendentals of this type could be added in a further revision upon
-request. It should be noted that it is these functions which force the
-dependency upon the
+We do, however provide several transcendentals, chief among which is
+the exponential. That it allows for a "closed formula" is a result
+of the author (the existence and definition of the exponential, on the
+octonions among others, on the other hand, is a few centuries old).
+Basically, any converging power series with real coefficients which
+allows for a closed formula in __C can be transposed to __O. More
+transcendentals of this type could be added in a further revision upon
+request. It should be noted that it is these functions which force the
+dependency upon the
[@../../../../boost/math/special_functions/sinc.hpp boost/math/special_functions/sinc.hpp]
-and the
-[@../../../../boost/math/special_functions/sinhc.hpp boost/math/special_functions/sinhc.hpp]
+and the
+[@../../../../boost/math/special_functions/sinhc.hpp boost/math/special_functions/sinhc.hpp]
headers.
[h4 exp]
- template<typename T>
+ template<typename T>
octonion<T> exp(octonion<T> const & o);
Computes the exponential of the octonion.
[h4 cos]
- template<typename T>
+ template<typename T>
octonion<T> cos(octonion<T> const & o);
Computes the cosine of the octonion
[h4 sin]
- template<typename T>
+ template<typename T>
octonion<T> sin(octonion<T> const & o);
Computes the sine of the octonion.
[h4 tan]
- template<typename T>
+ template<typename T>
octonion<T> tan(octonion<T> const & o);
Computes the tangent of the octonion.
[h4 cosh]
- template<typename T>
+ template<typename T>
octonion<T> cosh(octonion<T> const & o);
Computes the hyperbolic cosine of the octonion.
[h4 sinh]
- template<typename T>
+ template<typename T>
octonion<T> sinh(octonion<T> const & o);
Computes the hyperbolic sine of the octonion.
[h4 tanh]
- template<typename T>
+ template<typename T>
octonion<T> tanh(octonion<T> const & o);
Computes the hyperbolic tangent of the octonion.
[h4 pow]
- template<typename T>
+ template<typename T>
octonion<T> pow(octonion<T> const & o, int n);
Computes the n-th power of the octonion q.
@@ -926,33 +926,34 @@
[section:tests Test Program]
-The [@../../octonion/octonion_test.cpp octonion_test.cpp]
-test program tests octonions specialisations for float, double and long double
+The [@../../octonion/octonion_test.cpp octonion_test.cpp]
+test program tests octonions specialisations for float, double and long double
([@../../octonion/output.txt sample output]).
-If you define the symbol BOOST_OCTONION_TEST_VERBOSE, you will get additional
-output ([@../../octonion/output_more.txt verbose output]); this will
-only be helpfull if you enable message output at the same time, of course
-(by uncommenting the relevant line in the test or by adding --log_level=messages
-to your command line,...). In that case, and if you are running interactively,
-you may in addition define the symbol BOOST_INTERACTIVE_TEST_INPUT_ITERATOR to
-interactively test the input operator with input of your choice from the
+If you define the symbol BOOST_OCTONION_TEST_VERBOSE, you will get additional
+output ([@../../octonion/output_more.txt verbose output]); this will
+only be helpfull if you enable message output at the same time, of course
+(by uncommenting the relevant line in the test or by adding --log_level=messages
+to your command line,...). In that case, and if you are running interactively,
+you may in addition define the symbol BOOST_INTERACTIVE_TEST_INPUT_ITERATOR to
+interactively test the input operator with input of your choice from the
standard input (instead of hard-coding it in the test).
[endsect]
[section:acknowledgements Acknowledgements]
-The mathematical text has been typeset with
-[@http://www.nisus-soft.com/ Nisus Writer].
-Jens Maurer has helped with portability and standard adherence, and was the
-Review Manager for this library. More acknowledgements in the
+The mathematical text has been typeset with
+[@http://www.nisus-soft.com/ Nisus Writer].
+Jens Maurer has helped with portability and standard adherence, and was the
+Review Manager for this library. More acknowledgements in the
History section. Thank you to all who contributed to the discussion about this library.
[endsect]
[section:history History]
+* 1.5.9 - 13/5/2013: Incorporated into Boost.Math.
* 1.5.8 - 17/12/2005: Converted documentation to Quickbook Format.
* 1.5.7 - 25/02/2003: transitionned to the unit test framework; <boost/config.hpp> now included by the library header (rather than the test files), via <boost/math/quaternion.hpp>.
* 1.5.6 - 15/10/2002: Gcc2.95.x and stlport on linux compatibility by Alkis Evlogimenos (alkis_at_[hidden]).
@@ -967,7 +968,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]
@@ -975,8 +976,16 @@
* Improve testing.
* Rewrite input operatore using Spirit (creates a dependency).
-* Put in place an Expression Template mechanism (perhaps borrowing from uBlas).
+* Put in place an Expression Template mechanism (perhaps borrowing from uBlas).
[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