Main Page | Class List | Directories | File List | Class Members | File Members | Related Pages | Search for 

quat Class Reference

double-precision quaternion class More...

#include <quat.hpp>

List of all members.

Public Member Functions

 quat ()
 quat (const quat &)
 quat (const double &, const double &, const double &, const double &)
 ~quat ()
double & operator() (const int &)
double operator() (const int &) const
void normalize ()
quat operator+ (void)
quat operator- (void)
quat & operator= (const quat &)
quat & operator+= (const quat &)
quat & operator-= (const quat &)
quat & operator *= (const quat &)
quat & operator/= (const quat &)
quat & operator *= (const double &)
quat & operator/= (const double &)

Public Attributes

double x
 $ Q_0 $ component
double y
 $ Q_1 $ component
double z
 $ Q_2 $ component
double r
 $ Q_3 $ component

Friends

std::ostream & operator<< (std::ostream &, const quat &)
double abs (const quat &)
double norm (const quat &)
quat normal (const quat &)
quat inv (const quat &)
vec im (const quat &)
vec q2vt (const quat &)
quat conj (const quat &)
void swap (quat &, quat &)
quat operator+ (const quat &, const quat &)
quat operator- (const quat &, const quat &)
quat operator * (const quat &, const quat &)
quat operator/ (const quat &, const quat &)
quat operator * (const quat &, const double &)
quat operator/ (const quat &, const double &)
quat operator * (const double &, const quat &)

Detailed Description

double-precision quaternion class

Definition at line 3 of file quat.hpp.

Constructor & Destructor Documentation

quat::quat (   )  [inline]
 

quat constructor without arguments

Definition at line 3 of file quat-constructor.hpp.

Referenced by operator-().

00004 {
00005   ;
00006 }

quat::quat (  const quat &  q  )  [inline]
 

quat copy constructor

Definition at line 14 of file quat-constructor.hpp.

00015   : x(q.x), y(q.y), z(q.z), r(q.r)
00016 {
00017   ;
00018 }

quat::quat (  const double &  _x,
const double &  _y,
const double &  _z,
const double &  _r
)  [inline]
 

quat constructor to build from four components

Definition at line 23 of file quat-constructor.hpp.

00025   : x(_x), y(_y), z(_z), r(_r)
00026 {
00027   ;
00028 }

quat::~quat (   )  [inline]
 

quat destructor

Definition at line 36 of file quat-constructor.hpp.

00037 {
00038   ;
00039 }

Member Function Documentation

double & quat::operator() (  const int &  i  )  [inline]
 

operator() for non-const object

Definition at line 3 of file quat-io.hpp.

References r, x, y, and z.

00004 {
00005   switch( i ){
00006   case 0: return x;
00007   case 1: return y;
00008   case 2: return z;
00009   case 3: return r;
00010   default:
00011     std::cerr << "[ERROR] quat::operator()(const int&)" << std::endl
00012               << "The required component was not 0, 1, 2, or 3." << std::endl
00013               << "Your input was (" << i << ")." << std::endl;
00014     std::exit(1);
00015   }
00016 }

double quat::operator() (  const int &  i  )  const [inline]
 

operator() for const object

Definition at line 20 of file quat-io.hpp.

References r, x, y, and z.

00021 {
00022   switch( i ){
00023   case 0: return x;
00024   case 1: return y;
00025   case 2: return z;
00026   case 3: return r;
00027   default:
00028     std::cerr << "[ERROR] quat::operator()(const int&) const" << std::endl
00029               << "The required component was not 0, 1, 2, or 3." << std::endl
00030               << "Your input was (" << i << ")." << std::endl;
00031     std::exit(1);
00032   }
00033 }

void quat::normalize (   )  [inline]
 

normalize itself

Definition at line 3 of file quat-calc.hpp.

References abs, r, x, y, and z.

00004 {
00005   double myabs(abs(*this));
00006   x /=myabs;
00007   y /=myabs;
00008   z /=myabs;
00009   r /=myabs;
00010 }

quat quat::operator+ (  void   )  [inline]
 

Definition at line 2 of file quat-unary.hpp.

00003 {
00004   return( *this );
00005 }

quat quat::operator- (  void   )  [inline]
 

Definition at line 8 of file quat-unary.hpp.

References quat(), r, x, y, and z.

00009 {
00010   return quat(-x, -y, -z, -r);
00011 }

quat & quat::operator= (  const quat &  q  )  [inline]
 

quat=quat operator

Definition at line 3 of file quat-quat.hpp.

References r, x, y, and z.

00004 {
00005   x =q.x;
00006   y =q.y;
00007   z =q.z;
00008   r =q.r;
00009   return *this;
00010 }

quat & quat::operator+= (  const quat &  q  )  [inline]
 

quat+=quat operator

Definition at line 18 of file quat-quat.hpp.

References r, x, y, and z.

00019 {
00020   x +=q.x;
00021   y +=q.y;
00022   z +=q.z;
00023   r +=q.r;
00024   return *this;
00025 }

quat & quat::operator-= (  const quat &  q  )  [inline]
 

quat-=quat operator

Definition at line 29 of file quat-quat.hpp.

References r, x, y, and z.

00030 {
00031   x -=q.x;
00032   y -=q.y;
00033   z -=q.z;
00034   r -=q.r;
00035   return *this;
00036 }

quat & quat::operator *= (  const quat &  q  )  [inline]
 

quat*=quat operator

Definition at line 40 of file quat-quat.hpp.

00041 {
00042   (*this) =(*this)*q;
00043   return *this;
00044 }

quat & quat::operator/= (  const quat &  q  )  [inline]
 

quat/=quat operator

Definition at line 48 of file quat-quat.hpp.

00049 {
00050   (*this) =(*this)/q;
00051   return *this;
00052 }

quat & quat::operator *= (  const double &  d  )  [inline]
 

quat*=double operator

Definition at line 3 of file quat-double.hpp.

References r, x, y, and z.

00004 {
00005   x *=d;
00006   y *=d;
00007   z *=d;
00008   r *=d;
00009   return *this;
00010 }

quat & quat::operator/= (  const double &  d  )  [inline]
 

quat/=double operator

Definition at line 14 of file quat-double.hpp.

References r, x, y, and z.

00015 {
00016   x /=d;
00017   y /=d;
00018   z /=d;
00019   r /=d;
00020   return *this;
00021 }

Friends And Related Function Documentation

std::ostream& operator<< (  std::ostream &  s,
const quat &  q
)  [friend]
 

Definition at line 40 of file quat-io.hpp.

00041 {
00042   s << "( " << q.x << ", " << q.y << ", " << q.z
00043     << "; " << q.r << " )";
00044   return s;
00045 }

double abs (  const quat &  q  )  [friend]
 

return abs

Definition at line 18 of file quat-calc.hpp.

Referenced by normalize().

00019 {
00020   return std::sqrt(q.x*q.x +q.y*q.y +q.z*q.z +q.r*q.r);
00021 }

double norm (  const quat &  q  )  [friend]
 

return norm

Definition at line 25 of file quat-calc.hpp.

00026 {
00027   return q.x*q.x +q.y*q.y +q.z*q.z +q.r*q.r;
00028 }

quat normal (  const quat &  q  )  [friend]
 

return the normalized quat

Definition at line 32 of file quat-calc.hpp.

00033 {
00034   double abs_q(abs(q));
00035   return quat( q.x/abs_q, q.y/abs_q, q.z/abs_q, q.r/abs_q );
00036 }

quat inv (  const quat &  q  )  [friend]
 

return the inverse quat

Definition at line 44 of file quat-calc.hpp.

00045 {
00046   return conj(q)/norm(q);
00047 }

vec im (  const quat &  q  )  [friend]
 

return the imaginary part

Definition at line 3 of file quat-misc.hpp.

00004 {
00005   return vec( q.x, q.y, q.z );
00006 }

vec q2vt (  const quat &  q  )  [friend]
 

return vec from quat (|vec|=theta)

Definition at line 10 of file quat-misc.hpp.

00011 {
00012   double sin_theta_half;
00013   double theta( 2.*std::acos(q.r) );
00014   
00015   if(theta<M_PI){
00016     sin_theta_half =std::sin(0.5*theta);
00017   }
00018   else{
00019     theta -=2.*M_PI;
00020     sin_theta_half =-std::sin(0.5*theta);
00021   }
00022   
00023   return vec( theta*q.x/sin_theta_half,
00024               theta*q.y/sin_theta_half,
00025               theta*q.z/sin_theta_half );
00026 }

quat conj (  const quat &  q  )  [friend]
 

return the conjugate quat

Definition at line 34 of file quat-misc.hpp.

00035 {
00036   return quat( -q.x, -q.y, -q.z, q.r );
00037 }

void swap (  quat &  q1,
quat &  q2
)  [friend]
 

swap two quats

Definition at line 45 of file quat-misc.hpp.

00046 {
00047   quat _q1(q1);
00048   q1 = q2;
00049   q2 =_q1;
00050 }

quat operator+ (  const quat &  q1,
const quat &  q2
)  [friend]
 

quat+quat operator

Definition at line 61 of file quat-quat.hpp.

00062 {
00063   return quat(q1.x+q2.x, q1.y+q2.y, q1.z+q2.z, q1.r+q2.r);
00064 }

quat operator- (  const quat &  q1,
const quat &  q2
)  [friend]
 

quat-quat operator

Definition at line 68 of file quat-quat.hpp.

00069 {
00070   return quat(q1.x-q2.x, q1.y-q2.y, q1.z-q2.z, q1.r-q2.r);
00071 }

quat operator * (  const quat &  q1,
const quat &  q2
)  [friend]
 

quat*quat operator

Definition at line 75 of file quat-quat.hpp.

00076 {
00077   return quat(q1.r*q2.x +q1.x*q2.r +q1.y*q2.z -q1.z*q2.y,
00078               q1.r*q2.y -q1.x*q2.z +q1.y*q2.r +q1.z*q2.x,
00079               q1.r*q2.z +q1.x*q2.y -q2.x*q1.y +q1.z*q2.r,
00080               q1.r*q2.r -q1.x*q2.x -q1.y*q2.y -q1.z*q2.z );
00081 }

quat operator/ (  const quat &  q1,
const quat &  q2
)  [friend]
 

quat/quat operator

Definition at line 85 of file quat-quat.hpp.

00086 {
00087   return q1*inv(q2);
00088 }

quat operator * (  const quat &  q,
const double &  d
)  [friend]
 

quat*double operator

Definition at line 29 of file quat-double.hpp.

00030 {
00031   return quat( q.x*d, q.y*d, q.z*d, q.r*d );
00032 }

quat operator/ (  const quat &  q,
const double &  d
)  [friend]
 

quat/double operator

Definition at line 36 of file quat-double.hpp.

00037 {
00038   return quat( q.x/d, q.y/d, q.z/d, q.r/d );
00039 }

quat operator * (  const double &  d,
const quat &  q
)  [friend]
 

double*quat operator

Definition at line 3 of file double-quat.hpp.

00004 {
00005   return quat( d*q.x, d*q.y, d*q.z, d*q.r );
00006 }

Member Data Documentation

double quat::x
 

$ Q_0 $ component

Definition at line 7 of file quat.hpp.

Referenced by normalize(), operator *=(), operator()(), operator+=(), operator-(), operator-=(), operator/=(), and operator=().

double quat::y
 

$ Q_1 $ component

Definition at line 8 of file quat.hpp.

Referenced by normalize(), operator *=(), operator()(), operator+=(), operator-(), operator-=(), operator/=(), and operator=().

double quat::z
 

$ Q_2 $ component

Definition at line 9 of file quat.hpp.

Referenced by normalize(), operator *=(), operator()(), operator+=(), operator-(), operator-=(), operator/=(), and operator=().

double quat::r
 

$ Q_3 $ component

Definition at line 10 of file quat.hpp.

Referenced by normalize(), operator *=(), operator()(), operator+=(), operator-(), operator-=(), operator/=(), and operator=().

The documentation for this class was generated from the following files:
Generated on Tue Mar 15 16:02:38 2005 for QVM by  doxygen 1.4.1