synaps/linalg/lasym2d.h

#ifndef array2d_H
#define 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 lapack {  

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

    repsym<C> & operator=(const repsym<C> & v)
      {
        this->linalg::rep1d<C>::operator=(v);
        nbrow_ = v.nbrow(); nbcol_ = v.nbcol();
        return *this;
      }

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

  template<class C>
  void reserve(repsym<C> & m, size_type i,size_type j)
  {
    linalg::reserve(m,i*j);
    m.nbrow_=i; m.nbcol_=j;
  }

};
//----------------------------------------------------------------------

__END_NAMESPACE_SYNAPS

#endif //lasym2d_H