math-quaternion.qbk

Boost provides free peer-reviewed portable C++ source libraries. We emphasize libraries that work

   template<>
   class quaternion<float>
   {
   public:
      typedef float ``[link boost_quaternions.quaternions.mem_typedef value_type]``;
   	
      explicit ``[link boost_quaternions.quaternions.mem_fun.constructors quaternion]``(float const & requested_a = 0.0f, float const & requested_b = 0.0f, float const & requested_c = 0.0f, float const & requested_d = 0.0f);
      explicit ``[link boost_quaternions.quaternions.mem_fun.constructors quaternion]``(::std::complex<float> const & z0, ::std::complex<float> const & z1 = ::std::complex<float>());
      explicit ``[link boost_quaternions.quaternions.mem_fun.constructors quaternion]``(quaternion<double> const & a_recopier);
      explicit ``[link boost_quaternions.quaternions.mem_fun.constructors quaternion]``(quaternion<long double> const & a_recopier);
   	
      float                  ``[link boost_quaternions.quaternions.mem_fun.real_and_unreal_parts real]``() const;
      quaternion<float>      ``[link boost_quaternions.quaternions.mem_fun.real_and_unreal_parts unreal]``() const;
      float                  ``[link boost_quaternions.quaternions.mem_fun.individual_real_components R_component_1]``() const;
      float                  ``[link boost_quaternions.quaternions.mem_fun.individual_real_components R_component_2]``() const;
      float                  ``[link boost_quaternions.quaternions.mem_fun.individual_real_components R_component_3]``() const;
      float                  ``[link boost_quaternions.quaternions.mem_fun.individual_real_components R_component_4]``() const;
      ::std::complex<float>  ``[link boost_quaternions.quaternions.mem_fun.individual_complex__components C_component_1]``() const;
      ::std::complex<float>  ``[link boost_quaternions.quaternions.mem_fun.individual_complex__components C_component_2]``() const;

      quaternion<float>&     ``[link boost_quaternions.quaternions.mem_fun.assignment_operators operator = ]``(quaternion<float> const  & a_affecter);
      template<typename X>	
      quaternion<float>&     ``[link boost_quaternions.quaternions.mem_fun.assignment_operators operator = ]``(quaternion<X> const  & a_affecter);
      quaternion<float>&     ``[link boost_quaternions.quaternions.mem_fun.assignment_operators operator = ]``(float const  & a_affecter);
      quaternion<float>&     ``[link boost_quaternions.quaternions.mem_fun.assignment_operators operator = ]``(::std::complex<float> const & a_affecter);

      quaternion<float>&     ``[link boost_quaternions.quaternions.mem_fun.addition_operators operator += ]``(float const & rhs);
      quaternion<float>&     ``[link boost_quaternions.quaternions.mem_fun.addition_operators operator += ]``(::std::complex<float> const & rhs);
      template<typename X>
      quaternion<float>&     ``[link boost_quaternions.quaternions.mem_fun.addition_operators operator += ]``(quaternion<X> const & rhs);

      quaternion<float>&     ``[link boost_quaternions.quaternions.mem_fun.subtraction_operators operator -= ]``(float const & rhs);
      quaternion<float>&     ``[link boost_quaternions.quaternions.mem_fun.subtraction_operators operator -= ]``(::std::complex<float> const & rhs);
      template<typename X>
      quaternion<float>&     ``[link boost_quaternions.quaternions.mem_fun.subtraction_operators operator -= ]``(quaternion<X> const & rhs);

      quaternion<float>&     ``[link boost_quaternions.quaternions.mem_fun.multiplication_operators operator *= ]``(float const & rhs);
      quaternion<float>&     ``[link boost_quaternions.quaternions.mem_fun.multiplication_operators operator *= ]``(::std::complex<float> const & rhs);
      template<typename X>
      quaternion<float>&     ``[link boost_quaternions.quaternions.mem_fun.multiplication_operators operator *= ]``(quaternion<X> const & rhs);

      quaternion<float>&     ``[link boost_quaternions.quaternions.mem_fun.division_operators operator /= ]``(float const & rhs);
      quaternion<float>&     ``[link boost_quaternions.quaternions.mem_fun.division_operators operator /= ]``(::std::complex<float> const & rhs);
      template<typename X>
      quaternion<float>&     ``[link boost_quaternions.quaternions.mem_fun.division_operators operator /= ]``(quaternion<X> const & rhs);
   };
   
[#boost_quaternions.quaternion_double]

   template<>
   class quaternion<double>
   {
   public:
      typedef double ``[link boost_quaternions.quaternions.mem_typedef value_type]``;
   	
      explicit ``[link boost_quaternions.quaternions.mem_fun.constructors quaternion]``(double const & requested_a = 0.0, double const & requested_b = 0.0, double const & requested_c = 0.0, double const & requested_d = 0.0);
      explicit ``[link boost_quaternions.quaternions.mem_fun.constructors quaternion]``(::std::complex<double> const & z0, ::std::complex<double> const & z1 = ::std::complex<double>());
      explicit ``[link boost_quaternions.quaternions.mem_fun.constructors quaternion]``(quaternion<float> const & a_recopier);
      explicit ``[link boost_quaternions.quaternions.mem_fun.constructors quaternion]``(quaternion<long double> const & a_recopier);
   	
      double                  ``[link boost_quaternions.quaternions.mem_fun.real_and_unreal_parts real]``() const;
      quaternion<double>      ``[link boost_quaternions.quaternions.mem_fun.real_and_unreal_parts unreal]``() const;
      double                  ``[link boost_quaternions.quaternions.mem_fun.individual_real_components R_component_1]``() const;
      double                  ``[link boost_quaternions.quaternions.mem_fun.individual_real_components R_component_2]``() const;
      double                  ``[link boost_quaternions.quaternions.mem_fun.individual_real_components R_component_3]``() const;
      double                  ``[link boost_quaternions.quaternions.mem_fun.individual_real_components R_component_4]``() const;
      ::std::complex<double>  ``[link boost_quaternions.quaternions.mem_fun.individual_complex__components C_component_1]``() const;
      ::std::complex<double>  ``[link boost_quaternions.quaternions.mem_fun.individual_complex__components C_component_2]``() const;

      quaternion<double>&     ``[link boost_quaternions.quaternions.mem_fun.assignment_operators operator = ]``(quaternion<double> const  & a_affecter);
      template<typename X>	
      quaternion<double>&     ``[link boost_quaternions.quaternions.mem_fun.assignment_operators operator = ]``(quaternion<X> const  & a_affecter);
      quaternion<double>&     ``[link boost_quaternions.quaternions.mem_fun.assignment_operators operator = ]``(double const  & a_affecter);
      quaternion<double>&     ``[link boost_quaternions.quaternions.mem_fun.assignment_operators operator = ]``(::std::complex<double> const & a_affecter);

      quaternion<double>&     ``[link boost_quaternions.quaternions.mem_fun.addition_operators operator += ]``(double const & rhs);
      quaternion<double>&     ``[link boost_quaternions.quaternions.mem_fun.addition_operators operator += ]``(::std::complex<double> const & rhs);
      template<typename X>
      quaternion<double>&     ``[link boost_quaternions.quaternions.mem_fun.addition_operators operator += ]``(quaternion<X> const & rhs);

      quaternion<double>&     ``[link boost_quaternions.quaternions.mem_fun.subtraction_operators operator -= ]``(double const & rhs);
      quaternion<double>&     ``[link boost_quaternions.quaternions.mem_fun.subtraction_operators operator -= ]``(::std::complex<double> const & rhs);
      template<typename X>
      quaternion<double>&     ``[link boost_quaternions.quaternions.mem_fun.subtraction_operators operator -= ]``(quaternion<X> const & rhs);

      quaternion<double>&     ``[link boost_quaternions.quaternions.mem_fun.multiplication_operators operator *= ]``(double const & rhs);
      quaternion<double>&     ``[link boost_quaternions.quaternions.mem_fun.multiplication_operators operator *= ]``(::std::complex<double> const & rhs);
      template<typename X>
      quaternion<double>&     ``[link boost_quaternions.quaternions.mem_fun.multiplication_operators operator *= ]``(quaternion<X> const & rhs);

      quaternion<double>&     ``[link boost_quaternions.quaternions.mem_fun.division_operators operator /= ]``(double const & rhs);
      quaternion<double>&     ``[link boost_quaternions.quaternions.mem_fun.division_operators operator /= ]``(::std::complex<double> const & rhs);
      template<typename X>
      quaternion<double>&     ``[link boost_quaternions.quaternions.mem_fun.division_operators operator /= ]``(quaternion<X> const & rhs);
   };

[#boost_quaternions.quaternion_long_double]

   template<>
   class quaternion<long double>
   {
   public:
      typedef long double ``[link boost_quaternions.quaternions.mem_typedef value_type]``;
   	
      explicit ``[link boost_quaternions.quaternions.mem_fun.constructors quaternion]``(long double const & requested_a = 0.0L, long double const & requested_b = 0.0L, long double const & requested_c = 0.0L, long double const & requested_d = 0.0L);
      explicit ``[link boost_quaternions.quaternions.mem_fun.constructors quaternion]``(::std::complex<long double> const & z0, ::std::complex<long double> const & z1 = ::std::complex<long double>());
      explicit ``[link boost_quaternions.quaternions.mem_fun.constructors quaternion]``(quaternion<float> const & a_recopier);
      explicit ``[link boost_quaternions.quaternions.mem_fun.constructors quaternion]``(quaternion<double> const & a_recopier);
   	
      long double                  ``[link boost_quaternions.quaternions.mem_fun.real_and_unreal_parts real]``() const;
      quaternion<long double>      ``[link boost_quaternions.quaternions.mem_fun.real_and_unreal_parts unreal]``() const;
      long double                  ``[link boost_quaternions.quaternions.mem_fun.individual_real_components R_component_1]``() const;
      long double                  ``[link boost_quaternions.quaternions.mem_fun.individual_real_components R_component_2]``() const;
      long double                  ``[link boost_quaternions.quaternions.mem_fun.individual_real_components R_component_3]``() const;
      long double                  ``[link boost_quaternions.quaternions.mem_fun.individual_real_components R_component_4]``() const;
      ::std::complex<long double>  ``[link boost_quaternions.quaternions.mem_fun.individual_complex__components C_component_1]``() const;
      ::std::complex<long double>  ``[link boost_quaternions.quaternions.mem_fun.individual_complex__components C_component_2]``() const;

      quaternion<long double>&     ``[link boost_quaternions.quaternions.mem_fun.assignment_operators operator = ]``(quaternion<long double> const  & a_affecter);
      template<typename X>	
      quaternion<long double>&     ``[link boost_quaternions.quaternions.mem_fun.assignment_operators operator = ]``(quaternion<X> const  & a_affecter);
      quaternion<long double>&     ``[link boost_quaternions.quaternions.mem_fun.assignment_operators operator = ]``(long double const  & a_affecter);
      quaternion<long double>&     ``[link boost_quaternions.quaternions.mem_fun.assignment_operators operator = ]``(::std::complex<long double> const & a_affecter);

      quaternion<long double>&     ``[link boost_quaternions.quaternions.mem_fun.addition_operators operator += ]``(long double const & rhs);
      quaternion<long double>&     ``[link boost_quaternions.quaternions.mem_fun.addition_operators operator += ]``(::std::complex<long double> const & rhs);
      template<typename X>
      quaternion<long double>&     ``[link boost_quaternions.quaternions.mem_fun.addition_operators operator += ]``(quaternion<X> const & rhs);

      quaternion<long double>&     ``[link boost_quaternions.quaternions.mem_fun.subtraction_operators operator -= ]``(long double const & rhs);
      quaternion<long double>&     ``[link boost_quaternions.quaternions.mem_fun.subtraction_operators operator -= ]``(::std::complex<long double> const & rhs);
      template<typename X>
      quaternion<long double>&     ``[link boost_quaternions.quaternions.mem_fun.subtraction_operators operator -= ]``(quaternion<X> const & rhs);

      quaternion<long double>&     ``[link boost_quaternions.quaternions.mem_fun.multiplication_operators operator *= ]``(long double const & rhs);
      quaternion<long double>&     ``[link boost_quaternions.quaternions.mem_fun.multiplication_operators operator *= ]``(::std::complex<long double> const & rhs);
      template<typename X>
      quaternion<long double>&     ``[link boost_quaternions.quaternions.mem_fun.multiplication_operators operator *= ]``(quaternion<X> const & rhs);

      quaternion<long double>&     ``[link boost_quaternions.quaternions.mem_fun.division_operators operator /= ]``(long double const & rhs);
      quaternion<long double>&     ``[link boost_quaternions.quaternions.mem_fun.division_operators operator /= ]``(::std::complex<long double> const & rhs);
      template<typename X>
      quaternion<long double>&     ``[link boost_quaternions.quaternions.mem_fun.division_operators operator /= ]``(quaternion<X> const & rhs);
   };

   } // namespace math
   } // namespace boost
   
[endsect]

[section:mem_typedef Quaternion Member Typedefs]

[*value_type]

Template version:

   typedef T value_type;

Float specialization version:

   typedef float value_type;

Double specialization version:

   typedef double value_type;

Long double specialization version:

   typedef long double value_type;

These provide easy acces to the type the template is built upon.

[endsect]

[section:mem_fun Quaternion Member Functions]
[h3 Constructors]

Template version:

   explicit quaternion(T const & requested_a = T(), T const & requested_b = T(), T const & requested_c = T(), T const & requested_d = T());
   explicit quaternion(::std::complex<T> const & z0, ::std::complex<T> const & z1 = ::std::complex<T>());
   template<typename X>
   explicit quaternion(quaternion<X> const & a_recopier);

Float specialization version:

   explicit quaternion(float const & requested_a = 0.0f, float const & requested_b = 0.0f, float const & requested_c = 0.0f, float const & requested_d = 0.0f);
   explicit quaternion(::std::complex<float> const & z0,::std::complex<float> const & z1 = ::std::complex<float>());
   explicit quaternion(quaternion<double> const & a_recopier); 
   explicit quaternion(quaternion<long double> const & a_recopier);

Double specialization version:

   explicit quaternion(double const & requested_a = 0.0, double const & requested_b = 0.0, double const & requested_c = 0.0, double const & requested_d = 0.0);
   explicit quaternion(::std::complex<double> const & z0, ::std::complex<double> const & z1 = ::std::complex<double>());
   explicit quaternion(quaternion<float> const & a_recopier);
   explicit quaternion(quaternion<long double> const & a_recopier);

Long double specialization version:

   explicit quaternion(long double const & requested_a = 0.0L, long double const & requested_b = 0.0L, long double const & requested_c = 0.0L, long double const & requested_d = 0.0L);
   explicit quaternion(	::std::complex<long double> const & z0, ::std::complex<long double> const & z1 = ::std::complex<long double>());
   explicit quaternion(quaternion<float> const & a_recopier);
   explicit quaternion(quaternion<double> const & a_recopier);

A default constructor is provided for each form, which initializes 
each component to the default values for their type 
(i.e. zero for floating numbers). This constructor can also accept 
one to four base type arguments. A constructor is also provided to 
build quaternions from one or two complex numbers sharing the same 
base type. The unspecialized template also sports a templarized copy 
constructor, while the specialized forms have copy constructors 
from the other two specializations, which are explicit when a risk of 
precision loss exists. For the unspecialized form, the base type's 
constructors must not throw.

Destructors and untemplated copy constructors (from the same type) are 
provided by the compiler. Converting copy constructors make use of a 
templated helper function in a "detail" subnamespace.

[h3 Other member functions]
[h4 Real and Unreal Parts]

   T             real() const;
   quaternion<T> unreal() const;

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). 
These are returned by the first two functions.

[h4 Individual Real Components]