Data.Array.Knead.Index.Nested.Shape

Documentation

class C sh => C sh where

Associated Types

type Index sh :: *

Methods

intersectCode :: T sh -> T sh -> CodeGenFunction r (T sh)

sizeCode :: T sh -> CodeGenFunction r (Value Word32)

size :: sh -> Int

flattenIndexRec :: T sh -> T (Index sh) -> CodeGenFunction r (Value Word32, Value Word32)

Result is (size, flattenedIndex). size must equal the result of sizeCode. We use this for sharing intermediate results.

loop :: (Index sh ~ ix, Phi state) => (T ix -> state -> CodeGenFunction r state) -> T sh -> state -> CodeGenFunction r state

Instances

C Int32

Array dimensions and indexes cannot be negative, but computations in indices may temporarily yield negative values or we want to add negative values to indices.

Maybe we should better have type Index Word64 = Int64?

C Int64

C Word32

C Word64

C ()

(Integral n, ToSize n) => C (Shifted n)

(Integral n, ToSize n) => C (Range n)

(C n, C m) => C (n, m)

(~ * tag ShapeTag, C sh) => C (T tag sh)

(C n, C m, C l) => C (n, m, l)

value :: (C sh, Value val) => sh -> val sh

paramWith :: (Storable b, C b, Value val) => T p b -> (forall parameters. (Storable parameters, C parameters) => (p -> parameters) -> (T parameters -> val b) -> a) -> a

load :: C sh => f sh -> Value (Ptr (Struct sh)) -> CodeGenFunction r (T sh)

intersect :: C sh => Exp sh -> Exp sh -> Exp sh

flattenIndex :: C sh => T sh -> T (Index sh) -> CodeGenFunction r (Value Word32)

data Range n

Range denotes an inclusive range like those of the Haskell 98 standard Array type from the array package. E.g. the shape type (Range Int32, Range Int64) is equivalent to the ix type (Int32, Int64) for Arrays.

Constructors

Range n n

Instances

C n => C (Range n)

Compose n => Compose (Range n)

Decompose pn => Decompose (Range pn)

(Integral n, ToSize n) => C (Range n)

data Shifted n

Shifted denotes a range defined by the start index and the length.

Constructors

Shifted

Fields

shiftedOffset :: n

shiftedSize :: n

Instances

C n => C (Shifted n)

Compose n => Compose (Shifted n)

Decompose pn => Decompose (Shifted pn)

(Integral n, ToSize n) => C (Shifted n)

class C sh => Scalar sh where

Methods

scalar :: Value val => val sh

zeroIndex :: Value val => f sh -> val (Index sh)

Instances

Scalar ()

(~ * tag ShapeTag, ~ * sh Z) => Scalar (T tag sh)