{-# OPTIONS_GHC -Wno-orphans #-}
{-# LANGUAGE ConstraintKinds #-}
{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE UndecidableInstances #-}
module Data.Array.Internal.DynamicU(
Array(..), Vector, ShapeL, Unbox,
size, shapeL, rank,
toList, fromList, toVector, fromVector,
normalize,
scalar, unScalar, constant,
reshape, stretch, stretchOuter, transpose,
index, pad,
mapA, zipWithA, zipWith3A, zipWith4A, zipWith5A,
append, concatOuter,
ravel, unravel,
window, stride,
slice, rerank, rerank2, rev,
reduce, foldrA, traverseA,
allSameA,
sumA, productA, maximumA, minimumA,
anyA, allA,
broadcast,
update,
generate, iterateN, iota,
) where
import Control.DeepSeq
import Data.Coerce(coerce)
import Data.Data(Data)
import qualified Data.Vector.Unboxed as V
import GHC.Stack(HasCallStack)
import Test.QuickCheck hiding (generate)
import GHC.Generics(Generic)
import Text.PrettyPrint.HughesPJClass hiding ((<>))
import qualified Data.Array.Internal.Dynamic as D
import qualified Data.Array.DynamicG as G
import Data.Array.Internal(ShapeL, Vector(..))
type Unbox = V.Unbox
instance Vector V.Vector where
type VecElem V.Vector = Unbox
{-# INLINE vIndex #-}
vIndex :: forall a. VecElem Vector a => Vector a -> Int -> a
vIndex = forall a. Unbox a => Vector a -> Int -> a
(V.!)
{-# INLINE vLength #-}
vLength :: forall a. VecElem Vector a => Vector a -> Int
vLength = forall a. Unbox a => Vector a -> Int
V.length
{-# INLINE vToList #-}
vToList :: forall a. VecElem Vector a => Vector a -> [a]
vToList = forall a. Unbox a => Vector a -> [a]
V.toList
{-# INLINE vFromList #-}
vFromList :: forall a. VecElem Vector a => [a] -> Vector a
vFromList = forall a. Unbox a => [a] -> Vector a
V.fromList
{-# INLINE vSingleton #-}
vSingleton :: forall a. VecElem Vector a => a -> Vector a
vSingleton = forall a. Unbox a => a -> Vector a
V.singleton
{-# INLINE vReplicate #-}
vReplicate :: forall a. VecElem Vector a => Int -> a -> Vector a
vReplicate = forall a. Unbox a => Int -> a -> Vector a
V.replicate
{-# INLINE vMap #-}
vMap :: forall a b.
(VecElem Vector a, VecElem Vector b) =>
(a -> b) -> Vector a -> Vector b
vMap = forall a b. (Unbox a, Unbox b) => (a -> b) -> Vector a -> Vector b
V.map
{-# INLINE vZipWith #-}
vZipWith :: forall a b c.
(VecElem Vector a, VecElem Vector b, VecElem Vector c) =>
(a -> b -> c) -> Vector a -> Vector b -> Vector c
vZipWith = forall a b c.
(Unbox a, Unbox b, Unbox c) =>
(a -> b -> c) -> Vector a -> Vector b -> Vector c
V.zipWith
{-# INLINE vZipWith3 #-}
vZipWith3 :: forall a b c d.
(VecElem Vector a, VecElem Vector b, VecElem Vector c,
VecElem Vector d) =>
(a -> b -> c -> d) -> Vector a -> Vector b -> Vector c -> Vector d
vZipWith3 = forall a b c d.
(Unbox a, Unbox b, Unbox c, Unbox d) =>
(a -> b -> c -> d) -> Vector a -> Vector b -> Vector c -> Vector d
V.zipWith3
{-# INLINE vZipWith4 #-}
vZipWith4 :: forall a b c d e.
(VecElem Vector a, VecElem Vector b, VecElem Vector c,
VecElem Vector d, VecElem Vector e) =>
(a -> b -> c -> d -> e)
-> Vector a -> Vector b -> Vector c -> Vector d -> Vector e
vZipWith4 = forall a b c d e.
(Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) =>
(a -> b -> c -> d -> e)
-> Vector a -> Vector b -> Vector c -> Vector d -> Vector e
V.zipWith4
{-# INLINE vZipWith5 #-}
vZipWith5 :: forall a b c d e f.
(VecElem Vector a, VecElem Vector b, VecElem Vector c,
VecElem Vector d, VecElem Vector e, VecElem Vector f) =>
(a -> b -> c -> d -> e -> f)
-> Vector a
-> Vector b
-> Vector c
-> Vector d
-> Vector e
-> Vector f
vZipWith5 = forall a b c d e f.
(Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f) =>
(a -> b -> c -> d -> e -> f)
-> Vector a
-> Vector b
-> Vector c
-> Vector d
-> Vector e
-> Vector f
V.zipWith5
{-# INLINE vAppend #-}
vAppend :: forall a. VecElem Vector a => Vector a -> Vector a -> Vector a
vAppend = forall a. Unbox a => Vector a -> Vector a -> Vector a
(V.++)
{-# INLINE vConcat #-}
vConcat :: forall a. VecElem Vector a => [Vector a] -> Vector a
vConcat = forall a. Unbox a => [Vector a] -> Vector a
V.concat
{-# INLINE vFold #-}
vFold :: forall a. VecElem Vector a => (a -> a -> a) -> a -> Vector a -> a
vFold = forall b a. Unbox b => (a -> b -> a) -> a -> Vector b -> a
V.foldl'
{-# INLINE vSlice #-}
vSlice :: forall a. VecElem Vector a => Int -> Int -> Vector a -> Vector a
vSlice = forall a. Unbox a => Int -> Int -> Vector a -> Vector a
V.slice
{-# INLINE vSum #-}
vSum :: forall a. (VecElem Vector a, Num a) => Vector a -> a
vSum = forall a. (Unbox a, Num a) => Vector a -> a
V.sum
{-# INLINE vProduct #-}
vProduct :: forall a. (VecElem Vector a, Num a) => Vector a -> a
vProduct = forall a. (Unbox a, Num a) => Vector a -> a
V.product
{-# INLINE vMaximum #-}
vMaximum :: forall a. (VecElem Vector a, Ord a) => Vector a -> a
vMaximum = forall a. (Unbox a, Ord a) => Vector a -> a
V.maximum
{-# INLINE vMinimum #-}
vMinimum :: forall a. (VecElem Vector a, Ord a) => Vector a -> a
vMinimum = forall a. (Unbox a, Ord a) => Vector a -> a
V.minimum
{-# INLINE vUpdate #-}
vUpdate :: forall a. VecElem Vector a => Vector a -> [(Int, a)] -> Vector a
vUpdate = forall a. Unbox a => Vector a -> [(Int, a)] -> Vector a
(V.//)
{-# INLINE vGenerate #-}
vGenerate :: forall a. VecElem Vector a => Int -> (Int -> a) -> Vector a
vGenerate = forall a. Unbox a => Int -> (Int -> a) -> Vector a
V.generate
{-# INLINE vAll #-}
vAll :: forall a. VecElem Vector a => (a -> Bool) -> Vector a -> Bool
vAll = forall a. Unbox a => (a -> Bool) -> Vector a -> Bool
V.all
{-# INLINE vAny #-}
vAny :: forall a. VecElem Vector a => (a -> Bool) -> Vector a -> Bool
vAny = forall a. Unbox a => (a -> Bool) -> Vector a -> Bool
V.any
newtype Array a = A { forall a. Array a -> Array Vector a
unA :: G.Array V.Vector a }
deriving (PrettyLevel -> [Array a] -> Doc
PrettyLevel -> Rational -> Array a -> Doc
Array a -> Doc
forall a. (Pretty a, Unbox a) => PrettyLevel -> [Array a] -> Doc
forall a.
(Pretty a, Unbox a) =>
PrettyLevel -> Rational -> Array a -> Doc
forall a. (Pretty a, Unbox a) => Array a -> Doc
forall a.
(PrettyLevel -> Rational -> a -> Doc)
-> (a -> Doc) -> (PrettyLevel -> [a] -> Doc) -> Pretty a
pPrintList :: PrettyLevel -> [Array a] -> Doc
$cpPrintList :: forall a. (Pretty a, Unbox a) => PrettyLevel -> [Array a] -> Doc
pPrint :: Array a -> Doc
$cpPrint :: forall a. (Pretty a, Unbox a) => Array a -> Doc
pPrintPrec :: PrettyLevel -> Rational -> Array a -> Doc
$cpPrintPrec :: forall a.
(Pretty a, Unbox a) =>
PrettyLevel -> Rational -> Array a -> Doc
Pretty, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Array a) x -> Array a
forall a x. Array a -> Rep (Array a) x
$cto :: forall a x. Rep (Array a) x -> Array a
$cfrom :: forall a x. Array a -> Rep (Array a) x
Generic, Array a -> DataType
Array a -> Constr
forall {a}. (Data a, Unbox a) => Typeable (Array a)
forall a. (Data a, Unbox a) => Array a -> DataType
forall a. (Data a, Unbox a) => Array a -> Constr
forall a.
(Data a, Unbox a) =>
(forall b. Data b => b -> b) -> Array a -> Array a
forall a u.
(Data a, Unbox a) =>
Int -> (forall d. Data d => d -> u) -> Array a -> u
forall a u.
(Data a, Unbox a) =>
(forall d. Data d => d -> u) -> Array a -> [u]
forall a r r'.
(Data a, Unbox a) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Array a -> r
forall a r r'.
(Data a, Unbox a) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Array a -> r
forall a (m :: * -> *).
(Data a, Unbox a, Monad m) =>
(forall d. Data d => d -> m d) -> Array a -> m (Array a)
forall a (m :: * -> *).
(Data a, Unbox a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Array a -> m (Array a)
forall a (c :: * -> *).
(Data a, Unbox a) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Array a)
forall a (c :: * -> *).
(Data a, Unbox a) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Array a -> c (Array a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Unbox a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Array a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Unbox a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Array a))
forall a.
Typeable a
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Array a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Array a -> c (Array a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Array a))
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Array a -> m (Array a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, Unbox a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Array a -> m (Array a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Array a -> m (Array a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, Unbox a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Array a -> m (Array a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Array a -> m (Array a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Unbox a, Monad m) =>
(forall d. Data d => d -> m d) -> Array a -> m (Array a)
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Array a -> u
$cgmapQi :: forall a u.
(Data a, Unbox a) =>
Int -> (forall d. Data d => d -> u) -> Array a -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Array a -> [u]
$cgmapQ :: forall a u.
(Data a, Unbox a) =>
(forall d. Data d => d -> u) -> Array a -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Array a -> r
$cgmapQr :: forall a r r'.
(Data a, Unbox a) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Array a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Array a -> r
$cgmapQl :: forall a r r'.
(Data a, Unbox a) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Array a -> r
gmapT :: (forall b. Data b => b -> b) -> Array a -> Array a
$cgmapT :: forall a.
(Data a, Unbox a) =>
(forall b. Data b => b -> b) -> Array a -> Array a
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Array a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Unbox a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Array a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Array a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Unbox a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Array a))
dataTypeOf :: Array a -> DataType
$cdataTypeOf :: forall a. (Data a, Unbox a) => Array a -> DataType
toConstr :: Array a -> Constr
$ctoConstr :: forall a. (Data a, Unbox a) => Array a -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Array a)
$cgunfold :: forall a (c :: * -> *).
(Data a, Unbox a) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Array a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Array a -> c (Array a)
$cgfoldl :: forall a (c :: * -> *).
(Data a, Unbox a) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Array a -> c (Array a)
Data)
instance NFData a => NFData (Array a)
instance (Show a, Unbox a) => Show (Array a) where
showsPrec :: Int -> Array a -> ShowS
showsPrec Int
p = forall a. Show a => Int -> a -> ShowS
showsPrec Int
p forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Array a -> Array Vector a
unA
instance (Read a, Unbox a) => Read (Array a) where
readsPrec :: Int -> ReadS (Array a)
readsPrec Int
p String
s = [(forall a. Array Vector a -> Array a
A Array Vector a
a, String
r) | (Array Vector a
a, String
r) <- forall a. Read a => Int -> ReadS a
readsPrec Int
p String
s]
instance Eq (G.Array V.Vector a) => Eq (Array a) where
Array a
x == :: Array a -> Array a -> Bool
== Array a
y = forall a. Array a -> ShapeL
shapeL Array a
x forall a. Eq a => a -> a -> Bool
== forall a. Array a -> ShapeL
shapeL Array a
y Bool -> Bool -> Bool
&& forall a. Array a -> Array Vector a
unA Array a
x forall a. Eq a => a -> a -> Bool
== forall a. Array a -> Array Vector a
unA Array a
y
{-# INLINE (==) #-}
instance Ord (G.Array V.Vector a) => Ord (Array a) where
compare :: Array a -> Array a -> Ordering
compare Array a
x Array a
y = forall a. Ord a => a -> a -> Ordering
compare (forall a. Array a -> ShapeL
shapeL Array a
x) (forall a. Array a -> ShapeL
shapeL Array a
y) forall a. Semigroup a => a -> a -> a
<> forall a. Ord a => a -> a -> Ordering
compare (forall a. Array a -> Array Vector a
unA Array a
x) (forall a. Array a -> Array Vector a
unA Array a
y)
{-# INLINE compare #-}
{-# INLINE size #-}
size :: Array a -> Int
size :: forall a. Array a -> Int
size = forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
product forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Array a -> ShapeL
shapeL
shapeL :: Array a -> ShapeL
shapeL :: forall a. Array a -> ShapeL
shapeL = forall (v :: * -> *) a. Array v a -> ShapeL
G.shapeL forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Array a -> Array Vector a
unA
rank :: Array a -> Int
rank :: forall a. Array a -> Int
rank = forall (v :: * -> *) a. Array v a -> Int
G.rank forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Array a -> Array Vector a
unA
index :: (HasCallStack, Unbox a) => Array a -> Int -> Array a
index :: forall a. (HasCallStack, Unbox a) => Array a -> Int -> Array a
index Array a
a = forall a. Array Vector a -> Array a
A forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (v :: * -> *) a.
(HasCallStack, Vector v) =>
Array v a -> Int -> Array v a
G.index (forall a. Array a -> Array Vector a
unA Array a
a)
toList :: (HasCallStack, Unbox a) => Array a -> [a]
toList :: forall a. (HasCallStack, Unbox a) => Array a -> [a]
toList = forall (v :: * -> *) a. (Vector v, VecElem v a) => Array v a -> [a]
G.toList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Array a -> Array Vector a
unA
fromList :: (HasCallStack, Unbox a) => ShapeL -> [a] -> Array a
fromList :: forall a. (HasCallStack, Unbox a) => ShapeL -> [a] -> Array a
fromList ShapeL
ss = forall a. Array Vector a -> Array a
A forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (v :: * -> *) a.
(HasCallStack, Vector v, VecElem v a) =>
ShapeL -> [a] -> Array v a
G.fromList ShapeL
ss
toVector :: (HasCallStack, Unbox a) => Array a -> V.Vector a
toVector :: forall a. (HasCallStack, Unbox a) => Array a -> Vector a
toVector = forall (v :: * -> *) a. (Vector v, VecElem v a) => Array v a -> v a
G.toVector forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Array a -> Array Vector a
unA
fromVector :: (HasCallStack, Unbox a) => ShapeL -> V.Vector a -> Array a
fromVector :: forall a. (HasCallStack, Unbox a) => ShapeL -> Vector a -> Array a
fromVector ShapeL
ss = forall a. Array Vector a -> Array a
A forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (v :: * -> *) a.
(HasCallStack, Vector v, VecElem v a) =>
ShapeL -> v a -> Array v a
G.fromVector ShapeL
ss
{-# INLINE normalize #-}
normalize :: (Unbox a) => Array a -> Array a
normalize :: forall a. Unbox a => Array a -> Array a
normalize = forall a. Array Vector a -> Array a
A forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (v :: * -> *) a.
(Vector v, VecElem v a) =>
Array v a -> Array v a
G.normalize forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Array a -> Array Vector a
unA
reshape :: (HasCallStack, Unbox a) => ShapeL -> Array a -> Array a
reshape :: forall a. (HasCallStack, Unbox a) => ShapeL -> Array a -> Array a
reshape ShapeL
s = forall a. Array Vector a -> Array a
A forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (v :: * -> *) a.
(HasCallStack, Vector v, VecElem v a) =>
ShapeL -> Array v a -> Array v a
G.reshape ShapeL
s forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Array a -> Array Vector a
unA
stretch :: (HasCallStack) => ShapeL -> Array a -> Array a
stretch :: forall a. HasCallStack => ShapeL -> Array a -> Array a
stretch ShapeL
s = forall a. Array Vector a -> Array a
A forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (v :: * -> *) a.
HasCallStack =>
ShapeL -> Array v a -> Array v a
G.stretch ShapeL
s forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Array a -> Array Vector a
unA
stretchOuter :: (HasCallStack) => Int -> Array a -> Array a
stretchOuter :: forall a. HasCallStack => Int -> Array a -> Array a
stretchOuter Int
s = forall a. Array Vector a -> Array a
A forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (v :: * -> *) a.
HasCallStack =>
Int -> Array v a -> Array v a
G.stretchOuter Int
s forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Array a -> Array Vector a
unA
scalar :: (Unbox a) => a -> Array a
scalar :: forall a. Unbox a => a -> Array a
scalar = forall a. Array Vector a -> Array a
A forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (v :: * -> *) a. (Vector v, VecElem v a) => a -> Array v a
G.scalar
unScalar :: (HasCallStack, Unbox a) => Array a -> a
unScalar :: forall a. (HasCallStack, Unbox a) => Array a -> a
unScalar = forall (v :: * -> *) a.
(HasCallStack, Vector v, VecElem v a) =>
Array v a -> a
G.unScalar forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Array a -> Array Vector a
unA
{-# INLINE constant #-}
constant :: (Unbox a) => ShapeL -> a -> Array a
constant :: forall a. Unbox a => ShapeL -> a -> Array a
constant ShapeL
sh = forall a. Array Vector a -> Array a
A forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (v :: * -> *) a.
(HasCallStack, Vector v, VecElem v a) =>
ShapeL -> a -> Array v a
G.constant ShapeL
sh
{-# INLINE mapA #-}
mapA :: (Unbox a, Unbox b) => (a -> b) -> Array a -> Array b
mapA :: forall a b. (Unbox a, Unbox b) => (a -> b) -> Array a -> Array b
mapA a -> b
f = forall a. Array Vector a -> Array a
A forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (v :: * -> *) a b.
(Vector v, VecElem v a, VecElem v b) =>
(a -> b) -> Array v a -> Array v b
G.mapA a -> b
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Array a -> Array Vector a
unA
{-# INLINE zipWithA #-}
zipWithA :: (HasCallStack, Unbox a, Unbox b, Unbox c) =>
(a -> b -> c) -> Array a -> Array b -> Array c
zipWithA :: forall a b c.
(HasCallStack, Unbox a, Unbox b, Unbox c) =>
(a -> b -> c) -> Array a -> Array b -> Array c
zipWithA a -> b -> c
f Array a
a Array b
b = forall a. Array Vector a -> Array a
A forall a b. (a -> b) -> a -> b
$ forall (v :: * -> *) a b c.
(HasCallStack, Vector v, VecElem v a, VecElem v b, VecElem v c) =>
(a -> b -> c) -> Array v a -> Array v b -> Array v c
G.zipWithA a -> b -> c
f (forall a. Array a -> Array Vector a
unA Array a
a) (forall a. Array a -> Array Vector a
unA Array b
b)
{-# INLINE zipWith3A #-}
zipWith3A :: (HasCallStack, Unbox a, Unbox b, Unbox c, Unbox d) =>
(a -> b -> c -> d) -> Array a -> Array b -> Array c -> Array d
zipWith3A :: forall a b c d.
(HasCallStack, Unbox a, Unbox b, Unbox c, Unbox d) =>
(a -> b -> c -> d) -> Array a -> Array b -> Array c -> Array d
zipWith3A a -> b -> c -> d
f Array a
a Array b
b Array c
c = forall a. Array Vector a -> Array a
A forall a b. (a -> b) -> a -> b
$ forall (v :: * -> *) a b c d.
(HasCallStack, Vector v, VecElem v a, VecElem v b, VecElem v c,
VecElem v d) =>
(a -> b -> c -> d)
-> Array v a -> Array v b -> Array v c -> Array v d
G.zipWith3A a -> b -> c -> d
f (forall a. Array a -> Array Vector a
unA Array a
a) (forall a. Array a -> Array Vector a
unA Array b
b) (forall a. Array a -> Array Vector a
unA Array c
c)
{-# INLINE zipWith4A #-}
zipWith4A :: (HasCallStack, Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) =>
(a -> b -> c -> d -> e) -> Array a -> Array b -> Array c -> Array d -> Array e
zipWith4A :: forall a b c d e.
(HasCallStack, Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) =>
(a -> b -> c -> d -> e)
-> Array a -> Array b -> Array c -> Array d -> Array e
zipWith4A a -> b -> c -> d -> e
f Array a
a Array b
b Array c
c Array d
d = forall a. Array Vector a -> Array a
A forall a b. (a -> b) -> a -> b
$ forall (v :: * -> *) a b c d e.
(HasCallStack, Vector v, VecElem v a, VecElem v b, VecElem v c,
VecElem v d, VecElem v e) =>
(a -> b -> c -> d -> e)
-> Array v a -> Array v b -> Array v c -> Array v d -> Array v e
G.zipWith4A a -> b -> c -> d -> e
f (forall a. Array a -> Array Vector a
unA Array a
a) (forall a. Array a -> Array Vector a
unA Array b
b) (forall a. Array a -> Array Vector a
unA Array c
c) (forall a. Array a -> Array Vector a
unA Array d
d)
{-# INLINE zipWith5A #-}
zipWith5A :: (HasCallStack, Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f) =>
(a -> b -> c -> d -> e -> f) -> Array a -> Array b -> Array c -> Array d -> Array e -> Array f
zipWith5A :: forall a b c d e f.
(HasCallStack, Unbox a, Unbox b, Unbox c, Unbox d, Unbox e,
Unbox f) =>
(a -> b -> c -> d -> e -> f)
-> Array a -> Array b -> Array c -> Array d -> Array e -> Array f
zipWith5A a -> b -> c -> d -> e -> f
f Array a
a Array b
b Array c
c Array d
d Array e
e = forall a. Array Vector a -> Array a
A forall a b. (a -> b) -> a -> b
$ forall (v :: * -> *) a b c d e f.
(HasCallStack, Vector v, VecElem v a, VecElem v b, VecElem v c,
VecElem v d, VecElem v e, VecElem v f) =>
(a -> b -> c -> d -> e -> f)
-> Array v a
-> Array v b
-> Array v c
-> Array v d
-> Array v e
-> Array v f
G.zipWith5A a -> b -> c -> d -> e -> f
f (forall a. Array a -> Array Vector a
unA Array a
a) (forall a. Array a -> Array Vector a
unA Array b
b) (forall a. Array a -> Array Vector a
unA Array c
c) (forall a. Array a -> Array Vector a
unA Array d
d) (forall a. Array a -> Array Vector a
unA Array e
e)
pad :: (HasCallStack, Unbox a) => [(Int, Int)] -> a -> Array a -> Array a
pad :: forall a.
(HasCallStack, Unbox a) =>
[(Int, Int)] -> a -> Array a -> Array a
pad [(Int, Int)]
ps a
v = forall a. Array Vector a -> Array a
A forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a (v :: * -> *).
(Vector v, VecElem v a) =>
[(Int, Int)] -> a -> Array v a -> Array v a
G.pad [(Int, Int)]
ps a
v forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Array a -> Array Vector a
unA
transpose :: (HasCallStack) => [Int] -> Array a -> Array a
transpose :: forall a. HasCallStack => ShapeL -> Array a -> Array a
transpose ShapeL
is = forall a. Array Vector a -> Array a
A forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (v :: * -> *) a.
HasCallStack =>
ShapeL -> Array v a -> Array v a
G.transpose ShapeL
is forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Array a -> Array Vector a
unA
append :: (HasCallStack, Unbox a) => Array a -> Array a -> Array a
append :: forall a. (HasCallStack, Unbox a) => Array a -> Array a -> Array a
append Array a
x Array a
y = forall a. Array Vector a -> Array a
A forall a b. (a -> b) -> a -> b
$ forall (v :: * -> *) a.
(HasCallStack, Vector v, VecElem v a) =>
Array v a -> Array v a -> Array v a
G.append (forall a. Array a -> Array Vector a
unA Array a
x) (forall a. Array a -> Array Vector a
unA Array a
y)
concatOuter :: (HasCallStack, Unbox a) => [Array a] -> Array a
concatOuter :: forall a. (HasCallStack, Unbox a) => [Array a] -> Array a
concatOuter = forall a. Array Vector a -> Array a
A forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (v :: * -> *) a.
(HasCallStack, Vector v, VecElem v a) =>
[Array v a] -> Array v a
G.concatOuter forall b c a. (b -> c) -> (a -> b) -> a -> c
. coerce :: forall a b. Coercible a b => a -> b
coerce
ravel :: (HasCallStack, Unbox a) => D.Array (Array a) -> Array a
ravel :: forall a. (HasCallStack, Unbox a) => Array (Array a) -> Array a
ravel = forall a. Array Vector a -> Array a
A forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (v :: * -> *) (v' :: * -> *) a.
(HasCallStack, Vector v, Vector v', VecElem v a,
VecElem v' (Array v a)) =>
Array v' (Array v a) -> Array v a
G.ravel forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (v :: * -> *) a b.
(Vector v, VecElem v a, VecElem v b) =>
(a -> b) -> Array v a -> Array v b
G.mapA forall a. Array a -> Array Vector a
unA forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Array a -> Array Vector a
D.unA
unravel :: (HasCallStack, Unbox a) => Array a -> D.Array (Array a)
unravel :: forall a. (HasCallStack, Unbox a) => Array a -> Array (Array a)
unravel = forall a. Array Vector a -> Array a
D.A forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (v :: * -> *) a b.
(Vector v, VecElem v a, VecElem v b) =>
(a -> b) -> Array v a -> Array v b
G.mapA forall a. Array Vector a -> Array a
A forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (v :: * -> *) (v' :: * -> *) a.
(Vector v, Vector v', VecElem v a, VecElem v' (Array v a)) =>
Array v a -> Array v' (Array v a)
G.unravel forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Array a -> Array Vector a
unA
window :: (HasCallStack) => [Int] -> Array a -> Array a
window :: forall a. HasCallStack => ShapeL -> Array a -> Array a
window ShapeL
ws = forall a. Array Vector a -> Array a
A forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (v :: * -> *) a.
(HasCallStack, Vector v) =>
ShapeL -> Array v a -> Array v a
G.window ShapeL
ws forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Array a -> Array Vector a
unA
stride :: (HasCallStack) => [Int] -> Array a -> Array a
stride :: forall a. HasCallStack => ShapeL -> Array a -> Array a
stride ShapeL
ws = forall a. Array Vector a -> Array a
A forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (v :: * -> *) a.
(HasCallStack, Vector v) =>
ShapeL -> Array v a -> Array v a
G.stride ShapeL
ws forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Array a -> Array Vector a
unA
slice :: (HasCallStack) => [(Int, Int)] -> Array a -> Array a
slice :: forall a. HasCallStack => [(Int, Int)] -> Array a -> Array a
slice [(Int, Int)]
ss = forall a. Array Vector a -> Array a
A forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (v :: * -> *) a.
HasCallStack =>
[(Int, Int)] -> Array v a -> Array v a
G.slice [(Int, Int)]
ss forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Array a -> Array Vector a
unA
rerank :: (HasCallStack, Unbox a, Unbox b) => Int -> (Array a -> Array b) -> Array a -> Array b
rerank :: forall a b.
(HasCallStack, Unbox a, Unbox b) =>
Int -> (Array a -> Array b) -> Array a -> Array b
rerank Int
n Array a -> Array b
f = forall a. Array Vector a -> Array a
A forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (v :: * -> *) (v' :: * -> *) a b.
(HasCallStack, Vector v, Vector v', VecElem v a, VecElem v' b) =>
Int -> (Array v a -> Array v' b) -> Array v a -> Array v' b
G.rerank Int
n (forall a. Array a -> Array Vector a
unA forall b c a. (b -> c) -> (a -> b) -> a -> c
. Array a -> Array b
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Array Vector a -> Array a
A) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Array a -> Array Vector a
unA
rerank2 :: (HasCallStack, Unbox a, Unbox b, Unbox c) =>
Int -> (Array a -> Array b -> Array c) -> Array a -> Array b -> Array c
rerank2 :: forall a b c.
(HasCallStack, Unbox a, Unbox b, Unbox c) =>
Int
-> (Array a -> Array b -> Array c) -> Array a -> Array b -> Array c
rerank2 Int
n Array a -> Array b -> Array c
f Array a
ta Array b
tb = forall a. Array Vector a -> Array a
A forall a b. (a -> b) -> a -> b
$ forall (v :: * -> *) a b c.
(HasCallStack, Vector v, VecElem v a, VecElem v b, VecElem v c) =>
Int
-> (Array v a -> Array v b -> Array v c)
-> Array v a
-> Array v b
-> Array v c
G.rerank2 Int
n (\ Array Vector a
a Array Vector b
b -> forall a. Array a -> Array Vector a
unA forall a b. (a -> b) -> a -> b
$ Array a -> Array b -> Array c
f (forall a. Array Vector a -> Array a
A Array Vector a
a) (forall a. Array Vector a -> Array a
A Array Vector b
b)) (forall a. Array a -> Array Vector a
unA Array a
ta) (forall a. Array a -> Array Vector a
unA Array b
tb)
rev :: [Int] -> Array a -> Array a
rev :: forall a. ShapeL -> Array a -> Array a
rev ShapeL
rs = forall a. Array Vector a -> Array a
A forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (v :: * -> *) a.
HasCallStack =>
ShapeL -> Array v a -> Array v a
G.rev ShapeL
rs forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Array a -> Array Vector a
unA
reduce :: (Unbox a) => (a -> a -> a) -> a -> Array a -> Array a
reduce :: forall a. Unbox a => (a -> a -> a) -> a -> Array a -> Array a
reduce a -> a -> a
f a
z = forall a. Array Vector a -> Array a
A forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (v :: * -> *) a.
(Vector v, VecElem v a) =>
(a -> a -> a) -> a -> Array v a -> Array v a
G.reduce a -> a -> a
f a
z forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Array a -> Array Vector a
unA
foldrA :: (Unbox a) => (a -> b -> b) -> b -> Array a -> b
foldrA :: forall a b. Unbox a => (a -> b -> b) -> b -> Array a -> b
foldrA a -> b -> b
f b
z = forall (v :: * -> *) a b.
(Vector v, VecElem v a) =>
(a -> b -> b) -> b -> Array v a -> b
G.foldrA a -> b -> b
f b
z forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Array a -> Array Vector a
unA
traverseA
:: (Unbox a, Unbox b, Applicative f) => (a -> f b) -> Array a -> f (Array b)
traverseA :: forall a b (f :: * -> *).
(Unbox a, Unbox b, Applicative f) =>
(a -> f b) -> Array a -> f (Array b)
traverseA a -> f b
f = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. Array Vector a -> Array a
A forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (v :: * -> *) a b (f :: * -> *).
(Vector v, VecElem v a, VecElem v b, Applicative f) =>
(a -> f b) -> Array v a -> f (Array v b)
G.traverseA a -> f b
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Array a -> Array Vector a
unA
{-# INLINE allSameA #-}
allSameA :: (Unbox a, Eq a) => Array a -> Bool
allSameA :: forall a. (Unbox a, Eq a) => Array a -> Bool
allSameA = forall (v :: * -> *) a.
(Vector v, VecElem v a, Eq a) =>
Array v a -> Bool
G.allSameA forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Array a -> Array Vector a
unA
instance (Arbitrary a, Unbox a) => Arbitrary (Array a) where arbitrary :: Gen (Array a)
arbitrary = forall a. Array Vector a -> Array a
A forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. Arbitrary a => Gen a
arbitrary
{-# INLINE sumA #-}
sumA :: (Unbox a, Num a) => Array a -> a
sumA :: forall a. (Unbox a, Num a) => Array a -> a
sumA = forall (v :: * -> *) a.
(Vector v, VecElem v a, Num a) =>
Array v a -> a
G.sumA forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Array a -> Array Vector a
unA
{-# INLINE productA #-}
productA :: (Unbox a, Num a) => Array a -> a
productA :: forall a. (Unbox a, Num a) => Array a -> a
productA = forall (v :: * -> *) a.
(Vector v, VecElem v a, Num a) =>
Array v a -> a
G.productA forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Array a -> Array Vector a
unA
{-# INLINE maximumA #-}
maximumA :: (HasCallStack, Unbox a, Ord a) => Array a -> a
maximumA :: forall a. (HasCallStack, Unbox a, Ord a) => Array a -> a
maximumA = forall (v :: * -> *) a.
(HasCallStack, Vector v, VecElem v a, Ord a) =>
Array v a -> a
G.maximumA forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Array a -> Array Vector a
unA
{-# INLINE minimumA #-}
minimumA :: (HasCallStack, Unbox a, Ord a) => Array a -> a
minimumA :: forall a. (HasCallStack, Unbox a, Ord a) => Array a -> a
minimumA = forall (v :: * -> *) a.
(HasCallStack, Vector v, VecElem v a, Ord a) =>
Array v a -> a
G.minimumA forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Array a -> Array Vector a
unA
{-# INLINE anyA #-}
anyA :: Unbox a => (a -> Bool) -> Array a -> Bool
anyA :: forall a. Unbox a => (a -> Bool) -> Array a -> Bool
anyA a -> Bool
p = forall (v :: * -> *) a.
(Vector v, VecElem v a) =>
(a -> Bool) -> Array v a -> Bool
G.anyA a -> Bool
p forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Array a -> Array Vector a
unA
{-# INLINE allA #-}
allA :: Unbox a => (a -> Bool) -> Array a -> Bool
allA :: forall a. Unbox a => (a -> Bool) -> Array a -> Bool
allA a -> Bool
p = forall (v :: * -> *) a.
(Vector v, VecElem v a) =>
(a -> Bool) -> Array v a -> Bool
G.allA a -> Bool
p forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Array a -> Array Vector a
unA
{-# INLINE broadcast #-}
broadcast :: (HasCallStack, Unbox a) =>
[Int] -> ShapeL -> Array a -> Array a
broadcast :: forall a.
(HasCallStack, Unbox a) =>
ShapeL -> ShapeL -> Array a -> Array a
broadcast ShapeL
ds ShapeL
sh = forall a. Array Vector a -> Array a
Aforall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (v :: * -> *) a.
(HasCallStack, Vector v, VecElem v a) =>
ShapeL -> ShapeL -> Array v a -> Array v a
G.broadcast ShapeL
ds ShapeL
sh forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Array a -> Array Vector a
unA
{-# INLINE update #-}
update :: (HasCallStack, Unbox a) =>
Array a -> [([Int], a)] -> Array a
update :: forall a.
(HasCallStack, Unbox a) =>
Array a -> [(ShapeL, a)] -> Array a
update Array a
a = forall a. Array Vector a -> Array a
A forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (v :: * -> *) a.
(HasCallStack, Vector v, VecElem v a) =>
Array v a -> [(ShapeL, a)] -> Array v a
G.update (forall a. Array a -> Array Vector a
unA Array a
a)
{-# INLINE generate #-}
generate :: (Unbox a) => ShapeL -> ([Int] -> a) -> Array a
generate :: forall a. Unbox a => ShapeL -> (ShapeL -> a) -> Array a
generate ShapeL
sh = forall a. Array Vector a -> Array a
A forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (v :: * -> *) a.
(Vector v, VecElem v a) =>
ShapeL -> (ShapeL -> a) -> Array v a
G.generate ShapeL
sh
{-# INLINE iterateN #-}
iterateN :: (Unbox a) =>
Int -> (a -> a) -> a -> Array a
iterateN :: forall a. Unbox a => Int -> (a -> a) -> a -> Array a
iterateN Int
n a -> a
f = forall a. Array Vector a -> Array a
A forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (v :: * -> *) a.
(Vector v, VecElem v a) =>
Int -> (a -> a) -> a -> Array v a
G.iterateN Int
n a -> a
f
{-# INLINE iota #-}
iota :: (Unbox a, Enum a, Num a) => Int -> Array a
iota :: forall a. (Unbox a, Enum a, Num a) => Int -> Array a
iota = forall a. Array Vector a -> Array a
A forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (v :: * -> *) a.
(Vector v, VecElem v a, Enum a, Num a) =>
Int -> Array v a
G.iota