deltas.h

Ir a la documentación de este archivo.

#include <stdio.h>
#include <vector>
#include "uti.h"
#include "xalloc.h"
#include "cbuffer.h"



class ParamDeltas
{
    
/*  El algoritmo hace algo como esto: Mantiene dos listas de buffers, uno para el cálculo
    de derivadas (con tamaño size[j] = 2*N[j]+1) y otro para recordar muestras pasadas, con
    tamaño size[j] = \sum_j^{Numdeltas)(N[j])+1. Este tamaño se corresponde con el retardo de cálculo
    de todas las derivadas superiores a ese nivel más uno. De esta forma, en la posición [0]
    de ese buffer siempre está el valor de la delta actual. Dicho de otra forma, si concatenamos
    todas las posiciones [0], logramos el vector completo i-Delay(). De hecho, esto es lo que
    hace Get().
    
    No hay buffer para la última delta. No le hace falta, pues no hay que calcular nada por encima
    de ella y no requiere memoria, ya que es la de mayor retardo.
*/

public:
    
    inline
    ParamDeltas ()
    : m_Ndim(0), m_bInit(false), m_pdDiff(NULL)
    {}


    inline
    ParamDeltas (INT Ndeltas, INT* windowSize, INT Ndim)
    { Initialize(Ndeltas, windowSize, Ndim); }
    
    inline
    ~ParamDeltas()
    { if (m_pdDiff) xfree(m_pdDiff); }
    
    void
    Initialize (INT Ndeltas, INT* windowSize, INT Ndim);
            
    void
    Push (const DOUBLE* e);
    
    INT
    Delay() const
    { return m_vMemBuffers[0].Size()-1; }
    
    inline
    INT
    Ndim() const
    { return m_Ndim; }
    
    inline
    INT
    Ndeltas() const
    { return m_vDeltaBuffers.size(); }
    
    void
    Get(DOUBLE* e) const;
    
    
protected:
    
    void
    Populate (const DOUBLE* e);

protected:
    std::vector<buffer2D> m_vDeltaBuffers;  
    std::vector<buffer2D> m_vMemBuffers;    
    INT m_Ndim;                             
    bool m_bInit;                           
    DOUBLE* m_pdDiff;                       

};





void
GetDiff ( const buffer2D& buffer, DOUBLE* diff );

DOUBLE
GetDiff ( const buffer1D& buffer );


inline
void
GetSample ( const buffer2D& buffer, DOUBLE* mid, INT n)
{ memcpy(mid, buffer[n], buffer.Dim()*sizeof(DOUBLE)); }




inline
DOUBLE
GetSample ( const buffer1D& buffer, INT n)
{ return buffer[n]; }

    

---