numpy.fft.fftn

fft.fftn(a, s=None, axes=None, norm=None, out=None)[source]

Вычисление n-мерного дискретного преобразования Фурье.

Эта функция вычисляет n-мерное дискретное преобразование Фурье по любому количеству осей в массиве размерностью m с помощью Быстрого преобразования Фурье (FFT).

Параметры:

aarray_like

Входной массив, может быть комплексным.

sпоследовательность целых чисел, необязательно

Форма (длина каждой преобразованной оси) выходного значения (s[0] относится к оси 0, s[1] к оси 1 и т. д.). Это соответствует n для fft(x, n). По любой оси, если заданная форма меньше, чем форма входного значения, входное значение усекается. Если она больше, входное значение дополняется нулями.

Изменено в версии 2.0: Если это -1, всё входное значение используется (без дополнения/обрезания).

Если s не задано, используется форма входного значения по осям, указанным в axes.

Устарело начиная с версии 2.0: Если s не None, axes также не должно быть None.

Устарело начиная с версии 2.0: s должен содержать только int значения, а не None значения. None значения в настоящее время означают, что используется значение по умолчанию для n в соответствующем одномерном преобразовании, но такое поведение устарело.

axesпоследовательность целых чисел, необязательно

Оси, по которым вычисляется FFT. Если не указано, используются последние len(s) оси, или все оси, если s также не указано. Повторные индексы в axes означают, что преобразование по этой оси выполняется несколько раз.

Устарело начиная с версии 2.0: Если s указано, соответствующее axes для преобразования также должно быть явно указано.

norm{“backward”, “ortho”, “forward”}, optional

Новое в версии 1.10.0.

Режим нормализации (см. numpy.fft). По умолчанию — “backward”. Указывает, какая из направлений прямой/обратной пары преобразований масштабируется и с каким фактором нормализации.

Новое в версии 1.20.0: Были добавлены значения “backward”, “forward”.

outcomplex ndarray, optional

Если предоставлено, результат будет помещён в этот массив. Он должен иметь соответствующую форму и тип данных для всех осей (и, следовательно, несовместим с передачей во всех, кроме тривиальных s).

Новое в версии 2.0.0.

Возвращает:

outcomplex ndarray

Усечённое или дополненное нулями входное значение, преобразованное по осям, указанным в axes, или с помощью комбинации s и a, как описано в разделе параметров выше.

Возможные исключения:

ValueError

Если s и axes имеют разную длину.

IndexError

Если элемент axes больше, чем число осей в a.

См. также

numpy.fft

Общий вид дискретных преобразований Фурье с определениями и используемыми соглашениями.

ifftn

Обратное преобразование к fftn, обратное n-мерное преобразование Фурье.

fft

Одномерное преобразование Фурье с определениями и используемыми соглашениями.

rfftn

n-мерное преобразование Фурье действительного входного значения.

fft2

Двумерное преобразование Фурье.

fftshift

Смещает члены нулевой частоты в центр массива.

Примечания

Выход, аналогично fft, содержит член нулевой частоты в углу низкого порядка всех осей, положительные члены частоты в первой половине всех осей, член частоты Найквиста в середине всех осей и отрицательные члены частоты во второй половине всех осей в порядке убывания отрицательной частоты.

См. numpy.fft для получения подробной информации, определений и используемых соглашений.

Примеры

>>> a = np.mgrid[:3, :3, :3][0]
>>> np.fft.fftn(a, axes=(1, 2))
array([[[ 0.+0.j,   0.+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]],
       [[ 9.+0.j,   0.+0.j,   0.+0.j],
        [ 0.+0.j,   0.+0.j,   0.+0.j],
        [ 0.+0.j,   0.+0.j,   0.+0.j]],
       [[18.+0.j,   0.+0.j,   0.+0.j],
        [ 0.+0.j,   0.+0.j,   0.+0.j],
        [ 0.+0.j,   0.+0.j,   0.+0.j]]])
>>> np.fft.fftn(a, (2, 2), axes=(0, 1))
array([[[ 2.+0.j,  2.+0.j,  2.+0.j], # may vary
        [ 0.+0.j,  0.+0.j,  0.+0.j]],
       [[-2.+0.j, -2.+0.j, -2.+0.j],
        [ 0.+0.j,  0.+0.j,  0.+0.j]]])

>>> import matplotlib.pyplot as plt
>>> [X, Y] = np.meshgrid(2 * np.pi * np.arange(200) / 12,
...                      2 * np.pi * np.arange(200) / 34)
>>> S = np.sin(X) + np.cos(Y) + np.random.uniform(0, 1, X.shape)
>>> FS = np.fft.fftn(S)
>>> plt.imshow(np.log(np.abs(np.fft.fftshift(FS))**2))
<matplotlib.image.AxesImage object at 0x...>
>>> plt.show()