Planet

navi

home

PPS

about

screenshots

download

development

forum

Context Navigation

source: downloads/boost_1_34_1/boost/math/quaternion.hpp @ 46

Last change on this file since 46 was 29, checked in by landauf, 17 years ago
updated boost from 1_33_1 to 1_34_1
File size: 89.5 KB

Line
1	// boost quaternion.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	#ifndef BOOST_QUATERNION_HPP
11	#define BOOST_QUATERNION_HPP
12
13
14	#include <complex>
15	#include <iosfwd> // for the "<<" and ">>" operators
16	#include <sstream> // for the "<<" operator
17
18	#include <boost/config.hpp> // for BOOST_NO_STD_LOCALE
19	#include <boost/detail/workaround.hpp>
20	#ifndef BOOST_NO_STD_LOCALE
21	#include <locale> // for the "<<" operator
22	#endif /* BOOST_NO_STD_LOCALE */
23
24	#include <valarray>
25
26
27
28	#include <boost/math/special_functions/sinc.hpp> // for the Sinus cardinal
29	#include <boost/math/special_functions/sinhc.hpp> // for the Hyperbolic Sinus cardinal
30
31
32	namespace boost
33	{
34	namespace math
35	{
36	#if BOOST_WORKAROUND(__GNUC__, < 3)
37	// gcc 2.95.x uses expression templates for valarray calculations, but
38	// the result is not conforming. We need BOOST_GET_VALARRAY to get an
39	// actual valarray result when we need to call a member function
40	#define BOOST_GET_VALARRAY(T,x) ::std::valarray<T>(x)
41	// gcc 2.95.x has an "std::ios" class that is similar to
42	// "std::ios_base", so we just use a #define
43	#define BOOST_IOS_BASE ::std::ios
44	// gcc 2.x ignores function scope using declarations,
45	// put them in the scope of the enclosing namespace instead:
46	using ::std::valarray;
47	using ::std::sqrt;
48	using ::std::cos;
49	using ::std::sin;
50	using ::std::exp;
51	using ::std::cosh;
52	#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
53
54	#define BOOST_QUATERNION_ACCESSOR_GENERATOR(type) \
55	type real() const \
56	{ \
57	return(a); \
58	} \
59	\
60	quaternion<type> unreal() const \
61	{ \
62	return(quaternion<type>(static_cast<type>(0),b,c,d)); \
63	} \
64	\
65	type R_component_1() const \
66	{ \
67	return(a); \
68	} \
69	\
70	type R_component_2() const \
71	{ \
72	return(b); \
73	} \
74	\
75	type R_component_3() const \
76	{ \
77	return(c); \
78	} \
79	\
80	type R_component_4() const \
81	{ \
82	return(d); \
83	} \
84	\
85	::std::complex<type> C_component_1() const \
86	{ \
87	return(::std::complex<type>(a,b)); \
88	} \
89	\
90	::std::complex<type> C_component_2() const \
91	{ \
92	return(::std::complex<type>(c,d)); \
93	}
94
95
96	#define BOOST_QUATERNION_MEMBER_ASSIGNMENT_GENERATOR(type) \
97	template<typename X> \
98	quaternion<type> & operator = (quaternion<X> const & a_affecter) \
99	{ \
100	a = static_cast<type>(a_affecter.R_component_1()); \
101	b = static_cast<type>(a_affecter.R_component_2()); \
102	c = static_cast<type>(a_affecter.R_component_3()); \
103	d = static_cast<type>(a_affecter.R_component_4()); \
104	\
105	return(*this); \
106	} \
107	\
108	quaternion<type> & operator = (quaternion<type> const & a_affecter) \
109	{ \
110	a = a_affecter.a; \
111	b = a_affecter.b; \
112	c = a_affecter.c; \
113	d = a_affecter.d; \
114	\
115	return(*this); \
116	} \
117	\
118	quaternion<type> & operator = (type const & a_affecter) \
119	{ \
120	a = a_affecter; \
121	\
122	b = c = d = static_cast<type>(0); \
123	\
124	return(*this); \
125	} \
126	\
127	quaternion<type> & operator = (::std::complex<type> const & a_affecter) \
128	{ \
129	a = a_affecter.real(); \
130	b = a_affecter.imag(); \
131	\
132	c = d = static_cast<type>(0); \
133	\
134	return(*this); \
135	}
136
137
138	#define BOOST_QUATERNION_MEMBER_DATA_GENERATOR(type) \
139	type a; \
140	type b; \
141	type c; \
142	type d;
143
144
145	template<typename T>
146	class quaternion
147	{
148	public:
149
150	typedef T value_type;
151
152
153	// constructor for H seen as R^4
154	// (also default constructor)
155
156	explicit quaternion( T const & requested_a = T(),
157	T const & requested_b = T(),
158	T const & requested_c = T(),
159	T const & requested_d = T())
160	: a(requested_a),
161	b(requested_b),
162	c(requested_c),
163	d(requested_d)
164	{
165	// nothing to do!
166	}
167
168
169	// constructor for H seen as C^2
170
171	explicit quaternion( ::std::complex<T> const & z0,
172	::std::complex<T> const & z1 = ::std::complex<T>())
173	: a(z0.real()),
174	b(z0.imag()),
175	c(z1.real()),
176	d(z1.imag())
177	{
178	// nothing to do!
179	}
180
181
182	// UNtemplated copy constructor
183	// (this is taken care of by the compiler itself)
184
185
186	// templated copy constructor
187
188	template<typename X>
189	explicit quaternion(quaternion<X> const & a_recopier)
190	: a(static_cast<T>(a_recopier.R_component_1())),
191	b(static_cast<T>(a_recopier.R_component_2())),
192	c(static_cast<T>(a_recopier.R_component_3())),
193	d(static_cast<T>(a_recopier.R_component_4()))
194	{
195	// nothing to do!
196	}
197
198
199	// destructor
200	// (this is taken care of by the compiler itself)
201
202
203	// accessors
204	//
205	// Note: Like complex number, quaternions do have a meaningful notion of "real part",
206	// but unlike them there is no meaningful notion of "imaginary part".
207	// Instead there is an "unreal part" which itself is a quaternion, and usually
208	// nothing simpler (as opposed to the complex number case).
209	// However, for practicallity, there are accessors for the other components
210	// (these are necessary for the templated copy constructor, for instance).
211
212	BOOST_QUATERNION_ACCESSOR_GENERATOR(T)
213
214	// assignment operators
215
216	BOOST_QUATERNION_MEMBER_ASSIGNMENT_GENERATOR(T)
217
218	// other assignment-related operators
219	//
220	// NOTE: Quaternion multiplication is NOT commutative;
221	// symbolically, "q = rhs;" means "q = q rhs;"
222	// and "q /= rhs;" means "q = q * inverse_of(rhs);"
223
224	quaternion<T> & operator += (T const & rhs)
225	{
226	T at = a + rhs; // exception guard
227
228	a = at;
229
230	return(*this);
231	}
232
233
234	quaternion<T> & operator += (::std::complex<T> const & rhs)
235	{
236	T at = a + rhs.real(); // exception guard
237	T bt = b + rhs.imag(); // exception guard
238
239	a = at;
240	b = bt;
241
242	return(*this);
243	}
244
245
246	template<typename X>
247	quaternion<T> & operator += (quaternion<X> const & rhs)
248	{
249	T at = a + static_cast<T>(rhs.R_component_1()); // exception guard
250	T bt = b + static_cast<T>(rhs.R_component_2()); // exception guard
251	T ct = c + static_cast<T>(rhs.R_component_3()); // exception guard
252	T dt = d + static_cast<T>(rhs.R_component_4()); // exception guard
253
254	a = at;
255	b = bt;
256	c = ct;
257	d = dt;
258
259	return(*this);
260	}
261
262
263
264	quaternion<T> & operator -= (T const & rhs)
265	{
266	T at = a - rhs; // exception guard
267
268	a = at;
269
270	return(*this);
271	}
272
273
274	quaternion<T> & operator -= (::std::complex<T> const & rhs)
275	{
276	T at = a - rhs.real(); // exception guard
277	T bt = b - rhs.imag(); // exception guard
278
279	a = at;
280	b = bt;
281
282	return(*this);
283	}
284
285
286	template<typename X>
287	quaternion<T> & operator -= (quaternion<X> const & rhs)
288	{
289	T at = a - static_cast<T>(rhs.R_component_1()); // exception guard
290	T bt = b - static_cast<T>(rhs.R_component_2()); // exception guard
291	T ct = c - static_cast<T>(rhs.R_component_3()); // exception guard
292	T dt = d - static_cast<T>(rhs.R_component_4()); // exception guard
293
294	a = at;
295	b = bt;
296	c = ct;
297	d = dt;
298
299	return(*this);
300	}
301
302
303	quaternion<T> & operator *= (T const & rhs)
304	{
305	T at = a * rhs; // exception guard
306	T bt = b * rhs; // exception guard
307	T ct = c * rhs; // exception guard
308	T dt = d * rhs; // exception guard
309
310	a = at;
311	b = bt;
312	c = ct;
313	d = dt;
314
315	return(*this);
316	}
317
318
319	quaternion<T> & operator *= (::std::complex<T> const & rhs)
320	{
321	T ar = rhs.real();
322	T br = rhs.imag();
323
324	T at = +aar-bbr;
325	T bt = +abr+bar;
326	T ct = +car+dbr;
327	T dt = -cbr+dar;
328
329	a = at;
330	b = bt;
331	c = ct;
332	d = dt;
333
334	return(*this);
335	}
336
337
338	template<typename X>
339	quaternion<T> & operator *= (quaternion<X> const & rhs)
340	{
341	T ar = static_cast<T>(rhs.R_component_1());
342	T br = static_cast<T>(rhs.R_component_2());
343	T cr = static_cast<T>(rhs.R_component_3());
344	T dr = static_cast<T>(rhs.R_component_4());
345
346	T at = +aar-bbr-ccr-ddr;
347	T bt = +abr+bar+cdr-dcr; //(abr+arb)+(cdr-crd);
348	T ct = +acr-bdr+car+dbr; //(acr+arc)+(dbr-drb);
349	T dt = +adr+bcr-cbr+dar; //(adr+ard)+(bcr-brc);
350
351	a = at;
352	b = bt;
353	c = ct;
354	d = dt;
355
356	return(*this);
357	}
358
359
360
361	quaternion<T> & operator /= (T const & rhs)
362	{
363	T at = a / rhs; // exception guard
364	T bt = b / rhs; // exception guard
365	T ct = c / rhs; // exception guard
366	T dt = d / rhs; // exception guard
367
368	a = at;
369	b = bt;
370	c = ct;
371	d = dt;
372
373	return(*this);
374	}
375
376
377	quaternion<T> & operator /= (::std::complex<T> const & rhs)
378	{
379	T ar = rhs.real();
380	T br = rhs.imag();
381
382	T denominator = arar+brbr;
383
384	T at = (+aar+bbr)/denominator; //(aar+bbr)/denominator;
385	T bt = (-abr+bar)/denominator; //(arb-abr)/denominator;
386	T ct = (+car-dbr)/denominator; //(arc-dbr)/denominator;
387	T dt = (+cbr+dar)/denominator; //(ard+brc)/denominator;
388
389	a = at;
390	b = bt;
391	c = ct;
392	d = dt;
393
394	return(*this);
395	}
396
397
398	template<typename X>
399	quaternion<T> & operator /= (quaternion<X> const & rhs)
400	{
401	T ar = static_cast<T>(rhs.R_component_1());
402	T br = static_cast<T>(rhs.R_component_2());
403	T cr = static_cast<T>(rhs.R_component_3());
404	T dr = static_cast<T>(rhs.R_component_4());
405
406	T denominator = arar+brbr+crcr+drdr;
407
408	T at = (+aar+bbr+ccr+ddr)/denominator; //(aar+bbr+ccr+ddr)/denominator;
409	T bt = (-abr+bar-cdr+dcr)/denominator; //((arb-abr)+(crd-cdr))/denominator;
410	T ct = (-acr+bdr+car-dbr)/denominator; //((arc-acr)+(drb-dbr))/denominator;
411	T dt = (-adr-bcr+cbr+dar)/denominator; //((ard-adr)+(brc-bcr))/denominator;
412
413	a = at;
414	b = bt;
415	c = ct;
416	d = dt;
417
418	return(*this);
419	}
420
421
422	protected:
423
424	BOOST_QUATERNION_MEMBER_DATA_GENERATOR(T)
425
426
427	private:
428
429	};
430
431
432	// declaration of quaternion specialization
433
434	template<> class quaternion<float>;
435	template<> class quaternion<double>;
436	template<> class quaternion<long double>;
437
438
439	// helper templates for converting copy constructors (declaration)
440
441	namespace detail
442	{
443
444	template< typename T,
445	typename U
446	>
447	quaternion<T> quaternion_type_converter(quaternion<U> const & rhs);
448	}
449
450
451	// implementation of quaternion specialization
452
453
454	#define BOOST_QUATERNION_CONSTRUCTOR_GENERATOR(type) \
455	explicit quaternion( type const & requested_a = static_cast<type>(0), \
456	type const & requested_b = static_cast<type>(0), \
457	type const & requested_c = static_cast<type>(0), \
458	type const & requested_d = static_cast<type>(0)) \
459	: a(requested_a), \
460	b(requested_b), \
461	c(requested_c), \
462	d(requested_d) \
463	{ \
464	} \
465	\
466	explicit quaternion( ::std::complex<type> const & z0, \
467	::std::complex<type> const & z1 = ::std::complex<type>()) \
468	: a(z0.real()), \
469	b(z0.imag()), \
470	c(z1.real()), \
471	d(z1.imag()) \
472	{ \
473	}
474
475
476	#define BOOST_QUATERNION_MEMBER_ADD_GENERATOR_1(type) \
477	quaternion<type> & operator += (type const & rhs) \
478	{ \
479	a += rhs; \
480	\
481	return(*this); \
482	}
483
484	#define BOOST_QUATERNION_MEMBER_ADD_GENERATOR_2(type) \
485	quaternion<type> & operator += (::std::complex<type> const & rhs) \
486	{ \
487	a += rhs.real(); \
488	b += rhs.imag(); \
489	\
490	return(*this); \
491	}
492
493	#define BOOST_QUATERNION_MEMBER_ADD_GENERATOR_3(type) \
494	template<typename X> \
495	quaternion<type> & operator += (quaternion<X> const & rhs) \
496	{ \
497	a += static_cast<type>(rhs.R_component_1()); \
498	b += static_cast<type>(rhs.R_component_2()); \
499	c += static_cast<type>(rhs.R_component_3()); \
500	d += static_cast<type>(rhs.R_component_4()); \
501	\
502	return(*this); \
503	}
504
505	#define BOOST_QUATERNION_MEMBER_SUB_GENERATOR_1(type) \
506	quaternion<type> & operator -= (type const & rhs) \
507	{ \
508	a -= rhs; \
509	\
510	return(*this); \
511	}
512
513	#define BOOST_QUATERNION_MEMBER_SUB_GENERATOR_2(type) \
514	quaternion<type> & operator -= (::std::complex<type> const & rhs) \
515	{ \
516	a -= rhs.real(); \
517	b -= rhs.imag(); \
518	\
519	return(*this); \
520	}
521
522	#define BOOST_QUATERNION_MEMBER_SUB_GENERATOR_3(type) \
523	template<typename X> \
524	quaternion<type> & operator -= (quaternion<X> const & rhs) \
525	{ \
526	a -= static_cast<type>(rhs.R_component_1()); \
527	b -= static_cast<type>(rhs.R_component_2()); \
528	c -= static_cast<type>(rhs.R_component_3()); \
529	d -= static_cast<type>(rhs.R_component_4()); \
530	\
531	return(*this); \
532	}
533
534	#define BOOST_QUATERNION_MEMBER_MUL_GENERATOR_1(type) \
535	quaternion<type> & operator *= (type const & rhs) \
536	{ \
537	a *= rhs; \
538	b *= rhs; \
539	c *= rhs; \
540	d *= rhs; \
541	\
542	return(*this); \
543	}
544
545	#define BOOST_QUATERNION_MEMBER_MUL_GENERATOR_2(type) \
546	quaternion<type> & operator *= (::std::complex<type> const & rhs) \
547	{ \
548	type ar = rhs.real(); \
549	type br = rhs.imag(); \
550	\
551	type at = +aar-bbr; \
552	type bt = +abr+bar; \
553	type ct = +car+dbr; \
554	type dt = -cbr+dar; \
555	\
556	a = at; \
557	b = bt; \
558	c = ct; \
559	d = dt; \
560	\
561	return(*this); \
562	}
563
564	#define BOOST_QUATERNION_MEMBER_MUL_GENERATOR_3(type) \
565	template<typename X> \
566	quaternion<type> & operator *= (quaternion<X> const & rhs) \
567	{ \
568	type ar = static_cast<type>(rhs.R_component_1()); \
569	type br = static_cast<type>(rhs.R_component_2()); \
570	type cr = static_cast<type>(rhs.R_component_3()); \
571	type dr = static_cast<type>(rhs.R_component_4()); \
572	\
573	type at = +aar-bbr-ccr-ddr; \
574	type bt = +abr+bar+cdr-dcr; \
575	type ct = +acr-bdr+car+dbr; \
576	type dt = +adr+bcr-cbr+dar; \
577	\
578	a = at; \
579	b = bt; \
580	c = ct; \
581	d = dt; \
582	\
583	return(*this); \
584	}
585
586	// There is quite a lot of repetition in the code below. This is intentional.
587	// The last conditional block is the normal form, and the others merely
588	// consist of workarounds for various compiler deficiencies. Hopefuly, when
589	// more compilers are conformant and we can retire support for those that are
590	// not, we will be able to remove the clutter. This is makes the situation
591	// (painfully) explicit.
592
593	#define BOOST_QUATERNION_MEMBER_DIV_GENERATOR_1(type) \
594	quaternion<type> & operator /= (type const & rhs) \
595	{ \
596	a /= rhs; \
597	b /= rhs; \
598	c /= rhs; \
599	d /= rhs; \
600	\
601	return(*this); \
602	}
603
604	#if defined(__GNUC__) && (__GNUC__ < 3)
605	#define BOOST_QUATERNION_MEMBER_DIV_GENERATOR_2(type) \
606	quaternion<type> & operator /= (::std::complex<type> const & rhs) \
607	{ \
608	using ::std::valarray; \
609	\
610	valarray<type> tr(2); \
611	\
612	tr[0] = rhs.real(); \
613	tr[1] = rhs.imag(); \
614	\
615	type mixam = (BOOST_GET_VALARRAY(type,static_cast<type>(1)/abs(tr)).max)(); \
616	\
617	tr *= mixam; \
618	\
619	valarray<type> tt(4); \
620	\
621	tt[0] = +atr[0]+btr[1]; \
622	tt[1] = -atr[1]+btr[0]; \
623	tt[2] = +ctr[0]-dtr[1]; \
624	tt[3] = +ctr[1]+dtr[0]; \
625	\
626	tr *= tr; \
627	\
628	tt *= (mixam/tr.sum()); \
629	\
630	a = tt[0]; \
631	b = tt[1]; \
632	c = tt[2]; \
633	d = tt[3]; \
634	\
635	return(*this); \
636	}
637	#elif defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
638	#define BOOST_QUATERNION_MEMBER_DIV_GENERATOR_2(type) \
639	quaternion<type> & operator /= (::std::complex<type> const & rhs) \
640	{ \
641	using ::std::valarray; \
642	using ::std::abs; \
643	\
644	valarray<type> tr(2); \
645	\
646	tr[0] = rhs.real(); \
647	tr[1] = rhs.imag(); \
648	\
649	type mixam = static_cast<type>(1)/(abs(tr).max)(); \
650	\
651	tr *= mixam; \
652	\
653	valarray<type> tt(4); \
654	\
655	tt[0] = +atr[0]+btr[1]; \
656	tt[1] = -atr[1]+btr[0]; \
657	tt[2] = +ctr[0]-dtr[1]; \
658	tt[3] = +ctr[1]+dtr[0]; \
659	\
660	tr *= tr; \
661	\
662	tt *= (mixam/tr.sum()); \
663	\
664	a = tt[0]; \
665	b = tt[1]; \
666	c = tt[2]; \
667	d = tt[3]; \
668	\
669	return(*this); \
670	}
671	#else
672	#define BOOST_QUATERNION_MEMBER_DIV_GENERATOR_2(type) \
673	quaternion<type> & operator /= (::std::complex<type> const & rhs) \
674	{ \
675	using ::std::valarray; \
676	\
677	valarray<type> tr(2); \
678	\
679	tr[0] = rhs.real(); \
680	tr[1] = rhs.imag(); \
681	\
682	type mixam = static_cast<type>(1)/(abs(tr).max)(); \
683	\
684	tr *= mixam; \
685	\
686	valarray<type> tt(4); \
687	\
688	tt[0] = +atr[0]+btr[1]; \
689	tt[1] = -atr[1]+btr[0]; \
690	tt[2] = +ctr[0]-dtr[1]; \
691	tt[3] = +ctr[1]+dtr[0]; \
692	\
693	tr *= tr; \
694	\
695	tt *= (mixam/tr.sum()); \
696	\
697	a = tt[0]; \
698	b = tt[1]; \
699	c = tt[2]; \
700	d = tt[3]; \
701	\
702	return(*this); \
703	}
704	#endif /* defined(__GNUC__) && (__GNUC__ < 3) / / BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP */
705
706	#if defined(__GNUC__) && (__GNUC__ < 3)
707	#define BOOST_QUATERNION_MEMBER_DIV_GENERATOR_3(type) \
708	template<typename X> \
709	quaternion<type> & operator /= (quaternion<X> const & rhs) \
710	{ \
711	using ::std::valarray; \
712	\
713	valarray<type> tr(4); \
714	\
715	tr[0] = static_cast<type>(rhs.R_component_1()); \
716	tr[1] = static_cast<type>(rhs.R_component_2()); \
717	tr[2] = static_cast<type>(rhs.R_component_3()); \
718	tr[3] = static_cast<type>(rhs.R_component_4()); \
719	\
720	type mixam = (BOOST_GET_VALARRAY(type,static_cast<type>(1)/abs(tr)).max)(); \
721	\
722	tr *= mixam; \
723	\
724	valarray<type> tt(4); \
725	\
726	tt[0] = +atr[0]+btr[1]+ctr[2]+dtr[3]; \
727	tt[1] = -atr[1]+btr[0]-ctr[3]+dtr[2]; \
728	tt[2] = -atr[2]+btr[3]+ctr[0]-dtr[1]; \
729	tt[3] = -atr[3]-btr[2]+ctr[1]+dtr[0]; \
730	\
731	tr *= tr; \
732	\
733	tt *= (mixam/tr.sum()); \
734	\
735	a = tt[0]; \
736	b = tt[1]; \
737	c = tt[2]; \
738	d = tt[3]; \
739	\
740	return(*this); \
741	}
742	#elif defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
743	#define BOOST_QUATERNION_MEMBER_DIV_GENERATOR_3(type) \
744	template<typename X> \
745	quaternion<type> & operator /= (quaternion<X> const & rhs) \
746	{ \
747	using ::std::valarray; \
748	using ::std::abs; \
749	\
750	valarray<type> tr(4); \
751	\
752	tr[0] = static_cast<type>(rhs.R_component_1()); \
753	tr[1] = static_cast<type>(rhs.R_component_2()); \
754	tr[2] = static_cast<type>(rhs.R_component_3()); \
755	tr[3] = static_cast<type>(rhs.R_component_4()); \
756	\
757	type mixam = static_cast<type>(1)/(abs(tr).max)(); \
758	\
759	tr *= mixam; \
760	\
761	valarray<type> tt(4); \
762	\
763	tt[0] = +atr[0]+btr[1]+ctr[2]+dtr[3]; \
764	tt[1] = -atr[1]+btr[0]-ctr[3]+dtr[2]; \
765	tt[2] = -atr[2]+btr[3]+ctr[0]-dtr[1]; \
766	tt[3] = -atr[3]-btr[2]+ctr[1]+dtr[0]; \
767	\
768	tr *= tr; \
769	\
770	tt *= (mixam/tr.sum()); \
771	\
772	a = tt[0]; \
773	b = tt[1]; \
774	c = tt[2]; \
775	d = tt[3]; \
776	\
777	return(*this); \
778	}
779	#else
780	#define BOOST_QUATERNION_MEMBER_DIV_GENERATOR_3(type) \
781	template<typename X> \
782	quaternion<type> & operator /= (quaternion<X> const & rhs) \
783	{ \
784	using ::std::valarray; \
785	\
786	valarray<type> tr(4); \
787	\
788	tr[0] = static_cast<type>(rhs.R_component_1()); \
789	tr[1] = static_cast<type>(rhs.R_component_2()); \
790	tr[2] = static_cast<type>(rhs.R_component_3()); \
791	tr[3] = static_cast<type>(rhs.R_component_4()); \
792	\
793	type mixam = static_cast<type>(1)/(abs(tr).max)(); \
794	\
795	tr *= mixam; \
796	\
797	valarray<type> tt(4); \
798	\
799	tt[0] = +atr[0]+btr[1]+ctr[2]+dtr[3]; \
800	tt[1] = -atr[1]+btr[0]-ctr[3]+dtr[2]; \
801	tt[2] = -atr[2]+btr[3]+ctr[0]-dtr[1]; \
802	tt[3] = -atr[3]-btr[2]+ctr[1]+dtr[0]; \
803	\
804	tr *= tr; \
805	\
806	tt *= (mixam/tr.sum()); \
807	\
808	a = tt[0]; \
809	b = tt[1]; \
810	c = tt[2]; \
811	d = tt[3]; \
812	\
813	return(*this); \
814	}
815	#endif /* defined(__GNUC__) && (__GNUC__ < 3) / / BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP */
816
817	#define BOOST_QUATERNION_MEMBER_ADD_GENERATOR(type) \
818	BOOST_QUATERNION_MEMBER_ADD_GENERATOR_1(type) \
819	BOOST_QUATERNION_MEMBER_ADD_GENERATOR_2(type) \
820	BOOST_QUATERNION_MEMBER_ADD_GENERATOR_3(type)
821
822	#define BOOST_QUATERNION_MEMBER_SUB_GENERATOR(type) \
823	BOOST_QUATERNION_MEMBER_SUB_GENERATOR_1(type) \
824	BOOST_QUATERNION_MEMBER_SUB_GENERATOR_2(type) \
825	BOOST_QUATERNION_MEMBER_SUB_GENERATOR_3(type)
826
827	#define BOOST_QUATERNION_MEMBER_MUL_GENERATOR(type) \
828	BOOST_QUATERNION_MEMBER_MUL_GENERATOR_1(type) \
829	BOOST_QUATERNION_MEMBER_MUL_GENERATOR_2(type) \
830	BOOST_QUATERNION_MEMBER_MUL_GENERATOR_3(type)
831
832	#define BOOST_QUATERNION_MEMBER_DIV_GENERATOR(type) \
833	BOOST_QUATERNION_MEMBER_DIV_GENERATOR_1(type) \
834	BOOST_QUATERNION_MEMBER_DIV_GENERATOR_2(type) \
835	BOOST_QUATERNION_MEMBER_DIV_GENERATOR_3(type)
836
837	#define BOOST_QUATERNION_MEMBER_ALGEBRAIC_GENERATOR(type) \
838	BOOST_QUATERNION_MEMBER_ADD_GENERATOR(type) \
839	BOOST_QUATERNION_MEMBER_SUB_GENERATOR(type) \
840	BOOST_QUATERNION_MEMBER_MUL_GENERATOR(type) \
841	BOOST_QUATERNION_MEMBER_DIV_GENERATOR(type)
842
843
844	template<>
845	class quaternion<float>
846	{
847	public:
848
849	typedef float value_type;
850
851	BOOST_QUATERNION_CONSTRUCTOR_GENERATOR(float)
852
853	// UNtemplated copy constructor
854	// (this is taken care of by the compiler itself)
855
856	// explicit copy constructors (precision-loosing converters)
857
858	explicit quaternion(quaternion<double> const & a_recopier)
859	{
860	*this = detail::quaternion_type_converter<float, double>(a_recopier);
861	}
862
863	explicit quaternion(quaternion<long double> const & a_recopier)
864	{
865	*this = detail::quaternion_type_converter<float, long double>(a_recopier);
866	}
867
868	// destructor
869	// (this is taken care of by the compiler itself)
870
871	// accessors
872	//
873	// Note: Like complex number, quaternions do have a meaningful notion of "real part",
874	// but unlike them there is no meaningful notion of "imaginary part".
875	// Instead there is an "unreal part" which itself is a quaternion, and usually
876	// nothing simpler (as opposed to the complex number case).
877	// However, for practicallity, there are accessors for the other components
878	// (these are necessary for the templated copy constructor, for instance).
879
880	BOOST_QUATERNION_ACCESSOR_GENERATOR(float)
881
882	// assignment operators
883
884	BOOST_QUATERNION_MEMBER_ASSIGNMENT_GENERATOR(float)
885
886	// other assignment-related operators
887	//
888	// NOTE: Quaternion multiplication is NOT commutative;
889	// symbolically, "q = rhs;" means "q = q rhs;"
890	// and "q /= rhs;" means "q = q * inverse_of(rhs);"
891
892	BOOST_QUATERNION_MEMBER_ALGEBRAIC_GENERATOR(float)
893
894
895	protected:
896
897	BOOST_QUATERNION_MEMBER_DATA_GENERATOR(float)
898
899
900	private:
901
902	};
903
904
905	template<>
906	class quaternion<double>
907	{
908	public:
909
910	typedef double value_type;
911
912	BOOST_QUATERNION_CONSTRUCTOR_GENERATOR(double)
913
914	// UNtemplated copy constructor
915	// (this is taken care of by the compiler itself)
916
917	// converting copy constructor
918
919	explicit quaternion(quaternion<float> const & a_recopier)
920	{
921	*this = detail::quaternion_type_converter<double, float>(a_recopier);
922	}
923
924	// explicit copy constructors (precision-loosing converters)
925
926	explicit quaternion(quaternion<long double> const & a_recopier)
927	{
928	*this = detail::quaternion_type_converter<double, long double>(a_recopier);
929	}
930
931	// destructor
932	// (this is taken care of by the compiler itself)
933
934	// accessors
935	//
936	// Note: Like complex number, quaternions do have a meaningful notion of "real part",
937	// but unlike them there is no meaningful notion of "imaginary part".
938	// Instead there is an "unreal part" which itself is a quaternion, and usually
939	// nothing simpler (as opposed to the complex number case).
940	// However, for practicallity, there are accessors for the other components
941	// (these are necessary for the templated copy constructor, for instance).
942
943	BOOST_QUATERNION_ACCESSOR_GENERATOR(double)
944
945	// assignment operators
946
947	BOOST_QUATERNION_MEMBER_ASSIGNMENT_GENERATOR(double)
948
949	// other assignment-related operators
950	//
951	// NOTE: Quaternion multiplication is NOT commutative;
952	// symbolically, "q = rhs;" means "q = q rhs;"
953	// and "q /= rhs;" means "q = q * inverse_of(rhs);"
954
955	BOOST_QUATERNION_MEMBER_ALGEBRAIC_GENERATOR(double)
956
957
958	protected:
959
960	BOOST_QUATERNION_MEMBER_DATA_GENERATOR(double)
961
962
963	private:
964
965	};
966
967
968	template<>
969	class quaternion<long double>
970	{
971	public:
972
973	typedef long double value_type;
974
975	BOOST_QUATERNION_CONSTRUCTOR_GENERATOR(long double)
976
977	// UNtemplated copy constructor
978	// (this is taken care of by the compiler itself)
979
980	// converting copy constructors
981
982	explicit quaternion(quaternion<float> const & a_recopier)
983	{
984	*this = detail::quaternion_type_converter<long double, float>(a_recopier);
985	}
986
987	explicit quaternion(quaternion<double> const & a_recopier)
988	{
989	*this = detail::quaternion_type_converter<long double, double>(a_recopier);
990	}
991
992	// destructor
993	// (this is taken care of by the compiler itself)
994
995	// accessors
996	//
997	// Note: Like complex number, quaternions do have a meaningful notion of "real part",
998	// but unlike them there is no meaningful notion of "imaginary part".
999	// Instead there is an "unreal part" which itself is a quaternion, and usually
1000	// nothing simpler (as opposed to the complex number case).
1001	// However, for practicallity, there are accessors for the other components
1002	// (these are necessary for the templated copy constructor, for instance).
1003
1004	BOOST_QUATERNION_ACCESSOR_GENERATOR(long double)
1005
1006	// assignment operators
1007
1008	BOOST_QUATERNION_MEMBER_ASSIGNMENT_GENERATOR(long double)
1009
1010	// other assignment-related operators
1011	//
1012	// NOTE: Quaternion multiplication is NOT commutative;
1013	// symbolically, "q = rhs;" means "q = q rhs;"
1014	// and "q /= rhs;" means "q = q * inverse_of(rhs);"
1015
1016	BOOST_QUATERNION_MEMBER_ALGEBRAIC_GENERATOR(long double)
1017
1018
1019	protected:
1020
1021	BOOST_QUATERNION_MEMBER_DATA_GENERATOR(long double)
1022
1023
1024	private:
1025
1026	};
1027
1028
1029	#undef BOOST_QUATERNION_MEMBER_ALGEBRAIC_GENERATOR
1030	#undef BOOST_QUATERNION_MEMBER_ADD_GENERATOR
1031	#undef BOOST_QUATERNION_MEMBER_SUB_GENERATOR
1032	#undef BOOST_QUATERNION_MEMBER_MUL_GENERATOR
1033	#undef BOOST_QUATERNION_MEMBER_DIV_GENERATOR
1034	#undef BOOST_QUATERNION_MEMBER_ADD_GENERATOR_1
1035	#undef BOOST_QUATERNION_MEMBER_ADD_GENERATOR_2
1036	#undef BOOST_QUATERNION_MEMBER_ADD_GENERATOR_3
1037	#undef BOOST_QUATERNION_MEMBER_SUB_GENERATOR_1
1038	#undef BOOST_QUATERNION_MEMBER_SUB_GENERATOR_2
1039	#undef BOOST_QUATERNION_MEMBER_SUB_GENERATOR_3
1040	#undef BOOST_QUATERNION_MEMBER_MUL_GENERATOR_1
1041	#undef BOOST_QUATERNION_MEMBER_MUL_GENERATOR_2
1042	#undef BOOST_QUATERNION_MEMBER_MUL_GENERATOR_3
1043	#undef BOOST_QUATERNION_MEMBER_DIV_GENERATOR_1
1044	#undef BOOST_QUATERNION_MEMBER_DIV_GENERATOR_2
1045	#undef BOOST_QUATERNION_MEMBER_DIV_GENERATOR_3
1046
1047	#undef BOOST_QUATERNION_CONSTRUCTOR_GENERATOR
1048
1049
1050	#undef BOOST_QUATERNION_MEMBER_ASSIGNMENT_GENERATOR
1051
1052	#undef BOOST_QUATERNION_MEMBER_DATA_GENERATOR
1053
1054	#undef BOOST_QUATERNION_ACCESSOR_GENERATOR
1055
1056
1057	// operators
1058
1059	#define BOOST_QUATERNION_OPERATOR_GENERATOR_BODY(op) \
1060	{ \
1061	quaternion<T> res(lhs); \
1062	res op##= rhs; \
1063	return(res); \
1064	}
1065
1066	#define BOOST_QUATERNION_OPERATOR_GENERATOR_1_L(op) \
1067	template<typename T> \
1068	inline quaternion<T> operator op (T const & lhs, quaternion<T> const & rhs) \
1069	BOOST_QUATERNION_OPERATOR_GENERATOR_BODY(op)
1070
1071	#define BOOST_QUATERNION_OPERATOR_GENERATOR_1_R(op) \
1072	template<typename T> \
1073	inline quaternion<T> operator op (quaternion<T> const & lhs, T const & rhs) \
1074	BOOST_QUATERNION_OPERATOR_GENERATOR_BODY(op)
1075
1076	#define BOOST_QUATERNION_OPERATOR_GENERATOR_2_L(op) \
1077	template<typename T> \
1078	inline quaternion<T> operator op (::std::complex<T> const & lhs, quaternion<T> const & rhs) \
1079	BOOST_QUATERNION_OPERATOR_GENERATOR_BODY(op)
1080
1081	#define BOOST_QUATERNION_OPERATOR_GENERATOR_2_R(op) \
1082	template<typename T> \
1083	inline quaternion<T> operator op (quaternion<T> const & lhs, ::std::complex<T> const & rhs) \
1084	BOOST_QUATERNION_OPERATOR_GENERATOR_BODY(op)
1085
1086	#define BOOST_QUATERNION_OPERATOR_GENERATOR_3(op) \
1087	template<typename T> \
1088	inline quaternion<T> operator op (quaternion<T> const & lhs, quaternion<T> const & rhs) \
1089	BOOST_QUATERNION_OPERATOR_GENERATOR_BODY(op)
1090
1091	#define BOOST_QUATERNION_OPERATOR_GENERATOR(op) \
1092	BOOST_QUATERNION_OPERATOR_GENERATOR_1_L(op) \
1093	BOOST_QUATERNION_OPERATOR_GENERATOR_1_R(op) \
1094	BOOST_QUATERNION_OPERATOR_GENERATOR_2_L(op) \
1095	BOOST_QUATERNION_OPERATOR_GENERATOR_2_R(op) \
1096	BOOST_QUATERNION_OPERATOR_GENERATOR_3(op)
1097
1098
1099	BOOST_QUATERNION_OPERATOR_GENERATOR(+)
1100	BOOST_QUATERNION_OPERATOR_GENERATOR(-)
1101	BOOST_QUATERNION_OPERATOR_GENERATOR(*)
1102	BOOST_QUATERNION_OPERATOR_GENERATOR(/)
1103
1104
1105	#undef BOOST_QUATERNION_OPERATOR_GENERATOR
1106
1107	#undef BOOST_QUATERNION_OPERATOR_GENERATOR_1_L
1108	#undef BOOST_QUATERNION_OPERATOR_GENERATOR_1_R
1109	#undef BOOST_QUATERNION_OPERATOR_GENERATOR_2_L
1110	#undef BOOST_QUATERNION_OPERATOR_GENERATOR_2_R
1111	#undef BOOST_QUATERNION_OPERATOR_GENERATOR_3
1112
1113	#undef BOOST_QUATERNION_OPERATOR_GENERATOR_BODY
1114
1115
1116	template<typename T>
1117	inline quaternion<T> operator + (quaternion<T> const & q)
1118	{
1119	return(q);
1120	}
1121
1122
1123	template<typename T>
1124	inline quaternion<T> operator - (quaternion<T> const & q)
1125	{
1126	return(quaternion<T>(-q.R_component_1(),-q.R_component_2(),-q.R_component_3(),-q.R_component_4()));
1127	}
1128
1129
1130	template<typename T>
1131	inline bool operator == (T const & lhs, quaternion<T> const & rhs)
1132	{
1133	return (
1134	(rhs.R_component_1() == lhs)&&
1135	(rhs.R_component_2() == static_cast<T>(0))&&
1136	(rhs.R_component_3() == static_cast<T>(0))&&
1137	(rhs.R_component_4() == static_cast<T>(0))
1138	);
1139	}
1140
1141
1142	template<typename T>
1143	inline bool operator == (quaternion<T> const & lhs, T const & rhs)
1144	{
1145	return (
1146	(lhs.R_component_1() == rhs)&&
1147	(lhs.R_component_2() == static_cast<T>(0))&&
1148	(lhs.R_component_3() == static_cast<T>(0))&&
1149	(lhs.R_component_4() == static_cast<T>(0))
1150	);
1151	}
1152
1153
1154	template<typename T>
1155	inline bool operator == (::std::complex<T> const & lhs, quaternion<T> const & rhs)
1156	{
1157	return (
1158	(rhs.R_component_1() == lhs.real())&&
1159	(rhs.R_component_2() == lhs.imag())&&
1160	(rhs.R_component_3() == static_cast<T>(0))&&
1161	(rhs.R_component_4() == static_cast<T>(0))
1162	);
1163	}
1164
1165
1166	template<typename T>
1167	inline bool operator == (quaternion<T> const & lhs, ::std::complex<T> const & rhs)
1168	{
1169	return (
1170	(lhs.R_component_1() == rhs.real())&&
1171	(lhs.R_component_2() == rhs.imag())&&
1172	(lhs.R_component_3() == static_cast<T>(0))&&
1173	(lhs.R_component_4() == static_cast<T>(0))
1174	);
1175	}
1176
1177
1178	template<typename T>
1179	inline bool operator == (quaternion<T> const & lhs, quaternion<T> const & rhs)
1180	{
1181	return (
1182	(rhs.R_component_1() == lhs.R_component_1())&&
1183	(rhs.R_component_2() == lhs.R_component_2())&&
1184	(rhs.R_component_3() == lhs.R_component_3())&&
1185	(rhs.R_component_4() == lhs.R_component_4())
1186	);
1187	}
1188
1189
1190	#define BOOST_QUATERNION_NOT_EQUAL_GENERATOR \
1191	{ \
1192	return(!(lhs == rhs)); \
1193	}
1194
1195	template<typename T>
1196	inline bool operator != (T const & lhs, quaternion<T> const & rhs)
1197	BOOST_QUATERNION_NOT_EQUAL_GENERATOR
1198
1199	template<typename T>
1200	inline bool operator != (quaternion<T> const & lhs, T const & rhs)
1201	BOOST_QUATERNION_NOT_EQUAL_GENERATOR
1202
1203	template<typename T>
1204	inline bool operator != (::std::complex<T> const & lhs, quaternion<T> const & rhs)
1205	BOOST_QUATERNION_NOT_EQUAL_GENERATOR
1206
1207	template<typename T>
1208	inline bool operator != (quaternion<T> const & lhs, ::std::complex<T> const & rhs)
1209	BOOST_QUATERNION_NOT_EQUAL_GENERATOR
1210
1211	template<typename T>
1212	inline bool operator != (quaternion<T> const & lhs, quaternion<T> const & rhs)
1213	BOOST_QUATERNION_NOT_EQUAL_GENERATOR
1214
1215	#undef BOOST_QUATERNION_NOT_EQUAL_GENERATOR
1216
1217
1218	// Note: we allow the following formats, whith a, b, c, and d reals
1219	// a
1220	// (a), (a,b), (a,b,c), (a,b,c,d)
1221	// (a,(c)), (a,(c,d)), ((a)), ((a),c), ((a),(c)), ((a),(c,d)), ((a,b)), ((a,b),c), ((a,b),(c)), ((a,b),(c,d))
1222	#if BOOST_WORKAROUND(__GNUC__, < 3)
1223	template<typename T>
1224	std::istream & operator >> ( ::std::istream & is,
1225	quaternion<T> & q)
1226	#else
1227	template<typename T, typename charT, class traits>
1228	::std::basic_istream<charT,traits> & operator >> ( ::std::basic_istream<charT,traits> & is,
1229	quaternion<T> & q)
1230	#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
1231	{
1232	#if BOOST_WORKAROUND(__GNUC__, < 3)
1233	typedef char charT;
1234	#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
1235
1236	#ifdef BOOST_NO_STD_LOCALE
1237	#else
1238	const ::std::ctype<charT> & ct = ::std::use_facet< ::std::ctype<charT> >(is.getloc());
1239	#endif /* BOOST_NO_STD_LOCALE */
1240
1241	T a = T();
1242	T b = T();
1243	T c = T();
1244	T d = T();
1245
1246	::std::complex<T> u = ::std::complex<T>();
1247	::std::complex<T> v = ::std::complex<T>();
1248
1249	charT ch = charT();
1250	char cc;
1251
1252	is >> ch; // get the first lexeme
1253
1254	if (!is.good()) goto finish;
1255
1256	#ifdef BOOST_NO_STD_LOCALE
1257	cc = ch;
1258	#else
1259	cc = ct.narrow(ch, char());
1260	#endif /* BOOST_NO_STD_LOCALE */
1261
1262	if (cc == '(') // read "(", possible: (a), (a,b), (a,b,c), (a,b,c,d), (a,(c)), (a,(c,d)), ((a)), ((a),c), ((a),(c)), ((a),(c,d)), ((a,b)), ((a,b),c), ((a,b),(c)), ((a,b,),(c,d,))
1263	{
1264	is >> ch; // get the second lexeme
1265
1266	if (!is.good()) goto finish;
1267
1268	#ifdef BOOST_NO_STD_LOCALE
1269	cc = ch;
1270	#else
1271	cc = ct.narrow(ch, char());
1272	#endif /* BOOST_NO_STD_LOCALE */
1273
1274	if (cc == '(') // read "((", possible: ((a)), ((a),c), ((a),(c)), ((a),(c,d)), ((a,b)), ((a,b),c), ((a,b),(c)), ((a,b,),(c,d,))
1275	{
1276	is.putback(ch);
1277
1278	is >> u; // we extract the first and second components
1279	a = u.real();
1280	b = u.imag();
1281
1282	if (!is.good()) goto finish;
1283
1284	is >> ch; // get the next lexeme
1285
1286	if (!is.good()) goto finish;
1287
1288	#ifdef BOOST_NO_STD_LOCALE
1289	cc = ch;
1290	#else
1291	cc = ct.narrow(ch, char());
1292	#endif /* BOOST_NO_STD_LOCALE */
1293
1294	if (cc == ')') // format: ((a)) or ((a,b))
1295	{
1296	q = quaternion<T>(a,b);
1297	}
1298	else if (cc == ',') // read "((a)," or "((a,b),", possible: ((a),c), ((a),(c)), ((a),(c,d)), ((a,b),c), ((a,b),(c)), ((a,b,),(c,d,))
1299	{
1300	is >> v; // we extract the third and fourth components
1301	c = v.real();
1302	d = v.imag();
1303
1304	if (!is.good()) goto finish;
1305
1306	is >> ch; // get the last lexeme
1307
1308	if (!is.good()) goto finish;
1309
1310	#ifdef BOOST_NO_STD_LOCALE
1311	cc = ch;
1312	#else
1313	cc = ct.narrow(ch, char());
1314	#endif /* BOOST_NO_STD_LOCALE */
1315
1316	if (cc == ')') // format: ((a),c), ((a),(c)), ((a),(c,d)), ((a,b),c), ((a,b),(c)) or ((a,b,),(c,d,))
1317	{
1318	q = quaternion<T>(a,b,c,d);
1319	}
1320	else // error
1321	{
1322	#if BOOST_WORKAROUND(__GNUC__, < 3)
1323	is.setstate(::std::ios::failbit);
1324	#else
1325	is.setstate(::std::ios_base::failbit);
1326	#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
1327	}
1328	}
1329	else // error
1330	{
1331	#if BOOST_WORKAROUND(__GNUC__, < 3)
1332	is.setstate(::std::ios::failbit);
1333	#else
1334	is.setstate(::std::ios_base::failbit);
1335	#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
1336	}
1337	}
1338	else // read "(a", possible: (a), (a,b), (a,b,c), (a,b,c,d), (a,(c)), (a,(c,d))
1339	{
1340	is.putback(ch);
1341
1342	is >> a; // we extract the first component
1343
1344	if (!is.good()) goto finish;
1345
1346	is >> ch; // get the third lexeme
1347
1348	if (!is.good()) goto finish;
1349
1350	#ifdef BOOST_NO_STD_LOCALE
1351	cc = ch;
1352	#else
1353	cc = ct.narrow(ch, char());
1354	#endif /* BOOST_NO_STD_LOCALE */
1355
1356	if (cc == ')') // format: (a)
1357	{
1358	q = quaternion<T>(a);
1359	}
1360	else if (cc == ',') // read "(a,", possible: (a,b), (a,b,c), (a,b,c,d), (a,(c)), (a,(c,d))
1361	{
1362	is >> ch; // get the fourth lexeme
1363
1364	if (!is.good()) goto finish;
1365
1366	#ifdef BOOST_NO_STD_LOCALE
1367	cc = ch;
1368	#else
1369	cc = ct.narrow(ch, char());
1370	#endif /* BOOST_NO_STD_LOCALE */
1371
1372	if (cc == '(') // read "(a,(", possible: (a,(c)), (a,(c,d))
1373	{
1374	is.putback(ch);
1375
1376	is >> v; // we extract the third and fourth component
1377
1378	c = v.real();
1379	d = v.imag();
1380
1381	if (!is.good()) goto finish;
1382
1383	is >> ch; // get the ninth lexeme
1384
1385	if (!is.good()) goto finish;
1386
1387	#ifdef BOOST_NO_STD_LOCALE
1388	cc = ch;
1389	#else
1390	cc = ct.narrow(ch, char());
1391	#endif /* BOOST_NO_STD_LOCALE */
1392
1393	if (cc == ')') // format: (a,(c)) or (a,(c,d))
1394	{
1395	q = quaternion<T>(a,b,c,d);
1396	}
1397	else // error
1398	{
1399	#if BOOST_WORKAROUND(__GNUC__, < 3)
1400	is.setstate(::std::ios::failbit);
1401	#else
1402	is.setstate(::std::ios_base::failbit);
1403	#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
1404	}
1405	}
1406	else // read "(a,b", possible: (a,b), (a,b,c), (a,b,c,d)
1407	{
1408	is.putback(ch);
1409
1410	is >> b; // we extract the second component
1411
1412	if (!is.good()) goto finish;
1413
1414	is >> ch; // get the fifth lexeme
1415
1416	if (!is.good()) goto finish;
1417
1418	#ifdef BOOST_NO_STD_LOCALE
1419	cc = ch;
1420	#else
1421	cc = ct.narrow(ch, char());
1422	#endif /* BOOST_NO_STD_LOCALE */
1423
1424	if (cc == ')') // format: (a,b)
1425	{
1426	q = quaternion<T>(a,b);
1427	}
1428	else if (cc == ',') // read "(a,b,", possible: (a,b,c), (a,b,c,d)
1429	{
1430	is >> c; // we extract the third component
1431
1432	if (!is.good()) goto finish;
1433
1434	is >> ch; // get the seventh lexeme
1435
1436	if (!is.good()) goto finish;
1437
1438	#ifdef BOOST_NO_STD_LOCALE
1439	cc = ch;
1440	#else
1441	cc = ct.narrow(ch, char());
1442	#endif /* BOOST_NO_STD_LOCALE */
1443
1444	if (cc == ')') // format: (a,b,c)
1445	{
1446	q = quaternion<T>(a,b,c);
1447	}
1448	else if (cc == ',') // read "(a,b,c,", possible: (a,b,c,d)
1449	{
1450	is >> d; // we extract the fourth component
1451
1452	if (!is.good()) goto finish;
1453
1454	is >> ch; // get the ninth lexeme
1455
1456	if (!is.good()) goto finish;
1457
1458	#ifdef BOOST_NO_STD_LOCALE
1459	cc = ch;
1460	#else
1461	cc = ct.narrow(ch, char());
1462	#endif /* BOOST_NO_STD_LOCALE */
1463
1464	if (cc == ')') // format: (a,b,c,d)
1465	{
1466	q = quaternion<T>(a,b,c,d);
1467	}
1468	else // error
1469	{
1470	#if BOOST_WORKAROUND(__GNUC__, < 3)
1471	is.setstate(::std::ios::failbit);
1472	#else
1473	is.setstate(::std::ios_base::failbit);
1474	#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
1475	}
1476	}
1477	else // error
1478	{
1479	#if BOOST_WORKAROUND(__GNUC__, < 3)
1480	is.setstate(::std::ios::failbit);
1481	#else
1482	is.setstate(::std::ios_base::failbit);
1483	#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
1484	}
1485	}
1486	else // error
1487	{
1488	#if BOOST_WORKAROUND(__GNUC__, < 3)
1489	is.setstate(::std::ios::failbit);
1490	#else
1491	is.setstate(::std::ios_base::failbit);
1492	#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
1493	}
1494	}
1495	}
1496	else // error
1497	{
1498	#if BOOST_WORKAROUND(__GNUC__, < 3)
1499	is.setstate(::std::ios::failbit);
1500	#else
1501	is.setstate(::std::ios_base::failbit);
1502	#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
1503	}
1504	}
1505	}
1506	else // format: a
1507	{
1508	is.putback(ch);
1509
1510	is >> a; // we extract the first component
1511
1512	if (!is.good()) goto finish;
1513
1514	q = quaternion<T>(a);
1515	}
1516
1517	finish:
1518	return(is);
1519	}
1520
1521
1522	#if BOOST_WORKAROUND(__GNUC__, < 3)
1523	template<typename T>
1524	::std::ostream & operator << ( ::std::ostream & os,
1525	quaternion<T> const & q)
1526	#else
1527	template<typename T, typename charT, class traits>
1528	::std::basic_ostream<charT,traits> & operator << ( ::std::basic_ostream<charT,traits> & os,
1529	quaternion<T> const & q)
1530	#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
1531	{
1532	#if BOOST_WORKAROUND(__GNUC__, < 3)
1533	::std::ostringstream s;
1534	#else
1535	::std::basic_ostringstream<charT,traits> s;
1536	#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
1537
1538	s.flags(os.flags());
1539	#ifdef BOOST_NO_STD_LOCALE
1540	#else
1541	s.imbue(os.getloc());
1542	#endif /* BOOST_NO_STD_LOCALE */
1543	s.precision(os.precision());
1544
1545	s << '(' << q.R_component_1() << ','
1546	<< q.R_component_2() << ','
1547	<< q.R_component_3() << ','
1548	<< q.R_component_4() << ')';
1549
1550	return os << s.str();
1551	}
1552
1553
1554	// values
1555
1556	template<typename T>
1557	inline T real(quaternion<T> const & q)
1558	{
1559	return(q.real());
1560	}
1561
1562
1563	template<typename T>
1564	inline quaternion<T> unreal(quaternion<T> const & q)
1565	{
1566	return(q.unreal());
1567	}
1568
1569
1570	#define BOOST_QUATERNION_VALARRAY_LOADER \
1571	using ::std::valarray; \
1572	\
1573	valarray<T> temp(4); \
1574	\
1575	temp[0] = q.R_component_1(); \
1576	temp[1] = q.R_component_2(); \
1577	temp[2] = q.R_component_3(); \
1578	temp[3] = q.R_component_4();
1579
1580
1581	template<typename T>
1582	inline T sup(quaternion<T> const & q)
1583	{
1584	#ifdef BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
1585	using ::std::abs;
1586	#endif /* BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP */
1587
1588	BOOST_QUATERNION_VALARRAY_LOADER
1589
1590	#if BOOST_WORKAROUND(__GNUC__, < 3)
1591	return((BOOST_GET_VALARRAY(T, abs(temp)).max)());
1592	#else
1593	return((abs(temp).max)());
1594	#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
1595	}
1596
1597
1598	template<typename T>
1599	inline T l1(quaternion<T> const & q)
1600	{
1601	#ifdef BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
1602	using ::std::abs;
1603	#endif /* BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP */
1604
1605	BOOST_QUATERNION_VALARRAY_LOADER
1606
1607	#if BOOST_WORKAROUND(__GNUC__, < 3)
1608	return(BOOST_GET_VALARRAY(T, abs(temp)).sum());
1609	#else
1610	return(abs(temp).sum());
1611	#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
1612	}
1613
1614
1615	template<typename T>
1616	inline T abs(quaternion<T> const & q)
1617	{
1618	#ifdef BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
1619	using ::std::abs;
1620	#endif /* BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP */
1621
1622	using ::std::sqrt;
1623
1624	BOOST_QUATERNION_VALARRAY_LOADER
1625
1626	#if BOOST_WORKAROUND(__GNUC__, < 3)
1627	T maxim = (BOOST_GET_VALARRAY(T, abs(temp)).max)(); // overflow protection
1628	#else
1629	T maxim = (abs(temp).max)(); // overflow protection
1630	#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
1631
1632	if (maxim == static_cast<T>(0))
1633	{
1634	return(maxim);
1635	}
1636	else
1637	{
1638	T mixam = static_cast<T>(1)/maxim; // prefer multiplications over divisions
1639
1640	temp *= mixam;
1641
1642	temp *= temp;
1643
1644	return(maxim*sqrt(temp.sum()));
1645	}
1646
1647	//return(sqrt(norm(q)));
1648	}
1649
1650
1651	#undef BOOST_QUATERNION_VALARRAY_LOADER
1652
1653
1654	// Note: This is the Cayley norm, not the Euclidian norm...
1655
1656	template<typename T>
1657	inline T norm(quaternion<T>const & q)
1658	{
1659	return(real(q*conj(q)));
1660	}
1661
1662
1663	template<typename T>
1664	inline quaternion<T> conj(quaternion<T> const & q)
1665	{
1666	return(quaternion<T>( +q.R_component_1(),
1667	-q.R_component_2(),
1668	-q.R_component_3(),
1669	-q.R_component_4()));
1670	}
1671
1672
1673	template<typename T>
1674	inline quaternion<T> spherical( T const & rho,
1675	T const & theta,
1676	T const & phi1,
1677	T const & phi2)
1678	{
1679	using ::std::cos;
1680	using ::std::sin;
1681
1682	//T a = cos(theta)cos(phi1)cos(phi2);
1683	//T b = sin(theta)cos(phi1)cos(phi2);
1684	//T c = sin(phi1)*cos(phi2);
1685	//T d = sin(phi2);
1686
1687	T courrant = static_cast<T>(1);
1688
1689	T d = sin(phi2);
1690
1691	courrant *= cos(phi2);
1692
1693	T c = sin(phi1)*courrant;
1694
1695	courrant *= cos(phi1);
1696
1697	T b = sin(theta)*courrant;
1698	T a = cos(theta)*courrant;
1699
1700	return(rho*quaternion<T>(a,b,c,d));
1701	}
1702
1703
1704	template<typename T>
1705	inline quaternion<T> semipolar( T const & rho,
1706	T const & alpha,
1707	T const & theta1,
1708	T const & theta2)
1709	{
1710	using ::std::cos;
1711	using ::std::sin;
1712
1713	T a = cos(alpha)*cos(theta1);
1714	T b = cos(alpha)*sin(theta1);
1715	T c = sin(alpha)*cos(theta2);
1716	T d = sin(alpha)*sin(theta2);
1717
1718	return(rho*quaternion<T>(a,b,c,d));
1719	}
1720
1721
1722	template<typename T>
1723	inline quaternion<T> multipolar( T const & rho1,
1724	T const & theta1,
1725	T const & rho2,
1726	T const & theta2)
1727	{
1728	using ::std::cos;
1729	using ::std::sin;
1730
1731	T a = rho1*cos(theta1);
1732	T b = rho1*sin(theta1);
1733	T c = rho2*cos(theta2);
1734	T d = rho2*sin(theta2);
1735
1736	return(quaternion<T>(a,b,c,d));
1737	}
1738
1739
1740	template<typename T>
1741	inline quaternion<T> cylindrospherical( T const & t,
1742	T const & radius,
1743	T const & longitude,
1744	T const & latitude)
1745	{
1746	using ::std::cos;
1747	using ::std::sin;
1748
1749
1750
1751	T b = radiuscos(longitude)cos(latitude);
1752	T c = radiussin(longitude)cos(latitude);
1753	T d = radius*sin(latitude);
1754
1755	return(quaternion<T>(t,b,c,d));
1756	}
1757
1758
1759	template<typename T>
1760	inline quaternion<T> cylindrical(T const & r,
1761	T const & angle,
1762	T const & h1,
1763	T const & h2)
1764	{
1765	using ::std::cos;
1766	using ::std::sin;
1767
1768	T a = r*cos(angle);
1769	T b = r*sin(angle);
1770
1771	return(quaternion<T>(a,b,h1,h2));
1772	}
1773
1774
1775	// transcendentals
1776	// (please see the documentation)
1777
1778
1779	template<typename T>
1780	inline quaternion<T> exp(quaternion<T> const & q)
1781	{
1782	using ::std::exp;
1783	using ::std::cos;
1784
1785	using ::boost::math::sinc_pi;
1786
1787	T u = exp(real(q));
1788
1789	T z = abs(unreal(q));
1790
1791	T w = sinc_pi(z);
1792
1793	return(u*quaternion<T>(cos(z),
1794	wq.R_component_2(), wq.R_component_3(),
1795	w*q.R_component_4()));
1796	}
1797
1798
1799	template<typename T>
1800	inline quaternion<T> cos(quaternion<T> const & q)
1801	{
1802	using ::std::sin;
1803	using ::std::cos;
1804	using ::std::cosh;
1805
1806	using ::boost::math::sinhc_pi;
1807
1808	T z = abs(unreal(q));
1809
1810	T w = -sin(q.real())*sinhc_pi(z);
1811
1812	return(quaternion<T>(cos(q.real())*cosh(z),
1813	wq.R_component_2(), wq.R_component_3(),
1814	w*q.R_component_4()));
1815	}
1816
1817
1818	template<typename T>
1819	inline quaternion<T> sin(quaternion<T> const & q)
1820	{
1821	using ::std::sin;
1822	using ::std::cos;
1823	using ::std::cosh;
1824
1825	using ::boost::math::sinhc_pi;
1826
1827	T z = abs(unreal(q));
1828
1829	T w = +cos(q.real())*sinhc_pi(z);
1830
1831	return(quaternion<T>(sin(q.real())*cosh(z),
1832	wq.R_component_2(), wq.R_component_3(),
1833	w*q.R_component_4()));
1834	}
1835
1836
1837	template<typename T>
1838	inline quaternion<T> tan(quaternion<T> const & q)
1839	{
1840	return(sin(q)/cos(q));
1841	}
1842
1843
1844	template<typename T>
1845	inline quaternion<T> cosh(quaternion<T> const & q)
1846	{
1847	return((exp(+q)+exp(-q))/static_cast<T>(2));
1848	}
1849
1850
1851	template<typename T>
1852	inline quaternion<T> sinh(quaternion<T> const & q)
1853	{
1854	return((exp(+q)-exp(-q))/static_cast<T>(2));
1855	}
1856
1857
1858	template<typename T>
1859	inline quaternion<T> tanh(quaternion<T> const & q)
1860	{
1861	return(sinh(q)/cosh(q));
1862	}
1863
1864
1865	template<typename T>
1866	quaternion<T> pow(quaternion<T> const & q,
1867	int n)
1868	{
1869	if (n > 1)
1870	{
1871	int m = n>>1;
1872
1873	quaternion<T> result = pow(q, m);
1874
1875	result *= result;
1876
1877	if (n != (m<<1))
1878	{
1879	result *= q; // n odd
1880	}
1881
1882	return(result);
1883	}
1884	else if (n == 1)
1885	{
1886	return(q);
1887	}
1888	else if (n == 0)
1889	{
1890	return(quaternion<T>(1));
1891	}
1892	else /* n < 0 */
1893	{
1894	return(pow(quaternion<T>(1)/q,-n));
1895	}
1896	}
1897
1898
1899	// helper templates for converting copy constructors (definition)
1900
1901	namespace detail
1902	{
1903
1904	template< typename T,
1905	typename U
1906	>
1907	quaternion<T> quaternion_type_converter(quaternion<U> const & rhs)
1908	{
1909	return(quaternion<T>( static_cast<T>(rhs.R_component_1()),
1910	static_cast<T>(rhs.R_component_2()),
1911	static_cast<T>(rhs.R_component_3()),
1912	static_cast<T>(rhs.R_component_4())));
1913	}
1914	}
1915	}
1916	}
1917
1918
1919	#if BOOST_WORKAROUND(__GNUC__, < 3)
1920	#undef BOOST_GET_VALARRAY
1921	#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
1922
1923
1924	#endif /* BOOST_QUATERNION_HPP */

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

Download in other formats: