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

annotate DEPENDENCIES/generic/include/boost/math/octonion.hpp @ 16:2665513ce2d3

Add boost headers

author	Chris Cannam
date	Tue, 05 Aug 2014 11:11:38 +0100
parents
children	c530137014c0

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

Mercurial > hg > vamp-build-and-test

annotate DEPENDENCIES/generic/include/boost/math/octonion.hpp @ 16:2665513ce2d3