--- /tmp/pyfftw-0.12.0-15861xw6x/debian/python-pyfftw-doc_0.12.0-1_all.deb
+++ python-pyfftw-doc_0.12.0-1_all.deb
├── file list
│ @@ -1,3 +1,3 @@
│ -rw-r--r-- 0 0 0 4 2020-02-11 04:37:21.000000 debian-binary
│ -rw-r--r-- 0 0 0 2224 2020-02-11 04:37:21.000000 control.tar.xz
│ --rw-r--r-- 0 0 0 68712 2020-02-11 04:37:21.000000 data.tar.xz
│ +-rw-r--r-- 0 0 0 68692 2020-02-11 04:37:21.000000 data.tar.xz
├── control.tar.xz
│ ├── control.tar
│ │ ├── ./md5sums
│ │ │ ├── ./md5sums
│ │ │ │┄ Files differ
├── data.tar.xz
│ ├── data.tar
│ │ ├── file list
│ │ │ @@ -37,34 +37,34 @@
│ │ │ -rw-r--r-- 0 root (0) root (0) 10847 2020-02-11 04:37:21.000000 ./usr/share/doc/python-pyfftw-doc/html/_static/language_data.js
│ │ │ -rw-r--r-- 0 root (0) root (0) 90 2019-03-09 14:07:37.000000 ./usr/share/doc/python-pyfftw-doc/html/_static/minus.png
│ │ │ -rw-r--r-- 0 root (0) root (0) 90 2019-03-09 14:07:37.000000 ./usr/share/doc/python-pyfftw-doc/html/_static/plus.png
│ │ │ -rw-r--r-- 0 root (0) root (0) 4395 2020-02-11 04:37:21.000000 ./usr/share/doc/python-pyfftw-doc/html/_static/pygments.css
│ │ │ -rw-r--r-- 0 root (0) root (0) 15059 2019-03-10 07:47:02.000000 ./usr/share/doc/python-pyfftw-doc/html/_static/searchtools.js
│ │ │ -rw-r--r-- 0 root (0) root (0) 4803 2020-02-11 04:37:21.000000 ./usr/share/doc/python-pyfftw-doc/html/_static/sidebar.js
│ │ │ -rw-r--r-- 0 root (0) root (0) 21446 2020-02-11 04:37:21.000000 ./usr/share/doc/python-pyfftw-doc/html/genindex.html
│ │ │ --rw-r--r-- 0 root (0) root (0) 11439 2020-02-11 04:37:21.000000 ./usr/share/doc/python-pyfftw-doc/html/index.html
│ │ │ +-rw-r--r-- 0 root (0) root (0) 11437 2020-02-11 04:37:21.000000 ./usr/share/doc/python-pyfftw-doc/html/index.html
│ │ │ -rw-r--r-- 0 root (0) root (0) 1498 2020-02-11 04:37:21.000000 ./usr/share/doc/python-pyfftw-doc/html/objects.inv
│ │ │ -rw-r--r-- 0 root (0) root (0) 5499 2020-02-11 04:37:21.000000 ./usr/share/doc/python-pyfftw-doc/html/py-modindex.html
│ │ │ drwxr-xr-x 0 root (0) root (0) 0 2020-02-11 04:37:21.000000 ./usr/share/doc/python-pyfftw-doc/html/release/
│ │ │ -rw-r--r-- 0 root (0) root (0) 23633 2020-02-11 04:37:21.000000 ./usr/share/doc/python-pyfftw-doc/html/release/0.11.0.html
│ │ │ -rw-r--r-- 0 root (0) root (0) 9320 2020-02-11 04:37:21.000000 ./usr/share/doc/python-pyfftw-doc/html/release/0.12.0.html
│ │ │ -rw-r--r-- 0 root (0) root (0) 3718 2020-02-11 04:37:21.000000 ./usr/share/doc/python-pyfftw-doc/html/search.html
│ │ │ -rw-r--r-- 0 root (0) root (0) 22705 2020-02-11 04:37:21.000000 ./usr/share/doc/python-pyfftw-doc/html/searchindex.js
│ │ │ drwxr-xr-x 0 root (0) root (0) 0 2020-02-11 04:37:21.000000 ./usr/share/doc/python-pyfftw-doc/html/source/
│ │ │ -rw-r--r-- 0 root (0) root (0) 8101 2020-02-11 04:37:21.000000 ./usr/share/doc/python-pyfftw-doc/html/source/api.html
│ │ │ -rw-r--r-- 0 root (0) root (0) 6845 2020-02-11 04:37:21.000000 ./usr/share/doc/python-pyfftw-doc/html/source/license.html
│ │ │ drwxr-xr-x 0 root (0) root (0) 0 2020-02-11 04:37:21.000000 ./usr/share/doc/python-pyfftw-doc/html/source/pyfftw/
│ │ │ drwxr-xr-x 0 root (0) root (0) 0 2020-02-11 04:37:21.000000 ./usr/share/doc/python-pyfftw-doc/html/source/pyfftw/builders/
│ │ │ -rw-r--r-- 0 root (0) root (0) 14717 2020-02-11 04:37:21.000000 ./usr/share/doc/python-pyfftw-doc/html/source/pyfftw/builders/_utils.html
│ │ │ --rw-r--r-- 0 root (0) root (0) 44400 2020-02-11 04:37:21.000000 ./usr/share/doc/python-pyfftw-doc/html/source/pyfftw/builders/builders.html
│ │ │ +-rw-r--r-- 0 root (0) root (0) 44332 2020-02-11 04:37:21.000000 ./usr/share/doc/python-pyfftw-doc/html/source/pyfftw/builders/builders.html
│ │ │ drwxr-xr-x 0 root (0) root (0) 0 2020-02-11 04:37:21.000000 ./usr/share/doc/python-pyfftw-doc/html/source/pyfftw/interfaces/
│ │ │ --rw-r--r-- 0 root (0) root (0) 23919 2020-02-11 04:37:21.000000 ./usr/share/doc/python-pyfftw-doc/html/source/pyfftw/interfaces/dask_fft.html
│ │ │ --rw-r--r-- 0 root (0) root (0) 51690 2020-02-11 04:37:21.000000 ./usr/share/doc/python-pyfftw-doc/html/source/pyfftw/interfaces/interfaces.html
│ │ │ --rw-r--r-- 0 root (0) root (0) 25108 2020-02-11 04:37:21.000000 ./usr/share/doc/python-pyfftw-doc/html/source/pyfftw/interfaces/numpy_fft.html
│ │ │ --rw-r--r-- 0 root (0) root (0) 5800 2020-02-11 04:37:21.000000 ./usr/share/doc/python-pyfftw-doc/html/source/pyfftw/interfaces/scipy_fft.html
│ │ │ --rw-r--r-- 0 root (0) root (0) 20981 2020-02-11 04:37:21.000000 ./usr/share/doc/python-pyfftw-doc/html/source/pyfftw/interfaces/scipy_fftpack.html
│ │ │ --rw-r--r-- 0 root (0) root (0) 61697 2020-02-11 04:37:21.000000 ./usr/share/doc/python-pyfftw-doc/html/source/pyfftw/pyfftw.html
│ │ │ --rw-r--r-- 0 root (0) root (0) 69278 2020-02-11 04:37:21.000000 ./usr/share/doc/python-pyfftw-doc/html/source/tutorial.html
│ │ │ +-rw-r--r-- 0 root (0) root (0) 23855 2020-02-11 04:37:21.000000 ./usr/share/doc/python-pyfftw-doc/html/source/pyfftw/interfaces/dask_fft.html
│ │ │ +-rw-r--r-- 0 root (0) root (0) 51757 2020-02-11 04:37:21.000000 ./usr/share/doc/python-pyfftw-doc/html/source/pyfftw/interfaces/interfaces.html
│ │ │ +-rw-r--r-- 0 root (0) root (0) 25016 2020-02-11 04:37:21.000000 ./usr/share/doc/python-pyfftw-doc/html/source/pyfftw/interfaces/numpy_fft.html
│ │ │ +-rw-r--r-- 0 root (0) root (0) 5810 2020-02-11 04:37:21.000000 ./usr/share/doc/python-pyfftw-doc/html/source/pyfftw/interfaces/scipy_fft.html
│ │ │ +-rw-r--r-- 0 root (0) root (0) 21133 2020-02-11 04:37:21.000000 ./usr/share/doc/python-pyfftw-doc/html/source/pyfftw/interfaces/scipy_fftpack.html
│ │ │ +-rw-r--r-- 0 root (0) root (0) 61680 2020-02-11 04:37:21.000000 ./usr/share/doc/python-pyfftw-doc/html/source/pyfftw/pyfftw.html
│ │ │ +-rw-r--r-- 0 root (0) root (0) 69270 2020-02-11 04:37:21.000000 ./usr/share/doc/python-pyfftw-doc/html/source/tutorial.html
│ │ │ drwxr-xr-x 0 root (0) root (0) 0 2020-02-11 04:37:21.000000 ./usr/share/doc-base/
│ │ │ -rw-r--r-- 0 root (0) root (0) 292 2020-02-11 04:37:21.000000 ./usr/share/doc-base/pyfftw-doc
│ │ │ lrwxrwxrwx 0 root (0) root (0) 0 2020-02-11 04:37:21.000000 ./usr/share/doc/python-pyfftw-doc/html/_static/jquery.js -> ../../../../javascript/jquery/jquery.js
│ │ │ lrwxrwxrwx 0 root (0) root (0) 0 2020-02-11 04:37:21.000000 ./usr/share/doc/python-pyfftw-doc/html/_static/underscore.js -> ../../../../javascript/underscore/underscore.js
│ │ ├── ./usr/share/doc/python-pyfftw-doc/html/index.html
│ │ │ @@ -46,25 +46,25 @@
│ │ │
│ │ │
Introduction
│ │ │
pyFFTW is a pythonic wrapper around FFTW, the
│ │ │ speedy FFT library. The ultimate aim is to present a unified interface for all
│ │ │ the possible transforms that FFTW can perform.
│ │ │
Both the complex DFT and the real DFT are supported, as well as on arbitrary
│ │ │ axes of abitrary shaped and strided arrays, which makes it almost
│ │ │ -feature equivalent to standard and real FFT functions of numpy.fft
│ │ │ +feature equivalent to standard and real FFT functions of numpy.fft
│ │ │ (indeed, it supports the clongdouble dtype which
│ │ │ numpy.fft does not).
│ │ │
Operating FFTW in multithreaded mode is supported.
│ │ │
The core interface is provided by a unified class, pyfftw.FFTW.
│ │ │ This core interface can be accessed directly, or through a series of helper
│ │ │ functions, provided by the pyfftw.builders module. These helper
│ │ │ -functions provide an interface similar to numpy.fft for ease of use.
│ │ │ +functions provide an interface similar to
numpy.fft for ease of use.
│ │ │
In addition to using pyfftw.FFTW, a convenient series of functions
│ │ │ are included through pyfftw.interfaces that make using pyfftw
│ │ │ -almost equivalent to numpy.fft or scipy.fftpack.
│ │ │ +almost equivalent to
numpy.fft or
scipy.fftpack.
│ │ │
The source can be found in github and
│ │ │ its page in the python package index is here.
│ │ │
A comprehensive unittest suite is included with the source on the repository.
│ │ │ If any aspect of this library is not covered by the test suite, that is a bug
│ │ │ (please report it!).
│ │ │
│ │ ├── ./usr/share/doc/python-pyfftw-doc/html/source/pyfftw/builders/builders.html
│ │ │ @@ -49,15 +49,15 @@
│ │ │
│ │ │
pyfftw.builders - Get FFTW objects using a numpy.fft like interface
│ │ │
│ │ │
Overview
│ │ │
This module contains a set of functions that return
│ │ │ pyfftw.FFTW objects.
│ │ │
The interface to create these objects is mostly the same as
│ │ │ -numpy.fft, only instead of the call returning the result of the
│ │ │ +numpy.fft, only instead of the call returning the result of the
│ │ │ FFT, a pyfftw.FFTW object is returned that performs that FFT
│ │ │ operation when it is called. Users should be familiar with
│ │ │ numpy.fft before reading on.
│ │ │
In the case where the shape argument, s (or n in the
│ │ │ 1-dimensional case), dictates that the passed-in input array be copied
│ │ │ into a different processing array, the returned object is an
│ │ │ instance of a child class of pyfftw.FFTW,
│ │ │ @@ -112,15 +112,15 @@
│ │ │
│ │ │
More examples can be found in the tutorial.
│ │ │
│ │ │
│ │ │
Supported Functions and Caveats
│ │ │
The following functions are supported. They can be used with the
│ │ │ same calling signature as their respective functions in
│ │ │ -numpy.fft.
│ │ │ +
numpy.fft.
│ │ │
Standard FFTs
│ │ │
│ │ │ fft()ifft()fft2()ifft2()fftn()fft and ifft, the dtype must
│ │ │ be complex, for rfft it must be real, and so on. The other point
│ │ │ to note from this is that the precision of the transform matches the
│ │ │ precision of the input array. So, if a single precision input array is
│ │ │ passed in, then a single precision transform will be used.
│ │ │ The second caveat is that repeated axes are handled differently; with
│ │ │ the returned pyfftw.FFTW object, axes that are repeated in the
│ │ │ -axes argument are considered only once, as compared to numpy.fft
│ │ │ +axes argument are considered only once, as compared to numpy.fft
│ │ │ in which repeated axes results in the DFT being taken along that axes
│ │ │ as many times as the axis occurs (this is down to the underlying
│ │ │ library).
│ │ │ Note that unless the auto_align_input argument to the function
│ │ │ is set to True, the 'FFTW_UNALIGNED' flag
│ │ │ is set in the returned pyfftw.FFTW object. This disables some
│ │ │ of the FFTW optimisations that rely on aligned arrays. Also worth
│ │ │ noting is that the auto_align_input flag only results in a copy
│ │ │ when calling the resultant pyfftw.FFTW object if the input
│ │ │ array is not already aligned correctly.
│ │ │
│ │ │
│ │ │
Additional Arguments
│ │ │
In addition to the arguments that are present with their complementary
│ │ │ -functions in numpy.fft, each of these functions also offers the
│ │ │ +functions in numpy.fft, each of these functions also offers the
│ │ │ following additional keyword arguments:
│ │ │
│ │ │ overwrite_input: Whether or not the input array can be
│ │ │ overwritten during the transform. This sometimes results in a faster
│ │ │ algorithm being made available. It causes the 'FFTW_DESTROY_INPUT'
│ │ │ flag to be passed to the pyfftw.FFTW object. This flag is not
│ │ │ offered for the multi-dimensional inverse real transforms, as FFTW is
│ │ │ @@ -238,131 +238,131 @@
│ │ │
│ │ │
This argument is distinct from overwrite_input in that it only
│ │ │ influences a copy during the creation of the object. It changes no
│ │ │ flags in the pyfftw.FFTW object.
│ │ │
│ │ │
│ │ │
The exceptions raised by each of these functions are as per their
│ │ │ -equivalents in numpy.fft, or as documented above.
│ │ │ +equivalents in
numpy.fft, or as documented above.
│ │ │
│ │ │
│ │ │
The Functions
│ │ │
│ │ │ -
│ │ │
pyfftw.builders.fft(a, n=None, axis=-1, overwrite_input=False, planner_effort=None, threads=None, auto_align_input=True, auto_contiguous=True, avoid_copy=False, norm=None)
│ │ │ Return a pyfftw.FFTW object representing a 1D FFT.
│ │ │ -The first three arguments are as per numpy.fft.fft();
│ │ │ +
The first three arguments are as per numpy.fft.fft();
│ │ │ the rest of the arguments are documented
│ │ │ in the module docs.
│ │ │
│ │ │
│ │ │
│ │ │ -
│ │ │
pyfftw.builders.ifft(a, n=None, axis=-1, overwrite_input=False, planner_effort=None, threads=None, auto_align_input=True, auto_contiguous=True, avoid_copy=False, norm=None)
│ │ │ Return a pyfftw.FFTW object representing a 1D
│ │ │ inverse FFT.
│ │ │ -The first three arguments are as per numpy.fft.ifft();
│ │ │ +
The first three arguments are as per numpy.fft.ifft();
│ │ │ the rest of the arguments are documented
│ │ │ in the module docs.
│ │ │
│ │ │
│ │ │
│ │ │ -
│ │ │
pyfftw.builders.fft2(a, s=None, axes=(-2, -1), overwrite_input=False, planner_effort=None, threads=None, auto_align_input=True, auto_contiguous=True, avoid_copy=False, norm=None)
│ │ │ Return a pyfftw.FFTW object representing a 2D FFT.
│ │ │ -The first three arguments are as per numpy.fft.fft2();
│ │ │ +
The first three arguments are as per numpy.fft.fft2();
│ │ │ the rest of the arguments are documented
│ │ │ in the module docs.
│ │ │
│ │ │
│ │ │
│ │ │ -
│ │ │
pyfftw.builders.ifft2(a, s=None, axes=(-2, -1), overwrite_input=False, planner_effort=None, threads=None, auto_align_input=True, auto_contiguous=True, avoid_copy=False, norm=None)
│ │ │ Return a pyfftw.FFTW object representing a
│ │ │ 2D inverse FFT.
│ │ │ -The first three arguments are as per numpy.fft.ifft2();
│ │ │ +
The first three arguments are as per numpy.fft.ifft2();
│ │ │ the rest of the arguments are documented
│ │ │ in the module docs.
│ │ │
│ │ │
│ │ │
│ │ │ -
│ │ │
pyfftw.builders.fftn(a, s=None, axes=None, overwrite_input=False, planner_effort=None, threads=None, auto_align_input=True, auto_contiguous=True, avoid_copy=False, norm=None)
│ │ │ Return a pyfftw.FFTW object representing a n-D FFT.
│ │ │ -The first three arguments are as per numpy.fft.fftn();
│ │ │ +
The first three arguments are as per numpy.fft.fftn();
│ │ │ the rest of the arguments are documented
│ │ │ in the module docs.
│ │ │
│ │ │
│ │ │
│ │ │ -
│ │ │
pyfftw.builders.ifftn(a, s=None, axes=None, overwrite_input=False, planner_effort=None, threads=None, auto_align_input=True, auto_contiguous=True, avoid_copy=False, norm=None)
│ │ │ Return a pyfftw.FFTW object representing an n-D
│ │ │ inverse FFT.
│ │ │ -The first three arguments are as per numpy.fft.ifftn();
│ │ │ +
The first three arguments are as per numpy.fft.ifftn();
│ │ │ the rest of the arguments are documented
│ │ │ in the module docs.
│ │ │
│ │ │
│ │ │
│ │ │ -
│ │ │
pyfftw.builders.rfft(a, n=None, axis=-1, overwrite_input=False, planner_effort=None, threads=None, auto_align_input=True, auto_contiguous=True, avoid_copy=False, norm=None)
│ │ │ Return a pyfftw.FFTW object representing a 1D
│ │ │ real FFT.
│ │ │ -The first three arguments are as per numpy.fft.rfft();
│ │ │ +
The first three arguments are as per numpy.fft.rfft();
│ │ │ the rest of the arguments are documented
│ │ │ in the module docs.
│ │ │
│ │ │
│ │ │
│ │ │ -
│ │ │
pyfftw.builders.irfft(a, n=None, axis=-1, overwrite_input=False, planner_effort=None, threads=None, auto_align_input=True, auto_contiguous=True, avoid_copy=False, norm=None)
│ │ │ Return a pyfftw.FFTW object representing a 1D
│ │ │ real inverse FFT.
│ │ │ -The first three arguments are as per numpy.fft.irfft();
│ │ │ +
The first three arguments are as per numpy.fft.irfft();
│ │ │ the rest of the arguments are documented
│ │ │ in the module docs.
│ │ │
│ │ │
│ │ │
│ │ │ -
│ │ │
pyfftw.builders.rfft2(a, s=None, axes=(-2, -1), overwrite_input=False, planner_effort=None, threads=None, auto_align_input=True, auto_contiguous=True, avoid_copy=False, norm=None)
│ │ │ Return a pyfftw.FFTW object representing a 2D
│ │ │ real FFT.
│ │ │ -The first three arguments are as per numpy.fft.rfft2();
│ │ │ +
The first three arguments are as per numpy.fft.rfft2();
│ │ │ the rest of the arguments are documented
│ │ │ in the module docs.
│ │ │
│ │ │
│ │ │
│ │ │ -
│ │ │
pyfftw.builders.irfft2(a, s=None, axes=(-2, -1), planner_effort=None, threads=None, auto_align_input=True, auto_contiguous=True, avoid_copy=False, norm=None)
│ │ │ Return a pyfftw.FFTW object representing a 2D
│ │ │ real inverse FFT.
│ │ │ -The first three arguments are as per numpy.fft.irfft2();
│ │ │ +
The first three arguments are as per numpy.fft.irfft2();
│ │ │ the rest of the arguments are documented
│ │ │ in the module docs.
│ │ │
│ │ │
│ │ │
│ │ │ -
│ │ │
pyfftw.builders.rfftn(a, s=None, axes=None, overwrite_input=False, planner_effort=None, threads=None, auto_align_input=True, auto_contiguous=True, avoid_copy=False, norm=None)
│ │ │ Return a pyfftw.FFTW object representing an n-D
│ │ │ real FFT.
│ │ │ -The first three arguments are as per numpy.fft.rfftn();
│ │ │ +
The first three arguments are as per numpy.fft.rfftn();
│ │ │ the rest of the arguments are documented
│ │ │ in the module docs.
│ │ │
│ │ │
│ │ │
│ │ │ -
│ │ │
pyfftw.builders.irfftn(a, s=None, axes=None, planner_effort=None, threads=None, auto_align_input=True, auto_contiguous=True, avoid_copy=False, norm=None)
│ │ │ Return a pyfftw.FFTW object representing an n-D
│ │ │ real inverse FFT.
│ │ │ -The first three arguments are as per numpy.fft.rfftn();
│ │ │ +
The first three arguments are as per numpy.fft.rfftn();
│ │ │ the rest of the arguments are documented
│ │ │ in the module docs.
│ │ │
│ │ │
│ │ │
│ │ │
pyfftw.interfaces.dask_fft.fft(a, n=None, axis=None)
│ │ │ Wrapping of pyfftw.interfaces.numpy_fft.fft
│ │ │ The axis along which the FFT is applied must have a one chunk. To change
│ │ │ the array’s chunking use dask.Array.rechunk.
│ │ │ The pyfftw.interfaces.numpy_fft.fft docstring follows below:
│ │ │ Perform a 1D FFT.
│ │ │ -The first four arguments are as per numpy.fft.fft();
│ │ │ +
The first four arguments are as per numpy.fft.fft();
│ │ │ the rest of the arguments are documented
│ │ │ in the additional arguments docs.
│ │ │
│ │ │
│ │ │
│ │ │ -
│ │ │
pyfftw.interfaces.dask_fft.ifft(a, n=None, axis=None)
│ │ │ Wrapping of pyfftw.interfaces.numpy_fft.ifft
│ │ │ The axis along which the FFT is applied must have a one chunk. To change
│ │ │ the array’s chunking use dask.Array.rechunk.
│ │ │ The pyfftw.interfaces.numpy_fft.ifft docstring follows below:
│ │ │ Perform a 1D inverse FFT.
│ │ │ -The first four arguments are as per numpy.fft.ifft();
│ │ │ +
The first four arguments are as per numpy.fft.ifft();
│ │ │ the rest of the arguments are documented
│ │ │ in the additional arguments docs.
│ │ │
│ │ │
│ │ │
│ │ │ -
│ │ │
pyfftw.interfaces.dask_fft.fft2(a, s=None, axes=None)
│ │ │ Wrapping of pyfftw.interfaces.numpy_fft.fft2
│ │ │ The axis along which the FFT is applied must have a one chunk. To change
│ │ │ the array’s chunking use dask.Array.rechunk.
│ │ │ The pyfftw.interfaces.numpy_fft.fft2 docstring follows below:
│ │ │ Perform a 2D FFT.
│ │ │ -The first four arguments are as per numpy.fft.fft2();
│ │ │ +
The first four arguments are as per numpy.fft.fft2();
│ │ │ the rest of the arguments are documented
│ │ │ in the additional arguments docs.
│ │ │
│ │ │
│ │ │
│ │ │ -
│ │ │
pyfftw.interfaces.dask_fft.ifft2(a, s=None, axes=None)
│ │ │ Wrapping of pyfftw.interfaces.numpy_fft.ifft2
│ │ │ The axis along which the FFT is applied must have a one chunk. To change
│ │ │ the array’s chunking use dask.Array.rechunk.
│ │ │ The pyfftw.interfaces.numpy_fft.ifft2 docstring follows below:
│ │ │ Perform a 2D inverse FFT.
│ │ │ -The first four arguments are as per numpy.fft.ifft2();
│ │ │ +
The first four arguments are as per numpy.fft.ifft2();
│ │ │ the rest of the arguments are documented
│ │ │ in the additional arguments docs.
│ │ │
│ │ │
│ │ │
│ │ │ -
│ │ │
pyfftw.interfaces.dask_fft.fftn(a, s=None, axes=None)
│ │ │ Wrapping of pyfftw.interfaces.numpy_fft.fftn
│ │ │ The axis along which the FFT is applied must have a one chunk. To change
│ │ │ the array’s chunking use dask.Array.rechunk.
│ │ │ The pyfftw.interfaces.numpy_fft.fftn docstring follows below:
│ │ │ Perform an n-D FFT.
│ │ │ -The first four arguments are as per numpy.fft.fftn();
│ │ │ +
The first four arguments are as per numpy.fft.fftn();
│ │ │ the rest of the arguments are documented
│ │ │ in the additional arguments docs.
│ │ │
│ │ │
│ │ │
│ │ │ -
│ │ │
pyfftw.interfaces.dask_fft.ifftn(a, s=None, axes=None)
│ │ │ Wrapping of pyfftw.interfaces.numpy_fft.ifftn
│ │ │ The axis along which the FFT is applied must have a one chunk. To change
│ │ │ the array’s chunking use dask.Array.rechunk.
│ │ │ The pyfftw.interfaces.numpy_fft.ifftn docstring follows below:
│ │ │ Perform an n-D inverse FFT.
│ │ │ -The first four arguments are as per numpy.fft.ifftn();
│ │ │ +
The first four arguments are as per numpy.fft.ifftn();
│ │ │ the rest of the arguments are documented
│ │ │ in the additional arguments docs.
│ │ │
│ │ │
│ │ │
│ │ │ -
│ │ │
pyfftw.interfaces.dask_fft.rfft(a, n=None, axis=None)
│ │ │ Wrapping of pyfftw.interfaces.numpy_fft.rfft
│ │ │ The axis along which the FFT is applied must have a one chunk. To change
│ │ │ the array’s chunking use dask.Array.rechunk.
│ │ │ The pyfftw.interfaces.numpy_fft.rfft docstring follows below:
│ │ │ Perform a 1D real FFT.
│ │ │ -The first four arguments are as per numpy.fft.rfft();
│ │ │ +
The first four arguments are as per numpy.fft.rfft();
│ │ │ the rest of the arguments are documented
│ │ │ in the additional arguments docs.
│ │ │
│ │ │
│ │ │
│ │ │ -
│ │ │
pyfftw.interfaces.dask_fft.irfft(a, n=None, axis=None)
│ │ │ Wrapping of pyfftw.interfaces.numpy_fft.irfft
│ │ │ The axis along which the FFT is applied must have a one chunk. To change
│ │ │ the array’s chunking use dask.Array.rechunk.
│ │ │ The pyfftw.interfaces.numpy_fft.irfft docstring follows below:
│ │ │ Perform a 1D real inverse FFT.
│ │ │ -The first four arguments are as per numpy.fft.irfft();
│ │ │ +
The first four arguments are as per numpy.fft.irfft();
│ │ │ the rest of the arguments are documented
│ │ │ in the additional arguments docs.
│ │ │
│ │ │
│ │ │
│ │ │ -
│ │ │
pyfftw.interfaces.dask_fft.rfft2(a, s=None, axes=None)
│ │ │ Wrapping of pyfftw.interfaces.numpy_fft.rfft2
│ │ │ The axis along which the FFT is applied must have a one chunk. To change
│ │ │ the array’s chunking use dask.Array.rechunk.
│ │ │ The pyfftw.interfaces.numpy_fft.rfft2 docstring follows below:
│ │ │ Perform a 2D real FFT.
│ │ │ -The first four arguments are as per numpy.fft.rfft2();
│ │ │ +
The first four arguments are as per numpy.fft.rfft2();
│ │ │ the rest of the arguments are documented
│ │ │ in the additional arguments docs.
│ │ │
│ │ │
│ │ │
│ │ │ -
│ │ │
pyfftw.interfaces.dask_fft.irfft2(a, s=None, axes=None)
│ │ │ Wrapping of pyfftw.interfaces.numpy_fft.irfft2
│ │ │ The axis along which the FFT is applied must have a one chunk. To change
│ │ │ the array’s chunking use dask.Array.rechunk.
│ │ │ The pyfftw.interfaces.numpy_fft.irfft2 docstring follows below:
│ │ │ Perform a 2D real inverse FFT.
│ │ │ -The first four arguments are as per numpy.fft.irfft2();
│ │ │ +
The first four arguments are as per numpy.fft.irfft2();
│ │ │ the rest of the arguments are documented
│ │ │ in the additional arguments docs.
│ │ │
│ │ │
│ │ │
│ │ │ -
│ │ │
pyfftw.interfaces.dask_fft.rfftn(a, s=None, axes=None)
│ │ │ Wrapping of pyfftw.interfaces.numpy_fft.rfftn
│ │ │ The axis along which the FFT is applied must have a one chunk. To change
│ │ │ the array’s chunking use dask.Array.rechunk.
│ │ │ The pyfftw.interfaces.numpy_fft.rfftn docstring follows below:
│ │ │ Perform an n-D real FFT.
│ │ │ -The first four arguments are as per numpy.fft.rfftn();
│ │ │ +
The first four arguments are as per numpy.fft.rfftn();
│ │ │ the rest of the arguments are documented
│ │ │ in the additional arguments docs.
│ │ │
│ │ │
│ │ │
│ │ │ -
│ │ │
pyfftw.interfaces.dask_fft.irfftn(a, s=None, axes=None)
│ │ │ Wrapping of pyfftw.interfaces.numpy_fft.irfftn
│ │ │ The axis along which the FFT is applied must have a one chunk. To change
│ │ │ the array’s chunking use dask.Array.rechunk.
│ │ │ The pyfftw.interfaces.numpy_fft.irfftn docstring follows below:
│ │ │ Perform an n-D real inverse FFT.
│ │ │ -The first four arguments are as per numpy.fft.rfftn();
│ │ │ +
The first four arguments are as per numpy.fft.rfftn();
│ │ │ the rest of the arguments are documented
│ │ │ in the additional arguments docs.
│ │ │
│ │ │
│ │ │
│ │ │ -
│ │ │
pyfftw.interfaces.dask_fft.hfft(a, n=None, axis=None)
│ │ │ Wrapping of pyfftw.interfaces.numpy_fft.hfft
│ │ │ The axis along which the FFT is applied must have a one chunk. To change
│ │ │ the array’s chunking use dask.Array.rechunk.
│ │ │ The pyfftw.interfaces.numpy_fft.hfft docstring follows below:
│ │ │ Perform a 1D FFT of a signal with hermitian symmetry.
│ │ │ -This yields a real output spectrum. See numpy.fft.hfft()
│ │ │ +This yields a real output spectrum. See numpy.fft.hfft()
│ │ │ for more information.
│ │ │ -The first four arguments are as per numpy.fft.hfft();
│ │ │ +
The first four arguments are as per numpy.fft.hfft();
│ │ │ the rest of the arguments are documented
│ │ │ in the additional arguments docs.
│ │ │
│ │ │
│ │ │
│ │ │ -
│ │ │
pyfftw.interfaces.dask_fft.ihfft(a, n=None, axis=None)
│ │ │ Wrapping of pyfftw.interfaces.numpy_fft.ihfft
│ │ │ The axis along which the FFT is applied must have a one chunk. To change
│ │ │ the array’s chunking use dask.Array.rechunk.
│ │ │ The pyfftw.interfaces.numpy_fft.ihfft docstring follows below:
│ │ │ Perform a 1D inverse FFT of a real-spectrum, yielding
│ │ │ -a signal with hermitian symmetry. See numpy.fft.ihfft()
│ │ │ +a signal with hermitian symmetry. See numpy.fft.ihfft()
│ │ │ for more information.
│ │ │ -The first four arguments are as per numpy.fft.ihfft();
│ │ │ +
The first four arguments are as per numpy.fft.ihfft();
│ │ │ the rest of the arguments are documented
│ │ │ in the additional arguments docs.
│ │ │
│ │ │
│ │ │
│ │ ├── ./usr/share/doc/python-pyfftw-doc/html/source/pyfftw/interfaces/interfaces.html
│ │ │ @@ -48,15 +48,15 @@
│ │ │
│ │ │
│ │ │
pyfftw.interfaces - Drop in replacements for other FFT implementations
│ │ │
│ │ │
│ │ │
The pyfftw.interfaces package provides interfaces to pyfftw
│ │ │ that implement the API of other, more commonly used FFT libraries; specifically
│ │ │ -numpy.fft, scipy.fft and scipy.fftpack. The intention is
│ │ │ +numpy.fft, scipy.fft and scipy.fftpack. The intention is
│ │ │ to satisfy two clear use cases:
│ │ │
│ │ │ - Simple, clean and well established interfaces to using
pyfftw,
│ │ │ removing the requirement for users to know or understand about creating and
│ │ │ using pyfftw.FFTW objects, whilst still benefiting from most of the
│ │ │ speed benefits of FFTW.
│ │ │ - A library that can be dropped into code that is already written to
│ │ │ @@ -113,29 +113,29 @@
│ │ │
The usual wisdom import and export functions work well for the case where
│ │ │ the initial plan might be prohibitively expensive. Just use
│ │ │ pyfftw.export_wisdom() and pyfftw.import_wisdom() as needed after
│ │ │ having performed the transform once.
│ │ │
│ │ │
│ │ │
Additional Arguments
│ │ │ -
In addition to the equivalent arguments in numpy.fft, scipy.fft
│ │ │ -and scipy.fftpack, all these functions also add several additional
│ │ │ +
In addition to the equivalent arguments in numpy.fft, scipy.fft
│ │ │ +and scipy.fftpack, all these functions also add several additional
│ │ │ arguments for finer control over the FFT. These additional arguments are
│ │ │ largely a subset of the keyword arguments in pyfftw.builders with a few
│ │ │ exceptions and with different defaults.
│ │ │
│ │ │ overwrite_input: Whether or not the input array can be
│ │ │ overwritten during the transform. This sometimes results in a faster
│ │ │ algorithm being made available. It causes the 'FFTW_DESTROY_INPUT'
│ │ │ flag to be passed to the intermediate pyfftw.FFTW object.
│ │ │ Unlike with pyfftw.builders, this argument is included with
│ │ │ every function in this package.
│ │ │ In scipy_fftpack and
│ │ │ scipy_fft, this argument is replaced by
│ │ │ overwrite_x, to which it is equivalent (albeit at the same position).
│ │ │ -The default is False to be consistent with numpy.fft.
│ │ │ +The default is False to be consistent with numpy.fft.
│ │ │ planner_effort: A string dictating how much effort is spent
│ │ │ in planning the FFTW routines. This is passed to the creation
│ │ │ of the intermediate pyfftw.FFTW object as an entry
│ │ │ in the flags list. They correspond to flags passed to the
│ │ │ pyfftw.FFTW object.
│ │ │ The valid strings, in order of their increasing impact on the time
│ │ │ @@ -242,15 +242,15 @@
│ │ │ of time. For this reason, the default is to use 'FFTW_ESTIMATE', which
│ │ │ potentially results in a slightly suboptimal plan being used, but with
│ │ │ a substantially quicker first-time planner step.
│ │ │ threads: The number of threads used to perform the FFT.
│ │ │ In scipy_fft, this argument is replaced by
│ │ │ workers, which serves the same purpose, but is also compatible with the
│ │ │ -scipy.fft.set_workers() context manager.
│ │ │ +scipy.fft.set_workers() context manager.
│ │ │ The default is 1.
│ │ │ auto_align_input: Correctly byte align the input array for optimal
│ │ │ usage of vector instructions. This can lead to a substantial speedup.
│ │ │ This argument being True makes sure that the input array
│ │ │ is correctly aligned. It is possible to correctly byte align the array
│ │ │ prior to calling this function (using, for example,
│ │ │ @@ -301,15 +301,15 @@
│ │ │ Disable it by calling pyfftw.interfaces.cache.disable(). By default,
│ │ │ the cache is disabled.
│ │ │ Note that even with the cache enabled, there is a fixed overhead associated
│ │ │ with lookups. This means that for small transforms, the overhead may exceed
│ │ │ the transform. At this point, it’s worth looking at using pyfftw.FFTW
│ │ │ directly.
│ │ │ When the cache is enabled, the module spawns a new thread to keep track
│ │ │ -of the objects. If threading is not available, then the cache
│ │ │ +of the objects. If threading is not available, then the cache
│ │ │ is not available and trying to use it will raise an ImportError exception.
│ │ │ The actual implementation of the cache is liable to change, but the
│ │ │ documented API is stable.
│ │ │
│ │ │ -
│ │ │
pyfftw.interfaces.cache.enable()
│ │ │ Enable the cache.
│ │ ├── ./usr/share/doc/python-pyfftw-doc/html/source/pyfftw/interfaces/numpy_fft.html
│ │ │ @@ -44,161 +44,161 @@
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │ -
│ │ │ +
│ │ │
This module implements those functions that replace aspects of the
│ │ │ -numpy.fft module. This module provides the entire documented namespace
│ │ │ -of numpy.fft, but those functions that are not included here are imported
│ │ │ -directly from numpy.fft.
│ │ │ +
numpy.fft module. This module
provides the entire documented namespace
│ │ │ +of
numpy.fft, but those functions that are not included here are imported
│ │ │ +directly from
numpy.fft.
│ │ │
It is notable that unlike numpy.fftpack, these functions will generally
│ │ │ return an output array with the same precision as the input array, and the
│ │ │ transform that is chosen is chosen based on the precision of the input array.
│ │ │ That is, if the input array is 32-bit floating point, then the transform will
│ │ │ be 32-bit floating point and so will the returned array. Half precision input
│ │ │ will be converted to single precision. Otherwise, if any type conversion is
│ │ │ required, the default will be double precision. If pyFFTW was not built with
│ │ │ support for double precision, the default is long double precision. If that is not
│ │ │ available, it defaults to single precision.
│ │ │
One known caveat is that repeated axes are handled differently to
│ │ │ -numpy.fft; axes that are repeated in the axes argument are considered
│ │ │ -only once, as compared to numpy.fft in which repeated axes results in
│ │ │ +numpy.fft; axes that are repeated in the axes argument are considered
│ │ │ +only once, as compared to numpy.fft in which repeated axes results in
│ │ │ the DFT being taken along that axes as many times as the axis occurs.
│ │ │
The exceptions raised by each of these functions are mostly as per their
│ │ │ -equivalents in numpy.fft, though there are some corner cases in
│ │ │ +equivalents in numpy.fft, though there are some corner cases in
│ │ │ which this may not be true.
│ │ │
│ │ │ -
│ │ │
pyfftw.interfaces.numpy_fft.fft(a, n=None, axis=-1, norm=None, overwrite_input=False, planner_effort=None, threads=None, auto_align_input=True, auto_contiguous=True)
│ │ │ Perform a 1D FFT.
│ │ │ -The first four arguments are as per numpy.fft.fft();
│ │ │ +
The first four arguments are as per numpy.fft.fft();
│ │ │ the rest of the arguments are documented
│ │ │ in the additional arguments docs.
│ │ │
│ │ │
│ │ │
│ │ │ -
│ │ │
pyfftw.interfaces.numpy_fft.ifft(a, n=None, axis=-1, norm=None, overwrite_input=False, planner_effort=None, threads=None, auto_align_input=True, auto_contiguous=True)
│ │ │ Perform a 1D inverse FFT.
│ │ │ -The first four arguments are as per numpy.fft.ifft();
│ │ │ +
The first four arguments are as per numpy.fft.ifft();
│ │ │ the rest of the arguments are documented
│ │ │ in the additional arguments docs.
│ │ │
│ │ │
│ │ │
│ │ │ -
│ │ │
pyfftw.interfaces.numpy_fft.fft2(a, s=None, axes=(-2, -1), norm=None, overwrite_input=False, planner_effort=None, threads=None, auto_align_input=True, auto_contiguous=True)
│ │ │ Perform a 2D FFT.
│ │ │ -The first four arguments are as per numpy.fft.fft2();
│ │ │ +
The first four arguments are as per numpy.fft.fft2();
│ │ │ the rest of the arguments are documented
│ │ │ in the additional arguments docs.
│ │ │
│ │ │
│ │ │
│ │ │ -
│ │ │
pyfftw.interfaces.numpy_fft.ifft2(a, s=None, axes=(-2, -1), norm=None, overwrite_input=False, planner_effort=None, threads=None, auto_align_input=True, auto_contiguous=True)
│ │ │ Perform a 2D inverse FFT.
│ │ │ -The first four arguments are as per numpy.fft.ifft2();
│ │ │ +
The first four arguments are as per numpy.fft.ifft2();
│ │ │ the rest of the arguments are documented
│ │ │ in the additional arguments docs.
│ │ │
│ │ │
│ │ │
│ │ │ -
│ │ │
pyfftw.interfaces.numpy_fft.fftn(a, s=None, axes=None, norm=None, overwrite_input=False, planner_effort=None, threads=None, auto_align_input=True, auto_contiguous=True)
│ │ │ Perform an n-D FFT.
│ │ │ -The first four arguments are as per numpy.fft.fftn();
│ │ │ +
The first four arguments are as per numpy.fft.fftn();
│ │ │ the rest of the arguments are documented
│ │ │ in the additional arguments docs.
│ │ │
│ │ │
│ │ │
│ │ │ -
│ │ │
pyfftw.interfaces.numpy_fft.ifftn(a, s=None, axes=None, norm=None, overwrite_input=False, planner_effort=None, threads=None, auto_align_input=True, auto_contiguous=True)
│ │ │ Perform an n-D inverse FFT.
│ │ │ -The first four arguments are as per numpy.fft.ifftn();
│ │ │ +
The first four arguments are as per numpy.fft.ifftn();
│ │ │ the rest of the arguments are documented
│ │ │ in the additional arguments docs.
│ │ │
│ │ │
│ │ │
│ │ │ -
│ │ │
pyfftw.interfaces.numpy_fft.rfft(a, n=None, axis=-1, norm=None, overwrite_input=False, planner_effort=None, threads=None, auto_align_input=True, auto_contiguous=True)
│ │ │ Perform a 1D real FFT.
│ │ │ -The first four arguments are as per numpy.fft.rfft();
│ │ │ +
The first four arguments are as per numpy.fft.rfft();
│ │ │ the rest of the arguments are documented
│ │ │ in the additional arguments docs.
│ │ │
│ │ │
│ │ │
│ │ │ -
│ │ │
pyfftw.interfaces.numpy_fft.irfft(a, n=None, axis=-1, norm=None, overwrite_input=False, planner_effort=None, threads=None, auto_align_input=True, auto_contiguous=True)
│ │ │ Perform a 1D real inverse FFT.
│ │ │ -The first four arguments are as per numpy.fft.irfft();
│ │ │ +
The first four arguments are as per numpy.fft.irfft();
│ │ │ the rest of the arguments are documented
│ │ │ in the additional arguments docs.
│ │ │
│ │ │
│ │ │
│ │ │ -
│ │ │
pyfftw.interfaces.numpy_fft.rfft2(a, s=None, axes=(-2, -1), norm=None, overwrite_input=False, planner_effort=None, threads=None, auto_align_input=True, auto_contiguous=True)
│ │ │ Perform a 2D real FFT.
│ │ │ -The first four arguments are as per numpy.fft.rfft2();
│ │ │ +
The first four arguments are as per numpy.fft.rfft2();
│ │ │ the rest of the arguments are documented
│ │ │ in the additional arguments docs.
│ │ │
│ │ │
│ │ │
│ │ │ -
│ │ │
pyfftw.interfaces.numpy_fft.irfft2(a, s=None, axes=(-2, -1), norm=None, overwrite_input=False, planner_effort=None, threads=None, auto_align_input=True, auto_contiguous=True)
│ │ │ Perform a 2D real inverse FFT.
│ │ │ -The first four arguments are as per numpy.fft.irfft2();
│ │ │ +
The first four arguments are as per numpy.fft.irfft2();
│ │ │ the rest of the arguments are documented
│ │ │ in the additional arguments docs.
│ │ │
│ │ │
│ │ │
│ │ │ -
│ │ │
pyfftw.interfaces.numpy_fft.rfftn(a, s=None, axes=None, norm=None, overwrite_input=False, planner_effort=None, threads=None, auto_align_input=True, auto_contiguous=True)
│ │ │ Perform an n-D real FFT.
│ │ │ -The first four arguments are as per numpy.fft.rfftn();
│ │ │ +
The first four arguments are as per numpy.fft.rfftn();
│ │ │ the rest of the arguments are documented
│ │ │ in the additional arguments docs.
│ │ │
│ │ │
│ │ │
│ │ │ -
│ │ │
pyfftw.interfaces.numpy_fft.irfftn(a, s=None, axes=None, norm=None, overwrite_input=False, planner_effort=None, threads=None, auto_align_input=True, auto_contiguous=True)
│ │ │ Perform an n-D real inverse FFT.
│ │ │ -The first four arguments are as per numpy.fft.rfftn();
│ │ │ +
The first four arguments are as per numpy.fft.rfftn();
│ │ │ the rest of the arguments are documented
│ │ │ in the additional arguments docs.
│ │ │
│ │ │
│ │ │
│ │ │ -
│ │ │
pyfftw.interfaces.numpy_fft.hfft(a, n=None, axis=-1, norm=None, overwrite_input=False, planner_effort=None, threads=None, auto_align_input=True, auto_contiguous=True)
│ │ │ Perform a 1D FFT of a signal with hermitian symmetry.
│ │ │ -This yields a real output spectrum. See numpy.fft.hfft()
│ │ │ +This yields a real output spectrum. See numpy.fft.hfft()
│ │ │ for more information.
│ │ │ -The first four arguments are as per numpy.fft.hfft();
│ │ │ +
The first four arguments are as per numpy.fft.hfft();
│ │ │ the rest of the arguments are documented
│ │ │ in the additional arguments docs.
│ │ │
│ │ │
│ │ │
│ │ │ -
│ │ │
pyfftw.interfaces.numpy_fft.ihfft(a, n=None, axis=-1, norm=None, overwrite_input=False, planner_effort=None, threads=None, auto_align_input=True, auto_contiguous=True)
│ │ │ Perform a 1D inverse FFT of a real-spectrum, yielding
│ │ │ -a signal with hermitian symmetry. See numpy.fft.ihfft()
│ │ │ +a signal with hermitian symmetry. See numpy.fft.ihfft()
│ │ │ for more information.
│ │ │ -The first four arguments are as per numpy.fft.ihfft();
│ │ │ +
The first four arguments are as per numpy.fft.ihfft();
│ │ │ the rest of the arguments are documented
│ │ │ in the additional arguments docs.
│ │ │
│ │ │
│ │ │
│ │ ├── ./usr/share/doc/python-pyfftw-doc/html/source/pyfftw/interfaces/scipy_fft.html
│ │ │ @@ -44,15 +44,15 @@
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │