arrayND.h

Go to the documentation of this file.

#ifndef DLRNUMERIC_ARRAYND_H
#define DLRNUMERIC_ARRAYND_H

#include <iostream>
#include <string>
#include <dlrCommon/exception.h>
#include <dlrNumeric/array1D.h>

namespace dlr {


  namespace numeric {
    
    template <size_t Dimension, class Type>
    class ArrayND {
    public:
      /* ======== Public typedefs ======== */

      typedef Type value_type;

      typedef Type* iterator;
    
      typedef const Type* const_iterator;


      /* ======== Public member functions ======== */

      ArrayND();

      
      explicit
      ArrayND(size_t dimension, size_t const shape[]);


      explicit
      ArrayND(const Array1D<size_t>& shape);

    
      ArrayND(const ArrayND<Dimension, Type> &source);
    

      explicit
      ArrayND(const std::string& inputString);

      
      ~ArrayND();


      iterator
      begin() {return m_storage.begin();}

      
      const_iterator
      begin() const {return m_storage.begin();}


      inline void
      checkDimension(Array1D<size_t> const& shape) const;

    
      void
      clear() {m_shape.reinit(0); m_storage.reinit(0);}

      
      ArrayND<Dimension, Type>
      copy() const;

      
      template <class Type2> void
      copy(const ArrayND<Dimension, Type2>& source);

      
      template <class Type2> void
      copy(const Type2* dataPtr);

      
      Type*
      data() {return m_storage.data();}

      
      const Type*
      data() const {return m_storage.data();}

      
      bool
      empty() const {return m_storage.empty();}

    
      iterator
      end() {return m_storage.end();}

      
      const_iterator
      end() const {return m_storage.end();}


      size_t
      flattenIndex(const Array1D<size_t>& indexArray) const;

      
      inline Type
      getElement(size_t index0) const {return this->operator()(index0);}


      inline Type
      getElement(Array1D<size_t> const& index0) const {
        return this->operator()(index0);
      }


      inline const Array1D<size_t>&
      getShape() const {return m_shape;}


      size_t
      getStride(size_t axis) const {return m_strideArray[axis];}

      
      bool
      isAllocated() const {return true;}


      Array1D<Type>
      ravel() {return m_storage;}

      
      Array1D<Type> const
      ravel() const {return m_storage;}

      
      void
      reinit(Array1D<size_t> const& shape);
    

      Type&
      setElement(size_t index0, const Type& value) {
        return this->operator()(index0) = value;
      }


      Type&
      setElement(Array1D<size_t> const& index0, const Type& value) {
        return this->operator()(this->flattenIndex(index0)) = value;
      }


      size_t
      size() const {return m_storage.size();}

      
      ArrayND<Dimension, Type>&
      operator=(const ArrayND<Dimension, Type>& source);

      
      inline ArrayND<Dimension, Type>&
      operator=(Type value);


      Type&
      operator()(size_t index0) {return m_storage(index0);}
  

      Type operator()(size_t index0) const {return m_storage(index0);}

      
      Type&
      operator()(Array1D<size_t> const& index0) {
        return m_storage[this->flattenIndex(index0)];
      }
  

      Type operator()(Array1D<size_t> const& index0) const {
        return m_storage[this->flattenIndex(index0)];
      }


      Type& operator[](size_t index) {return this->operator()(index);}

      
      Type operator[](size_t index) const {return this->operator()(index);}


      template <class Type2>
      ArrayND<Dimension, Type>&
      operator+=(const ArrayND<Dimension, Type2>& arg);

      
      ArrayND<Dimension, Type>&
      operator+=(const Type arg);


      template <class Type2>
      ArrayND<Dimension, Type>&
      operator-=(const ArrayND<Dimension, Type2>& arg);

      
      ArrayND<Dimension, Type>&
      operator-=(const Type arg);

      
      template <class Type2>
      ArrayND<Dimension, Type>&
      operator*=(const ArrayND<Dimension, Type2>& arg);

      
      ArrayND<Dimension, Type>&
      operator*=(const Type arg);


      template <class Type2>
      ArrayND<Dimension, Type>&
      operator/=(const ArrayND<Dimension, Type2>& arg);

      
      ArrayND<Dimension, Type>&
      operator/=(const Type arg);

    private:
      /* ======== Private member functions ======== */

      size_t computeSize(Array1D<size_t> const& shape) const;
      Array1D<size_t> computeStride(Array1D<size_t> const& shape) const;

      
      /* ======== Private data members ======== */
      Array1D<size_t> m_shape;
      Array1D<Type> m_storage;
      Array1D<size_t> m_strideArray;
    };


    /* Non-member functions which should maybe wind up in a different file */

    template <size_t Dimension, class Type>
    ArrayND<Dimension, Type>
    operator+(const ArrayND<Dimension, Type>& array0,
              const ArrayND<Dimension, Type>& arrayN);
  

    template <size_t Dimension, class Type>
    ArrayND<Dimension, Type>
    operator-(const ArrayND<Dimension, Type>& array0,
              const ArrayND<Dimension, Type>& arrayN);


    template <size_t Dimension, class Type>
    ArrayND<Dimension, Type>
    operator*(const ArrayND<Dimension, Type>& array0,
              const ArrayND<Dimension, Type>& arrayN);
  

    template <size_t Dimension, class Type>
    ArrayND<Dimension, Type>
    operator/(const ArrayND<Dimension, Type>& array0,
              const ArrayND<Dimension, Type>& arrayN);


    template <size_t Dimension, class Type>
    ArrayND<Dimension, Type>
    operator+(const ArrayND<Dimension, Type>& array, Type scalar);


    template <size_t Dimension, class Type>
    ArrayND<Dimension, Type>
    operator-(const ArrayND<Dimension, Type>& array0, Type scalar);


    template <size_t Dimension, class Type>
    ArrayND<Dimension, Type>
    operator*(const ArrayND<Dimension, Type>& array0, Type scalar);


    template <size_t Dimension, class Type>
    ArrayND<Dimension, Type>
    operator/(const ArrayND<Dimension, Type>& array0, Type scalar);


    template <size_t Dimension, class Type>
    inline ArrayND<Dimension, Type>
    operator+(Type scalar, const ArrayND<Dimension, Type>& array0);


    template <size_t Dimension, class Type>
    inline ArrayND<Dimension, Type>
    operator-(Type scalar, const ArrayND<Dimension, Type>& array0);


    template <size_t Dimension, class Type>
    inline ArrayND<Dimension, Type>
    operator*(Type scalar, const ArrayND<Dimension, Type>& array0);


    template <size_t Dimension, class Type>
    inline ArrayND<Dimension, Type>
    operator/(Type scalar, const ArrayND<Dimension, Type>& array0);


    template <size_t Dimension, class Type>
    ArrayND<Dimension, bool>
    operator==(const ArrayND<Dimension, Type>& array0, const Type arg);

    
    template <size_t Dimension, class Type>
    ArrayND<Dimension, bool>
    operator==(const ArrayND<Dimension, Type>& array0,
               const ArrayND<Dimension, Type>& arrayN);
    

    template <size_t Dimension, class Type>
    ArrayND<Dimension, bool>
    operator>(const ArrayND<Dimension, Type>& array0, const Type arg);

  
    template <size_t Dimension, class Type>
    ArrayND<Dimension, bool>
    operator>=(const ArrayND<Dimension, Type>& array0, const Type arg);


    template <size_t Dimension, class Type>
    ArrayND<Dimension, bool>
    operator<(const ArrayND<Dimension, Type>& array0, const Type arg);


    template <size_t Dimension, class Type>
    ArrayND<Dimension, bool>
    operator<=(const ArrayND<Dimension, Type>& array0, const Type arg);


    template <size_t Dimension, class Type>
    std::ostream& operator<<(std::ostream& stream,
                             const ArrayND<Dimension, Type>& array0);

    
    template <size_t Dimension, class Type>
    std::istream& operator>>(std::istream& stream,
                             ArrayND<Dimension, Type> & array0);
    
  } // namespace numeric

} // namespace dlr



/* ============ Inline and template definitions follow. ============ */

#include <algorithm>
#include <numeric>
#include <sstream>
#include <vector>
#include <dlrNumeric/numericTraits.h>

namespace dlr {

  namespace numeric {
    
    template <size_t Dimension, class Type>
    ArrayND<Dimension, Type>::
    ArrayND()
      : m_shape(),
        m_storage(),
        m_strideArray()
    {
      // Empty.
    }


    template <size_t Dimension, class Type>
    ArrayND<Dimension, Type>::
    ArrayND(size_t dimension, size_t const shape[])
      : m_shape(dimension),
        m_storage(),
        m_strideArray()
    {
      m_shape.copy(shape);
      m_storage.reinit(this->computeSize(m_shape));
    }


    // Construct from an initialization string.
    template <size_t Dimension, class Type>
    ArrayND<Dimension, Type>::
    ArrayND(const Array1D<size_t>& shape)
      : m_shape(shape.copy()),
        m_storage(this->computeSize(m_shape)),
        m_strideArray(this->computeStride(m_shape))
    {
      // Empty.
    }

  
    /* When copying from a ArrayND do a shallow copy */
    /* Update reference count if the array we're copying has */
    /* valid data. */
    template <size_t Dimension, class Type>
    ArrayND<Dimension, Type>::
    ArrayND(const ArrayND<Dimension, Type>& source)
      : m_shape(source.m_shape.copy()),            // Deep copy.
        m_storage(source.m_storage),               // Shallow copy.
        m_strideArray(source.m_strideArray.copy()) // Deep copy.
    {
      // Empty.
    }


    // Construct from an initialization string.
    template <size_t Dimension, class Type>
    ArrayND<Dimension, Type>::
    ArrayND(const std::string& inputString)
    {
      std::istringstream stream(inputString);
      stream >> *this;
      if(!stream) {
        DLR_THROW(ValueException, "ArrayND::ArrayND(std::string const&)",
                  "Malformed input string.");
      }
    }


    template <size_t Dimension, class Type>
    ArrayND<Dimension, Type>::
    ~ArrayND()
    {
      // Empty.
    }


    template <size_t Dimension, class Type>
    inline void ArrayND<Dimension, Type>::
    checkDimension(Array1D<size_t> const& shape) const
    {
      // Hmm.  Seems like this should happen even if we're optimizing.
// #ifdef _DLRNUMERIC_CHECKBOUNDS_
      if(shape.size() != m_shape.size()) {
        std::ostringstream message;
        message << "Dimensionality mismatch: required dimensionality is "
                << shape.size()
                << " while *this has dimension " << m_shape.size() << ".";
        DLR_THROW(IndexException, "ArrayND::checkDimension()",
                  message.str().c_str());
      }
      for(size_t dimension = 0; dimension < m_shape.size(); ++dimension) {
        if(m_shape[dimension] != shape[dimension]) {
          std::ostringstream message;
          message << "Shape mismatch: required shape is " << shape
                << " while *this has shape " << m_shape << ".";
          DLR_THROW(IndexException, "ArrayND::checkDimension()",
                    message.str().c_str());
        }
      }
// #endif
    }


    template <size_t Dimension, class Type>
    ArrayND<Dimension, Type> ArrayND<Dimension, Type>::
    copy() const
    {
      ArrayND<Dimension, Type> newArray(m_shape);
      newArray.copy(*this);
      return newArray;
    }

  
    template <size_t Dimension, class Type> template <class Type2>
    void ArrayND<Dimension, Type>::
    copy(const ArrayND<Dimension, Type2>& source)
    {
      this->checkDimension(source.m_shape);
      if(m_storage.size() != 0) {
        this->copy(source.data());
      }
    }

  
    template <size_t Dimension, class Type> template <class Type2>
    void
    ArrayND<Dimension, Type>::
    copy(const Type2* dataPtr)
    {
      m_storage.copy(dataPtr);
    }


    template <size_t Dimension, class Type>
    ArrayND<Dimension, Type>&
    ArrayND<Dimension, Type>::
    operator=(Type val)
    {
      m_storage = val;
      return *this;
    }


    template <size_t Dimension, class Type>
    size_t
    ArrayND<Dimension, Type>::
    flattenIndex(const Array1D<size_t>& indexArray) const
    {
      dlr::numeric::Array1D<size_t>::const_iterator endMinus = indexArray.end();
      --endMinus;
      return std::inner_product(indexArray.begin(), endMinus,
                                m_strideArray.begin(), *endMinus);
    }

    
    template <size_t Dimension, class Type>
    void ArrayND<Dimension, Type>::
    reinit(Array1D<size_t> const& shape)
    {
      m_shape = shape.copy();
      m_storage.reinit(this->computeSize(m_shape));
      m_strideArray = this->computeStride(m_shape);
    }
  

    template <size_t Dimension, class Type>
    ArrayND<Dimension, Type>& ArrayND<Dimension, Type>::
    operator=(const ArrayND<Dimension, Type>& source)
    {
      // Check for self-assignment
      if(&source != this) {
        m_shape = source.m_shape.copy();             // Deep copy.
        m_storage = source.m_storage;                // Shallow copy.
        m_strideArray = source.m_strideArray.copy(); // Deep copy.
      }
      return *this;
    }


    template <size_t Dimension, class Type> template <class Type2>
    ArrayND<Dimension, Type>&
    ArrayND<Dimension, Type>::
    operator+=(const ArrayND<Dimension, Type2>& arg)
    {
      // Let m_storage worry about array size errors.
      m_storage += arg.m_storage;
      return *this;
    }


    template <size_t Dimension, class Type>
    ArrayND<Dimension, Type>&
    ArrayND<Dimension, Type>::
    operator+=(const Type arg)
    {
      m_storage += arg;
      return *this;
    }


    template <size_t Dimension, class Type> template <class Type2>
    ArrayND<Dimension, Type>&
    ArrayND<Dimension, Type>::
    operator-=(const ArrayND<Dimension, Type2>& arg)
    {
      // Let m_storage worry about array size errors.
      m_storage -= arg.m_storage;
      return *this;
    }


    template <size_t Dimension, class Type>
    ArrayND<Dimension, Type>&
    ArrayND<Dimension, Type>::
    operator-=(const Type arg)
    {
      m_storage -= arg;
      return *this;
    }


    template <size_t Dimension, class Type> template <class Type2>
    ArrayND<Dimension, Type>&
    ArrayND<Dimension, Type>::
    operator*=(const ArrayND<Dimension, Type2>& arg)
    {
      // Let m_storage worry about array size errors.
      m_storage *= arg.m_storage;
      return *this;
    }


    template <size_t Dimension, class Type>
    ArrayND<Dimension, Type>&
    ArrayND<Dimension, Type>::
    operator*=(const Type arg)
    {
      m_storage *= arg;
      return *this;
    }


    template <size_t Dimension, class Type> template <class Type2>
    ArrayND<Dimension, Type>&
    ArrayND<Dimension, Type>::
    operator/=(const ArrayND<Dimension, Type2>& arg)
    {
      // Let m_storage worry about array size errors.
      m_storage /= arg.m_storage;
      return *this;
    }


    template <size_t Dimension, class Type>
    ArrayND<Dimension, Type>&
    ArrayND<Dimension, Type>::
    operator/=(const Type arg)
    {
      m_storage /= arg;
      return *this;
    }


    template <size_t Dimension, class Type>
    size_t
    ArrayND<Dimension, Type>::
    computeSize(Array1D<size_t> const& shape) const
    {
      return std::accumulate(shape.begin(), shape.end(), size_t(1),
                             std::multiplies<size_t>());
    }
    

    template <size_t Dimension, class Type>
    Array1D<size_t>
    ArrayND<Dimension, Type>::
    computeStride(Array1D<size_t> const& shape) const
    {
      Array1D<size_t> strideArray(shape.size());
      strideArray[shape.size() - 1] = 1;
      for(size_t ii = shape.size() - 1; ii != 0; --ii) {
        strideArray[ii - 1] = shape[ii] * strideArray[ii];
      }
      return strideArray;
    }
    

    /* ========== Non-member functions ========== */
  
    template <size_t Dimension, class Type>
    ArrayND<Dimension, Type> operator+(const ArrayND<Dimension, Type>& array0,
                                       const ArrayND<Dimension, Type>& arrayN)
    {
      if(array0.size() != arrayN.size()) {
        std::ostringstream message;
        message << "Array sizes do not match.  Array0 has " << array0.size()
                << " elements, while arrayN has " << arrayN.size()
                << " elements.";
        DLR_THROW(ValueException, "ArrayND::operator+()", message.str().c_str());
      }
      ArrayND<Dimension, Type> result(array0.getShape());
      std::transform(array0.begin(), array0.end(), arrayN.begin(),
                     result.begin(), std::plus<Type>());
      return result;
    }


    template <size_t Dimension, class Type>
    ArrayND<Dimension, Type> operator-(const ArrayND<Dimension, Type>& array0,
                            const ArrayND<Dimension, Type>& arrayN)
    {
      if(array0.size() != arrayN.size()) {
        std::ostringstream message;
        message << "Array sizes do not match.  Array0 has " << array0.size()
                << " elements, while arrayN has " << arrayN.size()
                << " elements.";
        DLR_THROW(ValueException, "ArrayND::operator-()", message.str().c_str());
      }
      ArrayND<Dimension, Type> result(array0.getShape());
      std::transform(array0.begin(), array0.end(), arrayN.begin(),
                     result.begin(), std::minus<Type>());
      return result;
    }


    template <size_t Dimension, class Type>
    ArrayND<Dimension, Type> operator*(const ArrayND<Dimension, Type>& array0,
                            const ArrayND<Dimension, Type>& arrayN)
    {
      if(array0.size() != arrayN.size()) {
        std::ostringstream message;
        message << "Array sizes do not match.  Array0 has " << array0.size()
                << " elements, while arrayN has " << arrayN.size()
                << " elements.";
        DLR_THROW(ValueException, "ArrayND::operator*()", message.str().c_str());
      }
      ArrayND<Dimension, Type> result(array0.getShape());
      std::transform(array0.begin(), array0.end(), arrayN.begin(),
                     result.begin(), std::multiplies<Type>());
      return result;
    }


    template <size_t Dimension, class Type>
    ArrayND<Dimension, Type> operator/(const ArrayND<Dimension, Type>& array0,
                            const ArrayND<Dimension, Type>& arrayN)
    {
      if(array0.size() != arrayN.size()) {
        std::ostringstream message;
        message << "Array sizes do not match.  Array0 has " << array0.size()
                << " elements, while arrayN has " << arrayN.size()
                << " elements.";
        DLR_THROW(ValueException, "ArrayND::operator/()", message.str().c_str());
      }
      ArrayND<Dimension, Type> result(array0.getShape());
      std::transform(array0.begin(), array0.end(), arrayN.begin(),
                     result.begin(), std::divides<Type>());
      return result;
    }


    template <size_t Dimension, class Type>
    ArrayND<Dimension, Type> operator+(const ArrayND<Dimension, Type>& array0, Type scalar)
    {
      ArrayND<Dimension, Type> result(array0.getShape());
      std::transform(array0.begin(), array0.end(), result.begin(),
                     std::bind2nd(std::plus<Type>(), scalar));
      return result;
    }


    template <size_t Dimension, class Type>
    ArrayND<Dimension, Type> operator-(const ArrayND<Dimension, Type>& array0, Type scalar)
    {
      ArrayND<Dimension, Type> result(array0.getShape());
      std::transform(array0.begin(), array0.end(), result.begin(),
                     std::bind2nd(std::minus<Type>(), scalar));
      return result;
    }


    template <size_t Dimension, class Type>
    ArrayND<Dimension, Type> operator*(const ArrayND<Dimension, Type>& array0, Type scalar)
    {
      ArrayND<Dimension, Type> result(array0.getShape());
      std::transform(array0.begin(), array0.end(), result.begin(),
                     std::bind2nd(std::multiplies<Type>(), scalar));
      return result;
    }


    template <size_t Dimension, class Type>
    ArrayND<Dimension, Type> operator/(const ArrayND<Dimension, Type>& array0, Type scalar)
    {
      ArrayND<Dimension, Type> result(array0.getShape());
      std::transform(array0.begin(), array0.end(), result.begin(),
                     std::bind2nd(std::divides<Type>(), scalar));
      return result;
    }


    template <size_t Dimension, class Type>
    inline ArrayND<Dimension, Type> operator+(Type scalar, const ArrayND<Dimension, Type>& array0)
    {
      return array0 + scalar;
    }


    template <size_t Dimension, class Type>
    ArrayND<Dimension, Type> operator-(Type scalar, const ArrayND<Dimension, Type>& array0)
    {
      ArrayND<Dimension, Type> result(array0.getShape());
      std::transform(array0.begin(), array0.end(), result.begin(),
                     std::bind1st(std::minus<Type>(), scalar));
      return result;
    }

  
    template <size_t Dimension, class Type>
    inline ArrayND<Dimension, Type> operator*(Type scalar, const ArrayND<Dimension, Type>& array0)
    {
      return array0 * scalar;
    }

  
    template <size_t Dimension, class Type>
    ArrayND<Dimension, Type> operator/(Type scalar, const ArrayND<Dimension, Type>& array0)
    {
      ArrayND<Dimension, Type> result(array0.getShape());
      std::transform(array0.begin(), array0.end(), result.begin(),
                     std::bind1st(std::divides<Type>(), scalar));
      return result;
    }
  

    // Elementwise comparison of an ArrayND with a constant.
    template <size_t Dimension, class Type>
    ArrayND<Dimension, bool>
    operator==(const ArrayND<Dimension, Type>& array0, const Type arg)
    {
      ArrayND<Dimension, bool> result(array0.getShape());
      std::transform(array0.begin(), array0.end(), result.data(),
                     std::bind2nd(std::equal_to<Type>(), arg));
      return result;
    }

    
    // Elementwise comparison of an ArrayND with another array.
    template <size_t Dimension, class Type>
    ArrayND<Dimension, bool>
    operator==(const ArrayND<Dimension, Type>& array0,
               const ArrayND<Dimension, Type>& arrayN)
    {
      array0.checkDimension(arrayN.getShape());
      ArrayND<Dimension, bool> result(array0.getShape());
      std::transform(array0.begin(), array0.end(), arrayN.begin(),
                     result.begin(), std::equal_to<Type>());
      return result;
    }

  
    template <size_t Dimension, class Type>
    ArrayND<Dimension, bool>
    operator>(const ArrayND<Dimension, Type>& array0, const Type arg)
    {
      ArrayND<Dimension, bool> result(array0.getShape());
      std::transform(array0.begin(), array0.end(), result.begin(),
                     std::bind2nd(std::greater<Type>(), arg));
      return result;
    }

  
    template <size_t Dimension, class Type>
    ArrayND<Dimension, bool>
    operator>=(const ArrayND<Dimension, Type>& array0, const Type arg)
    {
      ArrayND<Dimension, bool> result(array0.getShape());
      std::transform(array0.begin(), array0.end(), result.begin(),
                     std::bind2nd(std::greater_equal<Type>(), arg));
      return result;
    }


    template <size_t Dimension, class Type>
    ArrayND<Dimension, bool>
    operator<(const ArrayND<Dimension, Type>& array0, const Type arg)
    {
      ArrayND<Dimension, bool> result(array0.getShape());
      std::transform(array0.begin(), array0.end(), result.begin(),
                     std::bind2nd(std::less<Type>(), arg));
      return result;
    }


    template <size_t Dimension, class Type>
    ArrayND<Dimension, bool>
    operator<=(const ArrayND<Dimension, Type>& array0, const Type arg)
    {
      ArrayND<Dimension, bool> result(array0.getShape());
      std::transform(array0.begin(), array0.end(), result.begin(),
                     std::bind2nd(std::less_equal<Type>(), arg));
      return result;
    }


    template <size_t Dimension, class Type>
    std::ostream& operator<<(std::ostream& stream,
                             const ArrayND<Dimension, Type>& array0)
    {
      if (!stream){
        return stream;
      }
      stream << "ArrayND {\n"
             << "  shape: " << array0.getShape() << "\n"
             << "  data: " << array0.ravel() << "\n"
             << "}";
      return stream;
    }

    
    // Sets the value of an ArrayND instance from a std::istream.
    template <size_t Dimension, class Type>
    std::istream& operator>>(std::istream& stream,
                             ArrayND<Dimension, Type> & array0)
    {
      if (!stream){
        return stream;
      }
      // Construct an InputStream instance so we can use our
      // convenience functions.
      InputStream inputStream(stream, InputStream::SKIP_WHITESPACE);
      inputStream.expect("ArrayND");
      inputStream.expect("{");

      Array1D<size_t> shape;
      inputStream.expect("shape:");
      inputStream >> shape;

      Array1D<Type> data;
      inputStream.expect("data:");
      inputStream >> data;
      
      if(!inputStream) {
        return stream;
      }
      array0.reinit(shape);
      array0.copy(data.data());
      return stream;
    }

  } // namespace numeric

} // namespace dlr

#endif /* #ifdef DLRNUMERIC_ARRAYND_H */