NumHask.Array

safe-typed n-dimensional arrays

Documentation

newtype Array r a

an n-dimensional array where shape is specified at the type level The main purpose of this, beyond safe typing, is to supply the Representable instance with an initial object.

>>> 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]]]

Constructors

Array (Vector a)

Instances

Functor (Array r)

Methods

fmap :: (a -> b) -> Array r a -> Array r b

(<$) :: a -> Array r b -> Array r a

Foldable (Array r)

Methods

fold :: Monoid m => Array r m -> m

foldMap :: Monoid m => (a -> m) -> Array r a -> m

foldr :: (a -> b -> b) -> b -> Array r a -> b

foldr' :: (a -> b -> b) -> b -> Array r a -> b

foldl :: (b -> a -> b) -> b -> Array r a -> b

foldl' :: (b -> a -> b) -> b -> Array r a -> b

foldr1 :: (a -> a -> a) -> Array r a -> a

foldl1 :: (a -> a -> a) -> Array r a -> a

toList :: Array r a -> [a]

null :: Array r a -> Bool

length :: Array r a -> Int

elem :: Eq a => a -> Array r a -> Bool

maximum :: Ord a => Array r a -> a

minimum :: Ord a => Array r a -> a

sum :: Num a => Array r a -> a

product :: Num a => Array r a -> a

Generic1 (Array r)

Associated Types

type Rep1 (Array r :: * -> *) :: * -> *

Methods

from1 :: Array r a -> Rep1 (Array r) a

to1 :: Rep1 (Array r) a -> Array r a

SingI [Nat] r => Distributive (Array r)

Methods

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

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

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

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

SingI [Nat] r => Representable (Array r)

Associated Types

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

Methods

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

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

SingI [Nat] r => HasShape (Array r)

Associated Types

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

Methods

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

(CRing a, Num a, Semiring a, SingI [Nat] r) => Hilbert (Array r) a

Methods

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

(SingI [Nat] r, Num a) => IsList (Array r a)

from flat list

Associated Types

type Item (Array r a) :: *

Methods

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

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

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

Eq a => Eq (Array r a)

Methods

(==) :: Array r a -> Array r a -> Bool

(/=) :: Array r a -> Array r a -> Bool

(Show a, SingI [Nat] r) => Show (Array r a)

Methods

showsPrec :: Int -> Array r a -> ShowS

show :: Array r a -> String

showList :: [Array r a] -> ShowS

Generic (Array r a)

Associated Types

type Rep (Array r a) :: * -> *

Methods

from :: Array r a -> Rep (Array r a) x

to :: Rep (Array r a) x -> Array r a

NFData a => NFData (Array r a)

Methods

rnf :: Array r a -> ()

(SingI [Nat] r, Integral a) => Integral (Array r a)

Methods

div :: Array r a -> Array r a -> Array r a

mod :: Array r a -> Array r a -> Array r a

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

(SingI [Nat] r, Signed a) => Signed (Array r a)

Methods

sign :: Array r a -> Array r a

abs :: Array r a -> Array r a

(SingI [Nat] r, Epsilon a) => Epsilon (Array r a)

Methods

nearZero :: Array r a -> Bool

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

positive :: Array r a -> Bool

veryPositive :: Array r a -> Bool

veryNegative :: Array r a -> Bool

(SingI [Nat] r, Field a) => Field (Array r a)

(SingI [Nat] r, ExpField a) => ExpField (Array r a)

Methods

exp :: Array r a -> Array r a

log :: Array r a -> Array r a

logBase :: Array r a -> Array r a -> Array r a

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

sqrt :: Array r a -> Array r a

(SingI [Nat] r, BoundedField a) => BoundedField (Array r a)

Methods

maxBound :: Array r a

minBound :: Array r a

nan :: Array r a

isNaN :: Array r a -> Bool

(SingI [Nat] r, Semiring a) => Semiring (Array r a)

(SingI [Nat] r, Ring a) => Ring (Array r a)

(SingI [Nat] r, CRing a) => CRing (Array r a)

(SingI [Nat] r, MultiplicativeMagma a, Additive a) => Distribution (Array r a)

(SingI [Nat] r, MultiplicativeMagma a) => MultiplicativeMagma (Array r a)

Methods

times :: Array r a -> Array r a -> Array r a

(SingI [Nat] r, MultiplicativeUnital a) => MultiplicativeUnital (Array r a)

Methods

one :: Array r a

(SingI [Nat] r, MultiplicativeAssociative a) => MultiplicativeAssociative (Array r a)

(SingI [Nat] r, MultiplicativeCommutative a) => MultiplicativeCommutative (Array r a)

(SingI [Nat] r, MultiplicativeInvertible a) => MultiplicativeInvertible (Array r a)

Methods

recip :: Array r a -> Array r a

(SingI [Nat] r, Multiplicative a) => Multiplicative (Array r a)

Methods

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

(SingI [Nat] r, MultiplicativeGroup a) => MultiplicativeGroup (Array r a)

Methods

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

(SingI [Nat] r, AdditiveMagma a) => AdditiveMagma (Array r a)

Methods

plus :: Array r a -> Array r a -> Array r a

(SingI [Nat] r, AdditiveUnital a) => AdditiveUnital (Array r a)

Methods

zero :: Array r a

(SingI [Nat] r, AdditiveAssociative a) => AdditiveAssociative (Array r a)

(SingI [Nat] r, AdditiveCommutative a) => AdditiveCommutative (Array r a)

(SingI [Nat] r, AdditiveInvertible a) => AdditiveInvertible (Array r a)

Methods

negate :: Array r a -> Array r a

(SingI [Nat] r, Additive a) => Additive (Array r a)

Methods

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

(SingI [Nat] r, AdditiveGroup a) => AdditiveGroup (Array r a)

Methods

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

ExpField a => Normed (Array r a) a

Methods

size :: Array r a -> a

(SingI [Nat] r, ExpField a) => Metric (Array r a) a

Methods

distance :: Array r a -> Array r a -> a

type Rep1 (Array r)

type Rep1 (Array r) = D1 (MetaData "Array" "NumHask.Array" "numhask-array-0.0.2-2lUyhulk8QKGaYUY0rlcHX" True) (C1 (MetaCons "Array" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 Vector)))

type Rep (Array r)

type Rep (Array r) = [Int]

type Shape (Array r)

type Shape (Array r) = [Int]

type Rep (Array r a)

type Rep (Array r a) = D1 (MetaData "Array" "NumHask.Array" "numhask-array-0.0.2-2lUyhulk8QKGaYUY0rlcHX" True) (C1 (MetaCons "Array" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Vector a))))

type Item (Array r a)

type Item (Array r a) = a

data SomeArray a

an n-dimensional array where shape is specified at the value level

Constructors

SomeArray [Int] (Vector a)

Instances

Functor SomeArray

Methods

fmap :: (a -> b) -> SomeArray a -> SomeArray b

(<$) :: a -> SomeArray b -> SomeArray a

Foldable SomeArray

Methods

fold :: Monoid m => SomeArray m -> m

foldMap :: Monoid m => (a -> m) -> SomeArray a -> m

foldr :: (a -> b -> b) -> b -> SomeArray a -> b

foldr' :: (a -> b -> b) -> b -> SomeArray a -> b

foldl :: (b -> a -> b) -> b -> SomeArray a -> b

foldl' :: (b -> a -> b) -> b -> SomeArray a -> b

foldr1 :: (a -> a -> a) -> SomeArray a -> a

foldl1 :: (a -> a -> a) -> SomeArray a -> a

toList :: SomeArray a -> [a]

null :: SomeArray a -> Bool

length :: SomeArray a -> Int

elem :: Eq a => a -> SomeArray a -> Bool

maximum :: Ord a => SomeArray a -> a

minimum :: Ord a => SomeArray a -> a

sum :: Num a => SomeArray a -> a

product :: Num a => SomeArray a -> a

Eq a => Eq (SomeArray a)

Methods

(==) :: SomeArray a -> SomeArray a -> Bool

(/=) :: SomeArray a -> SomeArray a -> Bool

Show a => Show (SomeArray a)

Methods

showsPrec :: Int -> SomeArray a -> ShowS

show :: SomeArray a -> String

showList :: [SomeArray a] -> ShowS

row :: forall i a m n. (KnownNat m, KnownNat n, KnownNat i, (i :< m) ~ True) => Proxy i -> Array '[m, n] a -> Array '[n] a

extract the row of a matrix

col :: forall j a m n. (KnownNat m, KnownNat n, KnownNat j, (j :< n) ~ True) => Proxy j -> Array '[m, n] a -> Array '[m] a

extract the column of a matrix

unsafeRow :: forall a m n. (KnownNat m, KnownNat n) => Int -> Array '[m, n] a -> Array '[n] a

unsafeCol :: forall a m n. (KnownNat m, KnownNat n) => Int -> Array '[m, n] a -> Array '[m] a

slice :: forall s r a. (SingI s, SingI r, And (ZipWith AllLTSym0 s r) ~ True) => Proxy s -> Array r a -> Array (Slice s) a

>>> slice (Proxy :: Proxy '[ '[0,1],'[2],'[1,2]]) a
[[[10, 11]],
 [[22, 23]]]

unsafeSlice :: SingI r => [[Int]] -> Array r a -> Array r0 a

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

index :: Representable f => forall a. f a -> Rep f -> a

unsafeIndex :: SingI r => Array r a -> [Int] -> a

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

foldAlong :: forall s vw uvw uw w a. (SingI s, SingI uvw, uw ~ Fold s uvw, w ~ Drop 1 vw, vw ~ TailModule s uvw) => Proxy s -> (Array vw a -> Array w a) -> Array uvw a -> Array 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 s uvw vw a. (SingI s, SingI uvw, vw ~ HeadModule s uvw) => Proxy s -> (Array vw a -> Array vw a) -> Array uvw a -> Array uvw a

>>> 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 s r t a. (SingI s, SingI r, SingI t, IsValidConcat s t r ~ True) => Proxy s -> Array r a -> Array t a -> Array (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]]]

zipWith :: (a -> a -> a) -> Array s a -> Array s a -> Array s a

transpose :: forall s t a. t ~ Transpose s => Array s a -> Array 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 s t a. t ~ Squeeze s => Array s a -> Array 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]]]

(><) :: forall r s a. (CRing a, SingI r, SingI s, SingI (r :++ s)) => Array r a -> Array s a -> Array (r :++ s) a

outer product

todo: reconcile with numhask version

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

mmult :: forall m n k a. (Semiring a, Num a, CRing a, KnownNat m, KnownNat n, KnownNat k) => Array '[m, k] a -> Array '[k, n] a -> Array '[m, n] a

matrix multiplication for a '2-Array'

>>> 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]]

fromList :: IsList l => [Item l] -> l

The fromList function constructs the structure l from the given list of Item l