---

matrixadapter.h

Go to the documentation of this file.

#ifndef __MATRIXADAPTER_H__
#define __MATRIXADAPTER_H__

#include "matrix.h"
#include "generic_stdlib.h"
#include "allocatingpointer.h"
#include "scale.h"
#include "aarectangle.h"

namespace mat {


template <class M,
          class T=typename M::value_type,
          class ScaleT=Scale::Linear<T>,
          class RegionT=Boundary::AAArbitraryRectangle<double,int> >
class MatrixAdapter {
  typedef MatrixAdapter<M,T,ScaleT,RegionT> self;
public:
  
  typedef typename M::size_type  size_type;
  typedef T                      value_type;
  typedef ScaleT                 ScaleType;
  typedef RegionT                Region;
  typedef int                    Coordinate;
  
  inline MatrixAdapter(const M&         x,
                       const ScaleType& vscale_i=ScaleType(),
                       const Region&    region=Region(),
                       const double&    size_multiplier=1.0)
    : m(x), vscale(vscale_i),
      height(size_type(size_multiplier*(!region.isinfinite()? region.height() : x.nrows()))),
      width( size_type(size_multiplier*(!region.isinfinite()? region.width()  : x.ncols()))),
      originr(Coordinate(region.corners().yl)), originc(Coordinate(region.corners().xl)),
      size_divisor(size_multiplier? 1.0/size_multiplier : 0)
    {  assert(region.corners().xh<=region.corners().xl); assert(region.corners().yh<=region.corners().yl); }
  
  inline MatrixAdapter(M*               x,
                       const ScaleType& vscale_i=ScaleType(), 
                       const Region&    region=Region(),
                       const double&    size_multiplier=1.0)
    : m(*x), allocated(x), vscale(vscale_i),
      height(size_type(size_multiplier*(!region.isinfinite()? region.height() : x->nrows()))),
      width( size_type(size_multiplier*(!region.isinfinite()? region.width()  : x->ncols()))),
      originr(Coordinate(region.corners().yl)), originc(Coordinate(region.corners().xl)),
      size_divisor(size_multiplier? 1.0/size_multiplier : 0)
    {  assert(region.corners().xh<=region.corners().xl); assert(region.corners().yh<=region.corners().yl); }
  
  inline value_type operator()(const size_type row, const size_type col) const {
    const size_type  lower_bound=MatIndex(0);
    const value_type default_value=0;
    const Coordinate r=row-lower_bound;
    const Coordinate c=col-lower_bound;
    /* The 0.000001 is to compensate for floating point truncation
       errors for some common size scales, e.g. multiples of 3. */
    const Coordinate sr=Coordinate(floor((r*size_divisor)+0.000001))-originr;
    const Coordinate sc=Coordinate(floor((c*size_divisor)+0.000001))-originc;

    return value_type(vscale(inbounds(sr,sc)? mat::elem(m,sr,sc): default_value));
  }
    
  
  inline size_type nrows() const { return height; }

  inline size_type ncols() const { return width; }
  
protected:
  const M& m;
  MemoryReference<M> allocated;

  ScaleT vscale;
  size_type  height,width;
  Coordinate originr,originc;
  double size_divisor;

  inline bool inbounds(const size_type r, const size_type c) const {
    return (int(r)>=0 && r<m.nrows() &&
            int(c)>=0 && c<m.ncols());
  }
};

 
template <class T, class Array>
class CArrayMatrixAdapter {
  typedef CArrayMatrixAdapter<T,Array> self;
public:
  
  typedef size_t size_type;
  typedef T value_type;
  
  inline CArrayMatrixAdapter(const Array& x, const size_type nrows, const size_type ncols)
    : a(x), height(nrows), width(ncols) { }

  inline value_type operator()(const size_type row, const size_type col) const {
    const size_type  lower_bound=MatIndex(0);
    assert((row-lower_bound)<height);
    assert((col-lower_bound)<width);
    //return a[row-lower_bound][col-lower_bound];
    return a[col-lower_bound][row-lower_bound];  // Temporary: Swaps to match flipped conventions
  }
  
  inline size_type nrows() const { return height; }

  inline size_type ncols() const { return width; }
  
protected:
  const Array& a;
  const size_type height, width;
};

 

template <class T>
class MatrixInterface {
  typedef MatrixInterface<T> self;
public:
  
  typedef int size_type;
  typedef T   value_type;
  
  virtual ~MatrixInterface() { };
 
  virtual value_type operator()(const size_type row, const size_type col) const =0;
  
  virtual size_type nrows() const =0;

  virtual size_type ncols() const =0;
};

 
  
template <class M,
          class T=typename M::value_type,
          class ScaleT=Scale::Linear<T>,
          class RegionT=Boundary::AAArbitraryRectangle<double,int> >
class MatrixInterfaceAdapter : public MatrixInterface<T> {
  typedef MatrixInterfaceAdapter<M,T,ScaleT,RegionT> self;

public:  
  typedef typename MatrixInterface<T>::size_type  size_type;
  typedef typename MatrixInterface<T>::value_type value_type;
  typedef ScaleT   ScaleType;
  typedef RegionT  Region;

  inline MatrixInterfaceAdapter(const M&         x,
                                const ScaleType& vscale=ScaleType(), 
                                const Region&    region=Region(),
                                const double&    size_multiplier=1.0)
    : ma(x,vscale,region,size_multiplier) { }
  
  inline MatrixInterfaceAdapter(M*               x,
                                const ScaleType& vscale=ScaleType(), 
                                const Region&    region=Region(),
                                const double&    size_multiplier=1.0)
    : ma(x,vscale,region,size_multiplier) { }
  
  inline value_type operator()(const size_type row, const size_type col) const 
    {  return value_type(ma(typename M::size_type(row),
                            typename M::size_type(col)));  }
  
  inline size_type nrows() const { return ma.nrows(); }

  inline size_type ncols() const { return ma.ncols(); }
  
protected:
  MatrixAdapter<M,value_type> ma;
};



template <class T=double>
class MatrixInterfaceConstant : public MatrixInterface<T> {
  typedef MatrixInterfaceConstant<T> self;

public:
  typedef typename MatrixInterface<T>::size_type  size_type;
  typedef typename MatrixInterface<T>::value_type value_type;
  
  inline MatrixInterfaceConstant(const value_type& a=1.0, size_type nr=1, size_type nc=1)
    : val(a), height(nr), width(nc) { }
  
  inline value_type operator()(const size_type, const size_type) const 
    {  return val;  }
  
  inline size_type nrows() const { return height; }

  inline size_type ncols() const { return width; }
  
protected:
  const T val;
  const size_type height,width;
};


template <class M, class BinaryFunction, class T=typename M::value_type >
class MatrixInterfaceBinaryAdapter : public MatrixInterface<T> {
  typedef MatrixInterfaceBinaryAdapter<M,T> self;
  
public:
  typedef typename MatrixInterface<T>::size_type  size_type;
  typedef typename MatrixInterface<T>::value_type value_type;

  inline MatrixInterfaceBinaryAdapter(const M& A, const M& B, const BinaryFunction& fn)
    : MA(A), MB(B), op(fn) {
      assert(MA.nrows()==MB.nrows());
      assert(MA.ncols()==MB.ncols());
    }
  
  virtual value_type operator()(const size_type row, const size_type col) const 
    {  return value_type( op( MA(row,col), MB(row,col) ));  }
   
  virtual size_type nrows() const { return MA.nrows(); }

  virtual size_type ncols() const { return MA.ncols(); }
  
protected:
  const M& MA;
  const M& MB;
  const BinaryFunction& op;
};


} /* namespace mat */


#endif /* __MATRIXADAPTER_H__ */

---