Data.Tensor

Tensor In Haskell

In ghci

λ> :set -XDataKinds
λ> :set -XOverloadedLists
λ> import Data.Tensor
λ> a = identity :: Tensor '[3,3] Int
λ> a
[[1,0,0],
[0,1,0],
[0,0,1]]
λ> b = [1..9] :: Tensor '[3,3] Int
λ> b
[[1,2,3],
[4,5,6],
[7,8,9]]
λ> a + b
[[2,2,3],
[4,6,6],
[7,8,10]]
λ> a - b
[[0,-2,-3],
[-4,-4,-6],
[-7,-8,-8]]
λ> a * b
[[1,0,0],
[0,5,0],
[0,0,9]]
λ> a `dot` b
[[1,2,3],
[4,5,6],
[7,8,9]]
λ> :t a `dyad` b
a `dyad` b :: Tensor '[3, 3, 3, 3] Int
λ> contraction a (i0,i1)
3
λ> :t contraction a (i0,i1)
contraction a (i0,i1) :: Tensor '[] Int
λ> select a (i0,i0)
[1,0,0]
λ> select a (i0,i1)
[0,1,0]
λ> select a (i0,i2)
[0,0,1]
λ> c = 1 :: Tensor '[3,3] Int
λ> c
[[1,1,1],
[1,1,1],
[1,1,1]]
λ> d = [1..4] :: Tensor '[2,2] Int
λ> d
[[1,2],
[3,4]]
λ> transpose d
[[1,3],
[2,4]]

Tensor Definition

data Tensor (s :: [Nat]) n

Definition of Tensor. s means shape of tensor.

identity :: Tensor '[3,3] Int

Instances

SingI s => Functor (Tensor s)

Defined in Data.Tensor.Tensor

Methods

fmap :: (a -> b) -> Tensor s a -> Tensor s b

(<$) :: a -> Tensor s b -> Tensor s a

SingI s => Applicative (Tensor s)

Defined in Data.Tensor.Tensor

Methods

pure :: a -> Tensor s a

(<*>) :: Tensor s (a -> b) -> Tensor s a -> Tensor s b

liftA2 :: (a -> b -> c) -> Tensor s a -> Tensor s b -> Tensor s c

(*>) :: Tensor s a -> Tensor s b -> Tensor s b

(<*) :: Tensor s a -> Tensor s b -> Tensor s a

SingI s => Foldable (Tensor s)

Defined in Data.Tensor.Tensor

Methods

fold :: Monoid m => Tensor s m -> m

foldMap :: Monoid m => (a -> m) -> Tensor s a -> m

foldr :: (a -> b -> b) -> b -> Tensor s a -> b

foldr' :: (a -> b -> b) -> b -> Tensor s a -> b

foldl :: (b -> a -> b) -> b -> Tensor s a -> b

foldl' :: (b -> a -> b) -> b -> Tensor s a -> b

foldr1 :: (a -> a -> a) -> Tensor s a -> a

foldl1 :: (a -> a -> a) -> Tensor s a -> a

toList :: Tensor s a -> [a]

null :: Tensor s a -> Bool

length :: Tensor s a -> Int

elem :: Eq a => a -> Tensor s a -> Bool

maximum :: Ord a => Tensor s a -> a

minimum :: Ord a => Tensor s a -> a

sum :: Num a => Tensor s a -> a

product :: Num a => Tensor s a -> a

SingI s => IsList (Tensor s n)

Defined in Data.Tensor.Tensor

Associated Types

type Item (Tensor s n) :: Type

Methods

fromList :: [Item (Tensor s n)] -> Tensor s n

fromListN :: Int -> [Item (Tensor s n)] -> Tensor s n

toList :: Tensor s n -> [Item (Tensor s n)]

(SingI s, Eq n) => Eq (Tensor s n)

Defined in Data.Tensor.Tensor

Methods

(==) :: Tensor s n -> Tensor s n -> Bool

(/=) :: Tensor s n -> Tensor s n -> Bool

(SingI s, Floating n) => Floating (Tensor s n)

Defined in Data.Tensor.Tensor

Methods

pi :: Tensor s n

exp :: Tensor s n -> Tensor s n

log :: Tensor s n -> Tensor s n

sqrt :: Tensor s n -> Tensor s n

(**) :: Tensor s n -> Tensor s n -> Tensor s n

logBase :: Tensor s n -> Tensor s n -> Tensor s n

sin :: Tensor s n -> Tensor s n

cos :: Tensor s n -> Tensor s n

tan :: Tensor s n -> Tensor s n

asin :: Tensor s n -> Tensor s n

acos :: Tensor s n -> Tensor s n

atan :: Tensor s n -> Tensor s n

sinh :: Tensor s n -> Tensor s n

cosh :: Tensor s n -> Tensor s n

tanh :: Tensor s n -> Tensor s n

asinh :: Tensor s n -> Tensor s n

acosh :: Tensor s n -> Tensor s n

atanh :: Tensor s n -> Tensor s n

log1p :: Tensor s n -> Tensor s n

expm1 :: Tensor s n -> Tensor s n

log1pexp :: Tensor s n -> Tensor s n

log1mexp :: Tensor s n -> Tensor s n

(SingI s, Fractional n) => Fractional (Tensor s n)

Defined in Data.Tensor.Tensor

Methods

(/) :: Tensor s n -> Tensor s n -> Tensor s n

recip :: Tensor s n -> Tensor s n

fromRational :: Rational -> Tensor s n

(SingI s, Num n) => Num (Tensor s n)

Defined in Data.Tensor.Tensor

Methods

(+) :: Tensor s n -> Tensor s n -> Tensor s n

(-) :: Tensor s n -> Tensor s n -> Tensor s n

(*) :: Tensor s n -> Tensor s n -> Tensor s n

negate :: Tensor s n -> Tensor s n

abs :: Tensor s n -> Tensor s n

signum :: Tensor s n -> Tensor s n

fromInteger :: Integer -> Tensor s n

(SingI s, Show n) => Show (Tensor s n)

Defined in Data.Tensor.Tensor

Methods

showsPrec :: Int -> Tensor s n -> ShowS

show :: Tensor s n -> String

showList :: [Tensor s n] -> ShowS

type Item (Tensor s n)

Defined in Data.Tensor.Tensor

type Item (Tensor s n) = n

identity :: forall s n. (SingI s, Num n) => Tensor s n

Unit tensor of shape s, if all the indices are equal then return 1, otherwise return 0.

type Scalar n = Tensor '[] n

Scalar is rank 0 of tensor

type Vector s n = Tensor '[s] n

Vector is rank 1 of tensor

type Matrix a b n = Tensor '[a, b] n

Matrix is rank 2 of tensor

type SimpleTensor (r :: Nat) (dim :: Nat) n = If ((==) dim 0) (Scalar n) (Tensor (Replicate r dim) n)

Simple Tensor is rank r tensor, has `n^r` dimension in total.

SimpleTensor 2 3 Int == Matrix 3 3 Int == Tensor '[3,3] Int
SimpleTensor r 0 Int == Scalar Int

Tensor Index

data TensorIndex (shape :: [Nat])

Tensor Index, used to locate each point of tensor

Instances

SingI s => IsList (TensorIndex s)

Defined in Data.Tensor.Index

Associated Types

type Item (TensorIndex s) :: Type

Methods

fromList :: [Item (TensorIndex s)] -> TensorIndex s

fromListN :: Int -> [Item (TensorIndex s)] -> TensorIndex s

toList :: TensorIndex s -> [Item (TensorIndex s)]

SingI s => Bounded (TensorIndex s)

Defined in Data.Tensor.Index

Methods

minBound :: TensorIndex s

maxBound :: TensorIndex s

SingI s => Enum (TensorIndex s)

Defined in Data.Tensor.Index

Methods

succ :: TensorIndex s -> TensorIndex s

pred :: TensorIndex s -> TensorIndex s

toEnum :: Int -> TensorIndex s

fromEnum :: TensorIndex s -> Int

enumFrom :: TensorIndex s -> [TensorIndex s]

enumFromThen :: TensorIndex s -> TensorIndex s -> [TensorIndex s]

enumFromTo :: TensorIndex s -> TensorIndex s -> [TensorIndex s]

enumFromThenTo :: TensorIndex s -> TensorIndex s -> TensorIndex s -> [TensorIndex s]

Eq (TensorIndex shape)

Defined in Data.Tensor.Index

Methods

(==) :: TensorIndex shape -> TensorIndex shape -> Bool

(/=) :: TensorIndex shape -> TensorIndex shape -> Bool

Ord (TensorIndex shape)

Defined in Data.Tensor.Index

Methods

compare :: TensorIndex shape -> TensorIndex shape -> Ordering

(<) :: TensorIndex shape -> TensorIndex shape -> Bool

(<=) :: TensorIndex shape -> TensorIndex shape -> Bool

(>) :: TensorIndex shape -> TensorIndex shape -> Bool

(>=) :: TensorIndex shape -> TensorIndex shape -> Bool

max :: TensorIndex shape -> TensorIndex shape -> TensorIndex shape

min :: TensorIndex shape -> TensorIndex shape -> TensorIndex shape

Show (TensorIndex shape)

Defined in Data.Tensor.Index

Methods

showsPrec :: Int -> TensorIndex shape -> ShowS

show :: TensorIndex shape -> String

showList :: [TensorIndex shape] -> ShowS

type Item (TensorIndex s)

Defined in Data.Tensor.Index

type Item (TensorIndex s) = Int

type Index = [Int]

Tensor Dimension

type TensorRank (s :: [Nat]) = Length s

Tensor rank.

type Shape = [Int]

shape :: forall s n. SingI s => Tensor s n -> [Int]

Shape of Tensor, is a list of integers, uniquely determine the shape of tensor.

rank :: SingI s => Tensor s n -> Int

Rank of Tensor

Tensor Operation

Reshape Tensor

reshape :: (Product s ~ Product s', SingI s) => Tensor s n -> Tensor s' n

Reshape a tensor to another tensor, with total dimensions are equal.

Clone Tensor

clone :: SingI s => Tensor s n -> Tensor s n

Clone tensor to a new Vector based tensor

Transpose Tensor

type Transpose (a :: [Nat]) = Reverse a

transpose :: SingI a => Tensor a n -> Tensor (Transpose a) n

Transpose tensor completely

λ> a = [1..9] :: Tensor '[3,3] Int
λ> a
[[1,2,3],
[4,5,6],
[7,8,9]]
λ> transpose a
[[1,4,7],
[2,5,8],
[3,6,9]]

type Swapaxes i j s = Concat '[Take i s, '[(!!) s j], Tail (Drop i (Take j s)), '[(!!) s i], Tail (Drop j s)]

type CheckSwapaxes i j s = And '[(>=) i 0, (<) i j, (<) j (Length s)]

swapaxes :: (Swapaxes i j s ~ s', CheckSwapaxes i j s ~ True, SingI s, KnownNat i, KnownNat j) => Proxy i -> Proxy j -> Tensor s n -> Tensor s' n

Swapaxes any rank

λ> a = [1..24] :: Tensor '[2,3,4] 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]]]
λ> swapaxes i0 i1 a
[[[1,2,3,4],
[13,14,15,16]],
[[5,6,7,8],
[17,18,19,20]],
[[9,10,11,12],
[21,22,23,24]]]
λ> :t swapaxes i0 i1 a
swapaxes i0 i1 a :: Tensor '[3, 2, 4] Int
λ> :t swapaxes i1 i2 a
swapaxes i1 i2 a :: Tensor '[2, 4, 3] Int

In rank 2 tensor, swapaxes is just transpose

transpose == swapaxes i0 i1

Dyadic Tensor

dyad' :: (r ~ (++) s t, SingI s, SingI t, SingI r) => (n -> m -> o) -> Tensor s n -> Tensor t m -> Tensor r o

dyad :: (r ~ (++) s t, SingI s, SingI t, SingI r, Num n, Eq n) => Tensor s n -> Tensor t n -> Tensor r n

Dyadic Tensor

λ> a = [1..4] :: Tensor '[2,2] Int
λ> a
[[1,2],
[3,4]]
λ> :t a `dyad` a
a `dyad` a :: Tensor '[2, 2, 2, 2] Int
λ> a `dyad` a
[[[[1,2],
[3,4]],
[[2,4],
[6,8]]],
[[[3,6],
[9,12]],
[[4,8],
[12,16]]]]

Tensor Product

type DotTensor s1 s2 = (++) (Init s1) (Tail s2)

dot :: (Last s ~ Head s', SingI (DotTensor s s'), SingI s, SingI s', Num n, Eq n) => Tensor s n -> Tensor s' n -> Tensor (DotTensor s s') n

Tensor Product

λ> a = [1..4] :: Tensor '[2,2] Int
λ> a
[[1,2],
[3,4]]
λ> a `dot` a
[[7,10],
[15,22]]

dot a b == contraction (dyad a b) (rank a - 1, rank a)

For rank 2 tensor, it is just matrix product.

Contraction Tensor

type CheckContraction s x y = And '[(<) x y, (>=) x 0, (<) y (TensorRank s)]

type Contraction s x y = DropIndex (DropIndex s y) x

type TensorDim s i = (!!) s i

type DropIndex (s :: [Nat]) (i :: Nat) = (++) (Fst (SplitAt i s)) (Tail (Snd (SplitAt i s)))

contraction :: forall x y s s' n. (CheckContraction s x y ~ True, s' ~ Contraction s x y, TensorDim s x ~ TensorDim s y, KnownNat x, KnownNat y, SingI s, SingI s', KnownNat (TensorDim s x), Num n) => (Proxy x, Proxy y) -> Tensor s n -> Tensor s' n

Contraction Tensor

λ> a = [1..16] :: Tensor '[4,4] Int
λ> a
[[1,2,3,4],
[5,6,7,8],
[9,10,11,12],
[13,14,15,16]]
λ> contraction (i0,i1) a
34

In rank 2 tensor, contraction of tensor is just the trace.

Tensor Selection

(!) :: SingI s => Tensor s n -> TensorIndex s -> n

Get value from tensor by index

type CheckDim dim s = And '[(>=) dim 0, (<) dim (Length s)]

type CheckSelect dim i s = And '[CheckDim dim s, (>=) i 0, (<) i ((!!) s dim)]

type Select i s = (++) (Take i s) (Tail (Drop i s))

select :: (CheckSelect dim i s ~ True, s' ~ Select dim s, SingI s, KnownNat dim, KnownNat i) => (Proxy dim, Proxy i) -> Tensor s n -> Tensor s' n

Select i indexing of tensor

λ> a = identity :: Tensor '[4,4] Int
λ> select (i0,i0) a
[1,0,0,0]
λ> select (i0,i1) a
[0,1,0,0]

type CheckSlice dim from to s = And '[CheckDim dim s, CheckSelect dim from s, (<) from to, (<=) to ((!!) s dim)]

type Slice dim from to s = Concat '[Take dim s, '[to - from], Tail (Drop dim s)]

slice :: (CheckSlice dim from to s ~ True, s' ~ Slice dim from to s, KnownNat dim, KnownNat from, KnownNat (to - from), SingI s) => (Proxy dim, (Proxy from, Proxy to)) -> Tensor s n -> Tensor s' n

Slice tensor

λ> a = identity :: Tensor '[4,4] Int
λ> a
[[1,0,0,0],
[0,1,0,0],
[0,0,1,0],
[0,0,0,1]]
λ> slice (i0,(i1,i3)) a
[[0,1,0,0],
[0,0,1,0]]
λ> slice (i1,(i1,i3)) a
[[0,0],
[1,0],
[0,1],
[0,0]]

Tensor Manipulation

expand :: (TensorRank s ~ TensorRank s', SingI s) => Tensor s n -> Tensor s' n

Expand tensor

λ> a = identity :: Tensor '[2,2] Int
λ> a
[[1,0],
[0,1]]
λ> expand a :: Tensor '[4,4] Int
[[1,0,1,0],
[0,1,0,1],
[1,0,1,0],
[0,1,0,1]]

type CheckConcatenate i a b = And '[(==) (Length a) (Length b), (>=) i 0, (<) i (Length a), (==) (Select i a) (Select i b)]

type Concatenate i a b = Concat '[Take i a, '[(+) (TensorDim a i) (TensorDim b i)], Tail (Drop i a)]

concatenate :: (CheckConcatenate i a b ~ True, Concatenate i a b ~ c, SingI a, SingI b, KnownNat i) => Proxy i -> Tensor a n -> Tensor b n -> Tensor c n

Join a sequence of arrays along an existing axis.

λ> a = [1..4] :: Tensor '[2,2] Int
λ> a
[[1,2],
[3,4]]
λ> b = [1,1,1,1] :: Tensor '[2,2] Int
λ> b
[[1,1],
[1,1]]
λ> concentrate i0 a b
[[1,2],
[3,4],
[1,1],
[1,1]]
λ> concentrate i1 a b
[[1,2,1,1],
[3,4,1,1]]

type CheckInsert dim i a b = And '[CheckDim dim b, (==) a (Select dim b), (>=) i 0, (<=) i (TensorDim b dim)]

type Insert dim a b = Concat '[Take dim b, '[TensorDim b dim + 1], Tail (Drop dim b)]

insert :: (CheckInsert dim i a b ~ True, KnownNat i, KnownNat dim, SingI a, SingI b) => Proxy dim -> Proxy i -> Tensor a n -> Tensor b n -> Tensor (Insert dim a b) n

Insert tensor to higher level tensor

λ> a = [1,2] :: Vector 2 Float
λ> b = a `dyad` a
λ> b
[[1.0,2.0],
[2.0,4.0]]
λ> :t b
b :: Tensor '[2, 2] Float
λ> c = [1..4] :: Tensor '[1,2,2] Float
λ> c
[[[1.0,2.0],
[3.0,4.0]]]
λ> d = insert i0 i0 b c
λ> :t d
d :: Tensor '[2, 2, 2] Float
λ> d
[[[1.0,2.0],
[2.0,4.0]],
[[1.0,2.0],
[3.0,4.0]]]
λ> insert i0 i1 b c
[[[1.0,2.0],
[3.0,4.0]],
[[1.0,2.0],
[2.0,4.0]]]

append :: forall dim a b n. (CheckInsert dim (TensorDim b dim) a b ~ True, KnownNat (TensorDim b dim), KnownNat dim, SingI a, SingI b) => Proxy dim -> Tensor a n -> Tensor b n -> Tensor (Insert dim a b) n

Append tensor to the end of some dimension of other tensor

λ> a = [1,2] :: Vector 2 Float
λ> a
[1.0,2.0]
λ> b = 3 :: Tensor '[] Float
λ> b
3.0
λ> append i0 b a
[1.0,2.0,3.0]

Tensor Space

linspace :: forall s n. (KnownNat s, Fractional n) => n -> n -> Vector s n

Return evenly spaced numbers over a specified interval.

λ> linspace 1 10 :: Tensor '[10] Float
[1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,..,10.0]

geospace :: forall s n. (KnownNat s, Floating n, Eq n) => n -> n -> Vector s n

Return numbers spaced evenly on a log scale (a geometric progression).

λ> geospace 1 10 :: Vector 10 Float
[1.0,1.2915497,1.6681006,2.1544347,2.7825596,3.593814,4.641589,5.994843,..,10.000001]

logspace :: forall s n. (KnownNat s, Floating n, Eq n) => n -> n -> n -> Vector s n

Return numbers spaced evenly on a log scale.

In linear space, the sequence starts at base ** start (base to the power of start) and ends with base ** stop

λ> logspace 10 2 3 :: Vector 4 Float
[100.0,215.44347,464.15887,1000.0]

type CheckGrid i a s = And '[(>=) i 0, (<) i (Length s)]

grid :: (CheckDim i s ~ True, KnownNat i, KnownNat (TensorDim s i)) => Proxy i -> Vector (TensorDim s i) n -> Tensor s n

Grid

λ> a = [1..2] :: Vector 2 Int
λ> a
[1,2]
λ> grid i0 a :: Tensor '[2,2,2] Int
[[[1,1],
[1,1]],
[[2,2],
[2,2]]]
λ> grid i1 a :: Tensor '[2,2,2] Int
[[[1,1],
[2,2]],
[[1,1],
[2,2]]]
λ> grid i2 a :: Tensor '[2,2,2] Int
[[[1,2],
[1,2]],
[[1,2],
[1,2]]]

meshgrid2 :: (s ~ '[a, b], KnownNat a, KnownNat b) => Vector a n -> Vector b n -> [Tensor s n]

Generate 2 dimension grid coordinates by two vectors.

meshgrid3 :: (s ~ '[a, b, c], KnownNat a, KnownNat b, KnownNat c) => Vector a n -> Vector b n -> Vector c n -> [Tensor s n]

Generate 3 dimension grid coordinates by three vectors.

meshgrid4 :: (s ~ '[a, b, c, d], KnownNat a, KnownNat b, KnownNat c, KnownNat d) => Vector a n -> Vector b n -> Vector c n -> Vector d n -> [Tensor s n]

Generate 4 dimension grid coordinates by four vectors.

meshgrid5 :: (s ~ '[a, b, c, d, e], KnownNat a, KnownNat b, KnownNat c, KnownNat d, KnownNat e) => Vector a n -> Vector b n -> Vector c n -> Vector d n -> Vector e n -> [Tensor s n]

Generate 5 dimension grid coordinates by five vectors.

meshgrid6 :: (s ~ '[a, b, c, d, e, f], KnownNat a, KnownNat b, KnownNat c, KnownNat d, KnownNat e, KnownNat f) => Vector a n -> Vector b n -> Vector c n -> Vector d n -> Vector e n -> Vector f n -> [Tensor s n]

Generate 6 dimension grid coordinates by six vectors.

meshgrid7 :: (s ~ '[a, b, c, d, e, f, g], KnownNat a, KnownNat b, KnownNat c, KnownNat d, KnownNat e, KnownNat f, KnownNat g) => Vector a n -> Vector b n -> Vector c n -> Vector d n -> Vector e n -> Vector f n -> Vector g n -> [Tensor s n]

Generate 7 dimension grid coordinates by seven vectors.

meshgrid8 :: (s ~ '[a, b, c, d, e, f, g, h], KnownNat a, KnownNat b, KnownNat c, KnownNat d, KnownNat e, KnownNat f, KnownNat g, KnownNat h) => Vector a n -> Vector b n -> Vector c n -> Vector d n -> Vector e n -> Vector f n -> Vector g n -> Vector h n -> [Tensor s n]

Generate 8 dimension grid coordinates by eight vectors.

meshgrid9 :: (s ~ '[a, b, c, d, e, f, g, h, i], KnownNat a, KnownNat b, KnownNat c, KnownNat d, KnownNat e, KnownNat f, KnownNat g, KnownNat h, KnownNat i) => Vector a n -> Vector b n -> Vector c n -> Vector d n -> Vector e n -> Vector f n -> Vector g n -> Vector h n -> Vector i n -> [Tensor s n]

Generate 9 dimension grid coordinates by nine vectors.

Matrix Operation

type SimpleMatrix a n = Matrix a a n

det :: forall a n. (KnownNat a, Num n, Eq n) => SimpleMatrix a n -> n

Determinant of n x n matrix

λ> a = [2,0,1,3,0,0,2,2,1,2,1,34,3,2,34,4] :: Tensor '[4,4] Int
λ> a
[[2,0,1,3],
[0,0,2,2],
[1,2,1,34],
[3,2,34,4]]
λ> det a
520

This implementation is not so fast, it can calculate 8 x 8 in 1 second with all the num none zero on my computer. It should be faster if more zero in the matrix.

lu :: forall a n. (KnownNat a, Integral n) => SimpleMatrix a n -> (SimpleMatrix a (Ratio n), SimpleMatrix a (Ratio n), SimpleMatrix a n)

LU decomposition of n x n matrix

λ> a = [1,2,3,2,5,7,3,5,3]:: Tensor '[3,3] Int
λ> (l,u,p) = lu a
λ> l
[[1 % 1,0 % 1,0 % 1],
[2 % 1,1 % 1,0 % 1],
[3 % 1,(-1) % 1,1 % 1]]
λ> u
[[1 % 1,2 % 1,3 % 1],
[0 % 1,1 % 1,1 % 1],
[0 % 1,0 % 1,(-5) % 1]]
λ> p
[[1,0,0],
[0,1,0],
[0,0,1]]

det' :: forall a n. (KnownNat a, Integral n) => SimpleMatrix a n -> n

determiant using lu decomposition

dotM :: (KnownNat a, Num n, Eq n) => SimpleMatrix a n -> SimpleMatrix a n -> SimpleMatrix a n

Matrix multiplication

trace :: (KnownNat a, Num n) => SimpleMatrix a n -> n

Matrix trace

diag :: SimpleMatrix a n -> Vector a n

Statistical Functions

average :: forall s n. (SingI s, Fractional n) => Tensor s n -> n

Average of tensor

λ> average (identity :: Tensor '[3,3] Float)
0.33333334

var :: forall s n. (SingI s, Fractional n) => Tensor s n -> n

Variance of tensor

λ> var ([1,2,3,4] :: Vector 4 Double )
1.25

std :: forall s n. (SingI s, Floating n) => Tensor s n -> n

Standard Deviation of tensor

λ> std ([1,2,3,4] :: Vector 4 Double )
1.118033988749895

Helper

runTensor :: SingI s => Tensor s n -> Index -> n

Convert tensor to untyped function, for internal usage.

i0 :: Proxy 0

i1 :: Proxy 1

i2 :: Proxy 2

i3 :: Proxy 3

i4 :: Proxy 4

i5 :: Proxy 5

i6 :: Proxy 6

i7 :: Proxy 7

i8 :: Proxy 8

i9 :: Proxy 9