Data.Vector.Unboxed.Static

Documentation

newtype Vec n a

Constructors

Vec

Fields

unVec :: Vec n Vector a

Instances

(Unbox a, Reify n) => Vector Vector (Vec n a)

(Reify n, Unbox a) => MVector MVector (Vec n a)

(Reify n, Bounded a, Unbox a) => Bounded (Vec n a)

(Eq a, Unbox a) => Eq (Vec n a)

(Reify n, Floating a, Unbox a) => Floating (Vec n a)

(Reify n, Fractional a, Unbox a) => Fractional (Vec n a)

(Reify n, Num a, Unbox a) => Num (Vec n a)

(Ord a, Unbox a) => Ord (Vec n a)

(Show a, Unbox a) => Show (Vec n a)

(Reify n, Monoid a, Unbox a) => Monoid (Vec n a)

(Unbox a, Reify n) => Unbox (Vec n a)

length :: Reify n => Vec n a -> Nat n

null :: forall n v a. Reify n => Vec n a -> Bool

empty :: Unbox a => Vec Z a

singleton :: Unbox a => a -> Vec (S Z) a

cons :: Unbox a => a -> Vec n a -> Vec (S n) a

snoc :: Unbox a => Vec n a -> a -> Vec (S n) a

replicate :: (Unbox a, Reify n) => a -> Vec n a

generate :: (Reify n, Unbox a) => (Fin n -> a) -> Vec n a

(++) :: Unbox a => Vec m a -> Vec n a -> Vec (m :+: n) a

copy :: Unbox a => Vec n a -> Vec n a

(!) :: Unbox a => Vec n a -> Fin n -> a

head :: Unbox a => Vec (S n) a -> a

last :: Unbox a => Vec (S n) a -> a

indexM :: (Monad m, Unbox a) => Vec n a -> Fin n -> m a

headM :: (Unbox a, Monad m) => Vec (S n) a -> m a

lastM :: (Unbox a, Monad m) => Vec (S n) a -> m a

slice :: (Reify k, Unbox a) => Fin n -> Vec (n :+: k) a -> Vec k a

init :: Unbox a => Vec (S n) a -> Vec n a

tail :: Unbox a => Vec (S n) a -> Vec n a

backpermute :: Unbox a => Vec m a -> Vec n (Fin m) -> Vec n a

reverse :: Unbox a => Vec n a -> Vec n a

map :: (Unbox a, Unbox b) => (a -> b) -> Vec n a -> Vec n b

imap :: (Unbox a, Unbox b) => (Fin n -> a -> b) -> Vec n a -> Vec n b

concatMap :: (Unbox a, Unbox b) => (a -> Vec n b) -> Vec m a -> Vec (m :*: n) b

zipWith :: (Unbox a, Unbox b, Unbox c) => (a -> b -> c) -> Vec n a -> Vec n b -> Vec n c

zipWith3 :: (Unbox a, Unbox b, Unbox c, Unbox d) => (a -> b -> c -> d) -> Vec n a -> Vec n b -> Vec n c -> Vec n d

zipWith4 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) => (a -> b -> c -> d -> e) -> Vec n a -> Vec n b -> Vec n c -> Vec n d -> Vec n e

zipWith5 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f) => (a -> b -> c -> d -> e -> f) -> Vec n a -> Vec n b -> Vec n c -> Vec n d -> Vec n e -> Vec n f

zipWith6 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f, Unbox g) => (a -> b -> c -> d -> e -> f -> g) -> Vec n a -> Vec n b -> Vec n c -> Vec n d -> Vec n e -> Vec n f -> Vec n g

izipWith :: (Unbox a, Unbox b, Unbox c) => (Fin n -> a -> b -> c) -> Vec n a -> Vec n b -> Vec n c

izipWith3 :: (Unbox a, Unbox b, Unbox c, Unbox d) => (Fin n -> a -> b -> c -> d) -> Vec n a -> Vec n b -> Vec n c -> Vec n d

izipWith4 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) => (Fin n -> a -> b -> c -> d -> e) -> Vec n a -> Vec n b -> Vec n c -> Vec n d -> Vec n e

izipWith5 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f) => (Fin n -> a -> b -> c -> d -> e -> f) -> Vec n a -> Vec n b -> Vec n c -> Vec n d -> Vec n e -> Vec n f

izipWith6 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f, Unbox g) => (Fin n -> a -> b -> c -> d -> e -> f -> g) -> Vec n a -> Vec n b -> Vec n c -> Vec n d -> Vec n e -> Vec n f -> Vec n g

zip :: (Unbox a, Unbox b) => Vec n a -> Vec n b -> Vec n (a, b)

zip3 :: (Unbox a, Unbox b, Unbox c) => Vec n a -> Vec n b -> Vec n c -> Vec n (a, b, c)

zip4 :: (Unbox a, Unbox b, Unbox c, Unbox d) => Vec n a -> Vec n b -> Vec n c -> Vec n d -> Vec n (a, b, c, d)

zip5 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) => Vec n a -> Vec n b -> Vec n c -> Vec n d -> Vec n e -> Vec n (a, b, c, d, e)

zip6 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f) => Vec n a -> Vec n b -> Vec n c -> Vec n d -> Vec n e -> Vec n f -> Vec n (a, b, c, d, e, f)

unzip :: (Unbox a, Unbox b) => Vec n (a, b) -> (Vec n a, Vec n b)

unzip3 :: (Unbox a, Unbox b, Unbox c) => Vec n (a, b, c) -> (Vec n a, Vec n b, Vec n c)

unzip4 :: (Unbox a, Unbox b, Unbox c, Unbox d) => Vec n (a, b, c, d) -> (Vec n a, Vec n b, Vec n c, Vec n d)

unzip5 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) => Vec n (a, b, c, d, e) -> (Vec n a, Vec n b, Vec n c, Vec n d, Vec n e)

unzip6 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f) => Vec n (a, b, c, d, e, f) -> (Vec n a, Vec n b, Vec n c, Vec n d, Vec n e, Vec n f)

elem :: (Unbox a, Eq a) => a -> Vec n a -> Bool

notElem :: (Unbox a, Eq a) => a -> Vec n a -> Bool

find :: (Unbox a, Eq a) => (a -> Bool) -> Vec n a -> Maybe a

findIndex :: Unbox a => (a -> Bool) -> Vec n a -> Maybe (Fin n)

elemIndex :: (Unbox a, Eq a) => a -> Vec n a -> Maybe (Fin n)

foldl :: Unbox b => (a -> b -> a) -> a -> Vec n b -> a

foldl1 :: Unbox a => (a -> a -> a) -> Vec (S n) a -> a

foldl' :: Unbox b => (a -> b -> a) -> a -> Vec n b -> a

foldl1' :: Unbox a => (a -> a -> a) -> Vec (S n) a -> a

foldr :: Unbox a => (a -> b -> b) -> b -> Vec n a -> b

foldr1 :: Unbox a => (a -> a -> a) -> Vec (S n) a -> a

foldr' :: Unbox a => (a -> b -> b) -> b -> Vec n a -> b

foldr1' :: Unbox a => (a -> a -> a) -> Vec (S n) a -> a

ifoldl :: Unbox b => (a -> Fin n -> b -> a) -> a -> Vec n b -> a

ifoldl' :: Unbox b => (a -> Fin n -> b -> a) -> a -> Vec n b -> a

ifoldr :: Unbox a => (Fin n -> a -> b -> b) -> b -> Vec n a -> b

ifoldr' :: Unbox a => (Fin n -> a -> b -> b) -> b -> Vec n a -> b

all :: Unbox a => (a -> Bool) -> Vec n a -> Bool

any :: Unbox a => (a -> Bool) -> Vec n a -> Bool

and :: Vec n Bool -> Bool

or :: Vec n Bool -> Bool

sum :: (Unbox a, Num a) => Vec n a -> a

product :: (Unbox a, Num a) => Vec n a -> a

minimum :: (Unbox a, Ord a) => Vec (S n) a -> a

minimumBy :: Unbox a => (a -> a -> Ordering) -> Vec (S n) a -> a

minIndex :: (Unbox a, Ord a) => Vec (S n) a -> Fin (S n)

minIndexBy :: Unbox a => (a -> a -> Ordering) -> Vec (S n) a -> Fin (S n)

maximum :: (Unbox a, Ord a) => Vec (S n) a -> a

maximumBy :: Unbox a => (a -> a -> Ordering) -> Vec (S n) a -> a

maxIndex :: (Unbox a, Ord a) => Vec (S n) a -> Fin (S n)

maxIndexBy :: Unbox a => (a -> a -> Ordering) -> Vec (S n) a -> Fin (S n)

unfoldr :: Unbox a => (b -> Maybe (a, b)) -> b -> (forall n. Vec n a -> r) -> r

enumFromN :: forall a n. (Unbox a, Num a, Reify n) => a -> Vec n a

enumFromStepN :: forall a n. (Unbox a, Num a, Reify n) => a -> a -> Vec n a

toList :: Unbox a => Vec n a -> [a]

fromList :: Unbox a => [a] -> (forall n. Vec n a -> r) -> r

stream :: Unbox a => Vec n a -> Stream a

unstream :: Unbox a => Stream a -> (forall n. Vec n a -> r) -> r

streamR :: Unbox a => Vec n a -> Stream a

unstreamR :: Unbox a => Stream a -> (forall n. Vec n a -> r) -> r

new :: Unbox a => New a -> (forall n. Vec n a -> r) -> r

allFin :: Reify n => Vec n (Fin n)