doxygen/html/matpackIV_8cc_source.html

 /* Copyright (C) 2002-2012 Stefan Buehler <sbuehler@ltu.se>

    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. */

 #include "matpackIV.h"
 #include "exceptions.h"

 using std::runtime_error;

 Tensor3View* Iterator4D::operator->() { return &msv; }

 Tensor3View& Iterator4D::operator*() { return msv; }

 const ConstTensor3View* ConstIterator4D::operator->() const { return &msv; }

 const ConstTensor3View& ConstIterator4D::operator*() const { return msv; }

 // Functions for ConstTensor4View:
 // ------------------------------


 bool ConstTensor4View::empty() const {
   return (nbooks() == 0 || npages() == 0 || nrows() == 0 || ncols() == 0);
 }

 Index ConstTensor4View::nbooks() const { return mbr.mextent; }

 Index ConstTensor4View::npages() const { return mpr.mextent; }

 Index ConstTensor4View::nrows() const { return mrr.mextent; }

 Index ConstTensor4View::ncols() const { return mcr.mextent; }

 ConstTensor4View ConstTensor4View::operator()(const Range& b,
                                               const Range& p,
                                               const Range& r,
                                               const Range& c) const {
   return ConstTensor4View(mdata, mbr, mpr, mrr, mcr, b, p, r, c);
 }

 ConstTensor3View ConstTensor4View::operator()(const Range& b,
                                               const Range& p,
                                               const Range& r,
                                               Index c) const {
   // Check that c is valid:
   assert(0 <= c);
   assert(c < mcr.mextent);

   return ConstTensor3View(
       mdata + mcr.mstart + c * mcr.mstride, mbr, mpr, mrr, b, p, r);
 }

 ConstTensor3View ConstTensor4View::operator()(const Range& b,
                                               const Range& p,
                                               Index r,
                                               const Range& c) const {
   // Check that r is valid:
   assert(0 <= r);
   assert(r < mrr.mextent);

   return ConstTensor3View(
       mdata + mrr.mstart + r * mrr.mstride, mbr, mpr, mcr, b, p, c);
 }

 ConstTensor3View ConstTensor4View::operator()(const Range& b,
                                               Index p,
                                               const Range& r,
                                               const Range& c) const {
   // Check that p is valid:
   assert(0 <= p);
   assert(p < mpr.mextent);

   return ConstTensor3View(
       mdata + mpr.mstart + p * mpr.mstride, mbr, mrr, mcr, b, r, c);
 }

 ConstTensor3View ConstTensor4View::operator()(Index b,
                                               const Range& p,
                                               const Range& r,
                                               const Range& c) const {
   // Check that b is valid:
   assert(0 <= b);
   assert(b < mbr.mextent);

   return ConstTensor3View(
       mdata + mbr.mstart + b * mbr.mstride, mpr, mrr, mcr, p, r, c);
 }

 ConstMatrixView ConstTensor4View::operator()(const Range& b,
                                              const Range& p,
                                              Index r,
                                              Index c) const {
   // Check that r and c are valid:
   assert(0 <= r);
   assert(0 <= c);
   assert(r < mrr.mextent);
   assert(c < mcr.mextent);

   return ConstMatrixView(
       mdata + mrr.mstart + r * mrr.mstride + mcr.mstart + c * mcr.mstride,
       mbr,
       mpr,
       b,
       p);
 }

 ConstMatrixView ConstTensor4View::operator()(const Range& b,
                                              Index p,
                                              const Range& r,
                                              Index c) const {
   // Check that p and c are valid:
   assert(0 <= p);
   assert(0 <= c);
   assert(p < mpr.mextent);
   assert(c < mcr.mextent);

   return ConstMatrixView(
       mdata + mpr.mstart + p * mpr.mstride + mcr.mstart + c * mcr.mstride,
       mbr,
       mrr,
       b,
       r);
 }

 ConstMatrixView ConstTensor4View::operator()(const Range& b,
                                              Index p,
                                              Index r,
                                              const Range& c) const {
   // Check that p and r are valid:
   assert(0 <= p);
   assert(0 <= r);
   assert(p < mpr.mextent);
   assert(r < mrr.mextent);

   return ConstMatrixView(
       mdata + mpr.mstart + p * mpr.mstride + mrr.mstart + r * mrr.mstride,
       mbr,
       mcr,
       b,
       c);
 }

 ConstMatrixView ConstTensor4View::operator()(Index b,
                                              const Range& p,
                                              Index r,
                                              const Range& c) const {
   // Check that b and r are valid:
   assert(0 <= b);
   assert(0 <= r);
   assert(b < mbr.mextent);
   assert(r < mrr.mextent);

   return ConstMatrixView(
       mdata + mbr.mstart + b * mbr.mstride + mrr.mstart + r * mrr.mstride,
       mpr,
       mcr,
       p,
       c);
 }

 ConstMatrixView ConstTensor4View::operator()(Index b,
                                              const Range& p,
                                              const Range& r,
                                              Index c) const {
   // Check that b and c are valid:
   assert(0 <= b);
   assert(0 <= c);
   assert(b < mbr.mextent);
   assert(c < mcr.mextent);

   return ConstMatrixView(
       mdata + mbr.mstart + b * mbr.mstride + mcr.mstart + c * mcr.mstride,
       mpr,
       mrr,
       p,
       r);
 }

 ConstMatrixView ConstTensor4View::operator()(Index b,
                                              Index p,
                                              const Range& r,
                                              const Range& c) const {
   // Check that b and p are valid:
   assert(0 <= b);
   assert(0 <= p);
   assert(b < mbr.mextent);
   assert(p < mpr.mextent);

   return ConstMatrixView(
       mdata + mbr.mstart + b * mbr.mstride + mpr.mstart + p * mpr.mstride,
       mrr,
       mcr,
       r,
       c);
 }

 ConstVectorView ConstTensor4View::operator()(const Range& b,
                                              Index p,
                                              Index r,
                                              Index c) const {
   // Check that p, r and c are valid:
   assert(0 <= p);
   assert(0 <= r);
   assert(0 <= c);
   assert(p < mpr.mextent);
   assert(r < mrr.mextent);
   assert(c < mcr.mextent);

   return ConstVectorView(mdata + mpr.mstart + p * mpr.mstride + mrr.mstart +
                              r * mrr.mstride + mcr.mstart + c * mcr.mstride,
                          mbr,
                          b);
 }

 ConstVectorView ConstTensor4View::operator()(Index b,
                                              const Range& p,
                                              Index r,
                                              Index c) const {
   // Check that b, r and c are valid:
   assert(0 <= b);
   assert(0 <= r);
   assert(0 <= c);
   assert(b < mbr.mextent);
   assert(r < mrr.mextent);
   assert(c < mcr.mextent);

   return ConstVectorView(mdata + mbr.mstart + b * mbr.mstride + mrr.mstart +
                              r * mrr.mstride + mcr.mstart + c * mcr.mstride,
                          mpr,
                          p);
 }

 ConstVectorView ConstTensor4View::operator()(Index b,
                                              Index p,
                                              const Range& r,
                                              Index c) const {
   // Check that b, p and c are valid:
   assert(0 <= b);
   assert(0 <= p);
   assert(0 <= c);
   assert(b < mbr.mextent);
   assert(p < mpr.mextent);
   assert(c < mcr.mextent);

   return ConstVectorView(mdata + mbr.mstart + b * mbr.mstride + mpr.mstart +
                              p * mpr.mstride + mcr.mstart + c * mcr.mstride,
                          mrr,
                          r);
 }

 ConstVectorView ConstTensor4View::operator()(Index b,
                                              Index p,
                                              Index r,
                                              const Range& c) const {
   // Check that b, p and r are valid:
   assert(0 <= b);
   assert(0 <= p);
   assert(0 <= r);
   assert(b < mbr.mextent);
   assert(p < mpr.mextent);
   assert(r < mrr.mextent);

   return ConstVectorView(mdata + mbr.mstart + b * mbr.mstride + mpr.mstart +
                              p * mpr.mstride + mrr.mstart + r * mrr.mstride,
                          mcr,
                          c);
 }

 Numeric* Tensor4View::get_c_array() {
   if (mbr.mstart != 0 ||
       mbr.mstride != mpr.mextent * mrr.mextent * mcr.mextent ||
       mpr.mstart != 0 || mpr.mstride != mrr.mextent * mcr.mextent ||
       mrr.mstart != 0 || mrr.mstride != mcr.mextent || mcr.mstart != 0 ||
       mcr.mstride != 1)
     throw std::runtime_error(
         "A Tensor4View can only be converted to a plain C-array if it's pointing to a continuous block of data");

   return mdata;
 }

 const Numeric* Tensor4View::get_c_array() const {
   if (mbr.mstart != 0 ||
       mbr.mstride != mpr.mextent * mrr.mextent * mcr.mextent ||
       mpr.mstart != 0 || mpr.mstride != mrr.mextent * mcr.mextent ||
       mrr.mstart != 0 || mrr.mstride != mcr.mextent || mcr.mstart != 0 ||
       mcr.mstride != 1)
     throw std::runtime_error(
         "A Tensor4View can only be converted to a plain C-array if it's pointing to a continuous block of data");

   return mdata;
 }

 ConstIterator4D ConstTensor4View::begin() const {
   return ConstIterator4D(ConstTensor3View(mdata + mbr.mstart, mpr, mrr, mcr),
                          mbr.mstride);
 }

 ConstIterator4D ConstTensor4View::end() const {
   return ConstIterator4D(
       ConstTensor3View(
           mdata + mbr.mstart + (mbr.mextent) * mbr.mstride, mpr, mrr, mcr),
       mbr.mstride);
 }

 ConstTensor4View::ConstTensor4View(const ConstTensor3View& a)
     : mbr(0, 1, a.mpr.mextent * a.mrr.mextent * a.mcr.mextent),
       mpr(a.mpr),
       mrr(a.mrr),
       mcr(a.mcr),
       mdata(a.mdata) {
   // Nothing to do here.
 }

 ConstTensor4View::ConstTensor4View(Numeric* data,
                                    const Range& br,
                                    const Range& pr,
                                    const Range& rr,
                                    const Range& cr)
     : mbr(br), mpr(pr), mrr(rr), mcr(cr), mdata(data) {
   // Nothing to do here.
 }

 ConstTensor4View::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)
     : mbr(pb, nb), mpr(pp, np), mrr(pr, nr), mcr(pc, nc), mdata(data) {
   // Nothing to do here.
 }

 std::ostream& operator<<(std::ostream& os, const ConstTensor4View& v) {
   // Page iterators:
   ConstIterator4D ib = v.begin();
   const ConstIterator4D end_book = v.end();

   if (ib != end_book) {
     os << *ib;
     ++ib;
   }

   for (; ib != end_book; ++ib) {
     os << "\n\n";
     os << *ib;
   }

   return os;
 }

 // Functions for Tensor4View:
 // -------------------------

 Tensor4View Tensor4View::operator()(const Range& b,
                                     const Range& p,
                                     const Range& r,
                                     const Range& c) {
   return Tensor4View(mdata, mbr, mpr, mrr, mcr, b, p, r, c);
 }

 Tensor3View Tensor4View::operator()(const Range& b,
                                     const Range& p,
                                     const Range& r,
                                     Index c) {
   // Check that c is valid:
   assert(0 <= c);
   assert(c < mcr.mextent);

   return Tensor3View(
       mdata + mcr.mstart + c * mcr.mstride, mbr, mpr, mrr, b, p, r);
 }

 Tensor3View Tensor4View::operator()(const Range& b,
                                     const Range& p,
                                     Index r,
                                     const Range& c) {
   // Check that r is valid:
   assert(0 <= r);
   assert(r < mrr.mextent);

   return Tensor3View(
       mdata + mrr.mstart + r * mrr.mstride, mbr, mpr, mcr, b, p, c);
 }

 Tensor3View Tensor4View::operator()(const Range& b,
                                     Index p,
                                     const Range& r,
                                     const Range& c) {
   // Check that p is valid:
   assert(0 <= p);
   assert(p < mpr.mextent);

   return Tensor3View(
       mdata + mpr.mstart + p * mpr.mstride, mbr, mrr, mcr, b, r, c);
 }

 Tensor3View Tensor4View::operator()(Index b,
                                     const Range& p,
                                     const Range& r,
                                     const Range& c) {
   // Check that b is valid:
   assert(0 <= b);
   assert(b < mbr.mextent);

   return Tensor3View(
       mdata + mbr.mstart + b * mbr.mstride, mpr, mrr, mcr, p, r, c);
 }

 MatrixView Tensor4View::operator()(const Range& b,
                                    const Range& p,
                                    Index r,
                                    Index c) {
   // Check that r and c are valid:
   assert(0 <= r);
   assert(0 <= c);
   assert(r < mrr.mextent);
   assert(c < mcr.mextent);

   return MatrixView(
       mdata + mrr.mstart + r * mrr.mstride + mcr.mstart + c * mcr.mstride,
       mbr,
       mpr,
       b,
       p);
 }

 MatrixView Tensor4View::operator()(const Range& b,
                                    Index p,
                                    const Range& r,
                                    Index c) {
   // Check that p and c are valid:
   assert(0 <= p);
   assert(0 <= c);
   assert(p < mpr.mextent);
   assert(c < mcr.mextent);

   return MatrixView(
       mdata + mpr.mstart + p * mpr.mstride + mcr.mstart + c * mcr.mstride,
       mbr,
       mrr,
       b,
       r);
 }

 MatrixView Tensor4View::operator()(const Range& b,
                                    Index p,
                                    Index r,
                                    const Range& c) {
   // Check that p and r are valid:
   assert(0 <= p);
   assert(0 <= r);
   assert(p < mpr.mextent);
   assert(r < mrr.mextent);

   return MatrixView(
       mdata + mpr.mstart + p * mpr.mstride + mrr.mstart + r * mrr.mstride,
       mbr,
       mcr,
       b,
       c);
 }

 MatrixView Tensor4View::operator()(Index b,
                                    const Range& p,
                                    Index r,
                                    const Range& c) {
   // Check that b and r are valid:
   assert(0 <= b);
   assert(0 <= r);
   assert(b < mbr.mextent);
   assert(r < mrr.mextent);

   return MatrixView(
       mdata + mbr.mstart + b * mbr.mstride + mrr.mstart + r * mrr.mstride,
       mpr,
       mcr,
       p,
       c);
 }

 MatrixView Tensor4View::operator()(Index b,
                                    const Range& p,
                                    const Range& r,
                                    Index c) {
   // Check that b and c are valid:
   assert(0 <= b);
   assert(0 <= c);
   assert(b < mbr.mextent);
   assert(c < mcr.mextent);

   return MatrixView(
       mdata + mbr.mstart + b * mbr.mstride + mcr.mstart + c * mcr.mstride,
       mpr,
       mrr,
       p,
       r);
 }

 MatrixView Tensor4View::operator()(Index b,
                                    Index p,
                                    const Range& r,
                                    const Range& c) {
   // Check that b and p are valid:
   assert(0 <= b);
   assert(0 <= p);
   assert(b < mbr.mextent);
   assert(p < mpr.mextent);

   return MatrixView(
       mdata + mbr.mstart + b * mbr.mstride + mpr.mstart + p * mpr.mstride,
       mrr,
       mcr,
       r,
       c);
 }

 VectorView Tensor4View::operator()(const Range& b, Index p, Index r, Index c) {
   // Check that p, r and c are valid:
   assert(0 <= p);
   assert(0 <= r);
   assert(0 <= c);
   assert(p < mpr.mextent);
   assert(r < mrr.mextent);
   assert(c < mcr.mextent);

   return VectorView(mdata + mpr.mstart + p * mpr.mstride + mrr.mstart +
                         r * mrr.mstride + mcr.mstart + c * mcr.mstride,
                     mbr,
                     b);
 }

 VectorView Tensor4View::operator()(Index b, const Range& p, Index r, Index c) {
   // Check that b, r and c are valid:
   assert(0 <= b);
   assert(0 <= r);
   assert(0 <= c);
   assert(b < mbr.mextent);
   assert(r < mrr.mextent);
   assert(c < mcr.mextent);

   return VectorView(mdata + mbr.mstart + b * mbr.mstride + mrr.mstart +
                         r * mrr.mstride + mcr.mstart + c * mcr.mstride,
                     mpr,
                     p);
 }

 VectorView Tensor4View::operator()(Index b, Index p, const Range& r, Index c) {
   // Check that b, p and c are valid:
   assert(0 <= b);
   assert(0 <= p);
   assert(0 <= c);
   assert(b < mbr.mextent);
   assert(p < mpr.mextent);
   assert(c < mcr.mextent);

   return VectorView(mdata + mbr.mstart + b * mbr.mstride + mpr.mstart +
                         p * mpr.mstride + mcr.mstart + c * mcr.mstride,
                     mrr,
                     r);
 }

 VectorView Tensor4View::operator()(Index b, Index p, Index r, const Range& c) {
   // Check that b, p and r are valid:
   assert(0 <= b);
   assert(0 <= p);
   assert(0 <= r);
   assert(b < mbr.mextent);
   assert(p < mpr.mextent);
   assert(r < mrr.mextent);

   return VectorView(mdata + mbr.mstart + b * mbr.mstride + mpr.mstart +
                         p * mpr.mstride + mrr.mstart + r * mrr.mstride,
                     mcr,
                     c);
 }

 Iterator4D Tensor4View::begin() {
   return Iterator4D(Tensor3View(mdata + mbr.mstart, mpr, mrr, mcr),
                     mbr.mstride);
 }

 Iterator4D Tensor4View::end() {
   return Iterator4D(
       Tensor3View(
           mdata + mbr.mstart + (mbr.mextent) * mbr.mstride, mpr, mrr, mcr),
       mbr.mstride);
 }

 Tensor4View& Tensor4View::operator=(const ConstTensor4View& m) {
   // Check that sizes are compatible:
   assert(mbr.mextent == m.mbr.mextent);
   assert(mpr.mextent == m.mpr.mextent);
   assert(mrr.mextent == m.mrr.mextent);
   assert(mcr.mextent == m.mcr.mextent);

   copy(m.begin(), m.end(), begin());
   return *this;
 }

 Tensor4View& Tensor4View::operator=(const Tensor4View& m) {
   // Check that sizes are compatible:
   assert(mbr.mextent == m.mbr.mextent);
   assert(mpr.mextent == m.mpr.mextent);
   assert(mrr.mextent == m.mrr.mextent);
   assert(mcr.mextent == m.mcr.mextent);

   copy(m.begin(), m.end(), begin());
   return *this;
 }

 Tensor4View& Tensor4View::operator=(const Tensor4& m) {
   // Check that sizes are compatible:
   assert(mbr.mextent == m.mbr.mextent);
   assert(mpr.mextent == m.mpr.mextent);
   assert(mrr.mextent == m.mrr.mextent);
   assert(mcr.mextent == m.mcr.mextent);

   copy(m.begin(), m.end(), begin());
   return *this;
 }

 Tensor4View& Tensor4View::operator=(Numeric x) {
   copy(x, begin(), end());
   return *this;
 }

 // Some little helper functions:
 //------------------------------

 Tensor4View& Tensor4View::operator*=(Numeric x) {
   const Iterator4D eb = end();
   for (Iterator4D b = begin(); b != eb; ++b) {
     *b *= x;
   }
   return *this;
 }

 Tensor4View& Tensor4View::operator/=(Numeric x) {
   const Iterator4D eb = end();
   for (Iterator4D b = begin(); b != eb; ++b) {
     *b /= x;
   }
   return *this;
 }

 Tensor4View& Tensor4View::operator+=(Numeric x) {
   const Iterator4D eb = end();
   for (Iterator4D b = begin(); b != eb; ++b) {
     *b += x;
   }
   return *this;
 }

 Tensor4View& Tensor4View::operator-=(Numeric x) {
   const Iterator4D eb = end();
   for (Iterator4D b = begin(); b != eb; ++b) {
     *b -= x;
   }
   return *this;
 }

 Tensor4View& Tensor4View::operator*=(const ConstTensor4View& x) {
   assert(nbooks() == x.nbooks());
   assert(npages() == x.npages());
   assert(nrows() == x.nrows());
   assert(ncols() == x.ncols());
   ConstIterator4D xb = x.begin();
   Iterator4D b = begin();
   const Iterator4D eb = end();
   for (; b != eb; ++b, ++xb) {
     *b *= *xb;
   }
   return *this;
 }

 Tensor4View& Tensor4View::operator/=(const ConstTensor4View& x) {
   assert(nbooks() == x.nbooks());
   assert(npages() == x.npages());
   assert(nrows() == x.nrows());
   assert(ncols() == x.ncols());
   ConstIterator4D xb = x.begin();
   Iterator4D b = begin();
   const Iterator4D eb = end();
   for (; b != eb; ++b, ++xb) {
     *b /= *xb;
   }
   return *this;
 }

 Tensor4View& Tensor4View::operator+=(const ConstTensor4View& x) {
   assert(nbooks() == x.nbooks());
   assert(npages() == x.npages());
   assert(nrows() == x.nrows());
   assert(ncols() == x.ncols());
   ConstIterator4D xb = x.begin();
   Iterator4D b = begin();
   const Iterator4D eb = end();
   for (; b != eb; ++b, ++xb) {
     *b += *xb;
   }
   return *this;
 }

 Tensor4View& Tensor4View::operator-=(const ConstTensor4View& x) {
   assert(nbooks() == x.nbooks());
   assert(npages() == x.npages());
   assert(nrows() == x.nrows());
   assert(ncols() == x.ncols());
   ConstIterator4D xb = x.begin();
   Iterator4D b = begin();
   const Iterator4D eb = end();
   for (; b != eb; ++b, ++xb) {
     *b -= *xb;
   }
   return *this;
 }

 Tensor4View::Tensor4View(const Tensor3View& a)
     : ConstTensor4View(
           a.mdata,
           Range(0, 1, a.mpr.mextent * a.mrr.mextent * a.mcr.mextent),
           a.mpr,
           a.mrr,
           a.mcr) {
   // Nothing to do here.
 }

 Tensor4View::Tensor4View(Numeric* data,
                          const Range& br,
                          const Range& pr,
                          const Range& rr,
                          const Range& cr)
     : ConstTensor4View(data, br, pr, rr, cr) {
   // Nothing to do here.
 }

 Tensor4View::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)
     : ConstTensor4View(data, pb, pp, pr, pc, nb, np, nr, nc) {
   // Nothing to do here.
 }

 void copy(ConstIterator4D origin,
           const ConstIterator4D& end,
           Iterator4D target) {
   for (; origin != end; ++origin, ++target) {
     // We use the copy function for the next smaller rank of tensor
     // recursively:
     copy(origin->begin(), origin->end(), target->begin());
   }
 }

 void copy(Numeric x, Iterator4D target, const Iterator4D& end) {
   for (; target != end; ++target) {
     // We use the copy function for the next smaller rank of tensor
     // recursively:
     copy(x, target->begin(), target->end());
   }
 }

 // Functions for Tensor4:
 // ---------------------

 Tensor4::Tensor4(Index b, Index p, Index r, Index c)
     : Tensor4View(new Numeric[b * p * r * c],
                   Range(0, b, p * r * c),
                   Range(0, p, r * c),
                   Range(0, r, c),
                   Range(0, c)) {
   // Nothing to do here.
 }

 Tensor4::Tensor4(Index b, Index p, Index r, Index c, Numeric fill)
     : Tensor4View(new Numeric[b * p * r * c],
                   Range(0, b, p * r * c),
                   Range(0, p, r * c),
                   Range(0, r, c),
                   Range(0, c)) {
   // Here we can access the raw memory directly, for slightly
   // increased efficiency:
   std::fill_n(mdata, b * p * r * c, fill);
 }

 Tensor4::Tensor4(const ConstTensor4View& m)
     : Tensor4View(new Numeric[m.nbooks() * m.npages() * m.nrows() * m.ncols()],
                   Range(0, m.nbooks(), m.npages() * m.nrows() * m.ncols()),
                   Range(0, m.npages(), m.nrows() * m.ncols()),
                   Range(0, m.nrows(), m.ncols()),
                   Range(0, m.ncols())) {
   copy(m.begin(), m.end(), begin());
 }

 Tensor4::Tensor4(const Tensor4& m)
     : Tensor4View(new Numeric[m.nbooks() * m.npages() * m.nrows() * m.ncols()],
                   Range(0, m.nbooks(), m.npages() * m.nrows() * m.ncols()),
                   Range(0, m.npages(), m.nrows() * m.ncols()),
                   Range(0, m.nrows(), m.ncols()),
                   Range(0, m.ncols())) {
   // There is a catch here: If m is an empty tensor, then it will have
   // dimensions of size 0. But these are used to initialize the stride
   // for higher dimensions! Thus, this method has to be consistent
   // with the behaviour of Range::Range. For now, Range::Range allows
   // also stride 0.
   std::memcpy(mdata,
               m.mdata,
               nbooks() * npages() * nrows() * ncols() * sizeof(Numeric));
 }


 Tensor4& Tensor4::operator=(const Tensor4& x) {
   if (this != &x) {
     resize(x.nbooks(), x.npages(), x.nrows(), x.ncols());
     std::memcpy(mdata,
                 x.mdata,
                 nbooks() * npages() * nrows() * ncols() * sizeof(Numeric));
   }
   return *this;
 }

 Tensor4& Tensor4::operator=(Tensor4&& x) noexcept {
   if (this != &x) {
     delete[] mdata;
     mdata = x.mdata;
     mbr = x.mbr;
     mpr = x.mpr;
     mrr = x.mrr;
     mcr = x.mcr;
     x.mbr = Range(0, 0);
     x.mpr = Range(0, 0);
     x.mrr = Range(0, 0);
     x.mcr = Range(0, 0);
     x.mdata = nullptr;
   }
   return *this;
 }

 Tensor4& Tensor4::operator=(Numeric x) {
   std::fill_n(mdata, nbooks() * npages() * nrows() * ncols(), x);
   return *this;
 }

 void Tensor4::resize(Index b, Index p, Index r, Index c) {
   assert(0 <= b);
   assert(0 <= p);
   assert(0 <= r);
   assert(0 <= c);

   if (mbr.mextent != b || mpr.mextent != p || mrr.mextent != r ||
       mcr.mextent != c) {
     delete[] mdata;
     mdata = new Numeric[b * p * r * c];

     mbr.mstart = 0;
     mbr.mextent = b;
     mbr.mstride = p * r * c;

     mpr.mstart = 0;
     mpr.mextent = p;
     mpr.mstride = r * c;

     mrr.mstart = 0;
     mrr.mextent = r;
     mrr.mstride = c;

     mcr.mstart = 0;
     mcr.mextent = c;
     mcr.mstride = 1;
   }
 }

 void swap(Tensor4& t1, Tensor4& t2) {
   std::swap(t1.mbr, t2.mbr);
   std::swap(t1.mpr, t2.mpr);
   std::swap(t1.mrr, t2.mrr);
   std::swap(t1.mcr, t2.mcr);
   std::swap(t1.mdata, t2.mdata);
 }

 Tensor4::~Tensor4() {
   //   cout << "Destroying a Tensor4:\n"
   //        << *this << "\n........................................\n";
   delete[] mdata;
 }

 void transform(Tensor4View y, double (&my_func)(double), ConstTensor4View x) {
   // Check dimensions:
   assert(y.nbooks() == x.nbooks());
   assert(y.npages() == x.npages());
   assert(y.nrows() == x.nrows());
   assert(y.ncols() == x.ncols());

   const ConstIterator4D xe = x.end();
   ConstIterator4D xi = x.begin();
   Iterator4D yi = y.begin();
   for (; xi != xe; ++xi, ++yi) {
     // Use the transform function of lower dimensional tensors
     // recursively:
     transform(*yi, my_func, *xi);
   }
 }

 Numeric max(const ConstTensor4View& x) {
   const ConstIterator4D xe = x.end();
   ConstIterator4D xi = x.begin();

   // Initial value for max:
   Numeric themax = max(*xi);
   ++xi;

   for (; xi != xe; ++xi) {
     // Use the max function of lower dimensional tensors
     // recursively:
     Numeric maxi = max(*xi);
     if (maxi > themax) themax = maxi;
   }

   return themax;
 }

 Numeric min(const ConstTensor4View& x) {
   const ConstIterator4D xe = x.end();
   ConstIterator4D xi = x.begin();

   // Initial value for min:
   Numeric themin = min(*xi);
   ++xi;

   for (; xi != xe; ++xi) {
     // Use the min function of lower dimensional tensors
     // recursively:
     Numeric mini = min(*xi);
     if (mini < themin) themin = mini;
   }

   return themin;
 }

 // Helper function for debugging
 #ifndef NDEBUG

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

 #endif
 Index
INDEX Index
The type to use for all integer numbers and indices.
Definition: matpack.h:39

eb
#define eb
Definition: legacy_continua.cc:22185

matpackIV.h

VectorView
The VectorView class.
Definition: matpackI.h:610

debug_tensor4view_get_elem
Numeric debug_tensor4view_get_elem(Tensor4View &tv, Index b, Index p, Index r, Index c)
Helper function to access tensor elements.
Definition: matpackIV.cc:1199

min
Numeric min(const ConstTensor4View &x)
Min function, tensor version.
Definition: matpackIV.cc:1162

copy
void copy(ConstIterator4D origin, const ConstIterator4D &end, Iterator4D target)
Copy data between begin and end to target.
Definition: matpackIV.cc:928

Range::mstride
Index mstride
The stride.
Definition: matpackI.h:355

Tensor4View
The Tensor4View class.
Definition: matpackIV.h:284

ConstIterator4D
Const version of Iterator4D.
Definition: matpackIV.h:77

Range::mstart
Index mstart
The start index.
Definition: matpackI.h:346

ConstTensor4View::mrr
Range mrr
The row range of mdata that is actually used.
Definition: matpackIV.h:268

MatrixView
The MatrixView class.
Definition: matpackI.h:1093

Iterator4D
Implementation of Tensors of Rank 4.
Definition: matpackIV.h:38

ConstTensor4View::begin
ConstIterator4D begin() const
Return const iterator to first book.
Definition: matpackIV.cc:371

Tensor4View::begin
Iterator4D begin()
Return iterator to first book.
Definition: matpackIV.cc:706

Tensor4::~Tensor4
virtual ~Tensor4()
Destructor for Tensor4.
Definition: matpackIV.cc:1104

Tensor4
The Tensor4 class.
Definition: matpackIV.h:421

Range
The range class.
Definition: matpackI.h:160

Tensor4View::operator+=
Tensor4View & operator+=(Numeric x)
Addition of scalar.
Definition: matpackIV.cc:793

ConstTensor4View::npages
Index npages() const
Returns the number of pages.
Definition: matpackIV.cc:60

Tensor4View::operator*=
Tensor4View & operator*=(Numeric x)
Multiplication by scalar.
Definition: matpackIV.cc:775

swap
void swap(Tensor4 &t1, Tensor4 &t2)
Swaps two objects.
Definition: matpackIV.cc:1094

Tensor4View::Tensor4View
Tensor4View()=default

Tensor3View::end
Iterator3D end()
Return iterator behind last page.
Definition: matpackIII.cc:337

data
G0 G2 FVC Y DV Numeric Numeric Numeric Zeeman LowerQuantumNumbers void * data
Definition: arts_api_classes.cc:232

ConstTensor4View::nrows
Index nrows() const
Returns the number of rows.
Definition: matpackIV.cc:63

ConstTensor4View
A constant view of a Tensor4.
Definition: matpackIV.h:133

Iterator4D::operator*
Tensor3View & operator*()
Dereferencing.
Definition: matpackIV.cc:35

ConstIterator4D::operator*
const ConstTensor3View & operator*() const
Dereferencing.
Definition: matpackIV.cc:42

ConstTensor4View::mpr
Range mpr
The page range of mdata that is actually used.
Definition: matpackIV.h:266

operator<<
std::ostream & operator<<(std::ostream &os, const ConstTensor4View &v)
Output operator.
Definition: matpackIV.cc:430

ConstTensor3View::end
ConstIterator3D end() const
Return const iterator behind last page.
Definition: matpackIII.cc:145

Tensor4View::operator=
Tensor4View & operator=(const ConstTensor4View &v)
Assignment operator.
Definition: matpackIV.cc:723

Tensor4View::end
Iterator4D end()
Return iterator behind last book.
Definition: matpackIV.cc:712

Tensor3View::begin
Iterator3D begin()
Return iterator to first page.
Definition: matpackIII.cc:332

Tensor3View
The Tensor3View class.
Definition: matpackIII.h:239

exceptions.h
The declarations of all the exception classes.

ConstTensor4View::Tensor4View
friend class Tensor4View
Definition: matpackIV.h:234

ConstTensor4View::mbr
Range mbr
The book range of mdata that is actually used.
Definition: matpackIV.h:264

max
Numeric max(const ConstTensor4View &x)
Max function, tensor version.
Definition: matpackIV.cc:1143

Numeric
NUMERIC Numeric
The type to use for all floating point numbers.
Definition: matpack.h:33

ConstTensor4View::operator()
ConstTensor4View operator()(const Range &b, const Range &p, const Range &r, const Range &c) const
Const index operator for subrange.
Definition: matpackIV.cc:71

ConstTensor4View::mcr
Range mcr
The column range of mdata that is actually used.
Definition: matpackIV.h:270

Range::mextent
Index mextent
The number of elements.
Definition: matpackI.h:353

Tensor4View::operator/=
Tensor4View & operator/=(Numeric x)
Division by scalar.
Definition: matpackIV.cc:784

ConstTensor4View::mdata
Numeric * mdata
Pointer to the plain C array that holds the data.
Definition: matpackIV.h:272

ConstTensor4View::end
ConstIterator4D end() const
Return const iterator behind last book.
Definition: matpackIV.cc:377

transform
void transform(Tensor4View y, double(&my_func)(double), ConstTensor4View x)
A generic transform function for tensors, which can be used to implement mathematical functions opera...
Definition: matpackIV.cc:1125

ConstTensor4View::empty
bool empty() const
Check if variable is empty.
Definition: matpackIV.cc:52

Tensor4::swap
friend void swap(Tensor4 &t1, Tensor4 &t2)
Swaps two objects.
Definition: matpackIV.cc:1094

Tensor4::Tensor4
Tensor4()=default

ConstTensor3View::begin
ConstIterator3D begin() const
Return const iterator to first page.
Definition: matpackIII.cc:139

ConstTensor3View
A constant view of a Tensor3.
Definition: matpackIII.h:132

ConstVectorView
A constant view of a Vector.
Definition: matpackI.h:476

Tensor4::operator=
Tensor4 & operator=(const Tensor4 &x)
Assignment operator from another tensor.
Definition: matpackIV.cc:1026

Tensor4View::operator-=
Tensor4View & operator-=(Numeric x)
Subtraction of scalar.
Definition: matpackIV.cc:802

ConstMatrixView
A constant view of a Matrix.
Definition: matpackI.h:982

Iterator4D::operator->
Tensor3View * operator->()
The -> operator is needed, so that we can write i->begin() to get the 3D iterators.
Definition: matpackIV.cc:32

ConstTensor4View::nbooks
Index nbooks() const
Returns the number of books.
Definition: matpackIV.cc:57

QuantumNumberType::r

ConstIterator4D::operator->
const ConstTensor3View * operator->() const
The -> operator is needed, so that we can write i->begin() to get the 3D iterators.
Definition: matpackIV.cc:39

ConstTensor4View::ncols
Index ncols() const
Returns the number of columns.
Definition: matpackIV.cc:66

ConstTensor4View::ConstTensor4View
ConstTensor4View()=default

Tensor4View::operator()
Tensor4View operator()(const Range &b, const Range &p, const Range &r, const Range &c)
Index operator for subrange.
Definition: matpackIV.cc:454

Tensor4::resize
void resize(Index b, Index p, Index r, Index c)
Resize function.
Definition: matpackIV.cc:1064

Iterator4D::msv
Tensor3View msv
Current position.
Definition: matpackIV.h:71

Tensor4View::get_c_array
const Numeric * get_c_array() const
Conversion to plain C-array.
Definition: matpackIV.cc:358