dph-lifted-vseg-0.7.0.1: Data Parallel Haskell lifted array combinators.

Safe HaskellNone

Data.Array.Parallel.PArray.PRepr

Contents

Description

Defines the PRepr family and PA class that converts between the user level element types and our generic representation. Apart from unpackPA, the PA wrapper functions defined here all have equivalent PR versions in Data.Array.Parallel.PArray.PData, so see there for documentation.

Synopsis

Documentation

type family PRepr a

Family of Representable types. These are the types that we know how to represent generically. PRepr takes an arbitrary type and produces the generic type we use to represent it.

Instances for simple types are defined by the library. For algebraic types, it's up to the vectoriser/client module to create a suitable instance.

class PR (PRepr a) => PA a where

A PA dictionary contains the functions that we use to convert a representable type to and from its generic representation.

The conversions methods should all be O(1).

Instances

PA Bool 
PA Double 
PA Int 
PA Integer 
PA Ordering 
PA Word8 
PA () 
PA Void 
(PR (PRepr (PArray a)), PA a) => PA (PArray a) 
(PR (PRepr (Either a b)), PR a, PR b) => PA (Either a b) 
(PR (PRepr (a, b)), PA a, PA b) => PA (a, b) 
(PR (PRepr (:-> a b)), PA a, PA b) => PA (:-> a b) 
(PR (PRepr (a, b, c)), PA a, PA b, PA c) => PA (a, b, c) 
(PR (PRepr (a, b, c, d)), PA a, PA b, PA c, PA d) => PA (a, b, c, d) 
(PR (PRepr (a, b, c, d, e)), PA a, PA b, PA c, PA d, PA e) => PA (a, b, c, d, e) 
(PR (PRepr (a, b, c, d, e, f)), PA a, PA b, PA c, PA d, PA e, PA f) => PA (a, b, c, d, e, f) 
(PR (PRepr (a, b, c, d, e, f, g)), PA a, PA b, PA c, PA d, PA e, PA f, PA g) => PA (a, b, c, d, e, f, g) 

toNestedArrPRepr :: PA a => PData (PArray a) -> PData (PArray (PRepr a))

Convert a nested array to its generic representation.

House Keeping

validPA :: PA a => PData a -> Bool

nfPA :: PA a => PData a -> ()

similarPA :: PA a => a -> a -> Bool

coversPA :: PA a => Bool -> PData a -> Int -> Bool

pprpPA :: PA a => a -> Doc

pprpDataPA :: PA a => PData a -> Doc

typeRepPA :: PA a => a -> TypeRep

Constructors

emptyPA :: PA a => PData a

replicatePA :: PA a => Int -> a -> PData a

replicatesPA :: PA a => Segd -> PData a -> PData a

appendPA :: PA a => PData a -> PData a -> PData a

appendsPA :: PA a => Segd -> VSegd -> PDatas a -> VSegd -> PDatas a -> PData a

Projections

lengthPA :: PA a => PData a -> Int

indexPA :: PA a => PData a -> Int -> a

indexsPA :: PA a => PDatas a -> Array (Int, Int) -> PData a

indexvsPA :: PA a => PDatas a -> VSegd -> Array (Int, Int) -> PData a

bpermutePA :: PA a => PData a -> Array Int -> PData a

extractPA :: PA a => PData a -> Int -> Int -> PData a

extractssPA :: PA a => PDatas a -> SSegd -> PData a

extractvsPA :: PA a => PDatas a -> VSegd -> PData a

Pack and Combine

packByTagPA :: PA a => PData a -> Array Tag -> Tag -> PData a

combine2PA :: PA a => Sel2 -> PData a -> PData a -> PData a

Conversions

fromVectorPA :: PA a => Vector a -> PData a

toVectorPA :: PA a => PData a -> Vector a

PDatas

emptydPA :: PA a => PDatas a

singletondPA :: PA a => PData a -> PDatas a

lengthdPA :: PA a => PDatas a -> Int

indexdPA :: PA a => PDatas a -> Int -> PData a

appenddPA :: PA a => PDatas a -> PDatas a -> PDatas a

toVectordPA :: PA a => PDatas a -> Vector (PData a)

Nested Arrays

mkPNestedPA :: PA a => VSegd -> PDatas a -> Segd -> PData a -> PData (PArray a)

Conatruct a nested array.

concatPA :: PA a => PData (PArray a) -> PData a

concatlPA :: PA a => PData (PArray (PArray a)) -> PData (PArray a)

unconcatPA :: (PA a, PA b) => PData (PArray a) -> PData b -> PData (PArray b)

appendlPA :: PA a => PData (PArray a) -> PData (PArray a) -> PData (PArray a)

indexlPA :: PA a => PData (PArray a) -> PData Int -> PData a

slicelPA :: PA a => PData Int -> PData Int -> PData (PArray a) -> PData (PArray a)

unpackPA :: PA a => PArray a -> PData (PRepr a)

Unpack an array to reveal its representation.

Tuple Arrays

type family PRepr a

Family of Representable types. These are the types that we know how to represent generically. PRepr takes an arbitrary type and produces the generic type we use to represent it.

Instances for simple types are defined by the library. For algebraic types, it's up to the vectoriser/client module to create a suitable instance.

ziplPA :: (PA a, PA b) => PData (PArray a) -> PData (PArray b) -> PData (PArray (a, b))

Lifted zip on PData arrays.