The representation tag for manifest arrays based on Data.Array.Accelerate.

The Accelerate array implementation is based on type families and picks an efficient, unboxed representation for every element type. Moreover, these arrays can be handed efficiently (without copying) to Accelerate programs for further computation.

Index conversion and equivalence statement between Repa and Accelerate array shapes. That is, a n-dimensional Repa array will produce an n-dimensional Accelerate array of the same extent, and vice-versa.

O(1). Unpack to an Accelerate array.

O(1). Wrap an Accelerate array.

Sequential computation of array elements

Parallel computation of array elements

A family of types that represents a collection of storable Vectors. The structure of the collection depends on the element type e.

For example:

• if e :: Int, then Vectors (EltRepr e) :: ((), Vector Int)
• if e :: (Double, Float), then Vectors (EltRepr e) :: (((), Vector Double), Vector Float)

O(1). Turn the Accelerate array into a collection of storable Vectors. The element type of the array e will determine the structure of the output collection. See Vectors.

Data will be output in row-major order.

O(1). Treat a set of storable vectors as Accelerate arrays. The type of elements e in the output Accelerate array determines the structure of the collection that will be required as the second argument. See Vectors.

Data will be consumed from the vector in row-major order. You must make sure that each of the input vectors contains the right number of elements

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.

Convert an accelerated array to an IArray.

Packed RGBA pixel data

Read RGBA components from a BMP file.

Write the image data to a file.

A family of types that represents a collection of ByteStrings. They are the source data for function fromByteString and the result data for toByteString

Block copies bytes from a collection of ByteStrings to freshly allocated Accelerate array.

The type of elements (e) in the output Accelerate array determines the structure of the collection of ByteStrings that will be required as the second argument to this function. See ByteStrings

Block copy from an Accelerate array to a collection of freshly allocated ByteStrings.

The type of elements (e) in the input Accelerate array determines the structure of the collection of ByteStrings that will be output. See ByteStrings

A family of types that represents a collection of pointers that are the source/destination addresses for a block copy. The structure of the collection of pointers depends on the element type e.

e.g.

If e :: Int, then BlockPtrs (EltRepr e) :: ((), Ptr Int)

If e :: (Double, Float) then BlockPtrs (EltRepr e) :: (((), Ptr Double), Ptr Float)

Block copy regions of memory into a freshly allocated Accelerate array. The type of elements (e) in the output Accelerate array determines the structure of the collection of pointers that will be required as the second argument to this function. See BlockPtrs

Each one of these pointers points to a block of memory that is the source of data for the Accelerate array (unlike function toArray where one passes in function which copies data to a destination address.).

Block copy from Accelerate array to pre-allocated regions of memory. The type of element of the input Accelerate array (e) determines the structure of the collection of pointers that will be required as the second argument to this function. See BlockPtrs

The memory associated with the pointers must have already been allocated.

Functions of this type are passed as arguments to toArray. A function of this type should copy a number of bytes (equal to the value of the parameter of type Int) to the destination memory pointed to by Ptr e.

Represents a collection of "block copy functions" (see BlockCopyFun). The structure of the collection of BlockCopyFuns depends on the element type e.

e.g.

If e :: Float then BlockCopyFuns (EltRepr e) :: ((), Ptr Float -> Int -> IO ())

If e :: (Double, Float) then BlockCopyFuns (EltRepr e) :: (((), Ptr Double -> Int -> IO ()), Ptr Float -> Int -> IO ())

Copy values from an Accelerate array using a collection of functions that have type BlockCopyFun. The argument of type Ptr e in each of these functions refers to the address of the source block of memory in the Accelerate Array. The destination address is implicit. e.g. the BlockCopyFun could be the result of partially application to a Ptr e pointing to the destination block.

The structure of this collection of functions depends on the elemente type e. Each function (of type BlockCopyFun) copies data to a destination address (pointed to by the argument of type Ptr ()).

Unless there is a particularly pressing reason to use this function, the fromPtr function is sufficient as it uses an efficient low-level call to libc's memcpy to perform the copy.

Copy values to a freshly allocated Accelerate array using a collection of functions that have type BlockCopyFun. The argument of type Ptr e in each of these functions refers to the address of the destination block of memory in the Accelerate Array. The source address is implicit. e.g. the BlockCopyFun could be the result of a partial application to a Ptr e pointing to the source block.

The structure of this collection of functions depends on the elemente type e. Each function (of type BlockCopyFun) copies data to a destination address (pointed to by the argument of type Ptr ()).

Unless there is a particularly pressing reason to use this function, the fromPtr function is sufficient as it uses an efficient low-level call to libc's memcpy to perform the copy.