Portability | non-portable (GHC extensions) |
---|---|
Stability | experimental |
Maintainer | Manuel M T Chakravarty <chak@cse.unsw.edu.au> |
Safe Haskell | None |
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:
- Data.Array.Accelerate.Interpreter: simple interpreter in Haskell as a reference implementation defining the semantics of the Accelerate language
- Data.Array.Accelerate.CUDA: an implementation supporting parallel execution on CUDA-capable NVIDIA GPUs
- data Acc a
- class (Typeable (ArrRepr a), Typeable (ArrRepr' a), Typeable a) => Arrays a
- data Array sh e
- type Scalar e = Array DIM0 e
- type Vector e = Array DIM1 e
- type Segments i = Vector i
- class (Show a, Typeable a, Typeable (EltRepr a), Typeable (EltRepr' a), ArrayElt (EltRepr a), ArrayElt (EltRepr' a)) => Elt a
- data Z = Z
- data tail :. head = tail :. head
- class (Elt sh, Elt (Any sh), Shape (EltRepr sh)) => Shape sh
- data All = All
- data Any sh = Any
- class (Elt sl, Shape (SliceShape sl), Shape (CoSliceShape sl), Shape (FullShape sl)) => Slice sl where
- type SliceShape sl :: *
- type CoSliceShape sl :: *
- type FullShape sl :: *
- sliceIndex :: sl -> SliceIndex (EltRepr sl) (EltRepr (SliceShape sl)) (EltRepr (CoSliceShape sl)) (EltRepr (FullShape sl))
- 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
- (!) :: (Shape ix, Elt e) => Acc (Array ix e) -> Exp ix -> Exp e
- (!!) :: (Shape ix, Elt e) => Acc (Array ix e) -> Exp Int -> Exp e
- the :: Elt e => Acc (Scalar e) -> Exp e
- null :: (Shape ix, Elt e) => Acc (Array ix e) -> Exp Bool
- shape :: (Shape ix, Elt e) => Acc (Array ix e) -> Exp ix
- size :: (Shape ix, Elt e) => Acc (Array ix e) -> Exp Int
- shapeSize :: Shape ix => Exp ix -> Exp Int
- slice :: (Slice slix, Elt e) => Acc (Array (FullShape slix) e) -> Exp slix -> Acc (Array (SliceShape slix) e)
- init :: Elt e => Acc (Vector e) -> Acc (Vector e)
- tail :: Elt e => Acc (Vector e) -> Acc (Vector e)
- take :: Elt e => Exp Int -> Acc (Vector e) -> Acc (Vector e)
- drop :: Elt e => Exp Int -> Acc (Vector e) -> Acc (Vector e)
- slit :: Elt e => Exp Int -> Exp Int -> Acc (Vector e) -> Acc (Vector e)
- use :: Arrays arrays => arrays -> Acc arrays
- unit :: Elt e => Exp e -> Acc (Scalar e)
- generate :: (Shape ix, Elt a) => Exp ix -> (Exp ix -> Exp a) -> Acc (Array ix a)
- replicate :: (Slice slix, Elt e) => Exp slix -> Acc (Array (SliceShape slix) e) -> Acc (Array (FullShape slix) e)
- fill :: (Shape sh, Elt e) => Exp sh -> Exp e -> Acc (Array sh e)
- enumFromN :: (Shape sh, Elt e, IsNum e) => Exp sh -> Exp e -> Acc (Array sh e)
- enumFromStepN :: (Shape sh, Elt e, IsNum e) => Exp sh -> Exp e -> Exp e -> Acc (Array sh e)
- (?|) :: Arrays a => Exp Bool -> (Acc a, Acc a) -> Acc a
- cond :: Arrays a => Exp Bool -> Acc a -> Acc a -> Acc a
- (>->) :: (Arrays a, Arrays b, Arrays c) => (Acc a -> Acc b) -> (Acc b -> Acc c) -> Acc a -> Acc c
- reshape :: (Shape ix, Shape ix', Elt e) => Exp ix -> Acc (Array ix' e) -> Acc (Array ix e)
- flatten :: (Shape ix, Elt a) => Acc (Array ix a) -> Acc (Vector a)
- permute :: (Shape ix, Shape ix', Elt a) => (Exp a -> Exp a -> Exp a) -> Acc (Array ix' a) -> (Exp ix -> Exp ix') -> Acc (Array ix a) -> Acc (Array ix' a)
- backpermute :: (Shape ix, Shape ix', Elt a) => Exp ix' -> (Exp ix' -> Exp ix) -> Acc (Array ix a) -> Acc (Array ix' a)
- ignore :: Shape ix => Exp ix
- reverse :: Elt e => Acc (Vector e) -> Acc (Vector e)
- transpose :: Elt e => Acc (Array DIM2 e) -> Acc (Array DIM2 e)
- map :: (Shape ix, Elt a, Elt b) => (Exp a -> Exp b) -> Acc (Array ix a) -> Acc (Array ix b)
- 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)
- zipWith3 :: (Shape sh, Elt a, Elt b, Elt c, Elt d) => (Exp a -> Exp b -> Exp c -> Exp d) -> Acc (Array sh a) -> Acc (Array sh b) -> Acc (Array sh c) -> Acc (Array sh d)
- zipWith4 :: (Shape sh, Elt a, Elt b, Elt c, Elt d, Elt e) => (Exp a -> Exp b -> Exp c -> Exp d -> Exp e) -> Acc (Array sh a) -> Acc (Array sh b) -> Acc (Array sh c) -> Acc (Array sh d) -> Acc (Array sh e)
- zip :: (Shape sh, Elt a, Elt b) => Acc (Array sh a) -> Acc (Array sh b) -> Acc (Array sh (a, b))
- 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))
- 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))
- unzip :: (Shape sh, Elt a, Elt b) => Acc (Array sh (a, b)) -> (Acc (Array sh a), Acc (Array sh b))
- unzip3 :: (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))
- unzip4 :: (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))
- filter :: Elt a => (Exp a -> Exp Bool) -> Acc (Vector a) -> Acc (Vector a)
- scatter :: Elt e => Acc (Vector Int) -> Acc (Vector e) -> Acc (Vector e) -> Acc (Vector e)
- scatterIf :: (Elt e, Elt e') => Acc (Vector Int) -> Acc (Vector e) -> (Exp e -> Exp Bool) -> Acc (Vector e') -> Acc (Vector e') -> Acc (Vector e')
- gather :: Elt e => Acc (Vector Int) -> Acc (Vector e) -> Acc (Vector e)
- gatherIf :: (Elt e, Elt e') => Acc (Vector Int) -> Acc (Vector e) -> (Exp e -> Exp Bool) -> Acc (Vector e') -> Acc (Vector e') -> Acc (Vector e')
- fold :: (Shape ix, Elt a) => (Exp a -> Exp a -> Exp a) -> Exp a -> Acc (Array (ix :. Int) a) -> Acc (Array ix a)
- fold1 :: (Shape ix, Elt a) => (Exp a -> Exp a -> Exp a) -> Acc (Array (ix :. Int) a) -> Acc (Array ix a)
- foldAll :: (Shape sh, Elt a) => (Exp a -> Exp a -> Exp a) -> Exp a -> Acc (Array sh a) -> Acc (Scalar a)
- fold1All :: (Shape sh, Elt a) => (Exp a -> Exp a -> Exp a) -> Acc (Array sh a) -> Acc (Scalar a)
- 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)
- 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)
- all :: (Shape sh, Elt e) => (Exp e -> Exp Bool) -> Acc (Array sh e) -> Acc (Scalar Bool)
- any :: (Shape sh, Elt e) => (Exp e -> Exp Bool) -> Acc (Array sh e) -> Acc (Scalar Bool)
- and :: Shape sh => Acc (Array sh Bool) -> Acc (Scalar Bool)
- or :: Shape sh => Acc (Array sh Bool) -> Acc (Scalar Bool)
- sum :: (Shape sh, Elt e, IsNum e) => Acc (Array sh e) -> Acc (Scalar e)
- product :: (Shape sh, Elt e, IsNum e) => Acc (Array sh e) -> Acc (Scalar e)
- minimum :: (Shape sh, Elt e, IsScalar e) => Acc (Array sh e) -> Acc (Scalar e)
- maximum :: (Shape sh, Elt e, IsScalar e) => Acc (Array sh e) -> Acc (Scalar e)
- scanl :: Elt a => (Exp a -> Exp a -> Exp a) -> Exp a -> Acc (Vector a) -> Acc (Vector a)
- scanl1 :: Elt a => (Exp a -> Exp a -> Exp a) -> Acc (Vector a) -> Acc (Vector a)
- scanl' :: Elt a => (Exp a -> Exp a -> Exp a) -> Exp a -> Acc (Vector a) -> (Acc (Vector a), Acc (Scalar a))
- scanr :: Elt a => (Exp a -> Exp a -> Exp a) -> Exp a -> Acc (Vector a) -> Acc (Vector a)
- scanr1 :: Elt a => (Exp a -> Exp a -> Exp a) -> Acc (Vector a) -> Acc (Vector a)
- scanr' :: Elt a => (Exp a -> Exp a -> Exp a) -> Exp a -> Acc (Vector a) -> (Acc (Vector a), Acc (Scalar a))
- prescanl :: Elt a => (Exp a -> Exp a -> Exp a) -> Exp a -> Acc (Vector a) -> Acc (Vector a)
- postscanl :: Elt a => (Exp a -> Exp a -> Exp a) -> Exp a -> Acc (Vector a) -> Acc (Vector a)
- prescanr :: Elt a => (Exp a -> Exp a -> Exp a) -> Exp a -> Acc (Vector a) -> Acc (Vector a)
- postscanr :: Elt a => (Exp a -> Exp a -> Exp a) -> Exp a -> Acc (Vector a) -> Acc (Vector a)
- scanlSeg :: (Elt a, Elt i, IsIntegral i) => (Exp a -> Exp a -> Exp a) -> Exp a -> Acc (Vector a) -> Acc (Segments i) -> Acc (Vector a)
- scanl1Seg :: (Elt a, Elt i, IsIntegral i) => (Exp a -> Exp a -> Exp a) -> Acc (Vector a) -> Acc (Segments i) -> Acc (Vector a)
- 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, Vector a)
- prescanlSeg :: (Elt a, Elt i, IsIntegral i) => (Exp a -> Exp a -> Exp a) -> Exp a -> Acc (Vector a) -> Acc (Segments i) -> Acc (Vector a)
- postscanlSeg :: (Elt a, Elt i, IsIntegral i) => (Exp a -> Exp a -> Exp a) -> Exp a -> Acc (Vector a) -> Acc (Segments i) -> Acc (Vector a)
- scanrSeg :: (Elt a, Elt i, IsIntegral i) => (Exp a -> Exp a -> Exp a) -> Exp a -> Acc (Vector a) -> Acc (Segments i) -> Acc (Vector a)
- scanr1Seg :: (Elt a, Elt i, IsIntegral i) => (Exp a -> Exp a -> Exp a) -> Acc (Vector a) -> Acc (Segments i) -> Acc (Vector a)
- 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, Vector a)
- prescanrSeg :: (Elt a, Elt i, IsIntegral i) => (Exp a -> Exp a -> Exp a) -> Exp a -> Acc (Vector a) -> Acc (Segments i) -> Acc (Vector a)
- postscanrSeg :: (Elt a, Elt i, IsIntegral i) => (Exp a -> Exp a -> Exp a) -> Exp a -> Acc (Vector a) -> Acc (Segments i) -> Acc (Vector a)
- stencil :: (Shape ix, Elt a, Elt b, Stencil ix a stencil) => (stencil -> Exp b) -> Boundary a -> Acc (Array ix a) -> Acc (Array ix b)
- stencil2 :: (Shape ix, Elt a, Elt b, Elt c, Stencil ix a stencil1, Stencil ix b stencil2) => (stencil1 -> stencil2 -> Exp c) -> Boundary a -> Acc (Array ix a) -> Boundary b -> Acc (Array ix b) -> Acc (Array ix c)
- class (Elt (StencilRepr sh stencil), Stencil sh a (StencilRepr sh stencil)) => Stencil sh a stencil
- data Boundary a
- 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)
- type Stencil3x3 a = (Stencil3 a, Stencil3 a, Stencil3 a)
- type Stencil5x3 a = (Stencil5 a, Stencil5 a, Stencil5 a)
- type Stencil3x5 a = (Stencil3 a, Stencil3 a, Stencil3 a, Stencil3 a, Stencil3 a)
- type Stencil5x5 a = (Stencil5 a, Stencil5 a, Stencil5 a, Stencil5 a, Stencil5 a)
- type Stencil3x3x3 a = (Stencil3x3 a, Stencil3x3 a, Stencil3x3 a)
- type Stencil5x3x3 a = (Stencil5x3 a, Stencil5x3 a, Stencil5x3 a)
- type Stencil3x5x3 a = (Stencil3x5 a, Stencil3x5 a, Stencil3x5 a)
- type Stencil3x3x5 a = (Stencil3x3 a, Stencil3x3 a, Stencil3x3 a, Stencil3x3 a, Stencil3x3 a)
- type Stencil5x5x3 a = (Stencil5x5 a, Stencil5x5 a, Stencil5x5 a)
- type Stencil5x3x5 a = (Stencil5x3 a, Stencil5x3 a, Stencil5x3 a, Stencil5x3 a, Stencil5x3 a)
- type Stencil3x5x5 a = (Stencil3x5 a, Stencil3x5 a, Stencil3x5 a, Stencil3x5 a, Stencil3x5 a)
- type Stencil5x5x5 a = (Stencil5x5 a, Stencil5x5 a, Stencil5x5 a, Stencil5x5 a, Stencil5x5 a)
- foreignAcc :: (Arrays acc, Arrays res, Foreign ff) => ff acc res -> (Acc acc -> Acc res) -> Acc acc -> Acc res
- foreignAcc2 :: (Arrays acc, Arrays res, Foreign ff1, Foreign ff2) => ff1 acc res -> ff2 acc res -> (Acc acc -> Acc res) -> Acc acc -> Acc res
- foreignAcc3 :: (Arrays acc, Arrays res, Foreign ff1, Foreign ff2, Foreign ff3) => ff1 acc res -> ff2 acc res -> ff3 acc res -> (Acc acc -> Acc res) -> Acc acc -> Acc res
- foreignExp :: (Elt e, Elt res, Foreign ff) => ff e res -> (Exp e -> Exp res) -> Exp e -> Exp res
- foreignExp2 :: (Elt e, Elt res, Foreign ff1, Foreign ff2) => ff1 e res -> ff2 e res -> (Exp e -> Exp res) -> Exp e -> Exp res
- foreignExp3 :: (Elt e, Elt res, Foreign ff1, Foreign ff2, Foreign ff3) => ff1 e res -> ff2 e res -> ff3 e res -> (Exp e -> Exp res) -> Exp e -> Exp res
- data Exp t
- class Typeable a => IsScalar a
- class (Num a, IsScalar a) => IsNum a
- class IsBounded a
- class (IsScalar a, IsNum a, IsBounded a) => IsIntegral a
- class (Floating a, IsScalar a, IsNum a) => IsFloating a
- class IsNonNum a
- data Int
- data Int8
- data Int16
- data Int32
- data Int64
- data Word
- data Word8
- data Word16
- data Word32
- data Word64
- data CShort
- data CUShort
- data CInt
- data CUInt
- data CLong
- data CULong
- data CLLong
- data CULLong
- data Float
- data Double
- data CFloat
- data CDouble
- data Bool
- data Char
- data CChar
- data CSChar
- data CUChar
- class Lift c e where
- class Lift c e => Unlift c e where
- lift1 :: (Unlift Exp e1, Lift Exp e2) => (e1 -> e2) -> Exp (Plain e1) -> Exp (Plain e2)
- lift2 :: (Unlift Exp e1, Unlift Exp e2, Lift Exp e3) => (e1 -> e2 -> e3) -> Exp (Plain e1) -> Exp (Plain e2) -> Exp (Plain e3)
- ilift1 :: (Exp Int -> Exp Int) -> Exp DIM1 -> Exp DIM1
- ilift2 :: (Exp Int -> Exp Int -> Exp Int) -> Exp DIM1 -> Exp DIM1 -> Exp DIM1
- constant :: Elt t => t -> Exp t
- fst :: forall f a b. Unlift f (f a, f b) => f (Plain (f a), Plain (f b)) -> f a
- snd :: forall f a b. Unlift f (f a, f b) => f (Plain (f a), Plain (f b)) -> f b
- curry :: Lift f (f a, f b) => (f (Plain (f a), Plain (f b)) -> f c) -> f a -> f b -> f c
- uncurry :: Unlift f (f a, f b) => (f a -> f b -> f c) -> f (Plain (f a), Plain (f b)) -> f c
- (?) :: Elt t => Exp Bool -> (Exp t, Exp t) -> Exp t
- (&&*) :: Exp Bool -> Exp Bool -> Exp Bool
- (||*) :: Exp Bool -> Exp Bool -> Exp Bool
- not :: Exp Bool -> Exp Bool
- (==*) :: (Elt t, IsScalar t) => Exp t -> Exp t -> Exp Bool
- (/=*) :: (Elt t, IsScalar t) => Exp t -> Exp t -> Exp Bool
- (<*) :: (Elt t, IsScalar t) => Exp t -> Exp t -> Exp Bool
- (<=*) :: (Elt t, IsScalar t) => Exp t -> Exp t -> Exp Bool
- (>*) :: (Elt t, IsScalar t) => Exp t -> Exp t -> Exp Bool
- (>=*) :: (Elt t, IsScalar t) => Exp t -> Exp t -> Exp Bool
- max :: (Elt t, IsScalar t) => Exp t -> Exp t -> Exp t
- min :: (Elt t, IsScalar t) => Exp t -> Exp t -> Exp t
- truncate :: (Elt a, Elt b, IsFloating a, IsIntegral b) => Exp a -> Exp b
- 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
- bit :: (Elt t, IsIntegral t) => Exp Int -> Exp t
- setBit :: (Elt t, IsIntegral t) => Exp t -> Exp Int -> Exp t
- clearBit :: (Elt t, IsIntegral t) => Exp t -> Exp Int -> Exp t
- complementBit :: (Elt t, IsIntegral t) => Exp t -> Exp Int -> Exp t
- testBit :: (Elt t, IsIntegral t) => Exp t -> Exp Int -> Exp Bool
- shift :: (Elt t, IsIntegral t) => Exp t -> Exp Int -> Exp t
- shiftL :: (Elt t, IsIntegral t) => Exp t -> Exp Int -> Exp t
- shiftR :: (Elt t, IsIntegral t) => Exp t -> Exp Int -> Exp t
- rotate :: (Elt t, IsIntegral t) => Exp t -> Exp Int -> Exp t
- rotateL :: (Elt t, IsIntegral t) => Exp t -> Exp Int -> Exp t
- rotateR :: (Elt t, IsIntegral t) => Exp t -> Exp Int -> Exp t
- index0 :: Exp Z
- index1 :: Elt i => Exp i -> Exp (Z :. i)
- unindex1 :: Elt i => Exp (Z :. i) -> Exp i
- index2 :: (Elt i, Slice (Z :. i)) => Exp i -> Exp i -> Exp ((Z :. i) :. i)
- unindex2 :: forall i. (Elt i, Slice (Z :. i)) => Exp ((Z :. i) :. i) -> Exp (i, i)
- indexHead :: Slice sh => Exp (sh :. Int) -> Exp Int
- indexTail :: Slice sh => Exp (sh :. Int) -> Exp sh
- toIndex :: Shape sh => Exp sh -> Exp sh -> Exp Int
- fromIndex :: Shape sh => Exp sh -> Exp Int -> Exp sh
- boolToInt :: Exp Bool -> Exp Int
- fromIntegral :: (Elt a, Elt b, IsIntegral a, IsNum b) => Exp a -> Exp b
- arrayDim :: Shape sh => sh -> Int
- arrayShape :: Shape sh => Array sh e -> sh
- arraySize :: Shape sh => sh -> Int
- indexArray :: Array sh e -> sh -> e
- fromList :: (Shape sh, Elt e) => sh -> [e] -> Array sh e
- toList :: forall sh e. Array sh e -> [e]
- fromIArray :: (EltRepr ix ~ EltRepr sh, IArray a e, Ix ix, Shape sh, Elt ix, Elt e) => a ix e -> Array sh e
- toIArray :: (EltRepr ix ~ EltRepr sh, IArray a e, Ix ix, Shape sh, Elt ix, Elt e) => Array sh e -> a ix e
The Accelerate Array Language
Array data types
Array-valued collective computations
class (Typeable (ArrRepr a), Typeable (ArrRepr' a), Typeable a) => Arrays a Source
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) |
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.
type Segments i = Vector iSource
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 Source
Accelerate supports as array elements only simple atomic types, and tuples thereof. These element types are stored efficiently in memory, unpacked as consecutive elements without pointers.
This class characterises the types of values that can be array elements, and hence, appear in scalar Accelerate expressions.
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 CChar | |
Elt CSChar | |
Elt CUChar | |
Elt CShort | |
Elt CUShort | |
Elt CInt | |
Elt CUInt | |
Elt CLong | |
Elt CULong | |
Elt CLLong | |
Elt CULLong | |
Elt CFloat | |
Elt CDouble | |
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) |
Shapes & Indices
Array indices are snoc type lists; that is, they are backwards and the
end-of-list token, Z
, occurs on the left. For example, the type of a
rank-2 array index is Z :. Int :. Int
.
Rank-0 index
Eq Z | |
Show Z | |
Typeable Z | |
Slice Z | |
Shape Z | |
Elt Z | |
Unlift Exp Z | |
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) | |
Elt (Any Z) |
Increase an index rank by one dimension. The :.
operator is
used to construct both values and types.
tail :. head |
Typeable2 :. | |
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) | |
(Elt e, Slice (Plain ix), Unlift Exp ix) => Unlift Exp (:. ix (Exp e)) | |
(Elt e, Slice ix) => Unlift Exp (:. (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)) | |
(Eq tail, Eq head) => Eq (:. tail head) | |
(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 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) |
class (Elt sh, Elt (Any sh), Shape (EltRepr sh)) => Shape sh Source
Shapes and indices of multi-dimensional arrays
Marker for arbitrary shapes in slice descriptors. Such arbitrary shapes may include an unknown number of dimensions.
Any
can be used in the leftmost position of a slice instead of
Z
, for example (Any :. _ :. _)
. In the following definition
Any
is used to match against whatever shape the type variable
sh
takes:
repN :: (Shape sh, Elt e) => Int -> Acc (Array sh e) -> Acc (Array (sh:.Int) e) repN n a = replicate (constant $ Any :. n) a
class (Elt sl, Shape (SliceShape sl), Shape (CoSliceShape sl), Shape (FullShape sl)) => Slice sl whereSource
Slices, aka generalised indices, as n-tuples and mappings of slice indices to slices, co-slices, and slice dimensions
sliceIndex :: sl -> SliceIndex (EltRepr sl) (EltRepr (SliceShape sl)) (EltRepr (CoSliceShape sl)) (EltRepr (FullShape sl))Source
Accessors
Indexing
(!) :: (Shape ix, Elt e) => Acc (Array ix e) -> Exp ix -> Exp eSource
Expression form that extracts a scalar from an array
(!!) :: (Shape ix, Elt e) => Acc (Array ix e) -> Exp Int -> Exp eSource
Expression form that extracts a scalar from an array at a linear index
Shape information
shape :: (Shape ix, Elt e) => Acc (Array ix e) -> Exp ixSource
Expression form that yields the shape of an array
size :: (Shape ix, Elt e) => Acc (Array ix e) -> Exp IntSource
Expression form that yields the size of an array
shapeSize :: Shape ix => Exp ix -> Exp IntSource
The total number of elements in an array of the given Shape
Extracting sub-arrays
slice :: (Slice slix, Elt e) => Acc (Array (FullShape slix) e) -> Exp slix -> Acc (Array (SliceShape slix) e)Source
Index an array with a generalised array index, supplied as the
second argument. The result is a new array (possibly a singleton)
containing the selected dimensions (All
s) in their entirety.
This can be used to cut out entire dimensions. The opposite of
replicate
. For example, if mat
is a two dimensional array, the
following will select a specific row and yield a one dimensional
result:
slice mat (constant (Z :. (2::Int) :. All))
A fully specified index (with no All
s) would return a single
element (zero dimensional array).
init :: Elt e => Acc (Vector e) -> Acc (Vector e)Source
Yield all but the last element of the input vector. The vector must not be empty.
tail :: Elt e => Acc (Vector e) -> Acc (Vector e)Source
Yield all but the first element of the input vector. The vector must not be empty.
take :: Elt e => Exp Int -> Acc (Vector e) -> Acc (Vector e)Source
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)Source
Yield all but the first n
elements of the input vector. The vector must
contain no fewer than n
elements.
slit :: Elt e => Exp Int -> Exp Int -> Acc (Vector e) -> Acc (Vector e)Source
Yield a slit (slice) from the vector. The vector must contain at least
i + n
elements. Denotationally, we have:
slit i n = take n . drop i
Construction
Introduction
use :: Arrays arrays => arrays -> Acc arraysSource
Array inlet: makes an array available for processing using the Accelerate language.
Depending upon the backend used to execute array computations, this may trigger (asynchronous) data transfer.
unit :: Elt e => Exp e -> Acc (Scalar e)Source
Scalar inlet: injects a scalar (or a tuple of scalars) into a singleton array for use in the Accelerate language.
Initialisation
generate :: (Shape ix, Elt a) => Exp ix -> (Exp ix -> Exp a) -> Acc (Array ix a)Source
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
replicate :: (Slice slix, Elt e) => Exp slix -> Acc (Array (SliceShape slix) e) -> Acc (Array (FullShape slix) e)Source
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.
fill :: (Shape sh, Elt e) => Exp sh -> Exp e -> Acc (Array sh e)Source
Create an array where all elements are the same value.
Enumeration
enumFromN :: (Shape sh, Elt e, IsNum e) => Exp sh -> Exp e -> Acc (Array sh e)Source
Create an array of the given shape containing the values x, x+1, etc (in row-major order).
Create an array of the given shape containing the values x
, x+y
,
x+y+y
etc. (in row-major order).
Composition
Flow control
An array-level if-then-else construct.
Pipelining
(>->) :: (Arrays a, Arrays b, Arrays c) => (Acc a -> Acc b) -> (Acc b -> Acc c) -> Acc a -> Acc cSource
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
.
Modifying Arrays
Shape manipulation
reshape :: (Shape ix, Shape ix', Elt e) => Exp ix -> Acc (Array ix' e) -> Acc (Array ix e)Source
Change the shape of an array without altering its contents. The size
of
the source and result arrays must be identical.
precondition: size ix == size ix'
flatten :: (Shape ix, Elt a) => Acc (Array ix a) -> Acc (Vector a)Source
Flattens a given array of arbitrary dimension.
Permutations
:: (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 dropped.
:: (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 specified by an index mapping from the destination array specifying which element of the source array to read.
ignore :: Shape ix => Exp ixSource
Magic value identifying elements that are ignored in a forward permutation. Note that this currently does not work for singleton arrays.
Specialised permutations
transpose :: Elt e => Acc (Array DIM2 e) -> Acc (Array DIM2 e)Source
Transpose the rows and columns of a matrix.
Element-wise operations
Mapping
map :: (Shape ix, Elt a, Elt b) => (Exp a -> Exp b) -> Acc (Array ix a) -> Acc (Array ix b)Source
Apply the given function element-wise to the given array.
Zipping
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)Source
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.
zipWith3 :: (Shape sh, Elt a, Elt b, Elt c, Elt d) => (Exp a -> Exp b -> Exp c -> Exp d) -> Acc (Array sh a) -> Acc (Array sh b) -> Acc (Array sh c) -> Acc (Array sh d)Source
Zip three arrays with the given function
zipWith4 :: (Shape sh, Elt a, Elt b, Elt c, Elt d, Elt e) => (Exp a -> Exp b -> Exp c -> Exp d -> Exp e) -> Acc (Array sh a) -> Acc (Array sh b) -> Acc (Array sh c) -> Acc (Array sh d) -> Acc (Array sh e)Source
Zip four arrays with the given function
zip :: (Shape sh, Elt a, Elt b) => Acc (Array sh a) -> Acc (Array sh b) -> Acc (Array sh (a, b))Source
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))Source
Take three arrays 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))Source
Take four arrays and return an array of quadruples, analogous to zip.
Unzipping
unzip :: (Shape sh, Elt a, Elt b) => Acc (Array sh (a, b)) -> (Acc (Array sh a), Acc (Array sh b))Source
The converse of zip
, but the shape of the two results is identical to the
shape of the argument.
unzip3 :: (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))Source
Take an array of triples and return three arrays, analogous to unzip.
unzip4 :: (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))Source
Take an array of quadruples and return four arrays, analogous to unzip.
Working with predicates
Filtering
filter :: Elt a => (Exp a -> Exp Bool) -> Acc (Vector a) -> Acc (Vector a)Source
Drop elements that do not satisfy the predicate
Scatter
:: 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 indices that are not mapped assume 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.
:: (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 output 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.
Gather
Copy elements from source array to destination array according to a map. This
is a backpermute operation where a map
vector encodes the output 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]
:: (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 operation where a map
vector encodes 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]
Folding
fold :: (Shape ix, Elt a) => (Exp a -> Exp a -> Exp a) -> Exp a -> Acc (Array (ix :. Int) a) -> Acc (Array ix a)Source
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)Source
Variant of fold
that requires the reduced array to be non-empty and
doesn't need an default value. The first argument needs to be an
associative function to enable an efficient parallel implementation.
foldAll :: (Shape sh, Elt a) => (Exp a -> Exp a -> Exp a) -> Exp a -> Acc (Array sh a) -> Acc (Scalar a)Source
Reduction of an array of arbitrary rank to a single scalar value.
fold1All :: (Shape sh, Elt a) => (Exp a -> Exp a -> Exp a) -> Acc (Array sh a) -> Acc (Scalar a)Source
Variant of foldAll
that requires the reduced array to be non-empty and
doesn't need an default value.
Segmented reductions
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)Source
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)Source
Specialised folds
all :: (Shape sh, Elt e) => (Exp e -> Exp Bool) -> Acc (Array sh e) -> Acc (Scalar Bool)Source
Check if all elements satisfy a predicate
any :: (Shape sh, Elt e) => (Exp e -> Exp Bool) -> Acc (Array sh e) -> Acc (Scalar Bool)Source
Check if any element satisfies the predicate
sum :: (Shape sh, Elt e, IsNum e) => Acc (Array sh e) -> Acc (Scalar e)Source
Compute the sum of elements
product :: (Shape sh, Elt e, IsNum e) => Acc (Array sh e) -> Acc (Scalar e)Source
Compute the product of the elements
minimum :: (Shape sh, Elt e, IsScalar e) => Acc (Array sh e) -> Acc (Scalar e)Source
Yield the minimum element of an array. The array must not be empty.
maximum :: (Shape sh, Elt e, IsScalar e) => Acc (Array sh e) -> Acc (Scalar e)Source
Yield the maximum element of an array. The array must not be empty.
Prefix sums (scans)
scanl :: Elt a => (Exp a -> Exp a -> Exp a) -> Exp a -> Acc (Vector a) -> Acc (Vector a)Source
Data.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.
scanl1 :: Elt a => (Exp a -> Exp a -> Exp a) -> Acc (Vector a) -> Acc (Vector a)Source
Data.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 = tail (scanl f e arr)
scanl' :: Elt a => (Exp a -> Exp a -> Exp a) -> Exp a -> Acc (Vector a) -> (Acc (Vector a), Acc (Scalar a))Source
Variant of scanl
, where the final result of the reduction is returned
separately. Denotationally, we have
scanl' f e arr = (init res, unit (res!len)) 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)Source
Right-to-left variant of scanl
.
scanr1 :: Elt a => (Exp a -> Exp a -> Exp a) -> Acc (Vector a) -> Acc (Vector a)Source
Right-to-left variant of scanl1
.
scanr' :: Elt a => (Exp a -> Exp a -> Exp a) -> Exp a -> Acc (Vector a) -> (Acc (Vector a), Acc (Scalar a))Source
Right-to-left variant of scanl'
.
prescanl :: Elt a => (Exp a -> Exp a -> Exp a) -> Exp a -> Acc (Vector a) -> Acc (Vector a)Source
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)Source
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)Source
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)Source
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 :: (Elt a, Elt i, IsIntegral i) => (Exp a -> Exp a -> Exp a) -> Exp a -> Acc (Vector a) -> Acc (Segments i) -> Acc (Vector a)Source
Segmented version of scanl
scanl1Seg :: (Elt a, Elt i, IsIntegral i) => (Exp a -> Exp a -> Exp a) -> Acc (Vector a) -> Acc (Segments i) -> Acc (Vector a)Source
Segmented version of scanl1
.
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, Vector a)Source
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.
prescanlSeg :: (Elt a, Elt i, IsIntegral i) => (Exp a -> Exp a -> Exp a) -> Exp a -> Acc (Vector a) -> Acc (Segments i) -> Acc (Vector a)Source
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)Source
Segmented version of postscanl
.
scanrSeg :: (Elt a, Elt i, IsIntegral i) => (Exp a -> Exp a -> Exp a) -> Exp a -> Acc (Vector a) -> Acc (Segments i) -> Acc (Vector a)Source
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)Source
Segmented version of scanr1
.
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, Vector a)Source
Segmented version of scanr'
.
prescanrSeg :: (Elt a, Elt i, IsIntegral i) => (Exp a -> Exp a -> Exp a) -> Exp a -> Acc (Vector a) -> Acc (Segments i) -> Acc (Vector a)Source
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)Source
Segmented version of postscanr
.
Stencil
:: (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.
:: (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.
Specification
class (Elt (StencilRepr sh stencil), Stencil sh a (StencilRepr sh stencil)) => Stencil sh a stencil Source
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) |
Boundary condition specification for stencil operations.
Common stencil patterns
type Stencil3x3 a = (Stencil3 a, Stencil3 a, Stencil3 a)Source
type Stencil5x3 a = (Stencil5 a, Stencil5 a, Stencil5 a)Source
type Stencil3x3x3 a = (Stencil3x3 a, Stencil3x3 a, Stencil3x3 a)Source
type Stencil5x3x3 a = (Stencil5x3 a, Stencil5x3 a, Stencil5x3 a)Source
type Stencil3x5x3 a = (Stencil3x5 a, Stencil3x5 a, Stencil3x5 a)Source
type Stencil3x3x5 a = (Stencil3x3 a, Stencil3x3 a, Stencil3x3 a, Stencil3x3 a, Stencil3x3 a)Source
type Stencil5x5x3 a = (Stencil5x5 a, Stencil5x5 a, Stencil5x5 a)Source
type Stencil5x3x5 a = (Stencil5x3 a, Stencil5x3 a, Stencil5x3 a, Stencil5x3 a, Stencil5x3 a)Source
type Stencil3x5x5 a = (Stencil3x5 a, Stencil3x5 a, Stencil3x5 a, Stencil3x5 a, Stencil3x5 a)Source
type Stencil5x5x5 a = (Stencil5x5 a, Stencil5x5 a, Stencil5x5 a, Stencil5x5 a, Stencil5x5 a)Source
Foreign
foreignAcc :: (Arrays acc, Arrays res, Foreign ff) => ff acc res -> (Acc acc -> Acc res) -> Acc acc -> Acc resSource
Call a foreign function. The form the function takes is dependent on the backend being used. The arguments are passed as either a single array or as a tuple of arrays. In addition a pure Accelerate version of the function needs to be provided to support backends other than the one being targeted.
foreignAcc2 :: (Arrays acc, Arrays res, Foreign ff1, Foreign ff2) => ff1 acc res -> ff2 acc res -> (Acc acc -> Acc res) -> Acc acc -> Acc resSource
Call a foreign function with foreign implementations for two different backends.
foreignAcc3 :: (Arrays acc, Arrays res, Foreign ff1, Foreign ff2, Foreign ff3) => ff1 acc res -> ff2 acc res -> ff3 acc res -> (Acc acc -> Acc res) -> Acc acc -> Acc resSource
Call a foreign function with foreign implementations for three different backends.
foreignExp :: (Elt e, Elt res, Foreign ff) => ff e res -> (Exp e -> Exp res) -> Exp e -> Exp resSource
Call a foreign expression function. The form the function takes is dependent on the backend being used. The arguments are passed as either a single scalar element or as a tuple of elements. In addition a pure Accelerate version of the function needs to be provided to support backends other than the one being targeted.
foreignExp2 :: (Elt e, Elt res, Foreign ff1, Foreign ff2) => ff1 e res -> ff2 e res -> (Exp e -> Exp res) -> Exp e -> Exp resSource
Call a foreign function with foreign implementations for two different backends.
foreignExp3 :: (Elt e, Elt res, Foreign ff1, Foreign ff2, Foreign ff3) => ff1 e res -> ff2 e res -> ff3 e res -> (Exp e -> Exp res) -> Exp e -> Exp resSource
Call a foreign function with foreign implementations for three different backends.
The Accelerate Expression Language
Scalar data types
Scalar expressions for plain array computations.
Type classes
class Typeable a => IsScalar a Source
All scalar type
Bounded types
class (IsScalar a, IsNum a, IsBounded a) => IsIntegral a Source
Integral types
class (Floating a, IsScalar a, IsNum a) => IsFloating a Source
Floating types
Non-numeric types
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.
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 | |
Hashable Int | |
Prim Int | |
Lift Int | |
Unbox Int | |
IsScalar Int | |
IsBounded Int | |
IsNum Int | |
IsIntegral Int | |
Elt Int | |
IArray UArray Int | |
Vector Vector Int | |
MVector MVector Int | |
Lift Exp Int | |
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) | |
(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) | |
(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) |
data Int8
8-bit signed integer type
data Int16
16-bit signed integer type
data Int32
32-bit signed integer type
data Int64
64-bit signed integer type
data Word
data Word8
8-bit unsigned integer type
data Word16
16-bit unsigned integer type
data Word32
32-bit unsigned integer type
data Word64
64-bit unsigned integer type
data CShort
Haskell type representing the C short
type.
data CUShort
Haskell type representing the C unsigned short
type.
data CInt
Haskell type representing the C int
type.
data CUInt
Haskell type representing the C unsigned int
type.
data CLong
Haskell type representing the C long
type.
data CULong
Haskell type representing the C unsigned long
type.
data CLLong
Haskell type representing the C long long
type.
data CULLong
Haskell type representing the C unsigned long long
type.
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 CFloat
Haskell type representing the C float
type.
data CDouble
Haskell type representing the C double
type.
data Bool
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
).
data CChar
Haskell type representing the C char
type.
data CSChar
Haskell type representing the C signed char
type.
data CUChar
Haskell type representing the C unsigned char
type.
Lifting and Unlifting
A value of type Int
is a plain Haskell value (unlifted), whereas an
Exp Int
is a lifted value, that is, an integer lifted into the domain
of expressions (an abstract syntax tree in disguise). Both Acc
and Exp
are surface types into which values may be lifted.
In general an Exp Int
cannot be unlifted into an Int
, because the
actual number will not be available until a later stage of execution (e.g.
GPU execution, when run
is called). However, in some cases unlifting
makes sense. For example, unlifting can convert, or unpack, an expression
of tuple type into a tuple of expressions; those expressions, at runtime,
will become tuple dereferences.
The class of types e
which can be lifted into c
.
An associated-type (i.e. a type-level function) that strips all
instances of surface type constructors c
from the input type e
.
For example, the tuple types (Exp Int, Int)
and (Int, Exp
Int)
have the same "Plain" representation. That is, the
following type equality holds:
Plain (Exp Int, Int) ~ (Int,Int) ~ Plain (Int, Exp Int)
class Lift c e => Unlift c e whereSource
A limited subset of types which can be lifted, can also be unlifted.
unlift :: c (Plain e) -> eSource
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.
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)) | |
(Elt e, Slice ix) => Unlift Exp (:. (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)Source
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)Source
Lift a binary function into Exp
.
ilift1 :: (Exp Int -> Exp Int) -> Exp DIM1 -> Exp DIM1Source
Lift a unary function to a computation over rank-1 indices.
ilift2 :: (Exp Int -> Exp Int -> Exp Int) -> Exp DIM1 -> Exp DIM1 -> Exp DIM1Source
Lift a binary function to a computation over rank-1 indices.
Operations
Some of the standard Haskell 98 typeclass functions need to be reimplemented because their types change. If so, function names kept the same and infix operations are suffixed by an asterisk. If not reimplemented here, the standard typeclass instances apply.
Introduction
constant :: Elt t => t -> Exp tSource
Scalar expression inlet: make a Haskell value available for processing in an Accelerate scalar expression.
Note that this embeds the value directly into the expression. Depending on the backend used to execute the computation, this might not always be desirable. For example, a backend that does external code generation may embed this constant directly into the generated code, which means new code will need to be generated and compiled every time the value changes. In such cases, consider instead lifting scalar values into (singleton) arrays so that they can be passed as an input to the computation and thus the value can change without the need to generate fresh code.
Tuples
fst :: forall f a b. Unlift f (f a, f b) => f (Plain (f a), Plain (f b)) -> f aSource
Extract the first component of a pair.
snd :: forall f a b. Unlift f (f a, f b) => f (Plain (f a), Plain (f b)) -> f bSource
Extract the second component of a pair.
curry :: Lift f (f a, f b) => (f (Plain (f a), Plain (f b)) -> f c) -> f a -> f b -> f cSource
Converts an uncurried function to a curried function.
uncurry :: Unlift f (f a, f b) => (f a -> f b -> f c) -> f (Plain (f a), Plain (f b)) -> f cSource
Converts a curried function to a function on pairs.
Conditional
(?) :: Elt t => Exp Bool -> (Exp t, Exp t) -> Exp tSource
Conditional expression. If the predicate evaluates to True
, the first
component of the tuple is returned, else the second.
Basic operations
(==*) :: (Elt t, IsScalar t) => Exp t -> Exp t -> Exp BoolSource
Equality lifted into Accelerate expressions.
(/=*) :: (Elt t, IsScalar t) => Exp t -> Exp t -> Exp BoolSource
Inequality lifted into Accelerate expressions.
(<*) :: (Elt t, IsScalar t) => Exp t -> Exp t -> Exp BoolSource
Smaller-than lifted into Accelerate expressions.
(<=*) :: (Elt t, IsScalar t) => Exp t -> Exp t -> Exp BoolSource
Smaller-or-equal lifted into Accelerate expressions.
(>*) :: (Elt t, IsScalar t) => Exp t -> Exp t -> Exp BoolSource
Greater-than lifted into Accelerate expressions.
(>=*) :: (Elt t, IsScalar t) => Exp t -> Exp t -> Exp BoolSource
Greater-or-equal lifted into Accelerate expressions.
Numeric functions
truncate :: (Elt a, Elt b, IsFloating a, IsIntegral b) => Exp a -> Exp bSource
truncate x
returns the integer nearest x
between zero and x
.
round :: (Elt a, Elt b, IsFloating a, IsIntegral b) => Exp a -> Exp bSource
round x
returns the nearest integer to x
, or the even integer if x
is
equidistant between two integers.
floor :: (Elt a, Elt b, IsFloating a, IsIntegral b) => Exp a -> Exp bSource
floor x
returns the greatest integer not greater than x
.
ceiling :: (Elt a, Elt b, IsFloating a, IsIntegral b) => Exp a -> Exp bSource
ceiling x
returns the least integer not less than x
.
Bitwise functions
bit :: (Elt t, IsIntegral t) => Exp Int -> Exp tSource
bit i
is a value with the i
th bit set and all other bits clear
setBit :: (Elt t, IsIntegral t) => Exp t -> Exp Int -> Exp tSource
x `setBit` i
is the same as x .|. bit i
clearBit :: (Elt t, IsIntegral t) => Exp t -> Exp Int -> Exp tSource
x `clearBit` i
is the same as x .&. complement (bit i)
complementBit :: (Elt t, IsIntegral t) => Exp t -> Exp Int -> Exp tSource
x `complementBit` i
is the same as x `xor` bit i
testBit :: (Elt t, IsIntegral t) => Exp t -> Exp Int -> Exp BoolSource
Return True
if the n
th bit of the argument is 1
shift :: (Elt t, IsIntegral t) => Exp t -> Exp Int -> Exp tSource
shifts shift
x ix
left by i
bits if i
is positive, or right by
-i
bits otherwise. Right shifts perform sign extension on signed number
types; i.e. they fill the top bits with 1 if the x
is negative and with 0
otherwise.
shiftL :: (Elt t, IsIntegral t) => Exp t -> Exp Int -> Exp tSource
Shift the argument left by the specified number of bits (which must be non-negative).
shiftR :: (Elt t, IsIntegral t) => Exp t -> Exp Int -> Exp tSource
Shift the first argument right by the specified number of bits. The result
is undefined for negative shift amounts and shift amounts greater or equal to
the bitSize
.
Right shifts perform sign extension on signed number types; i.e. they fill
the top bits with 1 if the x
is negative and with 0 otherwise.
rotate :: (Elt t, IsIntegral t) => Exp t -> Exp Int -> Exp tSource
rotates rotate
x ix
left by i
bits if i
is positive, or right by
-i
bits otherwise.
rotateL :: (Elt t, IsIntegral t) => Exp t -> Exp Int -> Exp tSource
Rotate the argument left by the specified number of bits (which must be non-negative).
rotateR :: (Elt t, IsIntegral t) => Exp t -> Exp Int -> Exp tSource
Rotate the argument right by the specified number of bits (which must be non-negative).
Shape manipulation
index1 :: Elt i => Exp i -> Exp (Z :. i)Source
Turn an Int
expression into a rank-1 indexing expression.
unindex1 :: Elt i => Exp (Z :. i) -> Exp iSource
Turn a rank-1 indexing expression into an Int
expression.
index2 :: (Elt i, Slice (Z :. i)) => Exp i -> Exp i -> Exp ((Z :. i) :. i)Source
Creates a rank-2 index from two Exp Int`s
unindex2 :: forall i. (Elt i, Slice (Z :. i)) => Exp ((Z :. i) :. i) -> Exp (i, i)Source
Destructs a rank-2 index to an Exp tuple of two Int`s.
indexTail :: Slice sh => Exp (sh :. Int) -> Exp shSource
Get all but the outermost element of a shape
toIndex :: Shape sh => Exp sh -> Exp sh -> Exp IntSource
Map a multi-dimensional index into a linear, row-major representation of an array. The first argument is the array shape, the second is the index.
Conversions
fromIntegral :: (Elt a, Elt b, IsIntegral a, IsNum b) => Exp a -> Exp bSource
General coercion from integral types
Plain arrays
Operations
arrayShape :: Shape sh => Array sh e -> shSource
Array shape in plain Haskell code
indexArray :: Array sh e -> sh -> eSource
Array indexing in plain Haskell code
Conversions
For additional conversion routines, see the accelerate-io package: http://hackage.haskell.org/package/accelerate-io
Lists
fromList :: (Shape sh, Elt e) => sh -> [e] -> Array sh eSource
Convert a list, with elements in row-major order, into an accelerated array.
toList :: forall sh e. Array sh e -> [e]Source
Convert an accelerated array to a list in row-major order.
IArray
fromIArray :: (EltRepr ix ~ EltRepr sh, IArray a e, Ix ix, Shape sh, Elt ix, Elt e) => a ix e -> Array sh eSource
Convert an IArray
to an accelerated array.
While the type signature mentions Accelerate internals that are not exported,
in practice satisfying the type equality is straight forward. The index type
ix
must be the unit type ()
for singleton arrays, or an Int
or tuple of
Int
's for multidimensional arrays.