synaps/base/maple.h

/*********************************************************************
*      This file is part of the source code of SYNAPS library.       *
*   Author(s): B. Mourrain, GALAAD, INRIA                            *
**********************************************************************
History: $Id: maple.H,v 1.1 2005/07/11 09:32:55 mourrain Exp $
**********************************************************************/
#ifndef synaps_inout_maple_H_
#define synaps_inout_maple_H_
//--------------------------------------------------------------------
#include <iostream>
#include <complex>
#include <synaps/init.h>
//--------------------------------------------------------------------
__BEGIN_NAMESPACE_SYNAPS
//--------------------------------------------------------------------
namespace maple
{
  
  class ostream {
  public:
    ostream(std::ostream& os): chl(os) { };
    std::ostream & chl;
  };

  template<class OSTREAM, class X>
  OSTREAM& print(OSTREAM & os, const X & x) {os.chl<<x; return(os);}

  template<class OSTREAM, class C>
  OSTREAM & print(OSTREAM& os, const std::complex<C> & c) {
    print(os, c.real()); 
    if(c.imag() !=0) {
      os<<"+I* ";
      print(os,c.imag());
    }
    return(os);
  }

}//namespace maple
//----------------------------------------------------------------------
namespace maple {
  namespace VECTOR 
  {
     template<class OSTREAM, class R>
     OSTREAM& print(OSTREAM& os, const R &V) 
     {
       os << "linalg[vector]([";
       maple::print(os,V[0]);
       for(unsigned int i = 1; i < V.size(); i++) {
        os<<","; maple::print(os,V[i]); 
       }
       os <<"])";
       return os;
     }
  } 
} //namespace maple;
//----------------------------------------------------------------------
template<class C,class R> struct VectDse;
//----------------------------------------------------------------------
namespace maple 
{
  template<class OSTREAM, class C,class R>
  OSTREAM& print (OSTREAM& os, const VectDse<C,R> &V) 
  { 
    return maple::VECTOR::print(os, V);
  }
}
//----------------------------------------------------------------------
namespace maple 
{
  namespace MATRIX 
  {  
    template <class OSTREAM, class R>
    inline OSTREAM & print(OSTREAM & os,const R & M) 
    {
      using namespace maple;
      typedef typename R::size_type  size_type;
      if(M.nbrow()) {
        os << "linalg[matrix](" << M.nbrow()<< "," << M.nbcol() << ", [";
        for(size_type i = 0; i < M.nbrow()-1; i++) {
          os << "[" ;
          for(size_type j = 0; j < M.nbcol()-1; j++)
            os << M(i, j) << ",";
          os << M(i, M.nbcol()-1) << "], ";
        }
        os << "[" ;
        for(size_type j = 0; j < M.nbcol()-1; j++) os<<M(M.nbrow()-1, j)<<',';
        os << M(M.nbrow()-1, M.nbcol()-1) << "] ])";
      }
      return os;
    }
  }
} //namespace maple

//----------------------------------------------------------------------
template<class C, class R> struct MatrDse;
//----------------------------------------------------------------------
template<class C,class R>
maple::ostream& operator<< (maple::ostream& os, const MatrDse<C,R> &M) {
  return maple::MATRIX::print(os,M);
}
//----------------------------------------------------------------------
template<class R> struct MatrStr;
//----------------------------------------------------------------------
template<class R>
maple::ostream& operator<< (maple::ostream& os, const MatrStr<R> &M) {
  return maple::MATRIX::print(os,M);
}
//----------------------------------------------------------------------
template<class C,class R> struct MatrSps;
//----------------------------------------------------------------------
template<class C, class R>
maple::ostream& operator<< (maple::ostream& os, const MatrSps<C,R> &M) {
  return maple::MATRIX::print(os,M);
}
//----------------------------------------------------------------------
maple::ostream& operator<< (maple::ostream& os, std::ostream& s(std::ostream &)) 
{
 maple::print(os,";"); maple::print(os,s); return os;
}
//----------------------------------------------------------------------
template<class T>
maple::ostream & operator<< (maple::ostream& os, T t)
{
  using namespace maple;
  print(os,t); return(os);
}
//----------------------------------------------------------------------
maple::ostream cmaple(std::cout);
//----------------------------------------------------------------------
__END_NAMESPACE_SYNAPS
//----------------------------------------------------------------------
#endif //synaps_inout_maple_H_