seriesTg.h

#ifndef SERIESTG_H
#define SERIESTG_H
#include "polyTg.h"
#include "../wrapperMMGD/seriesWrapper.h"
#include "../wrapperMMGD/matrixWrapper.h"
#include<iostream>
#include "../common/ISterm.h"


namespace etvo
{
  class seriesTg:public ISterm
  {
  private:
    bool _droite;  // true if right-form
    polyTg _p;     // _p polynomial
    polyTg _q;     // _q polynomial
    long _gamma;  // exponent of gn in p+q.[gn.dtr]*  or in p+[gn.dt]*.q
    long _deltaL;  // exponent of dt in p+[gn.dtl]*.q 
    long _deltaR;  // exponent of dt in p+q.[gn.dtr]*
    
    // internal usefull functions to simplify series in right-form
    void reductionPeriodicR();  
    void toProperFormR();
    void toProperPeriodicR();
    void toProperTransientR();
    void reductionTransientR();

    // internal usefull functions to simplify series in left-form
    void reductionPeriodicL();
    void toProperFormL();
    void toProperPeriodicL();
    void toProperTransientL();
    void reductionTransientL();
    void rightLeft();
    void degenerateCase();

    // internal usefull functions to compute the domination point for sums
    static long getDominationEventLH(const seriesTg & slow, const seriesTg & fast);
   // static seriesTg star(const etvo::series & s, unsigned nablaM, int gK);

   // internal usefull function to compute a part of the coreToSeriesTg function
    static seriesTg coreEntryToSeriesTg(int i, int j, int mb, const series & s);

  public:
    static seriesTg Epsilon();
    static seriesTg Top();
    static seriesTg E();
        
    seriesTg();

    seriesTg(bool TopNotE);

    seriesTg(const Tg & m);

    seriesTg(const polyTg & q);
    
  seriesTg(const polyTg & p,const polyTg & q, long n, long t, bool right = true);
  seriesTg(const polyTg & p, const polyTg & q, const gd & r,bool right = 1);
       
    bool isRightForm() const;
    bool isLeftForm() const;
    bool isPolynomial() const;
    bool isProper() const;
    bool isE() const;    
    void canon();

    void toRight();

    void toLeft();
    polyTg getP() const;
    polyTg getQ() const;
    gd getR() const;
       
    std::string toString() const;
    std::string toStringAsDeltaVar() const;

    bool operator==(const seriesTg & s) const;
    bool operator!=(const seriesTg &)const;
    bool operator<=(const seriesTg &) const;
    bool operator>=(const seriesTg &) const;
        
    static polyTg getPolyUpTo(int gammaN, const polyTg & p, const polyTg & q, const gd & r, bool droite = true);
        
    void getLcmGain(unsigned int & vee, unsigned int& wedge) const;
    void getMaxGain(unsigned int& vee, unsigned int& wedge) const;
    std::pair<unsigned int, unsigned int> getMaxGain() const;
       
    seriesTg operator+(const seriesTg & s) const;
    seriesTg oplus(const seriesTg & s) const;
    seriesTg oplus(const polyTg & p) const;

    seriesTg otimes(const seriesTg & s) const;

    static seriesTg otimes(const Tg & m, const seriesTg & s);
    static seriesTg otimes(const polyTg & m, const seriesTg & s);

    seriesTg operator*(const seriesTg  & s) const;
    seriesTg operator*(const Tg  & m) const;
    seriesTg operator*(const polyTg  & p) const;

    seriesTg otimes(const Tg & m) const;
    seriesTg otimes(const polyTg & p) const;

    static seriesTg oplus(const polyTg & p, const seriesTg & s);
    
    static seriesTg toSeriesTg(const series & s);

    etvo::matrix<series>  getCore(unsigned ratio = 1) const;
    etvo::matrix<series>  getCoreMax(unsigned ratio = 1) const;

    static etvo::matrix<series>  getMatN(unsigned size);
    seriesTg starCD() const;
    seriesTg star() const;

    static seriesTg coreToSeriesTg(const matrix<series> & C);
    
    seriesTg otimesCD(const seriesTg & s) const;
    seriesTg oplusCD(const seriesTg & s) const;

    seriesTg infCD(const seriesTg & s) const;
    seriesTg inf(const seriesTg & s) const;
    seriesTg lfracCD(const seriesTg & s) const;
    seriesTg rfracCD(const seriesTg & s) const;
    seriesTg lfrac(const seriesTg & s) const;
    seriesTg rfrac(const seriesTg & s) const;

    polyTg getPolyUpTo(int gammaN) const;

    static seriesTg toCausal(const seriesTg & s);

    std::vector<series> toImpulseResponse() const;

    series toSeries() const;

    /*      
    bool operator<=(const seriesEd &) const;
    bool operator>=(const seriesEd &) const;
    */
  };

  std::ostream & operator<<(std::ostream & f, const seriesTg & s);


  // necessary for matrix<T> computations.
  seriesTg star(const seriesTg & s);
  seriesTg oplus(const seriesTg &, const seriesTg &);
  seriesTg inf(const seriesTg &, const seriesTg &);
  seriesTg otimes(const seriesTg &, const seriesTg &);
  seriesTg lfrac(const seriesTg &, const seriesTg &);
  seriesTg rfrac(const seriesTg &, const seriesTg &);

  seriesTg tg(int n);
  seriesTg td(int t);
  seriesTg tD(unsigned n);
  seriesTg td(const std::vector<int> & seqDelays);
  seriesTg tv(unsigned v);
  seriesTg tw(unsigned w);
} // end namespace etvo

#endif // SERIESED_H