Safe Haskell | Safe-Infered |
---|

- 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, Shape sh, Source r2 c, Source r1 c) => Array r1 sh c -> Array r2 sh c -> Array D sh c
- (-^) :: (Num c, Shape sh, Source r2 c, Source r1 c) => Array r1 sh c -> Array r2 sh c -> Array D sh c
- (*^) :: (Num c, Shape sh, Source r2 c, Source r1 c) => Array r1 sh c -> Array r2 sh c -> Array D sh c
- (/^) :: (Fractional c, Shape sh, Source r2 c, Source r1 c) => Array r1 sh c -> Array r2 sh c -> Array D sh c
- class Structured r1 a b where

# Generic maps

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

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 cSource

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, Shape sh, Source r2 c, Source r1 c) => Array r1 sh c -> Array r2 sh c -> Array D sh cSource

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

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

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

# Structured maps

class Structured r1 a b whereSource

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 bSource

Structured `map`

.

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

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 (S r1) a b | |

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