synaps/arithm/GENERIC.h

/*********************************************************************
*      This file is part of the source code of SYNAPS library.       *
*   Author(s): B. Mourrain, GALAAD, INRIA                            *
**********************************************************************
$Id: GENERIC.h,v 1.1 2005/07/11 10:39:47 mourrain Exp $
**********************************************************************/
#ifndef SYNAPS_ARITHM_GENERIC_H
#define SYNAPS_ARITHM_GENERIC_H
//--------------------------------------------------------------------
#include <iostream>
#include <synaps/init.h>
//--------------------------------------------------------------------
__BEGIN_NAMESPACE_SYNAPS
//----------------------------------------------------------------------
template<class R> struct Coef;
template<class R> struct Ind;
//----------------------------------------------------------------------
template<class T> class cat;
//----------------------------------------------------------------------
template<class T> struct Info;
//----------------------------------------------------------------------
template <typename T>
class OPTraits {
public:
  typedef T const & OP_node_ref;
};
//----------------------------------------------------------------------
template <char O, class A, class B> 
struct OP {
  typename OPTraits<A>::OP_node_ref op1;
  typename OPTraits<B>::OP_node_ref op2;
  OP () {};
  OP(const OP<O,A,B> &  p): op1(p.op1), op2(p.op2) {};
  OP(const A & a, const B & b) : op1(a), op2(b) {};
};
//----------------------------------------------------------------------
template<char O, class R, class T> struct Coef<OP<O,R,T> >
{
  typedef typename Coef<R>::value_type value_type;
};
//----------------------------------------------------------------------
template<char O, class T, class R> struct Ind<OP<O,R,T> >
{
  typedef typename R::size_type size_type;
};
//----------------------------------------------------------------------
template<char O, class R, class T> struct Info<OP<O,R,T> >
{
  typedef typename Info<R>::value_type  value_type;
  typedef typename Info<R>::size_type size_type;
};
//----------------------------------------------------------------------
template<>
class OPTraits<char> {
public:
  typedef const char OP_node_ref;
};
template<>
class OPTraits<unsigned char> {
public:
  typedef const unsigned char OP_node_ref;
};
template<>
class OPTraits<int> {
public:
  typedef const int OP_node_ref;
};
template<>
class OPTraits<unsigned int> {
public:
  typedef const unsigned int OP_node_ref;
};
template<>
class OPTraits<long> {
public:
  typedef const long OP_node_ref;
};
template<>
class OPTraits<unsigned long> {
public:
  typedef const unsigned long OP_node_ref;
};
template<>
class OPTraits<float> {
public:
  typedef const float OP_node_ref;
};
template<>
class OPTraits<double> {
public:
  typedef const double OP_node_ref;
};
//----------------------------------------------------------------------
template <char O, class A, class B> 
struct S_OP {
  const A & op1;
  const B & op2;
  S_OP () {};
  S_OP(const OP<O,A,B> &  p): op1(p.op1), op2(p.op2) {};
  S_OP(const A & a, const B & b) : op1(a), op2(b) {};
};
//----------------------------------------------------------------------
template<char O, class R, class T> struct Coef<S_OP<O,R,T> >
{
  typedef typename Coef<R>::value_type value_type;
};
//----------------------------------------------------------------------
template<char O, class T, class R> struct Ind<S_OP<O,R,T> >
{
  typedef typename R::size_type size_type;
};
//====================================================================
template <class A> 
struct UMinus {
  const A & op;
  UMinus () {};
  UMinus(const UMinus<A> &  p): op(p.op) {};
  UMinus(const A & a) : op(a){};
};
//--------------------------------------------------------------------
template <class R> struct Coef
{
  typedef typename R::value_type value_type;
};
template <class R> struct Ind
{
  typedef typename R::size_type size_type;
};
//----------------------------------------------------------------------
template<class R, class T> struct Coef<OP<'+',R,T> >
{
  typedef typename Coef<R>::value_type value_type;
};

template <class T, class R> struct Ind<OP<'+',R,T> >
{
  typedef typename R::size_type size_type;
};

//----------------------------------------------------------------------
template<class R, class T> struct Info<OP<'+',R,T> >
{
  typedef typename Info<R>::value_type  value_type;
  typedef typename Info<R>::size_type size_type;
};

//---------------------------------------------------------------------
template <class T, class R> struct Coef<OP<'-',R,T> >
{
  typedef typename R::value_type value_type;
};

template <class T, class R> struct Ind<OP<'-',R,T> >
{
  typedef typename R::size_type size_type;
};
//--------------------------------------------------------------------
template <class T, class R> struct Coef<OP<'*',R,T> >
{
  typedef typename R::value_type value_type;
};

template <class T, class R> struct Ind<OP<'*',R,T> >
{
  typedef typename R::size_type size_type;
};
//-------------------------------------------------------------------
template <class T, class R> struct Coef<OP<'.',R,T> >
{
  typedef typename R::value_type value_type;
};

template <class T, class R> struct Ind<OP<'.',R,T> >
{
  typedef typename R::size_type size_type;
};
//-------------------------------------------------------------------
// template <class T, class R> struct Coef<S_OP<'*',R,T> >
// {
//   typedef typename T::value_type value_type;
// };

// template <class T, class R> struct Ind<S_OP<'*',R,T> >
// {
//   typedef typename T::size_type size_type;
// };
//------------------------------------------------------------------
// template <class T, class R> struct Coef<Divd<R,T> >
// {
//   typedef typename R::value_type value_type;
// };

//------------------------------------------------------------------
template <class R> struct Coef<UMinus<R> >
{
  typedef typename R::value_type value_type;
};

template <class R> struct Ind<UMinus<R> >
{
  typedef typename R::size_type size_type;
};
//----------------------------------------------------------------------
//struct ostream;
template<char O,class R,class T> inline
std::ostream & operator << (std::ostream & os,const OP<O,R,T> & M)
{
  os <<"("<<M.op1<<")"<<O<<"("<<M.op2<<")"; return os;
}


__END_NAMESPACE_SYNAPS

#endif //SYNAPS_ARITHM_GENERIC_H