shells/utilities/VArray.h

Go to the documentation of this file.

// -*- C++ -*-
//----------------------------------------------------------------------
//
//                           Fehmi Cirak
//                California Institute of Technology
//                   (C) 2004 All Rights Reserved
//
//----------------------------------------------------------------------
//
#ifndef VArray_h
#define VArray_h

#include <functional>
#include <algorithm>
#include <numeric>
#include <iosfwd>

namespace utilities {

template <int N, typename T=double>
class VArray {
public:
    typedef T value_type;
    typedef value_type* iterator;
    typedef const value_type*  const_iterator;
    typedef unsigned size_type; 
    
protected:
    value_type _data[N];       
    
public:
    VArray(){}
    ~VArray(){}
    
    // Copy constructor
    VArray(const VArray& x) {
        std::copy(x.begin(), x.end(), _data);
    }
    
    // Specify an initializing value for the components
    explicit VArray(value_type x);
    
    // Assignment operators
    VArray& operator=(const VArray& x);
    VArray& operator=(value_type x);
    
    // accessors - iterators
    iterator begin() {return _data;}
    iterator end() {return _data+N;}

    // accessors - const_iterators
    const_iterator begin() const {return _data;}
    const_iterator end() const {return _data+N;}
    
    // size of the array
    static size_type size() {return N;}
    
    // return the i_th component
    value_type operator[](size_type i) const {
        return _data[i];
    }
    
    // return the i_th component.
    value_type&  operator[](size_type i) {
        return _data[i];
    }
    
    // operations with a scalar
    VArray& operator+=(value_type x);
    VArray& operator-=(value_type x);    
    VArray& operator*=(value_type x);
    VArray& operator/=(value_type x);
    
    // operations with a VArray
    VArray& operator+=(const VArray& x);
    VArray& operator-=(const VArray& x);
};

    
// Partial template specialization for N = 3.
    template <typename T>
    class VArray<3,T> {
    public:
        typedef T value_type;
        typedef value_type* iterator;
        typedef const value_type*  const_iterator;
        typedef unsigned  size_type; 
        
    protected:
        value_type _data[3];
    
    public:
        VArray(){}
        VArray(value_type x){
            _data[0] = x;
            _data[1] = x;
            _data[2] = x;       
        }
        
        ~VArray(){}
        
        // Copy constructor
        VArray(const VArray& x){
            _data[0] = x._data[0];
            _data[1] = x._data[1];
            _data[2] = x._data[2];
        }
        
        // constructor with three components
        explicit VArray(value_type x0, value_type x1, value_type x2) {
            _data[0] = x0;
            _data[1] = x1;
            _data[2] = x2;
        }
        
        // assignment operatos
        VArray& operator=(const VArray& x) {
            if (&x != this) {
                _data[0] = x._data[0];
                _data[1] = x._data[1];
                _data[2] = x._data[2];
            }
            return *this;
        }
        
        VArray& operator=(value_type x) {
            _data[0] = x;
            _data[1] = x;
            _data[2] = x;
            return *this;
        }
        
        // accessors iterators
        iterator begin() {return _data;}
        iterator end() {return _data + 3;}
        const_iterator begin() const {return _data;}    
        const_iterator end() const {return _data+3;}
        
        // size of the array
        static size_type size() {return 3;}
    
        // return the ith component
        value_type operator[](size_type i) const {return _data[i];}
        value_type& operator[](size_type i) {return _data[i];}
        
    
        // operations with a scalar
        VArray& operator+=(value_type x){
            _data[0] += x;
            _data[1] += x;
            _data[2] += x;
            
            return *this;
        }
        
        VArray& operator-=(value_type x){
            _data[0] -= x;
            _data[1] -= x;
            _data[2] -= x;
            return *this;
        }
        
        VArray& operator*=(value_type x){
            _data[0] *= x;
            _data[1] *= x;
            _data[2] *= x;
            return *this;
        }
        
        VArray& operator/=(value_type x){
            _data[0] /= x;
            _data[1] /= x;
            _data[2] /= x;
            return *this;
        }
        
        // operations with a VArray
        VArray& operator+=(const VArray& x){
            _data[0] += x[0];
            _data[1] += x[1];
            _data[2] += x[2];
            return *this;
        }
        
        VArray& operator-=(const VArray& x) {
            _data[0] -= x[0];
            _data[1] -= x[1];
            _data[2] -= x[2];
            return *this;
        }
        
    };


    template <int N, typename T>
    inline VArray<N,T>::VArray(value_type x) {
        std::fill(begin(), end(), x);
    }
    
    
    template <int N, typename T> 
    inline VArray<N,T>& VArray<N,T>::operator+=(value_type x) {
        
        std::transform(begin(), end(), begin(), std::bind2nd(std::plus<T>(), x));
        
        return *this;
    }
    
    
    template <int N, typename T>
    inline VArray<N,T>& VArray<N,T>::operator-=(value_type x) {
        
        std::transform(begin(), end(), begin(), std::bind2nd(std::minus<T>(), x));
        
        return *this;
    }
    
    
    template <int N, typename T>
    inline VArray<N,T>& VArray<N,T>::operator*=(value_type x){
        
        std::transform(begin(), end(), begin(), std::bind2nd(std::multiplies<T>(), x));
        
        return *this;
    }
    
    
    template <int N, typename T>
    inline VArray<N,T>& VArray<N,T>:: operator/=(value_type x) {
        
        std::transform(begin(), end(), begin(), std::bind2nd(std::divides<T>(), x));
        
        return *this;
    }
    
    
    template <int N, typename T>
    inline VArray<N,T>& VArray<N,T>::operator+=(const VArray<N,T>& x) {
        
        std::transform(begin(), end(), x.begin(), begin(), std::plus<T>());
        
        return *this;
    }
    
    
    template <int N, typename T>
    inline VArray<N,T>& VArray<N,T>::operator-=(const VArray<N, T>& x){
        
        std::transform(begin(), end(), x.begin(), begin(), std::minus<T>());
        
        return *this;
    }
    
    
    template <int N, typename T>
    inline std::ostream& operator<<( std::ostream& out, const VArray<N,T>& x) {
        typename VArray<N,T>::const_iterator begin = x.begin(), end = x.end();
        if (begin != end) {
            out << *begin;
            ++begin;
        }
        for ( ; begin != end; ++begin) {
            out << " " << *begin;
        }
        return out;
    }

} // namespace utilities

#endif

// End of file.

---