Data.Array.Accelerate.CUFFT.Batched

Transformations of collections of datasets.

Documentation

type Transform sh a b = Acc (Array sh a) -> Acc (Array sh b)

transform :: (Shape sh, Slice sh, Real e) => Handle (sh :. Int) e a b -> Transform (sh :. Int) a b

The implementation works on all arrays of rank less than or equal to 3. The result is un-normalised.

data Handle sh e a b

plan1D :: (Shape sh, Slice sh, Elt e, Real e) => PTX -> Mode (Batch1 sh) e a b -> Batch1 sh -> IO (Handle (Batch1 sh) e a b)

The plan must be created in the PTX target where transform is executed. That is, if using cuFFT you always have to use a run*With function.

plan2D :: (Shape sh, Slice sh, Elt e, Real e) => PTX -> Mode (Batch2 sh) e a b -> Batch2 sh -> IO (Handle (Batch2 sh) e a b)

plan3D :: (Shape sh, Slice sh, Elt e, Real e) => PTX -> Mode (Batch3 sh) e a b -> Batch3 sh -> IO (Handle (Batch3 sh) e a b)

class (RealFloat e, RealFloat e, FromIntegral Int e) => Real e

Minimal complete definition

switch

Instances

Real Double

Methods

switch :: f Float -> f Double -> f Double

Real Float

Methods

switch :: f Float -> f Double -> f Float

data Mode sh e a b

forwardComplex :: (Shape sh, Slice sh, Real e) => Mode sh e (Complex e) (Complex e)

inverseComplex :: (Shape sh, Slice sh, Real e) => Mode sh e (Complex e) (Complex e)

forwardReal :: (Shape sh, Slice sh, Real e) => Mode (sh :. Int) e e (Complex e)

In contrast to plain CUFFT functions the data is redundant. That is, an array of shape sh is transformed to an array of shape sh. This way, all dimensions of an array are handled the same way. Chances are good, that the internal post processing is fused with following array operations and thus the redundant data will not be stored in a manifest array.

inverseReal :: (Shape sh, Slice sh, Real e) => Mode (sh :. Int) e (Complex e) e

type Batch0 sh = sh

type Batch1 sh = Batch0 sh :. Int

type Batch2 sh = Batch1 sh :. Int

type Batch3 sh = Batch2 sh :. Int

getBestTarget :: IO PTX