math/Vector4.h

Go to the documentation of this file.

#ifndef Vector4_h
#define Vector4_h 1

#include <assert.h>
#include <iostream>
#include "math2.h"


class Vector4 
{

  public:
    //## Constructors (specified)
      //## Operation: Vector4%922649209
      Vector4 ();

      //## Operation: Vector4%922649210
      Vector4 (const Vector4& right);

      //## Operation: Vector4%925235856
      Vector4 (const double  x, const double  y, const double  z);

    //## Destructor (generated)
      ~Vector4();


    //## Other Operations (specified)
      //## Operation: operator[]%922649204
      double& operator [] (const unsigned int index);

      //## Operation: operator+%922649205
      Vector4 operator + (const Vector4& right) const;

      //## Operation: operator-%922649206
      Vector4 operator - (const Vector4& right) const;

      Vector4& operator -= (const Vector4& right);

      //## Operation: operator*%922649207
      Vector4 operator * (const double right) const;

      //## Operation: operator*%922649207
      Vector4 operator / (const double right) const;

      //## Operation: operator[]%922649208
      const double operator [] (const unsigned int index) const;

      //## Operation: Magnitude%925235851
      //        returns the length of the vector
      double Magnitude () const;

      //## Operation: MagSquared%925235852
      //        this returns the square of the magnitude of the vector
      double MagSquared () const;

      //## Operation: Dot%926709626
      double Dot (const Vector4& right) const;

      //## Operation: Cross%926806998
      Vector4 Cross (const Vector4& right) const;

      //## Operation: Projection%926806999
      Vector4 Projection (const Vector4& right) const;

      //## Operation: ProjectionMag%926807000
      double ProjectionMag (const Vector4& right) const;

          //reflects this vector about a normal
          void Reflect( const Vector4& normal );

      //## Operation: operator==%926807001
      bool operator == (const Vector4& right) const;

          bool operator< ( const Vector4& right ) const; 

      //## Operation: Normalize%927307381
      void Normalize ();

          // Compares if two vectors are equal to within a given Tolerance.
          bool Compare( const Vector4& right, const double& tol) const;


    // Additional Public Declarations
      //## begin Vector4%36FEE75503CA.public preserve=yes
          bool operator !=( const Vector4& right ) const;
          Vector4& operator +=( const Vector4& right );
          Vector4& operator *=( const double right );
      Vector4& operator /=( const double right );
          Vector4 operator -() const;
      //## end Vector4%36FEE75503CA.public

  protected:
      double elements[ 3 ];

  private:

  private: //## implementation

};

//std::ostream & operator<<( std::ostream &os, const Vector4& v );

inline double& Vector4::operator [] (const unsigned int index)
{
    IJG_Assert( index < 3 );
    IJG_Assert( index >= 0 );
        return elements[ index ];
}

inline const double Vector4::operator [] (const unsigned int index) const
{
    IJG_Assert( index < 3 );
    IJG_Assert( index >= 0 );
        return elements[ index ];
}

//=============================================================================
// operator +=
//
// Description: in place addition operator
//=============================================================================
inline Vector4& Vector4::operator +=( const Vector4& right )
{
        elements[ 0 ] += right.elements[ 0 ];
        elements[ 1 ] += right.elements[ 1 ];
        elements[ 2 ] += right.elements[ 2 ];
        return *this;
}

//=============================================================================
// Constructor
//
// Description: copies x,y,z into the vector
//=============================================================================
inline Vector4::Vector4 (const double  x, const double  y, const double  z)
{
        elements[ 0 ] = x ;
        elements[ 1 ] = y ;
        elements[ 2 ] = z ;
}

//=============================================================================
// Destructor
//
// Description: does nothign
//=============================================================================
inline Vector4::~Vector4()
{
}


std::ostream & operator<<( std::ostream &os, const Vector4& v ) ;
std::istream & operator>>( std::istream &is, Vector4& v ) ;

//=============================================================================
// Verify
//
// Description: verifies that the vector is within valid ranges
//=============================================================================
#ifdef _DEBUG
inline void Verify( const Vector4& v )
{
        assert( Between( v[ 0 ], -10000.0, 10000.0 ) ); //+-10000 is rather arbitrary
        assert( Between( v[ 1 ], -10000.0, 10000.0 ) ); //+-10000 is rather arbitrary
        assert( Between( v[ 2 ], -10000.0, 10000.0 ) ); //+-10000 is rather arbitrary
}
#else
inline void Verify( const Vector4& v )
{
        //nothing
}
#endif

#endif

---