synaps/mpol/matrixof.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: 
$Id: matrix_of.h,v 1.1 2005/07/11 08:15:52 mourrain Exp $
**********************************************************************/
/*********************************************************************/
#ifndef SYNAPS_RESULTANT_MATRIXOF_H
#define SYNAPS_RESULTANT_MATRIXOF_H
//----------------------------------------------------------------------
#include <synaps/init.h>
#include <synaps/linalg/rep2d.h>
#include <synaps/linalg/MATRIX.m>
#include <synaps/mpol/Monom.h>
#include <synaps/mpol/MPol.h>
#include <list>
#include <map>
#include <set>


__BEGIN_NAMESPACE_SYNAPS

//----------------------------------------------------------------------
template<class C, class R> struct MatrSps;
//----------------------------------------------------------------------
namespace matrixof
{
  //----------------------------------------------------------------------
  template<class R> inline
  void reserve(R & A, typename R::size_type nl, typename R::size_type nc, 
               typename R::size_type nz) 
  {A= * new R(nl,nc);}
  
  template<class C, class R> inline
  void reserve(MatrSps<C,R> & A, 
               typename R::size_type nl, typename R::size_type nc, 
               typename R::size_type nz) 
  {A= * new R(nl,nc,nz);}
  //----------------------------------------------------------------------
  template<class R,class C> inline
  void assigncoeff(R & A, unsigned int m, unsigned int n, const C & c)
  {
    A(m,n)=c;
  }
  //----------------------------------------------------------------------
  template<class R,class C> 
  void assigncoeff(MatrSps<C,R> & A, unsigned int m, unsigned int n, const C & c)
  {
    (A.rep())(m,n,c);
  }
  //----------------------------------------------------------------------
} //matrixof

//======================================================================
template<class R, class L, class LM>
R matrix_of(const L & f, const LM & s, char t) 
{
  typedef typename L::value_type POL;
  typedef typename POL::monom_t  MON;
  typedef typename POL::order_t  O;

  MON mt;

  std::map<MON,int,O> index;
  int l=0;
  for(typename LM::const_iterator m = s.begin(); m!=s.end(); m++){
    //m->SetCoeff(1);
    index[*m]=l;
    l++;
  }
  unsigned nz=0;
  for(typename L::const_iterator fi = f.begin(); fi != f.end(); ++fi) 
    nz+=fi->size();
    
  R res; 
  if(t=='T') {
    matrixof::reserve(res.rep(),(unsigned) f.size(),(unsigned) s.size(),nz);
    l=0;
    for(typename L::const_iterator fi = f.begin(); fi != f.end(); ++fi){
      for(typename POL::const_iterator m = fi->begin(); m!=fi->end(); m++)
        matrixof::assigncoeff(res,l,index[*m],m->coeff());
      l++;
      }
  }else{
    matrixof::reserve(res.rep(),(unsigned) s.size(),(unsigned) f.size(),nz);
    l=0;
    for(typename L::const_iterator fi = f.begin(); fi != f.end(); ++fi){
      for(typename POL::const_iterator m = fi->begin(); m!=fi->end(); m++)
        matrixof::assigncoeff(res,index[*m],l,m->coeff());
      l++;
    }
  }
  return res;
}
//----------------------------------------------------------------------
template<class R, class L>
R matrix_of(const L & l, char t='N') 
{
  typedef typename L::value_type POL;
  typedef typename POL::monom_t  MON;
  POL s; MON tm;
  for(typename L::const_iterator fi = l.begin(); fi != l.end(); ++fi){
    for(typename POL::const_iterator m = fi->begin(); m!= fi->end(); m++)
      {
        tm =*m; tm.setcoeff(1);
        s += POL(tm);
      }
  }
  return matrix_of<R>(l,s,t);   
}
//----------------------------------------------------------------------
template<class R, class L, class LM>
R MatUpolyOf(const L & f, const LM & s, unsigned int v) 
{
  typedef typename R::value_type UPOL;
  typedef typename L::value_type POL;
  typedef typename POL::monom_t  MON;
  typedef typename POL::order_t  O;

  MON mt;

  std::map<MON,int,O> index;
  int l=0;
  for(typename LM::const_iterator m = s.begin(); m!=s.end(); m++){
    mt=*m;
    index[mt]=l;
    l++;
  }
  unsigned nz=0;
  for(typename L::const_iterator fi = f.begin(); fi != f.end(); ++fi) 
    nz+=fi->size();
    
  R res; 
  matrixof::reserve(res.rep(),(unsigned) s.size(),(unsigned) f.size(),nz);
  //Should be a zero matrix;
  l=0;
  for(typename L::const_iterator fi = f.begin(); fi != f.end(); ++fi){
    for(typename POL::const_iterator m = fi->begin(); m!=fi->end(); m++)
      {
        mt=*m; 
        if((int)v<=mt.nvars()) mt.setexp(v,0); 
        res(index[mt],l)+= UPOL(m->coeff(),(*m)[v]);
      }
      l++;
  }
  return res;
}
//----------------------------------------------------------------------
template<class R, class L>
R MatUpolyOf(const L & l,unsigned int v) 
{
  typedef typename L::value_type POL;
  typedef typename POL::monom_t  MON;
  POL s(0); MON tm;
  for(typename L::const_iterator fi = l.begin(); fi != l.end(); ++fi){
    for(typename POL::const_iterator m = fi->begin(); m!= fi->end(); m++)
      {
        tm =*m; 
        tm.setcoeff(1);
        if((int)v<=tm.nvars()) tm.setexp(v,0); 
        s += POL(tm);
      }
  }
  return MatUpolyOf<R>(l,s,v);   
}
//----------------------------------------------------------------------


__END_NAMESPACE_SYNAPS

#endif // SYNAPS_LINALG_MATRIXOF_H