Search  

---

C:/temp/src/j2k/Beta/Math/Vector/NotDone/Vector4D.cc

Go to the documentation of this file.

#ifndef __J2K__VECTOR4D_CC__
#define __J2K__VECTOR4D_CC__

Vector4D::Vector4D()
  : 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 )
  : X( x ), Y( y ), Z( z ), T( t ) { }

Vector4D::Vector4D( const Vector4D& v )
  : X( v.X ), Y( v.Y ), Z( v.Z ), T( v.T ) { }

BOOL Vector4D::Compare( const Vector4D& v ) const {
  if (v.X != X)  return FALSE;
  if (v.Y != Y)  return FALSE;
  if (v.Z != Z)  return FALSE;
  if (v.T != T)  return FALSE;

  return TRUE;
}

inline BOOL Vector4D::operator==( const Vector4D& v ) const {
  return Compare( v );
}

inline BOOL Vector4D::operator!=( const Vector4D& v ) const {
  return !Compare( v );
}

Vector4D operator+( const Vector4D& v1, const Vector4D& v2 ) {
  return Vector4D( v1.X + v2.X, v1.Y + v2.Y, v1.Z + v2.Z, v1.T + v2.T );
}

Vector4D operator-( const Vector4D& v1, const Vector4D& v2 ) {
  return Vector4D( v1.X - v2.X, v1.Y - v2.Y, v1.Z - v2.Z, v1.T - v2.T );
}

Vector4D operator*( const Vector4D& v1, const Vector4D& v2 ) {
  return Vector4D( v1.X * v2.X, v1.Y * v2.Y, v1.Z * v2.Z, v1.T * v2.T );
}

Vector4D operator/( const Vector4D& v1, const Vector4D& v2 ) {
  return Vector4D( v1.X / v2.X, v1.Y / v2.Y, v1.Z / v2.Z, v1.T / v2.T );
}

Vector4D operator+( const Vector4D& v, const double r ) {
  return Vector4D( v.X + r, v.Y + r, v.Z + r, v.T + r );
}

Vector4D operator-( const Vector4D& v, const double r ) {
  return Vector4D( v.X - r, v.Y - r, v.Z - r, v.T - r );
}

Vector4D operator*( const Vector4D& v, const double r ) {
  return Vector4D( v.X * r, v.Y * r, v.Z * r, v.T * r );
}

Vector4D operator/( const Vector4D& v, const double r ) {
  return Vector4D( v.X / r, v.Y / r, v.Z / r, v.T / r );
}

void Vector4D::operator+=( const Vector4D& v ) {
  X += v.X;
  Y += v.Y;
  Z += v.Z;
  T += v.T;
}

void Vector4D::operator-=( const Vector4D& v ) {
  X -= v.X;
  Y -= v.Y;
  Z -= v.Z;
  T -= v.T;
}

void Vector4D::operator*=( const Vector4D& v ) {
  X *= v.X;
  Y *= v.Y;
  Z *= v.Z;
  T *= v.T;
}

void Vector4D::operator/=( const Vector4D& v ) {
  X /= v.X;
  Y /= v.Y;
  Z /= v.Z;
  T /= v.T;
}

void Vector4D::operator+=( const double r ) {
  X += r;
  Y += r;
  Z += r;
  T += r;
}

void Vector4D::operator-=( const double r ) {
  X -= r;
  Y -= r;
  Z -= r;
  T -= r;
}

void Vector4D::operator*=( const double r ) {
  X *= r;
  Y *= r;
  Z *= r;
  T *= r;
}

void Vector4D::operator/=( const double r ) {
  if ( r == 0 ) return;
  X /= r;
  Y /= r;
  Z /= r;
  T /= r;
}

inline void Vector4D::Abs() {
  X = abs(X);
  Y = abs(Y);
  Z = abs(Z);
  T = abs(T);
}

inline BOOL Vector4D::bAtOrg() const {
  return ( (X == 0.0) && (Y == 0.0) && (Z == 0.0) && (T == 0.0) );
}

BOOL Vector4D::bWithinLimits( const double r ) const {
  return !( (X >  r) || (Y >  r) || (Z >  r) || (T >  r)
         || (X < -r) || (Y < -r) || (Z < -r) || (T < -r) );
}

inline double Vector4D::Dot( const Vector4D& v ) const {
  return (X * v.X) + (Y * v.Y) + (Z * v.Z) + (T * v.T);
}

inline double Vector4D::Magnitude() const {
  return sqrt( (X * X) + (Y * Y) + (Z * Z) + (T * T) );
}

void Vector4D::ClipToDegrees() {
  if (X > 360.0) 
    X = mod(X, 360.0);

  if (Y > 360.0)
    Y = mod(Y, 360.0);

  if (Z > 360.0)
    Z = mod(Z, 360.0);

  if (T > 360.0)
    T = mod(T, 360.0);
}

void Vector4D::Normalize() {
  double Mag = Magnitude();

  if ( Mag != 0 ) {
    X /= Mag;
    Y /= Mag;
    Z /= Mag;
    T /= Mag;
  }
}

void Vector4D::ToRadians()
{
  if (abs(X) > 360.0)
    X = mod(X, 360.0);

  if (abs(Y) > 360.0)
    Y = mod(Y, 360.0);

  if (abs(Z) > 360.0)
    Z = mod(Z, 360.0);

  if (abs(T) > 360.0)
    T = mod(T, 360.0);

  X *= MATH_PI / 180.0;
  Y *= MATH_PI / 180.0;
  Z *= MATH_PI / 180.0;
  T *= MATH_PI / 180.0;
}

void Vector4D::HalfBetween( const Vector4D& v ) {
  X = 0.5 * (X + v.X);
  Y = 0.5 * (Y + v.Y);
  Z = 0.5 * (Z + v.Z);
  T = 0.5 * (T + v.T);
}

inline Vector4D& Vector4D::operator=( const Vector4D& v ) {
  X = v.X;
  Y = v.Y:
  Z = v.Z;
  T = v.T;
  return *this;
}

inline void Vector4D::AddScaled( const Vector4D& v, const double Scale ) {
  X += v.X * Scale; 
  Y += v.Y * Scale; 
  Z += v.Z * Scale;
  T += v.T * Scale; 
}

inline void Vector4D::Adjust( const double x, const double y,
                              const double z, const double t ) {
  X += x;
  Y += y;
  Z += z;
  T += t;
}

inline double Vector4D::X() const {
  return X;
}

inline double Vector4D::X( const double x ) {
  X = x;
  return X;
}

inline double Vector4D::Y() const {
  return Y;
}

inline double Vector4D::Y( const double y ) {
  Y = y;
  return Y;
}

inline double Vector4D::Z() const {
  return Z;
}

inline double Vector4D::Z( const double z ) {
  Z = z;
  return Z;
}

inline double Vector4D::T() const {
  return T;
}

inline double Vector4D::T( const double t ) {
  T = t;
  return T;
}

inline double Vector4D::MagSum() const {
  return (X + Y + Z + T);
}

inline void Vector4D::Negate() {
  X *= -1;
  Y *= -1;
  Z *= -1;
  T *= -1;
}

inline void Vector4D::Set( const double x, const double y,
                           const double z, const double t ) {
  X = x;
  Y = y;
  Z = z;
  T = t;
}

inline void Vector4D::Square() {
  X *= X;
  Y *= Y;
  Z *= Z;
  T *= T;
}

inline Vector4D vecHalfBetween( const Vector4D& v1, const Vector4D& v2 ) {
  return Vector4D(  0.5 * (v1.X + v2.X),
                    0.5 * (v1.Y + v2.Y),
                    0.5 * (v1.Z + v2.Z)
                    0.5 * (v1.T + v2.T)
  );
}

// For 4D ???  ALL THAT FOLLOW MUST BE CHANGE FOR 4D VECTOR EQUIVALENT...
void Vector4D::Cross( const Vector4D& v ) {
  const double xTmp = (Y * v.Z) - (Z * v.Y);
  const double yTmp = (Z * v.X) - (X * v.Z);
  const double zTmp = (X * v.Y) - (Y * v.X);
  X = xTmp;
  Y = yTmp;
  Z = zTmp;
}

Vector4D vecCross( const Vector4D& v1, const Vector4D& v2 ) {
  return Vector4D( (v1.Y * v2.Z) - (v1.Z * v2.Y),
                   (v1.Z * v2.X) - (v1.X * v2.Z),
                   (v1.X * v2.Y) - (v1.Y * v2.X), v1.T );
}

inline Vector4D vecMix( const Vector4D& v1, const Vector4D& v2 ) {
  return Vector4D(  v1.X * v2.Y, v1.X * v2.Z, v1.Y * v2.Z );
}

void Vector4D::Mix( const Vector4D& v ) {  // ??????
  X *= v.Y;
  X *= v.Z;
  Y *= v.Z;
}

// ---------------------------------------------------------------------------
//  Typedef the vector to T4DPoint so that it can be more self documenting
//  when used as a point in a 4D floating point space.
// ---------------------------------------------------------------------------
typedef Vector4D   T4DPoint;

#endif

---