toolbox/stiffArray.hh

Go to the documentation of this file.

/* Stiff array which suites for applications where the 
   length is important to have as a template parameter,
   e.g. for MultiIndex
 */

#ifndef stiffArray_hh
#define stiffArray_hh

#include "toolbox/array.hh"
#include "basics/debug.hh"

#define StiffArrayConstr_D 0
#define StiffArrayDestr_D 0

namespace concepts {

  // *********************************************************** StiffArray ** 

  template<uint dim, class F>
  class StiffArray : public OutputOperator {
  public:
    StiffArray() : data_(new F[dim]) {}
    StiffArray(const F& dft) : data_(new F[dim]) { *this = dft; }
    StiffArray(const Array<F>& dft) : data_(new F[dim]) {
      memorycpy(data_, (const F*)dft, dim);
      conceptsAssert(dft.size() == dim, Assertion());
    }
    template<class H>
    StiffArray(const StiffArray<dim,H>& a, F fnc(const H&)) 
      : data_(new F[dim]) {
      F* d = data_; const H* e = (const H*)a; 
      for(uint i = dim; i--;) *d++ = fnc(*e++);
    }
    template<class H>
    StiffArray(const StiffArray<dim,H>& a, const F& fnc(const H&)) 
      : data_(new F[dim]) {
      F* d = data_; const H* e = (const H*)a; 
      for(uint i = dim; i--;) *d++ = fnc(*e++);
    }
    StiffArray(const StiffArray<dim,F>& a) : data_(new F[dim]) {
      std::memcpy(data_, a.data_, dim*sizeof(F));
    }
    ~StiffArray() {
      DEBUGL(StiffArrayDestr_D, "data = " << data_);
      delete[] data_;
      DEBUGL(StiffArrayDestr_D, "done.");
    }
    uint length() { return dim; }
    void zeros() { std::memset(data_, 0, dim*sizeof(F)); }
    operator F*() { return data_; }
    operator const F*() const { return data_; }

    operator Array<F>() const { return Array<F>(data_,dim); }

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

    StiffArray<dim,F>& operator*=(const F n) {
      F* d = data_; for(uint i = dim; i--;) *d++ *= n;
      return *this;
    }
    StiffArray<dim,F>& operator/=(const F n) {
      F* d = data_; for(uint i = dim; i--;) *d++ /= n;
      return *this;
    }
    StiffArray<dim,F>& operator=(const F n) {
      F* d = data_; for(uint i = dim; i--;) *d++ = n;
      return *this;
    }
    StiffArray<dim,F>& operator+=(const F n) {
      F* d = data_; for(uint i = dim; i--;) *d++ += n;
      return *this;
    }
    StiffArray<dim,F>& operator-=(const F n) {
      F* d = data_; for(uint i = dim; i--;) *d++ -= n;
      return *this;
    }
    StiffArray<dim,F>& operator*=(const StiffArray<dim,F>& a) {
      F* d = data_; const F* e = (const F*)a;
      for(uint i = dim; i--;) *d++ *= *e++;
      return *this;
    }
    StiffArray<dim,F>& apply(F& fnc(F&)) {
      F* d = data_; for(uint i = dim; i--;) *d = fnc(*d++);
      return *this;
    }
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    F* data_;
  };

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

  // ****************************************************** StiffArray<1,F> ** 

  template<class F>
  class StiffArray<1,F> : public OutputOperator {
  public:
    StiffArray() {}
    StiffArray(const F& dft) : data_(dft) {}
    StiffArray(const Array<F>& dft)  {
      conceptsAssert(dft.size() == 1, Assertion());
      data_ = dft[0];
    }
    template<class H>
    StiffArray(const StiffArray<1,H>& a, F fnc(const H&)) {
      data_ = fnc(a);
    }      
    StiffArray(const StiffArray<1,F>& a) : data_(a.data_) {}
    ~StiffArray() {
      DEBUGL(StiffArrayDestr_D, "done.");
    }
    uint length() { return 1; }
    void zeros() { data_ = 0; }
    operator F() const { return data_; }

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

    StiffArray<1,F>& operator*=(const F n) {
      data_ *= n; return *this;
    }
    StiffArray<1,F>& operator/=(const F n) {
      data_ /= n; return *this;
    }
    StiffArray<1,F>& operator=(const F n) {
      data_ = n; return *this;
    }
    StiffArray<1,F>& operator+=(const F n) {
      data_ += n; return *this;
    }
    StiffArray<1,F>& operator-=(const F n) {
      data_ -= n; return *this;
    }
    StiffArray<1,F>& apply(F& fnc(F&)) {
      data_ = fnc(data_); return *this;
    }
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    F data_;
  };

  template<class F>
  std::ostream& StiffArray<1, F>::info(std::ostream& os) const {
    return os << "StiffArray<1, F>([" << data_ << "])";
  }

  // ****************************************************** StiffArray<0,F> ** 

  template<class F>
  class StiffArray<0,F> : public OutputOperator {
  public:
    StiffArray() { throw conceptsException
         (concepts::MissingFeature("makes no sense")); }
  };


} // namespace concepts

#endif // stiffArray_hh