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