Safe Haskell | None |
---|---|

Language | Haskell98 |

- map :: (Shape sh, Source r a) => (a -> b) -> Array r sh a -> Array D sh b
- zipWith :: (Shape sh, Source r1 a, Source r2 b) => (a -> b -> c) -> Array r1 sh a -> Array r2 sh b -> Array D sh c
- (+^) :: (Num c, Source r2 c, Source r1 c, Shape sh) => Array r1 sh c -> Array r2 sh c -> Array D sh c
- (-^) :: (Num c, Source r2 c, Source r1 c, Shape sh) => Array r1 sh c -> Array r2 sh c -> Array D sh c
- (*^) :: (Num c, Source r2 c, Source r1 c, Shape sh) => Array r1 sh c -> Array r2 sh c -> Array D sh c
- (/^) :: (Fractional c, Source r2 c, Source r1 c, Shape sh) => Array r1 sh c -> Array r2 sh c -> Array D sh c
- class Structured r1 a b where
- type TR r1

# Generic maps

map :: (Shape sh, Source r a) => (a -> b) -> Array r sh a -> Array D sh b #

Apply a worker function to each element of an array, yielding a new array with the same extent.

zipWith :: (Shape sh, Source r1 a, Source r2 b) => (a -> b -> c) -> Array r1 sh a -> Array r2 sh b -> Array D sh c #

Combine two arrays, element-wise, with a binary operator. If the extent of the two array arguments differ, then the resulting array's extent is their intersection.

(+^) :: (Num c, Source r2 c, Source r1 c, Shape sh) => Array r1 sh c -> Array r2 sh c -> Array D sh c infixl 6 #

(-^) :: (Num c, Source r2 c, Source r1 c, Shape sh) => Array r1 sh c -> Array r2 sh c -> Array D sh c infixl 6 #

(*^) :: (Num c, Source r2 c, Source r1 c, Shape sh) => Array r1 sh c -> Array r2 sh c -> Array D sh c infixl 7 #

(/^) :: (Fractional c, Source r2 c, Source r1 c, Shape sh) => Array r1 sh c -> Array r2 sh c -> Array D sh c infixl 7 #

# Structured maps

class Structured r1 a b where #

Structured versions of `map`

and `zipWith`

that preserve the representation
of cursored and partitioned arrays.

For cursored (`C`

) arrays, the cursoring of the source array is preserved.

For partitioned (`P`

) arrays, the worker function is fused with each array
partition separately, instead of treating the whole array as a single
bulk object.

Preserving the cursored and/or paritioned representation of an array
is will make follow-on computation more efficient than if the array was
converted to a vanilla Delayed (`D`

) array as with plain `map`

and `zipWith`

.

If the source array is not cursored or partitioned then `smap`

and
`szipWith`

are identical to the plain functions.

smap :: Shape sh => (a -> b) -> Array r1 sh a -> Array (TR r1) sh b #

Structured `map`

.

szipWith :: (Shape sh, Source r c) => (c -> a -> b) -> Array r sh c -> Array r1 sh a -> Array (TR r1) sh b #

Structured `zipWith`

.
If you have a cursored or partitioned source array then use that as
the third argument (corresponding to `r1`

here)

Structured D a b # | |

Structured B Word8 b # | |

Storable a => Structured F a b # | |

Unbox a => Structured U a b # | |

Structured X a b # | |

Structured C a b # | |

Structured r1 a b => Structured (I r1) a b # | |

Structured r1 a b => Structured (S r1) a b # | |

(Structured r1 a b, Structured r2 a b) => Structured (P r1 r2) a b # | |