Main Page   Packages   Namespace List   Class Hierarchy   Alphabetical List   Compound List   File List   Compound Members   File Members   Search  

Vector4D Class Reference

#include <Vector4D.hh>

List of all members.

Public Methods

 Vector4D ()
 Vector4D (const double x, const double y, const double z, const double t)
 Vector4D (const Vector4D &v)
Vector4D & operator= (const Vector4D &v)
BOOL operator== (const Vector4D &v) const
BOOL operator!= (const Vector4D &v) const
void operator+= (const Vector4D &v)
void operator-= (const Vector4D &v)
void operator *= (const Vector4D &v)
void operator/= (const Vector4D &v)
void operator+= (const double Factor)
void operator-= (const double Factor)
void operator *= (const double Factor)
void operator/= (const double Factor)
void Abs ()
void AddScaled (const Vector4D &v, const double &Scale)
void Adjust (const double x, const double y, const double z, const double t)
BOOL bAtOrg () const
BOOL bWithinLimits (const double Limit) const
double Dot (const Vector4D &v) const
double X () const
double Y () const
double Z () const
double T () const
double X (const double x)
double Y (const double y)
double Z (const double z)
double T (const double t)
double Magnitude () const
double MagSum () const
void ClipToDegrees ()
void HalfBetween (const Vector4D &v)
void Negate ()
void Normalize ()
void Set (const double x, const double y, const double z, const double t)
void Square ()
void ToRadians ()
void Cross (const Vector4D &v)
void Mix (const Vector4D &v)

Private Attributes

double X
double Y
double Z
double T

Friends

class Matrix4by4
Vector4D operator+ (const Vector4D &left, const Vector4D &right)
Vector4D operator- (const Vector4D &left, const Vector4D &right)
Vector4D operator * (const Vector4D &left, const Vector4D &right)
Vector4D operator/ (const Vector4D &left, const Vector4D &right)
Vector4D operator+ (const Vector4D &left, const double Factor)
Vector4D operator- (const Vector4D &left, const double Factor)
Vector4D operator * (const Vector4D &left, const double Factor)
Vector4D operator/ (const Vector4D &left, const double Factor)
Vector4D vecHalfBetween (const Vector4D &left, const Vector4D &right)
Vector4D vecCross (const Vector4D &left, const Vector4D &right)
Vector4D vecMix (const Vector4D &left, const Vector4D &right)

Constructor & Destructor Documentation

Vector4D::Vector4D (    ) 
 

Definition at line 4 of file Vector4D.cc.

00005   : X( 0.0 ), Y( 0.0 ), Z( 0.0 ), T( 0.0 ) { }

Vector4D::Vector4D (  const double    x,
const double    y,
const double    z,
const double    t
) 
 

Definition at line 7 of file Vector4D.cc.

00009   : X( x ), Y( y ), Z( z ), T( t ) { }

Vector4D::Vector4D (  const Vector4D &    v ) 
 

Definition at line 11 of file Vector4D.cc.

00012   : X( v.X ), Y( v.Y ), Z( v.Z ), T( v.T ) { }

Member Function Documentation

void Vector4D::Abs (    )  [inline]
 

Definition at line 120 of file Vector4D.cc.

00120                           {
00121   X = abs(X);
00122   Y = abs(Y);
00123   Z = abs(Z);
00124   T = abs(T);
00125 }

void Vector4D::AddScaled (  const Vector4D &    v,
const double &    Scale
) 
 

void Vector4D::Adjust (  const double    x,
const double    y,
const double    z,
const double    t
)  [inline]
 

Definition at line 211 of file Vector4D.cc.

00212                                                                {
00213   X += x;
00214   Y += y;
00215   Z += z;
00216   T += t;
00217 }

void Vector4D::ClipToDegrees (    ) 
 

Definition at line 144 of file Vector4D.cc.

00144                              {
00145   if (X > 360.0) 
00146     X = mod(X, 360.0);
00147 
00148   if (Y > 360.0)
00149     Y = mod(Y, 360.0);
00150 
00151   if (Z > 360.0)
00152     Z = mod(Z, 360.0);
00153 
00154   if (T > 360.0)
00155     T = mod(T, 360.0);
00156 }

void Vector4D::Cross (  const Vector4D &    v ) 
 

Definition at line 290 of file Vector4D.cc.

00290                                         {
00291   const double xTmp = (Y * v.Z) - (Z * v.Y);
00292   const double yTmp = (Z * v.X) - (X * v.Z);
00293   const double zTmp = (X * v.Y) - (Y * v.X);
00294   X = xTmp;
00295   Y = yTmp;
00296   Z = zTmp;
00297 }

double Vector4D::Dot (  const Vector4D &    v )  const [inline]
 

Definition at line 136 of file Vector4D.cc.

00136                                                      {
00137   return (X * v.X) + (Y * v.Y) + (Z * v.Z) + (T * v.T);
00138 }

void Vector4D::HalfBetween (  const Vector4D &    v ) 
 

Definition at line 189 of file Vector4D.cc.

00189                                               {
00190   X = 0.5 * (X + v.X);
00191   Y = 0.5 * (Y + v.Y);
00192   Z = 0.5 * (Z + v.Z);
00193   T = 0.5 * (T + v.T);
00194 }

double Vector4D::MagSum (    )  const [inline]
 

Definition at line 255 of file Vector4D.cc.

00255                                      {
00256   return (X + Y + Z + T);
00257 }

double Vector4D::Magnitude (    )  const [inline]
 

Definition at line 140 of file Vector4D.cc.

Referenced by Normalize(). 

00140                                         {
00141   return sqrt( (X * X) + (Y * Y) + (Z * Z) + (T * T) );
00142 }

void Vector4D::Mix (  const Vector4D &    v ) 
 

Definition at line 309 of file Vector4D.cc.

00309                                       {  // ??????
00310   X *= v.Y;
00311   X *= v.Z;
00312   Y *= v.Z;
00313 }

void Vector4D::Negate (    )  [inline]
 

Definition at line 259 of file Vector4D.cc.

00259                              {
00260   X *= -1;
00261   Y *= -1;
00262   Z *= -1;
00263   T *= -1;
00264 }

void Vector4D::Normalize (    ) 
 

Definition at line 158 of file Vector4D.cc.

00158                          {
00159   double Mag = Magnitude();
00160 
00161   if ( Mag != 0 ) {
00162     X /= Mag;
00163     Y /= Mag;
00164     Z /= Mag;
00165     T /= Mag;
00166   }
00167 }

void Vector4D::Set (  const double    x,
const double    y,
const double    z,
const double    t
)  [inline]
 

Definition at line 266 of file Vector4D.cc.

00267                                                             {
00268   X = x;
00269   Y = y;
00270   Z = z;
00271   T = t;
00272 }

void Vector4D::Square (    )  [inline]
 

Definition at line 274 of file Vector4D.cc.

00274                              {
00275   X *= X;
00276   Y *= Y;
00277   Z *= Z;
00278   T *= T;
00279 }

double Vector4D::T (  const double    t ) 
 

double Vector4D::T (    )  const
 

Referenced by Dot(), HalfBetween(), operator *(), operator *=(), operator+(), operator+=(), operator-(), operator-=(), operator/(), operator/=(), operator=(), vecCross(), and vecHalfBetween().

void Vector4D::ToRadians (    ) 
 

Definition at line 169 of file Vector4D.cc.

00170 {
00171   if (abs(X) > 360.0)
00172     X = mod(X, 360.0);
00173 
00174   if (abs(Y) > 360.0)
00175     Y = mod(Y, 360.0);
00176 
00177   if (abs(Z) > 360.0)
00178     Z = mod(Z, 360.0);
00179 
00180   if (abs(T) > 360.0)
00181     T = mod(T, 360.0);
00182 
00183   X *= MATH_PI / 180.0;
00184   Y *= MATH_PI / 180.0;
00185   Z *= MATH_PI / 180.0;
00186   T *= MATH_PI / 180.0;
00187 }

double Vector4D::X (  const double    x ) 
 

double Vector4D::X (    )  const
 

Referenced by Cross(), Dot(), HalfBetween(), operator *(), operator *=(), operator+(), operator+=(), operator-(), operator-=(), operator/(), operator/=(), operator=(), vecCross(), vecHalfBetween(), and vecMix().

double Vector4D::Y (  const double    y ) 
 

double Vector4D::Y (    )  const
 

Referenced by Cross(), Dot(), HalfBetween(), Mix(), operator *(), operator *=(), operator+(), operator+=(), operator-(), operator-=(), operator/(), operator/=(), operator=(), vecCross(), vecHalfBetween(), and vecMix().

double Vector4D::Z (  const double    z ) 
 

double Vector4D::Z (    )  const
 

Referenced by Cross(), Dot(), HalfBetween(), Mix(), operator *(), operator *=(), operator+(), operator+=(), operator-(), operator-=(), operator/(), operator/=(), operator=(), vecCross(), vecHalfBetween(), and vecMix().

BOOL Vector4D::bAtOrg (    )  const [inline]
 

Definition at line 127 of file Vector4D.cc.

00127                                    {
00128   return ( (X == 0.0) && (Y == 0.0) && (Z == 0.0) && (T == 0.0) );
00129 }

BOOL Vector4D::bWithinLimits (  const double    r )  const
 

Definition at line 131 of file Vector4D.cc.

00131                                                    {
00132   return !( (X >  r) || (Y >  r) || (Z >  r) || (T >  r)
00133          || (X < -r) || (Y < -r) || (Z < -r) || (T < -r) );
00134 }

void Vector4D::operator *= (  const double    r ) 
 

Definition at line 105 of file Vector4D.cc.

00105                                           {
00106   X *= r;
00107   Y *= r;
00108   Z *= r;
00109   T *= r;
00110 }

void Vector4D::operator *= (  const Vector4D &    v ) 
 

Definition at line 77 of file Vector4D.cc.

00077                                              {
00078   X *= v.X;
00079   Y *= v.Y;
00080   Z *= v.Z;
00081   T *= v.T;
00082 }

BOOL Vector4D::operator!= (  const Vector4D &    v )  const [inline]
 

Definition at line 27 of file Vector4D.cc.

00027                                                           {
00028   return !Compare( v );
00029 }

void Vector4D::operator+= (  const double    r ) 
 

Definition at line 91 of file Vector4D.cc.

00091                                           {
00092   X += r;
00093   Y += r;
00094   Z += r;
00095   T += r;
00096 }

void Vector4D::operator+= (  const Vector4D &    v ) 
 

Definition at line 63 of file Vector4D.cc.

00063                                              {
00064   X += v.X;
00065   Y += v.Y;
00066   Z += v.Z;
00067   T += v.T;
00068 }

void Vector4D::operator-= (  const double    r ) 
 

Definition at line 98 of file Vector4D.cc.

00098                                           {
00099   X -= r;
00100   Y -= r;
00101   Z -= r;
00102   T -= r;
00103 }

void Vector4D::operator-= (  const Vector4D &    v ) 
 

Definition at line 70 of file Vector4D.cc.

00070                                              {
00071   X -= v.X;
00072   Y -= v.Y;
00073   Z -= v.Z;
00074   T -= v.T;
00075 }

void Vector4D::operator/= (  const double    r ) 
 

Definition at line 112 of file Vector4D.cc.

00112                                           {
00113   if ( r == 0 ) return;
00114   X /= r;
00115   Y /= r;
00116   Z /= r;
00117   T /= r;
00118 }

void Vector4D::operator/= (  const Vector4D &    v ) 
 

Definition at line 84 of file Vector4D.cc.

00084                                              {
00085   X /= v.X;
00086   Y /= v.Y;
00087   Z /= v.Z;
00088   T /= v.T;
00089 }

Vector4D & Vector4D::operator= (  const Vector4D &    v )  [inline]
 

Definition at line 196 of file Vector4D.cc.

00196                                                         {
00197   X = v.X;
00198   Y = v.Y:
00199   Z = v.Z;
00200   T = v.T;
00201   return *this;
00202 }

BOOL Vector4D::operator== (  const Vector4D &    v )  const [inline]
 

Definition at line 23 of file Vector4D.cc.

00023                                                           {
00024   return Compare( v );
00025 }

Friends And Related Function Documentation

friend class Matrix4by4 [friend]
 

Definition at line 78 of file Vector4D.hh.

Vector4D operator * (  const Vector4D &    v,
const double    r
)  [friend]
 

Definition at line 55 of file Vector4D.cc.

00055                                                         {
00056   return Vector4D( v.X * r, v.Y * r, v.Z * r, v.T * r );
00057 }

Vector4D operator * (  const Vector4D &    v1,
const Vector4D &    v2
)  [friend]
 

Definition at line 39 of file Vector4D.cc.

00039                                                              {
00040   return Vector4D( v1.X * v2.X, v1.Y * v2.Y, v1.Z * v2.Z, v1.T * v2.T );
00041 }

Vector4D operator+ (  const Vector4D &    v,
const double    r
)  [friend]
 

Definition at line 47 of file Vector4D.cc.

00047                                                         {
00048   return Vector4D( v.X + r, v.Y + r, v.Z + r, v.T + r );
00049 }

Vector4D operator+ (  const Vector4D &    v1,
const Vector4D &    v2
)  [friend]
 

Definition at line 31 of file Vector4D.cc.

00031                                                              {
00032   return Vector4D( v1.X + v2.X, v1.Y + v2.Y, v1.Z + v2.Z, v1.T + v2.T );
00033 }

Vector4D operator- (  const Vector4D &    v,
const double    r
)  [friend]
 

Definition at line 51 of file Vector4D.cc.

00051                                                         {
00052   return Vector4D( v.X - r, v.Y - r, v.Z - r, v.T - r );
00053 }

Vector4D operator- (  const Vector4D &    v1,
const Vector4D &    v2
)  [friend]
 

Definition at line 35 of file Vector4D.cc.

00035                                                              {
00036   return Vector4D( v1.X - v2.X, v1.Y - v2.Y, v1.Z - v2.Z, v1.T - v2.T );
00037 }

Vector4D operator/ (  const Vector4D &    v,
const double    r
)  [friend]
 

Definition at line 59 of file Vector4D.cc.

00059                                                         {
00060   return Vector4D( v.X / r, v.Y / r, v.Z / r, v.T / r );
00061 }

Vector4D operator/ (  const Vector4D &    v1,
const Vector4D &    v2
)  [friend]
 

Definition at line 43 of file Vector4D.cc.

00043                                                              {
00044   return Vector4D( v1.X / v2.X, v1.Y / v2.Y, v1.Z / v2.Z, v1.T / v2.T );
00045 }

Vector4D vecCross (  const Vector4D &    v1,
const Vector4D &    v2
)  [friend]
 

Definition at line 299 of file Vector4D.cc.

00299                                                             {
00300   return Vector4D( (v1.Y * v2.Z) - (v1.Z * v2.Y),
00301                    (v1.Z * v2.X) - (v1.X * v2.Z),
00302                    (v1.X * v2.Y) - (v1.Y * v2.X), v1.T );
00303 }

Vector4D vecHalfBetween (  const Vector4D &    v1,
const Vector4D &    v2
)  [friend]
 

Definition at line 281 of file Vector4D.cc.

00281                                                                          {
00282   return Vector4D(  0.5 * (v1.X + v2.X),
00283                     0.5 * (v1.Y + v2.Y),
00284                     0.5 * (v1.Z + v2.Z)
00285                     0.5 * (v1.T + v2.T)
00286   );
00287 }

Vector4D vecMix (  const Vector4D &    v1,
const Vector4D &    v2
)  [friend]
 

Definition at line 305 of file Vector4D.cc.

00305                                                                  {
00306   return Vector4D(  v1.X * v2.Y, v1.X * v2.Z, v1.Y * v2.Z );
00307 }

Member Data Documentation

double Vector4D::T [inline, private]
 

Definition at line 250 of file Vector4D.cc.

00250                                           {
00251   T = t;
00252   return T;
00253 }

double Vector4D::X [inline, private]
 

Definition at line 223 of file Vector4D.cc.

00223                                           {
00224   X = x;
00225   return X;
00226 }

double Vector4D::Y [inline, private]
 

Definition at line 232 of file Vector4D.cc.

00232                                           {
00233   Y = y;
00234   return Y;
00235 }

double Vector4D::Z [inline, private]
 

Definition at line 241 of file Vector4D.cc.

00241                                           {
00242   Z = z;
00243   return Z;
00244 }

The documentation for this class was generated from the following files:
Generated on Sun Oct 14 18:50:29 2001 for Standard J2K Library by doxygen1.2.11.1 written by Dimitri van Heesch, © 1997-2001