FFT in numpy vs FFT in MATLAB non hanno gli stessi risultati

Question

Ho un vettore con numeri complessi (può essere trovato here), sia in Python che in MATLAB. Sto calcolando la ifft -Trasformazione con

ifft(<vector>) 

in MATLAB e con

np.fft.ifft(<vector>) 

in Python. Il mio problema è che ottengo due risultati completamente diversi da esso, cioè mentre il vettore in Python è complesso, non è in MATLAB. Mentre alcuni componenti in MATLAB sono zero, nessuno è in Python. Perché? La versione fft funziona come previsto. I valori minimi sono intorno a 1e-10, cioè non troppo bassi.

Answer 1

In realtà, sono uguali ma Python mostra la parte immaginaria con estrema precisione. I componenti immaginari vengono visualizzati con valori di grandezza pari a circa 10^{-12}.

Ecco quello che ho scritto per ricostruire il vostro problema in MATLAB:

format long g; 
data = importdata('data.txt'); 
out = ifft(data); 

format long g; è un'opzione di formattazione che mostra cifre più significative in cui vi mostriamo 15 cifre significative, tra cui cifre decimali.

Quando mostro i primi 10 elementi della uscita FFT inversa, questo è ciò che ottengo:

>> out(1:10) 

ans = 

     -6.08077329443768 
     -5.90538963023573 
     -5.72145198564976 
     -5.53037208039314 
     -5.33360059559345 
     -5.13261402212083 
     -4.92890104744583 
     -4.72394865937531 
     -4.51922820694745 
     -4.31618153490126 

Per numpy, essere informati che i numeri complessi vengono letti con l'j lettera, non i. Pertanto, quando carichi il testo, devi convertire tutti i caratteri i in j. Una volta fatto questo, è possibile caricare nei dati come normale:

In [15]: import numpy as np 

In [16]: with open('data.txt', 'r') as f: 
    ....:  lines = map(lambda x: x.replace('i', 'j'), f) 
    ....:  data = np.loadtxt(lines, dtype=np.complex) 

Quando si apre il file, la chiamata a map sarebbe quindi prendere il contenuto del file e trasformare ogni carattere i in j e restituire un elenco di stringhe in cui ogni elemento in questo elenco è un numero complesso nel file di testo con lo i sostituito come j. Chiameremo quindi la funzione numpy.loadtxt per convertire queste stringhe in una serie di numeri complessi.

Ora, quando prendo l'IFFT e visualizzare la prima 10 elementi del risultato invertito come abbiamo visto con la versione di MATLAB, otteniamo:

In [20]: out = np.fft.ifft(data) 

In [21]: out[:10] 
Out[21]: 
array([-6.08077329 +0.00000000e+00j, -5.90538963 +8.25472974e-12j, 
     -5.72145199 +3.56159535e-12j, -5.53037208 -1.21875843e-11j, 
     -5.33360060 +1.77529105e-11j, -5.13261402 -1.58326676e-11j, 
     -4.92890105 -6.13731196e-12j, -4.72394866 +5.46673985e-12j, 
     -4.51922821 -2.59774424e-11j, -4.31618154 -1.77484689e-11j]) 

Come si può vedere la parte reale è lo stesso, ma la esiste ancora una parte immaginaria. Tuttavia, nota quanto siano piccoli i componenti immaginari. MATLAB in questo caso ha scelto di non visualizzare i componenti immaginari perché le loro grandezze sono molto piccole. In realtà, il tipo di dati restituito dalla chiamata ifft in MATLAB è reale, quindi probabilmente c'era qualche post-elaborazione dopo che ifft è stato chiamato per scartare questi componenti immaginari. numpy non fa la stessa cosa, ma si potrebbe anche considerare questi componenti molto piccoli e insignificanti.

---

Tutto sommato, entrambi ifft chiamate in Python e MATLAB sono essenzialmente gli stessi, ma le componenti immaginarie sono diversi, nel senso che Python/numpy restituisce quei componenti immaginari anche se sono insignificanti in cui come il ifft chiamata MATLAB no. Ricorda inoltre che è necessario assicurarsi che la variabile immaginaria sia sostituita con j e che non sia possibile utilizzare i come nel file di testo originale che hai fornito. Se si conosce per alcuni che il tipo di output deve essere reale, è anche possibile rilasciare i componenti immaginari dando una chiamata a numpy.real sul risultato ifft se lo si desidera.