matpackV.cc

Go to the documentation of this file.

/* Copyright (C) 2002-2008 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 "matpackV.h"

// Functions for ConstTensor5View:
// ------------------------------

Index ConstTensor5View::nshelves() const
{
  return msr.mextent;
}

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

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

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

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

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

ConstTensor4View ConstTensor5View::operator()(const Range& s,
                                                     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 ConstTensor4View(mdata +
                          mcr.mstart + c * mcr.mstride,
                          msr, mbr, mpr, mrr,
                          s,   b,   p,   r);
}

ConstTensor4View ConstTensor5View::operator()(const Range& s,
                                                     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 ConstTensor4View(mdata +
                          mrr.mstart + r * mrr.mstride,
                          msr, mbr, mpr, mcr,
                          s,   b,   p,   c);
}

ConstTensor4View ConstTensor5View::operator()(const Range& s,
                                                     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 ConstTensor4View(mdata +
                          mpr.mstart + p * mpr.mstride,
                          msr, mbr, mrr, mcr,
                          s,   b,   r,   c);
}

ConstTensor4View ConstTensor5View::operator()(const Range& s,
                                                     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 ConstTensor4View(mdata +
                          mbr.mstart + b * mbr.mstride,
                          msr, mpr, mrr, mcr,
                          s,   p,   r,   c);
}

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

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

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

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

ConstTensor3View ConstTensor5View::operator()(const Range& s,
                                                     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 ConstTensor3View(mdata +
                          mpr.mstart + p * mpr.mstride +
                          mcr.mstart + c * mcr.mstride,
                          msr, mbr, mrr,
                          s,   b,   r);
}

ConstTensor3View ConstTensor5View::operator()(const Range& s,
                                                     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 ConstTensor3View(mdata +
                          mpr.mstart + p * mpr.mstride +
                          mrr.mstart + r * mrr.mstride,
                          msr, mbr, mcr,
                          s,   b,   c);
}

ConstTensor3View ConstTensor5View::operator()(const Range& s,
                                                     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 ConstTensor3View(mdata +
                          mbr.mstart + b * mbr.mstride +
                          mrr.mstart + r * mrr.mstride,
                          msr, mpr, mcr,
                          s,   p,   c);
}

ConstTensor3View ConstTensor5View::operator()(const Range& s,
                                                     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 ConstTensor3View(mdata +
                          mbr.mstart + b * mbr.mstride +
                          mcr.mstart + c * mcr.mstride,
                          msr, mpr, mrr,
                          s,   p,   r);
}

ConstTensor3View ConstTensor5View::operator()(const Range& s,
                                                     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 ConstTensor3View(mdata +
                          mbr.mstart + b * mbr.mstride +
                          mpr.mstart + p * mpr.mstride,
                          msr, mrr, mcr,
                          s,   r,   c);
}

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

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

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

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

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

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

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

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

ConstMatrixView ConstTensor5View::operator()(const Range& s,
                                                    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 ConstMatrixView(mdata +
                         mpr.mstart + p * mpr.mstride +
                         mrr.mstart + r * mrr.mstride +
                         mcr.mstart + c * mcr.mstride,
                         msr, mbr,
                         s,   b);
}

ConstMatrixView ConstTensor5View::operator()(const Range& s,
                                                    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 ConstMatrixView(mdata +
                         mbr.mstart + b * mbr.mstride +
                         mrr.mstart + r * mpr.mstride +
                         mcr.mstart + c * mcr.mstride,
                         msr, mpr,
                         s,   p);
}

ConstMatrixView ConstTensor5View::operator()(const Range& s,
                                                    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 ConstMatrixView(mdata +
                         mbr.mstart + b * mbr.mstride +
                         mpr.mstart + p * mpr.mstride +
                         mcr.mstart + c * mcr.mstride,
                         msr, mrr,
                         s,   r);
}

ConstMatrixView ConstTensor5View::operator()(const Range& s,
                                                    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 ConstMatrixView(mdata +
                         mbr.mstart + b * mbr.mstride +
                         mpr.mstart + p * mpr.mstride +
                         mrr.mstart + r * mrr.mstride,
                         msr, mcr,
                         s,   c);
}

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

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

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

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

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

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

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

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

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

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

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

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

ConstVectorView ConstTensor5View::operator()(const Range& s,
                                                    Index b,
                                                    Index p,
                                                    Index r,
                                                    Index c       ) const
{
  // Check that b, p, r and c 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 ConstVectorView(mdata +
                         mbr.mstart + b * mbr.mstride +
                         mpr.mstart + p * mpr.mstride +
                         mrr.mstart + r * mrr.mstride +
                         mcr.mstart + c * mcr.mstride,
                         msr,
                         s);
}

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

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

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

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

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

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

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

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

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

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

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

ConstTensor5View::ConstTensor5View() :
  msr(0,0,1),
  mbr(0,0,1),
  mpr(0,0,1),
  mrr(0,0,1),
  mcr(0,0,1),
  mdata(NULL)
{
  // Nothing to do here.
}

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

ConstTensor5View::ConstTensor5View(Numeric *data,
                                          const Range& ps,
                                          const Range& pb,
                                          const Range& pp,
                                          const Range& pr,
                                          const Range& pc,
                                          const Range& ns,
                                          const Range& nb,
                                          const Range& np,
                                          const Range& nr,
                                          const Range& nc) :
  msr(ps,ns),
  mbr(pb,nb),
  mpr(pp,np),
  mrr(pr,nr),
  mcr(pc,nc),
  mdata(data)
{
  // Nothing to do here.
}

ostream& operator<<(ostream& os, const ConstTensor5View& v)
{
  // Page iterators:
  ConstIterator5D is = v.begin();
  const ConstIterator5D end_shelf = v.end();

  if ( is != end_shelf ) {
    os << *is;
    ++is;
  }

  for ( ; is != end_shelf; ++is ) {
    os << "\n\n";
    os << *is;
  }

  return os;
}


// Functions for Tensor5View:
// -------------------------

ConstTensor5View Tensor5View::operator()(const Range& s,
                                                const Range& b,
                                                const Range& p,
                                                const Range& r,
                                                const Range& c) const
{
  return ConstTensor5View::operator()(s,b,p,r,c);
}

ConstTensor4View Tensor5View::operator()(const Range& s,
                                                const Range& b,
                                                const Range& p,
                                                const Range& r,
                                                Index c       ) const
{
  return ConstTensor5View::operator()(s,b,p,r,c);
}

ConstTensor4View Tensor5View::operator()(const Range& s,
                                                const Range& b,
                                                const Range& p,
                                                Index r,
                                                const Range& c) const
{
  return ConstTensor5View::operator()(s,b,p,r,c);
}

ConstTensor4View Tensor5View::operator()(const Range& s,
                                                const Range& b,
                                                Index p,
                                                const Range& r,
                                                const Range& c) const
{
  return ConstTensor5View::operator()(s,b,p,r,c);
}

ConstTensor4View Tensor5View::operator()(const Range& s,
                                                Index b,
                                                const Range& p,
                                                const Range& r,
                                                const Range& c) const
{
  return ConstTensor5View::operator()(s,b,p,r,c);
}

ConstTensor4View Tensor5View::operator()(Index s,
                                                const Range& b,
                                                const Range& p,
                                                const Range& r,
                                                const Range& c) const
{
  return ConstTensor5View::operator()(s,b,p,r,c);
}

ConstTensor3View Tensor5View::operator()(const Range& s,
                                                const Range& b,
                                                const Range& p,
                                                Index r,
                                                Index c       ) const
{
  return ConstTensor5View::operator()(s,b,p,r,c);
}

ConstTensor3View Tensor5View::operator()(const Range& s,
                                                const Range& b,
                                                Index p,
                                                const Range& r,
                                                Index c       ) const
{
  return ConstTensor5View::operator()(s,b,p,r,c);
}

ConstTensor3View Tensor5View::operator()(const Range& s,
                                                const Range& b,
                                                Index p,
                                                Index r,
                                                const Range& c) const
{
  return ConstTensor5View::operator()(s,b,p,r,c);
}

ConstTensor3View Tensor5View::operator()(const Range& s,
                                                Index b,
                                                const Range& p,
                                                Index r,
                                                const Range& c) const
{
  return ConstTensor5View::operator()(s,b,p,r,c);
}

ConstTensor3View Tensor5View::operator()(const Range& s,
                                                Index b,
                                                const Range& p,
                                                const Range& r,
                                                Index c       ) const
{
  return ConstTensor5View::operator()(s,b,p,r,c);
}

ConstTensor3View Tensor5View::operator()(const Range& s,
                                                Index b,
                                                Index p,
                                                const Range& r,
                                                const Range& c) const
{
  return ConstTensor5View::operator()(s,b,p,r,c);
}

ConstTensor3View Tensor5View::operator()(Index s,
                                                const Range& b,
                                                Index p,
                                                const Range& r,
                                                const Range& c) const
{
  return ConstTensor5View::operator()(s,b,p,r,c);
}

ConstTensor3View Tensor5View::operator()(Index s,
                                                const Range& b,
                                                const Range& p,
                                                Index r,
                                                const Range& c) const
{
  return ConstTensor5View::operator()(s,b,p,r,c);
}

ConstTensor3View Tensor5View::operator()(Index s,
                                                const Range& b,
                                                const Range& p,
                                                const Range& r,
                                                Index c       ) const
{
  return ConstTensor5View::operator()(s,b,p,r,c);
}

ConstTensor3View Tensor5View::operator()(Index s,
                                                Index b,
                                                const Range& p,
                                                const Range& r,
                                                const Range& c) const
{
  return ConstTensor5View::operator()(s,b,p,r,c);
}

ConstMatrixView Tensor5View::operator()(const Range& s,
                                               const Range& b,
                                               Index p,
                                               Index r,
                                               Index c       ) const
{
  return ConstTensor5View::operator()(s,b,p,r,c);
}

ConstMatrixView Tensor5View::operator()(const Range& s,
                                               Index b,
                                               const Range& p,
                                               Index r,
                                               Index c       ) const
{
  return ConstTensor5View::operator()(s,b,p,r,c);
}

ConstMatrixView Tensor5View::operator()(const Range& s,
                                               Index b,
                                               Index p,
                                               const Range& r,
                                               Index c       ) const
{
  return ConstTensor5View::operator()(s,b,p,r,c);
}

ConstMatrixView Tensor5View::operator()(const Range& s,
                                               Index b,
                                               Index p,
                                               Index r,
                                               const Range& c) const
{
  return ConstTensor5View::operator()(s,b,p,r,c);
}

ConstMatrixView Tensor5View::operator()(Index s,
                                               const Range& b,
                                               Index p,
                                               Index r,
                                               const Range& c) const
{
  return ConstTensor5View::operator()(s,b,p,r,c);
}

ConstMatrixView Tensor5View::operator()(Index s,
                                               const Range& b,
                                               Index p,
                                               const Range& r,
                                               Index c       ) const
{
  return ConstTensor5View::operator()(s,b,p,r,c);
}

ConstMatrixView Tensor5View::operator()(Index s,
                                               const Range& b,
                                               const Range& p,
                                               Index r,
                                               Index c       ) const
{
  return ConstTensor5View::operator()(s,b,p,r,c);
}

ConstMatrixView Tensor5View::operator()(Index s,
                                               Index b,
                                               const Range& p,
                                               const Range& r,
                                               Index c       ) const
{
  return ConstTensor5View::operator()(s,b,p,r,c);
}

ConstMatrixView Tensor5View::operator()(Index s,
                                               Index b,
                                               const Range& p,
                                               Index r,
                                               const Range& c) const
{
  return ConstTensor5View::operator()(s,b,p,r,c);
}

ConstMatrixView Tensor5View::operator()(Index s,
                                               Index b,
                                               Index p,
                                               const Range& r,
                                               const Range& c) const
{
  return ConstTensor5View::operator()(s,b,p,r,c);
}

ConstVectorView Tensor5View::operator()(const Range& s,
                                               Index b,
                                               Index p,
                                               Index r,
                                               Index c       ) const
{
  return ConstTensor5View::operator()(s,b,p,r,c);
}

ConstVectorView Tensor5View::operator()(Index s,
                                               const Range& b,
                                               Index p,
                                               Index r,
                                               Index c       ) const
{
  return ConstTensor5View::operator()(s,b,p,r,c);
}

ConstVectorView Tensor5View::operator()(Index s,
                                               Index b,
                                               const Range& p,
                                               Index r,
                                               Index c       ) const
{
  return ConstTensor5View::operator()(s,b,p,r,c);
}

ConstVectorView Tensor5View::operator()(Index s,
                                               Index b,
                                               Index p,
                                               const Range& r,
                                               Index c       ) const
{
  return ConstTensor5View::operator()(s,b,p,r,c);
}

ConstVectorView Tensor5View::operator()(Index s,
                                               Index b,
                                               Index p,
                                               Index r,
                                               const Range& c) const
{
  return ConstTensor5View::operator()(s,b,p,r,c);
}

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

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

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

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

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

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

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

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

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

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

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

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

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

Tensor3View Tensor5View::operator()(const Range& s,
                                           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 Tensor3View(mdata +
                     mpr.mstart + p * mpr.mstride +
                     mcr.mstart + c * mcr.mstride,
                     msr, mbr, mrr,
                     s,   b,   r);
}

Tensor3View Tensor5View::operator()(const Range& s,
                                           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 Tensor3View(mdata +
                     mpr.mstart + p * mpr.mstride +
                     mrr.mstart + r * mrr.mstride,
                     msr, mbr, mcr,
                     s,   b,   c);
}

Tensor3View Tensor5View::operator()(const Range& s,
                                           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 Tensor3View(mdata +
                     mbr.mstart + b * mbr.mstride +
                     mrr.mstart + r * mrr.mstride,
                     msr, mpr, mcr,
                     s,   p,   c);
}

Tensor3View Tensor5View::operator()(const Range& s,
                                           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 Tensor3View(mdata +
                     mbr.mstart + b * mbr.mstride +
                     mcr.mstart + c * mcr.mstride,
                     msr, mpr, mrr,
                     s,   p,   r);
}

Tensor3View Tensor5View::operator()(const Range& s,
                                           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 Tensor3View(mdata +
                     mbr.mstart + b * mbr.mstride +
                     mpr.mstart + p * mpr.mstride,
                     msr, mrr, mcr,
                     s,   r,   c);
}

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

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

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

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

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

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

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

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

MatrixView Tensor5View::operator()(const Range& s,
                                          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 MatrixView(mdata +
                    mpr.mstart + p * mpr.mstride +
                    mrr.mstart + r * mrr.mstride +
                    mcr.mstart + c * mcr.mstride,
                    msr, mbr,
                    s,   b);
}

MatrixView Tensor5View::operator()(const Range& s,
                                          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 MatrixView(mdata +
                    mbr.mstart + b * mbr.mstride +
                    mrr.mstart + r * mpr.mstride +
                    mcr.mstart + c * mcr.mstride,
                    msr, mpr,
                    s,   p);
}

MatrixView Tensor5View::operator()(const Range& s,
                                          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 MatrixView(mdata +
                    mbr.mstart + b * mbr.mstride +
                    mpr.mstart + p * mpr.mstride +
                    mcr.mstart + c * mcr.mstride,
                    msr, mrr,
                    s,   r);
}

MatrixView Tensor5View::operator()(const Range& s,
                                          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 MatrixView(mdata +
                    mbr.mstart + b * mbr.mstride +
                    mpr.mstart + p * mpr.mstride +
                    mrr.mstart + r * mrr.mstride,
                    msr, mcr,
                    s,   c);
}

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

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

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

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

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

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

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

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

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

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

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

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

VectorView Tensor5View::operator()(const Range& s,
                                          Index b,
                                          Index p,
                                          Index r,
                                          Index c)
{
  // Check that b, p, r and c 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 VectorView(mdata +
                    mbr.mstart + b * mbr.mstride +
                    mpr.mstart + p * mpr.mstride +
                    mrr.mstart + r * mrr.mstride +
                    mcr.mstart + c * mcr.mstride,
                    msr,
                    s);
}

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

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

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

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

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

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

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

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


ConstIterator5D Tensor5View::begin() const
{
  return ConstTensor5View::begin();
}

ConstIterator5D Tensor5View::end() const
{
  return ConstTensor5View::end();
}

Iterator5D Tensor5View::begin()
{
  return Iterator5D( Tensor4View(mdata + msr.mstart,
                                 mbr, mpr, mrr, mcr),
                     msr.mstride );
}

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

Tensor5View& Tensor5View::operator=(const ConstTensor5View& m)
{
  // Check that sizes are compatible:
  assert( msr.mextent == m.msr.mextent );
  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;
}

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

Tensor5View& Tensor5View::operator=(const Tensor5& m)
{
  // Check that sizes are compatible:
  assert( msr.mextent == m.msr.mextent );
  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;
}

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

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

Tensor5View& Tensor5View::operator*=(Numeric x)
{
  const Iterator5D es = end();
  for ( Iterator5D s = begin(); s != es ; ++s )
  {
    *s *= x;
  }
  return *this;
}

Tensor5View& Tensor5View::operator/=(Numeric x)
{
  const Iterator5D es = end();
  for ( Iterator5D s = begin(); s != es ; ++s )
  {
    *s /= x;
  }
  return *this;
}

Tensor5View& Tensor5View::operator+=(Numeric x)
{
  const Iterator5D es = end();
  for ( Iterator5D s = begin(); s != es ; ++s )
  {
    *s += x;
  }
  return *this;
}

Tensor5View& Tensor5View::operator-=(Numeric x)
{
  const Iterator5D es = end();
  for ( Iterator5D s = begin(); s != es ; ++s )
  {
    *s -= x;
  }
  return *this;
}

Tensor5View& Tensor5View::operator*=(const ConstTensor5View& x)
{
  assert( nshelves() == x.nshelves() );
  assert( nbooks()   == x.nbooks()   );
  assert( npages()   == x.npages()   );
  assert( nrows()    == x.nrows()    );
  assert( ncols()    == x.ncols()    );
  ConstIterator5D  xs = x.begin();
  Iterator5D        s = begin();
  const Iterator5D es = end();
  for ( ; s != es ; ++s, ++xs )
    {
      *s *= *xs;
    }
  return *this;
}

Tensor5View& Tensor5View::operator/=(const ConstTensor5View& x)
{
  assert( nshelves() == x.nshelves() );
  assert( nbooks() == x.nbooks()     );
  assert( npages() == x.npages()     );
  assert( nrows()  == x.nrows()      );
  assert( ncols()  == x.ncols()      );
  ConstIterator5D  xs = x.begin();
  Iterator5D        s = begin();
  const Iterator5D es = end();
  for ( ; s != es ; ++s, ++xs )
    {
      *s /= *xs;
    }
  return *this;
}

Tensor5View& Tensor5View::operator+=(const ConstTensor5View& x)
{
  assert( nshelves() == x.nshelves() );
  assert( nbooks() == x.nbooks()     );
  assert( npages() == x.npages()     );
  assert( nrows()  == x.nrows()      );
  assert( ncols()  == x.ncols()      );
  ConstIterator5D  xs = x.begin();
  Iterator5D        s = begin();
  const Iterator5D es = end();
  for ( ; s != es ; ++s, ++xs )
    {
      *s += *xs;
    }
  return *this;
}

Tensor5View& Tensor5View::operator-=(const ConstTensor5View& x)
{
  assert( nshelves() == x.nshelves() );
  assert( nbooks() == x.nbooks()     );
  assert( npages() == x.npages()     );
  assert( nrows()  == x.nrows()      );
  assert( ncols()  == x.ncols()      );
  ConstIterator5D  xs = x.begin();
  Iterator5D        s = begin();
  const Iterator5D es = end();
  for ( ; s != es ; ++s, ++xs )
    {
      *s -= *xs;
    }
  return *this;
}

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

Tensor5View::Tensor5View() :
  ConstTensor5View()
{
  // Nothing to do here.
}

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

Tensor5View::Tensor5View(Numeric *data,
                                const Range& ps,
                                const Range& pb,
                                const Range& pp,
                                const Range& pr,
                                const Range& pc,
                                const Range& ns,
                                const Range& nb,
                                const Range& np,
                                const Range& nr,
                                const Range& nc) :
  ConstTensor5View(data, ps, pb, pp, pr, pc, ns, nb, np, nr, nc)
{
  // Nothing to do here.
}

void copy(ConstIterator5D origin,
                 const ConstIterator5D& end,
                 Iterator5D 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,
                 Iterator5D target,
                 const Iterator5D& 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 Tensor5:
// ---------------------

Tensor5::Tensor5() :
  Tensor5View::Tensor5View()
{
  // Nothing to do here. However, note that the default constructor
  // for Tensor5View has been called in the initializer list. That is
  // crucial, otherwise internal range objects will not be properly
  // initialized.
}

Tensor5::Tensor5(Index s, Index b, Index p, Index r, Index c) :
  Tensor5View( new Numeric[s*b*p*r*c],
               Range( 0, s, 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.
}

Tensor5::Tensor5(Index s, Index b, Index p, Index r, Index c, Numeric fill) :
  Tensor5View( new Numeric[s*b*p*r*c],
               Range( 0, s, 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:
  const Numeric *stop = mdata + s*b*p*r*c;
  for ( Numeric *x = mdata; x < stop; ++x )
    *x = fill;
}

Tensor5::Tensor5(const ConstTensor5View& m) :
  Tensor5View( new Numeric[m.nshelves()*m.nbooks()*m.npages()*m.nrows()*m.ncols()],
               Range( 0, m.nshelves(), 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() );
}

Tensor5::Tensor5(const Tensor5& m) :
  Tensor5View( new Numeric[m.nshelves()*m.nbooks()*m.npages()*m.nrows()*m.ncols()],
               Range( 0, m.nshelves(), 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.
  copy( m.begin(), m.end(), begin() );
}


Tensor5& Tensor5::operator=(const Tensor5& m)
{
  //  cout << "Tensor5 copy: m = " << m.nrows() << " " << m.ncols() << "\n";
  //  cout << "              n = " << nrows() << " " << ncols() << "\n";

  resize( m.msr.mextent,
          m.mbr.mextent,
          m.mpr.mextent,
          m.mrr.mextent,
          m.mcr.mextent );
  copy( m.begin(), m.end(), begin() );
  return *this;
}

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

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

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

      msr.mstart = 0;
      msr.mextent = s;
      msr.mstride = 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;
    }
}

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


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

  const ConstIterator5D xe = x.end();
  ConstIterator5D       xi = x.begin();
  Iterator5D            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 ConstTensor5View& x)
{
  const ConstIterator5D xe = x.end();
  ConstIterator5D       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 ConstTensor5View& x)
{
  const ConstIterator5D xe = x.end();
  ConstIterator5D       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_tensor5view_get_elem (Tensor5View& tv, Index s, Index b, Index p,
                                    Index r, Index c)
{
  return tv(s, b, p, r, c);
}

#endif

---