Planet

navi

home

PPS

about

screenshots

download

development

forum

Context Navigation

source: downloads/boost_1_33_1/boost/math/octonion.hpp @ 12

Last change on this file since 12 was 12, checked in by landauf, 17 years ago
added boost
File size: 269.4 KB

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

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

Download in other formats: