synaps/mpol/Ideal.h

/*********************************************************************
*      This file is part of the source code of the SYNAPS library.
*      Author(s): B. Mourrain, GALAAD, INRIA                 
**********************************************************************/
#ifndef SYNAPS_MPOL_Ideal_h
#define SYNAPS_MPOL_Ideal_h

#include <stdlib.h>
#include <string>
#include <list>
#include <synaps/init.h>
#include "synaps/base/Seq.h"
#include "synaps/mpol/MPol.h"

//--------------------------------------------------------------------
__BEGIN_NAMESPACE_SYNAPS
//----------------------------------------------------------------------
namespace linalg { template<class C> struct rep1d; }
//----------------------------------------------------------------------
template <class C,
          class R=MPol<C> >
struct Ideal : public Seq<R> {

  // Types
  typedef C                                  coeff_t;
  typedef typename Seq<R>::iterator               iterator;
  typedef typename Seq<R>::const_iterator         const_iterator;
  typedef typename Seq<R>::reverse_iterator       reverse_iterator;
  typedef typename Seq<R>::const_reverse_iterator const_reverse_iterator;
  typedef R                                  poly_t;
  typedef Ideal<C,R>                         self_t;

  // Constructors
  Ideal():Seq<R>() {this->resize(0);}
  Ideal(const poly_t& p):Seq<RR>() {this->push_back(p);}
  Ideal(const self_t & I):Seq<R>(I){}
  Ideal(int n, poly_t* t):Seq<R>(n,t){}
  Ideal(const Seq<R>& s):Seq<R>(s){}
  
  // Destructor
  // no dynamic allocation at this level.

  //  static Variable var;

  // Assignment operators
  self_t & operator =(const self_t & x)  {this->operator=(x); return *this;}


};

template<class C, class R> const Seq<R>& As_Seq(const Ideal<C,R>& x)
{ return *((const Seq<R>*)&x); };

template<class C,class R>
Ideal<C,R> operator+(const Ideal<C,R>& a, const Ideal<C,R> & b)
{
  return (Ideal<C,R>)((Seq<R>)(a)+(Seq<R>)(b));
}

template<class C, class R>
Ideal<C,R> operator*(const Ideal<C,R>& I1, const Ideal<C,R>& I2)
{
  Ideal<C,R> res;
  for(unsigned i=0; i<I1.size();i++)
    for(unsigned j=0; j<I2.size();j++)
       res.push_back(I1[i]*I2[j]);      
  return res;
}
__END_NAMESPACE_SYNAPS
//======================================================================
#endif // SYNAPS_MPOL_MPOL_H