2024.1.4

Version 2024.1.4 (2024-07-23)

• support numpy >=2.0

Version 2024.1.3 (2024-03-19)

• Correct handling of arrays where some axes
  have a length of 1 [https://github.com//issues/34],
  with a number of corner cases for R2C where the
  fast axis must be transformed.

Version 2024.1.2.post0 (2024-05-01)

• Fix nvcc search in setup.py without a CUDA_HOME type
  environment variable under linux.

Version 2024.1.2 (2024-02-17)

• Fix conda installation with specified cuda-version,
  notably for cuda 12.x support
• add conda-forge build test for cuda and opencl libraries

Version 2024.1.1 (2024-02-12)

• Fix pycuda initialisation during accuracy tests (pyvkff-test).

Version 2024.1 (2024-02-06)

• Based on VkFFT 1.3.4
• Add support for direct sine transforms (DST)
• R2C, DST and DCT now support arbitrary sizes (up to ~2^32,
  same as C2C)
• Odd lengths for the fast axis is now supported for all R2C
  transforms. Inplace transforms require using
  the r2c_odd=True parameter
• Custom transform axes (strided) are now allowed also for R2C,
  as long as the fast axis is transformed.
• added functions to access the size of the temporary buffer
  created by VkFFT (if any), the type of algorithm used along
  each axis (radix, Rader, Bluestein), and the number of
  uploads for each transformed axis.
• DCT and DST now support F-ordered arrays
• Longer default test including multi-upload using radix,
  Rader and Bluestein algorithms.
• The full test suite (including c2c, r2c, dct, dst, radix
  and non-radix transforms, single and double precision)
  now includes about 1.5 million unit tests
• The pyvkff-benchmark script can also test R2C, DCT and DST
  transforms, and will give more details about the algorithm
  used for performance tuning.
• Added pyvkfft-info script

2024.1.1

Version 2024.1.1 (2024-02-12)

• Fix pycuda initialisation during accuracy tests (pyvkff-test).

Version 2024.1 (2024-02-06)

• Based on VkFFT 1.3.4
• Add support for direct sine transforms (DST)
• R2C, DST and DCT now support arbitrary sizes (up to ~2^32,
  same as C2C)
• Odd lengths for the fast axis is now supported for all R2C
  transforms. Inplace transforms require using
  the r2c_odd=True parameter
• Custom transform axes (strided) are now allowed also for R2C,
  as long as the fast axis is transformed.
• added functions to access the size of the temporary buffer
  created by VkFFT (if any), the type of algorithm used along
  each axis (radix, Rader, Bluestein), and the number of
  uploads for each transformed axis.
• DCT and DST now support F-ordered arrays
• Longer default test including multi-upload using radix,
  Rader and Bluestein algorithms.
• The full test suite (including c2c, r2c, dct, dst, radix
  and non-radix transforms, single and double precision)
  now includes about 1.5 million unit tests
• The pyvkff-benchmark script can also test R2C, DCT and DST
  transforms, and will give more details about the algorithm
  used for performance tuning.
• Added pyvkfft-info script

2024.1

Version 2024.1 (2024-02-06)

• Based on VkFFT 1.3.4
• Add support for direct sine transforms (DST)
• R2C, DST and DCT now support arbitrary sizes (up to ~2^32,
  same as C2C)
• Odd lengths for the fast axis is now supported for all R2C
  transforms. Inplace transforms require using
  the r2c_odd=True parameter
• Custom transform axes (strided) are now allowed also for R2C,
  as long as the fast axis is transformed.
• added functions to access the size of the temporary buffer
  created by VkFFT (if any), the type of algorithm used along
  each axis (radix, Rader, Bluestein), and the number of
  uploads for each transformed axis.
• DCT and DST now support F-ordered arrays
• Longer default test including multi-upload using radix,
  Rader and Bluestein algorithms.
• The full test suite (including c2c, r2c, dct, dst, radix
  and non-radix transforms, single and double precision)
  now includes about 1.5 million unit tests
• The pyvkff-benchmark script can also test R2C, DCT and DST
  transforms, and will give more details about the algorithm
  used for performance tuning.
• Added pyvkfft-info script

2023.2

Version 2023.2 (2023-08-14)

• Based on VkFFT 1.3.1
• Add support for more than 3 FFT dimensions (defaults to 8
  in pyvkfft, can be changed when installing)
• Add options to manually or automatically tune the FFT performance
  for the used GPUs.
• Add pyvkfft-benchmark script.
• The VkFFT source is now included as a git subproject
• Actually use cuda_stream parameter in the pyvkfft.fft interface
• Take into account current cuda device when automatically
  caching VkFFTApp using the pyvkfft.fft interface(#26)
  This enable using multiple GPUs in a multi-threaded approach.
• The pyvkfft-test will ignore the PoCL OpenCL platform if
  another is available and unless it is explicitly selected.

2023.1.1

Version 2023.1.1 (2023-01-22)

• Fix MANIFEST.in including vkfft_cuda.cu for python setup.py sdist

Version 2023.1 (2023-01-19)

• VkFFT 1.2.33, now using Rader algorithm for better performance
  with many non-radix sizes.
• Fix R2C tests when using numpy (scipy unavailable) [#19]
• Add support for F-ordered arrays (C2C and R2C)
• Allow selection of backend for non-systematic pvkfft-test
• Add parameter to select the OpenCL platform in pyvkfft-test
• For pyopencl, transforms will use the array's queue by default
  instead of the application's (a warning will be written to
  notify this change when they differ; it can be disabled using
  config.WARN_OPENCL_QUEUE_MISMATCH). A queue can also be supplied
  to the fft() and ifft() methods.
  (from @isuruf, #17)
• Fix simple fft interface import when only pycuda is used
• Add cuda_driver_version, cuda_compile_version, cuda_runtime_version
  functions.
• Add simpler interface to run benchmarks, using separate processes.
• add pyvkfft-test-suite for long tests (up to 30 hours) for validation
  before new releases.

2023.1

• VkFFT 1.2.33, now using Rader algorithm for better performance
  with many non-radix sizes.
• Fix R2C tests when using numpy (scipy unavailable) [#19]
• Add support for F-ordered arrays (C2C and R2C)
• Allow selection of backend for non-systematic pvkfft-test
• Add parameter to select the OpenCL platform in pyvkfft-test
• For pyopencl, transforms will use the array's queue by default
  instead of the application's (a warning will be written to
  notify this change when they differ; it can be disabled using
  config.WARN_OPENCL_QUEUE_MISMATCH). A queue can also be supplied
  to the fft() and ifft() methods.
  (from @isuruf, #17)
• Fix simple fft interface import when only pycuda is used
• Add cuda_driver_version, cuda_compile_version, cuda_runtime_version
  functions.
• Add simpler interface to run benchmarks, using separate processes.
• add pyvkfft-test-suite for long tests (up to 30 hours) for validation
  before new releases.

2022.1

• Added accuracy unit tests, which can be used systematically
  using the pyvkfft-test installed script
• An extensive testing is now made before official releases,
  evaluating all type of transforms (c2c, r2c, dct, 1, 2 and 3D,
  in and out-of-place, norm 0 and 1), different GPUs, both OpenCL
  and CUDA, etc... Comparison is made against pyfftw, scipy or numpy.
• Update to VkFFT 1.2.21, with support for DCT types 1, 2, 3 and 4,
  also fixing a number of issues (see closed issues at
  https://github.com/DTolm/VkFFT/issues), and passing all tests
  on different GPUs (OpenCL and CUDA, AMD and nVidia)
• Raise a RuntimeError if the VkFFTApp initialisation or the
  GPU kernel launch fails, with the corresponding VkFFT error.
• [BUG] Correct inverse FFT calculation using pyvkfft.fft.ifftn()
• Installation from source using 'python setup.py install' is now
  disabled - 'pip install' should always be used.
• Added config.USE_LUT and config.FFT_CACHE_NB variables, which
  can be used to modify the default behaviour, and can also be set
  e.g. with the PYVKFFT_USE_LUT environment variable.

2021.2

• Enable transforms for any array size (VkFFT Bluestein algorithm)
• Allow 3D transforms on arrays with >3 dimensions (batch transform)
• Support for transforms on a given list of axes, instead of
  only the first ndim axes. Unavailable for R2C.
• Added a simple pyvkfft.fft interface with fftn, ifftn, rfftn, irfftn
  functions which automatically recognize the type of GPU arrays
  and cache the generated VkFFTApp (FFT plans).
• Direct Cosine Transform (DCT) of type 2, 3 and 4 (EXPERIMENTAL)
• Support CuPy arrays in addition to PyCUDA and PyOpenCL
• OpenCL: test for half and double-precision support
• OpenCL: relax accuracy requirements in unit tests
• Fix shape test for out-of-place R2C transforms
• Add a base VkFFTApp class common to OpenCL and CUDA
• Installation: fix macOS compilation. Allow selection of backends
  from an environment variable

2021.1b6 - first PyPI version

First beta version supporting:

• CUDA and OpenCL backends
• C2C, R2C/C2R for inplace and out-of-place transforms
• single and double precision for all transforms
• 1D, 2D and 3D transforms (always performed from the last axes).
• 1D and 2D FFT accept arrays of any number of dimensions (batch transforms), 3D FFT
  only accepts 3D arrays.
• allowed prime factors (radix) of the transform axes are 2, 3, 5, 7, 11 and 13
• normalisation=0 (array L2 norm * array size on each transform) and 1 (the backward
  transform divides the L2 norm by the array size, so FFT*iFFT restores the original array)
• now testing the FFT size does not exceed the allowed maximum prime number decomposition (13)
• unit tests for all transforms: see test sub-directory.
• Note that out-of-place C2R transform currently destroys the complex array for FFT dimensions >=2
• tested on macOS (10.13.6) and Linux.
• inplace transforms do not require an extra buffer or work area (as in cuFFT), unless the x
  size is larger than 8192, or if the y and z FFT size are larger than 2048. In that case
  a buffer of a size equal to the array is necessary. This makes larger FFT transforms possible
  based on memory requiremnts (even for R2C !) compared to cuFFT. For example you can compute
  the 3D FFT for a 1600**3 complex64 array withon 32GB of memory.