/usr/lib/python2.7/dist-packages/gpyfft-0.7.0.egg-info/PKG-INFO is in python-gpyfft 0.7.0-1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 | Metadata-Version: 1.0
Name: gpyfft
Version: 0.7.0
Summary: A Python wrapper for the OpenCL FFT library clFFT
Home-page: https://github.com/geggo/gpyfft
Author: Gregor Thalhammer
Author-email: gregor.thalhammer@gmail.com
License: LGPL
Description-Content-Type: UNKNOWN
Description: gpyfft
======
A Python wrapper for the OpenCL FFT library clFFT.
## Introduction
### clFFT
The open source library [clFFT] implements FFT for running on a GPU via OpenCL. Some highlights are:
* batched 1D, 2D, and 3D transforms
* supports many transform sizes (any combinatation of powers of 2,3,5,7,11, and 13)
* flexible memory layout
* single and double precisions
* complex and real-to-complex transforms
* supports injecting custom code for data pre- and post-processing
### gpyfft
This python wrapper is designed to tightly integrate with [PyOpenCL]. It consists of a low-level Cython based wrapper with an interface similar to the underlying C library. On top of that it offers a high-level interface designed to work on data contained in instances of `pyopencl.array.Array`, a numpy work-alike array class for GPU computations. The high-level interface takes some inspiration from [pyFFTW]. For details of the high-level interface see [fft.py].
## Status
The low lever interface is complete (more or less), the high-level interface is not yet settled and likely to change in future. Features to come (not yet implemented in the high-level interface):
### work done
- low level wrapper (mostly) completed
- high level wrapper
* complex-to-complex transform, in- and out-of-place
* real-to-complex transform (out-of-place)
* complex-to-real transform (out-of-place)
* single precision
* double precision
* interleaved data
* support injecting custom OpenCL code (pre and post callbacks)
* accept pyopencl arrays with non-zero offsets (Syam Gadde)
## Basic usage
Here we describe a simple example of performing a batch of 2D complex-to-complex FFT transforms on the GPU, using the high-level interface of gpyfft. The full source code of this example ist contained in [simple\_example.py], which is the essence of [benchmark.py].
Note, for testing it is recommended to start [simple\_example.py] from the command line, so you have the possibility to interactively choose an OpenCL context (otherwise, e.g. when using an IPython, you are not asked end might end up with a CPU device, which is prone to fail).
imports:
``` python
import numpy as np
import pyopencl as cl
import pyopencl.array as cla
from gpyfft.fft import FFT```
initialize GPU:
``` python
context = cl.create_some_context()
queue = cl.CommandQueue(context)
```
initialize memory (on host and GPU). In this example we want to perform in parallel four 2D FFTs for 1024x1024 single precision data.
``` python
data_host = np.zeros((4, 1024, 1024), dtype = np.complex64)
#data_host[:] = some_useful_data
data_gpu = cla.to_device(queue, data_host)```
create FFT transform plan for batched inline 2D transform along second two axes.
``` python
transform = FFT(context, queue, data_gpu, axes = (2, 1))
```
If you want an out-of-place transform, provide the output array as additional argument after the input data.
Start the work and wait until it is finished (Note that enqueu() returns a tuple of events)
``` python
event, = transform.enqueue()
event.wait()
```
Read back the data from the GPU to the host
``` python
result_host = data_gpu.get()
```
[clFFT]: https://github.com/clMathLibraries/clFFT
[pyFFTW]: https://github.com/hgomersall/pyFFTW
[PyOpenCL]: https://mathema.tician.de/software/pyopencl
[fft.py]: gpyfft/fft.py
[pyfft]: http://github.com/Manticore/pyfft
[simple\_example.py]: examples/simple_example.py
[benchmark.py]: gpyfft/benchmark.py
Platform: UNKNOWN
|