MatrixOf.hpp

Go to the documentation of this file.

/*********************************************************************
*      This file is part of the source code of BORDERBASIX software. *
*      (C) B. Mourrain,  INRIA                                       *
**********************************************************************
History: 
$Id: MatrixOf.hpp,v 1.1.1.1 2006/10/06 08:01:40 trebuche Exp $
**********************************************************************/
#ifndef _MatrixOf_H_
#define _MatrixOf_H_
//----------------------------------------------------------------------
#include "linpkg/array2d.H"
#include "linpkg/MATRIX.H"
#include "linpkg/MatRef.H"
#include "borderbasix/mpoly/Monom.hpp"
#include "borderbasix/mpoly/MPoly.hpp"
#include <list>
#include <map>
#include <set>
//----------------------------------------------------------------------
template<class POL> 
typename POL::coeff_t
CoeffOf(const POL & p, const typename POL::monom_t & mono)
{ 
  typedef typename POL::coeff_t coeff_t;
  typename POL::const_iterator m;
  for(m = p.begin(); !IsComparable((*m),mono) && m!= p.end(); m++);
  if(m!=p.end()) 
    return m->GetCoeff();
  else
    return  coeff_t(0);
}
//----------------------------------------------------------------------
namespace matrixof 
{
  template<class R> void build(R & A, typename R::index_t nl, 
                   typename R::index_t nc, typename R::index_t nz);
};
//----------------------------------------------------------------------
template<class R> 
void matrixof::build(R & A, typename R::index_t nl, 
             typename R::index_t nc, typename R::index_t nz)
{
  A.rebuild(nl,nc);
}
//----------------------------------------------------------------------
template<class POL, class RM>
MatRef<RM> MatrixOf(const list<POL> & L, RM M, char t='N') 
{
  typedef typename POL::monom_t monom_t;
  POL s;
  monom_t mt;
  int c=0;
  for(list<POL>::const_iterator pi = L.begin(); pi != L.end(); ++pi){
    for(typename POL::const_iterator m = pi->begin(); m!= pi->end(); m++)
      {
    mt=(*m);
    mt.SetCoeff(1.);
        s += POL(mt);
      }
    c++;
  }

  map<monom_t,int> index;
  int l=0;
  for(typename POL::iterator m = s.begin(); m!=s.end(); m++){
    m->SetCoeff(1.);
    index[*m]=l;
    l++;
  }
  unsigned nz=0;
  for(list<POL>::const_iterator pi = L.begin(); pi != L.end(); ++pi) 
    nz+=pi->rep.size();
    
  if(t=='T') {
    RM* res= new RM; 
    matrixof::build(*res,c,l,nz);
    l=0;
    for(list<POL>::const_iterator pi = L.begin(); pi != L.end(); ++pi)
      {
      for(typename POL::const_iterator m = pi->begin(); m!=pi->end(); m++)
    {
      (*res)(l,index[*m])=m->GetCoeff();
    }
      l++;
      }
    return MatRef<RM>(res);   
  }else{
    RM* res= new RM; matrixof::build(*res,l,c,nz);
    l=0;
    for(list<POL>::const_iterator pi = L.begin(); pi != L.end(); ++pi){
      for(typename POL::const_iterator m = pi->begin(); m!=pi->end(); m++)
    {
      (*res)(index[*m],l)=m->GetCoeff();
    }
      l++;
    }
    return MatRef<RM>(res);   
  }
}

template <class POL, class RM>
MatRef<RM>
MatrixOf(const list<POL> & L, 
     const list<typename POL::monom_t> & lm, 
     RM M, char t='N')
{
  typedef typename POL::monom_t monom_t;  

  map<monom_t,int> index;

  int l=1;
  for(list<monom_t>::const_iterator m = lm.begin(); m!=lm.end(); m++){
    index[*m]=l;
    l++;
  }
  int c;
  if(t=='T') {
    RM* res= new RM(L.size(),l-1);
    l=0;
    for(list<POL>::const_iterator pi = L.begin(); pi != L.end(); ++pi)
      {
      for(typename POL::const_iterator m = pi->begin(); m!=pi->end(); m++)
    {
      if((c=index[*m])) (*res)(l,c-1)=m->GetCoeff();
    }
      l++;
      }
    return MatRef<RM>(res);   
  }else{
    RM* res= new RM(l-1,L.size());
    l=0;
    for(list<POL>::const_iterator pi = L.begin(); pi != L.end(); ++pi){
      for(typename POL::const_iterator m = pi->begin(); m!=pi->end(); m++)
    {
      if((c=index[*m])) (*res)(c-1,l)=m->GetCoeff();
    }
      l++;
    }
    return MatRef<RM>(res);   
  }
}

#ifdef _SpUMFMat_H_

template <class POL, class C>
MatRef<umfpack<C> >
MatrixOf(const list<POL> & L, 
     const list<typename POL::monom_t> & lm, 
     umfpack<C> r, char t='N')
{
  typedef umfpack<C> R;
  typedef typename POL::monom_t monom_t;  

  map<monom_t,int> index;

  int l=1;
  for(list<monom_t>::const_iterator m = lm.begin(); m!=lm.end(); m++){
    index[*m]=l; l++;
  }

  int nz=0;
  for(list<POL>::const_iterator pi = L.begin(); pi != L.end(); ++pi) 
    for(typename POL::const_iterator m = pi->begin(); m!=pi->end(); m++)
      if(index[*m]) nz++;

  int nr= lm.size();
  int nc= L.size();

  if(t=='T') {
    R* res= new R(nr,nc,nz);
    int k =0, j=0, i;
    for(list<POL>::const_iterator pi = L.begin(); pi != L.end(); ++pi)
      {
    for(typename POL::const_iterator m = pi->begin(); m!=pi->end(); m++)
      {
        if((i=index[*m])) {
          res->tab_[k] = m->GetCoeff();
          res->index_[k]=j;
          res->index_[k+nz]=i-1;
          k++;
        }
      }
    j++;
      }
    return MatRef<R>(res);   
  }
}
#endif // _SpUMFMat_H_ 
#endif // _MatrixOf_H_