array1D.h

Go to the documentation of this file.

#ifndef _DLR_ARRAY1D_H_
#define _DLR_ARRAY1D_H_

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

namespace dlr {


  namespace numeric {
    
    template <class Type>
    class Array1D {
    public:
      /* ======== Public typedefs ======== */

      typedef Type value_type;

      typedef Type* iterator;
    
      typedef const Type* const_iterator;

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

      Array1D();
    
      explicit
      Array1D(size_t size);

      explicit
      Array1D(const std::string& inputString);
    
      Array1D(const Array1D<Type> &source);
    
      Array1D(size_t size, Type* const dataPtr);
    
      Array1D(size_t size, Type* const dataPtr, size_t* const refCountPtr);
    
      ~Array1D();

      iterator
      begin() {return m_dataPtr;}

      const_iterator
      begin() const {return m_dataPtr;}


      inline void
      checkDimension(size_t size) const;

    
      void
      clear() {this->reinit(0);}
    
      Array1D<Type>
      copy() const;

      template <class Type2> void
      copy(const Array1D<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;
      }


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

    
      iterator
      end() {return m_dataPtr + m_size;}

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

      bool
      isAllocated() const {return m_isAllocated;}

      size_t
      length() const {return this->size();}

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

      size_t*
      refCountPtr() const {return m_refCountPtr;}
    
      void
      reinit(size_t size);
    
      size_t
      size() const {return m_size;}
  
      Array1D<Type>&
      operator=(const Array1D<Type>& source);

      Array1D<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 index) {return this->operator()(index);}

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

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

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

      Array1D<Type>&
      operator-=(const Type arg);

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

      Array1D<Type>&
      operator*=(const Type arg);

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

      Array1D<Type>&
      operator/=(const Type arg);

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

      void
      allocate();

      inline void
      checkBounds(size_t index) 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_size;
      Type* m_dataPtr;
      size_t* m_refCountPtr;
      bool m_isAllocated;

    };

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

    template <class Type>
    Array1D<Type>
    operator+(const Array1D<Type>& array0, const Array1D<Type>& array1);
  
    template <class Type>
    Array1D<Type>
    operator-(const Array1D<Type>& array0, const Array1D<Type>& array1);

    template <class Type>
    Array1D<Type>
    operator*(const Array1D<Type>& array0, const Array1D<Type>& array1);
  
    template <class Type>
    Array1D<Type>
    operator/(const Array1D<Type>& array0, const Array1D<Type>& array1);

    template <class Type>
    Array1D<Type> operator+(const Array1D<Type>& array, Type scalar);

    template <class Type>
    Array1D<Type> operator-(const Array1D<Type>& array0, Type scalar);

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

    template <class Type>
    Array1D<Type> operator/(const Array1D<Type>& array0, Type scalar);

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


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

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

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


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

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

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

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


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


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

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

    template <class Type>
    std::istream&
    operator>>(std::istream& stream, Array1D<Type>& array0);

  } // namespace numeric

} // namespace dlr


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

namespace dlr {

  using numeric::Array1D;

} // namespace dlr


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

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

namespace dlr {

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


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

    // Non-static member functions below.

    template <class Type>
    Array1D<Type>::
    Array1D()
      : m_size(0),
        m_dataPtr(0),
        m_refCountPtr(0),
        m_isAllocated(false)
    {
      // Empty.
    }

  
    template <class Type>
    Array1D<Type>::
    Array1D(size_t size)
      : m_size(size),
        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>
    Array1D<Type>::
    Array1D(const std::string& inputString)
      : 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.
      Array1D<Type> inputArray;
      inputStream >> inputArray;
      if(!inputStream) {
        std::ostringstream message;
        message << "Couldn't parse input string: \"" << inputString << "\".";
        DLR_THROW3(ValueException, "Array1D::Array1D(const std::string&)",
                   message.str().c_str());                 
      }

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

  
    /* When copying from a Array1D do a shallow copy */
    /* Update reference count if the array we're copying has */
    /* valid data. */
    template <class Type>
    Array1D<Type>::
    Array1D(const Array1D<Type>& source)
      : 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);
      }
    }


    template <class Type>
    Array1D<Type>::
    Array1D(size_t size, Type* const dataPtr)
      : m_size(size),
        m_dataPtr(dataPtr),
        m_refCountPtr(NULL),
        m_isAllocated(false)
    {
      // empty
    }


    template <class Type>
    Array1D<Type>::
    Array1D(size_t size, Type* const dataPtr, size_t* const refCountPtr)
      : m_size(size),
        m_dataPtr(dataPtr),
        m_refCountPtr(refCountPtr),
        m_isAllocated(true)
    {
      ++(*m_refCountPtr);
    }


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


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


    template <class Type>
    Array1D<Type> Array1D<Type>::
    copy() const
    {
      Array1D<Type> newArray(m_size);
      newArray.copy(*this);
      return newArray;
    }

  
    template <class Type> template <class Type2>
    void Array1D<Type>::
    copy(const Array1D<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, "Array1D::copy(const Array1D&)",
                   message.str().c_str());
      }
      if(m_size != 0) {
        this->copy(source.data());
      }
    }

  
    template <class Type> template <class Type2>
    void
    Array1D<Type>::
    copy(const Type2* dataPtr)
    {
      std::copy(dataPtr, dataPtr + m_size, m_dataPtr);
    }


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


    // This member function sets the value of the array from an input
    // stream.
    template <class Type>
    std::istream&
    Array1D<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);

        stream.skipWhiteSpace();
      
        // We won't require the input format to start with "Array1D(", 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 "[#, #, #, ...]".  We require the square brackets to
        // be there.
        stream.expect(ioOpening);

        // Read the data.
        InputType inputValue;
        std::vector<Type> inputBuffer;
        while(1) {
          // Read the next value.
          stream >> inputValue;
          inputBuffer.push_back(static_cast<Type>(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.  Copy the data to *this.
        this->reinit(inputBuffer.size());
        std::copy(inputBuffer.begin(), inputBuffer.end(), this->begin());

      } catch(std::ios_base::failure) {
        // Empty
      }
      inputStream.exceptions(oldExceptionState);
      return inputStream;
    }
  

    template <class Type>
    void Array1D<Type>::
    reinit(size_t size)
    {
      this->deAllocate();
      this->m_size = size;
      this->allocate();
    }
  

    template <class Type>
    Array1D<Type>& Array1D<Type>::
    operator=(const Array1D<Type>& source)
    {
      // Check for self-assignment
      if(&source != this) {
        this->deAllocate();
        m_size = source.m_size;
        m_dataPtr = source.m_dataPtr;
        m_refCountPtr = source.m_refCountPtr;
        m_isAllocated = source.m_isAllocated;
        // Update reference count, if appropriate.
        if(m_isAllocated) {
          ++(*m_refCountPtr);
        }
      }
      return *this;
    }


    template <class Type> template <class Type2>
    Array1D<Type>&
    Array1D<Type>::
    operator+=(const Array1D<Type2>& arg)
    {
      if(m_size != arg.size()) {
        std::ostringstream message;
        message << "Mismatched array sizes. Argument array has "
                << arg.size() << " elements, while destination array has "
                << m_size << " elements.";
        DLR_THROW3(ValueException, "Array1D::operator+=(const Array1D&)",
                   message.str().c_str());
      }
      std::transform(m_dataPtr, m_dataPtr + m_size, arg.data(), m_dataPtr,
                     std::plus<Type>());
      return *this;
    }


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


    template <class Type> template <class Type2>
    Array1D<Type>&
    Array1D<Type>::
    operator-=(const Array1D<Type2>& arg)
    {
      if(m_size != arg.size()) {
        std::ostringstream message;
        message << "Mismatched array sizes. Argument array has "
                << arg.size() << " elements, while destination array has "
                << m_size << " elements.";
        DLR_THROW3(ValueException, "Array1D::operator-=(const Array1D&)",
                   message.str().c_str());
      }
      std::transform(m_dataPtr, m_dataPtr + m_size, arg.data(), m_dataPtr,
                     std::minus<Type>());
      return *this;
    }


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


    template <class Type> template <class Type2>
    Array1D<Type>&
    Array1D<Type>::
    operator*=(const Array1D<Type2>& arg)
    {
      if(m_size != arg.size()) {
        std::ostringstream message;
        message << "Mismatched array sizes. Argument array has "
                << arg.size() << " elements, while destination array has "
                << m_size << " elements.";
        DLR_THROW3(ValueException, "Array1D::operator*=(const Array1D&)",
                   message.str().c_str());
      }
      std::transform(m_dataPtr, m_dataPtr + m_size, arg.data(), m_dataPtr,
                     std::multiplies<Type>());
      return *this;
    }


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


    template <class Type> template <class Type2>
    Array1D<Type>&
    Array1D<Type>::
    operator/=(const Array1D<Type2>& arg)
    {
      if(m_size != arg.size()) {
        std::ostringstream message;
        message << "Mismatched array sizes. Argument array has "
                << arg.size() << " elements, while destination array has "
                << m_size << " elements.";
        DLR_THROW3(ValueException, "Array1D::operator/=(const Array1D&)",
                   message.str().c_str());
      }
      std::transform(m_dataPtr, m_dataPtr + m_size, arg.data(), m_dataPtr,
                     std::divides<Type>());
      return *this;
    }


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


    template <class Type>
    void Array1D<Type>::
    allocate()
    {
      // First check array size.  It doesn't make sense to allocate memory
      // for a zero size array.
      if(m_size > 0) {
        // Allocate data storage, and a new reference count.  new() should
        // throw an exception if we run out of memory.
        m_dataPtr = new(Type[m_size]);
        m_refCountPtr = new size_t;
        // Set reference count to show that exactly one Array is pointing
        // to this data.
        *m_refCountPtr = 1;
        m_isAllocated = true;
      } else {
        // Array size is zero, so no need to allocate memory.
        m_dataPtr = 0;
        m_refCountPtr = 0;
        m_isAllocated = false;
      }
      return;
    }


    template <class Type>
    inline void Array1D<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_size
                << " element array.";
        DLR_THROW(IndexException, "Array1D::checkBounds()",
                  message.str().c_str());
      }
#endif
    }


    template <class Type>
    void Array1D<Type>::
    deAllocate()
    {
      // Are we responsible for deallocating the contents of this array?
      if(m_isAllocated == true) {
        // If yes, are we currently the only array pointing to this data?
        if(--(*m_refCountPtr) == 0) {
          // If yes, then delete both data and reference count, and change
          // m_isAllocated to reflect this.
          delete[] m_dataPtr;
          delete m_refCountPtr;
          m_isAllocated = false;
        }
      }
      // Abandon our pointers to data and reference count.
      m_dataPtr = 0;
      m_refCountPtr = 0;
    }

    /* Non-member functions which should maybe wind up in a different file? */
  
    template <class Type>
    Array1D<Type> operator+(const Array1D<Type>& array0,
                            const Array1D<Type>& array1)
    {
      if(array0.size() != array1.size()) {
        std::ostringstream message;
        message << "Array sizes do not match.  Array0 has " << array0.size()
                << " elements, while array1 has " << array1.size()
                << " elements.";
        DLR_THROW(ValueException, "Array1D::operator+()", message.str().c_str());
      }
      Array1D<Type> result(array0.size());
      std::transform(array0.begin(), array0.end(), array1.begin(),
                     result.begin(), std::plus<Type>());
      return result;
    }


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


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


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


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


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


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


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


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


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

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

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

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

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

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

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


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


    template <class Type>
    Array1D<bool>
    operator<=(const Array1D<Type>& array0, const Type arg)
    {
      Array1D<bool> result(array0.size());
      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 Array1D<Type>& array0)
    {
      // Most of the time, OutputType will be the same as Type.
      typedef typename NumericTraits<Type>::TextOutputType OutputType;
    
      if (!stream){
        DLR_THROW(IOException, "operator<<(std::ostream&, const Array1D&)",
                  "Invalid stream\n");
      }

      size_t index;
      stream << "Array1D([";
      if (array0.size() > 0){
        for(index = 0; index < array0.size() - 1; ++index) {
          stream << static_cast<OutputType>(array0(index)) << ", ";
        }
        stream << static_cast<OutputType>(array0(index));
      }
      stream << "])";
      return stream;
    }

    // Sets the value of an Array1D instance from a std::istream.
    template <class Type>
    std::istream& operator>>(std::istream& inputStream, Array1D<Type>& array0)
    {
      return array0.readFromStream(inputStream);
    }

  } // namespace numeric

} // namespace dlr

#endif // #ifdef _DLR_ARRAY1D_H_

---