math/VectorN.cpp

Go to the documentation of this file.

#include <iostream>
#include "../additional/streams/mystreams.h"
#include <assert.h>
#include <math.h>
//## end module%36FDB2BC02C6.includes

// VectorN
#include "VectorN.h"
//## begin module%36FDB2BC02C6.additionalDeclarations preserve=yes
//## end module%36FDB2BC02C6.additionalDeclarations


// Class VectorN 

VectorN::VectorN ()
{
}

VectorN::VectorN (const VectorN& right)
{
        elements.erase( elements.begin(), elements.end() );
    int size = right.elements.size();
    elements.reserve( size );
        for( int i = 0; i < size; ++i )         //IAN IMPROVE: this for loop looks expensive
        {
                elements.push_back( right.elements[ i ] );
        }
}

//=============================================================================
// Constructor
//
// Description: construct a scalar (what a waste)
//=============================================================================
VectorN::VectorN( const double a )
{
        SetLength( 1 );
        (*this)[ 0 ] = a;
}


//=============================================================================
// Constructor
//
// Description: construct a pair
//=============================================================================
VectorN::VectorN( const double a, const double b )
{
        SetLength( 2 );
        (*this)[ 0 ] = a;
        (*this)[ 1 ] = b;
}

//=============================================================================
// Constructor
//
// Description: construct a triple
//=============================================================================
VectorN::VectorN( const double a, const double b, const double c )
{
    SetLength( 3 );
    operator[]( 0 ) = a;
    operator[]( 1 ) = b;
    operator[]( 2 ) = c;
}

//=============================================================================
// Constructor
//
// Description: construct a quad
//=============================================================================
VectorN::VectorN( const double a, const double b, const double c, const double d )
{
        SetLength( 4 );
        (*this)[ 0 ] = a;
        (*this)[ 1 ] = b;
        (*this)[ 2 ] = c;
        (*this)[ 3 ] = d;
}


VectorN::~VectorN()
{
        elements.clear() ;              //IMPROVE: is this absolutely needed?
}



//## Other Operations (implementation)
void VectorN::SetLength (const int length)
{
        if( elements.size() < length )
        {
                //boost the size of the array up
                elements.resize( length ) ;
        }
        else if( elements.size() > length )
        {
                //reduce the size of the array
                std::vector< double >::iterator it = elements.begin() ;
                for( int i = 0 ; i < length ; i++ )
                {
                        it++ ;
                }
                elements.erase( it, elements.end() ) ;
        }
}

double& VectorN::operator [] (const unsigned int index)
{
  //## begin VectorN::operator[]%922595693.body preserve=yes
        int size = elements.size() ;
        assert( elements.size() > index ) ;
        return elements[ index ] ;
  //## end VectorN::operator[]%922595693.body
}

VectorN VectorN::operator + (const VectorN& right) const
{
  //## begin VectorN::operator+%922595695.body preserve=yes
        VectorN returnMe = right ;
        for( int i = 0; i < elements.size(); i++ )
        {
                returnMe[ i ] += elements[ i ] ;
        }
        return returnMe ;
  //## end VectorN::operator+%922595695.body
}

VectorN VectorN::operator - (const VectorN& right) const
{
#ifdef _DEBUG
    int length = Length();
    int rightLength = right.Length();
    IJG_Assert( length == rightLength );
#endif
        VectorN returnMe = *this ;
        for( int i = 0; i < elements.size(); i++ )
        {
                returnMe[ i ] -= right[ i ] ;
        }
        return returnMe ;
}

VectorN VectorN::operator * (const double right) const
{
  //## begin VectorN::operator*%922595698.body preserve=yes
        VectorN returnMe = *this ;
        for( int i = 0; i < elements.size(); i++ )
        {
                returnMe[ i ] *= right ;
        }
        return returnMe ;
  //## end VectorN::operator*%922595698.body
}

VectorN& VectorN::operator *= (const double right)
{
        int i;
        int size = this->elements.size();
        for( i = 0; i < size; i++ )
        {
                elements[ i ] *= right;
        }
        return *this;
}

VectorN& VectorN::operator += (const VectorN& right)
{
        for( int i = 0; i < elements.size(); ++i )
        {
                elements[ i ] += right[ i ] ;
        }
        return *this ;
}

VectorN& VectorN::operator -= (const VectorN& right)
{
        for( int i = 0; i < elements.size(); ++i )
        {
                elements[ i ] -= right[ i ] ;
        }
        return *this ;
}

VectorN& VectorN::operator = (const VectorN& right)
{
  //## begin VectorN::operator=%923255753.body preserve=yes
        std::vector< double>::iterator b = elements.begin() ;
        std::vector< double>::iterator e = elements.end() ;


        if( this == &right )
        {
                return *this ;
        }
        elements.clear() ;
    unsigned int length = right.Length();
        for( int i = 0; i < length; i++ )
        {
                elements.push_back( right.elements[ i ] ) ;
        }
        return *this ;
  //## end VectorN::operator=%923255753.body
}

//=============================================================================
// Append
//
// Description: appends one vector to another one
//=============================================================================
void VectorN::Append( const VectorN& right )
{
        elements.insert( elements.end(), right.elements.begin(), right.elements.end() );
}

//=============================================================================
// Compare
//
// Description: Compares if two vectors are equal to within a given Tolerance.
//=============================================================================
bool VectorN::Compare( const VectorN& right, const double& tol) const
{
        //test that the lengths are the same
        if( Length() != right.Length() )
        {
                return false ;
        }

        //test that the elements are the same
        for( int i = 0; i < elements.size(); 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 ;
}

//=============================================================================
// VectorN::Dot
//
// Description: Dot product of two n dimentional vectors
//=============================================================================
double VectorN::Dot( const VectorN& right ) const
{
    double returnMe = 0;
    int i;
    int size = elements.size();
    for( i = 0; i < size; ++i )
    {
        returnMe += elements[ i ] * right.elements[ i ];
    }
    return returnMe;
}

//=============================================================================
// VectorN::Length
//
// Description: returns the length of the vector
//=============================================================================
unsigned int VectorN::Length () const
{
        return elements.size();
}

void VectorN::Output () const
{
  //## begin VectorN::Output%923255764.body preserve=yes
        for( int i = 0; i < Length() - 1; i++ )
        {
                std::cout << operator[]( i ) << "," ;
        }
        std::cout << operator[]( Length() - 1 ) ;       //IMPROVE: do we want this function?
  //## end VectorN::Output%923255764.body
}

bool VectorN::operator == (const VectorN& right) const
{
  //## begin VectorN::operator==%930083381.body preserve=yes

        //test that the lengths are the same
        if( Length() != right.Length() )
        {
                return false ;
        }

        //test that the elements are the same
        for( int i = 0; i < elements.size(); i++ )
        {
                if( elements[ i ] != right[ i ] )
                {
                        return false ;
                }
        }
        return true ;
  //## end VectorN::operator==%930083381.body
}

bool VectorN::operator != (const VectorN& right) const
{
  //## begin VectorN::operator!=%930083382.body preserve=yes
        return ! (*this == right ) ;
  //## end VectorN::operator!=%930083382.body
}

VectorN VectorN::operator / (const double right) const
{
  //## begin VectorN::operator/%930364107.body preserve=yes
        VectorN returnMe = *this ;
        for( int i = 0; i < elements.size(); i++ )
        {
                returnMe[ i ] /= right ;
        }
        return returnMe ;

  //## end VectorN::operator/%930364107.body
}

VectorN& VectorN::operator /= ( const double right)
{
    for( int i = 0; i < elements.size(); ++i )
    {
        elements[ i ] /= right;
    }
    return *this;
}

double VectorN::MagSquared () const
{
  //## begin VectorN::MagSquared%965514807.body preserve=yes
        int i;
        double runningCount = 0;
        for( i = 0; i < this->Length(); i++ )
        {
                double element = this->elements[ i ];
                runningCount += element * element;
        }
        return runningCount;
  //## end VectorN::MagSquared%965514807.body
}

double VectorN::Magnitude () const
{
  //## begin VectorN::Magnitude%965675401.body preserve=yes
        return sqrt( this->MagSquared() );
  //## end VectorN::Magnitude%965675401.body
}

//=============================================================================
// VectorN::Normalize
//
// Description: makes the length of the vector unity
//=============================================================================
void VectorN::Normalize()
{
    double magnitude = Magnitude();
    operator/=( Magnitude() );
}

//=============================================================================
// VectorN::clear
//
// Description: just like a std container
//=============================================================================
void VectorN::clear()
{
    elements.erase( elements.begin(), elements.end() );
}

//=============================================================================
// VectorN::push_back
//
// Description: just like a std container
//=============================================================================
void VectorN::push_back( const double newElement )
{
    elements.push_back( newElement );
}

//=============================================================================
// VectorN::reserve
//
// Description: just like a std container
//=============================================================================
void VectorN::reserve( const unsigned int size )
{
    elements.reserve( size );
}

//=============================================================================
// VectorN::resize
//
// Description: just like a std container
//=============================================================================
void VectorN::resize( const unsigned int size, const double fill )
{
    elements.resize( size, fill );
}

VectorN operator*( const double f, const VectorN& v )
{
    return v * f;
}

// Additional Declarations
  //## begin VectorN%36FDB2BC02C6.declarations preserve=yes
//-----------------------------------------------------------------------------
std::ostream & operator<<( std::ostream &os, const VectorN& v )
//file format looks like this
//[0.01,1203,2309]
{
        os << "[" ;
        for( int i = 0 ; i < v.Length(); i++ )
        {
                os << v[ i ] ;
                if( i != v.Length() - 1 )
                {
                        os << "," ;
                }
        }
        os      << "]" ;
        return os ;
}
//-----------------------------------------------------------------------------
std::istream & operator>>( std::istream &is, VectorN& v )
{
        //check inputs
        assert( is.good() ) ;

        //set the length of v to 0
        v.SetLength( 0 ) ;

        eatwhite( is ) ;

        //read in numbers seperated by commas until we hit the ']'
        while( ( is.peek() != ']' ) && ( is.peek() != EOF ) )
        {
                //remove the first character from the string
                char delimitingCharacter = 0 ;
                is >> delimitingCharacter ;

                //read in the number from the string
                double number ;
                is >> number ;

                //add the number to the vector
                int currentLength = v.Length() ;
                v.SetLength( currentLength + 1 ) ;
                v[ currentLength ] = number ;
                eatwhite( is ) ;
                //read the next character from the file
        }

        //eat the last ']' 
        if( is.peek() == ']' )
        {
                is.get() ;
        }
        else
        {
                //IMPROVE: should throw an exception or something?
        }
        return is ;
}
//-----------------------------------------------------------------------------
double  Average( const VectorN& v )
{
    int size = v.Size();
    int i;
    double total = 0.0;
    for( i = 0; i < size; ++i )
    {
        total += v[ i ];
    }
    total /= size;
    return total;
}
//-----------------------------------------------------------------------------
double DistanceSquared( const VectorN& c0, const VectorN& c1, const VectorN& p)
{
    VectorN segmentDirection = c1 - c0;
    VectorN pointDirection = p - c0;
    double dot = segmentDirection.Dot( pointDirection );
    if( dot <= 0.0 )
    {
        //
        // Point is behind the origin
        //
        double returnMe = pointDirection.MagSquared();
        return returnMe;
    }

    double segmentLengthSqr = segmentDirection.MagSquared();
    if( dot >= segmentLengthSqr )
    {
        //
        // Point is behind the other target
        //
        pointDirection -= segmentDirection;
        double returnMe = pointDirection.MagSquared();
        return returnMe;
    }
    else
    {
        //
        // Point is closest to somewhere in the middle of the line
        //
        dot /= segmentLengthSqr;
        pointDirection -= segmentDirection * dot;
        double returnMe = pointDirection.MagSquared();
        return returnMe;
    }
}

VectorN ClosestPoint( const VectorN& c0, const VectorN& c1, const VectorN& p)
{
    VectorN segmentDirection = c1 - c0;
    VectorN pointDirection = p - c0;
    double dot = segmentDirection.Dot( pointDirection );
    if( dot <= 0.0 )
    {
        //
        // Point is behind the origin
        //
        return c0;
    }

    double segmentLengthSqr = segmentDirection.MagSquared();
    if( dot >= segmentLengthSqr )
    {
        //
        // Point is behind the other target
        //
        return c1;
    }
    else
    {
        //
        // Point is closest to somewhere in the middle of the line
        //
        dot /= segmentLengthSqr;
        VectorN returnMe = c0 + segmentDirection * dot;
        return returnMe;
    }
}
//-----------------------------------------------------------------------------
VectorN Ln( const VectorN& right )
{
    VectorN returnMe = right;
    int size = returnMe.Size();
    int i;
    for( i = 0; i < size; ++i )
    {
        returnMe[ i ] = log( returnMe[ i ] );
    }
    return returnMe;
}
//-----------------------------------------------------------------------------

---