vamp-build-and-test: DEPENDENCIES/generic/include/boost/math/octonion.hpp annotate

annotate DEPENDENCIES/generic/include/boost/math/octonion.hpp @ 133:4acb5d8d80b6 tip

Don't fail environmental check if README.md exists (but .txt and no-suffix don't)

author	Chris Cannam
date	Tue, 30 Jul 2019 12:25:44 +0100
parents	c530137014c0
children

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

Mercurial > hg > vamp-build-and-test

annotate DEPENDENCIES/generic/include/boost/math/octonion.hpp @ 133:4acb5d8d80b6 tip