math/Vector4.cpp

Go to the documentation of this file.

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

#include "Vector4.h"

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

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

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

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

Vector4& Vector4::operator -= (const Vector4& right)
{
        Vector4 tempResult = *this - right;                     //IMPROVE: this is not efficient
        *this = tempResult;             
        return *this;
}


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

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

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

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

double Vector4::Dot (const Vector4& right) const
{
        double returnMe = 0 ;
        for( int i = 0; i < 3; i++ )
        {
                returnMe += elements[ i ] * right[ i ] ;
        }
        return returnMe ;
}

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

        Vector4 returnMe ;
        returnMe[ 0 ] = ay * bz - az * by ;
        returnMe[ 1 ] = az * bx - ax * bz ;
        returnMe[ 2 ] = ax * by - ay * bx ;
        return returnMe ;
}

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

double Vector4::ProjectionMag (const Vector4& right) const
{
        const Vector4& a = *this ;
        const Vector4& 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 Vector4::Reflect( const Vector4& normal )
{
        Vector4 projection = this->Projection( normal );
        *this -= ( projection * 2 ) ;
}

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

//=============================================================================
// Compare
//
// Description: Compares if two vectors are equal to within a given Tolerance.
//=============================================================================
bool Vector4::Compare( const Vector4& 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 Vector4::Normalize ()
{
        *this = *this * ( 1.0 / Magnitude() );
}

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

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

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

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

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

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

        if (delimiter != ']')
        {
                //this is to get rid of the extra homogenous coordinate
                double temp;
                is >> temp;
                delimiter = is.get();
                assert(delimiter == ']') ;
        }
        return is ;
};
//-----------------------------------------------------------------------------

---