accelerate-0.12.0.0: An embedded language for accelerated array processing

Portabilitynon-portable (GHC extensions)
Stabilityexperimental
MaintainerManuel M T Chakravarty <chak@cse.unsw.edu.au>
Safe HaskellNone

Data.Array.Accelerate

Contents

Description

This module defines an embedded language of array computations for high-performance computing. Computations on multi-dimensional, regular arrays are expressed in the form of parameterised collective operations (such as maps, reductions, and permutations). These computations are online compiled and executed on a range of architectures.

Abstract interface

The types representing array computations are only exported abstractly — i.e., client code can generate array computations and submit them for for execution, but it cannot inspect these computations. This is to allow for more flexibility for future extensions of this library.

Code execution

Access to the various backends is via a run function in backend-specific toplevel modules. Currently, we have the following:

Synopsis

Scalar element types

data Int

A fixed-precision integer type with at least the range [-2^29 .. 2^29-1]. The exact range for a given implementation can be determined by using minBound and maxBound from the Bounded class.

Instances

Bounded Int 
Enum Int 
Eq Int 
Integral Int 
Num Int 
Ord Int 
Read Int 
Real Int 
Show Int 
Ix Int 
Typeable Int 
Generic Int 
Storable Int 
Bits Int 
IsScalar Int 
IsBounded Int 
IsNum Int 
IsIntegral Int 
ArrayElt Int 
Elt Int 
IArray UArray Int 
Lift Exp Int 
Elt e => Stencil DIM1 e (e, e, e) 
Elt e => Stencil DIM1 e (Exp e, Exp e, Exp e) 
Elt e => Stencil DIM1 e (e, e, e, e, e) 
Elt e => Stencil DIM1 e (Exp e, Exp e, Exp e, Exp e, Exp e) 
Elt e => Stencil DIM1 e (e, e, e, e, e, e, e) 
Elt e => Stencil DIM1 e (Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e) 
Elt e => Stencil DIM1 e (e, e, e, e, e, e, e, e, e) 
Elt e => Stencil DIM1 e (Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e) 
(Slice (Plain ix), Lift Exp ix) => Lift Exp (:. ix Int) 
Shape sh => Elt (Any (:. sh Int)) 
MArray (STUArray s) Int (ST s) 
Slice sl => Slice (sl, Int) 
Shape sh => Shape (sh, Int) 
Slice sl => Slice (:. sl Int) 
Shape sh => Shape (:. sh Int) 
(Stencil (:. sh Int) a row1, Stencil (:. sh Int) a row2, Stencil (:. sh Int) a row3) => Stencil (:. (:. sh Int) Int) a (row1, row2, row3) 
(Stencil (:. sh Int) a row2, Stencil (:. sh Int) a row1, Stencil (:. sh Int) a row0) => Stencil (:. (:. sh Int) Int) a (row2, row1, row0) 
(Stencil (:. sh Int) a row1, Stencil (:. sh Int) a row2, Stencil (:. sh Int) a row3, Stencil (:. sh Int) a row4, Stencil (:. sh Int) a row5) => Stencil (:. (:. sh Int) Int) a (row1, row2, row3, row4, row5) 
(Stencil (:. sh Int) a row1, Stencil (:. sh Int) a row2, Stencil (:. sh Int) a row3, Stencil (:. sh Int) a row4, Stencil (:. sh Int) a row5) => Stencil (:. (:. sh Int) Int) a (row1, row2, row3, row4, row5) 
(Stencil (:. sh Int) a row1, Stencil (:. sh Int) a row2, Stencil (:. sh Int) a row3, Stencil (:. sh Int) a row4, Stencil (:. sh Int) a row5, Stencil (:. sh Int) a row6, Stencil (:. sh Int) a row7) => Stencil (:. (:. sh Int) Int) a (row1, row2, row3, row4, row5, row6, row7) 
(Stencil (:. sh Int) a row1, Stencil (:. sh Int) a row2, Stencil (:. sh Int) a row3, Stencil (:. sh Int) a row4, Stencil (:. sh Int) a row5, Stencil (:. sh Int) a row6, Stencil (:. sh Int) a row7) => Stencil (:. (:. sh Int) Int) a (row1, row2, row3, row4, row5, row6, row7) 
(Stencil (:. sh Int) a row1, Stencil (:. sh Int) a row2, Stencil (:. sh Int) a row3, Stencil (:. sh Int) a row4, Stencil (:. sh Int) a row5, Stencil (:. sh Int) a row6, Stencil (:. sh Int) a row7, Stencil (:. sh Int) a row8, Stencil (:. sh Int) a row9) => Stencil (:. (:. sh Int) Int) a (row1, row2, row3, row4, row5, row6, row7, row8, row9) 
(Stencil (:. sh Int) a row1, Stencil (:. sh Int) a row2, Stencil (:. sh Int) a row3, Stencil (:. sh Int) a row4, Stencil (:. sh Int) a row5, Stencil (:. sh Int) a row6, Stencil (:. sh Int) a row7, Stencil (:. sh Int) a row8, Stencil (:. sh Int) a row9) => Stencil (:. (:. sh Int) Int) a (row1, row2, row3, row4, row5, row6, row7, row8, row9) 

data Word

A Word is an unsigned integral type, with the same size as Int.

data Float

Single-precision floating point numbers. It is desirable that this type be at least equal in range and precision to the IEEE single-precision type.

data Double

Double-precision floating point numbers. It is desirable that this type be at least equal in range and precision to the IEEE double-precision type.

data Char

The character type Char is an enumeration whose values represent Unicode (or equivalently ISO/IEC 10646) characters (see http://www.unicode.org/ for details). This set extends the ISO 8859-1 (Latin-1) character set (the first 256 characters), which is itself an extension of the ASCII character set (the first 128 characters). A character literal in Haskell has type Char.

To convert a Char to or from the corresponding Int value defined by Unicode, use toEnum and fromEnum from the Enum class respectively (or equivalently ord and chr).

Scalar type classes

class IsNonNum a

Non-numeric types

Array data types

class (Typeable (ArrRepr a), Typeable (ArrRepr' a), Typeable a) => Arrays a

Instances

Arrays () 
(Arrays b, Arrays a) => Arrays (b, a) 
(Shape sh, Elt e) => Arrays (Array sh e) 
(Arrays c, Arrays b, Arrays a) => Arrays (c, b, a) 
(Arrays d, Arrays c, Arrays b, Arrays a) => Arrays (d, c, b, a) 
(Arrays e, Arrays d, Arrays c, Arrays b, Arrays a) => Arrays (e, d, c, b, a) 
(Arrays f, Arrays e, Arrays d, Arrays c, Arrays b, Arrays a) => Arrays (f, e, d, c, b, a) 
(Arrays g, Arrays f, Arrays e, Arrays d, Arrays c, Arrays b, Arrays a) => Arrays (g, f, e, d, c, b, a) 
(Arrays h, Arrays g, Arrays f, Arrays e, Arrays d, Arrays c, Arrays b, Arrays a) => Arrays (h, g, f, e, d, c, b, a) 
(Arrays i, Arrays h, Arrays g, Arrays f, Arrays e, Arrays d, Arrays c, Arrays b, Arrays a) => Arrays (i, h, g, f, e, d, c, b, a) 

data Array sh e

Multi-dimensional arrays for array processing

  • If device and host memory are separate, arrays will be transferred to the device when necessary (if possible asynchronously and in parallel with other tasks) and cached on the device if sufficient memory is available.

Instances

Typeable2 Array 
(Shape sh, Elt e) => Lift Acc (Array sh e) 
Show (Array sh e) 
(Shape sh, Elt e) => Arrays (Array sh e) 
Delayable (Array sh e) 

type Scalar e = Array DIM0 e

Scalars

type Vector e = Array DIM1 e

Vectors

type Segments i = Vector i

Segment descriptor (vector of segment lengths)

To represent nested one-dimensional arrays, we use a flat array of data values in conjunction with a segment descriptor, which stores the lengths of the subarrays.

Array element types

class (Show a, Typeable a, Typeable (EltRepr a), Typeable (EltRepr' a), ArrayElt (EltRepr a), ArrayElt (EltRepr' a)) => Elt a

Class that characterises the types of values that can be array elements, and hence, appear in scalar Accelerate expressions.

Instances

Elt Bool 
Elt Char 
Elt Double 
Elt Float 
Elt Int 
Elt Int8 
Elt Int16 
Elt Int32 
Elt Int64 
Elt Word 
Elt Word8 
Elt Word16 
Elt Word32 
Elt Word64 
Elt () 
Elt All 
Elt Z 
Shape sh => Elt (Any (:. sh Int)) 
Elt (Any Z) 
(Elt a, Elt b) => Elt (a, b) 
(Elt t, Elt h) => Elt (:. t h) 
(Elt a, Elt b, Elt c) => Elt (a, b, c) 
(Elt a, Elt b, Elt c, Elt d) => Elt (a, b, c, d) 
(Elt a, Elt b, Elt c, Elt d, Elt e) => Elt (a, b, c, d, e) 
(Elt a, Elt b, Elt c, Elt d, Elt e, Elt f) => Elt (a, b, c, d, e, f) 
(Elt a, Elt b, Elt c, Elt d, Elt e, Elt f, Elt g) => Elt (a, b, c, d, e, f, g) 
(Elt a, Elt b, Elt c, Elt d, Elt e, Elt f, Elt g, Elt h) => Elt (a, b, c, d, e, f, g, h) 
(Elt a, Elt b, Elt c, Elt d, Elt e, Elt f, Elt g, Elt h, Elt i) => Elt (a, b, c, d, e, f, g, h, i) 

Array shapes & indices

data Z

Array indices are snoc type lists. For example, the type of a rank-2 array index is Z :.Int :. Int.

Rank-0 index

Constructors

Z 

Instances

Show Z 
Typeable Z 
Slice Z 
Shape Z 
Elt Z 
Unlift Exp Z 
Lift Exp Z 
Elt e => Stencil DIM1 e (e, e, e) 
Elt e => Stencil DIM1 e (Exp e, Exp e, Exp e) 
Elt e => Stencil DIM1 e (e, e, e, e, e) 
Elt e => Stencil DIM1 e (Exp e, Exp e, Exp e, Exp e, Exp e) 
Elt e => Stencil DIM1 e (e, e, e, e, e, e, e) 
Elt e => Stencil DIM1 e (Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e) 
Elt e => Stencil DIM1 e (e, e, e, e, e, e, e, e, e) 
Elt e => Stencil DIM1 e (Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e) 
Elt (Any Z) 

data tail :. head

Increase an index rank by one dimension

Constructors

tail :. head 

Instances

Typeable2 :. 
Elt e => Stencil DIM1 e (e, e, e) 
Elt e => Stencil DIM1 e (Exp e, Exp e, Exp e) 
Elt e => Stencil DIM1 e (e, e, e, e, e) 
Elt e => Stencil DIM1 e (Exp e, Exp e, Exp e, Exp e, Exp e) 
Elt e => Stencil DIM1 e (e, e, e, e, e, e, e) 
Elt e => Stencil DIM1 e (Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e) 
Elt e => Stencil DIM1 e (e, e, e, e, e, e, e, e, e) 
Elt e => Stencil DIM1 e (Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e) 
(Elt e, Slice (Plain ix), Unlift Exp ix) => Unlift Exp (:. ix (Exp e)) 
(Elt e, Slice (Plain ix), Lift Exp ix) => Lift Exp (:. ix (Exp e)) 
(Slice (Plain ix), Lift Exp ix) => Lift Exp (:. ix All) 
(Slice (Plain ix), Lift Exp ix) => Lift Exp (:. ix Int) 
Shape sh => Elt (Any (:. sh Int)) 
(Show tail, Show head) => Show (:. tail head) 
Slice sl => Slice (:. sl Int) 
Slice sl => Slice (:. sl All) 
Shape sh => Shape (:. sh Int) 
(Elt t, Elt h) => Elt (:. t h) 
(Stencil (:. sh Int) a row1, Stencil (:. sh Int) a row2, Stencil (:. sh Int) a row3) => Stencil (:. (:. sh Int) Int) a (row1, row2, row3) 
(Stencil (:. sh Int) a row2, Stencil (:. sh Int) a row1, Stencil (:. sh Int) a row0) => Stencil (:. (:. sh Int) Int) a (row2, row1, row0) 
(Stencil (:. sh Int) a row1, Stencil (:. sh Int) a row2, Stencil (:. sh Int) a row3, Stencil (:. sh Int) a row4, Stencil (:. sh Int) a row5) => Stencil (:. (:. sh Int) Int) a (row1, row2, row3, row4, row5) 
(Stencil (:. sh Int) a row1, Stencil (:. sh Int) a row2, Stencil (:. sh Int) a row3, Stencil (:. sh Int) a row4, Stencil (:. sh Int) a row5) => Stencil (:. (:. sh Int) Int) a (row1, row2, row3, row4, row5) 
(Stencil (:. sh Int) a row1, Stencil (:. sh Int) a row2, Stencil (:. sh Int) a row3, Stencil (:. sh Int) a row4, Stencil (:. sh Int) a row5, Stencil (:. sh Int) a row6, Stencil (:. sh Int) a row7) => Stencil (:. (:. sh Int) Int) a (row1, row2, row3, row4, row5, row6, row7) 
(Stencil (:. sh Int) a row1, Stencil (:. sh Int) a row2, Stencil (:. sh Int) a row3, Stencil (:. sh Int) a row4, Stencil (:. sh Int) a row5, Stencil (:. sh Int) a row6, Stencil (:. sh Int) a row7) => Stencil (:. (:. sh Int) Int) a (row1, row2, row3, row4, row5, row6, row7) 
(Stencil (:. sh Int) a row1, Stencil (:. sh Int) a row2, Stencil (:. sh Int) a row3, Stencil (:. sh Int) a row4, Stencil (:. sh Int) a row5, Stencil (:. sh Int) a row6, Stencil (:. sh Int) a row7, Stencil (:. sh Int) a row8, Stencil (:. sh Int) a row9) => Stencil (:. (:. sh Int) Int) a (row1, row2, row3, row4, row5, row6, row7, row8, row9) 
(Stencil (:. sh Int) a row1, Stencil (:. sh Int) a row2, Stencil (:. sh Int) a row3, Stencil (:. sh Int) a row4, Stencil (:. sh Int) a row5, Stencil (:. sh Int) a row6, Stencil (:. sh Int) a row7, Stencil (:. sh Int) a row8, Stencil (:. sh Int) a row9) => Stencil (:. (:. sh Int) Int) a (row1, row2, row3, row4, row5, row6, row7, row8, row9) 

class (Elt sh, Elt (Any sh), Shape (EltRepr sh)) => Shape sh

Shapes and indices of multi-dimensional arrays

Instances

Shape Z 
Shape sh => Shape (:. sh Int) 

data All

Marker for entire dimensions in slice descriptors

Constructors

All 

Instances

Show All 
Typeable All 
Elt All 
(Slice (Plain ix), Lift Exp ix) => Lift Exp (:. ix All) 
Slice sl => Slice (:. sl All) 

data Any sh

Marker for arbitrary shapes in slice descriptors

Constructors

Any 

Instances

Typeable1 Any 
Shape sh => Lift Exp (Any sh) 
Show (Any sh) 
Shape sh => Slice (Any sh) 
Shape sh => Elt (Any (:. sh Int)) 
Elt (Any Z) 

class (Elt sl, Shape (SliceShape sl), Shape (CoSliceShape sl), Shape (FullShape sl)) => Slice sl where

Slices, aka generalised indices, as n-tuples and mappings of slice indices to slices, co-slices, and slice dimensions

Associated Types

type SliceShape sl :: *

type CoSliceShape sl :: *

type FullShape sl :: *

Methods

sliceIndex :: sl -> SliceIndex (EltRepr sl) (EltRepr (SliceShape sl)) (EltRepr (CoSliceShape sl)) (EltRepr (FullShape sl))

Instances

Slice Z 
Shape sh => Slice (Any sh) 
Slice sl => Slice (:. sl Int) 
Slice sl => Slice (:. sl All) 

type DIM0 = Z

type DIM1 = DIM0 :. Int

type DIM2 = DIM1 :. Int

type DIM3 = DIM2 :. Int

type DIM4 = DIM3 :. Int

type DIM5 = DIM4 :. Int

type DIM6 = DIM5 :. Int

type DIM7 = DIM6 :. Int

type DIM8 = DIM7 :. Int

type DIM9 = DIM8 :. Int

Operations to use Accelerate arrays from plain Haskell

arrayDim :: Shape sh => sh -> Int

arrayShape :: Shape sh => Array sh e -> sh

Array shape in plain Haskell code

arraySize :: Shape sh => sh -> Int

indexArray :: Array sh e -> sh -> e

Array indexing in plain Haskell code

fromIArray :: (EltRepr ix ~ EltRepr sh, IArray a e, Ix ix, Shape sh, Elt ix, Elt e) => a ix e -> Array sh e

Convert an IArray to an accelerated array.

toIArray :: (EltRepr ix ~ EltRepr sh, IArray a e, Ix ix, Shape sh, Elt ix, Elt e) => Array sh e -> a ix e

Convert an accelerated array to an IArray

fromList :: (Shape sh, Elt e) => sh -> [e] -> Array sh e

Convert a list (with elements in row-major order) to an accelerated array.

toList :: forall sh e. Array sh e -> [e]

Convert an accelerated array to a list in row-major order.

The Accelerate language

Array and scalar expressions

data Acc a

Array-valued collective computations

Instances

Typeable1 Acc 
Lift Acc (Acc a) 
(Arrays a, Arrays b) => Unlift Acc (Acc a, Acc b) 
(Lift Acc a, Lift Acc b, Arrays (Plain a), Arrays (Plain b)) => Lift Acc (a, b) 
(Shape sh, Elt e) => Lift Acc (Array sh e) 
(Arrays a, Arrays b, Arrays c) => Unlift Acc (Acc a, Acc b, Acc c) 
(Lift Acc a, Lift Acc b, Lift Acc c, Arrays (Plain a), Arrays (Plain b), Arrays (Plain c)) => Lift Acc (a, b, c) 
(Arrays a, Arrays b, Arrays c, Arrays d) => Unlift Acc (Acc a, Acc b, Acc c, Acc d) 
(Lift Acc a, Lift Acc b, Lift Acc c, Lift Acc d, Arrays (Plain a), Arrays (Plain b), Arrays (Plain c), Arrays (Plain d)) => Lift Acc (a, b, c, d) 
(Arrays a, Arrays b, Arrays c, Arrays d, Arrays e) => Unlift Acc (Acc a, Acc b, Acc c, Acc d, Acc e) 
(Lift Acc a, Lift Acc b, Lift Acc c, Lift Acc d, Lift Acc e, Arrays (Plain a), Arrays (Plain b), Arrays (Plain c), Arrays (Plain d), Arrays (Plain e)) => Lift Acc (a, b, c, d, e) 
(Arrays a, Arrays b, Arrays c, Arrays d, Arrays e, Arrays f) => Unlift Acc (Acc a, Acc b, Acc c, Acc d, Acc e, Acc f) 
(Lift Acc a, Lift Acc b, Lift Acc c, Lift Acc d, Lift Acc e, Lift Acc f, Arrays (Plain a), Arrays (Plain b), Arrays (Plain c), Arrays (Plain d), Arrays (Plain e), Arrays (Plain f)) => Lift Acc (a, b, c, d, e, f) 
(Arrays a, Arrays b, Arrays c, Arrays d, Arrays e, Arrays f, Arrays g) => Unlift Acc (Acc a, Acc b, Acc c, Acc d, Acc e, Acc f, Acc g) 
(Lift Acc a, Lift Acc b, Lift Acc c, Lift Acc d, Lift Acc e, Lift Acc f, Lift Acc g, Arrays (Plain a), Arrays (Plain b), Arrays (Plain c), Arrays (Plain d), Arrays (Plain e), Arrays (Plain f), Arrays (Plain g)) => Lift Acc (a, b, c, d, e, f, g) 
(Arrays a, Arrays b, Arrays c, Arrays d, Arrays e, Arrays f, Arrays g, Arrays h) => Unlift Acc (Acc a, Acc b, Acc c, Acc d, Acc e, Acc f, Acc g, Acc h) 
(Lift Acc a, Lift Acc b, Lift Acc c, Lift Acc d, Lift Acc e, Lift Acc f, Lift Acc g, Lift Acc h, Arrays (Plain a), Arrays (Plain b), Arrays (Plain c), Arrays (Plain d), Arrays (Plain e), Arrays (Plain f), Arrays (Plain g), Arrays (Plain h)) => Lift Acc (a, b, c, d, e, f, g, h) 
(Arrays a, Arrays b, Arrays c, Arrays d, Arrays e, Arrays f, Arrays g, Arrays h, Arrays i) => Unlift Acc (Acc a, Acc b, Acc c, Acc d, Acc e, Acc f, Acc g, Acc h, Acc i) 
(Lift Acc a, Lift Acc b, Lift Acc c, Lift Acc d, Lift Acc e, Lift Acc f, Lift Acc g, Lift Acc h, Lift Acc i, Arrays (Plain a), Arrays (Plain b), Arrays (Plain c), Arrays (Plain d), Arrays (Plain e), Arrays (Plain f), Arrays (Plain g), Arrays (Plain h), Arrays (Plain i)) => Lift Acc (a, b, c, d, e, f, g, h, i) 
Arrays arrs => Show (Acc arrs) 

data Exp t

Scalar expressions for plain array computations.

Instances

Typeable1 Exp 
Unlift Exp () 
Unlift Exp Z 
Lift Exp Bool 
Lift Exp Char 
Lift Exp Double 
Lift Exp Float 
Lift Exp Int 
Lift Exp Int8 
Lift Exp Int16 
Lift Exp Int32 
Lift Exp Int64 
Lift Exp Word 
Lift Exp Word8 
Lift Exp Word16 
Lift Exp Word32 
Lift Exp Word64 
Lift Exp () 
Lift Exp Z 
Elt e => Stencil DIM1 e (Exp e, Exp e, Exp e) 
Elt e => Stencil DIM1 e (Exp e, Exp e, Exp e, Exp e, Exp e) 
Elt e => Stencil DIM1 e (Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e) 
Elt e => Stencil DIM1 e (Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e) 
Shape sh => Lift Exp (Any sh) 
Lift Exp (Exp e) 
(Elt a, Elt b) => Unlift Exp (Exp a, Exp b) 
(Elt e, Slice (Plain ix), Unlift Exp ix) => Unlift Exp (:. ix (Exp e)) 
(Lift Exp a, Lift Exp b, Elt (Plain a), Elt (Plain b)) => Lift Exp (a, b) 
(Elt e, Slice (Plain ix), Lift Exp ix) => Lift Exp (:. ix (Exp e)) 
(Slice (Plain ix), Lift Exp ix) => Lift Exp (:. ix All) 
(Slice (Plain ix), Lift Exp ix) => Lift Exp (:. ix Int) 
(Elt a, Elt b, Elt c) => Unlift Exp (Exp a, Exp b, Exp c) 
(Lift Exp a, Lift Exp b, Lift Exp c, Elt (Plain a), Elt (Plain b), Elt (Plain c)) => Lift Exp (a, b, c) 
(Elt a, Elt b, Elt c, Elt d) => Unlift Exp (Exp a, Exp b, Exp c, Exp d) 
(Lift Exp a, Lift Exp b, Lift Exp c, Lift Exp d, Elt (Plain a), Elt (Plain b), Elt (Plain c), Elt (Plain d)) => Lift Exp (a, b, c, d) 
(Elt a, Elt b, Elt c, Elt d, Elt e) => Unlift Exp (Exp a, Exp b, Exp c, Exp d, Exp e) 
(Lift Exp a, Lift Exp b, Lift Exp c, Lift Exp d, Lift Exp e, Elt (Plain a), Elt (Plain b), Elt (Plain c), Elt (Plain d), Elt (Plain e)) => Lift Exp (a, b, c, d, e) 
(Elt a, Elt b, Elt c, Elt d, Elt e, Elt f) => Unlift Exp (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f) 
(Lift Exp a, Lift Exp b, Lift Exp c, Lift Exp d, Lift Exp e, Lift Exp f, Elt (Plain a), Elt (Plain b), Elt (Plain c), Elt (Plain d), Elt (Plain e), Elt (Plain f)) => Lift Exp (a, b, c, d, e, f) 
(Elt a, Elt b, Elt c, Elt d, Elt e, Elt f, Elt g) => Unlift Exp (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f, Exp g) 
(Lift Exp a, Lift Exp b, Lift Exp c, Lift Exp d, Lift Exp e, Lift Exp f, Lift Exp g, Elt (Plain a), Elt (Plain b), Elt (Plain c), Elt (Plain d), Elt (Plain e), Elt (Plain f), Elt (Plain g)) => Lift Exp (a, b, c, d, e, f, g) 
(Elt a, Elt b, Elt c, Elt d, Elt e, Elt f, Elt g, Elt h) => Unlift Exp (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f, Exp g, Exp h) 
(Lift Exp a, Lift Exp b, Lift Exp c, Lift Exp d, Lift Exp e, Lift Exp f, Lift Exp g, Lift Exp h, Elt (Plain a), Elt (Plain b), Elt (Plain c), Elt (Plain d), Elt (Plain e), Elt (Plain f), Elt (Plain g), Elt (Plain h)) => Lift Exp (a, b, c, d, e, f, g, h) 
(Elt a, Elt b, Elt c, Elt d, Elt e, Elt f, Elt g, Elt h, Elt i) => Unlift Exp (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f, Exp g, Exp h, Exp i) 
(Lift Exp a, Lift Exp b, Lift Exp c, Lift Exp d, Lift Exp e, Lift Exp f, Lift Exp g, Lift Exp h, Lift Exp i, Elt (Plain a), Elt (Plain b), Elt (Plain c), Elt (Plain d), Elt (Plain e), Elt (Plain f), Elt (Plain g), Elt (Plain h), Elt (Plain i)) => Lift Exp (a, b, c, d, e, f, g, h, i) 
(Elt t, IsBounded t) => Bounded (Exp t) 
(Elt t, IsScalar t) => Enum (Exp t) 
(Elt t, IsScalar t) => Eq (Exp t) 
(Elt t, IsFloating t) => Floating (Exp t) 
(Elt t, IsFloating t) => Fractional (Exp t) 
(Elt t, IsIntegral t) => Integral (Exp t) 
(Elt t, IsNum t) => Num (Exp t) 
(Elt t, IsScalar t) => Ord (Exp t) 
(Elt t, IsNum t) => Real (Exp t) 
(Elt t, IsFloating t) => RealFloat (Exp t) 
(Elt t, IsFloating t) => RealFrac (Exp t) 
Elt a => Show (Exp a) 
(Elt t, IsNum t, IsIntegral t) => Bits (Exp t) 

Stencil specification

data Boundary a

Boundary condition specification for stencil operations.

Constructors

Clamp

clamp coordinates to the extent of the array

Mirror

mirror coordinates beyond the array extent

Wrap

wrap coordinates around on each dimension

Constant a

use a constant value for outlying coordinates

Instances

Read a => Read (Boundary a) 
Show a => Show (Boundary a) 

class (Elt (StencilRepr sh stencil), Stencil sh a (StencilRepr sh stencil)) => Stencil sh a stencil

Instances

Elt e => Stencil DIM1 e (Exp e, Exp e, Exp e) 
Elt e => Stencil DIM1 e (Exp e, Exp e, Exp e, Exp e, Exp e) 
Elt e => Stencil DIM1 e (Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e) 
Elt e => Stencil DIM1 e (Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e) 
(Stencil (:. sh Int) a row2, Stencil (:. sh Int) a row1, Stencil (:. sh Int) a row0) => Stencil (:. (:. sh Int) Int) a (row2, row1, row0) 
(Stencil (:. sh Int) a row1, Stencil (:. sh Int) a row2, Stencil (:. sh Int) a row3, Stencil (:. sh Int) a row4, Stencil (:. sh Int) a row5) => Stencil (:. (:. sh Int) Int) a (row1, row2, row3, row4, row5) 
(Stencil (:. sh Int) a row1, Stencil (:. sh Int) a row2, Stencil (:. sh Int) a row3, Stencil (:. sh Int) a row4, Stencil (:. sh Int) a row5, Stencil (:. sh Int) a row6, Stencil (:. sh Int) a row7) => Stencil (:. (:. sh Int) Int) a (row1, row2, row3, row4, row5, row6, row7) 
(Stencil (:. sh Int) a row1, Stencil (:. sh Int) a row2, Stencil (:. sh Int) a row3, Stencil (:. sh Int) a row4, Stencil (:. sh Int) a row5, Stencil (:. sh Int) a row6, Stencil (:. sh Int) a row7, Stencil (:. sh Int) a row8, Stencil (:. sh Int) a row9) => Stencil (:. (:. sh Int) Int) a (row1, row2, row3, row4, row5, row6, row7, row8, row9) 

Common stencil types

type Stencil3 a = (Exp a, Exp a, Exp a)

type Stencil5 a = (Exp a, Exp a, Exp a, Exp a, Exp a)

type Stencil7 a = (Exp a, Exp a, Exp a, Exp a, Exp a, Exp a, Exp a)

type Stencil9 a = (Exp a, Exp a, Exp a, Exp a, Exp a, Exp a, Exp a, Exp a, Exp a)

Scalar introduction

constant :: Elt t => t -> Exp t

Constant scalar expression

Array construction

use :: Arrays arrays => arrays -> Acc arrays

Array inlet: makes an array available for processing using the Accelerate language; triggers asynchronous host->device transfer if necessary.

unit :: Elt e => Exp e -> Acc (Scalar e)

Scalar inlet: injects a scalar (or a tuple of scalars) into a singleton array for use in the Accelerate language.

replicate :: (Slice slix, Elt e) => Exp slix -> Acc (Array (SliceShape slix) e) -> Acc (Array (FullShape slix) e)

Replicate an array across one or more dimensions as specified by the *generalised* array index provided as the first argument.

For example, assuming arr is a vector (one-dimensional array),

 replicate (Z :.2 :.All :.3) arr

yields a three dimensional array, where arr is replicated twice across the first and three times across the third dimension.

generate :: (Shape ix, Elt a) => Exp ix -> (Exp ix -> Exp a) -> Acc (Array ix a)

Construct a new array by applying a function to each index.

For example, the following will generate a one-dimensional array (Vector) of three floating point numbers:

 generate (index1 3) (\_ -> 1.2)

Or, equivalently:

 generate (constant (Z :. (3::Int))) (\_ -> 1.2)

Finally, the following will create an array equivalent to '[1..10]':

 generate (index1 10) $ \ ix ->
          let (Z :. i) = unlift ix
          in fromIntegral i

Shape manipulation

reshape :: (Shape ix, Shape ix', Elt e) => Exp ix -> Acc (Array ix' e) -> Acc (Array ix e)

Change the shape of an array without altering its contents, where

 precondition: size ix == size ix'

Extraction of subarrays

slice :: (Slice slix, Elt e) => Acc (Array (FullShape slix) e) -> Exp slix -> Acc (Array (SliceShape slix) e)

Index an array with a *generalised* array index (supplied as the second argument). The result is a new array (possibly a singleton) containing all dimensions in their entirety.

Map-like functions

map :: (Shape ix, Elt a, Elt b) => (Exp a -> Exp b) -> Acc (Array ix a) -> Acc (Array ix b)

Apply the given function element-wise to the given array.

zipWith :: (Shape ix, Elt a, Elt b, Elt c) => (Exp a -> Exp b -> Exp c) -> Acc (Array ix a) -> Acc (Array ix b) -> Acc (Array ix c)

Apply the given binary function element-wise to the two arrays. The extent of the resulting array is the intersection of the extents of the two source arrays.

Reductions

fold :: (Shape ix, Elt a) => (Exp a -> Exp a -> Exp a) -> Exp a -> Acc (Array (ix :. Int) a) -> Acc (Array ix a)

Reduction of the innermost dimension of an array of arbitrary rank. The first argument needs to be an associative function to enable an efficient parallel implementation.

fold1 :: (Shape ix, Elt a) => (Exp a -> Exp a -> Exp a) -> Acc (Array (ix :. Int) a) -> Acc (Array ix a)

Variant of fold that requires the reduced array to be non-empty and doesn't need an default value.

foldSeg :: (Shape ix, Elt a, Elt i, IsIntegral i) => (Exp a -> Exp a -> Exp a) -> Exp a -> Acc (Array (ix :. Int) a) -> Acc (Segments i) -> Acc (Array (ix :. Int) a)

Segmented reduction along the innermost dimension. Performs one individual reduction per segment of the source array. These reductions proceed in parallel.

The source array must have at least rank 1. The Segments array determines the lengths of the logical sub-arrays, each of which is folded separately.

fold1Seg :: (Shape ix, Elt a, Elt i, IsIntegral i) => (Exp a -> Exp a -> Exp a) -> Acc (Array (ix :. Int) a) -> Acc (Segments i) -> Acc (Array (ix :. Int) a)

Variant of foldSeg that requires all segments of the reduced array to be non-empty and doesn't need a default value.

The source array must have at least rank 1. The Segments array determines the lengths of the logical sub-arrays, each of which is folded separately.

Scan functions

scanl :: Elt a => (Exp a -> Exp a -> Exp a) -> Exp a -> Acc (Vector a) -> Acc (Vector a)

List-style left-to-right scan, but with the additional restriction that the first argument needs to be an associative function to enable an efficient parallel implementation. The initial value (second argument) may be arbitrary.

scanl' :: Elt a => (Exp a -> Exp a -> Exp a) -> Exp a -> Acc (Vector a) -> (Acc (Vector a), Acc (Scalar a))

Variant of scanl, where the final result of the reduction is returned separately. Denotationally, we have

 scanl' f e arr = (crop 0 (len - 1) res, unit (res!len))
   where
     len = shape arr
     res = scanl f e arr

scanl1 :: Elt a => (Exp a -> Exp a -> Exp a) -> Acc (Vector a) -> Acc (Vector a)

List style left-to-right scan without an initial value (aka inclusive scan). Again, the first argument needs to be an associative function. Denotationally, we have

 scanl1 f e arr = crop 1 len res
   where
     len = shape arr
     res = scanl f e arr

scanr :: Elt a => (Exp a -> Exp a -> Exp a) -> Exp a -> Acc (Vector a) -> Acc (Vector a)

Right-to-left variant of scanl.

scanr' :: Elt a => (Exp a -> Exp a -> Exp a) -> Exp a -> Acc (Vector a) -> (Acc (Vector a), Acc (Scalar a))

Right-to-left variant of scanl'.

scanr1 :: Elt a => (Exp a -> Exp a -> Exp a) -> Acc (Vector a) -> Acc (Vector a)

Right-to-left variant of scanl1.

Permutations

permute

Arguments

:: (Shape ix, Shape ix', Elt a) 
=> (Exp a -> Exp a -> Exp a)

combination function

-> Acc (Array ix' a)

array of default values

-> (Exp ix -> Exp ix')

permutation

-> Acc (Array ix a)

array to be permuted

-> Acc (Array ix' a) 

Forward permutation specified by an index mapping. The result array is initialised with the given defaults and any further values that are permuted into the result array are added to the current value using the given combination function.

The combination function must be associative. Elements that are mapped to the magic value ignore by the permutation function are being dropped.

backpermute

Arguments

:: (Shape ix, Shape ix', Elt a) 
=> Exp ix'

shape of the result array

-> (Exp ix' -> Exp ix)

permutation

-> Acc (Array ix a)

source array

-> Acc (Array ix' a) 

Backward permutation

Stencil operations

stencil

Arguments

:: (Shape ix, Elt a, Elt b, Stencil ix a stencil) 
=> (stencil -> Exp b)

stencil function

-> Boundary a

boundary condition

-> Acc (Array ix a)

source array

-> Acc (Array ix b)

destination array

Map a stencil over an array. In contrast to map, the domain of a stencil function is an entire neighbourhood of each array element. Neighbourhoods are sub-arrays centred around a focal point. They are not necessarily rectangular, but they are symmetric in each dimension and have an extent of at least three in each dimensions — due to the symmetry requirement, the extent is necessarily odd. The focal point is the array position that is determined by the stencil.

For those array positions where the neighbourhood extends past the boundaries of the source array, a boundary condition determines the contents of the out-of-bounds neighbourhood positions.

stencil2

Arguments

:: (Shape ix, Elt a, Elt b, Elt c, Stencil ix a stencil1, Stencil ix b stencil2) 
=> (stencil1 -> stencil2 -> Exp c)

binary stencil function

-> Boundary a

boundary condition #1

-> Acc (Array ix a)

source array #1

-> Boundary b

boundary condition #2

-> Acc (Array ix b)

source array #2

-> Acc (Array ix c)

destination array

Map a binary stencil of an array. The extent of the resulting array is the intersection of the extents of the two source arrays.

Pipelining

(>->) :: (Arrays a, Arrays b, Arrays c) => (Acc a -> Acc b) -> (Acc b -> Acc c) -> Acc a -> Acc c

Pipelining of two array computations.

Denotationally, we have

 (acc1 >-> acc2) arrs = let tmp = acc1 arrs in acc2 tmp

Operationally, the array computations acc1 and acc2 will not share any sub-computations, neither between each other nor with the environment. This makes them truly independent stages that only communicate by way of the result of acc1 which is being fed as an argument to acc2.

Array-level flow-control

cond

Arguments

:: Arrays a 
=> Exp Bool

if-condition

-> Acc a

then-array

-> Acc a

else-array

-> Acc a 

An array-level if-then-else construct.

(?|) :: Arrays a => Exp Bool -> (Acc a, Acc a) -> Acc a

Infix version of cond.

Lifting and unlifting

class Lift c e where

Associated Types

type Plain e

Methods

lift :: e -> c (Plain e)

Lift the given value into a surface type c --- either Exp for scalar expressions or Acc for array computations. The value may already contain subexpressions in c.

Instances

Lift Exp Bool 
Lift Exp Char 
Lift Exp Double 
Lift Exp Float 
Lift Exp Int 
Lift Exp Int8 
Lift Exp Int16 
Lift Exp Int32 
Lift Exp Int64 
Lift Exp Word 
Lift Exp Word8 
Lift Exp Word16 
Lift Exp Word32 
Lift Exp Word64 
Lift Exp () 
Lift Exp Z 
Shape sh => Lift Exp (Any sh) 
Lift Exp (Exp e) 
Lift Acc (Acc a) 
(Lift Exp a, Lift Exp b, Elt (Plain a), Elt (Plain b)) => Lift Exp (a, b) 
(Elt e, Slice (Plain ix), Lift Exp ix) => Lift Exp (:. ix (Exp e)) 
(Slice (Plain ix), Lift Exp ix) => Lift Exp (:. ix All) 
(Slice (Plain ix), Lift Exp ix) => Lift Exp (:. ix Int) 
(Lift Acc a, Lift Acc b, Arrays (Plain a), Arrays (Plain b)) => Lift Acc (a, b) 
(Shape sh, Elt e) => Lift Acc (Array sh e) 
(Lift Exp a, Lift Exp b, Lift Exp c, Elt (Plain a), Elt (Plain b), Elt (Plain c)) => Lift Exp (a, b, c) 
(Lift Acc a, Lift Acc b, Lift Acc c, Arrays (Plain a), Arrays (Plain b), Arrays (Plain c)) => Lift Acc (a, b, c) 
(Lift Exp a, Lift Exp b, Lift Exp c, Lift Exp d, Elt (Plain a), Elt (Plain b), Elt (Plain c), Elt (Plain d)) => Lift Exp (a, b, c, d) 
(Lift Acc a, Lift Acc b, Lift Acc c, Lift Acc d, Arrays (Plain a), Arrays (Plain b), Arrays (Plain c), Arrays (Plain d)) => Lift Acc (a, b, c, d) 
(Lift Exp a, Lift Exp b, Lift Exp c, Lift Exp d, Lift Exp e, Elt (Plain a), Elt (Plain b), Elt (Plain c), Elt (Plain d), Elt (Plain e)) => Lift Exp (a, b, c, d, e) 
(Lift Acc a, Lift Acc b, Lift Acc c, Lift Acc d, Lift Acc e, Arrays (Plain a), Arrays (Plain b), Arrays (Plain c), Arrays (Plain d), Arrays (Plain e)) => Lift Acc (a, b, c, d, e) 
(Lift Exp a, Lift Exp b, Lift Exp c, Lift Exp d, Lift Exp e, Lift Exp f, Elt (Plain a), Elt (Plain b), Elt (Plain c), Elt (Plain d), Elt (Plain e), Elt (Plain f)) => Lift Exp (a, b, c, d, e, f) 
(Lift Acc a, Lift Acc b, Lift Acc c, Lift Acc d, Lift Acc e, Lift Acc f, Arrays (Plain a), Arrays (Plain b), Arrays (Plain c), Arrays (Plain d), Arrays (Plain e), Arrays (Plain f)) => Lift Acc (a, b, c, d, e, f) 
(Lift Exp a, Lift Exp b, Lift Exp c, Lift Exp d, Lift Exp e, Lift Exp f, Lift Exp g, Elt (Plain a), Elt (Plain b), Elt (Plain c), Elt (Plain d), Elt (Plain e), Elt (Plain f), Elt (Plain g)) => Lift Exp (a, b, c, d, e, f, g) 
(Lift Acc a, Lift Acc b, Lift Acc c, Lift Acc d, Lift Acc e, Lift Acc f, Lift Acc g, Arrays (Plain a), Arrays (Plain b), Arrays (Plain c), Arrays (Plain d), Arrays (Plain e), Arrays (Plain f), Arrays (Plain g)) => Lift Acc (a, b, c, d, e, f, g) 
(Lift Exp a, Lift Exp b, Lift Exp c, Lift Exp d, Lift Exp e, Lift Exp f, Lift Exp g, Lift Exp h, Elt (Plain a), Elt (Plain b), Elt (Plain c), Elt (Plain d), Elt (Plain e), Elt (Plain f), Elt (Plain g), Elt (Plain h)) => Lift Exp (a, b, c, d, e, f, g, h) 
(Lift Acc a, Lift Acc b, Lift Acc c, Lift Acc d, Lift Acc e, Lift Acc f, Lift Acc g, Lift Acc h, Arrays (Plain a), Arrays (Plain b), Arrays (Plain c), Arrays (Plain d), Arrays (Plain e), Arrays (Plain f), Arrays (Plain g), Arrays (Plain h)) => Lift Acc (a, b, c, d, e, f, g, h) 
(Lift Exp a, Lift Exp b, Lift Exp c, Lift Exp d, Lift Exp e, Lift Exp f, Lift Exp g, Lift Exp h, Lift Exp i, Elt (Plain a), Elt (Plain b), Elt (Plain c), Elt (Plain d), Elt (Plain e), Elt (Plain f), Elt (Plain g), Elt (Plain h), Elt (Plain i)) => Lift Exp (a, b, c, d, e, f, g, h, i) 
(Lift Acc a, Lift Acc b, Lift Acc c, Lift Acc d, Lift Acc e, Lift Acc f, Lift Acc g, Lift Acc h, Lift Acc i, Arrays (Plain a), Arrays (Plain b), Arrays (Plain c), Arrays (Plain d), Arrays (Plain e), Arrays (Plain f), Arrays (Plain g), Arrays (Plain h), Arrays (Plain i)) => Lift Acc (a, b, c, d, e, f, g, h, i) 

class Lift c e => Unlift c e where

Methods

unlift :: c (Plain e) -> e

Unlift the outermost constructor through the surface type. This is only possible if the constructor is fully determined by its type - i.e., it is a singleton.

Instances

Unlift Exp () 
Unlift Exp Z 
(Elt a, Elt b) => Unlift Exp (Exp a, Exp b) 
(Elt e, Slice (Plain ix), Unlift Exp ix) => Unlift Exp (:. ix (Exp e)) 
(Arrays a, Arrays b) => Unlift Acc (Acc a, Acc b) 
(Elt a, Elt b, Elt c) => Unlift Exp (Exp a, Exp b, Exp c) 
(Arrays a, Arrays b, Arrays c) => Unlift Acc (Acc a, Acc b, Acc c) 
(Elt a, Elt b, Elt c, Elt d) => Unlift Exp (Exp a, Exp b, Exp c, Exp d) 
(Arrays a, Arrays b, Arrays c, Arrays d) => Unlift Acc (Acc a, Acc b, Acc c, Acc d) 
(Elt a, Elt b, Elt c, Elt d, Elt e) => Unlift Exp (Exp a, Exp b, Exp c, Exp d, Exp e) 
(Arrays a, Arrays b, Arrays c, Arrays d, Arrays e) => Unlift Acc (Acc a, Acc b, Acc c, Acc d, Acc e) 
(Elt a, Elt b, Elt c, Elt d, Elt e, Elt f) => Unlift Exp (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f) 
(Arrays a, Arrays b, Arrays c, Arrays d, Arrays e, Arrays f) => Unlift Acc (Acc a, Acc b, Acc c, Acc d, Acc e, Acc f) 
(Elt a, Elt b, Elt c, Elt d, Elt e, Elt f, Elt g) => Unlift Exp (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f, Exp g) 
(Arrays a, Arrays b, Arrays c, Arrays d, Arrays e, Arrays f, Arrays g) => Unlift Acc (Acc a, Acc b, Acc c, Acc d, Acc e, Acc f, Acc g) 
(Elt a, Elt b, Elt c, Elt d, Elt e, Elt f, Elt g, Elt h) => Unlift Exp (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f, Exp g, Exp h) 
(Arrays a, Arrays b, Arrays c, Arrays d, Arrays e, Arrays f, Arrays g, Arrays h) => Unlift Acc (Acc a, Acc b, Acc c, Acc d, Acc e, Acc f, Acc g, Acc h) 
(Elt a, Elt b, Elt c, Elt d, Elt e, Elt f, Elt g, Elt h, Elt i) => Unlift Exp (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f, Exp g, Exp h, Exp i) 
(Arrays a, Arrays b, Arrays c, Arrays d, Arrays e, Arrays f, Arrays g, Arrays h, Arrays i) => Unlift Acc (Acc a, Acc b, Acc c, Acc d, Acc e, Acc f, Acc g, Acc h, Acc i) 

lift1 :: (Unlift Exp e1, Lift Exp e2) => (e1 -> e2) -> Exp (Plain e1) -> Exp (Plain e2)

Lift a unary function into Exp.

lift2 :: (Unlift Exp e1, Unlift Exp e2, Lift Exp e3) => (e1 -> e2 -> e3) -> Exp (Plain e1) -> Exp (Plain e2) -> Exp (Plain e3)

Lift a binary function into Exp.

ilift1 :: (Exp Int -> Exp Int) -> Exp (Z :. Int) -> Exp (Z :. Int)

Lift a unary function to a computation over rank-1 indices.

ilift2 :: (Exp Int -> Exp Int -> Exp Int) -> Exp (Z :. Int) -> Exp (Z :. Int) -> Exp (Z :. Int)

Lift a binary function to a computation over rank-1 indices.

Tuple construction and destruction

fst :: forall a b. (Elt a, Elt b) => Exp (a, b) -> Exp a

Extract the first component of a pair.

snd :: forall a b. (Elt a, Elt b) => Exp (a, b) -> Exp b

Extract the second component of a pair.

curry :: (Elt a, Elt b) => (Exp (a, b) -> Exp c) -> Exp a -> Exp b -> Exp c

Converts an uncurried function to a curried function.

uncurry :: (Elt a, Elt b) => (Exp a -> Exp b -> Exp c) -> Exp (a, b) -> Exp c

Converts a curried function to a function on pairs.

Index construction and destruction

index0 :: Exp Z

The one index for a rank-0 array.

index1 :: Exp Int -> Exp (Z :. Int)

Turn an Int expression into a rank-1 indexing expression.

unindex1 :: Exp (Z :. Int) -> Exp Int

Turn a rank-1 indexing expression into an Int expression.

index2 :: Exp Int -> Exp Int -> Exp DIM2

Creates a rank-2 index from two Exp Int`s

unindex2 :: Exp DIM2 -> Exp (Int, Int)

Destructs a rank-2 index to an Exp tuple of two Int`s.

Conditional expressions

(?) :: Elt t => Exp Bool -> (Exp t, Exp t) -> Exp t

Conditional expression.

Array operations with a scalar result

(!) :: (Shape ix, Elt e) => Acc (Array ix e) -> Exp ix -> Exp e

Expression form that extracts a scalar from an array.

the :: Elt e => Acc (Scalar e) -> Exp e

Extraction of the element in a singleton array.

shape :: (Shape ix, Elt e) => Acc (Array ix e) -> Exp ix

Expression form that yields the shape of an array.

size :: (Shape ix, Elt e) => Acc (Array ix e) -> Exp Int

Expression form that yields the size of an array.

shapeSize :: Shape ix => Exp ix -> Exp Int

The same as size but not operates directly on a shape without the array.

Methods of H98 classes that we need to redefine as their signatures change

(==*) :: (Elt t, IsScalar t) => Exp t -> Exp t -> Exp Bool

Equality lifted into Accelerate expressions.

(/=*) :: (Elt t, IsScalar t) => Exp t -> Exp t -> Exp Bool

Inequality lifted into Accelerate expressions.

(<*) :: (Elt t, IsScalar t) => Exp t -> Exp t -> Exp Bool

Smaller-than lifted into Accelerate expressions.

(<=*) :: (Elt t, IsScalar t) => Exp t -> Exp t -> Exp Bool

Smaller-or-equal lifted into Accelerate expressions.

(>*) :: (Elt t, IsScalar t) => Exp t -> Exp t -> Exp Bool

Greater-than lifted into Accelerate expressions.

(>=*) :: (Elt t, IsScalar t) => Exp t -> Exp t -> Exp Bool

Greater-or-equal lifted into Accelerate expressions.

max :: (Elt t, IsScalar t) => Exp t -> Exp t -> Exp t

Determine the maximum of two scalars.

min :: (Elt t, IsScalar t) => Exp t -> Exp t -> Exp t

Determine the minimum of two scalars.

bit :: (Elt t, IsIntegral t) => Exp Int -> Exp t

testBit :: (Elt t, IsIntegral t) => Exp t -> Exp Int -> Exp Bool

shift, shiftR, shiftL :: (Elt t, IsIntegral t) => Exp t -> Exp Int -> Exp t

rotate, rotateR, rotateL :: (Elt t, IsIntegral t) => Exp t -> Exp Int -> Exp t

truncate :: (Elt a, Elt b, IsFloating a, IsIntegral b) => Exp a -> Exp b

Conversions from the RealFrac class

round :: (Elt a, Elt b, IsFloating a, IsIntegral b) => Exp a -> Exp b

floor :: (Elt a, Elt b, IsFloating a, IsIntegral b) => Exp a -> Exp b

ceiling :: (Elt a, Elt b, IsFloating a, IsIntegral b) => Exp a -> Exp b

Standard functions that we need to redefine as their signatures change

(&&*) :: Exp Bool -> Exp Bool -> Exp Bool

Conjunction

(||*) :: Exp Bool -> Exp Bool -> Exp Bool

Disjunction

not :: Exp Bool -> Exp Bool

Negation

Conversions

boolToInt :: Exp Bool -> Exp Int

Convert a Boolean value to an Int, where False turns into '0' and True into '1'.

fromIntegral :: (Elt a, Elt b, IsIntegral a, IsNum b) => Exp a -> Exp b

General coercion from integral types

Constants

ignore :: Shape ix => Exp ix

Magic value identifying elements that are ignored in a forward permutation

Map-like

zip :: (Shape sh, Elt a, Elt b) => Acc (Array sh a) -> Acc (Array sh b) -> Acc (Array sh (a, b))

Combine the elements of two arrays pairwise. The shape of the result is the intersection of the two argument shapes.

zip3 :: forall sh a b c. (Shape sh, Elt a, Elt b, Elt c) => Acc (Array sh a) -> Acc (Array sh b) -> Acc (Array sh c) -> Acc (Array sh (a, b, c))

Take three arrays and and return an array of triples, analogous to zip.

zip4 :: forall sh a b c d. (Shape sh, Elt a, Elt b, Elt c, Elt d) => Acc (Array sh a) -> Acc (Array sh b) -> Acc (Array sh c) -> Acc (Array sh d) -> Acc (Array sh (a, b, c, d))

Take three arrays and and return an array of quadruples, analogous to zip.

unzip :: (Shape sh, Elt a, Elt b) => Acc (Array sh (a, b)) -> (Acc (Array sh a), Acc (Array sh b))

The converse of zip, but the shape of the two results is identical to the shape of the argument.

unzip3 :: forall sh a b c. (Shape sh, Elt a, Elt b, Elt c) => Acc (Array sh (a, b, c)) -> (Acc (Array sh a), Acc (Array sh b), Acc (Array sh c))

Take an array of triples and return three arrays, analogous to unzip.

unzip4 :: forall sh a b c d. (Shape sh, Elt a, Elt b, Elt c, Elt d) => Acc (Array sh (a, b, c, d)) -> (Acc (Array sh a), Acc (Array sh b), Acc (Array sh c), Acc (Array sh d))

Take an array of quadruples and return four arrays, analogous to unzip.

Reductions

foldAll :: (Shape sh, Elt a) => (Exp a -> Exp a -> Exp a) -> Exp a -> Acc (Array sh a) -> Acc (Scalar a)

Reduction of an array of arbitrary rank to a single scalar value. The first argument needs to be an associative function to enable an efficient parallel implementation.

fold1All :: (Shape sh, Elt a) => (Exp a -> Exp a -> Exp a) -> Acc (Array sh a) -> Acc (Scalar a)

Variant of foldAll that requires the reduced array to be non-empty and doesn't need an default value.

Scans

prescanl :: Elt a => (Exp a -> Exp a -> Exp a) -> Exp a -> Acc (Vector a) -> Acc (Vector a)

Left-to-right prescan (aka exclusive scan). As for scan, the first argument must be an associative function. Denotationally, we have

 prescanl f e = Prelude.fst . scanl' f e

postscanl :: Elt a => (Exp a -> Exp a -> Exp a) -> Exp a -> Acc (Vector a) -> Acc (Vector a)

Left-to-right postscan, a variant of scanl1 with an initial value. Denotationally, we have

 postscanl f e = map (e `f`) . scanl1 f

prescanr :: Elt a => (Exp a -> Exp a -> Exp a) -> Exp a -> Acc (Vector a) -> Acc (Vector a)

Right-to-left prescan (aka exclusive scan). As for scan, the first argument must be an associative function. Denotationally, we have

 prescanr f e = Prelude.fst . scanr' f e

postscanr :: Elt a => (Exp a -> Exp a -> Exp a) -> Exp a -> Acc (Vector a) -> Acc (Vector a)

Right-to-left postscan, a variant of scanr1 with an initial value. Denotationally, we have

 postscanr f e = map (e `f`) . scanr1 f

Segmented scans

scanlSeg :: forall a i. (Elt a, Elt i, IsIntegral i) => (Exp a -> Exp a -> Exp a) -> Exp a -> Acc (Vector a) -> Acc (Segments i) -> Acc (Vector a)

Segmented version of scanl.

scanl'Seg :: forall a i. (Elt a, Elt i, IsIntegral i) => (Exp a -> Exp a -> Exp a) -> Exp a -> Acc (Vector a) -> Acc (Segments i) -> (Acc (Vector a), Acc (Vector a))

Segmented version of scanl'.

The first element of the resulting tuple is a vector of scanned values. The second element is a vector of segment scan totals and has the same size as the segment vector.

scanl1Seg :: (Elt a, Elt i, IsIntegral i) => (Exp a -> Exp a -> Exp a) -> Acc (Vector a) -> Acc (Segments i) -> Acc (Vector a)

Segmented version of scanl1.

prescanlSeg :: (Elt a, Elt i, IsIntegral i) => (Exp a -> Exp a -> Exp a) -> Exp a -> Acc (Vector a) -> Acc (Segments i) -> Acc (Vector a)

Segmented version of prescanl.

postscanlSeg :: (Elt a, Elt i, IsIntegral i) => (Exp a -> Exp a -> Exp a) -> Exp a -> Acc (Vector a) -> Acc (Segments i) -> Acc (Vector a)

Segmented version of postscanl.

scanrSeg :: forall a i. (Elt a, Elt i, IsIntegral i) => (Exp a -> Exp a -> Exp a) -> Exp a -> Acc (Vector a) -> Acc (Segments i) -> Acc (Vector a)

Segmented version of scanr.

scanr'Seg :: forall a i. (Elt a, Elt i, IsIntegral i) => (Exp a -> Exp a -> Exp a) -> Exp a -> Acc (Vector a) -> Acc (Segments i) -> (Acc (Vector a), Acc (Vector a))

Segmented version of scanr'.

scanr1Seg :: (Elt a, Elt i, IsIntegral i) => (Exp a -> Exp a -> Exp a) -> Acc (Vector a) -> Acc (Segments i) -> Acc (Vector a)

Segmented version of scanr1.

prescanrSeg :: (Elt a, Elt i, IsIntegral i) => (Exp a -> Exp a -> Exp a) -> Exp a -> Acc (Vector a) -> Acc (Segments i) -> Acc (Vector a)

Segmented version of prescanr.

postscanrSeg :: (Elt a, Elt i, IsIntegral i) => (Exp a -> Exp a -> Exp a) -> Exp a -> Acc (Vector a) -> Acc (Segments i) -> Acc (Vector a)

Segmented version of postscanr.

Reshaping of arrays

flatten :: (Shape ix, Elt a) => Acc (Array ix a) -> Acc (Array DIM1 a)

Flattens a given array of arbitrary dimension.

Enumeration and filling

fill :: (Shape sh, Elt e) => Exp sh -> Exp e -> Acc (Array sh e)

Create an array where all elements are the same value.

enumFromN :: (Shape sh, Elt e, IsNum e) => Exp sh -> Exp e -> Acc (Array sh e)

Create an array of the given shape containing the values x, x+1, etc (in row-major order).

enumFromStepN

Arguments

:: (Shape sh, Elt e, IsNum e) 
=> Exp sh 
-> Exp e

x

-> Exp e

y

-> Acc (Array sh e) 

Create an array of the given shape containing the values x, x+y, x+y+y, etc (in row-major order).

Gather and scatter

gather

Arguments

:: Elt e 
=> Acc (Vector Int)

map

-> Acc (Vector e)

input

-> Acc (Vector e)

output

Copy elements from source array to destination array according to a map. This is a backpermute operation where a map vector encodes the ouput to input index mapping. For example:

input = [1, 9, 6, 4, 4, 2, 0, 1, 2] map = [1, 3, 7, 2, 5, 3]

output = [9, 4, 1, 6, 2, 4]

gatherIf

Arguments

:: (Elt e, Elt e') 
=> Acc (Vector Int)

map

-> Acc (Vector e)

mask

-> (Exp e -> Exp Bool)

predicate

-> Acc (Vector e')

default

-> Acc (Vector e')

input

-> Acc (Vector e')

output

Conditionally copy elements from source array to destination array according to a map. This is a backpermute opereation where a map vector encdes the output to input index mapping. In addition, there is a mask vector, and an associated predication function, that specifies whether an element will be copied. If not copied, the output array assumes the default vector's value. For example:

default = [6, 6, 6, 6, 6, 6] map = [1, 3, 7, 2, 5, 3] mask = [3, 4, 9, 2, 7, 5] pred = (> 4) input = [1, 9, 6, 4, 4, 2, 0, 1, 2]

output = [6, 6, 1, 6, 2, 4]

scatter

Arguments

:: Elt e 
=> Acc (Vector Int)

map

-> Acc (Vector e)

default

-> Acc (Vector e)

input

-> Acc (Vector e)

output

Copy elements from source array to destination array according to a map. This is a forward-permute operation where a map vector encodes an input to output index mapping. Output elements for indicies that are not mapped asume the default vector's value. For example:

default = [0, 0, 0, 0, 0, 0, 0, 0, 0] map = [1, 3, 7, 2, 5, 8] input = [1, 9, 6, 4, 4, 2, 5]

output = [0, 1, 4, 9, 0, 4, 0, 6, 2]

Note if the same index appears in the map more than once, the result is undefined. The map vector cannot be larger than the input vector.

scatterIf

Arguments

:: (Elt e, Elt e') 
=> Acc (Vector Int)

map

-> Acc (Vector e)

mask

-> (Exp e -> Exp Bool)

predicate

-> Acc (Vector e')

default

-> Acc (Vector e')

input

-> Acc (Vector e')

output

Conditionally copy elements from source array to destination array according to a map. This is a forward-permute operation where a map vector encodes an input to output index mapping. In addition, there is a mask vector, and an associated predicate function, that specifies whether an elements will be copied. If not copied, the ouput array assumes the default vector's value. For example:

default = [0, 0, 0, 0, 0, 0, 0, 0, 0] map = [1, 3, 7, 2, 5, 8] mask = [3, 4, 9, 2, 7, 5] pred = (> 4) input = [1, 9, 6, 4, 4, 2]

output = [0, 0, 0, 0, 0, 4, 0, 6, 2]

Note if the same index appears in the map more than once, the result is undefined. The map and input vector must be of the same length.

Subvector extraction

init :: Elt e => Acc (Vector e) -> Acc (Vector e)

Yield all but the last element of the input vector. The vector may not be empty.

tail :: Elt e => Acc (Vector e) -> Acc (Vector e)

Yield all but the first element of the input vector. The vector may not be empty.

take :: Elt e => Exp Int -> Acc (Vector e) -> Acc (Vector e)

Yield the first n elements of the input vector. The vector must contain no more than n elements.

drop :: Elt e => Exp Int -> Acc (Vector e) -> Acc (Vector e)

Yield all but the first n elements of the input vector. The vector must contain no more than n elements.

slit :: Elt e => Exp Int -> Exp Int -> Acc (Vector e) -> Acc (Vector e)

Yield a slit (slice) from the vector. The vector must contain at least i + n elements.

Deprecated names for backwards compatibility

class Elt e => Elem e

Instances

Elt e => Elem e 

class Shape sh => Ix sh

Instances

Shape sh => Ix sh 

class Slice sh => SliceIx sh

Instances

Slice sh => SliceIx sh 

tuple :: Lift Exp e => e -> Exp (Plain e)

untuple :: Unlift Exp e => Exp (Plain e) -> e

Diagnostics

initTrace :: Bool -> IO ()

Initialise the trace flag, which determines whether tracing messages should be emitted.