array2D.h

Go to the documentation of this file.

#ifndef _DLR_ARRAY2D_H_
#define _DLR_ARRAY2D_H_

// Early inclusion of <algorithm> to allow inlining of member templates.
#include <algorithm>

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

namespace dlr {

  namespace numeric {
    
    template <class Type>
    class Array2D {
    public:

      /* ******** Public typedefs ******** */

      typedef Type value_type;

      typedef Type* iterator;
    
      typedef const Type* const_iterator;

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

      Array2D();

      Array2D(size_t rows, size_t columns);

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

      Array2D(const Array2D<Type> &source);

      Array2D(size_t rows, size_t columns, Type* const dataPtr);


      Array2D(size_t rows, size_t columns, Type* const dataPtr,
              size_t* refCountPtr);
    
      virtual
      ~Array2D();

      iterator
      begin() {return m_dataPtr;}

      const_iterator
      begin() const {return m_dataPtr;}

      void
      clear() {this->reinit(0, 0);}

      size_t
      columns() const {return m_columns;}


      inline void 
      checkDimension(size_t rows, size_t columns) const;

    
      Array2D<Type>
      copy() const;

      template <class Type2> void
      copy(const Array2D<Type2>& source);

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

      Type*
      data() {return m_dataPtr;}

      const Type*
      data() const {return m_dataPtr;}

      Type*
      data(size_t index) {
        this->checkBounds(index);
        return m_dataPtr + index;
      }

      const Type*
      data(size_t index) const {
        this->checkBounds(index);
        return m_dataPtr+index;
      }

      Type*
      data(size_t row, size_t column) {
        this->checkBounds(row, column);
        return m_dataPtr + column + (row * m_columns);
      }

      const Type*
      data(size_t row, size_t column) const {
        this->checkBounds(row, column);
        return m_dataPtr + column + (row * m_columns);
      }

    
      bool
      empty() const {return this->size() == 0;}

    
      iterator
      end() {return m_dataPtr + m_size;}

      
      const_iterator
      end() const {return m_dataPtr + m_size;}

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


      Type
      getElement(size_t row, size_t column) const {
        return this->operator()(row, column);
      }        


      bool
      isAllocated() const {return m_isAllocated;}
    
    
      Array1D<Type>
      ravel();

      const Array1D<Type>
      ravel() const;

      std::istream&
      readFromStream(std::istream& inputStream);
    

      size_t*
      refCountPtr() const {return m_refCountPtr;}

    
      void
      reinit(size_t rows, size_t columns);

      void
      reshape(int rows, int columns);

      Array1D<Type>
      row(size_t index);

      const Array1D<Type>
      row(size_t index) const;

      
      iterator
      rowBegin(size_t rowIndex) {return m_dataPtr + rowIndex * m_columns;}

      
      const_iterator
      rowBegin(size_t rowIndex) const {
        return m_dataPtr + rowIndex * m_columns;
      }

      
      iterator
      rowEnd(size_t rowIndex) {
        return m_dataPtr + (rowIndex + 1) * m_columns;
      }


      const_iterator
      rowEnd(size_t rowIndex) const {
        return m_dataPtr + (rowIndex + 1) * m_columns;
      }

      
      size_t
      rows() const {return m_rows;}


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


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


      Array1D<size_t>
      shape() const;

      size_t
      shape(size_t axis) const;

      size_t
      size() const {return m_size;}

      Array2D<Type>
      transpose() const;
    
      Array2D<Type>&
      operator=(const Array2D<Type>& source);

      Array2D<Type>&
      operator=(Type value);

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

      Type operator()(size_t index) const {
        this->checkBounds(index);
        return m_dataPtr[index];
      }
  
      Type&
      operator()(size_t row, size_t column) {
        this->checkBounds(row, column);
        return m_dataPtr[column + row * m_columns];
      }
    
      Type
      operator()(size_t row, size_t column) const {
        this->checkBounds(row, column);
        return m_dataPtr[column + row * m_columns];
      }

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

      template <class Type2> Array2D<Type>&
      operator+=(const Array2D<Type2>& arg);
      
      template <class Type2> Array2D<Type>&
      operator-=(const Array2D<Type2>& arg);

      template <class Type2> Array2D<Type>&
      operator*=(const Array2D<Type2>& arg);

      template <class Type2> Array2D<Type>&
      operator/=(const Array2D<Type2>& arg);
    
      Array2D<Type>&
      operator+=(Type arg);

      Array2D<Type>&
      operator-=(Type arg);

      Array2D<Type>&
      operator*=(Type arg);

      Array2D<Type>&
      operator/=(Type arg);

    private:
      /* ******** Private member functions ******** */
      void
      allocate();
    
      // Optionally throw an exception if index is beyond the range of
      // this array.
      inline void
      checkBounds(size_t index) const;

      // Optionally throw an exception if either index is beyond the
      // range of this array.
      inline void
      checkBounds(size_t row, size_t column) const;

      void
      deAllocate();

      // Constants to help with formatting.  We use the initialization
      // on first use paradigm for the string constants to avoid
      // headaches.

      static const std::string& ioIntro(); 

      static const std::string& ioOutro();

      static const char ioOpening = '[';

      static const char ioClosing = ']';

      static const char ioSeparator = ',';

    
      /* ********Private data members******** */
      size_t m_rows;
      size_t m_columns;
      size_t m_size;
      Type* m_dataPtr;
      size_t* m_refCountPtr;
      bool m_isAllocated;
    
    };
  
    /* Non-member functions which will ultimately wind up in a different file */

    template <class Type>
    Array2D<Type>
    squareRoot(const Array2D<Type>& array0);
  
    template <class Type>
    inline Array2D<Type>
    sqrt(const Array2D<Type>& array0);

    template <class Type>
    Array2D<Type>
    operator+(const Array2D<Type>& array0,
              const Array2D<Type>& array1);
  
    template <class Type>
    Array2D<Type>
    operator-(const Array2D<Type>& array0,
              const Array2D<Type>& array1);
  
    template <class Type>
    Array2D<Type>
    operator*(const Array2D<Type>& array0,
              const Array2D<Type>& array1);
  
    template <class Type>
    Array2D<Type>
    operator/(const Array2D<Type>& array0,
              const Array2D<Type>& array1);
  
    template <class Type>
    Array2D<Type>
    operator+(const Array2D<Type>& array0, Type scalar);
  
    template <class Type>
    Array2D<Type>
    operator-(const Array2D<Type>& array0, Type scalar);
  
    template <class Type>
    Array2D<Type>
    operator*(const Array2D<Type>& array0, Type scalar);
  
    template <class Type>
    Array2D<Type>
    operator/(const Array2D<Type>& array0, Type scalar);

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

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


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

    
    template <class Type>
    Array2D<bool>
    operator==(const Array2D<Type>& array0, const Array2D<Type>& array1);
    

    template <class Type>
    Array2D<bool>
    operator>(const Array2D<Type>& array0, Type arg);

  
    template <class Type>
    Array2D<bool>
    operator<(const Array2D<Type>& array0, Type arg);

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

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

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

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

} // namespace dlr


/* ======= Declarations to maintain compatibility with legacy code. ======= */

namespace dlr {

  using numeric::Array2D;

} // namespace dlr


/*******************************************************************
 * Member function definitions follow.  This would be a .C file
 * if it weren't templated.
 *******************************************************************/

#include <algorithm>
#include <functional>
#include <sstream>
#include <vector>
#include <dlrCommon/functional.h>
#include <dlrCommon/inputStream.h>
#include <dlrNumeric/numericTraits.h>
#include <dlrNumeric/functional.h>

namespace dlr {

  namespace numeric {
    
    // Static constant describing how the string representation of an
    // Array2D should start.
    template <class Type>
    const std::string&
    Array2D<Type>::
    ioIntro()
    {
      static const std::string intro = "Array2D(";
      return intro;
    }

    // Static constant describing how the string representation of an
    // Array2D should end.
    template <class Type>
    const std::string&
    Array2D<Type>::
    ioOutro()
    {
      static const std::string outro = ")";
      return outro;
    }

    // Non-static member functions below.

    template <class Type>
    Array2D<Type>::
    Array2D()
      : m_rows(0),
        m_columns(0),
        m_size(0),
        m_dataPtr(0),
        m_refCountPtr(0),
        m_isAllocated(false)
    {
      // Empty
    }

    template <class Type>
    Array2D<Type>::
    Array2D(size_t rows, size_t columns)
      : m_rows(rows),
        m_columns(columns),
        m_size(0),          // This will be set in the call to allocate().
        m_dataPtr(0),       // This will be set in the call to allocate().
        m_refCountPtr(0),   // This will be set in the call to allocate().
        m_isAllocated(false)
    {
      this->allocate();
    }

  
    // Construct from an initialization string.
    template <class Type>
    Array2D<Type>::
    Array2D(const std::string& inputString)
      : m_rows(0),
        m_columns(0),
        m_size(0),
        m_dataPtr(0),
        m_refCountPtr(0),
        m_isAllocated(false)
    {
      // We'll use the stream input operator to parse the string.
      std::istringstream inputStream(inputString);

      // Now read the string into an array.
      Array2D<Type> inputArray;
      inputStream >> inputArray;
      if(!inputStream) {
        std::ostringstream message;
        message << "Couldn't parse input string: \"" << inputString << "\".";
        DLR_THROW3(ValueException, "Array2D::Array2D(const std::string&)",
                   message.str().c_str());                 
      }

      // If all went well, copy into *this.
      *this = inputArray;
    }


    /* When copying from a Array2D do a shallow copy */
    /* Update reference count if the array we're copying has */
    /* valid data. */
    template <class Type>
    Array2D<Type>::
    Array2D(const Array2D<Type>& source)
      : m_rows(source.m_rows),
        m_columns(source.m_columns),
        m_size(source.m_size),
        m_dataPtr(source.m_dataPtr),
        m_refCountPtr(source.m_refCountPtr),
        m_isAllocated(source.m_isAllocated)
    {
      if(m_isAllocated) {
        ++(*m_refCountPtr);
      }
    }

  
    /* Here's a constructor for getting image data into the array */
    /* cheaply. */
    template <class Type>
    Array2D<Type>::
    Array2D(size_t rows, size_t columns, Type* const dataPtr)
      : m_rows(rows),
        m_columns(columns),
        m_size(rows*columns),
        m_dataPtr(dataPtr),
        m_refCountPtr(0),
        m_isAllocated(false)
    {
      // Empty
    }

  
    // Construct an array around external data which was allocated by
    // an Array?D instance.
    template <class Type>
    Array2D<Type>::
    Array2D(size_t rows, size_t columns, Type* const dataPtr,
            size_t* refCountPtr)
      : m_rows(rows),
        m_columns(columns),
        m_size(rows*columns),
        m_dataPtr(dataPtr),
        m_refCountPtr(refCountPtr),
        m_isAllocated(true)
    {
      ++(*m_refCountPtr);
    }

  
    template <class Type>
    Array2D<Type>::
    ~Array2D()
    {
      deAllocate();
    }

  
    template <class Type>
    inline void Array2D<Type>::
    checkDimension(size_t rows, size_t columns) const
    {
#ifdef _DLRNUMERIC_CHECKBOUNDS_
      if(rows != this->rows()
         || columns != this->columns()) {
        std::ostringstream message;
        message << "Size mismatch: required dimension is ("
                << rows << ", " << columns << ") "
                << " while *this has dimension "
                << this->rows() << ", " << this->columns() << ").";
        DLR_THROW(IndexException, "Array2D::checkDimension()",
                  message.str().c_str());
      }
#endif
    }


    template <class Type>
    Array2D<Type> Array2D<Type>::
    copy() const
    {
      Array2D<Type> newArray(m_rows, m_columns);
      newArray.copy(*this);
      return newArray;
    }

    template <class Type> template <class Type2>
    void Array2D<Type>::
    copy(const Array2D<Type2>& source)
    {
      if(source.size() != m_size) {
        std::ostringstream message;
        message << "Mismatched array sizes. Source array has "
                << source.size() << " elements, while destination array has "
                << m_size << " elements.";
        DLR_THROW3(ValueException, "Array2D::copy(const Array2D&)",
                   message.str().c_str());
      }
      if(m_size != 0) {
        this->copy(source.data());
      }
    }

    template <class Type> template <class Type2>
    void Array2D<Type>::
    copy(const Type2* dataPtr)
    {
      if(dataPtr == 0) {
        DLR_THROW(ValueException, "Array2D::copy(const Type2*)",
                  "Argument is a NULL pointer.");
      }
      std::transform(dataPtr, dataPtr + m_size, m_dataPtr,
                     StaticCastFunctor<Type2, Type>());
    }


    template <class Type>
    const Array1D<Type> Array2D<Type>::
    ravel() const
    {
      if(m_isAllocated) {
        return Array1D<Type>(m_size, m_dataPtr, m_refCountPtr);
      }
      return Array1D<Type>(m_size, m_dataPtr);
    }

    template <class Type>
    Array1D<Type> Array2D<Type>::
    ravel()
    {
      if(m_isAllocated) {
        return Array1D<Type>(m_size, m_dataPtr, m_refCountPtr);
      }
      return Array1D<Type>(m_size, m_dataPtr);
    }


    template <class Type>
    std::istream&
    Array2D<Type>::
    readFromStream(std::istream& inputStream)
    {
      // Most of the time, InputType will be the same as Type.
      typedef typename NumericTraits<Type>::TextOutputType InputType;

      // If stream is in a bad state, we can't read from it.
      if (!inputStream){
        return inputStream;
      }
    
      // It's a lot easier to use a try block than to be constantly
      // testing whether the IO has succeeded, so we tell inputStream to
      // complain if anything goes wrong.
      std::ios_base::iostate oldExceptionState = inputStream.exceptions();
      inputStream.exceptions(
        std::ios_base::badbit | std::ios_base::failbit | std::ios_base::eofbit);

      // Now on with the show.
      try{
        // Construct an InputStream instance so we can use our
        // convenience functions.
        InputStream stream(inputStream);

        // Skip any preceding whitespace.
        stream.skipWhiteSpace();
      
        // We won't require the input format to start with "Array2D(", but
        // if it does we read it here.
        bool foundIntro = false;
        if(stream.peek() == ioIntro()[0]) {
          foundIntro = true;
          stream.expect(ioIntro());
        }

        // OK.  We've dispensed with the intro.  What's left should be of
        // the format "[row, row, row, ...]".  We require the square
        // brackets to be there.
        stream.expect(ioOpening);

        // Read the data.  We'll use the Array1D<Type> stream operator to
        // read each row.
        Array1D<Type> inputValue;
        std::vector< Array1D<Type> > inputBuffer;
        while(1) {
          // Read the next row.
          stream >> inputValue;
          inputBuffer.push_back(inputValue);

          // Read the separator, or else the closing character.
          char inChar = 0;
          stream >> inChar;
          if(inChar == ioClosing) {
            // Found a closing.  Stop here.
            break;
          }
          if(inChar != ioSeparator) {
            // Missing separator?  Fail here.
            stream.clear(std::ios_base::failbit);
          }
        }
    
        // If we found an intro, we expect the corresponding outro.
        if(foundIntro) {
          stream.expect(ioOutro());
        }

        // Now we're done with all of the parsing, verify that all rows
        // have the same length.
        size_t rows = inputBuffer.size();
        size_t columns = ((inputBuffer.size() != 0) ? inputBuffer[0].size() : 0);
        for(size_t index = 1; index < rows; ++index) {
          if(inputBuffer[index].size() != columns) {
            // Inconsistent row lengths!  Fail here.
            stream.clear(std::ios_base::failbit);
          }
        }

        // And finally, copy the data.
        this->reinit(rows, columns);
        for(size_t index = 0; index < rows; ++index) {
          std::copy(inputBuffer[index].begin(), inputBuffer[index].end(),
                    this->begin() + (index * columns));
        }
      } catch(std::ios_base::failure) {
        // Empty
      }
      inputStream.exceptions(oldExceptionState);
      return inputStream;
    }
  

    template <class Type>
    void Array2D<Type>::
    reinit(size_t rows, size_t columns)
    {
      this->deAllocate();
      this->m_rows = rows;
      this->m_columns = columns;
      this->allocate();
    }


    /* After reshaping, matrix is still row major order */
    template <class Type>
    void Array2D<Type>::
    reshape(int rows, int columns)
    {
      // If one axis is specified as -1, it will be automatically 
      // chosen to match the number of elements in the array.
      if((rows == -1) && (columns != 0)) {
        rows = static_cast<int>(this->size()) / columns;
      } else
        if((columns == -1) && (rows != 0)) {
          columns = static_cast<int>(this->size()) / rows;
        }
      if((rows * columns) != static_cast<int>(this->size())) {
        std::ostringstream message;
        message << "Can't reshape a(n) " << this->size()
                << " element array to have " << rows << " rows and "
                << columns << " columns.";
        DLR_THROW(ValueException, "Array2D::reshape()", message.str().c_str());
      }
      m_rows = rows;
      m_columns = columns;
    }

  
    template <class Type>
    Array1D<Type> Array2D<Type>::
    row(size_t index)
    {
      this->checkBounds(index, 0);
      return Array1D<Type>(this->columns(),
                           m_dataPtr + (index * this->m_columns));
    }

  
    template <class Type>
    const Array1D<Type> Array2D<Type>::
    row(size_t index) const
    {
      this->checkBounds(index, 0);
      return Array1D<Type>(this->columns(),
                           m_dataPtr + (index * this->m_columns));
    }


    template <class Type>
    Array1D<size_t> Array2D<Type>::
    shape() const
    {
      Array1D<size_t> rc(2);
      rc(0) = this->rows();
      rc(1) = this->columns();
      return rc;
    }


    template <class Type>
    size_t Array2D<Type>::
    shape(size_t axis) const
    {
      size_t shape;
      switch(axis) {
      case 0:
        shape = this->rows();
        break;
      case 1:
        shape = this->columns();
        break;
      default:
        std::ostringstream message;
        message << "Invalid Axis: "<< axis << ".";
        DLR_THROW(ValueException, "Array2D::shape(size_t)",
                  message.str().c_str());
        shape = 0;
        break;
      }
      return shape;
    }


    template <class Type>
    Array2D<Type>& Array2D<Type>::
    operator=(Type value)
    {
      std::fill(m_dataPtr, m_dataPtr + m_size, value);
      return *this;
    }

  
    template <class Type>
    Array2D<Type>& Array2D<Type>::
    operator=(const Array2D<Type>& source)
    {
      // Check for self-assignment
      if(&source != this) {
        this->deAllocate();
        m_rows = source.m_rows;
        m_columns = source.m_columns;
        m_size = source.m_size;
        m_dataPtr = source.m_dataPtr;
        m_refCountPtr = source.m_refCountPtr;
        m_isAllocated = source.m_isAllocated;
        if(m_isAllocated) {
          ++(*m_refCountPtr);
        }
      }
      return *this;
    }


    template <class Type> template <class Type2>
    Array2D<Type>&
    Array2D<Type>::
    operator+=(const Array2D<Type2>& arg)
    {
      if(m_size != arg.size()) {
        std::ostringstream message;
        message << "Mismatched array sizes. Argument array is "
                << arg.rows() << " x " << arg.columns()
                << ", while destination array is "
                << m_rows << " x " << m_columns << ".";
        DLR_THROW(ValueException, "Array2D::operator+=()",
                  message.str().c_str());
      }
      std::transform(m_dataPtr, m_dataPtr + m_size, arg.data(), m_dataPtr,
                     std::plus<Type>());
      return *this;
    }


    template <class Type> template <class Type2>
    Array2D<Type>&
    Array2D<Type>::
    operator-=(const Array2D<Type2>& arg)
    {
      if(m_size != arg.size()) {
        std::ostringstream message;
        message << "Mismatched array sizes. Argument array is "
                << arg.rows() << " x " << arg.columns()
                << ", while destination array is "
                << m_rows << " x " << m_columns << ".";
        DLR_THROW(ValueException, "Array2D::operator-=()",
                  message.str().c_str());
      }
      std::transform(m_dataPtr, m_dataPtr + m_size, arg.data(), m_dataPtr,
                     std::minus<Type>());
      return *this;
    }


    template <class Type> template <class Type2>
    Array2D<Type>&
    Array2D<Type>::
    operator*=(const Array2D<Type2>& arg)
    {
      if(m_size != arg.size()) {
        std::ostringstream message;
        message << "Mismatched array sizes. Argument array is "
                << arg.rows() << " x " << arg.columns()
                << ", while destination array is "
                << m_rows << " x " << m_columns << ".";
        DLR_THROW(ValueException, "Array2D::operator*=()",
                  message.str().c_str());
      }
      std::transform(m_dataPtr, m_dataPtr + m_size, arg.data(), m_dataPtr,
                     std::multiplies<Type>());
      return *this;
    }


    template <class Type> template <class Type2>
    Array2D<Type>&
    Array2D<Type>::
    operator/=(const Array2D<Type2>& arg)
    {
      if(m_size != arg.size()) {
        std::ostringstream message;
        message << "Mismatched array sizes. Argument array is "
                << arg.rows() << " x " << arg.columns()
                << ", while destination array is "
                << m_rows << " x " << m_columns << ".";
        DLR_THROW(ValueException, "Array2D::operator/=()",
                  message.str().c_str());
      }
      std::transform(m_dataPtr, m_dataPtr + m_size, arg.data(), m_dataPtr,
                     std::divides<Type>());
      return *this;
    }


    template <class Type>
    Array2D<Type>&
    Array2D<Type>::
    operator*=(Type arg)
    {
      std::transform(m_dataPtr, m_dataPtr + m_size, m_dataPtr,
                     std::bind2nd(std::multiplies<Type>(), arg));
      return *this;
    }


    template <class Type>
    Array2D<Type>&
    Array2D<Type>::
    operator/=(Type arg)
    {
      std::transform(m_dataPtr, m_dataPtr + m_size, m_dataPtr,
                     std::bind2nd(std::divides<Type>(), arg));
      return *this;
    }


    template <class Type>
    Array2D<Type>&
    Array2D<Type>::
    operator+=(Type arg)
    {
      std::transform(m_dataPtr, m_dataPtr + m_size, m_dataPtr,
                     std::bind2nd(std::plus<Type>(), arg));
      return *this;
    }


    template <class Type>
    Array2D<Type>&
    Array2D<Type>::
    operator-=(Type arg)
    {
      std::transform(m_dataPtr, m_dataPtr + m_size, m_dataPtr,
                     std::bind2nd(std::minus<Type>(), arg));
      return *this;
    }


    template <class Type>
    Array2D<Type> Array2D<Type>::
    transpose() const
    {
      Array2D<Type> newMx(m_columns, m_rows);

      // Waiting for row & column iterators
      Type *tPtr0 = newMx.m_dataPtr;
      for(size_t j = 0; j < m_columns; ++j) {
        // const Type *tPtr1 = this->data(0, j);
        const Type *tPtr1 = this->data(j);
        for(size_t i = 0; i < m_rows; ++i) {
          *tPtr0 = *tPtr1;
          ++tPtr0;
          tPtr1 += m_columns;
        }
      }
      return newMx;
    }


    template <class Type>
    void Array2D<Type>::
    allocate()
    {
      m_size = m_rows * m_columns;
      if(m_rows > 0 && m_columns > 0) {
        m_dataPtr = new(Type[m_rows * m_columns]); // should throw an exception
        m_refCountPtr = new size_t;                 // if we're out of memory.
        *m_refCountPtr = 1;
        m_isAllocated = true;
        return;
      }
      m_dataPtr = 0;
      m_refCountPtr = 0;
      m_isAllocated = false;
      return;
    }


    template <class Type>
    inline void Array2D<Type>::
    checkBounds(size_t index) const
    {
#ifdef _DLRNUMERIC_CHECKBOUNDS_
      if(index < 0 || index >= m_size) {
        std::ostringstream message;
        message << "Index " << index << " is invalid for a(n) " << m_rows
                << " x " << m_columns << " array.";
        DLR_THROW(IndexException, "Array2D::checkBounds(size_t)",
                  message.str().c_str());
      }
#endif
    }


    template <class Type>
    inline void Array2D<Type>::
    checkBounds(size_t row, size_t column) const
    {
#ifdef _DLRNUMERIC_CHECKBOUNDS_
      if(row < 0 || row >= m_rows) {
        std::ostringstream message;
        message << "Row index " << row << " is invalid for a(n) "
                << m_rows << " x " << m_columns << " array.";
        DLR_THROW(IndexException, "Array2D::checkBounds(size_t, size_t)",
                  message.str().c_str());
      }
      if(column < 0 || column >= m_columns) {
        std::ostringstream message;
        message << "Column index " << column << " is invalid for a(n) "
                << m_rows << " x " << m_columns << " array.";
        DLR_THROW(IndexException, "Array2D::checkBounds(size_t, size_t)",
                  message.str().c_str());
      }
#endif
    }


    template <class Type>
    void Array2D<Type>::
    deAllocate()
    {
      if(m_isAllocated == true) {
        if(--(*m_refCountPtr) == 0) {
          delete[] m_dataPtr;
          delete m_refCountPtr;
          m_isAllocated = false;
          m_dataPtr = 0;
          m_refCountPtr = 0;
        }
      } else {
        m_dataPtr = 0;
        m_refCountPtr = 0;
      }
    }

    /* Non-member functions which will ultimately wind up in a different file */

    template <class Type>
    inline Array2D<Type>
    sqrt(const Array2D<Type>& array0)
    {
      return squareRoot(array0);
    }

    // This function returns an Array2D instance of the same shape and
    // element type as its input, in which each element contains the
    // square root of the corresponding element of the input array.
    template <class Type>
    Array2D<Type>
    squareRoot(const Array2D<Type>& array0)
    {
      Array2D<Type> result(array0.rows(), array0.columns());
      std::transform(array0.begin(), array0.end(),
                     result.begin(), SquareRootFunctor<Type>());
      return result;
    }

    template <class Type>
    Array2D<Type> operator+(const Array2D<Type>& array0,
                            const Array2D<Type>& array1)
    {
      if((array0.rows() != array1.rows())
         || (array0.columns() != array1.columns())) {
        std::ostringstream message;
        message << "Array sizes do not match.  Array0 is " << array0.rows()
                << " x " << array0.columns() << ", while array1 is "
                << array1.rows() << " x " << array1.columns() << ".";
        DLR_THROW(ValueException, "Array2D::operator+()", message.str().c_str());
      }
      Array2D<Type> result(array0.rows(), array0.columns());
      std::transform(array0.begin(), array0.end(), array1.begin(),
                     result.begin(), std::plus<Type>());
      return result;
    }

    template <class Type>
    Array2D<Type> operator-(const Array2D<Type>& array0,
                            const Array2D<Type>& array1)
    {
      if((array0.rows() != array1.rows())
         || (array0.columns() != array1.columns())) {
        std::ostringstream message;
        message << "Array sizes do not match.  Array0 is " << array0.rows()
                << " x " << array0.columns() << ", while array1 is "
                << array1.rows() << " x " << array1.columns() << ".";
        DLR_THROW(ValueException, "Array2D::operator-()", message.str().c_str());
      }
      Array2D<Type> result(array0.rows(), array0.columns());
      std::transform(array0.begin(), array0.end(), array1.begin(),
                     result.begin(), std::minus<Type>());
      return result;
    }

    template <class Type>
    Array2D<Type> operator*(const Array2D<Type>& array0,
                            const Array2D<Type>& array1)
    {
      if((array0.rows() != array1.rows())
         || (array0.columns() != array1.columns())) {
        std::ostringstream message;
        message << "Array sizes do not match.  Array0 is " << array0.rows()
                << " x " << array0.columns() << ", while array1 is "
                << array1.rows() << " x " << array1.columns() << ".";
        DLR_THROW(ValueException, "Array2D::operator*()", message.str().c_str());
      }
      Array2D<Type> result(array0.rows(), array0.columns());
      std::transform(array0.begin(), array0.end(), array1.begin(),
                     result.begin(), std::multiplies<Type>());
      return result;
    }

    template <class Type>
    Array2D<Type> operator/(const Array2D<Type>& array0,
                            const Array2D<Type>& array1)
    {
      if((array0.rows() != array1.rows())
         || (array0.columns() != array1.columns())) {
        std::ostringstream message;
        message << "Array sizes do not match.  Array0 is " << array0.rows()
                << " x " << array0.columns() << ", while array1 is "
                << array1.rows() << " x " << array1.columns() << ".";
        DLR_THROW(ValueException, "Array2D::operator/()", message.str().c_str());
      }
      Array2D<Type> result(array0.rows(), array0.columns());
      std::transform(array0.begin(), array0.end(), array1.begin(),
                     result.begin(), std::divides<Type>());
      return result;
    }

    template <class Type>
    Array2D<Type> operator+(const Array2D<Type>& array0, Type scalar)
    {
      Array2D<Type> result(array0.rows(), array0.columns());
      std::transform(array0.begin(), array0.end(), result.begin(),
                     std::bind2nd(std::plus<Type>(), scalar));
      return result;
    }

    template <class Type>
    Array2D<Type> operator-(const Array2D<Type>& array0, Type scalar)
    {
      Array2D<Type> result(array0.rows(), array0.columns());
      std::transform(array0.begin(), array0.end(), result.begin(),
                     std::bind2nd(std::minus<Type>(), scalar));
      return result;
    }

    template <class Type>
    Array2D<Type> operator*(const Array2D<Type>& array0, Type scalar)
    {
      Array2D<Type> result(array0.rows(), array0.columns());
      std::transform(array0.begin(), array0.end(), result.begin(),
                     std::bind2nd(std::multiplies<Type>(), scalar));
      return result;
    }

    template <class Type>
    Array2D<Type> operator/(const Array2D<Type>& array0, Type scalar)
    {
      Array2D<Type> result(array0.rows(), array0.columns());
      std::transform(array0.begin(), array0.end(), result.begin(),
                     std::bind2nd(std::divides<Type>(), scalar));
      return result;
    }

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

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


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

    
    // Elementwise comparison of an Array2D with another array.
    template <class Type>
    Array2D<bool>
    operator==(const Array2D<Type>& array0, const Array2D<Type>& array1)
    {
      array0.checkDimension(array1.rows(), array1.columns());
      Array2D<bool> result(array0.rows(), array0.columns());
      std::transform(array0.begin(), array0.end(), array1.begin(),
                     result.begin(), std::equal_to<Type>());
      return result;
    }

  
    template <class Type>
    Array2D<bool> operator>(const Array2D<Type>& array0, Type arg)
    {
      Array2D<bool> result(array0.rows(), array0.columns());
      std::transform(array0.begin(), array0.end(), result.begin(),
                     std::bind2nd(std::greater<Type>(), arg));
      return result;
    }

    template <class Type>
    Array2D<bool> operator<(const Array2D<Type>& array0, Type arg)
    {
      Array2D<bool> result(array0.rows(), array0.columns());
      std::transform(array0.begin(), array0.end(), result.begin(),
                     std::bind2nd(std::less<Type>(), arg));
      return result;
    }

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

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

    template <class Type>
    std::ostream& operator<<(std::ostream& stream, const Array2D<Type>& array0)
    {
      // Most of the time, OutputType will be the same as Type.
      typedef typename NumericTraits<Type>::TextOutputType OutputType;

      stream << "Array2D([[";
      for(size_t row = 0; row < array0.rows(); ++row) {
        if (array0.columns() > 0) {
          for(size_t column = 0; column < array0.columns() - 1; ++column) {
            stream << static_cast<OutputType>(array0(row, column)) << ", ";
          }
          stream << static_cast<OutputType>(array0(row, array0.columns() - 1));
          if(row != array0.rows() - 1) {
            stream << "],\n";
            stream << "         [";
          }
        }
      } 
      stream << "]])";
      stream.flush();
      return stream;
    }

  
    template <class Type>
    std::istream& operator>>(std::istream& inputStream, Array2D<Type>& array0)
    {
      return array0.readFromStream(inputStream);
    }
  
  } // namespace numeric

} // namespace dlr

#endif /* #ifdef _DLR_ARRAY2D_H_ */

---