synaps/linalg/MatrDse.h

Go to the documentation of this file.

/*********************************************************************
*      This file is part of the source code of SYNAPS kernel.        *
*   Author(s): B. Mourrain, GALAAD, INRIA                            *
**********************************************************************
History: 
**********************************************************************/
#ifndef synaps_linalg_MatrDse_H
#define synaps_linalg_MatrDse_H
//----------------------------------------------------------------------
#include <sstream>
#include <list>
#include <synaps/init.h>
#include <synaps/base/type.h>
#include <synaps/base/Range.h>
#include <synaps/linalg/texp.h>
#include <synaps/arithm/let.h>
#include <synaps/arithm/Cst.h>
#include <synaps/linalg/MATRIX.m>
#include <synaps/linalg/VectDse.h>
#include <synaps/base/seq1d.h>
#include <synaps/linalg/rep2d.h>

//--------------------------------------------------------------------
__BEGIN_NAMESPACE_SYNAPS
//====================================================================
//--------------------------------------------------------------------
template<class C, class R=linalg::rep2d<C> > 
struct MatrDse 
{
  typedef VectDse<C> vector_type;
  typedef VectDse<C> row_type;
  typedef VectDse<C> col_type;
  shared_object<R>  data;
  R &       rep()       {return (*data);}
  const R & rep() const {return (*data);}
  
  typedef typename R::size_type     size_type;
  typedef C                         value_type;
  typedef C                         coeff_t;
  typedef typename R::row_iterator  row_iterator;
  typedef typename R::col_iterator  col_iterator;
  
  
  typedef R                         rep_type;
  typedef MatrDse<C, R>               self_t;
  
  MatrDse() {}
  MatrDse(const R & r): data(r) {}
  MatrDse(size_type m, size_type n) {
    rep().resize(m,n); 
  }
  MatrDse(size_type m, size_type n, const value_type & c) { 
    using MATRIX::init; rep().resize(m,n); init(rep(),c); 
  }
  MatrDse( size_type m, size_type n, const char* str, ByRow ){ 
    using MATRIX::init; std::istringstream ins(str); init(rep(),m,n,ins,ByRow()); 
  }
  MatrDse(size_type m, size_type n, const char * str, ByCol= ByCol()) { 
    using MATRIX::init; std::istringstream ins(str); init(rep(),m,n,ins,ByCol()); 
  };
  template<class T>
  MatrDse(size_type m, size_type n, const value_type * src, const T & t = ByCol()) { 
    using MATRIX::init; init( this->rep(), m, n, src, t ); 
  };
  // Copy constructors.
  MatrDse(const self_t & M): data(M.data) {
  } 
  // Assignement operators
  self_t & operator=(const self_t & M) {
    data = M.data; return *this;
  } 
  
    
  template<class X>
  self_t & operator=(const X & M);
  
  size_type nbrow() const {
    return rep().nbrow();
  } 
  
  size_type nbcol() const {
    return rep().nbcol();
  }
  
  value_type&       operator() (size_type i, size_type j) {return rep()(i,j);}
  
  const value_type& operator() (size_type i, size_type j) const {return rep()(i,j);} 
  
  typedef typename binary_operator_prototype< linalg::_submatrix_, self_t, Range2d >::F submatrix_t;
  submatrix_t  operator()(const Range & I, const Range & J) {  return submatrix(*this,Range2d(I,J)); };
  
  submatrix_t  operator()(const Range2d & rg ) {  return submatrix(*this,rg); };
  
  template<class X>
  self_t & operator+=(const X & x) { *this = *this + x; return *this; }
  
  template<class X>
  self_t & operator-=(const X & x) { *this = *this - x; return *this; };
  
  template<class X>
  self_t & operator*=(const X & x)  { *this = *this * x; return *this; };
  
  template<class X>
  self_t & operator/=(const X & x)  { *this = *this / x; return *this; };
  bool operator== (const self_t & v) { 
    using MATRIX::equal; return equal(*this,v); 
  };
  
  bool operator!= (const self_t & v) { return !(*this==v); }
  
  self_t & swaprow(size_type i, size_type j) {
    using MATRIX::swaprow; swaprow(rep(),i,j); return *this;
  };
  
  self_t & swapcol(size_type i, size_type j) { 
    using MATRIX::swapcol; swapcol(rep(),i,j); return *this;
  };
  
  self_t & addrow(size_type i,size_type j, const value_type & c = 1) {
    using MATRIX::addrow; addrow(rep(),i,j,c); return *this;
  };
  
  self_t & addcol(size_type i,size_type j, const value_type & c = 1) {
    using MATRIX::addcol; addcol(rep(),i,j,c); return *this;
  };
  
  self_t & multrow(size_type i, const value_type & c = 1) {
    using MATRIX::multrow; multrow(*this,i,c); return *this;
  };
  
  self_t & multcol(size_type i, const value_type & c = 1)
  {
    using MATRIX::multcol;
    multcol(*this,i,c);
    return *this;
  };
  
  self_t & transpose() {
    using MATRIX::transpose; transpose(rep()); return *this; 
  };

  self_t & resize(size_type i,size_type j) { 
    this->rep().resize(i,j); 
    return *this; 
  }
};


template<class C, class R>
MatrDse<C,R>  Transpose(const MatrDse<C,R> & M)
{
  MatrDse<C,R> TM(M); TM.transpose();
  return (TM);  
}
//======================================================================
// INPUT OUTPUT 
//======================================================================
template<class C, class R>
std::ostream & operator<<(std::ostream & os, const  MatrDse<C,R> & p)
{
  using namespace MATRIX;
  return print(os,p.rep());
}
//----------------------------------------------------------------------
template<class C, class R>  inline
std::istream & operator>>(std::istream & is, MatrDse<C,R> & M)
{
  using namespace MATRIX;
  return read(is,M);
}
//----------------------------------------------------------------------
template<class C> MatrDse<C> diag(unsigned n, const C & c)
{
  MatrDse<C> r(n,n);
  for(unsigned i=0;i<n;i++)
    for(unsigned j=0;j<n;j++)
      if(i==j) r(i,i)=c;
      else     r(i,j)=(C)0;
  return r;
}

__END_NAMESPACE_SYNAPS

#include "matrdse/let.h"
#include "matrdse/operations.h"
#include "matrdse/arithm.h"


__BEGIN_NAMESPACE_SYNAPS
template<class C, class R>
template<class X> inline
MatrDse<C,R> & MatrDse<C,R>::operator=(const X & M)
{ 
  using let::assign; assign(*this,M); return *this;  
} 

namespace type
{
  template<class C, class Y>
  struct instanceof< MatrDse<C>, Y> { typedef MatrDse<Y> T; };
  //  template<class C, class R, class Y>
  //    struct instanceof< MatrDse<C,R>, Y >{ typedef MatrDse<Y, typename instanceof<R,Y>::T > T; };
};
__END_NAMESPACE_SYNAPS
#endif // synaps_linalg_matrdse_H