Python interface¶
Quick-start examples¶
The easiest way to install is to run:
pip install finufft
which downloads and installs the latest precompiled binaries from PyPI.
If you would like to compile from source, you can tell pip
to compile the library from source with the option --no-binary
using the command:
pip install --no-binary finufft finufft
By default, this will use the -march=native
flag when compiling the library, which should result in improved performance.
Note that finufft
has to be specified twice (first as an argument to --no-binary
and second as the package the is to be installed). This option also allows you to switch out the default FFT library (FFTW) for DUCC0 using:
pip install --no-binary finufft finufft --config-settings=cmake.define.FINUFFT_USE_DUCC0=ON finufft
If you have pytest
installed, you can test it with:
pytest python/finufft/test
or, without having pytest
you can run the older-style eyeball check:
python3 python/finufft/test/run_accuracy_tests.py
which should report errors around 1e-6
and throughputs around 1-10 million points/sec.
(Please note that the finufftpy
package is obsolete.)
If you would like to compile from source, see the Python installation instructions.
Once installed, to calculate a 1D type 1 transform from nonuniform to uniform points, we import finufft
, specify the nonuniform points x
, their strengths c
, and call nufft1d1
:
import numpy as np
import finufft
# number of nonuniform points
M = 100000
# the nonuniform points
x = 2 * np.pi * np.random.uniform(size=M)
# their complex strengths
c = (np.random.standard_normal(size=M)
+ 1J * np.random.standard_normal(size=M))
# desired number of Fourier modes (uniform outputs)
N = 200000
# calculate the transform
f = finufft.nufft1d1(x, c, N)
The input here is a set of complex strengths c
, which are used to approximate (1) in Mathematical definitions of transforms.
That approximation is stored in f
, which is indexed from -N // 2
up to N // 2 - 1
(since N
is even; if odd it would be -(N - 1) // 2
up to (N - 1) // 2
).
The approximation is accurate to a tolerance of 1e-6
, which is the default tolerance of nufft1d1
.
It can be modified using the eps
argument:
# calculate the transform to higher accuracy
f = finufft.nufft1d1(x, c, N, eps=1e-12)
Note, however, that a lower tolerance (that is, a higher accuracy) results in a slower transform. See python/finufft/examples/simple1d1.py
for the demo code that includes a basic math test (useful to check both the math and the indexing).
For higher dimensions, we would specify point locations in more than one dimension:
# 2D nonuniform points (x,y coords)
x = 2 * np.pi * np.random.uniform(size=M)
y = 2 * np.pi * np.random.uniform(size=M)
# desired number of Fourier modes (in x, y directions respectively)
N1 = 1000
N2 = 2000
# the 2D transform outputs f array of shape (N1, N2)
f = finufft.nufft2d1(x, y, c, (N1, N2))
See python/finufft/examples/simple2d1.py
for the demo code that includes a basic math test (useful to check both the math and the indexing).
We can also go the other way, from uniform to non-uniform points, using a type 2 transform:
# input Fourier coefficients
f = (np.random.standard_normal(size=(N1, N2))
+ 1J * np.random.standard_normal(size=(N1, N2)))
# calculate the 2D type 2 transform
c = finufft.nufft2d2(x, y, f)
Now the output is a complex vector of length M
approximating (2) in Mathematical definitions of transforms, that is the adjoint (but not inverse) of (1). (Note that the default sign in the exponential is negative for type 2 in the Python interface.)
In addition to tolerance eps
, we can adjust other options for the transform.
These are listed in Options parameters (CPU) and are specified as keyword arguments in the Python interface.
For example, to change the mode ordering to FFT style (that is, in each dimension Ni = N1
or N2
, the indices go from 0
to Ni // 2 - 1
, then from -Ni // 2
to -1
, since each Ni
is even), we call
f = finufft.nufft2d1(x, y, c, (N1, N2), modeord=1)
We can also specify a preallocated output array using the out
keyword argument.
This would be done by
# allocate the output array
f = np.empty((N1, N2), dtype='complex128')
# calculate the transform
finufft.nufft2d1(x, y, c, out=f)
In this case, we do not need to specify the output shape since it can be inferred from f
.
Note that the above functions are all vectorized, which means that they can take multiple inputs stacked along the first dimension (that is, in row-major order) and process them simultaneously. This can bring significant speedups for small inputs by avoiding multiple short calls to FINUFFT. For the 2D type 1 vectorized interface, we would call
# number of transforms
K = 4
# generate K stacked coefficient arrays
c = (np.random.standard_normal(size=(K, M))
+ 1J * np.random.standard_normal(size=(K, M)))
# calculate the K transforms simultaneously (K is inferred from c.shape)
f = finufft.nufft2d1(x, y, c, (N1, N2))
The output array f
would then have the shape (K, N1, N2)
.
See the complete demo in python/finufft/examples/many2d1.py
.
More fine-grained control can be obtained using the plan (or guru) interface. Instead of preparing the transform, setting the nonuniform points, and executing the transform all at once, these steps are seperated into different function calls. This can speed up calculations if multiple transforms are executed for the same grid size, since the same FFTW plan can be reused between calls. Additionally, if the same nonuniform points are reused between calls, we gain an extra speedup since the points only have to be sorted once. To perform the call above using the plan interface, we would write
# specify type 1 transform
nufft_type = 1
# instantiate the plan (note ntrans must be set here)
plan = finufft.Plan(nufft_type, (N1, N2), n_trans=K)
# set the nonuniform points
plan.setpts(x, y)
# execute the plan
f = plan.execute(c)
See the complete demo in python/finufft/examples/guru2d1.py
.
All interfaces support both single and double precision, but for the plan, this must be specified at initialization time using the dtype
argument
# convert input data to single precision
x = x.astype('float32')
y = y.astype('float32')
c = c.astype('complex64')
# instantiate the plan and set the points
plan = finufft.Plan(nufft_type, (N1, N2), n_trans=K, dtype='complex64')
plan.setpts(x, y)
# execute the plan, giving single-precision output
f = plan.execute(c)
See the complete demo, with math test, in python/finufft/examples/guru2d1f.py
.
Full documentation¶
The Python interface to FINUFFT is divided into two parts: the simple
interface (through the nufft*
functions) and the more advanced plan
interface (through the Plan
class). The former allows the user to perform
an NUFFT in a single call while the latter allows for more efficient reuse of
resources when the same NUFFT is applied several times to different data by
saving FFTW plans, sorting the nonuniform points, and so on.
- finufft.nufft1d1(x, c, n_modes=None, out=None, eps=1e-06, isign=1, **kwargs)¶
1D type-1 (nonuniform to uniform) complex NUFFT
M-1 f[k1] = SUM c[j] exp(+/-i k1 x(j)) j=0 for -N1/2 <= k1 <= (N1-1)/2
Args:
- x(float[M]): nonuniform points, in [-pi, pi), values outside will be folded
c (complex[M] or complex[n_tr, M]): source strengths. n_modes (integer or integer tuple of length 1, optional): number of
uniform Fourier modes requested (N1, ). May be even or odd; in either case, modes k1 are integers satisfying -N1/2 <= k1 <= (N1-1)/2. Must be specified if
out
is not given.- out (complex[N1] or complex[n_tr, N1], optional): output array
for Fourier mode values. If
n_modes
is specifed, the shape must match, otherwisen_modes
is inferred fromout
.
eps (float, optional): precision requested (>1e-16). isign (int, optional): if non-negative, uses positive sign in
exponential, otherwise negative sign.
**kwargs (optional): for more options, see Options parameters (CPU).
Note
The output is written into the
out
array if supplied.- Returns:
complex[N1] or complex[n_tr, N1]: The resulting array.
Example:
import numpy as np import finufft # number of nonuniform points M = 100 # the nonuniform points
x = 2 * np.pi * np.random.uniform(size=M)
# their complex strengths c = (np.random.standard_normal(size=M)
1J * np.random.standard_normal(size=M))
# desired number of Fourier modes N1 = 50
# calculate the type-1 NUFFT f = finufft.nufft1d1(x, c, (N1, ))
See also
python/finufft/examples/simple1d1.py, python/finufft/examples/simpleopts1d1.py
.
- finufft.nufft1d2(x, f, out=None, eps=1e-06, isign=-1, **kwargs)¶
1D type-2 (uniform to nonuniform) complex NUFFT
c[j] = SUM f[k1] exp(+/-i k1 x(j)) k1 for j = 0, ..., M-1, where the sum is over -N1/2 <= k1 <= (N1-1)/2
Args:
- x(float[M]): nonuniform points, in [-pi, pi), values outside will be folded
- f (complex[N1] or complex[n_tr, N1]): Fourier mode
coefficients, where N1 may be even or odd. In either case the mode indices k1 satisfy -N1/2 <= k1 <= (N1-1)/2.
- out (complex[M] or complex[n_tr, M], optional): output array
at targets.
eps (float, optional): precision requested (>1e-16). isign (int, optional): if non-negative, uses positive sign in
exponential, otherwise negative sign.
**kwargs (optional): for more options, see Options parameters (CPU).
Note
The output is written into the
out
array if supplied.- Returns:
complex[M] or complex[n_tr, M]: The resulting array.
Example:
import numpy as np import finufft # number of nonuniform points M = 100 # the nonuniform points
x = 2 * np.pi * np.random.uniform(size=M)
# number of Fourier modes N1 = 50
# the Fourier mode coefficients f = (np.random.standard_normal(size=(N1, ))
1J * np.random.standard_normal(size=(N1, )))
# calculate the type-2 NUFFT c = finufft.nufft1d2(x, f)
See also
python/finufft/test/accuracy_speed_tests.py
.
- finufft.nufft1d3(x, c, s, out=None, eps=1e-06, isign=1, **kwargs)¶
1D type-3 (nonuniform to nonuniform) complex NUFFT
M-1 f[k] = SUM c[j] exp(+/-i s[k] x[j]), j=0 for k = 0, ..., N-1
Args:
- x(float[M]): nonuniform points, valid in [-pi, pi), values outside will be
folded c (complex[M] or complex[n_tr, M]): source strengths.
- s(float[N]): nonuniform target points.
- out (complex[N] or complex[n_tr, N]): output values at target
frequencies.
eps (float, optional): precision requested (>1e-16). isign (int, optional): if non-negative, uses positive sign in
exponential, otherwise negative sign.
**kwargs (optional): for more options, see Options parameters (CPU).
Note
The output is written into the
out
array if supplied.- Returns:
complex[M] or complex[n_tr, M]: The resulting array.
Example:
import numpy as np import finufft # number of source points M = 100 # number of target points N = 200 # the source points
x = 2 * np.pi * np.random.uniform(size=M)
# the target points
s = 2 * np.pi * np.random.uniform(size=N)
# their complex strengths c = (np.random.standard_normal(size=M)
1J * np.random.standard_normal(size=M))
# calcuate the type-3 NUFFT f = finufft.nufft1d3(x, c, s)
See also
python/finufft/test/accuracy_speed_tests.py
.
- finufft.nufft2d1(x, y, c, n_modes=None, out=None, eps=1e-06, isign=1, **kwargs)¶
2D type-1 (nonuniform to uniform) complex NUFFT
M-1 f[k1, k2] = SUM c[j] exp(+/-i (k1 x(j) + k2 y(j))) j=0 for -N1/2 <= k1 <= (N1-1)/2, -N2/2 <= k2 <= (N2-1)/2
Args:
x(float[M]): nonuniform points, in [-pi, pi), values outside will be folded y(float[M]): nonuniform points, in [-pi, pi), values outside will be folded
c (complex[M] or complex[n_tr, M]): source strengths. n_modes (integer or integer tuple of length 2, optional): number of
uniform Fourier modes requested (N1, N2). May be even or odd; in either case, modes k1, k2 are integers satisfying -N1/2 <= k1 <= (N1-1)/2, -N2/2 <= k2 <= (N2-1)/2. Must be specified if
out
is not given.- out (complex[N1, N2] or complex[n_tr, N1, N2], optional): output
array for Fourier mode values. If
n_modes
is specifed, the shape must match, otherwisen_modes
is inferred fromout
.
eps (float, optional): precision requested (>1e-16). isign (int, optional): if non-negative, uses positive sign in
exponential, otherwise negative sign.
**kwargs (optional): for more options, see Options parameters (CPU).
Note
The output is written into the
out
array if supplied.- Returns:
complex[N1, N2] or complex[n_tr, N1, N2]: The resulting array.
Example:
import numpy as np import finufft # number of nonuniform points M = 100 # the nonuniform points
x = 2 * np.pi * np.random.uniform(size=M) y = 2 * np.pi * np.random.uniform(size=M)
# their complex strengths c = (np.random.standard_normal(size=M)
1J * np.random.standard_normal(size=M))
# desired number of Fourier modes N1, N2 = 50, 75
# calculate the type-1 NUFFT f = finufft.nufft2d1(x, y, c, (N1, N2))
See also
python/finufft/examples/simple2d1.py, python/finufft/examples/many2d1.py
.
- finufft.nufft2d2(x, y, f, out=None, eps=1e-06, isign=-1, **kwargs)¶
2D type-2 (uniform to nonuniform) complex NUFFT
c[j] = SUM f[k1, k2] exp(+/-i (k1 x(j) + k2 y(j))) k1, k2 for j = 0, ..., M-1, where the sum is over -N1/2 <= k1 <= (N1-1)/2, -N2/2 <= k2 <= (N2-1)/2
Args:
x(float[M]): nonuniform points, in [-pi, pi), values outside will be folded y(float[M]): nonuniform points, in [-pi, pi), values outside will be folded
- f (complex[N1, N2] or complex[n_tr, N1, N2]): Fourier mode
coefficients, where N1, N2 may be even or odd. In either case the mode indices k1, k2 satisfy -N1/2 <= k1 <= (N1-1)/2, -N2/2 <= k2 <= (N2-1)/2.
- out (complex[M] or complex[n_tr, M], optional): output array
at targets.
eps (float, optional): precision requested (>1e-16). isign (int, optional): if non-negative, uses positive sign in
exponential, otherwise negative sign.
**kwargs (optional): for more options, see Options parameters (CPU).
Note
The output is written into the
out
array if supplied.- Returns:
complex[M] or complex[n_tr, M]: The resulting array.
Example:
import numpy as np import finufft # number of nonuniform points M = 100 # the nonuniform points
x = 2 * np.pi * np.random.uniform(size=M) y = 2 * np.pi * np.random.uniform(size=M)
# number of Fourier modes N1, N2 = 50, 75
# the Fourier mode coefficients f = (np.random.standard_normal(size=(N1, N2))
1J * np.random.standard_normal(size=(N1, N2)))
# calculate the type-2 NUFFT c = finufft.nufft2d2(x, y, f)
See also
python/finufft/test/accuracy_speed_tests.py
.
- finufft.nufft2d3(x, y, c, s, t, out=None, eps=1e-06, isign=1, **kwargs)¶
2D type-3 (nonuniform to nonuniform) complex NUFFT
M-1 f[k] = SUM c[j] exp(+/-i (s[k] x[j] + t[k] y[j])), j=0 for k = 0, ..., N-1
Args:
- x(float[M]): nonuniform points, valid in [-pi, pi), values outside will be
folded
- y(float[M]): nonuniform points, valid in [-pi, pi), values outside will be
folded c (complex[M] or complex[n_tr, M]): source strengths.
s(float[N]): nonuniform target points. t(float[N]): nonuniform target points.
- out (complex[N] or complex[n_tr, N]): output values at target
frequencies.
eps (float, optional): precision requested (>1e-16). isign (int, optional): if non-negative, uses positive sign in
exponential, otherwise negative sign.
**kwargs (optional): for more options, see Options parameters (CPU).
Note
The output is written into the
out
array if supplied.- Returns:
complex[M] or complex[n_tr, M]: The resulting array.
Example:
import numpy as np import finufft # number of source points M = 100 # number of target points N = 200 # the source points
x = 2 * np.pi * np.random.uniform(size=M) y = 2 * np.pi * np.random.uniform(size=M)
# the target points
s = 2 * np.pi * np.random.uniform(size=N) t = 2 * np.pi * np.random.uniform(size=N)
# their complex strengths c = (np.random.standard_normal(size=M)
1J * np.random.standard_normal(size=M))
# calcuate the type-3 NUFFT f = finufft.nufft2d3(x, y, c, s, t)
See also
python/finufft/test/accuracy_speed_tests.py
.
- finufft.nufft3d1(x, y, z, c, n_modes=None, out=None, eps=1e-06, isign=1, **kwargs)¶
3D type-1 (nonuniform to uniform) complex NUFFT
M-1 f[k1, k2, k3] = SUM c[j] exp(+/-i (k1 x(j) + k2 y(j) + k3 z(j))) j=0 for -N1/2 <= k1 <= (N1-1)/2, -N2/2 <= k2 <= (N2-1)/2, -N3/2 <= k3 <= (N3-1)/2
Args:
x(float[M]): nonuniform points, in [-pi, pi), values outside will be folded y(float[M]): nonuniform points, in [-pi, pi), values outside will be folded z(float[M]): nonuniform points, in [-pi, pi), values outside will be folded
c (complex[M] or complex[n_tr, M]): source strengths. n_modes (integer or integer tuple of length 3, optional): number of
uniform Fourier modes requested (N1, N2, N3). May be even or odd; in either case, modes k1, k2, k3 are integers satisfying -N1/2 <= k1 <= (N1-1)/2, -N2/2 <= k2 <= (N2-1)/2, -N3/2 <= k3 <= (N3-1)/2. Must be specified if
out
is not given.- out (complex[N1, N2, N3] or complex[n_tr, N1, N2, N3], optional):
output array for Fourier mode values. If
n_modes
is specifed, the shape must match, otherwisen_modes
is inferred fromout
.
eps (float, optional): precision requested (>1e-16). isign (int, optional): if non-negative, uses positive sign in
exponential, otherwise negative sign.
**kwargs (optional): for more options, see Options parameters (CPU).
Note
The output is written into the
out
array if supplied.- Returns:
complex[N1, N2, N3] or complex[n_tr, N1, N2, N3]: The resulting array.
Example:
import numpy as np import finufft # number of nonuniform points M = 100 # the nonuniform points
x = 2 * np.pi * np.random.uniform(size=M) y = 2 * np.pi * np.random.uniform(size=M) z = 2 * np.pi * np.random.uniform(size=M)
# their complex strengths c = (np.random.standard_normal(size=M)
1J * np.random.standard_normal(size=M))
# desired number of Fourier modes N1, N2, N3 = 50, 75, 100
# calculate the type-1 NUFFT f = finufft.nufft3d1(x, y, z, c, (N1, N2, N3))
See also
python/finufft/test/accuracy_speed_tests.py
.
- finufft.nufft3d2(x, y, z, f, out=None, eps=1e-06, isign=-1, **kwargs)¶
3D type-2 (uniform to nonuniform) complex NUFFT
c[j] = SUM f[k1, k2, k3] exp(+/-i (k1 x(j) + k2 y(j) + k3 z(j))) k1, k2, k3 for j = 0, ..., M-1, where the sum is over -N1/2 <= k1 <= (N1-1)/2, -N2/2 <= k2 <= (N2-1)/2, -N3/2 <= k3 <= (N3-1)/2
Args:
x(float[M]): nonuniform points, in [-pi, pi), values outside will be folded y(float[M]): nonuniform points, in [-pi, pi), values outside will be folded z(float[M]): nonuniform points, in [-pi, pi), values outside will be folded
- f (complex[N1, N2, N3] or complex[n_tr, N1, N2, N3]): Fourier mode
coefficients, where N1, N2, N3 may be even or odd. In either case the mode indices k1, k2, k3 satisfy -N1/2 <= k1 <= (N1-1)/2, -N2/2 <= k2 <= (N2-1)/2, -N3/2 <= k3 <= (N3-1)/2.
- out (complex[M] or complex[n_tr, M], optional): output array
at targets.
eps (float, optional): precision requested (>1e-16). isign (int, optional): if non-negative, uses positive sign in
exponential, otherwise negative sign.
**kwargs (optional): for more options, see Options parameters (CPU).
Note
The output is written into the
out
array if supplied.- Returns:
complex[M] or complex[n_tr, M]: The resulting array.
Example:
import numpy as np import finufft # number of nonuniform points M = 100 # the nonuniform points
x = 2 * np.pi * np.random.uniform(size=M) y = 2 * np.pi * np.random.uniform(size=M) z = 2 * np.pi * np.random.uniform(size=M)
# number of Fourier modes N1, N2, N3 = 50, 75, 100
# the Fourier mode coefficients f = (np.random.standard_normal(size=(N1, N2, N3))
1J * np.random.standard_normal(size=(N1, N2, N3)))
# calculate the type-2 NUFFT c = finufft.nufft3d2(x, y, z, f)
See also
python/finufft/test/accuracy_speed_tests.py
.
- finufft.nufft3d3(x, y, z, c, s, t, u, out=None, eps=1e-06, isign=1, **kwargs)¶
3D type-3 (nonuniform to nonuniform) complex NUFFT
M-1 f[k] = SUM c[j] exp(+/-i (s[k] x[j] + t[k] y[j] + u[k] z[j])), j=0 for k = 0, ..., N-1
Args:
- x(float[M]): nonuniform points, valid in [-pi, pi), values outside will be
folded
- y(float[M]): nonuniform points, valid in [-pi, pi), values outside will be
folded
- z(float[M]): nonuniform points, valid in [-pi, pi), values outside will be
folded c (complex[M] or complex[n_tr, M]): source strengths.
s(float[N]): nonuniform target points. t(float[N]): nonuniform target points. u(float[N]): nonuniform target points.
- out (complex[N] or complex[n_tr, N]): output values at target
frequencies.
eps (float, optional): precision requested (>1e-16). isign (int, optional): if non-negative, uses positive sign in
exponential, otherwise negative sign.
**kwargs (optional): for more options, see Options parameters (CPU).
Note
The output is written into the
out
array if supplied.- Returns:
complex[M] or complex[n_tr, M]: The resulting array.
Example:
import numpy as np import finufft # number of source points M = 100 # number of target points N = 200 # the source points
x = 2 * np.pi * np.random.uniform(size=M) y = 2 * np.pi * np.random.uniform(size=M) z = 2 * np.pi * np.random.uniform(size=M)
# the target points
s = 2 * np.pi * np.random.uniform(size=N) t = 2 * np.pi * np.random.uniform(size=N) u = 2 * np.pi * np.random.uniform(size=N)
# their complex strengths c = (np.random.standard_normal(size=M)
1J * np.random.standard_normal(size=M))
# calcuate the type-3 NUFFT f = finufft.nufft3d3(x, y, z, c, s, t, u)
See also
python/finufft/test/accuracy_speed_tests.py
.
- class finufft.Plan(nufft_type, n_modes_or_dim, n_trans=1, eps=1e-06, isign=None, dtype='complex128', **kwargs)¶
A non-uniform fast Fourier transform (NUFFT) plan
The
Plan
class lets the user exercise more fine-grained control over the execution of an NUFFT. First, the plan is created with a certain set of parameters (type, mode configuration, tolerance, sign, number of simultaneous transforms, and so on). Then the nonuniform points are set (source or target depending on the type). Finally, the plan is executed on some data, yielding the desired output.In the simple interface, all these steps are executed in a single call to the
nufft*
functions. The benefit of separating plan creation from execution is that it allows for plan reuse when certain parameters (like mode configuration) or nonuniform points remain the same between different NUFFT calls. This becomes especially important for small inputs, where execution time may be dominated by initialization steps such as allocating and FFTW plan and sorting the nonuniform points.Example:
import numpy as np import finufft # set up parameters n_modes = (1000, 2000) n_pts = 100000 nufft_type = 1 n_trans = 4 # generate nonuniform points x = 2 * np.pi * np.random.uniform(size=n_pts) y = 2 * np.pi * np.random.uniform(size=n_pts) # generate source strengths c = (np.random.standard_normal(size=(n_trans, n_pts)) + 1J * np.random.standard_normal(size=(n_trans, n_pts))) # initialize the plan plan = finufft.Plan(nufft_type, n_modes, n_trans) # set the nonuniform points plan.setpts(x, y) # execute the plan f = plan.execute(c)
Also see
python/finufft/examples/guru1d1.py
andpython/finufft/examples/guru2d1.py
.- Parameters:
nufft_type (int) – type of NUFFT (1, 2, or 3).
n_modes_or_dim (int or tuple of ints) – for type 1 and type 2, this should be a tuple specifying the number of modes in each dimension (for example,
(50, 100)
), otherwise, for type 3, this should be the number of dimensions (between 1 and 3).n_trans (int, optional) – number of transforms to compute simultaneously.
eps (float, optional) – precision requested (>1e-16).
isign (int, optional) – if +1, uses the positive sign exponential, otherwise the negative sign exponential; defaults to +1 for types 1 and 3 and to -1 for type 2.
dtype (string, optional) – the precision of the transform,
'complex64'
or'complex128'
.**kwargs (optional) – for more options, see Options parameters (CPU).
- setpts(x=None, y=None, z=None, s=None, t=None, u=None)¶
Set the nonuniform points
For type 1, this sets the coordinates of the
M
nonuniform source points, for type 2, it sets the coordinates of theM
target points, and for type 3 it sets both theM
source points and theN
target points.The dimension of the plan determines the number of arguments supplied. For example, if
dim == 2
, we providex
andy
(as well ass
andt
for a type-3 transform).- Parameters:
x (float[M]) – first coordinate of the nonuniform points (source for type 1 and 3, target for type 2).
y (float[M], optional) – second coordinate of the nonuniform points (source for type 1 and 3, target for type 2).
z (float[M], optional) – third coordinate of the nonuniform points (source for type 1 and 3, target for type 2).
s (float[N], optional) – first coordinate of the nonuniform points (target for type 3).
t (float[N], optional) – second coordinate of the nonuniform points (target for type 3).
u (float[N], optional) – third coordinate of the nonuniform points (target for type 3).
- execute(data, out=None)¶
Execute the plan
Performs the NUFFT specified at plan instantiation with the points set by
setpts
. For type-1 and type-3 transforms, the input is a set of source strengths, while for a type-2 transform, it consists of an array of sizen_modes
. Ifn_trans
is greater than one,n_trans
inputs are expected, stacked along the first axis.- Parameters:
data (complex[M], complex[n_tr, M], complex[n_modes], or complex[n_tr, n_modes]) – The input source strengths (type 1 and 3) or source modes (type 2).
out (complex[n_modes], complex[n_tr, n_modes], complex[M], or complex[n_tr, M], optional) – The array where the output is stored. Must be of the right size.
- Returns:
The output array of the transform(s).
- Return type:
complex[n_modes], complex[n_tr, n_modes], complex[M], or complex[n_tr, M]