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

• Maintainers:

  • Trevor L. McDonell: mailto:[e-mail]
  • Manuel M T Chakravarty: 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

Associated Types

type EltT Acc a :: Constraint

Methods

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

Unlift Acc (Acc a)

Methods

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

Lift Acc (Acc a)

Associated Types

type Plain (Acc a) :: *

Methods

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

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

Methods

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

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

Associated Types

type Plain (a, b) :: *

Methods

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

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

Associated Types

type Plain (Array sh e) :: *

Methods

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

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

Methods

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

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

Associated Types

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

Methods

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

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

Methods

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

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

Associated Types

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

Methods

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

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

Methods

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

(Lift Acc a, Lift Acc b, Lift Acc c, Lift Acc d, Lift Acc e, Arrays (Plain a), Arrays (Plain b), Arrays (Plain c), Arrays (Plain d), Arrays (Plain e)) => Lift Acc (a, b, c, d, e)

Associated Types

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

Methods

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

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

Methods

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

(Lift Acc a, Lift Acc b, Lift Acc c, Lift Acc d, Lift Acc e, Lift Acc f, Arrays (Plain a), Arrays (Plain b), Arrays (Plain c), Arrays (Plain d), Arrays (Plain e), Arrays (Plain f)) => Lift Acc (a, b, c, d, e, f)

Associated Types

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

Methods

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

(Arrays a, Arrays b, Arrays c, Arrays d, Arrays e, Arrays f, Arrays g) => Unlift Acc (Acc a, Acc b, Acc c, Acc d, Acc e, Acc f, Acc g)

Methods

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

(Lift Acc a, Lift Acc b, Lift Acc c, Lift Acc d, Lift Acc e, Lift Acc f, Lift Acc g, Arrays (Plain a), Arrays (Plain b), Arrays (Plain c), Arrays (Plain d), Arrays (Plain e), Arrays (Plain f), Arrays (Plain g)) => Lift Acc (a, b, c, d, e, f, g)

Associated Types

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

Methods

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

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

Methods

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

(Lift Acc a, Lift Acc b, Lift Acc c, Lift Acc d, Lift Acc e, Lift Acc f, Lift Acc g, Lift Acc h, Arrays (Plain a), Arrays (Plain b), Arrays (Plain c), Arrays (Plain d), Arrays (Plain e), Arrays (Plain f), Arrays (Plain g), Arrays (Plain h)) => Lift Acc (a, b, c, d, e, f, g, h)

Associated Types

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

Methods

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

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

Methods

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

(Lift Acc a, Lift Acc b, Lift Acc c, Lift Acc d, Lift Acc e, Lift Acc f, Lift Acc g, Lift Acc h, Lift Acc i, Arrays (Plain a), Arrays (Plain b), Arrays (Plain c), Arrays (Plain d), Arrays (Plain e), Arrays (Plain f), Arrays (Plain g), Arrays (Plain h), Arrays (Plain i)) => Lift Acc (a, b, c, d, e, f, g, h, i)

Associated Types

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

Methods

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

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

Methods

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

(Lift Acc a, Lift Acc b, Lift Acc c, Lift Acc d, Lift Acc e, Lift Acc f, Lift Acc g, Lift Acc h, Lift Acc i, Lift Acc j, Arrays (Plain a), Arrays (Plain b), Arrays (Plain c), Arrays (Plain d), Arrays (Plain e), Arrays (Plain f), Arrays (Plain g), Arrays (Plain h), Arrays (Plain i), Arrays (Plain j)) => Lift Acc (a, b, c, d, e, f, g, h, i, j)

Associated Types

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

Methods

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

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

Methods

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

(Lift Acc a, Lift Acc b, Lift Acc c, Lift Acc d, Lift Acc e, Lift Acc f, Lift Acc g, Lift Acc h, Lift Acc i, Lift Acc j, Lift Acc k, Arrays (Plain a), Arrays (Plain b), Arrays (Plain c), Arrays (Plain d), Arrays (Plain e), Arrays (Plain f), Arrays (Plain g), Arrays (Plain h), Arrays (Plain i), Arrays (Plain j), Arrays (Plain k)) => Lift Acc (a, b, c, d, e, f, g, h, i, j, k)

Associated Types

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

Methods

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

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

Methods

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

(Lift Acc a, Lift Acc b, Lift Acc c, Lift Acc d, Lift Acc e, Lift Acc f, Lift Acc g, Lift Acc h, Lift Acc i, Lift Acc j, Lift Acc k, Lift Acc l, Arrays (Plain a), Arrays (Plain b), Arrays (Plain c), Arrays (Plain d), Arrays (Plain e), Arrays (Plain f), Arrays (Plain g), Arrays (Plain h), Arrays (Plain i), Arrays (Plain j), Arrays (Plain k), Arrays (Plain l)) => Lift Acc (a, b, c, d, e, f, g, h, i, j, k, l)

Associated Types

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

Methods

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

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

Methods

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

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

Associated Types

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

Methods

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

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

Methods

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

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

Associated Types

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

Methods

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

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

Methods

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

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

Associated Types

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

Methods

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

Arrays arrs => Show (Acc arrs)

Methods

showsPrec :: Int -> Acc arrs -> ShowS

show :: Acc arrs -> String

showList :: [Acc arrs] -> ShowS

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

Methods

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

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

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

type EltT Acc a

type EltT Acc a = Arrays a

type Plain (Acc a)

type Plain (Acc a) = a

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 15-elements wide.

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

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

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

Instances

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

Associated Types

type Plain (Array sh e) :: *

Methods

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

Elt e => IsList (Vector e)

Associated Types

type Item (Vector e) :: *

Methods

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

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

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

Show (Vector e)

Methods

showsPrec :: Int -> Vector e -> ShowS

show :: Vector e -> String

showList :: [Vector e] -> ShowS

Show (Scalar e)

Methods

showsPrec :: Int -> Scalar e -> ShowS

show :: Scalar e -> String

showList :: [Scalar e] -> ShowS

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

Methods

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

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

Show (Array sh e)

Methods

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

show :: Array sh e -> String

showList :: [Array sh e] -> ShowS

Show (Array DIM2 e)

Methods

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

show :: Array DIM2 e -> String

showList :: [Array DIM2 e] -> ShowS

NFData (Array sh e)

Methods

rnf :: Array sh e -> ()

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

Methods

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

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

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

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

type Item (Vector e)

type Item (Vector e) = e

type Plain (Array sh e)

type Plain (Array sh e) = Array sh e

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

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

Minimal complete definition

arrays, flavour, toArr, fromArr

Instances

Arrays ()

Methods

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

flavour :: () -> ArraysFlavour ()

toArr :: ArrRepr () -> ()

fromArr :: () -> ArrRepr ()

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

Methods

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

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

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

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

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

Methods

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

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

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

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

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

Methods

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

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

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

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

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

Methods

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

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

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

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

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

Methods

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

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

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

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

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

Methods

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

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

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

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

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

Methods

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

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

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

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

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

Methods

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

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

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

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

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

Methods

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

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

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

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

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

Methods

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

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

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

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

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

Methods

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

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

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

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

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

Methods

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

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

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

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

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

Methods

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

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

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

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

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

Methods

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

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

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

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

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

Methods

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

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

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

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

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

Methods

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

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

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

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

type Scalar = Array DIM0

Scalar arrays hold a single element

type Vector = Array DIM1

Vectors are one-dimensional arrays

type Matrix = 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 subarrays.

Array elements

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

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

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

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

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

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

Minimal complete definition

eltType, fromElt, toElt

Instances

Elt Bool

Methods

eltType :: Bool -> TupleType (EltRepr Bool)

fromElt :: Bool -> EltRepr Bool

toElt :: EltRepr Bool -> Bool

Elt Char

Methods

eltType :: Char -> TupleType (EltRepr Char)

fromElt :: Char -> EltRepr Char

toElt :: EltRepr Char -> Char

Elt Double

Methods

eltType :: Double -> TupleType (EltRepr Double)

fromElt :: Double -> EltRepr Double

toElt :: EltRepr Double -> Double

Elt Float

Methods

eltType :: Float -> TupleType (EltRepr Float)

fromElt :: Float -> EltRepr Float

toElt :: EltRepr Float -> Float

Elt Int

Methods

eltType :: Int -> TupleType (EltRepr Int)

fromElt :: Int -> EltRepr Int

toElt :: EltRepr Int -> Int

Elt Int8

Methods

eltType :: Int8 -> TupleType (EltRepr Int8)

fromElt :: Int8 -> EltRepr Int8

toElt :: EltRepr Int8 -> Int8

Elt Int16

Methods

eltType :: Int16 -> TupleType (EltRepr Int16)

fromElt :: Int16 -> EltRepr Int16

toElt :: EltRepr Int16 -> Int16

Elt Int32

Methods

eltType :: Int32 -> TupleType (EltRepr Int32)

fromElt :: Int32 -> EltRepr Int32

toElt :: EltRepr Int32 -> Int32

Elt Int64

Methods

eltType :: Int64 -> TupleType (EltRepr Int64)

fromElt :: Int64 -> EltRepr Int64

toElt :: EltRepr Int64 -> Int64

Elt Ordering

Methods

eltType :: Ordering -> TupleType (EltRepr Ordering)

fromElt :: Ordering -> EltRepr Ordering

toElt :: EltRepr Ordering -> Ordering

Elt Word

Methods

eltType :: Word -> TupleType (EltRepr Word)

fromElt :: Word -> EltRepr Word

toElt :: EltRepr Word -> Word

Elt Word8

Methods

eltType :: Word8 -> TupleType (EltRepr Word8)

fromElt :: Word8 -> EltRepr Word8

toElt :: EltRepr Word8 -> Word8

Elt Word16

Methods

eltType :: Word16 -> TupleType (EltRepr Word16)

fromElt :: Word16 -> EltRepr Word16

toElt :: EltRepr Word16 -> Word16

Elt Word32

Methods

eltType :: Word32 -> TupleType (EltRepr Word32)

fromElt :: Word32 -> EltRepr Word32

toElt :: EltRepr Word32 -> Word32

Elt Word64

Methods

eltType :: Word64 -> TupleType (EltRepr Word64)

fromElt :: Word64 -> EltRepr Word64

toElt :: EltRepr Word64 -> Word64

Elt ()

Methods

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

fromElt :: () -> EltRepr ()

toElt :: EltRepr () -> ()

Elt CChar

Methods

eltType :: CChar -> TupleType (EltRepr CChar)

fromElt :: CChar -> EltRepr CChar

toElt :: EltRepr CChar -> CChar

Elt CSChar

Methods

eltType :: CSChar -> TupleType (EltRepr CSChar)

fromElt :: CSChar -> EltRepr CSChar

toElt :: EltRepr CSChar -> CSChar

Elt CUChar

Methods

eltType :: CUChar -> TupleType (EltRepr CUChar)

fromElt :: CUChar -> EltRepr CUChar

toElt :: EltRepr CUChar -> CUChar

Elt CShort

Methods

eltType :: CShort -> TupleType (EltRepr CShort)

fromElt :: CShort -> EltRepr CShort

toElt :: EltRepr CShort -> CShort

Elt CUShort

Methods

eltType :: CUShort -> TupleType (EltRepr CUShort)

fromElt :: CUShort -> EltRepr CUShort

toElt :: EltRepr CUShort -> CUShort

Elt CInt

Methods

eltType :: CInt -> TupleType (EltRepr CInt)

fromElt :: CInt -> EltRepr CInt

toElt :: EltRepr CInt -> CInt

Elt CUInt

Methods

eltType :: CUInt -> TupleType (EltRepr CUInt)

fromElt :: CUInt -> EltRepr CUInt

toElt :: EltRepr CUInt -> CUInt

Elt CLong

Methods

eltType :: CLong -> TupleType (EltRepr CLong)

fromElt :: CLong -> EltRepr CLong

toElt :: EltRepr CLong -> CLong

Elt CULong

Methods

eltType :: CULong -> TupleType (EltRepr CULong)

fromElt :: CULong -> EltRepr CULong

toElt :: EltRepr CULong -> CULong

Elt CLLong

Methods

eltType :: CLLong -> TupleType (EltRepr CLLong)

fromElt :: CLLong -> EltRepr CLLong

toElt :: EltRepr CLLong -> CLLong

Elt CULLong

Methods

eltType :: CULLong -> TupleType (EltRepr CULLong)

fromElt :: CULLong -> EltRepr CULLong

toElt :: EltRepr CULLong -> CULLong

Elt CFloat

Methods

eltType :: CFloat -> TupleType (EltRepr CFloat)

fromElt :: CFloat -> EltRepr CFloat

toElt :: EltRepr CFloat -> CFloat

Elt CDouble

Methods

eltType :: CDouble -> TupleType (EltRepr CDouble)

fromElt :: CDouble -> EltRepr CDouble

toElt :: EltRepr CDouble -> CDouble

Elt Half

Methods

eltType :: Half -> TupleType (EltRepr Half)

fromElt :: Half -> EltRepr Half

toElt :: EltRepr Half -> Half

Elt All

Methods

eltType :: All -> TupleType (EltRepr All)

fromElt :: All -> EltRepr All

toElt :: EltRepr All -> All

Elt Z

Methods

eltType :: Z -> TupleType (EltRepr Z)

fromElt :: Z -> EltRepr Z

toElt :: EltRepr Z -> Z

Elt a => Elt (Maybe a)

Methods

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

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

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

Elt (Complex Double)

Methods

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

fromElt :: Complex Double -> EltRepr (Complex Double)

toElt :: EltRepr (Complex Double) -> Complex Double

Elt (Complex Float)

Methods

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

fromElt :: Complex Float -> EltRepr (Complex Float)

toElt :: EltRepr (Complex Float) -> Complex Float

Elt (Complex CFloat)

Methods

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

fromElt :: Complex CFloat -> EltRepr (Complex CFloat)

toElt :: EltRepr (Complex CFloat) -> Complex CFloat

Elt (Complex CDouble)

Methods

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

fromElt :: Complex CDouble -> EltRepr (Complex CDouble)

toElt :: EltRepr (Complex CDouble) -> Complex CDouble

Elt (Complex Half)

Methods

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

fromElt :: Complex Half -> EltRepr (Complex Half)

toElt :: EltRepr (Complex Half) -> Complex Half

Elt a => Elt (Min a)

Methods

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

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

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

Elt a => Elt (Max a)

Methods

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

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

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

Elt a => Elt (Sum a)

Methods

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

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

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

Elt a => Elt (Product a)

Methods

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

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

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

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

Methods

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

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

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

Elt (Any Z)

Methods

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

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

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

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

Methods

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

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

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

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

Methods

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

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

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

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

Methods

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

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

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

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

Methods

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

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

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

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

Methods

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

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

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

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

Methods

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

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

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

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

Methods

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

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

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

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

Methods

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

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

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

(Elt a, Elt b, Elt c, Elt d, Elt e, Elt f, Elt g, Elt h) => Elt (a, b, c, d, e, f, g, h)

Methods

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

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

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

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

Methods

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

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

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

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

Methods

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

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

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

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

Methods

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

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

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

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

Methods

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

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

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

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

Methods

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

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

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

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

Methods

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

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

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

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

Methods

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

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

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

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

Methods

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

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

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

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

Methods

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

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

Show Z

Methods

showsPrec :: Int -> Z -> ShowS

show :: Z -> String

showList :: [Z] -> ShowS

Slice Z

Associated Types

type SliceShape Z :: *

type CoSliceShape Z :: *

type FullShape Z :: *

Methods

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

Shape Z

Methods

rank :: Z -> Int

size :: Z -> Int

empty :: Z

ignore :: Z

intersect :: Z -> Z -> Z

union :: Z -> Z -> Z

toIndex :: Z -> Z -> Int

fromIndex :: Z -> Int -> Z

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

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

rangeToShape :: (Z, Z) -> Z

shapeToRange :: Z -> (Z, Z)

shapeToList :: Z -> [Int]

listToShape :: [Int] -> Z

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

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

Elt Z

Methods

eltType :: Z -> TupleType (EltRepr Z)

fromElt :: Z -> EltRepr Z

toElt :: EltRepr Z -> Z

Unlift Exp Z

Methods

unlift :: Exp (Plain Z) -> Z

Lift Exp Z

Associated Types

type Plain Z :: *

Methods

lift :: Z -> Exp (Plain Z)

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

Associated Types

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

Methods

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

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

Associated Types

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

Methods

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

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

Associated Types

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

Methods

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

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

Associated Types

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

Methods

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

Elt e => IsList (Vector e)

Associated Types

type Item (Vector e) :: *

Methods

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

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

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

Show (Vector e)

Methods

showsPrec :: Int -> Vector e -> ShowS

show :: Vector e -> String

showList :: [Vector e] -> ShowS

Show (Scalar e)

Methods

showsPrec :: Int -> Scalar e -> ShowS

show :: Scalar e -> String

showList :: [Scalar e] -> ShowS

Elt (Any Z)

Methods

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

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

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

Show (Array DIM2 e)

Methods

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

show :: Array DIM2 e -> String

showList :: [Array DIM2 e] -> ShowS

type SliceShape Z

type SliceShape Z = Z

type CoSliceShape Z

type CoSliceShape Z = Z

type FullShape Z

type FullShape Z = Z

type Plain Z

type Plain Z = Z

type Item (Vector e)

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)

Associated Types

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

Methods

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

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

Associated Types

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

Methods

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

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

Associated Types

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

Methods

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

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

Associated Types

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

Methods

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

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

Methods

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

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

Methods

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

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

Associated Types

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

Methods

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

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

Associated Types

type Plain (ix :. All) :: *

Methods

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

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

Associated Types

type Plain (ix :. Int) :: *

Methods

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

Elt e => IsList (Vector e)

Associated Types

type Item (Vector e) :: *

Methods

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

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

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

Show (Vector e)

Methods

showsPrec :: Int -> Vector e -> ShowS

show :: Vector e -> String

showList :: [Vector e] -> ShowS

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

Methods

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

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

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

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

Methods

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

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

Show (Array DIM2 e)

Methods

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

show :: Array DIM2 e -> String

showList :: [Array DIM2 e] -> ShowS

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

Methods

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

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

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

Slice sl => Slice (sl :. Int)

Associated Types

type SliceShape (sl :. Int) :: *

type CoSliceShape (sl :. Int) :: *

type FullShape (sl :. Int) :: *

Methods

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

Slice sl => Slice (sl :. All)

Associated Types

type SliceShape (sl :. All) :: *

type CoSliceShape (sl :. All) :: *

type FullShape (sl :. All) :: *

Methods

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

Shape sh => Shape (sh :. Int)

Methods

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

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

empty :: sh :. Int

ignore :: sh :. Int

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

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

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

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

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

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

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

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

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

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

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

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

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

Methods

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

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

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

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

Associated Types

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

Methods

stencilPrj :: ((sh :. Int) :. Int) -> a -> Exp (StencilRepr ((sh :. Int) :. Int) (row2, row1, row0)) -> (row2, row1, row0)

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

Associated Types

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

Methods

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

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

Associated Types

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

Methods

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

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

Associated Types

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

Methods

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

type Item (Vector e)

type Item (Vector e) = e

type SliceShape (sl :. Int)

type SliceShape (sl :. Int) = SliceShape sl

type SliceShape (sl :. All)

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

type CoSliceShape (sl :. Int)

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

type CoSliceShape (sl :. All)

type CoSliceShape (sl :. All) = CoSliceShape sl

type FullShape (sl :. Int)

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

type FullShape (sl :. All)

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

type Plain (ix :. Exp e)

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

type Plain (ix :. All)

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

type Plain (ix :. Int)

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), Shape (EltRepr sh), FullShape sh ~ sh, CoSliceShape sh ~ sh, SliceShape sh ~ Z) => Shape sh

Shapes and indices of multi-dimensional arrays

Minimal complete definition

sliceAnyIndex, sliceNoneIndex

Instances

Shape Z

Methods

rank :: Z -> Int

size :: Z -> Int

empty :: Z

ignore :: Z

intersect :: Z -> Z -> Z

union :: Z -> Z -> Z

toIndex :: Z -> Z -> Int

fromIndex :: Z -> Int -> Z

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

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

rangeToShape :: (Z, Z) -> Z

shapeToRange :: Z -> (Z, Z)

shapeToList :: Z -> [Int]

listToShape :: [Int] -> Z

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

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

Shape sh => Shape (sh :. Int)

Methods

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

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

empty :: sh :. Int

ignore :: sh :. Int

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Minimal complete definition

sliceIndex

Associated Types

type SliceShape sl :: *

type CoSliceShape sl :: *

type FullShape sl :: *

Methods

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

Instances

Slice Z

Associated Types

type SliceShape Z :: *

type CoSliceShape Z :: *

type FullShape Z :: *

Methods

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

Shape sh => Slice (Any sh)

Associated Types

type SliceShape (Any sh) :: *

type CoSliceShape (Any sh) :: *

type FullShape (Any sh) :: *

Methods

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

Slice sl => Slice (sl :. Int)

Associated Types

type SliceShape (sl :. Int) :: *

type CoSliceShape (sl :. Int) :: *

type FullShape (sl :. Int) :: *

Methods

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

Slice sl => Slice (sl :. All)

Associated Types

type SliceShape (sl :. All) :: *

type CoSliceShape (sl :. All) :: *

type FullShape (sl :. All) :: *

Methods

sliceIndex :: (sl :. All) -> SliceIndex (EltRepr (sl :. All)) (EltRepr (SliceShape (sl :. All))) (EltRepr (CoSliceShape (sl :. All))) (EltRepr (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

Methods

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

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

Show All

Methods

showsPrec :: Int -> All -> ShowS

show :: All -> String

showList :: [All] -> ShowS

Elt All

Methods

eltType :: All -> TupleType (EltRepr All)

fromElt :: All -> EltRepr All

toElt :: EltRepr All -> All

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

Associated Types

type Plain (ix :. All) :: *

Methods

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

Slice sl => Slice (sl :. All)

Associated Types

type SliceShape (sl :. All) :: *

type CoSliceShape (sl :. All) :: *

type FullShape (sl :. All) :: *

Methods

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

type SliceShape (sl :. All)

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

type CoSliceShape (sl :. All)

type CoSliceShape (sl :. All) = CoSliceShape sl

type FullShape (sl :. All)

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

type Plain (ix :. All)

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

Associated Types

type Plain (Any sh) :: *

Methods

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

Eq (Any sh)

Methods

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

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

Show (Any sh)

Methods

showsPrec :: Int -> Any sh -> ShowS

show :: Any sh -> String

showList :: [Any sh] -> ShowS

Shape sh => Slice (Any sh)

Associated Types

type SliceShape (Any sh) :: *

type CoSliceShape (Any sh) :: *

type FullShape (Any sh) :: *

Methods

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

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

Methods

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

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

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

Elt (Any Z)

Methods

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

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

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

type SliceShape (Any sh)

type SliceShape (Any sh) = sh

type CoSliceShape (Any sh)

type CoSliceShape (Any sh) = Z

type FullShape (Any sh)

type FullShape (Any sh) = sh

type Plain (Any sh)

type Plain (Any sh) = Any sh

Array access

Element indexing

(!) :: (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

(!!) :: (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 :: (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 :: Shape sh => Exp sh -> Exp Int

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

Construction

Introduction

use :: 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 :: Elt e => Exp e -> Acc (Scalar e)

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

Initialisation

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

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 (index1 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 (index1 10) (\ix -> unindex1 ix + 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

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

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]

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

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

Minimal complete definition

ifThenElse

Associated Types

type EltT t a :: Constraint

Methods

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

Instances

IfThenElse Exp

Associated Types

type EltT Exp a :: Constraint

Methods

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

IfThenElse Acc

Associated Types

type EltT Acc a :: Constraint

Methods

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

Controlling execution

(>->) :: (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 :: (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 :: (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 8-tuples and return eight arrays, analogous to unzip.

Modifying Arrays

Shape manipulation

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

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 :: (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 :: (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 :: forall sh e. (Slice sh, 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 :: forall sh e. (Slice sh, 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 :: forall sh e. (Slice sh, 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 :: forall sh e. (Slice sh, 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

:: (Slice sh, 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

:: (Shape sh, Shape sh', Elt a)

=> (Exp a -> Exp a -> Exp a)

combination function

-> Acc (Array sh' a)

array of default values

-> (Exp sh -> Exp sh')

index permutation function

-> Acc (Array sh a)

array of source values to be permuted

-> Acc (Array sh' a)

Generalised forward permutation operation (array scatter).

Forward permutation specified by a function mapping indices from the source array to indices in the result array. The result array is initialised with the given defaults and any further values that are permuted into the result array are added to the current value using the given combination function.

The combination function must be associative and commutative. Elements that are mapped to the magic index ignore by the permutation function are dropped.

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

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

>>> :{
  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 -> index1 (xs!ix)) ones
:}

>>> let xs = fromList (Z :. 20) [0,0,1,2,1,1,2,4,8,3,4,9,8,3,2,5,5,3,1,2] :: 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 (index2 n n) 0
            ones  = fill (index1 n)   1
        in
        permute const zeros (\(unindex1 -> i) -> index2 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.

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.

ignore :: Shape sh => Exp sh

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

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

:: (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 :: forall sh e. (Shape sh, Slice 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])

Folding

fold :: (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 (\v -> let (x,_,_,_) = unlift v :: (Exp e, Exp e, Exp e, Exp e) in x)
        . fold1 f
        . map g
        where
          f :: (Num a, Ord a) => Exp (a,a,a,a) -> Exp (a,a,a,a) -> Exp (a,a,a,a)
          f x y =
            let (mssx, misx, mcsx, tsx) = unlift x
                (mssy, misy, mcsy, tsy) = unlift y
            in
            lift ( mssx `max` (mssy `max` (mcsx+misy))
                 , misx `max` (tsx+misy)
                 , mcsy `max` (mcsx+tsy)
                 , tsx+tsy
                 )
          --
          g :: (Num a, Ord a) => Exp a -> Exp (a,a,a,a)
          g x = let y = max x 0
                in  lift (y,y,y,x)
:}

>>> let vec = fromList (Z:.10) [-2,1,-3,4,-1,2,1,-5,4,0] :: 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 :: (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 :: (Shape sh, Elt a, Elt i, IsIntegral i) => (Exp a -> Exp a -> Exp a) -> Exp a -> Acc (Array (sh :. Int) a) -> Acc (Segments i) -> Acc (Array (sh :. Int) a)

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

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

Specialised reductions

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

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

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

stencil2

Arguments

:: (Stencil sh a stencil1, Stencil sh b stencil2, Elt c)

=> (stencil1 -> stencil2 -> Exp c)

binary stencil function

-> Boundary (Array sh a)

boundary condition #1

-> Acc (Array sh a)

source array #1

-> Boundary (Array sh b)

boundary condition #2

-> Acc (Array sh b)

source array #2

-> Acc (Array sh c)

destination array

Map a binary stencil of an array. The extent of the resulting array is the intersection of the extents of the two source arrays. This is the stencil equivalent of zipWith.

Stencil specification

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

Minimal complete definition

stencilPrj

Instances

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

Associated Types

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

Methods

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

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

Associated Types

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

Methods

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

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

Associated Types

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

Methods

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

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

Associated Types

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

Methods

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

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

Associated Types

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

Methods

stencilPrj :: ((sh :. Int) :. Int) -> a -> Exp (StencilRepr ((sh :. Int) :. Int) (row2, row1, row0)) -> (row2, row1, row0)

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

Associated Types

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

Methods

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

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

Associated Types

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

Methods

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

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

Associated Types

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

Methods

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

data Boundary t

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

Associated Types

type EltT Exp a :: Constraint

Methods

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

Unlift Exp ()

Methods

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

Unlift Exp Z

Methods

unlift :: Exp (Plain Z) -> Z

Lift Exp Bool

Associated Types

type Plain Bool :: *

Methods

lift :: Bool -> Exp (Plain Bool)

Lift Exp Char

Associated Types

type Plain Char :: *

Methods

lift :: Char -> Exp (Plain Char)

Lift Exp Double

Associated Types

type Plain Double :: *

Methods

lift :: Double -> Exp (Plain Double)

Lift Exp Float

Associated Types

type Plain Float :: *

Methods

lift :: Float -> Exp (Plain Float)

Lift Exp Int

Associated Types

type Plain Int :: *

Methods

lift :: Int -> Exp (Plain Int)

Lift Exp Int8

Associated Types

type Plain Int8 :: *

Methods

lift :: Int8 -> Exp (Plain Int8)

Lift Exp Int16

Associated Types

type Plain Int16 :: *

Methods

lift :: Int16 -> Exp (Plain Int16)

Lift Exp Int32

Associated Types

type Plain Int32 :: *

Methods

lift :: Int32 -> Exp (Plain Int32)

Lift Exp Int64

Associated Types

type Plain Int64 :: *

Methods

lift :: Int64 -> Exp (Plain Int64)

Lift Exp Word

Associated Types

type Plain Word :: *

Methods

lift :: Word -> Exp (Plain Word)

Lift Exp Word8

Associated Types

type Plain Word8 :: *

Methods

lift :: Word8 -> Exp (Plain Word8)

Lift Exp Word16

Associated Types

type Plain Word16 :: *

Methods

lift :: Word16 -> Exp (Plain Word16)

Lift Exp Word32

Associated Types

type Plain Word32 :: *

Methods

lift :: Word32 -> Exp (Plain Word32)

Lift Exp Word64

Associated Types

type Plain Word64 :: *

Methods

lift :: Word64 -> Exp (Plain Word64)

Lift Exp ()

Associated Types

type Plain () :: *

Methods

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

Lift Exp CChar

Associated Types

type Plain CChar :: *

Methods

lift :: CChar -> Exp (Plain CChar)

Lift Exp CSChar

Associated Types

type Plain CSChar :: *

Methods

lift :: CSChar -> Exp (Plain CSChar)

Lift Exp CUChar

Associated Types

type Plain CUChar :: *

Methods

lift :: CUChar -> Exp (Plain CUChar)

Lift Exp CShort

Associated Types

type Plain CShort :: *

Methods

lift :: CShort -> Exp (Plain CShort)

Lift Exp CUShort

Associated Types

type Plain CUShort :: *

Methods

lift :: CUShort -> Exp (Plain CUShort)

Lift Exp CInt

Associated Types

type Plain CInt :: *

Methods

lift :: CInt -> Exp (Plain CInt)

Lift Exp CUInt

Associated Types

type Plain CUInt :: *

Methods

lift :: CUInt -> Exp (Plain CUInt)

Lift Exp CLong

Associated Types

type Plain CLong :: *

Methods

lift :: CLong -> Exp (Plain CLong)

Lift Exp CULong

Associated Types

type Plain CULong :: *

Methods

lift :: CULong -> Exp (Plain CULong)

Lift Exp CLLong

Associated Types

type Plain CLLong :: *

Methods

lift :: CLLong -> Exp (Plain CLLong)

Lift Exp CULLong

Associated Types

type Plain CULLong :: *

Methods

lift :: CULLong -> Exp (Plain CULLong)

Lift Exp CFloat

Associated Types

type Plain CFloat :: *

Methods

lift :: CFloat -> Exp (Plain CFloat)

Lift Exp CDouble

Associated Types

type Plain CDouble :: *

Methods

lift :: CDouble -> Exp (Plain CDouble)

Lift Exp Z

Associated Types

type Plain Z :: *

Methods

lift :: Z -> Exp (Plain Z)

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

Associated Types

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

Methods

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

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

Associated Types

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

Methods

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

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

Associated Types

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

Methods

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

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

Associated Types

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

Methods

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

(Elt a, Elt (Complex a)) => Unlift Exp (Complex (Exp a))

Methods

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

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

Methods

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

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

Methods

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

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

Methods

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

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

Methods

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

Unlift Exp (Exp e)

Methods

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

(Lift Exp a, Elt (Plain a)) => Lift Exp (Maybe a)

Associated Types

type Plain (Maybe a) :: *

Methods

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

(Lift Exp a, Elt (Plain a), Elt (Complex (Plain a))) => Lift Exp (Complex a)

Associated Types

type Plain (Complex a) :: *

Methods

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

(Lift Exp a, Elt (Plain a)) => Lift Exp (Min a)

Associated Types

type Plain (Min a) :: *

Methods

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

(Lift Exp a, Elt (Plain a)) => Lift Exp (Max a)

Associated Types

type Plain (Max a) :: *

Methods

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

(Lift Exp a, Elt (Plain a)) => Lift Exp (Sum a)

Associated Types

type Plain (Sum a) :: *

Methods

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

(Lift Exp a, Elt (Plain a)) => Lift Exp (Product a)

Associated Types

type Plain (Product a) :: *

Methods

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

Shape sh => Lift Exp (Any sh)

Associated Types

type Plain (Any sh) :: *

Methods

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

Lift Exp (Exp e)

Associated Types

type Plain (Exp e) :: *

Methods

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

(Elt a, Elt b) => Unlift Exp (Exp a, Exp b)

Methods

unlift :: Exp (Plain (Exp a, Exp b)) -> (Exp a, Exp b)

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

Methods

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

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

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)

Associated Types

type Plain (Either a b) :: *

Methods

lift :: Either a b -> Exp (Plain (Either a b))

(Lift Exp a, Lift Exp b, Elt (Plain a), Elt (Plain b)) => Lift Exp (a, b)

Associated Types

type Plain (a, b) :: *

Methods

lift :: (a, b) -> Exp (Plain (a, b))

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

Associated Types

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

Methods

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

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

Associated Types

type Plain (ix :. All) :: *

Methods

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

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

Associated Types

type Plain (ix :. Int) :: *

Methods

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

(Elt a, Elt b, Elt c) => Unlift Exp (Exp a, Exp b, Exp c)

Methods

unlift :: Exp (Plain (Exp a, Exp b, Exp c)) -> (Exp a, Exp b, Exp c)

(Lift Exp a, Lift Exp b, Lift Exp c, Elt (Plain a), Elt (Plain b), Elt (Plain c)) => Lift Exp (a, b, c)

Associated Types

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

Methods

lift :: (a, b, c) -> Exp (Plain (a, b, c))

(Elt a, Elt b, Elt c, Elt d) => Unlift Exp (Exp a, Exp b, Exp c, Exp d)

Methods

unlift :: Exp (Plain (Exp a, Exp b, Exp c, Exp d)) -> (Exp a, Exp b, Exp c, Exp d)

(Lift Exp a, Lift Exp b, Lift Exp c, Lift Exp d, Elt (Plain a), Elt (Plain b), Elt (Plain c), Elt (Plain d)) => Lift Exp (a, b, c, d)

Associated Types

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

Methods

lift :: (a, b, c, d) -> Exp (Plain (a, b, c, d))

(Elt a, Elt b, Elt c, Elt d, Elt e) => Unlift Exp (Exp a, Exp b, Exp c, Exp d, Exp e)

Methods

unlift :: Exp (Plain (Exp a, Exp b, Exp c, Exp d, Exp e)) -> (Exp a, Exp b, Exp c, Exp d, Exp e)

(Lift Exp a, Lift Exp b, Lift Exp c, Lift Exp d, Lift Exp e, Elt (Plain a), Elt (Plain b), Elt (Plain c), Elt (Plain d), Elt (Plain e)) => Lift Exp (a, b, c, d, e)

Associated Types

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

Methods

lift :: (a, b, c, d, e) -> Exp (Plain (a, b, c, d, e))

(Elt a, Elt b, Elt c, Elt d, Elt e, Elt f) => Unlift Exp (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f)

Methods

unlift :: Exp (Plain (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f)) -> (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f)

(Lift Exp a, Lift Exp b, Lift Exp c, Lift Exp d, Lift Exp e, Lift Exp f, Elt (Plain a), Elt (Plain b), Elt (Plain c), Elt (Plain d), Elt (Plain e), Elt (Plain f)) => Lift Exp (a, b, c, d, e, f)

Associated Types

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

Methods

lift :: (a, b, c, d, e, f) -> Exp (Plain (a, b, c, d, e, f))

(Elt a, Elt b, Elt c, Elt d, Elt e, Elt f, Elt g) => Unlift Exp (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f, Exp g)

Methods

unlift :: Exp (Plain (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f, Exp g)) -> (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f, Exp g)

(Lift Exp a, Lift Exp b, Lift Exp c, Lift Exp d, Lift Exp e, Lift Exp f, Lift Exp g, Elt (Plain a), Elt (Plain b), Elt (Plain c), Elt (Plain d), Elt (Plain e), Elt (Plain f), Elt (Plain g)) => Lift Exp (a, b, c, d, e, f, g)

Associated Types

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

Methods

lift :: (a, b, c, d, e, f, g) -> Exp (Plain (a, b, c, d, e, f, g))

(Elt a, Elt b, Elt c, Elt d, Elt e, Elt f, Elt g, Elt h) => Unlift Exp (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f, Exp g, Exp h)

Methods

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

(Lift Exp a, Lift Exp b, Lift Exp c, Lift Exp d, Lift Exp e, Lift Exp f, Lift Exp g, Lift Exp h, Elt (Plain a), Elt (Plain b), Elt (Plain c), Elt (Plain d), Elt (Plain e), Elt (Plain f), Elt (Plain g), Elt (Plain h)) => Lift Exp (a, b, c, d, e, f, g, h)

Associated Types

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

Methods

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

(Elt a, Elt b, Elt c, Elt d, Elt e, Elt f, Elt g, Elt h, Elt i) => Unlift Exp (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f, Exp g, Exp h, Exp i)

Methods

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

(Lift Exp a, Lift Exp b, Lift Exp c, Lift Exp d, Lift Exp e, Lift Exp f, Lift Exp g, Lift Exp h, Lift Exp i, Elt (Plain a), Elt (Plain b), Elt (Plain c), Elt (Plain d), Elt (Plain e), Elt (Plain f), Elt (Plain g), Elt (Plain h), Elt (Plain i)) => Lift Exp (a, b, c, d, e, f, g, h, i)

Associated Types

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

Methods

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

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

Methods

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

(Lift Exp a, Lift Exp b, Lift Exp c, Lift Exp d, Lift Exp e, Lift Exp f, Lift Exp g, Lift Exp h, Lift Exp i, Lift Exp j, Elt (Plain a), Elt (Plain b), Elt (Plain c), Elt (Plain d), Elt (Plain e), Elt (Plain f), Elt (Plain g), Elt (Plain h), Elt (Plain i), Elt (Plain j)) => Lift Exp (a, b, c, d, e, f, g, h, i, j)

Associated Types

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

Methods

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

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

Methods

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

(Lift Exp a, Lift Exp b, Lift Exp c, Lift Exp d, Lift Exp e, Lift Exp f, Lift Exp g, Lift Exp h, Lift Exp i, Lift Exp j, Lift Exp k, Elt (Plain a), Elt (Plain b), Elt (Plain c), Elt (Plain d), Elt (Plain e), Elt (Plain f), Elt (Plain g), Elt (Plain h), Elt (Plain i), Elt (Plain j), Elt (Plain k)) => Lift Exp (a, b, c, d, e, f, g, h, i, j, k)

Associated Types

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

Methods

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

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

Methods

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

(Lift Exp a, Lift Exp b, Lift Exp c, Lift Exp d, Lift Exp e, Lift Exp f, Lift Exp g, Lift Exp h, Lift Exp i, Lift Exp j, Lift Exp k, Lift Exp l, Elt (Plain a), Elt (Plain b), Elt (Plain c), Elt (Plain d), Elt (Plain e), Elt (Plain f), Elt (Plain g), Elt (Plain h), Elt (Plain i), Elt (Plain j), Elt (Plain k), Elt (Plain l)) => Lift Exp (a, b, c, d, e, f, g, h, i, j, k, l)

Associated Types

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

Methods

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

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

Methods

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

(Lift Exp a, Lift Exp b, Lift Exp c, Lift Exp d, Lift Exp e, Lift Exp f, Lift Exp g, Lift Exp h, Lift Exp i, Lift Exp j, Lift Exp k, Lift Exp l, Lift Exp m, Elt (Plain a), Elt (Plain b), Elt (Plain c), Elt (Plain d), Elt (Plain e), Elt (Plain f), Elt (Plain g), Elt (Plain h), Elt (Plain i), Elt (Plain j), Elt (Plain k), Elt (Plain l), Elt (Plain m)) => Lift Exp (a, b, c, d, e, f, g, h, i, j, k, l, m)

Associated Types

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

Methods

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

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

Methods

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

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

Associated Types

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

Methods

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

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

Methods

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

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

Associated Types

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

Methods

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

Bounded (Exp Bool)

Methods

minBound :: Exp Bool

maxBound :: Exp Bool

Bounded (Exp Char)

Methods

minBound :: Exp Char

maxBound :: Exp Char

Bounded (Exp Int)

Methods

minBound :: Exp Int

maxBound :: Exp Int

Bounded (Exp Int8)

Methods

minBound :: Exp Int8

maxBound :: Exp Int8

Bounded (Exp Int16)

Methods

minBound :: Exp Int16

maxBound :: Exp Int16

Bounded (Exp Int32)

Methods

minBound :: Exp Int32

maxBound :: Exp Int32

Bounded (Exp Int64)

Methods

minBound :: Exp Int64

maxBound :: Exp Int64

Bounded (Exp Word)

Methods

minBound :: Exp Word

maxBound :: Exp Word

Bounded (Exp Word8)

Methods

minBound :: Exp Word8

maxBound :: Exp Word8

Bounded (Exp Word16)

Methods

minBound :: Exp Word16

maxBound :: Exp Word16

Bounded (Exp Word32)

Methods

minBound :: Exp Word32

maxBound :: Exp Word32

Bounded (Exp Word64)

Methods

minBound :: Exp Word64

maxBound :: Exp Word64

Bounded (Exp ())

Methods

minBound :: Exp ()

maxBound :: Exp ()

(Bounded a, Bounded b) => Bounded (Exp (a, b))

Methods

minBound :: Exp (a, b)

maxBound :: Exp (a, b)

(Bounded a, Bounded b, Bounded c) => Bounded (Exp (a, b, c))

Methods

minBound :: Exp (a, b, c)

maxBound :: Exp (a, b, c)

(Bounded a, Bounded b, Bounded c, Bounded d) => Bounded (Exp (a, b, c, d))

Methods

minBound :: Exp (a, b, c, d)

maxBound :: Exp (a, b, c, d)

(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e) => Bounded (Exp (a, b, c, d, e))

Methods

minBound :: Exp (a, b, c, d, e)

maxBound :: Exp (a, b, c, d, e)

(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f) => Bounded (Exp (a, b, c, d, e, f))

Methods

minBound :: Exp (a, b, c, d, e, f)

maxBound :: Exp (a, b, c, d, e, f)

(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g) => Bounded (Exp (a, b, c, d, e, f, g))

Methods

minBound :: Exp (a, b, c, d, e, f, g)

maxBound :: Exp (a, b, c, d, e, f, g)

(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h) => Bounded (Exp (a, b, c, d, e, f, g, h))

Methods

minBound :: Exp (a, b, c, d, e, f, g, h)

maxBound :: Exp (a, b, c, d, e, f, g, h)

(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i) => Bounded (Exp (a, b, c, d, e, f, g, h, i))

Methods

minBound :: Exp (a, b, c, d, e, f, g, h, i)

maxBound :: Exp (a, b, c, d, e, f, g, h, i)

(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j) => Bounded (Exp (a, b, c, d, e, f, g, h, i, j))

Methods

minBound :: Exp (a, b, c, d, e, f, g, h, i, j)

maxBound :: Exp (a, b, c, d, e, f, g, h, i, j)

(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k) => Bounded (Exp (a, b, c, d, e, f, g, h, i, j, k))

Methods

minBound :: Exp (a, b, c, d, e, f, g, h, i, j, k)

maxBound :: Exp (a, b, c, d, e, f, g, h, i, j, k)

(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k, Bounded l) => Bounded (Exp (a, b, c, d, e, f, g, h, i, j, k, l))

Methods

minBound :: Exp (a, b, c, d, e, f, g, h, i, j, k, l)

maxBound :: Exp (a, b, c, d, e, f, g, h, i, j, k, l)

(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k, Bounded l, Bounded m) => Bounded (Exp (a, b, c, d, e, f, g, h, i, j, k, l, m))

Methods

minBound :: Exp (a, b, c, d, e, f, g, h, i, j, k, l, m)

maxBound :: Exp (a, b, c, d, e, f, g, h, i, j, k, l, m)

(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k, Bounded l, Bounded m, Bounded n) => Bounded (Exp (a, b, c, d, e, f, g, h, i, j, k, l, m, n))

Methods

minBound :: Exp (a, b, c, d, e, f, g, h, i, j, k, l, m, n)

maxBound :: Exp (a, b, c, d, e, f, g, h, i, j, k, l, m, n)

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

Methods

minBound :: Exp (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)

maxBound :: Exp (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)

(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k, Bounded l, Bounded m, Bounded n, Bounded o, Bounded p) => Bounded (Exp (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p))

Methods

minBound :: Exp (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p)

maxBound :: Exp (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p)

Bounded a => Bounded (Exp (Min a))

Methods

minBound :: Exp (Min a)

maxBound :: Exp (Min a)

Bounded a => Bounded (Exp (Max a))

Methods

minBound :: Exp (Max a)

maxBound :: Exp (Max a)

Bounded a => Bounded (Exp (Sum a))

Methods

minBound :: Exp (Sum a)

maxBound :: Exp (Sum a)

Bounded a => Bounded (Exp (Product a))

Methods

minBound :: Exp (Product a)

maxBound :: Exp (Product a)

Bounded (Exp CChar)

Methods

minBound :: Exp CChar

maxBound :: Exp CChar

Bounded (Exp CSChar)

Methods

minBound :: Exp CSChar

maxBound :: Exp CSChar

Bounded (Exp CUChar)

Methods

minBound :: Exp CUChar

maxBound :: Exp CUChar

Bounded (Exp CShort)

Methods

minBound :: Exp CShort

maxBound :: Exp CShort

Bounded (Exp CUShort)

Methods

minBound :: Exp CUShort

maxBound :: Exp CUShort

Bounded (Exp CInt)

Methods

minBound :: Exp CInt

maxBound :: Exp CInt

Bounded (Exp CUInt)

Methods

minBound :: Exp CUInt

maxBound :: Exp CUInt

Bounded (Exp CLong)

Methods

minBound :: Exp CLong

maxBound :: Exp CLong

Bounded (Exp CULong)

Methods

minBound :: Exp CULong

maxBound :: Exp CULong

Bounded (Exp CLLong)

Methods

minBound :: Exp CLLong

maxBound :: Exp CLLong

Bounded (Exp CULLong)

Methods

minBound :: Exp CULLong

maxBound :: Exp CULLong

Enum (Exp Double)

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)

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)

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)

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)

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)

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)

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]

Enum (Exp Word)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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 a => Eq (Exp a)

Methods

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

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

Floating (Exp Double)

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)

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, Elt (Complex a)) => Floating (Exp (Complex a))

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)

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)

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)

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)

Methods

(/) :: Exp Double -> Exp Double -> Exp Double

recip :: Exp Double -> Exp Double

fromRational :: Rational -> Exp Double

Fractional (Exp Float)

Methods

(/) :: Exp Float -> Exp Float -> Exp Float

recip :: Exp Float -> Exp Float

fromRational :: Rational -> Exp Float

(RealFloat a, Elt (Complex a)) => Fractional (Exp (Complex a))

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)

Methods

(/) :: Exp CFloat -> Exp CFloat -> Exp CFloat

recip :: Exp CFloat -> Exp CFloat

fromRational :: Rational -> Exp CFloat

Fractional (Exp CDouble)

Methods

(/) :: Exp CDouble -> Exp CDouble -> Exp CDouble

recip :: Exp CDouble -> Exp CDouble

fromRational :: Rational -> Exp CDouble

Fractional (Exp Half)

Methods

(/) :: Exp Half -> Exp Half -> Exp Half

recip :: Exp Half -> Exp Half

fromRational :: Rational -> Exp Half

Integral (Exp Int)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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

Num (Exp Word)

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)

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)

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)

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)

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, Elt (Complex a)) => Num (Exp (Complex a))

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

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

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

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

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

Methods

toRational :: Exp a -> Rational

RealFloat a => RealFloat (Exp a)

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)

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)

Methods

showsPrec :: Int -> Exp e -> ShowS

show :: Exp e -> String

showList :: [Exp e] -> ShowS

(Semigroup (Exp a), Elt a) => Semigroup (Exp (Maybe a))

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

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

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

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

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

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

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

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

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

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

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

Methods

mempty :: Exp (Maybe a)

mappend :: Exp (Maybe a) -> Exp (Maybe a) -> Exp (Maybe a)

mconcat :: [Exp (Maybe a)] -> Exp (Maybe a)

Monoid (Exp ())

Methods

mempty :: Exp ()

mappend :: Exp () -> Exp () -> Exp ()

mconcat :: [Exp ()] -> Exp ()

(Elt a, Elt b, Monoid (Exp a), Monoid (Exp b)) => Monoid (Exp (a, b))

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

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

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

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

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

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

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

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

Methods

pi :: Fold a (Exp b)

exp :: Fold a (Exp b) -> Fold a (Exp b)

log :: Fold a (Exp b) -> Fold a (Exp b)

sqrt :: Fold a (Exp b) -> Fold a (Exp b)

(**) :: Fold a (Exp b) -> Fold a (Exp b) -> Fold a (Exp b)

logBase :: Fold a (Exp b) -> Fold a (Exp b) -> Fold a (Exp b)

sin :: Fold a (Exp b) -> Fold a (Exp b)

cos :: Fold a (Exp b) -> Fold a (Exp b)

tan :: Fold a (Exp b) -> Fold a (Exp b)

asin :: Fold a (Exp b) -> Fold a (Exp b)

acos :: Fold a (Exp b) -> Fold a (Exp b)

atan :: Fold a (Exp b) -> Fold a (Exp b)

sinh :: Fold a (Exp b) -> Fold a (Exp b)

cosh :: Fold a (Exp b) -> Fold a (Exp b)

tanh :: Fold a (Exp b) -> Fold a (Exp b)

asinh :: Fold a (Exp b) -> Fold a (Exp b)

acosh :: Fold a (Exp b) -> Fold a (Exp b)

atanh :: Fold a (Exp b) -> Fold a (Exp b)

log1p :: Fold a (Exp b) -> Fold a (Exp b)

expm1 :: Fold a (Exp b) -> Fold a (Exp b)

log1pexp :: Fold a (Exp b) -> Fold a (Exp b)

log1mexp :: Fold a (Exp b) -> Fold a (Exp b)

Fractional b => Fractional (Fold a (Exp b))

Methods

(/) :: Fold a (Exp b) -> Fold a (Exp b) -> Fold a (Exp b)

recip :: Fold a (Exp b) -> Fold a (Exp b)

fromRational :: Rational -> Fold a (Exp b)

Num b => Num (Fold a (Exp b))

Methods

(+) :: Fold a (Exp b) -> Fold a (Exp b) -> Fold a (Exp b)

(-) :: Fold a (Exp b) -> Fold a (Exp b) -> Fold a (Exp b)

(*) :: Fold a (Exp b) -> Fold a (Exp b) -> Fold a (Exp b)

negate :: Fold a (Exp b) -> Fold a (Exp b)

abs :: Fold a (Exp b) -> Fold a (Exp b)

signum :: Fold a (Exp b) -> Fold a (Exp b)

fromInteger :: Integer -> Fold a (Exp b)

Function (Exp a -> f) => Show (Exp a -> f)

Methods

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

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

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

type EltT Exp t

type EltT Exp t = Elt t

type Plain (Exp e)

type Plain (Exp e) = e

type Plain (ix :. Exp e)

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

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

Methods

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

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

Eq Char

Methods

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

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

Eq Double

Methods

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

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

Eq Float

Methods

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

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

Eq Int

Methods

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

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

Eq Int8

Methods

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

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

Eq Int16

Methods

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

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

Eq Int32

Methods

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

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

Eq Int64

Methods

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

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

Eq Ordering

Methods

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

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

Eq Word

Methods

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

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

Eq Word8

Methods

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

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

Eq Word16

Methods

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

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

Eq Word32

Methods

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

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

Eq Word64

Methods

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

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

Eq ()

Methods

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

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

Eq CChar

Methods

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

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

Eq CSChar

Methods

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

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

Eq CUChar

Methods

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

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

Eq CShort

Methods

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

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

Eq CUShort

Methods

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

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

Eq CInt

Methods

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

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

Eq CUInt

Methods

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

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

Eq CLong

Methods

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

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

Eq CULong

Methods

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

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

Eq CLLong

Methods

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

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

Eq CULLong

Methods

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

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

Eq CFloat

Methods

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

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

Eq CDouble

Methods

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

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

Eq Half

Methods

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

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

Eq a => Eq (Maybe a)

Methods

(==) :: Exp (Maybe a) -> Exp (Maybe a) -> Exp Bool

(/=) :: Exp (Maybe a) -> Exp (Maybe a) -> Exp Bool

(Eq a, Elt (Complex a)) => Eq (Complex a)

Methods

(==) :: Exp (Complex a) -> Exp (Complex a) -> Exp Bool

(/=) :: Exp (Complex a) -> Exp (Complex a) -> Exp Bool

Eq a => Eq (Min a)

Methods

(==) :: Exp (Min a) -> Exp (Min a) -> Exp Bool

(/=) :: Exp (Min a) -> Exp (Min a) -> Exp Bool

Eq a => Eq (Max a)

Methods

(==) :: Exp (Max a) -> Exp (Max a) -> Exp Bool

(/=) :: Exp (Max a) -> Exp (Max a) -> Exp Bool

Eq a => Eq (Sum a)

Methods

(==) :: Exp (Sum a) -> Exp (Sum a) -> Exp Bool

(/=) :: Exp (Sum a) -> Exp (Sum a) -> Exp Bool

Eq a => Eq (Product a)

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)

Methods

(==) :: Exp (Either a b) -> Exp (Either a b) -> Exp Bool

(/=) :: Exp (Either a b) -> Exp (Either a b) -> Exp Bool

(Eq a, Eq b) => Eq (a, b)

Methods

(==) :: Exp (a, b) -> Exp (a, b) -> Exp Bool

(/=) :: Exp (a, b) -> Exp (a, b) -> Exp Bool

(Eq a, Eq b, Eq c) => Eq (a, b, c)

Methods

(==) :: Exp (a, b, c) -> Exp (a, b, c) -> Exp Bool

(/=) :: Exp (a, b, c) -> Exp (a, b, c) -> Exp Bool

(Eq a, Eq b, Eq c, Eq d) => Eq (a, b, c, d)

Methods

(==) :: Exp (a, b, c, d) -> Exp (a, b, c, d) -> Exp Bool

(/=) :: Exp (a, b, c, d) -> Exp (a, b, c, d) -> Exp Bool

(Eq a, Eq b, Eq c, Eq d, Eq e) => Eq (a, b, c, d, e)

Methods

(==) :: Exp (a, b, c, d, e) -> Exp (a, b, c, d, e) -> Exp Bool

(/=) :: Exp (a, b, c, d, e) -> Exp (a, b, c, d, e) -> Exp Bool

(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f) => Eq (a, b, c, d, e, f)

Methods

(==) :: Exp (a, b, c, d, e, f) -> Exp (a, b, c, d, e, f) -> Exp Bool

(/=) :: Exp (a, b, c, d, e, f) -> Exp (a, b, c, d, e, f) -> Exp Bool

(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g) => Eq (a, b, c, d, e, f, g)

Methods

(==) :: Exp (a, b, c, d, e, f, g) -> Exp (a, b, c, d, e, f, g) -> Exp Bool

(/=) :: Exp (a, b, c, d, e, f, g) -> Exp (a, b, c, d, e, f, g) -> Exp Bool

(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h) => Eq (a, b, c, d, e, f, g, h)

Methods

(==) :: Exp (a, b, c, d, e, f, g, h) -> Exp (a, b, c, d, e, f, g, h) -> Exp Bool

(/=) :: Exp (a, b, c, d, e, f, g, h) -> Exp (a, b, c, d, e, f, g, h) -> Exp Bool

(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i) => Eq (a, b, c, d, e, f, g, h, i)

Methods

(==) :: Exp (a, b, c, d, e, f, g, h, i) -> Exp (a, b, c, d, e, f, g, h, i) -> Exp Bool

(/=) :: Exp (a, b, c, d, e, f, g, h, i) -> Exp (a, b, c, d, e, f, g, h, i) -> Exp Bool

(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j) => Eq (a, b, c, d, e, f, g, h, i, j)

Methods

(==) :: Exp (a, b, c, d, e, f, g, h, i, j) -> Exp (a, b, c, d, e, f, g, h, i, j) -> Exp Bool

(/=) :: Exp (a, b, c, d, e, f, g, h, i, j) -> Exp (a, b, c, d, e, f, g, h, i, j) -> Exp Bool

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

Methods

(==) :: Exp (a, b, c, d, e, f, g, h, i, j, k) -> Exp (a, b, c, d, e, f, g, h, i, j, k) -> Exp Bool

(/=) :: Exp (a, b, c, d, e, f, g, h, i, j, k) -> Exp (a, b, c, d, e, f, g, h, i, j, k) -> Exp Bool

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

Methods

(==) :: Exp (a, b, c, d, e, f, g, h, i, j, k, l) -> Exp (a, b, c, d, e, f, g, h, i, j, k, l) -> Exp Bool

(/=) :: Exp (a, b, c, d, e, f, g, h, i, j, k, l) -> Exp (a, b, c, d, e, f, g, h, i, j, k, l) -> Exp Bool

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

Methods

(==) :: Exp (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Exp (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Exp Bool

(/=) :: Exp (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Exp (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Exp Bool

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

Methods

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

(/=) :: Exp (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Exp (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Exp Bool

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

Methods

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

(/=) :: Exp (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Exp (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Exp Bool

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

Methods

(==) :: Exp (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) -> Exp (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) -> Exp Bool

(/=) :: Exp (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) -> Exp (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) -> 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 Bool

Methods

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

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

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

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

min :: Exp Bool -> Exp Bool -> Exp Bool

max :: Exp Bool -> Exp Bool -> Exp Bool

compare :: Exp Bool -> Exp Bool -> Exp Ordering

Ord Char

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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 a => Ord (Maybe a)

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

Ord a => Ord (Min a)

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)

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)

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)

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)

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 a, Ord b) => Ord (a, b)

Methods

(<) :: Exp (a, b) -> Exp (a, b) -> Exp Bool

(>) :: Exp (a, b) -> Exp (a, b) -> Exp Bool

(<=) :: Exp (a, b) -> Exp (a, b) -> Exp Bool

(>=) :: Exp (a, b) -> Exp (a, b) -> Exp Bool

min :: Exp (a, b) -> Exp (a, b) -> Exp (a, b)

max :: Exp (a, b) -> Exp (a, b) -> Exp (a, b)

compare :: Exp (a, b) -> Exp (a, b) -> Exp Ordering

(Ord a, Ord b, Ord c) => Ord (a, b, c)

Methods

(<) :: Exp (a, b, c) -> Exp (a, b, c) -> Exp Bool

(>) :: Exp (a, b, c) -> Exp (a, b, c) -> Exp Bool

(<=) :: Exp (a, b, c) -> Exp (a, b, c) -> Exp Bool

(>=) :: Exp (a, b, c) -> Exp (a, b, c) -> Exp Bool

min :: Exp (a, b, c) -> Exp (a, b, c) -> Exp (a, b, c)

max :: Exp (a, b, c) -> Exp (a, b, c) -> Exp (a, b, c)

compare :: Exp (a, b, c) -> Exp (a, b, c) -> Exp Ordering

(Ord a, Ord b, Ord c, Ord d) => Ord (a, b, c, d)

Methods

(<) :: Exp (a, b, c, d) -> Exp (a, b, c, d) -> Exp Bool

(>) :: Exp (a, b, c, d) -> Exp (a, b, c, d) -> Exp Bool

(<=) :: Exp (a, b, c, d) -> Exp (a, b, c, d) -> Exp Bool

(>=) :: Exp (a, b, c, d) -> Exp (a, b, c, d) -> Exp Bool

min :: Exp (a, b, c, d) -> Exp (a, b, c, d) -> Exp (a, b, c, d)

max :: Exp (a, b, c, d) -> Exp (a, b, c, d) -> Exp (a, b, c, d)

compare :: Exp (a, b, c, d) -> Exp (a, b, c, d) -> Exp Ordering

(Ord a, Ord b, Ord c, Ord d, Ord e) => Ord (a, b, c, d, e)

Methods

(<) :: Exp (a, b, c, d, e) -> Exp (a, b, c, d, e) -> Exp Bool

(>) :: Exp (a, b, c, d, e) -> Exp (a, b, c, d, e) -> Exp Bool

(<=) :: Exp (a, b, c, d, e) -> Exp (a, b, c, d, e) -> Exp Bool

(>=) :: Exp (a, b, c, d, e) -> Exp (a, b, c, d, e) -> Exp Bool

min :: Exp (a, b, c, d, e) -> Exp (a, b, c, d, e) -> Exp (a, b, c, d, e)

max :: Exp (a, b, c, d, e) -> Exp (a, b, c, d, e) -> Exp (a, b, c, d, e)

compare :: Exp (a, b, c, d, e) -> Exp (a, b, c, d, e) -> Exp Ordering

(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f) => Ord (a, b, c, d, e, f)

Methods

(<) :: Exp (a, b, c, d, e, f) -> Exp (a, b, c, d, e, f) -> Exp Bool

(>) :: Exp (a, b, c, d, e, f) -> Exp (a, b, c, d, e, f) -> Exp Bool

(<=) :: Exp (a, b, c, d, e, f) -> Exp (a, b, c, d, e, f) -> Exp Bool

(>=) :: Exp (a, b, c, d, e, f) -> Exp (a, b, c, d, e, f) -> Exp Bool

min :: Exp (a, b, c, d, e, f) -> Exp (a, b, c, d, e, f) -> Exp (a, b, c, d, e, f)

max :: Exp (a, b, c, d, e, f) -> Exp (a, b, c, d, e, f) -> Exp (a, b, c, d, e, f)

compare :: Exp (a, b, c, d, e, f) -> Exp (a, b, c, d, e, f) -> Exp Ordering

(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g) => Ord (a, b, c, d, e, f, g)

Methods

(<) :: Exp (a, b, c, d, e, f, g) -> Exp (a, b, c, d, e, f, g) -> Exp Bool

(>) :: Exp (a, b, c, d, e, f, g) -> Exp (a, b, c, d, e, f, g) -> Exp Bool

(<=) :: Exp (a, b, c, d, e, f, g) -> Exp (a, b, c, d, e, f, g) -> Exp Bool

(>=) :: Exp (a, b, c, d, e, f, g) -> Exp (a, b, c, d, e, f, g) -> Exp Bool

min :: Exp (a, b, c, d, e, f, g) -> Exp (a, b, c, d, e, f, g) -> Exp (a, b, c, d, e, f, g)

max :: Exp (a, b, c, d, e, f, g) -> Exp (a, b, c, d, e, f, g) -> Exp (a, b, c, d, e, f, g)

compare :: Exp (a, b, c, d, e, f, g) -> Exp (a, b, c, d, e, f, g) -> Exp Ordering

(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h) => Ord (a, b, c, d, e, f, g, h)

Methods

(<) :: Exp (a, b, c, d, e, f, g, h) -> Exp (a, b, c, d, e, f, g, h) -> Exp Bool

(>) :: Exp (a, b, c, d, e, f, g, h) -> Exp (a, b, c, d, e, f, g, h) -> Exp Bool

(<=) :: Exp (a, b, c, d, e, f, g, h) -> Exp (a, b, c, d, e, f, g, h) -> Exp Bool

(>=) :: Exp (a, b, c, d, e, f, g, h) -> Exp (a, b, c, d, e, f, g, h) -> Exp Bool

min :: Exp (a, b, c, d, e, f, g, h) -> Exp (a, b, c, d, e, f, g, h) -> Exp (a, b, c, d, e, f, g, h)

max :: Exp (a, b, c, d, e, f, g, h) -> Exp (a, b, c, d, e, f, g, h) -> Exp (a, b, c, d, e, f, g, h)

compare :: Exp (a, b, c, d, e, f, g, h) -> Exp (a, b, c, d, e, f, g, h) -> Exp Ordering

(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i) => Ord (a, b, c, d, e, f, g, h, i)

Methods

(<) :: Exp (a, b, c, d, e, f, g, h, i) -> Exp (a, b, c, d, e, f, g, h, i) -> Exp Bool

(>) :: Exp (a, b, c, d, e, f, g, h, i) -> Exp (a, b, c, d, e, f, g, h, i) -> Exp Bool

(<=) :: Exp (a, b, c, d, e, f, g, h, i) -> Exp (a, b, c, d, e, f, g, h, i) -> Exp Bool

(>=) :: Exp (a, b, c, d, e, f, g, h, i) -> Exp (a, b, c, d, e, f, g, h, i) -> Exp Bool

min :: Exp (a, b, c, d, e, f, g, h, i) -> Exp (a, b, c, d, e, f, g, h, i) -> Exp (a, b, c, d, e, f, g, h, i)

max :: Exp (a, b, c, d, e, f, g, h, i) -> Exp (a, b, c, d, e, f, g, h, i) -> Exp (a, b, c, d, e, f, g, h, i)

compare :: Exp (a, b, c, d, e, f, g, h, i) -> Exp (a, b, c, d, e, f, g, h, i) -> Exp Ordering

(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j) => Ord (a, b, c, d, e, f, g, h, i, j)

Methods

(<) :: Exp (a, b, c, d, e, f, g, h, i, j) -> Exp (a, b, c, d, e, f, g, h, i, j) -> Exp Bool

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

(<=) :: Exp (a, b, c, d, e, f, g, h, i, j) -> Exp (a, b, c, d, e, f, g, h, i, j) -> Exp Bool

(>=) :: Exp (a, b, c, d, e, f, g, h, i, j) -> Exp (a, b, c, d, e, f, g, h, i, j) -> Exp Bool

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

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

compare :: Exp (a, b, c, d, e, f, g, h, i, j) -> Exp (a, b, c, d, e, f, g, h, i, j) -> Exp Ordering

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

Methods

(<) :: Exp (a, b, c, d, e, f, g, h, i, j, k) -> Exp (a, b, c, d, e, f, g, h, i, j, k) -> Exp Bool

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

(<=) :: Exp (a, b, c, d, e, f, g, h, i, j, k) -> Exp (a, b, c, d, e, f, g, h, i, j, k) -> Exp Bool

(>=) :: Exp (a, b, c, d, e, f, g, h, i, j, k) -> Exp (a, b, c, d, e, f, g, h, i, j, k) -> Exp Bool

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

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

compare :: Exp (a, b, c, d, e, f, g, h, i, j, k) -> Exp (a, b, c, d, e, f, g, h, i, j, k) -> Exp Ordering

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

Methods

(<) :: Exp (a, b, c, d, e, f, g, h, i, j, k, l) -> Exp (a, b, c, d, e, f, g, h, i, j, k, l) -> Exp Bool

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

(<=) :: Exp (a, b, c, d, e, f, g, h, i, j, k, l) -> Exp (a, b, c, d, e, f, g, h, i, j, k, l) -> Exp Bool

(>=) :: Exp (a, b, c, d, e, f, g, h, i, j, k, l) -> Exp (a, b, c, d, e, f, g, h, i, j, k, l) -> Exp Bool

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

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

compare :: Exp (a, b, c, d, e, f, g, h, i, j, k, l) -> Exp (a, b, c, d, e, f, g, h, i, j, k, l) -> Exp Ordering

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

Methods

(<) :: Exp (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Exp (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Exp Bool

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

(<=) :: Exp (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Exp (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Exp Bool

(>=) :: Exp (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Exp (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Exp Bool

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

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

compare :: Exp (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Exp (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Exp Ordering

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

Methods

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

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

(<=) :: Exp (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Exp (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Exp Bool

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

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

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

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

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

Methods

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

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

(<=) :: Exp (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Exp (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Exp Bool

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

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

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

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

data Ordering

Constructors

LT

EQ

GT

Instances

Bounded Ordering

Since: 2.1

Methods

minBound :: Ordering

maxBound :: Ordering

Enum Ordering

Since: 2.1

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

Methods

(==) :: Ordering -> Ordering -> Bool

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

Ord Ordering

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: 2.1

Methods

readsPrec :: Int -> ReadS Ordering

readList :: ReadS [Ordering]

readPrec :: ReadPrec Ordering

readListPrec :: ReadPrec [Ordering]

Show Ordering

Methods

showsPrec :: Int -> Ordering -> ShowS

show :: Ordering -> String

showList :: [Ordering] -> ShowS

Generic Ordering

Associated Types

type Rep Ordering :: * -> *

Methods

from :: Ordering -> Rep Ordering x

to :: Rep Ordering x -> Ordering

Semigroup Ordering

Since: 4.9.0.0

Methods

(<>) :: Ordering -> Ordering -> Ordering

sconcat :: NonEmpty Ordering -> Ordering

stimes :: Integral b => b -> Ordering -> Ordering

Monoid Ordering

Since: 2.1

Methods

mempty :: Ordering

mappend :: Ordering -> Ordering -> Ordering

mconcat :: [Ordering] -> Ordering

NFData Ordering

Methods

rnf :: Ordering -> ()

Hashable Ordering

Methods

hashWithSalt :: Int -> Ordering -> Int

hash :: Ordering -> Int

AsEmpty Ordering

Methods

_Empty :: Prism' Ordering ()

Elt Ordering

Methods

eltType :: Ordering -> TupleType (EltRepr Ordering)

fromElt :: Ordering -> EltRepr Ordering

toElt :: EltRepr Ordering -> Ordering

Eq Ordering

Methods

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

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

Ord Ordering

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

() :=> (Bounded Ordering)

Methods

ins :: () :- Bounded Ordering

() :=> (Enum Ordering)

Methods

ins :: () :- Enum Ordering

() :=> (Read Ordering)

Methods

ins :: () :- Read Ordering

() :=> (Show Ordering)

Methods

ins :: () :- Show Ordering

() :=> (Semigroup Ordering)

Methods

ins :: () :- Semigroup Ordering

() :=> (Monoid Ordering)

Methods

ins :: () :- Monoid Ordering

type Rep Ordering

type Rep Ordering = D1 (MetaData "Ordering" "GHC.Types" "ghc-prim" False) (C1 (MetaCons "LT" PrefixI False) (U1 :: * -> *) :+: (C1 (MetaCons "EQ" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "GT" PrefixI False) (U1 :: * -> *)))

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

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

type Integral a = (Enum a, Real 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

type Fractional a = (Num a, Fractional (Exp a))

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

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 (Real a, Fractional a) => RealFrac a where

Extracting components of fractions.

Minimal complete definition

properFraction, truncate, round, ceiling, floor

Methods

properFraction :: (Num b, ToFloating b a, IsIntegral b) => Exp a -> (Exp b, Exp a)

truncate :: (Elt b, IsIntegral b) => Exp a -> Exp b

truncate x returns the integer nearest x between zero and x

round :: (Elt b, IsIntegral b) => Exp a -> Exp b

round x returns the nearest integer to x; the even integer if x is equidistant between two integers

ceiling :: (Elt b, IsIntegral b) => Exp a -> Exp b

ceiling x returns the least integer not less than x

floor :: (Elt b, IsIntegral b) => Exp a -> Exp b

floor x returns the greatest integer not greater than x

Instances

RealFrac Double

Methods

properFraction :: (Num b, ToFloating b Double, IsIntegral b) => Exp Double -> (Exp b, Exp Double)

truncate :: (Elt b, IsIntegral b) => Exp Double -> Exp b

round :: (Elt b, IsIntegral b) => Exp Double -> Exp b

ceiling :: (Elt b, IsIntegral b) => Exp Double -> Exp b

floor :: (Elt b, IsIntegral b) => Exp Double -> Exp b

RealFrac Float

Methods

properFraction :: (Num b, ToFloating b Float, IsIntegral b) => Exp Float -> (Exp b, Exp Float)

truncate :: (Elt b, IsIntegral b) => Exp Float -> Exp b

round :: (Elt b, IsIntegral b) => Exp Float -> Exp b

ceiling :: (Elt b, IsIntegral b) => Exp Float -> Exp b

floor :: (Elt b, IsIntegral b) => Exp Float -> Exp b

RealFrac CFloat

Methods

properFraction :: (Num b, ToFloating b CFloat, IsIntegral b) => Exp CFloat -> (Exp b, Exp CFloat)

truncate :: (Elt b, IsIntegral b) => Exp CFloat -> Exp b

round :: (Elt b, IsIntegral b) => Exp CFloat -> Exp b

ceiling :: (Elt b, IsIntegral b) => Exp CFloat -> Exp b

floor :: (Elt b, IsIntegral b) => Exp CFloat -> Exp b

RealFrac CDouble

Methods

properFraction :: (Num b, ToFloating b CDouble, IsIntegral b) => Exp CDouble -> (Exp b, Exp CDouble)

truncate :: (Elt b, IsIntegral b) => Exp CDouble -> Exp b

round :: (Elt b, IsIntegral b) => Exp CDouble -> Exp b

ceiling :: (Elt b, IsIntegral b) => Exp CDouble -> Exp b

floor :: (Elt b, IsIntegral b) => Exp CDouble -> Exp b

RealFrac Half

Methods

properFraction :: (Num b, ToFloating b Half, IsIntegral b) => Exp Half -> (Exp b, Exp Half)

truncate :: (Elt b, IsIntegral b) => Exp Half -> Exp b

round :: (Elt b, IsIntegral b) => Exp Half -> Exp b

ceiling :: (Elt b, IsIntegral b) => Exp Half -> Exp b

floor :: (Elt b, IsIntegral b) => Exp Half -> Exp b

div' :: (RealFrac a, Elt b, IsIntegral b) => Exp a -> Exp a -> Exp b

Generalisation of div to any instance of RealFrac

mod' :: (Floating a, RealFrac a, ToFloating Int a) => Exp a -> Exp a -> Exp a

Generalisation of mod to any instance of RealFrac

divMod' :: (Floating a, RealFrac a, Num b, IsIntegral b, ToFloating b a) => Exp a -> Exp a -> (Exp b, Exp a)

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)

floatRadix :: RealFloat a => Exp a -> Exp Int64

The radix of the representation (often 2) (constant)

floatDigits :: Exp a -> Exp Int

The number of digits of floatRadix in the significand (constant)

floatDigits :: RealFloat a => Exp a -> Exp Int

The number of digits of floatRadix in the significand (constant)

floatRange :: Exp a -> (Exp Int, Exp Int)

The lowest and highest values the exponent may assume (constant)

floatRange :: RealFloat a => Exp a -> (Exp Int, Exp Int)

The lowest and highest values the exponent may assume (constant)

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

encodeFloat :: (FromIntegral Int a, FromIntegral Int64 a) => Exp Int64 -> Exp Int -> Exp a

Inverse of decodeFloat

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

isIEEE :: RealFloat a => Exp a -> Exp Bool

True if the argument is an IEEE floating point number

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

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

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

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

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

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.

Minimal complete definition

fromIntegral

Methods

fromIntegral :: Integral a => Exp a -> Exp b

General coercion from integral types

Instances

FromIntegral Int Double

Methods

fromIntegral :: Exp Int -> Exp Double

FromIntegral Int Float

Methods

fromIntegral :: Exp Int -> Exp Float

FromIntegral Int Int

Methods

fromIntegral :: Exp Int -> Exp Int

FromIntegral Int Int8

Methods

fromIntegral :: Exp Int -> Exp Int8

FromIntegral Int Int16

Methods

fromIntegral :: Exp Int -> Exp Int16

FromIntegral Int Int32

Methods

fromIntegral :: Exp Int -> Exp Int32

FromIntegral Int Int64

Methods

fromIntegral :: Exp Int -> Exp Int64

FromIntegral Int Word

Methods

fromIntegral :: Exp Int -> Exp Word

FromIntegral Int Word8

Methods

fromIntegral :: Exp Int -> Exp Word8

FromIntegral Int Word16

Methods

fromIntegral :: Exp Int -> Exp Word16

FromIntegral Int Word32

Methods

fromIntegral :: Exp Int -> Exp Word32

FromIntegral Int Word64

Methods

fromIntegral :: Exp Int -> Exp Word64

FromIntegral Int CShort

Methods

fromIntegral :: Exp Int -> Exp CShort

FromIntegral Int CUShort

Methods

fromIntegral :: Exp Int -> Exp CUShort

FromIntegral Int CInt

Methods

fromIntegral :: Exp Int -> Exp CInt

FromIntegral Int CUInt

Methods

fromIntegral :: Exp Int -> Exp CUInt

FromIntegral Int CLong

Methods

fromIntegral :: Exp Int -> Exp CLong

FromIntegral Int CULong

Methods

fromIntegral :: Exp Int -> Exp CULong

FromIntegral Int CLLong

Methods

fromIntegral :: Exp Int -> Exp CLLong

FromIntegral Int CULLong

Methods

fromIntegral :: Exp Int -> Exp CULLong

FromIntegral Int CFloat

Methods

fromIntegral :: Exp Int -> Exp CFloat

FromIntegral Int CDouble

Methods

fromIntegral :: Exp Int -> Exp CDouble

FromIntegral Int Half

Methods

fromIntegral :: Exp Int -> Exp Half

FromIntegral Int8 Double

Methods

fromIntegral :: Exp Int8 -> Exp Double

FromIntegral Int8 Float

Methods

fromIntegral :: Exp Int8 -> Exp Float

FromIntegral Int8 Int

Methods

fromIntegral :: Exp Int8 -> Exp Int

FromIntegral Int8 Int8

Methods

fromIntegral :: Exp Int8 -> Exp Int8

FromIntegral Int8 Int16

Methods

fromIntegral :: Exp Int8 -> Exp Int16

FromIntegral Int8 Int32

Methods

fromIntegral :: Exp Int8 -> Exp Int32

FromIntegral Int8 Int64

Methods

fromIntegral :: Exp Int8 -> Exp Int64

FromIntegral Int8 Word

Methods

fromIntegral :: Exp Int8 -> Exp Word

FromIntegral Int8 Word8

Methods

fromIntegral :: Exp Int8 -> Exp Word8

FromIntegral Int8 Word16

Methods

fromIntegral :: Exp Int8 -> Exp Word16

FromIntegral Int8 Word32

Methods

fromIntegral :: Exp Int8 -> Exp Word32

FromIntegral Int8 Word64

Methods

fromIntegral :: Exp Int8 -> Exp Word64

FromIntegral Int8 CShort

Methods

fromIntegral :: Exp Int8 -> Exp CShort

FromIntegral Int8 CUShort

Methods

fromIntegral :: Exp Int8 -> Exp CUShort

FromIntegral Int8 CInt

Methods

fromIntegral :: Exp Int8 -> Exp CInt

FromIntegral Int8 CUInt

Methods

fromIntegral :: Exp Int8 -> Exp CUInt

FromIntegral Int8 CLong

Methods

fromIntegral :: Exp Int8 -> Exp CLong

FromIntegral Int8 CULong

Methods

fromIntegral :: Exp Int8 -> Exp CULong

FromIntegral Int8 CLLong

Methods

fromIntegral :: Exp Int8 -> Exp CLLong

FromIntegral Int8 CULLong

Methods

fromIntegral :: Exp Int8 -> Exp CULLong

FromIntegral Int8 CFloat

Methods

fromIntegral :: Exp Int8 -> Exp CFloat

FromIntegral Int8 CDouble

Methods

fromIntegral :: Exp Int8 -> Exp CDouble

FromIntegral Int8 Half

Methods

fromIntegral :: Exp Int8 -> Exp Half

FromIntegral Int16 Double

Methods

fromIntegral :: Exp Int16 -> Exp Double

FromIntegral Int16 Float

Methods

fromIntegral :: Exp Int16 -> Exp Float

FromIntegral Int16 Int

Methods

fromIntegral :: Exp Int16 -> Exp Int

FromIntegral Int16 Int8

Methods

fromIntegral :: Exp Int16 -> Exp Int8

FromIntegral Int16 Int16

Methods

fromIntegral :: Exp Int16 -> Exp Int16

FromIntegral Int16 Int32

Methods

fromIntegral :: Exp Int16 -> Exp Int32

FromIntegral Int16 Int64

Methods

fromIntegral :: Exp Int16 -> Exp Int64

FromIntegral Int16 Word

Methods

fromIntegral :: Exp Int16 -> Exp Word

FromIntegral Int16 Word8

Methods

fromIntegral :: Exp Int16 -> Exp Word8

FromIntegral Int16 Word16

Methods

fromIntegral :: Exp Int16 -> Exp Word16

FromIntegral Int16 Word32

Methods

fromIntegral :: Exp Int16 -> Exp Word32

FromIntegral Int16 Word64

Methods

fromIntegral :: Exp Int16 -> Exp Word64

FromIntegral Int16 CShort

Methods

fromIntegral :: Exp Int16 -> Exp CShort

FromIntegral Int16 CUShort

Methods

fromIntegral :: Exp Int16 -> Exp CUShort

FromIntegral Int16 CInt

Methods

fromIntegral :: Exp Int16 -> Exp CInt

FromIntegral Int16 CUInt

Methods

fromIntegral :: Exp Int16 -> Exp CUInt

FromIntegral Int16 CLong

Methods

fromIntegral :: Exp Int16 -> Exp CLong

FromIntegral Int16 CULong

Methods

fromIntegral :: Exp Int16 -> Exp CULong

FromIntegral Int16 CLLong

Methods

fromIntegral :: Exp Int16 -> Exp CLLong

FromIntegral Int16 CULLong

Methods

fromIntegral :: Exp Int16 -> Exp CULLong

FromIntegral Int16 CFloat

Methods

fromIntegral :: Exp Int16 -> Exp CFloat

FromIntegral Int16 CDouble

Methods

fromIntegral :: Exp Int16 -> Exp CDouble

FromIntegral Int16 Half

Methods

fromIntegral :: Exp Int16 -> Exp Half

FromIntegral Int32 Double

Methods

fromIntegral :: Exp Int32 -> Exp Double

FromIntegral Int32 Float

Methods

fromIntegral :: Exp Int32 -> Exp Float

FromIntegral Int32 Int

Methods

fromIntegral :: Exp Int32 -> Exp Int

FromIntegral Int32 Int8

Methods

fromIntegral :: Exp Int32 -> Exp Int8

FromIntegral Int32 Int16

Methods

fromIntegral :: Exp Int32 -> Exp Int16

FromIntegral Int32 Int32

Methods

fromIntegral :: Exp Int32 -> Exp Int32

FromIntegral Int32 Int64

Methods

fromIntegral :: Exp Int32 -> Exp Int64

FromIntegral Int32 Word

Methods

fromIntegral :: Exp Int32 -> Exp Word

FromIntegral Int32 Word8

Methods

fromIntegral :: Exp Int32 -> Exp Word8

FromIntegral Int32 Word16

Methods

fromIntegral :: Exp Int32 -> Exp Word16

FromIntegral Int32 Word32

Methods

fromIntegral :: Exp Int32 -> Exp Word32

FromIntegral Int32 Word64

Methods

fromIntegral :: Exp Int32 -> Exp Word64

FromIntegral Int32 CShort

Methods

fromIntegral :: Exp Int32 -> Exp CShort

FromIntegral Int32 CUShort

Methods

fromIntegral :: Exp Int32 -> Exp CUShort

FromIntegral Int32 CInt

Methods

fromIntegral :: Exp Int32 -> Exp CInt

FromIntegral Int32 CUInt

Methods

fromIntegral :: Exp Int32 -> Exp CUInt

FromIntegral Int32 CLong

Methods

fromIntegral :: Exp Int32 -> Exp CLong

FromIntegral Int32 CULong

Methods

fromIntegral :: Exp Int32 -> Exp CULong

FromIntegral Int32 CLLong

Methods

fromIntegral :: Exp Int32 -> Exp CLLong

FromIntegral Int32 CULLong

Methods

fromIntegral :: Exp Int32 -> Exp CULLong

FromIntegral Int32 CFloat

Methods

fromIntegral :: Exp Int32 -> Exp CFloat

FromIntegral Int32 CDouble

Methods

fromIntegral :: Exp Int32 -> Exp CDouble

FromIntegral Int32 Half

Methods

fromIntegral :: Exp Int32 -> Exp Half

FromIntegral Int64 Double

Methods

fromIntegral :: Exp Int64 -> Exp Double

FromIntegral Int64 Float

Methods

fromIntegral :: Exp Int64 -> Exp Float

FromIntegral Int64 Int

Methods

fromIntegral :: Exp Int64 -> Exp Int

FromIntegral Int64 Int8

Methods

fromIntegral :: Exp Int64 -> Exp Int8

FromIntegral Int64 Int16

Methods

fromIntegral :: Exp Int64 -> Exp Int16

FromIntegral Int64 Int32

Methods

fromIntegral :: Exp Int64 -> Exp Int32

FromIntegral Int64 Int64

Methods

fromIntegral :: Exp Int64 -> Exp Int64

FromIntegral Int64 Word

Methods

fromIntegral :: Exp Int64 -> Exp Word

FromIntegral Int64 Word8

Methods

fromIntegral :: Exp Int64 -> Exp Word8

FromIntegral Int64 Word16

Methods

fromIntegral :: Exp Int64 -> Exp Word16

FromIntegral Int64 Word32

Methods

fromIntegral :: Exp Int64 -> Exp Word32

FromIntegral Int64 Word64

Methods

fromIntegral :: Exp Int64 -> Exp Word64

FromIntegral Int64 CShort

Methods

fromIntegral :: Exp Int64 -> Exp CShort

FromIntegral Int64 CUShort

Methods

fromIntegral :: Exp Int64 -> Exp CUShort

FromIntegral Int64 CInt

Methods

fromIntegral :: Exp Int64 -> Exp CInt

FromIntegral Int64 CUInt

Methods

fromIntegral :: Exp Int64 -> Exp CUInt

FromIntegral Int64 CLong

Methods

fromIntegral :: Exp Int64 -> Exp CLong

FromIntegral Int64 CULong

Methods

fromIntegral :: Exp Int64 -> Exp CULong

FromIntegral Int64 CLLong

Methods

fromIntegral :: Exp Int64 -> Exp CLLong

FromIntegral Int64 CULLong

Methods

fromIntegral :: Exp Int64 -> Exp CULLong

FromIntegral Int64 CFloat

Methods

fromIntegral :: Exp Int64 -> Exp CFloat

FromIntegral Int64 CDouble

Methods

fromIntegral :: Exp Int64 -> Exp CDouble

FromIntegral Int64 Half

Methods

fromIntegral :: Exp Int64 -> Exp Half

FromIntegral Word Double

Methods

fromIntegral :: Exp Word -> Exp Double

FromIntegral Word Float

Methods

fromIntegral :: Exp Word -> Exp Float

FromIntegral Word Int

Methods

fromIntegral :: Exp Word -> Exp Int

FromIntegral Word Int8

Methods

fromIntegral :: Exp Word -> Exp Int8

FromIntegral Word Int16

Methods

fromIntegral :: Exp Word -> Exp Int16

FromIntegral Word Int32

Methods

fromIntegral :: Exp Word -> Exp Int32

FromIntegral Word Int64

Methods

fromIntegral :: Exp Word -> Exp Int64

FromIntegral Word Word

Methods

fromIntegral :: Exp Word -> Exp Word

FromIntegral Word Word8

Methods

fromIntegral :: Exp Word -> Exp Word8

FromIntegral Word Word16

Methods

fromIntegral :: Exp Word -> Exp Word16

FromIntegral Word Word32

Methods

fromIntegral :: Exp Word -> Exp Word32

FromIntegral Word Word64

Methods

fromIntegral :: Exp Word -> Exp Word64

FromIntegral Word CShort

Methods

fromIntegral :: Exp Word -> Exp CShort

FromIntegral Word CUShort

Methods

fromIntegral :: Exp Word -> Exp CUShort

FromIntegral Word CInt

Methods

fromIntegral :: Exp Word -> Exp CInt

FromIntegral Word CUInt

Methods

fromIntegral :: Exp Word -> Exp CUInt

FromIntegral Word CLong

Methods

fromIntegral :: Exp Word -> Exp CLong

FromIntegral Word CULong

Methods

fromIntegral :: Exp Word -> Exp CULong

FromIntegral Word CLLong

Methods

fromIntegral :: Exp Word -> Exp CLLong

FromIntegral Word CULLong

Methods

fromIntegral :: Exp Word -> Exp CULLong

FromIntegral Word CFloat

Methods

fromIntegral :: Exp Word -> Exp CFloat

FromIntegral Word CDouble

Methods

fromIntegral :: Exp Word -> Exp CDouble

FromIntegral Word Half

Methods

fromIntegral :: Exp Word -> Exp Half

FromIntegral Word8 Double

Methods

fromIntegral :: Exp Word8 -> Exp Double

FromIntegral Word8 Float

Methods

fromIntegral :: Exp Word8 -> Exp Float

FromIntegral Word8 Int

Methods

fromIntegral :: Exp Word8 -> Exp Int

FromIntegral Word8 Int8

Methods

fromIntegral :: Exp Word8 -> Exp Int8

FromIntegral Word8 Int16

Methods

fromIntegral :: Exp Word8 -> Exp Int16

FromIntegral Word8 Int32

Methods

fromIntegral :: Exp Word8 -> Exp Int32

FromIntegral Word8 Int64

Methods

fromIntegral :: Exp Word8 -> Exp Int64

FromIntegral Word8 Word

Methods

fromIntegral :: Exp Word8 -> Exp Word

FromIntegral Word8 Word8

Methods

fromIntegral :: Exp Word8 -> Exp Word8

FromIntegral Word8 Word16

Methods

fromIntegral :: Exp Word8 -> Exp Word16

FromIntegral Word8 Word32

Methods

fromIntegral :: Exp Word8 -> Exp Word32

FromIntegral Word8 Word64

Methods

fromIntegral :: Exp Word8 -> Exp Word64

FromIntegral Word8 CShort

Methods

fromIntegral :: Exp Word8 -> Exp CShort

FromIntegral Word8 CUShort

Methods

fromIntegral :: Exp Word8 -> Exp CUShort

FromIntegral Word8 CInt

Methods

fromIntegral :: Exp Word8 -> Exp CInt

FromIntegral Word8 CUInt

Methods

fromIntegral :: Exp Word8 -> Exp CUInt

FromIntegral Word8 CLong

Methods

fromIntegral :: Exp Word8 -> Exp CLong

FromIntegral Word8 CULong

Methods

fromIntegral :: Exp Word8 -> Exp CULong

FromIntegral Word8 CLLong

Methods

fromIntegral :: Exp Word8 -> Exp CLLong

FromIntegral Word8 CULLong

Methods

fromIntegral :: Exp Word8 -> Exp CULLong

FromIntegral Word8 CFloat

Methods

fromIntegral :: Exp Word8 -> Exp CFloat

FromIntegral Word8 CDouble

Methods

fromIntegral :: Exp Word8 -> Exp CDouble

FromIntegral Word8 Half

Methods

fromIntegral :: Exp Word8 -> Exp Half

FromIntegral Word16 Double

Methods

fromIntegral :: Exp Word16 -> Exp Double

FromIntegral Word16 Float

Methods

fromIntegral :: Exp Word16 -> Exp Float

FromIntegral Word16 Int

Methods

fromIntegral :: Exp Word16 -> Exp Int

FromIntegral Word16 Int8

Methods

fromIntegral :: Exp Word16 -> Exp Int8

FromIntegral Word16 Int16

Methods

fromIntegral :: Exp Word16 -> Exp Int16

FromIntegral Word16 Int32

Methods

fromIntegral :: Exp Word16 -> Exp Int32

FromIntegral Word16 Int64

Methods

fromIntegral :: Exp Word16 -> Exp Int64

FromIntegral Word16 Word

Methods

fromIntegral :: Exp Word16 -> Exp Word

FromIntegral Word16 Word8

Methods

fromIntegral :: Exp Word16 -> Exp Word8

FromIntegral Word16 Word16

Methods

fromIntegral :: Exp Word16 -> Exp Word16

FromIntegral Word16 Word32

Methods

fromIntegral :: Exp Word16 -> Exp Word32

FromIntegral Word16 Word64

Methods

fromIntegral :: Exp Word16 -> Exp Word64

FromIntegral Word16 CShort

Methods

fromIntegral :: Exp Word16 -> Exp CShort

FromIntegral Word16 CUShort

Methods

fromIntegral :: Exp Word16 -> Exp CUShort

FromIntegral Word16 CInt

Methods

fromIntegral :: Exp Word16 -> Exp CInt

FromIntegral Word16 CUInt

Methods

fromIntegral :: Exp Word16 -> Exp CUInt

FromIntegral Word16 CLong

Methods

fromIntegral :: Exp Word16 -> Exp CLong

FromIntegral Word16 CULong

Methods

fromIntegral :: Exp Word16 -> Exp CULong

FromIntegral Word16 CLLong

Methods

fromIntegral :: Exp Word16 -> Exp CLLong

FromIntegral Word16 CULLong

Methods

fromIntegral :: Exp Word16 -> Exp CULLong

FromIntegral Word16 CFloat

Methods

fromIntegral :: Exp Word16 -> Exp CFloat

FromIntegral Word16 CDouble

Methods

fromIntegral :: Exp Word16 -> Exp CDouble

FromIntegral Word16 Half

Methods

fromIntegral :: Exp Word16 -> Exp Half

FromIntegral Word32 Double

Methods

fromIntegral :: Exp Word32 -> Exp Double

FromIntegral Word32 Float

Methods

fromIntegral :: Exp Word32 -> Exp Float

FromIntegral Word32 Int

Methods

fromIntegral :: Exp Word32 -> Exp Int

FromIntegral Word32 Int8

Methods

fromIntegral :: Exp Word32 -> Exp Int8

FromIntegral Word32 Int16

Methods

fromIntegral :: Exp Word32 -> Exp Int16

FromIntegral Word32 Int32

Methods

fromIntegral :: Exp Word32 -> Exp Int32

FromIntegral Word32 Int64

Methods

fromIntegral :: Exp Word32 -> Exp Int64

FromIntegral Word32 Word

Methods

fromIntegral :: Exp Word32 -> Exp Word

FromIntegral Word32 Word8

Methods

fromIntegral :: Exp Word32 -> Exp Word8

FromIntegral Word32 Word16

Methods

fromIntegral :: Exp Word32 -> Exp Word16

FromIntegral Word32 Word32

Methods

fromIntegral :: Exp Word32 -> Exp Word32

FromIntegral Word32 Word64

Methods

fromIntegral :: Exp Word32 -> Exp Word64

FromIntegral Word32 CShort

Methods

fromIntegral :: Exp Word32 -> Exp CShort

FromIntegral Word32 CUShort

Methods

fromIntegral :: Exp Word32 -> Exp CUShort

FromIntegral Word32 CInt

Methods

fromIntegral :: Exp Word32 -> Exp CInt

FromIntegral Word32 CUInt

Methods

fromIntegral :: Exp Word32 -> Exp CUInt

FromIntegral Word32 CLong

Methods

fromIntegral :: Exp Word32 -> Exp CLong

FromIntegral Word32 CULong

Methods

fromIntegral :: Exp Word32 -> Exp CULong

FromIntegral Word32 CLLong

Methods

fromIntegral :: Exp Word32 -> Exp CLLong

FromIntegral Word32 CULLong

Methods

fromIntegral :: Exp Word32 -> Exp CULLong

FromIntegral Word32 CFloat

Methods

fromIntegral :: Exp Word32 -> Exp CFloat

FromIntegral Word32 CDouble

Methods

fromIntegral :: Exp Word32 -> Exp CDouble

FromIntegral Word32 Half

Methods

fromIntegral :: Exp Word32 -> Exp Half

FromIntegral Word64 Double

Methods

fromIntegral :: Exp Word64 -> Exp Double

FromIntegral Word64 Float

Methods

fromIntegral :: Exp Word64 -> Exp Float

FromIntegral Word64 Int

Methods

fromIntegral :: Exp Word64 -> Exp Int

FromIntegral Word64 Int8

Methods

fromIntegral :: Exp Word64 -> Exp Int8

FromIntegral Word64 Int16

Methods

fromIntegral :: Exp Word64 -> Exp Int16

FromIntegral Word64 Int32

Methods

fromIntegral :: Exp Word64 -> Exp Int32

FromIntegral Word64 Int64

Methods

fromIntegral :: Exp Word64 -> Exp Int64

FromIntegral Word64 Word

Methods

fromIntegral :: Exp Word64 -> Exp Word

FromIntegral Word64 Word8

Methods

fromIntegral :: Exp Word64 -> Exp Word8

FromIntegral Word64 Word16

Methods

fromIntegral :: Exp Word64 -> Exp Word16

FromIntegral Word64 Word32

Methods

fromIntegral :: Exp Word64 -> Exp Word32

FromIntegral Word64 Word64

Methods

fromIntegral :: Exp Word64 -> Exp Word64

FromIntegral Word64 CShort

Methods

fromIntegral :: Exp Word64 -> Exp CShort

FromIntegral Word64 CUShort

Methods

fromIntegral :: Exp Word64 -> Exp CUShort

FromIntegral Word64 CInt

Methods

fromIntegral :: Exp Word64 -> Exp CInt

FromIntegral Word64 CUInt

Methods

fromIntegral :: Exp Word64 -> Exp CUInt

FromIntegral Word64 CLong

Methods

fromIntegral :: Exp Word64 -> Exp CLong

FromIntegral Word64 CULong

Methods

fromIntegral :: Exp Word64 -> Exp CULong

FromIntegral Word64 CLLong

Methods

fromIntegral :: Exp Word64 -> Exp CLLong

FromIntegral Word64 CULLong

Methods

fromIntegral :: Exp Word64 -> Exp CULLong

FromIntegral Word64 CFloat

Methods

fromIntegral :: Exp Word64 -> Exp CFloat

FromIntegral Word64 CDouble

Methods

fromIntegral :: Exp Word64 -> Exp CDouble

FromIntegral Word64 Half

Methods

fromIntegral :: Exp Word64 -> Exp Half

FromIntegral CShort Double

Methods

fromIntegral :: Exp CShort -> Exp Double

FromIntegral CShort Float

Methods

fromIntegral :: Exp CShort -> Exp Float

FromIntegral CShort Int

Methods

fromIntegral :: Exp CShort -> Exp Int

FromIntegral CShort Int8

Methods

fromIntegral :: Exp CShort -> Exp Int8

FromIntegral CShort Int16

Methods

fromIntegral :: Exp CShort -> Exp Int16

FromIntegral CShort Int32

Methods

fromIntegral :: Exp CShort -> Exp Int32

FromIntegral CShort Int64

Methods

fromIntegral :: Exp CShort -> Exp Int64

FromIntegral CShort Word

Methods

fromIntegral :: Exp CShort -> Exp Word

FromIntegral CShort Word8

Methods

fromIntegral :: Exp CShort -> Exp Word8

FromIntegral CShort Word16

Methods

fromIntegral :: Exp CShort -> Exp Word16

FromIntegral CShort Word32

Methods

fromIntegral :: Exp CShort -> Exp Word32

FromIntegral CShort Word64

Methods

fromIntegral :: Exp CShort -> Exp Word64

FromIntegral CShort CShort

Methods

fromIntegral :: Exp CShort -> Exp CShort

FromIntegral CShort CUShort

Methods

fromIntegral :: Exp CShort -> Exp CUShort

FromIntegral CShort CInt

Methods

fromIntegral :: Exp CShort -> Exp CInt

FromIntegral CShort CUInt

Methods

fromIntegral :: Exp CShort -> Exp CUInt

FromIntegral CShort CLong

Methods

fromIntegral :: Exp CShort -> Exp CLong

FromIntegral CShort CULong

Methods

fromIntegral :: Exp CShort -> Exp CULong

FromIntegral CShort CLLong

Methods

fromIntegral :: Exp CShort -> Exp CLLong

FromIntegral CShort CULLong

Methods

fromIntegral :: Exp CShort -> Exp CULLong

FromIntegral CShort CFloat

Methods

fromIntegral :: Exp CShort -> Exp CFloat

FromIntegral CShort CDouble

Methods

fromIntegral :: Exp CShort -> Exp CDouble

FromIntegral CShort Half

Methods

fromIntegral :: Exp CShort -> Exp Half

FromIntegral CUShort Double

Methods

fromIntegral :: Exp CUShort -> Exp Double

FromIntegral CUShort Float

Methods

fromIntegral :: Exp CUShort -> Exp Float

FromIntegral CUShort Int

Methods

fromIntegral :: Exp CUShort -> Exp Int

FromIntegral CUShort Int8

Methods

fromIntegral :: Exp CUShort -> Exp Int8

FromIntegral CUShort Int16

Methods

fromIntegral :: Exp CUShort -> Exp Int16

FromIntegral CUShort Int32

Methods

fromIntegral :: Exp CUShort -> Exp Int32

FromIntegral CUShort Int64

Methods

fromIntegral :: Exp CUShort -> Exp Int64

FromIntegral CUShort Word

Methods

fromIntegral :: Exp CUShort -> Exp Word

FromIntegral CUShort Word8

Methods

fromIntegral :: Exp CUShort -> Exp Word8

FromIntegral CUShort Word16

Methods

fromIntegral :: Exp CUShort -> Exp Word16

FromIntegral CUShort Word32

Methods

fromIntegral :: Exp CUShort -> Exp Word32

FromIntegral CUShort Word64

Methods

fromIntegral :: Exp CUShort -> Exp Word64

FromIntegral CUShort CShort

Methods

fromIntegral :: Exp CUShort -> Exp CShort

FromIntegral CUShort CUShort

Methods

fromIntegral :: Exp CUShort -> Exp CUShort

FromIntegral CUShort CInt

Methods

fromIntegral :: Exp CUShort -> Exp CInt

FromIntegral CUShort CUInt

Methods

fromIntegral :: Exp CUShort -> Exp CUInt

FromIntegral CUShort CLong

Methods

fromIntegral :: Exp CUShort -> Exp CLong

FromIntegral CUShort CULong

Methods

fromIntegral :: Exp CUShort -> Exp CULong

FromIntegral CUShort CLLong

Methods

fromIntegral :: Exp CUShort -> Exp CLLong

FromIntegral CUShort CULLong

Methods

fromIntegral :: Exp CUShort -> Exp CULLong

FromIntegral CUShort CFloat

Methods

fromIntegral :: Exp CUShort -> Exp CFloat

FromIntegral CUShort CDouble

Methods

fromIntegral :: Exp CUShort -> Exp CDouble

FromIntegral CUShort Half

Methods

fromIntegral :: Exp CUShort -> Exp Half

FromIntegral CInt Double

Methods

fromIntegral :: Exp CInt -> Exp Double

FromIntegral CInt Float

Methods

fromIntegral :: Exp CInt -> Exp Float

FromIntegral CInt Int

Methods

fromIntegral :: Exp CInt -> Exp Int

FromIntegral CInt Int8

Methods

fromIntegral :: Exp CInt -> Exp Int8

FromIntegral CInt Int16

Methods

fromIntegral :: Exp CInt -> Exp Int16

FromIntegral CInt Int32

Methods

fromIntegral :: Exp CInt -> Exp Int32

FromIntegral CInt Int64

Methods

fromIntegral :: Exp CInt -> Exp Int64

FromIntegral CInt Word

Methods

fromIntegral :: Exp CInt -> Exp Word

FromIntegral CInt Word8

Methods

fromIntegral :: Exp CInt -> Exp Word8

FromIntegral CInt Word16

Methods

fromIntegral :: Exp CInt -> Exp Word16

FromIntegral CInt Word32

Methods

fromIntegral :: Exp CInt -> Exp Word32

FromIntegral CInt Word64

Methods

fromIntegral :: Exp CInt -> Exp Word64

FromIntegral CInt CShort

Methods

fromIntegral :: Exp CInt -> Exp CShort

FromIntegral CInt CUShort

Methods

fromIntegral :: Exp CInt -> Exp CUShort

FromIntegral CInt CInt

Methods

fromIntegral :: Exp CInt -> Exp CInt

FromIntegral CInt CUInt

Methods

fromIntegral :: Exp CInt -> Exp CUInt

FromIntegral CInt CLong

Methods

fromIntegral :: Exp CInt -> Exp CLong

FromIntegral CInt CULong

Methods

fromIntegral :: Exp CInt -> Exp CULong

FromIntegral CInt CLLong

Methods

fromIntegral :: Exp CInt -> Exp CLLong

FromIntegral CInt CULLong

Methods

fromIntegral :: Exp CInt -> Exp CULLong

FromIntegral CInt CFloat

Methods

fromIntegral :: Exp CInt -> Exp CFloat

FromIntegral CInt CDouble

Methods

fromIntegral :: Exp CInt -> Exp CDouble

FromIntegral CInt Half

Methods

fromIntegral :: Exp CInt -> Exp Half

FromIntegral CUInt Double

Methods

fromIntegral :: Exp CUInt -> Exp Double

FromIntegral CUInt Float

Methods

fromIntegral :: Exp CUInt -> Exp Float

FromIntegral CUInt Int

Methods

fromIntegral :: Exp CUInt -> Exp Int

FromIntegral CUInt Int8

Methods

fromIntegral :: Exp CUInt -> Exp Int8

FromIntegral CUInt Int16

Methods

fromIntegral :: Exp CUInt -> Exp Int16

FromIntegral CUInt Int32

Methods

fromIntegral :: Exp CUInt -> Exp Int32

FromIntegral CUInt Int64

Methods

fromIntegral :: Exp CUInt -> Exp Int64

FromIntegral CUInt Word

Methods

fromIntegral :: Exp CUInt -> Exp Word

FromIntegral CUInt Word8

Methods

fromIntegral :: Exp CUInt -> Exp Word8

FromIntegral CUInt Word16

Methods

fromIntegral :: Exp CUInt -> Exp Word16

FromIntegral CUInt Word32

Methods

fromIntegral :: Exp CUInt -> Exp Word32

FromIntegral CUInt Word64

Methods

fromIntegral :: Exp CUInt -> Exp Word64

FromIntegral CUInt CShort

Methods

fromIntegral :: Exp CUInt -> Exp CShort

FromIntegral CUInt CUShort

Methods

fromIntegral :: Exp CUInt -> Exp CUShort

FromIntegral CUInt CInt

Methods

fromIntegral :: Exp CUInt -> Exp CInt

FromIntegral CUInt CUInt

Methods

fromIntegral :: Exp CUInt -> Exp CUInt

FromIntegral CUInt CLong

Methods

fromIntegral :: Exp CUInt -> Exp CLong

FromIntegral CUInt CULong

Methods

fromIntegral :: Exp CUInt -> Exp CULong

FromIntegral CUInt CLLong

Methods

fromIntegral :: Exp CUInt -> Exp CLLong

FromIntegral CUInt CULLong

Methods

fromIntegral :: Exp CUInt -> Exp CULLong

FromIntegral CUInt CFloat

Methods

fromIntegral :: Exp CUInt -> Exp CFloat

FromIntegral CUInt CDouble

Methods

fromIntegral :: Exp CUInt -> Exp CDouble

FromIntegral CUInt Half

Methods

fromIntegral :: Exp CUInt -> Exp Half

FromIntegral CLong Double

Methods

fromIntegral :: Exp CLong -> Exp Double

FromIntegral CLong Float

Methods

fromIntegral :: Exp CLong -> Exp Float

FromIntegral CLong Int

Methods

fromIntegral :: Exp CLong -> Exp Int

FromIntegral CLong Int8

Methods

fromIntegral :: Exp CLong -> Exp Int8

FromIntegral CLong Int16

Methods

fromIntegral :: Exp CLong -> Exp Int16

FromIntegral CLong Int32

Methods

fromIntegral :: Exp CLong -> Exp Int32

FromIntegral CLong Int64

Methods

fromIntegral :: Exp CLong -> Exp Int64

FromIntegral CLong Word

Methods

fromIntegral :: Exp CLong -> Exp Word

FromIntegral CLong Word8

Methods

fromIntegral :: Exp CLong -> Exp Word8

FromIntegral CLong Word16

Methods

fromIntegral :: Exp CLong -> Exp Word16

FromIntegral CLong Word32

Methods

fromIntegral :: Exp CLong -> Exp Word32

FromIntegral CLong Word64

Methods

fromIntegral :: Exp CLong -> Exp Word64

FromIntegral CLong CShort

Methods

fromIntegral :: Exp CLong -> Exp CShort

FromIntegral CLong CUShort

Methods

fromIntegral :: Exp CLong -> Exp CUShort

FromIntegral CLong CInt

Methods

fromIntegral :: Exp CLong -> Exp CInt

FromIntegral CLong CUInt

Methods

fromIntegral :: Exp CLong -> Exp CUInt

FromIntegral CLong CLong

Methods

fromIntegral :: Exp CLong -> Exp CLong

FromIntegral CLong CULong

Methods

fromIntegral :: Exp CLong -> Exp CULong

FromIntegral CLong CLLong

Methods

fromIntegral :: Exp CLong -> Exp CLLong

FromIntegral CLong CULLong

Methods

fromIntegral :: Exp CLong -> Exp CULLong

FromIntegral CLong CFloat

Methods

fromIntegral :: Exp CLong -> Exp CFloat

FromIntegral CLong CDouble

Methods

fromIntegral :: Exp CLong -> Exp CDouble

FromIntegral CLong Half

Methods

fromIntegral :: Exp CLong -> Exp Half

FromIntegral CULong Double

Methods

fromIntegral :: Exp CULong -> Exp Double

FromIntegral CULong Float

Methods

fromIntegral :: Exp CULong -> Exp Float

FromIntegral CULong Int

Methods

fromIntegral :: Exp CULong -> Exp Int

FromIntegral CULong Int8

Methods

fromIntegral :: Exp CULong -> Exp Int8

FromIntegral CULong Int16

Methods

fromIntegral :: Exp CULong -> Exp Int16

FromIntegral CULong Int32

Methods

fromIntegral :: Exp CULong -> Exp Int32

FromIntegral CULong Int64

Methods

fromIntegral :: Exp CULong -> Exp Int64

FromIntegral CULong Word

Methods

fromIntegral :: Exp CULong -> Exp Word

FromIntegral CULong Word8

Methods

fromIntegral :: Exp CULong -> Exp Word8

FromIntegral CULong Word16

Methods

fromIntegral :: Exp CULong -> Exp Word16

FromIntegral CULong Word32

Methods

fromIntegral :: Exp CULong -> Exp Word32

FromIntegral CULong Word64

Methods

fromIntegral :: Exp CULong -> Exp Word64

FromIntegral CULong CShort

Methods

fromIntegral :: Exp CULong -> Exp CShort

FromIntegral CULong CUShort

Methods

fromIntegral :: Exp CULong -> Exp CUShort

FromIntegral CULong CInt

Methods

fromIntegral :: Exp CULong -> Exp CInt

FromIntegral CULong CUInt

Methods

fromIntegral :: Exp CULong -> Exp CUInt

FromIntegral CULong CLong

Methods

fromIntegral :: Exp CULong -> Exp CLong

FromIntegral CULong CULong

Methods

fromIntegral :: Exp CULong -> Exp CULong

FromIntegral CULong CLLong

Methods

fromIntegral :: Exp CULong -> Exp CLLong

FromIntegral CULong CULLong

Methods

fromIntegral :: Exp CULong -> Exp CULLong

FromIntegral CULong CFloat

Methods

fromIntegral :: Exp CULong -> Exp CFloat

FromIntegral CULong CDouble

Methods

fromIntegral :: Exp CULong -> Exp CDouble

FromIntegral CULong Half

Methods

fromIntegral :: Exp CULong -> Exp Half

FromIntegral CLLong Double

Methods

fromIntegral :: Exp CLLong -> Exp Double

FromIntegral CLLong Float

Methods

fromIntegral :: Exp CLLong -> Exp Float

FromIntegral CLLong Int

Methods

fromIntegral :: Exp CLLong -> Exp Int

FromIntegral CLLong Int8

Methods

fromIntegral :: Exp CLLong -> Exp Int8

FromIntegral CLLong Int16

Methods

fromIntegral :: Exp CLLong -> Exp Int16

FromIntegral CLLong Int32

Methods

fromIntegral :: Exp CLLong -> Exp Int32

FromIntegral CLLong Int64

Methods

fromIntegral :: Exp CLLong -> Exp Int64

FromIntegral CLLong Word

Methods

fromIntegral :: Exp CLLong -> Exp Word

FromIntegral CLLong Word8

Methods

fromIntegral :: Exp CLLong -> Exp Word8

FromIntegral CLLong Word16

Methods

fromIntegral :: Exp CLLong -> Exp Word16

FromIntegral CLLong Word32

Methods

fromIntegral :: Exp CLLong -> Exp Word32

FromIntegral CLLong Word64

Methods

fromIntegral :: Exp CLLong -> Exp Word64

FromIntegral CLLong CShort

Methods

fromIntegral :: Exp CLLong -> Exp CShort

FromIntegral CLLong CUShort

Methods

fromIntegral :: Exp CLLong -> Exp CUShort

FromIntegral CLLong CInt

Methods

fromIntegral :: Exp CLLong -> Exp CInt

FromIntegral CLLong CUInt

Methods

fromIntegral :: Exp CLLong -> Exp CUInt

FromIntegral CLLong CLong

Methods

fromIntegral :: Exp CLLong -> Exp CLong

FromIntegral CLLong CULong

Methods

fromIntegral :: Exp CLLong -> Exp CULong

FromIntegral CLLong CLLong

Methods

fromIntegral :: Exp CLLong -> Exp CLLong

FromIntegral CLLong CULLong

Methods

fromIntegral :: Exp CLLong -> Exp CULLong

FromIntegral CLLong CFloat

Methods

fromIntegral :: Exp CLLong -> Exp CFloat

FromIntegral CLLong CDouble

Methods

fromIntegral :: Exp CLLong -> Exp CDouble

FromIntegral CLLong Half

Methods

fromIntegral :: Exp CLLong -> Exp Half

FromIntegral CULLong Double

Methods

fromIntegral :: Exp CULLong -> Exp Double

FromIntegral CULLong Float

Methods

fromIntegral :: Exp CULLong -> Exp Float

FromIntegral CULLong Int

Methods

fromIntegral :: Exp CULLong -> Exp Int

FromIntegral CULLong Int8

Methods

fromIntegral :: Exp CULLong -> Exp Int8

FromIntegral CULLong Int16

Methods

fromIntegral :: Exp CULLong -> Exp Int16

FromIntegral CULLong Int32

Methods

fromIntegral :: Exp CULLong -> Exp Int32

FromIntegral CULLong Int64

Methods

fromIntegral :: Exp CULLong -> Exp Int64

FromIntegral CULLong Word

Methods

fromIntegral :: Exp CULLong -> Exp Word

FromIntegral CULLong Word8

Methods

fromIntegral :: Exp CULLong -> Exp Word8

FromIntegral CULLong Word16

Methods

fromIntegral :: Exp CULLong -> Exp Word16

FromIntegral CULLong Word32

Methods

fromIntegral :: Exp CULLong -> Exp Word32

FromIntegral CULLong Word64

Methods

fromIntegral :: Exp CULLong -> Exp Word64

FromIntegral CULLong CShort

Methods

fromIntegral :: Exp CULLong -> Exp CShort

FromIntegral CULLong CUShort

Methods

fromIntegral :: Exp CULLong -> Exp CUShort

FromIntegral CULLong CInt

Methods

fromIntegral :: Exp CULLong -> Exp CInt

FromIntegral CULLong CUInt

Methods

fromIntegral :: Exp CULLong -> Exp CUInt

FromIntegral CULLong CLong

Methods

fromIntegral :: Exp CULLong -> Exp CLong

FromIntegral CULLong CULong

Methods

fromIntegral :: Exp CULLong -> Exp CULong

FromIntegral CULLong CLLong

Methods

fromIntegral :: Exp CULLong -> Exp CLLong

FromIntegral CULLong CULLong

Methods

fromIntegral :: Exp CULLong -> Exp CULLong

FromIntegral CULLong CFloat

Methods

fromIntegral :: Exp CULLong -> Exp CFloat

FromIntegral CULLong CDouble

Methods

fromIntegral :: Exp CULLong -> Exp CDouble

FromIntegral CULLong Half

Methods

fromIntegral :: Exp CULLong -> Exp Half

(FromIntegral a b, Num b, Elt (Complex b)) => FromIntegral a (Complex b)

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 to types.

Minimal complete definition

toFloating

Methods

toFloating :: (Num a, Floating b) => Exp a -> Exp b

General coercion to floating types

Instances

ToFloating Double Double

Methods

toFloating :: Exp Double -> Exp Double

ToFloating Double Float

Methods

toFloating :: Exp Double -> Exp Float

ToFloating Double CFloat

Methods

toFloating :: Exp Double -> Exp CFloat

ToFloating Double CDouble

Methods

toFloating :: Exp Double -> Exp CDouble

ToFloating Double Half

Methods

toFloating :: Exp Double -> Exp Half

ToFloating Float Double

Methods

toFloating :: Exp Float -> Exp Double

ToFloating Float Float

Methods

toFloating :: Exp Float -> Exp Float

ToFloating Float CFloat

Methods

toFloating :: Exp Float -> Exp CFloat

ToFloating Float CDouble

Methods

toFloating :: Exp Float -> Exp CDouble

ToFloating Float Half

Methods

toFloating :: Exp Float -> Exp Half

ToFloating Int Double

Methods

toFloating :: Exp Int -> Exp Double

ToFloating Int Float

Methods

toFloating :: Exp Int -> Exp Float

ToFloating Int CFloat

Methods

toFloating :: Exp Int -> Exp CFloat

ToFloating Int CDouble

Methods

toFloating :: Exp Int -> Exp CDouble

ToFloating Int Half

Methods

toFloating :: Exp Int -> Exp Half

ToFloating Int8 Double

Methods

toFloating :: Exp Int8 -> Exp Double

ToFloating Int8 Float

Methods

toFloating :: Exp Int8 -> Exp Float

ToFloating Int8 CFloat

Methods

toFloating :: Exp Int8 -> Exp CFloat

ToFloating Int8 CDouble

Methods

toFloating :: Exp Int8 -> Exp CDouble

ToFloating Int8 Half

Methods

toFloating :: Exp Int8 -> Exp Half

ToFloating Int16 Double

Methods

toFloating :: Exp Int16 -> Exp Double

ToFloating Int16 Float

Methods

toFloating :: Exp Int16 -> Exp Float

ToFloating Int16 CFloat

Methods

toFloating :: Exp Int16 -> Exp CFloat

ToFloating Int16 CDouble

Methods

toFloating :: Exp Int16 -> Exp CDouble

ToFloating Int16 Half

Methods

toFloating :: Exp Int16 -> Exp Half

ToFloating Int32 Double

Methods

toFloating :: Exp Int32 -> Exp Double

ToFloating Int32 Float

Methods

toFloating :: Exp Int32 -> Exp Float

ToFloating Int32 CFloat

Methods

toFloating :: Exp Int32 -> Exp CFloat

ToFloating Int32 CDouble

Methods

toFloating :: Exp Int32 -> Exp CDouble

ToFloating Int32 Half

Methods

toFloating :: Exp Int32 -> Exp Half

ToFloating Int64 Double

Methods

toFloating :: Exp Int64 -> Exp Double

ToFloating Int64 Float

Methods

toFloating :: Exp Int64 -> Exp Float

ToFloating Int64 CFloat

Methods

toFloating :: Exp Int64 -> Exp CFloat

ToFloating Int64 CDouble

Methods

toFloating :: Exp Int64 -> Exp CDouble

ToFloating Int64 Half

Methods

toFloating :: Exp Int64 -> Exp Half

ToFloating Word Double

Methods

toFloating :: Exp Word -> Exp Double

ToFloating Word Float

Methods

toFloating :: Exp Word -> Exp Float

ToFloating Word CFloat

Methods

toFloating :: Exp Word -> Exp CFloat

ToFloating Word CDouble

Methods

toFloating :: Exp Word -> Exp CDouble

ToFloating Word Half

Methods

toFloating :: Exp Word -> Exp Half

ToFloating Word8 Double

Methods

toFloating :: Exp Word8 -> Exp Double

ToFloating Word8 Float

Methods

toFloating :: Exp Word8 -> Exp Float

ToFloating Word8 CFloat

Methods

toFloating :: Exp Word8 -> Exp CFloat

ToFloating Word8 CDouble

Methods

toFloating :: Exp Word8 -> Exp CDouble

ToFloating Word8 Half

Methods

toFloating :: Exp Word8 -> Exp Half

ToFloating Word16 Double

Methods

toFloating :: Exp Word16 -> Exp Double

ToFloating Word16 Float

Methods

toFloating :: Exp Word16 -> Exp Float

ToFloating Word16 CFloat

Methods

toFloating :: Exp Word16 -> Exp CFloat

ToFloating Word16 CDouble

Methods

toFloating :: Exp Word16 -> Exp CDouble

ToFloating Word16 Half

Methods

toFloating :: Exp Word16 -> Exp Half

ToFloating Word32 Double

Methods

toFloating :: Exp Word32 -> Exp Double

ToFloating Word32 Float

Methods

toFloating :: Exp Word32 -> Exp Float

ToFloating Word32 CFloat

Methods

toFloating :: Exp Word32 -> Exp CFloat

ToFloating Word32 CDouble

Methods

toFloating :: Exp Word32 -> Exp CDouble

ToFloating Word32 Half

Methods

toFloating :: Exp Word32 -> Exp Half

ToFloating Word64 Double

Methods

toFloating :: Exp Word64 -> Exp Double

ToFloating Word64 Float

Methods

toFloating :: Exp Word64 -> Exp Float

ToFloating Word64 CFloat

Methods

toFloating :: Exp Word64 -> Exp CFloat

ToFloating Word64 CDouble

Methods

toFloating :: Exp Word64 -> Exp CDouble

ToFloating Word64 Half

Methods

toFloating :: Exp Word64 -> Exp Half

ToFloating CShort Double

Methods

toFloating :: Exp CShort -> Exp Double

ToFloating CShort Float

Methods

toFloating :: Exp CShort -> Exp Float

ToFloating CShort CFloat

Methods

toFloating :: Exp CShort -> Exp CFloat

ToFloating CShort CDouble

Methods

toFloating :: Exp CShort -> Exp CDouble

ToFloating CShort Half

Methods

toFloating :: Exp CShort -> Exp Half

ToFloating CUShort Double

Methods

toFloating :: Exp CUShort -> Exp Double

ToFloating CUShort Float

Methods

toFloating :: Exp CUShort -> Exp Float

ToFloating CUShort CFloat

Methods

toFloating :: Exp CUShort -> Exp CFloat

ToFloating CUShort CDouble

Methods

toFloating :: Exp CUShort -> Exp CDouble

ToFloating CUShort Half

Methods

toFloating :: Exp CUShort -> Exp Half

ToFloating CInt Double

Methods

toFloating :: Exp CInt -> Exp Double

ToFloating CInt Float

Methods

toFloating :: Exp CInt -> Exp Float

ToFloating CInt CFloat

Methods

toFloating :: Exp CInt -> Exp CFloat

ToFloating CInt CDouble

Methods

toFloating :: Exp CInt -> Exp CDouble

ToFloating CInt Half

Methods

toFloating :: Exp CInt -> Exp Half

ToFloating CUInt Double

Methods

toFloating :: Exp CUInt -> Exp Double

ToFloating CUInt Float

Methods

toFloating :: Exp CUInt -> Exp Float

ToFloating CUInt CFloat

Methods

toFloating :: Exp CUInt -> Exp CFloat

ToFloating CUInt CDouble

Methods

toFloating :: Exp CUInt -> Exp CDouble

ToFloating CUInt Half

Methods

toFloating :: Exp CUInt -> Exp Half

ToFloating CLong Double

Methods

toFloating :: Exp CLong -> Exp Double

ToFloating CLong Float

Methods

toFloating :: Exp CLong -> Exp Float

ToFloating CLong CFloat

Methods

toFloating :: Exp CLong -> Exp CFloat

ToFloating CLong CDouble

Methods

toFloating :: Exp CLong -> Exp CDouble

ToFloating CLong Half

Methods

toFloating :: Exp CLong -> Exp Half

ToFloating CULong Double

Methods

toFloating :: Exp CULong -> Exp Double

ToFloating CULong Float

Methods

toFloating :: Exp CULong -> Exp Float

ToFloating CULong CFloat

Methods

toFloating :: Exp CULong -> Exp CFloat

ToFloating CULong CDouble

Methods

toFloating :: Exp CULong -> Exp CDouble

ToFloating CULong Half

Methods

toFloating :: Exp CULong -> Exp Half

ToFloating CLLong Double

Methods

toFloating :: Exp CLLong -> Exp Double

ToFloating CLLong Float

Methods

toFloating :: Exp CLLong -> Exp Float

ToFloating CLLong CFloat

Methods

toFloating :: Exp CLLong -> Exp CFloat

ToFloating CLLong CDouble

Methods

toFloating :: Exp CLLong -> Exp CDouble

ToFloating CLLong Half

Methods

toFloating :: Exp CLLong -> Exp Half

ToFloating CULLong Double

Methods

toFloating :: Exp CULLong -> Exp Double

ToFloating CULLong Float

Methods

toFloating :: Exp CULLong -> Exp Float

ToFloating CULLong CFloat

Methods

toFloating :: Exp CULLong -> Exp CFloat

ToFloating CULLong CDouble

Methods

toFloating :: Exp CULLong -> Exp CDouble

ToFloating CULLong Half

Methods

toFloating :: Exp CULLong -> Exp Half

ToFloating CFloat Double

Methods

toFloating :: Exp CFloat -> Exp Double

ToFloating CFloat Float

Methods

toFloating :: Exp CFloat -> Exp Float

ToFloating CFloat CFloat

Methods

toFloating :: Exp CFloat -> Exp CFloat

ToFloating CFloat CDouble

Methods

toFloating :: Exp CFloat -> Exp CDouble

ToFloating CFloat Half

Methods

toFloating :: Exp CFloat -> Exp Half

ToFloating CDouble Double

Methods

toFloating :: Exp CDouble -> Exp Double

ToFloating CDouble Float

Methods

toFloating :: Exp CDouble -> Exp Float

ToFloating CDouble CFloat

Methods

toFloating :: Exp CDouble -> Exp CFloat

ToFloating CDouble CDouble

Methods

toFloating :: Exp CDouble -> Exp CDouble

ToFloating CDouble Half

Methods

toFloating :: Exp CDouble -> Exp Half

ToFloating Half Double

Methods

toFloating :: Exp Half -> Exp Double

ToFloating Half Float

Methods

toFloating :: Exp Half -> Exp Float

ToFloating Half CFloat

Methods

toFloating :: Exp Half -> Exp CFloat

ToFloating Half CDouble

Methods

toFloating :: Exp Half -> Exp CDouble

ToFloating Half Half

Methods

toFloating :: Exp Half -> Exp Half

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

class Lift c e where

The class of types e which can be lifted into c.

Minimal complete definition

lift

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

Associated Types

type Plain Bool :: *

Methods

lift :: Bool -> Exp (Plain Bool)

Lift Exp Char

Associated Types

type Plain Char :: *

Methods

lift :: Char -> Exp (Plain Char)

Lift Exp Double

Associated Types

type Plain Double :: *

Methods

lift :: Double -> Exp (Plain Double)

Lift Exp Float

Associated Types

type Plain Float :: *

Methods

lift :: Float -> Exp (Plain Float)

Lift Exp Int

Associated Types

type Plain Int :: *

Methods

lift :: Int -> Exp (Plain Int)

Lift Exp Int8

Associated Types

type Plain Int8 :: *

Methods

lift :: Int8 -> Exp (Plain Int8)

Lift Exp Int16

Associated Types

type Plain Int16 :: *

Methods

lift :: Int16 -> Exp (Plain Int16)

Lift Exp Int32

Associated Types

type Plain Int32 :: *

Methods

lift :: Int32 -> Exp (Plain Int32)

Lift Exp Int64

Associated Types

type Plain Int64 :: *

Methods

lift :: Int64 -> Exp (Plain Int64)

Lift Exp Word

Associated Types

type Plain Word :: *

Methods

lift :: Word -> Exp (Plain Word)

Lift Exp Word8

Associated Types

type Plain Word8 :: *

Methods

lift :: Word8 -> Exp (Plain Word8)

Lift Exp Word16

Associated Types

type Plain Word16 :: *

Methods

lift :: Word16 -> Exp (Plain Word16)

Lift Exp Word32

Associated Types

type Plain Word32 :: *

Methods

lift :: Word32 -> Exp (Plain Word32)

Lift Exp Word64

Associated Types

type Plain Word64 :: *

Methods

lift :: Word64 -> Exp (Plain Word64)

Lift Exp ()

Associated Types

type Plain () :: *

Methods

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

Lift Exp CChar

Associated Types

type Plain CChar :: *

Methods

lift :: CChar -> Exp (Plain CChar)

Lift Exp CSChar

Associated Types

type Plain CSChar :: *

Methods

lift :: CSChar -> Exp (Plain CSChar)

Lift Exp CUChar

Associated Types

type Plain CUChar :: *

Methods

lift :: CUChar -> Exp (Plain CUChar)

Lift Exp CShort

Associated Types

type Plain CShort :: *

Methods

lift :: CShort -> Exp (Plain CShort)

Lift Exp CUShort

Associated Types

type Plain CUShort :: *

Methods

lift :: CUShort -> Exp (Plain CUShort)

Lift Exp CInt

Associated Types

type Plain CInt :: *

Methods

lift :: CInt -> Exp (Plain CInt)

Lift Exp CUInt

Associated Types

type Plain CUInt :: *

Methods

lift :: CUInt -> Exp (Plain CUInt)

Lift Exp CLong

Associated Types

type Plain CLong :: *

Methods

lift :: CLong -> Exp (Plain CLong)

Lift Exp CULong

Associated Types

type Plain CULong :: *

Methods

lift :: CULong -> Exp (Plain CULong)

Lift Exp CLLong

Associated Types

type Plain CLLong :: *

Methods

lift :: CLLong -> Exp (Plain CLLong)

Lift Exp CULLong

Associated Types

type Plain CULLong :: *

Methods

lift :: CULLong -> Exp (Plain CULLong)

Lift Exp CFloat

Associated Types

type Plain CFloat :: *

Methods

lift :: CFloat -> Exp (Plain CFloat)

Lift Exp CDouble

Associated Types

type Plain CDouble :: *

Methods

lift :: CDouble -> Exp (Plain CDouble)

Lift Exp Z

Associated Types

type Plain Z :: *

Methods

lift :: Z -> Exp (Plain Z)

(Lift Exp a, Elt (Plain a)) => Lift Exp (Maybe a)

Associated Types

type Plain (Maybe a) :: *

Methods

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

(Lift Exp a, Elt (Plain a), Elt (Complex (Plain a))) => Lift Exp (Complex a)

Associated Types

type Plain (Complex a) :: *

Methods

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

(Lift Exp a, Elt (Plain a)) => Lift Exp (Min a)

Associated Types

type Plain (Min a) :: *

Methods

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

(Lift Exp a, Elt (Plain a)) => Lift Exp (Max a)

Associated Types

type Plain (Max a) :: *

Methods

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

(Lift Exp a, Elt (Plain a)) => Lift Exp (Sum a)

Associated Types

type Plain (Sum a) :: *

Methods

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

(Lift Exp a, Elt (Plain a)) => Lift Exp (Product a)

Associated Types

type Plain (Product a) :: *

Methods

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

Shape sh => Lift Exp (Any sh)

Associated Types

type Plain (Any sh) :: *

Methods

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

Lift Exp (Exp e)

Associated Types

type Plain (Exp e) :: *

Methods

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

Lift Acc (Acc a)

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)

Associated Types

type Plain (Either a b) :: *

Methods

lift :: Either a b -> Exp (Plain (Either a b))

(Lift Exp a, Lift Exp b, Elt (Plain a), Elt (Plain b)) => Lift Exp (a, b)

Associated Types

type Plain (a, b) :: *

Methods

lift :: (a, b) -> Exp (Plain (a, b))

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

Associated Types

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

Methods

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

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

Associated Types

type Plain (ix :. All) :: *

Methods

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

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

Associated Types

type Plain (ix :. Int) :: *

Methods

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

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

Associated Types

type Plain (a, b) :: *

Methods

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

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

Associated Types

type Plain (Array sh e) :: *

Methods

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

(Lift Exp a, Lift Exp b, Lift Exp c, Elt (Plain a), Elt (Plain b), Elt (Plain c)) => Lift Exp (a, b, c)

Associated Types

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

Methods

lift :: (a, b, c) -> Exp (Plain (a, b, c))

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

Associated Types

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

Methods

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

(Lift Exp a, Lift Exp b, Lift Exp c, Lift Exp d, Elt (Plain a), Elt (Plain b), Elt (Plain c), Elt (Plain d)) => Lift Exp (a, b, c, d)

Associated Types

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

Methods

lift :: (a, b, c, d) -> Exp (Plain (a, b, c, d))

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

Associated Types

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

Methods

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

(Lift Exp a, Lift Exp b, Lift Exp c, Lift Exp d, Lift Exp e, Elt (Plain a), Elt (Plain b), Elt (Plain c), Elt (Plain d), Elt (Plain e)) => Lift Exp (a, b, c, d, e)

Associated Types

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

Methods

lift :: (a, b, c, d, e) -> Exp (Plain (a, b, c, d, e))

(Lift Acc a, Lift Acc b, Lift Acc c, Lift Acc d, Lift Acc e, Arrays (Plain a), Arrays (Plain b), Arrays (Plain c), Arrays (Plain d), Arrays (Plain e)) => Lift Acc (a, b, c, d, e)

Associated Types

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

Methods

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

(Lift Exp a, Lift Exp b, Lift Exp c, Lift Exp d, Lift Exp e, Lift Exp f, Elt (Plain a), Elt (Plain b), Elt (Plain c), Elt (Plain d), Elt (Plain e), Elt (Plain f)) => Lift Exp (a, b, c, d, e, f)

Associated Types

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

Methods

lift :: (a, b, c, d, e, f) -> Exp (Plain (a, b, c, d, e, f))

(Lift Acc a, Lift Acc b, Lift Acc c, Lift Acc d, Lift Acc e, Lift Acc f, Arrays (Plain a), Arrays (Plain b), Arrays (Plain c), Arrays (Plain d), Arrays (Plain e), Arrays (Plain f)) => Lift Acc (a, b, c, d, e, f)

Associated Types

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

Methods

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

(Lift Exp a, Lift Exp b, Lift Exp c, Lift Exp d, Lift Exp e, Lift Exp f, Lift Exp g, Elt (Plain a), Elt (Plain b), Elt (Plain c), Elt (Plain d), Elt (Plain e), Elt (Plain f), Elt (Plain g)) => Lift Exp (a, b, c, d, e, f, g)

Associated Types

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

Methods

lift :: (a, b, c, d, e, f, g) -> Exp (Plain (a, b, c, d, e, f, g))

(Lift Acc a, Lift Acc b, Lift Acc c, Lift Acc d, Lift Acc e, Lift Acc f, Lift Acc g, Arrays (Plain a), Arrays (Plain b), Arrays (Plain c), Arrays (Plain d), Arrays (Plain e), Arrays (Plain f), Arrays (Plain g)) => Lift Acc (a, b, c, d, e, f, g)

Associated Types

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

Methods

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

(Lift Exp a, Lift Exp b, Lift Exp c, Lift Exp d, Lift Exp e, Lift Exp f, Lift Exp g, Lift Exp h, Elt (Plain a), Elt (Plain b), Elt (Plain c), Elt (Plain d), Elt (Plain e), Elt (Plain f), Elt (Plain g), Elt (Plain h)) => Lift Exp (a, b, c, d, e, f, g, h)

Associated Types

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

Methods

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

(Lift Acc a, Lift Acc b, Lift Acc c, Lift Acc d, Lift Acc e, Lift Acc f, Lift Acc g, Lift Acc h, Arrays (Plain a), Arrays (Plain b), Arrays (Plain c), Arrays (Plain d), Arrays (Plain e), Arrays (Plain f), Arrays (Plain g), Arrays (Plain h)) => Lift Acc (a, b, c, d, e, f, g, h)

Associated Types

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

Methods

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

(Lift Exp a, Lift Exp b, Lift Exp c, Lift Exp d, Lift Exp e, Lift Exp f, Lift Exp g, Lift Exp h, Lift Exp i, Elt (Plain a), Elt (Plain b), Elt (Plain c), Elt (Plain d), Elt (Plain e), Elt (Plain f), Elt (Plain g), Elt (Plain h), Elt (Plain i)) => Lift Exp (a, b, c, d, e, f, g, h, i)

Associated Types

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

Methods

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

(Lift Acc a, Lift Acc b, Lift Acc c, Lift Acc d, Lift Acc e, Lift Acc f, Lift Acc g, Lift Acc h, Lift Acc i, Arrays (Plain a), Arrays (Plain b), Arrays (Plain c), Arrays (Plain d), Arrays (Plain e), Arrays (Plain f), Arrays (Plain g), Arrays (Plain h), Arrays (Plain i)) => Lift Acc (a, b, c, d, e, f, g, h, i)

Associated Types

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

Methods

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

(Lift Exp a, Lift Exp b, Lift Exp c, Lift Exp d, Lift Exp e, Lift Exp f, Lift Exp g, Lift Exp h, Lift Exp i, Lift Exp j, Elt (Plain a), Elt (Plain b), Elt (Plain c), Elt (Plain d), Elt (Plain e), Elt (Plain f), Elt (Plain g), Elt (Plain h), Elt (Plain i), Elt (Plain j)) => Lift Exp (a, b, c, d, e, f, g, h, i, j)

Associated Types

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

Methods

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

(Lift Acc a, Lift Acc b, Lift Acc c, Lift Acc d, Lift Acc e, Lift Acc f, Lift Acc g, Lift Acc h, Lift Acc i, Lift Acc j, Arrays (Plain a), Arrays (Plain b), Arrays (Plain c), Arrays (Plain d), Arrays (Plain e), Arrays (Plain f), Arrays (Plain g), Arrays (Plain h), Arrays (Plain i), Arrays (Plain j)) => Lift Acc (a, b, c, d, e, f, g, h, i, j)

Associated Types

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

Methods

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

(Lift Exp a, Lift Exp b, Lift Exp c, Lift Exp d, Lift Exp e, Lift Exp f, Lift Exp g, Lift Exp h, Lift Exp i, Lift Exp j, Lift Exp k, Elt (Plain a), Elt (Plain b), Elt (Plain c), Elt (Plain d), Elt (Plain e), Elt (Plain f), Elt (Plain g), Elt (Plain h), Elt (Plain i), Elt (Plain j), Elt (Plain k)) => Lift Exp (a, b, c, d, e, f, g, h, i, j, k)

Associated Types

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

Methods

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

(Lift Acc a, Lift Acc b, Lift Acc c, Lift Acc d, Lift Acc e, Lift Acc f, Lift Acc g, Lift Acc h, Lift Acc i, Lift Acc j, Lift Acc k, Arrays (Plain a), Arrays (Plain b), Arrays (Plain c), Arrays (Plain d), Arrays (Plain e), Arrays (Plain f), Arrays (Plain g), Arrays (Plain h), Arrays (Plain i), Arrays (Plain j), Arrays (Plain k)) => Lift Acc (a, b, c, d, e, f, g, h, i, j, k)

Associated Types

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

Methods

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

(Lift Exp a, Lift Exp b, Lift Exp c, Lift Exp d, Lift Exp e, Lift Exp f, Lift Exp g, Lift Exp h, Lift Exp i, Lift Exp j, Lift Exp k, Lift Exp l, Elt (Plain a), Elt (Plain b), Elt (Plain c), Elt (Plain d), Elt (Plain e), Elt (Plain f), Elt (Plain g), Elt (Plain h), Elt (Plain i), Elt (Plain j), Elt (Plain k), Elt (Plain l)) => Lift Exp (a, b, c, d, e, f, g, h, i, j, k, l)

Associated Types

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

Methods

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

(Lift Acc a, Lift Acc b, Lift Acc c, Lift Acc d, Lift Acc e, Lift Acc f, Lift Acc g, Lift Acc h, Lift Acc i, Lift Acc j, Lift Acc k, Lift Acc l, Arrays (Plain a), Arrays (Plain b), Arrays (Plain c), Arrays (Plain d), Arrays (Plain e), Arrays (Plain f), Arrays (Plain g), Arrays (Plain h), Arrays (Plain i), Arrays (Plain j), Arrays (Plain k), Arrays (Plain l)) => Lift Acc (a, b, c, d, e, f, g, h, i, j, k, l)

Associated Types

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

Methods

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

(Lift Exp a, Lift Exp b, Lift Exp c, Lift Exp d, Lift Exp e, Lift Exp f, Lift Exp g, Lift Exp h, Lift Exp i, Lift Exp j, Lift Exp k, Lift Exp l, Lift Exp m, Elt (Plain a), Elt (Plain b), Elt (Plain c), Elt (Plain d), Elt (Plain e), Elt (Plain f), Elt (Plain g), Elt (Plain h), Elt (Plain i), Elt (Plain j), Elt (Plain k), Elt (Plain l), Elt (Plain m)) => Lift Exp (a, b, c, d, e, f, g, h, i, j, k, l, m)

Associated Types

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

Methods

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

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

Associated Types

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

Methods

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

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

Associated Types

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

Methods

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

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

Associated Types

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

Methods

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

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

Associated Types

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

Methods

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

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

Associated Types

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

Methods

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

class Lift c e => Unlift c e where

A limited subset of types which can be lifted, can also be unlifted.

Minimal complete definition

unlift

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

Methods

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

Unlift Exp Z

Methods

unlift :: Exp (Plain Z) -> Z

(Elt a, Elt (Complex a)) => Unlift Exp (Complex (Exp a))

Methods

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

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

Methods

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

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

Methods

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

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

Methods

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

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

Methods

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

Unlift Exp (Exp e)

Methods

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

Unlift Acc (Acc a)

Methods

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

(Elt a, Elt b) => Unlift Exp (Exp a, Exp b)

Methods

unlift :: Exp (Plain (Exp a, Exp b)) -> (Exp a, Exp b)

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

Methods

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

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

Methods

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

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

Methods

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

(Elt a, Elt b, Elt c) => Unlift Exp (Exp a, Exp b, Exp c)

Methods

unlift :: Exp (Plain (Exp a, Exp b, Exp c)) -> (Exp a, Exp b, Exp c)

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

Methods

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

(Elt a, Elt b, Elt c, Elt d) => Unlift Exp (Exp a, Exp b, Exp c, Exp d)

Methods

unlift :: Exp (Plain (Exp a, Exp b, Exp c, Exp d)) -> (Exp a, Exp b, Exp c, Exp d)

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

Methods

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

(Elt a, Elt b, Elt c, Elt d, Elt e) => Unlift Exp (Exp a, Exp b, Exp c, Exp d, Exp e)

Methods

unlift :: Exp (Plain (Exp a, Exp b, Exp c, Exp d, Exp e)) -> (Exp a, Exp b, Exp c, Exp d, Exp e)

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

Methods

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

(Elt a, Elt b, Elt c, Elt d, Elt e, Elt f) => Unlift Exp (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f)

Methods

unlift :: Exp (Plain (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f)) -> (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f)

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

Methods

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

(Elt a, Elt b, Elt c, Elt d, Elt e, Elt f, Elt g) => Unlift Exp (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f, Exp g)

Methods

unlift :: Exp (Plain (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f, Exp g)) -> (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f, Exp g)

(Arrays a, Arrays b, Arrays c, Arrays d, Arrays e, Arrays f, Arrays g) => Unlift Acc (Acc a, Acc b, Acc c, Acc d, Acc e, Acc f, Acc g)

Methods

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

(Elt a, Elt b, Elt c, Elt d, Elt e, Elt f, Elt g, Elt h) => Unlift Exp (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f, Exp g, Exp h)

Methods

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

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

Methods

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

(Elt a, Elt b, Elt c, Elt d, Elt e, Elt f, Elt g, Elt h, Elt i) => Unlift Exp (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f, Exp g, Exp h, Exp i)

Methods

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

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

Methods

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

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

Methods

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

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

Methods

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

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

Methods

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

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

Methods

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

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

Methods

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

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

Methods

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

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

Methods

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

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

Methods

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

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

Methods

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

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

Methods

unlift :: Acc (Plain (Acc a, Acc b, Acc c, Acc d, Acc e, Acc f, Acc g, Acc h, Acc i, Acc j, Acc k, Acc l, Acc m, Acc n)) -> (Acc a, Acc b, Acc c, Acc d, Acc e, Acc f, Acc g, Acc h, Acc i, Acc j, Acc k, Acc l, Acc m, Acc n)

(Elt a, Elt b, Elt c, Elt d, Elt e, Elt f, Elt g, Elt h, Elt i, Elt j, Elt k, Elt l, Elt m, Elt n, Elt o) => Unlift Exp (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f, Exp g, Exp h, Exp i, Exp j, Exp k, Exp l, Exp m, Exp n, Exp o)

Methods

unlift :: Exp (Plain (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f, Exp g, Exp h, Exp i, Exp j, Exp k, Exp l, Exp m, Exp n, Exp o)) -> (Exp a, Exp b, Exp c, Exp d, Exp e, Exp f, Exp g, Exp h, Exp i, Exp j, Exp k, Exp l, Exp m, Exp n, Exp o)

(Arrays a, Arrays b, Arrays c, Arrays d, Arrays e, Arrays f, Arrays g, Arrays h, Arrays i, Arrays j, Arrays k, Arrays l, Arrays m, Arrays n, Arrays o) => Unlift Acc (Acc a, Acc b, Acc c, Acc d, Acc e, Acc f, Acc g, Acc h, Acc i, Acc j, Acc k, Acc l, Acc m, Acc n, Acc o)

Methods

unlift :: Acc (Plain (Acc a, Acc b, Acc c, Acc d, Acc e, Acc f, Acc g, Acc h, Acc i, Acc j, Acc k, Acc l, Acc m, Acc n, Acc o)) -> (Acc a, Acc b, Acc c, Acc d, Acc e, Acc f, Acc g, Acc h, Acc i, Acc j, Acc k, Acc l, Acc m, Acc n, Acc o)

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.

Scalar operations

Introduction

constant :: Elt t => t -> Exp t

Scalar expression inlet: make a Haskell value available for processing in an Accelerate scalar expression.

Note that this embeds the value directly into the expression. Depending on the backend used to execute the computation, this might not always be desirable. For example, a backend that does external code generation may embed this constant directly into the generated code, which means new code will need to be generated and compiled every time the value changes. In such cases, consider instead lifting scalar values into (singleton) arrays so that they can be passed as an input to the computation and thus the value can change without the need to generate fresh code.

Tuples

fst :: forall a b. (Elt a, Elt b) => Exp (a, b) -> Exp a

Extract the first component of a scalar pair.

afst :: forall a b. (Arrays a, Arrays b) => Acc (a, b) -> Acc a

Extract the first component of an array pair.

snd :: forall a b. (Elt a, Elt b) => Exp (a, b) -> Exp b

Extract the second component of a scalar pair.

asnd :: forall a b. (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.

caseof

Arguments

:: (Elt a, Elt b)

=> Exp a

case subject

-> [(Exp a -> Exp Bool, Exp b)]

list of cases to attempt

-> Exp b

default value

-> Exp b

A case-like control structure

cond

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

:: Elt e

=> (Exp e -> Exp Bool)

keep evaluating while this returns True

-> (Exp e -> Exp e)

function to apply

-> Exp e

initial value

-> Exp e

While construct. Continue to apply the given function, starting with the initial value, until the test function evaluates to False.

iterate :: forall a. Elt a => Exp Int -> (Exp a -> Exp a) -> Exp a -> Exp a

Repeatedly apply a function a fixed number of times

Scalar reduction

sfoldl :: forall sh a b. (Shape sh, Slice sh, Elt a, Elt b) => (Exp a -> Exp b -> Exp a) -> Exp a -> Exp sh -> Acc (Array (sh :. Int) b) -> Exp a

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, Slice (Z :. i)) => Exp i -> Exp i -> Exp ((Z :. i) :. i)

Creates a rank-2 index from two Exp Int`s

unindex2 :: forall i. (Elt i, Slice (Z :. i)) => Exp ((Z :. i) :. i) -> Exp (i, i)

Destructs a rank-2 index to an Exp tuple of two Int`s.

index3 :: (Elt i, Slice (Z :. i), Slice ((Z :. i) :. i)) => Exp i -> Exp i -> Exp i -> Exp (((Z :. i) :. i) :. i)

Create a rank-3 index from three Exp Int`s

unindex3 :: forall i. (Elt i, Slice (Z :. i), Slice ((Z :. i) :. i)) => Exp (((Z :. i) :. i) :. i) -> Exp (i, i, i)

Destruct a rank-3 index into an Exp tuple of Int`s

indexHead :: (Slice 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 :: (Slice sh, Elt a) => Exp (sh :. a) -> Exp sh

Get all but the innermost element of a shape

toIndex

Arguments

:: Shape sh

=> Exp sh

extent of the array

-> Exp sh

index to remap

-> Exp Int

Map a multi-dimensional index into a linear, row-major representation of an array.

fromIndex :: Shape sh => Exp sh -> Exp Int -> Exp sh

Inverse of toIndex

intersect :: 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 (EltRepr a), IsScalar (EltRepr b), BitSizeEq (EltRepr a) (EltRepr 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 :: (Arrays as, Arrays bs, Foreign asm) => asm (as -> 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 :: (Elt x, Elt y, Foreign asm) => asm (x -> 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 :: Shape sh => sh -> Int

Rank of an array.

arrayShape :: Shape sh => Array sh e -> sh

Array shape in plain Haskell code.

arraySize :: Shape sh => sh -> Int

Total number of elements in an array of the given Shape.

arrayReshape :: (Shape sh, Shape sh', Elt e) => 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 :: Array sh e -> sh -> e

Array indexing in plain Haskell code.

linearIndexArray :: 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 :: (Shape sh, Elt e) => sh -> (sh -> IO e) -> IO (Array sh e)

Create an array using a monadic function applied at each index.

Lists

fromList :: (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. Array sh e -> [e]

Convert an accelerated Array to a list in row-major order.

Prelude re-exports

(.) :: (b -> c) -> (a -> b) -> a -> c infixr 9

Function composition.

($) :: (a -> b) -> a -> b infixr 0

Application operator. This operator is redundant, since ordinary application (f x) means the same as (f $ x). However, $ has low, right-associative binding precedence, so it sometimes allows parentheses to be omitted; for example:

f $ g $ h x  =  f (g (h x))

It is also useful in higher-order situations, such as map ($ 0) xs, or zipWith ($) fs xs.

error :: HasCallStack => [Char] -> a

error stops execution and displays an error message.

undefined :: HasCallStack => a

A special case of error. It is expected that compilers will recognize this and insert error messages which are more appropriate to the context in which undefined appears.

const :: a -> b -> a

const x is a unary function which evaluates to x for all inputs.

>>> const 42 "hello"
42

>>> map (const 42) [0..3]
[42,42,42,42]

data Int

A fixed-precision integer type with at least the range [-2^29 .. 2^29-1]. The exact range for a given implementation can be determined by using minBound and maxBound from the Bounded class.

Instances

Bounded Int

Since: 2.1

Methods

minBound :: Int

maxBound :: Int

Enum Int

Since: 2.1

Methods

succ :: Int -> Int

pred :: Int -> Int

toEnum :: Int -> Int

fromEnum :: Int -> Int

enumFrom :: Int -> [Int]

enumFromThen :: Int -> Int -> [Int]

enumFromTo :: Int -> Int -> [Int]

enumFromThenTo :: Int -> Int -> Int -> [Int]

Eq Int

Methods

(==) :: Int -> Int -> Bool

(/=) :: Int -> Int -> Bool

Integral Int

Since: 2.0.1

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: 2.1

Methods

(+) :: Int -> Int -> Int

(-) :: Int -> Int -> Int

(*) :: Int -> Int -> Int

negate :: Int -> Int

abs :: Int -> Int

signum :: Int -> Int

fromInteger :: Integer -> Int

Ord Int

Methods

compare :: Int -> Int -> Ordering

(<) :: Int -> Int -> Bool

(<=) :: Int -> Int -> Bool

(>) :: Int -> Int -> Bool

(>=) :: Int -> Int -> Bool

max :: Int -> Int -> Int

min :: Int -> Int -> Int

Read Int

Since: 2.1

Methods

readsPrec :: Int -> ReadS Int

readList :: ReadS [Int]

readPrec :: ReadPrec Int

readListPrec :: ReadPrec [Int]

Real Int

Since: 2.0.1

Methods

toRational :: Int -> Rational

Show Int

Since: 2.1

Methods

showsPrec :: Int -> Int -> ShowS

show :: Int -> String

showList :: [Int] -> ShowS

Lift Int

Methods

lift :: Int -> Q Exp

Pretty Int

Methods

pretty :: Int -> Doc

prettyList :: [Int] -> Doc

PrintfArg Int

Since: 2.1

Methods

formatArg :: Int -> FieldFormatter

parseFormat :: Int -> ModifierParser

Storable Int

Since: 2.1

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: 2.1

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: 4.6.0.0

Methods

finiteBitSize :: Int -> Int

countLeadingZeros :: Int -> Int

countTrailingZeros :: Int -> Int

PrimType Int

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

Subtractive Int

Associated Types

type Difference Int :: *

Methods

(-) :: Int -> Int -> Difference Int

NFData Int

Methods

rnf :: Int -> ()

Hashable Int

Methods

hashWithSalt :: Int -> Int -> Int

hash :: Int -> Int

Prim Int

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

Pretty Int

Methods

pretty :: Int -> Doc b

prettyList :: [Int] -> Doc b

IsScalar Int

Methods

scalarType :: ScalarType Int

IsBounded Int

Methods

boundedType :: BoundedType Int

IsNum Int

Methods

numType :: NumType Int

IsIntegral Int

Methods

integralType :: IntegralType Int

Elt Int

Methods

eltType :: Int -> TupleType (EltRepr Int)

fromElt :: Int -> EltRepr Int

toElt :: EltRepr Int -> Int

Eq Int

Methods

(==) :: Exp Int -> Exp Int -> Exp Bool

(/=) :: Exp Int -> Exp Int -> Exp Bool

Ord Int

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

Methods

finiteBitSize :: Exp Int -> Exp Int

countLeadingZeros :: Exp Int -> Exp Int

countTrailingZeros :: Exp Int -> Exp Int

Bits Int

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

Vector Vector Int

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.

Methods

imap :: (Int -> a -> b) -> [a] -> [b]

imapped :: (Indexable Int p, Settable f) => p a (f b) -> [a] -> f [b]

FunctorWithIndex Int ZipList

Same instance as for [].

Methods

imap :: (Int -> a -> b) -> ZipList a -> ZipList b

imapped :: (Indexable Int p, Settable f) => p a (f b) -> ZipList a -> f (ZipList b)

FunctorWithIndex Int NonEmpty

Methods

imap :: (Int -> a -> b) -> NonEmpty a -> NonEmpty b

imapped :: (Indexable Int p, Settable f) => p a (f b) -> NonEmpty a -> f (NonEmpty b)

FunctorWithIndex Int IntMap

Methods

imap :: (Int -> a -> b) -> IntMap a -> IntMap b

imapped :: (Indexable Int p, Settable f) => p a (f b) -> IntMap a -> f (IntMap b)

FunctorWithIndex Int Seq

The position in the Seq is available as the index.

Methods

imap :: (Int -> a -> b) -> Seq a -> Seq b

imapped :: (Indexable Int p, Settable f) => p a (f b) -> Seq a -> f (Seq b)

FunctorWithIndex Int Vector

Methods

imap :: (Int -> a -> b) -> Vector a -> Vector b

imapped :: (Indexable Int p, Settable f) => p a (f b) -> Vector a -> f (Vector b)

FoldableWithIndex Int []

Methods

ifoldMap :: Monoid m => (Int -> a -> m) -> [a] -> m

ifolded :: (Indexable Int p, Contravariant f, Applicative f) => p a (f a) -> [a] -> f [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

Methods

ifoldMap :: Monoid m => (Int -> a -> m) -> ZipList a -> m

ifolded :: (Indexable Int p, Contravariant f, Applicative f) => p a (f a) -> ZipList a -> f (ZipList 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

Methods

ifoldMap :: Monoid m => (Int -> a -> m) -> NonEmpty a -> m

ifolded :: (Indexable Int p, Contravariant f, Applicative f) => p a (f a) -> NonEmpty a -> f (NonEmpty 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

Methods

ifoldMap :: Monoid m => (Int -> a -> m) -> IntMap a -> m

ifolded :: (Indexable Int p, Contravariant f, Applicative f) => p a (f a) -> IntMap a -> f (IntMap 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

Methods

ifoldMap :: Monoid m => (Int -> a -> m) -> Seq a -> m

ifolded :: (Indexable Int p, Contravariant f, Applicative f) => p a (f a) -> Seq a -> f (Seq 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

Methods

ifoldMap :: Monoid m => (Int -> a -> m) -> Vector a -> m

ifolded :: (Indexable Int p, Contravariant f, Applicative f) => p a (f a) -> Vector a -> f (Vector 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 []

Methods

itraverse :: Applicative f => (Int -> a -> f b) -> [a] -> f [b]

itraversed :: (Indexable Int p, Applicative f) => p a (f b) -> [a] -> f [b]

TraversableWithIndex Int ZipList

Methods

itraverse :: Applicative f => (Int -> a -> f b) -> ZipList a -> f (ZipList b)

itraversed :: (Indexable Int p, Applicative f) => p a (f b) -> ZipList a -> f (ZipList b)

TraversableWithIndex Int NonEmpty

Methods

itraverse :: Applicative f => (Int -> a -> f b) -> NonEmpty a -> f (NonEmpty b)

itraversed :: (Indexable Int p, Applicative f) => p a (f b) -> NonEmpty a -> f (NonEmpty b)

TraversableWithIndex Int IntMap

Methods

itraverse :: Applicative f => (Int -> a -> f b) -> IntMap a -> f (IntMap b)

itraversed :: (Indexable Int p, Applicative f) => p a (f b) -> IntMap a -> f (IntMap b)

TraversableWithIndex Int Seq

Methods

itraverse :: Applicative f => (Int -> a -> f b) -> Seq a -> f (Seq b)

itraversed :: (Indexable Int p, Applicative f) => p a (f b) -> Seq a -> f (Seq b)

TraversableWithIndex Int Vector

Methods

itraverse :: Applicative f => (Int -> a -> f b) -> Vector a -> f (Vector b)

itraversed :: (Indexable Int p, Applicative f) => p a (f b) -> Vector a -> f (Vector b)

TraverseMin Int IntMap

Methods

traverseMin :: (Indexable Int p, Applicative f) => p v (f v) -> IntMap v -> f (IntMap v)

TraverseMax Int IntMap

Methods

traverseMax :: (Indexable Int p, Applicative f) => p v (f v) -> IntMap v -> f (IntMap v)

MVector MVector Int

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)

Lift Exp Int

Associated Types

type Plain Int :: *

Methods

lift :: Int -> Exp (Plain Int)

ToFloating Int Double

Methods

toFloating :: Exp Int -> Exp Double

ToFloating Int Float

Methods

toFloating :: Exp Int -> Exp Float

ToFloating Int CFloat

Methods

toFloating :: Exp Int -> Exp CFloat

ToFloating Int CDouble

Methods

toFloating :: Exp Int -> Exp CDouble

ToFloating Int Half

Methods

toFloating :: Exp Int -> Exp Half

FromIntegral Int Double

Methods

fromIntegral :: Exp Int -> Exp Double

FromIntegral Int Float

Methods

fromIntegral :: Exp Int -> Exp Float

FromIntegral Int Int

Methods

fromIntegral :: Exp Int -> Exp Int

FromIntegral Int Int8

Methods

fromIntegral :: Exp Int -> Exp Int8

FromIntegral Int Int16

Methods

fromIntegral :: Exp Int -> Exp Int16

FromIntegral Int Int32

Methods

fromIntegral :: Exp Int -> Exp Int32

FromIntegral Int Int64

Methods

fromIntegral :: Exp Int -> Exp Int64

FromIntegral Int Word

Methods

fromIntegral :: Exp Int -> Exp Word

FromIntegral Int Word8

Methods

fromIntegral :: Exp Int -> Exp Word8

FromIntegral Int Word16

Methods

fromIntegral :: Exp Int -> Exp Word16

FromIntegral Int Word32

Methods

fromIntegral :: Exp Int -> Exp Word32

FromIntegral Int Word64

Methods

fromIntegral :: Exp Int -> Exp Word64

FromIntegral Int CShort

Methods

fromIntegral :: Exp Int -> Exp CShort

FromIntegral Int CUShort

Methods

fromIntegral :: Exp Int -> Exp CUShort

FromIntegral Int CInt

Methods

fromIntegral :: Exp Int -> Exp CInt

FromIntegral Int CUInt

Methods

fromIntegral :: Exp Int -> Exp CUInt

FromIntegral Int CLong

Methods

fromIntegral :: Exp Int -> Exp CLong

FromIntegral Int CULong

Methods

fromIntegral :: Exp Int -> Exp CULong

FromIntegral Int CLLong

Methods

fromIntegral :: Exp Int -> Exp CLLong

FromIntegral Int CULLong

Methods

fromIntegral :: Exp Int -> Exp CULLong

FromIntegral Int CFloat

Methods

fromIntegral :: Exp Int -> Exp CFloat

FromIntegral Int CDouble

Methods

fromIntegral :: Exp Int -> Exp CDouble

FromIntegral Int Half

Methods

fromIntegral :: Exp Int -> Exp Half

FromIntegral Int8 Int

Methods

fromIntegral :: Exp Int8 -> Exp Int

FromIntegral Int16 Int

Methods

fromIntegral :: Exp Int16 -> Exp Int

FromIntegral Int32 Int

Methods

fromIntegral :: Exp Int32 -> Exp Int

FromIntegral Int64 Int

Methods

fromIntegral :: Exp Int64 -> Exp Int

FromIntegral Word Int

Methods

fromIntegral :: Exp Word -> Exp Int

FromIntegral Word8 Int

Methods

fromIntegral :: Exp Word8 -> Exp Int

FromIntegral Word16 Int

Methods

fromIntegral :: Exp Word16 -> Exp Int

FromIntegral Word32 Int

Methods

fromIntegral :: Exp Word32 -> Exp Int

FromIntegral Word64 Int

Methods

fromIntegral :: Exp Word64 -> Exp Int

FromIntegral CShort Int

Methods

fromIntegral :: Exp CShort -> Exp Int

FromIntegral CUShort Int

Methods

fromIntegral :: Exp CUShort -> Exp Int

FromIntegral CInt Int

Methods

fromIntegral :: Exp CInt -> Exp Int

FromIntegral CUInt Int

Methods

fromIntegral :: Exp CUInt -> Exp Int

FromIntegral CLong Int

Methods

fromIntegral :: Exp CLong -> Exp Int

FromIntegral CULong Int

Methods

fromIntegral :: Exp CULong -> Exp Int

FromIntegral CLLong Int

Methods

fromIntegral :: Exp CLLong -> Exp Int

FromIntegral CULLong Int

Methods

fromIntegral :: Exp CULLong -> Exp Int

Elt e => Stencil DIM1 e (Exp e, Exp e, Exp e)

Associated Types

type StencilRepr DIM1 (Exp e, Exp e, Exp e) :: *

Methods

stencilPrj :: DIM1 -> e -> Exp (StencilRepr DIM1 (Exp e, Exp e, Exp e)) -> (Exp e, Exp e, Exp e)

Elt e => Stencil DIM1 e (Exp e, Exp e, Exp e, Exp e, Exp e)

Associated Types

type StencilRepr DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e) :: *

Methods

stencilPrj :: DIM1 -> e -> Exp (StencilRepr DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e)) -> (Exp e, Exp e, Exp e, Exp e, Exp e)

Elt e => Stencil DIM1 e (Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e)

Associated Types

type StencilRepr DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e) :: *

Methods

stencilPrj :: DIM1 -> e -> Exp (StencilRepr DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e)) -> (Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e)

Elt e => Stencil DIM1 e (Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e)

Associated Types

type StencilRepr DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e) :: *

Methods

stencilPrj :: DIM1 -> e -> Exp (StencilRepr DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e)) -> (Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e)

() :=> (Bounded Int)

Methods

ins :: () :- Bounded Int

() :=> (Enum Int)

Methods

ins :: () :- Enum Int

() :=> (Eq Int)

Methods

ins :: () :- Eq Int

() :=> (Integral Int)

Methods

ins :: () :- Integral Int

() :=> (Num Int)

Methods

ins :: () :- Num Int

() :=> (Ord Int)

Methods

ins :: () :- Ord Int

() :=> (Read Int)

Methods

ins :: () :- Read Int

() :=> (Real Int)

Methods

ins :: () :- Real Int

() :=> (Show Int)

Methods

ins :: () :- Show Int

() :=> (Bits Int)

Methods

ins :: () :- Bits Int

Generic1 (URec Int :: k -> *)

Associated Types

type Rep1 (URec Int) :: k -> *

Methods

from1 :: URec Int a -> Rep1 (URec Int) a

to1 :: Rep1 (URec Int) a -> URec Int a

(Slice (Plain ix), Lift Exp ix) => Lift Exp (ix :. Int)

Associated Types

type Plain (ix :. Int) :: *

Methods

lift :: (ix :. Int) -> Exp (Plain (ix :. Int))

Elt e => IsList (Vector e)

Associated Types

type Item (Vector e) :: *

Methods

fromList :: [Item (Vector e)] -> Vector e

fromListN :: Int -> [Item (Vector e)] -> Vector e

toList :: Vector e -> [Item (Vector e)]

Bounded (Exp Int)

Methods

minBound :: Exp Int

maxBound :: Exp Int

Enum (Exp Int)

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)

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)

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

Show (Vector e)

Methods

showsPrec :: Int -> Vector e -> ShowS

show :: Vector e -> String

showList :: [Vector e] -> ShowS

Shape sh => Elt (Any (sh :. Int))

Methods

eltType :: Any (sh :. Int) -> TupleType (EltRepr (Any (sh :. Int)))

fromElt :: Any (sh :. Int) -> EltRepr (Any (sh :. Int))

toElt :: EltRepr (Any (sh :. Int)) -> Any (sh :. Int)

FunctorWithIndex [Int] Tree

Methods

imap :: ([Int] -> a -> b) -> Tree a -> Tree b

imapped :: (Indexable [Int] p, Settable f) => p a (f b) -> Tree a -> f (Tree b)

FoldableWithIndex [Int] Tree

Methods

ifoldMap :: Monoid m => ([Int] -> a -> m) -> Tree a -> m

ifolded :: (Indexable [Int] p, Contravariant f, Applicative f) => p a (f a) -> Tree a -> f (Tree 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

Methods

itraverse :: Applicative f => ([Int] -> a -> f b) -> Tree a -> f (Tree b)

itraversed :: (Indexable [Int] p, Applicative f) => p a (f b) -> Tree a -> f (Tree b)

Bizarre (Indexed Int) Mafic

Methods

bazaar :: Applicative f => Indexed Int a (f b) -> Mafic a b t -> f t

Reifies Z Int

Methods

reflect :: proxy Z -> Int

Reifies n Int => Reifies (D n :: *) Int

Methods

reflect :: proxy (D n) -> Int

Reifies n Int => Reifies (SD n :: *) Int

Methods

reflect :: proxy (SD n) -> Int

Reifies n Int => Reifies (PD n :: *) Int

Methods

reflect :: proxy (PD n) -> Int

Functor (URec Int :: * -> *)

Methods

fmap :: (a -> b) -> URec Int a -> URec Int b

(<$) :: a -> URec Int b -> URec Int a

Show (Array DIM2 e)

Methods

showsPrec :: Int -> Array DIM2 e -> ShowS

show :: Array DIM2 e -> String

showList :: [Array DIM2 e] -> ShowS

Foldable (URec Int :: * -> *)

Methods

fold :: Monoid m => URec Int m -> m

foldMap :: Monoid m => (a -> m) -> URec Int a -> m

foldr :: (a -> b -> b) -> b -> URec Int a -> b

foldr' :: (a -> b -> b) -> b -> URec Int a -> b

foldl :: (b -> a -> b) -> b -> URec Int a -> b

foldl' :: (b -> a -> b) -> b -> URec Int a -> b

foldr1 :: (a -> a -> a) -> URec Int a -> a

foldl1 :: (a -> a -> a) -> URec Int a -> a

toList :: URec Int a -> [a]

null :: URec Int a -> Bool

length :: URec Int a -> Int

elem :: Eq a => a -> URec Int a -> Bool

maximum :: Ord a => URec Int a -> a

minimum :: Ord a => URec Int a -> a

sum :: Num a => URec Int a -> a

product :: Num a => URec Int a -> a

Traversable (URec Int :: * -> *)

Methods

traverse :: Applicative f => (a -> f b) -> URec Int a -> f (URec Int b)

sequenceA :: Applicative f => URec Int (f a) -> f (URec Int a)

mapM :: Monad m => (a -> m b) -> URec Int a -> m (URec Int b)

sequence :: Monad m => URec Int (m a) -> m (URec Int a)

Slice sl => Slice (sl :. Int)

Associated Types

type SliceShape (sl :. Int) :: *

type CoSliceShape (sl :. Int) :: *

type FullShape (sl :. Int) :: *

Methods

sliceIndex :: (sl :. Int) -> SliceIndex (EltRepr (sl :. Int)) (EltRepr (SliceShape (sl :. Int))) (EltRepr (CoSliceShape (sl :. Int))) (EltRepr (FullShape (sl :. Int)))

Shape sh => Shape (sh :. Int)

Methods

rank :: (sh :. Int) -> Int

size :: (sh :. Int) -> Int

empty :: sh :. Int

ignore :: sh :. Int

intersect :: (sh :. Int) -> (sh :. Int) -> sh :. Int

union :: (sh :. Int) -> (sh :. Int) -> sh :. Int

toIndex :: (sh :. Int) -> (sh :. Int) -> Int

fromIndex :: (sh :. Int) -> Int -> sh :. Int

iter :: (sh :. Int) -> ((sh :. Int) -> a) -> (a -> a -> a) -> a -> a

iter1 :: (sh :. Int) -> ((sh :. Int) -> a) -> (a -> a -> a) -> a

rangeToShape :: (sh :. Int, sh :. Int) -> sh :. Int

shapeToRange :: (sh :. Int) -> (sh :. Int, sh :. Int)

shapeToList :: (sh :. Int) -> [Int]

listToShape :: [Int] -> sh :. Int

sliceAnyIndex :: (sh :. Int) -> SliceIndex (EltRepr (Any (sh :. Int))) (EltRepr (sh :. Int)) () (EltRepr (sh :. Int))

sliceNoneIndex :: (sh :. Int) -> SliceIndex (EltRepr (sh :. Int)) () (EltRepr (sh :. Int)) (EltRepr (sh :. Int))

(Stencil (sh :. Int) a row2, Stencil (sh :. Int) a row1, Stencil (sh :. Int) a row0) => Stencil ((sh :. Int) :. Int) a (row2, row1, row0)

Associated Types

type StencilRepr ((sh :. Int) :. Int) (row2, row1, row0) :: *

Methods

stencilPrj :: ((sh :. Int) :. Int) -> a -> Exp (StencilRepr ((sh :. Int) :. Int) (row2, row1, row0)) -> (row2, row1, row0)

(Stencil (sh :. Int) a row1, Stencil (sh :. Int) a row2, Stencil (sh :. Int) a row3, Stencil (sh :. Int) a row4, Stencil (sh :. Int) a row5) => Stencil ((sh :. Int) :. Int) a (row1, row2, row3, row4, row5)

Associated Types

type StencilRepr ((sh :. Int) :. Int) (row1, row2, row3, row4, row5) :: *

Methods

stencilPrj :: ((sh :. Int) :. Int) -> a -> Exp (StencilRepr ((sh :. Int) :. Int) (row1, row2, row3, row4, row5)) -> (row1, row2, row3, row4, row5)

(Stencil (sh :. Int) a row1, Stencil (sh :. Int) a row2, Stencil (sh :. Int) a row3, Stencil (sh :. Int) a row4, Stencil (sh :. Int) a row5, Stencil (sh :. Int) a row6, Stencil (sh :. Int) a row7) => Stencil ((sh :. Int) :. Int) a (row1, row2, row3, row4, row5, row6, row7)

Associated Types

type StencilRepr ((sh :. Int) :. Int) (row1, row2, row3, row4, row5, row6, row7) :: *

Methods

stencilPrj :: ((sh :. Int) :. Int) -> a -> Exp (StencilRepr ((sh :. Int) :. Int) (row1, row2, row3, row4, row5, row6, row7)) -> (row1, row2, row3, row4, row5, row6, row7)

(Stencil (sh :. Int) a row1, Stencil (sh :. Int) a row2, Stencil (sh :. Int) a row3, Stencil (sh :. Int) a row4, Stencil (sh :. Int) a row5, Stencil (sh :. Int) a row6, Stencil (sh :. Int) a row7, Stencil (sh :. Int) a row8, Stencil (sh :. Int) a row9) => Stencil ((sh :. Int) :. Int) a (row1, row2, row3, row4, row5, row6, row7, row8, row9)

Associated Types

type StencilRepr ((sh :. Int) :. Int) (row1, row2, row3, row4, row5, row6, row7, row8, row9) :: *

Methods

stencilPrj :: ((sh :. Int) :. Int) -> a -> Exp (StencilRepr ((sh :. Int) :. Int) (row1, row2, row3, row4, row5, row6, row7, row8, row9)) -> (row1, row2, row3, row4, row5, row6, row7, row8, row9)

Eq (URec Int p)

Methods

(==) :: URec Int p -> URec Int p -> Bool

(/=) :: URec Int p -> URec Int p -> Bool

Ord (URec Int p)

Methods

compare :: URec Int p -> URec Int p -> Ordering

(<) :: URec Int p -> URec Int p -> Bool

(<=) :: URec Int p -> URec Int p -> Bool

(>) :: URec Int p -> URec Int p -> Bool

(>=) :: URec Int p -> URec Int p -> Bool

max :: URec Int p -> URec Int p -> URec Int p

min :: URec Int p -> URec Int p -> URec Int p

Show (URec Int p)

Methods

showsPrec :: Int -> URec Int p -> ShowS

show :: URec Int p -> String

showList :: [URec Int p] -> ShowS

Generic (URec Int p)

Associated Types

type Rep (URec Int p) :: * -> *

Methods

from :: URec Int p -> Rep (URec Int p) x

to :: Rep (URec Int p) x -> URec Int p

type PrimSize Int

type PrimSize Int = 8

type Difference Int

type Difference Int = Int

type NatNumMaxBound Int

type NatNumMaxBound Int = NatNumMaxBound Int64

data Vector Int

data Vector Int = V_Int (Vector Int)

type Plain Int

type Plain Int = Int

data URec Int (p :: k)

Used for marking occurrences of Int#

Since: 4.9.0.0

data URec Int (p :: k) = UInt {

• uInt# :: Int#

}

data MVector s Int

data MVector s Int = MV_Int (MVector s Int)

type Rep1 (URec Int :: k -> *)

type Rep1 (URec Int :: k -> *) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UInt" PrefixI True) (S1 (MetaSel (Just "uInt#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (UInt :: k -> *)))

type Item (Vector e)

type Item (Vector e) = e

type SliceShape (sl :. Int)

type SliceShape (sl :. Int) = SliceShape sl

type CoSliceShape (sl :. Int)

type CoSliceShape (sl :. Int) = CoSliceShape sl :. Int

type FullShape (sl :. Int)

type FullShape (sl :. Int) = FullShape sl :. Int

type Plain (ix :. Int)

type Plain (ix :. Int) = Plain ix :. Int

type Rep (URec Int p)

type Rep (URec Int p) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UInt" PrefixI True) (S1 (MetaSel (Just "uInt#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (UInt :: * -> *)))

data Int8

8-bit signed integer type

Instances

Bounded Int8

Since: 2.1

Methods

minBound :: Int8

maxBound :: Int8

Enum Int8

Since: 2.1

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: 2.1

Methods

(==) :: Int8 -> Int8 -> Bool

(/=) :: Int8 -> Int8 -> Bool

Integral Int8

Since: 2.1

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: 2.1

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: 2.1

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: 2.1

Methods

readsPrec :: Int -> ReadS Int8

readList :: ReadS [Int8]

readPrec :: ReadPrec Int8

readListPrec :: ReadPrec [Int8]

Real Int8

Since: 2.1

Methods

toRational :: Int8 -> Rational

Show Int8

Since: 2.1

Methods

showsPrec :: Int -> Int8 -> ShowS

show :: Int8 -> String

showList :: [Int8] -> ShowS

Ix Int8

Since: 2.1

Methods

range :: (Int8, Int8) -> [Int8]

index :: (Int8, Int8) -> Int8 -> Int

unsafeIndex :: (Int8, Int8) -> Int8 -> Int

inRange :: (Int8, Int8) -> Int8 -> Bool

rangeSize :: (Int8, Int8) -> Int

unsafeRangeSize :: (Int8, Int8) -> Int

Lift Int8

Methods

lift :: Int8 -> Q Exp

PrintfArg Int8

Since: 2.1

Methods

formatArg :: Int8 -> FieldFormatter

parseFormat :: Int8 -> ModifierParser

Storable Int8

Since: 2.1

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: 2.1

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: 4.6.0.0

Methods

finiteBitSize :: Int8 -> Int

countLeadingZeros :: Int8 -> Int

countTrailingZeros :: Int8 -> Int

PrimType Int8

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

Subtractive Int8

Associated Types

type Difference Int8 :: *

Methods

(-) :: Int8 -> Int8 -> Difference Int8

NFData Int8

Methods

rnf :: Int8 -> ()

Hashable Int8

Methods

hashWithSalt :: Int -> Int8 -> Int

hash :: Int8 -> Int

Prim Int8

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

Pretty Int8

Methods

pretty :: Int8 -> Doc b

prettyList :: [Int8] -> Doc b

IsScalar Int8

Methods

scalarType :: ScalarType Int8

IsBounded Int8

Methods

boundedType :: BoundedType Int8

IsNum Int8

Methods

numType :: NumType Int8

IsIntegral Int8

Methods

integralType :: IntegralType Int8

Elt Int8

Methods

eltType :: Int8 -> TupleType (EltRepr Int8)

fromElt :: Int8 -> EltRepr Int8

toElt :: EltRepr Int8 -> Int8

Eq Int8

Methods

(==) :: Exp Int8 -> Exp Int8 -> Exp Bool

(/=) :: Exp Int8 -> Exp Int8 -> Exp Bool

Ord Int8

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

Methods

finiteBitSize :: Exp Int8 -> Exp Int

countLeadingZeros :: Exp Int8 -> Exp Int

countTrailingZeros :: Exp Int8 -> Exp Int

Bits Int8

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

Vector Vector Int8

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

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)

Lift Exp Int8

Associated Types

type Plain Int8 :: *

Methods

lift :: Int8 -> Exp (Plain Int8)

ToFloating Int8 Double

Methods

toFloating :: Exp Int8 -> Exp Double

ToFloating Int8 Float

Methods

toFloating :: Exp Int8 -> Exp Float

ToFloating Int8 CFloat

Methods

toFloating :: Exp Int8 -> Exp CFloat

ToFloating Int8 CDouble

Methods

toFloating :: Exp Int8 -> Exp CDouble

ToFloating Int8 Half

Methods

toFloating :: Exp Int8 -> Exp Half

FromIntegral Int Int8

Methods

fromIntegral :: Exp Int -> Exp Int8

FromIntegral Int8 Double

Methods

fromIntegral :: Exp Int8 -> Exp Double

FromIntegral Int8 Float

Methods

fromIntegral :: Exp Int8 -> Exp Float

FromIntegral Int8 Int

Methods

fromIntegral :: Exp Int8 -> Exp Int

FromIntegral Int8 Int8

Methods

fromIntegral :: Exp Int8 -> Exp Int8

FromIntegral Int8 Int16

Methods

fromIntegral :: Exp Int8 -> Exp Int16

FromIntegral Int8 Int32

Methods

fromIntegral :: Exp Int8 -> Exp Int32

FromIntegral Int8 Int64

Methods

fromIntegral :: Exp Int8 -> Exp Int64

FromIntegral Int8 Word

Methods

fromIntegral :: Exp Int8 -> Exp Word

FromIntegral Int8 Word8

Methods

fromIntegral :: Exp Int8 -> Exp Word8

FromIntegral Int8 Word16

Methods

fromIntegral :: Exp Int8 -> Exp Word16

FromIntegral Int8 Word32

Methods

fromIntegral :: Exp Int8 -> Exp Word32

FromIntegral Int8 Word64

Methods

fromIntegral :: Exp Int8 -> Exp Word64

FromIntegral Int8 CShort

Methods

fromIntegral :: Exp Int8 -> Exp CShort

FromIntegral Int8 CUShort

Methods

fromIntegral :: Exp Int8 -> Exp CUShort

FromIntegral Int8 CInt

Methods

fromIntegral :: Exp Int8 -> Exp CInt

FromIntegral Int8 CUInt

Methods

fromIntegral :: Exp Int8 -> Exp CUInt

FromIntegral Int8 CLong

Methods

fromIntegral :: Exp Int8 -> Exp CLong

FromIntegral Int8 CULong

Methods

fromIntegral :: Exp Int8 -> Exp CULong

FromIntegral Int8 CLLong

Methods

fromIntegral :: Exp Int8 -> Exp CLLong

FromIntegral Int8 CULLong

Methods

fromIntegral :: Exp Int8 -> Exp CULLong

FromIntegral Int8 CFloat

Methods

fromIntegral :: Exp Int8 -> Exp CFloat

FromIntegral Int8 CDouble

Methods

fromIntegral :: Exp Int8 -> Exp CDouble

FromIntegral Int8 Half

Methods

fromIntegral :: Exp Int8 -> Exp Half

FromIntegral Int16 Int8

Methods

fromIntegral :: Exp Int16 -> Exp Int8

FromIntegral Int32 Int8

Methods

fromIntegral :: Exp Int32 -> Exp Int8

FromIntegral Int64 Int8

Methods

fromIntegral :: Exp Int64 -> Exp Int8

FromIntegral Word Int8

Methods

fromIntegral :: Exp Word -> Exp Int8

FromIntegral Word8 Int8

Methods

fromIntegral :: Exp Word8 -> Exp Int8

FromIntegral Word16 Int8

Methods

fromIntegral :: Exp Word16 -> Exp Int8

FromIntegral Word32 Int8

Methods

fromIntegral :: Exp Word32 -> Exp Int8

FromIntegral Word64 Int8

Methods

fromIntegral :: Exp Word64 -> Exp Int8

FromIntegral CShort Int8

Methods

fromIntegral :: Exp CShort -> Exp Int8

FromIntegral CUShort Int8

Methods

fromIntegral :: Exp CUShort -> Exp Int8

FromIntegral CInt Int8

Methods

fromIntegral :: Exp CInt -> Exp Int8

FromIntegral CUInt Int8

Methods

fromIntegral :: Exp CUInt -> Exp Int8

FromIntegral CLong Int8

Methods

fromIntegral :: Exp CLong -> Exp Int8

FromIntegral CULong Int8

Methods

fromIntegral :: Exp CULong -> Exp Int8

FromIntegral CLLong Int8

Methods

fromIntegral :: Exp CLLong -> Exp Int8

FromIntegral CULLong Int8

Methods

fromIntegral :: Exp CULLong -> Exp Int8

Bounded (Exp Int8)

Methods

minBound :: Exp Int8

maxBound :: Exp Int8

Enum (Exp Int8)

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)

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)

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

type PrimSize Int8 = 1

type Difference Int8

type Difference Int8 = Int8

type NatNumMaxBound Int8

type NatNumMaxBound Int8 = 127

data Vector Int8

data Vector Int8 = V_Int8 (Vector Int8)

type Plain Int8

type Plain Int8 = Int8

data MVector s Int8

data MVector s Int8 = MV_Int8 (MVector s Int8)

data Int16

16-bit signed integer type

Instances

Bounded Int16

Since: 2.1

Methods

minBound :: Int16

maxBound :: Int16

Enum Int16

Since: 2.1

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: 2.1

Methods

(==) :: Int16 -> Int16 -> Bool

(/=) :: Int16 -> Int16 -> Bool

Integral Int16

Since: 2.1

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: 2.1

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: 2.1

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: 2.1

Methods

readsPrec :: Int -> ReadS Int16

readList :: ReadS [Int16]

readPrec :: ReadPrec Int16

readListPrec :: ReadPrec [Int16]

Real Int16

Since: 2.1

Methods

toRational :: Int16 -> Rational

Show Int16

Since: 2.1

Methods

showsPrec :: Int -> Int16 -> ShowS

show :: Int16 -> String

showList :: [Int16] -> ShowS

Ix Int16

Since: 2.1

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

Lift Int16

Methods

lift :: Int16 -> Q Exp

PrintfArg Int16

Since: 2.1

Methods

formatArg :: Int16 -> FieldFormatter

parseFormat :: Int16 -> ModifierParser

Storable Int16

Since: 2.1

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: 2.1

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: 4.6.0.0

Methods

finiteBitSize :: Int16 -> Int

countLeadingZeros :: Int16 -> Int

countTrailingZeros :: Int16 -> Int

PrimType Int16

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

Subtractive Int16

Associated Types

type Difference Int16 :: *

Methods

(-) :: Int16 -> Int16 -> Difference Int16

NFData Int16

Methods

rnf :: Int16 -> ()

Hashable Int16

Methods

hashWithSalt :: Int -> Int16 -> Int

hash :: Int16 -> Int

Prim Int16

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

Pretty Int16

Methods

pretty :: Int16 -> Doc b

prettyList :: [Int16] -> Doc b

IsScalar Int16

Methods

scalarType :: ScalarType Int16

IsBounded Int16

Methods

boundedType :: BoundedType Int16

IsNum Int16

Methods

numType :: NumType Int16

IsIntegral Int16

Methods

integralType :: IntegralType Int16

Elt Int16

Methods

eltType :: Int16 -> TupleType (EltRepr Int16)

fromElt :: Int16 -> EltRepr Int16

toElt :: EltRepr Int16 -> Int16

Eq Int16

Methods

(==) :: Exp Int16 -> Exp Int16 -> Exp Bool

(/=) :: Exp Int16 -> Exp Int16 -> Exp Bool

Ord Int16

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

Methods

finiteBitSize :: Exp Int16 -> Exp Int

countLeadingZeros :: Exp Int16 -> Exp Int

countTrailingZeros :: Exp Int16 -> Exp Int

Bits Int16

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

Vector Vector Int16

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

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)

Lift Exp Int16

Associated Types

type Plain Int16 :: *

Methods

lift :: Int16 -> Exp (Plain Int16)

ToFloating Int16 Double

Methods

toFloating :: Exp Int16 -> Exp Double

ToFloating Int16 Float

Methods

toFloating :: Exp Int16 -> Exp Float

ToFloating Int16 CFloat

Methods

toFloating :: Exp Int16 -> Exp CFloat

ToFloating Int16 CDouble

Methods

toFloating :: Exp Int16 -> Exp CDouble

ToFloating Int16 Half

Methods

toFloating :: Exp Int16 -> Exp Half

FromIntegral Int Int16

Methods

fromIntegral :: Exp Int -> Exp Int16

FromIntegral Int8 Int16

Methods

fromIntegral :: Exp Int8 -> Exp Int16

FromIntegral Int16 Double

Methods

fromIntegral :: Exp Int16 -> Exp Double

FromIntegral Int16 Float

Methods

fromIntegral :: Exp Int16 -> Exp Float

FromIntegral Int16 Int

Methods

fromIntegral :: Exp Int16 -> Exp Int

FromIntegral Int16 Int8

Methods

fromIntegral :: Exp Int16 -> Exp Int8

FromIntegral Int16 Int16

Methods

fromIntegral :: Exp Int16 -> Exp Int16

FromIntegral Int16 Int32

Methods

fromIntegral :: Exp Int16 -> Exp Int32

FromIntegral Int16 Int64

Methods

fromIntegral :: Exp Int16 -> Exp Int64

FromIntegral Int16 Word

Methods

fromIntegral :: Exp Int16 -> Exp Word

FromIntegral Int16 Word8

Methods

fromIntegral :: Exp Int16 -> Exp Word8

FromIntegral Int16 Word16

Methods

fromIntegral :: Exp Int16 -> Exp Word16

FromIntegral Int16 Word32

Methods

fromIntegral :: Exp Int16 -> Exp Word32

FromIntegral Int16 Word64

Methods

fromIntegral :: Exp Int16 -> Exp Word64

FromIntegral Int16 CShort

Methods

fromIntegral :: Exp Int16 -> Exp CShort

FromIntegral Int16 CUShort

Methods

fromIntegral :: Exp Int16 -> Exp CUShort

FromIntegral Int16 CInt

Methods

fromIntegral :: Exp Int16 -> Exp CInt

FromIntegral Int16 CUInt

Methods

fromIntegral :: Exp Int16 -> Exp CUInt

FromIntegral Int16 CLong

Methods

fromIntegral :: Exp Int16 -> Exp CLong

FromIntegral Int16 CULong

Methods

fromIntegral :: Exp Int16 -> Exp CULong

FromIntegral Int16 CLLong

Methods

fromIntegral :: Exp Int16 -> Exp CLLong

FromIntegral Int16 CULLong

Methods

fromIntegral :: Exp Int16 -> Exp CULLong

FromIntegral Int16 CFloat

Methods

fromIntegral :: Exp Int16 -> Exp CFloat

FromIntegral Int16 CDouble

Methods

fromIntegral :: Exp Int16 -> Exp CDouble

FromIntegral Int16 Half

Methods

fromIntegral :: Exp Int16 -> Exp Half

FromIntegral Int32 Int16

Methods

fromIntegral :: Exp Int32 -> Exp Int16

FromIntegral Int64 Int16

Methods

fromIntegral :: Exp Int64 -> Exp Int16

FromIntegral Word Int16

Methods

fromIntegral :: Exp Word -> Exp Int16

FromIntegral Word8 Int16

Methods

fromIntegral :: Exp Word8 -> Exp Int16

FromIntegral Word16 Int16

Methods

fromIntegral :: Exp Word16 -> Exp Int16

FromIntegral Word32 Int16

Methods

fromIntegral :: Exp Word32 -> Exp Int16

FromIntegral Word64 Int16

Methods

fromIntegral :: Exp Word64 -> Exp Int16

FromIntegral CShort Int16

Methods

fromIntegral :: Exp CShort -> Exp Int16

FromIntegral CUShort Int16

Methods

fromIntegral :: Exp CUShort -> Exp Int16

FromIntegral CInt Int16

Methods

fromIntegral :: Exp CInt -> Exp Int16

FromIntegral CUInt Int16

Methods

fromIntegral :: Exp CUInt -> Exp Int16

FromIntegral CLong Int16

Methods

fromIntegral :: Exp CLong -> Exp Int16

FromIntegral CULong Int16

Methods

fromIntegral :: Exp CULong -> Exp Int16

FromIntegral CLLong Int16

Methods

fromIntegral :: Exp CLLong -> Exp Int16

FromIntegral CULLong Int16

Methods

fromIntegral :: Exp CULLong -> Exp Int16

Bounded (Exp Int16)

Methods

minBound :: Exp Int16

maxBound :: Exp Int16

Enum (Exp Int16)

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)

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)

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

type PrimSize Int16 = 2

type Difference Int16

type Difference Int16 = Int16

type NatNumMaxBound Int16

type NatNumMaxBound Int16 = 32767

data Vector Int16

data Vector Int16 = V_Int16 (Vector Int16)

type Plain Int16

type Plain Int16 = Int16

data MVector s Int16

data MVector s Int16 = MV_Int16 (MVector s Int16)

data Int32

32-bit signed integer type

Instances

Bounded Int32

Since: 2.1

Methods

minBound :: Int32

maxBound :: Int32

Enum Int32

Since: 2.1

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: 2.1

Methods

(==) :: Int32 -> Int32 -> Bool

(/=) :: Int32 -> Int32 -> Bool

Integral Int32

Since: 2.1

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: 2.1

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: 2.1

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: 2.1

Methods

readsPrec :: Int -> ReadS Int32

readList :: ReadS [Int32]

readPrec :: ReadPrec Int32

readListPrec :: ReadPrec [Int32]

Real Int32

Since: 2.1

Methods

toRational :: Int32 -> Rational

Show Int32

Since: 2.1

Methods

showsPrec :: Int -> Int32 -> ShowS

show :: Int32 -> String

showList :: [Int32] -> ShowS

Ix Int32

Since: 2.1

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

Lift Int32

Methods

lift :: Int32 -> Q Exp

PrintfArg Int32

Since: 2.1

Methods

formatArg :: Int32 -> FieldFormatter

parseFormat :: Int32 -> ModifierParser

Storable Int32

Since: 2.1

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: 2.1

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: 4.6.0.0

Methods

finiteBitSize :: Int32 -> Int

countLeadingZeros :: Int32 -> Int

countTrailingZeros :: Int32 -> Int

PrimType Int32

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

Subtractive Int32

Associated Types

type Difference Int32 :: *

Methods

(-) :: Int32 -> Int32 -> Difference Int32

NFData Int32

Methods

rnf :: Int32 -> ()

Hashable Int32

Methods

hashWithSalt :: Int -> Int32 -> Int

hash :: Int32 -> Int

Prim Int32

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

Pretty Int32

Methods

pretty :: Int32 -> Doc b

prettyList :: [Int32] -> Doc b

IsScalar Int32

Methods

scalarType :: ScalarType Int32

IsBounded Int32

Methods

boundedType :: BoundedType Int32

IsNum Int32

Methods

numType :: NumType Int32

IsIntegral Int32

Methods

integralType :: IntegralType Int32

Elt Int32

Methods

eltType :: Int32 -> TupleType (EltRepr Int32)

fromElt :: Int32 -> EltRepr Int32

toElt :: EltRepr Int32 -> Int32

Eq Int32

Methods

(==) :: Exp Int32 -> Exp Int32 -> Exp Bool

(/=) :: Exp Int32 -> Exp Int32 -> Exp Bool

Ord Int32

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

Methods

finiteBitSize :: Exp Int32 -> Exp Int

countLeadingZeros :: Exp Int32 -> Exp Int

countTrailingZeros :: Exp Int32 -> Exp Int

Bits Int32

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

Vector Vector Int32

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

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)

Lift Exp Int32

Associated Types

type Plain Int32 :: *

Methods

lift :: Int32 -> Exp (Plain Int32)

ToFloating Int32 Double

Methods

toFloating :: Exp Int32 -> Exp Double

ToFloating Int32 Float

Methods

toFloating :: Exp Int32 -> Exp Float

ToFloating Int32 CFloat

Methods

toFloating :: Exp Int32 -> Exp CFloat

ToFloating Int32 CDouble

Methods

toFloating :: Exp Int32 -> Exp CDouble

ToFloating Int32 Half

Methods

toFloating :: Exp Int32 -> Exp Half

FromIntegral Int Int32

Methods

fromIntegral :: Exp Int -> Exp Int32

FromIntegral Int8 Int32

Methods

fromIntegral :: Exp Int8 -> Exp Int32

FromIntegral Int16 Int32

Methods

fromIntegral :: Exp Int16 -> Exp Int32

FromIntegral Int32 Double

Methods

fromIntegral :: Exp Int32 -> Exp Double

FromIntegral Int32 Float

Methods

fromIntegral :: Exp Int32 -> Exp Float

FromIntegral Int32 Int

Methods

fromIntegral :: Exp Int32 -> Exp Int

FromIntegral Int32 Int8

Methods

fromIntegral :: Exp Int32 -> Exp Int8

FromIntegral Int32 Int16

Methods

fromIntegral :: Exp Int32 -> Exp Int16

FromIntegral Int32 Int32

Methods

fromIntegral :: Exp Int32 -> Exp Int32

FromIntegral Int32 Int64

Methods

fromIntegral :: Exp Int32 -> Exp Int64

FromIntegral Int32 Word

Methods

fromIntegral :: Exp Int32 -> Exp Word

FromIntegral Int32 Word8

Methods

fromIntegral :: Exp Int32 -> Exp Word8

FromIntegral Int32 Word16

Methods

fromIntegral :: Exp Int32 -> Exp Word16

FromIntegral Int32 Word32

Methods

fromIntegral :: Exp Int32 -> Exp Word32

FromIntegral Int32 Word64

Methods

fromIntegral :: Exp Int32 -> Exp Word64

FromIntegral Int32 CShort

Methods

fromIntegral :: Exp Int32 -> Exp CShort

FromIntegral Int32 CUShort

Methods

fromIntegral :: Exp Int32 -> Exp CUShort

FromIntegral Int32 CInt

Methods

fromIntegral :: Exp Int32 -> Exp CInt

FromIntegral Int32 CUInt

Methods

fromIntegral :: Exp Int32 -> Exp CUInt

FromIntegral Int32 CLong

Methods

fromIntegral :: Exp Int32 -> Exp CLong

FromIntegral Int32 CULong

Methods

fromIntegral :: Exp Int32 -> Exp CULong

FromIntegral Int32 CLLong

Methods

fromIntegral :: Exp Int32 -> Exp CLLong

FromIntegral Int32 CULLong

Methods

fromIntegral :: Exp Int32 -> Exp CULLong

FromIntegral Int32 CFloat

Methods

fromIntegral :: Exp Int32 -> Exp CFloat

FromIntegral Int32 CDouble

Methods

fromIntegral :: Exp Int32 -> Exp CDouble

FromIntegral Int32 Half

Methods

fromIntegral :: Exp Int32 -> Exp Half

FromIntegral Int64 Int32

Methods

fromIntegral :: Exp Int64 -> Exp Int32

FromIntegral Word Int32

Methods

fromIntegral :: Exp Word -> Exp Int32

FromIntegral Word8 Int32

Methods

fromIntegral :: Exp Word8 -> Exp Int32

FromIntegral Word16 Int32

Methods

fromIntegral :: Exp Word16 -> Exp Int32

FromIntegral Word32 Int32

Methods

fromIntegral :: Exp Word32 -> Exp Int32

FromIntegral Word64 Int32

Methods

fromIntegral :: Exp Word64 -> Exp Int32

FromIntegral CShort Int32

Methods

fromIntegral :: Exp CShort -> Exp Int32

FromIntegral CUShort Int32

Methods

fromIntegral :: Exp CUShort -> Exp Int32

FromIntegral CInt Int32

Methods

fromIntegral :: Exp CInt -> Exp Int32

FromIntegral CUInt Int32

Methods

fromIntegral :: Exp CUInt -> Exp Int32

FromIntegral CLong Int32

Methods

fromIntegral :: Exp CLong -> Exp Int32

FromIntegral CULong Int32

Methods

fromIntegral :: Exp CULong -> Exp Int32

FromIntegral CLLong Int32

Methods

fromIntegral :: Exp CLLong -> Exp Int32

FromIntegral CULLong Int32

Methods

fromIntegral :: Exp CULLong -> Exp Int32

Bounded (Exp Int32)

Methods

minBound :: Exp Int32

maxBound :: Exp Int32

Enum (Exp Int32)

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)

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)

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

type PrimSize Int32 = 4

type Difference Int32

type Difference Int32 = Int32

type NatNumMaxBound Int32

type NatNumMaxBound Int32 = 2147483647

data Vector Int32

data Vector Int32 = V_Int32 (Vector Int32)

type Plain Int32

type Plain Int32 = Int32

data MVector s Int32

data MVector s Int32 = MV_Int32 (MVector s Int32)

data Int64

64-bit signed integer type

Instances

Bounded Int64

Since: 2.1

Methods

minBound :: Int64

maxBound :: Int64

Enum Int64

Since: 2.1

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: 2.1

Methods

(==) :: Int64 -> Int64 -> Bool

(/=) :: Int64 -> Int64 -> Bool

Integral Int64

Since: 2.1

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: 2.1

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: 2.1

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: 2.1

Methods

readsPrec :: Int -> ReadS Int64

readList :: ReadS [Int64]

readPrec :: ReadPrec Int64

readListPrec :: ReadPrec [Int64]

Real Int64

Since: 2.1

Methods

toRational :: Int64 -> Rational

Show Int64

Since: 2.1

Methods

showsPrec :: Int -> Int64 -> ShowS

show :: Int64 -> String

showList :: [Int64] -> ShowS

Ix Int64

Since: 2.1

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

Lift Int64

Methods

lift :: Int64 -> Q Exp

PrintfArg Int64

Since: 2.1

Methods

formatArg :: Int64 -> FieldFormatter

parseFormat :: Int64 -> ModifierParser

Storable Int64

Since: 2.1

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: 2.1

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: 4.6.0.0

Methods

finiteBitSize :: Int64 -> Int

countLeadingZeros :: Int64 -> Int

countTrailingZeros :: Int64 -> Int

PrimType Int64

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

Subtractive Int64

Associated Types

type Difference Int64 :: *

Methods

(-) :: Int64 -> Int64 -> Difference Int64

NFData Int64

Methods

rnf :: Int64 -> ()

Hashable Int64

Methods

hashWithSalt :: Int -> Int64 -> Int

hash :: Int64 -> Int

Prim Int64

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

Pretty Int64

Methods

pretty :: Int64 -> Doc b

prettyList :: [Int64] -> Doc b

IsScalar Int64

Methods

scalarType :: ScalarType Int64

IsBounded Int64

Methods

boundedType :: BoundedType Int64

IsNum Int64

Methods

numType :: NumType Int64

IsIntegral Int64

Methods

integralType :: IntegralType Int64

Elt Int64

Methods

eltType :: Int64 -> TupleType (EltRepr Int64)

fromElt :: Int64 -> EltRepr Int64

toElt :: EltRepr Int64 -> Int64

Eq Int64

Methods

(==) :: Exp Int64 -> Exp Int64 -> Exp Bool

(/=) :: Exp Int64 -> Exp Int64 -> Exp Bool

Ord Int64

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

Methods

finiteBitSize :: Exp Int64 -> Exp Int

countLeadingZeros :: Exp Int64 -> Exp Int

countTrailingZeros :: Exp Int64 -> Exp Int

Bits Int64

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

Vector Vector Int64

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

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)

Lift Exp Int64

Associated Types

type Plain Int64 :: *

Methods

lift :: Int64 -> Exp (Plain Int64)

ToFloating Int64 Double

Methods

toFloating :: Exp Int64 -> Exp Double

ToFloating Int64 Float

Methods

toFloating :: Exp Int64 -> Exp Float

ToFloating Int64 CFloat

Methods

toFloating :: Exp Int64 -> Exp CFloat

ToFloating Int64 CDouble

Methods

toFloating :: Exp Int64 -> Exp CDouble

ToFloating Int64 Half

Methods

toFloating :: Exp Int64 -> Exp Half

FromIntegral Int Int64

Methods

fromIntegral :: Exp Int -> Exp Int64

FromIntegral Int8 Int64

Methods

fromIntegral :: Exp Int8 -> Exp Int64

FromIntegral Int16 Int64

Methods

fromIntegral :: Exp Int16 -> Exp Int64

FromIntegral Int32 Int64

Methods

fromIntegral :: Exp Int32 -> Exp Int64

FromIntegral Int64 Double

Methods

fromIntegral :: Exp Int64 -> Exp Double

FromIntegral Int64 Float

Methods

fromIntegral :: Exp Int64 -> Exp Float

FromIntegral Int64 Int

Methods

fromIntegral :: Exp Int64 -> Exp Int

FromIntegral Int64 Int8

Methods

fromIntegral :: Exp Int64 -> Exp Int8

FromIntegral Int64 Int16

Methods

fromIntegral :: Exp Int64 -> Exp Int16

FromIntegral Int64 Int32

Methods

fromIntegral :: Exp Int64 -> Exp Int32

FromIntegral Int64 Int64

Methods

fromIntegral :: Exp Int64 -> Exp Int64

FromIntegral Int64 Word

Methods

fromIntegral :: Exp Int64 -> Exp Word

FromIntegral Int64 Word8

Methods

fromIntegral :: Exp Int64 -> Exp Word8

FromIntegral Int64 Word16

Methods

fromIntegral :: Exp Int64 -> Exp Word16

FromIntegral Int64 Word32

Methods

fromIntegral :: Exp Int64 -> Exp Word32

FromIntegral Int64 Word64

Methods

fromIntegral :: Exp Int64 -> Exp Word64

FromIntegral Int64 CShort

Methods

fromIntegral :: Exp Int64 -> Exp CShort

FromIntegral Int64 CUShort

Methods

fromIntegral :: Exp Int64 -> Exp CUShort

FromIntegral Int64 CInt

Methods

fromIntegral :: Exp Int64 -> Exp CInt

FromIntegral Int64 CUInt

Methods

fromIntegral :: Exp Int64 -> Exp CUInt

FromIntegral Int64 CLong

Methods

fromIntegral :: Exp Int64 -> Exp CLong

FromIntegral Int64 CULong

Methods

fromIntegral :: Exp Int64 -> Exp CULong

FromIntegral Int64 CLLong

Methods

fromIntegral :: Exp Int64 -> Exp CLLong

FromIntegral Int64 CULLong

Methods

fromIntegral :: Exp Int64 -> Exp CULLong

FromIntegral Int64 CFloat

Methods

fromIntegral :: Exp Int64 -> Exp CFloat

FromIntegral Int64 CDouble

Methods

fromIntegral :: Exp Int64 -> Exp CDouble

FromIntegral Int64 Half

Methods

fromIntegral :: Exp Int64 -> Exp Half

FromIntegral Word Int64

Methods

fromIntegral :: Exp Word -> Exp Int64

FromIntegral Word8 Int64

Methods

fromIntegral :: Exp Word8 -> Exp Int64

FromIntegral Word16 Int64

Methods

fromIntegral :: Exp Word16 -> Exp Int64

FromIntegral Word32 Int64

Methods

fromIntegral :: Exp Word32 -> Exp Int64

FromIntegral Word64 Int64

Methods

fromIntegral :: Exp Word64 -> Exp Int64

FromIntegral CShort Int64

Methods

fromIntegral :: Exp CShort -> Exp Int64

FromIntegral CUShort Int64

Methods

fromIntegral :: Exp CUShort -> Exp Int64

FromIntegral CInt Int64

Methods

fromIntegral :: Exp CInt -> Exp Int64

FromIntegral CUInt Int64

Methods

fromIntegral :: Exp CUInt -> Exp Int64

FromIntegral CLong Int64

Methods

fromIntegral :: Exp CLong -> Exp Int64

FromIntegral CULong Int64

Methods

fromIntegral :: Exp CULong -> Exp Int64

FromIntegral CLLong Int64

Methods

fromIntegral :: Exp CLLong -> Exp Int64

FromIntegral CULLong Int64

Methods

fromIntegral :: Exp CULLong -> Exp Int64

Bounded (Exp Int64)

Methods

minBound :: Exp Int64

maxBound :: Exp Int64

Enum (Exp Int64)

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)

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)

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

type PrimSize Int64 = 8

type Difference Int64

type Difference Int64 = Int64

type NatNumMaxBound Int64

type NatNumMaxBound Int64 = 9223372036854775807

data Vector Int64

data Vector Int64 = V_Int64 (Vector Int64)

type Plain Int64

type Plain Int64 = Int64

data MVector s Int64

data 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: 2.1

Methods

minBound :: Word

maxBound :: Word

Enum Word

Since: 2.1

Methods

succ :: Word -> Word

pred :: Word -> Word

toEnum :: Int -> Word

fromEnum :: Word -> Int

enumFrom :: Word -> [Word]

enumFromThen :: Word -> Word -> [Word]

enumFromTo :: Word -> Word -> [Word]

enumFromThenTo :: Word -> Word -> Word -> [Word]

Eq Word

Methods

(==) :: Word -> Word -> Bool

(/=) :: Word -> Word -> Bool

Integral Word

Since: 2.1

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: 2.1

Methods

(+) :: Word -> Word -> Word

(-) :: Word -> Word -> Word

(*) :: Word -> Word -> Word

negate :: Word -> Word

abs :: Word -> Word

signum :: Word -> Word

fromInteger :: Integer -> Word

Ord Word

Methods

compare :: Word -> Word -> Ordering

(<) :: Word -> Word -> Bool

(<=) :: Word -> Word -> Bool

(>) :: Word -> Word -> Bool

(>=) :: Word -> Word -> Bool

max :: Word -> Word -> Word

min :: Word -> Word -> Word

Read Word

Since: 4.5.0.0

Methods

readsPrec :: Int -> ReadS Word

readList :: ReadS [Word]

readPrec :: ReadPrec Word

readListPrec :: ReadPrec [Word]

Real Word

Since: 2.1

Methods

toRational :: Word -> Rational

Show Word

Since: 2.1

Methods

showsPrec :: Int -> Word -> ShowS

show :: Word -> String

showList :: [Word] -> ShowS

Lift Word

Methods

lift :: Word -> Q Exp

PrintfArg Word

Since: 2.1

Methods

formatArg :: Word -> FieldFormatter

parseFormat :: Word -> ModifierParser

Storable Word

Since: 2.1

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: 2.1

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: 4.6.0.0

Methods

finiteBitSize :: Word -> Int

countLeadingZeros :: Word -> Int

countTrailingZeros :: Word -> Int

PrimType Word

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

Subtractive Word

Associated Types

type Difference Word :: *

Methods

(-) :: Word -> Word -> Difference Word

NFData Word

Methods

rnf :: Word -> ()

Hashable Word

Methods

hashWithSalt :: Int -> Word -> Int

hash :: Word -> Int

Prim Word

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

Pretty Word

Methods

pretty :: Word -> Doc b

prettyList :: [Word] -> Doc b

IsScalar Word

Methods

scalarType :: ScalarType Word

IsBounded Word

Methods

boundedType :: BoundedType Word

IsNum Word

Methods

numType :: NumType Word

IsIntegral Word

Methods

integralType :: IntegralType Word

Elt Word

Methods

eltType :: Word -> TupleType (EltRepr Word)

fromElt :: Word -> EltRepr Word

toElt :: EltRepr Word -> Word

Eq Word

Methods

(==) :: Exp Word -> Exp Word -> Exp Bool

(/=) :: Exp Word -> Exp Word -> Exp Bool

Ord Word

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

Methods

finiteBitSize :: Exp Word -> Exp Int

countLeadingZeros :: Exp Word -> Exp Int

countTrailingZeros :: Exp Word -> Exp Int

Bits Word

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

Vector Vector Word

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

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)

Lift Exp Word

Associated Types

type Plain Word :: *

Methods

lift :: Word -> Exp (Plain Word)

ToFloating Word Double

Methods

toFloating :: Exp Word -> Exp Double

ToFloating Word Float

Methods

toFloating :: Exp Word -> Exp Float

ToFloating Word CFloat

Methods

toFloating :: Exp Word -> Exp CFloat

ToFloating Word CDouble

Methods

toFloating :: Exp Word -> Exp CDouble

ToFloating Word Half

Methods

toFloating :: Exp Word -> Exp Half

FromIntegral Int Word

Methods

fromIntegral :: Exp Int -> Exp Word

FromIntegral Int8 Word

Methods

fromIntegral :: Exp Int8 -> Exp Word

FromIntegral Int16 Word

Methods

fromIntegral :: Exp Int16 -> Exp Word

FromIntegral Int32 Word

Methods

fromIntegral :: Exp Int32 -> Exp Word

FromIntegral Int64 Word

Methods

fromIntegral :: Exp Int64 -> Exp Word

FromIntegral Word Double

Methods

fromIntegral :: Exp Word -> Exp Double

FromIntegral Word Float

Methods

fromIntegral :: Exp Word -> Exp Float

FromIntegral Word Int

Methods

fromIntegral :: Exp Word -> Exp Int

FromIntegral Word Int8

Methods

fromIntegral :: Exp Word -> Exp Int8

FromIntegral Word Int16

Methods

fromIntegral :: Exp Word -> Exp Int16

FromIntegral Word Int32

Methods

fromIntegral :: Exp Word -> Exp Int32

FromIntegral Word Int64

Methods

fromIntegral :: Exp Word -> Exp Int64

FromIntegral Word Word

Methods

fromIntegral :: Exp Word -> Exp Word

FromIntegral Word Word8

Methods

fromIntegral :: Exp Word -> Exp Word8

FromIntegral Word Word16

Methods

fromIntegral :: Exp Word -> Exp Word16

FromIntegral Word Word32

Methods

fromIntegral :: Exp Word -> Exp Word32

FromIntegral Word Word64

Methods

fromIntegral :: Exp Word -> Exp Word64

FromIntegral Word CShort

Methods

fromIntegral :: Exp Word -> Exp CShort

FromIntegral Word CUShort

Methods

fromIntegral :: Exp Word -> Exp CUShort

FromIntegral Word CInt

Methods

fromIntegral :: Exp Word -> Exp CInt

FromIntegral Word CUInt

Methods

fromIntegral :: Exp Word -> Exp CUInt

FromIntegral Word CLong

Methods

fromIntegral :: Exp Word -> Exp CLong

FromIntegral Word CULong

Methods

fromIntegral :: Exp Word -> Exp CULong

FromIntegral Word CLLong

Methods

fromIntegral :: Exp Word -> Exp CLLong

FromIntegral Word CULLong

Methods

fromIntegral :: Exp Word -> Exp CULLong

FromIntegral Word CFloat

Methods

fromIntegral :: Exp Word -> Exp CFloat

FromIntegral Word CDouble

Methods

fromIntegral :: Exp Word -> Exp CDouble

FromIntegral Word Half

Methods

fromIntegral :: Exp Word -> Exp Half

FromIntegral Word8 Word

Methods

fromIntegral :: Exp Word8 -> Exp Word

FromIntegral Word16 Word

Methods

fromIntegral :: Exp Word16 -> Exp Word

FromIntegral Word32 Word

Methods

fromIntegral :: Exp Word32 -> Exp Word

FromIntegral Word64 Word

Methods

fromIntegral :: Exp Word64 -> Exp Word

FromIntegral CShort Word

Methods

fromIntegral :: Exp CShort -> Exp Word

FromIntegral CUShort Word

Methods

fromIntegral :: Exp CUShort -> Exp Word

FromIntegral CInt Word

Methods

fromIntegral :: Exp CInt -> Exp Word

FromIntegral CUInt Word

Methods

fromIntegral :: Exp CUInt -> Exp Word

FromIntegral CLong Word

Methods

fromIntegral :: Exp CLong -> Exp Word

FromIntegral CULong Word

Methods

fromIntegral :: Exp CULong -> Exp Word

FromIntegral CLLong Word

Methods

fromIntegral :: Exp CLLong -> Exp Word

FromIntegral CULLong Word

Methods

fromIntegral :: Exp CULLong -> Exp Word

() :=> (Bounded Word)

Methods

ins :: () :- Bounded Word

() :=> (Enum Word)

Methods

ins :: () :- Enum Word

() :=> (Eq Word)

Methods

ins :: () :- Eq Word

() :=> (Integral Word)

Methods

ins :: () :- Integral Word

() :=> (Num Word)

Methods

ins :: () :- Num Word

() :=> (Ord Word)

Methods

ins :: () :- Ord Word

() :=> (Read Word)

Methods

ins :: () :- Read Word

() :=> (Real Word)

Methods

ins :: () :- Real Word

() :=> (Show Word)

Methods

ins :: () :- Show Word

() :=> (Bits Word)

Methods

ins :: () :- Bits Word

Generic1 (URec Word :: k -> *)

Associated Types

type Rep1 (URec Word) :: k -> *

Methods

from1 :: URec Word a -> Rep1 (URec Word) a

to1 :: Rep1 (URec Word) a -> URec Word a

Bounded (Exp Word)

Methods

minBound :: Exp Word

maxBound :: Exp Word

Enum (Exp Word)

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)

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)

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

Functor (URec Word :: * -> *)

Methods

fmap :: (a -> b) -> URec Word a -> URec Word b

(<$) :: a -> URec Word b -> URec Word a

Foldable (URec Word :: * -> *)

Methods

fold :: Monoid m => URec Word m -> m

foldMap :: Monoid m => (a -> m) -> URec Word a -> m

foldr :: (a -> b -> b) -> b -> URec Word a -> b

foldr' :: (a -> b -> b) -> b -> URec Word a -> b

foldl :: (b -> a -> b) -> b -> URec Word a -> b

foldl' :: (b -> a -> b) -> b -> URec Word a -> b

foldr1 :: (a -> a -> a) -> URec Word a -> a

foldl1 :: (a -> a -> a) -> URec Word a -> a

toList :: URec Word a -> [a]

null :: URec Word a -> Bool

length :: URec Word a -> Int

elem :: Eq a => a -> URec Word a -> Bool

maximum :: Ord a => URec Word a -> a

minimum :: Ord a => URec Word a -> a

sum :: Num a => URec Word a -> a

product :: Num a => URec Word a -> a

Traversable (URec Word :: * -> *)

Methods

traverse :: Applicative f => (a -> f b) -> URec Word a -> f (URec Word b)

sequenceA :: Applicative f => URec Word (f a) -> f (URec Word a)

mapM :: Monad m => (a -> m b) -> URec Word a -> m (URec Word b)

sequence :: Monad m => URec Word (m a) -> m (URec Word a)

Eq (URec Word p)

Methods

(==) :: URec Word p -> URec Word p -> Bool

(/=) :: URec Word p -> URec Word p -> Bool

Ord (URec Word p)

Methods

compare :: URec Word p -> URec Word p -> Ordering

(<) :: URec Word p -> URec Word p -> Bool

(<=) :: URec Word p -> URec Word p -> Bool

(>) :: URec Word p -> URec Word p -> Bool

(>=) :: URec Word p -> URec Word p -> Bool

max :: URec Word p -> URec Word p -> URec Word p

min :: URec Word p -> URec Word p -> URec Word p

Show (URec Word p)

Methods

showsPrec :: Int -> URec Word p -> ShowS

show :: URec Word p -> String

showList :: [URec Word p] -> ShowS

Generic (URec Word p)

Associated Types

type Rep (URec Word p) :: * -> *

Methods

from :: URec Word p -> Rep (URec Word p) x

to :: Rep (URec Word p) x -> URec Word p

type PrimSize Word

type PrimSize Word = 8

type Difference Word

type Difference Word = Word

type NatNumMaxBound Word

type NatNumMaxBound Word = NatNumMaxBound Word64

data Vector Word

data Vector Word = V_Word (Vector Word)

type Plain Word

type Plain Word = Word

data URec Word (p :: k)

Used for marking occurrences of Word#

Since: 4.9.0.0

data URec Word (p :: k) = UWord {

• uWord# :: Word#

}

data MVector s Word

data MVector s Word = MV_Word (MVector s Word)

type Rep1 (URec Word :: k -> *)

type Rep1 (URec Word :: k -> *) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UWord" PrefixI True) (S1 (MetaSel (Just "uWord#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (UWord :: k -> *)))

type Rep (URec Word p)

type Rep (URec Word p) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UWord" PrefixI True) (S1 (MetaSel (Just "uWord#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (UWord :: * -> *)))

data Word8

8-bit unsigned integer type

Instances

Bounded Word8

Since: 2.1

Methods

minBound :: Word8

maxBound :: Word8

Enum Word8

Since: 2.1

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: 2.1

Methods

(==) :: Word8 -> Word8 -> Bool

(/=) :: Word8 -> Word8 -> Bool

Integral Word8

Since: 2.1

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: 2.1

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: 2.1

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: 2.1

Methods

readsPrec :: Int -> ReadS Word8

readList :: ReadS [Word8]

readPrec :: ReadPrec Word8

readListPrec :: ReadPrec [Word8]

Real Word8

Since: 2.1

Methods

toRational :: Word8 -> Rational

Show Word8

Since: 2.1

Methods

showsPrec :: Int -> Word8 -> ShowS

show :: Word8 -> String

showList :: [Word8] -> ShowS

Ix Word8

Since: 2.1

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

Lift Word8

Methods

lift :: Word8 -> Q Exp

PrintfArg Word8

Since: 2.1

Methods

formatArg :: Word8 -> FieldFormatter

parseFormat :: Word8 -> ModifierParser

Storable Word8

Since: 2.1

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: 2.1

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: 4.6.0.0

Methods

finiteBitSize :: Word8 -> Int

countLeadingZeros :: Word8 -> Int

countTrailingZeros :: Word8 -> Int

PrimType Word8

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

Subtractive Word8

Associated Types

type Difference Word8 :: *

Methods

(-) :: Word8 -> Word8 -> Difference Word8

NFData Word8

Methods

rnf :: Word8 -> ()

Hashable Word8

Methods

hashWithSalt :: Int -> Word8 -> Int

hash :: Word8 -> Int

Prim Word8

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

Pretty Word8

Methods

pretty :: Word8 -> Doc b

prettyList :: [Word8] -> Doc b

IsScalar Word8

Methods

scalarType :: ScalarType Word8

IsBounded Word8

Methods

boundedType :: BoundedType Word8

IsNum Word8

Methods

numType :: NumType Word8

IsIntegral Word8

Methods

integralType :: IntegralType Word8

Elt Word8

Methods

eltType :: Word8 -> TupleType (EltRepr Word8)

fromElt :: Word8 -> EltRepr Word8

toElt :: EltRepr Word8 -> Word8

Eq Word8

Methods

(==) :: Exp Word8 -> Exp Word8 -> Exp Bool

(/=) :: Exp Word8 -> Exp Word8 -> Exp Bool

Ord Word8

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

Methods

finiteBitSize :: Exp Word8 -> Exp Int

countLeadingZeros :: Exp Word8 -> Exp Int

countTrailingZeros :: Exp Word8 -> Exp Int

Bits Word8

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

Vector Vector Word8

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

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)

Lift Exp Word8

Associated Types

type Plain Word8 :: *

Methods

lift :: Word8 -> Exp (Plain Word8)

ToFloating Word8 Double

Methods

toFloating :: Exp Word8 -> Exp Double

ToFloating Word8 Float

Methods

toFloating :: Exp Word8 -> Exp Float

ToFloating Word8 CFloat

Methods

toFloating :: Exp Word8 -> Exp CFloat

ToFloating Word8 CDouble

Methods

toFloating :: Exp Word8 -> Exp CDouble

ToFloating Word8 Half

Methods

toFloating :: Exp Word8 -> Exp Half

FromIntegral Int Word8

Methods

fromIntegral :: Exp Int -> Exp Word8

FromIntegral Int8 Word8

Methods

fromIntegral :: Exp Int8 -> Exp Word8

FromIntegral Int16 Word8

Methods

fromIntegral :: Exp Int16 -> Exp Word8

FromIntegral Int32 Word8

Methods

fromIntegral :: Exp Int32 -> Exp Word8

FromIntegral Int64 Word8

Methods

fromIntegral :: Exp Int64 -> Exp Word8

FromIntegral Word Word8

Methods

fromIntegral :: Exp Word -> Exp Word8

FromIntegral Word8 Double

Methods

fromIntegral :: Exp Word8 -> Exp Double

FromIntegral Word8 Float

Methods

fromIntegral :: Exp Word8 -> Exp Float

FromIntegral Word8 Int

Methods

fromIntegral :: Exp Word8 -> Exp Int

FromIntegral Word8 Int8

Methods

fromIntegral :: Exp Word8 -> Exp Int8

FromIntegral Word8 Int16

Methods

fromIntegral :: Exp Word8 -> Exp Int16

FromIntegral Word8 Int32

Methods

fromIntegral :: Exp Word8 -> Exp Int32

FromIntegral Word8 Int64

Methods

fromIntegral :: Exp Word8 -> Exp Int64

FromIntegral Word8 Word

Methods

fromIntegral :: Exp Word8 -> Exp Word

FromIntegral Word8 Word8

Methods

fromIntegral :: Exp Word8 -> Exp Word8

FromIntegral Word8 Word16

Methods

fromIntegral :: Exp Word8 -> Exp Word16

FromIntegral Word8 Word32

Methods

fromIntegral :: Exp Word8 -> Exp Word32

FromIntegral Word8 Word64

Methods

fromIntegral :: Exp Word8 -> Exp Word64

FromIntegral Word8 CShort

Methods

fromIntegral :: Exp Word8 -> Exp CShort

FromIntegral Word8 CUShort

Methods

fromIntegral :: Exp Word8 -> Exp CUShort

FromIntegral Word8 CInt

Methods

fromIntegral :: Exp Word8 -> Exp CInt

FromIntegral Word8 CUInt

Methods

fromIntegral :: Exp Word8 -> Exp CUInt

FromIntegral Word8 CLong

Methods

fromIntegral :: Exp Word8 -> Exp CLong

FromIntegral Word8 CULong

Methods

fromIntegral :: Exp Word8 -> Exp CULong

FromIntegral Word8 CLLong

Methods

fromIntegral :: Exp Word8 -> Exp CLLong

FromIntegral Word8 CULLong

Methods

fromIntegral :: Exp Word8 -> Exp CULLong

FromIntegral Word8 CFloat

Methods

fromIntegral :: Exp Word8 -> Exp CFloat

FromIntegral Word8 CDouble

Methods

fromIntegral :: Exp Word8 -> Exp CDouble

FromIntegral Word8 Half

Methods

fromIntegral :: Exp Word8 -> Exp Half

FromIntegral Word16 Word8

Methods

fromIntegral :: Exp Word16 -> Exp Word8

FromIntegral Word32 Word8

Methods

fromIntegral :: Exp Word32 -> Exp Word8

FromIntegral Word64 Word8

Methods

fromIntegral :: Exp Word64 -> Exp Word8

FromIntegral CShort Word8

Methods

fromIntegral :: Exp CShort -> Exp Word8

FromIntegral CUShort Word8

Methods

fromIntegral :: Exp CUShort -> Exp Word8

FromIntegral CInt Word8

Methods

fromIntegral :: Exp CInt -> Exp Word8

FromIntegral CUInt Word8

Methods

fromIntegral :: Exp CUInt -> Exp Word8

FromIntegral CLong Word8

Methods

fromIntegral :: Exp CLong -> Exp Word8

FromIntegral CULong Word8

Methods

fromIntegral :: Exp CULong -> Exp Word8

FromIntegral CLLong Word8

Methods

fromIntegral :: Exp CLLong -> Exp Word8

FromIntegral CULLong Word8

Methods

fromIntegral :: Exp CULLong -> Exp Word8

Cons ByteString ByteString Word8 Word8

Methods

_Cons :: Prism ByteString ByteString (Word8, ByteString) (Word8, ByteString)

Cons ByteString ByteString Word8 Word8

Methods

_Cons :: Prism ByteString ByteString (Word8, ByteString) (Word8, ByteString)

Snoc ByteString ByteString Word8 Word8

Methods

_Snoc :: Prism ByteString ByteString (ByteString, Word8) (ByteString, Word8)

Snoc ByteString ByteString Word8 Word8

Methods

_Snoc :: Prism ByteString ByteString (ByteString, Word8) (ByteString, Word8)

Bounded (Exp Word8)

Methods

minBound :: Exp Word8

maxBound :: Exp Word8

Enum (Exp Word8)

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)

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)

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

type PrimSize Word8 = 1

type Difference Word8

type Difference Word8 = Word8

type NatNumMaxBound Word8

type NatNumMaxBound Word8 = 255

data Vector Word8

data Vector Word8 = V_Word8 (Vector Word8)

type Plain Word8

type Plain Word8 = Word8

data MVector s Word8

data MVector s Word8 = MV_Word8 (MVector s Word8)

data Word16

16-bit unsigned integer type

Instances

Bounded Word16

Since: 2.1

Methods

minBound :: Word16

maxBound :: Word16

Enum Word16

Since: 2.1

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: 2.1

Methods

(==) :: Word16 -> Word16 -> Bool

(/=) :: Word16 -> Word16 -> Bool

Integral Word16

Since: 2.1

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: 2.1

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: 2.1

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: 2.1

Methods

readsPrec :: Int -> ReadS Word16

readList :: ReadS [Word16]

readPrec :: ReadPrec Word16

readListPrec :: ReadPrec [Word16]

Real Word16

Since: 2.1

Methods

toRational :: Word16 -> Rational

Show Word16

Since: 2.1

Methods

showsPrec :: Int -> Word16 -> ShowS

show :: Word16 -> String

showList :: [Word16] -> ShowS

Ix Word16

Since: 2.1

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

Lift Word16

Methods

lift :: Word16 -> Q Exp

PrintfArg Word16

Since: 2.1

Methods

formatArg :: Word16 -> FieldFormatter

parseFormat :: Word16 -> ModifierParser

Storable Word16

Since: 2.1

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: 2.1

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: 4.6.0.0

Methods

finiteBitSize :: Word16 -> Int

countLeadingZeros :: Word16 -> Int

countTrailingZeros :: Word16 -> Int

PrimType Word16

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

Subtractive Word16

Associated Types

type Difference Word16 :: *

Methods

(-) :: Word16 -> Word16 -> Difference Word16

NFData Word16

Methods

rnf :: Word16 -> ()

Hashable Word16

Methods

hashWithSalt :: Int -> Word16 -> Int

hash :: Word16 -> Int

Prim Word16

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

Pretty Word16

Methods

pretty :: Word16 -> Doc b

prettyList :: [Word16] -> Doc b

IsScalar Word16

Methods

scalarType :: ScalarType Word16

IsBounded Word16

Methods

boundedType :: BoundedType Word16

IsNum Word16

Methods

numType :: NumType Word16

IsIntegral Word16

Methods

integralType :: IntegralType Word16

Elt Word16

Methods

eltType :: Word16 -> TupleType (EltRepr Word16)

fromElt :: Word16 -> EltRepr Word16

toElt :: EltRepr Word16 -> Word16

Eq Word16

Methods

(==) :: Exp Word16 -> Exp Word16 -> Exp Bool

(/=) :: Exp Word16 -> Exp Word16 -> Exp Bool

Ord Word16

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

Methods

finiteBitSize :: Exp Word16 -> Exp Int

countLeadingZeros :: Exp Word16 -> Exp Int

countTrailingZeros :: Exp Word16 -> Exp Int

Bits Word16

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

Vector Vector Word16

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

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)

Lift Exp Word16

Associated Types

type Plain Word16 :: *

Methods

lift :: Word16 -> Exp (Plain Word16)

ToFloating Word16 Double

Methods

toFloating :: Exp Word16 -> Exp Double

ToFloating Word16 Float

Methods

toFloating :: Exp Word16 -> Exp Float

ToFloating Word16 CFloat

Methods

toFloating :: Exp Word16 -> Exp CFloat

ToFloating Word16 CDouble

Methods

toFloating :: Exp Word16 -> Exp CDouble

ToFloating Word16 Half

Methods

toFloating :: Exp Word16 -> Exp Half

FromIntegral Int Word16

Methods

fromIntegral :: Exp Int -> Exp Word16

FromIntegral Int8 Word16

Methods

fromIntegral :: Exp Int8 -> Exp Word16

FromIntegral Int16 Word16

Methods

fromIntegral :: Exp Int16 -> Exp Word16

FromIntegral Int32 Word16

Methods

fromIntegral :: Exp Int32 -> Exp Word16

FromIntegral Int64 Word16

Methods

fromIntegral :: Exp Int64 -> Exp Word16

FromIntegral Word Word16

Methods

fromIntegral :: Exp Word -> Exp Word16

FromIntegral Word8 Word16

Methods

fromIntegral :: Exp Word8 -> Exp Word16

FromIntegral Word16 Double

Methods

fromIntegral :: Exp Word16 -> Exp Double

FromIntegral Word16 Float

Methods

fromIntegral :: Exp Word16 -> Exp Float

FromIntegral Word16 Int

Methods

fromIntegral :: Exp Word16 -> Exp Int

FromIntegral Word16 Int8

Methods

fromIntegral :: Exp Word16 -> Exp Int8

FromIntegral Word16 Int16

Methods

fromIntegral :: Exp Word16 -> Exp Int16

FromIntegral Word16 Int32

Methods

fromIntegral :: Exp Word16 -> Exp Int32

FromIntegral Word16 Int64

Methods

fromIntegral :: Exp Word16 -> Exp Int64

FromIntegral Word16 Word

Methods

fromIntegral :: Exp Word16 -> Exp Word

FromIntegral Word16 Word8

Methods

fromIntegral :: Exp Word16 -> Exp Word8

FromIntegral Word16 Word16

Methods

fromIntegral :: Exp Word16 -> Exp Word16

FromIntegral Word16 Word32

Methods

fromIntegral :: Exp Word16 -> Exp Word32

FromIntegral Word16 Word64

Methods

fromIntegral :: Exp Word16 -> Exp Word64

FromIntegral Word16 CShort

Methods

fromIntegral :: Exp Word16 -> Exp CShort

FromIntegral Word16 CUShort

Methods

fromIntegral :: Exp Word16 -> Exp CUShort

FromIntegral Word16 CInt

Methods

fromIntegral :: Exp Word16 -> Exp CInt

FromIntegral Word16 CUInt

Methods

fromIntegral :: Exp Word16 -> Exp CUInt

FromIntegral Word16 CLong

Methods

fromIntegral :: Exp Word16 -> Exp CLong

FromIntegral Word16 CULong

Methods

fromIntegral :: Exp Word16 -> Exp CULong

FromIntegral Word16 CLLong

Methods

fromIntegral :: Exp Word16 -> Exp CLLong

FromIntegral Word16 CULLong

Methods

fromIntegral :: Exp Word16 -> Exp CULLong

FromIntegral Word16 CFloat

Methods

fromIntegral :: Exp Word16 -> Exp CFloat

FromIntegral Word16 CDouble

Methods

fromIntegral :: Exp Word16 -> Exp CDouble

FromIntegral Word16 Half

Methods

fromIntegral :: Exp Word16 -> Exp Half

FromIntegral Word32 Word16

Methods

fromIntegral :: Exp Word32 -> Exp Word16

FromIntegral Word64 Word16

Methods

fromIntegral :: Exp Word64 -> Exp Word16

FromIntegral CShort Word16

Methods

fromIntegral :: Exp CShort -> Exp Word16

FromIntegral CUShort Word16

Methods

fromIntegral :: Exp CUShort -> Exp Word16

FromIntegral CInt Word16

Methods

fromIntegral :: Exp CInt -> Exp Word16

FromIntegral CUInt Word16

Methods

fromIntegral :: Exp CUInt -> Exp Word16

FromIntegral CLong Word16

Methods

fromIntegral :: Exp CLong -> Exp Word16

FromIntegral CULong Word16

Methods

fromIntegral :: Exp CULong -> Exp Word16

FromIntegral CLLong Word16

Methods

fromIntegral :: Exp CLLong -> Exp Word16

FromIntegral CULLong Word16

Methods

fromIntegral :: Exp CULLong -> Exp Word16

Bounded (Exp Word16)

Methods

minBound :: Exp Word16

maxBound :: Exp Word16

Enum (Exp Word16)

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)

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)

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

type PrimSize Word16 = 2

type Difference Word16

type Difference Word16 = Word16

type NatNumMaxBound Word16

type NatNumMaxBound Word16 = 65535

data Vector Word16

data Vector Word16 = V_Word16 (Vector Word16)

type Plain Word16

type Plain Word16 = Word16

data MVector s Word16

data MVector s Word16 = MV_Word16 (MVector s Word16)

data Word32

32-bit unsigned integer type

Instances

Bounded Word32

Since: 2.1

Methods

minBound :: Word32

maxBound :: Word32

Enum Word32

Since: 2.1

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: 2.1

Methods

(==) :: Word32 -> Word32 -> Bool

(/=) :: Word32 -> Word32 -> Bool

Integral Word32

Since: 2.1

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: 2.1

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: 2.1

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: 2.1

Methods

readsPrec :: Int -> ReadS Word32

readList :: ReadS [Word32]

readPrec :: ReadPrec Word32

readListPrec :: ReadPrec [Word32]

Real Word32

Since: 2.1

Methods

toRational :: Word32 -> Rational

Show Word32

Since: 2.1

Methods

showsPrec :: Int -> Word32 -> ShowS

show :: Word32 -> String

showList :: [Word32] -> ShowS

Ix Word32

Since: 2.1

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

Lift Word32

Methods

lift :: Word32 -> Q Exp

PrintfArg Word32

Since: 2.1

Methods

formatArg :: Word32 -> FieldFormatter

parseFormat :: Word32 -> ModifierParser

Storable Word32

Since: 2.1

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: 2.1

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: 4.6.0.0

Methods

finiteBitSize :: Word32 -> Int

countLeadingZeros :: Word32 -> Int

countTrailingZeros :: Word32 -> Int

PrimType Word32

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

Subtractive Word32

Associated Types

type Difference Word32 :: *

Methods

(-) :: Word32 -> Word32 -> Difference Word32

NFData Word32

Methods

rnf :: Word32 -> ()

Hashable Word32

Methods

hashWithSalt :: Int -> Word32 -> Int

hash :: Word32 -> Int

Prim Word32

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

Pretty Word32

Methods

pretty :: Word32 -> Doc b

prettyList :: [Word32] -> Doc b

IsScalar Word32

Methods

scalarType :: ScalarType Word32

IsBounded Word32

Methods

boundedType :: BoundedType Word32

IsNum Word32

Methods

numType :: NumType Word32

IsIntegral Word32

Methods

integralType :: IntegralType Word32

Elt Word32

Methods

eltType :: Word32 -> TupleType (EltRepr Word32)

fromElt :: Word32 -> EltRepr Word32

toElt :: EltRepr Word32 -> Word32

Eq Word32

Methods

(==) :: Exp Word32 -> Exp Word32 -> Exp Bool

(/=) :: Exp Word32 -> Exp Word32 -> Exp Bool

Ord Word32

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

Methods

finiteBitSize :: Exp Word32 -> Exp Int

countLeadingZeros :: Exp Word32 -> Exp Int

countTrailingZeros :: Exp Word32 -> Exp Int

Bits Word32

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

Vector Vector Word32

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

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)

Lift Exp Word32

Associated Types

type Plain Word32 :: *

Methods

lift :: Word32 -> Exp (Plain Word32)

ToFloating Word32 Double

Methods

toFloating :: Exp Word32 -> Exp Double

ToFloating Word32 Float

Methods

toFloating :: Exp Word32 -> Exp Float

ToFloating Word32 CFloat

Methods

toFloating :: Exp Word32 -> Exp CFloat

ToFloating Word32 CDouble

Methods

toFloating :: Exp Word32 -> Exp CDouble

ToFloating Word32 Half

Methods

toFloating :: Exp Word32 -> Exp Half

FromIntegral Int Word32

Methods

fromIntegral :: Exp Int -> Exp Word32

FromIntegral Int8 Word32

Methods

fromIntegral :: Exp Int8 -> Exp Word32

FromIntegral Int16 Word32

Methods

fromIntegral :: Exp Int16 -> Exp Word32

FromIntegral Int32 Word32

Methods

fromIntegral :: Exp Int32 -> Exp Word32

FromIntegral Int64 Word32

Methods

fromIntegral :: Exp Int64 -> Exp Word32

FromIntegral Word Word32

Methods

fromIntegral :: Exp Word -> Exp Word32

FromIntegral Word8 Word32

Methods

fromIntegral :: Exp Word8 -> Exp Word32

FromIntegral Word16 Word32

Methods

fromIntegral :: Exp Word16 -> Exp Word32

FromIntegral Word32 Double

Methods

fromIntegral :: Exp Word32 -> Exp Double

FromIntegral Word32 Float

Methods

fromIntegral :: Exp Word32 -> Exp Float

FromIntegral Word32 Int

Methods

fromIntegral :: Exp Word32 -> Exp Int

FromIntegral Word32 Int8

Methods

fromIntegral :: Exp Word32 -> Exp Int8

FromIntegral Word32 Int16

Methods

fromIntegral :: Exp Word32 -> Exp Int16

FromIntegral Word32 Int32

Methods

fromIntegral :: Exp Word32 -> Exp Int32

FromIntegral Word32 Int64

Methods

fromIntegral :: Exp Word32 -> Exp Int64

FromIntegral Word32 Word

Methods

fromIntegral :: Exp Word32 -> Exp Word

FromIntegral Word32 Word8

Methods

fromIntegral :: Exp Word32 -> Exp Word8

FromIntegral Word32 Word16

Methods

fromIntegral :: Exp Word32 -> Exp Word16

FromIntegral Word32 Word32

Methods

fromIntegral :: Exp Word32 -> Exp Word32

FromIntegral Word32 Word64

Methods

fromIntegral :: Exp Word32 -> Exp Word64

FromIntegral Word32 CShort

Methods

fromIntegral :: Exp Word32 -> Exp CShort

FromIntegral Word32 CUShort

Methods

fromIntegral :: Exp Word32 -> Exp CUShort

FromIntegral Word32 CInt

Methods

fromIntegral :: Exp Word32 -> Exp CInt

FromIntegral Word32 CUInt

Methods

fromIntegral :: Exp Word32 -> Exp CUInt

FromIntegral Word32 CLong

Methods

fromIntegral :: Exp Word32 -> Exp CLong

FromIntegral Word32 CULong

Methods

fromIntegral :: Exp Word32 -> Exp CULong

FromIntegral Word32 CLLong

Methods

fromIntegral :: Exp Word32 -> Exp CLLong

FromIntegral Word32 CULLong

Methods

fromIntegral :: Exp Word32 -> Exp CULLong

FromIntegral Word32 CFloat

Methods

fromIntegral :: Exp Word32 -> Exp CFloat

FromIntegral Word32 CDouble

Methods

fromIntegral :: Exp Word32 -> Exp CDouble

FromIntegral Word32 Half

Methods

fromIntegral :: Exp Word32 -> Exp Half

FromIntegral Word64 Word32

Methods

fromIntegral :: Exp Word64 -> Exp Word32

FromIntegral CShort Word32

Methods

fromIntegral :: Exp CShort -> Exp Word32

FromIntegral CUShort Word32

Methods

fromIntegral :: Exp CUShort -> Exp Word32

FromIntegral CInt Word32

Methods

fromIntegral :: Exp CInt -> Exp Word32

FromIntegral CUInt Word32

Methods

fromIntegral :: Exp CUInt -> Exp Word32

FromIntegral CLong Word32

Methods

fromIntegral :: Exp CLong -> Exp Word32

FromIntegral CULong Word32

Methods

fromIntegral :: Exp CULong -> Exp Word32

FromIntegral CLLong Word32

Methods

fromIntegral :: Exp CLLong -> Exp Word32

FromIntegral CULLong Word32

Methods

fromIntegral :: Exp CULLong -> Exp Word32

Bounded (Exp Word32)

Methods

minBound :: Exp Word32

maxBound :: Exp Word32

Enum (Exp Word32)

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)

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)

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

type PrimSize Word32 = 4

type Difference Word32

type Difference Word32 = Word32

type NatNumMaxBound Word32

type NatNumMaxBound Word32 = 4294967295

data Vector Word32

data Vector Word32 = V_Word32 (Vector Word32)

type Plain Word32

type Plain Word32 = Word32

data MVector s Word32

data MVector s Word32 = MV_Word32 (MVector s Word32)

data Word64

64-bit unsigned integer type

Instances

Bounded Word64

Since: 2.1

Methods

minBound :: Word64

maxBound :: Word64

Enum Word64

Since: 2.1

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: 2.1

Methods

(==) :: Word64 -> Word64 -> Bool

(/=) :: Word64 -> Word64 -> Bool

Integral Word64

Since: 2.1

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: 2.1

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: 2.1

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: 2.1

Methods

readsPrec :: Int -> ReadS Word64

readList :: ReadS [Word64]

readPrec :: ReadPrec Word64

readListPrec :: ReadPrec [Word64]

Real Word64

Since: 2.1

Methods

toRational :: Word64 -> Rational

Show Word64

Since: 2.1

Methods

showsPrec :: Int -> Word64 -> ShowS

show :: Word64 -> String

showList :: [Word64] -> ShowS

Ix Word64

Since: 2.1

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

Lift Word64

Methods

lift :: Word64 -> Q Exp

PrintfArg Word64

Since: 2.1

Methods

formatArg :: Word64 -> FieldFormatter

parseFormat :: Word64 -> ModifierParser

Storable Word64

Since: 2.1

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: 2.1

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: 4.6.0.0

Methods

finiteBitSize :: Word64 -> Int

countLeadingZeros :: Word64 -> Int

countTrailingZeros :: Word64 -> Int

PrimType Word64

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

Subtractive Word64

Associated Types

type Difference Word64 :: *

Methods

(-) :: Word64 -> Word64 -> Difference Word64

NFData Word64

Methods

rnf :: Word64 -> ()

Hashable Word64

Methods

hashWithSalt :: Int -> Word64 -> Int

hash :: Word64 -> Int

Prim Word64

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

Pretty Word64

Methods

pretty :: Word64 -> Doc b

prettyList :: [Word64] -> Doc b

IsScalar Word64

Methods

scalarType :: ScalarType Word64

IsBounded Word64

Methods

boundedType :: BoundedType Word64

IsNum Word64

Methods

numType :: NumType Word64

IsIntegral Word64

Methods

integralType :: IntegralType Word64

Elt Word64

Methods

eltType :: Word64 -> TupleType (EltRepr Word64)

fromElt :: Word64 -> EltRepr Word64

toElt :: EltRepr Word64 -> Word64

Eq Word64

Methods

(==) :: Exp Word64 -> Exp Word64 -> Exp Bool

(/=) :: Exp Word64 -> Exp Word64 -> Exp Bool

Ord Word64

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

Methods

finiteBitSize :: Exp Word64 -> Exp Int

countLeadingZeros :: Exp Word64 -> Exp Int

countTrailingZeros :: Exp Word64 -> Exp Int

Bits Word64

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

Vector Vector Word64

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

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)

Lift Exp Word64

Associated Types

type Plain Word64 :: *

Methods

lift :: Word64 -> Exp (Plain Word64)

ToFloating Word64 Double

Methods

toFloating :: Exp Word64 -> Exp Double

ToFloating Word64 Float

Methods

toFloating :: Exp Word64 -> Exp Float

ToFloating Word64 CFloat

Methods

toFloating :: Exp Word64 -> Exp CFloat

ToFloating Word64 CDouble

Methods

toFloating :: Exp Word64 -> Exp CDouble

ToFloating Word64 Half

Methods

toFloating :: Exp Word64 -> Exp Half

FromIntegral Int Word64

Methods

fromIntegral :: Exp Int -> Exp Word64

FromIntegral Int8 Word64

Methods

fromIntegral :: Exp Int8 -> Exp Word64

FromIntegral Int16 Word64

Methods

fromIntegral :: Exp Int16 -> Exp Word64

FromIntegral Int32 Word64

Methods

fromIntegral :: Exp Int32 -> Exp Word64

FromIntegral Int64 Word64

Methods

fromIntegral :: Exp Int64 -> Exp Word64

FromIntegral Word Word64

Methods

fromIntegral :: Exp Word -> Exp Word64

FromIntegral Word8 Word64

Methods

fromIntegral :: Exp Word8 -> Exp Word64

FromIntegral Word16 Word64

Methods

fromIntegral :: Exp Word16 -> Exp Word64

FromIntegral Word32 Word64

Methods

fromIntegral :: Exp Word32 -> Exp Word64

FromIntegral Word64 Double

Methods

fromIntegral :: Exp Word64 -> Exp Double

FromIntegral Word64 Float

Methods

fromIntegral :: Exp Word64 -> Exp Float

FromIntegral Word64 Int

Methods

fromIntegral :: Exp Word64 -> Exp Int

FromIntegral Word64 Int8

Methods

fromIntegral :: Exp Word64 -> Exp Int8

FromIntegral Word64 Int16

Methods

fromIntegral :: Exp Word64 -> Exp Int16

FromIntegral Word64 Int32

Methods

fromIntegral :: Exp Word64 -> Exp Int32

FromIntegral Word64 Int64

Methods

fromIntegral :: Exp Word64 -> Exp Int64

FromIntegral Word64 Word

Methods

fromIntegral :: Exp Word64 -> Exp Word

FromIntegral Word64 Word8

Methods

fromIntegral :: Exp Word64 -> Exp Word8

FromIntegral Word64 Word16

Methods

fromIntegral :: Exp Word64 -> Exp Word16

FromIntegral Word64 Word32

Methods

fromIntegral :: Exp Word64 -> Exp Word32

FromIntegral Word64 Word64

Methods

fromIntegral :: Exp Word64 -> Exp Word64

FromIntegral Word64 CShort

Methods

fromIntegral :: Exp Word64 -> Exp CShort

FromIntegral Word64 CUShort

Methods

fromIntegral :: Exp Word64 -> Exp CUShort

FromIntegral Word64 CInt

Methods

fromIntegral :: Exp Word64 -> Exp CInt

FromIntegral Word64 CUInt

Methods

fromIntegral :: Exp Word64 -> Exp CUInt

FromIntegral Word64 CLong

Methods

fromIntegral :: Exp Word64 -> Exp CLong

FromIntegral Word64 CULong

Methods

fromIntegral :: Exp Word64 -> Exp CULong

FromIntegral Word64 CLLong

Methods

fromIntegral :: Exp Word64 -> Exp CLLong

FromIntegral Word64 CULLong

Methods

fromIntegral :: Exp Word64 -> Exp CULLong

FromIntegral Word64 CFloat

Methods

fromIntegral :: Exp Word64 -> Exp CFloat

FromIntegral Word64 CDouble

Methods

fromIntegral :: Exp Word64 -> Exp CDouble

FromIntegral Word64 Half

Methods

fromIntegral :: Exp Word64 -> Exp Half

FromIntegral CShort Word64

Methods

fromIntegral :: Exp CShort -> Exp Word64

FromIntegral CUShort Word64

Methods

fromIntegral :: Exp CUShort -> Exp Word64

FromIntegral CInt Word64

Methods

fromIntegral :: Exp CInt -> Exp Word64

FromIntegral CUInt Word64

Methods

fromIntegral :: Exp CUInt -> Exp Word64

FromIntegral CLong Word64

Methods

fromIntegral :: Exp CLong -> Exp Word64

FromIntegral CULong Word64

Methods

fromIntegral :: Exp CULong -> Exp Word64

FromIntegral CLLong Word64

Methods

fromIntegral :: Exp CLLong -> Exp Word64

FromIntegral CULLong Word64

Methods

fromIntegral :: Exp CULLong -> Exp Word64

Bounded (Exp Word64)

Methods

minBound :: Exp Word64

maxBound :: Exp Word64

Enum (Exp Word64)

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)

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)

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

type PrimSize Word64 = 8

type Difference Word64

type Difference Word64 = Word64

type NatNumMaxBound Word64

type NatNumMaxBound Word64 = 18446744073709551615

data Vector Word64

data Vector Word64 = V_Word64 (Vector Word64)

type Plain Word64

type Plain Word64 = Word64

data MVector s Word64

data MVector s Word64 = MV_Word64 (MVector s Word64)

newtype Half

Constructors

Half

Fields

• getHalf :: CUShort

Instances

Eq Half

Methods

(==) :: Half -> Half -> Bool

(/=) :: Half -> Half -> Bool

Floating 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

Methods

(/) :: Half -> Half -> Half

recip :: Half -> Half

fromRational :: Rational -> Half

Num 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

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

Methods

readsPrec :: Int -> ReadS Half

readList :: ReadS [Half]

readPrec :: ReadPrec Half

readListPrec :: ReadPrec [Half]

Real Half

Methods

toRational :: Half -> Rational

RealFloat 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

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

Methods

showsPrec :: Int -> Half -> ShowS

show :: Half -> String

showList :: [Half] -> ShowS

Storable 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 ()

IsScalar Half

Methods

scalarType :: ScalarType Half

IsNum Half

Methods

numType :: NumType Half

IsFloating Half

Methods

floatingType :: FloatingType Half

Elt Half

Methods

eltType :: Half -> TupleType (EltRepr Half)

fromElt :: Half -> EltRepr Half

toElt :: EltRepr Half -> Half

Eq Half

Methods

(==) :: Exp Half -> Exp Half -> Exp Bool

(/=) :: Exp Half -> Exp Half -> Exp Bool

Ord Half

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

RealFrac Half

Methods

properFraction :: (Num b, ToFloating b Half, IsIntegral b) => Exp Half -> (Exp b, Exp Half)

truncate :: (Elt b, IsIntegral b) => Exp Half -> Exp b

round :: (Elt b, IsIntegral b) => Exp Half -> Exp b

ceiling :: (Elt b, IsIntegral b) => Exp Half -> Exp b

floor :: (Elt b, IsIntegral b) => Exp Half -> Exp b

RealFloat Half

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

ToFloating Double Half

Methods

toFloating :: Exp Double -> Exp Half

ToFloating Float Half

Methods

toFloating :: Exp Float -> Exp Half

ToFloating Int Half

Methods

toFloating :: Exp Int -> Exp Half

ToFloating Int8 Half

Methods

toFloating :: Exp Int8 -> Exp Half

ToFloating Int16 Half

Methods

toFloating :: Exp Int16 -> Exp Half

ToFloating Int32 Half

Methods

toFloating :: Exp Int32 -> Exp Half

ToFloating Int64 Half

Methods

toFloating :: Exp Int64 -> Exp Half

ToFloating Word Half

Methods

toFloating :: Exp Word -> Exp Half

ToFloating Word8 Half

Methods

toFloating :: Exp Word8 -> Exp Half

ToFloating Word16 Half

Methods

toFloating :: Exp Word16 -> Exp Half

ToFloating Word32 Half

Methods

toFloating :: Exp Word32 -> Exp Half

ToFloating Word64 Half

Methods

toFloating :: Exp Word64 -> Exp Half

ToFloating CShort Half

Methods

toFloating :: Exp CShort -> Exp Half

ToFloating CUShort Half

Methods

toFloating :: Exp CUShort -> Exp Half

ToFloating CInt Half

Methods

toFloating :: Exp CInt -> Exp Half

ToFloating CUInt Half

Methods

toFloating :: Exp CUInt -> Exp Half

ToFloating CLong Half

Methods

toFloating :: Exp CLong -> Exp Half

ToFloating CULong Half

Methods

toFloating :: Exp CULong -> Exp Half

ToFloating CLLong Half

Methods

toFloating :: Exp CLLong -> Exp Half

ToFloating CULLong Half

Methods

toFloating :: Exp CULLong -> Exp Half

ToFloating CFloat Half

Methods

toFloating :: Exp CFloat -> Exp Half

ToFloating CDouble Half

Methods

toFloating :: Exp CDouble -> Exp Half

ToFloating Half Double

Methods

toFloating :: Exp Half -> Exp Double

ToFloating Half Float

Methods

toFloating :: Exp Half -> Exp Float

ToFloating Half CFloat

Methods

toFloating :: Exp Half -> Exp CFloat

ToFloating Half CDouble

Methods

toFloating :: Exp Half -> Exp CDouble

ToFloating Half Half

Methods

toFloating :: Exp Half -> Exp Half

FromIntegral Int Half

Methods

fromIntegral :: Exp Int -> Exp Half

FromIntegral Int8 Half

Methods

fromIntegral :: Exp Int8 -> Exp Half

FromIntegral Int16 Half

Methods

fromIntegral :: Exp Int16 -> Exp Half

FromIntegral Int32 Half

Methods

fromIntegral :: Exp Int32 -> Exp Half

FromIntegral Int64 Half

Methods

fromIntegral :: Exp Int64 -> Exp Half

FromIntegral Word Half

Methods

fromIntegral :: Exp Word -> Exp Half

FromIntegral Word8 Half

Methods

fromIntegral :: Exp Word8 -> Exp Half

FromIntegral Word16 Half

Methods

fromIntegral :: Exp Word16 -> Exp Half

FromIntegral Word32 Half

Methods

fromIntegral :: Exp Word32 -> Exp Half

FromIntegral Word64 Half

Methods

fromIntegral :: Exp Word64 -> Exp Half

FromIntegral CShort Half

Methods

fromIntegral :: Exp CShort -> Exp Half

FromIntegral CUShort Half

Methods

fromIntegral :: Exp CUShort -> Exp Half

FromIntegral CInt Half

Methods

fromIntegral :: Exp CInt -> Exp Half

FromIntegral CUInt Half

Methods

fromIntegral :: Exp CUInt -> Exp Half

FromIntegral CLong Half

Methods

fromIntegral :: Exp CLong -> Exp Half

FromIntegral CULong Half

Methods

fromIntegral :: Exp CULong -> Exp Half

FromIntegral CLLong Half

Methods

fromIntegral :: Exp CLLong -> Exp Half

FromIntegral CULLong Half

Methods

fromIntegral :: Exp CULLong -> Exp Half

Enum (Exp Half)

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)

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)

Methods

(/) :: Exp Half -> Exp Half -> Exp Half

recip :: Exp Half -> Exp Half

fromRational :: Rational -> Exp Half

Num (Exp Half)

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

Elt (Complex Half)

Methods

eltType :: Complex Half -> TupleType (EltRepr (Complex Half))

fromElt :: Complex Half -> EltRepr (Complex Half)

toElt :: EltRepr (Complex Half) -> Complex 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

Methods

(==) :: Float -> Float -> Bool

(/=) :: Float -> Float -> Bool

Floating Float

Since: 2.1

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

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: 2.1

Methods

readsPrec :: Int -> ReadS Float

readList :: ReadS [Float]

readPrec :: ReadPrec Float

readListPrec :: ReadPrec [Float]

RealFloat Float

Since: 2.1

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

Lift Float

Methods

lift :: Float -> Q Exp

Pretty Float

Methods

pretty :: Float -> Doc

prettyList :: [Float] -> Doc

PrintfArg Float

Since: 2.1

Methods

formatArg :: Float -> FieldFormatter

parseFormat :: Float -> ModifierParser

Storable Float

Since: 2.1

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

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

Associated Types

type Difference Float :: *

Methods

(-) :: Float -> Float -> Difference Float

NFData Float

Methods

rnf :: Float -> ()

Hashable Float

Methods

hashWithSalt :: Int -> Float -> Int

hash :: Float -> Int

Prim Float

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

Pretty Float

Methods

pretty :: Float -> Doc b

prettyList :: [Float] -> Doc b

IsScalar Float

Methods

scalarType :: ScalarType Float

IsNum Float

Methods

numType :: NumType Float

IsFloating Float

Methods

floatingType :: FloatingType Float

Elt Float

Methods

eltType :: Float -> TupleType (EltRepr Float)

fromElt :: Float -> EltRepr Float

toElt :: EltRepr Float -> Float

Eq Float

Methods

(==) :: Exp Float -> Exp Float -> Exp Bool

(/=) :: Exp Float -> Exp Float -> Exp Bool

Ord Float

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

RealFrac Float

Methods

properFraction :: (Num b, ToFloating b Float, IsIntegral b) => Exp Float -> (Exp b, Exp Float)

truncate :: (Elt b, IsIntegral b) => Exp Float -> Exp b

round :: (Elt b, IsIntegral b) => Exp Float -> Exp b

ceiling :: (Elt b, IsIntegral b) => Exp Float -> Exp b

floor :: (Elt b, IsIntegral b) => Exp Float -> Exp b

RealFloat Float

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

Vector Vector Float

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

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)

Lift Exp Float

Associated Types

type Plain Float :: *

Methods

lift :: Float -> Exp (Plain Float)

ToFloating Double Float

Methods

toFloating :: Exp Double -> Exp Float

ToFloating Float Double

Methods

toFloating :: Exp Float -> Exp Double

ToFloating Float Float

Methods

toFloating :: Exp Float -> Exp Float

ToFloating Float CFloat

Methods

toFloating :: Exp Float -> Exp CFloat

ToFloating Float CDouble

Methods

toFloating :: Exp Float -> Exp CDouble

ToFloating Float Half

Methods

toFloating :: Exp Float -> Exp Half

ToFloating Int Float

Methods

toFloating :: Exp Int -> Exp Float

ToFloating Int8 Float

Methods

toFloating :: Exp Int8 -> Exp Float

ToFloating Int16 Float

Methods

toFloating :: Exp Int16 -> Exp Float

ToFloating Int32 Float

Methods

toFloating :: Exp Int32 -> Exp Float

ToFloating Int64 Float

Methods

toFloating :: Exp Int64 -> Exp Float

ToFloating Word Float

Methods

toFloating :: Exp Word -> Exp Float

ToFloating Word8 Float

Methods

toFloating :: Exp Word8 -> Exp Float

ToFloating Word16 Float

Methods

toFloating :: Exp Word16 -> Exp Float

ToFloating Word32 Float

Methods

toFloating :: Exp Word32 -> Exp Float

ToFloating Word64 Float

Methods

toFloating :: Exp Word64 -> Exp Float

ToFloating CShort Float

Methods

toFloating :: Exp CShort -> Exp Float

ToFloating CUShort Float

Methods

toFloating :: Exp CUShort -> Exp Float

ToFloating CInt Float

Methods

toFloating :: Exp CInt -> Exp Float

ToFloating CUInt Float

Methods

toFloating :: Exp CUInt -> Exp Float

ToFloating CLong Float

Methods

toFloating :: Exp CLong -> Exp Float

ToFloating CULong Float

Methods

toFloating :: Exp CULong -> Exp Float

ToFloating CLLong Float

Methods

toFloating :: Exp CLLong -> Exp Float

ToFloating CULLong Float

Methods

toFloating :: Exp CULLong -> Exp Float

ToFloating CFloat Float

Methods

toFloating :: Exp CFloat -> Exp Float

ToFloating CDouble Float

Methods

toFloating :: Exp CDouble -> Exp Float

ToFloating Half Float

Methods

toFloating :: Exp Half -> Exp Float

FromIntegral Int Float

Methods

fromIntegral :: Exp Int -> Exp Float

FromIntegral Int8 Float

Methods

fromIntegral :: Exp Int8 -> Exp Float

FromIntegral Int16 Float

Methods

fromIntegral :: Exp Int16 -> Exp Float

FromIntegral Int32 Float

Methods

fromIntegral :: Exp Int32 -> Exp Float

FromIntegral Int64 Float

Methods

fromIntegral :: Exp Int64 -> Exp Float

FromIntegral Word Float

Methods

fromIntegral :: Exp Word -> Exp Float

FromIntegral Word8 Float

Methods

fromIntegral :: Exp Word8 -> Exp Float

FromIntegral Word16 Float

Methods

fromIntegral :: Exp Word16 -> Exp Float

FromIntegral Word32 Float

Methods

fromIntegral :: Exp Word32 -> Exp Float

FromIntegral Word64 Float

Methods

fromIntegral :: Exp Word64 -> Exp Float

FromIntegral CShort Float

Methods

fromIntegral :: Exp CShort -> Exp Float

FromIntegral CUShort Float

Methods

fromIntegral :: Exp CUShort -> Exp Float

FromIntegral CInt Float

Methods

fromIntegral :: Exp CInt -> Exp Float

FromIntegral CUInt Float

Methods

fromIntegral :: Exp CUInt -> Exp Float

FromIntegral CLong Float

Methods

fromIntegral :: Exp CLong -> Exp Float

FromIntegral CULong Float

Methods

fromIntegral :: Exp CULong -> Exp Float

FromIntegral CLLong Float

Methods

fromIntegral :: Exp CLLong -> Exp Float

FromIntegral CULLong Float

Methods

fromIntegral :: Exp CULLong -> Exp Float

() :=> (Enum Float)

Methods

ins :: () :- Enum Float

() :=> (Eq Float)

Methods

ins :: () :- Eq Float

() :=> (Floating Float)

Methods

ins :: () :- Floating Float

() :=> (Fractional Float)

Methods

ins :: () :- Fractional Float

() :=> (Num Float)

Methods

ins :: () :- Num Float

() :=> (Ord Float)

Methods

ins :: () :- Ord Float

() :=> (Real Float)

Methods

ins :: () :- Real Float

() :=> (RealFloat Float)

Methods

ins :: () :- RealFloat Float

() :=> (RealFrac Float)

Methods

ins :: () :- RealFrac Float

Generic1 (URec Float :: k -> *)

Associated Types

type Rep1 (URec Float) :: k -> *

Methods

from1 :: URec Float a -> Rep1 (URec Float) a

to1 :: Rep1 (URec Float) a -> URec Float a

Enum (Exp Float)

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)

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)

Methods

(/) :: Exp Float -> Exp Float -> Exp Float

recip :: Exp Float -> Exp Float

fromRational :: Rational -> Exp Float

Num (Exp Float)

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

Elt (Complex Float)

Methods

eltType :: Complex Float -> TupleType (EltRepr (Complex Float))

fromElt :: Complex Float -> EltRepr (Complex Float)

toElt :: EltRepr (Complex Float) -> Complex Float

Functor (URec Float :: * -> *)

Methods

fmap :: (a -> b) -> URec Float a -> URec Float b

(<$) :: a -> URec Float b -> URec Float a

Foldable (URec Float :: * -> *)

Methods

fold :: Monoid m => URec Float m -> m

foldMap :: Monoid m => (a -> m) -> URec Float a -> m

foldr :: (a -> b -> b) -> b -> URec Float a -> b

foldr' :: (a -> b -> b) -> b -> URec Float a -> b

foldl :: (b -> a -> b) -> b -> URec Float a -> b

foldl' :: (b -> a -> b) -> b -> URec Float a -> b

foldr1 :: (a -> a -> a) -> URec Float a -> a

foldl1 :: (a -> a -> a) -> URec Float a -> a

toList :: URec Float a -> [a]

null :: URec Float a -> Bool

length :: URec Float a -> Int

elem :: Eq a => a -> URec Float a -> Bool

maximum :: Ord a => URec Float a -> a

minimum :: Ord a => URec Float a -> a

sum :: Num a => URec Float a -> a

product :: Num a => URec Float a -> a

Traversable (URec Float :: * -> *)

Methods

traverse :: Applicative f => (a -> f b) -> URec Float a -> f (URec Float b)

sequenceA :: Applicative f => URec Float (f a) -> f (URec Float a)

mapM :: Monad m => (a -> m b) -> URec Float a -> m (URec Float b)

sequence :: Monad m => URec Float (m a) -> m (URec Float a)

Eq (URec Float p)

Methods

(==) :: URec Float p -> URec Float p -> Bool

(/=) :: URec Float p -> URec Float p -> Bool

Ord (URec Float p)

Methods

compare :: URec Float p -> URec Float p -> Ordering

(<) :: URec Float p -> URec Float p -> Bool

(<=) :: URec Float p -> URec Float p -> Bool

(>) :: URec Float p -> URec Float p -> Bool

(>=) :: URec Float p -> URec Float p -> Bool

max :: URec Float p -> URec Float p -> URec Float p

min :: URec Float p -> URec Float p -> URec Float p

Show (URec Float p)

Methods

showsPrec :: Int -> URec Float p -> ShowS

show :: URec Float p -> String

showList :: [URec Float p] -> ShowS

Generic (URec Float p)

Associated Types

type Rep (URec Float p) :: * -> *

Methods

from :: URec Float p -> Rep (URec Float p) x

to :: Rep (URec Float p) x -> URec Float p

type PrimSize Float

type PrimSize Float = 4

type Difference Float

type Difference Float = Float

data Vector Float

data Vector Float = V_Float (Vector Float)

type Plain Float

type Plain Float = Float

data URec Float (p :: k)

Used for marking occurrences of Float#

Since: 4.9.0.0

data URec Float (p :: k) = UFloat {

• uFloat# :: Float#

}

data MVector s Float

data MVector s Float = MV_Float (MVector s Float)

type Rep1 (URec Float :: k -> *)

type Rep1 (URec Float :: k -> *) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UFloat" PrefixI True) (S1 (MetaSel (Just "uFloat#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (UFloat :: k -> *)))

type Rep (URec Float p)

type Rep (URec Float p) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UFloat" PrefixI True) (S1 (MetaSel (Just "uFloat#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (UFloat :: * -> *)))

data Double

Double-precision floating point numbers. It is desirable that this type be at least equal in range and precision to the IEEE double-precision type.

Instances

Eq Double

Methods

(==) :: Double -> Double -> Bool

(/=) :: Double -> Double -> Bool

Floating Double

Since: 2.1

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

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: 2.1

Methods

readsPrec :: Int -> ReadS Double

readList :: ReadS [Double]

readPrec :: ReadPrec Double

readListPrec :: ReadPrec [Double]

RealFloat Double

Since: 2.1

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

Lift Double

Methods

lift :: Double -> Q Exp

Pretty Double

Methods

pretty :: Double -> Doc

prettyList :: [Double] -> Doc

PrintfArg Double

Since: 2.1

Methods

formatArg :: Double -> FieldFormatter

parseFormat :: Double -> ModifierParser

Storable Double

Since: 2.1

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

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

Associated Types

type Difference Double :: *

Methods

(-) :: Double -> Double -> Difference Double

NFData Double

Methods

rnf :: Double -> ()

Hashable Double

Methods

hashWithSalt :: Int -> Double -> Int

hash :: Double -> Int

Prim Double

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

Pretty Double

Methods

pretty :: Double -> Doc b

prettyList :: [Double] -> Doc b

IsScalar Double

Methods

scalarType :: ScalarType Double

IsNum Double

Methods

numType :: NumType Double

IsFloating Double

Methods

floatingType :: FloatingType Double

Elt Double

Methods

eltType :: Double -> TupleType (EltRepr Double)

fromElt :: Double -> EltRepr Double

toElt :: EltRepr Double -> Double

Eq Double

Methods

(==) :: Exp Double -> Exp Double -> Exp Bool

(/=) :: Exp Double -> Exp Double -> Exp Bool

Ord Double

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

RealFrac Double

Methods

properFraction :: (Num b, ToFloating b Double, IsIntegral b) => Exp Double -> (Exp b, Exp Double)

truncate :: (Elt b, IsIntegral b) => Exp Double -> Exp b

round :: (Elt b, IsIntegral b) => Exp Double -> Exp b

ceiling :: (Elt b, IsIntegral b) => Exp Double -> Exp b

floor :: (Elt b, IsIntegral b) => Exp Double -> Exp b

RealFloat Double

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

Vector Vector Double

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

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)

Lift Exp Double

Associated Types

type Plain Double :: *

Methods

lift :: Double -> Exp (Plain Double)

ToFloating Double Double

Methods

toFloating :: Exp Double -> Exp Double

ToFloating Double Float

Methods

toFloating :: Exp Double -> Exp Float

ToFloating Double CFloat

Methods

toFloating :: Exp Double -> Exp CFloat

ToFloating Double CDouble

Methods

toFloating :: Exp Double -> Exp CDouble

ToFloating Double Half

Methods

toFloating :: Exp Double -> Exp Half

ToFloating Float Double

Methods

toFloating :: Exp Float -> Exp Double

ToFloating Int Double

Methods

toFloating :: Exp Int -> Exp Double

ToFloating Int8 Double

Methods

toFloating :: Exp Int8 -> Exp Double

ToFloating Int16 Double

Methods

toFloating :: Exp Int16 -> Exp Double

ToFloating Int32 Double

Methods

toFloating :: Exp Int32 -> Exp Double

ToFloating Int64 Double

Methods

toFloating :: Exp Int64 -> Exp Double

ToFloating Word Double

Methods

toFloating :: Exp Word -> Exp Double

ToFloating Word8 Double

Methods

toFloating :: Exp Word8 -> Exp Double

ToFloating Word16 Double

Methods

toFloating :: Exp Word16 -> Exp Double

ToFloating Word32 Double

Methods

toFloating :: Exp Word32 -> Exp Double

ToFloating Word64 Double

Methods

toFloating :: Exp Word64 -> Exp Double

ToFloating CShort Double

Methods

toFloating :: Exp CShort -> Exp Double

ToFloating CUShort Double

Methods

toFloating :: Exp CUShort -> Exp Double

ToFloating CInt Double

Methods

toFloating :: Exp CInt -> Exp Double

ToFloating CUInt Double

Methods

toFloating :: Exp CUInt -> Exp Double

ToFloating CLong Double

Methods

toFloating :: Exp CLong -> Exp Double

ToFloating CULong Double

Methods

toFloating :: Exp CULong -> Exp Double

ToFloating CLLong Double

Methods

toFloating :: Exp CLLong -> Exp Double

ToFloating CULLong Double

Methods

toFloating :: Exp CULLong -> Exp Double

ToFloating CFloat Double

Methods

toFloating :: Exp CFloat -> Exp Double

ToFloating CDouble Double

Methods

toFloating :: Exp CDouble -> Exp Double

ToFloating Half Double

Methods

toFloating :: Exp Half -> Exp Double

FromIntegral Int Double

Methods

fromIntegral :: Exp Int -> Exp Double

FromIntegral Int8 Double

Methods

fromIntegral :: Exp Int8 -> Exp Double

FromIntegral Int16 Double

Methods

fromIntegral :: Exp Int16 -> Exp Double

FromIntegral Int32 Double

Methods

fromIntegral :: Exp Int32 -> Exp Double

FromIntegral Int64 Double

Methods

fromIntegral :: Exp Int64 -> Exp Double

FromIntegral Word Double

Methods

fromIntegral :: Exp Word -> Exp Double

FromIntegral Word8 Double

Methods

fromIntegral :: Exp Word8 -> Exp Double

FromIntegral Word16 Double

Methods

fromIntegral :: Exp Word16 -> Exp Double

FromIntegral Word32 Double

Methods

fromIntegral :: Exp Word32 -> Exp Double

FromIntegral Word64 Double

Methods

fromIntegral :: Exp Word64 -> Exp Double

FromIntegral CShort Double

Methods

fromIntegral :: Exp CShort -> Exp Double

FromIntegral CUShort Double

Methods

fromIntegral :: Exp CUShort -> Exp Double

FromIntegral CInt Double

Methods

fromIntegral :: Exp CInt -> Exp Double

FromIntegral CUInt Double

Methods

fromIntegral :: Exp CUInt -> Exp Double

FromIntegral CLong Double

Methods

fromIntegral :: Exp CLong -> Exp Double

FromIntegral CULong Double

Methods

fromIntegral :: Exp CULong -> Exp Double

FromIntegral CLLong Double

Methods

fromIntegral :: Exp CLLong -> Exp Double

FromIntegral CULLong Double

Methods

fromIntegral :: Exp CULLong -> Exp Double

() :=> (Enum Double)

Methods

ins :: () :- Enum Double

() :=> (Eq Double)

Methods

ins :: () :- Eq Double

() :=> (Floating Double)

Methods

ins :: () :- Floating Double

() :=> (Fractional Double)

Methods

ins :: () :- Fractional Double

() :=> (Num Double)

Methods

ins :: () :- Num Double

() :=> (Ord Double)

Methods

ins :: () :- Ord Double

() :=> (Real Double)

Methods

ins :: () :- Real Double

() :=> (RealFloat Double)

Methods

ins :: () :- RealFloat Double

() :=> (RealFrac Double)

Methods

ins :: () :- RealFrac Double

Generic1 (URec Double :: k -> *)

Associated Types

type Rep1 (URec Double) :: k -> *

Methods

from1 :: URec Double a -> Rep1 (URec Double) a

to1 :: Rep1 (URec Double) a -> URec Double a

Enum (Exp Double)

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)

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)

Methods

(/) :: Exp Double -> Exp Double -> Exp Double

recip :: Exp Double -> Exp Double

fromRational :: Rational -> Exp Double

Num (Exp Double)

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

Elt (Complex Double)

Methods

eltType :: Complex Double -> TupleType (EltRepr (Complex Double))

fromElt :: Complex Double -> EltRepr (Complex Double)

toElt :: EltRepr (Complex Double) -> Complex Double

Functor (URec Double :: * -> *)

Methods

fmap :: (a -> b) -> URec Double a -> URec Double b

(<$) :: a -> URec Double b -> URec Double a

Foldable (URec Double :: * -> *)

Methods

fold :: Monoid m => URec Double m -> m

foldMap :: Monoid m => (a -> m) -> URec Double a -> m

foldr :: (a -> b -> b) -> b -> URec Double a -> b

foldr' :: (a -> b -> b) -> b -> URec Double a -> b

foldl :: (b -> a -> b) -> b -> URec Double a -> b

foldl' :: (b -> a -> b) -> b -> URec Double a -> b

foldr1 :: (a -> a -> a) -> URec Double a -> a

foldl1 :: (a -> a -> a) -> URec Double a -> a

toList :: URec Double a -> [a]

null :: URec Double a -> Bool

length :: URec Double a -> Int

elem :: Eq a => a -> URec Double a -> Bool

maximum :: Ord a => URec Double a -> a

minimum :: Ord a => URec Double a -> a

sum :: Num a => URec Double a -> a

product :: Num a => URec Double a -> a

Traversable (URec Double :: * -> *)

Methods

traverse :: Applicative f => (a -> f b) -> URec Double a -> f (URec Double b)

sequenceA :: Applicative f => URec Double (f a) -> f (URec Double a)

mapM :: Monad m => (a -> m b) -> URec Double a -> m (URec Double b)

sequence :: Monad m => URec Double (m a) -> m (URec Double a)

Eq (URec Double p)

Methods

(==) :: URec Double p -> URec Double p -> Bool

(/=) :: URec Double p -> URec Double p -> Bool

Ord (URec Double p)

Methods

compare :: URec Double p -> URec Double p -> Ordering

(<) :: URec Double p -> URec Double p -> Bool

(<=) :: URec Double p -> URec Double p -> Bool

(>) :: URec Double p -> URec Double p -> Bool

(>=) :: URec Double p -> URec Double p -> Bool

max :: URec Double p -> URec Double p -> URec Double p

min :: URec Double p -> URec Double p -> URec Double p

Show (URec Double p)

Methods

showsPrec :: Int -> URec Double p -> ShowS

show :: URec Double p -> String

showList :: [URec Double p] -> ShowS

Generic (URec Double p)

Associated Types

type Rep (URec Double p) :: * -> *

Methods

from :: URec Double p -> Rep (URec Double p) x

to :: Rep (URec Double p) x -> URec Double p

type PrimSize Double

type PrimSize Double = 8

type Difference Double

type Difference Double = Double

data Vector Double

data Vector Double = V_Double (Vector Double)

type Plain Double

type Plain Double = Double

data URec Double (p :: k)

Used for marking occurrences of Double#

Since: 4.9.0.0

data URec Double (p :: k) = UDouble {

• uDouble# :: Double#

}

data MVector s Double

data MVector s Double = MV_Double (MVector s Double)

type Rep1 (URec Double :: k -> *)

type Rep1 (URec Double :: k -> *) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UDouble" PrefixI True) (S1 (MetaSel (Just "uDouble#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (UDouble :: k -> *)))

type Rep (URec Double p)

type Rep (URec Double p) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UDouble" PrefixI True) (S1 (MetaSel (Just "uDouble#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (UDouble :: * -> *)))

data Bool

Constructors

False

True

Instances

Bounded Bool

Since: 2.1

Methods

minBound :: Bool

maxBound :: Bool

Enum Bool

Since: 2.1

Methods

succ :: Bool -> Bool

pred :: Bool -> Bool

toEnum :: Int -> Bool

fromEnum :: Bool -> Int

enumFrom :: Bool -> [Bool]

enumFromThen :: Bool -> Bool -> [Bool]

enumFromTo :: Bool -> Bool -> [Bool]

enumFromThenTo :: Bool -> Bool -> Bool -> [Bool]

Eq Bool

Methods

(==) :: Bool -> Bool -> Bool

(/=) :: Bool -> Bool -> Bool

Ord Bool

Methods

compare :: Bool -> Bool -> Ordering

(<) :: Bool -> Bool -> Bool

(<=) :: Bool -> Bool -> Bool

(>) :: Bool -> Bool -> Bool

(>=) :: Bool -> Bool -> Bool

max :: Bool -> Bool -> Bool

min :: Bool -> Bool -> Bool

Read Bool

Since: 2.1

Methods

readsPrec :: Int -> ReadS Bool

readList :: ReadS [Bool]

readPrec :: ReadPrec Bool

readListPrec :: ReadPrec [Bool]

Show Bool

Methods

showsPrec :: Int -> Bool -> ShowS

show :: Bool -> String

showList :: [Bool] -> ShowS

Generic Bool

Associated Types

type Rep Bool :: * -> *

Methods

from :: Bool -> Rep Bool x

to :: Rep Bool x -> Bool

Lift Bool

Methods

lift :: Bool -> Q Exp

Pretty Bool

Methods

pretty :: Bool -> Doc

prettyList :: [Bool] -> Doc

SingKind Bool

Since: 4.9.0.0

Associated Types

type DemoteRep Bool :: *

Methods

fromSing :: Sing a -> DemoteRep Bool

Storable Bool

Since: 2.1

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: 4.7.0.0

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: 4.7.0.0

Methods

finiteBitSize :: Bool -> Int

countLeadingZeros :: Bool -> Int

countTrailingZeros :: Bool -> Int

NFData Bool

Methods

rnf :: Bool -> ()

Hashable Bool

Methods

hashWithSalt :: Int -> Bool -> Int

hash :: Bool -> Int

Unbox Bool

AssertionPredicable Bool

Methods

assertionPredicate :: Bool -> IO Bool

Assertable Bool

Methods

assert :: Bool -> Assertion

Pretty Bool

Methods

pretty :: Bool -> Doc b

prettyList :: [Bool] -> Doc b

IsScalar Bool

Methods

scalarType :: ScalarType Bool

IsBounded Bool

Methods

boundedType :: BoundedType Bool

IsNonNum Bool

Methods

nonNumType :: NonNumType Bool

Elt Bool

Methods

eltType :: Bool -> TupleType (EltRepr Bool)

fromElt :: Bool -> EltRepr Bool

toElt :: EltRepr Bool -> Bool

Eq Bool

Methods

(==) :: Exp Bool -> Exp Bool -> Exp Bool

(/=) :: Exp Bool -> Exp Bool -> Exp Bool

Ord Bool

Methods

(<) :: Exp Bool -> Exp Bool -> Exp Bool

(>) :: Exp Bool -> Exp Bool -> Exp Bool

(<=) :: Exp Bool -> Exp Bool -> Exp Bool

(>=) :: Exp Bool -> Exp Bool -> Exp Bool

min :: Exp Bool -> Exp Bool -> Exp Bool

max :: Exp Bool -> Exp Bool -> Exp Bool

compare :: Exp Bool -> Exp Bool -> Exp Ordering

FiniteBits Bool

Methods

finiteBitSize :: Exp Bool -> Exp Int

countLeadingZeros :: Exp Bool -> Exp Int

countTrailingZeros :: Exp Bool -> Exp Int

Bits Bool

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

SingI False

Since: 4.9.0.0

Methods

sing :: Sing False

SingI True

Since: 4.9.0.0

Methods

sing :: Sing True

Vector Vector Bool

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

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)

Lift Exp Bool

Associated Types

type Plain Bool :: *

Methods

lift :: Bool -> Exp (Plain Bool)

() :=> (Bounded Bool)

Methods

ins :: () :- Bounded Bool

() :=> (Enum Bool)

Methods

ins :: () :- Enum Bool

() :=> (Eq Bool)

Methods

ins :: () :- Eq Bool

() :=> (Ord Bool)

Methods

ins :: () :- Ord Bool

() :=> (Read Bool)

Methods

ins :: () :- Read Bool

() :=> (Show Bool)

Methods

ins :: () :- Show Bool

() :=> (Bits Bool)

Methods

ins :: () :- Bits Bool

Bounded (Exp Bool)

Methods

minBound :: Exp Bool

maxBound :: Exp Bool

type Rep Bool

type Rep Bool = D1 (MetaData "Bool" "GHC.Types" "ghc-prim" False) (C1 (MetaCons "False" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "True" PrefixI False) (U1 :: * -> *))

data Sing (a :: Bool)

data Sing (a :: Bool) where

• STrue :: Sing True
• SFalse :: Sing False

type DemoteRep Bool

type DemoteRep Bool = Bool

data Vector Bool

data Vector Bool = V_Bool (Vector Word8)

type Plain Bool

type Plain Bool = Bool

data MVector s Bool

data MVector s Bool = MV_Bool (MVector s Word8)

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: 2.1

Methods

minBound :: Char

maxBound :: Char

Enum Char

Since: 2.1

Methods

succ :: Char -> Char

pred :: Char -> Char

toEnum :: Int -> Char

fromEnum :: Char -> Int

enumFrom :: Char -> [Char]

enumFromThen :: Char -> Char -> [Char]

enumFromTo :: Char -> Char -> [Char]

enumFromThenTo :: Char -> Char -> Char -> [Char]

Eq Char

Methods

(==) :: Char -> Char -> Bool

(/=) :: Char -> Char -> Bool

Ord Char

Methods

compare :: Char -> Char -> Ordering

(<) :: Char -> Char -> Bool

(<=) :: Char -> Char -> Bool

(>) :: Char -> Char -> Bool

(>=) :: Char -> Char -> Bool

max :: Char -> Char -> Char

min :: Char -> Char -> Char

Read Char

Since: 2.1

Methods

readsPrec :: Int -> ReadS Char

readList :: ReadS [Char]

readPrec :: ReadPrec Char

readListPrec :: ReadPrec [Char]

Show Char

Since: 2.1

Methods

showsPrec :: Int -> Char -> ShowS

show :: Char -> String

showList :: [Char] -> ShowS

Lift Char

Methods

lift :: Char -> Q Exp

Pretty Char

Methods

pretty :: Char -> Doc

prettyList :: [Char] -> Doc

PrintfArg Char

Since: 2.1

Methods

formatArg :: Char -> FieldFormatter

parseFormat :: Char -> ModifierParser

IsChar Char

Since: 2.1

Methods

toChar :: Char -> Char

fromChar :: Char -> Char

Storable Char

Since: 2.1

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

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

Subtractive Char

Associated Types

type Difference Char :: *

Methods

(-) :: Char -> Char -> Difference Char

NFData Char

Methods

rnf :: Char -> ()

Hashable Char

Methods

hashWithSalt :: Int -> Char -> Int

hash :: Char -> Int

Prim Char

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

Assertable String

Methods

assert :: String -> Assertion

ErrorList Char

Methods

listMsg :: String -> [Char]

Pretty Char

Methods

pretty :: Char -> Doc b

prettyList :: [Char] -> Doc b

IsScalar Char

Methods

scalarType :: ScalarType Char

IsBounded Char

Methods

boundedType :: BoundedType Char

IsNonNum Char

Methods

nonNumType :: NonNumType Char

Elt Char

Methods

eltType :: Char -> TupleType (EltRepr Char)

fromElt :: Char -> EltRepr Char

toElt :: EltRepr Char -> Char

Eq Char

Methods

(==) :: Exp Char -> Exp Char -> Exp Bool

(/=) :: Exp Char -> Exp Char -> Exp Bool

Ord Char

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

Vector Vector Char

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

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

Associated Types

type Plain Char :: *

Methods

lift :: Char -> Exp (Plain Char)

KnownSymbol n => Reifies (n :: Symbol) String

Methods

reflect :: proxy n -> String

Cons Text Text Char Char

Methods

_Cons :: Prism Text Text (Char, Text) (Char, Text)

Cons Text Text Char Char

Methods

_Cons :: Prism Text Text (Char, Text) (Char, Text)

Snoc Text Text Char Char

Methods

_Snoc :: Prism Text Text (Text, Char) (Text, Char)

Snoc Text Text Char Char

Methods

_Snoc :: Prism Text Text (Text, Char) (Text, Char)

() :=> (Bounded Char)

Methods

ins :: () :- Bounded Char

() :=> (Enum Char)

Methods

ins :: () :- Enum Char

() :=> (Ord Char)

Methods

ins :: () :- Ord Char

() :=> (Read Char)

Methods

ins :: () :- Read Char

() :=> (Show Char)

Methods

ins :: () :- Show Char

Generic1 (URec Char :: k -> *)

Associated Types

type Rep1 (URec Char) :: k -> *

Methods

from1 :: URec Char a -> Rep1 (URec Char) a

to1 :: Rep1 (URec Char) a -> URec Char a

Bounded (Exp Char)

Methods

minBound :: Exp Char

maxBound :: Exp Char

Functor (URec Char :: * -> *)

Methods

fmap :: (a -> b) -> URec Char a -> URec Char b

(<$) :: a -> URec Char b -> URec Char a

Foldable (URec Char :: * -> *)

Methods

fold :: Monoid m => URec Char m -> m

foldMap :: Monoid m => (a -> m) -> URec Char a -> m

foldr :: (a -> b -> b) -> b -> URec Char a -> b

foldr' :: (a -> b -> b) -> b -> URec Char a -> b

foldl :: (b -> a -> b) -> b -> URec Char a -> b

foldl' :: (b -> a -> b) -> b -> URec Char a -> b

foldr1 :: (a -> a -> a) -> URec Char a -> a

foldl1 :: (a -> a -> a) -> URec Char a -> a

toList :: URec Char a -> [a]

null :: URec Char a -> Bool

length :: URec Char a -> Int

elem :: Eq a => a -> URec Char a -> Bool

maximum :: Ord a => URec Char a -> a

minimum :: Ord a => URec Char a -> a

sum :: Num a => URec Char a -> a

product :: Num a => URec Char a -> a

Traversable (URec Char :: * -> *)

Methods

traverse :: Applicative f => (a -> f b) -> URec Char a -> f (URec Char b)

sequenceA :: Applicative f => URec Char (f a) -> f (URec Char a)

mapM :: Monad m => (a -> m b) -> URec Char a -> m (URec Char b)

sequence :: Monad m => URec Char (m a) -> m (URec Char a)

Eq (URec Char p)

Methods

(==) :: URec Char p -> URec Char p -> Bool

(/=) :: URec Char p -> URec Char p -> Bool

Ord (URec Char p)

Methods

compare :: URec Char p -> URec Char p -> Ordering

(<) :: URec Char p -> URec Char p -> Bool

(<=) :: URec Char p -> URec Char p -> Bool

(>) :: URec Char p -> URec Char p -> Bool

(>=) :: URec Char p -> URec Char p -> Bool

max :: URec Char p -> URec Char p -> URec Char p

min :: URec Char p -> URec Char p -> URec Char p

Show (URec Char p)

Methods

showsPrec :: Int -> URec Char p -> ShowS

show :: URec Char p -> String

showList :: [URec Char p] -> ShowS

Generic (URec Char p)

Associated Types

type Rep (URec Char p) :: * -> *

Methods

from :: URec Char p -> Rep (URec Char p) x

to :: Rep (URec Char p) x -> URec Char p

type PrimSize Char

type PrimSize Char = 4

type Difference Char

type Difference Char = Int

type NatNumMaxBound Char

type NatNumMaxBound Char = 1114111

data Vector Char

data Vector Char = V_Char (Vector Char)

type Plain Char

type Plain Char = Char

data URec Char (p :: k)

Used for marking occurrences of Char#

Since: 4.9.0.0

data URec Char (p :: k) = UChar {

• uChar# :: Char#

}

data MVector s Char

data MVector s Char = MV_Char (MVector s Char)

type Rep1 (URec Char :: k -> *)

type Rep1 (URec Char :: k -> *) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UChar" PrefixI True) (S1 (MetaSel (Just "uChar#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (UChar :: k -> *)))

type Rep (URec Char p)

type Rep (URec Char p) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UChar" PrefixI True) (S1 (MetaSel (Just "uChar#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (UChar :: * -> *)))

data CFloat

Haskell type representing the C float type.

Instances

Enum CFloat

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

Methods

(==) :: CFloat -> CFloat -> Bool

(/=) :: CFloat -> CFloat -> Bool

Floating CFloat

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

Methods

(/) :: CFloat -> CFloat -> CFloat

recip :: CFloat -> CFloat

fromRational :: Rational -> CFloat

Num CFloat

Methods

(+) :: CFloat -> CFloat -> CFloat

(-) :: CFloat -> CFloat -> CFloat

(*) :: CFloat -> CFloat -> CFloat

negate :: CFloat -> CFloat

abs :: CFloat -> CFloat

signum :: CFloat -> CFloat

fromInteger :: Integer -> CFloat

Ord CFloat

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

Methods

readsPrec :: Int -> ReadS CFloat

readList :: ReadS [CFloat]

readPrec :: ReadPrec CFloat

readListPrec :: ReadPrec [CFloat]

Real CFloat

Methods

toRational :: CFloat -> Rational

RealFloat CFloat

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

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

Methods

showsPrec :: Int -> CFloat -> ShowS

show :: CFloat -> String

showList :: [CFloat] -> ShowS

Storable CFloat

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

Associated Types

type Difference CFloat :: *

Methods

(-) :: CFloat -> CFloat -> Difference CFloat

NFData CFloat

Since: 1.4.0.0

Methods

rnf :: CFloat -> ()

Wrapped CFloat

Associated Types

type Unwrapped CFloat :: *

Methods

_Wrapped' :: Iso' CFloat (Unwrapped CFloat)

IsScalar CFloat

Methods

scalarType :: ScalarType CFloat

IsNum CFloat

Methods

numType :: NumType CFloat

IsFloating CFloat

Methods

floatingType :: FloatingType CFloat

Elt CFloat

Methods

eltType :: CFloat -> TupleType (EltRepr CFloat)

fromElt :: CFloat -> EltRepr CFloat

toElt :: EltRepr CFloat -> CFloat

Eq CFloat

Methods

(==) :: Exp CFloat -> Exp CFloat -> Exp Bool

(/=) :: Exp CFloat -> Exp CFloat -> Exp Bool

Ord CFloat

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

RealFrac CFloat

Methods

properFraction :: (Num b, ToFloating b CFloat, IsIntegral b) => Exp CFloat -> (Exp b, Exp CFloat)

truncate :: (Elt b, IsIntegral b) => Exp CFloat -> Exp b

round :: (Elt b, IsIntegral b) => Exp CFloat -> Exp b

ceiling :: (Elt b, IsIntegral b) => Exp CFloat -> Exp b

floor :: (Elt b, IsIntegral b) => Exp CFloat -> Exp b

RealFloat CFloat

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

Lift Exp CFloat

Associated Types

type Plain CFloat :: *

Methods

lift :: CFloat -> Exp (Plain CFloat)

ToFloating Double CFloat

Methods

toFloating :: Exp Double -> Exp CFloat

ToFloating Float CFloat

Methods

toFloating :: Exp Float -> Exp CFloat

ToFloating Int CFloat

Methods

toFloating :: Exp Int -> Exp CFloat

ToFloating Int8 CFloat

Methods

toFloating :: Exp Int8 -> Exp CFloat

ToFloating Int16 CFloat

Methods

toFloating :: Exp Int16 -> Exp CFloat

ToFloating Int32 CFloat

Methods

toFloating :: Exp Int32 -> Exp CFloat

ToFloating Int64 CFloat

Methods

toFloating :: Exp Int64 -> Exp CFloat

ToFloating Word CFloat

Methods

toFloating :: Exp Word -> Exp CFloat

ToFloating Word8 CFloat

Methods

toFloating :: Exp Word8 -> Exp CFloat

ToFloating Word16 CFloat

Methods

toFloating :: Exp Word16 -> Exp CFloat

ToFloating Word32 CFloat

Methods

toFloating :: Exp Word32 -> Exp CFloat

ToFloating Word64 CFloat

Methods

toFloating :: Exp Word64 -> Exp CFloat

ToFloating CShort CFloat

Methods

toFloating :: Exp CShort -> Exp CFloat

ToFloating CUShort CFloat

Methods

toFloating :: Exp CUShort -> Exp CFloat

ToFloating CInt CFloat

Methods

toFloating :: Exp CInt -> Exp CFloat

ToFloating CUInt CFloat

Methods

toFloating :: Exp CUInt -> Exp CFloat

ToFloating CLong CFloat

Methods

toFloating :: Exp CLong -> Exp CFloat

ToFloating CULong CFloat

Methods

toFloating :: Exp CULong -> Exp CFloat

ToFloating CLLong CFloat

Methods

toFloating :: Exp CLLong -> Exp CFloat

ToFloating CULLong CFloat

Methods

toFloating :: Exp CULLong -> Exp CFloat

ToFloating CFloat Double

Methods

toFloating :: Exp CFloat -> Exp Double

ToFloating CFloat Float

Methods

toFloating :: Exp CFloat -> Exp Float

ToFloating CFloat CFloat

Methods

toFloating :: Exp CFloat -> Exp CFloat

ToFloating CFloat CDouble

Methods

toFloating :: Exp CFloat -> Exp CDouble

ToFloating CFloat Half

Methods

toFloating :: Exp CFloat -> Exp Half

ToFloating CDouble CFloat

Methods

toFloating :: Exp CDouble -> Exp CFloat

ToFloating Half CFloat

Methods

toFloating :: Exp Half -> Exp CFloat

FromIntegral Int CFloat

Methods

fromIntegral :: Exp Int -> Exp CFloat

FromIntegral Int8 CFloat

Methods

fromIntegral :: Exp Int8 -> Exp CFloat

FromIntegral Int16 CFloat

Methods

fromIntegral :: Exp Int16 -> Exp CFloat

FromIntegral Int32 CFloat

Methods

fromIntegral :: Exp Int32 -> Exp CFloat

FromIntegral Int64 CFloat

Methods

fromIntegral :: Exp Int64 -> Exp CFloat

FromIntegral Word CFloat

Methods

fromIntegral :: Exp Word -> Exp CFloat

FromIntegral Word8 CFloat

Methods

fromIntegral :: Exp Word8 -> Exp CFloat

FromIntegral Word16 CFloat

Methods

fromIntegral :: Exp Word16 -> Exp CFloat

FromIntegral Word32 CFloat

Methods

fromIntegral :: Exp Word32 -> Exp CFloat

FromIntegral Word64 CFloat

Methods

fromIntegral :: Exp Word64 -> Exp CFloat

FromIntegral CShort CFloat

Methods

fromIntegral :: Exp CShort -> Exp CFloat

FromIntegral CUShort CFloat

Methods

fromIntegral :: Exp CUShort -> Exp CFloat

FromIntegral CInt CFloat

Methods

fromIntegral :: Exp CInt -> Exp CFloat

FromIntegral CUInt CFloat

Methods

fromIntegral :: Exp CUInt -> Exp CFloat

FromIntegral CLong CFloat

Methods

fromIntegral :: Exp CLong -> Exp CFloat

FromIntegral CULong CFloat

Methods

fromIntegral :: Exp CULong -> Exp CFloat

FromIntegral CLLong CFloat

Methods

fromIntegral :: Exp CLLong -> Exp CFloat

FromIntegral CULLong CFloat

Methods

fromIntegral :: Exp CULLong -> Exp CFloat

Enum (Exp CFloat)

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)

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)

Methods

(/) :: Exp CFloat -> Exp CFloat -> Exp CFloat

recip :: Exp CFloat -> Exp CFloat

fromRational :: Rational -> Exp CFloat

Num (Exp CFloat)

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

Elt (Complex CFloat)

Methods

eltType :: Complex CFloat -> TupleType (EltRepr (Complex CFloat))

fromElt :: Complex CFloat -> EltRepr (Complex CFloat)

toElt :: EltRepr (Complex CFloat) -> Complex CFloat

type Difference CFloat

type Difference CFloat = CFloat

type Unwrapped CFloat

type Unwrapped CFloat = Float

type Plain CFloat

type Plain CFloat = CFloat

data CDouble

Haskell type representing the C double type.

Instances

Enum CDouble

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

Methods

(==) :: CDouble -> CDouble -> Bool

(/=) :: CDouble -> CDouble -> Bool

Floating CDouble

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

Methods

(/) :: CDouble -> CDouble -> CDouble

recip :: CDouble -> CDouble

fromRational :: Rational -> CDouble

Num CDouble

Methods

(+) :: CDouble -> CDouble -> CDouble

(-) :: CDouble -> CDouble -> CDouble

(*) :: CDouble -> CDouble -> CDouble

negate :: CDouble -> CDouble

abs :: CDouble -> CDouble

signum :: CDouble -> CDouble

fromInteger :: Integer -> CDouble

Ord CDouble

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

Methods

readsPrec :: Int -> ReadS CDouble

readList :: ReadS [CDouble]

readPrec :: ReadPrec CDouble

readListPrec :: ReadPrec [CDouble]

Real CDouble

Methods

toRational :: CDouble -> Rational

RealFloat CDouble

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

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

Methods

showsPrec :: Int -> CDouble -> ShowS

show :: CDouble -> String

showList :: [CDouble] -> ShowS

Storable CDouble

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

Associated Types

type Difference CDouble :: *

Methods

(-) :: CDouble -> CDouble -> Difference CDouble

NFData CDouble

Since: 1.4.0.0

Methods

rnf :: CDouble -> ()

Wrapped CDouble

Associated Types

type Unwrapped CDouble :: *

Methods

_Wrapped' :: Iso' CDouble (Unwrapped CDouble)

IsScalar CDouble

Methods

scalarType :: ScalarType CDouble

IsNum CDouble

Methods

numType :: NumType CDouble

IsFloating CDouble

Methods

floatingType :: FloatingType CDouble

Elt CDouble

Methods

eltType :: CDouble -> TupleType (EltRepr CDouble)

fromElt :: CDouble -> EltRepr CDouble

toElt :: EltRepr CDouble -> CDouble

Eq CDouble

Methods

(==) :: Exp CDouble -> Exp CDouble -> Exp Bool

(/=) :: Exp CDouble -> Exp CDouble -> Exp Bool

Ord CDouble

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

RealFrac CDouble

Methods

properFraction :: (Num b, ToFloating b CDouble, IsIntegral b) => Exp CDouble -> (Exp b, Exp CDouble)

truncate :: (Elt b, IsIntegral b) => Exp CDouble -> Exp b

round :: (Elt b, IsIntegral b) => Exp CDouble -> Exp b

ceiling :: (Elt b, IsIntegral b) => Exp CDouble -> Exp b

floor :: (Elt b, IsIntegral b) => Exp CDouble -> Exp b

RealFloat CDouble

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

Lift Exp CDouble

Associated Types

type Plain CDouble :: *

Methods

lift :: CDouble -> Exp (Plain CDouble)

ToFloating Double CDouble

Methods

toFloating :: Exp Double -> Exp CDouble

ToFloating Float CDouble

Methods

toFloating :: Exp Float -> Exp CDouble

ToFloating Int CDouble

Methods

toFloating :: Exp Int -> Exp CDouble

ToFloating Int8 CDouble

Methods

toFloating :: Exp Int8 -> Exp CDouble

ToFloating Int16 CDouble

Methods

toFloating :: Exp Int16 -> Exp CDouble

ToFloating Int32 CDouble

Methods

toFloating :: Exp Int32 -> Exp CDouble

ToFloating Int64 CDouble

Methods

toFloating :: Exp Int64 -> Exp CDouble

ToFloating Word CDouble

Methods

toFloating :: Exp Word -> Exp CDouble

ToFloating Word8 CDouble

Methods

toFloating :: Exp Word8 -> Exp CDouble

ToFloating Word16 CDouble

Methods

toFloating :: Exp Word16 -> Exp CDouble

ToFloating Word32 CDouble

Methods

toFloating :: Exp Word32 -> Exp CDouble

ToFloating Word64 CDouble

Methods

toFloating :: Exp Word64 -> Exp CDouble

ToFloating CShort CDouble

Methods

toFloating :: Exp CShort -> Exp CDouble

ToFloating CUShort CDouble

Methods

toFloating :: Exp CUShort -> Exp CDouble

ToFloating CInt CDouble

Methods

toFloating :: Exp CInt -> Exp CDouble

ToFloating CUInt CDouble

Methods

toFloating :: Exp CUInt -> Exp CDouble

ToFloating CLong CDouble

Methods

toFloating :: Exp CLong -> Exp CDouble

ToFloating CULong CDouble

Methods

toFloating :: Exp CULong -> Exp CDouble

ToFloating CLLong CDouble

Methods

toFloating :: Exp CLLong -> Exp CDouble

ToFloating CULLong CDouble

Methods

toFloating :: Exp CULLong -> Exp CDouble

ToFloating CFloat CDouble

Methods

toFloating :: Exp CFloat -> Exp CDouble

ToFloating CDouble Double

Methods

toFloating :: Exp CDouble -> Exp Double

ToFloating CDouble Float

Methods

toFloating :: Exp CDouble -> Exp Float

ToFloating CDouble CFloat

Methods

toFloating :: Exp CDouble -> Exp CFloat

ToFloating CDouble CDouble

Methods

toFloating :: Exp CDouble -> Exp CDouble

ToFloating CDouble Half

Methods

toFloating :: Exp CDouble -> Exp Half

ToFloating Half CDouble

Methods

toFloating :: Exp Half -> Exp CDouble

FromIntegral Int CDouble

Methods

fromIntegral :: Exp Int -> Exp CDouble

FromIntegral Int8 CDouble

Methods

fromIntegral :: Exp Int8 -> Exp CDouble

FromIntegral Int16 CDouble

Methods

fromIntegral :: Exp Int16 -> Exp CDouble

FromIntegral Int32 CDouble

Methods

fromIntegral :: Exp Int32 -> Exp CDouble

FromIntegral Int64 CDouble

Methods

fromIntegral :: Exp Int64 -> Exp CDouble

FromIntegral Word CDouble

Methods

fromIntegral :: Exp Word -> Exp CDouble

FromIntegral Word8 CDouble

Methods

fromIntegral :: Exp Word8 -> Exp CDouble

FromIntegral Word16 CDouble

Methods

fromIntegral :: Exp Word16 -> Exp CDouble

FromIntegral Word32 CDouble

Methods

fromIntegral :: Exp Word32 -> Exp CDouble

FromIntegral Word64 CDouble

Methods

fromIntegral :: Exp Word64 -> Exp CDouble

FromIntegral CShort CDouble

Methods

fromIntegral :: Exp CShort -> Exp CDouble

FromIntegral CUShort CDouble

Methods

fromIntegral :: Exp CUShort -> Exp CDouble

FromIntegral CInt CDouble

Methods

fromIntegral :: Exp CInt -> Exp CDouble

FromIntegral CUInt CDouble

Methods

fromIntegral :: Exp CUInt -> Exp CDouble

FromIntegral CLong CDouble

Methods

fromIntegral :: Exp CLong -> Exp CDouble

FromIntegral CULong CDouble

Methods

fromIntegral :: Exp CULong -> Exp CDouble

FromIntegral CLLong CDouble

Methods

fromIntegral :: Exp CLLong -> Exp CDouble

FromIntegral CULLong CDouble

Methods

fromIntegral :: Exp CULLong -> Exp CDouble

Enum (Exp CDouble)

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)

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)

Methods

(/) :: Exp CDouble -> Exp CDouble -> Exp CDouble

recip :: Exp CDouble -> Exp CDouble

fromRational :: Rational -> Exp CDouble

Num (Exp CDouble)

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

Elt (Complex CDouble)

Methods

eltType :: Complex CDouble -> TupleType (EltRepr (Complex CDouble))

fromElt :: Complex CDouble -> EltRepr (Complex CDouble)

toElt :: EltRepr (Complex CDouble) -> Complex CDouble

type Difference CDouble

type Difference CDouble = CDouble

type Unwrapped CDouble

type Unwrapped CDouble = Double

type Plain CDouble

type Plain CDouble = CDouble

data CShort

Haskell type representing the C short type.

Instances

Bounded CShort

Methods

minBound :: CShort

maxBound :: CShort

Enum CShort

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

Methods

(==) :: CShort -> CShort -> Bool

(/=) :: CShort -> CShort -> Bool

Integral CShort

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

Methods

(+) :: CShort -> CShort -> CShort

(-) :: CShort -> CShort -> CShort

(*) :: CShort -> CShort -> CShort

negate :: CShort -> CShort

abs :: CShort -> CShort

signum :: CShort -> CShort

fromInteger :: Integer -> CShort

Ord CShort

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

Methods

readsPrec :: Int -> ReadS CShort

readList :: ReadS [CShort]

readPrec :: ReadPrec CShort

readListPrec :: ReadPrec [CShort]

Real CShort

Methods

toRational :: CShort -> Rational

Show CShort

Methods

showsPrec :: Int -> CShort -> ShowS

show :: CShort -> String

showList :: [CShort] -> ShowS

Storable CShort

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

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

Methods

finiteBitSize :: CShort -> Int

countLeadingZeros :: CShort -> Int

countTrailingZeros :: CShort -> Int

Subtractive CShort

Associated Types

type Difference CShort :: *

Methods

(-) :: CShort -> CShort -> Difference CShort

NFData CShort

Since: 1.4.0.0

Methods

rnf :: CShort -> ()

Wrapped CShort

Associated Types

type Unwrapped CShort :: *

Methods

_Wrapped' :: Iso' CShort (Unwrapped CShort)

IsScalar CShort

Methods

scalarType :: ScalarType CShort

IsBounded CShort

Methods

boundedType :: BoundedType CShort

IsNum CShort

Methods

numType :: NumType CShort

IsIntegral CShort

Methods

integralType :: IntegralType CShort

Elt CShort

Methods

eltType :: CShort -> TupleType (EltRepr CShort)

fromElt :: CShort -> EltRepr CShort

toElt :: EltRepr CShort -> CShort

Eq CShort

Methods

(==) :: Exp CShort -> Exp CShort -> Exp Bool

(/=) :: Exp CShort -> Exp CShort -> Exp Bool

Ord CShort

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

Methods

finiteBitSize :: Exp CShort -> Exp Int

countLeadingZeros :: Exp CShort -> Exp Int

countTrailingZeros :: Exp CShort -> Exp Int

Bits CShort

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

Lift Exp CShort

Associated Types

type Plain CShort :: *

Methods

lift :: CShort -> Exp (Plain CShort)

ToFloating CShort Double

Methods

toFloating :: Exp CShort -> Exp Double

ToFloating CShort Float

Methods

toFloating :: Exp CShort -> Exp Float

ToFloating CShort CFloat

Methods

toFloating :: Exp CShort -> Exp CFloat

ToFloating CShort CDouble

Methods

toFloating :: Exp CShort -> Exp CDouble

ToFloating CShort Half

Methods

toFloating :: Exp CShort -> Exp Half

FromIntegral Int CShort

Methods

fromIntegral :: Exp Int -> Exp CShort

FromIntegral Int8 CShort

Methods

fromIntegral :: Exp Int8 -> Exp CShort

FromIntegral Int16 CShort

Methods

fromIntegral :: Exp Int16 -> Exp CShort

FromIntegral Int32 CShort

Methods

fromIntegral :: Exp Int32 -> Exp CShort

FromIntegral Int64 CShort

Methods

fromIntegral :: Exp Int64 -> Exp CShort

FromIntegral Word CShort

Methods

fromIntegral :: Exp Word -> Exp CShort

FromIntegral Word8 CShort

Methods

fromIntegral :: Exp Word8 -> Exp CShort

FromIntegral Word16 CShort

Methods

fromIntegral :: Exp Word16 -> Exp CShort

FromIntegral Word32 CShort

Methods

fromIntegral :: Exp Word32 -> Exp CShort

FromIntegral Word64 CShort

Methods

fromIntegral :: Exp Word64 -> Exp CShort

FromIntegral CShort Double

Methods

fromIntegral :: Exp CShort -> Exp Double

FromIntegral CShort Float

Methods

fromIntegral :: Exp CShort -> Exp Float

FromIntegral CShort Int

Methods

fromIntegral :: Exp CShort -> Exp Int

FromIntegral CShort Int8

Methods

fromIntegral :: Exp CShort -> Exp Int8

FromIntegral CShort Int16

Methods

fromIntegral :: Exp CShort -> Exp Int16

FromIntegral CShort Int32

Methods

fromIntegral :: Exp CShort -> Exp Int32

FromIntegral CShort Int64

Methods

fromIntegral :: Exp CShort -> Exp Int64

FromIntegral CShort Word

Methods

fromIntegral :: Exp CShort -> Exp Word

FromIntegral CShort Word8

Methods

fromIntegral :: Exp CShort -> Exp Word8

FromIntegral CShort Word16

Methods

fromIntegral :: Exp CShort -> Exp Word16

FromIntegral CShort Word32

Methods

fromIntegral :: Exp CShort -> Exp Word32

FromIntegral CShort Word64

Methods

fromIntegral :: Exp CShort -> Exp Word64

FromIntegral CShort CShort

Methods

fromIntegral :: Exp CShort -> Exp CShort

FromIntegral CShort CUShort

Methods

fromIntegral :: Exp CShort -> Exp CUShort

FromIntegral CShort CInt

Methods

fromIntegral :: Exp CShort -> Exp CInt

FromIntegral CShort CUInt

Methods

fromIntegral :: Exp CShort -> Exp CUInt

FromIntegral CShort CLong

Methods

fromIntegral :: Exp CShort -> Exp CLong

FromIntegral CShort CULong

Methods

fromIntegral :: Exp CShort -> Exp CULong

FromIntegral CShort CLLong

Methods

fromIntegral :: Exp CShort -> Exp CLLong

FromIntegral CShort CULLong

Methods

fromIntegral :: Exp CShort -> Exp CULLong

FromIntegral CShort CFloat

Methods

fromIntegral :: Exp CShort -> Exp CFloat

FromIntegral CShort CDouble

Methods

fromIntegral :: Exp CShort -> Exp CDouble

FromIntegral CShort Half

Methods

fromIntegral :: Exp CShort -> Exp Half

FromIntegral CUShort CShort

Methods

fromIntegral :: Exp CUShort -> Exp CShort

FromIntegral CInt CShort

Methods

fromIntegral :: Exp CInt -> Exp CShort

FromIntegral CUInt CShort

Methods

fromIntegral :: Exp CUInt -> Exp CShort

FromIntegral CLong CShort

Methods

fromIntegral :: Exp CLong -> Exp CShort

FromIntegral CULong CShort

Methods

fromIntegral :: Exp CULong -> Exp CShort

FromIntegral CLLong CShort

Methods

fromIntegral :: Exp CLLong -> Exp CShort

FromIntegral CULLong CShort

Methods

fromIntegral :: Exp CULLong -> Exp CShort

Bounded (Exp CShort)

Methods

minBound :: Exp CShort

maxBound :: Exp CShort

Enum (Exp CShort)

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)

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)

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

type Difference CShort = CShort

type Unwrapped CShort

type Unwrapped CShort = Int16

type Plain CShort

type Plain CShort = CShort

data CUShort

Haskell type representing the C unsigned short type.

Instances

Bounded CUShort

Methods

minBound :: CUShort

maxBound :: CUShort

Enum CUShort

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

Methods

(==) :: CUShort -> CUShort -> Bool

(/=) :: CUShort -> CUShort -> Bool

Integral CUShort

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

Methods

(+) :: CUShort -> CUShort -> CUShort

(-) :: CUShort -> CUShort -> CUShort

(*) :: CUShort -> CUShort -> CUShort

negate :: CUShort -> CUShort

abs :: CUShort -> CUShort

signum :: CUShort -> CUShort

fromInteger :: Integer -> CUShort

Ord CUShort

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

Methods

readsPrec :: Int -> ReadS CUShort

readList :: ReadS [CUShort]

readPrec :: ReadPrec CUShort

readListPrec :: ReadPrec [CUShort]

Real CUShort

Methods

toRational :: CUShort -> Rational

Show CUShort

Methods

showsPrec :: Int -> CUShort -> ShowS

show :: CUShort -> String

showList :: [CUShort] -> ShowS

Storable CUShort

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

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

Methods

finiteBitSize :: CUShort -> Int

countLeadingZeros :: CUShort -> Int

countTrailingZeros :: CUShort -> Int

Subtractive CUShort

Associated Types

type Difference CUShort :: *

Methods

(-) :: CUShort -> CUShort -> Difference CUShort

NFData CUShort

Since: 1.4.0.0

Methods

rnf :: CUShort -> ()

Wrapped CUShort

Associated Types

type Unwrapped CUShort :: *

Methods

_Wrapped' :: Iso' CUShort (Unwrapped CUShort)

IsScalar CUShort

Methods

scalarType :: ScalarType CUShort

IsBounded CUShort

Methods

boundedType :: BoundedType CUShort

IsNum CUShort

Methods

numType :: NumType CUShort

IsIntegral CUShort

Methods

integralType :: IntegralType CUShort

Elt CUShort

Methods

eltType :: CUShort -> TupleType (EltRepr CUShort)

fromElt :: CUShort -> EltRepr CUShort

toElt :: EltRepr CUShort -> CUShort

Eq CUShort

Methods

(==) :: Exp CUShort -> Exp CUShort -> Exp Bool

(/=) :: Exp CUShort -> Exp CUShort -> Exp Bool

Ord CUShort

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

Methods

finiteBitSize :: Exp CUShort -> Exp Int

countLeadingZeros :: Exp CUShort -> Exp Int

countTrailingZeros :: Exp CUShort -> Exp Int

Bits CUShort

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

Lift Exp CUShort

Associated Types

type Plain CUShort :: *

Methods

lift :: CUShort -> Exp (Plain CUShort)

ToFloating CUShort Double

Methods

toFloating :: Exp CUShort -> Exp Double

ToFloating CUShort Float

Methods

toFloating :: Exp CUShort -> Exp Float

ToFloating CUShort CFloat

Methods

toFloating :: Exp CUShort -> Exp CFloat

ToFloating CUShort CDouble

Methods

toFloating :: Exp CUShort -> Exp CDouble

ToFloating CUShort Half

Methods

toFloating :: Exp CUShort -> Exp Half

FromIntegral Int CUShort

Methods

fromIntegral :: Exp Int -> Exp CUShort

FromIntegral Int8 CUShort

Methods

fromIntegral :: Exp Int8 -> Exp CUShort

FromIntegral Int16 CUShort

Methods

fromIntegral :: Exp Int16 -> Exp CUShort

FromIntegral Int32 CUShort

Methods

fromIntegral :: Exp Int32 -> Exp CUShort

FromIntegral Int64 CUShort

Methods

fromIntegral :: Exp Int64 -> Exp CUShort

FromIntegral Word CUShort

Methods

fromIntegral :: Exp Word -> Exp CUShort

FromIntegral Word8 CUShort

Methods

fromIntegral :: Exp Word8 -> Exp CUShort

FromIntegral Word16 CUShort

Methods

fromIntegral :: Exp Word16 -> Exp CUShort

FromIntegral Word32 CUShort

Methods

fromIntegral :: Exp Word32 -> Exp CUShort

FromIntegral Word64 CUShort

Methods

fromIntegral :: Exp Word64 -> Exp CUShort

FromIntegral CShort CUShort

Methods

fromIntegral :: Exp CShort -> Exp CUShort

FromIntegral CUShort Double

Methods

fromIntegral :: Exp CUShort -> Exp Double

FromIntegral CUShort Float

Methods

fromIntegral :: Exp CUShort -> Exp Float

FromIntegral CUShort Int

Methods

fromIntegral :: Exp CUShort -> Exp Int

FromIntegral CUShort Int8

Methods

fromIntegral :: Exp CUShort -> Exp Int8

FromIntegral CUShort Int16

Methods

fromIntegral :: Exp CUShort -> Exp Int16

FromIntegral CUShort Int32

Methods

fromIntegral :: Exp CUShort -> Exp Int32

FromIntegral CUShort Int64

Methods

fromIntegral :: Exp CUShort -> Exp Int64

FromIntegral CUShort Word

Methods

fromIntegral :: Exp CUShort -> Exp Word

FromIntegral CUShort Word8

Methods

fromIntegral :: Exp CUShort -> Exp Word8

FromIntegral CUShort Word16

Methods

fromIntegral :: Exp CUShort -> Exp Word16

FromIntegral CUShort Word32

Methods

fromIntegral :: Exp CUShort -> Exp Word32

FromIntegral CUShort Word64

Methods

fromIntegral :: Exp CUShort -> Exp Word64

FromIntegral CUShort CShort

Methods

fromIntegral :: Exp CUShort -> Exp CShort

FromIntegral CUShort CUShort

Methods

fromIntegral :: Exp CUShort -> Exp CUShort

FromIntegral CUShort CInt

Methods

fromIntegral :: Exp CUShort -> Exp CInt

FromIntegral CUShort CUInt

Methods

fromIntegral :: Exp CUShort -> Exp CUInt

FromIntegral CUShort CLong

Methods

fromIntegral :: Exp CUShort -> Exp CLong

FromIntegral CUShort CULong

Methods

fromIntegral :: Exp CUShort -> Exp CULong

FromIntegral CUShort CLLong

Methods

fromIntegral :: Exp CUShort -> Exp CLLong

FromIntegral CUShort CULLong

Methods

fromIntegral :: Exp CUShort -> Exp CULLong

FromIntegral CUShort CFloat

Methods

fromIntegral :: Exp CUShort -> Exp CFloat

FromIntegral CUShort CDouble

Methods

fromIntegral :: Exp CUShort -> Exp CDouble

FromIntegral CUShort Half

Methods

fromIntegral :: Exp CUShort -> Exp Half

FromIntegral CInt CUShort

Methods

fromIntegral :: Exp CInt -> Exp CUShort

FromIntegral CUInt CUShort

Methods

fromIntegral :: Exp CUInt -> Exp CUShort

FromIntegral CLong CUShort

Methods

fromIntegral :: Exp CLong -> Exp CUShort

FromIntegral CULong CUShort

Methods

fromIntegral :: Exp CULong -> Exp CUShort

FromIntegral CLLong CUShort

Methods

fromIntegral :: Exp CLLong -> Exp CUShort

FromIntegral CULLong CUShort

Methods

fromIntegral :: Exp CULLong -> Exp CUShort

Bounded (Exp CUShort)

Methods

minBound :: Exp CUShort

maxBound :: Exp CUShort

Enum (Exp CUShort)

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)

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)

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

type Difference CUShort = CUShort

type Unwrapped CUShort

type Unwrapped CUShort = Word16

type Plain CUShort

type Plain CUShort = CUShort

data CInt

Haskell type representing the C int type.

Instances

Bounded CInt

Methods

minBound :: CInt

maxBound :: CInt

Enum CInt

Methods

succ :: CInt -> CInt

pred :: CInt -> CInt

toEnum :: Int -> CInt

fromEnum :: CInt -> Int

enumFrom :: CInt -> [CInt]

enumFromThen :: CInt -> CInt -> [CInt]

enumFromTo :: CInt -> CInt -> [CInt]

enumFromThenTo :: CInt -> CInt -> CInt -> [CInt]

Eq CInt

Methods

(==) :: CInt -> CInt -> Bool

(/=) :: CInt -> CInt -> Bool

Integral CInt

Methods

quot :: CInt -> CInt -> CInt

rem :: CInt -> CInt -> CInt

div :: CInt -> CInt -> CInt

mod :: CInt -> CInt -> CInt

quotRem :: CInt -> CInt -> (CInt, CInt)

divMod :: CInt -> CInt -> (CInt, CInt)

toInteger :: CInt -> Integer

Num CInt

Methods

(+) :: CInt -> CInt -> CInt

(-) :: CInt -> CInt -> CInt

(*) :: CInt -> CInt -> CInt

negate :: CInt -> CInt

abs :: CInt -> CInt

signum :: CInt -> CInt

fromInteger :: Integer -> CInt

Ord CInt

Methods

compare :: CInt -> CInt -> Ordering

(<) :: CInt -> CInt -> Bool

(<=) :: CInt -> CInt -> Bool

(>) :: CInt -> CInt -> Bool

(>=) :: CInt -> CInt -> Bool

max :: CInt -> CInt -> CInt

min :: CInt -> CInt -> CInt

Read CInt

Methods

readsPrec :: Int -> ReadS CInt

readList :: ReadS [CInt]

readPrec :: ReadPrec CInt

readListPrec :: ReadPrec [CInt]

Real CInt

Methods

toRational :: CInt -> Rational

Show CInt

Methods

showsPrec :: Int -> CInt -> ShowS

show :: CInt -> String

showList :: [CInt] -> ShowS

Storable CInt

Methods

sizeOf :: CInt -> Int

alignment :: CInt -> Int

peekElemOff :: Ptr CInt -> Int -> IO CInt

pokeElemOff :: Ptr CInt -> Int -> CInt -> IO ()

peekByteOff :: Ptr b -> Int -> IO CInt

pokeByteOff :: Ptr b -> Int -> CInt -> IO ()

peek :: Ptr CInt -> IO CInt

poke :: Ptr CInt -> CInt -> IO ()

Bits CInt

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

Methods

finiteBitSize :: CInt -> Int

countLeadingZeros :: CInt -> Int

countTrailingZeros :: CInt -> Int

Subtractive CInt

Associated Types

type Difference CInt :: *

Methods

(-) :: CInt -> CInt -> Difference CInt

NFData CInt

Since: 1.4.0.0

Methods

rnf :: CInt -> ()

Wrapped CInt

Associated Types

type Unwrapped CInt :: *

Methods

_Wrapped' :: Iso' CInt (Unwrapped CInt)

IsScalar CInt

Methods

scalarType :: ScalarType CInt

IsBounded CInt

Methods

boundedType :: BoundedType CInt

IsNum CInt

Methods

numType :: NumType CInt

IsIntegral CInt

Methods

integralType :: IntegralType CInt

Elt CInt

Methods

eltType :: CInt -> TupleType (EltRepr CInt)

fromElt :: CInt -> EltRepr CInt

toElt :: EltRepr CInt -> CInt

Eq CInt

Methods

(==) :: Exp CInt -> Exp CInt -> Exp Bool

(/=) :: Exp CInt -> Exp CInt -> Exp Bool

Ord CInt

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

Methods

finiteBitSize :: Exp CInt -> Exp Int

countLeadingZeros :: Exp CInt -> Exp Int

countTrailingZeros :: Exp CInt -> Exp Int

Bits CInt

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

Lift Exp CInt

Associated Types

type Plain CInt :: *

Methods

lift :: CInt -> Exp (Plain CInt)

ToFloating CInt Double

Methods

toFloating :: Exp CInt -> Exp Double

ToFloating CInt Float

Methods

toFloating :: Exp CInt -> Exp Float

ToFloating CInt CFloat

Methods

toFloating :: Exp CInt -> Exp CFloat

ToFloating CInt CDouble

Methods

toFloating :: Exp CInt -> Exp CDouble

ToFloating CInt Half

Methods

toFloating :: Exp CInt -> Exp Half

FromIntegral Int CInt

Methods

fromIntegral :: Exp Int -> Exp CInt

FromIntegral Int8 CInt

Methods

fromIntegral :: Exp Int8 -> Exp CInt

FromIntegral Int16 CInt

Methods

fromIntegral :: Exp Int16 -> Exp CInt

FromIntegral Int32 CInt

Methods

fromIntegral :: Exp Int32 -> Exp CInt

FromIntegral Int64 CInt

Methods

fromIntegral :: Exp Int64 -> Exp CInt

FromIntegral Word CInt

Methods

fromIntegral :: Exp Word -> Exp CInt

FromIntegral Word8 CInt

Methods

fromIntegral :: Exp Word8 -> Exp CInt

FromIntegral Word16 CInt

Methods

fromIntegral :: Exp Word16 -> Exp CInt

FromIntegral Word32 CInt

Methods

fromIntegral :: Exp Word32 -> Exp CInt

FromIntegral Word64 CInt

Methods

fromIntegral :: Exp Word64 -> Exp CInt

FromIntegral CShort CInt

Methods

fromIntegral :: Exp CShort -> Exp CInt

FromIntegral CUShort CInt

Methods

fromIntegral :: Exp CUShort -> Exp CInt

FromIntegral CInt Double

Methods

fromIntegral :: Exp CInt -> Exp Double

FromIntegral CInt Float

Methods

fromIntegral :: Exp CInt -> Exp Float

FromIntegral CInt Int

Methods

fromIntegral :: Exp CInt -> Exp Int

FromIntegral CInt Int8

Methods

fromIntegral :: Exp CInt -> Exp Int8

FromIntegral CInt Int16

Methods

fromIntegral :: Exp CInt -> Exp Int16

FromIntegral CInt Int32

Methods

fromIntegral :: Exp CInt -> Exp Int32

FromIntegral CInt Int64

Methods

fromIntegral :: Exp CInt -> Exp Int64

FromIntegral CInt Word

Methods

fromIntegral :: Exp CInt -> Exp Word

FromIntegral CInt Word8

Methods

fromIntegral :: Exp CInt -> Exp Word8

FromIntegral CInt Word16

Methods

fromIntegral :: Exp CInt -> Exp Word16

FromIntegral CInt Word32

Methods

fromIntegral :: Exp CInt -> Exp Word32

FromIntegral CInt Word64

Methods

fromIntegral :: Exp CInt -> Exp Word64

FromIntegral CInt CShort

Methods

fromIntegral :: Exp CInt -> Exp CShort

FromIntegral CInt CUShort

Methods

fromIntegral :: Exp CInt -> Exp CUShort

FromIntegral CInt CInt

Methods

fromIntegral :: Exp CInt -> Exp CInt

FromIntegral CInt CUInt

Methods

fromIntegral :: Exp CInt -> Exp CUInt

FromIntegral CInt CLong

Methods

fromIntegral :: Exp CInt -> Exp CLong

FromIntegral CInt CULong

Methods

fromIntegral :: Exp CInt -> Exp CULong

FromIntegral CInt CLLong

Methods

fromIntegral :: Exp CInt -> Exp CLLong

FromIntegral CInt CULLong

Methods

fromIntegral :: Exp CInt -> Exp CULLong

FromIntegral CInt CFloat

Methods

fromIntegral :: Exp CInt -> Exp CFloat

FromIntegral CInt CDouble

Methods

fromIntegral :: Exp CInt -> Exp CDouble

FromIntegral CInt Half

Methods

fromIntegral :: Exp CInt -> Exp Half

FromIntegral CUInt CInt

Methods

fromIntegral :: Exp CUInt -> Exp CInt

FromIntegral CLong CInt

Methods

fromIntegral :: Exp CLong -> Exp CInt

FromIntegral CULong CInt

Methods

fromIntegral :: Exp CULong -> Exp CInt

FromIntegral CLLong CInt

Methods

fromIntegral :: Exp CLLong -> Exp CInt

FromIntegral CULLong CInt

Methods

fromIntegral :: Exp CULLong -> Exp CInt

Bounded (Exp CInt)

Methods

minBound :: Exp CInt

maxBound :: Exp CInt

Enum (Exp CInt)

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)

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)

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

type Difference CInt = CInt

type Unwrapped CInt

type Unwrapped CInt = Int32

type Plain CInt

type Plain CInt = CInt

data CUInt

Haskell type representing the C unsigned int type.

Instances

Bounded CUInt

Methods

minBound :: CUInt

maxBound :: CUInt

Enum CUInt

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

Methods

(==) :: CUInt -> CUInt -> Bool

(/=) :: CUInt -> CUInt -> Bool

Integral CUInt

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

Methods

(+) :: CUInt -> CUInt -> CUInt

(-) :: CUInt -> CUInt -> CUInt

(*) :: CUInt -> CUInt -> CUInt

negate :: CUInt -> CUInt

abs :: CUInt -> CUInt

signum :: CUInt -> CUInt

fromInteger :: Integer -> CUInt

Ord CUInt

Methods

compare :: CUInt -> CUInt -> Ordering

(<) :: CUInt -> CUInt -> Bool

(<=) :: CUInt -> CUInt -> Bool

(>) :: CUInt -> CUInt -> Bool

(>=) :: CUInt -> CUInt -> Bool

max :: CUInt -> CUInt -> CUInt

min :: CUInt -> CUInt -> CUInt

Read CUInt

Methods

readsPrec :: Int -> ReadS CUInt

readList :: ReadS [CUInt]

readPrec :: ReadPrec CUInt

readListPrec :: ReadPrec [CUInt]

Real CUInt

Methods

toRational :: CUInt -> Rational

Show CUInt

Methods

showsPrec :: Int -> CUInt -> ShowS

show :: CUInt -> String

showList :: [CUInt] -> ShowS

Storable CUInt

Methods

sizeOf :: CUInt -> Int

alignment :: CUInt -> Int

peekElemOff :: Ptr CUInt -> Int -> IO CUInt

pokeElemOff :: Ptr CUInt -> Int -> CUInt -> IO ()

peekByteOff :: Ptr b -> Int -> IO CUInt

pokeByteOff :: Ptr b -> Int -> CUInt -> IO ()

peek :: Ptr CUInt -> IO CUInt

poke :: Ptr CUInt -> CUInt -> IO ()

Bits CUInt

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

Methods

finiteBitSize :: CUInt -> Int

countLeadingZeros :: CUInt -> Int

countTrailingZeros :: CUInt -> Int

Subtractive CUInt

Associated Types

type Difference CUInt :: *

Methods

(-) :: CUInt -> CUInt -> Difference CUInt

NFData CUInt

Since: 1.4.0.0

Methods

rnf :: CUInt -> ()

Wrapped CUInt

Associated Types

type Unwrapped CUInt :: *

Methods

_Wrapped' :: Iso' CUInt (Unwrapped CUInt)

IsScalar CUInt

Methods

scalarType :: ScalarType CUInt

IsBounded CUInt

Methods

boundedType :: BoundedType CUInt

IsNum CUInt

Methods

numType :: NumType CUInt

IsIntegral CUInt

Methods

integralType :: IntegralType CUInt

Elt CUInt

Methods

eltType :: CUInt -> TupleType (EltRepr CUInt)

fromElt :: CUInt -> EltRepr CUInt

toElt :: EltRepr CUInt -> CUInt

Eq CUInt

Methods

(==) :: Exp CUInt -> Exp CUInt -> Exp Bool

(/=) :: Exp CUInt -> Exp CUInt -> Exp Bool

Ord CUInt

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

Methods

finiteBitSize :: Exp CUInt -> Exp Int

countLeadingZeros :: Exp CUInt -> Exp Int

countTrailingZeros :: Exp CUInt -> Exp Int

Bits CUInt

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

Lift Exp CUInt

Associated Types

type Plain CUInt :: *

Methods

lift :: CUInt -> Exp (Plain CUInt)

ToFloating CUInt Double

Methods

toFloating :: Exp CUInt -> Exp Double

ToFloating CUInt Float

Methods

toFloating :: Exp CUInt -> Exp Float

ToFloating CUInt CFloat

Methods

toFloating :: Exp CUInt -> Exp CFloat

ToFloating CUInt CDouble

Methods

toFloating :: Exp CUInt -> Exp CDouble

ToFloating CUInt Half

Methods

toFloating :: Exp CUInt -> Exp Half

FromIntegral Int CUInt

Methods

fromIntegral :: Exp Int -> Exp CUInt

FromIntegral Int8 CUInt

Methods

fromIntegral :: Exp Int8 -> Exp CUInt

FromIntegral Int16 CUInt

Methods

fromIntegral :: Exp Int16 -> Exp CUInt

FromIntegral Int32 CUInt

Methods

fromIntegral :: Exp Int32 -> Exp CUInt

FromIntegral Int64 CUInt

Methods

fromIntegral :: Exp Int64 -> Exp CUInt

FromIntegral Word CUInt

Methods

fromIntegral :: Exp Word -> Exp CUInt

FromIntegral Word8 CUInt

Methods

fromIntegral :: Exp Word8 -> Exp CUInt

FromIntegral Word16 CUInt

Methods

fromIntegral :: Exp Word16 -> Exp CUInt

FromIntegral Word32 CUInt

Methods

fromIntegral :: Exp Word32 -> Exp CUInt

FromIntegral Word64 CUInt

Methods

fromIntegral :: Exp Word64 -> Exp CUInt

FromIntegral CShort CUInt

Methods

fromIntegral :: Exp CShort -> Exp CUInt

FromIntegral CUShort CUInt

Methods

fromIntegral :: Exp CUShort -> Exp CUInt

FromIntegral CInt CUInt

Methods

fromIntegral :: Exp CInt -> Exp CUInt

FromIntegral CUInt Double

Methods

fromIntegral :: Exp CUInt -> Exp Double

FromIntegral CUInt Float

Methods

fromIntegral :: Exp CUInt -> Exp Float

FromIntegral CUInt Int

Methods

fromIntegral :: Exp CUInt -> Exp Int

FromIntegral CUInt Int8

Methods

fromIntegral :: Exp CUInt -> Exp Int8

FromIntegral CUInt Int16

Methods

fromIntegral :: Exp CUInt -> Exp Int16

FromIntegral CUInt Int32

Methods

fromIntegral :: Exp CUInt -> Exp Int32

FromIntegral CUInt Int64

Methods

fromIntegral :: Exp CUInt -> Exp Int64

FromIntegral CUInt Word

Methods

fromIntegral :: Exp CUInt -> Exp Word

FromIntegral CUInt Word8

Methods

fromIntegral :: Exp CUInt -> Exp Word8

FromIntegral CUInt Word16

Methods

fromIntegral :: Exp CUInt -> Exp Word16

FromIntegral CUInt Word32

Methods

fromIntegral :: Exp CUInt -> Exp Word32

FromIntegral CUInt Word64

Methods

fromIntegral :: Exp CUInt -> Exp Word64

FromIntegral CUInt CShort

Methods

fromIntegral :: Exp CUInt -> Exp CShort

FromIntegral CUInt CUShort

Methods

fromIntegral :: Exp CUInt -> Exp CUShort

FromIntegral CUInt CInt

Methods

fromIntegral :: Exp CUInt -> Exp CInt

FromIntegral CUInt CUInt

Methods

fromIntegral :: Exp CUInt -> Exp CUInt

FromIntegral CUInt CLong

Methods

fromIntegral :: Exp CUInt -> Exp CLong

FromIntegral CUInt CULong

Methods

fromIntegral :: Exp CUInt -> Exp CULong

FromIntegral CUInt CLLong

Methods

fromIntegral :: Exp CUInt -> Exp CLLong

FromIntegral CUInt CULLong

Methods

fromIntegral :: Exp CUInt -> Exp CULLong

FromIntegral CUInt CFloat

Methods

fromIntegral :: Exp CUInt -> Exp CFloat

FromIntegral CUInt CDouble

Methods

fromIntegral :: Exp CUInt -> Exp CDouble

FromIntegral CUInt Half

Methods

fromIntegral :: Exp CUInt -> Exp Half

FromIntegral CLong CUInt

Methods

fromIntegral :: Exp CLong -> Exp CUInt

FromIntegral CULong CUInt

Methods

fromIntegral :: Exp CULong -> Exp CUInt

FromIntegral CLLong CUInt

Methods

fromIntegral :: Exp CLLong -> Exp CUInt

FromIntegral CULLong CUInt

Methods

fromIntegral :: Exp CULLong -> Exp CUInt

Bounded (Exp CUInt)

Methods

minBound :: Exp CUInt

maxBound :: Exp CUInt

Enum (Exp CUInt)

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)

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)

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

type Difference CUInt = CUInt

type Unwrapped CUInt

type Unwrapped CUInt = Word32

type Plain CUInt

type Plain CUInt = CUInt

data CLong

Haskell type representing the C long type.

Instances

Bounded CLong

Methods

minBound :: CLong

maxBound :: CLong

Enum CLong

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

Methods

(==) :: CLong -> CLong -> Bool

(/=) :: CLong -> CLong -> Bool

Integral CLong

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

Methods

(+) :: CLong -> CLong -> CLong

(-) :: CLong -> CLong -> CLong

(*) :: CLong -> CLong -> CLong

negate :: CLong -> CLong

abs :: CLong -> CLong

signum :: CLong -> CLong

fromInteger :: Integer -> CLong

Ord CLong

Methods

compare :: CLong -> CLong -> Ordering

(<) :: CLong -> CLong -> Bool

(<=) :: CLong -> CLong -> Bool

(>) :: CLong -> CLong -> Bool

(>=) :: CLong -> CLong -> Bool

max :: CLong -> CLong -> CLong

min :: CLong -> CLong -> CLong

Read CLong

Methods

readsPrec :: Int -> ReadS CLong

readList :: ReadS [CLong]

readPrec :: ReadPrec CLong

readListPrec :: ReadPrec [CLong]

Real CLong

Methods

toRational :: CLong -> Rational

Show CLong

Methods

showsPrec :: Int -> CLong -> ShowS

show :: CLong -> String

showList :: [CLong] -> ShowS

Storable CLong

Methods

sizeOf :: CLong -> Int

alignment :: CLong -> Int

peekElemOff :: Ptr CLong -> Int -> IO CLong

pokeElemOff :: Ptr CLong -> Int -> CLong -> IO ()

peekByteOff :: Ptr b -> Int -> IO CLong

pokeByteOff :: Ptr b -> Int -> CLong -> IO ()

peek :: Ptr CLong -> IO CLong

poke :: Ptr CLong -> CLong -> IO ()

Bits CLong

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

Methods

finiteBitSize :: CLong -> Int

countLeadingZeros :: CLong -> Int

countTrailingZeros :: CLong -> Int

Subtractive CLong

Associated Types

type Difference CLong :: *

Methods

(-) :: CLong -> CLong -> Difference CLong

NFData CLong

Since: 1.4.0.0

Methods

rnf :: CLong -> ()

Wrapped CLong

Associated Types

type Unwrapped CLong :: *

Methods

_Wrapped' :: Iso' CLong (Unwrapped CLong)

IsScalar CLong

Methods

scalarType :: ScalarType CLong

IsBounded CLong

Methods

boundedType :: BoundedType CLong

IsNum CLong

Methods

numType :: NumType CLong

IsIntegral CLong

Methods

integralType :: IntegralType CLong

Elt CLong

Methods

eltType :: CLong -> TupleType (EltRepr CLong)

fromElt :: CLong -> EltRepr CLong

toElt :: EltRepr CLong -> CLong

Eq CLong

Methods

(==) :: Exp CLong -> Exp CLong -> Exp Bool

(/=) :: Exp CLong -> Exp CLong -> Exp Bool

Ord CLong

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

Methods

finiteBitSize :: Exp CLong -> Exp Int

countLeadingZeros :: Exp CLong -> Exp Int

countTrailingZeros :: Exp CLong -> Exp Int

Bits CLong

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

Lift Exp CLong

Associated Types

type Plain CLong :: *

Methods

lift :: CLong -> Exp (Plain CLong)

ToFloating CLong Double

Methods

toFloating :: Exp CLong -> Exp Double

ToFloating CLong Float

Methods

toFloating :: Exp CLong -> Exp Float

ToFloating CLong CFloat

Methods

toFloating :: Exp CLong -> Exp CFloat

ToFloating CLong CDouble

Methods

toFloating :: Exp CLong -> Exp CDouble

ToFloating CLong Half

Methods

toFloating :: Exp CLong -> Exp Half

FromIntegral Int CLong

Methods

fromIntegral :: Exp Int -> Exp CLong

FromIntegral Int8 CLong

Methods

fromIntegral :: Exp Int8 -> Exp CLong

FromIntegral Int16 CLong

Methods

fromIntegral :: Exp Int16 -> Exp CLong

FromIntegral Int32 CLong

Methods

fromIntegral :: Exp Int32 -> Exp CLong

FromIntegral Int64 CLong

Methods

fromIntegral :: Exp Int64 -> Exp CLong

FromIntegral Word CLong

Methods

fromIntegral :: Exp Word -> Exp CLong

FromIntegral Word8 CLong

Methods

fromIntegral :: Exp Word8 -> Exp CLong

FromIntegral Word16 CLong

Methods

fromIntegral :: Exp Word16 -> Exp CLong

FromIntegral Word32 CLong

Methods

fromIntegral :: Exp Word32 -> Exp CLong

FromIntegral Word64 CLong

Methods

fromIntegral :: Exp Word64 -> Exp CLong

FromIntegral CShort CLong

Methods

fromIntegral :: Exp CShort -> Exp CLong

FromIntegral CUShort CLong

Methods

fromIntegral :: Exp CUShort -> Exp CLong

FromIntegral CInt CLong

Methods

fromIntegral :: Exp CInt -> Exp CLong

FromIntegral CUInt CLong

Methods

fromIntegral :: Exp CUInt -> Exp CLong

FromIntegral CLong Double

Methods

fromIntegral :: Exp CLong -> Exp Double

FromIntegral CLong Float

Methods

fromIntegral :: Exp CLong -> Exp Float

FromIntegral CLong Int

Methods

fromIntegral :: Exp CLong -> Exp Int

FromIntegral CLong Int8

Methods

fromIntegral :: Exp CLong -> Exp Int8

FromIntegral CLong Int16

Methods

fromIntegral :: Exp CLong -> Exp Int16

FromIntegral CLong Int32

Methods

fromIntegral :: Exp CLong -> Exp Int32

FromIntegral CLong Int64

Methods

fromIntegral :: Exp CLong -> Exp Int64

FromIntegral CLong Word

Methods

fromIntegral :: Exp CLong -> Exp Word

FromIntegral CLong Word8

Methods

fromIntegral :: Exp CLong -> Exp Word8

FromIntegral CLong Word16

Methods

fromIntegral :: Exp CLong -> Exp Word16

FromIntegral CLong Word32

Methods

fromIntegral :: Exp CLong -> Exp Word32

FromIntegral CLong Word64

Methods

fromIntegral :: Exp CLong -> Exp Word64

FromIntegral CLong CShort

Methods

fromIntegral :: Exp CLong -> Exp CShort

FromIntegral CLong CUShort

Methods

fromIntegral :: Exp CLong -> Exp CUShort

FromIntegral CLong CInt

Methods

fromIntegral :: Exp CLong -> Exp CInt

FromIntegral CLong CUInt

Methods

fromIntegral :: Exp CLong -> Exp CUInt

FromIntegral CLong CLong

Methods

fromIntegral :: Exp CLong -> Exp CLong

FromIntegral CLong CULong

Methods

fromIntegral :: Exp CLong -> Exp CULong

FromIntegral CLong CLLong

Methods

fromIntegral :: Exp CLong -> Exp CLLong

FromIntegral CLong CULLong

Methods

fromIntegral :: Exp CLong -> Exp CULLong

FromIntegral CLong CFloat

Methods

fromIntegral :: Exp CLong -> Exp CFloat

FromIntegral CLong CDouble

Methods

fromIntegral :: Exp CLong -> Exp CDouble

FromIntegral CLong Half

Methods

fromIntegral :: Exp CLong -> Exp Half

FromIntegral CULong CLong

Methods

fromIntegral :: Exp CULong -> Exp CLong

FromIntegral CLLong CLong

Methods

fromIntegral :: Exp CLLong -> Exp CLong

FromIntegral CULLong CLong

Methods

fromIntegral :: Exp CULLong -> Exp CLong

Bounded (Exp CLong)

Methods

minBound :: Exp CLong

maxBound :: Exp CLong

Enum (Exp CLong)

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)

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)

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

type Difference CLong = CLong

type Unwrapped CLong

type Unwrapped CLong = Int64

type Plain CLong

type Plain CLong = CLong

data CULong

Haskell type representing the C unsigned long type.

Instances

Bounded CULong

Methods

minBound :: CULong

maxBound :: CULong

Enum CULong

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

Methods

(==) :: CULong -> CULong -> Bool

(/=) :: CULong -> CULong -> Bool

Integral CULong

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

Methods

(+) :: CULong -> CULong -> CULong

(-) :: CULong -> CULong -> CULong

(*) :: CULong -> CULong -> CULong

negate :: CULong -> CULong

abs :: CULong -> CULong

signum :: CULong -> CULong

fromInteger :: Integer -> CULong

Ord CULong

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

Methods

readsPrec :: Int -> ReadS CULong

readList :: ReadS [CULong]

readPrec :: ReadPrec CULong

readListPrec :: ReadPrec [CULong]

Real CULong

Methods

toRational :: CULong -> Rational

Show CULong

Methods

showsPrec :: Int -> CULong -> ShowS

show :: CULong -> String

showList :: [CULong] -> ShowS

Storable CULong

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

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

Methods

finiteBitSize :: CULong -> Int

countLeadingZeros :: CULong -> Int

countTrailingZeros :: CULong -> Int

Subtractive CULong

Associated Types

type Difference CULong :: *

Methods

(-) :: CULong -> CULong -> Difference CULong

NFData CULong

Since: 1.4.0.0

Methods

rnf :: CULong -> ()

Wrapped CULong

Associated Types

type Unwrapped CULong :: *

Methods

_Wrapped' :: Iso' CULong (Unwrapped CULong)

IsScalar CULong

Methods

scalarType :: ScalarType CULong

IsBounded CULong

Methods

boundedType :: BoundedType CULong

IsNum CULong

Methods

numType :: NumType CULong

IsIntegral CULong

Methods

integralType :: IntegralType CULong

Elt CULong

Methods

eltType :: CULong -> TupleType (EltRepr CULong)

fromElt :: CULong -> EltRepr CULong

toElt :: EltRepr CULong -> CULong

Eq CULong

Methods

(==) :: Exp CULong -> Exp CULong -> Exp Bool

(/=) :: Exp CULong -> Exp CULong -> Exp Bool

Ord CULong

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

Methods

finiteBitSize :: Exp CULong -> Exp Int

countLeadingZeros :: Exp CULong -> Exp Int

countTrailingZeros :: Exp CULong -> Exp Int

Bits CULong

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

Lift Exp CULong

Associated Types

type Plain CULong :: *

Methods

lift :: CULong -> Exp (Plain CULong)

ToFloating CULong Double

Methods

toFloating :: Exp CULong -> Exp Double

ToFloating CULong Float

Methods

toFloating :: Exp CULong -> Exp Float

ToFloating CULong CFloat

Methods

toFloating :: Exp CULong -> Exp CFloat

ToFloating CULong CDouble

Methods

toFloating :: Exp CULong -> Exp CDouble

ToFloating CULong Half

Methods

toFloating :: Exp CULong -> Exp Half

FromIntegral Int CULong

Methods

fromIntegral :: Exp Int -> Exp CULong

FromIntegral Int8 CULong

Methods

fromIntegral :: Exp Int8 -> Exp CULong

FromIntegral Int16 CULong

Methods

fromIntegral :: Exp Int16 -> Exp CULong

FromIntegral Int32 CULong

Methods

fromIntegral :: Exp Int32 -> Exp CULong

FromIntegral Int64 CULong

Methods

fromIntegral :: Exp Int64 -> Exp CULong

FromIntegral Word CULong

Methods

fromIntegral :: Exp Word -> Exp CULong

FromIntegral Word8 CULong

Methods

fromIntegral :: Exp Word8 -> Exp CULong

FromIntegral Word16 CULong

Methods

fromIntegral :: Exp Word16 -> Exp CULong

FromIntegral Word32 CULong

Methods

fromIntegral :: Exp Word32 -> Exp CULong

FromIntegral Word64 CULong

Methods

fromIntegral :: Exp Word64 -> Exp CULong

FromIntegral CShort CULong

Methods

fromIntegral :: Exp CShort -> Exp CULong

FromIntegral CUShort CULong

Methods

fromIntegral :: Exp CUShort -> Exp CULong

FromIntegral CInt CULong

Methods

fromIntegral :: Exp CInt -> Exp CULong

FromIntegral CUInt CULong

Methods

fromIntegral :: Exp CUInt -> Exp CULong

FromIntegral CLong CULong

Methods

fromIntegral :: Exp CLong -> Exp CULong

FromIntegral CULong Double

Methods

fromIntegral :: Exp CULong -> Exp Double

FromIntegral CULong Float

Methods

fromIntegral :: Exp CULong -> Exp Float

FromIntegral CULong Int

Methods

fromIntegral :: Exp CULong -> Exp Int

FromIntegral CULong Int8

Methods

fromIntegral :: Exp CULong -> Exp Int8

FromIntegral CULong Int16

Methods

fromIntegral :: Exp CULong -> Exp Int16

FromIntegral CULong Int32

Methods

fromIntegral :: Exp CULong -> Exp Int32

FromIntegral CULong Int64

Methods

fromIntegral :: Exp CULong -> Exp Int64

FromIntegral CULong Word

Methods

fromIntegral :: Exp CULong -> Exp Word

FromIntegral CULong Word8

Methods

fromIntegral :: Exp CULong -> Exp Word8

FromIntegral CULong Word16

Methods

fromIntegral :: Exp CULong -> Exp Word16

FromIntegral CULong Word32

Methods

fromIntegral :: Exp CULong -> Exp Word32

FromIntegral CULong Word64

Methods

fromIntegral :: Exp CULong -> Exp Word64

FromIntegral CULong CShort

Methods

fromIntegral :: Exp CULong -> Exp CShort

FromIntegral CULong CUShort

Methods

fromIntegral :: Exp CULong -> Exp CUShort

FromIntegral CULong CInt

Methods

fromIntegral :: Exp CULong -> Exp CInt

FromIntegral CULong CUInt

Methods

fromIntegral :: Exp CULong -> Exp CUInt

FromIntegral CULong CLong

Methods

fromIntegral :: Exp CULong -> Exp CLong

FromIntegral CULong CULong

Methods

fromIntegral :: Exp CULong -> Exp CULong

FromIntegral CULong CLLong

Methods

fromIntegral :: Exp CULong -> Exp CLLong

FromIntegral CULong CULLong

Methods

fromIntegral :: Exp CULong -> Exp CULLong

FromIntegral CULong CFloat

Methods

fromIntegral :: Exp CULong -> Exp CFloat

FromIntegral CULong CDouble

Methods

fromIntegral :: Exp CULong -> Exp CDouble

FromIntegral CULong Half

Methods

fromIntegral :: Exp CULong -> Exp Half

FromIntegral CLLong CULong

Methods

fromIntegral :: Exp CLLong -> Exp CULong

FromIntegral CULLong CULong

Methods

fromIntegral :: Exp CULLong -> Exp CULong

Bounded (Exp CULong)

Methods

minBound :: Exp CULong

maxBound :: Exp CULong

Enum (Exp CULong)

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)

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)

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

type Difference CULong = CULong

type Unwrapped CULong

type Unwrapped CULong = Word64

type Plain CULong

type Plain CULong = CULong

data CLLong

Haskell type representing the C long long type.

Instances

Bounded CLLong

Methods

minBound :: CLLong

maxBound :: CLLong

Enum CLLong

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

Methods

(==) :: CLLong -> CLLong -> Bool

(/=) :: CLLong -> CLLong -> Bool

Integral CLLong

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

Methods

(+) :: CLLong -> CLLong -> CLLong

(-) :: CLLong -> CLLong -> CLLong

(*) :: CLLong -> CLLong -> CLLong

negate :: CLLong -> CLLong

abs :: CLLong -> CLLong

signum :: CLLong -> CLLong

fromInteger :: Integer -> CLLong

Ord CLLong

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

Methods

readsPrec :: Int -> ReadS CLLong

readList :: ReadS [CLLong]

readPrec :: ReadPrec CLLong

readListPrec :: ReadPrec [CLLong]

Real CLLong

Methods

toRational :: CLLong -> Rational

Show CLLong

Methods

showsPrec :: Int -> CLLong -> ShowS

show :: CLLong -> String

showList :: [CLLong] -> ShowS

Storable CLLong

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

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

Methods

finiteBitSize :: CLLong -> Int

countLeadingZeros :: CLLong -> Int

countTrailingZeros :: CLLong -> Int

Subtractive CLLong

Associated Types

type Difference CLLong :: *

Methods

(-) :: CLLong -> CLLong -> Difference CLLong

NFData CLLong

Since: 1.4.0.0

Methods

rnf :: CLLong -> ()

Wrapped CLLong

Associated Types

type Unwrapped CLLong :: *

Methods

_Wrapped' :: Iso' CLLong (Unwrapped CLLong)

IsScalar CLLong

Methods

scalarType :: ScalarType CLLong

IsBounded CLLong

Methods

boundedType :: BoundedType CLLong

IsNum CLLong

Methods

numType :: NumType CLLong

IsIntegral CLLong

Methods

integralType :: IntegralType CLLong

Elt CLLong

Methods

eltType :: CLLong -> TupleType (EltRepr CLLong)

fromElt :: CLLong -> EltRepr CLLong

toElt :: EltRepr CLLong -> CLLong

Eq CLLong

Methods

(==) :: Exp CLLong -> Exp CLLong -> Exp Bool

(/=) :: Exp CLLong -> Exp CLLong -> Exp Bool

Ord CLLong

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

Methods

finiteBitSize :: Exp CLLong -> Exp Int

countLeadingZeros :: Exp CLLong -> Exp Int

countTrailingZeros :: Exp CLLong -> Exp Int

Bits CLLong

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

Lift Exp CLLong

Associated Types

type Plain CLLong :: *

Methods

lift :: CLLong -> Exp (Plain CLLong)

ToFloating CLLong Double

Methods

toFloating :: Exp CLLong -> Exp Double

ToFloating CLLong Float

Methods

toFloating :: Exp CLLong -> Exp Float

ToFloating CLLong CFloat

Methods

toFloating :: Exp CLLong -> Exp CFloat

ToFloating CLLong CDouble

Methods

toFloating :: Exp CLLong -> Exp CDouble

ToFloating CLLong Half

Methods

toFloating :: Exp CLLong -> Exp Half

FromIntegral Int CLLong

Methods

fromIntegral :: Exp Int -> Exp CLLong

FromIntegral Int8 CLLong

Methods

fromIntegral :: Exp Int8 -> Exp CLLong

FromIntegral Int16 CLLong

Methods

fromIntegral :: Exp Int16 -> Exp CLLong

FromIntegral Int32 CLLong

Methods

fromIntegral :: Exp Int32 -> Exp CLLong

FromIntegral Int64 CLLong

Methods

fromIntegral :: Exp Int64 -> Exp CLLong

FromIntegral Word CLLong

Methods

fromIntegral :: Exp Word -> Exp CLLong

FromIntegral Word8 CLLong

Methods

fromIntegral :: Exp Word8 -> Exp CLLong

FromIntegral Word16 CLLong

Methods

fromIntegral :: Exp Word16 -> Exp CLLong

FromIntegral Word32 CLLong

Methods

fromIntegral :: Exp Word32 -> Exp CLLong

FromIntegral Word64 CLLong

Methods

fromIntegral :: Exp Word64 -> Exp CLLong

FromIntegral CShort CLLong

Methods

fromIntegral :: Exp CShort -> Exp CLLong

FromIntegral CUShort CLLong

Methods

fromIntegral :: Exp CUShort -> Exp CLLong

FromIntegral CInt CLLong

Methods

fromIntegral :: Exp CInt -> Exp CLLong

FromIntegral CUInt CLLong

Methods

fromIntegral :: Exp CUInt -> Exp CLLong

FromIntegral CLong CLLong

Methods

fromIntegral :: Exp CLong -> Exp CLLong

FromIntegral CULong CLLong

Methods

fromIntegral :: Exp CULong -> Exp CLLong

FromIntegral CLLong Double

Methods

fromIntegral :: Exp CLLong -> Exp Double

FromIntegral CLLong Float

Methods

fromIntegral :: Exp CLLong -> Exp Float

FromIntegral CLLong Int

Methods

fromIntegral :: Exp CLLong -> Exp Int

FromIntegral CLLong Int8

Methods

fromIntegral :: Exp CLLong -> Exp Int8

FromIntegral CLLong Int16

Methods

fromIntegral :: Exp CLLong -> Exp Int16

FromIntegral CLLong Int32

Methods

fromIntegral :: Exp CLLong -> Exp Int32

FromIntegral CLLong Int64

Methods

fromIntegral :: Exp CLLong -> Exp Int64

FromIntegral CLLong Word

Methods

fromIntegral :: Exp CLLong -> Exp Word

FromIntegral CLLong Word8

Methods

fromIntegral :: Exp CLLong -> Exp Word8

FromIntegral CLLong Word16

Methods

fromIntegral :: Exp CLLong -> Exp Word16

FromIntegral CLLong Word32

Methods

fromIntegral :: Exp CLLong -> Exp Word32

FromIntegral CLLong Word64

Methods

fromIntegral :: Exp CLLong -> Exp Word64

FromIntegral CLLong CShort

Methods

fromIntegral :: Exp CLLong -> Exp CShort

FromIntegral CLLong CUShort

Methods

fromIntegral :: Exp CLLong -> Exp CUShort

FromIntegral CLLong CInt

Methods

fromIntegral :: Exp CLLong -> Exp CInt

FromIntegral CLLong CUInt

Methods

fromIntegral :: Exp CLLong -> Exp CUInt

FromIntegral CLLong CLong

Methods

fromIntegral :: Exp CLLong -> Exp CLong

FromIntegral CLLong CULong

Methods

fromIntegral :: Exp CLLong -> Exp CULong

FromIntegral CLLong CLLong

Methods

fromIntegral :: Exp CLLong -> Exp CLLong

FromIntegral CLLong CULLong

Methods

fromIntegral :: Exp CLLong -> Exp CULLong

FromIntegral CLLong CFloat

Methods

fromIntegral :: Exp CLLong -> Exp CFloat

FromIntegral CLLong CDouble

Methods

fromIntegral :: Exp CLLong -> Exp CDouble

FromIntegral CLLong Half

Methods

fromIntegral :: Exp CLLong -> Exp Half

FromIntegral CULLong CLLong

Methods

fromIntegral :: Exp CULLong -> Exp CLLong

Bounded (Exp CLLong)

Methods

minBound :: Exp CLLong

maxBound :: Exp CLLong

Enum (Exp CLLong)

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)

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)

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

type Difference CLLong = CLLong

type Unwrapped CLLong

type Unwrapped CLLong = Int64

type Plain CLLong

type Plain CLLong = CLLong

data CULLong

Haskell type representing the C unsigned long long type.

Instances

Bounded CULLong

Methods

minBound :: CULLong

maxBound :: CULLong

Enum CULLong

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

Methods

(==) :: CULLong -> CULLong -> Bool

(/=) :: CULLong -> CULLong -> Bool

Integral CULLong

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

Methods

(+) :: CULLong -> CULLong -> CULLong

(-) :: CULLong -> CULLong -> CULLong

(*) :: CULLong -> CULLong -> CULLong

negate :: CULLong -> CULLong

abs :: CULLong -> CULLong

signum :: CULLong -> CULLong

fromInteger :: Integer -> CULLong

Ord CULLong

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

Methods

readsPrec :: Int -> ReadS CULLong

readList :: ReadS [CULLong]

readPrec :: ReadPrec CULLong

readListPrec :: ReadPrec [CULLong]

Real CULLong

Methods

toRational :: CULLong -> Rational

Show CULLong

Methods

showsPrec :: Int -> CULLong -> ShowS

show :: CULLong -> String

showList :: [CULLong] -> ShowS

Storable CULLong

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

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

Methods

finiteBitSize :: CULLong -> Int

countLeadingZeros :: CULLong -> Int

countTrailingZeros :: CULLong -> Int

Subtractive CULLong

Associated Types

type Difference CULLong :: *

Methods

(-) :: CULLong -> CULLong -> Difference CULLong

NFData CULLong

Since: 1.4.0.0

Methods

rnf :: CULLong -> ()

Wrapped CULLong

Associated Types

type Unwrapped CULLong :: *

Methods

_Wrapped' :: Iso' CULLong (Unwrapped CULLong)

IsScalar CULLong

Methods

scalarType :: ScalarType CULLong

IsBounded CULLong

Methods

boundedType :: BoundedType CULLong

IsNum CULLong

Methods

numType :: NumType CULLong

IsIntegral CULLong

Methods

integralType :: IntegralType CULLong

Elt CULLong

Methods

eltType :: CULLong -> TupleType (EltRepr CULLong)

fromElt :: CULLong -> EltRepr CULLong

toElt :: EltRepr CULLong -> CULLong

Eq CULLong

Methods

(==) :: Exp CULLong -> Exp CULLong -> Exp Bool

(/=) :: Exp CULLong -> Exp CULLong -> Exp Bool

Ord CULLong

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

Methods

finiteBitSize :: Exp CULLong -> Exp Int

countLeadingZeros :: Exp CULLong -> Exp Int

countTrailingZeros :: Exp CULLong -> Exp Int

Bits CULLong

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

Lift Exp CULLong

Associated Types

type Plain CULLong :: *

Methods

lift :: CULLong -> Exp (Plain CULLong)

ToFloating CULLong Double

Methods

toFloating :: Exp CULLong -> Exp Double

ToFloating CULLong Float

Methods

toFloating :: Exp CULLong -> Exp Float

ToFloating CULLong CFloat

Methods

toFloating :: Exp CULLong -> Exp CFloat

ToFloating CULLong CDouble

Methods

toFloating :: Exp CULLong -> Exp CDouble

ToFloating CULLong Half

Methods

toFloating :: Exp CULLong -> Exp Half

FromIntegral Int CULLong

Methods

fromIntegral :: Exp Int -> Exp CULLong

FromIntegral Int8 CULLong

Methods

fromIntegral :: Exp Int8 -> Exp CULLong

FromIntegral Int16 CULLong

Methods

fromIntegral :: Exp Int16 -> Exp CULLong

FromIntegral Int32 CULLong

Methods

fromIntegral :: Exp Int32 -> Exp CULLong

FromIntegral Int64 CULLong

Methods

fromIntegral :: Exp Int64 -> Exp CULLong

FromIntegral Word CULLong

Methods

fromIntegral :: Exp Word -> Exp CULLong

FromIntegral Word8 CULLong

Methods

fromIntegral :: Exp Word8 -> Exp CULLong

FromIntegral Word16 CULLong

Methods

fromIntegral :: Exp Word16 -> Exp CULLong

FromIntegral Word32 CULLong

Methods

fromIntegral :: Exp Word32 -> Exp CULLong

FromIntegral Word64 CULLong

Methods

fromIntegral :: Exp Word64 -> Exp CULLong

FromIntegral CShort CULLong

Methods

fromIntegral :: Exp CShort -> Exp CULLong

FromIntegral CUShort CULLong

Methods

fromIntegral :: Exp CUShort -> Exp CULLong

FromIntegral CInt CULLong

Methods

fromIntegral :: Exp CInt -> Exp CULLong

FromIntegral CUInt CULLong

Methods

fromIntegral :: Exp CUInt -> Exp CULLong

FromIntegral CLong CULLong

Methods

fromIntegral :: Exp CLong -> Exp CULLong

FromIntegral CULong CULLong

Methods

fromIntegral :: Exp CULong -> Exp CULLong

FromIntegral CLLong CULLong

Methods

fromIntegral :: Exp CLLong -> Exp CULLong

FromIntegral CULLong Double

Methods

fromIntegral :: Exp CULLong -> Exp Double

FromIntegral CULLong Float

Methods

fromIntegral :: Exp CULLong -> Exp Float

FromIntegral CULLong Int

Methods

fromIntegral :: Exp CULLong -> Exp Int

FromIntegral CULLong Int8

Methods

fromIntegral :: Exp CULLong -> Exp Int8

FromIntegral CULLong Int16

Methods

fromIntegral :: Exp CULLong -> Exp Int16

FromIntegral CULLong Int32

Methods

fromIntegral :: Exp CULLong -> Exp Int32

FromIntegral CULLong Int64

Methods

fromIntegral :: Exp CULLong -> Exp Int64

FromIntegral CULLong Word

Methods

fromIntegral :: Exp CULLong -> Exp Word

FromIntegral CULLong Word8

Methods

fromIntegral :: Exp CULLong -> Exp Word8

FromIntegral CULLong Word16

Methods

fromIntegral :: Exp CULLong -> Exp Word16

FromIntegral CULLong Word32

Methods

fromIntegral :: Exp CULLong -> Exp Word32

FromIntegral CULLong Word64

Methods

fromIntegral :: Exp CULLong -> Exp Word64

FromIntegral CULLong CShort

Methods

fromIntegral :: Exp CULLong -> Exp CShort

FromIntegral CULLong CUShort

Methods

fromIntegral :: Exp CULLong -> Exp CUShort

FromIntegral CULLong CInt

Methods

fromIntegral :: Exp CULLong -> Exp CInt

FromIntegral CULLong CUInt

Methods

fromIntegral :: Exp CULLong -> Exp CUInt

FromIntegral CULLong CLong

Methods

fromIntegral :: Exp CULLong -> Exp CLong

FromIntegral CULLong CULong

Methods

fromIntegral :: Exp CULLong -> Exp CULong

FromIntegral CULLong CLLong

Methods

fromIntegral :: Exp CULLong -> Exp CLLong

FromIntegral CULLong CULLong

Methods

fromIntegral :: Exp CULLong -> Exp CULLong

FromIntegral CULLong CFloat

Methods

fromIntegral :: Exp CULLong -> Exp CFloat

FromIntegral CULLong CDouble

Methods

fromIntegral :: Exp CULLong -> Exp CDouble

FromIntegral CULLong Half

Methods

fromIntegral :: Exp CULLong -> Exp Half

Bounded (Exp CULLong)

Methods

minBound :: Exp CULLong

maxBound :: Exp CULLong

Enum (Exp CULLong)

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)

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)

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

type Difference CULLong = CULLong

type Unwrapped CULLong

type Unwrapped CULLong = Word64

type Plain CULLong

type Plain CULLong = CULLong

data CChar

Haskell type representing the C char type.

Instances

Bounded CChar

Methods

minBound :: CChar

maxBound :: CChar

Enum CChar

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

Methods

(==) :: CChar -> CChar -> Bool

(/=) :: CChar -> CChar -> Bool

Integral CChar

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

Methods

(+) :: CChar -> CChar -> CChar

(-) :: CChar -> CChar -> CChar

(*) :: CChar -> CChar -> CChar

negate :: CChar -> CChar

abs :: CChar -> CChar

signum :: CChar -> CChar

fromInteger :: Integer -> CChar

Ord CChar

Methods

compare :: CChar -> CChar -> Ordering

(<) :: CChar -> CChar -> Bool

(<=) :: CChar -> CChar -> Bool

(>) :: CChar -> CChar -> Bool

(>=) :: CChar -> CChar -> Bool

max :: CChar -> CChar -> CChar

min :: CChar -> CChar -> CChar

Read CChar

Methods

readsPrec :: Int -> ReadS CChar

readList :: ReadS [CChar]

readPrec :: ReadPrec CChar

readListPrec :: ReadPrec [CChar]

Real CChar

Methods

toRational :: CChar -> Rational

Show CChar

Methods

showsPrec :: Int -> CChar -> ShowS

show :: CChar -> String

showList :: [CChar] -> ShowS

Storable CChar

Methods

sizeOf :: CChar -> Int

alignment :: CChar -> Int

peekElemOff :: Ptr CChar -> Int -> IO CChar

pokeElemOff :: Ptr CChar -> Int -> CChar -> IO ()

peekByteOff :: Ptr b -> Int -> IO CChar

pokeByteOff :: Ptr b -> Int -> CChar -> IO ()

peek :: Ptr CChar -> IO CChar

poke :: Ptr CChar -> CChar -> IO ()

Bits CChar

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

Methods

finiteBitSize :: CChar -> Int

countLeadingZeros :: CChar -> Int

countTrailingZeros :: CChar -> Int

PrimType CChar

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

Subtractive CChar

Associated Types

type Difference CChar :: *

Methods

(-) :: CChar -> CChar -> Difference CChar

NFData CChar

Since: 1.4.0.0

Methods

rnf :: CChar -> ()

Wrapped CChar

Associated Types

type Unwrapped CChar :: *

Methods

_Wrapped' :: Iso' CChar (Unwrapped CChar)

IsScalar CChar

Methods

scalarType :: ScalarType CChar

IsBounded CChar

Methods

boundedType :: BoundedType CChar

IsNonNum CChar

Methods

nonNumType :: NonNumType CChar

Elt CChar

Methods

eltType :: CChar -> TupleType (EltRepr CChar)

fromElt :: CChar -> EltRepr CChar

toElt :: EltRepr CChar -> CChar

Eq CChar

Methods

(==) :: Exp CChar -> Exp CChar -> Exp Bool

(/=) :: Exp CChar -> Exp CChar -> Exp Bool

Ord CChar

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

Rewrapped CChar t

Lift Exp CChar

Associated Types

type Plain CChar :: *

Methods

lift :: CChar -> Exp (Plain CChar)

Bounded (Exp CChar)

Methods

minBound :: Exp CChar

maxBound :: Exp CChar

type PrimSize CChar

type PrimSize CChar = 1

type Difference CChar

type Difference CChar = CChar

type Unwrapped CChar

type Unwrapped CChar = Int8

type Plain CChar

type Plain CChar = CChar

data CSChar

Haskell type representing the C signed char type.

Instances

Bounded CSChar

Methods

minBound :: CSChar

maxBound :: CSChar

Enum CSChar

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

Methods

(==) :: CSChar -> CSChar -> Bool

(/=) :: CSChar -> CSChar -> Bool

Integral CSChar

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

Methods

(+) :: CSChar -> CSChar -> CSChar

(-) :: CSChar -> CSChar -> CSChar

(*) :: CSChar -> CSChar -> CSChar

negate :: CSChar -> CSChar

abs :: CSChar -> CSChar

signum :: CSChar -> CSChar

fromInteger :: Integer -> CSChar

Ord CSChar

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

Methods

readsPrec :: Int -> ReadS CSChar

readList :: ReadS [CSChar]

readPrec :: ReadPrec CSChar

readListPrec :: ReadPrec [CSChar]

Real CSChar

Methods

toRational :: CSChar -> Rational

Show CSChar

Methods

showsPrec :: Int -> CSChar -> ShowS

show :: CSChar -> String

showList :: [CSChar] -> ShowS

Storable CSChar

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

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

Methods

finiteBitSize :: CSChar -> Int

countLeadingZeros :: CSChar -> Int

countTrailingZeros :: CSChar -> Int

Subtractive CSChar

Associated Types

type Difference CSChar :: *

Methods

(-) :: CSChar -> CSChar -> Difference CSChar

NFData CSChar

Since: 1.4.0.0

Methods

rnf :: CSChar -> ()

Wrapped CSChar

Associated Types

type Unwrapped CSChar :: *

Methods

_Wrapped' :: Iso' CSChar (Unwrapped CSChar)

IsScalar CSChar

Methods

scalarType :: ScalarType CSChar

IsBounded CSChar

Methods

boundedType :: BoundedType CSChar

IsNonNum CSChar

Methods

nonNumType :: NonNumType CSChar

Elt CSChar

Methods

eltType :: CSChar -> TupleType (EltRepr CSChar)

fromElt :: CSChar -> EltRepr CSChar

toElt :: EltRepr CSChar -> CSChar

Eq CSChar

Methods

(==) :: Exp CSChar -> Exp CSChar -> Exp Bool

(/=) :: Exp CSChar -> Exp CSChar -> Exp Bool

Ord CSChar

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

Rewrapped CSChar t

Lift Exp CSChar

Associated Types

type Plain CSChar :: *

Methods

lift :: CSChar -> Exp (Plain CSChar)

Bounded (Exp CSChar)

Methods

minBound :: Exp CSChar

maxBound :: Exp CSChar

type Difference CSChar

type Difference CSChar = CSChar

type Unwrapped CSChar

type Unwrapped CSChar = Int8

type Plain CSChar

type Plain CSChar = CSChar

data CUChar

Haskell type representing the C unsigned char type.

Instances

Bounded CUChar

Methods

minBound :: CUChar

maxBound :: CUChar

Enum CUChar

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

Methods

(==) :: CUChar -> CUChar -> Bool

(/=) :: CUChar -> CUChar -> Bool

Integral CUChar

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

Methods

(+) :: CUChar -> CUChar -> CUChar

(-) :: CUChar -> CUChar -> CUChar

(*) :: CUChar -> CUChar -> CUChar

negate :: CUChar -> CUChar

abs :: CUChar -> CUChar

signum :: CUChar -> CUChar

fromInteger :: Integer -> CUChar

Ord CUChar

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

Methods

readsPrec :: Int -> ReadS CUChar

readList :: ReadS [CUChar]

readPrec :: ReadPrec CUChar

readListPrec :: ReadPrec [CUChar]

Real CUChar

Methods

toRational :: CUChar -> Rational

Show CUChar

Methods

showsPrec :: Int -> CUChar -> ShowS

show :: CUChar -> String

showList :: [CUChar] -> ShowS

Storable CUChar

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

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

Methods

finiteBitSize :: CUChar -> Int

countLeadingZeros :: CUChar -> Int

countTrailingZeros :: CUChar -> Int

PrimType CUChar

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

Subtractive CUChar

Associated Types

type Difference CUChar :: *

Methods

(-) :: CUChar -> CUChar -> Difference CUChar

NFData CUChar

Since: 1.4.0.0

Methods

rnf :: CUChar -> ()

Wrapped CUChar

Associated Types

type Unwrapped CUChar :: *

Methods

_Wrapped' :: Iso' CUChar (Unwrapped CUChar)

IsScalar CUChar

Methods

scalarType :: ScalarType CUChar

IsBounded CUChar

Methods

boundedType :: BoundedType CUChar

IsNonNum CUChar

Methods

nonNumType :: NonNumType CUChar

Elt CUChar

Methods

eltType :: CUChar -> TupleType (EltRepr CUChar)

fromElt :: CUChar -> EltRepr CUChar

toElt :: EltRepr CUChar -> CUChar

Eq CUChar

Methods

(==) :: Exp CUChar -> Exp CUChar -> Exp Bool

(/=) :: Exp CUChar -> Exp CUChar -> Exp Bool

Ord CUChar

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

Rewrapped CUChar t

Lift Exp CUChar

Associated Types

type Plain CUChar :: *

Methods

lift :: CUChar -> Exp (Plain CUChar)

Bounded (Exp CUChar)

Methods

minBound :: Exp CUChar

maxBound :: Exp CUChar

type PrimSize CUChar

type PrimSize CUChar = 1

type Difference CUChar

type Difference CUChar = CUChar

type Unwrapped CUChar

type Unwrapped CUChar = Word8

type Plain CUChar

type Plain CUChar = CUChar

Avoid using these in your own functions wherever possible.

class Typeable a => IsScalar a

All scalar types

Minimal complete definition

scalarType

Instances

IsScalar Bool

Methods

scalarType :: ScalarType Bool

IsScalar Char

Methods

scalarType :: ScalarType Char

IsScalar Double

Methods

scalarType :: ScalarType Double

IsScalar Float

Methods

scalarType :: ScalarType Float

IsScalar Int

Methods

scalarType :: ScalarType Int

IsScalar Int8

Methods

scalarType :: ScalarType Int8

IsScalar Int16

Methods

scalarType :: ScalarType Int16

IsScalar Int32

Methods

scalarType :: ScalarType Int32

IsScalar Int64

Methods

scalarType :: ScalarType Int64

IsScalar Word

Methods

scalarType :: ScalarType Word

IsScalar Word8

Methods

scalarType :: ScalarType Word8

IsScalar Word16

Methods

scalarType :: ScalarType Word16

IsScalar Word32

Methods

scalarType :: ScalarType Word32

IsScalar Word64

Methods

scalarType :: ScalarType Word64

IsScalar CChar

Methods

scalarType :: ScalarType CChar

IsScalar CSChar

Methods

scalarType :: ScalarType CSChar

IsScalar CUChar

Methods

scalarType :: ScalarType CUChar

IsScalar CShort

Methods

scalarType :: ScalarType CShort

IsScalar CUShort

Methods

scalarType :: ScalarType CUShort

IsScalar CInt

Methods

scalarType :: ScalarType CInt

IsScalar CUInt

Methods

scalarType :: ScalarType CUInt

IsScalar CLong

Methods

scalarType :: ScalarType CLong

IsScalar CULong

Methods

scalarType :: ScalarType CULong

IsScalar CLLong

Methods

scalarType :: ScalarType CLLong

IsScalar CULLong

Methods

scalarType :: ScalarType CULLong

IsScalar CFloat

Methods

scalarType :: ScalarType CFloat

IsScalar CDouble

Methods

scalarType :: ScalarType CDouble

IsScalar Half

Methods

scalarType :: ScalarType Half

class (Num a, IsSingle a) => IsNum a

Numeric types

Minimal complete definition

numType

Instances

IsNum Double

Methods

numType :: NumType Double

IsNum Float

Methods

numType :: NumType Float

IsNum Int

Methods

numType :: NumType Int

IsNum Int8

Methods

numType :: NumType Int8

IsNum Int16

Methods

numType :: NumType Int16

IsNum Int32

Methods

numType :: NumType Int32

IsNum Int64

Methods

numType :: NumType Int64

IsNum Word

Methods

numType :: NumType Word

IsNum Word8

Methods

numType :: NumType Word8

IsNum Word16

Methods

numType :: NumType Word16

IsNum Word32

Methods

numType :: NumType Word32

IsNum Word64

Methods

numType :: NumType Word64

IsNum CShort

Methods

numType :: NumType CShort

IsNum CUShort

Methods

numType :: NumType CUShort

IsNum CInt

Methods

numType :: NumType CInt

IsNum CUInt

Methods

numType :: NumType CUInt

IsNum CLong

Methods

numType :: NumType CLong

IsNum CULong

Methods

numType :: NumType CULong

IsNum CLLong

Methods

numType :: NumType CLLong

IsNum CULLong

Methods

numType :: NumType CULLong

IsNum CFloat

Methods

numType :: NumType CFloat

IsNum CDouble

Methods

numType :: NumType CDouble

IsNum Half

Methods

numType :: NumType Half

class IsBounded a

Bounded types

Minimal complete definition

boundedType

Instances

IsBounded Bool

Methods

boundedType :: BoundedType Bool

IsBounded Char

Methods

boundedType :: BoundedType Char

IsBounded Int

Methods

boundedType :: BoundedType Int

IsBounded Int8

Methods

boundedType :: BoundedType Int8

IsBounded Int16

Methods

boundedType :: BoundedType Int16

IsBounded Int32

Methods

boundedType :: BoundedType Int32

IsBounded Int64

Methods

boundedType :: BoundedType Int64

IsBounded Word

Methods

boundedType :: BoundedType Word

IsBounded Word8

Methods

boundedType :: BoundedType Word8

IsBounded Word16

Methods

boundedType :: BoundedType Word16

IsBounded Word32

Methods

boundedType :: BoundedType Word32

IsBounded Word64

Methods

boundedType :: BoundedType Word64

IsBounded CChar

Methods

boundedType :: BoundedType CChar

IsBounded CSChar

Methods

boundedType :: BoundedType CSChar

IsBounded CUChar

Methods

boundedType :: BoundedType CUChar

IsBounded CShort

Methods

boundedType :: BoundedType CShort

IsBounded CUShort

Methods

boundedType :: BoundedType CUShort

IsBounded CInt

Methods

boundedType :: BoundedType CInt

IsBounded CUInt

Methods

boundedType :: BoundedType CUInt

IsBounded CLong

Methods

boundedType :: BoundedType CLong

IsBounded CULong

Methods

boundedType :: BoundedType CULong

IsBounded CLLong

Methods

boundedType :: BoundedType CLLong

IsBounded CULLong

Methods

boundedType :: BoundedType CULLong

class (IsSingle a, IsNum a, IsBounded a) => IsIntegral a

Integral types

Minimal complete definition

integralType

Instances

IsIntegral Int

Methods

integralType :: IntegralType Int

IsIntegral Int8

Methods

integralType :: IntegralType Int8

IsIntegral Int16

Methods

integralType :: IntegralType Int16

IsIntegral Int32

Methods

integralType :: IntegralType Int32

IsIntegral Int64

Methods

integralType :: IntegralType Int64

IsIntegral Word

Methods

integralType :: IntegralType Word

IsIntegral Word8

Methods

integralType :: IntegralType Word8

IsIntegral Word16

Methods

integralType :: IntegralType Word16

IsIntegral Word32

Methods

integralType :: IntegralType Word32

IsIntegral Word64

Methods

integralType :: IntegralType Word64

IsIntegral CShort

Methods

integralType :: IntegralType CShort

IsIntegral CUShort

Methods

integralType :: IntegralType CUShort

IsIntegral CInt

Methods

integralType :: IntegralType CInt

IsIntegral CUInt

Methods

integralType :: IntegralType CUInt

IsIntegral CLong

Methods

integralType :: IntegralType CLong

IsIntegral CULong

Methods

integralType :: IntegralType CULong

IsIntegral CLLong

Methods

integralType :: IntegralType CLLong

IsIntegral CULLong

Methods

integralType :: IntegralType CULLong

class (Floating a, IsSingle a, IsNum a) => IsFloating a

Floating types

Minimal complete definition

floatingType

Instances

IsFloating Double

Methods

floatingType :: FloatingType Double

IsFloating Float

Methods

floatingType :: FloatingType Float

IsFloating CFloat

Methods

floatingType :: FloatingType CFloat

IsFloating CDouble

Methods

floatingType :: FloatingType CDouble

IsFloating Half

Methods

floatingType :: FloatingType Half

class IsNonNum a

Non-numeric types

Minimal complete definition

nonNumType

Instances

IsNonNum Bool

Methods

nonNumType :: NonNumType Bool

IsNonNum Char

Methods

nonNumType :: NonNumType Char

IsNonNum CChar

Methods

nonNumType :: NonNumType CChar

IsNonNum CSChar

Methods

nonNumType :: NonNumType CSChar

IsNonNum CUChar

Methods

nonNumType :: NonNumType CUChar