# accelerate-1.0.0.0: An embedded language for accelerated array processing

`Data.Array.Accelerate`

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

*A simple example*

As a simple example, consider the computation of a dot product of two vectors of floating point numbers:

dotp :: Acc (Vector Float) -> Acc (Vector Float) -> Acc (Scalar Float) dotp xs ys = fold (+) 0 (zipWith (*) xs ys)

Except for the type, this code is almost the same as the corresponding Haskell
code on lists of floats. The types indicate that the computation may be
online-compiled for performance - for example, using
`Data.Array.Accelerate.LLVM.PTX`

it may be on-the-fly off-loaded to the GPU.

*Additional components*

The following supported add-ons are available as separate packages. Install
them from Hackage with `cabal install <package>`

`accelerate-llvm-native`

: Backend supporting parallel execution on multicore CPUs.`accelerate-llvm-ptx`

: Backend supporting parallel execution on CUDA-capable NVIDIA GPUs. Requires a GPU with compute capability 2.0 or greater. See the following table for supported GPUs: http://en.wikipedia.org/wiki/CUDA#Supported_GPUs`accelerate-cuda`

: Backend targeting CUDA-enabled NVIDIA GPUs. Requires a GPU with compute compatibility 1.2 or greater. /NOTE: This backend is being deprecated in favour of`accelerate-llvm-ptx`

./`accelerate-examples`

: Computational kernels and applications showcasing the use of Accelerate as well as a regression test suite, supporting function and performance testing.`accelerate-io`

: Fast conversions between Accelerate arrays and other array formats (including vector and repa).`accelerate-fft`

: Discrete Fourier transforms, with FFI bindings to optimised implementations.`accelerate-bignum`

: Fixed-width large integer arithmetic.`colour-accelerate`

: Colour representations in Accelerate (RGB, sRGB, HSV, and HSL).`gloss-accelerate`

: Generate gloss pictures from Accelerate.`gloss-raster-accelerate`

: Parallel rendering of raster images and animations.`lens-accelerate`

: Lens operators for Accelerate types.`linear-accelerate`

: Linear vector spaces in Accelerate.`mwc-random-accelerate`

: Generate Accelerate arrays filled with high quality pseudorandom numbers.

*Examples and documentation*

Haddock documentation is included in the package

The `accelerate-examples`

package demonstrates a range of computational
kernels and several complete applications, including:

- An implementation of the Canny edge detection algorithm
- An interactive Mandelbrot set generator
- A particle-based simulation of stable fluid flows
- An
*n*-body simulation of gravitational attraction between solid particles - An implementation of the PageRank algorithm
- A simple interactive ray tracer
- A particle based simulation of stable fluid flows
- A cellular automata simulation
- A "password recovery" tool, for dictionary lookup of MD5 hashes

`lulesh-accelerate`

is an implementation of the Livermore Unstructured
Lagrangian Explicit Shock Hydrodynamics (LULESH) mini-app. LULESH represents a
typical hydrodynamics code such as ALE3D, but is highly simplified and
hard-coded to solve the Sedov blast problem on an unstructured hexahedron
mesh.

*Mailing list and contacts*

- Mailing list: accelerate-haskell@googlegroups.com (discussion of both use and development welcome).
- Sign up for the mailing list here: http://groups.google.com/group/accelerate-haskell
- Bug reports and issue tracking: https://github.com/AccelerateHS/accelerate/issues