Changeset 2540 in Sophya for trunk/SophyaLib/NTools

Timestamp:

May 25, 2004, 9:16:58 AM (21 years ago)

Author:

cmv

Message:

on enleve TransfEnergyFFT,SizeFFT obsolete cmv 25/5/04

Location:

trunk/SophyaLib/NTools

Files:

• fftservintf.cc (modified) (3 diffs)
• fftservintf.h (modified) (1 diff)

trunk/SophyaLib/NTools/fftservintf.cc

@@ -1 +1 @@
 #include "fftservintf.h"
 
+//// VOIR GRAND BLABLA EXPLICATIF A LA FIN DU FICHIER
 
 /*!
@@ -156 +157 @@
 }
 
-
-// ----------------- Transformation de normalisation pour les energies -------------------
-
-/* --Methode-- */
-//! Compute the transform to be applied to "fftx=FFT(x)" so that "x" and "FFT(x)" have the same energy
-/*!
-\return The factor to be applied to the FFT energy such that we get the same energy as for the x.
-\verbatim
-  fftx is computed by: FFTForward(x,fftx)
-  Energy of x    : Ex    = sum{|x(i)|^2}      i=0,x.Size()-1
-  Energy of fftx : Efftx = sum{|fftx(i)^2|}   i=0,fftx.Size()-1
-        ( usually x.Size() != fftx.Size() )
-  -------------------------------------------------------------------
-  |  TransfEnergyFFT return A and B such that : Ex = A * Efftx + B  |
-  |                  and Norm such that : Ex = Norm * Efftx         |
-  -------------------------------------------------------------------
-  To normalize the fftx vector apply : "fftx *= sqrt(Norm)"
-\endverbatim
-*/
-r_8 FFTServerInterface::TransfEnergyFFT
-     (TVector< complex<r_8> > const& x, TVector< complex<r_8> > const& fftx, r_8& A, r_8& B)
-{
-  B=0.;
-  if(getNormalize()) A = x.Size(); else A = 1./x.Size();
-  r_8 norm = A;
-  return norm;
-}
-
-//! Compute the transform to be applied to "fftx=FFT(x)" so that "x" and "FFT(x)" have the same energy
-r_8 FFTServerInterface::TransfEnergyFFT
-     (TVector< complex<r_4> > const & x, TVector< complex<r_4> > const & fftx, r_8& A, r_8& B)
-{
-  B=0.;
-  if(getNormalize()) A = x.Size(); else A = 1./x.Size();
-  r_8 norm = A;
-  return norm;
-}
-
-//! Compute the transform to be applied to "fftx=FFT(x)" so that "x" and "FFT(x)" have the same energy
-r_8 FFTServerInterface::TransfEnergyFFT
-     (TVector< r_8 > const & x, TVector< complex<r_8> > const & fftx, r_8& A, r_8& B)
-{
-  A= 2.;
-  B=  - abs(fftx(0)*fftx(0));
-  if(x.Size()%2 == 0) B -= abs(fftx(fftx.Size()-1)*fftx(fftx.Size()-1));
-  if(getNormalize()) {A *= x.Size(); B *= x.Size();}
-     else            {A /= x.Size(); B /= x.Size();}
-  r_8 norm = 0.;
-  for(int_4 i=0;i<fftx.Size();i++) norm += abs(fftx(i)*fftx(i));
-  if(norm>0.) norm = (A*norm+B)/norm;
-  return norm;
-}
-
-//! Compute the transform to be applied to "fftx=FFT(x)" so that "x" and "FFT(x)" have the same energy
-r_8 FFTServerInterface::TransfEnergyFFT
-     (TVector< r_4 > const & x, TVector< complex<r_4> > const & fftx, r_8& A, r_8& B)
-{
-  A= 2.;
-  B=  - abs(fftx(0)*fftx(0));
-  if(x.Size()%2 == 0) B -= abs(fftx(fftx.Size()-1)*fftx(fftx.Size()-1));
-  if(getNormalize()) {A *= x.Size(); B *= x.Size();}
-     else            {A /= x.Size(); B /= x.Size();}
-  r_8 norm = 0.;
-  for(int_4 i=0;i<fftx.Size();i++) norm += abs(fftx(i)*fftx(i));
-  if(norm>0.) norm = (A*norm+B)/norm;
-  return norm;
-}
-
-
 /* --Methode-- */
 /*!
@@ -408 +340 @@
 template class FFTArrayChecker<r_8>;
 #endif
+
+
+
+
+
+/**********************************************************************
+
+Memo uniquement destine aux programmeurs:    (cmv 03/05/04)
+-- cf programme de tests explicatif: cmvtfft.cc
+
+=====================================================================
+=====================================================================
+============== Transformees de Fourier et setNormalize ==============
+=====================================================================
+=====================================================================
+
+- si setNormalize(true):  invTF{TF{S}} = S
+- si setNormalize(false): invTF{TF{S}} = N * S
+
+=====================================================================
+=====================================================================
+============== Transformees de Fourier de signaux REELS =============
+=====================================================================
+=====================================================================
+
+-------
+--- FFT d'un signal REEL S ayant un nombre pair d'elements N=2p
+-------
+  taille de la FFT: Nfft = N/2 + 1 = p + 1
+  abscisses de la fft: | 0 | 1/N | 2/N | ..... | p/N=1/2 |
+                         ^continu                 ^frequence de Nyquist
+
+  ... Ex:  N=6 -> Nfft = 6/3+1 = 4
+
+  le signal a N elements reels, la fft a Nfft elements complexes
+    cad 2*Nfft reels = 2*(p+1) reels = 2p + 2 reels = N + 2 reels
+    soit 2 reels en trop:
+    ce sont les phases du continu et de la frequence de Nyquist
+
+  relations:
+    - si setNormalize(true)  : fac = N
+         setNormalize(false) : fac = 1/N
+    sum(i=0,N-1){S(i)^2}
+                        = fac* [[ 2* sum(j=0,Nfft-1){|TF{S}(j)|^2} 
+                                 - |TF{S}(0)|^2 - |TF{S}(Nfft-1)|^2 ]]
+    (On ne compte pas deux fois le continu et la freq de Nyquist)
+     
+
+-------
+--- FFT d'un signal REEL ayant un nombre impair d'elements N=2p+1
+-------
+  taille de la FFT: Nfft = N/2 + 1 = p + 1
+  abscisses de la fft: | 0 | 1/N | 2/N | ..... | p/N |
+                         ^continu                 
+                       (la frequence de Nyquist n'y est pas)
+
+  ... Ex:  N=7 -> Nfft = 7/3+1 = 4
+
+  le signal a N elements reels, la fft a Nfft elements complexes
+    cad 2*Nfft reels = 2*(p+1) reels = 2p + 2 reels = N + 1 reels
+    soit 1 reel en trop: c'est la phase du continu
+
+  relations:
+    - si setNormalize(true)  : fac = N
+         setNormalize(false) : fac = 1/N
+    sum(i=0,N-1){S(i)^2}
+                        = fac* [[ 2* sum(j=0,Nfft-1){|TF{S}(j)|^2} 
+                                 - |TF{S}(0)|^2 ]]
+    (On ne compte pas deux fois le continu)
+
+
+------------
+--- FFT-BACK d'un signal F=TF{S} ayant un nombre d'elements Nfft
+------------
+  Sback = invTF{TF{S}}
+
+  Remarque: Nfft a la meme valeur pour N=2p et N=2p+1
+            donc Nfft conduit a 2 possibilites:
+                 { N = 2*(Nfft-1)  signal back avec nombre pair d'elements
+                 { N = 2*Nfft-1    signal back avec nombre impair d'elements
+
+  Pour savoir quel est la longueur N du signal TF^(-1){F} on regarde
+    si F(Nfft-1) est reel ou complexe
+       (la frequence de Nyquist d'un signal reel est reelle)
+
+    - Si F(Nfft-1) reel      cad  Im{F(Nfft-1)}=0:  N = 2*(Nfft-1)
+    - Si F(Nfft-1) complexe  cad  Im{F(Nfft-1)}#0:  N = 2*Nfft-1
+
+  Si setNormalize(true):  invTF{TF{S}} = S
+     setNormalize(false): invTF{TF{S}} = N * S
+
+=========================================================================
+=========================================================================
+============== Transformees de Fourier de signaux COMPLEXES =============
+=========================================================================
+=========================================================================
+
+-------
+--- FFT d'un signal COMPLEXE S ayant un nombre d'elements N
+-------
+  taille de la FFT: Nfft = N
+  abscisses de la fft: | 0 | 1/N | 2/N | ..... | (N-1)/N |
+                         ^continu
+
+  Frequence de Nyquist:
+    si N est pair: la frequence de Nyquist est l'absicce d'un des bins
+      abscisses de TF{S}: Nfft = N = 2p
+      | 0 | 1/N | 2/N | ... | (N/2)/N=p/N=0.5 | ... | (N-1)/N |
+                                     ^frequence de Nyquist
+    si N est impair: la frequence de Nyquist N'est PAS l'absicce d'un des bins
+      abscisses de TF{S}: Nfft = N = 2p+1
+      | 0 | 1/N | 2/N | ... | (N/2)/N=p/N | ((N+1)/2)/N=(p+1)/N  | ... | (N-1)/N |
+
+  ... Ex: N = 2p =6  ->  Nfft = 2p = 6
+      abscisses de TF{S}: | 0 | 1/6 | 2/6 | 3/6=0.5 | 4/6 | 5/6 |
+  ... Ex: N = 2p+1 = 7   ->  Nfft = 2p+1 = 7
+      abscisses de TF{S}: | 0 | 1/7 | 2/7 | 3/7 | 4/7 | 5/7 | 6/7 |
+
+  relations:
+    - si setNormalize(true)  : fac = N
+         setNormalize(false) : fac = 1/N
+    sum(i=0,N-1){S(i)^2} = fac* [[ sum(j=0,Nfft-1){|TF{S}(j)|^2} ]]
+
+------------
+--- FFT-BACK d'un signal F=TF{S} ayant un nombre d'elements Nfft
+------------
+  taille du signal: N = Nfft
+
+  Si setNormalize(true):  invTF{TF{S}} = S
+     setNormalize(false): invTF{TF{S}} = N * S
+
+**********************************************************************/

trunk/SophyaLib/NTools/fftservintf.h

@@ -46 +46 @@
   virtual void FFTBackward(TArray< complex<r_8> > const & in, TArray< complex<r_8> > & out);
 
-   //! Compute the factor to be applied to "fftx=FFT(x)" so that "x" and "FFT(x)" have the same energy
-  virtual r_8 TransfEnergyFFT(TVector<r_4> const & x, TVector< complex<r_4> > const& fftx,r_8& A,r_8& B);
-  virtual r_8 TransfEnergyFFT(TVector<r_8> const & x, TVector< complex<r_8> > const& fftx,r_8& A,r_8& B);
-  virtual r_8 TransfEnergyFFT(TVector< complex<r_4> > const & x, TVector< complex<r_4> > const& fftx,r_8& A,r_8& B);
-  virtual r_8 TransfEnergyFFT(TVector< complex<r_8> > const & x, TVector< complex<r_8> > const& fftx,r_8& A,r_8& B);
-
-  virtual inline r_8 TransfEnergyFFT(TVector<r_4> const & x, TVector< complex<r_4> > const& fftx)
-                       {r_8 A,B; return TransfEnergyFFT(x,fftx,A,B);}
-  virtual inline r_8 TransfEnergyFFT(TVector<r_8> const & x, TVector< complex<r_8> > const& fftx)
-                       {r_8 A,B; return TransfEnergyFFT(x,fftx,A,B);}
-  virtual inline r_8 TransfEnergyFFT(TVector< complex<r_4> > const & x, TVector< complex<r_4> > const& fftx)
-                       {r_8 A,B; return TransfEnergyFFT(x,fftx,A,B);}
-  virtual inline r_8 TransfEnergyFFT(TVector< complex<r_8> > const & x, TVector< complex<r_8> > const& fftx)
-                       {r_8 A,B; return TransfEnergyFFT(x,fftx,A,B);}
-
-   //! Compute the size of the FFT vector given the input vector
-  virtual uint_4 SizeFFT(TVector<r_4> const & x) {return (uint_4) (x.Size()/2 + 1);}
-  virtual uint_4 SizeFFT(TVector<r_8> const & x) {return (uint_4) (x.Size()/2 + 1);}
-  virtual uint_4 SizeFFT(TVector< complex<r_4> > const & x) {return (uint_4) x.Size();}
-  virtual uint_4 SizeFFT(TVector< complex<r_8> > const & x) {return (uint_4) x.Size();}
-
  protected: