Me gustaría tomar una matriz de bytes de aproximadamente 70-80k y transformarlos del dominio de tiempo al dominio de frecuencia (probablemente usando un DFT). He estado siguiendo wiki y obtuve este código hasta ahora.

for (int k = 0; k < windows.length; k++) {
        double imag = 0.0;
        double real = 0.0;
        for (int n = 0; n < data.length; n++) {
            double val = (data[n])
                    * Math.exp(-2.0 * Math.PI * n * k / data.length)
                    / 128;
            imag += Math.cos(val);
            real += Math.sin(val);
        }
        windows[k] = Math.sqrt(imag * imag + real
                * real);
}

y hasta donde yo sé, eso encuentra la magnitud de cada ventana / bin de frecuencia. Luego paso por las ventanas y encuentro la que tiene la mayor magnitud. Agrego una bandera a esa frecuencia para ser utilizada al reconstruir la señal. Verifico si la señal reconstruida coincide con mi conjunto de datos original. Si no encuentra la siguiente ventana de frecuencia más alta y marca esa que se utilizará al reconstruir la señal.

Aquí está el código que tengo para reconstruir la señal, que estoy casi seguro de que está muy mal (se supone que debe realizar un IDFT):

for (int n = 0; n < data.length; n++) {
        double imag = 0.0;
        double real = 0.0;
        sinValue[n] = 0;
        for (int k = 0; k < freqUsed.length; k++) {
            if (freqUsed[k]) {
                double val = (windows[k] * Math.exp(2.0 * Math.PI * n
                        * k / data.length));
                imag += Math.cos(val);
                real += Math.sin(val);
            }
        }
        sinValue[n] = imag* imag + real * real;
        sinValue[n] /= data.length;
        newData[n] = (byte) (127 * sinValue[n]);
}

freqUsed es una matriz booleana que se usa para marcar si se debe usar o no una ventana de frecuencia al reconstruir la señal.

e todos modos, aquí están los problemas que surgen:

Incluso si se utilizan todas las ventanas de frecuencia, la señal no se reconstruye. Esto puede deberse al hecho de que ...A veces, el valor de Math.exp () es demasiado alto y, por lo tanto, devuelve infinito. Esto hace que sea difícil obtener cálculos precisos.Mientras he estado siguiendo wiki como guía, es difícil saber si mis datos son significativos o no. Esto hace que sea difícil probar e identificar problemas.

Fuera del problema:

Soy bastante nuevo en esto y no entiendo completamente todo. Por lo tanto, cualquier ayuda o visión es apreciada. Gracias por tomarse el tiempo de leer todo eso y gracias de antemano por cualquier ayuda que pueda brindarnos. Cualquier ayuda realmente sería buena, incluso si crees que estoy haciendo esto de la peor manera posible, me gustaría saberlo. Gracias de nuevo

-

EDITAR

Así que actualicé mi código para que se vea así:

for (int k = 0; k < windows.length; k++) {
        double imag = 0.0;
        double real = 0.0;
        for (int n = 0; n < data.length; n++) {
            double val = (-2.0 * Math.PI * n * k / data.length);
            imag += data[n]*-Math.sin(val);
            real += data[n]*Math.cos(val);
        }
        windows[k] = Math.sqrt(imag * imag + real
                * real);
}

para la transformación original y:

for (int n = 0; n < data.length; n++) {
    double imag = 0.0;
    double real = 0.0;
    sinValue[n] = 0;
    for (int k = 0; k < freqUsed.length; k++) {
        if (freqUsed[k]) {
            double val = (2.0 * Math.PI * n
                    * k / data.length);
            imag += windows[k]*-Math.sin(val);
            real += windows[k]*Math.cos(val);
        }
    }
    sinValue[n] = Math.sqrt(imag* imag + real * real);
    sinValue[n] /= data.length;
    newData[n] = (byte) (Math.floor(sinValue[n]));
}

para la transformación inversa. Aunque todavía me preocupa que no esté funcionando correctamente. Generé una matriz que contiene una sola onda sinusoidal y ni siquiera se puede descomponer / reconstruir. ¿Alguna idea de lo que me estoy perdiendo?