# mpi4py_fft.fftw package

## Submodules

## mpi4py_fft.fftw.fftw_xfftn module

class mpi4py_fft.fftw.fftw_xfftn.FFT

  Bases: `object`

  Unified class for FFTs of multidimensional arrays

  This class is used for any type of transform defined in the user manual of FFTW.

  Parameters:

    - input_array (array) – real or complex input array

    - output_array (array) – real or complex output array

    - axes (sequence of ints, optional) – The axes to transform over, starting from the last

    - kind (int or sequence of ints, optional) –

      Any one of

      > - FFTW_FORWARD (-1)

      > - FFTW_R2HC (0)

      > - FFTW_BACKWARD (1)

      > - FFTW_HC2R (1)

      > - FFTW_DHT (2)

      > - FFTW_REDFT00 (3)

      > - FFTW_REDFT01 (4)

      > - FFTW_REDFT10 (5)

      > - FFTW_REDFT11 (6)

      > - FFTW_RODFT00 (7)

      > - FFTW_RODFT01 (8)

      > - FFTW_RODFT10 (9)

      > - FFTW_RODFT11 (10)

    - threads (int, optional) – Number of threads to use in transforms

    - flags (int or sequence of ints, optional) –

      Any one of, but not necessarily for all transforms or all combinations

      > - FFTW_MEASURE (0)

      > - FFTW_DESTROY_INPUT (1)

      > - FFTW_UNALIGNED (2)

      > - FFTW_CONSERVE_MEMORY (4)

      > - FFTW_EXHAUSTIVE (8)

      > - FFTW_PRESERVE_INPUT (16)

      > - FFTW_PATIENT (32)

      > - FFTW_ESTIMATE (64)

      > - FFTW_WISDOM_ONLY (2097152)

    - normalization (float, optional) – Normalization factor

  __call__()

    Signature:

        __call__(input_array=None, output_array=None, implicit=True, normalize=False, **kw)

    Compute transform and return output array

    Parameters:

      - input_array (array, optional) – If not provided, then use internally stored array

      - output_array (array, optional) – If not provided, then use internally stored array

      - implicit (bool, optional) – If True, then use an implicit method that acts by applying the plan directly on the given input array. If False, then use an explicit method that first copies the given input_array into the internal _input_array. The explicit method is generally safer, because it always preserves the provided input_array. The implicit method can be faster because it may be done without any copying. However, the contents of the input_array may be destroyed during computation. So use with care!

      - normalize (bool, optional) – If True, normalize transform with internally stored normalization factor. The internally set normalization factor is possible to obtain through `FFT.get_normalization()`

      - kw (dict, optional)

    Note

    If the transform has been planned with FFTW_PRESERVE_INPUT, then both the two methods (implicit=True/False) will preserve the provided input_array. If not planned with this flag, then the implicit=True method may cause the input_array to be overwritten during computation.

  destroy()
  get_normalization()

    Return the internally set normalization factor

  input_array
  output_array
  print_plan()
  update_arrays(input_array, output_array)

mpi4py_fft.fftw.fftw_xfftn.alignment_of(input_array)

mpi4py_fft.fftw.fftw_xfftn.cleanup()

mpi4py_fft.fftw.fftw_xfftn.export_wisdom(filename)

mpi4py_fft.fftw.fftw_xfftn.forget_wisdom()

mpi4py_fft.fftw.fftw_xfftn.import_wisdom(filename)

mpi4py_fft.fftw.fftw_xfftn.set_timelimit(limit)

## mpi4py_fft.fftw.fftwf_xfftn module

class mpi4py_fft.fftw.fftwf_xfftn.FFT

  Bases: `object`

  Unified class for FFTs of multidimensional arrays

  This class is used for any type of transform defined in the user manual of FFTW.

  Parameters:

    - input_array (array) – real or complex input array

    - output_array (array) – real or complex output array

    - axes (sequence of ints, optional) – The axes to transform over, starting from the last

    - kind (int or sequence of ints, optional) –

      Any one of

      > - FFTW_FORWARD (-1)

      > - FFTW_R2HC (0)

      > - FFTW_BACKWARD (1)

      > - FFTW_HC2R (1)

      > - FFTW_DHT (2)

      > - FFTW_REDFT00 (3)

      > - FFTW_REDFT01 (4)

      > - FFTW_REDFT10 (5)

      > - FFTW_REDFT11 (6)

      > - FFTW_RODFT00 (7)

      > - FFTW_RODFT01 (8)

      > - FFTW_RODFT10 (9)

      > - FFTW_RODFT11 (10)

    - threads (int, optional) – Number of threads to use in transforms

    - flags (int or sequence of ints, optional) –

      Any one of, but not necessarily for all transforms or all combinations

      > - FFTW_MEASURE (0)

      > - FFTW_DESTROY_INPUT (1)

      > - FFTW_UNALIGNED (2)

      > - FFTW_CONSERVE_MEMORY (4)

      > - FFTW_EXHAUSTIVE (8)

      > - FFTW_PRESERVE_INPUT (16)

      > - FFTW_PATIENT (32)

      > - FFTW_ESTIMATE (64)

      > - FFTW_WISDOM_ONLY (2097152)

    - normalization (float, optional) – Normalization factor

  __call__()

    Signature:

        __call__(input_array=None, output_array=None, implicit=True, normalize=False, **kw)

    Compute transform and return output array

    Parameters:

      - input_array (array, optional) – If not provided, then use internally stored array

      - output_array (array, optional) – If not provided, then use internally stored array

      - implicit (bool, optional) – If True, then use an implicit method that acts by applying the plan directly on the given input array. If False, then use an explicit method that first copies the given input_array into the internal _input_array. The explicit method is generally safer, because it always preserves the provided input_array. The implicit method can be faster because it may be done without any copying. However, the contents of the input_array may be destroyed during computation. So use with care!

      - normalize (bool, optional) – If True, normalize transform with internally stored normalization factor. The internally set normalization factor is possible to obtain through `FFT.get_normalization()`

      - kw (dict, optional)

    Note

    If the transform has been planned with FFTW_PRESERVE_INPUT, then both the two methods (implicit=True/False) will preserve the provided input_array. If not planned with this flag, then the implicit=True method may cause the input_array to be overwritten during computation.

  destroy()
  get_normalization()

    Return the internally set normalization factor

  input_array
  output_array
  print_plan()
  update_arrays(input_array, output_array)

mpi4py_fft.fftw.fftwf_xfftn.alignment_of(input_array)

mpi4py_fft.fftw.fftwf_xfftn.cleanup()

mpi4py_fft.fftw.fftwf_xfftn.export_wisdom(filename)

mpi4py_fft.fftw.fftwf_xfftn.forget_wisdom()

mpi4py_fft.fftw.fftwf_xfftn.import_wisdom(filename)

mpi4py_fft.fftw.fftwf_xfftn.set_timelimit(limit)

## mpi4py_fft.fftw.fftwl_xfftn module

class mpi4py_fft.fftw.fftwl_xfftn.FFT

  Bases: `object`

  Unified class for FFTs of multidimensional arrays

  This class is used for any type of transform defined in the user manual of FFTW.

  Parameters:

    - input_array (array) – real or complex input array

    - output_array (array) – real or complex output array

    - axes (sequence of ints, optional) – The axes to transform over, starting from the last

    - kind (int or sequence of ints, optional) –

      Any one of

      > - FFTW_FORWARD (-1)

      > - FFTW_R2HC (0)

      > - FFTW_BACKWARD (1)

      > - FFTW_HC2R (1)

      > - FFTW_DHT (2)

      > - FFTW_REDFT00 (3)

      > - FFTW_REDFT01 (4)

      > - FFTW_REDFT10 (5)

      > - FFTW_REDFT11 (6)

      > - FFTW_RODFT00 (7)

      > - FFTW_RODFT01 (8)

      > - FFTW_RODFT10 (9)

      > - FFTW_RODFT11 (10)

    - threads (int, optional) – Number of threads to use in transforms

    - flags (int or sequence of ints, optional) –

      Any one of, but not necessarily for all transforms or all combinations

      > - FFTW_MEASURE (0)

      > - FFTW_DESTROY_INPUT (1)

      > - FFTW_UNALIGNED (2)

      > - FFTW_CONSERVE_MEMORY (4)

      > - FFTW_EXHAUSTIVE (8)

      > - FFTW_PRESERVE_INPUT (16)

      > - FFTW_PATIENT (32)

      > - FFTW_ESTIMATE (64)

      > - FFTW_WISDOM_ONLY (2097152)

    - normalization (float, optional) – Normalization factor

  __call__()

    Signature:

        __call__(input_array=None, output_array=None, implicit=True, normalize=False, **kw)

    Compute transform and return output array

    Parameters:

      - input_array (array, optional) – If not provided, then use internally stored array

      - output_array (array, optional) – If not provided, then use internally stored array

      - implicit (bool, optional) – If True, then use an implicit method that acts by applying the plan directly on the given input array. If False, then use an explicit method that first copies the given input_array into the internal _input_array. The explicit method is generally safer, because it always preserves the provided input_array. The implicit method can be faster because it may be done without any copying. However, the contents of the input_array may be destroyed during computation. So use with care!

      - normalize (bool, optional) – If True, normalize transform with internally stored normalization factor. The internally set normalization factor is possible to obtain through `FFT.get_normalization()`

      - kw (dict, optional)

    Note

    If the transform has been planned with FFTW_PRESERVE_INPUT, then both the two methods (implicit=True/False) will preserve the provided input_array. If not planned with this flag, then the implicit=True method may cause the input_array to be overwritten during computation.

  destroy()
  get_normalization()

    Return the internally set normalization factor

  input_array
  output_array
  print_plan()
  update_arrays(input_array, output_array)

mpi4py_fft.fftw.fftwl_xfftn.alignment_of(input_array)

mpi4py_fft.fftw.fftwl_xfftn.cleanup()

mpi4py_fft.fftw.fftwl_xfftn.export_wisdom(filename)

mpi4py_fft.fftw.fftwl_xfftn.forget_wisdom()

mpi4py_fft.fftw.fftwl_xfftn.import_wisdom(filename)

mpi4py_fft.fftw.fftwl_xfftn.set_timelimit(limit)

## mpi4py_fft.fftw.factory module

mpi4py_fft.fftw.factory.cleanup()

mpi4py_fft.fftw.factory.export_wisdom(filename)

  Export FFTW wisdom

  Parameters:

    filename (str) – Name of file used to export wisdom to

  Note

  Wisdom is stored for all precisions available: float, double and long double, using, respectively, prefix `Fn_`, `Dn_` and `Gn_`, where n is the rank of the processor. Wisdom is imported using `import_wisdom()`, which must be called with the same MPI configuration as used with `export_wisdom()`.

  See also

  `import_wisdom()`

mpi4py_fft.fftw.factory.forget_wisdom()

mpi4py_fft.fftw.factory.get_fftw_lib(dtype)

  Return compiled fftw module interfacing the FFTW library

  Parameters:

    dtype (dtype) – Data precision

  Returns:

    Module can be either `fftwf_xfftn`, `fftw_xfftn` or `fftwl_xfftn`, depending on precision.

  Return type:

    Module or `None`

mpi4py_fft.fftw.factory.get_planned_FFT(input_array, output_array, axes=(-1,), kind=-1, threads=1, flags=(0,), normalization=1.0)

  Return instance of transform class

  Parameters:

    - input_array (array) – real or complex input array

    - output_array (array) – real or complex output array

    - axes (sequence of ints, optional) – The axes to transform over, starting from the last

    - kind (int or sequence of ints, optional) –

      Any one of (or possibly several for real-to-real)

      > - FFTW_FORWARD (-1)

      > - FFTW_R2HC (0)

      > - FFTW_BACKWARD (1)

      > - FFTW_HC2R (1)

      > - FFTW_DHT (2)

      > - FFTW_REDFT00 (3)

      > - FFTW_REDFT01 (4)

      > - FFTW_REDFT10 (5)

      > - FFTW_REDFT11 (6)

      > - FFTW_RODFT00 (7)

      > - FFTW_RODFT01 (8)

      > - FFTW_RODFT10 (9)

      > - FFTW_RODFT11 (10)

    - threads (int, optional) – Number of threads to use in transforms

    - flags (int or sequence of ints, optional) –

      Any one of, but not necessarily for all transforms or all combinations

      > - FFTW_MEASURE (0)

      > - FFTW_DESTROY_INPUT (1)

      > - FFTW_UNALIGNED (2)

      > - FFTW_CONSERVE_MEMORY (4)

      > - FFTW_EXHAUSTIVE (8)

      > - FFTW_PRESERVE_INPUT (16)

      > - FFTW_PATIENT (32)

      > - FFTW_ESTIMATE (64)

      > - FFTW_WISDOM_ONLY (2097152)

    - normalization (float, optional) – Normalization factor

  Returns:

    An instance of the return type configured for the desired transforms

  Return type:

    `fftwf_xfftn.FFT`, `fftw_xfftn.FFT` or `fftwl_xfftn.FFT`

mpi4py_fft.fftw.factory.import_wisdom(filename)

  Import FFTW wisdom

  Parameters:

    filename (str) – Name of file used to import wisdom from

  Note

  Wisdom is imported for all available precisions: float, double and long double, using, respectively, prefix `Fn_`, `Dn_` and `Gn_`, where n is the rank of the processor. Wisdom is exported using `export_wisdom()`. Note that importing wisdom only works when using the same MPI configuration as used with `export_wisdom()`.

  See also

  `export_wisdom()`

mpi4py_fft.fftw.factory.set_timelimit(limit)

  Set time limit for planning

  Parameters:

    limit (number) – The new time limit set for planning of serial transforms

## mpi4py_fft.fftw.utilities module

mpi4py_fft.fftw.utilities.aligned(shape, n=32, dtype=dtype('float64'), fill=None)

  Returned array with byte-alignment according to n

  Parameters:

    - shape (sequence of ints) – The shape of the array to be created

    - n (int, optional) – The chosen byte-alignment

    - dtype (np.dtype, optional) – The type of the returned array

    - fill (None or number, optional) – If number then fill returned array with this number, otherwise return empty array

  Returns:

    byte-aligned array

  Return type:

    array

mpi4py_fft.fftw.utilities.aligned_like(z, fill=None)

  Return array with byte-alignment, shape and type like array z

  Parameters:

    - z (array) – An array with shape and type we want to recreate

    - fill (None or number, optional) – If number then fill returned array with this number, otherwise return empty array

  Returns:

    byte-aligned array

  Return type:

    array

mpi4py_fft.fftw.utilities.get_alignment(array)

  Return alignment assuming highest allowed is 32

  Parameters:

    array (array)

## mpi4py_fft.fftw.xfftn module

mpi4py_fft.fftw.xfftn.dctn(input_array, s=None, axes=(-1,), type=2, threads=1, flags=(0,), output_array=None)

  Return discrete cosine transform object

  Parameters:

    - input_array (array)

    - s (sequence of ints, optional) – Not used - included for compatibility with Numpy

    - axes (sequence of ints, optional) – Axes over which to compute the real-to-real dct.

    - type (int, optional) –

      Type of dct

      > - 1 - FFTW_REDFT00

      > - 2 - FFTW_REDFT10,

      > - 3 - FFTW_REDFT01,

      > - 4 - FFTW_REDFT11

    - threads (int, optional) – Number of threads used in computing dct.

    - flags (sequence of ints, optional) –

      Flags from

      > - FFTW_MEASURE

      > - FFTW_EXHAUSTIVE

      > - FFTW_PATIENT

      > - FFTW_DESTROY_INPUT

      > - FFTW_PRESERVE_INPUT

      > - FFTW_UNALIGNED

      > - FFTW_CONSERVE_MEMORY

      > - FFTW_ESTIMATE

    - output_array (array, optional) – Array to be used as output array. Must be of correct shape, type, strides and alignment

  Returns:

    An instance of the return type configured for real-to-real dct transforms of given type

  Return type:

    `fftwf_xfftn.FFT`, `fftw_xfftn.FFT` or `fftwl_xfftn.FFT`

  Note

  This routine does not compute the dct, it merely returns an instance of a class that can do it.

  Examples

      >>> import numpy as np
      >>> from mpi4py_fft.fftw import dctn as plan_dct
      >>> from mpi4py_fft.fftw import FFTW_ESTIMATE, aligned
      >>> A = aligned(4, dtype='d')
      >>> dct = plan_dct(A, flags=(FFTW_ESTIMATE,))
      >>> A[:] = 1, 2, 3, 4
      >>> B = dct()
      >>> print(B)
      [20.         -6.30864406  0.         -0.44834153]
      >>> assert id(A) == id(dct.input_array)
      >>> assert id(B) == id(dct.output_array)

mpi4py_fft.fftw.xfftn.dstn(input_array, s=None, axes=(-1,), type=2, threads=1, flags=(0,), output_array=None)

  Return discrete sine transform object

  Parameters:

    - input_array (array)

    - s (sequence of ints, optional) – Not used - included for compatibility with Numpy

    - axes (sequence of ints, optional) – Axes over which to compute the real-to-real dst.

    - type (int, optional) –

      Type of dst

      > - 1 - FFTW_RODFT00

      > - 2 - FFTW_RODFT10

      > - 3 - FFTW_RODFT01

      > - 4 - FFTW_RODFT11

    - threads (int, optional) – Number of threads used in computing dst.

    - flags (sequence of ints, optional) –

      Flags from

      > - FFTW_MEASURE

      > - FFTW_EXHAUSTIVE

      > - FFTW_PATIENT

      > - FFTW_DESTROY_INPUT

      > - FFTW_PRESERVE_INPUT

      > - FFTW_UNALIGNED

      > - FFTW_CONSERVE_MEMORY

      > - FFTW_ESTIMATE

    - output_array (array, optional) – Array to be used as output array. Must be of correct shape, type, strides and alignment

  Returns:

    An instance of the return type configured for real-to-real dst transforms of given type

  Return type:

    `fftwf_xfftn.FFT`, `fftw_xfftn.FFT` or `fftwl_xfftn.FFT`

  Note

  This routine does not compute the dst, it merely returns an instance of a class that can do it.

  Examples

      >>> import numpy as np
      >>> from mpi4py_fft.fftw import dstn as plan_dst
      >>> from mpi4py_fft.fftw import FFTW_ESTIMATE, aligned
      >>> A = aligned(4, dtype='d')
      >>> dst = plan_dst(A, flags=(FFTW_ESTIMATE,))
      >>> A[:] = 1, 2, 3, 4
      >>> B = dst()
      >>> print(B)
      [13.06562965 -5.65685425  5.411961   -4.        ]
      >>> assert id(A) == id(dst.input_array)
      >>> assert id(B) == id(dst.output_array)

mpi4py_fft.fftw.xfftn.fftn(input_array, s=None, axes=(-1,), threads=1, flags=(0,), output_array=None)

  Return complex-to-complex forward transform object

  Parameters:

    - input_array (complex array)

    - s (sequence of ints, optional) – Not used - included for compatibility with Numpy

    - axes (sequence of ints, optional) – Axes over which to compute the FFT.

    - threads (int, optional) – Number of threads used in computing FFT.

    - flags (sequence of ints, optional) –

      Flags from

      > - FFTW_MEASURE

      > - FFTW_EXHAUSTIVE

      > - FFTW_PATIENT

      > - FFTW_DESTROY_INPUT

      > - FFTW_PRESERVE_INPUT

      > - FFTW_UNALIGNED

      > - FFTW_CONSERVE_MEMORY

      > - FFTW_ESTIMATE

    - output_array (complex array, optional) – Array to be used as output array. Must be of correct shape, type, strides and alignment

  Returns:

    An instance of the return type configured for complex-to-complex transforms

  Return type:

    `fftwf_xfftn.FFT`, `fftw_xfftn.FFT` or `fftwl_xfftn.FFT`

  Note

  This routine does not compute the fftn, it merely returns an instance of a class that can do it. The contents of the input_array may be overwritten during planning. Make sure to keep a copy if needed.

  Examples

      >>> import numpy as np
      >>> from mpi4py_fft.fftw import fftn as plan_fftn
      >>> from mpi4py_fft.fftw import FFTW_ESTIMATE, aligned
      >>> A = aligned(4, dtype='D')
      >>> fftn = plan_fftn(A, flags=(FFTW_ESTIMATE,))
      >>> A[:] = 1, 2, 3, 4
      >>> B = fftn()
      >>> print(B)
      [10.+0.j -2.+2.j -2.+0.j -2.-2.j]
      >>> assert id(A) == id(fftn.input_array)
      >>> assert id(B) == id(fftn.output_array)

mpi4py_fft.fftw.xfftn.get_normalization(kind, shape, axes)

  Return normalization factor for multidimensional transform

  The normalization factor is, for Fourier transforms:

      1./np.prod(np.take(shape, axes))

  where shape is the global shape of the array that is input to the forward transform, and axes are the axes transformed over.

  For real-to-real transforms the normalization factor for each axis is

  > - REDFT00 - 2(N-1)

  > - REDFT01 - 2N

  > - REDFT10 - 2N

  > - REDFT11 - 2N

  > - RODFT00 - 2(N+1)

  > - RODFT01 - 2N

  > - RODFT10 - 2N

  > - RODFT11 - 2N

  where N is the length of the input array along that axis.

  Parameters:

    - kind (sequence of ints) – The kind of transform along each axis

    - shape (sequence of ints) – The shape of the global transformed array (input to the forward transform)

    - axes (sequence of ints) – The axes transformed over

  Note

  The returned normalization factor is the inverse of the product of the normalization factors for the axes it is transformed over.

mpi4py_fft.fftw.xfftn.hfftn(input_array, s=None, axes=(-1,), threads=1, flags=(0,), output_array=None)

  Return transform object for an array with Hermitian symmetry

  Parameters:

    - input_array (array)

    - s (sequence of ints, optional) – Not used - included for compatibility with Numpy

    - axes (sequence of ints, optional) – Axes over which to compute the hfftn.

    - threads (int, optional) – Number of threads used in computing hfftn.

    - flags (sequence of ints, optional) –

      Flags from

      > - FFTW_MEASURE

      > - FFTW_EXHAUSTIVE

      > - FFTW_PATIENT

      > - FFTW_DESTROY_INPUT

      > - FFTW_PRESERVE_INPUT

      > - FFTW_UNALIGNED

      > - FFTW_CONSERVE_MEMORY

      > - FFTW_ESTIMATE

    - output_array (array, optional) – Array to be used as output array. Must be of correct shape, type, strides and alignment

  Returns:

    An instance of the return type configured for complex-to-real hfftn transforms

  Return type:

    `fftwf_xfftn.FFT`, `fftw_xfftn.FFT` or `fftwl_xfftn.FFT`

  Note

  This routine does not compute the hfttn, it merely returns an instance of a class that can do it.

  Examples

      >>> import numpy as np
      >>> from mpi4py_fft.fftw import hfftn as plan_hfftn
      >>> from mpi4py_fft.fftw import FFTW_ESTIMATE, aligned
      >>> A = aligned(4, dtype='D')
      >>> hfftn = plan_hfftn(A, flags=(FFTW_ESTIMATE,)) # no shape given for output
      >>> A[:] = 1, 2, 3, 4
      >>> B = hfftn()
      >>> print(B)
      [15. -4.  0. -1.  0. -4.]
      >>> hfftn = plan_hfftn(A, s=(7,), flags=(FFTW_ESTIMATE,)) # output shape given
      >>> B = hfftn()
      >>> print(B)
      [19.         -5.04891734 -0.30797853 -0.64310413 -0.64310413 -0.30797853
       -5.04891734]
      >>> assert id(B) == id(hfftn.output_array)
      >>> assert id(A) == id(hfftn.input_array)

mpi4py_fft.fftw.xfftn.idctn(input_array, s=None, axes=(-1,), type=2, threads=1, flags=(0,), output_array=None)

  Return inverse discrete cosine transform object

  Parameters:

    - input_array (array)

    - s (sequence of ints, optional) – Not used - included for compatibility with Numpy

    - axes (sequence of ints, optional) – Axes over which to compute the real-to-real idct.

    - type (int, optional) –

      Type of idct

      > - 1 - FFTW_REDFT00

      > - 2 - FFTW_REDFT01

      > - 3 - FFTW_REDFT10

      > - 4 - FFTW_REDFT11

    - threads (int, optional) – Number of threads used in computing idct.

    - flags (sequence of ints, optional) –

      Flags from

      > - FFTW_MEASURE

      > - FFTW_EXHAUSTIVE

      > - FFTW_PATIENT

      > - FFTW_DESTROY_INPUT

      > - FFTW_PRESERVE_INPUT

      > - FFTW_UNALIGNED

      > - FFTW_CONSERVE_MEMORY

      > - FFTW_ESTIMATE

    - output_array (array, optional) – Array to be used as output array. Must be of correct shape, type, strides and alignment

  Returns:

    An instance of the return type configured for real-to-real idct transforms of given type

  Return type:

    `fftwf_xfftn.FFT`, `fftw_xfftn.FFT` or `fftwl_xfftn.FFT`

  Note

  This routine does not compute the idct, it merely returns an instance of a class that can do it.

  Examples

      >>> import numpy as np
      >>> from mpi4py_fft.fftw import idctn as plan_idct
      >>> from mpi4py_fft.fftw import FFTW_ESTIMATE, aligned
      >>> A = aligned(4, dtype='d')
      >>> idct = plan_idct(A, flags=(FFTW_ESTIMATE,))
      >>> A[:] = 1, 2, 3, 4
      >>> B = idct()
      >>> print(B)
      [11.99962628 -9.10294322  2.61766184 -1.5143449 ]
      >>> assert id(A) == id(idct.input_array)
      >>> assert id(B) == id(idct.output_array)

mpi4py_fft.fftw.xfftn.idstn(input_array, s=None, axes=(-1,), type=2, threads=1, flags=(0,), output_array=None)

  Return inverse discrete sine transform object

  Parameters:

    - input_array (array)

    - s (sequence of ints, optional) – Not used - included for compatibility with Numpy

    - axes (sequence of ints, optional) – Axes over which to compute the real-to-real inverse dst.

    - type (int, optional) –

      Type of idst

      > - 1 - FFTW_RODFT00

      > - 2 - FFTW_RODFT01

      > - 3 - FFTW_RODFT10

      > - 4 - FFTW_RODFT11

    - threads (int, optional) – Number of threads used in computing inverse dst.

    - flags (sequence of ints, optional) –

      Flags from

      > - FFTW_MEASURE

      > - FFTW_EXHAUSTIVE

      > - FFTW_PATIENT

      > - FFTW_DESTROY_INPUT

      > - FFTW_PRESERVE_INPUT

      > - FFTW_UNALIGNED

      > - FFTW_CONSERVE_MEMORY

      > - FFTW_ESTIMATE

    - output_array (array, optional) – Array to be used as output array. Must be of correct shape, type, strides and alignment

  Returns:

    An instance of the return type configured for real-to-real idst transforms of given type

  Return type:

    `fftwf_xfftn.FFT`, `fftw_xfftn.FFT` or `fftwl_xfftn.FFT`

  Note

  This routine does not compute the idst, it merely returns an instance of a class that can do it.

  Examples

      >>> import numpy as np
      >>> from mpi4py_fft.fftw import idstn as plan_idst
      >>> from mpi4py_fft.fftw import FFTW_ESTIMATE, aligned
      >>> A = aligned(4, dtype='d')
      >>> idst = plan_idst(A, flags=(FFTW_ESTIMATE,))
      >>> A[:] = 1, 2, 3, 4
      >>> B = idst()
      >>> print(B)
      [13.13707118 -1.6199144   0.72323135 -0.51978306]
      >>> assert id(A) == id(idst.input_array)
      >>> assert id(B) == id(idst.output_array)

mpi4py_fft.fftw.xfftn.ifftn(input_array, s=None, axes=(-1,), threads=1, flags=(0,), output_array=None)

  Return complex-to-complex inverse transform object

  Parameters:

    - input_array (array)

    - s (sequence of ints, optional) – Not used - included for compatibility with Numpy

    - axes (sequence of ints, optional) – Axes over which to compute the inverse FFT.

    - threads (int, optional) – Number of threads used in computing FFT.

    - flags (sequence of ints, optional) –

      Flags from

      > - FFTW_MEASURE

      > - FFTW_EXHAUSTIVE

      > - FFTW_PATIENT

      > - FFTW_DESTROY_INPUT

      > - FFTW_PRESERVE_INPUT

      > - FFTW_UNALIGNED

      > - FFTW_CONSERVE_MEMORY

      > - FFTW_ESTIMATE

    - output_array (array, optional) – Array to be used as output array. Must be of correct shape, type, strides and alignment

  Returns:

    An instance of the return type configured for complex-to-complex inverse transforms

  Return type:

    `fftwf_xfftn.FFT`, `fftw_xfftn.FFT` or `fftwl_xfftn.FFT`

  Note

  This routine does not compute the ifftn, it merely returns an instance of a class that can do it. The contents of the input_array may be overwritten during planning. Make sure that you keep a copy if needed.

  Examples

      >>> import numpy as np
      >>> from mpi4py_fft.fftw import ifftn as plan_ifftn
      >>> from mpi4py_fft.fftw import FFTW_ESTIMATE, FFTW_PRESERVE_INPUT, aligned
      >>> A = aligned(4, dtype='D')
      >>> ifftn = plan_ifftn(A, flags=(FFTW_ESTIMATE, FFTW_PRESERVE_INPUT))
      >>> A[:] = 1, 2, 3, 4
      >>> B = ifftn()
      >>> print(B)
      [10.+0.j -2.-2.j -2.+0.j -2.+2.j]
      >>> assert id(B) == id(ifftn.output_array)
      >>> assert id(A) == id(ifftn.input_array)

mpi4py_fft.fftw.xfftn.ihfftn(input_array, s=None, axes=(-1,), threads=1, flags=(0,), output_array=None)

  Return inverse transform object for an array with Hermitian symmetry

  Parameters:

    - input_array (array)

    - s (sequence of ints, optional) – Not used - included for compatibility with Numpy

    - axes (sequence of ints, optional) – Axes over which to compute the ihfftn.

    - threads (int, optional) – Number of threads used in computing ihfftn.

    - flags (sequence of ints, optional) –

      Flags from

      > - FFTW_MEASURE

      > - FFTW_EXHAUSTIVE

      > - FFTW_PATIENT

      > - FFTW_DESTROY_INPUT

      > - FFTW_PRESERVE_INPUT

      > - FFTW_UNALIGNED

      > - FFTW_CONSERVE_MEMORY

      > - FFTW_ESTIMATE

    - output_array (array, optional) – Array to be used as output array. Must be of correct shape, type, strides and alignment

  Returns:

    An instance of the return type configured for real-to-complex ihfftn transforms

  Return type:

    `fftwf_xfftn.FFT`, `fftw_xfftn.FFT` or `fftwl_xfftn.FFT`

  Note

  This routine does not compute the ihfttn, it merely returns an instance of a class that can do it.

  Examples

      >>> import numpy as np
      >>> from mpi4py_fft.fftw import ihfftn as plan_ihfftn
      >>> from mpi4py_fft.fftw import FFTW_ESTIMATE, aligned
      >>> A = aligned(4, dtype='d')
      >>> ihfftn = plan_ihfftn(A, flags=(FFTW_ESTIMATE,))
      >>> A[:] = 1, 2, 3, 4
      >>> B = ihfftn()
      >>> print(B)
      [10.+0.j -2.+2.j -2.+0.j]
      >>> assert id(A) == id(ihfftn.input_array)
      >>> assert id(B) == id(ihfftn.output_array)

mpi4py_fft.fftw.xfftn.irfftn(input_array, s=None, axes=(-1,), threads=1, flags=(0,), output_array=None)

  Return inverse complex-to-real transform object

  Parameters:

    - input_array (array)

    - s (sequence of ints, optional) – Shape of output array along each of the transformed axes. Must be same length as axes (len(s) == len(axes)). If not given it is assumed that the shape of the output along the first transformed axis (i.e., axes[-1]) is an even number. It is not possible to determine exactly, because for a real transform the output of a real array of length N is N//2+1. However, both N=4 and N=5 gives 4//2+1=3 and 5//2+1=3, so it is not possible to determine whether 4 or 5 is correct. Hence it must be given.

    - axes (sequence of ints, optional) – Axes over which to compute the real to complex FFT.

    - threads (int, optional) – Number of threads used in computing FFT.

    - flags (sequence of ints, optional) –

      Flags from

      > - FFTW_MEASURE

      > - FFTW_EXHAUSTIVE

      > - FFTW_PATIENT

      > - FFTW_UNALIGNED

      > - FFTW_CONSERVE_MEMORY

      > - FFTW_ESTIMATE

    - output_array (array, optional) – Array to be used as output array. Must be of correct shape, type, strides and alignment

  Returns:

    An instance of the return type configured for complex-to-real transforms

  Return type:

    `fftwf_xfftn.FFT`, `fftw_xfftn.FFT` or `fftwl_xfftn.FFT`

  Note

  This routine does not compute the irfftn, it merely returns an instance of a class that can do it. The irfftn is not possible to use with the FFTW_PRESERVE_INPUT flag.

  Examples

      >>> import numpy as np
      >>> from mpi4py_fft.fftw import irfftn as plan_irfftn
      >>> from mpi4py_fft.fftw import FFTW_ESTIMATE, aligned
      >>> A = aligned(4, dtype='D')
      >>> irfftn = plan_irfftn(A, flags=(FFTW_ESTIMATE,)) # no shape given for output
      >>> A[:] = 1, 2, 3, 4
      >>> B = irfftn()
      >>> print(B)
      [15. -4.  0. -1.  0. -4.]
      >>> irfftn = plan_irfftn(A, s=(7,), flags=(FFTW_ESTIMATE,)) # output shape given
      >>> B = irfftn()
      >>> print(B)
      [19.         -5.04891734 -0.30797853 -0.64310413 -0.64310413 -0.30797853
       -5.04891734]
      >>> assert id(B) == id(irfftn.output_array)
      >>> assert id(A) == id(irfftn.input_array)

mpi4py_fft.fftw.xfftn.rfftn(input_array, s=None, axes=(-1,), threads=1, flags=(0,), output_array=None)

  Return real-to-complex transform object

  Parameters:

    - input_array (real array)

    - s (sequence of ints, optional) – Not used - included for compatibility with Numpy

    - axes (sequence of ints, optional) – Axes over which to compute the real to complex FFT.

    - threads (int, optional) – Number of threads used in computing FFT.

    - flags (sequence of ints, optional) –

      Flags from

      > - FFTW_MEASURE

      > - FFTW_EXHAUSTIVE

      > - FFTW_PATIENT

      > - FFTW_DESTROY_INPUT

      > - FFTW_PRESERVE_INPUT

      > - FFTW_UNALIGNED

      > - FFTW_CONSERVE_MEMORY

      > - FFTW_ESTIMATE

    - output_array (array, optional) – Array to be used as output array. Must be of correct shape, type, strides and alignment

  Returns:

    An instance of the return type configured for real-to-complex transforms

  Return type:

    `fftwf_xfftn.FFT`, `fftw_xfftn.FFT` or `fftwl_xfftn.FFT`

  Note

  This routine does not compute the rfftn, it merely returns an instance of a class that can do it. The contents of the input_array may be overwritten during planning. Make sure that you keep a copy if needed.

  Examples

      >>> import numpy as np
      >>> from mpi4py_fft.fftw import rfftn as plan_rfftn
      >>> from mpi4py_fft.fftw import FFTW_ESTIMATE, aligned
      >>> A = aligned(4, dtype='d')
      >>> rfftn = plan_rfftn(A, flags=(FFTW_ESTIMATE,))
      >>> A[:] = 1, 2, 3, 4
      >>> B = rfftn()
      >>> print(B)
      [10.+0.j -2.+2.j -2.+0.j]
      >>> assert id(A) == id(rfftn.input_array)
      >>> assert id(B) == id(rfftn.output_array)

## Module contents