|
1 // boost octonion.hpp header file |
|
2 |
|
3 // (C) Copyright Hubert Holin 2001. |
|
4 // Distributed under the Boost Software License, Version 1.0. (See |
|
5 // accompanying file LICENSE_1_0.txt or copy at |
|
6 // http://www.boost.org/LICENSE_1_0.txt) |
|
7 |
|
8 // See http://www.boost.org for updates, documentation, and revision history. |
|
9 |
|
10 |
|
11 #ifndef BOOST_OCTONION_HPP |
|
12 #define BOOST_OCTONION_HPP |
|
13 |
|
14 #include <boost/math/quaternion.hpp> |
|
15 |
|
16 |
|
17 namespace boost |
|
18 { |
|
19 namespace math |
|
20 { |
|
21 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
22 // gcc 2.95.x uses expression templates for valarray calculations, but |
|
23 // the result is not conforming. We need BOOST_GET_VALARRAY to get an |
|
24 // actual valarray result when we need to call a member function |
|
25 #define BOOST_GET_VALARRAY(T,x) ::std::valarray<T>(x) |
|
26 // gcc 2.95.x has an "std::ios" class that is similar to |
|
27 // "std::ios_base", so we just use a #define |
|
28 #define BOOST_IOS_BASE ::std::ios |
|
29 // gcc 2.x ignores function scope using declarations, |
|
30 // put them in the scope of the enclosing namespace instead: |
|
31 using ::std::valarray; |
|
32 using ::std::sqrt; |
|
33 using ::std::cos; |
|
34 using ::std::sin; |
|
35 using ::std::exp; |
|
36 using ::std::cosh; |
|
37 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
38 |
|
39 #define BOOST_OCTONION_ACCESSOR_GENERATOR(type) \ |
|
40 type real() const \ |
|
41 { \ |
|
42 return(a); \ |
|
43 } \ |
|
44 \ |
|
45 octonion<type> unreal() const \ |
|
46 { \ |
|
47 return( octonion<type>(static_cast<type>(0),b,c,d,e,f,g,h)); \ |
|
48 } \ |
|
49 \ |
|
50 type R_component_1() const \ |
|
51 { \ |
|
52 return(a); \ |
|
53 } \ |
|
54 \ |
|
55 type R_component_2() const \ |
|
56 { \ |
|
57 return(b); \ |
|
58 } \ |
|
59 \ |
|
60 type R_component_3() const \ |
|
61 { \ |
|
62 return(c); \ |
|
63 } \ |
|
64 \ |
|
65 type R_component_4() const \ |
|
66 { \ |
|
67 return(d); \ |
|
68 } \ |
|
69 \ |
|
70 type R_component_5() const \ |
|
71 { \ |
|
72 return(e); \ |
|
73 } \ |
|
74 \ |
|
75 type R_component_6() const \ |
|
76 { \ |
|
77 return(f); \ |
|
78 } \ |
|
79 \ |
|
80 type R_component_7() const \ |
|
81 { \ |
|
82 return(g); \ |
|
83 } \ |
|
84 \ |
|
85 type R_component_8() const \ |
|
86 { \ |
|
87 return(h); \ |
|
88 } \ |
|
89 \ |
|
90 ::std::complex<type> C_component_1() const \ |
|
91 { \ |
|
92 return(::std::complex<type>(a,b)); \ |
|
93 } \ |
|
94 \ |
|
95 ::std::complex<type> C_component_2() const \ |
|
96 { \ |
|
97 return(::std::complex<type>(c,d)); \ |
|
98 } \ |
|
99 \ |
|
100 ::std::complex<type> C_component_3() const \ |
|
101 { \ |
|
102 return(::std::complex<type>(e,f)); \ |
|
103 } \ |
|
104 \ |
|
105 ::std::complex<type> C_component_4() const \ |
|
106 { \ |
|
107 return(::std::complex<type>(g,h)); \ |
|
108 } \ |
|
109 \ |
|
110 ::boost::math::quaternion<type> H_component_1() const \ |
|
111 { \ |
|
112 return(::boost::math::quaternion<type>(a,b,c,d)); \ |
|
113 } \ |
|
114 \ |
|
115 ::boost::math::quaternion<type> H_component_2() const \ |
|
116 { \ |
|
117 return(::boost::math::quaternion<type>(e,f,g,h)); \ |
|
118 } |
|
119 |
|
120 |
|
121 #define BOOST_OCTONION_MEMBER_ASSIGNMENT_GENERATOR(type) \ |
|
122 template<typename X> \ |
|
123 octonion<type> & operator = (octonion<X> const & a_affecter) \ |
|
124 { \ |
|
125 a = static_cast<type>(a_affecter.R_component_1()); \ |
|
126 b = static_cast<type>(a_affecter.R_component_2()); \ |
|
127 c = static_cast<type>(a_affecter.R_component_3()); \ |
|
128 d = static_cast<type>(a_affecter.R_component_4()); \ |
|
129 e = static_cast<type>(a_affecter.R_component_5()); \ |
|
130 f = static_cast<type>(a_affecter.R_component_6()); \ |
|
131 g = static_cast<type>(a_affecter.R_component_7()); \ |
|
132 h = static_cast<type>(a_affecter.R_component_8()); \ |
|
133 \ |
|
134 return(*this); \ |
|
135 } \ |
|
136 \ |
|
137 octonion<type> & operator = (octonion<type> const & a_affecter) \ |
|
138 { \ |
|
139 a = a_affecter.a; \ |
|
140 b = a_affecter.b; \ |
|
141 c = a_affecter.c; \ |
|
142 d = a_affecter.d; \ |
|
143 e = a_affecter.e; \ |
|
144 f = a_affecter.f; \ |
|
145 g = a_affecter.g; \ |
|
146 h = a_affecter.h; \ |
|
147 \ |
|
148 return(*this); \ |
|
149 } \ |
|
150 \ |
|
151 octonion<type> & operator = (type const & a_affecter) \ |
|
152 { \ |
|
153 a = a_affecter; \ |
|
154 \ |
|
155 b = c = d = e = f= g = h = static_cast<type>(0); \ |
|
156 \ |
|
157 return(*this); \ |
|
158 } \ |
|
159 \ |
|
160 octonion<type> & operator = (::std::complex<type> const & a_affecter) \ |
|
161 { \ |
|
162 a = a_affecter.real(); \ |
|
163 b = a_affecter.imag(); \ |
|
164 \ |
|
165 c = d = e = f = g = h = static_cast<type>(0); \ |
|
166 \ |
|
167 return(*this); \ |
|
168 } \ |
|
169 \ |
|
170 octonion<type> & operator = (::boost::math::quaternion<type> const & a_affecter) \ |
|
171 { \ |
|
172 a = a_affecter.R_component_1(); \ |
|
173 b = a_affecter.R_component_2(); \ |
|
174 c = a_affecter.R_component_3(); \ |
|
175 d = a_affecter.R_component_4(); \ |
|
176 \ |
|
177 e = f = g = h = static_cast<type>(0); \ |
|
178 \ |
|
179 return(*this); \ |
|
180 } |
|
181 |
|
182 |
|
183 #define BOOST_OCTONION_MEMBER_DATA_GENERATOR(type) \ |
|
184 type a; \ |
|
185 type b; \ |
|
186 type c; \ |
|
187 type d; \ |
|
188 type e; \ |
|
189 type f; \ |
|
190 type g; \ |
|
191 type h; \ |
|
192 |
|
193 |
|
194 template<typename T> |
|
195 class octonion |
|
196 { |
|
197 public: |
|
198 |
|
199 typedef T value_type; |
|
200 |
|
201 // constructor for O seen as R^8 |
|
202 // (also default constructor) |
|
203 |
|
204 explicit octonion( T const & requested_a = T(), |
|
205 T const & requested_b = T(), |
|
206 T const & requested_c = T(), |
|
207 T const & requested_d = T(), |
|
208 T const & requested_e = T(), |
|
209 T const & requested_f = T(), |
|
210 T const & requested_g = T(), |
|
211 T const & requested_h = T()) |
|
212 : a(requested_a), |
|
213 b(requested_b), |
|
214 c(requested_c), |
|
215 d(requested_d), |
|
216 e(requested_e), |
|
217 f(requested_f), |
|
218 g(requested_g), |
|
219 h(requested_h) |
|
220 { |
|
221 // nothing to do! |
|
222 } |
|
223 |
|
224 |
|
225 // constructor for H seen as C^4 |
|
226 |
|
227 explicit octonion( ::std::complex<T> const & z0, |
|
228 ::std::complex<T> const & z1 = ::std::complex<T>(), |
|
229 ::std::complex<T> const & z2 = ::std::complex<T>(), |
|
230 ::std::complex<T> const & z3 = ::std::complex<T>()) |
|
231 : a(z0.real()), |
|
232 b(z0.imag()), |
|
233 c(z1.real()), |
|
234 d(z1.imag()), |
|
235 e(z2.real()), |
|
236 f(z2.imag()), |
|
237 g(z3.real()), |
|
238 h(z3.imag()) |
|
239 { |
|
240 // nothing to do! |
|
241 } |
|
242 |
|
243 |
|
244 // constructor for O seen as H^2 |
|
245 |
|
246 explicit octonion( ::boost::math::quaternion<T> const & q0, |
|
247 ::boost::math::quaternion<T> const & q1 = ::boost::math::quaternion<T>()) |
|
248 : a(q0.R_component_1()), |
|
249 b(q0.R_component_2()), |
|
250 c(q0.R_component_3()), |
|
251 d(q0.R_component_4()), |
|
252 e(q1.R_component_1()), |
|
253 f(q1.R_component_2()), |
|
254 g(q1.R_component_3()), |
|
255 h(q1.R_component_4()) |
|
256 { |
|
257 // nothing to do! |
|
258 } |
|
259 |
|
260 |
|
261 // UNtemplated copy constructor |
|
262 // (this is taken care of by the compiler itself) |
|
263 |
|
264 |
|
265 // templated copy constructor |
|
266 |
|
267 template<typename X> |
|
268 explicit octonion(octonion<X> const & a_recopier) |
|
269 : a(static_cast<T>(a_recopier.R_component_1())), |
|
270 b(static_cast<T>(a_recopier.R_component_2())), |
|
271 c(static_cast<T>(a_recopier.R_component_3())), |
|
272 d(static_cast<T>(a_recopier.R_component_4())), |
|
273 e(static_cast<T>(a_recopier.R_component_5())), |
|
274 f(static_cast<T>(a_recopier.R_component_6())), |
|
275 g(static_cast<T>(a_recopier.R_component_7())), |
|
276 h(static_cast<T>(a_recopier.R_component_8())) |
|
277 { |
|
278 // nothing to do! |
|
279 } |
|
280 |
|
281 |
|
282 // destructor |
|
283 // (this is taken care of by the compiler itself) |
|
284 |
|
285 |
|
286 // accessors |
|
287 // |
|
288 // Note: Like complex number, octonions do have a meaningful notion of "real part", |
|
289 // but unlike them there is no meaningful notion of "imaginary part". |
|
290 // Instead there is an "unreal part" which itself is an octonion, and usually |
|
291 // nothing simpler (as opposed to the complex number case). |
|
292 // However, for practicallity, there are accessors for the other components |
|
293 // (these are necessary for the templated copy constructor, for instance). |
|
294 |
|
295 BOOST_OCTONION_ACCESSOR_GENERATOR(T) |
|
296 |
|
297 // assignment operators |
|
298 |
|
299 BOOST_OCTONION_MEMBER_ASSIGNMENT_GENERATOR(T) |
|
300 |
|
301 // other assignment-related operators |
|
302 // |
|
303 // NOTE: Octonion multiplication is *NOT* commutative; |
|
304 // symbolically, "q *= rhs;" means "q = q * rhs;" |
|
305 // and "q /= rhs;" means "q = q * inverse_of(rhs);"; |
|
306 // octonion multiplication is also *NOT* associative |
|
307 |
|
308 octonion<T> & operator += (T const & rhs) |
|
309 { |
|
310 T at = a + rhs; // exception guard |
|
311 |
|
312 a = at; |
|
313 |
|
314 return(*this); |
|
315 } |
|
316 |
|
317 |
|
318 octonion<T> & operator += (::std::complex<T> const & rhs) |
|
319 { |
|
320 T at = a + rhs.real(); // exception guard |
|
321 T bt = b + rhs.imag(); // exception guard |
|
322 |
|
323 a = at; |
|
324 b = bt; |
|
325 |
|
326 return(*this); |
|
327 } |
|
328 |
|
329 |
|
330 octonion<T> & operator += (::boost::math::quaternion<T> const & rhs) |
|
331 { |
|
332 T at = a + rhs.R_component_1(); // exception guard |
|
333 T bt = b + rhs.R_component_2(); // exception guard |
|
334 T ct = c + rhs.R_component_3(); // exception guard |
|
335 T dt = d + rhs.R_component_4(); // exception guard |
|
336 |
|
337 a = at; |
|
338 b = bt; |
|
339 c = ct; |
|
340 d = dt; |
|
341 |
|
342 return(*this); |
|
343 } |
|
344 |
|
345 |
|
346 template<typename X> |
|
347 octonion<T> & operator += (octonion<X> const & rhs) |
|
348 { |
|
349 T at = a + static_cast<T>(rhs.R_component_1()); // exception guard |
|
350 T bt = b + static_cast<T>(rhs.R_component_2()); // exception guard |
|
351 T ct = c + static_cast<T>(rhs.R_component_3()); // exception guard |
|
352 T dt = d + static_cast<T>(rhs.R_component_4()); // exception guard |
|
353 T et = e + static_cast<T>(rhs.R_component_5()); // exception guard |
|
354 T ft = f + static_cast<T>(rhs.R_component_6()); // exception guard |
|
355 T gt = g + static_cast<T>(rhs.R_component_7()); // exception guard |
|
356 T ht = h + static_cast<T>(rhs.R_component_8()); // exception guard |
|
357 |
|
358 a = at; |
|
359 b = bt; |
|
360 c = ct; |
|
361 d = dt; |
|
362 e = et; |
|
363 f = ft; |
|
364 g = gt; |
|
365 h = ht; |
|
366 |
|
367 return(*this); |
|
368 } |
|
369 |
|
370 |
|
371 |
|
372 octonion<T> & operator -= (T const & rhs) |
|
373 { |
|
374 T at = a - rhs; // exception guard |
|
375 |
|
376 a = at; |
|
377 |
|
378 return(*this); |
|
379 } |
|
380 |
|
381 |
|
382 octonion<T> & operator -= (::std::complex<T> const & rhs) |
|
383 { |
|
384 T at = a - rhs.real(); // exception guard |
|
385 T bt = b - rhs.imag(); // exception guard |
|
386 |
|
387 a = at; |
|
388 b = bt; |
|
389 |
|
390 return(*this); |
|
391 } |
|
392 |
|
393 |
|
394 octonion<T> & operator -= (::boost::math::quaternion<T> const & rhs) |
|
395 { |
|
396 T at = a - rhs.R_component_1(); // exception guard |
|
397 T bt = b - rhs.R_component_2(); // exception guard |
|
398 T ct = c - rhs.R_component_3(); // exception guard |
|
399 T dt = d - rhs.R_component_4(); // exception guard |
|
400 |
|
401 a = at; |
|
402 b = bt; |
|
403 c = ct; |
|
404 d = dt; |
|
405 |
|
406 return(*this); |
|
407 } |
|
408 |
|
409 |
|
410 template<typename X> |
|
411 octonion<T> & operator -= (octonion<X> const & rhs) |
|
412 { |
|
413 T at = a - static_cast<T>(rhs.R_component_1()); // exception guard |
|
414 T bt = b - static_cast<T>(rhs.R_component_2()); // exception guard |
|
415 T ct = c - static_cast<T>(rhs.R_component_3()); // exception guard |
|
416 T dt = d - static_cast<T>(rhs.R_component_4()); // exception guard |
|
417 T et = e - static_cast<T>(rhs.R_component_5()); // exception guard |
|
418 T ft = f - static_cast<T>(rhs.R_component_6()); // exception guard |
|
419 T gt = g - static_cast<T>(rhs.R_component_7()); // exception guard |
|
420 T ht = h - static_cast<T>(rhs.R_component_8()); // exception guard |
|
421 |
|
422 a = at; |
|
423 b = bt; |
|
424 c = ct; |
|
425 d = dt; |
|
426 e = et; |
|
427 f = ft; |
|
428 g = gt; |
|
429 h = ht; |
|
430 |
|
431 return(*this); |
|
432 } |
|
433 |
|
434 |
|
435 octonion<T> & operator *= (T const & rhs) |
|
436 { |
|
437 T at = a * rhs; // exception guard |
|
438 T bt = b * rhs; // exception guard |
|
439 T ct = c * rhs; // exception guard |
|
440 T dt = d * rhs; // exception guard |
|
441 T et = e * rhs; // exception guard |
|
442 T ft = f * rhs; // exception guard |
|
443 T gt = g * rhs; // exception guard |
|
444 T ht = h * rhs; // exception guard |
|
445 |
|
446 a = at; |
|
447 b = bt; |
|
448 c = ct; |
|
449 d = dt; |
|
450 e = et; |
|
451 f = ft; |
|
452 g = gt; |
|
453 h = ht; |
|
454 |
|
455 return(*this); |
|
456 } |
|
457 |
|
458 |
|
459 octonion<T> & operator *= (::std::complex<T> const & rhs) |
|
460 { |
|
461 T ar = rhs.real(); |
|
462 T br = rhs.imag(); |
|
463 |
|
464 T at = +a*ar-b*br; |
|
465 T bt = +a*br+b*ar; |
|
466 T ct = +c*ar+d*br; |
|
467 T dt = -c*br+d*ar; |
|
468 T et = +e*ar+f*br; |
|
469 T ft = -e*br+f*ar; |
|
470 T gt = +g*ar-h*br; |
|
471 T ht = +g*br+h*ar; |
|
472 |
|
473 a = at; |
|
474 b = bt; |
|
475 c = ct; |
|
476 d = dt; |
|
477 e = et; |
|
478 f = ft; |
|
479 g = gt; |
|
480 h = ht; |
|
481 |
|
482 return(*this); |
|
483 } |
|
484 |
|
485 |
|
486 octonion<T> & operator *= (::boost::math::quaternion<T> const & rhs) |
|
487 { |
|
488 T ar = rhs.R_component_1(); |
|
489 T br = rhs.R_component_2(); |
|
490 T cr = rhs.R_component_2(); |
|
491 T dr = rhs.R_component_2(); |
|
492 |
|
493 T at = +a*ar-b*br-c*cr-d*dr; |
|
494 T bt = +a*br+b*ar+c*dr-d*cr; |
|
495 T ct = +a*cr-b*dr+c*ar+d*br; |
|
496 T dt = +a*dr+b*cr-c*br+d*ar; |
|
497 T et = +e*ar+f*br+g*cr+h*dr; |
|
498 T ft = -e*br+f*ar-g*dr+h*cr; |
|
499 T gt = -e*cr+f*dr+g*ar-h*br; |
|
500 T ht = -e*dr-f*cr+g*br+h*ar; |
|
501 |
|
502 a = at; |
|
503 b = bt; |
|
504 c = ct; |
|
505 d = dt; |
|
506 e = et; |
|
507 f = ft; |
|
508 g = gt; |
|
509 h = ht; |
|
510 |
|
511 return(*this); |
|
512 } |
|
513 |
|
514 |
|
515 template<typename X> |
|
516 octonion<T> & operator *= (octonion<X> const & rhs) |
|
517 { |
|
518 T ar = static_cast<T>(rhs.R_component_1()); |
|
519 T br = static_cast<T>(rhs.R_component_2()); |
|
520 T cr = static_cast<T>(rhs.R_component_3()); |
|
521 T dr = static_cast<T>(rhs.R_component_4()); |
|
522 T er = static_cast<T>(rhs.R_component_5()); |
|
523 T fr = static_cast<T>(rhs.R_component_6()); |
|
524 T gr = static_cast<T>(rhs.R_component_7()); |
|
525 T hr = static_cast<T>(rhs.R_component_8()); |
|
526 |
|
527 T at = +a*ar-b*br-c*cr-d*dr-e*er-f*fr-g*gr-h*hr; |
|
528 T bt = +a*br+b*ar+c*dr-d*cr+e*fr-f*er-g*hr+h*gr; |
|
529 T ct = +a*cr-b*dr+c*ar+d*br+e*gr+f*hr-g*er-h*fr; |
|
530 T dt = +a*dr+b*cr-c*br+d*ar+e*hr-f*gr+g*fr-h*er; |
|
531 T et = +a*er-b*fr-c*gr-d*hr+e*ar+f*br+g*cr+h*dr; |
|
532 T ft = +a*fr+b*er-c*hr+d*gr-e*br+f*ar-g*dr+h*cr; |
|
533 T gt = +a*gr+b*hr+c*er-d*fr-e*cr+f*dr+g*ar-h*br; |
|
534 T ht = +a*hr-b*gr+c*fr+d*er-e*dr-f*cr+g*br+h*ar; |
|
535 |
|
536 a = at; |
|
537 b = bt; |
|
538 c = ct; |
|
539 d = dt; |
|
540 e = et; |
|
541 f = ft; |
|
542 g = gt; |
|
543 h = ht; |
|
544 |
|
545 return(*this); |
|
546 } |
|
547 |
|
548 |
|
549 octonion<T> & operator /= (T const & rhs) |
|
550 { |
|
551 T at = a / rhs; // exception guard |
|
552 T bt = b / rhs; // exception guard |
|
553 T ct = c / rhs; // exception guard |
|
554 T dt = d / rhs; // exception guard |
|
555 T et = e / rhs; // exception guard |
|
556 T ft = f / rhs; // exception guard |
|
557 T gt = g / rhs; // exception guard |
|
558 T ht = h / rhs; // exception guard |
|
559 |
|
560 a = at; |
|
561 b = bt; |
|
562 c = ct; |
|
563 d = dt; |
|
564 e = et; |
|
565 f = ft; |
|
566 g = gt; |
|
567 h = ht; |
|
568 |
|
569 return(*this); |
|
570 } |
|
571 |
|
572 |
|
573 octonion<T> & operator /= (::std::complex<T> const & rhs) |
|
574 { |
|
575 T ar = rhs.real(); |
|
576 T br = rhs.imag(); |
|
577 |
|
578 T denominator = ar*ar+br*br; |
|
579 |
|
580 T at = (+a*ar-b*br)/denominator; |
|
581 T bt = (-a*br+b*ar)/denominator; |
|
582 T ct = (+c*ar-d*br)/denominator; |
|
583 T dt = (+c*br+d*ar)/denominator; |
|
584 T et = (+e*ar-f*br)/denominator; |
|
585 T ft = (+e*br+f*ar)/denominator; |
|
586 T gt = (+g*ar+h*br)/denominator; |
|
587 T ht = (+g*br+h*ar)/denominator; |
|
588 |
|
589 a = at; |
|
590 b = bt; |
|
591 c = ct; |
|
592 d = dt; |
|
593 e = et; |
|
594 f = ft; |
|
595 g = gt; |
|
596 h = ht; |
|
597 |
|
598 return(*this); |
|
599 } |
|
600 |
|
601 |
|
602 octonion<T> & operator /= (::boost::math::quaternion<T> const & rhs) |
|
603 { |
|
604 T ar = rhs.R_component_1(); |
|
605 T br = rhs.R_component_2(); |
|
606 T cr = rhs.R_component_2(); |
|
607 T dr = rhs.R_component_2(); |
|
608 |
|
609 T denominator = ar*ar+br*br+cr*cr+dr*dr; |
|
610 |
|
611 T at = (+a*ar+b*br+c*cr+d*dr)/denominator; |
|
612 T bt = (-a*br+b*ar-c*dr+d*cr)/denominator; |
|
613 T ct = (-a*cr+b*dr+c*ar-d*br)/denominator; |
|
614 T dt = (-a*dr-b*cr+c*br+d*ar)/denominator; |
|
615 T et = (+e*ar-f*br-g*cr-h*dr)/denominator; |
|
616 T ft = (+e*br+f*ar+g*dr-h*cr)/denominator; |
|
617 T gt = (+e*cr-f*dr+g*ar+h*br)/denominator; |
|
618 T ht = (+e*dr+f*cr-g*br+h*ar)/denominator; |
|
619 |
|
620 a = at; |
|
621 b = bt; |
|
622 c = ct; |
|
623 d = dt; |
|
624 e = et; |
|
625 f = ft; |
|
626 g = gt; |
|
627 h = ht; |
|
628 |
|
629 return(*this); |
|
630 } |
|
631 |
|
632 |
|
633 template<typename X> |
|
634 octonion<T> & operator /= (octonion<X> const & rhs) |
|
635 { |
|
636 T ar = static_cast<T>(rhs.R_component_1()); |
|
637 T br = static_cast<T>(rhs.R_component_2()); |
|
638 T cr = static_cast<T>(rhs.R_component_3()); |
|
639 T dr = static_cast<T>(rhs.R_component_4()); |
|
640 T er = static_cast<T>(rhs.R_component_5()); |
|
641 T fr = static_cast<T>(rhs.R_component_6()); |
|
642 T gr = static_cast<T>(rhs.R_component_7()); |
|
643 T hr = static_cast<T>(rhs.R_component_8()); |
|
644 |
|
645 T denominator = ar*ar+br*br+cr*cr+dr*dr+er*er+fr*fr+gr*gr+hr*hr; |
|
646 |
|
647 T at = (+a*ar+b*br+c*cr+d*dr+e*er+f*fr+g*gr+h*hr)/denominator; |
|
648 T bt = (-a*br+b*ar-c*dr+d*cr-e*fr+f*er+g*hr-h*gr)/denominator; |
|
649 T ct = (-a*cr+b*dr+c*ar-d*br-e*gr-f*hr+g*er+h*fr)/denominator; |
|
650 T dt = (-a*dr-b*cr+c*br+d*ar-e*hr+f*gr-g*fr+h*er)/denominator; |
|
651 T et = (-a*er+b*fr+c*gr+d*hr+e*ar-f*br-g*cr-h*dr)/denominator; |
|
652 T ft = (-a*fr-b*er+c*hr-d*gr+e*br+f*ar+g*dr-h*cr)/denominator; |
|
653 T gt = (-a*gr-b*hr-c*er+d*fr+e*cr-f*dr+g*ar+h*br)/denominator; |
|
654 T ht = (-a*hr+b*gr-c*fr-d*er+e*dr+f*cr-g*br+h*ar)/denominator; |
|
655 |
|
656 a = at; |
|
657 b = bt; |
|
658 c = ct; |
|
659 d = dt; |
|
660 e = et; |
|
661 f = ft; |
|
662 g = gt; |
|
663 h = ht; |
|
664 |
|
665 return(*this); |
|
666 } |
|
667 |
|
668 |
|
669 protected: |
|
670 |
|
671 BOOST_OCTONION_MEMBER_DATA_GENERATOR(T) |
|
672 |
|
673 |
|
674 private: |
|
675 |
|
676 }; |
|
677 |
|
678 |
|
679 // declaration of octonion specialization |
|
680 |
|
681 template<> class octonion<float>; |
|
682 template<> class octonion<double>; |
|
683 template<> class octonion<long double>; |
|
684 |
|
685 |
|
686 // helper templates for converting copy constructors (declaration) |
|
687 |
|
688 namespace detail |
|
689 { |
|
690 |
|
691 template< typename T, |
|
692 typename U |
|
693 > |
|
694 octonion<T> octonion_type_converter(octonion<U> const & rhs); |
|
695 } |
|
696 |
|
697 |
|
698 // implementation of octonion specialization |
|
699 |
|
700 |
|
701 #define BOOST_OCTONION_CONSTRUCTOR_GENERATOR(type) \ |
|
702 explicit octonion( type const & requested_a = static_cast<type>(0), \ |
|
703 type const & requested_b = static_cast<type>(0), \ |
|
704 type const & requested_c = static_cast<type>(0), \ |
|
705 type const & requested_d = static_cast<type>(0), \ |
|
706 type const & requested_e = static_cast<type>(0), \ |
|
707 type const & requested_f = static_cast<type>(0), \ |
|
708 type const & requested_g = static_cast<type>(0), \ |
|
709 type const & requested_h = static_cast<type>(0)) \ |
|
710 : a(requested_a), \ |
|
711 b(requested_b), \ |
|
712 c(requested_c), \ |
|
713 d(requested_d), \ |
|
714 e(requested_e), \ |
|
715 f(requested_f), \ |
|
716 g(requested_g), \ |
|
717 h(requested_h) \ |
|
718 { \ |
|
719 } \ |
|
720 \ |
|
721 explicit octonion( ::std::complex<type> const & z0, \ |
|
722 ::std::complex<type> const & z1 = ::std::complex<type>(), \ |
|
723 ::std::complex<type> const & z2 = ::std::complex<type>(), \ |
|
724 ::std::complex<type> const & z3 = ::std::complex<type>()) \ |
|
725 : a(z0.real()), \ |
|
726 b(z0.imag()), \ |
|
727 c(z1.real()), \ |
|
728 d(z1.imag()), \ |
|
729 e(z2.real()), \ |
|
730 f(z2.imag()), \ |
|
731 g(z3.real()), \ |
|
732 h(z3.imag()) \ |
|
733 { \ |
|
734 } \ |
|
735 \ |
|
736 explicit octonion( ::boost::math::quaternion<type> const & q0, \ |
|
737 ::boost::math::quaternion<type> const & q1 = ::boost::math::quaternion<type>()) \ |
|
738 : a(q0.R_component_1()), \ |
|
739 b(q0.R_component_2()), \ |
|
740 c(q0.R_component_3()), \ |
|
741 d(q0.R_component_4()), \ |
|
742 e(q1.R_component_1()), \ |
|
743 f(q1.R_component_2()), \ |
|
744 g(q1.R_component_3()), \ |
|
745 h(q1.R_component_4()) \ |
|
746 { \ |
|
747 } |
|
748 |
|
749 |
|
750 #define BOOST_OCTONION_MEMBER_ADD_GENERATOR_1(type) \ |
|
751 octonion<type> & operator += (type const & rhs) \ |
|
752 { \ |
|
753 a += rhs; \ |
|
754 \ |
|
755 return(*this); \ |
|
756 } |
|
757 |
|
758 #define BOOST_OCTONION_MEMBER_ADD_GENERATOR_2(type) \ |
|
759 octonion<type> & operator += (::std::complex<type> const & rhs) \ |
|
760 { \ |
|
761 a += rhs.real(); \ |
|
762 b += rhs.imag(); \ |
|
763 \ |
|
764 return(*this); \ |
|
765 } |
|
766 |
|
767 #define BOOST_OCTONION_MEMBER_ADD_GENERATOR_3(type) \ |
|
768 octonion<type> & operator += (::boost::math::quaternion<type> const & rhs) \ |
|
769 { \ |
|
770 a += rhs.R_component_1(); \ |
|
771 b += rhs.R_component_2(); \ |
|
772 c += rhs.R_component_3(); \ |
|
773 d += rhs.R_component_4(); \ |
|
774 \ |
|
775 return(*this); \ |
|
776 } |
|
777 |
|
778 #define BOOST_OCTONION_MEMBER_ADD_GENERATOR_4(type) \ |
|
779 template<typename X> \ |
|
780 octonion<type> & operator += (octonion<X> const & rhs) \ |
|
781 { \ |
|
782 a += static_cast<type>(rhs.R_component_1()); \ |
|
783 b += static_cast<type>(rhs.R_component_2()); \ |
|
784 c += static_cast<type>(rhs.R_component_3()); \ |
|
785 d += static_cast<type>(rhs.R_component_4()); \ |
|
786 e += static_cast<type>(rhs.R_component_5()); \ |
|
787 f += static_cast<type>(rhs.R_component_6()); \ |
|
788 g += static_cast<type>(rhs.R_component_7()); \ |
|
789 h += static_cast<type>(rhs.R_component_8()); \ |
|
790 \ |
|
791 return(*this); \ |
|
792 } |
|
793 |
|
794 #define BOOST_OCTONION_MEMBER_SUB_GENERATOR_1(type) \ |
|
795 octonion<type> & operator -= (type const & rhs) \ |
|
796 { \ |
|
797 a -= rhs; \ |
|
798 \ |
|
799 return(*this); \ |
|
800 } |
|
801 |
|
802 #define BOOST_OCTONION_MEMBER_SUB_GENERATOR_2(type) \ |
|
803 octonion<type> & operator -= (::std::complex<type> const & rhs) \ |
|
804 { \ |
|
805 a -= rhs.real(); \ |
|
806 b -= rhs.imag(); \ |
|
807 \ |
|
808 return(*this); \ |
|
809 } |
|
810 |
|
811 #define BOOST_OCTONION_MEMBER_SUB_GENERATOR_3(type) \ |
|
812 octonion<type> & operator -= (::boost::math::quaternion<type> const & rhs) \ |
|
813 { \ |
|
814 a -= rhs.R_component_1(); \ |
|
815 b -= rhs.R_component_2(); \ |
|
816 c -= rhs.R_component_3(); \ |
|
817 d -= rhs.R_component_4(); \ |
|
818 \ |
|
819 return(*this); \ |
|
820 } |
|
821 |
|
822 #define BOOST_OCTONION_MEMBER_SUB_GENERATOR_4(type) \ |
|
823 template<typename X> \ |
|
824 octonion<type> & operator -= (octonion<X> const & rhs) \ |
|
825 { \ |
|
826 a -= static_cast<type>(rhs.R_component_1()); \ |
|
827 b -= static_cast<type>(rhs.R_component_2()); \ |
|
828 c -= static_cast<type>(rhs.R_component_3()); \ |
|
829 d -= static_cast<type>(rhs.R_component_4()); \ |
|
830 e -= static_cast<type>(rhs.R_component_5()); \ |
|
831 f -= static_cast<type>(rhs.R_component_6()); \ |
|
832 g -= static_cast<type>(rhs.R_component_7()); \ |
|
833 h -= static_cast<type>(rhs.R_component_8()); \ |
|
834 \ |
|
835 return(*this); \ |
|
836 } |
|
837 |
|
838 #define BOOST_OCTONION_MEMBER_MUL_GENERATOR_1(type) \ |
|
839 octonion<type> & operator *= (type const & rhs) \ |
|
840 { \ |
|
841 a *= rhs; \ |
|
842 b *= rhs; \ |
|
843 c *= rhs; \ |
|
844 d *= rhs; \ |
|
845 e *= rhs; \ |
|
846 f *= rhs; \ |
|
847 g *= rhs; \ |
|
848 h *= rhs; \ |
|
849 \ |
|
850 return(*this); \ |
|
851 } |
|
852 |
|
853 #define BOOST_OCTONION_MEMBER_MUL_GENERATOR_2(type) \ |
|
854 octonion<type> & operator *= (::std::complex<type> const & rhs) \ |
|
855 { \ |
|
856 type ar = rhs.real(); \ |
|
857 type br = rhs.imag(); \ |
|
858 \ |
|
859 type at = +a*ar-b*br; \ |
|
860 type bt = +a*br+b*ar; \ |
|
861 type ct = +c*ar+d*br; \ |
|
862 type dt = -c*br+d*ar; \ |
|
863 type et = +e*ar+f*br; \ |
|
864 type ft = -e*br+f*ar; \ |
|
865 type gt = +g*ar-h*br; \ |
|
866 type ht = +g*br+h*ar; \ |
|
867 \ |
|
868 a = at; \ |
|
869 b = bt; \ |
|
870 c = ct; \ |
|
871 d = dt; \ |
|
872 e = et; \ |
|
873 f = ft; \ |
|
874 g = gt; \ |
|
875 h = ht; \ |
|
876 \ |
|
877 return(*this); \ |
|
878 } |
|
879 |
|
880 #define BOOST_OCTONION_MEMBER_MUL_GENERATOR_3(type) \ |
|
881 octonion<type> & operator *= (::boost::math::quaternion<type> const & rhs) \ |
|
882 { \ |
|
883 type ar = rhs.R_component_1(); \ |
|
884 type br = rhs.R_component_2(); \ |
|
885 type cr = rhs.R_component_2(); \ |
|
886 type dr = rhs.R_component_2(); \ |
|
887 \ |
|
888 type at = +a*ar-b*br-c*cr-d*dr; \ |
|
889 type bt = +a*br+b*ar+c*dr-d*cr; \ |
|
890 type ct = +a*cr-b*dr+c*ar+d*br; \ |
|
891 type dt = +a*dr+b*cr-c*br+d*ar; \ |
|
892 type et = +e*ar+f*br+g*cr+h*dr; \ |
|
893 type ft = -e*br+f*ar-g*dr+h*cr; \ |
|
894 type gt = -e*cr+f*dr+g*ar-h*br; \ |
|
895 type ht = -e*dr-f*cr+g*br+h*ar; \ |
|
896 \ |
|
897 a = at; \ |
|
898 b = bt; \ |
|
899 c = ct; \ |
|
900 d = dt; \ |
|
901 e = et; \ |
|
902 f = ft; \ |
|
903 g = gt; \ |
|
904 h = ht; \ |
|
905 \ |
|
906 return(*this); \ |
|
907 } |
|
908 |
|
909 #define BOOST_OCTONION_MEMBER_MUL_GENERATOR_4(type) \ |
|
910 template<typename X> \ |
|
911 octonion<type> & operator *= (octonion<X> const & rhs) \ |
|
912 { \ |
|
913 type ar = static_cast<type>(rhs.R_component_1()); \ |
|
914 type br = static_cast<type>(rhs.R_component_2()); \ |
|
915 type cr = static_cast<type>(rhs.R_component_3()); \ |
|
916 type dr = static_cast<type>(rhs.R_component_4()); \ |
|
917 type er = static_cast<type>(rhs.R_component_5()); \ |
|
918 type fr = static_cast<type>(rhs.R_component_6()); \ |
|
919 type gr = static_cast<type>(rhs.R_component_7()); \ |
|
920 type hr = static_cast<type>(rhs.R_component_8()); \ |
|
921 \ |
|
922 type at = +a*ar-b*br-c*cr-d*dr-e*er-f*fr-g*gr-h*hr; \ |
|
923 type bt = +a*br+b*ar+c*dr-d*cr+e*fr-f*er-g*hr+h*gr; \ |
|
924 type ct = +a*cr-b*dr+c*ar+d*br+e*gr+f*hr-g*er-h*fr; \ |
|
925 type dt = +a*dr+b*cr-c*br+d*ar+e*hr-f*gr+g*fr-h*er; \ |
|
926 type et = +a*er-b*fr-c*gr-d*hr+e*ar+f*br+g*cr+h*dr; \ |
|
927 type ft = +a*fr+b*er-c*hr+d*gr-e*br+f*ar-g*dr+h*cr; \ |
|
928 type gt = +a*gr+b*hr+c*er-d*fr-e*cr+f*dr+g*ar-h*br; \ |
|
929 type ht = +a*hr-b*gr+c*fr+d*er-e*dr-f*cr+g*br+h*ar; \ |
|
930 \ |
|
931 a = at; \ |
|
932 b = bt; \ |
|
933 c = ct; \ |
|
934 d = dt; \ |
|
935 e = et; \ |
|
936 f = ft; \ |
|
937 g = gt; \ |
|
938 h = ht; \ |
|
939 \ |
|
940 return(*this); \ |
|
941 } |
|
942 |
|
943 // There is quite a lot of repetition in the code below. This is intentional. |
|
944 // The last conditional block is the normal form, and the others merely |
|
945 // consist of workarounds for various compiler deficiencies. Hopefuly, when |
|
946 // more compilers are conformant and we can retire support for those that are |
|
947 // not, we will be able to remove the clutter. This is makes the situation |
|
948 // (painfully) explicit. |
|
949 |
|
950 #define BOOST_OCTONION_MEMBER_DIV_GENERATOR_1(type) \ |
|
951 octonion<type> & operator /= (type const & rhs) \ |
|
952 { \ |
|
953 a /= rhs; \ |
|
954 b /= rhs; \ |
|
955 c /= rhs; \ |
|
956 d /= rhs; \ |
|
957 \ |
|
958 return(*this); \ |
|
959 } |
|
960 |
|
961 #if defined(__GNUC__) && (__GNUC__ < 3) |
|
962 #define BOOST_OCTONION_MEMBER_DIV_GENERATOR_2(type) \ |
|
963 octonion<type> & operator /= (::std::complex<type> const & rhs) \ |
|
964 { \ |
|
965 using ::std::valarray; \ |
|
966 \ |
|
967 valarray<type> tr(2); \ |
|
968 \ |
|
969 tr[0] = rhs.real(); \ |
|
970 tr[1] = rhs.imag(); \ |
|
971 \ |
|
972 type mixam = (BOOST_GET_VALARRAY(type,static_cast<type>(1)/abs(tr)).max)(); \ |
|
973 \ |
|
974 tr *= mixam; \ |
|
975 \ |
|
976 valarray<type> tt(8); \ |
|
977 \ |
|
978 tt[0] = +a*tr[0]-b*tr[1]; \ |
|
979 tt[1] = -a*tr[1]+b*tr[0]; \ |
|
980 tt[2] = +c*tr[0]-d*tr[1]; \ |
|
981 tt[3] = +c*tr[1]+d*tr[0]; \ |
|
982 tt[4] = +e*tr[0]-f*tr[1]; \ |
|
983 tt[5] = +e*tr[1]+f*tr[0]; \ |
|
984 tt[6] = +g*tr[0]+h*tr[1]; \ |
|
985 tt[7] = +g*tr[1]+h*tr[0]; \ |
|
986 \ |
|
987 tr *= tr; \ |
|
988 \ |
|
989 tt *= (mixam/tr.sum()); \ |
|
990 \ |
|
991 a = tt[0]; \ |
|
992 b = tt[1]; \ |
|
993 c = tt[2]; \ |
|
994 d = tt[3]; \ |
|
995 e = tt[4]; \ |
|
996 f = tt[5]; \ |
|
997 g = tt[6]; \ |
|
998 h = tt[7]; \ |
|
999 \ |
|
1000 return(*this); \ |
|
1001 } |
|
1002 #elif defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP) |
|
1003 #define BOOST_OCTONION_MEMBER_DIV_GENERATOR_2(type) \ |
|
1004 octonion<type> & operator /= (::std::complex<type> const & rhs) \ |
|
1005 { \ |
|
1006 using ::std::valarray; \ |
|
1007 using ::std::abs; \ |
|
1008 \ |
|
1009 valarray<type> tr(2); \ |
|
1010 \ |
|
1011 tr[0] = rhs.real(); \ |
|
1012 tr[1] = rhs.imag(); \ |
|
1013 \ |
|
1014 type mixam = static_cast<type>(1)/(abs(tr).max)(); \ |
|
1015 \ |
|
1016 tr *= mixam; \ |
|
1017 \ |
|
1018 valarray<type> tt(8); \ |
|
1019 \ |
|
1020 tt[0] = +a*tr[0]-b*tr[1]; \ |
|
1021 tt[1] = -a*tr[1]+b*tr[0]; \ |
|
1022 tt[2] = +c*tr[0]-d*tr[1]; \ |
|
1023 tt[3] = +c*tr[1]+d*tr[0]; \ |
|
1024 tt[4] = +e*tr[0]-f*tr[1]; \ |
|
1025 tt[5] = +e*tr[1]+f*tr[0]; \ |
|
1026 tt[6] = +g*tr[0]+h*tr[1]; \ |
|
1027 tt[7] = +g*tr[1]+h*tr[0]; \ |
|
1028 \ |
|
1029 tr *= tr; \ |
|
1030 \ |
|
1031 tt *= (mixam/tr.sum()); \ |
|
1032 \ |
|
1033 a = tt[0]; \ |
|
1034 b = tt[1]; \ |
|
1035 c = tt[2]; \ |
|
1036 d = tt[3]; \ |
|
1037 e = tt[4]; \ |
|
1038 f = tt[5]; \ |
|
1039 g = tt[6]; \ |
|
1040 h = tt[7]; \ |
|
1041 \ |
|
1042 return(*this); \ |
|
1043 } |
|
1044 #else |
|
1045 #define BOOST_OCTONION_MEMBER_DIV_GENERATOR_2(type) \ |
|
1046 octonion<type> & operator /= (::std::complex<type> const & rhs) \ |
|
1047 { \ |
|
1048 using ::std::valarray; \ |
|
1049 \ |
|
1050 valarray<type> tr(2); \ |
|
1051 \ |
|
1052 tr[0] = rhs.real(); \ |
|
1053 tr[1] = rhs.imag(); \ |
|
1054 \ |
|
1055 type mixam = static_cast<type>(1)/(abs(tr).max)(); \ |
|
1056 \ |
|
1057 tr *= mixam; \ |
|
1058 \ |
|
1059 valarray<type> tt(8); \ |
|
1060 \ |
|
1061 tt[0] = +a*tr[0]-b*tr[1]; \ |
|
1062 tt[1] = -a*tr[1]+b*tr[0]; \ |
|
1063 tt[2] = +c*tr[0]-d*tr[1]; \ |
|
1064 tt[3] = +c*tr[1]+d*tr[0]; \ |
|
1065 tt[4] = +e*tr[0]-f*tr[1]; \ |
|
1066 tt[5] = +e*tr[1]+f*tr[0]; \ |
|
1067 tt[6] = +g*tr[0]+h*tr[1]; \ |
|
1068 tt[7] = +g*tr[1]+h*tr[0]; \ |
|
1069 \ |
|
1070 tr *= tr; \ |
|
1071 \ |
|
1072 tt *= (mixam/tr.sum()); \ |
|
1073 \ |
|
1074 a = tt[0]; \ |
|
1075 b = tt[1]; \ |
|
1076 c = tt[2]; \ |
|
1077 d = tt[3]; \ |
|
1078 e = tt[4]; \ |
|
1079 f = tt[5]; \ |
|
1080 g = tt[6]; \ |
|
1081 h = tt[7]; \ |
|
1082 \ |
|
1083 return(*this); \ |
|
1084 } |
|
1085 #endif /* defined(__GNUC__) && (__GNUC__ < 3) */ /* BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP */ |
|
1086 |
|
1087 #if defined(__GNUC__) && (__GNUC__ < 3) |
|
1088 #define BOOST_OCTONION_MEMBER_DIV_GENERATOR_3(type) \ |
|
1089 octonion<type> & operator /= (::boost::math::quaternion<type> const & rhs) \ |
|
1090 { \ |
|
1091 using ::std::valarray; \ |
|
1092 \ |
|
1093 valarray<type> tr(4); \ |
|
1094 \ |
|
1095 tr[0] = static_cast<type>(rhs.R_component_1()); \ |
|
1096 tr[1] = static_cast<type>(rhs.R_component_2()); \ |
|
1097 tr[2] = static_cast<type>(rhs.R_component_3()); \ |
|
1098 tr[3] = static_cast<type>(rhs.R_component_4()); \ |
|
1099 \ |
|
1100 type mixam = (BOOST_GET_VALARRAY(type,static_cast<type>(1)/abs(tr)).max)();\ |
|
1101 \ |
|
1102 tr *= mixam; \ |
|
1103 \ |
|
1104 valarray<type> tt(8); \ |
|
1105 \ |
|
1106 tt[0] = +a*tr[0]+b*tr[1]+c*tr[2]+d*tr[3]; \ |
|
1107 tt[1] = -a*tr[1]+b*tr[0]-c*tr[3]+d*tr[2]; \ |
|
1108 tt[2] = -a*tr[2]+b*tr[3]+c*tr[0]-d*tr[1]; \ |
|
1109 tt[3] = -a*tr[3]-b*tr[2]+c*tr[1]+d*tr[0]; \ |
|
1110 tt[4] = +e*tr[0]-f*tr[1]-g*tr[2]-h*tr[3]; \ |
|
1111 tt[5] = +e*tr[1]+f*tr[0]+g*tr[3]-h*tr[2]; \ |
|
1112 tt[6] = +e*tr[2]-f*tr[3]+g*tr[0]+h*tr[1]; \ |
|
1113 tt[7] = +e*tr[3]+f*tr[2]-g*tr[1]+h*tr[0]; \ |
|
1114 \ |
|
1115 tr *= tr; \ |
|
1116 \ |
|
1117 tt *= (mixam/tr.sum()); \ |
|
1118 \ |
|
1119 a = tt[0]; \ |
|
1120 b = tt[1]; \ |
|
1121 c = tt[2]; \ |
|
1122 d = tt[3]; \ |
|
1123 e = tt[4]; \ |
|
1124 f = tt[5]; \ |
|
1125 g = tt[6]; \ |
|
1126 h = tt[7]; \ |
|
1127 \ |
|
1128 return(*this); \ |
|
1129 } |
|
1130 #elif defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP) |
|
1131 #define BOOST_OCTONION_MEMBER_DIV_GENERATOR_3(type) \ |
|
1132 octonion<type> & operator /= (::boost::math::quaternion<type> const & rhs) \ |
|
1133 { \ |
|
1134 using ::std::valarray; \ |
|
1135 using ::std::abs; \ |
|
1136 \ |
|
1137 valarray<type> tr(4); \ |
|
1138 \ |
|
1139 tr[0] = static_cast<type>(rhs.R_component_1()); \ |
|
1140 tr[1] = static_cast<type>(rhs.R_component_2()); \ |
|
1141 tr[2] = static_cast<type>(rhs.R_component_3()); \ |
|
1142 tr[3] = static_cast<type>(rhs.R_component_4()); \ |
|
1143 \ |
|
1144 type mixam = static_cast<type>(1)/(abs(tr).max)(); \ |
|
1145 \ |
|
1146 tr *= mixam; \ |
|
1147 \ |
|
1148 valarray<type> tt(8); \ |
|
1149 \ |
|
1150 tt[0] = +a*tr[0]+b*tr[1]+c*tr[2]+d*tr[3]; \ |
|
1151 tt[1] = -a*tr[1]+b*tr[0]-c*tr[3]+d*tr[2]; \ |
|
1152 tt[2] = -a*tr[2]+b*tr[3]+c*tr[0]-d*tr[1]; \ |
|
1153 tt[3] = -a*tr[3]-b*tr[2]+c*tr[1]+d*tr[0]; \ |
|
1154 tt[4] = +e*tr[0]-f*tr[1]-g*tr[2]-h*tr[3]; \ |
|
1155 tt[5] = +e*tr[1]+f*tr[0]+g*tr[3]-h*tr[2]; \ |
|
1156 tt[6] = +e*tr[2]-f*tr[3]+g*tr[0]+h*tr[1]; \ |
|
1157 tt[7] = +e*tr[3]+f*tr[2]-g*tr[1]+h*tr[0]; \ |
|
1158 \ |
|
1159 tr *= tr; \ |
|
1160 \ |
|
1161 tt *= (mixam/tr.sum()); \ |
|
1162 \ |
|
1163 a = tt[0]; \ |
|
1164 b = tt[1]; \ |
|
1165 c = tt[2]; \ |
|
1166 d = tt[3]; \ |
|
1167 e = tt[4]; \ |
|
1168 f = tt[5]; \ |
|
1169 g = tt[6]; \ |
|
1170 h = tt[7]; \ |
|
1171 \ |
|
1172 return(*this); \ |
|
1173 } |
|
1174 #else |
|
1175 #define BOOST_OCTONION_MEMBER_DIV_GENERATOR_3(type) \ |
|
1176 octonion<type> & operator /= (::boost::math::quaternion<type> const & rhs) \ |
|
1177 { \ |
|
1178 using ::std::valarray; \ |
|
1179 \ |
|
1180 valarray<type> tr(4); \ |
|
1181 \ |
|
1182 tr[0] = static_cast<type>(rhs.R_component_1()); \ |
|
1183 tr[1] = static_cast<type>(rhs.R_component_2()); \ |
|
1184 tr[2] = static_cast<type>(rhs.R_component_3()); \ |
|
1185 tr[3] = static_cast<type>(rhs.R_component_4()); \ |
|
1186 \ |
|
1187 type mixam = static_cast<type>(1)/(abs(tr).max)(); \ |
|
1188 \ |
|
1189 tr *= mixam; \ |
|
1190 \ |
|
1191 valarray<type> tt(8); \ |
|
1192 \ |
|
1193 tt[0] = +a*tr[0]+b*tr[1]+c*tr[2]+d*tr[3]; \ |
|
1194 tt[1] = -a*tr[1]+b*tr[0]-c*tr[3]+d*tr[2]; \ |
|
1195 tt[2] = -a*tr[2]+b*tr[3]+c*tr[0]-d*tr[1]; \ |
|
1196 tt[3] = -a*tr[3]-b*tr[2]+c*tr[1]+d*tr[0]; \ |
|
1197 tt[4] = +e*tr[0]-f*tr[1]-g*tr[2]-h*tr[3]; \ |
|
1198 tt[5] = +e*tr[1]+f*tr[0]+g*tr[3]-h*tr[2]; \ |
|
1199 tt[6] = +e*tr[2]-f*tr[3]+g*tr[0]+h*tr[1]; \ |
|
1200 tt[7] = +e*tr[3]+f*tr[2]-g*tr[1]+h*tr[0]; \ |
|
1201 \ |
|
1202 tr *= tr; \ |
|
1203 \ |
|
1204 tt *= (mixam/tr.sum()); \ |
|
1205 \ |
|
1206 a = tt[0]; \ |
|
1207 b = tt[1]; \ |
|
1208 c = tt[2]; \ |
|
1209 d = tt[3]; \ |
|
1210 e = tt[4]; \ |
|
1211 f = tt[5]; \ |
|
1212 g = tt[6]; \ |
|
1213 h = tt[7]; \ |
|
1214 \ |
|
1215 return(*this); \ |
|
1216 } |
|
1217 #endif /* defined(__GNUC__) && (__GNUC__ < 3) */ /* BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP */ |
|
1218 |
|
1219 #if defined(__GNUC__) && (__GNUC__ < 3) |
|
1220 #define BOOST_OCTONION_MEMBER_DIV_GENERATOR_4(type) \ |
|
1221 template<typename X> \ |
|
1222 octonion<type> & operator /= (octonion<X> const & rhs) \ |
|
1223 { \ |
|
1224 using ::std::valarray; \ |
|
1225 \ |
|
1226 valarray<type> tr(8); \ |
|
1227 \ |
|
1228 tr[0] = static_cast<type>(rhs.R_component_1()); \ |
|
1229 tr[1] = static_cast<type>(rhs.R_component_2()); \ |
|
1230 tr[2] = static_cast<type>(rhs.R_component_3()); \ |
|
1231 tr[3] = static_cast<type>(rhs.R_component_4()); \ |
|
1232 tr[4] = static_cast<type>(rhs.R_component_5()); \ |
|
1233 tr[5] = static_cast<type>(rhs.R_component_6()); \ |
|
1234 tr[6] = static_cast<type>(rhs.R_component_7()); \ |
|
1235 tr[7] = static_cast<type>(rhs.R_component_8()); \ |
|
1236 \ |
|
1237 type mixam = (BOOST_GET_VALARRAY(type,static_cast<type>(1)/abs(tr)).max)();\ |
|
1238 \ |
|
1239 tr *= mixam; \ |
|
1240 \ |
|
1241 valarray<type> tt(8); \ |
|
1242 \ |
|
1243 tt[0] = +a*tr[0]+b*tr[1]+c*tr[2]+d*tr[3]+e*tr[4]+f*tr[5]+g*tr[6]+h*tr[7]; \ |
|
1244 tt[1] = -a*tr[1]+b*tr[0]-c*tr[3]+d*tr[2]-e*tr[5]+f*tr[4]+g*tr[7]-h*tr[6]; \ |
|
1245 tt[2] = -a*tr[2]+b*tr[3]+c*tr[0]-d*tr[1]-e*tr[6]-f*tr[7]+g*tr[4]+h*tr[5]; \ |
|
1246 tt[3] = -a*tr[3]-b*tr[2]+c*tr[1]+d*tr[0]-e*tr[7]+f*tr[6]-g*tr[5]+h*tr[4]; \ |
|
1247 tt[4] = -a*tr[4]+b*tr[5]+c*tr[6]+d*tr[7]+e*tr[0]-f*tr[1]-g*tr[2]-h*tr[3]; \ |
|
1248 tt[5] = -a*tr[5]-b*tr[4]+c*tr[7]-d*tr[6]+e*tr[1]+f*tr[0]+g*tr[3]-h*tr[2]; \ |
|
1249 tt[6] = -a*tr[6]-b*tr[7]-c*tr[4]+d*tr[5]+e*tr[2]-f*tr[3]+g*tr[0]+h*tr[1]; \ |
|
1250 tt[7] = -a*tr[7]+b*tr[6]-c*tr[5]-d*tr[4]+e*tr[3]+f*tr[2]-g*tr[1]+h*tr[0]; \ |
|
1251 \ |
|
1252 tr *= tr; \ |
|
1253 \ |
|
1254 tt *= (mixam/tr.sum()); \ |
|
1255 \ |
|
1256 a = tt[0]; \ |
|
1257 b = tt[1]; \ |
|
1258 c = tt[2]; \ |
|
1259 d = tt[3]; \ |
|
1260 e = tt[4]; \ |
|
1261 f = tt[5]; \ |
|
1262 g = tt[6]; \ |
|
1263 h = tt[7]; \ |
|
1264 \ |
|
1265 return(*this); \ |
|
1266 } |
|
1267 #elif defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP) |
|
1268 #define BOOST_OCTONION_MEMBER_DIV_GENERATOR_4(type) \ |
|
1269 template<typename X> \ |
|
1270 octonion<type> & operator /= (octonion<X> const & rhs) \ |
|
1271 { \ |
|
1272 using ::std::valarray; \ |
|
1273 using ::std::abs; \ |
|
1274 \ |
|
1275 valarray<type> tr(8); \ |
|
1276 \ |
|
1277 tr[0] = static_cast<type>(rhs.R_component_1()); \ |
|
1278 tr[1] = static_cast<type>(rhs.R_component_2()); \ |
|
1279 tr[2] = static_cast<type>(rhs.R_component_3()); \ |
|
1280 tr[3] = static_cast<type>(rhs.R_component_4()); \ |
|
1281 tr[4] = static_cast<type>(rhs.R_component_5()); \ |
|
1282 tr[5] = static_cast<type>(rhs.R_component_6()); \ |
|
1283 tr[6] = static_cast<type>(rhs.R_component_7()); \ |
|
1284 tr[7] = static_cast<type>(rhs.R_component_8()); \ |
|
1285 \ |
|
1286 type mixam = static_cast<type>(1)/(abs(tr).max)(); \ |
|
1287 \ |
|
1288 tr *= mixam; \ |
|
1289 \ |
|
1290 valarray<type> tt(8); \ |
|
1291 \ |
|
1292 tt[0] = +a*tr[0]+b*tr[1]+c*tr[2]+d*tr[3]+e*tr[4]+f*tr[5]+g*tr[6]+h*tr[7]; \ |
|
1293 tt[1] = -a*tr[1]+b*tr[0]-c*tr[3]+d*tr[2]-e*tr[5]+f*tr[4]+g*tr[7]-h*tr[6]; \ |
|
1294 tt[2] = -a*tr[2]+b*tr[3]+c*tr[0]-d*tr[1]-e*tr[6]-f*tr[7]+g*tr[4]+h*tr[5]; \ |
|
1295 tt[3] = -a*tr[3]-b*tr[2]+c*tr[1]+d*tr[0]-e*tr[7]+f*tr[6]-g*tr[5]+h*tr[4]; \ |
|
1296 tt[4] = -a*tr[4]+b*tr[5]+c*tr[6]+d*tr[7]+e*tr[0]-f*tr[1]-g*tr[2]-h*tr[3]; \ |
|
1297 tt[5] = -a*tr[5]-b*tr[4]+c*tr[7]-d*tr[6]+e*tr[1]+f*tr[0]+g*tr[3]-h*tr[2]; \ |
|
1298 tt[6] = -a*tr[6]-b*tr[7]-c*tr[4]+d*tr[5]+e*tr[2]-f*tr[3]+g*tr[0]+h*tr[1]; \ |
|
1299 tt[7] = -a*tr[7]+b*tr[6]-c*tr[5]-d*tr[4]+e*tr[3]+f*tr[2]-g*tr[1]+h*tr[0]; \ |
|
1300 \ |
|
1301 tr *= tr; \ |
|
1302 \ |
|
1303 tt *= (mixam/tr.sum()); \ |
|
1304 \ |
|
1305 a = tt[0]; \ |
|
1306 b = tt[1]; \ |
|
1307 c = tt[2]; \ |
|
1308 d = tt[3]; \ |
|
1309 e = tt[4]; \ |
|
1310 f = tt[5]; \ |
|
1311 g = tt[6]; \ |
|
1312 h = tt[7]; \ |
|
1313 \ |
|
1314 return(*this); \ |
|
1315 } |
|
1316 #else |
|
1317 #define BOOST_OCTONION_MEMBER_DIV_GENERATOR_4(type) \ |
|
1318 template<typename X> \ |
|
1319 octonion<type> & operator /= (octonion<X> const & rhs) \ |
|
1320 { \ |
|
1321 using ::std::valarray; \ |
|
1322 \ |
|
1323 valarray<type> tr(8); \ |
|
1324 \ |
|
1325 tr[0] = static_cast<type>(rhs.R_component_1()); \ |
|
1326 tr[1] = static_cast<type>(rhs.R_component_2()); \ |
|
1327 tr[2] = static_cast<type>(rhs.R_component_3()); \ |
|
1328 tr[3] = static_cast<type>(rhs.R_component_4()); \ |
|
1329 tr[4] = static_cast<type>(rhs.R_component_5()); \ |
|
1330 tr[5] = static_cast<type>(rhs.R_component_6()); \ |
|
1331 tr[6] = static_cast<type>(rhs.R_component_7()); \ |
|
1332 tr[7] = static_cast<type>(rhs.R_component_8()); \ |
|
1333 \ |
|
1334 type mixam = static_cast<type>(1)/(abs(tr).max)(); \ |
|
1335 \ |
|
1336 tr *= mixam; \ |
|
1337 \ |
|
1338 valarray<type> tt(8); \ |
|
1339 \ |
|
1340 tt[0] = +a*tr[0]+b*tr[1]+c*tr[2]+d*tr[3]+e*tr[4]+f*tr[5]+g*tr[6]+h*tr[7]; \ |
|
1341 tt[1] = -a*tr[1]+b*tr[0]-c*tr[3]+d*tr[2]-e*tr[5]+f*tr[4]+g*tr[7]-h*tr[6]; \ |
|
1342 tt[2] = -a*tr[2]+b*tr[3]+c*tr[0]-d*tr[1]-e*tr[6]-f*tr[7]+g*tr[4]+h*tr[5]; \ |
|
1343 tt[3] = -a*tr[3]-b*tr[2]+c*tr[1]+d*tr[0]-e*tr[7]+f*tr[6]-g*tr[5]+h*tr[4]; \ |
|
1344 tt[4] = -a*tr[4]+b*tr[5]+c*tr[6]+d*tr[7]+e*tr[0]-f*tr[1]-g*tr[2]-h*tr[3]; \ |
|
1345 tt[5] = -a*tr[5]-b*tr[4]+c*tr[7]-d*tr[6]+e*tr[1]+f*tr[0]+g*tr[3]-h*tr[2]; \ |
|
1346 tt[6] = -a*tr[6]-b*tr[7]-c*tr[4]+d*tr[5]+e*tr[2]-f*tr[3]+g*tr[0]+h*tr[1]; \ |
|
1347 tt[7] = -a*tr[7]+b*tr[6]-c*tr[5]-d*tr[4]+e*tr[3]+f*tr[2]-g*tr[1]+h*tr[0]; \ |
|
1348 \ |
|
1349 tr *= tr; \ |
|
1350 \ |
|
1351 tt *= (mixam/tr.sum()); \ |
|
1352 \ |
|
1353 a = tt[0]; \ |
|
1354 b = tt[1]; \ |
|
1355 c = tt[2]; \ |
|
1356 d = tt[3]; \ |
|
1357 e = tt[4]; \ |
|
1358 f = tt[5]; \ |
|
1359 g = tt[6]; \ |
|
1360 h = tt[7]; \ |
|
1361 \ |
|
1362 return(*this); \ |
|
1363 } |
|
1364 #endif /* defined(__GNUC__) && (__GNUC__ < 3) */ /* BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP */ |
|
1365 |
|
1366 |
|
1367 #define BOOST_OCTONION_MEMBER_ADD_GENERATOR(type) \ |
|
1368 BOOST_OCTONION_MEMBER_ADD_GENERATOR_1(type) \ |
|
1369 BOOST_OCTONION_MEMBER_ADD_GENERATOR_2(type) \ |
|
1370 BOOST_OCTONION_MEMBER_ADD_GENERATOR_3(type) \ |
|
1371 BOOST_OCTONION_MEMBER_ADD_GENERATOR_4(type) |
|
1372 |
|
1373 #define BOOST_OCTONION_MEMBER_SUB_GENERATOR(type) \ |
|
1374 BOOST_OCTONION_MEMBER_SUB_GENERATOR_1(type) \ |
|
1375 BOOST_OCTONION_MEMBER_SUB_GENERATOR_2(type) \ |
|
1376 BOOST_OCTONION_MEMBER_SUB_GENERATOR_3(type) \ |
|
1377 BOOST_OCTONION_MEMBER_SUB_GENERATOR_4(type) |
|
1378 |
|
1379 #define BOOST_OCTONION_MEMBER_MUL_GENERATOR(type) \ |
|
1380 BOOST_OCTONION_MEMBER_MUL_GENERATOR_1(type) \ |
|
1381 BOOST_OCTONION_MEMBER_MUL_GENERATOR_2(type) \ |
|
1382 BOOST_OCTONION_MEMBER_MUL_GENERATOR_3(type) \ |
|
1383 BOOST_OCTONION_MEMBER_MUL_GENERATOR_4(type) |
|
1384 |
|
1385 #define BOOST_OCTONION_MEMBER_DIV_GENERATOR(type) \ |
|
1386 BOOST_OCTONION_MEMBER_DIV_GENERATOR_1(type) \ |
|
1387 BOOST_OCTONION_MEMBER_DIV_GENERATOR_2(type) \ |
|
1388 BOOST_OCTONION_MEMBER_DIV_GENERATOR_3(type) \ |
|
1389 BOOST_OCTONION_MEMBER_DIV_GENERATOR_4(type) |
|
1390 |
|
1391 #define BOOST_OCTONION_MEMBER_ALGEBRAIC_GENERATOR(type) \ |
|
1392 BOOST_OCTONION_MEMBER_ADD_GENERATOR(type) \ |
|
1393 BOOST_OCTONION_MEMBER_SUB_GENERATOR(type) \ |
|
1394 BOOST_OCTONION_MEMBER_MUL_GENERATOR(type) \ |
|
1395 BOOST_OCTONION_MEMBER_DIV_GENERATOR(type) |
|
1396 |
|
1397 |
|
1398 template<> |
|
1399 class octonion<float> |
|
1400 { |
|
1401 public: |
|
1402 |
|
1403 typedef float value_type; |
|
1404 |
|
1405 BOOST_OCTONION_CONSTRUCTOR_GENERATOR(float) |
|
1406 |
|
1407 // UNtemplated copy constructor |
|
1408 // (this is taken care of by the compiler itself) |
|
1409 |
|
1410 // explicit copy constructors (precision-loosing converters) |
|
1411 |
|
1412 explicit octonion(octonion<double> const & a_recopier) |
|
1413 { |
|
1414 *this = detail::octonion_type_converter<float, double>(a_recopier); |
|
1415 } |
|
1416 |
|
1417 explicit octonion(octonion<long double> const & a_recopier) |
|
1418 { |
|
1419 *this = detail::octonion_type_converter<float, long double>(a_recopier); |
|
1420 } |
|
1421 |
|
1422 // destructor |
|
1423 // (this is taken care of by the compiler itself) |
|
1424 |
|
1425 // accessors |
|
1426 // |
|
1427 // Note: Like complex number, octonions do have a meaningful notion of "real part", |
|
1428 // but unlike them there is no meaningful notion of "imaginary part". |
|
1429 // Instead there is an "unreal part" which itself is an octonion, and usually |
|
1430 // nothing simpler (as opposed to the complex number case). |
|
1431 // However, for practicallity, there are accessors for the other components |
|
1432 // (these are necessary for the templated copy constructor, for instance). |
|
1433 |
|
1434 BOOST_OCTONION_ACCESSOR_GENERATOR(float) |
|
1435 |
|
1436 // assignment operators |
|
1437 |
|
1438 BOOST_OCTONION_MEMBER_ASSIGNMENT_GENERATOR(float) |
|
1439 |
|
1440 // other assignment-related operators |
|
1441 // |
|
1442 // NOTE: Octonion multiplication is *NOT* commutative; |
|
1443 // symbolically, "q *= rhs;" means "q = q * rhs;" |
|
1444 // and "q /= rhs;" means "q = q * inverse_of(rhs);"; |
|
1445 // octonion multiplication is also *NOT* associative |
|
1446 |
|
1447 BOOST_OCTONION_MEMBER_ALGEBRAIC_GENERATOR(float) |
|
1448 |
|
1449 |
|
1450 protected: |
|
1451 |
|
1452 BOOST_OCTONION_MEMBER_DATA_GENERATOR(float) |
|
1453 |
|
1454 |
|
1455 private: |
|
1456 |
|
1457 }; |
|
1458 |
|
1459 |
|
1460 template<> |
|
1461 class octonion<double> |
|
1462 { |
|
1463 public: |
|
1464 |
|
1465 typedef double value_type; |
|
1466 |
|
1467 BOOST_OCTONION_CONSTRUCTOR_GENERATOR(double) |
|
1468 |
|
1469 // UNtemplated copy constructor |
|
1470 // (this is taken care of by the compiler itself) |
|
1471 |
|
1472 // converting copy constructor |
|
1473 |
|
1474 explicit octonion(octonion<float> const & a_recopier) |
|
1475 { |
|
1476 *this = detail::octonion_type_converter<double, float>(a_recopier); |
|
1477 } |
|
1478 |
|
1479 // explicit copy constructors (precision-loosing converters) |
|
1480 |
|
1481 explicit octonion(octonion<long double> const & a_recopier) |
|
1482 { |
|
1483 *this = detail::octonion_type_converter<double, long double>(a_recopier); |
|
1484 } |
|
1485 |
|
1486 // destructor |
|
1487 // (this is taken care of by the compiler itself) |
|
1488 |
|
1489 // accessors |
|
1490 // |
|
1491 // Note: Like complex number, octonions do have a meaningful notion of "real part", |
|
1492 // but unlike them there is no meaningful notion of "imaginary part". |
|
1493 // Instead there is an "unreal part" which itself is an octonion, and usually |
|
1494 // nothing simpler (as opposed to the complex number case). |
|
1495 // However, for practicallity, there are accessors for the other components |
|
1496 // (these are necessary for the templated copy constructor, for instance). |
|
1497 |
|
1498 BOOST_OCTONION_ACCESSOR_GENERATOR(double) |
|
1499 |
|
1500 // assignment operators |
|
1501 |
|
1502 BOOST_OCTONION_MEMBER_ASSIGNMENT_GENERATOR(double) |
|
1503 |
|
1504 // other assignment-related operators |
|
1505 // |
|
1506 // NOTE: Octonion multiplication is *NOT* commutative; |
|
1507 // symbolically, "q *= rhs;" means "q = q * rhs;" |
|
1508 // and "q /= rhs;" means "q = q * inverse_of(rhs);"; |
|
1509 // octonion multiplication is also *NOT* associative |
|
1510 |
|
1511 BOOST_OCTONION_MEMBER_ALGEBRAIC_GENERATOR(double) |
|
1512 |
|
1513 |
|
1514 protected: |
|
1515 |
|
1516 BOOST_OCTONION_MEMBER_DATA_GENERATOR(double) |
|
1517 |
|
1518 |
|
1519 private: |
|
1520 |
|
1521 }; |
|
1522 |
|
1523 |
|
1524 template<> |
|
1525 class octonion<long double> |
|
1526 { |
|
1527 public: |
|
1528 |
|
1529 typedef long double value_type; |
|
1530 |
|
1531 BOOST_OCTONION_CONSTRUCTOR_GENERATOR(long double) |
|
1532 |
|
1533 // UNtemplated copy constructor |
|
1534 // (this is taken care of by the compiler itself) |
|
1535 |
|
1536 // converting copy constructor |
|
1537 |
|
1538 explicit octonion(octonion<float> const & a_recopier) |
|
1539 { |
|
1540 *this = detail::octonion_type_converter<long double, float>(a_recopier); |
|
1541 } |
|
1542 |
|
1543 |
|
1544 explicit octonion(octonion<double> const & a_recopier) |
|
1545 { |
|
1546 *this = detail::octonion_type_converter<long double, double>(a_recopier); |
|
1547 } |
|
1548 |
|
1549 |
|
1550 // destructor |
|
1551 // (this is taken care of by the compiler itself) |
|
1552 |
|
1553 // accessors |
|
1554 // |
|
1555 // Note: Like complex number, octonions do have a meaningful notion of "real part", |
|
1556 // but unlike them there is no meaningful notion of "imaginary part". |
|
1557 // Instead there is an "unreal part" which itself is an octonion, and usually |
|
1558 // nothing simpler (as opposed to the complex number case). |
|
1559 // However, for practicallity, there are accessors for the other components |
|
1560 // (these are necessary for the templated copy constructor, for instance). |
|
1561 |
|
1562 BOOST_OCTONION_ACCESSOR_GENERATOR(long double) |
|
1563 |
|
1564 // assignment operators |
|
1565 |
|
1566 BOOST_OCTONION_MEMBER_ASSIGNMENT_GENERATOR(long double) |
|
1567 |
|
1568 // other assignment-related operators |
|
1569 // |
|
1570 // NOTE: Octonion multiplication is *NOT* commutative; |
|
1571 // symbolically, "q *= rhs;" means "q = q * rhs;" |
|
1572 // and "q /= rhs;" means "q = q * inverse_of(rhs);"; |
|
1573 // octonion multiplication is also *NOT* associative |
|
1574 |
|
1575 BOOST_OCTONION_MEMBER_ALGEBRAIC_GENERATOR(long double) |
|
1576 |
|
1577 |
|
1578 protected: |
|
1579 |
|
1580 BOOST_OCTONION_MEMBER_DATA_GENERATOR(long double) |
|
1581 |
|
1582 |
|
1583 private: |
|
1584 |
|
1585 }; |
|
1586 |
|
1587 |
|
1588 #undef BOOST_OCTONION_CONSTRUCTOR_GENERATOR |
|
1589 |
|
1590 #undef BOOST_OCTONION_MEMBER_ALGEBRAIC_GENERATOR |
|
1591 |
|
1592 #undef BOOST_OCTONION_MEMBER_ADD_GENERATOR |
|
1593 #undef BOOST_OCTONION_MEMBER_SUB_GENERATOR |
|
1594 #undef BOOST_OCTONION_MEMBER_MUL_GENERATOR |
|
1595 #undef BOOST_OCTONION_MEMBER_DIV_GENERATOR |
|
1596 |
|
1597 #undef BOOST_OCTONION_MEMBER_ADD_GENERATOR_1 |
|
1598 #undef BOOST_OCTONION_MEMBER_ADD_GENERATOR_2 |
|
1599 #undef BOOST_OCTONION_MEMBER_ADD_GENERATOR_3 |
|
1600 #undef BOOST_OCTONION_MEMBER_ADD_GENERATOR_4 |
|
1601 #undef BOOST_OCTONION_MEMBER_SUB_GENERATOR_1 |
|
1602 #undef BOOST_OCTONION_MEMBER_SUB_GENERATOR_2 |
|
1603 #undef BOOST_OCTONION_MEMBER_SUB_GENERATOR_3 |
|
1604 #undef BOOST_OCTONION_MEMBER_SUB_GENERATOR_4 |
|
1605 #undef BOOST_OCTONION_MEMBER_MUL_GENERATOR_1 |
|
1606 #undef BOOST_OCTONION_MEMBER_MUL_GENERATOR_2 |
|
1607 #undef BOOST_OCTONION_MEMBER_MUL_GENERATOR_3 |
|
1608 #undef BOOST_OCTONION_MEMBER_MUL_GENERATOR_4 |
|
1609 #undef BOOST_OCTONION_MEMBER_DIV_GENERATOR_1 |
|
1610 #undef BOOST_OCTONION_MEMBER_DIV_GENERATOR_2 |
|
1611 #undef BOOST_OCTONION_MEMBER_DIV_GENERATOR_3 |
|
1612 #undef BOOST_OCTONION_MEMBER_DIV_GENERATOR_4 |
|
1613 |
|
1614 |
|
1615 #undef BOOST_OCTONION_MEMBER_DATA_GENERATOR |
|
1616 |
|
1617 #undef BOOST_OCTONION_MEMBER_ASSIGNMENT_GENERATOR |
|
1618 |
|
1619 #undef BOOST_OCTONION_ACCESSOR_GENERATOR |
|
1620 |
|
1621 |
|
1622 // operators |
|
1623 |
|
1624 #define BOOST_OCTONION_OPERATOR_GENERATOR_BODY(op) \ |
|
1625 { \ |
|
1626 octonion<T> res(lhs); \ |
|
1627 res op##= rhs; \ |
|
1628 return(res); \ |
|
1629 } |
|
1630 |
|
1631 #define BOOST_OCTONION_OPERATOR_GENERATOR_1_L(op) \ |
|
1632 template<typename T> \ |
|
1633 inline octonion<T> operator op (T const & lhs, octonion<T> const & rhs) \ |
|
1634 BOOST_OCTONION_OPERATOR_GENERATOR_BODY(op) |
|
1635 |
|
1636 #define BOOST_OCTONION_OPERATOR_GENERATOR_1_R(op) \ |
|
1637 template<typename T> \ |
|
1638 inline octonion<T> operator op (octonion<T> const & lhs, T const & rhs) \ |
|
1639 BOOST_OCTONION_OPERATOR_GENERATOR_BODY(op) |
|
1640 |
|
1641 #define BOOST_OCTONION_OPERATOR_GENERATOR_2_L(op) \ |
|
1642 template<typename T> \ |
|
1643 inline octonion<T> operator op (::std::complex<T> const & lhs, octonion<T> const & rhs) \ |
|
1644 BOOST_OCTONION_OPERATOR_GENERATOR_BODY(op) |
|
1645 |
|
1646 #define BOOST_OCTONION_OPERATOR_GENERATOR_2_R(op) \ |
|
1647 template<typename T> \ |
|
1648 inline octonion<T> operator op (octonion<T> const & lhs, ::std::complex<T> const & rhs) \ |
|
1649 BOOST_OCTONION_OPERATOR_GENERATOR_BODY(op) |
|
1650 |
|
1651 #define BOOST_OCTONION_OPERATOR_GENERATOR_3_L(op) \ |
|
1652 template<typename T> \ |
|
1653 inline octonion<T> operator op (::boost::math::quaternion<T> const & lhs, octonion<T> const & rhs) \ |
|
1654 BOOST_OCTONION_OPERATOR_GENERATOR_BODY(op) |
|
1655 |
|
1656 #define BOOST_OCTONION_OPERATOR_GENERATOR_3_R(op) \ |
|
1657 template<typename T> \ |
|
1658 inline octonion<T> operator op (octonion<T> const & lhs, ::boost::math::quaternion<T> const & rhs) \ |
|
1659 BOOST_OCTONION_OPERATOR_GENERATOR_BODY(op) |
|
1660 |
|
1661 #define BOOST_OCTONION_OPERATOR_GENERATOR_4(op) \ |
|
1662 template<typename T> \ |
|
1663 inline octonion<T> operator op (octonion<T> const & lhs, octonion<T> const & rhs) \ |
|
1664 BOOST_OCTONION_OPERATOR_GENERATOR_BODY(op) |
|
1665 |
|
1666 #define BOOST_OCTONION_OPERATOR_GENERATOR(op) \ |
|
1667 BOOST_OCTONION_OPERATOR_GENERATOR_1_L(op) \ |
|
1668 BOOST_OCTONION_OPERATOR_GENERATOR_1_R(op) \ |
|
1669 BOOST_OCTONION_OPERATOR_GENERATOR_2_L(op) \ |
|
1670 BOOST_OCTONION_OPERATOR_GENERATOR_2_R(op) \ |
|
1671 BOOST_OCTONION_OPERATOR_GENERATOR_3_L(op) \ |
|
1672 BOOST_OCTONION_OPERATOR_GENERATOR_3_R(op) \ |
|
1673 BOOST_OCTONION_OPERATOR_GENERATOR_4(op) |
|
1674 |
|
1675 |
|
1676 BOOST_OCTONION_OPERATOR_GENERATOR(+) |
|
1677 BOOST_OCTONION_OPERATOR_GENERATOR(-) |
|
1678 BOOST_OCTONION_OPERATOR_GENERATOR(*) |
|
1679 BOOST_OCTONION_OPERATOR_GENERATOR(/) |
|
1680 |
|
1681 |
|
1682 #undef BOOST_OCTONION_OPERATOR_GENERATOR |
|
1683 |
|
1684 #undef BOOST_OCTONION_OPERATOR_GENERATOR_1_L |
|
1685 #undef BOOST_OCTONION_OPERATOR_GENERATOR_1_R |
|
1686 #undef BOOST_OCTONION_OPERATOR_GENERATOR_2_L |
|
1687 #undef BOOST_OCTONION_OPERATOR_GENERATOR_2_R |
|
1688 #undef BOOST_OCTONION_OPERATOR_GENERATOR_3_L |
|
1689 #undef BOOST_OCTONION_OPERATOR_GENERATOR_3_R |
|
1690 #undef BOOST_OCTONION_OPERATOR_GENERATOR_4 |
|
1691 |
|
1692 #undef BOOST_OCTONION_OPERATOR_GENERATOR_BODY |
|
1693 |
|
1694 |
|
1695 template<typename T> |
|
1696 inline octonion<T> operator + (octonion<T> const & o) |
|
1697 { |
|
1698 return(o); |
|
1699 } |
|
1700 |
|
1701 |
|
1702 template<typename T> |
|
1703 inline octonion<T> operator - (octonion<T> const & o) |
|
1704 { |
|
1705 return(octonion<T>(-o.R_component_1(),-o.R_component_2(),-o.R_component_3(),-o.R_component_4(),-o.R_component_5(),-o.R_component_6(),-o.R_component_7(),-o.R_component_8())); |
|
1706 } |
|
1707 |
|
1708 |
|
1709 template<typename T> |
|
1710 inline bool operator == (T const & lhs, octonion<T> const & rhs) |
|
1711 { |
|
1712 return( |
|
1713 (rhs.R_component_1() == lhs)&& |
|
1714 (rhs.R_component_2() == static_cast<T>(0))&& |
|
1715 (rhs.R_component_3() == static_cast<T>(0))&& |
|
1716 (rhs.R_component_4() == static_cast<T>(0))&& |
|
1717 (rhs.R_component_5() == static_cast<T>(0))&& |
|
1718 (rhs.R_component_6() == static_cast<T>(0))&& |
|
1719 (rhs.R_component_7() == static_cast<T>(0))&& |
|
1720 (rhs.R_component_8() == static_cast<T>(0)) |
|
1721 ); |
|
1722 } |
|
1723 |
|
1724 |
|
1725 template<typename T> |
|
1726 inline bool operator == (octonion<T> const & lhs, T const & rhs) |
|
1727 { |
|
1728 return( |
|
1729 (lhs.R_component_1() == rhs)&& |
|
1730 (lhs.R_component_2() == static_cast<T>(0))&& |
|
1731 (lhs.R_component_3() == static_cast<T>(0))&& |
|
1732 (lhs.R_component_4() == static_cast<T>(0))&& |
|
1733 (lhs.R_component_5() == static_cast<T>(0))&& |
|
1734 (lhs.R_component_6() == static_cast<T>(0))&& |
|
1735 (lhs.R_component_7() == static_cast<T>(0))&& |
|
1736 (lhs.R_component_8() == static_cast<T>(0)) |
|
1737 ); |
|
1738 } |
|
1739 |
|
1740 |
|
1741 template<typename T> |
|
1742 inline bool operator == (::std::complex<T> const & lhs, octonion<T> const & rhs) |
|
1743 { |
|
1744 return( |
|
1745 (rhs.R_component_1() == lhs.real())&& |
|
1746 (rhs.R_component_2() == lhs.imag())&& |
|
1747 (rhs.R_component_3() == static_cast<T>(0))&& |
|
1748 (rhs.R_component_4() == static_cast<T>(0))&& |
|
1749 (rhs.R_component_5() == static_cast<T>(0))&& |
|
1750 (rhs.R_component_6() == static_cast<T>(0))&& |
|
1751 (rhs.R_component_7() == static_cast<T>(0))&& |
|
1752 (rhs.R_component_8() == static_cast<T>(0)) |
|
1753 ); |
|
1754 } |
|
1755 |
|
1756 |
|
1757 template<typename T> |
|
1758 inline bool operator == (octonion<T> const & lhs, ::std::complex<T> const & rhs) |
|
1759 { |
|
1760 return( |
|
1761 (lhs.R_component_1() == rhs.real())&& |
|
1762 (lhs.R_component_2() == rhs.imag())&& |
|
1763 (lhs.R_component_3() == static_cast<T>(0))&& |
|
1764 (lhs.R_component_4() == static_cast<T>(0))&& |
|
1765 (lhs.R_component_5() == static_cast<T>(0))&& |
|
1766 (lhs.R_component_6() == static_cast<T>(0))&& |
|
1767 (lhs.R_component_7() == static_cast<T>(0))&& |
|
1768 (lhs.R_component_8() == static_cast<T>(0)) |
|
1769 ); |
|
1770 } |
|
1771 |
|
1772 |
|
1773 template<typename T> |
|
1774 inline bool operator == (::boost::math::quaternion<T> const & lhs, octonion<T> const & rhs) |
|
1775 { |
|
1776 return( |
|
1777 (rhs.R_component_1() == lhs.R_component_1())&& |
|
1778 (rhs.R_component_2() == lhs.R_component_2())&& |
|
1779 (rhs.R_component_3() == lhs.R_component_3())&& |
|
1780 (rhs.R_component_4() == lhs.R_component_4())&& |
|
1781 (rhs.R_component_5() == static_cast<T>(0))&& |
|
1782 (rhs.R_component_6() == static_cast<T>(0))&& |
|
1783 (rhs.R_component_7() == static_cast<T>(0))&& |
|
1784 (rhs.R_component_8() == static_cast<T>(0)) |
|
1785 ); |
|
1786 } |
|
1787 |
|
1788 |
|
1789 template<typename T> |
|
1790 inline bool operator == (octonion<T> const & lhs, ::boost::math::quaternion<T> const & rhs) |
|
1791 { |
|
1792 return( |
|
1793 (lhs.R_component_1() == rhs.R_component_1())&& |
|
1794 (lhs.R_component_2() == rhs.R_component_2())&& |
|
1795 (lhs.R_component_3() == rhs.R_component_3())&& |
|
1796 (lhs.R_component_4() == rhs.R_component_4())&& |
|
1797 (lhs.R_component_5() == static_cast<T>(0))&& |
|
1798 (lhs.R_component_6() == static_cast<T>(0))&& |
|
1799 (lhs.R_component_7() == static_cast<T>(0))&& |
|
1800 (lhs.R_component_8() == static_cast<T>(0)) |
|
1801 ); |
|
1802 } |
|
1803 |
|
1804 |
|
1805 template<typename T> |
|
1806 inline bool operator == (octonion<T> const & lhs, octonion<T> const & rhs) |
|
1807 { |
|
1808 return( |
|
1809 (rhs.R_component_1() == lhs.R_component_1())&& |
|
1810 (rhs.R_component_2() == lhs.R_component_2())&& |
|
1811 (rhs.R_component_3() == lhs.R_component_3())&& |
|
1812 (rhs.R_component_4() == lhs.R_component_4())&& |
|
1813 (rhs.R_component_5() == lhs.R_component_5())&& |
|
1814 (rhs.R_component_6() == lhs.R_component_6())&& |
|
1815 (rhs.R_component_7() == lhs.R_component_7())&& |
|
1816 (rhs.R_component_8() == lhs.R_component_8()) |
|
1817 ); |
|
1818 } |
|
1819 |
|
1820 |
|
1821 #define BOOST_OCTONION_NOT_EQUAL_GENERATOR \ |
|
1822 { \ |
|
1823 return(!(lhs == rhs)); \ |
|
1824 } |
|
1825 |
|
1826 template<typename T> |
|
1827 inline bool operator != (T const & lhs, octonion<T> const & rhs) |
|
1828 BOOST_OCTONION_NOT_EQUAL_GENERATOR |
|
1829 |
|
1830 template<typename T> |
|
1831 inline bool operator != (octonion<T> const & lhs, T const & rhs) |
|
1832 BOOST_OCTONION_NOT_EQUAL_GENERATOR |
|
1833 |
|
1834 template<typename T> |
|
1835 inline bool operator != (::std::complex<T> const & lhs, octonion<T> const & rhs) |
|
1836 BOOST_OCTONION_NOT_EQUAL_GENERATOR |
|
1837 |
|
1838 template<typename T> |
|
1839 inline bool operator != (octonion<T> const & lhs, ::std::complex<T> const & rhs) |
|
1840 BOOST_OCTONION_NOT_EQUAL_GENERATOR |
|
1841 |
|
1842 template<typename T> |
|
1843 inline bool operator != (::boost::math::quaternion<T> const & lhs, octonion<T> const & rhs) |
|
1844 BOOST_OCTONION_NOT_EQUAL_GENERATOR |
|
1845 |
|
1846 template<typename T> |
|
1847 inline bool operator != (octonion<T> const & lhs, ::boost::math::quaternion<T> const & rhs) |
|
1848 BOOST_OCTONION_NOT_EQUAL_GENERATOR |
|
1849 |
|
1850 template<typename T> |
|
1851 inline bool operator != (octonion<T> const & lhs, octonion<T> const & rhs) |
|
1852 BOOST_OCTONION_NOT_EQUAL_GENERATOR |
|
1853 |
|
1854 #undef BOOST_OCTONION_NOT_EQUAL_GENERATOR |
|
1855 |
|
1856 |
|
1857 // Note: the default values in the constructors of the complex and quaternions make for |
|
1858 // a very complex and ambiguous situation; we have made choices to disambiguate. |
|
1859 |
|
1860 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
1861 template<typename T> |
|
1862 ::std::istream & operator >> ( ::std::istream & is, |
|
1863 octonion<T>& o) |
|
1864 #else |
|
1865 template<typename T, typename charT, class traits> |
|
1866 ::std::basic_istream<charT,traits> & operator >> ( ::std::basic_istream<charT,traits> & is, |
|
1867 octonion<T> & o) |
|
1868 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
1869 { |
|
1870 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
1871 typedef char charT; |
|
1872 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
1873 |
|
1874 #ifdef BOOST_NO_STD_LOCALE |
|
1875 #else |
|
1876 const ::std::ctype<charT> & ct = ::std::use_facet< ::std::ctype<charT> >(is.getloc()); |
|
1877 #endif /* BOOST_NO_STD_LOCALE */ |
|
1878 |
|
1879 T a = T(); |
|
1880 T b = T(); |
|
1881 T c = T(); |
|
1882 T d = T(); |
|
1883 T e = T(); |
|
1884 T f = T(); |
|
1885 T g = T(); |
|
1886 T h = T(); |
|
1887 |
|
1888 ::std::complex<T> u = ::std::complex<T>(); |
|
1889 ::std::complex<T> v = ::std::complex<T>(); |
|
1890 ::std::complex<T> x = ::std::complex<T>(); |
|
1891 ::std::complex<T> y = ::std::complex<T>(); |
|
1892 |
|
1893 ::boost::math::quaternion<T> p = ::boost::math::quaternion<T>(); |
|
1894 ::boost::math::quaternion<T> q = ::boost::math::quaternion<T>(); |
|
1895 |
|
1896 charT ch = charT(); |
|
1897 char cc; |
|
1898 |
|
1899 is >> ch; // get the first lexeme |
|
1900 |
|
1901 if (!is.good()) goto finish; |
|
1902 |
|
1903 #ifdef BOOST_NO_STD_LOCALE |
|
1904 cc = ch; |
|
1905 #else |
|
1906 cc = ct.narrow(ch, char()); |
|
1907 #endif /* BOOST_NO_STD_LOCALE */ |
|
1908 |
|
1909 if (cc == '(') // read "(" |
|
1910 { |
|
1911 is >> ch; // get the second lexeme |
|
1912 |
|
1913 if (!is.good()) goto finish; |
|
1914 |
|
1915 #ifdef BOOST_NO_STD_LOCALE |
|
1916 cc = ch; |
|
1917 #else |
|
1918 cc = ct.narrow(ch, char()); |
|
1919 #endif /* BOOST_NO_STD_LOCALE */ |
|
1920 |
|
1921 if (cc == '(') // read "((" |
|
1922 { |
|
1923 is >> ch; // get the third lexeme |
|
1924 |
|
1925 if (!is.good()) goto finish; |
|
1926 |
|
1927 #ifdef BOOST_NO_STD_LOCALE |
|
1928 cc = ch; |
|
1929 #else |
|
1930 cc = ct.narrow(ch, char()); |
|
1931 #endif /* BOOST_NO_STD_LOCALE */ |
|
1932 |
|
1933 if (cc == '(') // read "(((" |
|
1934 { |
|
1935 is.putback(ch); |
|
1936 |
|
1937 is >> u; // read "((u" |
|
1938 |
|
1939 if (!is.good()) goto finish; |
|
1940 |
|
1941 is >> ch; // get the next lexeme |
|
1942 |
|
1943 if (!is.good()) goto finish; |
|
1944 |
|
1945 #ifdef BOOST_NO_STD_LOCALE |
|
1946 cc = ch; |
|
1947 #else |
|
1948 cc = ct.narrow(ch, char()); |
|
1949 #endif /* BOOST_NO_STD_LOCALE */ |
|
1950 |
|
1951 if (cc == ')') // read "((u)" |
|
1952 { |
|
1953 is >> ch; // get the next lexeme |
|
1954 |
|
1955 if (!is.good()) goto finish; |
|
1956 |
|
1957 #ifdef BOOST_NO_STD_LOCALE |
|
1958 cc = ch; |
|
1959 #else |
|
1960 cc = ct.narrow(ch, char()); |
|
1961 #endif /* BOOST_NO_STD_LOCALE */ |
|
1962 |
|
1963 if (cc == ')') // format: (((a))), (((a,b))) |
|
1964 { |
|
1965 o = octonion<T>(u); |
|
1966 } |
|
1967 else if (cc == ',') // read "((u)," |
|
1968 { |
|
1969 p = ::boost::math::quaternion<T>(u); |
|
1970 |
|
1971 is >> q; // read "((u),q" |
|
1972 |
|
1973 if (!is.good()) goto finish; |
|
1974 |
|
1975 is >> ch; // get the next lexeme |
|
1976 |
|
1977 if (!is.good()) goto finish; |
|
1978 |
|
1979 #ifdef BOOST_NO_STD_LOCALE |
|
1980 cc = ch; |
|
1981 #else |
|
1982 cc = ct.narrow(ch, char()); |
|
1983 #endif /* BOOST_NO_STD_LOCALE */ |
|
1984 |
|
1985 if (cc == ')') // format: (((a)),q), (((a,b)),q) |
|
1986 { |
|
1987 o = octonion<T>(p,q); |
|
1988 } |
|
1989 else // error |
|
1990 { |
|
1991 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
1992 is.setstate(::std::ios::failbit); |
|
1993 #else |
|
1994 is.setstate(::std::ios_base::failbit); |
|
1995 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
1996 } |
|
1997 } |
|
1998 else // error |
|
1999 { |
|
2000 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
2001 is.setstate(::std::ios::failbit); |
|
2002 #else |
|
2003 is.setstate(::std::ios_base::failbit); |
|
2004 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
2005 } |
|
2006 } |
|
2007 else if (cc ==',') // read "((u," |
|
2008 { |
|
2009 is >> v; // read "((u,v" |
|
2010 |
|
2011 if (!is.good()) goto finish; |
|
2012 |
|
2013 is >> ch; // get the next lexeme |
|
2014 |
|
2015 if (!is.good()) goto finish; |
|
2016 |
|
2017 #ifdef BOOST_NO_STD_LOCALE |
|
2018 cc = ch; |
|
2019 #else |
|
2020 cc = ct.narrow(ch, char()); |
|
2021 #endif /* BOOST_NO_STD_LOCALE */ |
|
2022 |
|
2023 if (cc == ')') // read "((u,v)" |
|
2024 { |
|
2025 p = ::boost::math::quaternion<T>(u,v); |
|
2026 |
|
2027 is >> ch; // get the next lexeme |
|
2028 |
|
2029 if (!is.good()) goto finish; |
|
2030 |
|
2031 #ifdef BOOST_NO_STD_LOCALE |
|
2032 cc = ch; |
|
2033 #else |
|
2034 cc = ct.narrow(ch, char()); |
|
2035 #endif /* BOOST_NO_STD_LOCALE */ |
|
2036 |
|
2037 if (cc == ')') // format: (((a),v)), (((a,b),v)) |
|
2038 { |
|
2039 o = octonion<T>(p); |
|
2040 } |
|
2041 else if (cc == ',') // read "((u,v)," |
|
2042 { |
|
2043 is >> q; // read "(p,q" |
|
2044 |
|
2045 if (!is.good()) goto finish; |
|
2046 |
|
2047 is >> ch; // get the next lexeme |
|
2048 |
|
2049 if (!is.good()) goto finish; |
|
2050 |
|
2051 #ifdef BOOST_NO_STD_LOCALE |
|
2052 cc = ch; |
|
2053 #else |
|
2054 cc = ct.narrow(ch, char()); |
|
2055 #endif /* BOOST_NO_STD_LOCALE */ |
|
2056 |
|
2057 if (cc == ')') // format: (((a),v),q), (((a,b),v),q) |
|
2058 { |
|
2059 o = octonion<T>(p,q); |
|
2060 } |
|
2061 else // error |
|
2062 { |
|
2063 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
2064 is.setstate(::std::ios::failbit); |
|
2065 #else |
|
2066 is.setstate(::std::ios_base::failbit); |
|
2067 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
2068 } |
|
2069 } |
|
2070 else // error |
|
2071 { |
|
2072 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
2073 is.setstate(::std::ios::failbit); |
|
2074 #else |
|
2075 is.setstate(::std::ios_base::failbit); |
|
2076 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
2077 } |
|
2078 } |
|
2079 else // error |
|
2080 { |
|
2081 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
2082 is.setstate(::std::ios::failbit); |
|
2083 #else |
|
2084 is.setstate(::std::ios_base::failbit); |
|
2085 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
2086 } |
|
2087 } |
|
2088 else // error |
|
2089 { |
|
2090 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
2091 is.setstate(::std::ios::failbit); |
|
2092 #else |
|
2093 is.setstate(::std::ios_base::failbit); |
|
2094 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
2095 } |
|
2096 } |
|
2097 else // read "((a" |
|
2098 { |
|
2099 is.putback(ch); |
|
2100 |
|
2101 is >> a; // we extract the first component |
|
2102 |
|
2103 if (!is.good()) goto finish; |
|
2104 |
|
2105 is >> ch; // get the next lexeme |
|
2106 |
|
2107 if (!is.good()) goto finish; |
|
2108 |
|
2109 #ifdef BOOST_NO_STD_LOCALE |
|
2110 cc = ch; |
|
2111 #else |
|
2112 cc = ct.narrow(ch, char()); |
|
2113 #endif /* BOOST_NO_STD_LOCALE */ |
|
2114 |
|
2115 if (cc == ')') // read "((a)" |
|
2116 { |
|
2117 is >> ch; // get the next lexeme |
|
2118 |
|
2119 if (!is.good()) goto finish; |
|
2120 |
|
2121 #ifdef BOOST_NO_STD_LOCALE |
|
2122 cc = ch; |
|
2123 #else |
|
2124 cc = ct.narrow(ch, char()); |
|
2125 #endif /* BOOST_NO_STD_LOCALE */ |
|
2126 |
|
2127 if (cc == ')') // read "((a))" |
|
2128 { |
|
2129 o = octonion<T>(a); |
|
2130 } |
|
2131 else if (cc == ',') // read "((a)," |
|
2132 { |
|
2133 is >> ch; // get the next lexeme |
|
2134 |
|
2135 if (!is.good()) goto finish; |
|
2136 |
|
2137 #ifdef BOOST_NO_STD_LOCALE |
|
2138 cc = ch; |
|
2139 #else |
|
2140 cc = ct.narrow(ch, char()); |
|
2141 #endif /* BOOST_NO_STD_LOCALE */ |
|
2142 |
|
2143 if (cc == '(') // read "((a),(" |
|
2144 { |
|
2145 is >> ch; // get the next lexeme |
|
2146 |
|
2147 if (!is.good()) goto finish; |
|
2148 |
|
2149 #ifdef BOOST_NO_STD_LOCALE |
|
2150 cc = ch; |
|
2151 #else |
|
2152 cc = ct.narrow(ch, char()); |
|
2153 #endif /* BOOST_NO_STD_LOCALE */ |
|
2154 |
|
2155 if (cc == '(') // read "((a),((" |
|
2156 { |
|
2157 is.putback(ch); |
|
2158 |
|
2159 is.putback(ch); // we backtrack twice, with the same value! |
|
2160 |
|
2161 is >> q; // read "((a),q" |
|
2162 |
|
2163 if (!is.good()) goto finish; |
|
2164 |
|
2165 is >> ch; // get the next lexeme |
|
2166 |
|
2167 if (!is.good()) goto finish; |
|
2168 |
|
2169 #ifdef BOOST_NO_STD_LOCALE |
|
2170 cc = ch; |
|
2171 #else |
|
2172 cc = ct.narrow(ch, char()); |
|
2173 #endif /* BOOST_NO_STD_LOCALE */ |
|
2174 |
|
2175 if (cc == ')') // read "((a),q)" |
|
2176 { |
|
2177 p = ::boost::math::quaternion<T>(a); |
|
2178 |
|
2179 o = octonion<T>(p,q); |
|
2180 } |
|
2181 else // error |
|
2182 { |
|
2183 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
2184 is.setstate(::std::ios::failbit); |
|
2185 #else |
|
2186 is.setstate(::std::ios_base::failbit); |
|
2187 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
2188 } |
|
2189 } |
|
2190 else // read "((a),(c" or "((a),(e" |
|
2191 { |
|
2192 is.putback(ch); |
|
2193 |
|
2194 is >> c; |
|
2195 |
|
2196 if (!is.good()) goto finish; |
|
2197 |
|
2198 is >> ch; // get the next lexeme |
|
2199 |
|
2200 if (!is.good()) goto finish; |
|
2201 |
|
2202 #ifdef BOOST_NO_STD_LOCALE |
|
2203 cc = ch; |
|
2204 #else |
|
2205 cc = ct.narrow(ch, char()); |
|
2206 #endif /* BOOST_NO_STD_LOCALE */ |
|
2207 |
|
2208 if (cc == ')') // read "((a),(c)" (ambiguity resolution) |
|
2209 { |
|
2210 is >> ch; // get the next lexeme |
|
2211 |
|
2212 if (!is.good()) goto finish; |
|
2213 |
|
2214 #ifdef BOOST_NO_STD_LOCALE |
|
2215 cc = ch; |
|
2216 #else |
|
2217 cc = ct.narrow(ch, char()); |
|
2218 #endif /* BOOST_NO_STD_LOCALE */ |
|
2219 |
|
2220 if (cc == ')') // read "((a),(c))" |
|
2221 { |
|
2222 o = octonion<T>(a,b,c); |
|
2223 } |
|
2224 else if (cc == ',') // read "((a),(c)," |
|
2225 { |
|
2226 u = ::std::complex<T>(a); |
|
2227 |
|
2228 v = ::std::complex<T>(c); |
|
2229 |
|
2230 is >> x; // read "((a),(c),x" |
|
2231 |
|
2232 if (!is.good()) goto finish; |
|
2233 |
|
2234 is >> ch; // get the next lexeme |
|
2235 |
|
2236 if (!is.good()) goto finish; |
|
2237 |
|
2238 #ifdef BOOST_NO_STD_LOCALE |
|
2239 cc = ch; |
|
2240 #else |
|
2241 cc = ct.narrow(ch, char()); |
|
2242 #endif /* BOOST_NO_STD_LOCALE */ |
|
2243 |
|
2244 if (cc == ')') // read "((a),(c),x)" |
|
2245 { |
|
2246 o = octonion<T>(u,v,x); |
|
2247 } |
|
2248 else if (cc == ',') // read "((a),(c),x," |
|
2249 { |
|
2250 is >> y; // read "((a),(c),x,y" |
|
2251 |
|
2252 if (!is.good()) goto finish; |
|
2253 |
|
2254 is >> ch; // get the next lexeme |
|
2255 |
|
2256 if (!is.good()) goto finish; |
|
2257 |
|
2258 #ifdef BOOST_NO_STD_LOCALE |
|
2259 cc = ch; |
|
2260 #else |
|
2261 cc = ct.narrow(ch, char()); |
|
2262 #endif /* BOOST_NO_STD_LOCALE */ |
|
2263 |
|
2264 if (cc == ')') // read "((a),(c),x,y)" |
|
2265 { |
|
2266 o = octonion<T>(u,v,x,y); |
|
2267 } |
|
2268 else // error |
|
2269 { |
|
2270 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
2271 is.setstate(::std::ios::failbit); |
|
2272 #else |
|
2273 is.setstate(::std::ios_base::failbit); |
|
2274 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
2275 } |
|
2276 } |
|
2277 else // error |
|
2278 { |
|
2279 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
2280 is.setstate(::std::ios::failbit); |
|
2281 #else |
|
2282 is.setstate(::std::ios_base::failbit); |
|
2283 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
2284 } |
|
2285 } |
|
2286 else // error |
|
2287 { |
|
2288 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
2289 is.setstate(::std::ios::failbit); |
|
2290 #else |
|
2291 is.setstate(::std::ios_base::failbit); |
|
2292 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
2293 } |
|
2294 } |
|
2295 else if (cc == ',') // read "((a),(c," or "((a),(e," |
|
2296 { |
|
2297 is >> ch; // get the next lexeme |
|
2298 |
|
2299 if (!is.good()) goto finish; |
|
2300 |
|
2301 #ifdef BOOST_NO_STD_LOCALE |
|
2302 cc = ch; |
|
2303 #else |
|
2304 cc = ct.narrow(ch, char()); |
|
2305 #endif /* BOOST_NO_STD_LOCALE */ |
|
2306 |
|
2307 if (cc == '(') // read "((a),(e,(" (ambiguity resolution) |
|
2308 { |
|
2309 p = ::boost::math::quaternion<T>(a); |
|
2310 |
|
2311 x = ::std::complex<T>(c); // "c" was actually "e" |
|
2312 |
|
2313 is.putback(ch); // we can only backtrace once |
|
2314 |
|
2315 is >> y; // read "((a),(e,y" |
|
2316 |
|
2317 if (!is.good()) goto finish; |
|
2318 |
|
2319 is >> ch; // get the next lexeme |
|
2320 |
|
2321 #ifdef BOOST_NO_STD_LOCALE |
|
2322 cc = ch; |
|
2323 #else |
|
2324 cc = ct.narrow(ch, char()); |
|
2325 #endif /* BOOST_NO_STD_LOCALE */ |
|
2326 |
|
2327 if (cc == ')') // read "((a),(e,y)" |
|
2328 { |
|
2329 q = ::boost::math::quaternion<T>(x,y); |
|
2330 |
|
2331 is >> ch; // get the next lexeme |
|
2332 |
|
2333 #ifdef BOOST_NO_STD_LOCALE |
|
2334 cc = ch; |
|
2335 #else |
|
2336 cc = ct.narrow(ch, char()); |
|
2337 #endif /* BOOST_NO_STD_LOCALE */ |
|
2338 |
|
2339 if (cc == ')') // read "((a),(e,y))" |
|
2340 { |
|
2341 o = octonion<T>(p,q); |
|
2342 } |
|
2343 else // error |
|
2344 { |
|
2345 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
2346 is.setstate(::std::ios::failbit); |
|
2347 #else |
|
2348 is.setstate(::std::ios_base::failbit); |
|
2349 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
2350 } |
|
2351 } |
|
2352 else // error |
|
2353 { |
|
2354 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
2355 is.setstate(::std::ios::failbit); |
|
2356 #else |
|
2357 is.setstate(::std::ios_base::failbit); |
|
2358 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
2359 } |
|
2360 } |
|
2361 else // read "((a),(c,d" or "((a),(e,f" |
|
2362 { |
|
2363 is.putback(ch); |
|
2364 |
|
2365 is >> d; |
|
2366 |
|
2367 if (!is.good()) goto finish; |
|
2368 |
|
2369 is >> ch; // get the next lexeme |
|
2370 |
|
2371 if (!is.good()) goto finish; |
|
2372 |
|
2373 #ifdef BOOST_NO_STD_LOCALE |
|
2374 cc = ch; |
|
2375 #else |
|
2376 cc = ct.narrow(ch, char()); |
|
2377 #endif /* BOOST_NO_STD_LOCALE */ |
|
2378 |
|
2379 if (cc == ')') // read "((a),(c,d)" (ambiguity resolution) |
|
2380 { |
|
2381 is >> ch; // get the next lexeme |
|
2382 |
|
2383 if (!is.good()) goto finish; |
|
2384 |
|
2385 #ifdef BOOST_NO_STD_LOCALE |
|
2386 cc = ch; |
|
2387 #else |
|
2388 cc = ct.narrow(ch, char()); |
|
2389 #endif /* BOOST_NO_STD_LOCALE */ |
|
2390 |
|
2391 if (cc == ')') // read "((a),(c,d))" |
|
2392 { |
|
2393 o = octonion<T>(a,b,c,d); |
|
2394 } |
|
2395 else if (cc == ',') // read "((a),(c,d)," |
|
2396 { |
|
2397 u = ::std::complex<T>(a); |
|
2398 |
|
2399 v = ::std::complex<T>(c,d); |
|
2400 |
|
2401 is >> x; // read "((a),(c,d),x" |
|
2402 |
|
2403 if (!is.good()) goto finish; |
|
2404 |
|
2405 is >> ch; // get the next lexeme |
|
2406 |
|
2407 if (!is.good()) goto finish; |
|
2408 |
|
2409 #ifdef BOOST_NO_STD_LOCALE |
|
2410 cc = ch; |
|
2411 #else |
|
2412 cc = ct.narrow(ch, char()); |
|
2413 #endif /* BOOST_NO_STD_LOCALE */ |
|
2414 |
|
2415 if (cc == ')') // read "((a),(c,d),x)" |
|
2416 { |
|
2417 o = octonion<T>(u,v,x); |
|
2418 } |
|
2419 else if (cc == ',') // read "((a),(c,d),x," |
|
2420 { |
|
2421 is >> y; // read "((a),(c,d),x,y" |
|
2422 |
|
2423 if (!is.good()) goto finish; |
|
2424 |
|
2425 is >> ch; // get the next lexeme |
|
2426 |
|
2427 if (!is.good()) goto finish; |
|
2428 |
|
2429 #ifdef BOOST_NO_STD_LOCALE |
|
2430 cc = ch; |
|
2431 #else |
|
2432 cc = ct.narrow(ch, char()); |
|
2433 #endif /* BOOST_NO_STD_LOCALE */ |
|
2434 |
|
2435 if (cc == ')') // read "((a),(c,d),x,y)" |
|
2436 { |
|
2437 o = octonion<T>(u,v,x,y); |
|
2438 } |
|
2439 else // error |
|
2440 { |
|
2441 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
2442 is.setstate(::std::ios::failbit); |
|
2443 #else |
|
2444 is.setstate(::std::ios_base::failbit); |
|
2445 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
2446 } |
|
2447 } |
|
2448 else // error |
|
2449 { |
|
2450 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
2451 is.setstate(::std::ios::failbit); |
|
2452 #else |
|
2453 is.setstate(::std::ios_base::failbit); |
|
2454 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
2455 } |
|
2456 } |
|
2457 else // error |
|
2458 { |
|
2459 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
2460 is.setstate(::std::ios::failbit); |
|
2461 #else |
|
2462 is.setstate(::std::ios_base::failbit); |
|
2463 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
2464 } |
|
2465 } |
|
2466 else if (cc == ',') // read "((a),(e,f," (ambiguity resolution) |
|
2467 { |
|
2468 p = ::boost::math::quaternion<T>(a); |
|
2469 |
|
2470 is >> g; // read "((a),(e,f,g" (too late to backtrack) |
|
2471 |
|
2472 if (!is.good()) goto finish; |
|
2473 |
|
2474 is >> ch; // get the next lexeme |
|
2475 |
|
2476 if (!is.good()) goto finish; |
|
2477 |
|
2478 #ifdef BOOST_NO_STD_LOCALE |
|
2479 cc = ch; |
|
2480 #else |
|
2481 cc = ct.narrow(ch, char()); |
|
2482 #endif /* BOOST_NO_STD_LOCALE */ |
|
2483 |
|
2484 if (cc == ')') // read "((a),(e,f,g)" |
|
2485 { |
|
2486 q = ::boost::math::quaternion<T>(c,d,g); // "c" was actually "e", and "d" was actually "f" |
|
2487 |
|
2488 is >> ch; // get the next lexeme |
|
2489 |
|
2490 if (!is.good()) goto finish; |
|
2491 |
|
2492 #ifdef BOOST_NO_STD_LOCALE |
|
2493 cc = ch; |
|
2494 #else |
|
2495 cc = ct.narrow(ch, char()); |
|
2496 #endif /* BOOST_NO_STD_LOCALE */ |
|
2497 |
|
2498 if (cc == ')') // read "((a),(e,f,g))" |
|
2499 { |
|
2500 o = octonion<T>(p,q); |
|
2501 } |
|
2502 else // error |
|
2503 { |
|
2504 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
2505 is.setstate(::std::ios::failbit); |
|
2506 #else |
|
2507 is.setstate(::std::ios_base::failbit); |
|
2508 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
2509 } |
|
2510 } |
|
2511 else if (cc == ',') // read "((a),(e,f,g," |
|
2512 { |
|
2513 is >> h; // read "((a),(e,f,g,h" |
|
2514 |
|
2515 if (!is.good()) goto finish; |
|
2516 |
|
2517 is >> ch; // get the next lexeme |
|
2518 |
|
2519 if (!is.good()) goto finish; |
|
2520 |
|
2521 #ifdef BOOST_NO_STD_LOCALE |
|
2522 cc = ch; |
|
2523 #else |
|
2524 cc = ct.narrow(ch, char()); |
|
2525 #endif /* BOOST_NO_STD_LOCALE */ |
|
2526 |
|
2527 if (cc == ')') // read "((a),(e,f,g,h)" |
|
2528 { |
|
2529 q = ::boost::math::quaternion<T>(c,d,g,h); // "c" was actually "e", and "d" was actually "f" |
|
2530 |
|
2531 is >> ch; // get the next lexeme |
|
2532 |
|
2533 if (!is.good()) goto finish; |
|
2534 |
|
2535 #ifdef BOOST_NO_STD_LOCALE |
|
2536 cc = ch; |
|
2537 #else |
|
2538 cc = ct.narrow(ch, char()); |
|
2539 #endif /* BOOST_NO_STD_LOCALE */ |
|
2540 |
|
2541 if (cc == ')') // read "((a),(e,f,g,h))" |
|
2542 { |
|
2543 o = octonion<T>(p,q); |
|
2544 } |
|
2545 else // error |
|
2546 { |
|
2547 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
2548 is.setstate(::std::ios::failbit); |
|
2549 #else |
|
2550 is.setstate(::std::ios_base::failbit); |
|
2551 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
2552 } |
|
2553 } |
|
2554 else // error |
|
2555 { |
|
2556 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
2557 is.setstate(::std::ios::failbit); |
|
2558 #else |
|
2559 is.setstate(::std::ios_base::failbit); |
|
2560 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
2561 } |
|
2562 } |
|
2563 else // error |
|
2564 { |
|
2565 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
2566 is.setstate(::std::ios::failbit); |
|
2567 #else |
|
2568 is.setstate(::std::ios_base::failbit); |
|
2569 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
2570 } |
|
2571 } |
|
2572 else // error |
|
2573 { |
|
2574 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
2575 is.setstate(::std::ios::failbit); |
|
2576 #else |
|
2577 is.setstate(::std::ios_base::failbit); |
|
2578 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
2579 } |
|
2580 } |
|
2581 } |
|
2582 else // error |
|
2583 { |
|
2584 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
2585 is.setstate(::std::ios::failbit); |
|
2586 #else |
|
2587 is.setstate(::std::ios_base::failbit); |
|
2588 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
2589 } |
|
2590 } |
|
2591 } |
|
2592 else // read "((a),c" (ambiguity resolution) |
|
2593 { |
|
2594 is.putback(ch); |
|
2595 |
|
2596 is >> c; // we extract the third component |
|
2597 |
|
2598 if (!is.good()) goto finish; |
|
2599 |
|
2600 is >> ch; // get the next lexeme |
|
2601 |
|
2602 if (!is.good()) goto finish; |
|
2603 |
|
2604 #ifdef BOOST_NO_STD_LOCALE |
|
2605 cc = ch; |
|
2606 #else |
|
2607 cc = ct.narrow(ch, char()); |
|
2608 #endif /* BOOST_NO_STD_LOCALE */ |
|
2609 |
|
2610 if (cc == ')') // read "((a),c)" |
|
2611 { |
|
2612 o = octonion<T>(a,b,c); |
|
2613 } |
|
2614 else if (cc == ',') // read "((a),c," |
|
2615 { |
|
2616 is >> x; // read "((a),c,x" |
|
2617 |
|
2618 if (!is.good()) goto finish; |
|
2619 |
|
2620 is >> ch; // get the next lexeme |
|
2621 |
|
2622 if (!is.good()) goto finish; |
|
2623 |
|
2624 #ifdef BOOST_NO_STD_LOCALE |
|
2625 cc = ch; |
|
2626 #else |
|
2627 cc = ct.narrow(ch, char()); |
|
2628 #endif /* BOOST_NO_STD_LOCALE */ |
|
2629 |
|
2630 if (cc == ')') // read "((a),c,x)" |
|
2631 { |
|
2632 o = octonion<T>(a,b,c,d,x.real(),x.imag()); |
|
2633 } |
|
2634 else if (cc == ',') // read "((a),c,x," |
|
2635 { |
|
2636 is >> y;if (!is.good()) goto finish; // read "((a),c,x,y" |
|
2637 |
|
2638 is >> ch; // get the next lexeme |
|
2639 |
|
2640 if (!is.good()) goto finish; |
|
2641 |
|
2642 #ifdef BOOST_NO_STD_LOCALE |
|
2643 cc = ch; |
|
2644 #else |
|
2645 cc = ct.narrow(ch, char()); |
|
2646 #endif /* BOOST_NO_STD_LOCALE */ |
|
2647 |
|
2648 if (cc == ')') // read "((a),c,x,y)" |
|
2649 { |
|
2650 o = octonion<T>(a,b,c,d,x.real(),x.imag(),y.real(),y.imag()); |
|
2651 } |
|
2652 else // error |
|
2653 { |
|
2654 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
2655 is.setstate(::std::ios::failbit); |
|
2656 #else |
|
2657 is.setstate(::std::ios_base::failbit); |
|
2658 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
2659 } |
|
2660 } |
|
2661 else // error |
|
2662 { |
|
2663 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
2664 is.setstate(::std::ios::failbit); |
|
2665 #else |
|
2666 is.setstate(::std::ios_base::failbit); |
|
2667 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
2668 } |
|
2669 } |
|
2670 else // error |
|
2671 { |
|
2672 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
2673 is.setstate(::std::ios::failbit); |
|
2674 #else |
|
2675 is.setstate(::std::ios_base::failbit); |
|
2676 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
2677 } |
|
2678 } |
|
2679 } |
|
2680 else // error |
|
2681 { |
|
2682 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
2683 is.setstate(::std::ios::failbit); |
|
2684 #else |
|
2685 is.setstate(::std::ios_base::failbit); |
|
2686 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
2687 } |
|
2688 } |
|
2689 else if (cc ==',') // read "((a," |
|
2690 { |
|
2691 is >> ch; // get the next lexeme |
|
2692 |
|
2693 if (!is.good()) goto finish; |
|
2694 |
|
2695 #ifdef BOOST_NO_STD_LOCALE |
|
2696 cc = ch; |
|
2697 #else |
|
2698 cc = ct.narrow(ch, char()); |
|
2699 #endif /* BOOST_NO_STD_LOCALE */ |
|
2700 |
|
2701 if (cc == '(') // read "((a,(" |
|
2702 { |
|
2703 u = ::std::complex<T>(a); |
|
2704 |
|
2705 is.putback(ch); // can only backtrack so much |
|
2706 |
|
2707 is >> v; // read "((a,v" |
|
2708 |
|
2709 if (!is.good()) goto finish; |
|
2710 |
|
2711 is >> ch; // get the next lexeme |
|
2712 |
|
2713 if (!is.good()) goto finish; |
|
2714 |
|
2715 #ifdef BOOST_NO_STD_LOCALE |
|
2716 cc = ch; |
|
2717 #else |
|
2718 cc = ct.narrow(ch, char()); |
|
2719 #endif /* BOOST_NO_STD_LOCALE */ |
|
2720 |
|
2721 if (cc == ')') // read "((a,v)" |
|
2722 { |
|
2723 is >> ch; // get the next lexeme |
|
2724 |
|
2725 if (!is.good()) goto finish; |
|
2726 |
|
2727 #ifdef BOOST_NO_STD_LOCALE |
|
2728 cc = ch; |
|
2729 #else |
|
2730 cc = ct.narrow(ch, char()); |
|
2731 #endif /* BOOST_NO_STD_LOCALE */ |
|
2732 |
|
2733 if (cc == ')') // read "((a,v))" |
|
2734 { |
|
2735 o = octonion<T>(u,v); |
|
2736 } |
|
2737 else if (cc == ',') // read "((a,v)," |
|
2738 { |
|
2739 p = ::boost::math::quaternion<T>(u,v); |
|
2740 |
|
2741 is >> q; // read "((a,v),q" |
|
2742 |
|
2743 if (!is.good()) goto finish; |
|
2744 |
|
2745 is >> ch; // get the next lexeme |
|
2746 |
|
2747 if (!is.good()) goto finish; |
|
2748 |
|
2749 #ifdef BOOST_NO_STD_LOCALE |
|
2750 cc = ch; |
|
2751 #else |
|
2752 cc = ct.narrow(ch, char()); |
|
2753 #endif /* BOOST_NO_STD_LOCALE */ |
|
2754 |
|
2755 if (cc == ')') // read "((a,v),q)" |
|
2756 { |
|
2757 o = octonion<T>(p,q); |
|
2758 } |
|
2759 else // error |
|
2760 { |
|
2761 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
2762 is.setstate(::std::ios::failbit); |
|
2763 #else |
|
2764 is.setstate(::std::ios_base::failbit); |
|
2765 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
2766 } |
|
2767 } |
|
2768 else // error |
|
2769 { |
|
2770 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
2771 is.setstate(::std::ios::failbit); |
|
2772 #else |
|
2773 is.setstate(::std::ios_base::failbit); |
|
2774 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
2775 } |
|
2776 } |
|
2777 else // error |
|
2778 { |
|
2779 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
2780 is.setstate(::std::ios::failbit); |
|
2781 #else |
|
2782 is.setstate(::std::ios_base::failbit); |
|
2783 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
2784 } |
|
2785 } |
|
2786 else |
|
2787 { |
|
2788 is.putback(ch); |
|
2789 |
|
2790 is >> b; // read "((a,b" |
|
2791 |
|
2792 if (!is.good()) goto finish; |
|
2793 |
|
2794 is >> ch; // get the next lexeme |
|
2795 |
|
2796 if (!is.good()) goto finish; |
|
2797 |
|
2798 #ifdef BOOST_NO_STD_LOCALE |
|
2799 cc = ch; |
|
2800 #else |
|
2801 cc = ct.narrow(ch, char()); |
|
2802 #endif /* BOOST_NO_STD_LOCALE */ |
|
2803 |
|
2804 if (cc == ')') // read "((a,b)" |
|
2805 { |
|
2806 is >> ch; // get the next lexeme |
|
2807 |
|
2808 if (!is.good()) goto finish; |
|
2809 |
|
2810 #ifdef BOOST_NO_STD_LOCALE |
|
2811 cc = ch; |
|
2812 #else |
|
2813 cc = ct.narrow(ch, char()); |
|
2814 #endif /* BOOST_NO_STD_LOCALE */ |
|
2815 |
|
2816 if (cc == ')') // read "((a,b))" |
|
2817 { |
|
2818 o = octonion<T>(a,b); |
|
2819 } |
|
2820 else if (cc == ',') // read "((a,b)," |
|
2821 { |
|
2822 is >> ch; // get the next lexeme |
|
2823 |
|
2824 if (!is.good()) goto finish; |
|
2825 |
|
2826 #ifdef BOOST_NO_STD_LOCALE |
|
2827 cc = ch; |
|
2828 #else |
|
2829 cc = ct.narrow(ch, char()); |
|
2830 #endif /* BOOST_NO_STD_LOCALE */ |
|
2831 |
|
2832 if (cc == '(') // read "((a,b),(" |
|
2833 { |
|
2834 is >> ch; // get the next lexeme |
|
2835 |
|
2836 if (!is.good()) goto finish; |
|
2837 |
|
2838 #ifdef BOOST_NO_STD_LOCALE |
|
2839 cc = ch; |
|
2840 #else |
|
2841 cc = ct.narrow(ch, char()); |
|
2842 #endif /* BOOST_NO_STD_LOCALE */ |
|
2843 |
|
2844 if (cc == '(') // read "((a,b),((" |
|
2845 { |
|
2846 p = ::boost::math::quaternion<T>(a,b); |
|
2847 |
|
2848 is.putback(ch); |
|
2849 |
|
2850 is.putback(ch); // we backtrack twice, with the same value |
|
2851 |
|
2852 is >> q; // read "((a,b),q" |
|
2853 |
|
2854 if (!is.good()) goto finish; |
|
2855 |
|
2856 is >> ch; // get the next lexeme |
|
2857 |
|
2858 if (!is.good()) goto finish; |
|
2859 |
|
2860 #ifdef BOOST_NO_STD_LOCALE |
|
2861 cc = ch; |
|
2862 #else |
|
2863 cc = ct.narrow(ch, char()); |
|
2864 #endif /* BOOST_NO_STD_LOCALE */ |
|
2865 |
|
2866 if (cc == ')') // read "((a,b),q)" |
|
2867 { |
|
2868 o = octonion<T>(p,q); |
|
2869 } |
|
2870 else // error |
|
2871 { |
|
2872 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
2873 is.setstate(::std::ios::failbit); |
|
2874 #else |
|
2875 is.setstate(::std::ios_base::failbit); |
|
2876 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
2877 } |
|
2878 } |
|
2879 else // read "((a,b),(c" or "((a,b),(e" |
|
2880 { |
|
2881 is.putback(ch); |
|
2882 |
|
2883 is >> c; |
|
2884 |
|
2885 if (!is.good()) goto finish; |
|
2886 |
|
2887 is >> ch; // get the next lexeme |
|
2888 |
|
2889 if (!is.good()) goto finish; |
|
2890 |
|
2891 #ifdef BOOST_NO_STD_LOCALE |
|
2892 cc = ch; |
|
2893 #else |
|
2894 cc = ct.narrow(ch, char()); |
|
2895 #endif /* BOOST_NO_STD_LOCALE */ |
|
2896 |
|
2897 if (cc == ')') // read "((a,b),(c)" (ambiguity resolution) |
|
2898 { |
|
2899 is >> ch; // get the next lexeme |
|
2900 |
|
2901 if (!is.good()) goto finish; |
|
2902 |
|
2903 #ifdef BOOST_NO_STD_LOCALE |
|
2904 cc = ch; |
|
2905 #else |
|
2906 cc = ct.narrow(ch, char()); |
|
2907 #endif /* BOOST_NO_STD_LOCALE */ |
|
2908 |
|
2909 if (cc == ')') // read "((a,b),(c))" |
|
2910 { |
|
2911 o = octonion<T>(a,b,c); |
|
2912 } |
|
2913 else if (cc == ',') // read "((a,b),(c)," |
|
2914 { |
|
2915 u = ::std::complex<T>(a,b); |
|
2916 |
|
2917 v = ::std::complex<T>(c); |
|
2918 |
|
2919 is >> x; // read "((a,b),(c),x" |
|
2920 |
|
2921 if (!is.good()) goto finish; |
|
2922 |
|
2923 is >> ch; // get the next lexeme |
|
2924 |
|
2925 if (!is.good()) goto finish; |
|
2926 |
|
2927 #ifdef BOOST_NO_STD_LOCALE |
|
2928 cc = ch; |
|
2929 #else |
|
2930 cc = ct.narrow(ch, char()); |
|
2931 #endif /* BOOST_NO_STD_LOCALE */ |
|
2932 |
|
2933 if (cc == ')') // read "((a,b),(c),x)" |
|
2934 { |
|
2935 o = octonion<T>(u,v,x); |
|
2936 } |
|
2937 else if (cc == ',') // read "((a,b),(c),x," |
|
2938 { |
|
2939 is >> y; // read "((a,b),(c),x,y" |
|
2940 |
|
2941 if (!is.good()) goto finish; |
|
2942 |
|
2943 is >> ch; // get the next lexeme |
|
2944 |
|
2945 if (!is.good()) goto finish; |
|
2946 |
|
2947 #ifdef BOOST_NO_STD_LOCALE |
|
2948 cc = ch; |
|
2949 #else |
|
2950 cc = ct.narrow(ch, char()); |
|
2951 #endif /* BOOST_NO_STD_LOCALE */ |
|
2952 |
|
2953 if (cc == ')') // read "((a,b),(c),x,y)" |
|
2954 { |
|
2955 o = octonion<T>(u,v,x,y); |
|
2956 } |
|
2957 else // error |
|
2958 { |
|
2959 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
2960 is.setstate(::std::ios::failbit); |
|
2961 #else |
|
2962 is.setstate(::std::ios_base::failbit); |
|
2963 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
2964 } |
|
2965 } |
|
2966 else // error |
|
2967 { |
|
2968 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
2969 is.setstate(::std::ios::failbit); |
|
2970 #else |
|
2971 is.setstate(::std::ios_base::failbit); |
|
2972 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
2973 } |
|
2974 } |
|
2975 else // error |
|
2976 { |
|
2977 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
2978 is.setstate(::std::ios::failbit); |
|
2979 #else |
|
2980 is.setstate(::std::ios_base::failbit); |
|
2981 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
2982 } |
|
2983 } |
|
2984 else if (cc == ',') // read "((a,b),(c," or "((a,b),(e," |
|
2985 { |
|
2986 is >> ch; // get the next lexeme |
|
2987 |
|
2988 if (!is.good()) goto finish; |
|
2989 |
|
2990 #ifdef BOOST_NO_STD_LOCALE |
|
2991 cc = ch; |
|
2992 #else |
|
2993 cc = ct.narrow(ch, char()); |
|
2994 #endif /* BOOST_NO_STD_LOCALE */ |
|
2995 |
|
2996 if (cc == '(') // read "((a,b),(e,(" (ambiguity resolution) |
|
2997 { |
|
2998 u = ::std::complex<T>(a,b); |
|
2999 |
|
3000 x = ::std::complex<T>(c); // "c" is actually "e" |
|
3001 |
|
3002 is.putback(ch); |
|
3003 |
|
3004 is >> y; // read "((a,b),(e,y" |
|
3005 |
|
3006 if (!is.good()) goto finish; |
|
3007 |
|
3008 is >> ch; // get the next lexeme |
|
3009 |
|
3010 if (!is.good()) goto finish; |
|
3011 |
|
3012 #ifdef BOOST_NO_STD_LOCALE |
|
3013 cc = ch; |
|
3014 #else |
|
3015 cc = ct.narrow(ch, char()); |
|
3016 #endif /* BOOST_NO_STD_LOCALE */ |
|
3017 |
|
3018 if (cc == ')') // read "((a,b),(e,y)" |
|
3019 { |
|
3020 is >> ch; // get the next lexeme |
|
3021 |
|
3022 if (!is.good()) goto finish; |
|
3023 |
|
3024 #ifdef BOOST_NO_STD_LOCALE |
|
3025 cc = ch; |
|
3026 #else |
|
3027 cc = ct.narrow(ch, char()); |
|
3028 #endif /* BOOST_NO_STD_LOCALE */ |
|
3029 |
|
3030 if (cc == ')') // read "((a,b),(e,y))" |
|
3031 { |
|
3032 o = octonion<T>(u,v,x,y); |
|
3033 } |
|
3034 else // error |
|
3035 { |
|
3036 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
3037 is.setstate(::std::ios::failbit); |
|
3038 #else |
|
3039 is.setstate(::std::ios_base::failbit); |
|
3040 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
3041 } |
|
3042 } |
|
3043 else // error |
|
3044 { |
|
3045 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
3046 is.setstate(::std::ios::failbit); |
|
3047 #else |
|
3048 is.setstate(::std::ios_base::failbit); |
|
3049 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
3050 } |
|
3051 } |
|
3052 else // read "((a,b),(c,d" or "((a,b),(e,f" |
|
3053 { |
|
3054 is.putback(ch); |
|
3055 |
|
3056 is >> d; |
|
3057 |
|
3058 if (!is.good()) goto finish; |
|
3059 |
|
3060 is >> ch; // get the next lexeme |
|
3061 |
|
3062 if (!is.good()) goto finish; |
|
3063 |
|
3064 #ifdef BOOST_NO_STD_LOCALE |
|
3065 cc = ch; |
|
3066 #else |
|
3067 cc = ct.narrow(ch, char()); |
|
3068 #endif /* BOOST_NO_STD_LOCALE */ |
|
3069 |
|
3070 if (cc == ')') // read "((a,b),(c,d)" (ambiguity resolution) |
|
3071 { |
|
3072 u = ::std::complex<T>(a,b); |
|
3073 |
|
3074 v = ::std::complex<T>(c,d); |
|
3075 |
|
3076 is >> ch; // get the next lexeme |
|
3077 |
|
3078 if (!is.good()) goto finish; |
|
3079 |
|
3080 #ifdef BOOST_NO_STD_LOCALE |
|
3081 cc = ch; |
|
3082 #else |
|
3083 cc = ct.narrow(ch, char()); |
|
3084 #endif /* BOOST_NO_STD_LOCALE */ |
|
3085 |
|
3086 if (cc == ')') // read "((a,b),(c,d))" |
|
3087 { |
|
3088 o = octonion<T>(u,v); |
|
3089 } |
|
3090 else if (cc == ',') // read "((a,b),(c,d)," |
|
3091 { |
|
3092 is >> x; // read "((a,b),(c,d),x |
|
3093 |
|
3094 if (!is.good()) goto finish; |
|
3095 |
|
3096 is >> ch; // get the next lexeme |
|
3097 |
|
3098 if (!is.good()) goto finish; |
|
3099 |
|
3100 #ifdef BOOST_NO_STD_LOCALE |
|
3101 cc = ch; |
|
3102 #else |
|
3103 cc = ct.narrow(ch, char()); |
|
3104 #endif /* BOOST_NO_STD_LOCALE */ |
|
3105 |
|
3106 if (cc == ')') // read "((a,b),(c,d),x)" |
|
3107 { |
|
3108 o = octonion<T>(u,v,x); |
|
3109 } |
|
3110 else if (cc == ',') // read "((a,b),(c,d),x," |
|
3111 { |
|
3112 is >> y; // read "((a,b),(c,d),x,y" |
|
3113 |
|
3114 if (!is.good()) goto finish; |
|
3115 |
|
3116 is >> ch; // get the next lexeme |
|
3117 |
|
3118 if (!is.good()) goto finish; |
|
3119 |
|
3120 #ifdef BOOST_NO_STD_LOCALE |
|
3121 cc = ch; |
|
3122 #else |
|
3123 cc = ct.narrow(ch, char()); |
|
3124 #endif /* BOOST_NO_STD_LOCALE */ |
|
3125 |
|
3126 if (cc == ')') // read "((a,b),(c,d),x,y)" |
|
3127 { |
|
3128 o = octonion<T>(u,v,x,y); |
|
3129 } |
|
3130 else // error |
|
3131 { |
|
3132 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
3133 is.setstate(::std::ios::failbit); |
|
3134 #else |
|
3135 is.setstate(::std::ios_base::failbit); |
|
3136 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
3137 } |
|
3138 } |
|
3139 else // error |
|
3140 { |
|
3141 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
3142 is.setstate(::std::ios::failbit); |
|
3143 #else |
|
3144 is.setstate(::std::ios_base::failbit); |
|
3145 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
3146 } |
|
3147 } |
|
3148 else // error |
|
3149 { |
|
3150 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
3151 is.setstate(::std::ios::failbit); |
|
3152 #else |
|
3153 is.setstate(::std::ios_base::failbit); |
|
3154 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
3155 } |
|
3156 } |
|
3157 else if (cc == ',') // read "((a,b),(e,f," (ambiguity resolution) |
|
3158 { |
|
3159 p = ::boost::math::quaternion<T>(a,b); // too late to backtrack |
|
3160 |
|
3161 is >> g; // read "((a,b),(e,f,g" |
|
3162 |
|
3163 if (!is.good()) goto finish; |
|
3164 |
|
3165 is >> ch; // get the next lexeme |
|
3166 |
|
3167 if (!is.good()) goto finish; |
|
3168 |
|
3169 #ifdef BOOST_NO_STD_LOCALE |
|
3170 cc = ch; |
|
3171 #else |
|
3172 cc = ct.narrow(ch, char()); |
|
3173 #endif /* BOOST_NO_STD_LOCALE */ |
|
3174 |
|
3175 if (cc == ')') // read "((a,b),(e,f,g)" |
|
3176 { |
|
3177 is >> ch; // get the next lexeme |
|
3178 |
|
3179 if (!is.good()) goto finish; |
|
3180 |
|
3181 #ifdef BOOST_NO_STD_LOCALE |
|
3182 cc = ch; |
|
3183 #else |
|
3184 cc = ct.narrow(ch, char()); |
|
3185 #endif /* BOOST_NO_STD_LOCALE */ |
|
3186 |
|
3187 if (cc == ')') // read "((a,b),(e,f,g))" |
|
3188 { |
|
3189 q = ::boost::math::quaternion<T>(c,d,g); // "c" is actually "e" and "d" is actually "f" |
|
3190 |
|
3191 o = octonion<T>(p,q); |
|
3192 } |
|
3193 else // error |
|
3194 { |
|
3195 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
3196 is.setstate(::std::ios::failbit); |
|
3197 #else |
|
3198 is.setstate(::std::ios_base::failbit); |
|
3199 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
3200 } |
|
3201 } |
|
3202 else if (cc == ',') // read "((a,b),(e,f,g," |
|
3203 { |
|
3204 is >> h; // read "((a,b),(e,f,g,h" |
|
3205 |
|
3206 if (!is.good()) goto finish; |
|
3207 |
|
3208 is >> ch; // get the next lexeme |
|
3209 |
|
3210 if (!is.good()) goto finish; |
|
3211 |
|
3212 #ifdef BOOST_NO_STD_LOCALE |
|
3213 cc = ch; |
|
3214 #else |
|
3215 cc = ct.narrow(ch, char()); |
|
3216 #endif /* BOOST_NO_STD_LOCALE */ |
|
3217 |
|
3218 if (cc == ')') // read "((a,b),(e,f,g,h)" |
|
3219 { |
|
3220 is >> ch; // get the next lexeme |
|
3221 |
|
3222 if (!is.good()) goto finish; |
|
3223 |
|
3224 #ifdef BOOST_NO_STD_LOCALE |
|
3225 cc = ch; |
|
3226 #else |
|
3227 cc = ct.narrow(ch, char()); |
|
3228 #endif /* BOOST_NO_STD_LOCALE */ |
|
3229 |
|
3230 if (cc == ')') // read ((a,b),(e,f,g,h))" |
|
3231 { |
|
3232 q = ::boost::math::quaternion<T>(c,d,g,h); // "c" is actually "e" and "d" is actually "f" |
|
3233 |
|
3234 o = octonion<T>(p,q); |
|
3235 } |
|
3236 else // error |
|
3237 { |
|
3238 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
3239 is.setstate(::std::ios::failbit); |
|
3240 #else |
|
3241 is.setstate(::std::ios_base::failbit); |
|
3242 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
3243 } |
|
3244 } |
|
3245 else // error |
|
3246 { |
|
3247 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
3248 is.setstate(::std::ios::failbit); |
|
3249 #else |
|
3250 is.setstate(::std::ios_base::failbit); |
|
3251 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
3252 } |
|
3253 } |
|
3254 else // error |
|
3255 { |
|
3256 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
3257 is.setstate(::std::ios::failbit); |
|
3258 #else |
|
3259 is.setstate(::std::ios_base::failbit); |
|
3260 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
3261 } |
|
3262 } |
|
3263 else // error |
|
3264 { |
|
3265 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
3266 is.setstate(::std::ios::failbit); |
|
3267 #else |
|
3268 is.setstate(::std::ios_base::failbit); |
|
3269 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
3270 } |
|
3271 } |
|
3272 } |
|
3273 else // error |
|
3274 { |
|
3275 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
3276 is.setstate(::std::ios::failbit); |
|
3277 #else |
|
3278 is.setstate(::std::ios_base::failbit); |
|
3279 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
3280 } |
|
3281 } |
|
3282 } |
|
3283 else // error |
|
3284 { |
|
3285 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
3286 is.setstate(::std::ios::failbit); |
|
3287 #else |
|
3288 is.setstate(::std::ios_base::failbit); |
|
3289 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
3290 } |
|
3291 } |
|
3292 else // error |
|
3293 { |
|
3294 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
3295 is.setstate(::std::ios::failbit); |
|
3296 #else |
|
3297 is.setstate(::std::ios_base::failbit); |
|
3298 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
3299 } |
|
3300 } |
|
3301 else if (cc == ',') // read "((a,b," |
|
3302 { |
|
3303 is >> c; // read "((a,b,c" |
|
3304 |
|
3305 if (!is.good()) goto finish; |
|
3306 |
|
3307 is >> ch; // get the next lexeme |
|
3308 |
|
3309 if (!is.good()) goto finish; |
|
3310 |
|
3311 #ifdef BOOST_NO_STD_LOCALE |
|
3312 cc = ch; |
|
3313 #else |
|
3314 cc = ct.narrow(ch, char()); |
|
3315 #endif /* BOOST_NO_STD_LOCALE */ |
|
3316 |
|
3317 if (cc == ')') // read "((a,b,c)" |
|
3318 { |
|
3319 is >> ch; // get the next lexeme |
|
3320 |
|
3321 if (!is.good()) goto finish; |
|
3322 |
|
3323 #ifdef BOOST_NO_STD_LOCALE |
|
3324 cc = ch; |
|
3325 #else |
|
3326 cc = ct.narrow(ch, char()); |
|
3327 #endif /* BOOST_NO_STD_LOCALE */ |
|
3328 |
|
3329 if (cc == ')') // read "((a,b,c))" |
|
3330 { |
|
3331 o = octonion<T>(a,b,c); |
|
3332 } |
|
3333 else if (cc == ',') // read "((a,b,c)," |
|
3334 { |
|
3335 p = ::boost::math::quaternion<T>(a,b,c); |
|
3336 |
|
3337 is >> q; // read "((a,b,c),q" |
|
3338 |
|
3339 if (!is.good()) goto finish; |
|
3340 |
|
3341 is >> ch; // get the next lexeme |
|
3342 |
|
3343 if (!is.good()) goto finish; |
|
3344 |
|
3345 #ifdef BOOST_NO_STD_LOCALE |
|
3346 cc = ch; |
|
3347 #else |
|
3348 cc = ct.narrow(ch, char()); |
|
3349 #endif /* BOOST_NO_STD_LOCALE */ |
|
3350 |
|
3351 if (cc == ')') // read "((a,b,c),q)" |
|
3352 { |
|
3353 o = octonion<T>(p,q); |
|
3354 } |
|
3355 else // error |
|
3356 { |
|
3357 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
3358 is.setstate(::std::ios::failbit); |
|
3359 #else |
|
3360 is.setstate(::std::ios_base::failbit); |
|
3361 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
3362 } |
|
3363 } |
|
3364 else // error |
|
3365 { |
|
3366 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
3367 is.setstate(::std::ios::failbit); |
|
3368 #else |
|
3369 is.setstate(::std::ios_base::failbit); |
|
3370 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
3371 } |
|
3372 } |
|
3373 else if (cc == ',') // read "((a,b,c," |
|
3374 { |
|
3375 is >> d; // read "((a,b,c,d" |
|
3376 |
|
3377 if (!is.good()) goto finish; |
|
3378 |
|
3379 is >> ch; // get the next lexeme |
|
3380 |
|
3381 if (!is.good()) goto finish; |
|
3382 |
|
3383 #ifdef BOOST_NO_STD_LOCALE |
|
3384 cc = ch; |
|
3385 #else |
|
3386 cc = ct.narrow(ch, char()); |
|
3387 #endif /* BOOST_NO_STD_LOCALE */ |
|
3388 |
|
3389 if (cc == ')') // read "((a,b,c,d)" |
|
3390 { |
|
3391 is >> ch; // get the next lexeme |
|
3392 |
|
3393 if (!is.good()) goto finish; |
|
3394 |
|
3395 #ifdef BOOST_NO_STD_LOCALE |
|
3396 cc = ch; |
|
3397 #else |
|
3398 cc = ct.narrow(ch, char()); |
|
3399 #endif /* BOOST_NO_STD_LOCALE */ |
|
3400 |
|
3401 if (cc == ')') // read "((a,b,c,d))" |
|
3402 { |
|
3403 o = octonion<T>(a,b,c,d); |
|
3404 } |
|
3405 else if (cc == ',') // read "((a,b,c,d)," |
|
3406 { |
|
3407 p = ::boost::math::quaternion<T>(a,b,c,d); |
|
3408 |
|
3409 is >> q; // read "((a,b,c,d),q" |
|
3410 |
|
3411 if (!is.good()) goto finish; |
|
3412 |
|
3413 is >> ch; // get the next lexeme |
|
3414 |
|
3415 if (!is.good()) goto finish; |
|
3416 |
|
3417 #ifdef BOOST_NO_STD_LOCALE |
|
3418 cc = ch; |
|
3419 #else |
|
3420 cc = ct.narrow(ch, char()); |
|
3421 #endif /* BOOST_NO_STD_LOCALE */ |
|
3422 |
|
3423 if (cc == ')') // read "((a,b,c,d),q)" |
|
3424 { |
|
3425 o = octonion<T>(p,q); |
|
3426 } |
|
3427 else // error |
|
3428 { |
|
3429 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
3430 is.setstate(::std::ios::failbit); |
|
3431 #else |
|
3432 is.setstate(::std::ios_base::failbit); |
|
3433 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
3434 } |
|
3435 } |
|
3436 else // error |
|
3437 { |
|
3438 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
3439 is.setstate(::std::ios::failbit); |
|
3440 #else |
|
3441 is.setstate(::std::ios_base::failbit); |
|
3442 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
3443 } |
|
3444 } |
|
3445 else // error |
|
3446 { |
|
3447 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
3448 is.setstate(::std::ios::failbit); |
|
3449 #else |
|
3450 is.setstate(::std::ios_base::failbit); |
|
3451 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
3452 } |
|
3453 } |
|
3454 else // error |
|
3455 { |
|
3456 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
3457 is.setstate(::std::ios::failbit); |
|
3458 #else |
|
3459 is.setstate(::std::ios_base::failbit); |
|
3460 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
3461 } |
|
3462 } |
|
3463 else // error |
|
3464 { |
|
3465 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
3466 is.setstate(::std::ios::failbit); |
|
3467 #else |
|
3468 is.setstate(::std::ios_base::failbit); |
|
3469 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
3470 } |
|
3471 } |
|
3472 } |
|
3473 else // error |
|
3474 { |
|
3475 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
3476 is.setstate(::std::ios::failbit); |
|
3477 #else |
|
3478 is.setstate(::std::ios_base::failbit); |
|
3479 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
3480 } |
|
3481 } |
|
3482 } |
|
3483 else // read "(a" |
|
3484 { |
|
3485 is.putback(ch); |
|
3486 |
|
3487 is >> a; // we extract the first component |
|
3488 |
|
3489 if (!is.good()) goto finish; |
|
3490 |
|
3491 is >> ch; // get the next lexeme |
|
3492 |
|
3493 if (!is.good()) goto finish; |
|
3494 |
|
3495 #ifdef BOOST_NO_STD_LOCALE |
|
3496 cc = ch; |
|
3497 #else |
|
3498 cc = ct.narrow(ch, char()); |
|
3499 #endif /* BOOST_NO_STD_LOCALE */ |
|
3500 |
|
3501 if (cc == ')') // read "(a)" |
|
3502 { |
|
3503 o = octonion<T>(a); |
|
3504 } |
|
3505 else if (cc == ',') // read "(a," |
|
3506 { |
|
3507 is >> ch; // get the next lexeme |
|
3508 |
|
3509 if (!is.good()) goto finish; |
|
3510 |
|
3511 #ifdef BOOST_NO_STD_LOCALE |
|
3512 cc = ch; |
|
3513 #else |
|
3514 cc = ct.narrow(ch, char()); |
|
3515 #endif /* BOOST_NO_STD_LOCALE */ |
|
3516 |
|
3517 if (cc == '(') // read "(a,(" |
|
3518 { |
|
3519 is >> ch; // get the next lexeme |
|
3520 |
|
3521 if (!is.good()) goto finish; |
|
3522 |
|
3523 #ifdef BOOST_NO_STD_LOCALE |
|
3524 cc = ch; |
|
3525 #else |
|
3526 cc = ct.narrow(ch, char()); |
|
3527 #endif /* BOOST_NO_STD_LOCALE */ |
|
3528 |
|
3529 if (cc == '(') // read "(a,((" |
|
3530 { |
|
3531 p = ::boost::math::quaternion<T>(a); |
|
3532 |
|
3533 is.putback(ch); |
|
3534 |
|
3535 is.putback(ch); // we backtrack twice, with the same value |
|
3536 |
|
3537 is >> q; // read "(a,q" |
|
3538 |
|
3539 if (!is.good()) goto finish; |
|
3540 |
|
3541 is >> ch; // get the next lexeme |
|
3542 |
|
3543 if (!is.good()) goto finish; |
|
3544 |
|
3545 #ifdef BOOST_NO_STD_LOCALE |
|
3546 cc = ch; |
|
3547 #else |
|
3548 cc = ct.narrow(ch, char()); |
|
3549 #endif /* BOOST_NO_STD_LOCALE */ |
|
3550 |
|
3551 if (cc == ')') // read "(a,q)" |
|
3552 { |
|
3553 o = octonion<T>(p,q); |
|
3554 } |
|
3555 else // error |
|
3556 { |
|
3557 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
3558 is.setstate(::std::ios::failbit); |
|
3559 #else |
|
3560 is.setstate(::std::ios_base::failbit); |
|
3561 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
3562 } |
|
3563 } |
|
3564 else // read "(a,(c" or "(a,(e" |
|
3565 { |
|
3566 is.putback(ch); |
|
3567 |
|
3568 is >> c; |
|
3569 |
|
3570 if (!is.good()) goto finish; |
|
3571 |
|
3572 is >> ch; // get the next lexeme |
|
3573 |
|
3574 if (!is.good()) goto finish; |
|
3575 |
|
3576 #ifdef BOOST_NO_STD_LOCALE |
|
3577 cc = ch; |
|
3578 #else |
|
3579 cc = ct.narrow(ch, char()); |
|
3580 #endif /* BOOST_NO_STD_LOCALE */ |
|
3581 |
|
3582 if (cc == ')') // read "(a,(c)" (ambiguity resolution) |
|
3583 { |
|
3584 is >> ch; // get the next lexeme |
|
3585 |
|
3586 if (!is.good()) goto finish; |
|
3587 |
|
3588 #ifdef BOOST_NO_STD_LOCALE |
|
3589 cc = ch; |
|
3590 #else |
|
3591 cc = ct.narrow(ch, char()); |
|
3592 #endif /* BOOST_NO_STD_LOCALE */ |
|
3593 |
|
3594 if (cc == ')') // read "(a,(c))" |
|
3595 { |
|
3596 o = octonion<T>(a,b,c); |
|
3597 } |
|
3598 else if (cc == ',') // read "(a,(c)," |
|
3599 { |
|
3600 u = ::std::complex<T>(a); |
|
3601 |
|
3602 v = ::std::complex<T>(c); |
|
3603 |
|
3604 is >> x; // read "(a,(c),x" |
|
3605 |
|
3606 if (!is.good()) goto finish; |
|
3607 |
|
3608 is >> ch; // get the next lexeme |
|
3609 |
|
3610 if (!is.good()) goto finish; |
|
3611 |
|
3612 #ifdef BOOST_NO_STD_LOCALE |
|
3613 cc = ch; |
|
3614 #else |
|
3615 cc = ct.narrow(ch, char()); |
|
3616 #endif /* BOOST_NO_STD_LOCALE */ |
|
3617 |
|
3618 if (cc == ')') // read "(a,(c),x)" |
|
3619 { |
|
3620 o = octonion<T>(u,v,x); |
|
3621 } |
|
3622 else if (cc == ',') // read "(a,(c),x," |
|
3623 { |
|
3624 is >> y; // read "(a,(c),x,y" |
|
3625 |
|
3626 if (!is.good()) goto finish; |
|
3627 |
|
3628 is >> ch; // get the next lexeme |
|
3629 |
|
3630 if (!is.good()) goto finish; |
|
3631 |
|
3632 #ifdef BOOST_NO_STD_LOCALE |
|
3633 cc = ch; |
|
3634 #else |
|
3635 cc = ct.narrow(ch, char()); |
|
3636 #endif /* BOOST_NO_STD_LOCALE */ |
|
3637 |
|
3638 if (cc == ')') // read "(a,(c),x,y)" |
|
3639 { |
|
3640 o = octonion<T>(u,v,x,y); |
|
3641 } |
|
3642 else // error |
|
3643 { |
|
3644 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
3645 is.setstate(::std::ios::failbit); |
|
3646 #else |
|
3647 is.setstate(::std::ios_base::failbit); |
|
3648 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
3649 } |
|
3650 } |
|
3651 else // error |
|
3652 { |
|
3653 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
3654 is.setstate(::std::ios::failbit); |
|
3655 #else |
|
3656 is.setstate(::std::ios_base::failbit); |
|
3657 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
3658 } |
|
3659 } |
|
3660 else // error |
|
3661 { |
|
3662 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
3663 is.setstate(::std::ios::failbit); |
|
3664 #else |
|
3665 is.setstate(::std::ios_base::failbit); |
|
3666 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
3667 } |
|
3668 } |
|
3669 else if (cc == ',') // read "(a,(c," or "(a,(e," |
|
3670 { |
|
3671 is >> ch; // get the next lexeme |
|
3672 |
|
3673 if (!is.good()) goto finish; |
|
3674 |
|
3675 #ifdef BOOST_NO_STD_LOCALE |
|
3676 cc = ch; |
|
3677 #else |
|
3678 cc = ct.narrow(ch, char()); |
|
3679 #endif /* BOOST_NO_STD_LOCALE */ |
|
3680 |
|
3681 if (cc == '(') // read "(a,(e,(" (ambiguity resolution) |
|
3682 { |
|
3683 u = ::std::complex<T>(a); |
|
3684 |
|
3685 x = ::std::complex<T>(c); // "c" is actually "e" |
|
3686 |
|
3687 is.putback(ch); // we backtrack |
|
3688 |
|
3689 is >> y; // read "(a,(e,y" |
|
3690 |
|
3691 if (!is.good()) goto finish; |
|
3692 |
|
3693 is >> ch; // get the next lexeme |
|
3694 |
|
3695 if (!is.good()) goto finish; |
|
3696 |
|
3697 #ifdef BOOST_NO_STD_LOCALE |
|
3698 cc = ch; |
|
3699 #else |
|
3700 cc = ct.narrow(ch, char()); |
|
3701 #endif /* BOOST_NO_STD_LOCALE */ |
|
3702 |
|
3703 if (cc == ')') // read "(a,(e,y)" |
|
3704 { |
|
3705 is >> ch; // get the next lexeme |
|
3706 |
|
3707 if (!is.good()) goto finish; |
|
3708 |
|
3709 #ifdef BOOST_NO_STD_LOCALE |
|
3710 cc = ch; |
|
3711 #else |
|
3712 cc = ct.narrow(ch, char()); |
|
3713 #endif /* BOOST_NO_STD_LOCALE */ |
|
3714 |
|
3715 if (cc == ')') // read "(a,(e,y))" |
|
3716 { |
|
3717 o = octonion<T>(u,v,x,y); |
|
3718 } |
|
3719 else // error |
|
3720 { |
|
3721 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
3722 is.setstate(::std::ios::failbit); |
|
3723 #else |
|
3724 is.setstate(::std::ios_base::failbit); |
|
3725 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
3726 } |
|
3727 } |
|
3728 else // error |
|
3729 { |
|
3730 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
3731 is.setstate(::std::ios::failbit); |
|
3732 #else |
|
3733 is.setstate(::std::ios_base::failbit); |
|
3734 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
3735 } |
|
3736 } |
|
3737 else // read "(a,(c,d" or "(a,(e,f" |
|
3738 { |
|
3739 is.putback(ch); |
|
3740 |
|
3741 is >> d; |
|
3742 |
|
3743 if (!is.good()) goto finish; |
|
3744 |
|
3745 is >> ch; // get the next lexeme |
|
3746 |
|
3747 if (!is.good()) goto finish; |
|
3748 |
|
3749 #ifdef BOOST_NO_STD_LOCALE |
|
3750 cc = ch; |
|
3751 #else |
|
3752 cc = ct.narrow(ch, char()); |
|
3753 #endif /* BOOST_NO_STD_LOCALE */ |
|
3754 |
|
3755 if (cc == ')') // read "(a,(c,d)" (ambiguity resolution) |
|
3756 { |
|
3757 is >> ch; // get the next lexeme |
|
3758 |
|
3759 if (!is.good()) goto finish; |
|
3760 |
|
3761 #ifdef BOOST_NO_STD_LOCALE |
|
3762 cc = ch; |
|
3763 #else |
|
3764 cc = ct.narrow(ch, char()); |
|
3765 #endif /* BOOST_NO_STD_LOCALE */ |
|
3766 |
|
3767 if (cc == ')') // read "(a,(c,d))" |
|
3768 { |
|
3769 o = octonion<T>(a,b,c,d); |
|
3770 } |
|
3771 else if (cc == ',') // read "(a,(c,d)," |
|
3772 { |
|
3773 u = ::std::complex<T>(a); |
|
3774 |
|
3775 v = ::std::complex<T>(c,d); |
|
3776 |
|
3777 is >> x; // read "(a,(c,d),x" |
|
3778 |
|
3779 if (!is.good()) goto finish; |
|
3780 |
|
3781 is >> ch; // get the next lexeme |
|
3782 |
|
3783 if (!is.good()) goto finish; |
|
3784 |
|
3785 #ifdef BOOST_NO_STD_LOCALE |
|
3786 cc = ch; |
|
3787 #else |
|
3788 cc = ct.narrow(ch, char()); |
|
3789 #endif /* BOOST_NO_STD_LOCALE */ |
|
3790 |
|
3791 if (cc == ')') // read "(a,(c,d),x)" |
|
3792 { |
|
3793 o = octonion<T>(u,v,x); |
|
3794 } |
|
3795 else if (cc == ',') // read "(a,(c,d),x," |
|
3796 { |
|
3797 is >> y; // read "(a,(c,d),x,y" |
|
3798 |
|
3799 if (!is.good()) goto finish; |
|
3800 |
|
3801 is >> ch; // get the next lexeme |
|
3802 |
|
3803 if (!is.good()) goto finish; |
|
3804 |
|
3805 #ifdef BOOST_NO_STD_LOCALE |
|
3806 cc = ch; |
|
3807 #else |
|
3808 cc = ct.narrow(ch, char()); |
|
3809 #endif /* BOOST_NO_STD_LOCALE */ |
|
3810 |
|
3811 if (cc == ')') // read "(a,(c,d),x,y)" |
|
3812 { |
|
3813 o = octonion<T>(u,v,x,y); |
|
3814 } |
|
3815 else // error |
|
3816 { |
|
3817 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
3818 is.setstate(::std::ios::failbit); |
|
3819 #else |
|
3820 is.setstate(::std::ios_base::failbit); |
|
3821 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
3822 } |
|
3823 } |
|
3824 else // error |
|
3825 { |
|
3826 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
3827 is.setstate(::std::ios::failbit); |
|
3828 #else |
|
3829 is.setstate(::std::ios_base::failbit); |
|
3830 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
3831 } |
|
3832 } |
|
3833 else // error |
|
3834 { |
|
3835 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
3836 is.setstate(::std::ios::failbit); |
|
3837 #else |
|
3838 is.setstate(::std::ios_base::failbit); |
|
3839 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
3840 } |
|
3841 } |
|
3842 else if (cc == ',') // read "(a,(e,f," (ambiguity resolution) |
|
3843 { |
|
3844 p = ::boost::math::quaternion<T>(a); |
|
3845 |
|
3846 is >> g; // read "(a,(e,f,g" |
|
3847 |
|
3848 if (!is.good()) goto finish; |
|
3849 |
|
3850 is >> ch; // get the next lexeme |
|
3851 |
|
3852 if (!is.good()) goto finish; |
|
3853 |
|
3854 #ifdef BOOST_NO_STD_LOCALE |
|
3855 cc = ch; |
|
3856 #else |
|
3857 cc = ct.narrow(ch, char()); |
|
3858 #endif /* BOOST_NO_STD_LOCALE */ |
|
3859 |
|
3860 if (cc == ')') // read "(a,(e,f,g)" |
|
3861 { |
|
3862 is >> ch; // get the next lexeme |
|
3863 |
|
3864 if (!is.good()) goto finish; |
|
3865 |
|
3866 #ifdef BOOST_NO_STD_LOCALE |
|
3867 cc = ch; |
|
3868 #else |
|
3869 cc = ct.narrow(ch, char()); |
|
3870 #endif /* BOOST_NO_STD_LOCALE */ |
|
3871 |
|
3872 if (cc == ')') // read "(a,(e,f,g))" |
|
3873 { |
|
3874 q = ::boost::math::quaternion<T>(c,d,g); // "c" is actually "e" and "d" is actually "f" |
|
3875 |
|
3876 o = octonion<T>(p,q); |
|
3877 } |
|
3878 else // error |
|
3879 { |
|
3880 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
3881 is.setstate(::std::ios::failbit); |
|
3882 #else |
|
3883 is.setstate(::std::ios_base::failbit); |
|
3884 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
3885 } |
|
3886 } |
|
3887 else if (cc == ',') // read "(a,(e,f,g," |
|
3888 { |
|
3889 is >> h; // read "(a,(e,f,g,h" |
|
3890 |
|
3891 if (!is.good()) goto finish; |
|
3892 |
|
3893 is >> ch; // get the next lexeme |
|
3894 |
|
3895 if (!is.good()) goto finish; |
|
3896 |
|
3897 #ifdef BOOST_NO_STD_LOCALE |
|
3898 cc = ch; |
|
3899 #else |
|
3900 cc = ct.narrow(ch, char()); |
|
3901 #endif /* BOOST_NO_STD_LOCALE */ |
|
3902 |
|
3903 if (cc == ')') // read "(a,(e,f,g,h)" |
|
3904 { |
|
3905 is >> ch; // get the next lexeme |
|
3906 |
|
3907 if (!is.good()) goto finish; |
|
3908 |
|
3909 #ifdef BOOST_NO_STD_LOCALE |
|
3910 cc = ch; |
|
3911 #else |
|
3912 cc = ct.narrow(ch, char()); |
|
3913 #endif /* BOOST_NO_STD_LOCALE */ |
|
3914 |
|
3915 if (cc == ')') // read "(a,(e,f,g,h))" |
|
3916 { |
|
3917 q = ::boost::math::quaternion<T>(c,d,g,h); // "c" is actually "e" and "d" is actually "f" |
|
3918 |
|
3919 o = octonion<T>(p,q); |
|
3920 } |
|
3921 else // error |
|
3922 { |
|
3923 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
3924 is.setstate(::std::ios::failbit); |
|
3925 #else |
|
3926 is.setstate(::std::ios_base::failbit); |
|
3927 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
3928 } |
|
3929 } |
|
3930 else // error |
|
3931 { |
|
3932 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
3933 is.setstate(::std::ios::failbit); |
|
3934 #else |
|
3935 is.setstate(::std::ios_base::failbit); |
|
3936 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
3937 } |
|
3938 } |
|
3939 else // error |
|
3940 { |
|
3941 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
3942 is.setstate(::std::ios::failbit); |
|
3943 #else |
|
3944 is.setstate(::std::ios_base::failbit); |
|
3945 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
3946 } |
|
3947 } |
|
3948 else // error |
|
3949 { |
|
3950 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
3951 is.setstate(::std::ios::failbit); |
|
3952 #else |
|
3953 is.setstate(::std::ios_base::failbit); |
|
3954 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
3955 } |
|
3956 } |
|
3957 } |
|
3958 else // error |
|
3959 { |
|
3960 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
3961 is.setstate(::std::ios::failbit); |
|
3962 #else |
|
3963 is.setstate(::std::ios_base::failbit); |
|
3964 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
3965 } |
|
3966 } |
|
3967 } |
|
3968 else // read "(a,b" or "(a,c" (ambiguity resolution) |
|
3969 { |
|
3970 is.putback(ch); |
|
3971 |
|
3972 is >> b; |
|
3973 |
|
3974 if (!is.good()) goto finish; |
|
3975 |
|
3976 is >> ch; // get the next lexeme |
|
3977 |
|
3978 if (!is.good()) goto finish; |
|
3979 |
|
3980 #ifdef BOOST_NO_STD_LOCALE |
|
3981 cc = ch; |
|
3982 #else |
|
3983 cc = ct.narrow(ch, char()); |
|
3984 #endif /* BOOST_NO_STD_LOCALE */ |
|
3985 |
|
3986 if (cc == ')') // read "(a,b)" (ambiguity resolution) |
|
3987 { |
|
3988 o = octonion<T>(a,b); |
|
3989 } |
|
3990 else if (cc == ',') // read "(a,b," or "(a,c," |
|
3991 { |
|
3992 is >> ch; // get the next lexeme |
|
3993 |
|
3994 if (!is.good()) goto finish; |
|
3995 |
|
3996 #ifdef BOOST_NO_STD_LOCALE |
|
3997 cc = ch; |
|
3998 #else |
|
3999 cc = ct.narrow(ch, char()); |
|
4000 #endif /* BOOST_NO_STD_LOCALE */ |
|
4001 |
|
4002 if (cc == '(') // read "(a,c,(" (ambiguity resolution) |
|
4003 { |
|
4004 u = ::std::complex<T>(a); |
|
4005 |
|
4006 v = ::std::complex<T>(b); // "b" is actually "c" |
|
4007 |
|
4008 is.putback(ch); // we backtrack |
|
4009 |
|
4010 is >> x; // read "(a,c,x" |
|
4011 |
|
4012 if (!is.good()) goto finish; |
|
4013 |
|
4014 is >> ch; // get the next lexeme |
|
4015 |
|
4016 if (!is.good()) goto finish; |
|
4017 |
|
4018 #ifdef BOOST_NO_STD_LOCALE |
|
4019 cc = ch; |
|
4020 #else |
|
4021 cc = ct.narrow(ch, char()); |
|
4022 #endif /* BOOST_NO_STD_LOCALE */ |
|
4023 |
|
4024 if (cc == ')') // read "(a,c,x)" |
|
4025 { |
|
4026 o = octonion<T>(u,v,x); |
|
4027 } |
|
4028 else if (cc == ',') // read "(a,c,x," |
|
4029 { |
|
4030 is >> y; // read "(a,c,x,y" // read "(a,c,x" |
|
4031 |
|
4032 if (!is.good()) goto finish; |
|
4033 |
|
4034 is >> ch; // get the next lexeme |
|
4035 |
|
4036 if (!is.good()) goto finish; |
|
4037 |
|
4038 #ifdef BOOST_NO_STD_LOCALE |
|
4039 cc = ch; |
|
4040 #else |
|
4041 cc = ct.narrow(ch, char()); |
|
4042 #endif /* BOOST_NO_STD_LOCALE */ |
|
4043 |
|
4044 if (cc == ')') // read "(a,c,x,y)" |
|
4045 { |
|
4046 o = octonion<T>(u,v,x,y); |
|
4047 } |
|
4048 else // error |
|
4049 { |
|
4050 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
4051 is.setstate(::std::ios::failbit); |
|
4052 #else |
|
4053 is.setstate(::std::ios_base::failbit); |
|
4054 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
4055 } |
|
4056 } |
|
4057 else // error |
|
4058 { |
|
4059 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
4060 is.setstate(::std::ios::failbit); |
|
4061 #else |
|
4062 is.setstate(::std::ios_base::failbit); |
|
4063 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
4064 } |
|
4065 } |
|
4066 else // read "(a,b,c" or "(a,c,e" |
|
4067 { |
|
4068 is.putback(ch); |
|
4069 |
|
4070 is >> c; |
|
4071 |
|
4072 if (!is.good()) goto finish; |
|
4073 |
|
4074 is >> ch; // get the next lexeme |
|
4075 |
|
4076 if (!is.good()) goto finish; |
|
4077 |
|
4078 #ifdef BOOST_NO_STD_LOCALE |
|
4079 cc = ch; |
|
4080 #else |
|
4081 cc = ct.narrow(ch, char()); |
|
4082 #endif /* BOOST_NO_STD_LOCALE */ |
|
4083 |
|
4084 if (cc == ')') // read "(a,b,c)" (ambiguity resolution) |
|
4085 { |
|
4086 o = octonion<T>(a,b,c); |
|
4087 } |
|
4088 else if (cc == ',') // read "(a,b,c," or "(a,c,e," |
|
4089 { |
|
4090 is >> ch; // get the next lexeme |
|
4091 |
|
4092 if (!is.good()) goto finish; |
|
4093 |
|
4094 #ifdef BOOST_NO_STD_LOCALE |
|
4095 cc = ch; |
|
4096 #else |
|
4097 cc = ct.narrow(ch, char()); |
|
4098 #endif /* BOOST_NO_STD_LOCALE */ |
|
4099 |
|
4100 if (cc == '(') // read "(a,c,e,(") (ambiguity resolution) |
|
4101 { |
|
4102 u = ::std::complex<T>(a); |
|
4103 |
|
4104 v = ::std::complex<T>(b); // "b" is actually "c" |
|
4105 |
|
4106 x = ::std::complex<T>(c); // "c" is actually "e" |
|
4107 |
|
4108 is.putback(ch); // we backtrack |
|
4109 |
|
4110 is >> y; // read "(a,c,e,y" |
|
4111 |
|
4112 if (!is.good()) goto finish; |
|
4113 |
|
4114 is >> ch; // get the next lexeme |
|
4115 |
|
4116 if (!is.good()) goto finish; |
|
4117 |
|
4118 #ifdef BOOST_NO_STD_LOCALE |
|
4119 cc = ch; |
|
4120 #else |
|
4121 cc = ct.narrow(ch, char()); |
|
4122 #endif /* BOOST_NO_STD_LOCALE */ |
|
4123 |
|
4124 if (cc == ')') // read "(a,c,e,y)" |
|
4125 { |
|
4126 o = octonion<T>(u,v,x,y); |
|
4127 } |
|
4128 else // error |
|
4129 { |
|
4130 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
4131 is.setstate(::std::ios::failbit); |
|
4132 #else |
|
4133 is.setstate(::std::ios_base::failbit); |
|
4134 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
4135 } |
|
4136 } |
|
4137 else // read "(a,b,c,d" (ambiguity resolution) |
|
4138 { |
|
4139 is.putback(ch); // we backtrack |
|
4140 |
|
4141 is >> d; |
|
4142 |
|
4143 if (!is.good()) goto finish; |
|
4144 |
|
4145 is >> ch; // get the next lexeme |
|
4146 |
|
4147 if (!is.good()) goto finish; |
|
4148 |
|
4149 #ifdef BOOST_NO_STD_LOCALE |
|
4150 cc = ch; |
|
4151 #else |
|
4152 cc = ct.narrow(ch, char()); |
|
4153 #endif /* BOOST_NO_STD_LOCALE */ |
|
4154 |
|
4155 if (cc == ')') // read "(a,b,c,d)" |
|
4156 { |
|
4157 o = octonion<T>(a,b,c,d); |
|
4158 } |
|
4159 else if (cc == ',') // read "(a,b,c,d," |
|
4160 { |
|
4161 is >> e; // read "(a,b,c,d,e" |
|
4162 |
|
4163 if (!is.good()) goto finish; |
|
4164 |
|
4165 is >> ch; // get the next lexeme |
|
4166 |
|
4167 if (!is.good()) goto finish; |
|
4168 |
|
4169 #ifdef BOOST_NO_STD_LOCALE |
|
4170 cc = ch; |
|
4171 #else |
|
4172 cc = ct.narrow(ch, char()); |
|
4173 #endif /* BOOST_NO_STD_LOCALE */ |
|
4174 |
|
4175 if (cc == ')') // read "(a,b,c,d,e)" |
|
4176 { |
|
4177 o = octonion<T>(a,b,c,d,e); |
|
4178 } |
|
4179 else if (cc == ',') // read "(a,b,c,d,e," |
|
4180 { |
|
4181 is >> f; // read "(a,b,c,d,e,f" |
|
4182 |
|
4183 if (!is.good()) goto finish; |
|
4184 |
|
4185 is >> ch; // get the next lexeme |
|
4186 |
|
4187 if (!is.good()) goto finish; |
|
4188 |
|
4189 #ifdef BOOST_NO_STD_LOCALE |
|
4190 cc = ch; |
|
4191 #else |
|
4192 cc = ct.narrow(ch, char()); |
|
4193 #endif /* BOOST_NO_STD_LOCALE */ |
|
4194 |
|
4195 if (cc == ')') // read "(a,b,c,d,e,f)" |
|
4196 { |
|
4197 o = octonion<T>(a,b,c,d,e,f); |
|
4198 } |
|
4199 else if (cc == ',') // read "(a,b,c,d,e,f," |
|
4200 { |
|
4201 is >> g; // read "(a,b,c,d,e,f,g" // read "(a,b,c,d,e,f" |
|
4202 |
|
4203 if (!is.good()) goto finish; |
|
4204 |
|
4205 is >> ch; // get the next lexeme |
|
4206 |
|
4207 if (!is.good()) goto finish; |
|
4208 |
|
4209 #ifdef BOOST_NO_STD_LOCALE |
|
4210 cc = ch; |
|
4211 #else |
|
4212 cc = ct.narrow(ch, char()); |
|
4213 #endif /* BOOST_NO_STD_LOCALE */ |
|
4214 |
|
4215 if (cc == ')') // read "(a,b,c,d,e,f,g)" |
|
4216 { |
|
4217 o = octonion<T>(a,b,c,d,e,f,g); |
|
4218 } |
|
4219 else if (cc == ',') // read "(a,b,c,d,e,f,g," |
|
4220 { |
|
4221 is >> h; // read "(a,b,c,d,e,f,g,h" // read "(a,b,c,d,e,f,g" // read "(a,b,c,d,e,f" |
|
4222 |
|
4223 if (!is.good()) goto finish; |
|
4224 |
|
4225 is >> ch; // get the next lexeme |
|
4226 |
|
4227 if (!is.good()) goto finish; |
|
4228 |
|
4229 #ifdef BOOST_NO_STD_LOCALE |
|
4230 cc = ch; |
|
4231 #else |
|
4232 cc = ct.narrow(ch, char()); |
|
4233 #endif /* BOOST_NO_STD_LOCALE */ |
|
4234 |
|
4235 if (cc == ')') // read "(a,b,c,d,e,f,g,h)" |
|
4236 { |
|
4237 o = octonion<T>(a,b,c,d,e,f,g,h); |
|
4238 } |
|
4239 else // error |
|
4240 { |
|
4241 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
4242 is.setstate(::std::ios::failbit); |
|
4243 #else |
|
4244 is.setstate(::std::ios_base::failbit); |
|
4245 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
4246 } |
|
4247 } |
|
4248 else // error |
|
4249 { |
|
4250 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
4251 is.setstate(::std::ios::failbit); |
|
4252 #else |
|
4253 is.setstate(::std::ios_base::failbit); |
|
4254 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
4255 } |
|
4256 } |
|
4257 else // error |
|
4258 { |
|
4259 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
4260 is.setstate(::std::ios::failbit); |
|
4261 #else |
|
4262 is.setstate(::std::ios_base::failbit); |
|
4263 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
4264 } |
|
4265 } |
|
4266 else // error |
|
4267 { |
|
4268 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
4269 is.setstate(::std::ios::failbit); |
|
4270 #else |
|
4271 is.setstate(::std::ios_base::failbit); |
|
4272 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
4273 } |
|
4274 } |
|
4275 else // error |
|
4276 { |
|
4277 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
4278 is.setstate(::std::ios::failbit); |
|
4279 #else |
|
4280 is.setstate(::std::ios_base::failbit); |
|
4281 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
4282 } |
|
4283 } |
|
4284 } |
|
4285 else // error |
|
4286 { |
|
4287 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
4288 is.setstate(::std::ios::failbit); |
|
4289 #else |
|
4290 is.setstate(::std::ios_base::failbit); |
|
4291 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
4292 } |
|
4293 } |
|
4294 } |
|
4295 else // error |
|
4296 { |
|
4297 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
4298 is.setstate(::std::ios::failbit); |
|
4299 #else |
|
4300 is.setstate(::std::ios_base::failbit); |
|
4301 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
4302 } |
|
4303 } |
|
4304 } |
|
4305 else // error |
|
4306 { |
|
4307 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
4308 is.setstate(::std::ios::failbit); |
|
4309 #else |
|
4310 is.setstate(::std::ios_base::failbit); |
|
4311 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
4312 } |
|
4313 } |
|
4314 } |
|
4315 else // format: a |
|
4316 { |
|
4317 is.putback(ch); |
|
4318 |
|
4319 is >> a; // we extract the first component |
|
4320 |
|
4321 if (!is.good()) goto finish; |
|
4322 |
|
4323 o = octonion<T>(a); |
|
4324 } |
|
4325 |
|
4326 finish: |
|
4327 return(is); |
|
4328 } |
|
4329 |
|
4330 |
|
4331 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
4332 template<typename T> |
|
4333 ::std::ostream & operator << ( ::std::ostream & os, |
|
4334 octonion<T> const & o) |
|
4335 #else |
|
4336 template<typename T, typename charT, class traits> |
|
4337 ::std::basic_ostream<charT,traits> & operator << ( ::std::basic_ostream<charT,traits> & os, |
|
4338 octonion<T> const & o) |
|
4339 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
4340 { |
|
4341 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
4342 ::std::ostringstream s; |
|
4343 #else |
|
4344 ::std::basic_ostringstream<charT,traits> s; |
|
4345 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
4346 |
|
4347 s.flags(os.flags()); |
|
4348 #ifdef BOOST_NO_STD_LOCALE |
|
4349 #else |
|
4350 s.imbue(os.getloc()); |
|
4351 #endif /* BOOST_NO_STD_LOCALE */ |
|
4352 s.precision(os.precision()); |
|
4353 |
|
4354 s << '(' << o.R_component_1() << ',' |
|
4355 << o.R_component_2() << ',' |
|
4356 << o.R_component_3() << ',' |
|
4357 << o.R_component_4() << ',' |
|
4358 << o.R_component_5() << ',' |
|
4359 << o.R_component_6() << ',' |
|
4360 << o.R_component_7() << ',' |
|
4361 << o.R_component_8() << ')'; |
|
4362 |
|
4363 return os << s.str(); |
|
4364 } |
|
4365 |
|
4366 |
|
4367 // values |
|
4368 |
|
4369 template<typename T> |
|
4370 inline T real(octonion<T> const & o) |
|
4371 { |
|
4372 return(o.real()); |
|
4373 } |
|
4374 |
|
4375 |
|
4376 template<typename T> |
|
4377 inline octonion<T> unreal(octonion<T> const & o) |
|
4378 { |
|
4379 return(o.unreal()); |
|
4380 } |
|
4381 |
|
4382 |
|
4383 #define BOOST_OCTONION_VALARRAY_LOADER \ |
|
4384 using ::std::valarray; \ |
|
4385 \ |
|
4386 valarray<T> temp(8); \ |
|
4387 \ |
|
4388 temp[0] = o.R_component_1(); \ |
|
4389 temp[1] = o.R_component_2(); \ |
|
4390 temp[2] = o.R_component_3(); \ |
|
4391 temp[3] = o.R_component_4(); \ |
|
4392 temp[4] = o.R_component_5(); \ |
|
4393 temp[5] = o.R_component_6(); \ |
|
4394 temp[6] = o.R_component_7(); \ |
|
4395 temp[7] = o.R_component_8(); |
|
4396 |
|
4397 |
|
4398 template<typename T> |
|
4399 inline T sup(octonion<T> const & o) |
|
4400 { |
|
4401 #ifdef BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP |
|
4402 using ::std::abs; |
|
4403 #endif /* BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP */ |
|
4404 |
|
4405 BOOST_OCTONION_VALARRAY_LOADER |
|
4406 |
|
4407 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
4408 return((BOOST_GET_VALARRAY(T, abs(temp)).max)()); |
|
4409 #else |
|
4410 return((abs(temp).max)()); |
|
4411 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
4412 } |
|
4413 |
|
4414 |
|
4415 template<typename T> |
|
4416 inline T l1(octonion<T> const & o) |
|
4417 { |
|
4418 #ifdef BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP |
|
4419 using ::std::abs; |
|
4420 #endif /* BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP */ |
|
4421 |
|
4422 BOOST_OCTONION_VALARRAY_LOADER |
|
4423 |
|
4424 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
4425 return(BOOST_GET_VALARRAY(T, abs(temp)).sum()); |
|
4426 #else |
|
4427 return(abs(temp).sum()); |
|
4428 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
4429 } |
|
4430 |
|
4431 |
|
4432 template<typename T> |
|
4433 inline T abs(const octonion<T> & o) |
|
4434 { |
|
4435 #ifdef BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP |
|
4436 using ::std::abs; |
|
4437 #endif /* BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP */ |
|
4438 |
|
4439 using ::std::sqrt; |
|
4440 |
|
4441 BOOST_OCTONION_VALARRAY_LOADER |
|
4442 |
|
4443 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
4444 T maxim = (BOOST_GET_VALARRAY(T,abs(temp)).max)(); // overflow protection |
|
4445 #else |
|
4446 T maxim = (abs(temp).max)(); // overflow protection |
|
4447 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
4448 |
|
4449 if (maxim == static_cast<T>(0)) |
|
4450 { |
|
4451 return(maxim); |
|
4452 } |
|
4453 else |
|
4454 { |
|
4455 T mixam = static_cast<T>(1)/maxim; // prefer multiplications over divisions |
|
4456 |
|
4457 temp *= mixam; |
|
4458 |
|
4459 temp *= temp; |
|
4460 |
|
4461 return(maxim*sqrt(temp.sum())); |
|
4462 } |
|
4463 |
|
4464 //return(::std::sqrt(norm(o))); |
|
4465 } |
|
4466 |
|
4467 |
|
4468 #undef BOOST_OCTONION_VALARRAY_LOADER |
|
4469 |
|
4470 |
|
4471 // Note: This is the Cayley norm, not the Euclidian norm... |
|
4472 |
|
4473 template<typename T> |
|
4474 inline T norm(octonion<T> const & o) |
|
4475 { |
|
4476 return(real(o*conj(o))); |
|
4477 } |
|
4478 |
|
4479 |
|
4480 template<typename T> |
|
4481 inline octonion<T> conj(octonion<T> const & o) |
|
4482 { |
|
4483 return(octonion<T>( +o.R_component_1(), |
|
4484 -o.R_component_2(), |
|
4485 -o.R_component_3(), |
|
4486 -o.R_component_4(), |
|
4487 -o.R_component_5(), |
|
4488 -o.R_component_6(), |
|
4489 -o.R_component_7(), |
|
4490 -o.R_component_8())); |
|
4491 } |
|
4492 |
|
4493 |
|
4494 // Note: There is little point, for the octonions, to introduce the equivalents |
|
4495 // to the complex "arg" and the quaternionic "cylindropolar". |
|
4496 |
|
4497 |
|
4498 template<typename T> |
|
4499 inline octonion<T> spherical(T const & rho, |
|
4500 T const & theta, |
|
4501 T const & phi1, |
|
4502 T const & phi2, |
|
4503 T const & phi3, |
|
4504 T const & phi4, |
|
4505 T const & phi5, |
|
4506 T const & phi6) |
|
4507 { |
|
4508 using ::std::cos; |
|
4509 using ::std::sin; |
|
4510 |
|
4511 //T a = cos(theta)*cos(phi1)*cos(phi2)*cos(phi3)*cos(phi4)*cos(phi5)*cos(phi6); |
|
4512 //T b = sin(theta)*cos(phi1)*cos(phi2)*cos(phi3)*cos(phi4)*cos(phi5)*cos(phi6); |
|
4513 //T c = sin(phi1)*cos(phi2)*cos(phi3)*cos(phi4)*cos(phi5)*cos(phi6); |
|
4514 //T d = sin(phi2)*cos(phi3)*cos(phi4)*cos(phi5)*cos(phi6); |
|
4515 //T e = sin(phi3)*cos(phi4)*cos(phi5)*cos(phi6); |
|
4516 //T f = sin(phi4)*cos(phi5)*cos(phi6); |
|
4517 //T g = sin(phi5)*cos(phi6); |
|
4518 //T h = sin(phi6); |
|
4519 |
|
4520 T courrant = static_cast<T>(1); |
|
4521 |
|
4522 T h = sin(phi6); |
|
4523 |
|
4524 courrant *= cos(phi6); |
|
4525 |
|
4526 T g = sin(phi5)*courrant; |
|
4527 |
|
4528 courrant *= cos(phi5); |
|
4529 |
|
4530 T f = sin(phi4)*courrant; |
|
4531 |
|
4532 courrant *= cos(phi4); |
|
4533 |
|
4534 T e = sin(phi3)*courrant; |
|
4535 |
|
4536 courrant *= cos(phi3); |
|
4537 |
|
4538 T d = sin(phi2)*courrant; |
|
4539 |
|
4540 courrant *= cos(phi2); |
|
4541 |
|
4542 T c = sin(phi1)*courrant; |
|
4543 |
|
4544 courrant *= cos(phi1); |
|
4545 |
|
4546 T b = sin(theta)*courrant; |
|
4547 T a = cos(theta)*courrant; |
|
4548 |
|
4549 return(rho*octonion<T>(a,b,c,d,e,f,g,h)); |
|
4550 } |
|
4551 |
|
4552 |
|
4553 template<typename T> |
|
4554 inline octonion<T> multipolar(T const & rho1, |
|
4555 T const & theta1, |
|
4556 T const & rho2, |
|
4557 T const & theta2, |
|
4558 T const & rho3, |
|
4559 T const & theta3, |
|
4560 T const & rho4, |
|
4561 T const & theta4) |
|
4562 { |
|
4563 using ::std::cos; |
|
4564 using ::std::sin; |
|
4565 |
|
4566 T a = rho1*cos(theta1); |
|
4567 T b = rho1*sin(theta1); |
|
4568 T c = rho2*cos(theta2); |
|
4569 T d = rho2*sin(theta2); |
|
4570 T e = rho3*cos(theta3); |
|
4571 T f = rho3*sin(theta3); |
|
4572 T g = rho4*cos(theta4); |
|
4573 T h = rho4*sin(theta4); |
|
4574 |
|
4575 return(octonion<T>(a,b,c,d,e,f,g,h)); |
|
4576 } |
|
4577 |
|
4578 |
|
4579 template<typename T> |
|
4580 inline octonion<T> cylindrical(T const & r, |
|
4581 T const & angle, |
|
4582 T const & h1, |
|
4583 T const & h2, |
|
4584 T const & h3, |
|
4585 T const & h4, |
|
4586 T const & h5, |
|
4587 T const & h6) |
|
4588 { |
|
4589 using ::std::cos; |
|
4590 using ::std::sin; |
|
4591 |
|
4592 T a = r*cos(angle); |
|
4593 T b = r*sin(angle); |
|
4594 |
|
4595 return(octonion<T>(a,b,h1,h2,h3,h4,h5,h6)); |
|
4596 } |
|
4597 |
|
4598 |
|
4599 template<typename T> |
|
4600 inline octonion<T> exp(octonion<T> const & o) |
|
4601 { |
|
4602 using ::std::exp; |
|
4603 using ::std::cos; |
|
4604 |
|
4605 using ::boost::math::sinc_pi; |
|
4606 |
|
4607 T u = exp(real(o)); |
|
4608 |
|
4609 T z = abs(unreal(o)); |
|
4610 |
|
4611 T w = sinc_pi(z); |
|
4612 |
|
4613 return(u*octonion<T>(cos(z), |
|
4614 w*o.R_component_2(), w*o.R_component_3(), |
|
4615 w*o.R_component_4(), w*o.R_component_5(), |
|
4616 w*o.R_component_6(), w*o.R_component_7(), |
|
4617 w*o.R_component_8())); |
|
4618 } |
|
4619 |
|
4620 |
|
4621 template<typename T> |
|
4622 inline octonion<T> cos(octonion<T> const & o) |
|
4623 { |
|
4624 using ::std::sin; |
|
4625 using ::std::cos; |
|
4626 using ::std::cosh; |
|
4627 |
|
4628 using ::boost::math::sinhc_pi; |
|
4629 |
|
4630 T z = abs(unreal(o)); |
|
4631 |
|
4632 T w = -sin(o.real())*sinhc_pi(z); |
|
4633 |
|
4634 return(octonion<T>(cos(o.real())*cosh(z), |
|
4635 w*o.R_component_2(), w*o.R_component_3(), |
|
4636 w*o.R_component_4(), w*o.R_component_5(), |
|
4637 w*o.R_component_6(), w*o.R_component_7(), |
|
4638 w*o.R_component_8())); |
|
4639 } |
|
4640 |
|
4641 |
|
4642 template<typename T> |
|
4643 inline octonion<T> sin(octonion<T> const & o) |
|
4644 { |
|
4645 using ::std::sin; |
|
4646 using ::std::cos; |
|
4647 using ::std::cosh; |
|
4648 |
|
4649 using ::boost::math::sinhc_pi; |
|
4650 |
|
4651 T z = abs(unreal(o)); |
|
4652 |
|
4653 T w = +cos(o.real())*sinhc_pi(z); |
|
4654 |
|
4655 return(octonion<T>(sin(o.real())*cosh(z), |
|
4656 w*o.R_component_2(), w*o.R_component_3(), |
|
4657 w*o.R_component_4(), w*o.R_component_5(), |
|
4658 w*o.R_component_6(), w*o.R_component_7(), |
|
4659 w*o.R_component_8())); |
|
4660 } |
|
4661 |
|
4662 |
|
4663 template<typename T> |
|
4664 inline octonion<T> tan(octonion<T> const & o) |
|
4665 { |
|
4666 return(sin(o)/cos(o)); |
|
4667 } |
|
4668 |
|
4669 |
|
4670 template<typename T> |
|
4671 inline octonion<T> cosh(octonion<T> const & o) |
|
4672 { |
|
4673 return((exp(+o)+exp(-o))/static_cast<T>(2)); |
|
4674 } |
|
4675 |
|
4676 |
|
4677 template<typename T> |
|
4678 inline octonion<T> sinh(octonion<T> const & o) |
|
4679 { |
|
4680 return((exp(+o)-exp(-o))/static_cast<T>(2)); |
|
4681 } |
|
4682 |
|
4683 |
|
4684 template<typename T> |
|
4685 inline octonion<T> tanh(octonion<T> const & o) |
|
4686 { |
|
4687 return(sinh(o)/cosh(o)); |
|
4688 } |
|
4689 |
|
4690 |
|
4691 template<typename T> |
|
4692 octonion<T> pow(octonion<T> const & o, |
|
4693 int n) |
|
4694 { |
|
4695 if (n > 1) |
|
4696 { |
|
4697 int m = n>>1; |
|
4698 |
|
4699 octonion<T> result = pow(o, m); |
|
4700 |
|
4701 result *= result; |
|
4702 |
|
4703 if (n != (m<<1)) |
|
4704 { |
|
4705 result *= o; // n odd |
|
4706 } |
|
4707 |
|
4708 return(result); |
|
4709 } |
|
4710 else if (n == 1) |
|
4711 { |
|
4712 return(o); |
|
4713 } |
|
4714 else if (n == 0) |
|
4715 { |
|
4716 return(octonion<T>(1)); |
|
4717 } |
|
4718 else /* n < 0 */ |
|
4719 { |
|
4720 return(pow(octonion<T>(1)/o,-n)); |
|
4721 } |
|
4722 } |
|
4723 |
|
4724 |
|
4725 // helper templates for converting copy constructors (definition) |
|
4726 |
|
4727 namespace detail |
|
4728 { |
|
4729 |
|
4730 template< typename T, |
|
4731 typename U |
|
4732 > |
|
4733 octonion<T> octonion_type_converter(octonion<U> const & rhs) |
|
4734 { |
|
4735 return(octonion<T>( static_cast<T>(rhs.R_component_1()), |
|
4736 static_cast<T>(rhs.R_component_2()), |
|
4737 static_cast<T>(rhs.R_component_3()), |
|
4738 static_cast<T>(rhs.R_component_4()), |
|
4739 static_cast<T>(rhs.R_component_5()), |
|
4740 static_cast<T>(rhs.R_component_6()), |
|
4741 static_cast<T>(rhs.R_component_7()), |
|
4742 static_cast<T>(rhs.R_component_8()))); |
|
4743 } |
|
4744 } |
|
4745 } |
|
4746 } |
|
4747 |
|
4748 |
|
4749 #if BOOST_WORKAROUND(__GNUC__, < 3) |
|
4750 #undef BOOST_GET_VALARRAY |
|
4751 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ |
|
4752 |
|
4753 |
|
4754 #endif /* BOOST_OCTONION_HPP */ |