NumHask.Array

Documentation

>>> :set -XDataKinds
>>> :set -XOverloadedLists
>>> :set -XTypeFamilies
>>> let a = [1..24] :: Array [] '[2,3,4] Int
>>> let v = [1,2,3] :: Array [] '[3] Int

data family Array (c :: Type -> Type) (ds :: [k]) (a :: Type)

an array polymorphic in container and shape

>>> a
[[[1, 2, 3, 4],
  [5, 6, 7, 8],
  [9, 10, 11, 12]],
 [[13, 14, 15, 16],
  [17, 18, 19, 20],
  [21, 22, 23, 24]]]

Instances

Functor c => Functor (Array Nat c ds)

Methods

fmap :: (a -> b) -> Array Nat c ds a -> Array Nat c ds b

(<$) :: a -> Array Nat c ds b -> Array Nat c ds a

Foldable c => Foldable (Array Nat c ds)

Methods

fold :: Monoid m => Array Nat c ds m -> m

foldMap :: Monoid m => (a -> m) -> Array Nat c ds a -> m

foldr :: (a -> b -> b) -> b -> Array Nat c ds a -> b

foldr' :: (a -> b -> b) -> b -> Array Nat c ds a -> b

foldl :: (b -> a -> b) -> b -> Array Nat c ds a -> b

foldl' :: (b -> a -> b) -> b -> Array Nat c ds a -> b

foldr1 :: (a -> a -> a) -> Array Nat c ds a -> a

foldl1 :: (a -> a -> a) -> Array Nat c ds a -> a

toList :: Array Nat c ds a -> [a]

null :: Array Nat c ds a -> Bool

length :: Array Nat c ds a -> Int

elem :: Eq a => a -> Array Nat c ds a -> Bool

maximum :: Ord a => Array Nat c ds a -> a

minimum :: Ord a => Array Nat c ds a -> a

sum :: Num a => Array Nat c ds a -> a

product :: Num a => Array Nat c ds a -> a

(Dimensions r, Container c) => Distributive (Array Nat c r)

Methods

distribute :: Functor f => f (Array Nat c r a) -> Array Nat c r (f a)

collect :: Functor f => (a -> Array Nat c r b) -> f a -> Array Nat c r (f b)

distributeM :: Monad m => m (Array Nat c r a) -> Array Nat c r (m a)

collectM :: Monad m => (a -> Array Nat c r b) -> m a -> Array Nat c r (m b)

(Dimensions r, Container c) => Representable (Array Nat c r)

Associated Types

type Rep (Array Nat c r :: * -> *) :: *

Methods

tabulate :: (Rep (Array Nat c r) -> a) -> Array Nat c r a

index :: Array Nat c r a -> Rep (Array Nat c r) -> a

(Dimensions r, Container c) => Singleton (Array Nat c r)

Methods

singleton :: a -> Array Nat c r a

Dimensions r => HasShape (Array Nat c r)

Associated Types

type Shape (Array Nat c r :: * -> *) :: *

Methods

shape :: Array Nat c r a -> Shape (Array Nat c r)

HasShape (Array XNat c xds)

Associated Types

type Shape (Array XNat c xds :: * -> *) :: *

Methods

shape :: Array XNat c xds a -> Shape (Array XNat c xds)

(Dimensions r, Container c, Additive a) => AdditiveModule (Array Nat c r) a

Methods

(.+) :: Array Nat c r a -> a -> Array Nat c r a

(+.) :: a -> Array Nat c r a -> Array Nat c r a

(Dimensions r, Container c, AdditiveGroup a) => AdditiveGroupModule (Array Nat c r) a

Methods

(.-) :: Array Nat c r a -> a -> Array Nat c r a

(-.) :: a -> Array Nat c r a -> Array Nat c r a

(Dimensions r, Container c, Multiplicative a) => MultiplicativeModule (Array Nat c r) a

Methods

(.*) :: Array Nat c r a -> a -> Array Nat c r a

(*.) :: a -> Array Nat c r a -> Array Nat c r a

(Dimensions r, Container c, MultiplicativeGroup a) => MultiplicativeGroupModule (Array Nat c r) a

Methods

(./) :: Array Nat c r a -> a -> Array Nat c r a

(/.) :: a -> Array Nat c r a -> Array Nat c r a

(Foldable (Array Nat c r), CRing a, Semiring a, Dimensions r, Container c) => Hilbert (Array Nat c r) a

Methods

(<.>) :: Array Nat c r a -> Array Nat c r a -> a

(Dimensions r, Container c, Additive a) => AdditiveBasis (Array Nat c r) a

Methods

(.+.) :: Array Nat c r a -> Array Nat c r a -> Array Nat c r a

(Dimensions r, Container c, AdditiveGroup a) => AdditiveGroupBasis (Array Nat c r) a

Methods

(.-.) :: Array Nat c r a -> Array Nat c r a -> Array Nat c r a

(Dimensions r, Container c, Multiplicative a) => MultiplicativeBasis (Array Nat c r) a

Methods

(.*.) :: Array Nat c r a -> Array Nat c r a -> Array Nat c r a

(Dimensions r, Container c, MultiplicativeGroup a) => MultiplicativeGroupBasis (Array Nat c r) a

Methods

(./.) :: Array Nat c r a -> Array Nat c r a -> Array Nat c r a

((~) * (Item (Array Nat c r a)) (Item (c a)), Dimensions r, AdditiveUnital a, IsList (c a)) => IsList (Array Nat c r a)

from flat list

Associated Types

type Item (Array Nat c r a) :: *

Methods

fromList :: [Item (Array Nat c r a)] -> Array Nat c r a

fromListN :: Int -> [Item (Array Nat c r a)] -> Array Nat c r a

toList :: Array Nat c r a -> [Item (Array Nat c r a)]

(Eq (c t), Dimensions ds) => Eq (Array Nat c ds t)

Methods

(==) :: Array Nat c ds t -> Array Nat c ds t -> Bool

(/=) :: Array Nat c ds t -> Array Nat c ds t -> Bool

(Show a, Show (Item (c a)), IsList (c a), Container c, Dimensions ds) => Show (Array Nat c ds a)

Methods

showsPrec :: Int -> Array Nat c ds a -> ShowS

show :: Array Nat c ds a -> String

showList :: [Array Nat c ds a] -> ShowS

(IsList (c a), (~) * (Item (c a)) a, KnownNat n, AdditiveUnital (Vector Nat c n a), Arbitrary a, AdditiveUnital a, Num a) => Arbitrary (Vector Nat c n a)

Methods

arbitrary :: Gen (Vector Nat c n a)

shrink :: Vector Nat c n a -> [Vector Nat c n a]

(Foldable (Array Nat c r), Dimensions r, Container c, CRing a, Multiplicative a) => TensorProduct (Array Nat c r a)

Methods

(><) :: Array Nat c r a -> Array Nat c r a -> (* >< *) (Array Nat c r a) (Array Nat c r a)

outer :: Array Nat c r a -> Array Nat c r a -> (* >< *) (Array Nat c r a) (Array Nat c r a)

timesleft :: Array Nat c r a -> (* >< *) (Array Nat c r a) (Array Nat c r a) -> Array Nat c r a

timesright :: (* >< *) (Array Nat c r a) (Array Nat c r a) -> Array Nat c r a -> Array Nat c r a

(Dimensions r, Container c, Signed a) => Signed (Array Nat c r a)

Methods

sign :: Array Nat c r a -> Array Nat c r a

abs :: Array Nat c r a -> Array Nat c r a

(Foldable (Array Nat c r), Dimensions r, Container c, Epsilon a) => Epsilon (Array Nat c r a)

Methods

nearZero :: Array Nat c r a -> Bool

aboutEqual :: Array Nat c r a -> Array Nat c r a -> Bool

positive :: Array Nat c r a -> Bool

veryPositive :: Array Nat c r a -> Bool

veryNegative :: Array Nat c r a -> Bool

(Dimensions r, Container c, Field a) => Field (Array Nat c r a)

(Dimensions r, Container c, ExpField a) => ExpField (Array Nat c r a)

Methods

exp :: Array Nat c r a -> Array Nat c r a

log :: Array Nat c r a -> Array Nat c r a

logBase :: Array Nat c r a -> Array Nat c r a -> Array Nat c r a

(**) :: Array Nat c r a -> Array Nat c r a -> Array Nat c r a

sqrt :: Array Nat c r a -> Array Nat c r a

(Foldable (Array Nat c r), Dimensions r, Container c, BoundedField a) => BoundedField (Array Nat c r a)

Methods

maxBound :: Array Nat c r a

minBound :: Array Nat c r a

nan :: Array Nat c r a

isNaN :: Array Nat c r a -> Bool

(Dimensions r, Container c, Integral a) => Integral (Array Nat c r a)

Methods

div :: Array Nat c r a -> Array Nat c r a -> Array Nat c r a

mod :: Array Nat c r a -> Array Nat c r a -> Array Nat c r a

divMod :: Array Nat c r a -> Array Nat c r a -> (Array Nat c r a, Array Nat c r a)

(Dimensions r, Container c, Semiring a) => Semiring (Array Nat c r a)

(Dimensions r, Container c, Ring a) => Ring (Array Nat c r a)

(Dimensions r, Container c, CRing a) => CRing (Array Nat c r a)

(Dimensions r, Container c, MultiplicativeMagma a, Additive a) => Distribution (Array Nat c r a)

(Dimensions r, Container c, MultiplicativeMagma a) => MultiplicativeMagma (Array Nat c r a)

Methods

times :: Array Nat c r a -> Array Nat c r a -> Array Nat c r a

(Dimensions r, Container c, MultiplicativeUnital a) => MultiplicativeUnital (Array Nat c r a)

Methods

one :: Array Nat c r a

(Dimensions r, Container c, MultiplicativeAssociative a) => MultiplicativeAssociative (Array Nat c r a)

(Dimensions r, Container c, MultiplicativeCommutative a) => MultiplicativeCommutative (Array Nat c r a)

(Dimensions r, Container c, MultiplicativeInvertible a) => MultiplicativeInvertible (Array Nat c r a)

Methods

recip :: Array Nat c r a -> Array Nat c r a

(Dimensions r, Container c, Multiplicative a) => Multiplicative (Array Nat c r a)

Methods

(*) :: Array Nat c r a -> Array Nat c r a -> Array Nat c r a

(Dimensions r, Container c, MultiplicativeGroup a) => MultiplicativeGroup (Array Nat c r a)

Methods

(/) :: Array Nat c r a -> Array Nat c r a -> Array Nat c r a

(Dimensions r, Container c, AdditiveMagma a) => AdditiveMagma (Array Nat c r a)

Methods

plus :: Array Nat c r a -> Array Nat c r a -> Array Nat c r a

(Dimensions r, Container c, AdditiveUnital a) => AdditiveUnital (Array Nat c r a)

Methods

zero :: Array Nat c r a

(Dimensions r, Container c, AdditiveAssociative a) => AdditiveAssociative (Array Nat c r a)

(Dimensions r, Container c, AdditiveCommutative a) => AdditiveCommutative (Array Nat c r a)

(Dimensions r, Container c, AdditiveInvertible a) => AdditiveInvertible (Array Nat c r a)

Methods

negate :: Array Nat c r a -> Array Nat c r a

(Dimensions r, Container c, Additive a) => Additive (Array Nat c r a)

Methods

(+) :: Array Nat c r a -> Array Nat c r a -> Array Nat c r a

(Dimensions r, Container c, AdditiveGroup a) => AdditiveGroup (Array Nat c r a)

Methods

(-) :: Array Nat c r a -> Array Nat c r a -> Array Nat c r a

(Functor (Array k c r), Foldable (Array k c r), ExpField a) => Normed (Array k c r a) a

Methods

size :: Array k c r a -> a

(Foldable (Array Nat c r), Dimensions r, Container c, ExpField a) => Metric (Array Nat c r a) a

Methods

distance :: Array Nat c r a -> Array Nat c r a -> a

(IsList (c a), (~) * (Item (c a)) a, AdditiveUnital (Matrix Nat c m n a), KnownNat m, KnownNat n, Arbitrary a, AdditiveUnital a, Num a) => Arbitrary (Matrix Nat c m n a)

Methods

arbitrary :: Gen (Matrix Nat c m n a)

shrink :: Matrix Nat c m n a -> [Matrix Nat c m n a]

data Array Nat

instance where dimensions are known at compile time

data Array Nat = Array {

• _getContainer :: c t

}

data Array XNat

instance of array where some of the dimensions are known at compile time it wraps an Array with some weird magic

data Array XNat where

• SomeArray :: Array XNat c xds t

type Rep (Array Nat c r)

type Rep (Array Nat c r) = [Int]

type Shape (Array Nat c r)

type Shape (Array Nat c r) = [Int]

type Shape (Array XNat c xds)

type Shape (Array XNat c xds) = [Int]

type Item (Array Nat c r a)

type Item (Array Nat c r a) = a

newtype AnyArray c a

an array with dimensions represented at the value level

Constructors

AnyArray ([Int], c a)

Instances

(Show a, Show (Item (c a)), Container c, IsList (c a)) => Show (AnyArray * c a)

Methods

showsPrec :: Int -> AnyArray * c a -> ShowS

show :: AnyArray * c a -> String

showList :: [AnyArray * c a] -> ShowS

anyArray :: Dimensions ds => Array c ds a -> AnyArray c a

convert an array with type-level shape to value-level shape

class Functor f => Container f where

a sweet class of container with attributes necessary to supply the set of operations here

Minimal complete definition

generate, idx, cslice, zipWith, chunkItUp, cfoldl', cfoldr, cconcat

Methods

generate :: Int -> (Int -> a) -> f a

idx :: f a -> Int -> a

cslice :: Int -> Int -> f a -> f a

zipWith :: (a -> a -> a) -> f a -> f a -> f a

chunkItUp :: [f a] -> Int -> f a -> [f a]

cfoldl' :: (b -> a -> b) -> b -> f a -> b

cfoldr :: (a -> b -> b) -> b -> f a -> b

cconcat :: [f a] -> f a

Instances

Container []

Methods

generate :: Int -> (Int -> a) -> [a]

idx :: [a] -> Int -> a

cslice :: Int -> Int -> [a] -> [a]

zipWith :: (a -> a -> a) -> [a] -> [a] -> [a]

chunkItUp :: [[a]] -> Int -> [a] -> [[a]]

cfoldl' :: (b -> a -> b) -> b -> [a] -> b

cfoldr :: (a -> b -> b) -> b -> [a] -> b

cconcat :: [[a]] -> [a]

Container Vector

Methods

generate :: Int -> (Int -> a) -> Vector a

idx :: Vector a -> Int -> a

cslice :: Int -> Int -> Vector a -> Vector a

zipWith :: (a -> a -> a) -> Vector a -> Vector a -> Vector a

chunkItUp :: [Vector a] -> Int -> Vector a -> [Vector a]

cfoldl' :: (b -> a -> b) -> b -> Vector a -> b

cfoldr :: (a -> b -> b) -> b -> Vector a -> b

cconcat :: [Vector a] -> Vector a

xdimList :: XDim ds -> [Int]

dimList :: Dim ds -> [Int]

shape helpers where dimensions ~ [Int]

ind :: [Int] -> [Int] -> Int

convert from n-dim shape index to a flat index

>>> ind [2,3,4] [1,1,1]
17

unind :: [Int] -> Int -> [Int]

convert from a flat index to a shape index

>>> unind [2,3,4] 17
[1,1,1]

flatten1 :: Container c => AnyArray c a -> [AnyArray c a]

convert the top layer of a SomeArray to a [SomeArray]

type Vector c n = Array c '[n]

type Matrix c m n = Array c '[m, n]

Operations

(><) :: forall c (r :: [Nat]) (s :: [Nat]) a. (Container c, CRing a, Dimensions r, Dimensions s, Dimensions (r ++ s)) => Array c r a -> Array c s a -> Array c (r ++ s) a

outer product

todo: reconcile with numhask version

>>> v NumHask.Array.>< v
[[1, 2, 3],
 [2, 4, 6],
 [3, 6, 9]]

mmult :: forall c m n k a. (Hilbert (Vector c k) a, Dimensions '[m, k], Dimensions '[k, n], Dimensions '[m, n], Container c, Semiring a, Num a, CRing a, KnownNat m, KnownNat n, KnownNat k) => Matrix c m k a -> Matrix c k n a -> Matrix c m n a

matrix multiplication

>>> let a = [1, 2, 3, 4] :: Array [] '[2, 2] Int
>>> let b = [5, 6, 7, 8] :: Array [] '[2, 2] Int
>>> a
[[1, 2],
 [3, 4]]

>>> b
[[5, 6],
 [7, 8]]

>>> mmult a b
[[19, 22],
 [43, 50]]

row :: forall c i a m n. (Dimensions '[m, n], Container c, KnownNat m, KnownNat n, KnownNat i, (i :< m) ~ True) => Proxy i -> Matrix c m n a -> Vector c n a

extract the row of a matrix

unsafeRow :: forall c a m n. (Container c, KnownNat m, KnownNat n, Dimensions '[m, n]) => Int -> Matrix c m n a -> Vector c n a

col :: forall c j a m n. (Dimensions '[m, n], Container c, KnownNat m, KnownNat n, KnownNat j, (j :< n) ~ True) => Proxy j -> Matrix c m n a -> Vector c m a

extract the column of a matrix

unsafeCol :: forall c a m n. (Container c, KnownNat m, KnownNat n, Dimensions '[m, n]) => Int -> Matrix c m n a -> Vector c m a

unsafeIndex :: (Container c, Dimensions r) => Array c r a -> [Int] -> a

>>> unsafeIndex a [0,2,1]
10

unsafeSlice :: (Container c, IsList (c a), Item (c a) ~ a, Dimensions r, Dimensions r0) => [[Int]] -> Array c r a -> Array c r0 a

>>> unsafeSlice [[0,1],[2],[1,2]] a :: Array [] '[2,1,2] Int
[[[10, 11]],
 [[22, 23]]]

type family Slice (xss :: [[Nat]]) :: [Nat] where ...

Slice xs = Map Length xs

Equations

Slice xss = Map LengthSym0 xss

data AllLTSym0 (a :: TyFun [Nat] (TyFun Nat Bool -> Type))

AllLT xs n = All (n >) xs

Instances

type Apply [Nat] (TyFun Nat Bool -> Type) AllLTSym0 l

type Apply [Nat] (TyFun Nat Bool -> Type) AllLTSym0 l = AllLTSym1 l

data AllLTSym1 (l :: [Nat]) (a :: TyFun Nat Bool)

Instances

type Apply Nat Bool (AllLTSym1 l) n

type Apply Nat Bool (AllLTSym1 l) n = All Nat ((:>$$) Nat n) l

slice :: ((~#) * * (Item (c a1)) a1, SingI [[Nat]] a2, Dimensions r0, Dimensions r, IsList (c a1), Container c) => proxy a2 -> Array Nat c r a1 -> Array Nat c r0 a1

todo: an ambiguous type variable has snucjk in here somewhere

slice (Proxy :: Proxy '[ '[0,1],'[2],'[1,2]]) a

[[10, 11

],

[22, 23

]]

foldAlong :: forall c s vw uvw uw w a. (Container c, KnownNat s, Dimensions uvw, uw ~ Fold s uvw, w ~ Drop 1 vw, vw ~ TailModule s uvw) => Proxy s -> (Array c vw a -> Array c w a) -> Array c uvw a -> Array c uw a

>>> foldAlong (Proxy :: Proxy 1) (\_ -> ([0..3] :: Array [] '[4] Int)) a
[[0, 1, 2, 3],
 [0, 1, 2, 3]]

todo: resolution of a primitive and a scalar eg Expected type: Array '[10] Int -> Array '[] Int Actual type: Array '[10] (Array '[] Int) -> Array '[] Int

mapAlong :: forall c s uvw vw a. (Container c, KnownNat s, Dimensions uvw, vw ~ HeadModule s uvw) => Proxy s -> (Array c vw a -> Array c vw a) -> Array c uvw a -> Array c uvw a

todo: No instance for (Container (Array [] '[]) error

mapAlong (Proxy :: Proxy 0) (\x -> NumHask.Array.zipWith (*) x x) a

[[1, 4, 9, 16

,

25, 36, 49, 64

,

81, 100, 121, 144

],

[169, 196, 225, 256

,

289, 324, 361, 400

,

441, 484, 529, 576

]]

concatenate :: forall c s r t a. (Container c, SingI s, Dimensions r, Dimensions t, IsValidConcat s t r ~ True) => Proxy s -> Array c r a -> Array c t a -> Array c (Concatenate s t r) a

>>> concatenate (Proxy :: Proxy 2) a a
[[[1, 2, 3, 4, 1, 2, 3, 4],
  [5, 6, 7, 8, 5, 6, 7, 8],
  [9, 10, 11, 12, 9, 10, 11, 12]],
 [[13, 14, 15, 16, 13, 14, 15, 16],
  [17, 18, 19, 20, 17, 18, 19, 20],
  [21, 22, 23, 24, 21, 22, 23, 24]]]

transpose :: forall c s t a. (t ~ Transpose s, Container c, Dimensions s, Dimensions t) => Array c s a -> Array c t a

>>> NumHask.Array.transpose a
[[[1, 2],
  [3, 4],
  [5, 6]],
 [[7, 8],
  [9, 10],
  [11, 12]],
 [[13, 14],
  [15, 16],
  [17, 18]],
 [[19, 20],
  [21, 22],
  [23, 24]]]

squeeze :: forall c s t a. t ~ Squeeze s => Array c s a -> Array c t a

>>> let a = [1..24] :: Array [] '[2,1,3,4,1] Int
>>> a
[[[[[1],
    [2],
    [3],
    [4]],
   [[5],
    [6],
    [7],
    [8]],
   [[9],
    [10],
    [11],
    [12]]]],
 [[[[13],
    [14],
    [15],
    [16]],
   [[17],
    [18],
    [19],
    [20]],
   [[21],
    [22],
    [23],
    [24]]]]]
>>> squeeze a
[[[1, 2, 3, 4],
  [5, 6, 7, 8],
  [9, 10, 11, 12]],
 [[13, 14, 15, 16],
  [17, 18, 19, 20],
  [21, 22, 23, 24]]]