#include <forgfact.h>

Inheritance diagram for DynamicForgettingFactor2:

Collaboration diagram for DynamicForgettingFactor2:

Public Member Functions
	DynamicForgettingFactor2 (integer n1, integer n2, integer i, doublereal r, doublereal f, doublereal kr, doublereal kl)

	~DynamicForgettingFactor2 (void)

void	Update (const doublereal *pErr=NULL)

doublereal	dGet (void) const

Public Member Functions inherited from ForgettingFactor
	ForgettingFactor (integer i)

virtual	~ForgettingFactor (void)

Protected Attributes
integer	N1

integer	N2

doublereal	dRho

doublereal	dFact

doublereal	dkRef

doublereal	dkLim

doublereal	dk

doublereal *	pdErr

doublereal **	ppdErr

integer	iRef1

integer	iRef2

doublereal *	pdErr1M

doublereal *	pdErr1S

doublereal *	pdErr2M

doublereal *	pdErr2S

Protected Attributes inherited from ForgettingFactor
integer	iNumErr

Detailed Description

Definition at line 115 of file forgfact.h.

Constructor & Destructor Documentation

DynamicForgettingFactor2::DynamicForgettingFactor2	(	integer	n1,
		integer	n2,
		integer	i,
		doublereal	r,
		doublereal	f,
		doublereal	kr,
		doublereal	kl
	)

Definition at line 156 of file forgfact.cc.

References ASSERT, dFact, dkLim, dkRef, dRho, ForgettingFactor::iNumErr, N1, N2, pdErr, pdErr1M, pdErr1S, pdErr2M, pdErr2S, ppdErr, and SAFENEWARR.

 : ForgettingFactor(i), 
 N1(n1), N2(n2), dRho(r), dFact(f), dkRef(kr), dkLim(kl),
 dk(kr), pdErr(NULL), ppdErr(NULL), iRef1(n1-1), iRef2(n1-n2-1),
 pdErr1M(NULL), pdErr1S(NULL), pdErr2M(NULL), pdErr2S(NULL) {
    ASSERT(N1 > 0);
    ASSERT(N2 > 0);
    ASSERT(N2 < N1);
    ASSERT(dRho > 0. && dRho < 1.);
    ASSERT(dFact > 0. && dFact < 1.);
    ASSERT(dkRef > 0. && dkRef < 1.);
    ASSERT(dkLim > dkRef && dkLim <= 1.);
    
    integer sz = (N1+4)*iNumErr;
    
    SAFENEWARR(pdErr, doublereal, sz);
    SAFENEWARR(ppdErr, doublereal*, N1);
    
    pdErr1M = pdErr+N1*iNumErr;
    pdErr1S = pdErr1M+iNumErr;
    pdErr2M = pdErr1S+iNumErr;
    pdErr2S = pdErr2M+iNumErr;
    for (integer i = sz; i-- > 0; ) {
       pdErr[i] = 0.;
    }
    for (integer i = N1; i-- > 0; ) {
       ppdErr[i] = pdErr+i*iNumErr;
    }    
 }

DynamicForgettingFactor2::~DynamicForgettingFactor2 ( void )

Definition at line 192 of file forgfact.cc.

References pdErr, ppdErr, and SAFEDELETEARR.

                                                         {
    /* pdErr must be non-null */
    SAFEDELETEARR(pdErr);
    SAFEDELETEARR(ppdErr);
 }

Member Function Documentation

doublereal DynamicForgettingFactor2::dGet ( void ) const

inlinevirtual

Implements ForgettingFactor.

Definition at line 148 of file forgfact.h.

References dk.

 {
    return dk;
 }

void DynamicForgettingFactor2::Update ( const doublereal * pErr = NULL )

virtual

Implements ForgettingFactor.

Definition at line 198 of file forgfact.cc.

References dFact, dk, dkLim, dkRef, dRho, grad::exp(), grad::fabs(), ForgettingFactor::iNumErr, iRef1, iRef2, N1, N2, pdErr1M, pdErr1S, pdErr2M, pdErr2S, grad::pow(), and ppdErr.

                                                           {
    /* setta i riferimenti */
    if (++iRef1 == N1) {
       iRef1 = 0;
    }
    if (++iRef2 == N1) {
       iRef2 = 0;
    }
    
    /* somma agli errori la norma dell'errore corrente, poi sottrae
     * l'errore al limite posteriore delle rispettive finestre */    
    doublereal dS1 = 0.;  
    doublereal dS2 = 0.;
    for (integer i = iNumErr; i-- > 0; ) {
       doublereal d = pE[i]*pE[i];
       pdErr1S[i] += d;
       pdErr1S[i] -= ppdErr[iRef1][i]*ppdErr[iRef1][i];
       pdErr1M[i] += pE[i];
       pdErr1M[i] -= ppdErr[iRef1][i];
       dS1 += pdErr1S[i]/N1-pow(pdErr1M[i]/N1,2);
       pdErr2S[i] += d;
       pdErr2S[i] -= ppdErr[iRef2][i]*ppdErr[iRef2][i];
       pdErr2M[i] += pE[i];
       pdErr2M[i] -= ppdErr[iRef2][i];
       dS2 += pdErr2S[i]/N2-pow(pdErr2M[i]/N2,2);
       
       /* aggiorna il limite superiore della finestra "lunga" */
       ppdErr[iRef1][i] = pE[i];       
    }
 
    
    
    /* per debug
    cout << setw(16) << dS1 << setw(16) << dS2 << setw(16) 
      << (dS1 != 0. ? 1.-dS2/dS1 : 0.) << endl;
     */
    
    
    
    /* differenza tra la varianza dell'errore "corto"
     * rispetto a quello "lungo"
     * se viene superato il limite, il forgetting factor scatta al valore 
     * minimo (massima dimenticanza) */
    doublereal d = 0.;
    if (fabs(dS1) > std::numeric_limits<doublereal>::epsilon() && (d = fabs(1.-dS2/dS1)) > dFact) {
 #if 0
       dk = (dkLim-dkRef)*exp(-d)+dkRef;
 #else 
       dk = dkRef;
 #endif
    } else {
       /* il forgetting factor viene fatto variare con una sua dinamica */
       dk = dRho*dk+(1-dRho)*dkLim;
    }
 }