math/Vector2.cpp

Go to the documentation of this file.

#include "../additional/streams/mystreams.h"
#include <assert.h>
#include <math.h>

#include "Vector2.h"

Vector2::Vector2 ()
{
        elements[ 0 ] = 0.0;
        elements[ 1 ] = 0.0;
}

Vector2::Vector2 (const Vector2& right)
{
        elements[ 0 ] = right.elements[ 0 ];
        elements[ 1 ] = right.elements[ 1 ];
}

Vector2 Vector2::operator + (const Vector2& right) const
{
        double x = elements[ 0 ] + right.elements[ 0 ];
        double y = elements[ 1 ] + right.elements[ 1 ];
        return Vector2( x, y );
}

Vector2 Vector2::operator - (const Vector2& right) const
{
        //Vector2 returnme ;
        double x = elements[ 0 ] - right.elements[ 0 ];
        double y = elements[ 1 ] - right.elements[ 1 ];
        return Vector2( x, y );
}

Vector2& Vector2::operator -= (const Vector2& right)
{
    elements[ 0 ] -= right[ 0 ];
    elements[ 1 ] -= right[ 1 ];
        return *this;
}


Vector2 Vector2::operator * (const double right) const
{
        double x = elements[ 0 ] * right;
        double y = elements[ 1 ] * right;
        return Vector2( x, y );
}

Vector2 Vector2::operator / (const double right) const
{
        double x = elements[ 0 ] / right;
        double y = elements[ 1 ] / right;
        return Vector2( x, y );
}

double Vector2::Magnitude () const
{
        return sqrt( elements[ 0 ] * elements[ 0 ] + elements[ 1 ] * elements[ 1 ] ) ;
}

double Vector2::MagSquared () const
{
        return elements[ 0 ] * elements[ 0 ] + elements[ 1 ] * elements[ 1 ];
}

double Vector2::Dot (const Vector2& right) const
{
        double returnMe = 0;
    returnMe += elements[ 0 ] * right[ 0 ];
    returnMe += elements[ 1 ] * right[ 1 ];
    return returnMe;
}

Vector2 Vector2::Cross (const Vector2& right) const
{
        const double& ax = elements[ 0 ] ;
        const double& ay = elements[ 1 ] ;
        const double& bx = right.elements[ 0 ] ;
        const double& by = right.elements[ 1 ] ;

        Vector2 returnMe ;
        return returnMe ;
}

Vector2 Vector2::Projection (const Vector2& right) const
{
        const Vector2& b = right ;
        return b * ProjectionMag( right ) ;
}

double Vector2::ProjectionMag (const Vector2& right) const
{
        const Vector2& a = *this ;
        const Vector2& b = right ;

        double num = a.Dot( b ) ;
        double den = b.Dot( b ) ;
        assert( den != 0 ) ;

        return ( num / den ) ;
}

//=============================================================================
// Reflect
//
// Description: Reflects this vector about a normal
//=============================================================================
void Vector2::Reflect( const Vector2& normal )
{
        Vector2 projection = this->Projection( normal );
        *this -= ( projection * 2 ) ;
}

bool Vector2::operator == (const Vector2& right) const
{
    //no homogenous coords
    if( this->elements[ 0 ] != right[ 0 ] )
    {
            return false ;
    }
    else if( this->elements[ 1 ] != right[ 1 ] )
    {
            return false ;
    }
    else
    {
            return true ;
    }
}

//=============================================================================
// Compare
//
// Description: Compares if two vectors are equal to within a given Tolerance.
//=============================================================================
bool Vector2::Compare( const Vector2& right, const double& tol) const
{
        //test that the elements are the same
        for( int i = 0; i < 4; i++ )
        {
                double diff = elements[ i ] - right[ i ];
                if( (diff > tol) || (diff < (-tol)) )
                {
                        return false ;
                }
        }

        // if still in the function, then all elements are equal to within tol.
        return true ;
}

void Vector2::Normalize ()
{
        *this = *this * ( 1.0 / Magnitude() );
}

// Additional Declarations
//-----------------------------------------------------------------------------
std::ostream & operator<<(std::ostream &os, const Vector2& v)
{
        os << "[" 
                << v[ 0 ] << " , " 
                << v[ 1 ] << " , " 
                << "]" ;
        return os ;
}
//-----------------------------------------------------------------------------
bool Vector2::operator< ( const Vector2& right ) const
{
        assert( false ) ;
        return false ;
}
//-----------------------------------------------------------------------------
bool Vector2::operator !=( const Vector2& right ) const
{
        return !( this->operator ==( right ) );
}

//=============================================================================
// operator *=
//
// Description: in place scalar multiplication operator
//=============================================================================
Vector2& Vector2::operator *=( const double right )
{
        int i; 
        for( i = 0; i < 2; i++ )
        {
                elements[ i ] *= right;
        }
        return *this;
}

//=============================================================================
// operator /=
//
// Description: in place scalar division operator
//=============================================================================
Vector2& Vector2::operator /=( const double right )
{
        int i; 
        for( i = 0; i < 2; ++i )
        {
                elements[ i ] /= right;
        }
        return *this;
}

//=============================================================================
// operator *=
//
// Description: in place scalar multiplication operator
//=============================================================================
Vector2 Vector2::operator -() const
{
        double x = -elements[ 0 ];
        double y = -elements[ 1 ];
        return Vector2( x, y );
}

//-----------------------------------------------------------------------------
std::istream & operator>>( std::istream &is, Vector2& v )
{
        eatwhite( is ) ;
        char leading = is.get() ;                       //get the leading '['
        assert( leading == '[' ) ;

        for( int i = 0; i < 2; i++ ) 
        {
                is >> v[ i ] ;
                eatwhite( is ) ;
                char delimiter = is.get() ;
                assert( ( delimiter == ',' ) || ( delimiter == ']' ) ) ;
        }

    //this is to get rid of the extra homogenous coordinate
    double temp;
    is >> temp;
    char delimiter = is.get();
        return is ;
};
//-----------------------------------------------------------------------------

---