matpackIV.h

Go to the documentation of this file.

/* Copyright (C) 2002-2012
   Stefan Buehler <sbuehler@ltu.se>
   Wolfram-Andre Haas <wolhaas@hermes.fho-emden.de>

   This program is free software; you can redistribute it and/or modify it
   under the terms of the GNU General Public License as published by the
   Free Software Foundation; either version 2, or (at your option) any
   later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
   USA. */

#ifndef matpackIV_h
#define matpackIV_h

#include "matpackIII.h"

class Iterator4D {
 public:
  // Constructors:
  Iterator4D() = default;

  Iterator4D(const Tensor3View& x, Index stride)
      : msv(x), mstride(stride) { /* Nothing to do here. */
  }

  // Operators:
  Iterator4D& operator++() {
    msv.mdata += mstride;
    return *this;
  }

  bool operator!=(const Iterator4D& other) const {
    if (msv.mdata + msv.mpr.mstart + msv.mrr.mstart + msv.mcr.mstart !=
        other.msv.mdata + other.msv.mpr.mstart + other.msv.mrr.mstart +
            other.msv.mcr.mstart)
      return true;
    else
      return false;
  }

  Tensor3View* operator->();
  Tensor3View& operator*();

 private:
  Tensor3View msv;
  Index mstride{0};
};

class ConstIterator4D {
 public:
  // Constructors:
  // Functions for ConstIterator4D
  // -----------------------------

  ConstIterator4D() = default;

  ConstIterator4D(const ConstTensor3View& x, Index stride)
      : msv(x), mstride(stride) { /* Nothing to do here. */
  }

  // Operators:
  ConstIterator4D& operator++() {
    msv.mdata += mstride;
    return *this;
  }

  bool operator!=(const ConstIterator4D& other) const {
    if (msv.mdata + msv.mpr.mstart + msv.mrr.mstart + msv.mcr.mstart !=
        other.msv.mdata + other.msv.mpr.mstart + other.msv.mrr.mstart +
            other.msv.mcr.mstart)
      return true;
    else
      return false;
  }

  const ConstTensor3View* operator->() const;
  const ConstTensor3View& operator*() const;

 private:
  ConstTensor3View msv;
  Index mstride{0};
};

// Declare class Tensor4:
class Tensor4;

class ConstTensor4View {
 public:
  constexpr ConstTensor4View(const ConstTensor4View&) = default;
  constexpr ConstTensor4View(ConstTensor4View&&) = default;
  ConstTensor4View& operator=(const ConstTensor4View&) = default;
  ConstTensor4View& operator=(ConstTensor4View&&) = default;

  // Member functions:

  bool empty() const;

  Index nbooks() const;
  Index npages() const;
  Index nrows() const;
  Index ncols() const;

  // Const index operators:
  ConstTensor4View operator()(const Range& b,
                              const Range& p,
                              const Range& r,
                              const Range& c) const;

  ConstTensor3View operator()(const Range& b,
                              const Range& p,
                              const Range& r,
                              Index c) const;
  ConstTensor3View operator()(const Range& b,
                              const Range& p,
                              Index r,
                              const Range& c) const;
  ConstTensor3View operator()(const Range& b,
                              Index p,
                              const Range& r,
                              const Range& c) const;
  ConstTensor3View operator()(Index b,
                              const Range& p,
                              const Range& r,
                              const Range& c) const;

  ConstMatrixView operator()(const Range& b,
                             const Range& p,
                             Index r,
                             Index c) const;
  ConstMatrixView operator()(const Range& b,
                             Index p,
                             const Range& r,
                             Index c) const;
  ConstMatrixView operator()(const Range& b,
                             Index p,
                             Index r,
                             const Range& c) const;
  ConstMatrixView operator()(Index b,
                             const Range& p,
                             Index r,
                             const Range& c) const;
  ConstMatrixView operator()(Index b,
                             const Range& p,
                             const Range& r,
                             Index c) const;
  ConstMatrixView operator()(Index b,
                             Index p,
                             const Range& r,
                             const Range& c) const;

  ConstVectorView operator()(const Range& b, Index p, Index r, Index c) const;
  ConstVectorView operator()(Index b, const Range& p, Index r, Index c) const;
  ConstVectorView operator()(Index b, Index p, const Range& r, Index c) const;
  ConstVectorView operator()(Index b, Index p, Index r, const Range& c) const;

  Numeric operator()(Index b,
                     Index p,
                     Index r,
                     Index c) const {  // Check if indices are valid:
    assert(0 <= b);
    assert(0 <= p);
    assert(0 <= r);
    assert(0 <= c);
    assert(b < mbr.mextent);
    assert(p < mpr.mextent);
    assert(r < mrr.mextent);
    assert(c < mcr.mextent);

    return get(b, p, r, c);
  }

  Numeric get(Index b, Index p, Index r, Index c) const {
    return *(mdata + mbr.mstart + b * mbr.mstride + mpr.mstart +
             p * mpr.mstride + mrr.mstart + r * mrr.mstride + mcr.mstart +
             c * mcr.mstride);
  }

  // Functions returning iterators:
  ConstIterator4D begin() const;
  ConstIterator4D end() const;

  virtual ~ConstTensor4View() = default;

  // Friends:
  friend class Tensor4View;
  friend class ConstIterator5D;
  friend class ConstTensor5View;
  friend class ConstTensor6View;
  friend class ConstTensor7View;

  // Special constructor to make a Tensor4 view of a Tensor3.
  ConstTensor4View(const ConstTensor3View& a);

 protected:
  // Constructors:
  ConstTensor4View() = default;
  ConstTensor4View(Numeric* data,
                   const Range& b,
                   const Range& p,
                   const Range& r,
                   const Range& c);
  ConstTensor4View(Numeric* data,
                   const Range& pb,
                   const Range& pp,
                   const Range& pr,
                   const Range& pc,
                   const Range& nb,
                   const Range& np,
                   const Range& nr,
                   const Range& nc);

  // Data members:
  // -------------
  Range mbr{0, 0, 1};
  Range mpr{0, 0, 1};
  Range mrr{0, 0, 1};
  Range mcr{0, 0, 1};
  Numeric* mdata{nullptr};
};

class Tensor4View : public ConstTensor4View {
 public:
  // Make const methods visible from base class
  using ConstTensor4View::begin;
  using ConstTensor4View::end;
  using ConstTensor4View::operator();
  using ConstTensor4View::get;

  constexpr Tensor4View(const Tensor4View&) = default;

  // Non-const index operators:

  Tensor4View operator()(const Range& b,
                         const Range& p,
                         const Range& r,
                         const Range& c);

  Tensor3View operator()(const Range& b,
                         const Range& p,
                         const Range& r,
                         Index c);
  Tensor3View operator()(const Range& b,
                         const Range& p,
                         Index r,
                         const Range& c);
  Tensor3View operator()(const Range& b,
                         Index p,
                         const Range& r,
                         const Range& c);
  Tensor3View operator()(Index b,
                         const Range& p,
                         const Range& r,
                         const Range& c);

  MatrixView operator()(const Range& b, const Range& p, Index r, Index c);
  MatrixView operator()(const Range& b, Index p, const Range& r, Index c);
  MatrixView operator()(const Range& b, Index p, Index r, const Range& c);
  MatrixView operator()(Index b, const Range& p, Index r, const Range& c);
  MatrixView operator()(Index b, const Range& p, const Range& r, Index c);
  MatrixView operator()(Index b, Index p, const Range& r, const Range& c);

  VectorView operator()(const Range& b, Index p, Index r, Index c);
  VectorView operator()(Index b, const Range& p, Index r, Index c);
  VectorView operator()(Index b, Index p, const Range& r, Index c);
  VectorView operator()(Index b, Index p, Index r, const Range& c);

  Numeric& operator()(Index b,
                      Index p,
                      Index r,
                      Index c) {  // Check if indices are valid:
    assert(0 <= b);
    assert(0 <= p);
    assert(0 <= r);
    assert(0 <= c);
    assert(b < mbr.mextent);
    assert(p < mpr.mextent);
    assert(r < mrr.mextent);
    assert(c < mcr.mextent);

    return get(b, p, r, c);
  }

  Numeric& get(Index b, Index p, Index r, Index c) {
    return *(mdata + mbr.mstart + b * mbr.mstride + mpr.mstart +
             p * mpr.mstride + mrr.mstart + r * mrr.mstride + mcr.mstart +
             c * mcr.mstride);
  }

  // Conversion to a plain C-array
  const Numeric* get_c_array() const;
  Numeric* get_c_array();

  // Functions returning iterators:
  Iterator4D begin();
  Iterator4D end();

  // Assignment operators:
  Tensor4View& operator=(const ConstTensor4View& v);
  Tensor4View& operator=(const Tensor4View& v);
  Tensor4View& operator=(const Tensor4& v);
  Tensor4View& operator=(Numeric x);

  // Other operators:
  Tensor4View& operator*=(Numeric x);
  Tensor4View& operator/=(Numeric x);
  Tensor4View& operator+=(Numeric x);
  Tensor4View& operator-=(Numeric x);

  Tensor4View& operator*=(const ConstTensor4View& x);
  Tensor4View& operator/=(const ConstTensor4View& x);
  Tensor4View& operator+=(const ConstTensor4View& x);
  Tensor4View& operator-=(const ConstTensor4View& x);

  virtual ~Tensor4View() = default;

  // Friends:
  // friend class VectorView;
  // friend ConstTensor4View transpose(ConstTensor4View m);
  // friend Tensor4View transpose(Tensor4View m);
  friend class Iterator5D;
  friend class Tensor5View;
  friend class Tensor6View;
  friend class Tensor7View;

  // Special constructor to make a Tensor4 view of a Tensor3.
  Tensor4View(const Tensor3View& a);

 protected:
  // Constructors:
  Tensor4View() = default;
  Tensor4View(Numeric* data,
              const Range& b,
              const Range& p,
              const Range& r,
              const Range& c);
  Tensor4View(Numeric* data,
              const Range& pb,
              const Range& pp,
              const Range& pr,
              const Range& pc,
              const Range& nb,
              const Range& np,
              const Range& nr,
              const Range& nc);
};

class Tensor4 : public Tensor4View {
 public:
  // Constructors:
  Tensor4() = default;
  Tensor4(Index b, Index p, Index r, Index c);
  Tensor4(Index b, Index p, Index r, Index c, Numeric fill);
  Tensor4(const ConstTensor4View& v);
  Tensor4(const Tensor4& v);
  Tensor4(Tensor4&& v) noexcept : Tensor4View(std::forward<Tensor4View>(v)) {
    v.mdata = nullptr;
  }

  // Assignment operators:
  Tensor4& operator=(const Tensor4& x);
  Tensor4& operator=(Tensor4&& x) noexcept;
  Tensor4& operator=(Numeric x);

  // Resize function:
  void resize(Index b, Index p, Index r, Index c);

  // Swap function:
  friend void swap(Tensor4& t1, Tensor4& t2);

  // Destructor:
  virtual ~Tensor4();
};

// Function declarations:
// ----------------------

void copy(ConstIterator4D origin,
          const ConstIterator4D& end,
          Iterator4D target);

void copy(Numeric x, Iterator4D target, const Iterator4D& end);

void transform(Tensor4View y, double (&my_func)(double), ConstTensor4View x);

Numeric max(const ConstTensor4View& x);

Numeric min(const ConstTensor4View& x);

std::ostream& operator<<(std::ostream& os, const ConstTensor4View& v);

// Helper function for debugging
#ifndef NDEBUG

Numeric debug_tensor4view_get_elem(
    Tensor4View& tv, Index b, Index p, Index r, Index c);

#endif

#endif  // matpackIV_h