| // boost quaternion.hpp header file | |
| // (C) Copyright Hubert Holin 2001. | |
| // Distributed under the Boost Software License, Version 1.0. (See | |
| // accompanying file LICENSE_1_0.txt or copy at | |
| // http://www.boost.org/LICENSE_1_0.txt) | |
| // See http://www.boost.org for updates, documentation, and revision history. | |
| #ifndef BOOST_QUATERNION_HPP | |
| #define BOOST_QUATERNION_HPP | |
| #include <complex> | |
| #include <iosfwd> // for the "<<" and ">>" operators | |
| #include <sstream> // for the "<<" operator | |
| #include <boost/config.hpp> // for BOOST_NO_STD_LOCALE | |
| #include <boost/detail/workaround.hpp> | |
| #ifndef BOOST_NO_STD_LOCALE | |
| #include <locale> // for the "<<" operator | |
| #endif /* BOOST_NO_STD_LOCALE */ | |
| #include <valarray> | |
| #include <boost/math/special_functions/sinc.hpp> // for the Sinus cardinal | |
| #include <boost/math/special_functions/sinhc.hpp> // for the Hyperbolic Sinus cardinal | |
| namespace boost | |
| { | |
| namespace math | |
| { | |
| #if BOOST_WORKAROUND(__GNUC__, < 3) | |
| // gcc 2.95.x uses expression templates for valarray calculations, but | |
| // the result is not conforming. We need BOOST_GET_VALARRAY to get an | |
| // actual valarray result when we need to call a member function | |
| #define BOOST_GET_VALARRAY(T,x) ::std::valarray<T>(x) | |
| // gcc 2.95.x has an "std::ios" class that is similar to | |
| // "std::ios_base", so we just use a #define | |
| #define BOOST_IOS_BASE ::std::ios | |
| // gcc 2.x ignores function scope using declarations, | |
| // put them in the scope of the enclosing namespace instead: | |
| using ::std::valarray; | |
| using ::std::sqrt; | |
| using ::std::cos; | |
| using ::std::sin; | |
| using ::std::exp; | |
| using ::std::cosh; | |
| #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ | |
| #define BOOST_QUATERNION_ACCESSOR_GENERATOR(type) \ | |
| type real() const \ | |
| { \ | |
| return(a); \ | |
| } \ | |
| \ | |
| quaternion<type> unreal() const \ | |
| { \ | |
| return(quaternion<type>(static_cast<type>(0),b,c,d)); \ | |
| } \ | |
| \ | |
| type R_component_1() const \ | |
| { \ | |
| return(a); \ | |
| } \ | |
| \ | |
| type R_component_2() const \ | |
| { \ | |
| return(b); \ | |
| } \ | |
| \ | |
| type R_component_3() const \ | |
| { \ | |
| return(c); \ | |
| } \ | |
| \ | |
| type R_component_4() const \ | |
| { \ | |
| return(d); \ | |
| } \ | |
| \ | |
| ::std::complex<type> C_component_1() const \ | |
| { \ | |
| return(::std::complex<type>(a,b)); \ | |
| } \ | |
| \ | |
| ::std::complex<type> C_component_2() const \ | |
| { \ | |
| return(::std::complex<type>(c,d)); \ | |
| } | |
| #define BOOST_QUATERNION_MEMBER_ASSIGNMENT_GENERATOR(type) \ | |
| template<typename X> \ | |
| quaternion<type> & operator = (quaternion<X> const & a_affecter) \ | |
| { \ | |
| a = static_cast<type>(a_affecter.R_component_1()); \ | |
| b = static_cast<type>(a_affecter.R_component_2()); \ | |
| c = static_cast<type>(a_affecter.R_component_3()); \ | |
| d = static_cast<type>(a_affecter.R_component_4()); \ | |
| \ | |
| return(*this); \ | |
| } \ | |
| \ | |
| quaternion<type> & operator = (quaternion<type> const & a_affecter) \ | |
| { \ | |
| a = a_affecter.a; \ | |
| b = a_affecter.b; \ | |
| c = a_affecter.c; \ | |
| d = a_affecter.d; \ | |
| \ | |
| return(*this); \ | |
| } \ | |
| \ | |
| quaternion<type> & operator = (type const & a_affecter) \ | |
| { \ | |
| a = a_affecter; \ | |
| \ | |
| b = c = d = static_cast<type>(0); \ | |
| \ | |
| return(*this); \ | |
| } \ | |
| \ | |
| quaternion<type> & operator = (::std::complex<type> const & a_affecter) \ | |
| { \ | |
| a = a_affecter.real(); \ | |
| b = a_affecter.imag(); \ | |
| \ | |
| c = d = static_cast<type>(0); \ | |
| \ | |
| return(*this); \ | |
| } | |
| #define BOOST_QUATERNION_MEMBER_DATA_GENERATOR(type) \ | |
| type a; \ | |
| type b; \ | |
| type c; \ | |
| type d; | |
| template<typename T> | |
| class quaternion | |
| { | |
| public: | |
| typedef T value_type; | |
| // constructor for H seen as R^4 | |
| // (also default constructor) | |
| explicit quaternion( T const & requested_a = T(), | |
| T const & requested_b = T(), | |
| T const & requested_c = T(), | |
| T const & requested_d = T()) | |
| : a(requested_a), | |
| b(requested_b), | |
| c(requested_c), | |
| d(requested_d) | |
| { | |
| // nothing to do! | |
| } | |
| // constructor for H seen as C^2 | |
| explicit quaternion( ::std::complex<T> const & z0, | |
| ::std::complex<T> const & z1 = ::std::complex<T>()) | |
| : a(z0.real()), | |
| b(z0.imag()), | |
| c(z1.real()), | |
| d(z1.imag()) | |
| { | |
| // nothing to do! | |
| } | |
| // UNtemplated copy constructor | |
| // (this is taken care of by the compiler itself) | |
| // templated copy constructor | |
| template<typename X> | |
| explicit quaternion(quaternion<X> const & a_recopier) | |
| : a(static_cast<T>(a_recopier.R_component_1())), | |
| b(static_cast<T>(a_recopier.R_component_2())), | |
| c(static_cast<T>(a_recopier.R_component_3())), | |
| d(static_cast<T>(a_recopier.R_component_4())) | |
| { | |
| // nothing to do! | |
| } | |
| // destructor | |
| // (this is taken care of by the compiler itself) | |
| // accessors | |
| // | |
| // Note: Like complex number, quaternions do have a meaningful notion of "real part", | |
| // but unlike them there is no meaningful notion of "imaginary part". | |
| // Instead there is an "unreal part" which itself is a quaternion, and usually | |
| // nothing simpler (as opposed to the complex number case). | |
| // However, for practicallity, there are accessors for the other components | |
| // (these are necessary for the templated copy constructor, for instance). | |
| BOOST_QUATERNION_ACCESSOR_GENERATOR(T) | |
| // assignment operators | |
| BOOST_QUATERNION_MEMBER_ASSIGNMENT_GENERATOR(T) | |
| // other assignment-related operators | |
| // | |
| // NOTE: Quaternion multiplication is *NOT* commutative; | |
| // symbolically, "q *= rhs;" means "q = q * rhs;" | |
| // and "q /= rhs;" means "q = q * inverse_of(rhs);" | |
| quaternion<T> & operator += (T const & rhs) | |
| { | |
| T at = a + rhs; // exception guard | |
| a = at; | |
| return(*this); | |
| } | |
| quaternion<T> & operator += (::std::complex<T> const & rhs) | |
| { | |
| T at = a + rhs.real(); // exception guard | |
| T bt = b + rhs.imag(); // exception guard | |
| a = at; | |
| b = bt; | |
| return(*this); | |
| } | |
| template<typename X> | |
| quaternion<T> & operator += (quaternion<X> const & rhs) | |
| { | |
| T at = a + static_cast<T>(rhs.R_component_1()); // exception guard | |
| T bt = b + static_cast<T>(rhs.R_component_2()); // exception guard | |
| T ct = c + static_cast<T>(rhs.R_component_3()); // exception guard | |
| T dt = d + static_cast<T>(rhs.R_component_4()); // exception guard | |
| a = at; | |
| b = bt; | |
| c = ct; | |
| d = dt; | |
| return(*this); | |
| } | |
| quaternion<T> & operator -= (T const & rhs) | |
| { | |
| T at = a - rhs; // exception guard | |
| a = at; | |
| return(*this); | |
| } | |
| quaternion<T> & operator -= (::std::complex<T> const & rhs) | |
| { | |
| T at = a - rhs.real(); // exception guard | |
| T bt = b - rhs.imag(); // exception guard | |
| a = at; | |
| b = bt; | |
| return(*this); | |
| } | |
| template<typename X> | |
| quaternion<T> & operator -= (quaternion<X> const & rhs) | |
| { | |
| T at = a - static_cast<T>(rhs.R_component_1()); // exception guard | |
| T bt = b - static_cast<T>(rhs.R_component_2()); // exception guard | |
| T ct = c - static_cast<T>(rhs.R_component_3()); // exception guard | |
| T dt = d - static_cast<T>(rhs.R_component_4()); // exception guard | |
| a = at; | |
| b = bt; | |
| c = ct; | |
| d = dt; | |
| return(*this); | |
| } | |
| quaternion<T> & operator *= (T const & rhs) | |
| { | |
| T at = a * rhs; // exception guard | |
| T bt = b * rhs; // exception guard | |
| T ct = c * rhs; // exception guard | |
| T dt = d * rhs; // exception guard | |
| a = at; | |
| b = bt; | |
| c = ct; | |
| d = dt; | |
| return(*this); | |
| } | |
| quaternion<T> & operator *= (::std::complex<T> const & rhs) | |
| { | |
| T ar = rhs.real(); | |
| T br = rhs.imag(); | |
| T at = +a*ar-b*br; | |
| T bt = +a*br+b*ar; | |
| T ct = +c*ar+d*br; | |
| T dt = -c*br+d*ar; | |
| a = at; | |
| b = bt; | |
| c = ct; | |
| d = dt; | |
| return(*this); | |
| } | |
| template<typename X> | |
| quaternion<T> & operator *= (quaternion<X> const & rhs) | |
| { | |
| T ar = static_cast<T>(rhs.R_component_1()); | |
| T br = static_cast<T>(rhs.R_component_2()); | |
| T cr = static_cast<T>(rhs.R_component_3()); | |
| T dr = static_cast<T>(rhs.R_component_4()); | |
| T at = +a*ar-b*br-c*cr-d*dr; | |
| T bt = +a*br+b*ar+c*dr-d*cr; //(a*br+ar*b)+(c*dr-cr*d); | |
| T ct = +a*cr-b*dr+c*ar+d*br; //(a*cr+ar*c)+(d*br-dr*b); | |
| T dt = +a*dr+b*cr-c*br+d*ar; //(a*dr+ar*d)+(b*cr-br*c); | |
| a = at; | |
| b = bt; | |
| c = ct; | |
| d = dt; | |
| return(*this); | |
| } | |
| quaternion<T> & operator /= (T const & rhs) | |
| { | |
| T at = a / rhs; // exception guard | |
| T bt = b / rhs; // exception guard | |
| T ct = c / rhs; // exception guard | |
| T dt = d / rhs; // exception guard | |
| a = at; | |
| b = bt; | |
| c = ct; | |
| d = dt; | |
| return(*this); | |
| } | |
| quaternion<T> & operator /= (::std::complex<T> const & rhs) | |
| { | |
| T ar = rhs.real(); | |
| T br = rhs.imag(); | |
| T denominator = ar*ar+br*br; | |
| T at = (+a*ar+b*br)/denominator; //(a*ar+b*br)/denominator; | |
| T bt = (-a*br+b*ar)/denominator; //(ar*b-a*br)/denominator; | |
| T ct = (+c*ar-d*br)/denominator; //(ar*c-d*br)/denominator; | |
| T dt = (+c*br+d*ar)/denominator; //(ar*d+br*c)/denominator; | |
| a = at; | |
| b = bt; | |
| c = ct; | |
| d = dt; | |
| return(*this); | |
| } | |
| template<typename X> | |
| quaternion<T> & operator /= (quaternion<X> const & rhs) | |
| { | |
| T ar = static_cast<T>(rhs.R_component_1()); | |
| T br = static_cast<T>(rhs.R_component_2()); | |
| T cr = static_cast<T>(rhs.R_component_3()); | |
| T dr = static_cast<T>(rhs.R_component_4()); | |
| T denominator = ar*ar+br*br+cr*cr+dr*dr; | |
| T at = (+a*ar+b*br+c*cr+d*dr)/denominator; //(a*ar+b*br+c*cr+d*dr)/denominator; | |
| T bt = (-a*br+b*ar-c*dr+d*cr)/denominator; //((ar*b-a*br)+(cr*d-c*dr))/denominator; | |
| T ct = (-a*cr+b*dr+c*ar-d*br)/denominator; //((ar*c-a*cr)+(dr*b-d*br))/denominator; | |
| T dt = (-a*dr-b*cr+c*br+d*ar)/denominator; //((ar*d-a*dr)+(br*c-b*cr))/denominator; | |
| a = at; | |
| b = bt; | |
| c = ct; | |
| d = dt; | |
| return(*this); | |
| } | |
| protected: | |
| BOOST_QUATERNION_MEMBER_DATA_GENERATOR(T) | |
| private: | |
| }; | |
| // declaration of quaternion specialization | |
| template<> class quaternion<float>; | |
| template<> class quaternion<double>; | |
| template<> class quaternion<long double>; | |
| // helper templates for converting copy constructors (declaration) | |
| namespace detail | |
| { | |
| template< typename T, | |
| typename U | |
| > | |
| quaternion<T> quaternion_type_converter(quaternion<U> const & rhs); | |
| } | |
| // implementation of quaternion specialization | |
| #define BOOST_QUATERNION_CONSTRUCTOR_GENERATOR(type) \ | |
| explicit quaternion( type const & requested_a = static_cast<type>(0), \ | |
| type const & requested_b = static_cast<type>(0), \ | |
| type const & requested_c = static_cast<type>(0), \ | |
| type const & requested_d = static_cast<type>(0)) \ | |
| : a(requested_a), \ | |
| b(requested_b), \ | |
| c(requested_c), \ | |
| d(requested_d) \ | |
| { \ | |
| } \ | |
| \ | |
| explicit quaternion( ::std::complex<type> const & z0, \ | |
| ::std::complex<type> const & z1 = ::std::complex<type>()) \ | |
| : a(z0.real()), \ | |
| b(z0.imag()), \ | |
| c(z1.real()), \ | |
| d(z1.imag()) \ | |
| { \ | |
| } | |
| #define BOOST_QUATERNION_MEMBER_ADD_GENERATOR_1(type) \ | |
| quaternion<type> & operator += (type const & rhs) \ | |
| { \ | |
| a += rhs; \ | |
| \ | |
| return(*this); \ | |
| } | |
| #define BOOST_QUATERNION_MEMBER_ADD_GENERATOR_2(type) \ | |
| quaternion<type> & operator += (::std::complex<type> const & rhs) \ | |
| { \ | |
| a += rhs.real(); \ | |
| b += rhs.imag(); \ | |
| \ | |
| return(*this); \ | |
| } | |
| #define BOOST_QUATERNION_MEMBER_ADD_GENERATOR_3(type) \ | |
| template<typename X> \ | |
| quaternion<type> & operator += (quaternion<X> const & rhs) \ | |
| { \ | |
| a += static_cast<type>(rhs.R_component_1()); \ | |
| b += static_cast<type>(rhs.R_component_2()); \ | |
| c += static_cast<type>(rhs.R_component_3()); \ | |
| d += static_cast<type>(rhs.R_component_4()); \ | |
| \ | |
| return(*this); \ | |
| } | |
| #define BOOST_QUATERNION_MEMBER_SUB_GENERATOR_1(type) \ | |
| quaternion<type> & operator -= (type const & rhs) \ | |
| { \ | |
| a -= rhs; \ | |
| \ | |
| return(*this); \ | |
| } | |
| #define BOOST_QUATERNION_MEMBER_SUB_GENERATOR_2(type) \ | |
| quaternion<type> & operator -= (::std::complex<type> const & rhs) \ | |
| { \ | |
| a -= rhs.real(); \ | |
| b -= rhs.imag(); \ | |
| \ | |
| return(*this); \ | |
| } | |
| #define BOOST_QUATERNION_MEMBER_SUB_GENERATOR_3(type) \ | |
| template<typename X> \ | |
| quaternion<type> & operator -= (quaternion<X> const & rhs) \ | |
| { \ | |
| a -= static_cast<type>(rhs.R_component_1()); \ | |
| b -= static_cast<type>(rhs.R_component_2()); \ | |
| c -= static_cast<type>(rhs.R_component_3()); \ | |
| d -= static_cast<type>(rhs.R_component_4()); \ | |
| \ | |
| return(*this); \ | |
| } | |
| #define BOOST_QUATERNION_MEMBER_MUL_GENERATOR_1(type) \ | |
| quaternion<type> & operator *= (type const & rhs) \ | |
| { \ | |
| a *= rhs; \ | |
| b *= rhs; \ | |
| c *= rhs; \ | |
| d *= rhs; \ | |
| \ | |
| return(*this); \ | |
| } | |
| #define BOOST_QUATERNION_MEMBER_MUL_GENERATOR_2(type) \ | |
| quaternion<type> & operator *= (::std::complex<type> const & rhs) \ | |
| { \ | |
| type ar = rhs.real(); \ | |
| type br = rhs.imag(); \ | |
| \ | |
| type at = +a*ar-b*br; \ | |
| type bt = +a*br+b*ar; \ | |
| type ct = +c*ar+d*br; \ | |
| type dt = -c*br+d*ar; \ | |
| \ | |
| a = at; \ | |
| b = bt; \ | |
| c = ct; \ | |
| d = dt; \ | |
| \ | |
| return(*this); \ | |
| } | |
| #define BOOST_QUATERNION_MEMBER_MUL_GENERATOR_3(type) \ | |
| template<typename X> \ | |
| quaternion<type> & operator *= (quaternion<X> const & rhs) \ | |
| { \ | |
| type ar = static_cast<type>(rhs.R_component_1()); \ | |
| type br = static_cast<type>(rhs.R_component_2()); \ | |
| type cr = static_cast<type>(rhs.R_component_3()); \ | |
| type dr = static_cast<type>(rhs.R_component_4()); \ | |
| \ | |
| type at = +a*ar-b*br-c*cr-d*dr; \ | |
| type bt = +a*br+b*ar+c*dr-d*cr; \ | |
| type ct = +a*cr-b*dr+c*ar+d*br; \ | |
| type dt = +a*dr+b*cr-c*br+d*ar; \ | |
| \ | |
| a = at; \ | |
| b = bt; \ | |
| c = ct; \ | |
| d = dt; \ | |
| \ | |
| return(*this); \ | |
| } | |
| // There is quite a lot of repetition in the code below. This is intentional. | |
| // The last conditional block is the normal form, and the others merely | |
| // consist of workarounds for various compiler deficiencies. Hopefuly, when | |
| // more compilers are conformant and we can retire support for those that are | |
| // not, we will be able to remove the clutter. This is makes the situation | |
| // (painfully) explicit. | |
| #define BOOST_QUATERNION_MEMBER_DIV_GENERATOR_1(type) \ | |
| quaternion<type> & operator /= (type const & rhs) \ | |
| { \ | |
| a /= rhs; \ | |
| b /= rhs; \ | |
| c /= rhs; \ | |
| d /= rhs; \ | |
| \ | |
| return(*this); \ | |
| } | |
| #if defined(__GNUC__) && (__GNUC__ < 3) | |
| #define BOOST_QUATERNION_MEMBER_DIV_GENERATOR_2(type) \ | |
| quaternion<type> & operator /= (::std::complex<type> const & rhs) \ | |
| { \ | |
| using ::std::valarray; \ | |
| \ | |
| valarray<type> tr(2); \ | |
| \ | |
| tr[0] = rhs.real(); \ | |
| tr[1] = rhs.imag(); \ | |
| \ | |
| type mixam = (BOOST_GET_VALARRAY(type,static_cast<type>(1)/abs(tr)).max)(); \ | |
| \ | |
| tr *= mixam; \ | |
| \ | |
| valarray<type> tt(4); \ | |
| \ | |
| tt[0] = +a*tr[0]+b*tr[1]; \ | |
| tt[1] = -a*tr[1]+b*tr[0]; \ | |
| tt[2] = +c*tr[0]-d*tr[1]; \ | |
| tt[3] = +c*tr[1]+d*tr[0]; \ | |
| \ | |
| tr *= tr; \ | |
| \ | |
| tt *= (mixam/tr.sum()); \ | |
| \ | |
| a = tt[0]; \ | |
| b = tt[1]; \ | |
| c = tt[2]; \ | |
| d = tt[3]; \ | |
| \ | |
| return(*this); \ | |
| } | |
| #elif defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP) | |
| #define BOOST_QUATERNION_MEMBER_DIV_GENERATOR_2(type) \ | |
| quaternion<type> & operator /= (::std::complex<type> const & rhs) \ | |
| { \ | |
| using ::std::valarray; \ | |
| using ::std::abs; \ | |
| \ | |
| valarray<type> tr(2); \ | |
| \ | |
| tr[0] = rhs.real(); \ | |
| tr[1] = rhs.imag(); \ | |
| \ | |
| type mixam = static_cast<type>(1)/(abs(tr).max)(); \ | |
| \ | |
| tr *= mixam; \ | |
| \ | |
| valarray<type> tt(4); \ | |
| \ | |
| tt[0] = +a*tr[0]+b*tr[1]; \ | |
| tt[1] = -a*tr[1]+b*tr[0]; \ | |
| tt[2] = +c*tr[0]-d*tr[1]; \ | |
| tt[3] = +c*tr[1]+d*tr[0]; \ | |
| \ | |
| tr *= tr; \ | |
| \ | |
| tt *= (mixam/tr.sum()); \ | |
| \ | |
| a = tt[0]; \ | |
| b = tt[1]; \ | |
| c = tt[2]; \ | |
| d = tt[3]; \ | |
| \ | |
| return(*this); \ | |
| } | |
| #else | |
| #define BOOST_QUATERNION_MEMBER_DIV_GENERATOR_2(type) \ | |
| quaternion<type> & operator /= (::std::complex<type> const & rhs) \ | |
| { \ | |
| using ::std::valarray; \ | |
| \ | |
| valarray<type> tr(2); \ | |
| \ | |
| tr[0] = rhs.real(); \ | |
| tr[1] = rhs.imag(); \ | |
| \ | |
| type mixam = static_cast<type>(1)/(abs(tr).max)(); \ | |
| \ | |
| tr *= mixam; \ | |
| \ | |
| valarray<type> tt(4); \ | |
| \ | |
| tt[0] = +a*tr[0]+b*tr[1]; \ | |
| tt[1] = -a*tr[1]+b*tr[0]; \ | |
| tt[2] = +c*tr[0]-d*tr[1]; \ | |
| tt[3] = +c*tr[1]+d*tr[0]; \ | |
| \ | |
| tr *= tr; \ | |
| \ | |
| tt *= (mixam/tr.sum()); \ | |
| \ | |
| a = tt[0]; \ | |
| b = tt[1]; \ | |
| c = tt[2]; \ | |
| d = tt[3]; \ | |
| \ | |
| return(*this); \ | |
| } | |
| #endif /* defined(__GNUC__) && (__GNUC__ < 3) */ /* BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP */ | |
| #if defined(__GNUC__) && (__GNUC__ < 3) | |
| #define BOOST_QUATERNION_MEMBER_DIV_GENERATOR_3(type) \ | |
| template<typename X> \ | |
| quaternion<type> & operator /= (quaternion<X> const & rhs) \ | |
| { \ | |
| using ::std::valarray; \ | |
| \ | |
| valarray<type> tr(4); \ | |
| \ | |
| tr[0] = static_cast<type>(rhs.R_component_1()); \ | |
| tr[1] = static_cast<type>(rhs.R_component_2()); \ | |
| tr[2] = static_cast<type>(rhs.R_component_3()); \ | |
| tr[3] = static_cast<type>(rhs.R_component_4()); \ | |
| \ | |
| type mixam = (BOOST_GET_VALARRAY(type,static_cast<type>(1)/abs(tr)).max)(); \ | |
| \ | |
| tr *= mixam; \ | |
| \ | |
| valarray<type> tt(4); \ | |
| \ | |
| tt[0] = +a*tr[0]+b*tr[1]+c*tr[2]+d*tr[3]; \ | |
| tt[1] = -a*tr[1]+b*tr[0]-c*tr[3]+d*tr[2]; \ | |
| tt[2] = -a*tr[2]+b*tr[3]+c*tr[0]-d*tr[1]; \ | |
| tt[3] = -a*tr[3]-b*tr[2]+c*tr[1]+d*tr[0]; \ | |
| \ | |
| tr *= tr; \ | |
| \ | |
| tt *= (mixam/tr.sum()); \ | |
| \ | |
| a = tt[0]; \ | |
| b = tt[1]; \ | |
| c = tt[2]; \ | |
| d = tt[3]; \ | |
| \ | |
| return(*this); \ | |
| } | |
| #elif defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP) | |
| #define BOOST_QUATERNION_MEMBER_DIV_GENERATOR_3(type) \ | |
| template<typename X> \ | |
| quaternion<type> & operator /= (quaternion<X> const & rhs) \ | |
| { \ | |
| using ::std::valarray; \ | |
| using ::std::abs; \ | |
| \ | |
| valarray<type> tr(4); \ | |
| \ | |
| tr[0] = static_cast<type>(rhs.R_component_1()); \ | |
| tr[1] = static_cast<type>(rhs.R_component_2()); \ | |
| tr[2] = static_cast<type>(rhs.R_component_3()); \ | |
| tr[3] = static_cast<type>(rhs.R_component_4()); \ | |
| \ | |
| type mixam = static_cast<type>(1)/(abs(tr).max)(); \ | |
| \ | |
| tr *= mixam; \ | |
| \ | |
| valarray<type> tt(4); \ | |
| \ | |
| tt[0] = +a*tr[0]+b*tr[1]+c*tr[2]+d*tr[3]; \ | |
| tt[1] = -a*tr[1]+b*tr[0]-c*tr[3]+d*tr[2]; \ | |
| tt[2] = -a*tr[2]+b*tr[3]+c*tr[0]-d*tr[1]; \ | |
| tt[3] = -a*tr[3]-b*tr[2]+c*tr[1]+d*tr[0]; \ | |
| \ | |
| tr *= tr; \ | |
| \ | |
| tt *= (mixam/tr.sum()); \ | |
| \ | |
| a = tt[0]; \ | |
| b = tt[1]; \ | |
| c = tt[2]; \ | |
| d = tt[3]; \ | |
| \ | |
| return(*this); \ | |
| } | |
| #else | |
| #define BOOST_QUATERNION_MEMBER_DIV_GENERATOR_3(type) \ | |
| template<typename X> \ | |
| quaternion<type> & operator /= (quaternion<X> const & rhs) \ | |
| { \ | |
| using ::std::valarray; \ | |
| \ | |
| valarray<type> tr(4); \ | |
| \ | |
| tr[0] = static_cast<type>(rhs.R_component_1()); \ | |
| tr[1] = static_cast<type>(rhs.R_component_2()); \ | |
| tr[2] = static_cast<type>(rhs.R_component_3()); \ | |
| tr[3] = static_cast<type>(rhs.R_component_4()); \ | |
| \ | |
| type mixam = static_cast<type>(1)/(abs(tr).max)(); \ | |
| \ | |
| tr *= mixam; \ | |
| \ | |
| valarray<type> tt(4); \ | |
| \ | |
| tt[0] = +a*tr[0]+b*tr[1]+c*tr[2]+d*tr[3]; \ | |
| tt[1] = -a*tr[1]+b*tr[0]-c*tr[3]+d*tr[2]; \ | |
| tt[2] = -a*tr[2]+b*tr[3]+c*tr[0]-d*tr[1]; \ | |
| tt[3] = -a*tr[3]-b*tr[2]+c*tr[1]+d*tr[0]; \ | |
| \ | |
| tr *= tr; \ | |
| \ | |
| tt *= (mixam/tr.sum()); \ | |
| \ | |
| a = tt[0]; \ | |
| b = tt[1]; \ | |
| c = tt[2]; \ | |
| d = tt[3]; \ | |
| \ | |
| return(*this); \ | |
| } | |
| #endif /* defined(__GNUC__) && (__GNUC__ < 3) */ /* BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP */ | |
| #define BOOST_QUATERNION_MEMBER_ADD_GENERATOR(type) \ | |
| BOOST_QUATERNION_MEMBER_ADD_GENERATOR_1(type) \ | |
| BOOST_QUATERNION_MEMBER_ADD_GENERATOR_2(type) \ | |
| BOOST_QUATERNION_MEMBER_ADD_GENERATOR_3(type) | |
| #define BOOST_QUATERNION_MEMBER_SUB_GENERATOR(type) \ | |
| BOOST_QUATERNION_MEMBER_SUB_GENERATOR_1(type) \ | |
| BOOST_QUATERNION_MEMBER_SUB_GENERATOR_2(type) \ | |
| BOOST_QUATERNION_MEMBER_SUB_GENERATOR_3(type) | |
| #define BOOST_QUATERNION_MEMBER_MUL_GENERATOR(type) \ | |
| BOOST_QUATERNION_MEMBER_MUL_GENERATOR_1(type) \ | |
| BOOST_QUATERNION_MEMBER_MUL_GENERATOR_2(type) \ | |
| BOOST_QUATERNION_MEMBER_MUL_GENERATOR_3(type) | |
| #define BOOST_QUATERNION_MEMBER_DIV_GENERATOR(type) \ | |
| BOOST_QUATERNION_MEMBER_DIV_GENERATOR_1(type) \ | |
| BOOST_QUATERNION_MEMBER_DIV_GENERATOR_2(type) \ | |
| BOOST_QUATERNION_MEMBER_DIV_GENERATOR_3(type) | |
| #define BOOST_QUATERNION_MEMBER_ALGEBRAIC_GENERATOR(type) \ | |
| BOOST_QUATERNION_MEMBER_ADD_GENERATOR(type) \ | |
| BOOST_QUATERNION_MEMBER_SUB_GENERATOR(type) \ | |
| BOOST_QUATERNION_MEMBER_MUL_GENERATOR(type) \ | |
| BOOST_QUATERNION_MEMBER_DIV_GENERATOR(type) | |
| template<> | |
| class quaternion<float> | |
| { | |
| public: | |
| typedef float value_type; | |
| BOOST_QUATERNION_CONSTRUCTOR_GENERATOR(float) | |
| // UNtemplated copy constructor | |
| // (this is taken care of by the compiler itself) | |
| // explicit copy constructors (precision-loosing converters) | |
| explicit quaternion(quaternion<double> const & a_recopier) | |
| { | |
| *this = detail::quaternion_type_converter<float, double>(a_recopier); | |
| } | |
| explicit quaternion(quaternion<long double> const & a_recopier) | |
| { | |
| *this = detail::quaternion_type_converter<float, long double>(a_recopier); | |
| } | |
| // destructor | |
| // (this is taken care of by the compiler itself) | |
| // accessors | |
| // | |
| // Note: Like complex number, quaternions do have a meaningful notion of "real part", | |
| // but unlike them there is no meaningful notion of "imaginary part". | |
| // Instead there is an "unreal part" which itself is a quaternion, and usually | |
| // nothing simpler (as opposed to the complex number case). | |
| // However, for practicallity, there are accessors for the other components | |
| // (these are necessary for the templated copy constructor, for instance). | |
| BOOST_QUATERNION_ACCESSOR_GENERATOR(float) | |
| // assignment operators | |
| BOOST_QUATERNION_MEMBER_ASSIGNMENT_GENERATOR(float) | |
| // other assignment-related operators | |
| // | |
| // NOTE: Quaternion multiplication is *NOT* commutative; | |
| // symbolically, "q *= rhs;" means "q = q * rhs;" | |
| // and "q /= rhs;" means "q = q * inverse_of(rhs);" | |
| BOOST_QUATERNION_MEMBER_ALGEBRAIC_GENERATOR(float) | |
| protected: | |
| BOOST_QUATERNION_MEMBER_DATA_GENERATOR(float) | |
| private: | |
| }; | |
| template<> | |
| class quaternion<double> | |
| { | |
| public: | |
| typedef double value_type; | |
| BOOST_QUATERNION_CONSTRUCTOR_GENERATOR(double) | |
| // UNtemplated copy constructor | |
| // (this is taken care of by the compiler itself) | |
| // converting copy constructor | |
| explicit quaternion(quaternion<float> const & a_recopier) | |
| { | |
| *this = detail::quaternion_type_converter<double, float>(a_recopier); | |
| } | |
| // explicit copy constructors (precision-loosing converters) | |
| explicit quaternion(quaternion<long double> const & a_recopier) | |
| { | |
| *this = detail::quaternion_type_converter<double, long double>(a_recopier); | |
| } | |
| // destructor | |
| // (this is taken care of by the compiler itself) | |
| // accessors | |
| // | |
| // Note: Like complex number, quaternions do have a meaningful notion of "real part", | |
| // but unlike them there is no meaningful notion of "imaginary part". | |
| // Instead there is an "unreal part" which itself is a quaternion, and usually | |
| // nothing simpler (as opposed to the complex number case). | |
| // However, for practicallity, there are accessors for the other components | |
| // (these are necessary for the templated copy constructor, for instance). | |
| BOOST_QUATERNION_ACCESSOR_GENERATOR(double) | |
| // assignment operators | |
| BOOST_QUATERNION_MEMBER_ASSIGNMENT_GENERATOR(double) | |
| // other assignment-related operators | |
| // | |
| // NOTE: Quaternion multiplication is *NOT* commutative; | |
| // symbolically, "q *= rhs;" means "q = q * rhs;" | |
| // and "q /= rhs;" means "q = q * inverse_of(rhs);" | |
| BOOST_QUATERNION_MEMBER_ALGEBRAIC_GENERATOR(double) | |
| protected: | |
| BOOST_QUATERNION_MEMBER_DATA_GENERATOR(double) | |
| private: | |
| }; | |
| template<> | |
| class quaternion<long double> | |
| { | |
| public: | |
| typedef long double value_type; | |
| BOOST_QUATERNION_CONSTRUCTOR_GENERATOR(long double) | |
| // UNtemplated copy constructor | |
| // (this is taken care of by the compiler itself) | |
| // converting copy constructors | |
| explicit quaternion(quaternion<float> const & a_recopier) | |
| { | |
| *this = detail::quaternion_type_converter<long double, float>(a_recopier); | |
| } | |
| explicit quaternion(quaternion<double> const & a_recopier) | |
| { | |
| *this = detail::quaternion_type_converter<long double, double>(a_recopier); | |
| } | |
| // destructor | |
| // (this is taken care of by the compiler itself) | |
| // accessors | |
| // | |
| // Note: Like complex number, quaternions do have a meaningful notion of "real part", | |
| // but unlike them there is no meaningful notion of "imaginary part". | |
| // Instead there is an "unreal part" which itself is a quaternion, and usually | |
| // nothing simpler (as opposed to the complex number case). | |
| // However, for practicallity, there are accessors for the other components | |
| // (these are necessary for the templated copy constructor, for instance). | |
| BOOST_QUATERNION_ACCESSOR_GENERATOR(long double) | |
| // assignment operators | |
| BOOST_QUATERNION_MEMBER_ASSIGNMENT_GENERATOR(long double) | |
| // other assignment-related operators | |
| // | |
| // NOTE: Quaternion multiplication is *NOT* commutative; | |
| // symbolically, "q *= rhs;" means "q = q * rhs;" | |
| // and "q /= rhs;" means "q = q * inverse_of(rhs);" | |
| BOOST_QUATERNION_MEMBER_ALGEBRAIC_GENERATOR(long double) | |
| protected: | |
| BOOST_QUATERNION_MEMBER_DATA_GENERATOR(long double) | |
| private: | |
| }; | |
| #undef BOOST_QUATERNION_MEMBER_ALGEBRAIC_GENERATOR | |
| #undef BOOST_QUATERNION_MEMBER_ADD_GENERATOR | |
| #undef BOOST_QUATERNION_MEMBER_SUB_GENERATOR | |
| #undef BOOST_QUATERNION_MEMBER_MUL_GENERATOR | |
| #undef BOOST_QUATERNION_MEMBER_DIV_GENERATOR | |
| #undef BOOST_QUATERNION_MEMBER_ADD_GENERATOR_1 | |
| #undef BOOST_QUATERNION_MEMBER_ADD_GENERATOR_2 | |
| #undef BOOST_QUATERNION_MEMBER_ADD_GENERATOR_3 | |
| #undef BOOST_QUATERNION_MEMBER_SUB_GENERATOR_1 | |
| #undef BOOST_QUATERNION_MEMBER_SUB_GENERATOR_2 | |
| #undef BOOST_QUATERNION_MEMBER_SUB_GENERATOR_3 | |
| #undef BOOST_QUATERNION_MEMBER_MUL_GENERATOR_1 | |
| #undef BOOST_QUATERNION_MEMBER_MUL_GENERATOR_2 | |
| #undef BOOST_QUATERNION_MEMBER_MUL_GENERATOR_3 | |
| #undef BOOST_QUATERNION_MEMBER_DIV_GENERATOR_1 | |
| #undef BOOST_QUATERNION_MEMBER_DIV_GENERATOR_2 | |
| #undef BOOST_QUATERNION_MEMBER_DIV_GENERATOR_3 | |
| #undef BOOST_QUATERNION_CONSTRUCTOR_GENERATOR | |
| #undef BOOST_QUATERNION_MEMBER_ASSIGNMENT_GENERATOR | |
| #undef BOOST_QUATERNION_MEMBER_DATA_GENERATOR | |
| #undef BOOST_QUATERNION_ACCESSOR_GENERATOR | |
| // operators | |
| #define BOOST_QUATERNION_OPERATOR_GENERATOR_BODY(op) \ | |
| { \ | |
| quaternion<T> res(lhs); \ | |
| res op##= rhs; \ | |
| return(res); \ | |
| } | |
| #define BOOST_QUATERNION_OPERATOR_GENERATOR_1_L(op) \ | |
| template<typename T> \ | |
| inline quaternion<T> operator op (T const & lhs, quaternion<T> const & rhs) \ | |
| BOOST_QUATERNION_OPERATOR_GENERATOR_BODY(op) | |
| #define BOOST_QUATERNION_OPERATOR_GENERATOR_1_R(op) \ | |
| template<typename T> \ | |
| inline quaternion<T> operator op (quaternion<T> const & lhs, T const & rhs) \ | |
| BOOST_QUATERNION_OPERATOR_GENERATOR_BODY(op) | |
| #define BOOST_QUATERNION_OPERATOR_GENERATOR_2_L(op) \ | |
| template<typename T> \ | |
| inline quaternion<T> operator op (::std::complex<T> const & lhs, quaternion<T> const & rhs) \ | |
| BOOST_QUATERNION_OPERATOR_GENERATOR_BODY(op) | |
| #define BOOST_QUATERNION_OPERATOR_GENERATOR_2_R(op) \ | |
| template<typename T> \ | |
| inline quaternion<T> operator op (quaternion<T> const & lhs, ::std::complex<T> const & rhs) \ | |
| BOOST_QUATERNION_OPERATOR_GENERATOR_BODY(op) | |
| #define BOOST_QUATERNION_OPERATOR_GENERATOR_3(op) \ | |
| template<typename T> \ | |
| inline quaternion<T> operator op (quaternion<T> const & lhs, quaternion<T> const & rhs) \ | |
| BOOST_QUATERNION_OPERATOR_GENERATOR_BODY(op) | |
| #define BOOST_QUATERNION_OPERATOR_GENERATOR(op) \ | |
| BOOST_QUATERNION_OPERATOR_GENERATOR_1_L(op) \ | |
| BOOST_QUATERNION_OPERATOR_GENERATOR_1_R(op) \ | |
| BOOST_QUATERNION_OPERATOR_GENERATOR_2_L(op) \ | |
| BOOST_QUATERNION_OPERATOR_GENERATOR_2_R(op) \ | |
| BOOST_QUATERNION_OPERATOR_GENERATOR_3(op) | |
| BOOST_QUATERNION_OPERATOR_GENERATOR(+) | |
| BOOST_QUATERNION_OPERATOR_GENERATOR(-) | |
| BOOST_QUATERNION_OPERATOR_GENERATOR(*) | |
| BOOST_QUATERNION_OPERATOR_GENERATOR(/) | |
| #undef BOOST_QUATERNION_OPERATOR_GENERATOR | |
| #undef BOOST_QUATERNION_OPERATOR_GENERATOR_1_L | |
| #undef BOOST_QUATERNION_OPERATOR_GENERATOR_1_R | |
| #undef BOOST_QUATERNION_OPERATOR_GENERATOR_2_L | |
| #undef BOOST_QUATERNION_OPERATOR_GENERATOR_2_R | |
| #undef BOOST_QUATERNION_OPERATOR_GENERATOR_3 | |
| #undef BOOST_QUATERNION_OPERATOR_GENERATOR_BODY | |
| template<typename T> | |
| inline quaternion<T> operator + (quaternion<T> const & q) | |
| { | |
| return(q); | |
| } | |
| template<typename T> | |
| inline quaternion<T> operator - (quaternion<T> const & q) | |
| { | |
| return(quaternion<T>(-q.R_component_1(),-q.R_component_2(),-q.R_component_3(),-q.R_component_4())); | |
| } | |
| template<typename T> | |
| inline bool operator == (T const & lhs, quaternion<T> const & rhs) | |
| { | |
| return ( | |
| (rhs.R_component_1() == lhs)&& | |
| (rhs.R_component_2() == static_cast<T>(0))&& | |
| (rhs.R_component_3() == static_cast<T>(0))&& | |
| (rhs.R_component_4() == static_cast<T>(0)) | |
| ); | |
| } | |
| template<typename T> | |
| inline bool operator == (quaternion<T> const & lhs, T const & rhs) | |
| { | |
| return ( | |
| (lhs.R_component_1() == rhs)&& | |
| (lhs.R_component_2() == static_cast<T>(0))&& | |
| (lhs.R_component_3() == static_cast<T>(0))&& | |
| (lhs.R_component_4() == static_cast<T>(0)) | |
| ); | |
| } | |
| template<typename T> | |
| inline bool operator == (::std::complex<T> const & lhs, quaternion<T> const & rhs) | |
| { | |
| return ( | |
| (rhs.R_component_1() == lhs.real())&& | |
| (rhs.R_component_2() == lhs.imag())&& | |
| (rhs.R_component_3() == static_cast<T>(0))&& | |
| (rhs.R_component_4() == static_cast<T>(0)) | |
| ); | |
| } | |
| template<typename T> | |
| inline bool operator == (quaternion<T> const & lhs, ::std::complex<T> const & rhs) | |
| { | |
| return ( | |
| (lhs.R_component_1() == rhs.real())&& | |
| (lhs.R_component_2() == rhs.imag())&& | |
| (lhs.R_component_3() == static_cast<T>(0))&& | |
| (lhs.R_component_4() == static_cast<T>(0)) | |
| ); | |
| } | |
| template<typename T> | |
| inline bool operator == (quaternion<T> const & lhs, quaternion<T> const & rhs) | |
| { | |
| return ( | |
| (rhs.R_component_1() == lhs.R_component_1())&& | |
| (rhs.R_component_2() == lhs.R_component_2())&& | |
| (rhs.R_component_3() == lhs.R_component_3())&& | |
| (rhs.R_component_4() == lhs.R_component_4()) | |
| ); | |
| } | |
| #define BOOST_QUATERNION_NOT_EQUAL_GENERATOR \ | |
| { \ | |
| return(!(lhs == rhs)); \ | |
| } | |
| template<typename T> | |
| inline bool operator != (T const & lhs, quaternion<T> const & rhs) | |
| BOOST_QUATERNION_NOT_EQUAL_GENERATOR | |
| template<typename T> | |
| inline bool operator != (quaternion<T> const & lhs, T const & rhs) | |
| BOOST_QUATERNION_NOT_EQUAL_GENERATOR | |
| template<typename T> | |
| inline bool operator != (::std::complex<T> const & lhs, quaternion<T> const & rhs) | |
| BOOST_QUATERNION_NOT_EQUAL_GENERATOR | |
| template<typename T> | |
| inline bool operator != (quaternion<T> const & lhs, ::std::complex<T> const & rhs) | |
| BOOST_QUATERNION_NOT_EQUAL_GENERATOR | |
| template<typename T> | |
| inline bool operator != (quaternion<T> const & lhs, quaternion<T> const & rhs) | |
| BOOST_QUATERNION_NOT_EQUAL_GENERATOR | |
| #undef BOOST_QUATERNION_NOT_EQUAL_GENERATOR | |
| // Note: we allow the following formats, whith a, b, c, and d reals | |
| // a | |
| // (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)) | |
| #if BOOST_WORKAROUND(__GNUC__, < 3) | |
| template<typename T> | |
| std::istream & operator >> ( ::std::istream & is, | |
| quaternion<T> & q) | |
| #else | |
| template<typename T, typename charT, class traits> | |
| ::std::basic_istream<charT,traits> & operator >> ( ::std::basic_istream<charT,traits> & is, | |
| quaternion<T> & q) | |
| #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ | |
| { | |
| #if BOOST_WORKAROUND(__GNUC__, < 3) | |
| typedef char charT; | |
| #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ | |
| #ifdef BOOST_NO_STD_LOCALE | |
| #else | |
| const ::std::ctype<charT> & ct = ::std::use_facet< ::std::ctype<charT> >(is.getloc()); | |
| #endif /* BOOST_NO_STD_LOCALE */ | |
| T a = T(); | |
| T b = T(); | |
| T c = T(); | |
| T d = T(); | |
| ::std::complex<T> u = ::std::complex<T>(); | |
| ::std::complex<T> v = ::std::complex<T>(); | |
| charT ch = charT(); | |
| char cc; | |
| is >> ch; // get the first lexeme | |
| if (!is.good()) goto finish; | |
| #ifdef BOOST_NO_STD_LOCALE | |
| cc = ch; | |
| #else | |
| cc = ct.narrow(ch, char()); | |
| #endif /* BOOST_NO_STD_LOCALE */ | |
| 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,)) | |
| { | |
| is >> ch; // get the second lexeme | |
| if (!is.good()) goto finish; | |
| #ifdef BOOST_NO_STD_LOCALE | |
| cc = ch; | |
| #else | |
| cc = ct.narrow(ch, char()); | |
| #endif /* BOOST_NO_STD_LOCALE */ | |
| if (cc == '(') // read "((", possible: ((a)), ((a),c), ((a),(c)), ((a),(c,d)), ((a,b)), ((a,b),c), ((a,b),(c)), ((a,b,),(c,d,)) | |
| { | |
| is.putback(ch); | |
| is >> u; // we extract the first and second components | |
| a = u.real(); | |
| b = u.imag(); | |
| if (!is.good()) goto finish; | |
| is >> ch; // get the next lexeme | |
| if (!is.good()) goto finish; | |
| #ifdef BOOST_NO_STD_LOCALE | |
| cc = ch; | |
| #else | |
| cc = ct.narrow(ch, char()); | |
| #endif /* BOOST_NO_STD_LOCALE */ | |
| if (cc == ')') // format: ((a)) or ((a,b)) | |
| { | |
| q = quaternion<T>(a,b); | |
| } | |
| 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,)) | |
| { | |
| is >> v; // we extract the third and fourth components | |
| c = v.real(); | |
| d = v.imag(); | |
| if (!is.good()) goto finish; | |
| is >> ch; // get the last lexeme | |
| if (!is.good()) goto finish; | |
| #ifdef BOOST_NO_STD_LOCALE | |
| cc = ch; | |
| #else | |
| cc = ct.narrow(ch, char()); | |
| #endif /* BOOST_NO_STD_LOCALE */ | |
| if (cc == ')') // format: ((a),c), ((a),(c)), ((a),(c,d)), ((a,b),c), ((a,b),(c)) or ((a,b,),(c,d,)) | |
| { | |
| q = quaternion<T>(a,b,c,d); | |
| } | |
| else // error | |
| { | |
| #if BOOST_WORKAROUND(__GNUC__, < 3) | |
| is.setstate(::std::ios::failbit); | |
| #else | |
| is.setstate(::std::ios_base::failbit); | |
| #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ | |
| } | |
| } | |
| else // error | |
| { | |
| #if BOOST_WORKAROUND(__GNUC__, < 3) | |
| is.setstate(::std::ios::failbit); | |
| #else | |
| is.setstate(::std::ios_base::failbit); | |
| #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ | |
| } | |
| } | |
| else // read "(a", possible: (a), (a,b), (a,b,c), (a,b,c,d), (a,(c)), (a,(c,d)) | |
| { | |
| is.putback(ch); | |
| is >> a; // we extract the first component | |
| if (!is.good()) goto finish; | |
| is >> ch; // get the third lexeme | |
| if (!is.good()) goto finish; | |
| #ifdef BOOST_NO_STD_LOCALE | |
| cc = ch; | |
| #else | |
| cc = ct.narrow(ch, char()); | |
| #endif /* BOOST_NO_STD_LOCALE */ | |
| if (cc == ')') // format: (a) | |
| { | |
| q = quaternion<T>(a); | |
| } | |
| else if (cc == ',') // read "(a,", possible: (a,b), (a,b,c), (a,b,c,d), (a,(c)), (a,(c,d)) | |
| { | |
| is >> ch; // get the fourth lexeme | |
| if (!is.good()) goto finish; | |
| #ifdef BOOST_NO_STD_LOCALE | |
| cc = ch; | |
| #else | |
| cc = ct.narrow(ch, char()); | |
| #endif /* BOOST_NO_STD_LOCALE */ | |
| if (cc == '(') // read "(a,(", possible: (a,(c)), (a,(c,d)) | |
| { | |
| is.putback(ch); | |
| is >> v; // we extract the third and fourth component | |
| c = v.real(); | |
| d = v.imag(); | |
| if (!is.good()) goto finish; | |
| is >> ch; // get the ninth lexeme | |
| if (!is.good()) goto finish; | |
| #ifdef BOOST_NO_STD_LOCALE | |
| cc = ch; | |
| #else | |
| cc = ct.narrow(ch, char()); | |
| #endif /* BOOST_NO_STD_LOCALE */ | |
| if (cc == ')') // format: (a,(c)) or (a,(c,d)) | |
| { | |
| q = quaternion<T>(a,b,c,d); | |
| } | |
| else // error | |
| { | |
| #if BOOST_WORKAROUND(__GNUC__, < 3) | |
| is.setstate(::std::ios::failbit); | |
| #else | |
| is.setstate(::std::ios_base::failbit); | |
| #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ | |
| } | |
| } | |
| else // read "(a,b", possible: (a,b), (a,b,c), (a,b,c,d) | |
| { | |
| is.putback(ch); | |
| is >> b; // we extract the second component | |
| if (!is.good()) goto finish; | |
| is >> ch; // get the fifth lexeme | |
| if (!is.good()) goto finish; | |
| #ifdef BOOST_NO_STD_LOCALE | |
| cc = ch; | |
| #else | |
| cc = ct.narrow(ch, char()); | |
| #endif /* BOOST_NO_STD_LOCALE */ | |
| if (cc == ')') // format: (a,b) | |
| { | |
| q = quaternion<T>(a,b); | |
| } | |
| else if (cc == ',') // read "(a,b,", possible: (a,b,c), (a,b,c,d) | |
| { | |
| is >> c; // we extract the third component | |
| if (!is.good()) goto finish; | |
| is >> ch; // get the seventh lexeme | |
| if (!is.good()) goto finish; | |
| #ifdef BOOST_NO_STD_LOCALE | |
| cc = ch; | |
| #else | |
| cc = ct.narrow(ch, char()); | |
| #endif /* BOOST_NO_STD_LOCALE */ | |
| if (cc == ')') // format: (a,b,c) | |
| { | |
| q = quaternion<T>(a,b,c); | |
| } | |
| else if (cc == ',') // read "(a,b,c,", possible: (a,b,c,d) | |
| { | |
| is >> d; // we extract the fourth component | |
| if (!is.good()) goto finish; | |
| is >> ch; // get the ninth lexeme | |
| if (!is.good()) goto finish; | |
| #ifdef BOOST_NO_STD_LOCALE | |
| cc = ch; | |
| #else | |
| cc = ct.narrow(ch, char()); | |
| #endif /* BOOST_NO_STD_LOCALE */ | |
| if (cc == ')') // format: (a,b,c,d) | |
| { | |
| q = quaternion<T>(a,b,c,d); | |
| } | |
| else // error | |
| { | |
| #if BOOST_WORKAROUND(__GNUC__, < 3) | |
| is.setstate(::std::ios::failbit); | |
| #else | |
| is.setstate(::std::ios_base::failbit); | |
| #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ | |
| } | |
| } | |
| else // error | |
| { | |
| #if BOOST_WORKAROUND(__GNUC__, < 3) | |
| is.setstate(::std::ios::failbit); | |
| #else | |
| is.setstate(::std::ios_base::failbit); | |
| #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ | |
| } | |
| } | |
| else // error | |
| { | |
| #if BOOST_WORKAROUND(__GNUC__, < 3) | |
| is.setstate(::std::ios::failbit); | |
| #else | |
| is.setstate(::std::ios_base::failbit); | |
| #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ | |
| } | |
| } | |
| } | |
| else // error | |
| { | |
| #if BOOST_WORKAROUND(__GNUC__, < 3) | |
| is.setstate(::std::ios::failbit); | |
| #else | |
| is.setstate(::std::ios_base::failbit); | |
| #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ | |
| } | |
| } | |
| } | |
| else // format: a | |
| { | |
| is.putback(ch); | |
| is >> a; // we extract the first component | |
| if (!is.good()) goto finish; | |
| q = quaternion<T>(a); | |
| } | |
| finish: | |
| return(is); | |
| } | |
| #if BOOST_WORKAROUND(__GNUC__, < 3) | |
| template<typename T> | |
| ::std::ostream & operator << ( ::std::ostream & os, | |
| quaternion<T> const & q) | |
| #else | |
| template<typename T, typename charT, class traits> | |
| ::std::basic_ostream<charT,traits> & operator << ( ::std::basic_ostream<charT,traits> & os, | |
| quaternion<T> const & q) | |
| #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ | |
| { | |
| #if BOOST_WORKAROUND(__GNUC__, < 3) | |
| ::std::ostringstream s; | |
| #else | |
| ::std::basic_ostringstream<charT,traits> s; | |
| #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ | |
| s.flags(os.flags()); | |
| #ifdef BOOST_NO_STD_LOCALE | |
| #else | |
| s.imbue(os.getloc()); | |
| #endif /* BOOST_NO_STD_LOCALE */ | |
| s.precision(os.precision()); | |
| s << '(' << q.R_component_1() << ',' | |
| << q.R_component_2() << ',' | |
| << q.R_component_3() << ',' | |
| << q.R_component_4() << ')'; | |
| return os << s.str(); | |
| } | |
| // values | |
| template<typename T> | |
| inline T real(quaternion<T> const & q) | |
| { | |
| return(q.real()); | |
| } | |
| template<typename T> | |
| inline quaternion<T> unreal(quaternion<T> const & q) | |
| { | |
| return(q.unreal()); | |
| } | |
| #define BOOST_QUATERNION_VALARRAY_LOADER \ | |
| using ::std::valarray; \ | |
| \ | |
| valarray<T> temp(4); \ | |
| \ | |
| temp[0] = q.R_component_1(); \ | |
| temp[1] = q.R_component_2(); \ | |
| temp[2] = q.R_component_3(); \ | |
| temp[3] = q.R_component_4(); | |
| template<typename T> | |
| inline T sup(quaternion<T> const & q) | |
| { | |
| #ifdef BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP | |
| using ::std::abs; | |
| #endif /* BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP */ | |
| BOOST_QUATERNION_VALARRAY_LOADER | |
| #if BOOST_WORKAROUND(__GNUC__, < 3) | |
| return((BOOST_GET_VALARRAY(T, abs(temp)).max)()); | |
| #else | |
| return((abs(temp).max)()); | |
| #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ | |
| } | |
| template<typename T> | |
| inline T l1(quaternion<T> const & q) | |
| { | |
| #ifdef BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP | |
| using ::std::abs; | |
| #endif /* BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP */ | |
| BOOST_QUATERNION_VALARRAY_LOADER | |
| #if BOOST_WORKAROUND(__GNUC__, < 3) | |
| return(BOOST_GET_VALARRAY(T, abs(temp)).sum()); | |
| #else | |
| return(abs(temp).sum()); | |
| #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ | |
| } | |
| template<typename T> | |
| inline T abs(quaternion<T> const & q) | |
| { | |
| #ifdef BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP | |
| using ::std::abs; | |
| #endif /* BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP */ | |
| using ::std::sqrt; | |
| BOOST_QUATERNION_VALARRAY_LOADER | |
| #if BOOST_WORKAROUND(__GNUC__, < 3) | |
| T maxim = (BOOST_GET_VALARRAY(T, abs(temp)).max)(); // overflow protection | |
| #else | |
| T maxim = (abs(temp).max)(); // overflow protection | |
| #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ | |
| if (maxim == static_cast<T>(0)) | |
| { | |
| return(maxim); | |
| } | |
| else | |
| { | |
| T mixam = static_cast<T>(1)/maxim; // prefer multiplications over divisions | |
| temp *= mixam; | |
| temp *= temp; | |
| return(maxim*sqrt(temp.sum())); | |
| } | |
| //return(sqrt(norm(q))); | |
| } | |
| #undef BOOST_QUATERNION_VALARRAY_LOADER | |
| // Note: This is the Cayley norm, not the Euclidian norm... | |
| template<typename T> | |
| inline T norm(quaternion<T>const & q) | |
| { | |
| return(real(q*conj(q))); | |
| } | |
| template<typename T> | |
| inline quaternion<T> conj(quaternion<T> const & q) | |
| { | |
| return(quaternion<T>( +q.R_component_1(), | |
| -q.R_component_2(), | |
| -q.R_component_3(), | |
| -q.R_component_4())); | |
| } | |
| template<typename T> | |
| inline quaternion<T> spherical( T const & rho, | |
| T const & theta, | |
| T const & phi1, | |
| T const & phi2) | |
| { | |
| using ::std::cos; | |
| using ::std::sin; | |
| //T a = cos(theta)*cos(phi1)*cos(phi2); | |
| //T b = sin(theta)*cos(phi1)*cos(phi2); | |
| //T c = sin(phi1)*cos(phi2); | |
| //T d = sin(phi2); | |
| T courrant = static_cast<T>(1); | |
| T d = sin(phi2); | |
| courrant *= cos(phi2); | |
| T c = sin(phi1)*courrant; | |
| courrant *= cos(phi1); | |
| T b = sin(theta)*courrant; | |
| T a = cos(theta)*courrant; | |
| return(rho*quaternion<T>(a,b,c,d)); | |
| } | |
| template<typename T> | |
| inline quaternion<T> semipolar( T const & rho, | |
| T const & alpha, | |
| T const & theta1, | |
| T const & theta2) | |
| { | |
| using ::std::cos; | |
| using ::std::sin; | |
| T a = cos(alpha)*cos(theta1); | |
| T b = cos(alpha)*sin(theta1); | |
| T c = sin(alpha)*cos(theta2); | |
| T d = sin(alpha)*sin(theta2); | |
| return(rho*quaternion<T>(a,b,c,d)); | |
| } | |
| template<typename T> | |
| inline quaternion<T> multipolar( T const & rho1, | |
| T const & theta1, | |
| T const & rho2, | |
| T const & theta2) | |
| { | |
| using ::std::cos; | |
| using ::std::sin; | |
| T a = rho1*cos(theta1); | |
| T b = rho1*sin(theta1); | |
| T c = rho2*cos(theta2); | |
| T d = rho2*sin(theta2); | |
| return(quaternion<T>(a,b,c,d)); | |
| } | |
| template<typename T> | |
| inline quaternion<T> cylindrospherical( T const & t, | |
| T const & radius, | |
| T const & longitude, | |
| T const & latitude) | |
| { | |
| using ::std::cos; | |
| using ::std::sin; | |
| T b = radius*cos(longitude)*cos(latitude); | |
| T c = radius*sin(longitude)*cos(latitude); | |
| T d = radius*sin(latitude); | |
| return(quaternion<T>(t,b,c,d)); | |
| } | |
| template<typename T> | |
| inline quaternion<T> cylindrical(T const & r, | |
| T const & angle, | |
| T const & h1, | |
| T const & h2) | |
| { | |
| using ::std::cos; | |
| using ::std::sin; | |
| T a = r*cos(angle); | |
| T b = r*sin(angle); | |
| return(quaternion<T>(a,b,h1,h2)); | |
| } | |
| // transcendentals | |
| // (please see the documentation) | |
| template<typename T> | |
| inline quaternion<T> exp(quaternion<T> const & q) | |
| { | |
| using ::std::exp; | |
| using ::std::cos; | |
| using ::boost::math::sinc_pi; | |
| T u = exp(real(q)); | |
| T z = abs(unreal(q)); | |
| T w = sinc_pi(z); | |
| return(u*quaternion<T>(cos(z), | |
| w*q.R_component_2(), w*q.R_component_3(), | |
| w*q.R_component_4())); | |
| } | |
| template<typename T> | |
| inline quaternion<T> cos(quaternion<T> const & q) | |
| { | |
| using ::std::sin; | |
| using ::std::cos; | |
| using ::std::cosh; | |
| using ::boost::math::sinhc_pi; | |
| T z = abs(unreal(q)); | |
| T w = -sin(q.real())*sinhc_pi(z); | |
| return(quaternion<T>(cos(q.real())*cosh(z), | |
| w*q.R_component_2(), w*q.R_component_3(), | |
| w*q.R_component_4())); | |
| } | |
| template<typename T> | |
| inline quaternion<T> sin(quaternion<T> const & q) | |
| { | |
| using ::std::sin; | |
| using ::std::cos; | |
| using ::std::cosh; | |
| using ::boost::math::sinhc_pi; | |
| T z = abs(unreal(q)); | |
| T w = +cos(q.real())*sinhc_pi(z); | |
| return(quaternion<T>(sin(q.real())*cosh(z), | |
| w*q.R_component_2(), w*q.R_component_3(), | |
| w*q.R_component_4())); | |
| } | |
| template<typename T> | |
| inline quaternion<T> tan(quaternion<T> const & q) | |
| { | |
| return(sin(q)/cos(q)); | |
| } | |
| template<typename T> | |
| inline quaternion<T> cosh(quaternion<T> const & q) | |
| { | |
| return((exp(+q)+exp(-q))/static_cast<T>(2)); | |
| } | |
| template<typename T> | |
| inline quaternion<T> sinh(quaternion<T> const & q) | |
| { | |
| return((exp(+q)-exp(-q))/static_cast<T>(2)); | |
| } | |
| template<typename T> | |
| inline quaternion<T> tanh(quaternion<T> const & q) | |
| { | |
| return(sinh(q)/cosh(q)); | |
| } | |
| template<typename T> | |
| quaternion<T> pow(quaternion<T> const & q, | |
| int n) | |
| { | |
| if (n > 1) | |
| { | |
| int m = n>>1; | |
| quaternion<T> result = pow(q, m); | |
| result *= result; | |
| if (n != (m<<1)) | |
| { | |
| result *= q; // n odd | |
| } | |
| return(result); | |
| } | |
| else if (n == 1) | |
| { | |
| return(q); | |
| } | |
| else if (n == 0) | |
| { | |
| return(quaternion<T>(1)); | |
| } | |
| else /* n < 0 */ | |
| { | |
| return(pow(quaternion<T>(1)/q,-n)); | |
| } | |
| } | |
| // helper templates for converting copy constructors (definition) | |
| namespace detail | |
| { | |
| template< typename T, | |
| typename U | |
| > | |
| quaternion<T> quaternion_type_converter(quaternion<U> const & rhs) | |
| { | |
| return(quaternion<T>( static_cast<T>(rhs.R_component_1()), | |
| static_cast<T>(rhs.R_component_2()), | |
| static_cast<T>(rhs.R_component_3()), | |
| static_cast<T>(rhs.R_component_4()))); | |
| } | |
| } | |
| } | |
| } | |
| #if BOOST_WORKAROUND(__GNUC__, < 3) | |
| #undef BOOST_GET_VALARRAY | |
| #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */ | |
| #endif /* BOOST_QUATERNION_HPP */ |