matpackIV.h

Go to the documentation of this file.

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

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

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

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

#ifndef matpackIV_h
#define matpackIV_h

#include "matpackIII.h"

class Iterator4D {
public:
  // Constructors:
  Iterator4D() : msv(), mstride(0) { /* Nothing to do here. */ }

  Iterator4D(const Iterator4D& o) : msv(o.msv), mstride(o.mstride)
      { /* Nothing to do here. */ }

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

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

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

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

private:
  Tensor3View msv;
  Index mstride;
};

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

  ConstIterator4D() : msv(), mstride(0) { /* Nothing to do here. */ }

  ConstIterator4D(const ConstIterator4D& o) : msv(o.msv), mstride(o.mstride)
      { /* Nothing to do here. */ }

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

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

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

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

private:
  ConstTensor3View msv;
  Index mstride;
};


// Declare class Tensor4:
class Tensor4;


class ConstTensor4View {
public:
  // Member functions:
  Index nbooks() const;
  Index npages() const;
  Index nrows()  const;
  Index ncols()  const;

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

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

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

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

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

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

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

  virtual ~ConstTensor4View() {};

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

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

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

  // Data members:
  // -------------
  Range mbr;
  Range mpr;
  Range mrr;
  Range mcr;
  Numeric *mdata;
};

class Tensor4View : public ConstTensor4View {
public:

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

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

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

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

  Numeric operator()(Index b, Index p, Index r, Index c) const
    { return ConstTensor4View::operator()(b,p,r,c); }

  // Non-const index operators:

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

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

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

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

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

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

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

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

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

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

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

  virtual ~Tensor4View() {};

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

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

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


class Tensor4 : public Tensor4View {
public:
  // Constructors:
  Tensor4();
  Tensor4(Index b, Index p, Index r, Index c);
  Tensor4(Index b, Index p, Index r, Index c, Numeric fill);
  Tensor4(const ConstTensor4View& v);
  Tensor4(const Tensor4& v);

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

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

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


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

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

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

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

Numeric max(const ConstTensor4View& x);

Numeric min(const ConstTensor4View& x);

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

// Helper function for debugging
#ifndef NDEBUG

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

#endif

#endif    // matpackIV_h

---