seriesET.h

Go to the documentation of this file.

#ifndef SERIESET_H
#define SERIESET_H
#include "../wrapperMMGD/seriesWrapper.h"
#include "../wrapperMMGD/matrixWrapper.h"
#include "../seriesEd/seriesEd.h"
#include "../seriesTg/seriesTg.h"
#include<iostream>
#include "../common/ISterm.h"


namespace etvo
{
  class seriesET:public ISterm
  {
  private:
    bool _QEdForm;  // true if Q in E[[d]] //false if Q in T[[g]]
    matrix<dDd> _Led;     
    matrix<seriesEd> _Qed;  // if _QEdForm -> Led.Qed.Red
    matrix<dDd> _Red;   
    matrix<gNg> _Ltg;     
    matrix<seriesTg> _Qtg;  // if !_QEdForm -> Ltg.Qtg.Rtg
    matrix<gNg> _Rtg;       
    // internal usefull functions       
    seriesET(const matrix<dDd> & Led, const matrix<seriesEd> Qed, const matrix<dDd> & Red);
    seriesET(const matrix<gNg> & Ltg, const matrix<seriesTg> Qtg, const matrix<gNg> & Rtg);

    void toQtg_polynomial_case();
    void toQed_polynomial_case();
    void toQtg_series_case();
    void toQed_series_case();

    void extendQed(unsigned mul);
    void extendQtg(unsigned mul);

    static seriesTg truncTg(const seriesTg &, int n, int gamma);
    static seriesEd truncEd(const seriesEd &, int n, int delta);
            
  public:
      
    static seriesTg scale(const seriesTg & s, unsigned mul);
    static seriesEd scale(const seriesEd & s, unsigned mul);

    static seriesET Epsilon();
    static seriesET Top();
    static seriesET E();        
    seriesET();
    seriesET(bool TopNotE);
    seriesET(const seriesEd & s);
    seriesET(const seriesTg & s);
       
    matrix<dDd> getLed() const;
    matrix<dDd> getRed() const;
    matrix<seriesEd> getQed() const;

    matrix<gNg> getLtg() const;
    matrix<gNg> getRtg() const;
    matrix<seriesTg> getQtg() const;
    
    bool isCoreEd() const { return _QEdForm; }
    bool isCoreTg() const { return !_QEdForm; }
    
    void getLcmGainEd(unsigned int & mu, unsigned int& beta) const;
    void getLcmGainTg(unsigned int & v, unsigned int& w) const;
    void getLcmQSlope(int & g, int & d) const;

    void toCoreEd();
    void toCoreTg();
    // extends the Core representation 
    void extendBy(unsigned mul);
    seriesET oplus(const seriesET & s) const;
    seriesET otimes(const seriesET & s) const;
    seriesET star() const;
    seriesET inf(const seriesET & s) const;
    seriesET lfrac(const seriesET & s) const;
    seriesET rfrac(const seriesET & s) const;   

    seriesET operator+(const seriesET & s) const;
    seriesET operator*(const seriesET  & s) const;
        
    void changeForm();

    bool isPolynomial() const;
        
    bool isE() const;    

    void canon();
    void toRight();
    void toLeft();
    
    void toLVectorEd(matrix<seriesEd> & LV, matrix<dDd> & R) const;
    void toRVectorEd(matrix<seriesEd> & RV, matrix<dDd> & L) const;

    void toLVectorTg(matrix<seriesTg> & LV, matrix<gNg> & R) const;
    void toRVectorTg(matrix<seriesTg> & RV, matrix<gNg> & L)const ;


    static etvo::matrix<seriesEd>  getMatNed(unsigned size);
    static etvo::matrix<seriesTg>  getMatNtg(unsigned size);

    static seriesET toCausal(const seriesET & s);

    std::string toString(unsigned f=0) const;   
    

    friend seriesET etg(int n, bool QedForm );
    friend seriesET etd(int t, bool QedForm );  
    friend seriesET etm(unsigned m, bool QedForm ); 
    friend seriesET etb(unsigned b, bool QedForm ); 
    friend seriesET etm(const std::vector<unsigned> & seq);
    friend seriesET etb(const std::vector<unsigned> & seq);
    friend seriesET etd(const std::vector<int> & seqDelays);
    friend seriesET etv(unsigned v, bool QedForm );
    friend seriesET etw(unsigned w, bool QedForm);

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


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

  seriesET etg(int n,bool QedForm=true);
  seriesET etd(int t,bool QedForm = true);
  seriesET etm(unsigned m,bool QedForm = true);
  seriesET etm(const std::vector<unsigned> & seq);
  seriesET etb(const std::vector<unsigned> & seq);
  seriesET etd(const std::vector<int> & seqDelays);

  seriesET etb(unsigned b, bool QedForm = true);
  seriesET etv(unsigned v, bool QedForm = true);
  seriesET etw(unsigned w, bool QedForm = true);

 
  /*
  seriesET etm(const std::vector<unsigned> & seq);
  seriesET etb(const std::vector<unsigned> & seq);
  
  // necessary for matrix<T> computations.
  seriesET star(const seriesET & s);
  seriesET oplus(const seriesET &, const seriesET &);
  seriesET inf(const seriesET &, const seriesET &);
  seriesET otimes(const seriesET &, const seriesET &);
  seriesET lfrac(const seriesET &, const seriesET &);
  seriesET rfrac(const seriesET &, const seriesET &);

  */
} // end namespace etvo

#endif // SERIESET_H