seriesEd.h

Go to the documentation of this file.

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


namespace etvo
{
  class seriesEd:public ISterm
  {
  private:
    bool _droite;  // true if right-form
    polyEd _p;     // _p polynomial
    polyEd _q;     // _q polynomial
    long _gammaR;  // exponent of gn in p+q.[gn.dt]*
    long _gammaL;  // exponent of gn in p+[gn.dt]*.q
    long _delta;  // exponent of dt in p+[gn.dt]*.q or in p+q.[gn.dt]*

    // 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 getDominationTimeLH(const seriesEd & slow, const seriesEd & fast);
    static long getDominationTime(const seriesEd & s1, const seriesEd & s2);   

    static seriesEd star(const etvo::series & s, unsigned nablaM, int gK);

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

    seriesEd(bool TopNotE);

    seriesEd(const Ed & m);

    seriesEd(const polyEd & q);
    
    seriesEd(const polyEd & p,const polyEd & q, long n, long t, bool right = true);
    seriesEd(const polyEd & p, const polyEd & 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();
    polyEd getP() const;
    polyEd getQ() const;
    gd getR() const;
       
    std::vector<series> toImpulseResponse() const;

    void getLcmGain(unsigned int & mu, unsigned int& beta) const;
    void getMaxGain(unsigned int& mu, unsigned int& beta) const;
    std::pair<unsigned int, unsigned int> getMaxGain() const;

    std::string toString() const;
    std::string toStringAsMuVar() const;

    bool operator==(const seriesEd & s) const;
    bool operator!=(const seriesEd &)const;
    bool operator<=(const seriesEd &) const;
    bool operator>=(const seriesEd &) const;

    seriesEd oplus(const seriesEd & s) const;
    seriesEd oplus(const polyEd & p) const;

    seriesEd otimes(const seriesEd & s) const;
    seriesEd otimes(const Ed & m) const;
    seriesEd otimes(const polyEd & p) const;

    static seriesEd oplus(const polyEd & p, const seriesEd & s);
    static seriesEd otimes(const Ed & m, const seriesEd & s);
    static seriesEd otimes(const polyEd & m, const seriesEd & s);

    seriesEd operator+(const seriesEd & s) const;
    seriesEd operator*(const seriesEd  & s) const;
    seriesEd operator*(const Ed  & m) const;
    seriesEd operator*(const polyEd  & p) const;

    seriesEd star() const;

    seriesEd starAlternate() const;

    seriesEd starCD() const;
    seriesEd starPolyBased() const;
    
    seriesEd lfrac(const seriesEd & s) const;
    seriesEd rfrac(const seriesEd & s) const;

    seriesEd otimesCD(const seriesEd & s) const;
    seriesEd oplusCD(const seriesEd & s) const;  
    seriesEd infCD(const seriesEd & s) const;
    seriesEd inf(const seriesEd & s) const;
    seriesEd lfracCD(const seriesEd & s) const;
    seriesEd rfracCD(const seriesEd & s) const;
    
    // to do : develop inf as oplus is developped(domination ...)
    // seriesEd inf(const seriesEd & s) const;
    // to do : develop lfrac and rfrac by alternative algorithm
    // seriesEd lfrac(const seriesEd & s) const;   
    // seriesEd rfrac(const seriesEd & s) const;
  
    static polyEd getPolyUpTo(int deltaT, const polyEd & p, const polyEd & q, const gd & r, bool droite = true);
    polyEd getPolyUpTo(int deltaT) const;

    static seriesEd toCausal(const seriesEd & s);

    static seriesEd toSeriesEd(const series & s);
    series toSeries() const;
    static seriesEd coreToSeriesEd(const matrix<series> & C);

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

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

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

  seriesEd eg(int n);
  seriesEd ed(int t);
  seriesEd em(unsigned m);
  seriesEd eb(unsigned b);
  seriesEd en(unsigned n);
  seriesEd em(const std::vector<unsigned> & seq);
  seriesEd eb(const std::vector<unsigned> & seq);

} // end namespace etvo

#endif // SERIESED_H