accelerate-1.1.1.0: An embedded language for accelerated array processing

Copyright[2008..2017] Manuel M T Chakravarty Gabriele Keller
[2009..2017] Trevor L. McDonell
[2013..2017] Robert Clifton-Everest
[2014..2014] Frederik M. Madsen
LicenseBSD3
MaintainerTrevor L. McDonell <tmcdonell@cse.unsw.edu.au>
Stabilityexperimental
Portabilitynon-portable (GHC extensions)
Safe HaskellNone
LanguageHaskell98

Data.Array.Accelerate

Contents

Description

Data.Array.Accelerate defines an embedded language of array 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 are online compiled and can be executed on a range of architectures.

Abstract interface:

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

Stratified language:

Accelerate distinguishes the types of collective operations Acc from the type of scalar operations Exp to achieve a stratified language. Collective operations comprise many scalar computations that are executed in parallel, but scalar computations can not contain collective operations. This separation excludes nested, irregular data-parallelism statically; instead, Accelerate is limited to flat data-parallelism involving only regular, multi-dimensional arrays.

Optimisations:

Accelerate uses a number of scalar and array optimisations, including array fusion, in order to improve the performance of programs. Fusing a program entails combining successive traversals (loops) over an array into a single traversal, which reduces memory traffic and eliminates intermediate arrays.

Code execution:

Several backends are available which can be used to evaluate accelerate programs:

Examples:
  • The accelerate-examples package demonstrates a range of computational kernels and several complete applications:

    • Implementation of the canny edge detector
    • Interactive Mandelbrot set generator
    • N-body simulation of gravitational attraction between large bodies
    • Implementation of the PageRank algorithm
    • A simple, real-time, interactive ray tracer.
    • A particle based simulation of stable fluid flows
    • A cellular automaton simulation
    • A "password recovery" tool, for dictionary attacks on MD5 hashes.

  • lulesh-accelerate is an implementation of the Livermore Unstructured Lagrangian Explicit Shock Hydrodynamics (LULESH) application. LULESH is representative of typical hydrodynamics codes, although simplified and hard-coded to solve the Sedov blast problem on an unstructured hexahedron mesh.

Additional components:
Contact:
Tip:

Accelerate tends to stress GHC's garbage collector, so it helps to increase the default GC allocation sizes. This can be done when running an executable by specifying RTS options on the command line, for example:

./foo +RTS -A64M -n2M -RTS

You can make these settings the default by adding the following ghc-options to your .cabal file or similar:

ghc-options: -with-rtsopts=-n2M -with-rtsopts=-A64M

To specify RTS options you will also need to compile your program with -rtsopts.

Synopsis

The Accelerate Array Language

Embedded array computations

data Acc a Source #

Accelerate is an embedded language that distinguishes between vanilla arrays (e.g. in Haskell memory on the CPU) and embedded arrays (e.g. in device memory on a GPU), as well as the computations on both of these. Since Accelerate is an embedded language, programs written in Accelerate are not compiled by the Haskell compiler (GHC). Rather, each Accelerate backend is a runtime compiler which generates and executes parallel SIMD code of the target language at application runtime.

The type constructor Acc represents embedded collective array operations. A term of type Acc a is an Accelerate program which, once executed, will produce a value of type a (an Array or a tuple of Arrays). Collective operations of type Acc a comprise many scalar expressions, wrapped in type constructor Exp, which will be executed in parallel. Although collective operations comprise many scalar operations executed in parallel, scalar operations cannot initiate new collective operations: this stratification between scalar operations in Exp and array operations in Acc helps statically exclude nested data parallelism, which is difficult to execute efficiently on constrained hardware such as GPUs.

For example, to compute a vector dot product we could write:

dotp :: Num a => Vector a -> Vector a -> Acc (Scalar a)
dotp xs ys =
  let
      xs' = use xs
      ys' = use ys
  in
  fold (+) 0 ( zipWith (*) xs' ys' )

The function dotp consumes two one-dimensional arrays (Vectors) of values, and produces a single (Scalar) result as output. As the return type is wrapped in the type Acc, we see that it is an embedded Accelerate computation - it will be evaluated in the object language of dynamically generated parallel code, rather than the meta language of vanilla Haskell.

As the arguments to dotp are plain Haskell arrays, to make these available to Accelerate computations they must be embedded with the use function.

An Accelerate backend is used to evaluate the embedded computation and return the result back to vanilla Haskell. Calling the run function of a backend will generate code for the target architecture, compile, and execute it. For example, the following backends are available:

See also Exp, which encapsulates embedded scalar computations.

Fusion:

Array computations of type Acc will be subject to array fusion; Accelerate will combine individual Acc computations into a single computation, which reduces the number of traversals over the input data and thus improves performance. As such, it is often useful to have some intuition on when fusion should occur.

The main idea is to first partition array operations into two categories:

  1. Element-wise operations, such as map, generate, and backpermute. Each element of these operations can be computed independently of all others.
  2. Collective operations such as fold, scanl, and stencil. To compute each output element of these operations requires reading multiple elements from the input array(s).

Element-wise operations fuse together whenever the consumer operation uses a single element of the input array. Element-wise operations can both fuse their inputs into themselves, as well be fused into later operations. Both these examples should fuse into a single loop:

map -> reverse -> reshape -> map -> map
map -> backpermute ->
                      zipWith -> map
          generate ->

If the consumer operation uses more than one element of the input array (typically, via generate indexing an array multiple times), then the input array will be completely evaluated first; no fusion occurs in this case, because fusing the first operation into the second implies duplicating work.

On the other hand, collective operations can fuse their input arrays into themselves, but on output always evaluate to an array; collective operations will not be fused into a later step. For example:

     use ->
            zipWith -> fold |-> map
generate ->

Here the element-wise sequence (use + generate + zipWith) will fuse into a single operation, which then fuses into the collective fold operation. At this point in the program the fold must now be evaluated. In the final step the map reads in the array produced by fold. As there is no fusion between the fold and map steps, this program consists of two "loops"; one for the use + generate + zipWith + fold step, and one for the final map step.

You can see how many operations will be executed in the fused program by Show-ing the Acc program, or by using the debugging option -ddump-dot to save the program as a graphviz DOT file.

As a special note, the operations unzip and reshape, when applied to a real array, are executed in constant time, so in this situation these operations will not be fused.

Tips:
  • Since Acc represents embedded computations that will only be executed when evaluated by a backend, we can programatically generate these computations using the meta language Haskell; for example, unrolling loops or embedding input values into the generated code.
  • It is usually best to keep all intermediate computations in Acc, and only run the computation at the very end to produce the final result. This enables optimisations between intermediate results (e.g. array fusion) and, if the target architecture has a separate memory space as is the case of GPUs, to prevent excessive data transfers.

Instances

IfThenElse Acc Source # 

Associated Types

type EltT (Acc :: * -> *) a :: Constraint Source #

Methods

ifThenElse :: EltT Acc a => Exp Bool -> Acc a -> Acc a -> Acc a Source #

Unlift Acc (Acc a) Source # 

Methods

unlift :: Acc (Plain (Acc a)) -> Acc a Source #

Lift Acc (Acc a) Source # 

Associated Types

type Plain (Acc a) :: * Source #

Methods

lift :: Acc a -> Acc (Plain (Acc a)) Source #

(Arrays a, Arrays b) => Unlift Acc (Acc a, Acc b) Source # 

Methods

unlift :: Acc (Plain (Acc a, Acc b)) -> (Acc a, Acc b) Source #

(Lift Acc a, Lift Acc b, Arrays (Plain a), Arrays (Plain b)) => Lift Acc (a, b) Source # 

Associated Types

type Plain (a, b) :: * Source #

Methods

lift :: (a, b) -> Acc (Plain (a, b)) Source #

(Shape sh, Elt e) => Lift Acc (Array sh e) Source # 

Associated Types

type Plain (Array sh e) :: * Source #

Methods

lift :: Array sh e -> Acc (Plain (Array sh e)) Source #

(Arrays a, Arrays b, Arrays c) => Unlift Acc (Acc a, Acc b, Acc c) Source # 

Methods

unlift :: Acc (Plain (Acc a, Acc b, Acc c)) -> (Acc a, Acc b, Acc c) Source #

(Lift Acc a, Lift Acc b, Lift Acc c, Arrays (Plain a), Arrays (Plain b), Arrays (Plain c)) => Lift Acc (a, b, c) Source # 

Associated Types

type Plain (a, b, c) :: * Source #

Methods

lift :: (a, b, c) -> Acc (Plain (a, b, c)) Source #

(Arrays a, Arrays b, Arrays c, Arrays d) => Unlift Acc (Acc a, Acc b, Acc c, Acc d) Source # 

Methods

unlift :: Acc (Plain (Acc a, Acc b, Acc c, Acc d)) -> (Acc a, Acc b, Acc c, Acc d) Source #

(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) Source # 

Associated Types

type Plain (a, b, c, d) :: * Source #

Methods

lift :: (a, b, c, d) -> Acc (Plain (a, b, c, d)) Source #

(Arrays a, Arrays b, Arrays c, Arrays d, Arrays e) => Unlift Acc (Acc a, Acc b, Acc c, Acc d, Acc e) Source # 

Methods

unlift :: Acc (Plain (Acc a, Acc b, Acc c, Acc d, Acc e)) -> (Acc a, Acc b, Acc c, Acc d, Acc e) Source #

(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) Source # 

Associated Types

type Plain (a, b, c, d, e) :: * Source #

Methods

lift :: (a, b, c, d, e) -> Acc (Plain (a, b, c, d, e)) Source #

(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) Source # 

Methods

unlift :: Acc (Plain (Acc a, Acc b, Acc c, Acc d, Acc e, Acc f)) -> (Acc a, Acc b, Acc c, Acc d, Acc e, Acc f) Source #

(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) Source # 

Associated Types

type Plain (a, b, c, d, e, f) :: * Source #

Methods

lift :: (a, b, c, d, e, f) -> Acc (Plain (a, b, c, d, e, f)) Source #

(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) Source # 

Methods

unlift :: Acc (Plain (Acc a, Acc b, Acc c, Acc d, Acc e, Acc f, Acc g)) -> (Acc a, Acc b, Acc c, Acc d, Acc e, Acc f, Acc g) Source #

(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) Source # 

Associated Types

type Plain (a, b, c, d, e, f, g) :: * Source #

Methods

lift :: (a, b, c, d, e, f, g) -> Acc (Plain (a, b, c, d, e, f, g)) Source #

(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) Source # 

Methods

unlift :: Acc (Plain (Acc a, Acc b, Acc c, Acc d, Acc e, Acc f, Acc g, Acc h)) -> (Acc a, Acc b, Acc c, Acc d, Acc e, Acc f, Acc g, Acc h) Source #

(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) Source # 

Associated Types

type Plain (a, b, c, d, e, f, g, h) :: * Source #

Methods

lift :: (a, b, c, d, e, f, g, h) -> Acc (Plain (a, b, c, d, e, f, g, h)) Source #

(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) Source # 

Methods

unlift :: Acc (Plain (Acc a, Acc b, Acc c, Acc d, Acc e, Acc f, Acc g, Acc h, Acc i)) -> (Acc a, Acc b, Acc c, Acc d, Acc e, Acc f, Acc g, Acc h, Acc i) Source #

(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) Source # 

Associated Types

type Plain (a, b, c, d, e, f, g, h, i) :: * Source #

Methods

lift :: (a, b, c, d, e, f, g, h, i) -> Acc (Plain (a, b, c, d, e, f, g, h, i)) Source #

(Arrays a, Arrays b, Arrays c, Arrays d, Arrays e, Arrays f, Arrays g, Arrays h, Arrays i, Arrays j) => Unlift Acc (Acc a, Acc b, Acc c, Acc d, Acc e, Acc f, Acc g, Acc h, Acc i, Acc j) Source # 

Methods

unlift :: Acc (Plain (Acc a, Acc b, Acc c, Acc d, Acc e, Acc f, Acc g, Acc h, Acc i, Acc j)) -> (Acc a, Acc b, Acc c, Acc d, Acc e, Acc f, Acc g, Acc h, Acc i, Acc j) Source #

(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, Lift Acc j, 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), Arrays (Plain j)) => Lift Acc (a, b, c, d, e, f, g, h, i, j) Source # 

Associated Types

type Plain (a, b, c, d, e, f, g, h, i, j) :: * Source #

Methods

lift :: (a, b, c, d, e, f, g, h, i, j) -> Acc (Plain (a, b, c, d, e, f, g, h, i, j)) Source #

(Arrays a, Arrays b, Arrays c, Arrays d, Arrays e, Arrays f, Arrays g, Arrays h, Arrays i, Arrays j, Arrays k) => Unlift Acc (Acc a, Acc b, Acc c, Acc d, Acc e, Acc f, Acc g, Acc h, Acc i, Acc j, Acc k) Source # 

Methods

unlift :: Acc (Plain (Acc a, Acc b, Acc c, Acc d, Acc e, Acc f, Acc g, Acc h, Acc i, Acc j, Acc k)) -> (Acc a, Acc b, Acc c, Acc d, Acc e, Acc f, Acc g, Acc h, Acc i, Acc j, Acc k) Source #

(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, Lift Acc j, Lift Acc k, 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), Arrays (Plain j), Arrays (Plain k)) => Lift Acc (a, b, c, d, e, f, g, h, i, j, k) Source # 

Associated Types

type Plain (a, b, c, d, e, f, g, h, i, j, k) :: * Source #

Methods

lift :: (a, b, c, d, e, f, g, h, i, j, k) -> Acc (Plain (a, b, c, d, e, f, g, h, i, j, k)) Source #

(Arrays a, Arrays b, Arrays c, Arrays d, Arrays e, Arrays f, Arrays g, Arrays h, Arrays i, Arrays j, Arrays k, Arrays l) => Unlift Acc (Acc a, Acc b, Acc c, Acc d, Acc e, Acc f, Acc g, Acc h, Acc i, Acc j, Acc k, Acc l) Source # 

Methods

unlift :: Acc (Plain (Acc a, Acc b, Acc c, Acc d, Acc e, Acc f, Acc g, Acc h, Acc i, Acc j, Acc k, Acc l)) -> (Acc a, Acc b, Acc c, Acc d, Acc e, Acc f, Acc g, Acc h, Acc i, Acc j, Acc k, Acc l) Source #

(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, Lift Acc j, Lift Acc k, Lift Acc l, 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), Arrays (Plain j), Arrays (Plain k), Arrays (Plain l)) => Lift Acc (a, b, c, d, e, f, g, h, i, j, k, l) Source # 

Associated Types

type Plain (a, b, c, d, e, f, g, h, i, j, k, l) :: * Source #

Methods

lift :: (a, b, c, d, e, f, g, h, i, j, k, l) -> Acc (Plain (a, b, c, d, e, f, g, h, i, j, k, l)) Source #

(Arrays a, Arrays b, Arrays c, Arrays d, Arrays e, Arrays f, Arrays g, Arrays h, Arrays i, Arrays j, Arrays k, Arrays l, Arrays m) => Unlift Acc (Acc a, Acc b, Acc c, Acc d, Acc e, Acc f, Acc g, Acc h, Acc i, Acc j, Acc k, Acc l, Acc m) Source # 

Methods

unlift :: Acc (Plain (Acc a, Acc b, Acc c, Acc d, Acc e, Acc f, Acc g, Acc h, Acc i, Acc j, Acc k, Acc l, Acc m)) -> (Acc a, Acc b, Acc c, Acc d, Acc e, Acc f, Acc g, Acc h, Acc i, Acc j, Acc k, Acc l, Acc m) Source #

(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, Lift Acc j, Lift Acc k, Lift Acc l, Lift Acc m, 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), Arrays (Plain j), Arrays (Plain k), Arrays (Plain l), Arrays (Plain m)) => Lift Acc (a, b, c, d, e, f, g, h, i, j, k, l, m) Source # 

Associated Types

type Plain (a, b, c, d, e, f, g, h, i, j, k, l, m) :: * Source #

Methods

lift :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Acc (Plain (a, b, c, d, e, f, g, h, i, j, k, l, m)) Source #

(Arrays a, Arrays b, Arrays c, Arrays d, Arrays e, Arrays f, Arrays g, Arrays h, Arrays i, Arrays j, Arrays k, Arrays l, Arrays m, Arrays n) => Unlift Acc (Acc a, Acc b, Acc c, Acc d, Acc e, Acc f, Acc g, Acc h, Acc i, Acc j, Acc k, Acc l, Acc m, Acc n) Source # 

Methods

unlift :: Acc (Plain (Acc a, Acc b, Acc c, Acc d, Acc e, Acc f, Acc g, Acc h, Acc i, Acc j, Acc k, Acc l, Acc m, Acc n)) -> (Acc a, Acc b, Acc c, Acc d, Acc e, Acc f, Acc g, Acc h, Acc i, Acc j, Acc k, Acc l, Acc m, Acc n) Source #

(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, Lift Acc j, Lift Acc k, Lift Acc l, Lift Acc m, Lift Acc n, 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), Arrays (Plain j), Arrays (Plain k), Arrays (Plain l), Arrays (Plain m), Arrays (Plain n)) => Lift Acc (a, b, c, d, e, f, g, h, i, j, k, l, m, n) Source # 

Associated Types

type Plain (a, b, c, d, e, f, g, h, i, j, k, l, m, n) :: * Source #

Methods

lift :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Acc (Plain (a, b, c, d, e, f, g, h, i, j, k, l, m, n)) Source #

(Arrays a, Arrays b, Arrays c, Arrays d, Arrays e, Arrays f, Arrays g, Arrays h, Arrays i, Arrays j, Arrays k, Arrays l, Arrays m, Arrays n, Arrays o) => Unlift Acc (Acc a, Acc b, Acc c, Acc d, Acc e, Acc f, Acc g, Acc h, Acc i, Acc j, Acc k, Acc l, Acc m, Acc n, Acc o) Source # 

Methods

unlift :: Acc (Plain (Acc a, Acc b, Acc c, Acc d, Acc e, Acc f, Acc g, Acc h, Acc i, Acc j, Acc k, Acc l, Acc m, Acc n, Acc o)) -> (Acc a, Acc b, Acc c, Acc d, Acc e, Acc f, Acc g, Acc h, Acc i, Acc j, Acc k, Acc l, Acc m, Acc n, Acc o) Source #

(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, Lift Acc j, Lift Acc k, Lift Acc l, Lift Acc m, Lift Acc n, Lift Acc o, 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), Arrays (Plain j), Arrays (Plain k), Arrays (Plain l), Arrays (Plain m), Arrays (Plain n), Arrays (Plain o)) => Lift Acc (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) Source # 

Associated Types

type Plain (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) :: * Source #

Methods

lift :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Acc (Plain (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)) Source #

type EltT Acc a Source # 
type EltT Acc a = Arrays a
type Plain (Acc a) Source # 
type Plain (Acc a) = a

Arrays

data Array sh e Source #

Dense, regular, multi-dimensional arrays.

The Array is the core computational unit of Accelerate; all programs in Accelerate take zero or more arrays as input and produce one or more arrays as output. The Array type has two type parameters:

  • sh: is the shape of the array, tracking the dimensionality and extent of each dimension of the array; for example, DIM1 for one-dimensional Vectors, DIM2 for two-dimensional matrices, and so on.
  • e: represents the type of each element of the array; for example, Int, Float, et cetera.

Array data is store unboxed in an unzipped struct-of-array representation. Elements are laid out in row-major order (the right-most index of a Shape is the fastest varying). The allowable array element types are members of the Elt class, which roughly consists of:

  • Signed and unsigned integers (8, 16, 32, and 64-bits wide).
  • Floating point numbers (single and double precision)
  • Char
  • Bool
  • ()
  • Shapes formed from Z and (:.)
  • Nested tuples of all of these, currently up to 15-elements wide.

Note that Array itself is not an allowable element type---there are no nested arrays in Accelerate, regular arrays only!

If device and host memory are separate, arrays will be transferred to the device when necessary (possibly asynchronously and in parallel with other tasks) and cached on the device if sufficient memory is available. Arrays are made available to embedded language computations via use.

Section "Getting data in" lists functions for getting data into and out of the Array type.

Instances

(Shape sh, Elt e) => Lift Acc (Array sh e) Source # 

Associated Types

type Plain (Array sh e) :: * Source #

Methods

lift :: Array sh e -> Acc (Plain (Array sh e)) Source #

Elt e => IsList (Vector e) Source # 

Associated Types

type Item (Vector e) :: * #

Methods

fromList :: [Item (Vector e)] -> Vector e #

fromListN :: Int -> [Item (Vector e)] -> Vector e #

toList :: Vector e -> [Item (Vector e)] #

Show (Vector e) Source # 

Methods

showsPrec :: Int -> Vector e -> ShowS #

show :: Vector e -> String #

showList :: [Vector e] -> ShowS #

Show (Scalar e) Source # 

Methods

showsPrec :: Int -> Scalar e -> ShowS #

show :: Scalar e -> String #

showList :: [Scalar e] -> ShowS #

(Eq sh, Eq e) => Eq (Array sh e) Source # 

Methods

(==) :: Array sh e -> Array sh e -> Bool #

(/=) :: Array sh e -> Array sh e -> Bool #

Show (Array sh e) Source # 

Methods

showsPrec :: Int -> Array sh e -> ShowS #

show :: Array sh e -> String #

showList :: [Array sh e] -> ShowS #

Show (Array DIM2 e) Source # 

Methods

showsPrec :: Int -> Array DIM2 e -> ShowS #

show :: Array DIM2 e -> String #

showList :: [Array DIM2 e] -> ShowS #

NFData (Array sh e) Source # 

Methods

rnf :: Array sh e -> () #

(Shape sh, Elt e) => Arrays (Array sh e) Source # 

Methods

arrays :: Array sh e -> ArraysR (ArrRepr (Array sh e))

flavour :: Array sh e -> ArraysFlavour (Array sh e)

toArr :: ArrRepr (Array sh e) -> Array sh e

fromArr :: Array sh e -> ArrRepr (Array sh e)

type Item (Vector e) Source # 
type Item (Vector e) = e
type Plain (Array sh e) Source # 
type Plain (Array sh e) = Array sh e

class (Typeable a, Typeable (ArrRepr a)) => Arrays a Source #

Arrays consists of nested tuples of individual Arrays, currently up to 15-elements wide. Accelerate computations can thereby return multiple results.

Minimal complete definition

arrays, flavour, toArr, fromArr

Instances

Arrays () Source # 

Methods

arrays :: () -> ArraysR (ArrRepr ())

flavour :: () -> ArraysFlavour ()

toArr :: ArrRepr () -> ()

fromArr :: () -> ArrRepr ()

(Arrays a, Arrays b) => Arrays (a, b) Source # 

Methods

arrays :: (a, b) -> ArraysR (ArrRepr (a, b))

flavour :: (a, b) -> ArraysFlavour (a, b)

toArr :: ArrRepr (a, b) -> (a, b)

fromArr :: (a, b) -> ArrRepr (a, b)

(Shape sh, Elt e) => Arrays (Array sh e) Source # 

Methods

arrays :: Array sh e -> ArraysR (ArrRepr (Array sh e))

flavour :: Array sh e -> ArraysFlavour (Array sh e)

toArr :: ArrRepr (Array sh e) -> Array sh e

fromArr :: Array sh e -> ArrRepr (Array sh e)

(Arrays a, Arrays b, Arrays c) => Arrays (a, b, c) Source # 

Methods

arrays :: (a, b, c) -> ArraysR (ArrRepr (a, b, c))

flavour :: (a, b, c) -> ArraysFlavour (a, b, c)

toArr :: ArrRepr (a, b, c) -> (a, b, c)

fromArr :: (a, b, c) -> ArrRepr (a, b, c)

(Arrays a, Arrays b, Arrays c, Arrays d) => Arrays (a, b, c, d) Source # 

Methods

arrays :: (a, b, c, d) -> ArraysR (ArrRepr (a, b, c, d))

flavour :: (a, b, c, d) -> ArraysFlavour (a, b, c, d)

toArr :: ArrRepr (a, b, c, d) -> (a, b, c, d)

fromArr :: (a, b, c, d) -> ArrRepr (a, b, c, d)

(Arrays a, Arrays b, Arrays c, Arrays d, Arrays e) => Arrays (a, b, c, d, e) Source # 

Methods

arrays :: (a, b, c, d, e) -> ArraysR (ArrRepr (a, b, c, d, e))

flavour :: (a, b, c, d, e) -> ArraysFlavour (a, b, c, d, e)

toArr :: ArrRepr (a, b, c, d, e) -> (a, b, c, d, e)

fromArr :: (a, b, c, d, e) -> ArrRepr (a, b, c, d, e)

(Arrays a, Arrays b, Arrays c, Arrays d, Arrays e, Arrays f) => Arrays (a, b, c, d, e, f) Source # 

Methods

arrays :: (a, b, c, d, e, f) -> ArraysR (ArrRepr (a, b, c, d, e, f))

flavour :: (a, b, c, d, e, f) -> ArraysFlavour (a, b, c, d, e, f)

toArr :: ArrRepr (a, b, c, d, e, f) -> (a, b, c, d, e, f)

fromArr :: (a, b, c, d, e, f) -> ArrRepr (a, b, c, d, e, f)

(Arrays a, Arrays b, Arrays c, Arrays d, Arrays e, Arrays f, Arrays g) => Arrays (a, b, c, d, e, f, g) Source # 

Methods

arrays :: (a, b, c, d, e, f, g) -> ArraysR (ArrRepr (a, b, c, d, e, f, g))

flavour :: (a, b, c, d, e, f, g) -> ArraysFlavour (a, b, c, d, e, f, g)

toArr :: ArrRepr (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g)

fromArr :: (a, b, c, d, e, f, g) -> ArrRepr (a, b, c, d, e, f, g)

(Arrays a, Arrays b, Arrays c, Arrays d, Arrays e, Arrays f, Arrays g, Arrays h) => Arrays (a, b, c, d, e, f, g, h) Source # 

Methods

arrays :: (a, b, c, d, e, f, g, h) -> ArraysR (ArrRepr (a, b, c, d, e, f, g, h))

flavour :: (a, b, c, d, e, f, g, h) -> ArraysFlavour (a, b, c, d, e, f, g, h)

toArr :: ArrRepr (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h)

fromArr :: (a, b, c, d, e, f, g, h) -> ArrRepr (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) => Arrays (a, b, c, d, e, f, g, h, i) Source # 

Methods

arrays :: (a, b, c, d, e, f, g, h, i) -> ArraysR (ArrRepr (a, b, c, d, e, f, g, h, i))

flavour :: (a, b, c, d, e, f, g, h, i) -> ArraysFlavour (a, b, c, d, e, f, g, h, i)

toArr :: ArrRepr (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i)

fromArr :: (a, b, c, d, e, f, g, h, i) -> ArrRepr (a, b, c, d, e, f, g, h, i)

(Arrays a, Arrays b, Arrays c, Arrays d, Arrays e, Arrays f, Arrays g, Arrays h, Arrays i, Arrays j) => Arrays (a, b, c, d, e, f, g, h, i, j) Source # 

Methods

arrays :: (a, b, c, d, e, f, g, h, i, j) -> ArraysR (ArrRepr (a, b, c, d, e, f, g, h, i, j))

flavour :: (a, b, c, d, e, f, g, h, i, j) -> ArraysFlavour (a, b, c, d, e, f, g, h, i, j)

toArr :: ArrRepr (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j)

fromArr :: (a, b, c, d, e, f, g, h, i, j) -> ArrRepr (a, b, c, d, e, f, g, h, i, j)

(Arrays a, Arrays b, Arrays c, Arrays d, Arrays e, Arrays f, Arrays g, Arrays h, Arrays i, Arrays j, Arrays k) => Arrays (a, b, c, d, e, f, g, h, i, j, k) Source # 

Methods

arrays :: (a, b, c, d, e, f, g, h, i, j, k) -> ArraysR (ArrRepr (a, b, c, d, e, f, g, h, i, j, k))

flavour :: (a, b, c, d, e, f, g, h, i, j, k) -> ArraysFlavour (a, b, c, d, e, f, g, h, i, j, k)

toArr :: ArrRepr (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k)

fromArr :: (a, b, c, d, e, f, g, h, i, j, k) -> ArrRepr (a, b, c, d, e, f, g, h, i, j, k)

(Arrays a, Arrays b, Arrays c, Arrays d, Arrays e, Arrays f, Arrays g, Arrays h, Arrays i, Arrays j, Arrays k, Arrays l) => Arrays (a, b, c, d, e, f, g, h, i, j, k, l) Source # 

Methods

arrays :: (a, b, c, d, e, f, g, h, i, j, k, l) -> ArraysR (ArrRepr (a, b, c, d, e, f, g, h, i, j, k, l))

flavour :: (a, b, c, d, e, f, g, h, i, j, k, l) -> ArraysFlavour (a, b, c, d, e, f, g, h, i, j, k, l)

toArr :: ArrRepr (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l)

fromArr :: (a, b, c, d, e, f, g, h, i, j, k, l) -> ArrRepr (a, b, c, d, e, f, g, h, i, j, k, l)

(Arrays a, Arrays b, Arrays c, Arrays d, Arrays e, Arrays f, Arrays g, Arrays h, Arrays i, Arrays j, Arrays k, Arrays l, Arrays m) => Arrays (a, b, c, d, e, f, g, h, i, j, k, l, m) Source # 

Methods

arrays :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> ArraysR (ArrRepr (a, b, c, d, e, f, g, h, i, j, k, l, m))

flavour :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> ArraysFlavour (a, b, c, d, e, f, g, h, i, j, k, l, m)

toArr :: ArrRepr (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m)

fromArr :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> ArrRepr (a, b, c, d, e, f, g, h, i, j, k, l, m)

(Arrays a, Arrays b, Arrays c, Arrays d, Arrays e, Arrays f, Arrays g, Arrays h, Arrays i, Arrays j, Arrays k, Arrays l, Arrays m, Arrays n) => Arrays (a, b, c, d, e, f, g, h, i, j, k, l, m, n) Source # 

Methods

arrays :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> ArraysR (ArrRepr (a, b, c, d, e, f, g, h, i, j, k, l, m, n))

flavour :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> ArraysFlavour (a, b, c, d, e, f, g, h, i, j, k, l, m, n)

toArr :: ArrRepr (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n)

fromArr :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> ArrRepr (a, b, c, d, e, f, g, h, i, j, k, l, m, n)

(Arrays a, Arrays b, Arrays c, Arrays d, Arrays e, Arrays f, Arrays g, Arrays h, Arrays i, Arrays j, Arrays k, Arrays l, Arrays m, Arrays n, Arrays o) => Arrays (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) Source # 

Methods

arrays :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> ArraysR (ArrRepr (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o))

flavour :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> ArraysFlavour (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)

toArr :: ArrRepr (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)

fromArr :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> ArrRepr (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)

type Scalar e = Array DIM0 e Source #

Scalars arrays hold a single element

type Vector e = Array DIM1 e Source #

Vectors are one-dimensional arrays

type Segments i = Vector i Source #

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 elements

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

The Elt class characterises the allowable array element types, and hence the types which can appear in scalar Accelerate expressions.

Accelerate arrays consist of simple atomic types as well as nested tuples thereof, stored efficiently in memory as consecutive unpacked elements without pointers. It roughly consists of:

  • Signed and unsigned integers (8, 16, 32, and 64-bits wide)
  • Floating point numbers (single and double precision)
  • Char
  • Bool
  • ()
  • Shapes formed from Z and (:.)
  • Nested tuples of all of these, currently up to 15-elements wide

Adding new instances for Elt consists of explaining to Accelerate how to map between your data type and a (tuple of) primitive values. For examples see:

Minimal complete definition

eltType, fromElt, toElt

Instances

Elt Bool Source # 

Methods

eltType :: Bool -> TupleType (EltRepr Bool)

fromElt :: Bool -> EltRepr Bool

toElt :: EltRepr Bool -> Bool

Elt Char Source # 

Methods

eltType :: Char -> TupleType (EltRepr Char)

fromElt :: Char -> EltRepr Char

toElt :: EltRepr Char -> Char

Elt Double Source # 

Methods

eltType :: Double -> TupleType (EltRepr Double)

fromElt :: Double -> EltRepr Double

toElt :: EltRepr Double -> Double

Elt Float Source # 

Methods

eltType :: Float -> TupleType (EltRepr Float)

fromElt :: Float -> EltRepr Float

toElt :: EltRepr Float -> Float

Elt Int Source # 

Methods

eltType :: Int -> TupleType (EltRepr Int)

fromElt :: Int -> EltRepr Int

toElt :: EltRepr Int -> Int

Elt Int8 Source # 

Methods

eltType :: Int8 -> TupleType (EltRepr Int8)

fromElt :: Int8 -> EltRepr Int8

toElt :: EltRepr Int8 -> Int8

Elt Int16 Source # 

Methods

eltType :: Int16 -> TupleType (EltRepr Int16)

fromElt :: Int16 -> EltRepr Int16

toElt :: EltRepr Int16 -> Int16

Elt Int32 Source # 

Methods

eltType :: Int32 -> TupleType (EltRepr Int32)

fromElt :: Int32 -> EltRepr Int32

toElt :: EltRepr Int32 -> Int32

Elt Int64 Source # 

Methods

eltType :: Int64 -> TupleType (EltRepr Int64)

fromElt :: Int64 -> EltRepr Int64

toElt :: EltRepr Int64 -> Int64

Elt Word Source # 

Methods

eltType :: Word -> TupleType (EltRepr Word)

fromElt :: Word -> EltRepr Word

toElt :: EltRepr Word -> Word

Elt Word8 Source # 

Methods

eltType :: Word8 -> TupleType (EltRepr Word8)

fromElt :: Word8 -> EltRepr Word8

toElt :: EltRepr Word8 -> Word8

Elt Word16 Source # 

Methods

eltType :: Word16 -> TupleType (EltRepr Word16)

fromElt :: Word16 -> EltRepr Word16

toElt :: EltRepr Word16 -> Word16

Elt Word32 Source # 

Methods

eltType :: Word32 -> TupleType (EltRepr Word32)

fromElt :: Word32 -> EltRepr Word32

toElt :: EltRepr Word32 -> Word32

Elt Word64 Source # 

Methods

eltType :: Word64 -> TupleType (EltRepr Word64)

fromElt :: Word64 -> EltRepr Word64

toElt :: EltRepr Word64 -> Word64

Elt () Source # 

Methods

eltType :: () -> TupleType (EltRepr ())

fromElt :: () -> EltRepr ()

toElt :: EltRepr () -> ()

Elt CChar Source # 

Methods

eltType :: CChar -> TupleType (EltRepr CChar)

fromElt :: CChar -> EltRepr CChar

toElt :: EltRepr CChar -> CChar

Elt CSChar Source # 

Methods

eltType :: CSChar -> TupleType (EltRepr CSChar)

fromElt :: CSChar -> EltRepr CSChar

toElt :: EltRepr CSChar -> CSChar

Elt CUChar Source # 

Methods

eltType :: CUChar -> TupleType (EltRepr CUChar)

fromElt :: CUChar -> EltRepr CUChar

toElt :: EltRepr CUChar -> CUChar

Elt CShort Source # 

Methods

eltType :: CShort -> TupleType (EltRepr CShort)

fromElt :: CShort -> EltRepr CShort

toElt :: EltRepr CShort -> CShort

Elt CUShort Source # 

Methods

eltType :: CUShort -> TupleType (EltRepr CUShort)

fromElt :: CUShort -> EltRepr CUShort

toElt :: EltRepr CUShort -> CUShort

Elt CInt Source # 

Methods

eltType :: CInt -> TupleType (EltRepr CInt)

fromElt :: CInt -> EltRepr CInt

toElt :: EltRepr CInt -> CInt

Elt CUInt Source # 

Methods

eltType :: CUInt -> TupleType (EltRepr CUInt)

fromElt :: CUInt -> EltRepr CUInt

toElt :: EltRepr CUInt -> CUInt

Elt CLong Source # 

Methods

eltType :: CLong -> TupleType (EltRepr CLong)

fromElt :: CLong -> EltRepr CLong

toElt :: EltRepr CLong -> CLong

Elt CULong Source # 

Methods

eltType :: CULong -> TupleType (EltRepr CULong)

fromElt :: CULong -> EltRepr CULong

toElt :: EltRepr CULong -> CULong

Elt CLLong Source # 

Methods

eltType :: CLLong -> TupleType (EltRepr CLLong)

fromElt :: CLLong -> EltRepr CLLong

toElt :: EltRepr CLLong -> CLLong

Elt CULLong Source # 

Methods

eltType :: CULLong -> TupleType (EltRepr CULLong)

fromElt :: CULLong -> EltRepr CULLong

toElt :: EltRepr CULLong -> CULLong

Elt CFloat Source # 

Methods

eltType :: CFloat -> TupleType (EltRepr CFloat)

fromElt :: CFloat -> EltRepr CFloat

toElt :: EltRepr CFloat -> CFloat

Elt CDouble Source # 

Methods

eltType :: CDouble -> TupleType (EltRepr CDouble)

fromElt :: CDouble -> EltRepr CDouble

toElt :: EltRepr CDouble -> CDouble

Elt All Source # 

Methods

eltType :: All -> TupleType (EltRepr All)

fromElt :: All -> EltRepr All

toElt :: EltRepr All -> All

Elt Z Source # 

Methods

eltType :: Z -> TupleType (EltRepr Z)

fromElt :: Z -> EltRepr Z

toElt :: EltRepr Z -> Z

Shape sh => Elt (Any ((:.) sh Int)) Source # 

Methods

eltType :: Any (sh :. Int) -> TupleType (EltRepr (Any (sh :. Int)))

fromElt :: Any (sh :. Int) -> EltRepr (Any (sh :. Int))

toElt :: EltRepr (Any (sh :. Int)) -> Any (sh :. Int)

Elt (Any Z) Source # 

Methods

eltType :: Any Z -> TupleType (EltRepr (Any Z))

fromElt :: Any Z -> EltRepr (Any Z)

toElt :: EltRepr (Any Z) -> Any Z

(Elt a, Elt b) => Elt (a, b) Source # 

Methods

eltType :: (a, b) -> TupleType (EltRepr (a, b))

fromElt :: (a, b) -> EltRepr (a, b)

toElt :: EltRepr (a, b) -> (a, b)

(Elt t, Elt h) => Elt ((:.) t h) Source # 

Methods

eltType :: (t :. h) -> TupleType (EltRepr (t :. h))

fromElt :: (t :. h) -> EltRepr (t :. h)

toElt :: EltRepr (t :. h) -> t :. h

(Elt a, Elt b, Elt c) => Elt (a, b, c) Source # 

Methods

eltType :: (a, b, c) -> TupleType (EltRepr (a, b, c))

fromElt :: (a, b, c) -> EltRepr (a, b, c)

toElt :: EltRepr (a, b, c) -> (a, b, c)

(Elt a, Elt b, Elt c, Elt d) => Elt (a, b, c, d) Source # 

Methods

eltType :: (a, b, c, d) -> TupleType (EltRepr (a, b, c, d))

fromElt :: (a, b, c, d) -> EltRepr (a, b, c, d)

toElt :: EltRepr (a, b, c, d) -> (a, b, c, d)

(Elt a, Elt b, Elt c, Elt d, Elt e) => Elt (a, b, c, d, e) Source # 

Methods

eltType :: (a, b, c, d, e) -> TupleType (EltRepr (a, b, c, d, e))

fromElt :: (a, b, c, d, e) -> EltRepr (a, b, c, d, e)

toElt :: EltRepr (a, b, c, d, e) -> (a, b, c, d, e)

(Elt a, Elt b, Elt c, Elt d, Elt e, Elt f) => Elt (a, b, c, d, e, f) Source # 

Methods

eltType :: (a, b, c, d, e, f) -> TupleType (EltRepr (a, b, c, d, e, f))

fromElt :: (a, b, c, d, e, f) -> EltRepr (a, b, c, d, e, f)

toElt :: EltRepr (a, b, c, d, e, f) -> (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) Source # 

Methods

eltType :: (a, b, c, d, e, f, g) -> TupleType (EltRepr (a, b, c, d, e, f, g))

fromElt :: (a, b, c, d, e, f, g) -> EltRepr (a, b, c, d, e, f, g)

toElt :: EltRepr (a, b, c, d, e, f, g) -> (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) Source # 

Methods

eltType :: (a, b, c, d, e, f, g, h) -> TupleType (EltRepr (a, b, c, d, e, f, g, h))

fromElt :: (a, b, c, d, e, f, g, h) -> EltRepr (a, b, c, d, e, f, g, h)

toElt :: EltRepr (a, b, c, d, e, f, g, h) -> (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) Source # 

Methods

eltType :: (a, b, c, d, e, f, g, h, i) -> TupleType (EltRepr (a, b, c, d, e, f, g, h, i))

fromElt :: (a, b, c, d, e, f, g, h, i) -> EltRepr (a, b, c, d, e, f, g, h, i)

toElt :: EltRepr (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i)

(Elt a, Elt b, Elt c, Elt d, Elt e, Elt f, Elt g, Elt h, Elt i, Elt j) => Elt (a, b, c, d, e, f, g, h, i, j) Source # 

Methods

eltType :: (a, b, c, d, e, f, g, h, i, j) -> TupleType (EltRepr (a, b, c, d, e, f, g, h, i, j))

fromElt :: (a, b, c, d, e, f, g, h, i, j) -> EltRepr (a, b, c, d, e, f, g, h, i, j)

toElt :: EltRepr (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j)

(Elt a, Elt b, Elt c, Elt d, Elt e, Elt f, Elt g, Elt h, Elt i, Elt j, Elt k) => Elt (a, b, c, d, e, f, g, h, i, j, k) Source # 

Methods

eltType :: (a, b, c, d, e, f, g, h, i, j, k) -> TupleType (EltRepr (a, b, c, d, e, f, g, h, i, j, k))

fromElt :: (a, b, c, d, e, f, g, h, i, j, k) -> EltRepr (a, b, c, d, e, f, g, h, i, j, k)

toElt :: EltRepr (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k)

(Elt a, Elt b, Elt c, Elt d, Elt e, Elt f, Elt g, Elt h, Elt i, Elt j, Elt k, Elt l) => Elt (a, b, c, d, e, f, g, h, i, j, k, l) Source # 

Methods

eltType :: (a, b, c, d, e, f, g, h, i, j, k, l) -> TupleType (EltRepr (a, b, c, d, e, f, g, h, i, j, k, l))

fromElt :: (a, b, c, d, e, f, g, h, i, j, k, l) -> EltRepr (a, b, c, d, e, f, g, h, i, j, k, l)

toElt :: EltRepr (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l)

(Elt a, Elt b, Elt c, Elt d, Elt e, Elt f, Elt g, Elt h, Elt i, Elt j, Elt k, Elt l, Elt m) => Elt (a, b, c, d, e, f, g, h, i, j, k, l, m) Source # 

Methods

eltType :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> TupleType (EltRepr (a, b, c, d, e, f, g, h, i, j, k, l, m))

fromElt :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> EltRepr (a, b, c, d, e, f, g, h, i, j, k, l, m)

toElt :: EltRepr (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m)

(Elt a, Elt b, Elt c, Elt d, Elt e, Elt f, Elt g, Elt h, Elt i, Elt j, Elt k, Elt l, Elt m, Elt n) => Elt (a, b, c, d, e, f, g, h, i, j, k, l, m, n) Source # 

Methods

eltType :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> TupleType (EltRepr (a, b, c, d, e, f, g, h, i, j, k, l, m, n))

fromElt :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> EltRepr (a, b, c, d, e, f, g, h, i, j, k, l, m, n)

toElt :: EltRepr (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n)

(Elt a, Elt b, Elt c, Elt d, Elt e, Elt f, Elt g, Elt h, Elt i, Elt j, Elt k, Elt l, Elt m, Elt n, Elt o) => Elt (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) Source # 

Methods

eltType :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> TupleType (EltRepr (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o))

fromElt :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> EltRepr (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)

toElt :: EltRepr (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)

Array shapes & indices

Operations in Accelerate take the form of collective operations over arrays of the type Array sh e. Much like the repa library, arrays in Accelerate are parameterised by a type sh which determines the dimensionality of the array and the type of each index, as well as the type of each element of the array e.

Shape types, and multidimensional array indices, are built like lists (technically; a heterogeneous snoc-list) using Z and (:.):

data Z = Z
data tail :. head = tail :. head

Here, the constructor Z corresponds to a shape with zero dimension (or a Scalar array, with one element) and is used to mark the end of the list. The constructor (:.) adds additional dimensions to the shape on the right. For example:

Z :. Int

is the type of the shape of a one-dimensional array (Vector) indexed by an Int, while:

Z :. Int :. Int

is the type of the shape of a two-dimensional array (a matrix) indexed by an Int in each dimension.

This style is used to construct both the type and value of the shape. For example, to define the shape of a vector of ten elements:

sh :: Z :. Int
sh = Z :. 10

Note that the right-most index is the innermost dimension. This is the fastest-varying index, and corresponds to the elements of the array which are adjacent in memory.

data Z Source #

Rank-0 index

Constructors

Z 

Instances

Eq Z Source # 

Methods

(==) :: Z -> Z -> Bool #

(/=) :: Z -> Z -> Bool #

Show Z Source # 

Methods

showsPrec :: Int -> Z -> ShowS #

show :: Z -> String #

showList :: [Z] -> ShowS #

Slice Z Source # 

Associated Types

type SliceShape Z :: * Source #

type CoSliceShape Z :: * Source #

type FullShape Z :: * Source #

Methods

sliceIndex :: Z -> SliceIndex (EltRepr Z) (EltRepr (SliceShape Z)) (EltRepr (CoSliceShape Z)) (EltRepr (FullShape Z)) Source #

Shape Z Source # 

Methods

rank :: Z -> Int

size :: Z -> Int

empty :: Z

ignore :: Z

intersect :: Z -> Z -> Z

union :: Z -> Z -> Z

toIndex :: Z -> Z -> Int

fromIndex :: Z -> Int -> Z

iter :: Z -> (Z -> a) -> (a -> a -> a) -> a -> a

iter1 :: Z -> (Z -> a) -> (a -> a -> a) -> a

rangeToShape :: (Z, Z) -> Z

shapeToRange :: Z -> (Z, Z)

shapeToList :: Z -> [Int]

listToShape :: [Int] -> Z

sliceAnyIndex :: Z -> SliceIndex (EltRepr (Any Z)) (EltRepr Z) () (EltRepr Z)

sliceNoneIndex :: Z -> SliceIndex (EltRepr Z) () (EltRepr Z) (EltRepr Z)

Elt Z Source # 

Methods

eltType :: Z -> TupleType (EltRepr Z)

fromElt :: Z -> EltRepr Z

toElt :: EltRepr Z -> Z

Unlift Exp Z Source # 

Methods

unlift :: Exp (Plain Z) -> Z Source #

Lift Exp Z Source # 

Associated Types

type Plain Z :: * Source #

Methods

lift :: Z -> Exp (Plain Z) Source #

Elt e => Stencil DIM1 e (Exp e, Exp e, Exp e) Source # 

Associated Types

type StencilRepr DIM1 (Exp e, Exp e, Exp e) :: *

Methods

stencilPrj :: DIM1 -> e -> Exp (StencilRepr DIM1 (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) Source # 

Associated Types

type StencilRepr DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e) :: *

Methods

stencilPrj :: DIM1 -> e -> Exp (StencilRepr DIM1 (Exp e, Exp e, Exp 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) Source # 

Associated Types

type StencilRepr DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e) :: *

Methods

stencilPrj :: DIM1 -> e -> Exp (StencilRepr DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp 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) Source # 

Associated Types

type StencilRepr DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e) :: *

Methods

stencilPrj :: DIM1 -> e -> Exp (StencilRepr DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e)) -> (Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e)

Elt e => IsList (Vector e) Source # 

Associated Types

type Item (Vector e) :: * #

Methods

fromList :: [Item (Vector e)] -> Vector e #

fromListN :: Int -> [Item (Vector e)] -> Vector e #

toList :: Vector e -> [Item (Vector e)] #

Show (Vector e) Source # 

Methods

showsPrec :: Int -> Vector e -> ShowS #

show :: Vector e -> String #

showList :: [Vector e] -> ShowS #

Show (Scalar e) Source # 

Methods

showsPrec :: Int -> Scalar e -> ShowS #

show :: Scalar e -> String #

showList :: [Scalar e] -> ShowS #

Elt (Any Z) Source # 

Methods

eltType :: Any Z -> TupleType (EltRepr (Any Z))

fromElt :: Any Z -> EltRepr (Any Z)

toElt :: EltRepr (Any Z) -> Any Z

Show (Array DIM2 e) Source # 

Methods

showsPrec :: Int -> Array DIM2 e -> ShowS #

show :: Array DIM2 e -> String #

showList :: [Array DIM2 e] -> ShowS #

type SliceShape Z Source # 
type SliceShape Z = Z
type CoSliceShape Z Source # 
type FullShape Z Source # 
type FullShape Z = Z
type Plain Z Source # 
type Plain Z = Z
type Item (Vector e) Source # 
type Item (Vector e) = e

data tail :. head infixl 3 Source #

Increase an index rank by one dimension. The :. operator is used to construct both values and types.

Constructors

tail :. head infixl 3 

Instances

Elt e => Stencil DIM1 e (Exp e, Exp e, Exp e) Source # 

Associated Types

type StencilRepr DIM1 (Exp e, Exp e, Exp e) :: *

Methods

stencilPrj :: DIM1 -> e -> Exp (StencilRepr DIM1 (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) Source # 

Associated Types

type StencilRepr DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e) :: *

Methods

stencilPrj :: DIM1 -> e -> Exp (StencilRepr DIM1 (Exp e, Exp e, Exp 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) Source # 

Associated Types

type StencilRepr DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e) :: *

Methods

stencilPrj :: DIM1 -> e -> Exp (StencilRepr DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp 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) Source # 

Associated Types

type StencilRepr DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e) :: *

Methods

stencilPrj :: DIM1 -> e -> Exp (StencilRepr DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp 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)) Source # 

Methods

unlift :: Exp (Plain (ix :. Exp e)) -> ix :. Exp e Source #

(Elt e, Slice ix) => Unlift Exp ((:.) (Exp ix) (Exp e)) Source # 

Methods

unlift :: Exp (Plain (Exp ix :. Exp e)) -> Exp ix :. Exp e Source #

(Elt e, Slice (Plain ix), Lift Exp ix) => Lift Exp ((:.) ix (Exp e)) Source # 

Associated Types

type Plain ((:.) ix (Exp e)) :: * Source #

Methods

lift :: (ix :. Exp e) -> Exp (Plain (ix :. Exp e)) Source #

(Slice (Plain ix), Lift Exp ix) => Lift Exp ((:.) ix All) Source # 

Associated Types

type Plain ((:.) ix All) :: * Source #

Methods

lift :: (ix :. All) -> Exp (Plain (ix :. All)) Source #

(Slice (Plain ix), Lift Exp ix) => Lift Exp ((:.) ix Int) Source # 

Associated Types

type Plain ((:.) ix Int) :: * Source #

Methods

lift :: (ix :. Int) -> Exp (Plain (ix :. Int)) Source #

Elt e => IsList (Vector e) Source # 

Associated Types

type Item (Vector e) :: * #

Methods

fromList :: [Item (Vector e)] -> Vector e #

fromListN :: Int -> [Item (Vector e)] -> Vector e #

toList :: Vector e -> [Item (Vector e)] #

Show (Vector e) Source # 

Methods

showsPrec :: Int -> Vector e -> ShowS #

show :: Vector e -> String #

showList :: [Vector e] -> ShowS #

Shape sh => Elt (Any ((:.) sh Int)) Source # 

Methods

eltType :: Any (sh :. Int) -> TupleType (EltRepr (Any (sh :. Int)))

fromElt :: Any (sh :. Int) -> EltRepr (Any (sh :. Int))

toElt :: EltRepr (Any (sh :. Int)) -> Any (sh :. Int)

(Eq head, Eq tail) => Eq ((:.) tail head) Source # 

Methods

(==) :: (tail :. head) -> (tail :. head) -> Bool #

(/=) :: (tail :. head) -> (tail :. head) -> Bool #

Show (Array DIM2 e) Source # 

Methods

showsPrec :: Int -> Array DIM2 e -> ShowS #

show :: Array DIM2 e -> String #

showList :: [Array DIM2 e] -> ShowS #

(Show sh, Show sz) => Show ((:.) sh sz) Source # 

Methods

showsPrec :: Int -> (sh :. sz) -> ShowS #

show :: (sh :. sz) -> String #

showList :: [sh :. sz] -> ShowS #

Slice sl => Slice ((:.) sl Int) Source # 

Associated Types

type SliceShape ((:.) sl Int) :: * Source #

type CoSliceShape ((:.) sl Int) :: * Source #

type FullShape ((:.) sl Int) :: * Source #

Methods

sliceIndex :: (sl :. Int) -> SliceIndex (EltRepr (sl :. Int)) (EltRepr (SliceShape (sl :. Int))) (EltRepr (CoSliceShape (sl :. Int))) (EltRepr (FullShape (sl :. Int))) Source #

Slice sl => Slice ((:.) sl All) Source # 

Associated Types

type SliceShape ((:.) sl All) :: * Source #

type CoSliceShape ((:.) sl All) :: * Source #

type FullShape ((:.) sl All) :: * Source #

Methods

sliceIndex :: (sl :. All) -> SliceIndex (EltRepr (sl :. All)) (EltRepr (SliceShape (sl :. All))) (EltRepr (CoSliceShape (sl :. All))) (EltRepr (FullShape (sl :. All))) Source #

Shape sh => Shape ((:.) sh Int) Source # 

Methods

rank :: (sh :. Int) -> Int

size :: (sh :. Int) -> Int

empty :: sh :. Int

ignore :: sh :. Int

intersect :: (sh :. Int) -> (sh :. Int) -> sh :. Int

union :: (sh :. Int) -> (sh :. Int) -> sh :. Int

toIndex :: (sh :. Int) -> (sh :. Int) -> Int

fromIndex :: (sh :. Int) -> Int -> sh :. Int

iter :: (sh :. Int) -> ((sh :. Int) -> a) -> (a -> a -> a) -> a -> a

iter1 :: (sh :. Int) -> ((sh :. Int) -> a) -> (a -> a -> a) -> a

rangeToShape :: (sh :. Int, sh :. Int) -> sh :. Int

shapeToRange :: (sh :. Int) -> (sh :. Int, sh :. Int)

shapeToList :: (sh :. Int) -> [Int]

listToShape :: [Int] -> sh :. Int

sliceAnyIndex :: (sh :. Int) -> SliceIndex (EltRepr (Any (sh :. Int))) (EltRepr (sh :. Int)) () (EltRepr (sh :. Int))

sliceNoneIndex :: (sh :. Int) -> SliceIndex (EltRepr (sh :. Int)) () (EltRepr (sh :. Int)) (EltRepr (sh :. Int))

(Elt t, Elt h) => Elt ((:.) t h) Source # 

Methods

eltType :: (t :. h) -> TupleType (EltRepr (t :. h))

fromElt :: (t :. h) -> EltRepr (t :. h)

toElt :: EltRepr (t :. h) -> 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) Source # 

Associated Types

type StencilRepr ((:.) ((:.) sh Int) Int) (row2, row1, row0) :: *

Methods

stencilPrj :: ((sh :. Int) :. Int) -> a -> Exp (StencilRepr ((sh :. Int) :. Int) (row2, row1, row0)) -> (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) Source # 

Associated Types

type StencilRepr ((:.) ((:.) sh Int) Int) (row1, row2, row3, row4, row5) :: *

Methods

stencilPrj :: ((sh :. Int) :. Int) -> a -> Exp (StencilRepr ((sh :. Int) :. Int) (row1, row2, row3, row4, row5)) -> (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) Source # 

Associated Types

type StencilRepr ((:.) ((:.) sh Int) Int) (row1, row2, row3, row4, row5, row6, row7) :: *

Methods

stencilPrj :: ((sh :. Int) :. Int) -> a -> Exp (StencilRepr ((sh :. Int) :. Int) (row1, row2, row3, row4, row5, row6, row7)) -> (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) Source # 

Associated Types

type StencilRepr ((:.) ((:.) sh Int) Int) (row1, row2, row3, row4, row5, row6, row7, row8, row9) :: *

Methods

stencilPrj :: ((sh :. Int) :. Int) -> a -> Exp (StencilRepr ((sh :. Int) :. Int) (row1, row2, row3, row4, row5, row6, row7, row8, row9)) -> (row1, row2, row3, row4, row5, row6, row7, row8, row9)

type Item (Vector e) Source # 
type Item (Vector e) = e
type SliceShape ((:.) sl Int) Source # 
type SliceShape ((:.) sl Int) = SliceShape sl
type SliceShape ((:.) sl All) Source # 
type CoSliceShape ((:.) sl Int) Source # 
type CoSliceShape ((:.) sl All) Source # 
type FullShape ((:.) sl Int) Source # 
type FullShape ((:.) sl Int) = (:.) (FullShape sl) Int
type FullShape ((:.) sl All) Source # 
type FullShape ((:.) sl All) = (:.) (FullShape sl) Int
type Plain ((:.) ix (Exp e)) Source # 
type Plain ((:.) ix (Exp e)) = (:.) (Plain ix) e
type Plain ((:.) ix All) Source # 
type Plain ((:.) ix All) = (:.) (Plain ix) All
type Plain ((:.) ix Int) Source # 
type Plain ((:.) ix Int) = (:.) (Plain ix) Int

type DIM0 = Z Source #

class (Elt sh, Elt (Any sh), Shape (EltRepr sh), FullShape sh ~ sh, CoSliceShape sh ~ sh, SliceShape sh ~ Z) => Shape sh Source #

Shapes and indices of multi-dimensional arrays

Minimal complete definition

sliceAnyIndex, sliceNoneIndex

Instances

Shape Z Source # 

Methods

rank :: Z -> Int

size :: Z -> Int

empty :: Z

ignore :: Z

intersect :: Z -> Z -> Z

union :: Z -> Z -> Z

toIndex :: Z -> Z -> Int

fromIndex :: Z -> Int -> Z

iter :: Z -> (Z -> a) -> (a -> a -> a) -> a -> a

iter1 :: Z -> (Z -> a) -> (a -> a -> a) -> a

rangeToShape :: (Z, Z) -> Z

shapeToRange :: Z -> (Z, Z)

shapeToList :: Z -> [Int]

listToShape :: [Int] -> Z

sliceAnyIndex :: Z -> SliceIndex (EltRepr (Any Z)) (EltRepr Z) () (EltRepr Z)

sliceNoneIndex :: Z -> SliceIndex (EltRepr Z) () (EltRepr Z) (EltRepr Z)

Shape sh => Shape ((:.) sh Int) Source # 

Methods

rank :: (sh :. Int) -> Int

size :: (sh :. Int) -> Int

empty :: sh :. Int

ignore :: sh :. Int

intersect :: (sh :. Int) -> (sh :. Int) -> sh :. Int

union :: (sh :. Int) -> (sh :. Int) -> sh :. Int

toIndex :: (sh :. Int) -> (sh :. Int) -> Int

fromIndex :: (sh :. Int) -> Int -> sh :. Int

iter :: (sh :. Int) -> ((sh :. Int) -> a) -> (a -> a -> a) -> a -> a

iter1 :: (sh :. Int) -> ((sh :. Int) -> a) -> (a -> a -> a) -> a

rangeToShape :: (sh :. Int, sh :. Int) -> sh :. Int

shapeToRange :: (sh :. Int) -> (sh :. Int, sh :. Int)

shapeToList :: (sh :. Int) -> [Int]

listToShape :: [Int] -> sh :. Int

sliceAnyIndex :: (sh :. Int) -> SliceIndex (EltRepr (Any (sh :. Int))) (EltRepr (sh :. Int)) () (EltRepr (sh :. Int))

sliceNoneIndex :: (sh :. Int) -> SliceIndex (EltRepr (sh :. Int)) () (EltRepr (sh :. Int)) (EltRepr (sh :. Int))

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

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

Minimal complete definition

sliceIndex

Associated Types

type SliceShape sl :: * Source #

type CoSliceShape sl :: * Source #

type FullShape sl :: * Source #

Methods

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

Instances

Slice Z Source # 

Associated Types

type SliceShape Z :: * Source #

type CoSliceShape Z :: * Source #

type FullShape Z :: * Source #

Methods

sliceIndex :: Z -> SliceIndex (EltRepr Z) (EltRepr (SliceShape Z)) (EltRepr (CoSliceShape Z)) (EltRepr (FullShape Z)) Source #

Shape sh => Slice (Any sh) Source # 

Associated Types

type SliceShape (Any sh) :: * Source #

type CoSliceShape (Any sh) :: * Source #

type FullShape (Any sh) :: * Source #

Methods

sliceIndex :: Any sh -> SliceIndex (EltRepr (Any sh)) (EltRepr (SliceShape (Any sh))) (EltRepr (CoSliceShape (Any sh))) (EltRepr (FullShape (Any sh))) Source #

Slice sl => Slice ((:.) sl Int) Source # 

Associated Types

type SliceShape ((:.) sl Int) :: * Source #

type CoSliceShape ((:.) sl Int) :: * Source #

type FullShape ((:.) sl Int) :: * Source #

Methods

sliceIndex :: (sl :. Int) -> SliceIndex (EltRepr (sl :. Int)) (EltRepr (SliceShape (sl :. Int))) (EltRepr (CoSliceShape (sl :. Int))) (EltRepr (FullShape (sl :. Int))) Source #

Slice sl => Slice ((:.) sl All) Source # 

Associated Types

type SliceShape ((:.) sl All) :: * Source #

type CoSliceShape ((:.) sl All) :: * Source #

type FullShape ((:.) sl All) :: * Source #

Methods

sliceIndex :: (sl :. All) -> SliceIndex (EltRepr (sl :. All)) (EltRepr (SliceShape (sl :. All))) (EltRepr (CoSliceShape (sl :. All))) (EltRepr (FullShape (sl :. All))) Source #

data All Source #

Marker for entire dimensions in slice and replicate descriptors.

Occurrences of All indicate the dimensions into which the array's existing extent will be placed unchanged.

See slice and replicate for examples.

Constructors

All 

Instances

Eq All Source # 

Methods

(==) :: All -> All -> Bool #

(/=) :: All -> All -> Bool #

Show All Source # 

Methods

showsPrec :: Int -> All -> ShowS #

show :: All -> String #

showList :: [All] -> ShowS #

Elt All Source # 

Methods

eltType :: All -> TupleType (EltRepr All)

fromElt :: All -> EltRepr All

toElt :: EltRepr All -> All

(Slice (Plain ix), Lift Exp ix) => Lift Exp ((:.) ix All) Source # 

Associated Types

type Plain ((:.) ix All) :: * Source #

Methods

lift :: (ix :. All) -> Exp (Plain (ix :. All)) Source #

Slice sl => Slice ((:.) sl All) Source # 

Associated Types

type SliceShape ((:.) sl All) :: * Source #

type CoSliceShape ((:.) sl All) :: * Source #

type FullShape ((:.) sl All) :: * Source #

Methods

sliceIndex :: (sl :. All) -> SliceIndex (EltRepr (sl :. All)) (EltRepr (SliceShape (sl :. All))) (EltRepr (CoSliceShape (sl :. All))) (EltRepr (FullShape (sl :. All))) Source #

type SliceShape ((:.) sl All) Source # 
type CoSliceShape ((:.) sl All) Source # 
type FullShape ((:.) sl All) Source # 
type FullShape ((:.) sl All) = (:.) (FullShape sl) Int
type Plain ((:.) ix All) Source # 
type Plain ((:.) ix All) = (:.) (Plain ix) All

data Any sh Source #

Marker for arbitrary dimensions in slice and replicate descriptors.

Any can be used in the leftmost position of a slice instead of Z, indicating that any dimensionality is admissible in that position.

See slice and replicate for examples.

Constructors

Any 

Instances

Shape sh => Lift Exp (Any sh) Source # 

Associated Types

type Plain (Any sh) :: * Source #

Methods

lift :: Any sh -> Exp (Plain (Any sh)) Source #

Eq (Any sh) Source # 

Methods

(==) :: Any sh -> Any sh -> Bool #

(/=) :: Any sh -> Any sh -> Bool #

Show (Any sh) Source # 

Methods

showsPrec :: Int -> Any sh -> ShowS #

show :: Any sh -> String #

showList :: [Any sh] -> ShowS #

Shape sh => Slice (Any sh) Source # 

Associated Types

type SliceShape (Any sh) :: * Source #

type CoSliceShape (Any sh) :: * Source #

type FullShape (Any sh) :: * Source #

Methods

sliceIndex :: Any sh -> SliceIndex (EltRepr (Any sh)) (EltRepr (SliceShape (Any sh))) (EltRepr (CoSliceShape (Any sh))) (EltRepr (FullShape (Any sh))) Source #

Shape sh => Elt (Any ((:.) sh Int)) Source # 

Methods

eltType :: Any (sh :. Int) -> TupleType (EltRepr (Any (sh :. Int)))

fromElt :: Any (sh :. Int) -> EltRepr (Any (sh :. Int))

toElt :: EltRepr (Any (sh :. Int)) -> Any (sh :. Int)

Elt (Any Z) Source # 

Methods

eltType :: Any Z -> TupleType (EltRepr (Any Z))

fromElt :: Any Z -> EltRepr (Any Z)

toElt :: EltRepr (Any Z) -> Any Z

type SliceShape (Any sh) Source # 
type SliceShape (Any sh) = sh
type CoSliceShape (Any sh) Source # 
type CoSliceShape (Any sh) = Z
type FullShape (Any sh) Source # 
type FullShape (Any sh) = sh
type Plain (Any sh) Source # 
type Plain (Any sh) = Any sh

Array access

Element indexing

(!) :: (Shape sh, Elt e) => Acc (Array sh e) -> Exp sh -> Exp e infixl 9 Source #

Multidimensional array indexing. Extract the value from an array at the specified zero-based index.

>>> let mat = fromList (Z:.5:.10) [0..]
>>> mat
Matrix (Z :. 5 :. 10)
  [  0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
    10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
    20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
    30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
    40, 41, 42, 43, 44, 45, 46, 47, 48, 49]
>>> mat ! Z:.1:.2
12

(!!) :: (Shape sh, Elt e) => Acc (Array sh e) -> Exp Int -> Exp e infixl 9 Source #

Extract the value from an array at the specified linear index. Multidimensional arrays in Accelerate are stored in row-major order with zero-based indexing.

>>> let mat = fromList (Z:.5:.10) [0..]
>>> mat
Matrix (Z :. 5 :. 10)
  [  0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
    10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
    20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
    30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
    40, 41, 42, 43, 44, 45, 46, 47, 48, 49]
>>> mat !! 12
12

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

Extract the element of a singleton array.

the xs  ==  xs ! Z

Shape information

null :: (Shape sh, Elt e) => Acc (Array sh e) -> Exp Bool Source #

Test whether an array is empty.

length :: Elt e => Acc (Vector e) -> Exp Int Source #

Get the length of a vector.

shape :: (Shape sh, Elt e) => Acc (Array sh e) -> Exp sh Source #

Extract the shape (extent) of an array.

size :: (Shape sh, Elt e) => Acc (Array sh e) -> Exp Int Source #

The number of elements in the array

shapeSize :: Shape sh => Exp sh -> Exp Int Source #

The number of elements that would be held by an array of the given shape.

Construction

Introduction

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

Make an array from vanilla Haskell available for processing within embedded Accelerate computations.

Depending upon which backend is used to eventually execute array computations, use may entail data transfer (e.g. to a GPU).

use is overloaded so that it can accept tuples of Arrays:

>>> let vec = fromList (Z:.10) [0..]  :: Array DIM1 Int
Vector (Z :. 10) [0,1,2,3,4,5,6,7,8,9]
>>> let mat = fromList (Z:.5:.10) [0..]  :: Array DIM2 Int
>>> mat
Matrix (Z :. 5 :. 10)
  [  0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
    10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
    20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
    30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
    40, 41, 42, 43, 44, 45, 46, 47, 48, 49]
>>> let vec' = use vec         :: Acc (Array DIM1 Int)
>>> let mat' = use mat         :: Acc (Array DIM2 Int)
>>> let tup  = use (vec, mat)  :: Acc (Array DIM1 Int, Array DIM2 Int)

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

Construct a singleton (one element) array from a scalar value (or tuple of scalar values).

Initialisation

generate :: (Shape sh, Elt a) => Exp sh -> (Exp sh -> Exp a) -> Acc (Array sh 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)
Vector (Z :. 3) [1.2,1.2,1.2]

Or equivalently:

>>> fill (constant (Z :. 3)) 1.2
Vector (Z :. 3) [1.2,1.2,1.2]

The following will create a vector with the elements [1..10]:

>>> generate (index1 10) (\ix -> unindex1 ix + 1)
Vector (Z :. 10) [1,2,3,4,5,6,7,8,9,10]
NOTE:

Using generate, it is possible to introduce nested data parallelism, which will cause the program to fail.

If the index given by the scalar function is then used to dispatch further parallel work, whose result is returned into Exp terms by array indexing operations such as (!) or the, the program will fail with the error: './Data/Array/Accelerate/Trafo/Sharing.hs:447 (convertSharingExp): inconsistent valuation @ shared 'Exp' tree ...'.

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

Create an array where all elements are the same value.

>>> let zeros = fill (Z:.10) 0
Vector (Z :. 10) [0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0]

Enumeration

enumFromN :: (Shape sh, Num e, FromIntegral Int 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).

>>> enumFromN (constant (Z:.5:.10)) 0 :: Array DIM2 Int
Matrix (Z :. 5 :. 10)
  [  0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
    10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
    20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
    30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
    40, 41, 42, 43, 44, 45, 46, 47, 48, 49]

enumFromStepN Source #

Arguments

:: (Shape sh, Num e, FromIntegral Int e) 
=> Exp sh 
-> Exp e

x: start

-> Exp e

y: step

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

>>> enumFromStepN (constant (Z:.5:.10)) 0 0.5 :: Array DIM2 Float
Matrix (Z :. 5 :. 10)
  [  0.0,  0.5,  1.0,  1.5,  2.0,  2.5,  3.0,  3.5,  4.0,  4.5,
     5.0,  5.5,  6.0,  6.5,  7.0,  7.5,  8.0,  8.5,  9.0,  9.5,
    10.0, 10.5, 11.0, 11.5, 12.0, 12.5, 13.0, 13.5, 14.0, 14.5,
    15.0, 15.5, 16.0, 16.5, 17.0, 17.5, 18.0, 18.5, 19.0, 19.5,
    20.0, 20.5, 21.0, 21.5, 22.0, 22.5, 23.0, 23.5, 24.0, 24.5]

Concatenation

(++) :: forall sh e. (Slice sh, Shape sh, Elt e) => Acc (Array (sh :. Int) e) -> Acc (Array (sh :. Int) e) -> Acc (Array (sh :. Int) e) infixr 5 Source #

Concatenate innermost component of two arrays. The extent of the lower dimensional component is the intersection of the two arrays.

>>> let m1 = fromList (Z:.5:.10) [0..]
>>> m1
Matrix (Z :. 5 :. 10)
  [  0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
    10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
    20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
    30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
    40, 41, 42, 43, 44, 45, 46, 47, 48, 49]
>>> let m2 = fromList (Z:.10:.3) [0..]
>>> m2
Matrix (Z :. 10 :. 3)
  [  0,  1,  2,
     3,  4,  5,
     6,  7,  8,
     9, 10, 11,
    12, 13, 14,
    15, 16, 17,
    18, 19, 20,
    21, 22, 23,
    24, 25, 26,
    27, 28, 29]
>>> use m1 ++ use m2
Matrix (Z :. 5 :. 13)
  [  0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  0,  1,  2,
    10, 11, 12, 13, 14, 15, 16, 17, 18, 19,  3,  4,  5,
    20, 21, 22, 23, 24, 25, 26, 27, 28, 29,  6,  7,  8,
    30, 31, 32, 33, 34, 35, 36, 37, 38, 39,  9, 10, 11,
    40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 12, 13, 14]

Composition

Flow control

(?|) :: Arrays a => Exp Bool -> (Acc a, Acc a) -> Acc a infix 0 Source #

Infix version of acond. If the predicate evaluates to True, the first component of the tuple is returned, else the second.

Enabling the RebindableSyntax extension will allow you to use the standard if-then-else syntax instead.

acond Source #

Arguments

:: Arrays a 
=> Exp Bool

if-condition

-> Acc a

then-array

-> Acc a

else-array

-> Acc a 

An array-level if-then-else construct.

Enabling the RebindableSyntax extension will allow you to use the standard if-then-else syntax instead.

awhile Source #

Arguments

:: Arrays a 
=> (Acc a -> Acc (Scalar Bool))

keep evaluating while this returns True

-> (Acc a -> Acc a)

function to apply

-> Acc a

initial value

-> Acc a 

An array-level while construct. Continue to apply the given function, starting with the initial value, until the test function evaluates to False.

class IfThenElse t where Source #

For use with -XRebindableSyntax, this class provides ifThenElse lifted to both scalar and array types.

Minimal complete definition

ifThenElse

Associated Types

type EltT t a :: Constraint Source #

Methods

ifThenElse :: EltT t a => Exp Bool -> t a -> t a -> t a Source #

Instances

IfThenElse Exp Source # 

Associated Types

type EltT (Exp :: * -> *) a :: Constraint Source #

Methods

ifThenElse :: EltT Exp a => Exp Bool -> Exp a -> Exp a -> Exp a Source #

IfThenElse Acc Source # 

Associated Types

type EltT (Acc :: * -> *) a :: Constraint Source #

Methods

ifThenElse :: EltT Acc a => Exp Bool -> Acc a -> Acc a -> Acc a Source #

Controlling execution

(>->) :: (Arrays a, Arrays b, Arrays c) => (Acc a -> Acc b) -> (Acc b -> Acc c) -> Acc a -> Acc c infixl 1 Source #

Pipelining of two array computations. The first argument will be fully evaluated before being passed to the second computation. This can be used to prevent the argument being fused into the function, for example.

Denotationally, we have

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

For an example use of this operation see the compute function.

compute :: Arrays a => Acc a -> Acc a Source #

Force an array expression to be evaluated, preventing it from fusing with other operations. Forcing operations to be computed to memory, rather than being fused into their consuming function, can sometimes improve performance. For example, computing a matrix transpose could provide better memory locality for the subsequent operation. Preventing fusion to split large operations into several simpler steps could also help by reducing register pressure.

Preventing fusion also means that the individual operations are available to be executed concurrently with other kernels. In particular, consider using this if you have a series of operations that are compute bound rather than memory bound.

Here is the synthetic example:

loop :: Exp Int -> Exp Int
loop ticks =
  let clockRate = 900000   -- kHz
  in  while (\i -> i < clockRate * ticks) (+1) 0

test :: Acc (Vector Int)
test =
  zip3
    (compute $ map loop (use $ fromList (Z:.1) [10]))
    (compute $ map loop (use $ fromList (Z:.1) [10]))
    (compute $ map loop (use $ fromList (Z:.1) [10]))

Without the use of compute, the operations are fused together and the three long-running loops are executed sequentially in a single kernel. Instead, the individual operations can now be executed concurrently, potentially reducing overall runtime.

Element-wise operations

Indexing

indexed :: (Shape sh, Elt a) => Acc (Array sh a) -> Acc (Array sh (sh, a)) Source #

Pair each element with its index

>>> let xs = fromList (Z:.5) [0..]
>>> indexed (use xs)
Vector (Z :. 5) [(Z :. 0,0.0),(Z :. 1,1.0),(Z :. 2,2.0),(Z :. 3,3.0),(Z :. 4,4.0)]
>>> let mat = fromList (Z:.3:.4) [0..]
>>> indexed (use mat)
Matrix (Z :. 3 :. 4)
  [(Z :. 0 :. 0,0.0),(Z :. 0 :. 1,1.0), (Z :. 0 :. 2,2.0), (Z :. 0 :. 3,3.0),
   (Z :. 1 :. 0,4.0),(Z :. 1 :. 1,5.0), (Z :. 1 :. 2,6.0), (Z :. 1 :. 3,7.0),
   (Z :. 2 :. 0,8.0),(Z :. 2 :. 1,9.0),(Z :. 2 :. 2,10.0),(Z :. 2 :. 3,11.0)]

Mapping

map :: (Shape sh, Elt a, Elt b) => (Exp a -> Exp b) -> Acc (Array sh a) -> Acc (Array sh b) Source #

Apply the given function element-wise to an array. Denotationally we have:

map f [x1, x2, ... xn] = [f x1, f x2, ... f xn]
>>> let xs = fromList (Z:.10) [0..]
>>> xs
Vector (Z :. 10) [0,1,2,3,4,5,6,7,8,9]
>>> map (+1) (use xs)
Vector (Z :. 10) [1,2,3,4,5,6,7,8,9,10]

imap :: (Shape sh, Elt a, Elt b) => (Exp sh -> Exp a -> Exp b) -> Acc (Array sh a) -> Acc (Array sh b) Source #

Apply a function to every element of an array and its index

Zipping

zipWith :: (Shape sh, Elt a, Elt b, Elt c) => (Exp a -> Exp b -> Exp c) -> Acc (Array sh a) -> Acc (Array sh b) -> Acc (Array sh 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.

>>> let xs = fromList (Z:.3:.5) [0..]
>>> xs
Matrix (Z :. 3 :. 5)
  [ 0, 1, 2, 3, 4,
    5, 6, 7, 8, 9,
   10,11,12,13,14]
>>> let ys = fromList (Z:.5:.10) [1..]
>>> ys
Matrix (Z :. 5 :. 10)
  [ 1, 2, 3, 4, 5, 6, 7, 8, 9,10,
   11,12,13,14,15,16,17,18,19,20,
   21,22,23,24,25,26,27,28,29,30,
   31,32,33,34,35,36,37,38,39,40,
   41,42,43,44,45,46,47,48,49,50]
>>> zipWith (+) (use xs) (use ys)
Matrix (Z :. 3 :. 5)
  [ 1, 3, 5, 7, 9,
   16,18,20,22,24,
   31,33,35,37,39]

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, analogous to zipWith.

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, analogous to zipWith.

zipWith5 :: (Shape sh, Elt a, Elt b, Elt c, Elt d, Elt e, Elt f) => (Exp a -> Exp b -> Exp c -> Exp d -> Exp e -> Exp f) -> Acc (Array sh a) -> Acc (Array sh b) -> Acc (Array sh c) -> Acc (Array sh d) -> Acc (Array sh e) -> Acc (Array sh f) Source #

Zip five arrays with the given function, analogous to zipWith.

zipWith6 :: (Shape sh, Elt a, Elt b, Elt c, Elt d, Elt e, Elt f, Elt g) => (Exp a -> Exp b -> Exp c -> Exp d -> Exp e -> Exp f -> Exp g) -> Acc (Array sh a) -> Acc (Array sh b) -> Acc (Array sh c) -> Acc (Array sh d) -> Acc (Array sh e) -> Acc (Array sh f) -> Acc (Array sh g) Source #

Zip six arrays with the given function, analogous to zipWith.

zipWith7 :: (Shape sh, Elt a, Elt b, Elt c, Elt d, Elt e, Elt f, Elt g, Elt h) => (Exp a -> Exp b -> Exp c -> Exp d -> Exp e -> Exp f -> Exp g -> Exp h) -> Acc (Array sh a) -> Acc (Array sh b) -> Acc (Array sh c) -> Acc (Array sh d) -> Acc (Array sh e) -> Acc (Array sh f) -> Acc (Array sh g) -> Acc (Array sh h) Source #

Zip seven arrays with the given function, analogous to zipWith.

zipWith8 :: (Shape sh, Elt a, Elt b, Elt c, Elt d, Elt e, Elt f, Elt g, Elt h, Elt i) => (Exp a -> Exp b -> Exp c -> Exp d -> Exp e -> Exp f -> Exp g -> Exp h -> Exp i) -> Acc (Array sh a) -> Acc (Array sh b) -> Acc (Array sh c) -> Acc (Array sh d) -> Acc (Array sh e) -> Acc (Array sh f) -> Acc (Array sh g) -> Acc (Array sh h) -> Acc (Array sh i) Source #

Zip eight arrays with the given function, analogous to zipWith.

zipWith9 :: (Shape sh, Elt a, Elt b, Elt c, Elt d, Elt e, Elt f, Elt g, Elt h, Elt i, Elt j) => (Exp a -> Exp b -> Exp c -> Exp d -> Exp e -> Exp f -> Exp g -> Exp h -> Exp i -> Exp j) -> Acc (Array sh a) -> Acc (Array sh b) -> Acc (Array sh c) -> Acc (Array sh d) -> Acc (Array sh e) -> Acc (Array sh f) -> Acc (Array sh g) -> Acc (Array sh h) -> Acc (Array sh i) -> Acc (Array sh j) Source #

Zip nine arrays with the given function, analogous to zipWith.

izipWith :: (Shape sh, Elt a, Elt b, Elt c) => (Exp sh -> Exp a -> Exp b -> Exp c) -> Acc (Array sh a) -> Acc (Array sh b) -> Acc (Array sh c) Source #

Zip two arrays with a function that also takes the element index

izipWith3 :: (Shape sh, Elt a, Elt b, Elt c, Elt d) => (Exp sh -> 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 a function that also takes the element index, analogous to izipWith.

izipWith4 :: (Shape sh, Elt a, Elt b, Elt c, Elt d, Elt e) => (Exp sh -> 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 that also takes the element index, analogous to zipWith.

izipWith5 :: (Shape sh, Elt a, Elt b, Elt c, Elt d, Elt e, Elt f) => (Exp sh -> Exp a -> Exp b -> Exp c -> Exp d -> Exp e -> Exp f) -> Acc (Array sh a) -> Acc (Array sh b) -> Acc (Array sh c) -> Acc (Array sh d) -> Acc (Array sh e) -> Acc (Array sh f) Source #

Zip five arrays with the given function that also takes the element index, analogous to zipWith.

izipWith6 :: (Shape sh, Elt a, Elt b, Elt c, Elt d, Elt e, Elt f, Elt g) => (Exp sh -> Exp a -> Exp b -> Exp c -> Exp d -> Exp e -> Exp f -> Exp g) -> Acc (Array sh a) -> Acc (Array sh b) -> Acc (Array sh c) -> Acc (Array sh d) -> Acc (Array sh e) -> Acc (Array sh f) -> Acc (Array sh g) Source #

Zip six arrays with the given function that also takes the element index, analogous to zipWith.

izipWith7 :: (Shape sh, Elt a, Elt b, Elt c, Elt d, Elt e, Elt f, Elt g, Elt h) => (Exp sh -> Exp a -> Exp b -> Exp c -> Exp d -> Exp e -> Exp f -> Exp g -> Exp h) -> Acc (Array sh a) -> Acc (Array sh b) -> Acc (Array sh c) -> Acc (Array sh d) -> Acc (Array sh e) -> Acc (Array sh f) -> Acc (Array sh g) -> Acc (Array sh h) Source #

Zip seven arrays with the given function that also takes the element index, analogous to zipWith.

izipWith8 :: (Shape sh, Elt a, Elt b, Elt c, Elt d, Elt e, Elt f, Elt g, Elt h, Elt i) => (Exp sh -> Exp a -> Exp b -> Exp c -> Exp d -> Exp e -> Exp f -> Exp g -> Exp h -> Exp i) -> Acc (Array sh a) -> Acc (Array sh b) -> Acc (Array sh c) -> Acc (Array sh d) -> Acc (Array sh e) -> Acc (Array sh f) -> Acc (Array sh g) -> Acc (Array sh h) -> Acc (Array sh i) Source #

Zip eight arrays with the given function that also takes the element index, analogous to zipWith.

izipWith9 :: (Shape sh, Elt a, Elt b, Elt c, Elt d, Elt e, Elt f, Elt g, Elt h, Elt i, Elt j) => (Exp sh -> Exp a -> Exp b -> Exp c -> Exp d -> Exp e -> Exp f -> Exp g -> Exp h -> Exp i -> Exp j) -> Acc (Array sh a) -> Acc (Array sh b) -> Acc (Array sh c) -> Acc (Array sh d) -> Acc (Array sh e) -> Acc (Array sh f) -> Acc (Array sh g) -> Acc (Array sh h) -> Acc (Array sh i) -> Acc (Array sh j) Source #

Zip nine arrays with the given function that also takes the element index, analogous to zipWith.

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 :: (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 :: (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.

zip5 :: (Shape sh, Elt a, Elt b, Elt c, Elt d, Elt e) => Acc (Array sh a) -> Acc (Array sh b) -> Acc (Array sh c) -> Acc (Array sh d) -> Acc (Array sh e) -> Acc (Array sh (a, b, c, d, e)) Source #

Take five arrays and return an array of five-tuples, analogous to zip.

zip6 :: (Shape sh, Elt a, Elt b, Elt c, Elt d, Elt e, Elt f) => Acc (Array sh a) -> Acc (Array sh b) -> Acc (Array sh c) -> Acc (Array sh d) -> Acc (Array sh e) -> Acc (Array sh f) -> Acc (Array sh (a, b, c, d, e, f)) Source #

Take six arrays and return an array of six-tuples, analogous to zip.

zip7 :: (Shape sh, Elt a, Elt b, Elt c, Elt d, Elt e, Elt f, Elt g) => Acc (Array sh a) -> Acc (Array sh b) -> Acc (Array sh c) -> Acc (Array sh d) -> Acc (Array sh e) -> Acc (Array sh f) -> Acc (Array sh g) -> Acc (Array sh (a, b, c, d, e, f, g)) Source #

Take seven arrays and return an array of seven-tuples, analogous to zip.

zip8 :: (Shape sh, Elt a, Elt b, Elt c, Elt d, Elt e, Elt f, Elt g, Elt h) => Acc (Array sh a) -> Acc (Array sh b) -> Acc (Array sh c) -> Acc (Array sh d) -> Acc (Array sh e) -> Acc (Array sh f) -> Acc (Array sh g) -> Acc (Array sh h) -> Acc (Array sh (a, b, c, d, e, f, g, h)) Source #

Take seven arrays and return an array of seven-tuples, analogous to zip.

zip9 :: (Shape sh, Elt a, Elt b, Elt c, Elt d, Elt e, Elt f, Elt g, Elt h, Elt i) => Acc (Array sh a) -> Acc (Array sh b) -> Acc (Array sh c) -> Acc (Array sh d) -> Acc (Array sh e) -> Acc (Array sh f) -> Acc (Array sh g) -> Acc (Array sh h) -> Acc (Array sh i) -> Acc (Array sh (a, b, c, d, e, f, g, h, i)) Source #

Take seven arrays and return an array of seven-tuples, 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.

If the argument array is manifest in memory, unzip is a no-op.

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.

unzip5 :: (Shape sh, Elt a, Elt b, Elt c, Elt d, Elt e) => Acc (Array sh (a, b, c, d, e)) -> (Acc (Array sh a), Acc (Array sh b), Acc (Array sh c), Acc (Array sh d), Acc (Array sh e)) Source #

Take an array of 5-tuples and return five arrays, analogous to unzip.

unzip6 :: (Shape sh, Elt a, Elt b, Elt c, Elt d, Elt e, Elt f) => Acc (Array sh (a, b, c, d, e, f)) -> (Acc (Array sh a), Acc (Array sh b), Acc (Array sh c), Acc (Array sh d), Acc (Array sh e), Acc (Array sh f)) Source #

Take an array of 6-tuples and return six arrays, analogous to unzip.

unzip7 :: (Shape sh, Elt a, Elt b, Elt c, Elt d, Elt e, Elt f, Elt g) => Acc (Array sh (a, b, c, d, e, f, g)) -> (Acc (Array sh a), Acc (Array sh b), Acc (Array sh c), Acc (Array sh d), Acc (Array sh e), Acc (Array sh f), Acc (Array sh g)) Source #

Take an array of 7-tuples and return seven arrays, analogous to unzip.

unzip8 :: (Shape sh, Elt a, Elt b, Elt c, Elt d, Elt e, Elt f, Elt g, Elt h) => Acc (Array sh (a, b, c, d, e, f, g, h)) -> (Acc (Array sh a), Acc (Array sh b), Acc (Array sh c), Acc (Array sh d), Acc (Array sh e), Acc (Array sh f), Acc (Array sh g), Acc (Array sh h)) Source #

Take an array of 8-tuples and return eight arrays, analogous to unzip.

unzip9 :: (Shape sh, Elt a, Elt b, Elt c, Elt d, Elt e, Elt f, Elt g, Elt h, Elt i) => Acc (Array sh (a, b, c, d, e, f, g, h, i)) -> (Acc (Array sh a), Acc (Array sh b), Acc (Array sh c), Acc (Array sh d), Acc (Array sh e), Acc (Array sh f), Acc (Array sh g), Acc (Array sh h), Acc (Array sh i)) Source #

Take an array of 8-tuples and return eight arrays, analogous to unzip.

Modifying Arrays

Shape manipulation

reshape :: (Shape sh, Shape sh', Elt e) => Exp sh -> Acc (Array sh' e) -> Acc (Array sh e) Source #

Change the shape of an array without altering its contents. The size of the source and result arrays must be identical.

precondition: shapeSize sh == shapeSize sh'

If the argument array is manifest in memory, reshape is a no-op. If the argument is to be fused into a subsequent operation, reshape corresponds to an index transformation in the fused code.

flatten :: forall sh e. (Shape sh, Elt e) => Acc (Array sh e) -> Acc (Vector e) Source #

Flatten the given array of arbitrary dimension into a one-dimensional vector. As with reshape, this operation performs no work.

Replication

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, given the following vector:

>>> let vec = fromList (Z:.10) [0..]
Vector (Z :. 10) [0,1,2,3,4,5,6,7,8,9]

...we can replicate these elements to form a two-dimensional array either by replicating those elements as new rows:

>>> replicate (lift (Z :. 4 :. All)) (use vec)
Matrix (Z :. 4 :. 10)
  [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
    0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
    0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
    0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

...or as columns:

>>> replicate (lift (Z :. All :. 4)) (use vec)
Matrix (Z :. 10 :. 4)
  [ 0, 0, 0, 0,
    1, 1, 1, 1,
    2, 2, 2, 2,
    3, 3, 3, 3,
    4, 4, 4, 4,
    5, 5, 5, 5,
    6, 6, 6, 6,
    7, 7, 7, 7,
    8, 8, 8, 8,
    9, 9, 9, 9]

Replication along more than one dimension is also possible. Here we replicate twice across the first dimension and three times across the third dimension:

>>> replicate (lift (Z :. 2 :. All :. 3)) (use vec)
Array (Z :. 2 :. 10 :. 3) [0,0,0,1,1,1,2,2,2,3,3,3,4,4,4,5,5,5,6,6,6,7,7,7,8,8,8,9,9,9,0,0,0,1,1,1,2,2,2,3,3,3,4,4,4,5,5,5,6,6,6,7,7,7,8,8,8,9,9,9]

The marker Any can be used in the slice specification to match against some arbitrary dimension. For example, here Any matches against whatever shape type variable sh takes.

rep0 :: (Shape sh, Elt e) => Exp Int -> Acc (Array sh e) -> Acc (Array (sh :. Int) e)
rep0 n a = replicate (lift (Any :. n)) a
>>> let x = unit 42  :: Acc (Scalar Int)
>>> rep0 10 x
Vector (Z :. 10) [42,42,42,42,42,42,42,42,42,42]
>>> rep0 5 (use vec)
Matrix (Z :. 10 :. 5)
  [ 0, 0, 0, 0, 0,
    1, 1, 1, 1, 1,
    2, 2, 2, 2, 2,
    3, 3, 3, 3, 3,
    4, 4, 4, 4, 4,
    5, 5, 5, 5, 5,
    6, 6, 6, 6, 6,
    7, 7, 7, 7, 7,
    8, 8, 8, 8, 8,
    9, 9, 9, 9, 9]

Of course, Any and All can be used together.

rep1 :: (Shape sh, Elt e) => Exp Int -> Acc (Array (sh :. Int) e) -> Acc (Array (sh :. Int :. Int) e)
rep1 n a = A.replicate (lift (Any :. n :. All)) a
>>> rep1 5 (use vec)
Matrix (Z :. 5 :. 10)
  [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
    0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
    0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
    0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
    0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

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 (Alls) in their entirety.

slice is the opposite of replicate, and can be used to cut out entire dimensions. For example, for the two dimensional array mat:

>>> let mat = fromList (Z:.5:.10) [0..]
>>> mat
Matrix (Z :. 5 :. 10)
  [  0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
    10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
    20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
    30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
    40, 41, 42, 43, 44, 45, 46, 47, 48, 49]

...will can select a specific row to yield a one dimensional result by fixing the row index (2) while allowing the column index to vary (via All):

>>> slice (use mat) (lift (Z :. 2 :. All))
Vector (Z :. 10) [20,21,22,23,24,25,26,27,28,29]

A fully specified index (with no Alls) returns a single element (zero dimensional array).

>>> slice (use mat) (lift (Z :. 4 :. 2))
Scalar Z [42]

The marker Any can be used in the slice specification to match against some arbitrary (lower) dimension. Here Any matches whatever shape type variable sh takes:

sl0 :: (Shape sh, Elt e) => Acc (Array (sh:.Int) e) -> Exp Int -> Acc (Array sh e)
sl0 a n = A.slice a (lift (Any :. n))
>>> let vec = fromList (Z:.10) [0..]
>>> sl0 (use vec) 4
Scalar Z [4]
>>> sl0 (use mat) 4
Vector (Z :. 5) [4,14,24,34,44]

Of course, Any and All can be used together.

sl1 :: (Shape sh, Elt e) => Acc (Array (sh:.Int:.Int) e) -> Exp Int -> Acc (Array (sh:.Int) e)
sl1 a n = A.slice a (lift (Any :. n :. All))
>>> sl1 (use mat) 4
Vector (Z :. 10) [40,41,42,43,44,45,46,47,48,49]
>>> let cube = fromList (Z:.3:.4:.5) [0..]
>>> cube
Array (Z :. 3 :. 4 :. 5) [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59]
>>> sl1 (use cube) 2
Matrix (Z :. 3 :. 5)
  [ 10, 11, 12, 13, 14,
    30, 31, 32, 33, 34,
    50, 51, 52, 53, 54]

init :: forall sh e. (Slice sh, Shape sh, Elt e) => Acc (Array (sh :. Int) e) -> Acc (Array (sh :. Int) e) Source #

Yield all but the elements in the last index of the innermost dimension.

>>> let mat = fromList (Z:.5:.10) [0..]
>>> mat
Matrix (Z :. 5 :. 10)
  [  0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
    10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
    20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
    30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
    40, 41, 42, 43, 44, 45, 46, 47, 48, 49]
>>> init (use mat)
Matrix (Z :. 5 :. 9)
  [  0,  1,  2,  3,  4,  5,  6,  7,  8,
    10, 11, 12, 13, 14, 15, 16, 17, 18,
    20, 21, 22, 23, 24, 25, 26, 27, 28,
    30, 31, 32, 33, 34, 35, 36, 37, 38,
    40, 41, 42, 43, 44, 45, 46, 47, 48]

tail :: forall sh e. (Slice sh, Shape sh, Elt e) => Acc (Array (sh :. Int) e) -> Acc (Array (sh :. Int) e) Source #

Yield all but the first element along the innermost dimension of an array. The innermost dimension must not be empty.

>>> let mat = fromList (Z:.5:.10) [0..]
>>> mat
Matrix (Z :. 5 :. 10)
  [  0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
    10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
    20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
    30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
    40, 41, 42, 43, 44, 45, 46, 47, 48, 49]
>>> tail (use mat)
Matrix (Z :. 5 :. 9)
  [  1,  2,  3,  4,  5,  6,  7,  8,  9,
    11, 12, 13, 14, 15, 16, 17, 18, 19,
    21, 22, 23, 24, 25, 26, 27, 28, 29,
    31, 32, 33, 34, 35, 36, 37, 38, 39,
    41, 42, 43, 44, 45, 46, 47, 48, 49]

take :: forall sh e. (Slice sh, Shape sh, Elt e) => Exp Int -> Acc (Array (sh :. Int) e) -> Acc (Array (sh :. Int) e) Source #

Yield the first n elements in the innermost dimension of the array (plus all lower dimensional elements).

>>> let mat = fromList (Z:.5:.10) [0..]
>>> mat
Matrix (Z :. 5 :. 10)
  [  0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
    10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
    20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
    30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
    40, 41, 42, 43, 44, 45, 46, 47, 48, 49]
>>> take 5 (use mat)
Matrix (Z :. 5 :. 5)
  [  0,  1,  2,  3,  4,
    10, 11, 12, 13, 14,
    20, 21, 22, 23, 24,
    30, 31, 32, 33, 34,
    40, 41, 42, 43, 44]

drop :: forall sh e. (Slice sh, Shape sh, Elt e) => Exp Int -> Acc (Array (sh :. Int) e) -> Acc (Array (sh :. Int) e) Source #

Yield all but the first n elements along the innermost dimension of the array (plus all lower dimensional elements).

>>> let mat = fromList (Z:.5:.10) [0..]
>>> mat
Matrix (Z :. 5 :. 10)
  [  0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
    10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
    20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
    30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
    40, 41, 42, 43, 44, 45, 46, 47, 48, 49]
>>> drop 7 (use mat)
Matrix (Z :. 5 :. 3)
  [  7,  8,  9,
    17, 18, 19,
    27, 28, 29,
    37, 38, 39,
    47, 48, 49]

slit :: forall sh e. (Slice sh, Shape sh, Elt e) => Exp Int -> Exp Int -> Acc (Array (sh :. Int) e) -> Acc (Array (sh :. Int) e) Source #

Yield a slit (slice) of the innermost indices of an array. Denotationally, we have:

slit i n = take n . drop i

Permutations

Forward permutation (scatter)

permute Source #

Arguments

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

combination function

-> Acc (Array sh' a)

array of default values

-> (Exp sh -> Exp sh')

index permutation function

-> Acc (Array sh a)

array of source values to be permuted

-> Acc (Array sh' a) 

Generalised forward permutation operation (array scatter).

Forward permutation specified by a function mapping indices from the source array to indices in the result array. 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 and commutative. Elements that are mapped to the magic value ignore by the permutation function are dropped.

The combination function is given the new value being permuted as its first argument, and the current value of the array as its second.

For example, we can use permute to compute the occurrence count (histogram) for an array of values in the range [0,10):

histogram :: Acc (Vector Int) -> Acc (Vector Int)
histogram xs =
  let zeros = fill (constant (Z:.10)) 0
      ones  = fill (shape xs)         1
  in
  permute (+) zeros (\ix -> index1 (xs!ix)) ones
>>> let xs = fromList (Z :. 20) [0,0,1,2,1,1,2,4,8,3,4,9,8,3,2,5,5,3,1,2]
>>> histogram (use xs)
Vector (Z :. 10) [2,4,4,3,2,2,0,0,2,1]

As a second example, note that the dimensionality of the source and destination arrays can differ. In this way, we can use permute to create an identity matrix by overwriting elements along the diagonal:

identity :: Num a => Exp Int -> Acc (Array DIM2 a)
identity n =
  let zeros = fill (index2 n n) 0
      ones  = fill (index1 n)   1
  in
  permute const zeros (\(unindex1 -> i) -> index2 i i) ones
>>> identity 5
Matrix (Z :. 5 :. 5)
  [1,0,0,0,0,
   0,1,0,0,0,
   0,0,1,0,0,
   0,0,0,1,0,
   0,0,0,0,1]
Note:

Regarding array fusion:

  1. The permute operation will always be evaluated; it can not be fused into a later step.
  2. Since the index permutation function might not cover all positions in the output array (the function is not surjective), the array of default values must be evaluated. However, other operations may fuse into this.
  3. The array of source values can fuse into the permutation operation.
  4. If the array of default values is only used once, it will be updated in-place.

ignore :: Shape sh => Exp sh Source #

Magic value identifying elements that are ignored in a forward permutation.

scatter Source #

Arguments

:: Elt e 
=> Acc (Vector Int)

destination indices to scatter into

-> Acc (Vector e)

default values

-> Acc (Vector e)

source values

-> Acc (Vector e) 

Overwrite elements of the destination by scattering the values of the source array according to the given index mapping.

Note that if the destination index appears more than once in the mapping the result is undefined.

>>> let to    = fromList (Z :. 6) [1,3,7,2,5,8]
>>> let input = fromList (Z :. 7) [1,9,6,4,4,2,5]
>>> scatter (use to) (fill (constant (Z:.10)) 0) (use input)
Vector (Z :. 10) [0,1,4,9,0,4,0,6,2,0]

Backward permutation (gather)

backpermute Source #

Arguments

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

shape of the result array

-> (Exp sh' -> Exp sh)

index permutation function

-> Acc (Array sh a)

source array

-> Acc (Array sh' a) 

Generalised backward permutation operation (array gather).

Backward permutation specified by a function mapping indices in the destination array to indices in the source array. Elements of the output array are thus generated by reading from the corresponding index in the source array.

For example, backpermute can be used to transpose a matrix; at every index Z:.y:.x in the result array, we get the value at that index by reading from the source array at index Z:.x:.y:

swap :: Exp DIM2 -> Exp DIM2
swap = lift1 $ \(Z:.y:.x) -> Z:.x:.y
>>> let mat = fromList (Z:.5:.10) [0..]
>>> mat
Matrix (Z :. 5 :. 10)
  [  0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
    10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
    20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
    30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
    40, 41, 42, 43, 44, 45, 46, 47, 48, 49]
>>> let mat' = use mat
>>> backpermute (swap (shape mat')) swap mat'
Matrix (Z :. 10 :. 5)
  [ 0, 10, 20, 30, 40,
    1, 11, 21, 31, 41,
    2, 12, 22, 32, 42,
    3, 13, 23, 33, 43,
    4, 14, 24, 34, 44,
    5, 15, 25, 35, 45,
    6, 16, 26, 36, 46,
    7, 17, 27, 37, 47,
    8, 18, 28, 38, 48,
    9, 19, 29, 39, 49]

gather Source #

Arguments

:: (Shape sh, Elt e) 
=> Acc (Array sh Int)

index of source at each index to gather

-> Acc (Vector e)

source values

-> Acc (Array sh e) 

Gather elements from a source array by reading values at the given indices.

>>> let input = fromList (Z:.9) [1,9,6,4,4,2,0,1,2]
>>> let from  = fromList (Z:.6) [1,3,7,2,5,3]
>>> gather (use from) (use input)
Vector (Z :. 6) [9,4,1,6,2,4]

Specialised permutations

reverse :: Elt e => Acc (Vector e) -> Acc (Vector e) Source #

Reverse the elements of a vector.

transpose :: Elt e => Acc (Array DIM2 e) -> Acc (Array DIM2 e) Source #

Transpose the rows and columns of a matrix.

Filtering

filter :: forall sh e. (Shape sh, Slice sh, Elt e) => (Exp e -> Exp Bool) -> Acc (Array (sh :. Int) e) -> Acc (Vector e, Array sh Int) Source #

Drop elements that do not satisfy the predicate. Returns the elements which pass the predicate, together with a segment descriptor indicating how many elements along each outer dimension were valid.

>>> let vec = fromList (Z :. 10) [1..10] :: Vector Int
>>> vec
Vector (Z :. 10) [1,2,3,4,5,6,7,8,9,10]
>>> filter even (use vec)
(Vector (Z :. 5) [2,4,6,8,10], Scalar Z [5])
>>> let mat = fromList (Z :. 4 :. 10) [1,2,3,4,5,6,7,8,9,10,1,1,1,1,1,2,2,2,2,2,2,4,6,8,10,12,14,16,18,20,1,3,5,7,9,11,13,15,17,19] :: Array DIM2 Int
>>> mat
Matrix (Z :. 4 :. 10)
  [ 1, 2, 3, 4,  5,  6,  7,  8,  9, 10,
    1, 1, 1, 1,  1,  2,  2,  2,  2,  2,
    2, 4, 6, 8, 10, 12, 14, 16, 18, 20,
    1, 3, 5, 7,  9, 11, 13, 15, 17, 19]
>>> filter odd (use mat)
(Vector (Z :. 20) [1,3,5,7,9,1,1,1,1,1,1,3,5,7,9,11,13,15,17,19], Vector (Z :. 4) [5,5,0,10])

Folding

fold :: (Shape sh, Elt a) => (Exp a -> Exp a -> Exp a) -> Exp a -> Acc (Array (sh :. Int) a) -> Acc (Array sh 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. The initial element does not need to be an identity element of the combination function.

>>> let mat = fromList (Z:.5:.10) [0..]
>>> mat
Matrix (Z :. 5 :. 10)
  [  0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
    10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
    20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
    30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
    40, 41, 42, 43, 44, 45, 46, 47, 48, 49]
>>> fold (+) 42 (use mat)
Vector (Z :. 5) [87,187,287,387,487]

Reductions with non-commutative operators are supported. For example, the following computes the maximum segment sum problem along each innermost dimension of the array.

https://en.wikipedia.org/wiki/Maximum_subarray_problem

maximumSegmentSum
    :: forall sh e. (Shape sh, Num e, Ord e)
    => Acc (Array (sh :. Int) e)
    -> Acc (Array sh e)
maximumSegmentSum
  = map (\v -> let (x,_,_,_) = unlift v :: (Exp e, Exp e, Exp e, Exp e) in x)
  . fold1 f
  . map g
  where
    f :: (Num a, Ord a) => Exp (a,a,a,a) -> Exp (a,a,a,a) -> Exp (a,a,a,a)
    f x y =
      let (mssx, misx, mcsx, tsx) = unlift x
          (mssy, misy, mcsy, tsy) = unlift y
      in
      lift ( mssx `max` (mssy `max` (mcsx+misy))
           , misx `max` (tsx+misy)
           , mcsy `max` (mcsx+tsy)
           , tsx+tsy
           )

    g :: (Num a, Ord a) => Exp a -> Exp (a,a,a,a)
    g x = let y = max x 0
          in  lift (y,y,y,x)
>>> let vec = fromList (Z:.10) [-2,1,-3,4,-1,2,1,-5,4,0]
>>> maximumSegmentSum (use vec)
Scalar Z [6]

See also Fold, which can be a useful way to compute multiple results from a single reduction.

fold1 :: (Shape sh, Elt a) => (Exp a -> Exp a -> Exp a) -> Acc (Array (sh :. Int) a) -> Acc (Array sh 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. The initial element does not need to be an identity element.

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. The first argument needs to be an associative function to enable efficient parallel implementation. The initial element does not need to be an identity element.

>>> let vec = fromList (Z:.10) [0..]
>>> foldAll (+) 42 (use vec)
Scalar Z [87]
>>> let mat = fromList (Z:.5:.10) [0..]
>>> foldAll (+) 0 (use mat)
Scalar Z [1225]

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 does not need a default value. The first argument must be an associative function.

Segmented reductions

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

Segmented reduction along the innermost dimension of an array. The segment descriptor specifies the lengths of the logical sub-arrays, each of which is reduced independently. The innermost dimension must contain at least as many elements as required by the segment descriptor (sum thereof).

>>> let seg = fromList (Z:.4) [1,4,0,3]
>>> seg
Vector (Z :. 4) [1,4,0,3]
>>> let mat = fromList (Z:.5:.10) [0..]
>>> mat
Matrix (Z :. 5 :. 10)
  [  0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
    10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
    20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
    30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
    40, 41, 42, 43, 44, 45, 46, 47, 48, 49]
>>> foldSeg (+) 0 (use mat) (use seg)
Matrix (Z :. 5 :. 4)
  [  0,  10, 0,  18,
    10,  50, 0,  48,
    20,  90, 0,  78,
    30, 130, 0, 108,
    40, 170, 0, 138]

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

Variant of foldSeg that requires all segments of the reduced array to be non-empty and doesn't need a default value. The segment descriptor specifies the length of each of the logical sub-arrays.

Specialised reductions

all :: (Shape sh, Elt e) => (Exp e -> Exp Bool) -> Acc (Array (sh :. Int) e) -> Acc (Array sh Bool) Source #

Check if all elements along the innermost dimension satisfy a predicate.

>>> let mat = fromList (Z :. 4 :. 10) [1,2,3,4,5,6,7,8,9,10,1,1,1,1,1,2,2,2,2,2,2,4,6,8,10,12,14,16,18,20,1,3,5,7,9,11,13,15,17,19] :: Array DIM2 Int
>>> mat
Matrix (Z :. 4 :. 10)
  [ 1, 2, 3, 4,  5,  6,  7,  8,  9, 10,
    1, 1, 1, 1,  1,  2,  2,  2,  2,  2,
    2, 4, 6, 8, 10, 12, 14, 16, 18, 20,
    1, 3, 5, 7,  9, 11, 13, 15, 17, 19]
>>> all even (use mat)
Vector (Z :. 4) [False,False,True,False]

any :: (Shape sh, Elt e) => (Exp e -> Exp Bool) -> Acc (Array (sh :. Int) e) -> Acc (Array sh Bool) Source #

Check if any element along the innermost dimension satisfies the predicate.

>>> let mat = fromList (Z :. 4 :. 10) [1,2,3,4,5,6,7,8,9,10,1,1,1,1,1,2,2,2,2,2,2,4,6,8,10,12,14,16,18,20,1,3,5,7,9,11,13,15,17,19] :: Array DIM2 Int
>>> mat
Matrix (Z :. 4 :. 10)
  [ 1, 2, 3, 4,  5,  6,  7,  8,  9, 10,
    1, 1, 1, 1,  1,  2,  2,  2,  2,  2,
    2, 4, 6, 8, 10, 12, 14, 16, 18, 20,
    1, 3, 5, 7,  9, 11, 13, 15, 17, 19]
>>> any even (use mat)
Vector (Z :. 4) [True,True,True,False]

and :: Shape sh => Acc (Array (sh :. Int) Bool) -> Acc (Array sh Bool) Source #

Check if all elements along the innermost dimension are True.

or :: Shape sh => Acc (Array (sh :. Int) Bool) -> Acc (Array sh Bool) Source #

Check if any element along the innermost dimension is True.

sum :: (Shape sh, Num e) => Acc (Array (sh :. Int) e) -> Acc (Array sh e) Source #

Compute the sum of elements along the innermost dimension of the array. To find the sum of the entire array, flatten it first.

>>> let mat = fromList (Z:.2:.5) [0..]
Vector (Z :. 2) [10,35]

product :: (Shape sh, Num e) => Acc (Array (sh :. Int) e) -> Acc (Array sh e) Source #

Compute the product of the elements along the innermost dimension of the array. To find the product of the entire array, flatten it first.

>>> let mat = fromList (Z:.2:.5) [0..]
Vector (Z :. 2) [0,15120]

minimum :: (Shape sh, Ord e) => Acc (Array (sh :. Int) e) -> Acc (Array sh e) Source #

Yield the minimum element along the innermost dimension of the array. To find find the minimum element of the entire array, flatten it first.

The array must not be empty. See also fold1.

>>> let mat = fromList (Z :. 3 :. 4) [1,4,3,8, 0,2,8,4, 7,9,8,8]
>>> mat
Matrix (Z :. 3 :. 4)
  [ 1, 4, 3, 8,
    0, 2, 8, 4,
    7, 9, 8, 8]
>>> minimum (use mat)
Vector (Z :. 3) [1,0,7]

maximum :: (Shape sh, Ord e) => Acc (Array (sh :. Int) e) -> Acc (Array sh e) Source #

Yield the maximum element along the innermost dimension of the array. To find the maximum element of the entire array, flatten it first.

The array must not be empty. See also fold1.

>>> let mat = fromList (Z :. 3 :. 4) [1,4,3,8, 0,2,8,4, 7,9,8,8]
>>> mat
Matrix (Z :. 3 :. 4)
  [ 1, 4, 3, 8,
    0, 2, 8, 4,
    7, 9, 8, 8]
>>> maximum (use mat)
Vector (Z :. 3) [8,8,9]

Scans (prefix sums)

scanl :: (Shape sh, Elt a) => (Exp a -> Exp a -> Exp a) -> Exp a -> Acc (Array (sh :. Int) a) -> Acc (Array (sh :. Int) a) Source #

Data.List style left-to-right scan along the innermost dimension of an arbitrary rank array. The first argument needs to be an associative function to enable efficient parallel implementation. The initial value (second argument) may be arbitrary.

>>> scanl (+) 10 (use $ fromList (Z :. 10) [0..])
Array (Z :. 11) [10,10,11,13,16,20,25,31,38,46,55]
>>> scanl (+) 0 (use $ fromList (Z :. 4 :. 10) [0..])
Matrix (Z :. 4 :. 11)
  [ 0,  0,  1,  3,   6,  10,  15,  21,  28,  36,  45,
    0, 10, 21, 33,  46,  60,  75,  91, 108, 126, 145,
    0, 20, 41, 63,  86, 110, 135, 161, 188, 216, 245,
    0, 30, 61, 93, 126, 160, 195, 231, 268, 306, 345]

scanl1 :: (Shape sh, Elt a) => (Exp a -> Exp a -> Exp a) -> Acc (Array (sh :. Int) a) -> Acc (Array (sh :. Int) a) Source #

Data.List style left-to-right scan along the innermost dimension without an initial value (aka inclusive scan). The array must not be empty. The first argument needs to be an associative function. Denotationally, we have:

scanl1 f e arr = tail (scanl f e arr)
>>> let mat = fromList (Z:.4:.10) [0..]
>>> scanl (+) (use mat)
Matrix (Z :. 4 :. 10)
  [  0,  1,  3,   6,  10,  15,  21,  28,  36,  45,
    10, 21, 33,  46,  60,  75,  91, 108, 126, 145,
    20, 41, 63,  86, 110, 135, 161, 188, 216, 245,
    30, 61, 93, 126, 160, 195, 231, 268, 306, 345]

scanl' :: (Shape sh, Elt a) => (Exp a -> Exp a -> Exp a) -> Exp a -> Acc (Array (sh :. Int) a) -> Acc (Array (sh :. Int) a, Array sh a) Source #

Variant of scanl, where the last element (final reduction result) along each dimension is returned separately. Denotationally we have:

scanl' f e arr = (init res, unit (res!len))
  where
    len = shape arr
    res = scanl f e arr
>>> let (res,sum) = scanl' (+) 0 (use $ fromList (Z:.10) [0..])
>>> res
Vector (Z :. 10) [0,0,1,3,6,10,15,21,28,36]
>>> sum
Scalar Z [45]
>>> let (res,sums) = scanl' (+) 0 (use $ fromList (Z:.4:.10) [0..])
>>> res
Matrix (Z :. 4 :. 10)
  [ 0,  0,  1,  3,   6,  10,  15,  21,  28,  36,
    0, 10, 21, 33,  46,  60,  75,  91, 108, 126,
    0, 20, 41, 63,  86, 110, 135, 161, 188, 216,
    0, 30, 61, 93, 126, 160, 195, 231, 268, 306]
>>> sums
Vector (Z :. 4) [45,145,245,345]

scanr :: (Shape sh, Elt a) => (Exp a -> Exp a -> Exp a) -> Exp a -> Acc (Array (sh :. Int) a) -> Acc (Array (sh :. Int) a) Source #

Right-to-left variant of scanl.

scanr1 :: (Shape sh, Elt a) => (Exp a -> Exp a -> Exp a) -> Acc (Array (sh :. Int) a) -> Acc (Array (sh :. Int) a) Source #

Right-to-left variant of scanl1.

scanr' :: (Shape sh, Elt a) => (Exp a -> Exp a -> Exp a) -> Exp a -> Acc (Array (sh :. Int) a) -> Acc (Array (sh :. Int) a, Array sh a) Source #

Right-to-left variant of scanl'.

prescanl :: (Shape sh, Elt a) => (Exp a -> Exp a -> Exp a) -> Exp a -> Acc (Array (sh :. Int) a) -> Acc (Array (sh :. Int) a) Source #

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

prescanl f e = afst . scanl' f e
>>> let vec = fromList (Z:.10) [1..10]
>>> prescanl (+) 0 (use vec)
Vector (Z :. 10) [0,1,3,6,10,15,21,28,36,45]

postscanl :: (Shape sh, Elt a) => (Exp a -> Exp a -> Exp a) -> Exp a -> Acc (Array (sh :. Int) a) -> Acc (Array (sh :. Int) a) Source #

Left-to-right post-scan, a variant of scanl1 with an initial value. As with scanl1, the array must not be empty. Denotationally, we have:

postscanl f e = map (e `f`) . scanl1 f
>>> let vec = fromList (Z:.10) [1..10]
>>> postscanl (+) 42 (use vec)
Vector (Z :. 10) [43,45,48,52,57,63,70,78,87,97]

prescanr :: (Shape sh, Elt a) => (Exp a -> Exp a -> Exp a) -> Exp a -> Acc (Array (sh :. Int) a) -> Acc (Array (sh :. Int) a) Source #

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

prescanr f e = afst . scanr' f e

postscanr :: (Shape sh, Elt a) => (Exp a -> Exp a -> Exp a) -> Exp a -> Acc (Array (sh :. Int) a) -> Acc (Array (sh :. Int) 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 :: forall sh e i. (Shape sh, Slice sh, Elt e, Integral i, Bits i, FromIntegral i Int) => (Exp e -> Exp e -> Exp e) -> Exp e -> Acc (Array (sh :. Int) e) -> Acc (Segments i) -> Acc (Array (sh :. Int) e) Source #

Segmented version of scanl along the innermost dimension of an array. The innermost dimension must have at least as many elements as the sum of the segment descriptor.

>>> let seg = fromList (Z:.4) [1,4,0,3]
>>> seg
Vector (Z :. 4) [1,4,0,3]
>>> let mat = fromList (Z:.5:.10) [0..]
>>> mat
Matrix (Z :. 5 :. 10)
  [  0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
    10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
    20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
    30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
    40, 41, 42, 43, 44, 45, 46, 47, 48, 49]
>>> scanlSeg (+) 0 (use mat) (use seg)
Matrix (Z :. 5 :. 12)
  [ 0,  0, 0,  1,  3,   6,  10, 0, 0,  5, 11,  18,
    0, 10, 0, 11, 23,  36,  50, 0, 0, 15, 31,  48,
    0, 20, 0, 21, 43,  66,  90, 0, 0, 25, 51,  78,
    0, 30, 0, 31, 63,  96, 130, 0, 0, 35, 71, 108,
    0, 40, 0, 41, 83, 126, 170, 0, 0, 45, 91, 138]

scanl1Seg :: (Shape sh, Slice sh, Elt e, Integral i, Bits i, FromIntegral i Int) => (Exp e -> Exp e -> Exp e) -> Acc (Array (sh :. Int) e) -> Acc (Segments i) -> Acc (Array (sh :. Int) e) Source #

Segmented version of scanl1 along the innermost dimension.

As with scanl1, the total number of elements considered, in this case given by the sum of segment descriptor, must not be zero. The input vector must contain at least this many elements.

Zero length segments are allowed, and the behaviour is as if those entries were not present in the segment descriptor; that is:

scanl1Seg f xs [n,0,0] == scanl1Seg f xs [n]   where n /= 0
>>> let seg = fromList (Z:.4) [1,4,0,3]
>>> seg
Vector (Z :. 4) [1,4,0,3]
>>> let mat = fromList (Z:.5:.10) [0..]
>>> mat
Matrix (Z :. 5 :. 10)
  [  0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
    10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
    20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
    30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
    40, 41, 42, 43, 44, 45, 46, 47, 48, 49]
>>> scanl1Seg (+) (use mat) (use seg)
Matrix (Z :. 5 :. 8)
  [  0,  1,  3,   6,  10,  5, 11,  18,
    10, 11, 23,  36,  50, 15, 31,  48,
    20, 21, 43,  66,  90, 25, 51,  78,
    30, 31, 63,  96, 130, 35, 71, 108,
    40, 41, 83, 126, 170, 45, 91, 138]

scanl'Seg :: forall sh e i. (Shape sh, Slice sh, Elt e, Integral i, Bits i, FromIntegral i Int) => (Exp e -> Exp e -> Exp e) -> Exp e -> Acc (Array (sh :. Int) e) -> Acc (Segments i) -> Acc (Array (sh :. Int) e, Array (sh :. Int) e) Source #

Segmented version of scanl' along the innermost dimension of an array. The innermost dimension must have at least as many elements as the sum of the segment descriptor.

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.

>>> let seg = fromList (Z:.4) [1,4,0,3]
>>> seg
Vector (Z :. 4) [1,4,0,3]
>>> let mat = fromList (Z:.5:.10) [0..]
>>> mat
Matrix (Z :. 5 :. 10)
  [  0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
    10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
    20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
    30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
    40, 41, 42, 43, 44, 45, 46, 47, 48, 49]
>>> let (res,sums) = scanl'Seg (+) 0 (use mat) (use seg)
>>> res
Matrix (Z :. 5 :. 8)
  [ 0, 0,  1,  3,   6, 0,  5, 11,
    0, 0, 11, 23,  36, 0, 15, 31,
    0, 0, 21, 43,  66, 0, 25, 51,
    0, 0, 31, 63,  96, 0, 35, 71,
    0, 0, 41, 83, 126, 0, 45, 91]
>>> sums
Matrix (Z :. 5 :. 4)
  [  0,  10, 0,  18,
    10,  50, 0,  48,
    20,  90, 0,  78,
    30, 130, 0, 108,
    40, 170, 0, 138]

prescanlSeg :: (Shape sh, Slice sh, Elt e, Integral i, Bits i, FromIntegral i Int) => (Exp e -> Exp e -> Exp e) -> Exp e -> Acc (Array (sh :. Int) e) -> Acc (Segments i) -> Acc (Array (sh :. Int) e) Source #

Segmented version of prescanl.

postscanlSeg :: (Shape sh, Slice sh, Elt e, Integral i, Bits i, FromIntegral i Int) => (Exp e -> Exp e -> Exp e) -> Exp e -> Acc (Array (sh :. Int) e) -> Acc (Segments i) -> Acc (Array (sh :. Int) e) Source #

Segmented version of postscanl.

scanrSeg :: forall sh e i. (Shape sh, Slice sh, Elt e, Integral i, Bits i, FromIntegral i Int) => (Exp e -> Exp e -> Exp e) -> Exp e -> Acc (Array (sh :. Int) e) -> Acc (Segments i) -> Acc (Array (sh :. Int) e) Source #

Segmented version of scanr along the innermost dimension of an array. The innermost dimension must have at least as many elements as the sum of the segment descriptor.

>>> let seg = fromList (Z:.4) [1,4,0,3]
>>> seg
Vector (Z :. 4) [1,4,0,3]
>>> let mat = fromList (Z:.5:.10) [0..]
>>> mat
Matrix (Z :. 5 :. 10)
  [  0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
    10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
    20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
    30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
    40, 41, 42, 43, 44, 45, 46, 47, 48, 49]
>>> scanrSeg (+) 0 (use mat) (use seg)
Matrix (Z :. 5 :. 12)
  [  2, 0,  18,  15, 11,  6, 0, 0,  24, 17,  9, 0,
    12, 0,  58,  45, 31, 16, 0, 0,  54, 37, 19, 0,
    22, 0,  98,  75, 51, 26, 0, 0,  84, 57, 29, 0,
    32, 0, 138, 105, 71, 36, 0, 0, 114, 77, 39, 0,
    42, 0, 178, 135, 91, 46, 0, 0, 144, 97, 49, 0]

scanr1Seg :: (Shape sh, Slice sh, Elt e, Integral i, Bits i, FromIntegral i Int) => (Exp e -> Exp e -> Exp e) -> Acc (Array (sh :. Int) e) -> Acc (Segments i) -> Acc (Array (sh :. Int) e) Source #

Segmented version of scanr1.

>>> let seg = fromList (Z:.4) [1,4,0,3]
>>> seg
Vector (Z :. 4) [1,4,0,3]
>>> let mat = fromList (Z:.5:.10) [0..]
>>> mat
Matrix (Z :. 5 :. 10)
  [  0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
    10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
    20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
    30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
    40, 41, 42, 43, 44, 45, 46, 47, 48, 49]
>>> scanr1Seg (+) (use mat) (use seg)
Matrix (Z :. 5 :. 8)
  [  0,  10,   9,  7,  4,  18, 13,  7,
    10,  50,  39, 27, 14,  48, 33, 17,
    20,  90,  69, 47, 24,  78, 53, 27,
    30, 130,  99, 67, 34, 108, 73, 37,
    40, 170, 129, 87, 44, 138, 93, 47]

scanr'Seg :: forall sh e i. (Shape sh, Slice sh, Elt e, Integral i, Bits i, FromIntegral i Int) => (Exp e -> Exp e -> Exp e) -> Exp e -> Acc (Array (sh :. Int) e) -> Acc (Segments i) -> Acc (Array (sh :. Int) e, Array (sh :. Int) e) Source #

Segmented version of scanr'.

>>> let seg = fromList (Z:.4) [1,4,0,3]
>>> seg
Vector (Z :. 4) [1,4,0,3]
>>> let mat = fromList (Z:.5:.10) [0..]
>>> mat
Matrix (Z :. 5 :. 10)
  [  0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
    10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
    20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
    30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
    40, 41, 42, 43, 44, 45, 46, 47, 48, 49]
>>> let (res,sums) = scanr'Seg (+) 0 (use mat) (use seg)
>>> res
Matrix (Z :. 5 :. 8)
  [ 0,  15, 11,  6, 0, 17,  9, 0,
    0,  45, 31, 16, 0, 37, 19, 0,
    0,  75, 51, 26, 0, 57, 29, 0,
    0, 105, 71, 36, 0, 77, 39, 0,
    0, 135, 91, 46, 0, 97, 49, 0]
>>> sums
Matrix (Z :. 5 :. 4)
  [  2,  18, 0,  24,
    12,  58, 0,  54,
    22,  98, 0,  84,
    32, 138, 0, 114,
    42, 178, 0, 144]

prescanrSeg :: (Shape sh, Slice sh, Elt e, Integral i, Bits i, FromIntegral i Int) => (Exp e -> Exp e -> Exp e) -> Exp e -> Acc (Array (sh :. Int) e) -> Acc (Segments i) -> Acc (Array (sh :. Int) e) Source #

Segmented version of prescanr.

postscanrSeg :: (Shape sh, Slice sh, Elt e, Integral i, Bits i, FromIntegral i Int) => (Exp e -> Exp e -> Exp e) -> Exp e -> Acc (Array (sh :. Int) e) -> Acc (Segments i) -> Acc (Array (sh :. Int) e) Source #

Segmented version of postscanr.

Stencils

stencil Source #

Arguments

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

stencil function

-> Boundary (Array sh a)

boundary condition

-> Acc (Array sh a)

source array

-> Acc (Array sh 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 and have an extent of at least three along each axis. 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.

Stencil neighbourhoods are specified via nested tuples, where the nesting depth is equal to the dimensionality of the array. For example, a 3x1 stencil for a one-dimensional array:

s31 :: Stencil3 a -> Exp a
s31 (l,c,r) = ...

...where c is the focal point of the stencil, and l and r represent the elements to the left and right of the focal point, respectively. Similarly, a 3x3 stencil for a two-dimensional array:

s33 :: Stencil3x3 a -> Exp a
s33 ((_,t,_)
    ,(l,c,r)
    ,(_,b,_)) = ...

...where c is again the focal point and t, b, l and r are the elements to the top, bottom, left, and right of the focal point, respectively (the diagonal elements have been elided).

For example, the following computes a 5x5 Gaussian blur as a separable 2-pass operation.

type Stencil5x1 a = (Stencil3 a, Stencil5 a, Stencil3 a)
type Stencil1x5 a = (Stencil3 a, Stencil3 a, Stencil3 a, Stencil3 a, Stencil3 a)

convolve5x1 :: Num a => [Exp a] -> Stencil5x1 a -> Exp a
convolve5x1 kernel (_, (a,b,c,d,e), _)
  = Prelude.sum $ Prelude.zipWith (*) kernel [a,b,c,d,e]

convolve1x5 :: Num a => [Exp a] -> Stencil1x5 a -> Exp a
convolve1x5 kernel ((_,a,_), (_,b,_), (_,c,_), (_,d,_), (_,e,_))
  = Prelude.sum $ Prelude.zipWith (*) kernel [a,b,c,d,e]

gaussian = [0.06136,0.24477,0.38774,0.24477,0.06136]

blur :: Num a => Acc (Array DIM2 a) -> Acc (Array DIM2 a)
blur = stencil (convolve5x1 gaussian) clamp
     . stencil (convolve1x5 gaussian) clamp

stencil2 Source #

Arguments

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

binary stencil function

-> Boundary (Array sh a)

boundary condition #1

-> Acc (Array sh a)

source array #1

-> Boundary (Array sh b)

boundary condition #2

-> Acc (Array sh b)

source array #2

-> Acc (Array sh 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. This is the stencil equivalent of zipWith.

Stencil specification

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

Minimal complete definition

stencilPrj

Instances

Elt e => Stencil DIM1 e (Exp e, Exp e, Exp e) Source # 

Associated Types

type StencilRepr DIM1 (Exp e, Exp e, Exp e) :: *

Methods

stencilPrj :: DIM1 -> e -> Exp (StencilRepr DIM1 (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) Source # 

Associated Types

type StencilRepr DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e) :: *

Methods

stencilPrj :: DIM1 -> e -> Exp (StencilRepr DIM1 (Exp e, Exp e, Exp 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) Source # 

Associated Types

type StencilRepr DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e) :: *

Methods

stencilPrj :: DIM1 -> e -> Exp (StencilRepr DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp 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) Source # 

Associated Types

type StencilRepr DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e) :: *

Methods

stencilPrj :: DIM1 -> e -> Exp (StencilRepr DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp 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) Source # 

Associated Types

type StencilRepr ((:.) ((:.) sh Int) Int) (row2, row1, row0) :: *

Methods

stencilPrj :: ((sh :. Int) :. Int) -> a -> Exp (StencilRepr ((sh :. Int) :. Int) (row2, row1, row0)) -> (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) Source # 

Associated Types

type StencilRepr ((:.) ((:.) sh Int) Int) (row1, row2, row3, row4, row5) :: *

Methods

stencilPrj :: ((sh :. Int) :. Int) -> a -> Exp (StencilRepr ((sh :. Int) :. Int) (row1, row2, row3, row4, row5)) -> (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) Source # 

Associated Types

type StencilRepr ((:.) ((:.) sh Int) Int) (row1, row2, row3, row4, row5, row6, row7) :: *

Methods

stencilPrj :: ((sh :. Int) :. Int) -> a -> Exp (StencilRepr ((sh :. Int) :. Int) (row1, row2, row3, row4, row5, row6, row7)) -> (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) Source # 

Associated Types

type StencilRepr ((:.) ((:.) sh Int) Int) (row1, row2, row3, row4, row5, row6, row7, row8, row9) :: *

Methods

stencilPrj :: ((sh :. Int) :. Int) -> a -> Exp (StencilRepr ((sh :. Int) :. Int) (row1, row2, row3, row4, row5, row6, row7, row8, row9)) -> (row1, row2, row3, row4, row5, row6, row7, row8, row9)

data Boundary t Source #

Boundary condition specification for stencil operations

clamp :: Boundary (Array sh e) Source #

Boundary condition where elements of the stencil which would be out-of-bounds are instead clamped to the edges of the array.

In the following 3x3 stencil, the out-of-bounds element b will instead return the value at position c:

  +------------+
  |a           |
 b|cd          |
  |e           |
  +------------+

mirror :: Boundary (Array sh e) Source #

Stencil boundary condition where coordinates beyond the array extent are instead mirrored

In the following 5x3 stencil, the out-of-bounds element c will instead return the value at position d, and similarly the element at b will return the value at e:

  +------------+
  |a           |
bc|def         |
  |g           |
  +------------+

wrap :: Boundary (Array sh e) Source #

Stencil boundary condition where coordinates beyond the array extent instead wrap around the array.

In the following 3x3 stencil, the out of bounds elements will be read as in the pattern on the right.

 a bc
  +------------+      +------------+
 d|ef          |      |ef         d|
 g|hi          |  ->  |hi         g|
  |            |      |bc         a|
  +------------+      +------------+

function :: (Shape sh, Elt e) => (Exp sh -> Exp e) -> Boundary (Array sh e) Source #

Stencil boundary condition where the given function is applied to any outlying coordinates.

Common stencil patterns

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

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

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

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

The Accelerate Expression Language

Scalar data types

data Exp t Source #

The type Exp represents embedded scalar expressions. The collective operations of Accelerate Acc consist of many scalar expressions executed in data-parallel.

Note that scalar expressions can not initiate new collective operations: doing so introduces nested data parallelism, which is difficult to execute efficiently on constrained hardware such as GPUs, and is thus currently unsupported.

Instances

IfThenElse Exp Source # 

Associated Types

type EltT (Exp :: * -> *) a :: Constraint Source #

Methods

ifThenElse :: EltT Exp a => Exp Bool -> Exp a -> Exp a -> Exp a Source #

Unlift Exp () Source # 

Methods

unlift :: Exp (Plain ()) -> () Source #

Unlift Exp Z Source # 

Methods

unlift :: Exp (Plain Z) -> Z Source #

Lift Exp Bool Source # 

Associated Types

type Plain Bool :: * Source #

Methods

lift :: Bool -> Exp (Plain Bool) Source #

Lift Exp Char Source # 

Associated Types

type Plain Char :: * Source #

Methods

lift :: Char -> Exp (Plain Char) Source #

Lift Exp Double Source # 

Associated Types

type Plain Double :: * Source #

Methods

lift :: Double -> Exp (Plain Double) Source #

Lift Exp Float Source # 

Associated Types

type Plain Float :: * Source #

Methods

lift :: Float -> Exp (Plain Float) Source #

Lift Exp Int Source # 

Associated Types

type Plain Int :: * Source #

Methods

lift :: Int -> Exp (Plain Int) Source #

Lift Exp Int8 Source # 

Associated Types

type Plain Int8 :: * Source #

Methods

lift :: Int8 -> Exp (Plain Int8) Source #

Lift Exp Int16 Source # 

Associated Types

type Plain Int16 :: * Source #

Methods

lift :: Int16 -> Exp (Plain Int16) Source #

Lift Exp Int32 Source # 

Associated Types

type Plain Int32 :: * Source #

Methods

lift :: Int32 -> Exp (Plain Int32) Source #

Lift Exp Int64 Source # 

Associated Types

type Plain Int64 :: * Source #

Methods

lift :: Int64 -> Exp (Plain Int64) Source #

Lift Exp Word Source # 

Associated Types

type Plain Word :: * Source #

Methods

lift :: Word -> Exp (Plain Word) Source #

Lift Exp Word8 Source # 

Associated Types

type Plain Word8 :: * Source #

Methods

lift :: Word8 -> Exp (Plain Word8) Source #

Lift Exp Word16 Source # 

Associated Types

type Plain Word16 :: * Source #

Methods

lift :: Word16 -> Exp (Plain Word16) Source #

Lift Exp Word32 Source # 

Associated Types

type Plain Word32 :: * Source #

Methods

lift :: Word32 -> Exp (Plain Word32) Source #

Lift Exp Word64 Source # 

Associated Types

type Plain Word64 :: * Source #

Methods

lift :: Word64 -> Exp (Plain Word64) Source #

Lift Exp () Source # 

Associated Types

type Plain () :: * Source #

Methods

lift :: () -> Exp (Plain ()) Source #

Lift Exp CChar Source # 

Associated Types

type Plain CChar :: * Source #

Methods

lift :: CChar -> Exp (Plain CChar) Source #

Lift Exp CSChar Source # 

Associated Types

type Plain CSChar :: * Source #

Methods

lift :: CSChar -> Exp (Plain CSChar) Source #

Lift Exp CUChar Source # 

Associated Types

type Plain CUChar :: * Source #

Methods

lift :: CUChar -> Exp (Plain CUChar) Source #

Lift Exp CShort Source # 

Associated Types

type Plain CShort :: * Source #

Methods

lift :: CShort -> Exp (Plain CShort) Source #

Lift Exp CUShort Source # 

Associated Types

type Plain CUShort :: * Source #

Lift Exp CInt Source # 

Associated Types

type Plain CInt :: * Source #

Methods

lift :: CInt -> Exp (Plain CInt) Source #

Lift Exp CUInt Source # 

Associated Types

type Plain CUInt :: * Source #

Methods

lift :: CUInt -> Exp (Plain CUInt) Source #

Lift Exp CLong Source # 

Associated Types

type Plain CLong :: * Source #

Methods

lift :: CLong -> Exp (Plain CLong) Source #

Lift Exp CULong Source # 

Associated Types

type Plain CULong :: * Source #

Methods

lift :: CULong -> Exp (Plain CULong) Source #

Lift Exp CLLong Source # 

Associated Types

type Plain CLLong :: * Source #

Methods

lift :: CLLong -> Exp (Plain CLLong) Source #

Lift Exp CULLong Source # 

Associated Types

type Plain CULLong :: * Source #

Lift Exp CFloat Source # 

Associated Types

type Plain CFloat :: * Source #

Methods

lift :: CFloat -> Exp (Plain CFloat) Source #

Lift Exp CDouble Source # 

Associated Types

type Plain CDouble :: * Source #

Lift Exp Z Source # 

Associated Types

type Plain Z :: * Source #

Methods

lift :: Z -> Exp (Plain Z) Source #

Elt e => Stencil DIM1 e (Exp e, Exp e, Exp e) Source # 

Associated Types

type StencilRepr DIM1 (Exp e, Exp e, Exp e) :: *

Methods

stencilPrj :: DIM1 -> e -> Exp (StencilRepr DIM1 (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) Source # 

Associated Types

type StencilRepr DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e) :: *

Methods

stencilPrj :: DIM1 -> e -> Exp (StencilRepr DIM1 (Exp e, Exp e, Exp 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) Source # 

Associated Types

type StencilRepr DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e) :: *

Methods

stencilPrj :: DIM1 -> e -> Exp (StencilRepr DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp 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) Source # 

Associated Types

type StencilRepr DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e) :: *

Methods

stencilPrj :: DIM1 -> e -> Exp (StencilRepr DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e)) -> (Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e)

Unlift Exp (Exp e) Source # 

Methods

unlift :: Exp (Plain (Exp e)) -> Exp e Source #

Shape sh => Lift Exp (Any sh) Source # 

Associated Types

type Plain (Any sh) :: * Source #

Methods

lift :: Any sh -> Exp (Plain (Any sh)) Source #

Lift Exp (Exp e) Source # 

Associated Types

type Plain (Exp e) :: * Source #

Methods

lift :: Exp e -> Exp (Plain (Exp e)) Source #

(Elt a, Elt b) => Unlift Exp (Exp a, Exp b) Source # 

Methods

unlift :: Exp (Plain (Exp a, Exp b)) -> (Exp a, Exp b) Source #

(Elt e, Slice (Plain ix), Unlift Exp ix) => Unlift Exp ((:.) ix (Exp e)) Source # 

Methods

unlift :: Exp (Plain (ix :. Exp e)) -> ix :. Exp e Source #

(Elt e, Slice ix) => Unlift Exp ((:.) (Exp ix) (Exp e)) Source # 

Methods

unlift :: Exp (Plain (Exp ix :. Exp e)) -> Exp ix :. Exp e Source #

(Lift Exp a, Lift Exp b, Elt (Plain a), Elt (Plain b)) => Lift Exp (a, b) Source # 

Associated Types

type Plain (a, b) :: * Source #

Methods

lift :: (a, b) -> Exp (Plain (a, b)) Source #

(Elt e, Slice (Plain ix), Lift Exp ix) => Lift Exp ((:.) ix (Exp e)) Source # 

Associated Types

type Plain ((:.) ix (Exp e)) :: * Source #

Methods

lift :: (ix :. Exp e) -> Exp (Plain (ix :. Exp e)) Source #

(Slice (Plain ix), Lift Exp ix) => Lift Exp ((:.) ix All) Source # 

Associated Types

type Plain ((:.) ix All) :: * Source #

Methods

lift :: (ix :. All) -> Exp (Plain (ix :. All)) Source #

(Slice (Plain ix), Lift Exp ix) => Lift Exp ((:.) ix Int) Source # 

Associated Types

type Plain ((:.) ix Int) :: * Source #

Methods

lift :: (ix :. Int) -> Exp (Plain (ix :. Int)) Source #

(Elt a, Elt b, Elt c) => Unlift Exp (Exp a, Exp b, Exp c) Source # 

Methods

unlift :: Exp (Plain (Exp a, Exp b, Exp c)) -> (Exp a, Exp b, Exp c) Source #

(Lift Exp a, Lift Exp b, Lift Exp c, Elt (Plain a), Elt (Plain b), Elt (Plain c)) => Lift Exp (a, b, c) Source # 

Associated Types

type Plain (a, b, c) :: * Source #

Methods

lift :: (a, b, c) -> Exp (Plain (a, b, c)) Source #

(Elt a, Elt b, Elt c, Elt d) => Unlift Exp (Exp a, Exp b, Exp c, Exp d) Source # 

Methods

unlift :: Exp (Plain (Exp a, Exp b, Exp c, Exp d)) -> (Exp a, Exp b, Exp c, Exp d) Source #

(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) Source # 

Associated Types

type Plain (a, b, c, d) :: * Source #

Methods

lift :: (a, b, c, d) -> Exp (Plain (a, b, c, d)) Source #

(Elt a, Elt b, Elt c, Elt d, Elt e) => Unlift Exp (Exp a, Exp b, Exp c, Exp d, Exp e) Source # 

Methods

unlift :: Exp (Plain (Exp a, Exp b, Exp c, Exp d, Exp e)) -> (Exp a, Exp b, Exp c, Exp d, Exp e) Source #

(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) Source # 

Associated Types

type Plain (a, b, c, d, e) :: * Source #

Methods

lift :: (a, b, c, d, e) -> Exp (Plain (a, b, c, d, e)) Source #

(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) Source # 

Methods

unlift :: Exp (Plain (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f)) -> (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f) Source #

(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) Source # 

Associated Types

type Plain (a, b, c, d, e, f) :: * Source #

Methods

lift :: (a, b, c, d, e, f) -> Exp (Plain (a, b, c, d, e, f)) Source #

(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) Source # 

Methods

unlift :: Exp (Plain (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f, Exp g)) -> (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f, Exp g) Source #

(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) Source # 

Associated Types

type Plain (a, b, c, d, e, f, g) :: * Source #

Methods

lift :: (a, b, c, d, e, f, g) -> Exp (Plain (a, b, c, d, e, f, g)) Source #

(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) Source # 

Methods

unlift :: Exp (Plain (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f, Exp g, Exp h)) -> (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f, Exp g, Exp h) Source #

(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) Source # 

Associated Types

type Plain (a, b, c, d, e, f, g, h) :: * Source #

Methods

lift :: (a, b, c, d, e, f, g, h) -> Exp (Plain (a, b, c, d, e, f, g, h)) Source #

(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) Source # 

Methods

unlift :: Exp (Plain (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f, Exp g, Exp h, Exp i)) -> (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f, Exp g, Exp h, Exp i) Source #

(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) Source # 

Associated Types

type Plain (a, b, c, d, e, f, g, h, i) :: * Source #

Methods

lift :: (a, b, c, d, e, f, g, h, i) -> Exp (Plain (a, b, c, d, e, f, g, h, i)) Source #

(Elt a, Elt b, Elt c, Elt d, Elt e, Elt f, Elt g, Elt h, Elt i, Elt j) => Unlift Exp (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f, Exp g, Exp h, Exp i, Exp j) Source # 

Methods

unlift :: Exp (Plain (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f, Exp g, Exp h, Exp i, Exp j)) -> (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f, Exp g, Exp h, Exp i, Exp j) Source #

(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, Lift Exp j, 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), Elt (Plain j)) => Lift Exp (a, b, c, d, e, f, g, h, i, j) Source # 

Associated Types

type Plain (a, b, c, d, e, f, g, h, i, j) :: * Source #

Methods

lift :: (a, b, c, d, e, f, g, h, i, j) -> Exp (Plain (a, b, c, d, e, f, g, h, i, j)) Source #

(Elt a, Elt b, Elt c, Elt d, Elt e, Elt f, Elt g, Elt h, Elt i, Elt j, Elt k) => Unlift Exp (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f, Exp g, Exp h, Exp i, Exp j, Exp k) Source # 

Methods

unlift :: Exp (Plain (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f, Exp g, Exp h, Exp i, Exp j, Exp k)) -> (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f, Exp g, Exp h, Exp i, Exp j, Exp k) Source #

(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, Lift Exp j, Lift Exp k, 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), Elt (Plain j), Elt (Plain k)) => Lift Exp (a, b, c, d, e, f, g, h, i, j, k) Source # 

Associated Types

type Plain (a, b, c, d, e, f, g, h, i, j, k) :: * Source #

Methods

lift :: (a, b, c, d, e, f, g, h, i, j, k) -> Exp (Plain (a, b, c, d, e, f, g, h, i, j, k)) Source #

(Elt a, Elt b, Elt c, Elt d, Elt e, Elt f, Elt g, Elt h, Elt i, Elt j, Elt k, Elt l) => Unlift Exp (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f, Exp g, Exp h, Exp i, Exp j, Exp k, Exp l) Source # 

Methods

unlift :: Exp (Plain (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f, Exp g, Exp h, Exp i, Exp j, Exp k, Exp l)) -> (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f, Exp g, Exp h, Exp i, Exp j, Exp k, Exp l) Source #

(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, Lift Exp j, Lift Exp k, Lift Exp l, 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), Elt (Plain j), Elt (Plain k), Elt (Plain l)) => Lift Exp (a, b, c, d, e, f, g, h, i, j, k, l) Source # 

Associated Types

type Plain (a, b, c, d, e, f, g, h, i, j, k, l) :: * Source #

Methods

lift :: (a, b, c, d, e, f, g, h, i, j, k, l) -> Exp (Plain (a, b, c, d, e, f, g, h, i, j, k, l)) Source #

(Elt a, Elt b, Elt c, Elt d, Elt e, Elt f, Elt g, Elt h, Elt i, Elt j, Elt k, Elt l, Elt m) => Unlift Exp (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f, Exp g, Exp h, Exp i, Exp j, Exp k, Exp l, Exp m) Source # 

Methods

unlift :: Exp (Plain (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f, Exp g, Exp h, Exp i, Exp j, Exp k, Exp l, Exp m)) -> (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f, Exp g, Exp h, Exp i, Exp j, Exp k, Exp l, Exp m) Source #

(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, Lift Exp j, Lift Exp k, Lift Exp l, Lift Exp m, 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), Elt (Plain j), Elt (Plain k), Elt (Plain l), Elt (Plain m)) => Lift Exp (a, b, c, d, e, f, g, h, i, j, k, l, m) Source # 

Associated Types

type Plain (a, b, c, d, e, f, g, h, i, j, k, l, m) :: * Source #

Methods

lift :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Exp (Plain (a, b, c, d, e, f, g, h, i, j, k, l, m)) Source #

(Elt a, Elt b, Elt c, Elt d, Elt e, Elt f, Elt g, Elt h, Elt i, Elt j, Elt k, Elt l, Elt m, Elt n) => Unlift Exp (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f, Exp g, Exp h, Exp i, Exp j, Exp k, Exp l, Exp m, Exp n) Source # 

Methods

unlift :: Exp (Plain (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f, Exp g, Exp h, Exp i, Exp j, Exp k, Exp l, Exp m, Exp n)) -> (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f, Exp g, Exp h, Exp i, Exp j, Exp k, Exp l, Exp m, Exp n) Source #

(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, Lift Exp j, Lift Exp k, Lift Exp l, Lift Exp m, Lift Exp n, 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), Elt (Plain j), Elt (Plain k), Elt (Plain l), Elt (Plain m), Elt (Plain n)) => Lift Exp (a, b, c, d, e, f, g, h, i, j, k, l, m, n) Source # 

Associated Types

type Plain (a, b, c, d, e, f, g, h, i, j, k, l, m, n) :: * Source #

Methods

lift :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Exp (Plain (a, b, c, d, e, f, g, h, i, j, k, l, m, n)) Source #

(Elt a, Elt b, Elt c, Elt d, Elt e, Elt f, Elt g, Elt h, Elt i, Elt j, Elt k, Elt l, Elt m, Elt n, Elt o) => Unlift Exp (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f, Exp g, Exp h, Exp i, Exp j, Exp k, Exp l, Exp m, Exp n, Exp o) Source # 

Methods

unlift :: Exp (Plain (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f, Exp g, Exp h, Exp i, Exp j, Exp k, Exp l, Exp m, Exp n, Exp o)) -> (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f, Exp g, Exp h, Exp i, Exp j, Exp k, Exp l, Exp m, Exp n, Exp o) Source #

(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, Lift Exp j, Lift Exp k, Lift Exp l, Lift Exp m, Lift Exp n, Lift Exp o, 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), Elt (Plain j), Elt (Plain k), Elt (Plain l), Elt (Plain m), Elt (Plain n), Elt (Plain o)) => Lift Exp (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) Source # 

Associated Types

type Plain (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) :: * Source #

Methods

lift :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Exp (Plain (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)) Source #

Floating b => Floating (Fold a (Exp b)) # 

Methods

pi :: Fold a (Exp b) #

exp :: Fold a (Exp b) -> Fold a (Exp b) #

log :: Fold a (Exp b) -> Fold a (Exp b) #

sqrt :: Fold a (Exp b) -> Fold a (Exp b) #

(**) :: Fold a (Exp b) -> Fold a (Exp b) -> Fold a (Exp b) #

logBase :: Fold a (Exp b) -> Fold a (Exp b) -> Fold a (Exp b) #

sin :: Fold a (Exp b) -> Fold a (Exp b) #

cos :: Fold a (Exp b) -> Fold a (Exp b) #

tan :: Fold a (Exp b) -> Fold a (Exp b) #

asin :: Fold a (Exp b) -> Fold a (Exp b) #

acos :: Fold a (Exp b) -> Fold a (Exp b) #

atan :: Fold a (Exp b) -> Fold a (Exp b) #

sinh :: Fold a (Exp b) -> Fold a (Exp b) #

cosh :: Fold a (Exp b) -> Fold a (Exp b) #

tanh :: Fold a (Exp b) -> Fold a (Exp b) #

asinh :: Fold a (Exp b) -> Fold a (Exp b) #

acosh :: Fold a (Exp b) -> Fold a (Exp b) #

atanh :: Fold a (Exp b) -> Fold a (Exp b) #

log1p :: Fold a (Exp b) -> Fold a (Exp b) #

expm1 :: Fold a (Exp b) -> Fold a (Exp b) #

log1pexp :: Fold a (Exp b) -> Fold a (Exp b) #

log1mexp :: Fold a (Exp b) -> Fold a (Exp b) #

Fractional b => Fractional (Fold a (Exp b)) # 

Methods

(/) :: Fold a (Exp b) -> Fold a (Exp b) -> Fold a (Exp b) #

recip :: Fold a (Exp b) -> Fold a (Exp b) #

fromRational :: Rational -> Fold a (Exp b) #

Num b => Num (Fold a (Exp b)) # 

Methods

(+) :: Fold a (Exp b) -> Fold a (Exp b) -> Fold a (Exp b) #

(-) :: Fold a (Exp b) -> Fold a (Exp b) -> Fold a (Exp b) #

(*) :: Fold a (Exp b) -> Fold a (Exp b) -> Fold a (Exp b) #

negate :: Fold a (Exp b) -> Fold a (Exp b) #

abs :: Fold a (Exp b) -> Fold a (Exp b) #

signum :: Fold a (Exp b) -> Fold a (Exp b) #

fromInteger :: Integer -> Fold a (Exp b) #

type EltT Exp t Source # 
type EltT Exp t = Elt t
type Plain (Exp e) Source # 
type Plain (Exp e) = e
type Plain ((:.) ix (Exp e)) Source # 
type Plain ((:.) ix (Exp e)) = (:.) (Plain ix) e

Type classes

Basic type classes

class Elt a => Eq a where Source #

The Eq class defines equality == and inequality /= for scalar Accelerate expressions.

For convenience, we include Elt as a superclass.

Minimal complete definition

(==) | (/=)

Methods

(==) :: Exp a -> Exp a -> Exp Bool infix 4 Source #

(/=) :: Exp a -> Exp a -> Exp Bool infix 4 Source #

Instances

Eq Bool Source # 
Eq Char Source # 
Eq Double Source # 
Eq Float Source # 
Eq Int Source # 

Methods

(==) :: Exp Int -> Exp Int -> Exp Bool Source #

(/=) :: Exp Int -> Exp Int -> Exp Bool Source #

Eq Int8 Source # 
Eq Int16 Source # 
Eq Int32 Source # 
Eq Int64 Source # 
Eq Word Source # 
Eq Word8 Source # 
Eq Word16 Source # 
Eq Word32 Source # 
Eq Word64 Source # 
Eq () Source # 

Methods

(==) :: Exp () -> Exp () -> Exp Bool Source #

(/=) :: Exp () -> Exp () -> Exp Bool Source #

Eq CChar Source # 
Eq CSChar Source # 
Eq CUChar Source # 
Eq CShort Source # 
Eq CUShort Source # 
Eq CInt Source # 
Eq CUInt Source # 
Eq CLong Source # 
Eq CULong Source # 
Eq CLLong Source # 
Eq CULLong Source # 
Eq CFloat Source # 
Eq CDouble Source # 
(Eq a, Eq b) => Eq (a, b) Source # 

Methods

(==) :: Exp (a, b) -> Exp (a, b) -> Exp Bool Source #

(/=) :: Exp (a, b) -> Exp (a, b) -> Exp Bool Source #

(Eq a, Eq b, Eq c) => Eq (a, b, c) Source # 

Methods

(==) :: Exp (a, b, c) -> Exp (a, b, c) -> Exp Bool Source #

(/=) :: Exp (a, b, c) -> Exp (a, b, c) -> Exp Bool Source #

(Eq a, Eq b, Eq c, Eq d) => Eq (a, b, c, d) Source # 

Methods

(==) :: Exp (a, b, c, d) -> Exp (a, b, c, d) -> Exp Bool Source #

(/=) :: Exp (a, b, c, d) -> Exp (a, b, c, d) -> Exp Bool Source #

(Eq a, Eq b, Eq c, Eq d, Eq e) => Eq (a, b, c, d, e) Source # 

Methods

(==) :: Exp (a, b, c, d, e) -> Exp (a, b, c, d, e) -> Exp Bool Source #

(/=) :: Exp (a, b, c, d, e) -> Exp (a, b, c, d, e) -> Exp Bool Source #

(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f) => Eq (a, b, c, d, e, f) Source # 

Methods

(==) :: Exp (a, b, c, d, e, f) -> Exp (a, b, c, d, e, f) -> Exp Bool Source #

(/=) :: Exp (a, b, c, d, e, f) -> Exp (a, b, c, d, e, f) -> Exp Bool Source #

(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g) => Eq (a, b, c, d, e, f, g) Source # 

Methods

(==) :: Exp (a, b, c, d, e, f, g) -> Exp (a, b, c, d, e, f, g) -> Exp Bool Source #

(/=) :: Exp (a, b, c, d, e, f, g) -> Exp (a, b, c, d, e, f, g) -> Exp Bool Source #

(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h) => Eq (a, b, c, d, e, f, g, h) Source # 

Methods

(==) :: Exp (a, b, c, d, e, f, g, h) -> Exp (a, b, c, d, e, f, g, h) -> Exp Bool Source #

(/=) :: Exp (a, b, c, d, e, f, g, h) -> Exp (a, b, c, d, e, f, g, h) -> Exp Bool Source #

(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i) => Eq (a, b, c, d, e, f, g, h, i) Source # 

Methods

(==) :: Exp (a, b, c, d, e, f, g, h, i) -> Exp (a, b, c, d, e, f, g, h, i) -> Exp Bool Source #

(/=) :: Exp (a, b, c, d, e, f, g, h, i) -> Exp (a, b, c, d, e, f, g, h, i) -> Exp Bool Source #

(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j) => Eq (a, b, c, d, e, f, g, h, i, j) Source # 

Methods

(==) :: Exp (a, b, c, d, e, f, g, h, i, j) -> Exp (a, b, c, d, e, f, g, h, i, j) -> Exp Bool Source #

(/=) :: Exp (a, b, c, d, e, f, g, h, i, j) -> Exp (a, b, c, d, e, f, g, h, i, j) -> Exp Bool Source #

(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k) => Eq (a, b, c, d, e, f, g, h, i, j, k) Source # 

Methods

(==) :: Exp (a, b, c, d, e, f, g, h, i, j, k) -> Exp (a, b, c, d, e, f, g, h, i, j, k) -> Exp Bool Source #

(/=) :: Exp (a, b, c, d, e, f, g, h, i, j, k) -> Exp (a, b, c, d, e, f, g, h, i, j, k) -> Exp Bool Source #

(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l) => Eq (a, b, c, d, e, f, g, h, i, j, k, l) Source # 

Methods

(==) :: Exp (a, b, c, d, e, f, g, h, i, j, k, l) -> Exp (a, b, c, d, e, f, g, h, i, j, k, l) -> Exp Bool Source #

(/=) :: Exp (a, b, c, d, e, f, g, h, i, j, k, l) -> Exp (a, b, c, d, e, f, g, h, i, j, k, l) -> Exp Bool Source #

(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l, Eq m) => Eq (a, b, c, d, e, f, g, h, i, j, k, l, m) Source # 

Methods

(==) :: Exp (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Exp (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Exp Bool Source #

(/=) :: Exp (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Exp (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Exp Bool Source #

(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l, Eq m, Eq n) => Eq (a, b, c, d, e, f, g, h, i, j, k, l, m, n) Source # 

Methods

(==) :: Exp (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Exp (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Exp Bool Source #

(/=) :: Exp (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Exp (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Exp Bool Source #

(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l, Eq m, Eq n, Eq o) => Eq (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) Source # 

Methods

(==) :: Exp (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Exp (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Exp Bool Source #

(/=) :: Exp (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Exp (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Exp Bool Source #

class Eq a => Ord a where Source #

The Ord class for totally ordered datatypes

Minimal complete definition

(<=)

Methods

(<) :: Exp a -> Exp a -> Exp Bool infix 4 Source #

(>) :: Exp a -> Exp a -> Exp Bool infix 4 Source #

(<=) :: Exp a -> Exp a -> Exp Bool infix 4 Source #

(>=) :: Exp a -> Exp a -> Exp Bool infix 4 Source #

min :: Exp a -> Exp a -> Exp a Source #

max :: Exp a -> Exp a -> Exp a Source #

Instances

Ord Bool Source # 
Ord Char Source # 
Ord Double Source # 
Ord Float Source # 
Ord Int Source # 
Ord Int8 Source # 
Ord Int16 Source # 
Ord Int32 Source # 
Ord Int64 Source # 
Ord Word Source # 
Ord Word8 Source # 
Ord Word16 Source # 
Ord Word32 Source # 
Ord Word64 Source # 
Ord () Source # 

Methods

(<) :: Exp () -> Exp () -> Exp Bool Source #

(>) :: Exp () -> Exp () -> Exp Bool Source #

(<=) :: Exp () -> Exp () -> Exp Bool Source #

(>=) :: Exp () -> Exp () -> Exp Bool Source #

min :: Exp () -> Exp () -> Exp () Source #

max :: Exp () -> Exp () -> Exp () Source #

Ord CChar Source # 
Ord CSChar Source # 
Ord CUChar Source # 
Ord CShort Source # 
Ord CUShort Source # 
Ord CInt Source # 
Ord CUInt Source # 
Ord CLong Source # 
Ord CULong Source # 
Ord CLLong Source # 
Ord CULLong Source # 
Ord CFloat Source # 
Ord CDouble Source # 
(Ord a, Ord b) => Ord (a, b) Source # 

Methods

(<) :: Exp (a, b) -> Exp (a, b) -> Exp Bool Source #

(>) :: Exp (a, b) -> Exp (a, b) -> Exp Bool Source #

(<=) :: Exp (a, b) -> Exp (a, b) -> Exp Bool Source #

(>=) :: Exp (a, b) -> Exp (a, b) -> Exp Bool Source #

min :: Exp (a, b) -> Exp (a, b) -> Exp (a, b) Source #

max :: Exp (a, b) -> Exp (a, b) -> Exp (a, b) Source #

(Ord a, Ord b, Ord c) => Ord (a, b, c) Source # 

Methods

(<) :: Exp (a, b, c) -> Exp (a, b, c) -> Exp Bool Source #

(>) :: Exp (a, b, c) -> Exp (a, b, c) -> Exp Bool Source #

(<=) :: Exp (a, b, c) -> Exp (a, b, c) -> Exp Bool Source #

(>=) :: Exp (a, b, c) -> Exp (a, b, c) -> Exp Bool Source #

min :: Exp (a, b, c) -> Exp (a, b, c) -> Exp (a, b, c) Source #

max :: Exp (a, b, c) -> Exp (a, b, c) -> Exp (a, b, c) Source #

(Ord a, Ord b, Ord c, Ord d) => Ord (a, b, c, d) Source # 

Methods

(<) :: Exp (a, b, c, d) -> Exp (a, b, c, d) -> Exp Bool Source #

(>) :: Exp (a, b, c, d) -> Exp (a, b, c, d) -> Exp Bool Source #

(<=) :: Exp (a, b, c, d) -> Exp (a, b, c, d) -> Exp Bool Source #

(>=) :: Exp (a, b, c, d) -> Exp (a, b, c, d) -> Exp Bool Source #

min :: Exp (a, b, c, d) -> Exp (a, b, c, d) -> Exp (a, b, c, d) Source #

max :: Exp (a, b, c, d) -> Exp (a, b, c, d) -> Exp (a, b, c, d) Source #

(Ord a, Ord b, Ord c, Ord d, Ord e) => Ord (a, b, c, d, e) Source # 

Methods

(<) :: Exp (a, b, c, d, e) -> Exp (a, b, c, d, e) -> Exp Bool Source #

(>) :: Exp (a, b, c, d, e) -> Exp (a, b, c, d, e) -> Exp Bool Source #

(<=) :: Exp (a, b, c, d, e) -> Exp (a, b, c, d, e) -> Exp Bool Source #

(>=) :: Exp (a, b, c, d, e) -> Exp (a, b, c, d, e) -> Exp Bool Source #

min :: Exp (a, b, c, d, e) -> Exp (a, b, c, d, e) -> Exp (a, b, c, d, e) Source #

max :: Exp (a, b, c, d, e) -> Exp (a, b, c, d, e) -> Exp (a, b, c, d, e) Source #

(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f) => Ord (a, b, c, d, e, f) Source # 

Methods

(<) :: Exp (a, b, c, d, e, f) -> Exp (a, b, c, d, e, f) -> Exp Bool Source #

(>) :: Exp (a, b, c, d, e, f) -> Exp (a, b, c, d, e, f) -> Exp Bool Source #

(<=) :: Exp (a, b, c, d, e, f) -> Exp (a, b, c, d, e, f) -> Exp Bool Source #

(>=) :: Exp (a, b, c, d, e, f) -> Exp (a, b, c, d, e, f) -> Exp Bool Source #

min :: Exp (a, b, c, d, e, f) -> Exp (a, b, c, d, e, f) -> Exp (a, b, c, d, e, f) Source #

max :: Exp (a, b, c, d, e, f) -> Exp (a, b, c, d, e, f) -> Exp (a, b, c, d, e, f) Source #

(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g) => Ord (a, b, c, d, e, f, g) Source # 

Methods

(<) :: Exp (a, b, c, d, e, f, g) -> Exp (a, b, c, d, e, f, g) -> Exp Bool Source #

(>) :: Exp (a, b, c, d, e, f, g) -> Exp (a, b, c, d, e, f, g) -> Exp Bool Source #

(<=) :: Exp (a, b, c, d, e, f, g) -> Exp (a, b, c, d, e, f, g) -> Exp Bool Source #

(>=) :: Exp (a, b, c, d, e, f, g) -> Exp (a, b, c, d, e, f, g) -> Exp Bool Source #

min :: Exp (a, b, c, d, e, f, g) -> Exp (a, b, c, d, e, f, g) -> Exp (a, b, c, d, e, f, g) Source #

max :: Exp (a, b, c, d, e, f, g) -> Exp (a, b, c, d, e, f, g) -> Exp (a, b, c, d, e, f, g) Source #

(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h) => Ord (a, b, c, d, e, f, g, h) Source # 

Methods

(<) :: Exp (a, b, c, d, e, f, g, h) -> Exp (a, b, c, d, e, f, g, h) -> Exp Bool Source #

(>) :: Exp (a, b, c, d, e, f, g, h) -> Exp (a, b, c, d, e, f, g, h) -> Exp Bool Source #

(<=) :: Exp (a, b, c, d, e, f, g, h) -> Exp (a, b, c, d, e, f, g, h) -> Exp Bool Source #

(>=) :: Exp (a, b, c, d, e, f, g, h) -> Exp (a, b, c, d, e, f, g, h) -> Exp Bool Source #

min :: Exp (a, b, c, d, e, f, g, h) -> Exp (a, b, c, d, e, f, g, h) -> Exp (a, b, c, d, e, f, g, h) Source #

max :: Exp (a, b, c, d, e, f, g, h) -> Exp (a, b, c, d, e, f, g, h) -> Exp (a, b, c, d, e, f, g, h) Source #

(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i) => Ord (a, b, c, d, e, f, g, h, i) Source # 

Methods

(<) :: Exp (a, b, c, d, e, f, g, h, i) -> Exp (a, b, c, d, e, f, g, h, i) -> Exp Bool Source #

(>) :: Exp (a, b, c, d, e, f, g, h, i) -> Exp (a, b, c, d, e, f, g, h, i) -> Exp Bool Source #

(<=) :: Exp (a, b, c, d, e, f, g, h, i) -> Exp (a, b, c, d, e, f, g, h, i) -> Exp Bool Source #

(>=) :: Exp (a, b, c, d, e, f, g, h, i) -> Exp (a, b, c, d, e, f, g, h, i) -> Exp Bool Source #

min :: Exp (a, b, c, d, e, f, g, h, i) -> Exp (a, b, c, d, e, f, g, h, i) -> Exp (a, b, c, d, e, f, g, h, i) Source #

max :: Exp (a, b, c, d, e, f, g, h, i) -> Exp (a, b, c, d, e, f, g, h, i) -> Exp (a, b, c, d, e, f, g, h, i) Source #

(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j) => Ord (a, b, c, d, e, f, g, h, i, j) Source # 

Methods

(<) :: Exp (a, b, c, d, e, f, g, h, i, j) -> Exp (a, b, c, d, e, f, g, h, i, j) -> Exp Bool Source #

(>) :: Exp (a, b, c, d, e, f, g, h, i, j) -> Exp (a, b, c, d, e, f, g, h, i, j) -> Exp Bool Source #

(<=) :: Exp (a, b, c, d, e, f, g, h, i, j) -> Exp (a, b, c, d, e, f, g, h, i, j) -> Exp Bool Source #

(>=) :: Exp (a, b, c, d, e, f, g, h, i, j) -> Exp (a, b, c, d, e, f, g, h, i, j) -> Exp Bool Source #

min :: Exp (a, b, c, d, e, f, g, h, i, j) -> Exp (a, b, c, d, e, f, g, h, i, j) -> Exp (a, b, c, d, e, f, g, h, i, j) Source #

max :: Exp (a, b, c, d, e, f, g, h, i, j) -> Exp (a, b, c, d, e, f, g, h, i, j) -> Exp (a, b, c, d, e, f, g, h, i, j) Source #

(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k) => Ord (a, b, c, d, e, f, g, h, i, j, k) Source # 

Methods

(<) :: Exp (a, b, c, d, e, f, g, h, i, j, k) -> Exp (a, b, c, d, e, f, g, h, i, j, k) -> Exp Bool Source #

(>) :: Exp (a, b, c, d, e, f, g, h, i, j, k) -> Exp (a, b, c, d, e, f, g, h, i, j, k) -> Exp Bool Source #

(<=) :: Exp (a, b, c, d, e, f, g, h, i, j, k) -> Exp (a, b, c, d, e, f, g, h, i, j, k) -> Exp Bool Source #

(>=) :: Exp (a, b, c, d, e, f, g, h, i, j, k) -> Exp (a, b, c, d, e, f, g, h, i, j, k) -> Exp Bool Source #

min :: Exp (a, b, c, d, e, f, g, h, i, j, k) -> Exp (a, b, c, d, e, f, g, h, i, j, k) -> Exp (a, b, c, d, e, f, g, h, i, j, k) Source #

max :: Exp (a, b, c, d, e, f, g, h, i, j, k) -> Exp (a, b, c, d, e, f, g, h, i, j, k) -> Exp (a, b, c, d, e, f, g, h, i, j, k) Source #

(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k, Ord l) => Ord (a, b, c, d, e, f, g, h, i, j, k, l) Source # 

Methods

(<) :: Exp (a, b, c, d, e, f, g, h, i, j, k, l) -> Exp (a, b, c, d, e, f, g, h, i, j, k, l) -> Exp Bool Source #

(>) :: Exp (a, b, c, d, e, f, g, h, i, j, k, l) -> Exp (a, b, c, d, e, f, g, h, i, j, k, l) -> Exp Bool Source #

(<=) :: Exp (a, b, c, d, e, f, g, h, i, j, k, l) -> Exp (a, b, c, d, e, f, g, h, i, j, k, l) -> Exp Bool Source #

(>=) :: Exp (a, b, c, d, e, f, g, h, i, j, k, l) -> Exp (a, b, c, d, e, f, g, h, i, j, k, l) -> Exp Bool Source #

min :: Exp (a, b, c, d, e, f, g, h, i, j, k, l) -> Exp (a, b, c, d, e, f, g, h, i, j, k, l) -> Exp (a, b, c, d, e, f, g, h, i, j, k, l) Source #

max :: Exp (a, b, c, d, e, f, g, h, i, j, k, l) -> Exp (a, b, c, d, e, f, g, h, i, j, k, l) -> Exp (a, b, c, d, e, f, g, h, i, j, k, l) Source #

(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k, Ord l, Ord m) => Ord (a, b, c, d, e, f, g, h, i, j, k, l, m) Source # 

Methods

(<) :: Exp (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Exp (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Exp Bool Source #

(>) :: Exp (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Exp (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Exp Bool Source #

(<=) :: Exp (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Exp (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Exp Bool Source #

(>=) :: Exp (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Exp (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Exp Bool Source #

min :: Exp (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Exp (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Exp (a, b, c, d, e, f, g, h, i, j, k, l, m) Source #

max :: Exp (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Exp (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Exp (a, b, c, d, e, f, g, h, i, j, k, l, m) Source #

(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k, Ord l, Ord m, Ord n) => Ord (a, b, c, d, e, f, g, h, i, j, k, l, m, n) Source # 

Methods

(<) :: Exp (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Exp (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Exp Bool Source #

(>) :: Exp (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Exp (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Exp Bool Source #

(<=) :: Exp (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Exp (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Exp Bool Source #

(>=) :: Exp (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Exp (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Exp Bool Source #

min :: Exp (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Exp (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Exp (a, b, c, d, e, f, g, h, i, j, k, l, m, n) Source #

max :: Exp (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Exp (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Exp (a, b, c, d, e, f, g, h, i, j, k, l, m, n) Source #

(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k, Ord l, Ord m, Ord n, Ord o) => Ord (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) Source # 

Methods

(<) :: Exp (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Exp (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Exp Bool Source #

(>) :: Exp (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Exp (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Exp Bool Source #

(<=) :: Exp (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Exp (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Exp Bool Source #

(>=) :: Exp (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Exp (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Exp Bool Source #

min :: Exp (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Exp (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Exp (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) Source #

max :: Exp (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Exp (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Exp (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) Source #

type Bounded a = (Elt a, Bounded (Exp a)) Source #

Name the upper and lower limits of a type. Types which are not totally ordered may still have upper and lower bounds.

minBound :: Bounded a => a #

maxBound :: Bounded a => a #

Numeric type classes

type Num a = (Elt a, Num (Exp a)) Source #

Basic numeric class

(+) :: Num a => a -> a -> a #

(-) :: Num a => a -> a -> a #

(*) :: Num a => a -> a -> a #

negate :: Num a => a -> a #

Unary negation.

abs :: Num a => a -> a #

Absolute value.

signum :: Num a => a -> a #

Sign of a number. The functions abs and signum should satisfy the law:

abs x * signum x == x

For real numbers, the signum is either -1 (negative), 0 (zero) or 1 (positive).

fromInteger :: Num a => Integer -> a #

Conversion from an Integer. An integer literal represents the application of the function fromInteger to the appropriate value of type Integer, so such literals have type (Num a) => a.

type Integral a = (Enum a, Real a, Integral (Exp a)) Source #

Integral numbers, supporting integral division

quot :: Integral a => a -> a -> a #

integer division truncated toward zero

rem :: Integral a => a -> a -> a #

integer remainder, satisfying

(x `quot` y)*y + (x `rem` y) == x

div :: Integral a => a -> a -> a #

integer division truncated toward negative infinity

mod :: Integral a => a -> a -> a #

integer modulus, satisfying

(x `div` y)*y + (x `mod` y) == x

quotRem :: Integral a => a -> a -> (a, a) #

simultaneous quot and rem

divMod :: Integral a => a -> a -> (a, a) #

simultaneous div and mod

type Fractional a = (Num a, Fractional (Exp a)) Source #

Fractional numbers, supporting real division

(/) :: Fractional a => a -> a -> a #

fractional division

recip :: Fractional a => a -> a #

reciprocal fraction

fromRational :: Fractional a => Rational -> a #

Conversion from a Rational (that is Ratio Integer). A floating literal stands for an application of fromRational to a value of type Rational, so such literals have type (Fractional a) => a.

type Floating a = (Fractional a, Floating (Exp a)) Source #

Trigonometric and hyperbolic functions and related functions

pi :: Floating a => a #

sin :: Floating a => a -> a #

cos :: Floating a => a -> a #

tan :: Floating a => a -> a #

asin :: Floating a => a -> a #

acos :: Floating a => a -> a #

atan :: Floating a => a -> a #

sinh :: Floating a => a -> a #

cosh :: Floating a => a -> a #

tanh :: Floating a => a -> a #

asinh :: Floating a => a -> a #

acosh :: Floating a => a -> a #

atanh :: Floating a => a -> a #

exp :: Floating a => a -> a #

sqrt :: Floating a => a -> a #

log :: Floating a => a -> a #

(**) :: Floating a => a -> a -> a #

logBase :: Floating a => a -> a -> a #

class (Real a, Fractional a) => RealFrac a where Source #

Extracting components of fractions.

Minimal complete definition

properFraction, truncate, round, ceiling, floor

Methods

properFraction :: (Num b, ToFloating b a, IsIntegral b) => Exp a -> (Exp b, Exp a) Source #

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

truncate x returns the integer nearest x between zero and x

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

round x returns the nearest integer to x; the even integer if x is equidistant between two integers

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

ceiling x returns the least integer not less than x

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

floor x returns the greatest integer not greater than x

Instances

RealFrac Double Source # 
RealFrac Float Source # 
RealFrac CFloat Source # 
RealFrac CDouble Source # 

div' :: (RealFrac a, Elt b, IsIntegral b) => Exp a -> Exp a -> Exp b Source #

Generalisation of div to any instance of RealFrac

mod' :: (Floating a, RealFrac a, ToFloating Int a) => Exp a -> Exp a -> Exp a Source #

Generalisation of mod to any instance of RealFrac

divMod' :: (Floating a, RealFrac a, Num b, IsIntegral b, ToFloating b a) => Exp a -> Exp a -> (Exp b, Exp a) Source #

Generalisation of divMod to any instance of RealFrac

class (RealFrac a, Floating a) => RealFloat a where Source #

Efficient, machine-independent access to the components of a floating-point number

Methods

floatRadix :: Exp a -> Exp Int64 Source #

The radix of the representation (often 2) (constant)

floatRadix :: RealFloat a => Exp a -> Exp Int64 Source #

The radix of the representation (often 2) (constant)

floatDigits :: Exp a -> Exp Int Source #

The number of digits of floatRadix in the significand (constant)

floatDigits :: RealFloat a => Exp a -> Exp Int Source #

The number of digits of floatRadix in the significand (constant)

floatRange :: Exp a -> (Exp Int, Exp Int) Source #

The lowest and highest values the exponent may assume (constant)

floatRange :: RealFloat a => Exp a -> (Exp Int, Exp Int) Source #

The lowest and highest values the exponent may assume (constant)

decodeFloat :: Exp a -> (Exp Int64, Exp Int) Source #

Return the significand and an appropriately scaled exponent. If (m,n) = decodeFloat x then x = m*b^^n, where b is the floating-point radix (floatRadix). Furthermore, either m and n are both zero, or b^(d-1) <= abs m < b^d, where d = floatDigits x.

encodeFloat :: Exp Int64 -> Exp Int -> Exp a Source #

Inverse of decodeFloat

encodeFloat :: (FromIntegral Int a, FromIntegral Int64 a) => Exp Int64 -> Exp Int -> Exp a Source #

Inverse of decodeFloat

exponent :: Exp a -> Exp Int Source #

Corresponds to the second component of decodeFloat

significand :: Exp a -> Exp a Source #

Corresponds to the first component of decodeFloat

scaleFloat :: Exp Int -> Exp a -> Exp a Source #

Multiply a floating point number by an integer power of the radix

isNaN :: Exp a -> Exp Bool Source #

True if the argument is an IEEE "not-a-number" (NaN) value

isInfinite :: Exp a -> Exp Bool Source #

True if the argument is an IEEE infinity or negative-infinity

isDenormalized :: Exp a -> Exp Bool Source #

True if the argument is too small to be represented in normalized format

isNegativeZero :: Exp a -> Exp Bool Source #

True if the argument is an IEEE negative zero

isIEEE :: Exp a -> Exp Bool Source #

True if the argument is an IEEE floating point number

isIEEE :: RealFloat a => Exp a -> Exp Bool Source #

True if the argument is an IEEE floating point number

atan2 :: Exp a -> Exp a -> Exp a Source #

A version of arctangent taking two real floating-point arguments. For real floating x and y, atan2 y x computes the angle (from the positive x-axis) of the vector from the origin to the point (x,y). atan2 y x returns a value in the range [-pi, pi].

Instances

RealFloat Double Source # 
RealFloat Float Source # 
RealFloat CFloat Source # 
RealFloat CDouble Source # 

Numeric conversion classes

class FromIntegral a b where Source #

Accelerate lacks a most-general lossless Integer type, which the standard fromIntegral function uses as an intermediate value when coercing from integral types. Instead, we use this class to capture a direct coercion between two types.

Minimal complete definition

fromIntegral

Methods

fromIntegral :: Integral a => Exp a -> Exp b Source #

General coercion from integral types

Instances

FromIntegral Int Double Source # 
FromIntegral Int Float Source # 
FromIntegral Int Int Source # 
FromIntegral Int Int8 Source # 
FromIntegral Int Int16 Source # 
FromIntegral Int Int32 Source # 
FromIntegral Int Int64 Source # 
FromIntegral Int Word Source # 
FromIntegral Int Word8 Source # 
FromIntegral Int Word16 Source # 
FromIntegral Int Word32 Source # 
FromIntegral Int Word64 Source # 
FromIntegral Int CShort Source # 
FromIntegral Int CUShort Source # 
FromIntegral Int CInt Source # 
FromIntegral Int CUInt Source # 
FromIntegral Int CLong Source # 
FromIntegral Int CULong Source # 
FromIntegral Int CLLong Source # 
FromIntegral Int CULLong Source # 
FromIntegral Int CFloat Source # 
FromIntegral Int CDouble Source # 
FromIntegral Int8 Double Source # 
FromIntegral Int8 Float Source # 
FromIntegral Int8 Int Source # 
FromIntegral Int8 Int8 Source # 
FromIntegral Int8 Int16 Source # 
FromIntegral Int8 Int32 Source # 
FromIntegral Int8 Int64 Source # 
FromIntegral Int8 Word Source # 
FromIntegral Int8 Word8 Source # 
FromIntegral Int8 Word16 Source # 
FromIntegral Int8 Word32 Source # 
FromIntegral Int8 Word64 Source # 
FromIntegral Int8 CShort Source # 
FromIntegral Int8 CUShort Source # 
FromIntegral Int8 CInt Source # 
FromIntegral Int8 CUInt Source # 
FromIntegral Int8 CLong Source # 
FromIntegral Int8 CULong Source # 
FromIntegral Int8 CLLong Source # 
FromIntegral Int8 CULLong Source # 
FromIntegral Int8 CFloat Source # 
FromIntegral Int8 CDouble Source # 
FromIntegral Int16 Double Source # 
FromIntegral Int16 Float Source # 
FromIntegral Int16 Int Source # 
FromIntegral Int16 Int8 Source # 
FromIntegral Int16 Int16 Source # 
FromIntegral Int16 Int32 Source # 
FromIntegral Int16 Int64 Source # 
FromIntegral Int16 Word Source # 
FromIntegral Int16 Word8 Source # 
FromIntegral Int16 Word16 Source # 
FromIntegral Int16 Word32 Source # 
FromIntegral Int16 Word64 Source # 
FromIntegral Int16 CShort Source # 
FromIntegral Int16 CUShort Source # 
FromIntegral Int16 CInt Source # 
FromIntegral Int16 CUInt Source # 
FromIntegral Int16 CLong Source # 
FromIntegral Int16 CULong Source # 
FromIntegral Int16 CLLong Source # 
FromIntegral Int16 CULLong Source # 
FromIntegral Int16 CFloat Source # 
FromIntegral Int16 CDouble Source # 
FromIntegral Int32 Double Source # 
FromIntegral Int32 Float Source # 
FromIntegral Int32 Int Source # 
FromIntegral Int32 Int8 Source # 
FromIntegral Int32 Int16 Source # 
FromIntegral Int32 Int32 Source # 
FromIntegral Int32 Int64 Source # 
FromIntegral Int32 Word Source # 
FromIntegral Int32 Word8 Source # 
FromIntegral Int32 Word16 Source # 
FromIntegral Int32 Word32 Source # 
FromIntegral Int32 Word64 Source # 
FromIntegral Int32 CShort Source # 
FromIntegral Int32 CUShort Source # 
FromIntegral Int32 CInt Source # 
FromIntegral Int32 CUInt Source # 
FromIntegral Int32 CLong Source # 
FromIntegral Int32 CULong Source # 
FromIntegral Int32 CLLong Source # 
FromIntegral Int32 CULLong Source # 
FromIntegral Int32 CFloat Source # 
FromIntegral Int32 CDouble Source # 
FromIntegral Int64 Double Source # 
FromIntegral Int64 Float Source # 
FromIntegral Int64 Int Source # 
FromIntegral Int64 Int8 Source # 
FromIntegral Int64 Int16 Source # 
FromIntegral Int64 Int32 Source # 
FromIntegral Int64 Int64 Source # 
FromIntegral Int64 Word Source # 
FromIntegral Int64 Word8 Source # 
FromIntegral Int64 Word16 Source # 
FromIntegral Int64 Word32 Source # 
FromIntegral Int64 Word64 Source # 
FromIntegral Int64 CShort Source # 
FromIntegral Int64 CUShort Source # 
FromIntegral Int64 CInt Source # 
FromIntegral Int64 CUInt Source # 
FromIntegral Int64 CLong Source # 
FromIntegral Int64 CULong Source # 
FromIntegral Int64 CLLong Source # 
FromIntegral Int64 CULLong Source # 
FromIntegral Int64 CFloat Source # 
FromIntegral Int64 CDouble Source # 
FromIntegral Word Double Source # 
FromIntegral Word Float Source # 
FromIntegral Word Int Source # 
FromIntegral Word Int8 Source # 
FromIntegral Word Int16 Source # 
FromIntegral Word Int32 Source # 
FromIntegral Word Int64 Source # 
FromIntegral Word Word Source # 
FromIntegral Word Word8 Source # 
FromIntegral Word Word16 Source # 
FromIntegral Word Word32 Source # 
FromIntegral Word Word64 Source # 
FromIntegral Word CShort Source # 
FromIntegral Word CUShort Source # 
FromIntegral Word CInt Source # 
FromIntegral Word CUInt Source # 
FromIntegral Word CLong Source # 
FromIntegral Word CULong Source # 
FromIntegral Word CLLong Source # 
FromIntegral Word CULLong Source # 
FromIntegral Word CFloat Source # 
FromIntegral Word CDouble Source # 
FromIntegral Word8 Double Source # 
FromIntegral Word8 Float Source # 
FromIntegral Word8 Int Source # 
FromIntegral Word8 Int8 Source # 
FromIntegral Word8 Int16 Source # 
FromIntegral Word8 Int32 Source # 
FromIntegral Word8 Int64 Source # 
FromIntegral Word8 Word Source # 
FromIntegral Word8 Word8 Source # 
FromIntegral Word8 Word16 Source # 
FromIntegral Word8 Word32 Source # 
FromIntegral Word8 Word64 Source # 
FromIntegral Word8 CShort Source # 
FromIntegral Word8 CUShort Source # 
FromIntegral Word8 CInt Source # 
FromIntegral Word8 CUInt Source # 
FromIntegral Word8 CLong Source # 
FromIntegral Word8 CULong Source # 
FromIntegral Word8 CLLong Source # 
FromIntegral Word8 CULLong Source # 
FromIntegral Word8 CFloat Source # 
FromIntegral Word8 CDouble Source # 
FromIntegral Word16 Double Source # 
FromIntegral Word16 Float Source # 
FromIntegral Word16 Int Source # 
FromIntegral Word16 Int8 Source # 
FromIntegral Word16 Int16 Source # 
FromIntegral Word16 Int32 Source # 
FromIntegral Word16 Int64 Source # 
FromIntegral Word16 Word Source # 
FromIntegral Word16 Word8 Source # 
FromIntegral Word16 Word16 Source # 
FromIntegral Word16 Word32 Source # 
FromIntegral Word16 Word64 Source # 
FromIntegral Word16 CShort Source # 
FromIntegral Word16 CUShort Source # 
FromIntegral Word16 CInt Source # 
FromIntegral Word16 CUInt Source # 
FromIntegral Word16 CLong Source # 
FromIntegral Word16 CULong Source # 
FromIntegral Word16 CLLong Source # 
FromIntegral Word16 CULLong Source # 
FromIntegral Word16 CFloat Source # 
FromIntegral Word16 CDouble Source # 
FromIntegral Word32 Double Source # 
FromIntegral Word32 Float Source # 
FromIntegral Word32 Int Source # 
FromIntegral Word32 Int8 Source # 
FromIntegral Word32 Int16 Source # 
FromIntegral Word32 Int32 Source # 
FromIntegral Word32 Int64 Source # 
FromIntegral Word32 Word Source # 
FromIntegral Word32 Word8 Source # 
FromIntegral Word32 Word16 Source # 
FromIntegral Word32 Word32 Source # 
FromIntegral Word32 Word64 Source # 
FromIntegral Word32 CShort Source # 
FromIntegral Word32 CUShort Source # 
FromIntegral Word32 CInt Source # 
FromIntegral Word32 CUInt Source # 
FromIntegral Word32 CLong Source # 
FromIntegral Word32 CULong Source # 
FromIntegral Word32 CLLong Source # 
FromIntegral Word32 CULLong Source # 
FromIntegral Word32 CFloat Source # 
FromIntegral Word32 CDouble Source # 
FromIntegral Word64 Double Source # 
FromIntegral Word64 Float Source # 
FromIntegral Word64 Int Source # 
FromIntegral Word64 Int8 Source # 
FromIntegral Word64 Int16 Source # 
FromIntegral Word64 Int32 Source # 
FromIntegral Word64 Int64 Source # 
FromIntegral Word64 Word Source # 
FromIntegral Word64 Word8 Source # 
FromIntegral Word64 Word16 Source # 
FromIntegral Word64 Word32 Source # 
FromIntegral Word64 Word64 Source # 
FromIntegral Word64 CShort Source # 
FromIntegral Word64 CUShort Source # 
FromIntegral Word64 CInt Source # 
FromIntegral Word64 CUInt Source # 
FromIntegral Word64 CLong Source # 
FromIntegral Word64 CULong Source # 
FromIntegral Word64 CLLong Source # 
FromIntegral Word64 CULLong Source # 
FromIntegral Word64 CFloat Source # 
FromIntegral Word64 CDouble Source # 
FromIntegral CShort Double Source # 
FromIntegral CShort Float Source # 
FromIntegral CShort Int Source # 
FromIntegral CShort Int8 Source # 
FromIntegral CShort Int16 Source # 
FromIntegral CShort Int32 Source # 
FromIntegral CShort Int64 Source # 
FromIntegral CShort Word Source # 
FromIntegral CShort Word8 Source # 
FromIntegral CShort Word16 Source # 
FromIntegral CShort Word32 Source # 
FromIntegral CShort Word64 Source # 
FromIntegral CShort CShort Source # 
FromIntegral CShort CUShort Source # 
FromIntegral CShort CInt Source # 
FromIntegral CShort CUInt Source # 
FromIntegral CShort CLong Source # 
FromIntegral CShort CULong Source # 
FromIntegral CShort CLLong Source # 
FromIntegral CShort CULLong Source # 
FromIntegral CShort CFloat Source # 
FromIntegral CShort CDouble Source # 
FromIntegral CUShort Double Source # 
FromIntegral CUShort Float Source # 
FromIntegral CUShort Int Source # 
FromIntegral CUShort Int8 Source # 
FromIntegral CUShort Int16 Source # 
FromIntegral CUShort Int32 Source # 
FromIntegral CUShort Int64 Source # 
FromIntegral CUShort Word Source # 
FromIntegral CUShort Word8 Source # 
FromIntegral CUShort Word16 Source # 
FromIntegral CUShort Word32 Source # 
FromIntegral CUShort Word64 Source # 
FromIntegral CUShort CShort Source # 
FromIntegral CUShort CUShort Source # 
FromIntegral CUShort CInt Source # 
FromIntegral CUShort CUInt Source # 
FromIntegral CUShort CLong Source # 
FromIntegral CUShort CULong Source # 
FromIntegral CUShort CLLong Source # 
FromIntegral CUShort CULLong Source # 
FromIntegral CUShort CFloat Source # 
FromIntegral CUShort CDouble Source # 
FromIntegral CInt Double Source # 
FromIntegral CInt Float Source # 
FromIntegral CInt Int Source # 
FromIntegral CInt Int8 Source # 
FromIntegral CInt Int16 Source # 
FromIntegral CInt Int32 Source # 
FromIntegral CInt Int64 Source # 
FromIntegral CInt Word Source # 
FromIntegral CInt Word8 Source # 
FromIntegral CInt Word16 Source # 
FromIntegral CInt Word32 Source # 
FromIntegral CInt Word64 Source # 
FromIntegral CInt CShort Source # 
FromIntegral CInt CUShort Source # 
FromIntegral CInt CInt Source # 
FromIntegral CInt CUInt Source # 
FromIntegral CInt CLong Source # 
FromIntegral CInt CULong Source # 
FromIntegral CInt CLLong Source # 
FromIntegral CInt CULLong Source # 
FromIntegral CInt CFloat Source # 
FromIntegral CInt CDouble Source # 
FromIntegral CUInt Double Source # 
FromIntegral CUInt Float Source # 
FromIntegral CUInt Int Source # 
FromIntegral CUInt Int8 Source # 
FromIntegral CUInt Int16 Source # 
FromIntegral CUInt Int32 Source # 
FromIntegral CUInt Int64 Source # 
FromIntegral CUInt Word Source # 
FromIntegral CUInt Word8 Source # 
FromIntegral CUInt Word16 Source # 
FromIntegral CUInt Word32 Source # 
FromIntegral CUInt Word64 Source # 
FromIntegral CUInt CShort Source # 
FromIntegral CUInt CUShort Source # 
FromIntegral CUInt CInt Source # 
FromIntegral CUInt CUInt Source # 
FromIntegral CUInt CLong Source # 
FromIntegral CUInt CULong Source # 
FromIntegral CUInt CLLong Source # 
FromIntegral CUInt CULLong Source # 
FromIntegral CUInt CFloat Source # 
FromIntegral CUInt CDouble Source # 
FromIntegral CLong Double Source # 
FromIntegral CLong Float Source # 
FromIntegral CLong Int Source # 
FromIntegral CLong Int8 Source # 
FromIntegral CLong Int16 Source # 
FromIntegral CLong Int32 Source # 
FromIntegral CLong Int64 Source # 
FromIntegral CLong Word Source # 
FromIntegral CLong Word8 Source # 
FromIntegral CLong Word16 Source # 
FromIntegral CLong Word32 Source # 
FromIntegral CLong Word64 Source # 
FromIntegral CLong CShort Source # 
FromIntegral CLong CUShort Source # 
FromIntegral CLong CInt Source # 
FromIntegral CLong CUInt Source # 
FromIntegral CLong CLong Source # 
FromIntegral CLong CULong Source # 
FromIntegral CLong CLLong Source # 
FromIntegral CLong CULLong Source # 
FromIntegral CLong CFloat Source # 
FromIntegral CLong CDouble Source # 
FromIntegral CULong Double Source # 
FromIntegral CULong Float Source # 
FromIntegral CULong Int Source # 
FromIntegral CULong Int8 Source # 
FromIntegral CULong Int16 Source # 
FromIntegral CULong Int32 Source # 
FromIntegral CULong Int64 Source # 
FromIntegral CULong Word Source # 
FromIntegral CULong Word8 Source # 
FromIntegral CULong Word16 Source # 
FromIntegral CULong Word32 Source # 
FromIntegral CULong Word64 Source # 
FromIntegral CULong CShort Source # 
FromIntegral CULong CUShort Source # 
FromIntegral CULong CInt Source # 
FromIntegral CULong CUInt Source # 
FromIntegral CULong CLong Source # 
FromIntegral CULong CULong Source # 
FromIntegral CULong CLLong Source # 
FromIntegral CULong CULLong Source # 
FromIntegral CULong CFloat Source # 
FromIntegral CULong CDouble Source # 
FromIntegral CLLong Double Source # 
FromIntegral CLLong Float Source # 
FromIntegral CLLong Int Source # 
FromIntegral CLLong Int8 Source # 
FromIntegral CLLong Int16 Source # 
FromIntegral CLLong Int32 Source # 
FromIntegral CLLong Int64 Source # 
FromIntegral CLLong Word Source # 
FromIntegral CLLong Word8 Source # 
FromIntegral CLLong Word16 Source # 
FromIntegral CLLong Word32 Source # 
FromIntegral CLLong Word64 Source # 
FromIntegral CLLong CShort Source # 
FromIntegral CLLong CUShort Source # 
FromIntegral CLLong CInt Source # 
FromIntegral CLLong CUInt Source # 
FromIntegral CLLong CLong Source # 
FromIntegral CLLong CULong Source # 
FromIntegral CLLong CLLong Source # 
FromIntegral CLLong CULLong Source # 
FromIntegral CLLong CFloat Source # 
FromIntegral CLLong CDouble Source # 
FromIntegral CULLong Double Source # 
FromIntegral CULLong Float Source # 
FromIntegral CULLong Int Source # 
FromIntegral CULLong Int8 Source # 
FromIntegral CULLong Int16 Source # 
FromIntegral CULLong Int32 Source # 
FromIntegral CULLong Int64 Source # 
FromIntegral CULLong Word Source # 
FromIntegral CULLong Word8 Source # 
FromIntegral CULLong Word16 Source # 
FromIntegral CULLong Word32 Source # 
FromIntegral CULLong Word64 Source # 
FromIntegral CULLong CShort Source # 
FromIntegral CULLong CUShort Source # 
FromIntegral CULLong CInt Source # 
FromIntegral CULLong CUInt Source # 
FromIntegral CULLong CLong Source # 
FromIntegral CULLong CULong Source # 
FromIntegral CULLong CLLong Source # 
FromIntegral CULLong CULLong Source # 
FromIntegral CULLong CFloat Source # 
FromIntegral CULLong CDouble Source # 

class ToFloating a b where Source #

Accelerate lacks an arbitrary-precision Rational type, which the standard realToFrac uses as an intermediate value when coercing to floating-point types. Instead, we use this class to capture a direct coercion between to types.

Minimal complete definition

toFloating

Methods

toFloating :: (Num a, Floating b) => Exp a -> Exp b Source #

General coercion to floating types

Instances

ToFloating Double Double Source # 
ToFloating Double Float Source # 
ToFloating Double CFloat Source # 
ToFloating Double CDouble Source # 
ToFloating Float Double Source # 
ToFloating Float Float Source # 
ToFloating Float CFloat Source # 
ToFloating Float CDouble Source # 
ToFloating Int Double Source # 
ToFloating Int Float Source # 
ToFloating Int CFloat Source # 
ToFloating Int CDouble Source # 
ToFloating Int8 Double Source # 
ToFloating Int8 Float Source # 
ToFloating Int8 CFloat Source # 
ToFloating Int8 CDouble Source # 
ToFloating Int16 Double Source # 
ToFloating Int16 Float Source # 
ToFloating Int16 CFloat Source # 
ToFloating Int16 CDouble Source # 
ToFloating Int32 Double Source # 
ToFloating Int32 Float Source # 
ToFloating Int32 CFloat Source # 
ToFloating Int32 CDouble Source # 
ToFloating Int64 Double Source # 
ToFloating Int64 Float Source # 
ToFloating Int64 CFloat Source # 
ToFloating Int64 CDouble Source # 
ToFloating Word Double Source # 
ToFloating Word Float Source # 
ToFloating Word CFloat Source # 
ToFloating Word CDouble Source # 
ToFloating Word8 Double Source # 
ToFloating Word8 Float Source # 
ToFloating Word8 CFloat Source # 
ToFloating Word8 CDouble Source # 
ToFloating Word16 Double Source # 
ToFloating Word16 Float Source # 
ToFloating Word16 CFloat Source # 
ToFloating Word16 CDouble Source # 
ToFloating Word32 Double Source # 
ToFloating Word32 Float Source # 
ToFloating Word32 CFloat Source # 
ToFloating Word32 CDouble Source # 
ToFloating Word64 Double Source # 
ToFloating Word64 Float Source # 
ToFloating Word64 CFloat Source # 
ToFloating Word64 CDouble Source # 
ToFloating CShort Double Source # 
ToFloating CShort Float Source # 
ToFloating CShort CFloat Source # 
ToFloating CShort CDouble Source # 
ToFloating CUShort Double Source # 
ToFloating CUShort Float Source # 
ToFloating CUShort CFloat Source # 
ToFloating CUShort CDouble Source # 
ToFloating CInt Double Source # 
ToFloating CInt Float Source # 
ToFloating CInt CFloat Source # 
ToFloating CInt CDouble Source # 
ToFloating CUInt Double Source # 
ToFloating CUInt Float Source # 
ToFloating CUInt CFloat Source # 
ToFloating CUInt CDouble Source # 
ToFloating CLong Double Source # 
ToFloating CLong Float Source # 
ToFloating CLong CFloat Source # 
ToFloating CLong CDouble Source # 
ToFloating CULong Double Source # 
ToFloating CULong Float Source # 
ToFloating CULong CFloat Source # 
ToFloating CULong CDouble Source # 
ToFloating CLLong Double Source # 
ToFloating CLLong Float Source # 
ToFloating CLLong CFloat Source # 
ToFloating CLLong CDouble Source # 
ToFloating CULLong Double Source # 
ToFloating CULLong Float Source # 
ToFloating CULLong CFloat Source # 
ToFloating CULLong CDouble Source # 
ToFloating CFloat Double Source # 
ToFloating CFloat Float Source # 
ToFloating CFloat CFloat Source # 
ToFloating CFloat CDouble Source # 
ToFloating CDouble Double Source # 
ToFloating CDouble Float Source # 
ToFloating CDouble CFloat Source # 
ToFloating CDouble CDouble Source # 

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 embedded expressions (an abstract syntax tree in disguise). Both Acc and Exp are surface types into which values may be lifted. Lifting plain array and scalar surface types is equivalent to use and constant respectively.

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. during GPU execution, when run is called). Similarly an Acc array can not be unlifted to a vanilla array; you should instead run the expression with a specific backend to evaluate it.

Lifting and unlifting are also used to pack and unpack an expression into and out of constructors such as tuples, respectively. Those expressions, at runtime, will become tuple dereferences. For example:

>>> let sh = constant (Z :. 4 :. 10)   :: Exp DIM2
>>> let Z :. x :. y = unlift sh        :: Z :. Exp Int :. Exp Int
>>> let t = lift (x,y)                 :: Exp (Int, Int)
>>> let r  = scanl' f z xs             :: (Acc (Vector Int), Acc (Scalar Int))
>>> let r' = lift r                    :: Acc (Vector Int, Scalar Int)
Note:

Use of lift and unlift is probably the most common source of type errors when using Accelerate. GHC is not very good at determining the type the [un]lifted expression should have, so it is often necessary to add an explicit type signature.

For example, in the following GHC will complain that it can not determine the type of y, even though we might expect that to be obvious (or for it to not care):

fst :: (Elt a, Elt b) => Exp (a,b) -> Exp a
fst t = let (x,y) = unlift t in x

The fix is to instead add an explicit type signature. Note that this requires the ScopedTypeVariables extension and to bring the type variables a and b into scope with forall:

fst :: forall a b. (Elt a, Elt b) => Exp (a,b) -> Exp a
fst t = let (x,y) = unlift t  :: (Exp a, Exp b)
        in x

class Lift c e where Source #

The class of types e which can be lifted into c.

Minimal complete definition

lift

Associated Types

type Plain e Source #

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)

Methods

lift :: e -> c (Plain e) Source #

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 Source # 

Associated Types

type Plain Bool :: * Source #

Methods

lift :: Bool -> Exp (Plain Bool) Source #

Lift Exp Char Source # 

Associated Types

type Plain Char :: * Source #

Methods

lift :: Char -> Exp (Plain Char) Source #

Lift Exp Double Source # 

Associated Types

type Plain Double :: * Source #

Methods

lift :: Double -> Exp (Plain Double) Source #

Lift Exp Float Source # 

Associated Types

type Plain Float :: * Source #

Methods

lift :: Float -> Exp (Plain Float) Source #

Lift Exp Int Source # 

Associated Types

type Plain Int :: * Source #

Methods

lift :: Int -> Exp (Plain Int) Source #

Lift Exp Int8 Source # 

Associated Types

type Plain Int8 :: * Source #

Methods

lift :: Int8 -> Exp (Plain Int8) Source #

Lift Exp Int16 Source # 

Associated Types

type Plain Int16 :: * Source #

Methods

lift :: Int16 -> Exp (Plain Int16) Source #

Lift Exp Int32 Source # 

Associated Types

type Plain Int32 :: * Source #

Methods

lift :: Int32 -> Exp (Plain Int32) Source #

Lift Exp Int64 Source # 

Associated Types

type Plain Int64 :: * Source #

Methods

lift :: Int64 -> Exp (Plain Int64) Source #

Lift Exp Word Source # 

Associated Types

type Plain Word :: * Source #

Methods

lift :: Word -> Exp (Plain Word) Source #

Lift Exp Word8 Source # 

Associated Types

type Plain Word8 :: * Source #

Methods

lift :: Word8 -> Exp (Plain Word8) Source #

Lift Exp Word16 Source # 

Associated Types

type Plain Word16 :: * Source #

Methods

lift :: Word16 -> Exp (Plain Word16) Source #

Lift Exp Word32 Source # 

Associated Types

type Plain Word32 :: * Source #

Methods

lift :: Word32 -> Exp (Plain Word32) Source #

Lift Exp Word64 Source # 

Associated Types

type Plain Word64 :: * Source #

Methods

lift :: Word64 -> Exp (Plain Word64) Source #

Lift Exp () Source # 

Associated Types

type Plain () :: * Source #

Methods

lift :: () -> Exp (Plain ()) Source #

Lift Exp CChar Source # 

Associated Types

type Plain CChar :: * Source #

Methods

lift :: CChar -> Exp (Plain CChar) Source #

Lift Exp CSChar Source # 

Associated Types

type Plain CSChar :: * Source #

Methods

lift :: CSChar -> Exp (Plain CSChar) Source #

Lift Exp CUChar Source # 

Associated Types

type Plain CUChar :: * Source #

Methods

lift :: CUChar -> Exp (Plain CUChar) Source #

Lift Exp CShort Source # 

Associated Types

type Plain CShort :: * Source #

Methods

lift :: CShort -> Exp (Plain CShort) Source #

Lift Exp CUShort Source # 

Associated Types

type Plain CUShort :: * Source #

Lift Exp CInt Source # 

Associated Types

type Plain CInt :: * Source #

Methods

lift :: CInt -> Exp (Plain CInt) Source #

Lift Exp CUInt Source # 

Associated Types

type Plain CUInt :: * Source #

Methods

lift :: CUInt -> Exp (Plain CUInt) Source #

Lift Exp CLong Source # 

Associated Types

type Plain CLong :: * Source #

Methods

lift :: CLong -> Exp (Plain CLong) Source #

Lift Exp CULong Source # 

Associated Types

type Plain CULong :: * Source #

Methods

lift :: CULong -> Exp (Plain CULong) Source #

Lift Exp CLLong Source # 

Associated Types

type Plain CLLong :: * Source #

Methods

lift :: CLLong -> Exp (Plain CLLong) Source #

Lift Exp CULLong Source # 

Associated Types

type Plain CULLong :: * Source #

Lift Exp CFloat Source # 

Associated Types

type Plain CFloat :: * Source #

Methods

lift :: CFloat -> Exp (Plain CFloat) Source #

Lift Exp CDouble Source # 

Associated Types

type Plain CDouble :: * Source #

Lift Exp Z Source # 

Associated Types

type Plain Z :: * Source #

Methods

lift :: Z -> Exp (Plain Z) Source #

Shape sh => Lift Exp (Any sh) Source # 

Associated Types

type Plain (Any sh) :: * Source #

Methods

lift :: Any sh -> Exp (Plain (Any sh)) Source #

Lift Exp (Exp e) Source # 

Associated Types

type Plain (Exp e) :: * Source #

Methods

lift :: Exp e -> Exp (Plain (Exp e)) Source #

Lift Acc (Acc a) Source # 

Associated Types

type Plain (Acc a) :: * Source #

Methods

lift :: Acc a -> Acc (Plain (Acc a)) Source #

(Lift Exp a, Lift Exp b, Elt (Plain a), Elt (Plain b)) => Lift Exp (a, b) Source # 

Associated Types

type Plain (a, b) :: * Source #

Methods

lift :: (a, b) -> Exp (Plain (a, b)) Source #

(Elt e, Slice (Plain ix), Lift Exp ix) => Lift Exp ((:.) ix (Exp e)) Source # 

Associated Types

type Plain ((:.) ix (Exp e)) :: * Source #

Methods

lift :: (ix :. Exp e) -> Exp (Plain (ix :. Exp e)) Source #

(Slice (Plain ix), Lift Exp ix) => Lift Exp ((:.) ix All) Source # 

Associated Types

type Plain ((:.) ix All) :: * Source #

Methods

lift :: (ix :. All) -> Exp (Plain (ix :. All)) Source #

(Slice (Plain ix), Lift Exp ix) => Lift Exp ((:.) ix Int) Source # 

Associated Types

type Plain ((:.) ix Int) :: * Source #

Methods

lift :: (ix :. Int) -> Exp (Plain (ix :. Int)) Source #

(Lift Acc a, Lift Acc b, Arrays (Plain a), Arrays (Plain b)) => Lift Acc (a, b) Source # 

Associated Types

type Plain (a, b) :: * Source #

Methods

lift :: (a, b) -> Acc (Plain (a, b)) Source #

(Shape sh, Elt e) => Lift Acc (Array sh e) Source # 

Associated Types

type Plain (Array sh e) :: * Source #

Methods

lift :: Array sh e -> Acc (Plain (Array sh e)) Source #

(Lift Exp a, Lift Exp b, Lift Exp c, Elt (Plain a), Elt (Plain b), Elt (Plain c)) => Lift Exp (a, b, c) Source # 

Associated Types

type Plain (a, b, c) :: * Source #

Methods

lift :: (a, b, c) -> Exp (Plain (a, b, c)) Source #

(Lift Acc a, Lift Acc b, Lift Acc c, Arrays (Plain a), Arrays (Plain b), Arrays (Plain c)) => Lift Acc (a, b, c) Source # 

Associated Types

type Plain (a, b, c) :: * Source #

Methods

lift :: (a, b, c) -> Acc (Plain (a, b, c)) Source #

(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) Source # 

Associated Types

type Plain (a, b, c, d) :: * Source #

Methods

lift :: (a, b, c, d) -> Exp (Plain (a, b, c, d)) Source #

(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) Source # 

Associated Types

type Plain (a, b, c, d) :: * Source #

Methods

lift :: (a, b, c, d) -> Acc (Plain (a, b, c, d)) Source #

(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) Source # 

Associated Types

type Plain (a, b, c, d, e) :: * Source #

Methods

lift :: (a, b, c, d, e) -> Exp (Plain (a, b, c, d, e)) Source #

(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) Source # 

Associated Types

type Plain (a, b, c, d, e) :: * Source #

Methods

lift :: (a, b, c, d, e) -> Acc (Plain (a, b, c, d, e)) Source #

(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) Source # 

Associated Types

type Plain (a, b, c, d, e, f) :: * Source #

Methods

lift :: (a, b, c, d, e, f) -> Exp (Plain (a, b, c, d, e, f)) Source #

(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) Source # 

Associated Types

type Plain (a, b, c, d, e, f) :: * Source #

Methods

lift :: (a, b, c, d, e, f) -> Acc (Plain (a, b, c, d, e, f)) Source #

(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) Source # 

Associated Types

type Plain (a, b, c, d, e, f, g) :: * Source #

Methods

lift :: (a, b, c, d, e, f, g) -> Exp (Plain (a, b, c, d, e, f, g)) Source #

(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) Source # 

Associated Types

type Plain (a, b, c, d, e, f, g) :: * Source #

Methods

lift :: (a, b, c, d, e, f, g) -> Acc (Plain (a, b, c, d, e, f, g)) Source #

(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) Source # 

Associated Types

type Plain (a, b, c, d, e, f, g, h) :: * Source #

Methods

lift :: (a, b, c, d, e, f, g, h) -> Exp (Plain (a, b, c, d, e, f, g, h)) Source #

(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) Source # 

Associated Types

type Plain (a, b, c, d, e, f, g, h) :: * Source #

Methods

lift :: (a, b, c, d, e, f, g, h) -> Acc (Plain (a, b, c, d, e, f, g, h)) Source #

(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) Source # 

Associated Types

type Plain (a, b, c, d, e, f, g, h, i) :: * Source #

Methods

lift :: (a, b, c, d, e, f, g, h, i) -> Exp (Plain (a, b, c, d, e, f, g, h, i)) Source #

(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) Source # 

Associated Types

type Plain (a, b, c, d, e, f, g, h, i) :: * Source #

Methods

lift :: (a, b, c, d, e, f, g, h, i) -> Acc (Plain (a, b, c, d, e, f, g, h, i)) Source #

(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, Lift Exp j, 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), Elt (Plain j)) => Lift Exp (a, b, c, d, e, f, g, h, i, j) Source # 

Associated Types

type Plain (a, b, c, d, e, f, g, h, i, j) :: * Source #

Methods

lift :: (a, b, c, d, e, f, g, h, i, j) -> Exp (Plain (a, b, c, d, e, f, g, h, i, j)) Source #

(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, Lift Acc j, 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), Arrays (Plain j)) => Lift Acc (a, b, c, d, e, f, g, h, i, j) Source # 

Associated Types

type Plain (a, b, c, d, e, f, g, h, i, j) :: * Source #

Methods

lift :: (a, b, c, d, e, f, g, h, i, j) -> Acc (Plain (a, b, c, d, e, f, g, h, i, j)) Source #

(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, Lift Exp j, Lift Exp k, 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), Elt (Plain j), Elt (Plain k)) => Lift Exp (a, b, c, d, e, f, g, h, i, j, k) Source # 

Associated Types

type Plain (a, b, c, d, e, f, g, h, i, j, k) :: * Source #

Methods

lift :: (a, b, c, d, e, f, g, h, i, j, k) -> Exp (Plain (a, b, c, d, e, f, g, h, i, j, k)) Source #

(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, Lift Acc j, Lift Acc k, 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), Arrays (Plain j), Arrays (Plain k)) => Lift Acc (a, b, c, d, e, f, g, h, i, j, k) Source # 

Associated Types

type Plain (a, b, c, d, e, f, g, h, i, j, k) :: * Source #

Methods

lift :: (a, b, c, d, e, f, g, h, i, j, k) -> Acc (Plain (a, b, c, d, e, f, g, h, i, j, k)) Source #

(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, Lift Exp j, Lift Exp k, Lift Exp l, 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), Elt (Plain j), Elt (Plain k), Elt (Plain l)) => Lift Exp (a, b, c, d, e, f, g, h, i, j, k, l) Source # 

Associated Types

type Plain (a, b, c, d, e, f, g, h, i, j, k, l) :: * Source #

Methods

lift :: (a, b, c, d, e, f, g, h, i, j, k, l) -> Exp (Plain (a, b, c, d, e, f, g, h, i, j, k, l)) Source #

(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, Lift Acc j, Lift Acc k, Lift Acc l, 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), Arrays (Plain j), Arrays (Plain k), Arrays (Plain l)) => Lift Acc (a, b, c, d, e, f, g, h, i, j, k, l) Source # 

Associated Types

type Plain (a, b, c, d, e, f, g, h, i, j, k, l) :: * Source #

Methods

lift :: (a, b, c, d, e, f, g, h, i, j, k, l) -> Acc (Plain (a, b, c, d, e, f, g, h, i, j, k, l)) Source #

(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, Lift Exp j, Lift Exp k, Lift Exp l, Lift Exp m, 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), Elt (Plain j), Elt (Plain k), Elt (Plain l), Elt (Plain m)) => Lift Exp (a, b, c, d, e, f, g, h, i, j, k, l, m) Source # 

Associated Types

type Plain (a, b, c, d, e, f, g, h, i, j, k, l, m) :: * Source #

Methods

lift :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Exp (Plain (a, b, c, d, e, f, g, h, i, j, k, l, m)) Source #

(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, Lift Acc j, Lift Acc k, Lift Acc l, Lift Acc m, 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), Arrays (Plain j), Arrays (Plain k), Arrays (Plain l), Arrays (Plain m)) => Lift Acc (a, b, c, d, e, f, g, h, i, j, k, l, m) Source # 

Associated Types

type Plain (a, b, c, d, e, f, g, h, i, j, k, l, m) :: * Source #

Methods

lift :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Acc (Plain (a, b, c, d, e, f, g, h, i, j, k, l, m)) Source #

(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, Lift Exp j, Lift Exp k, Lift Exp l, Lift Exp m, Lift Exp n, 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), Elt (Plain j), Elt (Plain k), Elt (Plain l), Elt (Plain m), Elt (Plain n)) => Lift Exp (a, b, c, d, e, f, g, h, i, j, k, l, m, n) Source # 

Associated Types

type Plain (a, b, c, d, e, f, g, h, i, j, k, l, m, n) :: * Source #

Methods

lift :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Exp (Plain (a, b, c, d, e, f, g, h, i, j, k, l, m, n)) Source #

(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, Lift Acc j, Lift Acc k, Lift Acc l, Lift Acc m, Lift Acc n, 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), Arrays (Plain j), Arrays (Plain k), Arrays (Plain l), Arrays (Plain m), Arrays (Plain n)) => Lift Acc (a, b, c, d, e, f, g, h, i, j, k, l, m, n) Source # 

Associated Types

type Plain (a, b, c, d, e, f, g, h, i, j, k, l, m, n) :: * Source #

Methods

lift :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Acc (Plain (a, b, c, d, e, f, g, h, i, j, k, l, m, n)) Source #

(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, Lift Exp j, Lift Exp k, Lift Exp l, Lift Exp m, Lift Exp n, Lift Exp o, 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), Elt (Plain j), Elt (Plain k), Elt (Plain l), Elt (Plain m), Elt (Plain n), Elt (Plain o)) => Lift Exp (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) Source # 

Associated Types

type Plain (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) :: * Source #

Methods

lift :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Exp (Plain (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)) Source #

(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, Lift Acc j, Lift Acc k, Lift Acc l, Lift Acc m, Lift Acc n, Lift Acc o, 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), Arrays (Plain j), Arrays (Plain k), Arrays (Plain l), Arrays (Plain m), Arrays (Plain n), Arrays (Plain o)) => Lift Acc (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) Source # 

Associated Types

type Plain (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) :: * Source #

Methods

lift :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Acc (Plain (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)) Source #

class Lift c e => Unlift c e where Source #

A limited subset of types which can be lifted, can also be unlifted.

Minimal complete definition

unlift

Methods

unlift :: c (Plain e) -> e Source #

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 () Source # 

Methods

unlift :: Exp (Plain ()) -> () Source #

Unlift Exp Z Source # 

Methods

unlift :: Exp (Plain Z) -> Z Source #

Unlift Exp (Exp e) Source # 

Methods

unlift :: Exp (Plain (Exp e)) -> Exp e Source #

Unlift Acc (Acc a) Source # 

Methods

unlift :: Acc (Plain (Acc a)) -> Acc a Source #

(Elt a, Elt b) => Unlift Exp (Exp a, Exp b) Source # 

Methods

unlift :: Exp (Plain (Exp a, Exp b)) -> (Exp a, Exp b) Source #

(Elt e, Slice (Plain ix), Unlift Exp ix) => Unlift Exp ((:.) ix (Exp e)) Source # 

Methods

unlift :: Exp (Plain (ix :. Exp e)) -> ix :. Exp e Source #

(Elt e, Slice ix) => Unlift Exp ((:.) (Exp ix) (Exp e)) Source # 

Methods

unlift :: Exp (Plain (Exp ix :. Exp e)) -> Exp ix :. Exp e Source #

(Arrays a, Arrays b) => Unlift Acc (Acc a, Acc b) Source # 

Methods

unlift :: Acc (Plain (Acc a, Acc b)) -> (Acc a, Acc b) Source #

(Elt a, Elt b, Elt c) => Unlift Exp (Exp a, Exp b, Exp c) Source # 

Methods

unlift :: Exp (Plain (Exp a, Exp b, Exp c)) -> (Exp a, Exp b, Exp c) Source #

(Arrays a, Arrays b, Arrays c) => Unlift Acc (Acc a, Acc b, Acc c) Source # 

Methods

unlift :: Acc (Plain (Acc a, Acc b, Acc c)) -> (Acc a, Acc b, Acc c) Source #

(Elt a, Elt b, Elt c, Elt d) => Unlift Exp (Exp a, Exp b, Exp c, Exp d) Source # 

Methods

unlift :: Exp (Plain (Exp a, Exp b, Exp c, Exp d)) -> (Exp a, Exp b, Exp c, Exp d) Source #

(Arrays a, Arrays b, Arrays c, Arrays d) => Unlift Acc (Acc a, Acc b, Acc c, Acc d) Source # 

Methods

unlift :: Acc (Plain (Acc a, Acc b, Acc c, Acc d)) -> (Acc a, Acc b, Acc c, Acc d) Source #

(Elt a, Elt b, Elt c, Elt d, Elt e) => Unlift Exp (Exp a, Exp b, Exp c, Exp d, Exp e) Source # 

Methods

unlift :: Exp (Plain (Exp a, Exp b, Exp c, Exp d, Exp e)) -> (Exp a, Exp b, Exp c, Exp d, Exp e) Source #

(Arrays a, Arrays b, Arrays c, Arrays d, Arrays e) => Unlift Acc (Acc a, Acc b, Acc c, Acc d, Acc e) Source # 

Methods

unlift :: Acc (Plain (Acc a, Acc b, Acc c, Acc d, Acc e)) -> (Acc a, Acc b, Acc c, Acc d, Acc e) Source #

(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) Source # 

Methods

unlift :: Exp (Plain (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f)) -> (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f) Source #

(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) Source # 

Methods

unlift :: Acc (Plain (Acc a, Acc b, Acc c, Acc d, Acc e, Acc f)) -> (Acc a, Acc b, Acc c, Acc d, Acc e, Acc f) Source #

(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) Source # 

Methods

unlift :: Exp (Plain (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f, Exp g)) -> (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f, Exp g) Source #

(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) Source # 

Methods

unlift :: Acc (Plain (Acc a, Acc b, Acc c, Acc d, Acc e, Acc f, Acc g)) -> (Acc a, Acc b, Acc c, Acc d, Acc e, Acc f, Acc g) Source #

(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) Source # 

Methods

unlift :: Exp (Plain (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f, Exp g, Exp h)) -> (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f, Exp g, Exp h) Source #

(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) Source # 

Methods

unlift :: Acc (Plain (Acc a, Acc b, Acc c, Acc d, Acc e, Acc f, Acc g, Acc h)) -> (Acc a, Acc b, Acc c, Acc d, Acc e, Acc f, Acc g, Acc h) Source #

(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) Source # 

Methods

unlift :: Exp (Plain (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f, Exp g, Exp h, Exp i)) -> (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f, Exp g, Exp h, Exp i) Source #

(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) Source # 

Methods

unlift :: Acc (Plain (Acc a, Acc b, Acc c, Acc d, Acc e, Acc f, Acc g, Acc h, Acc i)) -> (Acc a, Acc b, Acc c, Acc d, Acc e, Acc f, Acc g, Acc h, Acc i) Source #

(Elt a, Elt b, Elt c, Elt d, Elt e, Elt f, Elt g, Elt h, Elt i, Elt j) => Unlift Exp (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f, Exp g, Exp h, Exp i, Exp j) Source # 

Methods

unlift :: Exp (Plain (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f, Exp g, Exp h, Exp i, Exp j)) -> (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f, Exp g, Exp h, Exp i, Exp j) Source #

(Arrays a, Arrays b, Arrays c, Arrays d, Arrays e, Arrays f, Arrays g, Arrays h, Arrays i, Arrays j) => Unlift Acc (Acc a, Acc b, Acc c, Acc d, Acc e, Acc f, Acc g, Acc h, Acc i, Acc j) Source # 

Methods

unlift :: Acc (Plain (Acc a, Acc b, Acc c, Acc d, Acc e, Acc f, Acc g, Acc h, Acc i, Acc j)) -> (Acc a, Acc b, Acc c, Acc d, Acc e, Acc f, Acc g, Acc h, Acc i, Acc j) Source #

(Elt a, Elt b, Elt c, Elt d, Elt e, Elt f, Elt g, Elt h, Elt i, Elt j, Elt k) => Unlift Exp (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f, Exp g, Exp h, Exp i, Exp j, Exp k) Source # 

Methods

unlift :: Exp (Plain (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f, Exp g, Exp h, Exp i, Exp j, Exp k)) -> (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f, Exp g, Exp h, Exp i, Exp j, Exp k) Source #

(Arrays a, Arrays b, Arrays c, Arrays d, Arrays e, Arrays f, Arrays g, Arrays h, Arrays i, Arrays j, Arrays k) => Unlift Acc (Acc a, Acc b, Acc c, Acc d, Acc e, Acc f, Acc g, Acc h, Acc i, Acc j, Acc k) Source # 

Methods

unlift :: Acc (Plain (Acc a, Acc b, Acc c, Acc d, Acc e, Acc f, Acc g, Acc h, Acc i, Acc j, Acc k)) -> (Acc a, Acc b, Acc c, Acc d, Acc e, Acc f, Acc g, Acc h, Acc i, Acc j, Acc k) Source #

(Elt a, Elt b, Elt c, Elt d, Elt e, Elt f, Elt g, Elt h, Elt i, Elt j, Elt k, Elt l) => Unlift Exp (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f, Exp g, Exp h, Exp i, Exp j, Exp k, Exp l) Source # 

Methods

unlift :: Exp (Plain (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f, Exp g, Exp h, Exp i, Exp j, Exp k, Exp l)) -> (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f, Exp g, Exp h, Exp i, Exp j, Exp k, Exp l) Source #

(Arrays a, Arrays b, Arrays c, Arrays d, Arrays e, Arrays f, Arrays g, Arrays h, Arrays i, Arrays j, Arrays k, Arrays l) => Unlift Acc (Acc a, Acc b, Acc c, Acc d, Acc e, Acc f, Acc g, Acc h, Acc i, Acc j, Acc k, Acc l) Source # 

Methods

unlift :: Acc (Plain (Acc a, Acc b, Acc c, Acc d, Acc e, Acc f, Acc g, Acc h, Acc i, Acc j, Acc k, Acc l)) -> (Acc a, Acc b, Acc c, Acc d, Acc e, Acc f, Acc g, Acc h, Acc i, Acc j, Acc k, Acc l) Source #

(Elt a, Elt b, Elt c, Elt d, Elt e, Elt f, Elt g, Elt h, Elt i, Elt j, Elt k, Elt l, Elt m) => Unlift Exp (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f, Exp g, Exp h, Exp i, Exp j, Exp k, Exp l, Exp m) Source # 

Methods

unlift :: Exp (Plain (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f, Exp g, Exp h, Exp i, Exp j, Exp k, Exp l, Exp m)) -> (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f, Exp g, Exp h, Exp i, Exp j, Exp k, Exp l, Exp m) Source #

(Arrays a, Arrays b, Arrays c, Arrays d, Arrays e, Arrays f, Arrays g, Arrays h, Arrays i, Arrays j, Arrays k, Arrays l, Arrays m) => Unlift Acc (Acc a, Acc b, Acc c, Acc d, Acc e, Acc f, Acc g, Acc h, Acc i, Acc j, Acc k, Acc l, Acc m) Source # 

Methods

unlift :: Acc (Plain (Acc a, Acc b, Acc c, Acc d, Acc e, Acc f, Acc g, Acc h, Acc i, Acc j, Acc k, Acc l, Acc m)) -> (Acc a, Acc b, Acc c, Acc d, Acc e, Acc f, Acc g, Acc h, Acc i, Acc j, Acc k, Acc l, Acc m) Source #

(Elt a, Elt b, Elt c, Elt d, Elt e, Elt f, Elt g, Elt h, Elt i, Elt j, Elt k, Elt l, Elt m, Elt n) => Unlift Exp (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f, Exp g, Exp h, Exp i, Exp j, Exp k, Exp l, Exp m, Exp n) Source # 

Methods

unlift :: Exp (Plain (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f, Exp g, Exp h, Exp i, Exp j, Exp k, Exp l, Exp m, Exp n)) -> (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f, Exp g, Exp h, Exp i, Exp j, Exp k, Exp l, Exp m, Exp n) Source #

(Arrays a, Arrays b, Arrays c, Arrays d, Arrays e, Arrays f, Arrays g, Arrays h, Arrays i, Arrays j, Arrays k, Arrays l, Arrays m, Arrays n) => Unlift Acc (Acc a, Acc b, Acc c, Acc d, Acc e, Acc f, Acc g, Acc h, Acc i, Acc j, Acc k, Acc l, Acc m, Acc n) Source # 

Methods

unlift :: Acc (Plain (Acc a, Acc b, Acc c, Acc d, Acc e, Acc f, Acc g, Acc h, Acc i, Acc j, Acc k, Acc l, Acc m, Acc n)) -> (Acc a, Acc b, Acc c, Acc d, Acc e, Acc f, Acc g, Acc h, Acc i, Acc j, Acc k, Acc l, Acc m, Acc n) Source #

(Elt a, Elt b, Elt c, Elt d, Elt e, Elt f, Elt g, Elt h, Elt i, Elt j, Elt k, Elt l, Elt m, Elt n, Elt o) => Unlift Exp (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f, Exp g, Exp h, Exp i, Exp j, Exp k, Exp l, Exp m, Exp n, Exp o) Source # 

Methods

unlift :: Exp (Plain (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f, Exp g, Exp h, Exp i, Exp j, Exp k, Exp l, Exp m, Exp n, Exp o)) -> (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f, Exp g, Exp h, Exp i, Exp j, Exp k, Exp l, Exp m, Exp n, Exp o) Source #

(Arrays a, Arrays b, Arrays c, Arrays d, Arrays e, Arrays f, Arrays g, Arrays h, Arrays i, Arrays j, Arrays k, Arrays l, Arrays m, Arrays n, Arrays o) => Unlift Acc (Acc a, Acc b, Acc c, Acc d, Acc e, Acc f, Acc g, Acc h, Acc i, Acc j, Acc k, Acc l, Acc m, Acc n, Acc o) Source # 

Methods

unlift :: Acc (Plain (Acc a, Acc b, Acc c, Acc d, Acc e, Acc f, Acc g, Acc h, Acc i, Acc j, Acc k, Acc l, Acc m, Acc n, Acc o)) -> (Acc a, Acc b, Acc c, Acc d, Acc e, Acc f, Acc g, Acc h, Acc i, Acc j, Acc k, Acc l, Acc m, Acc n, Acc o) Source #

lift1 :: (Unlift Exp a, Lift Exp b) => (a -> b) -> Exp (Plain a) -> Exp (Plain b) Source #

Lift a unary function into Exp.

lift2 :: (Unlift Exp a, Unlift Exp b, Lift Exp c) => (a -> b -> c) -> Exp (Plain a) -> Exp (Plain b) -> Exp (Plain c) Source #

Lift a binary function into Exp.

lift3 :: (Unlift Exp a, Unlift Exp b, Unlift Exp c, Lift Exp d) => (a -> b -> c -> d) -> Exp (Plain a) -> Exp (Plain b) -> Exp (Plain c) -> Exp (Plain d) Source #

Lift a ternary function into Exp.

ilift1 :: (Exp Int -> Exp Int) -> Exp DIM1 -> Exp DIM1 Source #

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

ilift2 :: (Exp Int -> Exp Int -> Exp Int) -> Exp DIM1 -> Exp DIM1 -> Exp DIM1 Source #

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

ilift3 :: (Exp Int -> Exp Int -> Exp Int -> Exp Int) -> Exp DIM1 -> Exp DIM1 -> Exp DIM1 -> Exp DIM1 Source #

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

Scalar operations

Introduction

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

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 a b. (Elt a, Elt b) => Exp (a, b) -> Exp a Source #

Extract the first component of a scalar pair.

afst :: forall a b. (Arrays a, Arrays b) => Acc (a, b) -> Acc a Source #

Extract the first component of an array pair.

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

Extract the second component of a scalar pair.

asnd :: forall a b. (Arrays a, Arrays b) => Acc (a, b) -> Acc b Source #

Extract the second component of an array pair

curry :: Lift f (f a, f b) => (f (Plain (f a), Plain (f b)) -> f c) -> f a -> f b -> f c Source #

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 c Source #

Converts a curried function to a function on pairs.

Flow control

(?) :: Elt t => Exp Bool -> (Exp t, Exp t) -> Exp t infix 0 Source #

An infix version of cond. If the predicate evaluates to True, the first component of the tuple is returned, else the second.

Enabling the RebindableSyntax extension will allow you to use the standard if-then-else syntax instead.

caseof Source #

Arguments

:: (Elt a, Elt b) 
=> Exp a

case subject

-> [(Exp a -> Exp Bool, Exp b)]

list of cases to attempt

-> Exp b

default value

-> Exp b 

A case-like control structure

cond Source #

Arguments

:: Elt t 
=> Exp Bool

condition

-> Exp t

then-expression

-> Exp t

else-expression

-> Exp t 

A scalar-level if-then-else construct.

Enabling the RebindableSyntax extension will allow you to use the standard if-then-else syntax instead.

while Source #

Arguments

:: Elt e 
=> (Exp e -> Exp Bool)

keep evaluating while this returns True

-> (Exp e -> Exp e)

function to apply

-> Exp e

initial value

-> Exp e 

While construct. Continue to apply the given function, starting with the initial value, until the test function evaluates to False.

iterate :: forall a. Elt a => Exp Int -> (Exp a -> Exp a) -> Exp a -> Exp a Source #

Repeatedly apply a function a fixed number of times

Scalar reduction

sfoldl :: forall sh a b. (Shape sh, Slice sh, Elt a, Elt b) => (Exp a -> Exp b -> Exp a) -> Exp a -> Exp sh -> Acc (Array (sh :. Int) b) -> Exp a Source #

Reduce along an innermost slice of an array sequentially, by applying a binary operator to a starting value and the array from left to right.

Logical operations

(&&) :: Exp Bool -> Exp Bool -> Exp Bool infixr 3 Source #

Conjunction: True if both arguments are true. This is a short-circuit operator, so the second argument will be evaluated only if the first is true.

(||) :: Exp Bool -> Exp Bool -> Exp Bool infixr 2 Source #

Disjunction: True if either argument is true. This is a short-circuit operator, so the second argument will be evaluated only if the first is false.

not :: Exp Bool -> Exp Bool Source #

Logical negation

Numeric operations

subtract :: Num a => Exp a -> Exp a -> Exp a Source #

subtract is the same as flip (-).

even :: Integral a => Exp a -> Exp Bool Source #

Determine if a number is even

odd :: Integral a => Exp a -> Exp Bool Source #

Determine if a number is odd

gcd :: Integral a => Exp a -> Exp a -> Exp a Source #

gcd x y is the non-negative factor of both x and y of which every common factor of both x and y is also a factor; for example:

>>> gcd 4 2 = 2
>>> gcd (-4) 6 = 2
>>> gcd 0 4 = 4
>>> gcd 0 0 = 0

That is, the common divisor that is "greatest" in the divisibility preordering.

lcm :: Integral a => Exp a -> Exp a -> Exp a Source #

lcm x y is the smallest positive integer that both x and y divide.

(^) :: forall a b. (Num a, Integral b) => Exp a -> Exp b -> Exp a infixr 8 Source #

Raise a number to a non-negative integral power

(^^) :: (Fractional a, Integral b) => Exp a -> Exp b -> Exp a infixr 8 Source #

Raise a number to an integral power

Shape manipulation

index0 :: Exp Z Source #

The one index for a rank-0 array.

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 i Source #

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.

index3 :: (Elt i, Slice (Z :. i), Slice ((Z :. i) :. i)) => Exp i -> Exp i -> Exp i -> Exp (((Z :. i) :. i) :. i) Source #

Create a rank-3 index from three Exp Int`s

unindex3 :: forall i. (Elt i, Slice (Z :. i), Slice ((Z :. i) :. i)) => Exp (((Z :. i) :. i) :. i) -> Exp (i, i, i) Source #

Destruct a rank-3 index into an Exp tuple of Int`s

indexHead :: (Slice sh, Elt a) => Exp (sh :. a) -> Exp a Source #

Get the innermost dimension of a shape.

The innermost dimension (right-most component of the shape) is the index of the array which varies most rapidly, and corresponds to elements of the array which are adjacent in memory.

Another way to think of this is, for example when writing nested loops over an array in C, this index corresponds to the index iterated over by the innermost nested loop.

indexTail :: (Slice sh, Elt a) => Exp (sh :. a) -> Exp sh Source #

Get all but the innermost element of a shape

toIndex Source #

Arguments

:: Shape sh 
=> Exp sh

extent of the array

-> Exp sh

index to remap

-> Exp Int 

Map a multi-dimensional index into a linear, row-major representation of an array.

fromIndex :: Shape sh => Exp sh -> Exp Int -> Exp sh Source #

Inverse of toIndex

intersect :: Shape sh => Exp sh -> Exp sh -> Exp sh Source #

Intersection of two shapes

Conversions

ord :: Exp Char -> Exp Int Source #

Convert a character to an Int.

chr :: Exp Int -> Exp Char Source #

Convert an Int into a character.

boolToInt :: Exp Bool -> Exp Int Source #

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

bitcast :: (Elt a, Elt b, IsScalar a, IsScalar b, BitSizeEq a b) => Exp a -> Exp b Source #

Reinterpret a value as another type. The two representations must have the same bit size.

Foreign Function Interface (FFI)

foreignAcc :: (Arrays as, Arrays bs, Foreign asm) => asm (as -> bs) -> (Acc as -> Acc bs) -> Acc as -> Acc bs Source #

Call a foreign array function.

The form the first argument takes is dependent on the backend being targeted. Note that the foreign function only has access to the input array(s) passed in as its argument.

In case the operation is being executed on a backend which does not support this foreign implementation, the fallback implementation is used instead, which itself could be a foreign implementation for a (presumably) different backend, or an implementation in pure Accelerate. In this way, multiple foreign implementations can be supplied, and will be tested for suitability against the target backend in sequence.

For an example see the accelerate-fft package.

foreignExp :: (Elt x, Elt y, Foreign asm) => asm (x -> y) -> (Exp x -> Exp y) -> Exp x -> Exp y Source #

Call a foreign scalar expression.

The form of the first argument is dependent on the backend being targeted. Note that the foreign function only has access to the input element(s) passed in as its first argument.

As with foreignAcc, the fallback implementation itself may be a (sequence of) foreign implementation(s) for a different backend(s), or implemented purely in Accelerate.

Plain arrays

Operations

arrayRank :: Shape sh => sh -> Int Source #

Rank of an array.

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

Array shape in plain Haskell code.

arraySize :: Shape sh => sh -> Int Source #

Total number of elements in an array of the given Shape.

indexArray :: Array sh e -> sh -> e Source #

Array indexing in plain Haskell code.

Getting data in

We often need to generate or read data into an Array so that it can be used in Accelerate. The base accelerate library includes basic conversions routines, but for additional functionality see the accelerate-io package, which includes conversions between:

  • repa: another Haskell library for high-performance parallel arrays
  • vector: efficient boxed and unboxed one-dimensional arrays
  • array: immutable arrays
  • BMP: uncompressed BMP image files
  • bytestring compact, immutable binary data
  • As well as copying data directly from raw Ptrs

Function

fromFunction :: (Shape sh, Elt e) => sh -> (sh -> e) -> Array sh e Source #

Create an array from its representation function, applied at each index of the array.

Lists

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

Convert elements of a list into an Accelerate Array.

This will generate a new multidimensional Array of the specified shape and extent by consuming elements from the list and adding them to the array in row-major order.

>>> fromList (Z:.10) [0..] :: Vector Int
Vector (Z :. 10) [0,1,2,3,4,5,6,7,8,9]

Note that we pull elements off the list lazily, so infinite lists are accepted:

>>> fromList (Z:.5:.10) (repeat 0) :: Array DIM2 Float
Matrix (Z :. 5 :. 10)
  [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
    0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
    0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
    0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
    0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]

You can also make use of the OverloadedLists extension to produce one-dimensional vectors from a finite list.

>>> [0..9] :: Vector Int
Vector (Z :. 10) [0,1,2,3,4,5,6,7,8,9]

Note that this requires first traversing the list to determine its length, and then traversing it a second time to collect the elements into the array, thus forcing the spine of the list to be manifest on the heap.

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

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

Prelude re-exports

(.) :: (b -> c) -> (a -> b) -> a -> c infixr 9 #

Function composition.

($) :: (a -> b) -> a -> b infixr 0 #

Application operator. This operator is redundant, since ordinary application (f x) means the same as (f $ x). However, $ has low, right-associative binding precedence, so it sometimes allows parentheses to be omitted; for example:

    f $ g $ h x  =  f (g (h x))

It is also useful in higher-order situations, such as map ($ 0) xs, or zipWith ($) fs xs.

error :: HasCallStack => [Char] -> a #

error stops execution and displays an error message.

undefined :: HasCallStack => a #

A special case of error. It is expected that compilers will recognize this and insert error messages which are more appropriate to the context in which undefined appears.

const :: a -> b -> a #

const x is a unary function which evaluates to x for all inputs.

For instance,

>>> map (const 42) [0..3]
[42,42,42,42]

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 

Methods

minBound :: Int #

maxBound :: Int #

Enum Int 

Methods

succ :: Int -> Int #

pred :: Int -> Int #

toEnum :: Int -> Int #

fromEnum :: Int -> Int #

enumFrom :: Int -> [Int] #

enumFromThen :: Int -> Int -> [Int] #

enumFromTo :: Int -> Int -> [Int] #

enumFromThenTo :: Int -> Int -> Int -> [Int] #

Eq Int 

Methods

(==) :: Int -> Int -> Bool #

(/=) :: Int -> Int -> Bool #

Integral Int 

Methods

quot :: Int -> Int -> Int #

rem :: Int -> Int -> Int #

div :: Int -> Int -> Int #

mod :: Int -> Int -> Int #

quotRem :: Int -> Int -> (Int, Int) #

divMod :: Int -> Int -> (Int, Int) #

toInteger :: Int -> Integer #

Data Int 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int -> c Int #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int #

toConstr :: Int -> Constr #

dataTypeOf :: Int -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Int) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int) #

gmapT :: (forall b. Data b => b -> b) -> Int -> Int #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int -> r #

gmapQ :: (forall d. Data d => d -> u) -> Int -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Int -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int -> m Int #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int -> m Int #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int -> m Int #

Num Int 

Methods

(+) :: Int -> Int -> Int #

(-) :: Int -> Int -> Int #

(*) :: Int -> Int -> Int #

negate :: Int -> Int #

abs :: Int -> Int #

signum :: Int -> Int #

fromInteger :: Integer -> Int #

Ord Int 

Methods

compare :: Int -> Int -> Ordering #

(<) :: Int -> Int -> Bool #

(<=) :: Int -> Int -> Bool #

(>) :: Int -> Int -> Bool #

(>=) :: Int -> Int -> Bool #

max :: Int -> Int -> Int #

min :: Int -> Int -> Int #

Real Int 

Methods

toRational :: Int -> Rational #

Show Int 

Methods

showsPrec :: Int -> Int -> ShowS #

show :: Int -> String #

showList :: [Int] -> ShowS #

Ix Int 

Methods

range :: (Int, Int) -> [Int] #

index :: (Int, Int) -> Int -> Int #

unsafeIndex :: (Int, Int) -> Int -> Int

inRange :: (Int, Int) -> Int -> Bool #

rangeSize :: (Int, Int) -> Int #

unsafeRangeSize :: (Int, Int) -> Int

Lift Int 

Methods

lift :: Int -> Q Exp #

Pretty Int 

Methods

pretty :: Int -> Doc #

prettyList :: [Int] -> Doc #

PrintfArg Int 
Storable Int 

Methods

sizeOf :: Int -> Int #

alignment :: Int -> Int #

peekElemOff :: Ptr Int -> Int -> IO Int #

pokeElemOff :: Ptr Int -> Int -> Int -> IO () #

peekByteOff :: Ptr b -> Int -> IO Int #

pokeByteOff :: Ptr b -> Int -> Int -> IO () #

peek :: Ptr Int -> IO Int #

poke :: Ptr Int -> Int -> IO () #

Bits Int 

Methods

(.&.) :: Int -> Int -> Int #

(.|.) :: Int -> Int -> Int #

xor :: Int -> Int -> Int #

complement :: Int -> Int #

shift :: Int -> Int -> Int #

rotate :: Int -> Int -> Int #

zeroBits :: Int #

bit :: Int -> Int #

setBit :: Int -> Int -> Int #

clearBit :: Int -> Int -> Int #

complementBit :: Int -> Int -> Int #

testBit :: Int -> Int -> Bool #

bitSizeMaybe :: Int -> Maybe Int #

bitSize :: Int -> Int #

isSigned :: Int -> Bool #

shiftL :: Int -> Int -> Int #

unsafeShiftL :: Int -> Int -> Int #

shiftR :: Int -> Int -> Int #

unsafeShiftR :: Int -> Int -> Int #

rotateL :: Int -> Int -> Int #

rotateR :: Int -> Int -> Int #

popCount :: Int -> Int #

FiniteBits Int 
NFData Int 

Methods

rnf :: Int -> () #

Hashable Int 

Methods

hashWithSalt :: Int -> Int -> Int #

hash :: Int -> Int #

Prim Int 
Unbox Int 
IsScalar Int Source # 

Methods

scalarType :: ScalarType Int

IsBounded Int Source # 

Methods

boundedType :: BoundedType Int

IsNum Int Source # 

Methods

numType :: NumType Int

IsIntegral Int Source # 

Methods

integralType :: IntegralType Int

Elt Int Source # 

Methods

eltType :: Int -> TupleType (EltRepr Int)

fromElt :: Int -> EltRepr Int

toElt :: EltRepr Int -> Int

Eq Int Source # 

Methods

(==) :: Exp Int -> Exp Int -> Exp Bool Source #

(/=) :: Exp Int -> Exp Int -> Exp Bool Source #

Ord Int Source # 
FiniteBits Int Source # 
Bits Int Source # 
Vector Vector Int 
MVector MVector Int 
FromIntegral Int Double Source # 
FromIntegral Int Float Source # 
FromIntegral Int Int Source # 
FromIntegral Int Int8 Source # 
FromIntegral Int Int16 Source # 
FromIntegral Int Int32 Source # 
FromIntegral Int Int64 Source # 
FromIntegral Int Word Source # 
FromIntegral Int Word8 Source # 
FromIntegral Int Word16 Source # 
FromIntegral Int Word32 Source # 
FromIntegral Int Word64 Source # 
FromIntegral Int CShort Source # 
FromIntegral Int CUShort Source # 
FromIntegral Int CInt Source # 
FromIntegral Int CUInt Source # 
FromIntegral Int CLong Source # 
FromIntegral Int CULong Source # 
FromIntegral Int CLLong Source # 
FromIntegral Int CULLong Source # 
FromIntegral Int CFloat Source # 
FromIntegral Int CDouble Source # 
FromIntegral Int8 Int Source # 
FromIntegral Int16 Int Source # 
FromIntegral Int32 Int Source # 
FromIntegral Int64 Int Source # 
FromIntegral Word Int Source # 
FromIntegral Word8 Int Source # 
FromIntegral Word16 Int Source # 
FromIntegral Word32 Int Source # 
FromIntegral Word64 Int Source # 
FromIntegral CShort Int Source # 
FromIntegral CUShort Int Source # 
FromIntegral CInt Int Source # 
FromIntegral CUInt Int Source # 
FromIntegral CLong Int Source # 
FromIntegral CULong Int Source # 
FromIntegral CLLong Int Source # 
FromIntegral CULLong Int Source # 
ToFloating Int Double Source # 
ToFloating Int Float Source # 
ToFloating Int CFloat Source # 
ToFloating Int CDouble Source # 
Lift Exp Int Source # 

Associated Types

type Plain Int :: * Source #

Methods

lift :: Int -> Exp (Plain Int) Source #

Elt e => Stencil DIM1 e (Exp e, Exp e, Exp e) Source # 

Associated Types

type StencilRepr DIM1 (Exp e, Exp e, Exp e) :: *

Methods

stencilPrj :: DIM1 -> e -> Exp (StencilRepr DIM1 (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) Source # 

Associated Types

type StencilRepr DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e) :: *

Methods

stencilPrj :: DIM1 -> e -> Exp (StencilRepr DIM1 (Exp e, Exp e, Exp 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) Source # 

Associated Types

type StencilRepr DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e) :: *

Methods

stencilPrj :: DIM1 -> e -> Exp (StencilRepr DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp 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) Source # 

Associated Types

type StencilRepr DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e) :: *

Methods

stencilPrj :: DIM1 -> e -> Exp (StencilRepr DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp 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) Source # 

Associated Types

type Plain ((:.) ix Int) :: * Source #

Methods

lift :: (ix :. Int) -> Exp (Plain (ix :. Int)) Source #

Elt e => IsList (Vector e) # 

Associated Types

type Item (Vector e) :: * #

Methods

fromList :: [Item (Vector e)] -> Vector e #

fromListN :: Int -> [Item (Vector e)] -> Vector e #

toList :: Vector e -> [Item (Vector e)] #

Functor (URec Int) 

Methods

fmap :: (a -> b) -> URec Int a -> URec Int b #

(<$) :: a -> URec Int b -> URec Int a #

Show (Vector e) # 

Methods

showsPrec :: Int -> Vector e -> ShowS #

show :: Vector e -> String #

showList :: [Vector e] -> ShowS #

Foldable (URec Int) 

Methods

fold :: Monoid m => URec Int m -> m #

foldMap :: Monoid m => (a -> m) -> URec Int a -> m #

foldr :: (a -> b -> b) -> b -> URec Int a -> b #

foldr' :: (a -> b -> b) -> b -> URec Int a -> b #

foldl :: (b -> a -> b) -> b -> URec Int a -> b #

foldl' :: (b -> a -> b) -> b -> URec Int a -> b #

foldr1 :: (a -> a -> a) -> URec Int a -> a #

foldl1 :: (a -> a -> a) -> URec Int a -> a #

toList :: URec Int a -> [a] #

null :: URec Int a -> Bool #

length :: URec Int a -> Int #

elem :: Eq a => a -> URec Int a -> Bool #

maximum :: Ord a => URec Int a -> a #

minimum :: Ord a => URec Int a -> a #

sum :: Num a => URec Int a -> a #

product :: Num a => URec Int a -> a #

Traversable (URec Int) 

Methods

traverse :: Applicative f => (a -> f b) -> URec Int a -> f (URec Int b) #

sequenceA :: Applicative f => URec Int (f a) -> f (URec Int a) #

mapM :: Monad m => (a -> m b) -> URec Int a -> m (URec Int b) #

sequence :: Monad m => URec Int (m a) -> m (URec Int a) #

Generic1 (URec Int) 

Associated Types

type Rep1 (URec Int :: * -> *) :: * -> * #

Methods

from1 :: URec Int a -> Rep1 (URec Int) a #

to1 :: Rep1 (URec Int) a -> URec Int a #

Shape sh => Elt (Any ((:.) sh Int)) Source # 

Methods

eltType :: Any (sh :. Int) -> TupleType (EltRepr (Any (sh :. Int)))

fromElt :: Any (sh :. Int) -> EltRepr (Any (sh :. Int))

toElt :: EltRepr (Any (sh :. Int)) -> Any (sh :. Int)

Eq (URec Int p) 

Methods

(==) :: URec Int p -> URec Int p -> Bool #

(/=) :: URec Int p -> URec Int p -> Bool #

Ord (URec Int p) 

Methods

compare :: URec Int p -> URec Int p -> Ordering #

(<) :: URec Int p -> URec Int p -> Bool #

(<=) :: URec Int p -> URec Int p -> Bool #

(>) :: URec Int p -> URec Int p -> Bool #

(>=) :: URec Int p -> URec Int p -> Bool #

max :: URec Int p -> URec Int p -> URec Int p #

min :: URec Int p -> URec Int p -> URec Int p #

Show (URec Int p) 

Methods

showsPrec :: Int -> URec Int p -> ShowS #

show :: URec Int p -> String #

showList :: [URec Int p] -> ShowS #

Show (Array DIM2 e) # 

Methods

showsPrec :: Int -> Array DIM2 e -> ShowS #

show :: Array DIM2 e -> String #

showList :: [Array DIM2 e] -> ShowS #

Generic (URec Int p) 

Associated Types

type Rep (URec Int p) :: * -> * #

Methods

from :: URec Int p -> Rep (URec Int p) x #

to :: Rep (URec Int p) x -> URec Int p #

Slice sl => Slice ((:.) sl Int) Source # 

Associated Types

type SliceShape ((:.) sl Int) :: * Source #

type CoSliceShape ((:.) sl Int) :: * Source #

type FullShape ((:.) sl Int) :: * Source #

Methods

sliceIndex :: (sl :. Int) -> SliceIndex (EltRepr (sl :. Int)) (EltRepr (SliceShape (sl :. Int))) (EltRepr (CoSliceShape (sl :. Int))) (EltRepr (FullShape (sl :. Int))) Source #

Shape sh => Shape ((:.) sh Int) Source # 

Methods

rank :: (sh :. Int) -> Int

size :: (sh :. Int) -> Int

empty :: sh :. Int

ignore :: sh :. Int

intersect :: (sh :. Int) -> (sh :. Int) -> sh :. Int

union :: (sh :. Int) -> (sh :. Int) -> sh :. Int

toIndex :: (sh :. Int) -> (sh :. Int) -> Int

fromIndex :: (sh :. Int) -> Int -> sh :. Int

iter :: (sh :. Int) -> ((sh :. Int) -> a) -> (a -> a -> a) -> a -> a

iter1 :: (sh :. Int) -> ((sh :. Int) -> a) -> (a -> a -> a) -> a

rangeToShape :: (sh :. Int, sh :. Int) -> sh :. Int

shapeToRange :: (sh :. Int) -> (sh :. Int, sh :. Int)

shapeToList :: (sh :. Int) -> [Int]

listToShape :: [Int] -> sh :. Int

sliceAnyIndex :: (sh :. Int) -> SliceIndex (EltRepr (Any (sh :. Int))) (EltRepr (sh :. Int)) () (EltRepr (sh :. Int))

sliceNoneIndex :: (sh :. Int) -> SliceIndex (EltRepr (sh :. Int)) () (EltRepr (sh :. Int)) (EltRepr (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) Source # 

Associated Types

type StencilRepr ((:.) ((:.) sh Int) Int) (row2, row1, row0) :: *

Methods

stencilPrj :: ((sh :. Int) :. Int) -> a -> Exp (StencilRepr ((sh :. Int) :. Int) (row2, row1, row0)) -> (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) Source # 

Associated Types

type StencilRepr ((:.) ((:.) sh Int) Int) (row1, row2, row3, row4, row5) :: *

Methods

stencilPrj :: ((sh :. Int) :. Int) -> a -> Exp (StencilRepr ((sh :. Int) :. Int) (row1, row2, row3, row4, row5)) -> (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) Source # 

Associated Types

type StencilRepr ((:.) ((:.) sh Int) Int) (row1, row2, row3, row4, row5, row6, row7) :: *

Methods

stencilPrj :: ((sh :. Int) :. Int) -> a -> Exp (StencilRepr ((sh :. Int) :. Int) (row1, row2, row3, row4, row5, row6, row7)) -> (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) Source # 

Associated Types

type StencilRepr ((:.) ((:.) sh Int) Int) (row1, row2, row3, row4, row5, row6, row7, row8, row9) :: *

Methods

stencilPrj :: ((sh :. Int) :. Int) -> a -> Exp (StencilRepr ((sh :. Int) :. Int) (row1, row2, row3, row4, row5, row6, row7, row8, row9)) -> (row1, row2, row3, row4, row5, row6, row7, row8, row9)

data URec Int

Used for marking occurrences of Int#

data URec Int = UInt {}
data Vector Int 
type Plain Int Source # 
type Plain Int = Int
data MVector s Int 
type Rep1 (URec Int) 
type Rep1 (URec Int) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UInt" PrefixI True) (S1 (MetaSel (Just Symbol "uInt#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) UInt))
type Item (Vector e) # 
type Item (Vector e) = e
type Rep (URec Int p) 
type Rep (URec Int p) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UInt" PrefixI True) (S1 (MetaSel (Just Symbol "uInt#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) UInt))
type SliceShape ((:.) sl Int) Source # 
type SliceShape ((:.) sl Int) = SliceShape sl
type CoSliceShape ((:.) sl Int) Source # 
type FullShape ((:.) sl Int) Source # 
type FullShape ((:.) sl Int) = (:.) (FullShape sl) Int
type Plain ((:.) ix Int) Source # 
type Plain ((:.) ix Int) = (:.) (Plain ix) Int

data Int8 :: * #

8-bit signed integer type

Instances

Bounded Int8 
Enum Int8 

Methods

succ :: Int8 -> Int8 #

pred :: Int8 -> Int8 #

toEnum :: Int -> Int8 #

fromEnum :: Int8 -> Int #

enumFrom :: Int8 -> [Int8] #

enumFromThen :: Int8 -> Int8 -> [Int8] #

enumFromTo :: Int8 -> Int8 -> [Int8] #

enumFromThenTo :: Int8 -> Int8 -> Int8 -> [Int8] #

Eq Int8 

Methods

(==) :: Int8 -> Int8 -> Bool #

(/=) :: Int8 -> Int8 -> Bool #

Integral Int8 

Methods

quot :: Int8 -> Int8 -> Int8 #

rem :: Int8 -> Int8 -> Int8 #

div :: Int8 -> Int8 -> Int8 #

mod :: Int8 -> Int8 -> Int8 #

quotRem :: Int8 -> Int8 -> (Int8, Int8) #

divMod :: Int8 -> Int8 -> (Int8, Int8) #

toInteger :: Int8 -> Integer #

Data Int8 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int8 -> c Int8 #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int8 #

toConstr :: Int8 -> Constr #

dataTypeOf :: Int8 -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Int8) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int8) #

gmapT :: (forall b. Data b => b -> b) -> Int8 -> Int8 #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int8 -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int8 -> r #

gmapQ :: (forall d. Data d => d -> u) -> Int8 -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Int8 -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int8 -> m Int8 #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int8 -> m Int8 #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int8 -> m Int8 #

Num Int8 

Methods

(+) :: Int8 -> Int8 -> Int8 #

(-) :: Int8 -> Int8 -> Int8 #

(*) :: Int8 -> Int8 -> Int8 #

negate :: Int8 -> Int8 #

abs :: Int8 -> Int8 #

signum :: Int8 -> Int8 #

fromInteger :: Integer -> Int8 #

Ord Int8 

Methods

compare :: Int8 -> Int8 -> Ordering #

(<) :: Int8 -> Int8 -> Bool #

(<=) :: Int8 -> Int8 -> Bool #

(>) :: Int8 -> Int8 -> Bool #

(>=) :: Int8 -> Int8 -> Bool #

max :: Int8 -> Int8 -> Int8 #

min :: Int8 -> Int8 -> Int8 #

Read Int8 
Real Int8 

Methods

toRational :: Int8 -> Rational #

Show Int8 

Methods

showsPrec :: Int -> Int8 -> ShowS #

show :: Int8 -> String #

showList :: [Int8] -> ShowS #

Ix Int8 

Methods

range :: (Int8, Int8) -> [Int8] #

index :: (Int8, Int8) -> Int8 -> Int #

unsafeIndex :: (Int8, Int8) -> Int8 -> Int

inRange :: (Int8, Int8) -> Int8 -> Bool #

rangeSize :: (Int8, Int8) -> Int #

unsafeRangeSize :: (Int8, Int8) -> Int

Lift Int8 

Methods

lift :: Int8 -> Q Exp #

PrintfArg Int8 
Storable Int8 

Methods

sizeOf :: Int8 -> Int #

alignment :: Int8 -> Int #

peekElemOff :: Ptr Int8 -> Int -> IO Int8 #

pokeElemOff :: Ptr Int8 -> Int -> Int8 -> IO () #

peekByteOff :: Ptr b -> Int -> IO Int8 #

pokeByteOff :: Ptr b -> Int -> Int8 -> IO () #

peek :: Ptr Int8 -> IO Int8 #

poke :: Ptr Int8 -> Int8 -> IO () #

Bits Int8 
FiniteBits Int8 
NFData Int8 

Methods

rnf :: Int8 -> () #

Hashable Int8 

Methods

hashWithSalt :: Int -> Int8 -> Int #

hash :: Int8 -> Int #

Prim Int8 
Unbox Int8 
IsScalar Int8 Source # 

Methods

scalarType :: ScalarType Int8

IsBounded Int8 Source # 

Methods

boundedType :: BoundedType Int8

IsNum Int8 Source # 

Methods

numType :: NumType Int8

IsIntegral Int8 Source # 

Methods

integralType :: IntegralType Int8

Elt Int8 Source # 

Methods

eltType :: Int8 -> TupleType (EltRepr Int8)

fromElt :: Int8 -> EltRepr Int8

toElt :: EltRepr Int8 -> Int8

Eq Int8 Source # 
Ord Int8 Source # 
FiniteBits Int8 Source # 
Bits Int8 Source # 
Vector Vector Int8 
MVector MVector Int8 
FromIntegral Int Int8 Source # 
FromIntegral Int8 Double Source # 
FromIntegral Int8 Float Source # 
FromIntegral Int8 Int Source # 
FromIntegral Int8 Int8 Source # 
FromIntegral Int8 Int16 Source # 
FromIntegral Int8 Int32 Source # 
FromIntegral Int8 Int64 Source # 
FromIntegral Int8 Word Source # 
FromIntegral Int8 Word8 Source # 
FromIntegral Int8 Word16 Source # 
FromIntegral Int8 Word32 Source # 
FromIntegral Int8 Word64 Source # 
FromIntegral Int8 CShort Source # 
FromIntegral Int8 CUShort Source # 
FromIntegral Int8 CInt Source # 
FromIntegral Int8 CUInt Source # 
FromIntegral Int8 CLong Source # 
FromIntegral Int8 CULong Source # 
FromIntegral Int8 CLLong Source # 
FromIntegral Int8 CULLong Source # 
FromIntegral Int8 CFloat Source # 
FromIntegral Int8 CDouble Source # 
FromIntegral Int16 Int8 Source # 
FromIntegral Int32 Int8 Source # 
FromIntegral Int64 Int8 Source # 
FromIntegral Word Int8 Source # 
FromIntegral Word8 Int8 Source # 
FromIntegral Word16 Int8 Source # 
FromIntegral Word32 Int8 Source # 
FromIntegral Word64 Int8 Source # 
FromIntegral CShort Int8 Source # 
FromIntegral CUShort Int8 Source # 
FromIntegral CInt Int8 Source # 
FromIntegral CUInt Int8 Source # 
FromIntegral CLong Int8 Source # 
FromIntegral CULong Int8 Source # 
FromIntegral CLLong Int8 Source # 
FromIntegral CULLong Int8 Source # 
ToFloating Int8 Double Source # 
ToFloating Int8 Float Source # 
ToFloating Int8 CFloat Source # 
ToFloating Int8 CDouble Source # 
Lift Exp Int8 Source # 

Associated Types

type Plain Int8 :: * Source #

Methods

lift :: Int8 -> Exp (Plain Int8) Source #

data Vector Int8 
type Plain Int8 Source # 
type Plain Int8 = Int8
data MVector s Int8 

data Int16 :: * #

16-bit signed integer type

Instances

Bounded Int16 
Enum Int16 
Eq Int16 

Methods

(==) :: Int16 -> Int16 -> Bool #

(/=) :: Int16 -> Int16 -> Bool #

Integral Int16 
Data Int16 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int16 -> c Int16 #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int16 #

toConstr :: Int16 -> Constr #

dataTypeOf :: Int16 -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Int16) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int16) #

gmapT :: (forall b. Data b => b -> b) -> Int16 -> Int16 #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int16 -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int16 -> r #

gmapQ :: (forall d. Data d => d -> u) -> Int16 -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Int16 -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int16 -> m Int16 #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int16 -> m Int16 #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int16 -> m Int16 #

Num Int16 
Ord Int16 

Methods

compare :: Int16 -> Int16 -> Ordering #

(<) :: Int16 -> Int16 -> Bool #

(<=) :: Int16 -> Int16 -> Bool #

(>) :: Int16 -> Int16 -> Bool #

(>=) :: Int16 -> Int16 -> Bool #

max :: Int16 -> Int16 -> Int16 #

min :: Int16 -> Int16 -> Int16 #

Read Int16 
Real Int16 

Methods

toRational :: Int16 -> Rational #

Show Int16 

Methods

showsPrec :: Int -> Int16 -> ShowS #

show :: Int16 -> String #

showList :: [Int16] -> ShowS #

Ix Int16 
Lift Int16 

Methods

lift :: Int16 -> Q Exp #

PrintfArg Int16 
Storable Int16 

Methods

sizeOf :: Int16 -> Int #

alignment :: Int16 -> Int #

peekElemOff :: Ptr Int16 -> Int -> IO Int16 #

pokeElemOff :: Ptr Int16 -> Int -> Int16 -> IO () #

peekByteOff :: Ptr b -> Int -> IO Int16 #

pokeByteOff :: Ptr b -> Int -> Int16 -> IO () #

peek :: Ptr Int16 -> IO Int16 #

poke :: Ptr Int16 -> Int16 -> IO () #

Bits Int16 
FiniteBits Int16 
NFData Int16 

Methods

rnf :: Int16 -> () #

Hashable Int16 

Methods

hashWithSalt :: Int -> Int16 -> Int #

hash :: Int16 -> Int #

Prim Int16 
Unbox Int16 
IsScalar Int16 Source # 

Methods

scalarType :: ScalarType Int16

IsBounded Int16 Source # 

Methods

boundedType :: BoundedType Int16

IsNum Int16 Source # 

Methods

numType :: NumType Int16

IsIntegral Int16 Source # 

Methods

integralType :: IntegralType Int16

Elt Int16 Source # 

Methods

eltType :: Int16 -> TupleType (EltRepr Int16)

fromElt :: Int16 -> EltRepr Int16

toElt :: EltRepr Int16 -> Int16

Eq Int16 Source # 
Ord Int16 Source # 
FiniteBits Int16 Source # 
Bits Int16 Source # 
Vector Vector Int16 
MVector MVector Int16 
FromIntegral Int Int16 Source # 
FromIntegral Int8 Int16 Source # 
FromIntegral Int16 Double Source # 
FromIntegral Int16 Float Source # 
FromIntegral Int16 Int Source # 
FromIntegral Int16 Int8 Source # 
FromIntegral Int16 Int16 Source # 
FromIntegral Int16 Int32 Source # 
FromIntegral Int16 Int64 Source # 
FromIntegral Int16 Word Source # 
FromIntegral Int16 Word8 Source # 
FromIntegral Int16 Word16 Source # 
FromIntegral Int16 Word32 Source # 
FromIntegral Int16 Word64 Source # 
FromIntegral Int16 CShort Source # 
FromIntegral Int16 CUShort Source # 
FromIntegral Int16 CInt Source # 
FromIntegral Int16 CUInt Source # 
FromIntegral Int16 CLong Source # 
FromIntegral Int16 CULong Source # 
FromIntegral Int16 CLLong Source # 
FromIntegral Int16 CULLong Source # 
FromIntegral Int16 CFloat Source # 
FromIntegral Int16 CDouble Source # 
FromIntegral Int32 Int16 Source # 
FromIntegral Int64 Int16 Source # 
FromIntegral Word Int16 Source # 
FromIntegral Word8 Int16 Source # 
FromIntegral Word16 Int16 Source # 
FromIntegral Word32 Int16 Source # 
FromIntegral Word64 Int16 Source # 
FromIntegral CShort Int16 Source # 
FromIntegral CUShort Int16 Source # 
FromIntegral CInt Int16 Source # 
FromIntegral CUInt Int16 Source # 
FromIntegral CLong Int16 Source # 
FromIntegral CULong Int16 Source # 
FromIntegral CLLong Int16 Source # 
FromIntegral CULLong Int16 Source # 
ToFloating Int16 Double Source # 
ToFloating Int16 Float Source # 
ToFloating Int16 CFloat Source # 
ToFloating Int16 CDouble Source # 
Lift Exp Int16 Source # 

Associated Types

type Plain Int16 :: * Source #

Methods

lift :: Int16 -> Exp (Plain Int16) Source #

data Vector Int16 
type Plain Int16 Source # 
data MVector s Int16 

data Int32 :: * #

32-bit signed integer type

Instances

Bounded Int32 
Enum Int32 
Eq Int32 

Methods

(==) :: Int32 -> Int32 -> Bool #

(/=) :: Int32 -> Int32 -> Bool #

Integral Int32 
Data Int32 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int32 -> c Int32 #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int32 #

toConstr :: Int32 -> Constr #

dataTypeOf :: Int32 -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Int32) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int32) #

gmapT :: (forall b. Data b => b -> b) -> Int32 -> Int32 #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int32 -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int32 -> r #

gmapQ :: (forall d. Data d => d -> u) -> Int32 -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Int32 -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int32 -> m Int32 #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int32 -> m Int32 #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int32 -> m Int32 #

Num Int32 
Ord Int32 

Methods

compare :: Int32 -> Int32 -> Ordering #

(<) :: Int32 -> Int32 -> Bool #

(<=) :: Int32 -> Int32 -> Bool #

(>) :: Int32 -> Int32 -> Bool #

(>=) :: Int32 -> Int32 -> Bool #

max :: Int32 -> Int32 -> Int32 #

min :: Int32 -> Int32 -> Int32 #

Read Int32 
Real Int32 

Methods

toRational :: Int32 -> Rational #

Show Int32 

Methods

showsPrec :: Int -> Int32 -> ShowS #

show :: Int32 -> String #

showList :: [Int32] -> ShowS #

Ix Int32 
Lift Int32 

Methods

lift :: Int32 -> Q Exp #

PrintfArg Int32 
Storable Int32 

Methods

sizeOf :: Int32 -> Int #

alignment :: Int32 -> Int #

peekElemOff :: Ptr Int32 -> Int -> IO Int32 #

pokeElemOff :: Ptr Int32 -> Int -> Int32 -> IO () #

peekByteOff :: Ptr b -> Int -> IO Int32 #

pokeByteOff :: Ptr b -> Int -> Int32 -> IO () #

peek :: Ptr Int32 -> IO Int32 #

poke :: Ptr Int32 -> Int32 -> IO () #

Bits Int32 
FiniteBits Int32 
NFData Int32 

Methods

rnf :: Int32 -> () #

Hashable Int32 

Methods

hashWithSalt :: Int -> Int32 -> Int #

hash :: Int32 -> Int #

Prim Int32 
Unbox Int32 
IsScalar Int32 Source # 

Methods

scalarType :: ScalarType Int32

IsBounded Int32 Source # 

Methods

boundedType :: BoundedType Int32

IsNum Int32 Source # 

Methods

numType :: NumType Int32

IsIntegral Int32 Source # 

Methods

integralType :: IntegralType Int32

Elt Int32 Source # 

Methods

eltType :: Int32 -> TupleType (EltRepr Int32)

fromElt :: Int32 -> EltRepr Int32

toElt :: EltRepr Int32 -> Int32

Eq Int32 Source # 
Ord Int32 Source # 
FiniteBits Int32 Source # 
Bits Int32 Source # 
Vector Vector Int32 
MVector MVector Int32 
FromIntegral Int Int32 Source # 
FromIntegral Int8 Int32 Source # 
FromIntegral Int16 Int32 Source # 
FromIntegral Int32 Double Source # 
FromIntegral Int32 Float Source # 
FromIntegral Int32 Int Source # 
FromIntegral Int32 Int8 Source # 
FromIntegral Int32 Int16 Source # 
FromIntegral Int32 Int32 Source # 
FromIntegral Int32 Int64 Source # 
FromIntegral Int32 Word Source # 
FromIntegral Int32 Word8 Source # 
FromIntegral Int32 Word16 Source # 
FromIntegral Int32 Word32 Source # 
FromIntegral Int32 Word64 Source # 
FromIntegral Int32 CShort Source # 
FromIntegral Int32 CUShort Source # 
FromIntegral Int32 CInt Source # 
FromIntegral Int32 CUInt Source # 
FromIntegral Int32 CLong Source # 
FromIntegral Int32 CULong Source # 
FromIntegral Int32 CLLong Source # 
FromIntegral Int32 CULLong Source # 
FromIntegral Int32 CFloat Source # 
FromIntegral Int32 CDouble Source # 
FromIntegral Int64 Int32 Source # 
FromIntegral Word Int32 Source # 
FromIntegral Word8 Int32 Source # 
FromIntegral Word16 Int32 Source # 
FromIntegral Word32 Int32 Source # 
FromIntegral Word64 Int32 Source # 
FromIntegral CShort Int32 Source # 
FromIntegral CUShort Int32 Source # 
FromIntegral CInt Int32 Source # 
FromIntegral CUInt Int32 Source # 
FromIntegral CLong Int32 Source # 
FromIntegral CULong Int32 Source # 
FromIntegral CLLong Int32 Source # 
FromIntegral CULLong Int32 Source # 
ToFloating Int32 Double Source # 
ToFloating Int32 Float Source # 
ToFloating Int32 CFloat Source # 
ToFloating Int32 CDouble Source # 
Lift Exp Int32 Source # 

Associated Types

type Plain Int32 :: * Source #

Methods

lift :: Int32 -> Exp (Plain Int32) Source #

data Vector Int32 
type Plain Int32 Source # 
data MVector s Int32 

data Int64 :: * #

64-bit signed integer type

Instances

Bounded Int64 
Enum Int64 
Eq Int64 

Methods

(==) :: Int64 -> Int64 -> Bool #

(/=) :: Int64 -> Int64 -> Bool #

Integral Int64 
Data Int64 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int64 -> c Int64 #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int64 #

toConstr :: Int64 -> Constr #

dataTypeOf :: Int64 -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Int64) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int64) #

gmapT :: (forall b. Data b => b -> b) -> Int64 -> Int64 #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int64 -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int64 -> r #

gmapQ :: (forall d. Data d => d -> u) -> Int64 -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Int64 -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int64 -> m Int64 #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int64 -> m Int64 #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int64 -> m Int64 #

Num Int64 
Ord Int64 

Methods

compare :: Int64 -> Int64 -> Ordering #

(<) :: Int64 -> Int64 -> Bool #

(<=) :: Int64 -> Int64 -> Bool #

(>) :: Int64 -> Int64 -> Bool #

(>=) :: Int64 -> Int64 -> Bool #

max :: Int64 -> Int64 -> Int64 #

min :: Int64 -> Int64 -> Int64 #

Read Int64 
Real Int64 

Methods

toRational :: Int64 -> Rational #

Show Int64 

Methods

showsPrec :: Int -> Int64 -> ShowS #

show :: Int64 -> String #

showList :: [Int64] -> ShowS #

Ix Int64 
Lift Int64 

Methods

lift :: Int64 -> Q Exp #

PrintfArg Int64 
Storable Int64 

Methods

sizeOf :: Int64 -> Int #

alignment :: Int64 -> Int #

peekElemOff :: Ptr Int64 -> Int -> IO Int64 #

pokeElemOff :: Ptr Int64 -> Int -> Int64 -> IO () #

peekByteOff :: Ptr b -> Int -> IO Int64 #

pokeByteOff :: Ptr b -> Int -> Int64 -> IO () #

peek :: Ptr Int64 -> IO Int64 #

poke :: Ptr Int64 -> Int64 -> IO () #

Bits Int64 
FiniteBits Int64 
NFData Int64 

Methods

rnf :: Int64 -> () #

Hashable Int64 

Methods

hashWithSalt :: Int -> Int64 -> Int #

hash :: Int64 -> Int #

Prim Int64 
Unbox Int64 
IsScalar Int64 Source # 

Methods

scalarType :: ScalarType Int64

IsBounded Int64 Source # 

Methods

boundedType :: BoundedType Int64

IsNum Int64 Source # 

Methods

numType :: NumType Int64

IsIntegral Int64 Source # 

Methods

integralType :: IntegralType Int64

Elt Int64 Source # 

Methods

eltType :: Int64 -> TupleType (EltRepr Int64)

fromElt :: Int64 -> EltRepr Int64

toElt :: EltRepr Int64 -> Int64

Eq Int64 Source # 
Ord Int64 Source # 
FiniteBits Int64 Source # 
Bits Int64 Source # 
Vector Vector Int64 
MVector MVector Int64 
FromIntegral Int Int64 Source # 
FromIntegral Int8 Int64 Source # 
FromIntegral Int16 Int64 Source # 
FromIntegral Int32 Int64 Source # 
FromIntegral Int64 Double Source # 
FromIntegral Int64 Float Source # 
FromIntegral Int64 Int Source # 
FromIntegral Int64 Int8 Source # 
FromIntegral Int64 Int16 Source # 
FromIntegral Int64 Int32 Source # 
FromIntegral Int64 Int64 Source # 
FromIntegral Int64 Word Source # 
FromIntegral Int64 Word8 Source # 
FromIntegral Int64 Word16 Source # 
FromIntegral Int64 Word32 Source # 
FromIntegral Int64 Word64 Source # 
FromIntegral Int64 CShort Source # 
FromIntegral Int64 CUShort Source # 
FromIntegral Int64 CInt Source # 
FromIntegral Int64 CUInt Source # 
FromIntegral Int64 CLong Source # 
FromIntegral Int64 CULong Source # 
FromIntegral Int64 CLLong Source # 
FromIntegral Int64 CULLong Source # 
FromIntegral Int64 CFloat Source # 
FromIntegral Int64 CDouble Source # 
FromIntegral Word Int64 Source # 
FromIntegral Word8 Int64 Source # 
FromIntegral Word16 Int64 Source # 
FromIntegral Word32 Int64 Source # 
FromIntegral Word64 Int64 Source # 
FromIntegral CShort Int64 Source # 
FromIntegral CUShort Int64 Source # 
FromIntegral CInt Int64 Source # 
FromIntegral CUInt Int64 Source # 
FromIntegral CLong Int64 Source # 
FromIntegral CULong Int64 Source # 
FromIntegral CLLong Int64 Source # 
FromIntegral CULLong Int64 Source # 
ToFloating Int64 Double Source # 
ToFloating Int64 Float Source # 
ToFloating Int64 CFloat Source # 
ToFloating Int64 CDouble Source # 
Lift Exp Int64 Source # 

Associated Types

type Plain Int64 :: * Source #

Methods

lift :: Int64 -> Exp (Plain Int64) Source #

data Vector Int64 
type Plain Int64 Source # 
data MVector s Int64 

data Word :: * #

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

Instances

Bounded Word 
Enum Word 

Methods

succ :: Word -> Word #

pred :: Word -> Word #

toEnum :: Int -> Word #

fromEnum :: Word -> Int #

enumFrom :: Word -> [Word] #

enumFromThen :: Word -> Word -> [Word] #

enumFromTo :: Word -> Word -> [Word] #

enumFromThenTo :: Word -> Word -> Word -> [Word] #

Eq Word 

Methods

(==) :: Word -> Word -> Bool #

(/=) :: Word -> Word -> Bool #

Integral Word 

Methods

quot :: Word -> Word -> Word #

rem :: Word -> Word -> Word #

div :: Word -> Word -> Word #

mod :: Word -> Word -> Word #

quotRem :: Word -> Word -> (Word, Word) #

divMod :: Word -> Word -> (Word, Word) #

toInteger :: Word -> Integer #

Data Word 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word -> c Word #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word #

toConstr :: Word -> Constr #

dataTypeOf :: Word -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Word) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word) #

gmapT :: (forall b. Data b => b -> b) -> Word -> Word #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word -> r #

gmapQ :: (forall d. Data d => d -> u) -> Word -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Word -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word -> m Word #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word -> m Word #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word -> m Word #

Num Word 

Methods

(+) :: Word -> Word -> Word #

(-) :: Word -> Word -> Word #

(*) :: Word -> Word -> Word #

negate :: Word -> Word #

abs :: Word -> Word #

signum :: Word -> Word #

fromInteger :: Integer -> Word #

Ord Word 

Methods

compare :: Word -> Word -> Ordering #

(<) :: Word -> Word -> Bool #

(<=) :: Word -> Word -> Bool #

(>) :: Word -> Word -> Bool #

(>=) :: Word -> Word -> Bool #

max :: Word -> Word -> Word #

min :: Word -> Word -> Word #

Real Word 

Methods

toRational :: Word -> Rational #

Show Word 

Methods

showsPrec :: Int -> Word -> ShowS #

show :: Word -> String #

showList :: [Word] -> ShowS #

Ix Word 

Methods

range :: (Word, Word) -> [Word] #

index :: (Word, Word) -> Word -> Int #

unsafeIndex :: (Word, Word) -> Word -> Int

inRange :: (Word, Word) -> Word -> Bool #

rangeSize :: (Word, Word) -> Int #

unsafeRangeSize :: (Word, Word) -> Int

Lift Word 

Methods

lift :: Word -> Q Exp #

PrintfArg Word 
Storable Word 

Methods

sizeOf :: Word -> Int #

alignment :: Word -> Int #

peekElemOff :: Ptr Word -> Int -> IO Word #

pokeElemOff :: Ptr Word -> Int -> Word -> IO () #

peekByteOff :: Ptr b -> Int -> IO Word #

pokeByteOff :: Ptr b -> Int -> Word -> IO () #

peek :: Ptr Word -> IO Word #

poke :: Ptr Word -> Word -> IO () #

Bits Word 
FiniteBits Word 
NFData Word 

Methods

rnf :: Word -> () #

Hashable Word 

Methods

hashWithSalt :: Int -> Word -> Int #

hash :: Word -> Int #

Prim Word 
Unbox Word 
IsScalar Word Source # 

Methods

scalarType :: ScalarType Word

IsBounded Word Source # 

Methods

boundedType :: BoundedType Word

IsNum Word Source # 

Methods

numType :: NumType Word

IsIntegral Word Source # 

Methods

integralType :: IntegralType Word

Elt Word Source # 

Methods

eltType :: Word -> TupleType (EltRepr Word)

fromElt :: Word -> EltRepr Word

toElt :: EltRepr Word -> Word

Eq Word Source # 
Ord Word Source # 
FiniteBits Word Source # 
Bits Word Source # 
Vector Vector Word 
MVector MVector Word 
FromIntegral Int Word Source # 
FromIntegral Int8 Word Source # 
FromIntegral Int16 Word Source # 
FromIntegral Int32 Word Source # 
FromIntegral Int64 Word Source # 
FromIntegral Word Double Source # 
FromIntegral Word Float Source # 
FromIntegral Word Int Source # 
FromIntegral Word Int8 Source # 
FromIntegral Word Int16 Source # 
FromIntegral Word Int32 Source # 
FromIntegral Word Int64 Source # 
FromIntegral Word Word Source # 
FromIntegral Word Word8 Source # 
FromIntegral Word Word16 Source # 
FromIntegral Word Word32 Source # 
FromIntegral Word Word64 Source # 
FromIntegral Word CShort Source # 
FromIntegral Word CUShort Source # 
FromIntegral Word CInt Source # 
FromIntegral Word CUInt Source # 
FromIntegral Word CLong Source # 
FromIntegral Word CULong Source # 
FromIntegral Word CLLong Source # 
FromIntegral Word CULLong Source # 
FromIntegral Word CFloat Source # 
FromIntegral Word CDouble Source # 
FromIntegral Word8 Word Source # 
FromIntegral Word16 Word Source # 
FromIntegral Word32 Word Source # 
FromIntegral Word64 Word Source # 
FromIntegral CShort Word Source # 
FromIntegral CUShort Word Source # 
FromIntegral CInt Word Source # 
FromIntegral CUInt Word Source # 
FromIntegral CLong Word Source # 
FromIntegral CULong Word Source # 
FromIntegral CLLong Word Source # 
FromIntegral CULLong Word Source # 
ToFloating Word Double Source # 
ToFloating Word Float Source # 
ToFloating Word CFloat Source # 
ToFloating Word CDouble Source # 
Lift Exp Word Source # 

Associated Types

type Plain Word :: * Source #

Methods

lift :: Word -> Exp (Plain Word) Source #

Functor (URec Word) 

Methods

fmap :: (a -> b) -> URec Word a -> URec Word b #

(<$) :: a -> URec Word b -> URec Word a #

Foldable (URec Word) 

Methods

fold :: Monoid m => URec Word m -> m #

foldMap :: Monoid m => (a -> m) -> URec Word a -> m #

foldr :: (a -> b -> b) -> b -> URec Word a -> b #

foldr' :: (a -> b -> b) -> b -> URec Word a -> b #

foldl :: (b -> a -> b) -> b -> URec Word a -> b #

foldl' :: (b -> a -> b) -> b -> URec Word a -> b #

foldr1 :: (a -> a -> a) -> URec Word a -> a #

foldl1 :: (a -> a -> a) -> URec Word a -> a #

toList :: URec Word a -> [a] #

null :: URec Word a -> Bool #

length :: URec Word a -> Int #

elem :: Eq a => a -> URec Word a -> Bool #

maximum :: Ord a => URec Word a -> a #

minimum :: Ord a => URec Word a -> a #

sum :: Num a => URec Word a -> a #

product :: Num a => URec Word a -> a #

Traversable (URec Word) 

Methods

traverse :: Applicative f => (a -> f b) -> URec Word a -> f (URec Word b) #

sequenceA :: Applicative f => URec Word (f a) -> f (URec Word a) #

mapM :: Monad m => (a -> m b) -> URec Word a -> m (URec Word b) #

sequence :: Monad m => URec Word (m a) -> m (URec Word a) #

Generic1 (URec Word) 

Associated Types

type Rep1 (URec Word :: * -> *) :: * -> * #

Methods

from1 :: URec Word a -> Rep1 (URec Word) a #

to1 :: Rep1 (URec Word) a -> URec Word a #

Eq (URec Word p) 

Methods

(==) :: URec Word p -> URec Word p -> Bool #

(/=) :: URec Word p -> URec Word p -> Bool #

Ord (URec Word p) 

Methods

compare :: URec Word p -> URec Word p -> Ordering #

(<) :: URec Word p -> URec Word p -> Bool #

(<=) :: URec Word p -> URec Word p -> Bool #

(>) :: URec Word p -> URec Word p -> Bool #

(>=) :: URec Word p -> URec Word p -> Bool #

max :: URec Word p -> URec Word p -> URec Word p #

min :: URec Word p -> URec Word p -> URec Word p #

Show (URec Word p) 

Methods

showsPrec :: Int -> URec Word p -> ShowS #

show :: URec Word p -> String #

showList :: [URec Word p] -> ShowS #

Generic (URec Word p) 

Associated Types

type Rep (URec Word p) :: * -> * #

Methods

from :: URec Word p -> Rep (URec Word p) x #

to :: Rep (URec Word p) x -> URec Word p #

data URec Word

Used for marking occurrences of Word#

data URec Word = UWord {}
data Vector Word 
type Plain Word Source # 
type Plain Word = Word
data MVector s Word 
type Rep1 (URec Word) 
type Rep1 (URec Word) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UWord" PrefixI True) (S1 (MetaSel (Just Symbol "uWord#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) UWord))
type Rep (URec Word p) 
type Rep (URec Word p) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UWord" PrefixI True) (S1 (MetaSel (Just Symbol "uWord#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) UWord))

data Word8 :: * #

8-bit unsigned integer type

Instances

Bounded Word8 
Enum Word8 
Eq Word8 

Methods

(==) :: Word8 -> Word8 -> Bool #

(/=) :: Word8 -> Word8 -> Bool #

Integral Word8 
Data Word8 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word8 -> c Word8 #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word8 #

toConstr :: Word8 -> Constr #

dataTypeOf :: Word8 -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Word8) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word8) #

gmapT :: (forall b. Data b => b -> b) -> Word8 -> Word8 #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word8 -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word8 -> r #

gmapQ :: (forall d. Data d => d -> u) -> Word8 -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Word8 -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word8 -> m Word8 #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word8 -> m Word8 #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word8 -> m Word8 #

Num Word8 
Ord Word8 

Methods

compare :: Word8 -> Word8 -> Ordering #

(<) :: Word8 -> Word8 -> Bool #

(<=) :: Word8 -> Word8 -> Bool #

(>) :: Word8 -> Word8 -> Bool #

(>=) :: Word8 -> Word8 -> Bool #

max :: Word8 -> Word8 -> Word8 #

min :: Word8 -> Word8 -> Word8 #

Read Word8 
Real Word8 

Methods

toRational :: Word8 -> Rational #

Show Word8 

Methods

showsPrec :: Int -> Word8 -> ShowS #

show :: Word8 -> String #

showList :: [Word8] -> ShowS #

Ix Word8 
Lift Word8 

Methods

lift :: Word8 -> Q Exp #

PrintfArg Word8 
Storable Word8 

Methods

sizeOf :: Word8 -> Int #

alignment :: Word8 -> Int #

peekElemOff :: Ptr Word8 -> Int -> IO Word8 #

pokeElemOff :: Ptr Word8 -> Int -> Word8 -> IO () #

peekByteOff :: Ptr b -> Int -> IO Word8 #

pokeByteOff :: Ptr b -> Int -> Word8 -> IO () #

peek :: Ptr Word8 -> IO Word8 #

poke :: Ptr Word8 -> Word8 -> IO () #

Bits Word8 
FiniteBits Word8 
NFData Word8 

Methods

rnf :: Word8 -> () #

Hashable Word8 

Methods

hashWithSalt :: Int -> Word8 -> Int #

hash :: Word8 -> Int #

Prim Word8 
Unbox Word8 
IsScalar Word8 Source # 

Methods

scalarType :: ScalarType Word8

IsBounded Word8 Source # 

Methods

boundedType :: BoundedType Word8

IsNum Word8 Source # 

Methods

numType :: NumType Word8

IsIntegral Word8 Source # 

Methods

integralType :: IntegralType Word8

Elt Word8 Source # 

Methods

eltType :: Word8 -> TupleType (EltRepr Word8)

fromElt :: Word8 -> EltRepr Word8

toElt :: EltRepr Word8 -> Word8

Eq Word8 Source # 
Ord Word8 Source # 
FiniteBits Word8 Source # 
Bits Word8 Source # 
Vector Vector Word8 
MVector MVector Word8 
FromIntegral Int Word8 Source # 
FromIntegral Int8 Word8 Source # 
FromIntegral Int16 Word8 Source # 
FromIntegral Int32 Word8 Source # 
FromIntegral Int64 Word8 Source # 
FromIntegral Word Word8 Source # 
FromIntegral Word8 Double Source # 
FromIntegral Word8 Float Source # 
FromIntegral Word8 Int Source # 
FromIntegral Word8 Int8 Source # 
FromIntegral Word8 Int16 Source # 
FromIntegral Word8 Int32 Source # 
FromIntegral Word8 Int64 Source # 
FromIntegral Word8 Word Source # 
FromIntegral Word8 Word8 Source # 
FromIntegral Word8 Word16 Source # 
FromIntegral Word8 Word32 Source # 
FromIntegral Word8 Word64 Source # 
FromIntegral Word8 CShort Source # 
FromIntegral Word8 CUShort Source # 
FromIntegral Word8 CInt Source # 
FromIntegral Word8 CUInt Source # 
FromIntegral Word8 CLong Source # 
FromIntegral Word8 CULong Source # 
FromIntegral Word8 CLLong Source # 
FromIntegral Word8 CULLong Source # 
FromIntegral Word8 CFloat Source # 
FromIntegral Word8 CDouble Source # 
FromIntegral Word16 Word8 Source # 
FromIntegral Word32 Word8 Source # 
FromIntegral Word64 Word8 Source # 
FromIntegral CShort Word8 Source # 
FromIntegral CUShort Word8 Source # 
FromIntegral CInt Word8 Source # 
FromIntegral CUInt Word8 Source # 
FromIntegral CLong Word8 Source # 
FromIntegral CULong Word8 Source # 
FromIntegral CLLong Word8 Source # 
FromIntegral CULLong Word8 Source # 
ToFloating Word8 Double Source # 
ToFloating Word8 Float Source # 
ToFloating Word8 CFloat Source # 
ToFloating Word8 CDouble Source # 
Lift Exp Word8 Source # 

Associated Types

type Plain Word8 :: * Source #

Methods

lift :: Word8 -> Exp (Plain Word8) Source #

data Vector Word8 
type Plain Word8 Source # 
data MVector s Word8 

data Word16 :: * #

16-bit unsigned integer type

Instances

Bounded Word16 
Enum Word16 
Eq Word16 

Methods

(==) :: Word16 -> Word16 -> Bool #

(/=) :: Word16 -> Word16 -> Bool #

Integral Word16 
Data Word16 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word16 -> c Word16 #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word16 #

toConstr :: Word16 -> Constr #

dataTypeOf :: Word16 -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Word16) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word16) #

gmapT :: (forall b. Data b => b -> b) -> Word16 -> Word16 #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word16 -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word16 -> r #

gmapQ :: (forall d. Data d => d -> u) -> Word16 -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Word16 -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word16 -> m Word16 #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word16 -> m Word16 #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word16 -> m Word16 #

Num Word16 
Ord Word16 
Read Word16 
Real Word16 
Show Word16 
Ix Word16 
Lift Word16 

Methods

lift :: Word16 -> Q Exp #

PrintfArg Word16 
Storable Word16 
Bits Word16 
FiniteBits Word16 
NFData Word16 

Methods

rnf :: Word16 -> () #

Hashable Word16 

Methods

hashWithSalt :: Int -> Word16 -> Int #

hash :: Word16 -> Int #

Prim Word16 
Unbox Word16 
IsScalar Word16 Source # 

Methods

scalarType :: ScalarType Word16

IsBounded Word16 Source # 

Methods

boundedType :: BoundedType Word16

IsNum Word16 Source # 

Methods

numType :: NumType Word16

IsIntegral Word16 Source # 

Methods

integralType :: IntegralType Word16

Elt Word16 Source # 

Methods

eltType :: Word16 -> TupleType (EltRepr Word16)

fromElt :: Word16 -> EltRepr Word16

toElt :: EltRepr Word16 -> Word16

Eq Word16 Source # 
Ord Word16 Source # 
FiniteBits Word16 Source # 
Bits Word16 Source # 
Vector Vector Word16 
MVector MVector Word16 
FromIntegral Int Word16 Source # 
FromIntegral Int8 Word16 Source # 
FromIntegral Int16 Word16 Source # 
FromIntegral Int32 Word16 Source # 
FromIntegral Int64 Word16 Source # 
FromIntegral Word Word16 Source # 
FromIntegral Word8 Word16 Source # 
FromIntegral Word16 Double Source # 
FromIntegral Word16 Float Source # 
FromIntegral Word16 Int Source # 
FromIntegral Word16 Int8 Source # 
FromIntegral Word16 Int16 Source # 
FromIntegral Word16 Int32 Source # 
FromIntegral Word16 Int64 Source # 
FromIntegral Word16 Word Source # 
FromIntegral Word16 Word8 Source # 
FromIntegral Word16 Word16 Source # 
FromIntegral Word16 Word32 Source # 
FromIntegral Word16 Word64 Source # 
FromIntegral Word16 CShort Source # 
FromIntegral Word16 CUShort Source # 
FromIntegral Word16 CInt Source # 
FromIntegral Word16 CUInt Source # 
FromIntegral Word16 CLong Source # 
FromIntegral Word16 CULong Source # 
FromIntegral Word16 CLLong Source # 
FromIntegral Word16 CULLong Source # 
FromIntegral Word16 CFloat Source # 
FromIntegral Word16 CDouble Source # 
FromIntegral Word32 Word16 Source # 
FromIntegral Word64 Word16 Source # 
FromIntegral CShort Word16 Source # 
FromIntegral CUShort Word16 Source # 
FromIntegral CInt Word16 Source # 
FromIntegral CUInt Word16 Source # 
FromIntegral CLong Word16 Source # 
FromIntegral CULong Word16 Source # 
FromIntegral CLLong Word16 Source # 
FromIntegral CULLong Word16 Source # 
ToFloating Word16 Double Source # 
ToFloating Word16 Float Source # 
ToFloating Word16 CFloat Source # 
ToFloating Word16 CDouble Source # 
Lift Exp Word16 Source # 

Associated Types

type Plain Word16 :: * Source #

Methods

lift :: Word16 -> Exp (Plain Word16) Source #

data Vector Word16 
type Plain Word16 Source # 
data MVector s Word16 

data Word32 :: * #

32-bit unsigned integer type

Instances

Bounded Word32 
Enum Word32 
Eq Word32 

Methods

(==) :: Word32 -> Word32 -> Bool #

(/=) :: Word32 -> Word32 -> Bool #

Integral Word32 
Data Word32 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word32 -> c Word32 #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word32 #

toConstr :: Word32 -> Constr #

dataTypeOf :: Word32 -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Word32) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word32) #

gmapT :: (forall b. Data b => b -> b) -> Word32 -> Word32 #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word32 -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word32 -> r #

gmapQ :: (forall d. Data d => d -> u) -> Word32 -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Word32 -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word32 -> m Word32 #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word32 -> m Word32 #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word32 -> m Word32 #

Num Word32 
Ord Word32 
Read Word32 
Real Word32 
Show Word32 
Ix Word32 
Lift Word32 

Methods

lift :: Word32 -> Q Exp #

PrintfArg Word32 
Storable Word32 
Bits Word32 
FiniteBits Word32 
NFData Word32 

Methods

rnf :: Word32 -> () #

Hashable Word32 

Methods

hashWithSalt :: Int -> Word32 -> Int #

hash :: Word32 -> Int #

Prim Word32 
Unbox Word32 
IsScalar Word32 Source # 

Methods

scalarType :: ScalarType Word32

IsBounded Word32 Source # 

Methods

boundedType :: BoundedType Word32

IsNum Word32 Source # 

Methods

numType :: NumType Word32

IsIntegral Word32 Source # 

Methods

integralType :: IntegralType Word32

Elt Word32 Source # 

Methods

eltType :: Word32 -> TupleType (EltRepr Word32)

fromElt :: Word32 -> EltRepr Word32

toElt :: EltRepr Word32 -> Word32

Eq Word32 Source # 
Ord Word32 Source # 
FiniteBits Word32 Source # 
Bits Word32 Source # 
Vector Vector Word32 
MVector MVector Word32 
FromIntegral Int Word32 Source # 
FromIntegral Int8 Word32 Source # 
FromIntegral Int16 Word32 Source # 
FromIntegral Int32 Word32 Source # 
FromIntegral Int64 Word32 Source # 
FromIntegral Word Word32 Source # 
FromIntegral Word8 Word32 Source # 
FromIntegral Word16 Word32 Source # 
FromIntegral Word32 Double Source # 
FromIntegral Word32 Float Source # 
FromIntegral Word32 Int Source # 
FromIntegral Word32 Int8 Source # 
FromIntegral Word32 Int16 Source # 
FromIntegral Word32 Int32 Source # 
FromIntegral Word32 Int64 Source # 
FromIntegral Word32 Word Source # 
FromIntegral Word32 Word8 Source # 
FromIntegral Word32 Word16 Source # 
FromIntegral Word32 Word32 Source # 
FromIntegral Word32 Word64 Source # 
FromIntegral Word32 CShort Source # 
FromIntegral Word32 CUShort Source # 
FromIntegral Word32 CInt Source # 
FromIntegral Word32 CUInt Source # 
FromIntegral Word32 CLong Source # 
FromIntegral Word32 CULong Source # 
FromIntegral Word32 CLLong Source # 
FromIntegral Word32 CULLong Source # 
FromIntegral Word32 CFloat Source # 
FromIntegral Word32 CDouble Source # 
FromIntegral Word64 Word32 Source # 
FromIntegral CShort Word32 Source # 
FromIntegral CUShort Word32 Source # 
FromIntegral CInt Word32 Source # 
FromIntegral CUInt Word32 Source # 
FromIntegral CLong Word32 Source # 
FromIntegral CULong Word32 Source # 
FromIntegral CLLong Word32 Source # 
FromIntegral CULLong Word32 Source # 
ToFloating Word32 Double Source # 
ToFloating Word32 Float Source # 
ToFloating Word32 CFloat Source # 
ToFloating Word32 CDouble Source # 
Lift Exp Word32 Source # 

Associated Types

type Plain Word32 :: * Source #

Methods

lift :: Word32 -> Exp (Plain Word32) Source #

data Vector Word32 
type Plain Word32 Source # 
data MVector s Word32 

data Word64 :: * #

64-bit unsigned integer type

Instances

Bounded Word64 
Enum Word64 
Eq Word64 

Methods

(==) :: Word64 -> Word64 -> Bool #

(/=) :: Word64 -> Word64 -> Bool #

Integral Word64 
Data Word64 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word64 -> c Word64 #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word64 #

toConstr :: Word64 -> Constr #

dataTypeOf :: Word64 -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Word64) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word64) #

gmapT :: (forall b. Data b => b -> b) -> Word64 -> Word64 #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word64 -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word64 -> r #

gmapQ :: (forall d. Data d => d -> u) -> Word64 -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Word64 -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word64 -> m Word64 #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word64 -> m Word64 #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word64 -> m Word64 #

Num Word64 
Ord Word64 
Read Word64 
Real Word64 
Show Word64 
Ix Word64 
Lift Word64 

Methods

lift :: Word64 -> Q Exp #

PrintfArg Word64 
Storable Word64 
Bits Word64 
FiniteBits Word64 
NFData Word64 

Methods

rnf :: Word64 -> () #

Hashable Word64 

Methods

hashWithSalt :: Int -> Word64 -> Int #

hash :: Word64 -> Int #

Prim Word64 
Unbox Word64 
IsScalar Word64 Source # 

Methods

scalarType :: ScalarType Word64

IsBounded Word64 Source # 

Methods

boundedType :: BoundedType Word64

IsNum Word64 Source # 

Methods

numType :: NumType Word64

IsIntegral Word64 Source # 

Methods

integralType :: IntegralType Word64

Elt Word64 Source # 

Methods

eltType :: Word64 -> TupleType (EltRepr Word64)

fromElt :: Word64 -> EltRepr Word64

toElt :: EltRepr Word64 -> Word64

Eq Word64 Source # 
Ord Word64 Source # 
FiniteBits Word64 Source # 
Bits Word64 Source # 
Vector Vector Word64 
MVector MVector Word64 
FromIntegral Int Word64 Source # 
FromIntegral Int8 Word64 Source # 
FromIntegral Int16 Word64 Source # 
FromIntegral Int32 Word64 Source # 
FromIntegral Int64 Word64 Source # 
FromIntegral Word Word64 Source # 
FromIntegral Word8 Word64 Source # 
FromIntegral Word16 Word64 Source # 
FromIntegral Word32 Word64 Source # 
FromIntegral Word64 Double Source # 
FromIntegral Word64 Float Source # 
FromIntegral Word64 Int Source # 
FromIntegral Word64 Int8 Source # 
FromIntegral Word64 Int16 Source # 
FromIntegral Word64 Int32 Source # 
FromIntegral Word64 Int64 Source # 
FromIntegral Word64 Word Source # 
FromIntegral Word64 Word8 Source # 
FromIntegral Word64 Word16 Source # 
FromIntegral Word64 Word32 Source # 
FromIntegral Word64 Word64 Source # 
FromIntegral Word64 CShort Source # 
FromIntegral Word64 CUShort Source # 
FromIntegral Word64 CInt Source # 
FromIntegral Word64 CUInt Source # 
FromIntegral Word64 CLong Source # 
FromIntegral Word64 CULong Source # 
FromIntegral Word64 CLLong Source # 
FromIntegral Word64 CULLong Source # 
FromIntegral Word64 CFloat Source # 
FromIntegral Word64 CDouble Source # 
FromIntegral CShort Word64 Source # 
FromIntegral CUShort Word64 Source # 
FromIntegral CInt Word64 Source # 
FromIntegral CUInt Word64 Source # 
FromIntegral CLong Word64 Source # 
FromIntegral CULong Word64 Source # 
FromIntegral CLLong Word64 Source # 
FromIntegral CULLong Word64 Source # 
ToFloating Word64 Double Source # 
ToFloating Word64 Float Source # 
ToFloating Word64 CFloat Source # 
ToFloating Word64 CDouble Source # 
Lift Exp Word64 Source # 

Associated Types

type Plain Word64 :: * Source #

Methods

lift :: Word64 -> Exp (Plain Word64) Source #

data Vector Word64 
type Plain Word64 Source # 
data MVector s Word64 

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.

Instances

Eq Float 

Methods

(==) :: Float -> Float -> Bool #

(/=) :: Float -> Float -> Bool #

Floating Float 
Data Float 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Float -> c Float #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Float #

toConstr :: Float -> Constr #

dataTypeOf :: Float -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Float) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Float) #

gmapT :: (forall b. Data b => b -> b) -> Float -> Float #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Float -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Float -> r #

gmapQ :: (forall d. Data d => d -> u) -> Float -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Float -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Float -> m Float #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Float -> m Float #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Float -> m Float #

Ord Float 

Methods

compare :: Float -> Float -> Ordering #

(<) :: Float -> Float -> Bool #

(<=) :: Float -> Float -> Bool #

(>) :: Float -> Float -> Bool #

(>=) :: Float -> Float -> Bool #

max :: Float -> Float -> Float #

min :: Float -> Float -> Float #

RealFloat Float 
Lift Float 

Methods

lift :: Float -> Q Exp #

Pretty Float 

Methods

pretty :: Float -> Doc #

prettyList :: [Float] -> Doc #

PrintfArg Float 
Storable Float 

Methods

sizeOf :: Float -> Int #

alignment :: Float -> Int #

peekElemOff :: Ptr Float -> Int -> IO Float #

pokeElemOff :: Ptr Float -> Int -> Float -> IO () #

peekByteOff :: Ptr b -> Int -> IO Float #

pokeByteOff :: Ptr b -> Int -> Float -> IO () #

peek :: Ptr Float -> IO Float #

poke :: Ptr Float -> Float -> IO () #

NFData Float 

Methods

rnf :: Float -> () #

Hashable Float 

Methods

hashWithSalt :: Int -> Float -> Int #

hash :: Float -> Int #

Prim Float 
Unbox Float 
IsScalar Float Source # 

Methods

scalarType :: ScalarType Float

IsNum Float Source # 

Methods

numType :: NumType Float

IsFloating Float Source # 

Methods

floatingType :: FloatingType Float

Elt Float Source # 

Methods

eltType :: Float -> TupleType (EltRepr Float)

fromElt :: Float -> EltRepr Float

toElt :: EltRepr Float -> Float

Eq Float Source # 
Ord Float Source # 
RealFrac Float Source # 
RealFloat Float Source # 
Vector Vector Float 
MVector MVector Float 
FromIntegral Int Float Source # 
FromIntegral Int8 Float Source # 
FromIntegral Int16 Float Source # 
FromIntegral Int32 Float Source # 
FromIntegral Int64 Float Source # 
FromIntegral Word Float Source # 
FromIntegral Word8 Float Source # 
FromIntegral Word16 Float Source # 
FromIntegral Word32 Float Source # 
FromIntegral Word64 Float Source # 
FromIntegral CShort Float Source # 
FromIntegral CUShort Float Source # 
FromIntegral CInt Float Source # 
FromIntegral CUInt Float Source # 
FromIntegral CLong Float Source # 
FromIntegral CULong Float Source # 
FromIntegral CLLong Float Source # 
FromIntegral CULLong Float Source # 
ToFloating Double Float Source # 
ToFloating Float Double Source # 
ToFloating Float Float Source # 
ToFloating Float CFloat Source # 
ToFloating Float CDouble Source # 
ToFloating Int Float Source # 
ToFloating Int8 Float Source # 
ToFloating Int16 Float Source # 
ToFloating Int32 Float Source # 
ToFloating Int64 Float Source # 
ToFloating Word Float Source # 
ToFloating Word8 Float Source # 
ToFloating Word16 Float Source # 
ToFloating Word32 Float Source # 
ToFloating Word64 Float Source # 
ToFloating CShort Float Source # 
ToFloating CUShort Float Source # 
ToFloating CInt Float Source # 
ToFloating CUInt Float Source # 
ToFloating CLong Float Source # 
ToFloating CULong Float Source # 
ToFloating CLLong Float Source # 
ToFloating CULLong Float Source # 
ToFloating CFloat Float Source # 
ToFloating CDouble Float Source # 
Lift Exp Float Source # 

Associated Types

type Plain Float :: * Source #

Methods

lift :: Float -> Exp (Plain Float) Source #

Functor (URec Float) 

Methods

fmap :: (a -> b) -> URec Float a -> URec Float b #

(<$) :: a -> URec Float b -> URec Float a #

Foldable (URec Float) 

Methods

fold :: Monoid m => URec Float m -> m #

foldMap :: Monoid m => (a -> m) -> URec Float a -> m #

foldr :: (a -> b -> b) -> b -> URec Float a -> b #

foldr' :: (a -> b -> b) -> b -> URec Float a -> b #

foldl :: (b -> a -> b) -> b -> URec Float a -> b #

foldl' :: (b -> a -> b) -> b -> URec Float a -> b #

foldr1 :: (a -> a -> a) -> URec Float a -> a #

foldl1 :: (a -> a -> a) -> URec Float a -> a #

toList :: URec Float a -> [a] #

null :: URec Float a -> Bool #

length :: URec Float a -> Int #

elem :: Eq a => a -> URec Float a -> Bool #

maximum :: Ord a => URec Float a -> a #

minimum :: Ord a => URec Float a -> a #

sum :: Num a => URec Float a -> a #

product :: Num a => URec Float a -> a #

Traversable (URec Float) 

Methods

traverse :: Applicative f => (a -> f b) -> URec Float a -> f (URec Float b) #

sequenceA :: Applicative f => URec Float (f a) -> f (URec Float a) #

mapM :: Monad m => (a -> m b) -> URec Float a -> m (URec Float b) #

sequence :: Monad m => URec Float (m a) -> m (URec Float a) #

Generic1 (URec Float) 

Associated Types

type Rep1 (URec Float :: * -> *) :: * -> * #

Methods

from1 :: URec Float a -> Rep1 (URec Float) a #

to1 :: Rep1 (URec Float) a -> URec Float a #

Eq (URec Float p) 

Methods

(==) :: URec Float p -> URec Float p -> Bool #

(/=) :: URec Float p -> URec Float p -> Bool #

Ord (URec Float p) 

Methods

compare :: URec Float p -> URec Float p -> Ordering #

(<) :: URec Float p -> URec Float p -> Bool #

(<=) :: URec Float p -> URec Float p -> Bool #

(>) :: URec Float p -> URec Float p -> Bool #

(>=) :: URec Float p -> URec Float p -> Bool #

max :: URec Float p -> URec Float p -> URec Float p #

min :: URec Float p -> URec Float p -> URec Float p #

Show (URec Float p) 

Methods

showsPrec :: Int -> URec Float p -> ShowS #

show :: URec Float p -> String #

showList :: [URec Float p] -> ShowS #

Generic (URec Float p) 

Associated Types

type Rep (URec Float p) :: * -> * #

Methods

from :: URec Float p -> Rep (URec Float p) x #

to :: Rep (URec Float p) x -> URec Float p #

data URec Float

Used for marking occurrences of Float#

data Vector Float 
type Plain Float Source # 
data MVector s Float 
type Rep1 (URec Float) 
type Rep1 (URec Float) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UFloat" PrefixI True) (S1 (MetaSel (Just Symbol "uFloat#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) UFloat))
type Rep (URec Float p) 
type Rep (URec Float p) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UFloat" PrefixI True) (S1 (MetaSel (Just Symbol "uFloat#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) UFloat))

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.

Instances

Eq Double 

Methods

(==) :: Double -> Double -> Bool #

(/=) :: Double -> Double -> Bool #

Floating Double 
Data Double 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Double -> c Double #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Double #

toConstr :: Double -> Constr #

dataTypeOf :: Double -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Double) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Double) #

gmapT :: (forall b. Data b => b -> b) -> Double -> Double #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Double -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Double -> r #

gmapQ :: (forall d. Data d => d -> u) -> Double -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Double -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Double -> m Double #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Double -> m Double #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Double -> m Double #

Ord Double 
RealFloat Double 
Lift Double 

Methods

lift :: Double -> Q Exp #

Pretty Double 

Methods

pretty :: Double -> Doc #

prettyList :: [Double] -> Doc #

PrintfArg Double 
Storable Double 
NFData Double 

Methods

rnf :: Double -> () #

Hashable Double 

Methods

hashWithSalt :: Int -> Double -> Int #

hash :: Double -> Int #

Prim Double 
Unbox Double 
IsScalar Double Source # 

Methods

scalarType :: ScalarType Double

IsNum Double Source # 

Methods

numType :: NumType Double

IsFloating Double Source # 

Methods

floatingType :: FloatingType Double

Elt Double Source # 

Methods

eltType :: Double -> TupleType (EltRepr Double)

fromElt :: Double -> EltRepr Double

toElt :: EltRepr Double -> Double

Eq Double Source # 
Ord Double Source # 
RealFrac Double Source # 
RealFloat Double Source # 
Vector Vector Double 
MVector MVector Double 
FromIntegral Int Double Source # 
FromIntegral Int8 Double Source # 
FromIntegral Int16 Double Source # 
FromIntegral Int32 Double Source # 
FromIntegral Int64 Double Source # 
FromIntegral Word Double Source # 
FromIntegral Word8 Double Source # 
FromIntegral Word16 Double Source # 
FromIntegral Word32 Double Source # 
FromIntegral Word64 Double Source # 
FromIntegral CShort Double Source # 
FromIntegral CUShort Double Source # 
FromIntegral CInt Double Source # 
FromIntegral CUInt Double Source # 
FromIntegral CLong Double Source # 
FromIntegral CULong Double Source # 
FromIntegral CLLong Double Source # 
FromIntegral CULLong Double Source # 
ToFloating Double Double Source # 
ToFloating Double Float Source # 
ToFloating Double CFloat Source # 
ToFloating Double CDouble Source # 
ToFloating Float Double Source # 
ToFloating Int Double Source # 
ToFloating Int8 Double Source # 
ToFloating Int16 Double Source # 
ToFloating Int32 Double Source # 
ToFloating Int64 Double Source # 
ToFloating Word Double Source # 
ToFloating Word8 Double Source # 
ToFloating Word16 Double Source # 
ToFloating Word32 Double Source # 
ToFloating Word64 Double Source # 
ToFloating CShort Double Source # 
ToFloating CUShort Double Source # 
ToFloating CInt Double Source # 
ToFloating CUInt Double Source # 
ToFloating CLong Double Source # 
ToFloating CULong Double Source # 
ToFloating CLLong Double Source # 
ToFloating CULLong Double Source # 
ToFloating CFloat Double Source # 
ToFloating CDouble Double Source # 
Lift Exp Double Source # 

Associated Types

type Plain Double :: * Source #

Methods

lift :: Double -> Exp (Plain Double) Source #

Functor (URec Double) 

Methods

fmap :: (a -> b) -> URec Double a -> URec Double b #

(<$) :: a -> URec Double b -> URec Double a #

Foldable (URec Double) 

Methods

fold :: Monoid m => URec Double m -> m #

foldMap :: Monoid m => (a -> m) -> URec Double a -> m #

foldr :: (a -> b -> b) -> b -> URec Double a -> b #

foldr' :: (a -> b -> b) -> b -> URec Double a -> b #

foldl :: (b -> a -> b) -> b -> URec Double a -> b #

foldl' :: (b -> a -> b) -> b -> URec Double a -> b #

foldr1 :: (a -> a -> a) -> URec Double a -> a #

foldl1 :: (a -> a -> a) -> URec Double a -> a #

toList :: URec Double a -> [a] #

null :: URec Double a -> Bool #

length :: URec Double a -> Int #

elem :: Eq a => a -> URec Double a -> Bool #

maximum :: Ord a => URec Double a -> a #

minimum :: Ord a => URec Double a -> a #

sum :: Num a => URec Double a -> a #

product :: Num a => URec Double a -> a #

Traversable (URec Double) 

Methods

traverse :: Applicative f => (a -> f b) -> URec Double a -> f (URec Double b) #

sequenceA :: Applicative f => URec Double (f a) -> f (URec Double a) #

mapM :: Monad m => (a -> m b) -> URec Double a -> m (URec Double b) #

sequence :: Monad m => URec Double (m a) -> m (URec Double a) #

Generic1 (URec Double) 

Associated Types

type Rep1 (URec Double :: * -> *) :: * -> * #

Methods

from1 :: URec Double a -> Rep1 (URec Double) a #

to1 :: Rep1 (URec Double) a -> URec Double a #

Eq (URec Double p) 

Methods

(==) :: URec Double p -> URec Double p -> Bool #

(/=) :: URec Double p -> URec Double p -> Bool #

Ord (URec Double p) 

Methods

compare :: URec Double p -> URec Double p -> Ordering #

(<) :: URec Double p -> URec Double p -> Bool #

(<=) :: URec Double p -> URec Double p -> Bool #

(>) :: URec Double p -> URec Double p -> Bool #

(>=) :: URec Double p -> URec Double p -> Bool #

max :: URec Double p -> URec Double p -> URec Double p #

min :: URec Double p -> URec Double p -> URec Double p #

Show (URec Double p) 

Methods

showsPrec :: Int -> URec Double p -> ShowS #

show :: URec Double p -> String #

showList :: [URec Double p] -> ShowS #

Generic (URec Double p) 

Associated Types

type Rep (URec Double p) :: * -> * #

Methods

from :: URec Double p -> Rep (URec Double p) x #

to :: Rep (URec Double p) x -> URec Double p #

data URec Double

Used for marking occurrences of Double#

data Vector Double 
type Plain Double Source # 
data MVector s Double 
type Rep1 (URec Double) 
type Rep1 (URec Double) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UDouble" PrefixI True) (S1 (MetaSel (Just Symbol "uDouble#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) UDouble))
type Rep (URec Double p) 
type Rep (URec Double p) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UDouble" PrefixI True) (S1 (MetaSel (Just Symbol "uDouble#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) UDouble))

data Bool :: * #

Constructors

False 
True 

Instances

Bounded Bool 
Enum Bool 

Methods

succ :: Bool -> Bool #

pred :: Bool -> Bool #

toEnum :: Int -> Bool #

fromEnum :: Bool -> Int #

enumFrom :: Bool -> [Bool] #

enumFromThen :: Bool -> Bool -> [Bool] #

enumFromTo :: Bool -> Bool -> [Bool] #

enumFromThenTo :: Bool -> Bool -> Bool -> [Bool] #

Eq Bool 

Methods

(==) :: Bool -> Bool -> Bool #

(/=) :: Bool -> Bool -> Bool #

Data Bool 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Bool -> c Bool #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Bool #

toConstr :: Bool -> Constr #

dataTypeOf :: Bool -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Bool) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Bool) #

gmapT :: (forall b. Data b => b -> b) -> Bool -> Bool #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Bool -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Bool -> r #

gmapQ :: (forall d. Data d => d -> u) -> Bool -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Bool -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Bool -> m Bool #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Bool -> m Bool #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Bool -> m Bool #

Ord Bool 

Methods

compare :: Bool -> Bool -> Ordering #

(<) :: Bool -> Bool -> Bool #

(<=) :: Bool -> Bool -> Bool #

(>) :: Bool -> Bool -> Bool #

(>=) :: Bool -> Bool -> Bool #

max :: Bool -> Bool -> Bool #

min :: Bool -> Bool -> Bool #

Show Bool 

Methods

showsPrec :: Int -> Bool -> ShowS #

show :: Bool -> String #

showList :: [Bool] -> ShowS #

Ix Bool 

Methods

range :: (Bool, Bool) -> [Bool] #

index :: (Bool, Bool) -> Bool -> Int #

unsafeIndex :: (Bool, Bool) -> Bool -> Int

inRange :: (Bool, Bool) -> Bool -> Bool #

rangeSize :: (Bool, Bool) -> Int #

unsafeRangeSize :: (Bool, Bool) -> Int

Generic Bool 

Associated Types

type Rep Bool :: * -> * #

Methods

from :: Bool -> Rep Bool x #

to :: Rep Bool x -> Bool #

Lift Bool 

Methods

lift :: Bool -> Q Exp #

Pretty Bool 

Methods

pretty :: Bool -> Doc #

prettyList :: [Bool] -> Doc #

Storable Bool 

Methods

sizeOf :: Bool -> Int #

alignment :: Bool -> Int #

peekElemOff :: Ptr Bool -> Int -> IO Bool #

pokeElemOff :: Ptr Bool -> Int -> Bool -> IO () #

peekByteOff :: Ptr b -> Int -> IO Bool #

pokeByteOff :: Ptr b -> Int -> Bool -> IO () #

peek :: Ptr Bool -> IO Bool #

poke :: Ptr Bool -> Bool -> IO () #

Bits Bool 
FiniteBits Bool 
NFData Bool 

Methods

rnf :: Bool -> () #

Hashable Bool 

Methods

hashWithSalt :: Int -> Bool -> Int #

hash :: Bool -> Int #

Unbox Bool 
IsScalar Bool Source # 

Methods

scalarType :: ScalarType Bool

IsBounded Bool Source # 

Methods

boundedType :: BoundedType Bool

IsNonNum Bool Source # 

Methods

nonNumType :: NonNumType Bool

Elt Bool Source # 

Methods

eltType :: Bool -> TupleType (EltRepr Bool)

fromElt :: Bool -> EltRepr Bool

toElt :: EltRepr Bool -> Bool

Eq Bool Source # 
Ord Bool Source # 
FiniteBits Bool Source # 
Bits Bool Source # 
SingI Bool False 

Methods

sing :: Sing False a

SingI Bool True 

Methods

sing :: Sing True a

Vector Vector Bool 
MVector MVector Bool 
Lift Exp Bool Source # 

Associated Types

type Plain Bool :: * Source #

Methods

lift :: Bool -> Exp (Plain Bool) Source #

SingKind Bool (KProxy Bool) 

Associated Types

type DemoteRep (KProxy Bool) (kparam :: KProxy (KProxy Bool)) :: *

Methods

fromSing :: Sing (KProxy Bool) a -> DemoteRep (KProxy Bool) kparam

type Rep Bool 
type Rep Bool = D1 (MetaData "Bool" "GHC.Types" "ghc-prim" False) ((:+:) (C1 (MetaCons "False" PrefixI False) U1) (C1 (MetaCons "True" PrefixI False) U1))
data Sing Bool 
data Sing Bool where
data Vector Bool 
type Plain Bool Source # 
type Plain Bool = Bool
data MVector s Bool 
type (==) Bool a b 
type (==) Bool a b = EqBool a b
type DemoteRep Bool (KProxy Bool) 
type DemoteRep Bool (KProxy Bool) = 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).

Instances

Bounded Char 
Enum Char 

Methods

succ :: Char -> Char #

pred :: Char -> Char #

toEnum :: Int -> Char #

fromEnum :: Char -> Int #

enumFrom :: Char -> [Char] #

enumFromThen :: Char -> Char -> [Char] #

enumFromTo :: Char -> Char -> [Char] #

enumFromThenTo :: Char -> Char -> Char -> [Char] #

Eq Char 

Methods

(==) :: Char -> Char -> Bool #

(/=) :: Char -> Char -> Bool #

Data Char 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Char -> c Char #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Char #

toConstr :: Char -> Constr #

dataTypeOf :: Char -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Char) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Char) #

gmapT :: (forall b. Data b => b -> b) -> Char -> Char #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Char -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Char -> r #

gmapQ :: (forall d. Data d => d -> u) -> Char -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Char -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Char -> m Char #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Char -> m Char #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Char -> m Char #

Ord Char 

Methods

compare :: Char -> Char -> Ordering #

(<) :: Char -> Char -> Bool #

(<=) :: Char -> Char -> Bool #

(>) :: Char -> Char -> Bool #

(>=) :: Char -> Char -> Bool #

max :: Char -> Char -> Char #

min :: Char -> Char -> Char #

Show Char 

Methods

showsPrec :: Int -> Char -> ShowS #

show :: Char -> String #

showList :: [Char] -> ShowS #

Ix Char 

Methods

range :: (Char, Char) -> [Char] #

index :: (Char, Char) -> Char -> Int #

unsafeIndex :: (Char, Char) -> Char -> Int

inRange :: (Char, Char) -> Char -> Bool #

rangeSize :: (Char, Char) -> Int #

unsafeRangeSize :: (Char, Char) -> Int

Lift Char 

Methods

lift :: Char -> Q Exp #

Pretty Char 

Methods

pretty :: Char -> Doc #

prettyList :: [Char] -> Doc #

PrintfArg Char 
IsChar Char 

Methods

toChar :: Char -> Char #

fromChar :: Char -> Char #

Storable Char 

Methods

sizeOf :: Char -> Int #

alignment :: Char -> Int #

peekElemOff :: Ptr Char -> Int -> IO Char #

pokeElemOff :: Ptr Char -> Int -> Char -> IO () #

peekByteOff :: Ptr b -> Int -> IO Char #

pokeByteOff :: Ptr b -> Int -> Char -> IO () #

peek :: Ptr Char -> IO Char #

poke :: Ptr Char -> Char -> IO () #

NFData Char 

Methods

rnf :: Char -> () #

Hashable Char 

Methods

hashWithSalt :: Int -> Char -> Int #

hash :: Char -> Int #

Prim Char 
ErrorList Char 

Methods

listMsg :: String -> [Char] #

Unbox Char 
IsScalar Char Source # 

Methods

scalarType :: ScalarType Char

IsBounded Char Source # 

Methods

boundedType :: BoundedType Char

IsNonNum Char Source # 

Methods

nonNumType :: NonNumType Char

Elt Char Source # 

Methods

eltType :: Char -> TupleType (EltRepr Char)

fromElt :: Char -> EltRepr Char

toElt :: EltRepr Char -> Char

Eq Char Source # 
Ord Char Source # 
Vector Vector Char 
MVector MVector Char 
Lift Exp Char Source # 

Associated Types

type Plain Char :: * Source #

Methods

lift :: Char -> Exp (Plain Char) Source #

Functor (URec Char) 

Methods

fmap :: (a -> b) -> URec Char a -> URec Char b #

(<$) :: a -> URec Char b -> URec Char a #

IsString (Seq Char) 

Methods

fromString :: String -> Seq Char #

Foldable (URec Char) 

Methods

fold :: Monoid m => URec Char m -> m #

foldMap :: Monoid m => (a -> m) -> URec Char a -> m #

foldr :: (a -> b -> b) -> b -> URec Char a -> b #

foldr' :: (a -> b -> b) -> b -> URec Char a -> b #

foldl :: (b -> a -> b) -> b -> URec Char a -> b #

foldl' :: (b -> a -> b) -> b -> URec Char a -> b #

foldr1 :: (a -> a -> a) -> URec Char a -> a #

foldl1 :: (a -> a -> a) -> URec Char a -> a #

toList :: URec Char a -> [a] #

null :: URec Char a -> Bool #

length :: URec Char a -> Int #

elem :: Eq a => a -> URec Char a -> Bool #

maximum :: Ord a => URec Char a -> a #

minimum :: Ord a => URec Char a -> a #

sum :: Num a => URec Char a -> a #

product :: Num a => URec Char a -> a #

Traversable (URec Char) 

Methods

traverse :: Applicative f => (a -> f b) -> URec Char a -> f (URec Char b) #

sequenceA :: Applicative f => URec Char (f a) -> f (URec Char a) #

mapM :: Monad m => (a -> m b) -> URec Char a -> m (URec Char b) #

sequence :: Monad m => URec Char (m a) -> m (URec Char a) #

Generic1 (URec Char) 

Associated Types

type Rep1 (URec Char :: * -> *) :: * -> * #

Methods

from1 :: URec Char a -> Rep1 (URec Char) a #

to1 :: Rep1 (URec Char) a -> URec Char a #

Eq (URec Char p) 

Methods

(==) :: URec Char p -> URec Char p -> Bool #

(/=) :: URec Char p -> URec Char p -> Bool #

Ord (URec Char p) 

Methods

compare :: URec Char p -> URec Char p -> Ordering #

(<) :: URec Char p -> URec Char p -> Bool #

(<=) :: URec Char p -> URec Char p -> Bool #

(>) :: URec Char p -> URec Char p -> Bool #

(>=) :: URec Char p -> URec Char p -> Bool #

max :: URec Char p -> URec Char p -> URec Char p #

min :: URec Char p -> URec Char p -> URec Char p #

Show (URec Char p) 

Methods

showsPrec :: Int -> URec Char p -> ShowS #

show :: URec Char p -> String #

showList :: [URec Char p] -> ShowS #

Generic (URec Char p) 

Associated Types

type Rep (URec Char p) :: * -> * #

Methods

from :: URec Char p -> Rep (URec Char p) x #

to :: Rep (URec Char p) x -> URec Char p #

data URec Char

Used for marking occurrences of Char#

data URec Char = UChar {}
data Vector Char 
type Plain Char Source # 
type Plain Char = Char
data MVector s Char 
type Rep1 (URec Char) 
type Rep1 (URec Char) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UChar" PrefixI True) (S1 (MetaSel (Just Symbol "uChar#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) UChar))
type Rep (URec Char p) 
type Rep (URec Char p) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UChar" PrefixI True) (S1 (MetaSel (Just Symbol "uChar#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) UChar))

data CFloat :: * #

Haskell type representing the C float type.

Instances

Enum CFloat 
Eq CFloat 

Methods

(==) :: CFloat -> CFloat -> Bool #

(/=) :: CFloat -> CFloat -> Bool #

Floating CFloat 
Fractional CFloat 
Num CFloat 
Ord CFloat 
Read CFloat 
Real CFloat 
RealFloat CFloat 
RealFrac CFloat 

Methods

properFraction :: Integral b => CFloat -> (b, CFloat) #

truncate :: Integral b => CFloat -> b #

round :: Integral b => CFloat -> b #

ceiling :: Integral b => CFloat -> b #

floor :: Integral b => CFloat -> b #

Show CFloat 
Storable CFloat 
NFData CFloat

Since: 1.4.0.0

Methods

rnf :: CFloat -> () #

IsScalar CFloat Source # 

Methods

scalarType :: ScalarType CFloat

IsNum CFloat Source # 

Methods

numType :: NumType CFloat

IsFloating CFloat Source # 

Methods

floatingType :: FloatingType CFloat

Elt CFloat Source # 

Methods

eltType :: CFloat -> TupleType (EltRepr CFloat)

fromElt :: CFloat -> EltRepr CFloat

toElt :: EltRepr CFloat -> CFloat

Eq CFloat Source # 
Ord CFloat Source # 
RealFrac CFloat Source # 
RealFloat CFloat Source # 
FromIntegral Int CFloat Source # 
FromIntegral Int8 CFloat Source # 
FromIntegral Int16 CFloat Source # 
FromIntegral Int32 CFloat Source # 
FromIntegral Int64 CFloat Source # 
FromIntegral Word CFloat Source # 
FromIntegral Word8 CFloat Source # 
FromIntegral Word16 CFloat Source # 
FromIntegral Word32 CFloat Source # 
FromIntegral Word64 CFloat Source # 
FromIntegral CShort CFloat Source # 
FromIntegral CUShort CFloat Source # 
FromIntegral CInt CFloat Source # 
FromIntegral CUInt CFloat Source # 
FromIntegral CLong CFloat Source # 
FromIntegral CULong CFloat Source # 
FromIntegral CLLong CFloat Source # 
FromIntegral CULLong CFloat Source # 
ToFloating Double CFloat Source # 
ToFloating Float CFloat Source # 
ToFloating Int CFloat Source # 
ToFloating Int8 CFloat Source # 
ToFloating Int16 CFloat Source # 
ToFloating Int32 CFloat Source # 
ToFloating Int64 CFloat Source # 
ToFloating Word CFloat Source # 
ToFloating Word8 CFloat Source # 
ToFloating Word16 CFloat Source # 
ToFloating Word32 CFloat Source # 
ToFloating Word64 CFloat Source # 
ToFloating CShort CFloat Source # 
ToFloating CUShort CFloat Source # 
ToFloating CInt CFloat Source # 
ToFloating CUInt CFloat Source # 
ToFloating CLong CFloat Source # 
ToFloating CULong CFloat Source # 
ToFloating CLLong CFloat Source # 
ToFloating CULLong CFloat Source # 
ToFloating CFloat Double Source # 
ToFloating CFloat Float Source # 
ToFloating CFloat CFloat Source # 
ToFloating CFloat CDouble Source # 
ToFloating CDouble CFloat Source # 
Lift Exp CFloat Source # 

Associated Types

type Plain CFloat :: * Source #

Methods

lift :: CFloat -> Exp (Plain CFloat) Source #

type Plain CFloat Source # 

data CDouble :: * #

Haskell type representing the C double type.

Instances

Enum CDouble 
Eq CDouble 

Methods

(==) :: CDouble -> CDouble -> Bool #

(/=) :: CDouble -> CDouble -> Bool #

Floating CDouble 
Fractional CDouble 
Num CDouble 
Ord CDouble 
Read CDouble 
Real CDouble 
RealFloat CDouble 
RealFrac CDouble 

Methods

properFraction :: Integral b => CDouble -> (b, CDouble) #

truncate :: Integral b => CDouble -> b #

round :: Integral b => CDouble -> b #

ceiling :: Integral b => CDouble -> b #

floor :: Integral b => CDouble -> b #

Show CDouble 
Storable CDouble 
NFData CDouble

Since: 1.4.0.0

Methods

rnf :: CDouble -> () #

IsScalar CDouble Source # 

Methods

scalarType :: ScalarType CDouble

IsNum CDouble Source # 

Methods

numType :: NumType CDouble

IsFloating CDouble Source # 

Methods

floatingType :: FloatingType CDouble

Elt CDouble Source # 

Methods

eltType :: CDouble -> TupleType (EltRepr CDouble)

fromElt :: CDouble -> EltRepr CDouble

toElt :: EltRepr CDouble -> CDouble

Eq CDouble Source # 
Ord CDouble Source # 
RealFrac CDouble Source # 
RealFloat CDouble Source # 
FromIntegral Int CDouble Source # 
FromIntegral Int8 CDouble Source # 
FromIntegral Int16 CDouble Source # 
FromIntegral Int32 CDouble Source # 
FromIntegral Int64 CDouble Source # 
FromIntegral Word CDouble Source # 
FromIntegral Word8 CDouble Source # 
FromIntegral Word16 CDouble Source # 
FromIntegral Word32 CDouble Source # 
FromIntegral Word64 CDouble Source # 
FromIntegral CShort CDouble Source # 
FromIntegral CUShort CDouble Source # 
FromIntegral CInt CDouble Source # 
FromIntegral CUInt CDouble Source # 
FromIntegral CLong CDouble Source # 
FromIntegral CULong CDouble Source # 
FromIntegral CLLong CDouble Source # 
FromIntegral CULLong CDouble Source # 
ToFloating Double CDouble Source # 
ToFloating Float CDouble Source # 
ToFloating Int CDouble Source # 
ToFloating Int8 CDouble Source # 
ToFloating Int16 CDouble Source # 
ToFloating Int32 CDouble Source # 
ToFloating Int64 CDouble Source # 
ToFloating Word CDouble Source # 
ToFloating Word8 CDouble Source # 
ToFloating Word16 CDouble Source # 
ToFloating Word32 CDouble Source # 
ToFloating Word64 CDouble Source # 
ToFloating CShort CDouble Source # 
ToFloating CUShort CDouble Source # 
ToFloating CInt CDouble Source # 
ToFloating CUInt CDouble Source # 
ToFloating CLong CDouble Source # 
ToFloating CULong CDouble Source # 
ToFloating CLLong CDouble Source # 
ToFloating CULLong CDouble Source # 
ToFloating CFloat CDouble Source # 
ToFloating CDouble Double Source # 
ToFloating CDouble Float Source # 
ToFloating CDouble CFloat Source # 
ToFloating CDouble CDouble Source # 
Lift Exp CDouble Source # 

Associated Types

type Plain CDouble :: * Source #

type Plain CDouble Source # 

data CShort :: * #

Haskell type representing the C short type.

Instances

Bounded CShort 
Enum CShort 
Eq CShort 

Methods

(==) :: CShort -> CShort -> Bool #

(/=) :: CShort -> CShort -> Bool #

Integral CShort 
Num CShort 
Ord CShort 
Read CShort 
Real CShort 
Show CShort 
Storable CShort 
Bits CShort 
FiniteBits CShort 
NFData CShort

Since: 1.4.0.0

Methods

rnf :: CShort -> () #

IsScalar CShort Source # 

Methods

scalarType :: ScalarType CShort

IsBounded CShort Source # 

Methods

boundedType :: BoundedType CShort

IsNum CShort Source # 

Methods

numType :: NumType CShort

IsIntegral CShort Source # 

Methods

integralType :: IntegralType CShort

Elt CShort Source # 

Methods

eltType :: CShort -> TupleType (EltRepr CShort)

fromElt :: CShort -> EltRepr CShort

toElt :: EltRepr CShort -> CShort

Eq CShort Source # 
Ord CShort Source # 
FiniteBits CShort Source # 
Bits CShort Source # 
FromIntegral Int CShort Source # 
FromIntegral Int8 CShort Source # 
FromIntegral Int16 CShort Source # 
FromIntegral Int32 CShort Source # 
FromIntegral Int64 CShort Source # 
FromIntegral Word CShort Source # 
FromIntegral Word8 CShort Source # 
FromIntegral Word16 CShort Source # 
FromIntegral Word32 CShort Source # 
FromIntegral Word64 CShort Source # 
FromIntegral CShort Double Source # 
FromIntegral CShort Float Source # 
FromIntegral CShort Int Source # 
FromIntegral CShort Int8 Source # 
FromIntegral CShort Int16 Source # 
FromIntegral CShort Int32 Source # 
FromIntegral CShort Int64 Source # 
FromIntegral CShort Word Source # 
FromIntegral CShort Word8 Source # 
FromIntegral CShort Word16 Source # 
FromIntegral CShort Word32 Source # 
FromIntegral CShort Word64 Source # 
FromIntegral CShort CShort Source # 
FromIntegral CShort CUShort Source # 
FromIntegral CShort CInt Source # 
FromIntegral CShort CUInt Source # 
FromIntegral CShort CLong Source # 
FromIntegral CShort CULong Source # 
FromIntegral CShort CLLong Source # 
FromIntegral CShort CULLong Source # 
FromIntegral CShort CFloat Source # 
FromIntegral CShort CDouble Source # 
FromIntegral CUShort CShort Source # 
FromIntegral CInt CShort Source # 
FromIntegral CUInt CShort Source # 
FromIntegral CLong CShort Source # 
FromIntegral CULong CShort Source # 
FromIntegral CLLong CShort Source # 
FromIntegral CULLong CShort Source # 
ToFloating CShort Double Source # 
ToFloating CShort Float Source # 
ToFloating CShort CFloat Source # 
ToFloating CShort CDouble Source # 
Lift Exp CShort Source # 

Associated Types

type Plain CShort :: * Source #

Methods

lift :: CShort -> Exp (Plain CShort) Source #

type Plain CShort Source # 

data CUShort :: * #

Haskell type representing the C unsigned short type.

Instances

Bounded CUShort 
Enum CUShort 
Eq CUShort 

Methods

(==) :: CUShort -> CUShort -> Bool #

(/=) :: CUShort -> CUShort -> Bool #

Integral CUShort 
Num CUShort 
Ord CUShort 
Read CUShort 
Real CUShort 
Show CUShort 
Storable CUShort 
Bits CUShort 
FiniteBits CUShort 
NFData CUShort

Since: 1.4.0.0

Methods

rnf :: CUShort -> () #

IsScalar CUShort Source # 

Methods

scalarType :: ScalarType CUShort

IsBounded CUShort Source # 

Methods

boundedType :: BoundedType CUShort

IsNum CUShort Source # 

Methods

numType :: NumType CUShort

IsIntegral CUShort Source # 

Methods

integralType :: IntegralType CUShort

Elt CUShort Source # 

Methods

eltType :: CUShort -> TupleType (EltRepr CUShort)

fromElt :: CUShort -> EltRepr CUShort

toElt :: EltRepr CUShort -> CUShort

Eq CUShort Source # 
Ord CUShort Source # 
FiniteBits CUShort Source # 
Bits CUShort Source # 
FromIntegral Int CUShort Source # 
FromIntegral Int8 CUShort Source # 
FromIntegral Int16 CUShort Source # 
FromIntegral Int32 CUShort Source # 
FromIntegral Int64 CUShort Source # 
FromIntegral Word CUShort Source # 
FromIntegral Word8 CUShort Source # 
FromIntegral Word16 CUShort Source # 
FromIntegral Word32 CUShort Source # 
FromIntegral Word64 CUShort Source # 
FromIntegral CShort CUShort Source # 
FromIntegral CUShort Double Source # 
FromIntegral CUShort Float Source # 
FromIntegral CUShort Int Source # 
FromIntegral CUShort Int8 Source # 
FromIntegral CUShort Int16 Source # 
FromIntegral CUShort Int32 Source # 
FromIntegral CUShort Int64 Source # 
FromIntegral CUShort Word Source # 
FromIntegral CUShort Word8 Source # 
FromIntegral CUShort Word16 Source # 
FromIntegral CUShort Word32 Source # 
FromIntegral CUShort Word64 Source # 
FromIntegral CUShort CShort Source # 
FromIntegral CUShort CUShort Source # 
FromIntegral CUShort CInt Source # 
FromIntegral CUShort CUInt Source # 
FromIntegral CUShort CLong Source # 
FromIntegral CUShort CULong Source # 
FromIntegral CUShort CLLong Source # 
FromIntegral CUShort CULLong Source # 
FromIntegral CUShort CFloat Source # 
FromIntegral CUShort CDouble Source # 
FromIntegral CInt CUShort Source # 
FromIntegral CUInt CUShort Source # 
FromIntegral CLong CUShort Source # 
FromIntegral CULong CUShort Source # 
FromIntegral CLLong CUShort Source # 
FromIntegral CULLong CUShort Source # 
ToFloating CUShort Double Source # 
ToFloating CUShort Float Source # 
ToFloating CUShort CFloat Source # 
ToFloating CUShort CDouble Source # 
Lift Exp CUShort Source # 

Associated Types

type Plain CUShort :: * Source #

type Plain CUShort Source # 

data CInt :: * #

Haskell type representing the C int type.

Instances

Bounded CInt 
Enum CInt 

Methods

succ :: CInt -> CInt #

pred :: CInt -> CInt #

toEnum :: Int -> CInt #

fromEnum :: CInt -> Int #

enumFrom :: CInt -> [CInt] #

enumFromThen :: CInt -> CInt -> [CInt] #

enumFromTo :: CInt -> CInt -> [CInt] #

enumFromThenTo :: CInt -> CInt -> CInt -> [CInt] #

Eq CInt 

Methods

(==) :: CInt -> CInt -> Bool #

(/=) :: CInt -> CInt -> Bool #

Integral CInt 

Methods

quot :: CInt -> CInt -> CInt #

rem :: CInt -> CInt -> CInt #

div :: CInt -> CInt -> CInt #

mod :: CInt -> CInt -> CInt #

quotRem :: CInt -> CInt -> (CInt, CInt) #

divMod :: CInt -> CInt -> (CInt, CInt) #

toInteger :: CInt -> Integer #

Num CInt 

Methods

(+) :: CInt -> CInt -> CInt #

(-) :: CInt -> CInt -> CInt #

(*) :: CInt -> CInt -> CInt #

negate :: CInt -> CInt #

abs :: CInt -> CInt #

signum :: CInt -> CInt #

fromInteger :: Integer -> CInt #

Ord CInt 

Methods

compare :: CInt -> CInt -> Ordering #

(<) :: CInt -> CInt -> Bool #

(<=) :: CInt -> CInt -> Bool #

(>) :: CInt -> CInt -> Bool #

(>=) :: CInt -> CInt -> Bool #

max :: CInt -> CInt -> CInt #

min :: CInt -> CInt -> CInt #

Read CInt 
Real CInt 

Methods

toRational :: CInt -> Rational #

Show CInt 

Methods

showsPrec :: Int -> CInt -> ShowS #

show :: CInt -> String #

showList :: [CInt] -> ShowS #

Storable CInt 

Methods

sizeOf :: CInt -> Int #

alignment :: CInt -> Int #

peekElemOff :: Ptr CInt -> Int -> IO CInt #

pokeElemOff :: Ptr CInt -> Int -> CInt -> IO () #

peekByteOff :: Ptr b -> Int -> IO CInt #

pokeByteOff :: Ptr b -> Int -> CInt -> IO () #

peek :: Ptr CInt -> IO CInt #

poke :: Ptr CInt -> CInt -> IO () #

Bits CInt 
FiniteBits CInt 
NFData CInt

Since: 1.4.0.0

Methods

rnf :: CInt -> () #

IsScalar CInt Source # 

Methods

scalarType :: ScalarType CInt

IsBounded CInt Source # 

Methods

boundedType :: BoundedType CInt

IsNum CInt Source # 

Methods

numType :: NumType CInt

IsIntegral CInt Source # 

Methods

integralType :: IntegralType CInt

Elt CInt Source # 

Methods

eltType :: CInt -> TupleType (EltRepr CInt)

fromElt :: CInt -> EltRepr CInt

toElt :: EltRepr CInt -> CInt

Eq CInt Source # 
Ord CInt Source # 
FiniteBits CInt Source # 
Bits CInt Source # 
FromIntegral Int CInt Source # 
FromIntegral Int8 CInt Source # 
FromIntegral Int16 CInt Source # 
FromIntegral Int32 CInt Source # 
FromIntegral Int64 CInt Source # 
FromIntegral Word CInt Source # 
FromIntegral Word8 CInt Source # 
FromIntegral Word16 CInt Source # 
FromIntegral Word32 CInt Source # 
FromIntegral Word64 CInt Source # 
FromIntegral CShort CInt Source # 
FromIntegral CUShort CInt Source # 
FromIntegral CInt Double Source # 
FromIntegral CInt Float Source # 
FromIntegral CInt Int Source # 
FromIntegral CInt Int8 Source # 
FromIntegral CInt Int16 Source # 
FromIntegral CInt Int32 Source # 
FromIntegral CInt Int64 Source # 
FromIntegral CInt Word Source # 
FromIntegral CInt Word8 Source # 
FromIntegral CInt Word16 Source # 
FromIntegral CInt Word32 Source # 
FromIntegral CInt Word64 Source # 
FromIntegral CInt CShort Source # 
FromIntegral CInt CUShort Source # 
FromIntegral CInt CInt Source # 
FromIntegral CInt CUInt Source # 
FromIntegral CInt CLong Source # 
FromIntegral CInt CULong Source # 
FromIntegral CInt CLLong Source # 
FromIntegral CInt CULLong Source # 
FromIntegral CInt CFloat Source # 
FromIntegral CInt CDouble Source # 
FromIntegral CUInt CInt Source # 
FromIntegral CLong CInt Source # 
FromIntegral CULong CInt Source # 
FromIntegral CLLong CInt Source # 
FromIntegral CULLong CInt Source # 
ToFloating CInt Double Source # 
ToFloating CInt Float Source # 
ToFloating CInt CFloat Source # 
ToFloating CInt CDouble Source # 
Lift Exp CInt Source # 

Associated Types

type Plain CInt :: * Source #

Methods

lift :: CInt -> Exp (Plain CInt) Source #

type Plain CInt Source # 
type Plain CInt = CInt

data CUInt :: * #

Haskell type representing the C unsigned int type.

Instances

Bounded CUInt 
Enum CUInt 
Eq CUInt 

Methods

(==) :: CUInt -> CUInt -> Bool #

(/=) :: CUInt -> CUInt -> Bool #

Integral CUInt 
Num CUInt 
Ord CUInt 

Methods

compare :: CUInt -> CUInt -> Ordering #

(<) :: CUInt -> CUInt -> Bool #

(<=) :: CUInt -> CUInt -> Bool #

(>) :: CUInt -> CUInt -> Bool #

(>=) :: CUInt -> CUInt -> Bool #

max :: CUInt -> CUInt -> CUInt #

min :: CUInt -> CUInt -> CUInt #

Read CUInt 
Real CUInt 

Methods

toRational :: CUInt -> Rational #

Show CUInt 

Methods

showsPrec :: Int -> CUInt -> ShowS #

show :: CUInt -> String #

showList :: [CUInt] -> ShowS #

Storable CUInt 

Methods

sizeOf :: CUInt -> Int #

alignment :: CUInt -> Int #

peekElemOff :: Ptr CUInt -> Int -> IO CUInt #

pokeElemOff :: Ptr CUInt -> Int -> CUInt -> IO () #

peekByteOff :: Ptr b -> Int -> IO CUInt #

pokeByteOff :: Ptr b -> Int -> CUInt -> IO () #

peek :: Ptr CUInt -> IO CUInt #

poke :: Ptr CUInt -> CUInt -> IO () #

Bits CUInt 
FiniteBits CUInt 
NFData CUInt

Since: 1.4.0.0

Methods

rnf :: CUInt -> () #

IsScalar CUInt Source # 

Methods

scalarType :: ScalarType CUInt

IsBounded CUInt Source # 

Methods

boundedType :: BoundedType CUInt

IsNum CUInt Source # 

Methods

numType :: NumType CUInt

IsIntegral CUInt Source # 

Methods

integralType :: IntegralType CUInt

Elt CUInt Source # 

Methods

eltType :: CUInt -> TupleType (EltRepr CUInt)

fromElt :: CUInt -> EltRepr CUInt

toElt :: EltRepr CUInt -> CUInt

Eq CUInt Source # 
Ord CUInt Source # 
FiniteBits CUInt Source # 
Bits CUInt Source # 
FromIntegral Int CUInt Source # 
FromIntegral Int8 CUInt Source # 
FromIntegral Int16 CUInt Source # 
FromIntegral Int32 CUInt Source # 
FromIntegral Int64 CUInt Source # 
FromIntegral Word CUInt Source # 
FromIntegral Word8 CUInt Source # 
FromIntegral Word16 CUInt Source # 
FromIntegral Word32 CUInt Source # 
FromIntegral Word64 CUInt Source # 
FromIntegral CShort CUInt Source # 
FromIntegral CUShort CUInt Source # 
FromIntegral CInt CUInt Source # 
FromIntegral CUInt Double Source # 
FromIntegral CUInt Float Source # 
FromIntegral CUInt Int Source # 
FromIntegral CUInt Int8 Source # 
FromIntegral CUInt Int16 Source # 
FromIntegral CUInt Int32 Source # 
FromIntegral CUInt Int64 Source # 
FromIntegral CUInt Word Source # 
FromIntegral CUInt Word8 Source # 
FromIntegral CUInt Word16 Source # 
FromIntegral CUInt Word32 Source # 
FromIntegral CUInt Word64 Source # 
FromIntegral CUInt CShort Source # 
FromIntegral CUInt CUShort Source # 
FromIntegral CUInt CInt Source # 
FromIntegral CUInt CUInt Source # 
FromIntegral CUInt CLong Source # 
FromIntegral CUInt CULong Source # 
FromIntegral CUInt CLLong Source # 
FromIntegral CUInt CULLong Source # 
FromIntegral CUInt CFloat Source # 
FromIntegral CUInt CDouble Source # 
FromIntegral CLong CUInt Source # 
FromIntegral CULong CUInt Source # 
FromIntegral CLLong CUInt Source # 
FromIntegral CULLong CUInt Source # 
ToFloating CUInt Double Source # 
ToFloating CUInt Float Source # 
ToFloating CUInt CFloat Source # 
ToFloating CUInt CDouble Source # 
Lift Exp CUInt Source # 

Associated Types

type Plain CUInt :: * Source #

Methods

lift :: CUInt -> Exp (Plain CUInt) Source #

type Plain CUInt Source # 

data CLong :: * #

Haskell type representing the C long type.

Instances

Bounded CLong 
Enum CLong 
Eq CLong 

Methods

(==) :: CLong -> CLong -> Bool #

(/=) :: CLong -> CLong -> Bool #

Integral CLong 
Num CLong 
Ord CLong 

Methods

compare :: CLong -> CLong -> Ordering #

(<) :: CLong -> CLong -> Bool #

(<=) :: CLong -> CLong -> Bool #

(>) :: CLong -> CLong -> Bool #

(>=) :: CLong -> CLong -> Bool #

max :: CLong -> CLong -> CLong #

min :: CLong -> CLong -> CLong #

Read CLong 
Real CLong 

Methods

toRational :: CLong -> Rational #

Show CLong 

Methods

showsPrec :: Int -> CLong -> ShowS #

show :: CLong -> String #

showList :: [CLong] -> ShowS #

Storable CLong 

Methods

sizeOf :: CLong -> Int #

alignment :: CLong -> Int #

peekElemOff :: Ptr CLong -> Int -> IO CLong #

pokeElemOff :: Ptr CLong -> Int -> CLong -> IO () #

peekByteOff :: Ptr b -> Int -> IO CLong #

pokeByteOff :: Ptr b -> Int -> CLong -> IO () #

peek :: Ptr CLong -> IO CLong #

poke :: Ptr CLong -> CLong -> IO () #

Bits CLong 
FiniteBits CLong 
NFData CLong

Since: 1.4.0.0

Methods

rnf :: CLong -> () #

IsScalar CLong Source # 

Methods

scalarType :: ScalarType CLong

IsBounded CLong Source # 

Methods

boundedType :: BoundedType CLong

IsNum CLong Source # 

Methods

numType :: NumType CLong

IsIntegral CLong Source # 

Methods

integralType :: IntegralType CLong

Elt CLong Source # 

Methods

eltType :: CLong -> TupleType (EltRepr CLong)

fromElt :: CLong -> EltRepr CLong

toElt :: EltRepr CLong -> CLong

Eq CLong Source # 
Ord CLong Source # 
FiniteBits CLong Source # 
Bits CLong Source # 
FromIntegral Int CLong Source # 
FromIntegral Int8 CLong Source # 
FromIntegral Int16 CLong Source # 
FromIntegral Int32 CLong Source # 
FromIntegral Int64 CLong Source # 
FromIntegral Word CLong Source # 
FromIntegral Word8 CLong Source # 
FromIntegral Word16 CLong Source # 
FromIntegral Word32 CLong Source # 
FromIntegral Word64 CLong Source # 
FromIntegral CShort CLong Source # 
FromIntegral CUShort CLong Source # 
FromIntegral CInt CLong Source # 
FromIntegral CUInt CLong Source # 
FromIntegral CLong Double Source # 
FromIntegral CLong Float Source # 
FromIntegral CLong Int Source # 
FromIntegral CLong Int8 Source # 
FromIntegral CLong Int16 Source # 
FromIntegral CLong Int32 Source # 
FromIntegral CLong Int64 Source # 
FromIntegral CLong Word Source # 
FromIntegral CLong Word8 Source # 
FromIntegral CLong Word16 Source # 
FromIntegral CLong Word32 Source # 
FromIntegral CLong Word64 Source # 
FromIntegral CLong CShort Source # 
FromIntegral CLong CUShort Source # 
FromIntegral CLong CInt Source # 
FromIntegral CLong CUInt Source # 
FromIntegral CLong CLong Source # 
FromIntegral CLong CULong Source # 
FromIntegral CLong CLLong Source # 
FromIntegral CLong CULLong Source # 
FromIntegral CLong CFloat Source # 
FromIntegral CLong CDouble Source # 
FromIntegral CULong CLong Source # 
FromIntegral CLLong CLong Source # 
FromIntegral CULLong CLong Source # 
ToFloating CLong Double Source # 
ToFloating CLong Float Source # 
ToFloating CLong CFloat Source # 
ToFloating CLong CDouble Source # 
Lift Exp CLong Source # 

Associated Types

type Plain CLong :: * Source #

Methods

lift :: CLong -> Exp (Plain CLong) Source #

type Plain CLong Source # 

data CULong :: * #

Haskell type representing the C unsigned long type.

Instances

Bounded CULong 
Enum CULong 
Eq CULong 

Methods

(==) :: CULong -> CULong -> Bool #

(/=) :: CULong -> CULong -> Bool #

Integral CULong 
Num CULong 
Ord CULong 
Read CULong 
Real CULong 
Show CULong 
Storable CULong 
Bits CULong 
FiniteBits CULong 
NFData CULong

Since: 1.4.0.0

Methods

rnf :: CULong -> () #

IsScalar CULong Source # 

Methods

scalarType :: ScalarType CULong

IsBounded CULong Source # 

Methods

boundedType :: BoundedType CULong

IsNum CULong Source # 

Methods

numType :: NumType CULong

IsIntegral CULong Source # 

Methods

integralType :: IntegralType CULong

Elt CULong Source # 

Methods

eltType :: CULong -> TupleType (EltRepr CULong)

fromElt :: CULong -> EltRepr CULong

toElt :: EltRepr CULong -> CULong

Eq CULong Source # 
Ord CULong Source # 
FiniteBits CULong Source # 
Bits CULong Source # 
FromIntegral Int CULong Source # 
FromIntegral Int8 CULong Source # 
FromIntegral Int16 CULong Source # 
FromIntegral Int32 CULong Source # 
FromIntegral Int64 CULong Source # 
FromIntegral Word CULong Source # 
FromIntegral Word8 CULong Source # 
FromIntegral Word16 CULong Source # 
FromIntegral Word32 CULong Source # 
FromIntegral Word64 CULong Source # 
FromIntegral CShort CULong Source # 
FromIntegral CUShort CULong Source # 
FromIntegral CInt CULong Source # 
FromIntegral CUInt CULong Source # 
FromIntegral CLong CULong Source # 
FromIntegral CULong Double Source # 
FromIntegral CULong Float Source # 
FromIntegral CULong Int Source # 
FromIntegral CULong Int8 Source # 
FromIntegral CULong Int16 Source # 
FromIntegral CULong Int32 Source # 
FromIntegral CULong Int64 Source # 
FromIntegral CULong Word Source # 
FromIntegral CULong Word8 Source # 
FromIntegral CULong Word16 Source # 
FromIntegral CULong Word32 Source # 
FromIntegral CULong Word64 Source # 
FromIntegral CULong CShort Source # 
FromIntegral CULong CUShort Source # 
FromIntegral CULong CInt Source # 
FromIntegral CULong CUInt Source # 
FromIntegral CULong CLong Source # 
FromIntegral CULong CULong Source # 
FromIntegral CULong CLLong Source # 
FromIntegral CULong CULLong Source # 
FromIntegral CULong CFloat Source # 
FromIntegral CULong CDouble Source # 
FromIntegral CLLong CULong Source # 
FromIntegral CULLong CULong Source # 
ToFloating CULong Double Source # 
ToFloating CULong Float Source # 
ToFloating CULong CFloat Source # 
ToFloating CULong CDouble Source # 
Lift Exp CULong Source # 

Associated Types

type Plain CULong :: * Source #

Methods

lift :: CULong -> Exp (Plain CULong) Source #

type Plain CULong Source # 

data CLLong :: * #

Haskell type representing the C long long type.

Instances

Bounded CLLong 
Enum CLLong 
Eq CLLong 

Methods

(==) :: CLLong -> CLLong -> Bool #

(/=) :: CLLong -> CLLong -> Bool #

Integral CLLong 
Num CLLong 
Ord CLLong 
Read CLLong 
Real CLLong 
Show CLLong 
Storable CLLong 
Bits CLLong 
FiniteBits CLLong 
NFData CLLong

Since: 1.4.0.0

Methods

rnf :: CLLong -> () #

IsScalar CLLong Source # 

Methods

scalarType :: ScalarType CLLong

IsBounded CLLong Source # 

Methods

boundedType :: BoundedType CLLong

IsNum CLLong Source # 

Methods

numType :: NumType CLLong

IsIntegral CLLong Source # 

Methods

integralType :: IntegralType CLLong

Elt CLLong Source # 

Methods

eltType :: CLLong -> TupleType (EltRepr CLLong)

fromElt :: CLLong -> EltRepr CLLong

toElt :: EltRepr CLLong -> CLLong

Eq CLLong Source # 
Ord CLLong Source # 
FiniteBits CLLong Source # 
Bits CLLong Source # 
FromIntegral Int CLLong Source # 
FromIntegral Int8 CLLong Source # 
FromIntegral Int16 CLLong Source # 
FromIntegral Int32 CLLong Source # 
FromIntegral Int64 CLLong Source # 
FromIntegral Word CLLong Source # 
FromIntegral Word8 CLLong Source # 
FromIntegral Word16 CLLong Source # 
FromIntegral Word32 CLLong Source # 
FromIntegral Word64 CLLong Source # 
FromIntegral CShort CLLong Source # 
FromIntegral CUShort CLLong Source # 
FromIntegral CInt CLLong Source # 
FromIntegral CUInt CLLong Source # 
FromIntegral CLong CLLong Source # 
FromIntegral CULong CLLong Source # 
FromIntegral CLLong Double Source # 
FromIntegral CLLong Float Source # 
FromIntegral CLLong Int Source # 
FromIntegral CLLong Int8 Source # 
FromIntegral CLLong Int16 Source # 
FromIntegral CLLong Int32 Source # 
FromIntegral CLLong Int64 Source # 
FromIntegral CLLong Word Source # 
FromIntegral CLLong Word8 Source # 
FromIntegral CLLong Word16 Source # 
FromIntegral CLLong Word32 Source # 
FromIntegral CLLong Word64 Source # 
FromIntegral CLLong CShort Source # 
FromIntegral CLLong CUShort Source # 
FromIntegral CLLong CInt Source # 
FromIntegral CLLong CUInt Source # 
FromIntegral CLLong CLong Source # 
FromIntegral CLLong CULong Source # 
FromIntegral CLLong CLLong Source # 
FromIntegral CLLong CULLong Source # 
FromIntegral CLLong CFloat Source # 
FromIntegral CLLong CDouble Source # 
FromIntegral CULLong CLLong Source # 
ToFloating CLLong Double Source # 
ToFloating CLLong Float Source # 
ToFloating CLLong CFloat Source # 
ToFloating CLLong CDouble Source # 
Lift Exp CLLong Source # 

Associated Types

type Plain CLLong :: * Source #

Methods

lift :: CLLong -> Exp (Plain CLLong) Source #

type Plain CLLong Source # 

data CULLong :: * #

Haskell type representing the C unsigned long long type.

Instances

Bounded CULLong 
Enum CULLong 
Eq CULLong 

Methods

(==) :: CULLong -> CULLong -> Bool #

(/=) :: CULLong -> CULLong -> Bool #

Integral CULLong 
Num CULLong 
Ord CULLong 
Read CULLong 
Real CULLong 
Show CULLong 
Storable CULLong 
Bits CULLong 
FiniteBits CULLong 
NFData CULLong

Since: 1.4.0.0

Methods

rnf :: CULLong -> () #

IsScalar CULLong Source # 

Methods

scalarType :: ScalarType CULLong

IsBounded CULLong Source # 

Methods

boundedType :: BoundedType CULLong

IsNum CULLong Source # 

Methods

numType :: NumType CULLong

IsIntegral CULLong Source # 

Methods

integralType :: IntegralType CULLong

Elt CULLong Source # 

Methods

eltType :: CULLong -> TupleType (EltRepr CULLong)

fromElt :: CULLong -> EltRepr CULLong

toElt :: EltRepr CULLong -> CULLong

Eq CULLong Source # 
Ord CULLong Source # 
FiniteBits CULLong Source # 
Bits CULLong Source # 
FromIntegral Int CULLong Source # 
FromIntegral Int8 CULLong Source # 
FromIntegral Int16 CULLong Source # 
FromIntegral Int32 CULLong Source # 
FromIntegral Int64 CULLong Source # 
FromIntegral Word CULLong Source # 
FromIntegral Word8 CULLong Source # 
FromIntegral Word16 CULLong Source # 
FromIntegral Word32 CULLong Source # 
FromIntegral Word64 CULLong Source # 
FromIntegral CShort CULLong Source # 
FromIntegral CUShort CULLong Source # 
FromIntegral CInt CULLong Source # 
FromIntegral CUInt CULLong Source # 
FromIntegral CLong CULLong Source # 
FromIntegral CULong CULLong Source # 
FromIntegral CLLong CULLong Source # 
FromIntegral CULLong Double Source # 
FromIntegral CULLong Float Source # 
FromIntegral CULLong Int Source # 
FromIntegral CULLong Int8 Source # 
FromIntegral CULLong Int16 Source # 
FromIntegral CULLong Int32 Source # 
FromIntegral CULLong Int64 Source # 
FromIntegral CULLong Word Source # 
FromIntegral CULLong Word8 Source # 
FromIntegral CULLong Word16 Source # 
FromIntegral CULLong Word32 Source # 
FromIntegral CULLong Word64 Source # 
FromIntegral CULLong CShort Source # 
FromIntegral CULLong CUShort Source # 
FromIntegral CULLong CInt Source # 
FromIntegral CULLong CUInt Source # 
FromIntegral CULLong CLong Source # 
FromIntegral CULLong CULong Source # 
FromIntegral CULLong CLLong Source # 
FromIntegral CULLong CULLong Source # 
FromIntegral CULLong CFloat Source # 
FromIntegral CULLong CDouble Source # 
ToFloating CULLong Double Source # 
ToFloating CULLong Float Source # 
ToFloating CULLong CFloat Source # 
ToFloating CULLong CDouble Source # 
Lift Exp CULLong Source # 

Associated Types

type Plain CULLong :: * Source #

type Plain CULLong Source # 

data CChar :: * #

Haskell type representing the C char type.

Instances

Bounded CChar 
Enum CChar 
Eq CChar 

Methods

(==) :: CChar -> CChar -> Bool #

(/=) :: CChar -> CChar -> Bool #

Integral CChar 
Num CChar 
Ord CChar 

Methods

compare :: CChar -> CChar -> Ordering #

(<) :: CChar -> CChar -> Bool #

(<=) :: CChar -> CChar -> Bool #

(>) :: CChar -> CChar -> Bool #

(>=) :: CChar -> CChar -> Bool #

max :: CChar -> CChar -> CChar #

min :: CChar -> CChar -> CChar #

Read CChar 
Real CChar 

Methods

toRational :: CChar -> Rational #

Show CChar 

Methods

showsPrec :: Int -> CChar -> ShowS #

show :: CChar -> String #

showList :: [CChar] -> ShowS #

Storable CChar 

Methods

sizeOf :: CChar -> Int #

alignment :: CChar -> Int #

peekElemOff :: Ptr CChar -> Int -> IO CChar #

pokeElemOff :: Ptr CChar -> Int -> CChar -> IO () #

peekByteOff :: Ptr b -> Int -> IO CChar #

pokeByteOff :: Ptr b -> Int -> CChar -> IO () #

peek :: Ptr CChar -> IO CChar #

poke :: Ptr CChar -> CChar -> IO () #

Bits CChar 
FiniteBits CChar 
NFData CChar

Since: 1.4.0.0

Methods

rnf :: CChar -> () #

IsScalar CChar Source # 

Methods

scalarType :: ScalarType CChar

IsBounded CChar Source # 

Methods

boundedType :: BoundedType CChar

IsNonNum CChar Source # 

Methods

nonNumType :: NonNumType CChar

Elt CChar Source # 

Methods

eltType :: CChar -> TupleType (EltRepr CChar)

fromElt :: CChar -> EltRepr CChar

toElt :: EltRepr CChar -> CChar

Eq CChar Source # 
Ord CChar Source # 
Lift Exp CChar Source # 

Associated Types

type Plain CChar :: * Source #

Methods

lift :: CChar -> Exp (Plain CChar) Source #

type Plain CChar Source # 

data CSChar :: * #

Haskell type representing the C signed char type.

Instances

Bounded CSChar 
Enum CSChar 
Eq CSChar 

Methods

(==) :: CSChar -> CSChar -> Bool #

(/=) :: CSChar -> CSChar -> Bool #

Integral CSChar 
Num CSChar 
Ord CSChar 
Read CSChar 
Real CSChar 
Show CSChar 
Storable CSChar 
Bits CSChar 
FiniteBits CSChar 
NFData CSChar

Since: 1.4.0.0

Methods

rnf :: CSChar -> () #

IsScalar CSChar Source # 

Methods

scalarType :: ScalarType CSChar

IsBounded CSChar Source # 

Methods

boundedType :: BoundedType CSChar

IsNonNum CSChar Source # 

Methods

nonNumType :: NonNumType CSChar

Elt CSChar Source # 

Methods

eltType :: CSChar -> TupleType (EltRepr CSChar)

fromElt :: CSChar -> EltRepr CSChar

toElt :: EltRepr CSChar -> CSChar

Eq CSChar Source # 
Ord CSChar Source # 
Lift Exp CSChar Source # 

Associated Types

type Plain CSChar :: * Source #

Methods

lift :: CSChar -> Exp (Plain CSChar) Source #

type Plain CSChar Source # 

data CUChar :: * #

Haskell type representing the C unsigned char type.

Instances

Bounded CUChar 
Enum CUChar 
Eq CUChar 

Methods

(==) :: CUChar -> CUChar -> Bool #

(/=) :: CUChar -> CUChar -> Bool #

Integral CUChar 
Num CUChar 
Ord CUChar 
Read CUChar 
Real CUChar 
Show CUChar 
Storable CUChar 
Bits CUChar 
FiniteBits CUChar 
NFData CUChar

Since: 1.4.0.0

Methods

rnf :: CUChar -> () #

IsScalar CUChar Source # 

Methods

scalarType :: ScalarType CUChar

IsBounded CUChar Source # 

Methods

boundedType :: BoundedType CUChar

IsNonNum CUChar Source # 

Methods

nonNumType :: NonNumType CUChar

Elt CUChar Source # 

Methods

eltType :: CUChar -> TupleType (EltRepr CUChar)

fromElt :: CUChar -> EltRepr CUChar

toElt :: EltRepr CUChar -> CUChar

Eq CUChar Source # 
Ord CUChar Source # 
Lift Exp CUChar Source # 

Associated Types

type Plain CUChar :: * Source #

Methods

lift :: CUChar -> Exp (Plain CUChar) Source #

type Plain CUChar Source # 

Avoid using these in your own functions wherever possible.

class Typeable a => IsScalar a Source #

All scalar types

Minimal complete definition

scalarType

Instances

IsScalar Bool Source # 

Methods

scalarType :: ScalarType Bool

IsScalar Char Source # 

Methods

scalarType :: ScalarType Char

IsScalar Double Source # 

Methods

scalarType :: ScalarType Double

IsScalar Float Source # 

Methods

scalarType :: ScalarType Float

IsScalar Int Source # 

Methods

scalarType :: ScalarType Int

IsScalar Int8 Source # 

Methods

scalarType :: ScalarType Int8

IsScalar Int16 Source # 

Methods

scalarType :: ScalarType Int16

IsScalar Int32 Source # 

Methods

scalarType :: ScalarType Int32

IsScalar Int64 Source # 

Methods

scalarType :: ScalarType Int64

IsScalar Word Source # 

Methods

scalarType :: ScalarType Word

IsScalar Word8 Source # 

Methods

scalarType :: ScalarType Word8

IsScalar Word16 Source # 

Methods

scalarType :: ScalarType Word16

IsScalar Word32 Source # 

Methods

scalarType :: ScalarType Word32

IsScalar Word64 Source # 

Methods

scalarType :: ScalarType Word64

IsScalar CChar Source # 

Methods

scalarType :: ScalarType CChar

IsScalar CSChar Source # 

Methods

scalarType :: ScalarType CSChar

IsScalar CUChar Source # 

Methods

scalarType :: ScalarType CUChar

IsScalar CShort Source # 

Methods

scalarType :: ScalarType CShort

IsScalar CUShort Source # 

Methods

scalarType :: ScalarType CUShort

IsScalar CInt Source # 

Methods

scalarType :: ScalarType CInt

IsScalar CUInt Source # 

Methods

scalarType :: ScalarType CUInt

IsScalar CLong Source # 

Methods

scalarType :: ScalarType CLong

IsScalar CULong Source # 

Methods

scalarType :: ScalarType CULong

IsScalar CLLong Source # 

Methods

scalarType :: ScalarType CLLong

IsScalar CULLong Source # 

Methods

scalarType :: ScalarType CULLong

IsScalar CFloat Source # 

Methods

scalarType :: ScalarType CFloat

IsScalar CDouble Source # 

Methods

scalarType :: ScalarType CDouble

class (Num a, IsScalar a) => IsNum a Source #

Numeric types

Minimal complete definition

numType

Instances

IsNum Double Source # 

Methods

numType :: NumType Double

IsNum Float Source # 

Methods

numType :: NumType Float

IsNum Int Source # 

Methods

numType :: NumType Int

IsNum Int8 Source # 

Methods

numType :: NumType Int8

IsNum Int16 Source # 

Methods

numType :: NumType Int16

IsNum Int32 Source # 

Methods

numType :: NumType Int32

IsNum Int64 Source # 

Methods

numType :: NumType Int64

IsNum Word Source # 

Methods

numType :: NumType Word

IsNum Word8 Source # 

Methods

numType :: NumType Word8

IsNum Word16 Source # 

Methods

numType :: NumType Word16

IsNum Word32 Source # 

Methods

numType :: NumType Word32

IsNum Word64 Source # 

Methods

numType :: NumType Word64

IsNum CShort Source # 

Methods

numType :: NumType CShort

IsNum CUShort Source # 

Methods

numType :: NumType CUShort

IsNum CInt Source # 

Methods

numType :: NumType CInt

IsNum CUInt Source # 

Methods

numType :: NumType CUInt

IsNum CLong Source # 

Methods

numType :: NumType CLong

IsNum CULong Source # 

Methods

numType :: NumType CULong

IsNum CLLong Source # 

Methods

numType :: NumType CLLong

IsNum CULLong Source # 

Methods

numType :: NumType CULLong

IsNum CFloat Source # 

Methods

numType :: NumType CFloat

IsNum CDouble Source # 

Methods

numType :: NumType CDouble

class IsBounded a Source #

Bounded types

Minimal complete definition

boundedType

Instances

IsBounded Bool Source # 

Methods

boundedType :: BoundedType Bool

IsBounded Char Source # 

Methods

boundedType :: BoundedType Char

IsBounded Int Source # 

Methods

boundedType :: BoundedType Int

IsBounded Int8 Source # 

Methods

boundedType :: BoundedType Int8

IsBounded Int16 Source # 

Methods

boundedType :: BoundedType Int16

IsBounded Int32 Source # 

Methods

boundedType :: BoundedType Int32

IsBounded Int64 Source # 

Methods

boundedType :: BoundedType Int64

IsBounded Word Source # 

Methods

boundedType :: BoundedType Word

IsBounded Word8 Source # 

Methods

boundedType :: BoundedType Word8

IsBounded Word16 Source # 

Methods

boundedType :: BoundedType Word16

IsBounded Word32 Source # 

Methods

boundedType :: BoundedType Word32

IsBounded Word64 Source # 

Methods

boundedType :: BoundedType Word64

IsBounded CChar Source # 

Methods

boundedType :: BoundedType CChar

IsBounded CSChar Source # 

Methods

boundedType :: BoundedType CSChar

IsBounded CUChar Source # 

Methods

boundedType :: BoundedType CUChar

IsBounded CShort Source # 

Methods

boundedType :: BoundedType CShort

IsBounded CUShort Source # 

Methods

boundedType :: BoundedType CUShort

IsBounded CInt Source # 

Methods

boundedType :: BoundedType CInt

IsBounded CUInt Source # 

Methods

boundedType :: BoundedType CUInt

IsBounded CLong Source # 

Methods

boundedType :: BoundedType CLong

IsBounded CULong Source # 

Methods

boundedType :: BoundedType CULong

IsBounded CLLong Source # 

Methods

boundedType :: BoundedType CLLong

IsBounded CULLong Source # 

Methods

boundedType :: BoundedType CULLong

class (IsScalar a, IsNum a, IsBounded a) => IsIntegral a Source #

Integral types

Minimal complete definition

integralType

Instances

IsIntegral Int Source # 

Methods

integralType :: IntegralType Int

IsIntegral Int8 Source # 

Methods

integralType :: IntegralType Int8

IsIntegral Int16 Source # 

Methods

integralType :: IntegralType Int16

IsIntegral Int32 Source # 

Methods

integralType :: IntegralType Int32

IsIntegral Int64 Source # 

Methods

integralType :: IntegralType Int64

IsIntegral Word Source # 

Methods

integralType :: IntegralType Word

IsIntegral Word8 Source # 

Methods

integralType :: IntegralType Word8

IsIntegral Word16 Source # 

Methods

integralType :: IntegralType Word16

IsIntegral Word32 Source # 

Methods

integralType :: IntegralType Word32

IsIntegral Word64 Source # 

Methods

integralType :: IntegralType Word64

IsIntegral CShort Source # 

Methods

integralType :: IntegralType CShort

IsIntegral CUShort Source # 

Methods

integralType :: IntegralType CUShort

IsIntegral CInt Source # 

Methods

integralType :: IntegralType CInt

IsIntegral CUInt Source # 

Methods

integralType :: IntegralType CUInt

IsIntegral CLong Source # 

Methods

integralType :: IntegralType CLong

IsIntegral CULong Source # 

Methods

integralType :: IntegralType CULong

IsIntegral CLLong Source # 

Methods

integralType :: IntegralType CLLong

IsIntegral CULLong Source # 

Methods

integralType :: IntegralType CULLong

class (Floating a, IsScalar a, IsNum a) => IsFloating a Source #

Floating types

Minimal complete definition

floatingType

Instances

IsFloating Double Source # 

Methods

floatingType :: FloatingType Double

IsFloating Float Source # 

Methods

floatingType :: FloatingType Float

IsFloating CFloat Source # 

Methods

floatingType :: FloatingType CFloat

IsFloating CDouble Source # 

Methods

floatingType :: FloatingType CDouble

class IsNonNum a Source #

Non-numeric types

Minimal complete definition

nonNumType

Instances

IsNonNum Bool Source # 

Methods

nonNumType :: NonNumType Bool

IsNonNum Char Source # 

Methods

nonNumType :: NonNumType Char

IsNonNum CChar Source # 

Methods

nonNumType :: NonNumType CChar

IsNonNum CSChar Source # 

Methods

nonNumType :: NonNumType CSChar

IsNonNum CUChar Source # 

Methods

nonNumType :: NonNumType CUChar