/// <summary>
/// Calcul dune FFT sur un tableau de 1024 points Selon l'algorithme de Cooley–Tukey
/// </summary>
/// <param name="Y"> Y[] : array of 1024 (decimal) values on which FFT has to be performed </param>
/// <returns> Tc[] array of 1024 (complex) values of FFT </returns>
public static Complex[] FFT1024(decimal[] Y)
{
//calcul de la FFT surle tableau entrant Y[]
//resultant sortant dans le tableau Tc[]
int N = Y.Length;
if (N != 1024)
{
Console.WriteLine("nombre de points doit etre = 1024");
Console.WriteLine("FFT sera calculé sur 1024 points seulement avec FFT1024() ");
System.Environment.Exit(1);
}
Complex[] Tc = new Complex[1024]; // résultat de la FFT
Complex[] Ec = new Complex[512]; // Even (pair)
Complex[] Oc = new Complex[512]; // Od (impair)
decimal[] E = new decimal[512];
decimal[] O = new decimal[512];
double Re, Im;
for (int k = 0; k < 512; k++)
{
E[k] = Y[2 * k];
O[k] = Y[(2 * k) + 1];
}
Ec = DFT.DFTv2(E); // Ec ( Even - pair) DFT of Even indexed pat of signal
Oc = DFT.DFTv2(O); // Odd ( Odd - impair) DFT of Odd indexed pat of signal
for (int k = 0; k < 512; k++)
{
Complex temp = new Complex(0, 0);
Re = Math.Cos((double)-2 * Math.PI * ((double)k / (double)1024));
Im = Math.Sin((double)-2 * Math.PI * ((double)k / (double)1024));
temp = new Complex(Re, Im);
Oc[k] = Oc[k] * temp;
}
for (int k = 0; k < 512; k++)
{
Tc[k] = Ec[k] + Oc[k]; // Tc[k] = Ec[k] + exp(-2.i.pi.k/N).Oc[k]
Tc[k + (N / 2)] = Ec[k] - Oc[k]; // Tc[k+N/2] = Ec[k] - exp(-2.i.pi.k/N).Oc[k]
}
return(Tc);
}
/// <summary>
///Desnsité spectrale de puissance du signal ( module au carré du signal)
///argument en entrée :
/// Cmp : tableau des valeurs complexes : x + i.y d'une transformée de Fourier
/// argument en sortie :
/// Ts : tableau des modules elevés au carré (x*x + y*y)) de la transformée
/// type : decimal
/// <summary>
/// <param name="Cmp"> Cmp[] tableau des valeurs complexes : x + i.y d'une transformée de Fourier </param>
/// <param name="Ts"> Ts[] : tableau des modules elevés au carré (x*x + y*y)) de la transformée </param>
public static void Ds2(Complex[] Cmp, decimal[] Ts)
{
decimal[] Ds = new decimal[Cmp.Length];
Ds = DFT.DspMagnDec(Cmp);
for (int i = 0; i < Cmp.Length; i++)
{
Ts[i] = Ds[i] * Ds[i];
}
//On divise par la longueur du signal
for (int i = 0; i < Cmp.Length; i++)
{
Ts[i] = Ts[i] / Cmp.Length;
}
return;
}
/// <summary>
/// Calcul dune FFT sur un tableau de N points Selon l'algorithme de Cooley–Tukey
/// </summary>
/// <param name="Y"> y[] : array of (decimal) values on which FFT has to be performed </param>
/// <returns> Tc[] array of (complex) values of FFT </returns>
public static Complex[] FFTN(decimal[] Y)
{
//calcul de la FFT surle tableau entrant y[]
//resultant sortant dans le tableau Tc[]
int N = Y.Length;
Complex[] Tc = new Complex[N]; // résultat de la FFT
Complex[] Ec = new Complex[N / 2]; // Even (pair)
Complex[] Oc = new Complex[N / 2]; // Od (impair)
decimal[] E = new decimal[N / 2];
decimal[] O = new decimal[N / 2];
double Re, Im;
for (int k = 0; k < N / 2; k++)
{
E[k] = Y[2 * k];
O[k] = Y[(2 * k) + 1];
}
Ec = DFT.DFTv2(E); // Ec ( Even - pair) DFT of Even indexed pat of signal
Oc = DFT.DFTv2(O); // Odd ( Odd - impair) DFT of Odd indexed pat of signal
//Ec = FFT.FFTN(E); // Ec ( Even - pair) DFT of Even indexed pat of signal
//Oc = FFT.FFTN(O); // Odd ( Odd - impair) DFT of Odd indexed pat of signal
for (int k = 0; k < N / 2; k++)
{
Complex temp = new Complex(0, 0);
Re = Math.Cos((double)-2 * Math.PI * ((double)k / (double)N));
Im = Math.Sin((double)-2 * Math.PI * ((double)k / (double)N));
temp = new Complex(Re, Im);
Oc[k] = Oc[k] * temp;
}
for (int k = 0; k < N / 2; k++)
{
Tc[k] = Ec[k] + Oc[k]; // Tc[k] = Ec[k] + exp(-2.i.pi.k/N).Oc[k]
Tc[k + (N / 2)] = Ec[k] - Oc[k]; // Tc[k+N/2] = Ec[k] - exp(-2.i.pi.k/N).Oc[k]
}
return(Tc);
}
/// <summary>
///Desnsité spectrale de puissance du signal ( module au carré du signal)
///argument en entrée :
/// Cmp : tableau des valeurs complexes : x + i.y d'une transformée de Fourier
/// argument en sortie :
/// Ts : tableau des modules elevés au carré (x*x + y*y)) de la transformée
/// type : float
/// </summary>
/// <param name="Cmp"> Cmp[] tableau des valeurs complexes : x + i.y d'une transformée de Fourier </param>
/// <returns> Ts[] : tableau des modules elevés au carré (x*x + y*y)) de la transformée </returns>
public static float[] Dspflot(Complex[] Cmp)
{
float[] Ds = new float[Cmp.Length];
float[] Ts = new float[Cmp.Length];
Ds = DFT.DspMagnFlot(Cmp);
for (int i = 0; i < Cmp.Length; i++)
{
Ts[i] = Ds[i] * Ds[i];
}
//On divise par la longueur du signal
for (int i = 0; i < Cmp.Length; i++)
{
Ts[i] = Ts[i] / Cmp.Length;
}
return(Ts);
}
/// <summary>
///classe pour la Densite Spectrale de Puissance (DSP)
///Class for power spectral density
///----------------------------------------------
/// </summary>
/// <summary>
///Desnsité spectrale de puissance du signal ( module au carré du signal)
///argument en entrée : Cmp : tableau des valeurs complexes : x + i.y d'une transformée de Fourier
///argument en sortie : Ts : tableau des modules elevés au carré (x*x + y*y)) de la transformée
/// </summary>
/// <param name="Cmp"> tableau des valeurs complexes : x + i.y d'une transformée de Fourier </param>
/// <returns> Ts : tableau des modules elevés au carré (x*x + y*y)) de la transformée </returns>
public static double[] Dspdoub(Complex[] Cmp)
{
double[] Ds = new double[Cmp.Length];
double[] Ts = new double[Cmp.Length];
// Ds " contient les magnitudes : sqrt(x*x + y*y))
Ds = DFT.DspMagnDo(Cmp);
for (int i = 0; i < Cmp.Length; i++)
{
Ts[i] = Ds[i] * Ds[i];
}
//On divise par la longueur du signal
for (int i = 0; i < Cmp.Length; i++)
{
Ts[i] = Ts[i] / Cmp.Length;
}
return(Ts);
}
