synaps/linalg/rep2d.h

#ifndef SYNAPS_LINALG_ARRAY2D_H
#define SYNAPS_LINALG_ARRAY2D_H
//======================================================================
#include <synaps/init.h>
#include <synaps/arithm/Norm.h>
#include <synaps/linalg/MethodName.h>
#include <synaps/base/stride_iterator.h>
#include <synaps/linalg/rep1d.h>


__BEGIN_NAMESPACE_SYNAPS

//======================================================================
namespace linalg {
//----------------------------------------------------------------------
  typedef unsigned size_type;
  //extern double TOL;
//----------------------------------------------------------------------
template <class C>
struct rep2d : public rep1d<C> {
  typedef C*                              col_iterator;
  typedef stride_iterator<C,C*,size_type> row_iterator;
 
  size_type nbrow_, nbcol_;
 
  rep2d() {}
  rep2d(const rep2d<C> & v): 
    linalg::rep1d<C>(v), nbrow_(v.nbrow_), nbcol_(v.nbcol_) {}
  rep2d(size_type i,size_type j=1): 
    linalg::rep1d<C>(i*j), nbrow_(i),nbcol_(j) {}
  rep2d(size_type i, size_type j, C* t): 
    linalg::rep1d<C>(i*j,t), nbrow_(i), nbcol_(j) {}
  rep2d(const char * nm);

  rep2d<C> & operator=(const rep2d<C> & v);
 
  C &       operator()(size_type i, size_type j) 
  {
    assert(i < nbrow_ && j < nbcol_);
    return this->tab_[i+nbrow_*j];
  }

  const C & operator()(size_type i, size_type j) const 
  {
    return this->tab_[i+nbrow_*j];
  }  
  size_type nbrow() const {return nbrow_;}
  size_type nbcol() const {return nbcol_;}

  void resize(size_type i,size_type j)
    {
      nbrow_=i; nbcol_=j;
      this->linalg::rep1d<C>::resize(i*j); 
    }
  
};

//----------------------------------------------------------------------
template<class C>
typename linalg::rep2d<C>::col_iterator 
  create(typename linalg::rep2d<C>::col_iterator s,
         const linalg::rep2d<C> & a, unsigned int i, unsigned int j) 
{
  typedef  typename linalg::rep2d<C>::col_iterator iterator;
  return iterator(&a(i,j));
}
//----------------------------------------------------------------------
template<class C>
typename linalg::rep2d<C>::row_iterator 
  create(typename linalg::rep2d<C>::row_iterator s,
         const linalg::rep2d<C> & a, unsigned int i, unsigned int j) 
{
  typedef  typename linalg::rep2d<C>::row_iterator iterator;
  return iterator((C*)(&a(i,j)),a.nbrow());
}
//----------------------------------------------------------------------
template<class C>
typename linalg::rep2d<C>::row_iterator 
  begin_row(const linalg::rep2d<C> & a, unsigned int i) 
{
  return linalg::rep2d<C>::row_iterator(&a(i,0));
}
//----------------------------------------------------------------------
template<class C>
typename linalg::rep2d<C>::col_iterator 
  begin_col(const linalg::rep2d<C> & a, unsigned int i) 
{
  return linalg::rep2d<C>::col_iterator(&a(0,i));
}
//----------------------------------------------------------------------
template<class C>
typename linalg::rep2d<C>::row_iterator 
  end_row(const linalg::rep2d<C> & a, unsigned int i) 
{
  return linalg::rep2d<C>::row_iterator(&a(i,a.nbcol()));
}
//----------------------------------------------------------------------
template<class C>
typename linalg::rep2d<C>::col_iterator 
  end_col(const linalg::rep2d<C> & a, unsigned int i) 
{
  return linalg::rep2d<C>::col_iterator(&a(a.nbrow(),i));
}
//====================================================================
} //CLOSE linalg
__END_NAMESPACE_SYNAPS

//----------------------------------------------------------------------
#include "synaps/linalg/array2d.C"
//----------------------------------------------------------------------
#endif // SYNAPS_LINALG_ARRAY2D_H