Vector.hpp

Go to the documentation of this file.

#ifndef LOPER_VECTOR
#define LOPER_VECTOR

#include <valarray>
#include <Matrix.hpp>


template< typename T >
class Vector : public std::valarray< T >
{
public:
    typedef Vector< T > OurType;
/*
 * Constructors
 */
    Vector () {}
    Vector (int numElements) { resize (numElements); }
    Vector (const std::valarray< T > & v);
    void operator=(const std::valarray< T > & v);
    
/*
 * Calculations
 */
    double getLength()                          const;
    T dotProduct (const OurType & v)            const;
    OurType crossProduct (const OurType &v2)    const;
    Matrix< T > outerProduct (const OurType &v) const;
    OurType operator* (const Matrix< T > &m)    const;

/*
 * Mutators
 */
    void setToZero();
    void print(const char *title=NULL) const;
    OurType operator-(const OurType &v) const;

/*
 * Accessors
 */
    T & operator()(int index)      { return this->operator[](index); }
    T & at (int index)             { return this->operator[](index); }
    T operator() (int index) const { return this->operator[](index); }
    T at (int index)         const { return this->operator[](index); }

    bool operator==(const OurType & v) const;
    bool operator!=(const OurType & v) const;
};


/*******************************************************************
 *                        COMMON TYPEDEF'S                         *
 *******************************************************************/

typedef Vector< float  >        FloatVec;
typedef Vector< double >        DoubleVec;
typedef Vector< int    >        IntVec;
typedef Vector< unsigned char > UbyteVec;



/*******************************************************************
 *                      METHOD DEFINITIONS                         *
 *******************************************************************/

template< typename T >
Vector< T >::Vector (const std::valarray< T > & v)
{
    *this = v;
}

template< typename T >
void Vector< T >::operator=(const std::valarray< T > & v)
{
    resize(v.size());
    for (int i = 0; i < size(); i++)
        this->at(i) = v[i];
}


template< typename T >
double Vector< T >::getLength() const 
{ 
    return sqrt (dotProduct(*this)); 
}



template< typename T >
T Vector< T >::dotProduct (const OurType & v) const
{
    if (v.size() != size())
        throw exception ("Vector::dotProduct(): size mismatch");

    OurType a = *this;
    a *= v;
    return a.sum();
}



template< typename T >
Vector< T > Vector< T >::crossProduct (const OurType &v2) const
{
    if (this->size() != 3 || v2.size() != 3)
        throw exception("Vector::crossProduct(): must have 3 elements.");

    OurType result(3);
    const OurType & v1 = *this;
    result[0] = v1[1]*v2[2] - v1[2]*v2[1];
    result[1] = v1[2]*v2[0] - v1[0]*v2[2];
    result[2] = v1[0]*v2[1] - v1[1]*v2[0];  

    return result;
}



template< typename T >
void Vector< T >::print(const char *title) const
{
    printf("\nVector %s\n", title?title:"");

    for (int i = 0; i < size(); i++)
    {
        double d = this->at(i);
        printf("%.3lf  ", d);
        Sleep(0);
    }

    printf("\n\n");
}



template< typename T >
void Vector< T >::setToZero()
{
    for (unsigned int i = 0; i < size(); i++)
        (*this)[i] = (T)0;
}



template< typename T >
bool Vector< T >::operator!=(const OurType & v) const
{
    return (!(v == *this));
}



template< typename T >
bool Vector< T >::operator==(const OurType & v) const
{
    if (size() != v.size())
        return false;
    for (int i = 0; i < size(); i++)
        if (this->at(i) != v[i])
            return false;
    return true;
}



template< typename T >
Vector< T > Vector< T >::operator-(const OurType &v) const
{
    OurType result = *this;
    result -= v;
    return result;
}



template< typename T >
Matrix< T > Vector< T >::outerProduct (const OurType &v) const
{
    Matrix< T > result(size(), size());

    for (int destRow = 0; destRow < size(); destRow++)
    {
        for (int destCol = 0; destCol < size(); destCol++)
        {
            result(destRow, destCol) = this->at(destRow) * this->at(destCol);
        }
    }

    return result;
}



template< typename T >
Vector< T > Vector< T >::operator* (const Matrix< T > &m) const
{
    Vector< T > result(m.getWidth());
    result.setToZero();

    for (int col = 0; col < m.getWidth(); col++)
    {
        for (int row = 0; row < m.getHeight(); row++)
            result(col) += this->at(row) * m(row,col);
    }

    return result;
}



#endif // LOPER_VECTOR

---