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.

8-bit signed integer type

16-bit signed integer type

32-bit signed integer type

64-bit signed integer type

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

8-bit unsigned integer type

16-bit unsigned integer type

32-bit unsigned integer type

64-bit unsigned integer type

Haskell type representing the C short type.

Haskell type representing the C unsigned short type.

Haskell type representing the C int type.

Haskell type representing the C unsigned int type.

Haskell type representing the C long type.

Haskell type representing the C unsigned long type.

Haskell type representing the C long long type.

Haskell type representing the C unsigned long long type.

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.

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.

Haskell type representing the C float type.

Haskell type representing the C double type.

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).

Haskell type representing the C char type.

Haskell type representing the C signed char type.

Haskell type representing the C unsigned char type.

All scalar type

Numeric types

Bounded types

Integral types

Floating types

Non-numeric types

Tuples of arrays (of type 'Array dim e'). This characterises the domain of results of Accelerate array computations.

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.

Scalars

Vectors

Segment descriptor

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

Surface types representing array indices and slices ----------------------------------------------------

Array indices are snoc type lists

For example, the type of a rank-2 array index is 'Z :.Int :. Int'.

Rank-0 index

Increase an index rank by one dimension

Shapes and indices of multi-dimensional arrays

Marker for entire dimensions in slice descriptors

Marker for arbitrary shapes in slice descriptors

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

Array shape in plain Haskell code

Array indexing in plain Haskell code

Convert an IArray to an accelerated array.

Convert an accelerated array to an IArray

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

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

Array-valued collective computations

Scalar expressions for plain array computations.

Boundary condition specification for stencil operations.

Smart constructors for stencil reification -------------------------------------------

Constant scalar expression

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

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

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.

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

Extract the first component of an array pair.

Extract the second component of an array pair.

Create an array pair from two separate arrays.

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

 precondition: size ix == size ix'

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.

Apply the given function elementwise to the given array.

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

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.

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

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.

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.

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.

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

List style left-to-right scan without an intial 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

Right-to-left variant of scanl.

Right-to-left variant of 'scanl\''.

Right-to-left variant of scanl1.

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. Eltents that are mapped to the magic value ignore by the permutation function are being dropped.

Backward permutation

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.

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 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 subcomputations, 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.

An array-level if-then-else construct.

Infix version of cond.