{-# LANGUAGE AllowAmbiguousTypes #-}
{-# LANGUAGE ConstraintKinds #-}
{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE ExplicitNamespaces #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE UndecidableInstances #-}
module Data.Array.Internal.RankedS(
Array(..), Vector, ShapeL, Unbox,
size, shapeL, rank,
toList, fromList, toVector, fromVector,
normalize,
scalar, unScalar, constant,
reshape, stretch, stretchOuter, transpose,
index, pad,
mapA, zipWithA, zipWith3A,
append, concatOuter,
ravel, unravel,
window, stride, rotate,
slice, rerank, rerank2, rev,
reduce, foldrA, traverseA,
allSameA,
sumA, productA, minimumA, maximumA,
anyA, allA,
broadcast,
generate, iterateN, iota,
) where
import Control.DeepSeq
import Data.Coerce(coerce)
import Data.Data(Data)
import qualified Data.Vector.Storable as V
import GHC.TypeLits(KnownNat, type (+), type (<=))
import Test.QuickCheck hiding (generate)
import GHC.Generics(Generic)
import GHC.Stack(HasCallStack)
import Text.PrettyPrint.HughesPJClass hiding ((<>))
import Data.Array.Internal.DynamicS()
import qualified Data.Array.Internal.Ranked as R
import qualified Data.Array.Internal.RankedG as G
import Data.Array.Internal(ShapeL, Vector(..))
type Unbox = V.Storable
newtype Array n a = A { forall (n :: Nat) a. Array n a -> Array n Vector a
unA :: G.Array n V.Vector a }
deriving (PrettyLevel -> [Array n a] -> Doc
PrettyLevel -> Rational -> Array n a -> Doc
Array n a -> Doc
forall (n :: Nat) a.
(Pretty a, Storable a) =>
PrettyLevel -> [Array n a] -> Doc
forall (n :: Nat) a.
(Pretty a, Storable a) =>
PrettyLevel -> Rational -> Array n a -> Doc
forall (n :: Nat) a. (Pretty a, Storable a) => Array n a -> Doc
forall a.
(PrettyLevel -> Rational -> a -> Doc)
-> (a -> Doc) -> (PrettyLevel -> [a] -> Doc) -> Pretty a
pPrintList :: PrettyLevel -> [Array n a] -> Doc
$cpPrintList :: forall (n :: Nat) a.
(Pretty a, Storable a) =>
PrettyLevel -> [Array n a] -> Doc
pPrint :: Array n a -> Doc
$cpPrint :: forall (n :: Nat) a. (Pretty a, Storable a) => Array n a -> Doc
pPrintPrec :: PrettyLevel -> Rational -> Array n a -> Doc
$cpPrintPrec :: forall (n :: Nat) a.
(Pretty a, Storable a) =>
PrettyLevel -> Rational -> Array n a -> Doc
Pretty, forall (n :: Nat) a x. Rep (Array n a) x -> Array n a
forall (n :: Nat) a x. Array n a -> Rep (Array n a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall (n :: Nat) a x. Rep (Array n a) x -> Array n a
$cfrom :: forall (n :: Nat) a x. Array n a -> Rep (Array n a) x
Generic, Array n a -> DataType
Array n a -> Constr
forall {n :: Nat} {a}.
(KnownNat n, Data a, Storable a) =>
Typeable (Array n a)
forall (n :: Nat) a.
(KnownNat n, Data a, Storable a) =>
Array n a -> DataType
forall (n :: Nat) a.
(KnownNat n, Data a, Storable a) =>
Array n a -> Constr
forall (n :: Nat) a.
(KnownNat n, Data a, Storable a) =>
(forall b. Data b => b -> b) -> Array n a -> Array n a
forall (n :: Nat) a u.
(KnownNat n, Data a, Storable a) =>
Int -> (forall d. Data d => d -> u) -> Array n a -> u
forall (n :: Nat) a u.
(KnownNat n, Data a, Storable a) =>
(forall d. Data d => d -> u) -> Array n a -> [u]
forall (n :: Nat) a r r'.
(KnownNat n, Data a, Storable a) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Array n a -> r
forall (n :: Nat) a r r'.
(KnownNat n, Data a, Storable a) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Array n a -> r
forall (n :: Nat) a (m :: * -> *).
(KnownNat n, Data a, Storable a, Monad m) =>
(forall d. Data d => d -> m d) -> Array n a -> m (Array n a)
forall (n :: Nat) a (m :: * -> *).
(KnownNat n, Data a, Storable a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Array n a -> m (Array n a)
forall (n :: Nat) a (c :: * -> *).
(KnownNat n, Data a, Storable a) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Array n a)
forall (n :: Nat) a (c :: * -> *).
(KnownNat n, Data a, Storable a) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Array n a -> c (Array n a)
forall (n :: Nat) a (t :: * -> *) (c :: * -> *).
(KnownNat n, Data a, Storable a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Array n a))
forall (n :: Nat) a (t :: * -> * -> *) (c :: * -> *).
(KnownNat n, Data a, Storable a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Array n 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 n a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Array n a -> c (Array n a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Array n a -> m (Array n a)
$cgmapMo :: forall (n :: Nat) a (m :: * -> *).
(KnownNat n, Data a, Storable a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Array n a -> m (Array n a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Array n a -> m (Array n a)
$cgmapMp :: forall (n :: Nat) a (m :: * -> *).
(KnownNat n, Data a, Storable a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Array n a -> m (Array n a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Array n a -> m (Array n a)
$cgmapM :: forall (n :: Nat) a (m :: * -> *).
(KnownNat n, Data a, Storable a, Monad m) =>
(forall d. Data d => d -> m d) -> Array n a -> m (Array n a)
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Array n a -> u
$cgmapQi :: forall (n :: Nat) a u.
(KnownNat n, Data a, Storable a) =>
Int -> (forall d. Data d => d -> u) -> Array n a -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Array n a -> [u]
$cgmapQ :: forall (n :: Nat) a u.
(KnownNat n, Data a, Storable a) =>
(forall d. Data d => d -> u) -> Array n a -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Array n a -> r
$cgmapQr :: forall (n :: Nat) a r r'.
(KnownNat n, Data a, Storable a) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Array n a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Array n a -> r
$cgmapQl :: forall (n :: Nat) a r r'.
(KnownNat n, Data a, Storable a) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Array n a -> r
gmapT :: (forall b. Data b => b -> b) -> Array n a -> Array n a
$cgmapT :: forall (n :: Nat) a.
(KnownNat n, Data a, Storable a) =>
(forall b. Data b => b -> b) -> Array n a -> Array n a
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Array n a))
$cdataCast2 :: forall (n :: Nat) a (t :: * -> * -> *) (c :: * -> *).
(KnownNat n, Data a, Storable a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Array n a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Array n a))
$cdataCast1 :: forall (n :: Nat) a (t :: * -> *) (c :: * -> *).
(KnownNat n, Data a, Storable a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Array n a))
dataTypeOf :: Array n a -> DataType
$cdataTypeOf :: forall (n :: Nat) a.
(KnownNat n, Data a, Storable a) =>
Array n a -> DataType
toConstr :: Array n a -> Constr
$ctoConstr :: forall (n :: Nat) a.
(KnownNat n, Data a, Storable a) =>
Array n a -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Array n a)
$cgunfold :: forall (n :: Nat) a (c :: * -> *).
(KnownNat n, Data a, Storable a) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Array n a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Array n a -> c (Array n a)
$cgfoldl :: forall (n :: Nat) a (c :: * -> *).
(KnownNat n, Data a, Storable a) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Array n a -> c (Array n a)
Data)
instance NFData a => NFData (Array n a)
instance (Show a, Unbox a) => Show (Array n a) where
showsPrec :: Int -> Array n 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 (n :: Nat) a. Array n a -> Array n Vector a
unA
instance (KnownNat n, Read a, Unbox a) => Read (Array n a) where
readsPrec :: Int -> ReadS (Array n a)
readsPrec Int
p String
s = [(forall (n :: Nat) a. Array n Vector a -> Array n a
A Array n Vector a
a, String
r) | (Array n Vector a
a, String
r) <- forall a. Read a => Int -> ReadS a
readsPrec Int
p String
s]
instance Eq (G.Array n V.Vector a) => Eq (Array n a) where
Array n a
x == :: Array n a -> Array n a -> Bool
== Array n a
y = forall (n :: Nat) a. Array n a -> ShapeL
shapeL Array n a
x forall a. Eq a => a -> a -> Bool
== forall (n :: Nat) a. Array n a -> ShapeL
shapeL Array n a
y Bool -> Bool -> Bool
&& forall (n :: Nat) a. Array n a -> Array n Vector a
unA Array n a
x forall a. Eq a => a -> a -> Bool
== forall (n :: Nat) a. Array n a -> Array n Vector a
unA Array n a
y
{-# INLINE (==) #-}
instance Ord (G.Array n V.Vector a) => Ord (Array n a) where
compare :: Array n a -> Array n a -> Ordering
compare Array n a
x Array n a
y = forall a. Ord a => a -> a -> Ordering
compare (forall (n :: Nat) a. Array n a -> ShapeL
shapeL Array n a
x) (forall (n :: Nat) a. Array n a -> ShapeL
shapeL Array n a
y) forall a. Semigroup a => a -> a -> a
<> forall a. Ord a => a -> a -> Ordering
compare (forall (n :: Nat) a. Array n a -> Array n Vector a
unA Array n a
x) (forall (n :: Nat) a. Array n a -> Array n Vector a
unA Array n a
y)
{-# INLINE compare #-}
{-# INLINE size #-}
size :: Array n a -> Int
size :: forall (n :: Nat) a. Array n 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 (n :: Nat) a. Array n a -> ShapeL
shapeL
shapeL :: Array n a -> ShapeL
shapeL :: forall (n :: Nat) a. Array n a -> ShapeL
shapeL = forall (n :: Nat) (v :: * -> *) a. Array n v a -> ShapeL
G.shapeL forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) a. Array n a -> Array n Vector a
unA
rank :: (KnownNat n) => Array n a -> Int
rank :: forall (n :: Nat) a. KnownNat n => Array n a -> Int
rank = forall (n :: Nat) (v :: * -> *) a. KnownNat n => Array n v a -> Int
G.rank forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) a. Array n a -> Array n Vector a
unA
index :: (Unbox a) => Array (1+n) a -> Int -> Array n a
index :: forall a (n :: Nat). Unbox a => Array (1 + n) a -> Int -> Array n a
index Array (1 + n) a
a = forall (n :: Nat) a. Array n Vector a -> Array n a
A forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (v :: * -> *) (n :: Nat) a.
(Vector v, HasCallStack) =>
Array (1 + n) v a -> Int -> Array n v a
G.index (forall (n :: Nat) a. Array n a -> Array n Vector a
unA Array (1 + n) a
a)
{-# INLINABLE toList #-}
toList :: (Unbox a) => Array n a -> [a]
toList :: forall a (n :: Nat). Unbox a => Array n a -> [a]
toList = forall (v :: * -> *) a (n :: Nat).
(Vector v, VecElem v a) =>
Array n v a -> [a]
G.toList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) a. Array n a -> Array n Vector a
unA
{-# INLINABLE fromList #-}
fromList :: (Unbox a, KnownNat n) => ShapeL -> [a] -> Array n a
fromList :: forall a (n :: Nat).
(Unbox a, KnownNat n) =>
ShapeL -> [a] -> Array n a
fromList ShapeL
ss = forall (n :: Nat) a. Array n Vector a -> Array n a
A forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) (v :: * -> *) a.
(HasCallStack, Vector v, VecElem v a, KnownNat n) =>
ShapeL -> [a] -> Array n v a
G.fromList ShapeL
ss
{-# INLINABLE toVector #-}
toVector :: (Unbox a) => Array n a -> V.Vector a
toVector :: forall a (n :: Nat). Unbox a => Array n a -> Vector a
toVector = forall (v :: * -> *) a (n :: Nat).
(Vector v, VecElem v a) =>
Array n v a -> v a
G.toVector forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) a. Array n a -> Array n Vector a
unA
{-# INLINABLE fromVector #-}
fromVector :: (Unbox a, KnownNat n) => ShapeL -> V.Vector a -> Array n a
fromVector :: forall a (n :: Nat).
(Unbox a, KnownNat n) =>
ShapeL -> Vector a -> Array n a
fromVector ShapeL
ss = forall (n :: Nat) a. Array n Vector a -> Array n a
A forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) (v :: * -> *) a.
(HasCallStack, Vector v, VecElem v a, KnownNat n) =>
ShapeL -> v a -> Array n v a
G.fromVector ShapeL
ss
normalize :: (Unbox a, KnownNat n) => Array n a -> Array n a
normalize :: forall a (n :: Nat).
(Unbox a, KnownNat n) =>
Array n a -> Array n a
normalize = forall (n :: Nat) a. Array n Vector a -> Array n a
A forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (v :: * -> *) a (n :: Nat).
(Vector v, VecElem v a, KnownNat n) =>
Array n v a -> Array n v a
G.normalize forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) a. Array n a -> Array n Vector a
unA
reshape :: (Unbox a, KnownNat n, KnownNat n') => ShapeL -> Array n a -> Array n' a
reshape :: forall a (n :: Nat) (n' :: Nat).
(Unbox a, KnownNat n, KnownNat n') =>
ShapeL -> Array n a -> Array n' a
reshape ShapeL
s = forall (n :: Nat) a. Array n Vector a -> Array n a
A forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) (n' :: Nat) (v :: * -> *) a.
(HasCallStack, Vector v, VecElem v a, KnownNat n, KnownNat n') =>
ShapeL -> Array n v a -> Array n' v a
G.reshape ShapeL
s forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) a. Array n a -> Array n Vector a
unA
stretch :: ShapeL -> Array n a -> Array n a
stretch :: forall (n :: Nat) a. ShapeL -> Array n a -> Array n a
stretch ShapeL
s = forall (n :: Nat) a. Array n Vector a -> Array n a
A forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) (v :: * -> *) a.
HasCallStack =>
ShapeL -> Array n v a -> Array n v a
G.stretch ShapeL
s forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) a. Array n a -> Array n Vector a
unA
stretchOuter :: (HasCallStack, 1 <= n) => Int -> Array n a -> Array n a
stretchOuter :: forall (n :: Nat) a.
(HasCallStack, 1 <= n) =>
Int -> Array n a -> Array n a
stretchOuter Int
s = forall (n :: Nat) a. Array n Vector a -> Array n a
A forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) (v :: * -> *) a.
(HasCallStack, 1 <= n) =>
Int -> Array n v a -> Array n v a
G.stretchOuter Int
s forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) a. Array n a -> Array n Vector a
unA
scalar :: (Unbox a) => a -> Array 0 a
scalar :: forall a. Unbox a => a -> Array 0 a
scalar = forall (n :: Nat) a. Array n Vector a -> Array n a
A forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (v :: * -> *) a. (Vector v, VecElem v a) => a -> Array 0 v a
G.scalar
unScalar :: (Unbox a) => Array 0 a -> a
unScalar :: forall a. Unbox a => Array 0 a -> a
unScalar = forall (v :: * -> *) a. (Vector v, VecElem v a) => Array 0 v a -> a
G.unScalar forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) a. Array n a -> Array n Vector a
unA
constant :: (Unbox a, KnownNat n) => ShapeL -> a -> Array n a
constant :: forall a (n :: Nat).
(Unbox a, KnownNat n) =>
ShapeL -> a -> Array n a
constant ShapeL
sh = forall (n :: Nat) a. Array n Vector a -> Array n a
A forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) (v :: * -> *) a.
(Vector v, VecElem v a, KnownNat n) =>
ShapeL -> a -> Array n v a
G.constant ShapeL
sh
mapA :: (Unbox a, Unbox b) =>
(a -> b) -> Array n a -> Array n b
mapA :: forall a b (n :: Nat).
(Unbox a, Unbox b) =>
(a -> b) -> Array n a -> Array n b
mapA a -> b
f = forall (n :: Nat) a. Array n Vector a -> Array n a
A forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (v :: * -> *) a b (n :: Nat).
(Vector v, VecElem v a, VecElem v b) =>
(a -> b) -> Array n v a -> Array n v b
G.mapA a -> b
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) a. Array n a -> Array n Vector a
unA
zipWithA :: (Unbox a, Unbox b, Unbox c) =>
(a -> b -> c) -> Array n a -> Array n b -> Array n c
zipWithA :: forall a b c (n :: Nat).
(Unbox a, Unbox b, Unbox c) =>
(a -> b -> c) -> Array n a -> Array n b -> Array n c
zipWithA a -> b -> c
f Array n a
a Array n b
b = forall (n :: Nat) a. Array n Vector a -> Array n a
A forall a b. (a -> b) -> a -> b
$ forall (v :: * -> *) a b c (n :: Nat).
(Vector v, VecElem v a, VecElem v b, VecElem v c) =>
(a -> b -> c) -> Array n v a -> Array n v b -> Array n v c
G.zipWithA a -> b -> c
f (forall (n :: Nat) a. Array n a -> Array n Vector a
unA Array n a
a) (forall (n :: Nat) a. Array n a -> Array n Vector a
unA Array n b
b)
zipWith3A :: (Unbox a, Unbox b, Unbox c, Unbox d) =>
(a -> b -> c -> d) -> Array n a -> Array n b -> Array n c -> Array n d
zipWith3A :: forall a b c d (n :: Nat).
(Unbox a, Unbox b, Unbox c, Unbox d) =>
(a -> b -> c -> d)
-> Array n a -> Array n b -> Array n c -> Array n d
zipWith3A a -> b -> c -> d
f Array n a
a Array n b
b Array n c
c = forall (n :: Nat) a. Array n Vector a -> Array n a
A forall a b. (a -> b) -> a -> b
$ forall (v :: * -> *) a b c d (n :: Nat).
(Vector v, VecElem v a, VecElem v b, VecElem v c, VecElem v d) =>
(a -> b -> c -> d)
-> Array n v a -> Array n v b -> Array n v c -> Array n v d
G.zipWith3A a -> b -> c -> d
f (forall (n :: Nat) a. Array n a -> Array n Vector a
unA Array n a
a) (forall (n :: Nat) a. Array n a -> Array n Vector a
unA Array n b
b) (forall (n :: Nat) a. Array n a -> Array n Vector a
unA Array n c
c)
pad :: (Unbox a, KnownNat n) => [(Int, Int)] -> a -> Array n a -> Array n a
pad :: forall a (n :: Nat).
(Unbox a, KnownNat n) =>
[(Int, Int)] -> a -> Array n a -> Array n a
pad [(Int, Int)]
ps a
v = forall (n :: Nat) a. Array n Vector a -> Array n a
A forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) a (v :: * -> *).
(Vector v, VecElem v a) =>
[(Int, Int)] -> a -> Array n v a -> Array n v a
G.pad [(Int, Int)]
ps a
v forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) a. Array n a -> Array n Vector a
unA
transpose :: (KnownNat n) => [Int] -> Array n a -> Array n a
transpose :: forall (n :: Nat) a. KnownNat n => ShapeL -> Array n a -> Array n a
transpose ShapeL
is = forall (n :: Nat) a. Array n Vector a -> Array n a
A forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) (v :: * -> *) a.
KnownNat n =>
ShapeL -> Array n v a -> Array n v a
G.transpose ShapeL
is forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) a. Array n a -> Array n Vector a
unA
append :: (Unbox a, KnownNat n) => Array n a -> Array n a -> Array n a
append :: forall a (n :: Nat).
(Unbox a, KnownNat n) =>
Array n a -> Array n a -> Array n a
append Array n a
x Array n a
y = forall (n :: Nat) a. Array n Vector a -> Array n a
A forall a b. (a -> b) -> a -> b
$ forall (v :: * -> *) a (n :: Nat).
(Vector v, VecElem v a, KnownNat n) =>
Array n v a -> Array n v a -> Array n v a
G.append (forall (n :: Nat) a. Array n a -> Array n Vector a
unA Array n a
x) (forall (n :: Nat) a. Array n a -> Array n Vector a
unA Array n a
y)
concatOuter :: (Unbox a, KnownNat n) => [Array n a] -> Array n a
concatOuter :: forall a (n :: Nat).
(Unbox a, KnownNat n) =>
[Array n a] -> Array n a
concatOuter = forall (n :: Nat) a. Array n Vector a -> Array n a
A forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (v :: * -> *) a (n :: Nat).
(Vector v, VecElem v a, KnownNat n) =>
[Array n v a] -> Array n v a
G.concatOuter forall b c a. (b -> c) -> (a -> b) -> a -> c
. coerce :: forall a b. Coercible a b => a -> b
coerce
{-# INLINABLE ravel #-}
ravel :: (Unbox a, KnownNat (1+n)) =>
R.Array 1 (Array n a) -> Array (1+n) a
ravel :: forall a (n :: Nat).
(Unbox a, KnownNat (1 + n)) =>
Array 1 (Array n a) -> Array (1 + n) a
ravel = forall (n :: Nat) a. Array n Vector a -> Array n a
A forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (v :: * -> *) (v' :: * -> *) a (n :: Nat).
(Vector v, Vector v', VecElem v a, VecElem v' (Array n v a),
KnownNat (1 + n)) =>
Array 1 v' (Array n v a) -> Array (1 + n) v a
G.ravel forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (v :: * -> *) a b (n :: Nat).
(Vector v, VecElem v a, VecElem v b) =>
(a -> b) -> Array n v a -> Array n v b
G.mapA forall (n :: Nat) a. Array n a -> Array n Vector a
unA forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) a. Array n a -> Array n Vector a
R.unA
{-# INLINABLE unravel #-}
unravel :: (Unbox a) =>
Array (1+n) a -> R.Array 1 (Array n a)
unravel :: forall a (n :: Nat).
Unbox a =>
Array (1 + n) a -> Array 1 (Array n a)
unravel = forall (n :: Nat) a. Array n Vector a -> Array n a
R.A forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (v :: * -> *) a b (n :: Nat).
(Vector v, VecElem v a, VecElem v b) =>
(a -> b) -> Array n v a -> Array n v b
G.mapA forall (n :: Nat) a. Array n Vector a -> Array n a
A forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (v :: * -> *) (v' :: * -> *) a (n :: Nat).
(Vector v, Vector v', VecElem v a, VecElem v' (Array n v a)) =>
Array (1 + n) v a -> Array 1 v' (Array n v a)
G.unravel forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) a. Array n a -> Array n Vector a
unA
window :: (KnownNat n, KnownNat n') => [Int] -> Array n a -> Array n' a
window :: forall (n :: Nat) (n' :: Nat) a.
(KnownNat n, KnownNat n') =>
ShapeL -> Array n a -> Array n' a
window ShapeL
ws = forall (n :: Nat) a. Array n Vector a -> Array n a
A forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) (n' :: Nat) (v :: * -> *) a.
(Vector v, KnownNat n, KnownNat n') =>
ShapeL -> Array n v a -> Array n' v a
G.window ShapeL
ws forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) a. Array n a -> Array n Vector a
unA
stride :: [Int] -> Array n a -> Array n a
stride :: forall (n :: Nat) a. ShapeL -> Array n a -> Array n a
stride ShapeL
ws = forall (n :: Nat) a. Array n Vector a -> Array n a
A forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (v :: * -> *) (n :: Nat) a.
Vector v =>
ShapeL -> Array n v a -> Array n v a
G.stride ShapeL
ws forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) a. Array n a -> Array n Vector a
unA
rotate :: forall d p a.
(KnownNat p, KnownNat d, Unbox a,
(d + (p + 1)) ~ ((p + d) + 1),
(d + p) ~ (p + d),
1 <= p + 1,
KnownNat ((p + d) + 1),
KnownNat (p + 1),
KnownNat (1 + (p + 1))
) =>
Int -> Array (p + d) a -> Array (p + d + 1) a
rotate :: forall (d :: Nat) (p :: Nat) a.
(KnownNat p, KnownNat d, Unbox a, (d + (p + 1)) ~ ((p + d) + 1),
(d + p) ~ (p + d), 1 <= (p + 1), KnownNat ((p + d) + 1),
KnownNat (p + 1), KnownNat (1 + (p + 1))) =>
Int -> Array (p + d) a -> Array ((p + d) + 1) a
rotate Int
k = forall (n :: Nat) a. Array n Vector a -> Array n a
A forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (d :: Nat) (p :: Nat) (v :: * -> *) a.
(KnownNat p, KnownNat d, Vector v, VecElem v a,
(d + (p + 1)) ~ ((p + d) + 1), (d + p) ~ (p + d), 1 <= (p + 1),
KnownNat ((p + d) + 1), KnownNat (p + 1),
KnownNat (1 + (p + 1))) =>
Int -> Array (p + d) v a -> Array ((p + d) + 1) v a
G.rotate @d @p Int
k forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) a. Array n a -> Array n Vector a
unA
slice :: [(Int, Int)] -> Array n a -> Array n a
slice :: forall (n :: Nat) a. [(Int, Int)] -> Array n a -> Array n a
slice [(Int, Int)]
ss = forall (n :: Nat) a. Array n Vector a -> Array n a
A forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) (v :: * -> *) a.
[(Int, Int)] -> Array n v a -> Array n v a
G.slice [(Int, Int)]
ss forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) a. Array n a -> Array n Vector a
unA
rerank :: forall n i o a b .
(Unbox a, Unbox b, KnownNat n, KnownNat o, KnownNat (n+o), KnownNat (1+o)) =>
(Array i a -> Array o b) -> Array (n+i) a -> Array (n+o) b
rerank :: forall (n :: Nat) (i :: Nat) (o :: Nat) a b.
(Unbox a, Unbox b, KnownNat n, KnownNat o, KnownNat (n + o),
KnownNat (1 + o)) =>
(Array i a -> Array o b) -> Array (n + i) a -> Array (n + o) b
rerank Array i a -> Array o b
f = forall (n :: Nat) a. Array n Vector a -> Array n a
A forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) (i :: Nat) (o :: Nat) (v :: * -> *)
(v' :: * -> *) a b.
(Vector v, Vector v', VecElem v a, VecElem v' b, KnownNat n,
KnownNat o, KnownNat (n + o), KnownNat (1 + o)) =>
(Array i v a -> Array o v' b)
-> Array (n + i) v a -> Array (n + o) v' b
G.rerank (forall (n :: Nat) a. Array n a -> Array n Vector a
unA forall b c a. (b -> c) -> (a -> b) -> a -> c
. Array i a -> Array o b
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) a. Array n Vector a -> Array n a
A) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) a. Array n a -> Array n Vector a
unA
rerank2 :: forall n i o a b c .
(Unbox a, Unbox b, Unbox c, KnownNat n, KnownNat o, KnownNat (n+o), KnownNat (1+o)) =>
(Array i a -> Array i b -> Array o c) -> Array (n+i) a -> Array (n+i) b -> Array (n+o) c
rerank2 :: forall (n :: Nat) (i :: Nat) (o :: Nat) a b c.
(Unbox a, Unbox b, Unbox c, KnownNat n, KnownNat o,
KnownNat (n + o), KnownNat (1 + o)) =>
(Array i a -> Array i b -> Array o c)
-> Array (n + i) a -> Array (n + i) b -> Array (n + o) c
rerank2 Array i a -> Array i b -> Array o c
f Array (n + i) a
ta Array (n + i) b
tb = forall (n :: Nat) a. Array n Vector a -> Array n a
A forall a b. (a -> b) -> a -> b
$ forall (n :: Nat) (i :: Nat) (o :: Nat) a b c (v :: * -> *).
(Vector v, VecElem v a, VecElem v b, VecElem v c, KnownNat n,
KnownNat o, KnownNat (n + o), KnownNat (1 + o)) =>
(Array i v a -> Array i v b -> Array o v c)
-> Array (n + i) v a -> Array (n + i) v b -> Array (n + o) v c
G.rerank2 @n (\ Array i Vector a
a Array i Vector b
b -> forall (n :: Nat) a. Array n a -> Array n Vector a
unA forall a b. (a -> b) -> a -> b
$ Array i a -> Array i b -> Array o c
f (forall (n :: Nat) a. Array n Vector a -> Array n a
A Array i Vector a
a) (forall (n :: Nat) a. Array n Vector a -> Array n a
A Array i Vector b
b)) (forall (n :: Nat) a. Array n a -> Array n Vector a
unA Array (n + i) a
ta) (forall (n :: Nat) a. Array n a -> Array n Vector a
unA Array (n + i) b
tb)
rev :: [Int] -> Array n a -> Array n a
rev :: forall (n :: Nat) a. ShapeL -> Array n a -> Array n a
rev ShapeL
rs = forall (n :: Nat) a. Array n Vector a -> Array n a
A forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) (v :: * -> *) a.
ShapeL -> Array n v a -> Array n v a
G.rev ShapeL
rs forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) a. Array n a -> Array n Vector a
unA
reduce :: (Unbox a) => (a -> a -> a) -> a -> Array n a -> Array 0 a
reduce :: forall a (n :: Nat).
Unbox a =>
(a -> a -> a) -> a -> Array n a -> Array 0 a
reduce a -> a -> a
f a
z = forall (n :: Nat) a. Array n Vector a -> Array n a
A forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (v :: * -> *) a (n :: Nat).
(Vector v, VecElem v a) =>
(a -> a -> a) -> a -> Array n v a -> Array 0 v a
G.reduce a -> a -> a
f a
z forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) a. Array n a -> Array n Vector a
unA
foldrA :: (Unbox a, Unbox b) => (a -> b -> b) -> b -> Array n a -> b
foldrA :: forall a b (n :: Nat).
(Unbox a, Unbox b) =>
(a -> b -> b) -> b -> Array n a -> b
foldrA a -> b -> b
f b
z = forall (v :: * -> *) a b (n :: Nat).
(Vector v, VecElem v a) =>
(a -> b -> b) -> b -> Array n v a -> b
G.foldrA a -> b -> b
f b
z forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) a. Array n a -> Array n Vector a
unA
traverseA
:: (Unbox a, Unbox b, Applicative f)
=> (a -> f b) -> Array n a -> f (Array n b)
traverseA :: forall a b (f :: * -> *) (n :: Nat).
(Unbox a, Unbox b, Applicative f) =>
(a -> f b) -> Array n a -> f (Array n b)
traverseA a -> f b
f = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall (n :: Nat) a. Array n Vector a -> Array n a
A forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (v :: * -> *) a b (f :: * -> *) (n :: Nat).
(Vector v, VecElem v a, VecElem v b, Applicative f) =>
(a -> f b) -> Array n v a -> f (Array n v b)
G.traverseA a -> f b
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) a. Array n a -> Array n Vector a
unA
allSameA :: (Unbox a, Eq a) => Array n a -> Bool
allSameA :: forall a (n :: Nat). (Unbox a, Eq a) => Array n a -> Bool
allSameA = forall (v :: * -> *) a (r :: Nat).
(Vector v, VecElem v a, Eq a) =>
Array r v a -> Bool
G.allSameA forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) a. Array n a -> Array n Vector a
unA
instance (KnownNat r, Arbitrary a, Unbox a) => Arbitrary (Array r a) where arbitrary :: Gen (Array r a)
arbitrary = forall (n :: Nat) a. Array n Vector a -> Array n 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 r a -> a
sumA :: forall a (r :: Nat). (Unbox a, Num a) => Array r a -> a
sumA = forall (v :: * -> *) a (r :: Nat).
(Vector v, VecElem v a, Num a) =>
Array r v a -> a
G.sumA forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) a. Array n a -> Array n Vector a
unA
{-# INLINE productA #-}
productA :: (Unbox a, Num a) => Array r a -> a
productA :: forall a (r :: Nat). (Unbox a, Num a) => Array r a -> a
productA = forall (v :: * -> *) a (r :: Nat).
(Vector v, VecElem v a, Num a) =>
Array r v a -> a
G.productA forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) a. Array n a -> Array n Vector a
unA
{-# INLINE maximumA #-}
maximumA :: (Unbox a, Ord a) => Array r a -> a
maximumA :: forall a (r :: Nat). (Unbox a, Ord a) => Array r a -> a
maximumA = forall (v :: * -> *) a (r :: Nat).
(HasCallStack, Vector v, VecElem v a, Ord a) =>
Array r v a -> a
G.maximumA forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) a. Array n a -> Array n Vector a
unA
{-# INLINE minimumA #-}
minimumA :: (Unbox a, Ord a) => Array r a -> a
minimumA :: forall a (r :: Nat). (Unbox a, Ord a) => Array r a -> a
minimumA = forall (v :: * -> *) a (r :: Nat).
(HasCallStack, Vector v, VecElem v a, Ord a) =>
Array r v a -> a
G.minimumA forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) a. Array n a -> Array n Vector a
unA
{-# INLINE anyA #-}
anyA :: Unbox a => (a -> Bool) -> Array r a -> Bool
anyA :: forall a (r :: Nat). Unbox a => (a -> Bool) -> Array r a -> Bool
anyA a -> Bool
p = forall (v :: * -> *) a (r :: Nat).
(Vector v, VecElem v a) =>
(a -> Bool) -> Array r v a -> Bool
G.anyA a -> Bool
p forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) a. Array n a -> Array n Vector a
unA
{-# INLINE allA #-}
allA :: Unbox a => (a -> Bool) -> Array r a -> Bool
allA :: forall a (r :: Nat). Unbox a => (a -> Bool) -> Array r a -> Bool
allA a -> Bool
p = forall (v :: * -> *) a (r :: Nat).
(Vector v, VecElem v a) =>
(a -> Bool) -> Array r v a -> Bool
G.allA a -> Bool
p forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) a. Array n a -> Array n Vector a
unA
broadcast :: forall r' r a .
(HasCallStack, Unbox a, KnownNat r, KnownNat r') =>
[Int] -> ShapeL -> Array r a -> Array r' a
broadcast :: forall (r' :: Nat) (r :: Nat) a.
(HasCallStack, Unbox a, KnownNat r, KnownNat r') =>
ShapeL -> ShapeL -> Array r a -> Array r' a
broadcast ShapeL
ds ShapeL
sh = forall (n :: Nat) a. Array n Vector a -> Array n a
A forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (r' :: Nat) (r :: Nat) (v :: * -> *) a.
(HasCallStack, Vector v, VecElem v a, KnownNat r, KnownNat r') =>
ShapeL -> ShapeL -> Array r v a -> Array r' v a
G.broadcast ShapeL
ds ShapeL
sh forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) a. Array n a -> Array n Vector a
unA
{-# INLINE generate #-}
generate :: forall n a . (KnownNat n, Unbox a) =>
ShapeL -> ([Int] -> a) -> Array n a
generate :: forall (n :: Nat) a.
(KnownNat n, Unbox a) =>
ShapeL -> (ShapeL -> a) -> Array n a
generate ShapeL
sh = forall (n :: Nat) a. Array n Vector a -> Array n a
A forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) (v :: * -> *) a.
(KnownNat n, Vector v, VecElem v a) =>
ShapeL -> (ShapeL -> a) -> Array n v a
G.generate ShapeL
sh
{-# INLINE iterateN #-}
iterateN :: forall a . (Unbox a) =>
Int -> (a -> a) -> a -> Array 1 a
iterateN :: forall a. Unbox a => Int -> (a -> a) -> a -> Array 1 a
iterateN Int
n a -> a
f = forall (n :: Nat) a. Array n Vector a -> Array n 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 1 v a
G.iterateN Int
n a -> a
f
{-# INLINE iota #-}
iota :: (Unbox a, Enum a, Num a) => Int -> Array 1 a
iota :: forall a. (Unbox a, Enum a, Num a) => Int -> Array 1 a
iota = forall (n :: Nat) a. Array n Vector a -> Array n 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 1 v a
G.iota