ArrayContainer.h

Go to the documentation of this file.

// -*- C++ -*-

#if !defined(__ArrayContainer_h__)
#define __ArrayContainer_h__

// If we are debugging the whole ads package.
#if defined(DEBUG_ads) && !defined(DEBUG_ArrayContainer)
#define DEBUG_ArrayContainer
#endif

#include "ArrayTypes.h"

// For Int2Type.
#include "../../third-party/loki/TypeManip.h"

#include <iosfwd>
#include <iostream>
#include <numeric>
#include <algorithm>
#include <limits>

#include <cassert>
#include <cmath>

BEGIN_NAMESPACE_ADS


template<typename T = double, bool A = true>
class ArrayContainer
{
private:

  //
  // Private types.
  //

  typedef ArrayTypes<T> types;

public:

  //
  // Public types.
  //

  typedef typename types::value_type value_type;

  typedef typename types::parameter_type parameter_type;

  typedef typename types::unqualified_value_type unqualified_value_type;

  typedef typename types::pointer pointer;
  typedef typename types::const_pointer const_pointer;

  typedef typename types::iterator iterator;
  typedef typename types::const_iterator const_iterator;

  typedef typename types::reference reference;
  typedef typename types::const_reference const_reference;


  typedef typename types::size_type size_type;
  typedef typename types::difference_type difference_type;

private:

  //
  // Private data.
  //

  // The start of the data.
  pointer _start;
  // The end of the data.
  pointer _finish;
  // Number of elements in the array.
  size_type _size;

protected:

  //--------------------------------------------------------------------------
  // @{

  ArrayContainer() :
    _start(0),
    _finish(0),
    _size(0)
  {}

  // Copy constructor.
  ArrayContainer(const ArrayContainer& x) :
    _start(0),
    _finish(0),
    _size(0) {
    copy(x);
  }

  // Copy constructor for an array of different type or allocation policy.
  template<typename T2, bool A2>
  ArrayContainer(const ArrayContainer<T2,A2>& x) :
    _start(0),
    _finish(0),
    _size(0) {
    copy(x);
  }


  ArrayContainer& 
  operator=(const ArrayContainer& other) {
    if (&other != this) {
      copy(other);
    }
    return *this;
  }


  template<typename T2, bool A2>
  ArrayContainer& 
  operator=(const ArrayContainer<T2,A2>& x) {
    // No need to check if *this and x are the same.
    copy(x);
    return *this;
  }


  template<typename ForwardIterator>
  ArrayContainer(ForwardIterator start, ForwardIterator finish) :
    _start(0),
    _finish(0),
    _size(0) {
    copy_range(start, finish);
  }


  template<typename ForwardIterator>
  void
  rebuild(ForwardIterator start, ForwardIterator finish) {
    copy_range(start, finish);
  }
  

  template<typename Type>
  ArrayContainer(Type* start, Type* finish) :
    _start(0),
    _finish(0),
    _size(0) {
    copy_range(start, finish);
  }


  template<typename Type>
  void
  rebuild(Type* start, Type* finish) {
    copy_range(start, finish);
  }
  

  explicit
  ArrayContainer(const size_type size) :
    _start(0),
    _finish(0),
    _size(size) {
    allocate();
    _finish = _start + _size;
  }


  void
  rebuild(const size_type size) {
    _size = size;
    allocate();
    _finish = _start + _size;
  }

  void
  swap(ArrayContainer& other) {
    if (&other != this) {
      std::swap(_start, other._start);
      std::swap(_finish, other._finish);
      std::swap(_size, other._size);
    }
  }

  void
  resize(const size_type size) {
    resize(size, Loki::Int2Type<A>());
  }
  
  ~ArrayContainer() {
    destroy();
  }

  // @}

public:

  //--------------------------------------------------------------------------
  // @{

  size_type 
  size() const {
    return _size;
  }

  bool 
  empty() const { 
    return _size == 0;
  }

  size_type
  max_size() const { 
    return std::numeric_limits<int>::max() / sizeof(value_type); 
  }

  const_iterator 
  begin() const { 
    return _start;
  }

  const_iterator 
  end() const { 
    return _finish;
  }


  pointer
  data() const { 
    return _start;
  }


  parameter_type 
  operator[](const int i) const {
#ifdef DEBUG_ArrayContainer
    assert(0 <= i && i < _size);
#endif 
    return _start[i]; 
  }


  size_type 
  getMemoryUsage() const {
    return sizeof(ArrayContainer) + size() * sizeof(value_type);
  }

  // @}
  //--------------------------------------------------------------------------
  // @{

  iterator 
  begin() { 
    return _start;
  }

  iterator 
  end() { 
    return _finish;
  }

  pointer
  data() { 
    return _start;
  }


  reference 
  operator[](const int i) { 
#ifdef DEBUG_ArrayIndexing
    assert(0 <= i && i < size());
#endif 
    return _start[i]; 
  }

  void
  negate();

  void
  fill(parameter_type value);

  // @}
  //--------------------------------------------------------------------------
  // @{

  ArrayContainer& 
  operator=(parameter_type x);

  // @}
  //--------------------------------------------------------------------------
  // @{

  //CONTINUE: Should I make these free functions?
  template<typename T2, bool A2>
  bool
  operator==(const ArrayContainer<T2,A2>& x) const {
    // Check that the arrays have the same size.
    if (size() != x.size()) {
      return false;
    }
    // Check each of the components.
    return std::equal(begin(), end(), x.begin());
  }

  template<typename T2, bool A2>
  bool
  operator!=(const ArrayContainer<T2,A2>& x) const {
    return ! operator==(x);
  }

  // @}
  //--------------------------------------------------------------------------
  // @{

  void
  put(std::ostream& out) const {
    for (const_iterator iter = begin(); iter != end(); ++iter) {
      out << *iter << '\n';
    }
  }  

  void
  get(std::istream& in) {
    for (iterator iter = begin(); iter != end(); ++iter) {
      in >> *iter;
    }
  }

  void
  write(std::ostream& out) const {
    out.write(reinterpret_cast<const char*>(begin()), 
               size() * sizeof(value_type));
  }

  void
  write_elements_ascii(std::ostream& out) const {
    put(out);
  }

  void
  write_elements_binary(std::ostream& out) const {
    write(out);
  }

  void
  read(std::istream& in) {
    in.read(reinterpret_cast<char*>(begin()), 
             size() * sizeof(value_type));
    assert(in.gcount() == size_type(size() * sizeof(value_type)));
  }

  void
  read_elements_ascii(std::istream& in) {
    get(in);
  }

  void
  read_elements_binary(std::istream& in) {
    read(in);
  }

  // @}

private:

  //
  // Private member functions.
  //

  void
  resize(const size_type size, Loki::Int2Type<true>) {
    // If we need to resize this array.
    if (_size != size) {
      // Deallocate the old memory.
      destroy();
      // Set the size.
      _size = size;
      // Allocate new memory.
      allocate();
    }
    // Define the end of storage.
    _finish = _start + _size;
  }
  
  template<typename T2, bool A2>
  void
  copy(const ArrayContainer<T2,A2>& x) {
    copy_range(x.data(), x.data() + x.size());
  }
  
  template<typename ForwardIterator>
  void
  copy_range(ForwardIterator start, ForwardIterator finish) {
    copy_range(start, finish, Loki::Int2Type<A>());
  }

  template<typename ForwardIterator>
  void
  copy_range(ForwardIterator start, ForwardIterator finish, 
             Loki::Int2Type<true>) {
    // Resize the array if necessary.
    resize(std::distance(start, finish));
    // Copy the elements.
    std::copy(start, finish, _start);
  }

  template<typename RandomAccessIterator>
  void
  copy_range(RandomAccessIterator start, RandomAccessIterator finish, 
             Loki::Int2Type<false>) {
    _start = start;
    _finish = finish;
    _size = size_type(finish - start);
  }

  void
  allocate() {
    allocate(Loki::Int2Type<A>());
  }

  // Allocate the memory.
  void
  allocate(Loki::Int2Type<true>) {
    if (_size == 0) {
      _start = 0;
    }
    else {
      _start = new value_type[_size];
    }
  }

  // allocate(Loki::Int2Type<false>) is intentionally not implemented.

  // Allocate the memory.
  /*
  void
  allocate()
  {
    STATIC_CHECK(A == true, Trying_to_allocate_memory_when_A_is_false);
    
    if (_size == 0) {
      _start = 0;
    }
    else {
      _start = new value_type[ _size ];
    }
  }
  */

  void
  destroy() {
    deallocate();
    _start = 0;
    _finish = 0;
    _size = 0;
  }

  void
  deallocate() {
    deallocate(Loki::Int2Type<A>());
  }

  // Deallocate the memory.
  void
  deallocate(Loki::Int2Type<true>) {
    if (_size != 0) {
      delete[] _start;
    }
  }

  // No need to deallocate memory for array references.
  void
  deallocate(Loki::Int2Type<false>)
  {}
};


//-----------------------------------------------------------------------------

//
// Mathematical functions
//


template<typename T, bool A>
inline
T
computeSum(const ArrayContainer<T,A>& x) {
  return std::accumulate(x.begin(), x.end(), T(0));
}
    

template<typename T, bool A>
inline
T
computeProduct(const ArrayContainer<T,A>& x) {
  return std::accumulate(x.begin(), x.end(), T(1), std::multiplies<T>());
}


template<typename T, bool A>
inline
T
computeMinimum(const ArrayContainer<T,A>& x) {
  // Check the case that the array is empty.  In this case we can't dereference
  // the iterator as we do below.
  if (x.empty()) {
    return std::numeric_limits<T>::max();
  }
  return *std::min_element(x.begin(), x.end());
}
    

template<typename T, bool A>
inline
T
computeMaximum(const ArrayContainer<T,A>& x) {
  // Check the case that the array is empty.  In this case we can't dereference
  // the iterator as we do below.
  if (x.empty()) {
    return - std::numeric_limits<T>::max();
  }
  return *std::max_element(x.begin(), x.end());
}

//
// Apply the standard math functions.
//

// CONTINUE: Should I relate it to the other classes as well?

template<typename T, bool A>
inline
void
applyAbs(ArrayContainer<T,A>* x) {
  for (typename ArrayContainer<T,A>::iterator i = x->begin(); i != x->end(); 
       ++i) {
    *i = std::abs(*i);
  }
}


template<typename T, bool A>
inline
void
applyAcos(ArrayContainer<T,A>* x) {
  for (typename ArrayContainer<T,A>::iterator i = x->begin(); i != x->end(); 
       ++i) {
    *i = std::acos(*i);
  }
}


template<typename T, bool A>
inline
void
applyAsin(ArrayContainer<T,A>* x) {
  for (typename ArrayContainer<T,A>::iterator i = x->begin(); i != x->end(); 
       ++i) {
    *i = std::asin(*i);
  }
}


template<typename T, bool A>
inline
void
applyAtan(ArrayContainer<T,A>* x) {
  for (typename ArrayContainer<T,A>::iterator i = x->begin(); i != x->end(); 
       ++i) {
    *i = std::atan(*i);
  }
}


template<typename T, bool A>
inline
void
applyCeil(ArrayContainer<T,A>* x) {
  for (typename ArrayContainer<T,A>::iterator i = x->begin(); i != x->end(); 
       ++i) {
    *i = std::ceil(*i);
  }
}


template<typename T, bool A>
inline
void
applyCos(ArrayContainer<T,A>* x) {
  for (typename ArrayContainer<T,A>::iterator i = x->begin(); i != x->end(); 
       ++i) {
    *i = std::cos(*i);
  }
}


template<typename T, bool A>
inline
void
applyCosh(ArrayContainer<T,A>* x) {
  for (typename ArrayContainer<T,A>::iterator i = x->begin(); i != x->end(); 
       ++i) {
    *i = std::cosh(*i);
  }
}


template<typename T, bool A>
inline
void
applyExp(ArrayContainer<T,A>* x) {
  for (typename ArrayContainer<T,A>::iterator i = x->begin(); i != x->end(); 
       ++i) {
    *i = std::exp(*i);
  }
}


template<typename T, bool A>
inline
void
applyFloor(ArrayContainer<T,A>* x) {
  for (typename ArrayContainer<T,A>::iterator i = x->begin(); i != x->end(); 
       ++i) {
    *i = std::floor(*i);
  }
}


template<typename T, bool A>
inline
void
applyLog(ArrayContainer<T,A>* x) {
  for (typename ArrayContainer<T,A>::iterator i = x->begin(); i != x->end(); 
       ++i) {
    *i = std::log(*i);
  }
}


template<typename T, bool A>
inline
void
applyLog10(ArrayContainer<T,A>* x) {
  for (typename ArrayContainer<T,A>::iterator i = x->begin(); i != x->end(); 
       ++i) {
    *i = std::log10(*i);
  }
}


template<typename T, bool A>
inline
void
applySin(ArrayContainer<T,A>* x) {
  for (typename ArrayContainer<T,A>::iterator i = x->begin(); i != x->end(); 
       ++i) {
    *i = std::sin(*i);
  }
}


template<typename T, bool A>
inline
void
applySinh(ArrayContainer<T,A>* x) {
  for (typename ArrayContainer<T,A>::iterator i = x->begin(); i != x->end(); 
       ++i) {
    *i = std::sinh(*i);
  }
}


template<typename T, bool A>
inline
void
applySqrt(ArrayContainer<T,A>* x) {
  for (typename ArrayContainer<T,A>::iterator i = x->begin(); i != x->end(); 
       ++i) {
    *i = std::sqrt(*i);
  }
}


template<typename T, bool A>
inline
void
applyTan(ArrayContainer<T,A>* x) {
  for (typename ArrayContainer<T,A>::iterator i = x->begin(); i != x->end(); 
       ++i) {
    *i = std::tan(*i);
  }
}


template<typename T, bool A>
inline
void
applyTanh(ArrayContainer<T,A>* x) {
  for (typename ArrayContainer<T,A>::iterator i = x->begin(); i != x->end(); 
       ++i) {
    *i = std::tanh(*i);
  }
}

//
// Assignment operators with scalar operand.
//

template<typename T, bool A>
ArrayContainer<T,A>& 
operator+=(ArrayContainer<T,A>& array, 
           typename ArrayContainer<T,A>::parameter_type x);

template<typename T, bool A>
ArrayContainer<T,A>& 
operator-=(ArrayContainer<T,A>& array, 
           typename ArrayContainer<T,A>::parameter_type x);

template<typename T, bool A>
ArrayContainer<T,A>& 
operator*=(ArrayContainer<T,A>& array, 
           typename ArrayContainer<T,A>::parameter_type x);

template<typename T, bool A>
ArrayContainer<T,A>& 
operator/=(ArrayContainer<T,A>& array, 
           typename ArrayContainer<T,A>::parameter_type x);

template<typename T, bool A>
ArrayContainer<T,A>& 
operator%=(ArrayContainer<T,A>& array, 
           typename ArrayContainer<T,A>::parameter_type x);

template<typename T, bool A>
ArrayContainer<T*,A>& 
operator+=(ArrayContainer<T*,A>& array, 
           typename ArrayContainer<T*,A>::difference_type x);

template<typename T, bool A>
ArrayContainer<T*,A>& 
operator-=(ArrayContainer<T*,A>& array, 
           typename ArrayContainer<T*,A>::difference_type x);

//--------------------------------------------------------------------------
// Assignment operators with array operand.
//--------------------------------------------------------------------------

template<typename T1, bool A1, typename T2, bool A2>
ArrayContainer<T1,A1>& 
operator+=(ArrayContainer<T1,A1>& x, const ArrayContainer<T2,A2> & y);

template<typename T1, bool A1, typename T2, bool A2>
ArrayContainer<T1,A1>& 
operator-=(ArrayContainer<T1,A1>& x, const ArrayContainer<T2,A2> & y);

template<typename T1, bool A1, typename T2, bool A2>
ArrayContainer<T1,A1>& 
operator*=(ArrayContainer<T1,A1>& x, const ArrayContainer<T2,A2> & y);

template<typename T1, bool A1, typename T2, bool A2>
ArrayContainer<T1,A1>& 
operator/=(ArrayContainer<T1,A1>& x, const ArrayContainer<T2,A2> & y);

template<typename T1, bool A1, typename T2, bool A2>
ArrayContainer<T1,A1>& 
operator%=(ArrayContainer<T1,A1>& x, const ArrayContainer<T2,A2> & y);

//
// Equality Operators
//    

// CONTINUE
#if 0


template<typename T1, typename T2, bool A1, bool A2>
bool
operator==(const ArrayContainer<T1,A1>& a, const ArrayContainer<T2,A2>& b) {
  return a.operator==(b);
}


template<typename T1, typename T2, bool A1, bool A2>
inline
bool
operator!=(const ArrayContainer<T1,A1>& a, const ArrayContainer<T2,A2>& b) { 
  return !(a == b); 
}
#endif


END_NAMESPACE_ADS

#define __ArrayContainer_ipp__
#include "ArrayContainer.ipp"
#undef __ArrayContainer_ipp__

#endif

---