Class for ultimately-periodic series in the semiring E[[d]]. In a general way, the series are described by two standard (canonical) forms s=p+q.r*=p'+r'*.q' where p,p',q,q' are polynomials in E[[d]] and r/r' are etvo::gd terms (in MinMax[[g,d]]). More...

#include <seriesEd.h>

Inheritance diagram for etvo::seriesEd:

Public Member Functions
	seriesEd ()
	Default initialization : epsilon (p=eps q=eps r=g1.d0)

	seriesEd (bool TopNotE)

	seriesEd (const Ed &m)
	Initialization of a seriesEd from Ed term m (p=eps q=m r=g1.d0)

	seriesEd (const polyEd &q)
	Initialization of a seriesEd from polyEd term q (p=eps q=q r=g1.d0)

	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
	check if the current series in Right form

bool	isLeftForm () const
	check if the current series in Left form

bool	isPolynomial () const
	check if it is a polynomial

bool	isProper () const
	check if it is in proper form

bool	isE () const
	check if it is a neutral seriesEd

void	canon ()
	leads to the canonical left or right form (the simplest proper form)

void	toRight ()
	to Right form

void	toLeft ()
	to Left form

polyEd	getP () const
	getter returning p

polyEd	getQ () const
	getter returning q

gd	getR () const
	getter returning r

std::vector< series >	toImpulseResponse () const
	returns the response to I,g1.I,g2.I ...

void	getLcmGain (unsigned int &mu, unsigned int &beta) const
	returns the Least Common multiple of gains in the terms of the current series

void	getMaxGain (unsigned int &mu, unsigned int &beta) const
	returns the Maximum of gains in the terms of the current series

std::pair< unsigned int, unsigned int >	getMaxGain () const
	returns the gain as a pair (mu,beta)

std::string	toString () const

std::string	toStringAsMuVar () const

bool	operator== (const seriesEd &s) const
	check equality

bool	operator!= (const seriesEd &) const
	check difference

bool	operator<= (const seriesEd &) const
	check order on series

bool	operator>= (const seriesEd &) const
	check order on series

seriesEd	oplus (const seriesEd &s) const

seriesEd	oplus (const polyEd &p) const

seriesEd	otimes (const seriesEd &s) const
	product of series in E[[d]] : s1.otimes(s2)

seriesEd	otimes (const Ed &m) const
	product of a series by a monomial in E[[d]] : s1.otimes(m)

seriesEd	otimes (const polyEd &p) const
	product of a series by a polynomial in E[[d]] : s1.otimes(p)

seriesEd	operator+ (const seriesEd &s) const

seriesEd	operator* (const seriesEd &s) const
	product of series in E[[d]] : s1*s2

seriesEd	operator* (const Ed &m) const
	product of a series by a monomial in E[[d]] : s1*m

seriesEd	operator* (const polyEd &p) const
	product of a series by a polynomial in E[[d]] : s1*p

seriesEd	star () const

seriesEd	starAlternate () const

seriesEd	starCD () const

seriesEd	starPolyBased () const

seriesEd	lfrac (const seriesEd &s) const
	left-product residuation : s1.lfrac(s2) = s2

seriesEd	rfrac (const seriesEd &s) const
	right-product residuation : s1.rfrac(s2) = s1/s2

seriesEd	otimesCD (const seriesEd &s) const
	operations via Core Decomposition : otimes

seriesEd	oplusCD (const seriesEd &s) const
	operations via Core Decomposition : oplus

seriesEd	infCD (const seriesEd &s) const
	operations via Core Decomposition : inf

seriesEd	inf (const seriesEd &s) const
	inf of series

seriesEd	lfracCD (const seriesEd &s) const
	operations via Core Decomposition : lfrac

seriesEd	rfracCD (const seriesEd &s) const
	operations via Core Decomposition : rfrac

polyEd	getPolyUpTo (int deltaT) const
	method to develop the first terms of p+q.[r]* or p+[r]*.q up to a given deltaT time value

series	toSeries () const
	projection seriesEd->series (zero slice)

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

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

Public Member Functions inherited from etvo::ISterm
	ISterm (bool isEpsilon=false)
	default constructor : an epsilon term

	ISterm (int epsNTop)
	constructor to specify the type of ISterm

bool	isEpsilon () const

bool	isTop () const

bool	isExtreme () const

void	setEpsilon ()

void	setTop ()

bool	operator== (const ISterm &) const

Static Public Member Functions
static seriesEd	Epsilon ()
	The epsilon description of seriesEd.

static seriesEd	Top ()
	The Top description of seriesEd.

static seriesEd	E ()
	The description of g0.d0 as seriesEd.

static seriesEd	oplus (const polyEd &p, const seriesEd &s)

static seriesEd	otimes (const Ed &m, const seriesEd &s)
	[STATIC] product of a monomial and a series in E[[d]] : seriesEd::otimes(m,s)

static seriesEd	otimes (const polyEd &m, const seriesEd &s)
	[STATIC] product of a polynomial and a series in E[[d]] : seriesEd::otimes(p,s)

static polyEd	getPolyUpTo (int deltaT, const polyEd &p, const polyEd &q, const gd &r, bool droite=true)
	static function to develop the first terms of p+q.[r]* or p+[r]*.q up to a given deltaT time value

static seriesEd	toCausal (const seriesEd &s)
	returns the projection of s into the set of causal series in E[[d]] (not reliable yet)

static seriesEd	toSeriesEd (const series &s)
	injection series(mmgd)->seriesEd

static seriesEd	coreToSeriesEd (const matrix< series > &C)
	conversion CORE decomposition -> seriesEd

static etvo::matrix< series >	getMatN (unsigned size)

Additional Inherited Members
Protected Attributes inherited from etvo::ISterm
char	_epsNTop
	_epsNTop = -1 epsilon 0 not extrem (normal) +1 Top

Detailed Description

Class for ultimately-periodic series in the semiring E[[d]]. In a general way, the series are described by two standard (canonical) forms s=p+q.r*=p'+r'*.q' where p,p',q,q' are polynomials in E[[d]] and r/r' are etvo::gd terms (in MinMax[[g,d]]).

s=p+q.r* is called the right-form (because the periodic pattern is expressed with a right multiplication by r*)

s=p'+r'*.q' is called the left-form (because the periodic pattern is expressed with a left multiplication by r'*)

This class provides the main operations on ultimately-periodic series in E[[d]] such as :sum,product, Kleene star (when it is possible to compute the Kleene star), left/right product residuation. Some operations are possible thanks to a Core Decomposition introduced by J.Trunk.

The library contains also some usefull functions to swap left/right form, to obtain a projection into MinMax[[g,d]] (zero-slice projection). By using the boost library, it is also possible to express series in a string format for which a parser is given. Epsilon and Top element exist

Author: BC LH JT LARIS

Version: 2.0

Constructor & Destructor Documentation

◆ seriesEd() [1/3]

etvo::seriesEd::seriesEd ( bool TopNotE )

Initialization as Top (true) OR E(false) Top (p=T q=T r=g1.d0) E (p=eps q=g0.d0 r=g1.d0)

◆ seriesEd() [2/3]

etvo::seriesEd::seriesEd	(	const polyEd &	p,
		const polyEd &	q,
		long	n,
		long	t,
		bool	right = `true`
	)

Initialization of a seriesEd from periodic p,q,r (right/left) form if right=true -> s=p+q.[gn.dt]* otherwise -> s=p+[gn.dt]*.q

◆ seriesEd() [3/3]

etvo::seriesEd::seriesEd	(	const polyEd &	p,
		const polyEd &	q,
		const gd &	r,
		bool	right = `1`
	)

Initialization of a seriesEd from periodic p,q,r (right/left) form if right=true -> s=p+q.[r]* otherwise -> s=p+[r]*.q

Member Function Documentation

◆ getCore()

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

returns the Core matrix of the current series. A ratio!=1 allows us to expand the matrix to a multiple of the basic gain.

◆ getCoreMax()

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

returns the maximal Core matrix of the current series. A ratio!=1 allows us to expand the matrix to a multiple of the basic gain.

◆ operator+()

seriesEd etvo::seriesEd::operator+ ( const seriesEd & s ) const

sum of series in E[[d]] : s1+s2 (calls oplus) Throws an exception if s1 and s2 unbalanced (different gains)

◆ oplus() [1/3]

seriesEd etvo::seriesEd::oplus ( const seriesEd & s ) const

sum of series in E[[d]] : s1.oplus(s2) Throws an exception if s1 and s2 unbalanced (different gains)

◆ oplus() [2/3]

seriesEd etvo::seriesEd::oplus ( const polyEd & p ) const

sum of series and polynomial in E[[d]] : s1.oplus(p1) Throws an exception if s1 and p1 unbalanced (different gains)

◆ oplus() [3/3]

seriesEd etvo::seriesEd::oplus	(	const polyEd &	p,
		const seriesEd &	s
	)

static

[STATIC] sum of a polynomial and a series in E[[d]] : seriesEd::oplus(p,s) Throws an exception if p and s unbalanced (different gains)

◆ star()

seriesEd etvo::seriesEd::star ( ) const

returns the Kleene star of a series in E[[d]]. Operates via a Core Decomposition of the series (see J.Trunk thesis) Throws an exception if the computation is not handled yet (degenerate case)

◆ starAlternate()

seriesEd etvo::seriesEd::starAlternate ( ) const

returns the Kleene star of a series in E[[d]]. A different algorithm is used (without Core Decomposition) to obtain the result. Throws an exception if the computation is not handled yet (degenerate case)

◆ starCD()

seriesEd etvo::seriesEd::starCD ( ) const

returns the Kleene star of a series in E[[d]]. Operates via a Core Decomposition of the series (see J.Trunk thesis)

◆ starPolyBased()

seriesEd etvo::seriesEd::starPolyBased ( ) const

returns the star of a series by using the star of a polynomial as function.

◆ toString()

std::string etvo::seriesEd::toString ( ) const

returns the string description of a series in E[[d]]. This format is compatible with the parser of seriesEd (needs boost installation)

◆ toStringAsMuVar()

std::string etvo::seriesEd::toStringAsMuVar ( ) const

returns the string description of a series in E[[d]] with mu<seq> operators. This format is compatible with the parser of seriesEd (needs boost installation)

The documentation for this class was generated from the following files:

C:/Users/usrlocal/ownCloud/DevSoft/etvoIII/etvo31/etvo/seriesEd/seriesEd.h
C:/Users/usrlocal/ownCloud/DevSoft/etvoIII/etvo31/etvo/seriesEd/seriesEd.cpp

Public Member Functions

Static Public Member Functions

Additional Inherited Members