Math Engine : Capitulo 4. Clase LPData

El artículo original lo podeís encontrar aquí


Bienvenidos a un nuevo capitulo de como crear tu propio math engine. El capitulo de hoy es la presentación del tercer (y si no estoy equivocado, último) tipo de dato que se usará en el math engine: el LPData es decir, series de datos. Con series de datos se representarán tanto muestreo de señales (con lo que se podrán realizar FFT  y otras transformaciones, de audio sobretodo) como series de datos estadísticos o muestreo de funciones. (maximos, mínimos, medias, rectas de regresión, integración, derivación,etc....)

Por ahora solo os pongo la estructura, que funciones se irán implementando lo dejo para vosotros para que me lo vayais diciendo a medida que las vayais necesitando.

LPData.h:
/**************************************************************************************************/
//        Código creado por F.Bordas (LordPakus) como ejemplo de creación de un math engine
//        para el blog LordPakus (http://lordpakus.blogspot.com/).
//        Prohibida la distribución fuera de este blog sin el permiso expreso del autor
/**************************************************************************************************/


/**************************************************************************************************/
// LPData.h
/**************************************************************************************************/

#ifndef __LPData__
#define __LPData__

class LPData
{
public:
    LPData();
    ~LPData();

    //Funciones anexas.
    void Set(int t, float* vector);                //Funcion para inicializar un vector de n elementos
    void Delete();                                //Función para limpiar la variable vector
    void print();                                //Función para imprimir el vector por la consola
    void random(int t,float min, float max);    //Función para rellenar de random un vector de t posiciones

    float Max();
    float Min();
    float Average();

    //OPERACIONES DE AMULACIÓN DE RESULTADO (+=,-=,etc...), devuelven void como norma general
    //Operaciones vectoriales
    void operator +=(LPData vector);           
    void operator -=(LPData vector);   
   
    //Operaciones con escalares ( sumar , restar , etc ... todo un vector por un escalar)
    void operator +=(float scal);
    void operator -=(float scal);
    void operator *=(float scal);
    void operator /=(float scal);


    //OPERACIONES QUE DEVUELVEN ALGO (NO ACUMULADORES: +,-,*, etc...)

public:
    int n;         //número de elementos del vector
    float *v;    //puntero a memoria dinámica
};

#endif

LPData.cpp:
/**************************************************************************************************/
//        Código creado por F.Bordas (LordPakus) como ejemplo de creación de un math engine
//        para el blog LordPakus (http://lordpakus.blogspot.com/).
//        Prohibida la distribución fuera de este blog sin el permiso expreso del autor
/**************************************************************************************************/

#include "LPData.h"
#include <math.h>
#include <iostream>                //Usada para imprimir por consola

using namespace std;

//Constructor
LPData::LPData()
{
    n = 0;
    v = NULL;
}

//Destructor
LPData::~LPData()
{
    //if (n)
    //{
    //    if( v != NULL )
    //        free(v);
    //}
}

//Funcion para inicializar una serie de datos de n elementos
void LPData::Set(int t, float* vector)
{
    n = t; //Inicializamos el número de elementos del vector

    //Creamos un vector de memoria dinámica.
    v = (float*) malloc( sizeof(float) * n );

    //Copiamos el vector externo en el vector interno
    memcpy(v,vector,sizeof(float) * n );
}

//Función para limpiar la variable vector
void LPData::Delete()
{
    n=0;
    free(v);
}

//Imprimimos el valor del vector
void LPData::print()
{
    for(int i = 0 ; i < n ; ++i)
    {
        cout << (float) v[i] << " ";
    }
}

void LPData::random(int t, float min, float max)
{
    n = t; //Inicializamos el número de elementos del vector

    //Creamos un vector de memoria dinámica.
    v = (float*) malloc( sizeof(float) * n );

    for(int i = 0 ; i < n ; ++i)
        v[i] = (float)(rand()%(int)(max*1000 - min*1000))/1000 + min;

}

float LPData::Max()
{
    float max;

    max = v[0];
    for(int i = 1 ; i < n ; ++i)
        if( v[i] > max )
            max = v[i];

    return max;
}

float LPData::Min()
{
    float min;

    min = v[0];
    for(int i = 1 ; i < n ; ++i)
        if( v[i] < min )
            min = v[i];

    return min;
}

float LPData::Average()
{
    float ave = 0;

    for(int i = 0 ; i < n ; ++i)
        ave += v[i];
   
    ave /= n;

    return ave;
}

//Sobrecarga operador +=
void LPData::operator +=(LPData vector)
{
    //Si las dimensiones son diferentes , tenemos un problema grave.
    if (n != vector.n)
    {
        cout << "ERROR DIMENSIONAL ENTRE SERIES DE DATOS\n";
        return;
    }

    for(int i = 0 ; i < n ; ++i)
        v[i] += vector.v[i];
   
}

//Sobrecarga operador -=
void LPData::operator -=(LPData vector)
{
    //Si las dimensiones son diferentes , tenemos un problema grave.
    if (n != vector.n)
    {
        cout << "ERROR DIMENSIONAL ENTRE SERIES DE DATOS\n";
        return;
    }

    for(int i = 0 ; i < n ; ++i)
        v[i] -= vector.v[i];
}

//Sobrecarga operador +=
void LPData::operator +=(float scal)
{
    for(int i = 0 ; i < n ; ++i)
        v[i] += scal;
}

//Sobrecarga operador -=
void LPData::operator -=(float scal)
{
    for(int i = 0 ; i < n ; ++i)
        v[i] -= scal;
}

//Sobrecarga operador *=
void LPData::operator *=(float scal)
{
    for(int i = 0 ; i < n ; ++i)
        v[i] *= scal;
   
}

//Sobrecarga operador /=
void LPData::operator /=(float scal)
{
    for(int i = 0 ; i < n ; ++i)
        v[i] /= scal;
   
}




Salvo fallo de planificación a partir de ahora solo es ir "rellenando" la estructura que tenemos con nuevas funcionalidades e implementaciones más eficientes.

Espero que os haya gustado,

Nos vemos