Vector.h

Go to the documentation of this file.

// -*- c++ -*-
/*
 * Copyright (c) 2010-2012, Jim Bosch
 * All rights reserved.
 *
 * ndarray is distributed under a simple BSD-like license;
 * see the LICENSE file that should be present in the root
 * of the source distribution, or alternately available at:
 * https://github.com/ndarray/ndarray
 */
 
#ifndef NDARRAY_Vector_h_INCLUDED
#define NDARRAY_Vector_h_INCLUDED
 
 
#include <boost/type_traits/is_arithmetic.hpp>
#include <boost/iterator/reverse_iterator.hpp>
#include <boost/utility/enable_if.hpp>
#include <boost/mpl/int.hpp>
#include <boost/preprocessor/repetition/repeat.hpp>
#include <boost/preprocessor/repetition/repeat_from_to.hpp>
#include <boost/preprocessor/repetition/enum.hpp>
 
#include <iostream>
 
#include "ndarray_fwd.h"
#include "ndarray/types.h"
 
#define NDARRAY_MAKE_VECTOR_MAX 8
 
#define NDARRAY_MAKE_VECTOR_ARG_SPEC(Z,I,DATA) T v ## I
#define NDARRAY_MAKE_VECTOR_SET_SPEC(Z,I,DATA) r[I] = v ## I;
 
#define NDARRAY_MAKE_VECTOR_SPEC(Z,N,DATA)                      \
    template <typename T>                                       \
    inline Vector<T,N> makeVector(                              \
        BOOST_PP_ENUM(N,NDARRAY_MAKE_VECTOR_ARG_SPEC,unused)    \
    ) {                                                         \
        Vector<T,N> r;                                          \
        BOOST_PP_REPEAT(N,NDARRAY_MAKE_VECTOR_SET_SPEC,unused)  \
        return r;                                               \
    }
 
 
namespace ndarray {
 
namespace detail {
 
template <typename T, bool isArithmetic=boost::is_arithmetic<T>::value>
struct DefaultValue {
    static T get() { return T(); }
};
 
template <typename T>
struct DefaultValue<T,true> {
    static T get() { return T(0); }
};
 
} // namespace detail
 
 
template <
    typename T, 
    int N       
    >
struct Vector {
    
    typedef T Element;
    typedef T Value;
    typedef T & Reference;
    typedef T const & ConstReference;
    typedef T * Iterator;
    typedef T const * ConstIterator;
    
    typedef Value value_type;
    typedef Iterator iterator;
    typedef ConstIterator const_iterator;
    typedef Reference reference;
    typedef ConstReference const_reference;
    typedef boost::reverse_iterator<T*> reverse_iterator;
    typedef boost::reverse_iterator<const T*> const_reverse_iterator;
    typedef T * pointer;
    typedef int difference_type;
    typedef int size_type;
 
 
    typedef boost::mpl::int_<N> ND;
    size_type size() const { return N; }
    size_type max_size() const { return N; }
    bool empty() const { return N==0; }
    iterator begin() { return elems; }
    const_iterator begin() const { return elems; }
    iterator end() { return elems+N; }
    const_iterator end() const { return elems+N; }
    reverse_iterator rbegin() { return reverse_iterator(end()); }
    const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
    reverse_iterator rend() { return reverse_iterator(begin()); }
    const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
 
    reference front() { return *elems; }
    reference back() { return *(elems+N-1); }
    const_reference front() const { return *elems; }
    const_reference back() const { return *(elems+N-1); }
 
    reference operator[](int i) { return elems[i]; }
    const_reference operator[](int i) const { return elems[i]; }
 
    template <int Start, int Stop>
    Vector<T,Stop-Start> getRange() const {
        Vector<T,Stop-Start> r;
        std::copy(begin() + Start, begin()+Stop, r.begin());
        return r;
    }
 
    template <int M> Vector<T,M> first() const {
        Vector<T,M> r;
        std::copy(begin(), begin() + M, r.begin());
        return r;
    }
 
    template <int M> Vector<T,M> last() const {
        Vector<T,M> r;
        std::copy(begin() + (N - M), begin() + N, r.begin());
        return r;
    }
 
    friend std::ostream& operator<<(std::ostream& os, Vector<T,N> const & obj) {
        os << "(";
        std::copy(obj.begin(), obj.end(), std::ostream_iterator<T>(os,","));
        return os << ")";
    }
 
    Vector() { this->
    #ifndef _MSC_VER
    template 
    #endif
    operator=(detail::DefaultValue<T>::get()); }
 
    explicit Vector(T scalar) {
        this->operator=(scalar);
    }
 
    template <typename U>
    Vector(Vector<U,N> const & other) {
        this->
        #ifndef _MSC_VER
        template 
        #endif
        operator=(other);
    }
 
    bool operator==(Vector const & other) const {
        return std::equal(begin(), end(), other.begin());
    }
 
    bool operator!=(Vector const & other) const {
        return !(*this == other);
    }
 
    T sum() const {
        T r = 0;
        for (ConstIterator i = begin(); i != end(); ++i) r += (*i);
        return r;
    }
 
    T product() const {
        T r = 1;
        for (ConstIterator i = begin(); i != end(); ++i) r *= (*i);
        return r;
    }
 
    Vector reverse() const {
        Vector r;
        std::copy(begin(), end(), r.rbegin());
        return r;
    }
 
    template <typename U>
    Vector<U,N> cast() const {
        Vector<U,N> r;
        for (int i = 0; i < N; ++i) {
            r[i] = static_cast<U>((*this)[i]);
        }
        return r;
    }
 
    
    template <typename U>
    typename boost::enable_if<boost::is_convertible<U,T>,Vector&>::type
    operator = (Vector<U,N> const & other) {
        typename Vector<U,N>::ConstIterator j = other.begin();
        for (Iterator i = begin(); i != end(); ++i, ++j) (*i) = (*j);
        return *this;
    }
    template <typename U>
    typename boost::enable_if<boost::is_convertible<U,T>,Vector&>::type
    operator = (U scalar) {
        for (Iterator i = begin(); i != end(); ++i) (*i) = scalar;
        return *this;
    }
    
    template <typename U>
    typename boost::enable_if<boost::is_convertible<U,T>,Vector&>::type
    operator += (Vector<U,N> const & other) {
        typename Vector<U,N>::ConstIterator j = other.begin();
        for (Iterator i = begin(); i != end(); ++i, ++j) (*i) += (*j);
        return *this;
    }
    template <typename U>
    typename boost::enable_if<boost::is_convertible<U,T>,Vector&>::type
    operator += (U scalar) {
        for (Iterator i = begin(); i != end(); ++i) (*i) += scalar;
        return *this;
    }
    
    template <typename U>
    typename boost::enable_if<boost::is_convertible<U,T>,Vector&>::type
    operator -= (Vector<U,N> const & other) {
        typename Vector<U,N>::ConstIterator j = other.begin();
        for (Iterator i = begin(); i != end(); ++i, ++j) (*i) -= (*j);
        return *this;
    }
    template <typename U>
    typename boost::enable_if<boost::is_convertible<U,T>,Vector&>::type
    operator -= (U scalar) {
        for (Iterator i = begin(); i != end(); ++i) (*i) -= scalar;
        return *this;
    }
    
    template <typename U>
    typename boost::enable_if<boost::is_convertible<U,T>,Vector&>::type
    operator *= (Vector<U,N> const & other) {
        typename Vector<U,N>::ConstIterator j = other.begin();
        for (Iterator i = begin(); i != end(); ++i, ++j) (*i) *= (*j);
        return *this;
    }
    template <typename U>
    typename boost::enable_if<boost::is_convertible<U,T>,Vector&>::type
    operator *= (U scalar) {
        for (Iterator i = begin(); i != end(); ++i) (*i) *= scalar;
        return *this;
    }
    
    template <typename U>
    typename boost::enable_if<boost::is_convertible<U,T>,Vector&>::type
    operator /= (Vector<U,N> const & other) {
        typename Vector<U,N>::ConstIterator j = other.begin();
        for (Iterator i = begin(); i != end(); ++i, ++j) (*i) /= (*j);
        return *this;
    }
    template <typename U>
    typename boost::enable_if<boost::is_convertible<U,T>,Vector&>::type
    operator /= (U scalar) {
        for (Iterator i = begin(); i != end(); ++i) (*i) /= scalar;
        return *this;
    }
    
    template <typename U>
    typename boost::enable_if<boost::is_convertible<U,T>,Vector&>::type
    operator %= (Vector<U,N> const & other) {
        typename Vector<U,N>::ConstIterator j = other.begin();
        for (Iterator i = begin(); i != end(); ++i, ++j) (*i) %= (*j);
        return *this;
    }
    template <typename U>
    typename boost::enable_if<boost::is_convertible<U,T>,Vector&>::type
    operator %= (U scalar) {
        for (Iterator i = begin(); i != end(); ++i) (*i) %= scalar;
        return *this;
    }
    
    template <typename U>
    typename boost::enable_if<boost::is_convertible<U,T>,Vector&>::type
    operator &= (Vector<U,N> const & other) {
        typename Vector<U,N>::ConstIterator j = other.begin();
        for (Iterator i = begin(); i != end(); ++i, ++j) (*i) &= (*j);
        return *this;
    }
    template <typename U>
    typename boost::enable_if<boost::is_convertible<U,T>,Vector&>::type
    operator &= (U scalar) {
        for (Iterator i = begin(); i != end(); ++i) (*i) &= scalar;
        return *this;
    }
    
    template <typename U>
    typename boost::enable_if<boost::is_convertible<U,T>,Vector&>::type
    operator ^= (Vector<U,N> const & other) {
        typename Vector<U,N>::ConstIterator j = other.begin();
        for (Iterator i = begin(); i != end(); ++i, ++j) (*i) ^= (*j);
        return *this;
    }
    template <typename U>
    typename boost::enable_if<boost::is_convertible<U,T>,Vector&>::type
    operator ^= (U scalar) {
        for (Iterator i = begin(); i != end(); ++i) (*i) ^= scalar;
        return *this;
    }
    
    template <typename U>
    typename boost::enable_if<boost::is_convertible<U,T>,Vector&>::type
    operator |= (Vector<U,N> const & other) {
        typename Vector<U,N>::ConstIterator j = other.begin();
        for (Iterator i = begin(); i != end(); ++i, ++j) (*i) |= (*j);
        return *this;
    }
    template <typename U>
    typename boost::enable_if<boost::is_convertible<U,T>,Vector&>::type
    operator |= (U scalar) {
        for (Iterator i = begin(); i != end(); ++i) (*i) |= scalar;
        return *this;
    }
    
    template <typename U>
    typename boost::enable_if<boost::is_convertible<U,T>,Vector&>::type
    operator <<= (Vector<U,N> const & other) {
        typename Vector<U,N>::ConstIterator j = other.begin();
        for (Iterator i = begin(); i != end(); ++i, ++j) (*i) <<= (*j);
        return *this;
    }
    template <typename U>
    typename boost::enable_if<boost::is_convertible<U,T>,Vector&>::type
    operator <<= (U scalar) {
        for (Iterator i = begin(); i != end(); ++i) (*i) <<= scalar;
        return *this;
    }
    
    template <typename U>
    typename boost::enable_if<boost::is_convertible<U,T>,Vector&>::type
    operator >>= (Vector<U,N> const & other) {
        typename Vector<U,N>::ConstIterator j = other.begin();
        for (Iterator i = begin(); i != end(); ++i, ++j) (*i) >>= (*j);
        return *this;
    }
    template <typename U>
    typename boost::enable_if<boost::is_convertible<U,T>,Vector&>::type
    operator >>= (U scalar) {
        for (Iterator i = begin(); i != end(); ++i) (*i) >>= scalar;
        return *this;
    }
 
    T elems[N];
};
 
template <typename T>
struct Vector<T,0> {
    
    typedef T Element;
    typedef T Value;
    typedef T & Reference;
    typedef T const & ConstReference;
    typedef T * Iterator;
    typedef T const * ConstIterator;
    
    typedef Value value_type;
    typedef Iterator iterator;
    typedef ConstIterator const_iterator;
    typedef Reference reference;
    typedef ConstReference const_reference;
    typedef boost::reverse_iterator<T*> reverse_iterator;
    typedef boost::reverse_iterator<const T*> const_reverse_iterator;
    typedef T * pointer;
    typedef int difference_type;
    typedef int size_type;
 
 
    typedef boost::mpl::int_<0> ND;
 
    size_type size() const { return 0; }           
    size_type max_size() const { return 0; }       
    bool empty() const { return true; }            
    iterator begin() { return 0; }
    const_iterator begin() const { return 0; }
    iterator end() { return 0; }
    const_iterator end() const { return 0; }
    reverse_iterator rbegin() { return reverse_iterator(); }
    const_reverse_iterator rbegin() const { return const_reverse_iterator(); }
    reverse_iterator rend() { return reverse_iterator(); }
    const_reverse_iterator rend() const { return const_reverse_iterator(); }
 
    reference front() { NDARRAY_ASSERT(false); return 0; }
    reference back() { return NDARRAY_ASSERT(false); return 0; }
    const_reference front() const { NDARRAY_ASSERT(false); return 0; }
    const_reference back() const { NDARRAY_ASSERT(false); return 0; }
 
    reference operator[](int i) { NDARRAY_ASSERT(false); return 0; }
    const_reference operator[](int i) const { NDARRAY_ASSERT(false); return 0; }
 
    template <int Start, int Stop>
    Vector<T,Stop-Start> getRange() const {
        return Vector<T,Stop-Start>();
    }
 
    template <int M> Vector<T,M> first() const {
        return Vector<T,M>();
    }
 
    template <int M> Vector<T,M> last() const {
        return Vector<T,M>();
    }
 
    friend std::ostream& operator<<(std::ostream& os, Vector<T,0> const & obj) {
        return os << "()";
    }
 
    Vector() {}
 
    explicit Vector(T scalar) {}
 
    template <typename U>
    Vector(Vector<U,0> const & other) {}
 
    bool operator==(Vector const & other) const { return true; }
 
    bool operator!=(Vector const & other) const { return false; }
 
    T sum() const { return 0; }
 
    T product() const { return 1; }
 
    Vector reverse() const { return Vector(); }
 
    template <typename U>
    Vector<U,0> cast() const { return Vector<U,0>(); }
 
};
 
 
template <typename T, int N, int M>
inline Vector<T,N+M> concatenate(Vector<T,N> const & a, Vector<T,M> const & b) {
    Vector<T,N+M> r;
    std::copy(a.begin(),a.end(),r.begin());
    std::copy(b.begin(),b.end(),r.begin()+N);
    return r;
}
 
template <typename T, int N, typename U>
inline typename boost::enable_if<boost::is_convertible<U,T>,Vector<T,N+1> >::type
concatenate(Vector<T,N> const & a, U b) {
    Vector<T,N+1> r;
    std::copy(a.begin(),a.end(),r.begin());
    r[N] = b;
    return r;
}
 
template <typename T, int N, typename U>
inline typename boost::enable_if<boost::is_convertible<U,T>,Vector<T,N+1> >::type
concatenate(U a, Vector<T,N> const & b) {
    Vector<T,N+1> r;
    r[0] = a;
    std::copy(b.begin(),b.end(),r.begin()+1);
    return r;
}
 
#ifndef DOXYGEN
BOOST_PP_REPEAT_FROM_TO(1, NDARRAY_MAKE_VECTOR_MAX, NDARRAY_MAKE_VECTOR_SPEC, unused)
#else
template <typename T, int N>
Vector<T,N> makeVector(T v1, T v2, ..., T vN);
#endif
 
template <typename T, int N>
inline Vector<T,N> operator~(Vector<T,N> const & vector) {
    Vector<T,N> r(vector);
    for (typename Vector<T,N>::Iterator i = r.begin(); i != r.end(); ++i) (*i) = ~(*i);
    return r;    
}
 
template <typename T, int N>
inline Vector<T,N> operator!(Vector<T,N> const & vector) {
    Vector<T,N> r(vector);
    for (typename Vector<T,N>::Iterator i = r.begin(); i != r.end(); ++i) (*i) = !(*i);
    return r;
}
 
 
    template <typename T, typename U, int N>
    Vector<typename Promote<T,U>::Type,N>
    operator +(Vector<T,N> const & a, Vector<U,N> const & b) {
        Vector<typename Promote<T,U>::Type,N> r(a);
        return r += b;
    }
    template <typename T, typename U, int N>
    Vector<typename Promote<T,U>::Type,N>
    operator +(Vector<T,N> const & a, U b) {
        Vector<typename Promote<T,U>::Type,N> r(a);
        return r += b;
    }
    template <typename T, typename U, int N>
    Vector<typename Promote<T,U>::Type,N>
    operator +(U a, Vector<T,N> const & b) {
        Vector<typename Promote<T,U>::Type,N> r(a);
        return r += b;
    }
 
    template <typename T, typename U, int N>
    Vector<typename Promote<T,U>::Type,N>
    operator -(Vector<T,N> const & a, Vector<U,N> const & b) {
        Vector<typename Promote<T,U>::Type,N> r(a);
        return r -= b;
    }
    template <typename T, typename U, int N>
    Vector<typename Promote<T,U>::Type,N>
    operator -(Vector<T,N> const & a, U b) {
        Vector<typename Promote<T,U>::Type,N> r(a);
        return r -= b;
    }
    template <typename T, typename U, int N>
    Vector<typename Promote<T,U>::Type,N>
    operator -(U a, Vector<T,N> const & b) {
        Vector<typename Promote<T,U>::Type,N> r(a);
        return r -= b;
    }
 
    template <typename T, typename U, int N>
    Vector<typename Promote<T,U>::Type,N>
    operator *(Vector<T,N> const & a, Vector<U,N> const & b) {
        Vector<typename Promote<T,U>::Type,N> r(a);
        return r *= b;
    }
    template <typename T, typename U, int N>
    Vector<typename Promote<T,U>::Type,N>
    operator *(Vector<T,N> const & a, U b) {
        Vector<typename Promote<T,U>::Type,N> r(a);
        return r *= b;
    }
    template <typename T, typename U, int N>
    Vector<typename Promote<T,U>::Type,N>
    operator *(U a, Vector<T,N> const & b) {
        Vector<typename Promote<T,U>::Type,N> r(a);
        return r *= b;
    }
 
    template <typename T, typename U, int N>
    Vector<typename Promote<T,U>::Type,N>
    operator /(Vector<T,N> const & a, Vector<U,N> const & b) {
        Vector<typename Promote<T,U>::Type,N> r(a);
        return r /= b;
    }
    template <typename T, typename U, int N>
    Vector<typename Promote<T,U>::Type,N>
    operator /(Vector<T,N> const & a, U b) {
        Vector<typename Promote<T,U>::Type,N> r(a);
        return r /= b;
    }
    template <typename T, typename U, int N>
    Vector<typename Promote<T,U>::Type,N>
    operator /(U a, Vector<T,N> const & b) {
        Vector<typename Promote<T,U>::Type,N> r(a);
        return r /= b;
    }
 
    template <typename T, typename U, int N>
    Vector<typename Promote<T,U>::Type,N>
    operator %(Vector<T,N> const & a, Vector<U,N> const & b) {
        Vector<typename Promote<T,U>::Type,N> r(a);
        return r %= b;
    }
    template <typename T, typename U, int N>
    Vector<typename Promote<T,U>::Type,N>
    operator %(Vector<T,N> const & a, U b) {
        Vector<typename Promote<T,U>::Type,N> r(a);
        return r %= b;
    }
    template <typename T, typename U, int N>
    Vector<typename Promote<T,U>::Type,N>
    operator %(U a, Vector<T,N> const & b) {
        Vector<typename Promote<T,U>::Type,N> r(a);
        return r %= b;
    }
 
    template <typename T, typename U, int N>
    Vector<typename Promote<T,U>::Type,N>
    operator &(Vector<T,N> const & a, Vector<U,N> const & b) {
        Vector<typename Promote<T,U>::Type,N> r(a);
        return r &= b;
    }
    template <typename T, typename U, int N>
    Vector<typename Promote<T,U>::Type,N>
    operator &(Vector<T,N> const & a, U b) {
        Vector<typename Promote<T,U>::Type,N> r(a);
        return r &= b;
    }
    template <typename T, typename U, int N>
    Vector<typename Promote<T,U>::Type,N>
    operator &(U a, Vector<T,N> const & b) {
        Vector<typename Promote<T,U>::Type,N> r(a);
        return r &= b;
    }
 
    template <typename T, typename U, int N>
    Vector<typename Promote<T,U>::Type,N>
    operator ^(Vector<T,N> const & a, Vector<U,N> const & b) {
        Vector<typename Promote<T,U>::Type,N> r(a);
        return r ^= b;
    }
    template <typename T, typename U, int N>
    Vector<typename Promote<T,U>::Type,N>
    operator ^(Vector<T,N> const & a, U b) {
        Vector<typename Promote<T,U>::Type,N> r(a);
        return r ^= b;
    }
    template <typename T, typename U, int N>
    Vector<typename Promote<T,U>::Type,N>
    operator ^(U a, Vector<T,N> const & b) {
        Vector<typename Promote<T,U>::Type,N> r(a);
        return r ^= b;
    }
 
    template <typename T, typename U, int N>
    Vector<typename Promote<T,U>::Type,N>
    operator |(Vector<T,N> const & a, Vector<U,N> const & b) {
        Vector<typename Promote<T,U>::Type,N> r(a);
        return r |= b;
    }
    template <typename T, typename U, int N>
    Vector<typename Promote<T,U>::Type,N>
    operator |(Vector<T,N> const & a, U b) {
        Vector<typename Promote<T,U>::Type,N> r(a);
        return r |= b;
    }
    template <typename T, typename U, int N>
    Vector<typename Promote<T,U>::Type,N>
    operator |(U a, Vector<T,N> const & b) {
        Vector<typename Promote<T,U>::Type,N> r(a);
        return r |= b;
    }
 
    template <typename T, typename U, int N>
    Vector<typename Promote<T,U>::Type,N>
    operator <<(Vector<T,N> const & a, Vector<U,N> const & b) {
        Vector<typename Promote<T,U>::Type,N> r(a);
        return r <<= b;
    }
    template <typename T, typename U, int N>
    Vector<typename Promote<T,U>::Type,N>
    operator <<(Vector<T,N> const & a, U b) {
        Vector<typename Promote<T,U>::Type,N> r(a);
        return r <<= b;
    }
    template <typename T, typename U, int N>
    Vector<typename Promote<T,U>::Type,N>
    operator <<(U a, Vector<T,N> const & b) {
        Vector<typename Promote<T,U>::Type,N> r(a);
        return r <<= b;
    }
 
    template <typename T, typename U, int N>
    Vector<typename Promote<T,U>::Type,N>
    operator >>(Vector<T,N> const & a, Vector<U,N> const & b) {
        Vector<typename Promote<T,U>::Type,N> r(a);
        return r >>= b;
    }
    template <typename T, typename U, int N>
    Vector<typename Promote<T,U>::Type,N>
    operator >>(Vector<T,N> const & a, U b) {
        Vector<typename Promote<T,U>::Type,N> r(a);
        return r >>= b;
    }
    template <typename T, typename U, int N>
    Vector<typename Promote<T,U>::Type,N>
    operator >>(U a, Vector<T,N> const & b) {
        Vector<typename Promote<T,U>::Type,N> r(a);
        return r >>= b;
    }
 
 
} // namespace ndarray
 
#endif // !NDARRAY_Vector_h_INCLUDED