Data.Array.Accelerate

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:

• Data.Array.Accelerate.Interpreter: simple interpreter in Haskell as a reference implementation defining the semantics of the Accelerate language
• accelerate-llvm-native: implementation supporting parallel execution on multicore CPUs (e.g. x86).
• accelerate-llvm-ptx: implementation supporting parallel execution on CUDA-capable NVIDIA GPUs.

Examples:

• A short tutorial-style example for generating a Mandelbrot set: http://www.acceleratehs.org/examples/mandelbrot.html

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

  • For more information on LULESH: https://codesign.llnl.gov/lulesh.php.

  

Starting a new project:

Accelerate and its associated packages are available on both Hackage and Stackage. A project template is available to help create a new projects using the stack build tool. To create a new project using the template:

stack new PROJECT_NAME https://github.com/AccelerateHS/accelerate/raw/stable/accelerate.hsfiles

Additional components:

• accelerate-io: Fast conversion between Accelerate arrays and other formats (e.g. Repa, Vector).
• accelerate-fft: Fast Fourier transform, with FFI bindings to optimised implementations.
• accelerate-blas: BLAS and LAPACK operations, with FFI bindings to optimised implementations.
• accelerate-bignum: Fixed-width large integer arithmetic.
• containers-accelerate: Container types for use with Accelerate.
• hashable-accelerate: Class for types which can be converted to a value.
• colour-accelerate: Colour representations in Accelerate (RGB, sRGB, HSV, and HSL).
• gloss-accelerate: Generate gloss pictures from Accelerate.
• gloss-raster-accelerate: Parallel rendering of raster images and animations.
• lens-accelerate: Lens operators for Accelerate types.
• linear-accelerate: Linear vector space types for Accelerate.
• mwc-random-accelerate: Generate Accelerate arrays filled with high-quality pseudorandom numbers.

Contact:

• Mailing list for both use and development discussion:

  • mailto:[e-mail]
  • http://groups.google.com/group/accelerate-haskell
• Bug reports: https://github.com/AccelerateHS/accelerate/issues
• Maintainer: Trevor L. McDonell: mailto:[e-mail]

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.

The Accelerate Array Language

Embedded array computations

data Acc a

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.

A simple example

As a simple example, to compute a vector dot product we can 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:

• accelerate-llvm-native: for execution on multicore CPUs
• accelerate-llvm-ptx: for execution on NVIDIA CUDA-capable GPUs

See also Exp, which encapsulates embedded scalar computations.

Avoiding nested parallelism

As mentioned above, embedded scalar computations of type Exp can not initiate further collective operations.

Suppose we wanted to extend our above dotp function to matrix-vector multiplication. First, let's rewrite our dotp function to take Acc arrays as input (which is typically what we want):

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

We might then be inclined to lift our dot-product program to the following (incorrect) matrix-vector product, by applying dotp to each row of the input matrix:

mvm_ndp :: Num a => Acc (Matrix a) -> Acc (Vector a) -> Acc (Vector a)
mvm_ndp mat vec =
  let Z :. rows :. cols  = unlift (shape mat)  :: Z :. Exp Int :. Exp Int
  in  generate (index1 rows)
               (\row -> the $ dotp vec (slice mat (lift (row :. All))))

Here, we use generate to create a one-dimensional vector by applying at each index a function to slice out the corresponding row of the matrix to pass to the dotp function. However, since both generate and slice are data-parallel operations, and moreover that slice depends on the argument row given to it by the generate function, this definition requires nested data-parallelism, and is thus not permitted. The clue that this definition is invalid is that in order to create a program which will be accepted by the type checker, we must use the function the to retrieve the result of the dotp operation, effectively concealing that dotp is a collective array computation in order to match the type expected by generate, which is that of scalar expressions. Additionally, since we have fooled the type-checker, this problem will only be discovered at program runtime.

In order to avoid this problem, we can make use of the fact that operations in Accelerate are rank polymorphic. The fold operation reduces along the innermost dimension of an array of arbitrary rank, reducing the rank (dimensionality) of the array by one. Thus, we can replicate the input vector to as many rows there are in the input matrix, and perform the dot-product of the vector with every row simultaneously:

mvm :: A.Num a => Acc (Matrix a) -> Acc (Vector a) -> Acc (Vector a)
mvm mat vec =
  let Z :. rows :. cols = unlift (shape mat) :: Z :. Exp Int :. Exp Int
      vec'              = A.replicate (lift (Z :. rows :. All)) vec
  in
  A.fold (+) 0 ( A.zipWith (*) mat vec' )

Note that the intermediate, replicated array vec' is never actually created in memory; it will be fused directly into the operation which consumes it. We discuss fusion next.

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:

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:

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

Defined in Data.Array.Accelerate.Prelude

Associated Types

type EltT Acc a

Methods

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

Unlift Acc ()

Defined in Data.Array.Accelerate.Lift

Methods

unlift :: Acc (Plain ()) -> ()

Lift Acc ()

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain ()

Methods

lift :: () -> Acc (Plain ())

Unlift Acc (Acc a)

Defined in Data.Array.Accelerate.Lift

Methods

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

Lift Acc (Acc a)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (Acc a)

Methods

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

(Arrays x0, Arrays x1) => Unlift Acc (Acc x0, Acc x1)

Defined in Data.Array.Accelerate.Lift

Methods

unlift :: Acc (Plain (Acc x0, Acc x1)) -> (Acc x0, Acc x1)

((Lift Acc x0, Lift Acc x1), (Arrays (Plain x0), Arrays (Plain x1))) => Lift Acc (x0, x1)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (x0, x1)

Methods

lift :: (x0, x1) -> Acc (Plain (x0, x1))

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

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (Array sh e)

Methods

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

(Arrays x0, Arrays x1, Arrays x2) => Unlift Acc (Acc x0, Acc x1, Acc x2)

Defined in Data.Array.Accelerate.Lift

Methods

unlift :: Acc (Plain (Acc x0, Acc x1, Acc x2)) -> (Acc x0, Acc x1, Acc x2)

((Lift Acc x0, Lift Acc x1, Lift Acc x2), (Arrays (Plain x0), Arrays (Plain x1), Arrays (Plain x2))) => Lift Acc (x0, x1, x2)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (x0, x1, x2)

Methods

lift :: (x0, x1, x2) -> Acc (Plain (x0, x1, x2))

(Arrays x0, Arrays x1, Arrays x2, Arrays x3) => Unlift Acc (Acc x0, Acc x1, Acc x2, Acc x3)

Defined in Data.Array.Accelerate.Lift

Methods

unlift :: Acc (Plain (Acc x0, Acc x1, Acc x2, Acc x3)) -> (Acc x0, Acc x1, Acc x2, Acc x3)

((Lift Acc x0, Lift Acc x1, Lift Acc x2, Lift Acc x3), (Arrays (Plain x0), Arrays (Plain x1), Arrays (Plain x2), Arrays (Plain x3))) => Lift Acc (x0, x1, x2, x3)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (x0, x1, x2, x3)

Methods

lift :: (x0, x1, x2, x3) -> Acc (Plain (x0, x1, x2, x3))

(Arrays x0, Arrays x1, Arrays x2, Arrays x3, Arrays x4) => Unlift Acc (Acc x0, Acc x1, Acc x2, Acc x3, Acc x4)

Defined in Data.Array.Accelerate.Lift

Methods

unlift :: Acc (Plain (Acc x0, Acc x1, Acc x2, Acc x3, Acc x4)) -> (Acc x0, Acc x1, Acc x2, Acc x3, Acc x4)

((Lift Acc x0, Lift Acc x1, Lift Acc x2, Lift Acc x3, Lift Acc x4), (Arrays (Plain x0), Arrays (Plain x1), Arrays (Plain x2), Arrays (Plain x3), Arrays (Plain x4))) => Lift Acc (x0, x1, x2, x3, x4)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (x0, x1, x2, x3, x4)

Methods

lift :: (x0, x1, x2, x3, x4) -> Acc (Plain (x0, x1, x2, x3, x4))

(Arrays x0, Arrays x1, Arrays x2, Arrays x3, Arrays x4, Arrays x5) => Unlift Acc (Acc x0, Acc x1, Acc x2, Acc x3, Acc x4, Acc x5)

Defined in Data.Array.Accelerate.Lift

Methods

unlift :: Acc (Plain (Acc x0, Acc x1, Acc x2, Acc x3, Acc x4, Acc x5)) -> (Acc x0, Acc x1, Acc x2, Acc x3, Acc x4, Acc x5)

((Lift Acc x0, Lift Acc x1, Lift Acc x2, Lift Acc x3, Lift Acc x4, Lift Acc x5), (Arrays (Plain x0), Arrays (Plain x1), Arrays (Plain x2), Arrays (Plain x3), Arrays (Plain x4), Arrays (Plain x5))) => Lift Acc (x0, x1, x2, x3, x4, x5)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (x0, x1, x2, x3, x4, x5)

Methods

lift :: (x0, x1, x2, x3, x4, x5) -> Acc (Plain (x0, x1, x2, x3, x4, x5))

(Arrays x0, Arrays x1, Arrays x2, Arrays x3, Arrays x4, Arrays x5, Arrays x6) => Unlift Acc (Acc x0, Acc x1, Acc x2, Acc x3, Acc x4, Acc x5, Acc x6)

Defined in Data.Array.Accelerate.Lift

Methods

unlift :: Acc (Plain (Acc x0, Acc x1, Acc x2, Acc x3, Acc x4, Acc x5, Acc x6)) -> (Acc x0, Acc x1, Acc x2, Acc x3, Acc x4, Acc x5, Acc x6)

((Lift Acc x0, Lift Acc x1, Lift Acc x2, Lift Acc x3, Lift Acc x4, Lift Acc x5, Lift Acc x6), (Arrays (Plain x0), Arrays (Plain x1), Arrays (Plain x2), Arrays (Plain x3), Arrays (Plain x4), Arrays (Plain x5), Arrays (Plain x6))) => Lift Acc (x0, x1, x2, x3, x4, x5, x6)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (x0, x1, x2, x3, x4, x5, x6)

Methods

lift :: (x0, x1, x2, x3, x4, x5, x6) -> Acc (Plain (x0, x1, x2, x3, x4, x5, x6))

(Arrays x0, Arrays x1, Arrays x2, Arrays x3, Arrays x4, Arrays x5, Arrays x6, Arrays x7) => Unlift Acc (Acc x0, Acc x1, Acc x2, Acc x3, Acc x4, Acc x5, Acc x6, Acc x7)

Defined in Data.Array.Accelerate.Lift

Methods

unlift :: Acc (Plain (Acc x0, Acc x1, Acc x2, Acc x3, Acc x4, Acc x5, Acc x6, Acc x7)) -> (Acc x0, Acc x1, Acc x2, Acc x3, Acc x4, Acc x5, Acc x6, Acc x7)

((Lift Acc x0, Lift Acc x1, Lift Acc x2, Lift Acc x3, Lift Acc x4, Lift Acc x5, Lift Acc x6, Lift Acc x7), (Arrays (Plain x0), Arrays (Plain x1), Arrays (Plain x2), Arrays (Plain x3), Arrays (Plain x4), Arrays (Plain x5), Arrays (Plain x6), Arrays (Plain x7))) => Lift Acc (x0, x1, x2, x3, x4, x5, x6, x7)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (x0, x1, x2, x3, x4, x5, x6, x7)

Methods

lift :: (x0, x1, x2, x3, x4, x5, x6, x7) -> Acc (Plain (x0, x1, x2, x3, x4, x5, x6, x7))

(Arrays x0, Arrays x1, Arrays x2, Arrays x3, Arrays x4, Arrays x5, Arrays x6, Arrays x7, Arrays x8) => Unlift Acc (Acc x0, Acc x1, Acc x2, Acc x3, Acc x4, Acc x5, Acc x6, Acc x7, Acc x8)

Defined in Data.Array.Accelerate.Lift

Methods

unlift :: Acc (Plain (Acc x0, Acc x1, Acc x2, Acc x3, Acc x4, Acc x5, Acc x6, Acc x7, Acc x8)) -> (Acc x0, Acc x1, Acc x2, Acc x3, Acc x4, Acc x5, Acc x6, Acc x7, Acc x8)

((Lift Acc x0, Lift Acc x1, Lift Acc x2, Lift Acc x3, Lift Acc x4, Lift Acc x5, Lift Acc x6, Lift Acc x7, Lift Acc x8), (Arrays (Plain x0), Arrays (Plain x1), Arrays (Plain x2), Arrays (Plain x3), Arrays (Plain x4), Arrays (Plain x5), Arrays (Plain x6), Arrays (Plain x7), Arrays (Plain x8))) => Lift Acc (x0, x1, x2, x3, x4, x5, x6, x7, x8)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (x0, x1, x2, x3, x4, x5, x6, x7, x8)

Methods

lift :: (x0, x1, x2, x3, x4, x5, x6, x7, x8) -> Acc (Plain (x0, x1, x2, x3, x4, x5, x6, x7, x8))

(Arrays x0, Arrays x1, Arrays x2, Arrays x3, Arrays x4, Arrays x5, Arrays x6, Arrays x7, Arrays x8, Arrays x9) => Unlift Acc (Acc x0, Acc x1, Acc x2, Acc x3, Acc x4, Acc x5, Acc x6, Acc x7, Acc x8, Acc x9)

Defined in Data.Array.Accelerate.Lift

Methods

unlift :: Acc (Plain (Acc x0, Acc x1, Acc x2, Acc x3, Acc x4, Acc x5, Acc x6, Acc x7, Acc x8, Acc x9)) -> (Acc x0, Acc x1, Acc x2, Acc x3, Acc x4, Acc x5, Acc x6, Acc x7, Acc x8, Acc x9)

((Lift Acc x0, Lift Acc x1, Lift Acc x2, Lift Acc x3, Lift Acc x4, Lift Acc x5, Lift Acc x6, Lift Acc x7, Lift Acc x8, Lift Acc x9), (Arrays (Plain x0), Arrays (Plain x1), Arrays (Plain x2), Arrays (Plain x3), Arrays (Plain x4), Arrays (Plain x5), Arrays (Plain x6), Arrays (Plain x7), Arrays (Plain x8), Arrays (Plain x9))) => Lift Acc (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9)

Methods

lift :: (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9) -> Acc (Plain (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9))

(Arrays x0, Arrays x1, Arrays x2, Arrays x3, Arrays x4, Arrays x5, Arrays x6, Arrays x7, Arrays x8, Arrays x9, Arrays x10) => Unlift Acc (Acc x0, Acc x1, Acc x2, Acc x3, Acc x4, Acc x5, Acc x6, Acc x7, Acc x8, Acc x9, Acc x10)

Defined in Data.Array.Accelerate.Lift

Methods

unlift :: Acc (Plain (Acc x0, Acc x1, Acc x2, Acc x3, Acc x4, Acc x5, Acc x6, Acc x7, Acc x8, Acc x9, Acc x10)) -> (Acc x0, Acc x1, Acc x2, Acc x3, Acc x4, Acc x5, Acc x6, Acc x7, Acc x8, Acc x9, Acc x10)

((Lift Acc x0, Lift Acc x1, Lift Acc x2, Lift Acc x3, Lift Acc x4, Lift Acc x5, Lift Acc x6, Lift Acc x7, Lift Acc x8, Lift Acc x9, Lift Acc x10), (Arrays (Plain x0), Arrays (Plain x1), Arrays (Plain x2), Arrays (Plain x3), Arrays (Plain x4), Arrays (Plain x5), Arrays (Plain x6), Arrays (Plain x7), Arrays (Plain x8), Arrays (Plain x9), Arrays (Plain x10))) => Lift Acc (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)

Methods

lift :: (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10) -> Acc (Plain (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10))

(Arrays x0, Arrays x1, Arrays x2, Arrays x3, Arrays x4, Arrays x5, Arrays x6, Arrays x7, Arrays x8, Arrays x9, Arrays x10, Arrays x11) => Unlift Acc (Acc x0, Acc x1, Acc x2, Acc x3, Acc x4, Acc x5, Acc x6, Acc x7, Acc x8, Acc x9, Acc x10, Acc x11)

Defined in Data.Array.Accelerate.Lift

Methods

unlift :: Acc (Plain (Acc x0, Acc x1, Acc x2, Acc x3, Acc x4, Acc x5, Acc x6, Acc x7, Acc x8, Acc x9, Acc x10, Acc x11)) -> (Acc x0, Acc x1, Acc x2, Acc x3, Acc x4, Acc x5, Acc x6, Acc x7, Acc x8, Acc x9, Acc x10, Acc x11)

((Lift Acc x0, Lift Acc x1, Lift Acc x2, Lift Acc x3, Lift Acc x4, Lift Acc x5, Lift Acc x6, Lift Acc x7, Lift Acc x8, Lift Acc x9, Lift Acc x10, Lift Acc x11), (Arrays (Plain x0), Arrays (Plain x1), Arrays (Plain x2), Arrays (Plain x3), Arrays (Plain x4), Arrays (Plain x5), Arrays (Plain x6), Arrays (Plain x7), Arrays (Plain x8), Arrays (Plain x9), Arrays (Plain x10), Arrays (Plain x11))) => Lift Acc (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)

Methods

lift :: (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11) -> Acc (Plain (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11))

(Arrays x0, Arrays x1, Arrays x2, Arrays x3, Arrays x4, Arrays x5, Arrays x6, Arrays x7, Arrays x8, Arrays x9, Arrays x10, Arrays x11, Arrays x12) => Unlift Acc (Acc x0, Acc x1, Acc x2, Acc x3, Acc x4, Acc x5, Acc x6, Acc x7, Acc x8, Acc x9, Acc x10, Acc x11, Acc x12)

Defined in Data.Array.Accelerate.Lift

Methods

unlift :: Acc (Plain (Acc x0, Acc x1, Acc x2, Acc x3, Acc x4, Acc x5, Acc x6, Acc x7, Acc x8, Acc x9, Acc x10, Acc x11, Acc x12)) -> (Acc x0, Acc x1, Acc x2, Acc x3, Acc x4, Acc x5, Acc x6, Acc x7, Acc x8, Acc x9, Acc x10, Acc x11, Acc x12)

((Lift Acc x0, Lift Acc x1, Lift Acc x2, Lift Acc x3, Lift Acc x4, Lift Acc x5, Lift Acc x6, Lift Acc x7, Lift Acc x8, Lift Acc x9, Lift Acc x10, Lift Acc x11, Lift Acc x12), (Arrays (Plain x0), Arrays (Plain x1), Arrays (Plain x2), Arrays (Plain x3), Arrays (Plain x4), Arrays (Plain x5), Arrays (Plain x6), Arrays (Plain x7), Arrays (Plain x8), Arrays (Plain x9), Arrays (Plain x10), Arrays (Plain x11), Arrays (Plain x12))) => Lift Acc (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12)

Methods

lift :: (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12) -> Acc (Plain (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12))

(Arrays x0, Arrays x1, Arrays x2, Arrays x3, Arrays x4, Arrays x5, Arrays x6, Arrays x7, Arrays x8, Arrays x9, Arrays x10, Arrays x11, Arrays x12, Arrays x13) => Unlift Acc (Acc x0, Acc x1, Acc x2, Acc x3, Acc x4, Acc x5, Acc x6, Acc x7, Acc x8, Acc x9, Acc x10, Acc x11, Acc x12, Acc x13)

Defined in Data.Array.Accelerate.Lift

Methods

unlift :: Acc (Plain (Acc x0, Acc x1, Acc x2, Acc x3, Acc x4, Acc x5, Acc x6, Acc x7, Acc x8, Acc x9, Acc x10, Acc x11, Acc x12, Acc x13)) -> (Acc x0, Acc x1, Acc x2, Acc x3, Acc x4, Acc x5, Acc x6, Acc x7, Acc x8, Acc x9, Acc x10, Acc x11, Acc x12, Acc x13)

((Lift Acc x0, Lift Acc x1, Lift Acc x2, Lift Acc x3, Lift Acc x4, Lift Acc x5, Lift Acc x6, Lift Acc x7, Lift Acc x8, Lift Acc x9, Lift Acc x10, Lift Acc x11, Lift Acc x12, Lift Acc x13), (Arrays (Plain x0), Arrays (Plain x1), Arrays (Plain x2), Arrays (Plain x3), Arrays (Plain x4), Arrays (Plain x5), Arrays (Plain x6), Arrays (Plain x7), Arrays (Plain x8), Arrays (Plain x9), Arrays (Plain x10), Arrays (Plain x11), Arrays (Plain x12), Arrays (Plain x13))) => Lift Acc (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13)

Methods

lift :: (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13) -> Acc (Plain (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13))

(Arrays x0, Arrays x1, Arrays x2, Arrays x3, Arrays x4, Arrays x5, Arrays x6, Arrays x7, Arrays x8, Arrays x9, Arrays x10, Arrays x11, Arrays x12, Arrays x13, Arrays x14) => Unlift Acc (Acc x0, Acc x1, Acc x2, Acc x3, Acc x4, Acc x5, Acc x6, Acc x7, Acc x8, Acc x9, Acc x10, Acc x11, Acc x12, Acc x13, Acc x14)

Defined in Data.Array.Accelerate.Lift

Methods

unlift :: Acc (Plain (Acc x0, Acc x1, Acc x2, Acc x3, Acc x4, Acc x5, Acc x6, Acc x7, Acc x8, Acc x9, Acc x10, Acc x11, Acc x12, Acc x13, Acc x14)) -> (Acc x0, Acc x1, Acc x2, Acc x3, Acc x4, Acc x5, Acc x6, Acc x7, Acc x8, Acc x9, Acc x10, Acc x11, Acc x12, Acc x13, Acc x14)

((Lift Acc x0, Lift Acc x1, Lift Acc x2, Lift Acc x3, Lift Acc x4, Lift Acc x5, Lift Acc x6, Lift Acc x7, Lift Acc x8, Lift Acc x9, Lift Acc x10, Lift Acc x11, Lift Acc x12, Lift Acc x13, Lift Acc x14), (Arrays (Plain x0), Arrays (Plain x1), Arrays (Plain x2), Arrays (Plain x3), Arrays (Plain x4), Arrays (Plain x5), Arrays (Plain x6), Arrays (Plain x7), Arrays (Plain x8), Arrays (Plain x9), Arrays (Plain x10), Arrays (Plain x11), Arrays (Plain x12), Arrays (Plain x13), Arrays (Plain x14))) => Lift Acc (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14)

Methods

lift :: (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14) -> Acc (Plain (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14))

(Arrays x0, Arrays x1, Arrays x2, Arrays x3, Arrays x4, Arrays x5, Arrays x6, Arrays x7, Arrays x8, Arrays x9, Arrays x10, Arrays x11, Arrays x12, Arrays x13, Arrays x14, Arrays x15) => Unlift Acc (Acc x0, Acc x1, Acc x2, Acc x3, Acc x4, Acc x5, Acc x6, Acc x7, Acc x8, Acc x9, Acc x10, Acc x11, Acc x12, Acc x13, Acc x14, Acc x15)

Defined in Data.Array.Accelerate.Lift

Methods

unlift :: Acc (Plain (Acc x0, Acc x1, Acc x2, Acc x3, Acc x4, Acc x5, Acc x6, Acc x7, Acc x8, Acc x9, Acc x10, Acc x11, Acc x12, Acc x13, Acc x14, Acc x15)) -> (Acc x0, Acc x1, Acc x2, Acc x3, Acc x4, Acc x5, Acc x6, Acc x7, Acc x8, Acc x9, Acc x10, Acc x11, Acc x12, Acc x13, Acc x14, Acc x15)

((Lift Acc x0, Lift Acc x1, Lift Acc x2, Lift Acc x3, Lift Acc x4, Lift Acc x5, Lift Acc x6, Lift Acc x7, Lift Acc x8, Lift Acc x9, Lift Acc x10, Lift Acc x11, Lift Acc x12, Lift Acc x13, Lift Acc x14, Lift Acc x15), (Arrays (Plain x0), Arrays (Plain x1), Arrays (Plain x2), Arrays (Plain x3), Arrays (Plain x4), Arrays (Plain x5), Arrays (Plain x6), Arrays (Plain x7), Arrays (Plain x8), Arrays (Plain x9), Arrays (Plain x10), Arrays (Plain x11), Arrays (Plain x12), Arrays (Plain x13), Arrays (Plain x14), Arrays (Plain x15))) => Lift Acc (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15)

Methods

lift :: (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15) -> Acc (Plain (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15))

Arrays arrs => Show (Acc arrs)

Defined in Data.Array.Accelerate.Pretty

Methods

showsPrec :: Int -> Acc arrs -> ShowS

show :: Acc arrs -> String

showList :: [Acc arrs] -> ShowS

Arrays b => Afunction (Acc b)

Defined in Data.Array.Accelerate.Trafo.Sharing

Associated Types

type AfunctionR (Acc b)

type ArraysFunctionR (Acc b)

Methods

afunctionRepr :: AfunctionRepr (Acc b) (AfunctionR (Acc b)) (ArraysFunctionR (Acc b))

convertOpenAfun :: HasCallStack => Config -> ArrayLayout aenv aenv -> Acc b -> OpenAfun aenv (ArraysFunctionR (Acc b))

Afunction (Acc a -> f) => Show (Acc a -> f)

Defined in Data.Array.Accelerate.Pretty

Methods

showsPrec :: Int -> (Acc a -> f) -> ShowS

show :: (Acc a -> f) -> String

showList :: [Acc a -> f] -> ShowS

(Arrays a, Afunction r) => Afunction (Acc a -> r)

Defined in Data.Array.Accelerate.Trafo.Sharing

Associated Types

type AfunctionR (Acc a -> r)

type ArraysFunctionR (Acc a -> r)

Methods

afunctionRepr :: AfunctionRepr (Acc a -> r) (AfunctionR (Acc a -> r)) (ArraysFunctionR (Acc a -> r))

convertOpenAfun :: HasCallStack => Config -> ArrayLayout aenv aenv -> (Acc a -> r) -> OpenAfun aenv (ArraysFunctionR (Acc a -> r))

type EltT Acc a

Defined in Data.Array.Accelerate.Prelude

type EltT Acc a = Arrays a

type AfunctionR (Acc b)

Defined in Data.Array.Accelerate.Trafo.Sharing

type AfunctionR (Acc b) = b

type Plain (Acc a)

Defined in Data.Array.Accelerate.Lift

type Plain (Acc a) = a

type AfunctionR (Acc a -> r)

Defined in Data.Array.Accelerate.Trafo.Sharing

type AfunctionR (Acc a -> r) = a -> AfunctionR r

Arrays

data Array sh e

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

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (Array sh e)

Methods

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

Elt e => IsList (Array DIM1 e)

Defined in Data.Array.Accelerate.Sugar.Array

Associated Types

type Item (Array DIM1 e)

Methods

fromList :: [Item (Array DIM1 e)] -> Array DIM1 e

fromListN :: Int -> [Item (Array DIM1 e)] -> Array DIM1 e

toList :: Array DIM1 e -> [Item (Array DIM1 e)]

(Shape sh, Elt e, Eq sh, Eq e) => Eq (Array sh e)

Defined in Data.Array.Accelerate.Sugar.Array

Methods

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

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

(Shape sh, Elt e, Show e) => Show (Array sh e)

Defined in Data.Array.Accelerate.Sugar.Array

Methods

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

show :: Array sh e -> String

showList :: [Array sh e] -> ShowS

(Shape sh, Elt e) => NFData (Array sh e)

Defined in Data.Array.Accelerate.Sugar.Array

Methods

rnf :: Array sh e -> ()

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

Defined in Data.Array.Accelerate.Sugar.Array

Associated Types

type ArraysR (Array sh e)

Methods

arraysR :: ArraysR (ArraysR (Array sh e))

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

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

type Item (Vector e)

Defined in Data.Array.Accelerate.Sugar.Array

type Item (Vector e) = e

type Plain (Array sh e)

Defined in Data.Array.Accelerate.Lift

type Plain (Array sh e) = Array sh e

class Arrays a

The Arrays class characterises the types which can appear in collective Accelerate computations of type Acc.

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

Instances

Arrays ()

Defined in Data.Array.Accelerate.Sugar.Array

Associated Types

type ArraysR ()

Methods

arraysR :: ArraysR (ArraysR ())

toArr :: ArraysR () -> ()

fromArr :: () -> ArraysR ()

(Arrays x0, Arrays x1) => Arrays (x0, x1)

Defined in Data.Array.Accelerate.Sugar.Array

Associated Types

type ArraysR (x0, x1)

Methods

arraysR :: ArraysR (ArraysR (x0, x1))

toArr :: ArraysR (x0, x1) -> (x0, x1)

fromArr :: (x0, x1) -> ArraysR (x0, x1)

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

Defined in Data.Array.Accelerate.Sugar.Array

Associated Types

type ArraysR (Array sh e)

Methods

arraysR :: ArraysR (ArraysR (Array sh e))

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

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

(Arrays x0, Arrays x1, Arrays x2) => Arrays (x0, x1, x2)

Defined in Data.Array.Accelerate.Sugar.Array

Associated Types

type ArraysR (x0, x1, x2)

Methods

arraysR :: ArraysR (ArraysR (x0, x1, x2))

toArr :: ArraysR (x0, x1, x2) -> (x0, x1, x2)

fromArr :: (x0, x1, x2) -> ArraysR (x0, x1, x2)

(Arrays x0, Arrays x1, Arrays x2, Arrays x3) => Arrays (x0, x1, x2, x3)

Defined in Data.Array.Accelerate.Sugar.Array

Associated Types

type ArraysR (x0, x1, x2, x3)

Methods

arraysR :: ArraysR (ArraysR (x0, x1, x2, x3))

toArr :: ArraysR (x0, x1, x2, x3) -> (x0, x1, x2, x3)

fromArr :: (x0, x1, x2, x3) -> ArraysR (x0, x1, x2, x3)

(Arrays x0, Arrays x1, Arrays x2, Arrays x3, Arrays x4) => Arrays (x0, x1, x2, x3, x4)

Defined in Data.Array.Accelerate.Sugar.Array

Associated Types

type ArraysR (x0, x1, x2, x3, x4)

Methods

arraysR :: ArraysR (ArraysR (x0, x1, x2, x3, x4))

toArr :: ArraysR (x0, x1, x2, x3, x4) -> (x0, x1, x2, x3, x4)

fromArr :: (x0, x1, x2, x3, x4) -> ArraysR (x0, x1, x2, x3, x4)

(Arrays x0, Arrays x1, Arrays x2, Arrays x3, Arrays x4, Arrays x5) => Arrays (x0, x1, x2, x3, x4, x5)

Defined in Data.Array.Accelerate.Sugar.Array

Associated Types

type ArraysR (x0, x1, x2, x3, x4, x5)

Methods

arraysR :: ArraysR (ArraysR (x0, x1, x2, x3, x4, x5))

toArr :: ArraysR (x0, x1, x2, x3, x4, x5) -> (x0, x1, x2, x3, x4, x5)

fromArr :: (x0, x1, x2, x3, x4, x5) -> ArraysR (x0, x1, x2, x3, x4, x5)

(Arrays x0, Arrays x1, Arrays x2, Arrays x3, Arrays x4, Arrays x5, Arrays x6) => Arrays (x0, x1, x2, x3, x4, x5, x6)

Defined in Data.Array.Accelerate.Sugar.Array

Associated Types

type ArraysR (x0, x1, x2, x3, x4, x5, x6)

Methods

arraysR :: ArraysR (ArraysR (x0, x1, x2, x3, x4, x5, x6))

toArr :: ArraysR (x0, x1, x2, x3, x4, x5, x6) -> (x0, x1, x2, x3, x4, x5, x6)

fromArr :: (x0, x1, x2, x3, x4, x5, x6) -> ArraysR (x0, x1, x2, x3, x4, x5, x6)

(Arrays x0, Arrays x1, Arrays x2, Arrays x3, Arrays x4, Arrays x5, Arrays x6, Arrays x7) => Arrays (x0, x1, x2, x3, x4, x5, x6, x7)

Defined in Data.Array.Accelerate.Sugar.Array

Associated Types

type ArraysR (x0, x1, x2, x3, x4, x5, x6, x7)

Methods

arraysR :: ArraysR (ArraysR (x0, x1, x2, x3, x4, x5, x6, x7))

toArr :: ArraysR (x0, x1, x2, x3, x4, x5, x6, x7) -> (x0, x1, x2, x3, x4, x5, x6, x7)

fromArr :: (x0, x1, x2, x3, x4, x5, x6, x7) -> ArraysR (x0, x1, x2, x3, x4, x5, x6, x7)

(Arrays x0, Arrays x1, Arrays x2, Arrays x3, Arrays x4, Arrays x5, Arrays x6, Arrays x7, Arrays x8) => Arrays (x0, x1, x2, x3, x4, x5, x6, x7, x8)

Defined in Data.Array.Accelerate.Sugar.Array

Associated Types

type ArraysR (x0, x1, x2, x3, x4, x5, x6, x7, x8)

Methods

arraysR :: ArraysR (ArraysR (x0, x1, x2, x3, x4, x5, x6, x7, x8))

toArr :: ArraysR (x0, x1, x2, x3, x4, x5, x6, x7, x8) -> (x0, x1, x2, x3, x4, x5, x6, x7, x8)

fromArr :: (x0, x1, x2, x3, x4, x5, x6, x7, x8) -> ArraysR (x0, x1, x2, x3, x4, x5, x6, x7, x8)

(Arrays x0, Arrays x1, Arrays x2, Arrays x3, Arrays x4, Arrays x5, Arrays x6, Arrays x7, Arrays x8, Arrays x9) => Arrays (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9)

Defined in Data.Array.Accelerate.Sugar.Array

Associated Types

type ArraysR (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9)

Methods

arraysR :: ArraysR (ArraysR (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9))

toArr :: ArraysR (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9) -> (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9)

fromArr :: (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9) -> ArraysR (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9)

(Arrays x0, Arrays x1, Arrays x2, Arrays x3, Arrays x4, Arrays x5, Arrays x6, Arrays x7, Arrays x8, Arrays x9, Arrays x10) => Arrays (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)

Defined in Data.Array.Accelerate.Sugar.Array

Associated Types

type ArraysR (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)

Methods

arraysR :: ArraysR (ArraysR (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10))

toArr :: ArraysR (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10) -> (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)

fromArr :: (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10) -> ArraysR (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)

(Arrays x0, Arrays x1, Arrays x2, Arrays x3, Arrays x4, Arrays x5, Arrays x6, Arrays x7, Arrays x8, Arrays x9, Arrays x10, Arrays x11) => Arrays (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)

Defined in Data.Array.Accelerate.Sugar.Array

Associated Types

type ArraysR (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)

Methods

arraysR :: ArraysR (ArraysR (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11))

toArr :: ArraysR (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11) -> (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)

fromArr :: (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11) -> ArraysR (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)

(Arrays x0, Arrays x1, Arrays x2, Arrays x3, Arrays x4, Arrays x5, Arrays x6, Arrays x7, Arrays x8, Arrays x9, Arrays x10, Arrays x11, Arrays x12) => Arrays (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12)

Defined in Data.Array.Accelerate.Sugar.Array

Associated Types

type ArraysR (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12)

Methods

arraysR :: ArraysR (ArraysR (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12))

toArr :: ArraysR (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12) -> (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12)

fromArr :: (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12) -> ArraysR (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12)

(Arrays x0, Arrays x1, Arrays x2, Arrays x3, Arrays x4, Arrays x5, Arrays x6, Arrays x7, Arrays x8, Arrays x9, Arrays x10, Arrays x11, Arrays x12, Arrays x13) => Arrays (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13)

Defined in Data.Array.Accelerate.Sugar.Array

Associated Types

type ArraysR (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13)

Methods

arraysR :: ArraysR (ArraysR (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13))

toArr :: ArraysR (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13) -> (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13)

fromArr :: (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13) -> ArraysR (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13)

(Arrays x0, Arrays x1, Arrays x2, Arrays x3, Arrays x4, Arrays x5, Arrays x6, Arrays x7, Arrays x8, Arrays x9, Arrays x10, Arrays x11, Arrays x12, Arrays x13, Arrays x14) => Arrays (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14)

Defined in Data.Array.Accelerate.Sugar.Array

Associated Types

type ArraysR (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14)

Methods

arraysR :: ArraysR (ArraysR (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14))

toArr :: ArraysR (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14) -> (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14)

fromArr :: (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14) -> ArraysR (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14)

(Arrays x0, Arrays x1, Arrays x2, Arrays x3, Arrays x4, Arrays x5, Arrays x6, Arrays x7, Arrays x8, Arrays x9, Arrays x10, Arrays x11, Arrays x12, Arrays x13, Arrays x14, Arrays x15) => Arrays (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15)

Defined in Data.Array.Accelerate.Sugar.Array

Associated Types

type ArraysR (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15)

Methods

arraysR :: ArraysR (ArraysR (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15))

toArr :: ArraysR (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15) -> (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15)

fromArr :: (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15) -> ArraysR (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15)

type Scalar

Arguments

 = Array DIM0

Scalar arrays hold a single element

type Vector

Arguments

 = Array DIM1

Vectors are one-dimensional arrays

type Matrix

Arguments

 = Array DIM2

Matrices are two-dimensional arrays

type Segments = Vector

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 sub-arrays.

Array elements

class Elt a

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

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 (half, single, and double precision)
• Char
• Bool
• ()
• Shapes formed from Z and (:.)
• Nested tuples of all of these, currently up to 16-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:

• Data.Array.Accelerate.Data.Complex
• Data.Array.Accelerate.Data.Monoid
• linear-accelerate
• colour-accelerate

For simple types it is possible to derive Elt automatically, for example:

data Point = Point Int Float
  deriving (Generic, Elt)

data Option a = None | Just a
  deriving (Generic, Elt)

See the function match for details on how to use sum types in embedded code.

Instances

Elt Bool

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR Bool

Methods

eltR :: TypeR (EltR Bool)

tagsR :: [TagR (EltR Bool)]

fromElt :: Bool -> EltR Bool

toElt :: EltR Bool -> Bool

Elt Char

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR Char

Methods

eltR :: TypeR (EltR Char)

tagsR :: [TagR (EltR Char)]

fromElt :: Char -> EltR Char

toElt :: EltR Char -> Char

Elt Double

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR Double

Methods

eltR :: TypeR (EltR Double)

tagsR :: [TagR (EltR Double)]

fromElt :: Double -> EltR Double

toElt :: EltR Double -> Double

Elt Float

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR Float

Methods

eltR :: TypeR (EltR Float)

tagsR :: [TagR (EltR Float)]

fromElt :: Float -> EltR Float

toElt :: EltR Float -> Float

Elt Int

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR Int

Methods

eltR :: TypeR (EltR Int)

tagsR :: [TagR (EltR Int)]

fromElt :: Int -> EltR Int

toElt :: EltR Int -> Int

Elt Int8

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR Int8

Methods

eltR :: TypeR (EltR Int8)

tagsR :: [TagR (EltR Int8)]

fromElt :: Int8 -> EltR Int8

toElt :: EltR Int8 -> Int8

Elt Int16

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR Int16

Methods

eltR :: TypeR (EltR Int16)

tagsR :: [TagR (EltR Int16)]

fromElt :: Int16 -> EltR Int16

toElt :: EltR Int16 -> Int16

Elt Int32

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR Int32

Methods

eltR :: TypeR (EltR Int32)

tagsR :: [TagR (EltR Int32)]

fromElt :: Int32 -> EltR Int32

toElt :: EltR Int32 -> Int32

Elt Int64

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR Int64

Methods

eltR :: TypeR (EltR Int64)

tagsR :: [TagR (EltR Int64)]

fromElt :: Int64 -> EltR Int64

toElt :: EltR Int64 -> Int64

Elt Ordering

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR Ordering

Methods

eltR :: TypeR (EltR Ordering)

tagsR :: [TagR (EltR Ordering)]

fromElt :: Ordering -> EltR Ordering

toElt :: EltR Ordering -> Ordering

Elt Word

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR Word

Methods

eltR :: TypeR (EltR Word)

tagsR :: [TagR (EltR Word)]

fromElt :: Word -> EltR Word

toElt :: EltR Word -> Word

Elt Word8

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR Word8

Methods

eltR :: TypeR (EltR Word8)

tagsR :: [TagR (EltR Word8)]

fromElt :: Word8 -> EltR Word8

toElt :: EltR Word8 -> Word8

Elt Word16

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR Word16

Methods

eltR :: TypeR (EltR Word16)

tagsR :: [TagR (EltR Word16)]

fromElt :: Word16 -> EltR Word16

toElt :: EltR Word16 -> Word16

Elt Word32

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR Word32

Methods

eltR :: TypeR (EltR Word32)

tagsR :: [TagR (EltR Word32)]

fromElt :: Word32 -> EltR Word32

toElt :: EltR Word32 -> Word32

Elt Word64

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR Word64

Methods

eltR :: TypeR (EltR Word64)

tagsR :: [TagR (EltR Word64)]

fromElt :: Word64 -> EltR Word64

toElt :: EltR Word64 -> Word64

Elt ()

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR ()

Methods

eltR :: TypeR (EltR ())

tagsR :: [TagR (EltR ())]

fromElt :: () -> EltR ()

toElt :: EltR () -> ()

Elt CChar

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR CChar

Methods

eltR :: TypeR (EltR CChar)

tagsR :: [TagR (EltR CChar)]

fromElt :: CChar -> EltR CChar

toElt :: EltR CChar -> CChar

Elt CSChar

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR CSChar

Methods

eltR :: TypeR (EltR CSChar)

tagsR :: [TagR (EltR CSChar)]

fromElt :: CSChar -> EltR CSChar

toElt :: EltR CSChar -> CSChar

Elt CUChar

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR CUChar

Methods

eltR :: TypeR (EltR CUChar)

tagsR :: [TagR (EltR CUChar)]

fromElt :: CUChar -> EltR CUChar

toElt :: EltR CUChar -> CUChar

Elt CShort

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR CShort

Methods

eltR :: TypeR (EltR CShort)

tagsR :: [TagR (EltR CShort)]

fromElt :: CShort -> EltR CShort

toElt :: EltR CShort -> CShort

Elt CUShort

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR CUShort

Methods

eltR :: TypeR (EltR CUShort)

tagsR :: [TagR (EltR CUShort)]

fromElt :: CUShort -> EltR CUShort

toElt :: EltR CUShort -> CUShort

Elt CInt

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR CInt

Methods

eltR :: TypeR (EltR CInt)

tagsR :: [TagR (EltR CInt)]

fromElt :: CInt -> EltR CInt

toElt :: EltR CInt -> CInt

Elt CUInt

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR CUInt

Methods

eltR :: TypeR (EltR CUInt)

tagsR :: [TagR (EltR CUInt)]

fromElt :: CUInt -> EltR CUInt

toElt :: EltR CUInt -> CUInt

Elt CLong

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR CLong

Methods

eltR :: TypeR (EltR CLong)

tagsR :: [TagR (EltR CLong)]

fromElt :: CLong -> EltR CLong

toElt :: EltR CLong -> CLong

Elt CULong

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR CULong

Methods

eltR :: TypeR (EltR CULong)

tagsR :: [TagR (EltR CULong)]

fromElt :: CULong -> EltR CULong

toElt :: EltR CULong -> CULong

Elt CLLong

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR CLLong

Methods

eltR :: TypeR (EltR CLLong)

tagsR :: [TagR (EltR CLLong)]

fromElt :: CLLong -> EltR CLLong

toElt :: EltR CLLong -> CLLong

Elt CULLong

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR CULLong

Methods

eltR :: TypeR (EltR CULLong)

tagsR :: [TagR (EltR CULLong)]

fromElt :: CULLong -> EltR CULLong

toElt :: EltR CULLong -> CULLong

Elt CFloat

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR CFloat

Methods

eltR :: TypeR (EltR CFloat)

tagsR :: [TagR (EltR CFloat)]

fromElt :: CFloat -> EltR CFloat

toElt :: EltR CFloat -> CFloat

Elt CDouble

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR CDouble

Methods

eltR :: TypeR (EltR CDouble)

tagsR :: [TagR (EltR CDouble)]

fromElt :: CDouble -> EltR CDouble

toElt :: EltR CDouble -> CDouble

Elt Half

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR Half

Methods

eltR :: TypeR (EltR Half)

tagsR :: [TagR (EltR Half)]

fromElt :: Half -> EltR Half

toElt :: EltR Half -> Half

Elt All

Defined in Data.Array.Accelerate.Sugar.Shape

Associated Types

type EltR All

Methods

eltR :: TypeR (EltR All)

tagsR :: [TagR (EltR All)]

fromElt :: All -> EltR All

toElt :: EltR All -> All

Elt Z

Defined in Data.Array.Accelerate.Sugar.Shape

Associated Types

type EltR Z

Methods

eltR :: TypeR (EltR Z)

tagsR :: [TagR (EltR Z)]

fromElt :: Z -> EltR Z

toElt :: EltR Z -> Z

Elt a => Elt (Maybe a)

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR (Maybe a)

Methods

eltR :: TypeR (EltR (Maybe a))

tagsR :: [TagR (EltR (Maybe a))]

fromElt :: Maybe a -> EltR (Maybe a)

toElt :: EltR (Maybe a) -> Maybe a

Elt a => Elt (Ratio a)

Defined in Data.Array.Accelerate.Data.Ratio

Associated Types

type EltR (Ratio a)

Methods

eltR :: TypeR (EltR (Ratio a))

tagsR :: [TagR (EltR (Ratio a))]

fromElt :: Ratio a -> EltR (Ratio a)

toElt :: EltR (Ratio a) -> Ratio a

Elt a => Elt (Complex a)

Defined in Data.Array.Accelerate.Data.Complex

Associated Types

type EltR (Complex a)

Methods

eltR :: TypeR (EltR (Complex a))

tagsR :: [TagR (EltR (Complex a))]

fromElt :: Complex a -> EltR (Complex a)

toElt :: EltR (Complex a) -> Complex a

Elt a => Elt (Min a)

Defined in Data.Array.Accelerate.Data.Semigroup

Associated Types

type EltR (Min a)

Methods

eltR :: TypeR (EltR (Min a))

tagsR :: [TagR (EltR (Min a))]

fromElt :: Min a -> EltR (Min a)

toElt :: EltR (Min a) -> Min a

Elt a => Elt (Max a)

Defined in Data.Array.Accelerate.Data.Semigroup

Associated Types

type EltR (Max a)

Methods

eltR :: TypeR (EltR (Max a))

tagsR :: [TagR (EltR (Max a))]

fromElt :: Max a -> EltR (Max a)

toElt :: EltR (Max a) -> Max a

Elt a => Elt (Sum a)

Defined in Data.Array.Accelerate.Data.Monoid

Associated Types

type EltR (Sum a)

Methods

eltR :: TypeR (EltR (Sum a))

tagsR :: [TagR (EltR (Sum a))]

fromElt :: Sum a -> EltR (Sum a)

toElt :: EltR (Sum a) -> Sum a

Elt a => Elt (Product a)

Defined in Data.Array.Accelerate.Data.Monoid

Associated Types

type EltR (Product a)

Methods

eltR :: TypeR (EltR (Product a))

tagsR :: [TagR (EltR (Product a))]

fromElt :: Product a -> EltR (Product a)

toElt :: EltR (Product a) -> Product a

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

Defined in Data.Array.Accelerate.Sugar.Shape

Associated Types

type EltR (Any (sh :. Int))

Methods

eltR :: TypeR (EltR (Any (sh :. Int)))

tagsR :: [TagR (EltR (Any (sh :. Int)))]

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

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

Elt (Any Z)

Defined in Data.Array.Accelerate.Sugar.Shape

Associated Types

type EltR (Any Z)

Methods

eltR :: TypeR (EltR (Any Z))

tagsR :: [TagR (EltR (Any Z))]

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

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

(Elt a, Elt b) => Elt (Either a b)

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR (Either a b)

Methods

eltR :: TypeR (EltR (Either a b))

tagsR :: [TagR (EltR (Either a b))]

fromElt :: Either a b -> EltR (Either a b)

toElt :: EltR (Either a b) -> Either a b

(Elt x0, Elt x1) => Elt (x0, x1)

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR (x0, x1)

Methods

eltR :: TypeR (EltR (x0, x1))

tagsR :: [TagR (EltR (x0, x1))]

fromElt :: (x0, x1) -> EltR (x0, x1)

toElt :: EltR (x0, x1) -> (x0, x1)

(KnownNat n, VecElt a) => Elt (Vec n a)

Defined in Data.Array.Accelerate.Sugar.Vec

Associated Types

type EltR (Vec n a)

Methods

eltR :: TypeR (EltR (Vec n a))

tagsR :: [TagR (EltR (Vec n a))]

fromElt :: Vec n a -> EltR (Vec n a)

toElt :: EltR (Vec n a) -> Vec n a

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

Defined in Data.Array.Accelerate.Sugar.Shape

Associated Types

type EltR (t :. h)

Methods

eltR :: TypeR (EltR (t :. h))

tagsR :: [TagR (EltR (t :. h))]

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

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

(Elt x0, Elt x1, Elt x2) => Elt (x0, x1, x2)

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR (x0, x1, x2)

Methods

eltR :: TypeR (EltR (x0, x1, x2))

tagsR :: [TagR (EltR (x0, x1, x2))]

fromElt :: (x0, x1, x2) -> EltR (x0, x1, x2)

toElt :: EltR (x0, x1, x2) -> (x0, x1, x2)

(Elt x0, Elt x1, Elt x2, Elt x3) => Elt (x0, x1, x2, x3)

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR (x0, x1, x2, x3)

Methods

eltR :: TypeR (EltR (x0, x1, x2, x3))

tagsR :: [TagR (EltR (x0, x1, x2, x3))]

fromElt :: (x0, x1, x2, x3) -> EltR (x0, x1, x2, x3)

toElt :: EltR (x0, x1, x2, x3) -> (x0, x1, x2, x3)

(Elt x0, Elt x1, Elt x2, Elt x3, Elt x4) => Elt (x0, x1, x2, x3, x4)

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR (x0, x1, x2, x3, x4)

Methods

eltR :: TypeR (EltR (x0, x1, x2, x3, x4))

tagsR :: [TagR (EltR (x0, x1, x2, x3, x4))]

fromElt :: (x0, x1, x2, x3, x4) -> EltR (x0, x1, x2, x3, x4)

toElt :: EltR (x0, x1, x2, x3, x4) -> (x0, x1, x2, x3, x4)

(Elt x0, Elt x1, Elt x2, Elt x3, Elt x4, Elt x5) => Elt (x0, x1, x2, x3, x4, x5)

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR (x0, x1, x2, x3, x4, x5)

Methods

eltR :: TypeR (EltR (x0, x1, x2, x3, x4, x5))

tagsR :: [TagR (EltR (x0, x1, x2, x3, x4, x5))]

fromElt :: (x0, x1, x2, x3, x4, x5) -> EltR (x0, x1, x2, x3, x4, x5)

toElt :: EltR (x0, x1, x2, x3, x4, x5) -> (x0, x1, x2, x3, x4, x5)

(Elt x0, Elt x1, Elt x2, Elt x3, Elt x4, Elt x5, Elt x6) => Elt (x0, x1, x2, x3, x4, x5, x6)

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR (x0, x1, x2, x3, x4, x5, x6)

Methods

eltR :: TypeR (EltR (x0, x1, x2, x3, x4, x5, x6))

tagsR :: [TagR (EltR (x0, x1, x2, x3, x4, x5, x6))]

fromElt :: (x0, x1, x2, x3, x4, x5, x6) -> EltR (x0, x1, x2, x3, x4, x5, x6)

toElt :: EltR (x0, x1, x2, x3, x4, x5, x6) -> (x0, x1, x2, x3, x4, x5, x6)

(Elt x0, Elt x1, Elt x2, Elt x3, Elt x4, Elt x5, Elt x6, Elt x7) => Elt (x0, x1, x2, x3, x4, x5, x6, x7)

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR (x0, x1, x2, x3, x4, x5, x6, x7)

Methods

eltR :: TypeR (EltR (x0, x1, x2, x3, x4, x5, x6, x7))

tagsR :: [TagR (EltR (x0, x1, x2, x3, x4, x5, x6, x7))]

fromElt :: (x0, x1, x2, x3, x4, x5, x6, x7) -> EltR (x0, x1, x2, x3, x4, x5, x6, x7)

toElt :: EltR (x0, x1, x2, x3, x4, x5, x6, x7) -> (x0, x1, x2, x3, x4, x5, x6, x7)

(Elt x0, Elt x1, Elt x2, Elt x3, Elt x4, Elt x5, Elt x6, Elt x7, Elt x8) => Elt (x0, x1, x2, x3, x4, x5, x6, x7, x8)

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR (x0, x1, x2, x3, x4, x5, x6, x7, x8)

Methods

eltR :: TypeR (EltR (x0, x1, x2, x3, x4, x5, x6, x7, x8))

tagsR :: [TagR (EltR (x0, x1, x2, x3, x4, x5, x6, x7, x8))]

fromElt :: (x0, x1, x2, x3, x4, x5, x6, x7, x8) -> EltR (x0, x1, x2, x3, x4, x5, x6, x7, x8)

toElt :: EltR (x0, x1, x2, x3, x4, x5, x6, x7, x8) -> (x0, x1, x2, x3, x4, x5, x6, x7, x8)

(Elt x0, Elt x1, Elt x2, Elt x3, Elt x4, Elt x5, Elt x6, Elt x7, Elt x8, Elt x9) => Elt (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9)

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9)

Methods

eltR :: TypeR (EltR (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9))

tagsR :: [TagR (EltR (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9))]

fromElt :: (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9) -> EltR (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9)

toElt :: EltR (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9) -> (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9)

(Elt x0, Elt x1, Elt x2, Elt x3, Elt x4, Elt x5, Elt x6, Elt x7, Elt x8, Elt x9, Elt x10) => Elt (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)

Methods

eltR :: TypeR (EltR (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10))

tagsR :: [TagR (EltR (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10))]

fromElt :: (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10) -> EltR (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)

toElt :: EltR (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10) -> (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)

(Elt x0, Elt x1, Elt x2, Elt x3, Elt x4, Elt x5, Elt x6, Elt x7, Elt x8, Elt x9, Elt x10, Elt x11) => Elt (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)

Methods

eltR :: TypeR (EltR (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11))

tagsR :: [TagR (EltR (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11))]

fromElt :: (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11) -> EltR (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)

toElt :: EltR (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11) -> (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)

(Elt x0, Elt x1, Elt x2, Elt x3, Elt x4, Elt x5, Elt x6, Elt x7, Elt x8, Elt x9, Elt x10, Elt x11, Elt x12) => Elt (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12)

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12)

Methods

eltR :: TypeR (EltR (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12))

tagsR :: [TagR (EltR (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12))]

fromElt :: (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12) -> EltR (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12)

toElt :: EltR (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12) -> (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12)

(Elt x0, Elt x1, Elt x2, Elt x3, Elt x4, Elt x5, Elt x6, Elt x7, Elt x8, Elt x9, Elt x10, Elt x11, Elt x12, Elt x13) => Elt (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13)

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13)

Methods

eltR :: TypeR (EltR (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13))

tagsR :: [TagR (EltR (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13))]

fromElt :: (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13) -> EltR (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13)

toElt :: EltR (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13) -> (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13)

(Elt x0, Elt x1, Elt x2, Elt x3, Elt x4, Elt x5, Elt x6, Elt x7, Elt x8, Elt x9, Elt x10, Elt x11, Elt x12, Elt x13, Elt x14) => Elt (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14)

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14)

Methods

eltR :: TypeR (EltR (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14))

tagsR :: [TagR (EltR (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14))]

fromElt :: (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14) -> EltR (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14)

toElt :: EltR (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14) -> (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14)

(Elt x0, Elt x1, Elt x2, Elt x3, Elt x4, Elt x5, Elt x6, Elt x7, Elt x8, Elt x9, Elt x10, Elt x11, Elt x12, Elt x13, Elt x14, Elt x15) => Elt (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15)

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15)

Methods

eltR :: TypeR (EltR (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15))

tagsR :: [TagR (EltR (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15))]

fromElt :: (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15) -> EltR (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15)

toElt :: EltR (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15) -> (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15)

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

Rank-0 index

Constructors

Z

Instances

Eq Z

Defined in Data.Array.Accelerate.Sugar.Shape

Methods

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

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

Show Z

Defined in Data.Array.Accelerate.Sugar.Shape

Methods

showsPrec :: Int -> Z -> ShowS

show :: Z -> String

showList :: [Z] -> ShowS

Generic Z

Defined in Data.Array.Accelerate.Sugar.Shape

Associated Types

type Rep Z :: Type -> Type

Methods

from :: Z -> Rep Z x

to :: Rep Z x -> Z

Elt Z

Defined in Data.Array.Accelerate.Sugar.Shape

Associated Types

type EltR Z

Methods

eltR :: TypeR (EltR Z)

tagsR :: [TagR (EltR Z)]

fromElt :: Z -> EltR Z

toElt :: EltR Z -> Z

Slice Z

Defined in Data.Array.Accelerate.Sugar.Shape

Associated Types

type SliceShape Z

type CoSliceShape Z

type FullShape Z

Methods

sliceIndex :: SliceIndex (EltR Z) (EltR (SliceShape Z)) (EltR (CoSliceShape Z)) (EltR (FullShape Z))

Shape Z

Defined in Data.Array.Accelerate.Sugar.Shape

Methods

shapeR :: ShapeR (EltR Z)

sliceAnyIndex :: SliceIndex (EltR (Any Z)) (EltR Z) () (EltR Z)

sliceNoneIndex :: SliceIndex (EltR Z) () (EltR Z) (EltR Z)

Eq Z

Defined in Data.Array.Accelerate.Classes.Eq

Methods

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

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

Ord Z

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp Z -> Exp Z -> Exp Bool

(>) :: Exp Z -> Exp Z -> Exp Bool

(<=) :: Exp Z -> Exp Z -> Exp Bool

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

min :: Exp Z -> Exp Z -> Exp Z

max :: Exp Z -> Exp Z -> Exp Z

compare :: Exp Z -> Exp Z -> Exp Ordering

Unlift Exp Z

Defined in Data.Array.Accelerate.Lift

Methods

unlift :: Exp (Plain Z) -> Z

Lift Exp Z

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain Z

Methods

lift :: Z -> Exp (Plain Z)

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

Defined in Data.Array.Accelerate.Smart

Associated Types

type StencilR DIM1 (Exp e, Exp e, Exp e)

Methods

stencilR :: StencilR (EltR DIM1) (EltR e) (StencilR DIM1 (Exp e, Exp e, Exp e))

stencilPrj :: SmartExp (StencilR 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)

Defined in Data.Array.Accelerate.Smart

Associated Types

type StencilR DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e)

Methods

stencilR :: StencilR (EltR DIM1) (EltR e) (StencilR DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e))

stencilPrj :: SmartExp (StencilR 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)

Defined in Data.Array.Accelerate.Smart

Associated Types

type StencilR DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e)

Methods

stencilR :: StencilR (EltR DIM1) (EltR e) (StencilR DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e))

stencilPrj :: SmartExp (StencilR 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)

Defined in Data.Array.Accelerate.Smart

Associated Types

type StencilR DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e)

Methods

stencilR :: StencilR (EltR DIM1) (EltR e) (StencilR DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e))

stencilPrj :: SmartExp (StencilR 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 (Any Z)

Defined in Data.Array.Accelerate.Sugar.Shape

Associated Types

type EltR (Any Z)

Methods

eltR :: TypeR (EltR (Any Z))

tagsR :: [TagR (EltR (Any Z))]

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

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

Elt e => IsList (Array DIM1 e)

Defined in Data.Array.Accelerate.Sugar.Array

Associated Types

type Item (Array DIM1 e)

Methods

fromList :: [Item (Array DIM1 e)] -> Array DIM1 e

fromListN :: Int -> [Item (Array DIM1 e)] -> Array DIM1 e

toList :: Array DIM1 e -> [Item (Array DIM1 e)]

type Rep Z

Defined in Data.Array.Accelerate.Sugar.Shape

type Rep Z = D1 ('MetaData "Z" "Data.Array.Accelerate.Sugar.Shape" "accelerate-1.3.0.0-JUAol0vo0mBEBEK4xLffPu" 'False) (C1 ('MetaCons "Z" 'PrefixI 'False) (U1 :: Type -> Type))

type SliceShape Z

Defined in Data.Array.Accelerate.Sugar.Shape

type SliceShape Z = Z

type CoSliceShape Z

Defined in Data.Array.Accelerate.Sugar.Shape

type CoSliceShape Z = Z

type FullShape Z

Defined in Data.Array.Accelerate.Sugar.Shape

type FullShape Z = Z

type Plain Z

Defined in Data.Array.Accelerate.Lift

type Plain Z = Z

type Item (Vector e)

Defined in Data.Array.Accelerate.Sugar.Array

type Item (Vector e) = e

data tail :. head infixl 3

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)

Defined in Data.Array.Accelerate.Smart

Associated Types

type StencilR DIM1 (Exp e, Exp e, Exp e)

Methods

stencilR :: StencilR (EltR DIM1) (EltR e) (StencilR DIM1 (Exp e, Exp e, Exp e))

stencilPrj :: SmartExp (StencilR 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)

Defined in Data.Array.Accelerate.Smart

Associated Types

type StencilR DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e)

Methods

stencilR :: StencilR (EltR DIM1) (EltR e) (StencilR DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e))

stencilPrj :: SmartExp (StencilR 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)

Defined in Data.Array.Accelerate.Smart

Associated Types

type StencilR DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e)

Methods

stencilR :: StencilR (EltR DIM1) (EltR e) (StencilR DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e))

stencilPrj :: SmartExp (StencilR 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)

Defined in Data.Array.Accelerate.Smart

Associated Types

type StencilR DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e)

Methods

stencilR :: StencilR (EltR DIM1) (EltR e) (StencilR DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e))

stencilPrj :: SmartExp (StencilR 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, Elt (Plain ix), Unlift Exp ix) => Unlift Exp (ix :. Exp e)

Defined in Data.Array.Accelerate.Lift

Methods

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

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

Defined in Data.Array.Accelerate.Lift

Methods

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

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

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (ix :. Exp e)

Methods

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

(Elt (Plain ix), Lift Exp ix) => Lift Exp (ix :. All)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (ix :. All)

Methods

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

(Elt (Plain ix), Lift Exp ix) => Lift Exp (ix :. Int)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (ix :. Int)

Methods

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

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

Defined in Data.Array.Accelerate.Sugar.Shape

Associated Types

type EltR (Any (sh :. Int))

Methods

eltR :: TypeR (EltR (Any (sh :. Int)))

tagsR :: [TagR (EltR (Any (sh :. Int)))]

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

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

Elt e => IsList (Array DIM1 e)

Defined in Data.Array.Accelerate.Sugar.Array

Associated Types

type Item (Array DIM1 e)

Methods

fromList :: [Item (Array DIM1 e)] -> Array DIM1 e

fromListN :: Int -> [Item (Array DIM1 e)] -> Array DIM1 e

toList :: Array DIM1 e -> [Item (Array DIM1 e)]

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

Defined in Data.Array.Accelerate.Sugar.Shape

Methods

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

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

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

Defined in Data.Array.Accelerate.Sugar.Shape

Methods

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

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

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

Generic (tail :. head)

Defined in Data.Array.Accelerate.Sugar.Shape

Associated Types

type Rep (tail :. head) :: Type -> Type

Methods

from :: (tail :. head) -> Rep (tail :. head) x

to :: Rep (tail :. head) x -> tail :. head

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

Defined in Data.Array.Accelerate.Sugar.Shape

Associated Types

type EltR (t :. h)

Methods

eltR :: TypeR (EltR (t :. h))

tagsR :: [TagR (EltR (t :. h))]

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

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

Slice sl => Slice (sl :. Int)

Defined in Data.Array.Accelerate.Sugar.Shape

Associated Types

type SliceShape (sl :. Int)

type CoSliceShape (sl :. Int)

type FullShape (sl :. Int)

Methods

sliceIndex :: SliceIndex (EltR (sl :. Int)) (EltR (SliceShape (sl :. Int))) (EltR (CoSliceShape (sl :. Int))) (EltR (FullShape (sl :. Int)))

Slice sl => Slice (sl :. All)

Defined in Data.Array.Accelerate.Sugar.Shape

Associated Types

type SliceShape (sl :. All)

type CoSliceShape (sl :. All)

type FullShape (sl :. All)

Methods

sliceIndex :: SliceIndex (EltR (sl :. All)) (EltR (SliceShape (sl :. All))) (EltR (CoSliceShape (sl :. All))) (EltR (FullShape (sl :. All)))

Shape sh => Shape (sh :. Int)

Defined in Data.Array.Accelerate.Sugar.Shape

Methods

shapeR :: ShapeR (EltR (sh :. Int))

sliceAnyIndex :: SliceIndex (EltR (Any (sh :. Int))) (EltR (sh :. Int)) () (EltR (sh :. Int))

sliceNoneIndex :: SliceIndex (EltR (sh :. Int)) () (EltR (sh :. Int)) (EltR (sh :. Int))

Eq sh => Eq (sh :. Int)

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp (sh :. Int) -> Exp (sh :. Int) -> Exp Bool

(/=) :: Exp (sh :. Int) -> Exp (sh :. Int) -> Exp Bool

Ord sh => Ord (sh :. Int)

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp (sh :. Int) -> Exp (sh :. Int) -> Exp Bool

(>) :: Exp (sh :. Int) -> Exp (sh :. Int) -> Exp Bool

(<=) :: Exp (sh :. Int) -> Exp (sh :. Int) -> Exp Bool

(>=) :: Exp (sh :. Int) -> Exp (sh :. Int) -> Exp Bool

min :: Exp (sh :. Int) -> Exp (sh :. Int) -> Exp (sh :. Int)

max :: Exp (sh :. Int) -> Exp (sh :. Int) -> Exp (sh :. Int)

compare :: Exp (sh :. Int) -> Exp (sh :. Int) -> Exp Ordering

(Stencil (sh :. Int) a row2, Stencil (sh :. Int) a row1, Stencil (sh :. Int) a row0) => Stencil ((sh :. Int) :. Int) a (row2, row1, row0)

Defined in Data.Array.Accelerate.Smart

Associated Types

type StencilR ((sh :. Int) :. Int) (row2, row1, row0)

Methods

stencilR :: StencilR (EltR ((sh :. Int) :. Int)) (EltR a) (StencilR ((sh :. Int) :. Int) (row2, row1, row0))

stencilPrj :: SmartExp (StencilR ((sh :. Int) :. Int) (row2, row1, row0)) -> (row2, row1, row0)

(Stencil (sh :. Int) a row4, Stencil (sh :. Int) a row3, Stencil (sh :. Int) a row2, Stencil (sh :. Int) a row1, Stencil (sh :. Int) a row0) => Stencil ((sh :. Int) :. Int) a (row4, row3, row2, row1, row0)

Defined in Data.Array.Accelerate.Smart

Associated Types

type StencilR ((sh :. Int) :. Int) (row4, row3, row2, row1, row0)

Methods

stencilR :: StencilR (EltR ((sh :. Int) :. Int)) (EltR a) (StencilR ((sh :. Int) :. Int) (row4, row3, row2, row1, row0))

stencilPrj :: SmartExp (StencilR ((sh :. Int) :. Int) (row4, row3, row2, row1, row0)) -> (row4, row3, row2, row1, row0)

(Stencil (sh :. Int) a row6, Stencil (sh :. Int) a row5, Stencil (sh :. Int) a row4, Stencil (sh :. Int) a row3, Stencil (sh :. Int) a row2, Stencil (sh :. Int) a row1, Stencil (sh :. Int) a row0) => Stencil ((sh :. Int) :. Int) a (row6, row5, row4, row3, row2, row1, row0)

Defined in Data.Array.Accelerate.Smart

Associated Types

type StencilR ((sh :. Int) :. Int) (row6, row5, row4, row3, row2, row1, row0)

Methods

stencilR :: StencilR (EltR ((sh :. Int) :. Int)) (EltR a) (StencilR ((sh :. Int) :. Int) (row6, row5, row4, row3, row2, row1, row0))

stencilPrj :: SmartExp (StencilR ((sh :. Int) :. Int) (row6, row5, row4, row3, row2, row1, row0)) -> (row6, row5, row4, row3, row2, row1, row0)

(Stencil (sh :. Int) a row8, Stencil (sh :. Int) a row7, Stencil (sh :. Int) a row6, Stencil (sh :. Int) a row5, Stencil (sh :. Int) a row4, Stencil (sh :. Int) a row3, Stencil (sh :. Int) a row2, Stencil (sh :. Int) a row1, Stencil (sh :. Int) a row0) => Stencil ((sh :. Int) :. Int) a (row8, row7, row6, row5, row4, row3, row2, row1, row0)

Defined in Data.Array.Accelerate.Smart

Associated Types

type StencilR ((sh :. Int) :. Int) (row8, row7, row6, row5, row4, row3, row2, row1, row0)

Methods

stencilR :: StencilR (EltR ((sh :. Int) :. Int)) (EltR a) (StencilR ((sh :. Int) :. Int) (row8, row7, row6, row5, row4, row3, row2, row1, row0))

stencilPrj :: SmartExp (StencilR ((sh :. Int) :. Int) (row8, row7, row6, row5, row4, row3, row2, row1, row0)) -> (row8, row7, row6, row5, row4, row3, row2, row1, row0)

type Item (Vector e)

Defined in Data.Array.Accelerate.Sugar.Array

type Item (Vector e) = e

type Rep (tail :. head)

Defined in Data.Array.Accelerate.Sugar.Shape

type Rep (tail :. head) = D1 ('MetaData ":." "Data.Array.Accelerate.Sugar.Shape" "accelerate-1.3.0.0-JUAol0vo0mBEBEK4xLffPu" 'False) (C1 ('MetaCons ":." ('InfixI 'LeftAssociative 3) 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 tail) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 head)))

type SliceShape (sl :. Int)

Defined in Data.Array.Accelerate.Sugar.Shape

type SliceShape (sl :. Int) = SliceShape sl

type SliceShape (sl :. All)

Defined in Data.Array.Accelerate.Sugar.Shape

type SliceShape (sl :. All) = SliceShape sl :. Int

type CoSliceShape (sl :. Int)

Defined in Data.Array.Accelerate.Sugar.Shape

type CoSliceShape (sl :. Int) = CoSliceShape sl :. Int

type CoSliceShape (sl :. All)

Defined in Data.Array.Accelerate.Sugar.Shape

type CoSliceShape (sl :. All) = CoSliceShape sl

type FullShape (sl :. Int)

Defined in Data.Array.Accelerate.Sugar.Shape

type FullShape (sl :. Int) = FullShape sl :. Int

type FullShape (sl :. All)

Defined in Data.Array.Accelerate.Sugar.Shape

type FullShape (sl :. All) = FullShape sl :. Int

type Plain (ix :. Exp e)

Defined in Data.Array.Accelerate.Lift

type Plain (ix :. Exp e) = Plain ix :. e

type Plain (ix :. All)

Defined in Data.Array.Accelerate.Lift

type Plain (ix :. All) = Plain ix :. All

type Plain (ix :. Int)

Defined in Data.Array.Accelerate.Lift

type Plain (ix :. Int) = Plain ix :. Int

type DIM0 = Z

type DIM1 = DIM0 :. Int

type DIM2 = DIM1 :. Int

type DIM3 = DIM2 :. Int

type DIM4 = DIM3 :. Int

type DIM5 = DIM4 :. Int

type DIM6 = DIM5 :. Int

type DIM7 = DIM6 :. Int

type DIM8 = DIM7 :. Int

type DIM9 = DIM8 :. Int

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

Shapes and indices of multi-dimensional arrays

Minimal complete definition

shapeR, sliceAnyIndex, sliceNoneIndex

Instances

Shape Z

Defined in Data.Array.Accelerate.Sugar.Shape

Methods

shapeR :: ShapeR (EltR Z)

sliceAnyIndex :: SliceIndex (EltR (Any Z)) (EltR Z) () (EltR Z)

sliceNoneIndex :: SliceIndex (EltR Z) () (EltR Z) (EltR Z)

Shape sh => Shape (sh :. Int)

Defined in Data.Array.Accelerate.Sugar.Shape

Methods

shapeR :: ShapeR (EltR (sh :. Int))

sliceAnyIndex :: SliceIndex (EltR (Any (sh :. Int))) (EltR (sh :. Int)) () (EltR (sh :. Int))

sliceNoneIndex :: SliceIndex (EltR (sh :. Int)) () (EltR (sh :. Int)) (EltR (sh :. Int))

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

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

Associated Types

type SliceShape sl :: Type

type CoSliceShape sl :: Type

type FullShape sl :: Type

Methods

sliceIndex :: SliceIndex (EltR sl) (EltR (SliceShape sl)) (EltR (CoSliceShape sl)) (EltR (FullShape sl))

Instances

Slice Z

Defined in Data.Array.Accelerate.Sugar.Shape

Associated Types

type SliceShape Z

type CoSliceShape Z

type FullShape Z

Methods

sliceIndex :: SliceIndex (EltR Z) (EltR (SliceShape Z)) (EltR (CoSliceShape Z)) (EltR (FullShape Z))

Shape sh => Slice (Any sh)

Defined in Data.Array.Accelerate.Sugar.Shape

Associated Types

type SliceShape (Any sh)

type CoSliceShape (Any sh)

type FullShape (Any sh)

Methods

sliceIndex :: SliceIndex (EltR (Any sh)) (EltR (SliceShape (Any sh))) (EltR (CoSliceShape (Any sh))) (EltR (FullShape (Any sh)))

Slice sl => Slice (sl :. Int)

Defined in Data.Array.Accelerate.Sugar.Shape

Associated Types

type SliceShape (sl :. Int)

type CoSliceShape (sl :. Int)

type FullShape (sl :. Int)

Methods

sliceIndex :: SliceIndex (EltR (sl :. Int)) (EltR (SliceShape (sl :. Int))) (EltR (CoSliceShape (sl :. Int))) (EltR (FullShape (sl :. Int)))

Slice sl => Slice (sl :. All)

Defined in Data.Array.Accelerate.Sugar.Shape

Associated Types

type SliceShape (sl :. All)

type CoSliceShape (sl :. All)

type FullShape (sl :. All)

Methods

sliceIndex :: SliceIndex (EltR (sl :. All)) (EltR (SliceShape (sl :. All))) (EltR (CoSliceShape (sl :. All))) (EltR (FullShape (sl :. All)))

data All

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

Defined in Data.Array.Accelerate.Sugar.Shape

Methods

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

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

Show All

Defined in Data.Array.Accelerate.Sugar.Shape

Methods

showsPrec :: Int -> All -> ShowS

show :: All -> String

showList :: [All] -> ShowS

Generic All

Defined in Data.Array.Accelerate.Sugar.Shape

Associated Types

type Rep All :: Type -> Type

Methods

from :: All -> Rep All x

to :: Rep All x -> All

Elt All

Defined in Data.Array.Accelerate.Sugar.Shape

Associated Types

type EltR All

Methods

eltR :: TypeR (EltR All)

tagsR :: [TagR (EltR All)]

fromElt :: All -> EltR All

toElt :: EltR All -> All

(Elt (Plain ix), Lift Exp ix) => Lift Exp (ix :. All)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (ix :. All)

Methods

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

Slice sl => Slice (sl :. All)

Defined in Data.Array.Accelerate.Sugar.Shape

Associated Types

type SliceShape (sl :. All)

type CoSliceShape (sl :. All)

type FullShape (sl :. All)

Methods

sliceIndex :: SliceIndex (EltR (sl :. All)) (EltR (SliceShape (sl :. All))) (EltR (CoSliceShape (sl :. All))) (EltR (FullShape (sl :. All)))

type Rep All

Defined in Data.Array.Accelerate.Sugar.Shape

type Rep All = D1 ('MetaData "All" "Data.Array.Accelerate.Sugar.Shape" "accelerate-1.3.0.0-JUAol0vo0mBEBEK4xLffPu" 'False) (C1 ('MetaCons "All" 'PrefixI 'False) (U1 :: Type -> Type))

type SliceShape (sl :. All)

Defined in Data.Array.Accelerate.Sugar.Shape

type SliceShape (sl :. All) = SliceShape sl :. Int

type CoSliceShape (sl :. All)

Defined in Data.Array.Accelerate.Sugar.Shape

type CoSliceShape (sl :. All) = CoSliceShape sl

type FullShape (sl :. All)

Defined in Data.Array.Accelerate.Sugar.Shape

type FullShape (sl :. All) = FullShape sl :. Int

type Plain (ix :. All)

Defined in Data.Array.Accelerate.Lift

type Plain (ix :. All) = Plain ix :. All

data Any sh

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, Elt (Any sh)) => Lift Exp (Any sh)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (Any sh)

Methods

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

Eq (Any sh)

Defined in Data.Array.Accelerate.Sugar.Shape

Methods

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

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

Show (Any sh)

Defined in Data.Array.Accelerate.Sugar.Shape

Methods

showsPrec :: Int -> Any sh -> ShowS

show :: Any sh -> String

showList :: [Any sh] -> ShowS

Generic (Any sh)

Defined in Data.Array.Accelerate.Sugar.Shape

Associated Types

type Rep (Any sh) :: Type -> Type

Methods

from :: Any sh -> Rep (Any sh) x

to :: Rep (Any sh) x -> Any sh

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

Defined in Data.Array.Accelerate.Sugar.Shape

Associated Types

type EltR (Any (sh :. Int))

Methods

eltR :: TypeR (EltR (Any (sh :. Int)))

tagsR :: [TagR (EltR (Any (sh :. Int)))]

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

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

Elt (Any Z)

Defined in Data.Array.Accelerate.Sugar.Shape

Associated Types

type EltR (Any Z)

Methods

eltR :: TypeR (EltR (Any Z))

tagsR :: [TagR (EltR (Any Z))]

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

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

Shape sh => Slice (Any sh)

Defined in Data.Array.Accelerate.Sugar.Shape

Associated Types

type SliceShape (Any sh)

type CoSliceShape (Any sh)

type FullShape (Any sh)

Methods

sliceIndex :: SliceIndex (EltR (Any sh)) (EltR (SliceShape (Any sh))) (EltR (CoSliceShape (Any sh))) (EltR (FullShape (Any sh)))

type Rep (Any sh)

Defined in Data.Array.Accelerate.Sugar.Shape

type Rep (Any sh) = D1 ('MetaData "Any" "Data.Array.Accelerate.Sugar.Shape" "accelerate-1.3.0.0-JUAol0vo0mBEBEK4xLffPu" 'False) (C1 ('MetaCons "Any" 'PrefixI 'False) (U1 :: Type -> Type))

type SliceShape (Any sh)

Defined in Data.Array.Accelerate.Sugar.Shape

type SliceShape (Any sh) = sh

type CoSliceShape (Any sh)

Defined in Data.Array.Accelerate.Sugar.Shape

type CoSliceShape (Any sh) = Z

type FullShape (Any sh)

Defined in Data.Array.Accelerate.Sugar.Shape

type FullShape (Any sh) = sh

type Plain (Any sh)

Defined in Data.Array.Accelerate.Lift

type Plain (Any sh) = Any sh

Array access

Element indexing

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

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

>>> let mat = fromList (Z:.5:.10) [0..] :: Matrix 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]

>>> runExp $ use mat ! constant (Z:.1:.2)
12

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

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..] :: Matrix 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]

>>> runExp $ use mat !! 12
12

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

Extract the element of a singleton array.

the xs  ==  xs ! Z

Shape information

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

Test whether an array is empty.

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

Get the length of a vector.

shape :: forall sh e. (Shape sh, Elt e) => Acc (Array sh e) -> Exp sh

Extract the shape (extent) of an array.

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

The number of elements in the array

shapeSize :: forall sh. Shape sh => Exp sh -> Exp Int

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

Construction

Introduction

use :: forall arrays. Arrays arrays => arrays -> Acc arrays

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..] :: Vector Int
>>> vec
Vector (Z :. 10) [0,1,2,3,4,5,6,7,8,9]

>>> let mat = fromList (Z:.5:.10) [0..] :: Matrix 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 (Vector Int)
>>> let mat' = use mat         :: Acc (Matrix Int)
>>> let tup  = use (vec, mat)  :: Acc (Vector Int, Matrix Int)

unit :: forall e. Elt e => Exp e -> Acc (Scalar e)

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

Initialisation

generate :: forall sh a. (Shape sh, Elt a) => Exp sh -> (Exp sh -> Exp a) -> Acc (Array sh a)

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:

>>> run $ generate (I1 3) (\_ -> 1.2) :: Vector Float
Vector (Z :. 3) [1.2,1.2,1.2]

Or equivalently:

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

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

>>> run $ generate (I1 10) (\(I1 i) -> i + 1) :: Vector Int
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)

Create an array where all elements are the same value.

>>> run $ fill (constant (Z:.10)) 0 :: Vector Float
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)

Create an array of the given shape containing the values x, x+1, etc. (in row-major order).

>>> run $ enumFromN (constant (Z:.5:.10)) 0 :: Matrix 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

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

>>> run $ enumFromStepN (constant (Z:.5:.10)) 0 0.5 :: Matrix 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

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

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..] :: Matrix Int
>>> 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..] :: Matrix Int
>>> 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]

>>> run $ 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]

concatOn :: (Shape sh, Elt e) => Lens' (Exp sh) (Exp Int) -> Acc (Array sh e) -> Acc (Array sh e) -> Acc (Array sh e)

Generalised version of (++) where the argument Lens' specifies which dimension to concatenate along.

Appropriate lenses are available from lens-accelerate.

>>> let m1 = fromList (Z:.5:.10) [0..] :: Matrix Int
>>> 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:.5) [0..] :: Matrix Int
>>> m2
Matrix (Z :. 10 :. 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]

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

>>> run $ concatOn _2 (use m1) (use m2)
Matrix (Z :. 15 :. 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,
     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]

Expansion

expand :: (Elt a, Elt b) => (Exp a -> Exp Int) -> (Exp a -> Exp Int -> Exp b) -> Acc (Vector a) -> Acc (Vector b)

A recipe for generating flattened implementations of some kinds of irregular nested parallelism. Given two functions that:

1. for each source element, determine how many target elements it expands into; and
2. computes a particular target element based on a source element and the target element index associated with the source

The following example implements the Sieve of Eratosthenes, a contraction style algorithm which first computes all primes less than sqrt n, then uses this intermediate result to sieve away all numbers in the range [sqrt n .. n]. The expand function is used to calculate and flatten the sieves. For each prime p and upper limit c2, function sz computes the number of contributions in the sieve. Then, for each prime p and sieve index i, the function get computes the sieve contribution. The final step produces all the new primes in the interval [c1 .. c2].

>>> :{
  primes :: Exp Int -> Acc (Vector Int)
  primes n = afst loop
    where
      c0    = unit 2
      a0    = use $ fromList (Z:.0) []
      limit = truncate (sqrt (fromIntegral (n+1) :: Exp Float))
      loop  = awhile
                (\(T2 _   c) -> map (< n+1) c)
                (\(T2 old c) ->
                  let c1 = the c
                      c2 = c1 < limit ? ( c1*c1, n+1 )
                      --
                      sieves =
                        let sz p    = (c2 - p) `quot` p
                            get p i = (2+i)*p
                        in
                        map (subtract c1) (expand sz get old)
                      --
                      new =
                        let m     = c2-c1
                            put i = let s = sieves ! i
                                     in s >= 0 && s < m ? (Just_ (I1 s), Nothing_)
                        in
                        afst
                          $ filter (> 0)
                          $ permute const (enumFromN (I1 m) c1) put
                          $ fill (shape sieves) 0
                   in
                   T2 (old ++ new) (unit c2))
                (T2 a0 c0)
:}

>>> run $ primes 100
Vector (Z :. 25) [2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97]

Inspired by the paper Data-Parallel Flattening by Expansion by Martin Elsman, Troels Henriksen, and Niels Gustav Westphal Serup, ARRAY'19.

Since: 1.3.0.0

Composition

Flow control

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

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

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

Arguments

:: forall a. 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

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

Associated Types

type EltT t a :: Constraint

Methods

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

Instances

IfThenElse Exp

Defined in Data.Array.Accelerate.Prelude

Associated Types

type EltT Exp a

Methods

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

IfThenElse Acc

Defined in Data.Array.Accelerate.Prelude

Associated Types

type EltT Acc a

Methods

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

Controlling execution

(>->) :: forall a b c. (Arrays a, Arrays b, Arrays c) => (Acc a -> Acc b) -> (Acc b -> Acc c) -> Acc a -> Acc c infixl 1

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

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

Pair each element with its index

>>> let xs = fromList (Z:.5) [0..] :: Vector Float
>>> run $ 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..] :: Matrix Float
>>> run $ 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 :: forall sh a b. (Shape sh, Elt a, Elt b) => (Exp a -> Exp b) -> Acc (Array sh a) -> Acc (Array sh b)

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..] :: Vector Int
>>> xs
Vector (Z :. 10) [0,1,2,3,4,5,6,7,8,9]

>>> run $ 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)

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

Zipping

zipWith :: forall sh a b c. (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)

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..] :: Matrix Int
>>> 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..] :: Matrix Int
>>> 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]

>>> run $ 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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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

Combine the elements of two arrays pairwise. The shape of the result is the intersection of the two argument shapes.

>>> let m1 = fromList (Z:.5:.10) [0..] :: Matrix Int
>>> let m2 = fromList (Z:.10:.5) [0..] :: Matrix Float
>>> run $ zip (use m1) (use m2)
Matrix (Z :. 5 :. 5)
  [   (0,0.0),   (1,1.0),   (2,2.0),   (3,3.0),   (4,4.0),
     (10,5.0),  (11,6.0),  (12,7.0),  (13,8.0),  (14,9.0),
    (20,10.0), (21,11.0), (22,12.0), (23,13.0), (24,14.0),
    (30,15.0), (31,16.0), (32,17.0), (33,18.0), (34,19.0),
    (40,20.0), (41,21.0), (42,22.0), (43,23.0), (44,24.0)]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Take an array of 9-tuples and return nine arrays, analogous to unzip.

Modifying Arrays

Shape manipulation

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

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)

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

Replication

replicate :: forall slix e. (Slice slix, Elt e) => Exp slix -> Acc (Array (SliceShape slix) e) -> Acc (Array (FullShape slix) e)

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 Int
>>> vec
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:

>>> run $ replicate (constant (Z :. (4::Int) :. 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:

>>> run $ replicate (lift (Z :. All :. (4::Int))) (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:

>>> run $ replicate (constant (Z :. (2::Int) :. All :. (3::Int))) (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.

>>> :{
  let 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)
>>> run $ rep0 10 x
Vector (Z :. 10) [42,42,42,42,42,42,42,42,42,42]

>>> run $ 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.

>>> :{
  let rep1 :: (Shape sh, Elt e) => Exp Int -> Acc (Array (sh :. Int) e) -> Acc (Array (sh :. Int :. Int) e)
      rep1 n a = replicate (lift (Any :. n :. All)) a
:}

>>> run $ 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 :: forall slix e. (Slice slix, Elt e) => Acc (Array (FullShape slix) e) -> Exp slix -> Acc (Array (SliceShape slix) e)

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..] :: Matrix 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]

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

>>> run $ slice (use mat) (constant (Z :. (2::Int) :. 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).

>>> run $ slice (use mat) (constant (Z :. 4 :. 2 :: DIM2))
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:

>>> :{
  let
      sl0 :: (Shape sh, Elt e) => Acc (Array (sh:.Int) e) -> Exp Int -> Acc (Array sh e)
      sl0 a n = slice a (lift (Any :. n))
:}

>>> let vec = fromList (Z:.10) [0..] :: Vector Int
>>> run $ sl0 (use vec) 4
Scalar Z [4]

>>> run $ sl0 (use mat) 4
Vector (Z :. 5) [4,14,24,34,44]

Of course, Any and All can be used together.

>>> :{
  let sl1 :: (Shape sh, Elt e) => Acc (Array (sh:.Int:.Int) e) -> Exp Int -> Acc (Array (sh:.Int) e)
      sl1 a n = slice a (lift (Any :. n :. All))
:}

>>> run $ 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..] :: Array DIM3 Int
>>> 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]

>>> run $ sl1 (use cube) 2
Matrix (Z :. 3 :. 5)
  [ 10, 11, 12, 13, 14,
    30, 31, 32, 33, 34,
    50, 51, 52, 53, 54]

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

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

>>> let mat = fromList (Z:.5:.10) [0..] :: Matrix 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]

>>> run $ 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 :: (Shape sh, Elt e) => Acc (Array (sh :. Int) e) -> Acc (Array (sh :. Int) e)

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..] :: Matrix 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]

>>> run $ 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 :: (Shape sh, Elt e) => Exp Int -> Acc (Array (sh :. Int) e) -> Acc (Array (sh :. Int) e)

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

>>> let mat = fromList (Z:.5:.10) [0..] :: Matrix 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]

>>> run $ 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 :: (Shape sh, Elt e) => Exp Int -> Acc (Array (sh :. Int) e) -> Acc (Array (sh :. Int) e)

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..] :: Matrix 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]

>>> run $ drop 7 (use mat)
Matrix (Z :. 5 :. 3)
  [  7,  8,  9,
    17, 18, 19,
    27, 28, 29,
    37, 38, 39,
    47, 48, 49]

slit

Arguments

:: (Shape sh, Elt e)

=> Exp Int

starting index

-> Exp Int

length

-> Acc (Array (sh :. Int) e)

-> Acc (Array (sh :. Int) e)

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

slit i n = take n . drop i

initOn :: (Shape sh, Elt e) => Lens' (Exp sh) (Exp Int) -> Acc (Array sh e) -> Acc (Array sh e)

Generalised version of init where the argument Lens' specifies which dimension to operate over.

Appropriate lenses are available from lens-accelerate.

Since: 1.2.0.0

tailOn :: (Shape sh, Elt e) => Lens' (Exp sh) (Exp Int) -> Acc (Array sh e) -> Acc (Array sh e)

Generalised version of tail where the argument Lens' specifies which dimension to operate over.

Appropriate lenses are available from lens-accelerate.

Since: 1.2.0.0

takeOn :: (Shape sh, Elt e) => Lens' (Exp sh) (Exp Int) -> Exp Int -> Acc (Array sh e) -> Acc (Array sh e)

Generalised version of take where the argument Lens' specifies which dimension to operate over.

Appropriate lenses are available from lens-accelerate.

Since: 1.2.0.0

dropOn :: (Shape sh, Elt e) => Lens' (Exp sh) (Exp Int) -> Exp Int -> Acc (Array sh e) -> Acc (Array sh e)

Generalised version of drop where the argument Lens' specifies which dimension to operate over.

Appropriate lenses are available from lens-accelerate.

Since: 1.2.0.0

slitOn

Arguments

:: (Shape sh, Elt e)

=> Lens' (Exp sh) (Exp Int)

-> Exp Int

starting index

-> Exp Int

length

-> Acc (Array sh e)

-> Acc (Array sh e)

Generalised version of drop where the argument Lens' specifies which dimension to operate over.

Appropriate lenses are available from lens-accelerate.

Since: 1.2.0.0

Permutations

Forward permutation (scatter)

permute

Arguments

:: forall sh sh' a. (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 (Maybe 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 for which the permutation function returns Nothing 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):

>>> :{
  let 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 -> Just_ (I1 (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] :: Vector Int
>>> run $ 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:

>>> :{
  let identity :: Num a => Exp Int -> Acc (Matrix a)
      identity n =
        let zeros = fill (I2 n n) 0
            ones  = fill (I1 n)   1
        in
        permute const zeros (\(I1 i) -> Just_ (I2 i i)) ones
:}

>>> run $ identity 5 :: Matrix Int
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. This behaviour can be disabled this with -fno-inplace.

Regarding the defaults array:

If you are sure that the default values are not necessary---they are not used by the combination function and every element will be overwritten---a default array created by filling with the value undef will give you a new uninitialised array.

Regarding the combination function:

The function const can be used to replace elements of the defaults array with the new values. If the permutation function maps multiple values to the same location in the results array (the function is not injective) then this operation is non-deterministic.

Since Accelerate uses an unzipped struct-of-array representation, where the individual components of product types (for example, pairs) are stored in separate arrays, storing values of product type requires multiple store instructions.

Accelerate prior to version 1.3.0.0 performs this operation atomically, to ensure that the stored values are always consistent (each component of the product type is written by the same thread). Later versions relax this restriction, but this behaviour can be disabled with -fno-fast-permute-const.

scatter

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] :: Vector Int
>>> let input = fromList (Z :. 7) [1,9,6,4,4,2,5] :: Vector Int
>>> run $ 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

Arguments

:: forall sh sh' a. (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:

>>> :{
  let swap :: Exp DIM2 -> Exp DIM2
      swap = lift1 f
        where
          f :: Z :. Exp Int :. Exp Int -> Z :. Exp Int :. Exp Int
          f (Z:.y:.x) = Z :. x :. y
:}

>>> let mat = fromList (Z:.5:.10) [0..] :: Matrix 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 mat' = use mat
>>> run $ 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

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] :: Vector Int
>>> let from  = fromList (Z:.6) [1,3,7,2,5,3] :: Vector Int
>>> run $ 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)

Reverse the elements of a vector.

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

Transpose the rows and columns of a matrix.

reverseOn :: (Shape sh, Elt e) => Lens' (Exp sh) (Exp Int) -> Acc (Array sh e) -> Acc (Array sh e)

Generalised version of reverse where the argument Lens' specifies which dimension to reverse.

Appropriate lenses are available from lens-accelerate.

>>> let mat = fromList (Z:.5:.10) [0..] :: Matrix 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]

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

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

Since: 1.2.0.0

transposeOn :: (Shape sh, Elt e) => Lens' (Exp sh) (Exp Int) -> Lens' (Exp sh) (Exp Int) -> Acc (Array sh e) -> Acc (Array sh e)

Generalised version of transpose where the argument Lens's specify which two dimensions to transpose.

Appropriate lenses are available from lens-accelerate.

>>> let mat = fromList (Z:.5:.10) [0..] :: Matrix 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]

>>> run $ transposeOn _1 _2 (use 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]

>>> let box = fromList (Z:.2:.3:.5) [0..] :: Array DIM3 Int
>>> box
Array (Z :. 2 :. 3 :. 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]

>>> run $ transposeOn _1 _2 (use box)
Array (Z :. 2 :. 5 :. 3) [0,5,10,1,6,11,2,7,12,3,8,13,4,9,14,15,20,25,16,21,26,17,22,27,18,23,28,19,24,29]

>>> run $ transposeOn _2 _3 (use box)
Array (Z :. 3 :. 2 :. 5) [0,1,2,3,4,15,16,17,18,19,5,6,7,8,9,20,21,22,23,24,10,11,12,13,14,25,26,27,28,29]

>>> run $ transposeOn _1 _3 (use box)
Array (Z :. 5 :. 3 :. 2) [0,15,5,20,10,25,1,16,6,21,11,26,2,17,7,22,12,27,3,18,8,23,13,28,4,19,9,24,14,29]

Since: 1.2.0.0

Filtering

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

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]

>>> run $ 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] :: Matrix 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]

>>> run $ 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])

compact :: forall sh e. (Shape sh, Elt e) => Acc (Array (sh :. Int) Bool) -> Acc (Array (sh :. Int) e) -> Acc (Vector e, Array sh Int)

As filter, but with separate arrays for the data elements and the flags indicating which elements of that array should be kept.

Folding

fold :: forall sh a. (Shape sh, Elt a) => (Exp a -> Exp a -> Exp a) -> Exp a -> Acc (Array (sh :. Int) a) -> Acc (Array sh a)

Reduction of the innermost dimension of an array of arbitrary rank.

The shape of the result obeys the property:

shape (fold f z xs) == indexTail (shape xs)

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..] :: Matrix 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]

>>> run $ 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

>>> :{
  let maximumSegmentSum
          :: forall sh e. (Shape sh, Num e, Ord e)
          => Acc (Array (sh :. Int) e)
          -> Acc (Array sh e)
      maximumSegmentSum
        = map (\(T4 x _ _ _) -> 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 T4 mssx misx mcsx tsx = x
                T4 mssy misy mcsy tsy = y
            in
            T4 (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 T4 y y y x
:}

>>> let vec = fromList (Z:.10) [-2,1,-3,4,-1,2,1,-5,4,0] :: Vector Int
>>> run $ maximumSegmentSum (use vec)
Scalar Z [6]

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

fold1 :: forall sh a. (Shape sh, Elt a) => (Exp a -> Exp a -> Exp a) -> Acc (Array (sh :. Int) a) -> Acc (Array sh a)

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

The shape of the result obeys the property:

shape (fold f z xs) == indexTail (shape xs)

The first argument needs to be an associative function to enable an efficient parallel implementation, but does not need to be commutative.

foldAll :: (Shape sh, Elt a) => (Exp a -> Exp a -> Exp a) -> Exp a -> Acc (Array sh a) -> Acc (Scalar a)

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..] :: Vector Float
>>> run $ foldAll (+) 42 (use vec)
Scalar Z [87.0]

>>> let mat = fromList (Z:.5:.10) [0..] :: Matrix Float
>>> run $ foldAll (+) 0 (use mat)
Scalar Z [1225.0]

fold1All :: (Shape sh, Elt a) => (Exp a -> Exp a -> Exp a) -> Acc (Array sh a) -> Acc (Scalar a)

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 :: forall sh e i. (Shape sh, Elt e, Elt i, i ~ EltR i, IsIntegral i) => (Exp e -> Exp e -> Exp e) -> Exp e -> Acc (Array (sh :. Int) e) -> Acc (Segments i) -> Acc (Array (sh :. Int) e)

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] :: Segments Int
>>> seg
Vector (Z :. 4) [1,4,0,3]

>>> let mat = fromList (Z:.5:.10) [0..] :: Matrix 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]

>>> run $ 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 :: forall sh e i. (Shape sh, Elt e, Elt i, i ~ EltR i, IsIntegral i) => (Exp e -> Exp e -> Exp e) -> Acc (Array (sh :. Int) e) -> Acc (Segments i) -> Acc (Array (sh :. Int) e)

Variant of foldSeg that requires all segments of the reduced array to be non-empty, and does not need a default value. The segment descriptor species the length of each of the logical sub-arrays.

foldSeg' :: forall sh a i. (Shape sh, Elt a, Elt i, IsIntegral i, i ~ EltR i) => (Exp a -> Exp a -> Exp a) -> Exp a -> Acc (Array (sh :. Int) a) -> Acc (Segments i) -> Acc (Array (sh :. Int) a)

Segmented reduction along the innermost dimension of an array. The segment descriptor specifies the starting index (offset) along the innermost dimension to the beginning of each logical sub-array.

The value in the output array at index i is the reduction of values between the indices of the segment descriptor at index i and (i+1).

We have that:

foldSeg f z xs seg  ==  foldSeg' f z xs (scanl (+) 0 seg)

Since: 1.3.0.0

fold1Seg' :: forall sh a i. (Shape sh, Elt a, Elt i, IsIntegral i, i ~ EltR i) => (Exp a -> Exp a -> Exp a) -> Acc (Array (sh :. Int) a) -> Acc (Segments i) -> Acc (Array (sh :. Int) a)

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 offset to the beginning of each of the logical sub-arrays.

Since: 1.3.0.0

Specialised reductions

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

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] :: Matrix 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]

>>> run $ 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)

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] :: Matrix 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]

>>> run $ any even (use mat)
Vector (Z :. 4) [True,True,True,False]

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

Check if all elements along the innermost dimension are True.

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

Check if any element along the innermost dimension is True.

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

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..] :: Matrix Int
>>> run $ sum (use mat)
Vector (Z :. 2) [10,35]

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

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..] :: Matrix Int
>>> run $ product (use mat)
Vector (Z :. 2) [0,15120]

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

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] :: Matrix Int
>>> mat
Matrix (Z :. 3 :. 4)
  [ 1, 4, 3, 8,
    0, 2, 8, 4,
    7, 9, 8, 8]

>>> run $ minimum (use mat)
Vector (Z :. 3) [1,0,7]

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

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] :: Matrix Int
>>> mat
Matrix (Z :. 3 :. 4)
  [ 1, 4, 3, 8,
    0, 2, 8, 4,
    7, 9, 8, 8]

>>> run $ maximum (use mat)
Vector (Z :. 3) [8,8,9]

Scans (prefix sums)

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

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.

>>> let vec = fromList (Z :. 10) [0..] :: Vector Int
>>> run $ scanl (+) 10 (use vec)
Vector (Z :. 11) [10,10,11,13,16,20,25,31,38,46,55]

>>> let mat = fromList (Z :. 4 :. 10) [0..] :: Matrix Int
>>> run $ scanl (+) 0 (use mat)
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 :: forall sh a. (Shape sh, Elt a) => (Exp a -> Exp a -> Exp a) -> Acc (Array (sh :. Int) a) -> Acc (Array (sh :. Int) a)

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

>>> let mat = fromList (Z:.4:.10) [0..] :: Matrix Int
>>> run $ scanl1 (+) (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' :: forall sh a. (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)

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 vec       = fromList (Z:.10) [0..] :: Vector Int
>>> let (res,sum) = run $ scanl' (+) 0 (use vec)
>>> res
Vector (Z :. 10) [0,0,1,3,6,10,15,21,28,36]
>>> sum
Scalar Z [45]

>>> let mat        = fromList (Z:.4:.10) [0..] :: Matrix Int
>>> let (res,sums) = run $ scanl' (+) 0 (use mat)
>>> 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 :: forall sh a. (Shape sh, Elt a) => (Exp a -> Exp a -> Exp a) -> Exp a -> Acc (Array (sh :. Int) a) -> Acc (Array (sh :. Int) a)

Right-to-left variant of scanl.

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

Right-to-left variant of scanl1.

scanr' :: forall sh a. (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)

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)

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] :: Vector Int
>>> run $ 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)

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] :: Vector Int
>>> run $ 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)

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)

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)

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] :: Segments Int
>>> seg
Vector (Z :. 4) [1,4,0,3]

>>> let mat = fromList (Z:.5:.10) [0..] :: Matrix 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]

>>> run $ 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)

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] :: Segments Int
>>> seg
Vector (Z :. 4) [1,4,0,3]

>>> let mat = fromList (Z:.5:.10) [0..] :: Matrix 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]

>>> run $ 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)

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] :: Segments Int
>>> seg
Vector (Z :. 4) [1,4,0,3]

>>> let mat = fromList (Z:.5:.10) [0..] :: Matrix 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 (res,sums) = run $ 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)

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)

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)

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] :: Segments Int
>>> seg
Vector (Z :. 4) [1,4,0,3]

>>> let mat = fromList (Z:.5:.10) [0..] :: Matrix 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]

>>> run $ 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)

Segmented version of scanr1.

>>> let seg = fromList (Z:.4) [1,4,0,3] :: Segments Int
>>> seg
Vector (Z :. 4) [1,4,0,3]

>>> let mat = fromList (Z:.5:.10) [0..] :: Matrix 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]

>>> run $ 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)

Segmented version of scanr'.

>>> let seg = fromList (Z:.4) [1,4,0,3] :: Segments Int
>>> seg
Vector (Z :. 4) [1,4,0,3]

>>> let mat = fromList (Z:.5:.10) [0..] :: Matrix 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 (res,sums) = run $ 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)

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)

Segmented version of postscanr.

Stencils

stencil

Arguments

:: forall sh stencil a b. (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 (Matrix a) -> Acc (Matrix a)
blur = stencil (convolve5x1 gaussian) clamp
     . stencil (convolve1x5 gaussian) clamp

Note:

Since accelerate-1.3.0.0, we allow the source array to fuse into the stencil operation. However, since a stencil computation (typically) requires multiple values from the source array, this means that the work of the fused operation will be duplicated for each element in the stencil pattern.

For example, suppose we write:

blur . map f

The operation f will be fused into each element of the first Gaussian blur kernel, resulting in a stencil equivalent to:

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

This duplication is often beneficial, however you may choose to instead force the array to be evaluated first, preventing fusion, using the compute operation. Benchmarking should reveal which approach is best for your application.

stencil2

Arguments

:: forall sh stencil1 stencil2 a b c. (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 Stencil sh e stencil

Minimal complete definition

stencilR, stencilPrj

Instances

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

Defined in Data.Array.Accelerate.Smart

Associated Types

type StencilR DIM1 (Exp e, Exp e, Exp e)

Methods

stencilR :: StencilR (EltR DIM1) (EltR e) (StencilR DIM1 (Exp e, Exp e, Exp e))

stencilPrj :: SmartExp (StencilR 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)

Defined in Data.Array.Accelerate.Smart

Associated Types

type StencilR DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e)

Methods

stencilR :: StencilR (EltR DIM1) (EltR e) (StencilR DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e))

stencilPrj :: SmartExp (StencilR 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)

Defined in Data.Array.Accelerate.Smart

Associated Types

type StencilR DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e)

Methods

stencilR :: StencilR (EltR DIM1) (EltR e) (StencilR DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e))

stencilPrj :: SmartExp (StencilR 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)

Defined in Data.Array.Accelerate.Smart

Associated Types

type StencilR DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e)

Methods

stencilR :: StencilR (EltR DIM1) (EltR e) (StencilR DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e))

stencilPrj :: SmartExp (StencilR 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)

Defined in Data.Array.Accelerate.Smart

Associated Types

type StencilR ((sh :. Int) :. Int) (row2, row1, row0)

Methods

stencilR :: StencilR (EltR ((sh :. Int) :. Int)) (EltR a) (StencilR ((sh :. Int) :. Int) (row2, row1, row0))

stencilPrj :: SmartExp (StencilR ((sh :. Int) :. Int) (row2, row1, row0)) -> (row2, row1, row0)

(Stencil (sh :. Int) a row4, Stencil (sh :. Int) a row3, Stencil (sh :. Int) a row2, Stencil (sh :. Int) a row1, Stencil (sh :. Int) a row0) => Stencil ((sh :. Int) :. Int) a (row4, row3, row2, row1, row0)

Defined in Data.Array.Accelerate.Smart

Associated Types

type StencilR ((sh :. Int) :. Int) (row4, row3, row2, row1, row0)

Methods

stencilR :: StencilR (EltR ((sh :. Int) :. Int)) (EltR a) (StencilR ((sh :. Int) :. Int) (row4, row3, row2, row1, row0))

stencilPrj :: SmartExp (StencilR ((sh :. Int) :. Int) (row4, row3, row2, row1, row0)) -> (row4, row3, row2, row1, row0)

(Stencil (sh :. Int) a row6, Stencil (sh :. Int) a row5, Stencil (sh :. Int) a row4, Stencil (sh :. Int) a row3, Stencil (sh :. Int) a row2, Stencil (sh :. Int) a row1, Stencil (sh :. Int) a row0) => Stencil ((sh :. Int) :. Int) a (row6, row5, row4, row3, row2, row1, row0)

Defined in Data.Array.Accelerate.Smart

Associated Types

type StencilR ((sh :. Int) :. Int) (row6, row5, row4, row3, row2, row1, row0)

Methods

stencilR :: StencilR (EltR ((sh :. Int) :. Int)) (EltR a) (StencilR ((sh :. Int) :. Int) (row6, row5, row4, row3, row2, row1, row0))

stencilPrj :: SmartExp (StencilR ((sh :. Int) :. Int) (row6, row5, row4, row3, row2, row1, row0)) -> (row6, row5, row4, row3, row2, row1, row0)

(Stencil (sh :. Int) a row8, Stencil (sh :. Int) a row7, Stencil (sh :. Int) a row6, Stencil (sh :. Int) a row5, Stencil (sh :. Int) a row4, Stencil (sh :. Int) a row3, Stencil (sh :. Int) a row2, Stencil (sh :. Int) a row1, Stencil (sh :. Int) a row0) => Stencil ((sh :. Int) :. Int) a (row8, row7, row6, row5, row4, row3, row2, row1, row0)

Defined in Data.Array.Accelerate.Smart

Associated Types

type StencilR ((sh :. Int) :. Int) (row8, row7, row6, row5, row4, row3, row2, row1, row0)

Methods

stencilR :: StencilR (EltR ((sh :. Int) :. Int)) (EltR a) (StencilR ((sh :. Int) :. Int) (row8, row7, row6, row5, row4, row3, row2, row1, row0))

stencilPrj :: SmartExp (StencilR ((sh :. Int) :. Int) (row8, row7, row6, row5, row4, row3, row2, row1, row0)) -> (row8, row7, row6, row5, row4, row3, row2, row1, row0)

data Boundary t

Boundary condition specification for stencil operations

clamp :: Boundary (Array sh e)

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)

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)

Stencil boundary condition where coordinates beyond the array extent instead wrap around the array (circular boundary conditions).

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 :: forall sh e. (Shape sh, Elt e) => (Exp sh -> Exp e) -> Boundary (Array sh e)

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

The function is passed the out-of-bounds index, so you can use it to specify different boundary conditions at each side. For example, the following would clamp out-of-bounds elements in the y-direction to zero, while having circular boundary conditions in the x-direction.

ring :: Acc (Matrix Float) -> Acc (Matrix Float)
ring xs = stencil f boundary xs
  where
    boundary :: Boundary (Matrix Float)
    boundary = function $ \(unlift -> Z :. y :. x) ->
      if y < 0 || y >= height
        then 0
        else if x < 0
               then xs ! index2 y (width+x)
               else xs ! index2 y (x-width)

    f :: Stencil3x3 Float -> Exp Float
    f = ...

    Z :. height :. width = unlift (shape xs)

Common stencil patterns

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

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

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

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

type Stencil3x3 a = (Stencil3 a, Stencil3 a, Stencil3 a)

type Stencil5x3 a = (Stencil5 a, Stencil5 a, Stencil5 a)

type Stencil3x5 a = (Stencil3 a, Stencil3 a, Stencil3 a, Stencil3 a, Stencil3 a)

type Stencil5x5 a = (Stencil5 a, Stencil5 a, Stencil5 a, Stencil5 a, Stencil5 a)

type Stencil3x3x3 a = (Stencil3x3 a, Stencil3x3 a, Stencil3x3 a)

type Stencil5x3x3 a = (Stencil5x3 a, Stencil5x3 a, Stencil5x3 a)

type Stencil3x5x3 a = (Stencil3x5 a, Stencil3x5 a, Stencil3x5 a)

type Stencil3x3x5 a = (Stencil3x3 a, Stencil3x3 a, Stencil3x3 a, Stencil3x3 a, Stencil3x3 a)

type Stencil5x5x3 a = (Stencil5x5 a, Stencil5x5 a, Stencil5x5 a)

type Stencil5x3x5 a = (Stencil5x3 a, Stencil5x3 a, Stencil5x3 a, Stencil5x3 a, Stencil5x3 a)

type Stencil3x5x5 a = (Stencil3x5 a, Stencil3x5 a, Stencil3x5 a, Stencil3x5 a, Stencil3x5 a)

type Stencil5x5x5 a = (Stencil5x5 a, Stencil5x5 a, Stencil5x5 a, Stencil5x5 a, Stencil5x5 a)

The Accelerate Expression Language

Scalar data types

data Exp t

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

Defined in Data.Array.Accelerate.Prelude

Associated Types

type EltT Exp a

Methods

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

Unlift Exp ()

Defined in Data.Array.Accelerate.Lift

Methods

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

Unlift Exp Z

Defined in Data.Array.Accelerate.Lift

Methods

unlift :: Exp (Plain Z) -> Z

Lift Exp Bool

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain Bool

Methods

lift :: Bool -> Exp (Plain Bool)

Lift Exp Char

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain Char

Methods

lift :: Char -> Exp (Plain Char)

Lift Exp Double

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain Double

Methods

lift :: Double -> Exp (Plain Double)

Lift Exp Float

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain Float

Methods

lift :: Float -> Exp (Plain Float)

Lift Exp Int

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain Int

Methods

lift :: Int -> Exp (Plain Int)

Lift Exp Int8

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain Int8

Methods

lift :: Int8 -> Exp (Plain Int8)

Lift Exp Int16

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain Int16

Methods

lift :: Int16 -> Exp (Plain Int16)

Lift Exp Int32

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain Int32

Methods

lift :: Int32 -> Exp (Plain Int32)

Lift Exp Int64

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain Int64

Methods

lift :: Int64 -> Exp (Plain Int64)

Lift Exp Word

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain Word

Methods

lift :: Word -> Exp (Plain Word)

Lift Exp Word8

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain Word8

Methods

lift :: Word8 -> Exp (Plain Word8)

Lift Exp Word16

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain Word16

Methods

lift :: Word16 -> Exp (Plain Word16)

Lift Exp Word32

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain Word32

Methods

lift :: Word32 -> Exp (Plain Word32)

Lift Exp Word64

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain Word64

Methods

lift :: Word64 -> Exp (Plain Word64)

Lift Exp ()

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain ()

Methods

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

Lift Exp CChar

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain CChar

Methods

lift :: CChar -> Exp (Plain CChar)

Lift Exp CSChar

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain CSChar

Methods

lift :: CSChar -> Exp (Plain CSChar)

Lift Exp CUChar

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain CUChar

Methods

lift :: CUChar -> Exp (Plain CUChar)

Lift Exp CShort

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain CShort

Methods

lift :: CShort -> Exp (Plain CShort)

Lift Exp CUShort

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain CUShort

Methods

lift :: CUShort -> Exp (Plain CUShort)

Lift Exp CInt

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain CInt

Methods

lift :: CInt -> Exp (Plain CInt)

Lift Exp CUInt

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain CUInt

Methods

lift :: CUInt -> Exp (Plain CUInt)

Lift Exp CLong

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain CLong

Methods

lift :: CLong -> Exp (Plain CLong)

Lift Exp CULong

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain CULong

Methods

lift :: CULong -> Exp (Plain CULong)

Lift Exp CLLong

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain CLLong

Methods

lift :: CLLong -> Exp (Plain CLLong)

Lift Exp CULLong

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain CULLong

Methods

lift :: CULLong -> Exp (Plain CULLong)

Lift Exp CFloat

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain CFloat

Methods

lift :: CFloat -> Exp (Plain CFloat)

Lift Exp CDouble

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain CDouble

Methods

lift :: CDouble -> Exp (Plain CDouble)

Lift Exp Half

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain Half

Methods

lift :: Half -> Exp (Plain Half)

Lift Exp Z

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain Z

Methods

lift :: Z -> Exp (Plain Z)

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

Defined in Data.Array.Accelerate.Smart

Associated Types

type StencilR DIM1 (Exp e, Exp e, Exp e)

Methods

stencilR :: StencilR (EltR DIM1) (EltR e) (StencilR DIM1 (Exp e, Exp e, Exp e))

stencilPrj :: SmartExp (StencilR 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)

Defined in Data.Array.Accelerate.Smart

Associated Types

type StencilR DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e)

Methods

stencilR :: StencilR (EltR DIM1) (EltR e) (StencilR DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e))

stencilPrj :: SmartExp (StencilR 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)

Defined in Data.Array.Accelerate.Smart

Associated Types

type StencilR DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e)

Methods

stencilR :: StencilR (EltR DIM1) (EltR e) (StencilR DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e))

stencilPrj :: SmartExp (StencilR 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)

Defined in Data.Array.Accelerate.Smart

Associated Types

type StencilR DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e)

Methods

stencilR :: StencilR (EltR DIM1) (EltR e) (StencilR DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e))

stencilPrj :: SmartExp (StencilR 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 a => Unlift Exp (Complex (Exp a))

Defined in Data.Array.Accelerate.Data.Complex

Methods

unlift :: Exp (Plain (Complex (Exp a))) -> Complex (Exp a)

Elt a => Unlift Exp (Min (Exp a))

Defined in Data.Array.Accelerate.Data.Semigroup

Methods

unlift :: Exp (Plain (Min (Exp a))) -> Min (Exp a)

Elt a => Unlift Exp (Max (Exp a))

Defined in Data.Array.Accelerate.Data.Semigroup

Methods

unlift :: Exp (Plain (Max (Exp a))) -> Max (Exp a)

Elt a => Unlift Exp (Sum (Exp a))

Defined in Data.Array.Accelerate.Data.Monoid

Methods

unlift :: Exp (Plain (Sum (Exp a))) -> Sum (Exp a)

Elt a => Unlift Exp (Product (Exp a))

Defined in Data.Array.Accelerate.Data.Monoid

Methods

unlift :: Exp (Plain (Product (Exp a))) -> Product (Exp a)

Unlift Exp (Exp e)

Defined in Data.Array.Accelerate.Lift

Methods

unlift :: Exp (Plain (Exp e)) -> Exp e

(Lift Exp a, Elt (Plain a)) => Lift Exp (Maybe a)

Defined in Data.Array.Accelerate.Data.Maybe

Associated Types

type Plain (Maybe a)

Methods

lift :: Maybe a -> Exp (Plain (Maybe a))

(Lift Exp a, Elt (Plain a)) => Lift Exp (Complex a)

Defined in Data.Array.Accelerate.Data.Complex

Associated Types

type Plain (Complex a)

Methods

lift :: Complex a -> Exp (Plain (Complex a))

(Lift Exp a, Elt (Plain a)) => Lift Exp (Min a)

Defined in Data.Array.Accelerate.Data.Semigroup

Associated Types

type Plain (Min a)

Methods

lift :: Min a -> Exp (Plain (Min a))

(Lift Exp a, Elt (Plain a)) => Lift Exp (Max a)

Defined in Data.Array.Accelerate.Data.Semigroup

Associated Types

type Plain (Max a)

Methods

lift :: Max a -> Exp (Plain (Max a))

(Lift Exp a, Elt (Plain a)) => Lift Exp (Sum a)

Defined in Data.Array.Accelerate.Data.Monoid

Associated Types

type Plain (Sum a)

Methods

lift :: Sum a -> Exp (Plain (Sum a))

(Lift Exp a, Elt (Plain a)) => Lift Exp (Product a)

Defined in Data.Array.Accelerate.Data.Monoid

Associated Types

type Plain (Product a)

Methods

lift :: Product a -> Exp (Plain (Product a))

(Shape sh, Elt (Any sh)) => Lift Exp (Any sh)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (Any sh)

Methods

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

Lift Exp (Exp e)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (Exp e)

Methods

lift :: Exp e -> Exp (Plain (Exp e))

(Elt x0, Elt x1) => Unlift Exp (Exp x0, Exp x1)

Defined in Data.Array.Accelerate.Lift

Methods

unlift :: Exp (Plain (Exp x0, Exp x1)) -> (Exp x0, Exp x1)

(Elt e, Elt (Plain ix), Unlift Exp ix) => Unlift Exp (ix :. Exp e)

Defined in Data.Array.Accelerate.Lift

Methods

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

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

Defined in Data.Array.Accelerate.Lift

Methods

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

(Lift Exp a, Lift Exp b, Elt (Plain a), Elt (Plain b)) => Lift Exp (Either a b)

Defined in Data.Array.Accelerate.Data.Either

Associated Types

type Plain (Either a b)

Methods

lift :: Either a b -> Exp (Plain (Either a b))

((Lift Exp x0, Lift Exp x1), (Elt (Plain x0), Elt (Plain x1))) => Lift Exp (x0, x1)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (x0, x1)

Methods

lift :: (x0, x1) -> Exp (Plain (x0, x1))

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

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (ix :. Exp e)

Methods

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

(Elt (Plain ix), Lift Exp ix) => Lift Exp (ix :. All)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (ix :. All)

Methods

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

(Elt (Plain ix), Lift Exp ix) => Lift Exp (ix :. Int)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (ix :. Int)

Methods

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

(Elt x0, Elt x1, Elt x2) => Unlift Exp (Exp x0, Exp x1, Exp x2)

Defined in Data.Array.Accelerate.Lift

Methods

unlift :: Exp (Plain (Exp x0, Exp x1, Exp x2)) -> (Exp x0, Exp x1, Exp x2)

((Lift Exp x0, Lift Exp x1, Lift Exp x2), (Elt (Plain x0), Elt (Plain x1), Elt (Plain x2))) => Lift Exp (x0, x1, x2)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (x0, x1, x2)

Methods

lift :: (x0, x1, x2) -> Exp (Plain (x0, x1, x2))

(Elt x0, Elt x1, Elt x2, Elt x3) => Unlift Exp (Exp x0, Exp x1, Exp x2, Exp x3)

Defined in Data.Array.Accelerate.Lift

Methods

unlift :: Exp (Plain (Exp x0, Exp x1, Exp x2, Exp x3)) -> (Exp x0, Exp x1, Exp x2, Exp x3)

((Lift Exp x0, Lift Exp x1, Lift Exp x2, Lift Exp x3), (Elt (Plain x0), Elt (Plain x1), Elt (Plain x2), Elt (Plain x3))) => Lift Exp (x0, x1, x2, x3)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (x0, x1, x2, x3)

Methods

lift :: (x0, x1, x2, x3) -> Exp (Plain (x0, x1, x2, x3))

(Elt x0, Elt x1, Elt x2, Elt x3, Elt x4) => Unlift Exp (Exp x0, Exp x1, Exp x2, Exp x3, Exp x4)

Defined in Data.Array.Accelerate.Lift

Methods

unlift :: Exp (Plain (Exp x0, Exp x1, Exp x2, Exp x3, Exp x4)) -> (Exp x0, Exp x1, Exp x2, Exp x3, Exp x4)

((Lift Exp x0, Lift Exp x1, Lift Exp x2, Lift Exp x3, Lift Exp x4), (Elt (Plain x0), Elt (Plain x1), Elt (Plain x2), Elt (Plain x3), Elt (Plain x4))) => Lift Exp (x0, x1, x2, x3, x4)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (x0, x1, x2, x3, x4)

Methods

lift :: (x0, x1, x2, x3, x4) -> Exp (Plain (x0, x1, x2, x3, x4))

(Elt x0, Elt x1, Elt x2, Elt x3, Elt x4, Elt x5) => Unlift Exp (Exp x0, Exp x1, Exp x2, Exp x3, Exp x4, Exp x5)

Defined in Data.Array.Accelerate.Lift

Methods

unlift :: Exp (Plain (Exp x0, Exp x1, Exp x2, Exp x3, Exp x4, Exp x5)) -> (Exp x0, Exp x1, Exp x2, Exp x3, Exp x4, Exp x5)

((Lift Exp x0, Lift Exp x1, Lift Exp x2, Lift Exp x3, Lift Exp x4, Lift Exp x5), (Elt (Plain x0), Elt (Plain x1), Elt (Plain x2), Elt (Plain x3), Elt (Plain x4), Elt (Plain x5))) => Lift Exp (x0, x1, x2, x3, x4, x5)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (x0, x1, x2, x3, x4, x5)

Methods

lift :: (x0, x1, x2, x3, x4, x5) -> Exp (Plain (x0, x1, x2, x3, x4, x5))

(Elt x0, Elt x1, Elt x2, Elt x3, Elt x4, Elt x5, Elt x6) => Unlift Exp (Exp x0, Exp x1, Exp x2, Exp x3, Exp x4, Exp x5, Exp x6)

Defined in Data.Array.Accelerate.Lift

Methods

unlift :: Exp (Plain (Exp x0, Exp x1, Exp x2, Exp x3, Exp x4, Exp x5, Exp x6)) -> (Exp x0, Exp x1, Exp x2, Exp x3, Exp x4, Exp x5, Exp x6)

((Lift Exp x0, Lift Exp x1, Lift Exp x2, Lift Exp x3, Lift Exp x4, Lift Exp x5, Lift Exp x6), (Elt (Plain x0), Elt (Plain x1), Elt (Plain x2), Elt (Plain x3), Elt (Plain x4), Elt (Plain x5), Elt (Plain x6))) => Lift Exp (x0, x1, x2, x3, x4, x5, x6)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (x0, x1, x2, x3, x4, x5, x6)

Methods

lift :: (x0, x1, x2, x3, x4, x5, x6) -> Exp (Plain (x0, x1, x2, x3, x4, x5, x6))

(Elt x0, Elt x1, Elt x2, Elt x3, Elt x4, Elt x5, Elt x6, Elt x7) => Unlift Exp (Exp x0, Exp x1, Exp x2, Exp x3, Exp x4, Exp x5, Exp x6, Exp x7)

Defined in Data.Array.Accelerate.Lift

Methods

unlift :: Exp (Plain (Exp x0, Exp x1, Exp x2, Exp x3, Exp x4, Exp x5, Exp x6, Exp x7)) -> (Exp x0, Exp x1, Exp x2, Exp x3, Exp x4, Exp x5, Exp x6, Exp x7)

((Lift Exp x0, Lift Exp x1, Lift Exp x2, Lift Exp x3, Lift Exp x4, Lift Exp x5, Lift Exp x6, Lift Exp x7), (Elt (Plain x0), Elt (Plain x1), Elt (Plain x2), Elt (Plain x3), Elt (Plain x4), Elt (Plain x5), Elt (Plain x6), Elt (Plain x7))) => Lift Exp (x0, x1, x2, x3, x4, x5, x6, x7)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (x0, x1, x2, x3, x4, x5, x6, x7)

Methods

lift :: (x0, x1, x2, x3, x4, x5, x6, x7) -> Exp (Plain (x0, x1, x2, x3, x4, x5, x6, x7))

(Elt x0, Elt x1, Elt x2, Elt x3, Elt x4, Elt x5, Elt x6, Elt x7, Elt x8) => Unlift Exp (Exp x0, Exp x1, Exp x2, Exp x3, Exp x4, Exp x5, Exp x6, Exp x7, Exp x8)

Defined in Data.Array.Accelerate.Lift

Methods

unlift :: Exp (Plain (Exp x0, Exp x1, Exp x2, Exp x3, Exp x4, Exp x5, Exp x6, Exp x7, Exp x8)) -> (Exp x0, Exp x1, Exp x2, Exp x3, Exp x4, Exp x5, Exp x6, Exp x7, Exp x8)

((Lift Exp x0, Lift Exp x1, Lift Exp x2, Lift Exp x3, Lift Exp x4, Lift Exp x5, Lift Exp x6, Lift Exp x7, Lift Exp x8), (Elt (Plain x0), Elt (Plain x1), Elt (Plain x2), Elt (Plain x3), Elt (Plain x4), Elt (Plain x5), Elt (Plain x6), Elt (Plain x7), Elt (Plain x8))) => Lift Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (x0, x1, x2, x3, x4, x5, x6, x7, x8)

Methods

lift :: (x0, x1, x2, x3, x4, x5, x6, x7, x8) -> Exp (Plain (x0, x1, x2, x3, x4, x5, x6, x7, x8))

(Elt x0, Elt x1, Elt x2, Elt x3, Elt x4, Elt x5, Elt x6, Elt x7, Elt x8, Elt x9) => Unlift Exp (Exp x0, Exp x1, Exp x2, Exp x3, Exp x4, Exp x5, Exp x6, Exp x7, Exp x8, Exp x9)

Defined in Data.Array.Accelerate.Lift

Methods

unlift :: Exp (Plain (Exp x0, Exp x1, Exp x2, Exp x3, Exp x4, Exp x5, Exp x6, Exp x7, Exp x8, Exp x9)) -> (Exp x0, Exp x1, Exp x2, Exp x3, Exp x4, Exp x5, Exp x6, Exp x7, Exp x8, Exp x9)

((Lift Exp x0, Lift Exp x1, Lift Exp x2, Lift Exp x3, Lift Exp x4, Lift Exp x5, Lift Exp x6, Lift Exp x7, Lift Exp x8, Lift Exp x9), (Elt (Plain x0), Elt (Plain x1), Elt (Plain x2), Elt (Plain x3), Elt (Plain x4), Elt (Plain x5), Elt (Plain x6), Elt (Plain x7), Elt (Plain x8), Elt (Plain x9))) => Lift Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9)

Methods

lift :: (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9) -> Exp (Plain (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9))

(Elt x0, Elt x1, Elt x2, Elt x3, Elt x4, Elt x5, Elt x6, Elt x7, Elt x8, Elt x9, Elt x10) => Unlift Exp (Exp x0, Exp x1, Exp x2, Exp x3, Exp x4, Exp x5, Exp x6, Exp x7, Exp x8, Exp x9, Exp x10)

Defined in Data.Array.Accelerate.Lift

Methods

unlift :: Exp (Plain (Exp x0, Exp x1, Exp x2, Exp x3, Exp x4, Exp x5, Exp x6, Exp x7, Exp x8, Exp x9, Exp x10)) -> (Exp x0, Exp x1, Exp x2, Exp x3, Exp x4, Exp x5, Exp x6, Exp x7, Exp x8, Exp x9, Exp x10)

((Lift Exp x0, Lift Exp x1, Lift Exp x2, Lift Exp x3, Lift Exp x4, Lift Exp x5, Lift Exp x6, Lift Exp x7, Lift Exp x8, Lift Exp x9, Lift Exp x10), (Elt (Plain x0), Elt (Plain x1), Elt (Plain x2), Elt (Plain x3), Elt (Plain x4), Elt (Plain x5), Elt (Plain x6), Elt (Plain x7), Elt (Plain x8), Elt (Plain x9), Elt (Plain x10))) => Lift Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)

Methods

lift :: (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10) -> Exp (Plain (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10))

(Elt x0, Elt x1, Elt x2, Elt x3, Elt x4, Elt x5, Elt x6, Elt x7, Elt x8, Elt x9, Elt x10, Elt x11) => Unlift Exp (Exp x0, Exp x1, Exp x2, Exp x3, Exp x4, Exp x5, Exp x6, Exp x7, Exp x8, Exp x9, Exp x10, Exp x11)

Defined in Data.Array.Accelerate.Lift

Methods

unlift :: Exp (Plain (Exp x0, Exp x1, Exp x2, Exp x3, Exp x4, Exp x5, Exp x6, Exp x7, Exp x8, Exp x9, Exp x10, Exp x11)) -> (Exp x0, Exp x1, Exp x2, Exp x3, Exp x4, Exp x5, Exp x6, Exp x7, Exp x8, Exp x9, Exp x10, Exp x11)

((Lift Exp x0, Lift Exp x1, Lift Exp x2, Lift Exp x3, Lift Exp x4, Lift Exp x5, Lift Exp x6, Lift Exp x7, Lift Exp x8, Lift Exp x9, Lift Exp x10, Lift Exp x11), (Elt (Plain x0), Elt (Plain x1), Elt (Plain x2), Elt (Plain x3), Elt (Plain x4), Elt (Plain x5), Elt (Plain x6), Elt (Plain x7), Elt (Plain x8), Elt (Plain x9), Elt (Plain x10), Elt (Plain x11))) => Lift Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)

Methods

lift :: (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11) -> Exp (Plain (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11))

(Elt x0, Elt x1, Elt x2, Elt x3, Elt x4, Elt x5, Elt x6, Elt x7, Elt x8, Elt x9, Elt x10, Elt x11, Elt x12) => Unlift Exp (Exp x0, Exp x1, Exp x2, Exp x3, Exp x4, Exp x5, Exp x6, Exp x7, Exp x8, Exp x9, Exp x10, Exp x11, Exp x12)

Defined in Data.Array.Accelerate.Lift

Methods

unlift :: Exp (Plain (Exp x0, Exp x1, Exp x2, Exp x3, Exp x4, Exp x5, Exp x6, Exp x7, Exp x8, Exp x9, Exp x10, Exp x11, Exp x12)) -> (Exp x0, Exp x1, Exp x2, Exp x3, Exp x4, Exp x5, Exp x6, Exp x7, Exp x8, Exp x9, Exp x10, Exp x11, Exp x12)

((Lift Exp x0, Lift Exp x1, Lift Exp x2, Lift Exp x3, Lift Exp x4, Lift Exp x5, Lift Exp x6, Lift Exp x7, Lift Exp x8, Lift Exp x9, Lift Exp x10, Lift Exp x11, Lift Exp x12), (Elt (Plain x0), Elt (Plain x1), Elt (Plain x2), Elt (Plain x3), Elt (Plain x4), Elt (Plain x5), Elt (Plain x6), Elt (Plain x7), Elt (Plain x8), Elt (Plain x9), Elt (Plain x10), Elt (Plain x11), Elt (Plain x12))) => Lift Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12)

Methods

lift :: (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12) -> Exp (Plain (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12))

(Elt x0, Elt x1, Elt x2, Elt x3, Elt x4, Elt x5, Elt x6, Elt x7, Elt x8, Elt x9, Elt x10, Elt x11, Elt x12, Elt x13) => Unlift Exp (Exp x0, Exp x1, Exp x2, Exp x3, Exp x4, Exp x5, Exp x6, Exp x7, Exp x8, Exp x9, Exp x10, Exp x11, Exp x12, Exp x13)

Defined in Data.Array.Accelerate.Lift

Methods

unlift :: Exp (Plain (Exp x0, Exp x1, Exp x2, Exp x3, Exp x4, Exp x5, Exp x6, Exp x7, Exp x8, Exp x9, Exp x10, Exp x11, Exp x12, Exp x13)) -> (Exp x0, Exp x1, Exp x2, Exp x3, Exp x4, Exp x5, Exp x6, Exp x7, Exp x8, Exp x9, Exp x10, Exp x11, Exp x12, Exp x13)

((Lift Exp x0, Lift Exp x1, Lift Exp x2, Lift Exp x3, Lift Exp x4, Lift Exp x5, Lift Exp x6, Lift Exp x7, Lift Exp x8, Lift Exp x9, Lift Exp x10, Lift Exp x11, Lift Exp x12, Lift Exp x13), (Elt (Plain x0), Elt (Plain x1), Elt (Plain x2), Elt (Plain x3), Elt (Plain x4), Elt (Plain x5), Elt (Plain x6), Elt (Plain x7), Elt (Plain x8), Elt (Plain x9), Elt (Plain x10), Elt (Plain x11), Elt (Plain x12), Elt (Plain x13))) => Lift Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13)

Methods

lift :: (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13) -> Exp (Plain (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13))

(Elt x0, Elt x1, Elt x2, Elt x3, Elt x4, Elt x5, Elt x6, Elt x7, Elt x8, Elt x9, Elt x10, Elt x11, Elt x12, Elt x13, Elt x14) => Unlift Exp (Exp x0, Exp x1, Exp x2, Exp x3, Exp x4, Exp x5, Exp x6, Exp x7, Exp x8, Exp x9, Exp x10, Exp x11, Exp x12, Exp x13, Exp x14)

Defined in Data.Array.Accelerate.Lift

Methods

unlift :: Exp (Plain (Exp x0, Exp x1, Exp x2, Exp x3, Exp x4, Exp x5, Exp x6, Exp x7, Exp x8, Exp x9, Exp x10, Exp x11, Exp x12, Exp x13, Exp x14)) -> (Exp x0, Exp x1, Exp x2, Exp x3, Exp x4, Exp x5, Exp x6, Exp x7, Exp x8, Exp x9, Exp x10, Exp x11, Exp x12, Exp x13, Exp x14)

((Lift Exp x0, Lift Exp x1, Lift Exp x2, Lift Exp x3, Lift Exp x4, Lift Exp x5, Lift Exp x6, Lift Exp x7, Lift Exp x8, Lift Exp x9, Lift Exp x10, Lift Exp x11, Lift Exp x12, Lift Exp x13, Lift Exp x14), (Elt (Plain x0), Elt (Plain x1), Elt (Plain x2), Elt (Plain x3), Elt (Plain x4), Elt (Plain x5), Elt (Plain x6), Elt (Plain x7), Elt (Plain x8), Elt (Plain x9), Elt (Plain x10), Elt (Plain x11), Elt (Plain x12), Elt (Plain x13), Elt (Plain x14))) => Lift Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14)

Methods

lift :: (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14) -> Exp (Plain (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14))

(Elt x0, Elt x1, Elt x2, Elt x3, Elt x4, Elt x5, Elt x6, Elt x7, Elt x8, Elt x9, Elt x10, Elt x11, Elt x12, Elt x13, Elt x14, Elt x15) => Unlift Exp (Exp x0, Exp x1, Exp x2, Exp x3, Exp x4, Exp x5, Exp x6, Exp x7, Exp x8, Exp x9, Exp x10, Exp x11, Exp x12, Exp x13, Exp x14, Exp x15)

Defined in Data.Array.Accelerate.Lift

Methods

unlift :: Exp (Plain (Exp x0, Exp x1, Exp x2, Exp x3, Exp x4, Exp x5, Exp x6, Exp x7, Exp x8, Exp x9, Exp x10, Exp x11, Exp x12, Exp x13, Exp x14, Exp x15)) -> (Exp x0, Exp x1, Exp x2, Exp x3, Exp x4, Exp x5, Exp x6, Exp x7, Exp x8, Exp x9, Exp x10, Exp x11, Exp x12, Exp x13, Exp x14, Exp x15)

((Lift Exp x0, Lift Exp x1, Lift Exp x2, Lift Exp x3, Lift Exp x4, Lift Exp x5, Lift Exp x6, Lift Exp x7, Lift Exp x8, Lift Exp x9, Lift Exp x10, Lift Exp x11, Lift Exp x12, Lift Exp x13, Lift Exp x14, Lift Exp x15), (Elt (Plain x0), Elt (Plain x1), Elt (Plain x2), Elt (Plain x3), Elt (Plain x4), Elt (Plain x5), Elt (Plain x6), Elt (Plain x7), Elt (Plain x8), Elt (Plain x9), Elt (Plain x10), Elt (Plain x11), Elt (Plain x12), Elt (Plain x13), Elt (Plain x14), Elt (Plain x15))) => Lift Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15)

Methods

lift :: (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15) -> Exp (Plain (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15))

Bounded (Exp Bool)

Defined in Data.Array.Accelerate.Classes.Bounded

Methods

minBound :: Exp Bool

maxBound :: Exp Bool

Bounded (Exp Char)

Defined in Data.Array.Accelerate.Classes.Bounded

Methods

minBound :: Exp Char

maxBound :: Exp Char

Bounded (Exp Int)

Defined in Data.Array.Accelerate.Classes.Bounded

Methods

minBound :: Exp Int

maxBound :: Exp Int

Bounded (Exp Int8)

Defined in Data.Array.Accelerate.Classes.Bounded

Methods

minBound :: Exp Int8

maxBound :: Exp Int8

Bounded (Exp Int16)

Defined in Data.Array.Accelerate.Classes.Bounded

Methods

minBound :: Exp Int16

maxBound :: Exp Int16

Bounded (Exp Int32)

Defined in Data.Array.Accelerate.Classes.Bounded

Methods

minBound :: Exp Int32

maxBound :: Exp Int32

Bounded (Exp Int64)

Defined in Data.Array.Accelerate.Classes.Bounded

Methods

minBound :: Exp Int64

maxBound :: Exp Int64

Bounded (Exp Word)

Defined in Data.Array.Accelerate.Classes.Bounded

Methods

minBound :: Exp Word

maxBound :: Exp Word

Bounded (Exp Word8)

Defined in Data.Array.Accelerate.Classes.Bounded

Methods

minBound :: Exp Word8

maxBound :: Exp Word8

Bounded (Exp Word16)

Defined in Data.Array.Accelerate.Classes.Bounded

Methods

minBound :: Exp Word16

maxBound :: Exp Word16

Bounded (Exp Word32)

Defined in Data.Array.Accelerate.Classes.Bounded

Methods

minBound :: Exp Word32

maxBound :: Exp Word32

Bounded (Exp Word64)

Defined in Data.Array.Accelerate.Classes.Bounded

Methods

minBound :: Exp Word64

maxBound :: Exp Word64

Bounded (Exp ())

Defined in Data.Array.Accelerate.Classes.Bounded

Methods

minBound :: Exp ()

maxBound :: Exp ()

(Bounded x0, Bounded x1) => Bounded (Exp (x0, x1))

Defined in Data.Array.Accelerate.Classes.Bounded

Methods

minBound :: Exp (x0, x1)

maxBound :: Exp (x0, x1)

(Bounded x0, Bounded x1, Bounded x2) => Bounded (Exp (x0, x1, x2))

Defined in Data.Array.Accelerate.Classes.Bounded

Methods

minBound :: Exp (x0, x1, x2)

maxBound :: Exp (x0, x1, x2)

(Bounded x0, Bounded x1, Bounded x2, Bounded x3) => Bounded (Exp (x0, x1, x2, x3))

Defined in Data.Array.Accelerate.Classes.Bounded

Methods

minBound :: Exp (x0, x1, x2, x3)

maxBound :: Exp (x0, x1, x2, x3)

(Bounded x0, Bounded x1, Bounded x2, Bounded x3, Bounded x4) => Bounded (Exp (x0, x1, x2, x3, x4))

Defined in Data.Array.Accelerate.Classes.Bounded

Methods

minBound :: Exp (x0, x1, x2, x3, x4)

maxBound :: Exp (x0, x1, x2, x3, x4)

(Bounded x0, Bounded x1, Bounded x2, Bounded x3, Bounded x4, Bounded x5) => Bounded (Exp (x0, x1, x2, x3, x4, x5))

Defined in Data.Array.Accelerate.Classes.Bounded

Methods

minBound :: Exp (x0, x1, x2, x3, x4, x5)

maxBound :: Exp (x0, x1, x2, x3, x4, x5)

(Bounded x0, Bounded x1, Bounded x2, Bounded x3, Bounded x4, Bounded x5, Bounded x6) => Bounded (Exp (x0, x1, x2, x3, x4, x5, x6))

Defined in Data.Array.Accelerate.Classes.Bounded

Methods

minBound :: Exp (x0, x1, x2, x3, x4, x5, x6)

maxBound :: Exp (x0, x1, x2, x3, x4, x5, x6)

(Bounded x0, Bounded x1, Bounded x2, Bounded x3, Bounded x4, Bounded x5, Bounded x6, Bounded x7) => Bounded (Exp (x0, x1, x2, x3, x4, x5, x6, x7))

Defined in Data.Array.Accelerate.Classes.Bounded

Methods

minBound :: Exp (x0, x1, x2, x3, x4, x5, x6, x7)

maxBound :: Exp (x0, x1, x2, x3, x4, x5, x6, x7)

(Bounded x0, Bounded x1, Bounded x2, Bounded x3, Bounded x4, Bounded x5, Bounded x6, Bounded x7, Bounded x8) => Bounded (Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8))

Defined in Data.Array.Accelerate.Classes.Bounded

Methods

minBound :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8)

maxBound :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8)

(Bounded x0, Bounded x1, Bounded x2, Bounded x3, Bounded x4, Bounded x5, Bounded x6, Bounded x7, Bounded x8, Bounded x9) => Bounded (Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9))

Defined in Data.Array.Accelerate.Classes.Bounded

Methods

minBound :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9)

maxBound :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9)

(Bounded x0, Bounded x1, Bounded x2, Bounded x3, Bounded x4, Bounded x5, Bounded x6, Bounded x7, Bounded x8, Bounded x9, Bounded x10) => Bounded (Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10))

Defined in Data.Array.Accelerate.Classes.Bounded

Methods

minBound :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)

maxBound :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)

(Bounded x0, Bounded x1, Bounded x2, Bounded x3, Bounded x4, Bounded x5, Bounded x6, Bounded x7, Bounded x8, Bounded x9, Bounded x10, Bounded x11) => Bounded (Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11))

Defined in Data.Array.Accelerate.Classes.Bounded

Methods

minBound :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)

maxBound :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)

(Bounded x0, Bounded x1, Bounded x2, Bounded x3, Bounded x4, Bounded x5, Bounded x6, Bounded x7, Bounded x8, Bounded x9, Bounded x10, Bounded x11, Bounded x12) => Bounded (Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12))

Defined in Data.Array.Accelerate.Classes.Bounded

Methods

minBound :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12)

maxBound :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12)

(Bounded x0, Bounded x1, Bounded x2, Bounded x3, Bounded x4, Bounded x5, Bounded x6, Bounded x7, Bounded x8, Bounded x9, Bounded x10, Bounded x11, Bounded x12, Bounded x13) => Bounded (Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13))

Defined in Data.Array.Accelerate.Classes.Bounded

Methods

minBound :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13)

maxBound :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13)

(Bounded x0, Bounded x1, Bounded x2, Bounded x3, Bounded x4, Bounded x5, Bounded x6, Bounded x7, Bounded x8, Bounded x9, Bounded x10, Bounded x11, Bounded x12, Bounded x13, Bounded x14) => Bounded (Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14))

Defined in Data.Array.Accelerate.Classes.Bounded

Methods

minBound :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14)

maxBound :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14)

(Bounded x0, Bounded x1, Bounded x2, Bounded x3, Bounded x4, Bounded x5, Bounded x6, Bounded x7, Bounded x8, Bounded x9, Bounded x10, Bounded x11, Bounded x12, Bounded x13, Bounded x14, Bounded x15) => Bounded (Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15))

Defined in Data.Array.Accelerate.Classes.Bounded

Methods

minBound :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15)

maxBound :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15)

Bounded a => Bounded (Exp (Min a))

Defined in Data.Array.Accelerate.Data.Semigroup

Methods

minBound :: Exp (Min a)

maxBound :: Exp (Min a)

Bounded a => Bounded (Exp (Max a))

Defined in Data.Array.Accelerate.Data.Semigroup

Methods

minBound :: Exp (Max a)

maxBound :: Exp (Max a)

Bounded a => Bounded (Exp (Sum a))

Defined in Data.Array.Accelerate.Data.Monoid

Methods

minBound :: Exp (Sum a)

maxBound :: Exp (Sum a)

Bounded a => Bounded (Exp (Product a))

Defined in Data.Array.Accelerate.Data.Monoid

Methods

minBound :: Exp (Product a)

maxBound :: Exp (Product a)

Bounded (Exp CChar)

Defined in Data.Array.Accelerate.Classes.Bounded

Methods

minBound :: Exp CChar

maxBound :: Exp CChar

Bounded (Exp CSChar)

Defined in Data.Array.Accelerate.Classes.Bounded

Methods

minBound :: Exp CSChar

maxBound :: Exp CSChar

Bounded (Exp CUChar)

Defined in Data.Array.Accelerate.Classes.Bounded

Methods

minBound :: Exp CUChar

maxBound :: Exp CUChar

Bounded (Exp CShort)

Defined in Data.Array.Accelerate.Classes.Bounded

Methods

minBound :: Exp CShort

maxBound :: Exp CShort

Bounded (Exp CUShort)

Defined in Data.Array.Accelerate.Classes.Bounded

Methods

minBound :: Exp CUShort

maxBound :: Exp CUShort

Bounded (Exp CInt)

Defined in Data.Array.Accelerate.Classes.Bounded

Methods

minBound :: Exp CInt

maxBound :: Exp CInt

Bounded (Exp CUInt)

Defined in Data.Array.Accelerate.Classes.Bounded

Methods

minBound :: Exp CUInt

maxBound :: Exp CUInt

Bounded (Exp CLong)

Defined in Data.Array.Accelerate.Classes.Bounded

Methods

minBound :: Exp CLong

maxBound :: Exp CLong

Bounded (Exp CULong)

Defined in Data.Array.Accelerate.Classes.Bounded

Methods

minBound :: Exp CULong

maxBound :: Exp CULong

Bounded (Exp CLLong)

Defined in Data.Array.Accelerate.Classes.Bounded

Methods

minBound :: Exp CLLong

maxBound :: Exp CLLong

Bounded (Exp CULLong)

Defined in Data.Array.Accelerate.Classes.Bounded

Methods

minBound :: Exp CULLong

maxBound :: Exp CULLong

Enum (Exp Double)

Defined in Data.Array.Accelerate.Classes.Enum

Methods

succ :: Exp Double -> Exp Double

pred :: Exp Double -> Exp Double

toEnum :: Int -> Exp Double

fromEnum :: Exp Double -> Int

enumFrom :: Exp Double -> [Exp Double]

enumFromThen :: Exp Double -> Exp Double -> [Exp Double]

enumFromTo :: Exp Double -> Exp Double -> [Exp Double]

enumFromThenTo :: Exp Double -> Exp Double -> Exp Double -> [Exp Double]

Enum (Exp Float)

Defined in Data.Array.Accelerate.Classes.Enum

Methods

succ :: Exp Float -> Exp Float

pred :: Exp Float -> Exp Float

toEnum :: Int -> Exp Float

fromEnum :: Exp Float -> Int

enumFrom :: Exp Float -> [Exp Float]

enumFromThen :: Exp Float -> Exp Float -> [Exp Float]

enumFromTo :: Exp Float -> Exp Float -> [Exp Float]

enumFromThenTo :: Exp Float -> Exp Float -> Exp Float -> [Exp Float]

Enum (Exp Int)

Defined in Data.Array.Accelerate.Classes.Enum

Methods

succ :: Exp Int -> Exp Int

pred :: Exp Int -> Exp Int

toEnum :: Int -> Exp Int

fromEnum :: Exp Int -> Int

enumFrom :: Exp Int -> [Exp Int]

enumFromThen :: Exp Int -> Exp Int -> [Exp Int]

enumFromTo :: Exp Int -> Exp Int -> [Exp Int]

enumFromThenTo :: Exp Int -> Exp Int -> Exp Int -> [Exp Int]

Enum (Exp Int8)

Defined in Data.Array.Accelerate.Classes.Enum

Methods

succ :: Exp Int8 -> Exp Int8

pred :: Exp Int8 -> Exp Int8

toEnum :: Int -> Exp Int8

fromEnum :: Exp Int8 -> Int

enumFrom :: Exp Int8 -> [Exp Int8]

enumFromThen :: Exp Int8 -> Exp Int8 -> [Exp Int8]

enumFromTo :: Exp Int8 -> Exp Int8 -> [Exp Int8]

enumFromThenTo :: Exp Int8 -> Exp Int8 -> Exp Int8 -> [Exp Int8]

Enum (Exp Int16)

Defined in Data.Array.Accelerate.Classes.Enum

Methods

succ :: Exp Int16 -> Exp Int16

pred :: Exp Int16 -> Exp Int16

toEnum :: Int -> Exp Int16

fromEnum :: Exp Int16 -> Int

enumFrom :: Exp Int16 -> [Exp Int16]

enumFromThen :: Exp Int16 -> Exp Int16 -> [Exp Int16]

enumFromTo :: Exp Int16 -> Exp Int16 -> [Exp Int16]

enumFromThenTo :: Exp Int16 -> Exp Int16 -> Exp Int16 -> [Exp Int16]

Enum (Exp Int32)

Defined in Data.Array.Accelerate.Classes.Enum

Methods

succ :: Exp Int32 -> Exp Int32

pred :: Exp Int32 -> Exp Int32

toEnum :: Int -> Exp Int32

fromEnum :: Exp Int32 -> Int

enumFrom :: Exp Int32 -> [Exp Int32]

enumFromThen :: Exp Int32 -> Exp Int32 -> [Exp Int32]

enumFromTo :: Exp Int32 -> Exp Int32 -> [Exp Int32]

enumFromThenTo :: Exp Int32 -> Exp Int32 -> Exp Int32 -> [Exp Int32]

Enum (Exp Int64)

Defined in Data.Array.Accelerate.Classes.Enum

Methods

succ :: Exp Int64 -> Exp Int64

pred :: Exp Int64 -> Exp Int64

toEnum :: Int -> Exp Int64

fromEnum :: Exp Int64 -> Int

enumFrom :: Exp Int64 -> [Exp Int64]

enumFromThen :: Exp Int64 -> Exp Int64 -> [Exp Int64]

enumFromTo :: Exp Int64 -> Exp Int64 -> [Exp Int64]

enumFromThenTo :: Exp Int64 -> Exp Int64 -> Exp Int64 -> [Exp Int64]

Integral a => Enum (Exp (Ratio a))

Defined in Data.Array.Accelerate.Data.Ratio

Methods

succ :: Exp (Ratio a) -> Exp (Ratio a)

pred :: Exp (Ratio a) -> Exp (Ratio a)

toEnum :: Int -> Exp (Ratio a)

fromEnum :: Exp (Ratio a) -> Int

enumFrom :: Exp (Ratio a) -> [Exp (Ratio a)]

enumFromThen :: Exp (Ratio a) -> Exp (Ratio a) -> [Exp (Ratio a)]

enumFromTo :: Exp (Ratio a) -> Exp (Ratio a) -> [Exp (Ratio a)]

enumFromThenTo :: Exp (Ratio a) -> Exp (Ratio a) -> Exp (Ratio a) -> [Exp (Ratio a)]

Enum (Exp Word)

Defined in Data.Array.Accelerate.Classes.Enum

Methods

succ :: Exp Word -> Exp Word

pred :: Exp Word -> Exp Word

toEnum :: Int -> Exp Word

fromEnum :: Exp Word -> Int

enumFrom :: Exp Word -> [Exp Word]

enumFromThen :: Exp Word -> Exp Word -> [Exp Word]

enumFromTo :: Exp Word -> Exp Word -> [Exp Word]

enumFromThenTo :: Exp Word -> Exp Word -> Exp Word -> [Exp Word]

Enum (Exp Word8)

Defined in Data.Array.Accelerate.Classes.Enum

Methods

succ :: Exp Word8 -> Exp Word8

pred :: Exp Word8 -> Exp Word8

toEnum :: Int -> Exp Word8

fromEnum :: Exp Word8 -> Int

enumFrom :: Exp Word8 -> [Exp Word8]

enumFromThen :: Exp Word8 -> Exp Word8 -> [Exp Word8]

enumFromTo :: Exp Word8 -> Exp Word8 -> [Exp Word8]

enumFromThenTo :: Exp Word8 -> Exp Word8 -> Exp Word8 -> [Exp Word8]

Enum (Exp Word16)

Defined in Data.Array.Accelerate.Classes.Enum

Methods

succ :: Exp Word16 -> Exp Word16

pred :: Exp Word16 -> Exp Word16

toEnum :: Int -> Exp Word16

fromEnum :: Exp Word16 -> Int

enumFrom :: Exp Word16 -> [Exp Word16]

enumFromThen :: Exp Word16 -> Exp Word16 -> [Exp Word16]

enumFromTo :: Exp Word16 -> Exp Word16 -> [Exp Word16]

enumFromThenTo :: Exp Word16 -> Exp Word16 -> Exp Word16 -> [Exp Word16]

Enum (Exp Word32)

Defined in Data.Array.Accelerate.Classes.Enum

Methods

succ :: Exp Word32 -> Exp Word32

pred :: Exp Word32 -> Exp Word32

toEnum :: Int -> Exp Word32

fromEnum :: Exp Word32 -> Int

enumFrom :: Exp Word32 -> [Exp Word32]

enumFromThen :: Exp Word32 -> Exp Word32 -> [Exp Word32]

enumFromTo :: Exp Word32 -> Exp Word32 -> [Exp Word32]

enumFromThenTo :: Exp Word32 -> Exp Word32 -> Exp Word32 -> [Exp Word32]

Enum (Exp Word64)

Defined in Data.Array.Accelerate.Classes.Enum

Methods

succ :: Exp Word64 -> Exp Word64

pred :: Exp Word64 -> Exp Word64

toEnum :: Int -> Exp Word64

fromEnum :: Exp Word64 -> Int

enumFrom :: Exp Word64 -> [Exp Word64]

enumFromThen :: Exp Word64 -> Exp Word64 -> [Exp Word64]

enumFromTo :: Exp Word64 -> Exp Word64 -> [Exp Word64]

enumFromThenTo :: Exp Word64 -> Exp Word64 -> Exp Word64 -> [Exp Word64]

Enum (Exp CShort)

Defined in Data.Array.Accelerate.Classes.Enum

Methods

succ :: Exp CShort -> Exp CShort

pred :: Exp CShort -> Exp CShort

toEnum :: Int -> Exp CShort

fromEnum :: Exp CShort -> Int

enumFrom :: Exp CShort -> [Exp CShort]

enumFromThen :: Exp CShort -> Exp CShort -> [Exp CShort]

enumFromTo :: Exp CShort -> Exp CShort -> [Exp CShort]

enumFromThenTo :: Exp CShort -> Exp CShort -> Exp CShort -> [Exp CShort]

Enum (Exp CUShort)

Defined in Data.Array.Accelerate.Classes.Enum

Methods

succ :: Exp CUShort -> Exp CUShort

pred :: Exp CUShort -> Exp CUShort

toEnum :: Int -> Exp CUShort

fromEnum :: Exp CUShort -> Int

enumFrom :: Exp CUShort -> [Exp CUShort]

enumFromThen :: Exp CUShort -> Exp CUShort -> [Exp CUShort]

enumFromTo :: Exp CUShort -> Exp CUShort -> [Exp CUShort]

enumFromThenTo :: Exp CUShort -> Exp CUShort -> Exp CUShort -> [Exp CUShort]

Enum (Exp CInt)

Defined in Data.Array.Accelerate.Classes.Enum

Methods

succ :: Exp CInt -> Exp CInt

pred :: Exp CInt -> Exp CInt

toEnum :: Int -> Exp CInt

fromEnum :: Exp CInt -> Int

enumFrom :: Exp CInt -> [Exp CInt]

enumFromThen :: Exp CInt -> Exp CInt -> [Exp CInt]

enumFromTo :: Exp CInt -> Exp CInt -> [Exp CInt]

enumFromThenTo :: Exp CInt -> Exp CInt -> Exp CInt -> [Exp CInt]

Enum (Exp CUInt)

Defined in Data.Array.Accelerate.Classes.Enum

Methods

succ :: Exp CUInt -> Exp CUInt

pred :: Exp CUInt -> Exp CUInt

toEnum :: Int -> Exp CUInt

fromEnum :: Exp CUInt -> Int

enumFrom :: Exp CUInt -> [Exp CUInt]

enumFromThen :: Exp CUInt -> Exp CUInt -> [Exp CUInt]

enumFromTo :: Exp CUInt -> Exp CUInt -> [Exp CUInt]

enumFromThenTo :: Exp CUInt -> Exp CUInt -> Exp CUInt -> [Exp CUInt]

Enum (Exp CLong)

Defined in Data.Array.Accelerate.Classes.Enum

Methods

succ :: Exp CLong -> Exp CLong

pred :: Exp CLong -> Exp CLong

toEnum :: Int -> Exp CLong

fromEnum :: Exp CLong -> Int

enumFrom :: Exp CLong -> [Exp CLong]

enumFromThen :: Exp CLong -> Exp CLong -> [Exp CLong]

enumFromTo :: Exp CLong -> Exp CLong -> [Exp CLong]

enumFromThenTo :: Exp CLong -> Exp CLong -> Exp CLong -> [Exp CLong]

Enum (Exp CULong)

Defined in Data.Array.Accelerate.Classes.Enum

Methods

succ :: Exp CULong -> Exp CULong

pred :: Exp CULong -> Exp CULong

toEnum :: Int -> Exp CULong

fromEnum :: Exp CULong -> Int

enumFrom :: Exp CULong -> [Exp CULong]

enumFromThen :: Exp CULong -> Exp CULong -> [Exp CULong]

enumFromTo :: Exp CULong -> Exp CULong -> [Exp CULong]

enumFromThenTo :: Exp CULong -> Exp CULong -> Exp CULong -> [Exp CULong]

Enum (Exp CLLong)

Defined in Data.Array.Accelerate.Classes.Enum

Methods

succ :: Exp CLLong -> Exp CLLong

pred :: Exp CLLong -> Exp CLLong

toEnum :: Int -> Exp CLLong

fromEnum :: Exp CLLong -> Int

enumFrom :: Exp CLLong -> [Exp CLLong]

enumFromThen :: Exp CLLong -> Exp CLLong -> [Exp CLLong]

enumFromTo :: Exp CLLong -> Exp CLLong -> [Exp CLLong]

enumFromThenTo :: Exp CLLong -> Exp CLLong -> Exp CLLong -> [Exp CLLong]

Enum (Exp CULLong)

Defined in Data.Array.Accelerate.Classes.Enum

Methods

succ :: Exp CULLong -> Exp CULLong

pred :: Exp CULLong -> Exp CULLong

toEnum :: Int -> Exp CULLong

fromEnum :: Exp CULLong -> Int

enumFrom :: Exp CULLong -> [Exp CULLong]

enumFromThen :: Exp CULLong -> Exp CULLong -> [Exp CULLong]

enumFromTo :: Exp CULLong -> Exp CULLong -> [Exp CULLong]

enumFromThenTo :: Exp CULLong -> Exp CULLong -> Exp CULLong -> [Exp CULLong]

Enum (Exp CFloat)

Defined in Data.Array.Accelerate.Classes.Enum

Methods

succ :: Exp CFloat -> Exp CFloat

pred :: Exp CFloat -> Exp CFloat

toEnum :: Int -> Exp CFloat

fromEnum :: Exp CFloat -> Int

enumFrom :: Exp CFloat -> [Exp CFloat]

enumFromThen :: Exp CFloat -> Exp CFloat -> [Exp CFloat]

enumFromTo :: Exp CFloat -> Exp CFloat -> [Exp CFloat]

enumFromThenTo :: Exp CFloat -> Exp CFloat -> Exp CFloat -> [Exp CFloat]

Enum (Exp CDouble)

Defined in Data.Array.Accelerate.Classes.Enum

Methods

succ :: Exp CDouble -> Exp CDouble

pred :: Exp CDouble -> Exp CDouble

toEnum :: Int -> Exp CDouble

fromEnum :: Exp CDouble -> Int

enumFrom :: Exp CDouble -> [Exp CDouble]

enumFromThen :: Exp CDouble -> Exp CDouble -> [Exp CDouble]

enumFromTo :: Exp CDouble -> Exp CDouble -> [Exp CDouble]

enumFromThenTo :: Exp CDouble -> Exp CDouble -> Exp CDouble -> [Exp CDouble]

Enum (Exp Half)

Defined in Data.Array.Accelerate.Classes.Enum

Methods

succ :: Exp Half -> Exp Half

pred :: Exp Half -> Exp Half

toEnum :: Int -> Exp Half

fromEnum :: Exp Half -> Int

enumFrom :: Exp Half -> [Exp Half]

enumFromThen :: Exp Half -> Exp Half -> [Exp Half]

enumFromTo :: Exp Half -> Exp Half -> [Exp Half]

enumFromThenTo :: Exp Half -> Exp Half -> Exp Half -> [Exp Half]

Eq (Exp a)

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp a -> Exp a -> Bool

(/=) :: Exp a -> Exp a -> Bool

Floating (Exp Double)

Defined in Data.Array.Accelerate.Classes.Floating

Methods

pi :: Exp Double

exp :: Exp Double -> Exp Double

log :: Exp Double -> Exp Double

sqrt :: Exp Double -> Exp Double

(**) :: Exp Double -> Exp Double -> Exp Double

logBase :: Exp Double -> Exp Double -> Exp Double

sin :: Exp Double -> Exp Double

cos :: Exp Double -> Exp Double

tan :: Exp Double -> Exp Double

asin :: Exp Double -> Exp Double

acos :: Exp Double -> Exp Double

atan :: Exp Double -> Exp Double

sinh :: Exp Double -> Exp Double

cosh :: Exp Double -> Exp Double

tanh :: Exp Double -> Exp Double

asinh :: Exp Double -> Exp Double

acosh :: Exp Double -> Exp Double

atanh :: Exp Double -> Exp Double

log1p :: Exp Double -> Exp Double

expm1 :: Exp Double -> Exp Double

log1pexp :: Exp Double -> Exp Double

log1mexp :: Exp Double -> Exp Double

Floating (Exp Float)

Defined in Data.Array.Accelerate.Classes.Floating

Methods

pi :: Exp Float

exp :: Exp Float -> Exp Float

log :: Exp Float -> Exp Float

sqrt :: Exp Float -> Exp Float

(**) :: Exp Float -> Exp Float -> Exp Float

logBase :: Exp Float -> Exp Float -> Exp Float

sin :: Exp Float -> Exp Float

cos :: Exp Float -> Exp Float

tan :: Exp Float -> Exp Float

asin :: Exp Float -> Exp Float

acos :: Exp Float -> Exp Float

atan :: Exp Float -> Exp Float

sinh :: Exp Float -> Exp Float

cosh :: Exp Float -> Exp Float

tanh :: Exp Float -> Exp Float

asinh :: Exp Float -> Exp Float

acosh :: Exp Float -> Exp Float

atanh :: Exp Float -> Exp Float

log1p :: Exp Float -> Exp Float

expm1 :: Exp Float -> Exp Float

log1pexp :: Exp Float -> Exp Float

log1mexp :: Exp Float -> Exp Float

RealFloat a => Floating (Exp (Complex a))

Defined in Data.Array.Accelerate.Data.Complex

Methods

pi :: Exp (Complex a)

exp :: Exp (Complex a) -> Exp (Complex a)

log :: Exp (Complex a) -> Exp (Complex a)

sqrt :: Exp (Complex a) -> Exp (Complex a)

(**) :: Exp (Complex a) -> Exp (Complex a) -> Exp (Complex a)

logBase :: Exp (Complex a) -> Exp (Complex a) -> Exp (Complex a)

sin :: Exp (Complex a) -> Exp (Complex a)

cos :: Exp (Complex a) -> Exp (Complex a)

tan :: Exp (Complex a) -> Exp (Complex a)

asin :: Exp (Complex a) -> Exp (Complex a)

acos :: Exp (Complex a) -> Exp (Complex a)

atan :: Exp (Complex a) -> Exp (Complex a)

sinh :: Exp (Complex a) -> Exp (Complex a)

cosh :: Exp (Complex a) -> Exp (Complex a)

tanh :: Exp (Complex a) -> Exp (Complex a)

asinh :: Exp (Complex a) -> Exp (Complex a)

acosh :: Exp (Complex a) -> Exp (Complex a)

atanh :: Exp (Complex a) -> Exp (Complex a)

log1p :: Exp (Complex a) -> Exp (Complex a)

expm1 :: Exp (Complex a) -> Exp (Complex a)

log1pexp :: Exp (Complex a) -> Exp (Complex a)

log1mexp :: Exp (Complex a) -> Exp (Complex a)

Floating (Exp CFloat)

Defined in Data.Array.Accelerate.Classes.Floating

Methods

pi :: Exp CFloat

exp :: Exp CFloat -> Exp CFloat

log :: Exp CFloat -> Exp CFloat

sqrt :: Exp CFloat -> Exp CFloat

(**) :: Exp CFloat -> Exp CFloat -> Exp CFloat

logBase :: Exp CFloat -> Exp CFloat -> Exp CFloat

sin :: Exp CFloat -> Exp CFloat

cos :: Exp CFloat -> Exp CFloat

tan :: Exp CFloat -> Exp CFloat

asin :: Exp CFloat -> Exp CFloat

acos :: Exp CFloat -> Exp CFloat

atan :: Exp CFloat -> Exp CFloat

sinh :: Exp CFloat -> Exp CFloat

cosh :: Exp CFloat -> Exp CFloat

tanh :: Exp CFloat -> Exp CFloat

asinh :: Exp CFloat -> Exp CFloat

acosh :: Exp CFloat -> Exp CFloat

atanh :: Exp CFloat -> Exp CFloat

log1p :: Exp CFloat -> Exp CFloat

expm1 :: Exp CFloat -> Exp CFloat

log1pexp :: Exp CFloat -> Exp CFloat

log1mexp :: Exp CFloat -> Exp CFloat

Floating (Exp CDouble)

Defined in Data.Array.Accelerate.Classes.Floating

Methods

pi :: Exp CDouble

exp :: Exp CDouble -> Exp CDouble

log :: Exp CDouble -> Exp CDouble

sqrt :: Exp CDouble -> Exp CDouble

(**) :: Exp CDouble -> Exp CDouble -> Exp CDouble

logBase :: Exp CDouble -> Exp CDouble -> Exp CDouble

sin :: Exp CDouble -> Exp CDouble

cos :: Exp CDouble -> Exp CDouble

tan :: Exp CDouble -> Exp CDouble

asin :: Exp CDouble -> Exp CDouble

acos :: Exp CDouble -> Exp CDouble

atan :: Exp CDouble -> Exp CDouble

sinh :: Exp CDouble -> Exp CDouble

cosh :: Exp CDouble -> Exp CDouble

tanh :: Exp CDouble -> Exp CDouble

asinh :: Exp CDouble -> Exp CDouble

acosh :: Exp CDouble -> Exp CDouble

atanh :: Exp CDouble -> Exp CDouble

log1p :: Exp CDouble -> Exp CDouble

expm1 :: Exp CDouble -> Exp CDouble

log1pexp :: Exp CDouble -> Exp CDouble

log1mexp :: Exp CDouble -> Exp CDouble

Floating (Exp Half)

Defined in Data.Array.Accelerate.Classes.Floating

Methods

pi :: Exp Half

exp :: Exp Half -> Exp Half

log :: Exp Half -> Exp Half

sqrt :: Exp Half -> Exp Half

(**) :: Exp Half -> Exp Half -> Exp Half

logBase :: Exp Half -> Exp Half -> Exp Half

sin :: Exp Half -> Exp Half

cos :: Exp Half -> Exp Half

tan :: Exp Half -> Exp Half

asin :: Exp Half -> Exp Half

acos :: Exp Half -> Exp Half

atan :: Exp Half -> Exp Half

sinh :: Exp Half -> Exp Half

cosh :: Exp Half -> Exp Half

tanh :: Exp Half -> Exp Half

asinh :: Exp Half -> Exp Half

acosh :: Exp Half -> Exp Half

atanh :: Exp Half -> Exp Half

log1p :: Exp Half -> Exp Half

expm1 :: Exp Half -> Exp Half

log1pexp :: Exp Half -> Exp Half

log1mexp :: Exp Half -> Exp Half

Fractional (Exp Double)

Defined in Data.Array.Accelerate.Classes.Fractional

Methods

(/) :: Exp Double -> Exp Double -> Exp Double

recip :: Exp Double -> Exp Double

fromRational :: Rational -> Exp Double

Fractional (Exp Float)

Defined in Data.Array.Accelerate.Classes.Fractional

Methods

(/) :: Exp Float -> Exp Float -> Exp Float

recip :: Exp Float -> Exp Float

fromRational :: Rational -> Exp Float

Integral a => Fractional (Exp (Ratio a))

Defined in Data.Array.Accelerate.Data.Ratio

Methods

(/) :: Exp (Ratio a) -> Exp (Ratio a) -> Exp (Ratio a)

recip :: Exp (Ratio a) -> Exp (Ratio a)

fromRational :: Rational -> Exp (Ratio a)

RealFloat a => Fractional (Exp (Complex a))

Defined in Data.Array.Accelerate.Data.Complex

Methods

(/) :: Exp (Complex a) -> Exp (Complex a) -> Exp (Complex a)

recip :: Exp (Complex a) -> Exp (Complex a)

fromRational :: Rational -> Exp (Complex a)

Fractional (Exp CFloat)

Defined in Data.Array.Accelerate.Classes.Fractional

Methods

(/) :: Exp CFloat -> Exp CFloat -> Exp CFloat

recip :: Exp CFloat -> Exp CFloat

fromRational :: Rational -> Exp CFloat

Fractional (Exp CDouble)

Defined in Data.Array.Accelerate.Classes.Fractional

Methods

(/) :: Exp CDouble -> Exp CDouble -> Exp CDouble

recip :: Exp CDouble -> Exp CDouble

fromRational :: Rational -> Exp CDouble

Fractional (Exp Half)

Defined in Data.Array.Accelerate.Classes.Fractional

Methods

(/) :: Exp Half -> Exp Half -> Exp Half

recip :: Exp Half -> Exp Half

fromRational :: Rational -> Exp Half

Integral (Exp Int)

Defined in Data.Array.Accelerate.Classes.Integral

Methods

quot :: Exp Int -> Exp Int -> Exp Int

rem :: Exp Int -> Exp Int -> Exp Int

div :: Exp Int -> Exp Int -> Exp Int

mod :: Exp Int -> Exp Int -> Exp Int

quotRem :: Exp Int -> Exp Int -> (Exp Int, Exp Int)

divMod :: Exp Int -> Exp Int -> (Exp Int, Exp Int)

toInteger :: Exp Int -> Integer

Integral (Exp Int8)

Defined in Data.Array.Accelerate.Classes.Integral

Methods

quot :: Exp Int8 -> Exp Int8 -> Exp Int8

rem :: Exp Int8 -> Exp Int8 -> Exp Int8

div :: Exp Int8 -> Exp Int8 -> Exp Int8

mod :: Exp Int8 -> Exp Int8 -> Exp Int8

quotRem :: Exp Int8 -> Exp Int8 -> (Exp Int8, Exp Int8)

divMod :: Exp Int8 -> Exp Int8 -> (Exp Int8, Exp Int8)

toInteger :: Exp Int8 -> Integer

Integral (Exp Int16)

Defined in Data.Array.Accelerate.Classes.Integral

Methods

quot :: Exp Int16 -> Exp Int16 -> Exp Int16

rem :: Exp Int16 -> Exp Int16 -> Exp Int16

div :: Exp Int16 -> Exp Int16 -> Exp Int16

mod :: Exp Int16 -> Exp Int16 -> Exp Int16

quotRem :: Exp Int16 -> Exp Int16 -> (Exp Int16, Exp Int16)

divMod :: Exp Int16 -> Exp Int16 -> (Exp Int16, Exp Int16)

toInteger :: Exp Int16 -> Integer

Integral (Exp Int32)

Defined in Data.Array.Accelerate.Classes.Integral

Methods

quot :: Exp Int32 -> Exp Int32 -> Exp Int32

rem :: Exp Int32 -> Exp Int32 -> Exp Int32

div :: Exp Int32 -> Exp Int32 -> Exp Int32

mod :: Exp Int32 -> Exp Int32 -> Exp Int32

quotRem :: Exp Int32 -> Exp Int32 -> (Exp Int32, Exp Int32)

divMod :: Exp Int32 -> Exp Int32 -> (Exp Int32, Exp Int32)

toInteger :: Exp Int32 -> Integer

Integral (Exp Int64)

Defined in Data.Array.Accelerate.Classes.Integral

Methods

quot :: Exp Int64 -> Exp Int64 -> Exp Int64

rem :: Exp Int64 -> Exp Int64 -> Exp Int64

div :: Exp Int64 -> Exp Int64 -> Exp Int64

mod :: Exp Int64 -> Exp Int64 -> Exp Int64

quotRem :: Exp Int64 -> Exp Int64 -> (Exp Int64, Exp Int64)

divMod :: Exp Int64 -> Exp Int64 -> (Exp Int64, Exp Int64)

toInteger :: Exp Int64 -> Integer

Integral (Exp Word)

Defined in Data.Array.Accelerate.Classes.Integral

Methods

quot :: Exp Word -> Exp Word -> Exp Word

rem :: Exp Word -> Exp Word -> Exp Word

div :: Exp Word -> Exp Word -> Exp Word

mod :: Exp Word -> Exp Word -> Exp Word

quotRem :: Exp Word -> Exp Word -> (Exp Word, Exp Word)

divMod :: Exp Word -> Exp Word -> (Exp Word, Exp Word)

toInteger :: Exp Word -> Integer

Integral (Exp Word8)

Defined in Data.Array.Accelerate.Classes.Integral

Methods

quot :: Exp Word8 -> Exp Word8 -> Exp Word8

rem :: Exp Word8 -> Exp Word8 -> Exp Word8

div :: Exp Word8 -> Exp Word8 -> Exp Word8

mod :: Exp Word8 -> Exp Word8 -> Exp Word8

quotRem :: Exp Word8 -> Exp Word8 -> (Exp Word8, Exp Word8)

divMod :: Exp Word8 -> Exp Word8 -> (Exp Word8, Exp Word8)

toInteger :: Exp Word8 -> Integer

Integral (Exp Word16)

Defined in Data.Array.Accelerate.Classes.Integral

Methods

quot :: Exp Word16 -> Exp Word16 -> Exp Word16

rem :: Exp Word16 -> Exp Word16 -> Exp Word16

div :: Exp Word16 -> Exp Word16 -> Exp Word16

mod :: Exp Word16 -> Exp Word16 -> Exp Word16

quotRem :: Exp Word16 -> Exp Word16 -> (Exp Word16, Exp Word16)

divMod :: Exp Word16 -> Exp Word16 -> (Exp Word16, Exp Word16)

toInteger :: Exp Word16 -> Integer

Integral (Exp Word32)

Defined in Data.Array.Accelerate.Classes.Integral

Methods

quot :: Exp Word32 -> Exp Word32 -> Exp Word32

rem :: Exp Word32 -> Exp Word32 -> Exp Word32

div :: Exp Word32 -> Exp Word32 -> Exp Word32

mod :: Exp Word32 -> Exp Word32 -> Exp Word32

quotRem :: Exp Word32 -> Exp Word32 -> (Exp Word32, Exp Word32)

divMod :: Exp Word32 -> Exp Word32 -> (Exp Word32, Exp Word32)

toInteger :: Exp Word32 -> Integer

Integral (Exp Word64)

Defined in Data.Array.Accelerate.Classes.Integral

Methods

quot :: Exp Word64 -> Exp Word64 -> Exp Word64

rem :: Exp Word64 -> Exp Word64 -> Exp Word64

div :: Exp Word64 -> Exp Word64 -> Exp Word64

mod :: Exp Word64 -> Exp Word64 -> Exp Word64

quotRem :: Exp Word64 -> Exp Word64 -> (Exp Word64, Exp Word64)

divMod :: Exp Word64 -> Exp Word64 -> (Exp Word64, Exp Word64)

toInteger :: Exp Word64 -> Integer

Integral (Exp CShort)

Defined in Data.Array.Accelerate.Classes.Integral

Methods

quot :: Exp CShort -> Exp CShort -> Exp CShort

rem :: Exp CShort -> Exp CShort -> Exp CShort

div :: Exp CShort -> Exp CShort -> Exp CShort

mod :: Exp CShort -> Exp CShort -> Exp CShort

quotRem :: Exp CShort -> Exp CShort -> (Exp CShort, Exp CShort)

divMod :: Exp CShort -> Exp CShort -> (Exp CShort, Exp CShort)

toInteger :: Exp CShort -> Integer

Integral (Exp CUShort)

Defined in Data.Array.Accelerate.Classes.Integral

Methods

quot :: Exp CUShort -> Exp CUShort -> Exp CUShort

rem :: Exp CUShort -> Exp CUShort -> Exp CUShort

div :: Exp CUShort -> Exp CUShort -> Exp CUShort

mod :: Exp CUShort -> Exp CUShort -> Exp CUShort

quotRem :: Exp CUShort -> Exp CUShort -> (Exp CUShort, Exp CUShort)

divMod :: Exp CUShort -> Exp CUShort -> (Exp CUShort, Exp CUShort)

toInteger :: Exp CUShort -> Integer

Integral (Exp CInt)

Defined in Data.Array.Accelerate.Classes.Integral

Methods

quot :: Exp CInt -> Exp CInt -> Exp CInt

rem :: Exp CInt -> Exp CInt -> Exp CInt

div :: Exp CInt -> Exp CInt -> Exp CInt

mod :: Exp CInt -> Exp CInt -> Exp CInt

quotRem :: Exp CInt -> Exp CInt -> (Exp CInt, Exp CInt)

divMod :: Exp CInt -> Exp CInt -> (Exp CInt, Exp CInt)

toInteger :: Exp CInt -> Integer

Integral (Exp CUInt)

Defined in Data.Array.Accelerate.Classes.Integral

Methods

quot :: Exp CUInt -> Exp CUInt -> Exp CUInt

rem :: Exp CUInt -> Exp CUInt -> Exp CUInt

div :: Exp CUInt -> Exp CUInt -> Exp CUInt

mod :: Exp CUInt -> Exp CUInt -> Exp CUInt

quotRem :: Exp CUInt -> Exp CUInt -> (Exp CUInt, Exp CUInt)

divMod :: Exp CUInt -> Exp CUInt -> (Exp CUInt, Exp CUInt)

toInteger :: Exp CUInt -> Integer

Integral (Exp CLong)

Defined in Data.Array.Accelerate.Classes.Integral

Methods

quot :: Exp CLong -> Exp CLong -> Exp CLong

rem :: Exp CLong -> Exp CLong -> Exp CLong

div :: Exp CLong -> Exp CLong -> Exp CLong

mod :: Exp CLong -> Exp CLong -> Exp CLong

quotRem :: Exp CLong -> Exp CLong -> (Exp CLong, Exp CLong)

divMod :: Exp CLong -> Exp CLong -> (Exp CLong, Exp CLong)

toInteger :: Exp CLong -> Integer

Integral (Exp CULong)

Defined in Data.Array.Accelerate.Classes.Integral

Methods

quot :: Exp CULong -> Exp CULong -> Exp CULong

rem :: Exp CULong -> Exp CULong -> Exp CULong

div :: Exp CULong -> Exp CULong -> Exp CULong

mod :: Exp CULong -> Exp CULong -> Exp CULong

quotRem :: Exp CULong -> Exp CULong -> (Exp CULong, Exp CULong)

divMod :: Exp CULong -> Exp CULong -> (Exp CULong, Exp CULong)

toInteger :: Exp CULong -> Integer

Integral (Exp CLLong)

Defined in Data.Array.Accelerate.Classes.Integral

Methods

quot :: Exp CLLong -> Exp CLLong -> Exp CLLong

rem :: Exp CLLong -> Exp CLLong -> Exp CLLong

div :: Exp CLLong -> Exp CLLong -> Exp CLLong

mod :: Exp CLLong -> Exp CLLong -> Exp CLLong

quotRem :: Exp CLLong -> Exp CLLong -> (Exp CLLong, Exp CLLong)

divMod :: Exp CLLong -> Exp CLLong -> (Exp CLLong, Exp CLLong)

toInteger :: Exp CLLong -> Integer

Integral (Exp CULLong)

Defined in Data.Array.Accelerate.Classes.Integral

Methods

quot :: Exp CULLong -> Exp CULLong -> Exp CULLong

rem :: Exp CULLong -> Exp CULLong -> Exp CULLong

div :: Exp CULLong -> Exp CULLong -> Exp CULLong

mod :: Exp CULLong -> Exp CULLong -> Exp CULLong

quotRem :: Exp CULLong -> Exp CULLong -> (Exp CULLong, Exp CULLong)

divMod :: Exp CULLong -> Exp CULLong -> (Exp CULLong, Exp CULLong)

toInteger :: Exp CULLong -> Integer

Num (Exp Double)

Defined in Data.Array.Accelerate.Classes.Num

Methods

(+) :: Exp Double -> Exp Double -> Exp Double

(-) :: Exp Double -> Exp Double -> Exp Double

(*) :: Exp Double -> Exp Double -> Exp Double

negate :: Exp Double -> Exp Double

abs :: Exp Double -> Exp Double

signum :: Exp Double -> Exp Double

fromInteger :: Integer -> Exp Double

Num (Exp Float)

Defined in Data.Array.Accelerate.Classes.Num

Methods

(+) :: Exp Float -> Exp Float -> Exp Float

(-) :: Exp Float -> Exp Float -> Exp Float

(*) :: Exp Float -> Exp Float -> Exp Float

negate :: Exp Float -> Exp Float

abs :: Exp Float -> Exp Float

signum :: Exp Float -> Exp Float

fromInteger :: Integer -> Exp Float

Num (Exp Int)

Defined in Data.Array.Accelerate.Classes.Num

Methods

(+) :: Exp Int -> Exp Int -> Exp Int

(-) :: Exp Int -> Exp Int -> Exp Int

(*) :: Exp Int -> Exp Int -> Exp Int

negate :: Exp Int -> Exp Int

abs :: Exp Int -> Exp Int

signum :: Exp Int -> Exp Int

fromInteger :: Integer -> Exp Int

Num (Exp Int8)

Defined in Data.Array.Accelerate.Classes.Num

Methods

(+) :: Exp Int8 -> Exp Int8 -> Exp Int8

(-) :: Exp Int8 -> Exp Int8 -> Exp Int8

(*) :: Exp Int8 -> Exp Int8 -> Exp Int8

negate :: Exp Int8 -> Exp Int8

abs :: Exp Int8 -> Exp Int8

signum :: Exp Int8 -> Exp Int8

fromInteger :: Integer -> Exp Int8

Num (Exp Int16)

Defined in Data.Array.Accelerate.Classes.Num

Methods

(+) :: Exp Int16 -> Exp Int16 -> Exp Int16

(-) :: Exp Int16 -> Exp Int16 -> Exp Int16

(*) :: Exp Int16 -> Exp Int16 -> Exp Int16

negate :: Exp Int16 -> Exp Int16

abs :: Exp Int16 -> Exp Int16

signum :: Exp Int16 -> Exp Int16

fromInteger :: Integer -> Exp Int16

Num (Exp Int32)

Defined in Data.Array.Accelerate.Classes.Num

Methods

(+) :: Exp Int32 -> Exp Int32 -> Exp Int32

(-) :: Exp Int32 -> Exp Int32 -> Exp Int32

(*) :: Exp Int32 -> Exp Int32 -> Exp Int32

negate :: Exp Int32 -> Exp Int32

abs :: Exp Int32 -> Exp Int32

signum :: Exp Int32 -> Exp Int32

fromInteger :: Integer -> Exp Int32

Num (Exp Int64)

Defined in Data.Array.Accelerate.Classes.Num

Methods

(+) :: Exp Int64 -> Exp Int64 -> Exp Int64

(-) :: Exp Int64 -> Exp Int64 -> Exp Int64

(*) :: Exp Int64 -> Exp Int64 -> Exp Int64

negate :: Exp Int64 -> Exp Int64

abs :: Exp Int64 -> Exp Int64

signum :: Exp Int64 -> Exp Int64

fromInteger :: Integer -> Exp Int64

Integral a => Num (Exp (Ratio a))

Defined in Data.Array.Accelerate.Data.Ratio

Methods

(+) :: Exp (Ratio a) -> Exp (Ratio a) -> Exp (Ratio a)

(-) :: Exp (Ratio a) -> Exp (Ratio a) -> Exp (Ratio a)

(*) :: Exp (Ratio a) -> Exp (Ratio a) -> Exp (Ratio a)

negate :: Exp (Ratio a) -> Exp (Ratio a)

abs :: Exp (Ratio a) -> Exp (Ratio a)

signum :: Exp (Ratio a) -> Exp (Ratio a)

fromInteger :: Integer -> Exp (Ratio a)

Num (Exp Word)

Defined in Data.Array.Accelerate.Classes.Num

Methods

(+) :: Exp Word -> Exp Word -> Exp Word

(-) :: Exp Word -> Exp Word -> Exp Word

(*) :: Exp Word -> Exp Word -> Exp Word

negate :: Exp Word -> Exp Word

abs :: Exp Word -> Exp Word

signum :: Exp Word -> Exp Word

fromInteger :: Integer -> Exp Word

Num (Exp Word8)

Defined in Data.Array.Accelerate.Classes.Num

Methods

(+) :: Exp Word8 -> Exp Word8 -> Exp Word8

(-) :: Exp Word8 -> Exp Word8 -> Exp Word8

(*) :: Exp Word8 -> Exp Word8 -> Exp Word8

negate :: Exp Word8 -> Exp Word8

abs :: Exp Word8 -> Exp Word8

signum :: Exp Word8 -> Exp Word8

fromInteger :: Integer -> Exp Word8

Num (Exp Word16)

Defined in Data.Array.Accelerate.Classes.Num

Methods

(+) :: Exp Word16 -> Exp Word16 -> Exp Word16

(-) :: Exp Word16 -> Exp Word16 -> Exp Word16

(*) :: Exp Word16 -> Exp Word16 -> Exp Word16

negate :: Exp Word16 -> Exp Word16

abs :: Exp Word16 -> Exp Word16

signum :: Exp Word16 -> Exp Word16

fromInteger :: Integer -> Exp Word16

Num (Exp Word32)

Defined in Data.Array.Accelerate.Classes.Num

Methods

(+) :: Exp Word32 -> Exp Word32 -> Exp Word32

(-) :: Exp Word32 -> Exp Word32 -> Exp Word32

(*) :: Exp Word32 -> Exp Word32 -> Exp Word32

negate :: Exp Word32 -> Exp Word32

abs :: Exp Word32 -> Exp Word32

signum :: Exp Word32 -> Exp Word32

fromInteger :: Integer -> Exp Word32

Num (Exp Word64)

Defined in Data.Array.Accelerate.Classes.Num

Methods

(+) :: Exp Word64 -> Exp Word64 -> Exp Word64

(-) :: Exp Word64 -> Exp Word64 -> Exp Word64

(*) :: Exp Word64 -> Exp Word64 -> Exp Word64

negate :: Exp Word64 -> Exp Word64

abs :: Exp Word64 -> Exp Word64

signum :: Exp Word64 -> Exp Word64

fromInteger :: Integer -> Exp Word64

RealFloat a => Num (Exp (Complex a))

Defined in Data.Array.Accelerate.Data.Complex

Methods

(+) :: Exp (Complex a) -> Exp (Complex a) -> Exp (Complex a)

(-) :: Exp (Complex a) -> Exp (Complex a) -> Exp (Complex a)

(*) :: Exp (Complex a) -> Exp (Complex a) -> Exp (Complex a)

negate :: Exp (Complex a) -> Exp (Complex a)

abs :: Exp (Complex a) -> Exp (Complex a)

signum :: Exp (Complex a) -> Exp (Complex a)

fromInteger :: Integer -> Exp (Complex a)

Num a => Num (Exp (Min a))

Defined in Data.Array.Accelerate.Data.Semigroup

Methods

(+) :: Exp (Min a) -> Exp (Min a) -> Exp (Min a)

(-) :: Exp (Min a) -> Exp (Min a) -> Exp (Min a)

(*) :: Exp (Min a) -> Exp (Min a) -> Exp (Min a)

negate :: Exp (Min a) -> Exp (Min a)

abs :: Exp (Min a) -> Exp (Min a)

signum :: Exp (Min a) -> Exp (Min a)

fromInteger :: Integer -> Exp (Min a)

Num a => Num (Exp (Max a))

Defined in Data.Array.Accelerate.Data.Semigroup

Methods

(+) :: Exp (Max a) -> Exp (Max a) -> Exp (Max a)

(-) :: Exp (Max a) -> Exp (Max a) -> Exp (Max a)

(*) :: Exp (Max a) -> Exp (Max a) -> Exp (Max a)

negate :: Exp (Max a) -> Exp (Max a)

abs :: Exp (Max a) -> Exp (Max a)

signum :: Exp (Max a) -> Exp (Max a)

fromInteger :: Integer -> Exp (Max a)

Num a => Num (Exp (Sum a))

Defined in Data.Array.Accelerate.Data.Monoid

Methods

(+) :: Exp (Sum a) -> Exp (Sum a) -> Exp (Sum a)

(-) :: Exp (Sum a) -> Exp (Sum a) -> Exp (Sum a)

(*) :: Exp (Sum a) -> Exp (Sum a) -> Exp (Sum a)

negate :: Exp (Sum a) -> Exp (Sum a)

abs :: Exp (Sum a) -> Exp (Sum a)

signum :: Exp (Sum a) -> Exp (Sum a)

fromInteger :: Integer -> Exp (Sum a)

Num a => Num (Exp (Product a))

Defined in Data.Array.Accelerate.Data.Monoid

Methods

(+) :: Exp (Product a) -> Exp (Product a) -> Exp (Product a)

(-) :: Exp (Product a) -> Exp (Product a) -> Exp (Product a)

(*) :: Exp (Product a) -> Exp (Product a) -> Exp (Product a)

negate :: Exp (Product a) -> Exp (Product a)

abs :: Exp (Product a) -> Exp (Product a)

signum :: Exp (Product a) -> Exp (Product a)

fromInteger :: Integer -> Exp (Product a)

Num (Exp CShort)

Defined in Data.Array.Accelerate.Classes.Num

Methods

(+) :: Exp CShort -> Exp CShort -> Exp CShort

(-) :: Exp CShort -> Exp CShort -> Exp CShort

(*) :: Exp CShort -> Exp CShort -> Exp CShort

negate :: Exp CShort -> Exp CShort

abs :: Exp CShort -> Exp CShort

signum :: Exp CShort -> Exp CShort

fromInteger :: Integer -> Exp CShort

Num (Exp CUShort)

Defined in Data.Array.Accelerate.Classes.Num

Methods

(+) :: Exp CUShort -> Exp CUShort -> Exp CUShort

(-) :: Exp CUShort -> Exp CUShort -> Exp CUShort

(*) :: Exp CUShort -> Exp CUShort -> Exp CUShort

negate :: Exp CUShort -> Exp CUShort

abs :: Exp CUShort -> Exp CUShort

signum :: Exp CUShort -> Exp CUShort

fromInteger :: Integer -> Exp CUShort

Num (Exp CInt)

Defined in Data.Array.Accelerate.Classes.Num

Methods

(+) :: Exp CInt -> Exp CInt -> Exp CInt

(-) :: Exp CInt -> Exp CInt -> Exp CInt

(*) :: Exp CInt -> Exp CInt -> Exp CInt

negate :: Exp CInt -> Exp CInt

abs :: Exp CInt -> Exp CInt

signum :: Exp CInt -> Exp CInt

fromInteger :: Integer -> Exp CInt

Num (Exp CUInt)

Defined in Data.Array.Accelerate.Classes.Num

Methods

(+) :: Exp CUInt -> Exp CUInt -> Exp CUInt

(-) :: Exp CUInt -> Exp CUInt -> Exp CUInt

(*) :: Exp CUInt -> Exp CUInt -> Exp CUInt

negate :: Exp CUInt -> Exp CUInt

abs :: Exp CUInt -> Exp CUInt

signum :: Exp CUInt -> Exp CUInt

fromInteger :: Integer -> Exp CUInt

Num (Exp CLong)

Defined in Data.Array.Accelerate.Classes.Num

Methods

(+) :: Exp CLong -> Exp CLong -> Exp CLong

(-) :: Exp CLong -> Exp CLong -> Exp CLong

(*) :: Exp CLong -> Exp CLong -> Exp CLong

negate :: Exp CLong -> Exp CLong

abs :: Exp CLong -> Exp CLong

signum :: Exp CLong -> Exp CLong

fromInteger :: Integer -> Exp CLong

Num (Exp CULong)

Defined in Data.Array.Accelerate.Classes.Num

Methods

(+) :: Exp CULong -> Exp CULong -> Exp CULong

(-) :: Exp CULong -> Exp CULong -> Exp CULong

(*) :: Exp CULong -> Exp CULong -> Exp CULong

negate :: Exp CULong -> Exp CULong

abs :: Exp CULong -> Exp CULong

signum :: Exp CULong -> Exp CULong

fromInteger :: Integer -> Exp CULong

Num (Exp CLLong)

Defined in Data.Array.Accelerate.Classes.Num

Methods

(+) :: Exp CLLong -> Exp CLLong -> Exp CLLong

(-) :: Exp CLLong -> Exp CLLong -> Exp CLLong

(*) :: Exp CLLong -> Exp CLLong -> Exp CLLong

negate :: Exp CLLong -> Exp CLLong

abs :: Exp CLLong -> Exp CLLong

signum :: Exp CLLong -> Exp CLLong

fromInteger :: Integer -> Exp CLLong

Num (Exp CULLong)

Defined in Data.Array.Accelerate.Classes.Num

Methods

(+) :: Exp CULLong -> Exp CULLong -> Exp CULLong

(-) :: Exp CULLong -> Exp CULLong -> Exp CULLong

(*) :: Exp CULLong -> Exp CULLong -> Exp CULLong

negate :: Exp CULLong -> Exp CULLong

abs :: Exp CULLong -> Exp CULLong

signum :: Exp CULLong -> Exp CULLong

fromInteger :: Integer -> Exp CULLong

Num (Exp CFloat)

Defined in Data.Array.Accelerate.Classes.Num

Methods

(+) :: Exp CFloat -> Exp CFloat -> Exp CFloat

(-) :: Exp CFloat -> Exp CFloat -> Exp CFloat

(*) :: Exp CFloat -> Exp CFloat -> Exp CFloat

negate :: Exp CFloat -> Exp CFloat

abs :: Exp CFloat -> Exp CFloat

signum :: Exp CFloat -> Exp CFloat

fromInteger :: Integer -> Exp CFloat

Num (Exp CDouble)

Defined in Data.Array.Accelerate.Classes.Num

Methods

(+) :: Exp CDouble -> Exp CDouble -> Exp CDouble

(-) :: Exp CDouble -> Exp CDouble -> Exp CDouble

(*) :: Exp CDouble -> Exp CDouble -> Exp CDouble

negate :: Exp CDouble -> Exp CDouble

abs :: Exp CDouble -> Exp CDouble

signum :: Exp CDouble -> Exp CDouble

fromInteger :: Integer -> Exp CDouble

Num (Exp Half)

Defined in Data.Array.Accelerate.Classes.Num

Methods

(+) :: Exp Half -> Exp Half -> Exp Half

(-) :: Exp Half -> Exp Half -> Exp Half

(*) :: Exp Half -> Exp Half -> Exp Half

negate :: Exp Half -> Exp Half

abs :: Exp Half -> Exp Half

signum :: Exp Half -> Exp Half

fromInteger :: Integer -> Exp Half

Ord a => Ord (Exp a)

Defined in Data.Array.Accelerate.Classes.Ord

Methods

compare :: Exp a -> Exp a -> Ordering

(<) :: Exp a -> Exp a -> Bool

(<=) :: Exp a -> Exp a -> Bool

(>) :: Exp a -> Exp a -> Bool

(>=) :: Exp a -> Exp a -> Bool

max :: Exp a -> Exp a -> Exp a

min :: Exp a -> Exp a -> Exp a

(Num a, Ord a) => Real (Exp a)

Defined in Data.Array.Accelerate.Classes.Real

Methods

toRational :: Exp a -> Rational

RealFloat a => RealFloat (Exp a)

Defined in Data.Array.Accelerate.Classes.RealFloat

Methods

floatRadix :: Exp a -> Integer

floatDigits :: Exp a -> Int

floatRange :: Exp a -> (Int, Int)

decodeFloat :: Exp a -> (Integer, Int)

encodeFloat :: Integer -> Int -> Exp a

exponent :: Exp a -> Int

significand :: Exp a -> Exp a

scaleFloat :: Int -> Exp a -> Exp a

isNaN :: Exp a -> Bool

isInfinite :: Exp a -> Bool

isDenormalized :: Exp a -> Bool

isNegativeZero :: Exp a -> Bool

isIEEE :: Exp a -> Bool

atan2 :: Exp a -> Exp a -> Exp a

RealFrac a => RealFrac (Exp a)

Defined in Data.Array.Accelerate.Classes.RealFrac

Methods

properFraction :: Integral b => Exp a -> (b, Exp a)

truncate :: Integral b => Exp a -> b

round :: Integral b => Exp a -> b

ceiling :: Integral b => Exp a -> b

floor :: Integral b => Exp a -> b

Elt e => Show (Exp e)

Defined in Data.Array.Accelerate.Pretty

Methods

showsPrec :: Int -> Exp e -> ShowS

show :: Exp e -> String

showList :: [Exp e] -> ShowS

(Semigroup (Exp a), Elt a) => Semigroup (Exp (Maybe a))

Defined in Data.Array.Accelerate.Data.Maybe

Methods

(<>) :: Exp (Maybe a) -> Exp (Maybe a) -> Exp (Maybe a)

sconcat :: NonEmpty (Exp (Maybe a)) -> Exp (Maybe a)

stimes :: Integral b => b -> Exp (Maybe a) -> Exp (Maybe a)

(Elt a, Elt b) => Semigroup (Exp (Either a b))

Defined in Data.Array.Accelerate.Data.Either

Methods

(<>) :: Exp (Either a b) -> Exp (Either a b) -> Exp (Either a b)

sconcat :: NonEmpty (Exp (Either a b)) -> Exp (Either a b)

stimes :: Integral b0 => b0 -> Exp (Either a b) -> Exp (Either a b)

Semigroup (Exp ())

Defined in Data.Array.Accelerate.Data.Semigroup

Methods

(<>) :: Exp () -> Exp () -> Exp ()

sconcat :: NonEmpty (Exp ()) -> Exp ()

stimes :: Integral b => b -> Exp () -> Exp ()

(Elt a, Elt b, Semigroup (Exp a), Semigroup (Exp b)) => Semigroup (Exp (a, b))

Defined in Data.Array.Accelerate.Data.Semigroup

Methods

(<>) :: Exp (a, b) -> Exp (a, b) -> Exp (a, b)

sconcat :: NonEmpty (Exp (a, b)) -> Exp (a, b)

stimes :: Integral b0 => b0 -> Exp (a, b) -> Exp (a, b)

(Elt a, Elt b, Elt c, Semigroup (Exp a), Semigroup (Exp b), Semigroup (Exp c)) => Semigroup (Exp (a, b, c))

Defined in Data.Array.Accelerate.Data.Semigroup

Methods

(<>) :: Exp (a, b, c) -> Exp (a, b, c) -> Exp (a, b, c)

sconcat :: NonEmpty (Exp (a, b, c)) -> Exp (a, b, c)

stimes :: Integral b0 => b0 -> Exp (a, b, c) -> Exp (a, b, c)

(Elt a, Elt b, Elt c, Elt d, Semigroup (Exp a), Semigroup (Exp b), Semigroup (Exp c), Semigroup (Exp d)) => Semigroup (Exp (a, b, c, d))

Defined in Data.Array.Accelerate.Data.Semigroup

Methods

(<>) :: Exp (a, b, c, d) -> Exp (a, b, c, d) -> Exp (a, b, c, d)

sconcat :: NonEmpty (Exp (a, b, c, d)) -> Exp (a, b, c, d)

stimes :: Integral b0 => b0 -> Exp (a, b, c, d) -> Exp (a, b, c, d)

(Elt a, Elt b, Elt c, Elt d, Elt e, Semigroup (Exp a), Semigroup (Exp b), Semigroup (Exp c), Semigroup (Exp d), Semigroup (Exp e)) => Semigroup (Exp (a, b, c, d, e))

Defined in Data.Array.Accelerate.Data.Semigroup

Methods

(<>) :: Exp (a, b, c, d, e) -> Exp (a, b, c, d, e) -> Exp (a, b, c, d, e)

sconcat :: NonEmpty (Exp (a, b, c, d, e)) -> Exp (a, b, c, d, e)

stimes :: Integral b0 => b0 -> Exp (a, b, c, d, e) -> Exp (a, b, c, d, e)

Ord a => Semigroup (Exp (Min a))

Defined in Data.Array.Accelerate.Data.Semigroup

Methods

(<>) :: Exp (Min a) -> Exp (Min a) -> Exp (Min a)

sconcat :: NonEmpty (Exp (Min a)) -> Exp (Min a)

stimes :: Integral b => b -> Exp (Min a) -> Exp (Min a)

Ord a => Semigroup (Exp (Max a))

Defined in Data.Array.Accelerate.Data.Semigroup

Methods

(<>) :: Exp (Max a) -> Exp (Max a) -> Exp (Max a)

sconcat :: NonEmpty (Exp (Max a)) -> Exp (Max a)

stimes :: Integral b => b -> Exp (Max a) -> Exp (Max a)

Num a => Semigroup (Exp (Sum a))

Since: 1.2.0.0

Defined in Data.Array.Accelerate.Data.Monoid

Methods

(<>) :: Exp (Sum a) -> Exp (Sum a) -> Exp (Sum a)

sconcat :: NonEmpty (Exp (Sum a)) -> Exp (Sum a)

stimes :: Integral b => b -> Exp (Sum a) -> Exp (Sum a)

Num a => Semigroup (Exp (Product a))

Since: 1.2.0.0

Defined in Data.Array.Accelerate.Data.Monoid

Methods

(<>) :: Exp (Product a) -> Exp (Product a) -> Exp (Product a)

sconcat :: NonEmpty (Exp (Product a)) -> Exp (Product a)

stimes :: Integral b => b -> Exp (Product a) -> Exp (Product a)

(Monoid (Exp a), Elt a) => Monoid (Exp (Maybe a))

Defined in Data.Array.Accelerate.Data.Maybe

Methods

mempty :: Exp (Maybe a)

mappend :: Exp (Maybe a) -> Exp (Maybe a) -> Exp (Maybe a)

mconcat :: [Exp (Maybe a)] -> Exp (Maybe a)

Monoid (Exp ())

Defined in Data.Array.Accelerate.Data.Monoid

Methods

mempty :: Exp ()

mappend :: Exp () -> Exp () -> Exp ()

mconcat :: [Exp ()] -> Exp ()

(Elt a, Elt b, Monoid (Exp a), Monoid (Exp b)) => Monoid (Exp (a, b))

Defined in Data.Array.Accelerate.Data.Monoid

Methods

mempty :: Exp (a, b)

mappend :: Exp (a, b) -> Exp (a, b) -> Exp (a, b)

mconcat :: [Exp (a, b)] -> Exp (a, b)

(Elt a, Elt b, Elt c, Monoid (Exp a), Monoid (Exp b), Monoid (Exp c)) => Monoid (Exp (a, b, c))

Defined in Data.Array.Accelerate.Data.Monoid

Methods

mempty :: Exp (a, b, c)

mappend :: Exp (a, b, c) -> Exp (a, b, c) -> Exp (a, b, c)

mconcat :: [Exp (a, b, c)] -> Exp (a, b, c)

(Elt a, Elt b, Elt c, Elt d, Monoid (Exp a), Monoid (Exp b), Monoid (Exp c), Monoid (Exp d)) => Monoid (Exp (a, b, c, d))

Defined in Data.Array.Accelerate.Data.Monoid

Methods

mempty :: Exp (a, b, c, d)

mappend :: Exp (a, b, c, d) -> Exp (a, b, c, d) -> Exp (a, b, c, d)

mconcat :: [Exp (a, b, c, d)] -> Exp (a, b, c, d)

(Elt a, Elt b, Elt c, Elt d, Elt e, Monoid (Exp a), Monoid (Exp b), Monoid (Exp c), Monoid (Exp d), Monoid (Exp e)) => Monoid (Exp (a, b, c, d, e))

Defined in Data.Array.Accelerate.Data.Monoid

Methods

mempty :: Exp (a, b, c, d, e)

mappend :: Exp (a, b, c, d, e) -> Exp (a, b, c, d, e) -> Exp (a, b, c, d, e)

mconcat :: [Exp (a, b, c, d, e)] -> Exp (a, b, c, d, e)

(Ord a, Bounded a) => Monoid (Exp (Min a))

Defined in Data.Array.Accelerate.Data.Semigroup

Methods

mempty :: Exp (Min a)

mappend :: Exp (Min a) -> Exp (Min a) -> Exp (Min a)

mconcat :: [Exp (Min a)] -> Exp (Min a)

(Ord a, Bounded a) => Monoid (Exp (Max a))

Defined in Data.Array.Accelerate.Data.Semigroup

Methods

mempty :: Exp (Max a)

mappend :: Exp (Max a) -> Exp (Max a) -> Exp (Max a)

mconcat :: [Exp (Max a)] -> Exp (Max a)

Num a => Monoid (Exp (Sum a))

Defined in Data.Array.Accelerate.Data.Monoid

Methods

mempty :: Exp (Sum a)

mappend :: Exp (Sum a) -> Exp (Sum a) -> Exp (Sum a)

mconcat :: [Exp (Sum a)] -> Exp (Sum a)

Num a => Monoid (Exp (Product a))

Defined in Data.Array.Accelerate.Data.Monoid

Methods

mempty :: Exp (Product a)

mappend :: Exp (Product a) -> Exp (Product a) -> Exp (Product a)

mconcat :: [Exp (Product a)] -> Exp (Product a)

Floating b => Floating (Fold a (Exp b))

Defined in Data.Array.Accelerate.Data.Fold

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

Defined in Data.Array.Accelerate.Data.Fold

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

Defined in Data.Array.Accelerate.Data.Fold

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)

Function (Exp a -> f) => Show (Exp a -> f)

Defined in Data.Array.Accelerate.Pretty

Methods

showsPrec :: Int -> (Exp a -> f) -> ShowS

show :: (Exp a -> f) -> String

showList :: [Exp a -> f] -> ShowS

type EltT Exp t

Defined in Data.Array.Accelerate.Prelude

type EltT Exp t = Elt t

type Plain (Exp e)

Defined in Data.Array.Accelerate.Lift

type Plain (Exp e) = e

type Plain (ix :. Exp e)

Defined in Data.Array.Accelerate.Lift

type Plain (ix :. Exp e) = Plain ix :. e

SIMD vectors

data Vec (n :: Nat) a

Instances

Eq (Vec n a)

Defined in Data.Primitive.Vec

Methods

(==) :: Vec n a -> Vec n a -> Bool

(/=) :: Vec n a -> Vec n a -> Bool

(Show a, Prim a, KnownNat n) => Show (Vec n a)

Defined in Data.Primitive.Vec

Methods

showsPrec :: Int -> Vec n a -> ShowS

show :: Vec n a -> String

showList :: [Vec n a] -> ShowS

(KnownNat n, VecElt a) => Elt (Vec n a)

Defined in Data.Array.Accelerate.Sugar.Vec

Associated Types

type EltR (Vec n a)

Methods

eltR :: TypeR (EltR (Vec n a))

tagsR :: [TagR (EltR (Vec n a))]

fromElt :: Vec n a -> EltR (Vec n a)

toElt :: EltR (Vec n a) -> Vec n a

type VecElt a = (Elt a, Prim a, IsSingle a, EltR a ~ a)

Type classes

Basic type classes

class Elt a => Eq a where

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

(/=) :: Exp a -> Exp a -> Exp Bool infix 4

Instances

Eq Bool

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp Bool -> Exp Bool -> Exp Bool

(/=) :: Exp Bool -> Exp Bool -> Exp Bool

Eq Char

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp Char -> Exp Char -> Exp Bool

(/=) :: Exp Char -> Exp Char -> Exp Bool

Eq Double

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp Double -> Exp Double -> Exp Bool

(/=) :: Exp Double -> Exp Double -> Exp Bool

Eq Float

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp Float -> Exp Float -> Exp Bool

(/=) :: Exp Float -> Exp Float -> Exp Bool

Eq Int

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp Int -> Exp Int -> Exp Bool

(/=) :: Exp Int -> Exp Int -> Exp Bool

Eq Int8

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp Int8 -> Exp Int8 -> Exp Bool

(/=) :: Exp Int8 -> Exp Int8 -> Exp Bool

Eq Int16

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp Int16 -> Exp Int16 -> Exp Bool

(/=) :: Exp Int16 -> Exp Int16 -> Exp Bool

Eq Int32

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp Int32 -> Exp Int32 -> Exp Bool

(/=) :: Exp Int32 -> Exp Int32 -> Exp Bool

Eq Int64

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp Int64 -> Exp Int64 -> Exp Bool

(/=) :: Exp Int64 -> Exp Int64 -> Exp Bool

Eq Ordering

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(==) :: Exp Ordering -> Exp Ordering -> Exp Bool

(/=) :: Exp Ordering -> Exp Ordering -> Exp Bool

Eq Word

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp Word -> Exp Word -> Exp Bool

(/=) :: Exp Word -> Exp Word -> Exp Bool

Eq Word8

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp Word8 -> Exp Word8 -> Exp Bool

(/=) :: Exp Word8 -> Exp Word8 -> Exp Bool

Eq Word16

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp Word16 -> Exp Word16 -> Exp Bool

(/=) :: Exp Word16 -> Exp Word16 -> Exp Bool

Eq Word32

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp Word32 -> Exp Word32 -> Exp Bool

(/=) :: Exp Word32 -> Exp Word32 -> Exp Bool

Eq Word64

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp Word64 -> Exp Word64 -> Exp Bool

(/=) :: Exp Word64 -> Exp Word64 -> Exp Bool

Eq ()

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp () -> Exp () -> Exp Bool

(/=) :: Exp () -> Exp () -> Exp Bool

Eq CChar

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp CChar -> Exp CChar -> Exp Bool

(/=) :: Exp CChar -> Exp CChar -> Exp Bool

Eq CSChar

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp CSChar -> Exp CSChar -> Exp Bool

(/=) :: Exp CSChar -> Exp CSChar -> Exp Bool

Eq CUChar

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp CUChar -> Exp CUChar -> Exp Bool

(/=) :: Exp CUChar -> Exp CUChar -> Exp Bool

Eq CShort

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp CShort -> Exp CShort -> Exp Bool

(/=) :: Exp CShort -> Exp CShort -> Exp Bool

Eq CUShort

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp CUShort -> Exp CUShort -> Exp Bool

(/=) :: Exp CUShort -> Exp CUShort -> Exp Bool

Eq CInt

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp CInt -> Exp CInt -> Exp Bool

(/=) :: Exp CInt -> Exp CInt -> Exp Bool

Eq CUInt

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp CUInt -> Exp CUInt -> Exp Bool

(/=) :: Exp CUInt -> Exp CUInt -> Exp Bool

Eq CLong

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp CLong -> Exp CLong -> Exp Bool

(/=) :: Exp CLong -> Exp CLong -> Exp Bool

Eq CULong

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp CULong -> Exp CULong -> Exp Bool

(/=) :: Exp CULong -> Exp CULong -> Exp Bool

Eq CLLong

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp CLLong -> Exp CLLong -> Exp Bool

(/=) :: Exp CLLong -> Exp CLLong -> Exp Bool

Eq CULLong

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp CULLong -> Exp CULLong -> Exp Bool

(/=) :: Exp CULLong -> Exp CULLong -> Exp Bool

Eq CFloat

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp CFloat -> Exp CFloat -> Exp Bool

(/=) :: Exp CFloat -> Exp CFloat -> Exp Bool

Eq CDouble

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp CDouble -> Exp CDouble -> Exp Bool

(/=) :: Exp CDouble -> Exp CDouble -> Exp Bool

Eq Half

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp Half -> Exp Half -> Exp Bool

(/=) :: Exp Half -> Exp Half -> Exp Bool

Eq Z

Defined in Data.Array.Accelerate.Classes.Eq

Methods

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

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

Eq a => Eq (Maybe a)

Defined in Data.Array.Accelerate.Data.Maybe

Methods

(==) :: Exp (Maybe a) -> Exp (Maybe a) -> Exp Bool

(/=) :: Exp (Maybe a) -> Exp (Maybe a) -> Exp Bool

Integral a => Eq (Ratio a)

Defined in Data.Array.Accelerate.Data.Ratio

Methods

(==) :: Exp (Ratio a) -> Exp (Ratio a) -> Exp Bool

(/=) :: Exp (Ratio a) -> Exp (Ratio a) -> Exp Bool

Eq a => Eq (Complex a)

Defined in Data.Array.Accelerate.Data.Complex

Methods

(==) :: Exp (Complex a) -> Exp (Complex a) -> Exp Bool

(/=) :: Exp (Complex a) -> Exp (Complex a) -> Exp Bool

Eq a => Eq (Min a)

Defined in Data.Array.Accelerate.Data.Semigroup

Methods

(==) :: Exp (Min a) -> Exp (Min a) -> Exp Bool

(/=) :: Exp (Min a) -> Exp (Min a) -> Exp Bool

Eq a => Eq (Max a)

Defined in Data.Array.Accelerate.Data.Semigroup

Methods

(==) :: Exp (Max a) -> Exp (Max a) -> Exp Bool

(/=) :: Exp (Max a) -> Exp (Max a) -> Exp Bool

Eq a => Eq (Sum a)

Defined in Data.Array.Accelerate.Data.Monoid

Methods

(==) :: Exp (Sum a) -> Exp (Sum a) -> Exp Bool

(/=) :: Exp (Sum a) -> Exp (Sum a) -> Exp Bool

Eq a => Eq (Product a)

Defined in Data.Array.Accelerate.Data.Monoid

Methods

(==) :: Exp (Product a) -> Exp (Product a) -> Exp Bool

(/=) :: Exp (Product a) -> Exp (Product a) -> Exp Bool

(Eq a, Eq b) => Eq (Either a b)

Defined in Data.Array.Accelerate.Data.Either

Methods

(==) :: Exp (Either a b) -> Exp (Either a b) -> Exp Bool

(/=) :: Exp (Either a b) -> Exp (Either a b) -> Exp Bool

(Eq x0, Eq x1) => Eq (x0, x1)

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp (x0, x1) -> Exp (x0, x1) -> Exp Bool

(/=) :: Exp (x0, x1) -> Exp (x0, x1) -> Exp Bool

Eq sh => Eq (sh :. Int)

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp (sh :. Int) -> Exp (sh :. Int) -> Exp Bool

(/=) :: Exp (sh :. Int) -> Exp (sh :. Int) -> Exp Bool

(Eq x0, Eq x1, Eq x2) => Eq (x0, x1, x2)

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp (x0, x1, x2) -> Exp (x0, x1, x2) -> Exp Bool

(/=) :: Exp (x0, x1, x2) -> Exp (x0, x1, x2) -> Exp Bool

(Eq x0, Eq x1, Eq x2, Eq x3) => Eq (x0, x1, x2, x3)

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp (x0, x1, x2, x3) -> Exp (x0, x1, x2, x3) -> Exp Bool

(/=) :: Exp (x0, x1, x2, x3) -> Exp (x0, x1, x2, x3) -> Exp Bool

(Eq x0, Eq x1, Eq x2, Eq x3, Eq x4) => Eq (x0, x1, x2, x3, x4)

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp (x0, x1, x2, x3, x4) -> Exp (x0, x1, x2, x3, x4) -> Exp Bool

(/=) :: Exp (x0, x1, x2, x3, x4) -> Exp (x0, x1, x2, x3, x4) -> Exp Bool

(Eq x0, Eq x1, Eq x2, Eq x3, Eq x4, Eq x5) => Eq (x0, x1, x2, x3, x4, x5)

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp (x0, x1, x2, x3, x4, x5) -> Exp (x0, x1, x2, x3, x4, x5) -> Exp Bool

(/=) :: Exp (x0, x1, x2, x3, x4, x5) -> Exp (x0, x1, x2, x3, x4, x5) -> Exp Bool

(Eq x0, Eq x1, Eq x2, Eq x3, Eq x4, Eq x5, Eq x6) => Eq (x0, x1, x2, x3, x4, x5, x6)

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp (x0, x1, x2, x3, x4, x5, x6) -> Exp (x0, x1, x2, x3, x4, x5, x6) -> Exp Bool

(/=) :: Exp (x0, x1, x2, x3, x4, x5, x6) -> Exp (x0, x1, x2, x3, x4, x5, x6) -> Exp Bool

(Eq x0, Eq x1, Eq x2, Eq x3, Eq x4, Eq x5, Eq x6, Eq x7) => Eq (x0, x1, x2, x3, x4, x5, x6, x7)

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp (x0, x1, x2, x3, x4, x5, x6, x7) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7) -> Exp Bool

(/=) :: Exp (x0, x1, x2, x3, x4, x5, x6, x7) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7) -> Exp Bool

(Eq x0, Eq x1, Eq x2, Eq x3, Eq x4, Eq x5, Eq x6, Eq x7, Eq x8) => Eq (x0, x1, x2, x3, x4, x5, x6, x7, x8)

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8) -> Exp Bool

(/=) :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8) -> Exp Bool

(Eq x0, Eq x1, Eq x2, Eq x3, Eq x4, Eq x5, Eq x6, Eq x7, Eq x8, Eq x9) => Eq (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9)

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9) -> Exp Bool

(/=) :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9) -> Exp Bool

(Eq x0, Eq x1, Eq x2, Eq x3, Eq x4, Eq x5, Eq x6, Eq x7, Eq x8, Eq x9, Eq x10) => Eq (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10) -> Exp Bool

(/=) :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10) -> Exp Bool

(Eq x0, Eq x1, Eq x2, Eq x3, Eq x4, Eq x5, Eq x6, Eq x7, Eq x8, Eq x9, Eq x10, Eq x11) => Eq (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11) -> Exp Bool

(/=) :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11) -> Exp Bool

(Eq x0, Eq x1, Eq x2, Eq x3, Eq x4, Eq x5, Eq x6, Eq x7, Eq x8, Eq x9, Eq x10, Eq x11, Eq x12) => Eq (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12)

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12) -> Exp Bool

(/=) :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12) -> Exp Bool

(Eq x0, Eq x1, Eq x2, Eq x3, Eq x4, Eq x5, Eq x6, Eq x7, Eq x8, Eq x9, Eq x10, Eq x11, Eq x12, Eq x13) => Eq (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13)

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13) -> Exp Bool

(/=) :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13) -> Exp Bool

(Eq x0, Eq x1, Eq x2, Eq x3, Eq x4, Eq x5, Eq x6, Eq x7, Eq x8, Eq x9, Eq x10, Eq x11, Eq x12, Eq x13, Eq x14) => Eq (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14)

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14) -> Exp Bool

(/=) :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14) -> Exp Bool

(Eq x0, Eq x1, Eq x2, Eq x3, Eq x4, Eq x5, Eq x6, Eq x7, Eq x8, Eq x9, Eq x10, Eq x11, Eq x12, Eq x13, Eq x14, Eq x15) => Eq (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15)

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15) -> Exp Bool

(/=) :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15) -> Exp Bool

class Eq a => Ord a where

The Ord class for totally ordered datatypes

Minimal complete definition

(<=) | compare

Methods

(<) :: Exp a -> Exp a -> Exp Bool infix 4

(>) :: Exp a -> Exp a -> Exp Bool infix 4

(<=) :: Exp a -> Exp a -> Exp Bool infix 4

(>=) :: Exp a -> Exp a -> Exp Bool infix 4

min :: Exp a -> Exp a -> Exp a

max :: Exp a -> Exp a -> Exp a

compare :: Exp a -> Exp a -> Exp Ordering

Instances

Ord Char

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp Char -> Exp Char -> Exp Bool

(>) :: Exp Char -> Exp Char -> Exp Bool

(<=) :: Exp Char -> Exp Char -> Exp Bool

(>=) :: Exp Char -> Exp Char -> Exp Bool

min :: Exp Char -> Exp Char -> Exp Char

max :: Exp Char -> Exp Char -> Exp Char

compare :: Exp Char -> Exp Char -> Exp Ordering

Ord Double

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp Double -> Exp Double -> Exp Bool

(>) :: Exp Double -> Exp Double -> Exp Bool

(<=) :: Exp Double -> Exp Double -> Exp Bool

(>=) :: Exp Double -> Exp Double -> Exp Bool

min :: Exp Double -> Exp Double -> Exp Double

max :: Exp Double -> Exp Double -> Exp Double

compare :: Exp Double -> Exp Double -> Exp Ordering

Ord Float

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp Float -> Exp Float -> Exp Bool

(>) :: Exp Float -> Exp Float -> Exp Bool

(<=) :: Exp Float -> Exp Float -> Exp Bool

(>=) :: Exp Float -> Exp Float -> Exp Bool

min :: Exp Float -> Exp Float -> Exp Float

max :: Exp Float -> Exp Float -> Exp Float

compare :: Exp Float -> Exp Float -> Exp Ordering

Ord Int

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp Int -> Exp Int -> Exp Bool

(>) :: Exp Int -> Exp Int -> Exp Bool

(<=) :: Exp Int -> Exp Int -> Exp Bool

(>=) :: Exp Int -> Exp Int -> Exp Bool

min :: Exp Int -> Exp Int -> Exp Int

max :: Exp Int -> Exp Int -> Exp Int

compare :: Exp Int -> Exp Int -> Exp Ordering

Ord Int8

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp Int8 -> Exp Int8 -> Exp Bool

(>) :: Exp Int8 -> Exp Int8 -> Exp Bool

(<=) :: Exp Int8 -> Exp Int8 -> Exp Bool

(>=) :: Exp Int8 -> Exp Int8 -> Exp Bool

min :: Exp Int8 -> Exp Int8 -> Exp Int8

max :: Exp Int8 -> Exp Int8 -> Exp Int8

compare :: Exp Int8 -> Exp Int8 -> Exp Ordering

Ord Int16

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp Int16 -> Exp Int16 -> Exp Bool

(>) :: Exp Int16 -> Exp Int16 -> Exp Bool

(<=) :: Exp Int16 -> Exp Int16 -> Exp Bool

(>=) :: Exp Int16 -> Exp Int16 -> Exp Bool

min :: Exp Int16 -> Exp Int16 -> Exp Int16

max :: Exp Int16 -> Exp Int16 -> Exp Int16

compare :: Exp Int16 -> Exp Int16 -> Exp Ordering

Ord Int32

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp Int32 -> Exp Int32 -> Exp Bool

(>) :: Exp Int32 -> Exp Int32 -> Exp Bool

(<=) :: Exp Int32 -> Exp Int32 -> Exp Bool

(>=) :: Exp Int32 -> Exp Int32 -> Exp Bool

min :: Exp Int32 -> Exp Int32 -> Exp Int32

max :: Exp Int32 -> Exp Int32 -> Exp Int32

compare :: Exp Int32 -> Exp Int32 -> Exp Ordering

Ord Int64

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp Int64 -> Exp Int64 -> Exp Bool

(>) :: Exp Int64 -> Exp Int64 -> Exp Bool

(<=) :: Exp Int64 -> Exp Int64 -> Exp Bool

(>=) :: Exp Int64 -> Exp Int64 -> Exp Bool

min :: Exp Int64 -> Exp Int64 -> Exp Int64

max :: Exp Int64 -> Exp Int64 -> Exp Int64

compare :: Exp Int64 -> Exp Int64 -> Exp Ordering

Ord Ordering

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp Ordering -> Exp Ordering -> Exp Bool

(>) :: Exp Ordering -> Exp Ordering -> Exp Bool

(<=) :: Exp Ordering -> Exp Ordering -> Exp Bool

(>=) :: Exp Ordering -> Exp Ordering -> Exp Bool

min :: Exp Ordering -> Exp Ordering -> Exp Ordering

max :: Exp Ordering -> Exp Ordering -> Exp Ordering

compare :: Exp Ordering -> Exp Ordering -> Exp Ordering

Ord Word

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp Word -> Exp Word -> Exp Bool

(>) :: Exp Word -> Exp Word -> Exp Bool

(<=) :: Exp Word -> Exp Word -> Exp Bool

(>=) :: Exp Word -> Exp Word -> Exp Bool

min :: Exp Word -> Exp Word -> Exp Word

max :: Exp Word -> Exp Word -> Exp Word

compare :: Exp Word -> Exp Word -> Exp Ordering

Ord Word8

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp Word8 -> Exp Word8 -> Exp Bool

(>) :: Exp Word8 -> Exp Word8 -> Exp Bool

(<=) :: Exp Word8 -> Exp Word8 -> Exp Bool

(>=) :: Exp Word8 -> Exp Word8 -> Exp Bool

min :: Exp Word8 -> Exp Word8 -> Exp Word8

max :: Exp Word8 -> Exp Word8 -> Exp Word8

compare :: Exp Word8 -> Exp Word8 -> Exp Ordering

Ord Word16

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp Word16 -> Exp Word16 -> Exp Bool

(>) :: Exp Word16 -> Exp Word16 -> Exp Bool

(<=) :: Exp Word16 -> Exp Word16 -> Exp Bool

(>=) :: Exp Word16 -> Exp Word16 -> Exp Bool

min :: Exp Word16 -> Exp Word16 -> Exp Word16

max :: Exp Word16 -> Exp Word16 -> Exp Word16

compare :: Exp Word16 -> Exp Word16 -> Exp Ordering

Ord Word32

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp Word32 -> Exp Word32 -> Exp Bool

(>) :: Exp Word32 -> Exp Word32 -> Exp Bool

(<=) :: Exp Word32 -> Exp Word32 -> Exp Bool

(>=) :: Exp Word32 -> Exp Word32 -> Exp Bool

min :: Exp Word32 -> Exp Word32 -> Exp Word32

max :: Exp Word32 -> Exp Word32 -> Exp Word32

compare :: Exp Word32 -> Exp Word32 -> Exp Ordering

Ord Word64

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp Word64 -> Exp Word64 -> Exp Bool

(>) :: Exp Word64 -> Exp Word64 -> Exp Bool

(<=) :: Exp Word64 -> Exp Word64 -> Exp Bool

(>=) :: Exp Word64 -> Exp Word64 -> Exp Bool

min :: Exp Word64 -> Exp Word64 -> Exp Word64

max :: Exp Word64 -> Exp Word64 -> Exp Word64

compare :: Exp Word64 -> Exp Word64 -> Exp Ordering

Ord ()

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp () -> Exp () -> Exp Bool

(>) :: Exp () -> Exp () -> Exp Bool

(<=) :: Exp () -> Exp () -> Exp Bool

(>=) :: Exp () -> Exp () -> Exp Bool

min :: Exp () -> Exp () -> Exp ()

max :: Exp () -> Exp () -> Exp ()

compare :: Exp () -> Exp () -> Exp Ordering

Ord CChar

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp CChar -> Exp CChar -> Exp Bool

(>) :: Exp CChar -> Exp CChar -> Exp Bool

(<=) :: Exp CChar -> Exp CChar -> Exp Bool

(>=) :: Exp CChar -> Exp CChar -> Exp Bool

min :: Exp CChar -> Exp CChar -> Exp CChar

max :: Exp CChar -> Exp CChar -> Exp CChar

compare :: Exp CChar -> Exp CChar -> Exp Ordering

Ord CSChar

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp CSChar -> Exp CSChar -> Exp Bool

(>) :: Exp CSChar -> Exp CSChar -> Exp Bool

(<=) :: Exp CSChar -> Exp CSChar -> Exp Bool

(>=) :: Exp CSChar -> Exp CSChar -> Exp Bool

min :: Exp CSChar -> Exp CSChar -> Exp CSChar

max :: Exp CSChar -> Exp CSChar -> Exp CSChar

compare :: Exp CSChar -> Exp CSChar -> Exp Ordering

Ord CUChar

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp CUChar -> Exp CUChar -> Exp Bool

(>) :: Exp CUChar -> Exp CUChar -> Exp Bool

(<=) :: Exp CUChar -> Exp CUChar -> Exp Bool

(>=) :: Exp CUChar -> Exp CUChar -> Exp Bool

min :: Exp CUChar -> Exp CUChar -> Exp CUChar

max :: Exp CUChar -> Exp CUChar -> Exp CUChar

compare :: Exp CUChar -> Exp CUChar -> Exp Ordering

Ord CShort

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp CShort -> Exp CShort -> Exp Bool

(>) :: Exp CShort -> Exp CShort -> Exp Bool

(<=) :: Exp CShort -> Exp CShort -> Exp Bool

(>=) :: Exp CShort -> Exp CShort -> Exp Bool

min :: Exp CShort -> Exp CShort -> Exp CShort

max :: Exp CShort -> Exp CShort -> Exp CShort

compare :: Exp CShort -> Exp CShort -> Exp Ordering

Ord CUShort

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp CUShort -> Exp CUShort -> Exp Bool

(>) :: Exp CUShort -> Exp CUShort -> Exp Bool

(<=) :: Exp CUShort -> Exp CUShort -> Exp Bool

(>=) :: Exp CUShort -> Exp CUShort -> Exp Bool

min :: Exp CUShort -> Exp CUShort -> Exp CUShort

max :: Exp CUShort -> Exp CUShort -> Exp CUShort

compare :: Exp CUShort -> Exp CUShort -> Exp Ordering

Ord CInt

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp CInt -> Exp CInt -> Exp Bool

(>) :: Exp CInt -> Exp CInt -> Exp Bool

(<=) :: Exp CInt -> Exp CInt -> Exp Bool

(>=) :: Exp CInt -> Exp CInt -> Exp Bool

min :: Exp CInt -> Exp CInt -> Exp CInt

max :: Exp CInt -> Exp CInt -> Exp CInt

compare :: Exp CInt -> Exp CInt -> Exp Ordering

Ord CUInt

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp CUInt -> Exp CUInt -> Exp Bool

(>) :: Exp CUInt -> Exp CUInt -> Exp Bool

(<=) :: Exp CUInt -> Exp CUInt -> Exp Bool

(>=) :: Exp CUInt -> Exp CUInt -> Exp Bool

min :: Exp CUInt -> Exp CUInt -> Exp CUInt

max :: Exp CUInt -> Exp CUInt -> Exp CUInt

compare :: Exp CUInt -> Exp CUInt -> Exp Ordering

Ord CLong

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp CLong -> Exp CLong -> Exp Bool

(>) :: Exp CLong -> Exp CLong -> Exp Bool

(<=) :: Exp CLong -> Exp CLong -> Exp Bool

(>=) :: Exp CLong -> Exp CLong -> Exp Bool

min :: Exp CLong -> Exp CLong -> Exp CLong

max :: Exp CLong -> Exp CLong -> Exp CLong

compare :: Exp CLong -> Exp CLong -> Exp Ordering

Ord CULong

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp CULong -> Exp CULong -> Exp Bool

(>) :: Exp CULong -> Exp CULong -> Exp Bool

(<=) :: Exp CULong -> Exp CULong -> Exp Bool

(>=) :: Exp CULong -> Exp CULong -> Exp Bool

min :: Exp CULong -> Exp CULong -> Exp CULong

max :: Exp CULong -> Exp CULong -> Exp CULong

compare :: Exp CULong -> Exp CULong -> Exp Ordering

Ord CLLong

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp CLLong -> Exp CLLong -> Exp Bool

(>) :: Exp CLLong -> Exp CLLong -> Exp Bool

(<=) :: Exp CLLong -> Exp CLLong -> Exp Bool

(>=) :: Exp CLLong -> Exp CLLong -> Exp Bool

min :: Exp CLLong -> Exp CLLong -> Exp CLLong

max :: Exp CLLong -> Exp CLLong -> Exp CLLong

compare :: Exp CLLong -> Exp CLLong -> Exp Ordering

Ord CULLong

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp CULLong -> Exp CULLong -> Exp Bool

(>) :: Exp CULLong -> Exp CULLong -> Exp Bool

(<=) :: Exp CULLong -> Exp CULLong -> Exp Bool

(>=) :: Exp CULLong -> Exp CULLong -> Exp Bool

min :: Exp CULLong -> Exp CULLong -> Exp CULLong

max :: Exp CULLong -> Exp CULLong -> Exp CULLong

compare :: Exp CULLong -> Exp CULLong -> Exp Ordering

Ord CFloat

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp CFloat -> Exp CFloat -> Exp Bool

(>) :: Exp CFloat -> Exp CFloat -> Exp Bool

(<=) :: Exp CFloat -> Exp CFloat -> Exp Bool

(>=) :: Exp CFloat -> Exp CFloat -> Exp Bool

min :: Exp CFloat -> Exp CFloat -> Exp CFloat

max :: Exp CFloat -> Exp CFloat -> Exp CFloat

compare :: Exp CFloat -> Exp CFloat -> Exp Ordering

Ord CDouble

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp CDouble -> Exp CDouble -> Exp Bool

(>) :: Exp CDouble -> Exp CDouble -> Exp Bool

(<=) :: Exp CDouble -> Exp CDouble -> Exp Bool

(>=) :: Exp CDouble -> Exp CDouble -> Exp Bool

min :: Exp CDouble -> Exp CDouble -> Exp CDouble

max :: Exp CDouble -> Exp CDouble -> Exp CDouble

compare :: Exp CDouble -> Exp CDouble -> Exp Ordering

Ord Half

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp Half -> Exp Half -> Exp Bool

(>) :: Exp Half -> Exp Half -> Exp Bool

(<=) :: Exp Half -> Exp Half -> Exp Bool

(>=) :: Exp Half -> Exp Half -> Exp Bool

min :: Exp Half -> Exp Half -> Exp Half

max :: Exp Half -> Exp Half -> Exp Half

compare :: Exp Half -> Exp Half -> Exp Ordering

Ord Z

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp Z -> Exp Z -> Exp Bool

(>) :: Exp Z -> Exp Z -> Exp Bool

(<=) :: Exp Z -> Exp Z -> Exp Bool

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

min :: Exp Z -> Exp Z -> Exp Z

max :: Exp Z -> Exp Z -> Exp Z

compare :: Exp Z -> Exp Z -> Exp Ordering

Ord a => Ord (Maybe a)

Defined in Data.Array.Accelerate.Data.Maybe

Methods

(<) :: Exp (Maybe a) -> Exp (Maybe a) -> Exp Bool

(>) :: Exp (Maybe a) -> Exp (Maybe a) -> Exp Bool

(<=) :: Exp (Maybe a) -> Exp (Maybe a) -> Exp Bool

(>=) :: Exp (Maybe a) -> Exp (Maybe a) -> Exp Bool

min :: Exp (Maybe a) -> Exp (Maybe a) -> Exp (Maybe a)

max :: Exp (Maybe a) -> Exp (Maybe a) -> Exp (Maybe a)

compare :: Exp (Maybe a) -> Exp (Maybe a) -> Exp Ordering

Integral a => Ord (Ratio a)

Defined in Data.Array.Accelerate.Data.Ratio

Methods

(<) :: Exp (Ratio a) -> Exp (Ratio a) -> Exp Bool

(>) :: Exp (Ratio a) -> Exp (Ratio a) -> Exp Bool

(<=) :: Exp (Ratio a) -> Exp (Ratio a) -> Exp Bool

(>=) :: Exp (Ratio a) -> Exp (Ratio a) -> Exp Bool

min :: Exp (Ratio a) -> Exp (Ratio a) -> Exp (Ratio a)

max :: Exp (Ratio a) -> Exp (Ratio a) -> Exp (Ratio a)

compare :: Exp (Ratio a) -> Exp (Ratio a) -> Exp Ordering

Ord a => Ord (Min a)

Defined in Data.Array.Accelerate.Data.Semigroup

Methods

(<) :: Exp (Min a) -> Exp (Min a) -> Exp Bool

(>) :: Exp (Min a) -> Exp (Min a) -> Exp Bool

(<=) :: Exp (Min a) -> Exp (Min a) -> Exp Bool

(>=) :: Exp (Min a) -> Exp (Min a) -> Exp Bool

min :: Exp (Min a) -> Exp (Min a) -> Exp (Min a)

max :: Exp (Min a) -> Exp (Min a) -> Exp (Min a)

compare :: Exp (Min a) -> Exp (Min a) -> Exp Ordering

Ord a => Ord (Max a)

Defined in Data.Array.Accelerate.Data.Semigroup

Methods

(<) :: Exp (Max a) -> Exp (Max a) -> Exp Bool

(>) :: Exp (Max a) -> Exp (Max a) -> Exp Bool

(<=) :: Exp (Max a) -> Exp (Max a) -> Exp Bool

(>=) :: Exp (Max a) -> Exp (Max a) -> Exp Bool

min :: Exp (Max a) -> Exp (Max a) -> Exp (Max a)

max :: Exp (Max a) -> Exp (Max a) -> Exp (Max a)

compare :: Exp (Max a) -> Exp (Max a) -> Exp Ordering

Ord a => Ord (Sum a)

Defined in Data.Array.Accelerate.Data.Monoid

Methods

(<) :: Exp (Sum a) -> Exp (Sum a) -> Exp Bool

(>) :: Exp (Sum a) -> Exp (Sum a) -> Exp Bool

(<=) :: Exp (Sum a) -> Exp (Sum a) -> Exp Bool

(>=) :: Exp (Sum a) -> Exp (Sum a) -> Exp Bool

min :: Exp (Sum a) -> Exp (Sum a) -> Exp (Sum a)

max :: Exp (Sum a) -> Exp (Sum a) -> Exp (Sum a)

compare :: Exp (Sum a) -> Exp (Sum a) -> Exp Ordering

Ord a => Ord (Product a)

Defined in Data.Array.Accelerate.Data.Monoid

Methods

(<) :: Exp (Product a) -> Exp (Product a) -> Exp Bool

(>) :: Exp (Product a) -> Exp (Product a) -> Exp Bool

(<=) :: Exp (Product a) -> Exp (Product a) -> Exp Bool

(>=) :: Exp (Product a) -> Exp (Product a) -> Exp Bool

min :: Exp (Product a) -> Exp (Product a) -> Exp (Product a)

max :: Exp (Product a) -> Exp (Product a) -> Exp (Product a)

compare :: Exp (Product a) -> Exp (Product a) -> Exp Ordering

(Ord a, Ord b) => Ord (Either a b)

Defined in Data.Array.Accelerate.Data.Either

Methods

(<) :: Exp (Either a b) -> Exp (Either a b) -> Exp Bool

(>) :: Exp (Either a b) -> Exp (Either a b) -> Exp Bool

(<=) :: Exp (Either a b) -> Exp (Either a b) -> Exp Bool

(>=) :: Exp (Either a b) -> Exp (Either a b) -> Exp Bool

min :: Exp (Either a b) -> Exp (Either a b) -> Exp (Either a b)

max :: Exp (Either a b) -> Exp (Either a b) -> Exp (Either a b)

compare :: Exp (Either a b) -> Exp (Either a b) -> Exp Ordering

(Ord x0, Ord x1) => Ord (x0, x1)

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp (x0, x1) -> Exp (x0, x1) -> Exp Bool

(>) :: Exp (x0, x1) -> Exp (x0, x1) -> Exp Bool

(<=) :: Exp (x0, x1) -> Exp (x0, x1) -> Exp Bool

(>=) :: Exp (x0, x1) -> Exp (x0, x1) -> Exp Bool

min :: Exp (x0, x1) -> Exp (x0, x1) -> Exp (x0, x1)

max :: Exp (x0, x1) -> Exp (x0, x1) -> Exp (x0, x1)

compare :: Exp (x0, x1) -> Exp (x0, x1) -> Exp Ordering

Ord sh => Ord (sh :. Int)

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp (sh :. Int) -> Exp (sh :. Int) -> Exp Bool

(>) :: Exp (sh :. Int) -> Exp (sh :. Int) -> Exp Bool

(<=) :: Exp (sh :. Int) -> Exp (sh :. Int) -> Exp Bool

(>=) :: Exp (sh :. Int) -> Exp (sh :. Int) -> Exp Bool

min :: Exp (sh :. Int) -> Exp (sh :. Int) -> Exp (sh :. Int)

max :: Exp (sh :. Int) -> Exp (sh :. Int) -> Exp (sh :. Int)

compare :: Exp (sh :. Int) -> Exp (sh :. Int) -> Exp Ordering

(Ord x0, Ord x1, Ord x2) => Ord (x0, x1, x2)

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp (x0, x1, x2) -> Exp (x0, x1, x2) -> Exp Bool

(>) :: Exp (x0, x1, x2) -> Exp (x0, x1, x2) -> Exp Bool

(<=) :: Exp (x0, x1, x2) -> Exp (x0, x1, x2) -> Exp Bool

(>=) :: Exp (x0, x1, x2) -> Exp (x0, x1, x2) -> Exp Bool

min :: Exp (x0, x1, x2) -> Exp (x0, x1, x2) -> Exp (x0, x1, x2)

max :: Exp (x0, x1, x2) -> Exp (x0, x1, x2) -> Exp (x0, x1, x2)

compare :: Exp (x0, x1, x2) -> Exp (x0, x1, x2) -> Exp Ordering

(Ord x0, Ord x1, Ord x2, Ord x3) => Ord (x0, x1, x2, x3)

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp (x0, x1, x2, x3) -> Exp (x0, x1, x2, x3) -> Exp Bool

(>) :: Exp (x0, x1, x2, x3) -> Exp (x0, x1, x2, x3) -> Exp Bool

(<=) :: Exp (x0, x1, x2, x3) -> Exp (x0, x1, x2, x3) -> Exp Bool

(>=) :: Exp (x0, x1, x2, x3) -> Exp (x0, x1, x2, x3) -> Exp Bool

min :: Exp (x0, x1, x2, x3) -> Exp (x0, x1, x2, x3) -> Exp (x0, x1, x2, x3)

max :: Exp (x0, x1, x2, x3) -> Exp (x0, x1, x2, x3) -> Exp (x0, x1, x2, x3)

compare :: Exp (x0, x1, x2, x3) -> Exp (x0, x1, x2, x3) -> Exp Ordering

(Ord x0, Ord x1, Ord x2, Ord x3, Ord x4) => Ord (x0, x1, x2, x3, x4)

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp (x0, x1, x2, x3, x4) -> Exp (x0, x1, x2, x3, x4) -> Exp Bool

(>) :: Exp (x0, x1, x2, x3, x4) -> Exp (x0, x1, x2, x3, x4) -> Exp Bool

(<=) :: Exp (x0, x1, x2, x3, x4) -> Exp (x0, x1, x2, x3, x4) -> Exp Bool

(>=) :: Exp (x0, x1, x2, x3, x4) -> Exp (x0, x1, x2, x3, x4) -> Exp Bool

min :: Exp (x0, x1, x2, x3, x4) -> Exp (x0, x1, x2, x3, x4) -> Exp (x0, x1, x2, x3, x4)

max :: Exp (x0, x1, x2, x3, x4) -> Exp (x0, x1, x2, x3, x4) -> Exp (x0, x1, x2, x3, x4)

compare :: Exp (x0, x1, x2, x3, x4) -> Exp (x0, x1, x2, x3, x4) -> Exp Ordering

(Ord x0, Ord x1, Ord x2, Ord x3, Ord x4, Ord x5) => Ord (x0, x1, x2, x3, x4, x5)

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp (x0, x1, x2, x3, x4, x5) -> Exp (x0, x1, x2, x3, x4, x5) -> Exp Bool

(>) :: Exp (x0, x1, x2, x3, x4, x5) -> Exp (x0, x1, x2, x3, x4, x5) -> Exp Bool

(<=) :: Exp (x0, x1, x2, x3, x4, x5) -> Exp (x0, x1, x2, x3, x4, x5) -> Exp Bool

(>=) :: Exp (x0, x1, x2, x3, x4, x5) -> Exp (x0, x1, x2, x3, x4, x5) -> Exp Bool

min :: Exp (x0, x1, x2, x3, x4, x5) -> Exp (x0, x1, x2, x3, x4, x5) -> Exp (x0, x1, x2, x3, x4, x5)

max :: Exp (x0, x1, x2, x3, x4, x5) -> Exp (x0, x1, x2, x3, x4, x5) -> Exp (x0, x1, x2, x3, x4, x5)

compare :: Exp (x0, x1, x2, x3, x4, x5) -> Exp (x0, x1, x2, x3, x4, x5) -> Exp Ordering

(Ord x0, Ord x1, Ord x2, Ord x3, Ord x4, Ord x5, Ord x6) => Ord (x0, x1, x2, x3, x4, x5, x6)

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp (x0, x1, x2, x3, x4, x5, x6) -> Exp (x0, x1, x2, x3, x4, x5, x6) -> Exp Bool

(>) :: Exp (x0, x1, x2, x3, x4, x5, x6) -> Exp (x0, x1, x2, x3, x4, x5, x6) -> Exp Bool

(<=) :: Exp (x0, x1, x2, x3, x4, x5, x6) -> Exp (x0, x1, x2, x3, x4, x5, x6) -> Exp Bool

(>=) :: Exp (x0, x1, x2, x3, x4, x5, x6) -> Exp (x0, x1, x2, x3, x4, x5, x6) -> Exp Bool

min :: Exp (x0, x1, x2, x3, x4, x5, x6) -> Exp (x0, x1, x2, x3, x4, x5, x6) -> Exp (x0, x1, x2, x3, x4, x5, x6)

max :: Exp (x0, x1, x2, x3, x4, x5, x6) -> Exp (x0, x1, x2, x3, x4, x5, x6) -> Exp (x0, x1, x2, x3, x4, x5, x6)

compare :: Exp (x0, x1, x2, x3, x4, x5, x6) -> Exp (x0, x1, x2, x3, x4, x5, x6) -> Exp Ordering

(Ord x0, Ord x1, Ord x2, Ord x3, Ord x4, Ord x5, Ord x6, Ord x7) => Ord (x0, x1, x2, x3, x4, x5, x6, x7)

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp (x0, x1, x2, x3, x4, x5, x6, x7) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7) -> Exp Bool

(>) :: Exp (x0, x1, x2, x3, x4, x5, x6, x7) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7) -> Exp Bool

(<=) :: Exp (x0, x1, x2, x3, x4, x5, x6, x7) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7) -> Exp Bool

(>=) :: Exp (x0, x1, x2, x3, x4, x5, x6, x7) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7) -> Exp Bool

min :: Exp (x0, x1, x2, x3, x4, x5, x6, x7) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7)

max :: Exp (x0, x1, x2, x3, x4, x5, x6, x7) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7)

compare :: Exp (x0, x1, x2, x3, x4, x5, x6, x7) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7) -> Exp Ordering

(Ord x0, Ord x1, Ord x2, Ord x3, Ord x4, Ord x5, Ord x6, Ord x7, Ord x8) => Ord (x0, x1, x2, x3, x4, x5, x6, x7, x8)

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8) -> Exp Bool

(>) :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8) -> Exp Bool

(<=) :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8) -> Exp Bool

(>=) :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8) -> Exp Bool

min :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8)

max :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8)

compare :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8) -> Exp Ordering

(Ord x0, Ord x1, Ord x2, Ord x3, Ord x4, Ord x5, Ord x6, Ord x7, Ord x8, Ord x9) => Ord (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9)

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9) -> Exp Bool

(>) :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9) -> Exp Bool

(<=) :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9) -> Exp Bool

(>=) :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9) -> Exp Bool

min :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9)

max :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9)

compare :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9) -> Exp Ordering

(Ord x0, Ord x1, Ord x2, Ord x3, Ord x4, Ord x5, Ord x6, Ord x7, Ord x8, Ord x9, Ord x10) => Ord (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10) -> Exp Bool

(>) :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10) -> Exp Bool

(<=) :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10) -> Exp Bool

(>=) :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10) -> Exp Bool

min :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)

max :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)

compare :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10) -> Exp Ordering

(Ord x0, Ord x1, Ord x2, Ord x3, Ord x4, Ord x5, Ord x6, Ord x7, Ord x8, Ord x9, Ord x10, Ord x11) => Ord (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11) -> Exp Bool

(>) :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11) -> Exp Bool

(<=) :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11) -> Exp Bool

(>=) :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11) -> Exp Bool

min :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)

max :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)

compare :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11) -> Exp Ordering

(Ord x0, Ord x1, Ord x2, Ord x3, Ord x4, Ord x5, Ord x6, Ord x7, Ord x8, Ord x9, Ord x10, Ord x11, Ord x12) => Ord (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12)

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12) -> Exp Bool

(>) :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12) -> Exp Bool

(<=) :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12) -> Exp Bool

(>=) :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12) -> Exp Bool

min :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12)

max :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12)

compare :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12) -> Exp Ordering

(Ord x0, Ord x1, Ord x2, Ord x3, Ord x4, Ord x5, Ord x6, Ord x7, Ord x8, Ord x9, Ord x10, Ord x11, Ord x12, Ord x13) => Ord (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13)

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13) -> Exp Bool

(>) :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13) -> Exp Bool

(<=) :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13) -> Exp Bool

(>=) :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13) -> Exp Bool

min :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13)

max :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13)

compare :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13) -> Exp Ordering

(Ord x0, Ord x1, Ord x2, Ord x3, Ord x4, Ord x5, Ord x6, Ord x7, Ord x8, Ord x9, Ord x10, Ord x11, Ord x12, Ord x13, Ord x14) => Ord (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14)

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14) -> Exp Bool

(>) :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14) -> Exp Bool

(<=) :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14) -> Exp Bool

(>=) :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14) -> Exp Bool

min :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14)

max :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14)

compare :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14) -> Exp Ordering

(Ord x0, Ord x1, Ord x2, Ord x3, Ord x4, Ord x5, Ord x6, Ord x7, Ord x8, Ord x9, Ord x10, Ord x11, Ord x12, Ord x13, Ord x14, Ord x15) => Ord (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15)

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15) -> Exp Bool

(>) :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15) -> Exp Bool

(<=) :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15) -> Exp Bool

(>=) :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15) -> Exp Bool

min :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15)

max :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15)

compare :: Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15) -> Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15) -> Exp Ordering

data Ordering

Constructors

LT

EQ

GT

Instances

Bounded Ordering

Since: base-2.1

Defined in GHC.Enum

Methods

minBound :: Ordering

maxBound :: Ordering

Enum Ordering

Since: base-2.1

Defined in GHC.Enum

Methods

succ :: Ordering -> Ordering

pred :: Ordering -> Ordering

toEnum :: Int -> Ordering

fromEnum :: Ordering -> Int

enumFrom :: Ordering -> [Ordering]

enumFromThen :: Ordering -> Ordering -> [Ordering]

enumFromTo :: Ordering -> Ordering -> [Ordering]

enumFromThenTo :: Ordering -> Ordering -> Ordering -> [Ordering]

Eq Ordering

Defined in GHC.Classes

Methods

(==) :: Ordering -> Ordering -> Bool

(/=) :: Ordering -> Ordering -> Bool

Ord Ordering

Defined in GHC.Classes

Methods

compare :: Ordering -> Ordering -> Ordering

(<) :: Ordering -> Ordering -> Bool

(<=) :: Ordering -> Ordering -> Bool

(>) :: Ordering -> Ordering -> Bool

(>=) :: Ordering -> Ordering -> Bool

max :: Ordering -> Ordering -> Ordering

min :: Ordering -> Ordering -> Ordering

Read Ordering

Since: base-2.1

Defined in GHC.Read

Methods

readsPrec :: Int -> ReadS Ordering

readList :: ReadS [Ordering]

readPrec :: ReadPrec Ordering

readListPrec :: ReadPrec [Ordering]

Show Ordering

Since: base-2.1

Defined in GHC.Show

Methods

showsPrec :: Int -> Ordering -> ShowS

show :: Ordering -> String

showList :: [Ordering] -> ShowS

Ix Ordering

Since: base-2.1

Defined in GHC.Ix

Methods

range :: (Ordering, Ordering) -> [Ordering]

index :: (Ordering, Ordering) -> Ordering -> Int

unsafeIndex :: (Ordering, Ordering) -> Ordering -> Int

inRange :: (Ordering, Ordering) -> Ordering -> Bool

rangeSize :: (Ordering, Ordering) -> Int

unsafeRangeSize :: (Ordering, Ordering) -> Int

Generic Ordering

Since: base-4.6.0.0

Defined in GHC.Generics

Associated Types

type Rep Ordering :: Type -> Type

Methods

from :: Ordering -> Rep Ordering x

to :: Rep Ordering x -> Ordering

Semigroup Ordering

Since: base-4.9.0.0

Defined in GHC.Base

Methods

(<>) :: Ordering -> Ordering -> Ordering

sconcat :: NonEmpty Ordering -> Ordering

stimes :: Integral b => b -> Ordering -> Ordering

Monoid Ordering

Since: base-2.1

Defined in GHC.Base

Methods

mempty :: Ordering

mappend :: Ordering -> Ordering -> Ordering

mconcat :: [Ordering] -> Ordering

NFData Ordering

Defined in Control.DeepSeq

Methods

rnf :: Ordering -> ()

Hashable Ordering

Defined in Data.Hashable.Class

Methods

hashWithSalt :: Int -> Ordering -> Int

hash :: Ordering -> Int

AsEmpty Ordering

Defined in Control.Lens.Empty

Methods

_Empty :: Prism' Ordering ()

Elt Ordering

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR Ordering

Methods

eltR :: TypeR (EltR Ordering)

tagsR :: [TagR (EltR Ordering)]

fromElt :: Ordering -> EltR Ordering

toElt :: EltR Ordering -> Ordering

Eq Ordering

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(==) :: Exp Ordering -> Exp Ordering -> Exp Bool

(/=) :: Exp Ordering -> Exp Ordering -> Exp Bool

Ord Ordering

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp Ordering -> Exp Ordering -> Exp Bool

(>) :: Exp Ordering -> Exp Ordering -> Exp Bool

(<=) :: Exp Ordering -> Exp Ordering -> Exp Bool

(>=) :: Exp Ordering -> Exp Ordering -> Exp Bool

min :: Exp Ordering -> Exp Ordering -> Exp Ordering

max :: Exp Ordering -> Exp Ordering -> Exp Ordering

compare :: Exp Ordering -> Exp Ordering -> Exp Ordering

type Rep Ordering

Defined in GHC.Generics

type Rep Ordering = D1 ('MetaData "Ordering" "GHC.Types" "ghc-prim" 'False) (C1 ('MetaCons "LT" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "EQ" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "GT" 'PrefixI 'False) (U1 :: Type -> Type)))

pattern LT_ :: HasCallStack => Exp Ordering

pattern EQ_ :: HasCallStack => Exp Ordering

pattern GT_ :: HasCallStack => Exp Ordering

type Enum a = Enum (Exp a)

Operations over sequentially ordered types

succ :: Enum a => a -> a

the successor of a value. For numeric types, succ adds 1.

pred :: Enum a => a -> a

the predecessor of a value. For numeric types, pred subtracts 1.

type Bounded a = (Elt a, Bounded (Exp a))

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

Conversion from an Integer.

An integer literal represents the application of the function fromInteger to the appropriate value of type Integer. We export this specialised version where the return type is fixed to an Exp term in order to improve type checking in Accelerate modules when RebindableSyntax is enabled.

fromInteger :: Num a => Integer -> Exp a fromInteger = P.fromInteger

Basic numeric class

(+) :: Num a => a -> a -> a infixl 6

(-) :: Num a => a -> a -> a infixl 6

(*) :: Num a => a -> a -> a infixl 7

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, Ord a, Num a, Integral (Exp a))

Integral numbers, supporting integral division

quot :: Integral a => a -> a -> a infixl 7

integer division truncated toward zero

rem :: Integral a => a -> a -> a infixl 7

integer remainder, satisfying

(x `quot` y)*y + (x `rem` y) == x

div :: Integral a => a -> a -> a infixl 7

integer division truncated toward negative infinity

mod :: Integral a => a -> a -> a infixl 7

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

class (Num a, Ord a) => Rational a where

Numbers which can be expressed as the quotient of two integers.

Accelerate does not have an arbitrary precision Integer type, however fixed-length large integers are provide by the accelerate-bignum package.

Methods

toRational :: (FromIntegral Int64 b, Integral b) => Exp a -> Exp (Ratio b)

Convert a number to the quotient of two integers

Instances

Rational Double

Defined in Data.Array.Accelerate.Classes.Rational

Methods

toRational :: (FromIntegral Int64 b, Integral b) => Exp Double -> Exp (Ratio b)

Rational Float

Defined in Data.Array.Accelerate.Classes.Rational

Methods

toRational :: (FromIntegral Int64 b, Integral b) => Exp Float -> Exp (Ratio b)

Rational Int

Defined in Data.Array.Accelerate.Classes.Rational

Methods

toRational :: (FromIntegral Int64 b, Integral b) => Exp Int -> Exp (Ratio b)

Rational Int8

Defined in Data.Array.Accelerate.Classes.Rational

Methods

toRational :: (FromIntegral Int64 b, Integral b) => Exp Int8 -> Exp (Ratio b)

Rational Int16

Defined in Data.Array.Accelerate.Classes.Rational

Methods

toRational :: (FromIntegral Int64 b, Integral b) => Exp Int16 -> Exp (Ratio b)

Rational Int32

Defined in Data.Array.Accelerate.Classes.Rational

Methods

toRational :: (FromIntegral Int64 b, Integral b) => Exp Int32 -> Exp (Ratio b)

Rational Int64

Defined in Data.Array.Accelerate.Classes.Rational

Methods

toRational :: (FromIntegral Int64 b, Integral b) => Exp Int64 -> Exp (Ratio b)

Rational Word

Defined in Data.Array.Accelerate.Classes.Rational

Methods

toRational :: (FromIntegral Int64 b, Integral b) => Exp Word -> Exp (Ratio b)

Rational Word8

Defined in Data.Array.Accelerate.Classes.Rational

Methods

toRational :: (FromIntegral Int64 b, Integral b) => Exp Word8 -> Exp (Ratio b)

Rational Word16

Defined in Data.Array.Accelerate.Classes.Rational

Methods

toRational :: (FromIntegral Int64 b, Integral b) => Exp Word16 -> Exp (Ratio b)

Rational Word32

Defined in Data.Array.Accelerate.Classes.Rational

Methods

toRational :: (FromIntegral Int64 b, Integral b) => Exp Word32 -> Exp (Ratio b)

Rational Word64

Defined in Data.Array.Accelerate.Classes.Rational

Methods

toRational :: (FromIntegral Int64 b, Integral b) => Exp Word64 -> Exp (Ratio b)

Rational Half

Defined in Data.Array.Accelerate.Classes.Rational

Methods

toRational :: (FromIntegral Int64 b, Integral b) => Exp Half -> Exp (Ratio b)

type Fractional a = (Num a, Fractional (Exp a))

Conversion from a Rational.

A floating point literal representations the application of the function fromRational to a value of type Rational. We export this specialised version where the return type is fixed to an Exp term in order to improve type checking in Accelerate modules when RebindableSyntax is enabled.

fromRational :: Fractional a => Rational -> Exp a fromRational = P.fromRational

Fractional numbers, supporting real division

(/) :: Fractional a => a -> a -> a infixl 7

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

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 infixr 8

logBase :: Floating a => a -> a -> a

class (Ord a, Fractional a) => RealFrac a where

Extracting components of fractions.

Minimal complete definition

properFraction

Methods

properFraction :: (Integral b, FromIntegral Int64 b) => Exp a -> (Exp b, Exp a)

The function properFraction takes a real fractional number x and returns a pair (n,f) such that x = n+f, and:

• n is an integral number with the same sign as x; and
• f is a fraction with the same type and sign as x, and with absolute value less than 1.

The default definitions of the ceiling, floor, truncate and round functions are in terms of properFraction.

truncate :: (Integral b, FromIntegral Int64 b) => Exp a -> Exp b

truncate x returns the integer nearest x between zero and x

round :: (Integral b, FromIntegral Int64 b) => Exp a -> Exp b

round x returns the nearest integer to x; the even integer if x is equidistant between two integers

ceiling :: (Integral b, FromIntegral Int64 b) => Exp a -> Exp b

ceiling x returns the least integer not less than x

floor :: (Integral b, FromIntegral Int64 b) => Exp a -> Exp b

floor x returns the greatest integer not greater than x

Instances

RealFrac Double

Defined in Data.Array.Accelerate.Classes.RealFrac

Methods

properFraction :: (Integral b, FromIntegral Int64 b) => Exp Double -> (Exp b, Exp Double)

truncate :: (Integral b, FromIntegral Int64 b) => Exp Double -> Exp b

round :: (Integral b, FromIntegral Int64 b) => Exp Double -> Exp b

ceiling :: (Integral b, FromIntegral Int64 b) => Exp Double -> Exp b

floor :: (Integral b, FromIntegral Int64 b) => Exp Double -> Exp b

RealFrac Float

Defined in Data.Array.Accelerate.Classes.RealFrac

Methods

properFraction :: (Integral b, FromIntegral Int64 b) => Exp Float -> (Exp b, Exp Float)

truncate :: (Integral b, FromIntegral Int64 b) => Exp Float -> Exp b

round :: (Integral b, FromIntegral Int64 b) => Exp Float -> Exp b

ceiling :: (Integral b, FromIntegral Int64 b) => Exp Float -> Exp b

floor :: (Integral b, FromIntegral Int64 b) => Exp Float -> Exp b

RealFrac CFloat

Defined in Data.Array.Accelerate.Classes.RealFrac

Methods

properFraction :: (Integral b, FromIntegral Int64 b) => Exp CFloat -> (Exp b, Exp CFloat)

truncate :: (Integral b, FromIntegral Int64 b) => Exp CFloat -> Exp b

round :: (Integral b, FromIntegral Int64 b) => Exp CFloat -> Exp b

ceiling :: (Integral b, FromIntegral Int64 b) => Exp CFloat -> Exp b

floor :: (Integral b, FromIntegral Int64 b) => Exp CFloat -> Exp b

RealFrac CDouble

Defined in Data.Array.Accelerate.Classes.RealFrac

Methods

properFraction :: (Integral b, FromIntegral Int64 b) => Exp CDouble -> (Exp b, Exp CDouble)

truncate :: (Integral b, FromIntegral Int64 b) => Exp CDouble -> Exp b

round :: (Integral b, FromIntegral Int64 b) => Exp CDouble -> Exp b

ceiling :: (Integral b, FromIntegral Int64 b) => Exp CDouble -> Exp b

floor :: (Integral b, FromIntegral Int64 b) => Exp CDouble -> Exp b

RealFrac Half

Defined in Data.Array.Accelerate.Classes.RealFrac

Methods

properFraction :: (Integral b, FromIntegral Int64 b) => Exp Half -> (Exp b, Exp Half)

truncate :: (Integral b, FromIntegral Int64 b) => Exp Half -> Exp b

round :: (Integral b, FromIntegral Int64 b) => Exp Half -> Exp b

ceiling :: (Integral b, FromIntegral Int64 b) => Exp Half -> Exp b

floor :: (Integral b, FromIntegral Int64 b) => Exp Half -> Exp b

(Integral a, FromIntegral a Int64) => RealFrac (Ratio a)

Defined in Data.Array.Accelerate.Data.Ratio

Methods

properFraction :: (Integral b, FromIntegral Int64 b) => Exp (Ratio a) -> (Exp b, Exp (Ratio a))

truncate :: (Integral b, FromIntegral Int64 b) => Exp (Ratio a) -> Exp b

round :: (Integral b, FromIntegral Int64 b) => Exp (Ratio a) -> Exp b

ceiling :: (Integral b, FromIntegral Int64 b) => Exp (Ratio a) -> Exp b

floor :: (Integral b, FromIntegral Int64 b) => Exp (Ratio a) -> Exp b

div' :: (RealFrac a, FromIntegral Int64 b, Integral b) => Exp a -> Exp a -> Exp b

Generalisation of div to any instance of RealFrac

mod' :: (Floating a, RealFrac a, ToFloating Int64 a) => Exp a -> Exp a -> Exp a

Generalisation of mod to any instance of RealFrac

divMod' :: (Floating a, RealFrac a, Integral b, FromIntegral Int64 b, ToFloating b a) => Exp a -> Exp a -> (Exp b, Exp a)

Generalisation of divMod to any instance of RealFrac

class (RealFrac a, Floating a) => RealFloat a where

Efficient, machine-independent access to the components of a floating-point number

Minimal complete definition

decodeFloat, isNaN, isInfinite, isDenormalized, isNegativeZero, atan2

Methods

floatRadix :: Exp a -> Exp Int64

The radix of the representation (often 2) (constant)

default floatRadix :: RealFloat a => Exp a -> Exp Int64

floatDigits :: Exp a -> Exp Int

The number of digits of floatRadix in the significand (constant)

default floatDigits :: RealFloat a => Exp a -> Exp Int

floatRange :: Exp a -> (Exp Int, Exp Int)

The lowest and highest values the exponent may assume (constant)

default floatRange :: RealFloat a => Exp a -> (Exp Int, Exp Int)

decodeFloat :: Exp a -> (Exp Int64, Exp Int)

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

Inverse of decodeFloat

default encodeFloat :: (FromIntegral Int a, FromIntegral Int64 a) => Exp Int64 -> Exp Int -> Exp a

exponent :: Exp a -> Exp Int

Corresponds to the second component of decodeFloat

significand :: Exp a -> Exp a

Corresponds to the first component of decodeFloat

scaleFloat :: Exp Int -> Exp a -> Exp a

Multiply a floating point number by an integer power of the radix

isNaN :: Exp a -> Exp Bool

True if the argument is an IEEE "not-a-number" (NaN) value

isInfinite :: Exp a -> Exp Bool

True if the argument is an IEEE infinity or negative-infinity

isDenormalized :: Exp a -> Exp Bool

True if the argument is too small to be represented in normalized format

isNegativeZero :: Exp a -> Exp Bool

True if the argument is an IEEE negative zero

isIEEE :: Exp a -> Exp Bool

True if the argument is an IEEE floating point number

default isIEEE :: RealFloat a => Exp a -> Exp Bool

atan2 :: Exp a -> Exp a -> Exp a

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

Defined in Data.Array.Accelerate.Classes.RealFloat

Methods

floatRadix :: Exp Double -> Exp Int64

floatDigits :: Exp Double -> Exp Int

floatRange :: Exp Double -> (Exp Int, Exp Int)

decodeFloat :: Exp Double -> (Exp Int64, Exp Int)

encodeFloat :: Exp Int64 -> Exp Int -> Exp Double

exponent :: Exp Double -> Exp Int

significand :: Exp Double -> Exp Double

scaleFloat :: Exp Int -> Exp Double -> Exp Double

isNaN :: Exp Double -> Exp Bool

isInfinite :: Exp Double -> Exp Bool

isDenormalized :: Exp Double -> Exp Bool

isNegativeZero :: Exp Double -> Exp Bool

isIEEE :: Exp Double -> Exp Bool

atan2 :: Exp Double -> Exp Double -> Exp Double

RealFloat Float

Defined in Data.Array.Accelerate.Classes.RealFloat

Methods

floatRadix :: Exp Float -> Exp Int64

floatDigits :: Exp Float -> Exp Int

floatRange :: Exp Float -> (Exp Int, Exp Int)

decodeFloat :: Exp Float -> (Exp Int64, Exp Int)

encodeFloat :: Exp Int64 -> Exp Int -> Exp Float

exponent :: Exp Float -> Exp Int

significand :: Exp Float -> Exp Float

scaleFloat :: Exp Int -> Exp Float -> Exp Float

isNaN :: Exp Float -> Exp Bool

isInfinite :: Exp Float -> Exp Bool

isDenormalized :: Exp Float -> Exp Bool

isNegativeZero :: Exp Float -> Exp Bool

isIEEE :: Exp Float -> Exp Bool

atan2 :: Exp Float -> Exp Float -> Exp Float

RealFloat CFloat

Defined in Data.Array.Accelerate.Classes.RealFloat

Methods

floatRadix :: Exp CFloat -> Exp Int64

floatDigits :: Exp CFloat -> Exp Int

floatRange :: Exp CFloat -> (Exp Int, Exp Int)

decodeFloat :: Exp CFloat -> (Exp Int64, Exp Int)

encodeFloat :: Exp Int64 -> Exp Int -> Exp CFloat

exponent :: Exp CFloat -> Exp Int

significand :: Exp CFloat -> Exp CFloat

scaleFloat :: Exp Int -> Exp CFloat -> Exp CFloat

isNaN :: Exp CFloat -> Exp Bool

isInfinite :: Exp CFloat -> Exp Bool

isDenormalized :: Exp CFloat -> Exp Bool

isNegativeZero :: Exp CFloat -> Exp Bool

isIEEE :: Exp CFloat -> Exp Bool

atan2 :: Exp CFloat -> Exp CFloat -> Exp CFloat

RealFloat CDouble

Defined in Data.Array.Accelerate.Classes.RealFloat

Methods

floatRadix :: Exp CDouble -> Exp Int64

floatDigits :: Exp CDouble -> Exp Int

floatRange :: Exp CDouble -> (Exp Int, Exp Int)

decodeFloat :: Exp CDouble -> (Exp Int64, Exp Int)

encodeFloat :: Exp Int64 -> Exp Int -> Exp CDouble

exponent :: Exp CDouble -> Exp Int

significand :: Exp CDouble -> Exp CDouble

scaleFloat :: Exp Int -> Exp CDouble -> Exp CDouble

isNaN :: Exp CDouble -> Exp Bool

isInfinite :: Exp CDouble -> Exp Bool

isDenormalized :: Exp CDouble -> Exp Bool

isNegativeZero :: Exp CDouble -> Exp Bool

isIEEE :: Exp CDouble -> Exp Bool

atan2 :: Exp CDouble -> Exp CDouble -> Exp CDouble

RealFloat Half

Defined in Data.Array.Accelerate.Classes.RealFloat

Methods

floatRadix :: Exp Half -> Exp Int64

floatDigits :: Exp Half -> Exp Int

floatRange :: Exp Half -> (Exp Int, Exp Int)

decodeFloat :: Exp Half -> (Exp Int64, Exp Int)

encodeFloat :: Exp Int64 -> Exp Int -> Exp Half

exponent :: Exp Half -> Exp Int

significand :: Exp Half -> Exp Half

scaleFloat :: Exp Int -> Exp Half -> Exp Half

isNaN :: Exp Half -> Exp Bool

isInfinite :: Exp Half -> Exp Bool

isDenormalized :: Exp Half -> Exp Bool

isNegativeZero :: Exp Half -> Exp Bool

isIEEE :: Exp Half -> Exp Bool

atan2 :: Exp Half -> Exp Half -> Exp Half

Numeric conversion classes

class FromIntegral a b where

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.

Methods

fromIntegral :: Integral a => Exp a -> Exp b

General coercion from integral types

Instances

FromIntegral Int Double

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int -> Exp Double

FromIntegral Int Float

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int -> Exp Float

FromIntegral Int Int

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int -> Exp Int

FromIntegral Int Int8

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int -> Exp Int8

FromIntegral Int Int16

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int -> Exp Int16

FromIntegral Int Int32

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int -> Exp Int32

FromIntegral Int Int64

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int -> Exp Int64

FromIntegral Int Word

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int -> Exp Word

FromIntegral Int Word8

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int -> Exp Word8

FromIntegral Int Word16

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int -> Exp Word16

FromIntegral Int Word32

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int -> Exp Word32

FromIntegral Int Word64

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int -> Exp Word64

FromIntegral Int Half

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int -> Exp Half

FromIntegral Int8 Double

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int8 -> Exp Double

FromIntegral Int8 Float

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int8 -> Exp Float

FromIntegral Int8 Int

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int8 -> Exp Int

FromIntegral Int8 Int8

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int8 -> Exp Int8

FromIntegral Int8 Int16

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int8 -> Exp Int16

FromIntegral Int8 Int32

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int8 -> Exp Int32

FromIntegral Int8 Int64

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int8 -> Exp Int64

FromIntegral Int8 Word

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int8 -> Exp Word

FromIntegral Int8 Word8

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int8 -> Exp Word8

FromIntegral Int8 Word16

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int8 -> Exp Word16

FromIntegral Int8 Word32

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int8 -> Exp Word32

FromIntegral Int8 Word64

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int8 -> Exp Word64

FromIntegral Int8 Half

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int8 -> Exp Half

FromIntegral Int16 Double

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int16 -> Exp Double

FromIntegral Int16 Float

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int16 -> Exp Float

FromIntegral Int16 Int

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int16 -> Exp Int

FromIntegral Int16 Int8

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int16 -> Exp Int8

FromIntegral Int16 Int16

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int16 -> Exp Int16

FromIntegral Int16 Int32

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int16 -> Exp Int32

FromIntegral Int16 Int64

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int16 -> Exp Int64

FromIntegral Int16 Word

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int16 -> Exp Word

FromIntegral Int16 Word8

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int16 -> Exp Word8

FromIntegral Int16 Word16

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int16 -> Exp Word16

FromIntegral Int16 Word32

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int16 -> Exp Word32

FromIntegral Int16 Word64

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int16 -> Exp Word64

FromIntegral Int16 Half

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int16 -> Exp Half

FromIntegral Int32 Double

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int32 -> Exp Double

FromIntegral Int32 Float

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int32 -> Exp Float

FromIntegral Int32 Int

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int32 -> Exp Int

FromIntegral Int32 Int8

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int32 -> Exp Int8

FromIntegral Int32 Int16

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int32 -> Exp Int16

FromIntegral Int32 Int32

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int32 -> Exp Int32

FromIntegral Int32 Int64

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int32 -> Exp Int64

FromIntegral Int32 Word

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int32 -> Exp Word

FromIntegral Int32 Word8

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int32 -> Exp Word8

FromIntegral Int32 Word16

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int32 -> Exp Word16

FromIntegral Int32 Word32

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int32 -> Exp Word32

FromIntegral Int32 Word64

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int32 -> Exp Word64

FromIntegral Int32 Half

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int32 -> Exp Half

FromIntegral Int64 Double

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int64 -> Exp Double

FromIntegral Int64 Float

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int64 -> Exp Float

FromIntegral Int64 Int

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int64 -> Exp Int

FromIntegral Int64 Int8

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int64 -> Exp Int8

FromIntegral Int64 Int16

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int64 -> Exp Int16

FromIntegral Int64 Int32

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int64 -> Exp Int32

FromIntegral Int64 Int64

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int64 -> Exp Int64

FromIntegral Int64 Word

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int64 -> Exp Word

FromIntegral Int64 Word8

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int64 -> Exp Word8

FromIntegral Int64 Word16

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int64 -> Exp Word16

FromIntegral Int64 Word32

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int64 -> Exp Word32

FromIntegral Int64 Word64

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int64 -> Exp Word64

FromIntegral Int64 Half

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int64 -> Exp Half

FromIntegral Word Double

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word -> Exp Double

FromIntegral Word Float

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word -> Exp Float

FromIntegral Word Int

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word -> Exp Int

FromIntegral Word Int8

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word -> Exp Int8

FromIntegral Word Int16

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word -> Exp Int16

FromIntegral Word Int32

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word -> Exp Int32

FromIntegral Word Int64

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word -> Exp Int64

FromIntegral Word Word

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word -> Exp Word

FromIntegral Word Word8

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word -> Exp Word8

FromIntegral Word Word16

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word -> Exp Word16

FromIntegral Word Word32

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word -> Exp Word32

FromIntegral Word Word64

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word -> Exp Word64

FromIntegral Word Half

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word -> Exp Half

FromIntegral Word8 Double

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word8 -> Exp Double

FromIntegral Word8 Float

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word8 -> Exp Float

FromIntegral Word8 Int

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word8 -> Exp Int

FromIntegral Word8 Int8

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word8 -> Exp Int8

FromIntegral Word8 Int16

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word8 -> Exp Int16

FromIntegral Word8 Int32

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word8 -> Exp Int32

FromIntegral Word8 Int64

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word8 -> Exp Int64

FromIntegral Word8 Word

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word8 -> Exp Word

FromIntegral Word8 Word8

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word8 -> Exp Word8

FromIntegral Word8 Word16

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word8 -> Exp Word16

FromIntegral Word8 Word32

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word8 -> Exp Word32

FromIntegral Word8 Word64

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word8 -> Exp Word64

FromIntegral Word8 Half

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word8 -> Exp Half

FromIntegral Word16 Double

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word16 -> Exp Double

FromIntegral Word16 Float

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word16 -> Exp Float

FromIntegral Word16 Int

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word16 -> Exp Int

FromIntegral Word16 Int8

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word16 -> Exp Int8

FromIntegral Word16 Int16

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word16 -> Exp Int16

FromIntegral Word16 Int32

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word16 -> Exp Int32

FromIntegral Word16 Int64

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word16 -> Exp Int64

FromIntegral Word16 Word

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word16 -> Exp Word

FromIntegral Word16 Word8

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word16 -> Exp Word8

FromIntegral Word16 Word16

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word16 -> Exp Word16

FromIntegral Word16 Word32

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word16 -> Exp Word32

FromIntegral Word16 Word64

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word16 -> Exp Word64

FromIntegral Word16 Half

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word16 -> Exp Half

FromIntegral Word32 Double

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word32 -> Exp Double

FromIntegral Word32 Float

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word32 -> Exp Float

FromIntegral Word32 Int

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word32 -> Exp Int

FromIntegral Word32 Int8

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word32 -> Exp Int8

FromIntegral Word32 Int16

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word32 -> Exp Int16

FromIntegral Word32 Int32

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word32 -> Exp Int32

FromIntegral Word32 Int64

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word32 -> Exp Int64

FromIntegral Word32 Word

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word32 -> Exp Word

FromIntegral Word32 Word8

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word32 -> Exp Word8

FromIntegral Word32 Word16

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word32 -> Exp Word16

FromIntegral Word32 Word32

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word32 -> Exp Word32

FromIntegral Word32 Word64

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word32 -> Exp Word64

FromIntegral Word32 Half

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word32 -> Exp Half

FromIntegral Word64 Double

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word64 -> Exp Double

FromIntegral Word64 Float

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word64 -> Exp Float

FromIntegral Word64 Int

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word64 -> Exp Int

FromIntegral Word64 Int8

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word64 -> Exp Int8

FromIntegral Word64 Int16

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word64 -> Exp Int16

FromIntegral Word64 Int32

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word64 -> Exp Int32

FromIntegral Word64 Int64

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word64 -> Exp Int64

FromIntegral Word64 Word

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word64 -> Exp Word

FromIntegral Word64 Word8

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word64 -> Exp Word8

FromIntegral Word64 Word16

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word64 -> Exp Word16

FromIntegral Word64 Word32

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word64 -> Exp Word32

FromIntegral Word64 Word64

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word64 -> Exp Word64

FromIntegral Word64 Half

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word64 -> Exp Half

(FromIntegral a b, Integral b) => FromIntegral a (Ratio b)

Defined in Data.Array.Accelerate.Data.Ratio

Methods

fromIntegral :: Exp a -> Exp (Ratio b)

(FromIntegral a b, Num b, Elt (Complex b)) => FromIntegral a (Complex b)

Defined in Data.Array.Accelerate.Data.Complex

Methods

fromIntegral :: Exp a -> Exp (Complex b)

class ToFloating a b where

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 two types.

Methods

toFloating :: (Num a, Floating b) => Exp a -> Exp b

General coercion to floating types

Instances

ToFloating Double Double

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Double -> Exp Double

ToFloating Double Float

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Double -> Exp Float

ToFloating Double Half

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Double -> Exp Half

ToFloating Float Double

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Float -> Exp Double

ToFloating Float Float

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Float -> Exp Float

ToFloating Float Half

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Float -> Exp Half

ToFloating Int Double

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Int -> Exp Double

ToFloating Int Float

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Int -> Exp Float

ToFloating Int Half

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Int -> Exp Half

ToFloating Int8 Double

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Int8 -> Exp Double

ToFloating Int8 Float

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Int8 -> Exp Float

ToFloating Int8 Half

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Int8 -> Exp Half

ToFloating Int16 Double

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Int16 -> Exp Double

ToFloating Int16 Float

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Int16 -> Exp Float

ToFloating Int16 Half

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Int16 -> Exp Half

ToFloating Int32 Double

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Int32 -> Exp Double

ToFloating Int32 Float

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Int32 -> Exp Float

ToFloating Int32 Half

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Int32 -> Exp Half

ToFloating Int64 Double

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Int64 -> Exp Double

ToFloating Int64 Float

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Int64 -> Exp Float

ToFloating Int64 Half

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Int64 -> Exp Half

ToFloating Word Double

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Word -> Exp Double

ToFloating Word Float

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Word -> Exp Float

ToFloating Word Half

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Word -> Exp Half

ToFloating Word8 Double

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Word8 -> Exp Double

ToFloating Word8 Float

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Word8 -> Exp Float

ToFloating Word8 Half

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Word8 -> Exp Half

ToFloating Word16 Double

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Word16 -> Exp Double

ToFloating Word16 Float

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Word16 -> Exp Float

ToFloating Word16 Half

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Word16 -> Exp Half

ToFloating Word32 Double

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Word32 -> Exp Double

ToFloating Word32 Float

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Word32 -> Exp Float

ToFloating Word32 Half

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Word32 -> Exp Half

ToFloating Word64 Double

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Word64 -> Exp Double

ToFloating Word64 Float

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Word64 -> Exp Float

ToFloating Word64 Half

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Word64 -> Exp Half

ToFloating Half Double

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Half -> Exp Double

ToFloating Half Float

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Half -> Exp Float

ToFloating Half Half

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Half -> Exp Half

(Integral a, ToFloating a b) => ToFloating (Ratio a) b

Defined in Data.Array.Accelerate.Data.Ratio

Methods

toFloating :: Exp (Ratio a) -> Exp b

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 xs = use $ fromList (Z:.10) [0..]   :: Acc (Vector Int)
>>> let ys = use $ fromList (Z:.3:.4) [0..] :: Acc (Matrix Int)
>>> let r  = (xs,ys)                        :: (Acc (Vector Int), Acc (Matrix Int))
>>> let r' = lift r                         :: Acc (Vector Int, Matrix 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

For an alternative, see section Pattern synonyms.

class Lift c e where

The class of types e which can be lifted into c.

Associated Types

type Plain e

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)

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

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain Bool

Methods

lift :: Bool -> Exp (Plain Bool)

Lift Exp Char

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain Char

Methods

lift :: Char -> Exp (Plain Char)

Lift Exp Double

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain Double

Methods

lift :: Double -> Exp (Plain Double)

Lift Exp Float

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain Float

Methods

lift :: Float -> Exp (Plain Float)

Lift Exp Int

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain Int

Methods

lift :: Int -> Exp (Plain Int)

Lift Exp Int8

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain Int8

Methods

lift :: Int8 -> Exp (Plain Int8)

Lift Exp Int16

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain Int16

Methods

lift :: Int16 -> Exp (Plain Int16)

Lift Exp Int32

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain Int32

Methods

lift :: Int32 -> Exp (Plain Int32)

Lift Exp Int64

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain Int64

Methods

lift :: Int64 -> Exp (Plain Int64)

Lift Exp Word

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain Word

Methods

lift :: Word -> Exp (Plain Word)

Lift Exp Word8

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain Word8

Methods

lift :: Word8 -> Exp (Plain Word8)

Lift Exp Word16

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain Word16

Methods

lift :: Word16 -> Exp (Plain Word16)

Lift Exp Word32

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain Word32

Methods

lift :: Word32 -> Exp (Plain Word32)

Lift Exp Word64

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain Word64

Methods

lift :: Word64 -> Exp (Plain Word64)

Lift Exp ()

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain ()

Methods

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

Lift Exp CChar

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain CChar

Methods

lift :: CChar -> Exp (Plain CChar)

Lift Exp CSChar

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain CSChar

Methods

lift :: CSChar -> Exp (Plain CSChar)

Lift Exp CUChar

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain CUChar

Methods

lift :: CUChar -> Exp (Plain CUChar)

Lift Exp CShort

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain CShort

Methods

lift :: CShort -> Exp (Plain CShort)

Lift Exp CUShort

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain CUShort

Methods

lift :: CUShort -> Exp (Plain CUShort)

Lift Exp CInt

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain CInt

Methods

lift :: CInt -> Exp (Plain CInt)

Lift Exp CUInt

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain CUInt

Methods

lift :: CUInt -> Exp (Plain CUInt)

Lift Exp CLong

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain CLong

Methods

lift :: CLong -> Exp (Plain CLong)

Lift Exp CULong

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain CULong

Methods

lift :: CULong -> Exp (Plain CULong)

Lift Exp CLLong

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain CLLong

Methods

lift :: CLLong -> Exp (Plain CLLong)

Lift Exp CULLong

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain CULLong

Methods

lift :: CULLong -> Exp (Plain CULLong)

Lift Exp CFloat

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain CFloat

Methods

lift :: CFloat -> Exp (Plain CFloat)

Lift Exp CDouble

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain CDouble

Methods

lift :: CDouble -> Exp (Plain CDouble)

Lift Exp Half

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain Half

Methods

lift :: Half -> Exp (Plain Half)

Lift Exp Z

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain Z

Methods

lift :: Z -> Exp (Plain Z)

Lift Acc ()

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain ()

Methods

lift :: () -> Acc (Plain ())

(Lift Exp a, Elt (Plain a)) => Lift Exp (Maybe a)

Defined in Data.Array.Accelerate.Data.Maybe

Associated Types

type Plain (Maybe a)

Methods

lift :: Maybe a -> Exp (Plain (Maybe a))

(Lift Exp a, Elt (Plain a)) => Lift Exp (Complex a)

Defined in Data.Array.Accelerate.Data.Complex

Associated Types

type Plain (Complex a)

Methods

lift :: Complex a -> Exp (Plain (Complex a))

(Lift Exp a, Elt (Plain a)) => Lift Exp (Min a)

Defined in Data.Array.Accelerate.Data.Semigroup

Associated Types

type Plain (Min a)

Methods

lift :: Min a -> Exp (Plain (Min a))

(Lift Exp a, Elt (Plain a)) => Lift Exp (Max a)

Defined in Data.Array.Accelerate.Data.Semigroup

Associated Types

type Plain (Max a)

Methods

lift :: Max a -> Exp (Plain (Max a))

(Lift Exp a, Elt (Plain a)) => Lift Exp (Sum a)

Defined in Data.Array.Accelerate.Data.Monoid

Associated Types

type Plain (Sum a)

Methods

lift :: Sum a -> Exp (Plain (Sum a))

(Lift Exp a, Elt (Plain a)) => Lift Exp (Product a)

Defined in Data.Array.Accelerate.Data.Monoid

Associated Types

type Plain (Product a)

Methods

lift :: Product a -> Exp (Plain (Product a))

(Shape sh, Elt (Any sh)) => Lift Exp (Any sh)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (Any sh)

Methods

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

Lift Exp (Exp e)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (Exp e)

Methods

lift :: Exp e -> Exp (Plain (Exp e))

Lift Acc (Acc a)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (Acc a)

Methods

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

(Lift Exp a, Lift Exp b, Elt (Plain a), Elt (Plain b)) => Lift Exp (Either a b)

Defined in Data.Array.Accelerate.Data.Either

Associated Types

type Plain (Either a b)

Methods

lift :: Either a b -> Exp (Plain (Either a b))

((Lift Exp x0, Lift Exp x1), (Elt (Plain x0), Elt (Plain x1))) => Lift Exp (x0, x1)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (x0, x1)

Methods

lift :: (x0, x1) -> Exp (Plain (x0, x1))

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

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (ix :. Exp e)

Methods

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

(Elt (Plain ix), Lift Exp ix) => Lift Exp (ix :. All)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (ix :. All)

Methods

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

(Elt (Plain ix), Lift Exp ix) => Lift Exp (ix :. Int)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (ix :. Int)

Methods

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

((Lift Acc x0, Lift Acc x1), (Arrays (Plain x0), Arrays (Plain x1))) => Lift Acc (x0, x1)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (x0, x1)

Methods

lift :: (x0, x1) -> Acc (Plain (x0, x1))

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

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (Array sh e)

Methods

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

((Lift Exp x0, Lift Exp x1, Lift Exp x2), (Elt (Plain x0), Elt (Plain x1), Elt (Plain x2))) => Lift Exp (x0, x1, x2)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (x0, x1, x2)

Methods

lift :: (x0, x1, x2) -> Exp (Plain (x0, x1, x2))

((Lift Acc x0, Lift Acc x1, Lift Acc x2), (Arrays (Plain x0), Arrays (Plain x1), Arrays (Plain x2))) => Lift Acc (x0, x1, x2)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (x0, x1, x2)

Methods

lift :: (x0, x1, x2) -> Acc (Plain (x0, x1, x2))

((Lift Exp x0, Lift Exp x1, Lift Exp x2, Lift Exp x3), (Elt (Plain x0), Elt (Plain x1), Elt (Plain x2), Elt (Plain x3))) => Lift Exp (x0, x1, x2, x3)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (x0, x1, x2, x3)

Methods

lift :: (x0, x1, x2, x3) -> Exp (Plain (x0, x1, x2, x3))

((Lift Acc x0, Lift Acc x1, Lift Acc x2, Lift Acc x3), (Arrays (Plain x0), Arrays (Plain x1), Arrays (Plain x2), Arrays (Plain x3))) => Lift Acc (x0, x1, x2, x3)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (x0, x1, x2, x3)

Methods

lift :: (x0, x1, x2, x3) -> Acc (Plain (x0, x1, x2, x3))

((Lift Exp x0, Lift Exp x1, Lift Exp x2, Lift Exp x3, Lift Exp x4), (Elt (Plain x0), Elt (Plain x1), Elt (Plain x2), Elt (Plain x3), Elt (Plain x4))) => Lift Exp (x0, x1, x2, x3, x4)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (x0, x1, x2, x3, x4)

Methods

lift :: (x0, x1, x2, x3, x4) -> Exp (Plain (x0, x1, x2, x3, x4))

((Lift Acc x0, Lift Acc x1, Lift Acc x2, Lift Acc x3, Lift Acc x4), (Arrays (Plain x0), Arrays (Plain x1), Arrays (Plain x2), Arrays (Plain x3), Arrays (Plain x4))) => Lift Acc (x0, x1, x2, x3, x4)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (x0, x1, x2, x3, x4)

Methods

lift :: (x0, x1, x2, x3, x4) -> Acc (Plain (x0, x1, x2, x3, x4))

((Lift Exp x0, Lift Exp x1, Lift Exp x2, Lift Exp x3, Lift Exp x4, Lift Exp x5), (Elt (Plain x0), Elt (Plain x1), Elt (Plain x2), Elt (Plain x3), Elt (Plain x4), Elt (Plain x5))) => Lift Exp (x0, x1, x2, x3, x4, x5)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (x0, x1, x2, x3, x4, x5)

Methods

lift :: (x0, x1, x2, x3, x4, x5) -> Exp (Plain (x0, x1, x2, x3, x4, x5))

((Lift Acc x0, Lift Acc x1, Lift Acc x2, Lift Acc x3, Lift Acc x4, Lift Acc x5), (Arrays (Plain x0), Arrays (Plain x1), Arrays (Plain x2), Arrays (Plain x3), Arrays (Plain x4), Arrays (Plain x5))) => Lift Acc (x0, x1, x2, x3, x4, x5)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (x0, x1, x2, x3, x4, x5)

Methods

lift :: (x0, x1, x2, x3, x4, x5) -> Acc (Plain (x0, x1, x2, x3, x4, x5))

((Lift Exp x0, Lift Exp x1, Lift Exp x2, Lift Exp x3, Lift Exp x4, Lift Exp x5, Lift Exp x6), (Elt (Plain x0), Elt (Plain x1), Elt (Plain x2), Elt (Plain x3), Elt (Plain x4), Elt (Plain x5), Elt (Plain x6))) => Lift Exp (x0, x1, x2, x3, x4, x5, x6)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (x0, x1, x2, x3, x4, x5, x6)

Methods

lift :: (x0, x1, x2, x3, x4, x5, x6) -> Exp (Plain (x0, x1, x2, x3, x4, x5, x6))

((Lift Acc x0, Lift Acc x1, Lift Acc x2, Lift Acc x3, Lift Acc x4, Lift Acc x5, Lift Acc x6), (Arrays (Plain x0), Arrays (Plain x1), Arrays (Plain x2), Arrays (Plain x3), Arrays (Plain x4), Arrays (Plain x5), Arrays (Plain x6))) => Lift Acc (x0, x1, x2, x3, x4, x5, x6)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (x0, x1, x2, x3, x4, x5, x6)

Methods

lift :: (x0, x1, x2, x3, x4, x5, x6) -> Acc (Plain (x0, x1, x2, x3, x4, x5, x6))

((Lift Exp x0, Lift Exp x1, Lift Exp x2, Lift Exp x3, Lift Exp x4, Lift Exp x5, Lift Exp x6, Lift Exp x7), (Elt (Plain x0), Elt (Plain x1), Elt (Plain x2), Elt (Plain x3), Elt (Plain x4), Elt (Plain x5), Elt (Plain x6), Elt (Plain x7))) => Lift Exp (x0, x1, x2, x3, x4, x5, x6, x7)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (x0, x1, x2, x3, x4, x5, x6, x7)

Methods

lift :: (x0, x1, x2, x3, x4, x5, x6, x7) -> Exp (Plain (x0, x1, x2, x3, x4, x5, x6, x7))

((Lift Acc x0, Lift Acc x1, Lift Acc x2, Lift Acc x3, Lift Acc x4, Lift Acc x5, Lift Acc x6, Lift Acc x7), (Arrays (Plain x0), Arrays (Plain x1), Arrays (Plain x2), Arrays (Plain x3), Arrays (Plain x4), Arrays (Plain x5), Arrays (Plain x6), Arrays (Plain x7))) => Lift Acc (x0, x1, x2, x3, x4, x5, x6, x7)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (x0, x1, x2, x3, x4, x5, x6, x7)

Methods

lift :: (x0, x1, x2, x3, x4, x5, x6, x7) -> Acc (Plain (x0, x1, x2, x3, x4, x5, x6, x7))

((Lift Exp x0, Lift Exp x1, Lift Exp x2, Lift Exp x3, Lift Exp x4, Lift Exp x5, Lift Exp x6, Lift Exp x7, Lift Exp x8), (Elt (Plain x0), Elt (Plain x1), Elt (Plain x2), Elt (Plain x3), Elt (Plain x4), Elt (Plain x5), Elt (Plain x6), Elt (Plain x7), Elt (Plain x8))) => Lift Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (x0, x1, x2, x3, x4, x5, x6, x7, x8)

Methods

lift :: (x0, x1, x2, x3, x4, x5, x6, x7, x8) -> Exp (Plain (x0, x1, x2, x3, x4, x5, x6, x7, x8))

((Lift Acc x0, Lift Acc x1, Lift Acc x2, Lift Acc x3, Lift Acc x4, Lift Acc x5, Lift Acc x6, Lift Acc x7, Lift Acc x8), (Arrays (Plain x0), Arrays (Plain x1), Arrays (Plain x2), Arrays (Plain x3), Arrays (Plain x4), Arrays (Plain x5), Arrays (Plain x6), Arrays (Plain x7), Arrays (Plain x8))) => Lift Acc (x0, x1, x2, x3, x4, x5, x6, x7, x8)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (x0, x1, x2, x3, x4, x5, x6, x7, x8)

Methods

lift :: (x0, x1, x2, x3, x4, x5, x6, x7, x8) -> Acc (Plain (x0, x1, x2, x3, x4, x5, x6, x7, x8))

((Lift Exp x0, Lift Exp x1, Lift Exp x2, Lift Exp x3, Lift Exp x4, Lift Exp x5, Lift Exp x6, Lift Exp x7, Lift Exp x8, Lift Exp x9), (Elt (Plain x0), Elt (Plain x1), Elt (Plain x2), Elt (Plain x3), Elt (Plain x4), Elt (Plain x5), Elt (Plain x6), Elt (Plain x7), Elt (Plain x8), Elt (Plain x9))) => Lift Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9)

Methods

lift :: (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9) -> Exp (Plain (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9))

((Lift Acc x0, Lift Acc x1, Lift Acc x2, Lift Acc x3, Lift Acc x4, Lift Acc x5, Lift Acc x6, Lift Acc x7, Lift Acc x8, Lift Acc x9), (Arrays (Plain x0), Arrays (Plain x1), Arrays (Plain x2), Arrays (Plain x3), Arrays (Plain x4), Arrays (Plain x5), Arrays (Plain x6), Arrays (Plain x7), Arrays (Plain x8), Arrays (Plain x9))) => Lift Acc (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9)

Methods

lift :: (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9) -> Acc (Plain (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9))

((Lift Exp x0, Lift Exp x1, Lift Exp x2, Lift Exp x3, Lift Exp x4, Lift Exp x5, Lift Exp x6, Lift Exp x7, Lift Exp x8, Lift Exp x9, Lift Exp x10), (Elt (Plain x0), Elt (Plain x1), Elt (Plain x2), Elt (Plain x3), Elt (Plain x4), Elt (Plain x5), Elt (Plain x6), Elt (Plain x7), Elt (Plain x8), Elt (Plain x9), Elt (Plain x10))) => Lift Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)

Methods

lift :: (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10) -> Exp (Plain (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10))

((Lift Acc x0, Lift Acc x1, Lift Acc x2, Lift Acc x3, Lift Acc x4, Lift Acc x5, Lift Acc x6, Lift Acc x7, Lift Acc x8, Lift Acc x9, Lift Acc x10), (Arrays (Plain x0), Arrays (Plain x1), Arrays (Plain x2), Arrays (Plain x3), Arrays (Plain x4), Arrays (Plain x5), Arrays (Plain x6), Arrays (Plain x7), Arrays (Plain x8), Arrays (Plain x9), Arrays (Plain x10))) => Lift Acc (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)

Methods

lift :: (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10) -> Acc (Plain (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10))

((Lift Exp x0, Lift Exp x1, Lift Exp x2, Lift Exp x3, Lift Exp x4, Lift Exp x5, Lift Exp x6, Lift Exp x7, Lift Exp x8, Lift Exp x9, Lift Exp x10, Lift Exp x11), (Elt (Plain x0), Elt (Plain x1), Elt (Plain x2), Elt (Plain x3), Elt (Plain x4), Elt (Plain x5), Elt (Plain x6), Elt (Plain x7), Elt (Plain x8), Elt (Plain x9), Elt (Plain x10), Elt (Plain x11))) => Lift Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)

Methods

lift :: (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11) -> Exp (Plain (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11))

((Lift Acc x0, Lift Acc x1, Lift Acc x2, Lift Acc x3, Lift Acc x4, Lift Acc x5, Lift Acc x6, Lift Acc x7, Lift Acc x8, Lift Acc x9, Lift Acc x10, Lift Acc x11), (Arrays (Plain x0), Arrays (Plain x1), Arrays (Plain x2), Arrays (Plain x3), Arrays (Plain x4), Arrays (Plain x5), Arrays (Plain x6), Arrays (Plain x7), Arrays (Plain x8), Arrays (Plain x9), Arrays (Plain x10), Arrays (Plain x11))) => Lift Acc (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)

Methods

lift :: (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11) -> Acc (Plain (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11))

((Lift Exp x0, Lift Exp x1, Lift Exp x2, Lift Exp x3, Lift Exp x4, Lift Exp x5, Lift Exp x6, Lift Exp x7, Lift Exp x8, Lift Exp x9, Lift Exp x10, Lift Exp x11, Lift Exp x12), (Elt (Plain x0), Elt (Plain x1), Elt (Plain x2), Elt (Plain x3), Elt (Plain x4), Elt (Plain x5), Elt (Plain x6), Elt (Plain x7), Elt (Plain x8), Elt (Plain x9), Elt (Plain x10), Elt (Plain x11), Elt (Plain x12))) => Lift Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12)

Methods

lift :: (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12) -> Exp (Plain (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12))

((Lift Acc x0, Lift Acc x1, Lift Acc x2, Lift Acc x3, Lift Acc x4, Lift Acc x5, Lift Acc x6, Lift Acc x7, Lift Acc x8, Lift Acc x9, Lift Acc x10, Lift Acc x11, Lift Acc x12), (Arrays (Plain x0), Arrays (Plain x1), Arrays (Plain x2), Arrays (Plain x3), Arrays (Plain x4), Arrays (Plain x5), Arrays (Plain x6), Arrays (Plain x7), Arrays (Plain x8), Arrays (Plain x9), Arrays (Plain x10), Arrays (Plain x11), Arrays (Plain x12))) => Lift Acc (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12)

Methods

lift :: (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12) -> Acc (Plain (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12))

((Lift Exp x0, Lift Exp x1, Lift Exp x2, Lift Exp x3, Lift Exp x4, Lift Exp x5, Lift Exp x6, Lift Exp x7, Lift Exp x8, Lift Exp x9, Lift Exp x10, Lift Exp x11, Lift Exp x12, Lift Exp x13), (Elt (Plain x0), Elt (Plain x1), Elt (Plain x2), Elt (Plain x3), Elt (Plain x4), Elt (Plain x5), Elt (Plain x6), Elt (Plain x7), Elt (Plain x8), Elt (Plain x9), Elt (Plain x10), Elt (Plain x11), Elt (Plain x12), Elt (Plain x13))) => Lift Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13)

Methods

lift :: (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13) -> Exp (Plain (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13))

((Lift Acc x0, Lift Acc x1, Lift Acc x2, Lift Acc x3, Lift Acc x4, Lift Acc x5, Lift Acc x6, Lift Acc x7, Lift Acc x8, Lift Acc x9, Lift Acc x10, Lift Acc x11, Lift Acc x12, Lift Acc x13), (Arrays (Plain x0), Arrays (Plain x1), Arrays (Plain x2), Arrays (Plain x3), Arrays (Plain x4), Arrays (Plain x5), Arrays (Plain x6), Arrays (Plain x7), Arrays (Plain x8), Arrays (Plain x9), Arrays (Plain x10), Arrays (Plain x11), Arrays (Plain x12), Arrays (Plain x13))) => Lift Acc (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13)

Methods

lift :: (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13) -> Acc (Plain (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13))

((Lift Exp x0, Lift Exp x1, Lift Exp x2, Lift Exp x3, Lift Exp x4, Lift Exp x5, Lift Exp x6, Lift Exp x7, Lift Exp x8, Lift Exp x9, Lift Exp x10, Lift Exp x11, Lift Exp x12, Lift Exp x13, Lift Exp x14), (Elt (Plain x0), Elt (Plain x1), Elt (Plain x2), Elt (Plain x3), Elt (Plain x4), Elt (Plain x5), Elt (Plain x6), Elt (Plain x7), Elt (Plain x8), Elt (Plain x9), Elt (Plain x10), Elt (Plain x11), Elt (Plain x12), Elt (Plain x13), Elt (Plain x14))) => Lift Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14)

Methods

lift :: (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14) -> Exp (Plain (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14))

((Lift Acc x0, Lift Acc x1, Lift Acc x2, Lift Acc x3, Lift Acc x4, Lift Acc x5, Lift Acc x6, Lift Acc x7, Lift Acc x8, Lift Acc x9, Lift Acc x10, Lift Acc x11, Lift Acc x12, Lift Acc x13, Lift Acc x14), (Arrays (Plain x0), Arrays (Plain x1), Arrays (Plain x2), Arrays (Plain x3), Arrays (Plain x4), Arrays (Plain x5), Arrays (Plain x6), Arrays (Plain x7), Arrays (Plain x8), Arrays (Plain x9), Arrays (Plain x10), Arrays (Plain x11), Arrays (Plain x12), Arrays (Plain x13), Arrays (Plain x14))) => Lift Acc (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14)

Methods

lift :: (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14) -> Acc (Plain (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14))

((Lift Exp x0, Lift Exp x1, Lift Exp x2, Lift Exp x3, Lift Exp x4, Lift Exp x5, Lift Exp x6, Lift Exp x7, Lift Exp x8, Lift Exp x9, Lift Exp x10, Lift Exp x11, Lift Exp x12, Lift Exp x13, Lift Exp x14, Lift Exp x15), (Elt (Plain x0), Elt (Plain x1), Elt (Plain x2), Elt (Plain x3), Elt (Plain x4), Elt (Plain x5), Elt (Plain x6), Elt (Plain x7), Elt (Plain x8), Elt (Plain x9), Elt (Plain x10), Elt (Plain x11), Elt (Plain x12), Elt (Plain x13), Elt (Plain x14), Elt (Plain x15))) => Lift Exp (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15)

Methods

lift :: (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15) -> Exp (Plain (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15))

((Lift Acc x0, Lift Acc x1, Lift Acc x2, Lift Acc x3, Lift Acc x4, Lift Acc x5, Lift Acc x6, Lift Acc x7, Lift Acc x8, Lift Acc x9, Lift Acc x10, Lift Acc x11, Lift Acc x12, Lift Acc x13, Lift Acc x14, Lift Acc x15), (Arrays (Plain x0), Arrays (Plain x1), Arrays (Plain x2), Arrays (Plain x3), Arrays (Plain x4), Arrays (Plain x5), Arrays (Plain x6), Arrays (Plain x7), Arrays (Plain x8), Arrays (Plain x9), Arrays (Plain x10), Arrays (Plain x11), Arrays (Plain x12), Arrays (Plain x13), Arrays (Plain x14), Arrays (Plain x15))) => Lift Acc (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15)

Methods

lift :: (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15) -> Acc (Plain (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15))

class Lift c e => Unlift c e where

A limited subset of types which can be lifted, can also be unlifted.

Methods

unlift :: c (Plain e) -> e

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

Defined in Data.Array.Accelerate.Lift

Methods

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

Unlift Exp Z

Defined in Data.Array.Accelerate.Lift

Methods

unlift :: Exp (Plain Z) -> Z

Unlift Acc ()

Defined in Data.Array.Accelerate.Lift

Methods

unlift :: Acc (Plain ()) -> ()

Elt a => Unlift Exp (Complex (Exp a))

Defined in Data.Array.Accelerate.Data.Complex

Methods

unlift :: Exp (Plain (Complex (Exp a))) -> Complex (Exp a)

Elt a => Unlift Exp (Min (Exp a))

Defined in Data.Array.Accelerate.Data.Semigroup

Methods

unlift :: Exp (Plain (Min (Exp a))) -> Min (Exp a)

Elt a => Unlift Exp (Max (Exp a))

Defined in Data.Array.Accelerate.Data.Semigroup

Methods

unlift :: Exp (Plain (Max (Exp a))) -> Max (Exp a)

Elt a => Unlift Exp (Sum (Exp a))

Defined in Data.Array.Accelerate.Data.Monoid

Methods

unlift :: Exp (Plain (Sum (Exp a))) -> Sum (Exp a)

Elt a => Unlift Exp (Product (Exp a))

Defined in Data.Array.Accelerate.Data.Monoid

Methods

unlift :: Exp (Plain (Product (Exp a))) -> Product (Exp a)

Unlift Exp (Exp e)

Defined in Data.Array.Accelerate.Lift

Methods

unlift :: Exp (Plain (Exp e)) -> Exp e

Unlift Acc (Acc a)

Defined in Data.Array.Accelerate.Lift

Methods

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

(Elt x0, Elt x1) => Unlift Exp (Exp x0, Exp x1)

Defined in Data.Array.Accelerate.Lift

Methods

unlift :: Exp (Plain (Exp x0, Exp x1)) -> (Exp x0, Exp x1)

(Elt e, Elt (Plain ix), Unlift Exp ix) => Unlift Exp (ix :. Exp e)

Defined in Data.Array.Accelerate.Lift

Methods

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

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

Defined in Data.Array.Accelerate.Lift

Methods

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

(Arrays x0, Arrays x1) => Unlift Acc (Acc x0, Acc x1)

Defined in Data.Array.Accelerate.Lift

Methods

unlift :: Acc (Plain (Acc x0, Acc x1)) -> (Acc x0, Acc x1)

(Elt x0, Elt x1, Elt x2) => Unlift Exp (Exp x0, Exp x1, Exp x2)

Defined in Data.Array.Accelerate.Lift

Methods

unlift :: Exp (Plain (Exp x0, Exp x1, Exp x2)) -> (Exp x0, Exp x1, Exp x2)

(Arrays x0, Arrays x1, Arrays x2) => Unlift Acc (Acc x0, Acc x1, Acc x2)

Defined in Data.Array.Accelerate.Lift

Methods

unlift :: Acc (Plain (Acc x0, Acc x1, Acc x2)) -> (Acc x0, Acc x1, Acc x2)

(Elt x0, Elt x1, Elt x2, Elt x3) => Unlift Exp (Exp x0, Exp x1, Exp x2, Exp x3)

Defined in Data.Array.Accelerate.Lift

Methods

unlift :: Exp (Plain (Exp x0, Exp x1, Exp x2, Exp x3)) -> (Exp x0, Exp x1, Exp x2, Exp x3)

(Arrays x0, Arrays x1, Arrays x2, Arrays x3) => Unlift Acc (Acc x0, Acc x1, Acc x2, Acc x3)

Defined in Data.Array.Accelerate.Lift

Methods

unlift :: Acc (Plain (Acc x0, Acc x1, Acc x2, Acc x3)) -> (Acc x0, Acc x1, Acc x2, Acc x3)

(Elt x0, Elt x1, Elt x2, Elt x3, Elt x4) => Unlift Exp (Exp x0, Exp x1, Exp x2, Exp x3, Exp x4)

Defined in Data.Array.Accelerate.Lift

Methods

unlift :: Exp (Plain (Exp x0, Exp x1, Exp x2, Exp x3, Exp x4)) -> (Exp x0, Exp x1, Exp x2, Exp x3, Exp x4)

(Arrays x0, Arrays x1, Arrays x2, Arrays x3, Arrays x4) => Unlift Acc (Acc x0, Acc x1, Acc x2, Acc x3, Acc x4)

Defined in Data.Array.Accelerate.Lift

Methods

unlift :: Acc (Plain (Acc x0, Acc x1, Acc x2, Acc x3, Acc x4)) -> (Acc x0, Acc x1, Acc x2, Acc x3, Acc x4)

(Elt x0, Elt x1, Elt x2, Elt x3, Elt x4, Elt x5) => Unlift Exp (Exp x0, Exp x1, Exp x2, Exp x3, Exp x4, Exp x5)

Defined in Data.Array.Accelerate.Lift

Methods

unlift :: Exp (Plain (Exp x0, Exp x1, Exp x2, Exp x3, Exp x4, Exp x5)) -> (Exp x0, Exp x1, Exp x2, Exp x3, Exp x4, Exp x5)

(Arrays x0, Arrays x1, Arrays x2, Arrays x3, Arrays x4, Arrays x5) => Unlift Acc (Acc x0, Acc x1, Acc x2, Acc x3, Acc x4, Acc x5)

Defined in Data.Array.Accelerate.Lift

Methods

unlift :: Acc (Plain (Acc x0, Acc x1, Acc x2, Acc x3, Acc x4, Acc x5)) -> (Acc x0, Acc x1, Acc x2, Acc x3, Acc x4, Acc x5)

(Elt x0, Elt x1, Elt x2, Elt x3, Elt x4, Elt x5, Elt x6) => Unlift Exp (Exp x0, Exp x1, Exp x2, Exp x3, Exp x4, Exp x5, Exp x6)

Defined in Data.Array.Accelerate.Lift

Methods

unlift :: Exp (Plain (Exp x0, Exp x1, Exp x2, Exp x3, Exp x4, Exp x5, Exp x6)) -> (Exp x0, Exp x1, Exp x2, Exp x3, Exp x4, Exp x5, Exp x6)

(Arrays x0, Arrays x1, Arrays x2, Arrays x3, Arrays x4, Arrays x5, Arrays x6) => Unlift Acc (Acc x0, Acc x1, Acc x2, Acc x3, Acc x4, Acc x5, Acc x6)

Defined in Data.Array.Accelerate.Lift

Methods

unlift :: Acc (Plain (Acc x0, Acc x1, Acc x2, Acc x3, Acc x4, Acc x5, Acc x6)) -> (Acc x0, Acc x1, Acc x2, Acc x3, Acc x4, Acc x5, Acc x6)

(Elt x0, Elt x1, Elt x2, Elt x3, Elt x4, Elt x5, Elt x6, Elt x7) => Unlift Exp (Exp x0, Exp x1, Exp x2, Exp x3, Exp x4, Exp x5, Exp x6, Exp x7)

Defined in Data.Array.Accelerate.Lift

Methods

unlift :: Exp (Plain (Exp x0, Exp x1, Exp x2, Exp x3, Exp x4, Exp x5, Exp x6, Exp x7)) -> (Exp x0, Exp x1, Exp x2, Exp x3, Exp x4, Exp x5, Exp x6, Exp x7)

(Arrays x0, Arrays x1, Arrays x2, Arrays x3, Arrays x4, Arrays x5, Arrays x6, Arrays x7) => Unlift Acc (Acc x0, Acc x1, Acc x2, Acc x3, Acc x4, Acc x5, Acc x6, Acc x7)

Defined in Data.Array.Accelerate.Lift

Methods

unlift :: Acc (Plain (Acc x0, Acc x1, Acc x2, Acc x3, Acc x4, Acc x5, Acc x6, Acc x7)) -> (Acc x0, Acc x1, Acc x2, Acc x3, Acc x4, Acc x5, Acc x6, Acc x7)

(Elt x0, Elt x1, Elt x2, Elt x3, Elt x4, Elt x5, Elt x6, Elt x7, Elt x8) => Unlift Exp (Exp x0, Exp x1, Exp x2, Exp x3, Exp x4, Exp x5, Exp x6, Exp x7, Exp x8)

Defined in Data.Array.Accelerate.Lift

Methods

unlift :: Exp (Plain (Exp x0, Exp x1, Exp x2, Exp x3, Exp x4, Exp x5, Exp x6, Exp x7, Exp x8)) -> (Exp x0, Exp x1, Exp x2, Exp x3, Exp x4, Exp x5, Exp x6, Exp x7, Exp x8)

(Arrays x0, Arrays x1, Arrays x2, Arrays x3, Arrays x4, Arrays x5, Arrays x6, Arrays x7, Arrays x8) => Unlift Acc (Acc x0, Acc x1, Acc x2, Acc x3, Acc x4, Acc x5, Acc x6, Acc x7, Acc x8)

Defined in Data.Array.Accelerate.Lift

Methods

unlift :: Acc (Plain (Acc x0, Acc x1, Acc x2, Acc x3, Acc x4, Acc x5, Acc x6, Acc x7, Acc x8)) -> (Acc x0, Acc x1, Acc x2, Acc x3, Acc x4, Acc x5, Acc x6, Acc x7, Acc x8)

(Elt x0, Elt x1, Elt x2, Elt x3, Elt x4, Elt x5, Elt x6, Elt x7, Elt x8, Elt x9) => Unlift Exp (Exp x0, Exp x1, Exp x2, Exp x3, Exp x4, Exp x5, Exp x6, Exp x7, Exp x8, Exp x9)

Defined in Data.Array.Accelerate.Lift

Methods

unlift :: Exp (Plain (Exp x0, Exp x1, Exp x2, Exp x3, Exp x4, Exp x5, Exp x6, Exp x7, Exp x8, Exp x9)) -> (Exp x0, Exp x1, Exp x2, Exp x3, Exp x4, Exp x5, Exp x6, Exp x7, Exp x8, Exp x9)

(Arrays x0, Arrays x1, Arrays x2, Arrays x3, Arrays x4, Arrays x5, Arrays x6, Arrays x7, Arrays x8, Arrays x9) => Unlift Acc (Acc x0, Acc x1, Acc x2, Acc x3, Acc x4, Acc x5, Acc x6, Acc x7, Acc x8, Acc x9)

Defined in Data.Array.Accelerate.Lift

Methods

unlift :: Acc (Plain (Acc x0, Acc x1, Acc x2, Acc x3, Acc x4, Acc x5, Acc x6, Acc x7, Acc x8, Acc x9)) -> (Acc x0, Acc x1, Acc x2, Acc x3, Acc x4, Acc x5, Acc x6, Acc x7, Acc x8, Acc x9)

(Elt x0, Elt x1, Elt x2, Elt x3, Elt x4, Elt x5, Elt x6, Elt x7, Elt x8, Elt x9, Elt x10) => Unlift Exp (Exp x0, Exp x1, Exp x2, Exp x3, Exp x4, Exp x5, Exp x6, Exp x7, Exp x8, Exp x9, Exp x10)

Defined in Data.Array.Accelerate.Lift

Methods

unlift :: Exp (Plain (Exp x0, Exp x1, Exp x2, Exp x3, Exp x4, Exp x5, Exp x6, Exp x7, Exp x8, Exp x9, Exp x10)) -> (Exp x0, Exp x1, Exp x2, Exp x3, Exp x4, Exp x5, Exp x6, Exp x7, Exp x8, Exp x9, Exp x10)

(Arrays x0, Arrays x1, Arrays x2, Arrays x3, Arrays x4, Arrays x5, Arrays x6, Arrays x7, Arrays x8, Arrays x9, Arrays x10) => Unlift Acc (Acc x0, Acc x1, Acc x2, Acc x3, Acc x4, Acc x5, Acc x6, Acc x7, Acc x8, Acc x9, Acc x10)

Defined in Data.Array.Accelerate.Lift

Methods

unlift :: Acc (Plain (Acc x0, Acc x1, Acc x2, Acc x3, Acc x4, Acc x5, Acc x6, Acc x7, Acc x8, Acc x9, Acc x10)) -> (Acc x0, Acc x1, Acc x2, Acc x3, Acc x4, Acc x5, Acc x6, Acc x7, Acc x8, Acc x9, Acc x10)

(Elt x0, Elt x1, Elt x2, Elt x3, Elt x4, Elt x5, Elt x6, Elt x7, Elt x8, Elt x9, Elt x10, Elt x11) => Unlift Exp (Exp x0, Exp x1, Exp x2, Exp x3, Exp x4, Exp x5, Exp x6, Exp x7, Exp x8, Exp x9, Exp x10, Exp x11)

Defined in Data.Array.Accelerate.Lift

Methods

unlift :: Exp (Plain (Exp x0, Exp x1, Exp x2, Exp x3, Exp x4, Exp x5, Exp x6, Exp x7, Exp x8, Exp x9, Exp x10, Exp x11)) -> (Exp x0, Exp x1, Exp x2, Exp x3, Exp x4, Exp x5, Exp x6, Exp x7, Exp x8, Exp x9, Exp x10, Exp x11)

(Arrays x0, Arrays x1, Arrays x2, Arrays x3, Arrays x4, Arrays x5, Arrays x6, Arrays x7, Arrays x8, Arrays x9, Arrays x10, Arrays x11) => Unlift Acc (Acc x0, Acc x1, Acc x2, Acc x3, Acc x4, Acc x5, Acc x6, Acc x7, Acc x8, Acc x9, Acc x10, Acc x11)

Defined in Data.Array.Accelerate.Lift

Methods

unlift :: Acc (Plain (Acc x0, Acc x1, Acc x2, Acc x3, Acc x4, Acc x5, Acc x6, Acc x7, Acc x8, Acc x9, Acc x10, Acc x11)) -> (Acc x0, Acc x1, Acc x2, Acc x3, Acc x4, Acc x5, Acc x6, Acc x7, Acc x8, Acc x9, Acc x10, Acc x11)

(Elt x0, Elt x1, Elt x2, Elt x3, Elt x4, Elt x5, Elt x6, Elt x7, Elt x8, Elt x9, Elt x10, Elt x11, Elt x12) => Unlift Exp (Exp x0, Exp x1, Exp x2, Exp x3, Exp x4, Exp x5, Exp x6, Exp x7, Exp x8, Exp x9, Exp x10, Exp x11, Exp x12)

Defined in Data.Array.Accelerate.Lift

Methods

unlift :: Exp (Plain (Exp x0, Exp x1, Exp x2, Exp x3, Exp x4, Exp x5, Exp x6, Exp x7, Exp x8, Exp x9, Exp x10, Exp x11, Exp x12)) -> (Exp x0, Exp x1, Exp x2, Exp x3, Exp x4, Exp x5, Exp x6, Exp x7, Exp x8, Exp x9, Exp x10, Exp x11, Exp x12)

(Arrays x0, Arrays x1, Arrays x2, Arrays x3, Arrays x4, Arrays x5, Arrays x6, Arrays x7, Arrays x8, Arrays x9, Arrays x10, Arrays x11, Arrays x12) => Unlift Acc (Acc x0, Acc x1, Acc x2, Acc x3, Acc x4, Acc x5, Acc x6, Acc x7, Acc x8, Acc x9, Acc x10, Acc x11, Acc x12)

Defined in Data.Array.Accelerate.Lift

Methods

unlift :: Acc (Plain (Acc x0, Acc x1, Acc x2, Acc x3, Acc x4, Acc x5, Acc x6, Acc x7, Acc x8, Acc x9, Acc x10, Acc x11, Acc x12)) -> (Acc x0, Acc x1, Acc x2, Acc x3, Acc x4, Acc x5, Acc x6, Acc x7, Acc x8, Acc x9, Acc x10, Acc x11, Acc x12)

(Elt x0, Elt x1, Elt x2, Elt x3, Elt x4, Elt x5, Elt x6, Elt x7, Elt x8, Elt x9, Elt x10, Elt x11, Elt x12, Elt x13) => Unlift Exp (Exp x0, Exp x1, Exp x2, Exp x3, Exp x4, Exp x5, Exp x6, Exp x7, Exp x8, Exp x9, Exp x10, Exp x11, Exp x12, Exp x13)

Defined in Data.Array.Accelerate.Lift

Methods

unlift :: Exp (Plain (Exp x0, Exp x1, Exp x2, Exp x3, Exp x4, Exp x5, Exp x6, Exp x7, Exp x8, Exp x9, Exp x10, Exp x11, Exp x12, Exp x13)) -> (Exp x0, Exp x1, Exp x2, Exp x3, Exp x4, Exp x5, Exp x6, Exp x7, Exp x8, Exp x9, Exp x10, Exp x11, Exp x12, Exp x13)

(Arrays x0, Arrays x1, Arrays x2, Arrays x3, Arrays x4, Arrays x5, Arrays x6, Arrays x7, Arrays x8, Arrays x9, Arrays x10, Arrays x11, Arrays x12, Arrays x13) => Unlift Acc (Acc x0, Acc x1, Acc x2, Acc x3, Acc x4, Acc x5, Acc x6, Acc x7, Acc x8, Acc x9, Acc x10, Acc x11, Acc x12, Acc x13)

Defined in Data.Array.Accelerate.Lift

Methods

unlift :: Acc (Plain (Acc x0, Acc x1, Acc x2, Acc x3, Acc x4, Acc x5, Acc x6, Acc x7, Acc x8, Acc x9, Acc x10, Acc x11, Acc x12, Acc x13)) -> (Acc x0, Acc x1, Acc x2, Acc x3, Acc x4, Acc x5, Acc x6, Acc x7, Acc x8, Acc x9, Acc x10, Acc x11, Acc x12, Acc x13)

(Elt x0, Elt x1, Elt x2, Elt x3, Elt x4, Elt x5, Elt x6, Elt x7, Elt x8, Elt x9, Elt x10, Elt x11, Elt x12, Elt x13, Elt x14) => Unlift Exp (Exp x0, Exp x1, Exp x2, Exp x3, Exp x4, Exp x5, Exp x6, Exp x7, Exp x8, Exp x9, Exp x10, Exp x11, Exp x12, Exp x13, Exp x14)

Defined in Data.Array.Accelerate.Lift

Methods

unlift :: Exp (Plain (Exp x0, Exp x1, Exp x2, Exp x3, Exp x4, Exp x5, Exp x6, Exp x7, Exp x8, Exp x9, Exp x10, Exp x11, Exp x12, Exp x13, Exp x14)) -> (Exp x0, Exp x1, Exp x2, Exp x3, Exp x4, Exp x5, Exp x6, Exp x7, Exp x8, Exp x9, Exp x10, Exp x11, Exp x12, Exp x13, Exp x14)

(Arrays x0, Arrays x1, Arrays x2, Arrays x3, Arrays x4, Arrays x5, Arrays x6, Arrays x7, Arrays x8, Arrays x9, Arrays x10, Arrays x11, Arrays x12, Arrays x13, Arrays x14) => Unlift Acc (Acc x0, Acc x1, Acc x2, Acc x3, Acc x4, Acc x5, Acc x6, Acc x7, Acc x8, Acc x9, Acc x10, Acc x11, Acc x12, Acc x13, Acc x14)

Defined in Data.Array.Accelerate.Lift

Methods

unlift :: Acc (Plain (Acc x0, Acc x1, Acc x2, Acc x3, Acc x4, Acc x5, Acc x6, Acc x7, Acc x8, Acc x9, Acc x10, Acc x11, Acc x12, Acc x13, Acc x14)) -> (Acc x0, Acc x1, Acc x2, Acc x3, Acc x4, Acc x5, Acc x6, Acc x7, Acc x8, Acc x9, Acc x10, Acc x11, Acc x12, Acc x13, Acc x14)

(Elt x0, Elt x1, Elt x2, Elt x3, Elt x4, Elt x5, Elt x6, Elt x7, Elt x8, Elt x9, Elt x10, Elt x11, Elt x12, Elt x13, Elt x14, Elt x15) => Unlift Exp (Exp x0, Exp x1, Exp x2, Exp x3, Exp x4, Exp x5, Exp x6, Exp x7, Exp x8, Exp x9, Exp x10, Exp x11, Exp x12, Exp x13, Exp x14, Exp x15)

Defined in Data.Array.Accelerate.Lift

Methods

unlift :: Exp (Plain (Exp x0, Exp x1, Exp x2, Exp x3, Exp x4, Exp x5, Exp x6, Exp x7, Exp x8, Exp x9, Exp x10, Exp x11, Exp x12, Exp x13, Exp x14, Exp x15)) -> (Exp x0, Exp x1, Exp x2, Exp x3, Exp x4, Exp x5, Exp x6, Exp x7, Exp x8, Exp x9, Exp x10, Exp x11, Exp x12, Exp x13, Exp x14, Exp x15)

(Arrays x0, Arrays x1, Arrays x2, Arrays x3, Arrays x4, Arrays x5, Arrays x6, Arrays x7, Arrays x8, Arrays x9, Arrays x10, Arrays x11, Arrays x12, Arrays x13, Arrays x14, Arrays x15) => Unlift Acc (Acc x0, Acc x1, Acc x2, Acc x3, Acc x4, Acc x5, Acc x6, Acc x7, Acc x8, Acc x9, Acc x10, Acc x11, Acc x12, Acc x13, Acc x14, Acc x15)

Defined in Data.Array.Accelerate.Lift

Methods

unlift :: Acc (Plain (Acc x0, Acc x1, Acc x2, Acc x3, Acc x4, Acc x5, Acc x6, Acc x7, Acc x8, Acc x9, Acc x10, Acc x11, Acc x12, Acc x13, Acc x14, Acc x15)) -> (Acc x0, Acc x1, Acc x2, Acc x3, Acc x4, Acc x5, Acc x6, Acc x7, Acc x8, Acc x9, Acc x10, Acc x11, Acc x12, Acc x13, Acc x14, Acc x15)

lift1 :: (Unlift Exp a, Lift Exp b) => (a -> b) -> Exp (Plain a) -> Exp (Plain b)

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)

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)

Lift a ternary function into Exp.

ilift1 :: (Exp Int -> Exp Int) -> Exp DIM1 -> Exp DIM1

Lift a unary function to a computation over rank-1 indices.

ilift2 :: (Exp Int -> Exp Int -> Exp Int) -> Exp DIM1 -> Exp DIM1 -> Exp DIM1

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

Lift a ternary function to a computation over rank-1 indices.

Pattern synonyms

Pattern synonyms can be used as an alternative to lift and unlift for constructing and accessing data types isomorphic to simple product (tuple) types.

In contrast to lift and unlift however, pattern synonyms do not require these data types to be fully polymorphic.

For example, let's say we have regular Haskell data type representing a point in two-dimensional space:

data Point = Point_ Float Float
  deriving (Generic, Elt)

Here we derive instance an instance of the Elt class (via Generic), so that this data type can be used within scalar Accelerate expressions

In order to access the individual fields of the data constructor from within an Accelerate expression, we define the following pattern synonym:

pattern Point :: Exp Float -> Exp Float -> Exp Point
pattern Point x y = Pattern (x,y)

Notice how we named the constructor of our original datatype with a trailing underscore, so that we can use the undecorated name for the pattern synonym; these must have unique names.

In essence, the Pattern pattern is really telling GHC how to treat our Point type as a regular pair for use in Accelerate code. The pattern can then be used on both the left and right hand side of an expression:

addPoint :: Exp Point -> Exp Point -> Exp Point
addPoint (Point x1 y1) (Point x2 y2) = Point (x1+x2) (y1+y2)

Similarly, we can define pattern synonyms for values in Acc. We can also use record syntax to generate field accessors, if we desire:

data SparseVector a = SparseVector_ (Vector Int) (Vector a)
  deriving (Generic, Arrays)

pattern SparseVector :: Elt a => Acc (Vector Int) -> Acc (Vector a) -> Acc (SparseVector a)
pattern SparseVector { indices, values } = Pattern (indices, values)

For convenience, we have defined several pattern synonyms for regular tuples, T2 (for pairs), T3 (for triples), and so on up to T16. These are occasionally more convenient to use than lift and unlift together with the regular tuple syntax.

Since: 1.3.0.0

pattern Pattern :: forall b a context. IsPattern context a b => b -> context a

A pattern synonym for working with (product) data types. You can declare your own pattern synonyms based off of this.

pattern T2 :: IsPattern con (x0, x1) (con x0, con x1) => con x0 -> con x1 -> con (x0, x1)

pattern T3 :: IsPattern con (x0, x1, x2) (con x0, con x1, con x2) => con x0 -> con x1 -> con x2 -> con (x0, x1, x2)

pattern T4 :: IsPattern con (x0, x1, x2, x3) (con x0, con x1, con x2, con x3) => con x0 -> con x1 -> con x2 -> con x3 -> con (x0, x1, x2, x3)

pattern T5 :: IsPattern con (x0, x1, x2, x3, x4) (con x0, con x1, con x2, con x3, con x4) => con x0 -> con x1 -> con x2 -> con x3 -> con x4 -> con (x0, x1, x2, x3, x4)

pattern T6 :: IsPattern con (x0, x1, x2, x3, x4, x5) (con x0, con x1, con x2, con x3, con x4, con x5) => con x0 -> con x1 -> con x2 -> con x3 -> con x4 -> con x5 -> con (x0, x1, x2, x3, x4, x5)

pattern T7 :: IsPattern con (x0, x1, x2, x3, x4, x5, x6) (con x0, con x1, con x2, con x3, con x4, con x5, con x6) => con x0 -> con x1 -> con x2 -> con x3 -> con x4 -> con x5 -> con x6 -> con (x0, x1, x2, x3, x4, x5, x6)

pattern T8 :: IsPattern con (x0, x1, x2, x3, x4, x5, x6, x7) (con x0, con x1, con x2, con x3, con x4, con x5, con x6, con x7) => con x0 -> con x1 -> con x2 -> con x3 -> con x4 -> con x5 -> con x6 -> con x7 -> con (x0, x1, x2, x3, x4, x5, x6, x7)

pattern T9 :: IsPattern con (x0, x1, x2, x3, x4, x5, x6, x7, x8) (con x0, con x1, con x2, con x3, con x4, con x5, con x6, con x7, con x8) => con x0 -> con x1 -> con x2 -> con x3 -> con x4 -> con x5 -> con x6 -> con x7 -> con x8 -> con (x0, x1, x2, x3, x4, x5, x6, x7, x8)

pattern T10 :: IsPattern con (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9) (con x0, con x1, con x2, con x3, con x4, con x5, con x6, con x7, con x8, con x9) => con x0 -> con x1 -> con x2 -> con x3 -> con x4 -> con x5 -> con x6 -> con x7 -> con x8 -> con x9 -> con (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9)

pattern T11 :: IsPattern con (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10) (con x0, con x1, con x2, con x3, con x4, con x5, con x6, con x7, con x8, con x9, con x10) => con x0 -> con x1 -> con x2 -> con x3 -> con x4 -> con x5 -> con x6 -> con x7 -> con x8 -> con x9 -> con x10 -> con (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)

pattern T12 :: IsPattern con (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11) (con x0, con x1, con x2, con x3, con x4, con x5, con x6, con x7, con x8, con x9, con x10, con x11) => con x0 -> con x1 -> con x2 -> con x3 -> con x4 -> con x5 -> con x6 -> con x7 -> con x8 -> con x9 -> con x10 -> con x11 -> con (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)

pattern T13 :: IsPattern con (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12) (con x0, con x1, con x2, con x3, con x4, con x5, con x6, con x7, con x8, con x9, con x10, con x11, con x12) => con x0 -> con x1 -> con x2 -> con x3 -> con x4 -> con x5 -> con x6 -> con x7 -> con x8 -> con x9 -> con x10 -> con x11 -> con x12 -> con (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12)

pattern T14 :: IsPattern con (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13) (con x0, con x1, con x2, con x3, con x4, con x5, con x6, con x7, con x8, con x9, con x10, con x11, con x12, con x13) => con x0 -> con x1 -> con x2 -> con x3 -> con x4 -> con x5 -> con x6 -> con x7 -> con x8 -> con x9 -> con x10 -> con x11 -> con x12 -> con x13 -> con (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13)

pattern T15 :: IsPattern con (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14) (con x0, con x1, con x2, con x3, con x4, con x5, con x6, con x7, con x8, con x9, con x10, con x11, con x12, con x13, con x14) => con x0 -> con x1 -> con x2 -> con x3 -> con x4 -> con x5 -> con x6 -> con x7 -> con x8 -> con x9 -> con x10 -> con x11 -> con x12 -> con x13 -> con x14 -> con (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14)

pattern T16 :: IsPattern con (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15) (con x0, con x1, con x2, con x3, con x4, con x5, con x6, con x7, con x8, con x9, con x10, con x11, con x12, con x13, con x14, con x15) => con x0 -> con x1 -> con x2 -> con x3 -> con x4 -> con x5 -> con x6 -> con x7 -> con x8 -> con x9 -> con x10 -> con x11 -> con x12 -> con x13 -> con x14 -> con x15 -> con (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15)

pattern Z_ :: Exp DIM0

Pattern synonyms for indices, which may be more convenient to use than lift and unlift.

pattern Ix :: (Elt a, Elt b) => Exp a -> Exp b -> Exp (a :. b) infixl 3

pattern (::.) :: (Elt a, Elt b) => Exp a -> Exp b -> Exp (a :. b) infixl 3

pattern I0 :: () => Exp Z

pattern I1 :: Elt x0 => Exp x0 -> Exp ((:.) Z x0)

pattern I2 :: (Elt x0, Elt x1) => Exp x0 -> Exp x1 -> Exp ((:.) ((:.) Z x0) x1)

pattern I3 :: (Elt x0, Elt x1, Elt x2) => Exp x0 -> Exp x1 -> Exp x2 -> Exp ((:.) ((:.) ((:.) Z x0) x1) x2)

pattern I4 :: (Elt x0, Elt x1, Elt x2, Elt x3) => Exp x0 -> Exp x1 -> Exp x2 -> Exp x3 -> Exp ((:.) ((:.) ((:.) ((:.) Z x0) x1) x2) x3)

pattern I5 :: (Elt x0, Elt x1, Elt x2, Elt x3, Elt x4) => Exp x0 -> Exp x1 -> Exp x2 -> Exp x3 -> Exp x4 -> Exp ((:.) ((:.) ((:.) ((:.) ((:.) Z x0) x1) x2) x3) x4)

pattern I6 :: (Elt x0, Elt x1, Elt x2, Elt x3, Elt x4, Elt x5) => Exp x0 -> Exp x1 -> Exp x2 -> Exp x3 -> Exp x4 -> Exp x5 -> Exp ((:.) ((:.) ((:.) ((:.) ((:.) ((:.) Z x0) x1) x2) x3) x4) x5)

pattern I7 :: (Elt x0, Elt x1, Elt x2, Elt x3, Elt x4, Elt x5, Elt x6) => Exp x0 -> Exp x1 -> Exp x2 -> Exp x3 -> Exp x4 -> Exp x5 -> Exp x6 -> Exp ((:.) ((:.) ((:.) ((:.) ((:.) ((:.) ((:.) Z x0) x1) x2) x3) x4) x5) x6)

pattern I8 :: (Elt x0, Elt x1, Elt x2, Elt x3, Elt x4, Elt x5, Elt x6, Elt x7) => Exp x0 -> Exp x1 -> Exp x2 -> Exp x3 -> Exp x4 -> Exp x5 -> Exp x6 -> Exp x7 -> Exp ((:.) ((:.) ((:.) ((:.) ((:.) ((:.) ((:.) ((:.) Z x0) x1) x2) x3) x4) x5) x6) x7)

pattern I9 :: (Elt x0, Elt x1, Elt x2, Elt x3, Elt x4, Elt x5, Elt x6, Elt x7, Elt x8) => Exp x0 -> Exp x1 -> Exp x2 -> Exp x3 -> Exp x4 -> Exp x5 -> Exp x6 -> Exp x7 -> Exp x8 -> Exp ((:.) ((:.) ((:.) ((:.) ((:.) ((:.) ((:.) ((:.) ((:.) Z x0) x1) x2) x3) x4) x5) x6) x7) x8)

pattern Vec2 :: Prim a => a -> a -> Vec2 a

pattern V2 :: IsVector con vec (con x0, con x1) => con x0 -> con x1 -> con vec

pattern Vec3 :: Prim a => a -> a -> a -> Vec3 a

pattern V3 :: IsVector con vec (con x0, con x1, con x2) => con x0 -> con x1 -> con x2 -> con vec

pattern Vec4 :: Prim a => a -> a -> a -> a -> Vec4 a

pattern V4 :: IsVector con vec (con x0, con x1, con x2, con x3) => con x0 -> con x1 -> con x2 -> con x3 -> con vec

pattern Vec8 :: Prim a => a -> a -> a -> a -> a -> a -> a -> a -> Vec8 a

pattern V8 :: IsVector con vec (con x0, con x1, con x2, con x3, con x4, con x5, con x6, con x7) => con x0 -> con x1 -> con x2 -> con x3 -> con x4 -> con x5 -> con x6 -> con x7 -> con vec

pattern Vec16 :: Prim a => a -> a -> a -> a -> a -> a -> a -> a -> a -> a -> a -> a -> a -> a -> a -> a -> Vec16 a

pattern V16 :: IsVector con vec (con x0, con x1, con x2, con x3, con x4, con x5, con x6, con x7, con x8, con x9, con x10, con x11, con x12, con x13, con x14, con x15) => con x0 -> con x1 -> con x2 -> con x3 -> con x4 -> con x5 -> con x6 -> con x7 -> con x8 -> con x9 -> con x10 -> con x11 -> con x12 -> con x13 -> con x14 -> con x15 -> con vec

Specialised pattern synonyms for tuples, which may be more convenient to use than lift and unlift. For example, to construct a pair:

let a = 4        :: Exp Int
let b = 2        :: Exp Float
let c = T2 a b   -- :: Exp (Int, Float); equivalent to 'lift (a,b)'

Similarly they can be used to destruct values:

let T2 x y = c   -- x :: Exp Int, y :: Exp Float; equivalent to 'let (x,y) = unlift c'

These pattern synonyms can be used for both Exp and Acc terms.

Similarly, we have patterns for constructing and destructing indices of a given dimensionality:

let ix = Ix 2 3    -- :: Exp DIM2
let I2 y x = ix    -- y :: Exp Int, x :: Exp Int

mkPattern :: Name -> DecsQ

Generate pattern synonyms for the given simple (Haskell'98) sum or product data type.

Constructor and record selectors are renamed to add a trailing underscore if it does not exist, or to remove it if it does. For infix constructors, the name is prepended with a colon :. For example:

data Point = Point { xcoord_ :: Float, ycoord_ :: Float }
  deriving (Generic, Elt)

Will create the pattern synonym:

Point_ :: Exp Float -> Exp Float -> Exp Point

together with the selector functions

xcoord :: Exp Point -> Exp Float
ycoord :: Exp Point -> Exp Float

mkPatterns :: [Name] -> DecsQ

As mkPattern, but for a list of types

Scalar operations

Introduction

constant :: forall e. (HasCallStack, Elt e) => e -> Exp e

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 :: (Elt a, Elt b) => Exp (a, b) -> Exp a

Extract the first component of a scalar pair.

afst :: (Arrays a, Arrays b) => Acc (a, b) -> Acc a

Extract the first component of an array pair.

snd :: (Elt a, Elt b) => Exp (a, b) -> Exp b

Extract the second component of a scalar pair.

asnd :: (Arrays a, Arrays b) => Acc (a, b) -> Acc b

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

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

Converts a curried function to a function on pairs.

Flow control

(?) :: Elt t => Exp Bool -> (Exp t, Exp t) -> Exp t infix 0

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.

match :: Matching f => f -> f

The match operation is the core operation which enables embedded pattern matching. It is applied to an n-ary scalar function, and generates the necessary case-statements in the embedded code for each argument. For example, given the function:

example1 :: Exp (Maybe Bool) -> Exp Int
example1 Nothing_ = 0
example1 (Just_ False_) = 1
example1 (Just_ True_) = 2

In order to use this function it must be applied to the match operator:

match example1

Using the infix-flip operator (&), we can also write case statements inline. For example, instead of this:

example2 x = case f x of
  Nothing_ -> ...      -- error: embedded pattern synonym...
  Just_ y  -> ...      -- ...used outside of 'match' context

This can be written instead as:

example3 x = f x & match \case
  Nothing_ -> ...
  Just_ y  -> ...

And utilising the LambdaCase and BlockArguments syntactic extensions.

The Template Haskell splice mkPattern (or mkPatterns) can be used to generate the pattern synonyms for a given Haskell'98 sum or product data type. For example:

data Option a = None | Some a
  deriving (Generic, Elt)

mkPattern ''Option

Which can then be used such as:

isNone :: Elt a => Exp (Option a) -> Exp Bool
isNone = match \case
  None_   -> True_
  Some_{} -> False_

Since: 1.3.0.0

cond

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

Arguments

:: forall e. 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 :: Elt a => Exp Int -> (Exp a -> Exp a) -> Exp a -> Exp a

Repeatedly apply a function a fixed number of times

Scalar reduction

sfoldl :: (Shape sh, Elt a, Elt b) => (Exp a -> Exp b -> Exp a) -> Exp a -> Exp sh -> Acc (Array (sh :. Int) b) -> Exp a

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

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

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

Logical negation

Numeric operations

subtract :: Num a => Exp a -> Exp a -> Exp a

subtract is the same as flip (-).

even :: Integral a => Exp a -> Exp Bool

Determine if a number is even

odd :: Integral a => Exp a -> Exp Bool

Determine if a number is odd

gcd :: Integral a => Exp a -> Exp a -> Exp a

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

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

Raise a number to a non-negative integral power

(^^) :: (Fractional a, Integral b) => Exp a -> Exp b -> Exp a infixr 8

Raise a number to an integral power

Shape manipulation

index0 :: Exp Z

The one index for a rank-0 array.

index1 :: Elt i => Exp i -> Exp (Z :. i)

Turn an Int expression into a rank-1 indexing expression.

unindex1 :: Elt i => Exp (Z :. i) -> Exp i

Turn a rank-1 indexing expression into an Int expression.

index2 :: Elt i => Exp i -> Exp i -> Exp ((Z :. i) :. i)

Creates a rank-2 index from two Exp Int`s

unindex2 :: Elt i => Exp ((Z :. i) :. i) -> Exp (i, i)

Destructs a rank-2 index to an Exp tuple of two Int`s.

index3 :: Elt i => Exp i -> Exp i -> Exp i -> Exp (((Z :. i) :. i) :. i)

Create a rank-3 index from three Exp Int`s

unindex3 :: Elt i => Exp (((Z :. i) :. i) :. i) -> Exp (i, i, i)

Destruct a rank-3 index into an Exp tuple of Int`s

indexHead :: (Elt sh, Elt a) => Exp (sh :. a) -> Exp a

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 :: (Elt sh, Elt a) => Exp (sh :. a) -> Exp sh

Get all but the innermost element of a shape

toIndex

Arguments

:: forall sh. 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 :: forall sh. Shape sh => Exp sh -> Exp Int -> Exp sh

Inverse of toIndex

intersect :: forall sh. Shape sh => Exp sh -> Exp sh -> Exp sh

Intersection of two shapes

Conversions

ord :: Exp Char -> Exp Int

Convert a character to an Int.

chr :: Exp Int -> Exp Char

Convert an Int into a character.

boolToInt :: Exp Bool -> Exp Int

Convert a Boolean value to an Int, where False turns into '0' and True into '1'.

bitcast :: (Elt a, Elt b, IsScalar (EltR a), IsScalar (EltR b), BitSizeEq (EltR a) (EltR b)) => Exp a -> Exp b

Reinterpret a value as another type. The two representations must have the same bit size.

Foreign Function Interface (FFI)

foreignAcc :: forall as bs asm. (Arrays as, Arrays bs, Foreign asm) => asm (ArraysR as -> ArraysR bs) -> (Acc as -> Acc bs) -> Acc as -> Acc bs

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 :: forall x y asm. (Elt x, Elt y, Foreign asm) => asm (EltR x -> EltR y) -> (Exp x -> Exp y) -> Exp x -> Exp y

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 :: forall sh e. Shape sh => Array sh e -> Int

Rank of an array (as a plain Haskell value)

arrayShape :: Shape sh => Array sh e -> sh

Shape of an array (as a plain Haskell value)

arraySize :: Shape sh => Array sh e -> Int

Total number of elements in an array (as a plain Haskell value)

arrayReshape :: (Shape sh, Shape sh') => sh -> Array sh' e -> Array sh e

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

indexArray :: (Shape sh, Elt e) => Array sh e -> sh -> e

Array indexing in plain Haskell code.

linearIndexArray :: Elt e => Array sh e -> Int -> e

Linear 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

Create an array from its representation function, applied at each index of the array

fromFunctionM :: forall sh e. (Shape sh, Elt e) => sh -> (sh -> IO e) -> IO (Array sh e)

Create an array using a monadic function applied at each index

Since: 1.2.0.0

Lists

fromList :: forall sh e. (Shape sh, Elt e) => sh -> [e] -> Array sh e

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) :: Matrix 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. (Shape sh, Elt e) => Array sh e -> [e]

Convert an accelerated Array to a list in row-major order

Useful re-exports

(.) :: (b -> c) -> (a -> b) -> a -> c infixr 9

Function composition.

($) :: forall (r :: RuntimeRep) a (b :: TYPE r). (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.

Note that ($) is levity-polymorphic in its result type, so that foo $ True where foo :: Bool -> Int# is well-typed.

(&) :: a -> (a -> b) -> b infixl 1

& is a reverse application operator. This provides notational convenience. Its precedence is one higher than that of the forward application operator $, which allows & to be nested in $.

>>> 5 & (+1) & show
"6"

Since: base-4.8.0.0

error :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => [Char] -> a

error stops execution and displays an error message.

undefined :: forall (r :: RuntimeRep) (a :: TYPE r). 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.

>>> const 42 "hello"
42

>>> map (const 42) [0..3]
[42,42,42,42]

otherwise :: Bool

otherwise is defined as the value True. It helps to make guards more readable. eg.

 f x | x < 0     = ...
     | otherwise = ...

class Show a

Conversion of values to readable Strings.

Derived instances of Show have the following properties, which are compatible with derived instances of Read:

• The result of show is a syntactically correct Haskell expression containing only constants, given the fixity declarations in force at the point where the type is declared. It contains only the constructor names defined in the data type, parentheses, and spaces. When labelled constructor fields are used, braces, commas, field names, and equal signs are also used.
• If the constructor is defined to be an infix operator, then showsPrec will produce infix applications of the constructor.
• the representation will be enclosed in parentheses if the precedence of the top-level constructor in x is less than d (associativity is ignored). Thus, if d is 0 then the result is never surrounded in parentheses; if d is 11 it is always surrounded in parentheses, unless it is an atomic expression.
• If the constructor is defined using record syntax, then show will produce the record-syntax form, with the fields given in the same order as the original declaration.

For example, given the declarations

infixr 5 :^:
data Tree a =  Leaf a  |  Tree a :^: Tree a

the derived instance of Show is equivalent to

instance (Show a) => Show (Tree a) where

       showsPrec d (Leaf m) = showParen (d > app_prec) $
            showString "Leaf " . showsPrec (app_prec+1) m
         where app_prec = 10

       showsPrec d (u :^: v) = showParen (d > up_prec) $
            showsPrec (up_prec+1) u .
            showString " :^: "      .
            showsPrec (up_prec+1) v
         where up_prec = 5

Note that right-associativity of :^: is ignored. For example,

• show (Leaf 1 :^: Leaf 2 :^: Leaf 3) produces the string "Leaf 1 :^: (Leaf 2 :^: Leaf 3)".

Minimal complete definition

showsPrec | show

Instances

Show Bool

Since: base-2.1

Defined in GHC.Show

Methods

showsPrec :: Int -> Bool -> ShowS

show :: Bool -> String

showList :: [Bool] -> ShowS

Show Char

Since: base-2.1

Defined in GHC.Show

Methods

showsPrec :: Int -> Char -> ShowS

show :: Char -> String

showList :: [Char] -> ShowS

Show Int

Since: base-2.1

Defined in GHC.Show

Methods

showsPrec :: Int -> Int -> ShowS

show :: Int -> String

showList :: [Int] -> ShowS

Show Int8

Since: base-2.1

Defined in GHC.Int

Methods

showsPrec :: Int -> Int8 -> ShowS

show :: Int8 -> String

showList :: [Int8] -> ShowS

Show Int16

Since: base-2.1

Defined in GHC.Int

Methods

showsPrec :: Int -> Int16 -> ShowS

show :: Int16 -> String

showList :: [Int16] -> ShowS

Show Int32

Since: base-2.1

Defined in GHC.Int

Methods

showsPrec :: Int -> Int32 -> ShowS

show :: Int32 -> String

showList :: [Int32] -> ShowS

Show Int64

Since: base-2.1

Defined in GHC.Int

Methods

showsPrec :: Int -> Int64 -> ShowS

show :: Int64 -> String

showList :: [Int64] -> ShowS

Show Integer

Since: base-2.1

Defined in GHC.Show

Methods

showsPrec :: Int -> Integer -> ShowS

show :: Integer -> String

showList :: [Integer] -> ShowS

Show Natural

Since: base-4.8.0.0

Defined in GHC.Show

Methods

showsPrec :: Int -> Natural -> ShowS

show :: Natural -> String

showList :: [Natural] -> ShowS

Show Ordering

Since: base-2.1

Defined in GHC.Show

Methods

showsPrec :: Int -> Ordering -> ShowS

show :: Ordering -> String

showList :: [Ordering] -> ShowS

Show Word

Since: base-2.1

Defined in GHC.Show

Methods

showsPrec :: Int -> Word -> ShowS

show :: Word -> String

showList :: [Word] -> ShowS

Show Word8

Since: base-2.1

Defined in GHC.Word

Methods

showsPrec :: Int -> Word8 -> ShowS

show :: Word8 -> String

showList :: [Word8] -> ShowS

Show Word16

Since: base-2.1

Defined in GHC.Word

Methods

showsPrec :: Int -> Word16 -> ShowS

show :: Word16 -> String

showList :: [Word16] -> ShowS

Show Word32

Since: base-2.1

Defined in GHC.Word

Methods

showsPrec :: Int -> Word32 -> ShowS

show :: Word32 -> String

showList :: [Word32] -> ShowS

Show Word64

Since: base-2.1

Defined in GHC.Word

Methods

showsPrec :: Int -> Word64 -> ShowS

show :: Word64 -> String

showList :: [Word64] -> ShowS

Show RuntimeRep

Since: base-4.11.0.0

Defined in GHC.Show

Methods

showsPrec :: Int -> RuntimeRep -> ShowS

show :: RuntimeRep -> String

showList :: [RuntimeRep] -> ShowS

Show VecCount

Since: base-4.11.0.0

Defined in GHC.Show

Methods

showsPrec :: Int -> VecCount -> ShowS

show :: VecCount -> String

showList :: [VecCount] -> ShowS

Show VecElem

Since: base-4.11.0.0

Defined in GHC.Show

Methods

showsPrec :: Int -> VecElem -> ShowS

show :: VecElem -> String

showList :: [VecElem] -> ShowS

Show CallStack

Since: base-4.9.0.0

Defined in GHC.Show

Methods

showsPrec :: Int -> CallStack -> ShowS

show :: CallStack -> String

showList :: [CallStack] -> ShowS

Show SomeTypeRep

Since: base-4.10.0.0

Defined in Data.Typeable.Internal

Methods

showsPrec :: Int -> SomeTypeRep -> ShowS

show :: SomeTypeRep -> String

showList :: [SomeTypeRep] -> ShowS

Show Exp

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> Exp -> ShowS

show :: Exp -> String

showList :: [Exp] -> ShowS

Show Match

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> Match -> ShowS

show :: Match -> String

showList :: [Match] -> ShowS

Show Clause

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> Clause -> ShowS

show :: Clause -> String

showList :: [Clause] -> ShowS

Show Pat

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> Pat -> ShowS

show :: Pat -> String

showList :: [Pat] -> ShowS

Show Type

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> Type -> ShowS

show :: Type -> String

showList :: [Type] -> ShowS

Show Dec

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> Dec -> ShowS

show :: Dec -> String

showList :: [Dec] -> ShowS

Show Name

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> Name -> ShowS

show :: Name -> String

showList :: [Name] -> ShowS

Show FunDep

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> FunDep -> ShowS

show :: FunDep -> String

showList :: [FunDep] -> ShowS

Show InjectivityAnn

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> InjectivityAnn -> ShowS

show :: InjectivityAnn -> String

showList :: [InjectivityAnn] -> ShowS

Show Overlap

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> Overlap -> ShowS

show :: Overlap -> String

showList :: [Overlap] -> ShowS

Show ()

Since: base-2.1

Defined in GHC.Show

Methods

showsPrec :: Int -> () -> ShowS

show :: () -> String

showList :: [()] -> ShowS

Show TyCon

Since: base-2.1

Defined in GHC.Show

Methods

showsPrec :: Int -> TyCon -> ShowS

show :: TyCon -> String

showList :: [TyCon] -> ShowS

Show Module

Since: base-4.9.0.0

Defined in GHC.Show

Methods

showsPrec :: Int -> Module -> ShowS

show :: Module -> String

showList :: [Module] -> ShowS

Show TrName

Since: base-4.9.0.0

Defined in GHC.Show

Methods

showsPrec :: Int -> TrName -> ShowS

show :: TrName -> String

showList :: [TrName] -> ShowS

Show KindRep

Defined in GHC.Show

Methods

showsPrec :: Int -> KindRep -> ShowS

show :: KindRep -> String

showList :: [KindRep] -> ShowS

Show TypeLitSort

Since: base-4.11.0.0

Defined in GHC.Show

Methods

showsPrec :: Int -> TypeLitSort -> ShowS

show :: TypeLitSort -> String

showList :: [TypeLitSort] -> ShowS

Show Handle

Since: base-4.1.0.0

Defined in GHC.IO.Handle.Types

Methods

showsPrec :: Int -> Handle -> ShowS

show :: Handle -> String

showList :: [Handle] -> ShowS

Show ThreadId

Since: base-4.2.0.0

Defined in GHC.Conc.Sync

Methods

showsPrec :: Int -> ThreadId -> ShowS

show :: ThreadId -> String

showList :: [ThreadId] -> ShowS

Show Void

Since: base-4.8.0.0

Defined in Data.Void

Methods

showsPrec :: Int -> Void -> ShowS

show :: Void -> String

showList :: [Void] -> ShowS

Show Version

Since: base-2.1

Defined in Data.Version

Methods

showsPrec :: Int -> Version -> ShowS

show :: Version -> String

showList :: [Version] -> ShowS

Show HandlePosn

Since: base-4.1.0.0

Defined in GHC.IO.Handle

Methods

showsPrec :: Int -> HandlePosn -> ShowS

show :: HandlePosn -> String

showList :: [HandlePosn] -> ShowS

Show PatternMatchFail

Since: base-4.0

Defined in Control.Exception.Base

Methods

showsPrec :: Int -> PatternMatchFail -> ShowS

show :: PatternMatchFail -> String

showList :: [PatternMatchFail] -> ShowS

Show RecSelError

Since: base-4.0

Defined in Control.Exception.Base

Methods

showsPrec :: Int -> RecSelError -> ShowS

show :: RecSelError -> String

showList :: [RecSelError] -> ShowS

Show RecConError

Since: base-4.0

Defined in Control.Exception.Base

Methods

showsPrec :: Int -> RecConError -> ShowS

show :: RecConError -> String

showList :: [RecConError] -> ShowS

Show RecUpdError

Since: base-4.0

Defined in Control.Exception.Base

Methods

showsPrec :: Int -> RecUpdError -> ShowS

show :: RecUpdError -> String

showList :: [RecUpdError] -> ShowS

Show NoMethodError

Since: base-4.0

Defined in Control.Exception.Base

Methods

showsPrec :: Int -> NoMethodError -> ShowS

show :: NoMethodError -> String

showList :: [NoMethodError] -> ShowS

Show TypeError

Since: base-4.9.0.0

Defined in Control.Exception.Base

Methods

showsPrec :: Int -> TypeError -> ShowS

show :: TypeError -> String

showList :: [TypeError] -> ShowS

Show NonTermination

Since: base-4.0

Defined in Control.Exception.Base

Methods

showsPrec :: Int -> NonTermination -> ShowS

show :: NonTermination -> String

showList :: [NonTermination] -> ShowS

Show NestedAtomically

Since: base-4.0

Defined in Control.Exception.Base

Methods

showsPrec :: Int -> NestedAtomically -> ShowS

show :: NestedAtomically -> String

showList :: [NestedAtomically] -> ShowS

Show BlockReason

Since: base-4.3.0.0

Defined in GHC.Conc.Sync

Methods

showsPrec :: Int -> BlockReason -> ShowS

show :: BlockReason -> String

showList :: [BlockReason] -> ShowS

Show ThreadStatus

Since: base-4.3.0.0

Defined in GHC.Conc.Sync

Methods

showsPrec :: Int -> ThreadStatus -> ShowS

show :: ThreadStatus -> String

showList :: [ThreadStatus] -> ShowS

Show CDev

Defined in System.Posix.Types

Methods

showsPrec :: Int -> CDev -> ShowS

show :: CDev -> String

showList :: [CDev] -> ShowS

Show CIno

Defined in System.Posix.Types

Methods

showsPrec :: Int -> CIno -> ShowS

show :: CIno -> String

showList :: [CIno] -> ShowS

Show CMode

Defined in System.Posix.Types

Methods

showsPrec :: Int -> CMode -> ShowS

show :: CMode -> String

showList :: [CMode] -> ShowS

Show COff

Defined in System.Posix.Types

Methods

showsPrec :: Int -> COff -> ShowS

show :: COff -> String

showList :: [COff] -> ShowS

Show CPid

Defined in System.Posix.Types

Methods

showsPrec :: Int -> CPid -> ShowS

show :: CPid -> String

showList :: [CPid] -> ShowS

Show CSsize

Defined in System.Posix.Types

Methods

showsPrec :: Int -> CSsize -> ShowS

show :: CSsize -> String

showList :: [CSsize] -> ShowS

Show CGid

Defined in System.Posix.Types

Methods

showsPrec :: Int -> CGid -> ShowS

show :: CGid -> String

showList :: [CGid] -> ShowS

Show CNlink

Defined in System.Posix.Types

Methods

showsPrec :: Int -> CNlink -> ShowS

show :: CNlink -> String

showList :: [CNlink] -> ShowS

Show CUid

Defined in System.Posix.Types

Methods

showsPrec :: Int -> CUid -> ShowS

show :: CUid -> String

showList :: [CUid] -> ShowS

Show CCc

Defined in System.Posix.Types

Methods

showsPrec :: Int -> CCc -> ShowS

show :: CCc -> String

showList :: [CCc] -> ShowS

Show CSpeed

Defined in System.Posix.Types

Methods

showsPrec :: Int -> CSpeed -> ShowS

show :: CSpeed -> String

showList :: [CSpeed] -> ShowS

Show CTcflag

Defined in System.Posix.Types

Methods

showsPrec :: Int -> CTcflag -> ShowS

show :: CTcflag -> String

showList :: [CTcflag] -> ShowS

Show CRLim

Defined in System.Posix.Types

Methods

showsPrec :: Int -> CRLim -> ShowS

show :: CRLim -> String

showList :: [CRLim] -> ShowS

Show CBlkSize

Defined in System.Posix.Types

Methods

showsPrec :: Int -> CBlkSize -> ShowS

show :: CBlkSize -> String

showList :: [CBlkSize] -> ShowS

Show CBlkCnt

Defined in System.Posix.Types

Methods

showsPrec :: Int -> CBlkCnt -> ShowS

show :: CBlkCnt -> String

showList :: [CBlkCnt] -> ShowS

Show CClockId

Defined in System.Posix.Types

Methods

showsPrec :: Int -> CClockId -> ShowS

show :: CClockId -> String

showList :: [CClockId] -> ShowS

Show CFsBlkCnt

Defined in System.Posix.Types

Methods

showsPrec :: Int -> CFsBlkCnt -> ShowS

show :: CFsBlkCnt -> String

showList :: [CFsBlkCnt] -> ShowS

Show CFsFilCnt

Defined in System.Posix.Types

Methods

showsPrec :: Int -> CFsFilCnt -> ShowS

show :: CFsFilCnt -> String

showList :: [CFsFilCnt] -> ShowS

Show CId

Defined in System.Posix.Types

Methods

showsPrec :: Int -> CId -> ShowS

show :: CId -> String

showList :: [CId] -> ShowS

Show CKey

Defined in System.Posix.Types

Methods

showsPrec :: Int -> CKey -> ShowS

show :: CKey -> String

showList :: [CKey] -> ShowS

Show CSocklen

Defined in System.Posix.Types

Methods

showsPrec :: Int -> CSocklen -> ShowS

show :: CSocklen -> String

showList :: [CSocklen] -> ShowS

Show CNfds

Defined in System.Posix.Types

Methods

showsPrec :: Int -> CNfds -> ShowS

show :: CNfds -> String

showList :: [CNfds] -> ShowS

Show Fd

Defined in System.Posix.Types

Methods

showsPrec :: Int -> Fd -> ShowS

show :: Fd -> String

showList :: [Fd] -> ShowS

Show BlockedIndefinitelyOnMVar

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

showsPrec :: Int -> BlockedIndefinitelyOnMVar -> ShowS

show :: BlockedIndefinitelyOnMVar -> String

showList :: [BlockedIndefinitelyOnMVar] -> ShowS

Show BlockedIndefinitelyOnSTM

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

showsPrec :: Int -> BlockedIndefinitelyOnSTM -> ShowS

show :: BlockedIndefinitelyOnSTM -> String

showList :: [BlockedIndefinitelyOnSTM] -> ShowS

Show Deadlock

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

showsPrec :: Int -> Deadlock -> ShowS

show :: Deadlock -> String

showList :: [Deadlock] -> ShowS

Show AllocationLimitExceeded

Since: base-4.7.1.0

Defined in GHC.IO.Exception

Methods

showsPrec :: Int -> AllocationLimitExceeded -> ShowS

show :: AllocationLimitExceeded -> String

showList :: [AllocationLimitExceeded] -> ShowS

Show CompactionFailed

Since: base-4.10.0.0

Defined in GHC.IO.Exception

Methods

showsPrec :: Int -> CompactionFailed -> ShowS

show :: CompactionFailed -> String

showList :: [CompactionFailed] -> ShowS

Show AssertionFailed

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

showsPrec :: Int -> AssertionFailed -> ShowS

show :: AssertionFailed -> String

showList :: [AssertionFailed] -> ShowS

Show SomeAsyncException

Since: base-4.7.0.0

Defined in GHC.IO.Exception

Methods

showsPrec :: Int -> SomeAsyncException -> ShowS

show :: SomeAsyncException -> String

showList :: [SomeAsyncException] -> ShowS

Show AsyncException

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

showsPrec :: Int -> AsyncException -> ShowS

show :: AsyncException -> String

showList :: [AsyncException] -> ShowS

Show ArrayException

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

showsPrec :: Int -> ArrayException -> ShowS

show :: ArrayException -> String

showList :: [ArrayException] -> ShowS

Show FixIOException

Since: base-4.11.0.0

Defined in GHC.IO.Exception

Methods

showsPrec :: Int -> FixIOException -> ShowS

show :: FixIOException -> String

showList :: [FixIOException] -> ShowS

Show ExitCode

Defined in GHC.IO.Exception

Methods

showsPrec :: Int -> ExitCode -> ShowS

show :: ExitCode -> String

showList :: [ExitCode] -> ShowS

Show IOErrorType

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

showsPrec :: Int -> IOErrorType -> ShowS

show :: IOErrorType -> String

showList :: [IOErrorType] -> ShowS

Show HandleType

Since: base-4.1.0.0

Defined in GHC.IO.Handle.Types

Methods

showsPrec :: Int -> HandleType -> ShowS

show :: HandleType -> String

showList :: [HandleType] -> ShowS

Show BufferMode

Since: base-4.2.0.0

Defined in GHC.IO.Handle.Types

Methods

showsPrec :: Int -> BufferMode -> ShowS

show :: BufferMode -> String

showList :: [BufferMode] -> ShowS

Show Newline

Since: base-4.3.0.0

Defined in GHC.IO.Handle.Types

Methods

showsPrec :: Int -> Newline -> ShowS

show :: Newline -> String

showList :: [Newline] -> ShowS

Show NewlineMode

Since: base-4.3.0.0

Defined in GHC.IO.Handle.Types

Methods

showsPrec :: Int -> NewlineMode -> ShowS

show :: NewlineMode -> String

showList :: [NewlineMode] -> ShowS

Show SeekMode

Since: base-4.2.0.0

Defined in GHC.IO.Device

Methods

showsPrec :: Int -> SeekMode -> ShowS

show :: SeekMode -> String

showList :: [SeekMode] -> ShowS

Show TextEncoding

Since: base-4.3.0.0

Defined in GHC.IO.Encoding.Types

Methods

showsPrec :: Int -> TextEncoding -> ShowS

show :: TextEncoding -> String

showList :: [TextEncoding] -> ShowS

Show CodingProgress

Since: base-4.4.0.0

Defined in GHC.IO.Encoding.Types

Methods

showsPrec :: Int -> CodingProgress -> ShowS

show :: CodingProgress -> String

showList :: [CodingProgress] -> ShowS

Show MaskingState

Since: base-4.3.0.0

Defined in GHC.IO

Methods

showsPrec :: Int -> MaskingState -> ShowS

show :: MaskingState -> String

showList :: [MaskingState] -> ShowS

Show IOException

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

showsPrec :: Int -> IOException -> ShowS

show :: IOException -> String

showList :: [IOException] -> ShowS

Show ErrorCall

Since: base-4.0.0.0

Defined in GHC.Exception

Methods

showsPrec :: Int -> ErrorCall -> ShowS

show :: ErrorCall -> String

showList :: [ErrorCall] -> ShowS

Show ArithException

Since: base-4.0.0.0

Defined in GHC.Exception.Type

Methods

showsPrec :: Int -> ArithException -> ShowS

show :: ArithException -> String

showList :: [ArithException] -> ShowS

Show All

Since: base-2.1

Defined in Data.Semigroup.Internal

Methods

showsPrec :: Int -> All -> ShowS

show :: All -> String

showList :: [All] -> ShowS

Show Any

Since: base-2.1

Defined in Data.Semigroup.Internal

Methods

showsPrec :: Int -> Any -> ShowS

show :: Any -> String

showList :: [Any] -> ShowS

Show Fixity

Since: base-4.6.0.0

Defined in GHC.Generics

Methods

showsPrec :: Int -> Fixity -> ShowS

show :: Fixity -> String

showList :: [Fixity] -> ShowS

Show Associativity

Since: base-4.6.0.0

Defined in GHC.Generics

Methods

showsPrec :: Int -> Associativity -> ShowS

show :: Associativity -> String

showList :: [Associativity] -> ShowS

Show SourceUnpackedness

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

showsPrec :: Int -> SourceUnpackedness -> ShowS

show :: SourceUnpackedness -> String

showList :: [SourceUnpackedness] -> ShowS

Show SourceStrictness

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

showsPrec :: Int -> SourceStrictness -> ShowS

show :: SourceStrictness -> String

showList :: [SourceStrictness] -> ShowS

Show DecidedStrictness

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

showsPrec :: Int -> DecidedStrictness -> ShowS

show :: DecidedStrictness -> String

showList :: [DecidedStrictness] -> ShowS

Show SomeSymbol

Since: base-4.7.0.0

Defined in GHC.TypeLits

Methods

showsPrec :: Int -> SomeSymbol -> ShowS

show :: SomeSymbol -> String

showList :: [SomeSymbol] -> ShowS

Show SomeNat

Since: base-4.7.0.0

Defined in GHC.TypeNats

Methods

showsPrec :: Int -> SomeNat -> ShowS

show :: SomeNat -> String

showList :: [SomeNat] -> ShowS

Show CChar

Defined in Foreign.C.Types

Methods

showsPrec :: Int -> CChar -> ShowS

show :: CChar -> String

showList :: [CChar] -> ShowS

Show CSChar

Defined in Foreign.C.Types

Methods

showsPrec :: Int -> CSChar -> ShowS

show :: CSChar -> String

showList :: [CSChar] -> ShowS

Show CUChar

Defined in Foreign.C.Types

Methods

showsPrec :: Int -> CUChar -> ShowS

show :: CUChar -> String

showList :: [CUChar] -> ShowS

Show CShort

Defined in Foreign.C.Types

Methods

showsPrec :: Int -> CShort -> ShowS

show :: CShort -> String

showList :: [CShort] -> ShowS

Show CUShort

Defined in Foreign.C.Types

Methods

showsPrec :: Int -> CUShort -> ShowS

show :: CUShort -> String

showList :: [CUShort] -> ShowS

Show CInt

Defined in Foreign.C.Types

Methods

showsPrec :: Int -> CInt -> ShowS

show :: CInt -> String

showList :: [CInt] -> ShowS

Show CUInt

Defined in Foreign.C.Types

Methods

showsPrec :: Int -> CUInt -> ShowS

show :: CUInt -> String

showList :: [CUInt] -> ShowS

Show CLong

Defined in Foreign.C.Types

Methods

showsPrec :: Int -> CLong -> ShowS

show :: CLong -> String

showList :: [CLong] -> ShowS

Show CULong

Defined in Foreign.C.Types

Methods

showsPrec :: Int -> CULong -> ShowS

show :: CULong -> String

showList :: [CULong] -> ShowS

Show CLLong

Defined in Foreign.C.Types

Methods

showsPrec :: Int -> CLLong -> ShowS

show :: CLLong -> String

showList :: [CLLong] -> ShowS

Show CULLong

Defined in Foreign.C.Types

Methods

showsPrec :: Int -> CULLong -> ShowS

show :: CULLong -> String

showList :: [CULLong] -> ShowS

Show CBool

Defined in Foreign.C.Types

Methods

showsPrec :: Int -> CBool -> ShowS

show :: CBool -> String

showList :: [CBool] -> ShowS

Show CFloat

Defined in Foreign.C.Types

Methods

showsPrec :: Int -> CFloat -> ShowS

show :: CFloat -> String

showList :: [CFloat] -> ShowS

Show CDouble

Defined in Foreign.C.Types

Methods

showsPrec :: Int -> CDouble -> ShowS

show :: CDouble -> String

showList :: [CDouble] -> ShowS

Show CPtrdiff

Defined in Foreign.C.Types

Methods

showsPrec :: Int -> CPtrdiff -> ShowS

show :: CPtrdiff -> String

showList :: [CPtrdiff] -> ShowS

Show CSize

Defined in Foreign.C.Types

Methods

showsPrec :: Int -> CSize -> ShowS

show :: CSize -> String

showList :: [CSize] -> ShowS

Show CWchar

Defined in Foreign.C.Types

Methods

showsPrec :: Int -> CWchar -> ShowS

show :: CWchar -> String

showList :: [CWchar] -> ShowS

Show CSigAtomic

Defined in Foreign.C.Types

Methods

showsPrec :: Int -> CSigAtomic -> ShowS

show :: CSigAtomic -> String

showList :: [CSigAtomic] -> ShowS

Show CClock

Defined in Foreign.C.Types

Methods

showsPrec :: Int -> CClock -> ShowS

show :: CClock -> String

showList :: [CClock] -> ShowS

Show CTime

Defined in Foreign.C.Types

Methods

showsPrec :: Int -> CTime -> ShowS

show :: CTime -> String

showList :: [CTime] -> ShowS

Show CUSeconds

Defined in Foreign.C.Types

Methods

showsPrec :: Int -> CUSeconds -> ShowS

show :: CUSeconds -> String

showList :: [CUSeconds] -> ShowS

Show CSUSeconds

Defined in Foreign.C.Types

Methods

showsPrec :: Int -> CSUSeconds -> ShowS

show :: CSUSeconds -> String

showList :: [CSUSeconds] -> ShowS

Show CIntPtr

Defined in Foreign.C.Types

Methods

showsPrec :: Int -> CIntPtr -> ShowS

show :: CIntPtr -> String

showList :: [CIntPtr] -> ShowS

Show CUIntPtr

Defined in Foreign.C.Types

Methods

showsPrec :: Int -> CUIntPtr -> ShowS

show :: CUIntPtr -> String

showList :: [CUIntPtr] -> ShowS

Show CIntMax

Defined in Foreign.C.Types

Methods

showsPrec :: Int -> CIntMax -> ShowS

show :: CIntMax -> String

showList :: [CIntMax] -> ShowS

Show CUIntMax

Defined in Foreign.C.Types

Methods

showsPrec :: Int -> CUIntMax -> ShowS

show :: CUIntMax -> String

showList :: [CUIntMax] -> ShowS

Show WordPtr

Defined in Foreign.Ptr

Methods

showsPrec :: Int -> WordPtr -> ShowS

show :: WordPtr -> String

showList :: [WordPtr] -> ShowS

Show IntPtr

Defined in Foreign.Ptr

Methods

showsPrec :: Int -> IntPtr -> ShowS

show :: IntPtr -> String

showList :: [IntPtr] -> ShowS

Show IOMode

Since: base-4.2.0.0

Defined in GHC.IO.IOMode

Methods

showsPrec :: Int -> IOMode -> ShowS

show :: IOMode -> String

showList :: [IOMode] -> ShowS

Show Fingerprint

Since: base-4.7.0.0

Defined in GHC.Fingerprint.Type

Methods

showsPrec :: Int -> Fingerprint -> ShowS

show :: Fingerprint -> String

showList :: [Fingerprint] -> ShowS

Show GeneralCategory

Since: base-2.1

Defined in GHC.Unicode

Methods

showsPrec :: Int -> GeneralCategory -> ShowS

show :: GeneralCategory -> String

showList :: [GeneralCategory] -> ShowS

Show SrcLoc

Since: base-4.9.0.0

Defined in GHC.Show

Methods

showsPrec :: Int -> SrcLoc -> ShowS

show :: SrcLoc -> String

showList :: [SrcLoc] -> ShowS

Show SomeException

Since: base-3.0

Defined in GHC.Exception.Type

Methods

showsPrec :: Int -> SomeException -> ShowS

show :: SomeException -> String

showList :: [SomeException] -> ShowS

Show ASCII7_Invalid

Defined in Basement.String.Encoding.ASCII7

Methods

showsPrec :: Int -> ASCII7_Invalid -> ShowS

show :: ASCII7_Invalid -> String

showList :: [ASCII7_Invalid] -> ShowS

Show ISO_8859_1_Invalid

Defined in Basement.String.Encoding.ISO_8859_1

Methods

showsPrec :: Int -> ISO_8859_1_Invalid -> ShowS

show :: ISO_8859_1_Invalid -> String

showList :: [ISO_8859_1_Invalid] -> ShowS

Show UTF16_Invalid

Defined in Basement.String.Encoding.UTF16

Methods

showsPrec :: Int -> UTF16_Invalid -> ShowS

show :: UTF16_Invalid -> String

showList :: [UTF16_Invalid] -> ShowS

Show UTF32_Invalid

Defined in Basement.String.Encoding.UTF32

Methods

showsPrec :: Int -> UTF32_Invalid -> ShowS

show :: UTF32_Invalid -> String

showList :: [UTF32_Invalid] -> ShowS

Show Encoding

Defined in Basement.String

Methods

showsPrec :: Int -> Encoding -> ShowS

show :: Encoding -> String

showList :: [Encoding] -> ShowS

Show String

Defined in Basement.UTF8.Base

Methods

showsPrec :: Int -> String -> ShowS

show :: String -> String0

showList :: [String] -> ShowS

Show FileSize

Defined in Basement.Types.OffsetSize

Methods

showsPrec :: Int -> FileSize -> ShowS

show :: FileSize -> String

showList :: [FileSize] -> ShowS

Show ShortByteString

Defined in Data.ByteString.Short.Internal

Methods

showsPrec :: Int -> ShortByteString -> ShowS

show :: ShortByteString -> String

showList :: [ShortByteString] -> ShowS

Show ByteString

Defined in Data.ByteString.Lazy.Internal

Methods

showsPrec :: Int -> ByteString -> ShowS

show :: ByteString -> String

showList :: [ByteString] -> ShowS

Show ByteString

Defined in Data.ByteString.Internal

Methods

showsPrec :: Int -> ByteString -> ShowS

show :: ByteString -> String

showList :: [ByteString] -> ShowS

Show Clock

Defined in System.Clock

Methods

showsPrec :: Int -> Clock -> ShowS

show :: Clock -> String

showList :: [Clock] -> ShowS

Show TimeSpec

Defined in System.Clock

Methods

showsPrec :: Int -> TimeSpec -> ShowS

show :: TimeSpec -> String

showList :: [TimeSpec] -> ShowS

Show IntSet

Defined in Data.IntSet.Internal

Methods

showsPrec :: Int -> IntSet -> ShowS

show :: IntSet -> String

showList :: [IntSet] -> ShowS

Show Blake2b_160

Defined in Crypto.Hash.Blake2b

Methods

showsPrec :: Int -> Blake2b_160 -> ShowS

show :: Blake2b_160 -> String

showList :: [Blake2b_160] -> ShowS

Show Blake2b_224

Defined in Crypto.Hash.Blake2b

Methods

showsPrec :: Int -> Blake2b_224 -> ShowS

show :: Blake2b_224 -> String

showList :: [Blake2b_224] -> ShowS

Show Blake2b_256

Defined in Crypto.Hash.Blake2b

Methods

showsPrec :: Int -> Blake2b_256 -> ShowS

show :: Blake2b_256 -> String

showList :: [Blake2b_256] -> ShowS

Show Blake2b_384

Defined in Crypto.Hash.Blake2b

Methods

showsPrec :: Int -> Blake2b_384 -> ShowS

show :: Blake2b_384 -> String

showList :: [Blake2b_384] -> ShowS

Show Blake2b_512

Defined in Crypto.Hash.Blake2b

Methods

showsPrec :: Int -> Blake2b_512 -> ShowS

show :: Blake2b_512 -> String

showList :: [Blake2b_512] -> ShowS

Show Blake2bp_512

Defined in Crypto.Hash.Blake2bp

Methods

showsPrec :: Int -> Blake2bp_512 -> ShowS

show :: Blake2bp_512 -> String

showList :: [Blake2bp_512] -> ShowS

Show Blake2s_160

Defined in Crypto.Hash.Blake2s

Methods

showsPrec :: Int -> Blake2s_160 -> ShowS

show :: Blake2s_160 -> String

showList :: [Blake2s_160] -> ShowS

Show Blake2s_224

Defined in Crypto.Hash.Blake2s

Methods

showsPrec :: Int -> Blake2s_224 -> ShowS

show :: Blake2s_224 -> String

showList :: [Blake2s_224] -> ShowS

Show Blake2s_256

Defined in Crypto.Hash.Blake2s

Methods

showsPrec :: Int -> Blake2s_256 -> ShowS

show :: Blake2s_256 -> String

showList :: [Blake2s_256] -> ShowS

Show Blake2sp_224

Defined in Crypto.Hash.Blake2sp

Methods

showsPrec :: Int -> Blake2sp_224 -> ShowS

show :: Blake2sp_224 -> String

showList :: [Blake2sp_224] -> ShowS

Show Blake2sp_256

Defined in Crypto.Hash.Blake2sp

Methods

showsPrec :: Int -> Blake2sp_256 -> ShowS

show :: Blake2sp_256 -> String

showList :: [Blake2sp_256] -> ShowS

Show Keccak_224

Defined in Crypto.Hash.Keccak

Methods

showsPrec :: Int -> Keccak_224 -> ShowS

show :: Keccak_224 -> String

showList :: [Keccak_224] -> ShowS

Show Keccak_256

Defined in Crypto.Hash.Keccak

Methods

showsPrec :: Int -> Keccak_256 -> ShowS

show :: Keccak_256 -> String

showList :: [Keccak_256] -> ShowS

Show Keccak_384

Defined in Crypto.Hash.Keccak

Methods

showsPrec :: Int -> Keccak_384 -> ShowS

show :: Keccak_384 -> String

showList :: [Keccak_384] -> ShowS

Show Keccak_512

Defined in Crypto.Hash.Keccak

Methods

showsPrec :: Int -> Keccak_512 -> ShowS

show :: Keccak_512 -> String

showList :: [Keccak_512] -> ShowS

Show MD2

Defined in Crypto.Hash.MD2

Methods

showsPrec :: Int -> MD2 -> ShowS

show :: MD2 -> String

showList :: [MD2] -> ShowS

Show MD4

Defined in Crypto.Hash.MD4

Methods

showsPrec :: Int -> MD4 -> ShowS

show :: MD4 -> String

showList :: [MD4] -> ShowS

Show MD5

Defined in Crypto.Hash.MD5

Methods

showsPrec :: Int -> MD5 -> ShowS

show :: MD5 -> String

showList :: [MD5] -> ShowS

Show RIPEMD160

Defined in Crypto.Hash.RIPEMD160

Methods

showsPrec :: Int -> RIPEMD160 -> ShowS

show :: RIPEMD160 -> String

showList :: [RIPEMD160] -> ShowS

Show SHA1

Defined in Crypto.Hash.SHA1

Methods

showsPrec :: Int -> SHA1 -> ShowS

show :: SHA1 -> String

showList :: [SHA1] -> ShowS

Show SHA224

Defined in Crypto.Hash.SHA224

Methods

showsPrec :: Int -> SHA224 -> ShowS

show :: SHA224 -> String

showList :: [SHA224] -> ShowS

Show SHA256

Defined in Crypto.Hash.SHA256

Methods

showsPrec :: Int -> SHA256 -> ShowS

show :: SHA256 -> String

showList :: [SHA256] -> ShowS

Show SHA3_224

Defined in Crypto.Hash.SHA3

Methods

showsPrec :: Int -> SHA3_224 -> ShowS

show :: SHA3_224 -> String

showList :: [SHA3_224] -> ShowS

Show SHA3_256

Defined in Crypto.Hash.SHA3

Methods

showsPrec :: Int -> SHA3_256 -> ShowS

show :: SHA3_256 -> String

showList :: [SHA3_256] -> ShowS

Show SHA3_384

Defined in Crypto.Hash.SHA3

Methods

showsPrec :: Int -> SHA3_384 -> ShowS

show :: SHA3_384 -> String

showList :: [SHA3_384] -> ShowS

Show SHA3_512

Defined in Crypto.Hash.SHA3

Methods

showsPrec :: Int -> SHA3_512 -> ShowS

show :: SHA3_512 -> String

showList :: [SHA3_512] -> ShowS

Show SHA384

Defined in Crypto.Hash.SHA384

Methods

showsPrec :: Int -> SHA384 -> ShowS

show :: SHA384 -> String

showList :: [SHA384] -> ShowS

Show SHA512

Defined in Crypto.Hash.SHA512

Methods

showsPrec :: Int -> SHA512 -> ShowS

show :: SHA512 -> String

showList :: [SHA512] -> ShowS

Show SHA512t_224

Defined in Crypto.Hash.SHA512t

Methods

showsPrec :: Int -> SHA512t_224 -> ShowS

show :: SHA512t_224 -> String

showList :: [SHA512t_224] -> ShowS

Show SHA512t_256

Defined in Crypto.Hash.SHA512t

Methods

showsPrec :: Int -> SHA512t_256 -> ShowS

show :: SHA512t_256 -> String

showList :: [SHA512t_256] -> ShowS

Show Skein256_224

Defined in Crypto.Hash.Skein256

Methods

showsPrec :: Int -> Skein256_224 -> ShowS

show :: Skein256_224 -> String

showList :: [Skein256_224] -> ShowS

Show Skein256_256

Defined in Crypto.Hash.Skein256

Methods

showsPrec :: Int -> Skein256_256 -> ShowS

show :: Skein256_256 -> String

showList :: [Skein256_256] -> ShowS

Show Skein512_224

Defined in Crypto.Hash.Skein512

Methods

showsPrec :: Int -> Skein512_224 -> ShowS

show :: Skein512_224 -> String

showList :: [Skein512_224] -> ShowS

Show Skein512_256

Defined in Crypto.Hash.Skein512

Methods

showsPrec :: Int -> Skein512_256 -> ShowS

show :: Skein512_256 -> String

showList :: [Skein512_256] -> ShowS

Show Skein512_384

Defined in Crypto.Hash.Skein512

Methods

showsPrec :: Int -> Skein512_384 -> ShowS

show :: Skein512_384 -> String

showList :: [Skein512_384] -> ShowS

Show Skein512_512

Defined in Crypto.Hash.Skein512

Methods

showsPrec :: Int -> Skein512_512 -> ShowS

show :: Skein512_512 -> String

showList :: [Skein512_512] -> ShowS

Show Tiger

Defined in Crypto.Hash.Tiger

Methods

showsPrec :: Int -> Tiger -> ShowS

show :: Tiger -> String

showList :: [Tiger] -> ShowS

Show Whirlpool

Defined in Crypto.Hash.Whirlpool

Methods

showsPrec :: Int -> Whirlpool -> ShowS

show :: Whirlpool -> String

showList :: [Whirlpool] -> ShowS

Show FileType

Defined in System.Directory.Internal.Common

Methods

showsPrec :: Int -> FileType -> ShowS

show :: FileType -> String

showList :: [FileType] -> ShowS

Show Permissions

Defined in System.Directory.Internal.Common

Methods

showsPrec :: Int -> Permissions -> ShowS

show :: Permissions -> String

showList :: [Permissions] -> ShowS

Show XdgDirectory

Defined in System.Directory.Internal.Common

Methods

showsPrec :: Int -> XdgDirectory -> ShowS

show :: XdgDirectory -> String

showList :: [XdgDirectory] -> ShowS

Show XdgDirectoryList

Defined in System.Directory.Internal.Common

Methods

showsPrec :: Int -> XdgDirectoryList -> ShowS

show :: XdgDirectoryList -> String

showList :: [XdgDirectoryList] -> ShowS

Show Extension

Defined in GHC.LanguageExtensions.Type

Methods

showsPrec :: Int -> Extension -> ShowS

show :: Extension -> String

showList :: [Extension] -> ShowS

Show ForeignSrcLang

Defined in GHC.ForeignSrcLang.Type

Methods

showsPrec :: Int -> ForeignSrcLang -> ShowS

show :: ForeignSrcLang -> String

showList :: [ForeignSrcLang] -> ShowS

Show Half

Defined in Numeric.Half

Methods

showsPrec :: Int -> Half -> ShowS

show :: Half -> String

showList :: [Half] -> ShowS

Show Name

Defined in Hedgehog.Internal.State

Methods

showsPrec :: Int -> Name -> ShowS

show :: Name -> String

showList :: [Name] -> ShowS

Show Environment

Defined in Hedgehog.Internal.State

Methods

showsPrec :: Int -> Environment -> ShowS

show :: Environment -> String

showList :: [Environment] -> ShowS

Show EnvironmentError

Defined in Hedgehog.Internal.State

Methods

showsPrec :: Int -> EnvironmentError -> ShowS

show :: EnvironmentError -> String

showList :: [EnvironmentError] -> ShowS

Show PropertyName

Defined in Hedgehog.Internal.Property

Methods

showsPrec :: Int -> PropertyName -> ShowS

show :: PropertyName -> String

showList :: [PropertyName] -> ShowS

Show Confidence

Defined in Hedgehog.Internal.Property

Methods

showsPrec :: Int -> Confidence -> ShowS

show :: Confidence -> String

showList :: [Confidence] -> ShowS

Show PropertyConfig

Defined in Hedgehog.Internal.Property

Methods

showsPrec :: Int -> PropertyConfig -> ShowS

show :: PropertyConfig -> String

showList :: [PropertyConfig] -> ShowS

Show TestLimit

Defined in Hedgehog.Internal.Property

Methods

showsPrec :: Int -> TestLimit -> ShowS

show :: TestLimit -> String

showList :: [TestLimit] -> ShowS

Show TestCount

Defined in Hedgehog.Internal.Property

Methods

showsPrec :: Int -> TestCount -> ShowS

show :: TestCount -> String

showList :: [TestCount] -> ShowS

Show DiscardCount

Defined in Hedgehog.Internal.Property

Methods

showsPrec :: Int -> DiscardCount -> ShowS

show :: DiscardCount -> String

showList :: [DiscardCount] -> ShowS

Show DiscardLimit

Defined in Hedgehog.Internal.Property

Methods

showsPrec :: Int -> DiscardLimit -> ShowS

show :: DiscardLimit -> String

showList :: [DiscardLimit] -> ShowS

Show ShrinkLimit

Defined in Hedgehog.Internal.Property

Methods

showsPrec :: Int -> ShrinkLimit -> ShowS

show :: ShrinkLimit -> String

showList :: [ShrinkLimit] -> ShowS

Show ShrinkCount

Defined in Hedgehog.Internal.Property

Methods

showsPrec :: Int -> ShrinkCount -> ShowS

show :: ShrinkCount -> String

showList :: [ShrinkCount] -> ShowS

Show ShrinkRetries

Defined in Hedgehog.Internal.Property

Methods

showsPrec :: Int -> ShrinkRetries -> ShowS

show :: ShrinkRetries -> String

showList :: [ShrinkRetries] -> ShowS

Show GroupName

Defined in Hedgehog.Internal.Property

Methods

showsPrec :: Int -> GroupName -> ShowS

show :: GroupName -> String

showList :: [GroupName] -> ShowS

Show PropertyCount

Defined in Hedgehog.Internal.Property

Methods

showsPrec :: Int -> PropertyCount -> ShowS

show :: PropertyCount -> String

showList :: [PropertyCount] -> ShowS

Show TerminationCriteria

Defined in Hedgehog.Internal.Property

Methods

showsPrec :: Int -> TerminationCriteria -> ShowS

show :: TerminationCriteria -> String

showList :: [TerminationCriteria] -> ShowS

Show Log

Defined in Hedgehog.Internal.Property

Methods

showsPrec :: Int -> Log -> ShowS

show :: Log -> String

showList :: [Log] -> ShowS

Show Journal

Defined in Hedgehog.Internal.Property

Methods

showsPrec :: Int -> Journal -> ShowS

show :: Journal -> String

showList :: [Journal] -> ShowS

Show Failure

Defined in Hedgehog.Internal.Property

Methods

showsPrec :: Int -> Failure -> ShowS

show :: Failure -> String

showList :: [Failure] -> ShowS

Show Diff

Defined in Hedgehog.Internal.Property

Methods

showsPrec :: Int -> Diff -> ShowS

show :: Diff -> String

showList :: [Diff] -> ShowS

Show Cover

Defined in Hedgehog.Internal.Property

Methods

showsPrec :: Int -> Cover -> ShowS

show :: Cover -> String

showList :: [Cover] -> ShowS

Show CoverCount

Defined in Hedgehog.Internal.Property

Methods

showsPrec :: Int -> CoverCount -> ShowS

show :: CoverCount -> String

showList :: [CoverCount] -> ShowS

Show CoverPercentage

Defined in Hedgehog.Internal.Property

Methods

showsPrec :: Int -> CoverPercentage -> ShowS

show :: CoverPercentage -> String

showList :: [CoverPercentage] -> ShowS

Show LabelName

Defined in Hedgehog.Internal.Property

Methods

showsPrec :: Int -> LabelName -> ShowS

show :: LabelName -> String

showList :: [LabelName] -> ShowS

Show LineNo

Defined in Hedgehog.Internal.Source

Methods

showsPrec :: Int -> LineNo -> ShowS

show :: LineNo -> String

showList :: [LineNo] -> ShowS

Show ColumnNo

Defined in Hedgehog.Internal.Source

Methods

showsPrec :: Int -> ColumnNo -> ShowS

show :: ColumnNo -> String

showList :: [ColumnNo] -> ShowS

Show Span

Defined in Hedgehog.Internal.Source

Methods

showsPrec :: Int -> Span -> ShowS

show :: Span -> String

showList :: [Span] -> ShowS

Show Seed

Defined in Hedgehog.Internal.Seed

Methods

showsPrec :: Int -> Seed -> ShowS

show :: Seed -> String

showList :: [Seed] -> ShowS

Show Size

Defined in Hedgehog.Internal.Range

Methods

showsPrec :: Int -> Size -> ShowS

show :: Size -> String

showList :: [Size] -> ShowS

Show RuleBndr

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> RuleBndr -> ShowS

show :: RuleBndr -> String

showList :: [RuleBndr] -> ShowS

Show Phases

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> Phases -> ShowS

show :: Phases -> String

showList :: [Phases] -> ShowS

Show RuleMatch

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> RuleMatch -> ShowS

show :: RuleMatch -> String

showList :: [RuleMatch] -> ShowS

Show Inline

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> Inline -> ShowS

show :: Inline -> String

showList :: [Inline] -> ShowS

Show Pragma

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> Pragma -> ShowS

show :: Pragma -> String

showList :: [Pragma] -> ShowS

Show DerivClause

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> DerivClause -> ShowS

show :: DerivClause -> String

showList :: [DerivClause] -> ShowS

Show DerivStrategy

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> DerivStrategy -> ShowS

show :: DerivStrategy -> String

showList :: [DerivStrategy] -> ShowS

Show TySynEqn

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> TySynEqn -> ShowS

show :: TySynEqn -> String

showList :: [TySynEqn] -> ShowS

Show Fixity

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> Fixity -> ShowS

show :: Fixity -> String

showList :: [Fixity] -> ShowS

Show Info

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> Info -> ShowS

show :: Info -> String

showList :: [Info] -> ShowS

Show Con

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> Con -> ShowS

show :: Con -> String

showList :: [Con] -> ShowS

Show TyVarBndr

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> TyVarBndr -> ShowS

show :: TyVarBndr -> String

showList :: [TyVarBndr] -> ShowS

Show DefName

Defined in Control.Lens.Internal.FieldTH

Methods

showsPrec :: Int -> DefName -> ShowS

show :: DefName -> String

showList :: [DefName] -> ShowS

Show IsCmdStart

Defined in Options.Applicative.Types

Methods

showsPrec :: Int -> IsCmdStart -> ShowS

show :: IsCmdStart -> String

showList :: [IsCmdStart] -> ShowS

Show Backtracking

Defined in Options.Applicative.Types

Methods

showsPrec :: Int -> Backtracking -> ShowS

show :: Backtracking -> String

showList :: [Backtracking] -> ShowS

Show ParserPrefs

Defined in Options.Applicative.Types

Methods

showsPrec :: Int -> ParserPrefs -> ShowS

show :: ParserPrefs -> String

showList :: [ParserPrefs] -> ShowS

Show OptName

Defined in Options.Applicative.Types

Methods

showsPrec :: Int -> OptName -> ShowS

show :: OptName -> String

showList :: [OptName] -> ShowS

Show OptVisibility

Defined in Options.Applicative.Types

Methods

showsPrec :: Int -> OptVisibility -> ShowS

show :: OptVisibility -> String

showList :: [OptVisibility] -> ShowS

Show OptProperties

Defined in Options.Applicative.Types

Methods

showsPrec :: Int -> OptProperties -> ShowS

show :: OptProperties -> String

showList :: [OptProperties] -> ShowS

Show CompletionResult

Defined in Options.Applicative.Types

Methods

showsPrec :: Int -> CompletionResult -> ShowS

show :: CompletionResult -> String

showList :: [CompletionResult] -> ShowS

Show ArgPolicy

Defined in Options.Applicative.Types

Methods

showsPrec :: Int -> ArgPolicy -> ShowS

show :: ArgPolicy -> String

showList :: [ArgPolicy] -> ShowS

Show OptHelpInfo

Defined in Options.Applicative.Types

Methods

showsPrec :: Int -> OptHelpInfo -> ShowS

show :: OptHelpInfo -> String

showList :: [OptHelpInfo] -> ShowS

Show AltNodeType

Defined in Options.Applicative.Types

Methods

showsPrec :: Int -> AltNodeType -> ShowS

show :: AltNodeType -> String

showList :: [AltNodeType] -> ShowS

Show Doc

Defined in Text.PrettyPrint.HughesPJ

Methods

showsPrec :: Int -> Doc -> ShowS

show :: Doc -> String

showList :: [Doc] -> ShowS

Show TextDetails

Defined in Text.PrettyPrint.Annotated.HughesPJ

Methods

showsPrec :: Int -> TextDetails -> ShowS

show :: TextDetails -> String

showList :: [TextDetails] -> ShowS

Show Style

Defined in Text.PrettyPrint.Annotated.HughesPJ

Methods

showsPrec :: Int -> Style -> ShowS

show :: Style -> String

showList :: [Style] -> ShowS

Show Mode

Defined in Text.PrettyPrint.Annotated.HughesPJ

Methods

showsPrec :: Int -> Mode -> ShowS

show :: Mode -> String

showList :: [Mode] -> ShowS

Show FusionDepth

Defined in Data.Text.Prettyprint.Doc.Internal

Methods

showsPrec :: Int -> FusionDepth -> ShowS

show :: FusionDepth -> String

showList :: [FusionDepth] -> ShowS

Show PageWidth

Defined in Data.Text.Prettyprint.Doc.Internal

Methods

showsPrec :: Int -> PageWidth -> ShowS

show :: PageWidth -> String

showList :: [PageWidth] -> ShowS

Show LayoutOptions

Defined in Data.Text.Prettyprint.Doc.Internal

Methods

showsPrec :: Int -> LayoutOptions -> ShowS

show :: LayoutOptions -> String

showList :: [LayoutOptions] -> ShowS

Show Color

Defined in Prettyprinter.Render.Terminal.Internal

Methods

showsPrec :: Int -> Color -> ShowS

show :: Color -> String

showList :: [Color] -> ShowS

Show Intensity

Defined in Prettyprinter.Render.Terminal.Internal

Methods

showsPrec :: Int -> Intensity -> ShowS

show :: Intensity -> String

showList :: [Intensity] -> ShowS

Show Bold

Defined in Prettyprinter.Render.Terminal.Internal

Methods

showsPrec :: Int -> Bold -> ShowS

show :: Bold -> String

showList :: [Bold] -> ShowS

Show Underlined

Defined in Prettyprinter.Render.Terminal.Internal

Methods

showsPrec :: Int -> Underlined -> ShowS

show :: Underlined -> String

showList :: [Underlined] -> ShowS

Show Italicized

Defined in Prettyprinter.Render.Terminal.Internal

Methods

showsPrec :: Int -> Italicized -> ShowS

show :: Italicized -> String

showList :: [Italicized] -> ShowS

Show AnsiStyle

Defined in Prettyprinter.Render.Terminal.Internal

Methods

showsPrec :: Int -> AnsiStyle -> ShowS

show :: AnsiStyle -> String

showList :: [AnsiStyle] -> ShowS

Show ByteArray

Since: primitive-0.6.3.0

Defined in Data.Primitive.ByteArray

Methods

showsPrec :: Int -> ByteArray -> ShowS

show :: ByteArray -> String

showList :: [ByteArray] -> ShowS

Show InvalidAccess

Defined in Control.Monad.Trans.Resource.Internal

Methods

showsPrec :: Int -> InvalidAccess -> ShowS

show :: InvalidAccess -> String

showList :: [InvalidAccess] -> ShowS

Show ResourceCleanupException

Defined in Control.Monad.Trans.Resource.Internal

Methods

showsPrec :: Int -> ResourceCleanupException -> ShowS

show :: ResourceCleanupException -> String

showList :: [ResourceCleanupException] -> ShowS

Show ResourceError

Defined in Test.Tasty.Core

Methods

showsPrec :: Int -> ResourceError -> ShowS

show :: ResourceError -> String

showList :: [ResourceError] -> ShowS

Show FailureReason

Defined in Test.Tasty.Core

Methods

showsPrec :: Int -> FailureReason -> ShowS

show :: FailureReason -> String

showList :: [FailureReason] -> ShowS

Show Outcome

Defined in Test.Tasty.Core

Methods

showsPrec :: Int -> Outcome -> ShowS

show :: Outcome -> String

showList :: [Outcome] -> ShowS

Show Result

Defined in Test.Tasty.Core

Methods

showsPrec :: Int -> Result -> ShowS

show :: Result -> String

showList :: [Result] -> ShowS

Show Progress

Defined in Test.Tasty.Core

Methods

showsPrec :: Int -> Progress -> ShowS

show :: Progress -> String

showList :: [Progress] -> ShowS

Show DependencyType

Defined in Test.Tasty.Core

Methods

showsPrec :: Int -> DependencyType -> ShowS

show :: DependencyType -> String

showList :: [DependencyType] -> ShowS

Show Timeout

Defined in Test.Tasty.Options.Core

Methods

showsPrec :: Int -> Timeout -> ShowS

show :: Timeout -> String

showList :: [Timeout] -> ShowS

Show ForallVisFlag

Defined in Language.Haskell.TH.Ppr

Methods

showsPrec :: Int -> ForallVisFlag -> ShowS

show :: ForallVisFlag -> String

showList :: [ForallVisFlag] -> ShowS

Show ModName

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> ModName -> ShowS

show :: ModName -> String

showList :: [ModName] -> ShowS

Show PkgName

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> PkgName -> ShowS

show :: PkgName -> String

showList :: [PkgName] -> ShowS

Show Module

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> Module -> ShowS

show :: Module -> String

showList :: [Module] -> ShowS

Show OccName

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> OccName -> ShowS

show :: OccName -> String

showList :: [OccName] -> ShowS

Show NameFlavour

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> NameFlavour -> ShowS

show :: NameFlavour -> String

showList :: [NameFlavour] -> ShowS

Show NameSpace

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> NameSpace -> ShowS

show :: NameSpace -> String

showList :: [NameSpace] -> ShowS

Show Loc

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> Loc -> ShowS

show :: Loc -> String

showList :: [Loc] -> ShowS

Show ModuleInfo

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> ModuleInfo -> ShowS

show :: ModuleInfo -> String

showList :: [ModuleInfo] -> ShowS

Show FixityDirection

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> FixityDirection -> ShowS

show :: FixityDirection -> String

showList :: [FixityDirection] -> ShowS

Show Lit

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> Lit -> ShowS

show :: Lit -> String

showList :: [Lit] -> ShowS

Show Bytes

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> Bytes -> ShowS

show :: Bytes -> String

showList :: [Bytes] -> ShowS

Show Body

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> Body -> ShowS

show :: Body -> String

showList :: [Body] -> ShowS

Show Guard

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> Guard -> ShowS

show :: Guard -> String

showList :: [Guard] -> ShowS

Show Stmt

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> Stmt -> ShowS

show :: Stmt -> String

showList :: [Stmt] -> ShowS

Show Range

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> Range -> ShowS

show :: Range -> String

showList :: [Range] -> ShowS

Show TypeFamilyHead

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> TypeFamilyHead -> ShowS

show :: TypeFamilyHead -> String

showList :: [TypeFamilyHead] -> ShowS

Show Foreign

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> Foreign -> ShowS

show :: Foreign -> String

showList :: [Foreign] -> ShowS

Show Callconv

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> Callconv -> ShowS

show :: Callconv -> String

showList :: [Callconv] -> ShowS

Show Safety

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> Safety -> ShowS

show :: Safety -> String

showList :: [Safety] -> ShowS

Show AnnTarget

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> AnnTarget -> ShowS

show :: AnnTarget -> String

showList :: [AnnTarget] -> ShowS

Show SourceUnpackedness

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> SourceUnpackedness -> ShowS

show :: SourceUnpackedness -> String

showList :: [SourceUnpackedness] -> ShowS

Show SourceStrictness

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> SourceStrictness -> ShowS

show :: SourceStrictness -> String

showList :: [SourceStrictness] -> ShowS

Show DecidedStrictness

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> DecidedStrictness -> ShowS

show :: DecidedStrictness -> String

showList :: [DecidedStrictness] -> ShowS

Show Bang

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> Bang -> ShowS

show :: Bang -> String

showList :: [Bang] -> ShowS

Show PatSynDir

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> PatSynDir -> ShowS

show :: PatSynDir -> String

showList :: [PatSynDir] -> ShowS

Show PatSynArgs

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> PatSynArgs -> ShowS

show :: PatSynArgs -> String

showList :: [PatSynArgs] -> ShowS

Show FamilyResultSig

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> FamilyResultSig -> ShowS

show :: FamilyResultSig -> String

showList :: [FamilyResultSig] -> ShowS

Show TyLit

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> TyLit -> ShowS

show :: TyLit -> String

showList :: [TyLit] -> ShowS

Show Role

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> Role -> ShowS

show :: Role -> String

showList :: [Role] -> ShowS

Show AnnLookup

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> AnnLookup -> ShowS

show :: AnnLookup -> String

showList :: [AnnLookup] -> ShowS

Show DatatypeInfo

Defined in Language.Haskell.TH.Datatype

Methods

showsPrec :: Int -> DatatypeInfo -> ShowS

show :: DatatypeInfo -> String

showList :: [DatatypeInfo] -> ShowS

Show DatatypeVariant

Defined in Language.Haskell.TH.Datatype

Methods

showsPrec :: Int -> DatatypeVariant -> ShowS

show :: DatatypeVariant -> String

showList :: [DatatypeVariant] -> ShowS

Show ConstructorInfo

Defined in Language.Haskell.TH.Datatype

Methods

showsPrec :: Int -> ConstructorInfo -> ShowS

show :: ConstructorInfo -> String

showList :: [ConstructorInfo] -> ShowS

Show ConstructorVariant

Defined in Language.Haskell.TH.Datatype

Methods

showsPrec :: Int -> ConstructorVariant -> ShowS

show :: ConstructorVariant -> String

showList :: [ConstructorVariant] -> ShowS

Show FieldStrictness

Defined in Language.Haskell.TH.Datatype

Methods

showsPrec :: Int -> FieldStrictness -> ShowS

show :: FieldStrictness -> String

showList :: [FieldStrictness] -> ShowS

Show Unpackedness

Defined in Language.Haskell.TH.Datatype

Methods

showsPrec :: Int -> Unpackedness -> ShowS

show :: Unpackedness -> String

showList :: [Unpackedness] -> ShowS

Show Strictness

Defined in Language.Haskell.TH.Datatype

Methods

showsPrec :: Int -> Strictness -> ShowS

show :: Strictness -> String

showList :: [Strictness] -> ShowS

Show ZonedTime

Defined in Data.Time.LocalTime.Internal.ZonedTime

Methods

showsPrec :: Int -> ZonedTime -> ShowS

show :: ZonedTime -> String

showList :: [ZonedTime] -> ShowS

Show LocalTime

Defined in Data.Time.LocalTime.Internal.LocalTime

Methods

showsPrec :: Int -> LocalTime -> ShowS

show :: LocalTime -> String

showList :: [LocalTime] -> ShowS

Show Layer

Defined in Prettyprinter.Render.Terminal.Internal

Methods

showsPrec :: Int -> Layer -> ShowS

show :: Layer -> String

showList :: [Layer] -> ShowS

Show All

Defined in Data.Array.Accelerate.Sugar.Shape

Methods

showsPrec :: Int -> All -> ShowS

show :: All -> String

showList :: [All] -> ShowS

Show Z

Defined in Data.Array.Accelerate.Sugar.Shape

Methods

showsPrec :: Int -> Z -> ShowS

show :: Z -> String

showList :: [Z] -> ShowS

Show Slot

Defined in Data.HashTable.ST.Basic

Methods

showsPrec :: Int -> Slot -> ShowS

show :: Slot -> String

showList :: [Slot] -> ShowS

Show SlotFindResponse

Defined in Data.HashTable.ST.Basic

Methods

showsPrec :: Int -> SlotFindResponse -> ShowS

show :: SlotFindResponse -> String

showList :: [SlotFindResponse] -> ShowS

Show a => Show [a]

Since: base-2.1

Defined in GHC.Show

Methods

showsPrec :: Int -> [a] -> ShowS

show :: [a] -> String

showList :: [[a]] -> ShowS

Show a => Show (Maybe a)

Since: base-2.1

Defined in GHC.Show

Methods

showsPrec :: Int -> Maybe a -> ShowS

show :: Maybe a -> String

showList :: [Maybe a] -> ShowS

Show a => Show (Ratio a)

Since: base-2.0.1

Defined in GHC.Real

Methods

showsPrec :: Int -> Ratio a -> ShowS

show :: Ratio a -> String

showList :: [Ratio a] -> ShowS

Show (Ptr a)

Since: base-2.1

Defined in GHC.Ptr

Methods

showsPrec :: Int -> Ptr a -> ShowS

show :: Ptr a -> String

showList :: [Ptr a] -> ShowS

Show (FunPtr a)

Since: base-2.1

Defined in GHC.Ptr

Methods

showsPrec :: Int -> FunPtr a -> ShowS

show :: FunPtr a -> String

showList :: [FunPtr a] -> ShowS

Show p => Show (Par1 p)

Since: base-4.7.0.0

Defined in GHC.Generics

Methods

showsPrec :: Int -> Par1 p -> ShowS

show :: Par1 p -> String

showList :: [Par1 p] -> ShowS

Show (ForeignPtr a)

Since: base-2.1

Defined in GHC.ForeignPtr

Methods

showsPrec :: Int -> ForeignPtr a -> ShowS

show :: ForeignPtr a -> String

showList :: [ForeignPtr a] -> ShowS

Show a => Show (Complex a)

Since: base-2.1

Defined in Data.Complex

Methods

showsPrec :: Int -> Complex a -> ShowS

show :: Complex a -> String

showList :: [Complex a] -> ShowS

Show a => Show (Min a)

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

showsPrec :: Int -> Min a -> ShowS

show :: Min a -> String

showList :: [Min a] -> ShowS

Show a => Show (Max a)

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

showsPrec :: Int -> Max a -> ShowS

show :: Max a -> String

showList :: [Max a] -> ShowS

Show a => Show (First a)

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

showsPrec :: Int -> First a -> ShowS

show :: First a -> String

showList :: [First a] -> ShowS

Show a => Show (Last a)

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

showsPrec :: Int -> Last a -> ShowS

show :: Last a -> String

showList :: [Last a] -> ShowS

Show m => Show (WrappedMonoid m)

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

showsPrec :: Int -> WrappedMonoid m -> ShowS

show :: WrappedMonoid m -> String

showList :: [WrappedMonoid m] -> ShowS

Show a => Show (Option a)

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

showsPrec :: Int -> Option a -> ShowS

show :: Option a -> String

showList :: [Option a] -> ShowS

Show a => Show (ZipList a)

Since: base-4.7.0.0

Defined in Control.Applicative

Methods

showsPrec :: Int -> ZipList a -> ShowS

show :: ZipList a -> String

showList :: [ZipList a] -> ShowS

Show a => Show (Identity a)

This instance would be equivalent to the derived instances of the Identity newtype if the runIdentity field were removed

Since: base-4.8.0.0

Defined in Data.Functor.Identity

Methods

showsPrec :: Int -> Identity a -> ShowS

show :: Identity a -> String

showList :: [Identity a] -> ShowS

Show a => Show (First a)

Since: base-2.1

Defined in Data.Monoid

Methods

showsPrec :: Int -> First a -> ShowS

show :: First a -> String

showList :: [First a] -> ShowS

Show a => Show (Last a)

Since: base-2.1

Defined in Data.Monoid

Methods

showsPrec :: Int -> Last a -> ShowS

show :: Last a -> String

showList :: [Last a] -> ShowS

Show a => Show (Dual a)

Since: base-2.1

Defined in Data.Semigroup.Internal

Methods

showsPrec :: Int -> Dual a -> ShowS

show :: Dual a -> String

showList :: [Dual a] -> ShowS

Show a => Show (Sum a)

Since: base-2.1

Defined in Data.Semigroup.Internal

Methods

showsPrec :: Int -> Sum a -> ShowS

show :: Sum a -> String

showList :: [Sum a] -> ShowS

Show a => Show (Product a)

Since: base-2.1

Defined in Data.Semigroup.Internal

Methods

showsPrec :: Int -> Product a -> ShowS

show :: Product a -> String

showList :: [Product a] -> ShowS

Show a => Show (Down a)

This instance would be equivalent to the derived instances of the Down newtype if the getDown field were removed

Since: base-4.7.0.0

Defined in Data.Ord

Methods

showsPrec :: Int -> Down a -> ShowS

show :: Down a -> String

showList :: [Down a] -> ShowS

Show a => Show (NonEmpty a)

Since: base-4.11.0.0

Defined in GHC.Show

Methods

showsPrec :: Int -> NonEmpty a -> ShowS

show :: NonEmpty a -> String

showList :: [NonEmpty a] -> ShowS

(PrimType ty, Show ty) => Show (UArray ty)

Defined in Basement.UArray.Base

Methods

showsPrec :: Int -> UArray ty -> ShowS

show :: UArray ty -> String

showList :: [UArray ty] -> ShowS

(PrimType ty, Show ty) => Show (Block ty)

Defined in Basement.Block.Base

Methods

showsPrec :: Int -> Block ty -> ShowS

show :: Block ty -> String

showList :: [Block ty] -> ShowS

Show a => Show (NonEmpty a)

Defined in Basement.NonEmpty

Methods

showsPrec :: Int -> NonEmpty a -> ShowS

show :: NonEmpty a -> String

showList :: [NonEmpty a] -> ShowS

Show (Offset ty)

Defined in Basement.Types.OffsetSize

Methods

showsPrec :: Int -> Offset ty -> ShowS

show :: Offset ty -> String

showList :: [Offset ty] -> ShowS

Show (CountOf ty)

Defined in Basement.Types.OffsetSize

Methods

showsPrec :: Int -> CountOf ty -> ShowS

show :: CountOf ty -> String

showList :: [CountOf ty] -> ShowS

Show (Zn64 n)

Defined in Basement.Bounded

Methods

showsPrec :: Int -> Zn64 n -> ShowS

show :: Zn64 n -> String

showList :: [Zn64 n] -> ShowS

Show (Zn n)

Defined in Basement.Bounded

Methods

showsPrec :: Int -> Zn n -> ShowS

show :: Zn n -> String

showList :: [Zn n] -> ShowS

Show a => Show (ExitCase a)

Defined in Control.Monad.Catch

Methods

showsPrec :: Int -> ExitCase a -> ShowS

show :: ExitCase a -> String

showList :: [ExitCase a] -> ShowS

Show a => Show (IntMap a)

Defined in Data.IntMap.Internal

Methods

showsPrec :: Int -> IntMap a -> ShowS

show :: IntMap a -> String

showList :: [IntMap a] -> ShowS

Show vertex => Show (SCC vertex)

Since: containers-0.5.9

Defined in Data.Graph

Methods

showsPrec :: Int -> SCC vertex -> ShowS

show :: SCC vertex -> String

showList :: [SCC vertex] -> ShowS

Show a => Show (Tree a)

Defined in Data.Tree

Methods

showsPrec :: Int -> Tree a -> ShowS

show :: Tree a -> String

showList :: [Tree a] -> ShowS

Show a => Show (Seq a)

Defined in Data.Sequence.Internal

Methods

showsPrec :: Int -> Seq a -> ShowS

show :: Seq a -> String

showList :: [Seq a] -> ShowS

Show a => Show (ViewL a)

Defined in Data.Sequence.Internal

Methods

showsPrec :: Int -> ViewL a -> ShowS

show :: ViewL a -> String

showList :: [ViewL a] -> ShowS

Show a => Show (ViewR a)

Defined in Data.Sequence.Internal

Methods

showsPrec :: Int -> ViewR a -> ShowS

show :: ViewR a -> String

showList :: [ViewR a] -> ShowS

Show a => Show (Set a)

Defined in Data.Set.Internal

Methods

showsPrec :: Int -> Set a -> ShowS

show :: Set a -> String

showList :: [Set a] -> ShowS

Show (Blake2s bitlen)

Defined in Crypto.Hash.Blake2

Methods

showsPrec :: Int -> Blake2s bitlen -> ShowS

show :: Blake2s bitlen -> String

showList :: [Blake2s bitlen] -> ShowS

Show (Blake2b bitlen)

Defined in Crypto.Hash.Blake2

Methods

showsPrec :: Int -> Blake2b bitlen -> ShowS

show :: Blake2b bitlen -> String

showList :: [Blake2b bitlen] -> ShowS

Show (Blake2sp bitlen)

Defined in Crypto.Hash.Blake2

Methods

showsPrec :: Int -> Blake2sp bitlen -> ShowS

show :: Blake2sp bitlen -> String

showList :: [Blake2sp bitlen] -> ShowS

Show (Blake2bp bitlen)

Defined in Crypto.Hash.Blake2

Methods

showsPrec :: Int -> Blake2bp bitlen -> ShowS

show :: Blake2bp bitlen -> String

showList :: [Blake2bp bitlen] -> ShowS

Show (SHAKE128 bitlen)

Defined in Crypto.Hash.SHAKE

Methods

showsPrec :: Int -> SHAKE128 bitlen -> ShowS

show :: SHAKE128 bitlen -> String

showList :: [SHAKE128 bitlen] -> ShowS

Show (SHAKE256 bitlen)

Defined in Crypto.Hash.SHAKE

Methods

showsPrec :: Int -> SHAKE256 bitlen -> ShowS

show :: SHAKE256 bitlen -> String

showList :: [SHAKE256 bitlen] -> ShowS

Show (Digest a)

Defined in Crypto.Hash.Types

Methods

showsPrec :: Int -> Digest a -> ShowS

show :: Digest a -> String

showList :: [Digest a] -> ShowS

Show a => Show (Hashed a)

Defined in Data.Hashable.Class

Methods

showsPrec :: Int -> Hashed a -> ShowS

show :: Hashed a -> String

showList :: [Hashed a] -> ShowS

Show (Symbolic a)

Defined in Hedgehog.Internal.State

Methods

showsPrec :: Int -> Symbolic a -> ShowS

show :: Symbolic a -> String

showList :: [Symbolic a] -> ShowS

Show a => Show (Concrete a)

Defined in Hedgehog.Internal.State

Methods

showsPrec :: Int -> Concrete a -> ShowS

show :: Concrete a -> String

showList :: [Concrete a] -> ShowS

Show a => Show (Label a)

Defined in Hedgehog.Internal.Property

Methods

showsPrec :: Int -> Label a -> ShowS

show :: Label a -> String

showList :: [Label a] -> ShowS

Show a => Show (Coverage a)

Defined in Hedgehog.Internal.Property

Methods

showsPrec :: Int -> Coverage a -> ShowS

show :: Coverage a -> String

showList :: [Coverage a] -> ShowS

Show (Opaque a)

Defined in Hedgehog.Internal.Opaque

Methods

showsPrec :: Int -> Opaque a -> ShowS

show :: Opaque a -> String

showList :: [Opaque a] -> ShowS

(Show a, Prim a) => Show (Vector a)

Defined in Data.Vector.Primitive

Methods

showsPrec :: Int -> Vector a -> ShowS

show :: Vector a -> String

showList :: [Vector a] -> ShowS

(Show a, Storable a) => Show (Vector a)

Defined in Data.Vector.Storable

Methods

showsPrec :: Int -> Vector a -> ShowS

show :: Vector a -> String

showList :: [Vector a] -> ShowS

Show a => Show (HashSet a)

Defined in Data.HashSet.Internal

Methods

showsPrec :: Int -> HashSet a -> ShowS

show :: HashSet a -> String

showList :: [HashSet a] -> ShowS

Show a => Show (Vector a)

Defined in Data.Vector

Methods

showsPrec :: Int -> Vector a -> ShowS

show :: Vector a -> String

showList :: [Vector a] -> ShowS

Show (Option a)

Defined in Options.Applicative.Types

Methods

showsPrec :: Int -> Option a -> ShowS

show :: Option a -> String

showList :: [Option a] -> ShowS

Show h => Show (ParserFailure h)

Defined in Options.Applicative.Types

Methods

showsPrec :: Int -> ParserFailure h -> ShowS

show :: ParserFailure h -> String

showList :: [ParserFailure h] -> ShowS

Show a => Show (ParserResult a)

Defined in Options.Applicative.Types

Methods

showsPrec :: Int -> ParserResult a -> ShowS

show :: ParserResult a -> String

showList :: [ParserResult a] -> ShowS

Show a => Show (OptTree a)

Defined in Options.Applicative.Types

Methods

showsPrec :: Int -> OptTree a -> ShowS

show :: OptTree a -> String

showList :: [OptTree a] -> ShowS

Show (Doc a)

Defined in Text.PrettyPrint.Annotated.HughesPJ

Methods

showsPrec :: Int -> Doc a -> ShowS

show :: Doc a -> String

showList :: [Doc a] -> ShowS

Show a => Show (AnnotDetails a)

Defined in Text.PrettyPrint.Annotated.HughesPJ

Methods

showsPrec :: Int -> AnnotDetails a -> ShowS

show :: AnnotDetails a -> String

showList :: [AnnotDetails a] -> ShowS

Show a => Show (Span a)

Defined in Text.PrettyPrint.Annotated.HughesPJ

Methods

showsPrec :: Int -> Span a -> ShowS

show :: Span a -> String

showList :: [Span a] -> ShowS

Show (Doc ann)

(show doc) prettyprints document doc with defaultLayoutOptions, ignoring all annotations.

Defined in Data.Text.Prettyprint.Doc.Internal

Methods

showsPrec :: Int -> Doc ann -> ShowS

show :: Doc ann -> String

showList :: [Doc ann] -> ShowS

Show ann => Show (SimpleDocStream ann)

Defined in Data.Text.Prettyprint.Doc.Internal

Methods

showsPrec :: Int -> SimpleDocStream ann -> ShowS

show :: SimpleDocStream ann -> String

showList :: [SimpleDocStream ann] -> ShowS

(Show a, Prim a) => Show (PrimArray a)

Since: primitive-0.6.4.0

Defined in Data.Primitive.PrimArray

Methods

showsPrec :: Int -> PrimArray a -> ShowS

show :: PrimArray a -> String

showList :: [PrimArray a] -> ShowS

Show a => Show (SmallArray a)

Defined in Data.Primitive.SmallArray

Methods

showsPrec :: Int -> SmallArray a -> ShowS

show :: SmallArray a -> String

showList :: [SmallArray a] -> ShowS

Show a => Show (Array a)

Defined in Data.Primitive.Array

Methods

showsPrec :: Int -> Array a -> ShowS

show :: Array a -> String

showList :: [Array a] -> ShowS

Show a => Show (Window a)

Defined in System.Console.Terminal.Common

Methods

showsPrec :: Int -> Window a -> ShowS

show :: Window a -> String

showList :: [Window a] -> ShowS

Show (Doc a)

Defined in Text.PrettyPrint.Annotated.WL

Methods

showsPrec :: Int -> Doc a -> ShowS

show :: Doc a -> String

showList :: [Doc a] -> ShowS

Show (Any sh)

Defined in Data.Array.Accelerate.Sugar.Shape

Methods

showsPrec :: Int -> Any sh -> ShowS

show :: Any sh -> String

showList :: [Any sh] -> ShowS

Elt e => Show (Exp e)

Defined in Data.Array.Accelerate.Pretty

Methods

showsPrec :: Int -> Exp e -> ShowS

show :: Exp e -> String

showList :: [Exp e] -> ShowS

Arrays arrs => Show (Acc arrs)

Defined in Data.Array.Accelerate.Pretty

Methods

showsPrec :: Int -> Acc arrs -> ShowS

show :: Acc arrs -> String

showList :: [Acc arrs] -> ShowS

Function (Exp a -> f) => Show (Exp a -> f)

Defined in Data.Array.Accelerate.Pretty

Methods

showsPrec :: Int -> (Exp a -> f) -> ShowS

show :: (Exp a -> f) -> String

showList :: [Exp a -> f] -> ShowS

Afunction (Acc a -> f) => Show (Acc a -> f)

Defined in Data.Array.Accelerate.Pretty

Methods

showsPrec :: Int -> (Acc a -> f) -> ShowS

show :: (Acc a -> f) -> String

showList :: [Acc a -> f] -> ShowS

(Show a, Show b) => Show (Either a b)

Since: base-3.0

Defined in Data.Either

Methods

showsPrec :: Int -> Either a b -> ShowS

show :: Either a b -> String

showList :: [Either a b] -> ShowS

Show (V1 p)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

showsPrec :: Int -> V1 p -> ShowS

show :: V1 p -> String

showList :: [V1 p] -> ShowS

Show (U1 p)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

showsPrec :: Int -> U1 p -> ShowS

show :: U1 p -> String

showList :: [U1 p] -> ShowS

Show (TypeRep a)

Defined in Data.Typeable.Internal

Methods

showsPrec :: Int -> TypeRep a -> ShowS

show :: TypeRep a -> String

showList :: [TypeRep a] -> ShowS

(Show a, Show b) => Show (a, b)

Since: base-2.1

Defined in GHC.Show

Methods

showsPrec :: Int -> (a, b) -> ShowS

show :: (a, b) -> String

showList :: [(a, b)] -> ShowS

Show (ST s a)

Since: base-2.1

Defined in GHC.ST

Methods

showsPrec :: Int -> ST s a -> ShowS

show :: ST s a -> String

showList :: [ST s a] -> ShowS

(Ix a, Show a, Show b) => Show (Array a b)

Since: base-2.1

Defined in GHC.Arr

Methods

showsPrec :: Int -> Array a b -> ShowS

show :: Array a b -> String

showList :: [Array a b] -> ShowS

HasResolution a => Show (Fixed a)

Since: base-2.1

Defined in Data.Fixed

Methods

showsPrec :: Int -> Fixed a -> ShowS

show :: Fixed a -> String

showList :: [Fixed a] -> ShowS

(Show a, Show b) => Show (Arg a b)

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

showsPrec :: Int -> Arg a b -> ShowS

show :: Arg a b -> String

showList :: [Arg a b] -> ShowS

Show (Proxy s)

Since: base-4.7.0.0

Defined in Data.Proxy

Methods

showsPrec :: Int -> Proxy s -> ShowS

show :: Proxy s -> String

showList :: [Proxy s] -> ShowS

(Show k, Show a) => Show (Map k a)

Defined in Data.Map.Internal

Methods

showsPrec :: Int -> Map k a -> ShowS

show :: Map k a -> String

showList :: [Map k a] -> ShowS

(Show1 m, Show a) => Show (MaybeT m a)

Defined in Control.Monad.Trans.Maybe

Methods

showsPrec :: Int -> MaybeT m a -> ShowS

show :: MaybeT m a -> String

showList :: [MaybeT m a] -> ShowS

(Show1 f, Show a) => Show (Cofree f a)

Defined in Control.Comonad.Cofree

Methods

showsPrec :: Int -> Cofree f a -> ShowS

show :: Cofree f a -> String

showList :: [Cofree f a] -> ShowS

(Show1 f, Show a) => Show (Free f a)

Defined in Control.Monad.Free

Methods

showsPrec :: Int -> Free f a -> ShowS

show :: Free f a -> String

showList :: [Free f a] -> ShowS

(Show a, Show1 v) => Show (Var a v)

Defined in Hedgehog.Internal.State

Methods

showsPrec :: Int -> Var a v -> ShowS

show :: Var a v -> String

showList :: [Var a v] -> ShowS

Show (Action m state)

Defined in Hedgehog.Internal.State

Methods

showsPrec :: Int -> Action m state -> ShowS

show :: Action m state -> String

showList :: [Action m state] -> ShowS

Show (Sequential m state)

Defined in Hedgehog.Internal.State

Methods

showsPrec :: Int -> Sequential m state -> ShowS

show :: Sequential m state -> String

showList :: [Sequential m state] -> ShowS

Show (Parallel m state)

Defined in Hedgehog.Internal.State

Methods

showsPrec :: Int -> Parallel m state -> ShowS

show :: Parallel m state -> String

showList :: [Parallel m state] -> ShowS

(Show1 m, Show a) => Show (TreeT m a)

Defined in Hedgehog.Internal.Tree

Methods

showsPrec :: Int -> TreeT m a -> ShowS

show :: TreeT m a -> String

showList :: [TreeT m a] -> ShowS

(Show1 m, Show a) => Show (NodeT m a)

Defined in Hedgehog.Internal.Tree

Methods

showsPrec :: Int -> NodeT m a -> ShowS

show :: NodeT m a -> String

showList :: [NodeT m a] -> ShowS

Show (f a) => Show (Yoneda f a)

Defined in Data.Functor.Yoneda

Methods

showsPrec :: Int -> Yoneda f a -> ShowS

show :: Yoneda f a -> String

showList :: [Yoneda f a] -> ShowS

(Show k, Show v) => Show (HashMap k v)

Defined in Data.HashMap.Internal

Methods

showsPrec :: Int -> HashMap k v -> ShowS

show :: HashMap k v -> String

showList :: [HashMap k v] -> ShowS

(Show i, Show a) => Show (Level i a)

Defined in Control.Lens.Internal.Level

Methods

showsPrec :: Int -> Level i a -> ShowS

show :: Level i a -> String

showList :: [Level i a] -> ShowS

(Show1 m, Show a) => Show (ListT m a)

Defined in Control.Monad.Trans.List

Methods

showsPrec :: Int -> ListT m a -> ShowS

show :: ListT m a -> String

showList :: [ListT m a] -> ShowS

(Show a, Prim a, KnownNat n) => Show (Vec n a)

Defined in Data.Primitive.Vec

Methods

showsPrec :: Int -> Vec n a -> ShowS

show :: Vec n a -> String

showList :: [Vec n a] -> ShowS

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

Defined in Data.Array.Accelerate.Sugar.Shape

Methods

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

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

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

(Shape sh, Elt e, Show e) => Show (Array sh e)

Defined in Data.Array.Accelerate.Sugar.Array

Methods

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

show :: Array sh e -> String

showList :: [Array sh e] -> ShowS

Show (f p) => Show (Rec1 f p)

Since: base-4.7.0.0

Defined in GHC.Generics

Methods

showsPrec :: Int -> Rec1 f p -> ShowS

show :: Rec1 f p -> String

showList :: [Rec1 f p] -> ShowS

Show (URec Char p)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

showsPrec :: Int -> URec Char p -> ShowS

show :: URec Char p -> String

showList :: [URec Char p] -> ShowS

Show (URec Double p)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

showsPrec :: Int -> URec Double p -> ShowS

show :: URec Double p -> String

showList :: [URec Double p] -> ShowS

Show (URec Float p)

Defined in GHC.Generics

Methods

showsPrec :: Int -> URec Float p -> ShowS

show :: URec Float p -> String

showList :: [URec Float p] -> ShowS

Show (URec Int p)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

showsPrec :: Int -> URec Int p -> ShowS

show :: URec Int p -> String

showList :: [URec Int p] -> ShowS

Show (URec Word p)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

showsPrec :: Int -> URec Word p -> ShowS

show :: URec Word p -> String

showList :: [URec Word p] -> ShowS

(Show a, Show b, Show c) => Show (a, b, c)

Since: base-2.1

Defined in GHC.Show

Methods

showsPrec :: Int -> (a, b, c) -> ShowS

show :: (a, b, c) -> String

showList :: [(a, b, c)] -> ShowS

Show a => Show (Const a b)

This instance would be equivalent to the derived instances of the Const newtype if the getConst field were removed

Since: base-4.8.0.0

Defined in Data.Functor.Const

Methods

showsPrec :: Int -> Const a b -> ShowS

show :: Const a b -> String

showList :: [Const a b] -> ShowS

Show (f a) => Show (Ap f a)

Since: base-4.12.0.0

Defined in Data.Monoid

Methods

showsPrec :: Int -> Ap f a -> ShowS

show :: Ap f a -> String

showList :: [Ap f a] -> ShowS

Show (f a) => Show (Alt f a)

Since: base-4.8.0.0

Defined in Data.Semigroup.Internal

Methods

showsPrec :: Int -> Alt f a -> ShowS

show :: Alt f a -> String

showList :: [Alt f a] -> ShowS

Show (a :~: b)

Since: base-4.7.0.0

Defined in Data.Type.Equality

Methods

showsPrec :: Int -> (a :~: b) -> ShowS

show :: (a :~: b) -> String

showList :: [a :~: b] -> ShowS

Show (p a a) => Show (Join p a)

Defined in Data.Bifunctor.Join

Methods

showsPrec :: Int -> Join p a -> ShowS

show :: Join p a -> String

showList :: [Join p a] -> ShowS

Show (p (Fix p a) a) => Show (Fix p a)

Defined in Data.Bifunctor.Fix

Methods

showsPrec :: Int -> Fix p a -> ShowS

show :: Fix p a -> String

showList :: [Fix p a] -> ShowS

(Show1 f, Show a) => Show (IdentityT f a)

Defined in Control.Monad.Trans.Identity

Methods

showsPrec :: Int -> IdentityT f a -> ShowS

show :: IdentityT f a -> String

showList :: [IdentityT f a] -> ShowS

(Show e, Show1 m, Show a) => Show (ExceptT e m a)

Defined in Control.Monad.Trans.Except

Methods

showsPrec :: Int -> ExceptT e m a -> ShowS

show :: ExceptT e m a -> String

showList :: [ExceptT e m a] -> ShowS

(Show a, Show (f b)) => Show (FreeF f a b)

Defined in Control.Monad.Trans.Free

Methods

showsPrec :: Int -> FreeF f a b -> ShowS

show :: FreeF f a b -> String

showList :: [FreeF f a b] -> ShowS

(Show1 f, Show1 m, Show a) => Show (FreeT f m a)

Defined in Control.Monad.Trans.Free

Methods

showsPrec :: Int -> FreeT f m a -> ShowS

show :: FreeT f m a -> String

showList :: [FreeT f m a] -> ShowS

(Show a, Show (f b)) => Show (CofreeF f a b)

Defined in Control.Comonad.Trans.Cofree

Methods

showsPrec :: Int -> CofreeF f a b -> ShowS

show :: CofreeF f a b -> String

showList :: [CofreeF f a b] -> ShowS

Show (w (CofreeF f a (CofreeT f w a))) => Show (CofreeT f w a)

Defined in Control.Comonad.Trans.Cofree

Methods

showsPrec :: Int -> CofreeT f w a -> ShowS

show :: CofreeT f w a -> String

showList :: [CofreeT f w a] -> ShowS

Show (HashTable s k v)

Defined in Data.HashTable.ST.Cuckoo

Methods

showsPrec :: Int -> HashTable s k v -> ShowS

show :: HashTable s k v -> String

showList :: [HashTable s k v] -> ShowS

Show (HashTable s k v)

Defined in Data.HashTable.ST.Basic

Methods

showsPrec :: Int -> HashTable s k v -> ShowS

show :: HashTable s k v -> String

showList :: [HashTable s k v] -> ShowS

(Show e, Show1 m, Show a) => Show (ErrorT e m a)

Defined in Control.Monad.Trans.Error

Methods

showsPrec :: Int -> ErrorT e m a -> ShowS

show :: ErrorT e m a -> String

showList :: [ErrorT e m a] -> ShowS

Show b => Show (Tagged s b)

Defined in Data.Tagged

Methods

showsPrec :: Int -> Tagged s b -> ShowS

show :: Tagged s b -> String

showList :: [Tagged s b] -> ShowS

(Show w, Show1 m, Show a) => Show (WriterT w m a)

Defined in Control.Monad.Trans.Writer.Lazy

Methods

showsPrec :: Int -> WriterT w m a -> ShowS

show :: WriterT w m a -> String

showList :: [WriterT w m a] -> ShowS

(Show w, Show1 m, Show a) => Show (WriterT w m a)

Defined in Control.Monad.Trans.Writer.Strict

Methods

showsPrec :: Int -> WriterT w m a -> ShowS

show :: WriterT w m a -> String

showList :: [WriterT w m a] -> ShowS

Show c => Show (K1 i c p)

Since: base-4.7.0.0

Defined in GHC.Generics

Methods

showsPrec :: Int -> K1 i c p -> ShowS

show :: K1 i c p -> String

showList :: [K1 i c p] -> ShowS

(Show (f p), Show (g p)) => Show ((f :+: g) p)

Since: base-4.7.0.0

Defined in GHC.Generics

Methods

showsPrec :: Int -> (f :+: g) p -> ShowS

show :: (f :+: g) p -> String

showList :: [(f :+: g) p] -> ShowS

(Show (f p), Show (g p)) => Show ((f :*: g) p)

Since: base-4.7.0.0

Defined in GHC.Generics

Methods

showsPrec :: Int -> (f :*: g) p -> ShowS

show :: (f :*: g) p -> String

showList :: [(f :*: g) p] -> ShowS

(Show a, Show b, Show c, Show d) => Show (a, b, c, d)

Since: base-2.1

Defined in GHC.Show

Methods

showsPrec :: Int -> (a, b, c, d) -> ShowS

show :: (a, b, c, d) -> String

showList :: [(a, b, c, d)] -> ShowS

(Show1 f, Show1 g, Show a) => Show (Product f g a)

Since: base-4.9.0.0

Defined in Data.Functor.Product

Methods

showsPrec :: Int -> Product f g a -> ShowS

show :: Product f g a -> String

showList :: [Product f g a] -> ShowS

(Show1 f, Show1 g, Show a) => Show (Sum f g a)

Since: base-4.9.0.0

Defined in Data.Functor.Sum

Methods

showsPrec :: Int -> Sum f g a -> ShowS

show :: Sum f g a -> String

showList :: [Sum f g a] -> ShowS

Show (a :~~: b)

Since: base-4.10.0.0

Defined in Data.Type.Equality

Methods

showsPrec :: Int -> (a :~~: b) -> ShowS

show :: (a :~~: b) -> String

showList :: [a :~~: b] -> ShowS

(Show i, Show a) => Show (Magma i t b a)

Defined in Control.Lens.Internal.Magma

Methods

showsPrec :: Int -> Magma i t b a -> ShowS

show :: Magma i t b a -> String

showList :: [Magma i t b a] -> ShowS

Show (f p) => Show (M1 i c f p)

Since: base-4.7.0.0

Defined in GHC.Generics

Methods

showsPrec :: Int -> M1 i c f p -> ShowS

show :: M1 i c f p -> String

showList :: [M1 i c f p] -> ShowS

Show (f (g p)) => Show ((f :.: g) p)

Since: base-4.7.0.0

Defined in GHC.Generics

Methods

showsPrec :: Int -> (f :.: g) p -> ShowS

show :: (f :.: g) p -> String

showList :: [(f :.: g) p] -> ShowS

(Show a, Show b, Show c, Show d, Show e) => Show (a, b, c, d, e)

Since: base-2.1

Defined in GHC.Show

Methods

showsPrec :: Int -> (a, b, c, d, e) -> ShowS

show :: (a, b, c, d, e) -> String

showList :: [(a, b, c, d, e)] -> ShowS

(Show1 f, Show1 g, Show a) => Show (Compose f g a)

Since: base-4.9.0.0

Defined in Data.Functor.Compose

Methods

showsPrec :: Int -> Compose f g a -> ShowS

show :: Compose f g a -> String

showList :: [Compose f g a] -> ShowS

Show (p a b) => Show (WrappedBifunctor p a b)

Defined in Data.Bifunctor.Wrapped

Methods

showsPrec :: Int -> WrappedBifunctor p a b -> ShowS

show :: WrappedBifunctor p a b -> String

showList :: [WrappedBifunctor p a b] -> ShowS

Show (g b) => Show (Joker g a b)

Defined in Data.Bifunctor.Joker

Methods

showsPrec :: Int -> Joker g a b -> ShowS

show :: Joker g a b -> String

showList :: [Joker g a b] -> ShowS

Show (p b a) => Show (Flip p a b)

Defined in Data.Bifunctor.Flip

Methods

showsPrec :: Int -> Flip p a b -> ShowS

show :: Flip p a b -> String

showList :: [Flip p a b] -> ShowS

Show (f a) => Show (Clown f a b)

Defined in Data.Bifunctor.Clown

Methods

showsPrec :: Int -> Clown f a b -> ShowS

show :: Clown f a b -> String

showList :: [Clown f a b] -> ShowS

(Show a, Show b, Show c, Show d, Show e, Show f) => Show (a, b, c, d, e, f)

Since: base-2.1

Defined in GHC.Show

Methods

showsPrec :: Int -> (a, b, c, d, e, f) -> ShowS

show :: (a, b, c, d, e, f) -> String

showList :: [(a, b, c, d, e, f)] -> ShowS

(Show (p a b), Show (q a b)) => Show (Sum p q a b)

Defined in Data.Bifunctor.Sum

Methods

showsPrec :: Int -> Sum p q a b -> ShowS

show :: Sum p q a b -> String

showList :: [Sum p q a b] -> ShowS

(Show (f a b), Show (g a b)) => Show (Product f g a b)

Defined in Data.Bifunctor.Product

Methods

showsPrec :: Int -> Product f g a b -> ShowS

show :: Product f g a b -> String

showList :: [Product f g a b] -> ShowS

(Show a, Show b, Show c, Show d, Show e, Show f, Show g) => Show (a, b, c, d, e, f, g)

Since: base-2.1

Defined in GHC.Show

Methods

showsPrec :: Int -> (a, b, c, d, e, f, g) -> ShowS

show :: (a, b, c, d, e, f, g) -> String

showList :: [(a, b, c, d, e, f, g)] -> ShowS

Show (f (p a b)) => Show (Tannen f p a b)

Defined in Data.Bifunctor.Tannen

Methods

showsPrec :: Int -> Tannen f p a b -> ShowS

show :: Tannen f p a b -> String

showList :: [Tannen f p a b] -> ShowS

(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h) => Show (a, b, c, d, e, f, g, h)

Since: base-2.1

Defined in GHC.Show

Methods

showsPrec :: Int -> (a, b, c, d, e, f, g, h) -> ShowS

show :: (a, b, c, d, e, f, g, h) -> String

showList :: [(a, b, c, d, e, f, g, h)] -> ShowS

(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i) => Show (a, b, c, d, e, f, g, h, i)

Since: base-2.1

Defined in GHC.Show

Methods

showsPrec :: Int -> (a, b, c, d, e, f, g, h, i) -> ShowS

show :: (a, b, c, d, e, f, g, h, i) -> String

showList :: [(a, b, c, d, e, f, g, h, i)] -> ShowS

Show (p (f a) (g b)) => Show (Biff p f g a b)

Defined in Data.Bifunctor.Biff

Methods

showsPrec :: Int -> Biff p f g a b -> ShowS

show :: Biff p f g a b -> String

showList :: [Biff p f g a b] -> ShowS

(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j) => Show (a, b, c, d, e, f, g, h, i, j)

Since: base-2.1

Defined in GHC.Show

Methods

showsPrec :: Int -> (a, b, c, d, e, f, g, h, i, j) -> ShowS

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

showList :: [(a, b, c, d, e, f, g, h, i, j)] -> ShowS

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

Since: base-2.1

Defined in GHC.Show

Methods

showsPrec :: Int -> (a, b, c, d, e, f, g, h, i, j, k) -> ShowS

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

showList :: [(a, b, c, d, e, f, g, h, i, j, k)] -> ShowS

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

Since: base-2.1

Defined in GHC.Show

Methods

showsPrec :: Int -> (a, b, c, d, e, f, g, h, i, j, k, l) -> ShowS

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

showList :: [(a, b, c, d, e, f, g, h, i, j, k, l)] -> ShowS

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

Since: base-2.1

Defined in GHC.Show

Methods

showsPrec :: Int -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> ShowS

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

showList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m)] -> ShowS

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

Since: base-2.1

Defined in GHC.Show

Methods

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

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

showList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m, n)] -> ShowS

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

Since: base-2.1

Defined in GHC.Show

Methods

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

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

showList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)] -> ShowS

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

Defined in Data.Array.Accelerate.Orphans

Methods

showsPrec :: Int -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) -> ShowS

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

showList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p)] -> ShowS

class Generic a

Representable types of kind *. This class is derivable in GHC with the DeriveGeneric flag on.

A Generic instance must satisfy the following laws:

from . to ≡ id
to . from ≡ id

Minimal complete definition

from, to

Instances

Generic Bool

Since: base-4.6.0.0

Defined in GHC.Generics

Associated Types

type Rep Bool :: Type -> Type

Methods

from :: Bool -> Rep Bool x

to :: Rep Bool x -> Bool

Generic Ordering

Since: base-4.6.0.0

Defined in GHC.Generics

Associated Types

type Rep Ordering :: Type -> Type

Methods

from :: Ordering -> Rep Ordering x

to :: Rep Ordering x -> Ordering

Generic Exp

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Exp :: Type -> Type

Methods

from :: Exp -> Rep Exp x

to :: Rep Exp x -> Exp

Generic Match

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Match :: Type -> Type

Methods

from :: Match -> Rep Match x

to :: Rep Match x -> Match

Generic Clause

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Clause :: Type -> Type

Methods

from :: Clause -> Rep Clause x

to :: Rep Clause x -> Clause

Generic Pat

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Pat :: Type -> Type

Methods

from :: Pat -> Rep Pat x

to :: Rep Pat x -> Pat

Generic Type

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Type :: Type -> Type

Methods

from :: Type -> Rep Type x

to :: Rep Type x -> Type

Generic Dec

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Dec :: Type -> Type

Methods

from :: Dec -> Rep Dec x

to :: Rep Dec x -> Dec

Generic Name

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Name :: Type -> Type

Methods

from :: Name -> Rep Name x

to :: Rep Name x -> Name

Generic FunDep

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep FunDep :: Type -> Type

Methods

from :: FunDep -> Rep FunDep x

to :: Rep FunDep x -> FunDep

Generic InjectivityAnn

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep InjectivityAnn :: Type -> Type

Methods

from :: InjectivityAnn -> Rep InjectivityAnn x

to :: Rep InjectivityAnn x -> InjectivityAnn

Generic Overlap

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Overlap :: Type -> Type

Methods

from :: Overlap -> Rep Overlap x

to :: Rep Overlap x -> Overlap

Generic ()

Since: base-4.6.0.0

Defined in GHC.Generics

Associated Types

type Rep () :: Type -> Type

Methods

from :: () -> Rep () x

to :: Rep () x -> ()

Generic Void

Since: base-4.8.0.0

Defined in Data.Void

Associated Types

type Rep Void :: Type -> Type

Methods

from :: Void -> Rep Void x

to :: Rep Void x -> Void

Generic Version

Since: base-4.9.0.0

Defined in Data.Version

Associated Types

type Rep Version :: Type -> Type

Methods

from :: Version -> Rep Version x

to :: Rep Version x -> Version

Generic ExitCode

Defined in GHC.IO.Exception

Associated Types

type Rep ExitCode :: Type -> Type

Methods

from :: ExitCode -> Rep ExitCode x

to :: Rep ExitCode x -> ExitCode

Generic All

Since: base-4.7.0.0

Defined in Data.Semigroup.Internal

Associated Types

type Rep All :: Type -> Type

Methods

from :: All -> Rep All x

to :: Rep All x -> All

Generic Any

Since: base-4.7.0.0

Defined in Data.Semigroup.Internal

Associated Types

type Rep Any :: Type -> Type

Methods

from :: Any -> Rep Any x

to :: Rep Any x -> Any

Generic Fixity

Since: base-4.7.0.0

Defined in GHC.Generics

Associated Types

type Rep Fixity :: Type -> Type

Methods

from :: Fixity -> Rep Fixity x

to :: Rep Fixity x -> Fixity

Generic Associativity

Since: base-4.7.0.0

Defined in GHC.Generics

Associated Types

type Rep Associativity :: Type -> Type

Methods

from :: Associativity -> Rep Associativity x

to :: Rep Associativity x -> Associativity

Generic SourceUnpackedness

Since: base-4.9.0.0

Defined in GHC.Generics

Associated Types

type Rep SourceUnpackedness :: Type -> Type

Methods

from :: SourceUnpackedness -> Rep SourceUnpackedness x

to :: Rep SourceUnpackedness x -> SourceUnpackedness

Generic SourceStrictness

Since: base-4.9.0.0

Defined in GHC.Generics

Associated Types

type Rep SourceStrictness :: Type -> Type

Methods

from :: SourceStrictness -> Rep SourceStrictness x

to :: Rep SourceStrictness x -> SourceStrictness

Generic DecidedStrictness

Since: base-4.9.0.0

Defined in GHC.Generics

Associated Types

type Rep DecidedStrictness :: Type -> Type

Methods

from :: DecidedStrictness -> Rep DecidedStrictness x

to :: Rep DecidedStrictness x -> DecidedStrictness

Generic Clock

Defined in System.Clock

Associated Types

type Rep Clock :: Type -> Type

Methods

from :: Clock -> Rep Clock x

to :: Rep Clock x -> Clock

Generic TimeSpec

Defined in System.Clock

Associated Types

type Rep TimeSpec :: Type -> Type

Methods

from :: TimeSpec -> Rep TimeSpec x

to :: Rep TimeSpec x -> TimeSpec

Generic Extension

Defined in GHC.LanguageExtensions.Type

Associated Types

type Rep Extension :: Type -> Type

Methods

from :: Extension -> Rep Extension x

to :: Rep Extension x -> Extension

Generic ForeignSrcLang

Defined in GHC.ForeignSrcLang.Type

Associated Types

type Rep ForeignSrcLang :: Type -> Type

Methods

from :: ForeignSrcLang -> Rep ForeignSrcLang x

to :: Rep ForeignSrcLang x -> ForeignSrcLang

Generic Half

Defined in Numeric.Half

Associated Types

type Rep Half :: Type -> Type

Methods

from :: Half -> Rep Half x

to :: Rep Half x -> Half

Generic RuleBndr

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep RuleBndr :: Type -> Type

Methods

from :: RuleBndr -> Rep RuleBndr x

to :: Rep RuleBndr x -> RuleBndr

Generic Phases

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Phases :: Type -> Type

Methods

from :: Phases -> Rep Phases x

to :: Rep Phases x -> Phases

Generic RuleMatch

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep RuleMatch :: Type -> Type

Methods

from :: RuleMatch -> Rep RuleMatch x

to :: Rep RuleMatch x -> RuleMatch

Generic Inline

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Inline :: Type -> Type

Methods

from :: Inline -> Rep Inline x

to :: Rep Inline x -> Inline

Generic Pragma

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Pragma :: Type -> Type

Methods

from :: Pragma -> Rep Pragma x

to :: Rep Pragma x -> Pragma

Generic DerivClause

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep DerivClause :: Type -> Type

Methods

from :: DerivClause -> Rep DerivClause x

to :: Rep DerivClause x -> DerivClause

Generic DerivStrategy

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep DerivStrategy :: Type -> Type

Methods

from :: DerivStrategy -> Rep DerivStrategy x

to :: Rep DerivStrategy x -> DerivStrategy

Generic TySynEqn

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep TySynEqn :: Type -> Type

Methods

from :: TySynEqn -> Rep TySynEqn x

to :: Rep TySynEqn x -> TySynEqn

Generic Fixity

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Fixity :: Type -> Type

Methods

from :: Fixity -> Rep Fixity x

to :: Rep Fixity x -> Fixity

Generic Info

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Info :: Type -> Type

Methods

from :: Info -> Rep Info x

to :: Rep Info x -> Info

Generic Con

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Con :: Type -> Type

Methods

from :: Con -> Rep Con x

to :: Rep Con x -> Con

Generic TyVarBndr

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep TyVarBndr :: Type -> Type

Methods

from :: TyVarBndr -> Rep TyVarBndr x

to :: Rep TyVarBndr x -> TyVarBndr

Generic Doc

Defined in Text.PrettyPrint.HughesPJ

Associated Types

type Rep Doc :: Type -> Type

Methods

from :: Doc -> Rep Doc x

to :: Rep Doc x -> Doc

Generic TextDetails

Defined in Text.PrettyPrint.Annotated.HughesPJ

Associated Types

type Rep TextDetails :: Type -> Type

Methods

from :: TextDetails -> Rep TextDetails x

to :: Rep TextDetails x -> TextDetails

Generic Style

Defined in Text.PrettyPrint.Annotated.HughesPJ

Associated Types

type Rep Style :: Type -> Type

Methods

from :: Style -> Rep Style x

to :: Rep Style x -> Style

Generic Mode

Defined in Text.PrettyPrint.Annotated.HughesPJ

Associated Types

type Rep Mode :: Type -> Type

Methods

from :: Mode -> Rep Mode x

to :: Rep Mode x -> Mode

Generic Outcome

Defined in Test.Tasty.Core

Associated Types

type Rep Outcome :: Type -> Type

Methods

from :: Outcome -> Rep Outcome x

to :: Rep Outcome x -> Outcome

Generic ModName

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep ModName :: Type -> Type

Methods

from :: ModName -> Rep ModName x

to :: Rep ModName x -> ModName

Generic PkgName

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep PkgName :: Type -> Type

Methods

from :: PkgName -> Rep PkgName x

to :: Rep PkgName x -> PkgName

Generic Module

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Module :: Type -> Type

Methods

from :: Module -> Rep Module x

to :: Rep Module x -> Module

Generic OccName

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep OccName :: Type -> Type

Methods

from :: OccName -> Rep OccName x

to :: Rep OccName x -> OccName

Generic NameFlavour

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep NameFlavour :: Type -> Type

Methods

from :: NameFlavour -> Rep NameFlavour x

to :: Rep NameFlavour x -> NameFlavour

Generic NameSpace

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep NameSpace :: Type -> Type

Methods

from :: NameSpace -> Rep NameSpace x

to :: Rep NameSpace x -> NameSpace

Generic Loc

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Loc :: Type -> Type

Methods

from :: Loc -> Rep Loc x

to :: Rep Loc x -> Loc

Generic ModuleInfo

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep ModuleInfo :: Type -> Type

Methods

from :: ModuleInfo -> Rep ModuleInfo x

to :: Rep ModuleInfo x -> ModuleInfo

Generic FixityDirection

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep FixityDirection :: Type -> Type

Methods

from :: FixityDirection -> Rep FixityDirection x

to :: Rep FixityDirection x -> FixityDirection

Generic Lit

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Lit :: Type -> Type

Methods

from :: Lit -> Rep Lit x

to :: Rep Lit x -> Lit

Generic Bytes

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Bytes :: Type -> Type

Methods

from :: Bytes -> Rep Bytes x

to :: Rep Bytes x -> Bytes

Generic Body

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Body :: Type -> Type

Methods

from :: Body -> Rep Body x

to :: Rep Body x -> Body

Generic Guard

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Guard :: Type -> Type

Methods

from :: Guard -> Rep Guard x

to :: Rep Guard x -> Guard

Generic Stmt

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Stmt :: Type -> Type

Methods

from :: Stmt -> Rep Stmt x

to :: Rep Stmt x -> Stmt

Generic Range

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Range :: Type -> Type

Methods

from :: Range -> Rep Range x

to :: Rep Range x -> Range

Generic TypeFamilyHead

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep TypeFamilyHead :: Type -> Type

Methods

from :: TypeFamilyHead -> Rep TypeFamilyHead x

to :: Rep TypeFamilyHead x -> TypeFamilyHead

Generic Foreign

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Foreign :: Type -> Type

Methods

from :: Foreign -> Rep Foreign x

to :: Rep Foreign x -> Foreign

Generic Callconv

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Callconv :: Type -> Type

Methods

from :: Callconv -> Rep Callconv x

to :: Rep Callconv x -> Callconv

Generic Safety

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Safety :: Type -> Type

Methods

from :: Safety -> Rep Safety x

to :: Rep Safety x -> Safety

Generic AnnTarget

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep AnnTarget :: Type -> Type

Methods

from :: AnnTarget -> Rep AnnTarget x

to :: Rep AnnTarget x -> AnnTarget

Generic SourceUnpackedness

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep SourceUnpackedness :: Type -> Type

Methods

from :: SourceUnpackedness -> Rep SourceUnpackedness x

to :: Rep SourceUnpackedness x -> SourceUnpackedness

Generic SourceStrictness

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep SourceStrictness :: Type -> Type

Methods

from :: SourceStrictness -> Rep SourceStrictness x

to :: Rep SourceStrictness x -> SourceStrictness

Generic DecidedStrictness

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep DecidedStrictness :: Type -> Type

Methods

from :: DecidedStrictness -> Rep DecidedStrictness x

to :: Rep DecidedStrictness x -> DecidedStrictness

Generic Bang

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Bang :: Type -> Type

Methods

from :: Bang -> Rep Bang x

to :: Rep Bang x -> Bang

Generic PatSynDir

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep PatSynDir :: Type -> Type

Methods

from :: PatSynDir -> Rep PatSynDir x

to :: Rep PatSynDir x -> PatSynDir

Generic PatSynArgs

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep PatSynArgs :: Type -> Type

Methods

from :: PatSynArgs -> Rep PatSynArgs x

to :: Rep PatSynArgs x -> PatSynArgs

Generic FamilyResultSig

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep FamilyResultSig :: Type -> Type

Methods

from :: FamilyResultSig -> Rep FamilyResultSig x

to :: Rep FamilyResultSig x -> FamilyResultSig

Generic TyLit

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep TyLit :: Type -> Type

Methods

from :: TyLit -> Rep TyLit x

to :: Rep TyLit x -> TyLit

Generic Role

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Role :: Type -> Type

Methods

from :: Role -> Rep Role x

to :: Rep Role x -> Role

Generic AnnLookup

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep AnnLookup :: Type -> Type

Methods

from :: AnnLookup -> Rep AnnLookup x

to :: Rep AnnLookup x -> AnnLookup

Generic DatatypeInfo

Defined in Language.Haskell.TH.Datatype

Associated Types

type Rep DatatypeInfo :: Type -> Type

Methods

from :: DatatypeInfo -> Rep DatatypeInfo x

to :: Rep DatatypeInfo x -> DatatypeInfo

Generic DatatypeVariant

Defined in Language.Haskell.TH.Datatype

Associated Types

type Rep DatatypeVariant :: Type -> Type

Methods

from :: DatatypeVariant -> Rep DatatypeVariant x

to :: Rep DatatypeVariant x -> DatatypeVariant

Generic ConstructorInfo

Defined in Language.Haskell.TH.Datatype

Associated Types

type Rep ConstructorInfo :: Type -> Type

Methods

from :: ConstructorInfo -> Rep ConstructorInfo x

to :: Rep ConstructorInfo x -> ConstructorInfo

Generic ConstructorVariant

Defined in Language.Haskell.TH.Datatype

Associated Types

type Rep ConstructorVariant :: Type -> Type

Methods

from :: ConstructorVariant -> Rep ConstructorVariant x

to :: Rep ConstructorVariant x -> ConstructorVariant

Generic FieldStrictness

Defined in Language.Haskell.TH.Datatype

Associated Types

type Rep FieldStrictness :: Type -> Type

Methods

from :: FieldStrictness -> Rep FieldStrictness x

to :: Rep FieldStrictness x -> FieldStrictness

Generic Unpackedness

Defined in Language.Haskell.TH.Datatype

Associated Types

type Rep Unpackedness :: Type -> Type

Methods

from :: Unpackedness -> Rep Unpackedness x

to :: Rep Unpackedness x -> Unpackedness

Generic Strictness

Defined in Language.Haskell.TH.Datatype

Associated Types

type Rep Strictness :: Type -> Type

Methods

from :: Strictness -> Rep Strictness x

to :: Rep Strictness x -> Strictness

Generic All

Defined in Data.Array.Accelerate.Sugar.Shape

Associated Types

type Rep All :: Type -> Type

Methods

from :: All -> Rep All x

to :: Rep All x -> All

Generic Z

Defined in Data.Array.Accelerate.Sugar.Shape

Associated Types

type Rep Z :: Type -> Type

Methods

from :: Z -> Rep Z x

to :: Rep Z x -> Z

Generic [a]

Since: base-4.6.0.0

Defined in GHC.Generics

Associated Types

type Rep [a] :: Type -> Type

Methods

from :: [a] -> Rep [a] x

to :: Rep [a] x -> [a]

Generic (Maybe a)

Since: base-4.6.0.0

Defined in GHC.Generics

Associated Types

type Rep (Maybe a) :: Type -> Type

Methods

from :: Maybe a -> Rep (Maybe a) x

to :: Rep (Maybe a) x -> Maybe a

Generic (Ratio a)

Defined in Data.Array.Accelerate.Orphans

Associated Types

type Rep (Ratio a) :: Type -> Type

Methods

from :: Ratio a -> Rep (Ratio a) x

to :: Rep (Ratio a) x -> Ratio a

Generic (Par1 p)

Since: base-4.7.0.0

Defined in GHC.Generics

Associated Types

type Rep (Par1 p) :: Type -> Type

Methods

from :: Par1 p -> Rep (Par1 p) x

to :: Rep (Par1 p) x -> Par1 p

Generic (Complex a)

Since: base-4.9.0.0

Defined in Data.Complex

Associated Types

type Rep (Complex a) :: Type -> Type

Methods

from :: Complex a -> Rep (Complex a) x

to :: Rep (Complex a) x -> Complex a

Generic (Min a)

Since: base-4.9.0.0

Defined in Data.Semigroup

Associated Types

type Rep (Min a) :: Type -> Type

Methods

from :: Min a -> Rep (Min a) x

to :: Rep (Min a) x -> Min a

Generic (Max a)

Since: base-4.9.0.0

Defined in Data.Semigroup

Associated Types

type Rep (Max a) :: Type -> Type

Methods

from :: Max a -> Rep (Max a) x

to :: Rep (Max a) x -> Max a

Generic (First a)

Since: base-4.9.0.0

Defined in Data.Semigroup

Associated Types

type Rep (First a) :: Type -> Type

Methods

from :: First a -> Rep (First a) x

to :: Rep (First a) x -> First a

Generic (Last a)

Since: base-4.9.0.0

Defined in Data.Semigroup

Associated Types

type Rep (Last a) :: Type -> Type

Methods

from :: Last a -> Rep (Last a) x

to :: Rep (Last a) x -> Last a

Generic (WrappedMonoid m)

Since: base-4.9.0.0

Defined in Data.Semigroup

Associated Types

type Rep (WrappedMonoid m) :: Type -> Type

Methods

from :: WrappedMonoid m -> Rep (WrappedMonoid m) x

to :: Rep (WrappedMonoid m) x -> WrappedMonoid m

Generic (Option a)

Since: base-4.9.0.0

Defined in Data.Semigroup

Associated Types

type Rep (Option a) :: Type -> Type

Methods

from :: Option a -> Rep (Option a) x

to :: Rep (Option a) x -> Option a

Generic (ZipList a)

Since: base-4.7.0.0

Defined in Control.Applicative

Associated Types

type Rep (ZipList a) :: Type -> Type

Methods

from :: ZipList a -> Rep (ZipList a) x

to :: Rep (ZipList a) x -> ZipList a

Generic (Identity a)

Since: base-4.8.0.0

Defined in Data.Functor.Identity

Associated Types

type Rep (Identity a) :: Type -> Type

Methods

from :: Identity a -> Rep (Identity a) x

to :: Rep (Identity a) x -> Identity a

Generic (First a)

Since: base-4.7.0.0

Defined in Data.Monoid

Associated Types

type Rep (First a) :: Type -> Type

Methods

from :: First a -> Rep (First a) x

to :: Rep (First a) x -> First a

Generic (Last a)

Since: base-4.7.0.0

Defined in Data.Monoid

Associated Types

type Rep (Last a) :: Type -> Type

Methods

from :: Last a -> Rep (Last a) x

to :: Rep (Last a) x -> Last a

Generic (Dual a)

Since: base-4.7.0.0

Defined in Data.Semigroup.Internal

Associated Types

type Rep (Dual a) :: Type -> Type

Methods

from :: Dual a -> Rep (Dual a) x

to :: Rep (Dual a) x -> Dual a

Generic (Endo a)

Since: base-4.7.0.0

Defined in Data.Semigroup.Internal

Associated Types

type Rep (Endo a) :: Type -> Type

Methods

from :: Endo a -> Rep (Endo a) x

to :: Rep (Endo a) x -> Endo a

Generic (Sum a)

Since: base-4.7.0.0

Defined in Data.Semigroup.Internal

Associated Types

type Rep (Sum a) :: Type -> Type

Methods

from :: Sum a -> Rep (Sum a) x

to :: Rep (Sum a) x -> Sum a

Generic (Product a)

Since: base-4.7.0.0

Defined in Data.Semigroup.Internal

Associated Types

type Rep (Product a) :: Type -> Type

Methods

from :: Product a -> Rep (Product a) x

to :: Rep (Product a) x -> Product a

Generic (Down a)

Since: base-4.12.0.0

Defined in GHC.Generics

Associated Types

type Rep (Down a) :: Type -> Type

Methods

from :: Down a -> Rep (Down a) x

to :: Rep (Down a) x -> Down a

Generic (NonEmpty a)

Since: base-4.6.0.0

Defined in GHC.Generics

Associated Types

type Rep (NonEmpty a) :: Type -> Type

Methods

from :: NonEmpty a -> Rep (NonEmpty a) x

to :: Rep (NonEmpty a) x -> NonEmpty a

Generic (SCC vertex)

Since: containers-0.5.9

Defined in Data.Graph

Associated Types

type Rep (SCC vertex) :: Type -> Type

Methods

from :: SCC vertex -> Rep (SCC vertex) x

to :: Rep (SCC vertex) x -> SCC vertex

Generic (Tree a)

Since: containers-0.5.8

Defined in Data.Tree

Associated Types

type Rep (Tree a) :: Type -> Type

Methods

from :: Tree a -> Rep (Tree a) x

to :: Rep (Tree a) x -> Tree a

Generic (FingerTree a)

Since: containers-0.6.1

Defined in Data.Sequence.Internal

Associated Types

type Rep (FingerTree a) :: Type -> Type

Methods

from :: FingerTree a -> Rep (FingerTree a) x

to :: Rep (FingerTree a) x -> FingerTree a

Generic (Digit a)

Since: containers-0.6.1

Defined in Data.Sequence.Internal

Associated Types

type Rep (Digit a) :: Type -> Type

Methods

from :: Digit a -> Rep (Digit a) x

to :: Rep (Digit a) x -> Digit a

Generic (Node a)

Since: containers-0.6.1

Defined in Data.Sequence.Internal

Associated Types

type Rep (Node a) :: Type -> Type

Methods

from :: Node a -> Rep (Node a) x

to :: Rep (Node a) x -> Node a

Generic (Elem a)

Since: containers-0.6.1

Defined in Data.Sequence.Internal

Associated Types

type Rep (Elem a) :: Type -> Type

Methods

from :: Elem a -> Rep (Elem a) x

to :: Rep (Elem a) x -> Elem a

Generic (ViewL a)

Since: containers-0.5.8

Defined in Data.Sequence.Internal

Associated Types

type Rep (ViewL a) :: Type -> Type

Methods

from :: ViewL a -> Rep (ViewL a) x

to :: Rep (ViewL a) x -> ViewL a

Generic (ViewR a)

Since: containers-0.5.8

Defined in Data.Sequence.Internal

Associated Types

type Rep (ViewR a) :: Type -> Type

Methods

from :: ViewR a -> Rep (ViewR a) x

to :: Rep (ViewR a) x -> ViewR a

Generic (Doc a)

Defined in Text.PrettyPrint.Annotated.HughesPJ

Associated Types

type Rep (Doc a) :: Type -> Type

Methods

from :: Doc a -> Rep (Doc a) x

to :: Rep (Doc a) x -> Doc a

Generic (Doc ann)

Defined in Data.Text.Prettyprint.Doc.Internal

Associated Types

type Rep (Doc ann) :: Type -> Type

Methods

from :: Doc ann -> Rep (Doc ann) x

to :: Rep (Doc ann) x -> Doc ann

Generic (SimpleDocStream ann)

Defined in Data.Text.Prettyprint.Doc.Internal

Associated Types

type Rep (SimpleDocStream ann) :: Type -> Type

Methods

from :: SimpleDocStream ann -> Rep (SimpleDocStream ann) x

to :: Rep (SimpleDocStream ann) x -> SimpleDocStream ann

Generic (Window a)

Defined in System.Console.Terminal.Common

Associated Types

type Rep (Window a) :: Type -> Type

Methods

from :: Window a -> Rep (Window a) x

to :: Rep (Window a) x -> Window a

Generic (Doc a)

Defined in Text.PrettyPrint.Annotated.WL

Associated Types

type Rep (Doc a) :: Type -> Type

Methods

from :: Doc a -> Rep (Doc a) x

to :: Rep (Doc a) x -> Doc a

Generic (SimpleDoc a)

Defined in Text.PrettyPrint.Annotated.WL

Associated Types

type Rep (SimpleDoc a) :: Type -> Type

Methods

from :: SimpleDoc a -> Rep (SimpleDoc a) x

to :: Rep (SimpleDoc a) x -> SimpleDoc a

Generic (Any sh)

Defined in Data.Array.Accelerate.Sugar.Shape

Associated Types

type Rep (Any sh) :: Type -> Type

Methods

from :: Any sh -> Rep (Any sh) x

to :: Rep (Any sh) x -> Any sh

Generic (Either a b)

Since: base-4.6.0.0

Defined in GHC.Generics

Associated Types

type Rep (Either a b) :: Type -> Type

Methods

from :: Either a b -> Rep (Either a b) x

to :: Rep (Either a b) x -> Either a b

Generic (V1 p)

Since: base-4.9.0.0

Defined in GHC.Generics

Associated Types

type Rep (V1 p) :: Type -> Type

Methods

from :: V1 p -> Rep (V1 p) x

to :: Rep (V1 p) x -> V1 p

Generic (U1 p)

Since: base-4.7.0.0

Defined in GHC.Generics

Associated Types

type Rep (U1 p) :: Type -> Type

Methods

from :: U1 p -> Rep (U1 p) x

to :: Rep (U1 p) x -> U1 p

Generic (a, b)

Since: base-4.6.0.0

Defined in GHC.Generics

Associated Types

type Rep (a, b) :: Type -> Type

Methods

from :: (a, b) -> Rep (a, b) x

to :: Rep (a, b) x -> (a, b)

Generic (Arg a b)

Since: base-4.9.0.0

Defined in Data.Semigroup

Associated Types

type Rep (Arg a b) :: Type -> Type

Methods

from :: Arg a b -> Rep (Arg a b) x

to :: Rep (Arg a b) x -> Arg a b

Generic (WrappedMonad m a)

Since: base-4.7.0.0

Defined in Control.Applicative

Associated Types

type Rep (WrappedMonad m a) :: Type -> Type

Methods

from :: WrappedMonad m a -> Rep (WrappedMonad m a) x

to :: Rep (WrappedMonad m a) x -> WrappedMonad m a

Generic (Proxy t)

Since: base-4.6.0.0

Defined in GHC.Generics

Associated Types

type Rep (Proxy t) :: Type -> Type

Methods

from :: Proxy t -> Rep (Proxy t) x

to :: Rep (Proxy t) x -> Proxy t

Generic (Cofree f a)

Defined in Control.Comonad.Cofree

Associated Types

type Rep (Cofree f a) :: Type -> Type

Methods

from :: Cofree f a -> Rep (Cofree f a) x

to :: Rep (Cofree f a) x -> Cofree f a

Generic (Free f a)

Defined in Control.Monad.Free

Associated Types

type Rep (Free f a) :: Type -> Type

Methods

from :: Free f a -> Rep (Free f a) x

to :: Rep (Free f a) x -> Free f a

Generic (tail :. head)

Defined in Data.Array.Accelerate.Sugar.Shape

Associated Types

type Rep (tail :. head) :: Type -> Type

Methods

from :: (tail :. head) -> Rep (tail :. head) x

to :: Rep (tail :. head) x -> tail :. head

Generic (Rec1 f p)

Since: base-4.7.0.0

Defined in GHC.Generics

Associated Types

type Rep (Rec1 f p) :: Type -> Type

Methods

from :: Rec1 f p -> Rep (Rec1 f p) x

to :: Rep (Rec1 f p) x -> Rec1 f p

Generic (URec (Ptr ()) p)

Since: base-4.9.0.0

Defined in GHC.Generics

Associated Types

type Rep (URec (Ptr ()) p) :: Type -> Type

Methods

from :: URec (Ptr ()) p -> Rep (URec (Ptr ()) p) x

to :: Rep (URec (Ptr ()) p) x -> URec (Ptr ()) p

Generic (URec Char p)

Since: base-4.9.0.0

Defined in GHC.Generics

Associated Types

type Rep (URec Char p) :: Type -> Type

Methods

from :: URec Char p -> Rep (URec Char p) x

to :: Rep (URec Char p) x -> URec Char p

Generic (URec Double p)

Since: base-4.9.0.0

Defined in GHC.Generics

Associated Types

type Rep (URec Double p) :: Type -> Type

Methods

from :: URec Double p -> Rep (URec Double p) x

to :: Rep (URec Double p) x -> URec Double p

Generic (URec Float p)

Defined in GHC.Generics

Associated Types

type Rep (URec Float p) :: Type -> Type

Methods

from :: URec Float p -> Rep (URec Float p) x

to :: Rep (URec Float p) x -> URec Float p

Generic (URec Int p)

Since: base-4.9.0.0

Defined in GHC.Generics

Associated Types

type Rep (URec Int p) :: Type -> Type

Methods

from :: URec Int p -> Rep (URec Int p) x

to :: Rep (URec Int p) x -> URec Int p

Generic (URec Word p)

Since: base-4.9.0.0

Defined in GHC.Generics

Associated Types

type Rep (URec Word p) :: Type -> Type

Methods

from :: URec Word p -> Rep (URec Word p) x

to :: Rep (URec Word p) x -> URec Word p

Generic (a, b, c)

Since: base-4.6.0.0

Defined in GHC.Generics

Associated Types

type Rep (a, b, c) :: Type -> Type

Methods

from :: (a, b, c) -> Rep (a, b, c) x

to :: Rep (a, b, c) x -> (a, b, c)

Generic (WrappedArrow a b c)

Since: base-4.7.0.0

Defined in Control.Applicative

Associated Types

type Rep (WrappedArrow a b c) :: Type -> Type

Methods

from :: WrappedArrow a b c -> Rep (WrappedArrow a b c) x

to :: Rep (WrappedArrow a b c) x -> WrappedArrow a b c

Generic (Kleisli m a b)

Since: base-4.14.0.0

Defined in Control.Arrow

Associated Types

type Rep (Kleisli m a b) :: Type -> Type

Methods

from :: Kleisli m a b -> Rep (Kleisli m a b) x

to :: Rep (Kleisli m a b) x -> Kleisli m a b

Generic (Const a b)

Since: base-4.9.0.0

Defined in Data.Functor.Const

Associated Types

type Rep (Const a b) :: Type -> Type

Methods

from :: Const a b -> Rep (Const a b) x

to :: Rep (Const a b) x -> Const a b

Generic (Ap f a)

Since: base-4.12.0.0

Defined in Data.Monoid

Associated Types

type Rep (Ap f a) :: Type -> Type

Methods

from :: Ap f a -> Rep (Ap f a) x

to :: Rep (Ap f a) x -> Ap f a

Generic (Alt f a)

Since: base-4.8.0.0

Defined in Data.Semigroup.Internal

Associated Types

type Rep (Alt f a) :: Type -> Type

Methods

from :: Alt f a -> Rep (Alt f a) x

to :: Rep (Alt f a) x -> Alt f a

Generic (Join p a)

Defined in Data.Bifunctor.Join

Associated Types

type Rep (Join p a) :: Type -> Type

Methods

from :: Join p a -> Rep (Join p a) x

to :: Rep (Join p a) x -> Join p a

Generic (Fix p a)

Defined in Data.Bifunctor.Fix

Associated Types

type Rep (Fix p a) :: Type -> Type

Methods

from :: Fix p a -> Rep (Fix p a) x

to :: Rep (Fix p a) x -> Fix p a

Generic (FreeF f a b)

Defined in Control.Monad.Trans.Free

Associated Types

type Rep (FreeF f a b) :: Type -> Type

Methods

from :: FreeF f a b -> Rep (FreeF f a b) x

to :: Rep (FreeF f a b) x -> FreeF f a b

Generic (CofreeF f a b)

Defined in Control.Comonad.Trans.Cofree

Associated Types

type Rep (CofreeF f a b) :: Type -> Type

Methods

from :: CofreeF f a b -> Rep (CofreeF f a b) x

to :: Rep (CofreeF f a b) x -> CofreeF f a b

Generic (Tagged s b)

Defined in Data.Tagged

Associated Types

type Rep (Tagged s b) :: Type -> Type

Methods

from :: Tagged s b -> Rep (Tagged s b) x

to :: Rep (Tagged s b) x -> Tagged s b

Generic (K1 i c p)

Since: base-4.7.0.0

Defined in GHC.Generics

Associated Types

type Rep (K1 i c p) :: Type -> Type

Methods

from :: K1 i c p -> Rep (K1 i c p) x

to :: Rep (K1 i c p) x -> K1 i c p

Generic ((f :+: g) p)

Since: base-4.7.0.0

Defined in GHC.Generics

Associated Types

type Rep ((f :+: g) p) :: Type -> Type

Methods

from :: (f :+: g) p -> Rep ((f :+: g) p) x

to :: Rep ((f :+: g) p) x -> (f :+: g) p

Generic ((f :*: g) p)

Since: base-4.7.0.0

Defined in GHC.Generics

Associated Types

type Rep ((f :*: g) p) :: Type -> Type

Methods

from :: (f :*: g) p -> Rep ((f :*: g) p) x

to :: Rep ((f :*: g) p) x -> (f :*: g) p

Generic (a, b, c, d)

Since: base-4.6.0.0

Defined in GHC.Generics

Associated Types

type Rep (a, b, c, d) :: Type -> Type

Methods

from :: (a, b, c, d) -> Rep (a, b, c, d) x

to :: Rep (a, b, c, d) x -> (a, b, c, d)

Generic (Product f g a)

Since: base-4.9.0.0

Defined in Data.Functor.Product

Associated Types

type Rep (Product f g a) :: Type -> Type

Methods

from :: Product f g a -> Rep (Product f g a) x

to :: Rep (Product f g a) x -> Product f g a

Generic (Sum f g a)

Since: base-4.9.0.0

Defined in Data.Functor.Sum

Associated Types

type Rep (Sum f g a) :: Type -> Type

Methods

from :: Sum f g a -> Rep (Sum f g a) x

to :: Rep (Sum f g a) x -> Sum f g a

Generic (M1 i c f p)

Since: base-4.7.0.0

Defined in GHC.Generics

Associated Types

type Rep (M1 i c f p) :: Type -> Type

Methods

from :: M1 i c f p -> Rep (M1 i c f p) x

to :: Rep (M1 i c f p) x -> M1 i c f p

Generic ((f :.: g) p)

Since: base-4.7.0.0

Defined in GHC.Generics

Associated Types

type Rep ((f :.: g) p) :: Type -> Type

Methods

from :: (f :.: g) p -> Rep ((f :.: g) p) x

to :: Rep ((f :.: g) p) x -> (f :.: g) p

Generic (a, b, c, d, e)

Since: base-4.6.0.0

Defined in GHC.Generics

Associated Types

type Rep (a, b, c, d, e) :: Type -> Type

Methods

from :: (a, b, c, d, e) -> Rep (a, b, c, d, e) x

to :: Rep (a, b, c, d, e) x -> (a, b, c, d, e)

Generic (Compose f g a)

Since: base-4.9.0.0

Defined in Data.Functor.Compose

Associated Types

type Rep (Compose f g a) :: Type -> Type

Methods

from :: Compose f g a -> Rep (Compose f g a) x

to :: Rep (Compose f g a) x -> Compose f g a

Generic (WrappedBifunctor p a b)

Defined in Data.Bifunctor.Wrapped

Associated Types

type Rep (WrappedBifunctor p a b) :: Type -> Type

Methods

from :: WrappedBifunctor p a b -> Rep (WrappedBifunctor p a b) x

to :: Rep (WrappedBifunctor p a b) x -> WrappedBifunctor p a b

Generic (Joker g a b)

Defined in Data.Bifunctor.Joker

Associated Types

type Rep (Joker g a b) :: Type -> Type

Methods

from :: Joker g a b -> Rep (Joker g a b) x

to :: Rep (Joker g a b) x -> Joker g a b

Generic (Flip p a b)

Defined in Data.Bifunctor.Flip

Associated Types

type Rep (Flip p a b) :: Type -> Type

Methods

from :: Flip p a b -> Rep (Flip p a b) x

to :: Rep (Flip p a b) x -> Flip p a b

Generic (Clown f a b)

Defined in Data.Bifunctor.Clown

Associated Types

type Rep (Clown f a b) :: Type -> Type

Methods

from :: Clown f a b -> Rep (Clown f a b) x

to :: Rep (Clown f a b) x -> Clown f a b

Generic (a, b, c, d, e, f)

Since: base-4.6.0.0

Defined in GHC.Generics

Associated Types

type Rep (a, b, c, d, e, f) :: Type -> Type

Methods

from :: (a, b, c, d, e, f) -> Rep (a, b, c, d, e, f) x

to :: Rep (a, b, c, d, e, f) x -> (a, b, c, d, e, f)

Generic (Sum p q a b)

Defined in Data.Bifunctor.Sum

Associated Types

type Rep (Sum p q a b) :: Type -> Type

Methods

from :: Sum p q a b -> Rep (Sum p q a b) x

to :: Rep (Sum p q a b) x -> Sum p q a b

Generic (Product f g a b)

Defined in Data.Bifunctor.Product

Associated Types

type Rep (Product f g a b) :: Type -> Type

Methods

from :: Product f g a b -> Rep (Product f g a b) x

to :: Rep (Product f g a b) x -> Product f g a b

Generic (a, b, c, d, e, f, g)

Since: base-4.6.0.0

Defined in GHC.Generics

Associated Types

type Rep (a, b, c, d, e, f, g) :: Type -> Type

Methods

from :: (a, b, c, d, e, f, g) -> Rep (a, b, c, d, e, f, g) x

to :: Rep (a, b, c, d, e, f, g) x -> (a, b, c, d, e, f, g)

Generic (Tannen f p a b)

Defined in Data.Bifunctor.Tannen

Associated Types

type Rep (Tannen f p a b) :: Type -> Type

Methods

from :: Tannen f p a b -> Rep (Tannen f p a b) x

to :: Rep (Tannen f p a b) x -> Tannen f p a b

Generic (a, b, c, d, e, f, g, h)

Defined in Data.Array.Accelerate.Orphans

Associated Types

type Rep (a, b, c, d, e, f, g, h) :: Type -> Type

Methods

from :: (a, b, c, d, e, f, g, h) -> Rep (a, b, c, d, e, f, g, h) x

to :: Rep (a, b, c, d, e, f, g, h) x -> (a, b, c, d, e, f, g, h)

Generic (a, b, c, d, e, f, g, h, i)

Defined in Data.Array.Accelerate.Orphans

Associated Types

type Rep (a, b, c, d, e, f, g, h, i) :: Type -> Type

Methods

from :: (a, b, c, d, e, f, g, h, i) -> Rep (a, b, c, d, e, f, g, h, i) x

to :: Rep (a, b, c, d, e, f, g, h, i) x -> (a, b, c, d, e, f, g, h, i)

Generic (Biff p f g a b)

Defined in Data.Bifunctor.Biff

Associated Types

type Rep (Biff p f g a b) :: Type -> Type

Methods

from :: Biff p f g a b -> Rep (Biff p f g a b) x

to :: Rep (Biff p f g a b) x -> Biff p f g a b

Generic (a, b, c, d, e, f, g, h, i, j)

Defined in Data.Array.Accelerate.Orphans

Associated Types

type Rep (a, b, c, d, e, f, g, h, i, j) :: Type -> Type

Methods

from :: (a, b, c, d, e, f, g, h, i, j) -> Rep (a, b, c, d, e, f, g, h, i, j) x

to :: Rep (a, b, c, d, e, f, g, h, i, j) x -> (a, b, c, d, e, f, g, h, i, j)

Generic (a, b, c, d, e, f, g, h, i, j, k)

Defined in Data.Array.Accelerate.Orphans

Associated Types

type Rep (a, b, c, d, e, f, g, h, i, j, k) :: Type -> Type

Methods

from :: (a, b, c, d, e, f, g, h, i, j, k) -> Rep (a, b, c, d, e, f, g, h, i, j, k) x

to :: Rep (a, b, c, d, e, f, g, h, i, j, k) x -> (a, b, c, d, e, f, g, h, i, j, k)

Generic (a, b, c, d, e, f, g, h, i, j, k, l)

Defined in Data.Array.Accelerate.Orphans

Associated Types

type Rep (a, b, c, d, e, f, g, h, i, j, k, l) :: Type -> Type

Methods

from :: (a, b, c, d, e, f, g, h, i, j, k, l) -> Rep (a, b, c, d, e, f, g, h, i, j, k, l) x

to :: Rep (a, b, c, d, e, f, g, h, i, j, k, l) x -> (a, b, c, d, e, f, g, h, i, j, k, l)

Generic (a, b, c, d, e, f, g, h, i, j, k, l, m)

Defined in Data.Array.Accelerate.Orphans

Associated Types

type Rep (a, b, c, d, e, f, g, h, i, j, k, l, m) :: Type -> Type

Methods

from :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Rep (a, b, c, d, e, f, g, h, i, j, k, l, m) x

to :: Rep (a, b, c, d, e, f, g, h, i, j, k, l, m) x -> (a, b, c, d, e, f, g, h, i, j, k, l, m)

Generic (a, b, c, d, e, f, g, h, i, j, k, l, m, n)

Defined in Data.Array.Accelerate.Orphans

Associated Types

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

Methods

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

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

Generic (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)

Defined in Data.Array.Accelerate.Orphans

Associated Types

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

Methods

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

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

Generic (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p)

Defined in Data.Array.Accelerate.Orphans

Associated Types

type Rep (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) :: Type -> Type

Methods

from :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) -> Rep (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) x

to :: Rep (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) x -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p)

type HasCallStack = ?callStack :: CallStack

Request a CallStack.

NOTE: The implicit parameter ?callStack :: CallStack is an implementation detail and should not be considered part of the CallStack API, we may decide to change the implementation in the future.

Since: base-4.9.0.0

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

Since: base-2.1

Defined in GHC.Enum

Methods

minBound :: Int

maxBound :: Int

Enum Int

Since: base-2.1

Defined in GHC.Enum

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

Defined in GHC.Classes

Methods

(==) :: Int -> Int -> Bool

(/=) :: Int -> Int -> Bool

Integral Int

Since: base-2.0.1

Defined in GHC.Real

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

Num Int

Since: base-2.1

Defined in GHC.Num

Methods

(+) :: Int -> Int -> Int

(-) :: Int -> Int -> Int

(*) :: Int -> Int -> Int

negate :: Int -> Int

abs :: Int -> Int

signum :: Int -> Int

fromInteger :: Integer -> Int

Ord Int

Defined in GHC.Classes

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

Read Int

Since: base-2.1

Defined in GHC.Read

Methods

readsPrec :: Int -> ReadS Int

readList :: ReadS [Int]

readPrec :: ReadPrec Int

readListPrec :: ReadPrec [Int]

Real Int

Since: base-2.0.1

Defined in GHC.Real

Methods

toRational :: Int -> Rational

Show Int

Since: base-2.1

Defined in GHC.Show

Methods

showsPrec :: Int -> Int -> ShowS

show :: Int -> String

showList :: [Int] -> ShowS

Ix Int

Since: base-2.1

Defined in GHC.Ix

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

PrintfArg Int

Since: base-2.1

Defined in Text.Printf

Methods

formatArg :: Int -> FieldFormatter

parseFormat :: Int -> ModifierParser

Storable Int

Since: base-2.1

Defined in Foreign.Storable

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

Since: base-2.1

Defined in Data.Bits

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

Since: base-4.6.0.0

Defined in Data.Bits

Methods

finiteBitSize :: Int -> Int

countLeadingZeros :: Int -> Int

countTrailingZeros :: Int -> Int

PrimType Int

Defined in Basement.PrimType

Associated Types

type PrimSize Int :: Nat

Methods

primSizeInBytes :: Proxy Int -> CountOf Word8

primShiftToBytes :: Proxy Int -> Int

primBaUIndex :: ByteArray# -> Offset Int -> Int

primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Int -> prim Int

primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Int -> Int -> prim ()

primAddrIndex :: Addr# -> Offset Int -> Int

primAddrRead :: PrimMonad prim => Addr# -> Offset Int -> prim Int

primAddrWrite :: PrimMonad prim => Addr# -> Offset Int -> Int -> prim ()

PrimMemoryComparable Int

Defined in Basement.PrimType

Subtractive Int

Defined in Basement.Numerical.Subtractive

Associated Types

type Difference Int

Methods

(-) :: Int -> Int -> Difference Int

NFData Int

Defined in Control.DeepSeq

Methods

rnf :: Int -> ()

Hashable Int

Defined in Data.Hashable.Class

Methods

hashWithSalt :: Int -> Int -> Int

hash :: Int -> Int

Prim Int

Defined in Data.Primitive.Types

Methods

sizeOf# :: Int -> Int#

alignment# :: Int -> Int#

indexByteArray# :: ByteArray# -> Int# -> Int

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Int #)

writeByteArray# :: MutableByteArray# s -> Int# -> Int -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Int -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> Int

readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Int #)

writeOffAddr# :: Addr# -> Int# -> Int -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> Int -> State# s -> State# s

Unbox Int

Defined in Data.Vector.Unboxed.Base

Pretty Int

>>> pretty (123 :: Int)
123

Defined in Data.Text.Prettyprint.Doc.Internal

Methods

pretty :: Int -> Doc ann

prettyList :: [Int] -> Doc ann

Pretty Int

Defined in Text.PrettyPrint.Annotated.WL

Methods

pretty :: Int -> Doc b

prettyList :: [Int] -> Doc b

Elt Int

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR Int

Methods

eltR :: TypeR (EltR Int)

tagsR :: [TagR (EltR Int)]

fromElt :: Int -> EltR Int

toElt :: EltR Int -> Int

Eq Int

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp Int -> Exp Int -> Exp Bool

(/=) :: Exp Int -> Exp Int -> Exp Bool

Ord Int

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp Int -> Exp Int -> Exp Bool

(>) :: Exp Int -> Exp Int -> Exp Bool

(<=) :: Exp Int -> Exp Int -> Exp Bool

(>=) :: Exp Int -> Exp Int -> Exp Bool

min :: Exp Int -> Exp Int -> Exp Int

max :: Exp Int -> Exp Int -> Exp Int

compare :: Exp Int -> Exp Int -> Exp Ordering

FiniteBits Int

Defined in Data.Array.Accelerate.Data.Bits

Methods

finiteBitSize :: Exp Int -> Exp Int

countLeadingZeros :: Exp Int -> Exp Int

countTrailingZeros :: Exp Int -> Exp Int

Bits Int

Defined in Data.Array.Accelerate.Data.Bits

Methods

(.&.) :: Exp Int -> Exp Int -> Exp Int

(.|.) :: Exp Int -> Exp Int -> Exp Int

xor :: Exp Int -> Exp Int -> Exp Int

complement :: Exp Int -> Exp Int

shift :: Exp Int -> Exp Int -> Exp Int

rotate :: Exp Int -> Exp Int -> Exp Int

zeroBits :: Exp Int

bit :: Exp Int -> Exp Int

setBit :: Exp Int -> Exp Int -> Exp Int

clearBit :: Exp Int -> Exp Int -> Exp Int

complementBit :: Exp Int -> Exp Int -> Exp Int

testBit :: Exp Int -> Exp Int -> Exp Bool

isSigned :: Exp Int -> Exp Bool

shiftL :: Exp Int -> Exp Int -> Exp Int

unsafeShiftL :: Exp Int -> Exp Int -> Exp Int

shiftR :: Exp Int -> Exp Int -> Exp Int

unsafeShiftR :: Exp Int -> Exp Int -> Exp Int

rotateL :: Exp Int -> Exp Int -> Exp Int

rotateR :: Exp Int -> Exp Int -> Exp Int

popCount :: Exp Int -> Exp Int

Rational Int

Defined in Data.Array.Accelerate.Classes.Rational

Methods

toRational :: (FromIntegral Int64 b, Integral b) => Exp Int -> Exp (Ratio b)

Lift Int

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Int -> Q Exp

liftTyped :: Int -> Q (TExp Int)

Vector Vector Int

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Int -> m (Vector Int)

basicUnsafeThaw :: PrimMonad m => Vector Int -> m (Mutable Vector (PrimState m) Int)

basicLength :: Vector Int -> Int

basicUnsafeSlice :: Int -> Int -> Vector Int -> Vector Int

basicUnsafeIndexM :: Monad m => Vector Int -> Int -> m Int

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Int -> Vector Int -> m ()

elemseq :: Vector Int -> Int -> b -> b

FunctorWithIndex Int []

The position in the list is available as the index.

Defined in Control.Lens.Indexed

Methods

imap :: (Int -> a -> b) -> [a] -> [b]

imapped :: IndexedSetter Int [a] [b] a b

FunctorWithIndex Int ZipList

Same instance as for [].

Defined in Control.Lens.Indexed

Methods

imap :: (Int -> a -> b) -> ZipList a -> ZipList b

imapped :: IndexedSetter Int (ZipList a) (ZipList b) a b

FunctorWithIndex Int NonEmpty

Defined in Control.Lens.Indexed

Methods

imap :: (Int -> a -> b) -> NonEmpty a -> NonEmpty b

imapped :: IndexedSetter Int (NonEmpty a) (NonEmpty b) a b

FunctorWithIndex Int IntMap

Defined in Control.Lens.Indexed

Methods

imap :: (Int -> a -> b) -> IntMap a -> IntMap b

imapped :: IndexedSetter Int (IntMap a) (IntMap b) a b

FunctorWithIndex Int Seq

The position in the Seq is available as the index.

Defined in Control.Lens.Indexed

Methods

imap :: (Int -> a -> b) -> Seq a -> Seq b

imapped :: IndexedSetter Int (Seq a) (Seq b) a b

FunctorWithIndex Int Vector

Defined in Control.Lens.Indexed

Methods

imap :: (Int -> a -> b) -> Vector a -> Vector b

imapped :: IndexedSetter Int (Vector a) (Vector b) a b

FoldableWithIndex Int []

Defined in Control.Lens.Indexed

Methods

ifoldMap :: Monoid m => (Int -> a -> m) -> [a] -> m

ifolded :: IndexedFold Int [a] a

ifoldr :: (Int -> a -> b -> b) -> b -> [a] -> b

ifoldl :: (Int -> b -> a -> b) -> b -> [a] -> b

ifoldr' :: (Int -> a -> b -> b) -> b -> [a] -> b

ifoldl' :: (Int -> b -> a -> b) -> b -> [a] -> b

FoldableWithIndex Int ZipList

Defined in Control.Lens.Indexed

Methods

ifoldMap :: Monoid m => (Int -> a -> m) -> ZipList a -> m

ifolded :: IndexedFold Int (ZipList a) a

ifoldr :: (Int -> a -> b -> b) -> b -> ZipList a -> b

ifoldl :: (Int -> b -> a -> b) -> b -> ZipList a -> b

ifoldr' :: (Int -> a -> b -> b) -> b -> ZipList a -> b

ifoldl' :: (Int -> b -> a -> b) -> b -> ZipList a -> b

FoldableWithIndex Int NonEmpty

Defined in Control.Lens.Indexed

Methods

ifoldMap :: Monoid m => (Int -> a -> m) -> NonEmpty a -> m

ifolded :: IndexedFold Int (NonEmpty a) a

ifoldr :: (Int -> a -> b -> b) -> b -> NonEmpty a -> b

ifoldl :: (Int -> b -> a -> b) -> b -> NonEmpty a -> b

ifoldr' :: (Int -> a -> b -> b) -> b -> NonEmpty a -> b

ifoldl' :: (Int -> b -> a -> b) -> b -> NonEmpty a -> b

FoldableWithIndex Int IntMap

Defined in Control.Lens.Indexed

Methods

ifoldMap :: Monoid m => (Int -> a -> m) -> IntMap a -> m

ifolded :: IndexedFold Int (IntMap a) a

ifoldr :: (Int -> a -> b -> b) -> b -> IntMap a -> b

ifoldl :: (Int -> b -> a -> b) -> b -> IntMap a -> b

ifoldr' :: (Int -> a -> b -> b) -> b -> IntMap a -> b

ifoldl' :: (Int -> b -> a -> b) -> b -> IntMap a -> b

FoldableWithIndex Int Seq

Defined in Control.Lens.Indexed

Methods

ifoldMap :: Monoid m => (Int -> a -> m) -> Seq a -> m

ifolded :: IndexedFold Int (Seq a) a

ifoldr :: (Int -> a -> b -> b) -> b -> Seq a -> b

ifoldl :: (Int -> b -> a -> b) -> b -> Seq a -> b

ifoldr' :: (Int -> a -> b -> b) -> b -> Seq a -> b

ifoldl' :: (Int -> b -> a -> b) -> b -> Seq a -> b

FoldableWithIndex Int Vector

Defined in Control.Lens.Indexed

Methods

ifoldMap :: Monoid m => (Int -> a -> m) -> Vector a -> m

ifolded :: IndexedFold Int (Vector a) a

ifoldr :: (Int -> a -> b -> b) -> b -> Vector a -> b

ifoldl :: (Int -> b -> a -> b) -> b -> Vector a -> b

ifoldr' :: (Int -> a -> b -> b) -> b -> Vector a -> b

ifoldl' :: (Int -> b -> a -> b) -> b -> Vector a -> b

TraversableWithIndex Int []

Defined in Control.Lens.Indexed

Methods

itraverse :: Applicative f => (Int -> a -> f b) -> [a] -> f [b]

itraversed :: IndexedTraversal Int [a] [b] a b

TraversableWithIndex Int ZipList

Defined in Control.Lens.Indexed

Methods

itraverse :: Applicative f => (Int -> a -> f b) -> ZipList a -> f (ZipList b)

itraversed :: IndexedTraversal Int (ZipList a) (ZipList b) a b

TraversableWithIndex Int NonEmpty

Defined in Control.Lens.Indexed

Methods

itraverse :: Applicative f => (Int -> a -> f b) -> NonEmpty a -> f (NonEmpty b)

itraversed :: IndexedTraversal Int (NonEmpty a) (NonEmpty b) a b

TraversableWithIndex Int IntMap

Defined in Control.Lens.Indexed

Methods

itraverse :: Applicative f => (Int -> a -> f b) -> IntMap a -> f (IntMap b)

itraversed :: IndexedTraversal Int (IntMap a) (IntMap b) a b

TraversableWithIndex Int Seq

Defined in Control.Lens.Indexed

Methods

itraverse :: Applicative f => (Int -> a -> f b) -> Seq a -> f (Seq b)

itraversed :: IndexedTraversal Int (Seq a) (Seq b) a b

TraversableWithIndex Int Vector

Defined in Control.Lens.Indexed

Methods

itraverse :: Applicative f => (Int -> a -> f b) -> Vector a -> f (Vector b)

itraversed :: IndexedTraversal Int (Vector a) (Vector b) a b

TraverseMin Int IntMap

Defined in Control.Lens.Traversal

Methods

traverseMin :: IndexedTraversal' Int (IntMap v) v

TraverseMax Int IntMap

Defined in Control.Lens.Traversal

Methods

traverseMax :: IndexedTraversal' Int (IntMap v) v

MVector MVector Int

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Int -> Int

basicUnsafeSlice :: Int -> Int -> MVector s Int -> MVector s Int

basicOverlaps :: MVector s Int -> MVector s Int -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Int)

basicInitialize :: PrimMonad m => MVector (PrimState m) Int -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Int -> m (MVector (PrimState m) Int)

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Int -> Int -> m Int

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Int -> Int -> Int -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) Int -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) Int -> Int -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Int -> MVector (PrimState m) Int -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Int -> MVector (PrimState m) Int -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Int -> Int -> m (MVector (PrimState m) Int)

ToFloating Int Double

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Int -> Exp Double

ToFloating Int Float

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Int -> Exp Float

ToFloating Int Half

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Int -> Exp Half

Lift Exp Int

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain Int

Methods

lift :: Int -> Exp (Plain Int)

FromIntegral Int Double

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int -> Exp Double

FromIntegral Int Float

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int -> Exp Float

FromIntegral Int Int

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int -> Exp Int

FromIntegral Int Int8

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int -> Exp Int8

FromIntegral Int Int16

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int -> Exp Int16

FromIntegral Int Int32

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int -> Exp Int32

FromIntegral Int Int64

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int -> Exp Int64

FromIntegral Int Word

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int -> Exp Word

FromIntegral Int Word8

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int -> Exp Word8

FromIntegral Int Word16

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int -> Exp Word16

FromIntegral Int Word32

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int -> Exp Word32

FromIntegral Int Word64

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int -> Exp Word64

FromIntegral Int Half

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int -> Exp Half

FromIntegral Int8 Int

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int8 -> Exp Int

FromIntegral Int16 Int

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int16 -> Exp Int

FromIntegral Int32 Int

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int32 -> Exp Int

FromIntegral Int64 Int

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int64 -> Exp Int

FromIntegral Word Int

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word -> Exp Int

FromIntegral Word8 Int

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word8 -> Exp Int

FromIntegral Word16 Int

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word16 -> Exp Int

FromIntegral Word32 Int

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word32 -> Exp Int

FromIntegral Word64 Int

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word64 -> Exp Int

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

Defined in Data.Array.Accelerate.Smart

Associated Types

type StencilR DIM1 (Exp e, Exp e, Exp e)

Methods

stencilR :: StencilR (EltR DIM1) (EltR e) (StencilR DIM1 (Exp e, Exp e, Exp e))

stencilPrj :: SmartExp (StencilR 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)

Defined in Data.Array.Accelerate.Smart

Associated Types

type StencilR DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e)

Methods

stencilR :: StencilR (EltR DIM1) (EltR e) (StencilR DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e))

stencilPrj :: SmartExp (StencilR 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)

Defined in Data.Array.Accelerate.Smart

Associated Types

type StencilR DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e)

Methods

stencilR :: StencilR (EltR DIM1) (EltR e) (StencilR DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e))

stencilPrj :: SmartExp (StencilR 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)

Defined in Data.Array.Accelerate.Smart

Associated Types

type StencilR DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e)

Methods

stencilR :: StencilR (EltR DIM1) (EltR e) (StencilR DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e))

stencilPrj :: SmartExp (StencilR 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)

Generic1 (URec Int :: k -> Type)

Since: base-4.9.0.0

Defined in GHC.Generics

Associated Types

type Rep1 (URec Int) :: k -> Type

Methods

from1 :: forall (a :: k0). URec Int a -> Rep1 (URec Int) a

to1 :: forall (a :: k0). Rep1 (URec Int) a -> URec Int a

(Elt (Plain ix), Lift Exp ix) => Lift Exp (ix :. Int)

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain (ix :. Int)

Methods

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

Bounded (Exp Int)

Defined in Data.Array.Accelerate.Classes.Bounded

Methods

minBound :: Exp Int

maxBound :: Exp Int

Enum (Exp Int)

Defined in Data.Array.Accelerate.Classes.Enum

Methods

succ :: Exp Int -> Exp Int

pred :: Exp Int -> Exp Int

toEnum :: Int -> Exp Int

fromEnum :: Exp Int -> Int

enumFrom :: Exp Int -> [Exp Int]

enumFromThen :: Exp Int -> Exp Int -> [Exp Int]

enumFromTo :: Exp Int -> Exp Int -> [Exp Int]

enumFromThenTo :: Exp Int -> Exp Int -> Exp Int -> [Exp Int]

Integral (Exp Int)

Defined in Data.Array.Accelerate.Classes.Integral

Methods

quot :: Exp Int -> Exp Int -> Exp Int

rem :: Exp Int -> Exp Int -> Exp Int

div :: Exp Int -> Exp Int -> Exp Int

mod :: Exp Int -> Exp Int -> Exp Int

quotRem :: Exp Int -> Exp Int -> (Exp Int, Exp Int)

divMod :: Exp Int -> Exp Int -> (Exp Int, Exp Int)

toInteger :: Exp Int -> Integer

Num (Exp Int)

Defined in Data.Array.Accelerate.Classes.Num

Methods

(+) :: Exp Int -> Exp Int -> Exp Int

(-) :: Exp Int -> Exp Int -> Exp Int

(*) :: Exp Int -> Exp Int -> Exp Int

negate :: Exp Int -> Exp Int

abs :: Exp Int -> Exp Int

signum :: Exp Int -> Exp Int

fromInteger :: Integer -> Exp Int

Foldable (UInt :: Type -> Type)

Since: base-4.9.0.0

Defined in Data.Foldable

Methods

fold :: Monoid m => UInt m -> m

foldMap :: Monoid m => (a -> m) -> UInt a -> m

foldMap' :: Monoid m => (a -> m) -> UInt a -> m

foldr :: (a -> b -> b) -> b -> UInt a -> b

foldr' :: (a -> b -> b) -> b -> UInt a -> b

foldl :: (b -> a -> b) -> b -> UInt a -> b

foldl' :: (b -> a -> b) -> b -> UInt a -> b

foldr1 :: (a -> a -> a) -> UInt a -> a

foldl1 :: (a -> a -> a) -> UInt a -> a

toList :: UInt a -> [a]

null :: UInt a -> Bool

length :: UInt a -> Int

elem :: Eq a => a -> UInt a -> Bool

maximum :: Ord a => UInt a -> a

minimum :: Ord a => UInt a -> a

sum :: Num a => UInt a -> a

product :: Num a => UInt a -> a

Traversable (UInt :: Type -> Type)

Since: base-4.9.0.0

Defined in Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> UInt a -> f (UInt b)

sequenceA :: Applicative f => UInt (f a) -> f (UInt a)

mapM :: Monad m => (a -> m b) -> UInt a -> m (UInt b)

sequence :: Monad m => UInt (m a) -> m (UInt a)

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

Defined in Data.Array.Accelerate.Sugar.Shape

Associated Types

type EltR (Any (sh :. Int))

Methods

eltR :: TypeR (EltR (Any (sh :. Int)))

tagsR :: [TagR (EltR (Any (sh :. Int)))]

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

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

FunctorWithIndex [Int] Tree

Defined in Control.Lens.Indexed

Methods

imap :: ([Int] -> a -> b) -> Tree a -> Tree b

imapped :: IndexedSetter [Int] (Tree a) (Tree b) a b

FoldableWithIndex [Int] Tree

Defined in Control.Lens.Indexed

Methods

ifoldMap :: Monoid m => ([Int] -> a -> m) -> Tree a -> m

ifolded :: IndexedFold [Int] (Tree a) a

ifoldr :: ([Int] -> a -> b -> b) -> b -> Tree a -> b

ifoldl :: ([Int] -> b -> a -> b) -> b -> Tree a -> b

ifoldr' :: ([Int] -> a -> b -> b) -> b -> Tree a -> b

ifoldl' :: ([Int] -> b -> a -> b) -> b -> Tree a -> b

TraversableWithIndex [Int] Tree

Defined in Control.Lens.Indexed

Methods

itraverse :: Applicative f => ([Int] -> a -> f b) -> Tree a -> f (Tree b)

itraversed :: IndexedTraversal [Int] (Tree a) (Tree b) a b

Bizarre (Indexed Int) Mafic

Defined in Control.Lens.Internal.Magma

Methods

bazaar :: Applicative f => Indexed Int a (f b) -> Mafic a b t -> f t

Reifies Z Int

Defined in Data.Reflection

Methods

reflect :: proxy Z -> Int

Reifies n Int => Reifies (D n :: Type) Int

Defined in Data.Reflection

Methods

reflect :: proxy (D n) -> Int

Reifies n Int => Reifies (SD n :: Type) Int

Defined in Data.Reflection

Methods

reflect :: proxy (SD n) -> Int

Reifies n Int => Reifies (PD n :: Type) Int

Defined in Data.Reflection

Methods

reflect :: proxy (PD n) -> Int

Elt e => IsList (Array DIM1 e)

Defined in Data.Array.Accelerate.Sugar.Array

Associated Types

type Item (Array DIM1 e)

Methods

fromList :: [Item (Array DIM1 e)] -> Array DIM1 e

fromListN :: Int -> [Item (Array DIM1 e)] -> Array DIM1 e

toList :: Array DIM1 e -> [Item (Array DIM1 e)]

Functor (URec Int :: Type -> Type)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> URec Int a -> URec Int b

(<$) :: a -> URec Int b -> URec Int a

Slice sl => Slice (sl :. Int)

Defined in Data.Array.Accelerate.Sugar.Shape

Associated Types

type SliceShape (sl :. Int)

type CoSliceShape (sl :. Int)

type FullShape (sl :. Int)

Methods

sliceIndex :: SliceIndex (EltR (sl :. Int)) (EltR (SliceShape (sl :. Int))) (EltR (CoSliceShape (sl :. Int))) (EltR (FullShape (sl :. Int)))

Shape sh => Shape (sh :. Int)

Defined in Data.Array.Accelerate.Sugar.Shape

Methods

shapeR :: ShapeR (EltR (sh :. Int))

sliceAnyIndex :: SliceIndex (EltR (Any (sh :. Int))) (EltR (sh :. Int)) () (EltR (sh :. Int))

sliceNoneIndex :: SliceIndex (EltR (sh :. Int)) () (EltR (sh :. Int)) (EltR (sh :. Int))

Eq sh => Eq (sh :. Int)

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp (sh :. Int) -> Exp (sh :. Int) -> Exp Bool

(/=) :: Exp (sh :. Int) -> Exp (sh :. Int) -> Exp Bool

Ord sh => Ord (sh :. Int)

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp (sh :. Int) -> Exp (sh :. Int) -> Exp Bool

(>) :: Exp (sh :. Int) -> Exp (sh :. Int) -> Exp Bool

(<=) :: Exp (sh :. Int) -> Exp (sh :. Int) -> Exp Bool

(>=) :: Exp (sh :. Int) -> Exp (sh :. Int) -> Exp Bool

min :: Exp (sh :. Int) -> Exp (sh :. Int) -> Exp (sh :. Int)

max :: Exp (sh :. Int) -> Exp (sh :. Int) -> Exp (sh :. Int)

compare :: Exp (sh :. Int) -> Exp (sh :. Int) -> Exp Ordering

(Stencil (sh :. Int) a row2, Stencil (sh :. Int) a row1, Stencil (sh :. Int) a row0) => Stencil ((sh :. Int) :. Int) a (row2, row1, row0)

Defined in Data.Array.Accelerate.Smart

Associated Types

type StencilR ((sh :. Int) :. Int) (row2, row1, row0)

Methods

stencilR :: StencilR (EltR ((sh :. Int) :. Int)) (EltR a) (StencilR ((sh :. Int) :. Int) (row2, row1, row0))

stencilPrj :: SmartExp (StencilR ((sh :. Int) :. Int) (row2, row1, row0)) -> (row2, row1, row0)

(Stencil (sh :. Int) a row4, Stencil (sh :. Int) a row3, Stencil (sh :. Int) a row2, Stencil (sh :. Int) a row1, Stencil (sh :. Int) a row0) => Stencil ((sh :. Int) :. Int) a (row4, row3, row2, row1, row0)

Defined in Data.Array.Accelerate.Smart

Associated Types

type StencilR ((sh :. Int) :. Int) (row4, row3, row2, row1, row0)

Methods

stencilR :: StencilR (EltR ((sh :. Int) :. Int)) (EltR a) (StencilR ((sh :. Int) :. Int) (row4, row3, row2, row1, row0))

stencilPrj :: SmartExp (StencilR ((sh :. Int) :. Int) (row4, row3, row2, row1, row0)) -> (row4, row3, row2, row1, row0)

(Stencil (sh :. Int) a row6, Stencil (sh :. Int) a row5, Stencil (sh :. Int) a row4, Stencil (sh :. Int) a row3, Stencil (sh :. Int) a row2, Stencil (sh :. Int) a row1, Stencil (sh :. Int) a row0) => Stencil ((sh :. Int) :. Int) a (row6, row5, row4, row3, row2, row1, row0)

Defined in Data.Array.Accelerate.Smart

Associated Types

type StencilR ((sh :. Int) :. Int) (row6, row5, row4, row3, row2, row1, row0)

Methods

stencilR :: StencilR (EltR ((sh :. Int) :. Int)) (EltR a) (StencilR ((sh :. Int) :. Int) (row6, row5, row4, row3, row2, row1, row0))

stencilPrj :: SmartExp (StencilR ((sh :. Int) :. Int) (row6, row5, row4, row3, row2, row1, row0)) -> (row6, row5, row4, row3, row2, row1, row0)

(Stencil (sh :. Int) a row8, Stencil (sh :. Int) a row7, Stencil (sh :. Int) a row6, Stencil (sh :. Int) a row5, Stencil (sh :. Int) a row4, Stencil (sh :. Int) a row3, Stencil (sh :. Int) a row2, Stencil (sh :. Int) a row1, Stencil (sh :. Int) a row0) => Stencil ((sh :. Int) :. Int) a (row8, row7, row6, row5, row4, row3, row2, row1, row0)

Defined in Data.Array.Accelerate.Smart

Associated Types

type StencilR ((sh :. Int) :. Int) (row8, row7, row6, row5, row4, row3, row2, row1, row0)

Methods

stencilR :: StencilR (EltR ((sh :. Int) :. Int)) (EltR a) (StencilR ((sh :. Int) :. Int) (row8, row7, row6, row5, row4, row3, row2, row1, row0))

stencilPrj :: SmartExp (StencilR ((sh :. Int) :. Int) (row8, row7, row6, row5, row4, row3, row2, row1, row0)) -> (row8, row7, row6, row5, row4, row3, row2, row1, row0)

Eq (URec Int p)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

(==) :: URec Int p -> URec Int p -> Bool

(/=) :: URec Int p -> URec Int p -> Bool

Ord (URec Int p)

Since: base-4.9.0.0

Defined in GHC.Generics

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)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

showsPrec :: Int -> URec Int p -> ShowS

show :: URec Int p -> String

showList :: [URec Int p] -> ShowS

Generic (URec Int p)

Since: base-4.9.0.0

Defined in GHC.Generics

Associated Types

type Rep (URec Int p) :: Type -> Type

Methods

from :: URec Int p -> Rep (URec Int p) x

to :: Rep (URec Int p) x -> URec Int p

type PrimSize Int

Defined in Basement.PrimType

type PrimSize Int = 8

type Difference Int

Defined in Basement.Numerical.Subtractive

type Difference Int = Int

type NatNumMaxBound Int

Defined in Basement.Nat

type NatNumMaxBound Int = NatNumMaxBound Int64

newtype Vector Int

Defined in Data.Vector.Unboxed.Base

newtype Vector Int = V_Int (Vector Int)

type Plain Int

Defined in Data.Array.Accelerate.Lift

type Plain Int = Int

data URec Int (p :: k)

Used for marking occurrences of Int#

Since: base-4.9.0.0

Defined in GHC.Generics

data URec Int (p :: k) = UInt {

• uInt# :: Int#

}

newtype MVector s Int

Defined in Data.Vector.Unboxed.Base

newtype MVector s Int = MV_Int (MVector s Int)

type Rep1 (URec Int :: k -> Type)

Defined in GHC.Generics

type Rep1 (URec Int :: k -> Type) = D1 ('MetaData "URec" "GHC.Generics" "base" 'False) (C1 ('MetaCons "UInt" 'PrefixI 'True) (S1 ('MetaSel ('Just "uInt#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UInt :: k -> Type)))

type Item (Vector e)

Defined in Data.Array.Accelerate.Sugar.Array

type Item (Vector e) = e

type SliceShape (sl :. Int)

Defined in Data.Array.Accelerate.Sugar.Shape

type SliceShape (sl :. Int) = SliceShape sl

type CoSliceShape (sl :. Int)

Defined in Data.Array.Accelerate.Sugar.Shape

type CoSliceShape (sl :. Int) = CoSliceShape sl :. Int

type FullShape (sl :. Int)

Defined in Data.Array.Accelerate.Sugar.Shape

type FullShape (sl :. Int) = FullShape sl :. Int

type Plain (ix :. Int)

Defined in Data.Array.Accelerate.Lift

type Plain (ix :. Int) = Plain ix :. Int

type Rep (URec Int p)

Defined in GHC.Generics

type Rep (URec Int p) = D1 ('MetaData "URec" "GHC.Generics" "base" 'False) (C1 ('MetaCons "UInt" 'PrefixI 'True) (S1 ('MetaSel ('Just "uInt#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UInt :: Type -> Type)))

data Int8

8-bit signed integer type

Instances

Bounded Int8

Since: base-2.1

Defined in GHC.Int

Methods

minBound :: Int8

maxBound :: Int8

Enum Int8

Since: base-2.1

Defined in GHC.Int

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

Since: base-2.1

Defined in GHC.Int

Methods

(==) :: Int8 -> Int8 -> Bool

(/=) :: Int8 -> Int8 -> Bool

Integral Int8

Since: base-2.1

Defined in GHC.Int

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

Num Int8

Since: base-2.1

Defined in GHC.Int

Methods

(+) :: Int8 -> Int8 -> Int8

(-) :: Int8 -> Int8 -> Int8

(*) :: Int8 -> Int8 -> Int8

negate :: Int8 -> Int8

abs :: Int8 -> Int8

signum :: Int8 -> Int8

fromInteger :: Integer -> Int8

Ord Int8

Since: base-2.1

Defined in GHC.Int

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

Since: base-2.1

Defined in GHC.Int

Methods

readsPrec :: Int -> ReadS Int8

readList :: ReadS [Int8]

readPrec :: ReadPrec Int8

readListPrec :: ReadPrec [Int8]

Real Int8

Since: base-2.1

Defined in GHC.Int

Methods

toRational :: Int8 -> Rational

Show Int8

Since: base-2.1

Defined in GHC.Int

Methods

showsPrec :: Int -> Int8 -> ShowS

show :: Int8 -> String

showList :: [Int8] -> ShowS

Ix Int8

Since: base-2.1

Defined in GHC.Int

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

PrintfArg Int8

Since: base-2.1

Defined in Text.Printf

Methods

formatArg :: Int8 -> FieldFormatter

parseFormat :: Int8 -> ModifierParser

Storable Int8

Since: base-2.1

Defined in Foreign.Storable

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

Since: base-2.1

Defined in GHC.Int

Methods

(.&.) :: Int8 -> Int8 -> Int8

(.|.) :: Int8 -> Int8 -> Int8

xor :: Int8 -> Int8 -> Int8

complement :: Int8 -> Int8

shift :: Int8 -> Int -> Int8

rotate :: Int8 -> Int -> Int8

zeroBits :: Int8

bit :: Int -> Int8

setBit :: Int8 -> Int -> Int8

clearBit :: Int8 -> Int -> Int8

complementBit :: Int8 -> Int -> Int8

testBit :: Int8 -> Int -> Bool

bitSizeMaybe :: Int8 -> Maybe Int

bitSize :: Int8 -> Int

isSigned :: Int8 -> Bool

shiftL :: Int8 -> Int -> Int8

unsafeShiftL :: Int8 -> Int -> Int8

shiftR :: Int8 -> Int -> Int8

unsafeShiftR :: Int8 -> Int -> Int8

rotateL :: Int8 -> Int -> Int8

rotateR :: Int8 -> Int -> Int8

popCount :: Int8 -> Int

FiniteBits Int8

Since: base-4.6.0.0

Defined in GHC.Int

Methods

finiteBitSize :: Int8 -> Int

countLeadingZeros :: Int8 -> Int

countTrailingZeros :: Int8 -> Int

PrimType Int8

Defined in Basement.PrimType

Associated Types

type PrimSize Int8 :: Nat

Methods

primSizeInBytes :: Proxy Int8 -> CountOf Word8

primShiftToBytes :: Proxy Int8 -> Int

primBaUIndex :: ByteArray# -> Offset Int8 -> Int8

primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Int8 -> prim Int8

primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Int8 -> Int8 -> prim ()

primAddrIndex :: Addr# -> Offset Int8 -> Int8

primAddrRead :: PrimMonad prim => Addr# -> Offset Int8 -> prim Int8

primAddrWrite :: PrimMonad prim => Addr# -> Offset Int8 -> Int8 -> prim ()

PrimMemoryComparable Int8

Defined in Basement.PrimType

Subtractive Int8

Defined in Basement.Numerical.Subtractive

Associated Types

type Difference Int8

Methods

(-) :: Int8 -> Int8 -> Difference Int8

NFData Int8

Defined in Control.DeepSeq

Methods

rnf :: Int8 -> ()

Hashable Int8

Defined in Data.Hashable.Class

Methods

hashWithSalt :: Int -> Int8 -> Int

hash :: Int8 -> Int

Prim Int8

Defined in Data.Primitive.Types

Methods

sizeOf# :: Int8 -> Int#

alignment# :: Int8 -> Int#

indexByteArray# :: ByteArray# -> Int# -> Int8

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Int8 #)

writeByteArray# :: MutableByteArray# s -> Int# -> Int8 -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Int8 -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> Int8

readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Int8 #)

writeOffAddr# :: Addr# -> Int# -> Int8 -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> Int8 -> State# s -> State# s

Unbox Int8

Defined in Data.Vector.Unboxed.Base

Pretty Int8

Defined in Data.Text.Prettyprint.Doc.Internal

Methods

pretty :: Int8 -> Doc ann

prettyList :: [Int8] -> Doc ann

Pretty Int8

Defined in Text.PrettyPrint.Annotated.WL

Methods

pretty :: Int8 -> Doc b

prettyList :: [Int8] -> Doc b

Elt Int8

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR Int8

Methods

eltR :: TypeR (EltR Int8)

tagsR :: [TagR (EltR Int8)]

fromElt :: Int8 -> EltR Int8

toElt :: EltR Int8 -> Int8

Eq Int8

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp Int8 -> Exp Int8 -> Exp Bool

(/=) :: Exp Int8 -> Exp Int8 -> Exp Bool

Ord Int8

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp Int8 -> Exp Int8 -> Exp Bool

(>) :: Exp Int8 -> Exp Int8 -> Exp Bool

(<=) :: Exp Int8 -> Exp Int8 -> Exp Bool

(>=) :: Exp Int8 -> Exp Int8 -> Exp Bool

min :: Exp Int8 -> Exp Int8 -> Exp Int8

max :: Exp Int8 -> Exp Int8 -> Exp Int8

compare :: Exp Int8 -> Exp Int8 -> Exp Ordering

FiniteBits Int8

Defined in Data.Array.Accelerate.Data.Bits

Methods

finiteBitSize :: Exp Int8 -> Exp Int

countLeadingZeros :: Exp Int8 -> Exp Int

countTrailingZeros :: Exp Int8 -> Exp Int

Bits Int8

Defined in Data.Array.Accelerate.Data.Bits

Methods

(.&.) :: Exp Int8 -> Exp Int8 -> Exp Int8

(.|.) :: Exp Int8 -> Exp Int8 -> Exp Int8

xor :: Exp Int8 -> Exp Int8 -> Exp Int8

complement :: Exp Int8 -> Exp Int8

shift :: Exp Int8 -> Exp Int -> Exp Int8

rotate :: Exp Int8 -> Exp Int -> Exp Int8

zeroBits :: Exp Int8

bit :: Exp Int -> Exp Int8

setBit :: Exp Int8 -> Exp Int -> Exp Int8

clearBit :: Exp Int8 -> Exp Int -> Exp Int8

complementBit :: Exp Int8 -> Exp Int -> Exp Int8

testBit :: Exp Int8 -> Exp Int -> Exp Bool

isSigned :: Exp Int8 -> Exp Bool

shiftL :: Exp Int8 -> Exp Int -> Exp Int8

unsafeShiftL :: Exp Int8 -> Exp Int -> Exp Int8

shiftR :: Exp Int8 -> Exp Int -> Exp Int8

unsafeShiftR :: Exp Int8 -> Exp Int -> Exp Int8

rotateL :: Exp Int8 -> Exp Int -> Exp Int8

rotateR :: Exp Int8 -> Exp Int -> Exp Int8

popCount :: Exp Int8 -> Exp Int

Rational Int8

Defined in Data.Array.Accelerate.Classes.Rational

Methods

toRational :: (FromIntegral Int64 b, Integral b) => Exp Int8 -> Exp (Ratio b)

Lift Int8

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Int8 -> Q Exp

liftTyped :: Int8 -> Q (TExp Int8)

Vector Vector Int8

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Int8 -> m (Vector Int8)

basicUnsafeThaw :: PrimMonad m => Vector Int8 -> m (Mutable Vector (PrimState m) Int8)

basicLength :: Vector Int8 -> Int

basicUnsafeSlice :: Int -> Int -> Vector Int8 -> Vector Int8

basicUnsafeIndexM :: Monad m => Vector Int8 -> Int -> m Int8

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Int8 -> Vector Int8 -> m ()

elemseq :: Vector Int8 -> Int8 -> b -> b

MVector MVector Int8

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Int8 -> Int

basicUnsafeSlice :: Int -> Int -> MVector s Int8 -> MVector s Int8

basicOverlaps :: MVector s Int8 -> MVector s Int8 -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Int8)

basicInitialize :: PrimMonad m => MVector (PrimState m) Int8 -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Int8 -> m (MVector (PrimState m) Int8)

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Int8 -> Int -> m Int8

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Int8 -> Int -> Int8 -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) Int8 -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) Int8 -> Int8 -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Int8 -> MVector (PrimState m) Int8 -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Int8 -> MVector (PrimState m) Int8 -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Int8 -> Int -> m (MVector (PrimState m) Int8)

ToFloating Int8 Double

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Int8 -> Exp Double

ToFloating Int8 Float

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Int8 -> Exp Float

ToFloating Int8 Half

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Int8 -> Exp Half

Lift Exp Int8

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain Int8

Methods

lift :: Int8 -> Exp (Plain Int8)

FromIntegral Int Int8

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int -> Exp Int8

FromIntegral Int8 Double

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int8 -> Exp Double

FromIntegral Int8 Float

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int8 -> Exp Float

FromIntegral Int8 Int

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int8 -> Exp Int

FromIntegral Int8 Int8

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int8 -> Exp Int8

FromIntegral Int8 Int16

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int8 -> Exp Int16

FromIntegral Int8 Int32

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int8 -> Exp Int32

FromIntegral Int8 Int64

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int8 -> Exp Int64

FromIntegral Int8 Word

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int8 -> Exp Word

FromIntegral Int8 Word8

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int8 -> Exp Word8

FromIntegral Int8 Word16

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int8 -> Exp Word16

FromIntegral Int8 Word32

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int8 -> Exp Word32

FromIntegral Int8 Word64

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int8 -> Exp Word64

FromIntegral Int8 Half

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int8 -> Exp Half

FromIntegral Int16 Int8

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int16 -> Exp Int8

FromIntegral Int32 Int8

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int32 -> Exp Int8

FromIntegral Int64 Int8

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int64 -> Exp Int8

FromIntegral Word Int8

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word -> Exp Int8

FromIntegral Word8 Int8

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word8 -> Exp Int8

FromIntegral Word16 Int8

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word16 -> Exp Int8

FromIntegral Word32 Int8

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word32 -> Exp Int8

FromIntegral Word64 Int8

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word64 -> Exp Int8

Bounded (Exp Int8)

Defined in Data.Array.Accelerate.Classes.Bounded

Methods

minBound :: Exp Int8

maxBound :: Exp Int8

Enum (Exp Int8)

Defined in Data.Array.Accelerate.Classes.Enum

Methods

succ :: Exp Int8 -> Exp Int8

pred :: Exp Int8 -> Exp Int8

toEnum :: Int -> Exp Int8

fromEnum :: Exp Int8 -> Int

enumFrom :: Exp Int8 -> [Exp Int8]

enumFromThen :: Exp Int8 -> Exp Int8 -> [Exp Int8]

enumFromTo :: Exp Int8 -> Exp Int8 -> [Exp Int8]

enumFromThenTo :: Exp Int8 -> Exp Int8 -> Exp Int8 -> [Exp Int8]

Integral (Exp Int8)

Defined in Data.Array.Accelerate.Classes.Integral

Methods

quot :: Exp Int8 -> Exp Int8 -> Exp Int8

rem :: Exp Int8 -> Exp Int8 -> Exp Int8

div :: Exp Int8 -> Exp Int8 -> Exp Int8

mod :: Exp Int8 -> Exp Int8 -> Exp Int8

quotRem :: Exp Int8 -> Exp Int8 -> (Exp Int8, Exp Int8)

divMod :: Exp Int8 -> Exp Int8 -> (Exp Int8, Exp Int8)

toInteger :: Exp Int8 -> Integer

Num (Exp Int8)

Defined in Data.Array.Accelerate.Classes.Num

Methods

(+) :: Exp Int8 -> Exp Int8 -> Exp Int8

(-) :: Exp Int8 -> Exp Int8 -> Exp Int8

(*) :: Exp Int8 -> Exp Int8 -> Exp Int8

negate :: Exp Int8 -> Exp Int8

abs :: Exp Int8 -> Exp Int8

signum :: Exp Int8 -> Exp Int8

fromInteger :: Integer -> Exp Int8

type PrimSize Int8

Defined in Basement.PrimType

type PrimSize Int8 = 1

type Difference Int8

Defined in Basement.Numerical.Subtractive

type Difference Int8 = Int8

type NatNumMaxBound Int8

Defined in Basement.Nat

type NatNumMaxBound Int8 = 127

newtype Vector Int8

Defined in Data.Vector.Unboxed.Base

newtype Vector Int8 = V_Int8 (Vector Int8)

type Plain Int8

Defined in Data.Array.Accelerate.Lift

type Plain Int8 = Int8

newtype MVector s Int8

Defined in Data.Vector.Unboxed.Base

newtype MVector s Int8 = MV_Int8 (MVector s Int8)

data Int16

16-bit signed integer type

Instances

Bounded Int16

Since: base-2.1

Defined in GHC.Int

Methods

minBound :: Int16

maxBound :: Int16

Enum Int16

Since: base-2.1

Defined in GHC.Int

Methods

succ :: Int16 -> Int16

pred :: Int16 -> Int16

toEnum :: Int -> Int16

fromEnum :: Int16 -> Int

enumFrom :: Int16 -> [Int16]

enumFromThen :: Int16 -> Int16 -> [Int16]

enumFromTo :: Int16 -> Int16 -> [Int16]

enumFromThenTo :: Int16 -> Int16 -> Int16 -> [Int16]

Eq Int16

Since: base-2.1

Defined in GHC.Int

Methods

(==) :: Int16 -> Int16 -> Bool

(/=) :: Int16 -> Int16 -> Bool

Integral Int16

Since: base-2.1

Defined in GHC.Int

Methods

quot :: Int16 -> Int16 -> Int16

rem :: Int16 -> Int16 -> Int16

div :: Int16 -> Int16 -> Int16

mod :: Int16 -> Int16 -> Int16

quotRem :: Int16 -> Int16 -> (Int16, Int16)

divMod :: Int16 -> Int16 -> (Int16, Int16)

toInteger :: Int16 -> Integer

Num Int16

Since: base-2.1

Defined in GHC.Int

Methods

(+) :: Int16 -> Int16 -> Int16

(-) :: Int16 -> Int16 -> Int16

(*) :: Int16 -> Int16 -> Int16

negate :: Int16 -> Int16

abs :: Int16 -> Int16

signum :: Int16 -> Int16

fromInteger :: Integer -> Int16

Ord Int16

Since: base-2.1

Defined in GHC.Int

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

Since: base-2.1

Defined in GHC.Int

Methods

readsPrec :: Int -> ReadS Int16

readList :: ReadS [Int16]

readPrec :: ReadPrec Int16

readListPrec :: ReadPrec [Int16]

Real Int16

Since: base-2.1

Defined in GHC.Int

Methods

toRational :: Int16 -> Rational

Show Int16

Since: base-2.1

Defined in GHC.Int

Methods

showsPrec :: Int -> Int16 -> ShowS

show :: Int16 -> String

showList :: [Int16] -> ShowS

Ix Int16

Since: base-2.1

Defined in GHC.Int

Methods

range :: (Int16, Int16) -> [Int16]

index :: (Int16, Int16) -> Int16 -> Int

unsafeIndex :: (Int16, Int16) -> Int16 -> Int

inRange :: (Int16, Int16) -> Int16 -> Bool

rangeSize :: (Int16, Int16) -> Int

unsafeRangeSize :: (Int16, Int16) -> Int

PrintfArg Int16

Since: base-2.1

Defined in Text.Printf

Methods

formatArg :: Int16 -> FieldFormatter

parseFormat :: Int16 -> ModifierParser

Storable Int16

Since: base-2.1

Defined in Foreign.Storable

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

Since: base-2.1

Defined in GHC.Int

Methods

(.&.) :: Int16 -> Int16 -> Int16

(.|.) :: Int16 -> Int16 -> Int16

xor :: Int16 -> Int16 -> Int16

complement :: Int16 -> Int16

shift :: Int16 -> Int -> Int16

rotate :: Int16 -> Int -> Int16

zeroBits :: Int16

bit :: Int -> Int16

setBit :: Int16 -> Int -> Int16

clearBit :: Int16 -> Int -> Int16

complementBit :: Int16 -> Int -> Int16

testBit :: Int16 -> Int -> Bool

bitSizeMaybe :: Int16 -> Maybe Int

bitSize :: Int16 -> Int

isSigned :: Int16 -> Bool

shiftL :: Int16 -> Int -> Int16

unsafeShiftL :: Int16 -> Int -> Int16

shiftR :: Int16 -> Int -> Int16

unsafeShiftR :: Int16 -> Int -> Int16

rotateL :: Int16 -> Int -> Int16

rotateR :: Int16 -> Int -> Int16

popCount :: Int16 -> Int

FiniteBits Int16

Since: base-4.6.0.0

Defined in GHC.Int

Methods

finiteBitSize :: Int16 -> Int

countLeadingZeros :: Int16 -> Int

countTrailingZeros :: Int16 -> Int

PrimType Int16

Defined in Basement.PrimType

Associated Types

type PrimSize Int16 :: Nat

Methods

primSizeInBytes :: Proxy Int16 -> CountOf Word8

primShiftToBytes :: Proxy Int16 -> Int

primBaUIndex :: ByteArray# -> Offset Int16 -> Int16

primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Int16 -> prim Int16

primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Int16 -> Int16 -> prim ()

primAddrIndex :: Addr# -> Offset Int16 -> Int16

primAddrRead :: PrimMonad prim => Addr# -> Offset Int16 -> prim Int16

primAddrWrite :: PrimMonad prim => Addr# -> Offset Int16 -> Int16 -> prim ()

PrimMemoryComparable Int16

Defined in Basement.PrimType

Subtractive Int16

Defined in Basement.Numerical.Subtractive

Associated Types

type Difference Int16

Methods

(-) :: Int16 -> Int16 -> Difference Int16

NFData Int16

Defined in Control.DeepSeq

Methods

rnf :: Int16 -> ()

Hashable Int16

Defined in Data.Hashable.Class

Methods

hashWithSalt :: Int -> Int16 -> Int

hash :: Int16 -> Int

Prim Int16

Defined in Data.Primitive.Types

Methods

sizeOf# :: Int16 -> Int#

alignment# :: Int16 -> Int#

indexByteArray# :: ByteArray# -> Int# -> Int16

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Int16 #)

writeByteArray# :: MutableByteArray# s -> Int# -> Int16 -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Int16 -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> Int16

readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Int16 #)

writeOffAddr# :: Addr# -> Int# -> Int16 -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> Int16 -> State# s -> State# s

Unbox Int16

Defined in Data.Vector.Unboxed.Base

Pretty Int16

Defined in Data.Text.Prettyprint.Doc.Internal

Methods

pretty :: Int16 -> Doc ann

prettyList :: [Int16] -> Doc ann

Pretty Int16

Defined in Text.PrettyPrint.Annotated.WL

Methods

pretty :: Int16 -> Doc b

prettyList :: [Int16] -> Doc b

Elt Int16

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR Int16

Methods

eltR :: TypeR (EltR Int16)

tagsR :: [TagR (EltR Int16)]

fromElt :: Int16 -> EltR Int16

toElt :: EltR Int16 -> Int16

Eq Int16

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp Int16 -> Exp Int16 -> Exp Bool

(/=) :: Exp Int16 -> Exp Int16 -> Exp Bool

Ord Int16

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp Int16 -> Exp Int16 -> Exp Bool

(>) :: Exp Int16 -> Exp Int16 -> Exp Bool

(<=) :: Exp Int16 -> Exp Int16 -> Exp Bool

(>=) :: Exp Int16 -> Exp Int16 -> Exp Bool

min :: Exp Int16 -> Exp Int16 -> Exp Int16

max :: Exp Int16 -> Exp Int16 -> Exp Int16

compare :: Exp Int16 -> Exp Int16 -> Exp Ordering

FiniteBits Int16

Defined in Data.Array.Accelerate.Data.Bits

Methods

finiteBitSize :: Exp Int16 -> Exp Int

countLeadingZeros :: Exp Int16 -> Exp Int

countTrailingZeros :: Exp Int16 -> Exp Int

Bits Int16

Defined in Data.Array.Accelerate.Data.Bits

Methods

(.&.) :: Exp Int16 -> Exp Int16 -> Exp Int16

(.|.) :: Exp Int16 -> Exp Int16 -> Exp Int16

xor :: Exp Int16 -> Exp Int16 -> Exp Int16

complement :: Exp Int16 -> Exp Int16

shift :: Exp Int16 -> Exp Int -> Exp Int16

rotate :: Exp Int16 -> Exp Int -> Exp Int16

zeroBits :: Exp Int16

bit :: Exp Int -> Exp Int16

setBit :: Exp Int16 -> Exp Int -> Exp Int16

clearBit :: Exp Int16 -> Exp Int -> Exp Int16

complementBit :: Exp Int16 -> Exp Int -> Exp Int16

testBit :: Exp Int16 -> Exp Int -> Exp Bool

isSigned :: Exp Int16 -> Exp Bool

shiftL :: Exp Int16 -> Exp Int -> Exp Int16

unsafeShiftL :: Exp Int16 -> Exp Int -> Exp Int16

shiftR :: Exp Int16 -> Exp Int -> Exp Int16

unsafeShiftR :: Exp Int16 -> Exp Int -> Exp Int16

rotateL :: Exp Int16 -> Exp Int -> Exp Int16

rotateR :: Exp Int16 -> Exp Int -> Exp Int16

popCount :: Exp Int16 -> Exp Int

Rational Int16

Defined in Data.Array.Accelerate.Classes.Rational

Methods

toRational :: (FromIntegral Int64 b, Integral b) => Exp Int16 -> Exp (Ratio b)

Lift Int16

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Int16 -> Q Exp

liftTyped :: Int16 -> Q (TExp Int16)

Vector Vector Int16

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Int16 -> m (Vector Int16)

basicUnsafeThaw :: PrimMonad m => Vector Int16 -> m (Mutable Vector (PrimState m) Int16)

basicLength :: Vector Int16 -> Int

basicUnsafeSlice :: Int -> Int -> Vector Int16 -> Vector Int16

basicUnsafeIndexM :: Monad m => Vector Int16 -> Int -> m Int16

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Int16 -> Vector Int16 -> m ()

elemseq :: Vector Int16 -> Int16 -> b -> b

MVector MVector Int16

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Int16 -> Int

basicUnsafeSlice :: Int -> Int -> MVector s Int16 -> MVector s Int16

basicOverlaps :: MVector s Int16 -> MVector s Int16 -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Int16)

basicInitialize :: PrimMonad m => MVector (PrimState m) Int16 -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Int16 -> m (MVector (PrimState m) Int16)

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Int16 -> Int -> m Int16

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Int16 -> Int -> Int16 -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) Int16 -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) Int16 -> Int16 -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Int16 -> MVector (PrimState m) Int16 -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Int16 -> MVector (PrimState m) Int16 -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Int16 -> Int -> m (MVector (PrimState m) Int16)

ToFloating Int16 Double

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Int16 -> Exp Double

ToFloating Int16 Float

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Int16 -> Exp Float

ToFloating Int16 Half

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Int16 -> Exp Half

Lift Exp Int16

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain Int16

Methods

lift :: Int16 -> Exp (Plain Int16)

FromIntegral Int Int16

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int -> Exp Int16

FromIntegral Int8 Int16

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int8 -> Exp Int16

FromIntegral Int16 Double

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int16 -> Exp Double

FromIntegral Int16 Float

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int16 -> Exp Float

FromIntegral Int16 Int

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int16 -> Exp Int

FromIntegral Int16 Int8

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int16 -> Exp Int8

FromIntegral Int16 Int16

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int16 -> Exp Int16

FromIntegral Int16 Int32

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int16 -> Exp Int32

FromIntegral Int16 Int64

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int16 -> Exp Int64

FromIntegral Int16 Word

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int16 -> Exp Word

FromIntegral Int16 Word8

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int16 -> Exp Word8

FromIntegral Int16 Word16

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int16 -> Exp Word16

FromIntegral Int16 Word32

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int16 -> Exp Word32

FromIntegral Int16 Word64

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int16 -> Exp Word64

FromIntegral Int16 Half

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int16 -> Exp Half

FromIntegral Int32 Int16

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int32 -> Exp Int16

FromIntegral Int64 Int16

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int64 -> Exp Int16

FromIntegral Word Int16

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word -> Exp Int16

FromIntegral Word8 Int16

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word8 -> Exp Int16

FromIntegral Word16 Int16

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word16 -> Exp Int16

FromIntegral Word32 Int16

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word32 -> Exp Int16

FromIntegral Word64 Int16

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word64 -> Exp Int16

Bounded (Exp Int16)

Defined in Data.Array.Accelerate.Classes.Bounded

Methods

minBound :: Exp Int16

maxBound :: Exp Int16

Enum (Exp Int16)

Defined in Data.Array.Accelerate.Classes.Enum

Methods

succ :: Exp Int16 -> Exp Int16

pred :: Exp Int16 -> Exp Int16

toEnum :: Int -> Exp Int16

fromEnum :: Exp Int16 -> Int

enumFrom :: Exp Int16 -> [Exp Int16]

enumFromThen :: Exp Int16 -> Exp Int16 -> [Exp Int16]

enumFromTo :: Exp Int16 -> Exp Int16 -> [Exp Int16]

enumFromThenTo :: Exp Int16 -> Exp Int16 -> Exp Int16 -> [Exp Int16]

Integral (Exp Int16)

Defined in Data.Array.Accelerate.Classes.Integral

Methods

quot :: Exp Int16 -> Exp Int16 -> Exp Int16

rem :: Exp Int16 -> Exp Int16 -> Exp Int16

div :: Exp Int16 -> Exp Int16 -> Exp Int16

mod :: Exp Int16 -> Exp Int16 -> Exp Int16

quotRem :: Exp Int16 -> Exp Int16 -> (Exp Int16, Exp Int16)

divMod :: Exp Int16 -> Exp Int16 -> (Exp Int16, Exp Int16)

toInteger :: Exp Int16 -> Integer

Num (Exp Int16)

Defined in Data.Array.Accelerate.Classes.Num

Methods

(+) :: Exp Int16 -> Exp Int16 -> Exp Int16

(-) :: Exp Int16 -> Exp Int16 -> Exp Int16

(*) :: Exp Int16 -> Exp Int16 -> Exp Int16

negate :: Exp Int16 -> Exp Int16

abs :: Exp Int16 -> Exp Int16

signum :: Exp Int16 -> Exp Int16

fromInteger :: Integer -> Exp Int16

type PrimSize Int16

Defined in Basement.PrimType

type PrimSize Int16 = 2

type Difference Int16

Defined in Basement.Numerical.Subtractive

type Difference Int16 = Int16

type NatNumMaxBound Int16

Defined in Basement.Nat

type NatNumMaxBound Int16 = 32767

newtype Vector Int16

Defined in Data.Vector.Unboxed.Base

newtype Vector Int16 = V_Int16 (Vector Int16)

type Plain Int16

Defined in Data.Array.Accelerate.Lift

type Plain Int16 = Int16

newtype MVector s Int16

Defined in Data.Vector.Unboxed.Base

newtype MVector s Int16 = MV_Int16 (MVector s Int16)

data Int32

32-bit signed integer type

Instances

Bounded Int32

Since: base-2.1

Defined in GHC.Int

Methods

minBound :: Int32

maxBound :: Int32

Enum Int32

Since: base-2.1

Defined in GHC.Int

Methods

succ :: Int32 -> Int32

pred :: Int32 -> Int32

toEnum :: Int -> Int32

fromEnum :: Int32 -> Int

enumFrom :: Int32 -> [Int32]

enumFromThen :: Int32 -> Int32 -> [Int32]

enumFromTo :: Int32 -> Int32 -> [Int32]

enumFromThenTo :: Int32 -> Int32 -> Int32 -> [Int32]

Eq Int32

Since: base-2.1

Defined in GHC.Int

Methods

(==) :: Int32 -> Int32 -> Bool

(/=) :: Int32 -> Int32 -> Bool

Integral Int32

Since: base-2.1

Defined in GHC.Int

Methods

quot :: Int32 -> Int32 -> Int32

rem :: Int32 -> Int32 -> Int32

div :: Int32 -> Int32 -> Int32

mod :: Int32 -> Int32 -> Int32

quotRem :: Int32 -> Int32 -> (Int32, Int32)

divMod :: Int32 -> Int32 -> (Int32, Int32)

toInteger :: Int32 -> Integer

Num Int32

Since: base-2.1

Defined in GHC.Int

Methods

(+) :: Int32 -> Int32 -> Int32

(-) :: Int32 -> Int32 -> Int32

(*) :: Int32 -> Int32 -> Int32

negate :: Int32 -> Int32

abs :: Int32 -> Int32

signum :: Int32 -> Int32

fromInteger :: Integer -> Int32

Ord Int32

Since: base-2.1

Defined in GHC.Int

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

Since: base-2.1

Defined in GHC.Int

Methods

readsPrec :: Int -> ReadS Int32

readList :: ReadS [Int32]

readPrec :: ReadPrec Int32

readListPrec :: ReadPrec [Int32]

Real Int32

Since: base-2.1

Defined in GHC.Int

Methods

toRational :: Int32 -> Rational

Show Int32

Since: base-2.1

Defined in GHC.Int

Methods

showsPrec :: Int -> Int32 -> ShowS

show :: Int32 -> String

showList :: [Int32] -> ShowS

Ix Int32

Since: base-2.1

Defined in GHC.Int

Methods

range :: (Int32, Int32) -> [Int32]

index :: (Int32, Int32) -> Int32 -> Int

unsafeIndex :: (Int32, Int32) -> Int32 -> Int

inRange :: (Int32, Int32) -> Int32 -> Bool

rangeSize :: (Int32, Int32) -> Int

unsafeRangeSize :: (Int32, Int32) -> Int

PrintfArg Int32

Since: base-2.1

Defined in Text.Printf

Methods

formatArg :: Int32 -> FieldFormatter

parseFormat :: Int32 -> ModifierParser

Storable Int32

Since: base-2.1

Defined in Foreign.Storable

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

Since: base-2.1

Defined in GHC.Int

Methods

(.&.) :: Int32 -> Int32 -> Int32

(.|.) :: Int32 -> Int32 -> Int32

xor :: Int32 -> Int32 -> Int32

complement :: Int32 -> Int32

shift :: Int32 -> Int -> Int32

rotate :: Int32 -> Int -> Int32

zeroBits :: Int32

bit :: Int -> Int32

setBit :: Int32 -> Int -> Int32

clearBit :: Int32 -> Int -> Int32

complementBit :: Int32 -> Int -> Int32

testBit :: Int32 -> Int -> Bool

bitSizeMaybe :: Int32 -> Maybe Int

bitSize :: Int32 -> Int

isSigned :: Int32 -> Bool

shiftL :: Int32 -> Int -> Int32

unsafeShiftL :: Int32 -> Int -> Int32

shiftR :: Int32 -> Int -> Int32

unsafeShiftR :: Int32 -> Int -> Int32

rotateL :: Int32 -> Int -> Int32

rotateR :: Int32 -> Int -> Int32

popCount :: Int32 -> Int

FiniteBits Int32

Since: base-4.6.0.0

Defined in GHC.Int

Methods

finiteBitSize :: Int32 -> Int

countLeadingZeros :: Int32 -> Int

countTrailingZeros :: Int32 -> Int

PrimType Int32

Defined in Basement.PrimType

Associated Types

type PrimSize Int32 :: Nat

Methods

primSizeInBytes :: Proxy Int32 -> CountOf Word8

primShiftToBytes :: Proxy Int32 -> Int

primBaUIndex :: ByteArray# -> Offset Int32 -> Int32

primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Int32 -> prim Int32

primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Int32 -> Int32 -> prim ()

primAddrIndex :: Addr# -> Offset Int32 -> Int32

primAddrRead :: PrimMonad prim => Addr# -> Offset Int32 -> prim Int32

primAddrWrite :: PrimMonad prim => Addr# -> Offset Int32 -> Int32 -> prim ()

PrimMemoryComparable Int32

Defined in Basement.PrimType

Subtractive Int32

Defined in Basement.Numerical.Subtractive

Associated Types

type Difference Int32

Methods

(-) :: Int32 -> Int32 -> Difference Int32

NFData Int32

Defined in Control.DeepSeq

Methods

rnf :: Int32 -> ()

Hashable Int32

Defined in Data.Hashable.Class

Methods

hashWithSalt :: Int -> Int32 -> Int

hash :: Int32 -> Int

Prim Int32

Defined in Data.Primitive.Types

Methods

sizeOf# :: Int32 -> Int#

alignment# :: Int32 -> Int#

indexByteArray# :: ByteArray# -> Int# -> Int32

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Int32 #)

writeByteArray# :: MutableByteArray# s -> Int# -> Int32 -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Int32 -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> Int32

readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Int32 #)

writeOffAddr# :: Addr# -> Int# -> Int32 -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> Int32 -> State# s -> State# s

Unbox Int32

Defined in Data.Vector.Unboxed.Base

Pretty Int32

Defined in Data.Text.Prettyprint.Doc.Internal

Methods

pretty :: Int32 -> Doc ann

prettyList :: [Int32] -> Doc ann

Pretty Int32

Defined in Text.PrettyPrint.Annotated.WL

Methods

pretty :: Int32 -> Doc b

prettyList :: [Int32] -> Doc b

Elt Int32

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR Int32

Methods

eltR :: TypeR (EltR Int32)

tagsR :: [TagR (EltR Int32)]

fromElt :: Int32 -> EltR Int32

toElt :: EltR Int32 -> Int32

Eq Int32

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp Int32 -> Exp Int32 -> Exp Bool

(/=) :: Exp Int32 -> Exp Int32 -> Exp Bool

Ord Int32

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp Int32 -> Exp Int32 -> Exp Bool

(>) :: Exp Int32 -> Exp Int32 -> Exp Bool

(<=) :: Exp Int32 -> Exp Int32 -> Exp Bool

(>=) :: Exp Int32 -> Exp Int32 -> Exp Bool

min :: Exp Int32 -> Exp Int32 -> Exp Int32

max :: Exp Int32 -> Exp Int32 -> Exp Int32

compare :: Exp Int32 -> Exp Int32 -> Exp Ordering

FiniteBits Int32

Defined in Data.Array.Accelerate.Data.Bits

Methods

finiteBitSize :: Exp Int32 -> Exp Int

countLeadingZeros :: Exp Int32 -> Exp Int

countTrailingZeros :: Exp Int32 -> Exp Int

Bits Int32

Defined in Data.Array.Accelerate.Data.Bits

Methods

(.&.) :: Exp Int32 -> Exp Int32 -> Exp Int32

(.|.) :: Exp Int32 -> Exp Int32 -> Exp Int32

xor :: Exp Int32 -> Exp Int32 -> Exp Int32

complement :: Exp Int32 -> Exp Int32

shift :: Exp Int32 -> Exp Int -> Exp Int32

rotate :: Exp Int32 -> Exp Int -> Exp Int32

zeroBits :: Exp Int32

bit :: Exp Int -> Exp Int32

setBit :: Exp Int32 -> Exp Int -> Exp Int32

clearBit :: Exp Int32 -> Exp Int -> Exp Int32

complementBit :: Exp Int32 -> Exp Int -> Exp Int32

testBit :: Exp Int32 -> Exp Int -> Exp Bool

isSigned :: Exp Int32 -> Exp Bool

shiftL :: Exp Int32 -> Exp Int -> Exp Int32

unsafeShiftL :: Exp Int32 -> Exp Int -> Exp Int32

shiftR :: Exp Int32 -> Exp Int -> Exp Int32

unsafeShiftR :: Exp Int32 -> Exp Int -> Exp Int32

rotateL :: Exp Int32 -> Exp Int -> Exp Int32

rotateR :: Exp Int32 -> Exp Int -> Exp Int32

popCount :: Exp Int32 -> Exp Int

Rational Int32

Defined in Data.Array.Accelerate.Classes.Rational

Methods

toRational :: (FromIntegral Int64 b, Integral b) => Exp Int32 -> Exp (Ratio b)

Lift Int32

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Int32 -> Q Exp

liftTyped :: Int32 -> Q (TExp Int32)

Vector Vector Int32

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Int32 -> m (Vector Int32)

basicUnsafeThaw :: PrimMonad m => Vector Int32 -> m (Mutable Vector (PrimState m) Int32)

basicLength :: Vector Int32 -> Int

basicUnsafeSlice :: Int -> Int -> Vector Int32 -> Vector Int32

basicUnsafeIndexM :: Monad m => Vector Int32 -> Int -> m Int32

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Int32 -> Vector Int32 -> m ()

elemseq :: Vector Int32 -> Int32 -> b -> b

MVector MVector Int32

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Int32 -> Int

basicUnsafeSlice :: Int -> Int -> MVector s Int32 -> MVector s Int32

basicOverlaps :: MVector s Int32 -> MVector s Int32 -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Int32)

basicInitialize :: PrimMonad m => MVector (PrimState m) Int32 -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Int32 -> m (MVector (PrimState m) Int32)

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Int32 -> Int -> m Int32

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Int32 -> Int -> Int32 -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) Int32 -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) Int32 -> Int32 -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Int32 -> MVector (PrimState m) Int32 -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Int32 -> MVector (PrimState m) Int32 -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Int32 -> Int -> m (MVector (PrimState m) Int32)

ToFloating Int32 Double

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Int32 -> Exp Double

ToFloating Int32 Float

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Int32 -> Exp Float

ToFloating Int32 Half

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Int32 -> Exp Half

Lift Exp Int32

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain Int32

Methods

lift :: Int32 -> Exp (Plain Int32)

FromIntegral Int Int32

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int -> Exp Int32

FromIntegral Int8 Int32

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int8 -> Exp Int32

FromIntegral Int16 Int32

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int16 -> Exp Int32

FromIntegral Int32 Double

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int32 -> Exp Double

FromIntegral Int32 Float

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int32 -> Exp Float

FromIntegral Int32 Int

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int32 -> Exp Int

FromIntegral Int32 Int8

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int32 -> Exp Int8

FromIntegral Int32 Int16

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int32 -> Exp Int16

FromIntegral Int32 Int32

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int32 -> Exp Int32

FromIntegral Int32 Int64

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int32 -> Exp Int64

FromIntegral Int32 Word

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int32 -> Exp Word

FromIntegral Int32 Word8

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int32 -> Exp Word8

FromIntegral Int32 Word16

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int32 -> Exp Word16

FromIntegral Int32 Word32

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int32 -> Exp Word32

FromIntegral Int32 Word64

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int32 -> Exp Word64

FromIntegral Int32 Half

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int32 -> Exp Half

FromIntegral Int64 Int32

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int64 -> Exp Int32

FromIntegral Word Int32

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word -> Exp Int32

FromIntegral Word8 Int32

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word8 -> Exp Int32

FromIntegral Word16 Int32

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word16 -> Exp Int32

FromIntegral Word32 Int32

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word32 -> Exp Int32

FromIntegral Word64 Int32

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word64 -> Exp Int32

Bounded (Exp Int32)

Defined in Data.Array.Accelerate.Classes.Bounded

Methods

minBound :: Exp Int32

maxBound :: Exp Int32

Enum (Exp Int32)

Defined in Data.Array.Accelerate.Classes.Enum

Methods

succ :: Exp Int32 -> Exp Int32

pred :: Exp Int32 -> Exp Int32

toEnum :: Int -> Exp Int32

fromEnum :: Exp Int32 -> Int

enumFrom :: Exp Int32 -> [Exp Int32]

enumFromThen :: Exp Int32 -> Exp Int32 -> [Exp Int32]

enumFromTo :: Exp Int32 -> Exp Int32 -> [Exp Int32]

enumFromThenTo :: Exp Int32 -> Exp Int32 -> Exp Int32 -> [Exp Int32]

Integral (Exp Int32)

Defined in Data.Array.Accelerate.Classes.Integral

Methods

quot :: Exp Int32 -> Exp Int32 -> Exp Int32

rem :: Exp Int32 -> Exp Int32 -> Exp Int32

div :: Exp Int32 -> Exp Int32 -> Exp Int32

mod :: Exp Int32 -> Exp Int32 -> Exp Int32

quotRem :: Exp Int32 -> Exp Int32 -> (Exp Int32, Exp Int32)

divMod :: Exp Int32 -> Exp Int32 -> (Exp Int32, Exp Int32)

toInteger :: Exp Int32 -> Integer

Num (Exp Int32)

Defined in Data.Array.Accelerate.Classes.Num

Methods

(+) :: Exp Int32 -> Exp Int32 -> Exp Int32

(-) :: Exp Int32 -> Exp Int32 -> Exp Int32

(*) :: Exp Int32 -> Exp Int32 -> Exp Int32

negate :: Exp Int32 -> Exp Int32

abs :: Exp Int32 -> Exp Int32

signum :: Exp Int32 -> Exp Int32

fromInteger :: Integer -> Exp Int32

type PrimSize Int32

Defined in Basement.PrimType

type PrimSize Int32 = 4

type Difference Int32

Defined in Basement.Numerical.Subtractive

type Difference Int32 = Int32

type NatNumMaxBound Int32

Defined in Basement.Nat

type NatNumMaxBound Int32 = 2147483647

newtype Vector Int32

Defined in Data.Vector.Unboxed.Base

newtype Vector Int32 = V_Int32 (Vector Int32)

type Plain Int32

Defined in Data.Array.Accelerate.Lift

type Plain Int32 = Int32

newtype MVector s Int32

Defined in Data.Vector.Unboxed.Base

newtype MVector s Int32 = MV_Int32 (MVector s Int32)

data Int64

64-bit signed integer type

Instances

Bounded Int64

Since: base-2.1

Defined in GHC.Int

Methods

minBound :: Int64

maxBound :: Int64

Enum Int64

Since: base-2.1

Defined in GHC.Int

Methods

succ :: Int64 -> Int64

pred :: Int64 -> Int64

toEnum :: Int -> Int64

fromEnum :: Int64 -> Int

enumFrom :: Int64 -> [Int64]

enumFromThen :: Int64 -> Int64 -> [Int64]

enumFromTo :: Int64 -> Int64 -> [Int64]

enumFromThenTo :: Int64 -> Int64 -> Int64 -> [Int64]

Eq Int64

Since: base-2.1

Defined in GHC.Int

Methods

(==) :: Int64 -> Int64 -> Bool

(/=) :: Int64 -> Int64 -> Bool

Integral Int64

Since: base-2.1

Defined in GHC.Int

Methods

quot :: Int64 -> Int64 -> Int64

rem :: Int64 -> Int64 -> Int64

div :: Int64 -> Int64 -> Int64

mod :: Int64 -> Int64 -> Int64

quotRem :: Int64 -> Int64 -> (Int64, Int64)

divMod :: Int64 -> Int64 -> (Int64, Int64)

toInteger :: Int64 -> Integer

Num Int64

Since: base-2.1

Defined in GHC.Int

Methods

(+) :: Int64 -> Int64 -> Int64

(-) :: Int64 -> Int64 -> Int64

(*) :: Int64 -> Int64 -> Int64

negate :: Int64 -> Int64

abs :: Int64 -> Int64

signum :: Int64 -> Int64

fromInteger :: Integer -> Int64

Ord Int64

Since: base-2.1

Defined in GHC.Int

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

Since: base-2.1

Defined in GHC.Int

Methods

readsPrec :: Int -> ReadS Int64

readList :: ReadS [Int64]

readPrec :: ReadPrec Int64

readListPrec :: ReadPrec [Int64]

Real Int64

Since: base-2.1

Defined in GHC.Int

Methods

toRational :: Int64 -> Rational

Show Int64

Since: base-2.1

Defined in GHC.Int

Methods

showsPrec :: Int -> Int64 -> ShowS

show :: Int64 -> String

showList :: [Int64] -> ShowS

Ix Int64

Since: base-2.1

Defined in GHC.Int

Methods

range :: (Int64, Int64) -> [Int64]

index :: (Int64, Int64) -> Int64 -> Int

unsafeIndex :: (Int64, Int64) -> Int64 -> Int

inRange :: (Int64, Int64) -> Int64 -> Bool

rangeSize :: (Int64, Int64) -> Int

unsafeRangeSize :: (Int64, Int64) -> Int

PrintfArg Int64

Since: base-2.1

Defined in Text.Printf

Methods

formatArg :: Int64 -> FieldFormatter

parseFormat :: Int64 -> ModifierParser

Storable Int64

Since: base-2.1

Defined in Foreign.Storable

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

Since: base-2.1

Defined in GHC.Int

Methods

(.&.) :: Int64 -> Int64 -> Int64

(.|.) :: Int64 -> Int64 -> Int64

xor :: Int64 -> Int64 -> Int64

complement :: Int64 -> Int64

shift :: Int64 -> Int -> Int64

rotate :: Int64 -> Int -> Int64

zeroBits :: Int64

bit :: Int -> Int64

setBit :: Int64 -> Int -> Int64

clearBit :: Int64 -> Int -> Int64

complementBit :: Int64 -> Int -> Int64

testBit :: Int64 -> Int -> Bool

bitSizeMaybe :: Int64 -> Maybe Int

bitSize :: Int64 -> Int

isSigned :: Int64 -> Bool

shiftL :: Int64 -> Int -> Int64

unsafeShiftL :: Int64 -> Int -> Int64

shiftR :: Int64 -> Int -> Int64

unsafeShiftR :: Int64 -> Int -> Int64

rotateL :: Int64 -> Int -> Int64

rotateR :: Int64 -> Int -> Int64

popCount :: Int64 -> Int

FiniteBits Int64

Since: base-4.6.0.0

Defined in GHC.Int

Methods

finiteBitSize :: Int64 -> Int

countLeadingZeros :: Int64 -> Int

countTrailingZeros :: Int64 -> Int

PrimType Int64

Defined in Basement.PrimType

Associated Types

type PrimSize Int64 :: Nat

Methods

primSizeInBytes :: Proxy Int64 -> CountOf Word8

primShiftToBytes :: Proxy Int64 -> Int

primBaUIndex :: ByteArray# -> Offset Int64 -> Int64

primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Int64 -> prim Int64

primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Int64 -> Int64 -> prim ()

primAddrIndex :: Addr# -> Offset Int64 -> Int64

primAddrRead :: PrimMonad prim => Addr# -> Offset Int64 -> prim Int64

primAddrWrite :: PrimMonad prim => Addr# -> Offset Int64 -> Int64 -> prim ()

PrimMemoryComparable Int64

Defined in Basement.PrimType

Subtractive Int64

Defined in Basement.Numerical.Subtractive

Associated Types

type Difference Int64

Methods

(-) :: Int64 -> Int64 -> Difference Int64

NFData Int64

Defined in Control.DeepSeq

Methods

rnf :: Int64 -> ()

Hashable Int64

Defined in Data.Hashable.Class

Methods

hashWithSalt :: Int -> Int64 -> Int

hash :: Int64 -> Int

Prim Int64

Defined in Data.Primitive.Types

Methods

sizeOf# :: Int64 -> Int#

alignment# :: Int64 -> Int#

indexByteArray# :: ByteArray# -> Int# -> Int64

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Int64 #)

writeByteArray# :: MutableByteArray# s -> Int# -> Int64 -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Int64 -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> Int64

readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Int64 #)

writeOffAddr# :: Addr# -> Int# -> Int64 -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> Int64 -> State# s -> State# s

Unbox Int64

Defined in Data.Vector.Unboxed.Base

Pretty Int64

Defined in Data.Text.Prettyprint.Doc.Internal

Methods

pretty :: Int64 -> Doc ann

prettyList :: [Int64] -> Doc ann

Pretty Int64

Defined in Text.PrettyPrint.Annotated.WL

Methods

pretty :: Int64 -> Doc b

prettyList :: [Int64] -> Doc b

Elt Int64

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR Int64

Methods

eltR :: TypeR (EltR Int64)

tagsR :: [TagR (EltR Int64)]

fromElt :: Int64 -> EltR Int64

toElt :: EltR Int64 -> Int64

Eq Int64

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp Int64 -> Exp Int64 -> Exp Bool

(/=) :: Exp Int64 -> Exp Int64 -> Exp Bool

Ord Int64

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp Int64 -> Exp Int64 -> Exp Bool

(>) :: Exp Int64 -> Exp Int64 -> Exp Bool

(<=) :: Exp Int64 -> Exp Int64 -> Exp Bool

(>=) :: Exp Int64 -> Exp Int64 -> Exp Bool

min :: Exp Int64 -> Exp Int64 -> Exp Int64

max :: Exp Int64 -> Exp Int64 -> Exp Int64

compare :: Exp Int64 -> Exp Int64 -> Exp Ordering

FiniteBits Int64

Defined in Data.Array.Accelerate.Data.Bits

Methods

finiteBitSize :: Exp Int64 -> Exp Int

countLeadingZeros :: Exp Int64 -> Exp Int

countTrailingZeros :: Exp Int64 -> Exp Int

Bits Int64

Defined in Data.Array.Accelerate.Data.Bits

Methods

(.&.) :: Exp Int64 -> Exp Int64 -> Exp Int64

(.|.) :: Exp Int64 -> Exp Int64 -> Exp Int64

xor :: Exp Int64 -> Exp Int64 -> Exp Int64

complement :: Exp Int64 -> Exp Int64

shift :: Exp Int64 -> Exp Int -> Exp Int64

rotate :: Exp Int64 -> Exp Int -> Exp Int64

zeroBits :: Exp Int64

bit :: Exp Int -> Exp Int64

setBit :: Exp Int64 -> Exp Int -> Exp Int64

clearBit :: Exp Int64 -> Exp Int -> Exp Int64

complementBit :: Exp Int64 -> Exp Int -> Exp Int64

testBit :: Exp Int64 -> Exp Int -> Exp Bool

isSigned :: Exp Int64 -> Exp Bool

shiftL :: Exp Int64 -> Exp Int -> Exp Int64

unsafeShiftL :: Exp Int64 -> Exp Int -> Exp Int64

shiftR :: Exp Int64 -> Exp Int -> Exp Int64

unsafeShiftR :: Exp Int64 -> Exp Int -> Exp Int64

rotateL :: Exp Int64 -> Exp Int -> Exp Int64

rotateR :: Exp Int64 -> Exp Int -> Exp Int64

popCount :: Exp Int64 -> Exp Int

Rational Int64

Defined in Data.Array.Accelerate.Classes.Rational

Methods

toRational :: (FromIntegral Int64 b, Integral b) => Exp Int64 -> Exp (Ratio b)

Lift Int64

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Int64 -> Q Exp

liftTyped :: Int64 -> Q (TExp Int64)

Vector Vector Int64

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Int64 -> m (Vector Int64)

basicUnsafeThaw :: PrimMonad m => Vector Int64 -> m (Mutable Vector (PrimState m) Int64)

basicLength :: Vector Int64 -> Int

basicUnsafeSlice :: Int -> Int -> Vector Int64 -> Vector Int64

basicUnsafeIndexM :: Monad m => Vector Int64 -> Int -> m Int64

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Int64 -> Vector Int64 -> m ()

elemseq :: Vector Int64 -> Int64 -> b -> b

MVector MVector Int64

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Int64 -> Int

basicUnsafeSlice :: Int -> Int -> MVector s Int64 -> MVector s Int64

basicOverlaps :: MVector s Int64 -> MVector s Int64 -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Int64)

basicInitialize :: PrimMonad m => MVector (PrimState m) Int64 -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Int64 -> m (MVector (PrimState m) Int64)

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Int64 -> Int -> m Int64

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Int64 -> Int -> Int64 -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) Int64 -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) Int64 -> Int64 -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Int64 -> MVector (PrimState m) Int64 -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Int64 -> MVector (PrimState m) Int64 -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Int64 -> Int -> m (MVector (PrimState m) Int64)

ToFloating Int64 Double

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Int64 -> Exp Double

ToFloating Int64 Float

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Int64 -> Exp Float

ToFloating Int64 Half

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Int64 -> Exp Half

Lift Exp Int64

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain Int64

Methods

lift :: Int64 -> Exp (Plain Int64)

FromIntegral Int Int64

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int -> Exp Int64

FromIntegral Int8 Int64

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int8 -> Exp Int64

FromIntegral Int16 Int64

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int16 -> Exp Int64

FromIntegral Int32 Int64

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int32 -> Exp Int64

FromIntegral Int64 Double

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int64 -> Exp Double

FromIntegral Int64 Float

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int64 -> Exp Float

FromIntegral Int64 Int

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int64 -> Exp Int

FromIntegral Int64 Int8

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int64 -> Exp Int8

FromIntegral Int64 Int16

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int64 -> Exp Int16

FromIntegral Int64 Int32

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int64 -> Exp Int32

FromIntegral Int64 Int64

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int64 -> Exp Int64

FromIntegral Int64 Word

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int64 -> Exp Word

FromIntegral Int64 Word8

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int64 -> Exp Word8

FromIntegral Int64 Word16

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int64 -> Exp Word16

FromIntegral Int64 Word32

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int64 -> Exp Word32

FromIntegral Int64 Word64

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int64 -> Exp Word64

FromIntegral Int64 Half

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int64 -> Exp Half

FromIntegral Word Int64

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word -> Exp Int64

FromIntegral Word8 Int64

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word8 -> Exp Int64

FromIntegral Word16 Int64

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word16 -> Exp Int64

FromIntegral Word32 Int64

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word32 -> Exp Int64

FromIntegral Word64 Int64

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word64 -> Exp Int64

Bounded (Exp Int64)

Defined in Data.Array.Accelerate.Classes.Bounded

Methods

minBound :: Exp Int64

maxBound :: Exp Int64

Enum (Exp Int64)

Defined in Data.Array.Accelerate.Classes.Enum

Methods

succ :: Exp Int64 -> Exp Int64

pred :: Exp Int64 -> Exp Int64

toEnum :: Int -> Exp Int64

fromEnum :: Exp Int64 -> Int

enumFrom :: Exp Int64 -> [Exp Int64]

enumFromThen :: Exp Int64 -> Exp Int64 -> [Exp Int64]

enumFromTo :: Exp Int64 -> Exp Int64 -> [Exp Int64]

enumFromThenTo :: Exp Int64 -> Exp Int64 -> Exp Int64 -> [Exp Int64]

Integral (Exp Int64)

Defined in Data.Array.Accelerate.Classes.Integral

Methods

quot :: Exp Int64 -> Exp Int64 -> Exp Int64

rem :: Exp Int64 -> Exp Int64 -> Exp Int64

div :: Exp Int64 -> Exp Int64 -> Exp Int64

mod :: Exp Int64 -> Exp Int64 -> Exp Int64

quotRem :: Exp Int64 -> Exp Int64 -> (Exp Int64, Exp Int64)

divMod :: Exp Int64 -> Exp Int64 -> (Exp Int64, Exp Int64)

toInteger :: Exp Int64 -> Integer

Num (Exp Int64)

Defined in Data.Array.Accelerate.Classes.Num

Methods

(+) :: Exp Int64 -> Exp Int64 -> Exp Int64

(-) :: Exp Int64 -> Exp Int64 -> Exp Int64

(*) :: Exp Int64 -> Exp Int64 -> Exp Int64

negate :: Exp Int64 -> Exp Int64

abs :: Exp Int64 -> Exp Int64

signum :: Exp Int64 -> Exp Int64

fromInteger :: Integer -> Exp Int64

type PrimSize Int64

Defined in Basement.PrimType

type PrimSize Int64 = 8

type Difference Int64

Defined in Basement.Numerical.Subtractive

type Difference Int64 = Int64

type NatNumMaxBound Int64

Defined in Basement.Nat

type NatNumMaxBound Int64 = 9223372036854775807

newtype Vector Int64

Defined in Data.Vector.Unboxed.Base

newtype Vector Int64 = V_Int64 (Vector Int64)

type Plain Int64

Defined in Data.Array.Accelerate.Lift

type Plain Int64 = Int64

newtype MVector s Int64

Defined in Data.Vector.Unboxed.Base

newtype MVector s Int64 = MV_Int64 (MVector s Int64)

data Word

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

Instances

Bounded Word

Since: base-2.1

Defined in GHC.Enum

Methods

minBound :: Word

maxBound :: Word

Enum Word

Since: base-2.1

Defined in GHC.Enum

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

Defined in GHC.Classes

Methods

(==) :: Word -> Word -> Bool

(/=) :: Word -> Word -> Bool

Integral Word

Since: base-2.1

Defined in GHC.Real

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

Num Word

Since: base-2.1

Defined in GHC.Num

Methods

(+) :: Word -> Word -> Word

(-) :: Word -> Word -> Word

(*) :: Word -> Word -> Word

negate :: Word -> Word

abs :: Word -> Word

signum :: Word -> Word

fromInteger :: Integer -> Word

Ord Word

Defined in GHC.Classes

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

Read Word

Since: base-4.5.0.0

Defined in GHC.Read

Methods

readsPrec :: Int -> ReadS Word

readList :: ReadS [Word]

readPrec :: ReadPrec Word

readListPrec :: ReadPrec [Word]

Real Word

Since: base-2.1

Defined in GHC.Real

Methods

toRational :: Word -> Rational

Show Word

Since: base-2.1

Defined in GHC.Show

Methods

showsPrec :: Int -> Word -> ShowS

show :: Word -> String

showList :: [Word] -> ShowS

Ix Word

Since: base-4.6.0.0

Defined in GHC.Ix

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

PrintfArg Word

Since: base-2.1

Defined in Text.Printf

Methods

formatArg :: Word -> FieldFormatter

parseFormat :: Word -> ModifierParser

Storable Word

Since: base-2.1

Defined in Foreign.Storable

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

Since: base-2.1

Defined in Data.Bits

Methods

(.&.) :: Word -> Word -> Word

(.|.) :: Word -> Word -> Word

xor :: Word -> Word -> Word

complement :: Word -> Word

shift :: Word -> Int -> Word

rotate :: Word -> Int -> Word

zeroBits :: Word

bit :: Int -> Word

setBit :: Word -> Int -> Word

clearBit :: Word -> Int -> Word

complementBit :: Word -> Int -> Word

testBit :: Word -> Int -> Bool

bitSizeMaybe :: Word -> Maybe Int

bitSize :: Word -> Int

isSigned :: Word -> Bool

shiftL :: Word -> Int -> Word

unsafeShiftL :: Word -> Int -> Word

shiftR :: Word -> Int -> Word

unsafeShiftR :: Word -> Int -> Word

rotateL :: Word -> Int -> Word

rotateR :: Word -> Int -> Word

popCount :: Word -> Int

FiniteBits Word

Since: base-4.6.0.0

Defined in Data.Bits

Methods

finiteBitSize :: Word -> Int

countLeadingZeros :: Word -> Int

countTrailingZeros :: Word -> Int

PrimType Word

Defined in Basement.PrimType

Associated Types

type PrimSize Word :: Nat

Methods

primSizeInBytes :: Proxy Word -> CountOf Word8

primShiftToBytes :: Proxy Word -> Int

primBaUIndex :: ByteArray# -> Offset Word -> Word

primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Word -> prim Word

primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Word -> Word -> prim ()

primAddrIndex :: Addr# -> Offset Word -> Word

primAddrRead :: PrimMonad prim => Addr# -> Offset Word -> prim Word

primAddrWrite :: PrimMonad prim => Addr# -> Offset Word -> Word -> prim ()

PrimMemoryComparable Word

Defined in Basement.PrimType

Subtractive Word

Defined in Basement.Numerical.Subtractive

Associated Types

type Difference Word

Methods

(-) :: Word -> Word -> Difference Word

NFData Word

Defined in Control.DeepSeq

Methods

rnf :: Word -> ()

Hashable Word

Defined in Data.Hashable.Class

Methods

hashWithSalt :: Int -> Word -> Int

hash :: Word -> Int

Prim Word

Defined in Data.Primitive.Types

Methods

sizeOf# :: Word -> Int#

alignment# :: Word -> Int#

indexByteArray# :: ByteArray# -> Int# -> Word

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Word #)

writeByteArray# :: MutableByteArray# s -> Int# -> Word -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Word -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> Word

readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Word #)

writeOffAddr# :: Addr# -> Int# -> Word -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> Word -> State# s -> State# s

Unbox Word

Defined in Data.Vector.Unboxed.Base

Pretty Word

Defined in Data.Text.Prettyprint.Doc.Internal

Methods

pretty :: Word -> Doc ann

prettyList :: [Word] -> Doc ann

Pretty Word

Defined in Text.PrettyPrint.Annotated.WL

Methods

pretty :: Word -> Doc b

prettyList :: [Word] -> Doc b

Elt Word

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR Word

Methods

eltR :: TypeR (EltR Word)

tagsR :: [TagR (EltR Word)]

fromElt :: Word -> EltR Word

toElt :: EltR Word -> Word

Eq Word

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp Word -> Exp Word -> Exp Bool

(/=) :: Exp Word -> Exp Word -> Exp Bool

Ord Word

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp Word -> Exp Word -> Exp Bool

(>) :: Exp Word -> Exp Word -> Exp Bool

(<=) :: Exp Word -> Exp Word -> Exp Bool

(>=) :: Exp Word -> Exp Word -> Exp Bool

min :: Exp Word -> Exp Word -> Exp Word

max :: Exp Word -> Exp Word -> Exp Word

compare :: Exp Word -> Exp Word -> Exp Ordering

FiniteBits Word

Defined in Data.Array.Accelerate.Data.Bits

Methods

finiteBitSize :: Exp Word -> Exp Int

countLeadingZeros :: Exp Word -> Exp Int

countTrailingZeros :: Exp Word -> Exp Int

Bits Word

Defined in Data.Array.Accelerate.Data.Bits

Methods

(.&.) :: Exp Word -> Exp Word -> Exp Word

(.|.) :: Exp Word -> Exp Word -> Exp Word

xor :: Exp Word -> Exp Word -> Exp Word

complement :: Exp Word -> Exp Word

shift :: Exp Word -> Exp Int -> Exp Word

rotate :: Exp Word -> Exp Int -> Exp Word

zeroBits :: Exp Word

bit :: Exp Int -> Exp Word

setBit :: Exp Word -> Exp Int -> Exp Word

clearBit :: Exp Word -> Exp Int -> Exp Word

complementBit :: Exp Word -> Exp Int -> Exp Word

testBit :: Exp Word -> Exp Int -> Exp Bool

isSigned :: Exp Word -> Exp Bool

shiftL :: Exp Word -> Exp Int -> Exp Word

unsafeShiftL :: Exp Word -> Exp Int -> Exp Word

shiftR :: Exp Word -> Exp Int -> Exp Word

unsafeShiftR :: Exp Word -> Exp Int -> Exp Word

rotateL :: Exp Word -> Exp Int -> Exp Word

rotateR :: Exp Word -> Exp Int -> Exp Word

popCount :: Exp Word -> Exp Int

Rational Word

Defined in Data.Array.Accelerate.Classes.Rational

Methods

toRational :: (FromIntegral Int64 b, Integral b) => Exp Word -> Exp (Ratio b)

Lift Word

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Word -> Q Exp

liftTyped :: Word -> Q (TExp Word)

Vector Vector Word

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Word -> m (Vector Word)

basicUnsafeThaw :: PrimMonad m => Vector Word -> m (Mutable Vector (PrimState m) Word)

basicLength :: Vector Word -> Int

basicUnsafeSlice :: Int -> Int -> Vector Word -> Vector Word

basicUnsafeIndexM :: Monad m => Vector Word -> Int -> m Word

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Word -> Vector Word -> m ()

elemseq :: Vector Word -> Word -> b -> b

MVector MVector Word

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Word -> Int

basicUnsafeSlice :: Int -> Int -> MVector s Word -> MVector s Word

basicOverlaps :: MVector s Word -> MVector s Word -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Word)

basicInitialize :: PrimMonad m => MVector (PrimState m) Word -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Word -> m (MVector (PrimState m) Word)

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Word -> Int -> m Word

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Word -> Int -> Word -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) Word -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) Word -> Word -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Word -> MVector (PrimState m) Word -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Word -> MVector (PrimState m) Word -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Word -> Int -> m (MVector (PrimState m) Word)

ToFloating Word Double

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Word -> Exp Double

ToFloating Word Float

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Word -> Exp Float

ToFloating Word Half

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Word -> Exp Half

Lift Exp Word

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain Word

Methods

lift :: Word -> Exp (Plain Word)

FromIntegral Int Word

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int -> Exp Word

FromIntegral Int8 Word

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int8 -> Exp Word

FromIntegral Int16 Word

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int16 -> Exp Word

FromIntegral Int32 Word

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int32 -> Exp Word

FromIntegral Int64 Word

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int64 -> Exp Word

FromIntegral Word Double

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word -> Exp Double

FromIntegral Word Float

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word -> Exp Float

FromIntegral Word Int

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word -> Exp Int

FromIntegral Word Int8

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word -> Exp Int8

FromIntegral Word Int16

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word -> Exp Int16

FromIntegral Word Int32

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word -> Exp Int32

FromIntegral Word Int64

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word -> Exp Int64

FromIntegral Word Word

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word -> Exp Word

FromIntegral Word Word8

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word -> Exp Word8

FromIntegral Word Word16

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word -> Exp Word16

FromIntegral Word Word32

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word -> Exp Word32

FromIntegral Word Word64

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word -> Exp Word64

FromIntegral Word Half

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word -> Exp Half

FromIntegral Word8 Word

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word8 -> Exp Word

FromIntegral Word16 Word

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word16 -> Exp Word

FromIntegral Word32 Word

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word32 -> Exp Word

FromIntegral Word64 Word

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word64 -> Exp Word

Generic1 (URec Word :: k -> Type)

Since: base-4.9.0.0

Defined in GHC.Generics

Associated Types

type Rep1 (URec Word) :: k -> Type

Methods

from1 :: forall (a :: k0). URec Word a -> Rep1 (URec Word) a

to1 :: forall (a :: k0). Rep1 (URec Word) a -> URec Word a

Bounded (Exp Word)

Defined in Data.Array.Accelerate.Classes.Bounded

Methods

minBound :: Exp Word

maxBound :: Exp Word

Enum (Exp Word)

Defined in Data.Array.Accelerate.Classes.Enum

Methods

succ :: Exp Word -> Exp Word

pred :: Exp Word -> Exp Word

toEnum :: Int -> Exp Word

fromEnum :: Exp Word -> Int

enumFrom :: Exp Word -> [Exp Word]

enumFromThen :: Exp Word -> Exp Word -> [Exp Word]

enumFromTo :: Exp Word -> Exp Word -> [Exp Word]

enumFromThenTo :: Exp Word -> Exp Word -> Exp Word -> [Exp Word]

Integral (Exp Word)

Defined in Data.Array.Accelerate.Classes.Integral

Methods

quot :: Exp Word -> Exp Word -> Exp Word

rem :: Exp Word -> Exp Word -> Exp Word

div :: Exp Word -> Exp Word -> Exp Word

mod :: Exp Word -> Exp Word -> Exp Word

quotRem :: Exp Word -> Exp Word -> (Exp Word, Exp Word)

divMod :: Exp Word -> Exp Word -> (Exp Word, Exp Word)

toInteger :: Exp Word -> Integer

Num (Exp Word)

Defined in Data.Array.Accelerate.Classes.Num

Methods

(+) :: Exp Word -> Exp Word -> Exp Word

(-) :: Exp Word -> Exp Word -> Exp Word

(*) :: Exp Word -> Exp Word -> Exp Word

negate :: Exp Word -> Exp Word

abs :: Exp Word -> Exp Word

signum :: Exp Word -> Exp Word

fromInteger :: Integer -> Exp Word

Foldable (UWord :: Type -> Type)

Since: base-4.9.0.0

Defined in Data.Foldable

Methods

fold :: Monoid m => UWord m -> m

foldMap :: Monoid m => (a -> m) -> UWord a -> m

foldMap' :: Monoid m => (a -> m) -> UWord a -> m

foldr :: (a -> b -> b) -> b -> UWord a -> b

foldr' :: (a -> b -> b) -> b -> UWord a -> b

foldl :: (b -> a -> b) -> b -> UWord a -> b

foldl' :: (b -> a -> b) -> b -> UWord a -> b

foldr1 :: (a -> a -> a) -> UWord a -> a

foldl1 :: (a -> a -> a) -> UWord a -> a

toList :: UWord a -> [a]

null :: UWord a -> Bool

length :: UWord a -> Int

elem :: Eq a => a -> UWord a -> Bool

maximum :: Ord a => UWord a -> a

minimum :: Ord a => UWord a -> a

sum :: Num a => UWord a -> a

product :: Num a => UWord a -> a

Traversable (UWord :: Type -> Type)

Since: base-4.9.0.0

Defined in Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> UWord a -> f (UWord b)

sequenceA :: Applicative f => UWord (f a) -> f (UWord a)

mapM :: Monad m => (a -> m b) -> UWord a -> m (UWord b)

sequence :: Monad m => UWord (m a) -> m (UWord a)

Functor (URec Word :: Type -> Type)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> URec Word a -> URec Word b

(<$) :: a -> URec Word b -> URec Word a

Eq (URec Word p)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

(==) :: URec Word p -> URec Word p -> Bool

(/=) :: URec Word p -> URec Word p -> Bool

Ord (URec Word p)

Since: base-4.9.0.0

Defined in GHC.Generics

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)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

showsPrec :: Int -> URec Word p -> ShowS

show :: URec Word p -> String

showList :: [URec Word p] -> ShowS

Generic (URec Word p)

Since: base-4.9.0.0

Defined in GHC.Generics

Associated Types

type Rep (URec Word p) :: Type -> Type

Methods

from :: URec Word p -> Rep (URec Word p) x

to :: Rep (URec Word p) x -> URec Word p

type PrimSize Word

Defined in Basement.PrimType

type PrimSize Word = 8

type Difference Word

Defined in Basement.Numerical.Subtractive

type Difference Word = Word

type NatNumMaxBound Word

Defined in Basement.Nat

type NatNumMaxBound Word = NatNumMaxBound Word64

newtype Vector Word

Defined in Data.Vector.Unboxed.Base

newtype Vector Word = V_Word (Vector Word)

type Plain Word

Defined in Data.Array.Accelerate.Lift

type Plain Word = Word

data URec Word (p :: k)

Used for marking occurrences of Word#

Since: base-4.9.0.0

Defined in GHC.Generics

data URec Word (p :: k) = UWord {

• uWord# :: Word#

}

newtype MVector s Word

Defined in Data.Vector.Unboxed.Base

newtype MVector s Word = MV_Word (MVector s Word)

type Rep1 (URec Word :: k -> Type)

Defined in GHC.Generics

type Rep1 (URec Word :: k -> Type) = D1 ('MetaData "URec" "GHC.Generics" "base" 'False) (C1 ('MetaCons "UWord" 'PrefixI 'True) (S1 ('MetaSel ('Just "uWord#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UWord :: k -> Type)))

type Rep (URec Word p)

Defined in GHC.Generics

type Rep (URec Word p) = D1 ('MetaData "URec" "GHC.Generics" "base" 'False) (C1 ('MetaCons "UWord" 'PrefixI 'True) (S1 ('MetaSel ('Just "uWord#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UWord :: Type -> Type)))

data Word8

8-bit unsigned integer type

Instances

Bounded Word8

Since: base-2.1

Defined in GHC.Word

Methods

minBound :: Word8

maxBound :: Word8

Enum Word8

Since: base-2.1

Defined in GHC.Word

Methods

succ :: Word8 -> Word8

pred :: Word8 -> Word8

toEnum :: Int -> Word8

fromEnum :: Word8 -> Int

enumFrom :: Word8 -> [Word8]

enumFromThen :: Word8 -> Word8 -> [Word8]

enumFromTo :: Word8 -> Word8 -> [Word8]

enumFromThenTo :: Word8 -> Word8 -> Word8 -> [Word8]

Eq Word8

Since: base-2.1

Defined in GHC.Word

Methods

(==) :: Word8 -> Word8 -> Bool

(/=) :: Word8 -> Word8 -> Bool

Integral Word8

Since: base-2.1

Defined in GHC.Word

Methods

quot :: Word8 -> Word8 -> Word8

rem :: Word8 -> Word8 -> Word8

div :: Word8 -> Word8 -> Word8

mod :: Word8 -> Word8 -> Word8

quotRem :: Word8 -> Word8 -> (Word8, Word8)

divMod :: Word8 -> Word8 -> (Word8, Word8)

toInteger :: Word8 -> Integer

Num Word8

Since: base-2.1

Defined in GHC.Word

Methods

(+) :: Word8 -> Word8 -> Word8

(-) :: Word8 -> Word8 -> Word8

(*) :: Word8 -> Word8 -> Word8

negate :: Word8 -> Word8

abs :: Word8 -> Word8

signum :: Word8 -> Word8

fromInteger :: Integer -> Word8

Ord Word8

Since: base-2.1

Defined in GHC.Word

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

Since: base-2.1

Defined in GHC.Read

Methods

readsPrec :: Int -> ReadS Word8

readList :: ReadS [Word8]

readPrec :: ReadPrec Word8

readListPrec :: ReadPrec [Word8]

Real Word8

Since: base-2.1

Defined in GHC.Word

Methods

toRational :: Word8 -> Rational

Show Word8

Since: base-2.1

Defined in GHC.Word

Methods

showsPrec :: Int -> Word8 -> ShowS

show :: Word8 -> String

showList :: [Word8] -> ShowS

Ix Word8

Since: base-2.1

Defined in GHC.Word

Methods

range :: (Word8, Word8) -> [Word8]

index :: (Word8, Word8) -> Word8 -> Int

unsafeIndex :: (Word8, Word8) -> Word8 -> Int

inRange :: (Word8, Word8) -> Word8 -> Bool

rangeSize :: (Word8, Word8) -> Int

unsafeRangeSize :: (Word8, Word8) -> Int

PrintfArg Word8

Since: base-2.1

Defined in Text.Printf

Methods

formatArg :: Word8 -> FieldFormatter

parseFormat :: Word8 -> ModifierParser

Storable Word8

Since: base-2.1

Defined in Foreign.Storable

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

Since: base-2.1

Defined in GHC.Word

Methods

(.&.) :: Word8 -> Word8 -> Word8

(.|.) :: Word8 -> Word8 -> Word8

xor :: Word8 -> Word8 -> Word8

complement :: Word8 -> Word8

shift :: Word8 -> Int -> Word8

rotate :: Word8 -> Int -> Word8

zeroBits :: Word8

bit :: Int -> Word8

setBit :: Word8 -> Int -> Word8

clearBit :: Word8 -> Int -> Word8

complementBit :: Word8 -> Int -> Word8

testBit :: Word8 -> Int -> Bool

bitSizeMaybe :: Word8 -> Maybe Int

bitSize :: Word8 -> Int

isSigned :: Word8 -> Bool

shiftL :: Word8 -> Int -> Word8

unsafeShiftL :: Word8 -> Int -> Word8

shiftR :: Word8 -> Int -> Word8

unsafeShiftR :: Word8 -> Int -> Word8

rotateL :: Word8 -> Int -> Word8

rotateR :: Word8 -> Int -> Word8

popCount :: Word8 -> Int

FiniteBits Word8

Since: base-4.6.0.0

Defined in GHC.Word

Methods

finiteBitSize :: Word8 -> Int

countLeadingZeros :: Word8 -> Int

countTrailingZeros :: Word8 -> Int

PrimType Word8

Defined in Basement.PrimType

Associated Types

type PrimSize Word8 :: Nat

Methods

primSizeInBytes :: Proxy Word8 -> CountOf Word8

primShiftToBytes :: Proxy Word8 -> Int

primBaUIndex :: ByteArray# -> Offset Word8 -> Word8

primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Word8 -> prim Word8

primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Word8 -> Word8 -> prim ()

primAddrIndex :: Addr# -> Offset Word8 -> Word8

primAddrRead :: PrimMonad prim => Addr# -> Offset Word8 -> prim Word8

primAddrWrite :: PrimMonad prim => Addr# -> Offset Word8 -> Word8 -> prim ()

PrimMemoryComparable Word8

Defined in Basement.PrimType

Subtractive Word8

Defined in Basement.Numerical.Subtractive

Associated Types

type Difference Word8

Methods

(-) :: Word8 -> Word8 -> Difference Word8

NFData Word8

Defined in Control.DeepSeq

Methods

rnf :: Word8 -> ()

Hashable Word8

Defined in Data.Hashable.Class

Methods

hashWithSalt :: Int -> Word8 -> Int

hash :: Word8 -> Int

Prim Word8

Defined in Data.Primitive.Types

Methods

sizeOf# :: Word8 -> Int#

alignment# :: Word8 -> Int#

indexByteArray# :: ByteArray# -> Int# -> Word8

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Word8 #)

writeByteArray# :: MutableByteArray# s -> Int# -> Word8 -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Word8 -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> Word8

readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Word8 #)

writeOffAddr# :: Addr# -> Int# -> Word8 -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> Word8 -> State# s -> State# s

Unbox Word8

Defined in Data.Vector.Unboxed.Base

Pretty Word8

Defined in Data.Text.Prettyprint.Doc.Internal

Methods

pretty :: Word8 -> Doc ann

prettyList :: [Word8] -> Doc ann

Pretty Word8

Defined in Text.PrettyPrint.Annotated.WL

Methods

pretty :: Word8 -> Doc b

prettyList :: [Word8] -> Doc b

Elt Word8

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR Word8

Methods

eltR :: TypeR (EltR Word8)

tagsR :: [TagR (EltR Word8)]

fromElt :: Word8 -> EltR Word8

toElt :: EltR Word8 -> Word8

Eq Word8

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp Word8 -> Exp Word8 -> Exp Bool

(/=) :: Exp Word8 -> Exp Word8 -> Exp Bool

Ord Word8

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp Word8 -> Exp Word8 -> Exp Bool

(>) :: Exp Word8 -> Exp Word8 -> Exp Bool

(<=) :: Exp Word8 -> Exp Word8 -> Exp Bool

(>=) :: Exp Word8 -> Exp Word8 -> Exp Bool

min :: Exp Word8 -> Exp Word8 -> Exp Word8

max :: Exp Word8 -> Exp Word8 -> Exp Word8

compare :: Exp Word8 -> Exp Word8 -> Exp Ordering

FiniteBits Word8

Defined in Data.Array.Accelerate.Data.Bits

Methods

finiteBitSize :: Exp Word8 -> Exp Int

countLeadingZeros :: Exp Word8 -> Exp Int

countTrailingZeros :: Exp Word8 -> Exp Int

Bits Word8

Defined in Data.Array.Accelerate.Data.Bits

Methods

(.&.) :: Exp Word8 -> Exp Word8 -> Exp Word8

(.|.) :: Exp Word8 -> Exp Word8 -> Exp Word8

xor :: Exp Word8 -> Exp Word8 -> Exp Word8

complement :: Exp Word8 -> Exp Word8

shift :: Exp Word8 -> Exp Int -> Exp Word8

rotate :: Exp Word8 -> Exp Int -> Exp Word8

zeroBits :: Exp Word8

bit :: Exp Int -> Exp Word8

setBit :: Exp Word8 -> Exp Int -> Exp Word8

clearBit :: Exp Word8 -> Exp Int -> Exp Word8

complementBit :: Exp Word8 -> Exp Int -> Exp Word8

testBit :: Exp Word8 -> Exp Int -> Exp Bool

isSigned :: Exp Word8 -> Exp Bool

shiftL :: Exp Word8 -> Exp Int -> Exp Word8

unsafeShiftL :: Exp Word8 -> Exp Int -> Exp Word8

shiftR :: Exp Word8 -> Exp Int -> Exp Word8

unsafeShiftR :: Exp Word8 -> Exp Int -> Exp Word8

rotateL :: Exp Word8 -> Exp Int -> Exp Word8

rotateR :: Exp Word8 -> Exp Int -> Exp Word8

popCount :: Exp Word8 -> Exp Int

Rational Word8

Defined in Data.Array.Accelerate.Classes.Rational

Methods

toRational :: (FromIntegral Int64 b, Integral b) => Exp Word8 -> Exp (Ratio b)

Lift Word8

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Word8 -> Q Exp

liftTyped :: Word8 -> Q (TExp Word8)

Vector Vector Word8

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Word8 -> m (Vector Word8)

basicUnsafeThaw :: PrimMonad m => Vector Word8 -> m (Mutable Vector (PrimState m) Word8)

basicLength :: Vector Word8 -> Int

basicUnsafeSlice :: Int -> Int -> Vector Word8 -> Vector Word8

basicUnsafeIndexM :: Monad m => Vector Word8 -> Int -> m Word8

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Word8 -> Vector Word8 -> m ()

elemseq :: Vector Word8 -> Word8 -> b -> b

MVector MVector Word8

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Word8 -> Int

basicUnsafeSlice :: Int -> Int -> MVector s Word8 -> MVector s Word8

basicOverlaps :: MVector s Word8 -> MVector s Word8 -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Word8)

basicInitialize :: PrimMonad m => MVector (PrimState m) Word8 -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Word8 -> m (MVector (PrimState m) Word8)

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Word8 -> Int -> m Word8

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Word8 -> Int -> Word8 -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) Word8 -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) Word8 -> Word8 -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Word8 -> MVector (PrimState m) Word8 -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Word8 -> MVector (PrimState m) Word8 -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Word8 -> Int -> m (MVector (PrimState m) Word8)

ToFloating Word8 Double

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Word8 -> Exp Double

ToFloating Word8 Float

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Word8 -> Exp Float

ToFloating Word8 Half

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Word8 -> Exp Half

Lift Exp Word8

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain Word8

Methods

lift :: Word8 -> Exp (Plain Word8)

FromIntegral Int Word8

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int -> Exp Word8

FromIntegral Int8 Word8

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int8 -> Exp Word8

FromIntegral Int16 Word8

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int16 -> Exp Word8

FromIntegral Int32 Word8

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int32 -> Exp Word8

FromIntegral Int64 Word8

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int64 -> Exp Word8

FromIntegral Word Word8

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word -> Exp Word8

FromIntegral Word8 Double

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word8 -> Exp Double

FromIntegral Word8 Float

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word8 -> Exp Float

FromIntegral Word8 Int

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word8 -> Exp Int

FromIntegral Word8 Int8

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word8 -> Exp Int8

FromIntegral Word8 Int16

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word8 -> Exp Int16

FromIntegral Word8 Int32

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word8 -> Exp Int32

FromIntegral Word8 Int64

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word8 -> Exp Int64

FromIntegral Word8 Word

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word8 -> Exp Word

FromIntegral Word8 Word8

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word8 -> Exp Word8

FromIntegral Word8 Word16

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word8 -> Exp Word16

FromIntegral Word8 Word32

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word8 -> Exp Word32

FromIntegral Word8 Word64

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word8 -> Exp Word64

FromIntegral Word8 Half

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word8 -> Exp Half

FromIntegral Word16 Word8

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word16 -> Exp Word8

FromIntegral Word32 Word8

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word32 -> Exp Word8

FromIntegral Word64 Word8

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word64 -> Exp Word8

Cons ByteString ByteString Word8 Word8

Defined in Control.Lens.Cons

Methods

_Cons :: Prism ByteString ByteString (Word8, ByteString) (Word8, ByteString)

Cons ByteString ByteString Word8 Word8

Defined in Control.Lens.Cons

Methods

_Cons :: Prism ByteString ByteString (Word8, ByteString) (Word8, ByteString)

Snoc ByteString ByteString Word8 Word8

Defined in Control.Lens.Cons

Methods

_Snoc :: Prism ByteString ByteString (ByteString, Word8) (ByteString, Word8)

Snoc ByteString ByteString Word8 Word8

Defined in Control.Lens.Cons

Methods

_Snoc :: Prism ByteString ByteString (ByteString, Word8) (ByteString, Word8)

Bounded (Exp Word8)

Defined in Data.Array.Accelerate.Classes.Bounded

Methods

minBound :: Exp Word8

maxBound :: Exp Word8

Enum (Exp Word8)

Defined in Data.Array.Accelerate.Classes.Enum

Methods

succ :: Exp Word8 -> Exp Word8

pred :: Exp Word8 -> Exp Word8

toEnum :: Int -> Exp Word8

fromEnum :: Exp Word8 -> Int

enumFrom :: Exp Word8 -> [Exp Word8]

enumFromThen :: Exp Word8 -> Exp Word8 -> [Exp Word8]

enumFromTo :: Exp Word8 -> Exp Word8 -> [Exp Word8]

enumFromThenTo :: Exp Word8 -> Exp Word8 -> Exp Word8 -> [Exp Word8]

Integral (Exp Word8)

Defined in Data.Array.Accelerate.Classes.Integral

Methods

quot :: Exp Word8 -> Exp Word8 -> Exp Word8

rem :: Exp Word8 -> Exp Word8 -> Exp Word8

div :: Exp Word8 -> Exp Word8 -> Exp Word8

mod :: Exp Word8 -> Exp Word8 -> Exp Word8

quotRem :: Exp Word8 -> Exp Word8 -> (Exp Word8, Exp Word8)

divMod :: Exp Word8 -> Exp Word8 -> (Exp Word8, Exp Word8)

toInteger :: Exp Word8 -> Integer

Num (Exp Word8)

Defined in Data.Array.Accelerate.Classes.Num

Methods

(+) :: Exp Word8 -> Exp Word8 -> Exp Word8

(-) :: Exp Word8 -> Exp Word8 -> Exp Word8

(*) :: Exp Word8 -> Exp Word8 -> Exp Word8

negate :: Exp Word8 -> Exp Word8

abs :: Exp Word8 -> Exp Word8

signum :: Exp Word8 -> Exp Word8

fromInteger :: Integer -> Exp Word8

type PrimSize Word8

Defined in Basement.PrimType

type PrimSize Word8 = 1

type Difference Word8

Defined in Basement.Numerical.Subtractive

type Difference Word8 = Word8

type NatNumMaxBound Word8

Defined in Basement.Nat

type NatNumMaxBound Word8 = 255

newtype Vector Word8

Defined in Data.Vector.Unboxed.Base

newtype Vector Word8 = V_Word8 (Vector Word8)

type Plain Word8

Defined in Data.Array.Accelerate.Lift

type Plain Word8 = Word8

newtype MVector s Word8

Defined in Data.Vector.Unboxed.Base

newtype MVector s Word8 = MV_Word8 (MVector s Word8)

data Word16

16-bit unsigned integer type

Instances

Bounded Word16

Since: base-2.1

Defined in GHC.Word

Methods

minBound :: Word16

maxBound :: Word16

Enum Word16

Since: base-2.1

Defined in GHC.Word

Methods

succ :: Word16 -> Word16

pred :: Word16 -> Word16

toEnum :: Int -> Word16

fromEnum :: Word16 -> Int

enumFrom :: Word16 -> [Word16]

enumFromThen :: Word16 -> Word16 -> [Word16]

enumFromTo :: Word16 -> Word16 -> [Word16]

enumFromThenTo :: Word16 -> Word16 -> Word16 -> [Word16]

Eq Word16

Since: base-2.1

Defined in GHC.Word

Methods

(==) :: Word16 -> Word16 -> Bool

(/=) :: Word16 -> Word16 -> Bool

Integral Word16

Since: base-2.1

Defined in GHC.Word

Methods

quot :: Word16 -> Word16 -> Word16

rem :: Word16 -> Word16 -> Word16

div :: Word16 -> Word16 -> Word16

mod :: Word16 -> Word16 -> Word16

quotRem :: Word16 -> Word16 -> (Word16, Word16)

divMod :: Word16 -> Word16 -> (Word16, Word16)

toInteger :: Word16 -> Integer

Num Word16

Since: base-2.1

Defined in GHC.Word

Methods

(+) :: Word16 -> Word16 -> Word16

(-) :: Word16 -> Word16 -> Word16

(*) :: Word16 -> Word16 -> Word16

negate :: Word16 -> Word16

abs :: Word16 -> Word16

signum :: Word16 -> Word16

fromInteger :: Integer -> Word16

Ord Word16

Since: base-2.1

Defined in GHC.Word

Methods

compare :: Word16 -> Word16 -> Ordering

(<) :: Word16 -> Word16 -> Bool

(<=) :: Word16 -> Word16 -> Bool

(>) :: Word16 -> Word16 -> Bool

(>=) :: Word16 -> Word16 -> Bool

max :: Word16 -> Word16 -> Word16

min :: Word16 -> Word16 -> Word16

Read Word16

Since: base-2.1

Defined in GHC.Read

Methods

readsPrec :: Int -> ReadS Word16

readList :: ReadS [Word16]

readPrec :: ReadPrec Word16

readListPrec :: ReadPrec [Word16]

Real Word16

Since: base-2.1

Defined in GHC.Word

Methods

toRational :: Word16 -> Rational

Show Word16

Since: base-2.1

Defined in GHC.Word

Methods

showsPrec :: Int -> Word16 -> ShowS

show :: Word16 -> String

showList :: [Word16] -> ShowS

Ix Word16

Since: base-2.1

Defined in GHC.Word

Methods

range :: (Word16, Word16) -> [Word16]

index :: (Word16, Word16) -> Word16 -> Int

unsafeIndex :: (Word16, Word16) -> Word16 -> Int

inRange :: (Word16, Word16) -> Word16 -> Bool

rangeSize :: (Word16, Word16) -> Int

unsafeRangeSize :: (Word16, Word16) -> Int

PrintfArg Word16

Since: base-2.1

Defined in Text.Printf

Methods

formatArg :: Word16 -> FieldFormatter

parseFormat :: Word16 -> ModifierParser

Storable Word16

Since: base-2.1

Defined in Foreign.Storable

Methods

sizeOf :: Word16 -> Int

alignment :: Word16 -> Int

peekElemOff :: Ptr Word16 -> Int -> IO Word16

pokeElemOff :: Ptr Word16 -> Int -> Word16 -> IO ()

peekByteOff :: Ptr b -> Int -> IO Word16

pokeByteOff :: Ptr b -> Int -> Word16 -> IO ()

peek :: Ptr Word16 -> IO Word16

poke :: Ptr Word16 -> Word16 -> IO ()

Bits Word16

Since: base-2.1

Defined in GHC.Word

Methods

(.&.) :: Word16 -> Word16 -> Word16

(.|.) :: Word16 -> Word16 -> Word16

xor :: Word16 -> Word16 -> Word16

complement :: Word16 -> Word16

shift :: Word16 -> Int -> Word16

rotate :: Word16 -> Int -> Word16

zeroBits :: Word16

bit :: Int -> Word16

setBit :: Word16 -> Int -> Word16

clearBit :: Word16 -> Int -> Word16

complementBit :: Word16 -> Int -> Word16

testBit :: Word16 -> Int -> Bool

bitSizeMaybe :: Word16 -> Maybe Int

bitSize :: Word16 -> Int

isSigned :: Word16 -> Bool

shiftL :: Word16 -> Int -> Word16

unsafeShiftL :: Word16 -> Int -> Word16

shiftR :: Word16 -> Int -> Word16

unsafeShiftR :: Word16 -> Int -> Word16

rotateL :: Word16 -> Int -> Word16

rotateR :: Word16 -> Int -> Word16

popCount :: Word16 -> Int

FiniteBits Word16

Since: base-4.6.0.0

Defined in GHC.Word

Methods

finiteBitSize :: Word16 -> Int

countLeadingZeros :: Word16 -> Int

countTrailingZeros :: Word16 -> Int

PrimType Word16

Defined in Basement.PrimType

Associated Types

type PrimSize Word16 :: Nat

Methods

primSizeInBytes :: Proxy Word16 -> CountOf Word8

primShiftToBytes :: Proxy Word16 -> Int

primBaUIndex :: ByteArray# -> Offset Word16 -> Word16

primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Word16 -> prim Word16

primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Word16 -> Word16 -> prim ()

primAddrIndex :: Addr# -> Offset Word16 -> Word16

primAddrRead :: PrimMonad prim => Addr# -> Offset Word16 -> prim Word16

primAddrWrite :: PrimMonad prim => Addr# -> Offset Word16 -> Word16 -> prim ()

PrimMemoryComparable Word16

Defined in Basement.PrimType

Subtractive Word16

Defined in Basement.Numerical.Subtractive

Associated Types

type Difference Word16

Methods

(-) :: Word16 -> Word16 -> Difference Word16

NFData Word16

Defined in Control.DeepSeq

Methods

rnf :: Word16 -> ()

Hashable Word16

Defined in Data.Hashable.Class

Methods

hashWithSalt :: Int -> Word16 -> Int

hash :: Word16 -> Int

Prim Word16

Defined in Data.Primitive.Types

Methods

sizeOf# :: Word16 -> Int#

alignment# :: Word16 -> Int#

indexByteArray# :: ByteArray# -> Int# -> Word16

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Word16 #)

writeByteArray# :: MutableByteArray# s -> Int# -> Word16 -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Word16 -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> Word16

readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Word16 #)

writeOffAddr# :: Addr# -> Int# -> Word16 -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> Word16 -> State# s -> State# s

Unbox Word16

Defined in Data.Vector.Unboxed.Base

Pretty Word16

Defined in Data.Text.Prettyprint.Doc.Internal

Methods

pretty :: Word16 -> Doc ann

prettyList :: [Word16] -> Doc ann

Pretty Word16

Defined in Text.PrettyPrint.Annotated.WL

Methods

pretty :: Word16 -> Doc b

prettyList :: [Word16] -> Doc b

Elt Word16

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR Word16

Methods

eltR :: TypeR (EltR Word16)

tagsR :: [TagR (EltR Word16)]

fromElt :: Word16 -> EltR Word16

toElt :: EltR Word16 -> Word16

Eq Word16

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp Word16 -> Exp Word16 -> Exp Bool

(/=) :: Exp Word16 -> Exp Word16 -> Exp Bool

Ord Word16

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp Word16 -> Exp Word16 -> Exp Bool

(>) :: Exp Word16 -> Exp Word16 -> Exp Bool

(<=) :: Exp Word16 -> Exp Word16 -> Exp Bool

(>=) :: Exp Word16 -> Exp Word16 -> Exp Bool

min :: Exp Word16 -> Exp Word16 -> Exp Word16

max :: Exp Word16 -> Exp Word16 -> Exp Word16

compare :: Exp Word16 -> Exp Word16 -> Exp Ordering

FiniteBits Word16

Defined in Data.Array.Accelerate.Data.Bits

Methods

finiteBitSize :: Exp Word16 -> Exp Int

countLeadingZeros :: Exp Word16 -> Exp Int

countTrailingZeros :: Exp Word16 -> Exp Int

Bits Word16

Defined in Data.Array.Accelerate.Data.Bits

Methods

(.&.) :: Exp Word16 -> Exp Word16 -> Exp Word16

(.|.) :: Exp Word16 -> Exp Word16 -> Exp Word16

xor :: Exp Word16 -> Exp Word16 -> Exp Word16

complement :: Exp Word16 -> Exp Word16

shift :: Exp Word16 -> Exp Int -> Exp Word16

rotate :: Exp Word16 -> Exp Int -> Exp Word16

zeroBits :: Exp Word16

bit :: Exp Int -> Exp Word16

setBit :: Exp Word16 -> Exp Int -> Exp Word16

clearBit :: Exp Word16 -> Exp Int -> Exp Word16

complementBit :: Exp Word16 -> Exp Int -> Exp Word16

testBit :: Exp Word16 -> Exp Int -> Exp Bool

isSigned :: Exp Word16 -> Exp Bool

shiftL :: Exp Word16 -> Exp Int -> Exp Word16

unsafeShiftL :: Exp Word16 -> Exp Int -> Exp Word16

shiftR :: Exp Word16 -> Exp Int -> Exp Word16

unsafeShiftR :: Exp Word16 -> Exp Int -> Exp Word16

rotateL :: Exp Word16 -> Exp Int -> Exp Word16

rotateR :: Exp Word16 -> Exp Int -> Exp Word16

popCount :: Exp Word16 -> Exp Int

Rational Word16

Defined in Data.Array.Accelerate.Classes.Rational

Methods

toRational :: (FromIntegral Int64 b, Integral b) => Exp Word16 -> Exp (Ratio b)

Lift Word16

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Word16 -> Q Exp

liftTyped :: Word16 -> Q (TExp Word16)

Vector Vector Word16

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Word16 -> m (Vector Word16)

basicUnsafeThaw :: PrimMonad m => Vector Word16 -> m (Mutable Vector (PrimState m) Word16)

basicLength :: Vector Word16 -> Int

basicUnsafeSlice :: Int -> Int -> Vector Word16 -> Vector Word16

basicUnsafeIndexM :: Monad m => Vector Word16 -> Int -> m Word16

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Word16 -> Vector Word16 -> m ()

elemseq :: Vector Word16 -> Word16 -> b -> b

MVector MVector Word16

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Word16 -> Int

basicUnsafeSlice :: Int -> Int -> MVector s Word16 -> MVector s Word16

basicOverlaps :: MVector s Word16 -> MVector s Word16 -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Word16)

basicInitialize :: PrimMonad m => MVector (PrimState m) Word16 -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Word16 -> m (MVector (PrimState m) Word16)

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Word16 -> Int -> m Word16

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Word16 -> Int -> Word16 -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) Word16 -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) Word16 -> Word16 -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Word16 -> MVector (PrimState m) Word16 -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Word16 -> MVector (PrimState m) Word16 -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Word16 -> Int -> m (MVector (PrimState m) Word16)

ToFloating Word16 Double

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Word16 -> Exp Double

ToFloating Word16 Float

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Word16 -> Exp Float

ToFloating Word16 Half

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Word16 -> Exp Half

Lift Exp Word16

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain Word16

Methods

lift :: Word16 -> Exp (Plain Word16)

FromIntegral Int Word16

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int -> Exp Word16

FromIntegral Int8 Word16

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int8 -> Exp Word16

FromIntegral Int16 Word16

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int16 -> Exp Word16

FromIntegral Int32 Word16

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int32 -> Exp Word16

FromIntegral Int64 Word16

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int64 -> Exp Word16

FromIntegral Word Word16

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word -> Exp Word16

FromIntegral Word8 Word16

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word8 -> Exp Word16

FromIntegral Word16 Double

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word16 -> Exp Double

FromIntegral Word16 Float

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word16 -> Exp Float

FromIntegral Word16 Int

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word16 -> Exp Int

FromIntegral Word16 Int8

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word16 -> Exp Int8

FromIntegral Word16 Int16

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word16 -> Exp Int16

FromIntegral Word16 Int32

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word16 -> Exp Int32

FromIntegral Word16 Int64

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word16 -> Exp Int64

FromIntegral Word16 Word

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word16 -> Exp Word

FromIntegral Word16 Word8

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word16 -> Exp Word8

FromIntegral Word16 Word16

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word16 -> Exp Word16

FromIntegral Word16 Word32

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word16 -> Exp Word32

FromIntegral Word16 Word64

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word16 -> Exp Word64

FromIntegral Word16 Half

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word16 -> Exp Half

FromIntegral Word32 Word16

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word32 -> Exp Word16

FromIntegral Word64 Word16

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word64 -> Exp Word16

Bounded (Exp Word16)

Defined in Data.Array.Accelerate.Classes.Bounded

Methods

minBound :: Exp Word16

maxBound :: Exp Word16

Enum (Exp Word16)

Defined in Data.Array.Accelerate.Classes.Enum

Methods

succ :: Exp Word16 -> Exp Word16

pred :: Exp Word16 -> Exp Word16

toEnum :: Int -> Exp Word16

fromEnum :: Exp Word16 -> Int

enumFrom :: Exp Word16 -> [Exp Word16]

enumFromThen :: Exp Word16 -> Exp Word16 -> [Exp Word16]

enumFromTo :: Exp Word16 -> Exp Word16 -> [Exp Word16]

enumFromThenTo :: Exp Word16 -> Exp Word16 -> Exp Word16 -> [Exp Word16]

Integral (Exp Word16)

Defined in Data.Array.Accelerate.Classes.Integral

Methods

quot :: Exp Word16 -> Exp Word16 -> Exp Word16

rem :: Exp Word16 -> Exp Word16 -> Exp Word16

div :: Exp Word16 -> Exp Word16 -> Exp Word16

mod :: Exp Word16 -> Exp Word16 -> Exp Word16

quotRem :: Exp Word16 -> Exp Word16 -> (Exp Word16, Exp Word16)

divMod :: Exp Word16 -> Exp Word16 -> (Exp Word16, Exp Word16)

toInteger :: Exp Word16 -> Integer

Num (Exp Word16)

Defined in Data.Array.Accelerate.Classes.Num

Methods

(+) :: Exp Word16 -> Exp Word16 -> Exp Word16

(-) :: Exp Word16 -> Exp Word16 -> Exp Word16

(*) :: Exp Word16 -> Exp Word16 -> Exp Word16

negate :: Exp Word16 -> Exp Word16

abs :: Exp Word16 -> Exp Word16

signum :: Exp Word16 -> Exp Word16

fromInteger :: Integer -> Exp Word16

type PrimSize Word16

Defined in Basement.PrimType

type PrimSize Word16 = 2

type Difference Word16

Defined in Basement.Numerical.Subtractive

type Difference Word16 = Word16

type NatNumMaxBound Word16

Defined in Basement.Nat

type NatNumMaxBound Word16 = 65535

newtype Vector Word16

Defined in Data.Vector.Unboxed.Base

newtype Vector Word16 = V_Word16 (Vector Word16)

type Plain Word16

Defined in Data.Array.Accelerate.Lift

type Plain Word16 = Word16

newtype MVector s Word16

Defined in Data.Vector.Unboxed.Base

newtype MVector s Word16 = MV_Word16 (MVector s Word16)

data Word32

32-bit unsigned integer type

Instances

Bounded Word32

Since: base-2.1

Defined in GHC.Word

Methods

minBound :: Word32

maxBound :: Word32

Enum Word32

Since: base-2.1

Defined in GHC.Word

Methods

succ :: Word32 -> Word32

pred :: Word32 -> Word32

toEnum :: Int -> Word32

fromEnum :: Word32 -> Int

enumFrom :: Word32 -> [Word32]

enumFromThen :: Word32 -> Word32 -> [Word32]

enumFromTo :: Word32 -> Word32 -> [Word32]

enumFromThenTo :: Word32 -> Word32 -> Word32 -> [Word32]

Eq Word32

Since: base-2.1

Defined in GHC.Word

Methods

(==) :: Word32 -> Word32 -> Bool

(/=) :: Word32 -> Word32 -> Bool

Integral Word32

Since: base-2.1

Defined in GHC.Word

Methods

quot :: Word32 -> Word32 -> Word32

rem :: Word32 -> Word32 -> Word32

div :: Word32 -> Word32 -> Word32

mod :: Word32 -> Word32 -> Word32

quotRem :: Word32 -> Word32 -> (Word32, Word32)

divMod :: Word32 -> Word32 -> (Word32, Word32)

toInteger :: Word32 -> Integer

Num Word32

Since: base-2.1

Defined in GHC.Word

Methods

(+) :: Word32 -> Word32 -> Word32

(-) :: Word32 -> Word32 -> Word32

(*) :: Word32 -> Word32 -> Word32

negate :: Word32 -> Word32

abs :: Word32 -> Word32

signum :: Word32 -> Word32

fromInteger :: Integer -> Word32

Ord Word32

Since: base-2.1

Defined in GHC.Word

Methods

compare :: Word32 -> Word32 -> Ordering

(<) :: Word32 -> Word32 -> Bool

(<=) :: Word32 -> Word32 -> Bool

(>) :: Word32 -> Word32 -> Bool

(>=) :: Word32 -> Word32 -> Bool

max :: Word32 -> Word32 -> Word32

min :: Word32 -> Word32 -> Word32

Read Word32

Since: base-2.1

Defined in GHC.Read

Methods

readsPrec :: Int -> ReadS Word32

readList :: ReadS [Word32]

readPrec :: ReadPrec Word32

readListPrec :: ReadPrec [Word32]

Real Word32

Since: base-2.1

Defined in GHC.Word

Methods

toRational :: Word32 -> Rational

Show Word32

Since: base-2.1

Defined in GHC.Word

Methods

showsPrec :: Int -> Word32 -> ShowS

show :: Word32 -> String

showList :: [Word32] -> ShowS

Ix Word32

Since: base-2.1

Defined in GHC.Word

Methods

range :: (Word32, Word32) -> [Word32]

index :: (Word32, Word32) -> Word32 -> Int

unsafeIndex :: (Word32, Word32) -> Word32 -> Int

inRange :: (Word32, Word32) -> Word32 -> Bool

rangeSize :: (Word32, Word32) -> Int

unsafeRangeSize :: (Word32, Word32) -> Int

PrintfArg Word32

Since: base-2.1

Defined in Text.Printf

Methods

formatArg :: Word32 -> FieldFormatter

parseFormat :: Word32 -> ModifierParser

Storable Word32

Since: base-2.1

Defined in Foreign.Storable

Methods

sizeOf :: Word32 -> Int

alignment :: Word32 -> Int

peekElemOff :: Ptr Word32 -> Int -> IO Word32

pokeElemOff :: Ptr Word32 -> Int -> Word32 -> IO ()

peekByteOff :: Ptr b -> Int -> IO Word32

pokeByteOff :: Ptr b -> Int -> Word32 -> IO ()

peek :: Ptr Word32 -> IO Word32

poke :: Ptr Word32 -> Word32 -> IO ()

Bits Word32

Since: base-2.1

Defined in GHC.Word

Methods

(.&.) :: Word32 -> Word32 -> Word32

(.|.) :: Word32 -> Word32 -> Word32

xor :: Word32 -> Word32 -> Word32

complement :: Word32 -> Word32

shift :: Word32 -> Int -> Word32

rotate :: Word32 -> Int -> Word32

zeroBits :: Word32

bit :: Int -> Word32

setBit :: Word32 -> Int -> Word32

clearBit :: Word32 -> Int -> Word32

complementBit :: Word32 -> Int -> Word32

testBit :: Word32 -> Int -> Bool

bitSizeMaybe :: Word32 -> Maybe Int

bitSize :: Word32 -> Int

isSigned :: Word32 -> Bool

shiftL :: Word32 -> Int -> Word32

unsafeShiftL :: Word32 -> Int -> Word32

shiftR :: Word32 -> Int -> Word32

unsafeShiftR :: Word32 -> Int -> Word32

rotateL :: Word32 -> Int -> Word32

rotateR :: Word32 -> Int -> Word32

popCount :: Word32 -> Int

FiniteBits Word32

Since: base-4.6.0.0

Defined in GHC.Word

Methods

finiteBitSize :: Word32 -> Int

countLeadingZeros :: Word32 -> Int

countTrailingZeros :: Word32 -> Int

PrimType Word32

Defined in Basement.PrimType

Associated Types

type PrimSize Word32 :: Nat

Methods

primSizeInBytes :: Proxy Word32 -> CountOf Word8

primShiftToBytes :: Proxy Word32 -> Int

primBaUIndex :: ByteArray# -> Offset Word32 -> Word32

primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Word32 -> prim Word32

primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Word32 -> Word32 -> prim ()

primAddrIndex :: Addr# -> Offset Word32 -> Word32

primAddrRead :: PrimMonad prim => Addr# -> Offset Word32 -> prim Word32

primAddrWrite :: PrimMonad prim => Addr# -> Offset Word32 -> Word32 -> prim ()

PrimMemoryComparable Word32

Defined in Basement.PrimType

Subtractive Word32

Defined in Basement.Numerical.Subtractive

Associated Types

type Difference Word32

Methods

(-) :: Word32 -> Word32 -> Difference Word32

NFData Word32

Defined in Control.DeepSeq

Methods

rnf :: Word32 -> ()

Hashable Word32

Defined in Data.Hashable.Class

Methods

hashWithSalt :: Int -> Word32 -> Int

hash :: Word32 -> Int

Prim Word32

Defined in Data.Primitive.Types

Methods

sizeOf# :: Word32 -> Int#

alignment# :: Word32 -> Int#

indexByteArray# :: ByteArray# -> Int# -> Word32

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Word32 #)

writeByteArray# :: MutableByteArray# s -> Int# -> Word32 -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Word32 -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> Word32

readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Word32 #)

writeOffAddr# :: Addr# -> Int# -> Word32 -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> Word32 -> State# s -> State# s

Unbox Word32

Defined in Data.Vector.Unboxed.Base

Pretty Word32

Defined in Data.Text.Prettyprint.Doc.Internal

Methods

pretty :: Word32 -> Doc ann

prettyList :: [Word32] -> Doc ann

Pretty Word32

Defined in Text.PrettyPrint.Annotated.WL

Methods

pretty :: Word32 -> Doc b

prettyList :: [Word32] -> Doc b

Elt Word32

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR Word32

Methods

eltR :: TypeR (EltR Word32)

tagsR :: [TagR (EltR Word32)]

fromElt :: Word32 -> EltR Word32

toElt :: EltR Word32 -> Word32

Eq Word32

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp Word32 -> Exp Word32 -> Exp Bool

(/=) :: Exp Word32 -> Exp Word32 -> Exp Bool

Ord Word32

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp Word32 -> Exp Word32 -> Exp Bool

(>) :: Exp Word32 -> Exp Word32 -> Exp Bool

(<=) :: Exp Word32 -> Exp Word32 -> Exp Bool

(>=) :: Exp Word32 -> Exp Word32 -> Exp Bool

min :: Exp Word32 -> Exp Word32 -> Exp Word32

max :: Exp Word32 -> Exp Word32 -> Exp Word32

compare :: Exp Word32 -> Exp Word32 -> Exp Ordering

FiniteBits Word32

Defined in Data.Array.Accelerate.Data.Bits

Methods

finiteBitSize :: Exp Word32 -> Exp Int

countLeadingZeros :: Exp Word32 -> Exp Int

countTrailingZeros :: Exp Word32 -> Exp Int

Bits Word32

Defined in Data.Array.Accelerate.Data.Bits

Methods

(.&.) :: Exp Word32 -> Exp Word32 -> Exp Word32

(.|.) :: Exp Word32 -> Exp Word32 -> Exp Word32

xor :: Exp Word32 -> Exp Word32 -> Exp Word32

complement :: Exp Word32 -> Exp Word32

shift :: Exp Word32 -> Exp Int -> Exp Word32

rotate :: Exp Word32 -> Exp Int -> Exp Word32

zeroBits :: Exp Word32

bit :: Exp Int -> Exp Word32

setBit :: Exp Word32 -> Exp Int -> Exp Word32

clearBit :: Exp Word32 -> Exp Int -> Exp Word32

complementBit :: Exp Word32 -> Exp Int -> Exp Word32

testBit :: Exp Word32 -> Exp Int -> Exp Bool

isSigned :: Exp Word32 -> Exp Bool

shiftL :: Exp Word32 -> Exp Int -> Exp Word32

unsafeShiftL :: Exp Word32 -> Exp Int -> Exp Word32

shiftR :: Exp Word32 -> Exp Int -> Exp Word32

unsafeShiftR :: Exp Word32 -> Exp Int -> Exp Word32

rotateL :: Exp Word32 -> Exp Int -> Exp Word32

rotateR :: Exp Word32 -> Exp Int -> Exp Word32

popCount :: Exp Word32 -> Exp Int

Rational Word32

Defined in Data.Array.Accelerate.Classes.Rational

Methods

toRational :: (FromIntegral Int64 b, Integral b) => Exp Word32 -> Exp (Ratio b)

Lift Word32

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Word32 -> Q Exp

liftTyped :: Word32 -> Q (TExp Word32)

Vector Vector Word32

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Word32 -> m (Vector Word32)

basicUnsafeThaw :: PrimMonad m => Vector Word32 -> m (Mutable Vector (PrimState m) Word32)

basicLength :: Vector Word32 -> Int

basicUnsafeSlice :: Int -> Int -> Vector Word32 -> Vector Word32

basicUnsafeIndexM :: Monad m => Vector Word32 -> Int -> m Word32

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Word32 -> Vector Word32 -> m ()

elemseq :: Vector Word32 -> Word32 -> b -> b

MVector MVector Word32

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Word32 -> Int

basicUnsafeSlice :: Int -> Int -> MVector s Word32 -> MVector s Word32

basicOverlaps :: MVector s Word32 -> MVector s Word32 -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Word32)

basicInitialize :: PrimMonad m => MVector (PrimState m) Word32 -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Word32 -> m (MVector (PrimState m) Word32)

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Word32 -> Int -> m Word32

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Word32 -> Int -> Word32 -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) Word32 -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) Word32 -> Word32 -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Word32 -> MVector (PrimState m) Word32 -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Word32 -> MVector (PrimState m) Word32 -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Word32 -> Int -> m (MVector (PrimState m) Word32)

ToFloating Word32 Double

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Word32 -> Exp Double

ToFloating Word32 Float

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Word32 -> Exp Float

ToFloating Word32 Half

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Word32 -> Exp Half

Lift Exp Word32

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain Word32

Methods

lift :: Word32 -> Exp (Plain Word32)

FromIntegral Int Word32

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int -> Exp Word32

FromIntegral Int8 Word32

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int8 -> Exp Word32

FromIntegral Int16 Word32

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int16 -> Exp Word32

FromIntegral Int32 Word32

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int32 -> Exp Word32

FromIntegral Int64 Word32

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int64 -> Exp Word32

FromIntegral Word Word32

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word -> Exp Word32

FromIntegral Word8 Word32

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word8 -> Exp Word32

FromIntegral Word16 Word32

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word16 -> Exp Word32

FromIntegral Word32 Double

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word32 -> Exp Double

FromIntegral Word32 Float

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word32 -> Exp Float

FromIntegral Word32 Int

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word32 -> Exp Int

FromIntegral Word32 Int8

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word32 -> Exp Int8

FromIntegral Word32 Int16

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word32 -> Exp Int16

FromIntegral Word32 Int32

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word32 -> Exp Int32

FromIntegral Word32 Int64

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word32 -> Exp Int64

FromIntegral Word32 Word

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word32 -> Exp Word

FromIntegral Word32 Word8

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word32 -> Exp Word8

FromIntegral Word32 Word16

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word32 -> Exp Word16

FromIntegral Word32 Word32

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word32 -> Exp Word32

FromIntegral Word32 Word64

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word32 -> Exp Word64

FromIntegral Word32 Half

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word32 -> Exp Half

FromIntegral Word64 Word32

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word64 -> Exp Word32

Bounded (Exp Word32)

Defined in Data.Array.Accelerate.Classes.Bounded

Methods

minBound :: Exp Word32

maxBound :: Exp Word32

Enum (Exp Word32)

Defined in Data.Array.Accelerate.Classes.Enum

Methods

succ :: Exp Word32 -> Exp Word32

pred :: Exp Word32 -> Exp Word32

toEnum :: Int -> Exp Word32

fromEnum :: Exp Word32 -> Int

enumFrom :: Exp Word32 -> [Exp Word32]

enumFromThen :: Exp Word32 -> Exp Word32 -> [Exp Word32]

enumFromTo :: Exp Word32 -> Exp Word32 -> [Exp Word32]

enumFromThenTo :: Exp Word32 -> Exp Word32 -> Exp Word32 -> [Exp Word32]

Integral (Exp Word32)

Defined in Data.Array.Accelerate.Classes.Integral

Methods

quot :: Exp Word32 -> Exp Word32 -> Exp Word32

rem :: Exp Word32 -> Exp Word32 -> Exp Word32

div :: Exp Word32 -> Exp Word32 -> Exp Word32

mod :: Exp Word32 -> Exp Word32 -> Exp Word32

quotRem :: Exp Word32 -> Exp Word32 -> (Exp Word32, Exp Word32)

divMod :: Exp Word32 -> Exp Word32 -> (Exp Word32, Exp Word32)

toInteger :: Exp Word32 -> Integer

Num (Exp Word32)

Defined in Data.Array.Accelerate.Classes.Num

Methods

(+) :: Exp Word32 -> Exp Word32 -> Exp Word32

(-) :: Exp Word32 -> Exp Word32 -> Exp Word32

(*) :: Exp Word32 -> Exp Word32 -> Exp Word32

negate :: Exp Word32 -> Exp Word32

abs :: Exp Word32 -> Exp Word32

signum :: Exp Word32 -> Exp Word32

fromInteger :: Integer -> Exp Word32

type PrimSize Word32

Defined in Basement.PrimType

type PrimSize Word32 = 4

type Difference Word32

Defined in Basement.Numerical.Subtractive

type Difference Word32 = Word32

type NatNumMaxBound Word32

Defined in Basement.Nat

type NatNumMaxBound Word32 = 4294967295

newtype Vector Word32

Defined in Data.Vector.Unboxed.Base

newtype Vector Word32 = V_Word32 (Vector Word32)

type Plain Word32

Defined in Data.Array.Accelerate.Lift

type Plain Word32 = Word32

newtype MVector s Word32

Defined in Data.Vector.Unboxed.Base

newtype MVector s Word32 = MV_Word32 (MVector s Word32)

data Word64

64-bit unsigned integer type

Instances

Bounded Word64

Since: base-2.1

Defined in GHC.Word

Methods

minBound :: Word64

maxBound :: Word64

Enum Word64

Since: base-2.1

Defined in GHC.Word

Methods

succ :: Word64 -> Word64

pred :: Word64 -> Word64

toEnum :: Int -> Word64

fromEnum :: Word64 -> Int

enumFrom :: Word64 -> [Word64]

enumFromThen :: Word64 -> Word64 -> [Word64]

enumFromTo :: Word64 -> Word64 -> [Word64]

enumFromThenTo :: Word64 -> Word64 -> Word64 -> [Word64]

Eq Word64

Since: base-2.1

Defined in GHC.Word

Methods

(==) :: Word64 -> Word64 -> Bool

(/=) :: Word64 -> Word64 -> Bool

Integral Word64

Since: base-2.1

Defined in GHC.Word

Methods

quot :: Word64 -> Word64 -> Word64

rem :: Word64 -> Word64 -> Word64

div :: Word64 -> Word64 -> Word64

mod :: Word64 -> Word64 -> Word64

quotRem :: Word64 -> Word64 -> (Word64, Word64)

divMod :: Word64 -> Word64 -> (Word64, Word64)

toInteger :: Word64 -> Integer

Num Word64

Since: base-2.1

Defined in GHC.Word

Methods

(+) :: Word64 -> Word64 -> Word64

(-) :: Word64 -> Word64 -> Word64

(*) :: Word64 -> Word64 -> Word64

negate :: Word64 -> Word64

abs :: Word64 -> Word64

signum :: Word64 -> Word64

fromInteger :: Integer -> Word64

Ord Word64

Since: base-2.1

Defined in GHC.Word

Methods

compare :: Word64 -> Word64 -> Ordering

(<) :: Word64 -> Word64 -> Bool

(<=) :: Word64 -> Word64 -> Bool

(>) :: Word64 -> Word64 -> Bool

(>=) :: Word64 -> Word64 -> Bool

max :: Word64 -> Word64 -> Word64

min :: Word64 -> Word64 -> Word64

Read Word64

Since: base-2.1

Defined in GHC.Read

Methods

readsPrec :: Int -> ReadS Word64

readList :: ReadS [Word64]

readPrec :: ReadPrec Word64

readListPrec :: ReadPrec [Word64]

Real Word64

Since: base-2.1

Defined in GHC.Word

Methods

toRational :: Word64 -> Rational

Show Word64

Since: base-2.1

Defined in GHC.Word

Methods

showsPrec :: Int -> Word64 -> ShowS

show :: Word64 -> String

showList :: [Word64] -> ShowS

Ix Word64

Since: base-2.1

Defined in GHC.Word

Methods

range :: (Word64, Word64) -> [Word64]

index :: (Word64, Word64) -> Word64 -> Int

unsafeIndex :: (Word64, Word64) -> Word64 -> Int

inRange :: (Word64, Word64) -> Word64 -> Bool

rangeSize :: (Word64, Word64) -> Int

unsafeRangeSize :: (Word64, Word64) -> Int

PrintfArg Word64

Since: base-2.1

Defined in Text.Printf

Methods

formatArg :: Word64 -> FieldFormatter

parseFormat :: Word64 -> ModifierParser

Storable Word64

Since: base-2.1

Defined in Foreign.Storable

Methods

sizeOf :: Word64 -> Int

alignment :: Word64 -> Int

peekElemOff :: Ptr Word64 -> Int -> IO Word64

pokeElemOff :: Ptr Word64 -> Int -> Word64 -> IO ()

peekByteOff :: Ptr b -> Int -> IO Word64

pokeByteOff :: Ptr b -> Int -> Word64 -> IO ()

peek :: Ptr Word64 -> IO Word64

poke :: Ptr Word64 -> Word64 -> IO ()

Bits Word64

Since: base-2.1

Defined in GHC.Word

Methods

(.&.) :: Word64 -> Word64 -> Word64

(.|.) :: Word64 -> Word64 -> Word64

xor :: Word64 -> Word64 -> Word64

complement :: Word64 -> Word64

shift :: Word64 -> Int -> Word64

rotate :: Word64 -> Int -> Word64

zeroBits :: Word64

bit :: Int -> Word64

setBit :: Word64 -> Int -> Word64

clearBit :: Word64 -> Int -> Word64

complementBit :: Word64 -> Int -> Word64

testBit :: Word64 -> Int -> Bool

bitSizeMaybe :: Word64 -> Maybe Int

bitSize :: Word64 -> Int

isSigned :: Word64 -> Bool

shiftL :: Word64 -> Int -> Word64

unsafeShiftL :: Word64 -> Int -> Word64

shiftR :: Word64 -> Int -> Word64

unsafeShiftR :: Word64 -> Int -> Word64

rotateL :: Word64 -> Int -> Word64

rotateR :: Word64 -> Int -> Word64

popCount :: Word64 -> Int

FiniteBits Word64

Since: base-4.6.0.0

Defined in GHC.Word

Methods

finiteBitSize :: Word64 -> Int

countLeadingZeros :: Word64 -> Int

countTrailingZeros :: Word64 -> Int

PrimType Word64

Defined in Basement.PrimType

Associated Types

type PrimSize Word64 :: Nat

Methods

primSizeInBytes :: Proxy Word64 -> CountOf Word8

primShiftToBytes :: Proxy Word64 -> Int

primBaUIndex :: ByteArray# -> Offset Word64 -> Word64

primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Word64 -> prim Word64

primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Word64 -> Word64 -> prim ()

primAddrIndex :: Addr# -> Offset Word64 -> Word64

primAddrRead :: PrimMonad prim => Addr# -> Offset Word64 -> prim Word64

primAddrWrite :: PrimMonad prim => Addr# -> Offset Word64 -> Word64 -> prim ()

PrimMemoryComparable Word64

Defined in Basement.PrimType

Subtractive Word64

Defined in Basement.Numerical.Subtractive

Associated Types

type Difference Word64

Methods

(-) :: Word64 -> Word64 -> Difference Word64

NFData Word64

Defined in Control.DeepSeq

Methods

rnf :: Word64 -> ()

Hashable Word64

Defined in Data.Hashable.Class

Methods

hashWithSalt :: Int -> Word64 -> Int

hash :: Word64 -> Int

Prim Word64

Defined in Data.Primitive.Types

Methods

sizeOf# :: Word64 -> Int#

alignment# :: Word64 -> Int#

indexByteArray# :: ByteArray# -> Int# -> Word64

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Word64 #)

writeByteArray# :: MutableByteArray# s -> Int# -> Word64 -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Word64 -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> Word64

readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Word64 #)

writeOffAddr# :: Addr# -> Int# -> Word64 -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> Word64 -> State# s -> State# s

Unbox Word64

Defined in Data.Vector.Unboxed.Base

Pretty Word64

Defined in Data.Text.Prettyprint.Doc.Internal

Methods

pretty :: Word64 -> Doc ann

prettyList :: [Word64] -> Doc ann

Pretty Word64

Defined in Text.PrettyPrint.Annotated.WL

Methods

pretty :: Word64 -> Doc b

prettyList :: [Word64] -> Doc b

Elt Word64

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR Word64

Methods

eltR :: TypeR (EltR Word64)

tagsR :: [TagR (EltR Word64)]

fromElt :: Word64 -> EltR Word64

toElt :: EltR Word64 -> Word64

Eq Word64

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp Word64 -> Exp Word64 -> Exp Bool

(/=) :: Exp Word64 -> Exp Word64 -> Exp Bool

Ord Word64

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp Word64 -> Exp Word64 -> Exp Bool

(>) :: Exp Word64 -> Exp Word64 -> Exp Bool

(<=) :: Exp Word64 -> Exp Word64 -> Exp Bool

(>=) :: Exp Word64 -> Exp Word64 -> Exp Bool

min :: Exp Word64 -> Exp Word64 -> Exp Word64

max :: Exp Word64 -> Exp Word64 -> Exp Word64

compare :: Exp Word64 -> Exp Word64 -> Exp Ordering

FiniteBits Word64

Defined in Data.Array.Accelerate.Data.Bits

Methods

finiteBitSize :: Exp Word64 -> Exp Int

countLeadingZeros :: Exp Word64 -> Exp Int

countTrailingZeros :: Exp Word64 -> Exp Int

Bits Word64

Defined in Data.Array.Accelerate.Data.Bits

Methods

(.&.) :: Exp Word64 -> Exp Word64 -> Exp Word64

(.|.) :: Exp Word64 -> Exp Word64 -> Exp Word64

xor :: Exp Word64 -> Exp Word64 -> Exp Word64

complement :: Exp Word64 -> Exp Word64

shift :: Exp Word64 -> Exp Int -> Exp Word64

rotate :: Exp Word64 -> Exp Int -> Exp Word64

zeroBits :: Exp Word64

bit :: Exp Int -> Exp Word64

setBit :: Exp Word64 -> Exp Int -> Exp Word64

clearBit :: Exp Word64 -> Exp Int -> Exp Word64

complementBit :: Exp Word64 -> Exp Int -> Exp Word64

testBit :: Exp Word64 -> Exp Int -> Exp Bool

isSigned :: Exp Word64 -> Exp Bool

shiftL :: Exp Word64 -> Exp Int -> Exp Word64

unsafeShiftL :: Exp Word64 -> Exp Int -> Exp Word64

shiftR :: Exp Word64 -> Exp Int -> Exp Word64

unsafeShiftR :: Exp Word64 -> Exp Int -> Exp Word64

rotateL :: Exp Word64 -> Exp Int -> Exp Word64

rotateR :: Exp Word64 -> Exp Int -> Exp Word64

popCount :: Exp Word64 -> Exp Int

Rational Word64

Defined in Data.Array.Accelerate.Classes.Rational

Methods

toRational :: (FromIntegral Int64 b, Integral b) => Exp Word64 -> Exp (Ratio b)

Lift Word64

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Word64 -> Q Exp

liftTyped :: Word64 -> Q (TExp Word64)

Vector Vector Word64

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Word64 -> m (Vector Word64)

basicUnsafeThaw :: PrimMonad m => Vector Word64 -> m (Mutable Vector (PrimState m) Word64)

basicLength :: Vector Word64 -> Int

basicUnsafeSlice :: Int -> Int -> Vector Word64 -> Vector Word64

basicUnsafeIndexM :: Monad m => Vector Word64 -> Int -> m Word64

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Word64 -> Vector Word64 -> m ()

elemseq :: Vector Word64 -> Word64 -> b -> b

MVector MVector Word64

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Word64 -> Int

basicUnsafeSlice :: Int -> Int -> MVector s Word64 -> MVector s Word64

basicOverlaps :: MVector s Word64 -> MVector s Word64 -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Word64)

basicInitialize :: PrimMonad m => MVector (PrimState m) Word64 -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Word64 -> m (MVector (PrimState m) Word64)

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Word64 -> Int -> m Word64

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Word64 -> Int -> Word64 -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) Word64 -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) Word64 -> Word64 -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Word64 -> MVector (PrimState m) Word64 -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Word64 -> MVector (PrimState m) Word64 -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Word64 -> Int -> m (MVector (PrimState m) Word64)

ToFloating Word64 Double

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Word64 -> Exp Double

ToFloating Word64 Float

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Word64 -> Exp Float

ToFloating Word64 Half

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Word64 -> Exp Half

Lift Exp Word64

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain Word64

Methods

lift :: Word64 -> Exp (Plain Word64)

FromIntegral Int Word64

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int -> Exp Word64

FromIntegral Int8 Word64

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int8 -> Exp Word64

FromIntegral Int16 Word64

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int16 -> Exp Word64

FromIntegral Int32 Word64

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int32 -> Exp Word64

FromIntegral Int64 Word64

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int64 -> Exp Word64

FromIntegral Word Word64

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word -> Exp Word64

FromIntegral Word8 Word64

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word8 -> Exp Word64

FromIntegral Word16 Word64

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word16 -> Exp Word64

FromIntegral Word32 Word64

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word32 -> Exp Word64

FromIntegral Word64 Double

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word64 -> Exp Double

FromIntegral Word64 Float

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word64 -> Exp Float

FromIntegral Word64 Int

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word64 -> Exp Int

FromIntegral Word64 Int8

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word64 -> Exp Int8

FromIntegral Word64 Int16

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word64 -> Exp Int16

FromIntegral Word64 Int32

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word64 -> Exp Int32

FromIntegral Word64 Int64

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word64 -> Exp Int64

FromIntegral Word64 Word

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word64 -> Exp Word

FromIntegral Word64 Word8

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word64 -> Exp Word8

FromIntegral Word64 Word16

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word64 -> Exp Word16

FromIntegral Word64 Word32

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word64 -> Exp Word32

FromIntegral Word64 Word64

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word64 -> Exp Word64

FromIntegral Word64 Half

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word64 -> Exp Half

Bounded (Exp Word64)

Defined in Data.Array.Accelerate.Classes.Bounded

Methods

minBound :: Exp Word64

maxBound :: Exp Word64

Enum (Exp Word64)

Defined in Data.Array.Accelerate.Classes.Enum

Methods

succ :: Exp Word64 -> Exp Word64

pred :: Exp Word64 -> Exp Word64

toEnum :: Int -> Exp Word64

fromEnum :: Exp Word64 -> Int

enumFrom :: Exp Word64 -> [Exp Word64]

enumFromThen :: Exp Word64 -> Exp Word64 -> [Exp Word64]

enumFromTo :: Exp Word64 -> Exp Word64 -> [Exp Word64]

enumFromThenTo :: Exp Word64 -> Exp Word64 -> Exp Word64 -> [Exp Word64]

Integral (Exp Word64)

Defined in Data.Array.Accelerate.Classes.Integral

Methods

quot :: Exp Word64 -> Exp Word64 -> Exp Word64

rem :: Exp Word64 -> Exp Word64 -> Exp Word64

div :: Exp Word64 -> Exp Word64 -> Exp Word64

mod :: Exp Word64 -> Exp Word64 -> Exp Word64

quotRem :: Exp Word64 -> Exp Word64 -> (Exp Word64, Exp Word64)

divMod :: Exp Word64 -> Exp Word64 -> (Exp Word64, Exp Word64)

toInteger :: Exp Word64 -> Integer

Num (Exp Word64)

Defined in Data.Array.Accelerate.Classes.Num

Methods

(+) :: Exp Word64 -> Exp Word64 -> Exp Word64

(-) :: Exp Word64 -> Exp Word64 -> Exp Word64

(*) :: Exp Word64 -> Exp Word64 -> Exp Word64

negate :: Exp Word64 -> Exp Word64

abs :: Exp Word64 -> Exp Word64

signum :: Exp Word64 -> Exp Word64

fromInteger :: Integer -> Exp Word64

type PrimSize Word64

Defined in Basement.PrimType

type PrimSize Word64 = 8

type Difference Word64

Defined in Basement.Numerical.Subtractive

type Difference Word64 = Word64

type NatNumMaxBound Word64

Defined in Basement.Nat

type NatNumMaxBound Word64 = 18446744073709551615

newtype Vector Word64

Defined in Data.Vector.Unboxed.Base

newtype Vector Word64 = V_Word64 (Vector Word64)

type Plain Word64

Defined in Data.Array.Accelerate.Lift

type Plain Word64 = Word64

newtype MVector s Word64

Defined in Data.Vector.Unboxed.Base

newtype MVector s Word64 = MV_Word64 (MVector s Word64)

newtype Half

Constructors

Half

Fields

• getHalf :: CUShort

Instances

Eq Half

Defined in Numeric.Half

Methods

(==) :: Half -> Half -> Bool

(/=) :: Half -> Half -> Bool

Floating Half

Defined in Numeric.Half

Methods

pi :: Half

exp :: Half -> Half

log :: Half -> Half

sqrt :: Half -> Half

(**) :: Half -> Half -> Half

logBase :: Half -> Half -> Half

sin :: Half -> Half

cos :: Half -> Half

tan :: Half -> Half

asin :: Half -> Half

acos :: Half -> Half

atan :: Half -> Half

sinh :: Half -> Half

cosh :: Half -> Half

tanh :: Half -> Half

asinh :: Half -> Half

acosh :: Half -> Half

atanh :: Half -> Half

log1p :: Half -> Half

expm1 :: Half -> Half

log1pexp :: Half -> Half

log1mexp :: Half -> Half

Fractional Half

Defined in Numeric.Half

Methods

(/) :: Half -> Half -> Half

recip :: Half -> Half

fromRational :: Rational -> Half

Num Half

Defined in Numeric.Half

Methods

(+) :: Half -> Half -> Half

(-) :: Half -> Half -> Half

(*) :: Half -> Half -> Half

negate :: Half -> Half

abs :: Half -> Half

signum :: Half -> Half

fromInteger :: Integer -> Half

Ord Half

Defined in Numeric.Half

Methods

compare :: Half -> Half -> Ordering

(<) :: Half -> Half -> Bool

(<=) :: Half -> Half -> Bool

(>) :: Half -> Half -> Bool

(>=) :: Half -> Half -> Bool

max :: Half -> Half -> Half

min :: Half -> Half -> Half

Read Half

Defined in Numeric.Half

Methods

readsPrec :: Int -> ReadS Half

readList :: ReadS [Half]

readPrec :: ReadPrec Half

readListPrec :: ReadPrec [Half]

Real Half

Defined in Numeric.Half

Methods

toRational :: Half -> Rational

RealFloat Half

Defined in Numeric.Half

Methods

floatRadix :: Half -> Integer

floatDigits :: Half -> Int

floatRange :: Half -> (Int, Int)

decodeFloat :: Half -> (Integer, Int)

encodeFloat :: Integer -> Int -> Half

exponent :: Half -> Int

significand :: Half -> Half

scaleFloat :: Int -> Half -> Half

isNaN :: Half -> Bool

isInfinite :: Half -> Bool

isDenormalized :: Half -> Bool

isNegativeZero :: Half -> Bool

isIEEE :: Half -> Bool

atan2 :: Half -> Half -> Half

RealFrac Half

Defined in Numeric.Half

Methods

properFraction :: Integral b => Half -> (b, Half)

truncate :: Integral b => Half -> b

round :: Integral b => Half -> b

ceiling :: Integral b => Half -> b

floor :: Integral b => Half -> b

Show Half

Defined in Numeric.Half

Methods

showsPrec :: Int -> Half -> ShowS

show :: Half -> String

showList :: [Half] -> ShowS

Generic Half

Defined in Numeric.Half

Associated Types

type Rep Half :: Type -> Type

Methods

from :: Half -> Rep Half x

to :: Rep Half x -> Half

Storable Half

Defined in Numeric.Half

Methods

sizeOf :: Half -> Int

alignment :: Half -> Int

peekElemOff :: Ptr Half -> Int -> IO Half

pokeElemOff :: Ptr Half -> Int -> Half -> IO ()

peekByteOff :: Ptr b -> Int -> IO Half

pokeByteOff :: Ptr b -> Int -> Half -> IO ()

peek :: Ptr Half -> IO Half

poke :: Ptr Half -> Half -> IO ()

NFData Half

Defined in Numeric.Half

Methods

rnf :: Half -> ()

Prim Half

Defined in Data.Array.Accelerate.Orphans

Methods

sizeOf# :: Half -> Int#

alignment# :: Half -> Int#

indexByteArray# :: ByteArray# -> Int# -> Half

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Half #)

writeByteArray# :: MutableByteArray# s -> Int# -> Half -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Half -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> Half

readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Half #)

writeOffAddr# :: Addr# -> Int# -> Half -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> Half -> State# s -> State# s

RealFrac Half

Defined in Data.Array.Accelerate.Classes.RealFrac

Methods

properFraction :: (Integral b, FromIntegral Int64 b) => Exp Half -> (Exp b, Exp Half)

truncate :: (Integral b, FromIntegral Int64 b) => Exp Half -> Exp b

round :: (Integral b, FromIntegral Int64 b) => Exp Half -> Exp b

ceiling :: (Integral b, FromIntegral Int64 b) => Exp Half -> Exp b

floor :: (Integral b, FromIntegral Int64 b) => Exp Half -> Exp b

Elt Half

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR Half

Methods

eltR :: TypeR (EltR Half)

tagsR :: [TagR (EltR Half)]

fromElt :: Half -> EltR Half

toElt :: EltR Half -> Half

Eq Half

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp Half -> Exp Half -> Exp Bool

(/=) :: Exp Half -> Exp Half -> Exp Bool

Ord Half

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp Half -> Exp Half -> Exp Bool

(>) :: Exp Half -> Exp Half -> Exp Bool

(<=) :: Exp Half -> Exp Half -> Exp Bool

(>=) :: Exp Half -> Exp Half -> Exp Bool

min :: Exp Half -> Exp Half -> Exp Half

max :: Exp Half -> Exp Half -> Exp Half

compare :: Exp Half -> Exp Half -> Exp Ordering

RealFloat Half

Defined in Data.Array.Accelerate.Classes.RealFloat

Methods

floatRadix :: Exp Half -> Exp Int64

floatDigits :: Exp Half -> Exp Int

floatRange :: Exp Half -> (Exp Int, Exp Int)

decodeFloat :: Exp Half -> (Exp Int64, Exp Int)

encodeFloat :: Exp Int64 -> Exp Int -> Exp Half

exponent :: Exp Half -> Exp Int

significand :: Exp Half -> Exp Half

scaleFloat :: Exp Int -> Exp Half -> Exp Half

isNaN :: Exp Half -> Exp Bool

isInfinite :: Exp Half -> Exp Bool

isDenormalized :: Exp Half -> Exp Bool

isNegativeZero :: Exp Half -> Exp Bool

isIEEE :: Exp Half -> Exp Bool

atan2 :: Exp Half -> Exp Half -> Exp Half

Rational Half

Defined in Data.Array.Accelerate.Classes.Rational

Methods

toRational :: (FromIntegral Int64 b, Integral b) => Exp Half -> Exp (Ratio b)

Lift Half

Defined in Numeric.Half

Methods

lift :: Half -> Q Exp

liftTyped :: Half -> Q (TExp Half)

ToFloating Double Half

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Double -> Exp Half

ToFloating Float Half

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Float -> Exp Half

ToFloating Int Half

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Int -> Exp Half

ToFloating Int8 Half

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Int8 -> Exp Half

ToFloating Int16 Half

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Int16 -> Exp Half

ToFloating Int32 Half

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Int32 -> Exp Half

ToFloating Int64 Half

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Int64 -> Exp Half

ToFloating Word Half

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Word -> Exp Half

ToFloating Word8 Half

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Word8 -> Exp Half

ToFloating Word16 Half

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Word16 -> Exp Half

ToFloating Word32 Half

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Word32 -> Exp Half

ToFloating Word64 Half

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Word64 -> Exp Half

ToFloating Half Double

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Half -> Exp Double

ToFloating Half Float

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Half -> Exp Float

ToFloating Half Half

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Half -> Exp Half

Lift Exp Half

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain Half

Methods

lift :: Half -> Exp (Plain Half)

FromIntegral Int Half

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int -> Exp Half

FromIntegral Int8 Half

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int8 -> Exp Half

FromIntegral Int16 Half

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int16 -> Exp Half

FromIntegral Int32 Half

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int32 -> Exp Half

FromIntegral Int64 Half

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int64 -> Exp Half

FromIntegral Word Half

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word -> Exp Half

FromIntegral Word8 Half

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word8 -> Exp Half

FromIntegral Word16 Half

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word16 -> Exp Half

FromIntegral Word32 Half

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word32 -> Exp Half

FromIntegral Word64 Half

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word64 -> Exp Half

Enum (Exp Half)

Defined in Data.Array.Accelerate.Classes.Enum

Methods

succ :: Exp Half -> Exp Half

pred :: Exp Half -> Exp Half

toEnum :: Int -> Exp Half

fromEnum :: Exp Half -> Int

enumFrom :: Exp Half -> [Exp Half]

enumFromThen :: Exp Half -> Exp Half -> [Exp Half]

enumFromTo :: Exp Half -> Exp Half -> [Exp Half]

enumFromThenTo :: Exp Half -> Exp Half -> Exp Half -> [Exp Half]

Floating (Exp Half)

Defined in Data.Array.Accelerate.Classes.Floating

Methods

pi :: Exp Half

exp :: Exp Half -> Exp Half

log :: Exp Half -> Exp Half

sqrt :: Exp Half -> Exp Half

(**) :: Exp Half -> Exp Half -> Exp Half

logBase :: Exp Half -> Exp Half -> Exp Half

sin :: Exp Half -> Exp Half

cos :: Exp Half -> Exp Half

tan :: Exp Half -> Exp Half

asin :: Exp Half -> Exp Half

acos :: Exp Half -> Exp Half

atan :: Exp Half -> Exp Half

sinh :: Exp Half -> Exp Half

cosh :: Exp Half -> Exp Half

tanh :: Exp Half -> Exp Half

asinh :: Exp Half -> Exp Half

acosh :: Exp Half -> Exp Half

atanh :: Exp Half -> Exp Half

log1p :: Exp Half -> Exp Half

expm1 :: Exp Half -> Exp Half

log1pexp :: Exp Half -> Exp Half

log1mexp :: Exp Half -> Exp Half

Fractional (Exp Half)

Defined in Data.Array.Accelerate.Classes.Fractional

Methods

(/) :: Exp Half -> Exp Half -> Exp Half

recip :: Exp Half -> Exp Half

fromRational :: Rational -> Exp Half

Num (Exp Half)

Defined in Data.Array.Accelerate.Classes.Num

Methods

(+) :: Exp Half -> Exp Half -> Exp Half

(-) :: Exp Half -> Exp Half -> Exp Half

(*) :: Exp Half -> Exp Half -> Exp Half

negate :: Exp Half -> Exp Half

abs :: Exp Half -> Exp Half

signum :: Exp Half -> Exp Half

fromInteger :: Integer -> Exp Half

type Rep Half

Defined in Numeric.Half

type Rep Half = D1 ('MetaData "Half" "Numeric.Half" "half-0.3-5I6Y1Z6OYBD6TOLu4NSPvX" 'True) (C1 ('MetaCons "Half" 'PrefixI 'True) (S1 ('MetaSel ('Just "getHalf") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 CUShort)))

type Plain Half

Defined in Data.Array.Accelerate.Lift

type Plain Half = Half

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

Note that due to the presence of NaN, Float's Eq instance does not satisfy reflexivity.

>>> 0/0 == (0/0 :: Float)
False

Also note that Float's Eq instance does not satisfy substitutivity:

>>> 0 == (-0 :: Float)
True
>>> recip 0 == recip (-0 :: Float)
False

Defined in GHC.Classes

Methods

(==) :: Float -> Float -> Bool

(/=) :: Float -> Float -> Bool

Floating Float

Since: base-2.1

Defined in GHC.Float

Methods

pi :: Float

exp :: Float -> Float

log :: Float -> Float

sqrt :: Float -> Float

(**) :: Float -> Float -> Float

logBase :: Float -> Float -> Float

sin :: Float -> Float

cos :: Float -> Float

tan :: Float -> Float

asin :: Float -> Float

acos :: Float -> Float

atan :: Float -> Float

sinh :: Float -> Float

cosh :: Float -> Float

tanh :: Float -> Float

asinh :: Float -> Float

acosh :: Float -> Float

atanh :: Float -> Float

log1p :: Float -> Float

expm1 :: Float -> Float

log1pexp :: Float -> Float

log1mexp :: Float -> Float

Ord Float

Note that due to the presence of NaN, Float's Ord instance does not satisfy reflexivity.

>>> 0/0 <= (0/0 :: Float)
False

Also note that, due to the same, Ord's operator interactions are not respected by Float's instance:

>>> (0/0 :: Float) > 1
False
>>> compare (0/0 :: Float) 1
GT

Defined in GHC.Classes

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

Read Float

Since: base-2.1

Defined in GHC.Read

Methods

readsPrec :: Int -> ReadS Float

readList :: ReadS [Float]

readPrec :: ReadPrec Float

readListPrec :: ReadPrec [Float]

RealFloat Float

Since: base-2.1

Defined in GHC.Float

Methods

floatRadix :: Float -> Integer

floatDigits :: Float -> Int

floatRange :: Float -> (Int, Int)

decodeFloat :: Float -> (Integer, Int)

encodeFloat :: Integer -> Int -> Float

exponent :: Float -> Int

significand :: Float -> Float

scaleFloat :: Int -> Float -> Float

isNaN :: Float -> Bool

isInfinite :: Float -> Bool

isDenormalized :: Float -> Bool

isNegativeZero :: Float -> Bool

isIEEE :: Float -> Bool

atan2 :: Float -> Float -> Float

PrintfArg Float

Since: base-2.1

Defined in Text.Printf

Methods

formatArg :: Float -> FieldFormatter

parseFormat :: Float -> ModifierParser

Storable Float

Since: base-2.1

Defined in Foreign.Storable

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

PrimType Float

Defined in Basement.PrimType

Associated Types

type PrimSize Float :: Nat

Methods

primSizeInBytes :: Proxy Float -> CountOf Word8

primShiftToBytes :: Proxy Float -> Int

primBaUIndex :: ByteArray# -> Offset Float -> Float

primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Float -> prim Float

primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Float -> Float -> prim ()

primAddrIndex :: Addr# -> Offset Float -> Float

primAddrRead :: PrimMonad prim => Addr# -> Offset Float -> prim Float

primAddrWrite :: PrimMonad prim => Addr# -> Offset Float -> Float -> prim ()

Subtractive Float

Defined in Basement.Numerical.Subtractive

Associated Types

type Difference Float

Methods

(-) :: Float -> Float -> Difference Float

NFData Float

Defined in Control.DeepSeq

Methods

rnf :: Float -> ()

Hashable Float

Note: prior to hashable-1.3.0.0, hash 0.0 /= hash (-0.0)

The hash of NaN is not well defined.

Since: hashable-1.3.0.0

Defined in Data.Hashable.Class

Methods

hashWithSalt :: Int -> Float -> Int

hash :: Float -> Int

Prim Float

Defined in Data.Primitive.Types

Methods

sizeOf# :: Float -> Int#

alignment# :: Float -> Int#

indexByteArray# :: ByteArray# -> Int# -> Float

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Float #)

writeByteArray# :: MutableByteArray# s -> Int# -> Float -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Float -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> Float

readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Float #)

writeOffAddr# :: Addr# -> Int# -> Float -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> Float -> State# s -> State# s

Unbox Float

Defined in Data.Vector.Unboxed.Base

Pretty Float

>>> pretty (pi :: Float)
3.1415927

Defined in Data.Text.Prettyprint.Doc.Internal

Methods

pretty :: Float -> Doc ann

prettyList :: [Float] -> Doc ann

Pretty Float

Defined in Text.PrettyPrint.Annotated.WL

Methods

pretty :: Float -> Doc b

prettyList :: [Float] -> Doc b

RealFrac Float

Defined in Data.Array.Accelerate.Classes.RealFrac

Methods

properFraction :: (Integral b, FromIntegral Int64 b) => Exp Float -> (Exp b, Exp Float)

truncate :: (Integral b, FromIntegral Int64 b) => Exp Float -> Exp b

round :: (Integral b, FromIntegral Int64 b) => Exp Float -> Exp b

ceiling :: (Integral b, FromIntegral Int64 b) => Exp Float -> Exp b

floor :: (Integral b, FromIntegral Int64 b) => Exp Float -> Exp b

Elt Float

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR Float

Methods

eltR :: TypeR (EltR Float)

tagsR :: [TagR (EltR Float)]

fromElt :: Float -> EltR Float

toElt :: EltR Float -> Float

Eq Float

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp Float -> Exp Float -> Exp Bool

(/=) :: Exp Float -> Exp Float -> Exp Bool

Ord Float

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp Float -> Exp Float -> Exp Bool

(>) :: Exp Float -> Exp Float -> Exp Bool

(<=) :: Exp Float -> Exp Float -> Exp Bool

(>=) :: Exp Float -> Exp Float -> Exp Bool

min :: Exp Float -> Exp Float -> Exp Float

max :: Exp Float -> Exp Float -> Exp Float

compare :: Exp Float -> Exp Float -> Exp Ordering

RealFloat Float

Defined in Data.Array.Accelerate.Classes.RealFloat

Methods

floatRadix :: Exp Float -> Exp Int64

floatDigits :: Exp Float -> Exp Int

floatRange :: Exp Float -> (Exp Int, Exp Int)

decodeFloat :: Exp Float -> (Exp Int64, Exp Int)

encodeFloat :: Exp Int64 -> Exp Int -> Exp Float

exponent :: Exp Float -> Exp Int

significand :: Exp Float -> Exp Float

scaleFloat :: Exp Int -> Exp Float -> Exp Float

isNaN :: Exp Float -> Exp Bool

isInfinite :: Exp Float -> Exp Bool

isDenormalized :: Exp Float -> Exp Bool

isNegativeZero :: Exp Float -> Exp Bool

isIEEE :: Exp Float -> Exp Bool

atan2 :: Exp Float -> Exp Float -> Exp Float

Rational Float

Defined in Data.Array.Accelerate.Classes.Rational

Methods

toRational :: (FromIntegral Int64 b, Integral b) => Exp Float -> Exp (Ratio b)

Lift Float

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Float -> Q Exp

liftTyped :: Float -> Q (TExp Float)

Vector Vector Float

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Float -> m (Vector Float)

basicUnsafeThaw :: PrimMonad m => Vector Float -> m (Mutable Vector (PrimState m) Float)

basicLength :: Vector Float -> Int

basicUnsafeSlice :: Int -> Int -> Vector Float -> Vector Float

basicUnsafeIndexM :: Monad m => Vector Float -> Int -> m Float

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Float -> Vector Float -> m ()

elemseq :: Vector Float -> Float -> b -> b

MVector MVector Float

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Float -> Int

basicUnsafeSlice :: Int -> Int -> MVector s Float -> MVector s Float

basicOverlaps :: MVector s Float -> MVector s Float -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Float)

basicInitialize :: PrimMonad m => MVector (PrimState m) Float -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Float -> m (MVector (PrimState m) Float)

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Float -> Int -> m Float

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Float -> Int -> Float -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) Float -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) Float -> Float -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Float -> MVector (PrimState m) Float -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Float -> MVector (PrimState m) Float -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Float -> Int -> m (MVector (PrimState m) Float)

ToFloating Double Float

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Double -> Exp Float

ToFloating Float Double

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Float -> Exp Double

ToFloating Float Float

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Float -> Exp Float

ToFloating Float Half

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Float -> Exp Half

ToFloating Int Float

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Int -> Exp Float

ToFloating Int8 Float

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Int8 -> Exp Float

ToFloating Int16 Float

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Int16 -> Exp Float

ToFloating Int32 Float

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Int32 -> Exp Float

ToFloating Int64 Float

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Int64 -> Exp Float

ToFloating Word Float

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Word -> Exp Float

ToFloating Word8 Float

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Word8 -> Exp Float

ToFloating Word16 Float

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Word16 -> Exp Float

ToFloating Word32 Float

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Word32 -> Exp Float

ToFloating Word64 Float

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Word64 -> Exp Float

ToFloating Half Float

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Half -> Exp Float

Lift Exp Float

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain Float

Methods

lift :: Float -> Exp (Plain Float)

FromIntegral Int Float

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int -> Exp Float

FromIntegral Int8 Float

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int8 -> Exp Float

FromIntegral Int16 Float

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int16 -> Exp Float

FromIntegral Int32 Float

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int32 -> Exp Float

FromIntegral Int64 Float

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int64 -> Exp Float

FromIntegral Word Float

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word -> Exp Float

FromIntegral Word8 Float

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word8 -> Exp Float

FromIntegral Word16 Float

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word16 -> Exp Float

FromIntegral Word32 Float

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word32 -> Exp Float

FromIntegral Word64 Float

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word64 -> Exp Float

Generic1 (URec Float :: k -> Type)

Since: base-4.9.0.0

Defined in GHC.Generics

Associated Types

type Rep1 (URec Float) :: k -> Type

Methods

from1 :: forall (a :: k0). URec Float a -> Rep1 (URec Float) a

to1 :: forall (a :: k0). Rep1 (URec Float) a -> URec Float a

Enum (Exp Float)

Defined in Data.Array.Accelerate.Classes.Enum

Methods

succ :: Exp Float -> Exp Float

pred :: Exp Float -> Exp Float

toEnum :: Int -> Exp Float

fromEnum :: Exp Float -> Int

enumFrom :: Exp Float -> [Exp Float]

enumFromThen :: Exp Float -> Exp Float -> [Exp Float]

enumFromTo :: Exp Float -> Exp Float -> [Exp Float]

enumFromThenTo :: Exp Float -> Exp Float -> Exp Float -> [Exp Float]

Floating (Exp Float)

Defined in Data.Array.Accelerate.Classes.Floating

Methods

pi :: Exp Float

exp :: Exp Float -> Exp Float

log :: Exp Float -> Exp Float

sqrt :: Exp Float -> Exp Float

(**) :: Exp Float -> Exp Float -> Exp Float

logBase :: Exp Float -> Exp Float -> Exp Float

sin :: Exp Float -> Exp Float

cos :: Exp Float -> Exp Float

tan :: Exp Float -> Exp Float

asin :: Exp Float -> Exp Float

acos :: Exp Float -> Exp Float

atan :: Exp Float -> Exp Float

sinh :: Exp Float -> Exp Float

cosh :: Exp Float -> Exp Float

tanh :: Exp Float -> Exp Float

asinh :: Exp Float -> Exp Float

acosh :: Exp Float -> Exp Float

atanh :: Exp Float -> Exp Float

log1p :: Exp Float -> Exp Float

expm1 :: Exp Float -> Exp Float

log1pexp :: Exp Float -> Exp Float

log1mexp :: Exp Float -> Exp Float

Fractional (Exp Float)

Defined in Data.Array.Accelerate.Classes.Fractional

Methods

(/) :: Exp Float -> Exp Float -> Exp Float

recip :: Exp Float -> Exp Float

fromRational :: Rational -> Exp Float

Num (Exp Float)

Defined in Data.Array.Accelerate.Classes.Num

Methods

(+) :: Exp Float -> Exp Float -> Exp Float

(-) :: Exp Float -> Exp Float -> Exp Float

(*) :: Exp Float -> Exp Float -> Exp Float

negate :: Exp Float -> Exp Float

abs :: Exp Float -> Exp Float

signum :: Exp Float -> Exp Float

fromInteger :: Integer -> Exp Float

Foldable (UFloat :: Type -> Type)

Since: base-4.9.0.0

Defined in Data.Foldable

Methods

fold :: Monoid m => UFloat m -> m

foldMap :: Monoid m => (a -> m) -> UFloat a -> m

foldMap' :: Monoid m => (a -> m) -> UFloat a -> m

foldr :: (a -> b -> b) -> b -> UFloat a -> b

foldr' :: (a -> b -> b) -> b -> UFloat a -> b

foldl :: (b -> a -> b) -> b -> UFloat a -> b

foldl' :: (b -> a -> b) -> b -> UFloat a -> b

foldr1 :: (a -> a -> a) -> UFloat a -> a

foldl1 :: (a -> a -> a) -> UFloat a -> a

toList :: UFloat a -> [a]

null :: UFloat a -> Bool

length :: UFloat a -> Int

elem :: Eq a => a -> UFloat a -> Bool

maximum :: Ord a => UFloat a -> a

minimum :: Ord a => UFloat a -> a

sum :: Num a => UFloat a -> a

product :: Num a => UFloat a -> a

Traversable (UFloat :: Type -> Type)

Since: base-4.9.0.0

Defined in Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> UFloat a -> f (UFloat b)

sequenceA :: Applicative f => UFloat (f a) -> f (UFloat a)

mapM :: Monad m => (a -> m b) -> UFloat a -> m (UFloat b)

sequence :: Monad m => UFloat (m a) -> m (UFloat a)

Functor (URec Float :: Type -> Type)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> URec Float a -> URec Float b

(<$) :: a -> URec Float b -> URec Float a

Eq (URec Float p)

Defined in GHC.Generics

Methods

(==) :: URec Float p -> URec Float p -> Bool

(/=) :: URec Float p -> URec Float p -> Bool

Ord (URec Float p)

Defined in GHC.Generics

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)

Defined in GHC.Generics

Methods

showsPrec :: Int -> URec Float p -> ShowS

show :: URec Float p -> String

showList :: [URec Float p] -> ShowS

Generic (URec Float p)

Defined in GHC.Generics

Associated Types

type Rep (URec Float p) :: Type -> Type

Methods

from :: URec Float p -> Rep (URec Float p) x

to :: Rep (URec Float p) x -> URec Float p

type PrimSize Float

Defined in Basement.PrimType

type PrimSize Float = 4

type Difference Float

Defined in Basement.Numerical.Subtractive

type Difference Float = Float

newtype Vector Float

Defined in Data.Vector.Unboxed.Base

newtype Vector Float = V_Float (Vector Float)

type Plain Float

Defined in Data.Array.Accelerate.Lift

type Plain Float = Float

data URec Float (p :: k)

Used for marking occurrences of Float#

Since: base-4.9.0.0

Defined in GHC.Generics

data URec Float (p :: k) = UFloat {

• uFloat# :: Float#

}

newtype MVector s Float

Defined in Data.Vector.Unboxed.Base

newtype MVector s Float = MV_Float (MVector s Float)

type Rep1 (URec Float :: k -> Type)

Defined in GHC.Generics

type Rep1 (URec Float :: k -> Type) = D1 ('MetaData "URec" "GHC.Generics" "base" 'False) (C1 ('MetaCons "UFloat" 'PrefixI 'True) (S1 ('MetaSel ('Just "uFloat#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UFloat :: k -> Type)))

type Rep (URec Float p)

Defined in GHC.Generics

type Rep (URec Float p) = D1 ('MetaData "URec" "GHC.Generics" "base" 'False) (C1 ('MetaCons "UFloat" 'PrefixI 'True) (S1 ('MetaSel ('Just "uFloat#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UFloat :: Type -> Type)))

data Double

Double-precision floating point numbers. It is desirable that this type be at least equal in range and precision to the IEEE double-precision type.

Instances

Eq Double

Note that due to the presence of NaN, Double's Eq instance does not satisfy reflexivity.

>>> 0/0 == (0/0 :: Double)
False

Also note that Double's Eq instance does not satisfy substitutivity:

>>> 0 == (-0 :: Double)
True
>>> recip 0 == recip (-0 :: Double)
False

Defined in GHC.Classes

Methods

(==) :: Double -> Double -> Bool

(/=) :: Double -> Double -> Bool

Floating Double

Since: base-2.1

Defined in GHC.Float

Methods

pi :: Double

exp :: Double -> Double

log :: Double -> Double

sqrt :: Double -> Double

(**) :: Double -> Double -> Double

logBase :: Double -> Double -> Double

sin :: Double -> Double

cos :: Double -> Double

tan :: Double -> Double

asin :: Double -> Double

acos :: Double -> Double

atan :: Double -> Double

sinh :: Double -> Double

cosh :: Double -> Double

tanh :: Double -> Double

asinh :: Double -> Double

acosh :: Double -> Double

atanh :: Double -> Double

log1p :: Double -> Double

expm1 :: Double -> Double

log1pexp :: Double -> Double

log1mexp :: Double -> Double

Ord Double

Note that due to the presence of NaN, Double's Ord instance does not satisfy reflexivity.

>>> 0/0 <= (0/0 :: Double)
False

Also note that, due to the same, Ord's operator interactions are not respected by Double's instance:

>>> (0/0 :: Double) > 1
False
>>> compare (0/0 :: Double) 1
GT

Defined in GHC.Classes

Methods

compare :: Double -> Double -> Ordering

(<) :: Double -> Double -> Bool

(<=) :: Double -> Double -> Bool

(>) :: Double -> Double -> Bool

(>=) :: Double -> Double -> Bool

max :: Double -> Double -> Double

min :: Double -> Double -> Double

Read Double

Since: base-2.1

Defined in GHC.Read

Methods

readsPrec :: Int -> ReadS Double

readList :: ReadS [Double]

readPrec :: ReadPrec Double

readListPrec :: ReadPrec [Double]

RealFloat Double

Since: base-2.1

Defined in GHC.Float

Methods

floatRadix :: Double -> Integer

floatDigits :: Double -> Int

floatRange :: Double -> (Int, Int)

decodeFloat :: Double -> (Integer, Int)

encodeFloat :: Integer -> Int -> Double

exponent :: Double -> Int

significand :: Double -> Double

scaleFloat :: Int -> Double -> Double

isNaN :: Double -> Bool

isInfinite :: Double -> Bool

isDenormalized :: Double -> Bool

isNegativeZero :: Double -> Bool

isIEEE :: Double -> Bool

atan2 :: Double -> Double -> Double

PrintfArg Double

Since: base-2.1

Defined in Text.Printf

Methods

formatArg :: Double -> FieldFormatter

parseFormat :: Double -> ModifierParser

Storable Double

Since: base-2.1

Defined in Foreign.Storable

Methods

sizeOf :: Double -> Int

alignment :: Double -> Int

peekElemOff :: Ptr Double -> Int -> IO Double

pokeElemOff :: Ptr Double -> Int -> Double -> IO ()

peekByteOff :: Ptr b -> Int -> IO Double

pokeByteOff :: Ptr b -> Int -> Double -> IO ()

peek :: Ptr Double -> IO Double

poke :: Ptr Double -> Double -> IO ()

PrimType Double

Defined in Basement.PrimType

Associated Types

type PrimSize Double :: Nat

Methods

primSizeInBytes :: Proxy Double -> CountOf Word8

primShiftToBytes :: Proxy Double -> Int

primBaUIndex :: ByteArray# -> Offset Double -> Double

primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Double -> prim Double

primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Double -> Double -> prim ()

primAddrIndex :: Addr# -> Offset Double -> Double

primAddrRead :: PrimMonad prim => Addr# -> Offset Double -> prim Double

primAddrWrite :: PrimMonad prim => Addr# -> Offset Double -> Double -> prim ()

Subtractive Double

Defined in Basement.Numerical.Subtractive

Associated Types

type Difference Double

Methods

(-) :: Double -> Double -> Difference Double

NFData Double

Defined in Control.DeepSeq

Methods

rnf :: Double -> ()

Hashable Double

Note: prior to hashable-1.3.0.0, hash 0.0 /= hash (-0.0)

The hash of NaN is not well defined.

Since: hashable-1.3.0.0

Defined in Data.Hashable.Class

Methods

hashWithSalt :: Int -> Double -> Int

hash :: Double -> Int

Prim Double

Defined in Data.Primitive.Types

Methods

sizeOf# :: Double -> Int#

alignment# :: Double -> Int#

indexByteArray# :: ByteArray# -> Int# -> Double

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Double #)

writeByteArray# :: MutableByteArray# s -> Int# -> Double -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Double -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> Double

readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Double #)

writeOffAddr# :: Addr# -> Int# -> Double -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> Double -> State# s -> State# s

Unbox Double

Defined in Data.Vector.Unboxed.Base

Pretty Double

>>> pretty (exp 1 :: Double)
2.71828182845904...

Defined in Data.Text.Prettyprint.Doc.Internal

Methods

pretty :: Double -> Doc ann

prettyList :: [Double] -> Doc ann

Pretty Double

Defined in Text.PrettyPrint.Annotated.WL

Methods

pretty :: Double -> Doc b

prettyList :: [Double] -> Doc b

RealFrac Double

Defined in Data.Array.Accelerate.Classes.RealFrac

Methods

properFraction :: (Integral b, FromIntegral Int64 b) => Exp Double -> (Exp b, Exp Double)

truncate :: (Integral b, FromIntegral Int64 b) => Exp Double -> Exp b

round :: (Integral b, FromIntegral Int64 b) => Exp Double -> Exp b

ceiling :: (Integral b, FromIntegral Int64 b) => Exp Double -> Exp b

floor :: (Integral b, FromIntegral Int64 b) => Exp Double -> Exp b

Elt Double

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR Double

Methods

eltR :: TypeR (EltR Double)

tagsR :: [TagR (EltR Double)]

fromElt :: Double -> EltR Double

toElt :: EltR Double -> Double

Eq Double

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp Double -> Exp Double -> Exp Bool

(/=) :: Exp Double -> Exp Double -> Exp Bool

Ord Double

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp Double -> Exp Double -> Exp Bool

(>) :: Exp Double -> Exp Double -> Exp Bool

(<=) :: Exp Double -> Exp Double -> Exp Bool

(>=) :: Exp Double -> Exp Double -> Exp Bool

min :: Exp Double -> Exp Double -> Exp Double

max :: Exp Double -> Exp Double -> Exp Double

compare :: Exp Double -> Exp Double -> Exp Ordering

RealFloat Double

Defined in Data.Array.Accelerate.Classes.RealFloat

Methods

floatRadix :: Exp Double -> Exp Int64

floatDigits :: Exp Double -> Exp Int

floatRange :: Exp Double -> (Exp Int, Exp Int)

decodeFloat :: Exp Double -> (Exp Int64, Exp Int)

encodeFloat :: Exp Int64 -> Exp Int -> Exp Double

exponent :: Exp Double -> Exp Int

significand :: Exp Double -> Exp Double

scaleFloat :: Exp Int -> Exp Double -> Exp Double

isNaN :: Exp Double -> Exp Bool

isInfinite :: Exp Double -> Exp Bool

isDenormalized :: Exp Double -> Exp Bool

isNegativeZero :: Exp Double -> Exp Bool

isIEEE :: Exp Double -> Exp Bool

atan2 :: Exp Double -> Exp Double -> Exp Double

Rational Double

Defined in Data.Array.Accelerate.Classes.Rational

Methods

toRational :: (FromIntegral Int64 b, Integral b) => Exp Double -> Exp (Ratio b)

Lift Double

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Double -> Q Exp

liftTyped :: Double -> Q (TExp Double)

Vector Vector Double

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Double -> m (Vector Double)

basicUnsafeThaw :: PrimMonad m => Vector Double -> m (Mutable Vector (PrimState m) Double)

basicLength :: Vector Double -> Int

basicUnsafeSlice :: Int -> Int -> Vector Double -> Vector Double

basicUnsafeIndexM :: Monad m => Vector Double -> Int -> m Double

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Double -> Vector Double -> m ()

elemseq :: Vector Double -> Double -> b -> b

MVector MVector Double

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Double -> Int

basicUnsafeSlice :: Int -> Int -> MVector s Double -> MVector s Double

basicOverlaps :: MVector s Double -> MVector s Double -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Double)

basicInitialize :: PrimMonad m => MVector (PrimState m) Double -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Double -> m (MVector (PrimState m) Double)

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Double -> Int -> m Double

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Double -> Int -> Double -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) Double -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) Double -> Double -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Double -> MVector (PrimState m) Double -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Double -> MVector (PrimState m) Double -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Double -> Int -> m (MVector (PrimState m) Double)

ToFloating Double Double

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Double -> Exp Double

ToFloating Double Float

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Double -> Exp Float

ToFloating Double Half

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Double -> Exp Half

ToFloating Float Double

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Float -> Exp Double

ToFloating Int Double

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Int -> Exp Double

ToFloating Int8 Double

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Int8 -> Exp Double

ToFloating Int16 Double

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Int16 -> Exp Double

ToFloating Int32 Double

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Int32 -> Exp Double

ToFloating Int64 Double

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Int64 -> Exp Double

ToFloating Word Double

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Word -> Exp Double

ToFloating Word8 Double

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Word8 -> Exp Double

ToFloating Word16 Double

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Word16 -> Exp Double

ToFloating Word32 Double

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Word32 -> Exp Double

ToFloating Word64 Double

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Word64 -> Exp Double

ToFloating Half Double

Defined in Data.Array.Accelerate.Classes.ToFloating

Methods

toFloating :: Exp Half -> Exp Double

Lift Exp Double

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain Double

Methods

lift :: Double -> Exp (Plain Double)

FromIntegral Int Double

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int -> Exp Double

FromIntegral Int8 Double

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int8 -> Exp Double

FromIntegral Int16 Double

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int16 -> Exp Double

FromIntegral Int32 Double

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int32 -> Exp Double

FromIntegral Int64 Double

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Int64 -> Exp Double

FromIntegral Word Double

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word -> Exp Double

FromIntegral Word8 Double

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word8 -> Exp Double

FromIntegral Word16 Double

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word16 -> Exp Double

FromIntegral Word32 Double

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word32 -> Exp Double

FromIntegral Word64 Double

Defined in Data.Array.Accelerate.Classes.FromIntegral

Methods

fromIntegral :: Exp Word64 -> Exp Double

Generic1 (URec Double :: k -> Type)

Since: base-4.9.0.0

Defined in GHC.Generics

Associated Types

type Rep1 (URec Double) :: k -> Type

Methods

from1 :: forall (a :: k0). URec Double a -> Rep1 (URec Double) a

to1 :: forall (a :: k0). Rep1 (URec Double) a -> URec Double a

Enum (Exp Double)

Defined in Data.Array.Accelerate.Classes.Enum

Methods

succ :: Exp Double -> Exp Double

pred :: Exp Double -> Exp Double

toEnum :: Int -> Exp Double

fromEnum :: Exp Double -> Int

enumFrom :: Exp Double -> [Exp Double]

enumFromThen :: Exp Double -> Exp Double -> [Exp Double]

enumFromTo :: Exp Double -> Exp Double -> [Exp Double]

enumFromThenTo :: Exp Double -> Exp Double -> Exp Double -> [Exp Double]

Floating (Exp Double)

Defined in Data.Array.Accelerate.Classes.Floating

Methods

pi :: Exp Double

exp :: Exp Double -> Exp Double

log :: Exp Double -> Exp Double

sqrt :: Exp Double -> Exp Double

(**) :: Exp Double -> Exp Double -> Exp Double

logBase :: Exp Double -> Exp Double -> Exp Double

sin :: Exp Double -> Exp Double

cos :: Exp Double -> Exp Double

tan :: Exp Double -> Exp Double

asin :: Exp Double -> Exp Double

acos :: Exp Double -> Exp Double

atan :: Exp Double -> Exp Double

sinh :: Exp Double -> Exp Double

cosh :: Exp Double -> Exp Double

tanh :: Exp Double -> Exp Double

asinh :: Exp Double -> Exp Double

acosh :: Exp Double -> Exp Double

atanh :: Exp Double -> Exp Double

log1p :: Exp Double -> Exp Double

expm1 :: Exp Double -> Exp Double

log1pexp :: Exp Double -> Exp Double

log1mexp :: Exp Double -> Exp Double

Fractional (Exp Double)

Defined in Data.Array.Accelerate.Classes.Fractional

Methods

(/) :: Exp Double -> Exp Double -> Exp Double

recip :: Exp Double -> Exp Double

fromRational :: Rational -> Exp Double

Num (Exp Double)

Defined in Data.Array.Accelerate.Classes.Num

Methods

(+) :: Exp Double -> Exp Double -> Exp Double

(-) :: Exp Double -> Exp Double -> Exp Double

(*) :: Exp Double -> Exp Double -> Exp Double

negate :: Exp Double -> Exp Double

abs :: Exp Double -> Exp Double

signum :: Exp Double -> Exp Double

fromInteger :: Integer -> Exp Double

Foldable (UDouble :: Type -> Type)

Since: base-4.9.0.0

Defined in Data.Foldable

Methods

fold :: Monoid m => UDouble m -> m

foldMap :: Monoid m => (a -> m) -> UDouble a -> m

foldMap' :: Monoid m => (a -> m) -> UDouble a -> m

foldr :: (a -> b -> b) -> b -> UDouble a -> b

foldr' :: (a -> b -> b) -> b -> UDouble a -> b

foldl :: (b -> a -> b) -> b -> UDouble a -> b

foldl' :: (b -> a -> b) -> b -> UDouble a -> b

foldr1 :: (a -> a -> a) -> UDouble a -> a

foldl1 :: (a -> a -> a) -> UDouble a -> a

toList :: UDouble a -> [a]

null :: UDouble a -> Bool

length :: UDouble a -> Int

elem :: Eq a => a -> UDouble a -> Bool

maximum :: Ord a => UDouble a -> a

minimum :: Ord a => UDouble a -> a

sum :: Num a => UDouble a -> a

product :: Num a => UDouble a -> a

Traversable (UDouble :: Type -> Type)

Since: base-4.9.0.0

Defined in Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> UDouble a -> f (UDouble b)

sequenceA :: Applicative f => UDouble (f a) -> f (UDouble a)

mapM :: Monad m => (a -> m b) -> UDouble a -> m (UDouble b)

sequence :: Monad m => UDouble (m a) -> m (UDouble a)

Functor (URec Double :: Type -> Type)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> URec Double a -> URec Double b

(<$) :: a -> URec Double b -> URec Double a

Eq (URec Double p)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

(==) :: URec Double p -> URec Double p -> Bool

(/=) :: URec Double p -> URec Double p -> Bool

Ord (URec Double p)

Since: base-4.9.0.0

Defined in GHC.Generics

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)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

showsPrec :: Int -> URec Double p -> ShowS

show :: URec Double p -> String

showList :: [URec Double p] -> ShowS

Generic (URec Double p)

Since: base-4.9.0.0

Defined in GHC.Generics

Associated Types

type Rep (URec Double p) :: Type -> Type

Methods

from :: URec Double p -> Rep (URec Double p) x

to :: Rep (URec Double p) x -> URec Double p

type PrimSize Double

Defined in Basement.PrimType

type PrimSize Double = 8

type Difference Double

Defined in Basement.Numerical.Subtractive

type Difference Double = Double

newtype Vector Double

Defined in Data.Vector.Unboxed.Base

newtype Vector Double = V_Double (Vector Double)

type Plain Double

Defined in Data.Array.Accelerate.Lift

type Plain Double = Double

data URec Double (p :: k)

Used for marking occurrences of Double#

Since: base-4.9.0.0

Defined in GHC.Generics

data URec Double (p :: k) = UDouble {

• uDouble# :: Double#

}

newtype MVector s Double

Defined in Data.Vector.Unboxed.Base

newtype MVector s Double = MV_Double (MVector s Double)

type Rep1 (URec Double :: k -> Type)

Defined in GHC.Generics

type Rep1 (URec Double :: k -> Type) = D1 ('MetaData "URec" "GHC.Generics" "base" 'False) (C1 ('MetaCons "UDouble" 'PrefixI 'True) (S1 ('MetaSel ('Just "uDouble#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UDouble :: k -> Type)))

type Rep (URec Double p)

Defined in GHC.Generics

type Rep (URec Double p) = D1 ('MetaData "URec" "GHC.Generics" "base" 'False) (C1 ('MetaCons "UDouble" 'PrefixI 'True) (S1 ('MetaSel ('Just "uDouble#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UDouble :: Type -> Type)))

data Bool

Constructors

False

True

Instances

Bounded Bool

Since: base-2.1

Defined in GHC.Enum

Methods

minBound :: Bool

maxBound :: Bool

Enum Bool

Since: base-2.1

Defined in GHC.Enum

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

Defined in GHC.Classes

Methods

(==) :: Bool -> Bool -> Bool

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

Ord Bool

Defined in GHC.Classes

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

Read Bool

Since: base-2.1

Defined in GHC.Read

Methods

readsPrec :: Int -> ReadS Bool

readList :: ReadS [Bool]

readPrec :: ReadPrec Bool

readListPrec :: ReadPrec [Bool]

Show Bool

Since: base-2.1

Defined in GHC.Show

Methods

showsPrec :: Int -> Bool -> ShowS

show :: Bool -> String

showList :: [Bool] -> ShowS

Ix Bool

Since: base-2.1

Defined in GHC.Ix

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

Since: base-4.6.0.0

Defined in GHC.Generics

Associated Types

type Rep Bool :: Type -> Type

Methods

from :: Bool -> Rep Bool x

to :: Rep Bool x -> Bool

Storable Bool

Since: base-2.1

Defined in Foreign.Storable

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

Interpret Bool as 1-bit bit-field

Since: base-4.7.0.0

Defined in Data.Bits

Methods

(.&.) :: Bool -> Bool -> Bool

(.|.) :: Bool -> Bool -> Bool

xor :: Bool -> Bool -> Bool

complement :: Bool -> Bool

shift :: Bool -> Int -> Bool

rotate :: Bool -> Int -> Bool

zeroBits :: Bool

bit :: Int -> Bool

setBit :: Bool -> Int -> Bool

clearBit :: Bool -> Int -> Bool

complementBit :: Bool -> Int -> Bool

testBit :: Bool -> Int -> Bool

bitSizeMaybe :: Bool -> Maybe Int

bitSize :: Bool -> Int

isSigned :: Bool -> Bool

shiftL :: Bool -> Int -> Bool

unsafeShiftL :: Bool -> Int -> Bool

shiftR :: Bool -> Int -> Bool

unsafeShiftR :: Bool -> Int -> Bool

rotateL :: Bool -> Int -> Bool

rotateR :: Bool -> Int -> Bool

popCount :: Bool -> Int

FiniteBits Bool

Since: base-4.7.0.0

Defined in Data.Bits

Methods

finiteBitSize :: Bool -> Int

countLeadingZeros :: Bool -> Int

countTrailingZeros :: Bool -> Int

NFData Bool

Defined in Control.DeepSeq

Methods

rnf :: Bool -> ()

Hashable Bool

Defined in Data.Hashable.Class

Methods

hashWithSalt :: Int -> Bool -> Int

hash :: Bool -> Int

Unbox Bool

Defined in Data.Vector.Unboxed.Base

Pretty Bool

>>> pretty True
True

Defined in Data.Text.Prettyprint.Doc.Internal

Methods

pretty :: Bool -> Doc ann

prettyList :: [Bool] -> Doc ann

Pretty Bool

Defined in Text.PrettyPrint.Annotated.WL

Methods

pretty :: Bool -> Doc b

prettyList :: [Bool] -> Doc b

SingKind Bool

Since: base-4.9.0.0

Defined in GHC.Generics

Associated Types

type DemoteRep Bool

Methods

fromSing :: forall (a :: Bool). Sing a -> DemoteRep Bool

Elt Bool

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR Bool

Methods

eltR :: TypeR (EltR Bool)

tagsR :: [TagR (EltR Bool)]

fromElt :: Bool -> EltR Bool

toElt :: EltR Bool -> Bool

Eq Bool

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp Bool -> Exp Bool -> Exp Bool

(/=) :: Exp Bool -> Exp Bool -> Exp Bool

FiniteBits Bool

Defined in Data.Array.Accelerate.Data.Bits

Methods

finiteBitSize :: Exp Bool -> Exp Int

countLeadingZeros :: Exp Bool -> Exp Int

countTrailingZeros :: Exp Bool -> Exp Int

Bits Bool

Defined in Data.Array.Accelerate.Data.Bits

Methods

(.&.) :: Exp Bool -> Exp Bool -> Exp Bool

(.|.) :: Exp Bool -> Exp Bool -> Exp Bool

xor :: Exp Bool -> Exp Bool -> Exp Bool

complement :: Exp Bool -> Exp Bool

shift :: Exp Bool -> Exp Int -> Exp Bool

rotate :: Exp Bool -> Exp Int -> Exp Bool

zeroBits :: Exp Bool

bit :: Exp Int -> Exp Bool

setBit :: Exp Bool -> Exp Int -> Exp Bool

clearBit :: Exp Bool -> Exp Int -> Exp Bool

complementBit :: Exp Bool -> Exp Int -> Exp Bool

testBit :: Exp Bool -> Exp Int -> Exp Bool

isSigned :: Exp Bool -> Exp Bool

shiftL :: Exp Bool -> Exp Int -> Exp Bool

unsafeShiftL :: Exp Bool -> Exp Int -> Exp Bool

shiftR :: Exp Bool -> Exp Int -> Exp Bool

unsafeShiftR :: Exp Bool -> Exp Int -> Exp Bool

rotateL :: Exp Bool -> Exp Int -> Exp Bool

rotateR :: Exp Bool -> Exp Int -> Exp Bool

popCount :: Exp Bool -> Exp Int

Lift Bool

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Bool -> Q Exp

liftTyped :: Bool -> Q (TExp Bool)

Vector Vector Bool

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Bool -> m (Vector Bool)

basicUnsafeThaw :: PrimMonad m => Vector Bool -> m (Mutable Vector (PrimState m) Bool)

basicLength :: Vector Bool -> Int

basicUnsafeSlice :: Int -> Int -> Vector Bool -> Vector Bool

basicUnsafeIndexM :: Monad m => Vector Bool -> Int -> m Bool

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Bool -> Vector Bool -> m ()

elemseq :: Vector Bool -> Bool -> b -> b

MVector MVector Bool

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Bool -> Int

basicUnsafeSlice :: Int -> Int -> MVector s Bool -> MVector s Bool

basicOverlaps :: MVector s Bool -> MVector s Bool -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Bool)

basicInitialize :: PrimMonad m => MVector (PrimState m) Bool -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Bool -> m (MVector (PrimState m) Bool)

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Bool -> Int -> m Bool

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Bool -> Int -> Bool -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) Bool -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) Bool -> Bool -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Bool -> MVector (PrimState m) Bool -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Bool -> MVector (PrimState m) Bool -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Bool -> Int -> m (MVector (PrimState m) Bool)

SingI 'False

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

sing :: Sing 'False

SingI 'True

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

sing :: Sing 'True

Lift Exp Bool

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain Bool

Methods

lift :: Bool -> Exp (Plain Bool)

Bounded (Exp Bool)

Defined in Data.Array.Accelerate.Classes.Bounded

Methods

minBound :: Exp Bool

maxBound :: Exp Bool

type Rep Bool

Defined in GHC.Generics

type Rep Bool = D1 ('MetaData "Bool" "GHC.Types" "ghc-prim" 'False) (C1 ('MetaCons "False" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "True" 'PrefixI 'False) (U1 :: Type -> Type))

newtype Vector Bool

Defined in Data.Vector.Unboxed.Base

newtype Vector Bool = V_Bool (Vector Word8)

type DemoteRep Bool

Defined in GHC.Generics

type DemoteRep Bool = Bool

data Sing (a :: Bool)

Defined in GHC.Generics

data Sing (a :: Bool) where

• STrue :: Sing 'True
• SFalse :: Sing 'False

type Plain Bool

Defined in Data.Array.Accelerate.Lift

type Plain Bool = Bool

newtype MVector s Bool

Defined in Data.Vector.Unboxed.Base

newtype MVector s Bool = MV_Bool (MVector s Word8)

pattern True_ :: HasCallStack => Exp Bool

pattern False_ :: HasCallStack => Exp Bool

data Maybe a

The Maybe type encapsulates an optional value. A value of type Maybe a either contains a value of type a (represented as Just a), or it is empty (represented as Nothing). Using Maybe is a good way to deal with errors or exceptional cases without resorting to drastic measures such as error.

The Maybe type is also a monad. It is a simple kind of error monad, where all errors are represented by Nothing. A richer error monad can be built using the Either type.

Constructors

Nothing

Just a

Instances

Monad Maybe

Since: base-2.1

Defined in GHC.Base

Methods

(>>=) :: Maybe a -> (a -> Maybe b) -> Maybe b

(>>) :: Maybe a -> Maybe b -> Maybe b

return :: a -> Maybe a

Functor Maybe

Since: base-2.1

Defined in GHC.Base

Methods

fmap :: (a -> b) -> Maybe a -> Maybe b

(<$) :: a -> Maybe b -> Maybe a

MonadFix Maybe

Since: base-2.1

Defined in Control.Monad.Fix

Methods

mfix :: (a -> Maybe a) -> Maybe a

MonadFail Maybe

Since: base-4.9.0.0

Defined in Control.Monad.Fail

Methods

fail :: String -> Maybe a

Applicative Maybe

Since: base-2.1

Defined in GHC.Base

Methods

pure :: a -> Maybe a

(<*>) :: Maybe (a -> b) -> Maybe a -> Maybe b

liftA2 :: (a -> b -> c) -> Maybe a -> Maybe b -> Maybe c

(*>) :: Maybe a -> Maybe b -> Maybe b

(<*) :: Maybe a -> Maybe b -> Maybe a

Foldable Maybe

Since: base-2.1

Defined in Data.Foldable

Methods

fold :: Monoid m => Maybe m -> m

foldMap :: Monoid m => (a -> m) -> Maybe a -> m

foldMap' :: Monoid m => (a -> m) -> Maybe a -> m

foldr :: (a -> b -> b) -> b -> Maybe a -> b

foldr' :: (a -> b -> b) -> b -> Maybe a -> b

foldl :: (b -> a -> b) -> b -> Maybe a -> b

foldl' :: (b -> a -> b) -> b -> Maybe a -> b

foldr1 :: (a -> a -> a) -> Maybe a -> a

foldl1 :: (a -> a -> a) -> Maybe a -> a

toList :: Maybe a -> [a]

null :: Maybe a -> Bool

length :: Maybe a -> Int

elem :: Eq a => a -> Maybe a -> Bool

maximum :: Ord a => Maybe a -> a

minimum :: Ord a => Maybe a -> a

sum :: Num a => Maybe a -> a

product :: Num a => Maybe a -> a

Traversable Maybe

Since: base-2.1

Defined in Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> Maybe a -> f (Maybe b)

sequenceA :: Applicative f => Maybe (f a) -> f (Maybe a)

mapM :: Monad m => (a -> m b) -> Maybe a -> m (Maybe b)

sequence :: Monad m => Maybe (m a) -> m (Maybe a)

Eq1 Maybe

Since: base-4.9.0.0

Defined in Data.Functor.Classes

Methods

liftEq :: (a -> b -> Bool) -> Maybe a -> Maybe b -> Bool

Ord1 Maybe

Since: base-4.9.0.0

Defined in Data.Functor.Classes

Methods

liftCompare :: (a -> b -> Ordering) -> Maybe a -> Maybe b -> Ordering

Read1 Maybe

Since: base-4.9.0.0

Defined in Data.Functor.Classes

Methods

liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Maybe a)

liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Maybe a]

liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Maybe a)

liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Maybe a]

Show1 Maybe

Since: base-4.9.0.0

Defined in Data.Functor.Classes

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Maybe a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Maybe a] -> ShowS

Alternative Maybe

Since: base-2.1

Defined in GHC.Base

Methods

empty :: Maybe a

(<|>) :: Maybe a -> Maybe a -> Maybe a

some :: Maybe a -> Maybe [a]

many :: Maybe a -> Maybe [a]

MonadPlus Maybe

Since: base-2.1

Defined in GHC.Base

Methods

mzero :: Maybe a

mplus :: Maybe a -> Maybe a -> Maybe a

MonadFailure Maybe

Defined in Basement.Monad

Associated Types

type Failure Maybe

Methods

mFail :: Failure Maybe -> Maybe ()

MonadThrow Maybe

Defined in Control.Monad.Catch

Methods

throwM :: Exception e => e -> Maybe a

NFData1 Maybe

Since: deepseq-1.4.3.0

Defined in Control.DeepSeq

Methods

liftRnf :: (a -> ()) -> Maybe a -> ()

Hashable1 Maybe

Defined in Data.Hashable.Class

Methods

liftHashWithSalt :: (Int -> a -> Int) -> Int -> Maybe a -> Int

Functor Maybe

Defined in Data.Array.Accelerate.Data.Maybe

Methods

fmap :: (Elt a, Elt b, Elt (Maybe a), Elt (Maybe b)) => (Exp a -> Exp b) -> Exp (Maybe a) -> Exp (Maybe b)

(<$) :: (Elt a, Elt b, Elt (Maybe a), Elt (Maybe b)) => Exp a -> Exp (Maybe b) -> Exp (Maybe a)

MonadBaseControl Maybe Maybe

Defined in Control.Monad.Trans.Control

Associated Types

type StM Maybe a

Methods

liftBaseWith :: (RunInBase Maybe Maybe -> Maybe a) -> Maybe a

restoreM :: StM Maybe a -> Maybe a

FunctorWithIndex () Maybe

Defined in Control.Lens.Indexed

Methods

imap :: (() -> a -> b) -> Maybe a -> Maybe b

imapped :: IndexedSetter () (Maybe a) (Maybe b) a b

FoldableWithIndex () Maybe

Defined in Control.Lens.Indexed

Methods

ifoldMap :: Monoid m => (() -> a -> m) -> Maybe a -> m

ifolded :: IndexedFold () (Maybe a) a

ifoldr :: (() -> a -> b -> b) -> b -> Maybe a -> b

ifoldl :: (() -> b -> a -> b) -> b -> Maybe a -> b

ifoldr' :: (() -> a -> b -> b) -> b -> Maybe a -> b

ifoldl' :: (() -> b -> a -> b) -> b -> Maybe a -> b

TraversableWithIndex () Maybe

Defined in Control.Lens.Indexed

Methods

itraverse :: Applicative f => (() -> a -> f b) -> Maybe a -> f (Maybe b)

itraversed :: IndexedTraversal () (Maybe a) (Maybe b) a b

Lift a => Lift (Maybe a :: Type)

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Maybe a -> Q Exp

liftTyped :: Maybe a -> Q (TExp (Maybe a))

(Lift Exp a, Elt (Plain a)) => Lift Exp (Maybe a)

Defined in Data.Array.Accelerate.Data.Maybe

Associated Types

type Plain (Maybe a)

Methods

lift :: Maybe a -> Exp (Plain (Maybe a))

Eq a => Eq (Maybe a)

Since: base-2.1

Defined in GHC.Maybe

Methods

(==) :: Maybe a -> Maybe a -> Bool

(/=) :: Maybe a -> Maybe a -> Bool

Ord a => Ord (Maybe a)

Since: base-2.1

Defined in GHC.Maybe

Methods

compare :: Maybe a -> Maybe a -> Ordering

(<) :: Maybe a -> Maybe a -> Bool

(<=) :: Maybe a -> Maybe a -> Bool

(>) :: Maybe a -> Maybe a -> Bool

(>=) :: Maybe a -> Maybe a -> Bool

max :: Maybe a -> Maybe a -> Maybe a

min :: Maybe a -> Maybe a -> Maybe a

Read a => Read (Maybe a)

Since: base-2.1

Defined in GHC.Read

Methods

readsPrec :: Int -> ReadS (Maybe a)

readList :: ReadS [Maybe a]

readPrec :: ReadPrec (Maybe a)

readListPrec :: ReadPrec [Maybe a]

Show a => Show (Maybe a)

Since: base-2.1

Defined in GHC.Show

Methods

showsPrec :: Int -> Maybe a -> ShowS

show :: Maybe a -> String

showList :: [Maybe a] -> ShowS

Generic (Maybe a)

Since: base-4.6.0.0

Defined in GHC.Generics

Associated Types

type Rep (Maybe a) :: Type -> Type

Methods

from :: Maybe a -> Rep (Maybe a) x

to :: Rep (Maybe a) x -> Maybe a

Semigroup a => Semigroup (Maybe a)

Since: base-4.9.0.0

Defined in GHC.Base

Methods

(<>) :: Maybe a -> Maybe a -> Maybe a

sconcat :: NonEmpty (Maybe a) -> Maybe a

stimes :: Integral b => b -> Maybe a -> Maybe a

(Semigroup (Exp a), Elt a) => Semigroup (Exp (Maybe a))

Defined in Data.Array.Accelerate.Data.Maybe

Methods

(<>) :: Exp (Maybe a) -> Exp (Maybe a) -> Exp (Maybe a)

sconcat :: NonEmpty (Exp (Maybe a)) -> Exp (Maybe a)

stimes :: Integral b => b -> Exp (Maybe a) -> Exp (Maybe a)

Semigroup a => Monoid (Maybe a)

Lift a semigroup into Maybe forming a Monoid according to http://en.wikipedia.org/wiki/Monoid: "Any semigroup S may be turned into a monoid simply by adjoining an element e not in S and defining e*e = e and e*s = s = s*e for all s ∈ S."

Since 4.11.0: constraint on inner a value generalised from Monoid to Semigroup.

Since: base-2.1

Defined in GHC.Base

Methods

mempty :: Maybe a

mappend :: Maybe a -> Maybe a -> Maybe a

mconcat :: [Maybe a] -> Maybe a

(Monoid (Exp a), Elt a) => Monoid (Exp (Maybe a))

Defined in Data.Array.Accelerate.Data.Maybe

Methods

mempty :: Exp (Maybe a)

mappend :: Exp (Maybe a) -> Exp (Maybe a) -> Exp (Maybe a)

mconcat :: [Exp (Maybe a)] -> Exp (Maybe a)

NFData a => NFData (Maybe a)

Defined in Control.DeepSeq

Methods

rnf :: Maybe a -> ()

Hashable a => Hashable (Maybe a)

Defined in Data.Hashable.Class

Methods

hashWithSalt :: Int -> Maybe a -> Int

hash :: Maybe a -> Int

Ixed (Maybe a)

Defined in Control.Lens.At

Methods

ix :: Index (Maybe a) -> Traversal' (Maybe a) (IxValue (Maybe a))

At (Maybe a)

Defined in Control.Lens.At

Methods

at :: Index (Maybe a) -> Lens' (Maybe a) (Maybe (IxValue (Maybe a)))

AsEmpty (Maybe a)

Defined in Control.Lens.Empty

Methods

_Empty :: Prism' (Maybe a) ()

Pretty a => Pretty (Maybe a)

Ignore Nothings, print Just contents.

>>> pretty (Just True)
True
>>> braces (pretty (Nothing :: Maybe Bool))
{}

>>> pretty [Just 1, Nothing, Just 3, Nothing]
[1, 3]

Defined in Data.Text.Prettyprint.Doc.Internal

Methods

pretty :: Maybe a -> Doc ann

prettyList :: [Maybe a] -> Doc ann

Pretty a => Pretty (Maybe a)

Defined in Text.PrettyPrint.Annotated.WL

Methods

pretty :: Maybe a -> Doc b

prettyList :: [Maybe a] -> Doc b

SingKind a => SingKind (Maybe a)

Since: base-4.9.0.0

Defined in GHC.Generics

Associated Types

type DemoteRep (Maybe a)

Methods

fromSing :: forall (a0 :: Maybe a). Sing a0 -> DemoteRep (Maybe a)

Elt a => Elt (Maybe a)

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR (Maybe a)

Methods

eltR :: TypeR (EltR (Maybe a))

tagsR :: [TagR (EltR (Maybe a))]

fromElt :: Maybe a -> EltR (Maybe a)

toElt :: EltR (Maybe a) -> Maybe a

Eq a => Eq (Maybe a)

Defined in Data.Array.Accelerate.Data.Maybe

Methods

(==) :: Exp (Maybe a) -> Exp (Maybe a) -> Exp Bool

(/=) :: Exp (Maybe a) -> Exp (Maybe a) -> Exp Bool

Ord a => Ord (Maybe a)

Defined in Data.Array.Accelerate.Data.Maybe

Methods

(<) :: Exp (Maybe a) -> Exp (Maybe a) -> Exp Bool

(>) :: Exp (Maybe a) -> Exp (Maybe a) -> Exp Bool

(<=) :: Exp (Maybe a) -> Exp (Maybe a) -> Exp Bool

(>=) :: Exp (Maybe a) -> Exp (Maybe a) -> Exp Bool

min :: Exp (Maybe a) -> Exp (Maybe a) -> Exp (Maybe a)

max :: Exp (Maybe a) -> Exp (Maybe a) -> Exp (Maybe a)

compare :: Exp (Maybe a) -> Exp (Maybe a) -> Exp Ordering

Generic1 Maybe

Since: base-4.6.0.0

Defined in GHC.Generics

Associated Types

type Rep1 Maybe :: k -> Type

Methods

from1 :: forall (a :: k). Maybe a -> Rep1 Maybe a

to1 :: forall (a :: k). Rep1 Maybe a -> Maybe a

SingI ('Nothing :: Maybe a)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

sing :: Sing 'Nothing

Each (Maybe a) (Maybe b) a b

each :: Traversal (Maybe a) (Maybe b) a b

Defined in Control.Lens.Each

Methods

each :: Traversal (Maybe a) (Maybe b) a b

SingI a2 => SingI ('Just a2 :: Maybe a1)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

sing :: Sing ('Just a2)

type Failure Maybe

Defined in Basement.Monad

type Failure Maybe = ()

type StM Maybe a

Defined in Control.Monad.Trans.Control

type StM Maybe a = a

type Rep (Maybe a)

Defined in GHC.Generics

type Rep (Maybe a) = D1 ('MetaData "Maybe" "GHC.Maybe" "base" 'False) (C1 ('MetaCons "Nothing" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Just" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)))

type Index (Maybe a)

Defined in Control.Lens.At

type Index (Maybe a) = ()

type IxValue (Maybe a)

Defined in Control.Lens.At

type IxValue (Maybe a) = a

type DemoteRep (Maybe a)

Defined in GHC.Generics

type DemoteRep (Maybe a) = Maybe (DemoteRep a)

data Sing (b :: Maybe a)

Defined in GHC.Generics

data Sing (b :: Maybe a) where

• SNothing :: forall a. Sing ('Nothing :: Maybe a)
• SJust :: forall a (a1 :: a). Sing a1 -> Sing ('Just a1)

type Plain (Maybe a)

Defined in Data.Array.Accelerate.Data.Maybe

type Plain (Maybe a) = Maybe (Plain a)

type Rep1 Maybe

Defined in GHC.Generics

type Rep1 Maybe = D1 ('MetaData "Maybe" "GHC.Maybe" "base" 'False) (C1 ('MetaCons "Nothing" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Just" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1))

pattern Nothing_ :: forall a. (HasCallStack, Elt a) => Exp (Maybe a)

pattern Just_ :: forall a. (HasCallStack, Elt a) => Exp a -> Exp (Maybe a)

data Char

The character type Char is an enumeration whose values represent Unicode (or equivalently ISO/IEC 10646) code points (i.e. 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

Since: base-2.1

Defined in GHC.Enum

Methods

minBound :: Char

maxBound :: Char

Enum Char

Since: base-2.1

Defined in GHC.Enum

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

Defined in GHC.Classes

Methods

(==) :: Char -> Char -> Bool

(/=) :: Char -> Char -> Bool

Ord Char

Defined in GHC.Classes

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

Read Char

Since: base-2.1

Defined in GHC.Read

Methods

readsPrec :: Int -> ReadS Char

readList :: ReadS [Char]

readPrec :: ReadPrec Char

readListPrec :: ReadPrec [Char]

Show Char

Since: base-2.1

Defined in GHC.Show

Methods

showsPrec :: Int -> Char -> ShowS

show :: Char -> String

showList :: [Char] -> ShowS

Ix Char

Since: base-2.1

Defined in GHC.Ix

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

PrintfArg Char

Since: base-2.1

Defined in Text.Printf

Methods

formatArg :: Char -> FieldFormatter

parseFormat :: Char -> ModifierParser

IsChar Char

Since: base-2.1

Defined in Text.Printf

Methods

toChar :: Char -> Char

fromChar :: Char -> Char

Storable Char

Since: base-2.1

Defined in Foreign.Storable

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

PrimType Char

Defined in Basement.PrimType

Associated Types

type PrimSize Char :: Nat

Methods

primSizeInBytes :: Proxy Char -> CountOf Word8

primShiftToBytes :: Proxy Char -> Int

primBaUIndex :: ByteArray# -> Offset Char -> Char

primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Char -> prim Char

primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Char -> Char -> prim ()

primAddrIndex :: Addr# -> Offset Char -> Char

primAddrRead :: PrimMonad prim => Addr# -> Offset Char -> prim Char

primAddrWrite :: PrimMonad prim => Addr# -> Offset Char -> Char -> prim ()

PrimMemoryComparable Char

Defined in Basement.PrimType

Subtractive Char

Defined in Basement.Numerical.Subtractive

Associated Types

type Difference Char

Methods

(-) :: Char -> Char -> Difference Char

NFData Char

Defined in Control.DeepSeq

Methods

rnf :: Char -> ()

Hashable Char

Defined in Data.Hashable.Class

Methods

hashWithSalt :: Int -> Char -> Int

hash :: Char -> Int

Prim Char

Defined in Data.Primitive.Types

Methods

sizeOf# :: Char -> Int#

alignment# :: Char -> Int#

indexByteArray# :: ByteArray# -> Int# -> Char

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Char #)

writeByteArray# :: MutableByteArray# s -> Int# -> Char -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Char -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> Char

readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Char #)

writeOffAddr# :: Addr# -> Int# -> Char -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> Char -> State# s -> State# s

Unbox Char

Defined in Data.Vector.Unboxed.Base

Pretty Char

Instead of (pretty 'n'), consider using line as a more readable alternative.

>>> pretty 'f' <> pretty 'o' <> pretty 'o'
foo
>>> pretty ("string" :: String)
string

Defined in Data.Text.Prettyprint.Doc.Internal

Methods

pretty :: Char -> Doc ann

prettyList :: [Char] -> Doc ann

ErrorList Char

Defined in Control.Monad.Trans.Error

Methods

listMsg :: String -> [Char]

Pretty Char

Defined in Text.PrettyPrint.Annotated.WL

Methods

pretty :: Char -> Doc b

prettyList :: [Char] -> Doc b

Elt Char

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR Char

Methods

eltR :: TypeR (EltR Char)

tagsR :: [TagR (EltR Char)]

fromElt :: Char -> EltR Char

toElt :: EltR Char -> Char

Eq Char

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp Char -> Exp Char -> Exp Bool

(/=) :: Exp Char -> Exp Char -> Exp Bool

Ord Char

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp Char -> Exp Char -> Exp Bool

(>) :: Exp Char -> Exp Char -> Exp Bool

(<=) :: Exp Char -> Exp Char -> Exp Bool

(>=) :: Exp Char -> Exp Char -> Exp Bool

min :: Exp Char -> Exp Char -> Exp Char

max :: Exp Char -> Exp Char -> Exp Char

compare :: Exp Char -> Exp Char -> Exp Ordering

Lift Char

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Char -> Q Exp

liftTyped :: Char -> Q (TExp Char)

Vector Vector Char

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Char -> m (Vector Char)

basicUnsafeThaw :: PrimMonad m => Vector Char -> m (Mutable Vector (PrimState m) Char)

basicLength :: Vector Char -> Int

basicUnsafeSlice :: Int -> Int -> Vector Char -> Vector Char

basicUnsafeIndexM :: Monad m => Vector Char -> Int -> m Char

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Char -> Vector Char -> m ()

elemseq :: Vector Char -> Char -> b -> b

MVector MVector Char

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Char -> Int

basicUnsafeSlice :: Int -> Int -> MVector s Char -> MVector s Char

basicOverlaps :: MVector s Char -> MVector s Char -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Char)

basicInitialize :: PrimMonad m => MVector (PrimState m) Char -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Char -> m (MVector (PrimState m) Char)

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Char -> Int -> m Char

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Char -> Int -> Char -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) Char -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) Char -> Char -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Char -> MVector (PrimState m) Char -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Char -> MVector (PrimState m) Char -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Char -> Int -> m (MVector (PrimState m) Char)

Lift Exp Char

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain Char

Methods

lift :: Char -> Exp (Plain Char)

KnownSymbol n => Reifies (n :: Symbol) String

Defined in Data.Reflection

Methods

reflect :: proxy n -> String

Cons Text Text Char Char

Defined in Control.Lens.Cons

Methods

_Cons :: Prism Text Text (Char, Text) (Char, Text)

Cons Text Text Char Char

Defined in Control.Lens.Cons

Methods

_Cons :: Prism Text Text (Char, Text) (Char, Text)

Snoc Text Text Char Char

Defined in Control.Lens.Cons

Methods

_Snoc :: Prism Text Text (Text, Char) (Text, Char)

Snoc Text Text Char Char

Defined in Control.Lens.Cons

Methods

_Snoc :: Prism Text Text (Text, Char) (Text, Char)

Generic1 (URec Char :: k -> Type)

Since: base-4.9.0.0

Defined in GHC.Generics

Associated Types

type Rep1 (URec Char) :: k -> Type

Methods

from1 :: forall (a :: k0). URec Char a -> Rep1 (URec Char) a

to1 :: forall (a :: k0). Rep1 (URec Char) a -> URec Char a

Bounded (Exp Char)

Defined in Data.Array.Accelerate.Classes.Bounded

Methods

minBound :: Exp Char

maxBound :: Exp Char

Foldable (UChar :: Type -> Type)

Since: base-4.9.0.0

Defined in Data.Foldable

Methods

fold :: Monoid m => UChar m -> m

foldMap :: Monoid m => (a -> m) -> UChar a -> m

foldMap' :: Monoid m => (a -> m) -> UChar a -> m

foldr :: (a -> b -> b) -> b -> UChar a -> b

foldr' :: (a -> b -> b) -> b -> UChar a -> b

foldl :: (b -> a -> b) -> b -> UChar a -> b

foldl' :: (b -> a -> b) -> b -> UChar a -> b

foldr1 :: (a -> a -> a) -> UChar a -> a

foldl1 :: (a -> a -> a) -> UChar a -> a

toList :: UChar a -> [a]

null :: UChar a -> Bool

length :: UChar a -> Int

elem :: Eq a => a -> UChar a -> Bool

maximum :: Ord a => UChar a -> a

minimum :: Ord a => UChar a -> a

sum :: Num a => UChar a -> a

product :: Num a => UChar a -> a

Traversable (UChar :: Type -> Type)

Since: base-4.9.0.0

Defined in Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> UChar a -> f (UChar b)

sequenceA :: Applicative f => UChar (f a) -> f (UChar a)

mapM :: Monad m => (a -> m b) -> UChar a -> m (UChar b)

sequence :: Monad m => UChar (m a) -> m (UChar a)

Functor (URec Char :: Type -> Type)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> URec Char a -> URec Char b

(<$) :: a -> URec Char b -> URec Char a

Eq (URec Char p)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

(==) :: URec Char p -> URec Char p -> Bool

(/=) :: URec Char p -> URec Char p -> Bool

Ord (URec Char p)

Since: base-4.9.0.0

Defined in GHC.Generics

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)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

showsPrec :: Int -> URec Char p -> ShowS

show :: URec Char p -> String

showList :: [URec Char p] -> ShowS

Generic (URec Char p)

Since: base-4.9.0.0

Defined in GHC.Generics

Associated Types

type Rep (URec Char p) :: Type -> Type

Methods

from :: URec Char p -> Rep (URec Char p) x

to :: Rep (URec Char p) x -> URec Char p

type PrimSize Char

Defined in Basement.PrimType

type PrimSize Char = 4

type Difference Char

Defined in Basement.Numerical.Subtractive

type Difference Char = Int

type NatNumMaxBound Char

Defined in Basement.Nat

type NatNumMaxBound Char = 1114111

newtype Vector Char

Defined in Data.Vector.Unboxed.Base

newtype Vector Char = V_Char (Vector Char)

type Plain Char

Defined in Data.Array.Accelerate.Lift

type Plain Char = Char

data URec Char (p :: k)

Used for marking occurrences of Char#

Since: base-4.9.0.0

Defined in GHC.Generics

data URec Char (p :: k) = UChar {

• uChar# :: Char#

}

newtype MVector s Char

Defined in Data.Vector.Unboxed.Base

newtype MVector s Char = MV_Char (MVector s Char)

type Rep1 (URec Char :: k -> Type)

Defined in GHC.Generics

type Rep1 (URec Char :: k -> Type) = D1 ('MetaData "URec" "GHC.Generics" "base" 'False) (C1 ('MetaCons "UChar" 'PrefixI 'True) (S1 ('MetaSel ('Just "uChar#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UChar :: k -> Type)))

type Rep (URec Char p)

Defined in GHC.Generics

type Rep (URec Char p) = D1 ('MetaData "URec" "GHC.Generics" "base" 'False) (C1 ('MetaCons "UChar" 'PrefixI 'True) (S1 ('MetaSel ('Just "uChar#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UChar :: Type -> Type)))

data CFloat

Haskell type representing the C float type. (The concrete types of Foreign.C.Types are platform-specific.)

Instances

Enum CFloat

Defined in Foreign.C.Types

Methods

succ :: CFloat -> CFloat

pred :: CFloat -> CFloat

toEnum :: Int -> CFloat

fromEnum :: CFloat -> Int

enumFrom :: CFloat -> [CFloat]

enumFromThen :: CFloat -> CFloat -> [CFloat]

enumFromTo :: CFloat -> CFloat -> [CFloat]

enumFromThenTo :: CFloat -> CFloat -> CFloat -> [CFloat]

Eq CFloat

Defined in Foreign.C.Types

Methods

(==) :: CFloat -> CFloat -> Bool

(/=) :: CFloat -> CFloat -> Bool

Floating CFloat

Defined in Foreign.C.Types

Methods

pi :: CFloat

exp :: CFloat -> CFloat

log :: CFloat -> CFloat

sqrt :: CFloat -> CFloat

(**) :: CFloat -> CFloat -> CFloat

logBase :: CFloat -> CFloat -> CFloat

sin :: CFloat -> CFloat

cos :: CFloat -> CFloat

tan :: CFloat -> CFloat

asin :: CFloat -> CFloat

acos :: CFloat -> CFloat

atan :: CFloat -> CFloat

sinh :: CFloat -> CFloat

cosh :: CFloat -> CFloat

tanh :: CFloat -> CFloat

asinh :: CFloat -> CFloat

acosh :: CFloat -> CFloat

atanh :: CFloat -> CFloat

log1p :: CFloat -> CFloat

expm1 :: CFloat -> CFloat

log1pexp :: CFloat -> CFloat

log1mexp :: CFloat -> CFloat

Fractional CFloat

Defined in Foreign.C.Types

Methods

(/) :: CFloat -> CFloat -> CFloat

recip :: CFloat -> CFloat

fromRational :: Rational -> CFloat

Num CFloat

Defined in Foreign.C.Types

Methods

(+) :: CFloat -> CFloat -> CFloat

(-) :: CFloat -> CFloat -> CFloat

(*) :: CFloat -> CFloat -> CFloat

negate :: CFloat -> CFloat

abs :: CFloat -> CFloat

signum :: CFloat -> CFloat

fromInteger :: Integer -> CFloat

Ord CFloat

Defined in Foreign.C.Types

Methods

compare :: CFloat -> CFloat -> Ordering

(<) :: CFloat -> CFloat -> Bool

(<=) :: CFloat -> CFloat -> Bool

(>) :: CFloat -> CFloat -> Bool

(>=) :: CFloat -> CFloat -> Bool

max :: CFloat -> CFloat -> CFloat

min :: CFloat -> CFloat -> CFloat

Read CFloat

Defined in Foreign.C.Types

Methods

readsPrec :: Int -> ReadS CFloat

readList :: ReadS [CFloat]

readPrec :: ReadPrec CFloat

readListPrec :: ReadPrec [CFloat]

Real CFloat

Defined in Foreign.C.Types

Methods

toRational :: CFloat -> Rational

RealFloat CFloat

Defined in Foreign.C.Types

Methods

floatRadix :: CFloat -> Integer

floatDigits :: CFloat -> Int

floatRange :: CFloat -> (Int, Int)

decodeFloat :: CFloat -> (Integer, Int)

encodeFloat :: Integer -> Int -> CFloat

exponent :: CFloat -> Int

significand :: CFloat -> CFloat

scaleFloat :: Int -> CFloat -> CFloat

isNaN :: CFloat -> Bool

isInfinite :: CFloat -> Bool

isDenormalized :: CFloat -> Bool

isNegativeZero :: CFloat -> Bool

isIEEE :: CFloat -> Bool

atan2 :: CFloat -> CFloat -> CFloat

RealFrac CFloat

Defined in Foreign.C.Types

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

Defined in Foreign.C.Types

Methods

showsPrec :: Int -> CFloat -> ShowS

show :: CFloat -> String

showList :: [CFloat] -> ShowS

Storable CFloat

Defined in Foreign.C.Types

Methods

sizeOf :: CFloat -> Int

alignment :: CFloat -> Int

peekElemOff :: Ptr CFloat -> Int -> IO CFloat

pokeElemOff :: Ptr CFloat -> Int -> CFloat -> IO ()

peekByteOff :: Ptr b -> Int -> IO CFloat

pokeByteOff :: Ptr b -> Int -> CFloat -> IO ()

peek :: Ptr CFloat -> IO CFloat

poke :: Ptr CFloat -> CFloat -> IO ()

Subtractive CFloat

Defined in Basement.Numerical.Subtractive

Associated Types

type Difference CFloat

Methods

(-) :: CFloat -> CFloat -> Difference CFloat

NFData CFloat

Since: deepseq-1.4.0.0

Defined in Control.DeepSeq

Methods

rnf :: CFloat -> ()

Prim CFloat

Defined in Data.Primitive.Types

Methods

sizeOf# :: CFloat -> Int#

alignment# :: CFloat -> Int#

indexByteArray# :: ByteArray# -> Int# -> CFloat

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, CFloat #)

writeByteArray# :: MutableByteArray# s -> Int# -> CFloat -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> CFloat -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> CFloat

readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, CFloat #)

writeOffAddr# :: Addr# -> Int# -> CFloat -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> CFloat -> State# s -> State# s

Wrapped CFloat

Defined in Control.Lens.Wrapped

Associated Types

type Unwrapped CFloat

Methods

_Wrapped' :: Iso' CFloat (Unwrapped CFloat)

RealFrac CFloat

Defined in Data.Array.Accelerate.Classes.RealFrac

Methods

properFraction :: (Integral b, FromIntegral Int64 b) => Exp CFloat -> (Exp b, Exp CFloat)

truncate :: (Integral b, FromIntegral Int64 b) => Exp CFloat -> Exp b

round :: (Integral b, FromIntegral Int64 b) => Exp CFloat -> Exp b

ceiling :: (Integral b, FromIntegral Int64 b) => Exp CFloat -> Exp b

floor :: (Integral b, FromIntegral Int64 b) => Exp CFloat -> Exp b

Elt CFloat

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR CFloat

Methods

eltR :: TypeR (EltR CFloat)

tagsR :: [TagR (EltR CFloat)]

fromElt :: CFloat -> EltR CFloat

toElt :: EltR CFloat -> CFloat

Eq CFloat

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp CFloat -> Exp CFloat -> Exp Bool

(/=) :: Exp CFloat -> Exp CFloat -> Exp Bool

Ord CFloat

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp CFloat -> Exp CFloat -> Exp Bool

(>) :: Exp CFloat -> Exp CFloat -> Exp Bool

(<=) :: Exp CFloat -> Exp CFloat -> Exp Bool

(>=) :: Exp CFloat -> Exp CFloat -> Exp Bool

min :: Exp CFloat -> Exp CFloat -> Exp CFloat

max :: Exp CFloat -> Exp CFloat -> Exp CFloat

compare :: Exp CFloat -> Exp CFloat -> Exp Ordering

RealFloat CFloat

Defined in Data.Array.Accelerate.Classes.RealFloat

Methods

floatRadix :: Exp CFloat -> Exp Int64

floatDigits :: Exp CFloat -> Exp Int

floatRange :: Exp CFloat -> (Exp Int, Exp Int)

decodeFloat :: Exp CFloat -> (Exp Int64, Exp Int)

encodeFloat :: Exp Int64 -> Exp Int -> Exp CFloat

exponent :: Exp CFloat -> Exp Int

significand :: Exp CFloat -> Exp CFloat

scaleFloat :: Exp Int -> Exp CFloat -> Exp CFloat

isNaN :: Exp CFloat -> Exp Bool

isInfinite :: Exp CFloat -> Exp Bool

isDenormalized :: Exp CFloat -> Exp Bool

isNegativeZero :: Exp CFloat -> Exp Bool

isIEEE :: Exp CFloat -> Exp Bool

atan2 :: Exp CFloat -> Exp CFloat -> Exp CFloat

Rewrapped CFloat t

Defined in Control.Lens.Wrapped

Lift Exp CFloat

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain CFloat

Methods

lift :: CFloat -> Exp (Plain CFloat)

Enum (Exp CFloat)

Defined in Data.Array.Accelerate.Classes.Enum

Methods

succ :: Exp CFloat -> Exp CFloat

pred :: Exp CFloat -> Exp CFloat

toEnum :: Int -> Exp CFloat

fromEnum :: Exp CFloat -> Int

enumFrom :: Exp CFloat -> [Exp CFloat]

enumFromThen :: Exp CFloat -> Exp CFloat -> [Exp CFloat]

enumFromTo :: Exp CFloat -> Exp CFloat -> [Exp CFloat]

enumFromThenTo :: Exp CFloat -> Exp CFloat -> Exp CFloat -> [Exp CFloat]

Floating (Exp CFloat)

Defined in Data.Array.Accelerate.Classes.Floating

Methods

pi :: Exp CFloat

exp :: Exp CFloat -> Exp CFloat

log :: Exp CFloat -> Exp CFloat

sqrt :: Exp CFloat -> Exp CFloat

(**) :: Exp CFloat -> Exp CFloat -> Exp CFloat

logBase :: Exp CFloat -> Exp CFloat -> Exp CFloat

sin :: Exp CFloat -> Exp CFloat

cos :: Exp CFloat -> Exp CFloat

tan :: Exp CFloat -> Exp CFloat

asin :: Exp CFloat -> Exp CFloat

acos :: Exp CFloat -> Exp CFloat

atan :: Exp CFloat -> Exp CFloat

sinh :: Exp CFloat -> Exp CFloat

cosh :: Exp CFloat -> Exp CFloat

tanh :: Exp CFloat -> Exp CFloat

asinh :: Exp CFloat -> Exp CFloat

acosh :: Exp CFloat -> Exp CFloat

atanh :: Exp CFloat -> Exp CFloat

log1p :: Exp CFloat -> Exp CFloat

expm1 :: Exp CFloat -> Exp CFloat

log1pexp :: Exp CFloat -> Exp CFloat

log1mexp :: Exp CFloat -> Exp CFloat

Fractional (Exp CFloat)

Defined in Data.Array.Accelerate.Classes.Fractional

Methods

(/) :: Exp CFloat -> Exp CFloat -> Exp CFloat

recip :: Exp CFloat -> Exp CFloat

fromRational :: Rational -> Exp CFloat

Num (Exp CFloat)

Defined in Data.Array.Accelerate.Classes.Num

Methods

(+) :: Exp CFloat -> Exp CFloat -> Exp CFloat

(-) :: Exp CFloat -> Exp CFloat -> Exp CFloat

(*) :: Exp CFloat -> Exp CFloat -> Exp CFloat

negate :: Exp CFloat -> Exp CFloat

abs :: Exp CFloat -> Exp CFloat

signum :: Exp CFloat -> Exp CFloat

fromInteger :: Integer -> Exp CFloat

type Difference CFloat

Defined in Basement.Numerical.Subtractive

type Difference CFloat = CFloat

type Unwrapped CFloat

Defined in Control.Lens.Wrapped

type Unwrapped CFloat = Float

type Plain CFloat

Defined in Data.Array.Accelerate.Lift

type Plain CFloat = CFloat

data CDouble

Haskell type representing the C double type. (The concrete types of Foreign.C.Types are platform-specific.)

Instances

Enum CDouble

Defined in Foreign.C.Types

Methods

succ :: CDouble -> CDouble

pred :: CDouble -> CDouble

toEnum :: Int -> CDouble

fromEnum :: CDouble -> Int

enumFrom :: CDouble -> [CDouble]

enumFromThen :: CDouble -> CDouble -> [CDouble]

enumFromTo :: CDouble -> CDouble -> [CDouble]

enumFromThenTo :: CDouble -> CDouble -> CDouble -> [CDouble]

Eq CDouble

Defined in Foreign.C.Types

Methods

(==) :: CDouble -> CDouble -> Bool

(/=) :: CDouble -> CDouble -> Bool

Floating CDouble

Defined in Foreign.C.Types

Methods

pi :: CDouble

exp :: CDouble -> CDouble

log :: CDouble -> CDouble

sqrt :: CDouble -> CDouble

(**) :: CDouble -> CDouble -> CDouble

logBase :: CDouble -> CDouble -> CDouble

sin :: CDouble -> CDouble

cos :: CDouble -> CDouble

tan :: CDouble -> CDouble

asin :: CDouble -> CDouble

acos :: CDouble -> CDouble

atan :: CDouble -> CDouble

sinh :: CDouble -> CDouble

cosh :: CDouble -> CDouble

tanh :: CDouble -> CDouble

asinh :: CDouble -> CDouble

acosh :: CDouble -> CDouble

atanh :: CDouble -> CDouble

log1p :: CDouble -> CDouble

expm1 :: CDouble -> CDouble

log1pexp :: CDouble -> CDouble

log1mexp :: CDouble -> CDouble

Fractional CDouble

Defined in Foreign.C.Types

Methods

(/) :: CDouble -> CDouble -> CDouble

recip :: CDouble -> CDouble

fromRational :: Rational -> CDouble

Num CDouble

Defined in Foreign.C.Types

Methods

(+) :: CDouble -> CDouble -> CDouble

(-) :: CDouble -> CDouble -> CDouble

(*) :: CDouble -> CDouble -> CDouble

negate :: CDouble -> CDouble

abs :: CDouble -> CDouble

signum :: CDouble -> CDouble

fromInteger :: Integer -> CDouble

Ord CDouble

Defined in Foreign.C.Types

Methods

compare :: CDouble -> CDouble -> Ordering

(<) :: CDouble -> CDouble -> Bool

(<=) :: CDouble -> CDouble -> Bool

(>) :: CDouble -> CDouble -> Bool

(>=) :: CDouble -> CDouble -> Bool

max :: CDouble -> CDouble -> CDouble

min :: CDouble -> CDouble -> CDouble

Read CDouble

Defined in Foreign.C.Types

Methods

readsPrec :: Int -> ReadS CDouble

readList :: ReadS [CDouble]

readPrec :: ReadPrec CDouble

readListPrec :: ReadPrec [CDouble]

Real CDouble

Defined in Foreign.C.Types

Methods

toRational :: CDouble -> Rational

RealFloat CDouble

Defined in Foreign.C.Types

Methods

floatRadix :: CDouble -> Integer

floatDigits :: CDouble -> Int

floatRange :: CDouble -> (Int, Int)

decodeFloat :: CDouble -> (Integer, Int)

encodeFloat :: Integer -> Int -> CDouble

exponent :: CDouble -> Int

significand :: CDouble -> CDouble

scaleFloat :: Int -> CDouble -> CDouble

isNaN :: CDouble -> Bool

isInfinite :: CDouble -> Bool

isDenormalized :: CDouble -> Bool

isNegativeZero :: CDouble -> Bool

isIEEE :: CDouble -> Bool

atan2 :: CDouble -> CDouble -> CDouble

RealFrac CDouble

Defined in Foreign.C.Types

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

Defined in Foreign.C.Types

Methods

showsPrec :: Int -> CDouble -> ShowS

show :: CDouble -> String

showList :: [CDouble] -> ShowS

Storable CDouble

Defined in Foreign.C.Types

Methods

sizeOf :: CDouble -> Int

alignment :: CDouble -> Int

peekElemOff :: Ptr CDouble -> Int -> IO CDouble

pokeElemOff :: Ptr CDouble -> Int -> CDouble -> IO ()

peekByteOff :: Ptr b -> Int -> IO CDouble

pokeByteOff :: Ptr b -> Int -> CDouble -> IO ()

peek :: Ptr CDouble -> IO CDouble

poke :: Ptr CDouble -> CDouble -> IO ()

Subtractive CDouble

Defined in Basement.Numerical.Subtractive

Associated Types

type Difference CDouble

Methods

(-) :: CDouble -> CDouble -> Difference CDouble

NFData CDouble

Since: deepseq-1.4.0.0

Defined in Control.DeepSeq

Methods

rnf :: CDouble -> ()

Prim CDouble

Defined in Data.Primitive.Types

Methods

sizeOf# :: CDouble -> Int#

alignment# :: CDouble -> Int#

indexByteArray# :: ByteArray# -> Int# -> CDouble

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, CDouble #)

writeByteArray# :: MutableByteArray# s -> Int# -> CDouble -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> CDouble -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> CDouble

readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, CDouble #)

writeOffAddr# :: Addr# -> Int# -> CDouble -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> CDouble -> State# s -> State# s

Wrapped CDouble

Defined in Control.Lens.Wrapped

Associated Types

type Unwrapped CDouble

Methods

_Wrapped' :: Iso' CDouble (Unwrapped CDouble)

RealFrac CDouble

Defined in Data.Array.Accelerate.Classes.RealFrac

Methods

properFraction :: (Integral b, FromIntegral Int64 b) => Exp CDouble -> (Exp b, Exp CDouble)

truncate :: (Integral b, FromIntegral Int64 b) => Exp CDouble -> Exp b

round :: (Integral b, FromIntegral Int64 b) => Exp CDouble -> Exp b

ceiling :: (Integral b, FromIntegral Int64 b) => Exp CDouble -> Exp b

floor :: (Integral b, FromIntegral Int64 b) => Exp CDouble -> Exp b

Elt CDouble

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR CDouble

Methods

eltR :: TypeR (EltR CDouble)

tagsR :: [TagR (EltR CDouble)]

fromElt :: CDouble -> EltR CDouble

toElt :: EltR CDouble -> CDouble

Eq CDouble

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp CDouble -> Exp CDouble -> Exp Bool

(/=) :: Exp CDouble -> Exp CDouble -> Exp Bool

Ord CDouble

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp CDouble -> Exp CDouble -> Exp Bool

(>) :: Exp CDouble -> Exp CDouble -> Exp Bool

(<=) :: Exp CDouble -> Exp CDouble -> Exp Bool

(>=) :: Exp CDouble -> Exp CDouble -> Exp Bool

min :: Exp CDouble -> Exp CDouble -> Exp CDouble

max :: Exp CDouble -> Exp CDouble -> Exp CDouble

compare :: Exp CDouble -> Exp CDouble -> Exp Ordering

RealFloat CDouble

Defined in Data.Array.Accelerate.Classes.RealFloat

Methods

floatRadix :: Exp CDouble -> Exp Int64

floatDigits :: Exp CDouble -> Exp Int

floatRange :: Exp CDouble -> (Exp Int, Exp Int)

decodeFloat :: Exp CDouble -> (Exp Int64, Exp Int)

encodeFloat :: Exp Int64 -> Exp Int -> Exp CDouble

exponent :: Exp CDouble -> Exp Int

significand :: Exp CDouble -> Exp CDouble

scaleFloat :: Exp Int -> Exp CDouble -> Exp CDouble

isNaN :: Exp CDouble -> Exp Bool

isInfinite :: Exp CDouble -> Exp Bool

isDenormalized :: Exp CDouble -> Exp Bool

isNegativeZero :: Exp CDouble -> Exp Bool

isIEEE :: Exp CDouble -> Exp Bool

atan2 :: Exp CDouble -> Exp CDouble -> Exp CDouble

Rewrapped CDouble t

Defined in Control.Lens.Wrapped

Lift Exp CDouble

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain CDouble

Methods

lift :: CDouble -> Exp (Plain CDouble)

Enum (Exp CDouble)

Defined in Data.Array.Accelerate.Classes.Enum

Methods

succ :: Exp CDouble -> Exp CDouble

pred :: Exp CDouble -> Exp CDouble

toEnum :: Int -> Exp CDouble

fromEnum :: Exp CDouble -> Int

enumFrom :: Exp CDouble -> [Exp CDouble]

enumFromThen :: Exp CDouble -> Exp CDouble -> [Exp CDouble]

enumFromTo :: Exp CDouble -> Exp CDouble -> [Exp CDouble]

enumFromThenTo :: Exp CDouble -> Exp CDouble -> Exp CDouble -> [Exp CDouble]

Floating (Exp CDouble)

Defined in Data.Array.Accelerate.Classes.Floating

Methods

pi :: Exp CDouble

exp :: Exp CDouble -> Exp CDouble

log :: Exp CDouble -> Exp CDouble

sqrt :: Exp CDouble -> Exp CDouble

(**) :: Exp CDouble -> Exp CDouble -> Exp CDouble

logBase :: Exp CDouble -> Exp CDouble -> Exp CDouble

sin :: Exp CDouble -> Exp CDouble

cos :: Exp CDouble -> Exp CDouble

tan :: Exp CDouble -> Exp CDouble

asin :: Exp CDouble -> Exp CDouble

acos :: Exp CDouble -> Exp CDouble

atan :: Exp CDouble -> Exp CDouble

sinh :: Exp CDouble -> Exp CDouble

cosh :: Exp CDouble -> Exp CDouble

tanh :: Exp CDouble -> Exp CDouble

asinh :: Exp CDouble -> Exp CDouble

acosh :: Exp CDouble -> Exp CDouble

atanh :: Exp CDouble -> Exp CDouble

log1p :: Exp CDouble -> Exp CDouble

expm1 :: Exp CDouble -> Exp CDouble

log1pexp :: Exp CDouble -> Exp CDouble

log1mexp :: Exp CDouble -> Exp CDouble

Fractional (Exp CDouble)

Defined in Data.Array.Accelerate.Classes.Fractional

Methods

(/) :: Exp CDouble -> Exp CDouble -> Exp CDouble

recip :: Exp CDouble -> Exp CDouble

fromRational :: Rational -> Exp CDouble

Num (Exp CDouble)

Defined in Data.Array.Accelerate.Classes.Num

Methods

(+) :: Exp CDouble -> Exp CDouble -> Exp CDouble

(-) :: Exp CDouble -> Exp CDouble -> Exp CDouble

(*) :: Exp CDouble -> Exp CDouble -> Exp CDouble

negate :: Exp CDouble -> Exp CDouble

abs :: Exp CDouble -> Exp CDouble

signum :: Exp CDouble -> Exp CDouble

fromInteger :: Integer -> Exp CDouble

type Difference CDouble

Defined in Basement.Numerical.Subtractive

type Difference CDouble = CDouble

type Unwrapped CDouble

Defined in Control.Lens.Wrapped

type Unwrapped CDouble = Double

type Plain CDouble

Defined in Data.Array.Accelerate.Lift

type Plain CDouble = CDouble

data CShort

Haskell type representing the C short type. (The concrete types of Foreign.C.Types are platform-specific.)

Instances

Bounded CShort

Defined in Foreign.C.Types

Methods

minBound :: CShort

maxBound :: CShort

Enum CShort

Defined in Foreign.C.Types

Methods

succ :: CShort -> CShort

pred :: CShort -> CShort

toEnum :: Int -> CShort

fromEnum :: CShort -> Int

enumFrom :: CShort -> [CShort]

enumFromThen :: CShort -> CShort -> [CShort]

enumFromTo :: CShort -> CShort -> [CShort]

enumFromThenTo :: CShort -> CShort -> CShort -> [CShort]

Eq CShort

Defined in Foreign.C.Types

Methods

(==) :: CShort -> CShort -> Bool

(/=) :: CShort -> CShort -> Bool

Integral CShort

Defined in Foreign.C.Types

Methods

quot :: CShort -> CShort -> CShort

rem :: CShort -> CShort -> CShort

div :: CShort -> CShort -> CShort

mod :: CShort -> CShort -> CShort

quotRem :: CShort -> CShort -> (CShort, CShort)

divMod :: CShort -> CShort -> (CShort, CShort)

toInteger :: CShort -> Integer

Num CShort

Defined in Foreign.C.Types

Methods

(+) :: CShort -> CShort -> CShort

(-) :: CShort -> CShort -> CShort

(*) :: CShort -> CShort -> CShort

negate :: CShort -> CShort

abs :: CShort -> CShort

signum :: CShort -> CShort

fromInteger :: Integer -> CShort

Ord CShort

Defined in Foreign.C.Types

Methods

compare :: CShort -> CShort -> Ordering

(<) :: CShort -> CShort -> Bool

(<=) :: CShort -> CShort -> Bool

(>) :: CShort -> CShort -> Bool

(>=) :: CShort -> CShort -> Bool

max :: CShort -> CShort -> CShort

min :: CShort -> CShort -> CShort

Read CShort

Defined in Foreign.C.Types

Methods

readsPrec :: Int -> ReadS CShort

readList :: ReadS [CShort]

readPrec :: ReadPrec CShort

readListPrec :: ReadPrec [CShort]

Real CShort

Defined in Foreign.C.Types

Methods

toRational :: CShort -> Rational

Show CShort

Defined in Foreign.C.Types

Methods

showsPrec :: Int -> CShort -> ShowS

show :: CShort -> String

showList :: [CShort] -> ShowS

Storable CShort

Defined in Foreign.C.Types

Methods

sizeOf :: CShort -> Int

alignment :: CShort -> Int

peekElemOff :: Ptr CShort -> Int -> IO CShort

pokeElemOff :: Ptr CShort -> Int -> CShort -> IO ()

peekByteOff :: Ptr b -> Int -> IO CShort

pokeByteOff :: Ptr b -> Int -> CShort -> IO ()

peek :: Ptr CShort -> IO CShort

poke :: Ptr CShort -> CShort -> IO ()

Bits CShort

Defined in Foreign.C.Types

Methods

(.&.) :: CShort -> CShort -> CShort

(.|.) :: CShort -> CShort -> CShort

xor :: CShort -> CShort -> CShort

complement :: CShort -> CShort

shift :: CShort -> Int -> CShort

rotate :: CShort -> Int -> CShort

zeroBits :: CShort

bit :: Int -> CShort

setBit :: CShort -> Int -> CShort

clearBit :: CShort -> Int -> CShort

complementBit :: CShort -> Int -> CShort

testBit :: CShort -> Int -> Bool

bitSizeMaybe :: CShort -> Maybe Int

bitSize :: CShort -> Int

isSigned :: CShort -> Bool

shiftL :: CShort -> Int -> CShort

unsafeShiftL :: CShort -> Int -> CShort

shiftR :: CShort -> Int -> CShort

unsafeShiftR :: CShort -> Int -> CShort

rotateL :: CShort -> Int -> CShort

rotateR :: CShort -> Int -> CShort

popCount :: CShort -> Int

FiniteBits CShort

Defined in Foreign.C.Types

Methods

finiteBitSize :: CShort -> Int

countLeadingZeros :: CShort -> Int

countTrailingZeros :: CShort -> Int

Subtractive CShort

Defined in Basement.Numerical.Subtractive

Associated Types

type Difference CShort

Methods

(-) :: CShort -> CShort -> Difference CShort

NFData CShort

Since: deepseq-1.4.0.0

Defined in Control.DeepSeq

Methods

rnf :: CShort -> ()

Prim CShort

Defined in Data.Primitive.Types

Methods

sizeOf# :: CShort -> Int#

alignment# :: CShort -> Int#

indexByteArray# :: ByteArray# -> Int# -> CShort

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, CShort #)

writeByteArray# :: MutableByteArray# s -> Int# -> CShort -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> CShort -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> CShort

readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, CShort #)

writeOffAddr# :: Addr# -> Int# -> CShort -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> CShort -> State# s -> State# s

Wrapped CShort

Defined in Control.Lens.Wrapped

Associated Types

type Unwrapped CShort

Methods

_Wrapped' :: Iso' CShort (Unwrapped CShort)

Elt CShort

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR CShort

Methods

eltR :: TypeR (EltR CShort)

tagsR :: [TagR (EltR CShort)]

fromElt :: CShort -> EltR CShort

toElt :: EltR CShort -> CShort

Eq CShort

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp CShort -> Exp CShort -> Exp Bool

(/=) :: Exp CShort -> Exp CShort -> Exp Bool

Ord CShort

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp CShort -> Exp CShort -> Exp Bool

(>) :: Exp CShort -> Exp CShort -> Exp Bool

(<=) :: Exp CShort -> Exp CShort -> Exp Bool

(>=) :: Exp CShort -> Exp CShort -> Exp Bool

min :: Exp CShort -> Exp CShort -> Exp CShort

max :: Exp CShort -> Exp CShort -> Exp CShort

compare :: Exp CShort -> Exp CShort -> Exp Ordering

FiniteBits CShort

Defined in Data.Array.Accelerate.Data.Bits

Methods

finiteBitSize :: Exp CShort -> Exp Int

countLeadingZeros :: Exp CShort -> Exp Int

countTrailingZeros :: Exp CShort -> Exp Int

Bits CShort

Defined in Data.Array.Accelerate.Data.Bits

Methods

(.&.) :: Exp CShort -> Exp CShort -> Exp CShort

(.|.) :: Exp CShort -> Exp CShort -> Exp CShort

xor :: Exp CShort -> Exp CShort -> Exp CShort

complement :: Exp CShort -> Exp CShort

shift :: Exp CShort -> Exp Int -> Exp CShort

rotate :: Exp CShort -> Exp Int -> Exp CShort

zeroBits :: Exp CShort

bit :: Exp Int -> Exp CShort

setBit :: Exp CShort -> Exp Int -> Exp CShort

clearBit :: Exp CShort -> Exp Int -> Exp CShort

complementBit :: Exp CShort -> Exp Int -> Exp CShort

testBit :: Exp CShort -> Exp Int -> Exp Bool

isSigned :: Exp CShort -> Exp Bool

shiftL :: Exp CShort -> Exp Int -> Exp CShort

unsafeShiftL :: Exp CShort -> Exp Int -> Exp CShort

shiftR :: Exp CShort -> Exp Int -> Exp CShort

unsafeShiftR :: Exp CShort -> Exp Int -> Exp CShort

rotateL :: Exp CShort -> Exp Int -> Exp CShort

rotateR :: Exp CShort -> Exp Int -> Exp CShort

popCount :: Exp CShort -> Exp Int

Rewrapped CShort t

Defined in Control.Lens.Wrapped

Lift Exp CShort

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain CShort

Methods

lift :: CShort -> Exp (Plain CShort)

Bounded (Exp CShort)

Defined in Data.Array.Accelerate.Classes.Bounded

Methods

minBound :: Exp CShort

maxBound :: Exp CShort

Enum (Exp CShort)

Defined in Data.Array.Accelerate.Classes.Enum

Methods

succ :: Exp CShort -> Exp CShort

pred :: Exp CShort -> Exp CShort

toEnum :: Int -> Exp CShort

fromEnum :: Exp CShort -> Int

enumFrom :: Exp CShort -> [Exp CShort]

enumFromThen :: Exp CShort -> Exp CShort -> [Exp CShort]

enumFromTo :: Exp CShort -> Exp CShort -> [Exp CShort]

enumFromThenTo :: Exp CShort -> Exp CShort -> Exp CShort -> [Exp CShort]

Integral (Exp CShort)

Defined in Data.Array.Accelerate.Classes.Integral

Methods

quot :: Exp CShort -> Exp CShort -> Exp CShort

rem :: Exp CShort -> Exp CShort -> Exp CShort

div :: Exp CShort -> Exp CShort -> Exp CShort

mod :: Exp CShort -> Exp CShort -> Exp CShort

quotRem :: Exp CShort -> Exp CShort -> (Exp CShort, Exp CShort)

divMod :: Exp CShort -> Exp CShort -> (Exp CShort, Exp CShort)

toInteger :: Exp CShort -> Integer

Num (Exp CShort)

Defined in Data.Array.Accelerate.Classes.Num

Methods

(+) :: Exp CShort -> Exp CShort -> Exp CShort

(-) :: Exp CShort -> Exp CShort -> Exp CShort

(*) :: Exp CShort -> Exp CShort -> Exp CShort

negate :: Exp CShort -> Exp CShort

abs :: Exp CShort -> Exp CShort

signum :: Exp CShort -> Exp CShort

fromInteger :: Integer -> Exp CShort

type Difference CShort

Defined in Basement.Numerical.Subtractive

type Difference CShort = CShort

type Unwrapped CShort

Defined in Control.Lens.Wrapped

type Unwrapped CShort = Int16

type Plain CShort

Defined in Data.Array.Accelerate.Lift

type Plain CShort = CShort

data CUShort

Haskell type representing the C unsigned short type. (The concrete types of Foreign.C.Types are platform-specific.)

Instances

Bounded CUShort

Defined in Foreign.C.Types

Methods

minBound :: CUShort

maxBound :: CUShort

Enum CUShort

Defined in Foreign.C.Types

Methods

succ :: CUShort -> CUShort

pred :: CUShort -> CUShort

toEnum :: Int -> CUShort

fromEnum :: CUShort -> Int

enumFrom :: CUShort -> [CUShort]

enumFromThen :: CUShort -> CUShort -> [CUShort]

enumFromTo :: CUShort -> CUShort -> [CUShort]

enumFromThenTo :: CUShort -> CUShort -> CUShort -> [CUShort]

Eq CUShort

Defined in Foreign.C.Types

Methods

(==) :: CUShort -> CUShort -> Bool

(/=) :: CUShort -> CUShort -> Bool

Integral CUShort

Defined in Foreign.C.Types

Methods

quot :: CUShort -> CUShort -> CUShort

rem :: CUShort -> CUShort -> CUShort

div :: CUShort -> CUShort -> CUShort

mod :: CUShort -> CUShort -> CUShort

quotRem :: CUShort -> CUShort -> (CUShort, CUShort)

divMod :: CUShort -> CUShort -> (CUShort, CUShort)

toInteger :: CUShort -> Integer

Num CUShort

Defined in Foreign.C.Types

Methods

(+) :: CUShort -> CUShort -> CUShort

(-) :: CUShort -> CUShort -> CUShort

(*) :: CUShort -> CUShort -> CUShort

negate :: CUShort -> CUShort

abs :: CUShort -> CUShort

signum :: CUShort -> CUShort

fromInteger :: Integer -> CUShort

Ord CUShort

Defined in Foreign.C.Types

Methods

compare :: CUShort -> CUShort -> Ordering

(<) :: CUShort -> CUShort -> Bool

(<=) :: CUShort -> CUShort -> Bool

(>) :: CUShort -> CUShort -> Bool

(>=) :: CUShort -> CUShort -> Bool

max :: CUShort -> CUShort -> CUShort

min :: CUShort -> CUShort -> CUShort

Read CUShort

Defined in Foreign.C.Types

Methods

readsPrec :: Int -> ReadS CUShort

readList :: ReadS [CUShort]

readPrec :: ReadPrec CUShort

readListPrec :: ReadPrec [CUShort]

Real CUShort

Defined in Foreign.C.Types

Methods

toRational :: CUShort -> Rational

Show CUShort

Defined in Foreign.C.Types

Methods

showsPrec :: Int -> CUShort -> ShowS

show :: CUShort -> String

showList :: [CUShort] -> ShowS

Storable CUShort

Defined in Foreign.C.Types

Methods

sizeOf :: CUShort -> Int

alignment :: CUShort -> Int

peekElemOff :: Ptr CUShort -> Int -> IO CUShort

pokeElemOff :: Ptr CUShort -> Int -> CUShort -> IO ()

peekByteOff :: Ptr b -> Int -> IO CUShort

pokeByteOff :: Ptr b -> Int -> CUShort -> IO ()

peek :: Ptr CUShort -> IO CUShort

poke :: Ptr CUShort -> CUShort -> IO ()

Bits CUShort

Defined in Foreign.C.Types

Methods

(.&.) :: CUShort -> CUShort -> CUShort

(.|.) :: CUShort -> CUShort -> CUShort

xor :: CUShort -> CUShort -> CUShort

complement :: CUShort -> CUShort

shift :: CUShort -> Int -> CUShort

rotate :: CUShort -> Int -> CUShort

zeroBits :: CUShort

bit :: Int -> CUShort

setBit :: CUShort -> Int -> CUShort

clearBit :: CUShort -> Int -> CUShort

complementBit :: CUShort -> Int -> CUShort

testBit :: CUShort -> Int -> Bool

bitSizeMaybe :: CUShort -> Maybe Int

bitSize :: CUShort -> Int

isSigned :: CUShort -> Bool

shiftL :: CUShort -> Int -> CUShort

unsafeShiftL :: CUShort -> Int -> CUShort

shiftR :: CUShort -> Int -> CUShort

unsafeShiftR :: CUShort -> Int -> CUShort

rotateL :: CUShort -> Int -> CUShort

rotateR :: CUShort -> Int -> CUShort

popCount :: CUShort -> Int

FiniteBits CUShort

Defined in Foreign.C.Types

Methods

finiteBitSize :: CUShort -> Int

countLeadingZeros :: CUShort -> Int

countTrailingZeros :: CUShort -> Int

Subtractive CUShort

Defined in Basement.Numerical.Subtractive

Associated Types

type Difference CUShort

Methods

(-) :: CUShort -> CUShort -> Difference CUShort

NFData CUShort

Since: deepseq-1.4.0.0

Defined in Control.DeepSeq

Methods

rnf :: CUShort -> ()

Prim CUShort

Defined in Data.Primitive.Types

Methods

sizeOf# :: CUShort -> Int#

alignment# :: CUShort -> Int#

indexByteArray# :: ByteArray# -> Int# -> CUShort

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, CUShort #)

writeByteArray# :: MutableByteArray# s -> Int# -> CUShort -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> CUShort -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> CUShort

readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, CUShort #)

writeOffAddr# :: Addr# -> Int# -> CUShort -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> CUShort -> State# s -> State# s

Wrapped CUShort

Defined in Control.Lens.Wrapped

Associated Types

type Unwrapped CUShort

Methods

_Wrapped' :: Iso' CUShort (Unwrapped CUShort)

Elt CUShort

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR CUShort

Methods

eltR :: TypeR (EltR CUShort)

tagsR :: [TagR (EltR CUShort)]

fromElt :: CUShort -> EltR CUShort

toElt :: EltR CUShort -> CUShort

Eq CUShort

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp CUShort -> Exp CUShort -> Exp Bool

(/=) :: Exp CUShort -> Exp CUShort -> Exp Bool

Ord CUShort

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp CUShort -> Exp CUShort -> Exp Bool

(>) :: Exp CUShort -> Exp CUShort -> Exp Bool

(<=) :: Exp CUShort -> Exp CUShort -> Exp Bool

(>=) :: Exp CUShort -> Exp CUShort -> Exp Bool

min :: Exp CUShort -> Exp CUShort -> Exp CUShort

max :: Exp CUShort -> Exp CUShort -> Exp CUShort

compare :: Exp CUShort -> Exp CUShort -> Exp Ordering

FiniteBits CUShort

Defined in Data.Array.Accelerate.Data.Bits

Methods

finiteBitSize :: Exp CUShort -> Exp Int

countLeadingZeros :: Exp CUShort -> Exp Int

countTrailingZeros :: Exp CUShort -> Exp Int

Bits CUShort

Defined in Data.Array.Accelerate.Data.Bits

Methods

(.&.) :: Exp CUShort -> Exp CUShort -> Exp CUShort

(.|.) :: Exp CUShort -> Exp CUShort -> Exp CUShort

xor :: Exp CUShort -> Exp CUShort -> Exp CUShort

complement :: Exp CUShort -> Exp CUShort

shift :: Exp CUShort -> Exp Int -> Exp CUShort

rotate :: Exp CUShort -> Exp Int -> Exp CUShort

zeroBits :: Exp CUShort

bit :: Exp Int -> Exp CUShort

setBit :: Exp CUShort -> Exp Int -> Exp CUShort

clearBit :: Exp CUShort -> Exp Int -> Exp CUShort

complementBit :: Exp CUShort -> Exp Int -> Exp CUShort

testBit :: Exp CUShort -> Exp Int -> Exp Bool

isSigned :: Exp CUShort -> Exp Bool

shiftL :: Exp CUShort -> Exp Int -> Exp CUShort

unsafeShiftL :: Exp CUShort -> Exp Int -> Exp CUShort

shiftR :: Exp CUShort -> Exp Int -> Exp CUShort

unsafeShiftR :: Exp CUShort -> Exp Int -> Exp CUShort

rotateL :: Exp CUShort -> Exp Int -> Exp CUShort

rotateR :: Exp CUShort -> Exp Int -> Exp CUShort

popCount :: Exp CUShort -> Exp Int

Rewrapped CUShort t

Defined in Control.Lens.Wrapped

Lift Exp CUShort

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain CUShort

Methods

lift :: CUShort -> Exp (Plain CUShort)

Bounded (Exp CUShort)

Defined in Data.Array.Accelerate.Classes.Bounded

Methods

minBound :: Exp CUShort

maxBound :: Exp CUShort

Enum (Exp CUShort)

Defined in Data.Array.Accelerate.Classes.Enum

Methods

succ :: Exp CUShort -> Exp CUShort

pred :: Exp CUShort -> Exp CUShort

toEnum :: Int -> Exp CUShort

fromEnum :: Exp CUShort -> Int

enumFrom :: Exp CUShort -> [Exp CUShort]

enumFromThen :: Exp CUShort -> Exp CUShort -> [Exp CUShort]

enumFromTo :: Exp CUShort -> Exp CUShort -> [Exp CUShort]

enumFromThenTo :: Exp CUShort -> Exp CUShort -> Exp CUShort -> [Exp CUShort]

Integral (Exp CUShort)

Defined in Data.Array.Accelerate.Classes.Integral

Methods

quot :: Exp CUShort -> Exp CUShort -> Exp CUShort

rem :: Exp CUShort -> Exp CUShort -> Exp CUShort

div :: Exp CUShort -> Exp CUShort -> Exp CUShort

mod :: Exp CUShort -> Exp CUShort -> Exp CUShort

quotRem :: Exp CUShort -> Exp CUShort -> (Exp CUShort, Exp CUShort)

divMod :: Exp CUShort -> Exp CUShort -> (Exp CUShort, Exp CUShort)

toInteger :: Exp CUShort -> Integer

Num (Exp CUShort)

Defined in Data.Array.Accelerate.Classes.Num

Methods

(+) :: Exp CUShort -> Exp CUShort -> Exp CUShort

(-) :: Exp CUShort -> Exp CUShort -> Exp CUShort

(*) :: Exp CUShort -> Exp CUShort -> Exp CUShort

negate :: Exp CUShort -> Exp CUShort

abs :: Exp CUShort -> Exp CUShort

signum :: Exp CUShort -> Exp CUShort

fromInteger :: Integer -> Exp CUShort

type Difference CUShort

Defined in Basement.Numerical.Subtractive

type Difference CUShort = CUShort

type Unwrapped CUShort

Defined in Control.Lens.Wrapped

type Unwrapped CUShort = Word16

type Plain CUShort

Defined in Data.Array.Accelerate.Lift

type Plain CUShort = CUShort

data CInt

Haskell type representing the C int type. (The concrete types of Foreign.C.Types are platform-specific.)

Instances

Bounded CInt

Defined in Foreign.C.Types

Methods

minBound :: CInt

maxBound :: CInt

Enum CInt

Defined in Foreign.C.Types

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

Defined in Foreign.C.Types

Methods

(==) :: CInt -> CInt -> Bool

(/=) :: CInt -> CInt -> Bool

Integral CInt

Defined in Foreign.C.Types

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

Defined in Foreign.C.Types

Methods

(+) :: CInt -> CInt -> CInt

(-) :: CInt -> CInt -> CInt

(*) :: CInt -> CInt -> CInt

negate :: CInt -> CInt

abs :: CInt -> CInt

signum :: CInt -> CInt

fromInteger :: Integer -> CInt

Ord CInt

Defined in Foreign.C.Types

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

Defined in Foreign.C.Types

Methods

readsPrec :: Int -> ReadS CInt

readList :: ReadS [CInt]

readPrec :: ReadPrec CInt

readListPrec :: ReadPrec [CInt]

Real CInt

Defined in Foreign.C.Types

Methods

toRational :: CInt -> Rational

Show CInt

Defined in Foreign.C.Types

Methods

showsPrec :: Int -> CInt -> ShowS

show :: CInt -> String

showList :: [CInt] -> ShowS

Storable CInt

Defined in Foreign.C.Types

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

Defined in Foreign.C.Types

Methods

(.&.) :: CInt -> CInt -> CInt

(.|.) :: CInt -> CInt -> CInt

xor :: CInt -> CInt -> CInt

complement :: CInt -> CInt

shift :: CInt -> Int -> CInt

rotate :: CInt -> Int -> CInt

zeroBits :: CInt

bit :: Int -> CInt

setBit :: CInt -> Int -> CInt

clearBit :: CInt -> Int -> CInt

complementBit :: CInt -> Int -> CInt

testBit :: CInt -> Int -> Bool

bitSizeMaybe :: CInt -> Maybe Int

bitSize :: CInt -> Int

isSigned :: CInt -> Bool

shiftL :: CInt -> Int -> CInt

unsafeShiftL :: CInt -> Int -> CInt

shiftR :: CInt -> Int -> CInt

unsafeShiftR :: CInt -> Int -> CInt

rotateL :: CInt -> Int -> CInt

rotateR :: CInt -> Int -> CInt

popCount :: CInt -> Int

FiniteBits CInt

Defined in Foreign.C.Types

Methods

finiteBitSize :: CInt -> Int

countLeadingZeros :: CInt -> Int

countTrailingZeros :: CInt -> Int

Subtractive CInt

Defined in Basement.Numerical.Subtractive

Associated Types

type Difference CInt

Methods

(-) :: CInt -> CInt -> Difference CInt

NFData CInt

Since: deepseq-1.4.0.0

Defined in Control.DeepSeq

Methods

rnf :: CInt -> ()

Prim CInt

Defined in Data.Primitive.Types

Methods

sizeOf# :: CInt -> Int#

alignment# :: CInt -> Int#

indexByteArray# :: ByteArray# -> Int# -> CInt

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, CInt #)

writeByteArray# :: MutableByteArray# s -> Int# -> CInt -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> CInt -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> CInt

readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, CInt #)

writeOffAddr# :: Addr# -> Int# -> CInt -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> CInt -> State# s -> State# s

Wrapped CInt

Defined in Control.Lens.Wrapped

Associated Types

type Unwrapped CInt

Methods

_Wrapped' :: Iso' CInt (Unwrapped CInt)

Elt CInt

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR CInt

Methods

eltR :: TypeR (EltR CInt)

tagsR :: [TagR (EltR CInt)]

fromElt :: CInt -> EltR CInt

toElt :: EltR CInt -> CInt

Eq CInt

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp CInt -> Exp CInt -> Exp Bool

(/=) :: Exp CInt -> Exp CInt -> Exp Bool

Ord CInt

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp CInt -> Exp CInt -> Exp Bool

(>) :: Exp CInt -> Exp CInt -> Exp Bool

(<=) :: Exp CInt -> Exp CInt -> Exp Bool

(>=) :: Exp CInt -> Exp CInt -> Exp Bool

min :: Exp CInt -> Exp CInt -> Exp CInt

max :: Exp CInt -> Exp CInt -> Exp CInt

compare :: Exp CInt -> Exp CInt -> Exp Ordering

FiniteBits CInt

Defined in Data.Array.Accelerate.Data.Bits

Methods

finiteBitSize :: Exp CInt -> Exp Int

countLeadingZeros :: Exp CInt -> Exp Int

countTrailingZeros :: Exp CInt -> Exp Int

Bits CInt

Defined in Data.Array.Accelerate.Data.Bits

Methods

(.&.) :: Exp CInt -> Exp CInt -> Exp CInt

(.|.) :: Exp CInt -> Exp CInt -> Exp CInt

xor :: Exp CInt -> Exp CInt -> Exp CInt

complement :: Exp CInt -> Exp CInt

shift :: Exp CInt -> Exp Int -> Exp CInt

rotate :: Exp CInt -> Exp Int -> Exp CInt

zeroBits :: Exp CInt

bit :: Exp Int -> Exp CInt

setBit :: Exp CInt -> Exp Int -> Exp CInt

clearBit :: Exp CInt -> Exp Int -> Exp CInt

complementBit :: Exp CInt -> Exp Int -> Exp CInt

testBit :: Exp CInt -> Exp Int -> Exp Bool

isSigned :: Exp CInt -> Exp Bool

shiftL :: Exp CInt -> Exp Int -> Exp CInt

unsafeShiftL :: Exp CInt -> Exp Int -> Exp CInt

shiftR :: Exp CInt -> Exp Int -> Exp CInt

unsafeShiftR :: Exp CInt -> Exp Int -> Exp CInt

rotateL :: Exp CInt -> Exp Int -> Exp CInt

rotateR :: Exp CInt -> Exp Int -> Exp CInt

popCount :: Exp CInt -> Exp Int

Rewrapped CInt t

Defined in Control.Lens.Wrapped

Lift Exp CInt

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain CInt

Methods

lift :: CInt -> Exp (Plain CInt)

Bounded (Exp CInt)

Defined in Data.Array.Accelerate.Classes.Bounded

Methods

minBound :: Exp CInt

maxBound :: Exp CInt

Enum (Exp CInt)

Defined in Data.Array.Accelerate.Classes.Enum

Methods

succ :: Exp CInt -> Exp CInt

pred :: Exp CInt -> Exp CInt

toEnum :: Int -> Exp CInt

fromEnum :: Exp CInt -> Int

enumFrom :: Exp CInt -> [Exp CInt]

enumFromThen :: Exp CInt -> Exp CInt -> [Exp CInt]

enumFromTo :: Exp CInt -> Exp CInt -> [Exp CInt]

enumFromThenTo :: Exp CInt -> Exp CInt -> Exp CInt -> [Exp CInt]

Integral (Exp CInt)

Defined in Data.Array.Accelerate.Classes.Integral

Methods

quot :: Exp CInt -> Exp CInt -> Exp CInt

rem :: Exp CInt -> Exp CInt -> Exp CInt

div :: Exp CInt -> Exp CInt -> Exp CInt

mod :: Exp CInt -> Exp CInt -> Exp CInt

quotRem :: Exp CInt -> Exp CInt -> (Exp CInt, Exp CInt)

divMod :: Exp CInt -> Exp CInt -> (Exp CInt, Exp CInt)

toInteger :: Exp CInt -> Integer

Num (Exp CInt)

Defined in Data.Array.Accelerate.Classes.Num

Methods

(+) :: Exp CInt -> Exp CInt -> Exp CInt

(-) :: Exp CInt -> Exp CInt -> Exp CInt

(*) :: Exp CInt -> Exp CInt -> Exp CInt

negate :: Exp CInt -> Exp CInt

abs :: Exp CInt -> Exp CInt

signum :: Exp CInt -> Exp CInt

fromInteger :: Integer -> Exp CInt

type Difference CInt

Defined in Basement.Numerical.Subtractive

type Difference CInt = CInt

type Unwrapped CInt

Defined in Control.Lens.Wrapped

type Unwrapped CInt = Int32

type Plain CInt

Defined in Data.Array.Accelerate.Lift

type Plain CInt = CInt

data CUInt

Haskell type representing the C unsigned int type. (The concrete types of Foreign.C.Types are platform-specific.)

Instances

Bounded CUInt

Defined in Foreign.C.Types

Methods

minBound :: CUInt

maxBound :: CUInt

Enum CUInt

Defined in Foreign.C.Types

Methods

succ :: CUInt -> CUInt

pred :: CUInt -> CUInt

toEnum :: Int -> CUInt

fromEnum :: CUInt -> Int

enumFrom :: CUInt -> [CUInt]

enumFromThen :: CUInt -> CUInt -> [CUInt]

enumFromTo :: CUInt -> CUInt -> [CUInt]

enumFromThenTo :: CUInt -> CUInt -> CUInt -> [CUInt]

Eq CUInt

Defined in Foreign.C.Types

Methods

(==) :: CUInt -> CUInt -> Bool

(/=) :: CUInt -> CUInt -> Bool

Integral CUInt

Defined in Foreign.C.Types

Methods

quot :: CUInt -> CUInt -> CUInt

rem :: CUInt -> CUInt -> CUInt

div :: CUInt -> CUInt -> CUInt

mod :: CUInt -> CUInt -> CUInt

quotRem :: CUInt -> CUInt -> (CUInt, CUInt)

divMod :: CUInt -> CUInt -> (CUInt, CUInt)

toInteger :: CUInt -> Integer

Num CUInt

Defined in Foreign.C.Types

Methods

(+) :: CUInt -> CUInt -> CUInt

(-) :: CUInt -> CUInt -> CUInt

(*) :: CUInt -> CUInt -> CUInt

negate :: CUInt -> CUInt

abs :: CUInt -> CUInt

signum :: CUInt -> CUInt

fromInteger :: Integer -> CUInt

Ord CUInt

Defined in Foreign.C.Types

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

Defined in Foreign.C.Types

Methods

readsPrec :: Int -> ReadS CUInt

readList :: ReadS [CUInt]

readPrec :: ReadPrec CUInt

readListPrec :: ReadPrec [CUInt]

Real CUInt

Defined in Foreign.C.Types

Methods

toRational :: CUInt -> Rational

Show CUInt

Defined in Foreign.C.Types

Methods

showsPrec :: Int -> CUInt -> ShowS

show :: CUInt -> String

showList :: [CUInt] -> ShowS

Storable CUInt

Defined in Foreign.C.Types

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

Defined in Foreign.C.Types

Methods

(.&.) :: CUInt -> CUInt -> CUInt

(.|.) :: CUInt -> CUInt -> CUInt

xor :: CUInt -> CUInt -> CUInt

complement :: CUInt -> CUInt

shift :: CUInt -> Int -> CUInt

rotate :: CUInt -> Int -> CUInt

zeroBits :: CUInt

bit :: Int -> CUInt

setBit :: CUInt -> Int -> CUInt

clearBit :: CUInt -> Int -> CUInt

complementBit :: CUInt -> Int -> CUInt

testBit :: CUInt -> Int -> Bool

bitSizeMaybe :: CUInt -> Maybe Int

bitSize :: CUInt -> Int

isSigned :: CUInt -> Bool

shiftL :: CUInt -> Int -> CUInt

unsafeShiftL :: CUInt -> Int -> CUInt

shiftR :: CUInt -> Int -> CUInt

unsafeShiftR :: CUInt -> Int -> CUInt

rotateL :: CUInt -> Int -> CUInt

rotateR :: CUInt -> Int -> CUInt

popCount :: CUInt -> Int

FiniteBits CUInt

Defined in Foreign.C.Types

Methods

finiteBitSize :: CUInt -> Int

countLeadingZeros :: CUInt -> Int

countTrailingZeros :: CUInt -> Int

Subtractive CUInt

Defined in Basement.Numerical.Subtractive

Associated Types

type Difference CUInt

Methods

(-) :: CUInt -> CUInt -> Difference CUInt

NFData CUInt

Since: deepseq-1.4.0.0

Defined in Control.DeepSeq

Methods

rnf :: CUInt -> ()

Prim CUInt

Defined in Data.Primitive.Types

Methods

sizeOf# :: CUInt -> Int#

alignment# :: CUInt -> Int#

indexByteArray# :: ByteArray# -> Int# -> CUInt

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, CUInt #)

writeByteArray# :: MutableByteArray# s -> Int# -> CUInt -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> CUInt -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> CUInt

readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, CUInt #)

writeOffAddr# :: Addr# -> Int# -> CUInt -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> CUInt -> State# s -> State# s

Wrapped CUInt

Defined in Control.Lens.Wrapped

Associated Types

type Unwrapped CUInt

Methods

_Wrapped' :: Iso' CUInt (Unwrapped CUInt)

Elt CUInt

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR CUInt

Methods

eltR :: TypeR (EltR CUInt)

tagsR :: [TagR (EltR CUInt)]

fromElt :: CUInt -> EltR CUInt

toElt :: EltR CUInt -> CUInt

Eq CUInt

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp CUInt -> Exp CUInt -> Exp Bool

(/=) :: Exp CUInt -> Exp CUInt -> Exp Bool

Ord CUInt

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp CUInt -> Exp CUInt -> Exp Bool

(>) :: Exp CUInt -> Exp CUInt -> Exp Bool

(<=) :: Exp CUInt -> Exp CUInt -> Exp Bool

(>=) :: Exp CUInt -> Exp CUInt -> Exp Bool

min :: Exp CUInt -> Exp CUInt -> Exp CUInt

max :: Exp CUInt -> Exp CUInt -> Exp CUInt

compare :: Exp CUInt -> Exp CUInt -> Exp Ordering

FiniteBits CUInt

Defined in Data.Array.Accelerate.Data.Bits

Methods

finiteBitSize :: Exp CUInt -> Exp Int

countLeadingZeros :: Exp CUInt -> Exp Int

countTrailingZeros :: Exp CUInt -> Exp Int

Bits CUInt

Defined in Data.Array.Accelerate.Data.Bits

Methods

(.&.) :: Exp CUInt -> Exp CUInt -> Exp CUInt

(.|.) :: Exp CUInt -> Exp CUInt -> Exp CUInt

xor :: Exp CUInt -> Exp CUInt -> Exp CUInt

complement :: Exp CUInt -> Exp CUInt

shift :: Exp CUInt -> Exp Int -> Exp CUInt

rotate :: Exp CUInt -> Exp Int -> Exp CUInt

zeroBits :: Exp CUInt

bit :: Exp Int -> Exp CUInt

setBit :: Exp CUInt -> Exp Int -> Exp CUInt

clearBit :: Exp CUInt -> Exp Int -> Exp CUInt

complementBit :: Exp CUInt -> Exp Int -> Exp CUInt

testBit :: Exp CUInt -> Exp Int -> Exp Bool

isSigned :: Exp CUInt -> Exp Bool

shiftL :: Exp CUInt -> Exp Int -> Exp CUInt

unsafeShiftL :: Exp CUInt -> Exp Int -> Exp CUInt

shiftR :: Exp CUInt -> Exp Int -> Exp CUInt

unsafeShiftR :: Exp CUInt -> Exp Int -> Exp CUInt

rotateL :: Exp CUInt -> Exp Int -> Exp CUInt

rotateR :: Exp CUInt -> Exp Int -> Exp CUInt

popCount :: Exp CUInt -> Exp Int

Rewrapped CUInt t

Defined in Control.Lens.Wrapped

Lift Exp CUInt

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain CUInt

Methods

lift :: CUInt -> Exp (Plain CUInt)

Bounded (Exp CUInt)

Defined in Data.Array.Accelerate.Classes.Bounded

Methods

minBound :: Exp CUInt

maxBound :: Exp CUInt

Enum (Exp CUInt)

Defined in Data.Array.Accelerate.Classes.Enum

Methods

succ :: Exp CUInt -> Exp CUInt

pred :: Exp CUInt -> Exp CUInt

toEnum :: Int -> Exp CUInt

fromEnum :: Exp CUInt -> Int

enumFrom :: Exp CUInt -> [Exp CUInt]

enumFromThen :: Exp CUInt -> Exp CUInt -> [Exp CUInt]

enumFromTo :: Exp CUInt -> Exp CUInt -> [Exp CUInt]

enumFromThenTo :: Exp CUInt -> Exp CUInt -> Exp CUInt -> [Exp CUInt]

Integral (Exp CUInt)

Defined in Data.Array.Accelerate.Classes.Integral

Methods

quot :: Exp CUInt -> Exp CUInt -> Exp CUInt

rem :: Exp CUInt -> Exp CUInt -> Exp CUInt

div :: Exp CUInt -> Exp CUInt -> Exp CUInt

mod :: Exp CUInt -> Exp CUInt -> Exp CUInt

quotRem :: Exp CUInt -> Exp CUInt -> (Exp CUInt, Exp CUInt)

divMod :: Exp CUInt -> Exp CUInt -> (Exp CUInt, Exp CUInt)

toInteger :: Exp CUInt -> Integer

Num (Exp CUInt)

Defined in Data.Array.Accelerate.Classes.Num

Methods

(+) :: Exp CUInt -> Exp CUInt -> Exp CUInt

(-) :: Exp CUInt -> Exp CUInt -> Exp CUInt

(*) :: Exp CUInt -> Exp CUInt -> Exp CUInt

negate :: Exp CUInt -> Exp CUInt

abs :: Exp CUInt -> Exp CUInt

signum :: Exp CUInt -> Exp CUInt

fromInteger :: Integer -> Exp CUInt

type Difference CUInt

Defined in Basement.Numerical.Subtractive

type Difference CUInt = CUInt

type Unwrapped CUInt

Defined in Control.Lens.Wrapped

type Unwrapped CUInt = Word32

type Plain CUInt

Defined in Data.Array.Accelerate.Lift

type Plain CUInt = CUInt

data CLong

Haskell type representing the C long type. (The concrete types of Foreign.C.Types are platform-specific.)

Instances

Bounded CLong

Defined in Foreign.C.Types

Methods

minBound :: CLong

maxBound :: CLong

Enum CLong

Defined in Foreign.C.Types

Methods

succ :: CLong -> CLong

pred :: CLong -> CLong

toEnum :: Int -> CLong

fromEnum :: CLong -> Int

enumFrom :: CLong -> [CLong]

enumFromThen :: CLong -> CLong -> [CLong]

enumFromTo :: CLong -> CLong -> [CLong]

enumFromThenTo :: CLong -> CLong -> CLong -> [CLong]

Eq CLong

Defined in Foreign.C.Types

Methods

(==) :: CLong -> CLong -> Bool

(/=) :: CLong -> CLong -> Bool

Integral CLong

Defined in Foreign.C.Types

Methods

quot :: CLong -> CLong -> CLong

rem :: CLong -> CLong -> CLong

div :: CLong -> CLong -> CLong

mod :: CLong -> CLong -> CLong

quotRem :: CLong -> CLong -> (CLong, CLong)

divMod :: CLong -> CLong -> (CLong, CLong)

toInteger :: CLong -> Integer

Num CLong

Defined in Foreign.C.Types

Methods

(+) :: CLong -> CLong -> CLong

(-) :: CLong -> CLong -> CLong

(*) :: CLong -> CLong -> CLong

negate :: CLong -> CLong

abs :: CLong -> CLong

signum :: CLong -> CLong

fromInteger :: Integer -> CLong

Ord CLong

Defined in Foreign.C.Types

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

Defined in Foreign.C.Types

Methods

readsPrec :: Int -> ReadS CLong

readList :: ReadS [CLong]

readPrec :: ReadPrec CLong

readListPrec :: ReadPrec [CLong]

Real CLong

Defined in Foreign.C.Types

Methods

toRational :: CLong -> Rational

Show CLong

Defined in Foreign.C.Types

Methods

showsPrec :: Int -> CLong -> ShowS

show :: CLong -> String

showList :: [CLong] -> ShowS

Storable CLong

Defined in Foreign.C.Types

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

Defined in Foreign.C.Types

Methods

(.&.) :: CLong -> CLong -> CLong

(.|.) :: CLong -> CLong -> CLong

xor :: CLong -> CLong -> CLong

complement :: CLong -> CLong

shift :: CLong -> Int -> CLong

rotate :: CLong -> Int -> CLong

zeroBits :: CLong

bit :: Int -> CLong

setBit :: CLong -> Int -> CLong

clearBit :: CLong -> Int -> CLong

complementBit :: CLong -> Int -> CLong

testBit :: CLong -> Int -> Bool

bitSizeMaybe :: CLong -> Maybe Int

bitSize :: CLong -> Int

isSigned :: CLong -> Bool

shiftL :: CLong -> Int -> CLong

unsafeShiftL :: CLong -> Int -> CLong

shiftR :: CLong -> Int -> CLong

unsafeShiftR :: CLong -> Int -> CLong

rotateL :: CLong -> Int -> CLong

rotateR :: CLong -> Int -> CLong

popCount :: CLong -> Int

FiniteBits CLong

Defined in Foreign.C.Types

Methods

finiteBitSize :: CLong -> Int

countLeadingZeros :: CLong -> Int

countTrailingZeros :: CLong -> Int

Subtractive CLong

Defined in Basement.Numerical.Subtractive

Associated Types

type Difference CLong

Methods

(-) :: CLong -> CLong -> Difference CLong

NFData CLong

Since: deepseq-1.4.0.0

Defined in Control.DeepSeq

Methods

rnf :: CLong -> ()

Prim CLong

Defined in Data.Primitive.Types

Methods

sizeOf# :: CLong -> Int#

alignment# :: CLong -> Int#

indexByteArray# :: ByteArray# -> Int# -> CLong

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, CLong #)

writeByteArray# :: MutableByteArray# s -> Int# -> CLong -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> CLong -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> CLong

readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, CLong #)

writeOffAddr# :: Addr# -> Int# -> CLong -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> CLong -> State# s -> State# s

Wrapped CLong

Defined in Control.Lens.Wrapped

Associated Types

type Unwrapped CLong

Methods

_Wrapped' :: Iso' CLong (Unwrapped CLong)

Elt CLong

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR CLong

Methods

eltR :: TypeR (EltR CLong)

tagsR :: [TagR (EltR CLong)]

fromElt :: CLong -> EltR CLong

toElt :: EltR CLong -> CLong

Eq CLong

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp CLong -> Exp CLong -> Exp Bool

(/=) :: Exp CLong -> Exp CLong -> Exp Bool

Ord CLong

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp CLong -> Exp CLong -> Exp Bool

(>) :: Exp CLong -> Exp CLong -> Exp Bool

(<=) :: Exp CLong -> Exp CLong -> Exp Bool

(>=) :: Exp CLong -> Exp CLong -> Exp Bool

min :: Exp CLong -> Exp CLong -> Exp CLong

max :: Exp CLong -> Exp CLong -> Exp CLong

compare :: Exp CLong -> Exp CLong -> Exp Ordering

FiniteBits CLong

Defined in Data.Array.Accelerate.Data.Bits

Methods

finiteBitSize :: Exp CLong -> Exp Int

countLeadingZeros :: Exp CLong -> Exp Int

countTrailingZeros :: Exp CLong -> Exp Int

Bits CLong

Defined in Data.Array.Accelerate.Data.Bits

Methods

(.&.) :: Exp CLong -> Exp CLong -> Exp CLong

(.|.) :: Exp CLong -> Exp CLong -> Exp CLong

xor :: Exp CLong -> Exp CLong -> Exp CLong

complement :: Exp CLong -> Exp CLong

shift :: Exp CLong -> Exp Int -> Exp CLong

rotate :: Exp CLong -> Exp Int -> Exp CLong

zeroBits :: Exp CLong

bit :: Exp Int -> Exp CLong

setBit :: Exp CLong -> Exp Int -> Exp CLong

clearBit :: Exp CLong -> Exp Int -> Exp CLong

complementBit :: Exp CLong -> Exp Int -> Exp CLong

testBit :: Exp CLong -> Exp Int -> Exp Bool

isSigned :: Exp CLong -> Exp Bool

shiftL :: Exp CLong -> Exp Int -> Exp CLong

unsafeShiftL :: Exp CLong -> Exp Int -> Exp CLong

shiftR :: Exp CLong -> Exp Int -> Exp CLong

unsafeShiftR :: Exp CLong -> Exp Int -> Exp CLong

rotateL :: Exp CLong -> Exp Int -> Exp CLong

rotateR :: Exp CLong -> Exp Int -> Exp CLong

popCount :: Exp CLong -> Exp Int

Rewrapped CLong t

Defined in Control.Lens.Wrapped

Lift Exp CLong

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain CLong

Methods

lift :: CLong -> Exp (Plain CLong)

Bounded (Exp CLong)

Defined in Data.Array.Accelerate.Classes.Bounded

Methods

minBound :: Exp CLong

maxBound :: Exp CLong

Enum (Exp CLong)

Defined in Data.Array.Accelerate.Classes.Enum

Methods

succ :: Exp CLong -> Exp CLong

pred :: Exp CLong -> Exp CLong

toEnum :: Int -> Exp CLong

fromEnum :: Exp CLong -> Int

enumFrom :: Exp CLong -> [Exp CLong]

enumFromThen :: Exp CLong -> Exp CLong -> [Exp CLong]

enumFromTo :: Exp CLong -> Exp CLong -> [Exp CLong]

enumFromThenTo :: Exp CLong -> Exp CLong -> Exp CLong -> [Exp CLong]

Integral (Exp CLong)

Defined in Data.Array.Accelerate.Classes.Integral

Methods

quot :: Exp CLong -> Exp CLong -> Exp CLong

rem :: Exp CLong -> Exp CLong -> Exp CLong

div :: Exp CLong -> Exp CLong -> Exp CLong

mod :: Exp CLong -> Exp CLong -> Exp CLong

quotRem :: Exp CLong -> Exp CLong -> (Exp CLong, Exp CLong)

divMod :: Exp CLong -> Exp CLong -> (Exp CLong, Exp CLong)

toInteger :: Exp CLong -> Integer

Num (Exp CLong)

Defined in Data.Array.Accelerate.Classes.Num

Methods

(+) :: Exp CLong -> Exp CLong -> Exp CLong

(-) :: Exp CLong -> Exp CLong -> Exp CLong

(*) :: Exp CLong -> Exp CLong -> Exp CLong

negate :: Exp CLong -> Exp CLong

abs :: Exp CLong -> Exp CLong

signum :: Exp CLong -> Exp CLong

fromInteger :: Integer -> Exp CLong

type Difference CLong

Defined in Basement.Numerical.Subtractive

type Difference CLong = CLong

type Unwrapped CLong

Defined in Control.Lens.Wrapped

type Unwrapped CLong = Int64

type Plain CLong

Defined in Data.Array.Accelerate.Lift

type Plain CLong = CLong

data CULong

Haskell type representing the C unsigned long type. (The concrete types of Foreign.C.Types are platform-specific.)

Instances

Bounded CULong

Defined in Foreign.C.Types

Methods

minBound :: CULong

maxBound :: CULong

Enum CULong

Defined in Foreign.C.Types

Methods

succ :: CULong -> CULong

pred :: CULong -> CULong

toEnum :: Int -> CULong

fromEnum :: CULong -> Int

enumFrom :: CULong -> [CULong]

enumFromThen :: CULong -> CULong -> [CULong]

enumFromTo :: CULong -> CULong -> [CULong]

enumFromThenTo :: CULong -> CULong -> CULong -> [CULong]

Eq CULong

Defined in Foreign.C.Types

Methods

(==) :: CULong -> CULong -> Bool

(/=) :: CULong -> CULong -> Bool

Integral CULong

Defined in Foreign.C.Types

Methods

quot :: CULong -> CULong -> CULong

rem :: CULong -> CULong -> CULong

div :: CULong -> CULong -> CULong

mod :: CULong -> CULong -> CULong

quotRem :: CULong -> CULong -> (CULong, CULong)

divMod :: CULong -> CULong -> (CULong, CULong)

toInteger :: CULong -> Integer

Num CULong

Defined in Foreign.C.Types

Methods

(+) :: CULong -> CULong -> CULong

(-) :: CULong -> CULong -> CULong

(*) :: CULong -> CULong -> CULong

negate :: CULong -> CULong

abs :: CULong -> CULong

signum :: CULong -> CULong

fromInteger :: Integer -> CULong

Ord CULong

Defined in Foreign.C.Types

Methods

compare :: CULong -> CULong -> Ordering

(<) :: CULong -> CULong -> Bool

(<=) :: CULong -> CULong -> Bool

(>) :: CULong -> CULong -> Bool

(>=) :: CULong -> CULong -> Bool

max :: CULong -> CULong -> CULong

min :: CULong -> CULong -> CULong

Read CULong

Defined in Foreign.C.Types

Methods

readsPrec :: Int -> ReadS CULong

readList :: ReadS [CULong]

readPrec :: ReadPrec CULong

readListPrec :: ReadPrec [CULong]

Real CULong

Defined in Foreign.C.Types

Methods

toRational :: CULong -> Rational

Show CULong

Defined in Foreign.C.Types

Methods

showsPrec :: Int -> CULong -> ShowS

show :: CULong -> String

showList :: [CULong] -> ShowS

Storable CULong

Defined in Foreign.C.Types

Methods

sizeOf :: CULong -> Int

alignment :: CULong -> Int

peekElemOff :: Ptr CULong -> Int -> IO CULong

pokeElemOff :: Ptr CULong -> Int -> CULong -> IO ()

peekByteOff :: Ptr b -> Int -> IO CULong

pokeByteOff :: Ptr b -> Int -> CULong -> IO ()

peek :: Ptr CULong -> IO CULong

poke :: Ptr CULong -> CULong -> IO ()

Bits CULong

Defined in Foreign.C.Types

Methods

(.&.) :: CULong -> CULong -> CULong

(.|.) :: CULong -> CULong -> CULong

xor :: CULong -> CULong -> CULong

complement :: CULong -> CULong

shift :: CULong -> Int -> CULong

rotate :: CULong -> Int -> CULong

zeroBits :: CULong

bit :: Int -> CULong

setBit :: CULong -> Int -> CULong

clearBit :: CULong -> Int -> CULong

complementBit :: CULong -> Int -> CULong

testBit :: CULong -> Int -> Bool

bitSizeMaybe :: CULong -> Maybe Int

bitSize :: CULong -> Int

isSigned :: CULong -> Bool

shiftL :: CULong -> Int -> CULong

unsafeShiftL :: CULong -> Int -> CULong

shiftR :: CULong -> Int -> CULong

unsafeShiftR :: CULong -> Int -> CULong

rotateL :: CULong -> Int -> CULong

rotateR :: CULong -> Int -> CULong

popCount :: CULong -> Int

FiniteBits CULong

Defined in Foreign.C.Types

Methods

finiteBitSize :: CULong -> Int

countLeadingZeros :: CULong -> Int

countTrailingZeros :: CULong -> Int

Subtractive CULong

Defined in Basement.Numerical.Subtractive

Associated Types

type Difference CULong

Methods

(-) :: CULong -> CULong -> Difference CULong

NFData CULong

Since: deepseq-1.4.0.0

Defined in Control.DeepSeq

Methods

rnf :: CULong -> ()

Prim CULong

Defined in Data.Primitive.Types

Methods

sizeOf# :: CULong -> Int#

alignment# :: CULong -> Int#

indexByteArray# :: ByteArray# -> Int# -> CULong

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, CULong #)

writeByteArray# :: MutableByteArray# s -> Int# -> CULong -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> CULong -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> CULong

readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, CULong #)

writeOffAddr# :: Addr# -> Int# -> CULong -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> CULong -> State# s -> State# s

Wrapped CULong

Defined in Control.Lens.Wrapped

Associated Types

type Unwrapped CULong

Methods

_Wrapped' :: Iso' CULong (Unwrapped CULong)

Elt CULong

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR CULong

Methods

eltR :: TypeR (EltR CULong)

tagsR :: [TagR (EltR CULong)]

fromElt :: CULong -> EltR CULong

toElt :: EltR CULong -> CULong

Eq CULong

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp CULong -> Exp CULong -> Exp Bool

(/=) :: Exp CULong -> Exp CULong -> Exp Bool

Ord CULong

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp CULong -> Exp CULong -> Exp Bool

(>) :: Exp CULong -> Exp CULong -> Exp Bool

(<=) :: Exp CULong -> Exp CULong -> Exp Bool

(>=) :: Exp CULong -> Exp CULong -> Exp Bool

min :: Exp CULong -> Exp CULong -> Exp CULong

max :: Exp CULong -> Exp CULong -> Exp CULong

compare :: Exp CULong -> Exp CULong -> Exp Ordering

FiniteBits CULong

Defined in Data.Array.Accelerate.Data.Bits

Methods

finiteBitSize :: Exp CULong -> Exp Int

countLeadingZeros :: Exp CULong -> Exp Int

countTrailingZeros :: Exp CULong -> Exp Int

Bits CULong

Defined in Data.Array.Accelerate.Data.Bits

Methods

(.&.) :: Exp CULong -> Exp CULong -> Exp CULong

(.|.) :: Exp CULong -> Exp CULong -> Exp CULong

xor :: Exp CULong -> Exp CULong -> Exp CULong

complement :: Exp CULong -> Exp CULong

shift :: Exp CULong -> Exp Int -> Exp CULong

rotate :: Exp CULong -> Exp Int -> Exp CULong

zeroBits :: Exp CULong

bit :: Exp Int -> Exp CULong

setBit :: Exp CULong -> Exp Int -> Exp CULong

clearBit :: Exp CULong -> Exp Int -> Exp CULong

complementBit :: Exp CULong -> Exp Int -> Exp CULong

testBit :: Exp CULong -> Exp Int -> Exp Bool

isSigned :: Exp CULong -> Exp Bool

shiftL :: Exp CULong -> Exp Int -> Exp CULong

unsafeShiftL :: Exp CULong -> Exp Int -> Exp CULong

shiftR :: Exp CULong -> Exp Int -> Exp CULong

unsafeShiftR :: Exp CULong -> Exp Int -> Exp CULong

rotateL :: Exp CULong -> Exp Int -> Exp CULong

rotateR :: Exp CULong -> Exp Int -> Exp CULong

popCount :: Exp CULong -> Exp Int

Rewrapped CULong t

Defined in Control.Lens.Wrapped

Lift Exp CULong

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain CULong

Methods

lift :: CULong -> Exp (Plain CULong)

Bounded (Exp CULong)

Defined in Data.Array.Accelerate.Classes.Bounded

Methods

minBound :: Exp CULong

maxBound :: Exp CULong

Enum (Exp CULong)

Defined in Data.Array.Accelerate.Classes.Enum

Methods

succ :: Exp CULong -> Exp CULong

pred :: Exp CULong -> Exp CULong

toEnum :: Int -> Exp CULong

fromEnum :: Exp CULong -> Int

enumFrom :: Exp CULong -> [Exp CULong]

enumFromThen :: Exp CULong -> Exp CULong -> [Exp CULong]

enumFromTo :: Exp CULong -> Exp CULong -> [Exp CULong]

enumFromThenTo :: Exp CULong -> Exp CULong -> Exp CULong -> [Exp CULong]

Integral (Exp CULong)

Defined in Data.Array.Accelerate.Classes.Integral

Methods

quot :: Exp CULong -> Exp CULong -> Exp CULong

rem :: Exp CULong -> Exp CULong -> Exp CULong

div :: Exp CULong -> Exp CULong -> Exp CULong

mod :: Exp CULong -> Exp CULong -> Exp CULong

quotRem :: Exp CULong -> Exp CULong -> (Exp CULong, Exp CULong)

divMod :: Exp CULong -> Exp CULong -> (Exp CULong, Exp CULong)

toInteger :: Exp CULong -> Integer

Num (Exp CULong)

Defined in Data.Array.Accelerate.Classes.Num

Methods

(+) :: Exp CULong -> Exp CULong -> Exp CULong

(-) :: Exp CULong -> Exp CULong -> Exp CULong

(*) :: Exp CULong -> Exp CULong -> Exp CULong

negate :: Exp CULong -> Exp CULong

abs :: Exp CULong -> Exp CULong

signum :: Exp CULong -> Exp CULong

fromInteger :: Integer -> Exp CULong

type Difference CULong

Defined in Basement.Numerical.Subtractive

type Difference CULong = CULong

type Unwrapped CULong

Defined in Control.Lens.Wrapped

type Unwrapped CULong = Word64

type Plain CULong

Defined in Data.Array.Accelerate.Lift

type Plain CULong = CULong

data CLLong

Haskell type representing the C long long type. (The concrete types of Foreign.C.Types are platform-specific.)

Instances

Bounded CLLong

Defined in Foreign.C.Types

Methods

minBound :: CLLong

maxBound :: CLLong

Enum CLLong

Defined in Foreign.C.Types

Methods

succ :: CLLong -> CLLong

pred :: CLLong -> CLLong

toEnum :: Int -> CLLong

fromEnum :: CLLong -> Int

enumFrom :: CLLong -> [CLLong]

enumFromThen :: CLLong -> CLLong -> [CLLong]

enumFromTo :: CLLong -> CLLong -> [CLLong]

enumFromThenTo :: CLLong -> CLLong -> CLLong -> [CLLong]

Eq CLLong

Defined in Foreign.C.Types

Methods

(==) :: CLLong -> CLLong -> Bool

(/=) :: CLLong -> CLLong -> Bool

Integral CLLong

Defined in Foreign.C.Types

Methods

quot :: CLLong -> CLLong -> CLLong

rem :: CLLong -> CLLong -> CLLong

div :: CLLong -> CLLong -> CLLong

mod :: CLLong -> CLLong -> CLLong

quotRem :: CLLong -> CLLong -> (CLLong, CLLong)

divMod :: CLLong -> CLLong -> (CLLong, CLLong)

toInteger :: CLLong -> Integer

Num CLLong

Defined in Foreign.C.Types

Methods

(+) :: CLLong -> CLLong -> CLLong

(-) :: CLLong -> CLLong -> CLLong

(*) :: CLLong -> CLLong -> CLLong

negate :: CLLong -> CLLong

abs :: CLLong -> CLLong

signum :: CLLong -> CLLong

fromInteger :: Integer -> CLLong

Ord CLLong

Defined in Foreign.C.Types

Methods

compare :: CLLong -> CLLong -> Ordering

(<) :: CLLong -> CLLong -> Bool

(<=) :: CLLong -> CLLong -> Bool

(>) :: CLLong -> CLLong -> Bool

(>=) :: CLLong -> CLLong -> Bool

max :: CLLong -> CLLong -> CLLong

min :: CLLong -> CLLong -> CLLong

Read CLLong

Defined in Foreign.C.Types

Methods

readsPrec :: Int -> ReadS CLLong

readList :: ReadS [CLLong]

readPrec :: ReadPrec CLLong

readListPrec :: ReadPrec [CLLong]

Real CLLong

Defined in Foreign.C.Types

Methods

toRational :: CLLong -> Rational

Show CLLong

Defined in Foreign.C.Types

Methods

showsPrec :: Int -> CLLong -> ShowS

show :: CLLong -> String

showList :: [CLLong] -> ShowS

Storable CLLong

Defined in Foreign.C.Types

Methods

sizeOf :: CLLong -> Int

alignment :: CLLong -> Int

peekElemOff :: Ptr CLLong -> Int -> IO CLLong

pokeElemOff :: Ptr CLLong -> Int -> CLLong -> IO ()

peekByteOff :: Ptr b -> Int -> IO CLLong

pokeByteOff :: Ptr b -> Int -> CLLong -> IO ()

peek :: Ptr CLLong -> IO CLLong

poke :: Ptr CLLong -> CLLong -> IO ()

Bits CLLong

Defined in Foreign.C.Types

Methods

(.&.) :: CLLong -> CLLong -> CLLong

(.|.) :: CLLong -> CLLong -> CLLong

xor :: CLLong -> CLLong -> CLLong

complement :: CLLong -> CLLong

shift :: CLLong -> Int -> CLLong

rotate :: CLLong -> Int -> CLLong

zeroBits :: CLLong

bit :: Int -> CLLong

setBit :: CLLong -> Int -> CLLong

clearBit :: CLLong -> Int -> CLLong

complementBit :: CLLong -> Int -> CLLong

testBit :: CLLong -> Int -> Bool

bitSizeMaybe :: CLLong -> Maybe Int

bitSize :: CLLong -> Int

isSigned :: CLLong -> Bool

shiftL :: CLLong -> Int -> CLLong

unsafeShiftL :: CLLong -> Int -> CLLong

shiftR :: CLLong -> Int -> CLLong

unsafeShiftR :: CLLong -> Int -> CLLong

rotateL :: CLLong -> Int -> CLLong

rotateR :: CLLong -> Int -> CLLong

popCount :: CLLong -> Int

FiniteBits CLLong

Defined in Foreign.C.Types

Methods

finiteBitSize :: CLLong -> Int

countLeadingZeros :: CLLong -> Int

countTrailingZeros :: CLLong -> Int

Subtractive CLLong

Defined in Basement.Numerical.Subtractive

Associated Types

type Difference CLLong

Methods

(-) :: CLLong -> CLLong -> Difference CLLong

NFData CLLong

Since: deepseq-1.4.0.0

Defined in Control.DeepSeq

Methods

rnf :: CLLong -> ()

Prim CLLong

Defined in Data.Primitive.Types

Methods

sizeOf# :: CLLong -> Int#

alignment# :: CLLong -> Int#

indexByteArray# :: ByteArray# -> Int# -> CLLong

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, CLLong #)

writeByteArray# :: MutableByteArray# s -> Int# -> CLLong -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> CLLong -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> CLLong

readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, CLLong #)

writeOffAddr# :: Addr# -> Int# -> CLLong -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> CLLong -> State# s -> State# s

Wrapped CLLong

Defined in Control.Lens.Wrapped

Associated Types

type Unwrapped CLLong

Methods

_Wrapped' :: Iso' CLLong (Unwrapped CLLong)

Elt CLLong

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR CLLong

Methods

eltR :: TypeR (EltR CLLong)

tagsR :: [TagR (EltR CLLong)]

fromElt :: CLLong -> EltR CLLong

toElt :: EltR CLLong -> CLLong

Eq CLLong

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp CLLong -> Exp CLLong -> Exp Bool

(/=) :: Exp CLLong -> Exp CLLong -> Exp Bool

Ord CLLong

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp CLLong -> Exp CLLong -> Exp Bool

(>) :: Exp CLLong -> Exp CLLong -> Exp Bool

(<=) :: Exp CLLong -> Exp CLLong -> Exp Bool

(>=) :: Exp CLLong -> Exp CLLong -> Exp Bool

min :: Exp CLLong -> Exp CLLong -> Exp CLLong

max :: Exp CLLong -> Exp CLLong -> Exp CLLong

compare :: Exp CLLong -> Exp CLLong -> Exp Ordering

FiniteBits CLLong

Defined in Data.Array.Accelerate.Data.Bits

Methods

finiteBitSize :: Exp CLLong -> Exp Int

countLeadingZeros :: Exp CLLong -> Exp Int

countTrailingZeros :: Exp CLLong -> Exp Int

Bits CLLong

Defined in Data.Array.Accelerate.Data.Bits

Methods

(.&.) :: Exp CLLong -> Exp CLLong -> Exp CLLong

(.|.) :: Exp CLLong -> Exp CLLong -> Exp CLLong

xor :: Exp CLLong -> Exp CLLong -> Exp CLLong

complement :: Exp CLLong -> Exp CLLong

shift :: Exp CLLong -> Exp Int -> Exp CLLong

rotate :: Exp CLLong -> Exp Int -> Exp CLLong

zeroBits :: Exp CLLong

bit :: Exp Int -> Exp CLLong

setBit :: Exp CLLong -> Exp Int -> Exp CLLong

clearBit :: Exp CLLong -> Exp Int -> Exp CLLong

complementBit :: Exp CLLong -> Exp Int -> Exp CLLong

testBit :: Exp CLLong -> Exp Int -> Exp Bool

isSigned :: Exp CLLong -> Exp Bool

shiftL :: Exp CLLong -> Exp Int -> Exp CLLong

unsafeShiftL :: Exp CLLong -> Exp Int -> Exp CLLong

shiftR :: Exp CLLong -> Exp Int -> Exp CLLong

unsafeShiftR :: Exp CLLong -> Exp Int -> Exp CLLong

rotateL :: Exp CLLong -> Exp Int -> Exp CLLong

rotateR :: Exp CLLong -> Exp Int -> Exp CLLong

popCount :: Exp CLLong -> Exp Int

Rewrapped CLLong t

Defined in Control.Lens.Wrapped

Lift Exp CLLong

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain CLLong

Methods

lift :: CLLong -> Exp (Plain CLLong)

Bounded (Exp CLLong)

Defined in Data.Array.Accelerate.Classes.Bounded

Methods

minBound :: Exp CLLong

maxBound :: Exp CLLong

Enum (Exp CLLong)

Defined in Data.Array.Accelerate.Classes.Enum

Methods

succ :: Exp CLLong -> Exp CLLong

pred :: Exp CLLong -> Exp CLLong

toEnum :: Int -> Exp CLLong

fromEnum :: Exp CLLong -> Int

enumFrom :: Exp CLLong -> [Exp CLLong]

enumFromThen :: Exp CLLong -> Exp CLLong -> [Exp CLLong]

enumFromTo :: Exp CLLong -> Exp CLLong -> [Exp CLLong]

enumFromThenTo :: Exp CLLong -> Exp CLLong -> Exp CLLong -> [Exp CLLong]

Integral (Exp CLLong)

Defined in Data.Array.Accelerate.Classes.Integral

Methods

quot :: Exp CLLong -> Exp CLLong -> Exp CLLong

rem :: Exp CLLong -> Exp CLLong -> Exp CLLong

div :: Exp CLLong -> Exp CLLong -> Exp CLLong

mod :: Exp CLLong -> Exp CLLong -> Exp CLLong

quotRem :: Exp CLLong -> Exp CLLong -> (Exp CLLong, Exp CLLong)

divMod :: Exp CLLong -> Exp CLLong -> (Exp CLLong, Exp CLLong)

toInteger :: Exp CLLong -> Integer

Num (Exp CLLong)

Defined in Data.Array.Accelerate.Classes.Num

Methods

(+) :: Exp CLLong -> Exp CLLong -> Exp CLLong

(-) :: Exp CLLong -> Exp CLLong -> Exp CLLong

(*) :: Exp CLLong -> Exp CLLong -> Exp CLLong

negate :: Exp CLLong -> Exp CLLong

abs :: Exp CLLong -> Exp CLLong

signum :: Exp CLLong -> Exp CLLong

fromInteger :: Integer -> Exp CLLong

type Difference CLLong

Defined in Basement.Numerical.Subtractive

type Difference CLLong = CLLong

type Unwrapped CLLong

Defined in Control.Lens.Wrapped

type Unwrapped CLLong = Int64

type Plain CLLong

Defined in Data.Array.Accelerate.Lift

type Plain CLLong = CLLong

data CULLong

Haskell type representing the C unsigned long long type. (The concrete types of Foreign.C.Types are platform-specific.)

Instances

Bounded CULLong

Defined in Foreign.C.Types

Methods

minBound :: CULLong

maxBound :: CULLong

Enum CULLong

Defined in Foreign.C.Types

Methods

succ :: CULLong -> CULLong

pred :: CULLong -> CULLong

toEnum :: Int -> CULLong

fromEnum :: CULLong -> Int

enumFrom :: CULLong -> [CULLong]

enumFromThen :: CULLong -> CULLong -> [CULLong]

enumFromTo :: CULLong -> CULLong -> [CULLong]

enumFromThenTo :: CULLong -> CULLong -> CULLong -> [CULLong]

Eq CULLong

Defined in Foreign.C.Types

Methods

(==) :: CULLong -> CULLong -> Bool

(/=) :: CULLong -> CULLong -> Bool

Integral CULLong

Defined in Foreign.C.Types

Methods

quot :: CULLong -> CULLong -> CULLong

rem :: CULLong -> CULLong -> CULLong

div :: CULLong -> CULLong -> CULLong

mod :: CULLong -> CULLong -> CULLong

quotRem :: CULLong -> CULLong -> (CULLong, CULLong)

divMod :: CULLong -> CULLong -> (CULLong, CULLong)

toInteger :: CULLong -> Integer

Num CULLong

Defined in Foreign.C.Types

Methods

(+) :: CULLong -> CULLong -> CULLong

(-) :: CULLong -> CULLong -> CULLong

(*) :: CULLong -> CULLong -> CULLong

negate :: CULLong -> CULLong

abs :: CULLong -> CULLong

signum :: CULLong -> CULLong

fromInteger :: Integer -> CULLong

Ord CULLong

Defined in Foreign.C.Types

Methods

compare :: CULLong -> CULLong -> Ordering

(<) :: CULLong -> CULLong -> Bool

(<=) :: CULLong -> CULLong -> Bool

(>) :: CULLong -> CULLong -> Bool

(>=) :: CULLong -> CULLong -> Bool

max :: CULLong -> CULLong -> CULLong

min :: CULLong -> CULLong -> CULLong

Read CULLong

Defined in Foreign.C.Types

Methods

readsPrec :: Int -> ReadS CULLong

readList :: ReadS [CULLong]

readPrec :: ReadPrec CULLong

readListPrec :: ReadPrec [CULLong]

Real CULLong

Defined in Foreign.C.Types

Methods

toRational :: CULLong -> Rational

Show CULLong

Defined in Foreign.C.Types

Methods

showsPrec :: Int -> CULLong -> ShowS

show :: CULLong -> String

showList :: [CULLong] -> ShowS

Storable CULLong

Defined in Foreign.C.Types

Methods

sizeOf :: CULLong -> Int

alignment :: CULLong -> Int

peekElemOff :: Ptr CULLong -> Int -> IO CULLong

pokeElemOff :: Ptr CULLong -> Int -> CULLong -> IO ()

peekByteOff :: Ptr b -> Int -> IO CULLong

pokeByteOff :: Ptr b -> Int -> CULLong -> IO ()

peek :: Ptr CULLong -> IO CULLong

poke :: Ptr CULLong -> CULLong -> IO ()

Bits CULLong

Defined in Foreign.C.Types

Methods

(.&.) :: CULLong -> CULLong -> CULLong

(.|.) :: CULLong -> CULLong -> CULLong

xor :: CULLong -> CULLong -> CULLong

complement :: CULLong -> CULLong

shift :: CULLong -> Int -> CULLong

rotate :: CULLong -> Int -> CULLong

zeroBits :: CULLong

bit :: Int -> CULLong

setBit :: CULLong -> Int -> CULLong

clearBit :: CULLong -> Int -> CULLong

complementBit :: CULLong -> Int -> CULLong

testBit :: CULLong -> Int -> Bool

bitSizeMaybe :: CULLong -> Maybe Int

bitSize :: CULLong -> Int

isSigned :: CULLong -> Bool

shiftL :: CULLong -> Int -> CULLong

unsafeShiftL :: CULLong -> Int -> CULLong

shiftR :: CULLong -> Int -> CULLong

unsafeShiftR :: CULLong -> Int -> CULLong

rotateL :: CULLong -> Int -> CULLong

rotateR :: CULLong -> Int -> CULLong

popCount :: CULLong -> Int

FiniteBits CULLong

Defined in Foreign.C.Types

Methods

finiteBitSize :: CULLong -> Int

countLeadingZeros :: CULLong -> Int

countTrailingZeros :: CULLong -> Int

Subtractive CULLong

Defined in Basement.Numerical.Subtractive

Associated Types

type Difference CULLong

Methods

(-) :: CULLong -> CULLong -> Difference CULLong

NFData CULLong

Since: deepseq-1.4.0.0

Defined in Control.DeepSeq

Methods

rnf :: CULLong -> ()

Prim CULLong

Defined in Data.Primitive.Types

Methods

sizeOf# :: CULLong -> Int#

alignment# :: CULLong -> Int#

indexByteArray# :: ByteArray# -> Int# -> CULLong

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, CULLong #)

writeByteArray# :: MutableByteArray# s -> Int# -> CULLong -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> CULLong -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> CULLong

readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, CULLong #)

writeOffAddr# :: Addr# -> Int# -> CULLong -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> CULLong -> State# s -> State# s

Wrapped CULLong

Defined in Control.Lens.Wrapped

Associated Types

type Unwrapped CULLong

Methods

_Wrapped' :: Iso' CULLong (Unwrapped CULLong)

Elt CULLong

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR CULLong

Methods

eltR :: TypeR (EltR CULLong)

tagsR :: [TagR (EltR CULLong)]

fromElt :: CULLong -> EltR CULLong

toElt :: EltR CULLong -> CULLong

Eq CULLong

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp CULLong -> Exp CULLong -> Exp Bool

(/=) :: Exp CULLong -> Exp CULLong -> Exp Bool

Ord CULLong

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp CULLong -> Exp CULLong -> Exp Bool

(>) :: Exp CULLong -> Exp CULLong -> Exp Bool

(<=) :: Exp CULLong -> Exp CULLong -> Exp Bool

(>=) :: Exp CULLong -> Exp CULLong -> Exp Bool

min :: Exp CULLong -> Exp CULLong -> Exp CULLong

max :: Exp CULLong -> Exp CULLong -> Exp CULLong

compare :: Exp CULLong -> Exp CULLong -> Exp Ordering

FiniteBits CULLong

Defined in Data.Array.Accelerate.Data.Bits

Methods

finiteBitSize :: Exp CULLong -> Exp Int

countLeadingZeros :: Exp CULLong -> Exp Int

countTrailingZeros :: Exp CULLong -> Exp Int

Bits CULLong

Defined in Data.Array.Accelerate.Data.Bits

Methods

(.&.) :: Exp CULLong -> Exp CULLong -> Exp CULLong

(.|.) :: Exp CULLong -> Exp CULLong -> Exp CULLong

xor :: Exp CULLong -> Exp CULLong -> Exp CULLong

complement :: Exp CULLong -> Exp CULLong

shift :: Exp CULLong -> Exp Int -> Exp CULLong

rotate :: Exp CULLong -> Exp Int -> Exp CULLong

zeroBits :: Exp CULLong

bit :: Exp Int -> Exp CULLong

setBit :: Exp CULLong -> Exp Int -> Exp CULLong

clearBit :: Exp CULLong -> Exp Int -> Exp CULLong

complementBit :: Exp CULLong -> Exp Int -> Exp CULLong

testBit :: Exp CULLong -> Exp Int -> Exp Bool

isSigned :: Exp CULLong -> Exp Bool

shiftL :: Exp CULLong -> Exp Int -> Exp CULLong

unsafeShiftL :: Exp CULLong -> Exp Int -> Exp CULLong

shiftR :: Exp CULLong -> Exp Int -> Exp CULLong

unsafeShiftR :: Exp CULLong -> Exp Int -> Exp CULLong

rotateL :: Exp CULLong -> Exp Int -> Exp CULLong

rotateR :: Exp CULLong -> Exp Int -> Exp CULLong

popCount :: Exp CULLong -> Exp Int

Rewrapped CULLong t

Defined in Control.Lens.Wrapped

Lift Exp CULLong

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain CULLong

Methods

lift :: CULLong -> Exp (Plain CULLong)

Bounded (Exp CULLong)

Defined in Data.Array.Accelerate.Classes.Bounded

Methods

minBound :: Exp CULLong

maxBound :: Exp CULLong

Enum (Exp CULLong)

Defined in Data.Array.Accelerate.Classes.Enum

Methods

succ :: Exp CULLong -> Exp CULLong

pred :: Exp CULLong -> Exp CULLong

toEnum :: Int -> Exp CULLong

fromEnum :: Exp CULLong -> Int

enumFrom :: Exp CULLong -> [Exp CULLong]

enumFromThen :: Exp CULLong -> Exp CULLong -> [Exp CULLong]

enumFromTo :: Exp CULLong -> Exp CULLong -> [Exp CULLong]

enumFromThenTo :: Exp CULLong -> Exp CULLong -> Exp CULLong -> [Exp CULLong]

Integral (Exp CULLong)

Defined in Data.Array.Accelerate.Classes.Integral

Methods

quot :: Exp CULLong -> Exp CULLong -> Exp CULLong

rem :: Exp CULLong -> Exp CULLong -> Exp CULLong

div :: Exp CULLong -> Exp CULLong -> Exp CULLong

mod :: Exp CULLong -> Exp CULLong -> Exp CULLong

quotRem :: Exp CULLong -> Exp CULLong -> (Exp CULLong, Exp CULLong)

divMod :: Exp CULLong -> Exp CULLong -> (Exp CULLong, Exp CULLong)

toInteger :: Exp CULLong -> Integer

Num (Exp CULLong)

Defined in Data.Array.Accelerate.Classes.Num

Methods

(+) :: Exp CULLong -> Exp CULLong -> Exp CULLong

(-) :: Exp CULLong -> Exp CULLong -> Exp CULLong

(*) :: Exp CULLong -> Exp CULLong -> Exp CULLong

negate :: Exp CULLong -> Exp CULLong

abs :: Exp CULLong -> Exp CULLong

signum :: Exp CULLong -> Exp CULLong

fromInteger :: Integer -> Exp CULLong

type Difference CULLong

Defined in Basement.Numerical.Subtractive

type Difference CULLong = CULLong

type Unwrapped CULLong

Defined in Control.Lens.Wrapped

type Unwrapped CULLong = Word64

type Plain CULLong

Defined in Data.Array.Accelerate.Lift

type Plain CULLong = CULLong

data CChar

Haskell type representing the C char type. (The concrete types of Foreign.C.Types are platform-specific.)

Instances

Bounded CChar

Defined in Foreign.C.Types

Methods

minBound :: CChar

maxBound :: CChar

Enum CChar

Defined in Foreign.C.Types

Methods

succ :: CChar -> CChar

pred :: CChar -> CChar

toEnum :: Int -> CChar

fromEnum :: CChar -> Int

enumFrom :: CChar -> [CChar]

enumFromThen :: CChar -> CChar -> [CChar]

enumFromTo :: CChar -> CChar -> [CChar]

enumFromThenTo :: CChar -> CChar -> CChar -> [CChar]

Eq CChar

Defined in Foreign.C.Types

Methods

(==) :: CChar -> CChar -> Bool

(/=) :: CChar -> CChar -> Bool

Integral CChar

Defined in Foreign.C.Types

Methods

quot :: CChar -> CChar -> CChar

rem :: CChar -> CChar -> CChar

div :: CChar -> CChar -> CChar

mod :: CChar -> CChar -> CChar

quotRem :: CChar -> CChar -> (CChar, CChar)

divMod :: CChar -> CChar -> (CChar, CChar)

toInteger :: CChar -> Integer

Num CChar

Defined in Foreign.C.Types

Methods

(+) :: CChar -> CChar -> CChar

(-) :: CChar -> CChar -> CChar

(*) :: CChar -> CChar -> CChar

negate :: CChar -> CChar

abs :: CChar -> CChar

signum :: CChar -> CChar

fromInteger :: Integer -> CChar

Ord CChar

Defined in Foreign.C.Types

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

Defined in Foreign.C.Types

Methods

readsPrec :: Int -> ReadS CChar

readList :: ReadS [CChar]

readPrec :: ReadPrec CChar

readListPrec :: ReadPrec [CChar]

Real CChar

Defined in Foreign.C.Types

Methods

toRational :: CChar -> Rational

Show CChar

Defined in Foreign.C.Types

Methods

showsPrec :: Int -> CChar -> ShowS

show :: CChar -> String

showList :: [CChar] -> ShowS

Storable CChar

Defined in Foreign.C.Types

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

Defined in Foreign.C.Types

Methods

(.&.) :: CChar -> CChar -> CChar

(.|.) :: CChar -> CChar -> CChar

xor :: CChar -> CChar -> CChar

complement :: CChar -> CChar

shift :: CChar -> Int -> CChar

rotate :: CChar -> Int -> CChar

zeroBits :: CChar

bit :: Int -> CChar

setBit :: CChar -> Int -> CChar

clearBit :: CChar -> Int -> CChar

complementBit :: CChar -> Int -> CChar

testBit :: CChar -> Int -> Bool

bitSizeMaybe :: CChar -> Maybe Int

bitSize :: CChar -> Int

isSigned :: CChar -> Bool

shiftL :: CChar -> Int -> CChar

unsafeShiftL :: CChar -> Int -> CChar

shiftR :: CChar -> Int -> CChar

unsafeShiftR :: CChar -> Int -> CChar

rotateL :: CChar -> Int -> CChar

rotateR :: CChar -> Int -> CChar

popCount :: CChar -> Int

FiniteBits CChar

Defined in Foreign.C.Types

Methods

finiteBitSize :: CChar -> Int

countLeadingZeros :: CChar -> Int

countTrailingZeros :: CChar -> Int

PrimType CChar

Defined in Basement.PrimType

Associated Types

type PrimSize CChar :: Nat

Methods

primSizeInBytes :: Proxy CChar -> CountOf Word8

primShiftToBytes :: Proxy CChar -> Int

primBaUIndex :: ByteArray# -> Offset CChar -> CChar

primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset CChar -> prim CChar

primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset CChar -> CChar -> prim ()

primAddrIndex :: Addr# -> Offset CChar -> CChar

primAddrRead :: PrimMonad prim => Addr# -> Offset CChar -> prim CChar

primAddrWrite :: PrimMonad prim => Addr# -> Offset CChar -> CChar -> prim ()

PrimMemoryComparable CChar

Defined in Basement.PrimType

Subtractive CChar

Defined in Basement.Numerical.Subtractive

Associated Types

type Difference CChar

Methods

(-) :: CChar -> CChar -> Difference CChar

NFData CChar

Since: deepseq-1.4.0.0

Defined in Control.DeepSeq

Methods

rnf :: CChar -> ()

Prim CChar

Defined in Data.Primitive.Types

Methods

sizeOf# :: CChar -> Int#

alignment# :: CChar -> Int#

indexByteArray# :: ByteArray# -> Int# -> CChar

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, CChar #)

writeByteArray# :: MutableByteArray# s -> Int# -> CChar -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> CChar -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> CChar

readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, CChar #)

writeOffAddr# :: Addr# -> Int# -> CChar -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> CChar -> State# s -> State# s

Wrapped CChar

Defined in Control.Lens.Wrapped

Associated Types

type Unwrapped CChar

Methods

_Wrapped' :: Iso' CChar (Unwrapped CChar)

Elt CChar

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR CChar

Methods

eltR :: TypeR (EltR CChar)

tagsR :: [TagR (EltR CChar)]

fromElt :: CChar -> EltR CChar

toElt :: EltR CChar -> CChar

Eq CChar

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp CChar -> Exp CChar -> Exp Bool

(/=) :: Exp CChar -> Exp CChar -> Exp Bool

Ord CChar

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp CChar -> Exp CChar -> Exp Bool

(>) :: Exp CChar -> Exp CChar -> Exp Bool

(<=) :: Exp CChar -> Exp CChar -> Exp Bool

(>=) :: Exp CChar -> Exp CChar -> Exp Bool

min :: Exp CChar -> Exp CChar -> Exp CChar

max :: Exp CChar -> Exp CChar -> Exp CChar

compare :: Exp CChar -> Exp CChar -> Exp Ordering

FiniteBits CChar

Defined in Data.Array.Accelerate.Data.Bits

Methods

finiteBitSize :: Exp CChar -> Exp Int

countLeadingZeros :: Exp CChar -> Exp Int

countTrailingZeros :: Exp CChar -> Exp Int

Bits CChar

Defined in Data.Array.Accelerate.Data.Bits

Methods

(.&.) :: Exp CChar -> Exp CChar -> Exp CChar

(.|.) :: Exp CChar -> Exp CChar -> Exp CChar

xor :: Exp CChar -> Exp CChar -> Exp CChar

complement :: Exp CChar -> Exp CChar

shift :: Exp CChar -> Exp Int -> Exp CChar

rotate :: Exp CChar -> Exp Int -> Exp CChar

zeroBits :: Exp CChar

bit :: Exp Int -> Exp CChar

setBit :: Exp CChar -> Exp Int -> Exp CChar

clearBit :: Exp CChar -> Exp Int -> Exp CChar

complementBit :: Exp CChar -> Exp Int -> Exp CChar

testBit :: Exp CChar -> Exp Int -> Exp Bool

isSigned :: Exp CChar -> Exp Bool

shiftL :: Exp CChar -> Exp Int -> Exp CChar

unsafeShiftL :: Exp CChar -> Exp Int -> Exp CChar

shiftR :: Exp CChar -> Exp Int -> Exp CChar

unsafeShiftR :: Exp CChar -> Exp Int -> Exp CChar

rotateL :: Exp CChar -> Exp Int -> Exp CChar

rotateR :: Exp CChar -> Exp Int -> Exp CChar

popCount :: Exp CChar -> Exp Int

Rewrapped CChar t

Defined in Control.Lens.Wrapped

Lift Exp CChar

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain CChar

Methods

lift :: CChar -> Exp (Plain CChar)

Bounded (Exp CChar)

Defined in Data.Array.Accelerate.Classes.Bounded

Methods

minBound :: Exp CChar

maxBound :: Exp CChar

type PrimSize CChar

Defined in Basement.PrimType

type PrimSize CChar = 1

type Difference CChar

Defined in Basement.Numerical.Subtractive

type Difference CChar = CChar

type Unwrapped CChar

Defined in Control.Lens.Wrapped

type Unwrapped CChar = Int8

type Plain CChar

Defined in Data.Array.Accelerate.Lift

type Plain CChar = CChar

data CSChar

Haskell type representing the C signed char type. (The concrete types of Foreign.C.Types are platform-specific.)

Instances

Bounded CSChar

Defined in Foreign.C.Types

Methods

minBound :: CSChar

maxBound :: CSChar

Enum CSChar

Defined in Foreign.C.Types

Methods

succ :: CSChar -> CSChar

pred :: CSChar -> CSChar

toEnum :: Int -> CSChar

fromEnum :: CSChar -> Int

enumFrom :: CSChar -> [CSChar]

enumFromThen :: CSChar -> CSChar -> [CSChar]

enumFromTo :: CSChar -> CSChar -> [CSChar]

enumFromThenTo :: CSChar -> CSChar -> CSChar -> [CSChar]

Eq CSChar

Defined in Foreign.C.Types

Methods

(==) :: CSChar -> CSChar -> Bool

(/=) :: CSChar -> CSChar -> Bool

Integral CSChar

Defined in Foreign.C.Types

Methods

quot :: CSChar -> CSChar -> CSChar

rem :: CSChar -> CSChar -> CSChar

div :: CSChar -> CSChar -> CSChar

mod :: CSChar -> CSChar -> CSChar

quotRem :: CSChar -> CSChar -> (CSChar, CSChar)

divMod :: CSChar -> CSChar -> (CSChar, CSChar)

toInteger :: CSChar -> Integer

Num CSChar

Defined in Foreign.C.Types

Methods

(+) :: CSChar -> CSChar -> CSChar

(-) :: CSChar -> CSChar -> CSChar

(*) :: CSChar -> CSChar -> CSChar

negate :: CSChar -> CSChar

abs :: CSChar -> CSChar

signum :: CSChar -> CSChar

fromInteger :: Integer -> CSChar

Ord CSChar

Defined in Foreign.C.Types

Methods

compare :: CSChar -> CSChar -> Ordering

(<) :: CSChar -> CSChar -> Bool

(<=) :: CSChar -> CSChar -> Bool

(>) :: CSChar -> CSChar -> Bool

(>=) :: CSChar -> CSChar -> Bool

max :: CSChar -> CSChar -> CSChar

min :: CSChar -> CSChar -> CSChar

Read CSChar

Defined in Foreign.C.Types

Methods

readsPrec :: Int -> ReadS CSChar

readList :: ReadS [CSChar]

readPrec :: ReadPrec CSChar

readListPrec :: ReadPrec [CSChar]

Real CSChar

Defined in Foreign.C.Types

Methods

toRational :: CSChar -> Rational

Show CSChar

Defined in Foreign.C.Types

Methods

showsPrec :: Int -> CSChar -> ShowS

show :: CSChar -> String

showList :: [CSChar] -> ShowS

Storable CSChar

Defined in Foreign.C.Types

Methods

sizeOf :: CSChar -> Int

alignment :: CSChar -> Int

peekElemOff :: Ptr CSChar -> Int -> IO CSChar

pokeElemOff :: Ptr CSChar -> Int -> CSChar -> IO ()

peekByteOff :: Ptr b -> Int -> IO CSChar

pokeByteOff :: Ptr b -> Int -> CSChar -> IO ()

peek :: Ptr CSChar -> IO CSChar

poke :: Ptr CSChar -> CSChar -> IO ()

Bits CSChar

Defined in Foreign.C.Types

Methods

(.&.) :: CSChar -> CSChar -> CSChar

(.|.) :: CSChar -> CSChar -> CSChar

xor :: CSChar -> CSChar -> CSChar

complement :: CSChar -> CSChar

shift :: CSChar -> Int -> CSChar

rotate :: CSChar -> Int -> CSChar

zeroBits :: CSChar

bit :: Int -> CSChar

setBit :: CSChar -> Int -> CSChar

clearBit :: CSChar -> Int -> CSChar

complementBit :: CSChar -> Int -> CSChar

testBit :: CSChar -> Int -> Bool

bitSizeMaybe :: CSChar -> Maybe Int

bitSize :: CSChar -> Int

isSigned :: CSChar -> Bool

shiftL :: CSChar -> Int -> CSChar

unsafeShiftL :: CSChar -> Int -> CSChar

shiftR :: CSChar -> Int -> CSChar

unsafeShiftR :: CSChar -> Int -> CSChar

rotateL :: CSChar -> Int -> CSChar

rotateR :: CSChar -> Int -> CSChar

popCount :: CSChar -> Int

FiniteBits CSChar

Defined in Foreign.C.Types

Methods

finiteBitSize :: CSChar -> Int

countLeadingZeros :: CSChar -> Int

countTrailingZeros :: CSChar -> Int

Subtractive CSChar

Defined in Basement.Numerical.Subtractive

Associated Types

type Difference CSChar

Methods

(-) :: CSChar -> CSChar -> Difference CSChar

NFData CSChar

Since: deepseq-1.4.0.0

Defined in Control.DeepSeq

Methods

rnf :: CSChar -> ()

Prim CSChar

Defined in Data.Primitive.Types

Methods

sizeOf# :: CSChar -> Int#

alignment# :: CSChar -> Int#

indexByteArray# :: ByteArray# -> Int# -> CSChar

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, CSChar #)

writeByteArray# :: MutableByteArray# s -> Int# -> CSChar -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> CSChar -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> CSChar

readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, CSChar #)

writeOffAddr# :: Addr# -> Int# -> CSChar -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> CSChar -> State# s -> State# s

Wrapped CSChar

Defined in Control.Lens.Wrapped

Associated Types

type Unwrapped CSChar

Methods

_Wrapped' :: Iso' CSChar (Unwrapped CSChar)

Elt CSChar

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR CSChar

Methods

eltR :: TypeR (EltR CSChar)

tagsR :: [TagR (EltR CSChar)]

fromElt :: CSChar -> EltR CSChar

toElt :: EltR CSChar -> CSChar

Eq CSChar

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp CSChar -> Exp CSChar -> Exp Bool

(/=) :: Exp CSChar -> Exp CSChar -> Exp Bool

Ord CSChar

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp CSChar -> Exp CSChar -> Exp Bool

(>) :: Exp CSChar -> Exp CSChar -> Exp Bool

(<=) :: Exp CSChar -> Exp CSChar -> Exp Bool

(>=) :: Exp CSChar -> Exp CSChar -> Exp Bool

min :: Exp CSChar -> Exp CSChar -> Exp CSChar

max :: Exp CSChar -> Exp CSChar -> Exp CSChar

compare :: Exp CSChar -> Exp CSChar -> Exp Ordering

FiniteBits CSChar

Defined in Data.Array.Accelerate.Data.Bits

Methods

finiteBitSize :: Exp CSChar -> Exp Int

countLeadingZeros :: Exp CSChar -> Exp Int

countTrailingZeros :: Exp CSChar -> Exp Int

Bits CSChar

Defined in Data.Array.Accelerate.Data.Bits

Methods

(.&.) :: Exp CSChar -> Exp CSChar -> Exp CSChar

(.|.) :: Exp CSChar -> Exp CSChar -> Exp CSChar

xor :: Exp CSChar -> Exp CSChar -> Exp CSChar

complement :: Exp CSChar -> Exp CSChar

shift :: Exp CSChar -> Exp Int -> Exp CSChar

rotate :: Exp CSChar -> Exp Int -> Exp CSChar

zeroBits :: Exp CSChar

bit :: Exp Int -> Exp CSChar

setBit :: Exp CSChar -> Exp Int -> Exp CSChar

clearBit :: Exp CSChar -> Exp Int -> Exp CSChar

complementBit :: Exp CSChar -> Exp Int -> Exp CSChar

testBit :: Exp CSChar -> Exp Int -> Exp Bool

isSigned :: Exp CSChar -> Exp Bool

shiftL :: Exp CSChar -> Exp Int -> Exp CSChar

unsafeShiftL :: Exp CSChar -> Exp Int -> Exp CSChar

shiftR :: Exp CSChar -> Exp Int -> Exp CSChar

unsafeShiftR :: Exp CSChar -> Exp Int -> Exp CSChar

rotateL :: Exp CSChar -> Exp Int -> Exp CSChar

rotateR :: Exp CSChar -> Exp Int -> Exp CSChar

popCount :: Exp CSChar -> Exp Int

Rewrapped CSChar t

Defined in Control.Lens.Wrapped

Lift Exp CSChar

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain CSChar

Methods

lift :: CSChar -> Exp (Plain CSChar)

Bounded (Exp CSChar)

Defined in Data.Array.Accelerate.Classes.Bounded

Methods

minBound :: Exp CSChar

maxBound :: Exp CSChar

type Difference CSChar

Defined in Basement.Numerical.Subtractive

type Difference CSChar = CSChar

type Unwrapped CSChar

Defined in Control.Lens.Wrapped

type Unwrapped CSChar = Int8

type Plain CSChar

Defined in Data.Array.Accelerate.Lift

type Plain CSChar = CSChar

data CUChar

Haskell type representing the C unsigned char type. (The concrete types of Foreign.C.Types are platform-specific.)

Instances

Bounded CUChar

Defined in Foreign.C.Types

Methods

minBound :: CUChar

maxBound :: CUChar

Enum CUChar

Defined in Foreign.C.Types

Methods

succ :: CUChar -> CUChar

pred :: CUChar -> CUChar

toEnum :: Int -> CUChar

fromEnum :: CUChar -> Int

enumFrom :: CUChar -> [CUChar]

enumFromThen :: CUChar -> CUChar -> [CUChar]

enumFromTo :: CUChar -> CUChar -> [CUChar]

enumFromThenTo :: CUChar -> CUChar -> CUChar -> [CUChar]

Eq CUChar

Defined in Foreign.C.Types

Methods

(==) :: CUChar -> CUChar -> Bool

(/=) :: CUChar -> CUChar -> Bool

Integral CUChar

Defined in Foreign.C.Types

Methods

quot :: CUChar -> CUChar -> CUChar

rem :: CUChar -> CUChar -> CUChar

div :: CUChar -> CUChar -> CUChar

mod :: CUChar -> CUChar -> CUChar

quotRem :: CUChar -> CUChar -> (CUChar, CUChar)

divMod :: CUChar -> CUChar -> (CUChar, CUChar)

toInteger :: CUChar -> Integer

Num CUChar

Defined in Foreign.C.Types

Methods

(+) :: CUChar -> CUChar -> CUChar

(-) :: CUChar -> CUChar -> CUChar

(*) :: CUChar -> CUChar -> CUChar

negate :: CUChar -> CUChar

abs :: CUChar -> CUChar

signum :: CUChar -> CUChar

fromInteger :: Integer -> CUChar

Ord CUChar

Defined in Foreign.C.Types

Methods

compare :: CUChar -> CUChar -> Ordering

(<) :: CUChar -> CUChar -> Bool

(<=) :: CUChar -> CUChar -> Bool

(>) :: CUChar -> CUChar -> Bool

(>=) :: CUChar -> CUChar -> Bool

max :: CUChar -> CUChar -> CUChar

min :: CUChar -> CUChar -> CUChar

Read CUChar

Defined in Foreign.C.Types

Methods

readsPrec :: Int -> ReadS CUChar

readList :: ReadS [CUChar]

readPrec :: ReadPrec CUChar

readListPrec :: ReadPrec [CUChar]

Real CUChar

Defined in Foreign.C.Types

Methods

toRational :: CUChar -> Rational

Show CUChar

Defined in Foreign.C.Types

Methods

showsPrec :: Int -> CUChar -> ShowS

show :: CUChar -> String

showList :: [CUChar] -> ShowS

Storable CUChar

Defined in Foreign.C.Types

Methods

sizeOf :: CUChar -> Int

alignment :: CUChar -> Int

peekElemOff :: Ptr CUChar -> Int -> IO CUChar

pokeElemOff :: Ptr CUChar -> Int -> CUChar -> IO ()

peekByteOff :: Ptr b -> Int -> IO CUChar

pokeByteOff :: Ptr b -> Int -> CUChar -> IO ()

peek :: Ptr CUChar -> IO CUChar

poke :: Ptr CUChar -> CUChar -> IO ()

Bits CUChar

Defined in Foreign.C.Types

Methods

(.&.) :: CUChar -> CUChar -> CUChar

(.|.) :: CUChar -> CUChar -> CUChar

xor :: CUChar -> CUChar -> CUChar

complement :: CUChar -> CUChar

shift :: CUChar -> Int -> CUChar

rotate :: CUChar -> Int -> CUChar

zeroBits :: CUChar

bit :: Int -> CUChar

setBit :: CUChar -> Int -> CUChar

clearBit :: CUChar -> Int -> CUChar

complementBit :: CUChar -> Int -> CUChar

testBit :: CUChar -> Int -> Bool

bitSizeMaybe :: CUChar -> Maybe Int

bitSize :: CUChar -> Int

isSigned :: CUChar -> Bool

shiftL :: CUChar -> Int -> CUChar

unsafeShiftL :: CUChar -> Int -> CUChar

shiftR :: CUChar -> Int -> CUChar

unsafeShiftR :: CUChar -> Int -> CUChar

rotateL :: CUChar -> Int -> CUChar

rotateR :: CUChar -> Int -> CUChar

popCount :: CUChar -> Int

FiniteBits CUChar

Defined in Foreign.C.Types

Methods

finiteBitSize :: CUChar -> Int

countLeadingZeros :: CUChar -> Int

countTrailingZeros :: CUChar -> Int

PrimType CUChar

Defined in Basement.PrimType

Associated Types

type PrimSize CUChar :: Nat

Methods

primSizeInBytes :: Proxy CUChar -> CountOf Word8

primShiftToBytes :: Proxy CUChar -> Int

primBaUIndex :: ByteArray# -> Offset CUChar -> CUChar

primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset CUChar -> prim CUChar

primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset CUChar -> CUChar -> prim ()

primAddrIndex :: Addr# -> Offset CUChar -> CUChar

primAddrRead :: PrimMonad prim => Addr# -> Offset CUChar -> prim CUChar

primAddrWrite :: PrimMonad prim => Addr# -> Offset CUChar -> CUChar -> prim ()

PrimMemoryComparable CUChar

Defined in Basement.PrimType

Subtractive CUChar

Defined in Basement.Numerical.Subtractive

Associated Types

type Difference CUChar

Methods

(-) :: CUChar -> CUChar -> Difference CUChar

NFData CUChar

Since: deepseq-1.4.0.0

Defined in Control.DeepSeq

Methods

rnf :: CUChar -> ()

Prim CUChar

Defined in Data.Primitive.Types

Methods

sizeOf# :: CUChar -> Int#

alignment# :: CUChar -> Int#

indexByteArray# :: ByteArray# -> Int# -> CUChar

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, CUChar #)

writeByteArray# :: MutableByteArray# s -> Int# -> CUChar -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> CUChar -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> CUChar

readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, CUChar #)

writeOffAddr# :: Addr# -> Int# -> CUChar -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> CUChar -> State# s -> State# s

Wrapped CUChar

Defined in Control.Lens.Wrapped

Associated Types

type Unwrapped CUChar

Methods

_Wrapped' :: Iso' CUChar (Unwrapped CUChar)

Elt CUChar

Defined in Data.Array.Accelerate.Sugar.Elt

Associated Types

type EltR CUChar

Methods

eltR :: TypeR (EltR CUChar)

tagsR :: [TagR (EltR CUChar)]

fromElt :: CUChar -> EltR CUChar

toElt :: EltR CUChar -> CUChar

Eq CUChar

Defined in Data.Array.Accelerate.Classes.Eq

Methods

(==) :: Exp CUChar -> Exp CUChar -> Exp Bool

(/=) :: Exp CUChar -> Exp CUChar -> Exp Bool

Ord CUChar

Defined in Data.Array.Accelerate.Classes.Ord

Methods

(<) :: Exp CUChar -> Exp CUChar -> Exp Bool

(>) :: Exp CUChar -> Exp CUChar -> Exp Bool

(<=) :: Exp CUChar -> Exp CUChar -> Exp Bool

(>=) :: Exp CUChar -> Exp CUChar -> Exp Bool

min :: Exp CUChar -> Exp CUChar -> Exp CUChar

max :: Exp CUChar -> Exp CUChar -> Exp CUChar

compare :: Exp CUChar -> Exp CUChar -> Exp Ordering

FiniteBits CUChar

Defined in Data.Array.Accelerate.Data.Bits

Methods

finiteBitSize :: Exp CUChar -> Exp Int

countLeadingZeros :: Exp CUChar -> Exp Int

countTrailingZeros :: Exp CUChar -> Exp Int

Bits CUChar

Defined in Data.Array.Accelerate.Data.Bits

Methods

(.&.) :: Exp CUChar -> Exp CUChar -> Exp CUChar

(.|.) :: Exp CUChar -> Exp CUChar -> Exp CUChar

xor :: Exp CUChar -> Exp CUChar -> Exp CUChar

complement :: Exp CUChar -> Exp CUChar

shift :: Exp CUChar -> Exp Int -> Exp CUChar

rotate :: Exp CUChar -> Exp Int -> Exp CUChar

zeroBits :: Exp CUChar

bit :: Exp Int -> Exp CUChar

setBit :: Exp CUChar -> Exp Int -> Exp CUChar

clearBit :: Exp CUChar -> Exp Int -> Exp CUChar

complementBit :: Exp CUChar -> Exp Int -> Exp CUChar

testBit :: Exp CUChar -> Exp Int -> Exp Bool

isSigned :: Exp CUChar -> Exp Bool

shiftL :: Exp CUChar -> Exp Int -> Exp CUChar

unsafeShiftL :: Exp CUChar -> Exp Int -> Exp CUChar

shiftR :: Exp CUChar -> Exp Int -> Exp CUChar

unsafeShiftR :: Exp CUChar -> Exp Int -> Exp CUChar

rotateL :: Exp CUChar -> Exp Int -> Exp CUChar

rotateR :: Exp CUChar -> Exp Int -> Exp CUChar

popCount :: Exp CUChar -> Exp Int

Rewrapped CUChar t

Defined in Control.Lens.Wrapped

Lift Exp CUChar

Defined in Data.Array.Accelerate.Lift

Associated Types

type Plain CUChar

Methods

lift :: CUChar -> Exp (Plain CUChar)

Bounded (Exp CUChar)

Defined in Data.Array.Accelerate.Classes.Bounded

Methods

minBound :: Exp CUChar

maxBound :: Exp CUChar

type PrimSize CUChar

Defined in Basement.PrimType

type PrimSize CUChar = 1

type Difference CUChar

Defined in Basement.Numerical.Subtractive

type Difference CUChar = CUChar

type Unwrapped CUChar

Defined in Control.Lens.Wrapped

type Unwrapped CUChar = Word8

type Plain CUChar

Defined in Data.Array.Accelerate.Lift

type Plain CUChar = CUChar