{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE MagicHash #-}
{-# LANGUAGE NoStarIsType #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeOperators #-}
module Data.Vec.Short
( Vec
, mkVec, mkVec'
, backpermute
, fromList, withVec
, vec1, vec2, vec3, vec4, vec6, vec8
, viota
, svSize, vLength, vSize, withSize
, (!), indexK
, insert, remove, overIx
, nil
, (++), split
, concat, concatMap, reshape
, rev, rot
, vtranspose
, iterate, iterate'
, vsort, vsortBy, vsortOn
, vfindIndex
, map', imap', withPos
, cross
, vscanl
, liftA2Lazy
) where
import Prelude hiding (concatMap, concat, iterate, (++))
import GHC.TypeNats (KnownNat, type (+), type (*))
import GHC.Stack (HasCallStack)
import Data.Fin.Int (Fin)
import Data.SInt (sintVal, unSInt, reifySInt)
import Data.Vec.Short.Internal hiding
( backpermute, mkVec, mkVec', split, reshape, vtranspose
, iterate, iterate', fromList, viota, liftA2Lazy
)
import qualified Data.Vec.Short.Internal as V
mkVec :: KnownNat n => (Fin n -> a) -> Vec n a
mkVec :: forall (n :: Nat) a. KnownNat n => (Fin n -> a) -> Vec n a
mkVec = forall (n :: Nat) a. SInt n -> (Fin n -> a) -> Vec n a
V.mkVec forall (n :: Nat). (HasCallStack, KnownNat n) => SInt n
sintVal
{-# INLINE mkVec #-}
mkVec' :: KnownNat n => (Fin n -> a) -> Vec n a
mkVec' :: forall (n :: Nat) a. KnownNat n => (Fin n -> a) -> Vec n a
mkVec' = forall (n :: Nat) a. SInt n -> (Fin n -> a) -> Vec n a
V.mkVec' forall (n :: Nat). (HasCallStack, KnownNat n) => SInt n
sintVal
{-# INLINE mkVec' #-}
backpermute :: KnownNat m => (Fin m -> Fin n) -> Vec n a -> Vec m a
backpermute :: forall (m :: Nat) (n :: Nat) a.
KnownNat m =>
(Fin m -> Fin n) -> Vec n a -> Vec m a
backpermute = forall (m :: Nat) (n :: Nat) a.
SInt m -> (Fin m -> Fin n) -> Vec n a -> Vec m a
V.backpermute forall (n :: Nat). (HasCallStack, KnownNat n) => SInt n
sintVal
{-# INLINE backpermute #-}
fromList :: (HasCallStack, KnownNat n) => [a] -> Vec n a
fromList :: forall (n :: Nat) a. (HasCallStack, KnownNat n) => [a] -> Vec n a
fromList = forall (n :: Nat) a. HasCallStack => SInt n -> [a] -> Vec n a
V.fromList forall (n :: Nat). (HasCallStack, KnownNat n) => SInt n
sintVal
{-# INLINE fromList #-}
viota :: KnownNat n => Vec n (Fin n)
viota :: forall (n :: Nat). KnownNat n => Vec n (Fin n)
viota = forall (n :: Nat). SInt n -> Vec n (Fin n)
V.viota forall (n :: Nat). (HasCallStack, KnownNat n) => SInt n
sintVal
{-# INLINE viota #-}
split :: KnownNat m => Vec (m + n) a -> (Vec m a, Vec n a)
split :: forall (m :: Nat) (n :: Nat) a.
KnownNat m =>
Vec (m + n) a -> (Vec m a, Vec n a)
split = forall (m :: Nat) (n :: Nat) a.
SInt m -> Vec (m + n) a -> (Vec m a, Vec n a)
V.split forall (n :: Nat). (HasCallStack, KnownNat n) => SInt n
sintVal
{-# INLINE split #-}
reshape :: KnownNat m => Vec (n * m) a -> Vec n (Vec m a)
reshape :: forall (m :: Nat) (n :: Nat) a.
KnownNat m =>
Vec (n * m) a -> Vec n (Vec m a)
reshape = forall (m :: Nat) (n :: Nat) a.
SInt m -> Vec (n * m) a -> Vec n (Vec m a)
V.reshape forall (n :: Nat). (HasCallStack, KnownNat n) => SInt n
sintVal
{-# INLINE reshape #-}
vtranspose :: KnownNat m => Vec n (Vec m a) -> Vec m (Vec n a)
vtranspose :: forall (m :: Nat) (n :: Nat) a.
KnownNat m =>
Vec n (Vec m a) -> Vec m (Vec n a)
vtranspose = forall (m :: Nat) (n :: Nat) a.
SInt m -> Vec n (Vec m a) -> Vec m (Vec n a)
V.vtranspose forall (n :: Nat). (HasCallStack, KnownNat n) => SInt n
sintVal
{-# INLINE vtranspose #-}
vLength :: forall n a. KnownNat n => Vec n a -> Int
vLength :: forall (n :: Nat) a. KnownNat n => Vec n a -> Int
vLength Vec n a
_ = forall (n :: Nat). SInt n -> Int
unSInt @n forall (n :: Nat). (HasCallStack, KnownNat n) => SInt n
sintVal
{-# INLINE vLength #-}
iterate :: KnownNat n => (a -> a) -> a -> Vec n a
iterate :: forall (n :: Nat) a. KnownNat n => (a -> a) -> a -> Vec n a
iterate = forall (n :: Nat) a. SInt n -> (a -> a) -> a -> Vec n a
V.iterate forall (n :: Nat). (HasCallStack, KnownNat n) => SInt n
sintVal
{-# INLINE iterate #-}
iterate' :: KnownNat n => (a -> a) -> a -> Vec n a
iterate' :: forall (n :: Nat) a. KnownNat n => (a -> a) -> a -> Vec n a
iterate' = forall (n :: Nat) a. SInt n -> (a -> a) -> a -> Vec n a
V.iterate' forall (n :: Nat). (HasCallStack, KnownNat n) => SInt n
sintVal
{-# INLINE iterate' #-}
liftA2Lazy :: KnownNat n => (a -> b -> c) -> Vec n a -> Vec n b -> Vec n c
liftA2Lazy :: forall (n :: Nat) a b c.
KnownNat n =>
(a -> b -> c) -> Vec n a -> Vec n b -> Vec n c
liftA2Lazy = forall (n :: Nat) a b c.
SInt n -> (a -> b -> c) -> Vec n a -> Vec n b -> Vec n c
V.liftA2Lazy forall (n :: Nat). (HasCallStack, KnownNat n) => SInt n
sintVal
{-# INLINE liftA2Lazy #-}
withSize :: forall n a r . Vec n a -> (KnownNat n => r) -> r
withSize :: forall (n :: Nat) a r. Vec n a -> (KnownNat n => r) -> r
withSize !Vec n a
xs KnownNat n => r
f = forall (n :: Nat) r. SInt n -> (KnownNat n => r) -> r
reifySInt (forall (n :: Nat) a. Vec n a -> SInt n
svSize Vec n a
xs) KnownNat n => r
f
{-# INLINE withSize #-}