scipy.fft.

ihfftn#

scipy.fft.ihfftn(x, s=None, axes=None, norm=None, overwrite_x=False, workers=None, *, plan=None)[Quelle]#

Berechnet die N-D-diskrete inverse Fourier-Transformation für ein reelles Spektrum.

Diese Funktion berechnet die N-D-diskrete inverse Fourier-Transformation über beliebig viele Achsen in einem M-D-reellen Array mittels der schnellen Fourier-Transformation (FFT). Standardmäßig werden alle Achsen transformiert, wobei die reelle Transformation über die letzte Achse erfolgt, während die verbleibenden Transformationen komplex sind.

Parameter:

xarray_like: Eingabearray, das als reell angenommen wird.
sSequenz von ganzen Zahlen, optional: Form (Länge entlang jeder transformierten Achse), die aus der Eingabe verwendet werden soll. (s[0] bezieht sich auf Achse 0, s[1] auf Achse 1 usw.). Entlang jeder Achse, wenn die angegebene Form kleiner als die der Eingabe ist, wird die Eingabe abgeschnitten. Wenn sie größer ist, wird die Eingabe mit Nullen aufgefüllt. Wenn s nicht angegeben ist, wird die Form der Eingabe entlang der von axes angegebenen Achsen verwendet.
axesSequenz von ganzen Zahlen, optional: Achsen, über die die FFT berechnet werden soll. Wenn nicht angegeben, werden die letzten len(s) Achsen verwendet, oder alle Achsen, wenn auch s nicht angegeben ist.
norm{“backward”, “ortho”, “forward”}, optional: Normalisierungsmodus (siehe fft). Standard ist „backward“.
overwrite_xbool, optional: Wenn True, kann der Inhalt von x zerstört werden; Standard ist False. Weitere Einzelheiten finden Sie unter fft.
workersint, optional: Maximale Anzahl von Workern, die für die parallele Berechnung verwendet werden sollen. Wenn negativ, wickelt sich der Wert von os.cpu_count() ab. Weitere Einzelheiten finden Sie unter fft.
planobject, optional: Dieses Argument ist für die Übergabe eines vorab berechneten Plans von nachgelagerten FFT-Anbietern reserviert. Es wird derzeit in SciPy nicht verwendet.

Hinzugefügt in Version 1.5.0.

Rückgabe:

outcomplex ndarray: Die abgeschnittene oder mit Nullen aufgefüllte Eingabe, transformiert entlang der durch axes angegebenen Achsen oder durch eine Kombination von s und x, wie im obigen Abschnitt Parameter erklärt. Die Länge der letzten transformierten Achse wird s[-1]//2+1 betragen, während die verbleibenden transformierten Achsen Längen gemäß s oder unverändert von der Eingabe haben werden.

Löst aus:

ValueError: Wenn s und axes unterschiedliche Längen haben.
IndexError: Wenn ein Element von axes größer ist als die Anzahl der Achsen von x.

Siehe auch

hfftn: Die vorwärts N-D FFT einer hermiteschen Eingabe.
hfft: Die 1-D FFT einer hermiteschen Eingabe.
fft: Die 1-D FFT mit Definitionen und Konventionen.
fftn: Die N-dimensionale FFT.
hfft2: Die 2-D FFT einer hermiteschen Eingabe.

Hinweise

Die Transformation für reelle Eingaben erfolgt über die letzte Transformationsachse, wie bei ihfft, dann erfolgt die Transformation über die verbleibenden Achsen wie bei ifftn. Die Reihenfolge der Ausgabe ist der positive Teil des hermiteschen Ausgangssignals, im selben Format wie bei rfft.

Beispiele

>>> import scipy.fft
>>> import numpy as np
>>> x = np.ones((2, 2, 2))
>>> scipy.fft.ihfftn(x)
array([[[1.+0.j,  0.+0.j], # may vary
        [0.+0.j,  0.+0.j]],
       [[0.+0.j,  0.+0.j],
        [0.+0.j,  0.+0.j]]])
>>> scipy.fft.ihfftn(x, axes=(2, 0))
array([[[1.+0.j,  0.+0.j], # may vary
        [1.+0.j,  0.+0.j]],
       [[0.+0.j,  0.+0.j],
        [0.+0.j,  0.+0.j]]])