toolbox/array.hh

Go to the documentation of this file.

/* Array which does enlarge on request, zero out and more.
 * In a sense a very minimalistic implementation of STLs vector.
 * It's mainly intended to be an exception safe way to have an array
 * of something. Especially suitable for vectors and matrices.
 */

#ifndef Array_hh
#define Array_hh

#include <cstring>
#include <memory>
#include <iostream>

#include "basics/typedefs.hh"
#include "basics/vectorsMatrices.hh"
#include "basics/exceptions.hh"
#include "basics/pointerOutput.hh"

// debugging
#define ArrayConstr_D 0
#define ArrayDestr_D 0

namespace concepts {

  // **************************************** Output operator for auto_ptr's **

  template<class F>
  std::ostream& operator<<(std::ostream& os, std::auto_ptr<F>& a) {
    return os << "std::auto_ptr output";
  }

  // ***************************************************************** Array **

  template<class F>
  class Array {
  public:
    Array(const uint sz = 0) : data_(sz ? new F[sz] : 0),
             size_(sz), n_(sz) {
      DEBUGL(ArrayConstr_D, "start: size = " << sz << ", data = " << data_);
    }
    Array(const uint sz, const F& dft) : data_(sz ? new F[sz] : 0),
           size_(sz), n_(sz) {
      F* d = data_; for(uint i = size_; i--;) *d++ = dft;
    }
    Array(const F* dft, const uint sz) : data_(sz ? new F[sz] : 0),
            size_(sz), n_(sz) {
      memorycpy(data_, dft, sz);
    }
    Array(const uint sz, const F& first, const F& diff) : 
      data_(sz ? new F[sz] : 0), size_(sz), n_(sz) {
      if (sz > 0) {
        F* d = data_, *e = data_;
        *d++ = first;
        for(uint i = sz - 1; i--;) *d++ = *e++ + diff;
      }
    }
    template<class H>
    Array(const Array<H>& a, F fnc(const H&)) : data_(0), size_(0), n_(0) {
      apply(a, fnc);
    }
    Array(const Array<F>& a) : data_(a.n_ ? new F[a.n_] : 0),
             size_(a.n_), n_(a.n_) {
      std::memcpy(data_, a.data_, n_*sizeof(F));
    }
    template<class H>
    Array(const Array<H>& a) : data_(0), size_(0), n_(0) { *this = a; }

    ~Array() {
      DEBUGL(ArrayDestr_D, "start: size = " << size_ << ", n = " << n_
       << ", data = " << data_);
      delete[] data_;
      DEBUGL(ArrayDestr_D, "done.");
    }

    void resize(const uint sz);
    void resizePreserve(const uint sz);
    void zeros() { std::memset(data_, 0, n_*sizeof(F)); }

    operator F*() { return data_; }
    operator const F*() const { return data_; }

    const F& operator[] (const int i) const { 
      conceptsAssert3(i < (int)size_, Assertion(),
          "i = " << i << ", size = " << size_);
      return data_[i];
    }
    F& operator[] (const int i) { 
      conceptsAssert3(i < (int)size_, Assertion(),
          "i = " << i << ", size = " << size_);
      return data_[i];
    }

    template<class G>
    Array<F>& operator*=(const G n) {
      F* d = data_; 
      for(uint i = size_; i--;) *d++ *= n;
      return *this;
    }

    template<class H>
    Array<F>& operator*=(const Array<H>& a) {
      conceptsAssert(n_ <= a.size(), Assertion()); 
      F* d = data_; const H* e = (const H*)a;
      for(uint i = n_; i--;) *d++ *= *e++;
      return *this;
    }
    
    Array<F>& operator=(const F n) {
      F* d = data_; for(uint i = size_; i--;) *d++ = n;
      return *this;
    }
    Array<F>& operator=(const Array<F>& a) {
      resize(a.size());
      std::memcpy(data_, a.data_, n_*sizeof(F));
      return *this;
    }
    template<class H>
    Array<F>& operator=(const Array<H>& a) {
      resize(a.size());
      F* d = data_; const H* e = (const H*)a;
      for(uint i = size_; i--;) *d++ = *e++;
      return *this;
    }
    Array<F>& operator+=(const F n) {
      F* d = data_; for(uint i = size_; i--;) *d++ += n;
      return *this;
    }
    template<class H>
    Array<F>& operator+=(const Array<H>& a) {
      if (size_ == 0 && a.size() > 0) *this = Array<F>(a.size(), F(0));
      F* d = data_; const H* e = (const H*)a;
      for(uint i = size_; i--;) *d++ += *e++;
      return *this;
    }
    Array<F>& operator-=(const F n) {
      F* d = data_; for(uint i = size_; i--;) *d++ -= n;
      return *this;
    }
    template<class H>
    Array<F>& operator-=(const Array<H>& a) {
      if (size_ == 0 && a.size() > 0) *this = Array<F>(a.size(), F(0));
      F* d = data_; const H* e = (const H*)a;
      for(uint i = size_; i--;) *d++ -= *e++;
      return *this;
    }
    Array<F> operator-() const {
      Array<F> a(size_);
      F* d = (F*)a; const F* e = data_;
      for(uint i = size_; i--;) *d++ = -*e++;
      return a;
    }
    Array<F>& apply(F& fnc(F&)) {
      F* d = data_; 
      for(uint i = size_; i--;++d) *d = fnc(*d);
      return *this;
    }
    template<class H>
    Array<F>& apply(const Array<H>& a, F fnc(const H&)) {
      resize(a.size());
      F* d = data_; const H* e = (const H*)a; 
      for(uint i = size_; i--; ++d) 
        *d = fnc(*e++);
      return *this;
    }
    template<class H>
    Array<F>& apply(const Array<H>& a, F fnc(const H&, const F&)) {
      resize(a.size());
      F* d = data_; const H* e = (const H*)a; 
      for(uint i = n_; i--;++d) { 
        *d = fnc(*e++, *d);
      }
      return *this;
    }

    uint size() const { return n_; }

    uint cursize() const { return size_;}

    int memory() const { return size_*sizeof(F); }

    Array<F>& reverse();

    std::ostream& info(std::ostream& os) const;
  protected:
    F* data_;
    uint size_;
    uint n_;
  };

  template<class F>
  void Array<F>::resize(const uint sz) {
    if (sz > size_) {
      if (size_ > 0) delete[] data_;
      data_ = new F[size_ = sz];
    }
    n_ = sz;
  }

  template<class F>
  void Array<F>::resizePreserve(const uint sz) {
    if (sz > size_) {
      F* data = new F[sz];
      std::memcpy(data, data_, n_*sizeof(F));
      delete[] data_;
      data_ = data;
      size_ = sz;
    }
    n_ = sz;
  }

  template<class F>
  std::ostream& Array<F>::info(std::ostream& os) const {
    os << "Array<F>(" << n_ << ", [";
    F* d = data_;
    for (uint i = n_; i--;)
      os << *d++ << ((i == 0) ? "" : ", ");
    return os << "])";
  }

  template<class F>
  Array<F>& Array<F>::reverse() {
    F *d = data_, *e = data_ + (n_-1);
    for(uint i = std::floor(double(n_)/2.0); i--; )
      std::swap(*d++, *e--);
    return *this;
  }

  template<class F>
  std::ostream& operator<<(std::ostream& os, const Array<F>& o) {
#ifdef DEBUG
    os << std::flush;
#endif
    return o.info(os);
  }

  template <class F>
  inline bool operator==(const Array<F>& x, const Array<F>& y)
  {
    uint n = x.size();
    if (n != y.size()) return false;
    const F* d = (const F*)x; const F* e = (const F*)y;
    for (uint i = n; i--;)
      if (*d++ != *e++) return false;
    return true;
  }

  template <class F>
  inline bool operator==(const Array<F>& x, F& y)
  {
    uint n = x.size();
    const F* d = (const F*)x;
    for (uint i = n; i--;)
      if (*d++ != y) return false;
    return true;
  }

  template <class F>
  inline bool operator==(F& y, const Array<F>& x)
  {
    return x == y;
  }

  template<class F, class G>
  concepts::Array<typename Combtype<F,G>::type>
  operator*(const concepts::Array<F>& array, const G& val) {
    concepts::Array<typename Combtype<F,G>::type> result(array.size());
    typename Combtype<F,G>::type* r = (typename Combtype<F,G>::type*)result;
    const F* a = (const F*)array;
    for(uint i = array.size(); i--;) *r++ = *a++ * val;
    return result;
  }

  template<class F, class G>
  Array<typename Combtype<F,G>::type>
  operator*(const G& val, const Array<F>& array) {
    return array * val;
  }

  // ************************************************************** Realtype **

  template<typename F>
  struct Realtype<Array<F> > {
    typedef typename Realtype<F>::type type;
  };

  template<class F>
  void pointerOutput(std::ostream& os, const Array<F>& array) {
    os << "Array<F>(" << array.size() << ", [";
    const F* d = (const F*)array;
    for (uint i = array.size(); i--;) {
      pointerOutput(os, *d++);
      os << ((i == 0) ? "" : ", ");
    }
    os << "])";
  }

} // namespace concepts

#endif // Array_hh