massiv-0.1.0.0: Massiv (Массив) is an Array Library.

Copyright(c) Alexey Kuleshevich 2018
LicenseBSD3
MaintainerAlexey Kuleshevich <lehins@yandex.ru>
Stabilityexperimental
Portabilitynon-portable
Safe HaskellNone
LanguageHaskell2010

Data.Massiv.Core

Description

 

Synopsis

Documentation

data family Array r ix e :: * Source #

The array family. Representations r describes how data is arranged or computed. All arrays have a common property that each index ix always maps to the same unique element, even if that element does not exist in memory and has to be computed upon lookup. Data is always arranged in a nested fasion, depth of which is controlled by Rank ix.

Instances

Functor (Array D ix) # 

Methods

fmap :: (a -> b) -> Array D ix a -> Array D ix b #

(<$) :: a -> Array D ix b -> Array D ix a #

Functor (Array DW ix) # 

Methods

fmap :: (a -> b) -> Array DW ix a -> Array DW ix b #

(<$) :: a -> Array DW ix b -> Array DW ix a #

Functor (Array DI ix) # 

Methods

fmap :: (a -> b) -> Array DI ix a -> Array DI ix b #

(<$) :: a -> Array DI ix b -> Array DI ix a #

Index ix => Applicative (Array D ix) # 

Methods

pure :: a -> Array D ix a #

(<*>) :: Array D ix (a -> b) -> Array D ix a -> Array D ix b #

liftA2 :: (a -> b -> c) -> Array D ix a -> Array D ix b -> Array D ix c #

(*>) :: Array D ix a -> Array D ix b -> Array D ix b #

(<*) :: Array D ix a -> Array D ix b -> Array D ix a #

Index ix => Foldable (Array D ix) #

Row-major sequential folding over a delayed array.

Methods

fold :: Monoid m => Array D ix m -> m #

foldMap :: Monoid m => (a -> m) -> Array D ix a -> m #

foldr :: (a -> b -> b) -> b -> Array D ix a -> b #

foldr' :: (a -> b -> b) -> b -> Array D ix a -> b #

foldl :: (b -> a -> b) -> b -> Array D ix a -> b #

foldl' :: (b -> a -> b) -> b -> Array D ix a -> b #

foldr1 :: (a -> a -> a) -> Array D ix a -> a #

foldl1 :: (a -> a -> a) -> Array D ix a -> a #

toList :: Array D ix a -> [a] #

null :: Array D ix a -> Bool #

length :: Array D ix a -> Int #

elem :: Eq a => a -> Array D ix a -> Bool #

maximum :: Ord a => Array D ix a -> a #

minimum :: Ord a => Array D ix a -> a #

sum :: Num a => Array D ix a -> a #

product :: Num a => Array D ix a -> a #

Index ix => Foldable (Array M ix) #

Row-major sequential folding over a Manifest array.

Methods

fold :: Monoid m => Array M ix m -> m #

foldMap :: Monoid m => (a -> m) -> Array M ix a -> m #

foldr :: (a -> b -> b) -> b -> Array M ix a -> b #

foldr' :: (a -> b -> b) -> b -> Array M ix a -> b #

foldl :: (b -> a -> b) -> b -> Array M ix a -> b #

foldl' :: (b -> a -> b) -> b -> Array M ix a -> b #

foldr1 :: (a -> a -> a) -> Array M ix a -> a #

foldl1 :: (a -> a -> a) -> Array M ix a -> a #

toList :: Array M ix a -> [a] #

null :: Array M ix a -> Bool #

length :: Array M ix a -> Int #

elem :: Eq a => a -> Array M ix a -> Bool #

maximum :: Ord a => Array M ix a -> a #

minimum :: Ord a => Array M ix a -> a #

sum :: Num a => Array M ix a -> a #

product :: Num a => Array M ix a -> a #

Index ix => Foldable (Array B ix) #

Row-major sequential folding over a Boxed array.

Methods

fold :: Monoid m => Array B ix m -> m #

foldMap :: Monoid m => (a -> m) -> Array B ix a -> m #

foldr :: (a -> b -> b) -> b -> Array B ix a -> b #

foldr' :: (a -> b -> b) -> b -> Array B ix a -> b #

foldl :: (b -> a -> b) -> b -> Array B ix a -> b #

foldl' :: (b -> a -> b) -> b -> Array B ix a -> b #

foldr1 :: (a -> a -> a) -> Array B ix a -> a #

foldl1 :: (a -> a -> a) -> Array B ix a -> a #

toList :: Array B ix a -> [a] #

null :: Array B ix a -> Bool #

length :: Array B ix a -> Int #

elem :: Eq a => a -> Array B ix a -> Bool #

maximum :: Ord a => Array B ix a -> a #

minimum :: Ord a => Array B ix a -> a #

sum :: Num a => Array B ix a -> a #

product :: Num a => Array B ix a -> a #

Nested LN ix e => IsList (Array L ix e) # 

Associated Types

type Item (Array L ix e) :: * #

Methods

fromList :: [Item (Array L ix e)] -> Array L ix e #

fromListN :: Int -> [Item (Array L ix e)] -> Array L ix e #

toList :: Array L ix e -> [Item (Array L ix e)] #

Nested LN ix e => IsList (Array LN ix e) # 

Associated Types

type Item (Array LN ix e) :: * #

Methods

fromList :: [Item (Array LN ix e)] -> Array LN ix e #

fromListN :: Int -> [Item (Array LN ix e)] -> Array LN ix e #

toList :: Array LN ix e -> [Item (Array LN ix e)] #

(Unbox e, IsList (Array L ix e), Nested LN ix e, Nested L ix e, Ragged L ix e) => IsList (Array U ix e) # 

Associated Types

type Item (Array U ix e) :: * #

Methods

fromList :: [Item (Array U ix e)] -> Array U ix e #

fromListN :: Int -> [Item (Array U ix e)] -> Array U ix e #

toList :: Array U ix e -> [Item (Array U ix e)] #

(Storable e, IsList (Array L ix e), Nested LN ix e, Nested L ix e, Ragged L ix e) => IsList (Array S ix e) # 

Associated Types

type Item (Array S ix e) :: * #

Methods

fromList :: [Item (Array S ix e)] -> Array S ix e #

fromListN :: Int -> [Item (Array S ix e)] -> Array S ix e #

toList :: Array S ix e -> [Item (Array S ix e)] #

(Prim e, IsList (Array L ix e), Nested LN ix e, Nested L ix e, Ragged L ix e) => IsList (Array P ix e) # 

Associated Types

type Item (Array P ix e) :: * #

Methods

fromList :: [Item (Array P ix e)] -> Array P ix e #

fromListN :: Int -> [Item (Array P ix e)] -> Array P ix e #

toList :: Array P ix e -> [Item (Array P ix e)] #

(NFData e, IsList (Array L ix e), Nested LN ix e, Nested L ix e, Ragged L ix e) => IsList (Array N ix e) # 

Associated Types

type Item (Array N ix e) :: * #

Methods

fromList :: [Item (Array N ix e)] -> Array N ix e #

fromListN :: Int -> [Item (Array N ix e)] -> Array N ix e #

toList :: Array N ix e -> [Item (Array N ix e)] #

(IsList (Array L ix e), Nested LN ix e, Nested L ix e, Ragged L ix e) => IsList (Array B ix e) # 

Associated Types

type Item (Array B ix e) :: * #

Methods

fromList :: [Item (Array B ix e)] -> Array B ix e #

fromListN :: Int -> [Item (Array B ix e)] -> Array B ix e #

toList :: Array B ix e -> [Item (Array B ix e)] #

(Eq e, Index ix) => Eq (Array D ix e) # 

Methods

(==) :: Array D ix e -> Array D ix e -> Bool #

(/=) :: Array D ix e -> Array D ix e -> Bool #

(Unbox e, Eq e, Index ix) => Eq (Array U ix e) # 

Methods

(==) :: Array U ix e -> Array U ix e -> Bool #

(/=) :: Array U ix e -> Array U ix e -> Bool #

(Storable e, Eq e, Index ix) => Eq (Array S ix e) # 

Methods

(==) :: Array S ix e -> Array S ix e -> Bool #

(/=) :: Array S ix e -> Array S ix e -> Bool #

(Prim e, Eq e, Index ix) => Eq (Array P ix e) # 

Methods

(==) :: Array P ix e -> Array P ix e -> Bool #

(/=) :: Array P ix e -> Array P ix e -> Bool #

(Index ix, NFData e, Eq e) => Eq (Array N ix e) # 

Methods

(==) :: Array N ix e -> Array N ix e -> Bool #

(/=) :: Array N ix e -> Array N ix e -> Bool #

(Index ix, Eq e) => Eq (Array B ix e) # 

Methods

(==) :: Array B ix e -> Array B ix e -> Bool #

(/=) :: Array B ix e -> Array B ix e -> Bool #

(Index ix, Floating e) => Floating (Array D ix e) # 

Methods

pi :: Array D ix e #

exp :: Array D ix e -> Array D ix e #

log :: Array D ix e -> Array D ix e #

sqrt :: Array D ix e -> Array D ix e #

(**) :: Array D ix e -> Array D ix e -> Array D ix e #

logBase :: Array D ix e -> Array D ix e -> Array D ix e #

sin :: Array D ix e -> Array D ix e #

cos :: Array D ix e -> Array D ix e #

tan :: Array D ix e -> Array D ix e #

asin :: Array D ix e -> Array D ix e #

acos :: Array D ix e -> Array D ix e #

atan :: Array D ix e -> Array D ix e #

sinh :: Array D ix e -> Array D ix e #

cosh :: Array D ix e -> Array D ix e #

tanh :: Array D ix e -> Array D ix e #

asinh :: Array D ix e -> Array D ix e #

acosh :: Array D ix e -> Array D ix e #

atanh :: Array D ix e -> Array D ix e #

log1p :: Array D ix e -> Array D ix e #

expm1 :: Array D ix e -> Array D ix e #

log1pexp :: Array D ix e -> Array D ix e #

log1mexp :: Array D ix e -> Array D ix e #

(Index ix, Fractional e) => Fractional (Array D ix e) # 

Methods

(/) :: Array D ix e -> Array D ix e -> Array D ix e #

recip :: Array D ix e -> Array D ix e #

fromRational :: Rational -> Array D ix e #

(Index ix, Num e) => Num (Array D ix e) # 

Methods

(+) :: Array D ix e -> Array D ix e -> Array D ix e #

(-) :: Array D ix e -> Array D ix e -> Array D ix e #

(*) :: Array D ix e -> Array D ix e -> Array D ix e #

negate :: Array D ix e -> Array D ix e #

abs :: Array D ix e -> Array D ix e #

signum :: Array D ix e -> Array D ix e #

fromInteger :: Integer -> Array D ix e #

(Ragged L ix e, Show e) => Show (Array L ix e) # 

Methods

showsPrec :: Int -> Array L ix e -> ShowS #

show :: Array L ix e -> String #

showList :: [Array L ix e] -> ShowS #

(Ragged L ix e, Nested LN ix e, Show e) => Show (Array LN ix e) # 

Methods

showsPrec :: Int -> Array LN ix e -> ShowS #

show :: Array LN ix e -> String #

showList :: [Array LN ix e] -> ShowS #

(Index ix, NFData e) => NFData (Array U ix e) # 

Methods

rnf :: Array U ix e -> () #

(Index ix, NFData e) => NFData (Array S ix e) # 

Methods

rnf :: Array S ix e -> () #

(Index ix, NFData e) => NFData (Array P ix e) # 

Methods

rnf :: Array P ix e -> () #

(Index ix, NFData e) => NFData (Array N ix e) # 

Methods

rnf :: Array N ix e -> () #

(Index ix, NFData e) => NFData (Array B ix e) # 

Methods

rnf :: Array B ix e -> () #

data Array L Source # 
data Array L = LArray {}
data Array LN Source # 
data Array LN = List {}
data Array D Source # 
data Array D = DArray {}
data Array M Source # 
data Array M = MArray {}
data Array DW Source # 
data Array DI Source # 
data Array DI = DIArray {}
data Array U Source # 
data Array U = UArray {}
data Array S Source # 
data Array S = SArray {}
data Array P Source # 
data Array P = PArray {}
data Array N Source # 
data Array N = NArray {}
data Array B Source # 
data Array B = BArray {}
type Item (Array L ix e) # 
type Item (Array L ix e) = ListItem ix e
type Item (Array LN ix e) # 
type Item (Array LN ix e) = ListItem ix e
type Item (Array U ix e) # 
type Item (Array U ix e) = Item (Array L ix e)
type Item (Array S ix e) # 
type Item (Array S ix e) = Item (Array L ix e)
type Item (Array P ix e) # 
type Item (Array P ix e) = Item (Array L ix e)
type Item (Array N ix e) # 
type Item (Array N ix e) = Item (Array L ix e)
type Item (Array B ix e) # 
type Item (Array B ix e) = Item (Array L ix e)

type family Elt r ix e :: * where ... Source #

Equations

Elt r Ix1 e = e 
Elt r ix e = Array (EltRepr r ix) (Lower ix) e 

type family EltRepr r ix :: * Source #

Instances

type EltRepr L ix Source # 
type EltRepr L ix = L
type EltRepr LN ix Source # 
type EltRepr LN ix = LN
type EltRepr D ix Source # 
type EltRepr D ix = D
type EltRepr M ix Source # 
type EltRepr M ix = M
type EltRepr DW ix Source # 
type EltRepr DW ix = D
type EltRepr DI ix Source # 
type EltRepr DI ix = DI
type EltRepr U ix Source # 
type EltRepr U ix = M
type EltRepr S ix Source # 
type EltRepr S ix = M
type EltRepr P ix Source # 
type EltRepr P ix = M
type EltRepr N ix Source # 
type EltRepr N ix = M
type EltRepr B ix Source # 
type EltRepr B ix = M

class (Typeable r, Index ix) => Construct r ix e Source #

Array types that can be constructed.

Minimal complete definition

getComp, setComp, unsafeMakeArray

Instances

(Index ix, Ragged L ix e, Ragged L (Lower ix) e, (~) * (Elt L ix e) (Array L (Lower ix) e)) => Construct L ix e Source # 

Methods

getComp :: Array L ix e -> Comp Source #

setComp :: Comp -> Array L ix e -> Array L ix e Source #

unsafeMakeArray :: Comp -> ix -> (ix -> e) -> Array L ix e Source #

Construct L Ix1 e Source # 

Methods

getComp :: Array L Ix1 e -> Comp Source #

setComp :: Comp -> Array L Ix1 e -> Array L Ix1 e Source #

unsafeMakeArray :: Comp -> Ix1 -> (Ix1 -> e) -> Array L Ix1 e Source #

Index ix => Construct D ix e Source # 

Methods

getComp :: Array D ix e -> Comp Source #

setComp :: Comp -> Array D ix e -> Array D ix e Source #

unsafeMakeArray :: Comp -> ix -> (ix -> e) -> Array D ix e Source #

Index ix => Construct M ix e Source # 

Methods

getComp :: Array M ix e -> Comp Source #

setComp :: Comp -> Array M ix e -> Array M ix e Source #

unsafeMakeArray :: Comp -> ix -> (ix -> e) -> Array M ix e Source #

Index ix => Construct DW ix e Source # 

Methods

getComp :: Array DW ix e -> Comp Source #

setComp :: Comp -> Array DW ix e -> Array DW ix e Source #

unsafeMakeArray :: Comp -> ix -> (ix -> e) -> Array DW ix e Source #

Index ix => Construct DI ix e Source # 

Methods

getComp :: Array DI ix e -> Comp Source #

setComp :: Comp -> Array DI ix e -> Array DI ix e Source #

unsafeMakeArray :: Comp -> ix -> (ix -> e) -> Array DI ix e Source #

(Unbox e, Index ix) => Construct U ix e Source # 

Methods

getComp :: Array U ix e -> Comp Source #

setComp :: Comp -> Array U ix e -> Array U ix e Source #

unsafeMakeArray :: Comp -> ix -> (ix -> e) -> Array U ix e Source #

(Storable e, Index ix) => Construct S ix e Source # 

Methods

getComp :: Array S ix e -> Comp Source #

setComp :: Comp -> Array S ix e -> Array S ix e Source #

unsafeMakeArray :: Comp -> ix -> (ix -> e) -> Array S ix e Source #

(Prim e, Index ix) => Construct P ix e Source # 

Methods

getComp :: Array P ix e -> Comp Source #

setComp :: Comp -> Array P ix e -> Array P ix e Source #

unsafeMakeArray :: Comp -> ix -> (ix -> e) -> Array P ix e Source #

(Index ix, NFData e) => Construct N ix e Source # 

Methods

getComp :: Array N ix e -> Comp Source #

setComp :: Comp -> Array N ix e -> Array N ix e Source #

unsafeMakeArray :: Comp -> ix -> (ix -> e) -> Array N ix e Source #

Index ix => Construct B ix e Source # 

Methods

getComp :: Array B ix e -> Comp Source #

setComp :: Comp -> Array B ix e -> Array B ix e Source #

unsafeMakeArray :: Comp -> ix -> (ix -> e) -> Array B ix e Source #

class Size r ix e => Source r ix e Source #

Arrays that can be used as source to practically any manipulation function.

Instances

Index ix => Source D ix e Source # 

Methods

unsafeIndex :: Array D ix e -> ix -> e Source #

unsafeLinearIndex :: Array D ix e -> Int -> e Source #

Index ix => Source M ix e Source # 

Methods

unsafeIndex :: Array M ix e -> ix -> e Source #

unsafeLinearIndex :: Array M ix e -> Int -> e Source #

(Unbox e, Index ix) => Source U ix e Source # 

Methods

unsafeIndex :: Array U ix e -> ix -> e Source #

unsafeLinearIndex :: Array U ix e -> Int -> e Source #

(Storable e, Index ix) => Source S ix e Source # 

Methods

unsafeIndex :: Array S ix e -> ix -> e Source #

unsafeLinearIndex :: Array S ix e -> Int -> e Source #

(Prim e, Index ix) => Source P ix e Source # 

Methods

unsafeIndex :: Array P ix e -> ix -> e Source #

unsafeLinearIndex :: Array P ix e -> Int -> e Source #

(Index ix, NFData e) => Source N ix e Source # 

Methods

unsafeIndex :: Array N ix e -> ix -> e Source #

unsafeLinearIndex :: Array N ix e -> Int -> e Source #

Index ix => Source B ix e Source # 

Methods

unsafeIndex :: Array B ix e -> ix -> e Source #

unsafeLinearIndex :: Array B ix e -> Int -> e Source #

class Size r ix e => Load r ix e where Source #

Any array that can be computed

Minimal complete definition

loadS, loadP

Methods

loadS Source #

Arguments

:: Monad m 
=> Array r ix e

Array that is being loaded

-> (Int -> m e)

Function that reads an element from target array

-> (Int -> e -> m ())

Function that writes an element into target array

-> m () 

Load an array into memory sequentially

loadP Source #

Arguments

:: [Int]

List of capabilities to run workers on, as described in forkOn. Empty list will imply all capabilities, i.e. run on all cores available through +RTS -N.

-> Array r ix e

Array that is being loaded

-> (Int -> IO e)

Function that reads an element from target array

-> (Int -> e -> IO ())

Function that writes an element into target array

-> IO () 

Load an array into memory in parallel

Instances

Index ix => Load D ix e Source # 

Methods

loadS :: Monad m => Array D ix e -> (Int -> m e) -> (Int -> e -> m ()) -> m () Source #

loadP :: [Int] -> Array D ix e -> (Int -> IO e) -> (Int -> e -> IO ()) -> IO () Source #

Index ix => Load M ix e Source # 

Methods

loadS :: Monad m => Array M ix e -> (Int -> m e) -> (Int -> e -> m ()) -> m () Source #

loadP :: [Int] -> Array M ix e -> (Int -> IO e) -> (Int -> e -> IO ()) -> IO () Source #

(Index ix, Load DW (Lower ix) e) => Load DW ix e Source # 

Methods

loadS :: Monad m => Array DW ix e -> (Int -> m e) -> (Int -> e -> m ()) -> m () Source #

loadP :: [Int] -> Array DW ix e -> (Int -> IO e) -> (Int -> e -> IO ()) -> IO () Source #

Load DW Ix2T e Source # 

Methods

loadS :: Monad m => Array DW Ix2T e -> (Int -> m e) -> (Int -> e -> m ()) -> m () Source #

loadP :: [Int] -> Array DW Ix2T e -> (Int -> IO e) -> (Int -> e -> IO ()) -> IO () Source #

Load DW Ix2 e Source # 

Methods

loadS :: Monad m => Array DW Ix2 e -> (Int -> m e) -> (Int -> e -> m ()) -> m () Source #

loadP :: [Int] -> Array DW Ix2 e -> (Int -> IO e) -> (Int -> e -> IO ()) -> IO () Source #

Load DW Ix1 e Source # 

Methods

loadS :: Monad m => Array DW Ix1 e -> (Int -> m e) -> (Int -> e -> m ()) -> m () Source #

loadP :: [Int] -> Array DW Ix1 e -> (Int -> IO e) -> (Int -> e -> IO ()) -> IO () Source #

Index ix => Load DI ix e Source # 

Methods

loadS :: Monad m => Array DI ix e -> (Int -> m e) -> (Int -> e -> m ()) -> m () Source #

loadP :: [Int] -> Array DI ix e -> (Int -> IO e) -> (Int -> e -> IO ()) -> IO () Source #

class Construct r ix e => Size r ix e Source #

An array that contains size information. They can be resized and new arrays extracted from it in constant time.

Minimal complete definition

size, unsafeResize, unsafeExtract

Instances

Index ix => Size D ix e Source # 

Methods

size :: Array D ix e -> ix Source #

unsafeResize :: Index ix' => ix' -> Array D ix e -> Array D ix' e Source #

unsafeExtract :: ix -> ix -> Array D ix e -> Array (EltRepr D ix) ix e Source #

Index ix => Size M ix e Source # 

Methods

size :: Array M ix e -> ix Source #

unsafeResize :: Index ix' => ix' -> Array M ix e -> Array M ix' e Source #

unsafeExtract :: ix -> ix -> Array M ix e -> Array (EltRepr M ix) ix e Source #

Index ix => Size DW ix e Source #

Any resize or extract on Windowed Array will hurt the performance.

Methods

size :: Array DW ix e -> ix Source #

unsafeResize :: Index ix' => ix' -> Array DW ix e -> Array DW ix' e Source #

unsafeExtract :: ix -> ix -> Array DW ix e -> Array (EltRepr DW ix) ix e Source #

Index ix => Size DI ix e Source # 

Methods

size :: Array DI ix e -> ix Source #

unsafeResize :: Index ix' => ix' -> Array DI ix e -> Array DI ix' e Source #

unsafeExtract :: ix -> ix -> Array DI ix e -> Array (EltRepr DI ix) ix e Source #

(Unbox e, Index ix) => Size U ix e Source # 

Methods

size :: Array U ix e -> ix Source #

unsafeResize :: Index ix' => ix' -> Array U ix e -> Array U ix' e Source #

unsafeExtract :: ix -> ix -> Array U ix e -> Array (EltRepr U ix) ix e Source #

(Storable e, Index ix) => Size S ix e Source # 

Methods

size :: Array S ix e -> ix Source #

unsafeResize :: Index ix' => ix' -> Array S ix e -> Array S ix' e Source #

unsafeExtract :: ix -> ix -> Array S ix e -> Array (EltRepr S ix) ix e Source #

(Prim e, Index ix) => Size P ix e Source # 

Methods

size :: Array P ix e -> ix Source #

unsafeResize :: Index ix' => ix' -> Array P ix e -> Array P ix' e Source #

unsafeExtract :: ix -> ix -> Array P ix e -> Array (EltRepr P ix) ix e Source #

(Index ix, NFData e) => Size N ix e Source # 

Methods

size :: Array N ix e -> ix Source #

unsafeResize :: Index ix' => ix' -> Array N ix e -> Array N ix' e Source #

unsafeExtract :: ix -> ix -> Array N ix e -> Array (EltRepr N ix) ix e Source #

Index ix => Size B ix e Source # 

Methods

size :: Array B ix e -> ix Source #

unsafeResize :: Index ix' => ix' -> Array B ix e -> Array B ix' e Source #

unsafeExtract :: ix -> ix -> Array B ix e -> Array (EltRepr B ix) ix e Source #

class Size r ix e => Slice r ix e Source #

Minimal complete definition

unsafeSlice

Instances

(Index ix, Index (Lower ix), (~) * (Elt D ix e) (Array D (Lower ix) e)) => Slice D ix e Source # 

Methods

unsafeSlice :: Array D ix e -> ix -> ix -> Dim -> Maybe (Elt D ix e) Source #

(Index ix, Index (Lower ix), (~) * (Elt M ix e) (Array M (Lower ix) e)) => Slice M ix e Source # 

Methods

unsafeSlice :: Array M ix e -> ix -> ix -> Dim -> Maybe (Elt M ix e) Source #

Slice M Ix1 e Source # 

Methods

unsafeSlice :: Array M Ix1 e -> Ix1 -> Ix1 -> Dim -> Maybe (Elt M Ix1 e) Source #

(Unbox e, Index ix, Index (Lower ix), (~) * (Elt U ix e) (Elt M ix e), (~) * (Elt M ix e) (Array M (Lower ix) e)) => Slice U ix e Source # 

Methods

unsafeSlice :: Array U ix e -> ix -> ix -> Dim -> Maybe (Elt U ix e) Source #

Unbox e => Slice U Ix1 e Source # 

Methods

unsafeSlice :: Array U Ix1 e -> Ix1 -> Ix1 -> Dim -> Maybe (Elt U Ix1 e) Source #

(Prim e, Index ix, Index (Lower ix), (~) * (Elt P ix e) (Elt M ix e), (~) * (Elt M ix e) (Array M (Lower ix) e)) => Slice P ix e Source # 

Methods

unsafeSlice :: Array P ix e -> ix -> ix -> Dim -> Maybe (Elt P ix e) Source #

Prim e => Slice P Ix1 e Source # 

Methods

unsafeSlice :: Array P Ix1 e -> Ix1 -> Ix1 -> Dim -> Maybe (Elt P Ix1 e) Source #

class OuterSlice r ix e where Source #

Minimal complete definition

unsafeOuterSlice

Methods

outerLength :: Array r ix e -> Int Source #

outerLength :: Size r ix e => Array r ix e -> Int Source #

Instances

Ragged L ix e => OuterSlice L ix e Source # 

Methods

unsafeOuterSlice :: Array L ix e -> Int -> Elt L ix e Source #

outerLength :: Array L ix e -> Int Source #

OuterSlice L Ix1 e Source # 
((~) * (Elt D ix e) (Array D (Lower ix) e), Index ix) => OuterSlice D ix e Source # 

Methods

unsafeOuterSlice :: Array D ix e -> Int -> Elt D ix e Source #

outerLength :: Array D ix e -> Int Source #

((~) * (Elt M ix e) (Array M (Lower ix) e), Index ix, Index (Lower ix)) => OuterSlice M ix e Source # 

Methods

unsafeOuterSlice :: Array M ix e -> Int -> Elt M ix e Source #

outerLength :: Array M ix e -> Int Source #

OuterSlice M Ix1 e Source # 
(Unbox e, Index ix, Index (Lower ix), (~) * (Elt U ix e) (Elt M ix e), (~) * (Elt M ix e) (Array M (Lower ix) e)) => OuterSlice U ix e Source # 

Methods

unsafeOuterSlice :: Array U ix e -> Int -> Elt U ix e Source #

outerLength :: Array U ix e -> Int Source #

Unbox e => OuterSlice U Ix1 e Source # 
(Storable e, Index ix, Index (Lower ix), (~) * (Elt M ix e) (Array M (Lower ix) e), (~) * (Elt S ix e) (Array M (Lower ix) e)) => OuterSlice S ix e Source # 

Methods

unsafeOuterSlice :: Array S ix e -> Int -> Elt S ix e Source #

outerLength :: Array S ix e -> Int Source #

(Prim e, Index ix, Index (Lower ix), (~) * (Elt M ix e) (Array M (Lower ix) e), (~) * (Elt P ix e) (Array M (Lower ix) e)) => OuterSlice P ix e Source # 

Methods

unsafeOuterSlice :: Array P ix e -> Int -> Elt P ix e Source #

outerLength :: Array P ix e -> Int Source #

Prim e => OuterSlice P Ix1 e Source # 
(NFData e, Index ix, Index (Lower ix), (~) * (Elt M ix e) (Array M (Lower ix) e), (~) * (Elt N ix e) (Array M (Lower ix) e)) => OuterSlice N ix e Source # 

Methods

unsafeOuterSlice :: Array N ix e -> Int -> Elt N ix e Source #

outerLength :: Array N ix e -> Int Source #

(NFData e, Index ix, Index (Lower ix), (~) * (Elt M ix e) (Array M (Lower ix) e), (~) * (Elt B ix e) (Array M (Lower ix) e)) => OuterSlice B ix e Source # 

Methods

unsafeOuterSlice :: Array B ix e -> Int -> Elt B ix e Source #

outerLength :: Array B ix e -> Int Source #

class Size r ix e => InnerSlice r ix e Source #

Minimal complete definition

unsafeInnerSlice

Instances

((~) * (Elt D ix e) (Array D (Lower ix) e), Index ix) => InnerSlice D ix e Source # 

Methods

unsafeInnerSlice :: Array D ix e -> (Lower ix, Int) -> Int -> Elt D ix e Source #

((~) * (Elt M ix e) (Array M (Lower ix) e), Index ix, Index (Lower ix)) => InnerSlice M ix e Source # 

Methods

unsafeInnerSlice :: Array M ix e -> (Lower ix, Int) -> Int -> Elt M ix e Source #

InnerSlice M Ix1 e Source # 

Methods

unsafeInnerSlice :: Array M Ix1 e -> (Lower Ix1, Int) -> Int -> Elt M Ix1 e Source #

(Unbox e, Index ix, Index (Lower ix), (~) * (Elt U ix e) (Elt M ix e), (~) * (Elt M ix e) (Array M (Lower ix) e)) => InnerSlice U ix e Source # 

Methods

unsafeInnerSlice :: Array U ix e -> (Lower ix, Int) -> Int -> Elt U ix e Source #

Unbox e => InnerSlice U Ix1 e Source # 

Methods

unsafeInnerSlice :: Array U Ix1 e -> (Lower Ix1, Int) -> Int -> Elt U Ix1 e Source #

(Storable e, Index ix, Index (Lower ix), (~) * (Elt M ix e) (Array M (Lower ix) e), (~) * (Elt S ix e) (Array M (Lower ix) e)) => InnerSlice S ix e Source # 

Methods

unsafeInnerSlice :: Array S ix e -> (Lower ix, Int) -> Int -> Elt S ix e Source #

(Prim e, Index ix, Index (Lower ix), (~) * (Elt M ix e) (Array M (Lower ix) e), (~) * (Elt P ix e) (Array M (Lower ix) e)) => InnerSlice P ix e Source # 

Methods

unsafeInnerSlice :: Array P ix e -> (Lower ix, Int) -> Int -> Elt P ix e Source #

Prim e => InnerSlice P Ix1 e Source # 

Methods

unsafeInnerSlice :: Array P Ix1 e -> (Lower Ix1, Int) -> Int -> Elt P Ix1 e Source #

(NFData e, Index ix, Index (Lower ix), (~) * (Elt M ix e) (Array M (Lower ix) e), (~) * (Elt N ix e) (Array M (Lower ix) e)) => InnerSlice N ix e Source # 

Methods

unsafeInnerSlice :: Array N ix e -> (Lower ix, Int) -> Int -> Elt N ix e Source #

(NFData e, Index ix, Index (Lower ix), (~) * (Elt M ix e) (Array M (Lower ix) e), (~) * (Elt B ix e) (Array M (Lower ix) e)) => InnerSlice B ix e Source # 

Methods

unsafeInnerSlice :: Array B ix e -> (Lower ix, Int) -> Int -> Elt B ix e Source #

class Source r ix e => Manifest r ix e Source #

Manifest arrays are backed by actual memory and values are looked up versus computed as it is with delayed arrays. Because of this fact indexing functions (!), (!?), etc. are constrained to manifest arrays only.

Minimal complete definition

unsafeLinearIndexM

Instances

Index ix => Manifest M ix e Source # 

Methods

unsafeLinearIndexM :: Array M ix e -> Int -> e Source #

(Unbox e, Index ix) => Manifest U ix e Source # 

Methods

unsafeLinearIndexM :: Array U ix e -> Int -> e Source #

(Index ix, Storable e) => Manifest S ix e Source # 

Methods

unsafeLinearIndexM :: Array S ix e -> Int -> e Source #

(Index ix, Prim e) => Manifest P ix e Source # 

Methods

unsafeLinearIndexM :: Array P ix e -> Int -> e Source #

(Index ix, NFData e) => Manifest N ix e Source # 

Methods

unsafeLinearIndexM :: Array N ix e -> Int -> e Source #

Index ix => Manifest B ix e Source # 

Methods

unsafeLinearIndexM :: Array B ix e -> Int -> e Source #

class Manifest r ix e => Mutable r ix e Source #

Instances

(Unbox e, Index ix) => Mutable U ix e Source # 

Associated Types

data MArray s U ix e :: * Source #

Methods

msize :: MArray s U ix e -> ix Source #

unsafeThaw :: PrimMonad m => Array U ix e -> m (MArray (PrimState m) U ix e) Source #

unsafeFreeze :: PrimMonad m => Comp -> MArray (PrimState m) U ix e -> m (Array U ix e) Source #

unsafeNew :: PrimMonad m => ix -> m (MArray (PrimState m) U ix e) Source #

unsafeNewZero :: PrimMonad m => ix -> m (MArray (PrimState m) U ix e) Source #

unsafeLinearRead :: PrimMonad m => MArray (PrimState m) U ix e -> Int -> m e Source #

unsafeLinearWrite :: PrimMonad m => MArray (PrimState m) U ix e -> Int -> e -> m () Source #

(Index ix, Storable e) => Mutable S ix e Source # 

Associated Types

data MArray s S ix e :: * Source #

Methods

msize :: MArray s S ix e -> ix Source #

unsafeThaw :: PrimMonad m => Array S ix e -> m (MArray (PrimState m) S ix e) Source #

unsafeFreeze :: PrimMonad m => Comp -> MArray (PrimState m) S ix e -> m (Array S ix e) Source #

unsafeNew :: PrimMonad m => ix -> m (MArray (PrimState m) S ix e) Source #

unsafeNewZero :: PrimMonad m => ix -> m (MArray (PrimState m) S ix e) Source #

unsafeLinearRead :: PrimMonad m => MArray (PrimState m) S ix e -> Int -> m e Source #

unsafeLinearWrite :: PrimMonad m => MArray (PrimState m) S ix e -> Int -> e -> m () Source #

(Index ix, Prim e) => Mutable P ix e Source # 

Associated Types

data MArray s P ix e :: * Source #

Methods

msize :: MArray s P ix e -> ix Source #

unsafeThaw :: PrimMonad m => Array P ix e -> m (MArray (PrimState m) P ix e) Source #

unsafeFreeze :: PrimMonad m => Comp -> MArray (PrimState m) P ix e -> m (Array P ix e) Source #

unsafeNew :: PrimMonad m => ix -> m (MArray (PrimState m) P ix e) Source #

unsafeNewZero :: PrimMonad m => ix -> m (MArray (PrimState m) P ix e) Source #

unsafeLinearRead :: PrimMonad m => MArray (PrimState m) P ix e -> Int -> m e Source #

unsafeLinearWrite :: PrimMonad m => MArray (PrimState m) P ix e -> Int -> e -> m () Source #

(Index ix, NFData e) => Mutable N ix e Source # 

Associated Types

data MArray s N ix e :: * Source #

Methods

msize :: MArray s N ix e -> ix Source #

unsafeThaw :: PrimMonad m => Array N ix e -> m (MArray (PrimState m) N ix e) Source #

unsafeFreeze :: PrimMonad m => Comp -> MArray (PrimState m) N ix e -> m (Array N ix e) Source #

unsafeNew :: PrimMonad m => ix -> m (MArray (PrimState m) N ix e) Source #

unsafeNewZero :: PrimMonad m => ix -> m (MArray (PrimState m) N ix e) Source #

unsafeLinearRead :: PrimMonad m => MArray (PrimState m) N ix e -> Int -> m e Source #

unsafeLinearWrite :: PrimMonad m => MArray (PrimState m) N ix e -> Int -> e -> m () Source #

Index ix => Mutable B ix e Source # 

Associated Types

data MArray s B ix e :: * Source #

Methods

msize :: MArray s B ix e -> ix Source #

unsafeThaw :: PrimMonad m => Array B ix e -> m (MArray (PrimState m) B ix e) Source #

unsafeFreeze :: PrimMonad m => Comp -> MArray (PrimState m) B ix e -> m (Array B ix e) Source #

unsafeNew :: PrimMonad m => ix -> m (MArray (PrimState m) B ix e) Source #

unsafeNewZero :: PrimMonad m => ix -> m (MArray (PrimState m) B ix e) Source #

unsafeLinearRead :: PrimMonad m => MArray (PrimState m) B ix e -> Int -> m e Source #

unsafeLinearWrite :: PrimMonad m => MArray (PrimState m) B ix e -> Int -> e -> m () Source #

class Construct r ix e => Ragged r ix e where Source #

Methods

empty :: Comp -> Array r ix e Source #

isNull :: Array r ix e -> Bool Source #

cons :: Elt r ix e -> Array r ix e -> Array r ix e Source #

uncons :: Array r ix e -> Maybe (Elt r ix e, Array r ix e) Source #

edgeSize :: Array r ix e -> ix Source #

flatten :: Array r ix e -> Array r Ix1 e Source #

loadRagged :: (IO () -> IO ()) -> (Int -> e -> IO a) -> Int -> Int -> Lower ix -> Array r ix e -> IO () Source #

raggedFormat :: (e -> String) -> String -> Array r ix e -> String Source #

Instances

(Index ix, Index (Lower ix), Ragged L (Lower ix) e, (~) * (Elt L ix e) (Array L (Lower ix) e), (~) * (Elt LN ix e) (Array LN (Lower ix) e), Coercible * (Elt LN ix e) [Elt LN (Lower ix) e]) => Ragged L ix e Source # 

Methods

empty :: Comp -> Array L ix e Source #

isNull :: Array L ix e -> Bool Source #

cons :: Elt L ix e -> Array L ix e -> Array L ix e Source #

uncons :: Array L ix e -> Maybe (Elt L ix e, Array L ix e) Source #

unsafeGenerateM :: Monad m => Comp -> ix -> (ix -> m e) -> m (Array L ix e) Source #

edgeSize :: Array L ix e -> ix Source #

flatten :: Array L ix e -> Array L Ix1 e Source #

loadRagged :: (IO () -> IO ()) -> (Int -> e -> IO a) -> Int -> Int -> Lower ix -> Array L ix e -> IO () Source #

raggedFormat :: (e -> String) -> String -> Array L ix e -> String Source #

Ragged L Ix1 e Source # 

Methods

empty :: Comp -> Array L Ix1 e Source #

isNull :: Array L Ix1 e -> Bool Source #

cons :: Elt L Ix1 e -> Array L Ix1 e -> Array L Ix1 e Source #

uncons :: Array L Ix1 e -> Maybe (Elt L Ix1 e, Array L Ix1 e) Source #

unsafeGenerateM :: Monad m => Comp -> Ix1 -> (Ix1 -> m e) -> m (Array L Ix1 e) Source #

edgeSize :: Array L Ix1 e -> Ix1 Source #

flatten :: Array L Ix1 e -> Array L Ix1 e Source #

loadRagged :: (IO () -> IO ()) -> (Int -> e -> IO a) -> Int -> Int -> Lower Ix1 -> Array L Ix1 e -> IO () Source #

raggedFormat :: (e -> String) -> String -> Array L Ix1 e -> String Source #

class Nested r ix e where Source #

Minimal complete definition

fromNested, toNested

Methods

fromNested :: NestedStruct r ix e -> Array r ix e Source #

toNested :: Array r ix e -> NestedStruct r ix e Source #

Instances

Nested L ix e Source # 

Methods

fromNested :: NestedStruct L ix e -> Array L ix e Source #

toNested :: Array L ix e -> NestedStruct L ix e Source #

((~) * (Elt LN ix e) (Array LN (Lower ix) e), (~) * (ListItem ix e) [ListItem (Lower ix) e], Coercible * (Elt LN ix e) (ListItem ix e)) => Nested LN ix e Source # 

Methods

fromNested :: NestedStruct LN ix e -> Array LN ix e Source #

toNested :: Array LN ix e -> NestedStruct LN ix e Source #

Nested LN Ix1 e Source # 

type family NestedStruct r ix e :: * Source #

Instances

type NestedStruct L ix e Source # 
type NestedStruct L ix e = Array LN ix e
type NestedStruct LN ix e Source # 
type NestedStruct LN ix e = [ListItem ix e]

data L Source #

Constructors

L 

Instances

(Index ix, Index (Lower ix), Ragged L (Lower ix) e, (~) * (Elt L ix e) (Array L (Lower ix) e), (~) * (Elt LN ix e) (Array LN (Lower ix) e), Coercible * (Elt LN ix e) [Elt LN (Lower ix) e]) => Ragged L ix e Source # 

Methods

empty :: Comp -> Array L ix e Source #

isNull :: Array L ix e -> Bool Source #

cons :: Elt L ix e -> Array L ix e -> Array L ix e Source #

uncons :: Array L ix e -> Maybe (Elt L ix e, Array L ix e) Source #

unsafeGenerateM :: Monad m => Comp -> ix -> (ix -> m e) -> m (Array L ix e) Source #

edgeSize :: Array L ix e -> ix Source #

flatten :: Array L ix e -> Array L Ix1 e Source #

loadRagged :: (IO () -> IO ()) -> (Int -> e -> IO a) -> Int -> Int -> Lower ix -> Array L ix e -> IO () Source #

raggedFormat :: (e -> String) -> String -> Array L ix e -> String Source #

Ragged L Ix1 e Source # 

Methods

empty :: Comp -> Array L Ix1 e Source #

isNull :: Array L Ix1 e -> Bool Source #

cons :: Elt L Ix1 e -> Array L Ix1 e -> Array L Ix1 e Source #

uncons :: Array L Ix1 e -> Maybe (Elt L Ix1 e, Array L Ix1 e) Source #

unsafeGenerateM :: Monad m => Comp -> Ix1 -> (Ix1 -> m e) -> m (Array L Ix1 e) Source #

edgeSize :: Array L Ix1 e -> Ix1 Source #

flatten :: Array L Ix1 e -> Array L Ix1 e Source #

loadRagged :: (IO () -> IO ()) -> (Int -> e -> IO a) -> Int -> Int -> Lower Ix1 -> Array L Ix1 e -> IO () Source #

raggedFormat :: (e -> String) -> String -> Array L Ix1 e -> String Source #

Nested L ix e Source # 

Methods

fromNested :: NestedStruct L ix e -> Array L ix e Source #

toNested :: Array L ix e -> NestedStruct L ix e Source #

Ragged L ix e => OuterSlice L ix e Source # 

Methods

unsafeOuterSlice :: Array L ix e -> Int -> Elt L ix e Source #

outerLength :: Array L ix e -> Int Source #

OuterSlice L Ix1 e Source # 
(Index ix, Ragged L ix e, Ragged L (Lower ix) e, (~) * (Elt L ix e) (Array L (Lower ix) e)) => Construct L ix e Source # 

Methods

getComp :: Array L ix e -> Comp Source #

setComp :: Comp -> Array L ix e -> Array L ix e Source #

unsafeMakeArray :: Comp -> ix -> (ix -> e) -> Array L ix e Source #

Construct L Ix1 e Source # 

Methods

getComp :: Array L Ix1 e -> Comp Source #

setComp :: Comp -> Array L Ix1 e -> Array L Ix1 e Source #

unsafeMakeArray :: Comp -> Ix1 -> (Ix1 -> e) -> Array L Ix1 e Source #

Nested LN ix e => IsList (Array L ix e) Source # 

Associated Types

type Item (Array L ix e) :: * #

Methods

fromList :: [Item (Array L ix e)] -> Array L ix e #

fromListN :: Int -> [Item (Array L ix e)] -> Array L ix e #

toList :: Array L ix e -> [Item (Array L ix e)] #

(Ragged L ix e, Show e) => Show (Array L ix e) Source # 

Methods

showsPrec :: Int -> Array L ix e -> ShowS #

show :: Array L ix e -> String #

showList :: [Array L ix e] -> ShowS #

data Array L Source # 
data Array L = LArray {}
type EltRepr L ix Source # 
type EltRepr L ix = L
type NestedStruct L ix e Source # 
type NestedStruct L ix e = Array LN ix e
type Item (Array L ix e) Source # 
type Item (Array L ix e) = ListItem ix e

data LN Source #

Instances

((~) * (Elt LN ix e) (Array LN (Lower ix) e), (~) * (ListItem ix e) [ListItem (Lower ix) e], Coercible * (Elt LN ix e) (ListItem ix e)) => Nested LN ix e Source # 

Methods

fromNested :: NestedStruct LN ix e -> Array LN ix e Source #

toNested :: Array LN ix e -> NestedStruct LN ix e Source #

Nested LN Ix1 e Source # 
Nested LN ix e => IsList (Array LN ix e) Source # 

Associated Types

type Item (Array LN ix e) :: * #

Methods

fromList :: [Item (Array LN ix e)] -> Array LN ix e #

fromListN :: Int -> [Item (Array LN ix e)] -> Array LN ix e #

toList :: Array LN ix e -> [Item (Array LN ix e)] #

(Ragged L ix e, Nested LN ix e, Show e) => Show (Array LN ix e) Source # 

Methods

showsPrec :: Int -> Array LN ix e -> ShowS #

show :: Array LN ix e -> String #

showList :: [Array LN ix e] -> ShowS #

data Array LN Source # 
data Array LN = List {}
type EltRepr LN ix Source # 
type EltRepr LN ix = LN
type NestedStruct LN ix e Source # 
type NestedStruct LN ix e = [ListItem ix e]
type Item (Array LN ix e) Source # 
type Item (Array LN ix e) = ListItem ix e

type family ListItem ix e :: * where ... Source #

Equations

ListItem Ix1 e = e 
ListItem ix e = [ListItem (Lower ix) e] 

data Comp Source #

Computation type to use.

Constructors

Seq

Sequential computation

ParOn [Int]

Use Par instead to use your CPU to the fullest. Also don't forget to compile the program with -threaded flag.

Parallel computation with a list of capabilities to run computation on. Specifying an empty list (ParOn []) or using Par will result in utilization of all available capabilities, which are set at runtime by +RTS -Nx or at compile time by GHC flag -with-rtsopts=-Nx, where x is the number of capabilities. Ommiting x in above flags defaults to number available cores.

Instances

Eq Comp Source # 

Methods

(==) :: Comp -> Comp -> Bool #

(/=) :: Comp -> Comp -> Bool #

Show Comp Source # 

Methods

showsPrec :: Int -> Comp -> ShowS #

show :: Comp -> String #

showList :: [Comp] -> ShowS #

Monoid Comp Source # 

Methods

mempty :: Comp #

mappend :: Comp -> Comp -> Comp #

mconcat :: [Comp] -> Comp #

NFData Comp Source # 

Methods

rnf :: Comp -> () #

pattern Par :: Comp Source #

Parallel computation using all available cores.

elemsCount :: Size r ix e => Array r ix e -> Int Source #

O(1) - Get the number of elements in the array

isEmpty :: Size r ix e => Array r ix e -> Bool Source #

O(1) - Check if array has no elements.