Context Navigation

math-octonion.qbk @ 35

Last change on this file since 35 was 29, checked in by landauf, 17 years ago
updated boost from 1_33_1 to 1_34_1
File size: 67.0 KB

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

Note: See TracBrowser for help on using the repository browser.

Download in other formats:

Original Format