#include <id.h>

Inheritance diagram for IdentARMAXProcess:

Collaboration diagram for IdentARMAXProcess:

Public Member Functions
	IdentARMAXProcess (unsigned int iOut, unsigned int iIn, unsigned int iA, unsigned int iB, ForgettingFactor *pf)

virtual	~IdentARMAXProcess (void)

virtual void	Update (const doublereal pdYTmp, const doublereal pdUTmp)

virtual void	GetTheta (doublereal *pdTheta)

void	GetErr (doublereal *pdE)

virtual integer	iGetSize (void) const

Public Member Functions inherited from IdentProcess
	IdentProcess (unsigned int iOut, unsigned int iIn, unsigned int iA, unsigned int iB)

virtual	~IdentProcess (void)

void	CreateIdent (integer size, integer nout, ForgettingFactor *pf)

virtual doublereal	dGetForgettingFactor (void)

integer	iGetNumOutput (void) const

Protected Member Functions
flag	fCheckMA (doublereal *pdTheta)

Protected Attributes
integer	size

doublereal *	pdBase

doublereal *	pdPhi

doublereal *	pdY

doublereal *	pdErr

Protected Attributes inherited from IdentProcess
unsigned int	iNumOutput

unsigned int	iNumInput

unsigned int	iOrdA

unsigned int	iOrdB

Ident *	pIdent

Detailed Description

Definition at line 154 of file id.h.

Constructor & Destructor Documentation

IdentARMAXProcess::IdentARMAXProcess	(	unsigned int	iOut,
		unsigned int	iIn,
		unsigned int	iA,
		unsigned int	iB,
		ForgettingFactor *	pf
	)

Definition at line 272 of file id.cc.

References IdentProcess::CreateIdent(), pdBase, pdErr, pdPhi, pdY, SAFENEWARR, and size.

 : IdentProcess(iOut, iIn, iA, iB), 
 size(2*iOut*iA+iIn*(iB+1)), pdBase(NULL), pdPhi(NULL), pdY(NULL), pdErr(NULL) 
 {
    // size e' il lato lungo di Theta.
    
    CreateIdent(size, integer(iOut), pf);
    
    integer i = size        // Phi
      +iOut                 // Y
      +iOut;                // Err
      
    SAFENEWARR(pdBase, doublereal, i);
    
    pdPhi = pdBase;
    pdY = pdPhi+size;
    pdErr = pdY+iOut;
  
    
    for (integer j = i; j-- > 0; ) {
       pdBase[j] = 0.;
    }    
 }

Here is the call graph for this function:

IdentARMAXProcess::~IdentARMAXProcess ( void )

virtual

Definition at line 298 of file id.cc.

References pdBase, and SAFEDELETEARR.

                                           {    
    SAFEDELETEARR(pdBase);
 }  

Member Function Documentation

flag IdentARMAXProcess::fCheckMA ( doublereal * pdTheta )

protected

Definition at line 370 of file id.cc.

Referenced by GetTheta().

 {
    // fa la correzione di Theta in base agli autovalori ed autovettori
    return flag(0);
 }

void IdentARMAXProcess::GetErr ( doublereal * pdE )

virtual

Reimplemented from IdentProcess.

Definition at line 363 of file id.cc.

References IdentProcess::iNumOutput, and pdErr.

 {
    for (integer i = iNumOutput; i-- > 0; ) {
       pdE[i] = pdErr[i];
    }          
 }

void IdentARMAXProcess::GetTheta ( doublereal * pdTheta )

virtual

Implements IdentProcess.

Definition at line 346 of file id.cc.

References fCheckMA(), IdentProcess::iNumOutput, NO_OP, Ident::pdGetTheta(), IdentProcess::pIdent, and size.

 {
    // fa calcolare il nuovo theta
    doublereal* p = pIdent->pdGetTheta();
 
    // se e' il caso, corregge la parte di MA di Theta
    if (fCheckMA(p)) {
       // se la parte MA di theta e' stata corretta, e' stata aggiornata in loco
       NO_OP;
    }   
    
    // restituisce il nuovo theta
    for (integer i = iNumOutput*size; i-- > 0; ) {     
       pdTheta[i] = p[i];
    }   
 }

Here is the call graph for this function:

virtual integer IdentARMAXProcess::iGetSize ( void ) const

inlinevirtual

Implements IdentProcess.

Definition at line 177 of file id.h.

References size.

                                         {
       return size;
    };

void IdentARMAXProcess::Update	(	const doublereal *	pdYTmp,
		const doublereal *	pdUTmp
	)

virtual

Implements IdentProcess.

Definition at line 304 of file id.cc.

References IdentProcess::iNumInput, IdentProcess::iNumOutput, IdentProcess::iOrdA, IdentProcess::iOrdB, pdErr, Ident::pdGetErr(), pdPhi, pdY, IdentProcess::pIdent, and Ident::Update().

 {
    // qui iniziano gli errori
    doublereal* pdTmp = pdPhi+iNumOutput*iOrdA+iNumInput*(iOrdB+1);
    
    // sposta di un passo (iNumOutput) le uscite e gli errori
    for (integer i = iNumOutput*(iOrdA-1); i-- > 0; ) {
       pdPhi[i+iNumOutput] = pdPhi[i]; // Y vecchi
       pdTmp[i+iNumOutput] = pdTmp[i]; // Err vecchi
    }
    // aggiunge in testa le uscite e gli errori al passo precedente
    for (integer i = iNumOutput; i-- > 0; ) {       
       pdPhi[i] = pdY[i];    // Y all'ultima iterazione
       pdY[i] = pdYTmp[i];   // Y nuovo
       pdTmp[i] = pdErr[i];  // Err all'ultima iterazione 
    }
 
    // qui iniziano gli ingressi
    pdTmp = pdPhi+iNumOutput*iOrdA;
    // sposta di un passo (iNumInput) gli ingressi
    // if (iOrdB == 0) // ARMA is implicitly satisfied 
    for (integer i = iNumInput*iOrdB; i-- > 0; ) {      
       pdTmp[i+iNumInput] = pdTmp[i];
    }
    // aggiunge in testa gli ingressi al passo corrente
    for (integer i = iNumInput; i-- > 0; ) {     
       pdTmp[i] = pdUTmp[i];
    }
    
    // fa aggiornare la stima di Theta
    pIdent->Update(pdPhi, pdY);
  
    // err al passo corrente e' stato calcolato da Ident; lo ricopia
    doublereal* pd = pIdent->pdGetErr();
    for (integer i = iNumOutput; i-- > 0; ) {
       pdErr[i] = pd[i];
    }
 }