Vector.h

Go to the documentation of this file.

// -*- lsst-c++ -*-
/* 
 * LSST Data Management System
 * Copyright 2008, 2009, 2010, 2011 LSST Corporation.
 * 
 * This product includes software developed by the
 * LSST Project (http://www.lsst.org/).
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the LSST License Statement and 
 * the GNU General Public License along with this program.  If not, 
 * see <http://www.lsstcorp.org/LegalNotices/>.
 */
#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/mpl/int.hpp>
#include <boost/utility/enable_if.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->template operator=(detail::DefaultValue<T>::get()); }

    template <typename U>
    explicit Vector(U scalar) {
        this->template operator=(scalar);
    }

    template <typename U>
    explicit Vector(Vector<U,N> const & other) {
        this->template 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>
    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() {}

    template <typename U>
    explicit Vector(U scalar) {}

    template <typename U>
    explicit 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 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>
inline Vector<T,N+1> concatenate(Vector<T,N> const & a, T const & b) {
    Vector<T,N+1> r;
    std::copy(a.begin(),a.end(),r.begin());
    r[N] = b;
    return r;
}

template <typename T, int N>
inline Vector<T,N+1> concatenate(T const & 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