Copyright	[2008..2017] Manuel M T Chakravarty Gabriele Keller [2009..2017] Trevor L. McDonell [2013..2017] Robert Clifton-Everest [2014..2014] Frederik M. Madsen
License	BSD3
Maintainer	Trevor L. McDonell <tmcdonell@cse.unsw.edu.au>
Stability	experimental
Portability	non-portable (GHC extensions)
Safe Haskell	None
Language	Haskell2010

Data.Array.Accelerate

Contents

The Accelerate Array Language
The Accelerate Expression Language
Foreign Function Interface (FFI)
Plain arrays
- Operations
- Getting data in
  - Function
  - Lists
Prelude re-exports

Description

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

Abstract interface:

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

Stratified language:

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

Optimisations:

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

Code execution:

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

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:accelerate-haskell@googlegroups.com
- http://groups.google.com/group/accelerate-haskell
Bug reports: https://github.com/AccelerateHS/accelerate/issues
Maintainers:
- Trevor L. McDonell: mailto:tmcdonell@cse.unsw.edu.au
- Manuel M T Chakravarty: mailto:chak@cse.unsw.edu.au

Tip:

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

./foo +RTS -A64M -n2M -RTS

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

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

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

Synopsis

data Acc a
data Array sh e
class (Typeable a, Typeable (ArrRepr a)) => Arrays a
type Scalar = Array DIM0
type Vector = Array DIM1
type Matrix = Array DIM2
type Segments = Vector
class (Show a, Typeable a, Typeable (EltRepr a), ArrayElt (EltRepr a)) => Elt a
data Z = Z
data tail :. head = tail :. head
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
class (Elt sl, Shape (SliceShape sl), Shape (CoSliceShape sl), Shape (FullShape sl)) => Slice sl where
- type SliceShape sl :: *
- type CoSliceShape sl :: *
- type FullShape sl :: *
- sliceIndex :: sl -> SliceIndex (EltRepr sl) (EltRepr (SliceShape sl)) (EltRepr (CoSliceShape sl)) (EltRepr (FullShape sl))
data All = All
data Any sh = Any
(!) :: (Shape sh, Elt e) => Acc (Array sh e) -> Exp sh -> Exp e
(!!) :: (Shape sh, Elt e) => Acc (Array sh e) -> Exp Int -> Exp e
the :: Elt e => Acc (Scalar e) -> Exp e
null :: (Shape sh, Elt e) => Acc (Array sh e) -> Exp Bool
length :: Elt e => Acc (Vector e) -> Exp Int
shape :: (Shape sh, Elt e) => Acc (Array sh e) -> Exp sh
size :: (Shape sh, Elt e) => Acc (Array sh e) -> Exp Int
shapeSize :: Shape sh => Exp sh -> Exp Int
use :: Arrays arrays => arrays -> Acc arrays
unit :: Elt e => Exp e -> Acc (Scalar e)
generate :: (Shape sh, Elt a) => Exp sh -> (Exp sh -> Exp a) -> Acc (Array sh a)
fill :: (Shape sh, Elt e) => Exp sh -> Exp e -> Acc (Array sh e)
enumFromN :: (Shape sh, Num e, FromIntegral Int e) => Exp sh -> Exp e -> Acc (Array sh e)
enumFromStepN :: (Shape sh, Num e, FromIntegral Int e) => Exp sh -> Exp e -> Exp e -> Acc (Array sh e)
(++) :: forall sh e. (Slice sh, Shape sh, Elt e) => Acc (Array (sh :. Int) e) -> Acc (Array (sh :. Int) e) -> Acc (Array (sh :. Int) e)
concatOn :: (Shape sh, Elt e) => Lens' (Exp sh) (Exp Int) -> Acc (Array sh e) -> Acc (Array sh e) -> Acc (Array sh e)
(?|) :: Arrays a => Exp Bool -> (Acc a, Acc a) -> Acc a
acond :: Arrays a => Exp Bool -> Acc a -> Acc a -> Acc a
awhile :: Arrays a => (Acc a -> Acc (Scalar Bool)) -> (Acc a -> Acc a) -> Acc a -> Acc a
class IfThenElse t where
- type EltT t a :: Constraint
- ifThenElse :: EltT t a => Exp Bool -> t a -> t a -> t a
(>->) :: (Arrays a, Arrays b, Arrays c) => (Acc a -> Acc b) -> (Acc b -> Acc c) -> Acc a -> Acc c
compute :: Arrays a => Acc a -> Acc a
indexed :: (Shape sh, Elt a) => Acc (Array sh a) -> Acc (Array sh (sh, a))
map :: (Shape sh, Elt a, Elt b) => (Exp a -> Exp b) -> Acc (Array sh a) -> Acc (Array sh b)
imap :: (Shape sh, Elt a, Elt b) => (Exp sh -> Exp a -> Exp b) -> Acc (Array sh a) -> Acc (Array sh b)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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 :: (Shape sh, Elt a, Elt b) => Acc (Array sh a) -> Acc (Array sh b) -> Acc (Array sh (a, b))
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))
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))
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))
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))
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))
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))
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))
unzip :: (Shape sh, Elt a, Elt b) => Acc (Array sh (a, b)) -> (Acc (Array sh a), Acc (Array sh b))
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))
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))
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))
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))
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))
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))
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))
reshape :: (Shape sh, Shape sh', Elt e) => Exp sh -> Acc (Array sh' e) -> Acc (Array sh e)
flatten :: forall sh e. (Shape sh, Elt e) => Acc (Array sh e) -> Acc (Vector e)
replicate :: (Slice slix, Elt e) => Exp slix -> Acc (Array (SliceShape slix) e) -> Acc (Array (FullShape slix) e)
slice :: (Slice slix, Elt e) => Acc (Array (FullShape slix) e) -> Exp slix -> Acc (Array (SliceShape slix) e)
init :: forall sh e. (Slice sh, Shape sh, Elt e) => Acc (Array (sh :. Int) e) -> Acc (Array (sh :. Int) e)
tail :: forall sh e. (Slice sh, Shape sh, Elt e) => Acc (Array (sh :. Int) e) -> Acc (Array (sh :. Int) e)
take :: forall sh e. (Slice sh, Shape sh, Elt e) => Exp Int -> Acc (Array (sh :. Int) e) -> Acc (Array (sh :. Int) e)
drop :: forall sh e. (Slice sh, Shape sh, Elt e) => Exp Int -> Acc (Array (sh :. Int) e) -> Acc (Array (sh :. Int) e)
slit :: forall sh e. (Slice sh, Shape sh, Elt e) => Exp Int -> Exp Int -> Acc (Array (sh :. Int) e) -> Acc (Array (sh :. Int) e)
initOn :: (Shape sh, Elt e) => Lens' (Exp sh) (Exp Int) -> Acc (Array sh e) -> Acc (Array sh e)
tailOn :: (Shape sh, Elt e) => Lens' (Exp sh) (Exp Int) -> Acc (Array sh e) -> Acc (Array sh e)
takeOn :: (Shape sh, Elt e) => Lens' (Exp sh) (Exp Int) -> Exp Int -> Acc (Array sh e) -> Acc (Array sh e)
dropOn :: (Shape sh, Elt e) => Lens' (Exp sh) (Exp Int) -> Exp Int -> Acc (Array sh e) -> Acc (Array sh e)
slitOn :: (Shape sh, Elt e) => Lens' (Exp sh) (Exp Int) -> Exp Int -> Exp Int -> Acc (Array sh e) -> Acc (Array sh e)
permute :: (Shape sh, Shape sh', Elt a) => (Exp a -> Exp a -> Exp a) -> Acc (Array sh' a) -> (Exp sh -> Exp sh') -> Acc (Array sh a) -> Acc (Array sh' a)
ignore :: Shape sh => Exp sh
scatter :: Elt e => Acc (Vector Int) -> Acc (Vector e) -> Acc (Vector e) -> Acc (Vector e)
backpermute :: (Shape sh, Shape sh', Elt a) => Exp sh' -> (Exp sh' -> Exp sh) -> Acc (Array sh a) -> Acc (Array sh' a)
gather :: (Shape sh, Elt e) => Acc (Array sh Int) -> Acc (Vector e) -> Acc (Array sh e)
reverse :: Elt e => Acc (Vector e) -> Acc (Vector e)
transpose :: Elt e => Acc (Array DIM2 e) -> Acc (Array DIM2 e)
reverseOn :: (Shape sh, Elt e) => Lens' (Exp sh) (Exp Int) -> Acc (Array sh e) -> Acc (Array sh e)
transposeOn :: (Shape sh, Elt e) => Lens' (Exp sh) (Exp Int) -> Lens' (Exp sh) (Exp Int) -> Acc (Array sh e) -> Acc (Array sh e)
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)
fold :: (Shape sh, Elt a) => (Exp a -> Exp a -> Exp a) -> Exp a -> Acc (Array (sh :. Int) a) -> Acc (Array sh a)
fold1 :: (Shape sh, Elt a) => (Exp a -> Exp a -> Exp a) -> Acc (Array (sh :. Int) a) -> Acc (Array sh a)
foldAll :: (Shape sh, Elt a) => (Exp a -> Exp a -> Exp a) -> Exp a -> Acc (Array sh a) -> Acc (Scalar a)
fold1All :: (Shape sh, Elt a) => (Exp a -> Exp a -> Exp a) -> Acc (Array sh a) -> Acc (Scalar a)
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)
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)
all :: (Shape sh, Elt e) => (Exp e -> Exp Bool) -> Acc (Array (sh :. Int) e) -> Acc (Array sh Bool)
any :: (Shape sh, Elt e) => (Exp e -> Exp Bool) -> Acc (Array (sh :. Int) e) -> Acc (Array sh Bool)
and :: Shape sh => Acc (Array (sh :. Int) Bool) -> Acc (Array sh Bool)
or :: Shape sh => Acc (Array (sh :. Int) Bool) -> Acc (Array sh Bool)
sum :: (Shape sh, Num e) => Acc (Array (sh :. Int) e) -> Acc (Array sh e)
product :: (Shape sh, Num e) => Acc (Array (sh :. Int) e) -> Acc (Array sh e)
minimum :: (Shape sh, Ord e) => Acc (Array (sh :. Int) e) -> Acc (Array sh e)
maximum :: (Shape sh, Ord e) => Acc (Array (sh :. Int) e) -> Acc (Array sh e)
scanl :: (Shape sh, Elt a) => (Exp a -> Exp a -> Exp a) -> Exp a -> Acc (Array (sh :. Int) a) -> Acc (Array (sh :. Int) a)
scanl1 :: (Shape sh, Elt a) => (Exp a -> Exp a -> Exp a) -> Acc (Array (sh :. Int) a) -> Acc (Array (sh :. Int) a)
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)
scanr :: (Shape sh, Elt a) => (Exp a -> Exp a -> Exp a) -> Exp a -> Acc (Array (sh :. Int) a) -> Acc (Array (sh :. Int) a)
scanr1 :: (Shape sh, Elt a) => (Exp a -> Exp a -> Exp a) -> Acc (Array (sh :. Int) a) -> Acc (Array (sh :. Int) a)
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)
prescanl :: (Shape sh, Elt a) => (Exp a -> Exp a -> Exp a) -> Exp a -> Acc (Array (sh :. Int) a) -> Acc (Array (sh :. Int) a)
postscanl :: (Shape sh, Elt a) => (Exp a -> Exp a -> Exp a) -> Exp a -> Acc (Array (sh :. Int) a) -> Acc (Array (sh :. Int) a)
prescanr :: (Shape sh, Elt a) => (Exp a -> Exp a -> Exp a) -> Exp a -> Acc (Array (sh :. Int) a) -> Acc (Array (sh :. Int) a)
postscanr :: (Shape sh, Elt a) => (Exp a -> Exp a -> Exp a) -> Exp a -> Acc (Array (sh :. Int) a) -> Acc (Array (sh :. Int) a)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
stencil :: (Stencil sh a stencil, Elt b) => (stencil -> Exp b) -> Boundary (Array sh a) -> Acc (Array sh a) -> Acc (Array sh b)
stencil2 :: (Stencil sh a stencil1, Stencil sh b stencil2, Elt c) => (stencil1 -> stencil2 -> Exp c) -> Boundary (Array sh a) -> Acc (Array sh a) -> Boundary (Array sh b) -> Acc (Array sh b) -> Acc (Array sh c)
class (Elt (StencilRepr sh stencil), Stencil sh a (StencilRepr sh stencil)) => Stencil sh a stencil
data Boundary t
clamp :: Boundary (Array sh e)
mirror :: Boundary (Array sh e)
wrap :: Boundary (Array sh e)
function :: (Shape sh, Elt e) => (Exp sh -> Exp e) -> Boundary (Array sh e)
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)
data Exp t
class Elt a => Eq a where
- (==) :: Exp a -> Exp a -> Exp Bool
- (/=) :: Exp a -> Exp a -> Exp Bool
class Eq a => Ord a where
- (<) :: Exp a -> Exp a -> Exp Bool
- (>) :: Exp a -> Exp a -> Exp Bool
- (<=) :: Exp a -> Exp a -> Exp Bool
- (>=) :: Exp a -> Exp a -> Exp Bool
- min :: Exp a -> Exp a -> Exp a
- max :: Exp a -> Exp a -> Exp a
- compare :: Exp a -> Exp a -> Exp Ordering
data Ordering
- = LT
- | EQ
- | GT
type Enum a = Enum (Exp a)
succ :: Enum a => a -> a
pred :: Enum a => a -> a
type Bounded a = (Elt a, Bounded (Exp a))
minBound :: Bounded a => a
maxBound :: Bounded a => a
type Num a = (Elt a, Num (Exp a))
(+) :: Num a => a -> a -> a
(-) :: Num a => a -> a -> a
(*) :: Num a => a -> a -> a
negate :: Num a => a -> a
abs :: Num a => a -> a
signum :: Num a => a -> a
fromInteger :: Num a => Integer -> Exp a
type Integral a = (Enum a, Real a, Integral (Exp a))
quot :: Integral a => a -> a -> a
rem :: Integral a => a -> a -> a
div :: Integral a => a -> a -> a
mod :: Integral a => a -> a -> a
quotRem :: Integral a => a -> a -> (a, a)
divMod :: Integral a => a -> a -> (a, a)
type Fractional a = (Num a, Fractional (Exp a))
(/) :: Fractional a => a -> a -> a
recip :: Fractional a => a -> a
fromRational :: Fractional a => Rational -> Exp a
type Floating a = (Fractional a, Floating (Exp a))
pi :: Floating a => a
sin :: Floating a => a -> a
cos :: Floating a => a -> a
tan :: Floating a => a -> a
asin :: Floating a => a -> a
acos :: Floating a => a -> a
atan :: Floating a => a -> a
sinh :: Floating a => a -> a
cosh :: Floating a => a -> a
tanh :: Floating a => a -> a
asinh :: Floating a => a -> a
acosh :: Floating a => a -> a
atanh :: Floating a => a -> a
exp :: Floating a => a -> a
sqrt :: Floating a => a -> a
log :: Floating a => a -> a
(**) :: Floating a => a -> a -> a
logBase :: Floating a => a -> a -> a
class (Real a, Fractional a) => RealFrac a where
- properFraction :: (Num b, ToFloating b a, IsIntegral b) => Exp a -> (Exp b, Exp a)
- truncate :: (Elt b, IsIntegral b) => Exp a -> Exp b
- round :: (Elt b, IsIntegral b) => Exp a -> Exp b
- ceiling :: (Elt b, IsIntegral b) => Exp a -> Exp b
- floor :: (Elt b, IsIntegral b) => Exp a -> Exp b
div' :: (RealFrac a, Elt b, IsIntegral b) => Exp a -> Exp a -> Exp b
mod' :: (Floating a, RealFrac a, ToFloating Int a) => Exp a -> Exp a -> Exp a
divMod' :: (Floating a, RealFrac a, Num b, IsIntegral b, ToFloating b a) => Exp a -> Exp a -> (Exp b, Exp a)
class (RealFrac a, Floating a) => RealFloat a where
- floatRadix :: Exp a -> Exp Int64
- floatDigits :: Exp a -> Exp Int
- floatRange :: Exp a -> (Exp Int, Exp Int)
- decodeFloat :: Exp a -> (Exp Int64, Exp Int)
- encodeFloat :: Exp Int64 -> Exp Int -> Exp a
- exponent :: Exp a -> Exp Int
- significand :: Exp a -> Exp a
- scaleFloat :: Exp Int -> Exp a -> Exp a
- isNaN :: Exp a -> Exp Bool
- isInfinite :: Exp a -> Exp Bool
- isDenormalized :: Exp a -> Exp Bool
- isNegativeZero :: Exp a -> Exp Bool
- isIEEE :: Exp a -> Exp Bool
- atan2 :: Exp a -> Exp a -> Exp a
class FromIntegral a b where
- fromIntegral :: Integral a => Exp a -> Exp b
class ToFloating a b where
- toFloating :: (Num a, Floating b) => Exp a -> Exp b
class Lift c e where
- type Plain e
- lift :: e -> c (Plain e)
class Lift c e => Unlift c e where
- unlift :: c (Plain e) -> e
lift1 :: (Unlift Exp a, Lift Exp b) => (a -> b) -> Exp (Plain a) -> Exp (Plain b)
lift2 :: (Unlift Exp a, Unlift Exp b, Lift Exp c) => (a -> b -> c) -> Exp (Plain a) -> Exp (Plain b) -> Exp (Plain c)
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)
ilift1 :: (Exp Int -> Exp Int) -> Exp DIM1 -> Exp DIM1
ilift2 :: (Exp Int -> Exp Int -> Exp Int) -> Exp DIM1 -> Exp DIM1 -> Exp DIM1
ilift3 :: (Exp Int -> Exp Int -> Exp Int -> Exp Int) -> Exp DIM1 -> Exp DIM1 -> Exp DIM1 -> Exp DIM1
constant :: Elt t => t -> Exp t
fst :: forall a b. (Elt a, Elt b) => Exp (a, b) -> Exp a
afst :: forall a b. (Arrays a, Arrays b) => Acc (a, b) -> Acc a
snd :: forall a b. (Elt a, Elt b) => Exp (a, b) -> Exp b
asnd :: forall a b. (Arrays a, Arrays b) => Acc (a, b) -> Acc b
curry :: Lift f (f a, f b) => (f (Plain (f a), Plain (f b)) -> f c) -> f a -> f b -> f c
uncurry :: Unlift f (f a, f b) => (f a -> f b -> f c) -> f (Plain (f a), Plain (f b)) -> f c
(?) :: Elt t => Exp Bool -> (Exp t, Exp t) -> Exp t
caseof :: (Elt a, Elt b) => Exp a -> [(Exp a -> Exp Bool, Exp b)] -> Exp b -> Exp b
cond :: Elt t => Exp Bool -> Exp t -> Exp t -> Exp t
while :: Elt e => (Exp e -> Exp Bool) -> (Exp e -> Exp e) -> Exp e -> Exp e
iterate :: forall a. Elt a => Exp Int -> (Exp a -> Exp a) -> Exp a -> Exp a
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
(&&) :: Exp Bool -> Exp Bool -> Exp Bool
(||) :: Exp Bool -> Exp Bool -> Exp Bool
not :: Exp Bool -> Exp Bool
subtract :: Num a => Exp a -> Exp a -> Exp a
even :: Integral a => Exp a -> Exp Bool
odd :: Integral a => Exp a -> Exp Bool
gcd :: Integral a => Exp a -> Exp a -> Exp a
lcm :: Integral a => Exp a -> Exp a -> Exp a
(^) :: forall a b. (Num a, Integral b) => Exp a -> Exp b -> Exp a
(^^) :: (Fractional a, Integral b) => Exp a -> Exp b -> Exp a
index0 :: Exp Z
index1 :: Elt i => Exp i -> Exp (Z :. i)
unindex1 :: Elt i => Exp (Z :. i) -> Exp i
index2 :: (Elt i, Slice (Z :. i)) => Exp i -> Exp i -> Exp ((Z :. i) :. i)
unindex2 :: forall i. (Elt i, Slice (Z :. i)) => Exp ((Z :. i) :. i) -> Exp (i, i)
index3 :: (Elt i, Slice (Z :. i), Slice ((Z :. i) :. i)) => Exp i -> Exp i -> Exp i -> Exp (((Z :. i) :. i) :. i)
unindex3 :: forall i. (Elt i, Slice (Z :. i), Slice ((Z :. i) :. i)) => Exp (((Z :. i) :. i) :. i) -> Exp (i, i, i)
indexHead :: (Slice sh, Elt a) => Exp (sh :. a) -> Exp a
indexTail :: (Slice sh, Elt a) => Exp (sh :. a) -> Exp sh
toIndex :: Shape sh => Exp sh -> Exp sh -> Exp Int
fromIndex :: Shape sh => Exp sh -> Exp Int -> Exp sh
intersect :: Shape sh => Exp sh -> Exp sh -> Exp sh
ord :: Exp Char -> Exp Int
chr :: Exp Int -> Exp Char
boolToInt :: Exp Bool -> Exp Int
bitcast :: (Elt a, Elt b, IsScalar (EltRepr a), IsScalar (EltRepr b), BitSizeEq (EltRepr a) (EltRepr b)) => Exp a -> Exp b
foreignAcc :: (Arrays as, Arrays bs, Foreign asm) => asm (as -> bs) -> (Acc as -> Acc bs) -> Acc as -> Acc bs
foreignExp :: (Elt x, Elt y, Foreign asm) => asm (x -> y) -> (Exp x -> Exp y) -> Exp x -> Exp y
arrayRank :: Shape sh => sh -> Int
arrayShape :: Shape sh => Array sh e -> sh
arraySize :: Shape sh => sh -> Int
arrayReshape :: (Shape sh, Shape sh', Elt e) => sh -> Array sh' e -> Array sh e
indexArray :: Array sh e -> sh -> e
linearIndexArray :: Array sh e -> Int -> e
fromFunction :: (Shape sh, Elt e) => sh -> (sh -> e) -> Array sh e
fromFunctionM :: (Shape sh, Elt e) => sh -> (sh -> IO e) -> IO (Array sh e)
fromList :: (Shape sh, Elt e) => sh -> [e] -> Array sh e
toList :: forall sh e. Array sh e -> [e]
(.) :: (b -> c) -> (a -> b) -> a -> c
($) :: (a -> b) -> a -> b
error :: HasCallStack => [Char] -> a
undefined :: HasCallStack => a
const :: a -> b -> a
data Int
data Int8
data Int16
data Int32
data Int64
data Word
data Word8
data Word16
data Word32
data Word64
newtype Half = Half {
- getHalf :: CUShort
}
data Float
data Double
data Bool
- = False
- | True
data Char
data CFloat
data CDouble
data CShort
data CUShort
data CInt
data CUInt
data CLong
data CULong
data CLLong
data CULLong
data CChar
data CSChar
data CUChar
class Typeable a => IsScalar a
class (Num a, IsSingle a) => IsNum a
class IsBounded a
class (IsSingle a, IsNum a, IsBounded a) => IsIntegral a
class (Floating a, IsSingle a, IsNum a) => IsFloating a
class IsNonNum a

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:

Element-wise operations, such as map, generate, and backpermute. Each element of these operations can be computed independently of all others.
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 #
Instance details Defined in Data.Array.Accelerate.Prelude Associated Types type EltT Acc a :: Constraint # Methods ifThenElse :: EltT Acc a => Exp Bool -> Acc a -> Acc a -> Acc a #
Unlift Acc (Acc a) #
Instance details Defined in Data.Array.Accelerate.Lift Methods unlift :: Acc (Plain (Acc a)) -> Acc a #
Lift Acc (Acc a) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (Acc a) :: Type # Methods lift :: Acc a -> Acc (Plain (Acc a)) #
(Arrays a, Arrays b) => Unlift Acc (Acc a, Acc b) #
Instance details Defined in Data.Array.Accelerate.Lift 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) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (a, b) :: Type # Methods lift :: (a, b) -> Acc (Plain (a, b)) #
(Shape sh, Elt e) => Lift Acc (Array sh e) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (Array sh e) :: Type # Methods lift :: Array sh e -> Acc (Plain (Array sh e)) #
(Arrays a, Arrays b, Arrays c) => Unlift Acc (Acc a, Acc b, Acc c) #
Instance details Defined in Data.Array.Accelerate.Lift 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) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (a, b, c) :: Type # 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) #
Instance details Defined in Data.Array.Accelerate.Lift 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) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (a, b, c, d) :: Type # 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) #
Instance details Defined in Data.Array.Accelerate.Lift 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) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (a, b, c, d, e) :: Type # 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) #
Instance details Defined in Data.Array.Accelerate.Lift 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) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (a, b, c, d, e, f) :: Type # 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) #
Instance details Defined in Data.Array.Accelerate.Lift 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) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (a, b, c, d, e, f, g) :: Type # 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) #
Instance details Defined in Data.Array.Accelerate.Lift 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) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (a, b, c, d, e, f, g, h) :: Type # 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) #
Instance details Defined in Data.Array.Accelerate.Lift 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) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (a, b, c, d, e, f, g, h, i) :: Type # 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) #
Instance details Defined in Data.Array.Accelerate.Lift 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) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (a, b, c, d, e, f, g, h, i, j) :: Type # 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) #
Instance details Defined in Data.Array.Accelerate.Lift 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) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (a, b, c, d, e, f, g, h, i, j, k) :: Type # 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) #
Instance details Defined in Data.Array.Accelerate.Lift 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) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (a, b, c, d, e, f, g, h, i, j, k, l) :: Type # 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) #
Instance details Defined in Data.Array.Accelerate.Lift 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) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (a, b, c, d, e, f, g, h, i, j, k, l, m) :: Type # 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) #
Instance details Defined in Data.Array.Accelerate.Lift 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) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (a, b, c, d, e, f, g, h, i, j, k, l, m, n) :: Type # 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) #
Instance details Defined in Data.Array.Accelerate.Lift 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) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) :: Type # 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) #
Instance details Defined in Data.Array.Accelerate.Trafo Methods showsPrec :: Int -> Acc arrs -> ShowS # show :: Acc arrs -> String # showList :: [Acc arrs] -> ShowS #
Afunction (Acc a -> f) => Show (Acc a -> f) #
Instance details Defined in Data.Array.Accelerate.Trafo Methods showsPrec :: Int -> (Acc a -> f) -> ShowS # show :: (Acc a -> f) -> String # showList :: [Acc a -> f] -> ShowS #
type EltT Acc a #
Instance details Defined in Data.Array.Accelerate.Prelude type EltT Acc a = Arrays a
type Plain (Acc a) #
Instance details Defined in Data.Array.Accelerate.Lift 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) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (Array sh e) :: Type # Methods lift :: Array sh e -> Acc (Plain (Array sh e)) #
Elt e => IsList (Vector e) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Associated Types type Item (Vector e) :: Type # Methods fromList :: [Item (Vector e)] -> Vector e # fromListN :: Int -> [Item (Vector e)] -> Vector e # toList :: Vector e -> [Item (Vector e)] #
Show (Vector e) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods showsPrec :: Int -> Vector e -> ShowS # show :: Vector e -> String # showList :: [Vector e] -> ShowS #
Show (Scalar e) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods showsPrec :: Int -> Scalar e -> ShowS # show :: Scalar e -> String # showList :: [Scalar e] -> ShowS #
(Eq sh, Eq e) => Eq (Array sh e) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods (==) :: Array sh e -> Array sh e -> Bool # (/=) :: Array sh e -> Array sh e -> Bool #
Show (Array sh e) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods showsPrec :: Int -> Array sh e -> ShowS # show :: Array sh e -> String # showList :: [Array sh e] -> ShowS #
Show (Array DIM2 e) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods showsPrec :: Int -> Array DIM2 e -> ShowS # show :: Array DIM2 e -> String # showList :: [Array DIM2 e] -> ShowS #
NFData (Array sh e) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods rnf :: Array sh e -> () #
(Shape sh, Elt e) => Arrays (Array sh e) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar 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) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar type Item (Vector e) = e
type Plain (Array sh e) #
Instance details Defined in Data.Array.Accelerate.Lift 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 () #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods arrays :: () -> ArraysR (ArrRepr ()) flavour :: () -> ArraysFlavour () toArr :: ArrRepr () -> () fromArr :: () -> ArrRepr ()
(Arrays a, Arrays b) => Arrays (a, b) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar 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) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar 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) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar 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) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar 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) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar 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) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar 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) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar 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) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar 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) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar 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) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar 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) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar 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) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar 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) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar 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) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar 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) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar 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) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar 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:

Minimal complete definition

eltType, fromElt, toElt

Instances

Elt Bool #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods eltType :: Bool -> TupleType (EltRepr Bool) fromElt :: Bool -> EltRepr Bool toElt :: EltRepr Bool -> Bool
Elt Char #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods eltType :: Char -> TupleType (EltRepr Char) fromElt :: Char -> EltRepr Char toElt :: EltRepr Char -> Char
Elt Double #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods eltType :: Double -> TupleType (EltRepr Double) fromElt :: Double -> EltRepr Double toElt :: EltRepr Double -> Double
Elt Float #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods eltType :: Float -> TupleType (EltRepr Float) fromElt :: Float -> EltRepr Float toElt :: EltRepr Float -> Float
Elt Int #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods eltType :: Int -> TupleType (EltRepr Int) fromElt :: Int -> EltRepr Int toElt :: EltRepr Int -> Int
Elt Int8 #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods eltType :: Int8 -> TupleType (EltRepr Int8) fromElt :: Int8 -> EltRepr Int8 toElt :: EltRepr Int8 -> Int8
Elt Int16 #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods eltType :: Int16 -> TupleType (EltRepr Int16) fromElt :: Int16 -> EltRepr Int16 toElt :: EltRepr Int16 -> Int16
Elt Int32 #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods eltType :: Int32 -> TupleType (EltRepr Int32) fromElt :: Int32 -> EltRepr Int32 toElt :: EltRepr Int32 -> Int32
Elt Int64 #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods eltType :: Int64 -> TupleType (EltRepr Int64) fromElt :: Int64 -> EltRepr Int64 toElt :: EltRepr Int64 -> Int64
Elt Ordering #
Instance details Defined in Data.Array.Accelerate.Classes.Ord Methods eltType :: Ordering -> TupleType (EltRepr Ordering) fromElt :: Ordering -> EltRepr Ordering toElt :: EltRepr Ordering -> Ordering
Elt Word #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods eltType :: Word -> TupleType (EltRepr Word) fromElt :: Word -> EltRepr Word toElt :: EltRepr Word -> Word
Elt Word8 #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods eltType :: Word8 -> TupleType (EltRepr Word8) fromElt :: Word8 -> EltRepr Word8 toElt :: EltRepr Word8 -> Word8
Elt Word16 #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods eltType :: Word16 -> TupleType (EltRepr Word16) fromElt :: Word16 -> EltRepr Word16 toElt :: EltRepr Word16 -> Word16
Elt Word32 #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods eltType :: Word32 -> TupleType (EltRepr Word32) fromElt :: Word32 -> EltRepr Word32 toElt :: EltRepr Word32 -> Word32
Elt Word64 #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods eltType :: Word64 -> TupleType (EltRepr Word64) fromElt :: Word64 -> EltRepr Word64 toElt :: EltRepr Word64 -> Word64
Elt () #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods eltType :: () -> TupleType (EltRepr ()) fromElt :: () -> EltRepr () toElt :: EltRepr () -> ()
Elt CChar #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods eltType :: CChar -> TupleType (EltRepr CChar) fromElt :: CChar -> EltRepr CChar toElt :: EltRepr CChar -> CChar
Elt CSChar #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods eltType :: CSChar -> TupleType (EltRepr CSChar) fromElt :: CSChar -> EltRepr CSChar toElt :: EltRepr CSChar -> CSChar
Elt CUChar #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods eltType :: CUChar -> TupleType (EltRepr CUChar) fromElt :: CUChar -> EltRepr CUChar toElt :: EltRepr CUChar -> CUChar
Elt CShort #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods eltType :: CShort -> TupleType (EltRepr CShort) fromElt :: CShort -> EltRepr CShort toElt :: EltRepr CShort -> CShort
Elt CUShort #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods eltType :: CUShort -> TupleType (EltRepr CUShort) fromElt :: CUShort -> EltRepr CUShort toElt :: EltRepr CUShort -> CUShort
Elt CInt #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods eltType :: CInt -> TupleType (EltRepr CInt) fromElt :: CInt -> EltRepr CInt toElt :: EltRepr CInt -> CInt
Elt CUInt #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods eltType :: CUInt -> TupleType (EltRepr CUInt) fromElt :: CUInt -> EltRepr CUInt toElt :: EltRepr CUInt -> CUInt
Elt CLong #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods eltType :: CLong -> TupleType (EltRepr CLong) fromElt :: CLong -> EltRepr CLong toElt :: EltRepr CLong -> CLong
Elt CULong #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods eltType :: CULong -> TupleType (EltRepr CULong) fromElt :: CULong -> EltRepr CULong toElt :: EltRepr CULong -> CULong
Elt CLLong #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods eltType :: CLLong -> TupleType (EltRepr CLLong) fromElt :: CLLong -> EltRepr CLLong toElt :: EltRepr CLLong -> CLLong
Elt CULLong #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods eltType :: CULLong -> TupleType (EltRepr CULLong) fromElt :: CULLong -> EltRepr CULLong toElt :: EltRepr CULLong -> CULLong
Elt CFloat #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods eltType :: CFloat -> TupleType (EltRepr CFloat) fromElt :: CFloat -> EltRepr CFloat toElt :: EltRepr CFloat -> CFloat
Elt CDouble #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods eltType :: CDouble -> TupleType (EltRepr CDouble) fromElt :: CDouble -> EltRepr CDouble toElt :: EltRepr CDouble -> CDouble
Elt Half #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods eltType :: Half -> TupleType (EltRepr Half) fromElt :: Half -> EltRepr Half toElt :: EltRepr Half -> Half
Elt All #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods eltType :: All -> TupleType (EltRepr All) fromElt :: All -> EltRepr All toElt :: EltRepr All -> All
Elt Z #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods eltType :: Z -> TupleType (EltRepr Z) fromElt :: Z -> EltRepr Z toElt :: EltRepr Z -> Z
Elt a => Elt (Maybe a) #
Instance details Defined in Data.Array.Accelerate.Data.Maybe Methods eltType :: Maybe a -> TupleType (EltRepr (Maybe a)) fromElt :: Maybe a -> EltRepr (Maybe a) toElt :: EltRepr (Maybe a) -> Maybe a
Elt (Complex Double) #
Instance details Defined in Data.Array.Accelerate.Data.Complex Methods eltType :: Complex Double -> TupleType (EltRepr (Complex Double)) fromElt :: Complex Double -> EltRepr (Complex Double) toElt :: EltRepr (Complex Double) -> Complex Double
Elt (Complex Float) #
Instance details Defined in Data.Array.Accelerate.Data.Complex Methods eltType :: Complex Float -> TupleType (EltRepr (Complex Float)) fromElt :: Complex Float -> EltRepr (Complex Float) toElt :: EltRepr (Complex Float) -> Complex Float
Elt (Complex CFloat) #
Instance details Defined in Data.Array.Accelerate.Data.Complex Methods eltType :: Complex CFloat -> TupleType (EltRepr (Complex CFloat)) fromElt :: Complex CFloat -> EltRepr (Complex CFloat) toElt :: EltRepr (Complex CFloat) -> Complex CFloat
Elt (Complex CDouble) #
Instance details Defined in Data.Array.Accelerate.Data.Complex Methods eltType :: Complex CDouble -> TupleType (EltRepr (Complex CDouble)) fromElt :: Complex CDouble -> EltRepr (Complex CDouble) toElt :: EltRepr (Complex CDouble) -> Complex CDouble
Elt (Complex Half) #
Instance details Defined in Data.Array.Accelerate.Data.Complex 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) #
Instance details Defined in Data.Array.Accelerate.Data.Semigroup 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) #
Instance details Defined in Data.Array.Accelerate.Data.Semigroup 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) #
Instance details Defined in Data.Array.Accelerate.Data.Monoid 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) #
Instance details Defined in Data.Array.Accelerate.Data.Monoid 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)) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar 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) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar 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) #
Instance details Defined in Data.Array.Accelerate.Data.Either 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) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar 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) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar 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) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar 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) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar 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) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar 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) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar 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) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar 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) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar 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) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar 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) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar 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) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar 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) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar 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) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar 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) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar 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) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar 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) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar 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 #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods (==) :: Z -> Z -> Bool # (/=) :: Z -> Z -> Bool #
Show Z #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods showsPrec :: Int -> Z -> ShowS # show :: Z -> String # showList :: [Z] -> ShowS #
Slice Z #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Associated Types type SliceShape Z :: Type # type CoSliceShape Z :: Type # type FullShape Z :: Type # Methods sliceIndex :: Z -> SliceIndex (EltRepr Z) (EltRepr (SliceShape Z)) (EltRepr (CoSliceShape Z)) (EltRepr (FullShape Z)) #
Shape Z #
Instance details Defined in Data.Array.Accelerate.Array.Sugar 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 #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods eltType :: Z -> TupleType (EltRepr Z) fromElt :: Z -> EltRepr Z toElt :: EltRepr Z -> Z
Unlift Exp Z #
Instance details Defined in Data.Array.Accelerate.Lift Methods unlift :: Exp (Plain Z) -> Z #
Lift Exp Z #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain Z :: Type # Methods lift :: Z -> Exp (Plain Z) #
Elt e => Stencil DIM1 e (Exp e, Exp e, Exp e) #
Instance details Defined in Data.Array.Accelerate.Smart Associated Types type StencilRepr DIM1 (Exp e, Exp e, Exp e) :: Type 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) #
Instance details Defined in Data.Array.Accelerate.Smart Associated Types type StencilRepr DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e) :: Type 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) #
Instance details Defined in Data.Array.Accelerate.Smart Associated Types type StencilRepr DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e) :: Type 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) #
Instance details Defined in Data.Array.Accelerate.Smart Associated Types type StencilRepr DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e) :: Type 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) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Associated Types type Item (Vector e) :: Type # Methods fromList :: [Item (Vector e)] -> Vector e # fromListN :: Int -> [Item (Vector e)] -> Vector e # toList :: Vector e -> [Item (Vector e)] #
Show (Vector e) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods showsPrec :: Int -> Vector e -> ShowS # show :: Vector e -> String # showList :: [Vector e] -> ShowS #
Show (Scalar e) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods showsPrec :: Int -> Scalar e -> ShowS # show :: Scalar e -> String # showList :: [Scalar e] -> ShowS #
Elt (Any Z) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods eltType :: Any Z -> TupleType (EltRepr (Any Z)) fromElt :: Any Z -> EltRepr (Any Z) toElt :: EltRepr (Any Z) -> Any Z
Show (Array DIM2 e) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods showsPrec :: Int -> Array DIM2 e -> ShowS # show :: Array DIM2 e -> String # showList :: [Array DIM2 e] -> ShowS #
type SliceShape Z #
Instance details Defined in Data.Array.Accelerate.Array.Sugar type SliceShape Z = Z
type CoSliceShape Z #
Instance details Defined in Data.Array.Accelerate.Array.Sugar type CoSliceShape Z = Z
type FullShape Z #
Instance details Defined in Data.Array.Accelerate.Array.Sugar type FullShape Z = Z
type Plain Z #
Instance details Defined in Data.Array.Accelerate.Lift type Plain Z = Z
type Item (Vector e) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar 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) #
Instance details Defined in Data.Array.Accelerate.Smart Associated Types type StencilRepr DIM1 (Exp e, Exp e, Exp e) :: Type 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) #
Instance details Defined in Data.Array.Accelerate.Smart Associated Types type StencilRepr DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e) :: Type 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) #
Instance details Defined in Data.Array.Accelerate.Smart Associated Types type StencilRepr DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e) :: Type 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) #
Instance details Defined in Data.Array.Accelerate.Smart Associated Types type StencilRepr DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e) :: Type 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) #
Instance details Defined in Data.Array.Accelerate.Lift Methods unlift :: Exp (Plain (ix :. Exp e)) -> ix :. Exp e #
(Elt e, Slice ix) => Unlift Exp (Exp ix :. Exp e) #
Instance details Defined in Data.Array.Accelerate.Lift 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) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (ix :. Exp e) :: Type # Methods lift :: (ix :. Exp e) -> Exp (Plain (ix :. Exp e)) #
(Slice (Plain ix), Lift Exp ix) => Lift Exp (ix :. All) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (ix :. All) :: Type # Methods lift :: (ix :. All) -> Exp (Plain (ix :. All)) #
(Slice (Plain ix), Lift Exp ix) => Lift Exp (ix :. Int) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (ix :. Int) :: Type # Methods lift :: (ix :. Int) -> Exp (Plain (ix :. Int)) #
Elt e => IsList (Vector e) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Associated Types type Item (Vector e) :: Type # Methods fromList :: [Item (Vector e)] -> Vector e # fromListN :: Int -> [Item (Vector e)] -> Vector e # toList :: Vector e -> [Item (Vector e)] #
Show (Vector e) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods showsPrec :: Int -> Vector e -> ShowS # show :: Vector e -> String # showList :: [Vector e] -> ShowS #
Shape sh => Elt (Any (sh :. Int)) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar 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) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods (==) :: (tail :. head) -> (tail :. head) -> Bool # (/=) :: (tail :. head) -> (tail :. head) -> Bool #
Show (Array DIM2 e) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods showsPrec :: Int -> Array DIM2 e -> ShowS # show :: Array DIM2 e -> String # showList :: [Array DIM2 e] -> ShowS #
(Show sh, Show sz) => Show (sh :. sz) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods showsPrec :: Int -> (sh :. sz) -> ShowS # show :: (sh :. sz) -> String # showList :: [sh :. sz] -> ShowS #
Slice sl => Slice (sl :. Int) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Associated Types type SliceShape (sl :. Int) :: Type # type CoSliceShape (sl :. Int) :: Type # type FullShape (sl :. Int) :: Type # 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) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Associated Types type SliceShape (sl :. All) :: Type # type CoSliceShape (sl :. All) :: Type # type FullShape (sl :. All) :: Type # 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) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar 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) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar 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) #
Instance details Defined in Data.Array.Accelerate.Smart Associated Types type StencilRepr ((sh :. Int) :. Int) (row2, row1, row0) :: Type 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) #
Instance details Defined in Data.Array.Accelerate.Smart Associated Types type StencilRepr ((sh :. Int) :. Int) (row1, row2, row3, row4, row5) :: Type 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) #
Instance details Defined in Data.Array.Accelerate.Smart Associated Types type StencilRepr ((sh :. Int) :. Int) (row1, row2, row3, row4, row5, row6, row7) :: Type 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) #
Instance details Defined in Data.Array.Accelerate.Smart Associated Types type StencilRepr ((sh :. Int) :. Int) (row1, row2, row3, row4, row5, row6, row7, row8, row9) :: Type 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) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar type Item (Vector e) = e
type SliceShape (sl :. Int) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar type SliceShape (sl :. Int) = SliceShape sl
type SliceShape (sl :. All) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar type SliceShape (sl :. All) = SliceShape sl :. Int
type CoSliceShape (sl :. Int) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar type CoSliceShape (sl :. Int) = CoSliceShape sl :. Int
type CoSliceShape (sl :. All) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar type CoSliceShape (sl :. All) = CoSliceShape sl
type FullShape (sl :. Int) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar type FullShape (sl :. Int) = FullShape sl :. Int
type FullShape (sl :. All) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar type FullShape (sl :. All) = FullShape sl :. Int
type Plain (ix :. Exp e) #
Instance details Defined in Data.Array.Accelerate.Lift type Plain (ix :. Exp e) = Plain ix :. e
type Plain (ix :. All) #
Instance details Defined in Data.Array.Accelerate.Lift type Plain (ix :. All) = Plain ix :. All
type Plain (ix :. Int) #
Instance details Defined in Data.Array.Accelerate.Lift type Plain (ix :. Int) = Plain ix :. Int

type DIM0 = Z #

type DIM1 = DIM0 :. Int #

type DIM2 = DIM1 :. Int #

type DIM3 = DIM2 :. Int #

type DIM4 = DIM3 :. Int #

type DIM5 = DIM4 :. Int #

type DIM6 = DIM5 :. Int #

type DIM7 = DIM6 :. Int #

type DIM8 = DIM7 :. Int #

type DIM9 = DIM8 :. Int #

class (Elt sh, Elt (Any sh), 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 #
Instance details Defined in Data.Array.Accelerate.Array.Sugar 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) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar 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

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 #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Associated Types type SliceShape Z :: Type # type CoSliceShape Z :: Type # type FullShape Z :: Type # Methods sliceIndex :: Z -> SliceIndex (EltRepr Z) (EltRepr (SliceShape Z)) (EltRepr (CoSliceShape Z)) (EltRepr (FullShape Z)) #
Shape sh => Slice (Any sh) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Associated Types type SliceShape (Any sh) :: Type # type CoSliceShape (Any sh) :: Type # type FullShape (Any sh) :: Type # 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) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Associated Types type SliceShape (sl :. Int) :: Type # type CoSliceShape (sl :. Int) :: Type # type FullShape (sl :. Int) :: Type # 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) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Associated Types type SliceShape (sl :. All) :: Type # type CoSliceShape (sl :. All) :: Type # type FullShape (sl :. All) :: Type # 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 #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods (==) :: All -> All -> Bool # (/=) :: All -> All -> Bool #
Show All #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods showsPrec :: Int -> All -> ShowS # show :: All -> String # showList :: [All] -> ShowS #
Elt All #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods eltType :: All -> TupleType (EltRepr All) fromElt :: All -> EltRepr All toElt :: EltRepr All -> All
(Slice (Plain ix), Lift Exp ix) => Lift Exp (ix :. All) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (ix :. All) :: Type # Methods lift :: (ix :. All) -> Exp (Plain (ix :. All)) #
Slice sl => Slice (sl :. All) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Associated Types type SliceShape (sl :. All) :: Type # type CoSliceShape (sl :. All) :: Type # type FullShape (sl :. All) :: Type # Methods sliceIndex :: (sl :. All) -> SliceIndex (EltRepr (sl :. All)) (EltRepr (SliceShape (sl :. All))) (EltRepr (CoSliceShape (sl :. All))) (EltRepr (FullShape (sl :. All))) #
type SliceShape (sl :. All) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar type SliceShape (sl :. All) = SliceShape sl :. Int
type CoSliceShape (sl :. All) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar type CoSliceShape (sl :. All) = CoSliceShape sl
type FullShape (sl :. All) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar type FullShape (sl :. All) = FullShape sl :. Int
type Plain (ix :. All) #
Instance details Defined in Data.Array.Accelerate.Lift type Plain (ix :. All) = Plain ix :. All

data Any sh #

Marker for arbitrary dimensions in slice and replicate descriptors.

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

See slice and replicate for examples.

Constructors

Any

Instances

Shape sh => Lift Exp (Any sh) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (Any sh) :: Type # Methods lift :: Any sh -> Exp (Plain (Any sh)) #
Eq (Any sh) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods (==) :: Any sh -> Any sh -> Bool # (/=) :: Any sh -> Any sh -> Bool #
Show (Any sh) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods showsPrec :: Int -> Any sh -> ShowS # show :: Any sh -> String # showList :: [Any sh] -> ShowS #
Shape sh => Slice (Any sh) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Associated Types type SliceShape (Any sh) :: Type # type CoSliceShape (Any sh) :: Type # type FullShape (Any sh) :: Type # 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)) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar 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) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods eltType :: Any Z -> TupleType (EltRepr (Any Z)) fromElt :: Any Z -> EltRepr (Any Z) toElt :: EltRepr (Any Z) -> Any Z
type SliceShape (Any sh) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar type SliceShape (Any sh) = sh
type CoSliceShape (Any sh) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar type CoSliceShape (Any sh) = Z
type FullShape (Any sh) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar type FullShape (Any sh) = sh
type Plain (Any sh) #
Instance details Defined in Data.Array.Accelerate.Lift 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.

Associated Types

type EltT t a :: Constraint #

Methods

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

Instances

IfThenElse Exp #
Instance details Defined in Data.Array.Accelerate.Prelude Associated Types type EltT Exp a :: Constraint # Methods ifThenElse :: EltT Exp a => Exp Bool -> Exp a -> Exp a -> Exp a #
IfThenElse Acc #
Instance details Defined in Data.Array.Accelerate.Prelude 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:

The permute operation will always be evaluated; it can not be fused into a later step.
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.
The array of source values can fuse into the permutation operation.
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) #
Instance details Defined in Data.Array.Accelerate.Smart Associated Types type StencilRepr DIM1 (Exp e, Exp e, Exp e) :: Type 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) #
Instance details Defined in Data.Array.Accelerate.Smart Associated Types type StencilRepr DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e) :: Type 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) #
Instance details Defined in Data.Array.Accelerate.Smart Associated Types type StencilRepr DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e) :: Type 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) #
Instance details Defined in Data.Array.Accelerate.Smart Associated Types type StencilRepr DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e) :: Type 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) #
Instance details Defined in Data.Array.Accelerate.Smart Associated Types type StencilRepr ((sh :. Int) :. Int) (row2, row1, row0) :: Type 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) #
Instance details Defined in Data.Array.Accelerate.Smart Associated Types type StencilRepr ((sh :. Int) :. Int) (row1, row2, row3, row4, row5) :: Type 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) #
Instance details Defined in Data.Array.Accelerate.Smart Associated Types type StencilRepr ((sh :. Int) :. Int) (row1, row2, row3, row4, row5, row6, row7) :: Type 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) #
Instance details Defined in Data.Array.Accelerate.Smart Associated Types type StencilRepr ((sh :. Int) :. Int) (row1, row2, row3, row4, row5, row6, row7, row8, row9) :: Type 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 #
Instance details Defined in Data.Array.Accelerate.Prelude Associated Types type EltT Exp a :: Constraint # Methods ifThenElse :: EltT Exp a => Exp Bool -> Exp a -> Exp a -> Exp a #
Unlift Exp () #
Instance details Defined in Data.Array.Accelerate.Lift Methods unlift :: Exp (Plain ()) -> () #
Unlift Exp Z #
Instance details Defined in Data.Array.Accelerate.Lift Methods unlift :: Exp (Plain Z) -> Z #
Lift Exp Bool #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain Bool :: Type # Methods lift :: Bool -> Exp (Plain Bool) #
Lift Exp Char #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain Char :: Type # Methods lift :: Char -> Exp (Plain Char) #
Lift Exp Double #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain Double :: Type # Methods lift :: Double -> Exp (Plain Double) #
Lift Exp Float #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain Float :: Type # Methods lift :: Float -> Exp (Plain Float) #
Lift Exp Int #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain Int :: Type # Methods lift :: Int -> Exp (Plain Int) #
Lift Exp Int8 #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain Int8 :: Type # Methods lift :: Int8 -> Exp (Plain Int8) #
Lift Exp Int16 #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain Int16 :: Type # Methods lift :: Int16 -> Exp (Plain Int16) #
Lift Exp Int32 #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain Int32 :: Type # Methods lift :: Int32 -> Exp (Plain Int32) #
Lift Exp Int64 #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain Int64 :: Type # Methods lift :: Int64 -> Exp (Plain Int64) #
Lift Exp Word #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain Word :: Type # Methods lift :: Word -> Exp (Plain Word) #
Lift Exp Word8 #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain Word8 :: Type # Methods lift :: Word8 -> Exp (Plain Word8) #
Lift Exp Word16 #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain Word16 :: Type # Methods lift :: Word16 -> Exp (Plain Word16) #
Lift Exp Word32 #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain Word32 :: Type # Methods lift :: Word32 -> Exp (Plain Word32) #
Lift Exp Word64 #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain Word64 :: Type # Methods lift :: Word64 -> Exp (Plain Word64) #
Lift Exp () #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain () :: Type # Methods lift :: () -> Exp (Plain ()) #
Lift Exp CChar #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain CChar :: Type # Methods lift :: CChar -> Exp (Plain CChar) #
Lift Exp CSChar #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain CSChar :: Type # Methods lift :: CSChar -> Exp (Plain CSChar) #
Lift Exp CUChar #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain CUChar :: Type # Methods lift :: CUChar -> Exp (Plain CUChar) #
Lift Exp CShort #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain CShort :: Type # Methods lift :: CShort -> Exp (Plain CShort) #
Lift Exp CUShort #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain CUShort :: Type # Methods lift :: CUShort -> Exp (Plain CUShort) #
Lift Exp CInt #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain CInt :: Type # Methods lift :: CInt -> Exp (Plain CInt) #
Lift Exp CUInt #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain CUInt :: Type # Methods lift :: CUInt -> Exp (Plain CUInt) #
Lift Exp CLong #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain CLong :: Type # Methods lift :: CLong -> Exp (Plain CLong) #
Lift Exp CULong #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain CULong :: Type # Methods lift :: CULong -> Exp (Plain CULong) #
Lift Exp CLLong #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain CLLong :: Type # Methods lift :: CLLong -> Exp (Plain CLLong) #
Lift Exp CULLong #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain CULLong :: Type # Methods lift :: CULLong -> Exp (Plain CULLong) #
Lift Exp CFloat #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain CFloat :: Type # Methods lift :: CFloat -> Exp (Plain CFloat) #
Lift Exp CDouble #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain CDouble :: Type # Methods lift :: CDouble -> Exp (Plain CDouble) #
Lift Exp Z #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain Z :: Type # Methods lift :: Z -> Exp (Plain Z) #
Elt e => Stencil DIM1 e (Exp e, Exp e, Exp e) #
Instance details Defined in Data.Array.Accelerate.Smart Associated Types type StencilRepr DIM1 (Exp e, Exp e, Exp e) :: Type 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) #
Instance details Defined in Data.Array.Accelerate.Smart Associated Types type StencilRepr DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e) :: Type 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) #
Instance details Defined in Data.Array.Accelerate.Smart Associated Types type StencilRepr DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e) :: Type 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) #
Instance details Defined in Data.Array.Accelerate.Smart Associated Types type StencilRepr DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e) :: Type 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)) #
Instance details Defined in Data.Array.Accelerate.Data.Complex Methods unlift :: Exp (Plain (Complex (Exp a))) -> Complex (Exp a) #
Elt a => Unlift Exp (Min (Exp a)) #
Instance details Defined in Data.Array.Accelerate.Data.Semigroup Methods unlift :: Exp (Plain (Min (Exp a))) -> Min (Exp a) #
Elt a => Unlift Exp (Max (Exp a)) #
Instance details Defined in Data.Array.Accelerate.Data.Semigroup Methods unlift :: Exp (Plain (Max (Exp a))) -> Max (Exp a) #
Elt a => Unlift Exp (Sum (Exp a)) #
Instance details Defined in Data.Array.Accelerate.Data.Monoid Methods unlift :: Exp (Plain (Sum (Exp a))) -> Sum (Exp a) #
Elt a => Unlift Exp (Product (Exp a)) #
Instance details Defined in Data.Array.Accelerate.Data.Monoid Methods unlift :: Exp (Plain (Product (Exp a))) -> Product (Exp a) #
Unlift Exp (Exp e) #
Instance details Defined in Data.Array.Accelerate.Lift Methods unlift :: Exp (Plain (Exp e)) -> Exp e #
(Lift Exp a, Elt (Plain a)) => Lift Exp (Maybe a) #
Instance details Defined in Data.Array.Accelerate.Data.Maybe Associated Types type Plain (Maybe a) :: Type # Methods lift :: Maybe a -> Exp (Plain (Maybe a)) #
(Lift Exp a, Elt (Plain a), Elt (Complex (Plain a))) => Lift Exp (Complex a) #
Instance details Defined in Data.Array.Accelerate.Data.Complex Associated Types type Plain (Complex a) :: Type # Methods lift :: Complex a -> Exp (Plain (Complex a)) #
(Lift Exp a, Elt (Plain a)) => Lift Exp (Min a) #
Instance details Defined in Data.Array.Accelerate.Data.Semigroup Associated Types type Plain (Min a) :: Type # Methods lift :: Min a -> Exp (Plain (Min a)) #
(Lift Exp a, Elt (Plain a)) => Lift Exp (Max a) #
Instance details Defined in Data.Array.Accelerate.Data.Semigroup Associated Types type Plain (Max a) :: Type # Methods lift :: Max a -> Exp (Plain (Max a)) #
(Lift Exp a, Elt (Plain a)) => Lift Exp (Sum a) #
Instance details Defined in Data.Array.Accelerate.Data.Monoid Associated Types type Plain (Sum a) :: Type # Methods lift :: Sum a -> Exp (Plain (Sum a)) #
(Lift Exp a, Elt (Plain a)) => Lift Exp (Product a) #
Instance details Defined in Data.Array.Accelerate.Data.Monoid Associated Types type Plain (Product a) :: Type # Methods lift :: Product a -> Exp (Plain (Product a)) #
Shape sh => Lift Exp (Any sh) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (Any sh) :: Type # Methods lift :: Any sh -> Exp (Plain (Any sh)) #
Lift Exp (Exp e) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (Exp e) :: Type # Methods lift :: Exp e -> Exp (Plain (Exp e)) #
(Elt a, Elt b) => Unlift Exp (Exp a, Exp b) #
Instance details Defined in Data.Array.Accelerate.Lift 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) #
Instance details Defined in Data.Array.Accelerate.Lift Methods unlift :: Exp (Plain (ix :. Exp e)) -> ix :. Exp e #
(Elt e, Slice ix) => Unlift Exp (Exp ix :. Exp e) #
Instance details Defined in Data.Array.Accelerate.Lift Methods unlift :: Exp (Plain (Exp ix :. Exp e)) -> Exp ix :. Exp e #
(Lift Exp a, Lift Exp b, Elt (Plain a), Elt (Plain b)) => Lift Exp (Either a b) #
Instance details Defined in Data.Array.Accelerate.Data.Either Associated Types type Plain (Either a b) :: Type # 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) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (a, b) :: Type # Methods lift :: (a, b) -> Exp (Plain (a, b)) #
(Elt e, Slice (Plain ix), Lift Exp ix) => Lift Exp (ix :. Exp e) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (ix :. Exp e) :: Type # Methods lift :: (ix :. Exp e) -> Exp (Plain (ix :. Exp e)) #
(Slice (Plain ix), Lift Exp ix) => Lift Exp (ix :. All) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (ix :. All) :: Type # Methods lift :: (ix :. All) -> Exp (Plain (ix :. All)) #
(Slice (Plain ix), Lift Exp ix) => Lift Exp (ix :. Int) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (ix :. Int) :: Type # Methods lift :: (ix :. Int) -> Exp (Plain (ix :. Int)) #
(Elt a, Elt b, Elt c) => Unlift Exp (Exp a, Exp b, Exp c) #
Instance details Defined in Data.Array.Accelerate.Lift 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) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (a, b, c) :: Type # 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) #
Instance details Defined in Data.Array.Accelerate.Lift 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) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (a, b, c, d) :: Type # 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) #
Instance details Defined in Data.Array.Accelerate.Lift 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) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (a, b, c, d, e) :: Type # 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) #
Instance details Defined in Data.Array.Accelerate.Lift 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) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (a, b, c, d, e, f) :: Type # 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) #
Instance details Defined in Data.Array.Accelerate.Lift 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) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (a, b, c, d, e, f, g) :: Type # 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) #
Instance details Defined in Data.Array.Accelerate.Lift 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) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (a, b, c, d, e, f, g, h) :: Type # 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) #
Instance details Defined in Data.Array.Accelerate.Lift 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) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (a, b, c, d, e, f, g, h, i) :: Type # 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) #
Instance details Defined in Data.Array.Accelerate.Lift 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) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (a, b, c, d, e, f, g, h, i, j) :: Type # 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) #
Instance details Defined in Data.Array.Accelerate.Lift 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) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (a, b, c, d, e, f, g, h, i, j, k) :: Type # 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) #
Instance details Defined in Data.Array.Accelerate.Lift 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) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (a, b, c, d, e, f, g, h, i, j, k, l) :: Type # 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) #
Instance details Defined in Data.Array.Accelerate.Lift 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) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (a, b, c, d, e, f, g, h, i, j, k, l, m) :: Type # 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) #
Instance details Defined in Data.Array.Accelerate.Lift 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) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (a, b, c, d, e, f, g, h, i, j, k, l, m, n) :: Type # 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) #
Instance details Defined in Data.Array.Accelerate.Lift 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) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) :: Type # 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) #
Instance details Defined in Data.Array.Accelerate.Classes.Bounded Methods minBound :: Exp Bool # maxBound :: Exp Bool #
Bounded (Exp Char) #
Instance details Defined in Data.Array.Accelerate.Classes.Bounded Methods minBound :: Exp Char # maxBound :: Exp Char #
Bounded (Exp Int) #
Instance details Defined in Data.Array.Accelerate.Classes.Bounded Methods minBound :: Exp Int # maxBound :: Exp Int #
Bounded (Exp Int8) #
Instance details Defined in Data.Array.Accelerate.Classes.Bounded Methods minBound :: Exp Int8 # maxBound :: Exp Int8 #
Bounded (Exp Int16) #
Instance details Defined in Data.Array.Accelerate.Classes.Bounded Methods minBound :: Exp Int16 # maxBound :: Exp Int16 #
Bounded (Exp Int32) #
Instance details Defined in Data.Array.Accelerate.Classes.Bounded Methods minBound :: Exp Int32 # maxBound :: Exp Int32 #
Bounded (Exp Int64) #
Instance details Defined in Data.Array.Accelerate.Classes.Bounded Methods minBound :: Exp Int64 # maxBound :: Exp Int64 #
Bounded (Exp Word) #
Instance details Defined in Data.Array.Accelerate.Classes.Bounded Methods minBound :: Exp Word # maxBound :: Exp Word #
Bounded (Exp Word8) #
Instance details Defined in Data.Array.Accelerate.Classes.Bounded Methods minBound :: Exp Word8 # maxBound :: Exp Word8 #
Bounded (Exp Word16) #
Instance details Defined in Data.Array.Accelerate.Classes.Bounded Methods minBound :: Exp Word16 # maxBound :: Exp Word16 #
Bounded (Exp Word32) #
Instance details Defined in Data.Array.Accelerate.Classes.Bounded Methods minBound :: Exp Word32 # maxBound :: Exp Word32 #
Bounded (Exp Word64) #
Instance details Defined in Data.Array.Accelerate.Classes.Bounded Methods minBound :: Exp Word64 # maxBound :: Exp Word64 #
Bounded (Exp ()) #
Instance details Defined in Data.Array.Accelerate.Classes.Bounded Methods minBound :: Exp () # maxBound :: Exp () #
(Bounded a, Bounded b) => Bounded (Exp (a, b)) #
Instance details Defined in Data.Array.Accelerate.Classes.Bounded Methods minBound :: Exp (a, b) # maxBound :: Exp (a, b) #
(Bounded a, Bounded b, Bounded c) => Bounded (Exp (a, b, c)) #
Instance details Defined in Data.Array.Accelerate.Classes.Bounded 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)) #
Instance details Defined in Data.Array.Accelerate.Classes.Bounded 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)) #
Instance details Defined in Data.Array.Accelerate.Classes.Bounded 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)) #
Instance details Defined in Data.Array.Accelerate.Classes.Bounded 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)) #
Instance details Defined in Data.Array.Accelerate.Classes.Bounded 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)) #
Instance details Defined in Data.Array.Accelerate.Classes.Bounded 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)) #
Instance details Defined in Data.Array.Accelerate.Classes.Bounded 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)) #
Instance details Defined in Data.Array.Accelerate.Classes.Bounded 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)) #
Instance details Defined in Data.Array.Accelerate.Classes.Bounded 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)) #
Instance details Defined in Data.Array.Accelerate.Classes.Bounded 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)) #
Instance details Defined in Data.Array.Accelerate.Classes.Bounded 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)) #
Instance details Defined in Data.Array.Accelerate.Classes.Bounded 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)) #
Instance details Defined in Data.Array.Accelerate.Classes.Bounded 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)) #
Instance details Defined in Data.Array.Accelerate.Classes.Bounded 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)) #
Instance details Defined in Data.Array.Accelerate.Data.Semigroup Methods minBound :: Exp (Min a) # maxBound :: Exp (Min a) #
Bounded a => Bounded (Exp (Max a)) #
Instance details Defined in Data.Array.Accelerate.Data.Semigroup Methods minBound :: Exp (Max a) # maxBound :: Exp (Max a) #
Bounded a => Bounded (Exp (Sum a)) #
Instance details Defined in Data.Array.Accelerate.Data.Monoid Methods minBound :: Exp (Sum a) # maxBound :: Exp (Sum a) #
Bounded a => Bounded (Exp (Product a)) #
Instance details Defined in Data.Array.Accelerate.Data.Monoid Methods minBound :: Exp (Product a) # maxBound :: Exp (Product a) #
Bounded (Exp CChar) #
Instance details Defined in Data.Array.Accelerate.Classes.Bounded Methods minBound :: Exp CChar # maxBound :: Exp CChar #
Bounded (Exp CSChar) #
Instance details Defined in Data.Array.Accelerate.Classes.Bounded Methods minBound :: Exp CSChar # maxBound :: Exp CSChar #
Bounded (Exp CUChar) #
Instance details Defined in Data.Array.Accelerate.Classes.Bounded Methods minBound :: Exp CUChar # maxBound :: Exp CUChar #
Bounded (Exp CShort) #
Instance details Defined in Data.Array.Accelerate.Classes.Bounded Methods minBound :: Exp CShort # maxBound :: Exp CShort #
Bounded (Exp CUShort) #
Instance details Defined in Data.Array.Accelerate.Classes.Bounded Methods minBound :: Exp CUShort # maxBound :: Exp CUShort #
Bounded (Exp CInt) #
Instance details Defined in Data.Array.Accelerate.Classes.Bounded Methods minBound :: Exp CInt # maxBound :: Exp CInt #
Bounded (Exp CUInt) #
Instance details Defined in Data.Array.Accelerate.Classes.Bounded Methods minBound :: Exp CUInt # maxBound :: Exp CUInt #
Bounded (Exp CLong) #
Instance details Defined in Data.Array.Accelerate.Classes.Bounded Methods minBound :: Exp CLong # maxBound :: Exp CLong #
Bounded (Exp CULong) #
Instance details Defined in Data.Array.Accelerate.Classes.Bounded Methods minBound :: Exp CULong # maxBound :: Exp CULong #
Bounded (Exp CLLong) #
Instance details Defined in Data.Array.Accelerate.Classes.Bounded Methods minBound :: Exp CLLong # maxBound :: Exp CLLong #
Bounded (Exp CULLong) #
Instance details Defined in Data.Array.Accelerate.Classes.Bounded Methods minBound :: Exp CULLong # maxBound :: Exp CULLong #
Enum (Exp Double) #
Instance details Defined in Data.Array.Accelerate.Classes.Enum Methods succ :: Exp Double -> Exp Double # pred :: Exp Double -> Exp Double # toEnum :: Int -> Exp Double # fromEnum :: Exp Double -> Int # enumFrom :: Exp Double -> [Exp Double] # enumFromThen :: Exp Double -> Exp Double -> [Exp Double] # enumFromTo :: Exp Double -> Exp Double -> [Exp Double] # enumFromThenTo :: Exp Double -> Exp Double -> Exp Double -> [Exp Double] #
Enum (Exp Float) #
Instance details Defined in Data.Array.Accelerate.Classes.Enum Methods succ :: Exp Float -> Exp Float # pred :: Exp Float -> Exp Float # toEnum :: Int -> Exp Float # fromEnum :: Exp Float -> Int # enumFrom :: Exp Float -> [Exp Float] # enumFromThen :: Exp Float -> Exp Float -> [Exp Float] # enumFromTo :: Exp Float -> Exp Float -> [Exp Float] # enumFromThenTo :: Exp Float -> Exp Float -> Exp Float -> [Exp Float] #
Enum (Exp Int) #
Instance details Defined in Data.Array.Accelerate.Classes.Enum Methods succ :: Exp Int -> Exp Int # pred :: Exp Int -> Exp Int # toEnum :: Int -> Exp Int # fromEnum :: Exp Int -> Int # enumFrom :: Exp Int -> [Exp Int] # enumFromThen :: Exp Int -> Exp Int -> [Exp Int] # enumFromTo :: Exp Int -> Exp Int -> [Exp Int] # enumFromThenTo :: Exp Int -> Exp Int -> Exp Int -> [Exp Int] #
Enum (Exp Int8) #
Instance details Defined in Data.Array.Accelerate.Classes.Enum Methods succ :: Exp Int8 -> Exp Int8 # pred :: Exp Int8 -> Exp Int8 # toEnum :: Int -> Exp Int8 # fromEnum :: Exp Int8 -> Int # enumFrom :: Exp Int8 -> [Exp Int8] # enumFromThen :: Exp Int8 -> Exp Int8 -> [Exp Int8] # enumFromTo :: Exp Int8 -> Exp Int8 -> [Exp Int8] # enumFromThenTo :: Exp Int8 -> Exp Int8 -> Exp Int8 -> [Exp Int8] #
Enum (Exp Int16) #
Instance details Defined in Data.Array.Accelerate.Classes.Enum Methods succ :: Exp Int16 -> Exp Int16 # pred :: Exp Int16 -> Exp Int16 # toEnum :: Int -> Exp Int16 # fromEnum :: Exp Int16 -> Int # enumFrom :: Exp Int16 -> [Exp Int16] # enumFromThen :: Exp Int16 -> Exp Int16 -> [Exp Int16] # enumFromTo :: Exp Int16 -> Exp Int16 -> [Exp Int16] # enumFromThenTo :: Exp Int16 -> Exp Int16 -> Exp Int16 -> [Exp Int16] #
Enum (Exp Int32) #
Instance details Defined in Data.Array.Accelerate.Classes.Enum Methods succ :: Exp Int32 -> Exp Int32 # pred :: Exp Int32 -> Exp Int32 # toEnum :: Int -> Exp Int32 # fromEnum :: Exp Int32 -> Int # enumFrom :: Exp Int32 -> [Exp Int32] # enumFromThen :: Exp Int32 -> Exp Int32 -> [Exp Int32] # enumFromTo :: Exp Int32 -> Exp Int32 -> [Exp Int32] # enumFromThenTo :: Exp Int32 -> Exp Int32 -> Exp Int32 -> [Exp Int32] #
Enum (Exp Int64) #
Instance details Defined in Data.Array.Accelerate.Classes.Enum Methods succ :: Exp Int64 -> Exp Int64 # pred :: Exp Int64 -> Exp Int64 # toEnum :: Int -> Exp Int64 # fromEnum :: Exp Int64 -> Int # enumFrom :: Exp Int64 -> [Exp Int64] # enumFromThen :: Exp Int64 -> Exp Int64 -> [Exp Int64] # enumFromTo :: Exp Int64 -> Exp Int64 -> [Exp Int64] # enumFromThenTo :: Exp Int64 -> Exp Int64 -> Exp Int64 -> [Exp Int64] #
Enum (Exp Word) #
Instance details Defined in Data.Array.Accelerate.Classes.Enum Methods succ :: Exp Word -> Exp Word # pred :: Exp Word -> Exp Word # toEnum :: Int -> Exp Word # fromEnum :: Exp Word -> Int # enumFrom :: Exp Word -> [Exp Word] # enumFromThen :: Exp Word -> Exp Word -> [Exp Word] # enumFromTo :: Exp Word -> Exp Word -> [Exp Word] # enumFromThenTo :: Exp Word -> Exp Word -> Exp Word -> [Exp Word] #
Enum (Exp Word8) #
Instance details Defined in Data.Array.Accelerate.Classes.Enum Methods succ :: Exp Word8 -> Exp Word8 # pred :: Exp Word8 -> Exp Word8 # toEnum :: Int -> Exp Word8 # fromEnum :: Exp Word8 -> Int # enumFrom :: Exp Word8 -> [Exp Word8] # enumFromThen :: Exp Word8 -> Exp Word8 -> [Exp Word8] # enumFromTo :: Exp Word8 -> Exp Word8 -> [Exp Word8] # enumFromThenTo :: Exp Word8 -> Exp Word8 -> Exp Word8 -> [Exp Word8] #
Enum (Exp Word16) #
Instance details Defined in Data.Array.Accelerate.Classes.Enum Methods succ :: Exp Word16 -> Exp Word16 # pred :: Exp Word16 -> Exp Word16 # toEnum :: Int -> Exp Word16 # fromEnum :: Exp Word16 -> Int # enumFrom :: Exp Word16 -> [Exp Word16] # enumFromThen :: Exp Word16 -> Exp Word16 -> [Exp Word16] # enumFromTo :: Exp Word16 -> Exp Word16 -> [Exp Word16] # enumFromThenTo :: Exp Word16 -> Exp Word16 -> Exp Word16 -> [Exp Word16] #
Enum (Exp Word32) #
Instance details Defined in Data.Array.Accelerate.Classes.Enum Methods succ :: Exp Word32 -> Exp Word32 # pred :: Exp Word32 -> Exp Word32 # toEnum :: Int -> Exp Word32 # fromEnum :: Exp Word32 -> Int # enumFrom :: Exp Word32 -> [Exp Word32] # enumFromThen :: Exp Word32 -> Exp Word32 -> [Exp Word32] # enumFromTo :: Exp Word32 -> Exp Word32 -> [Exp Word32] # enumFromThenTo :: Exp Word32 -> Exp Word32 -> Exp Word32 -> [Exp Word32] #
Enum (Exp Word64) #
Instance details Defined in Data.Array.Accelerate.Classes.Enum Methods succ :: Exp Word64 -> Exp Word64 # pred :: Exp Word64 -> Exp Word64 # toEnum :: Int -> Exp Word64 # fromEnum :: Exp Word64 -> Int # enumFrom :: Exp Word64 -> [Exp Word64] # enumFromThen :: Exp Word64 -> Exp Word64 -> [Exp Word64] # enumFromTo :: Exp Word64 -> Exp Word64 -> [Exp Word64] # enumFromThenTo :: Exp Word64 -> Exp Word64 -> Exp Word64 -> [Exp Word64] #
Enum (Exp CShort) #
Instance details Defined in Data.Array.Accelerate.Classes.Enum Methods succ :: Exp CShort -> Exp CShort # pred :: Exp CShort -> Exp CShort # toEnum :: Int -> Exp CShort # fromEnum :: Exp CShort -> Int # enumFrom :: Exp CShort -> [Exp CShort] # enumFromThen :: Exp CShort -> Exp CShort -> [Exp CShort] # enumFromTo :: Exp CShort -> Exp CShort -> [Exp CShort] # enumFromThenTo :: Exp CShort -> Exp CShort -> Exp CShort -> [Exp CShort] #
Enum (Exp CUShort) #
Instance details Defined in Data.Array.Accelerate.Classes.Enum Methods succ :: Exp CUShort -> Exp CUShort # pred :: Exp CUShort -> Exp CUShort # toEnum :: Int -> Exp CUShort # fromEnum :: Exp CUShort -> Int # enumFrom :: Exp CUShort -> [Exp CUShort] # enumFromThen :: Exp CUShort -> Exp CUShort -> [Exp CUShort] # enumFromTo :: Exp CUShort -> Exp CUShort -> [Exp CUShort] # enumFromThenTo :: Exp CUShort -> Exp CUShort -> Exp CUShort -> [Exp CUShort] #
Enum (Exp CInt) #
Instance details Defined in Data.Array.Accelerate.Classes.Enum Methods succ :: Exp CInt -> Exp CInt # pred :: Exp CInt -> Exp CInt # toEnum :: Int -> Exp CInt # fromEnum :: Exp CInt -> Int # enumFrom :: Exp CInt -> [Exp CInt] # enumFromThen :: Exp CInt -> Exp CInt -> [Exp CInt] # enumFromTo :: Exp CInt -> Exp CInt -> [Exp CInt] # enumFromThenTo :: Exp CInt -> Exp CInt -> Exp CInt -> [Exp CInt] #
Enum (Exp CUInt) #
Instance details Defined in Data.Array.Accelerate.Classes.Enum Methods succ :: Exp CUInt -> Exp CUInt # pred :: Exp CUInt -> Exp CUInt # toEnum :: Int -> Exp CUInt # fromEnum :: Exp CUInt -> Int # enumFrom :: Exp CUInt -> [Exp CUInt] # enumFromThen :: Exp CUInt -> Exp CUInt -> [Exp CUInt] # enumFromTo :: Exp CUInt -> Exp CUInt -> [Exp CUInt] # enumFromThenTo :: Exp CUInt -> Exp CUInt -> Exp CUInt -> [Exp CUInt] #
Enum (Exp CLong) #
Instance details Defined in Data.Array.Accelerate.Classes.Enum Methods succ :: Exp CLong -> Exp CLong # pred :: Exp CLong -> Exp CLong # toEnum :: Int -> Exp CLong # fromEnum :: Exp CLong -> Int # enumFrom :: Exp CLong -> [Exp CLong] # enumFromThen :: Exp CLong -> Exp CLong -> [Exp CLong] # enumFromTo :: Exp CLong -> Exp CLong -> [Exp CLong] # enumFromThenTo :: Exp CLong -> Exp CLong -> Exp CLong -> [Exp CLong] #
Enum (Exp CULong) #
Instance details Defined in Data.Array.Accelerate.Classes.Enum Methods succ :: Exp CULong -> Exp CULong # pred :: Exp CULong -> Exp CULong # toEnum :: Int -> Exp CULong # fromEnum :: Exp CULong -> Int # enumFrom :: Exp CULong -> [Exp CULong] # enumFromThen :: Exp CULong -> Exp CULong -> [Exp CULong] # enumFromTo :: Exp CULong -> Exp CULong -> [Exp CULong] # enumFromThenTo :: Exp CULong -> Exp CULong -> Exp CULong -> [Exp CULong] #
Enum (Exp CLLong) #
Instance details Defined in Data.Array.Accelerate.Classes.Enum Methods succ :: Exp CLLong -> Exp CLLong # pred :: Exp CLLong -> Exp CLLong # toEnum :: Int -> Exp CLLong # fromEnum :: Exp CLLong -> Int # enumFrom :: Exp CLLong -> [Exp CLLong] # enumFromThen :: Exp CLLong -> Exp CLLong -> [Exp CLLong] # enumFromTo :: Exp CLLong -> Exp CLLong -> [Exp CLLong] # enumFromThenTo :: Exp CLLong -> Exp CLLong -> Exp CLLong -> [Exp CLLong] #
Enum (Exp CULLong) #
Instance details Defined in Data.Array.Accelerate.Classes.Enum Methods succ :: Exp CULLong -> Exp CULLong # pred :: Exp CULLong -> Exp CULLong # toEnum :: Int -> Exp CULLong # fromEnum :: Exp CULLong -> Int # enumFrom :: Exp CULLong -> [Exp CULLong] # enumFromThen :: Exp CULLong -> Exp CULLong -> [Exp CULLong] # enumFromTo :: Exp CULLong -> Exp CULLong -> [Exp CULLong] # enumFromThenTo :: Exp CULLong -> Exp CULLong -> Exp CULLong -> [Exp CULLong] #
Enum (Exp CFloat) #
Instance details Defined in Data.Array.Accelerate.Classes.Enum Methods succ :: Exp CFloat -> Exp CFloat # pred :: Exp CFloat -> Exp CFloat # toEnum :: Int -> Exp CFloat # fromEnum :: Exp CFloat -> Int # enumFrom :: Exp CFloat -> [Exp CFloat] # enumFromThen :: Exp CFloat -> Exp CFloat -> [Exp CFloat] # enumFromTo :: Exp CFloat -> Exp CFloat -> [Exp CFloat] # enumFromThenTo :: Exp CFloat -> Exp CFloat -> Exp CFloat -> [Exp CFloat] #
Enum (Exp CDouble) #
Instance details Defined in Data.Array.Accelerate.Classes.Enum Methods succ :: Exp CDouble -> Exp CDouble # pred :: Exp CDouble -> Exp CDouble # toEnum :: Int -> Exp CDouble # fromEnum :: Exp CDouble -> Int # enumFrom :: Exp CDouble -> [Exp CDouble] # enumFromThen :: Exp CDouble -> Exp CDouble -> [Exp CDouble] # enumFromTo :: Exp CDouble -> Exp CDouble -> [Exp CDouble] # enumFromThenTo :: Exp CDouble -> Exp CDouble -> Exp CDouble -> [Exp CDouble] #
Enum (Exp Half) #
Instance details Defined in Data.Array.Accelerate.Classes.Enum Methods succ :: Exp Half -> Exp Half # pred :: Exp Half -> Exp Half # toEnum :: Int -> Exp Half # fromEnum :: Exp Half -> Int # enumFrom :: Exp Half -> [Exp Half] # enumFromThen :: Exp Half -> Exp Half -> [Exp Half] # enumFromTo :: Exp Half -> Exp Half -> [Exp Half] # enumFromThenTo :: Exp Half -> Exp Half -> Exp Half -> [Exp Half] #
Eq a => Eq (Exp a) #
Instance details Defined in Data.Array.Accelerate.Classes.Eq Methods (==) :: Exp a -> Exp a -> Bool # (/=) :: Exp a -> Exp a -> Bool #
Floating (Exp Double) #
Instance details Defined in Data.Array.Accelerate.Classes.Floating Methods pi :: Exp Double # exp :: Exp Double -> Exp Double # log :: Exp Double -> Exp Double # sqrt :: Exp Double -> Exp Double # (**) :: Exp Double -> Exp Double -> Exp Double # logBase :: Exp Double -> Exp Double -> Exp Double # sin :: Exp Double -> Exp Double # cos :: Exp Double -> Exp Double # tan :: Exp Double -> Exp Double # asin :: Exp Double -> Exp Double # acos :: Exp Double -> Exp Double # atan :: Exp Double -> Exp Double # sinh :: Exp Double -> Exp Double # cosh :: Exp Double -> Exp Double # tanh :: Exp Double -> Exp Double # asinh :: Exp Double -> Exp Double # acosh :: Exp Double -> Exp Double # atanh :: Exp Double -> Exp Double # log1p :: Exp Double -> Exp Double # expm1 :: Exp Double -> Exp Double # log1pexp :: Exp Double -> Exp Double # log1mexp :: Exp Double -> Exp Double #
Floating (Exp Float) #
Instance details Defined in Data.Array.Accelerate.Classes.Floating Methods pi :: Exp Float # exp :: Exp Float -> Exp Float # log :: Exp Float -> Exp Float # sqrt :: Exp Float -> Exp Float # (**) :: Exp Float -> Exp Float -> Exp Float # logBase :: Exp Float -> Exp Float -> Exp Float # sin :: Exp Float -> Exp Float # cos :: Exp Float -> Exp Float # tan :: Exp Float -> Exp Float # asin :: Exp Float -> Exp Float # acos :: Exp Float -> Exp Float # atan :: Exp Float -> Exp Float # sinh :: Exp Float -> Exp Float # cosh :: Exp Float -> Exp Float # tanh :: Exp Float -> Exp Float # asinh :: Exp Float -> Exp Float # acosh :: Exp Float -> Exp Float # atanh :: Exp Float -> Exp Float # log1p :: Exp Float -> Exp Float # expm1 :: Exp Float -> Exp Float # log1pexp :: Exp Float -> Exp Float # log1mexp :: Exp Float -> Exp Float #
(RealFloat a, Elt (Complex a)) => Floating (Exp (Complex a)) #
Instance details Defined in Data.Array.Accelerate.Data.Complex Methods pi :: Exp (Complex a) # exp :: Exp (Complex a) -> Exp (Complex a) # log :: Exp (Complex a) -> Exp (Complex a) # sqrt :: Exp (Complex a) -> Exp (Complex a) # (**) :: Exp (Complex a) -> Exp (Complex a) -> Exp (Complex a) # logBase :: Exp (Complex a) -> Exp (Complex a) -> Exp (Complex a) # sin :: Exp (Complex a) -> Exp (Complex a) # cos :: Exp (Complex a) -> Exp (Complex a) # tan :: Exp (Complex a) -> Exp (Complex a) # asin :: Exp (Complex a) -> Exp (Complex a) # acos :: Exp (Complex a) -> Exp (Complex a) # atan :: Exp (Complex a) -> Exp (Complex a) # sinh :: Exp (Complex a) -> Exp (Complex a) # cosh :: Exp (Complex a) -> Exp (Complex a) # tanh :: Exp (Complex a) -> Exp (Complex a) # asinh :: Exp (Complex a) -> Exp (Complex a) # acosh :: Exp (Complex a) -> Exp (Complex a) # atanh :: Exp (Complex a) -> Exp (Complex a) # log1p :: Exp (Complex a) -> Exp (Complex a) # expm1 :: Exp (Complex a) -> Exp (Complex a) # log1pexp :: Exp (Complex a) -> Exp (Complex a) # log1mexp :: Exp (Complex a) -> Exp (Complex a) #
Floating (Exp CFloat) #
Instance details Defined in Data.Array.Accelerate.Classes.Floating Methods pi :: Exp CFloat # exp :: Exp CFloat -> Exp CFloat # log :: Exp CFloat -> Exp CFloat # sqrt :: Exp CFloat -> Exp CFloat # (**) :: Exp CFloat -> Exp CFloat -> Exp CFloat # logBase :: Exp CFloat -> Exp CFloat -> Exp CFloat # sin :: Exp CFloat -> Exp CFloat # cos :: Exp CFloat -> Exp CFloat # tan :: Exp CFloat -> Exp CFloat # asin :: Exp CFloat -> Exp CFloat # acos :: Exp CFloat -> Exp CFloat # atan :: Exp CFloat -> Exp CFloat # sinh :: Exp CFloat -> Exp CFloat # cosh :: Exp CFloat -> Exp CFloat # tanh :: Exp CFloat -> Exp CFloat # asinh :: Exp CFloat -> Exp CFloat # acosh :: Exp CFloat -> Exp CFloat # atanh :: Exp CFloat -> Exp CFloat # log1p :: Exp CFloat -> Exp CFloat # expm1 :: Exp CFloat -> Exp CFloat # log1pexp :: Exp CFloat -> Exp CFloat # log1mexp :: Exp CFloat -> Exp CFloat #
Floating (Exp CDouble) #
Instance details Defined in Data.Array.Accelerate.Classes.Floating Methods pi :: Exp CDouble # exp :: Exp CDouble -> Exp CDouble # log :: Exp CDouble -> Exp CDouble # sqrt :: Exp CDouble -> Exp CDouble # (**) :: Exp CDouble -> Exp CDouble -> Exp CDouble # logBase :: Exp CDouble -> Exp CDouble -> Exp CDouble # sin :: Exp CDouble -> Exp CDouble # cos :: Exp CDouble -> Exp CDouble # tan :: Exp CDouble -> Exp CDouble # asin :: Exp CDouble -> Exp CDouble # acos :: Exp CDouble -> Exp CDouble # atan :: Exp CDouble -> Exp CDouble # sinh :: Exp CDouble -> Exp CDouble # cosh :: Exp CDouble -> Exp CDouble # tanh :: Exp CDouble -> Exp CDouble # asinh :: Exp CDouble -> Exp CDouble # acosh :: Exp CDouble -> Exp CDouble # atanh :: Exp CDouble -> Exp CDouble # log1p :: Exp CDouble -> Exp CDouble # expm1 :: Exp CDouble -> Exp CDouble # log1pexp :: Exp CDouble -> Exp CDouble # log1mexp :: Exp CDouble -> Exp CDouble #
Floating (Exp Half) #
Instance details Defined in Data.Array.Accelerate.Classes.Floating Methods pi :: Exp Half # exp :: Exp Half -> Exp Half # log :: Exp Half -> Exp Half # sqrt :: Exp Half -> Exp Half # (**) :: Exp Half -> Exp Half -> Exp Half # logBase :: Exp Half -> Exp Half -> Exp Half # sin :: Exp Half -> Exp Half # cos :: Exp Half -> Exp Half # tan :: Exp Half -> Exp Half # asin :: Exp Half -> Exp Half # acos :: Exp Half -> Exp Half # atan :: Exp Half -> Exp Half # sinh :: Exp Half -> Exp Half # cosh :: Exp Half -> Exp Half # tanh :: Exp Half -> Exp Half # asinh :: Exp Half -> Exp Half # acosh :: Exp Half -> Exp Half # atanh :: Exp Half -> Exp Half # log1p :: Exp Half -> Exp Half # expm1 :: Exp Half -> Exp Half # log1pexp :: Exp Half -> Exp Half # log1mexp :: Exp Half -> Exp Half #
Fractional (Exp Double) #
Instance details Defined in Data.Array.Accelerate.Classes.Fractional Methods (/) :: Exp Double -> Exp Double -> Exp Double # recip :: Exp Double -> Exp Double # fromRational :: Rational -> Exp Double #
Fractional (Exp Float) #
Instance details Defined in Data.Array.Accelerate.Classes.Fractional 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)) #
Instance details Defined in Data.Array.Accelerate.Data.Complex Methods (/) :: Exp (Complex a) -> Exp (Complex a) -> Exp (Complex a) # recip :: Exp (Complex a) -> Exp (Complex a) # fromRational :: Rational -> Exp (Complex a) #
Fractional (Exp CFloat) #
Instance details Defined in Data.Array.Accelerate.Classes.Fractional Methods (/) :: Exp CFloat -> Exp CFloat -> Exp CFloat # recip :: Exp CFloat -> Exp CFloat # fromRational :: Rational -> Exp CFloat #
Fractional (Exp CDouble) #
Instance details Defined in Data.Array.Accelerate.Classes.Fractional Methods (/) :: Exp CDouble -> Exp CDouble -> Exp CDouble # recip :: Exp CDouble -> Exp CDouble # fromRational :: Rational -> Exp CDouble #
Fractional (Exp Half) #
Instance details Defined in Data.Array.Accelerate.Classes.Fractional Methods (/) :: Exp Half -> Exp Half -> Exp Half # recip :: Exp Half -> Exp Half # fromRational :: Rational -> Exp Half #
Integral (Exp Int) #
Instance details Defined in Data.Array.Accelerate.Classes.Integral Methods quot :: Exp Int -> Exp Int -> Exp Int # rem :: Exp Int -> Exp Int -> Exp Int # div :: Exp Int -> Exp Int -> Exp Int # mod :: Exp Int -> Exp Int -> Exp Int # quotRem :: Exp Int -> Exp Int -> (Exp Int, Exp Int) # divMod :: Exp Int -> Exp Int -> (Exp Int, Exp Int) # toInteger :: Exp Int -> Integer #
Integral (Exp Int8) #
Instance details Defined in Data.Array.Accelerate.Classes.Integral Methods quot :: Exp Int8 -> Exp Int8 -> Exp Int8 # rem :: Exp Int8 -> Exp Int8 -> Exp Int8 # div :: Exp Int8 -> Exp Int8 -> Exp Int8 # mod :: Exp Int8 -> Exp Int8 -> Exp Int8 # quotRem :: Exp Int8 -> Exp Int8 -> (Exp Int8, Exp Int8) # divMod :: Exp Int8 -> Exp Int8 -> (Exp Int8, Exp Int8) # toInteger :: Exp Int8 -> Integer #
Integral (Exp Int16) #
Instance details Defined in Data.Array.Accelerate.Classes.Integral Methods quot :: Exp Int16 -> Exp Int16 -> Exp Int16 # rem :: Exp Int16 -> Exp Int16 -> Exp Int16 # div :: Exp Int16 -> Exp Int16 -> Exp Int16 # mod :: Exp Int16 -> Exp Int16 -> Exp Int16 # quotRem :: Exp Int16 -> Exp Int16 -> (Exp Int16, Exp Int16) # divMod :: Exp Int16 -> Exp Int16 -> (Exp Int16, Exp Int16) # toInteger :: Exp Int16 -> Integer #
Integral (Exp Int32) #
Instance details Defined in Data.Array.Accelerate.Classes.Integral Methods quot :: Exp Int32 -> Exp Int32 -> Exp Int32 # rem :: Exp Int32 -> Exp Int32 -> Exp Int32 # div :: Exp Int32 -> Exp Int32 -> Exp Int32 # mod :: Exp Int32 -> Exp Int32 -> Exp Int32 # quotRem :: Exp Int32 -> Exp Int32 -> (Exp Int32, Exp Int32) # divMod :: Exp Int32 -> Exp Int32 -> (Exp Int32, Exp Int32) # toInteger :: Exp Int32 -> Integer #
Integral (Exp Int64) #
Instance details Defined in Data.Array.Accelerate.Classes.Integral Methods quot :: Exp Int64 -> Exp Int64 -> Exp Int64 # rem :: Exp Int64 -> Exp Int64 -> Exp Int64 # div :: Exp Int64 -> Exp Int64 -> Exp Int64 # mod :: Exp Int64 -> Exp Int64 -> Exp Int64 # quotRem :: Exp Int64 -> Exp Int64 -> (Exp Int64, Exp Int64) # divMod :: Exp Int64 -> Exp Int64 -> (Exp Int64, Exp Int64) # toInteger :: Exp Int64 -> Integer #
Integral (Exp Word) #
Instance details Defined in Data.Array.Accelerate.Classes.Integral Methods quot :: Exp Word -> Exp Word -> Exp Word # rem :: Exp Word -> Exp Word -> Exp Word # div :: Exp Word -> Exp Word -> Exp Word # mod :: Exp Word -> Exp Word -> Exp Word # quotRem :: Exp Word -> Exp Word -> (Exp Word, Exp Word) # divMod :: Exp Word -> Exp Word -> (Exp Word, Exp Word) # toInteger :: Exp Word -> Integer #
Integral (Exp Word8) #
Instance details Defined in Data.Array.Accelerate.Classes.Integral Methods quot :: Exp Word8 -> Exp Word8 -> Exp Word8 # rem :: Exp Word8 -> Exp Word8 -> Exp Word8 # div :: Exp Word8 -> Exp Word8 -> Exp Word8 # mod :: Exp Word8 -> Exp Word8 -> Exp Word8 # quotRem :: Exp Word8 -> Exp Word8 -> (Exp Word8, Exp Word8) # divMod :: Exp Word8 -> Exp Word8 -> (Exp Word8, Exp Word8) # toInteger :: Exp Word8 -> Integer #
Integral (Exp Word16) #
Instance details Defined in Data.Array.Accelerate.Classes.Integral Methods quot :: Exp Word16 -> Exp Word16 -> Exp Word16 # rem :: Exp Word16 -> Exp Word16 -> Exp Word16 # div :: Exp Word16 -> Exp Word16 -> Exp Word16 # mod :: Exp Word16 -> Exp Word16 -> Exp Word16 # quotRem :: Exp Word16 -> Exp Word16 -> (Exp Word16, Exp Word16) # divMod :: Exp Word16 -> Exp Word16 -> (Exp Word16, Exp Word16) # toInteger :: Exp Word16 -> Integer #
Integral (Exp Word32) #
Instance details Defined in Data.Array.Accelerate.Classes.Integral Methods quot :: Exp Word32 -> Exp Word32 -> Exp Word32 # rem :: Exp Word32 -> Exp Word32 -> Exp Word32 # div :: Exp Word32 -> Exp Word32 -> Exp Word32 # mod :: Exp Word32 -> Exp Word32 -> Exp Word32 # quotRem :: Exp Word32 -> Exp Word32 -> (Exp Word32, Exp Word32) # divMod :: Exp Word32 -> Exp Word32 -> (Exp Word32, Exp Word32) # toInteger :: Exp Word32 -> Integer #
Integral (Exp Word64) #
Instance details Defined in Data.Array.Accelerate.Classes.Integral Methods quot :: Exp Word64 -> Exp Word64 -> Exp Word64 # rem :: Exp Word64 -> Exp Word64 -> Exp Word64 # div :: Exp Word64 -> Exp Word64 -> Exp Word64 # mod :: Exp Word64 -> Exp Word64 -> Exp Word64 # quotRem :: Exp Word64 -> Exp Word64 -> (Exp Word64, Exp Word64) # divMod :: Exp Word64 -> Exp Word64 -> (Exp Word64, Exp Word64) # toInteger :: Exp Word64 -> Integer #
Integral (Exp CShort) #
Instance details Defined in Data.Array.Accelerate.Classes.Integral Methods quot :: Exp CShort -> Exp CShort -> Exp CShort # rem :: Exp CShort -> Exp CShort -> Exp CShort # div :: Exp CShort -> Exp CShort -> Exp CShort # mod :: Exp CShort -> Exp CShort -> Exp CShort # quotRem :: Exp CShort -> Exp CShort -> (Exp CShort, Exp CShort) # divMod :: Exp CShort -> Exp CShort -> (Exp CShort, Exp CShort) # toInteger :: Exp CShort -> Integer #
Integral (Exp CUShort) #
Instance details Defined in Data.Array.Accelerate.Classes.Integral Methods quot :: Exp CUShort -> Exp CUShort -> Exp CUShort # rem :: Exp CUShort -> Exp CUShort -> Exp CUShort # div :: Exp CUShort -> Exp CUShort -> Exp CUShort # mod :: Exp CUShort -> Exp CUShort -> Exp CUShort # quotRem :: Exp CUShort -> Exp CUShort -> (Exp CUShort, Exp CUShort) # divMod :: Exp CUShort -> Exp CUShort -> (Exp CUShort, Exp CUShort) # toInteger :: Exp CUShort -> Integer #
Integral (Exp CInt) #
Instance details Defined in Data.Array.Accelerate.Classes.Integral Methods quot :: Exp CInt -> Exp CInt -> Exp CInt # rem :: Exp CInt -> Exp CInt -> Exp CInt # div :: Exp CInt -> Exp CInt -> Exp CInt # mod :: Exp CInt -> Exp CInt -> Exp CInt # quotRem :: Exp CInt -> Exp CInt -> (Exp CInt, Exp CInt) # divMod :: Exp CInt -> Exp CInt -> (Exp CInt, Exp CInt) # toInteger :: Exp CInt -> Integer #
Integral (Exp CUInt) #
Instance details Defined in Data.Array.Accelerate.Classes.Integral Methods quot :: Exp CUInt -> Exp CUInt -> Exp CUInt # rem :: Exp CUInt -> Exp CUInt -> Exp CUInt # div :: Exp CUInt -> Exp CUInt -> Exp CUInt # mod :: Exp CUInt -> Exp CUInt -> Exp CUInt # quotRem :: Exp CUInt -> Exp CUInt -> (Exp CUInt, Exp CUInt) # divMod :: Exp CUInt -> Exp CUInt -> (Exp CUInt, Exp CUInt) # toInteger :: Exp CUInt -> Integer #
Integral (Exp CLong) #
Instance details Defined in Data.Array.Accelerate.Classes.Integral Methods quot :: Exp CLong -> Exp CLong -> Exp CLong # rem :: Exp CLong -> Exp CLong -> Exp CLong # div :: Exp CLong -> Exp CLong -> Exp CLong # mod :: Exp CLong -> Exp CLong -> Exp CLong # quotRem :: Exp CLong -> Exp CLong -> (Exp CLong, Exp CLong) # divMod :: Exp CLong -> Exp CLong -> (Exp CLong, Exp CLong) # toInteger :: Exp CLong -> Integer #
Integral (Exp CULong) #
Instance details Defined in Data.Array.Accelerate.Classes.Integral Methods quot :: Exp CULong -> Exp CULong -> Exp CULong # rem :: Exp CULong -> Exp CULong -> Exp CULong # div :: Exp CULong -> Exp CULong -> Exp CULong # mod :: Exp CULong -> Exp CULong -> Exp CULong # quotRem :: Exp CULong -> Exp CULong -> (Exp CULong, Exp CULong) # divMod :: Exp CULong -> Exp CULong -> (Exp CULong, Exp CULong) # toInteger :: Exp CULong -> Integer #
Integral (Exp CLLong) #
Instance details Defined in Data.Array.Accelerate.Classes.Integral Methods quot :: Exp CLLong -> Exp CLLong -> Exp CLLong # rem :: Exp CLLong -> Exp CLLong -> Exp CLLong # div :: Exp CLLong -> Exp CLLong -> Exp CLLong # mod :: Exp CLLong -> Exp CLLong -> Exp CLLong # quotRem :: Exp CLLong -> Exp CLLong -> (Exp CLLong, Exp CLLong) # divMod :: Exp CLLong -> Exp CLLong -> (Exp CLLong, Exp CLLong) # toInteger :: Exp CLLong -> Integer #
Integral (Exp CULLong) #
Instance details Defined in Data.Array.Accelerate.Classes.Integral Methods quot :: Exp CULLong -> Exp CULLong -> Exp CULLong # rem :: Exp CULLong -> Exp CULLong -> Exp CULLong # div :: Exp CULLong -> Exp CULLong -> Exp CULLong # mod :: Exp CULLong -> Exp CULLong -> Exp CULLong # quotRem :: Exp CULLong -> Exp CULLong -> (Exp CULLong, Exp CULLong) # divMod :: Exp CULLong -> Exp CULLong -> (Exp CULLong, Exp CULLong) # toInteger :: Exp CULLong -> Integer #
Num (Exp Double) #
Instance details Defined in Data.Array.Accelerate.Classes.Num Methods (+) :: Exp Double -> Exp Double -> Exp Double # (-) :: Exp Double -> Exp Double -> Exp Double # (*) :: Exp Double -> Exp Double -> Exp Double # negate :: Exp Double -> Exp Double # abs :: Exp Double -> Exp Double # signum :: Exp Double -> Exp Double # fromInteger :: Integer -> Exp Double #
Num (Exp Float) #
Instance details Defined in Data.Array.Accelerate.Classes.Num Methods (+) :: Exp Float -> Exp Float -> Exp Float # (-) :: Exp Float -> Exp Float -> Exp Float # (*) :: Exp Float -> Exp Float -> Exp Float # negate :: Exp Float -> Exp Float # abs :: Exp Float -> Exp Float # signum :: Exp Float -> Exp Float # fromInteger :: Integer -> Exp Float #
Num (Exp Int) #
Instance details Defined in Data.Array.Accelerate.Classes.Num Methods (+) :: Exp Int -> Exp Int -> Exp Int # (-) :: Exp Int -> Exp Int -> Exp Int # (*) :: Exp Int -> Exp Int -> Exp Int # negate :: Exp Int -> Exp Int # abs :: Exp Int -> Exp Int # signum :: Exp Int -> Exp Int # fromInteger :: Integer -> Exp Int #
Num (Exp Int8) #
Instance details Defined in Data.Array.Accelerate.Classes.Num Methods (+) :: Exp Int8 -> Exp Int8 -> Exp Int8 # (-) :: Exp Int8 -> Exp Int8 -> Exp Int8 # (*) :: Exp Int8 -> Exp Int8 -> Exp Int8 # negate :: Exp Int8 -> Exp Int8 # abs :: Exp Int8 -> Exp Int8 # signum :: Exp Int8 -> Exp Int8 # fromInteger :: Integer -> Exp Int8 #
Num (Exp Int16) #
Instance details Defined in Data.Array.Accelerate.Classes.Num Methods (+) :: Exp Int16 -> Exp Int16 -> Exp Int16 # (-) :: Exp Int16 -> Exp Int16 -> Exp Int16 # (*) :: Exp Int16 -> Exp Int16 -> Exp Int16 # negate :: Exp Int16 -> Exp Int16 # abs :: Exp Int16 -> Exp Int16 # signum :: Exp Int16 -> Exp Int16 # fromInteger :: Integer -> Exp Int16 #
Num (Exp Int32) #
Instance details Defined in Data.Array.Accelerate.Classes.Num Methods (+) :: Exp Int32 -> Exp Int32 -> Exp Int32 # (-) :: Exp Int32 -> Exp Int32 -> Exp Int32 # (*) :: Exp Int32 -> Exp Int32 -> Exp Int32 # negate :: Exp Int32 -> Exp Int32 # abs :: Exp Int32 -> Exp Int32 # signum :: Exp Int32 -> Exp Int32 # fromInteger :: Integer -> Exp Int32 #
Num (Exp Int64) #
Instance details Defined in Data.Array.Accelerate.Classes.Num Methods (+) :: Exp Int64 -> Exp Int64 -> Exp Int64 # (-) :: Exp Int64 -> Exp Int64 -> Exp Int64 # (*) :: Exp Int64 -> Exp Int64 -> Exp Int64 # negate :: Exp Int64 -> Exp Int64 # abs :: Exp Int64 -> Exp Int64 # signum :: Exp Int64 -> Exp Int64 # fromInteger :: Integer -> Exp Int64 #
Num (Exp Word) #
Instance details Defined in Data.Array.Accelerate.Classes.Num Methods (+) :: Exp Word -> Exp Word -> Exp Word # (-) :: Exp Word -> Exp Word -> Exp Word # (*) :: Exp Word -> Exp Word -> Exp Word # negate :: Exp Word -> Exp Word # abs :: Exp Word -> Exp Word # signum :: Exp Word -> Exp Word # fromInteger :: Integer -> Exp Word #
Num (Exp Word8) #
Instance details Defined in Data.Array.Accelerate.Classes.Num Methods (+) :: Exp Word8 -> Exp Word8 -> Exp Word8 # (-) :: Exp Word8 -> Exp Word8 -> Exp Word8 # (*) :: Exp Word8 -> Exp Word8 -> Exp Word8 # negate :: Exp Word8 -> Exp Word8 # abs :: Exp Word8 -> Exp Word8 # signum :: Exp Word8 -> Exp Word8 # fromInteger :: Integer -> Exp Word8 #
Num (Exp Word16) #
Instance details Defined in Data.Array.Accelerate.Classes.Num Methods (+) :: Exp Word16 -> Exp Word16 -> Exp Word16 # (-) :: Exp Word16 -> Exp Word16 -> Exp Word16 # (*) :: Exp Word16 -> Exp Word16 -> Exp Word16 # negate :: Exp Word16 -> Exp Word16 # abs :: Exp Word16 -> Exp Word16 # signum :: Exp Word16 -> Exp Word16 # fromInteger :: Integer -> Exp Word16 #
Num (Exp Word32) #
Instance details Defined in Data.Array.Accelerate.Classes.Num Methods (+) :: Exp Word32 -> Exp Word32 -> Exp Word32 # (-) :: Exp Word32 -> Exp Word32 -> Exp Word32 # (*) :: Exp Word32 -> Exp Word32 -> Exp Word32 # negate :: Exp Word32 -> Exp Word32 # abs :: Exp Word32 -> Exp Word32 # signum :: Exp Word32 -> Exp Word32 # fromInteger :: Integer -> Exp Word32 #
Num (Exp Word64) #
Instance details Defined in Data.Array.Accelerate.Classes.Num Methods (+) :: Exp Word64 -> Exp Word64 -> Exp Word64 # (-) :: Exp Word64 -> Exp Word64 -> Exp Word64 # (*) :: Exp Word64 -> Exp Word64 -> Exp Word64 # negate :: Exp Word64 -> Exp Word64 # abs :: Exp Word64 -> Exp Word64 # signum :: Exp Word64 -> Exp Word64 # fromInteger :: Integer -> Exp Word64 #
(RealFloat a, Elt (Complex a)) => Num (Exp (Complex a)) #
Instance details Defined in Data.Array.Accelerate.Data.Complex Methods (+) :: Exp (Complex a) -> Exp (Complex a) -> Exp (Complex a) # (-) :: Exp (Complex a) -> Exp (Complex a) -> Exp (Complex a) # (*) :: Exp (Complex a) -> Exp (Complex a) -> Exp (Complex a) # negate :: Exp (Complex a) -> Exp (Complex a) # abs :: Exp (Complex a) -> Exp (Complex a) # signum :: Exp (Complex a) -> Exp (Complex a) # fromInteger :: Integer -> Exp (Complex a) #
Num a => Num (Exp (Min a)) #
Instance details Defined in Data.Array.Accelerate.Data.Semigroup Methods (+) :: Exp (Min a) -> Exp (Min a) -> Exp (Min a) # (-) :: Exp (Min a) -> Exp (Min a) -> Exp (Min a) # (*) :: Exp (Min a) -> Exp (Min a) -> Exp (Min a) # negate :: Exp (Min a) -> Exp (Min a) # abs :: Exp (Min a) -> Exp (Min a) # signum :: Exp (Min a) -> Exp (Min a) # fromInteger :: Integer -> Exp (Min a) #
Num a => Num (Exp (Max a)) #
Instance details Defined in Data.Array.Accelerate.Data.Semigroup Methods (+) :: Exp (Max a) -> Exp (Max a) -> Exp (Max a) # (-) :: Exp (Max a) -> Exp (Max a) -> Exp (Max a) # (*) :: Exp (Max a) -> Exp (Max a) -> Exp (Max a) # negate :: Exp (Max a) -> Exp (Max a) # abs :: Exp (Max a) -> Exp (Max a) # signum :: Exp (Max a) -> Exp (Max a) # fromInteger :: Integer -> Exp (Max a) #
Num a => Num (Exp (Sum a)) #
Instance details Defined in Data.Array.Accelerate.Data.Monoid Methods (+) :: Exp (Sum a) -> Exp (Sum a) -> Exp (Sum a) # (-) :: Exp (Sum a) -> Exp (Sum a) -> Exp (Sum a) # (*) :: Exp (Sum a) -> Exp (Sum a) -> Exp (Sum a) # negate :: Exp (Sum a) -> Exp (Sum a) # abs :: Exp (Sum a) -> Exp (Sum a) # signum :: Exp (Sum a) -> Exp (Sum a) # fromInteger :: Integer -> Exp (Sum a) #
Num a => Num (Exp (Product a)) #
Instance details Defined in Data.Array.Accelerate.Data.Monoid Methods (+) :: Exp (Product a) -> Exp (Product a) -> Exp (Product a) # (-) :: Exp (Product a) -> Exp (Product a) -> Exp (Product a) # (*) :: Exp (Product a) -> Exp (Product a) -> Exp (Product a) # negate :: Exp (Product a) -> Exp (Product a) # abs :: Exp (Product a) -> Exp (Product a) # signum :: Exp (Product a) -> Exp (Product a) # fromInteger :: Integer -> Exp (Product a) #
Num (Exp CShort) #
Instance details Defined in Data.Array.Accelerate.Classes.Num Methods (+) :: Exp CShort -> Exp CShort -> Exp CShort # (-) :: Exp CShort -> Exp CShort -> Exp CShort # (*) :: Exp CShort -> Exp CShort -> Exp CShort # negate :: Exp CShort -> Exp CShort # abs :: Exp CShort -> Exp CShort # signum :: Exp CShort -> Exp CShort # fromInteger :: Integer -> Exp CShort #
Num (Exp CUShort) #
Instance details Defined in Data.Array.Accelerate.Classes.Num Methods (+) :: Exp CUShort -> Exp CUShort -> Exp CUShort # (-) :: Exp CUShort -> Exp CUShort -> Exp CUShort # (*) :: Exp CUShort -> Exp CUShort -> Exp CUShort # negate :: Exp CUShort -> Exp CUShort # abs :: Exp CUShort -> Exp CUShort # signum :: Exp CUShort -> Exp CUShort # fromInteger :: Integer -> Exp CUShort #
Num (Exp CInt) #
Instance details Defined in Data.Array.Accelerate.Classes.Num Methods (+) :: Exp CInt -> Exp CInt -> Exp CInt # (-) :: Exp CInt -> Exp CInt -> Exp CInt # (*) :: Exp CInt -> Exp CInt -> Exp CInt # negate :: Exp CInt -> Exp CInt # abs :: Exp CInt -> Exp CInt # signum :: Exp CInt -> Exp CInt # fromInteger :: Integer -> Exp CInt #
Num (Exp CUInt) #
Instance details Defined in Data.Array.Accelerate.Classes.Num Methods (+) :: Exp CUInt -> Exp CUInt -> Exp CUInt # (-) :: Exp CUInt -> Exp CUInt -> Exp CUInt # (*) :: Exp CUInt -> Exp CUInt -> Exp CUInt # negate :: Exp CUInt -> Exp CUInt # abs :: Exp CUInt -> Exp CUInt # signum :: Exp CUInt -> Exp CUInt # fromInteger :: Integer -> Exp CUInt #
Num (Exp CLong) #
Instance details Defined in Data.Array.Accelerate.Classes.Num Methods (+) :: Exp CLong -> Exp CLong -> Exp CLong # (-) :: Exp CLong -> Exp CLong -> Exp CLong # (*) :: Exp CLong -> Exp CLong -> Exp CLong # negate :: Exp CLong -> Exp CLong # abs :: Exp CLong -> Exp CLong # signum :: Exp CLong -> Exp CLong # fromInteger :: Integer -> Exp CLong #
Num (Exp CULong) #
Instance details Defined in Data.Array.Accelerate.Classes.Num Methods (+) :: Exp CULong -> Exp CULong -> Exp CULong # (-) :: Exp CULong -> Exp CULong -> Exp CULong # (*) :: Exp CULong -> Exp CULong -> Exp CULong # negate :: Exp CULong -> Exp CULong # abs :: Exp CULong -> Exp CULong # signum :: Exp CULong -> Exp CULong # fromInteger :: Integer -> Exp CULong #
Num (Exp CLLong) #
Instance details Defined in Data.Array.Accelerate.Classes.Num Methods (+) :: Exp CLLong -> Exp CLLong -> Exp CLLong # (-) :: Exp CLLong -> Exp CLLong -> Exp CLLong # (*) :: Exp CLLong -> Exp CLLong -> Exp CLLong # negate :: Exp CLLong -> Exp CLLong # abs :: Exp CLLong -> Exp CLLong # signum :: Exp CLLong -> Exp CLLong # fromInteger :: Integer -> Exp CLLong #
Num (Exp CULLong) #
Instance details Defined in Data.Array.Accelerate.Classes.Num Methods (+) :: Exp CULLong -> Exp CULLong -> Exp CULLong # (-) :: Exp CULLong -> Exp CULLong -> Exp CULLong # (*) :: Exp CULLong -> Exp CULLong -> Exp CULLong # negate :: Exp CULLong -> Exp CULLong # abs :: Exp CULLong -> Exp CULLong # signum :: Exp CULLong -> Exp CULLong # fromInteger :: Integer -> Exp CULLong #
Num (Exp CFloat) #
Instance details Defined in Data.Array.Accelerate.Classes.Num Methods (+) :: Exp CFloat -> Exp CFloat -> Exp CFloat # (-) :: Exp CFloat -> Exp CFloat -> Exp CFloat # (*) :: Exp CFloat -> Exp CFloat -> Exp CFloat # negate :: Exp CFloat -> Exp CFloat # abs :: Exp CFloat -> Exp CFloat # signum :: Exp CFloat -> Exp CFloat # fromInteger :: Integer -> Exp CFloat #
Num (Exp CDouble) #
Instance details Defined in Data.Array.Accelerate.Classes.Num Methods (+) :: Exp CDouble -> Exp CDouble -> Exp CDouble # (-) :: Exp CDouble -> Exp CDouble -> Exp CDouble # (*) :: Exp CDouble -> Exp CDouble -> Exp CDouble # negate :: Exp CDouble -> Exp CDouble # abs :: Exp CDouble -> Exp CDouble # signum :: Exp CDouble -> Exp CDouble # fromInteger :: Integer -> Exp CDouble #
Num (Exp Half) #
Instance details Defined in Data.Array.Accelerate.Classes.Num Methods (+) :: Exp Half -> Exp Half -> Exp Half # (-) :: Exp Half -> Exp Half -> Exp Half # (*) :: Exp Half -> Exp Half -> Exp Half # negate :: Exp Half -> Exp Half # abs :: Exp Half -> Exp Half # signum :: Exp Half -> Exp Half # fromInteger :: Integer -> Exp Half #
Ord a => Ord (Exp a) #
Instance details Defined in Data.Array.Accelerate.Classes.Ord Methods compare :: Exp a -> Exp a -> Ordering # (<) :: Exp a -> Exp a -> Bool # (<=) :: Exp a -> Exp a -> Bool # (>) :: Exp a -> Exp a -> Bool # (>=) :: Exp a -> Exp a -> Bool # max :: Exp a -> Exp a -> Exp a # min :: Exp a -> Exp a -> Exp a #
(Num a, Ord a) => Real (Exp a) #
Instance details Defined in Data.Array.Accelerate.Classes.Real Methods toRational :: Exp a -> Rational #
RealFloat a => RealFloat (Exp a) #
Instance details Defined in Data.Array.Accelerate.Classes.RealFloat Methods floatRadix :: Exp a -> Integer # floatDigits :: Exp a -> Int # floatRange :: Exp a -> (Int, Int) # decodeFloat :: Exp a -> (Integer, Int) # encodeFloat :: Integer -> Int -> Exp a # exponent :: Exp a -> Int # significand :: Exp a -> Exp a # scaleFloat :: Int -> Exp a -> Exp a # isNaN :: Exp a -> Bool # isInfinite :: Exp a -> Bool # isDenormalized :: Exp a -> Bool # isNegativeZero :: Exp a -> Bool # isIEEE :: Exp a -> Bool # atan2 :: Exp a -> Exp a -> Exp a #
RealFrac a => RealFrac (Exp a) #
Instance details Defined in Data.Array.Accelerate.Classes.RealFrac Methods properFraction :: Integral b => Exp a -> (b, Exp a) # truncate :: Integral b => Exp a -> b # round :: Integral b => Exp a -> b # ceiling :: Integral b => Exp a -> b # floor :: Integral b => Exp a -> b #
Elt e => Show (Exp e) #
Instance details Defined in Data.Array.Accelerate.Trafo Methods showsPrec :: Int -> Exp e -> ShowS # show :: Exp e -> String # showList :: [Exp e] -> ShowS #
(Semigroup (Exp a), Elt a) => Semigroup (Exp (Maybe a)) #
Instance details Defined in Data.Array.Accelerate.Data.Maybe Methods (<>) :: Exp (Maybe a) -> Exp (Maybe a) -> Exp (Maybe a) # sconcat :: NonEmpty (Exp (Maybe a)) -> Exp (Maybe a) # stimes :: Integral b => b -> Exp (Maybe a) -> Exp (Maybe a) #
(Elt a, Elt b) => Semigroup (Exp (Either a b)) #
Instance details Defined in Data.Array.Accelerate.Data.Either Methods (<>) :: Exp (Either a b) -> Exp (Either a b) -> Exp (Either a b) # sconcat :: NonEmpty (Exp (Either a b)) -> Exp (Either a b) # stimes :: Integral b0 => b0 -> Exp (Either a b) -> Exp (Either a b) #
Semigroup (Exp ()) #
Instance details Defined in Data.Array.Accelerate.Data.Semigroup Methods (<>) :: Exp () -> Exp () -> Exp () # sconcat :: NonEmpty (Exp ()) -> Exp () # stimes :: Integral b => b -> Exp () -> Exp () #
(Elt a, Elt b, Semigroup (Exp a), Semigroup (Exp b)) => Semigroup (Exp (a, b)) #
Instance details Defined in Data.Array.Accelerate.Data.Semigroup Methods (<>) :: Exp (a, b) -> Exp (a, b) -> Exp (a, b) # sconcat :: NonEmpty (Exp (a, b)) -> Exp (a, b) # stimes :: Integral b0 => b0 -> Exp (a, b) -> Exp (a, b) #
(Elt a, Elt b, Elt c, Semigroup (Exp a), Semigroup (Exp b), Semigroup (Exp c)) => Semigroup (Exp (a, b, c)) #
Instance details Defined in Data.Array.Accelerate.Data.Semigroup Methods (<>) :: Exp (a, b, c) -> Exp (a, b, c) -> Exp (a, b, c) # sconcat :: NonEmpty (Exp (a, b, c)) -> Exp (a, b, c) # stimes :: Integral b0 => b0 -> Exp (a, b, c) -> Exp (a, b, c) #
(Elt a, Elt b, Elt c, Elt d, Semigroup (Exp a), Semigroup (Exp b), Semigroup (Exp c), Semigroup (Exp d)) => Semigroup (Exp (a, b, c, d)) #
Instance details Defined in Data.Array.Accelerate.Data.Semigroup Methods (<>) :: Exp (a, b, c, d) -> Exp (a, b, c, d) -> Exp (a, b, c, d) # sconcat :: NonEmpty (Exp (a, b, c, d)) -> Exp (a, b, c, d) # stimes :: Integral b0 => b0 -> Exp (a, b, c, d) -> Exp (a, b, c, d) #
(Elt a, Elt b, Elt c, Elt d, Elt e, Semigroup (Exp a), Semigroup (Exp b), Semigroup (Exp c), Semigroup (Exp d), Semigroup (Exp e)) => Semigroup (Exp (a, b, c, d, e)) #
Instance details Defined in Data.Array.Accelerate.Data.Semigroup Methods (<>) :: Exp (a, b, c, d, e) -> Exp (a, b, c, d, e) -> Exp (a, b, c, d, e) # sconcat :: NonEmpty (Exp (a, b, c, d, e)) -> Exp (a, b, c, d, e) # stimes :: Integral b0 => b0 -> Exp (a, b, c, d, e) -> Exp (a, b, c, d, e) #
Ord a => Semigroup (Exp (Min a)) #
Instance details Defined in Data.Array.Accelerate.Data.Semigroup Methods (<>) :: Exp (Min a) -> Exp (Min a) -> Exp (Min a) # sconcat :: NonEmpty (Exp (Min a)) -> Exp (Min a) # stimes :: Integral b => b -> Exp (Min a) -> Exp (Min a) #
Ord a => Semigroup (Exp (Max a)) #
Instance details Defined in Data.Array.Accelerate.Data.Semigroup Methods (<>) :: Exp (Max a) -> Exp (Max a) -> Exp (Max a) # sconcat :: NonEmpty (Exp (Max a)) -> Exp (Max a) # stimes :: Integral b => b -> Exp (Max a) -> Exp (Max a) #
Num a => Semigroup (Exp (Sum a)) #	Since: 1.2.0.0
Instance details Defined in Data.Array.Accelerate.Data.Monoid Methods (<>) :: Exp (Sum a) -> Exp (Sum a) -> Exp (Sum a) # sconcat :: NonEmpty (Exp (Sum a)) -> Exp (Sum a) # stimes :: Integral b => b -> Exp (Sum a) -> Exp (Sum a) #
Num a => Semigroup (Exp (Product a)) #	Since: 1.2.0.0
Instance details Defined in Data.Array.Accelerate.Data.Monoid Methods (<>) :: Exp (Product a) -> Exp (Product a) -> Exp (Product a) # sconcat :: NonEmpty (Exp (Product a)) -> Exp (Product a) # stimes :: Integral b => b -> Exp (Product a) -> Exp (Product a) #
(Monoid (Exp a), Elt a) => Monoid (Exp (Maybe a)) #
Instance details Defined in Data.Array.Accelerate.Data.Maybe Methods mempty :: Exp (Maybe a) # mappend :: Exp (Maybe a) -> Exp (Maybe a) -> Exp (Maybe a) # mconcat :: [Exp (Maybe a)] -> Exp (Maybe a) #
Monoid (Exp ()) #
Instance details Defined in Data.Array.Accelerate.Data.Monoid Methods mempty :: Exp () # mappend :: Exp () -> Exp () -> Exp () # mconcat :: [Exp ()] -> Exp () #
(Elt a, Elt b, Monoid (Exp a), Monoid (Exp b)) => Monoid (Exp (a, b)) #
Instance details Defined in Data.Array.Accelerate.Data.Monoid Methods mempty :: Exp (a, b) # mappend :: Exp (a, b) -> Exp (a, b) -> Exp (a, b) # mconcat :: [Exp (a, b)] -> Exp (a, b) #
(Elt a, Elt b, Elt c, Monoid (Exp a), Monoid (Exp b), Monoid (Exp c)) => Monoid (Exp (a, b, c)) #
Instance details Defined in Data.Array.Accelerate.Data.Monoid Methods mempty :: Exp (a, b, c) # mappend :: Exp (a, b, c) -> Exp (a, b, c) -> Exp (a, b, c) # mconcat :: [Exp (a, b, c)] -> Exp (a, b, c) #
(Elt a, Elt b, Elt c, Elt d, Monoid (Exp a), Monoid (Exp b), Monoid (Exp c), Monoid (Exp d)) => Monoid (Exp (a, b, c, d)) #
Instance details Defined in Data.Array.Accelerate.Data.Monoid Methods mempty :: Exp (a, b, c, d) # mappend :: Exp (a, b, c, d) -> Exp (a, b, c, d) -> Exp (a, b, c, d) # mconcat :: [Exp (a, b, c, d)] -> Exp (a, b, c, d) #
(Elt a, Elt b, Elt c, Elt d, Elt e, Monoid (Exp a), Monoid (Exp b), Monoid (Exp c), Monoid (Exp d), Monoid (Exp e)) => Monoid (Exp (a, b, c, d, e)) #
Instance details Defined in Data.Array.Accelerate.Data.Monoid Methods mempty :: Exp (a, b, c, d, e) # mappend :: Exp (a, b, c, d, e) -> Exp (a, b, c, d, e) -> Exp (a, b, c, d, e) # mconcat :: [Exp (a, b, c, d, e)] -> Exp (a, b, c, d, e) #
(Ord a, Bounded a) => Monoid (Exp (Min a)) #
Instance details Defined in Data.Array.Accelerate.Data.Semigroup Methods mempty :: Exp (Min a) # mappend :: Exp (Min a) -> Exp (Min a) -> Exp (Min a) # mconcat :: [Exp (Min a)] -> Exp (Min a) #
(Ord a, Bounded a) => Monoid (Exp (Max a)) #
Instance details Defined in Data.Array.Accelerate.Data.Semigroup Methods mempty :: Exp (Max a) # mappend :: Exp (Max a) -> Exp (Max a) -> Exp (Max a) # mconcat :: [Exp (Max a)] -> Exp (Max a) #
Num a => Monoid (Exp (Sum a)) #
Instance details Defined in Data.Array.Accelerate.Data.Monoid Methods mempty :: Exp (Sum a) # mappend :: Exp (Sum a) -> Exp (Sum a) -> Exp (Sum a) # mconcat :: [Exp (Sum a)] -> Exp (Sum a) #
Num a => Monoid (Exp (Product a)) #
Instance details Defined in Data.Array.Accelerate.Data.Monoid Methods mempty :: Exp (Product a) # mappend :: Exp (Product a) -> Exp (Product a) -> Exp (Product a) # mconcat :: [Exp (Product a)] -> Exp (Product a) #
Floating b => Floating (Fold a (Exp b)) #
Instance details Defined in Data.Array.Accelerate.Data.Fold Methods pi :: Fold a (Exp b) # exp :: Fold a (Exp b) -> Fold a (Exp b) # log :: Fold a (Exp b) -> Fold a (Exp b) # sqrt :: Fold a (Exp b) -> Fold a (Exp b) # (**) :: Fold a (Exp b) -> Fold a (Exp b) -> Fold a (Exp b) # logBase :: Fold a (Exp b) -> Fold a (Exp b) -> Fold a (Exp b) # sin :: Fold a (Exp b) -> Fold a (Exp b) # cos :: Fold a (Exp b) -> Fold a (Exp b) # tan :: Fold a (Exp b) -> Fold a (Exp b) # asin :: Fold a (Exp b) -> Fold a (Exp b) # acos :: Fold a (Exp b) -> Fold a (Exp b) # atan :: Fold a (Exp b) -> Fold a (Exp b) # sinh :: Fold a (Exp b) -> Fold a (Exp b) # cosh :: Fold a (Exp b) -> Fold a (Exp b) # tanh :: Fold a (Exp b) -> Fold a (Exp b) # asinh :: Fold a (Exp b) -> Fold a (Exp b) # acosh :: Fold a (Exp b) -> Fold a (Exp b) # atanh :: Fold a (Exp b) -> Fold a (Exp b) # log1p :: Fold a (Exp b) -> Fold a (Exp b) # expm1 :: Fold a (Exp b) -> Fold a (Exp b) # log1pexp :: Fold a (Exp b) -> Fold a (Exp b) # log1mexp :: Fold a (Exp b) -> Fold a (Exp b) #
Fractional b => Fractional (Fold a (Exp b)) #
Instance details Defined in Data.Array.Accelerate.Data.Fold Methods (/) :: Fold a (Exp b) -> Fold a (Exp b) -> Fold a (Exp b) # recip :: Fold a (Exp b) -> Fold a (Exp b) # fromRational :: Rational -> Fold a (Exp b) #
Num b => Num (Fold a (Exp b)) #
Instance details Defined in Data.Array.Accelerate.Data.Fold Methods (+) :: Fold a (Exp b) -> Fold a (Exp b) -> Fold a (Exp b) # (-) :: Fold a (Exp b) -> Fold a (Exp b) -> Fold a (Exp b) # (*) :: Fold a (Exp b) -> Fold a (Exp b) -> Fold a (Exp b) # negate :: Fold a (Exp b) -> Fold a (Exp b) # abs :: Fold a (Exp b) -> Fold a (Exp b) # signum :: Fold a (Exp b) -> Fold a (Exp b) # fromInteger :: Integer -> Fold a (Exp b) #
Function (Exp a -> f) => Show (Exp a -> f) #
Instance details Defined in Data.Array.Accelerate.Trafo Methods showsPrec :: Int -> (Exp a -> f) -> ShowS # show :: (Exp a -> f) -> String # showList :: [Exp a -> f] -> ShowS #
type EltT Exp t #
Instance details Defined in Data.Array.Accelerate.Prelude type EltT Exp t = Elt t
type Plain (Exp e) #
Instance details Defined in Data.Array.Accelerate.Lift type Plain (Exp e) = e
type Plain (ix :. Exp e) #
Instance details Defined in Data.Array.Accelerate.Lift 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 #
Instance details Defined in Data.Array.Accelerate.Classes.Eq Methods (==) :: Exp Bool -> Exp Bool -> Exp Bool # (/=) :: Exp Bool -> Exp Bool -> Exp Bool #
Eq Char #
Instance details Defined in Data.Array.Accelerate.Classes.Eq Methods (==) :: Exp Char -> Exp Char -> Exp Bool # (/=) :: Exp Char -> Exp Char -> Exp Bool #
Eq Double #
Instance details Defined in Data.Array.Accelerate.Classes.Eq Methods (==) :: Exp Double -> Exp Double -> Exp Bool # (/=) :: Exp Double -> Exp Double -> Exp Bool #
Eq Float #
Instance details Defined in Data.Array.Accelerate.Classes.Eq Methods (==) :: Exp Float -> Exp Float -> Exp Bool # (/=) :: Exp Float -> Exp Float -> Exp Bool #
Eq Int #
Instance details Defined in Data.Array.Accelerate.Classes.Eq Methods (==) :: Exp Int -> Exp Int -> Exp Bool # (/=) :: Exp Int -> Exp Int -> Exp Bool #
Eq Int8 #
Instance details Defined in Data.Array.Accelerate.Classes.Eq Methods (==) :: Exp Int8 -> Exp Int8 -> Exp Bool # (/=) :: Exp Int8 -> Exp Int8 -> Exp Bool #
Eq Int16 #
Instance details Defined in Data.Array.Accelerate.Classes.Eq Methods (==) :: Exp Int16 -> Exp Int16 -> Exp Bool # (/=) :: Exp Int16 -> Exp Int16 -> Exp Bool #
Eq Int32 #
Instance details Defined in Data.Array.Accelerate.Classes.Eq Methods (==) :: Exp Int32 -> Exp Int32 -> Exp Bool # (/=) :: Exp Int32 -> Exp Int32 -> Exp Bool #
Eq Int64 #
Instance details Defined in Data.Array.Accelerate.Classes.Eq Methods (==) :: Exp Int64 -> Exp Int64 -> Exp Bool # (/=) :: Exp Int64 -> Exp Int64 -> Exp Bool #
Eq Ordering #
Instance details Defined in Data.Array.Accelerate.Classes.Ord Methods (==) :: Exp Ordering -> Exp Ordering -> Exp Bool # (/=) :: Exp Ordering -> Exp Ordering -> Exp Bool #
Eq Word #
Instance details Defined in Data.Array.Accelerate.Classes.Eq Methods (==) :: Exp Word -> Exp Word -> Exp Bool # (/=) :: Exp Word -> Exp Word -> Exp Bool #
Eq Word8 #
Instance details Defined in Data.Array.Accelerate.Classes.Eq Methods (==) :: Exp Word8 -> Exp Word8 -> Exp Bool # (/=) :: Exp Word8 -> Exp Word8 -> Exp Bool #
Eq Word16 #
Instance details Defined in Data.Array.Accelerate.Classes.Eq Methods (==) :: Exp Word16 -> Exp Word16 -> Exp Bool # (/=) :: Exp Word16 -> Exp Word16 -> Exp Bool #
Eq Word32 #
Instance details Defined in Data.Array.Accelerate.Classes.Eq Methods (==) :: Exp Word32 -> Exp Word32 -> Exp Bool # (/=) :: Exp Word32 -> Exp Word32 -> Exp Bool #
Eq Word64 #
Instance details Defined in Data.Array.Accelerate.Classes.Eq Methods (==) :: Exp Word64 -> Exp Word64 -> Exp Bool # (/=) :: Exp Word64 -> Exp Word64 -> Exp Bool #
Eq () #
Instance details Defined in Data.Array.Accelerate.Classes.Eq Methods (==) :: Exp () -> Exp () -> Exp Bool # (/=) :: Exp () -> Exp () -> Exp Bool #
Eq CChar #
Instance details Defined in Data.Array.Accelerate.Classes.Eq Methods (==) :: Exp CChar -> Exp CChar -> Exp Bool # (/=) :: Exp CChar -> Exp CChar -> Exp Bool #
Eq CSChar #
Instance details Defined in Data.Array.Accelerate.Classes.Eq Methods (==) :: Exp CSChar -> Exp CSChar -> Exp Bool # (/=) :: Exp CSChar -> Exp CSChar -> Exp Bool #
Eq CUChar #
Instance details Defined in Data.Array.Accelerate.Classes.Eq Methods (==) :: Exp CUChar -> Exp CUChar -> Exp Bool # (/=) :: Exp CUChar -> Exp CUChar -> Exp Bool #
Eq CShort #
Instance details Defined in Data.Array.Accelerate.Classes.Eq Methods (==) :: Exp CShort -> Exp CShort -> Exp Bool # (/=) :: Exp CShort -> Exp CShort -> Exp Bool #
Eq CUShort #
Instance details Defined in Data.Array.Accelerate.Classes.Eq Methods (==) :: Exp CUShort -> Exp CUShort -> Exp Bool # (/=) :: Exp CUShort -> Exp CUShort -> Exp Bool #
Eq CInt #
Instance details Defined in Data.Array.Accelerate.Classes.Eq Methods (==) :: Exp CInt -> Exp CInt -> Exp Bool # (/=) :: Exp CInt -> Exp CInt -> Exp Bool #
Eq CUInt #
Instance details Defined in Data.Array.Accelerate.Classes.Eq Methods (==) :: Exp CUInt -> Exp CUInt -> Exp Bool # (/=) :: Exp CUInt -> Exp CUInt -> Exp Bool #
Eq CLong #
Instance details Defined in Data.Array.Accelerate.Classes.Eq Methods (==) :: Exp CLong -> Exp CLong -> Exp Bool # (/=) :: Exp CLong -> Exp CLong -> Exp Bool #
Eq CULong #
Instance details Defined in Data.Array.Accelerate.Classes.Eq Methods (==) :: Exp CULong -> Exp CULong -> Exp Bool # (/=) :: Exp CULong -> Exp CULong -> Exp Bool #
Eq CLLong #
Instance details Defined in Data.Array.Accelerate.Classes.Eq Methods (==) :: Exp CLLong -> Exp CLLong -> Exp Bool # (/=) :: Exp CLLong -> Exp CLLong -> Exp Bool #
Eq CULLong #
Instance details Defined in Data.Array.Accelerate.Classes.Eq Methods (==) :: Exp CULLong -> Exp CULLong -> Exp Bool # (/=) :: Exp CULLong -> Exp CULLong -> Exp Bool #
Eq CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.Eq Methods (==) :: Exp CFloat -> Exp CFloat -> Exp Bool # (/=) :: Exp CFloat -> Exp CFloat -> Exp Bool #
Eq CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.Eq Methods (==) :: Exp CDouble -> Exp CDouble -> Exp Bool # (/=) :: Exp CDouble -> Exp CDouble -> Exp Bool #
Eq Half #
Instance details Defined in Data.Array.Accelerate.Classes.Eq Methods (==) :: Exp Half -> Exp Half -> Exp Bool # (/=) :: Exp Half -> Exp Half -> Exp Bool #
Eq a => Eq (Maybe a) #
Instance details Defined in Data.Array.Accelerate.Data.Maybe 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) #
Instance details Defined in Data.Array.Accelerate.Data.Complex Methods (==) :: Exp (Complex a) -> Exp (Complex a) -> Exp Bool # (/=) :: Exp (Complex a) -> Exp (Complex a) -> Exp Bool #
Eq a => Eq (Min a) #
Instance details Defined in Data.Array.Accelerate.Data.Semigroup Methods (==) :: Exp (Min a) -> Exp (Min a) -> Exp Bool # (/=) :: Exp (Min a) -> Exp (Min a) -> Exp Bool #
Eq a => Eq (Max a) #
Instance details Defined in Data.Array.Accelerate.Data.Semigroup Methods (==) :: Exp (Max a) -> Exp (Max a) -> Exp Bool # (/=) :: Exp (Max a) -> Exp (Max a) -> Exp Bool #
Eq a => Eq (Sum a) #
Instance details Defined in Data.Array.Accelerate.Data.Monoid Methods (==) :: Exp (Sum a) -> Exp (Sum a) -> Exp Bool # (/=) :: Exp (Sum a) -> Exp (Sum a) -> Exp Bool #
Eq a => Eq (Product a) #
Instance details Defined in Data.Array.Accelerate.Data.Monoid Methods (==) :: Exp (Product a) -> Exp (Product a) -> Exp Bool # (/=) :: Exp (Product a) -> Exp (Product a) -> Exp Bool #
(Eq a, Eq b) => Eq (Either a b) #
Instance details Defined in Data.Array.Accelerate.Data.Either Methods (==) :: Exp (Either a b) -> Exp (Either a b) -> Exp Bool # (/=) :: Exp (Either a b) -> Exp (Either a b) -> Exp Bool #
(Eq a, Eq b) => Eq (a, b) #
Instance details Defined in Data.Array.Accelerate.Classes.Eq 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) #
Instance details Defined in Data.Array.Accelerate.Classes.Eq 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) #
Instance details Defined in Data.Array.Accelerate.Classes.Eq 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) #
Instance details Defined in Data.Array.Accelerate.Classes.Eq 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) #
Instance details Defined in Data.Array.Accelerate.Classes.Eq 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) #
Instance details Defined in Data.Array.Accelerate.Classes.Eq 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) #
Instance details Defined in Data.Array.Accelerate.Classes.Eq 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) #
Instance details Defined in Data.Array.Accelerate.Classes.Eq 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) #
Instance details Defined in Data.Array.Accelerate.Classes.Eq 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) #
Instance details Defined in Data.Array.Accelerate.Classes.Eq 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) #
Instance details Defined in Data.Array.Accelerate.Classes.Eq 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) #
Instance details Defined in Data.Array.Accelerate.Classes.Eq 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) #
Instance details Defined in Data.Array.Accelerate.Classes.Eq 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) #
Instance details Defined in Data.Array.Accelerate.Classes.Eq 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) #
Instance details Defined in Data.Array.Accelerate.Classes.Eq 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 #
Instance details Defined in Data.Array.Accelerate.Classes.Ord 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 #
Instance details Defined in Data.Array.Accelerate.Classes.Ord Methods (<) :: Exp Char -> Exp Char -> Exp Bool # (>) :: Exp Char -> Exp Char -> Exp Bool # (<=) :: Exp Char -> Exp Char -> Exp Bool # (>=) :: Exp Char -> Exp Char -> Exp Bool # min :: Exp Char -> Exp Char -> Exp Char # max :: Exp Char -> Exp Char -> Exp Char # compare :: Exp Char -> Exp Char -> Exp Ordering #
Ord Double #
Instance details Defined in Data.Array.Accelerate.Classes.Ord Methods (<) :: Exp Double -> Exp Double -> Exp Bool # (>) :: Exp Double -> Exp Double -> Exp Bool # (<=) :: Exp Double -> Exp Double -> Exp Bool # (>=) :: Exp Double -> Exp Double -> Exp Bool # min :: Exp Double -> Exp Double -> Exp Double # max :: Exp Double -> Exp Double -> Exp Double # compare :: Exp Double -> Exp Double -> Exp Ordering #
Ord Float #
Instance details Defined in Data.Array.Accelerate.Classes.Ord Methods (<) :: Exp Float -> Exp Float -> Exp Bool # (>) :: Exp Float -> Exp Float -> Exp Bool # (<=) :: Exp Float -> Exp Float -> Exp Bool # (>=) :: Exp Float -> Exp Float -> Exp Bool # min :: Exp Float -> Exp Float -> Exp Float # max :: Exp Float -> Exp Float -> Exp Float # compare :: Exp Float -> Exp Float -> Exp Ordering #
Ord Int #
Instance details Defined in Data.Array.Accelerate.Classes.Ord Methods (<) :: Exp Int -> Exp Int -> Exp Bool # (>) :: Exp Int -> Exp Int -> Exp Bool # (<=) :: Exp Int -> Exp Int -> Exp Bool # (>=) :: Exp Int -> Exp Int -> Exp Bool # min :: Exp Int -> Exp Int -> Exp Int # max :: Exp Int -> Exp Int -> Exp Int # compare :: Exp Int -> Exp Int -> Exp Ordering #
Ord Int8 #
Instance details Defined in Data.Array.Accelerate.Classes.Ord Methods (<) :: Exp Int8 -> Exp Int8 -> Exp Bool # (>) :: Exp Int8 -> Exp Int8 -> Exp Bool # (<=) :: Exp Int8 -> Exp Int8 -> Exp Bool # (>=) :: Exp Int8 -> Exp Int8 -> Exp Bool # min :: Exp Int8 -> Exp Int8 -> Exp Int8 # max :: Exp Int8 -> Exp Int8 -> Exp Int8 # compare :: Exp Int8 -> Exp Int8 -> Exp Ordering #
Ord Int16 #
Instance details Defined in Data.Array.Accelerate.Classes.Ord Methods (<) :: Exp Int16 -> Exp Int16 -> Exp Bool # (>) :: Exp Int16 -> Exp Int16 -> Exp Bool # (<=) :: Exp Int16 -> Exp Int16 -> Exp Bool # (>=) :: Exp Int16 -> Exp Int16 -> Exp Bool # min :: Exp Int16 -> Exp Int16 -> Exp Int16 # max :: Exp Int16 -> Exp Int16 -> Exp Int16 # compare :: Exp Int16 -> Exp Int16 -> Exp Ordering #
Ord Int32 #
Instance details Defined in Data.Array.Accelerate.Classes.Ord Methods (<) :: Exp Int32 -> Exp Int32 -> Exp Bool # (>) :: Exp Int32 -> Exp Int32 -> Exp Bool # (<=) :: Exp Int32 -> Exp Int32 -> Exp Bool # (>=) :: Exp Int32 -> Exp Int32 -> Exp Bool # min :: Exp Int32 -> Exp Int32 -> Exp Int32 # max :: Exp Int32 -> Exp Int32 -> Exp Int32 # compare :: Exp Int32 -> Exp Int32 -> Exp Ordering #
Ord Int64 #
Instance details Defined in Data.Array.Accelerate.Classes.Ord Methods (<) :: Exp Int64 -> Exp Int64 -> Exp Bool # (>) :: Exp Int64 -> Exp Int64 -> Exp Bool # (<=) :: Exp Int64 -> Exp Int64 -> Exp Bool # (>=) :: Exp Int64 -> Exp Int64 -> Exp Bool # min :: Exp Int64 -> Exp Int64 -> Exp Int64 # max :: Exp Int64 -> Exp Int64 -> Exp Int64 # compare :: Exp Int64 -> Exp Int64 -> Exp Ordering #
Ord Ordering #
Instance details Defined in Data.Array.Accelerate.Classes.Ord Methods (<) :: Exp Ordering -> Exp Ordering -> Exp Bool # (>) :: Exp Ordering -> Exp Ordering -> Exp Bool # (<=) :: Exp Ordering -> Exp Ordering -> Exp Bool # (>=) :: Exp Ordering -> Exp Ordering -> Exp Bool # min :: Exp Ordering -> Exp Ordering -> Exp Ordering # max :: Exp Ordering -> Exp Ordering -> Exp Ordering # compare :: Exp Ordering -> Exp Ordering -> Exp Ordering #
Ord Word #
Instance details Defined in Data.Array.Accelerate.Classes.Ord Methods (<) :: Exp Word -> Exp Word -> Exp Bool # (>) :: Exp Word -> Exp Word -> Exp Bool # (<=) :: Exp Word -> Exp Word -> Exp Bool # (>=) :: Exp Word -> Exp Word -> Exp Bool # min :: Exp Word -> Exp Word -> Exp Word # max :: Exp Word -> Exp Word -> Exp Word # compare :: Exp Word -> Exp Word -> Exp Ordering #
Ord Word8 #
Instance details Defined in Data.Array.Accelerate.Classes.Ord Methods (<) :: Exp Word8 -> Exp Word8 -> Exp Bool # (>) :: Exp Word8 -> Exp Word8 -> Exp Bool # (<=) :: Exp Word8 -> Exp Word8 -> Exp Bool # (>=) :: Exp Word8 -> Exp Word8 -> Exp Bool # min :: Exp Word8 -> Exp Word8 -> Exp Word8 # max :: Exp Word8 -> Exp Word8 -> Exp Word8 # compare :: Exp Word8 -> Exp Word8 -> Exp Ordering #
Ord Word16 #
Instance details Defined in Data.Array.Accelerate.Classes.Ord Methods (<) :: Exp Word16 -> Exp Word16 -> Exp Bool # (>) :: Exp Word16 -> Exp Word16 -> Exp Bool # (<=) :: Exp Word16 -> Exp Word16 -> Exp Bool # (>=) :: Exp Word16 -> Exp Word16 -> Exp Bool # min :: Exp Word16 -> Exp Word16 -> Exp Word16 # max :: Exp Word16 -> Exp Word16 -> Exp Word16 # compare :: Exp Word16 -> Exp Word16 -> Exp Ordering #
Ord Word32 #
Instance details Defined in Data.Array.Accelerate.Classes.Ord Methods (<) :: Exp Word32 -> Exp Word32 -> Exp Bool # (>) :: Exp Word32 -> Exp Word32 -> Exp Bool # (<=) :: Exp Word32 -> Exp Word32 -> Exp Bool # (>=) :: Exp Word32 -> Exp Word32 -> Exp Bool # min :: Exp Word32 -> Exp Word32 -> Exp Word32 # max :: Exp Word32 -> Exp Word32 -> Exp Word32 # compare :: Exp Word32 -> Exp Word32 -> Exp Ordering #
Ord Word64 #
Instance details Defined in Data.Array.Accelerate.Classes.Ord Methods (<) :: Exp Word64 -> Exp Word64 -> Exp Bool # (>) :: Exp Word64 -> Exp Word64 -> Exp Bool # (<=) :: Exp Word64 -> Exp Word64 -> Exp Bool # (>=) :: Exp Word64 -> Exp Word64 -> Exp Bool # min :: Exp Word64 -> Exp Word64 -> Exp Word64 # max :: Exp Word64 -> Exp Word64 -> Exp Word64 # compare :: Exp Word64 -> Exp Word64 -> Exp Ordering #
Ord () #
Instance details Defined in Data.Array.Accelerate.Classes.Ord Methods (<) :: Exp () -> Exp () -> Exp Bool # (>) :: Exp () -> Exp () -> Exp Bool # (<=) :: Exp () -> Exp () -> Exp Bool # (>=) :: Exp () -> Exp () -> Exp Bool # min :: Exp () -> Exp () -> Exp () # max :: Exp () -> Exp () -> Exp () # compare :: Exp () -> Exp () -> Exp Ordering #
Ord CChar #
Instance details Defined in Data.Array.Accelerate.Classes.Ord Methods (<) :: Exp CChar -> Exp CChar -> Exp Bool # (>) :: Exp CChar -> Exp CChar -> Exp Bool # (<=) :: Exp CChar -> Exp CChar -> Exp Bool # (>=) :: Exp CChar -> Exp CChar -> Exp Bool # min :: Exp CChar -> Exp CChar -> Exp CChar # max :: Exp CChar -> Exp CChar -> Exp CChar # compare :: Exp CChar -> Exp CChar -> Exp Ordering #
Ord CSChar #
Instance details Defined in Data.Array.Accelerate.Classes.Ord Methods (<) :: Exp CSChar -> Exp CSChar -> Exp Bool # (>) :: Exp CSChar -> Exp CSChar -> Exp Bool # (<=) :: Exp CSChar -> Exp CSChar -> Exp Bool # (>=) :: Exp CSChar -> Exp CSChar -> Exp Bool # min :: Exp CSChar -> Exp CSChar -> Exp CSChar # max :: Exp CSChar -> Exp CSChar -> Exp CSChar # compare :: Exp CSChar -> Exp CSChar -> Exp Ordering #
Ord CUChar #
Instance details Defined in Data.Array.Accelerate.Classes.Ord Methods (<) :: Exp CUChar -> Exp CUChar -> Exp Bool # (>) :: Exp CUChar -> Exp CUChar -> Exp Bool # (<=) :: Exp CUChar -> Exp CUChar -> Exp Bool # (>=) :: Exp CUChar -> Exp CUChar -> Exp Bool # min :: Exp CUChar -> Exp CUChar -> Exp CUChar # max :: Exp CUChar -> Exp CUChar -> Exp CUChar # compare :: Exp CUChar -> Exp CUChar -> Exp Ordering #
Ord CShort #
Instance details Defined in Data.Array.Accelerate.Classes.Ord Methods (<) :: Exp CShort -> Exp CShort -> Exp Bool # (>) :: Exp CShort -> Exp CShort -> Exp Bool # (<=) :: Exp CShort -> Exp CShort -> Exp Bool # (>=) :: Exp CShort -> Exp CShort -> Exp Bool # min :: Exp CShort -> Exp CShort -> Exp CShort # max :: Exp CShort -> Exp CShort -> Exp CShort # compare :: Exp CShort -> Exp CShort -> Exp Ordering #
Ord CUShort #
Instance details Defined in Data.Array.Accelerate.Classes.Ord Methods (<) :: Exp CUShort -> Exp CUShort -> Exp Bool # (>) :: Exp CUShort -> Exp CUShort -> Exp Bool # (<=) :: Exp CUShort -> Exp CUShort -> Exp Bool # (>=) :: Exp CUShort -> Exp CUShort -> Exp Bool # min :: Exp CUShort -> Exp CUShort -> Exp CUShort # max :: Exp CUShort -> Exp CUShort -> Exp CUShort # compare :: Exp CUShort -> Exp CUShort -> Exp Ordering #
Ord CInt #
Instance details Defined in Data.Array.Accelerate.Classes.Ord Methods (<) :: Exp CInt -> Exp CInt -> Exp Bool # (>) :: Exp CInt -> Exp CInt -> Exp Bool # (<=) :: Exp CInt -> Exp CInt -> Exp Bool # (>=) :: Exp CInt -> Exp CInt -> Exp Bool # min :: Exp CInt -> Exp CInt -> Exp CInt # max :: Exp CInt -> Exp CInt -> Exp CInt # compare :: Exp CInt -> Exp CInt -> Exp Ordering #
Ord CUInt #
Instance details Defined in Data.Array.Accelerate.Classes.Ord Methods (<) :: Exp CUInt -> Exp CUInt -> Exp Bool # (>) :: Exp CUInt -> Exp CUInt -> Exp Bool # (<=) :: Exp CUInt -> Exp CUInt -> Exp Bool # (>=) :: Exp CUInt -> Exp CUInt -> Exp Bool # min :: Exp CUInt -> Exp CUInt -> Exp CUInt # max :: Exp CUInt -> Exp CUInt -> Exp CUInt # compare :: Exp CUInt -> Exp CUInt -> Exp Ordering #
Ord CLong #
Instance details Defined in Data.Array.Accelerate.Classes.Ord Methods (<) :: Exp CLong -> Exp CLong -> Exp Bool # (>) :: Exp CLong -> Exp CLong -> Exp Bool # (<=) :: Exp CLong -> Exp CLong -> Exp Bool # (>=) :: Exp CLong -> Exp CLong -> Exp Bool # min :: Exp CLong -> Exp CLong -> Exp CLong # max :: Exp CLong -> Exp CLong -> Exp CLong # compare :: Exp CLong -> Exp CLong -> Exp Ordering #
Ord CULong #
Instance details Defined in Data.Array.Accelerate.Classes.Ord Methods (<) :: Exp CULong -> Exp CULong -> Exp Bool # (>) :: Exp CULong -> Exp CULong -> Exp Bool # (<=) :: Exp CULong -> Exp CULong -> Exp Bool # (>=) :: Exp CULong -> Exp CULong -> Exp Bool # min :: Exp CULong -> Exp CULong -> Exp CULong # max :: Exp CULong -> Exp CULong -> Exp CULong # compare :: Exp CULong -> Exp CULong -> Exp Ordering #
Ord CLLong #
Instance details Defined in Data.Array.Accelerate.Classes.Ord Methods (<) :: Exp CLLong -> Exp CLLong -> Exp Bool # (>) :: Exp CLLong -> Exp CLLong -> Exp Bool # (<=) :: Exp CLLong -> Exp CLLong -> Exp Bool # (>=) :: Exp CLLong -> Exp CLLong -> Exp Bool # min :: Exp CLLong -> Exp CLLong -> Exp CLLong # max :: Exp CLLong -> Exp CLLong -> Exp CLLong # compare :: Exp CLLong -> Exp CLLong -> Exp Ordering #
Ord CULLong #
Instance details Defined in Data.Array.Accelerate.Classes.Ord Methods (<) :: Exp CULLong -> Exp CULLong -> Exp Bool # (>) :: Exp CULLong -> Exp CULLong -> Exp Bool # (<=) :: Exp CULLong -> Exp CULLong -> Exp Bool # (>=) :: Exp CULLong -> Exp CULLong -> Exp Bool # min :: Exp CULLong -> Exp CULLong -> Exp CULLong # max :: Exp CULLong -> Exp CULLong -> Exp CULLong # compare :: Exp CULLong -> Exp CULLong -> Exp Ordering #
Ord CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.Ord Methods (<) :: Exp CFloat -> Exp CFloat -> Exp Bool # (>) :: Exp CFloat -> Exp CFloat -> Exp Bool # (<=) :: Exp CFloat -> Exp CFloat -> Exp Bool # (>=) :: Exp CFloat -> Exp CFloat -> Exp Bool # min :: Exp CFloat -> Exp CFloat -> Exp CFloat # max :: Exp CFloat -> Exp CFloat -> Exp CFloat # compare :: Exp CFloat -> Exp CFloat -> Exp Ordering #
Ord CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.Ord Methods (<) :: Exp CDouble -> Exp CDouble -> Exp Bool # (>) :: Exp CDouble -> Exp CDouble -> Exp Bool # (<=) :: Exp CDouble -> Exp CDouble -> Exp Bool # (>=) :: Exp CDouble -> Exp CDouble -> Exp Bool # min :: Exp CDouble -> Exp CDouble -> Exp CDouble # max :: Exp CDouble -> Exp CDouble -> Exp CDouble # compare :: Exp CDouble -> Exp CDouble -> Exp Ordering #
Ord Half #
Instance details Defined in Data.Array.Accelerate.Classes.Ord Methods (<) :: Exp Half -> Exp Half -> Exp Bool # (>) :: Exp Half -> Exp Half -> Exp Bool # (<=) :: Exp Half -> Exp Half -> Exp Bool # (>=) :: Exp Half -> Exp Half -> Exp Bool # min :: Exp Half -> Exp Half -> Exp Half # max :: Exp Half -> Exp Half -> Exp Half # compare :: Exp Half -> Exp Half -> Exp Ordering #
Ord a => Ord (Maybe a) #
Instance details Defined in Data.Array.Accelerate.Data.Maybe Methods (<) :: Exp (Maybe a) -> Exp (Maybe a) -> Exp Bool # (>) :: Exp (Maybe a) -> Exp (Maybe a) -> Exp Bool # (<=) :: Exp (Maybe a) -> Exp (Maybe a) -> Exp Bool # (>=) :: Exp (Maybe a) -> Exp (Maybe a) -> Exp Bool # min :: Exp (Maybe a) -> Exp (Maybe a) -> Exp (Maybe a) # max :: Exp (Maybe a) -> Exp (Maybe a) -> Exp (Maybe a) # compare :: Exp (Maybe a) -> Exp (Maybe a) -> Exp Ordering #
Ord a => Ord (Min a) #
Instance details Defined in Data.Array.Accelerate.Data.Semigroup Methods (<) :: Exp (Min a) -> Exp (Min a) -> Exp Bool # (>) :: Exp (Min a) -> Exp (Min a) -> Exp Bool # (<=) :: Exp (Min a) -> Exp (Min a) -> Exp Bool # (>=) :: Exp (Min a) -> Exp (Min a) -> Exp Bool # min :: Exp (Min a) -> Exp (Min a) -> Exp (Min a) # max :: Exp (Min a) -> Exp (Min a) -> Exp (Min a) # compare :: Exp (Min a) -> Exp (Min a) -> Exp Ordering #
Ord a => Ord (Max a) #
Instance details Defined in Data.Array.Accelerate.Data.Semigroup Methods (<) :: Exp (Max a) -> Exp (Max a) -> Exp Bool # (>) :: Exp (Max a) -> Exp (Max a) -> Exp Bool # (<=) :: Exp (Max a) -> Exp (Max a) -> Exp Bool # (>=) :: Exp (Max a) -> Exp (Max a) -> Exp Bool # min :: Exp (Max a) -> Exp (Max a) -> Exp (Max a) # max :: Exp (Max a) -> Exp (Max a) -> Exp (Max a) # compare :: Exp (Max a) -> Exp (Max a) -> Exp Ordering #
Ord a => Ord (Sum a) #
Instance details Defined in Data.Array.Accelerate.Data.Monoid Methods (<) :: Exp (Sum a) -> Exp (Sum a) -> Exp Bool # (>) :: Exp (Sum a) -> Exp (Sum a) -> Exp Bool # (<=) :: Exp (Sum a) -> Exp (Sum a) -> Exp Bool # (>=) :: Exp (Sum a) -> Exp (Sum a) -> Exp Bool # min :: Exp (Sum a) -> Exp (Sum a) -> Exp (Sum a) # max :: Exp (Sum a) -> Exp (Sum a) -> Exp (Sum a) # compare :: Exp (Sum a) -> Exp (Sum a) -> Exp Ordering #
Ord a => Ord (Product a) #
Instance details Defined in Data.Array.Accelerate.Data.Monoid Methods (<) :: Exp (Product a) -> Exp (Product a) -> Exp Bool # (>) :: Exp (Product a) -> Exp (Product a) -> Exp Bool # (<=) :: Exp (Product a) -> Exp (Product a) -> Exp Bool # (>=) :: Exp (Product a) -> Exp (Product a) -> Exp Bool # min :: Exp (Product a) -> Exp (Product a) -> Exp (Product a) # max :: Exp (Product a) -> Exp (Product a) -> Exp (Product a) # compare :: Exp (Product a) -> Exp (Product a) -> Exp Ordering #
(Ord a, Ord b) => Ord (Either a b) #
Instance details Defined in Data.Array.Accelerate.Data.Either Methods (<) :: Exp (Either a b) -> Exp (Either a b) -> Exp Bool # (>) :: Exp (Either a b) -> Exp (Either a b) -> Exp Bool # (<=) :: Exp (Either a b) -> Exp (Either a b) -> Exp Bool # (>=) :: Exp (Either a b) -> Exp (Either a b) -> Exp Bool # min :: Exp (Either a b) -> Exp (Either a b) -> Exp (Either a b) # max :: Exp (Either a b) -> Exp (Either a b) -> Exp (Either a b) # compare :: Exp (Either a b) -> Exp (Either a b) -> Exp Ordering #
(Ord a, Ord b) => Ord (a, b) #
Instance details Defined in Data.Array.Accelerate.Classes.Ord 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) #
Instance details Defined in Data.Array.Accelerate.Classes.Ord 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) #
Instance details Defined in Data.Array.Accelerate.Classes.Ord 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) #
Instance details Defined in Data.Array.Accelerate.Classes.Ord 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) #
Instance details Defined in Data.Array.Accelerate.Classes.Ord 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) #
Instance details Defined in Data.Array.Accelerate.Classes.Ord 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) #
Instance details Defined in Data.Array.Accelerate.Classes.Ord 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) #
Instance details Defined in Data.Array.Accelerate.Classes.Ord 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) #
Instance details Defined in Data.Array.Accelerate.Classes.Ord 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) #
Instance details Defined in Data.Array.Accelerate.Classes.Ord 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) #
Instance details Defined in Data.Array.Accelerate.Classes.Ord 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) #
Instance details Defined in Data.Array.Accelerate.Classes.Ord 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) #
Instance details Defined in Data.Array.Accelerate.Classes.Ord 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) #
Instance details Defined in Data.Array.Accelerate.Classes.Ord 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: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: Ordering # maxBound :: Ordering #
Enum Ordering	Since: base-2.1
Instance details Defined in GHC.Enum Methods succ :: Ordering -> Ordering # pred :: Ordering -> Ordering # toEnum :: Int -> Ordering # fromEnum :: Ordering -> Int # enumFrom :: Ordering -> [Ordering] # enumFromThen :: Ordering -> Ordering -> [Ordering] # enumFromTo :: Ordering -> Ordering -> [Ordering] # enumFromThenTo :: Ordering -> Ordering -> Ordering -> [Ordering] #
Eq Ordering
Instance details Defined in GHC.Classes Methods (==) :: Ordering -> Ordering -> Bool # (/=) :: Ordering -> Ordering -> Bool #
Ord Ordering
Instance details Defined in GHC.Classes Methods compare :: Ordering -> Ordering -> Ordering # (<) :: Ordering -> Ordering -> Bool # (<=) :: Ordering -> Ordering -> Bool # (>) :: Ordering -> Ordering -> Bool # (>=) :: Ordering -> Ordering -> Bool # max :: Ordering -> Ordering -> Ordering # min :: Ordering -> Ordering -> Ordering #
Read Ordering	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Ordering # readList :: ReadS [Ordering] # readPrec :: ReadPrec Ordering # readListPrec :: ReadPrec [Ordering] #
Show Ordering	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Ordering -> ShowS # show :: Ordering -> String # showList :: [Ordering] -> ShowS #
Generic Ordering
Instance details Defined in GHC.Generics Associated Types type Rep Ordering :: Type -> Type # Methods from :: Ordering -> Rep Ordering x # to :: Rep Ordering x -> Ordering #
Semigroup Ordering	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods (<>) :: Ordering -> Ordering -> Ordering # sconcat :: NonEmpty Ordering -> Ordering # stimes :: Integral b => b -> Ordering -> Ordering #
Monoid Ordering	Since: base-2.1
Instance details Defined in GHC.Base Methods mempty :: Ordering # mappend :: Ordering -> Ordering -> Ordering # mconcat :: [Ordering] -> Ordering #
NFData Ordering
Instance details Defined in Control.DeepSeq Methods rnf :: Ordering -> () #
Hashable Ordering
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Ordering -> Int # hash :: Ordering -> Int #
AsEmpty Ordering
Instance details Defined in Control.Lens.Empty Methods _Empty :: Prism' Ordering () #
Elt Ordering #
Instance details Defined in Data.Array.Accelerate.Classes.Ord Methods eltType :: Ordering -> TupleType (EltRepr Ordering) fromElt :: Ordering -> EltRepr Ordering toElt :: EltRepr Ordering -> Ordering
Eq Ordering #
Instance details Defined in Data.Array.Accelerate.Classes.Ord Methods (==) :: Exp Ordering -> Exp Ordering -> Exp Bool # (/=) :: Exp Ordering -> Exp Ordering -> Exp Bool #
Ord Ordering #
Instance details Defined in Data.Array.Accelerate.Classes.Ord Methods (<) :: Exp Ordering -> Exp Ordering -> Exp Bool # (>) :: Exp Ordering -> Exp Ordering -> Exp Bool # (<=) :: Exp Ordering -> Exp Ordering -> Exp Bool # (>=) :: Exp Ordering -> Exp Ordering -> Exp Bool # min :: Exp Ordering -> Exp Ordering -> Exp Ordering # max :: Exp Ordering -> Exp Ordering -> Exp Ordering # compare :: Exp Ordering -> Exp Ordering -> Exp Ordering #
() :=> (Bounded Ordering)
Instance details Defined in Data.Constraint Methods ins :: () :- Bounded Ordering #
() :=> (Enum Ordering)
Instance details Defined in Data.Constraint Methods ins :: () :- Enum Ordering #
() :=> (Read Ordering)
Instance details Defined in Data.Constraint Methods ins :: () :- Read Ordering #
() :=> (Show Ordering)
Instance details Defined in Data.Constraint Methods ins :: () :- Show Ordering #
() :=> (Semigroup Ordering)
Instance details Defined in Data.Constraint Methods ins :: () :- Semigroup Ordering #
() :=> (Monoid Ordering)
Instance details Defined in Data.Constraint Methods ins :: () :- Monoid Ordering #
type Rep Ordering	Since: base-4.6.0.0
Instance details Defined in GHC.Generics type Rep Ordering = D1 (MetaData "Ordering" "GHC.Types" "ghc-prim" False) (C1 (MetaCons "LT" PrefixI False) (U1 :: Type -> Type) :+: (C1 (MetaCons "EQ" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "GT" PrefixI False) (U1 :: Type -> Type)))

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.

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 #
Instance details Defined in Data.Array.Accelerate.Classes.RealFrac 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 #
Instance details Defined in Data.Array.Accelerate.Classes.RealFrac 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 #
Instance details Defined in Data.Array.Accelerate.Classes.RealFrac 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 #
Instance details Defined in Data.Array.Accelerate.Classes.RealFrac 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 #
Instance details Defined in Data.Array.Accelerate.Classes.RealFrac 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 #
Instance details Defined in Data.Array.Accelerate.Classes.RealFloat Methods floatRadix :: Exp Double -> Exp Int64 # floatDigits :: Exp Double -> Exp Int # floatRange :: Exp Double -> (Exp Int, Exp Int) # decodeFloat :: Exp Double -> (Exp Int64, Exp Int) # encodeFloat :: Exp Int64 -> Exp Int -> Exp Double # exponent :: Exp Double -> Exp Int # significand :: Exp Double -> Exp Double # scaleFloat :: Exp Int -> Exp Double -> Exp Double # isNaN :: Exp Double -> Exp Bool # isInfinite :: Exp Double -> Exp Bool # isDenormalized :: Exp Double -> Exp Bool # isNegativeZero :: Exp Double -> Exp Bool # isIEEE :: Exp Double -> Exp Bool # atan2 :: Exp Double -> Exp Double -> Exp Double #
RealFloat Float #
Instance details Defined in Data.Array.Accelerate.Classes.RealFloat Methods floatRadix :: Exp Float -> Exp Int64 # floatDigits :: Exp Float -> Exp Int # floatRange :: Exp Float -> (Exp Int, Exp Int) # decodeFloat :: Exp Float -> (Exp Int64, Exp Int) # encodeFloat :: Exp Int64 -> Exp Int -> Exp Float # exponent :: Exp Float -> Exp Int # significand :: Exp Float -> Exp Float # scaleFloat :: Exp Int -> Exp Float -> Exp Float # isNaN :: Exp Float -> Exp Bool # isInfinite :: Exp Float -> Exp Bool # isDenormalized :: Exp Float -> Exp Bool # isNegativeZero :: Exp Float -> Exp Bool # isIEEE :: Exp Float -> Exp Bool # atan2 :: Exp Float -> Exp Float -> Exp Float #
RealFloat CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.RealFloat Methods floatRadix :: Exp CFloat -> Exp Int64 # floatDigits :: Exp CFloat -> Exp Int # floatRange :: Exp CFloat -> (Exp Int, Exp Int) # decodeFloat :: Exp CFloat -> (Exp Int64, Exp Int) # encodeFloat :: Exp Int64 -> Exp Int -> Exp CFloat # exponent :: Exp CFloat -> Exp Int # significand :: Exp CFloat -> Exp CFloat # scaleFloat :: Exp Int -> Exp CFloat -> Exp CFloat # isNaN :: Exp CFloat -> Exp Bool # isInfinite :: Exp CFloat -> Exp Bool # isDenormalized :: Exp CFloat -> Exp Bool # isNegativeZero :: Exp CFloat -> Exp Bool # isIEEE :: Exp CFloat -> Exp Bool # atan2 :: Exp CFloat -> Exp CFloat -> Exp CFloat #
RealFloat CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.RealFloat Methods floatRadix :: Exp CDouble -> Exp Int64 # floatDigits :: Exp CDouble -> Exp Int # floatRange :: Exp CDouble -> (Exp Int, Exp Int) # decodeFloat :: Exp CDouble -> (Exp Int64, Exp Int) # encodeFloat :: Exp Int64 -> Exp Int -> Exp CDouble # exponent :: Exp CDouble -> Exp Int # significand :: Exp CDouble -> Exp CDouble # scaleFloat :: Exp Int -> Exp CDouble -> Exp CDouble # isNaN :: Exp CDouble -> Exp Bool # isInfinite :: Exp CDouble -> Exp Bool # isDenormalized :: Exp CDouble -> Exp Bool # isNegativeZero :: Exp CDouble -> Exp Bool # isIEEE :: Exp CDouble -> Exp Bool # atan2 :: Exp CDouble -> Exp CDouble -> Exp CDouble #
RealFloat Half #
Instance details Defined in Data.Array.Accelerate.Classes.RealFloat Methods floatRadix :: Exp Half -> Exp Int64 # floatDigits :: Exp Half -> Exp Int # floatRange :: Exp Half -> (Exp Int, Exp Int) # decodeFloat :: Exp Half -> (Exp Int64, Exp Int) # encodeFloat :: Exp Int64 -> Exp Int -> Exp Half # exponent :: Exp Half -> Exp Int # significand :: Exp Half -> Exp Half # scaleFloat :: Exp Int -> Exp Half -> Exp Half # isNaN :: Exp Half -> Exp Bool # isInfinite :: Exp Half -> Exp Bool # isDenormalized :: Exp Half -> Exp Bool # isNegativeZero :: Exp Half -> Exp Bool # isIEEE :: Exp Half -> Exp Bool # atan2 :: Exp Half -> Exp Half -> Exp Half #

Numeric conversion classes

class FromIntegral a b where #

Accelerate lacks a most-general lossless Integer type, which the standard fromIntegral function uses as an intermediate value when coercing from integral types. Instead, we use this class to capture a direct coercion between two types.

Methods

fromIntegral :: Integral a => Exp a -> Exp b #

General coercion from integral types

Instances

FromIntegral Int Double #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int -> Exp Double #
FromIntegral Int Float #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int -> Exp Float #
FromIntegral Int Int #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int -> Exp Int #
FromIntegral Int Int8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int -> Exp Int8 #
FromIntegral Int Int16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int -> Exp Int16 #
FromIntegral Int Int32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int -> Exp Int32 #
FromIntegral Int Int64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int -> Exp Int64 #
FromIntegral Int Word #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int -> Exp Word #
FromIntegral Int Word8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int -> Exp Word8 #
FromIntegral Int Word16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int -> Exp Word16 #
FromIntegral Int Word32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int -> Exp Word32 #
FromIntegral Int Word64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int -> Exp Word64 #
FromIntegral Int CShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int -> Exp CShort #
FromIntegral Int CUShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int -> Exp CUShort #
FromIntegral Int CInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int -> Exp CInt #
FromIntegral Int CUInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int -> Exp CUInt #
FromIntegral Int CLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int -> Exp CLong #
FromIntegral Int CULong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int -> Exp CULong #
FromIntegral Int CLLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int -> Exp CLLong #
FromIntegral Int CULLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int -> Exp CULLong #
FromIntegral Int CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int -> Exp CFloat #
FromIntegral Int CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int -> Exp CDouble #
FromIntegral Int Half #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int -> Exp Half #
FromIntegral Int8 Double #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int8 -> Exp Double #
FromIntegral Int8 Float #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int8 -> Exp Float #
FromIntegral Int8 Int #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int8 -> Exp Int #
FromIntegral Int8 Int8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int8 -> Exp Int8 #
FromIntegral Int8 Int16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int8 -> Exp Int16 #
FromIntegral Int8 Int32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int8 -> Exp Int32 #
FromIntegral Int8 Int64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int8 -> Exp Int64 #
FromIntegral Int8 Word #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int8 -> Exp Word #
FromIntegral Int8 Word8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int8 -> Exp Word8 #
FromIntegral Int8 Word16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int8 -> Exp Word16 #
FromIntegral Int8 Word32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int8 -> Exp Word32 #
FromIntegral Int8 Word64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int8 -> Exp Word64 #
FromIntegral Int8 CShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int8 -> Exp CShort #
FromIntegral Int8 CUShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int8 -> Exp CUShort #
FromIntegral Int8 CInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int8 -> Exp CInt #
FromIntegral Int8 CUInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int8 -> Exp CUInt #
FromIntegral Int8 CLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int8 -> Exp CLong #
FromIntegral Int8 CULong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int8 -> Exp CULong #
FromIntegral Int8 CLLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int8 -> Exp CLLong #
FromIntegral Int8 CULLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int8 -> Exp CULLong #
FromIntegral Int8 CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int8 -> Exp CFloat #
FromIntegral Int8 CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int8 -> Exp CDouble #
FromIntegral Int8 Half #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int8 -> Exp Half #
FromIntegral Int16 Double #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int16 -> Exp Double #
FromIntegral Int16 Float #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int16 -> Exp Float #
FromIntegral Int16 Int #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int16 -> Exp Int #
FromIntegral Int16 Int8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int16 -> Exp Int8 #
FromIntegral Int16 Int16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int16 -> Exp Int16 #
FromIntegral Int16 Int32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int16 -> Exp Int32 #
FromIntegral Int16 Int64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int16 -> Exp Int64 #
FromIntegral Int16 Word #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int16 -> Exp Word #
FromIntegral Int16 Word8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int16 -> Exp Word8 #
FromIntegral Int16 Word16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int16 -> Exp Word16 #
FromIntegral Int16 Word32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int16 -> Exp Word32 #
FromIntegral Int16 Word64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int16 -> Exp Word64 #
FromIntegral Int16 CShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int16 -> Exp CShort #
FromIntegral Int16 CUShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int16 -> Exp CUShort #
FromIntegral Int16 CInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int16 -> Exp CInt #
FromIntegral Int16 CUInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int16 -> Exp CUInt #
FromIntegral Int16 CLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int16 -> Exp CLong #
FromIntegral Int16 CULong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int16 -> Exp CULong #
FromIntegral Int16 CLLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int16 -> Exp CLLong #
FromIntegral Int16 CULLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int16 -> Exp CULLong #
FromIntegral Int16 CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int16 -> Exp CFloat #
FromIntegral Int16 CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int16 -> Exp CDouble #
FromIntegral Int16 Half #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int16 -> Exp Half #
FromIntegral Int32 Double #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int32 -> Exp Double #
FromIntegral Int32 Float #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int32 -> Exp Float #
FromIntegral Int32 Int #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int32 -> Exp Int #
FromIntegral Int32 Int8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int32 -> Exp Int8 #
FromIntegral Int32 Int16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int32 -> Exp Int16 #
FromIntegral Int32 Int32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int32 -> Exp Int32 #
FromIntegral Int32 Int64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int32 -> Exp Int64 #
FromIntegral Int32 Word #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int32 -> Exp Word #
FromIntegral Int32 Word8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int32 -> Exp Word8 #
FromIntegral Int32 Word16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int32 -> Exp Word16 #
FromIntegral Int32 Word32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int32 -> Exp Word32 #
FromIntegral Int32 Word64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int32 -> Exp Word64 #
FromIntegral Int32 CShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int32 -> Exp CShort #
FromIntegral Int32 CUShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int32 -> Exp CUShort #
FromIntegral Int32 CInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int32 -> Exp CInt #
FromIntegral Int32 CUInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int32 -> Exp CUInt #
FromIntegral Int32 CLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int32 -> Exp CLong #
FromIntegral Int32 CULong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int32 -> Exp CULong #
FromIntegral Int32 CLLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int32 -> Exp CLLong #
FromIntegral Int32 CULLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int32 -> Exp CULLong #
FromIntegral Int32 CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int32 -> Exp CFloat #
FromIntegral Int32 CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int32 -> Exp CDouble #
FromIntegral Int32 Half #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int32 -> Exp Half #
FromIntegral Int64 Double #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int64 -> Exp Double #
FromIntegral Int64 Float #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int64 -> Exp Float #
FromIntegral Int64 Int #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int64 -> Exp Int #
FromIntegral Int64 Int8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int64 -> Exp Int8 #
FromIntegral Int64 Int16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int64 -> Exp Int16 #
FromIntegral Int64 Int32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int64 -> Exp Int32 #
FromIntegral Int64 Int64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int64 -> Exp Int64 #
FromIntegral Int64 Word #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int64 -> Exp Word #
FromIntegral Int64 Word8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int64 -> Exp Word8 #
FromIntegral Int64 Word16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int64 -> Exp Word16 #
FromIntegral Int64 Word32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int64 -> Exp Word32 #
FromIntegral Int64 Word64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int64 -> Exp Word64 #
FromIntegral Int64 CShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int64 -> Exp CShort #
FromIntegral Int64 CUShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int64 -> Exp CUShort #
FromIntegral Int64 CInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int64 -> Exp CInt #
FromIntegral Int64 CUInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int64 -> Exp CUInt #
FromIntegral Int64 CLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int64 -> Exp CLong #
FromIntegral Int64 CULong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int64 -> Exp CULong #
FromIntegral Int64 CLLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int64 -> Exp CLLong #
FromIntegral Int64 CULLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int64 -> Exp CULLong #
FromIntegral Int64 CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int64 -> Exp CFloat #
FromIntegral Int64 CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int64 -> Exp CDouble #
FromIntegral Int64 Half #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int64 -> Exp Half #
FromIntegral Word Double #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word -> Exp Double #
FromIntegral Word Float #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word -> Exp Float #
FromIntegral Word Int #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word -> Exp Int #
FromIntegral Word Int8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word -> Exp Int8 #
FromIntegral Word Int16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word -> Exp Int16 #
FromIntegral Word Int32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word -> Exp Int32 #
FromIntegral Word Int64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word -> Exp Int64 #
FromIntegral Word Word #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word -> Exp Word #
FromIntegral Word Word8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word -> Exp Word8 #
FromIntegral Word Word16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word -> Exp Word16 #
FromIntegral Word Word32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word -> Exp Word32 #
FromIntegral Word Word64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word -> Exp Word64 #
FromIntegral Word CShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word -> Exp CShort #
FromIntegral Word CUShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word -> Exp CUShort #
FromIntegral Word CInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word -> Exp CInt #
FromIntegral Word CUInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word -> Exp CUInt #
FromIntegral Word CLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word -> Exp CLong #
FromIntegral Word CULong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word -> Exp CULong #
FromIntegral Word CLLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word -> Exp CLLong #
FromIntegral Word CULLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word -> Exp CULLong #
FromIntegral Word CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word -> Exp CFloat #
FromIntegral Word CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word -> Exp CDouble #
FromIntegral Word Half #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word -> Exp Half #
FromIntegral Word8 Double #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word8 -> Exp Double #
FromIntegral Word8 Float #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word8 -> Exp Float #
FromIntegral Word8 Int #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word8 -> Exp Int #
FromIntegral Word8 Int8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word8 -> Exp Int8 #
FromIntegral Word8 Int16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word8 -> Exp Int16 #
FromIntegral Word8 Int32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word8 -> Exp Int32 #
FromIntegral Word8 Int64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word8 -> Exp Int64 #
FromIntegral Word8 Word #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word8 -> Exp Word #
FromIntegral Word8 Word8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word8 -> Exp Word8 #
FromIntegral Word8 Word16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word8 -> Exp Word16 #
FromIntegral Word8 Word32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word8 -> Exp Word32 #
FromIntegral Word8 Word64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word8 -> Exp Word64 #
FromIntegral Word8 CShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word8 -> Exp CShort #
FromIntegral Word8 CUShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word8 -> Exp CUShort #
FromIntegral Word8 CInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word8 -> Exp CInt #
FromIntegral Word8 CUInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word8 -> Exp CUInt #
FromIntegral Word8 CLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word8 -> Exp CLong #
FromIntegral Word8 CULong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word8 -> Exp CULong #
FromIntegral Word8 CLLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word8 -> Exp CLLong #
FromIntegral Word8 CULLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word8 -> Exp CULLong #
FromIntegral Word8 CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word8 -> Exp CFloat #
FromIntegral Word8 CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word8 -> Exp CDouble #
FromIntegral Word8 Half #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word8 -> Exp Half #
FromIntegral Word16 Double #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word16 -> Exp Double #
FromIntegral Word16 Float #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word16 -> Exp Float #
FromIntegral Word16 Int #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word16 -> Exp Int #
FromIntegral Word16 Int8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word16 -> Exp Int8 #
FromIntegral Word16 Int16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word16 -> Exp Int16 #
FromIntegral Word16 Int32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word16 -> Exp Int32 #
FromIntegral Word16 Int64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word16 -> Exp Int64 #
FromIntegral Word16 Word #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word16 -> Exp Word #
FromIntegral Word16 Word8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word16 -> Exp Word8 #
FromIntegral Word16 Word16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word16 -> Exp Word16 #
FromIntegral Word16 Word32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word16 -> Exp Word32 #
FromIntegral Word16 Word64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word16 -> Exp Word64 #
FromIntegral Word16 CShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word16 -> Exp CShort #
FromIntegral Word16 CUShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word16 -> Exp CUShort #
FromIntegral Word16 CInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word16 -> Exp CInt #
FromIntegral Word16 CUInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word16 -> Exp CUInt #
FromIntegral Word16 CLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word16 -> Exp CLong #
FromIntegral Word16 CULong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word16 -> Exp CULong #
FromIntegral Word16 CLLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word16 -> Exp CLLong #
FromIntegral Word16 CULLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word16 -> Exp CULLong #
FromIntegral Word16 CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word16 -> Exp CFloat #
FromIntegral Word16 CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word16 -> Exp CDouble #
FromIntegral Word16 Half #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word16 -> Exp Half #
FromIntegral Word32 Double #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word32 -> Exp Double #
FromIntegral Word32 Float #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word32 -> Exp Float #
FromIntegral Word32 Int #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word32 -> Exp Int #
FromIntegral Word32 Int8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word32 -> Exp Int8 #
FromIntegral Word32 Int16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word32 -> Exp Int16 #
FromIntegral Word32 Int32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word32 -> Exp Int32 #
FromIntegral Word32 Int64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word32 -> Exp Int64 #
FromIntegral Word32 Word #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word32 -> Exp Word #
FromIntegral Word32 Word8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word32 -> Exp Word8 #
FromIntegral Word32 Word16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word32 -> Exp Word16 #
FromIntegral Word32 Word32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word32 -> Exp Word32 #
FromIntegral Word32 Word64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word32 -> Exp Word64 #
FromIntegral Word32 CShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word32 -> Exp CShort #
FromIntegral Word32 CUShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word32 -> Exp CUShort #
FromIntegral Word32 CInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word32 -> Exp CInt #
FromIntegral Word32 CUInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word32 -> Exp CUInt #
FromIntegral Word32 CLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word32 -> Exp CLong #
FromIntegral Word32 CULong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word32 -> Exp CULong #
FromIntegral Word32 CLLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word32 -> Exp CLLong #
FromIntegral Word32 CULLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word32 -> Exp CULLong #
FromIntegral Word32 CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word32 -> Exp CFloat #
FromIntegral Word32 CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word32 -> Exp CDouble #
FromIntegral Word32 Half #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word32 -> Exp Half #
FromIntegral Word64 Double #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word64 -> Exp Double #
FromIntegral Word64 Float #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word64 -> Exp Float #
FromIntegral Word64 Int #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word64 -> Exp Int #
FromIntegral Word64 Int8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word64 -> Exp Int8 #
FromIntegral Word64 Int16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word64 -> Exp Int16 #
FromIntegral Word64 Int32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word64 -> Exp Int32 #
FromIntegral Word64 Int64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word64 -> Exp Int64 #
FromIntegral Word64 Word #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word64 -> Exp Word #
FromIntegral Word64 Word8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word64 -> Exp Word8 #
FromIntegral Word64 Word16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word64 -> Exp Word16 #
FromIntegral Word64 Word32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word64 -> Exp Word32 #
FromIntegral Word64 Word64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word64 -> Exp Word64 #
FromIntegral Word64 CShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word64 -> Exp CShort #
FromIntegral Word64 CUShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word64 -> Exp CUShort #
FromIntegral Word64 CInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word64 -> Exp CInt #
FromIntegral Word64 CUInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word64 -> Exp CUInt #
FromIntegral Word64 CLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word64 -> Exp CLong #
FromIntegral Word64 CULong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word64 -> Exp CULong #
FromIntegral Word64 CLLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word64 -> Exp CLLong #
FromIntegral Word64 CULLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word64 -> Exp CULLong #
FromIntegral Word64 CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word64 -> Exp CFloat #
FromIntegral Word64 CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word64 -> Exp CDouble #
FromIntegral Word64 Half #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word64 -> Exp Half #
FromIntegral CShort Double #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CShort -> Exp Double #
FromIntegral CShort Float #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CShort -> Exp Float #
FromIntegral CShort Int #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CShort -> Exp Int #
FromIntegral CShort Int8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CShort -> Exp Int8 #
FromIntegral CShort Int16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CShort -> Exp Int16 #
FromIntegral CShort Int32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CShort -> Exp Int32 #
FromIntegral CShort Int64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CShort -> Exp Int64 #
FromIntegral CShort Word #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CShort -> Exp Word #
FromIntegral CShort Word8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CShort -> Exp Word8 #
FromIntegral CShort Word16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CShort -> Exp Word16 #
FromIntegral CShort Word32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CShort -> Exp Word32 #
FromIntegral CShort Word64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CShort -> Exp Word64 #
FromIntegral CShort CShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CShort -> Exp CShort #
FromIntegral CShort CUShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CShort -> Exp CUShort #
FromIntegral CShort CInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CShort -> Exp CInt #
FromIntegral CShort CUInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CShort -> Exp CUInt #
FromIntegral CShort CLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CShort -> Exp CLong #
FromIntegral CShort CULong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CShort -> Exp CULong #
FromIntegral CShort CLLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CShort -> Exp CLLong #
FromIntegral CShort CULLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CShort -> Exp CULLong #
FromIntegral CShort CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CShort -> Exp CFloat #
FromIntegral CShort CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CShort -> Exp CDouble #
FromIntegral CShort Half #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CShort -> Exp Half #
FromIntegral CUShort Double #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUShort -> Exp Double #
FromIntegral CUShort Float #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUShort -> Exp Float #
FromIntegral CUShort Int #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUShort -> Exp Int #
FromIntegral CUShort Int8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUShort -> Exp Int8 #
FromIntegral CUShort Int16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUShort -> Exp Int16 #
FromIntegral CUShort Int32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUShort -> Exp Int32 #
FromIntegral CUShort Int64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUShort -> Exp Int64 #
FromIntegral CUShort Word #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUShort -> Exp Word #
FromIntegral CUShort Word8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUShort -> Exp Word8 #
FromIntegral CUShort Word16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUShort -> Exp Word16 #
FromIntegral CUShort Word32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUShort -> Exp Word32 #
FromIntegral CUShort Word64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUShort -> Exp Word64 #
FromIntegral CUShort CShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUShort -> Exp CShort #
FromIntegral CUShort CUShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUShort -> Exp CUShort #
FromIntegral CUShort CInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUShort -> Exp CInt #
FromIntegral CUShort CUInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUShort -> Exp CUInt #
FromIntegral CUShort CLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUShort -> Exp CLong #
FromIntegral CUShort CULong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUShort -> Exp CULong #
FromIntegral CUShort CLLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUShort -> Exp CLLong #
FromIntegral CUShort CULLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUShort -> Exp CULLong #
FromIntegral CUShort CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUShort -> Exp CFloat #
FromIntegral CUShort CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUShort -> Exp CDouble #
FromIntegral CUShort Half #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUShort -> Exp Half #
FromIntegral CInt Double #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CInt -> Exp Double #
FromIntegral CInt Float #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CInt -> Exp Float #
FromIntegral CInt Int #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CInt -> Exp Int #
FromIntegral CInt Int8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CInt -> Exp Int8 #
FromIntegral CInt Int16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CInt -> Exp Int16 #
FromIntegral CInt Int32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CInt -> Exp Int32 #
FromIntegral CInt Int64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CInt -> Exp Int64 #
FromIntegral CInt Word #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CInt -> Exp Word #
FromIntegral CInt Word8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CInt -> Exp Word8 #
FromIntegral CInt Word16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CInt -> Exp Word16 #
FromIntegral CInt Word32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CInt -> Exp Word32 #
FromIntegral CInt Word64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CInt -> Exp Word64 #
FromIntegral CInt CShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CInt -> Exp CShort #
FromIntegral CInt CUShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CInt -> Exp CUShort #
FromIntegral CInt CInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CInt -> Exp CInt #
FromIntegral CInt CUInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CInt -> Exp CUInt #
FromIntegral CInt CLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CInt -> Exp CLong #
FromIntegral CInt CULong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CInt -> Exp CULong #
FromIntegral CInt CLLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CInt -> Exp CLLong #
FromIntegral CInt CULLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CInt -> Exp CULLong #
FromIntegral CInt CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CInt -> Exp CFloat #
FromIntegral CInt CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CInt -> Exp CDouble #
FromIntegral CInt Half #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CInt -> Exp Half #
FromIntegral CUInt Double #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUInt -> Exp Double #
FromIntegral CUInt Float #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUInt -> Exp Float #
FromIntegral CUInt Int #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUInt -> Exp Int #
FromIntegral CUInt Int8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUInt -> Exp Int8 #
FromIntegral CUInt Int16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUInt -> Exp Int16 #
FromIntegral CUInt Int32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUInt -> Exp Int32 #
FromIntegral CUInt Int64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUInt -> Exp Int64 #
FromIntegral CUInt Word #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUInt -> Exp Word #
FromIntegral CUInt Word8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUInt -> Exp Word8 #
FromIntegral CUInt Word16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUInt -> Exp Word16 #
FromIntegral CUInt Word32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUInt -> Exp Word32 #
FromIntegral CUInt Word64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUInt -> Exp Word64 #
FromIntegral CUInt CShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUInt -> Exp CShort #
FromIntegral CUInt CUShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUInt -> Exp CUShort #
FromIntegral CUInt CInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUInt -> Exp CInt #
FromIntegral CUInt CUInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUInt -> Exp CUInt #
FromIntegral CUInt CLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUInt -> Exp CLong #
FromIntegral CUInt CULong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUInt -> Exp CULong #
FromIntegral CUInt CLLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUInt -> Exp CLLong #
FromIntegral CUInt CULLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUInt -> Exp CULLong #
FromIntegral CUInt CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUInt -> Exp CFloat #
FromIntegral CUInt CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUInt -> Exp CDouble #
FromIntegral CUInt Half #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUInt -> Exp Half #
FromIntegral CLong Double #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLong -> Exp Double #
FromIntegral CLong Float #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLong -> Exp Float #
FromIntegral CLong Int #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLong -> Exp Int #
FromIntegral CLong Int8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLong -> Exp Int8 #
FromIntegral CLong Int16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLong -> Exp Int16 #
FromIntegral CLong Int32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLong -> Exp Int32 #
FromIntegral CLong Int64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLong -> Exp Int64 #
FromIntegral CLong Word #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLong -> Exp Word #
FromIntegral CLong Word8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLong -> Exp Word8 #
FromIntegral CLong Word16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLong -> Exp Word16 #
FromIntegral CLong Word32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLong -> Exp Word32 #
FromIntegral CLong Word64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLong -> Exp Word64 #
FromIntegral CLong CShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLong -> Exp CShort #
FromIntegral CLong CUShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLong -> Exp CUShort #
FromIntegral CLong CInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLong -> Exp CInt #
FromIntegral CLong CUInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLong -> Exp CUInt #
FromIntegral CLong CLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLong -> Exp CLong #
FromIntegral CLong CULong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLong -> Exp CULong #
FromIntegral CLong CLLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLong -> Exp CLLong #
FromIntegral CLong CULLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLong -> Exp CULLong #
FromIntegral CLong CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLong -> Exp CFloat #
FromIntegral CLong CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLong -> Exp CDouble #
FromIntegral CLong Half #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLong -> Exp Half #
FromIntegral CULong Double #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULong -> Exp Double #
FromIntegral CULong Float #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULong -> Exp Float #
FromIntegral CULong Int #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULong -> Exp Int #
FromIntegral CULong Int8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULong -> Exp Int8 #
FromIntegral CULong Int16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULong -> Exp Int16 #
FromIntegral CULong Int32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULong -> Exp Int32 #
FromIntegral CULong Int64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULong -> Exp Int64 #
FromIntegral CULong Word #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULong -> Exp Word #
FromIntegral CULong Word8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULong -> Exp Word8 #
FromIntegral CULong Word16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULong -> Exp Word16 #
FromIntegral CULong Word32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULong -> Exp Word32 #
FromIntegral CULong Word64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULong -> Exp Word64 #
FromIntegral CULong CShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULong -> Exp CShort #
FromIntegral CULong CUShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULong -> Exp CUShort #
FromIntegral CULong CInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULong -> Exp CInt #
FromIntegral CULong CUInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULong -> Exp CUInt #
FromIntegral CULong CLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULong -> Exp CLong #
FromIntegral CULong CULong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULong -> Exp CULong #
FromIntegral CULong CLLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULong -> Exp CLLong #
FromIntegral CULong CULLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULong -> Exp CULLong #
FromIntegral CULong CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULong -> Exp CFloat #
FromIntegral CULong CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULong -> Exp CDouble #
FromIntegral CULong Half #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULong -> Exp Half #
FromIntegral CLLong Double #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLLong -> Exp Double #
FromIntegral CLLong Float #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLLong -> Exp Float #
FromIntegral CLLong Int #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLLong -> Exp Int #
FromIntegral CLLong Int8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLLong -> Exp Int8 #
FromIntegral CLLong Int16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLLong -> Exp Int16 #
FromIntegral CLLong Int32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLLong -> Exp Int32 #
FromIntegral CLLong Int64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLLong -> Exp Int64 #
FromIntegral CLLong Word #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLLong -> Exp Word #
FromIntegral CLLong Word8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLLong -> Exp Word8 #
FromIntegral CLLong Word16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLLong -> Exp Word16 #
FromIntegral CLLong Word32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLLong -> Exp Word32 #
FromIntegral CLLong Word64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLLong -> Exp Word64 #
FromIntegral CLLong CShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLLong -> Exp CShort #
FromIntegral CLLong CUShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLLong -> Exp CUShort #
FromIntegral CLLong CInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLLong -> Exp CInt #
FromIntegral CLLong CUInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLLong -> Exp CUInt #
FromIntegral CLLong CLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLLong -> Exp CLong #
FromIntegral CLLong CULong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLLong -> Exp CULong #
FromIntegral CLLong CLLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLLong -> Exp CLLong #
FromIntegral CLLong CULLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLLong -> Exp CULLong #
FromIntegral CLLong CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLLong -> Exp CFloat #
FromIntegral CLLong CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLLong -> Exp CDouble #
FromIntegral CLLong Half #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLLong -> Exp Half #
FromIntegral CULLong Double #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULLong -> Exp Double #
FromIntegral CULLong Float #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULLong -> Exp Float #
FromIntegral CULLong Int #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULLong -> Exp Int #
FromIntegral CULLong Int8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULLong -> Exp Int8 #
FromIntegral CULLong Int16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULLong -> Exp Int16 #
FromIntegral CULLong Int32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULLong -> Exp Int32 #
FromIntegral CULLong Int64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULLong -> Exp Int64 #
FromIntegral CULLong Word #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULLong -> Exp Word #
FromIntegral CULLong Word8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULLong -> Exp Word8 #
FromIntegral CULLong Word16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULLong -> Exp Word16 #
FromIntegral CULLong Word32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULLong -> Exp Word32 #
FromIntegral CULLong Word64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULLong -> Exp Word64 #
FromIntegral CULLong CShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULLong -> Exp CShort #
FromIntegral CULLong CUShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULLong -> Exp CUShort #
FromIntegral CULLong CInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULLong -> Exp CInt #
FromIntegral CULLong CUInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULLong -> Exp CUInt #
FromIntegral CULLong CLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULLong -> Exp CLong #
FromIntegral CULLong CULong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULLong -> Exp CULong #
FromIntegral CULLong CLLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULLong -> Exp CLLong #
FromIntegral CULLong CULLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULLong -> Exp CULLong #
FromIntegral CULLong CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULLong -> Exp CFloat #
FromIntegral CULLong CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULLong -> Exp CDouble #
FromIntegral CULLong Half #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULLong -> Exp Half #
(FromIntegral a b, Num b, Elt (Complex b)) => FromIntegral a (Complex b) #
Instance details Defined in Data.Array.Accelerate.Data.Complex Methods fromIntegral :: Exp a -> Exp (Complex b) #

class ToFloating a b where #

Accelerate lacks an arbitrary-precision Rational type, which the standard realToFrac uses as an intermediate value when coercing to floating-point types. Instead, we use this class to capture a direct coercion between to types.

Methods

toFloating :: (Num a, Floating b) => Exp a -> Exp b #

General coercion to floating types

Instances

ToFloating Double Double #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Double -> Exp Double #
ToFloating Double Float #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Double -> Exp Float #
ToFloating Double CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Double -> Exp CFloat #
ToFloating Double CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Double -> Exp CDouble #
ToFloating Double Half #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Double -> Exp Half #
ToFloating Float Double #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Float -> Exp Double #
ToFloating Float Float #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Float -> Exp Float #
ToFloating Float CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Float -> Exp CFloat #
ToFloating Float CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Float -> Exp CDouble #
ToFloating Float Half #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Float -> Exp Half #
ToFloating Int Double #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int -> Exp Double #
ToFloating Int Float #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int -> Exp Float #
ToFloating Int CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int -> Exp CFloat #
ToFloating Int CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int -> Exp CDouble #
ToFloating Int Half #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int -> Exp Half #
ToFloating Int8 Double #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int8 -> Exp Double #
ToFloating Int8 Float #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int8 -> Exp Float #
ToFloating Int8 CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int8 -> Exp CFloat #
ToFloating Int8 CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int8 -> Exp CDouble #
ToFloating Int8 Half #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int8 -> Exp Half #
ToFloating Int16 Double #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int16 -> Exp Double #
ToFloating Int16 Float #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int16 -> Exp Float #
ToFloating Int16 CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int16 -> Exp CFloat #
ToFloating Int16 CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int16 -> Exp CDouble #
ToFloating Int16 Half #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int16 -> Exp Half #
ToFloating Int32 Double #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int32 -> Exp Double #
ToFloating Int32 Float #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int32 -> Exp Float #
ToFloating Int32 CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int32 -> Exp CFloat #
ToFloating Int32 CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int32 -> Exp CDouble #
ToFloating Int32 Half #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int32 -> Exp Half #
ToFloating Int64 Double #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int64 -> Exp Double #
ToFloating Int64 Float #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int64 -> Exp Float #
ToFloating Int64 CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int64 -> Exp CFloat #
ToFloating Int64 CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int64 -> Exp CDouble #
ToFloating Int64 Half #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int64 -> Exp Half #
ToFloating Word Double #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word -> Exp Double #
ToFloating Word Float #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word -> Exp Float #
ToFloating Word CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word -> Exp CFloat #
ToFloating Word CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word -> Exp CDouble #
ToFloating Word Half #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word -> Exp Half #
ToFloating Word8 Double #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word8 -> Exp Double #
ToFloating Word8 Float #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word8 -> Exp Float #
ToFloating Word8 CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word8 -> Exp CFloat #
ToFloating Word8 CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word8 -> Exp CDouble #
ToFloating Word8 Half #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word8 -> Exp Half #
ToFloating Word16 Double #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word16 -> Exp Double #
ToFloating Word16 Float #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word16 -> Exp Float #
ToFloating Word16 CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word16 -> Exp CFloat #
ToFloating Word16 CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word16 -> Exp CDouble #
ToFloating Word16 Half #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word16 -> Exp Half #
ToFloating Word32 Double #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word32 -> Exp Double #
ToFloating Word32 Float #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word32 -> Exp Float #
ToFloating Word32 CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word32 -> Exp CFloat #
ToFloating Word32 CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word32 -> Exp CDouble #
ToFloating Word32 Half #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word32 -> Exp Half #
ToFloating Word64 Double #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word64 -> Exp Double #
ToFloating Word64 Float #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word64 -> Exp Float #
ToFloating Word64 CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word64 -> Exp CFloat #
ToFloating Word64 CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word64 -> Exp CDouble #
ToFloating Word64 Half #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word64 -> Exp Half #
ToFloating CShort Double #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CShort -> Exp Double #
ToFloating CShort Float #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CShort -> Exp Float #
ToFloating CShort CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CShort -> Exp CFloat #
ToFloating CShort CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CShort -> Exp CDouble #
ToFloating CShort Half #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CShort -> Exp Half #
ToFloating CUShort Double #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CUShort -> Exp Double #
ToFloating CUShort Float #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CUShort -> Exp Float #
ToFloating CUShort CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CUShort -> Exp CFloat #
ToFloating CUShort CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CUShort -> Exp CDouble #
ToFloating CUShort Half #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CUShort -> Exp Half #
ToFloating CInt Double #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CInt -> Exp Double #
ToFloating CInt Float #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CInt -> Exp Float #
ToFloating CInt CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CInt -> Exp CFloat #
ToFloating CInt CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CInt -> Exp CDouble #
ToFloating CInt Half #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CInt -> Exp Half #
ToFloating CUInt Double #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CUInt -> Exp Double #
ToFloating CUInt Float #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CUInt -> Exp Float #
ToFloating CUInt CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CUInt -> Exp CFloat #
ToFloating CUInt CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CUInt -> Exp CDouble #
ToFloating CUInt Half #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CUInt -> Exp Half #
ToFloating CLong Double #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CLong -> Exp Double #
ToFloating CLong Float #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CLong -> Exp Float #
ToFloating CLong CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CLong -> Exp CFloat #
ToFloating CLong CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CLong -> Exp CDouble #
ToFloating CLong Half #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CLong -> Exp Half #
ToFloating CULong Double #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CULong -> Exp Double #
ToFloating CULong Float #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CULong -> Exp Float #
ToFloating CULong CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CULong -> Exp CFloat #
ToFloating CULong CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CULong -> Exp CDouble #
ToFloating CULong Half #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CULong -> Exp Half #
ToFloating CLLong Double #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CLLong -> Exp Double #
ToFloating CLLong Float #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CLLong -> Exp Float #
ToFloating CLLong CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CLLong -> Exp CFloat #
ToFloating CLLong CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CLLong -> Exp CDouble #
ToFloating CLLong Half #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CLLong -> Exp Half #
ToFloating CULLong Double #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CULLong -> Exp Double #
ToFloating CULLong Float #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CULLong -> Exp Float #
ToFloating CULLong CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CULLong -> Exp CFloat #
ToFloating CULLong CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CULLong -> Exp CDouble #
ToFloating CULLong Half #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CULLong -> Exp Half #
ToFloating CFloat Double #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CFloat -> Exp Double #
ToFloating CFloat Float #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CFloat -> Exp Float #
ToFloating CFloat CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CFloat -> Exp CFloat #
ToFloating CFloat CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CFloat -> Exp CDouble #
ToFloating CFloat Half #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CFloat -> Exp Half #
ToFloating CDouble Double #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CDouble -> Exp Double #
ToFloating CDouble Float #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CDouble -> Exp Float #
ToFloating CDouble CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CDouble -> Exp CFloat #
ToFloating CDouble CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CDouble -> Exp CDouble #
ToFloating CDouble Half #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CDouble -> Exp Half #
ToFloating Half Double #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Half -> Exp Double #
ToFloating Half Float #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Half -> Exp Float #
ToFloating Half CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Half -> Exp CFloat #
ToFloating Half CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Half -> Exp CDouble #
ToFloating Half Half #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating 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.

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 #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain Bool :: Type # Methods lift :: Bool -> Exp (Plain Bool) #
Lift Exp Char #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain Char :: Type # Methods lift :: Char -> Exp (Plain Char) #
Lift Exp Double #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain Double :: Type # Methods lift :: Double -> Exp (Plain Double) #
Lift Exp Float #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain Float :: Type # Methods lift :: Float -> Exp (Plain Float) #
Lift Exp Int #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain Int :: Type # Methods lift :: Int -> Exp (Plain Int) #
Lift Exp Int8 #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain Int8 :: Type # Methods lift :: Int8 -> Exp (Plain Int8) #
Lift Exp Int16 #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain Int16 :: Type # Methods lift :: Int16 -> Exp (Plain Int16) #
Lift Exp Int32 #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain Int32 :: Type # Methods lift :: Int32 -> Exp (Plain Int32) #
Lift Exp Int64 #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain Int64 :: Type # Methods lift :: Int64 -> Exp (Plain Int64) #
Lift Exp Word #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain Word :: Type # Methods lift :: Word -> Exp (Plain Word) #
Lift Exp Word8 #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain Word8 :: Type # Methods lift :: Word8 -> Exp (Plain Word8) #
Lift Exp Word16 #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain Word16 :: Type # Methods lift :: Word16 -> Exp (Plain Word16) #
Lift Exp Word32 #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain Word32 :: Type # Methods lift :: Word32 -> Exp (Plain Word32) #
Lift Exp Word64 #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain Word64 :: Type # Methods lift :: Word64 -> Exp (Plain Word64) #
Lift Exp () #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain () :: Type # Methods lift :: () -> Exp (Plain ()) #
Lift Exp CChar #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain CChar :: Type # Methods lift :: CChar -> Exp (Plain CChar) #
Lift Exp CSChar #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain CSChar :: Type # Methods lift :: CSChar -> Exp (Plain CSChar) #
Lift Exp CUChar #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain CUChar :: Type # Methods lift :: CUChar -> Exp (Plain CUChar) #
Lift Exp CShort #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain CShort :: Type # Methods lift :: CShort -> Exp (Plain CShort) #
Lift Exp CUShort #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain CUShort :: Type # Methods lift :: CUShort -> Exp (Plain CUShort) #
Lift Exp CInt #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain CInt :: Type # Methods lift :: CInt -> Exp (Plain CInt) #
Lift Exp CUInt #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain CUInt :: Type # Methods lift :: CUInt -> Exp (Plain CUInt) #
Lift Exp CLong #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain CLong :: Type # Methods lift :: CLong -> Exp (Plain CLong) #
Lift Exp CULong #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain CULong :: Type # Methods lift :: CULong -> Exp (Plain CULong) #
Lift Exp CLLong #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain CLLong :: Type # Methods lift :: CLLong -> Exp (Plain CLLong) #
Lift Exp CULLong #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain CULLong :: Type # Methods lift :: CULLong -> Exp (Plain CULLong) #
Lift Exp CFloat #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain CFloat :: Type # Methods lift :: CFloat -> Exp (Plain CFloat) #
Lift Exp CDouble #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain CDouble :: Type # Methods lift :: CDouble -> Exp (Plain CDouble) #
Lift Exp Z #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain Z :: Type # Methods lift :: Z -> Exp (Plain Z) #
(Lift Exp a, Elt (Plain a)) => Lift Exp (Maybe a) #
Instance details Defined in Data.Array.Accelerate.Data.Maybe Associated Types type Plain (Maybe a) :: Type # Methods lift :: Maybe a -> Exp (Plain (Maybe a)) #
(Lift Exp a, Elt (Plain a), Elt (Complex (Plain a))) => Lift Exp (Complex a) #
Instance details Defined in Data.Array.Accelerate.Data.Complex Associated Types type Plain (Complex a) :: Type # Methods lift :: Complex a -> Exp (Plain (Complex a)) #
(Lift Exp a, Elt (Plain a)) => Lift Exp (Min a) #
Instance details Defined in Data.Array.Accelerate.Data.Semigroup Associated Types type Plain (Min a) :: Type # Methods lift :: Min a -> Exp (Plain (Min a)) #
(Lift Exp a, Elt (Plain a)) => Lift Exp (Max a) #
Instance details Defined in Data.Array.Accelerate.Data.Semigroup Associated Types type Plain (Max a) :: Type # Methods lift :: Max a -> Exp (Plain (Max a)) #
(Lift Exp a, Elt (Plain a)) => Lift Exp (Sum a) #
Instance details Defined in Data.Array.Accelerate.Data.Monoid Associated Types type Plain (Sum a) :: Type # Methods lift :: Sum a -> Exp (Plain (Sum a)) #
(Lift Exp a, Elt (Plain a)) => Lift Exp (Product a) #
Instance details Defined in Data.Array.Accelerate.Data.Monoid Associated Types type Plain (Product a) :: Type # Methods lift :: Product a -> Exp (Plain (Product a)) #
Shape sh => Lift Exp (Any sh) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (Any sh) :: Type # Methods lift :: Any sh -> Exp (Plain (Any sh)) #
Lift Exp (Exp e) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (Exp e) :: Type # Methods lift :: Exp e -> Exp (Plain (Exp e)) #
Lift Acc (Acc a) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (Acc a) :: Type # 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) #
Instance details Defined in Data.Array.Accelerate.Data.Either Associated Types type Plain (Either a b) :: Type # 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) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (a, b) :: Type # Methods lift :: (a, b) -> Exp (Plain (a, b)) #
(Elt e, Slice (Plain ix), Lift Exp ix) => Lift Exp (ix :. Exp e) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (ix :. Exp e) :: Type # Methods lift :: (ix :. Exp e) -> Exp (Plain (ix :. Exp e)) #
(Slice (Plain ix), Lift Exp ix) => Lift Exp (ix :. All) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (ix :. All) :: Type # Methods lift :: (ix :. All) -> Exp (Plain (ix :. All)) #
(Slice (Plain ix), Lift Exp ix) => Lift Exp (ix :. Int) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (ix :. Int) :: Type # Methods lift :: (ix :. Int) -> Exp (Plain (ix :. Int)) #
(Lift Acc a, Lift Acc b, Arrays (Plain a), Arrays (Plain b)) => Lift Acc (a, b) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (a, b) :: Type # Methods lift :: (a, b) -> Acc (Plain (a, b)) #
(Shape sh, Elt e) => Lift Acc (Array sh e) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (Array sh e) :: Type # 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) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (a, b, c) :: Type # 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) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (a, b, c) :: Type # 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) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (a, b, c, d) :: Type # 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) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (a, b, c, d) :: Type # 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) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (a, b, c, d, e) :: Type # 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) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (a, b, c, d, e) :: Type # 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) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (a, b, c, d, e, f) :: Type # 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) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (a, b, c, d, e, f) :: Type # 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) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (a, b, c, d, e, f, g) :: Type # 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) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (a, b, c, d, e, f, g) :: Type # 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) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (a, b, c, d, e, f, g, h) :: Type # 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) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (a, b, c, d, e, f, g, h) :: Type # 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) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (a, b, c, d, e, f, g, h, i) :: Type # 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) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (a, b, c, d, e, f, g, h, i) :: Type # 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) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (a, b, c, d, e, f, g, h, i, j) :: Type # 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) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (a, b, c, d, e, f, g, h, i, j) :: Type # 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) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (a, b, c, d, e, f, g, h, i, j, k) :: Type # 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) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (a, b, c, d, e, f, g, h, i, j, k) :: Type # 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) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (a, b, c, d, e, f, g, h, i, j, k, l) :: Type # 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) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (a, b, c, d, e, f, g, h, i, j, k, l) :: Type # 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) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (a, b, c, d, e, f, g, h, i, j, k, l, m) :: Type # 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) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (a, b, c, d, e, f, g, h, i, j, k, l, m) :: Type # 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) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (a, b, c, d, e, f, g, h, i, j, k, l, m, n) :: Type # 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) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (a, b, c, d, e, f, g, h, i, j, k, l, m, n) :: Type # 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) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) :: Type # 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) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) :: Type # 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.

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 () #
Instance details Defined in Data.Array.Accelerate.Lift Methods unlift :: Exp (Plain ()) -> () #
Unlift Exp Z #
Instance details Defined in Data.Array.Accelerate.Lift Methods unlift :: Exp (Plain Z) -> Z #
(Elt a, Elt (Complex a)) => Unlift Exp (Complex (Exp a)) #
Instance details Defined in Data.Array.Accelerate.Data.Complex Methods unlift :: Exp (Plain (Complex (Exp a))) -> Complex (Exp a) #
Elt a => Unlift Exp (Min (Exp a)) #
Instance details Defined in Data.Array.Accelerate.Data.Semigroup Methods unlift :: Exp (Plain (Min (Exp a))) -> Min (Exp a) #
Elt a => Unlift Exp (Max (Exp a)) #
Instance details Defined in Data.Array.Accelerate.Data.Semigroup Methods unlift :: Exp (Plain (Max (Exp a))) -> Max (Exp a) #
Elt a => Unlift Exp (Sum (Exp a)) #
Instance details Defined in Data.Array.Accelerate.Data.Monoid Methods unlift :: Exp (Plain (Sum (Exp a))) -> Sum (Exp a) #
Elt a => Unlift Exp (Product (Exp a)) #
Instance details Defined in Data.Array.Accelerate.Data.Monoid Methods unlift :: Exp (Plain (Product (Exp a))) -> Product (Exp a) #
Unlift Exp (Exp e) #
Instance details Defined in Data.Array.Accelerate.Lift Methods unlift :: Exp (Plain (Exp e)) -> Exp e #
Unlift Acc (Acc a) #
Instance details Defined in Data.Array.Accelerate.Lift Methods unlift :: Acc (Plain (Acc a)) -> Acc a #
(Elt a, Elt b) => Unlift Exp (Exp a, Exp b) #
Instance details Defined in Data.Array.Accelerate.Lift 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) #
Instance details Defined in Data.Array.Accelerate.Lift Methods unlift :: Exp (Plain (ix :. Exp e)) -> ix :. Exp e #
(Elt e, Slice ix) => Unlift Exp (Exp ix :. Exp e) #
Instance details Defined in Data.Array.Accelerate.Lift Methods unlift :: Exp (Plain (Exp ix :. Exp e)) -> Exp ix :. Exp e #
(Arrays a, Arrays b) => Unlift Acc (Acc a, Acc b) #
Instance details Defined in Data.Array.Accelerate.Lift 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) #
Instance details Defined in Data.Array.Accelerate.Lift 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) #
Instance details Defined in Data.Array.Accelerate.Lift 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) #
Instance details Defined in Data.Array.Accelerate.Lift 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) #
Instance details Defined in Data.Array.Accelerate.Lift 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) #
Instance details Defined in Data.Array.Accelerate.Lift 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) #
Instance details Defined in Data.Array.Accelerate.Lift 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) #
Instance details Defined in Data.Array.Accelerate.Lift 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) #
Instance details Defined in Data.Array.Accelerate.Lift 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) #
Instance details Defined in Data.Array.Accelerate.Lift 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) #
Instance details Defined in Data.Array.Accelerate.Lift 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) #
Instance details Defined in Data.Array.Accelerate.Lift 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) #
Instance details Defined in Data.Array.Accelerate.Lift 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) #
Instance details Defined in Data.Array.Accelerate.Lift 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) #
Instance details Defined in Data.Array.Accelerate.Lift 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) #
Instance details Defined in Data.Array.Accelerate.Lift 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) #
Instance details Defined in Data.Array.Accelerate.Lift 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) #
Instance details Defined in Data.Array.Accelerate.Lift 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) #
Instance details Defined in Data.Array.Accelerate.Lift 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) #
Instance details Defined in Data.Array.Accelerate.Lift 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) #
Instance details Defined in Data.Array.Accelerate.Lift 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) #
Instance details Defined in Data.Array.Accelerate.Lift 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) #
Instance details Defined in Data.Array.Accelerate.Lift 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) #
Instance details Defined in Data.Array.Accelerate.Lift 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) #
Instance details Defined in Data.Array.Accelerate.Lift 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) #
Instance details Defined in Data.Array.Accelerate.Lift 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) #
Instance details Defined in Data.Array.Accelerate.Lift 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.

Note that ($) is levity-polymorphic in its result type, so that foo $ True where foo :: Bool -> Int# is well-typed

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: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: Int # maxBound :: Int #
Enum Int	Since: base-2.1
Instance details Defined in GHC.Enum Methods succ :: Int -> Int # pred :: Int -> Int # toEnum :: Int -> Int # fromEnum :: Int -> Int # enumFrom :: Int -> [Int] # enumFromThen :: Int -> Int -> [Int] # enumFromTo :: Int -> Int -> [Int] # enumFromThenTo :: Int -> Int -> Int -> [Int] #
Eq Int
Instance details Defined in GHC.Classes Methods (==) :: Int -> Int -> Bool # (/=) :: Int -> Int -> Bool #
Integral Int	Since: base-2.0.1
Instance details Defined in GHC.Real Methods quot :: Int -> Int -> Int # rem :: Int -> Int -> Int # div :: Int -> Int -> Int # mod :: Int -> Int -> Int # quotRem :: Int -> Int -> (Int, Int) # divMod :: Int -> Int -> (Int, Int) # toInteger :: Int -> Integer #
Num Int	Since: base-2.1
Instance details Defined in GHC.Num Methods (+) :: Int -> Int -> Int # (-) :: Int -> Int -> Int # (*) :: Int -> Int -> Int # negate :: Int -> Int # abs :: Int -> Int # signum :: Int -> Int # fromInteger :: Integer -> Int #
Ord Int
Instance details Defined in GHC.Classes Methods compare :: Int -> Int -> Ordering # (<) :: Int -> Int -> Bool # (<=) :: Int -> Int -> Bool # (>) :: Int -> Int -> Bool # (>=) :: Int -> Int -> Bool # max :: Int -> Int -> Int # min :: Int -> Int -> Int #
Read Int	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Int # readList :: ReadS [Int] # readPrec :: ReadPrec Int # readListPrec :: ReadPrec [Int] #
Real Int	Since: base-2.0.1
Instance details Defined in GHC.Real Methods toRational :: Int -> Rational #
Show Int	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Int -> ShowS # show :: Int -> String # showList :: [Int] -> ShowS #
Lift Int
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Int -> Q Exp #
Pretty Int
Instance details Defined in Text.PrettyPrint.ANSI.Leijen.Internal Methods pretty :: Int -> Doc # prettyList :: [Int] -> Doc #
PrintfArg Int	Since: base-2.1
Instance details Defined in Text.Printf Methods formatArg :: Int -> FieldFormatter # parseFormat :: Int -> ModifierParser #
Storable Int	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Int -> Int # alignment :: Int -> Int # peekElemOff :: Ptr Int -> Int -> IO Int # pokeElemOff :: Ptr Int -> Int -> Int -> IO () # peekByteOff :: Ptr b -> Int -> IO Int # pokeByteOff :: Ptr b -> Int -> Int -> IO () # peek :: Ptr Int -> IO Int # poke :: Ptr Int -> Int -> IO () #
Bits Int	Since: base-2.1
Instance details Defined in Data.Bits Methods (.&.) :: Int -> Int -> Int # (.\|.) :: Int -> Int -> Int # xor :: Int -> Int -> Int # complement :: Int -> Int # shift :: Int -> Int -> Int # rotate :: Int -> Int -> Int # zeroBits :: Int # bit :: Int -> Int # setBit :: Int -> Int -> Int # clearBit :: Int -> Int -> Int # complementBit :: Int -> Int -> Int # testBit :: Int -> Int -> Bool # bitSizeMaybe :: Int -> Maybe Int # bitSize :: Int -> Int # isSigned :: Int -> Bool # shiftL :: Int -> Int -> Int # unsafeShiftL :: Int -> Int -> Int # shiftR :: Int -> Int -> Int # unsafeShiftR :: Int -> Int -> Int # rotateL :: Int -> Int -> Int # rotateR :: Int -> Int -> Int # popCount :: Int -> Int #
FiniteBits Int	Since: base-4.6.0.0
Instance details Defined in Data.Bits Methods finiteBitSize :: Int -> Int # countLeadingZeros :: Int -> Int # countTrailingZeros :: Int -> Int #
PrimType Int
Instance details Defined in Basement.PrimType Associated Types type PrimSize Int :: Nat # Methods primSizeInBytes :: Proxy Int -> CountOf Word8 # primShiftToBytes :: Proxy Int -> Int # primBaUIndex :: ByteArray# -> Offset Int -> Int # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Int -> prim Int # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Int -> Int -> prim () # primAddrIndex :: Addr# -> Offset Int -> Int # primAddrRead :: PrimMonad prim => Addr# -> Offset Int -> prim Int # primAddrWrite :: PrimMonad prim => Addr# -> Offset Int -> Int -> prim () #
PrimMemoryComparable Int
Instance details Defined in Basement.PrimType
Subtractive Int
Instance details Defined in Basement.Numerical.Subtractive Associated Types type Difference Int :: Type # Methods (-) :: Int -> Int -> Difference Int #
NFData Int
Instance details Defined in Control.DeepSeq Methods rnf :: Int -> () #
Hashable Int
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Int -> Int # hash :: Int -> Int #
Prim Int
Instance details Defined in Data.Primitive.Types Methods sizeOf# :: Int -> Int# # alignment# :: Int -> Int# # indexByteArray# :: ByteArray# -> Int# -> Int # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, Int#) # writeByteArray# :: MutableByteArray# s -> Int# -> Int -> State# s -> State# s # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Int -> State# s -> State# s # indexOffAddr# :: Addr# -> Int# -> Int # readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, Int#) # writeOffAddr# :: Addr# -> Int# -> Int -> State# s -> State# s # setOffAddr# :: Addr# -> Int# -> Int# -> Int -> State# s -> State# s #
Unbox Int
Instance details Defined in Data.Vector.Unboxed.Base
Pretty Int
Instance details Defined in Text.PrettyPrint.Annotated.WL Methods pretty :: Int -> Doc b # prettyList :: [Int] -> Doc b #
IsScalar Int #
Instance details Defined in Data.Array.Accelerate.Type Methods scalarType :: ScalarType Int
IsBounded Int #
Instance details Defined in Data.Array.Accelerate.Type Methods boundedType :: BoundedType Int
IsNum Int #
Instance details Defined in Data.Array.Accelerate.Type Methods numType :: NumType Int
IsIntegral Int #
Instance details Defined in Data.Array.Accelerate.Type Methods integralType :: IntegralType Int
Elt Int #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods eltType :: Int -> TupleType (EltRepr Int) fromElt :: Int -> EltRepr Int toElt :: EltRepr Int -> Int
Eq Int #
Instance details Defined in Data.Array.Accelerate.Classes.Eq Methods (==) :: Exp Int -> Exp Int -> Exp Bool # (/=) :: Exp Int -> Exp Int -> Exp Bool #
Ord Int #
Instance details Defined in Data.Array.Accelerate.Classes.Ord Methods (<) :: Exp Int -> Exp Int -> Exp Bool # (>) :: Exp Int -> Exp Int -> Exp Bool # (<=) :: Exp Int -> Exp Int -> Exp Bool # (>=) :: Exp Int -> Exp Int -> Exp Bool # min :: Exp Int -> Exp Int -> Exp Int # max :: Exp Int -> Exp Int -> Exp Int # compare :: Exp Int -> Exp Int -> Exp Ordering #
FiniteBits Int #
Instance details Defined in Data.Array.Accelerate.Data.Bits Methods finiteBitSize :: Exp Int -> Exp Int # countLeadingZeros :: Exp Int -> Exp Int # countTrailingZeros :: Exp Int -> Exp Int #
Bits Int #
Instance details Defined in Data.Array.Accelerate.Data.Bits Methods (.&.) :: Exp Int -> Exp Int -> Exp Int # (.\|.) :: Exp Int -> Exp Int -> Exp Int # xor :: Exp Int -> Exp Int -> Exp Int # complement :: Exp Int -> Exp Int # shift :: Exp Int -> Exp Int -> Exp Int # rotate :: Exp Int -> Exp Int -> Exp Int # zeroBits :: Exp Int # bit :: Exp Int -> Exp Int # setBit :: Exp Int -> Exp Int -> Exp Int # clearBit :: Exp Int -> Exp Int -> Exp Int # complementBit :: Exp Int -> Exp Int -> Exp Int # testBit :: Exp Int -> Exp Int -> Exp Bool # isSigned :: Exp Int -> Exp Bool # shiftL :: Exp Int -> Exp Int -> Exp Int # unsafeShiftL :: Exp Int -> Exp Int -> Exp Int # shiftR :: Exp Int -> Exp Int -> Exp Int # unsafeShiftR :: Exp Int -> Exp Int -> Exp Int # rotateL :: Exp Int -> Exp Int -> Exp Int # rotateR :: Exp Int -> Exp Int -> Exp Int # popCount :: Exp Int -> Exp Int #
Vector Vector Int
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Int -> m (Vector Int) # basicUnsafeThaw :: PrimMonad m => Vector Int -> m (Mutable Vector (PrimState m) Int) # basicLength :: Vector Int -> Int # basicUnsafeSlice :: Int -> Int -> Vector Int -> Vector Int # basicUnsafeIndexM :: Monad m => Vector Int -> Int -> m Int # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Int -> Vector Int -> m () # elemseq :: Vector Int -> Int -> b -> b #
FunctorWithIndex Int []	The position in the list is available as the index.
Instance details Defined in Control.Lens.Indexed Methods imap :: (Int -> a -> b) -> [a] -> [b] # imapped :: IndexedSetter Int [a] [b] a b #
FunctorWithIndex Int ZipList	Same instance as for `[]`.
Instance details Defined in Control.Lens.Indexed Methods imap :: (Int -> a -> b) -> ZipList a -> ZipList b # imapped :: IndexedSetter Int (ZipList a) (ZipList b) a b #
FunctorWithIndex Int NonEmpty
Instance details Defined in Control.Lens.Indexed Methods imap :: (Int -> a -> b) -> NonEmpty a -> NonEmpty b # imapped :: IndexedSetter Int (NonEmpty a) (NonEmpty b) a b #
FunctorWithIndex Int IntMap
Instance details Defined in Control.Lens.Indexed Methods imap :: (Int -> a -> b) -> IntMap a -> IntMap b # imapped :: IndexedSetter Int (IntMap a) (IntMap b) a b #
FunctorWithIndex Int Seq	The position in the `Seq` is available as the index.
Instance details Defined in Control.Lens.Indexed Methods imap :: (Int -> a -> b) -> Seq a -> Seq b # imapped :: IndexedSetter Int (Seq a) (Seq b) a b #
FunctorWithIndex Int Vector
Instance details Defined in Control.Lens.Indexed Methods imap :: (Int -> a -> b) -> Vector a -> Vector b # imapped :: IndexedSetter Int (Vector a) (Vector b) a b #
FoldableWithIndex Int []
Instance details Defined in Control.Lens.Indexed Methods ifoldMap :: Monoid m => (Int -> a -> m) -> [a] -> m # ifolded :: IndexedFold Int [a] a # ifoldr :: (Int -> a -> b -> b) -> b -> [a] -> b # ifoldl :: (Int -> b -> a -> b) -> b -> [a] -> b # ifoldr' :: (Int -> a -> b -> b) -> b -> [a] -> b # ifoldl' :: (Int -> b -> a -> b) -> b -> [a] -> b #
FoldableWithIndex Int ZipList
Instance details Defined in Control.Lens.Indexed Methods ifoldMap :: Monoid m => (Int -> a -> m) -> ZipList a -> m # ifolded :: IndexedFold Int (ZipList a) a # ifoldr :: (Int -> a -> b -> b) -> b -> ZipList a -> b # ifoldl :: (Int -> b -> a -> b) -> b -> ZipList a -> b # ifoldr' :: (Int -> a -> b -> b) -> b -> ZipList a -> b # ifoldl' :: (Int -> b -> a -> b) -> b -> ZipList a -> b #
FoldableWithIndex Int NonEmpty
Instance details Defined in Control.Lens.Indexed Methods ifoldMap :: Monoid m => (Int -> a -> m) -> NonEmpty a -> m # ifolded :: IndexedFold Int (NonEmpty a) a # ifoldr :: (Int -> a -> b -> b) -> b -> NonEmpty a -> b # ifoldl :: (Int -> b -> a -> b) -> b -> NonEmpty a -> b # ifoldr' :: (Int -> a -> b -> b) -> b -> NonEmpty a -> b # ifoldl' :: (Int -> b -> a -> b) -> b -> NonEmpty a -> b #
FoldableWithIndex Int IntMap
Instance details Defined in Control.Lens.Indexed Methods ifoldMap :: Monoid m => (Int -> a -> m) -> IntMap a -> m # ifolded :: IndexedFold Int (IntMap a) a # ifoldr :: (Int -> a -> b -> b) -> b -> IntMap a -> b # ifoldl :: (Int -> b -> a -> b) -> b -> IntMap a -> b # ifoldr' :: (Int -> a -> b -> b) -> b -> IntMap a -> b # ifoldl' :: (Int -> b -> a -> b) -> b -> IntMap a -> b #
FoldableWithIndex Int Seq
Instance details Defined in Control.Lens.Indexed Methods ifoldMap :: Monoid m => (Int -> a -> m) -> Seq a -> m # ifolded :: IndexedFold Int (Seq a) a # ifoldr :: (Int -> a -> b -> b) -> b -> Seq a -> b # ifoldl :: (Int -> b -> a -> b) -> b -> Seq a -> b # ifoldr' :: (Int -> a -> b -> b) -> b -> Seq a -> b # ifoldl' :: (Int -> b -> a -> b) -> b -> Seq a -> b #
FoldableWithIndex Int Vector
Instance details Defined in Control.Lens.Indexed Methods ifoldMap :: Monoid m => (Int -> a -> m) -> Vector a -> m # ifolded :: IndexedFold Int (Vector a) a # ifoldr :: (Int -> a -> b -> b) -> b -> Vector a -> b # ifoldl :: (Int -> b -> a -> b) -> b -> Vector a -> b # ifoldr' :: (Int -> a -> b -> b) -> b -> Vector a -> b # ifoldl' :: (Int -> b -> a -> b) -> b -> Vector a -> b #
TraversableWithIndex Int []
Instance details Defined in Control.Lens.Indexed Methods itraverse :: Applicative f => (Int -> a -> f b) -> [a] -> f [b] # itraversed :: IndexedTraversal Int [a] [b] a b #
TraversableWithIndex Int ZipList
Instance details Defined in Control.Lens.Indexed Methods itraverse :: Applicative f => (Int -> a -> f b) -> ZipList a -> f (ZipList b) # itraversed :: IndexedTraversal Int (ZipList a) (ZipList b) a b #
TraversableWithIndex Int NonEmpty
Instance details Defined in Control.Lens.Indexed Methods itraverse :: Applicative f => (Int -> a -> f b) -> NonEmpty a -> f (NonEmpty b) # itraversed :: IndexedTraversal Int (NonEmpty a) (NonEmpty b) a b #
TraversableWithIndex Int IntMap
Instance details Defined in Control.Lens.Indexed Methods itraverse :: Applicative f => (Int -> a -> f b) -> IntMap a -> f (IntMap b) # itraversed :: IndexedTraversal Int (IntMap a) (IntMap b) a b #
TraversableWithIndex Int Seq
Instance details Defined in Control.Lens.Indexed Methods itraverse :: Applicative f => (Int -> a -> f b) -> Seq a -> f (Seq b) # itraversed :: IndexedTraversal Int (Seq a) (Seq b) a b #
TraversableWithIndex Int Vector
Instance details Defined in Control.Lens.Indexed Methods itraverse :: Applicative f => (Int -> a -> f b) -> Vector a -> f (Vector b) # itraversed :: IndexedTraversal Int (Vector a) (Vector b) a b #
TraverseMin Int IntMap
Instance details Defined in Control.Lens.Traversal Methods traverseMin :: IndexedTraversal' Int (IntMap v) v #
TraverseMax Int IntMap
Instance details Defined in Control.Lens.Traversal Methods traverseMax :: IndexedTraversal' Int (IntMap v) v #
MVector MVector Int
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Int -> Int # basicUnsafeSlice :: Int -> Int -> MVector s Int -> MVector s Int # basicOverlaps :: MVector s Int -> MVector s Int -> Bool # basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Int) # basicInitialize :: PrimMonad m => MVector (PrimState m) Int -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> Int -> m (MVector (PrimState m) Int) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Int -> Int -> m Int # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Int -> Int -> Int -> m () # basicClear :: PrimMonad m => MVector (PrimState m) Int -> m () # basicSet :: PrimMonad m => MVector (PrimState m) Int -> Int -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Int -> MVector (PrimState m) Int -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Int -> MVector (PrimState m) Int -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Int -> Int -> m (MVector (PrimState m) Int) #
Lift Exp Int #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain Int :: Type # Methods lift :: Int -> Exp (Plain Int) #
ToFloating Int Double #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int -> Exp Double #
ToFloating Int Float #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int -> Exp Float #
ToFloating Int CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int -> Exp CFloat #
ToFloating Int CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int -> Exp CDouble #
ToFloating Int Half #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int -> Exp Half #
FromIntegral Int Double #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int -> Exp Double #
FromIntegral Int Float #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int -> Exp Float #
FromIntegral Int Int #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int -> Exp Int #
FromIntegral Int Int8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int -> Exp Int8 #
FromIntegral Int Int16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int -> Exp Int16 #
FromIntegral Int Int32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int -> Exp Int32 #
FromIntegral Int Int64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int -> Exp Int64 #
FromIntegral Int Word #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int -> Exp Word #
FromIntegral Int Word8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int -> Exp Word8 #
FromIntegral Int Word16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int -> Exp Word16 #
FromIntegral Int Word32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int -> Exp Word32 #
FromIntegral Int Word64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int -> Exp Word64 #
FromIntegral Int CShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int -> Exp CShort #
FromIntegral Int CUShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int -> Exp CUShort #
FromIntegral Int CInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int -> Exp CInt #
FromIntegral Int CUInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int -> Exp CUInt #
FromIntegral Int CLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int -> Exp CLong #
FromIntegral Int CULong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int -> Exp CULong #
FromIntegral Int CLLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int -> Exp CLLong #
FromIntegral Int CULLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int -> Exp CULLong #
FromIntegral Int CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int -> Exp CFloat #
FromIntegral Int CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int -> Exp CDouble #
FromIntegral Int Half #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int -> Exp Half #
FromIntegral Int8 Int #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int8 -> Exp Int #
FromIntegral Int16 Int #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int16 -> Exp Int #
FromIntegral Int32 Int #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int32 -> Exp Int #
FromIntegral Int64 Int #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int64 -> Exp Int #
FromIntegral Word Int #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word -> Exp Int #
FromIntegral Word8 Int #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word8 -> Exp Int #
FromIntegral Word16 Int #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word16 -> Exp Int #
FromIntegral Word32 Int #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word32 -> Exp Int #
FromIntegral Word64 Int #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word64 -> Exp Int #
FromIntegral CShort Int #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CShort -> Exp Int #
FromIntegral CUShort Int #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUShort -> Exp Int #
FromIntegral CInt Int #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CInt -> Exp Int #
FromIntegral CUInt Int #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUInt -> Exp Int #
FromIntegral CLong Int #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLong -> Exp Int #
FromIntegral CULong Int #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULong -> Exp Int #
FromIntegral CLLong Int #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLLong -> Exp Int #
FromIntegral CULLong Int #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULLong -> Exp Int #
Elt e => Stencil DIM1 e (Exp e, Exp e, Exp e) #
Instance details Defined in Data.Array.Accelerate.Smart Associated Types type StencilRepr DIM1 (Exp e, Exp e, Exp e) :: Type 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) #
Instance details Defined in Data.Array.Accelerate.Smart Associated Types type StencilRepr DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e) :: Type 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) #
Instance details Defined in Data.Array.Accelerate.Smart Associated Types type StencilRepr DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e) :: Type 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) #
Instance details Defined in Data.Array.Accelerate.Smart Associated Types type StencilRepr DIM1 (Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e, Exp e) :: Type 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)
Instance details Defined in Data.Constraint Methods ins :: () :- Bounded Int #
() :=> (Enum Int)
Instance details Defined in Data.Constraint Methods ins :: () :- Enum Int #
() :=> (Eq Int)
Instance details Defined in Data.Constraint Methods ins :: () :- Eq Int #
() :=> (Integral Int)
Instance details Defined in Data.Constraint Methods ins :: () :- Integral Int #
() :=> (Num Int)
Instance details Defined in Data.Constraint Methods ins :: () :- Num Int #
() :=> (Ord Int)
Instance details Defined in Data.Constraint Methods ins :: () :- Ord Int #
() :=> (Read Int)
Instance details Defined in Data.Constraint Methods ins :: () :- Read Int #
() :=> (Real Int)
Instance details Defined in Data.Constraint Methods ins :: () :- Real Int #
() :=> (Show Int)
Instance details Defined in Data.Constraint Methods ins :: () :- Show Int #
() :=> (Bits Int)
Instance details Defined in Data.Constraint Methods ins :: () :- Bits Int #
Generic1 (URec Int :: k -> Type)
Instance details Defined in GHC.Generics Associated Types type Rep1 (URec Int) :: k -> Type # 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) #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain (ix :. Int) :: Type # Methods lift :: (ix :. Int) -> Exp (Plain (ix :. Int)) #
Elt e => IsList (Vector e) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Associated Types type Item (Vector e) :: Type # Methods fromList :: [Item (Vector e)] -> Vector e # fromListN :: Int -> [Item (Vector e)] -> Vector e # toList :: Vector e -> [Item (Vector e)] #
Bounded (Exp Int) #
Instance details Defined in Data.Array.Accelerate.Classes.Bounded Methods minBound :: Exp Int # maxBound :: Exp Int #
Enum (Exp Int) #
Instance details Defined in Data.Array.Accelerate.Classes.Enum Methods succ :: Exp Int -> Exp Int # pred :: Exp Int -> Exp Int # toEnum :: Int -> Exp Int # fromEnum :: Exp Int -> Int # enumFrom :: Exp Int -> [Exp Int] # enumFromThen :: Exp Int -> Exp Int -> [Exp Int] # enumFromTo :: Exp Int -> Exp Int -> [Exp Int] # enumFromThenTo :: Exp Int -> Exp Int -> Exp Int -> [Exp Int] #
Integral (Exp Int) #
Instance details Defined in Data.Array.Accelerate.Classes.Integral Methods quot :: Exp Int -> Exp Int -> Exp Int # rem :: Exp Int -> Exp Int -> Exp Int # div :: Exp Int -> Exp Int -> Exp Int # mod :: Exp Int -> Exp Int -> Exp Int # quotRem :: Exp Int -> Exp Int -> (Exp Int, Exp Int) # divMod :: Exp Int -> Exp Int -> (Exp Int, Exp Int) # toInteger :: Exp Int -> Integer #
Num (Exp Int) #
Instance details Defined in Data.Array.Accelerate.Classes.Num Methods (+) :: Exp Int -> Exp Int -> Exp Int # (-) :: Exp Int -> Exp Int -> Exp Int # (*) :: Exp Int -> Exp Int -> Exp Int # negate :: Exp Int -> Exp Int # abs :: Exp Int -> Exp Int # signum :: Exp Int -> Exp Int # fromInteger :: Integer -> Exp Int #
Show (Vector e) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods showsPrec :: Int -> Vector e -> ShowS # show :: Vector e -> String # showList :: [Vector e] -> ShowS #
Shape sh => Elt (Any (sh :. Int)) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar 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
Instance details Defined in Control.Lens.Indexed Methods imap :: ([Int] -> a -> b) -> Tree a -> Tree b # imapped :: IndexedSetter [Int] (Tree a) (Tree b) a b #
FoldableWithIndex [Int] Tree
Instance details Defined in Control.Lens.Indexed Methods ifoldMap :: Monoid m => ([Int] -> a -> m) -> Tree a -> m # ifolded :: IndexedFold [Int] (Tree a) a # ifoldr :: ([Int] -> a -> b -> b) -> b -> Tree a -> b # ifoldl :: ([Int] -> b -> a -> b) -> b -> Tree a -> b # ifoldr' :: ([Int] -> a -> b -> b) -> b -> Tree a -> b # ifoldl' :: ([Int] -> b -> a -> b) -> b -> Tree a -> b #
TraversableWithIndex [Int] Tree
Instance details Defined in Control.Lens.Indexed Methods itraverse :: Applicative f => ([Int] -> a -> f b) -> Tree a -> f (Tree b) # itraversed :: IndexedTraversal [Int] (Tree a) (Tree b) a b #
Bizarre (Indexed Int) Mafic
Instance details Defined in Control.Lens.Internal.Magma Methods bazaar :: Applicative f => Indexed Int a (f b) -> Mafic a b t -> f t #
Reifies Z Int
Instance details Defined in Data.Reflection Methods reflect :: proxy Z -> Int #
Reifies n Int => Reifies (D n :: Type) Int
Instance details Defined in Data.Reflection Methods reflect :: proxy (D n) -> Int #
Reifies n Int => Reifies (SD n :: Type) Int
Instance details Defined in Data.Reflection Methods reflect :: proxy (SD n) -> Int #
Reifies n Int => Reifies (PD n :: Type) Int
Instance details Defined in Data.Reflection Methods reflect :: proxy (PD n) -> Int #
Functor (URec Int :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> URec Int a -> URec Int b # (<$) :: a -> URec Int b -> URec Int a #
Show (Array DIM2 e) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods showsPrec :: Int -> Array DIM2 e -> ShowS # show :: Array DIM2 e -> String # showList :: [Array DIM2 e] -> ShowS #
Foldable (URec Int :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Foldable 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 :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable 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) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Associated Types type SliceShape (sl :. Int) :: Type # type CoSliceShape (sl :. Int) :: Type # type FullShape (sl :. Int) :: Type # 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) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar 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) #
Instance details Defined in Data.Array.Accelerate.Smart Associated Types type StencilRepr ((sh :. Int) :. Int) (row2, row1, row0) :: Type 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) #
Instance details Defined in Data.Array.Accelerate.Smart Associated Types type StencilRepr ((sh :. Int) :. Int) (row1, row2, row3, row4, row5) :: Type 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) #
Instance details Defined in Data.Array.Accelerate.Smart Associated Types type StencilRepr ((sh :. Int) :. Int) (row1, row2, row3, row4, row5, row6, row7) :: Type 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) #
Instance details Defined in Data.Array.Accelerate.Smart Associated Types type StencilRepr ((sh :. Int) :. Int) (row1, row2, row3, row4, row5, row6, row7, row8, row9) :: Type 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)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (==) :: URec Int p -> URec Int p -> Bool # (/=) :: URec Int p -> URec Int p -> Bool #
Ord (URec Int p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods compare :: URec Int p -> URec Int p -> Ordering # (<) :: URec Int p -> URec Int p -> Bool # (<=) :: URec Int p -> URec Int p -> Bool # (>) :: URec Int p -> URec Int p -> Bool # (>=) :: URec Int p -> URec Int p -> Bool # max :: URec Int p -> URec Int p -> URec Int p # min :: URec Int p -> URec Int p -> URec Int p #
Show (URec Int p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> URec Int p -> ShowS # show :: URec Int p -> String # showList :: [URec Int p] -> ShowS #
Generic (URec Int p)
Instance details Defined in GHC.Generics Associated Types type Rep (URec Int p) :: Type -> Type # Methods from :: URec Int p -> Rep (URec Int p) x # to :: Rep (URec Int p) x -> URec Int p #
type PrimSize Int
Instance details Defined in Basement.PrimType type PrimSize Int = 8
type Difference Int
Instance details Defined in Basement.Numerical.Subtractive type Difference Int = Int
type NatNumMaxBound Int
Instance details Defined in Basement.Nat type NatNumMaxBound Int = NatNumMaxBound Int64
newtype Vector Int
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Int = V_Int (Vector Int)
type Plain Int #
Instance details Defined in Data.Array.Accelerate.Lift type Plain Int = Int
data URec Int (p :: k)	Used for marking occurrences of `Int#` Since: base-4.9.0.0
Instance details Defined in GHC.Generics data URec Int (p :: k) = UInt { uInt# :: Int# }
newtype MVector s Int
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Int = MV_Int (MVector s Int)
type Rep1 (URec Int :: k -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics type Rep1 (URec Int :: k -> Type) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UInt" PrefixI True) (S1 (MetaSel (Just "uInt#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (UInt :: k -> Type)))
type Item (Vector e) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar type Item (Vector e) = e
type SliceShape (sl :. Int) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar type SliceShape (sl :. Int) = SliceShape sl
type CoSliceShape (sl :. Int) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar type CoSliceShape (sl :. Int) = CoSliceShape sl :. Int
type FullShape (sl :. Int) #
Instance details Defined in Data.Array.Accelerate.Array.Sugar type FullShape (sl :. Int) = FullShape sl :. Int
type Plain (ix :. Int) #
Instance details Defined in Data.Array.Accelerate.Lift type Plain (ix :. Int) = Plain ix :. Int
type Rep (URec Int p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics type Rep (URec Int p) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UInt" PrefixI True) (S1 (MetaSel (Just "uInt#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (UInt :: Type -> Type)))

data Int8 #

8-bit signed integer type

Instances

Bounded Int8	Since: base-2.1
Instance details Defined in GHC.Int Methods minBound :: Int8 # maxBound :: Int8 #
Enum Int8	Since: base-2.1
Instance details Defined in GHC.Int Methods succ :: Int8 -> Int8 # pred :: Int8 -> Int8 # toEnum :: Int -> Int8 # fromEnum :: Int8 -> Int # enumFrom :: Int8 -> [Int8] # enumFromThen :: Int8 -> Int8 -> [Int8] # enumFromTo :: Int8 -> Int8 -> [Int8] # enumFromThenTo :: Int8 -> Int8 -> Int8 -> [Int8] #
Eq Int8	Since: base-2.1
Instance details Defined in GHC.Int Methods (==) :: Int8 -> Int8 -> Bool # (/=) :: Int8 -> Int8 -> Bool #
Integral Int8	Since: base-2.1
Instance details Defined in GHC.Int Methods quot :: Int8 -> Int8 -> Int8 # rem :: Int8 -> Int8 -> Int8 # div :: Int8 -> Int8 -> Int8 # mod :: Int8 -> Int8 -> Int8 # quotRem :: Int8 -> Int8 -> (Int8, Int8) # divMod :: Int8 -> Int8 -> (Int8, Int8) # toInteger :: Int8 -> Integer #
Num Int8	Since: base-2.1
Instance details Defined in GHC.Int Methods (+) :: Int8 -> Int8 -> Int8 # (-) :: Int8 -> Int8 -> Int8 # (*) :: Int8 -> Int8 -> Int8 # negate :: Int8 -> Int8 # abs :: Int8 -> Int8 # signum :: Int8 -> Int8 # fromInteger :: Integer -> Int8 #
Ord Int8	Since: base-2.1
Instance details Defined in GHC.Int Methods compare :: Int8 -> Int8 -> Ordering # (<) :: Int8 -> Int8 -> Bool # (<=) :: Int8 -> Int8 -> Bool # (>) :: Int8 -> Int8 -> Bool # (>=) :: Int8 -> Int8 -> Bool # max :: Int8 -> Int8 -> Int8 # min :: Int8 -> Int8 -> Int8 #
Read Int8	Since: base-2.1
Instance details Defined in GHC.Int Methods readsPrec :: Int -> ReadS Int8 # readList :: ReadS [Int8] # readPrec :: ReadPrec Int8 # readListPrec :: ReadPrec [Int8] #
Real Int8	Since: base-2.1
Instance details Defined in GHC.Int Methods toRational :: Int8 -> Rational #
Show Int8	Since: base-2.1
Instance details Defined in GHC.Int Methods showsPrec :: Int -> Int8 -> ShowS # show :: Int8 -> String # showList :: [Int8] -> ShowS #
Ix Int8	Since: base-2.1
Instance details Defined in GHC.Int Methods range :: (Int8, Int8) -> [Int8] # index :: (Int8, Int8) -> Int8 -> Int # unsafeIndex :: (Int8, Int8) -> Int8 -> Int inRange :: (Int8, Int8) -> Int8 -> Bool # rangeSize :: (Int8, Int8) -> Int # unsafeRangeSize :: (Int8, Int8) -> Int
Lift Int8
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Int8 -> Q Exp #
PrintfArg Int8	Since: base-2.1
Instance details Defined in Text.Printf Methods formatArg :: Int8 -> FieldFormatter # parseFormat :: Int8 -> ModifierParser #
Storable Int8	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Int8 -> Int # alignment :: Int8 -> Int # peekElemOff :: Ptr Int8 -> Int -> IO Int8 # pokeElemOff :: Ptr Int8 -> Int -> Int8 -> IO () # peekByteOff :: Ptr b -> Int -> IO Int8 # pokeByteOff :: Ptr b -> Int -> Int8 -> IO () # peek :: Ptr Int8 -> IO Int8 # poke :: Ptr Int8 -> Int8 -> IO () #
Bits Int8	Since: base-2.1
Instance details Defined in GHC.Int Methods (.&.) :: Int8 -> Int8 -> Int8 # (.\|.) :: Int8 -> Int8 -> Int8 # xor :: Int8 -> Int8 -> Int8 # complement :: Int8 -> Int8 # shift :: Int8 -> Int -> Int8 # rotate :: Int8 -> Int -> Int8 # zeroBits :: Int8 # bit :: Int -> Int8 # setBit :: Int8 -> Int -> Int8 # clearBit :: Int8 -> Int -> Int8 # complementBit :: Int8 -> Int -> Int8 # testBit :: Int8 -> Int -> Bool # bitSizeMaybe :: Int8 -> Maybe Int # bitSize :: Int8 -> Int # isSigned :: Int8 -> Bool # shiftL :: Int8 -> Int -> Int8 # unsafeShiftL :: Int8 -> Int -> Int8 # shiftR :: Int8 -> Int -> Int8 # unsafeShiftR :: Int8 -> Int -> Int8 # rotateL :: Int8 -> Int -> Int8 # rotateR :: Int8 -> Int -> Int8 # popCount :: Int8 -> Int #
FiniteBits Int8	Since: base-4.6.0.0
Instance details Defined in GHC.Int Methods finiteBitSize :: Int8 -> Int # countLeadingZeros :: Int8 -> Int # countTrailingZeros :: Int8 -> Int #
PrimType Int8
Instance details Defined in Basement.PrimType Associated Types type PrimSize Int8 :: Nat # Methods primSizeInBytes :: Proxy Int8 -> CountOf Word8 # primShiftToBytes :: Proxy Int8 -> Int # primBaUIndex :: ByteArray# -> Offset Int8 -> Int8 # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Int8 -> prim Int8 # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Int8 -> Int8 -> prim () # primAddrIndex :: Addr# -> Offset Int8 -> Int8 # primAddrRead :: PrimMonad prim => Addr# -> Offset Int8 -> prim Int8 # primAddrWrite :: PrimMonad prim => Addr# -> Offset Int8 -> Int8 -> prim () #
PrimMemoryComparable Int8
Instance details Defined in Basement.PrimType
Subtractive Int8
Instance details Defined in Basement.Numerical.Subtractive Associated Types type Difference Int8 :: Type # Methods (-) :: Int8 -> Int8 -> Difference Int8 #
NFData Int8
Instance details Defined in Control.DeepSeq Methods rnf :: Int8 -> () #
Hashable Int8
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Int8 -> Int # hash :: Int8 -> Int #
Prim Int8
Instance details Defined in Data.Primitive.Types Methods sizeOf# :: Int8 -> Int# # alignment# :: Int8 -> Int# # indexByteArray# :: ByteArray# -> Int# -> Int8 # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, Int8#) # writeByteArray# :: MutableByteArray# s -> Int# -> Int8 -> State# s -> State# s # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Int8 -> State# s -> State# s # indexOffAddr# :: Addr# -> Int# -> Int8 # readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, Int8#) # writeOffAddr# :: Addr# -> Int# -> Int8 -> State# s -> State# s # setOffAddr# :: Addr# -> Int# -> Int# -> Int8 -> State# s -> State# s #
Unbox Int8
Instance details Defined in Data.Vector.Unboxed.Base
Pretty Int8
Instance details Defined in Text.PrettyPrint.Annotated.WL Methods pretty :: Int8 -> Doc b # prettyList :: [Int8] -> Doc b #
IsScalar Int8 #
Instance details Defined in Data.Array.Accelerate.Type Methods scalarType :: ScalarType Int8
IsBounded Int8 #
Instance details Defined in Data.Array.Accelerate.Type Methods boundedType :: BoundedType Int8
IsNum Int8 #
Instance details Defined in Data.Array.Accelerate.Type Methods numType :: NumType Int8
IsIntegral Int8 #
Instance details Defined in Data.Array.Accelerate.Type Methods integralType :: IntegralType Int8
Elt Int8 #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods eltType :: Int8 -> TupleType (EltRepr Int8) fromElt :: Int8 -> EltRepr Int8 toElt :: EltRepr Int8 -> Int8
Eq Int8 #
Instance details Defined in Data.Array.Accelerate.Classes.Eq Methods (==) :: Exp Int8 -> Exp Int8 -> Exp Bool # (/=) :: Exp Int8 -> Exp Int8 -> Exp Bool #
Ord Int8 #
Instance details Defined in Data.Array.Accelerate.Classes.Ord Methods (<) :: Exp Int8 -> Exp Int8 -> Exp Bool # (>) :: Exp Int8 -> Exp Int8 -> Exp Bool # (<=) :: Exp Int8 -> Exp Int8 -> Exp Bool # (>=) :: Exp Int8 -> Exp Int8 -> Exp Bool # min :: Exp Int8 -> Exp Int8 -> Exp Int8 # max :: Exp Int8 -> Exp Int8 -> Exp Int8 # compare :: Exp Int8 -> Exp Int8 -> Exp Ordering #
FiniteBits Int8 #
Instance details Defined in Data.Array.Accelerate.Data.Bits Methods finiteBitSize :: Exp Int8 -> Exp Int # countLeadingZeros :: Exp Int8 -> Exp Int # countTrailingZeros :: Exp Int8 -> Exp Int #
Bits Int8 #
Instance details Defined in Data.Array.Accelerate.Data.Bits Methods (.&.) :: Exp Int8 -> Exp Int8 -> Exp Int8 # (.\|.) :: Exp Int8 -> Exp Int8 -> Exp Int8 # xor :: Exp Int8 -> Exp Int8 -> Exp Int8 # complement :: Exp Int8 -> Exp Int8 # shift :: Exp Int8 -> Exp Int -> Exp Int8 # rotate :: Exp Int8 -> Exp Int -> Exp Int8 # zeroBits :: Exp Int8 # bit :: Exp Int -> Exp Int8 # setBit :: Exp Int8 -> Exp Int -> Exp Int8 # clearBit :: Exp Int8 -> Exp Int -> Exp Int8 # complementBit :: Exp Int8 -> Exp Int -> Exp Int8 # testBit :: Exp Int8 -> Exp Int -> Exp Bool # isSigned :: Exp Int8 -> Exp Bool # shiftL :: Exp Int8 -> Exp Int -> Exp Int8 # unsafeShiftL :: Exp Int8 -> Exp Int -> Exp Int8 # shiftR :: Exp Int8 -> Exp Int -> Exp Int8 # unsafeShiftR :: Exp Int8 -> Exp Int -> Exp Int8 # rotateL :: Exp Int8 -> Exp Int -> Exp Int8 # rotateR :: Exp Int8 -> Exp Int -> Exp Int8 # popCount :: Exp Int8 -> Exp Int #
Vector Vector Int8
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Int8 -> m (Vector Int8) # basicUnsafeThaw :: PrimMonad m => Vector Int8 -> m (Mutable Vector (PrimState m) Int8) # basicLength :: Vector Int8 -> Int # basicUnsafeSlice :: Int -> Int -> Vector Int8 -> Vector Int8 # basicUnsafeIndexM :: Monad m => Vector Int8 -> Int -> m Int8 # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Int8 -> Vector Int8 -> m () # elemseq :: Vector Int8 -> Int8 -> b -> b #
MVector MVector Int8
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Int8 -> Int # basicUnsafeSlice :: Int -> Int -> MVector s Int8 -> MVector s Int8 # basicOverlaps :: MVector s Int8 -> MVector s Int8 -> Bool # basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Int8) # basicInitialize :: PrimMonad m => MVector (PrimState m) Int8 -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> Int8 -> m (MVector (PrimState m) Int8) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Int8 -> Int -> m Int8 # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Int8 -> Int -> Int8 -> m () # basicClear :: PrimMonad m => MVector (PrimState m) Int8 -> m () # basicSet :: PrimMonad m => MVector (PrimState m) Int8 -> Int8 -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Int8 -> MVector (PrimState m) Int8 -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Int8 -> MVector (PrimState m) Int8 -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Int8 -> Int -> m (MVector (PrimState m) Int8) #
Lift Exp Int8 #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain Int8 :: Type # Methods lift :: Int8 -> Exp (Plain Int8) #
ToFloating Int8 Double #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int8 -> Exp Double #
ToFloating Int8 Float #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int8 -> Exp Float #
ToFloating Int8 CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int8 -> Exp CFloat #
ToFloating Int8 CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int8 -> Exp CDouble #
ToFloating Int8 Half #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int8 -> Exp Half #
FromIntegral Int Int8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int -> Exp Int8 #
FromIntegral Int8 Double #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int8 -> Exp Double #
FromIntegral Int8 Float #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int8 -> Exp Float #
FromIntegral Int8 Int #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int8 -> Exp Int #
FromIntegral Int8 Int8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int8 -> Exp Int8 #
FromIntegral Int8 Int16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int8 -> Exp Int16 #
FromIntegral Int8 Int32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int8 -> Exp Int32 #
FromIntegral Int8 Int64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int8 -> Exp Int64 #
FromIntegral Int8 Word #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int8 -> Exp Word #
FromIntegral Int8 Word8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int8 -> Exp Word8 #
FromIntegral Int8 Word16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int8 -> Exp Word16 #
FromIntegral Int8 Word32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int8 -> Exp Word32 #
FromIntegral Int8 Word64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int8 -> Exp Word64 #
FromIntegral Int8 CShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int8 -> Exp CShort #
FromIntegral Int8 CUShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int8 -> Exp CUShort #
FromIntegral Int8 CInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int8 -> Exp CInt #
FromIntegral Int8 CUInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int8 -> Exp CUInt #
FromIntegral Int8 CLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int8 -> Exp CLong #
FromIntegral Int8 CULong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int8 -> Exp CULong #
FromIntegral Int8 CLLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int8 -> Exp CLLong #
FromIntegral Int8 CULLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int8 -> Exp CULLong #
FromIntegral Int8 CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int8 -> Exp CFloat #
FromIntegral Int8 CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int8 -> Exp CDouble #
FromIntegral Int8 Half #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int8 -> Exp Half #
FromIntegral Int16 Int8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int16 -> Exp Int8 #
FromIntegral Int32 Int8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int32 -> Exp Int8 #
FromIntegral Int64 Int8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int64 -> Exp Int8 #
FromIntegral Word Int8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word -> Exp Int8 #
FromIntegral Word8 Int8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word8 -> Exp Int8 #
FromIntegral Word16 Int8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word16 -> Exp Int8 #
FromIntegral Word32 Int8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word32 -> Exp Int8 #
FromIntegral Word64 Int8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word64 -> Exp Int8 #
FromIntegral CShort Int8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CShort -> Exp Int8 #
FromIntegral CUShort Int8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUShort -> Exp Int8 #
FromIntegral CInt Int8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CInt -> Exp Int8 #
FromIntegral CUInt Int8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUInt -> Exp Int8 #
FromIntegral CLong Int8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLong -> Exp Int8 #
FromIntegral CULong Int8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULong -> Exp Int8 #
FromIntegral CLLong Int8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLLong -> Exp Int8 #
FromIntegral CULLong Int8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULLong -> Exp Int8 #
Bounded (Exp Int8) #
Instance details Defined in Data.Array.Accelerate.Classes.Bounded Methods minBound :: Exp Int8 # maxBound :: Exp Int8 #
Enum (Exp Int8) #
Instance details Defined in Data.Array.Accelerate.Classes.Enum Methods succ :: Exp Int8 -> Exp Int8 # pred :: Exp Int8 -> Exp Int8 # toEnum :: Int -> Exp Int8 # fromEnum :: Exp Int8 -> Int # enumFrom :: Exp Int8 -> [Exp Int8] # enumFromThen :: Exp Int8 -> Exp Int8 -> [Exp Int8] # enumFromTo :: Exp Int8 -> Exp Int8 -> [Exp Int8] # enumFromThenTo :: Exp Int8 -> Exp Int8 -> Exp Int8 -> [Exp Int8] #
Integral (Exp Int8) #
Instance details Defined in Data.Array.Accelerate.Classes.Integral Methods quot :: Exp Int8 -> Exp Int8 -> Exp Int8 # rem :: Exp Int8 -> Exp Int8 -> Exp Int8 # div :: Exp Int8 -> Exp Int8 -> Exp Int8 # mod :: Exp Int8 -> Exp Int8 -> Exp Int8 # quotRem :: Exp Int8 -> Exp Int8 -> (Exp Int8, Exp Int8) # divMod :: Exp Int8 -> Exp Int8 -> (Exp Int8, Exp Int8) # toInteger :: Exp Int8 -> Integer #
Num (Exp Int8) #
Instance details Defined in Data.Array.Accelerate.Classes.Num Methods (+) :: Exp Int8 -> Exp Int8 -> Exp Int8 # (-) :: Exp Int8 -> Exp Int8 -> Exp Int8 # (*) :: Exp Int8 -> Exp Int8 -> Exp Int8 # negate :: Exp Int8 -> Exp Int8 # abs :: Exp Int8 -> Exp Int8 # signum :: Exp Int8 -> Exp Int8 # fromInteger :: Integer -> Exp Int8 #
type PrimSize Int8
Instance details Defined in Basement.PrimType type PrimSize Int8 = 1
type Difference Int8
Instance details Defined in Basement.Numerical.Subtractive type Difference Int8 = Int8
type NatNumMaxBound Int8
Instance details Defined in Basement.Nat type NatNumMaxBound Int8 = 127
newtype Vector Int8
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Int8 = V_Int8 (Vector Int8)
type Plain Int8 #
Instance details Defined in Data.Array.Accelerate.Lift type Plain Int8 = Int8
newtype MVector s Int8
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Int8 = MV_Int8 (MVector s Int8)

data Int16 #

16-bit signed integer type

Instances

Bounded Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods minBound :: Int16 # maxBound :: Int16 #
Enum Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods succ :: Int16 -> Int16 # pred :: Int16 -> Int16 # toEnum :: Int -> Int16 # fromEnum :: Int16 -> Int # enumFrom :: Int16 -> [Int16] # enumFromThen :: Int16 -> Int16 -> [Int16] # enumFromTo :: Int16 -> Int16 -> [Int16] # enumFromThenTo :: Int16 -> Int16 -> Int16 -> [Int16] #
Eq Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods (==) :: Int16 -> Int16 -> Bool # (/=) :: Int16 -> Int16 -> Bool #
Integral Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods quot :: Int16 -> Int16 -> Int16 # rem :: Int16 -> Int16 -> Int16 # div :: Int16 -> Int16 -> Int16 # mod :: Int16 -> Int16 -> Int16 # quotRem :: Int16 -> Int16 -> (Int16, Int16) # divMod :: Int16 -> Int16 -> (Int16, Int16) # toInteger :: Int16 -> Integer #
Num Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods (+) :: Int16 -> Int16 -> Int16 # (-) :: Int16 -> Int16 -> Int16 # (*) :: Int16 -> Int16 -> Int16 # negate :: Int16 -> Int16 # abs :: Int16 -> Int16 # signum :: Int16 -> Int16 # fromInteger :: Integer -> Int16 #
Ord Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods compare :: Int16 -> Int16 -> Ordering # (<) :: Int16 -> Int16 -> Bool # (<=) :: Int16 -> Int16 -> Bool # (>) :: Int16 -> Int16 -> Bool # (>=) :: Int16 -> Int16 -> Bool # max :: Int16 -> Int16 -> Int16 # min :: Int16 -> Int16 -> Int16 #
Read Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods readsPrec :: Int -> ReadS Int16 # readList :: ReadS [Int16] # readPrec :: ReadPrec Int16 # readListPrec :: ReadPrec [Int16] #
Real Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods toRational :: Int16 -> Rational #
Show Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods showsPrec :: Int -> Int16 -> ShowS # show :: Int16 -> String # showList :: [Int16] -> ShowS #
Ix Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods range :: (Int16, Int16) -> [Int16] # index :: (Int16, Int16) -> Int16 -> Int # unsafeIndex :: (Int16, Int16) -> Int16 -> Int inRange :: (Int16, Int16) -> Int16 -> Bool # rangeSize :: (Int16, Int16) -> Int # unsafeRangeSize :: (Int16, Int16) -> Int
Lift Int16
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Int16 -> Q Exp #
PrintfArg Int16	Since: base-2.1
Instance details Defined in Text.Printf Methods formatArg :: Int16 -> FieldFormatter # parseFormat :: Int16 -> ModifierParser #
Storable Int16	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Int16 -> Int # alignment :: Int16 -> Int # peekElemOff :: Ptr Int16 -> Int -> IO Int16 # pokeElemOff :: Ptr Int16 -> Int -> Int16 -> IO () # peekByteOff :: Ptr b -> Int -> IO Int16 # pokeByteOff :: Ptr b -> Int -> Int16 -> IO () # peek :: Ptr Int16 -> IO Int16 # poke :: Ptr Int16 -> Int16 -> IO () #
Bits Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods (.&.) :: Int16 -> Int16 -> Int16 # (.\|.) :: Int16 -> Int16 -> Int16 # xor :: Int16 -> Int16 -> Int16 # complement :: Int16 -> Int16 # shift :: Int16 -> Int -> Int16 # rotate :: Int16 -> Int -> Int16 # zeroBits :: Int16 # bit :: Int -> Int16 # setBit :: Int16 -> Int -> Int16 # clearBit :: Int16 -> Int -> Int16 # complementBit :: Int16 -> Int -> Int16 # testBit :: Int16 -> Int -> Bool # bitSizeMaybe :: Int16 -> Maybe Int # bitSize :: Int16 -> Int # isSigned :: Int16 -> Bool # shiftL :: Int16 -> Int -> Int16 # unsafeShiftL :: Int16 -> Int -> Int16 # shiftR :: Int16 -> Int -> Int16 # unsafeShiftR :: Int16 -> Int -> Int16 # rotateL :: Int16 -> Int -> Int16 # rotateR :: Int16 -> Int -> Int16 # popCount :: Int16 -> Int #
FiniteBits Int16	Since: base-4.6.0.0
Instance details Defined in GHC.Int Methods finiteBitSize :: Int16 -> Int # countLeadingZeros :: Int16 -> Int # countTrailingZeros :: Int16 -> Int #
PrimType Int16
Instance details Defined in Basement.PrimType Associated Types type PrimSize Int16 :: Nat # Methods primSizeInBytes :: Proxy Int16 -> CountOf Word8 # primShiftToBytes :: Proxy Int16 -> Int # primBaUIndex :: ByteArray# -> Offset Int16 -> Int16 # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Int16 -> prim Int16 # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Int16 -> Int16 -> prim () # primAddrIndex :: Addr# -> Offset Int16 -> Int16 # primAddrRead :: PrimMonad prim => Addr# -> Offset Int16 -> prim Int16 # primAddrWrite :: PrimMonad prim => Addr# -> Offset Int16 -> Int16 -> prim () #
PrimMemoryComparable Int16
Instance details Defined in Basement.PrimType
Subtractive Int16
Instance details Defined in Basement.Numerical.Subtractive Associated Types type Difference Int16 :: Type # Methods (-) :: Int16 -> Int16 -> Difference Int16 #
NFData Int16
Instance details Defined in Control.DeepSeq Methods rnf :: Int16 -> () #
Hashable Int16
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Int16 -> Int # hash :: Int16 -> Int #
Prim Int16
Instance details Defined in Data.Primitive.Types Methods sizeOf# :: Int16 -> Int# # alignment# :: Int16 -> Int# # indexByteArray# :: ByteArray# -> Int# -> Int16 # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, Int16#) # writeByteArray# :: MutableByteArray# s -> Int# -> Int16 -> State# s -> State# s # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Int16 -> State# s -> State# s # indexOffAddr# :: Addr# -> Int# -> Int16 # readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, Int16#) # writeOffAddr# :: Addr# -> Int# -> Int16 -> State# s -> State# s # setOffAddr# :: Addr# -> Int# -> Int# -> Int16 -> State# s -> State# s #
Unbox Int16
Instance details Defined in Data.Vector.Unboxed.Base
Pretty Int16
Instance details Defined in Text.PrettyPrint.Annotated.WL Methods pretty :: Int16 -> Doc b # prettyList :: [Int16] -> Doc b #
IsScalar Int16 #
Instance details Defined in Data.Array.Accelerate.Type Methods scalarType :: ScalarType Int16
IsBounded Int16 #
Instance details Defined in Data.Array.Accelerate.Type Methods boundedType :: BoundedType Int16
IsNum Int16 #
Instance details Defined in Data.Array.Accelerate.Type Methods numType :: NumType Int16
IsIntegral Int16 #
Instance details Defined in Data.Array.Accelerate.Type Methods integralType :: IntegralType Int16
Elt Int16 #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods eltType :: Int16 -> TupleType (EltRepr Int16) fromElt :: Int16 -> EltRepr Int16 toElt :: EltRepr Int16 -> Int16
Eq Int16 #
Instance details Defined in Data.Array.Accelerate.Classes.Eq Methods (==) :: Exp Int16 -> Exp Int16 -> Exp Bool # (/=) :: Exp Int16 -> Exp Int16 -> Exp Bool #
Ord Int16 #
Instance details Defined in Data.Array.Accelerate.Classes.Ord Methods (<) :: Exp Int16 -> Exp Int16 -> Exp Bool # (>) :: Exp Int16 -> Exp Int16 -> Exp Bool # (<=) :: Exp Int16 -> Exp Int16 -> Exp Bool # (>=) :: Exp Int16 -> Exp Int16 -> Exp Bool # min :: Exp Int16 -> Exp Int16 -> Exp Int16 # max :: Exp Int16 -> Exp Int16 -> Exp Int16 # compare :: Exp Int16 -> Exp Int16 -> Exp Ordering #
FiniteBits Int16 #
Instance details Defined in Data.Array.Accelerate.Data.Bits Methods finiteBitSize :: Exp Int16 -> Exp Int # countLeadingZeros :: Exp Int16 -> Exp Int # countTrailingZeros :: Exp Int16 -> Exp Int #
Bits Int16 #
Instance details Defined in Data.Array.Accelerate.Data.Bits Methods (.&.) :: Exp Int16 -> Exp Int16 -> Exp Int16 # (.\|.) :: Exp Int16 -> Exp Int16 -> Exp Int16 # xor :: Exp Int16 -> Exp Int16 -> Exp Int16 # complement :: Exp Int16 -> Exp Int16 # shift :: Exp Int16 -> Exp Int -> Exp Int16 # rotate :: Exp Int16 -> Exp Int -> Exp Int16 # zeroBits :: Exp Int16 # bit :: Exp Int -> Exp Int16 # setBit :: Exp Int16 -> Exp Int -> Exp Int16 # clearBit :: Exp Int16 -> Exp Int -> Exp Int16 # complementBit :: Exp Int16 -> Exp Int -> Exp Int16 # testBit :: Exp Int16 -> Exp Int -> Exp Bool # isSigned :: Exp Int16 -> Exp Bool # shiftL :: Exp Int16 -> Exp Int -> Exp Int16 # unsafeShiftL :: Exp Int16 -> Exp Int -> Exp Int16 # shiftR :: Exp Int16 -> Exp Int -> Exp Int16 # unsafeShiftR :: Exp Int16 -> Exp Int -> Exp Int16 # rotateL :: Exp Int16 -> Exp Int -> Exp Int16 # rotateR :: Exp Int16 -> Exp Int -> Exp Int16 # popCount :: Exp Int16 -> Exp Int #
Vector Vector Int16
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Int16 -> m (Vector Int16) # basicUnsafeThaw :: PrimMonad m => Vector Int16 -> m (Mutable Vector (PrimState m) Int16) # basicLength :: Vector Int16 -> Int # basicUnsafeSlice :: Int -> Int -> Vector Int16 -> Vector Int16 # basicUnsafeIndexM :: Monad m => Vector Int16 -> Int -> m Int16 # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Int16 -> Vector Int16 -> m () # elemseq :: Vector Int16 -> Int16 -> b -> b #
MVector MVector Int16
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Int16 -> Int # basicUnsafeSlice :: Int -> Int -> MVector s Int16 -> MVector s Int16 # basicOverlaps :: MVector s Int16 -> MVector s Int16 -> Bool # basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Int16) # basicInitialize :: PrimMonad m => MVector (PrimState m) Int16 -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> Int16 -> m (MVector (PrimState m) Int16) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Int16 -> Int -> m Int16 # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Int16 -> Int -> Int16 -> m () # basicClear :: PrimMonad m => MVector (PrimState m) Int16 -> m () # basicSet :: PrimMonad m => MVector (PrimState m) Int16 -> Int16 -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Int16 -> MVector (PrimState m) Int16 -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Int16 -> MVector (PrimState m) Int16 -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Int16 -> Int -> m (MVector (PrimState m) Int16) #
Lift Exp Int16 #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain Int16 :: Type # Methods lift :: Int16 -> Exp (Plain Int16) #
ToFloating Int16 Double #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int16 -> Exp Double #
ToFloating Int16 Float #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int16 -> Exp Float #
ToFloating Int16 CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int16 -> Exp CFloat #
ToFloating Int16 CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int16 -> Exp CDouble #
ToFloating Int16 Half #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int16 -> Exp Half #
FromIntegral Int Int16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int -> Exp Int16 #
FromIntegral Int8 Int16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int8 -> Exp Int16 #
FromIntegral Int16 Double #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int16 -> Exp Double #
FromIntegral Int16 Float #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int16 -> Exp Float #
FromIntegral Int16 Int #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int16 -> Exp Int #
FromIntegral Int16 Int8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int16 -> Exp Int8 #
FromIntegral Int16 Int16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int16 -> Exp Int16 #
FromIntegral Int16 Int32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int16 -> Exp Int32 #
FromIntegral Int16 Int64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int16 -> Exp Int64 #
FromIntegral Int16 Word #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int16 -> Exp Word #
FromIntegral Int16 Word8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int16 -> Exp Word8 #
FromIntegral Int16 Word16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int16 -> Exp Word16 #
FromIntegral Int16 Word32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int16 -> Exp Word32 #
FromIntegral Int16 Word64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int16 -> Exp Word64 #
FromIntegral Int16 CShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int16 -> Exp CShort #
FromIntegral Int16 CUShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int16 -> Exp CUShort #
FromIntegral Int16 CInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int16 -> Exp CInt #
FromIntegral Int16 CUInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int16 -> Exp CUInt #
FromIntegral Int16 CLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int16 -> Exp CLong #
FromIntegral Int16 CULong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int16 -> Exp CULong #
FromIntegral Int16 CLLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int16 -> Exp CLLong #
FromIntegral Int16 CULLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int16 -> Exp CULLong #
FromIntegral Int16 CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int16 -> Exp CFloat #
FromIntegral Int16 CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int16 -> Exp CDouble #
FromIntegral Int16 Half #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int16 -> Exp Half #
FromIntegral Int32 Int16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int32 -> Exp Int16 #
FromIntegral Int64 Int16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int64 -> Exp Int16 #
FromIntegral Word Int16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word -> Exp Int16 #
FromIntegral Word8 Int16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word8 -> Exp Int16 #
FromIntegral Word16 Int16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word16 -> Exp Int16 #
FromIntegral Word32 Int16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word32 -> Exp Int16 #
FromIntegral Word64 Int16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word64 -> Exp Int16 #
FromIntegral CShort Int16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CShort -> Exp Int16 #
FromIntegral CUShort Int16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUShort -> Exp Int16 #
FromIntegral CInt Int16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CInt -> Exp Int16 #
FromIntegral CUInt Int16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUInt -> Exp Int16 #
FromIntegral CLong Int16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLong -> Exp Int16 #
FromIntegral CULong Int16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULong -> Exp Int16 #
FromIntegral CLLong Int16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLLong -> Exp Int16 #
FromIntegral CULLong Int16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULLong -> Exp Int16 #
Bounded (Exp Int16) #
Instance details Defined in Data.Array.Accelerate.Classes.Bounded Methods minBound :: Exp Int16 # maxBound :: Exp Int16 #
Enum (Exp Int16) #
Instance details Defined in Data.Array.Accelerate.Classes.Enum Methods succ :: Exp Int16 -> Exp Int16 # pred :: Exp Int16 -> Exp Int16 # toEnum :: Int -> Exp Int16 # fromEnum :: Exp Int16 -> Int # enumFrom :: Exp Int16 -> [Exp Int16] # enumFromThen :: Exp Int16 -> Exp Int16 -> [Exp Int16] # enumFromTo :: Exp Int16 -> Exp Int16 -> [Exp Int16] # enumFromThenTo :: Exp Int16 -> Exp Int16 -> Exp Int16 -> [Exp Int16] #
Integral (Exp Int16) #
Instance details Defined in Data.Array.Accelerate.Classes.Integral Methods quot :: Exp Int16 -> Exp Int16 -> Exp Int16 # rem :: Exp Int16 -> Exp Int16 -> Exp Int16 # div :: Exp Int16 -> Exp Int16 -> Exp Int16 # mod :: Exp Int16 -> Exp Int16 -> Exp Int16 # quotRem :: Exp Int16 -> Exp Int16 -> (Exp Int16, Exp Int16) # divMod :: Exp Int16 -> Exp Int16 -> (Exp Int16, Exp Int16) # toInteger :: Exp Int16 -> Integer #
Num (Exp Int16) #
Instance details Defined in Data.Array.Accelerate.Classes.Num Methods (+) :: Exp Int16 -> Exp Int16 -> Exp Int16 # (-) :: Exp Int16 -> Exp Int16 -> Exp Int16 # (*) :: Exp Int16 -> Exp Int16 -> Exp Int16 # negate :: Exp Int16 -> Exp Int16 # abs :: Exp Int16 -> Exp Int16 # signum :: Exp Int16 -> Exp Int16 # fromInteger :: Integer -> Exp Int16 #
type PrimSize Int16
Instance details Defined in Basement.PrimType type PrimSize Int16 = 2
type Difference Int16
Instance details Defined in Basement.Numerical.Subtractive type Difference Int16 = Int16
type NatNumMaxBound Int16
Instance details Defined in Basement.Nat type NatNumMaxBound Int16 = 32767
newtype Vector Int16
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Int16 = V_Int16 (Vector Int16)
type Plain Int16 #
Instance details Defined in Data.Array.Accelerate.Lift type Plain Int16 = Int16
newtype MVector s Int16
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Int16 = MV_Int16 (MVector s Int16)

data Int32 #

32-bit signed integer type

Instances

Bounded Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods minBound :: Int32 # maxBound :: Int32 #
Enum Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods succ :: Int32 -> Int32 # pred :: Int32 -> Int32 # toEnum :: Int -> Int32 # fromEnum :: Int32 -> Int # enumFrom :: Int32 -> [Int32] # enumFromThen :: Int32 -> Int32 -> [Int32] # enumFromTo :: Int32 -> Int32 -> [Int32] # enumFromThenTo :: Int32 -> Int32 -> Int32 -> [Int32] #
Eq Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods (==) :: Int32 -> Int32 -> Bool # (/=) :: Int32 -> Int32 -> Bool #
Integral Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods quot :: Int32 -> Int32 -> Int32 # rem :: Int32 -> Int32 -> Int32 # div :: Int32 -> Int32 -> Int32 # mod :: Int32 -> Int32 -> Int32 # quotRem :: Int32 -> Int32 -> (Int32, Int32) # divMod :: Int32 -> Int32 -> (Int32, Int32) # toInteger :: Int32 -> Integer #
Num Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods (+) :: Int32 -> Int32 -> Int32 # (-) :: Int32 -> Int32 -> Int32 # (*) :: Int32 -> Int32 -> Int32 # negate :: Int32 -> Int32 # abs :: Int32 -> Int32 # signum :: Int32 -> Int32 # fromInteger :: Integer -> Int32 #
Ord Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods compare :: Int32 -> Int32 -> Ordering # (<) :: Int32 -> Int32 -> Bool # (<=) :: Int32 -> Int32 -> Bool # (>) :: Int32 -> Int32 -> Bool # (>=) :: Int32 -> Int32 -> Bool # max :: Int32 -> Int32 -> Int32 # min :: Int32 -> Int32 -> Int32 #
Read Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods readsPrec :: Int -> ReadS Int32 # readList :: ReadS [Int32] # readPrec :: ReadPrec Int32 # readListPrec :: ReadPrec [Int32] #
Real Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods toRational :: Int32 -> Rational #
Show Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods showsPrec :: Int -> Int32 -> ShowS # show :: Int32 -> String # showList :: [Int32] -> ShowS #
Ix Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods range :: (Int32, Int32) -> [Int32] # index :: (Int32, Int32) -> Int32 -> Int # unsafeIndex :: (Int32, Int32) -> Int32 -> Int inRange :: (Int32, Int32) -> Int32 -> Bool # rangeSize :: (Int32, Int32) -> Int # unsafeRangeSize :: (Int32, Int32) -> Int
Lift Int32
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Int32 -> Q Exp #
PrintfArg Int32	Since: base-2.1
Instance details Defined in Text.Printf Methods formatArg :: Int32 -> FieldFormatter # parseFormat :: Int32 -> ModifierParser #
Storable Int32	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Int32 -> Int # alignment :: Int32 -> Int # peekElemOff :: Ptr Int32 -> Int -> IO Int32 # pokeElemOff :: Ptr Int32 -> Int -> Int32 -> IO () # peekByteOff :: Ptr b -> Int -> IO Int32 # pokeByteOff :: Ptr b -> Int -> Int32 -> IO () # peek :: Ptr Int32 -> IO Int32 # poke :: Ptr Int32 -> Int32 -> IO () #
Bits Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods (.&.) :: Int32 -> Int32 -> Int32 # (.\|.) :: Int32 -> Int32 -> Int32 # xor :: Int32 -> Int32 -> Int32 # complement :: Int32 -> Int32 # shift :: Int32 -> Int -> Int32 # rotate :: Int32 -> Int -> Int32 # zeroBits :: Int32 # bit :: Int -> Int32 # setBit :: Int32 -> Int -> Int32 # clearBit :: Int32 -> Int -> Int32 # complementBit :: Int32 -> Int -> Int32 # testBit :: Int32 -> Int -> Bool # bitSizeMaybe :: Int32 -> Maybe Int # bitSize :: Int32 -> Int # isSigned :: Int32 -> Bool # shiftL :: Int32 -> Int -> Int32 # unsafeShiftL :: Int32 -> Int -> Int32 # shiftR :: Int32 -> Int -> Int32 # unsafeShiftR :: Int32 -> Int -> Int32 # rotateL :: Int32 -> Int -> Int32 # rotateR :: Int32 -> Int -> Int32 # popCount :: Int32 -> Int #
FiniteBits Int32	Since: base-4.6.0.0
Instance details Defined in GHC.Int Methods finiteBitSize :: Int32 -> Int # countLeadingZeros :: Int32 -> Int # countTrailingZeros :: Int32 -> Int #
PrimType Int32
Instance details Defined in Basement.PrimType Associated Types type PrimSize Int32 :: Nat # Methods primSizeInBytes :: Proxy Int32 -> CountOf Word8 # primShiftToBytes :: Proxy Int32 -> Int # primBaUIndex :: ByteArray# -> Offset Int32 -> Int32 # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Int32 -> prim Int32 # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Int32 -> Int32 -> prim () # primAddrIndex :: Addr# -> Offset Int32 -> Int32 # primAddrRead :: PrimMonad prim => Addr# -> Offset Int32 -> prim Int32 # primAddrWrite :: PrimMonad prim => Addr# -> Offset Int32 -> Int32 -> prim () #
PrimMemoryComparable Int32
Instance details Defined in Basement.PrimType
Subtractive Int32
Instance details Defined in Basement.Numerical.Subtractive Associated Types type Difference Int32 :: Type # Methods (-) :: Int32 -> Int32 -> Difference Int32 #
NFData Int32
Instance details Defined in Control.DeepSeq Methods rnf :: Int32 -> () #
Hashable Int32
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Int32 -> Int # hash :: Int32 -> Int #
Prim Int32
Instance details Defined in Data.Primitive.Types Methods sizeOf# :: Int32 -> Int# # alignment# :: Int32 -> Int# # indexByteArray# :: ByteArray# -> Int# -> Int32 # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, Int32#) # writeByteArray# :: MutableByteArray# s -> Int# -> Int32 -> State# s -> State# s # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Int32 -> State# s -> State# s # indexOffAddr# :: Addr# -> Int# -> Int32 # readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, Int32#) # writeOffAddr# :: Addr# -> Int# -> Int32 -> State# s -> State# s # setOffAddr# :: Addr# -> Int# -> Int# -> Int32 -> State# s -> State# s #
Unbox Int32
Instance details Defined in Data.Vector.Unboxed.Base
Pretty Int32
Instance details Defined in Text.PrettyPrint.Annotated.WL Methods pretty :: Int32 -> Doc b # prettyList :: [Int32] -> Doc b #
IsScalar Int32 #
Instance details Defined in Data.Array.Accelerate.Type Methods scalarType :: ScalarType Int32
IsBounded Int32 #
Instance details Defined in Data.Array.Accelerate.Type Methods boundedType :: BoundedType Int32
IsNum Int32 #
Instance details Defined in Data.Array.Accelerate.Type Methods numType :: NumType Int32
IsIntegral Int32 #
Instance details Defined in Data.Array.Accelerate.Type Methods integralType :: IntegralType Int32
Elt Int32 #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods eltType :: Int32 -> TupleType (EltRepr Int32) fromElt :: Int32 -> EltRepr Int32 toElt :: EltRepr Int32 -> Int32
Eq Int32 #
Instance details Defined in Data.Array.Accelerate.Classes.Eq Methods (==) :: Exp Int32 -> Exp Int32 -> Exp Bool # (/=) :: Exp Int32 -> Exp Int32 -> Exp Bool #
Ord Int32 #
Instance details Defined in Data.Array.Accelerate.Classes.Ord Methods (<) :: Exp Int32 -> Exp Int32 -> Exp Bool # (>) :: Exp Int32 -> Exp Int32 -> Exp Bool # (<=) :: Exp Int32 -> Exp Int32 -> Exp Bool # (>=) :: Exp Int32 -> Exp Int32 -> Exp Bool # min :: Exp Int32 -> Exp Int32 -> Exp Int32 # max :: Exp Int32 -> Exp Int32 -> Exp Int32 # compare :: Exp Int32 -> Exp Int32 -> Exp Ordering #
FiniteBits Int32 #
Instance details Defined in Data.Array.Accelerate.Data.Bits Methods finiteBitSize :: Exp Int32 -> Exp Int # countLeadingZeros :: Exp Int32 -> Exp Int # countTrailingZeros :: Exp Int32 -> Exp Int #
Bits Int32 #
Instance details Defined in Data.Array.Accelerate.Data.Bits Methods (.&.) :: Exp Int32 -> Exp Int32 -> Exp Int32 # (.\|.) :: Exp Int32 -> Exp Int32 -> Exp Int32 # xor :: Exp Int32 -> Exp Int32 -> Exp Int32 # complement :: Exp Int32 -> Exp Int32 # shift :: Exp Int32 -> Exp Int -> Exp Int32 # rotate :: Exp Int32 -> Exp Int -> Exp Int32 # zeroBits :: Exp Int32 # bit :: Exp Int -> Exp Int32 # setBit :: Exp Int32 -> Exp Int -> Exp Int32 # clearBit :: Exp Int32 -> Exp Int -> Exp Int32 # complementBit :: Exp Int32 -> Exp Int -> Exp Int32 # testBit :: Exp Int32 -> Exp Int -> Exp Bool # isSigned :: Exp Int32 -> Exp Bool # shiftL :: Exp Int32 -> Exp Int -> Exp Int32 # unsafeShiftL :: Exp Int32 -> Exp Int -> Exp Int32 # shiftR :: Exp Int32 -> Exp Int -> Exp Int32 # unsafeShiftR :: Exp Int32 -> Exp Int -> Exp Int32 # rotateL :: Exp Int32 -> Exp Int -> Exp Int32 # rotateR :: Exp Int32 -> Exp Int -> Exp Int32 # popCount :: Exp Int32 -> Exp Int #
Vector Vector Int32
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Int32 -> m (Vector Int32) # basicUnsafeThaw :: PrimMonad m => Vector Int32 -> m (Mutable Vector (PrimState m) Int32) # basicLength :: Vector Int32 -> Int # basicUnsafeSlice :: Int -> Int -> Vector Int32 -> Vector Int32 # basicUnsafeIndexM :: Monad m => Vector Int32 -> Int -> m Int32 # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Int32 -> Vector Int32 -> m () # elemseq :: Vector Int32 -> Int32 -> b -> b #
MVector MVector Int32
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Int32 -> Int # basicUnsafeSlice :: Int -> Int -> MVector s Int32 -> MVector s Int32 # basicOverlaps :: MVector s Int32 -> MVector s Int32 -> Bool # basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Int32) # basicInitialize :: PrimMonad m => MVector (PrimState m) Int32 -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> Int32 -> m (MVector (PrimState m) Int32) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Int32 -> Int -> m Int32 # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Int32 -> Int -> Int32 -> m () # basicClear :: PrimMonad m => MVector (PrimState m) Int32 -> m () # basicSet :: PrimMonad m => MVector (PrimState m) Int32 -> Int32 -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Int32 -> MVector (PrimState m) Int32 -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Int32 -> MVector (PrimState m) Int32 -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Int32 -> Int -> m (MVector (PrimState m) Int32) #
Lift Exp Int32 #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain Int32 :: Type # Methods lift :: Int32 -> Exp (Plain Int32) #
ToFloating Int32 Double #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int32 -> Exp Double #
ToFloating Int32 Float #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int32 -> Exp Float #
ToFloating Int32 CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int32 -> Exp CFloat #
ToFloating Int32 CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int32 -> Exp CDouble #
ToFloating Int32 Half #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int32 -> Exp Half #
FromIntegral Int Int32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int -> Exp Int32 #
FromIntegral Int8 Int32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int8 -> Exp Int32 #
FromIntegral Int16 Int32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int16 -> Exp Int32 #
FromIntegral Int32 Double #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int32 -> Exp Double #
FromIntegral Int32 Float #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int32 -> Exp Float #
FromIntegral Int32 Int #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int32 -> Exp Int #
FromIntegral Int32 Int8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int32 -> Exp Int8 #
FromIntegral Int32 Int16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int32 -> Exp Int16 #
FromIntegral Int32 Int32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int32 -> Exp Int32 #
FromIntegral Int32 Int64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int32 -> Exp Int64 #
FromIntegral Int32 Word #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int32 -> Exp Word #
FromIntegral Int32 Word8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int32 -> Exp Word8 #
FromIntegral Int32 Word16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int32 -> Exp Word16 #
FromIntegral Int32 Word32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int32 -> Exp Word32 #
FromIntegral Int32 Word64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int32 -> Exp Word64 #
FromIntegral Int32 CShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int32 -> Exp CShort #
FromIntegral Int32 CUShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int32 -> Exp CUShort #
FromIntegral Int32 CInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int32 -> Exp CInt #
FromIntegral Int32 CUInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int32 -> Exp CUInt #
FromIntegral Int32 CLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int32 -> Exp CLong #
FromIntegral Int32 CULong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int32 -> Exp CULong #
FromIntegral Int32 CLLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int32 -> Exp CLLong #
FromIntegral Int32 CULLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int32 -> Exp CULLong #
FromIntegral Int32 CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int32 -> Exp CFloat #
FromIntegral Int32 CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int32 -> Exp CDouble #
FromIntegral Int32 Half #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int32 -> Exp Half #
FromIntegral Int64 Int32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int64 -> Exp Int32 #
FromIntegral Word Int32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word -> Exp Int32 #
FromIntegral Word8 Int32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word8 -> Exp Int32 #
FromIntegral Word16 Int32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word16 -> Exp Int32 #
FromIntegral Word32 Int32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word32 -> Exp Int32 #
FromIntegral Word64 Int32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word64 -> Exp Int32 #
FromIntegral CShort Int32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CShort -> Exp Int32 #
FromIntegral CUShort Int32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUShort -> Exp Int32 #
FromIntegral CInt Int32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CInt -> Exp Int32 #
FromIntegral CUInt Int32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUInt -> Exp Int32 #
FromIntegral CLong Int32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLong -> Exp Int32 #
FromIntegral CULong Int32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULong -> Exp Int32 #
FromIntegral CLLong Int32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLLong -> Exp Int32 #
FromIntegral CULLong Int32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULLong -> Exp Int32 #
Bounded (Exp Int32) #
Instance details Defined in Data.Array.Accelerate.Classes.Bounded Methods minBound :: Exp Int32 # maxBound :: Exp Int32 #
Enum (Exp Int32) #
Instance details Defined in Data.Array.Accelerate.Classes.Enum Methods succ :: Exp Int32 -> Exp Int32 # pred :: Exp Int32 -> Exp Int32 # toEnum :: Int -> Exp Int32 # fromEnum :: Exp Int32 -> Int # enumFrom :: Exp Int32 -> [Exp Int32] # enumFromThen :: Exp Int32 -> Exp Int32 -> [Exp Int32] # enumFromTo :: Exp Int32 -> Exp Int32 -> [Exp Int32] # enumFromThenTo :: Exp Int32 -> Exp Int32 -> Exp Int32 -> [Exp Int32] #
Integral (Exp Int32) #
Instance details Defined in Data.Array.Accelerate.Classes.Integral Methods quot :: Exp Int32 -> Exp Int32 -> Exp Int32 # rem :: Exp Int32 -> Exp Int32 -> Exp Int32 # div :: Exp Int32 -> Exp Int32 -> Exp Int32 # mod :: Exp Int32 -> Exp Int32 -> Exp Int32 # quotRem :: Exp Int32 -> Exp Int32 -> (Exp Int32, Exp Int32) # divMod :: Exp Int32 -> Exp Int32 -> (Exp Int32, Exp Int32) # toInteger :: Exp Int32 -> Integer #
Num (Exp Int32) #
Instance details Defined in Data.Array.Accelerate.Classes.Num Methods (+) :: Exp Int32 -> Exp Int32 -> Exp Int32 # (-) :: Exp Int32 -> Exp Int32 -> Exp Int32 # (*) :: Exp Int32 -> Exp Int32 -> Exp Int32 # negate :: Exp Int32 -> Exp Int32 # abs :: Exp Int32 -> Exp Int32 # signum :: Exp Int32 -> Exp Int32 # fromInteger :: Integer -> Exp Int32 #
type PrimSize Int32
Instance details Defined in Basement.PrimType type PrimSize Int32 = 4
type Difference Int32
Instance details Defined in Basement.Numerical.Subtractive type Difference Int32 = Int32
type NatNumMaxBound Int32
Instance details Defined in Basement.Nat type NatNumMaxBound Int32 = 2147483647
newtype Vector Int32
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Int32 = V_Int32 (Vector Int32)
type Plain Int32 #
Instance details Defined in Data.Array.Accelerate.Lift type Plain Int32 = Int32
newtype MVector s Int32
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Int32 = MV_Int32 (MVector s Int32)

data Int64 #

64-bit signed integer type

Instances

Bounded Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods minBound :: Int64 # maxBound :: Int64 #
Enum Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods succ :: Int64 -> Int64 # pred :: Int64 -> Int64 # toEnum :: Int -> Int64 # fromEnum :: Int64 -> Int # enumFrom :: Int64 -> [Int64] # enumFromThen :: Int64 -> Int64 -> [Int64] # enumFromTo :: Int64 -> Int64 -> [Int64] # enumFromThenTo :: Int64 -> Int64 -> Int64 -> [Int64] #
Eq Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods (==) :: Int64 -> Int64 -> Bool # (/=) :: Int64 -> Int64 -> Bool #
Integral Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods quot :: Int64 -> Int64 -> Int64 # rem :: Int64 -> Int64 -> Int64 # div :: Int64 -> Int64 -> Int64 # mod :: Int64 -> Int64 -> Int64 # quotRem :: Int64 -> Int64 -> (Int64, Int64) # divMod :: Int64 -> Int64 -> (Int64, Int64) # toInteger :: Int64 -> Integer #
Num Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods (+) :: Int64 -> Int64 -> Int64 # (-) :: Int64 -> Int64 -> Int64 # (*) :: Int64 -> Int64 -> Int64 # negate :: Int64 -> Int64 # abs :: Int64 -> Int64 # signum :: Int64 -> Int64 # fromInteger :: Integer -> Int64 #
Ord Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods compare :: Int64 -> Int64 -> Ordering # (<) :: Int64 -> Int64 -> Bool # (<=) :: Int64 -> Int64 -> Bool # (>) :: Int64 -> Int64 -> Bool # (>=) :: Int64 -> Int64 -> Bool # max :: Int64 -> Int64 -> Int64 # min :: Int64 -> Int64 -> Int64 #
Read Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods readsPrec :: Int -> ReadS Int64 # readList :: ReadS [Int64] # readPrec :: ReadPrec Int64 # readListPrec :: ReadPrec [Int64] #
Real Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods toRational :: Int64 -> Rational #
Show Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods showsPrec :: Int -> Int64 -> ShowS # show :: Int64 -> String # showList :: [Int64] -> ShowS #
Ix Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods range :: (Int64, Int64) -> [Int64] # index :: (Int64, Int64) -> Int64 -> Int # unsafeIndex :: (Int64, Int64) -> Int64 -> Int inRange :: (Int64, Int64) -> Int64 -> Bool # rangeSize :: (Int64, Int64) -> Int # unsafeRangeSize :: (Int64, Int64) -> Int
Lift Int64
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Int64 -> Q Exp #
PrintfArg Int64	Since: base-2.1
Instance details Defined in Text.Printf Methods formatArg :: Int64 -> FieldFormatter # parseFormat :: Int64 -> ModifierParser #
Storable Int64	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Int64 -> Int # alignment :: Int64 -> Int # peekElemOff :: Ptr Int64 -> Int -> IO Int64 # pokeElemOff :: Ptr Int64 -> Int -> Int64 -> IO () # peekByteOff :: Ptr b -> Int -> IO Int64 # pokeByteOff :: Ptr b -> Int -> Int64 -> IO () # peek :: Ptr Int64 -> IO Int64 # poke :: Ptr Int64 -> Int64 -> IO () #
Bits Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods (.&.) :: Int64 -> Int64 -> Int64 # (.\|.) :: Int64 -> Int64 -> Int64 # xor :: Int64 -> Int64 -> Int64 # complement :: Int64 -> Int64 # shift :: Int64 -> Int -> Int64 # rotate :: Int64 -> Int -> Int64 # zeroBits :: Int64 # bit :: Int -> Int64 # setBit :: Int64 -> Int -> Int64 # clearBit :: Int64 -> Int -> Int64 # complementBit :: Int64 -> Int -> Int64 # testBit :: Int64 -> Int -> Bool # bitSizeMaybe :: Int64 -> Maybe Int # bitSize :: Int64 -> Int # isSigned :: Int64 -> Bool # shiftL :: Int64 -> Int -> Int64 # unsafeShiftL :: Int64 -> Int -> Int64 # shiftR :: Int64 -> Int -> Int64 # unsafeShiftR :: Int64 -> Int -> Int64 # rotateL :: Int64 -> Int -> Int64 # rotateR :: Int64 -> Int -> Int64 # popCount :: Int64 -> Int #
FiniteBits Int64	Since: base-4.6.0.0
Instance details Defined in GHC.Int Methods finiteBitSize :: Int64 -> Int # countLeadingZeros :: Int64 -> Int # countTrailingZeros :: Int64 -> Int #
PrimType Int64
Instance details Defined in Basement.PrimType Associated Types type PrimSize Int64 :: Nat # Methods primSizeInBytes :: Proxy Int64 -> CountOf Word8 # primShiftToBytes :: Proxy Int64 -> Int # primBaUIndex :: ByteArray# -> Offset Int64 -> Int64 # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Int64 -> prim Int64 # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Int64 -> Int64 -> prim () # primAddrIndex :: Addr# -> Offset Int64 -> Int64 # primAddrRead :: PrimMonad prim => Addr# -> Offset Int64 -> prim Int64 # primAddrWrite :: PrimMonad prim => Addr# -> Offset Int64 -> Int64 -> prim () #
PrimMemoryComparable Int64
Instance details Defined in Basement.PrimType
Subtractive Int64
Instance details Defined in Basement.Numerical.Subtractive Associated Types type Difference Int64 :: Type # Methods (-) :: Int64 -> Int64 -> Difference Int64 #
NFData Int64
Instance details Defined in Control.DeepSeq Methods rnf :: Int64 -> () #
Hashable Int64
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Int64 -> Int # hash :: Int64 -> Int #
Prim Int64
Instance details Defined in Data.Primitive.Types Methods sizeOf# :: Int64 -> Int# # alignment# :: Int64 -> Int# # indexByteArray# :: ByteArray# -> Int# -> Int64 # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, Int64#) # writeByteArray# :: MutableByteArray# s -> Int# -> Int64 -> State# s -> State# s # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Int64 -> State# s -> State# s # indexOffAddr# :: Addr# -> Int# -> Int64 # readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, Int64#) # writeOffAddr# :: Addr# -> Int# -> Int64 -> State# s -> State# s # setOffAddr# :: Addr# -> Int# -> Int# -> Int64 -> State# s -> State# s #
Unbox Int64
Instance details Defined in Data.Vector.Unboxed.Base
Pretty Int64
Instance details Defined in Text.PrettyPrint.Annotated.WL Methods pretty :: Int64 -> Doc b # prettyList :: [Int64] -> Doc b #
IsScalar Int64 #
Instance details Defined in Data.Array.Accelerate.Type Methods scalarType :: ScalarType Int64
IsBounded Int64 #
Instance details Defined in Data.Array.Accelerate.Type Methods boundedType :: BoundedType Int64
IsNum Int64 #
Instance details Defined in Data.Array.Accelerate.Type Methods numType :: NumType Int64
IsIntegral Int64 #
Instance details Defined in Data.Array.Accelerate.Type Methods integralType :: IntegralType Int64
Elt Int64 #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods eltType :: Int64 -> TupleType (EltRepr Int64) fromElt :: Int64 -> EltRepr Int64 toElt :: EltRepr Int64 -> Int64
Eq Int64 #
Instance details Defined in Data.Array.Accelerate.Classes.Eq Methods (==) :: Exp Int64 -> Exp Int64 -> Exp Bool # (/=) :: Exp Int64 -> Exp Int64 -> Exp Bool #
Ord Int64 #
Instance details Defined in Data.Array.Accelerate.Classes.Ord Methods (<) :: Exp Int64 -> Exp Int64 -> Exp Bool # (>) :: Exp Int64 -> Exp Int64 -> Exp Bool # (<=) :: Exp Int64 -> Exp Int64 -> Exp Bool # (>=) :: Exp Int64 -> Exp Int64 -> Exp Bool # min :: Exp Int64 -> Exp Int64 -> Exp Int64 # max :: Exp Int64 -> Exp Int64 -> Exp Int64 # compare :: Exp Int64 -> Exp Int64 -> Exp Ordering #
FiniteBits Int64 #
Instance details Defined in Data.Array.Accelerate.Data.Bits Methods finiteBitSize :: Exp Int64 -> Exp Int # countLeadingZeros :: Exp Int64 -> Exp Int # countTrailingZeros :: Exp Int64 -> Exp Int #
Bits Int64 #
Instance details Defined in Data.Array.Accelerate.Data.Bits Methods (.&.) :: Exp Int64 -> Exp Int64 -> Exp Int64 # (.\|.) :: Exp Int64 -> Exp Int64 -> Exp Int64 # xor :: Exp Int64 -> Exp Int64 -> Exp Int64 # complement :: Exp Int64 -> Exp Int64 # shift :: Exp Int64 -> Exp Int -> Exp Int64 # rotate :: Exp Int64 -> Exp Int -> Exp Int64 # zeroBits :: Exp Int64 # bit :: Exp Int -> Exp Int64 # setBit :: Exp Int64 -> Exp Int -> Exp Int64 # clearBit :: Exp Int64 -> Exp Int -> Exp Int64 # complementBit :: Exp Int64 -> Exp Int -> Exp Int64 # testBit :: Exp Int64 -> Exp Int -> Exp Bool # isSigned :: Exp Int64 -> Exp Bool # shiftL :: Exp Int64 -> Exp Int -> Exp Int64 # unsafeShiftL :: Exp Int64 -> Exp Int -> Exp Int64 # shiftR :: Exp Int64 -> Exp Int -> Exp Int64 # unsafeShiftR :: Exp Int64 -> Exp Int -> Exp Int64 # rotateL :: Exp Int64 -> Exp Int -> Exp Int64 # rotateR :: Exp Int64 -> Exp Int -> Exp Int64 # popCount :: Exp Int64 -> Exp Int #
Vector Vector Int64
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Int64 -> m (Vector Int64) # basicUnsafeThaw :: PrimMonad m => Vector Int64 -> m (Mutable Vector (PrimState m) Int64) # basicLength :: Vector Int64 -> Int # basicUnsafeSlice :: Int -> Int -> Vector Int64 -> Vector Int64 # basicUnsafeIndexM :: Monad m => Vector Int64 -> Int -> m Int64 # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Int64 -> Vector Int64 -> m () # elemseq :: Vector Int64 -> Int64 -> b -> b #
MVector MVector Int64
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Int64 -> Int # basicUnsafeSlice :: Int -> Int -> MVector s Int64 -> MVector s Int64 # basicOverlaps :: MVector s Int64 -> MVector s Int64 -> Bool # basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Int64) # basicInitialize :: PrimMonad m => MVector (PrimState m) Int64 -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> Int64 -> m (MVector (PrimState m) Int64) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Int64 -> Int -> m Int64 # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Int64 -> Int -> Int64 -> m () # basicClear :: PrimMonad m => MVector (PrimState m) Int64 -> m () # basicSet :: PrimMonad m => MVector (PrimState m) Int64 -> Int64 -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Int64 -> MVector (PrimState m) Int64 -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Int64 -> MVector (PrimState m) Int64 -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Int64 -> Int -> m (MVector (PrimState m) Int64) #
Lift Exp Int64 #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain Int64 :: Type # Methods lift :: Int64 -> Exp (Plain Int64) #
ToFloating Int64 Double #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int64 -> Exp Double #
ToFloating Int64 Float #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int64 -> Exp Float #
ToFloating Int64 CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int64 -> Exp CFloat #
ToFloating Int64 CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int64 -> Exp CDouble #
ToFloating Int64 Half #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int64 -> Exp Half #
FromIntegral Int Int64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int -> Exp Int64 #
FromIntegral Int8 Int64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int8 -> Exp Int64 #
FromIntegral Int16 Int64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int16 -> Exp Int64 #
FromIntegral Int32 Int64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int32 -> Exp Int64 #
FromIntegral Int64 Double #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int64 -> Exp Double #
FromIntegral Int64 Float #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int64 -> Exp Float #
FromIntegral Int64 Int #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int64 -> Exp Int #
FromIntegral Int64 Int8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int64 -> Exp Int8 #
FromIntegral Int64 Int16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int64 -> Exp Int16 #
FromIntegral Int64 Int32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int64 -> Exp Int32 #
FromIntegral Int64 Int64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int64 -> Exp Int64 #
FromIntegral Int64 Word #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int64 -> Exp Word #
FromIntegral Int64 Word8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int64 -> Exp Word8 #
FromIntegral Int64 Word16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int64 -> Exp Word16 #
FromIntegral Int64 Word32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int64 -> Exp Word32 #
FromIntegral Int64 Word64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int64 -> Exp Word64 #
FromIntegral Int64 CShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int64 -> Exp CShort #
FromIntegral Int64 CUShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int64 -> Exp CUShort #
FromIntegral Int64 CInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int64 -> Exp CInt #
FromIntegral Int64 CUInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int64 -> Exp CUInt #
FromIntegral Int64 CLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int64 -> Exp CLong #
FromIntegral Int64 CULong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int64 -> Exp CULong #
FromIntegral Int64 CLLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int64 -> Exp CLLong #
FromIntegral Int64 CULLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int64 -> Exp CULLong #
FromIntegral Int64 CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int64 -> Exp CFloat #
FromIntegral Int64 CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int64 -> Exp CDouble #
FromIntegral Int64 Half #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int64 -> Exp Half #
FromIntegral Word Int64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word -> Exp Int64 #
FromIntegral Word8 Int64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word8 -> Exp Int64 #
FromIntegral Word16 Int64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word16 -> Exp Int64 #
FromIntegral Word32 Int64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word32 -> Exp Int64 #
FromIntegral Word64 Int64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word64 -> Exp Int64 #
FromIntegral CShort Int64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CShort -> Exp Int64 #
FromIntegral CUShort Int64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUShort -> Exp Int64 #
FromIntegral CInt Int64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CInt -> Exp Int64 #
FromIntegral CUInt Int64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUInt -> Exp Int64 #
FromIntegral CLong Int64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLong -> Exp Int64 #
FromIntegral CULong Int64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULong -> Exp Int64 #
FromIntegral CLLong Int64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLLong -> Exp Int64 #
FromIntegral CULLong Int64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULLong -> Exp Int64 #
Bounded (Exp Int64) #
Instance details Defined in Data.Array.Accelerate.Classes.Bounded Methods minBound :: Exp Int64 # maxBound :: Exp Int64 #
Enum (Exp Int64) #
Instance details Defined in Data.Array.Accelerate.Classes.Enum Methods succ :: Exp Int64 -> Exp Int64 # pred :: Exp Int64 -> Exp Int64 # toEnum :: Int -> Exp Int64 # fromEnum :: Exp Int64 -> Int # enumFrom :: Exp Int64 -> [Exp Int64] # enumFromThen :: Exp Int64 -> Exp Int64 -> [Exp Int64] # enumFromTo :: Exp Int64 -> Exp Int64 -> [Exp Int64] # enumFromThenTo :: Exp Int64 -> Exp Int64 -> Exp Int64 -> [Exp Int64] #
Integral (Exp Int64) #
Instance details Defined in Data.Array.Accelerate.Classes.Integral Methods quot :: Exp Int64 -> Exp Int64 -> Exp Int64 # rem :: Exp Int64 -> Exp Int64 -> Exp Int64 # div :: Exp Int64 -> Exp Int64 -> Exp Int64 # mod :: Exp Int64 -> Exp Int64 -> Exp Int64 # quotRem :: Exp Int64 -> Exp Int64 -> (Exp Int64, Exp Int64) # divMod :: Exp Int64 -> Exp Int64 -> (Exp Int64, Exp Int64) # toInteger :: Exp Int64 -> Integer #
Num (Exp Int64) #
Instance details Defined in Data.Array.Accelerate.Classes.Num Methods (+) :: Exp Int64 -> Exp Int64 -> Exp Int64 # (-) :: Exp Int64 -> Exp Int64 -> Exp Int64 # (*) :: Exp Int64 -> Exp Int64 -> Exp Int64 # negate :: Exp Int64 -> Exp Int64 # abs :: Exp Int64 -> Exp Int64 # signum :: Exp Int64 -> Exp Int64 # fromInteger :: Integer -> Exp Int64 #
type PrimSize Int64
Instance details Defined in Basement.PrimType type PrimSize Int64 = 8
type Difference Int64
Instance details Defined in Basement.Numerical.Subtractive type Difference Int64 = Int64
type NatNumMaxBound Int64
Instance details Defined in Basement.Nat type NatNumMaxBound Int64 = 9223372036854775807
newtype Vector Int64
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Int64 = V_Int64 (Vector Int64)
type Plain Int64 #
Instance details Defined in Data.Array.Accelerate.Lift type Plain Int64 = Int64
newtype MVector s Int64
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Int64 = MV_Int64 (MVector s Int64)

data Word #

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

Instances

Bounded Word	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: Word # maxBound :: Word #
Enum Word	Since: base-2.1
Instance details Defined in GHC.Enum Methods succ :: Word -> Word # pred :: Word -> Word # toEnum :: Int -> Word # fromEnum :: Word -> Int # enumFrom :: Word -> [Word] # enumFromThen :: Word -> Word -> [Word] # enumFromTo :: Word -> Word -> [Word] # enumFromThenTo :: Word -> Word -> Word -> [Word] #
Eq Word
Instance details Defined in GHC.Classes Methods (==) :: Word -> Word -> Bool # (/=) :: Word -> Word -> Bool #
Integral Word	Since: base-2.1
Instance details Defined in GHC.Real Methods quot :: Word -> Word -> Word # rem :: Word -> Word -> Word # div :: Word -> Word -> Word # mod :: Word -> Word -> Word # quotRem :: Word -> Word -> (Word, Word) # divMod :: Word -> Word -> (Word, Word) # toInteger :: Word -> Integer #
Num Word	Since: base-2.1
Instance details Defined in GHC.Num Methods (+) :: Word -> Word -> Word # (-) :: Word -> Word -> Word # (*) :: Word -> Word -> Word # negate :: Word -> Word # abs :: Word -> Word # signum :: Word -> Word # fromInteger :: Integer -> Word #
Ord Word
Instance details Defined in GHC.Classes Methods compare :: Word -> Word -> Ordering # (<) :: Word -> Word -> Bool # (<=) :: Word -> Word -> Bool # (>) :: Word -> Word -> Bool # (>=) :: Word -> Word -> Bool # max :: Word -> Word -> Word # min :: Word -> Word -> Word #
Read Word	Since: base-4.5.0.0
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Word # readList :: ReadS [Word] # readPrec :: ReadPrec Word # readListPrec :: ReadPrec [Word] #
Real Word	Since: base-2.1
Instance details Defined in GHC.Real Methods toRational :: Word -> Rational #
Show Word	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Word -> ShowS # show :: Word -> String # showList :: [Word] -> ShowS #
Lift Word
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Word -> Q Exp #
PrintfArg Word	Since: base-2.1
Instance details Defined in Text.Printf Methods formatArg :: Word -> FieldFormatter # parseFormat :: Word -> ModifierParser #
Storable Word	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Word -> Int # alignment :: Word -> Int # peekElemOff :: Ptr Word -> Int -> IO Word # pokeElemOff :: Ptr Word -> Int -> Word -> IO () # peekByteOff :: Ptr b -> Int -> IO Word # pokeByteOff :: Ptr b -> Int -> Word -> IO () # peek :: Ptr Word -> IO Word # poke :: Ptr Word -> Word -> IO () #
Bits Word	Since: base-2.1
Instance details Defined in Data.Bits Methods (.&.) :: Word -> Word -> Word # (.\|.) :: Word -> Word -> Word # xor :: Word -> Word -> Word # complement :: Word -> Word # shift :: Word -> Int -> Word # rotate :: Word -> Int -> Word # zeroBits :: Word # bit :: Int -> Word # setBit :: Word -> Int -> Word # clearBit :: Word -> Int -> Word # complementBit :: Word -> Int -> Word # testBit :: Word -> Int -> Bool # bitSizeMaybe :: Word -> Maybe Int # bitSize :: Word -> Int # isSigned :: Word -> Bool # shiftL :: Word -> Int -> Word # unsafeShiftL :: Word -> Int -> Word # shiftR :: Word -> Int -> Word # unsafeShiftR :: Word -> Int -> Word # rotateL :: Word -> Int -> Word # rotateR :: Word -> Int -> Word # popCount :: Word -> Int #
FiniteBits Word	Since: base-4.6.0.0
Instance details Defined in Data.Bits Methods finiteBitSize :: Word -> Int # countLeadingZeros :: Word -> Int # countTrailingZeros :: Word -> Int #
PrimType Word
Instance details Defined in Basement.PrimType Associated Types type PrimSize Word :: Nat # Methods primSizeInBytes :: Proxy Word -> CountOf Word8 # primShiftToBytes :: Proxy Word -> Int # primBaUIndex :: ByteArray# -> Offset Word -> Word # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Word -> prim Word # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Word -> Word -> prim () # primAddrIndex :: Addr# -> Offset Word -> Word # primAddrRead :: PrimMonad prim => Addr# -> Offset Word -> prim Word # primAddrWrite :: PrimMonad prim => Addr# -> Offset Word -> Word -> prim () #
PrimMemoryComparable Word
Instance details Defined in Basement.PrimType
Subtractive Word
Instance details Defined in Basement.Numerical.Subtractive Associated Types type Difference Word :: Type # Methods (-) :: Word -> Word -> Difference Word #
NFData Word
Instance details Defined in Control.DeepSeq Methods rnf :: Word -> () #
Hashable Word
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Word -> Int # hash :: Word -> Int #
Prim Word
Instance details Defined in Data.Primitive.Types Methods sizeOf# :: Word -> Int# # alignment# :: Word -> Int# # indexByteArray# :: ByteArray# -> Int# -> Word # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, Word#) # writeByteArray# :: MutableByteArray# s -> Int# -> Word -> State# s -> State# s # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Word -> State# s -> State# s # indexOffAddr# :: Addr# -> Int# -> Word # readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, Word#) # writeOffAddr# :: Addr# -> Int# -> Word -> State# s -> State# s # setOffAddr# :: Addr# -> Int# -> Int# -> Word -> State# s -> State# s #
Unbox Word
Instance details Defined in Data.Vector.Unboxed.Base
Pretty Word
Instance details Defined in Text.PrettyPrint.Annotated.WL Methods pretty :: Word -> Doc b # prettyList :: [Word] -> Doc b #
IsScalar Word #
Instance details Defined in Data.Array.Accelerate.Type Methods scalarType :: ScalarType Word
IsBounded Word #
Instance details Defined in Data.Array.Accelerate.Type Methods boundedType :: BoundedType Word
IsNum Word #
Instance details Defined in Data.Array.Accelerate.Type Methods numType :: NumType Word
IsIntegral Word #
Instance details Defined in Data.Array.Accelerate.Type Methods integralType :: IntegralType Word
Elt Word #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods eltType :: Word -> TupleType (EltRepr Word) fromElt :: Word -> EltRepr Word toElt :: EltRepr Word -> Word
Eq Word #
Instance details Defined in Data.Array.Accelerate.Classes.Eq Methods (==) :: Exp Word -> Exp Word -> Exp Bool # (/=) :: Exp Word -> Exp Word -> Exp Bool #
Ord Word #
Instance details Defined in Data.Array.Accelerate.Classes.Ord Methods (<) :: Exp Word -> Exp Word -> Exp Bool # (>) :: Exp Word -> Exp Word -> Exp Bool # (<=) :: Exp Word -> Exp Word -> Exp Bool # (>=) :: Exp Word -> Exp Word -> Exp Bool # min :: Exp Word -> Exp Word -> Exp Word # max :: Exp Word -> Exp Word -> Exp Word # compare :: Exp Word -> Exp Word -> Exp Ordering #
FiniteBits Word #
Instance details Defined in Data.Array.Accelerate.Data.Bits Methods finiteBitSize :: Exp Word -> Exp Int # countLeadingZeros :: Exp Word -> Exp Int # countTrailingZeros :: Exp Word -> Exp Int #
Bits Word #
Instance details Defined in Data.Array.Accelerate.Data.Bits Methods (.&.) :: Exp Word -> Exp Word -> Exp Word # (.\|.) :: Exp Word -> Exp Word -> Exp Word # xor :: Exp Word -> Exp Word -> Exp Word # complement :: Exp Word -> Exp Word # shift :: Exp Word -> Exp Int -> Exp Word # rotate :: Exp Word -> Exp Int -> Exp Word # zeroBits :: Exp Word # bit :: Exp Int -> Exp Word # setBit :: Exp Word -> Exp Int -> Exp Word # clearBit :: Exp Word -> Exp Int -> Exp Word # complementBit :: Exp Word -> Exp Int -> Exp Word # testBit :: Exp Word -> Exp Int -> Exp Bool # isSigned :: Exp Word -> Exp Bool # shiftL :: Exp Word -> Exp Int -> Exp Word # unsafeShiftL :: Exp Word -> Exp Int -> Exp Word # shiftR :: Exp Word -> Exp Int -> Exp Word # unsafeShiftR :: Exp Word -> Exp Int -> Exp Word # rotateL :: Exp Word -> Exp Int -> Exp Word # rotateR :: Exp Word -> Exp Int -> Exp Word # popCount :: Exp Word -> Exp Int #
Vector Vector Word
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Word -> m (Vector Word) # basicUnsafeThaw :: PrimMonad m => Vector Word -> m (Mutable Vector (PrimState m) Word) # basicLength :: Vector Word -> Int # basicUnsafeSlice :: Int -> Int -> Vector Word -> Vector Word # basicUnsafeIndexM :: Monad m => Vector Word -> Int -> m Word # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Word -> Vector Word -> m () # elemseq :: Vector Word -> Word -> b -> b #
MVector MVector Word
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Word -> Int # basicUnsafeSlice :: Int -> Int -> MVector s Word -> MVector s Word # basicOverlaps :: MVector s Word -> MVector s Word -> Bool # basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Word) # basicInitialize :: PrimMonad m => MVector (PrimState m) Word -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> Word -> m (MVector (PrimState m) Word) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Word -> Int -> m Word # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Word -> Int -> Word -> m () # basicClear :: PrimMonad m => MVector (PrimState m) Word -> m () # basicSet :: PrimMonad m => MVector (PrimState m) Word -> Word -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Word -> MVector (PrimState m) Word -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Word -> MVector (PrimState m) Word -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Word -> Int -> m (MVector (PrimState m) Word) #
Lift Exp Word #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain Word :: Type # Methods lift :: Word -> Exp (Plain Word) #
ToFloating Word Double #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word -> Exp Double #
ToFloating Word Float #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word -> Exp Float #
ToFloating Word CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word -> Exp CFloat #
ToFloating Word CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word -> Exp CDouble #
ToFloating Word Half #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word -> Exp Half #
FromIntegral Int Word #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int -> Exp Word #
FromIntegral Int8 Word #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int8 -> Exp Word #
FromIntegral Int16 Word #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int16 -> Exp Word #
FromIntegral Int32 Word #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int32 -> Exp Word #
FromIntegral Int64 Word #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int64 -> Exp Word #
FromIntegral Word Double #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word -> Exp Double #
FromIntegral Word Float #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word -> Exp Float #
FromIntegral Word Int #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word -> Exp Int #
FromIntegral Word Int8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word -> Exp Int8 #
FromIntegral Word Int16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word -> Exp Int16 #
FromIntegral Word Int32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word -> Exp Int32 #
FromIntegral Word Int64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word -> Exp Int64 #
FromIntegral Word Word #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word -> Exp Word #
FromIntegral Word Word8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word -> Exp Word8 #
FromIntegral Word Word16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word -> Exp Word16 #
FromIntegral Word Word32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word -> Exp Word32 #
FromIntegral Word Word64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word -> Exp Word64 #
FromIntegral Word CShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word -> Exp CShort #
FromIntegral Word CUShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word -> Exp CUShort #
FromIntegral Word CInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word -> Exp CInt #
FromIntegral Word CUInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word -> Exp CUInt #
FromIntegral Word CLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word -> Exp CLong #
FromIntegral Word CULong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word -> Exp CULong #
FromIntegral Word CLLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word -> Exp CLLong #
FromIntegral Word CULLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word -> Exp CULLong #
FromIntegral Word CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word -> Exp CFloat #
FromIntegral Word CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word -> Exp CDouble #
FromIntegral Word Half #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word -> Exp Half #
FromIntegral Word8 Word #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word8 -> Exp Word #
FromIntegral Word16 Word #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word16 -> Exp Word #
FromIntegral Word32 Word #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word32 -> Exp Word #
FromIntegral Word64 Word #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word64 -> Exp Word #
FromIntegral CShort Word #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CShort -> Exp Word #
FromIntegral CUShort Word #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUShort -> Exp Word #
FromIntegral CInt Word #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CInt -> Exp Word #
FromIntegral CUInt Word #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUInt -> Exp Word #
FromIntegral CLong Word #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLong -> Exp Word #
FromIntegral CULong Word #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULong -> Exp Word #
FromIntegral CLLong Word #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLLong -> Exp Word #
FromIntegral CULLong Word #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULLong -> Exp Word #
() :=> (Bounded Word)
Instance details Defined in Data.Constraint Methods ins :: () :- Bounded Word #
() :=> (Enum Word)
Instance details Defined in Data.Constraint Methods ins :: () :- Enum Word #
() :=> (Eq Word)
Instance details Defined in Data.Constraint Methods ins :: () :- Eq Word #
() :=> (Integral Word)
Instance details Defined in Data.Constraint Methods ins :: () :- Integral Word #
() :=> (Num Word)
Instance details Defined in Data.Constraint Methods ins :: () :- Num Word #
() :=> (Ord Word)
Instance details Defined in Data.Constraint Methods ins :: () :- Ord Word #
() :=> (Read Word)
Instance details Defined in Data.Constraint Methods ins :: () :- Read Word #
() :=> (Real Word)
Instance details Defined in Data.Constraint Methods ins :: () :- Real Word #
() :=> (Show Word)
Instance details Defined in Data.Constraint Methods ins :: () :- Show Word #
() :=> (Bits Word)
Instance details Defined in Data.Constraint Methods ins :: () :- Bits Word #
Generic1 (URec Word :: k -> Type)
Instance details Defined in GHC.Generics Associated Types type Rep1 (URec Word) :: k -> Type # Methods from1 :: URec Word a -> Rep1 (URec Word) a # to1 :: Rep1 (URec Word) a -> URec Word a #
Bounded (Exp Word) #
Instance details Defined in Data.Array.Accelerate.Classes.Bounded Methods minBound :: Exp Word # maxBound :: Exp Word #
Enum (Exp Word) #
Instance details Defined in Data.Array.Accelerate.Classes.Enum Methods succ :: Exp Word -> Exp Word # pred :: Exp Word -> Exp Word # toEnum :: Int -> Exp Word # fromEnum :: Exp Word -> Int # enumFrom :: Exp Word -> [Exp Word] # enumFromThen :: Exp Word -> Exp Word -> [Exp Word] # enumFromTo :: Exp Word -> Exp Word -> [Exp Word] # enumFromThenTo :: Exp Word -> Exp Word -> Exp Word -> [Exp Word] #
Integral (Exp Word) #
Instance details Defined in Data.Array.Accelerate.Classes.Integral Methods quot :: Exp Word -> Exp Word -> Exp Word # rem :: Exp Word -> Exp Word -> Exp Word # div :: Exp Word -> Exp Word -> Exp Word # mod :: Exp Word -> Exp Word -> Exp Word # quotRem :: Exp Word -> Exp Word -> (Exp Word, Exp Word) # divMod :: Exp Word -> Exp Word -> (Exp Word, Exp Word) # toInteger :: Exp Word -> Integer #
Num (Exp Word) #
Instance details Defined in Data.Array.Accelerate.Classes.Num Methods (+) :: Exp Word -> Exp Word -> Exp Word # (-) :: Exp Word -> Exp Word -> Exp Word # (*) :: Exp Word -> Exp Word -> Exp Word # negate :: Exp Word -> Exp Word # abs :: Exp Word -> Exp Word # signum :: Exp Word -> Exp Word # fromInteger :: Integer -> Exp Word #
Functor (URec Word :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> URec Word a -> URec Word b # (<$) :: a -> URec Word b -> URec Word a #
Foldable (URec Word :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Foldable 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 :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable 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)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (==) :: URec Word p -> URec Word p -> Bool # (/=) :: URec Word p -> URec Word p -> Bool #
Ord (URec Word p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods compare :: URec Word p -> URec Word p -> Ordering # (<) :: URec Word p -> URec Word p -> Bool # (<=) :: URec Word p -> URec Word p -> Bool # (>) :: URec Word p -> URec Word p -> Bool # (>=) :: URec Word p -> URec Word p -> Bool # max :: URec Word p -> URec Word p -> URec Word p # min :: URec Word p -> URec Word p -> URec Word p #
Show (URec Word p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> URec Word p -> ShowS # show :: URec Word p -> String # showList :: [URec Word p] -> ShowS #
Generic (URec Word p)
Instance details Defined in GHC.Generics Associated Types type Rep (URec Word p) :: Type -> Type # Methods from :: URec Word p -> Rep (URec Word p) x # to :: Rep (URec Word p) x -> URec Word p #
type PrimSize Word
Instance details Defined in Basement.PrimType type PrimSize Word = 8
type Difference Word
Instance details Defined in Basement.Numerical.Subtractive type Difference Word = Word
type NatNumMaxBound Word
Instance details Defined in Basement.Nat type NatNumMaxBound Word = NatNumMaxBound Word64
newtype Vector Word
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Word = V_Word (Vector Word)
type Plain Word #
Instance details Defined in Data.Array.Accelerate.Lift type Plain Word = Word
data URec Word (p :: k)	Used for marking occurrences of `Word#` Since: base-4.9.0.0
Instance details Defined in GHC.Generics data URec Word (p :: k) = UWord { uWord# :: Word# }
newtype MVector s Word
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Word = MV_Word (MVector s Word)
type Rep1 (URec Word :: k -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics type Rep1 (URec Word :: k -> Type) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UWord" PrefixI True) (S1 (MetaSel (Just "uWord#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (UWord :: k -> Type)))
type Rep (URec Word p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics type Rep (URec Word p) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UWord" PrefixI True) (S1 (MetaSel (Just "uWord#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (UWord :: Type -> Type)))

data Word8 #

8-bit unsigned integer type

Instances

Bounded Word8	Since: base-2.1
Instance details Defined in GHC.Word Methods minBound :: Word8 # maxBound :: Word8 #
Enum Word8	Since: base-2.1
Instance details Defined in GHC.Word Methods succ :: Word8 -> Word8 # pred :: Word8 -> Word8 # toEnum :: Int -> Word8 # fromEnum :: Word8 -> Int # enumFrom :: Word8 -> [Word8] # enumFromThen :: Word8 -> Word8 -> [Word8] # enumFromTo :: Word8 -> Word8 -> [Word8] # enumFromThenTo :: Word8 -> Word8 -> Word8 -> [Word8] #
Eq Word8	Since: base-2.1
Instance details Defined in GHC.Word Methods (==) :: Word8 -> Word8 -> Bool # (/=) :: Word8 -> Word8 -> Bool #
Integral Word8	Since: base-2.1
Instance details Defined in GHC.Word Methods quot :: Word8 -> Word8 -> Word8 # rem :: Word8 -> Word8 -> Word8 # div :: Word8 -> Word8 -> Word8 # mod :: Word8 -> Word8 -> Word8 # quotRem :: Word8 -> Word8 -> (Word8, Word8) # divMod :: Word8 -> Word8 -> (Word8, Word8) # toInteger :: Word8 -> Integer #
Num Word8	Since: base-2.1
Instance details Defined in GHC.Word Methods (+) :: Word8 -> Word8 -> Word8 # (-) :: Word8 -> Word8 -> Word8 # (*) :: Word8 -> Word8 -> Word8 # negate :: Word8 -> Word8 # abs :: Word8 -> Word8 # signum :: Word8 -> Word8 # fromInteger :: Integer -> Word8 #
Ord Word8	Since: base-2.1
Instance details Defined in GHC.Word Methods compare :: Word8 -> Word8 -> Ordering # (<) :: Word8 -> Word8 -> Bool # (<=) :: Word8 -> Word8 -> Bool # (>) :: Word8 -> Word8 -> Bool # (>=) :: Word8 -> Word8 -> Bool # max :: Word8 -> Word8 -> Word8 # min :: Word8 -> Word8 -> Word8 #
Read Word8	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Word8 # readList :: ReadS [Word8] # readPrec :: ReadPrec Word8 # readListPrec :: ReadPrec [Word8] #
Real Word8	Since: base-2.1
Instance details Defined in GHC.Word Methods toRational :: Word8 -> Rational #
Show Word8	Since: base-2.1
Instance details Defined in GHC.Word Methods showsPrec :: Int -> Word8 -> ShowS # show :: Word8 -> String # showList :: [Word8] -> ShowS #
Ix Word8	Since: base-2.1
Instance details Defined in GHC.Word Methods range :: (Word8, Word8) -> [Word8] # index :: (Word8, Word8) -> Word8 -> Int # unsafeIndex :: (Word8, Word8) -> Word8 -> Int inRange :: (Word8, Word8) -> Word8 -> Bool # rangeSize :: (Word8, Word8) -> Int # unsafeRangeSize :: (Word8, Word8) -> Int
Lift Word8
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Word8 -> Q Exp #
PrintfArg Word8	Since: base-2.1
Instance details Defined in Text.Printf Methods formatArg :: Word8 -> FieldFormatter # parseFormat :: Word8 -> ModifierParser #
Storable Word8	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Word8 -> Int # alignment :: Word8 -> Int # peekElemOff :: Ptr Word8 -> Int -> IO Word8 # pokeElemOff :: Ptr Word8 -> Int -> Word8 -> IO () # peekByteOff :: Ptr b -> Int -> IO Word8 # pokeByteOff :: Ptr b -> Int -> Word8 -> IO () # peek :: Ptr Word8 -> IO Word8 # poke :: Ptr Word8 -> Word8 -> IO () #
Bits Word8	Since: base-2.1
Instance details Defined in GHC.Word Methods (.&.) :: Word8 -> Word8 -> Word8 # (.\|.) :: Word8 -> Word8 -> Word8 # xor :: Word8 -> Word8 -> Word8 # complement :: Word8 -> Word8 # shift :: Word8 -> Int -> Word8 # rotate :: Word8 -> Int -> Word8 # zeroBits :: Word8 # bit :: Int -> Word8 # setBit :: Word8 -> Int -> Word8 # clearBit :: Word8 -> Int -> Word8 # complementBit :: Word8 -> Int -> Word8 # testBit :: Word8 -> Int -> Bool # bitSizeMaybe :: Word8 -> Maybe Int # bitSize :: Word8 -> Int # isSigned :: Word8 -> Bool # shiftL :: Word8 -> Int -> Word8 # unsafeShiftL :: Word8 -> Int -> Word8 # shiftR :: Word8 -> Int -> Word8 # unsafeShiftR :: Word8 -> Int -> Word8 # rotateL :: Word8 -> Int -> Word8 # rotateR :: Word8 -> Int -> Word8 # popCount :: Word8 -> Int #
FiniteBits Word8	Since: base-4.6.0.0
Instance details Defined in GHC.Word Methods finiteBitSize :: Word8 -> Int # countLeadingZeros :: Word8 -> Int # countTrailingZeros :: Word8 -> Int #
PrimType Word8
Instance details Defined in Basement.PrimType Associated Types type PrimSize Word8 :: Nat # Methods primSizeInBytes :: Proxy Word8 -> CountOf Word8 # primShiftToBytes :: Proxy Word8 -> Int # primBaUIndex :: ByteArray# -> Offset Word8 -> Word8 # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Word8 -> prim Word8 # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Word8 -> Word8 -> prim () # primAddrIndex :: Addr# -> Offset Word8 -> Word8 # primAddrRead :: PrimMonad prim => Addr# -> Offset Word8 -> prim Word8 # primAddrWrite :: PrimMonad prim => Addr# -> Offset Word8 -> Word8 -> prim () #
PrimMemoryComparable Word8
Instance details Defined in Basement.PrimType
Subtractive Word8
Instance details Defined in Basement.Numerical.Subtractive Associated Types type Difference Word8 :: Type # Methods (-) :: Word8 -> Word8 -> Difference Word8 #
NFData Word8
Instance details Defined in Control.DeepSeq Methods rnf :: Word8 -> () #
Hashable Word8
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Word8 -> Int # hash :: Word8 -> Int #
Prim Word8
Instance details Defined in Data.Primitive.Types Methods sizeOf# :: Word8 -> Int# # alignment# :: Word8 -> Int# # indexByteArray# :: ByteArray# -> Int# -> Word8 # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, Word8#) # writeByteArray# :: MutableByteArray# s -> Int# -> Word8 -> State# s -> State# s # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Word8 -> State# s -> State# s # indexOffAddr# :: Addr# -> Int# -> Word8 # readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, Word8#) # writeOffAddr# :: Addr# -> Int# -> Word8 -> State# s -> State# s # setOffAddr# :: Addr# -> Int# -> Int# -> Word8 -> State# s -> State# s #
Unbox Word8
Instance details Defined in Data.Vector.Unboxed.Base
Pretty Word8
Instance details Defined in Text.PrettyPrint.Annotated.WL Methods pretty :: Word8 -> Doc b # prettyList :: [Word8] -> Doc b #
IsScalar Word8 #
Instance details Defined in Data.Array.Accelerate.Type Methods scalarType :: ScalarType Word8
IsBounded Word8 #
Instance details Defined in Data.Array.Accelerate.Type Methods boundedType :: BoundedType Word8
IsNum Word8 #
Instance details Defined in Data.Array.Accelerate.Type Methods numType :: NumType Word8
IsIntegral Word8 #
Instance details Defined in Data.Array.Accelerate.Type Methods integralType :: IntegralType Word8
Elt Word8 #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods eltType :: Word8 -> TupleType (EltRepr Word8) fromElt :: Word8 -> EltRepr Word8 toElt :: EltRepr Word8 -> Word8
Eq Word8 #
Instance details Defined in Data.Array.Accelerate.Classes.Eq Methods (==) :: Exp Word8 -> Exp Word8 -> Exp Bool # (/=) :: Exp Word8 -> Exp Word8 -> Exp Bool #
Ord Word8 #
Instance details Defined in Data.Array.Accelerate.Classes.Ord Methods (<) :: Exp Word8 -> Exp Word8 -> Exp Bool # (>) :: Exp Word8 -> Exp Word8 -> Exp Bool # (<=) :: Exp Word8 -> Exp Word8 -> Exp Bool # (>=) :: Exp Word8 -> Exp Word8 -> Exp Bool # min :: Exp Word8 -> Exp Word8 -> Exp Word8 # max :: Exp Word8 -> Exp Word8 -> Exp Word8 # compare :: Exp Word8 -> Exp Word8 -> Exp Ordering #
FiniteBits Word8 #
Instance details Defined in Data.Array.Accelerate.Data.Bits Methods finiteBitSize :: Exp Word8 -> Exp Int # countLeadingZeros :: Exp Word8 -> Exp Int # countTrailingZeros :: Exp Word8 -> Exp Int #
Bits Word8 #
Instance details Defined in Data.Array.Accelerate.Data.Bits Methods (.&.) :: Exp Word8 -> Exp Word8 -> Exp Word8 # (.\|.) :: Exp Word8 -> Exp Word8 -> Exp Word8 # xor :: Exp Word8 -> Exp Word8 -> Exp Word8 # complement :: Exp Word8 -> Exp Word8 # shift :: Exp Word8 -> Exp Int -> Exp Word8 # rotate :: Exp Word8 -> Exp Int -> Exp Word8 # zeroBits :: Exp Word8 # bit :: Exp Int -> Exp Word8 # setBit :: Exp Word8 -> Exp Int -> Exp Word8 # clearBit :: Exp Word8 -> Exp Int -> Exp Word8 # complementBit :: Exp Word8 -> Exp Int -> Exp Word8 # testBit :: Exp Word8 -> Exp Int -> Exp Bool # isSigned :: Exp Word8 -> Exp Bool # shiftL :: Exp Word8 -> Exp Int -> Exp Word8 # unsafeShiftL :: Exp Word8 -> Exp Int -> Exp Word8 # shiftR :: Exp Word8 -> Exp Int -> Exp Word8 # unsafeShiftR :: Exp Word8 -> Exp Int -> Exp Word8 # rotateL :: Exp Word8 -> Exp Int -> Exp Word8 # rotateR :: Exp Word8 -> Exp Int -> Exp Word8 # popCount :: Exp Word8 -> Exp Int #
Vector Vector Word8
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Word8 -> m (Vector Word8) # basicUnsafeThaw :: PrimMonad m => Vector Word8 -> m (Mutable Vector (PrimState m) Word8) # basicLength :: Vector Word8 -> Int # basicUnsafeSlice :: Int -> Int -> Vector Word8 -> Vector Word8 # basicUnsafeIndexM :: Monad m => Vector Word8 -> Int -> m Word8 # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Word8 -> Vector Word8 -> m () # elemseq :: Vector Word8 -> Word8 -> b -> b #
MVector MVector Word8
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Word8 -> Int # basicUnsafeSlice :: Int -> Int -> MVector s Word8 -> MVector s Word8 # basicOverlaps :: MVector s Word8 -> MVector s Word8 -> Bool # basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Word8) # basicInitialize :: PrimMonad m => MVector (PrimState m) Word8 -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> Word8 -> m (MVector (PrimState m) Word8) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Word8 -> Int -> m Word8 # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Word8 -> Int -> Word8 -> m () # basicClear :: PrimMonad m => MVector (PrimState m) Word8 -> m () # basicSet :: PrimMonad m => MVector (PrimState m) Word8 -> Word8 -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Word8 -> MVector (PrimState m) Word8 -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Word8 -> MVector (PrimState m) Word8 -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Word8 -> Int -> m (MVector (PrimState m) Word8) #
Lift Exp Word8 #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain Word8 :: Type # Methods lift :: Word8 -> Exp (Plain Word8) #
ToFloating Word8 Double #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word8 -> Exp Double #
ToFloating Word8 Float #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word8 -> Exp Float #
ToFloating Word8 CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word8 -> Exp CFloat #
ToFloating Word8 CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word8 -> Exp CDouble #
ToFloating Word8 Half #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word8 -> Exp Half #
FromIntegral Int Word8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int -> Exp Word8 #
FromIntegral Int8 Word8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int8 -> Exp Word8 #
FromIntegral Int16 Word8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int16 -> Exp Word8 #
FromIntegral Int32 Word8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int32 -> Exp Word8 #
FromIntegral Int64 Word8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int64 -> Exp Word8 #
FromIntegral Word Word8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word -> Exp Word8 #
FromIntegral Word8 Double #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word8 -> Exp Double #
FromIntegral Word8 Float #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word8 -> Exp Float #
FromIntegral Word8 Int #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word8 -> Exp Int #
FromIntegral Word8 Int8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word8 -> Exp Int8 #
FromIntegral Word8 Int16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word8 -> Exp Int16 #
FromIntegral Word8 Int32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word8 -> Exp Int32 #
FromIntegral Word8 Int64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word8 -> Exp Int64 #
FromIntegral Word8 Word #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word8 -> Exp Word #
FromIntegral Word8 Word8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word8 -> Exp Word8 #
FromIntegral Word8 Word16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word8 -> Exp Word16 #
FromIntegral Word8 Word32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word8 -> Exp Word32 #
FromIntegral Word8 Word64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word8 -> Exp Word64 #
FromIntegral Word8 CShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word8 -> Exp CShort #
FromIntegral Word8 CUShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word8 -> Exp CUShort #
FromIntegral Word8 CInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word8 -> Exp CInt #
FromIntegral Word8 CUInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word8 -> Exp CUInt #
FromIntegral Word8 CLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word8 -> Exp CLong #
FromIntegral Word8 CULong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word8 -> Exp CULong #
FromIntegral Word8 CLLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word8 -> Exp CLLong #
FromIntegral Word8 CULLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word8 -> Exp CULLong #
FromIntegral Word8 CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word8 -> Exp CFloat #
FromIntegral Word8 CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word8 -> Exp CDouble #
FromIntegral Word8 Half #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word8 -> Exp Half #
FromIntegral Word16 Word8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word16 -> Exp Word8 #
FromIntegral Word32 Word8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word32 -> Exp Word8 #
FromIntegral Word64 Word8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word64 -> Exp Word8 #
FromIntegral CShort Word8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CShort -> Exp Word8 #
FromIntegral CUShort Word8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUShort -> Exp Word8 #
FromIntegral CInt Word8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CInt -> Exp Word8 #
FromIntegral CUInt Word8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUInt -> Exp Word8 #
FromIntegral CLong Word8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLong -> Exp Word8 #
FromIntegral CULong Word8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULong -> Exp Word8 #
FromIntegral CLLong Word8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLLong -> Exp Word8 #
FromIntegral CULLong Word8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULLong -> Exp Word8 #
Cons ByteString ByteString Word8 Word8
Instance details Defined in Control.Lens.Cons Methods _Cons :: Prism ByteString ByteString (Word8, ByteString) (Word8, ByteString) #
Cons ByteString ByteString Word8 Word8
Instance details Defined in Control.Lens.Cons Methods _Cons :: Prism ByteString ByteString (Word8, ByteString) (Word8, ByteString) #
Snoc ByteString ByteString Word8 Word8
Instance details Defined in Control.Lens.Cons Methods _Snoc :: Prism ByteString ByteString (ByteString, Word8) (ByteString, Word8) #
Snoc ByteString ByteString Word8 Word8
Instance details Defined in Control.Lens.Cons Methods _Snoc :: Prism ByteString ByteString (ByteString, Word8) (ByteString, Word8) #
Bounded (Exp Word8) #
Instance details Defined in Data.Array.Accelerate.Classes.Bounded Methods minBound :: Exp Word8 # maxBound :: Exp Word8 #
Enum (Exp Word8) #
Instance details Defined in Data.Array.Accelerate.Classes.Enum Methods succ :: Exp Word8 -> Exp Word8 # pred :: Exp Word8 -> Exp Word8 # toEnum :: Int -> Exp Word8 # fromEnum :: Exp Word8 -> Int # enumFrom :: Exp Word8 -> [Exp Word8] # enumFromThen :: Exp Word8 -> Exp Word8 -> [Exp Word8] # enumFromTo :: Exp Word8 -> Exp Word8 -> [Exp Word8] # enumFromThenTo :: Exp Word8 -> Exp Word8 -> Exp Word8 -> [Exp Word8] #
Integral (Exp Word8) #
Instance details Defined in Data.Array.Accelerate.Classes.Integral Methods quot :: Exp Word8 -> Exp Word8 -> Exp Word8 # rem :: Exp Word8 -> Exp Word8 -> Exp Word8 # div :: Exp Word8 -> Exp Word8 -> Exp Word8 # mod :: Exp Word8 -> Exp Word8 -> Exp Word8 # quotRem :: Exp Word8 -> Exp Word8 -> (Exp Word8, Exp Word8) # divMod :: Exp Word8 -> Exp Word8 -> (Exp Word8, Exp Word8) # toInteger :: Exp Word8 -> Integer #
Num (Exp Word8) #
Instance details Defined in Data.Array.Accelerate.Classes.Num Methods (+) :: Exp Word8 -> Exp Word8 -> Exp Word8 # (-) :: Exp Word8 -> Exp Word8 -> Exp Word8 # (*) :: Exp Word8 -> Exp Word8 -> Exp Word8 # negate :: Exp Word8 -> Exp Word8 # abs :: Exp Word8 -> Exp Word8 # signum :: Exp Word8 -> Exp Word8 # fromInteger :: Integer -> Exp Word8 #
type PrimSize Word8
Instance details Defined in Basement.PrimType type PrimSize Word8 = 1
type Difference Word8
Instance details Defined in Basement.Numerical.Subtractive type Difference Word8 = Word8
type NatNumMaxBound Word8
Instance details Defined in Basement.Nat type NatNumMaxBound Word8 = 255
newtype Vector Word8
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Word8 = V_Word8 (Vector Word8)
type Plain Word8 #
Instance details Defined in Data.Array.Accelerate.Lift type Plain Word8 = Word8
newtype MVector s Word8
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Word8 = MV_Word8 (MVector s Word8)

data Word16 #

16-bit unsigned integer type

Instances

Bounded Word16	Since: base-2.1
Instance details Defined in GHC.Word Methods minBound :: Word16 # maxBound :: Word16 #
Enum Word16	Since: base-2.1
Instance details Defined in GHC.Word Methods succ :: Word16 -> Word16 # pred :: Word16 -> Word16 # toEnum :: Int -> Word16 # fromEnum :: Word16 -> Int # enumFrom :: Word16 -> [Word16] # enumFromThen :: Word16 -> Word16 -> [Word16] # enumFromTo :: Word16 -> Word16 -> [Word16] # enumFromThenTo :: Word16 -> Word16 -> Word16 -> [Word16] #
Eq Word16	Since: base-2.1
Instance details Defined in GHC.Word Methods (==) :: Word16 -> Word16 -> Bool # (/=) :: Word16 -> Word16 -> Bool #
Integral Word16	Since: base-2.1
Instance details Defined in GHC.Word Methods quot :: Word16 -> Word16 -> Word16 # rem :: Word16 -> Word16 -> Word16 # div :: Word16 -> Word16 -> Word16 # mod :: Word16 -> Word16 -> Word16 # quotRem :: Word16 -> Word16 -> (Word16, Word16) # divMod :: Word16 -> Word16 -> (Word16, Word16) # toInteger :: Word16 -> Integer #
Num Word16	Since: base-2.1
Instance details Defined in GHC.Word Methods (+) :: Word16 -> Word16 -> Word16 # (-) :: Word16 -> Word16 -> Word16 # (*) :: Word16 -> Word16 -> Word16 # negate :: Word16 -> Word16 # abs :: Word16 -> Word16 # signum :: Word16 -> Word16 # fromInteger :: Integer -> Word16 #
Ord Word16	Since: base-2.1
Instance details Defined in GHC.Word Methods compare :: Word16 -> Word16 -> Ordering # (<) :: Word16 -> Word16 -> Bool # (<=) :: Word16 -> Word16 -> Bool # (>) :: Word16 -> Word16 -> Bool # (>=) :: Word16 -> Word16 -> Bool # max :: Word16 -> Word16 -> Word16 # min :: Word16 -> Word16 -> Word16 #
Read Word16	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Word16 # readList :: ReadS [Word16] # readPrec :: ReadPrec Word16 # readListPrec :: ReadPrec [Word16] #
Real Word16	Since: base-2.1
Instance details Defined in GHC.Word Methods toRational :: Word16 -> Rational #
Show Word16	Since: base-2.1
Instance details Defined in GHC.Word Methods showsPrec :: Int -> Word16 -> ShowS # show :: Word16 -> String # showList :: [Word16] -> ShowS #
Ix Word16	Since: base-2.1
Instance details Defined in GHC.Word Methods range :: (Word16, Word16) -> [Word16] # index :: (Word16, Word16) -> Word16 -> Int # unsafeIndex :: (Word16, Word16) -> Word16 -> Int inRange :: (Word16, Word16) -> Word16 -> Bool # rangeSize :: (Word16, Word16) -> Int # unsafeRangeSize :: (Word16, Word16) -> Int
Lift Word16
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Word16 -> Q Exp #
PrintfArg Word16	Since: base-2.1
Instance details Defined in Text.Printf Methods formatArg :: Word16 -> FieldFormatter # parseFormat :: Word16 -> ModifierParser #
Storable Word16	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Word16 -> Int # alignment :: Word16 -> Int # peekElemOff :: Ptr Word16 -> Int -> IO Word16 # pokeElemOff :: Ptr Word16 -> Int -> Word16 -> IO () # peekByteOff :: Ptr b -> Int -> IO Word16 # pokeByteOff :: Ptr b -> Int -> Word16 -> IO () # peek :: Ptr Word16 -> IO Word16 # poke :: Ptr Word16 -> Word16 -> IO () #
Bits Word16	Since: base-2.1
Instance details Defined in GHC.Word Methods (.&.) :: Word16 -> Word16 -> Word16 # (.\|.) :: Word16 -> Word16 -> Word16 # xor :: Word16 -> Word16 -> Word16 # complement :: Word16 -> Word16 # shift :: Word16 -> Int -> Word16 # rotate :: Word16 -> Int -> Word16 # zeroBits :: Word16 # bit :: Int -> Word16 # setBit :: Word16 -> Int -> Word16 # clearBit :: Word16 -> Int -> Word16 # complementBit :: Word16 -> Int -> Word16 # testBit :: Word16 -> Int -> Bool # bitSizeMaybe :: Word16 -> Maybe Int # bitSize :: Word16 -> Int # isSigned :: Word16 -> Bool # shiftL :: Word16 -> Int -> Word16 # unsafeShiftL :: Word16 -> Int -> Word16 # shiftR :: Word16 -> Int -> Word16 # unsafeShiftR :: Word16 -> Int -> Word16 # rotateL :: Word16 -> Int -> Word16 # rotateR :: Word16 -> Int -> Word16 # popCount :: Word16 -> Int #
FiniteBits Word16	Since: base-4.6.0.0
Instance details Defined in GHC.Word Methods finiteBitSize :: Word16 -> Int # countLeadingZeros :: Word16 -> Int # countTrailingZeros :: Word16 -> Int #
PrimType Word16
Instance details Defined in Basement.PrimType Associated Types type PrimSize Word16 :: Nat # Methods primSizeInBytes :: Proxy Word16 -> CountOf Word8 # primShiftToBytes :: Proxy Word16 -> Int # primBaUIndex :: ByteArray# -> Offset Word16 -> Word16 # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Word16 -> prim Word16 # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Word16 -> Word16 -> prim () # primAddrIndex :: Addr# -> Offset Word16 -> Word16 # primAddrRead :: PrimMonad prim => Addr# -> Offset Word16 -> prim Word16 # primAddrWrite :: PrimMonad prim => Addr# -> Offset Word16 -> Word16 -> prim () #
PrimMemoryComparable Word16
Instance details Defined in Basement.PrimType
Subtractive Word16
Instance details Defined in Basement.Numerical.Subtractive Associated Types type Difference Word16 :: Type # Methods (-) :: Word16 -> Word16 -> Difference Word16 #
NFData Word16
Instance details Defined in Control.DeepSeq Methods rnf :: Word16 -> () #
Hashable Word16
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Word16 -> Int # hash :: Word16 -> Int #
Prim Word16
Instance details Defined in Data.Primitive.Types Methods sizeOf# :: Word16 -> Int# # alignment# :: Word16 -> Int# # indexByteArray# :: ByteArray# -> Int# -> Word16 # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, Word16#) # writeByteArray# :: MutableByteArray# s -> Int# -> Word16 -> State# s -> State# s # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Word16 -> State# s -> State# s # indexOffAddr# :: Addr# -> Int# -> Word16 # readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, Word16#) # writeOffAddr# :: Addr# -> Int# -> Word16 -> State# s -> State# s # setOffAddr# :: Addr# -> Int# -> Int# -> Word16 -> State# s -> State# s #
Unbox Word16
Instance details Defined in Data.Vector.Unboxed.Base
Pretty Word16
Instance details Defined in Text.PrettyPrint.Annotated.WL Methods pretty :: Word16 -> Doc b # prettyList :: [Word16] -> Doc b #
IsScalar Word16 #
Instance details Defined in Data.Array.Accelerate.Type Methods scalarType :: ScalarType Word16
IsBounded Word16 #
Instance details Defined in Data.Array.Accelerate.Type Methods boundedType :: BoundedType Word16
IsNum Word16 #
Instance details Defined in Data.Array.Accelerate.Type Methods numType :: NumType Word16
IsIntegral Word16 #
Instance details Defined in Data.Array.Accelerate.Type Methods integralType :: IntegralType Word16
Elt Word16 #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods eltType :: Word16 -> TupleType (EltRepr Word16) fromElt :: Word16 -> EltRepr Word16 toElt :: EltRepr Word16 -> Word16
Eq Word16 #
Instance details Defined in Data.Array.Accelerate.Classes.Eq Methods (==) :: Exp Word16 -> Exp Word16 -> Exp Bool # (/=) :: Exp Word16 -> Exp Word16 -> Exp Bool #
Ord Word16 #
Instance details Defined in Data.Array.Accelerate.Classes.Ord Methods (<) :: Exp Word16 -> Exp Word16 -> Exp Bool # (>) :: Exp Word16 -> Exp Word16 -> Exp Bool # (<=) :: Exp Word16 -> Exp Word16 -> Exp Bool # (>=) :: Exp Word16 -> Exp Word16 -> Exp Bool # min :: Exp Word16 -> Exp Word16 -> Exp Word16 # max :: Exp Word16 -> Exp Word16 -> Exp Word16 # compare :: Exp Word16 -> Exp Word16 -> Exp Ordering #
FiniteBits Word16 #
Instance details Defined in Data.Array.Accelerate.Data.Bits Methods finiteBitSize :: Exp Word16 -> Exp Int # countLeadingZeros :: Exp Word16 -> Exp Int # countTrailingZeros :: Exp Word16 -> Exp Int #
Bits Word16 #
Instance details Defined in Data.Array.Accelerate.Data.Bits Methods (.&.) :: Exp Word16 -> Exp Word16 -> Exp Word16 # (.\|.) :: Exp Word16 -> Exp Word16 -> Exp Word16 # xor :: Exp Word16 -> Exp Word16 -> Exp Word16 # complement :: Exp Word16 -> Exp Word16 # shift :: Exp Word16 -> Exp Int -> Exp Word16 # rotate :: Exp Word16 -> Exp Int -> Exp Word16 # zeroBits :: Exp Word16 # bit :: Exp Int -> Exp Word16 # setBit :: Exp Word16 -> Exp Int -> Exp Word16 # clearBit :: Exp Word16 -> Exp Int -> Exp Word16 # complementBit :: Exp Word16 -> Exp Int -> Exp Word16 # testBit :: Exp Word16 -> Exp Int -> Exp Bool # isSigned :: Exp Word16 -> Exp Bool # shiftL :: Exp Word16 -> Exp Int -> Exp Word16 # unsafeShiftL :: Exp Word16 -> Exp Int -> Exp Word16 # shiftR :: Exp Word16 -> Exp Int -> Exp Word16 # unsafeShiftR :: Exp Word16 -> Exp Int -> Exp Word16 # rotateL :: Exp Word16 -> Exp Int -> Exp Word16 # rotateR :: Exp Word16 -> Exp Int -> Exp Word16 # popCount :: Exp Word16 -> Exp Int #
Vector Vector Word16
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Word16 -> m (Vector Word16) # basicUnsafeThaw :: PrimMonad m => Vector Word16 -> m (Mutable Vector (PrimState m) Word16) # basicLength :: Vector Word16 -> Int # basicUnsafeSlice :: Int -> Int -> Vector Word16 -> Vector Word16 # basicUnsafeIndexM :: Monad m => Vector Word16 -> Int -> m Word16 # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Word16 -> Vector Word16 -> m () # elemseq :: Vector Word16 -> Word16 -> b -> b #
MVector MVector Word16
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Word16 -> Int # basicUnsafeSlice :: Int -> Int -> MVector s Word16 -> MVector s Word16 # basicOverlaps :: MVector s Word16 -> MVector s Word16 -> Bool # basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Word16) # basicInitialize :: PrimMonad m => MVector (PrimState m) Word16 -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> Word16 -> m (MVector (PrimState m) Word16) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Word16 -> Int -> m Word16 # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Word16 -> Int -> Word16 -> m () # basicClear :: PrimMonad m => MVector (PrimState m) Word16 -> m () # basicSet :: PrimMonad m => MVector (PrimState m) Word16 -> Word16 -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Word16 -> MVector (PrimState m) Word16 -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Word16 -> MVector (PrimState m) Word16 -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Word16 -> Int -> m (MVector (PrimState m) Word16) #
Lift Exp Word16 #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain Word16 :: Type # Methods lift :: Word16 -> Exp (Plain Word16) #
ToFloating Word16 Double #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word16 -> Exp Double #
ToFloating Word16 Float #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word16 -> Exp Float #
ToFloating Word16 CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word16 -> Exp CFloat #
ToFloating Word16 CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word16 -> Exp CDouble #
ToFloating Word16 Half #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word16 -> Exp Half #
FromIntegral Int Word16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int -> Exp Word16 #
FromIntegral Int8 Word16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int8 -> Exp Word16 #
FromIntegral Int16 Word16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int16 -> Exp Word16 #
FromIntegral Int32 Word16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int32 -> Exp Word16 #
FromIntegral Int64 Word16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int64 -> Exp Word16 #
FromIntegral Word Word16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word -> Exp Word16 #
FromIntegral Word8 Word16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word8 -> Exp Word16 #
FromIntegral Word16 Double #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word16 -> Exp Double #
FromIntegral Word16 Float #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word16 -> Exp Float #
FromIntegral Word16 Int #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word16 -> Exp Int #
FromIntegral Word16 Int8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word16 -> Exp Int8 #
FromIntegral Word16 Int16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word16 -> Exp Int16 #
FromIntegral Word16 Int32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word16 -> Exp Int32 #
FromIntegral Word16 Int64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word16 -> Exp Int64 #
FromIntegral Word16 Word #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word16 -> Exp Word #
FromIntegral Word16 Word8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word16 -> Exp Word8 #
FromIntegral Word16 Word16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word16 -> Exp Word16 #
FromIntegral Word16 Word32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word16 -> Exp Word32 #
FromIntegral Word16 Word64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word16 -> Exp Word64 #
FromIntegral Word16 CShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word16 -> Exp CShort #
FromIntegral Word16 CUShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word16 -> Exp CUShort #
FromIntegral Word16 CInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word16 -> Exp CInt #
FromIntegral Word16 CUInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word16 -> Exp CUInt #
FromIntegral Word16 CLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word16 -> Exp CLong #
FromIntegral Word16 CULong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word16 -> Exp CULong #
FromIntegral Word16 CLLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word16 -> Exp CLLong #
FromIntegral Word16 CULLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word16 -> Exp CULLong #
FromIntegral Word16 CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word16 -> Exp CFloat #
FromIntegral Word16 CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word16 -> Exp CDouble #
FromIntegral Word16 Half #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word16 -> Exp Half #
FromIntegral Word32 Word16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word32 -> Exp Word16 #
FromIntegral Word64 Word16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word64 -> Exp Word16 #
FromIntegral CShort Word16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CShort -> Exp Word16 #
FromIntegral CUShort Word16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUShort -> Exp Word16 #
FromIntegral CInt Word16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CInt -> Exp Word16 #
FromIntegral CUInt Word16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUInt -> Exp Word16 #
FromIntegral CLong Word16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLong -> Exp Word16 #
FromIntegral CULong Word16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULong -> Exp Word16 #
FromIntegral CLLong Word16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLLong -> Exp Word16 #
FromIntegral CULLong Word16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULLong -> Exp Word16 #
Bounded (Exp Word16) #
Instance details Defined in Data.Array.Accelerate.Classes.Bounded Methods minBound :: Exp Word16 # maxBound :: Exp Word16 #
Enum (Exp Word16) #
Instance details Defined in Data.Array.Accelerate.Classes.Enum Methods succ :: Exp Word16 -> Exp Word16 # pred :: Exp Word16 -> Exp Word16 # toEnum :: Int -> Exp Word16 # fromEnum :: Exp Word16 -> Int # enumFrom :: Exp Word16 -> [Exp Word16] # enumFromThen :: Exp Word16 -> Exp Word16 -> [Exp Word16] # enumFromTo :: Exp Word16 -> Exp Word16 -> [Exp Word16] # enumFromThenTo :: Exp Word16 -> Exp Word16 -> Exp Word16 -> [Exp Word16] #
Integral (Exp Word16) #
Instance details Defined in Data.Array.Accelerate.Classes.Integral Methods quot :: Exp Word16 -> Exp Word16 -> Exp Word16 # rem :: Exp Word16 -> Exp Word16 -> Exp Word16 # div :: Exp Word16 -> Exp Word16 -> Exp Word16 # mod :: Exp Word16 -> Exp Word16 -> Exp Word16 # quotRem :: Exp Word16 -> Exp Word16 -> (Exp Word16, Exp Word16) # divMod :: Exp Word16 -> Exp Word16 -> (Exp Word16, Exp Word16) # toInteger :: Exp Word16 -> Integer #
Num (Exp Word16) #
Instance details Defined in Data.Array.Accelerate.Classes.Num Methods (+) :: Exp Word16 -> Exp Word16 -> Exp Word16 # (-) :: Exp Word16 -> Exp Word16 -> Exp Word16 # (*) :: Exp Word16 -> Exp Word16 -> Exp Word16 # negate :: Exp Word16 -> Exp Word16 # abs :: Exp Word16 -> Exp Word16 # signum :: Exp Word16 -> Exp Word16 # fromInteger :: Integer -> Exp Word16 #
type PrimSize Word16
Instance details Defined in Basement.PrimType type PrimSize Word16 = 2
type Difference Word16
Instance details Defined in Basement.Numerical.Subtractive type Difference Word16 = Word16
type NatNumMaxBound Word16
Instance details Defined in Basement.Nat type NatNumMaxBound Word16 = 65535
newtype Vector Word16
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Word16 = V_Word16 (Vector Word16)
type Plain Word16 #
Instance details Defined in Data.Array.Accelerate.Lift type Plain Word16 = Word16
newtype MVector s Word16
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Word16 = MV_Word16 (MVector s Word16)

data Word32 #

32-bit unsigned integer type

Instances

Bounded Word32	Since: base-2.1
Instance details Defined in GHC.Word Methods minBound :: Word32 # maxBound :: Word32 #
Enum Word32	Since: base-2.1
Instance details Defined in GHC.Word Methods succ :: Word32 -> Word32 # pred :: Word32 -> Word32 # toEnum :: Int -> Word32 # fromEnum :: Word32 -> Int # enumFrom :: Word32 -> [Word32] # enumFromThen :: Word32 -> Word32 -> [Word32] # enumFromTo :: Word32 -> Word32 -> [Word32] # enumFromThenTo :: Word32 -> Word32 -> Word32 -> [Word32] #
Eq Word32	Since: base-2.1
Instance details Defined in GHC.Word Methods (==) :: Word32 -> Word32 -> Bool # (/=) :: Word32 -> Word32 -> Bool #
Integral Word32	Since: base-2.1
Instance details Defined in GHC.Word Methods quot :: Word32 -> Word32 -> Word32 # rem :: Word32 -> Word32 -> Word32 # div :: Word32 -> Word32 -> Word32 # mod :: Word32 -> Word32 -> Word32 # quotRem :: Word32 -> Word32 -> (Word32, Word32) # divMod :: Word32 -> Word32 -> (Word32, Word32) # toInteger :: Word32 -> Integer #
Num Word32	Since: base-2.1
Instance details Defined in GHC.Word Methods (+) :: Word32 -> Word32 -> Word32 # (-) :: Word32 -> Word32 -> Word32 # (*) :: Word32 -> Word32 -> Word32 # negate :: Word32 -> Word32 # abs :: Word32 -> Word32 # signum :: Word32 -> Word32 # fromInteger :: Integer -> Word32 #
Ord Word32	Since: base-2.1
Instance details Defined in GHC.Word Methods compare :: Word32 -> Word32 -> Ordering # (<) :: Word32 -> Word32 -> Bool # (<=) :: Word32 -> Word32 -> Bool # (>) :: Word32 -> Word32 -> Bool # (>=) :: Word32 -> Word32 -> Bool # max :: Word32 -> Word32 -> Word32 # min :: Word32 -> Word32 -> Word32 #
Read Word32	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Word32 # readList :: ReadS [Word32] # readPrec :: ReadPrec Word32 # readListPrec :: ReadPrec [Word32] #
Real Word32	Since: base-2.1
Instance details Defined in GHC.Word Methods toRational :: Word32 -> Rational #
Show Word32	Since: base-2.1
Instance details Defined in GHC.Word Methods showsPrec :: Int -> Word32 -> ShowS # show :: Word32 -> String # showList :: [Word32] -> ShowS #
Ix Word32	Since: base-2.1
Instance details Defined in GHC.Word Methods range :: (Word32, Word32) -> [Word32] # index :: (Word32, Word32) -> Word32 -> Int # unsafeIndex :: (Word32, Word32) -> Word32 -> Int inRange :: (Word32, Word32) -> Word32 -> Bool # rangeSize :: (Word32, Word32) -> Int # unsafeRangeSize :: (Word32, Word32) -> Int
Lift Word32
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Word32 -> Q Exp #
PrintfArg Word32	Since: base-2.1
Instance details Defined in Text.Printf Methods formatArg :: Word32 -> FieldFormatter # parseFormat :: Word32 -> ModifierParser #
Storable Word32	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Word32 -> Int # alignment :: Word32 -> Int # peekElemOff :: Ptr Word32 -> Int -> IO Word32 # pokeElemOff :: Ptr Word32 -> Int -> Word32 -> IO () # peekByteOff :: Ptr b -> Int -> IO Word32 # pokeByteOff :: Ptr b -> Int -> Word32 -> IO () # peek :: Ptr Word32 -> IO Word32 # poke :: Ptr Word32 -> Word32 -> IO () #
Bits Word32	Since: base-2.1
Instance details Defined in GHC.Word Methods (.&.) :: Word32 -> Word32 -> Word32 # (.\|.) :: Word32 -> Word32 -> Word32 # xor :: Word32 -> Word32 -> Word32 # complement :: Word32 -> Word32 # shift :: Word32 -> Int -> Word32 # rotate :: Word32 -> Int -> Word32 # zeroBits :: Word32 # bit :: Int -> Word32 # setBit :: Word32 -> Int -> Word32 # clearBit :: Word32 -> Int -> Word32 # complementBit :: Word32 -> Int -> Word32 # testBit :: Word32 -> Int -> Bool # bitSizeMaybe :: Word32 -> Maybe Int # bitSize :: Word32 -> Int # isSigned :: Word32 -> Bool # shiftL :: Word32 -> Int -> Word32 # unsafeShiftL :: Word32 -> Int -> Word32 # shiftR :: Word32 -> Int -> Word32 # unsafeShiftR :: Word32 -> Int -> Word32 # rotateL :: Word32 -> Int -> Word32 # rotateR :: Word32 -> Int -> Word32 # popCount :: Word32 -> Int #
FiniteBits Word32	Since: base-4.6.0.0
Instance details Defined in GHC.Word Methods finiteBitSize :: Word32 -> Int # countLeadingZeros :: Word32 -> Int # countTrailingZeros :: Word32 -> Int #
PrimType Word32
Instance details Defined in Basement.PrimType Associated Types type PrimSize Word32 :: Nat # Methods primSizeInBytes :: Proxy Word32 -> CountOf Word8 # primShiftToBytes :: Proxy Word32 -> Int # primBaUIndex :: ByteArray# -> Offset Word32 -> Word32 # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Word32 -> prim Word32 # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Word32 -> Word32 -> prim () # primAddrIndex :: Addr# -> Offset Word32 -> Word32 # primAddrRead :: PrimMonad prim => Addr# -> Offset Word32 -> prim Word32 # primAddrWrite :: PrimMonad prim => Addr# -> Offset Word32 -> Word32 -> prim () #
PrimMemoryComparable Word32
Instance details Defined in Basement.PrimType
Subtractive Word32
Instance details Defined in Basement.Numerical.Subtractive Associated Types type Difference Word32 :: Type # Methods (-) :: Word32 -> Word32 -> Difference Word32 #
NFData Word32
Instance details Defined in Control.DeepSeq Methods rnf :: Word32 -> () #
Hashable Word32
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Word32 -> Int # hash :: Word32 -> Int #
Prim Word32
Instance details Defined in Data.Primitive.Types Methods sizeOf# :: Word32 -> Int# # alignment# :: Word32 -> Int# # indexByteArray# :: ByteArray# -> Int# -> Word32 # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, Word32#) # writeByteArray# :: MutableByteArray# s -> Int# -> Word32 -> State# s -> State# s # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Word32 -> State# s -> State# s # indexOffAddr# :: Addr# -> Int# -> Word32 # readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, Word32#) # writeOffAddr# :: Addr# -> Int# -> Word32 -> State# s -> State# s # setOffAddr# :: Addr# -> Int# -> Int# -> Word32 -> State# s -> State# s #
Unbox Word32
Instance details Defined in Data.Vector.Unboxed.Base
Pretty Word32
Instance details Defined in Text.PrettyPrint.Annotated.WL Methods pretty :: Word32 -> Doc b # prettyList :: [Word32] -> Doc b #
IsScalar Word32 #
Instance details Defined in Data.Array.Accelerate.Type Methods scalarType :: ScalarType Word32
IsBounded Word32 #
Instance details Defined in Data.Array.Accelerate.Type Methods boundedType :: BoundedType Word32
IsNum Word32 #
Instance details Defined in Data.Array.Accelerate.Type Methods numType :: NumType Word32
IsIntegral Word32 #
Instance details Defined in Data.Array.Accelerate.Type Methods integralType :: IntegralType Word32
Elt Word32 #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods eltType :: Word32 -> TupleType (EltRepr Word32) fromElt :: Word32 -> EltRepr Word32 toElt :: EltRepr Word32 -> Word32
Eq Word32 #
Instance details Defined in Data.Array.Accelerate.Classes.Eq Methods (==) :: Exp Word32 -> Exp Word32 -> Exp Bool # (/=) :: Exp Word32 -> Exp Word32 -> Exp Bool #
Ord Word32 #
Instance details Defined in Data.Array.Accelerate.Classes.Ord Methods (<) :: Exp Word32 -> Exp Word32 -> Exp Bool # (>) :: Exp Word32 -> Exp Word32 -> Exp Bool # (<=) :: Exp Word32 -> Exp Word32 -> Exp Bool # (>=) :: Exp Word32 -> Exp Word32 -> Exp Bool # min :: Exp Word32 -> Exp Word32 -> Exp Word32 # max :: Exp Word32 -> Exp Word32 -> Exp Word32 # compare :: Exp Word32 -> Exp Word32 -> Exp Ordering #
FiniteBits Word32 #
Instance details Defined in Data.Array.Accelerate.Data.Bits Methods finiteBitSize :: Exp Word32 -> Exp Int # countLeadingZeros :: Exp Word32 -> Exp Int # countTrailingZeros :: Exp Word32 -> Exp Int #
Bits Word32 #
Instance details Defined in Data.Array.Accelerate.Data.Bits Methods (.&.) :: Exp Word32 -> Exp Word32 -> Exp Word32 # (.\|.) :: Exp Word32 -> Exp Word32 -> Exp Word32 # xor :: Exp Word32 -> Exp Word32 -> Exp Word32 # complement :: Exp Word32 -> Exp Word32 # shift :: Exp Word32 -> Exp Int -> Exp Word32 # rotate :: Exp Word32 -> Exp Int -> Exp Word32 # zeroBits :: Exp Word32 # bit :: Exp Int -> Exp Word32 # setBit :: Exp Word32 -> Exp Int -> Exp Word32 # clearBit :: Exp Word32 -> Exp Int -> Exp Word32 # complementBit :: Exp Word32 -> Exp Int -> Exp Word32 # testBit :: Exp Word32 -> Exp Int -> Exp Bool # isSigned :: Exp Word32 -> Exp Bool # shiftL :: Exp Word32 -> Exp Int -> Exp Word32 # unsafeShiftL :: Exp Word32 -> Exp Int -> Exp Word32 # shiftR :: Exp Word32 -> Exp Int -> Exp Word32 # unsafeShiftR :: Exp Word32 -> Exp Int -> Exp Word32 # rotateL :: Exp Word32 -> Exp Int -> Exp Word32 # rotateR :: Exp Word32 -> Exp Int -> Exp Word32 # popCount :: Exp Word32 -> Exp Int #
Vector Vector Word32
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Word32 -> m (Vector Word32) # basicUnsafeThaw :: PrimMonad m => Vector Word32 -> m (Mutable Vector (PrimState m) Word32) # basicLength :: Vector Word32 -> Int # basicUnsafeSlice :: Int -> Int -> Vector Word32 -> Vector Word32 # basicUnsafeIndexM :: Monad m => Vector Word32 -> Int -> m Word32 # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Word32 -> Vector Word32 -> m () # elemseq :: Vector Word32 -> Word32 -> b -> b #
MVector MVector Word32
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Word32 -> Int # basicUnsafeSlice :: Int -> Int -> MVector s Word32 -> MVector s Word32 # basicOverlaps :: MVector s Word32 -> MVector s Word32 -> Bool # basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Word32) # basicInitialize :: PrimMonad m => MVector (PrimState m) Word32 -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> Word32 -> m (MVector (PrimState m) Word32) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Word32 -> Int -> m Word32 # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Word32 -> Int -> Word32 -> m () # basicClear :: PrimMonad m => MVector (PrimState m) Word32 -> m () # basicSet :: PrimMonad m => MVector (PrimState m) Word32 -> Word32 -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Word32 -> MVector (PrimState m) Word32 -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Word32 -> MVector (PrimState m) Word32 -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Word32 -> Int -> m (MVector (PrimState m) Word32) #
Lift Exp Word32 #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain Word32 :: Type # Methods lift :: Word32 -> Exp (Plain Word32) #
ToFloating Word32 Double #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word32 -> Exp Double #
ToFloating Word32 Float #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word32 -> Exp Float #
ToFloating Word32 CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word32 -> Exp CFloat #
ToFloating Word32 CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word32 -> Exp CDouble #
ToFloating Word32 Half #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word32 -> Exp Half #
FromIntegral Int Word32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int -> Exp Word32 #
FromIntegral Int8 Word32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int8 -> Exp Word32 #
FromIntegral Int16 Word32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int16 -> Exp Word32 #
FromIntegral Int32 Word32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int32 -> Exp Word32 #
FromIntegral Int64 Word32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int64 -> Exp Word32 #
FromIntegral Word Word32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word -> Exp Word32 #
FromIntegral Word8 Word32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word8 -> Exp Word32 #
FromIntegral Word16 Word32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word16 -> Exp Word32 #
FromIntegral Word32 Double #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word32 -> Exp Double #
FromIntegral Word32 Float #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word32 -> Exp Float #
FromIntegral Word32 Int #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word32 -> Exp Int #
FromIntegral Word32 Int8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word32 -> Exp Int8 #
FromIntegral Word32 Int16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word32 -> Exp Int16 #
FromIntegral Word32 Int32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word32 -> Exp Int32 #
FromIntegral Word32 Int64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word32 -> Exp Int64 #
FromIntegral Word32 Word #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word32 -> Exp Word #
FromIntegral Word32 Word8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word32 -> Exp Word8 #
FromIntegral Word32 Word16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word32 -> Exp Word16 #
FromIntegral Word32 Word32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word32 -> Exp Word32 #
FromIntegral Word32 Word64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word32 -> Exp Word64 #
FromIntegral Word32 CShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word32 -> Exp CShort #
FromIntegral Word32 CUShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word32 -> Exp CUShort #
FromIntegral Word32 CInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word32 -> Exp CInt #
FromIntegral Word32 CUInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word32 -> Exp CUInt #
FromIntegral Word32 CLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word32 -> Exp CLong #
FromIntegral Word32 CULong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word32 -> Exp CULong #
FromIntegral Word32 CLLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word32 -> Exp CLLong #
FromIntegral Word32 CULLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word32 -> Exp CULLong #
FromIntegral Word32 CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word32 -> Exp CFloat #
FromIntegral Word32 CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word32 -> Exp CDouble #
FromIntegral Word32 Half #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word32 -> Exp Half #
FromIntegral Word64 Word32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word64 -> Exp Word32 #
FromIntegral CShort Word32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CShort -> Exp Word32 #
FromIntegral CUShort Word32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUShort -> Exp Word32 #
FromIntegral CInt Word32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CInt -> Exp Word32 #
FromIntegral CUInt Word32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUInt -> Exp Word32 #
FromIntegral CLong Word32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLong -> Exp Word32 #
FromIntegral CULong Word32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULong -> Exp Word32 #
FromIntegral CLLong Word32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLLong -> Exp Word32 #
FromIntegral CULLong Word32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULLong -> Exp Word32 #
Bounded (Exp Word32) #
Instance details Defined in Data.Array.Accelerate.Classes.Bounded Methods minBound :: Exp Word32 # maxBound :: Exp Word32 #
Enum (Exp Word32) #
Instance details Defined in Data.Array.Accelerate.Classes.Enum Methods succ :: Exp Word32 -> Exp Word32 # pred :: Exp Word32 -> Exp Word32 # toEnum :: Int -> Exp Word32 # fromEnum :: Exp Word32 -> Int # enumFrom :: Exp Word32 -> [Exp Word32] # enumFromThen :: Exp Word32 -> Exp Word32 -> [Exp Word32] # enumFromTo :: Exp Word32 -> Exp Word32 -> [Exp Word32] # enumFromThenTo :: Exp Word32 -> Exp Word32 -> Exp Word32 -> [Exp Word32] #
Integral (Exp Word32) #
Instance details Defined in Data.Array.Accelerate.Classes.Integral Methods quot :: Exp Word32 -> Exp Word32 -> Exp Word32 # rem :: Exp Word32 -> Exp Word32 -> Exp Word32 # div :: Exp Word32 -> Exp Word32 -> Exp Word32 # mod :: Exp Word32 -> Exp Word32 -> Exp Word32 # quotRem :: Exp Word32 -> Exp Word32 -> (Exp Word32, Exp Word32) # divMod :: Exp Word32 -> Exp Word32 -> (Exp Word32, Exp Word32) # toInteger :: Exp Word32 -> Integer #
Num (Exp Word32) #
Instance details Defined in Data.Array.Accelerate.Classes.Num Methods (+) :: Exp Word32 -> Exp Word32 -> Exp Word32 # (-) :: Exp Word32 -> Exp Word32 -> Exp Word32 # (*) :: Exp Word32 -> Exp Word32 -> Exp Word32 # negate :: Exp Word32 -> Exp Word32 # abs :: Exp Word32 -> Exp Word32 # signum :: Exp Word32 -> Exp Word32 # fromInteger :: Integer -> Exp Word32 #
type PrimSize Word32
Instance details Defined in Basement.PrimType type PrimSize Word32 = 4
type Difference Word32
Instance details Defined in Basement.Numerical.Subtractive type Difference Word32 = Word32
type NatNumMaxBound Word32
Instance details Defined in Basement.Nat type NatNumMaxBound Word32 = 4294967295
newtype Vector Word32
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Word32 = V_Word32 (Vector Word32)
type Plain Word32 #
Instance details Defined in Data.Array.Accelerate.Lift type Plain Word32 = Word32
newtype MVector s Word32
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Word32 = MV_Word32 (MVector s Word32)

data Word64 #

64-bit unsigned integer type

Instances

Bounded Word64	Since: base-2.1
Instance details Defined in GHC.Word Methods minBound :: Word64 # maxBound :: Word64 #
Enum Word64	Since: base-2.1
Instance details Defined in GHC.Word Methods succ :: Word64 -> Word64 # pred :: Word64 -> Word64 # toEnum :: Int -> Word64 # fromEnum :: Word64 -> Int # enumFrom :: Word64 -> [Word64] # enumFromThen :: Word64 -> Word64 -> [Word64] # enumFromTo :: Word64 -> Word64 -> [Word64] # enumFromThenTo :: Word64 -> Word64 -> Word64 -> [Word64] #
Eq Word64	Since: base-2.1
Instance details Defined in GHC.Word Methods (==) :: Word64 -> Word64 -> Bool # (/=) :: Word64 -> Word64 -> Bool #
Integral Word64	Since: base-2.1
Instance details Defined in GHC.Word Methods quot :: Word64 -> Word64 -> Word64 # rem :: Word64 -> Word64 -> Word64 # div :: Word64 -> Word64 -> Word64 # mod :: Word64 -> Word64 -> Word64 # quotRem :: Word64 -> Word64 -> (Word64, Word64) # divMod :: Word64 -> Word64 -> (Word64, Word64) # toInteger :: Word64 -> Integer #
Num Word64	Since: base-2.1
Instance details Defined in GHC.Word Methods (+) :: Word64 -> Word64 -> Word64 # (-) :: Word64 -> Word64 -> Word64 # (*) :: Word64 -> Word64 -> Word64 # negate :: Word64 -> Word64 # abs :: Word64 -> Word64 # signum :: Word64 -> Word64 # fromInteger :: Integer -> Word64 #
Ord Word64	Since: base-2.1
Instance details Defined in GHC.Word Methods compare :: Word64 -> Word64 -> Ordering # (<) :: Word64 -> Word64 -> Bool # (<=) :: Word64 -> Word64 -> Bool # (>) :: Word64 -> Word64 -> Bool # (>=) :: Word64 -> Word64 -> Bool # max :: Word64 -> Word64 -> Word64 # min :: Word64 -> Word64 -> Word64 #
Read Word64	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Word64 # readList :: ReadS [Word64] # readPrec :: ReadPrec Word64 # readListPrec :: ReadPrec [Word64] #
Real Word64	Since: base-2.1
Instance details Defined in GHC.Word Methods toRational :: Word64 -> Rational #
Show Word64	Since: base-2.1
Instance details Defined in GHC.Word Methods showsPrec :: Int -> Word64 -> ShowS # show :: Word64 -> String # showList :: [Word64] -> ShowS #
Ix Word64	Since: base-2.1
Instance details Defined in GHC.Word Methods range :: (Word64, Word64) -> [Word64] # index :: (Word64, Word64) -> Word64 -> Int # unsafeIndex :: (Word64, Word64) -> Word64 -> Int inRange :: (Word64, Word64) -> Word64 -> Bool # rangeSize :: (Word64, Word64) -> Int # unsafeRangeSize :: (Word64, Word64) -> Int
Lift Word64
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Word64 -> Q Exp #
PrintfArg Word64	Since: base-2.1
Instance details Defined in Text.Printf Methods formatArg :: Word64 -> FieldFormatter # parseFormat :: Word64 -> ModifierParser #
Storable Word64	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Word64 -> Int # alignment :: Word64 -> Int # peekElemOff :: Ptr Word64 -> Int -> IO Word64 # pokeElemOff :: Ptr Word64 -> Int -> Word64 -> IO () # peekByteOff :: Ptr b -> Int -> IO Word64 # pokeByteOff :: Ptr b -> Int -> Word64 -> IO () # peek :: Ptr Word64 -> IO Word64 # poke :: Ptr Word64 -> Word64 -> IO () #
Bits Word64	Since: base-2.1
Instance details Defined in GHC.Word Methods (.&.) :: Word64 -> Word64 -> Word64 # (.\|.) :: Word64 -> Word64 -> Word64 # xor :: Word64 -> Word64 -> Word64 # complement :: Word64 -> Word64 # shift :: Word64 -> Int -> Word64 # rotate :: Word64 -> Int -> Word64 # zeroBits :: Word64 # bit :: Int -> Word64 # setBit :: Word64 -> Int -> Word64 # clearBit :: Word64 -> Int -> Word64 # complementBit :: Word64 -> Int -> Word64 # testBit :: Word64 -> Int -> Bool # bitSizeMaybe :: Word64 -> Maybe Int # bitSize :: Word64 -> Int # isSigned :: Word64 -> Bool # shiftL :: Word64 -> Int -> Word64 # unsafeShiftL :: Word64 -> Int -> Word64 # shiftR :: Word64 -> Int -> Word64 # unsafeShiftR :: Word64 -> Int -> Word64 # rotateL :: Word64 -> Int -> Word64 # rotateR :: Word64 -> Int -> Word64 # popCount :: Word64 -> Int #
FiniteBits Word64	Since: base-4.6.0.0
Instance details Defined in GHC.Word Methods finiteBitSize :: Word64 -> Int # countLeadingZeros :: Word64 -> Int # countTrailingZeros :: Word64 -> Int #
PrimType Word64
Instance details Defined in Basement.PrimType Associated Types type PrimSize Word64 :: Nat # Methods primSizeInBytes :: Proxy Word64 -> CountOf Word8 # primShiftToBytes :: Proxy Word64 -> Int # primBaUIndex :: ByteArray# -> Offset Word64 -> Word64 # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Word64 -> prim Word64 # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Word64 -> Word64 -> prim () # primAddrIndex :: Addr# -> Offset Word64 -> Word64 # primAddrRead :: PrimMonad prim => Addr# -> Offset Word64 -> prim Word64 # primAddrWrite :: PrimMonad prim => Addr# -> Offset Word64 -> Word64 -> prim () #
PrimMemoryComparable Word64
Instance details Defined in Basement.PrimType
Subtractive Word64
Instance details Defined in Basement.Numerical.Subtractive Associated Types type Difference Word64 :: Type # Methods (-) :: Word64 -> Word64 -> Difference Word64 #
NFData Word64
Instance details Defined in Control.DeepSeq Methods rnf :: Word64 -> () #
Hashable Word64
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Word64 -> Int # hash :: Word64 -> Int #
Prim Word64
Instance details Defined in Data.Primitive.Types Methods sizeOf# :: Word64 -> Int# # alignment# :: Word64 -> Int# # indexByteArray# :: ByteArray# -> Int# -> Word64 # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, Word64#) # writeByteArray# :: MutableByteArray# s -> Int# -> Word64 -> State# s -> State# s # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Word64 -> State# s -> State# s # indexOffAddr# :: Addr# -> Int# -> Word64 # readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, Word64#) # writeOffAddr# :: Addr# -> Int# -> Word64 -> State# s -> State# s # setOffAddr# :: Addr# -> Int# -> Int# -> Word64 -> State# s -> State# s #
Unbox Word64
Instance details Defined in Data.Vector.Unboxed.Base
Pretty Word64
Instance details Defined in Text.PrettyPrint.Annotated.WL Methods pretty :: Word64 -> Doc b # prettyList :: [Word64] -> Doc b #
IsScalar Word64 #
Instance details Defined in Data.Array.Accelerate.Type Methods scalarType :: ScalarType Word64
IsBounded Word64 #
Instance details Defined in Data.Array.Accelerate.Type Methods boundedType :: BoundedType Word64
IsNum Word64 #
Instance details Defined in Data.Array.Accelerate.Type Methods numType :: NumType Word64
IsIntegral Word64 #
Instance details Defined in Data.Array.Accelerate.Type Methods integralType :: IntegralType Word64
Elt Word64 #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods eltType :: Word64 -> TupleType (EltRepr Word64) fromElt :: Word64 -> EltRepr Word64 toElt :: EltRepr Word64 -> Word64
Eq Word64 #
Instance details Defined in Data.Array.Accelerate.Classes.Eq Methods (==) :: Exp Word64 -> Exp Word64 -> Exp Bool # (/=) :: Exp Word64 -> Exp Word64 -> Exp Bool #
Ord Word64 #
Instance details Defined in Data.Array.Accelerate.Classes.Ord Methods (<) :: Exp Word64 -> Exp Word64 -> Exp Bool # (>) :: Exp Word64 -> Exp Word64 -> Exp Bool # (<=) :: Exp Word64 -> Exp Word64 -> Exp Bool # (>=) :: Exp Word64 -> Exp Word64 -> Exp Bool # min :: Exp Word64 -> Exp Word64 -> Exp Word64 # max :: Exp Word64 -> Exp Word64 -> Exp Word64 # compare :: Exp Word64 -> Exp Word64 -> Exp Ordering #
FiniteBits Word64 #
Instance details Defined in Data.Array.Accelerate.Data.Bits Methods finiteBitSize :: Exp Word64 -> Exp Int # countLeadingZeros :: Exp Word64 -> Exp Int # countTrailingZeros :: Exp Word64 -> Exp Int #
Bits Word64 #
Instance details Defined in Data.Array.Accelerate.Data.Bits Methods (.&.) :: Exp Word64 -> Exp Word64 -> Exp Word64 # (.\|.) :: Exp Word64 -> Exp Word64 -> Exp Word64 # xor :: Exp Word64 -> Exp Word64 -> Exp Word64 # complement :: Exp Word64 -> Exp Word64 # shift :: Exp Word64 -> Exp Int -> Exp Word64 # rotate :: Exp Word64 -> Exp Int -> Exp Word64 # zeroBits :: Exp Word64 # bit :: Exp Int -> Exp Word64 # setBit :: Exp Word64 -> Exp Int -> Exp Word64 # clearBit :: Exp Word64 -> Exp Int -> Exp Word64 # complementBit :: Exp Word64 -> Exp Int -> Exp Word64 # testBit :: Exp Word64 -> Exp Int -> Exp Bool # isSigned :: Exp Word64 -> Exp Bool # shiftL :: Exp Word64 -> Exp Int -> Exp Word64 # unsafeShiftL :: Exp Word64 -> Exp Int -> Exp Word64 # shiftR :: Exp Word64 -> Exp Int -> Exp Word64 # unsafeShiftR :: Exp Word64 -> Exp Int -> Exp Word64 # rotateL :: Exp Word64 -> Exp Int -> Exp Word64 # rotateR :: Exp Word64 -> Exp Int -> Exp Word64 # popCount :: Exp Word64 -> Exp Int #
Vector Vector Word64
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Word64 -> m (Vector Word64) # basicUnsafeThaw :: PrimMonad m => Vector Word64 -> m (Mutable Vector (PrimState m) Word64) # basicLength :: Vector Word64 -> Int # basicUnsafeSlice :: Int -> Int -> Vector Word64 -> Vector Word64 # basicUnsafeIndexM :: Monad m => Vector Word64 -> Int -> m Word64 # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Word64 -> Vector Word64 -> m () # elemseq :: Vector Word64 -> Word64 -> b -> b #
MVector MVector Word64
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Word64 -> Int # basicUnsafeSlice :: Int -> Int -> MVector s Word64 -> MVector s Word64 # basicOverlaps :: MVector s Word64 -> MVector s Word64 -> Bool # basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Word64) # basicInitialize :: PrimMonad m => MVector (PrimState m) Word64 -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> Word64 -> m (MVector (PrimState m) Word64) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Word64 -> Int -> m Word64 # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Word64 -> Int -> Word64 -> m () # basicClear :: PrimMonad m => MVector (PrimState m) Word64 -> m () # basicSet :: PrimMonad m => MVector (PrimState m) Word64 -> Word64 -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Word64 -> MVector (PrimState m) Word64 -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Word64 -> MVector (PrimState m) Word64 -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Word64 -> Int -> m (MVector (PrimState m) Word64) #
Lift Exp Word64 #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain Word64 :: Type # Methods lift :: Word64 -> Exp (Plain Word64) #
ToFloating Word64 Double #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word64 -> Exp Double #
ToFloating Word64 Float #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word64 -> Exp Float #
ToFloating Word64 CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word64 -> Exp CFloat #
ToFloating Word64 CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word64 -> Exp CDouble #
ToFloating Word64 Half #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word64 -> Exp Half #
FromIntegral Int Word64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int -> Exp Word64 #
FromIntegral Int8 Word64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int8 -> Exp Word64 #
FromIntegral Int16 Word64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int16 -> Exp Word64 #
FromIntegral Int32 Word64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int32 -> Exp Word64 #
FromIntegral Int64 Word64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int64 -> Exp Word64 #
FromIntegral Word Word64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word -> Exp Word64 #
FromIntegral Word8 Word64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word8 -> Exp Word64 #
FromIntegral Word16 Word64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word16 -> Exp Word64 #
FromIntegral Word32 Word64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word32 -> Exp Word64 #
FromIntegral Word64 Double #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word64 -> Exp Double #
FromIntegral Word64 Float #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word64 -> Exp Float #
FromIntegral Word64 Int #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word64 -> Exp Int #
FromIntegral Word64 Int8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word64 -> Exp Int8 #
FromIntegral Word64 Int16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word64 -> Exp Int16 #
FromIntegral Word64 Int32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word64 -> Exp Int32 #
FromIntegral Word64 Int64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word64 -> Exp Int64 #
FromIntegral Word64 Word #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word64 -> Exp Word #
FromIntegral Word64 Word8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word64 -> Exp Word8 #
FromIntegral Word64 Word16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word64 -> Exp Word16 #
FromIntegral Word64 Word32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word64 -> Exp Word32 #
FromIntegral Word64 Word64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word64 -> Exp Word64 #
FromIntegral Word64 CShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word64 -> Exp CShort #
FromIntegral Word64 CUShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word64 -> Exp CUShort #
FromIntegral Word64 CInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word64 -> Exp CInt #
FromIntegral Word64 CUInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word64 -> Exp CUInt #
FromIntegral Word64 CLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word64 -> Exp CLong #
FromIntegral Word64 CULong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word64 -> Exp CULong #
FromIntegral Word64 CLLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word64 -> Exp CLLong #
FromIntegral Word64 CULLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word64 -> Exp CULLong #
FromIntegral Word64 CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word64 -> Exp CFloat #
FromIntegral Word64 CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word64 -> Exp CDouble #
FromIntegral Word64 Half #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word64 -> Exp Half #
FromIntegral CShort Word64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CShort -> Exp Word64 #
FromIntegral CUShort Word64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUShort -> Exp Word64 #
FromIntegral CInt Word64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CInt -> Exp Word64 #
FromIntegral CUInt Word64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUInt -> Exp Word64 #
FromIntegral CLong Word64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLong -> Exp Word64 #
FromIntegral CULong Word64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULong -> Exp Word64 #
FromIntegral CLLong Word64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLLong -> Exp Word64 #
FromIntegral CULLong Word64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULLong -> Exp Word64 #
Bounded (Exp Word64) #
Instance details Defined in Data.Array.Accelerate.Classes.Bounded Methods minBound :: Exp Word64 # maxBound :: Exp Word64 #
Enum (Exp Word64) #
Instance details Defined in Data.Array.Accelerate.Classes.Enum Methods succ :: Exp Word64 -> Exp Word64 # pred :: Exp Word64 -> Exp Word64 # toEnum :: Int -> Exp Word64 # fromEnum :: Exp Word64 -> Int # enumFrom :: Exp Word64 -> [Exp Word64] # enumFromThen :: Exp Word64 -> Exp Word64 -> [Exp Word64] # enumFromTo :: Exp Word64 -> Exp Word64 -> [Exp Word64] # enumFromThenTo :: Exp Word64 -> Exp Word64 -> Exp Word64 -> [Exp Word64] #
Integral (Exp Word64) #
Instance details Defined in Data.Array.Accelerate.Classes.Integral Methods quot :: Exp Word64 -> Exp Word64 -> Exp Word64 # rem :: Exp Word64 -> Exp Word64 -> Exp Word64 # div :: Exp Word64 -> Exp Word64 -> Exp Word64 # mod :: Exp Word64 -> Exp Word64 -> Exp Word64 # quotRem :: Exp Word64 -> Exp Word64 -> (Exp Word64, Exp Word64) # divMod :: Exp Word64 -> Exp Word64 -> (Exp Word64, Exp Word64) # toInteger :: Exp Word64 -> Integer #
Num (Exp Word64) #
Instance details Defined in Data.Array.Accelerate.Classes.Num Methods (+) :: Exp Word64 -> Exp Word64 -> Exp Word64 # (-) :: Exp Word64 -> Exp Word64 -> Exp Word64 # (*) :: Exp Word64 -> Exp Word64 -> Exp Word64 # negate :: Exp Word64 -> Exp Word64 # abs :: Exp Word64 -> Exp Word64 # signum :: Exp Word64 -> Exp Word64 # fromInteger :: Integer -> Exp Word64 #
type PrimSize Word64
Instance details Defined in Basement.PrimType type PrimSize Word64 = 8
type Difference Word64
Instance details Defined in Basement.Numerical.Subtractive type Difference Word64 = Word64
type NatNumMaxBound Word64
Instance details Defined in Basement.Nat type NatNumMaxBound Word64 = 18446744073709551615
newtype Vector Word64
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Word64 = V_Word64 (Vector Word64)
type Plain Word64 #
Instance details Defined in Data.Array.Accelerate.Lift type Plain Word64 = Word64
newtype MVector s Word64
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Word64 = MV_Word64 (MVector s Word64)

newtype Half #

Constructors

Half
Fields getHalf :: CUShort

Instances

Eq Half
Instance details Defined in Numeric.Half Methods (==) :: Half -> Half -> Bool # (/=) :: Half -> Half -> Bool #
Floating Half
Instance details Defined in Numeric.Half Methods pi :: Half # exp :: Half -> Half # log :: Half -> Half # sqrt :: Half -> Half # (**) :: Half -> Half -> Half # logBase :: Half -> Half -> Half # sin :: Half -> Half # cos :: Half -> Half # tan :: Half -> Half # asin :: Half -> Half # acos :: Half -> Half # atan :: Half -> Half # sinh :: Half -> Half # cosh :: Half -> Half # tanh :: Half -> Half # asinh :: Half -> Half # acosh :: Half -> Half # atanh :: Half -> Half # log1p :: Half -> Half # expm1 :: Half -> Half # log1pexp :: Half -> Half # log1mexp :: Half -> Half #
Fractional Half
Instance details Defined in Numeric.Half Methods (/) :: Half -> Half -> Half # recip :: Half -> Half # fromRational :: Rational -> Half #
Num Half
Instance details Defined in Numeric.Half Methods (+) :: Half -> Half -> Half # (-) :: Half -> Half -> Half # (*) :: Half -> Half -> Half # negate :: Half -> Half # abs :: Half -> Half # signum :: Half -> Half # fromInteger :: Integer -> Half #
Ord Half
Instance details Defined in Numeric.Half Methods compare :: Half -> Half -> Ordering # (<) :: Half -> Half -> Bool # (<=) :: Half -> Half -> Bool # (>) :: Half -> Half -> Bool # (>=) :: Half -> Half -> Bool # max :: Half -> Half -> Half # min :: Half -> Half -> Half #
Read Half
Instance details Defined in Numeric.Half Methods readsPrec :: Int -> ReadS Half # readList :: ReadS [Half] # readPrec :: ReadPrec Half # readListPrec :: ReadPrec [Half] #
Real Half
Instance details Defined in Numeric.Half Methods toRational :: Half -> Rational #
RealFloat Half
Instance details Defined in Numeric.Half Methods floatRadix :: Half -> Integer # floatDigits :: Half -> Int # floatRange :: Half -> (Int, Int) # decodeFloat :: Half -> (Integer, Int) # encodeFloat :: Integer -> Int -> Half # exponent :: Half -> Int # significand :: Half -> Half # scaleFloat :: Int -> Half -> Half # isNaN :: Half -> Bool # isInfinite :: Half -> Bool # isDenormalized :: Half -> Bool # isNegativeZero :: Half -> Bool # isIEEE :: Half -> Bool # atan2 :: Half -> Half -> Half #
RealFrac Half
Instance details Defined in Numeric.Half Methods properFraction :: Integral b => Half -> (b, Half) # truncate :: Integral b => Half -> b # round :: Integral b => Half -> b # ceiling :: Integral b => Half -> b # floor :: Integral b => Half -> b #
Show Half
Instance details Defined in Numeric.Half Methods showsPrec :: Int -> Half -> ShowS # show :: Half -> String # showList :: [Half] -> ShowS #
Generic Half
Instance details Defined in Numeric.Half Associated Types type Rep Half :: Type -> Type # Methods from :: Half -> Rep Half x # to :: Rep Half x -> Half #
Lift Half
Instance details Defined in Numeric.Half Methods lift :: Half -> Q Exp #
Storable Half
Instance details Defined in Numeric.Half Methods sizeOf :: Half -> Int # alignment :: Half -> Int # peekElemOff :: Ptr Half -> Int -> IO Half # pokeElemOff :: Ptr Half -> Int -> Half -> IO () # peekByteOff :: Ptr b -> Int -> IO Half # pokeByteOff :: Ptr b -> Int -> Half -> IO () # peek :: Ptr Half -> IO Half # poke :: Ptr Half -> Half -> IO () #
NFData Half
Instance details Defined in Numeric.Half Methods rnf :: Half -> () #
IsScalar Half #
Instance details Defined in Data.Array.Accelerate.Type Methods scalarType :: ScalarType Half
IsNum Half #
Instance details Defined in Data.Array.Accelerate.Type Methods numType :: NumType Half
IsFloating Half #
Instance details Defined in Data.Array.Accelerate.Type Methods floatingType :: FloatingType Half
Elt Half #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods eltType :: Half -> TupleType (EltRepr Half) fromElt :: Half -> EltRepr Half toElt :: EltRepr Half -> Half
Eq Half #
Instance details Defined in Data.Array.Accelerate.Classes.Eq Methods (==) :: Exp Half -> Exp Half -> Exp Bool # (/=) :: Exp Half -> Exp Half -> Exp Bool #
Ord Half #
Instance details Defined in Data.Array.Accelerate.Classes.Ord Methods (<) :: Exp Half -> Exp Half -> Exp Bool # (>) :: Exp Half -> Exp Half -> Exp Bool # (<=) :: Exp Half -> Exp Half -> Exp Bool # (>=) :: Exp Half -> Exp Half -> Exp Bool # min :: Exp Half -> Exp Half -> Exp Half # max :: Exp Half -> Exp Half -> Exp Half # compare :: Exp Half -> Exp Half -> Exp Ordering #
RealFrac Half #
Instance details Defined in Data.Array.Accelerate.Classes.RealFrac 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 #
Instance details Defined in Data.Array.Accelerate.Classes.RealFloat Methods floatRadix :: Exp Half -> Exp Int64 # floatDigits :: Exp Half -> Exp Int # floatRange :: Exp Half -> (Exp Int, Exp Int) # decodeFloat :: Exp Half -> (Exp Int64, Exp Int) # encodeFloat :: Exp Int64 -> Exp Int -> Exp Half # exponent :: Exp Half -> Exp Int # significand :: Exp Half -> Exp Half # scaleFloat :: Exp Int -> Exp Half -> Exp Half # isNaN :: Exp Half -> Exp Bool # isInfinite :: Exp Half -> Exp Bool # isDenormalized :: Exp Half -> Exp Bool # isNegativeZero :: Exp Half -> Exp Bool # isIEEE :: Exp Half -> Exp Bool # atan2 :: Exp Half -> Exp Half -> Exp Half #
ToFloating Double Half #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Double -> Exp Half #
ToFloating Float Half #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Float -> Exp Half #
ToFloating Int Half #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int -> Exp Half #
ToFloating Int8 Half #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int8 -> Exp Half #
ToFloating Int16 Half #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int16 -> Exp Half #
ToFloating Int32 Half #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int32 -> Exp Half #
ToFloating Int64 Half #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int64 -> Exp Half #
ToFloating Word Half #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word -> Exp Half #
ToFloating Word8 Half #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word8 -> Exp Half #
ToFloating Word16 Half #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word16 -> Exp Half #
ToFloating Word32 Half #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word32 -> Exp Half #
ToFloating Word64 Half #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word64 -> Exp Half #
ToFloating CShort Half #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CShort -> Exp Half #
ToFloating CUShort Half #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CUShort -> Exp Half #
ToFloating CInt Half #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CInt -> Exp Half #
ToFloating CUInt Half #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CUInt -> Exp Half #
ToFloating CLong Half #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CLong -> Exp Half #
ToFloating CULong Half #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CULong -> Exp Half #
ToFloating CLLong Half #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CLLong -> Exp Half #
ToFloating CULLong Half #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CULLong -> Exp Half #
ToFloating CFloat Half #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CFloat -> Exp Half #
ToFloating CDouble Half #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CDouble -> Exp Half #
ToFloating Half Double #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Half -> Exp Double #
ToFloating Half Float #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Half -> Exp Float #
ToFloating Half CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Half -> Exp CFloat #
ToFloating Half CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Half -> Exp CDouble #
ToFloating Half Half #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Half -> Exp Half #
FromIntegral Int Half #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int -> Exp Half #
FromIntegral Int8 Half #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int8 -> Exp Half #
FromIntegral Int16 Half #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int16 -> Exp Half #
FromIntegral Int32 Half #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int32 -> Exp Half #
FromIntegral Int64 Half #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int64 -> Exp Half #
FromIntegral Word Half #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word -> Exp Half #
FromIntegral Word8 Half #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word8 -> Exp Half #
FromIntegral Word16 Half #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word16 -> Exp Half #
FromIntegral Word32 Half #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word32 -> Exp Half #
FromIntegral Word64 Half #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word64 -> Exp Half #
FromIntegral CShort Half #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CShort -> Exp Half #
FromIntegral CUShort Half #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUShort -> Exp Half #
FromIntegral CInt Half #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CInt -> Exp Half #
FromIntegral CUInt Half #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUInt -> Exp Half #
FromIntegral CLong Half #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLong -> Exp Half #
FromIntegral CULong Half #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULong -> Exp Half #
FromIntegral CLLong Half #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLLong -> Exp Half #
FromIntegral CULLong Half #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULLong -> Exp Half #
Enum (Exp Half) #
Instance details Defined in Data.Array.Accelerate.Classes.Enum Methods succ :: Exp Half -> Exp Half # pred :: Exp Half -> Exp Half # toEnum :: Int -> Exp Half # fromEnum :: Exp Half -> Int # enumFrom :: Exp Half -> [Exp Half] # enumFromThen :: Exp Half -> Exp Half -> [Exp Half] # enumFromTo :: Exp Half -> Exp Half -> [Exp Half] # enumFromThenTo :: Exp Half -> Exp Half -> Exp Half -> [Exp Half] #
Floating (Exp Half) #
Instance details Defined in Data.Array.Accelerate.Classes.Floating Methods pi :: Exp Half # exp :: Exp Half -> Exp Half # log :: Exp Half -> Exp Half # sqrt :: Exp Half -> Exp Half # (**) :: Exp Half -> Exp Half -> Exp Half # logBase :: Exp Half -> Exp Half -> Exp Half # sin :: Exp Half -> Exp Half # cos :: Exp Half -> Exp Half # tan :: Exp Half -> Exp Half # asin :: Exp Half -> Exp Half # acos :: Exp Half -> Exp Half # atan :: Exp Half -> Exp Half # sinh :: Exp Half -> Exp Half # cosh :: Exp Half -> Exp Half # tanh :: Exp Half -> Exp Half # asinh :: Exp Half -> Exp Half # acosh :: Exp Half -> Exp Half # atanh :: Exp Half -> Exp Half # log1p :: Exp Half -> Exp Half # expm1 :: Exp Half -> Exp Half # log1pexp :: Exp Half -> Exp Half # log1mexp :: Exp Half -> Exp Half #
Fractional (Exp Half) #
Instance details Defined in Data.Array.Accelerate.Classes.Fractional Methods (/) :: Exp Half -> Exp Half -> Exp Half # recip :: Exp Half -> Exp Half # fromRational :: Rational -> Exp Half #
Num (Exp Half) #
Instance details Defined in Data.Array.Accelerate.Classes.Num Methods (+) :: Exp Half -> Exp Half -> Exp Half # (-) :: Exp Half -> Exp Half -> Exp Half # (*) :: Exp Half -> Exp Half -> Exp Half # negate :: Exp Half -> Exp Half # abs :: Exp Half -> Exp Half # signum :: Exp Half -> Exp Half # fromInteger :: Integer -> Exp Half #
Elt (Complex Half) #
Instance details Defined in Data.Array.Accelerate.Data.Complex Methods eltType :: Complex Half -> TupleType (EltRepr (Complex Half)) fromElt :: Complex Half -> EltRepr (Complex Half) toElt :: EltRepr (Complex Half) -> Complex Half
type Rep Half
Instance details Defined in Numeric.Half type Rep Half = D1 (MetaData "Half" "Numeric.Half" "half-0.3-Ev8Lz3j60xACodwSKk6ogk" True) (C1 (MetaCons "Half" PrefixI True) (S1 (MetaSel (Just "getHalf") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 CUShort)))

data Float #

Single-precision floating point numbers. It is desirable that this type be at least equal in range and precision to the IEEE single-precision type.

Instances

Eq Float	Note that due to the presence of `NaN`, `Float`'s `Eq` instance does not satisfy reflexivity. `>>>` `0/0 == (0/0 :: Float)`False Also note that `Float`'s `Eq` instance does not satisfy substitutivity: `>>>` `0 == (-0 :: Float)`True `>>>` `recip 0 == recip (-0 :: Float)`False
Instance details Defined in GHC.Classes Methods (==) :: Float -> Float -> Bool # (/=) :: Float -> Float -> Bool #
Floating Float	Since: base-2.1
Instance details Defined in GHC.Float Methods pi :: Float # exp :: Float -> Float # log :: Float -> Float # sqrt :: Float -> Float # (**) :: Float -> Float -> Float # logBase :: Float -> Float -> Float # sin :: Float -> Float # cos :: Float -> Float # tan :: Float -> Float # asin :: Float -> Float # acos :: Float -> Float # atan :: Float -> Float # sinh :: Float -> Float # cosh :: Float -> Float # tanh :: Float -> Float # asinh :: Float -> Float # acosh :: Float -> Float # atanh :: Float -> Float # log1p :: Float -> Float # expm1 :: Float -> Float # log1pexp :: Float -> Float # log1mexp :: Float -> Float #
Ord Float	Note that due to the presence of `NaN`, `Float`'s `Ord` instance does not satisfy reflexivity. `>>>` `0/0 <= (0/0 :: Float)`False Also note that, due to the same, `Ord`'s operator interactions are not respected by `Float`'s instance: `>>>` `(0/0 :: Float) > 1`False `>>>` `compare (0/0 :: Float) 1`GT
Instance details Defined in GHC.Classes Methods compare :: Float -> Float -> Ordering # (<) :: Float -> Float -> Bool # (<=) :: Float -> Float -> Bool # (>) :: Float -> Float -> Bool # (>=) :: Float -> Float -> Bool # max :: Float -> Float -> Float # min :: Float -> Float -> Float #
Read Float	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Float # readList :: ReadS [Float] # readPrec :: ReadPrec Float # readListPrec :: ReadPrec [Float] #
RealFloat Float	Since: base-2.1
Instance details Defined in GHC.Float Methods floatRadix :: Float -> Integer # floatDigits :: Float -> Int # floatRange :: Float -> (Int, Int) # decodeFloat :: Float -> (Integer, Int) # encodeFloat :: Integer -> Int -> Float # exponent :: Float -> Int # significand :: Float -> Float # scaleFloat :: Int -> Float -> Float # isNaN :: Float -> Bool # isInfinite :: Float -> Bool # isDenormalized :: Float -> Bool # isNegativeZero :: Float -> Bool # isIEEE :: Float -> Bool # atan2 :: Float -> Float -> Float #
Lift Float
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Float -> Q Exp #
Pretty Float
Instance details Defined in Text.PrettyPrint.ANSI.Leijen.Internal Methods pretty :: Float -> Doc # prettyList :: [Float] -> Doc #
PrintfArg Float	Since: base-2.1
Instance details Defined in Text.Printf Methods formatArg :: Float -> FieldFormatter # parseFormat :: Float -> ModifierParser #
Storable Float	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Float -> Int # alignment :: Float -> Int # peekElemOff :: Ptr Float -> Int -> IO Float # pokeElemOff :: Ptr Float -> Int -> Float -> IO () # peekByteOff :: Ptr b -> Int -> IO Float # pokeByteOff :: Ptr b -> Int -> Float -> IO () # peek :: Ptr Float -> IO Float # poke :: Ptr Float -> Float -> IO () #
PrimType Float
Instance details Defined in Basement.PrimType Associated Types type PrimSize Float :: Nat # Methods primSizeInBytes :: Proxy Float -> CountOf Word8 # primShiftToBytes :: Proxy Float -> Int # primBaUIndex :: ByteArray# -> Offset Float -> Float # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Float -> prim Float # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Float -> Float -> prim () # primAddrIndex :: Addr# -> Offset Float -> Float # primAddrRead :: PrimMonad prim => Addr# -> Offset Float -> prim Float # primAddrWrite :: PrimMonad prim => Addr# -> Offset Float -> Float -> prim () #
Subtractive Float
Instance details Defined in Basement.Numerical.Subtractive Associated Types type Difference Float :: Type # Methods (-) :: Float -> Float -> Difference Float #
NFData Float
Instance details Defined in Control.DeepSeq Methods rnf :: Float -> () #
Hashable Float
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Float -> Int # hash :: Float -> Int #
Prim Float
Instance details Defined in Data.Primitive.Types Methods sizeOf# :: Float -> Int# # alignment# :: Float -> Int# # indexByteArray# :: ByteArray# -> Int# -> Float # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, Float#) # writeByteArray# :: MutableByteArray# s -> Int# -> Float -> State# s -> State# s # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Float -> State# s -> State# s # indexOffAddr# :: Addr# -> Int# -> Float # readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, Float#) # writeOffAddr# :: Addr# -> Int# -> Float -> State# s -> State# s # setOffAddr# :: Addr# -> Int# -> Int# -> Float -> State# s -> State# s #
Unbox Float
Instance details Defined in Data.Vector.Unboxed.Base
Pretty Float
Instance details Defined in Text.PrettyPrint.Annotated.WL Methods pretty :: Float -> Doc b # prettyList :: [Float] -> Doc b #
IsScalar Float #
Instance details Defined in Data.Array.Accelerate.Type Methods scalarType :: ScalarType Float
IsNum Float #
Instance details Defined in Data.Array.Accelerate.Type Methods numType :: NumType Float
IsFloating Float #
Instance details Defined in Data.Array.Accelerate.Type Methods floatingType :: FloatingType Float
Elt Float #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods eltType :: Float -> TupleType (EltRepr Float) fromElt :: Float -> EltRepr Float toElt :: EltRepr Float -> Float
Eq Float #
Instance details Defined in Data.Array.Accelerate.Classes.Eq Methods (==) :: Exp Float -> Exp Float -> Exp Bool # (/=) :: Exp Float -> Exp Float -> Exp Bool #
Ord Float #
Instance details Defined in Data.Array.Accelerate.Classes.Ord Methods (<) :: Exp Float -> Exp Float -> Exp Bool # (>) :: Exp Float -> Exp Float -> Exp Bool # (<=) :: Exp Float -> Exp Float -> Exp Bool # (>=) :: Exp Float -> Exp Float -> Exp Bool # min :: Exp Float -> Exp Float -> Exp Float # max :: Exp Float -> Exp Float -> Exp Float # compare :: Exp Float -> Exp Float -> Exp Ordering #
RealFrac Float #
Instance details Defined in Data.Array.Accelerate.Classes.RealFrac 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 #
Instance details Defined in Data.Array.Accelerate.Classes.RealFloat Methods floatRadix :: Exp Float -> Exp Int64 # floatDigits :: Exp Float -> Exp Int # floatRange :: Exp Float -> (Exp Int, Exp Int) # decodeFloat :: Exp Float -> (Exp Int64, Exp Int) # encodeFloat :: Exp Int64 -> Exp Int -> Exp Float # exponent :: Exp Float -> Exp Int # significand :: Exp Float -> Exp Float # scaleFloat :: Exp Int -> Exp Float -> Exp Float # isNaN :: Exp Float -> Exp Bool # isInfinite :: Exp Float -> Exp Bool # isDenormalized :: Exp Float -> Exp Bool # isNegativeZero :: Exp Float -> Exp Bool # isIEEE :: Exp Float -> Exp Bool # atan2 :: Exp Float -> Exp Float -> Exp Float #
Vector Vector Float
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Float -> m (Vector Float) # basicUnsafeThaw :: PrimMonad m => Vector Float -> m (Mutable Vector (PrimState m) Float) # basicLength :: Vector Float -> Int # basicUnsafeSlice :: Int -> Int -> Vector Float -> Vector Float # basicUnsafeIndexM :: Monad m => Vector Float -> Int -> m Float # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Float -> Vector Float -> m () # elemseq :: Vector Float -> Float -> b -> b #
MVector MVector Float
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Float -> Int # basicUnsafeSlice :: Int -> Int -> MVector s Float -> MVector s Float # basicOverlaps :: MVector s Float -> MVector s Float -> Bool # basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Float) # basicInitialize :: PrimMonad m => MVector (PrimState m) Float -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> Float -> m (MVector (PrimState m) Float) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Float -> Int -> m Float # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Float -> Int -> Float -> m () # basicClear :: PrimMonad m => MVector (PrimState m) Float -> m () # basicSet :: PrimMonad m => MVector (PrimState m) Float -> Float -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Float -> MVector (PrimState m) Float -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Float -> MVector (PrimState m) Float -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Float -> Int -> m (MVector (PrimState m) Float) #
Lift Exp Float #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain Float :: Type # Methods lift :: Float -> Exp (Plain Float) #
ToFloating Double Float #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Double -> Exp Float #
ToFloating Float Double #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Float -> Exp Double #
ToFloating Float Float #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Float -> Exp Float #
ToFloating Float CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Float -> Exp CFloat #
ToFloating Float CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Float -> Exp CDouble #
ToFloating Float Half #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Float -> Exp Half #
ToFloating Int Float #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int -> Exp Float #
ToFloating Int8 Float #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int8 -> Exp Float #
ToFloating Int16 Float #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int16 -> Exp Float #
ToFloating Int32 Float #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int32 -> Exp Float #
ToFloating Int64 Float #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int64 -> Exp Float #
ToFloating Word Float #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word -> Exp Float #
ToFloating Word8 Float #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word8 -> Exp Float #
ToFloating Word16 Float #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word16 -> Exp Float #
ToFloating Word32 Float #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word32 -> Exp Float #
ToFloating Word64 Float #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word64 -> Exp Float #
ToFloating CShort Float #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CShort -> Exp Float #
ToFloating CUShort Float #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CUShort -> Exp Float #
ToFloating CInt Float #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CInt -> Exp Float #
ToFloating CUInt Float #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CUInt -> Exp Float #
ToFloating CLong Float #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CLong -> Exp Float #
ToFloating CULong Float #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CULong -> Exp Float #
ToFloating CLLong Float #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CLLong -> Exp Float #
ToFloating CULLong Float #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CULLong -> Exp Float #
ToFloating CFloat Float #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CFloat -> Exp Float #
ToFloating CDouble Float #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CDouble -> Exp Float #
ToFloating Half Float #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Half -> Exp Float #
FromIntegral Int Float #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int -> Exp Float #
FromIntegral Int8 Float #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int8 -> Exp Float #
FromIntegral Int16 Float #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int16 -> Exp Float #
FromIntegral Int32 Float #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int32 -> Exp Float #
FromIntegral Int64 Float #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int64 -> Exp Float #
FromIntegral Word Float #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word -> Exp Float #
FromIntegral Word8 Float #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word8 -> Exp Float #
FromIntegral Word16 Float #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word16 -> Exp Float #
FromIntegral Word32 Float #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word32 -> Exp Float #
FromIntegral Word64 Float #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word64 -> Exp Float #
FromIntegral CShort Float #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CShort -> Exp Float #
FromIntegral CUShort Float #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUShort -> Exp Float #
FromIntegral CInt Float #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CInt -> Exp Float #
FromIntegral CUInt Float #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUInt -> Exp Float #
FromIntegral CLong Float #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLong -> Exp Float #
FromIntegral CULong Float #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULong -> Exp Float #
FromIntegral CLLong Float #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLLong -> Exp Float #
FromIntegral CULLong Float #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULLong -> Exp Float #
() :=> (Enum Float)
Instance details Defined in Data.Constraint Methods ins :: () :- Enum Float #
() :=> (Eq Float)
Instance details Defined in Data.Constraint Methods ins :: () :- Eq Float #
() :=> (Floating Float)
Instance details Defined in Data.Constraint Methods ins :: () :- Floating Float #
() :=> (Fractional Float)
Instance details Defined in Data.Constraint Methods ins :: () :- Fractional Float #
() :=> (Num Float)
Instance details Defined in Data.Constraint Methods ins :: () :- Num Float #
() :=> (Ord Float)
Instance details Defined in Data.Constraint Methods ins :: () :- Ord Float #
() :=> (Real Float)
Instance details Defined in Data.Constraint Methods ins :: () :- Real Float #
() :=> (RealFloat Float)
Instance details Defined in Data.Constraint Methods ins :: () :- RealFloat Float #
() :=> (RealFrac Float)
Instance details Defined in Data.Constraint Methods ins :: () :- RealFrac Float #
Generic1 (URec Float :: k -> Type)
Instance details Defined in GHC.Generics Associated Types type Rep1 (URec Float) :: k -> Type # Methods from1 :: URec Float a -> Rep1 (URec Float) a # to1 :: Rep1 (URec Float) a -> URec Float a #
Enum (Exp Float) #
Instance details Defined in Data.Array.Accelerate.Classes.Enum Methods succ :: Exp Float -> Exp Float # pred :: Exp Float -> Exp Float # toEnum :: Int -> Exp Float # fromEnum :: Exp Float -> Int # enumFrom :: Exp Float -> [Exp Float] # enumFromThen :: Exp Float -> Exp Float -> [Exp Float] # enumFromTo :: Exp Float -> Exp Float -> [Exp Float] # enumFromThenTo :: Exp Float -> Exp Float -> Exp Float -> [Exp Float] #
Floating (Exp Float) #
Instance details Defined in Data.Array.Accelerate.Classes.Floating Methods pi :: Exp Float # exp :: Exp Float -> Exp Float # log :: Exp Float -> Exp Float # sqrt :: Exp Float -> Exp Float # (**) :: Exp Float -> Exp Float -> Exp Float # logBase :: Exp Float -> Exp Float -> Exp Float # sin :: Exp Float -> Exp Float # cos :: Exp Float -> Exp Float # tan :: Exp Float -> Exp Float # asin :: Exp Float -> Exp Float # acos :: Exp Float -> Exp Float # atan :: Exp Float -> Exp Float # sinh :: Exp Float -> Exp Float # cosh :: Exp Float -> Exp Float # tanh :: Exp Float -> Exp Float # asinh :: Exp Float -> Exp Float # acosh :: Exp Float -> Exp Float # atanh :: Exp Float -> Exp Float # log1p :: Exp Float -> Exp Float # expm1 :: Exp Float -> Exp Float # log1pexp :: Exp Float -> Exp Float # log1mexp :: Exp Float -> Exp Float #
Fractional (Exp Float) #
Instance details Defined in Data.Array.Accelerate.Classes.Fractional Methods (/) :: Exp Float -> Exp Float -> Exp Float # recip :: Exp Float -> Exp Float # fromRational :: Rational -> Exp Float #
Num (Exp Float) #
Instance details Defined in Data.Array.Accelerate.Classes.Num Methods (+) :: Exp Float -> Exp Float -> Exp Float # (-) :: Exp Float -> Exp Float -> Exp Float # (*) :: Exp Float -> Exp Float -> Exp Float # negate :: Exp Float -> Exp Float # abs :: Exp Float -> Exp Float # signum :: Exp Float -> Exp Float # fromInteger :: Integer -> Exp Float #
Elt (Complex Float) #
Instance details Defined in Data.Array.Accelerate.Data.Complex Methods eltType :: Complex Float -> TupleType (EltRepr (Complex Float)) fromElt :: Complex Float -> EltRepr (Complex Float) toElt :: EltRepr (Complex Float) -> Complex Float
Functor (URec Float :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> URec Float a -> URec Float b # (<$) :: a -> URec Float b -> URec Float a #
Foldable (URec Float :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Foldable 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 :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable 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)
Instance details Defined in GHC.Generics Methods (==) :: URec Float p -> URec Float p -> Bool # (/=) :: URec Float p -> URec Float p -> Bool #
Ord (URec Float p)
Instance details Defined in GHC.Generics Methods compare :: URec Float p -> URec Float p -> Ordering # (<) :: URec Float p -> URec Float p -> Bool # (<=) :: URec Float p -> URec Float p -> Bool # (>) :: URec Float p -> URec Float p -> Bool # (>=) :: URec Float p -> URec Float p -> Bool # max :: URec Float p -> URec Float p -> URec Float p # min :: URec Float p -> URec Float p -> URec Float p #
Show (URec Float p)
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> URec Float p -> ShowS # show :: URec Float p -> String # showList :: [URec Float p] -> ShowS #
Generic (URec Float p)
Instance details Defined in GHC.Generics Associated Types type Rep (URec Float p) :: Type -> Type # Methods from :: URec Float p -> Rep (URec Float p) x # to :: Rep (URec Float p) x -> URec Float p #
type PrimSize Float
Instance details Defined in Basement.PrimType type PrimSize Float = 4
type Difference Float
Instance details Defined in Basement.Numerical.Subtractive type Difference Float = Float
newtype Vector Float
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Float = V_Float (Vector Float)
type Plain Float #
Instance details Defined in Data.Array.Accelerate.Lift type Plain Float = Float
data URec Float (p :: k)	Used for marking occurrences of `Float#` Since: base-4.9.0.0
Instance details Defined in GHC.Generics data URec Float (p :: k) = UFloat { uFloat# :: Float# }
newtype MVector s Float
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Float = MV_Float (MVector s Float)
type Rep1 (URec Float :: k -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics type Rep1 (URec Float :: k -> Type) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UFloat" PrefixI True) (S1 (MetaSel (Just "uFloat#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (UFloat :: k -> Type)))
type Rep (URec Float p)
Instance details Defined in GHC.Generics type Rep (URec Float p) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UFloat" PrefixI True) (S1 (MetaSel (Just "uFloat#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (UFloat :: Type -> Type)))

data Double #

Double-precision floating point numbers. It is desirable that this type be at least equal in range and precision to the IEEE double-precision type.

Instances

Eq Double	Note that due to the presence of `NaN`, `Double`'s `Eq` instance does not satisfy reflexivity. `>>>` `0/0 == (0/0 :: Double)`False Also note that `Double`'s `Eq` instance does not satisfy substitutivity: `>>>` `0 == (-0 :: Double)`True `>>>` `recip 0 == recip (-0 :: Double)`False
Instance details Defined in GHC.Classes Methods (==) :: Double -> Double -> Bool # (/=) :: Double -> Double -> Bool #
Floating Double	Since: base-2.1
Instance details Defined in GHC.Float Methods pi :: Double # exp :: Double -> Double # log :: Double -> Double # sqrt :: Double -> Double # (**) :: Double -> Double -> Double # logBase :: Double -> Double -> Double # sin :: Double -> Double # cos :: Double -> Double # tan :: Double -> Double # asin :: Double -> Double # acos :: Double -> Double # atan :: Double -> Double # sinh :: Double -> Double # cosh :: Double -> Double # tanh :: Double -> Double # asinh :: Double -> Double # acosh :: Double -> Double # atanh :: Double -> Double # log1p :: Double -> Double # expm1 :: Double -> Double # log1pexp :: Double -> Double # log1mexp :: Double -> Double #
Ord Double	Note that due to the presence of `NaN`, `Double`'s `Ord` instance does not satisfy reflexivity. `>>>` `0/0 <= (0/0 :: Double)`False Also note that, due to the same, `Ord`'s operator interactions are not respected by `Double`'s instance: `>>>` `(0/0 :: Double) > 1`False `>>>` `compare (0/0 :: Double) 1`GT
Instance details Defined in GHC.Classes Methods compare :: Double -> Double -> Ordering # (<) :: Double -> Double -> Bool # (<=) :: Double -> Double -> Bool # (>) :: Double -> Double -> Bool # (>=) :: Double -> Double -> Bool # max :: Double -> Double -> Double # min :: Double -> Double -> Double #
Read Double	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Double # readList :: ReadS [Double] # readPrec :: ReadPrec Double # readListPrec :: ReadPrec [Double] #
RealFloat Double	Since: base-2.1
Instance details Defined in GHC.Float Methods floatRadix :: Double -> Integer # floatDigits :: Double -> Int # floatRange :: Double -> (Int, Int) # decodeFloat :: Double -> (Integer, Int) # encodeFloat :: Integer -> Int -> Double # exponent :: Double -> Int # significand :: Double -> Double # scaleFloat :: Int -> Double -> Double # isNaN :: Double -> Bool # isInfinite :: Double -> Bool # isDenormalized :: Double -> Bool # isNegativeZero :: Double -> Bool # isIEEE :: Double -> Bool # atan2 :: Double -> Double -> Double #
Lift Double
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Double -> Q Exp #
Pretty Double
Instance details Defined in Text.PrettyPrint.ANSI.Leijen.Internal Methods pretty :: Double -> Doc # prettyList :: [Double] -> Doc #
PrintfArg Double	Since: base-2.1
Instance details Defined in Text.Printf Methods formatArg :: Double -> FieldFormatter # parseFormat :: Double -> ModifierParser #
Storable Double	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Double -> Int # alignment :: Double -> Int # peekElemOff :: Ptr Double -> Int -> IO Double # pokeElemOff :: Ptr Double -> Int -> Double -> IO () # peekByteOff :: Ptr b -> Int -> IO Double # pokeByteOff :: Ptr b -> Int -> Double -> IO () # peek :: Ptr Double -> IO Double # poke :: Ptr Double -> Double -> IO () #
PrimType Double
Instance details Defined in Basement.PrimType Associated Types type PrimSize Double :: Nat # Methods primSizeInBytes :: Proxy Double -> CountOf Word8 # primShiftToBytes :: Proxy Double -> Int # primBaUIndex :: ByteArray# -> Offset Double -> Double # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Double -> prim Double # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Double -> Double -> prim () # primAddrIndex :: Addr# -> Offset Double -> Double # primAddrRead :: PrimMonad prim => Addr# -> Offset Double -> prim Double # primAddrWrite :: PrimMonad prim => Addr# -> Offset Double -> Double -> prim () #
Subtractive Double
Instance details Defined in Basement.Numerical.Subtractive Associated Types type Difference Double :: Type # Methods (-) :: Double -> Double -> Difference Double #
NFData Double
Instance details Defined in Control.DeepSeq Methods rnf :: Double -> () #
Hashable Double
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Double -> Int # hash :: Double -> Int #
Prim Double
Instance details Defined in Data.Primitive.Types Methods sizeOf# :: Double -> Int# # alignment# :: Double -> Int# # indexByteArray# :: ByteArray# -> Int# -> Double # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, Double#) # writeByteArray# :: MutableByteArray# s -> Int# -> Double -> State# s -> State# s # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Double -> State# s -> State# s # indexOffAddr# :: Addr# -> Int# -> Double # readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, Double#) # writeOffAddr# :: Addr# -> Int# -> Double -> State# s -> State# s # setOffAddr# :: Addr# -> Int# -> Int# -> Double -> State# s -> State# s #
Unbox Double
Instance details Defined in Data.Vector.Unboxed.Base
Pretty Double
Instance details Defined in Text.PrettyPrint.Annotated.WL Methods pretty :: Double -> Doc b # prettyList :: [Double] -> Doc b #
IsScalar Double #
Instance details Defined in Data.Array.Accelerate.Type Methods scalarType :: ScalarType Double
IsNum Double #
Instance details Defined in Data.Array.Accelerate.Type Methods numType :: NumType Double
IsFloating Double #
Instance details Defined in Data.Array.Accelerate.Type Methods floatingType :: FloatingType Double
Elt Double #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods eltType :: Double -> TupleType (EltRepr Double) fromElt :: Double -> EltRepr Double toElt :: EltRepr Double -> Double
Eq Double #
Instance details Defined in Data.Array.Accelerate.Classes.Eq Methods (==) :: Exp Double -> Exp Double -> Exp Bool # (/=) :: Exp Double -> Exp Double -> Exp Bool #
Ord Double #
Instance details Defined in Data.Array.Accelerate.Classes.Ord Methods (<) :: Exp Double -> Exp Double -> Exp Bool # (>) :: Exp Double -> Exp Double -> Exp Bool # (<=) :: Exp Double -> Exp Double -> Exp Bool # (>=) :: Exp Double -> Exp Double -> Exp Bool # min :: Exp Double -> Exp Double -> Exp Double # max :: Exp Double -> Exp Double -> Exp Double # compare :: Exp Double -> Exp Double -> Exp Ordering #
RealFrac Double #
Instance details Defined in Data.Array.Accelerate.Classes.RealFrac 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 #
Instance details Defined in Data.Array.Accelerate.Classes.RealFloat Methods floatRadix :: Exp Double -> Exp Int64 # floatDigits :: Exp Double -> Exp Int # floatRange :: Exp Double -> (Exp Int, Exp Int) # decodeFloat :: Exp Double -> (Exp Int64, Exp Int) # encodeFloat :: Exp Int64 -> Exp Int -> Exp Double # exponent :: Exp Double -> Exp Int # significand :: Exp Double -> Exp Double # scaleFloat :: Exp Int -> Exp Double -> Exp Double # isNaN :: Exp Double -> Exp Bool # isInfinite :: Exp Double -> Exp Bool # isDenormalized :: Exp Double -> Exp Bool # isNegativeZero :: Exp Double -> Exp Bool # isIEEE :: Exp Double -> Exp Bool # atan2 :: Exp Double -> Exp Double -> Exp Double #
Vector Vector Double
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Double -> m (Vector Double) # basicUnsafeThaw :: PrimMonad m => Vector Double -> m (Mutable Vector (PrimState m) Double) # basicLength :: Vector Double -> Int # basicUnsafeSlice :: Int -> Int -> Vector Double -> Vector Double # basicUnsafeIndexM :: Monad m => Vector Double -> Int -> m Double # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Double -> Vector Double -> m () # elemseq :: Vector Double -> Double -> b -> b #
MVector MVector Double
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Double -> Int # basicUnsafeSlice :: Int -> Int -> MVector s Double -> MVector s Double # basicOverlaps :: MVector s Double -> MVector s Double -> Bool # basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Double) # basicInitialize :: PrimMonad m => MVector (PrimState m) Double -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> Double -> m (MVector (PrimState m) Double) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Double -> Int -> m Double # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Double -> Int -> Double -> m () # basicClear :: PrimMonad m => MVector (PrimState m) Double -> m () # basicSet :: PrimMonad m => MVector (PrimState m) Double -> Double -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Double -> MVector (PrimState m) Double -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Double -> MVector (PrimState m) Double -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Double -> Int -> m (MVector (PrimState m) Double) #
Lift Exp Double #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain Double :: Type # Methods lift :: Double -> Exp (Plain Double) #
ToFloating Double Double #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Double -> Exp Double #
ToFloating Double Float #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Double -> Exp Float #
ToFloating Double CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Double -> Exp CFloat #
ToFloating Double CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Double -> Exp CDouble #
ToFloating Double Half #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Double -> Exp Half #
ToFloating Float Double #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Float -> Exp Double #
ToFloating Int Double #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int -> Exp Double #
ToFloating Int8 Double #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int8 -> Exp Double #
ToFloating Int16 Double #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int16 -> Exp Double #
ToFloating Int32 Double #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int32 -> Exp Double #
ToFloating Int64 Double #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int64 -> Exp Double #
ToFloating Word Double #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word -> Exp Double #
ToFloating Word8 Double #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word8 -> Exp Double #
ToFloating Word16 Double #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word16 -> Exp Double #
ToFloating Word32 Double #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word32 -> Exp Double #
ToFloating Word64 Double #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word64 -> Exp Double #
ToFloating CShort Double #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CShort -> Exp Double #
ToFloating CUShort Double #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CUShort -> Exp Double #
ToFloating CInt Double #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CInt -> Exp Double #
ToFloating CUInt Double #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CUInt -> Exp Double #
ToFloating CLong Double #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CLong -> Exp Double #
ToFloating CULong Double #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CULong -> Exp Double #
ToFloating CLLong Double #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CLLong -> Exp Double #
ToFloating CULLong Double #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CULLong -> Exp Double #
ToFloating CFloat Double #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CFloat -> Exp Double #
ToFloating CDouble Double #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CDouble -> Exp Double #
ToFloating Half Double #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Half -> Exp Double #
FromIntegral Int Double #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int -> Exp Double #
FromIntegral Int8 Double #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int8 -> Exp Double #
FromIntegral Int16 Double #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int16 -> Exp Double #
FromIntegral Int32 Double #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int32 -> Exp Double #
FromIntegral Int64 Double #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int64 -> Exp Double #
FromIntegral Word Double #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word -> Exp Double #
FromIntegral Word8 Double #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word8 -> Exp Double #
FromIntegral Word16 Double #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word16 -> Exp Double #
FromIntegral Word32 Double #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word32 -> Exp Double #
FromIntegral Word64 Double #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word64 -> Exp Double #
FromIntegral CShort Double #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CShort -> Exp Double #
FromIntegral CUShort Double #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUShort -> Exp Double #
FromIntegral CInt Double #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CInt -> Exp Double #
FromIntegral CUInt Double #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUInt -> Exp Double #
FromIntegral CLong Double #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLong -> Exp Double #
FromIntegral CULong Double #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULong -> Exp Double #
FromIntegral CLLong Double #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLLong -> Exp Double #
FromIntegral CULLong Double #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULLong -> Exp Double #
() :=> (Enum Double)
Instance details Defined in Data.Constraint Methods ins :: () :- Enum Double #
() :=> (Eq Double)
Instance details Defined in Data.Constraint Methods ins :: () :- Eq Double #
() :=> (Floating Double)
Instance details Defined in Data.Constraint Methods ins :: () :- Floating Double #
() :=> (Fractional Double)
Instance details Defined in Data.Constraint Methods ins :: () :- Fractional Double #
() :=> (Num Double)
Instance details Defined in Data.Constraint Methods ins :: () :- Num Double #
() :=> (Ord Double)
Instance details Defined in Data.Constraint Methods ins :: () :- Ord Double #
() :=> (Real Double)
Instance details Defined in Data.Constraint Methods ins :: () :- Real Double #
() :=> (RealFloat Double)
Instance details Defined in Data.Constraint Methods ins :: () :- RealFloat Double #
() :=> (RealFrac Double)
Instance details Defined in Data.Constraint Methods ins :: () :- RealFrac Double #
Generic1 (URec Double :: k -> Type)
Instance details Defined in GHC.Generics Associated Types type Rep1 (URec Double) :: k -> Type # Methods from1 :: URec Double a -> Rep1 (URec Double) a # to1 :: Rep1 (URec Double) a -> URec Double a #
Enum (Exp Double) #
Instance details Defined in Data.Array.Accelerate.Classes.Enum Methods succ :: Exp Double -> Exp Double # pred :: Exp Double -> Exp Double # toEnum :: Int -> Exp Double # fromEnum :: Exp Double -> Int # enumFrom :: Exp Double -> [Exp Double] # enumFromThen :: Exp Double -> Exp Double -> [Exp Double] # enumFromTo :: Exp Double -> Exp Double -> [Exp Double] # enumFromThenTo :: Exp Double -> Exp Double -> Exp Double -> [Exp Double] #
Floating (Exp Double) #
Instance details Defined in Data.Array.Accelerate.Classes.Floating Methods pi :: Exp Double # exp :: Exp Double -> Exp Double # log :: Exp Double -> Exp Double # sqrt :: Exp Double -> Exp Double # (**) :: Exp Double -> Exp Double -> Exp Double # logBase :: Exp Double -> Exp Double -> Exp Double # sin :: Exp Double -> Exp Double # cos :: Exp Double -> Exp Double # tan :: Exp Double -> Exp Double # asin :: Exp Double -> Exp Double # acos :: Exp Double -> Exp Double # atan :: Exp Double -> Exp Double # sinh :: Exp Double -> Exp Double # cosh :: Exp Double -> Exp Double # tanh :: Exp Double -> Exp Double # asinh :: Exp Double -> Exp Double # acosh :: Exp Double -> Exp Double # atanh :: Exp Double -> Exp Double # log1p :: Exp Double -> Exp Double # expm1 :: Exp Double -> Exp Double # log1pexp :: Exp Double -> Exp Double # log1mexp :: Exp Double -> Exp Double #
Fractional (Exp Double) #
Instance details Defined in Data.Array.Accelerate.Classes.Fractional Methods (/) :: Exp Double -> Exp Double -> Exp Double # recip :: Exp Double -> Exp Double # fromRational :: Rational -> Exp Double #
Num (Exp Double) #
Instance details Defined in Data.Array.Accelerate.Classes.Num Methods (+) :: Exp Double -> Exp Double -> Exp Double # (-) :: Exp Double -> Exp Double -> Exp Double # (*) :: Exp Double -> Exp Double -> Exp Double # negate :: Exp Double -> Exp Double # abs :: Exp Double -> Exp Double # signum :: Exp Double -> Exp Double # fromInteger :: Integer -> Exp Double #
Elt (Complex Double) #
Instance details Defined in Data.Array.Accelerate.Data.Complex Methods eltType :: Complex Double -> TupleType (EltRepr (Complex Double)) fromElt :: Complex Double -> EltRepr (Complex Double) toElt :: EltRepr (Complex Double) -> Complex Double
Functor (URec Double :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> URec Double a -> URec Double b # (<$) :: a -> URec Double b -> URec Double a #
Foldable (URec Double :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Foldable 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 :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable 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)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (==) :: URec Double p -> URec Double p -> Bool # (/=) :: URec Double p -> URec Double p -> Bool #
Ord (URec Double p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods compare :: URec Double p -> URec Double p -> Ordering # (<) :: URec Double p -> URec Double p -> Bool # (<=) :: URec Double p -> URec Double p -> Bool # (>) :: URec Double p -> URec Double p -> Bool # (>=) :: URec Double p -> URec Double p -> Bool # max :: URec Double p -> URec Double p -> URec Double p # min :: URec Double p -> URec Double p -> URec Double p #
Show (URec Double p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> URec Double p -> ShowS # show :: URec Double p -> String # showList :: [URec Double p] -> ShowS #
Generic (URec Double p)
Instance details Defined in GHC.Generics Associated Types type Rep (URec Double p) :: Type -> Type # Methods from :: URec Double p -> Rep (URec Double p) x # to :: Rep (URec Double p) x -> URec Double p #
type PrimSize Double
Instance details Defined in Basement.PrimType type PrimSize Double = 8
type Difference Double
Instance details Defined in Basement.Numerical.Subtractive type Difference Double = Double
newtype Vector Double
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Double = V_Double (Vector Double)
type Plain Double #
Instance details Defined in Data.Array.Accelerate.Lift type Plain Double = Double
data URec Double (p :: k)	Used for marking occurrences of `Double#` Since: base-4.9.0.0
Instance details Defined in GHC.Generics data URec Double (p :: k) = UDouble { uDouble# :: Double# }
newtype MVector s Double
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Double = MV_Double (MVector s Double)
type Rep1 (URec Double :: k -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics type Rep1 (URec Double :: k -> Type) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UDouble" PrefixI True) (S1 (MetaSel (Just "uDouble#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (UDouble :: k -> Type)))
type Rep (URec Double p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics type Rep (URec Double p) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UDouble" PrefixI True) (S1 (MetaSel (Just "uDouble#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (UDouble :: Type -> Type)))

data Bool #

Constructors

False
True

Instances

Bounded Bool	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: Bool # maxBound :: Bool #
Enum Bool	Since: base-2.1
Instance details Defined in GHC.Enum Methods succ :: Bool -> Bool # pred :: Bool -> Bool # toEnum :: Int -> Bool # fromEnum :: Bool -> Int # enumFrom :: Bool -> [Bool] # enumFromThen :: Bool -> Bool -> [Bool] # enumFromTo :: Bool -> Bool -> [Bool] # enumFromThenTo :: Bool -> Bool -> Bool -> [Bool] #
Eq Bool
Instance details Defined in GHC.Classes Methods (==) :: Bool -> Bool -> Bool # (/=) :: Bool -> Bool -> Bool #
Ord Bool
Instance details Defined in GHC.Classes Methods compare :: Bool -> Bool -> Ordering # (<) :: Bool -> Bool -> Bool # (<=) :: Bool -> Bool -> Bool # (>) :: Bool -> Bool -> Bool # (>=) :: Bool -> Bool -> Bool # max :: Bool -> Bool -> Bool # min :: Bool -> Bool -> Bool #
Read Bool	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Bool # readList :: ReadS [Bool] # readPrec :: ReadPrec Bool # readListPrec :: ReadPrec [Bool] #
Show Bool	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Bool -> ShowS # show :: Bool -> String # showList :: [Bool] -> ShowS #
Generic Bool
Instance details Defined in GHC.Generics Associated Types type Rep Bool :: Type -> Type # Methods from :: Bool -> Rep Bool x # to :: Rep Bool x -> Bool #
Lift Bool
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Bool -> Q Exp #
Pretty Bool
Instance details Defined in Text.PrettyPrint.ANSI.Leijen.Internal Methods pretty :: Bool -> Doc # prettyList :: [Bool] -> Doc #
SingKind Bool	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type DemoteRep Bool :: Type Methods fromSing :: Sing a -> DemoteRep Bool
Storable Bool	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Bool -> Int # alignment :: Bool -> Int # peekElemOff :: Ptr Bool -> Int -> IO Bool # pokeElemOff :: Ptr Bool -> Int -> Bool -> IO () # peekByteOff :: Ptr b -> Int -> IO Bool # pokeByteOff :: Ptr b -> Int -> Bool -> IO () # peek :: Ptr Bool -> IO Bool # poke :: Ptr Bool -> Bool -> IO () #
Bits Bool	Interpret `Bool` as 1-bit bit-field Since: base-4.7.0.0
Instance details Defined in Data.Bits Methods (.&.) :: Bool -> Bool -> Bool # (.\|.) :: Bool -> Bool -> Bool # xor :: Bool -> Bool -> Bool # complement :: Bool -> Bool # shift :: Bool -> Int -> Bool # rotate :: Bool -> Int -> Bool # zeroBits :: Bool # bit :: Int -> Bool # setBit :: Bool -> Int -> Bool # clearBit :: Bool -> Int -> Bool # complementBit :: Bool -> Int -> Bool # testBit :: Bool -> Int -> Bool # bitSizeMaybe :: Bool -> Maybe Int # bitSize :: Bool -> Int # isSigned :: Bool -> Bool # shiftL :: Bool -> Int -> Bool # unsafeShiftL :: Bool -> Int -> Bool # shiftR :: Bool -> Int -> Bool # unsafeShiftR :: Bool -> Int -> Bool # rotateL :: Bool -> Int -> Bool # rotateR :: Bool -> Int -> Bool # popCount :: Bool -> Int #
FiniteBits Bool	Since: base-4.7.0.0
Instance details Defined in Data.Bits Methods finiteBitSize :: Bool -> Int # countLeadingZeros :: Bool -> Int # countTrailingZeros :: Bool -> Int #
NFData Bool
Instance details Defined in Control.DeepSeq Methods rnf :: Bool -> () #
Hashable Bool
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Bool -> Int # hash :: Bool -> Int #
Unbox Bool
Instance details Defined in Data.Vector.Unboxed.Base
AssertionPredicable Bool
Instance details Defined in Test.Tasty.HUnit.Orig Methods assertionPredicate :: Bool -> IO Bool #
Assertable Bool
Instance details Defined in Test.Tasty.HUnit.Orig Methods assert :: Bool -> Assertion #
Pretty Bool
Instance details Defined in Text.PrettyPrint.Annotated.WL Methods pretty :: Bool -> Doc b # prettyList :: [Bool] -> Doc b #
IsScalar Bool #
Instance details Defined in Data.Array.Accelerate.Type Methods scalarType :: ScalarType Bool
IsBounded Bool #
Instance details Defined in Data.Array.Accelerate.Type Methods boundedType :: BoundedType Bool
IsNonNum Bool #
Instance details Defined in Data.Array.Accelerate.Type Methods nonNumType :: NonNumType Bool
Elt Bool #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods eltType :: Bool -> TupleType (EltRepr Bool) fromElt :: Bool -> EltRepr Bool toElt :: EltRepr Bool -> Bool
Eq Bool #
Instance details Defined in Data.Array.Accelerate.Classes.Eq Methods (==) :: Exp Bool -> Exp Bool -> Exp Bool # (/=) :: Exp Bool -> Exp Bool -> Exp Bool #
Ord Bool #
Instance details Defined in Data.Array.Accelerate.Classes.Ord 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 #
Instance details Defined in Data.Array.Accelerate.Data.Bits Methods finiteBitSize :: Exp Bool -> Exp Int # countLeadingZeros :: Exp Bool -> Exp Int # countTrailingZeros :: Exp Bool -> Exp Int #
Bits Bool #
Instance details Defined in Data.Array.Accelerate.Data.Bits Methods (.&.) :: Exp Bool -> Exp Bool -> Exp Bool # (.\|.) :: Exp Bool -> Exp Bool -> Exp Bool # xor :: Exp Bool -> Exp Bool -> Exp Bool # complement :: Exp Bool -> Exp Bool # shift :: Exp Bool -> Exp Int -> Exp Bool # rotate :: Exp Bool -> Exp Int -> Exp Bool # zeroBits :: Exp Bool # bit :: Exp Int -> Exp Bool # setBit :: Exp Bool -> Exp Int -> Exp Bool # clearBit :: Exp Bool -> Exp Int -> Exp Bool # complementBit :: Exp Bool -> Exp Int -> Exp Bool # testBit :: Exp Bool -> Exp Int -> Exp Bool # isSigned :: Exp Bool -> Exp Bool # shiftL :: Exp Bool -> Exp Int -> Exp Bool # unsafeShiftL :: Exp Bool -> Exp Int -> Exp Bool # shiftR :: Exp Bool -> Exp Int -> Exp Bool # unsafeShiftR :: Exp Bool -> Exp Int -> Exp Bool # rotateL :: Exp Bool -> Exp Int -> Exp Bool # rotateR :: Exp Bool -> Exp Int -> Exp Bool # popCount :: Exp Bool -> Exp Int #
SingI False	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods sing :: Sing False
SingI True	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods sing :: Sing True
Vector Vector Bool
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Bool -> m (Vector Bool) # basicUnsafeThaw :: PrimMonad m => Vector Bool -> m (Mutable Vector (PrimState m) Bool) # basicLength :: Vector Bool -> Int # basicUnsafeSlice :: Int -> Int -> Vector Bool -> Vector Bool # basicUnsafeIndexM :: Monad m => Vector Bool -> Int -> m Bool # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Bool -> Vector Bool -> m () # elemseq :: Vector Bool -> Bool -> b -> b #
MVector MVector Bool
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Bool -> Int # basicUnsafeSlice :: Int -> Int -> MVector s Bool -> MVector s Bool # basicOverlaps :: MVector s Bool -> MVector s Bool -> Bool # basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Bool) # basicInitialize :: PrimMonad m => MVector (PrimState m) Bool -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> Bool -> m (MVector (PrimState m) Bool) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Bool -> Int -> m Bool # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Bool -> Int -> Bool -> m () # basicClear :: PrimMonad m => MVector (PrimState m) Bool -> m () # basicSet :: PrimMonad m => MVector (PrimState m) Bool -> Bool -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Bool -> MVector (PrimState m) Bool -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Bool -> MVector (PrimState m) Bool -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Bool -> Int -> m (MVector (PrimState m) Bool) #
Lift Exp Bool #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain Bool :: Type # Methods lift :: Bool -> Exp (Plain Bool) #
() :=> (Bounded Bool)
Instance details Defined in Data.Constraint Methods ins :: () :- Bounded Bool #
() :=> (Enum Bool)
Instance details Defined in Data.Constraint Methods ins :: () :- Enum Bool #
() :=> (Eq Bool)
Instance details Defined in Data.Constraint Methods ins :: () :- Eq Bool #
() :=> (Ord Bool)
Instance details Defined in Data.Constraint Methods ins :: () :- Ord Bool #
() :=> (Read Bool)
Instance details Defined in Data.Constraint Methods ins :: () :- Read Bool #
() :=> (Show Bool)
Instance details Defined in Data.Constraint Methods ins :: () :- Show Bool #
() :=> (Bits Bool)
Instance details Defined in Data.Constraint Methods ins :: () :- Bits Bool #
Bounded (Exp Bool) #
Instance details Defined in Data.Array.Accelerate.Classes.Bounded Methods minBound :: Exp Bool # maxBound :: Exp Bool #
type Rep Bool	Since: base-4.6.0.0
Instance details Defined in GHC.Generics type Rep Bool = D1 (MetaData "Bool" "GHC.Types" "ghc-prim" False) (C1 (MetaCons "False" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "True" PrefixI False) (U1 :: Type -> Type))
data Sing (a :: Bool)
Instance details Defined in GHC.Generics data Sing (a :: Bool) where STrue :: forall (a :: Bool). Sing True SFalse :: forall (a :: Bool). Sing False
type DemoteRep Bool
Instance details Defined in GHC.Generics type DemoteRep Bool = Bool
newtype Vector Bool
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Bool = V_Bool (Vector Word8)
type Plain Bool #
Instance details Defined in Data.Array.Accelerate.Lift type Plain Bool = Bool
newtype MVector s Bool
Instance details Defined in Data.Vector.Unboxed.Base newtype 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: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: Char # maxBound :: Char #
Enum Char	Since: base-2.1
Instance details Defined in GHC.Enum Methods succ :: Char -> Char # pred :: Char -> Char # toEnum :: Int -> Char # fromEnum :: Char -> Int # enumFrom :: Char -> [Char] # enumFromThen :: Char -> Char -> [Char] # enumFromTo :: Char -> Char -> [Char] # enumFromThenTo :: Char -> Char -> Char -> [Char] #
Eq Char
Instance details Defined in GHC.Classes Methods (==) :: Char -> Char -> Bool # (/=) :: Char -> Char -> Bool #
Ord Char
Instance details Defined in GHC.Classes Methods compare :: Char -> Char -> Ordering # (<) :: Char -> Char -> Bool # (<=) :: Char -> Char -> Bool # (>) :: Char -> Char -> Bool # (>=) :: Char -> Char -> Bool # max :: Char -> Char -> Char # min :: Char -> Char -> Char #
Read Char	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Char # readList :: ReadS [Char] # readPrec :: ReadPrec Char # readListPrec :: ReadPrec [Char] #
Show Char	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Char -> ShowS # show :: Char -> String # showList :: [Char] -> ShowS #
Lift Char
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Char -> Q Exp #
Pretty Char
Instance details Defined in Text.PrettyPrint.ANSI.Leijen.Internal Methods pretty :: Char -> Doc # prettyList :: [Char] -> Doc #
PrintfArg Char	Since: base-2.1
Instance details Defined in Text.Printf Methods formatArg :: Char -> FieldFormatter # parseFormat :: Char -> ModifierParser #
IsChar Char	Since: base-2.1
Instance details Defined in Text.Printf Methods toChar :: Char -> Char # fromChar :: Char -> Char #
Storable Char	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Char -> Int # alignment :: Char -> Int # peekElemOff :: Ptr Char -> Int -> IO Char # pokeElemOff :: Ptr Char -> Int -> Char -> IO () # peekByteOff :: Ptr b -> Int -> IO Char # pokeByteOff :: Ptr b -> Int -> Char -> IO () # peek :: Ptr Char -> IO Char # poke :: Ptr Char -> Char -> IO () #
PrimType Char
Instance details Defined in Basement.PrimType Associated Types type PrimSize Char :: Nat # Methods primSizeInBytes :: Proxy Char -> CountOf Word8 # primShiftToBytes :: Proxy Char -> Int # primBaUIndex :: ByteArray# -> Offset Char -> Char # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Char -> prim Char # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Char -> Char -> prim () # primAddrIndex :: Addr# -> Offset Char -> Char # primAddrRead :: PrimMonad prim => Addr# -> Offset Char -> prim Char # primAddrWrite :: PrimMonad prim => Addr# -> Offset Char -> Char -> prim () #
PrimMemoryComparable Char
Instance details Defined in Basement.PrimType
Subtractive Char
Instance details Defined in Basement.Numerical.Subtractive Associated Types type Difference Char :: Type # Methods (-) :: Char -> Char -> Difference Char #
NFData Char
Instance details Defined in Control.DeepSeq Methods rnf :: Char -> () #
Hashable Char
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Char -> Int # hash :: Char -> Int #
Prim Char
Instance details Defined in Data.Primitive.Types Methods sizeOf# :: Char -> Int# # alignment# :: Char -> Int# # indexByteArray# :: ByteArray# -> Int# -> Char # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, Char#) # writeByteArray# :: MutableByteArray# s -> Int# -> Char -> State# s -> State# s # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Char -> State# s -> State# s # indexOffAddr# :: Addr# -> Int# -> Char # readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, Char#) # writeOffAddr# :: Addr# -> Int# -> Char -> State# s -> State# s # setOffAddr# :: Addr# -> Int# -> Int# -> Char -> State# s -> State# s #
Unbox Char
Instance details Defined in Data.Vector.Unboxed.Base
Assertable String
Instance details Defined in Test.Tasty.HUnit.Orig Methods assert :: String -> Assertion #
ErrorList Char
Instance details Defined in Control.Monad.Trans.Error Methods listMsg :: String -> [Char] #
Pretty Char
Instance details Defined in Text.PrettyPrint.Annotated.WL Methods pretty :: Char -> Doc b # prettyList :: [Char] -> Doc b #
IsScalar Char #
Instance details Defined in Data.Array.Accelerate.Type Methods scalarType :: ScalarType Char
IsBounded Char #
Instance details Defined in Data.Array.Accelerate.Type Methods boundedType :: BoundedType Char
IsNonNum Char #
Instance details Defined in Data.Array.Accelerate.Type Methods nonNumType :: NonNumType Char
Elt Char #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods eltType :: Char -> TupleType (EltRepr Char) fromElt :: Char -> EltRepr Char toElt :: EltRepr Char -> Char
Eq Char #
Instance details Defined in Data.Array.Accelerate.Classes.Eq Methods (==) :: Exp Char -> Exp Char -> Exp Bool # (/=) :: Exp Char -> Exp Char -> Exp Bool #
Ord Char #
Instance details Defined in Data.Array.Accelerate.Classes.Ord Methods (<) :: Exp Char -> Exp Char -> Exp Bool # (>) :: Exp Char -> Exp Char -> Exp Bool # (<=) :: Exp Char -> Exp Char -> Exp Bool # (>=) :: Exp Char -> Exp Char -> Exp Bool # min :: Exp Char -> Exp Char -> Exp Char # max :: Exp Char -> Exp Char -> Exp Char # compare :: Exp Char -> Exp Char -> Exp Ordering #
Vector Vector Char
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Char -> m (Vector Char) # basicUnsafeThaw :: PrimMonad m => Vector Char -> m (Mutable Vector (PrimState m) Char) # basicLength :: Vector Char -> Int # basicUnsafeSlice :: Int -> Int -> Vector Char -> Vector Char # basicUnsafeIndexM :: Monad m => Vector Char -> Int -> m Char # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Char -> Vector Char -> m () # elemseq :: Vector Char -> Char -> b -> b #
MVector MVector Char
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Char -> Int # basicUnsafeSlice :: Int -> Int -> MVector s Char -> MVector s Char # basicOverlaps :: MVector s Char -> MVector s Char -> Bool # basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Char) # basicInitialize :: PrimMonad m => MVector (PrimState m) Char -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> Char -> m (MVector (PrimState m) Char) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Char -> Int -> m Char # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Char -> Int -> Char -> m () # basicClear :: PrimMonad m => MVector (PrimState m) Char -> m () # basicSet :: PrimMonad m => MVector (PrimState m) Char -> Char -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Char -> MVector (PrimState m) Char -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Char -> MVector (PrimState m) Char -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Char -> Int -> m (MVector (PrimState m) Char) #
Lift Exp Char #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain Char :: Type # Methods lift :: Char -> Exp (Plain Char) #
KnownSymbol n => Reifies (n :: Symbol) String
Instance details Defined in Data.Reflection Methods reflect :: proxy n -> String #
Cons Text Text Char Char
Instance details Defined in Control.Lens.Cons Methods _Cons :: Prism Text Text (Char, Text) (Char, Text) #
Cons Text Text Char Char
Instance details Defined in Control.Lens.Cons Methods _Cons :: Prism Text Text (Char, Text) (Char, Text) #
Snoc Text Text Char Char
Instance details Defined in Control.Lens.Cons Methods _Snoc :: Prism Text Text (Text, Char) (Text, Char) #
Snoc Text Text Char Char
Instance details Defined in Control.Lens.Cons Methods _Snoc :: Prism Text Text (Text, Char) (Text, Char) #
() :=> (Bounded Char)
Instance details Defined in Data.Constraint Methods ins :: () :- Bounded Char #
() :=> (Enum Char)
Instance details Defined in Data.Constraint Methods ins :: () :- Enum Char #
() :=> (Ord Char)
Instance details Defined in Data.Constraint Methods ins :: () :- Ord Char #
() :=> (Read Char)
Instance details Defined in Data.Constraint Methods ins :: () :- Read Char #
() :=> (Show Char)
Instance details Defined in Data.Constraint Methods ins :: () :- Show Char #
Generic1 (URec Char :: k -> Type)
Instance details Defined in GHC.Generics Associated Types type Rep1 (URec Char) :: k -> Type # Methods from1 :: URec Char a -> Rep1 (URec Char) a # to1 :: Rep1 (URec Char) a -> URec Char a #
Bounded (Exp Char) #
Instance details Defined in Data.Array.Accelerate.Classes.Bounded Methods minBound :: Exp Char # maxBound :: Exp Char #
Functor (URec Char :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> URec Char a -> URec Char b # (<$) :: a -> URec Char b -> URec Char a #
Foldable (URec Char :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Foldable 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 :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable 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)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (==) :: URec Char p -> URec Char p -> Bool # (/=) :: URec Char p -> URec Char p -> Bool #
Ord (URec Char p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods compare :: URec Char p -> URec Char p -> Ordering # (<) :: URec Char p -> URec Char p -> Bool # (<=) :: URec Char p -> URec Char p -> Bool # (>) :: URec Char p -> URec Char p -> Bool # (>=) :: URec Char p -> URec Char p -> Bool # max :: URec Char p -> URec Char p -> URec Char p # min :: URec Char p -> URec Char p -> URec Char p #
Show (URec Char p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> URec Char p -> ShowS # show :: URec Char p -> String # showList :: [URec Char p] -> ShowS #
Generic (URec Char p)
Instance details Defined in GHC.Generics Associated Types type Rep (URec Char p) :: Type -> Type # Methods from :: URec Char p -> Rep (URec Char p) x # to :: Rep (URec Char p) x -> URec Char p #
type PrimSize Char
Instance details Defined in Basement.PrimType type PrimSize Char = 4
type Difference Char
Instance details Defined in Basement.Numerical.Subtractive type Difference Char = Int
type NatNumMaxBound Char
Instance details Defined in Basement.Nat type NatNumMaxBound Char = 1114111
newtype Vector Char
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Char = V_Char (Vector Char)
type Plain Char #
Instance details Defined in Data.Array.Accelerate.Lift type Plain Char = Char
data URec Char (p :: k)	Used for marking occurrences of `Char#` Since: base-4.9.0.0
Instance details Defined in GHC.Generics data URec Char (p :: k) = UChar { uChar# :: Char# }
newtype MVector s Char
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Char = MV_Char (MVector s Char)
type Rep1 (URec Char :: k -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics type Rep1 (URec Char :: k -> Type) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UChar" PrefixI True) (S1 (MetaSel (Just "uChar#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (UChar :: k -> Type)))
type Rep (URec Char p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics type Rep (URec Char p) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UChar" PrefixI True) (S1 (MetaSel (Just "uChar#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (UChar :: Type -> Type)))

data CFloat #

Haskell type representing the C float type.

Instances

Enum CFloat
Instance details Defined in Foreign.C.Types Methods succ :: CFloat -> CFloat # pred :: CFloat -> CFloat # toEnum :: Int -> CFloat # fromEnum :: CFloat -> Int # enumFrom :: CFloat -> [CFloat] # enumFromThen :: CFloat -> CFloat -> [CFloat] # enumFromTo :: CFloat -> CFloat -> [CFloat] # enumFromThenTo :: CFloat -> CFloat -> CFloat -> [CFloat] #
Eq CFloat
Instance details Defined in Foreign.C.Types Methods (==) :: CFloat -> CFloat -> Bool # (/=) :: CFloat -> CFloat -> Bool #
Floating CFloat
Instance details Defined in Foreign.C.Types Methods pi :: CFloat # exp :: CFloat -> CFloat # log :: CFloat -> CFloat # sqrt :: CFloat -> CFloat # (**) :: CFloat -> CFloat -> CFloat # logBase :: CFloat -> CFloat -> CFloat # sin :: CFloat -> CFloat # cos :: CFloat -> CFloat # tan :: CFloat -> CFloat # asin :: CFloat -> CFloat # acos :: CFloat -> CFloat # atan :: CFloat -> CFloat # sinh :: CFloat -> CFloat # cosh :: CFloat -> CFloat # tanh :: CFloat -> CFloat # asinh :: CFloat -> CFloat # acosh :: CFloat -> CFloat # atanh :: CFloat -> CFloat # log1p :: CFloat -> CFloat # expm1 :: CFloat -> CFloat # log1pexp :: CFloat -> CFloat # log1mexp :: CFloat -> CFloat #
Fractional CFloat
Instance details Defined in Foreign.C.Types Methods (/) :: CFloat -> CFloat -> CFloat # recip :: CFloat -> CFloat # fromRational :: Rational -> CFloat #
Num CFloat
Instance details Defined in Foreign.C.Types Methods (+) :: CFloat -> CFloat -> CFloat # (-) :: CFloat -> CFloat -> CFloat # (*) :: CFloat -> CFloat -> CFloat # negate :: CFloat -> CFloat # abs :: CFloat -> CFloat # signum :: CFloat -> CFloat # fromInteger :: Integer -> CFloat #
Ord CFloat
Instance details Defined in Foreign.C.Types Methods compare :: CFloat -> CFloat -> Ordering # (<) :: CFloat -> CFloat -> Bool # (<=) :: CFloat -> CFloat -> Bool # (>) :: CFloat -> CFloat -> Bool # (>=) :: CFloat -> CFloat -> Bool # max :: CFloat -> CFloat -> CFloat # min :: CFloat -> CFloat -> CFloat #
Read CFloat
Instance details Defined in Foreign.C.Types Methods readsPrec :: Int -> ReadS CFloat # readList :: ReadS [CFloat] # readPrec :: ReadPrec CFloat # readListPrec :: ReadPrec [CFloat] #
Real CFloat
Instance details Defined in Foreign.C.Types Methods toRational :: CFloat -> Rational #
RealFloat CFloat
Instance details Defined in Foreign.C.Types Methods floatRadix :: CFloat -> Integer # floatDigits :: CFloat -> Int # floatRange :: CFloat -> (Int, Int) # decodeFloat :: CFloat -> (Integer, Int) # encodeFloat :: Integer -> Int -> CFloat # exponent :: CFloat -> Int # significand :: CFloat -> CFloat # scaleFloat :: Int -> CFloat -> CFloat # isNaN :: CFloat -> Bool # isInfinite :: CFloat -> Bool # isDenormalized :: CFloat -> Bool # isNegativeZero :: CFloat -> Bool # isIEEE :: CFloat -> Bool # atan2 :: CFloat -> CFloat -> CFloat #
RealFrac CFloat
Instance details Defined in Foreign.C.Types Methods properFraction :: Integral b => CFloat -> (b, CFloat) # truncate :: Integral b => CFloat -> b # round :: Integral b => CFloat -> b # ceiling :: Integral b => CFloat -> b # floor :: Integral b => CFloat -> b #
Show CFloat
Instance details Defined in Foreign.C.Types Methods showsPrec :: Int -> CFloat -> ShowS # show :: CFloat -> String # showList :: [CFloat] -> ShowS #
Storable CFloat
Instance details Defined in Foreign.C.Types Methods sizeOf :: CFloat -> Int # alignment :: CFloat -> Int # peekElemOff :: Ptr CFloat -> Int -> IO CFloat # pokeElemOff :: Ptr CFloat -> Int -> CFloat -> IO () # peekByteOff :: Ptr b -> Int -> IO CFloat # pokeByteOff :: Ptr b -> Int -> CFloat -> IO () # peek :: Ptr CFloat -> IO CFloat # poke :: Ptr CFloat -> CFloat -> IO () #
Subtractive CFloat
Instance details Defined in Basement.Numerical.Subtractive Associated Types type Difference CFloat :: Type # Methods (-) :: CFloat -> CFloat -> Difference CFloat #
NFData CFloat	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: CFloat -> () #
Prim CFloat
Instance details Defined in Data.Primitive.Types Methods sizeOf# :: CFloat -> Int# # alignment# :: CFloat -> Int# # indexByteArray# :: ByteArray# -> Int# -> CFloat # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, CFloat#) # writeByteArray# :: MutableByteArray# s -> Int# -> CFloat -> State# s -> State# s # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> CFloat -> State# s -> State# s # indexOffAddr# :: Addr# -> Int# -> CFloat # readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, CFloat#) # writeOffAddr# :: Addr# -> Int# -> CFloat -> State# s -> State# s # setOffAddr# :: Addr# -> Int# -> Int# -> CFloat -> State# s -> State# s #
Wrapped CFloat
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped CFloat :: Type # Methods _Wrapped' :: Iso' CFloat (Unwrapped CFloat) #
IsScalar CFloat #
Instance details Defined in Data.Array.Accelerate.Type Methods scalarType :: ScalarType CFloat
IsNum CFloat #
Instance details Defined in Data.Array.Accelerate.Type Methods numType :: NumType CFloat
IsFloating CFloat #
Instance details Defined in Data.Array.Accelerate.Type Methods floatingType :: FloatingType CFloat
Elt CFloat #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods eltType :: CFloat -> TupleType (EltRepr CFloat) fromElt :: CFloat -> EltRepr CFloat toElt :: EltRepr CFloat -> CFloat
Eq CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.Eq Methods (==) :: Exp CFloat -> Exp CFloat -> Exp Bool # (/=) :: Exp CFloat -> Exp CFloat -> Exp Bool #
Ord CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.Ord Methods (<) :: Exp CFloat -> Exp CFloat -> Exp Bool # (>) :: Exp CFloat -> Exp CFloat -> Exp Bool # (<=) :: Exp CFloat -> Exp CFloat -> Exp Bool # (>=) :: Exp CFloat -> Exp CFloat -> Exp Bool # min :: Exp CFloat -> Exp CFloat -> Exp CFloat # max :: Exp CFloat -> Exp CFloat -> Exp CFloat # compare :: Exp CFloat -> Exp CFloat -> Exp Ordering #
RealFrac CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.RealFrac 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 #
Instance details Defined in Data.Array.Accelerate.Classes.RealFloat Methods floatRadix :: Exp CFloat -> Exp Int64 # floatDigits :: Exp CFloat -> Exp Int # floatRange :: Exp CFloat -> (Exp Int, Exp Int) # decodeFloat :: Exp CFloat -> (Exp Int64, Exp Int) # encodeFloat :: Exp Int64 -> Exp Int -> Exp CFloat # exponent :: Exp CFloat -> Exp Int # significand :: Exp CFloat -> Exp CFloat # scaleFloat :: Exp Int -> Exp CFloat -> Exp CFloat # isNaN :: Exp CFloat -> Exp Bool # isInfinite :: Exp CFloat -> Exp Bool # isDenormalized :: Exp CFloat -> Exp Bool # isNegativeZero :: Exp CFloat -> Exp Bool # isIEEE :: Exp CFloat -> Exp Bool # atan2 :: Exp CFloat -> Exp CFloat -> Exp CFloat #
Rewrapped CFloat t
Instance details Defined in Control.Lens.Wrapped
Lift Exp CFloat #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain CFloat :: Type # Methods lift :: CFloat -> Exp (Plain CFloat) #
ToFloating Double CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Double -> Exp CFloat #
ToFloating Float CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Float -> Exp CFloat #
ToFloating Int CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int -> Exp CFloat #
ToFloating Int8 CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int8 -> Exp CFloat #
ToFloating Int16 CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int16 -> Exp CFloat #
ToFloating Int32 CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int32 -> Exp CFloat #
ToFloating Int64 CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int64 -> Exp CFloat #
ToFloating Word CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word -> Exp CFloat #
ToFloating Word8 CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word8 -> Exp CFloat #
ToFloating Word16 CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word16 -> Exp CFloat #
ToFloating Word32 CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word32 -> Exp CFloat #
ToFloating Word64 CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word64 -> Exp CFloat #
ToFloating CShort CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CShort -> Exp CFloat #
ToFloating CUShort CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CUShort -> Exp CFloat #
ToFloating CInt CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CInt -> Exp CFloat #
ToFloating CUInt CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CUInt -> Exp CFloat #
ToFloating CLong CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CLong -> Exp CFloat #
ToFloating CULong CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CULong -> Exp CFloat #
ToFloating CLLong CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CLLong -> Exp CFloat #
ToFloating CULLong CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CULLong -> Exp CFloat #
ToFloating CFloat Double #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CFloat -> Exp Double #
ToFloating CFloat Float #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CFloat -> Exp Float #
ToFloating CFloat CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CFloat -> Exp CFloat #
ToFloating CFloat CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CFloat -> Exp CDouble #
ToFloating CFloat Half #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CFloat -> Exp Half #
ToFloating CDouble CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CDouble -> Exp CFloat #
ToFloating Half CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Half -> Exp CFloat #
FromIntegral Int CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int -> Exp CFloat #
FromIntegral Int8 CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int8 -> Exp CFloat #
FromIntegral Int16 CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int16 -> Exp CFloat #
FromIntegral Int32 CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int32 -> Exp CFloat #
FromIntegral Int64 CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int64 -> Exp CFloat #
FromIntegral Word CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word -> Exp CFloat #
FromIntegral Word8 CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word8 -> Exp CFloat #
FromIntegral Word16 CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word16 -> Exp CFloat #
FromIntegral Word32 CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word32 -> Exp CFloat #
FromIntegral Word64 CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word64 -> Exp CFloat #
FromIntegral CShort CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CShort -> Exp CFloat #
FromIntegral CUShort CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUShort -> Exp CFloat #
FromIntegral CInt CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CInt -> Exp CFloat #
FromIntegral CUInt CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUInt -> Exp CFloat #
FromIntegral CLong CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLong -> Exp CFloat #
FromIntegral CULong CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULong -> Exp CFloat #
FromIntegral CLLong CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLLong -> Exp CFloat #
FromIntegral CULLong CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULLong -> Exp CFloat #
Enum (Exp CFloat) #
Instance details Defined in Data.Array.Accelerate.Classes.Enum Methods succ :: Exp CFloat -> Exp CFloat # pred :: Exp CFloat -> Exp CFloat # toEnum :: Int -> Exp CFloat # fromEnum :: Exp CFloat -> Int # enumFrom :: Exp CFloat -> [Exp CFloat] # enumFromThen :: Exp CFloat -> Exp CFloat -> [Exp CFloat] # enumFromTo :: Exp CFloat -> Exp CFloat -> [Exp CFloat] # enumFromThenTo :: Exp CFloat -> Exp CFloat -> Exp CFloat -> [Exp CFloat] #
Floating (Exp CFloat) #
Instance details Defined in Data.Array.Accelerate.Classes.Floating Methods pi :: Exp CFloat # exp :: Exp CFloat -> Exp CFloat # log :: Exp CFloat -> Exp CFloat # sqrt :: Exp CFloat -> Exp CFloat # (**) :: Exp CFloat -> Exp CFloat -> Exp CFloat # logBase :: Exp CFloat -> Exp CFloat -> Exp CFloat # sin :: Exp CFloat -> Exp CFloat # cos :: Exp CFloat -> Exp CFloat # tan :: Exp CFloat -> Exp CFloat # asin :: Exp CFloat -> Exp CFloat # acos :: Exp CFloat -> Exp CFloat # atan :: Exp CFloat -> Exp CFloat # sinh :: Exp CFloat -> Exp CFloat # cosh :: Exp CFloat -> Exp CFloat # tanh :: Exp CFloat -> Exp CFloat # asinh :: Exp CFloat -> Exp CFloat # acosh :: Exp CFloat -> Exp CFloat # atanh :: Exp CFloat -> Exp CFloat # log1p :: Exp CFloat -> Exp CFloat # expm1 :: Exp CFloat -> Exp CFloat # log1pexp :: Exp CFloat -> Exp CFloat # log1mexp :: Exp CFloat -> Exp CFloat #
Fractional (Exp CFloat) #
Instance details Defined in Data.Array.Accelerate.Classes.Fractional Methods (/) :: Exp CFloat -> Exp CFloat -> Exp CFloat # recip :: Exp CFloat -> Exp CFloat # fromRational :: Rational -> Exp CFloat #
Num (Exp CFloat) #
Instance details Defined in Data.Array.Accelerate.Classes.Num Methods (+) :: Exp CFloat -> Exp CFloat -> Exp CFloat # (-) :: Exp CFloat -> Exp CFloat -> Exp CFloat # (*) :: Exp CFloat -> Exp CFloat -> Exp CFloat # negate :: Exp CFloat -> Exp CFloat # abs :: Exp CFloat -> Exp CFloat # signum :: Exp CFloat -> Exp CFloat # fromInteger :: Integer -> Exp CFloat #
Elt (Complex CFloat) #
Instance details Defined in Data.Array.Accelerate.Data.Complex Methods eltType :: Complex CFloat -> TupleType (EltRepr (Complex CFloat)) fromElt :: Complex CFloat -> EltRepr (Complex CFloat) toElt :: EltRepr (Complex CFloat) -> Complex CFloat
type Difference CFloat
Instance details Defined in Basement.Numerical.Subtractive type Difference CFloat = CFloat
type Unwrapped CFloat
Instance details Defined in Control.Lens.Wrapped type Unwrapped CFloat = Float
type Plain CFloat #
Instance details Defined in Data.Array.Accelerate.Lift type Plain CFloat = CFloat

data CDouble #

Haskell type representing the C double type.

Instances

Enum CDouble
Instance details Defined in Foreign.C.Types Methods succ :: CDouble -> CDouble # pred :: CDouble -> CDouble # toEnum :: Int -> CDouble # fromEnum :: CDouble -> Int # enumFrom :: CDouble -> [CDouble] # enumFromThen :: CDouble -> CDouble -> [CDouble] # enumFromTo :: CDouble -> CDouble -> [CDouble] # enumFromThenTo :: CDouble -> CDouble -> CDouble -> [CDouble] #
Eq CDouble
Instance details Defined in Foreign.C.Types Methods (==) :: CDouble -> CDouble -> Bool # (/=) :: CDouble -> CDouble -> Bool #
Floating CDouble
Instance details Defined in Foreign.C.Types Methods pi :: CDouble # exp :: CDouble -> CDouble # log :: CDouble -> CDouble # sqrt :: CDouble -> CDouble # (**) :: CDouble -> CDouble -> CDouble # logBase :: CDouble -> CDouble -> CDouble # sin :: CDouble -> CDouble # cos :: CDouble -> CDouble # tan :: CDouble -> CDouble # asin :: CDouble -> CDouble # acos :: CDouble -> CDouble # atan :: CDouble -> CDouble # sinh :: CDouble -> CDouble # cosh :: CDouble -> CDouble # tanh :: CDouble -> CDouble # asinh :: CDouble -> CDouble # acosh :: CDouble -> CDouble # atanh :: CDouble -> CDouble # log1p :: CDouble -> CDouble # expm1 :: CDouble -> CDouble # log1pexp :: CDouble -> CDouble # log1mexp :: CDouble -> CDouble #
Fractional CDouble
Instance details Defined in Foreign.C.Types Methods (/) :: CDouble -> CDouble -> CDouble # recip :: CDouble -> CDouble # fromRational :: Rational -> CDouble #
Num CDouble
Instance details Defined in Foreign.C.Types Methods (+) :: CDouble -> CDouble -> CDouble # (-) :: CDouble -> CDouble -> CDouble # (*) :: CDouble -> CDouble -> CDouble # negate :: CDouble -> CDouble # abs :: CDouble -> CDouble # signum :: CDouble -> CDouble # fromInteger :: Integer -> CDouble #
Ord CDouble
Instance details Defined in Foreign.C.Types Methods compare :: CDouble -> CDouble -> Ordering # (<) :: CDouble -> CDouble -> Bool # (<=) :: CDouble -> CDouble -> Bool # (>) :: CDouble -> CDouble -> Bool # (>=) :: CDouble -> CDouble -> Bool # max :: CDouble -> CDouble -> CDouble # min :: CDouble -> CDouble -> CDouble #
Read CDouble
Instance details Defined in Foreign.C.Types Methods readsPrec :: Int -> ReadS CDouble # readList :: ReadS [CDouble] # readPrec :: ReadPrec CDouble # readListPrec :: ReadPrec [CDouble] #
Real CDouble
Instance details Defined in Foreign.C.Types Methods toRational :: CDouble -> Rational #
RealFloat CDouble
Instance details Defined in Foreign.C.Types Methods floatRadix :: CDouble -> Integer # floatDigits :: CDouble -> Int # floatRange :: CDouble -> (Int, Int) # decodeFloat :: CDouble -> (Integer, Int) # encodeFloat :: Integer -> Int -> CDouble # exponent :: CDouble -> Int # significand :: CDouble -> CDouble # scaleFloat :: Int -> CDouble -> CDouble # isNaN :: CDouble -> Bool # isInfinite :: CDouble -> Bool # isDenormalized :: CDouble -> Bool # isNegativeZero :: CDouble -> Bool # isIEEE :: CDouble -> Bool # atan2 :: CDouble -> CDouble -> CDouble #
RealFrac CDouble
Instance details Defined in Foreign.C.Types Methods properFraction :: Integral b => CDouble -> (b, CDouble) # truncate :: Integral b => CDouble -> b # round :: Integral b => CDouble -> b # ceiling :: Integral b => CDouble -> b # floor :: Integral b => CDouble -> b #
Show CDouble
Instance details Defined in Foreign.C.Types Methods showsPrec :: Int -> CDouble -> ShowS # show :: CDouble -> String # showList :: [CDouble] -> ShowS #
Storable CDouble
Instance details Defined in Foreign.C.Types Methods sizeOf :: CDouble -> Int # alignment :: CDouble -> Int # peekElemOff :: Ptr CDouble -> Int -> IO CDouble # pokeElemOff :: Ptr CDouble -> Int -> CDouble -> IO () # peekByteOff :: Ptr b -> Int -> IO CDouble # pokeByteOff :: Ptr b -> Int -> CDouble -> IO () # peek :: Ptr CDouble -> IO CDouble # poke :: Ptr CDouble -> CDouble -> IO () #
Subtractive CDouble
Instance details Defined in Basement.Numerical.Subtractive Associated Types type Difference CDouble :: Type # Methods (-) :: CDouble -> CDouble -> Difference CDouble #
NFData CDouble	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: CDouble -> () #
Prim CDouble
Instance details Defined in Data.Primitive.Types Methods sizeOf# :: CDouble -> Int# # alignment# :: CDouble -> Int# # indexByteArray# :: ByteArray# -> Int# -> CDouble # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, CDouble#) # writeByteArray# :: MutableByteArray# s -> Int# -> CDouble -> State# s -> State# s # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> CDouble -> State# s -> State# s # indexOffAddr# :: Addr# -> Int# -> CDouble # readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, CDouble#) # writeOffAddr# :: Addr# -> Int# -> CDouble -> State# s -> State# s # setOffAddr# :: Addr# -> Int# -> Int# -> CDouble -> State# s -> State# s #
Wrapped CDouble
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped CDouble :: Type # Methods _Wrapped' :: Iso' CDouble (Unwrapped CDouble) #
IsScalar CDouble #
Instance details Defined in Data.Array.Accelerate.Type Methods scalarType :: ScalarType CDouble
IsNum CDouble #
Instance details Defined in Data.Array.Accelerate.Type Methods numType :: NumType CDouble
IsFloating CDouble #
Instance details Defined in Data.Array.Accelerate.Type Methods floatingType :: FloatingType CDouble
Elt CDouble #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods eltType :: CDouble -> TupleType (EltRepr CDouble) fromElt :: CDouble -> EltRepr CDouble toElt :: EltRepr CDouble -> CDouble
Eq CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.Eq Methods (==) :: Exp CDouble -> Exp CDouble -> Exp Bool # (/=) :: Exp CDouble -> Exp CDouble -> Exp Bool #
Ord CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.Ord Methods (<) :: Exp CDouble -> Exp CDouble -> Exp Bool # (>) :: Exp CDouble -> Exp CDouble -> Exp Bool # (<=) :: Exp CDouble -> Exp CDouble -> Exp Bool # (>=) :: Exp CDouble -> Exp CDouble -> Exp Bool # min :: Exp CDouble -> Exp CDouble -> Exp CDouble # max :: Exp CDouble -> Exp CDouble -> Exp CDouble # compare :: Exp CDouble -> Exp CDouble -> Exp Ordering #
RealFrac CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.RealFrac 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 #
Instance details Defined in Data.Array.Accelerate.Classes.RealFloat Methods floatRadix :: Exp CDouble -> Exp Int64 # floatDigits :: Exp CDouble -> Exp Int # floatRange :: Exp CDouble -> (Exp Int, Exp Int) # decodeFloat :: Exp CDouble -> (Exp Int64, Exp Int) # encodeFloat :: Exp Int64 -> Exp Int -> Exp CDouble # exponent :: Exp CDouble -> Exp Int # significand :: Exp CDouble -> Exp CDouble # scaleFloat :: Exp Int -> Exp CDouble -> Exp CDouble # isNaN :: Exp CDouble -> Exp Bool # isInfinite :: Exp CDouble -> Exp Bool # isDenormalized :: Exp CDouble -> Exp Bool # isNegativeZero :: Exp CDouble -> Exp Bool # isIEEE :: Exp CDouble -> Exp Bool # atan2 :: Exp CDouble -> Exp CDouble -> Exp CDouble #
Rewrapped CDouble t
Instance details Defined in Control.Lens.Wrapped
Lift Exp CDouble #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain CDouble :: Type # Methods lift :: CDouble -> Exp (Plain CDouble) #
ToFloating Double CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Double -> Exp CDouble #
ToFloating Float CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Float -> Exp CDouble #
ToFloating Int CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int -> Exp CDouble #
ToFloating Int8 CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int8 -> Exp CDouble #
ToFloating Int16 CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int16 -> Exp CDouble #
ToFloating Int32 CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int32 -> Exp CDouble #
ToFloating Int64 CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Int64 -> Exp CDouble #
ToFloating Word CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word -> Exp CDouble #
ToFloating Word8 CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word8 -> Exp CDouble #
ToFloating Word16 CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word16 -> Exp CDouble #
ToFloating Word32 CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word32 -> Exp CDouble #
ToFloating Word64 CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Word64 -> Exp CDouble #
ToFloating CShort CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CShort -> Exp CDouble #
ToFloating CUShort CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CUShort -> Exp CDouble #
ToFloating CInt CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CInt -> Exp CDouble #
ToFloating CUInt CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CUInt -> Exp CDouble #
ToFloating CLong CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CLong -> Exp CDouble #
ToFloating CULong CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CULong -> Exp CDouble #
ToFloating CLLong CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CLLong -> Exp CDouble #
ToFloating CULLong CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CULLong -> Exp CDouble #
ToFloating CFloat CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CFloat -> Exp CDouble #
ToFloating CDouble Double #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CDouble -> Exp Double #
ToFloating CDouble Float #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CDouble -> Exp Float #
ToFloating CDouble CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CDouble -> Exp CFloat #
ToFloating CDouble CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CDouble -> Exp CDouble #
ToFloating CDouble Half #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CDouble -> Exp Half #
ToFloating Half CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp Half -> Exp CDouble #
FromIntegral Int CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int -> Exp CDouble #
FromIntegral Int8 CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int8 -> Exp CDouble #
FromIntegral Int16 CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int16 -> Exp CDouble #
FromIntegral Int32 CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int32 -> Exp CDouble #
FromIntegral Int64 CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int64 -> Exp CDouble #
FromIntegral Word CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word -> Exp CDouble #
FromIntegral Word8 CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word8 -> Exp CDouble #
FromIntegral Word16 CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word16 -> Exp CDouble #
FromIntegral Word32 CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word32 -> Exp CDouble #
FromIntegral Word64 CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word64 -> Exp CDouble #
FromIntegral CShort CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CShort -> Exp CDouble #
FromIntegral CUShort CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUShort -> Exp CDouble #
FromIntegral CInt CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CInt -> Exp CDouble #
FromIntegral CUInt CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUInt -> Exp CDouble #
FromIntegral CLong CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLong -> Exp CDouble #
FromIntegral CULong CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULong -> Exp CDouble #
FromIntegral CLLong CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLLong -> Exp CDouble #
FromIntegral CULLong CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULLong -> Exp CDouble #
Enum (Exp CDouble) #
Instance details Defined in Data.Array.Accelerate.Classes.Enum Methods succ :: Exp CDouble -> Exp CDouble # pred :: Exp CDouble -> Exp CDouble # toEnum :: Int -> Exp CDouble # fromEnum :: Exp CDouble -> Int # enumFrom :: Exp CDouble -> [Exp CDouble] # enumFromThen :: Exp CDouble -> Exp CDouble -> [Exp CDouble] # enumFromTo :: Exp CDouble -> Exp CDouble -> [Exp CDouble] # enumFromThenTo :: Exp CDouble -> Exp CDouble -> Exp CDouble -> [Exp CDouble] #
Floating (Exp CDouble) #
Instance details Defined in Data.Array.Accelerate.Classes.Floating Methods pi :: Exp CDouble # exp :: Exp CDouble -> Exp CDouble # log :: Exp CDouble -> Exp CDouble # sqrt :: Exp CDouble -> Exp CDouble # (**) :: Exp CDouble -> Exp CDouble -> Exp CDouble # logBase :: Exp CDouble -> Exp CDouble -> Exp CDouble # sin :: Exp CDouble -> Exp CDouble # cos :: Exp CDouble -> Exp CDouble # tan :: Exp CDouble -> Exp CDouble # asin :: Exp CDouble -> Exp CDouble # acos :: Exp CDouble -> Exp CDouble # atan :: Exp CDouble -> Exp CDouble # sinh :: Exp CDouble -> Exp CDouble # cosh :: Exp CDouble -> Exp CDouble # tanh :: Exp CDouble -> Exp CDouble # asinh :: Exp CDouble -> Exp CDouble # acosh :: Exp CDouble -> Exp CDouble # atanh :: Exp CDouble -> Exp CDouble # log1p :: Exp CDouble -> Exp CDouble # expm1 :: Exp CDouble -> Exp CDouble # log1pexp :: Exp CDouble -> Exp CDouble # log1mexp :: Exp CDouble -> Exp CDouble #
Fractional (Exp CDouble) #
Instance details Defined in Data.Array.Accelerate.Classes.Fractional Methods (/) :: Exp CDouble -> Exp CDouble -> Exp CDouble # recip :: Exp CDouble -> Exp CDouble # fromRational :: Rational -> Exp CDouble #
Num (Exp CDouble) #
Instance details Defined in Data.Array.Accelerate.Classes.Num Methods (+) :: Exp CDouble -> Exp CDouble -> Exp CDouble # (-) :: Exp CDouble -> Exp CDouble -> Exp CDouble # (*) :: Exp CDouble -> Exp CDouble -> Exp CDouble # negate :: Exp CDouble -> Exp CDouble # abs :: Exp CDouble -> Exp CDouble # signum :: Exp CDouble -> Exp CDouble # fromInteger :: Integer -> Exp CDouble #
Elt (Complex CDouble) #
Instance details Defined in Data.Array.Accelerate.Data.Complex Methods eltType :: Complex CDouble -> TupleType (EltRepr (Complex CDouble)) fromElt :: Complex CDouble -> EltRepr (Complex CDouble) toElt :: EltRepr (Complex CDouble) -> Complex CDouble
type Difference CDouble
Instance details Defined in Basement.Numerical.Subtractive type Difference CDouble = CDouble
type Unwrapped CDouble
Instance details Defined in Control.Lens.Wrapped type Unwrapped CDouble = Double
type Plain CDouble #
Instance details Defined in Data.Array.Accelerate.Lift type Plain CDouble = CDouble

data CShort #

Haskell type representing the C short type.

Instances

Bounded CShort
Instance details Defined in Foreign.C.Types Methods minBound :: CShort # maxBound :: CShort #
Enum CShort
Instance details Defined in Foreign.C.Types Methods succ :: CShort -> CShort # pred :: CShort -> CShort # toEnum :: Int -> CShort # fromEnum :: CShort -> Int # enumFrom :: CShort -> [CShort] # enumFromThen :: CShort -> CShort -> [CShort] # enumFromTo :: CShort -> CShort -> [CShort] # enumFromThenTo :: CShort -> CShort -> CShort -> [CShort] #
Eq CShort
Instance details Defined in Foreign.C.Types Methods (==) :: CShort -> CShort -> Bool # (/=) :: CShort -> CShort -> Bool #
Integral CShort
Instance details Defined in Foreign.C.Types Methods quot :: CShort -> CShort -> CShort # rem :: CShort -> CShort -> CShort # div :: CShort -> CShort -> CShort # mod :: CShort -> CShort -> CShort # quotRem :: CShort -> CShort -> (CShort, CShort) # divMod :: CShort -> CShort -> (CShort, CShort) # toInteger :: CShort -> Integer #
Num CShort
Instance details Defined in Foreign.C.Types Methods (+) :: CShort -> CShort -> CShort # (-) :: CShort -> CShort -> CShort # (*) :: CShort -> CShort -> CShort # negate :: CShort -> CShort # abs :: CShort -> CShort # signum :: CShort -> CShort # fromInteger :: Integer -> CShort #
Ord CShort
Instance details Defined in Foreign.C.Types Methods compare :: CShort -> CShort -> Ordering # (<) :: CShort -> CShort -> Bool # (<=) :: CShort -> CShort -> Bool # (>) :: CShort -> CShort -> Bool # (>=) :: CShort -> CShort -> Bool # max :: CShort -> CShort -> CShort # min :: CShort -> CShort -> CShort #
Read CShort
Instance details Defined in Foreign.C.Types Methods readsPrec :: Int -> ReadS CShort # readList :: ReadS [CShort] # readPrec :: ReadPrec CShort # readListPrec :: ReadPrec [CShort] #
Real CShort
Instance details Defined in Foreign.C.Types Methods toRational :: CShort -> Rational #
Show CShort
Instance details Defined in Foreign.C.Types Methods showsPrec :: Int -> CShort -> ShowS # show :: CShort -> String # showList :: [CShort] -> ShowS #
Storable CShort
Instance details Defined in Foreign.C.Types Methods sizeOf :: CShort -> Int # alignment :: CShort -> Int # peekElemOff :: Ptr CShort -> Int -> IO CShort # pokeElemOff :: Ptr CShort -> Int -> CShort -> IO () # peekByteOff :: Ptr b -> Int -> IO CShort # pokeByteOff :: Ptr b -> Int -> CShort -> IO () # peek :: Ptr CShort -> IO CShort # poke :: Ptr CShort -> CShort -> IO () #
Bits CShort
Instance details Defined in Foreign.C.Types Methods (.&.) :: CShort -> CShort -> CShort # (.\|.) :: CShort -> CShort -> CShort # xor :: CShort -> CShort -> CShort # complement :: CShort -> CShort # shift :: CShort -> Int -> CShort # rotate :: CShort -> Int -> CShort # zeroBits :: CShort # bit :: Int -> CShort # setBit :: CShort -> Int -> CShort # clearBit :: CShort -> Int -> CShort # complementBit :: CShort -> Int -> CShort # testBit :: CShort -> Int -> Bool # bitSizeMaybe :: CShort -> Maybe Int # bitSize :: CShort -> Int # isSigned :: CShort -> Bool # shiftL :: CShort -> Int -> CShort # unsafeShiftL :: CShort -> Int -> CShort # shiftR :: CShort -> Int -> CShort # unsafeShiftR :: CShort -> Int -> CShort # rotateL :: CShort -> Int -> CShort # rotateR :: CShort -> Int -> CShort # popCount :: CShort -> Int #
FiniteBits CShort
Instance details Defined in Foreign.C.Types Methods finiteBitSize :: CShort -> Int # countLeadingZeros :: CShort -> Int # countTrailingZeros :: CShort -> Int #
Subtractive CShort
Instance details Defined in Basement.Numerical.Subtractive Associated Types type Difference CShort :: Type # Methods (-) :: CShort -> CShort -> Difference CShort #
NFData CShort	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: CShort -> () #
Prim CShort
Instance details Defined in Data.Primitive.Types Methods sizeOf# :: CShort -> Int# # alignment# :: CShort -> Int# # indexByteArray# :: ByteArray# -> Int# -> CShort # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, CShort#) # writeByteArray# :: MutableByteArray# s -> Int# -> CShort -> State# s -> State# s # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> CShort -> State# s -> State# s # indexOffAddr# :: Addr# -> Int# -> CShort # readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, CShort#) # writeOffAddr# :: Addr# -> Int# -> CShort -> State# s -> State# s # setOffAddr# :: Addr# -> Int# -> Int# -> CShort -> State# s -> State# s #
Wrapped CShort
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped CShort :: Type # Methods _Wrapped' :: Iso' CShort (Unwrapped CShort) #
IsScalar CShort #
Instance details Defined in Data.Array.Accelerate.Type Methods scalarType :: ScalarType CShort
IsBounded CShort #
Instance details Defined in Data.Array.Accelerate.Type Methods boundedType :: BoundedType CShort
IsNum CShort #
Instance details Defined in Data.Array.Accelerate.Type Methods numType :: NumType CShort
IsIntegral CShort #
Instance details Defined in Data.Array.Accelerate.Type Methods integralType :: IntegralType CShort
Elt CShort #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods eltType :: CShort -> TupleType (EltRepr CShort) fromElt :: CShort -> EltRepr CShort toElt :: EltRepr CShort -> CShort
Eq CShort #
Instance details Defined in Data.Array.Accelerate.Classes.Eq Methods (==) :: Exp CShort -> Exp CShort -> Exp Bool # (/=) :: Exp CShort -> Exp CShort -> Exp Bool #
Ord CShort #
Instance details Defined in Data.Array.Accelerate.Classes.Ord Methods (<) :: Exp CShort -> Exp CShort -> Exp Bool # (>) :: Exp CShort -> Exp CShort -> Exp Bool # (<=) :: Exp CShort -> Exp CShort -> Exp Bool # (>=) :: Exp CShort -> Exp CShort -> Exp Bool # min :: Exp CShort -> Exp CShort -> Exp CShort # max :: Exp CShort -> Exp CShort -> Exp CShort # compare :: Exp CShort -> Exp CShort -> Exp Ordering #
FiniteBits CShort #
Instance details Defined in Data.Array.Accelerate.Data.Bits Methods finiteBitSize :: Exp CShort -> Exp Int # countLeadingZeros :: Exp CShort -> Exp Int # countTrailingZeros :: Exp CShort -> Exp Int #
Bits CShort #
Instance details Defined in Data.Array.Accelerate.Data.Bits Methods (.&.) :: Exp CShort -> Exp CShort -> Exp CShort # (.\|.) :: Exp CShort -> Exp CShort -> Exp CShort # xor :: Exp CShort -> Exp CShort -> Exp CShort # complement :: Exp CShort -> Exp CShort # shift :: Exp CShort -> Exp Int -> Exp CShort # rotate :: Exp CShort -> Exp Int -> Exp CShort # zeroBits :: Exp CShort # bit :: Exp Int -> Exp CShort # setBit :: Exp CShort -> Exp Int -> Exp CShort # clearBit :: Exp CShort -> Exp Int -> Exp CShort # complementBit :: Exp CShort -> Exp Int -> Exp CShort # testBit :: Exp CShort -> Exp Int -> Exp Bool # isSigned :: Exp CShort -> Exp Bool # shiftL :: Exp CShort -> Exp Int -> Exp CShort # unsafeShiftL :: Exp CShort -> Exp Int -> Exp CShort # shiftR :: Exp CShort -> Exp Int -> Exp CShort # unsafeShiftR :: Exp CShort -> Exp Int -> Exp CShort # rotateL :: Exp CShort -> Exp Int -> Exp CShort # rotateR :: Exp CShort -> Exp Int -> Exp CShort # popCount :: Exp CShort -> Exp Int #
Rewrapped CShort t
Instance details Defined in Control.Lens.Wrapped
Lift Exp CShort #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain CShort :: Type # Methods lift :: CShort -> Exp (Plain CShort) #
ToFloating CShort Double #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CShort -> Exp Double #
ToFloating CShort Float #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CShort -> Exp Float #
ToFloating CShort CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CShort -> Exp CFloat #
ToFloating CShort CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CShort -> Exp CDouble #
ToFloating CShort Half #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CShort -> Exp Half #
FromIntegral Int CShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int -> Exp CShort #
FromIntegral Int8 CShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int8 -> Exp CShort #
FromIntegral Int16 CShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int16 -> Exp CShort #
FromIntegral Int32 CShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int32 -> Exp CShort #
FromIntegral Int64 CShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int64 -> Exp CShort #
FromIntegral Word CShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word -> Exp CShort #
FromIntegral Word8 CShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word8 -> Exp CShort #
FromIntegral Word16 CShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word16 -> Exp CShort #
FromIntegral Word32 CShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word32 -> Exp CShort #
FromIntegral Word64 CShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word64 -> Exp CShort #
FromIntegral CShort Double #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CShort -> Exp Double #
FromIntegral CShort Float #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CShort -> Exp Float #
FromIntegral CShort Int #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CShort -> Exp Int #
FromIntegral CShort Int8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CShort -> Exp Int8 #
FromIntegral CShort Int16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CShort -> Exp Int16 #
FromIntegral CShort Int32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CShort -> Exp Int32 #
FromIntegral CShort Int64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CShort -> Exp Int64 #
FromIntegral CShort Word #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CShort -> Exp Word #
FromIntegral CShort Word8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CShort -> Exp Word8 #
FromIntegral CShort Word16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CShort -> Exp Word16 #
FromIntegral CShort Word32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CShort -> Exp Word32 #
FromIntegral CShort Word64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CShort -> Exp Word64 #
FromIntegral CShort CShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CShort -> Exp CShort #
FromIntegral CShort CUShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CShort -> Exp CUShort #
FromIntegral CShort CInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CShort -> Exp CInt #
FromIntegral CShort CUInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CShort -> Exp CUInt #
FromIntegral CShort CLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CShort -> Exp CLong #
FromIntegral CShort CULong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CShort -> Exp CULong #
FromIntegral CShort CLLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CShort -> Exp CLLong #
FromIntegral CShort CULLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CShort -> Exp CULLong #
FromIntegral CShort CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CShort -> Exp CFloat #
FromIntegral CShort CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CShort -> Exp CDouble #
FromIntegral CShort Half #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CShort -> Exp Half #
FromIntegral CUShort CShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUShort -> Exp CShort #
FromIntegral CInt CShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CInt -> Exp CShort #
FromIntegral CUInt CShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUInt -> Exp CShort #
FromIntegral CLong CShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLong -> Exp CShort #
FromIntegral CULong CShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULong -> Exp CShort #
FromIntegral CLLong CShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLLong -> Exp CShort #
FromIntegral CULLong CShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULLong -> Exp CShort #
Bounded (Exp CShort) #
Instance details Defined in Data.Array.Accelerate.Classes.Bounded Methods minBound :: Exp CShort # maxBound :: Exp CShort #
Enum (Exp CShort) #
Instance details Defined in Data.Array.Accelerate.Classes.Enum Methods succ :: Exp CShort -> Exp CShort # pred :: Exp CShort -> Exp CShort # toEnum :: Int -> Exp CShort # fromEnum :: Exp CShort -> Int # enumFrom :: Exp CShort -> [Exp CShort] # enumFromThen :: Exp CShort -> Exp CShort -> [Exp CShort] # enumFromTo :: Exp CShort -> Exp CShort -> [Exp CShort] # enumFromThenTo :: Exp CShort -> Exp CShort -> Exp CShort -> [Exp CShort] #
Integral (Exp CShort) #
Instance details Defined in Data.Array.Accelerate.Classes.Integral Methods quot :: Exp CShort -> Exp CShort -> Exp CShort # rem :: Exp CShort -> Exp CShort -> Exp CShort # div :: Exp CShort -> Exp CShort -> Exp CShort # mod :: Exp CShort -> Exp CShort -> Exp CShort # quotRem :: Exp CShort -> Exp CShort -> (Exp CShort, Exp CShort) # divMod :: Exp CShort -> Exp CShort -> (Exp CShort, Exp CShort) # toInteger :: Exp CShort -> Integer #
Num (Exp CShort) #
Instance details Defined in Data.Array.Accelerate.Classes.Num Methods (+) :: Exp CShort -> Exp CShort -> Exp CShort # (-) :: Exp CShort -> Exp CShort -> Exp CShort # (*) :: Exp CShort -> Exp CShort -> Exp CShort # negate :: Exp CShort -> Exp CShort # abs :: Exp CShort -> Exp CShort # signum :: Exp CShort -> Exp CShort # fromInteger :: Integer -> Exp CShort #
type Difference CShort
Instance details Defined in Basement.Numerical.Subtractive type Difference CShort = CShort
type Unwrapped CShort
Instance details Defined in Control.Lens.Wrapped type Unwrapped CShort = Int16
type Plain CShort #
Instance details Defined in Data.Array.Accelerate.Lift type Plain CShort = CShort

data CUShort #

Haskell type representing the C unsigned short type.

Instances

Bounded CUShort
Instance details Defined in Foreign.C.Types Methods minBound :: CUShort # maxBound :: CUShort #
Enum CUShort
Instance details Defined in Foreign.C.Types Methods succ :: CUShort -> CUShort # pred :: CUShort -> CUShort # toEnum :: Int -> CUShort # fromEnum :: CUShort -> Int # enumFrom :: CUShort -> [CUShort] # enumFromThen :: CUShort -> CUShort -> [CUShort] # enumFromTo :: CUShort -> CUShort -> [CUShort] # enumFromThenTo :: CUShort -> CUShort -> CUShort -> [CUShort] #
Eq CUShort
Instance details Defined in Foreign.C.Types Methods (==) :: CUShort -> CUShort -> Bool # (/=) :: CUShort -> CUShort -> Bool #
Integral CUShort
Instance details Defined in Foreign.C.Types Methods quot :: CUShort -> CUShort -> CUShort # rem :: CUShort -> CUShort -> CUShort # div :: CUShort -> CUShort -> CUShort # mod :: CUShort -> CUShort -> CUShort # quotRem :: CUShort -> CUShort -> (CUShort, CUShort) # divMod :: CUShort -> CUShort -> (CUShort, CUShort) # toInteger :: CUShort -> Integer #
Num CUShort
Instance details Defined in Foreign.C.Types Methods (+) :: CUShort -> CUShort -> CUShort # (-) :: CUShort -> CUShort -> CUShort # (*) :: CUShort -> CUShort -> CUShort # negate :: CUShort -> CUShort # abs :: CUShort -> CUShort # signum :: CUShort -> CUShort # fromInteger :: Integer -> CUShort #
Ord CUShort
Instance details Defined in Foreign.C.Types Methods compare :: CUShort -> CUShort -> Ordering # (<) :: CUShort -> CUShort -> Bool # (<=) :: CUShort -> CUShort -> Bool # (>) :: CUShort -> CUShort -> Bool # (>=) :: CUShort -> CUShort -> Bool # max :: CUShort -> CUShort -> CUShort # min :: CUShort -> CUShort -> CUShort #
Read CUShort
Instance details Defined in Foreign.C.Types Methods readsPrec :: Int -> ReadS CUShort # readList :: ReadS [CUShort] # readPrec :: ReadPrec CUShort # readListPrec :: ReadPrec [CUShort] #
Real CUShort
Instance details Defined in Foreign.C.Types Methods toRational :: CUShort -> Rational #
Show CUShort
Instance details Defined in Foreign.C.Types Methods showsPrec :: Int -> CUShort -> ShowS # show :: CUShort -> String # showList :: [CUShort] -> ShowS #
Storable CUShort
Instance details Defined in Foreign.C.Types Methods sizeOf :: CUShort -> Int # alignment :: CUShort -> Int # peekElemOff :: Ptr CUShort -> Int -> IO CUShort # pokeElemOff :: Ptr CUShort -> Int -> CUShort -> IO () # peekByteOff :: Ptr b -> Int -> IO CUShort # pokeByteOff :: Ptr b -> Int -> CUShort -> IO () # peek :: Ptr CUShort -> IO CUShort # poke :: Ptr CUShort -> CUShort -> IO () #
Bits CUShort
Instance details Defined in Foreign.C.Types Methods (.&.) :: CUShort -> CUShort -> CUShort # (.\|.) :: CUShort -> CUShort -> CUShort # xor :: CUShort -> CUShort -> CUShort # complement :: CUShort -> CUShort # shift :: CUShort -> Int -> CUShort # rotate :: CUShort -> Int -> CUShort # zeroBits :: CUShort # bit :: Int -> CUShort # setBit :: CUShort -> Int -> CUShort # clearBit :: CUShort -> Int -> CUShort # complementBit :: CUShort -> Int -> CUShort # testBit :: CUShort -> Int -> Bool # bitSizeMaybe :: CUShort -> Maybe Int # bitSize :: CUShort -> Int # isSigned :: CUShort -> Bool # shiftL :: CUShort -> Int -> CUShort # unsafeShiftL :: CUShort -> Int -> CUShort # shiftR :: CUShort -> Int -> CUShort # unsafeShiftR :: CUShort -> Int -> CUShort # rotateL :: CUShort -> Int -> CUShort # rotateR :: CUShort -> Int -> CUShort # popCount :: CUShort -> Int #
FiniteBits CUShort
Instance details Defined in Foreign.C.Types Methods finiteBitSize :: CUShort -> Int # countLeadingZeros :: CUShort -> Int # countTrailingZeros :: CUShort -> Int #
Subtractive CUShort
Instance details Defined in Basement.Numerical.Subtractive Associated Types type Difference CUShort :: Type # Methods (-) :: CUShort -> CUShort -> Difference CUShort #
NFData CUShort	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: CUShort -> () #
Prim CUShort
Instance details Defined in Data.Primitive.Types Methods sizeOf# :: CUShort -> Int# # alignment# :: CUShort -> Int# # indexByteArray# :: ByteArray# -> Int# -> CUShort # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, CUShort#) # writeByteArray# :: MutableByteArray# s -> Int# -> CUShort -> State# s -> State# s # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> CUShort -> State# s -> State# s # indexOffAddr# :: Addr# -> Int# -> CUShort # readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, CUShort#) # writeOffAddr# :: Addr# -> Int# -> CUShort -> State# s -> State# s # setOffAddr# :: Addr# -> Int# -> Int# -> CUShort -> State# s -> State# s #
Wrapped CUShort
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped CUShort :: Type # Methods _Wrapped' :: Iso' CUShort (Unwrapped CUShort) #
IsScalar CUShort #
Instance details Defined in Data.Array.Accelerate.Type Methods scalarType :: ScalarType CUShort
IsBounded CUShort #
Instance details Defined in Data.Array.Accelerate.Type Methods boundedType :: BoundedType CUShort
IsNum CUShort #
Instance details Defined in Data.Array.Accelerate.Type Methods numType :: NumType CUShort
IsIntegral CUShort #
Instance details Defined in Data.Array.Accelerate.Type Methods integralType :: IntegralType CUShort
Elt CUShort #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods eltType :: CUShort -> TupleType (EltRepr CUShort) fromElt :: CUShort -> EltRepr CUShort toElt :: EltRepr CUShort -> CUShort
Eq CUShort #
Instance details Defined in Data.Array.Accelerate.Classes.Eq Methods (==) :: Exp CUShort -> Exp CUShort -> Exp Bool # (/=) :: Exp CUShort -> Exp CUShort -> Exp Bool #
Ord CUShort #
Instance details Defined in Data.Array.Accelerate.Classes.Ord Methods (<) :: Exp CUShort -> Exp CUShort -> Exp Bool # (>) :: Exp CUShort -> Exp CUShort -> Exp Bool # (<=) :: Exp CUShort -> Exp CUShort -> Exp Bool # (>=) :: Exp CUShort -> Exp CUShort -> Exp Bool # min :: Exp CUShort -> Exp CUShort -> Exp CUShort # max :: Exp CUShort -> Exp CUShort -> Exp CUShort # compare :: Exp CUShort -> Exp CUShort -> Exp Ordering #
FiniteBits CUShort #
Instance details Defined in Data.Array.Accelerate.Data.Bits Methods finiteBitSize :: Exp CUShort -> Exp Int # countLeadingZeros :: Exp CUShort -> Exp Int # countTrailingZeros :: Exp CUShort -> Exp Int #
Bits CUShort #
Instance details Defined in Data.Array.Accelerate.Data.Bits Methods (.&.) :: Exp CUShort -> Exp CUShort -> Exp CUShort # (.\|.) :: Exp CUShort -> Exp CUShort -> Exp CUShort # xor :: Exp CUShort -> Exp CUShort -> Exp CUShort # complement :: Exp CUShort -> Exp CUShort # shift :: Exp CUShort -> Exp Int -> Exp CUShort # rotate :: Exp CUShort -> Exp Int -> Exp CUShort # zeroBits :: Exp CUShort # bit :: Exp Int -> Exp CUShort # setBit :: Exp CUShort -> Exp Int -> Exp CUShort # clearBit :: Exp CUShort -> Exp Int -> Exp CUShort # complementBit :: Exp CUShort -> Exp Int -> Exp CUShort # testBit :: Exp CUShort -> Exp Int -> Exp Bool # isSigned :: Exp CUShort -> Exp Bool # shiftL :: Exp CUShort -> Exp Int -> Exp CUShort # unsafeShiftL :: Exp CUShort -> Exp Int -> Exp CUShort # shiftR :: Exp CUShort -> Exp Int -> Exp CUShort # unsafeShiftR :: Exp CUShort -> Exp Int -> Exp CUShort # rotateL :: Exp CUShort -> Exp Int -> Exp CUShort # rotateR :: Exp CUShort -> Exp Int -> Exp CUShort # popCount :: Exp CUShort -> Exp Int #
Rewrapped CUShort t
Instance details Defined in Control.Lens.Wrapped
Lift Exp CUShort #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain CUShort :: Type # Methods lift :: CUShort -> Exp (Plain CUShort) #
ToFloating CUShort Double #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CUShort -> Exp Double #
ToFloating CUShort Float #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CUShort -> Exp Float #
ToFloating CUShort CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CUShort -> Exp CFloat #
ToFloating CUShort CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CUShort -> Exp CDouble #
ToFloating CUShort Half #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CUShort -> Exp Half #
FromIntegral Int CUShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int -> Exp CUShort #
FromIntegral Int8 CUShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int8 -> Exp CUShort #
FromIntegral Int16 CUShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int16 -> Exp CUShort #
FromIntegral Int32 CUShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int32 -> Exp CUShort #
FromIntegral Int64 CUShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int64 -> Exp CUShort #
FromIntegral Word CUShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word -> Exp CUShort #
FromIntegral Word8 CUShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word8 -> Exp CUShort #
FromIntegral Word16 CUShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word16 -> Exp CUShort #
FromIntegral Word32 CUShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word32 -> Exp CUShort #
FromIntegral Word64 CUShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word64 -> Exp CUShort #
FromIntegral CShort CUShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CShort -> Exp CUShort #
FromIntegral CUShort Double #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUShort -> Exp Double #
FromIntegral CUShort Float #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUShort -> Exp Float #
FromIntegral CUShort Int #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUShort -> Exp Int #
FromIntegral CUShort Int8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUShort -> Exp Int8 #
FromIntegral CUShort Int16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUShort -> Exp Int16 #
FromIntegral CUShort Int32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUShort -> Exp Int32 #
FromIntegral CUShort Int64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUShort -> Exp Int64 #
FromIntegral CUShort Word #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUShort -> Exp Word #
FromIntegral CUShort Word8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUShort -> Exp Word8 #
FromIntegral CUShort Word16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUShort -> Exp Word16 #
FromIntegral CUShort Word32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUShort -> Exp Word32 #
FromIntegral CUShort Word64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUShort -> Exp Word64 #
FromIntegral CUShort CShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUShort -> Exp CShort #
FromIntegral CUShort CUShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUShort -> Exp CUShort #
FromIntegral CUShort CInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUShort -> Exp CInt #
FromIntegral CUShort CUInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUShort -> Exp CUInt #
FromIntegral CUShort CLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUShort -> Exp CLong #
FromIntegral CUShort CULong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUShort -> Exp CULong #
FromIntegral CUShort CLLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUShort -> Exp CLLong #
FromIntegral CUShort CULLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUShort -> Exp CULLong #
FromIntegral CUShort CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUShort -> Exp CFloat #
FromIntegral CUShort CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUShort -> Exp CDouble #
FromIntegral CUShort Half #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUShort -> Exp Half #
FromIntegral CInt CUShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CInt -> Exp CUShort #
FromIntegral CUInt CUShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUInt -> Exp CUShort #
FromIntegral CLong CUShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLong -> Exp CUShort #
FromIntegral CULong CUShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULong -> Exp CUShort #
FromIntegral CLLong CUShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLLong -> Exp CUShort #
FromIntegral CULLong CUShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULLong -> Exp CUShort #
Bounded (Exp CUShort) #
Instance details Defined in Data.Array.Accelerate.Classes.Bounded Methods minBound :: Exp CUShort # maxBound :: Exp CUShort #
Enum (Exp CUShort) #
Instance details Defined in Data.Array.Accelerate.Classes.Enum Methods succ :: Exp CUShort -> Exp CUShort # pred :: Exp CUShort -> Exp CUShort # toEnum :: Int -> Exp CUShort # fromEnum :: Exp CUShort -> Int # enumFrom :: Exp CUShort -> [Exp CUShort] # enumFromThen :: Exp CUShort -> Exp CUShort -> [Exp CUShort] # enumFromTo :: Exp CUShort -> Exp CUShort -> [Exp CUShort] # enumFromThenTo :: Exp CUShort -> Exp CUShort -> Exp CUShort -> [Exp CUShort] #
Integral (Exp CUShort) #
Instance details Defined in Data.Array.Accelerate.Classes.Integral Methods quot :: Exp CUShort -> Exp CUShort -> Exp CUShort # rem :: Exp CUShort -> Exp CUShort -> Exp CUShort # div :: Exp CUShort -> Exp CUShort -> Exp CUShort # mod :: Exp CUShort -> Exp CUShort -> Exp CUShort # quotRem :: Exp CUShort -> Exp CUShort -> (Exp CUShort, Exp CUShort) # divMod :: Exp CUShort -> Exp CUShort -> (Exp CUShort, Exp CUShort) # toInteger :: Exp CUShort -> Integer #
Num (Exp CUShort) #
Instance details Defined in Data.Array.Accelerate.Classes.Num Methods (+) :: Exp CUShort -> Exp CUShort -> Exp CUShort # (-) :: Exp CUShort -> Exp CUShort -> Exp CUShort # (*) :: Exp CUShort -> Exp CUShort -> Exp CUShort # negate :: Exp CUShort -> Exp CUShort # abs :: Exp CUShort -> Exp CUShort # signum :: Exp CUShort -> Exp CUShort # fromInteger :: Integer -> Exp CUShort #
type Difference CUShort
Instance details Defined in Basement.Numerical.Subtractive type Difference CUShort = CUShort
type Unwrapped CUShort
Instance details Defined in Control.Lens.Wrapped type Unwrapped CUShort = Word16
type Plain CUShort #
Instance details Defined in Data.Array.Accelerate.Lift type Plain CUShort = CUShort

data CInt #

Haskell type representing the C int type.

Instances

Bounded CInt
Instance details Defined in Foreign.C.Types Methods minBound :: CInt # maxBound :: CInt #
Enum CInt
Instance details Defined in Foreign.C.Types Methods succ :: CInt -> CInt # pred :: CInt -> CInt # toEnum :: Int -> CInt # fromEnum :: CInt -> Int # enumFrom :: CInt -> [CInt] # enumFromThen :: CInt -> CInt -> [CInt] # enumFromTo :: CInt -> CInt -> [CInt] # enumFromThenTo :: CInt -> CInt -> CInt -> [CInt] #
Eq CInt
Instance details Defined in Foreign.C.Types Methods (==) :: CInt -> CInt -> Bool # (/=) :: CInt -> CInt -> Bool #
Integral CInt
Instance details Defined in Foreign.C.Types Methods quot :: CInt -> CInt -> CInt # rem :: CInt -> CInt -> CInt # div :: CInt -> CInt -> CInt # mod :: CInt -> CInt -> CInt # quotRem :: CInt -> CInt -> (CInt, CInt) # divMod :: CInt -> CInt -> (CInt, CInt) # toInteger :: CInt -> Integer #
Num CInt
Instance details Defined in Foreign.C.Types Methods (+) :: CInt -> CInt -> CInt # (-) :: CInt -> CInt -> CInt # (*) :: CInt -> CInt -> CInt # negate :: CInt -> CInt # abs :: CInt -> CInt # signum :: CInt -> CInt # fromInteger :: Integer -> CInt #
Ord CInt
Instance details Defined in Foreign.C.Types Methods compare :: CInt -> CInt -> Ordering # (<) :: CInt -> CInt -> Bool # (<=) :: CInt -> CInt -> Bool # (>) :: CInt -> CInt -> Bool # (>=) :: CInt -> CInt -> Bool # max :: CInt -> CInt -> CInt # min :: CInt -> CInt -> CInt #
Read CInt
Instance details Defined in Foreign.C.Types Methods readsPrec :: Int -> ReadS CInt # readList :: ReadS [CInt] # readPrec :: ReadPrec CInt # readListPrec :: ReadPrec [CInt] #
Real CInt
Instance details Defined in Foreign.C.Types Methods toRational :: CInt -> Rational #
Show CInt
Instance details Defined in Foreign.C.Types Methods showsPrec :: Int -> CInt -> ShowS # show :: CInt -> String # showList :: [CInt] -> ShowS #
Storable CInt
Instance details Defined in Foreign.C.Types Methods sizeOf :: CInt -> Int # alignment :: CInt -> Int # peekElemOff :: Ptr CInt -> Int -> IO CInt # pokeElemOff :: Ptr CInt -> Int -> CInt -> IO () # peekByteOff :: Ptr b -> Int -> IO CInt # pokeByteOff :: Ptr b -> Int -> CInt -> IO () # peek :: Ptr CInt -> IO CInt # poke :: Ptr CInt -> CInt -> IO () #
Bits CInt
Instance details Defined in Foreign.C.Types Methods (.&.) :: CInt -> CInt -> CInt # (.\|.) :: CInt -> CInt -> CInt # xor :: CInt -> CInt -> CInt # complement :: CInt -> CInt # shift :: CInt -> Int -> CInt # rotate :: CInt -> Int -> CInt # zeroBits :: CInt # bit :: Int -> CInt # setBit :: CInt -> Int -> CInt # clearBit :: CInt -> Int -> CInt # complementBit :: CInt -> Int -> CInt # testBit :: CInt -> Int -> Bool # bitSizeMaybe :: CInt -> Maybe Int # bitSize :: CInt -> Int # isSigned :: CInt -> Bool # shiftL :: CInt -> Int -> CInt # unsafeShiftL :: CInt -> Int -> CInt # shiftR :: CInt -> Int -> CInt # unsafeShiftR :: CInt -> Int -> CInt # rotateL :: CInt -> Int -> CInt # rotateR :: CInt -> Int -> CInt # popCount :: CInt -> Int #
FiniteBits CInt
Instance details Defined in Foreign.C.Types Methods finiteBitSize :: CInt -> Int # countLeadingZeros :: CInt -> Int # countTrailingZeros :: CInt -> Int #
Subtractive CInt
Instance details Defined in Basement.Numerical.Subtractive Associated Types type Difference CInt :: Type # Methods (-) :: CInt -> CInt -> Difference CInt #
NFData CInt	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: CInt -> () #
Prim CInt
Instance details Defined in Data.Primitive.Types Methods sizeOf# :: CInt -> Int# # alignment# :: CInt -> Int# # indexByteArray# :: ByteArray# -> Int# -> CInt # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, CInt#) # writeByteArray# :: MutableByteArray# s -> Int# -> CInt -> State# s -> State# s # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> CInt -> State# s -> State# s # indexOffAddr# :: Addr# -> Int# -> CInt # readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, CInt#) # writeOffAddr# :: Addr# -> Int# -> CInt -> State# s -> State# s # setOffAddr# :: Addr# -> Int# -> Int# -> CInt -> State# s -> State# s #
Wrapped CInt
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped CInt :: Type # Methods _Wrapped' :: Iso' CInt (Unwrapped CInt) #
IsScalar CInt #
Instance details Defined in Data.Array.Accelerate.Type Methods scalarType :: ScalarType CInt
IsBounded CInt #
Instance details Defined in Data.Array.Accelerate.Type Methods boundedType :: BoundedType CInt
IsNum CInt #
Instance details Defined in Data.Array.Accelerate.Type Methods numType :: NumType CInt
IsIntegral CInt #
Instance details Defined in Data.Array.Accelerate.Type Methods integralType :: IntegralType CInt
Elt CInt #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods eltType :: CInt -> TupleType (EltRepr CInt) fromElt :: CInt -> EltRepr CInt toElt :: EltRepr CInt -> CInt
Eq CInt #
Instance details Defined in Data.Array.Accelerate.Classes.Eq Methods (==) :: Exp CInt -> Exp CInt -> Exp Bool # (/=) :: Exp CInt -> Exp CInt -> Exp Bool #
Ord CInt #
Instance details Defined in Data.Array.Accelerate.Classes.Ord Methods (<) :: Exp CInt -> Exp CInt -> Exp Bool # (>) :: Exp CInt -> Exp CInt -> Exp Bool # (<=) :: Exp CInt -> Exp CInt -> Exp Bool # (>=) :: Exp CInt -> Exp CInt -> Exp Bool # min :: Exp CInt -> Exp CInt -> Exp CInt # max :: Exp CInt -> Exp CInt -> Exp CInt # compare :: Exp CInt -> Exp CInt -> Exp Ordering #
FiniteBits CInt #
Instance details Defined in Data.Array.Accelerate.Data.Bits Methods finiteBitSize :: Exp CInt -> Exp Int # countLeadingZeros :: Exp CInt -> Exp Int # countTrailingZeros :: Exp CInt -> Exp Int #
Bits CInt #
Instance details Defined in Data.Array.Accelerate.Data.Bits Methods (.&.) :: Exp CInt -> Exp CInt -> Exp CInt # (.\|.) :: Exp CInt -> Exp CInt -> Exp CInt # xor :: Exp CInt -> Exp CInt -> Exp CInt # complement :: Exp CInt -> Exp CInt # shift :: Exp CInt -> Exp Int -> Exp CInt # rotate :: Exp CInt -> Exp Int -> Exp CInt # zeroBits :: Exp CInt # bit :: Exp Int -> Exp CInt # setBit :: Exp CInt -> Exp Int -> Exp CInt # clearBit :: Exp CInt -> Exp Int -> Exp CInt # complementBit :: Exp CInt -> Exp Int -> Exp CInt # testBit :: Exp CInt -> Exp Int -> Exp Bool # isSigned :: Exp CInt -> Exp Bool # shiftL :: Exp CInt -> Exp Int -> Exp CInt # unsafeShiftL :: Exp CInt -> Exp Int -> Exp CInt # shiftR :: Exp CInt -> Exp Int -> Exp CInt # unsafeShiftR :: Exp CInt -> Exp Int -> Exp CInt # rotateL :: Exp CInt -> Exp Int -> Exp CInt # rotateR :: Exp CInt -> Exp Int -> Exp CInt # popCount :: Exp CInt -> Exp Int #
Rewrapped CInt t
Instance details Defined in Control.Lens.Wrapped
Lift Exp CInt #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain CInt :: Type # Methods lift :: CInt -> Exp (Plain CInt) #
ToFloating CInt Double #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CInt -> Exp Double #
ToFloating CInt Float #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CInt -> Exp Float #
ToFloating CInt CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CInt -> Exp CFloat #
ToFloating CInt CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CInt -> Exp CDouble #
ToFloating CInt Half #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CInt -> Exp Half #
FromIntegral Int CInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int -> Exp CInt #
FromIntegral Int8 CInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int8 -> Exp CInt #
FromIntegral Int16 CInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int16 -> Exp CInt #
FromIntegral Int32 CInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int32 -> Exp CInt #
FromIntegral Int64 CInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int64 -> Exp CInt #
FromIntegral Word CInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word -> Exp CInt #
FromIntegral Word8 CInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word8 -> Exp CInt #
FromIntegral Word16 CInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word16 -> Exp CInt #
FromIntegral Word32 CInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word32 -> Exp CInt #
FromIntegral Word64 CInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word64 -> Exp CInt #
FromIntegral CShort CInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CShort -> Exp CInt #
FromIntegral CUShort CInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUShort -> Exp CInt #
FromIntegral CInt Double #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CInt -> Exp Double #
FromIntegral CInt Float #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CInt -> Exp Float #
FromIntegral CInt Int #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CInt -> Exp Int #
FromIntegral CInt Int8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CInt -> Exp Int8 #
FromIntegral CInt Int16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CInt -> Exp Int16 #
FromIntegral CInt Int32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CInt -> Exp Int32 #
FromIntegral CInt Int64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CInt -> Exp Int64 #
FromIntegral CInt Word #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CInt -> Exp Word #
FromIntegral CInt Word8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CInt -> Exp Word8 #
FromIntegral CInt Word16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CInt -> Exp Word16 #
FromIntegral CInt Word32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CInt -> Exp Word32 #
FromIntegral CInt Word64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CInt -> Exp Word64 #
FromIntegral CInt CShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CInt -> Exp CShort #
FromIntegral CInt CUShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CInt -> Exp CUShort #
FromIntegral CInt CInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CInt -> Exp CInt #
FromIntegral CInt CUInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CInt -> Exp CUInt #
FromIntegral CInt CLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CInt -> Exp CLong #
FromIntegral CInt CULong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CInt -> Exp CULong #
FromIntegral CInt CLLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CInt -> Exp CLLong #
FromIntegral CInt CULLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CInt -> Exp CULLong #
FromIntegral CInt CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CInt -> Exp CFloat #
FromIntegral CInt CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CInt -> Exp CDouble #
FromIntegral CInt Half #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CInt -> Exp Half #
FromIntegral CUInt CInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUInt -> Exp CInt #
FromIntegral CLong CInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLong -> Exp CInt #
FromIntegral CULong CInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULong -> Exp CInt #
FromIntegral CLLong CInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLLong -> Exp CInt #
FromIntegral CULLong CInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULLong -> Exp CInt #
Bounded (Exp CInt) #
Instance details Defined in Data.Array.Accelerate.Classes.Bounded Methods minBound :: Exp CInt # maxBound :: Exp CInt #
Enum (Exp CInt) #
Instance details Defined in Data.Array.Accelerate.Classes.Enum Methods succ :: Exp CInt -> Exp CInt # pred :: Exp CInt -> Exp CInt # toEnum :: Int -> Exp CInt # fromEnum :: Exp CInt -> Int # enumFrom :: Exp CInt -> [Exp CInt] # enumFromThen :: Exp CInt -> Exp CInt -> [Exp CInt] # enumFromTo :: Exp CInt -> Exp CInt -> [Exp CInt] # enumFromThenTo :: Exp CInt -> Exp CInt -> Exp CInt -> [Exp CInt] #
Integral (Exp CInt) #
Instance details Defined in Data.Array.Accelerate.Classes.Integral Methods quot :: Exp CInt -> Exp CInt -> Exp CInt # rem :: Exp CInt -> Exp CInt -> Exp CInt # div :: Exp CInt -> Exp CInt -> Exp CInt # mod :: Exp CInt -> Exp CInt -> Exp CInt # quotRem :: Exp CInt -> Exp CInt -> (Exp CInt, Exp CInt) # divMod :: Exp CInt -> Exp CInt -> (Exp CInt, Exp CInt) # toInteger :: Exp CInt -> Integer #
Num (Exp CInt) #
Instance details Defined in Data.Array.Accelerate.Classes.Num Methods (+) :: Exp CInt -> Exp CInt -> Exp CInt # (-) :: Exp CInt -> Exp CInt -> Exp CInt # (*) :: Exp CInt -> Exp CInt -> Exp CInt # negate :: Exp CInt -> Exp CInt # abs :: Exp CInt -> Exp CInt # signum :: Exp CInt -> Exp CInt # fromInteger :: Integer -> Exp CInt #
type Difference CInt
Instance details Defined in Basement.Numerical.Subtractive type Difference CInt = CInt
type Unwrapped CInt
Instance details Defined in Control.Lens.Wrapped type Unwrapped CInt = Int32
type Plain CInt #
Instance details Defined in Data.Array.Accelerate.Lift type Plain CInt = CInt

data CUInt #

Haskell type representing the C unsigned int type.

Instances

Bounded CUInt
Instance details Defined in Foreign.C.Types Methods minBound :: CUInt # maxBound :: CUInt #
Enum CUInt
Instance details Defined in Foreign.C.Types Methods succ :: CUInt -> CUInt # pred :: CUInt -> CUInt # toEnum :: Int -> CUInt # fromEnum :: CUInt -> Int # enumFrom :: CUInt -> [CUInt] # enumFromThen :: CUInt -> CUInt -> [CUInt] # enumFromTo :: CUInt -> CUInt -> [CUInt] # enumFromThenTo :: CUInt -> CUInt -> CUInt -> [CUInt] #
Eq CUInt
Instance details Defined in Foreign.C.Types Methods (==) :: CUInt -> CUInt -> Bool # (/=) :: CUInt -> CUInt -> Bool #
Integral CUInt
Instance details Defined in Foreign.C.Types Methods quot :: CUInt -> CUInt -> CUInt # rem :: CUInt -> CUInt -> CUInt # div :: CUInt -> CUInt -> CUInt # mod :: CUInt -> CUInt -> CUInt # quotRem :: CUInt -> CUInt -> (CUInt, CUInt) # divMod :: CUInt -> CUInt -> (CUInt, CUInt) # toInteger :: CUInt -> Integer #
Num CUInt
Instance details Defined in Foreign.C.Types Methods (+) :: CUInt -> CUInt -> CUInt # (-) :: CUInt -> CUInt -> CUInt # (*) :: CUInt -> CUInt -> CUInt # negate :: CUInt -> CUInt # abs :: CUInt -> CUInt # signum :: CUInt -> CUInt # fromInteger :: Integer -> CUInt #
Ord CUInt
Instance details Defined in Foreign.C.Types Methods compare :: CUInt -> CUInt -> Ordering # (<) :: CUInt -> CUInt -> Bool # (<=) :: CUInt -> CUInt -> Bool # (>) :: CUInt -> CUInt -> Bool # (>=) :: CUInt -> CUInt -> Bool # max :: CUInt -> CUInt -> CUInt # min :: CUInt -> CUInt -> CUInt #
Read CUInt
Instance details Defined in Foreign.C.Types Methods readsPrec :: Int -> ReadS CUInt # readList :: ReadS [CUInt] # readPrec :: ReadPrec CUInt # readListPrec :: ReadPrec [CUInt] #
Real CUInt
Instance details Defined in Foreign.C.Types Methods toRational :: CUInt -> Rational #
Show CUInt
Instance details Defined in Foreign.C.Types Methods showsPrec :: Int -> CUInt -> ShowS # show :: CUInt -> String # showList :: [CUInt] -> ShowS #
Storable CUInt
Instance details Defined in Foreign.C.Types Methods sizeOf :: CUInt -> Int # alignment :: CUInt -> Int # peekElemOff :: Ptr CUInt -> Int -> IO CUInt # pokeElemOff :: Ptr CUInt -> Int -> CUInt -> IO () # peekByteOff :: Ptr b -> Int -> IO CUInt # pokeByteOff :: Ptr b -> Int -> CUInt -> IO () # peek :: Ptr CUInt -> IO CUInt # poke :: Ptr CUInt -> CUInt -> IO () #
Bits CUInt
Instance details Defined in Foreign.C.Types Methods (.&.) :: CUInt -> CUInt -> CUInt # (.\|.) :: CUInt -> CUInt -> CUInt # xor :: CUInt -> CUInt -> CUInt # complement :: CUInt -> CUInt # shift :: CUInt -> Int -> CUInt # rotate :: CUInt -> Int -> CUInt # zeroBits :: CUInt # bit :: Int -> CUInt # setBit :: CUInt -> Int -> CUInt # clearBit :: CUInt -> Int -> CUInt # complementBit :: CUInt -> Int -> CUInt # testBit :: CUInt -> Int -> Bool # bitSizeMaybe :: CUInt -> Maybe Int # bitSize :: CUInt -> Int # isSigned :: CUInt -> Bool # shiftL :: CUInt -> Int -> CUInt # unsafeShiftL :: CUInt -> Int -> CUInt # shiftR :: CUInt -> Int -> CUInt # unsafeShiftR :: CUInt -> Int -> CUInt # rotateL :: CUInt -> Int -> CUInt # rotateR :: CUInt -> Int -> CUInt # popCount :: CUInt -> Int #
FiniteBits CUInt
Instance details Defined in Foreign.C.Types Methods finiteBitSize :: CUInt -> Int # countLeadingZeros :: CUInt -> Int # countTrailingZeros :: CUInt -> Int #
Subtractive CUInt
Instance details Defined in Basement.Numerical.Subtractive Associated Types type Difference CUInt :: Type # Methods (-) :: CUInt -> CUInt -> Difference CUInt #
NFData CUInt	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: CUInt -> () #
Prim CUInt
Instance details Defined in Data.Primitive.Types Methods sizeOf# :: CUInt -> Int# # alignment# :: CUInt -> Int# # indexByteArray# :: ByteArray# -> Int# -> CUInt # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, CUInt#) # writeByteArray# :: MutableByteArray# s -> Int# -> CUInt -> State# s -> State# s # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> CUInt -> State# s -> State# s # indexOffAddr# :: Addr# -> Int# -> CUInt # readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, CUInt#) # writeOffAddr# :: Addr# -> Int# -> CUInt -> State# s -> State# s # setOffAddr# :: Addr# -> Int# -> Int# -> CUInt -> State# s -> State# s #
Wrapped CUInt
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped CUInt :: Type # Methods _Wrapped' :: Iso' CUInt (Unwrapped CUInt) #
IsScalar CUInt #
Instance details Defined in Data.Array.Accelerate.Type Methods scalarType :: ScalarType CUInt
IsBounded CUInt #
Instance details Defined in Data.Array.Accelerate.Type Methods boundedType :: BoundedType CUInt
IsNum CUInt #
Instance details Defined in Data.Array.Accelerate.Type Methods numType :: NumType CUInt
IsIntegral CUInt #
Instance details Defined in Data.Array.Accelerate.Type Methods integralType :: IntegralType CUInt
Elt CUInt #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods eltType :: CUInt -> TupleType (EltRepr CUInt) fromElt :: CUInt -> EltRepr CUInt toElt :: EltRepr CUInt -> CUInt
Eq CUInt #
Instance details Defined in Data.Array.Accelerate.Classes.Eq Methods (==) :: Exp CUInt -> Exp CUInt -> Exp Bool # (/=) :: Exp CUInt -> Exp CUInt -> Exp Bool #
Ord CUInt #
Instance details Defined in Data.Array.Accelerate.Classes.Ord Methods (<) :: Exp CUInt -> Exp CUInt -> Exp Bool # (>) :: Exp CUInt -> Exp CUInt -> Exp Bool # (<=) :: Exp CUInt -> Exp CUInt -> Exp Bool # (>=) :: Exp CUInt -> Exp CUInt -> Exp Bool # min :: Exp CUInt -> Exp CUInt -> Exp CUInt # max :: Exp CUInt -> Exp CUInt -> Exp CUInt # compare :: Exp CUInt -> Exp CUInt -> Exp Ordering #
FiniteBits CUInt #
Instance details Defined in Data.Array.Accelerate.Data.Bits Methods finiteBitSize :: Exp CUInt -> Exp Int # countLeadingZeros :: Exp CUInt -> Exp Int # countTrailingZeros :: Exp CUInt -> Exp Int #
Bits CUInt #
Instance details Defined in Data.Array.Accelerate.Data.Bits Methods (.&.) :: Exp CUInt -> Exp CUInt -> Exp CUInt # (.\|.) :: Exp CUInt -> Exp CUInt -> Exp CUInt # xor :: Exp CUInt -> Exp CUInt -> Exp CUInt # complement :: Exp CUInt -> Exp CUInt # shift :: Exp CUInt -> Exp Int -> Exp CUInt # rotate :: Exp CUInt -> Exp Int -> Exp CUInt # zeroBits :: Exp CUInt # bit :: Exp Int -> Exp CUInt # setBit :: Exp CUInt -> Exp Int -> Exp CUInt # clearBit :: Exp CUInt -> Exp Int -> Exp CUInt # complementBit :: Exp CUInt -> Exp Int -> Exp CUInt # testBit :: Exp CUInt -> Exp Int -> Exp Bool # isSigned :: Exp CUInt -> Exp Bool # shiftL :: Exp CUInt -> Exp Int -> Exp CUInt # unsafeShiftL :: Exp CUInt -> Exp Int -> Exp CUInt # shiftR :: Exp CUInt -> Exp Int -> Exp CUInt # unsafeShiftR :: Exp CUInt -> Exp Int -> Exp CUInt # rotateL :: Exp CUInt -> Exp Int -> Exp CUInt # rotateR :: Exp CUInt -> Exp Int -> Exp CUInt # popCount :: Exp CUInt -> Exp Int #
Rewrapped CUInt t
Instance details Defined in Control.Lens.Wrapped
Lift Exp CUInt #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain CUInt :: Type # Methods lift :: CUInt -> Exp (Plain CUInt) #
ToFloating CUInt Double #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CUInt -> Exp Double #
ToFloating CUInt Float #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CUInt -> Exp Float #
ToFloating CUInt CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CUInt -> Exp CFloat #
ToFloating CUInt CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CUInt -> Exp CDouble #
ToFloating CUInt Half #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CUInt -> Exp Half #
FromIntegral Int CUInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int -> Exp CUInt #
FromIntegral Int8 CUInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int8 -> Exp CUInt #
FromIntegral Int16 CUInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int16 -> Exp CUInt #
FromIntegral Int32 CUInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int32 -> Exp CUInt #
FromIntegral Int64 CUInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int64 -> Exp CUInt #
FromIntegral Word CUInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word -> Exp CUInt #
FromIntegral Word8 CUInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word8 -> Exp CUInt #
FromIntegral Word16 CUInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word16 -> Exp CUInt #
FromIntegral Word32 CUInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word32 -> Exp CUInt #
FromIntegral Word64 CUInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word64 -> Exp CUInt #
FromIntegral CShort CUInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CShort -> Exp CUInt #
FromIntegral CUShort CUInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUShort -> Exp CUInt #
FromIntegral CInt CUInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CInt -> Exp CUInt #
FromIntegral CUInt Double #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUInt -> Exp Double #
FromIntegral CUInt Float #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUInt -> Exp Float #
FromIntegral CUInt Int #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUInt -> Exp Int #
FromIntegral CUInt Int8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUInt -> Exp Int8 #
FromIntegral CUInt Int16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUInt -> Exp Int16 #
FromIntegral CUInt Int32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUInt -> Exp Int32 #
FromIntegral CUInt Int64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUInt -> Exp Int64 #
FromIntegral CUInt Word #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUInt -> Exp Word #
FromIntegral CUInt Word8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUInt -> Exp Word8 #
FromIntegral CUInt Word16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUInt -> Exp Word16 #
FromIntegral CUInt Word32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUInt -> Exp Word32 #
FromIntegral CUInt Word64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUInt -> Exp Word64 #
FromIntegral CUInt CShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUInt -> Exp CShort #
FromIntegral CUInt CUShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUInt -> Exp CUShort #
FromIntegral CUInt CInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUInt -> Exp CInt #
FromIntegral CUInt CUInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUInt -> Exp CUInt #
FromIntegral CUInt CLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUInt -> Exp CLong #
FromIntegral CUInt CULong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUInt -> Exp CULong #
FromIntegral CUInt CLLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUInt -> Exp CLLong #
FromIntegral CUInt CULLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUInt -> Exp CULLong #
FromIntegral CUInt CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUInt -> Exp CFloat #
FromIntegral CUInt CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUInt -> Exp CDouble #
FromIntegral CUInt Half #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUInt -> Exp Half #
FromIntegral CLong CUInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLong -> Exp CUInt #
FromIntegral CULong CUInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULong -> Exp CUInt #
FromIntegral CLLong CUInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLLong -> Exp CUInt #
FromIntegral CULLong CUInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULLong -> Exp CUInt #
Bounded (Exp CUInt) #
Instance details Defined in Data.Array.Accelerate.Classes.Bounded Methods minBound :: Exp CUInt # maxBound :: Exp CUInt #
Enum (Exp CUInt) #
Instance details Defined in Data.Array.Accelerate.Classes.Enum Methods succ :: Exp CUInt -> Exp CUInt # pred :: Exp CUInt -> Exp CUInt # toEnum :: Int -> Exp CUInt # fromEnum :: Exp CUInt -> Int # enumFrom :: Exp CUInt -> [Exp CUInt] # enumFromThen :: Exp CUInt -> Exp CUInt -> [Exp CUInt] # enumFromTo :: Exp CUInt -> Exp CUInt -> [Exp CUInt] # enumFromThenTo :: Exp CUInt -> Exp CUInt -> Exp CUInt -> [Exp CUInt] #
Integral (Exp CUInt) #
Instance details Defined in Data.Array.Accelerate.Classes.Integral Methods quot :: Exp CUInt -> Exp CUInt -> Exp CUInt # rem :: Exp CUInt -> Exp CUInt -> Exp CUInt # div :: Exp CUInt -> Exp CUInt -> Exp CUInt # mod :: Exp CUInt -> Exp CUInt -> Exp CUInt # quotRem :: Exp CUInt -> Exp CUInt -> (Exp CUInt, Exp CUInt) # divMod :: Exp CUInt -> Exp CUInt -> (Exp CUInt, Exp CUInt) # toInteger :: Exp CUInt -> Integer #
Num (Exp CUInt) #
Instance details Defined in Data.Array.Accelerate.Classes.Num Methods (+) :: Exp CUInt -> Exp CUInt -> Exp CUInt # (-) :: Exp CUInt -> Exp CUInt -> Exp CUInt # (*) :: Exp CUInt -> Exp CUInt -> Exp CUInt # negate :: Exp CUInt -> Exp CUInt # abs :: Exp CUInt -> Exp CUInt # signum :: Exp CUInt -> Exp CUInt # fromInteger :: Integer -> Exp CUInt #
type Difference CUInt
Instance details Defined in Basement.Numerical.Subtractive type Difference CUInt = CUInt
type Unwrapped CUInt
Instance details Defined in Control.Lens.Wrapped type Unwrapped CUInt = Word32
type Plain CUInt #
Instance details Defined in Data.Array.Accelerate.Lift type Plain CUInt = CUInt

data CLong #

Haskell type representing the C long type.

Instances

Bounded CLong
Instance details Defined in Foreign.C.Types Methods minBound :: CLong # maxBound :: CLong #
Enum CLong
Instance details Defined in Foreign.C.Types Methods succ :: CLong -> CLong # pred :: CLong -> CLong # toEnum :: Int -> CLong # fromEnum :: CLong -> Int # enumFrom :: CLong -> [CLong] # enumFromThen :: CLong -> CLong -> [CLong] # enumFromTo :: CLong -> CLong -> [CLong] # enumFromThenTo :: CLong -> CLong -> CLong -> [CLong] #
Eq CLong
Instance details Defined in Foreign.C.Types Methods (==) :: CLong -> CLong -> Bool # (/=) :: CLong -> CLong -> Bool #
Integral CLong
Instance details Defined in Foreign.C.Types Methods quot :: CLong -> CLong -> CLong # rem :: CLong -> CLong -> CLong # div :: CLong -> CLong -> CLong # mod :: CLong -> CLong -> CLong # quotRem :: CLong -> CLong -> (CLong, CLong) # divMod :: CLong -> CLong -> (CLong, CLong) # toInteger :: CLong -> Integer #
Num CLong
Instance details Defined in Foreign.C.Types Methods (+) :: CLong -> CLong -> CLong # (-) :: CLong -> CLong -> CLong # (*) :: CLong -> CLong -> CLong # negate :: CLong -> CLong # abs :: CLong -> CLong # signum :: CLong -> CLong # fromInteger :: Integer -> CLong #
Ord CLong
Instance details Defined in Foreign.C.Types Methods compare :: CLong -> CLong -> Ordering # (<) :: CLong -> CLong -> Bool # (<=) :: CLong -> CLong -> Bool # (>) :: CLong -> CLong -> Bool # (>=) :: CLong -> CLong -> Bool # max :: CLong -> CLong -> CLong # min :: CLong -> CLong -> CLong #
Read CLong
Instance details Defined in Foreign.C.Types Methods readsPrec :: Int -> ReadS CLong # readList :: ReadS [CLong] # readPrec :: ReadPrec CLong # readListPrec :: ReadPrec [CLong] #
Real CLong
Instance details Defined in Foreign.C.Types Methods toRational :: CLong -> Rational #
Show CLong
Instance details Defined in Foreign.C.Types Methods showsPrec :: Int -> CLong -> ShowS # show :: CLong -> String # showList :: [CLong] -> ShowS #
Storable CLong
Instance details Defined in Foreign.C.Types Methods sizeOf :: CLong -> Int # alignment :: CLong -> Int # peekElemOff :: Ptr CLong -> Int -> IO CLong # pokeElemOff :: Ptr CLong -> Int -> CLong -> IO () # peekByteOff :: Ptr b -> Int -> IO CLong # pokeByteOff :: Ptr b -> Int -> CLong -> IO () # peek :: Ptr CLong -> IO CLong # poke :: Ptr CLong -> CLong -> IO () #
Bits CLong
Instance details Defined in Foreign.C.Types Methods (.&.) :: CLong -> CLong -> CLong # (.\|.) :: CLong -> CLong -> CLong # xor :: CLong -> CLong -> CLong # complement :: CLong -> CLong # shift :: CLong -> Int -> CLong # rotate :: CLong -> Int -> CLong # zeroBits :: CLong # bit :: Int -> CLong # setBit :: CLong -> Int -> CLong # clearBit :: CLong -> Int -> CLong # complementBit :: CLong -> Int -> CLong # testBit :: CLong -> Int -> Bool # bitSizeMaybe :: CLong -> Maybe Int # bitSize :: CLong -> Int # isSigned :: CLong -> Bool # shiftL :: CLong -> Int -> CLong # unsafeShiftL :: CLong -> Int -> CLong # shiftR :: CLong -> Int -> CLong # unsafeShiftR :: CLong -> Int -> CLong # rotateL :: CLong -> Int -> CLong # rotateR :: CLong -> Int -> CLong # popCount :: CLong -> Int #
FiniteBits CLong
Instance details Defined in Foreign.C.Types Methods finiteBitSize :: CLong -> Int # countLeadingZeros :: CLong -> Int # countTrailingZeros :: CLong -> Int #
Subtractive CLong
Instance details Defined in Basement.Numerical.Subtractive Associated Types type Difference CLong :: Type # Methods (-) :: CLong -> CLong -> Difference CLong #
NFData CLong	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: CLong -> () #
Prim CLong
Instance details Defined in Data.Primitive.Types Methods sizeOf# :: CLong -> Int# # alignment# :: CLong -> Int# # indexByteArray# :: ByteArray# -> Int# -> CLong # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, CLong#) # writeByteArray# :: MutableByteArray# s -> Int# -> CLong -> State# s -> State# s # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> CLong -> State# s -> State# s # indexOffAddr# :: Addr# -> Int# -> CLong # readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, CLong#) # writeOffAddr# :: Addr# -> Int# -> CLong -> State# s -> State# s # setOffAddr# :: Addr# -> Int# -> Int# -> CLong -> State# s -> State# s #
Wrapped CLong
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped CLong :: Type # Methods _Wrapped' :: Iso' CLong (Unwrapped CLong) #
IsScalar CLong #
Instance details Defined in Data.Array.Accelerate.Type Methods scalarType :: ScalarType CLong
IsBounded CLong #
Instance details Defined in Data.Array.Accelerate.Type Methods boundedType :: BoundedType CLong
IsNum CLong #
Instance details Defined in Data.Array.Accelerate.Type Methods numType :: NumType CLong
IsIntegral CLong #
Instance details Defined in Data.Array.Accelerate.Type Methods integralType :: IntegralType CLong
Elt CLong #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods eltType :: CLong -> TupleType (EltRepr CLong) fromElt :: CLong -> EltRepr CLong toElt :: EltRepr CLong -> CLong
Eq CLong #
Instance details Defined in Data.Array.Accelerate.Classes.Eq Methods (==) :: Exp CLong -> Exp CLong -> Exp Bool # (/=) :: Exp CLong -> Exp CLong -> Exp Bool #
Ord CLong #
Instance details Defined in Data.Array.Accelerate.Classes.Ord Methods (<) :: Exp CLong -> Exp CLong -> Exp Bool # (>) :: Exp CLong -> Exp CLong -> Exp Bool # (<=) :: Exp CLong -> Exp CLong -> Exp Bool # (>=) :: Exp CLong -> Exp CLong -> Exp Bool # min :: Exp CLong -> Exp CLong -> Exp CLong # max :: Exp CLong -> Exp CLong -> Exp CLong # compare :: Exp CLong -> Exp CLong -> Exp Ordering #
FiniteBits CLong #
Instance details Defined in Data.Array.Accelerate.Data.Bits Methods finiteBitSize :: Exp CLong -> Exp Int # countLeadingZeros :: Exp CLong -> Exp Int # countTrailingZeros :: Exp CLong -> Exp Int #
Bits CLong #
Instance details Defined in Data.Array.Accelerate.Data.Bits Methods (.&.) :: Exp CLong -> Exp CLong -> Exp CLong # (.\|.) :: Exp CLong -> Exp CLong -> Exp CLong # xor :: Exp CLong -> Exp CLong -> Exp CLong # complement :: Exp CLong -> Exp CLong # shift :: Exp CLong -> Exp Int -> Exp CLong # rotate :: Exp CLong -> Exp Int -> Exp CLong # zeroBits :: Exp CLong # bit :: Exp Int -> Exp CLong # setBit :: Exp CLong -> Exp Int -> Exp CLong # clearBit :: Exp CLong -> Exp Int -> Exp CLong # complementBit :: Exp CLong -> Exp Int -> Exp CLong # testBit :: Exp CLong -> Exp Int -> Exp Bool # isSigned :: Exp CLong -> Exp Bool # shiftL :: Exp CLong -> Exp Int -> Exp CLong # unsafeShiftL :: Exp CLong -> Exp Int -> Exp CLong # shiftR :: Exp CLong -> Exp Int -> Exp CLong # unsafeShiftR :: Exp CLong -> Exp Int -> Exp CLong # rotateL :: Exp CLong -> Exp Int -> Exp CLong # rotateR :: Exp CLong -> Exp Int -> Exp CLong # popCount :: Exp CLong -> Exp Int #
Rewrapped CLong t
Instance details Defined in Control.Lens.Wrapped
Lift Exp CLong #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain CLong :: Type # Methods lift :: CLong -> Exp (Plain CLong) #
ToFloating CLong Double #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CLong -> Exp Double #
ToFloating CLong Float #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CLong -> Exp Float #
ToFloating CLong CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CLong -> Exp CFloat #
ToFloating CLong CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CLong -> Exp CDouble #
ToFloating CLong Half #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CLong -> Exp Half #
FromIntegral Int CLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int -> Exp CLong #
FromIntegral Int8 CLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int8 -> Exp CLong #
FromIntegral Int16 CLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int16 -> Exp CLong #
FromIntegral Int32 CLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int32 -> Exp CLong #
FromIntegral Int64 CLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int64 -> Exp CLong #
FromIntegral Word CLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word -> Exp CLong #
FromIntegral Word8 CLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word8 -> Exp CLong #
FromIntegral Word16 CLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word16 -> Exp CLong #
FromIntegral Word32 CLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word32 -> Exp CLong #
FromIntegral Word64 CLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word64 -> Exp CLong #
FromIntegral CShort CLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CShort -> Exp CLong #
FromIntegral CUShort CLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUShort -> Exp CLong #
FromIntegral CInt CLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CInt -> Exp CLong #
FromIntegral CUInt CLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUInt -> Exp CLong #
FromIntegral CLong Double #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLong -> Exp Double #
FromIntegral CLong Float #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLong -> Exp Float #
FromIntegral CLong Int #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLong -> Exp Int #
FromIntegral CLong Int8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLong -> Exp Int8 #
FromIntegral CLong Int16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLong -> Exp Int16 #
FromIntegral CLong Int32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLong -> Exp Int32 #
FromIntegral CLong Int64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLong -> Exp Int64 #
FromIntegral CLong Word #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLong -> Exp Word #
FromIntegral CLong Word8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLong -> Exp Word8 #
FromIntegral CLong Word16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLong -> Exp Word16 #
FromIntegral CLong Word32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLong -> Exp Word32 #
FromIntegral CLong Word64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLong -> Exp Word64 #
FromIntegral CLong CShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLong -> Exp CShort #
FromIntegral CLong CUShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLong -> Exp CUShort #
FromIntegral CLong CInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLong -> Exp CInt #
FromIntegral CLong CUInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLong -> Exp CUInt #
FromIntegral CLong CLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLong -> Exp CLong #
FromIntegral CLong CULong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLong -> Exp CULong #
FromIntegral CLong CLLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLong -> Exp CLLong #
FromIntegral CLong CULLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLong -> Exp CULLong #
FromIntegral CLong CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLong -> Exp CFloat #
FromIntegral CLong CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLong -> Exp CDouble #
FromIntegral CLong Half #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLong -> Exp Half #
FromIntegral CULong CLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULong -> Exp CLong #
FromIntegral CLLong CLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLLong -> Exp CLong #
FromIntegral CULLong CLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULLong -> Exp CLong #
Bounded (Exp CLong) #
Instance details Defined in Data.Array.Accelerate.Classes.Bounded Methods minBound :: Exp CLong # maxBound :: Exp CLong #
Enum (Exp CLong) #
Instance details Defined in Data.Array.Accelerate.Classes.Enum Methods succ :: Exp CLong -> Exp CLong # pred :: Exp CLong -> Exp CLong # toEnum :: Int -> Exp CLong # fromEnum :: Exp CLong -> Int # enumFrom :: Exp CLong -> [Exp CLong] # enumFromThen :: Exp CLong -> Exp CLong -> [Exp CLong] # enumFromTo :: Exp CLong -> Exp CLong -> [Exp CLong] # enumFromThenTo :: Exp CLong -> Exp CLong -> Exp CLong -> [Exp CLong] #
Integral (Exp CLong) #
Instance details Defined in Data.Array.Accelerate.Classes.Integral Methods quot :: Exp CLong -> Exp CLong -> Exp CLong # rem :: Exp CLong -> Exp CLong -> Exp CLong # div :: Exp CLong -> Exp CLong -> Exp CLong # mod :: Exp CLong -> Exp CLong -> Exp CLong # quotRem :: Exp CLong -> Exp CLong -> (Exp CLong, Exp CLong) # divMod :: Exp CLong -> Exp CLong -> (Exp CLong, Exp CLong) # toInteger :: Exp CLong -> Integer #
Num (Exp CLong) #
Instance details Defined in Data.Array.Accelerate.Classes.Num Methods (+) :: Exp CLong -> Exp CLong -> Exp CLong # (-) :: Exp CLong -> Exp CLong -> Exp CLong # (*) :: Exp CLong -> Exp CLong -> Exp CLong # negate :: Exp CLong -> Exp CLong # abs :: Exp CLong -> Exp CLong # signum :: Exp CLong -> Exp CLong # fromInteger :: Integer -> Exp CLong #
type Difference CLong
Instance details Defined in Basement.Numerical.Subtractive type Difference CLong = CLong
type Unwrapped CLong
Instance details Defined in Control.Lens.Wrapped type Unwrapped CLong = Int64
type Plain CLong #
Instance details Defined in Data.Array.Accelerate.Lift type Plain CLong = CLong

data CULong #

Haskell type representing the C unsigned long type.

Instances

Bounded CULong
Instance details Defined in Foreign.C.Types Methods minBound :: CULong # maxBound :: CULong #
Enum CULong
Instance details Defined in Foreign.C.Types Methods succ :: CULong -> CULong # pred :: CULong -> CULong # toEnum :: Int -> CULong # fromEnum :: CULong -> Int # enumFrom :: CULong -> [CULong] # enumFromThen :: CULong -> CULong -> [CULong] # enumFromTo :: CULong -> CULong -> [CULong] # enumFromThenTo :: CULong -> CULong -> CULong -> [CULong] #
Eq CULong
Instance details Defined in Foreign.C.Types Methods (==) :: CULong -> CULong -> Bool # (/=) :: CULong -> CULong -> Bool #
Integral CULong
Instance details Defined in Foreign.C.Types Methods quot :: CULong -> CULong -> CULong # rem :: CULong -> CULong -> CULong # div :: CULong -> CULong -> CULong # mod :: CULong -> CULong -> CULong # quotRem :: CULong -> CULong -> (CULong, CULong) # divMod :: CULong -> CULong -> (CULong, CULong) # toInteger :: CULong -> Integer #
Num CULong
Instance details Defined in Foreign.C.Types Methods (+) :: CULong -> CULong -> CULong # (-) :: CULong -> CULong -> CULong # (*) :: CULong -> CULong -> CULong # negate :: CULong -> CULong # abs :: CULong -> CULong # signum :: CULong -> CULong # fromInteger :: Integer -> CULong #
Ord CULong
Instance details Defined in Foreign.C.Types Methods compare :: CULong -> CULong -> Ordering # (<) :: CULong -> CULong -> Bool # (<=) :: CULong -> CULong -> Bool # (>) :: CULong -> CULong -> Bool # (>=) :: CULong -> CULong -> Bool # max :: CULong -> CULong -> CULong # min :: CULong -> CULong -> CULong #
Read CULong
Instance details Defined in Foreign.C.Types Methods readsPrec :: Int -> ReadS CULong # readList :: ReadS [CULong] # readPrec :: ReadPrec CULong # readListPrec :: ReadPrec [CULong] #
Real CULong
Instance details Defined in Foreign.C.Types Methods toRational :: CULong -> Rational #
Show CULong
Instance details Defined in Foreign.C.Types Methods showsPrec :: Int -> CULong -> ShowS # show :: CULong -> String # showList :: [CULong] -> ShowS #
Storable CULong
Instance details Defined in Foreign.C.Types Methods sizeOf :: CULong -> Int # alignment :: CULong -> Int # peekElemOff :: Ptr CULong -> Int -> IO CULong # pokeElemOff :: Ptr CULong -> Int -> CULong -> IO () # peekByteOff :: Ptr b -> Int -> IO CULong # pokeByteOff :: Ptr b -> Int -> CULong -> IO () # peek :: Ptr CULong -> IO CULong # poke :: Ptr CULong -> CULong -> IO () #
Bits CULong
Instance details Defined in Foreign.C.Types Methods (.&.) :: CULong -> CULong -> CULong # (.\|.) :: CULong -> CULong -> CULong # xor :: CULong -> CULong -> CULong # complement :: CULong -> CULong # shift :: CULong -> Int -> CULong # rotate :: CULong -> Int -> CULong # zeroBits :: CULong # bit :: Int -> CULong # setBit :: CULong -> Int -> CULong # clearBit :: CULong -> Int -> CULong # complementBit :: CULong -> Int -> CULong # testBit :: CULong -> Int -> Bool # bitSizeMaybe :: CULong -> Maybe Int # bitSize :: CULong -> Int # isSigned :: CULong -> Bool # shiftL :: CULong -> Int -> CULong # unsafeShiftL :: CULong -> Int -> CULong # shiftR :: CULong -> Int -> CULong # unsafeShiftR :: CULong -> Int -> CULong # rotateL :: CULong -> Int -> CULong # rotateR :: CULong -> Int -> CULong # popCount :: CULong -> Int #
FiniteBits CULong
Instance details Defined in Foreign.C.Types Methods finiteBitSize :: CULong -> Int # countLeadingZeros :: CULong -> Int # countTrailingZeros :: CULong -> Int #
Subtractive CULong
Instance details Defined in Basement.Numerical.Subtractive Associated Types type Difference CULong :: Type # Methods (-) :: CULong -> CULong -> Difference CULong #
NFData CULong	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: CULong -> () #
Prim CULong
Instance details Defined in Data.Primitive.Types Methods sizeOf# :: CULong -> Int# # alignment# :: CULong -> Int# # indexByteArray# :: ByteArray# -> Int# -> CULong # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, CULong#) # writeByteArray# :: MutableByteArray# s -> Int# -> CULong -> State# s -> State# s # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> CULong -> State# s -> State# s # indexOffAddr# :: Addr# -> Int# -> CULong # readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, CULong#) # writeOffAddr# :: Addr# -> Int# -> CULong -> State# s -> State# s # setOffAddr# :: Addr# -> Int# -> Int# -> CULong -> State# s -> State# s #
Wrapped CULong
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped CULong :: Type # Methods _Wrapped' :: Iso' CULong (Unwrapped CULong) #
IsScalar CULong #
Instance details Defined in Data.Array.Accelerate.Type Methods scalarType :: ScalarType CULong
IsBounded CULong #
Instance details Defined in Data.Array.Accelerate.Type Methods boundedType :: BoundedType CULong
IsNum CULong #
Instance details Defined in Data.Array.Accelerate.Type Methods numType :: NumType CULong
IsIntegral CULong #
Instance details Defined in Data.Array.Accelerate.Type Methods integralType :: IntegralType CULong
Elt CULong #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods eltType :: CULong -> TupleType (EltRepr CULong) fromElt :: CULong -> EltRepr CULong toElt :: EltRepr CULong -> CULong
Eq CULong #
Instance details Defined in Data.Array.Accelerate.Classes.Eq Methods (==) :: Exp CULong -> Exp CULong -> Exp Bool # (/=) :: Exp CULong -> Exp CULong -> Exp Bool #
Ord CULong #
Instance details Defined in Data.Array.Accelerate.Classes.Ord Methods (<) :: Exp CULong -> Exp CULong -> Exp Bool # (>) :: Exp CULong -> Exp CULong -> Exp Bool # (<=) :: Exp CULong -> Exp CULong -> Exp Bool # (>=) :: Exp CULong -> Exp CULong -> Exp Bool # min :: Exp CULong -> Exp CULong -> Exp CULong # max :: Exp CULong -> Exp CULong -> Exp CULong # compare :: Exp CULong -> Exp CULong -> Exp Ordering #
FiniteBits CULong #
Instance details Defined in Data.Array.Accelerate.Data.Bits Methods finiteBitSize :: Exp CULong -> Exp Int # countLeadingZeros :: Exp CULong -> Exp Int # countTrailingZeros :: Exp CULong -> Exp Int #
Bits CULong #
Instance details Defined in Data.Array.Accelerate.Data.Bits Methods (.&.) :: Exp CULong -> Exp CULong -> Exp CULong # (.\|.) :: Exp CULong -> Exp CULong -> Exp CULong # xor :: Exp CULong -> Exp CULong -> Exp CULong # complement :: Exp CULong -> Exp CULong # shift :: Exp CULong -> Exp Int -> Exp CULong # rotate :: Exp CULong -> Exp Int -> Exp CULong # zeroBits :: Exp CULong # bit :: Exp Int -> Exp CULong # setBit :: Exp CULong -> Exp Int -> Exp CULong # clearBit :: Exp CULong -> Exp Int -> Exp CULong # complementBit :: Exp CULong -> Exp Int -> Exp CULong # testBit :: Exp CULong -> Exp Int -> Exp Bool # isSigned :: Exp CULong -> Exp Bool # shiftL :: Exp CULong -> Exp Int -> Exp CULong # unsafeShiftL :: Exp CULong -> Exp Int -> Exp CULong # shiftR :: Exp CULong -> Exp Int -> Exp CULong # unsafeShiftR :: Exp CULong -> Exp Int -> Exp CULong # rotateL :: Exp CULong -> Exp Int -> Exp CULong # rotateR :: Exp CULong -> Exp Int -> Exp CULong # popCount :: Exp CULong -> Exp Int #
Rewrapped CULong t
Instance details Defined in Control.Lens.Wrapped
Lift Exp CULong #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain CULong :: Type # Methods lift :: CULong -> Exp (Plain CULong) #
ToFloating CULong Double #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CULong -> Exp Double #
ToFloating CULong Float #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CULong -> Exp Float #
ToFloating CULong CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CULong -> Exp CFloat #
ToFloating CULong CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CULong -> Exp CDouble #
ToFloating CULong Half #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CULong -> Exp Half #
FromIntegral Int CULong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int -> Exp CULong #
FromIntegral Int8 CULong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int8 -> Exp CULong #
FromIntegral Int16 CULong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int16 -> Exp CULong #
FromIntegral Int32 CULong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int32 -> Exp CULong #
FromIntegral Int64 CULong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int64 -> Exp CULong #
FromIntegral Word CULong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word -> Exp CULong #
FromIntegral Word8 CULong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word8 -> Exp CULong #
FromIntegral Word16 CULong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word16 -> Exp CULong #
FromIntegral Word32 CULong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word32 -> Exp CULong #
FromIntegral Word64 CULong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word64 -> Exp CULong #
FromIntegral CShort CULong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CShort -> Exp CULong #
FromIntegral CUShort CULong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUShort -> Exp CULong #
FromIntegral CInt CULong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CInt -> Exp CULong #
FromIntegral CUInt CULong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUInt -> Exp CULong #
FromIntegral CLong CULong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLong -> Exp CULong #
FromIntegral CULong Double #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULong -> Exp Double #
FromIntegral CULong Float #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULong -> Exp Float #
FromIntegral CULong Int #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULong -> Exp Int #
FromIntegral CULong Int8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULong -> Exp Int8 #
FromIntegral CULong Int16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULong -> Exp Int16 #
FromIntegral CULong Int32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULong -> Exp Int32 #
FromIntegral CULong Int64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULong -> Exp Int64 #
FromIntegral CULong Word #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULong -> Exp Word #
FromIntegral CULong Word8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULong -> Exp Word8 #
FromIntegral CULong Word16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULong -> Exp Word16 #
FromIntegral CULong Word32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULong -> Exp Word32 #
FromIntegral CULong Word64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULong -> Exp Word64 #
FromIntegral CULong CShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULong -> Exp CShort #
FromIntegral CULong CUShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULong -> Exp CUShort #
FromIntegral CULong CInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULong -> Exp CInt #
FromIntegral CULong CUInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULong -> Exp CUInt #
FromIntegral CULong CLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULong -> Exp CLong #
FromIntegral CULong CULong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULong -> Exp CULong #
FromIntegral CULong CLLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULong -> Exp CLLong #
FromIntegral CULong CULLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULong -> Exp CULLong #
FromIntegral CULong CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULong -> Exp CFloat #
FromIntegral CULong CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULong -> Exp CDouble #
FromIntegral CULong Half #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULong -> Exp Half #
FromIntegral CLLong CULong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLLong -> Exp CULong #
FromIntegral CULLong CULong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULLong -> Exp CULong #
Bounded (Exp CULong) #
Instance details Defined in Data.Array.Accelerate.Classes.Bounded Methods minBound :: Exp CULong # maxBound :: Exp CULong #
Enum (Exp CULong) #
Instance details Defined in Data.Array.Accelerate.Classes.Enum Methods succ :: Exp CULong -> Exp CULong # pred :: Exp CULong -> Exp CULong # toEnum :: Int -> Exp CULong # fromEnum :: Exp CULong -> Int # enumFrom :: Exp CULong -> [Exp CULong] # enumFromThen :: Exp CULong -> Exp CULong -> [Exp CULong] # enumFromTo :: Exp CULong -> Exp CULong -> [Exp CULong] # enumFromThenTo :: Exp CULong -> Exp CULong -> Exp CULong -> [Exp CULong] #
Integral (Exp CULong) #
Instance details Defined in Data.Array.Accelerate.Classes.Integral Methods quot :: Exp CULong -> Exp CULong -> Exp CULong # rem :: Exp CULong -> Exp CULong -> Exp CULong # div :: Exp CULong -> Exp CULong -> Exp CULong # mod :: Exp CULong -> Exp CULong -> Exp CULong # quotRem :: Exp CULong -> Exp CULong -> (Exp CULong, Exp CULong) # divMod :: Exp CULong -> Exp CULong -> (Exp CULong, Exp CULong) # toInteger :: Exp CULong -> Integer #
Num (Exp CULong) #
Instance details Defined in Data.Array.Accelerate.Classes.Num Methods (+) :: Exp CULong -> Exp CULong -> Exp CULong # (-) :: Exp CULong -> Exp CULong -> Exp CULong # (*) :: Exp CULong -> Exp CULong -> Exp CULong # negate :: Exp CULong -> Exp CULong # abs :: Exp CULong -> Exp CULong # signum :: Exp CULong -> Exp CULong # fromInteger :: Integer -> Exp CULong #
type Difference CULong
Instance details Defined in Basement.Numerical.Subtractive type Difference CULong = CULong
type Unwrapped CULong
Instance details Defined in Control.Lens.Wrapped type Unwrapped CULong = Word64
type Plain CULong #
Instance details Defined in Data.Array.Accelerate.Lift type Plain CULong = CULong

data CLLong #

Haskell type representing the C long long type.

Instances

Bounded CLLong
Instance details Defined in Foreign.C.Types Methods minBound :: CLLong # maxBound :: CLLong #
Enum CLLong
Instance details Defined in Foreign.C.Types Methods succ :: CLLong -> CLLong # pred :: CLLong -> CLLong # toEnum :: Int -> CLLong # fromEnum :: CLLong -> Int # enumFrom :: CLLong -> [CLLong] # enumFromThen :: CLLong -> CLLong -> [CLLong] # enumFromTo :: CLLong -> CLLong -> [CLLong] # enumFromThenTo :: CLLong -> CLLong -> CLLong -> [CLLong] #
Eq CLLong
Instance details Defined in Foreign.C.Types Methods (==) :: CLLong -> CLLong -> Bool # (/=) :: CLLong -> CLLong -> Bool #
Integral CLLong
Instance details Defined in Foreign.C.Types Methods quot :: CLLong -> CLLong -> CLLong # rem :: CLLong -> CLLong -> CLLong # div :: CLLong -> CLLong -> CLLong # mod :: CLLong -> CLLong -> CLLong # quotRem :: CLLong -> CLLong -> (CLLong, CLLong) # divMod :: CLLong -> CLLong -> (CLLong, CLLong) # toInteger :: CLLong -> Integer #
Num CLLong
Instance details Defined in Foreign.C.Types Methods (+) :: CLLong -> CLLong -> CLLong # (-) :: CLLong -> CLLong -> CLLong # (*) :: CLLong -> CLLong -> CLLong # negate :: CLLong -> CLLong # abs :: CLLong -> CLLong # signum :: CLLong -> CLLong # fromInteger :: Integer -> CLLong #
Ord CLLong
Instance details Defined in Foreign.C.Types Methods compare :: CLLong -> CLLong -> Ordering # (<) :: CLLong -> CLLong -> Bool # (<=) :: CLLong -> CLLong -> Bool # (>) :: CLLong -> CLLong -> Bool # (>=) :: CLLong -> CLLong -> Bool # max :: CLLong -> CLLong -> CLLong # min :: CLLong -> CLLong -> CLLong #
Read CLLong
Instance details Defined in Foreign.C.Types Methods readsPrec :: Int -> ReadS CLLong # readList :: ReadS [CLLong] # readPrec :: ReadPrec CLLong # readListPrec :: ReadPrec [CLLong] #
Real CLLong
Instance details Defined in Foreign.C.Types Methods toRational :: CLLong -> Rational #
Show CLLong
Instance details Defined in Foreign.C.Types Methods showsPrec :: Int -> CLLong -> ShowS # show :: CLLong -> String # showList :: [CLLong] -> ShowS #
Storable CLLong
Instance details Defined in Foreign.C.Types Methods sizeOf :: CLLong -> Int # alignment :: CLLong -> Int # peekElemOff :: Ptr CLLong -> Int -> IO CLLong # pokeElemOff :: Ptr CLLong -> Int -> CLLong -> IO () # peekByteOff :: Ptr b -> Int -> IO CLLong # pokeByteOff :: Ptr b -> Int -> CLLong -> IO () # peek :: Ptr CLLong -> IO CLLong # poke :: Ptr CLLong -> CLLong -> IO () #
Bits CLLong
Instance details Defined in Foreign.C.Types Methods (.&.) :: CLLong -> CLLong -> CLLong # (.\|.) :: CLLong -> CLLong -> CLLong # xor :: CLLong -> CLLong -> CLLong # complement :: CLLong -> CLLong # shift :: CLLong -> Int -> CLLong # rotate :: CLLong -> Int -> CLLong # zeroBits :: CLLong # bit :: Int -> CLLong # setBit :: CLLong -> Int -> CLLong # clearBit :: CLLong -> Int -> CLLong # complementBit :: CLLong -> Int -> CLLong # testBit :: CLLong -> Int -> Bool # bitSizeMaybe :: CLLong -> Maybe Int # bitSize :: CLLong -> Int # isSigned :: CLLong -> Bool # shiftL :: CLLong -> Int -> CLLong # unsafeShiftL :: CLLong -> Int -> CLLong # shiftR :: CLLong -> Int -> CLLong # unsafeShiftR :: CLLong -> Int -> CLLong # rotateL :: CLLong -> Int -> CLLong # rotateR :: CLLong -> Int -> CLLong # popCount :: CLLong -> Int #
FiniteBits CLLong
Instance details Defined in Foreign.C.Types Methods finiteBitSize :: CLLong -> Int # countLeadingZeros :: CLLong -> Int # countTrailingZeros :: CLLong -> Int #
Subtractive CLLong
Instance details Defined in Basement.Numerical.Subtractive Associated Types type Difference CLLong :: Type # Methods (-) :: CLLong -> CLLong -> Difference CLLong #
NFData CLLong	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: CLLong -> () #
Prim CLLong
Instance details Defined in Data.Primitive.Types Methods sizeOf# :: CLLong -> Int# # alignment# :: CLLong -> Int# # indexByteArray# :: ByteArray# -> Int# -> CLLong # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, CLLong#) # writeByteArray# :: MutableByteArray# s -> Int# -> CLLong -> State# s -> State# s # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> CLLong -> State# s -> State# s # indexOffAddr# :: Addr# -> Int# -> CLLong # readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, CLLong#) # writeOffAddr# :: Addr# -> Int# -> CLLong -> State# s -> State# s # setOffAddr# :: Addr# -> Int# -> Int# -> CLLong -> State# s -> State# s #
Wrapped CLLong
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped CLLong :: Type # Methods _Wrapped' :: Iso' CLLong (Unwrapped CLLong) #
IsScalar CLLong #
Instance details Defined in Data.Array.Accelerate.Type Methods scalarType :: ScalarType CLLong
IsBounded CLLong #
Instance details Defined in Data.Array.Accelerate.Type Methods boundedType :: BoundedType CLLong
IsNum CLLong #
Instance details Defined in Data.Array.Accelerate.Type Methods numType :: NumType CLLong
IsIntegral CLLong #
Instance details Defined in Data.Array.Accelerate.Type Methods integralType :: IntegralType CLLong
Elt CLLong #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods eltType :: CLLong -> TupleType (EltRepr CLLong) fromElt :: CLLong -> EltRepr CLLong toElt :: EltRepr CLLong -> CLLong
Eq CLLong #
Instance details Defined in Data.Array.Accelerate.Classes.Eq Methods (==) :: Exp CLLong -> Exp CLLong -> Exp Bool # (/=) :: Exp CLLong -> Exp CLLong -> Exp Bool #
Ord CLLong #
Instance details Defined in Data.Array.Accelerate.Classes.Ord Methods (<) :: Exp CLLong -> Exp CLLong -> Exp Bool # (>) :: Exp CLLong -> Exp CLLong -> Exp Bool # (<=) :: Exp CLLong -> Exp CLLong -> Exp Bool # (>=) :: Exp CLLong -> Exp CLLong -> Exp Bool # min :: Exp CLLong -> Exp CLLong -> Exp CLLong # max :: Exp CLLong -> Exp CLLong -> Exp CLLong # compare :: Exp CLLong -> Exp CLLong -> Exp Ordering #
FiniteBits CLLong #
Instance details Defined in Data.Array.Accelerate.Data.Bits Methods finiteBitSize :: Exp CLLong -> Exp Int # countLeadingZeros :: Exp CLLong -> Exp Int # countTrailingZeros :: Exp CLLong -> Exp Int #
Bits CLLong #
Instance details Defined in Data.Array.Accelerate.Data.Bits Methods (.&.) :: Exp CLLong -> Exp CLLong -> Exp CLLong # (.\|.) :: Exp CLLong -> Exp CLLong -> Exp CLLong # xor :: Exp CLLong -> Exp CLLong -> Exp CLLong # complement :: Exp CLLong -> Exp CLLong # shift :: Exp CLLong -> Exp Int -> Exp CLLong # rotate :: Exp CLLong -> Exp Int -> Exp CLLong # zeroBits :: Exp CLLong # bit :: Exp Int -> Exp CLLong # setBit :: Exp CLLong -> Exp Int -> Exp CLLong # clearBit :: Exp CLLong -> Exp Int -> Exp CLLong # complementBit :: Exp CLLong -> Exp Int -> Exp CLLong # testBit :: Exp CLLong -> Exp Int -> Exp Bool # isSigned :: Exp CLLong -> Exp Bool # shiftL :: Exp CLLong -> Exp Int -> Exp CLLong # unsafeShiftL :: Exp CLLong -> Exp Int -> Exp CLLong # shiftR :: Exp CLLong -> Exp Int -> Exp CLLong # unsafeShiftR :: Exp CLLong -> Exp Int -> Exp CLLong # rotateL :: Exp CLLong -> Exp Int -> Exp CLLong # rotateR :: Exp CLLong -> Exp Int -> Exp CLLong # popCount :: Exp CLLong -> Exp Int #
Rewrapped CLLong t
Instance details Defined in Control.Lens.Wrapped
Lift Exp CLLong #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain CLLong :: Type # Methods lift :: CLLong -> Exp (Plain CLLong) #
ToFloating CLLong Double #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CLLong -> Exp Double #
ToFloating CLLong Float #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CLLong -> Exp Float #
ToFloating CLLong CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CLLong -> Exp CFloat #
ToFloating CLLong CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CLLong -> Exp CDouble #
ToFloating CLLong Half #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CLLong -> Exp Half #
FromIntegral Int CLLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int -> Exp CLLong #
FromIntegral Int8 CLLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int8 -> Exp CLLong #
FromIntegral Int16 CLLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int16 -> Exp CLLong #
FromIntegral Int32 CLLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int32 -> Exp CLLong #
FromIntegral Int64 CLLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int64 -> Exp CLLong #
FromIntegral Word CLLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word -> Exp CLLong #
FromIntegral Word8 CLLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word8 -> Exp CLLong #
FromIntegral Word16 CLLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word16 -> Exp CLLong #
FromIntegral Word32 CLLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word32 -> Exp CLLong #
FromIntegral Word64 CLLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word64 -> Exp CLLong #
FromIntegral CShort CLLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CShort -> Exp CLLong #
FromIntegral CUShort CLLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUShort -> Exp CLLong #
FromIntegral CInt CLLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CInt -> Exp CLLong #
FromIntegral CUInt CLLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUInt -> Exp CLLong #
FromIntegral CLong CLLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLong -> Exp CLLong #
FromIntegral CULong CLLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULong -> Exp CLLong #
FromIntegral CLLong Double #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLLong -> Exp Double #
FromIntegral CLLong Float #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLLong -> Exp Float #
FromIntegral CLLong Int #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLLong -> Exp Int #
FromIntegral CLLong Int8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLLong -> Exp Int8 #
FromIntegral CLLong Int16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLLong -> Exp Int16 #
FromIntegral CLLong Int32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLLong -> Exp Int32 #
FromIntegral CLLong Int64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLLong -> Exp Int64 #
FromIntegral CLLong Word #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLLong -> Exp Word #
FromIntegral CLLong Word8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLLong -> Exp Word8 #
FromIntegral CLLong Word16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLLong -> Exp Word16 #
FromIntegral CLLong Word32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLLong -> Exp Word32 #
FromIntegral CLLong Word64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLLong -> Exp Word64 #
FromIntegral CLLong CShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLLong -> Exp CShort #
FromIntegral CLLong CUShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLLong -> Exp CUShort #
FromIntegral CLLong CInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLLong -> Exp CInt #
FromIntegral CLLong CUInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLLong -> Exp CUInt #
FromIntegral CLLong CLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLLong -> Exp CLong #
FromIntegral CLLong CULong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLLong -> Exp CULong #
FromIntegral CLLong CLLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLLong -> Exp CLLong #
FromIntegral CLLong CULLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLLong -> Exp CULLong #
FromIntegral CLLong CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLLong -> Exp CFloat #
FromIntegral CLLong CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLLong -> Exp CDouble #
FromIntegral CLLong Half #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLLong -> Exp Half #
FromIntegral CULLong CLLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULLong -> Exp CLLong #
Bounded (Exp CLLong) #
Instance details Defined in Data.Array.Accelerate.Classes.Bounded Methods minBound :: Exp CLLong # maxBound :: Exp CLLong #
Enum (Exp CLLong) #
Instance details Defined in Data.Array.Accelerate.Classes.Enum Methods succ :: Exp CLLong -> Exp CLLong # pred :: Exp CLLong -> Exp CLLong # toEnum :: Int -> Exp CLLong # fromEnum :: Exp CLLong -> Int # enumFrom :: Exp CLLong -> [Exp CLLong] # enumFromThen :: Exp CLLong -> Exp CLLong -> [Exp CLLong] # enumFromTo :: Exp CLLong -> Exp CLLong -> [Exp CLLong] # enumFromThenTo :: Exp CLLong -> Exp CLLong -> Exp CLLong -> [Exp CLLong] #
Integral (Exp CLLong) #
Instance details Defined in Data.Array.Accelerate.Classes.Integral Methods quot :: Exp CLLong -> Exp CLLong -> Exp CLLong # rem :: Exp CLLong -> Exp CLLong -> Exp CLLong # div :: Exp CLLong -> Exp CLLong -> Exp CLLong # mod :: Exp CLLong -> Exp CLLong -> Exp CLLong # quotRem :: Exp CLLong -> Exp CLLong -> (Exp CLLong, Exp CLLong) # divMod :: Exp CLLong -> Exp CLLong -> (Exp CLLong, Exp CLLong) # toInteger :: Exp CLLong -> Integer #
Num (Exp CLLong) #
Instance details Defined in Data.Array.Accelerate.Classes.Num Methods (+) :: Exp CLLong -> Exp CLLong -> Exp CLLong # (-) :: Exp CLLong -> Exp CLLong -> Exp CLLong # (*) :: Exp CLLong -> Exp CLLong -> Exp CLLong # negate :: Exp CLLong -> Exp CLLong # abs :: Exp CLLong -> Exp CLLong # signum :: Exp CLLong -> Exp CLLong # fromInteger :: Integer -> Exp CLLong #
type Difference CLLong
Instance details Defined in Basement.Numerical.Subtractive type Difference CLLong = CLLong
type Unwrapped CLLong
Instance details Defined in Control.Lens.Wrapped type Unwrapped CLLong = Int64
type Plain CLLong #
Instance details Defined in Data.Array.Accelerate.Lift type Plain CLLong = CLLong

data CULLong #

Haskell type representing the C unsigned long long type.

Instances

Bounded CULLong
Instance details Defined in Foreign.C.Types Methods minBound :: CULLong # maxBound :: CULLong #
Enum CULLong
Instance details Defined in Foreign.C.Types Methods succ :: CULLong -> CULLong # pred :: CULLong -> CULLong # toEnum :: Int -> CULLong # fromEnum :: CULLong -> Int # enumFrom :: CULLong -> [CULLong] # enumFromThen :: CULLong -> CULLong -> [CULLong] # enumFromTo :: CULLong -> CULLong -> [CULLong] # enumFromThenTo :: CULLong -> CULLong -> CULLong -> [CULLong] #
Eq CULLong
Instance details Defined in Foreign.C.Types Methods (==) :: CULLong -> CULLong -> Bool # (/=) :: CULLong -> CULLong -> Bool #
Integral CULLong
Instance details Defined in Foreign.C.Types Methods quot :: CULLong -> CULLong -> CULLong # rem :: CULLong -> CULLong -> CULLong # div :: CULLong -> CULLong -> CULLong # mod :: CULLong -> CULLong -> CULLong # quotRem :: CULLong -> CULLong -> (CULLong, CULLong) # divMod :: CULLong -> CULLong -> (CULLong, CULLong) # toInteger :: CULLong -> Integer #
Num CULLong
Instance details Defined in Foreign.C.Types Methods (+) :: CULLong -> CULLong -> CULLong # (-) :: CULLong -> CULLong -> CULLong # (*) :: CULLong -> CULLong -> CULLong # negate :: CULLong -> CULLong # abs :: CULLong -> CULLong # signum :: CULLong -> CULLong # fromInteger :: Integer -> CULLong #
Ord CULLong
Instance details Defined in Foreign.C.Types Methods compare :: CULLong -> CULLong -> Ordering # (<) :: CULLong -> CULLong -> Bool # (<=) :: CULLong -> CULLong -> Bool # (>) :: CULLong -> CULLong -> Bool # (>=) :: CULLong -> CULLong -> Bool # max :: CULLong -> CULLong -> CULLong # min :: CULLong -> CULLong -> CULLong #
Read CULLong
Instance details Defined in Foreign.C.Types Methods readsPrec :: Int -> ReadS CULLong # readList :: ReadS [CULLong] # readPrec :: ReadPrec CULLong # readListPrec :: ReadPrec [CULLong] #
Real CULLong
Instance details Defined in Foreign.C.Types Methods toRational :: CULLong -> Rational #
Show CULLong
Instance details Defined in Foreign.C.Types Methods showsPrec :: Int -> CULLong -> ShowS # show :: CULLong -> String # showList :: [CULLong] -> ShowS #
Storable CULLong
Instance details Defined in Foreign.C.Types Methods sizeOf :: CULLong -> Int # alignment :: CULLong -> Int # peekElemOff :: Ptr CULLong -> Int -> IO CULLong # pokeElemOff :: Ptr CULLong -> Int -> CULLong -> IO () # peekByteOff :: Ptr b -> Int -> IO CULLong # pokeByteOff :: Ptr b -> Int -> CULLong -> IO () # peek :: Ptr CULLong -> IO CULLong # poke :: Ptr CULLong -> CULLong -> IO () #
Bits CULLong
Instance details Defined in Foreign.C.Types Methods (.&.) :: CULLong -> CULLong -> CULLong # (.\|.) :: CULLong -> CULLong -> CULLong # xor :: CULLong -> CULLong -> CULLong # complement :: CULLong -> CULLong # shift :: CULLong -> Int -> CULLong # rotate :: CULLong -> Int -> CULLong # zeroBits :: CULLong # bit :: Int -> CULLong # setBit :: CULLong -> Int -> CULLong # clearBit :: CULLong -> Int -> CULLong # complementBit :: CULLong -> Int -> CULLong # testBit :: CULLong -> Int -> Bool # bitSizeMaybe :: CULLong -> Maybe Int # bitSize :: CULLong -> Int # isSigned :: CULLong -> Bool # shiftL :: CULLong -> Int -> CULLong # unsafeShiftL :: CULLong -> Int -> CULLong # shiftR :: CULLong -> Int -> CULLong # unsafeShiftR :: CULLong -> Int -> CULLong # rotateL :: CULLong -> Int -> CULLong # rotateR :: CULLong -> Int -> CULLong # popCount :: CULLong -> Int #
FiniteBits CULLong
Instance details Defined in Foreign.C.Types Methods finiteBitSize :: CULLong -> Int # countLeadingZeros :: CULLong -> Int # countTrailingZeros :: CULLong -> Int #
Subtractive CULLong
Instance details Defined in Basement.Numerical.Subtractive Associated Types type Difference CULLong :: Type # Methods (-) :: CULLong -> CULLong -> Difference CULLong #
NFData CULLong	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: CULLong -> () #
Prim CULLong
Instance details Defined in Data.Primitive.Types Methods sizeOf# :: CULLong -> Int# # alignment# :: CULLong -> Int# # indexByteArray# :: ByteArray# -> Int# -> CULLong # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, CULLong#) # writeByteArray# :: MutableByteArray# s -> Int# -> CULLong -> State# s -> State# s # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> CULLong -> State# s -> State# s # indexOffAddr# :: Addr# -> Int# -> CULLong # readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, CULLong#) # writeOffAddr# :: Addr# -> Int# -> CULLong -> State# s -> State# s # setOffAddr# :: Addr# -> Int# -> Int# -> CULLong -> State# s -> State# s #
Wrapped CULLong
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped CULLong :: Type # Methods _Wrapped' :: Iso' CULLong (Unwrapped CULLong) #
IsScalar CULLong #
Instance details Defined in Data.Array.Accelerate.Type Methods scalarType :: ScalarType CULLong
IsBounded CULLong #
Instance details Defined in Data.Array.Accelerate.Type Methods boundedType :: BoundedType CULLong
IsNum CULLong #
Instance details Defined in Data.Array.Accelerate.Type Methods numType :: NumType CULLong
IsIntegral CULLong #
Instance details Defined in Data.Array.Accelerate.Type Methods integralType :: IntegralType CULLong
Elt CULLong #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods eltType :: CULLong -> TupleType (EltRepr CULLong) fromElt :: CULLong -> EltRepr CULLong toElt :: EltRepr CULLong -> CULLong
Eq CULLong #
Instance details Defined in Data.Array.Accelerate.Classes.Eq Methods (==) :: Exp CULLong -> Exp CULLong -> Exp Bool # (/=) :: Exp CULLong -> Exp CULLong -> Exp Bool #
Ord CULLong #
Instance details Defined in Data.Array.Accelerate.Classes.Ord Methods (<) :: Exp CULLong -> Exp CULLong -> Exp Bool # (>) :: Exp CULLong -> Exp CULLong -> Exp Bool # (<=) :: Exp CULLong -> Exp CULLong -> Exp Bool # (>=) :: Exp CULLong -> Exp CULLong -> Exp Bool # min :: Exp CULLong -> Exp CULLong -> Exp CULLong # max :: Exp CULLong -> Exp CULLong -> Exp CULLong # compare :: Exp CULLong -> Exp CULLong -> Exp Ordering #
FiniteBits CULLong #
Instance details Defined in Data.Array.Accelerate.Data.Bits Methods finiteBitSize :: Exp CULLong -> Exp Int # countLeadingZeros :: Exp CULLong -> Exp Int # countTrailingZeros :: Exp CULLong -> Exp Int #
Bits CULLong #
Instance details Defined in Data.Array.Accelerate.Data.Bits Methods (.&.) :: Exp CULLong -> Exp CULLong -> Exp CULLong # (.\|.) :: Exp CULLong -> Exp CULLong -> Exp CULLong # xor :: Exp CULLong -> Exp CULLong -> Exp CULLong # complement :: Exp CULLong -> Exp CULLong # shift :: Exp CULLong -> Exp Int -> Exp CULLong # rotate :: Exp CULLong -> Exp Int -> Exp CULLong # zeroBits :: Exp CULLong # bit :: Exp Int -> Exp CULLong # setBit :: Exp CULLong -> Exp Int -> Exp CULLong # clearBit :: Exp CULLong -> Exp Int -> Exp CULLong # complementBit :: Exp CULLong -> Exp Int -> Exp CULLong # testBit :: Exp CULLong -> Exp Int -> Exp Bool # isSigned :: Exp CULLong -> Exp Bool # shiftL :: Exp CULLong -> Exp Int -> Exp CULLong # unsafeShiftL :: Exp CULLong -> Exp Int -> Exp CULLong # shiftR :: Exp CULLong -> Exp Int -> Exp CULLong # unsafeShiftR :: Exp CULLong -> Exp Int -> Exp CULLong # rotateL :: Exp CULLong -> Exp Int -> Exp CULLong # rotateR :: Exp CULLong -> Exp Int -> Exp CULLong # popCount :: Exp CULLong -> Exp Int #
Rewrapped CULLong t
Instance details Defined in Control.Lens.Wrapped
Lift Exp CULLong #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain CULLong :: Type # Methods lift :: CULLong -> Exp (Plain CULLong) #
ToFloating CULLong Double #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CULLong -> Exp Double #
ToFloating CULLong Float #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CULLong -> Exp Float #
ToFloating CULLong CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CULLong -> Exp CFloat #
ToFloating CULLong CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CULLong -> Exp CDouble #
ToFloating CULLong Half #
Instance details Defined in Data.Array.Accelerate.Classes.ToFloating Methods toFloating :: Exp CULLong -> Exp Half #
FromIntegral Int CULLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int -> Exp CULLong #
FromIntegral Int8 CULLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int8 -> Exp CULLong #
FromIntegral Int16 CULLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int16 -> Exp CULLong #
FromIntegral Int32 CULLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int32 -> Exp CULLong #
FromIntegral Int64 CULLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Int64 -> Exp CULLong #
FromIntegral Word CULLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word -> Exp CULLong #
FromIntegral Word8 CULLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word8 -> Exp CULLong #
FromIntegral Word16 CULLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word16 -> Exp CULLong #
FromIntegral Word32 CULLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word32 -> Exp CULLong #
FromIntegral Word64 CULLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp Word64 -> Exp CULLong #
FromIntegral CShort CULLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CShort -> Exp CULLong #
FromIntegral CUShort CULLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUShort -> Exp CULLong #
FromIntegral CInt CULLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CInt -> Exp CULLong #
FromIntegral CUInt CULLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CUInt -> Exp CULLong #
FromIntegral CLong CULLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLong -> Exp CULLong #
FromIntegral CULong CULLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULong -> Exp CULLong #
FromIntegral CLLong CULLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CLLong -> Exp CULLong #
FromIntegral CULLong Double #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULLong -> Exp Double #
FromIntegral CULLong Float #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULLong -> Exp Float #
FromIntegral CULLong Int #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULLong -> Exp Int #
FromIntegral CULLong Int8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULLong -> Exp Int8 #
FromIntegral CULLong Int16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULLong -> Exp Int16 #
FromIntegral CULLong Int32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULLong -> Exp Int32 #
FromIntegral CULLong Int64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULLong -> Exp Int64 #
FromIntegral CULLong Word #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULLong -> Exp Word #
FromIntegral CULLong Word8 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULLong -> Exp Word8 #
FromIntegral CULLong Word16 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULLong -> Exp Word16 #
FromIntegral CULLong Word32 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULLong -> Exp Word32 #
FromIntegral CULLong Word64 #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULLong -> Exp Word64 #
FromIntegral CULLong CShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULLong -> Exp CShort #
FromIntegral CULLong CUShort #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULLong -> Exp CUShort #
FromIntegral CULLong CInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULLong -> Exp CInt #
FromIntegral CULLong CUInt #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULLong -> Exp CUInt #
FromIntegral CULLong CLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULLong -> Exp CLong #
FromIntegral CULLong CULong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULLong -> Exp CULong #
FromIntegral CULLong CLLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULLong -> Exp CLLong #
FromIntegral CULLong CULLong #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULLong -> Exp CULLong #
FromIntegral CULLong CFloat #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULLong -> Exp CFloat #
FromIntegral CULLong CDouble #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULLong -> Exp CDouble #
FromIntegral CULLong Half #
Instance details Defined in Data.Array.Accelerate.Classes.FromIntegral Methods fromIntegral :: Exp CULLong -> Exp Half #
Bounded (Exp CULLong) #
Instance details Defined in Data.Array.Accelerate.Classes.Bounded Methods minBound :: Exp CULLong # maxBound :: Exp CULLong #
Enum (Exp CULLong) #
Instance details Defined in Data.Array.Accelerate.Classes.Enum Methods succ :: Exp CULLong -> Exp CULLong # pred :: Exp CULLong -> Exp CULLong # toEnum :: Int -> Exp CULLong # fromEnum :: Exp CULLong -> Int # enumFrom :: Exp CULLong -> [Exp CULLong] # enumFromThen :: Exp CULLong -> Exp CULLong -> [Exp CULLong] # enumFromTo :: Exp CULLong -> Exp CULLong -> [Exp CULLong] # enumFromThenTo :: Exp CULLong -> Exp CULLong -> Exp CULLong -> [Exp CULLong] #
Integral (Exp CULLong) #
Instance details Defined in Data.Array.Accelerate.Classes.Integral Methods quot :: Exp CULLong -> Exp CULLong -> Exp CULLong # rem :: Exp CULLong -> Exp CULLong -> Exp CULLong # div :: Exp CULLong -> Exp CULLong -> Exp CULLong # mod :: Exp CULLong -> Exp CULLong -> Exp CULLong # quotRem :: Exp CULLong -> Exp CULLong -> (Exp CULLong, Exp CULLong) # divMod :: Exp CULLong -> Exp CULLong -> (Exp CULLong, Exp CULLong) # toInteger :: Exp CULLong -> Integer #
Num (Exp CULLong) #
Instance details Defined in Data.Array.Accelerate.Classes.Num Methods (+) :: Exp CULLong -> Exp CULLong -> Exp CULLong # (-) :: Exp CULLong -> Exp CULLong -> Exp CULLong # (*) :: Exp CULLong -> Exp CULLong -> Exp CULLong # negate :: Exp CULLong -> Exp CULLong # abs :: Exp CULLong -> Exp CULLong # signum :: Exp CULLong -> Exp CULLong # fromInteger :: Integer -> Exp CULLong #
type Difference CULLong
Instance details Defined in Basement.Numerical.Subtractive type Difference CULLong = CULLong
type Unwrapped CULLong
Instance details Defined in Control.Lens.Wrapped type Unwrapped CULLong = Word64
type Plain CULLong #
Instance details Defined in Data.Array.Accelerate.Lift type Plain CULLong = CULLong

data CChar #

Haskell type representing the C char type.

Instances

Bounded CChar
Instance details Defined in Foreign.C.Types Methods minBound :: CChar # maxBound :: CChar #
Enum CChar
Instance details Defined in Foreign.C.Types Methods succ :: CChar -> CChar # pred :: CChar -> CChar # toEnum :: Int -> CChar # fromEnum :: CChar -> Int # enumFrom :: CChar -> [CChar] # enumFromThen :: CChar -> CChar -> [CChar] # enumFromTo :: CChar -> CChar -> [CChar] # enumFromThenTo :: CChar -> CChar -> CChar -> [CChar] #
Eq CChar
Instance details Defined in Foreign.C.Types Methods (==) :: CChar -> CChar -> Bool # (/=) :: CChar -> CChar -> Bool #
Integral CChar
Instance details Defined in Foreign.C.Types Methods quot :: CChar -> CChar -> CChar # rem :: CChar -> CChar -> CChar # div :: CChar -> CChar -> CChar # mod :: CChar -> CChar -> CChar # quotRem :: CChar -> CChar -> (CChar, CChar) # divMod :: CChar -> CChar -> (CChar, CChar) # toInteger :: CChar -> Integer #
Num CChar
Instance details Defined in Foreign.C.Types Methods (+) :: CChar -> CChar -> CChar # (-) :: CChar -> CChar -> CChar # (*) :: CChar -> CChar -> CChar # negate :: CChar -> CChar # abs :: CChar -> CChar # signum :: CChar -> CChar # fromInteger :: Integer -> CChar #
Ord CChar
Instance details Defined in Foreign.C.Types Methods compare :: CChar -> CChar -> Ordering # (<) :: CChar -> CChar -> Bool # (<=) :: CChar -> CChar -> Bool # (>) :: CChar -> CChar -> Bool # (>=) :: CChar -> CChar -> Bool # max :: CChar -> CChar -> CChar # min :: CChar -> CChar -> CChar #
Read CChar
Instance details Defined in Foreign.C.Types Methods readsPrec :: Int -> ReadS CChar # readList :: ReadS [CChar] # readPrec :: ReadPrec CChar # readListPrec :: ReadPrec [CChar] #
Real CChar
Instance details Defined in Foreign.C.Types Methods toRational :: CChar -> Rational #
Show CChar
Instance details Defined in Foreign.C.Types Methods showsPrec :: Int -> CChar -> ShowS # show :: CChar -> String # showList :: [CChar] -> ShowS #
Storable CChar
Instance details Defined in Foreign.C.Types Methods sizeOf :: CChar -> Int # alignment :: CChar -> Int # peekElemOff :: Ptr CChar -> Int -> IO CChar # pokeElemOff :: Ptr CChar -> Int -> CChar -> IO () # peekByteOff :: Ptr b -> Int -> IO CChar # pokeByteOff :: Ptr b -> Int -> CChar -> IO () # peek :: Ptr CChar -> IO CChar # poke :: Ptr CChar -> CChar -> IO () #
Bits CChar
Instance details Defined in Foreign.C.Types Methods (.&.) :: CChar -> CChar -> CChar # (.\|.) :: CChar -> CChar -> CChar # xor :: CChar -> CChar -> CChar # complement :: CChar -> CChar # shift :: CChar -> Int -> CChar # rotate :: CChar -> Int -> CChar # zeroBits :: CChar # bit :: Int -> CChar # setBit :: CChar -> Int -> CChar # clearBit :: CChar -> Int -> CChar # complementBit :: CChar -> Int -> CChar # testBit :: CChar -> Int -> Bool # bitSizeMaybe :: CChar -> Maybe Int # bitSize :: CChar -> Int # isSigned :: CChar -> Bool # shiftL :: CChar -> Int -> CChar # unsafeShiftL :: CChar -> Int -> CChar # shiftR :: CChar -> Int -> CChar # unsafeShiftR :: CChar -> Int -> CChar # rotateL :: CChar -> Int -> CChar # rotateR :: CChar -> Int -> CChar # popCount :: CChar -> Int #
FiniteBits CChar
Instance details Defined in Foreign.C.Types Methods finiteBitSize :: CChar -> Int # countLeadingZeros :: CChar -> Int # countTrailingZeros :: CChar -> Int #
PrimType CChar
Instance details Defined in Basement.PrimType Associated Types type PrimSize CChar :: Nat # Methods primSizeInBytes :: Proxy CChar -> CountOf Word8 # primShiftToBytes :: Proxy CChar -> Int # primBaUIndex :: ByteArray# -> Offset CChar -> CChar # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset CChar -> prim CChar # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset CChar -> CChar -> prim () # primAddrIndex :: Addr# -> Offset CChar -> CChar # primAddrRead :: PrimMonad prim => Addr# -> Offset CChar -> prim CChar # primAddrWrite :: PrimMonad prim => Addr# -> Offset CChar -> CChar -> prim () #
PrimMemoryComparable CChar
Instance details Defined in Basement.PrimType
Subtractive CChar
Instance details Defined in Basement.Numerical.Subtractive Associated Types type Difference CChar :: Type # Methods (-) :: CChar -> CChar -> Difference CChar #
NFData CChar	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: CChar -> () #
Prim CChar
Instance details Defined in Data.Primitive.Types Methods sizeOf# :: CChar -> Int# # alignment# :: CChar -> Int# # indexByteArray# :: ByteArray# -> Int# -> CChar # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, CChar#) # writeByteArray# :: MutableByteArray# s -> Int# -> CChar -> State# s -> State# s # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> CChar -> State# s -> State# s # indexOffAddr# :: Addr# -> Int# -> CChar # readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, CChar#) # writeOffAddr# :: Addr# -> Int# -> CChar -> State# s -> State# s # setOffAddr# :: Addr# -> Int# -> Int# -> CChar -> State# s -> State# s #
Wrapped CChar
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped CChar :: Type # Methods _Wrapped' :: Iso' CChar (Unwrapped CChar) #
IsScalar CChar #
Instance details Defined in Data.Array.Accelerate.Type Methods scalarType :: ScalarType CChar
IsBounded CChar #
Instance details Defined in Data.Array.Accelerate.Type Methods boundedType :: BoundedType CChar
IsNonNum CChar #
Instance details Defined in Data.Array.Accelerate.Type Methods nonNumType :: NonNumType CChar
Elt CChar #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods eltType :: CChar -> TupleType (EltRepr CChar) fromElt :: CChar -> EltRepr CChar toElt :: EltRepr CChar -> CChar
Eq CChar #
Instance details Defined in Data.Array.Accelerate.Classes.Eq Methods (==) :: Exp CChar -> Exp CChar -> Exp Bool # (/=) :: Exp CChar -> Exp CChar -> Exp Bool #
Ord CChar #
Instance details Defined in Data.Array.Accelerate.Classes.Ord Methods (<) :: Exp CChar -> Exp CChar -> Exp Bool # (>) :: Exp CChar -> Exp CChar -> Exp Bool # (<=) :: Exp CChar -> Exp CChar -> Exp Bool # (>=) :: Exp CChar -> Exp CChar -> Exp Bool # min :: Exp CChar -> Exp CChar -> Exp CChar # max :: Exp CChar -> Exp CChar -> Exp CChar # compare :: Exp CChar -> Exp CChar -> Exp Ordering #
Rewrapped CChar t
Instance details Defined in Control.Lens.Wrapped
Lift Exp CChar #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain CChar :: Type # Methods lift :: CChar -> Exp (Plain CChar) #
Bounded (Exp CChar) #
Instance details Defined in Data.Array.Accelerate.Classes.Bounded Methods minBound :: Exp CChar # maxBound :: Exp CChar #
type PrimSize CChar
Instance details Defined in Basement.PrimType type PrimSize CChar = 1
type Difference CChar
Instance details Defined in Basement.Numerical.Subtractive type Difference CChar = CChar
type Unwrapped CChar
Instance details Defined in Control.Lens.Wrapped type Unwrapped CChar = Int8
type Plain CChar #
Instance details Defined in Data.Array.Accelerate.Lift type Plain CChar = CChar

data CSChar #

Haskell type representing the C signed char type.

Instances

Bounded CSChar
Instance details Defined in Foreign.C.Types Methods minBound :: CSChar # maxBound :: CSChar #
Enum CSChar
Instance details Defined in Foreign.C.Types Methods succ :: CSChar -> CSChar # pred :: CSChar -> CSChar # toEnum :: Int -> CSChar # fromEnum :: CSChar -> Int # enumFrom :: CSChar -> [CSChar] # enumFromThen :: CSChar -> CSChar -> [CSChar] # enumFromTo :: CSChar -> CSChar -> [CSChar] # enumFromThenTo :: CSChar -> CSChar -> CSChar -> [CSChar] #
Eq CSChar
Instance details Defined in Foreign.C.Types Methods (==) :: CSChar -> CSChar -> Bool # (/=) :: CSChar -> CSChar -> Bool #
Integral CSChar
Instance details Defined in Foreign.C.Types Methods quot :: CSChar -> CSChar -> CSChar # rem :: CSChar -> CSChar -> CSChar # div :: CSChar -> CSChar -> CSChar # mod :: CSChar -> CSChar -> CSChar # quotRem :: CSChar -> CSChar -> (CSChar, CSChar) # divMod :: CSChar -> CSChar -> (CSChar, CSChar) # toInteger :: CSChar -> Integer #
Num CSChar
Instance details Defined in Foreign.C.Types Methods (+) :: CSChar -> CSChar -> CSChar # (-) :: CSChar -> CSChar -> CSChar # (*) :: CSChar -> CSChar -> CSChar # negate :: CSChar -> CSChar # abs :: CSChar -> CSChar # signum :: CSChar -> CSChar # fromInteger :: Integer -> CSChar #
Ord CSChar
Instance details Defined in Foreign.C.Types Methods compare :: CSChar -> CSChar -> Ordering # (<) :: CSChar -> CSChar -> Bool # (<=) :: CSChar -> CSChar -> Bool # (>) :: CSChar -> CSChar -> Bool # (>=) :: CSChar -> CSChar -> Bool # max :: CSChar -> CSChar -> CSChar # min :: CSChar -> CSChar -> CSChar #
Read CSChar
Instance details Defined in Foreign.C.Types Methods readsPrec :: Int -> ReadS CSChar # readList :: ReadS [CSChar] # readPrec :: ReadPrec CSChar # readListPrec :: ReadPrec [CSChar] #
Real CSChar
Instance details Defined in Foreign.C.Types Methods toRational :: CSChar -> Rational #
Show CSChar
Instance details Defined in Foreign.C.Types Methods showsPrec :: Int -> CSChar -> ShowS # show :: CSChar -> String # showList :: [CSChar] -> ShowS #
Storable CSChar
Instance details Defined in Foreign.C.Types Methods sizeOf :: CSChar -> Int # alignment :: CSChar -> Int # peekElemOff :: Ptr CSChar -> Int -> IO CSChar # pokeElemOff :: Ptr CSChar -> Int -> CSChar -> IO () # peekByteOff :: Ptr b -> Int -> IO CSChar # pokeByteOff :: Ptr b -> Int -> CSChar -> IO () # peek :: Ptr CSChar -> IO CSChar # poke :: Ptr CSChar -> CSChar -> IO () #
Bits CSChar
Instance details Defined in Foreign.C.Types Methods (.&.) :: CSChar -> CSChar -> CSChar # (.\|.) :: CSChar -> CSChar -> CSChar # xor :: CSChar -> CSChar -> CSChar # complement :: CSChar -> CSChar # shift :: CSChar -> Int -> CSChar # rotate :: CSChar -> Int -> CSChar # zeroBits :: CSChar # bit :: Int -> CSChar # setBit :: CSChar -> Int -> CSChar # clearBit :: CSChar -> Int -> CSChar # complementBit :: CSChar -> Int -> CSChar # testBit :: CSChar -> Int -> Bool # bitSizeMaybe :: CSChar -> Maybe Int # bitSize :: CSChar -> Int # isSigned :: CSChar -> Bool # shiftL :: CSChar -> Int -> CSChar # unsafeShiftL :: CSChar -> Int -> CSChar # shiftR :: CSChar -> Int -> CSChar # unsafeShiftR :: CSChar -> Int -> CSChar # rotateL :: CSChar -> Int -> CSChar # rotateR :: CSChar -> Int -> CSChar # popCount :: CSChar -> Int #
FiniteBits CSChar
Instance details Defined in Foreign.C.Types Methods finiteBitSize :: CSChar -> Int # countLeadingZeros :: CSChar -> Int # countTrailingZeros :: CSChar -> Int #
Subtractive CSChar
Instance details Defined in Basement.Numerical.Subtractive Associated Types type Difference CSChar :: Type # Methods (-) :: CSChar -> CSChar -> Difference CSChar #
NFData CSChar	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: CSChar -> () #
Prim CSChar
Instance details Defined in Data.Primitive.Types Methods sizeOf# :: CSChar -> Int# # alignment# :: CSChar -> Int# # indexByteArray# :: ByteArray# -> Int# -> CSChar # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, CSChar#) # writeByteArray# :: MutableByteArray# s -> Int# -> CSChar -> State# s -> State# s # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> CSChar -> State# s -> State# s # indexOffAddr# :: Addr# -> Int# -> CSChar # readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, CSChar#) # writeOffAddr# :: Addr# -> Int# -> CSChar -> State# s -> State# s # setOffAddr# :: Addr# -> Int# -> Int# -> CSChar -> State# s -> State# s #
Wrapped CSChar
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped CSChar :: Type # Methods _Wrapped' :: Iso' CSChar (Unwrapped CSChar) #
IsScalar CSChar #
Instance details Defined in Data.Array.Accelerate.Type Methods scalarType :: ScalarType CSChar
IsBounded CSChar #
Instance details Defined in Data.Array.Accelerate.Type Methods boundedType :: BoundedType CSChar
IsNonNum CSChar #
Instance details Defined in Data.Array.Accelerate.Type Methods nonNumType :: NonNumType CSChar
Elt CSChar #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods eltType :: CSChar -> TupleType (EltRepr CSChar) fromElt :: CSChar -> EltRepr CSChar toElt :: EltRepr CSChar -> CSChar
Eq CSChar #
Instance details Defined in Data.Array.Accelerate.Classes.Eq Methods (==) :: Exp CSChar -> Exp CSChar -> Exp Bool # (/=) :: Exp CSChar -> Exp CSChar -> Exp Bool #
Ord CSChar #
Instance details Defined in Data.Array.Accelerate.Classes.Ord Methods (<) :: Exp CSChar -> Exp CSChar -> Exp Bool # (>) :: Exp CSChar -> Exp CSChar -> Exp Bool # (<=) :: Exp CSChar -> Exp CSChar -> Exp Bool # (>=) :: Exp CSChar -> Exp CSChar -> Exp Bool # min :: Exp CSChar -> Exp CSChar -> Exp CSChar # max :: Exp CSChar -> Exp CSChar -> Exp CSChar # compare :: Exp CSChar -> Exp CSChar -> Exp Ordering #
Rewrapped CSChar t
Instance details Defined in Control.Lens.Wrapped
Lift Exp CSChar #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain CSChar :: Type # Methods lift :: CSChar -> Exp (Plain CSChar) #
Bounded (Exp CSChar) #
Instance details Defined in Data.Array.Accelerate.Classes.Bounded Methods minBound :: Exp CSChar # maxBound :: Exp CSChar #
type Difference CSChar
Instance details Defined in Basement.Numerical.Subtractive type Difference CSChar = CSChar
type Unwrapped CSChar
Instance details Defined in Control.Lens.Wrapped type Unwrapped CSChar = Int8
type Plain CSChar #
Instance details Defined in Data.Array.Accelerate.Lift type Plain CSChar = CSChar

data CUChar #

Haskell type representing the C unsigned char type.

Instances

Bounded CUChar
Instance details Defined in Foreign.C.Types Methods minBound :: CUChar # maxBound :: CUChar #
Enum CUChar
Instance details Defined in Foreign.C.Types Methods succ :: CUChar -> CUChar # pred :: CUChar -> CUChar # toEnum :: Int -> CUChar # fromEnum :: CUChar -> Int # enumFrom :: CUChar -> [CUChar] # enumFromThen :: CUChar -> CUChar -> [CUChar] # enumFromTo :: CUChar -> CUChar -> [CUChar] # enumFromThenTo :: CUChar -> CUChar -> CUChar -> [CUChar] #
Eq CUChar
Instance details Defined in Foreign.C.Types Methods (==) :: CUChar -> CUChar -> Bool # (/=) :: CUChar -> CUChar -> Bool #
Integral CUChar
Instance details Defined in Foreign.C.Types Methods quot :: CUChar -> CUChar -> CUChar # rem :: CUChar -> CUChar -> CUChar # div :: CUChar -> CUChar -> CUChar # mod :: CUChar -> CUChar -> CUChar # quotRem :: CUChar -> CUChar -> (CUChar, CUChar) # divMod :: CUChar -> CUChar -> (CUChar, CUChar) # toInteger :: CUChar -> Integer #
Num CUChar
Instance details Defined in Foreign.C.Types Methods (+) :: CUChar -> CUChar -> CUChar # (-) :: CUChar -> CUChar -> CUChar # (*) :: CUChar -> CUChar -> CUChar # negate :: CUChar -> CUChar # abs :: CUChar -> CUChar # signum :: CUChar -> CUChar # fromInteger :: Integer -> CUChar #
Ord CUChar
Instance details Defined in Foreign.C.Types Methods compare :: CUChar -> CUChar -> Ordering # (<) :: CUChar -> CUChar -> Bool # (<=) :: CUChar -> CUChar -> Bool # (>) :: CUChar -> CUChar -> Bool # (>=) :: CUChar -> CUChar -> Bool # max :: CUChar -> CUChar -> CUChar # min :: CUChar -> CUChar -> CUChar #
Read CUChar
Instance details Defined in Foreign.C.Types Methods readsPrec :: Int -> ReadS CUChar # readList :: ReadS [CUChar] # readPrec :: ReadPrec CUChar # readListPrec :: ReadPrec [CUChar] #
Real CUChar
Instance details Defined in Foreign.C.Types Methods toRational :: CUChar -> Rational #
Show CUChar
Instance details Defined in Foreign.C.Types Methods showsPrec :: Int -> CUChar -> ShowS # show :: CUChar -> String # showList :: [CUChar] -> ShowS #
Storable CUChar
Instance details Defined in Foreign.C.Types Methods sizeOf :: CUChar -> Int # alignment :: CUChar -> Int # peekElemOff :: Ptr CUChar -> Int -> IO CUChar # pokeElemOff :: Ptr CUChar -> Int -> CUChar -> IO () # peekByteOff :: Ptr b -> Int -> IO CUChar # pokeByteOff :: Ptr b -> Int -> CUChar -> IO () # peek :: Ptr CUChar -> IO CUChar # poke :: Ptr CUChar -> CUChar -> IO () #
Bits CUChar
Instance details Defined in Foreign.C.Types Methods (.&.) :: CUChar -> CUChar -> CUChar # (.\|.) :: CUChar -> CUChar -> CUChar # xor :: CUChar -> CUChar -> CUChar # complement :: CUChar -> CUChar # shift :: CUChar -> Int -> CUChar # rotate :: CUChar -> Int -> CUChar # zeroBits :: CUChar # bit :: Int -> CUChar # setBit :: CUChar -> Int -> CUChar # clearBit :: CUChar -> Int -> CUChar # complementBit :: CUChar -> Int -> CUChar # testBit :: CUChar -> Int -> Bool # bitSizeMaybe :: CUChar -> Maybe Int # bitSize :: CUChar -> Int # isSigned :: CUChar -> Bool # shiftL :: CUChar -> Int -> CUChar # unsafeShiftL :: CUChar -> Int -> CUChar # shiftR :: CUChar -> Int -> CUChar # unsafeShiftR :: CUChar -> Int -> CUChar # rotateL :: CUChar -> Int -> CUChar # rotateR :: CUChar -> Int -> CUChar # popCount :: CUChar -> Int #
FiniteBits CUChar
Instance details Defined in Foreign.C.Types Methods finiteBitSize :: CUChar -> Int # countLeadingZeros :: CUChar -> Int # countTrailingZeros :: CUChar -> Int #
PrimType CUChar
Instance details Defined in Basement.PrimType Associated Types type PrimSize CUChar :: Nat # Methods primSizeInBytes :: Proxy CUChar -> CountOf Word8 # primShiftToBytes :: Proxy CUChar -> Int # primBaUIndex :: ByteArray# -> Offset CUChar -> CUChar # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset CUChar -> prim CUChar # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset CUChar -> CUChar -> prim () # primAddrIndex :: Addr# -> Offset CUChar -> CUChar # primAddrRead :: PrimMonad prim => Addr# -> Offset CUChar -> prim CUChar # primAddrWrite :: PrimMonad prim => Addr# -> Offset CUChar -> CUChar -> prim () #
PrimMemoryComparable CUChar
Instance details Defined in Basement.PrimType
Subtractive CUChar
Instance details Defined in Basement.Numerical.Subtractive Associated Types type Difference CUChar :: Type # Methods (-) :: CUChar -> CUChar -> Difference CUChar #
NFData CUChar	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: CUChar -> () #
Prim CUChar
Instance details Defined in Data.Primitive.Types Methods sizeOf# :: CUChar -> Int# # alignment# :: CUChar -> Int# # indexByteArray# :: ByteArray# -> Int# -> CUChar # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, CUChar#) # writeByteArray# :: MutableByteArray# s -> Int# -> CUChar -> State# s -> State# s # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> CUChar -> State# s -> State# s # indexOffAddr# :: Addr# -> Int# -> CUChar # readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, CUChar#) # writeOffAddr# :: Addr# -> Int# -> CUChar -> State# s -> State# s # setOffAddr# :: Addr# -> Int# -> Int# -> CUChar -> State# s -> State# s #
Wrapped CUChar
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped CUChar :: Type # Methods _Wrapped' :: Iso' CUChar (Unwrapped CUChar) #
IsScalar CUChar #
Instance details Defined in Data.Array.Accelerate.Type Methods scalarType :: ScalarType CUChar
IsBounded CUChar #
Instance details Defined in Data.Array.Accelerate.Type Methods boundedType :: BoundedType CUChar
IsNonNum CUChar #
Instance details Defined in Data.Array.Accelerate.Type Methods nonNumType :: NonNumType CUChar
Elt CUChar #
Instance details Defined in Data.Array.Accelerate.Array.Sugar Methods eltType :: CUChar -> TupleType (EltRepr CUChar) fromElt :: CUChar -> EltRepr CUChar toElt :: EltRepr CUChar -> CUChar
Eq CUChar #
Instance details Defined in Data.Array.Accelerate.Classes.Eq Methods (==) :: Exp CUChar -> Exp CUChar -> Exp Bool # (/=) :: Exp CUChar -> Exp CUChar -> Exp Bool #
Ord CUChar #
Instance details Defined in Data.Array.Accelerate.Classes.Ord Methods (<) :: Exp CUChar -> Exp CUChar -> Exp Bool # (>) :: Exp CUChar -> Exp CUChar -> Exp Bool # (<=) :: Exp CUChar -> Exp CUChar -> Exp Bool # (>=) :: Exp CUChar -> Exp CUChar -> Exp Bool # min :: Exp CUChar -> Exp CUChar -> Exp CUChar # max :: Exp CUChar -> Exp CUChar -> Exp CUChar # compare :: Exp CUChar -> Exp CUChar -> Exp Ordering #
Rewrapped CUChar t
Instance details Defined in Control.Lens.Wrapped
Lift Exp CUChar #
Instance details Defined in Data.Array.Accelerate.Lift Associated Types type Plain CUChar :: Type # Methods lift :: CUChar -> Exp (Plain CUChar) #
Bounded (Exp CUChar) #
Instance details Defined in Data.Array.Accelerate.Classes.Bounded Methods minBound :: Exp CUChar # maxBound :: Exp CUChar #
type PrimSize CUChar
Instance details Defined in Basement.PrimType type PrimSize CUChar = 1
type Difference CUChar
Instance details Defined in Basement.Numerical.Subtractive type Difference CUChar = CUChar
type Unwrapped CUChar
Instance details Defined in Control.Lens.Wrapped type Unwrapped CUChar = Word8
type Plain CUChar #
Instance details Defined in Data.Array.Accelerate.Lift 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 #
Instance details Defined in Data.Array.Accelerate.Type Methods scalarType :: ScalarType Bool
IsScalar Char #
Instance details Defined in Data.Array.Accelerate.Type Methods scalarType :: ScalarType Char
IsScalar Double #
Instance details Defined in Data.Array.Accelerate.Type Methods scalarType :: ScalarType Double
IsScalar Float #
Instance details Defined in Data.Array.Accelerate.Type Methods scalarType :: ScalarType Float
IsScalar Int #
Instance details Defined in Data.Array.Accelerate.Type Methods scalarType :: ScalarType Int
IsScalar Int8 #
Instance details Defined in Data.Array.Accelerate.Type Methods scalarType :: ScalarType Int8
IsScalar Int16 #
Instance details Defined in Data.Array.Accelerate.Type Methods scalarType :: ScalarType Int16
IsScalar Int32 #
Instance details Defined in Data.Array.Accelerate.Type Methods scalarType :: ScalarType Int32
IsScalar Int64 #
Instance details Defined in Data.Array.Accelerate.Type Methods scalarType :: ScalarType Int64
IsScalar Word #
Instance details Defined in Data.Array.Accelerate.Type Methods scalarType :: ScalarType Word
IsScalar Word8 #
Instance details Defined in Data.Array.Accelerate.Type Methods scalarType :: ScalarType Word8
IsScalar Word16 #
Instance details Defined in Data.Array.Accelerate.Type Methods scalarType :: ScalarType Word16
IsScalar Word32 #
Instance details Defined in Data.Array.Accelerate.Type Methods scalarType :: ScalarType Word32
IsScalar Word64 #
Instance details Defined in Data.Array.Accelerate.Type Methods scalarType :: ScalarType Word64
IsScalar CChar #
Instance details Defined in Data.Array.Accelerate.Type Methods scalarType :: ScalarType CChar
IsScalar CSChar #
Instance details Defined in Data.Array.Accelerate.Type Methods scalarType :: ScalarType CSChar
IsScalar CUChar #
Instance details Defined in Data.Array.Accelerate.Type Methods scalarType :: ScalarType CUChar
IsScalar CShort #
Instance details Defined in Data.Array.Accelerate.Type Methods scalarType :: ScalarType CShort
IsScalar CUShort #
Instance details Defined in Data.Array.Accelerate.Type Methods scalarType :: ScalarType CUShort
IsScalar CInt #
Instance details Defined in Data.Array.Accelerate.Type Methods scalarType :: ScalarType CInt
IsScalar CUInt #
Instance details Defined in Data.Array.Accelerate.Type Methods scalarType :: ScalarType CUInt
IsScalar CLong #
Instance details Defined in Data.Array.Accelerate.Type Methods scalarType :: ScalarType CLong
IsScalar CULong #
Instance details Defined in Data.Array.Accelerate.Type Methods scalarType :: ScalarType CULong
IsScalar CLLong #
Instance details Defined in Data.Array.Accelerate.Type Methods scalarType :: ScalarType CLLong
IsScalar CULLong #
Instance details Defined in Data.Array.Accelerate.Type Methods scalarType :: ScalarType CULLong
IsScalar CFloat #
Instance details Defined in Data.Array.Accelerate.Type Methods scalarType :: ScalarType CFloat
IsScalar CDouble #
Instance details Defined in Data.Array.Accelerate.Type Methods scalarType :: ScalarType CDouble
IsScalar Half #
Instance details Defined in Data.Array.Accelerate.Type Methods scalarType :: ScalarType Half

class (Num a, IsSingle a) => IsNum a #

Numeric types

Minimal complete definition

numType

Instances

IsNum Double #
Instance details Defined in Data.Array.Accelerate.Type Methods numType :: NumType Double
IsNum Float #
Instance details Defined in Data.Array.Accelerate.Type Methods numType :: NumType Float
IsNum Int #
Instance details Defined in Data.Array.Accelerate.Type Methods numType :: NumType Int
IsNum Int8 #
Instance details Defined in Data.Array.Accelerate.Type Methods numType :: NumType Int8
IsNum Int16 #
Instance details Defined in Data.Array.Accelerate.Type Methods numType :: NumType Int16
IsNum Int32 #
Instance details Defined in Data.Array.Accelerate.Type Methods numType :: NumType Int32
IsNum Int64 #
Instance details Defined in Data.Array.Accelerate.Type Methods numType :: NumType Int64
IsNum Word #
Instance details Defined in Data.Array.Accelerate.Type Methods numType :: NumType Word
IsNum Word8 #
Instance details Defined in Data.Array.Accelerate.Type Methods numType :: NumType Word8
IsNum Word16 #
Instance details Defined in Data.Array.Accelerate.Type Methods numType :: NumType Word16
IsNum Word32 #
Instance details Defined in Data.Array.Accelerate.Type Methods numType :: NumType Word32
IsNum Word64 #
Instance details Defined in Data.Array.Accelerate.Type Methods numType :: NumType Word64
IsNum CShort #
Instance details Defined in Data.Array.Accelerate.Type Methods numType :: NumType CShort
IsNum CUShort #
Instance details Defined in Data.Array.Accelerate.Type Methods numType :: NumType CUShort
IsNum CInt #
Instance details Defined in Data.Array.Accelerate.Type Methods numType :: NumType CInt
IsNum CUInt #
Instance details Defined in Data.Array.Accelerate.Type Methods numType :: NumType CUInt
IsNum CLong #
Instance details Defined in Data.Array.Accelerate.Type Methods numType :: NumType CLong
IsNum CULong #
Instance details Defined in Data.Array.Accelerate.Type Methods numType :: NumType CULong
IsNum CLLong #
Instance details Defined in Data.Array.Accelerate.Type Methods numType :: NumType CLLong
IsNum CULLong #
Instance details Defined in Data.Array.Accelerate.Type Methods numType :: NumType CULLong
IsNum CFloat #
Instance details Defined in Data.Array.Accelerate.Type Methods numType :: NumType CFloat
IsNum CDouble #
Instance details Defined in Data.Array.Accelerate.Type Methods numType :: NumType CDouble
IsNum Half #
Instance details Defined in Data.Array.Accelerate.Type Methods numType :: NumType Half

class IsBounded a #

Bounded types

Minimal complete definition

boundedType

Instances

IsBounded Bool #
Instance details Defined in Data.Array.Accelerate.Type Methods boundedType :: BoundedType Bool
IsBounded Char #
Instance details Defined in Data.Array.Accelerate.Type Methods boundedType :: BoundedType Char
IsBounded Int #
Instance details Defined in Data.Array.Accelerate.Type Methods boundedType :: BoundedType Int
IsBounded Int8 #
Instance details Defined in Data.Array.Accelerate.Type Methods boundedType :: BoundedType Int8
IsBounded Int16 #
Instance details Defined in Data.Array.Accelerate.Type Methods boundedType :: BoundedType Int16
IsBounded Int32 #
Instance details Defined in Data.Array.Accelerate.Type Methods boundedType :: BoundedType Int32
IsBounded Int64 #
Instance details Defined in Data.Array.Accelerate.Type Methods boundedType :: BoundedType Int64
IsBounded Word #
Instance details Defined in Data.Array.Accelerate.Type Methods boundedType :: BoundedType Word
IsBounded Word8 #
Instance details Defined in Data.Array.Accelerate.Type Methods boundedType :: BoundedType Word8
IsBounded Word16 #
Instance details Defined in Data.Array.Accelerate.Type Methods boundedType :: BoundedType Word16
IsBounded Word32 #
Instance details Defined in Data.Array.Accelerate.Type Methods boundedType :: BoundedType Word32
IsBounded Word64 #
Instance details Defined in Data.Array.Accelerate.Type Methods boundedType :: BoundedType Word64
IsBounded CChar #
Instance details Defined in Data.Array.Accelerate.Type Methods boundedType :: BoundedType CChar
IsBounded CSChar #
Instance details Defined in Data.Array.Accelerate.Type Methods boundedType :: BoundedType CSChar
IsBounded CUChar #
Instance details Defined in Data.Array.Accelerate.Type Methods boundedType :: BoundedType CUChar
IsBounded CShort #
Instance details Defined in Data.Array.Accelerate.Type Methods boundedType :: BoundedType CShort
IsBounded CUShort #
Instance details Defined in Data.Array.Accelerate.Type Methods boundedType :: BoundedType CUShort
IsBounded CInt #
Instance details Defined in Data.Array.Accelerate.Type Methods boundedType :: BoundedType CInt
IsBounded CUInt #
Instance details Defined in Data.Array.Accelerate.Type Methods boundedType :: BoundedType CUInt
IsBounded CLong #
Instance details Defined in Data.Array.Accelerate.Type Methods boundedType :: BoundedType CLong
IsBounded CULong #
Instance details Defined in Data.Array.Accelerate.Type Methods boundedType :: BoundedType CULong
IsBounded CLLong #
Instance details Defined in Data.Array.Accelerate.Type Methods boundedType :: BoundedType CLLong
IsBounded CULLong #
Instance details Defined in Data.Array.Accelerate.Type Methods boundedType :: BoundedType CULLong

class (IsSingle a, IsNum a, IsBounded a) => IsIntegral a #

Integral types

Minimal complete definition

integralType

Instances

IsIntegral Int #
Instance details Defined in Data.Array.Accelerate.Type Methods integralType :: IntegralType Int
IsIntegral Int8 #
Instance details Defined in Data.Array.Accelerate.Type Methods integralType :: IntegralType Int8
IsIntegral Int16 #
Instance details Defined in Data.Array.Accelerate.Type Methods integralType :: IntegralType Int16
IsIntegral Int32 #
Instance details Defined in Data.Array.Accelerate.Type Methods integralType :: IntegralType Int32
IsIntegral Int64 #
Instance details Defined in Data.Array.Accelerate.Type Methods integralType :: IntegralType Int64
IsIntegral Word #
Instance details Defined in Data.Array.Accelerate.Type Methods integralType :: IntegralType Word
IsIntegral Word8 #
Instance details Defined in Data.Array.Accelerate.Type Methods integralType :: IntegralType Word8
IsIntegral Word16 #
Instance details Defined in Data.Array.Accelerate.Type Methods integralType :: IntegralType Word16
IsIntegral Word32 #
Instance details Defined in Data.Array.Accelerate.Type Methods integralType :: IntegralType Word32
IsIntegral Word64 #
Instance details Defined in Data.Array.Accelerate.Type Methods integralType :: IntegralType Word64
IsIntegral CShort #
Instance details Defined in Data.Array.Accelerate.Type Methods integralType :: IntegralType CShort
IsIntegral CUShort #
Instance details Defined in Data.Array.Accelerate.Type Methods integralType :: IntegralType CUShort
IsIntegral CInt #
Instance details Defined in Data.Array.Accelerate.Type Methods integralType :: IntegralType CInt
IsIntegral CUInt #
Instance details Defined in Data.Array.Accelerate.Type Methods integralType :: IntegralType CUInt
IsIntegral CLong #
Instance details Defined in Data.Array.Accelerate.Type Methods integralType :: IntegralType CLong
IsIntegral CULong #
Instance details Defined in Data.Array.Accelerate.Type Methods integralType :: IntegralType CULong
IsIntegral CLLong #
Instance details Defined in Data.Array.Accelerate.Type Methods integralType :: IntegralType CLLong
IsIntegral CULLong #
Instance details Defined in Data.Array.Accelerate.Type Methods integralType :: IntegralType CULLong

class (Floating a, IsSingle a, IsNum a) => IsFloating a #

Floating types

Minimal complete definition

floatingType

Instances

IsFloating Double #
Instance details Defined in Data.Array.Accelerate.Type Methods floatingType :: FloatingType Double
IsFloating Float #
Instance details Defined in Data.Array.Accelerate.Type Methods floatingType :: FloatingType Float
IsFloating CFloat #
Instance details Defined in Data.Array.Accelerate.Type Methods floatingType :: FloatingType CFloat
IsFloating CDouble #
Instance details Defined in Data.Array.Accelerate.Type Methods floatingType :: FloatingType CDouble
IsFloating Half #
Instance details Defined in Data.Array.Accelerate.Type Methods floatingType :: FloatingType Half

class IsNonNum a #

Non-numeric types

Minimal complete definition

nonNumType

Instances

IsNonNum Bool #
Instance details Defined in Data.Array.Accelerate.Type Methods nonNumType :: NonNumType Bool
IsNonNum Char #
Instance details Defined in Data.Array.Accelerate.Type Methods nonNumType :: NonNumType Char
IsNonNum CChar #
Instance details Defined in Data.Array.Accelerate.Type Methods nonNumType :: NonNumType CChar
IsNonNum CSChar #
Instance details Defined in Data.Array.Accelerate.Type Methods nonNumType :: NonNumType CSChar
IsNonNum CUChar #
Instance details Defined in Data.Array.Accelerate.Type Methods nonNumType :: NonNumType CUChar