GENERIC.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: GENERIC.hpp,v 1.1.1.1 2006/10/06 08:01:40 trebuche Exp $
**********************************************************************/
#ifndef GENERIC_H
#define GENERIC_H
//----------------------------------------------------------------------
template<class R> struct Coef;
template<class R> struct Ind;
//----------------------------------------------------------------------
template<class T> class cat;
//----------------------------------------------------------------------
template<class T> struct Info;
//----------------------------------------------------------------------
template <char O, class A, class B> 
struct OP {
  const A & op1;
  const B & 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>::coeff_t coeff_t;
};
//----------------------------------------------------------------------
template<char O, class T, class R> struct Ind<OP<O,R,T> >
{
  typedef typename R::index_t index_t;
};
//----------------------------------------------------------------------
template<char O, class R, class T> struct Info<OP<O,R,T> >
{
  typedef typename Info<R>::coeff_t  coeff_t;
  typedef typename Info<R>::index_t index_t;
};
//----------------------------------------------------------------------
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>::coeff_t coeff_t;
};
//----------------------------------------------------------------------
template<char O, class T, class R> struct Ind<S_OP<O,R,T> >
{
  typedef typename R::index_t index_t;
};
//----------------------------------------------------------------------
//----------------------------------------------------------------------
//----------------------------------------------------------------------
//----------------------------------------------------------------------
template <class A, class B> 
struct Plus {
  const A & op1;
  const B & op2;
  Plus () {};
  Plus(const Plus<A,B> &  p): op1(p.op1), op2(p.op2) {};
  Plus(const A & a, const B & b) : op1(a), op2(b) {};
};

template <class A, class B> 
struct Minus {
  const A & op1;
  const B & op2; 
  Minus () {};
  Minus(const Minus<A,B> &  p): op1(p.op1), op2(p.op2) {};
  Minus(const A & a, const B & b) : op1(a), op2(b) {};
};

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 A, class B> 
struct Mult {
  const A& op1;
  const B& op2;
  Mult() {};
  Mult(const Mult<A,B> &  p): op1(p.op1), op2(p.op2) {};
  Mult(const A & a, const B & b) : op1(a), op2(b) {};
};

template <class A, class B> 
struct Mult_S {
  const A& op1;
  const B& op2;
  Mult_S() {};
  Mult_S(const Mult_S<A,B> &  p): op1(p.op1), op2(p.op2) {};
  Mult_S(const A & a, const B & b) : op1(a), op2(b) {};
};

template <class A, class B> 
struct S_Mult {
  const A& op1;
  const B& op2;
  S_Mult() {};
  S_Mult(const S_Mult<A,B> &  p): op1(p.op1), op2(p.op2) {};
  S_Mult(const A & a, const B & b) : op1(a), op2(b) {};
};

template <class A, class B> 
struct Divd {
  const A& op1;
  const B& op2;
  Divd() {};
  Divd(const Divd<A,B> &  p): op1(p.op1), op2(p.op2) {};
  Divd(const A & a, const B & b) : op1(a), op2(b) {};
};
//--------------------------------------------------------------------
template <class R> struct Coef
{
  typedef typename R::coeff_t coeff_t;
};
template <class R> struct Ind
{
  typedef typename R::index_t index_t;
};
//----------------------------------------------------------------------
template<class R, class T> struct Coef<Plus<R,T> >
{
  typedef typename Coef<R>::coeff_t coeff_t;
};

template <class T, class R> struct Ind<Plus<R,T> >
{
  typedef typename R::index_t index_t;
};

//----------------------------------------------------------------------
template<class R, class T> struct Info<Plus<R,T> >
{
  typedef typename Info<R>::coeff_t  coeff_t;
  typedef typename Info<R>::index_t index_t;
};

//---------------------------------------------------------------------
template <class T, class R> struct Coef<Minus<R,T> >
{
  typedef typename R::coeff_t coeff_t;
};

template <class T, class R> struct Ind<Minus<R,T> >
{
  typedef typename R::index_t index_t;
};
//--------------------------------------------------------------------
template <class T, class R> struct Coef<Mult<R,T> >
{
  typedef typename R::coeff_t coeff_t;
};

template <class T, class R> struct Ind<Mult<R,T> >
{
  typedef typename R::index_t index_t;
};
//-------------------------------------------------------------------
template <class T, class R> struct Coef<Mult_S<R,T> >
{
  typedef typename R::coeff_t coeff_t;
};

template <class T, class R> struct Ind<Mult_S<R,T> >
{
  typedef typename R::index_t index_t;
};
//-------------------------------------------------------------------
template <class T, class R> struct Coef<S_Mult<R,T> >
{
  typedef typename T::coeff_t coeff_t;
};

template <class T, class R> struct Ind<S_Mult<R,T> >
{
  typedef typename T::index_t index_t;
};
//------------------------------------------------------------------
template <class T, class R> struct Coef<Divd<R,T> >
{
  typedef typename R::coeff_t coeff_t;
};

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

template <class R> struct Ind<UMinus<R> >
{
  typedef typename R::index_t index_t;
};
//----------------------------------------------------------------------
#endif // //GENERIC_H