math/Vector2.h

Go to the documentation of this file.

#ifndef Vector2_h
#define Vector2_h 1

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


class Vector2 
{

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

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

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

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


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

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

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

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

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

      //## Operation: operator*%922649207
      Vector2 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 Vector2& right) const;

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

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

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

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

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

          bool operator< ( const Vector2& right ) const; 

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

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


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

  protected:
      double elements[ 2 ];

  private:

  private: //## implementation

};

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

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

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

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

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

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


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

//=============================================================================
// Verify
//
// Description: verifies that the vector is within valid ranges
//=============================================================================
#ifdef _DEBUG
inline void Verify( const Vector2& 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
}
#else
inline void Verify( const Vector2& v )
{
        //nothing
}
#endif

#endif

---