NumHask.Vector

Two different classes are supplied:

• Vector where shape information is held at the type level, and
• SomeVector where shape is held at the value level.

Documentation

newtype Vector n a

a one-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 Boxed Vector is used underneath for efficient slicing, but this may change or become polymorphic in the future.

Constructors

Vector

Fields

• toVec :: Vector a

Instances

Functor (Vector n)

Methods

fmap :: (a -> b) -> Vector n a -> Vector n b

(<$) :: a -> Vector n b -> Vector n a

Foldable (Vector n)

Methods

fold :: Monoid m => Vector n m -> m

foldMap :: Monoid m => (a -> m) -> Vector n a -> m

foldr :: (a -> b -> b) -> b -> Vector n a -> b

foldr' :: (a -> b -> b) -> b -> Vector n a -> b

foldl :: (b -> a -> b) -> b -> Vector n a -> b

foldl' :: (b -> a -> b) -> b -> Vector n a -> b

foldr1 :: (a -> a -> a) -> Vector n a -> a

foldl1 :: (a -> a -> a) -> Vector n a -> a

toList :: Vector n a -> [a]

null :: Vector n a -> Bool

length :: Vector n a -> Int

elem :: Eq a => a -> Vector n a -> Bool

maximum :: Ord a => Vector n a -> a

minimum :: Ord a => Vector n a -> a

sum :: Num a => Vector n a -> a

product :: Num a => Vector n a -> a

KnownNat n => Distributive (Vector n)

Methods

distribute :: Functor f => f (Vector n a) -> Vector n (f a)

collect :: Functor f => (a -> Vector n b) -> f a -> Vector n (f b)

distributeM :: Monad m => m (Vector n a) -> Vector n (m a)

collectM :: Monad m => (a -> Vector n b) -> m a -> Vector n (m b)

KnownNat n => Representable (Vector n)

Associated Types

type Rep (Vector n :: * -> *) :: *

Methods

tabulate :: (Rep (Vector n) -> a) -> Vector n a

index :: Vector n a -> Rep (Vector n) -> a

KnownNat n => Naperian (Vector n)

KnownNat n => HasShape (Vector n)

Associated Types

type Shape (Vector n :: * -> *) :: *

Methods

shape :: Vector n a -> Shape (Vector n)

ndim :: Vector n a -> Int

(KnownNat n, AdditiveUnital a) => IsList (Vector n a)

pads with zero if needed

Associated Types

type Item (Vector n a) :: *

Methods

fromList :: [Item (Vector n a)] -> Vector n a

fromListN :: Int -> [Item (Vector n a)] -> Vector n a

toList :: Vector n a -> [Item (Vector n a)]

Eq a => Eq (Vector n a)

Methods

(==) :: Vector n a -> Vector n a -> Bool

(/=) :: Vector n a -> Vector n a -> Bool

Ord a => Ord (Vector n a)

Methods

compare :: Vector n a -> Vector n a -> Ordering

(<) :: Vector n a -> Vector n a -> Bool

(<=) :: Vector n a -> Vector n a -> Bool

(>) :: Vector n a -> Vector n a -> Bool

(>=) :: Vector n a -> Vector n a -> Bool

max :: Vector n a -> Vector n a -> Vector n a

min :: Vector n a -> Vector n a -> Vector n a

(Show a, KnownNat n) => Show (Vector n a)

Methods

showsPrec :: Int -> Vector n a -> ShowS

show :: Vector n a -> String

showList :: [Vector n a] -> ShowS

(KnownNat n, Arbitrary a, AdditiveUnital a) => Arbitrary (Vector n a)

Methods

arbitrary :: Gen (Vector n a)

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

type Rep (Vector n)

type Rep (Vector n) = Int

type Shape (Vector n)

type Shape (Vector n) = Int

type Item (Vector n a)

type Item (Vector n a) = a

data SomeVector a

a one-dimensional array where shape is specified at the value level Use this to avoid type-level hasochism by demoting a Vector with someVector

Constructors

SomeVector Int (Vector a)

Instances

Functor SomeVector

Methods

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

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

Foldable SomeVector

Methods

fold :: Monoid m => SomeVector m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> SomeVector a -> a

foldl1 :: (a -> a -> a) -> SomeVector a -> a

toList :: SomeVector a -> [a]

null :: SomeVector a -> Bool

length :: SomeVector a -> Int

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

maximum :: Ord a => SomeVector a -> a

minimum :: Ord a => SomeVector a -> a

sum :: Num a => SomeVector a -> a

product :: Num a => SomeVector a -> a

HasShape SomeVector

Associated Types

type Shape (SomeVector :: * -> *) :: *

Methods

shape :: SomeVector a -> Shape SomeVector

ndim :: SomeVector a -> Int

IsList (SomeVector a)

Associated Types

type Item (SomeVector a) :: *

Methods

fromList :: [Item (SomeVector a)] -> SomeVector a

fromListN :: Int -> [Item (SomeVector a)] -> SomeVector a

toList :: SomeVector a -> [Item (SomeVector a)]

Eq a => Eq (SomeVector a)

Methods

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

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

Ord a => Ord (SomeVector a)

Methods

compare :: SomeVector a -> SomeVector a -> Ordering

(<) :: SomeVector a -> SomeVector a -> Bool

(<=) :: SomeVector a -> SomeVector a -> Bool

(>) :: SomeVector a -> SomeVector a -> Bool

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

max :: SomeVector a -> SomeVector a -> SomeVector a

min :: SomeVector a -> SomeVector a -> SomeVector a

Show a => Show (SomeVector a)

Methods

showsPrec :: Int -> SomeVector a -> ShowS

show :: SomeVector a -> String

showList :: [SomeVector a] -> ShowS

Arbitrary a => Arbitrary (SomeVector a)

Methods

arbitrary :: Gen (SomeVector a)

shrink :: SomeVector a -> [SomeVector a]

type Shape SomeVector

type Shape SomeVector = Int

type Item (SomeVector a)

type Item (SomeVector a) = a

newtype ShapeV

used to get sensible arbitrary instances of SomeVector

Constructors

ShapeV

Fields

• unshapeV :: Int

Instances

Arbitrary ShapeV

Methods

arbitrary :: Gen ShapeV

shrink :: ShapeV -> [ShapeV]

Conversion

someVector :: KnownNat r => Vector (r :: Nat) a -> SomeVector a

convert from a Vector to a SomeVector

unsafeToVector :: SomeVector a -> Vector (r :: Nat) a

convert from a SomeVector to a Vector with no shape check

toVector :: forall a r. KnownNat r => SomeVector a -> Maybe (Vector (r :: Nat) a)

convert from a SomeVector to a Vector, checking shape