matpackIII.cc

Go to the documentation of this file.

/* 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 "matpackIII.h"
#include "exceptions.h"

using std::runtime_error;

// Functions for ConstTensor3View:
// ------------------------------


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

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

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

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

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

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

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

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

ConstVectorView ConstTensor3View::operator()(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 ConstVectorView(
      mdata + mpr.mstart + p * mpr.mstride + mrr.mstart + r * mrr.mstride,
      mcr,
      c);
}

ConstVectorView ConstTensor3View::operator()(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 ConstVectorView(
      mdata + mpr.mstart + p * mpr.mstride + mcr.mstart + c * mcr.mstride,
      mrr,
      r);
}

ConstVectorView ConstTensor3View::operator()(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 ConstVectorView(
      mdata + mrr.mstart + r * mrr.mstride + mcr.mstart + c * mcr.mstride,
      mpr,
      p);
}

ConstIterator3D ConstTensor3View::begin() const {
  return ConstIterator3D(ConstMatrixView(mdata + mpr.mstart, mrr, mcr),
                         mpr.mstride);
}

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

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

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

ConstTensor3View::ConstTensor3View(Numeric* data,
                                   const Range& pp,
                                   const Range& pr,
                                   const Range& pc,
                                   const Range& np,
                                   const Range& nr,
                                   const Range& nc)
    : mpr(pp, np), mrr(pr, nr), mcr(pc, nc), mdata(data) {
  // Nothing to do here.
}

std::ostream& operator<<(std::ostream& os, const ConstTensor3View& v) {
  // Page iterators:
  ConstIterator3D ip = v.begin();
  const ConstIterator3D end_page = v.end();

  if (ip != end_page) {
    os << *ip;
    ++ip;
  }

  for (; ip != end_page; ++ip) {
    os << "\n\n";
    os << *ip;
  }

  return os;
}

// Functions for Tensor3View:
// -------------------------

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

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

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

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

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

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

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

VectorView Tensor3View::operator()(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 VectorView(
      mdata + mpr.mstart + p * mpr.mstride + mrr.mstart + r * mrr.mstride,
      mcr,
      c);
}

VectorView Tensor3View::operator()(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 VectorView(
      mdata + mpr.mstart + p * mpr.mstride + mcr.mstart + c * mcr.mstride,
      mrr,
      r);
}

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

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

Numeric* Tensor3View::get_c_array() {
  if (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 Tensor3View can only be converted to a plain C-array if it's pointing to a continuous block of data");

  return mdata;
}

const Numeric* Tensor3View::get_c_array() const {
  if (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 Tensor3View can only be converted to a plain C-array if it's pointing to a continuous block of data");

  return mdata;
}

Iterator3D Tensor3View::begin() {
  return Iterator3D(MatrixView(mdata + mpr.mstart, mrr, mcr), mpr.mstride);
}

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

Tensor3View& Tensor3View::operator=(const ConstTensor3View& m) {
  // Check that sizes are compatible:
  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;
}

Tensor3View& Tensor3View::operator=(const Tensor3View& m) {
  // Check that sizes are compatible:
  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;
}

Tensor3View& Tensor3View::operator=(const Tensor3& m) {
  // Check that sizes are compatible:
  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;
}

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

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

Numeric add(Numeric x, Numeric y) { return x + y; }

Tensor3View& Tensor3View::operator*=(Numeric x) {
  const Iterator3D ep = end();
  for (Iterator3D p = begin(); p != ep; ++p) {
    *p *= x;
  }
  return *this;
}

Tensor3View& Tensor3View::operator/=(Numeric x) {
  const Iterator3D ep = end();
  for (Iterator3D p = begin(); p != ep; ++p) {
    *p /= x;
  }
  return *this;
}

Tensor3View& Tensor3View::operator+=(Numeric x) {
  const Iterator3D ep = end();
  for (Iterator3D p = begin(); p != ep; ++p) {
    *p += x;
  }
  return *this;
}

Tensor3View& Tensor3View::operator-=(Numeric x) {
  const Iterator3D ep = end();
  for (Iterator3D p = begin(); p != ep; ++p) {
    *p -= x;
  }
  return *this;
}

Tensor3View& Tensor3View::operator*=(const ConstTensor3View& x) {
  assert(npages() == x.npages());
  assert(nrows() == x.nrows());
  assert(ncols() == x.ncols());
  ConstIterator3D xp = x.begin();
  Iterator3D p = begin();
  const Iterator3D ep = end();
  for (; p != ep; ++p, ++xp) {
    *p *= *xp;
  }
  return *this;
}

Tensor3View& Tensor3View::operator/=(const ConstTensor3View& x) {
  assert(npages() == x.npages());
  assert(nrows() == x.nrows());
  assert(ncols() == x.ncols());
  ConstIterator3D xp = x.begin();
  Iterator3D p = begin();
  const Iterator3D ep = end();
  for (; p != ep; ++p, ++xp) {
    *p /= *xp;
  }
  return *this;
}

Tensor3View& Tensor3View::operator+=(const ConstTensor3View& x) {
  assert(npages() == x.npages());
  assert(nrows() == x.nrows());
  assert(ncols() == x.ncols());
  ConstIterator3D xp = x.begin();
  Iterator3D p = begin();
  const Iterator3D ep = end();
  for (; p != ep; ++p, ++xp) {
    *p += *xp;
  }
  return *this;
}

Tensor3View& Tensor3View::operator-=(const ConstTensor3View& x) {
  assert(npages() == x.npages());
  assert(nrows() == x.nrows());
  assert(ncols() == x.ncols());
  ConstIterator3D xp = x.begin();
  Iterator3D p = begin();
  const Iterator3D ep = end();
  for (; p != ep; ++p, ++xp) {
    *p -= *xp;
  }
  return *this;
}

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

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

Tensor3View::Tensor3View(Numeric* data,
                         const Range& pp,
                         const Range& pr,
                         const Range& pc,
                         const Range& np,
                         const Range& nr,
                         const Range& nc)
    : ConstTensor3View(data, pp, pr, pc, np, nr, nc) {
  // Nothing to do here.
}

void copy(ConstIterator3D origin,
          const ConstIterator3D& end,
          Iterator3D 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, Iterator3D target, const Iterator3D& 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 Tensor3:
// ---------------------

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

Tensor3::Tensor3(Index p, Index r, Index c, Numeric fill)
    : Tensor3View(new Numeric[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, p * r * c, fill);
}

Tensor3::Tensor3(const ConstTensor3View& m)
    : Tensor3View(new Numeric[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());
}

Tensor3::Tensor3(const Tensor3& m)
    : Tensor3View(new Numeric[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, npages() * nrows() * ncols() * sizeof(Numeric));
}


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

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

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

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

  if (mpr.mextent != p || mrr.mextent != r || mcr.mextent != c) {
    delete[] mdata;
    mdata = new Numeric[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(Tensor3& t1, Tensor3& t2) {
  std::swap(t1.mpr, t2.mpr);
  std::swap(t1.mrr, t2.mrr);
  std::swap(t1.mcr, t2.mcr);
  std::swap(t1.mdata, t2.mdata);
}

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

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

  const ConstIterator3D xe = x.end();
  ConstIterator3D xi = x.begin();
  Iterator3D 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 ConstTensor3View& x) {
  const ConstIterator3D xe = x.end();
  ConstIterator3D 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 ConstTensor3View& x) {
  const ConstIterator3D xe = x.end();
  ConstIterator3D 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_tensor3view_get_elem(Tensor3View& tv, Index p, Index r, Index c) {
  return tv(p, r, c);
}

#endif


void mult(Tensor3View A, const ConstVectorView B, const ConstMatrixView C) {
  assert(A.npages() == B.nelem());
  assert(A.nrows() == C.nrows());
  assert(A.ncols() == C.ncols());

  for (Index ii = 0; ii < B.nelem(); ii++) {
    A(ii, joker, joker) = C;
    A(ii, joker, joker) *= B[ii];
  }
}