Exemplo n.º 1
0
        /// <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);
        }
Exemplo n.º 2
0
        /// <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;
        }
Exemplo n.º 3
0
        /// <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);
        }
Exemplo n.º 4
0
        /// <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);
        }
Exemplo n.º 5
0
        /// <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);
        }