public static extern cufftResult cufftMakePlanMany64(cufftHandle plan,
int rank,
[In] long[] n, [In] long[] inembed, [In] long istride, [In] long idist,
[In] long[] onembed, [In] long ostride, [In] long odist,
cufftType type,
long batch,
ref SizeT workSize);
/// <summary>
/// Creates a new 2D FFT plan (new API)
/// </summary>
/// <param name="handle">cufftHandle object</param>
/// <param name="nx">The transform size in the X dimension (number of rows)</param>
/// <param name="ny">The transform size in the Y dimension (number of columns)</param>
/// <param name="type">The transform data type (e.g., C2R for complex to real)</param>
/// <param name="stream">A valid CUDA stream created with cudaStreamCreate() (or 0 for the default stream)</param>
/// <param name="mode">The <see cref="Compatibility"/> option to be used</param>
/// <param name="autoAllocate">indicates that the caller intends to allocate and manage
/// work areas for plans that have been generated.</param>
public CudaFFTPlan2D(cufftHandle handle, int nx, int ny, cufftType type, CUstream stream, Compatibility mode, bool autoAllocate)
: this(handle, nx, ny, type)
{
SetStream(stream);
SetCompatibilityMode(mode);
SetAutoAllocation(autoAllocate);
}
/// <summary>
/// Creates a new 1D FFT plan (new API)
/// </summary>
/// <param name="handle">cufftHandle object</param>
/// <param name="nx">The transform size (e.g., 256 for a 256-point FFT)</param>
/// <param name="type">The transform data type (e.g., C2C for complex to complex)</param>
/// <param name="batch">Number of transforms of size nx</param>
/// <param name="stream">A valid CUDA stream created with cudaStreamCreate() (or 0 for the default stream)</param>
/// <param name="mode">The <see cref="Compatibility"/> option to be used</param>
/// <param name="size"></param>
/// <param name="autoAllocate">indicates that the caller intends to allocate and manage
/// work areas for plans that have been generated.</param>
public CudaFFTPlan1D(cufftHandle handle, int nx, cufftType type, int batch, CUstream stream, Compatibility mode, ref SizeT size, bool autoAllocate)
: this(handle, nx, type, batch, ref size)
{
SetStream(stream);
SetCompatibilityMode(mode);
SetAutoAllocation(autoAllocate);
}
public static extern cufftResult cufftMakePlanMany(cufftHandle plan,
int rank,
[In] int[] n, [In] int[] inembed, [In] int istride, [In] int idist,
[In] int[] onembed, [In] int ostride, [In] int odist,
cufftType type,
int batch,
ref SizeT workSize);
/// <summary>
/// Creates a new 2D FFT plan (old API)
/// </summary>
/// <param name="nx">The transform size in the X dimension (number of rows)</param>
/// <param name="ny">The transform size in the Y dimension (number of columns)</param>
/// <param name="type">The transform data type (e.g., C2R for complex to real)</param>
public CudaFFTPlan2D(int nx, int ny, cufftType type)
{
_handle = new cufftHandle();
_nx = nx;
_ny = ny;
_type = type;
res = CudaFFTNativeMethods.cufftPlan2d(ref _handle, nx, ny, type);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "cufftPlan2d", res));
if (res != cufftResult.Success)
throw new CudaFFTException(res);
}
// /// <summary>
///// Creates a new 3D FFT plan (old API)
// /// </summary>
// /// <param name="nx">The transform size in the X dimension</param>
// /// <param name="ny">The transform size in the Y dimension</param>
// /// <param name="nz">The transform size in the Z dimension</param>
// /// <param name="type">The transform data type (e.g., R2C for real to complex)</param>
// /// <param name="mode">The <see cref="Compatibility"/> option to be used</param>
// public CudaFFTPlan3D(int nx, int ny, int nz, cufftType type, Compatibility mode)
// : this(nx, ny, nz, type)
// {
// SetCompatibilityMode(mode);
// }
// /// <summary>
///// Creates a new 3D FFT plan (old API)
// /// </summary>
// /// <param name="nx">The transform size in the X dimension</param>
// /// <param name="ny">The transform size in the Y dimension</param>
// /// <param name="nz">The transform size in the Z dimension</param>
// /// <param name="type">The transform data type (e.g., R2C for real to complex)</param>
// /// <param name="stream">A valid CUDA stream created with cudaStreamCreate() (or 0 for the default stream)</param>
// /// <param name="mode">The <see cref="Compatibility"/> option to be used</param>
// public CudaFFTPlan3D(int nx, int ny, int nz, cufftType type, CUstream stream, Compatibility mode)
// : this(nx, ny, nz, type)
// {
// SetStream(stream);
// SetCompatibilityMode(mode);
// }
/// <summary>
/// Creates a new 3D FFT plan (new API)
/// </summary>
/// <param name="handle">cufftHandle object</param>
/// <param name="nx">The transform size in the X dimension</param>
/// <param name="ny">The transform size in the Y dimension</param>
/// <param name="nz">The transform size in the Z dimension</param>
/// <param name="type">The transform data type (e.g., C2R for complex to real)</param>
/// <param name="size"></param>
public CudaFFTPlan3D(cufftHandle handle, int nx, int ny, int nz, cufftType type, ref SizeT size)
{
_handle = handle;
_nx = nx;
_type = type;
res = CudaFFTNativeMethods.cufftMakePlan2d(_handle, nx, ny, type, ref size);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "cufftMakePlan2d", res));
if (res != cufftResult.Success)
{
throw new CudaFFTException(res);
}
}
/// <summary>
/// During plan execution, CUFFT requires a work area for temporary storage of
/// intermediate results. This call returns an estimate for the size of the work area required,
/// given the specified parameters, and assuming default plan settings. Note that changing
/// some plan settings, such as compatibility mode, may alter the size required for the work
/// area.
/// </summary>
/// <param name="nx">The transform size in the x dimension</param>
/// <param name="ny">The transform size in the y dimension</param>
/// <param name="nz">The transform size in the z dimension</param>
/// <param name="type">The transform data type (e.g., CUFFT_C2C for single
/// precision complex to complex)</param>
/// <returns></returns>
public static SizeT EstimateSize(int nx, int ny, int nz, cufftType type)
{
SizeT size = new SizeT();
cufftResult res = CudaFFTNativeMethods.cufftEstimate3d(nx, ny, nz, type, ref size);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "cufftEstimate3d", res));
if (res != cufftResult.Success)
{
throw new CudaFFTException(res);
}
return(size);
}
/// <summary>
/// Creates a new 1D FFT plan (old API)
/// </summary>
/// <param name="nx">The transform size (e.g., 256 for a 256-point FFT)</param>
/// <param name="type">The transform data type (e.g., C2C for complex to complex)</param>
/// <param name="batch">Number of transforms of size nx</param>
public CudaFFTPlan1D(int nx, cufftType type, int batch)
{
_handle = new cufftHandle();
_nx = nx;
_type = type;
_batch = batch;
res = CudaFFTNativeMethods.cufftPlan1d(ref _handle, nx, type, batch);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "cufftPlan1d", res));
if (res != cufftResult.Success)
{
throw new CudaFFTException(res);
}
}
/// <summary>
/// Creates a new 3D FFT plan (old API)
/// </summary>
/// <param name="nx">The transform size in the X dimension</param>
/// <param name="ny">The transform size in the Y dimension</param>
/// <param name="nz">The transform size in the Z dimension</param>
/// <param name="type">The transform data type (e.g., R2C for real to complex)</param>
public CudaFFTPlan3D(int nx, int ny, int nz, cufftType type)
{
_handle = new cufftHandle();
_nx = nx;
_ny = ny;
_nz = nz;
_type = type;
res = CudaFFTNativeMethods.cufftPlan3d(ref _handle, nx, ny, nz, type);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "cufftPlan3d", res));
if (res != cufftResult.Success)
{
throw new CudaFFTException(res);
}
}
/// <summary>
/// Creates a FFT plan configuration of dimension rank, with sizes
/// specified in the array <c>n</c>. The <c>batch</c> input parameter tells CUFFT how
/// many transforms to configure in parallel. With this function, batched
/// plans of any dimension may be created. (new API)
/// </summary>
/// <param name="handle">cufftHandle object</param>
/// <param name="rank">Dimensionality of the transform (1, 2, or 3)</param>
/// <param name="n">An array of size rank, describing the size of each dimension</param>
/// <param name="batch">Batch size for this transform</param>
/// <param name="type">Transform data type (e.g., C2C, as per other CUFFT calls)</param>
/// <param name="size"></param>
public CudaFFTPlanMany64(cufftHandle handle, int rank, long[] n, long batch, cufftType type, ref SizeT size)
{
_handle = handle;
_rank = rank;
_n = n;
_batch = batch;
_type = type;
//optional:
_inembed = null;
_istride = 1;
_idist = 0;
_onembed = null;
_ostride = 1;
_odist = 0;
res = CudaFFTNativeMethods.cufftMakePlanMany64(_handle, _rank, _n, _inembed, _istride, _idist, _onembed, _ostride, _odist, _type, _batch, ref size);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "cufftMakePlanMany64", res));
if (res != cufftResult.Success)
throw new CudaFFTException(res);
}
/// <summary>
/// Creates a FFT plan configuration of dimension rank, with sizes
/// specified in the array <c>n</c>. The <c>batch</c> input parameter tells CUFFT how
/// many transforms to configure in parallel. With this function, batched
/// plans of any dimension may be created. (old API)
/// </summary>
/// <param name="rank">Dimensionality of the transform (1, 2, or 3)</param>
/// <param name="n">An array of size rank, describing the size of each dimension</param>
/// <param name="batch">Batch size for this transform</param>
/// <param name="type">Transform data type (e.g., C2C, as per other CUFFT calls)</param>
public CudaFFTPlanMany(int rank, int[] n, int batch, cufftType type)
{
_handle = new cufftHandle();
_rank = rank;
_n = n;
_batch = batch;
_type = type;
//optional:
_inembed = null;
_istride = 1;
_idist = 0;
_onembed = null;
_ostride = 1;
_odist = 0;
res = CudaFFTNativeMethods.cufftPlanMany(ref _handle, rank, n, _inembed, _istride, _idist, _onembed, _ostride, _odist, type, batch);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "CudaFFTPlanMany", res));
if (res != cufftResult.Success)
throw new CudaFFTException(res);
}
/// <summary>
/// Creates a new 2D FFT plan (new API)
/// </summary>
/// <param name="handle">cufftHandle object</param>
/// <param name="nx">The transform size in the X dimension (number of rows)</param>
/// <param name="ny">The transform size in the Y dimension (number of columns)</param>
/// <param name="type">The transform data type (e.g., C2R for complex to real)</param>
/// <param name="size"></param>
/// <param name="autoAllocate">indicates that the caller intends to allocate and manage
/// work areas for plans that have been generated.</param>
public CudaFFTPlan2D(cufftHandle handle, int nx, int ny, cufftType type, ref SizeT size, bool autoAllocate)
: this(handle, nx, ny, type, ref size)
{
SetAutoAllocation(autoAllocate);
}
/// <summary>
/// Creates a new 2D FFT plan (new API)
/// </summary>
/// <param name="handle">cufftHandle object</param>
/// <param name="nx">The transform size in the X dimension (number of rows)</param>
/// <param name="ny">The transform size in the Y dimension (number of columns)</param>
/// <param name="type">The transform data type (e.g., C2R for complex to real)</param>
/// <param name="mode">The <see cref="Compatibility"/> option to be used</param>
/// <param name="autoAllocate">indicates that the caller intends to allocate and manage
/// work areas for plans that have been generated.</param>
public CudaFFTPlan2D(cufftHandle handle, int nx, int ny, cufftType type, Compatibility mode, bool autoAllocate)
: this(handle, nx, ny, type)
{
SetCompatibilityMode(mode);
SetAutoAllocation(autoAllocate);
}
public static extern cufftResult cufftGetSizeMany64(cufftHandle plan, long rank, [In] long[] n, [In] long[] inembed, [In] long istride, [In] long idist, [In] long[] onembed, [In] long ostride, [In] long odist, cufftType type, long batch, ref SizeT workArea);
/// <summary>
/// Creates a new 2D FFT plan (new API)
/// </summary>
/// <param name="handle">cufftHandle object</param>
/// <param name="nx">The transform size in the X dimension (number of rows)</param>
/// <param name="ny">The transform size in the Y dimension (number of columns)</param>
/// <param name="type">The transform data type (e.g., C2R for complex to real)</param>
/// <param name="stream">A valid CUDA stream created with cudaStreamCreate() (or 0 for the default stream)</param>
/// <param name="size"></param>
public CudaFFTPlan2D(cufftHandle handle, int nx, int ny, cufftType type, CUstream stream, ref SizeT size)
: this(handle, nx, ny, type, ref size)
{
SetStream(stream);
}
/// <summary>
/// Creates a new 1D FFT plan (new API)
/// </summary>
/// <param name="handle">cufftHandle object</param>
/// <param name="nx">The transform size (e.g., 256 for a 256-point FFT)</param>
/// <param name="type">The transform data type (e.g., C2C for complex to complex)</param>
/// <param name="batch">Number of transforms of size nx</param>
/// <param name="mode">The <see cref="Compatibility"/> option to be used</param>
/// <param name="autoAllocate">indicates that the caller intends to allocate and manage
/// work areas for plans that have been generated.</param>
public CudaFFTPlan1D(cufftHandle handle, int nx, cufftType type, int batch, Compatibility mode, bool autoAllocate)
: this(handle, nx, type, batch)
{
SetCompatibilityMode(mode);
SetAutoAllocation(autoAllocate);
}
public static extern cufftResult cufftGetSize3d(cufftHandle handle,
int nx, int ny, int nz,
cufftType type,
ref SizeT workSize);
///// <summary>
///// Creates a new 3D FFT plan (new API)
///// </summary>
///// <param name="handle">cufftHandle object</param>
///// <param name="nx">The transform size in the X dimension</param>
///// <param name="ny">The transform size in the Y dimension</param>
///// <param name="nz">The transform size in the Z dimension</param>
///// <param name="type">The transform data type (e.g., C2R for complex to real)</param>
///// <param name="mode">The <see cref="Compatibility"/> option to be used</param>
//public CudaFFTPlan3D(cufftHandle handle, int nx, int ny, int nz, cufftType type, Compatibility mode)
// : this(handle, nx, ny, nz, type)
//{
// SetCompatibilityMode(mode);
//}
///// <summary>
///// Creates a new 3D FFT plan (new API)
///// </summary>
///// <param name="handle">cufftHandle object</param>
///// <param name="nx">The transform size in the X dimension</param>
///// <param name="ny">The transform size in the Y dimension</param>
///// <param name="nz">The transform size in the Z dimension</param>
///// <param name="type">The transform data type (e.g., C2R for complex to real)</param>
///// <param name="stream">A valid CUDA stream created with cudaStreamCreate() (or 0 for the default stream)</param>
///// <param name="mode">The <see cref="Compatibility"/> option to be used</param>
//public CudaFFTPlan3D(cufftHandle handle, int nx, int ny, int nz, cufftType type, CUstream stream, Compatibility mode)
// : this(handle, nx, ny, nz, type)
//{
// SetStream(stream);
// SetCompatibilityMode(mode);
//}
/// <summary>
/// Creates a new 3D FFT plan (new API)
/// </summary>
/// <param name="handle">cufftHandle object</param>
/// <param name="nx">The transform size in the X dimension</param>
/// <param name="ny">The transform size in the Y dimension</param>
/// <param name="nz">The transform size in the Z dimension</param>
/// <param name="type">The transform data type (e.g., C2R for complex to real)</param>
/// <param name="stream">A valid CUDA stream created with cudaStreamCreate() (or 0 for the default stream)</param>
/// <param name="size"></param>
public CudaFFTPlan3D(cufftHandle handle, int nx, int ny, int nz, cufftType type, CUstream stream, ref SizeT size)
: this(handle, nx, ny, nz, type, ref size)
{
SetStream(stream);
}
public static extern cufftResult cufftPlanMany([In, Out] ref cufftHandle plan, [In] int rank, [In] int[] n, [In] int[] inembed, [In] int istride, [In] int idist,
[In] int[] onembed, [In] int ostride, [In] int odist, [In] cufftType type, [In] int batch);
/// <summary>
/// Creates a new 1D FFT plan (old API)
/// </summary>
/// <param name="nx">The transform size (e.g., 256 for a 256-point FFT)</param>
/// <param name="type">The transform data type (e.g., C2C for complex to complex)</param>
/// <param name="batch">Number of transforms of size nx</param>
/// <param name="stream">A valid CUDA stream created with cudaStreamCreate() (or 0 for the default stream)</param>
/// <param name="mode">The <see cref="Compatibility"/> option to be used</param>
public CudaFFTPlan1D(int nx, cufftType type, int batch, CUstream stream, Compatibility mode)
: this(nx, type, batch)
{
SetStream(stream);
SetCompatibilityMode(mode);
}
/// <summary>
/// Creates a new 1D FFT plan (old API)
/// </summary>
/// <param name="nx">The transform size (e.g., 256 for a 256-point FFT)</param>
/// <param name="type">The transform data type (e.g., C2C for complex to complex)</param>
/// <param name="batch">Number of transforms of size nx</param>
/// <param name="stream">A valid CUDA stream created with cudaStreamCreate() (or 0 for the default stream)</param>
/// <param name="mode">The <see cref="Compatibility"/> option to be used</param>
public CudaFFTPlan1D(int nx, cufftType type, int batch, CUstream stream, Compatibility mode)
: this(nx, type, batch)
{
SetStream(stream);
SetCompatibilityMode(mode);
}
/// <summary>
/// Creates a new 1D FFT plan (old API)
/// </summary>
/// <param name="nx">The transform size (e.g., 256 for a 256-point FFT)</param>
/// <param name="type">The transform data type (e.g., C2C for complex to complex)</param>
/// <param name="batch">Number of transforms of size nx</param>
/// <param name="stream">A valid CUDA stream created with cudaStreamCreate() (or 0 for the default stream)</param>
public CudaFFTPlan1D(int nx, cufftType type, int batch, CUstream stream)
: this(nx, type, batch)
{
SetStream(stream);
}
/// <summary>
/// Creates a new 1D FFT plan (new API)
/// </summary>
/// <param name="handle">cufftHandle object</param>
/// <param name="nx">The transform size (e.g., 256 for a 256-point FFT)</param>
/// <param name="type">The transform data type (e.g., C2C for complex to complex)</param>
/// <param name="batch">Number of transforms of size nx</param>
/// <param name="mode">The <see cref="Compatibility"/> option to be used</param>
/// <param name="size"></param>
public CudaFFTPlan1D(cufftHandle handle, int nx, cufftType type, int batch, Compatibility mode, ref SizeT size)
: this(handle, nx, type, batch, ref size)
{
SetCompatibilityMode(mode);
}
/// <summary>
/// Creates a new 1D FFT plan (new API)
/// </summary>
/// <param name="handle">cufftHandle object</param>
/// <param name="nx">The transform size (e.g., 256 for a 256-point FFT)</param>
/// <param name="type">The transform data type (e.g., C2C for complex to complex)</param>
/// <param name="batch">Number of transforms of size nx</param>
/// <param name="size"></param>
/// <param name="autoAllocate">indicates that the caller intends to allocate and manage
/// work areas for plans that have been generated.</param>
public CudaFFTPlan1D(cufftHandle handle, int nx, cufftType type, int batch, ref SizeT size, bool autoAllocate)
: this(handle, nx, type, batch, ref size)
{
SetAutoAllocation(autoAllocate);
}
/// <summary>
/// During plan execution, CUFFT requires a work area for temporary storage of
/// intermediate results. This call returns an estimate for the size of the work area required,
/// given the specified parameters, and assuming default plan settings. Note that changing
/// some plan settings, such as compatibility mode, may alter the size required for the work
/// area.
/// </summary>
/// <param name="nx">The transform size in the x dimension (number of rows)</param>
/// <param name="ny">The transform size in the y dimension (number of columns)</param>
/// <param name="type">The transform data type (e.g., CUFFT_C2C for single
/// precision complex to complex)</param>
/// <returns></returns>
public static SizeT EstimateSize(int nx, int ny, cufftType type)
{
SizeT size = new SizeT();
cufftResult res = CudaFFTNativeMethods.cufftEstimate2d(nx, ny, type, ref size);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "cufftEstimate2d", res));
if (res != cufftResult.Success)
throw new CudaFFTException(res);
return size;
}
///// <summary>
///// Creates a new 3D FFT plan (new API)
///// </summary>
///// <param name="handle">cufftHandle object</param>
///// <param name="nx">The transform size in the X dimension</param>
///// <param name="ny">The transform size in the Y dimension</param>
///// <param name="nz">The transform size in the Z dimension</param>
///// <param name="type">The transform data type (e.g., C2R for complex to real)</param>
///// <param name="mode">The <see cref="Compatibility"/> option to be used</param>
///// <param name="size"></param>
//public CudaFFTPlan3D(cufftHandle handle, int nx, int ny, int nz, cufftType type, Compatibility mode, ref SizeT size)
// : this(handle, nx, ny, nz, type, ref size)
//{
// SetCompatibilityMode(mode);
//}
///// <summary>
///// Creates a new 3D FFT plan (new API)
///// </summary>
///// <param name="handle">cufftHandle object</param>
///// <param name="nx">The transform size in the X dimension</param>
///// <param name="ny">The transform size in the Y dimension</param>
///// <param name="nz">The transform size in the Z dimension</param>
///// <param name="type">The transform data type (e.g., C2R for complex to real)</param>
///// <param name="stream">A valid CUDA stream created with cudaStreamCreate() (or 0 for the default stream)</param>
///// <param name="mode">The <see cref="Compatibility"/> option to be used</param>
///// <param name="size"></param>
//public CudaFFTPlan3D(cufftHandle handle, int nx, int ny, int nz, cufftType type, CUstream stream, Compatibility mode, ref SizeT size)
// : this(handle, nx, ny, nz, type, ref size)
//{
// SetStream(stream);
// SetCompatibilityMode(mode);
//}
/// <summary>
/// Creates a new 3D FFT plan (new API)
/// </summary>
/// <param name="handle">cufftHandle object</param>
/// <param name="nx">The transform size in the X dimension</param>
/// <param name="ny">The transform size in the Y dimension</param>
/// <param name="nz">The transform size in the Z dimension</param>
/// <param name="type">The transform data type (e.g., C2R for complex to real)</param>
/// <param name="autoAllocate">indicates that the caller intends to allocate and manage
/// work areas for plans that have been generated.</param>
public CudaFFTPlan3D(cufftHandle handle, int nx, int ny, int nz, cufftType type, bool autoAllocate)
: this(handle, nx, ny, nz, type)
{
SetAutoAllocation(autoAllocate);
}
/// <summary>
/// Creates a new 2D FFT plan (old API)
/// </summary>
/// <param name="nx">The transform size in the X dimension (number of rows)</param>
/// <param name="ny">The transform size in the Y dimension (number of columns)</param>
/// <param name="type">The transform data type (e.g., C2R for complex to real)</param>
/// <param name="stream">A valid CUDA stream created with cudaStreamCreate() (or 0 for the default stream)</param>
public CudaFFTPlan2D(int nx, int ny, cufftType type, CUstream stream)
: this(nx, ny, type)
{
SetStream(stream);
}
///// <summary>
///// Creates a new 3D FFT plan (new API)
///// </summary>
///// <param name="handle">cufftHandle object</param>
///// <param name="nx">The transform size in the X dimension</param>
///// <param name="ny">The transform size in the Y dimension</param>
///// <param name="nz">The transform size in the Z dimension</param>
///// <param name="type">The transform data type (e.g., C2R for complex to real)</param>
///// <param name="mode">The <see cref="Compatibility"/> option to be used</param>
///// <param name="autoAllocate">indicates that the caller intends to allocate and manage
///// work areas for plans that have been generated.</param>
//public CudaFFTPlan3D(cufftHandle handle, int nx, int ny, int nz, cufftType type, Compatibility mode, bool autoAllocate)
// : this(handle, nx, ny, nz, type)
//{
// SetCompatibilityMode(mode);
// SetAutoAllocation(autoAllocate);
//}
///// <summary>
///// Creates a new 3D FFT plan (new API)
///// </summary>
///// <param name="handle">cufftHandle object</param>
///// <param name="nx">The transform size in the X dimension</param>
///// <param name="ny">The transform size in the Y dimension</param>
///// <param name="nz">The transform size in the Z dimension</param>
///// <param name="type">The transform data type (e.g., C2R for complex to real)</param>
///// <param name="stream">A valid CUDA stream created with cudaStreamCreate() (or 0 for the default stream)</param>
///// <param name="mode">The <see cref="Compatibility"/> option to be used</param>
///// <param name="autoAllocate">indicates that the caller intends to allocate and manage
///// work areas for plans that have been generated.</param>
//public CudaFFTPlan3D(cufftHandle handle, int nx, int ny, int nz, cufftType type, CUstream stream, Compatibility mode, bool autoAllocate)
// : this(handle, nx, ny, nz, type)
//{
// SetStream(stream);
// SetCompatibilityMode(mode);
// SetAutoAllocation(autoAllocate);
//}
/// <summary>
/// Creates a new 3D FFT plan (new API)
/// </summary>
/// <param name="handle">cufftHandle object</param>
/// <param name="nx">The transform size in the X dimension</param>
/// <param name="ny">The transform size in the Y dimension</param>
/// <param name="nz">The transform size in the Z dimension</param>
/// <param name="type">The transform data type (e.g., C2R for complex to real)</param>
/// <param name="stream">A valid CUDA stream created with cudaStreamCreate() (or 0 for the default stream)</param>
/// <param name="size"></param>
/// <param name="autoAllocate">indicates that the caller intends to allocate and manage
/// work areas for plans that have been generated.</param>
public CudaFFTPlan3D(cufftHandle handle, int nx, int ny, int nz, cufftType type, CUstream stream, ref SizeT size, bool autoAllocate)
: this(handle, nx, ny, nz, type, ref size)
{
SetStream(stream);
SetAutoAllocation(autoAllocate);
}
public static extern cufftResult cufftMakePlan3d(cufftHandle plan,
int nx, int ny, int nz,
cufftType type,
ref SizeT workSize);
/// <summary>
/// Creates a new 1D FFT plan (old API)
/// </summary>
/// <param name="nx">The transform size (e.g., 256 for a 256-point FFT)</param>
/// <param name="type">The transform data type (e.g., C2C for complex to complex)</param>
/// <param name="batch">Number of transforms of size nx</param>
/// <param name="stream">A valid CUDA stream created with cudaStreamCreate() (or 0 for the default stream)</param>
public CudaFFTPlan1D(int nx, cufftType type, int batch, CUstream stream)
: this(nx, type, batch)
{
SetStream(stream);
}
public static extern cufftResult cufftGetSize1d(cufftHandle handle,
int nx,
cufftType type,
int batch,
ref SizeT workSize);
/// <summary>
/// Creates a new 1D FFT plan (new API)
/// </summary>
/// <param name="handle">cufftHandle object</param>
/// <param name="nx">The transform size (e.g., 256 for a 256-point FFT)</param>
/// <param name="type">The transform data type (e.g., C2C for complex to complex)</param>
/// <param name="batch">Number of transforms of size nx</param>
/// <param name="mode">The <see cref="Compatibility"/> option to be used</param>
/// <param name="size"></param>
/// <param name="autoAllocate">indicates that the caller intends to allocate and manage
/// work areas for plans that have been generated.</param>
public CudaFFTPlan1D(cufftHandle handle, int nx, cufftType type, int batch, Compatibility mode, ref SizeT size, bool autoAllocate)
: this(handle, nx, type, batch, ref size)
{
SetCompatibilityMode(mode);
SetAutoAllocation(autoAllocate);
}
public static extern cufftResult cufftGetSizeMany(cufftHandle handle, int rank, [In] int[] n, [In] int[] inembed, [In] int istride, [In] int idist, [In] int[] onembed, [In] int ostride, [In] int odist, cufftType type, int batch, ref SizeT workArea);
/// <summary>
/// Creates a new 3D FFT plan (old API)
/// </summary>
/// <param name="nx">The transform size in the X dimension</param>
/// <param name="ny">The transform size in the Y dimension</param>
/// <param name="nz">The transform size in the Z dimension</param>
/// <param name="type">The transform data type (e.g., R2C for real to complex)</param>
/// <param name="stream">A valid CUDA stream created with cudaStreamCreate() (or 0 for the default stream)</param>
public CudaFFTPlan3D(int nx, int ny, int nz, cufftType type, CUstream stream)
: this(nx, ny, nz, type)
{
SetStream(stream);
}
/// <summary>
/// Creates a new 2D FFT plan (new API)
/// </summary>
/// <param name="handle">cufftHandle object</param>
/// <param name="nx">The transform size in the X dimension (number of rows)</param>
/// <param name="ny">The transform size in the Y dimension (number of columns)</param>
/// <param name="type">The transform data type (e.g., C2R for complex to real)</param>
public CudaFFTPlan2D(cufftHandle handle, int nx, int ny, cufftType type)
{
SizeT size = new SizeT();
_handle = handle;
_nx = nx;
_type = type;
res = CudaFFTNativeMethods.cufftMakePlan2d(_handle, nx, ny, type, ref size);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "cufftMakePlan2d", res));
if (res != cufftResult.Success)
throw new CudaFFTException(res);
}
public static extern cufftResult cufftMakePlan1d(cufftHandle plan,
int nx,
cufftType type,
int batch, /* deprecated - use cufftPlanMany */
ref SizeT workSize);
/// <summary>
/// Creates a new 2D FFT plan (new API)
/// </summary>
/// <param name="handle">cufftHandle object</param>
/// <param name="nx">The transform size in the X dimension (number of rows)</param>
/// <param name="ny">The transform size in the Y dimension (number of columns)</param>
/// <param name="type">The transform data type (e.g., C2R for complex to real)</param>
/// <param name="mode">The <see cref="Compatibility"/> option to be used</param>
/// <param name="size"></param>
public CudaFFTPlan2D(cufftHandle handle, int nx, int ny, cufftType type, Compatibility mode, ref SizeT size)
: this(handle, nx, ny, type, ref size)
{
SetCompatibilityMode(mode);
}
/// <summary>
/// Creates a new 1D FFT plan (new API)
/// </summary>
/// <param name="handle">cufftHandle object</param>
/// <param name="nx">The transform size (e.g., 256 for a 256-point FFT)</param>
/// <param name="type">The transform data type (e.g., C2C for complex to complex)</param>
/// <param name="batch">Number of transforms of size nx</param>
/// <param name="stream">A valid CUDA stream created with cudaStreamCreate() (or 0 for the default stream)</param>
/// <param name="size"></param>
/// <param name="autoAllocate">indicates that the caller intends to allocate and manage
/// work areas for plans that have been generated.</param>
public CudaFFTPlan1D(cufftHandle handle, int nx, cufftType type, int batch, CUstream stream, ref SizeT size, bool autoAllocate)
: this(handle, nx, type, batch, ref size)
{
SetStream(stream);
SetAutoAllocation(autoAllocate);
}
/// <summary>
/// Creates a new 2D FFT plan (new API)
/// </summary>
/// <param name="handle">cufftHandle object</param>
/// <param name="nx">The transform size in the X dimension (number of rows)</param>
/// <param name="ny">The transform size in the Y dimension (number of columns)</param>
/// <param name="type">The transform data type (e.g., C2R for complex to real)</param>
/// <param name="stream">A valid CUDA stream created with cudaStreamCreate() (or 0 for the default stream)</param>
/// <param name="autoAllocate">indicates that the caller intends to allocate and manage
/// work areas for plans that have been generated.</param>
public CudaFFTPlan2D(cufftHandle handle, int nx, int ny, cufftType type, CUstream stream, bool autoAllocate)
: this(handle, nx, ny, type)
{
SetStream(stream);
SetAutoAllocation(autoAllocate);
}
public static extern cufftResult cufftEstimate3d(int nx, int ny, int nz,
cufftType type,
ref SizeT workSize);
/// <summary>
/// Creates a new 2D FFT plan (new API)
/// </summary>
/// <param name="handle">cufftHandle object</param>
/// <param name="nx">The transform size in the X dimension (number of rows)</param>
/// <param name="ny">The transform size in the Y dimension (number of columns)</param>
/// <param name="type">The transform data type (e.g., C2R for complex to real)</param>
/// <param name="stream">A valid CUDA stream created with cudaStreamCreate() (or 0 for the default stream)</param>
/// <param name="mode">The <see cref="Compatibility"/> option to be used</param>
/// <param name="size"></param>
/// <param name="autoAllocate">indicates that the caller intends to allocate and manage
/// work areas for plans that have been generated.</param>
public CudaFFTPlan2D(cufftHandle handle, int nx, int ny, cufftType type, CUstream stream, Compatibility mode, ref SizeT size, bool autoAllocate)
: this(handle, nx, ny, type, ref size)
{
SetStream(stream);
SetCompatibilityMode(mode);
SetAutoAllocation(autoAllocate);
}
public static extern cufftResult cufftGetSize1d(cufftHandle handle,
int nx,
cufftType type,
int batch,
ref SizeT workSize);
/// <summary>
/// Creates a new 1D FFT plan (new API)
/// </summary>
/// <param name="handle">cufftHandle object</param>
/// <param name="nx">The transform size (e.g., 256 for a 256-point FFT)</param>
/// <param name="type">The transform data type (e.g., C2C for complex to complex)</param>
/// <param name="batch">Number of transforms of size nx</param>
/// <param name="autoAllocate">indicates that the caller intends to allocate and manage
/// work areas for plans that have been generated.</param>
public CudaFFTPlan1D(cufftHandle handle, int nx, cufftType type, int batch, bool autoAllocate)
: this(handle, nx, type, batch)
{
SetAutoAllocation(autoAllocate);
}
public static extern cufftResult cufftGetSizeMany(cufftHandle handle,
int rank, [In] int[] n, [In] int[] inembed, [In] int istride, [In] int idist,
[In] int[] onembed, [In] int ostride, [In] int odist,
cufftType type, int batch, ref SizeT workArea);
/// <summary>
/// Creates a new 2D FFT plan (old API)
/// </summary>
/// <param name="nx">The transform size in the X dimension (number of rows)</param>
/// <param name="ny">The transform size in the Y dimension (number of columns)</param>
/// <param name="type">The transform data type (e.g., C2R for complex to real)</param>
/// <param name="stream">A valid CUDA stream created with cudaStreamCreate() (or 0 for the default stream)</param>
/// <param name="mode">The <see cref="Compatibility"/> option to be used</param>
public CudaFFTPlan2D(int nx, int ny, cufftType type, CUstream stream, Compatibility mode)
: this(nx, ny, type)
{
SetStream(stream);
SetCompatibilityMode(mode);
}
public static extern cufftResult cufftPlan1d([In, Out] ref cufftHandle plan, [In] int nx, [In] cufftType type, [In] int batch);
public static extern cufftResult cufftMakePlan1d(cufftHandle plan,
int nx,
cufftType type,
int batch, /* deprecated - use cufftPlanMany */
ref SizeT workSize);
/// <summary>
/// Creates a new 1D FFT plan (new API)
/// </summary>
/// <param name="handle">cufftHandle object</param>
/// <param name="nx">The transform size (e.g., 256 for a 256-point FFT)</param>
/// <param name="type">The transform data type (e.g., C2C for complex to complex)</param>
/// <param name="batch">Number of transforms of size nx</param>
/// <param name="stream">A valid CUDA stream created with cudaStreamCreate() (or 0 for the default stream)</param>
/// <param name="mode">The <see cref="Compatibility"/> option to be used</param>
/// <param name="autoAllocate">indicates that the caller intends to allocate and manage
/// work areas for plans that have been generated.</param>
public CudaFFTPlan1D(cufftHandle handle, int nx, cufftType type, int batch, CUstream stream, Compatibility mode, bool autoAllocate)
: this(handle, nx, type, batch)
{
SetStream(stream);
SetCompatibilityMode(mode);
SetAutoAllocation(autoAllocate);
}
public static extern cufftResult cufftMakePlan3d(cufftHandle plan,
int nx, int ny, int nz,
cufftType type,
ref SizeT workSize);
/// <summary>
/// Creates a new 1D FFT plan (new API)
/// </summary>
/// <param name="handle">cufftHandle object</param>
/// <param name="nx">The transform size (e.g., 256 for a 256-point FFT)</param>
/// <param name="type">The transform data type (e.g., C2C for complex to complex)</param>
/// <param name="batch">Number of transforms of size nx</param>
/// <param name="stream">A valid CUDA stream created with cudaStreamCreate() (or 0 for the default stream)</param>
/// <param name="autoAllocate">indicates that the caller intends to allocate and manage
/// work areas for plans that have been generated.</param>
public CudaFFTPlan1D(cufftHandle handle, int nx, cufftType type, int batch, CUstream stream, bool autoAllocate)
: this(handle, nx, type, batch)
{
SetStream(stream);
SetAutoAllocation(autoAllocate);
}
public static extern cufftResult cufftEstimate1d(int nx,
cufftType type,
int batch, /* deprecated - use cufftPlanMany */
ref SizeT workSize);
public static extern cufftResult cufftMakePlanMany(cufftHandle plan,
int rank,
[In] int[] n, [In] int[] inembed, [In] int istride, [In] int idist,
[In] int[] onembed, [In] int ostride, [In] int odist,
cufftType type,
int batch,
ref SizeT workSize);
public static extern cufftResult cufftEstimateMany(int rank,
[In] int[] n, [In] int[] inembed, [In] int istride, [In] int idist,
[In] int[] onembed, [In] int ostride, [In] int odist,
cufftType type,
int batch,
ref SizeT workSize);
public static extern cufftResult cufftMakePlanMany64(cufftHandle plan,
int rank,
[In] long[] n, [In] long[] inembed, [In] long istride, [In] long idist,
[In] long[] onembed, [In] long ostride, [In] long odist,
cufftType type,
long batch,
ref SizeT workSize);
public static extern cufftResult cufftGetSize3d(cufftHandle handle,
int nx, int ny, int nz,
cufftType type,
ref SizeT workSize);
public static extern cufftResult cufftEstimate1d(int nx,
cufftType type,
int batch, /* deprecated - use cufftPlanMany */
ref SizeT workSize);
public static extern cufftResult cufftGetSizeMany64(cufftHandle plan,
long rank, [In] long[] n, [In] long[] inembed, [In] long istride, [In] long idist,
[In] long[] onembed, [In] long ostride, [In] long odist,
cufftType type, long batch, ref SizeT workArea);
public static extern cufftResult cufftEstimate3d(int nx, int ny, int nz,
cufftType type,
ref SizeT workSize);
public static extern cufftResult cufftPlan3d([In, Out] ref cufftHandle plan, [In] int nx, [In] int ny, [In] int nz, [In] cufftType type);
public static extern cufftResult cufftEstimateMany(int rank,
[In] int[] n, [In] int[] inembed, [In] int istride, [In] int idist,
[In] int[] onembed, [In] int ostride, [In] int odist,
cufftType type,
int batch,
ref SizeT workSize);
