vector.h

Go to the documentation of this file.

/***********************************************************************/
#ifndef vector_H
#define vector_H
 
#ifndef assert
#define assert(x)
#endif
 
#include "embedded_math.h"
 
template <class datatype, int size> class matrix;
template <class datatype> class quaternion;
 
template <class datatype, int size>
class vector
{
    friend class matrix<datatype, size>;
    friend class quaternion<datatype>;
public:
 
    vector( void)
    {
        for( int i=0; i < size; ++i)
          e[i]=ZERO;
    }
    vector( const datatype *data);
    vector( const vector & right);
 
    datatype scalar_multiply( const vector & right) const 
    {
        datatype retval = 0;
        for( int i=0; i < size; ++i)
          retval += right.e[i] * e[i];
        return retval;
    }
 
    datatype operator * ( const vector & right) const 
    {
      return scalar_multiply( right);
    }
 
    vector vector_multiply( const vector & right) const 
    {
        assert( size == 3); // operation not defined for vectors of other size
        vector <datatype, size> tmp;
        tmp.e[0]=e[1]*right.e[2]-e[2]*right.e[1];
        tmp.e[1]=e[2]*right.e[0]-e[0]*right.e[2];
        tmp.e[2]=e[0]*right.e[1]-e[1]*right.e[0];
        return tmp;
    }
 
    datatype abs( void) const
    {
        datatype squaresum=datatype();
        for( int i=0; i< size; ++i)
            squaresum += (e[i]*e[i]);
        return (datatype) SQRT( squaresum);
    };
 
    vector & operator =  ( const vector & right);
    void zero( void)
    {
        for( int i=0; i<size; ++i)
            e[i]=0.0;
    }
    vector & negate( void)
    {
        for( int i=0; i<size; ++i)
            e[i] = -e[i];
        return *this;
    }
    vector & operator += ( const vector & right);
    vector & operator -= ( const vector & right);
 
    vector operator + ( const vector & right) const;
    vector operator - ( const vector & right) const;
    vector operator * ( const datatype & right) const 
    {
        vector result = *this;
        for( int i=0; i < size; ++i)
            result.e[i] *= right;
        return result;
    }
    vector & operator *= ( const datatype & right) 
    {
        *this = *this * right;
        return *this;
    }
    datatype & operator []( const int index)
    {
        assert( index < size);
        return e[index];
    };
    const datatype operator []( int index) const
    {
      return e[index];
    }
 
    void normalize( void)
    {
        datatype norm = abs();
        norm = ONE / norm;
        *this *= norm;
    }
 
private:
    datatype e[size];
};
 
template <class datatype, int size> vector <datatype, size>::vector( const vector <datatype, size> & right)
{
    for( int i=0; i<size; ++i)
        e[i]=right.e[i];
}
 
template <class datatype, int size> vector <datatype, size>::vector( const datatype * init)
{
    if( init==0)
        for( int i=0; i<size; ++i)
            e[i]=datatype();
    else
        for( int i=0; i<size; ++i)
            e[i]=*init++;
}
 
template <class datatype, int size> vector <datatype, size> & vector <datatype, size>::operator +=( const vector <datatype, size> & right)
{
    for( int i=0; i<size; ++i)
        e[i]+=right.e[i];
    return *this;
}
 
template <class datatype, int size> vector <datatype, size> & vector <datatype, size>::operator -=( const vector <datatype, size> & right)
{
    for( int i=0; i<size; ++i)
        e[i]-=right.e[i];
    return *this;
}
 
template <class datatype, int size> vector <datatype, size> vector <datatype, size>::operator +( const vector <datatype, size> & right) const
{
    vector <datatype, size> tmp( *this);
    tmp+=right;
    return tmp;
}
 
#if 0 // presently unused
 
template <class datatype, int size> vector <datatype, size> vector <datatype, size>::operator *( const vector <datatype, size> & right) const
{
    //  ASSERT( size == 3); // operation not defined for vectors of other size
    vector <datatype, size> tmp;
    tmp.e[0]=e[1]*right.e[2]-e[2]*right.e[1];
    tmp.e[1]=e[2]*right.e[0]-e[0]*right.e[2];
    tmp.e[2]=e[0]*right.e[1]-e[1]*right.e[0];
    return tmp;
}
 
 
template <class datatype, int size> vector <datatype, size> vector <datatype, size>::operator *( const double & right) const
{
    vector <datatype, size> tmp( *this);
    tmp*=right;
    return tmp;
}
 
template <class datatype, int size> vector <datatype, size> vector <datatype, size>::operator *=( const double & right)
{
    for( int i=0; i<size; ++i)
        e[i]*=right;
    return *this;
}
 
template <class datatype, int size> vector <datatype, size> vector <datatype, size>::operator /=( const double & right)
{
    for( int i=0; i<size; ++i)
        e[i]/=right;
    return *this;
}
#endif
 
template <class datatype, int size> vector <datatype, size> vector <datatype, size>::operator -( const vector <datatype, size> & right) const
{
    vector <datatype, size> tmp( *this);
    tmp-=right;
    return tmp;
}
 
template <class datatype, int size>
vector <datatype, size> & vector <datatype, size>::operator =( const vector <datatype, size> & right)
{
    for( int i=0; i<size; ++i)
        e[i]=right.e[i];
    return *this;
}
 
#endif