VVector.h

// -*- C++ -*-
#ifndef __VVECTOR_H__
#define __VVECTOR_H__

#include <iostream>
#include <iostream>
#include <algorithm>
#include <functional>
#include <iterator>
#include <Utilities.h>

namespace math {

template<typename T, int N> class Vec;


template<typename T, int N>
struct VVector {

    enum { size = N };
    
    typedef T                           value_type;
    typedef T*                          value_ptr;
    typedef const T*                    value_cptr;
    typedef VVector<T, N>               vec_type;
    typedef const VVector<T, N>         cvec_type;
    
    VVector() {}
    VVector(const T& val) { assign(val); }
    VVector(const VVector<T,N>& rhs) { assign(rhs); }
    /* Constructor that copies data from array of minimum size N. */
    VVector(const T* vptr) { assign(vptr); }

    //for STL compatibility
    T*        begin()       { return &data[0]; };
    const T*  begin() const { return &data[0]; };
    T*        end()         { return &data[N]; };
    const T*  end()   const { return &data[N]; };
    
    const T&  operator[](const unsigned int i) const { return data[i]; };
    T&        operator[](const unsigned int i)       { return data[i]; };
    
    // Returns the number of elements in the array.
    //static unsigned int size() { return N; }
    static unsigned int bytesize() { return sizeof(VVector<T,N>); }

    VVector<T,N>& assign(const T& val) 
        { std::fill( begin(), end(), val); return *this; }
    VVector<T,N>& assign(const T* vptr)
        { std::copy(&vptr[0], &vptr[N], begin()); return *this; }
    VVector<T,N>& assign(const VVector<T,N>& rhs)
        { std::copy(rhs.begin(), rhs.end(), begin()); return *this; }
    VVector<T,N>& operator=(const VVector<T,N>& rhs) 
        { return assign(rhs); }

    bool operator==(const VVector<T,N>& rhs) const {
        return std::equal(begin(), end(), rhs.begin());
    }
    bool operator!=(const VVector<T,N>& rhs) const {
        return !operator==(rhs);
    }
    bool allNotEqual(const VVector<T,N>& rhs) const {
        return std::equal(begin(), end(), rhs.begin(), std::not_equal_to<T>());
    }
    bool operator<(const VVector<T,N>& rhs) const {
        return std::equal(begin(), end(), rhs.begin(), std::less<T>());
    }
    bool operator<=(const VVector<T,N>& rhs) const {
        return std::equal(begin(), end(), rhs.begin(), std::less_equal<T>());
    }
    bool operator>(const VVector<T,N>& rhs) const {
        return std::equal(begin(), end(), rhs.begin(), std::greater<T>());
    }
    bool operator>=(const VVector<T,N>& rhs) const {
        return std::equal(begin(), end(), rhs.begin(),std::greater_equal<T>());
    }
    VVector<T,N>& operator+=(const VVector<T,N>& rhs) { 
        std::transform(begin(), end(), rhs.begin(), begin(), std::plus<T>());
        return *this;
    }
    VVector<T,N>& operator-=(const VVector<T,N>& rhs) { 
        std::transform(begin(), end(), rhs.begin(), begin(), std::minus<T>());
        return *this;
    }
    VVector<T,N>& operator*=(const VVector<T,N>& rhs) { 
        std::transform(begin(), end(), rhs.begin(), begin(), 
                       std::multiplies<T>());
        return *this;
    }
    VVector<T,N>& operator/=(const VVector<T,N>& rhs) { 
        std::transform(begin(), end(), rhs.begin(), begin(), 
                       std::divides<T>());
        return *this;
    }
    VVector<T,N> operator+(const VVector<T,N>& rhs) const {
        VVector<T,N> res; 
        transform(begin(), end(), rhs.begin(), res.begin(), std::plus<T>());
        return res;
    }
    VVector<T,N> operator-(const VVector<T,N>& rhs) const {
        VVector<T,N> res; 
        transform(begin(), end(), rhs.begin(), res.begin(), std::minus<T>());
        return res;
    }
    VVector<T,N> operator*(const VVector<T,N>& rhs) const {
        VVector<T,N> res; 
        transform(begin(), end(), rhs.begin(), res.begin(), 
                  std::multiplies<T>());
        return res;
    }
    VVector<T,N> operator/(const VVector<T,N>& rhs) const {
        VVector<T,N> res; 
        transform(begin(), end(), rhs.begin(), res.begin(), std::divides<T>());
        return res;
    }
    VVector<T,N> operator+(const T& val) const {
        VVector<T,N> res; 
        transform(begin(), end(), res.begin(), std::bind2nd(std::plus<T>(), val));
        return res;
    }
    VVector<T,N> operator-(const T& val) const {
        VVector<T,N> res; 
        transform(begin(), end(), res.begin(), std::bind2nd(std::minus<T>(),val));
        return res;
    }
    VVector<T,N> operator*(const T& val) const {
        VVector<T,N> res; 
        transform(begin(), end(), res.begin(), std::bind2nd(std::multiplies<T>(),val));
        return res;
    }
    VVector<T,N> operator/(const T& val) const {
        VVector<T,N> res; 
        transform(begin(), end(), res.begin(), std::bind2nd(std::divides<T>(),val));
        return res;
    }
    VVector<T,N> operator+=(const T& val) {
        transform(begin(), end(), this->begin(), std::bind2nd(std::plus<T>(), val));
        return *this;
    }
    VVector<T,N> operator-=(const T& val) {
        transform(begin(), end(), this->begin(), std::bind2nd(std::minus<T>(),val));
        return *this;
    }
    VVector<T,N> operator*=(const T& val) {
        transform(begin(), end(), this->begin(), std::bind2nd(std::multiplies<T>(),val));
        return *this;
    }
    VVector<T,N> operator/=(const T& val) {
        transform(begin(), end(), this->begin(), std::bind2nd(std::divides<T>(),val));
        return *this;
    }

    T data[N];
};

template<typename T, int N>
std::ostream& operator<<(std::ostream& os, const VVector<T,N>& rhs) {
    std::copy(rhs.begin(), rhs.end(), std::ostream_iterator<T>(os," "));
    return os;
}

template<typename T, int N>
std::istream& operator>>(std::istream& is, VVector<T,N>& rhs) {
    std::copy(std::istream_iterator<T>(is), std::istream_iterator<T>(), 
              rhs.begin());
    return is;
}

template class VVector<float,2>;
template class VVector<float,3>;
template class VVector<float,4>;
template class VVector<double,2>;
template class VVector<double,3>;
template class VVector<double,4>;
template class VVector<int,2>;
template class VVector<int,3>;
template class VVector<int,4>;

typedef VVector<float,2> Vector2f;
typedef VVector<float,3> Vector3f;
typedef VVector<float,4> Vector4f;
typedef VVector<double,2> Vector2d;
typedef VVector<double,3> Vector3d;
typedef VVector<double,4> Vector4d;
typedef VVector<int,2> Vector2i;
typedef VVector<int,3> Vector3i;
typedef VVector<int,4> Vector4i;

} // end of namespace math

#endif

---