Scipy fft

Numpy et Scipy en Python ont de nombreuses routines FFT (de base au complexe). Le concept Scipy FFT sera examiné de manière approfondie dans ce post. Nous explorerons également comment l'appliquer dans la pratique. Nous expliquerons quelles sont les fonctions Scipy FFT et vous donneront quelques exemples de programmation pour vous aider à démarrer. Le scipy.fft (), scipy.fft rfft (), scipy.Les méthodes FFT Shift (), FFTFREQ () et FFTConVolve () seront toutes couvertes en détail ainsi que des exemples de cet article. Les exemples sont fournis pour clarifier le sujet pour vous afin que vous puissiez le mettre en pratique avec facilité.

Python Scipy FFT Explication

La méthode d'analyse de Fourier définit uniquement une fonction comme le total des composants périodiques et dérive le signal qui est couvert par le module Python Scipy appelé Scipy.FFT. La fonction et sa transformée de Fourier (Ft) sont toutes deux remplacées par des équivalents discrétisés pour produire la transformée de Fourier discrète.

En utilisant une séquence basée sur le temps, la transformée de Fourier, simplement appelée Fourier, est une fonction mathématique qui détermine la vitesse de rotation globale, sa force et le décalage du cycle pour le cycle potentiel de chaque modèle. Les formes d'onde, les principales opérations du temps, de l'espace ou de toute autre variable peuvent facilement être transformées à l'aide de la transformée de Fourier.

Nous étudierons la méthode de transformation de Fourier la plus populaire avec des exemples dans les sous-sections suivantes.

Exemple 1:

Nous commençons par décrire le scipy.Méthode fft () utilisant le morceau de code suivant. Dans cet exemple, nous pouvons voir que le scipy.La méthode fft () peut calculer la transformation rapide de Fourier en recevant un tableau de valeurs et en renvoyant le résultat. Regardez chaque ligne du code.

Ici, dans le code, vous pouvez voir que les deux modules, Scipy et Numpy, sont importés en premier. Après cela, une variable nommée «Input_val» est créée dans laquelle un Numpy.La méthode Array () est utilisée pour produire une grille de valeurs. Après cela, une autre variable nommée «Res_val» peut être vue dans laquelle le scipy.La méthode FFT est utilisée lorsque le «Input_val» créé est passé. Enfin, le résultat est donné.

importer scipy
Importer Numpy
input_val = Numpy.Array (Numpy.Arange (8))
res_val = scipy.fft (input_val)
imprimer (res_val)

Ici, la sortie est attachée pour votre référence:

Exemple 2:

Discutons de la fonction Scipy FFT RFFT de Python. La transformation discrète de Fourier dans une dimension de l'entrée réelle spécifiée est calculée par le module Scipy RFFT () du langage de programmation Python.

La sortie de la méthode RFFT est de type ndarray. L'entrée finale si l'axe n'est pas spécifié, ou l'entrée qui a été nul ou tronquée et transformée le long de l'axe fourni par l'axe.

Prenons le programme comme exemple en exécutant le code suivant. Essayez de comprendre complètement le programme de code.

Dans la première ligne, la méthode RFFT est importée du scipy.module FFT. Suivant cela, la méthode RFFT est appliquée aux valeurs de tableau créées. Les valeurs sont 2,4,6 et 8. Le résultat de la méthode FFT est stocké dans la variable créée nommée «Magnum». Enfin, l'instruction «Print (Magnum)» est utilisée pour afficher le résultat.

de Scipy.FFT IMPORT RFFT
magnum = rfft ([2, 4, 6, 8])
Imprimer (Magnum)

C'est la bonne façon d'utiliser la méthode Python Scipy RFFT () et comment calculer la transformée de Fourier discrète.

Ce qui suit est la sortie générée à partir du code précédent pour votre aide:

Exemple 3:

Le troisième exemple de cet article comprend les détails sur Python Scipy FFT Shift. La méthode fftshift () produit le type y de ndarray. Ici, y est le tableau décalé.

Voyons cet exemple.

Au départ, vous pouvez voir que nous importons les bibliothèques requises. Le code pour ce faire est «de Scipy.FFT IMPORT FFTSHIFT, FFTFREQ ”comme vous le voyez au début du code qui est joint dans les éléments suivants. Après cela, nous calculons les fréquences en utilisant la deuxième ligne du code. Maintenant, nous fournissons les fréquences à une méthode de fftShift () en utilisant le code «res = fftshift (fréquences)». Enfin, l'impression (RES) est utilisée pour afficher le résultat pour les lecteurs.

de Scipy.FFT IMPORT FFTSHIFT, FFTFREQ
frequncics = fftfreq (7,4)
res = fftshift (frequncics)
imprimer (res)

La capture d'écran qui en résulte est. C'est la meilleure façon de déplacer le composant zéro fréquence du spectre vers le point médian. Il est déplacé dans les fréquences définies en utilisant la méthode fftShift ():

Exemple 4:

La fréquence des échantillons est contrôlée par le scipy scipy.module FFT. Les centres de bac de fréquence sont retournés par le tableau flottant «F». C'est en cycles par unité. La méthode fftfreq () renvoie un objet ndarary avec la valeur F.

Ce qui suit est un autre exemple de programme pour mieux comprendre le concept.

Tout d'abord, nous importons les bibliothèques nécessaires à l'aide de l'instruction IMPORT. Ensuite, comme le montre le code suivant, il produit un signal et Fourier le transforme.

Nous importons les bibliothèques requises (Numpy, FFT et FFTREQ) à l'aide des instructions d'importation. Après cela, nous créons un signal. Il est ensuite transformé en utilisant Fourier comme indiqué dans le code suivant. Après cela, nous calculons les fréquences d'échantillonnage et prédisons le temps comme «Time_st = 0.1". C'est la façon recommandée d'utiliser la méthode fftfreq () disponible dans Python Scipy.

Importer Numpy
de Scipy.FFT IMPORT FFT
de Scipy.FFT IMPORT FFTFREQ
créé_sig = numpy.Array ([3, -4, 5, 0, 2, 5, 8, 10], dtype = float)
ft_val = fft (créé_sig)
data_val = créé_sig.taille
Time_st = 0.1
freq = fftfreq (data_val, d = time_st)
Imprimer (Freq)

Voici le résultat:

Exemple 5:

FFT est utilisé par la méthode FFTConVolve () de Scipy dans le scipy.Module de signal pour convoluer les tableaux en n dimension (transformée de Fourier rapide). L'exemple de code de programmation suivant démontre l'idée fftConvolve (). Reportez-vous au code joint suivant.

Le code est très similaire aux codes d'échantillons précédents, sauf que nous avons utilisé la méthode fftConvolve () ici et déterminé les niveaux de bruit et d'autocorrélation.

Exécutez cet exemple de code (voir l'image ci-jointe suivante) et comprenez comment utiliser la méthode fftConvelve () pour condamner un tableau à n dimensions:

de Scipy.Importation de signal fftConvolve
importer scipy.signal
Importer Numpy
Importer Matplotlib.pypllot comme plt
SIG1 = Numpy.aléatoire.default_rng ()
res = sig1.Standard_Normal (500)
autocorrélation = fftConvolve (res, res [:: - 1], mode = 'full')
Fig, (orig_axes, mag_axes) = plt.intrigues secondaires (2, 1)
origine.Terrain (res)
origine.set_title ('bruit')
mag_axes.Terrain (Numpy.arange (-len (res) + 1, len (res)), autocorrélation)
mag_axes.set_title («autocorrélation»)
figue.serré_layout ()
figue.montrer()

Voir la sortie suivante. Cette sortie est générée à partir du code précédent. Le premier graphique montre le bruit et le deuxième graphique montre l'autocorrélation:

Conclusion

Scipy FFT est le sujet de discussion dans ce post. Pour résumer, le simple réseau Numpy 1-D est transmis au scipy.Méthode fft () qui calcule la transformation rapide de Fourier et renvoie le tableau transformé. Nous avons diverses techniques, notamment Scipy Fft () Shift (), FftFreq () et FftConVolve (). Les échantillons de programmation et les discussions détaillées de chacune de ces techniques sont fournies. Pour mieux comprendre ledit sujet, reportez-vous aux codes fournis dans cet article.