scipy.fft.

rfftn#

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

Berechnet die N-dimensionale diskrete Fouriertransformation für reelle Eingaben.

Diese Funktion berechnet die N-dimensionale diskrete Fouriertransformation über eine beliebige Anzahl von Achsen in einem M-dimensionalen reellen Array mithilfe der Fast Fourier Transform (FFT). Standardmäßig werden alle Achsen transformiert, wobei die reelle Transformation über die letzte Achse durchgeführt wird, 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.). Das letzte Element von s entspricht n für rfft(x, n), während es für die verbleibenden Achsen n für fft(x, n) entspricht. Entlang jeder Achse, wenn die gegebene Form kleiner ist als die der Eingabe, 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 durch 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 über die Parameter erläutert. Die Länge der letzten transformierten Achse beträgt s[-1]//2+1, während die verbleibenden transformierten Achsen Längen gemäß s oder unverändert von der Eingabe haben.

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

irfftn: Die Umkehrfunktion von rfftn, d. h. die Umkehrung der N-dimensionalen FFT reeller Eingaben.
fft: Die 1-D FFT mit Definitionen und Konventionen.
rfft: Die 1D-FFT reeller Eingaben.
fftn: Die N-dimensionale FFT.
rfft2: Die 2-D-FFT von reellen Eingaben.

Hinweise

Die Transformation für reelle Eingaben wird über die letzte Transformationsachse durchgeführt, wie bei rfft, und dann wird die Transformation über die verbleibenden Achsen wie bei fftn durchgeführt. Die Reihenfolge der Ausgabe ist für die letzte Transformationsachse wie bei rfft und für die verbleibenden Transformationsachsen wie bei fftn.

Siehe fft für Details, Definitionen und verwendete Konventionen.

Beispiele

>>> import scipy.fft
>>> import numpy as np
>>> x = np.ones((2, 2, 2))
>>> scipy.fft.rfftn(x)
array([[[8.+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.rfftn(x, axes=(2, 0))
array([[[4.+0.j,  0.+0.j], # may vary
        [4.+0.j,  0.+0.j]],
       [[0.+0.j,  0.+0.j],
        [0.+0.j,  0.+0.j]]])