This file is indexed.

/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