Scipy fft

Sia Numpy che Scipy a Python hanno molte routine FFT (da base al complesso). Il concetto FFT di Scipy sarà esaminato a fondo in questo post. Esploreremo anche come applicarlo in pratica. Spiegheremo quali sono le funzioni FFT di Scipy e ti daremo alcuni esempi di programmazione per iniziare. Il Scipy.fft (), Scipy.fft rfft (), Scipy.FFT shift (), fftfreq () e fftconvoluve () saranno tutti trattati in dettaglio insieme ad esempi in questo articolo. Gli esempi sono forniti per chiarire l'argomento per te in modo da poterlo mettere in pratica con facilità.

Python Scipy FFT Spiegazione

Il metodo di analisi di Fourier definisce esclusivamente una funzione come il totale dei componenti periodici e deriva il segnale che è coperto dal modulo Python Scipy chiamato Scipy.fft. La funzione e la sua trasformazione di Fourier (FT) sono entrambi sostituiti con equivalenti discretizzati per produrre la trasformata discreta di Fourier.

Usando una sequenza basata sul tempo, la trasformata di Fourier, semplicemente chiamata Fourier, è una funzione matematica che determina la velocità di rotazione complessiva, la sua forza e l'offset del ciclo per il potenziale ciclo di ciascun modello. Le forme d'onda, le operazioni primarie di tempo, spazio o qualsiasi altra variabile possono essere facilmente trasformate con l'aiuto della trasformata di Fourier.

Studieremo il metodo di trasformazione di Fourier più popolare con esempi nelle seguenti sottosezioni.

Esempio 1:

Iniziamo descrivendo lo Scipy.Metodo fft () utilizzando il seguente pezzo di codice. In questo esempio, possiamo vedere che il Scipy.Il metodo fft () può calcolare la trasformazione veloce di Fourier ricevendo un array di valori e restituendo il risultato. Guarda ogni riga del codice.

Qui, nel codice, puoi vedere che i due moduli, Scipy e Numpy, vengono importati per primi. Successivamente, viene creata una variabile denominata "input_val" in cui un numpy.Il metodo array () viene utilizzato per produrre una griglia di valori. Dopodiché, si può vedere un'altra variabile denominata "res_val" in cui il Scipy.Viene utilizzato il metodo FFT in cui viene superato il "input_val" creato. Infine, il risultato è dato.

Import Scipy
importa numpy
input_val = numpy.Array (Numpy.Arange (8))
Res_val = Scipy.FFT (input_val)
Stampa (res_val)

Qui, l'output è allegato per il tuo riferimento:

Esempio 2:

Discutiamo la funzione FFT RFFT di Python's Scipy. La trasformata discreta di Fourier in una dimensione dell'input reale specificato viene calcolata dal modulo Scipy Rfft () del linguaggio di programmazione Python.

L'output del metodo RFFT è di tipo ndarray. L'input finale se l'asse non è specificato o l'ingresso che è stato a zero imbottiti o troncati e trasformati lungo l'asse fornito dall'asse.

Prendiamo il programma come esempio eseguendo il seguente codice. Prova a comprendere completamente il programma di codice.

Nella prima riga, il metodo Rfft viene importato dal Scipy.Modulo FFT. Successivamente, il metodo RFFT viene applicato ai valori dell'array creato. I valori sono 2,4,6 e 8. Il risultato del metodo FFT è memorizzato nella variabile creata denominata "Magnum". Infine, l'istruzione "Print (Magnum)" viene utilizzata per mostrare il risultato.

da Scipy.FFT Import Rfft
Magnum = Rfft ([2, 4, 6, 8])
Stampa (Magnum)

Questo è il modo giusto di utilizzare il metodo Python Scipy rfft () e come calcolare la trasformata discreta di Fourier.

Quanto segue è l'output generato dal codice precedente per il tuo aiuto:

Esempio 3:

Il terzo esempio di questo articolo include i dettagli su Python Scipy FFT Shift. Il metodo fftshift () produce il tipo di NDArray. Qui, Y è l'array spostato.

Consideriamo questo esempio.

Inizialmente, puoi vedere che importiamo le biblioteche richieste. Il codice per farlo è "da Scipy.FFT Importa fftshift, fftfreq ”come vedi all'inizio del codice che è allegato nel seguente. Successivamente, calcoliamo le frequenze usando la seconda riga del codice. Ora, forniamo le frequenze a un metodo di fftshift () utilizzando il codice "res = fftshift (frequenze)". Infine, la stampa (RES) viene utilizzata per visualizzare il risultato per i lettori.

da Scipy.FFT Import FftShift, Fftfreq
FreqUncies = fftfreq (7,4)
Res = fftshift (FreqUncies)
Stampa (Res)

Allegato è lo screenshot risultante. Questo è il modo migliore per spostare il componente a frequenza zero dello spettro nel punto medio. Viene spostato nelle frequenze definite usando il metodo fftshift ():

Esempio 4:

La frequenza dei campioni è controllata da Scipy Scipy.Modulo FFT. I centri di cestino di frequenza vengono restituiti dall'array float "F". È in cicli per unità. Il metodo fftfreq () restituisce un oggetto ndarary con il valore f.

Quello che segue è un altro programma di esempio per comprendere meglio il concetto.

Innanzitutto, importiamo le librerie necessarie utilizzando l'istruzione di importazione. Quindi, come visto nel seguente codice, produce un segnale e Fourier lo trasforma.

Importiamo le librerie richieste (Numpy, FFT e FFTREQ) utilizzando le istruzioni di importazione. Dopodiché, creiamo un segnale. Viene quindi trasformato usando Fourier come mostrato nel codice seguente. Successivamente, calcoliamo le frequenze del campione e predefiniamo il tempo come “time_st = 0.1 ". Questo è il modo consigliato per utilizzare il metodo fftfreq () disponibile in Python Scipy.

importa numpy
da Scipy.FFT Importa FFT
da Scipy.FFT Import fftfreq
creato_sig = numpy.Array ([3, -4, 5, 0, 2, 5, 8, 10], dType = float)
ft_val = fft (creato_sig)
data_val = creato_sig.misurare
time_st = 0.1
freq = fftfreq (data_val, d = time_st)
Stampa (freq)

Ecco il risultato:

Esempio 5:

FFT è utilizzato dal metodo FFTConVolve () di Scipy in Scipy.Modulo di segnale per convogliare gli array N-dimensionali (trasformata di Fourier veloce). Il seguente codice di programmazione di esempio dimostra l'idea fftconvolve (). Fare riferimento al seguente codice allegato.

Il codice è molto simile ai precedenti codici di esempio, tranne per il fatto che abbiamo usato il metodo FFTConVolve () qui e determinato i livelli di rumore e autocorrelazione.

Esegui questo codice di esempio (consultare la seguente immagine allegata) e capire come utilizzare il metodo FFTConVolve () per convocare un array N-dimensionale:

da Scipy.Signal Importa FFTConVolve
Import Scipy.segnale
importa numpy
Importa matplotlib.Pyplot come Plt
sig1 = numpy.casuale.default_rng ()
Res = Sig1.Standard_Normal (500)
autocorrelazione = fftconvolve (res, res [:: 1], modalità = 'full')
Fig, (orig_axes, mag_axes) = plt.sottotrame (2, 1)
orig_axes.trama (res)
orig_axes.set_title ('rumore')
mag_axes.Trama (numpy.Arange (-len (res)+1, len (res)), autocorrelazione)
mag_axes.set_title ('autocorrelazione')
Fico.stretto_layout ()
Fico.spettacolo()

Vedere il seguente output. Questo output viene generato dal codice precedente. Il primo grafico mostra il rumore e il secondo grafico mostra l'autocorrelazione:

Conclusione

SCIPY FFT ​​è l'argomento della discussione in questo post. Per riassumere, il semplice array numpy 1-d viene passato allo Scipy.Metodo fft () che calcola la trasformazione rapida di Fourier e restituisce l'array trasformato. Abbiamo varie tecniche tra cui Scipy fft () shift (), fftfreq () e fftconvolve (). Vengono forniti i campioni di programmazione e le discussioni dettagliate di ciascuna di queste tecniche. Per comprendere ulteriormente il suddetto argomento, consultare i codici forniti in questo articolo.