Orphan instances

Methods

tconvert :: forall (a :: TK) (b :: TK). TKConversion a b -> SingletonTK a -> Concrete a -> Concrete b Source #

kfromR :: GoodScalar r => Concrete (TKR 0 r) -> Concrete ('TKScalar r) Source #

kfromS :: GoodScalar r => Concrete (TKS ('[] :: [Nat]) r) -> Concrete ('TKScalar r) Source #

kfromX :: GoodScalar r => Concrete (TKX ('[] :: [Maybe Nat]) r) -> Concrete ('TKScalar r) Source #

rfromK :: GoodScalar r => Concrete ('TKScalar r) -> Concrete (TKR 0 r) Source #

rfromS :: forall (sh :: [Nat]) (x :: TK). (KnownShS sh, KnownSTK x) => Concrete ('TKS2 sh x) -> Concrete ('TKR2 (Rank sh) x) Source #

rfromX :: forall (sh :: [Maybe Nat]) (x :: TK). KnownSTK x => Concrete ('TKX2 sh x) -> Concrete ('TKR2 (Rank sh) x) Source #

sfromK :: GoodScalar r => Concrete ('TKScalar r) -> Concrete (TKS ('[] :: [Nat]) r) Source #

sfromR :: forall (sh :: [Nat]) (x :: TK). (KnownShS sh, KnownSTK x) => Concrete ('TKR2 (Rank sh) x) -> Concrete ('TKS2 sh x) Source #

sfromX :: forall (sh :: [Nat]) (sh' :: [Maybe Nat]) (x :: TK). (KnownShS sh, Rank sh ~ Rank sh', KnownSTK x) => Concrete ('TKX2 sh' x) -> Concrete ('TKS2 sh x) Source #

xfromK :: GoodScalar r => Concrete ('TKScalar r) -> Concrete (TKX ('[] :: [Maybe Nat]) r) Source #

xfromR :: forall (sh' :: [Maybe Nat]) (x :: TK). (KnownShX sh', KnownSTK x) => Concrete ('TKR2 (Rank sh') x) -> Concrete ('TKX2 sh' x) Source #

xfromS :: forall (sh :: [Nat]) (sh' :: [Maybe Nat]) (x :: TK). (KnownShS sh, KnownShX sh', Rank sh ~ Rank sh', KnownSTK x) => Concrete ('TKS2 sh x) -> Concrete ('TKX2 sh' x) Source #

rzip :: forall (y :: TK) (z :: TK) (n :: Nat). (KnownSTK y, KnownSTK z) => Concrete ('TKProduct ('TKR2 n y) ('TKR2 n z)) -> Concrete ('TKR2 n ('TKProduct y z)) Source #

runzip :: forall (y :: TK) (z :: TK) (n :: Nat). Concrete ('TKR2 n ('TKProduct y z)) -> Concrete ('TKProduct ('TKR2 n y) ('TKR2 n z)) Source #

szip :: forall (y :: TK) (z :: TK) (sh :: [Nat]). (KnownSTK y, KnownSTK z) => Concrete ('TKProduct ('TKS2 sh y) ('TKS2 sh z)) -> Concrete ('TKS2 sh ('TKProduct y z)) Source #

sunzip :: forall (y :: TK) (z :: TK) (sh :: [Nat]). Concrete ('TKS2 sh ('TKProduct y z)) -> Concrete ('TKProduct ('TKS2 sh y) ('TKS2 sh z)) Source #

xzip :: forall (y :: TK) (z :: TK) (sh :: [Maybe Nat]). (KnownSTK y, KnownSTK z) => Concrete ('TKProduct ('TKX2 sh y) ('TKX2 sh z)) -> Concrete ('TKX2 sh ('TKProduct y z)) Source #

xunzip :: forall (y :: TK) (z :: TK) (sh :: [Maybe Nat]). Concrete ('TKX2 sh ('TKProduct y z)) -> Concrete ('TKProduct ('TKX2 sh y) ('TKX2 sh z)) Source #

rnest :: forall (n :: Nat) (m :: Nat) (x :: TK). (KnownNat m, KnownSTK x) => SNat n -> Concrete ('TKR2 (n + m) x) -> Concrete ('TKR2 n ('TKR2 m x)) Source #

rnestS :: forall (n :: Nat) (sh2 :: [Nat]) (x :: TK). (KnownShS sh2, KnownSTK x) => SNat n -> Concrete ('TKX2 (Replicate n ('Nothing :: Maybe Nat) ++ MapJust sh2) x) -> Concrete ('TKR2 n ('TKS2 sh2 x)) Source #

rnestX :: forall (n :: Nat) (sh2 :: [Maybe Nat]) (x :: TK). (KnownShX sh2, KnownSTK x) => SNat n -> Concrete ('TKX2 (Replicate n ('Nothing :: Maybe Nat) ++ sh2) x) -> Concrete ('TKR2 n ('TKX2 sh2 x)) Source #

snestR :: forall (sh1 :: [Nat]) (m :: Nat) (x :: TK). (KnownNat m, KnownSTK x) => ShS sh1 -> Concrete ('TKX2 (MapJust sh1 ++ Replicate m ('Nothing :: Maybe Nat)) x) -> Concrete ('TKS2 sh1 ('TKR2 m x)) Source #

snest :: forall (sh1 :: [Nat]) (sh2 :: [Nat]) (x :: TK). (KnownShS sh2, KnownSTK x) => ShS sh1 -> Concrete ('TKS2 (sh1 ++ sh2) x) -> Concrete ('TKS2 sh1 ('TKS2 sh2 x)) Source #

snestX :: forall (sh1 :: [Nat]) (sh2 :: [Maybe Nat]) (x :: TK). (KnownShX sh2, KnownSTK x) => ShS sh1 -> Concrete ('TKX2 (MapJust sh1 ++ sh2) x) -> Concrete ('TKS2 sh1 ('TKX2 sh2 x)) Source #

xnestR :: forall (sh1 :: [Maybe Nat]) (m :: Nat) (x :: TK). (KnownNat m, KnownSTK x) => StaticShX sh1 -> Concrete ('TKX2 (sh1 ++ Replicate m ('Nothing :: Maybe Nat)) x) -> Concrete ('TKX2 sh1 ('TKR2 m x)) Source #

xnestS :: forall (sh1 :: [Maybe Nat]) (sh2 :: [Nat]) (x :: TK). (KnownShS sh2, KnownSTK x) => StaticShX sh1 -> Concrete ('TKX2 (sh1 ++ MapJust sh2) x) -> Concrete ('TKX2 sh1 ('TKS2 sh2 x)) Source #

xnest :: forall (sh1 :: [Maybe Nat]) (sh2 :: [Maybe Nat]) (x :: TK). (KnownShX sh2, KnownSTK x) => StaticShX sh1 -> Concrete ('TKX2 (sh1 ++ sh2) x) -> Concrete ('TKX2 sh1 ('TKX2 sh2 x)) Source #

runNest :: forall (n :: Nat) (m :: Nat) (x :: TK). (KnownNat n, KnownNat m, KnownSTK x) => Concrete ('TKR2 n ('TKR2 m x)) -> Concrete ('TKR2 (n + m) x) Source #

runNestS :: forall (n :: Nat) (sh2 :: [Nat]) (x :: TK). (KnownNat n, KnownShS sh2, KnownSTK x) => Concrete ('TKR2 n ('TKS2 sh2 x)) -> Concrete ('TKX2 (Replicate n ('Nothing :: Maybe Nat) ++ MapJust sh2) x) Source #

runNestX :: forall (n :: Nat) (sh2 :: [Maybe Nat]) (x :: TK). (KnownNat n, KnownShX sh2, KnownSTK x) => Concrete ('TKR2 n ('TKX2 sh2 x)) -> Concrete ('TKX2 (Replicate n ('Nothing :: Maybe Nat) ++ sh2) x) Source #

sunNestR :: forall (sh1 :: [Nat]) (m :: Nat) (x :: TK). (KnownShS sh1, KnownNat m, KnownSTK x) => Concrete ('TKS2 sh1 ('TKR2 m x)) -> Concrete ('TKX2 (MapJust sh1 ++ Replicate m ('Nothing :: Maybe Nat)) x) Source #

sunNest :: forall (sh1 :: [Nat]) (sh2 :: [Nat]) (x :: TK). (KnownShS sh1, KnownShS sh2, KnownSTK x) => Concrete ('TKS2 sh1 ('TKS2 sh2 x)) -> Concrete ('TKS2 (sh1 ++ sh2) x) Source #

sunNestX :: forall (sh1 :: [Nat]) (sh2 :: [Maybe Nat]) (x :: TK). (KnownShS sh1, KnownShX sh2, KnownSTK x) => Concrete ('TKS2 sh1 ('TKX2 sh2 x)) -> Concrete ('TKX2 (MapJust sh1 ++ sh2) x) Source #

xunNestR :: forall (sh1 :: [Maybe Nat]) (m :: Nat) (x :: TK). (KnownShX sh1, KnownNat m, KnownSTK x) => Concrete ('TKX2 sh1 ('TKR2 m x)) -> Concrete ('TKX2 (sh1 ++ Replicate m ('Nothing :: Maybe Nat)) x) Source #

xunNestS :: forall (sh1 :: [Maybe Nat]) (sh2 :: [Nat]) (x :: TK). (KnownShX sh1, KnownShS sh2, KnownSTK x) => Concrete ('TKX2 sh1 ('TKS2 sh2 x)) -> Concrete ('TKX2 (sh1 ++ MapJust sh2) x) Source #

xunNest :: forall (sh1 :: [Maybe Nat]) (sh2 :: [Maybe Nat]) (x :: TK). (KnownShX sh1, KnownShX sh2, KnownSTK x) => Concrete ('TKX2 sh1 ('TKX2 sh2 x)) -> Concrete ('TKX2 (sh1 ++ sh2) x) Source #

tpairConv :: forall (x :: TK) (z :: TK). Concrete x -> Concrete z -> Concrete ('TKProduct x z) Source #

tunpairConv :: forall (x :: TK) (z :: TK). Concrete ('TKProduct x z) -> (Concrete x, Concrete z) Source #

Methods

rshape :: forall (n :: Nat) (x :: TK). KnownSTK x => Concrete ('TKR2 n x) -> IShR n Source #

rlength :: forall (n :: Nat) (x :: TK). KnownSTK x => Concrete ('TKR2 n x) -> Int Source #

rsize :: forall (n :: Nat) (x :: TK). KnownSTK x => Concrete ('TKR2 n x) -> Int Source #

rwidth :: forall (n :: Natural) (x :: TK). KnownSTK x => Concrete ('TKR2 (1 + n) x) -> Int Source #

sshape :: forall (sh :: [Nat]) (x :: TK). KnownSTK x => Concrete ('TKS2 sh x) -> ShS sh Source #

slength :: forall (sh :: [Nat]) (x :: TK). KnownSTK x => Concrete ('TKS2 sh x) -> Int Source #

ssize :: forall (sh :: [Nat]) (x :: TK). KnownSTK x => Concrete ('TKS2 sh x) -> Int Source #

swidth :: forall (n :: Nat) (sh :: [Nat]) (x :: TK). KnownSTK x => Concrete ('TKS2 (n ': sh) x) -> Int Source #

xshape :: forall (sh :: [Maybe Nat]) (x :: TK). KnownSTK x => Concrete ('TKX2 sh x) -> IShX sh Source #

xlength :: forall (sh :: [Maybe Nat]) (x :: TK). KnownSTK x => Concrete ('TKX2 sh x) -> Int Source #

xsize :: forall (sh :: [Maybe Nat]) (x :: TK). KnownSTK x => Concrete ('TKX2 sh x) -> Int Source #

xwidth :: forall (mn :: Maybe Nat) (sh :: [Maybe Nat]) (x :: TK). KnownSTK x => Concrete ('TKX2 (mn ': sh) x) -> Int Source #

tsize :: forall (y :: TK). SingletonTK y -> Concrete y -> Int Source #

tftk :: forall (y :: TK). SingletonTK y -> Concrete y -> FullShapeTK y Source #

tpair :: forall (x :: TK) (z :: TK). Concrete x -> Concrete z -> Concrete ('TKProduct x z) Source #

tproject1 :: forall (x :: TK) (z :: TK). Concrete ('TKProduct x z) -> Concrete x Source #

tproject2 :: forall (x :: TK) (z :: TK). Concrete ('TKProduct x z) -> Concrete z Source #

tcond :: forall (y :: TK). Boolean (BoolOf Concrete) => SingletonTK y -> BoolOf Concrete -> Concrete y -> Concrete y -> Concrete y Source #

trconcrete :: forall r (n :: Nat). GoodScalar r => Ranked n r -> Concrete (TKR n r) Source #

tsconcrete :: forall r (sh :: [Nat]). GoodScalar r => Shaped sh r -> Concrete (TKS sh r) Source #

txconcrete :: forall r (sh :: [Maybe Nat]). GoodScalar r => Mixed sh r -> Concrete (TKX sh r) Source #

tkconcrete :: GoodScalar r => r -> Concrete ('TKScalar r) Source #

tconcrete :: forall (y :: TK). FullShapeTK y -> Concrete y -> Concrete y Source #

trfromVector :: forall (n :: Nat) (x :: TK). (KnownNat n, KnownSTK x) => Vector (Concrete ('TKR2 n x)) -> Concrete ('TKR2 (1 + n) x) Source #

trfromVector0N :: forall (n :: Nat) (x :: TK). KnownSTK x => IShR n -> Vector (Concrete ('TKR2 0 x)) -> Concrete ('TKR2 n x) Source #

trunravelToList :: forall (n :: Nat) (x :: TK). (KnownNat n, KnownSTK x) => Concrete ('TKR2 (1 + n) x) -> [Concrete ('TKR2 n x)] Source #

tsfromVector :: forall (n :: Nat) (sh :: [Nat]) (x :: TK). (KnownNat n, KnownShS sh, KnownSTK x) => Vector (Concrete ('TKS2 sh x)) -> Concrete ('TKS2 (n ': sh) x) Source #

tsfromVector0N :: forall (sh :: [Nat]) (x :: TK). (KnownShS sh, KnownSTK x) => Vector (Concrete ('TKS2 ('[] :: [Nat]) x)) -> Concrete ('TKS2 sh x) Source #

tsunravelToList :: forall (n :: Nat) (sh :: [Nat]) (x :: TK). (KnownNat n, KnownShS sh, KnownSTK x) => Concrete ('TKS2 (n ': sh) x) -> [Concrete ('TKS2 sh x)] Source #

txfromVector :: forall (n :: Nat) (sh :: [Maybe Nat]) (x :: TK). (KnownNat n, KnownShX sh, KnownSTK x) => Vector (Concrete ('TKX2 sh x)) -> Concrete ('TKX2 ('Just n ': sh) x) Source #

txfromVector0N :: forall (sh :: [Maybe Nat]) (x :: TK). KnownSTK x => IShX sh -> Vector (Concrete ('TKX2 ('[] :: [Maybe Nat]) x)) -> Concrete ('TKX2 sh x) Source #

txunravelToList :: forall (n :: Nat) (sh :: [Maybe Nat]) (x :: TK). (KnownNat n, KnownShX sh, KnownSTK x) => Concrete ('TKX2 ('Just n ': sh) x) -> [Concrete ('TKX2 sh x)] Source #

tfromVector :: forall (y :: TK) (k :: Nat). SNat k -> SingletonTK y -> Vector (Concrete y) -> Concrete (BuildTensorKind k y) Source #

tfromListR :: forall (y :: TK) (k :: Nat). SingletonTK y -> ListR k (Concrete y) -> Concrete (BuildTensorKind k y) Source #

trsum :: forall (n :: Nat) (x :: TK). (KnownNat n, KnownSTK x) => Concrete ('TKR2 (1 + n) x) -> Concrete ('TKR2 n x) Source #

trsum0 :: forall (n :: Nat) (x :: TK). (KnownNat n, KnownSTK x) => Concrete ('TKR2 n x) -> Concrete ('TKR2 0 x) Source #

trdot0 :: forall (n :: Nat) r. (KnownNat n, GoodScalar r) => Concrete (TKR n r) -> Concrete (TKR n r) -> Concrete (TKR 0 r) Source #

trdot1In :: forall (n :: Nat) r. (KnownNat n, GoodScalar r) => Concrete (TKR (1 + n) r) -> Concrete (TKR (1 + n) r) -> Concrete (TKR n r) Source #

trmatvecmul :: GoodScalar r => Concrete (TKR 2 r) -> Concrete (TKR 1 r) -> Concrete (TKR 1 r) Source #

trmatmul2 :: GoodScalar r => Concrete (TKR 2 r) -> Concrete (TKR 2 r) -> Concrete (TKR 2 r) Source #

trreplicate :: forall (n :: Nat) (x :: TK). (KnownNat n, KnownSTK x) => Int -> Concrete ('TKR2 n x) -> Concrete ('TKR2 (1 + n) x) Source #

trreplicate0N :: forall (n :: Nat) (x :: TK). (KnownNat n, KnownSTK x) => IShR n -> Concrete ('TKR2 0 x) -> Concrete ('TKR2 n x) Source #

tssum :: forall (n :: Nat) (sh :: [Nat]) (x :: TK). (KnownNat n, KnownShS sh, KnownSTK x) => Concrete ('TKS2 (n ': sh) x) -> Concrete ('TKS2 sh x) Source #

tssum0 :: forall (sh :: [Nat]) (x :: TK). (KnownShS sh, KnownSTK x) => Concrete ('TKS2 sh x) -> Concrete ('TKS2 ('[] :: [Nat]) x) Source #

tsdot0 :: forall (sh :: [Nat]) r. (KnownShS sh, GoodScalar r) => Concrete (TKS sh r) -> Concrete (TKS sh r) -> Concrete (TKS ('[] :: [Nat]) r) Source #

tsdot1In :: forall (sh :: [Nat]) r (n :: Nat). (KnownShS sh, GoodScalar r) => SNat n -> Concrete (TKS (sh ++ '[n]) r) -> Concrete (TKS (sh ++ '[n]) r) -> Concrete (TKS sh r) Source #

tsmatvecmul :: forall (m :: Nat) (n :: Nat) r. (KnownNat m, KnownNat n, GoodScalar r) => Concrete (TKS '[m, n] r) -> Concrete (TKS '[n] r) -> Concrete (TKS '[m] r) Source #

tsmatmul2 :: forall (m :: Nat) (n :: Nat) (p :: Nat) r. (KnownNat m, KnownNat n, KnownNat p, GoodScalar r) => Concrete (TKS '[m, n] r) -> Concrete (TKS '[n, p] r) -> Concrete (TKS '[m, p] r) Source #

tsreplicate :: forall (sh :: [Nat]) (k :: Nat) (x :: TK). KnownSTK x => SNat k -> ShS sh -> Concrete ('TKS2 sh x) -> Concrete ('TKS2 (k ': sh) x) Source #

tsreplicate0N :: forall (sh :: [Nat]) (x :: TK). KnownSTK x => ShS sh -> Concrete ('TKS2 ('[] :: [Nat]) x) -> Concrete ('TKS2 sh x) Source #

txsum :: forall (n :: Nat) (sh :: [Maybe Nat]) (x :: TK). (KnownNat n, KnownShX sh, KnownSTK x) => Concrete ('TKX2 ('Just n ': sh) x) -> Concrete ('TKX2 sh x) Source #

txsum0 :: forall (sh :: [Maybe Nat]) (x :: TK). (KnownShX sh, KnownSTK x, ConvertTensor Concrete) => Concrete ('TKX2 sh x) -> Concrete ('TKX2 ('[] :: [Maybe Nat]) x) Source #

txdot0 :: forall (sh :: [Maybe Nat]) r. (KnownShX sh, GoodScalar r, ConvertTensor Concrete) => Concrete (TKX sh r) -> Concrete (TKX sh r) -> Concrete (TKX ('[] :: [Maybe Nat]) r) Source #

txdot1In :: forall (sh :: [Maybe Nat]) r (n :: Nat). (KnownShX sh, GoodScalar r) => SNat n -> Concrete (TKX (sh ++ '['Just n]) r) -> Concrete (TKX (sh ++ '['Just n]) r) -> Concrete (TKX sh r) Source #

txmatvecmul :: forall (mm :: Maybe Nat) (mn :: Maybe Nat) r. (GoodScalar r, ConvertTensor Concrete) => SMayNat Int SNat mm -> SMayNat Int SNat mn -> Concrete (TKX '[mm, mn] r) -> Concrete (TKX '[mn] r) -> Concrete (TKX '[mm] r) Source #

txmatmul2 :: forall (m :: Nat) (n :: Nat) (p :: Nat) r. (KnownNat m, KnownNat n, KnownNat p, GoodScalar r, ConvertTensor Concrete) => Concrete (TKX '['Just m, 'Just n] r) -> Concrete (TKX '['Just n, 'Just p] r) -> Concrete (TKX '['Just m, 'Just p] r) Source #

txreplicate :: forall (sh :: [Maybe Nat]) (k :: Nat) (x :: TK). KnownSTK x => SNat k -> StaticShX sh -> Concrete ('TKX2 sh x) -> Concrete ('TKX2 ('Just k ': sh) x) Source #

txreplicate0N :: forall (sh :: [Maybe Nat]) (x :: TK). (KnownShX sh, KnownSTK x) => IShX sh -> Concrete ('TKX2 ('[] :: [Maybe Nat]) x) -> Concrete ('TKX2 sh x) Source #

trindex :: forall (m :: Nat) (n :: Nat) (x :: TK). (KnownNat m, KnownNat n, KnownSTK x) => Concrete ('TKR2 (m + n) x) -> IxROf Concrete m -> Concrete ('TKR2 n x) Source #

trindex0 :: forall (m :: Nat) (x :: TK). (KnownNat m, KnownSTK x) => Concrete ('TKR2 m x) -> IxROf Concrete m -> Concrete ('TKR2 0 x) Source #

troneHot :: forall (m :: Nat) (n :: Nat) (x :: TK). (KnownNat m, KnownNat n, KnownSTK x, BoolOf (PrimalOf Concrete) ~ BoolOf Concrete, EqH (PrimalOf Concrete) ('TKScalar Int64)) => IShR m -> Concrete ('TKR2 n x) -> IxROf Concrete m -> Concrete ('TKR2 (m + n) x) Source #

trscatter :: forall (m :: Nat) (n :: Nat) (p :: Nat) (x :: TK). (KnownNat m, KnownNat n, KnownNat p, KnownSTK x) => IShR (p + n) -> Concrete ('TKR2 (m + n) x) -> (IxROf Concrete m -> IxROf Concrete p) -> Concrete ('TKR2 (p + n) x) Source #

trscatter1 :: forall (n :: Nat) (p :: Nat) (x :: TK). (KnownNat n, KnownNat p, KnownSTK x) => IShR (p + n) -> Concrete ('TKR2 (1 + n) x) -> (IntOf Concrete -> IxROf Concrete p) -> Concrete ('TKR2 (p + n) x) Source #

trgather :: forall (m :: Nat) (n :: Nat) (p :: Nat) (x :: TK). (KnownNat m, KnownNat n, KnownNat p, KnownSTK x) => IShR (m + n) -> Concrete ('TKR2 (p + n) x) -> (IxROf Concrete m -> IxROf Concrete p) -> Concrete ('TKR2 (m + n) x) Source #

trgather1 :: forall (n :: Nat) (p :: Nat) (x :: TK). (KnownNat n, KnownNat p, KnownSTK x) => Int -> Concrete ('TKR2 (p + n) x) -> (IntOf Concrete -> IxROf Concrete p) -> Concrete ('TKR2 (1 + n) x) Source #

tsindex :: forall (shm :: [Nat]) (shn :: [Nat]) (x :: TK). (KnownShS shm, KnownShS shn, KnownSTK x) => Concrete ('TKS2 (shm ++ shn) x) -> IxSOf Concrete shm -> Concrete ('TKS2 shn x) Source #

tsindex0 :: forall (sh1 :: [Nat]) (x :: TK). (KnownShS sh1, KnownSTK x) => Concrete ('TKS2 sh1 x) -> IxSOf Concrete sh1 -> Concrete ('TKS2 ('[] :: [Nat]) x) Source #

tsoneHot :: forall (sh1 :: [Nat]) (sh2 :: [Nat]) (x :: TK). (KnownShS sh1, KnownShS sh2, KnownSTK x, BoolOf (PrimalOf Concrete) ~ BoolOf Concrete, EqH (PrimalOf Concrete) ('TKScalar Int64)) => Concrete ('TKS2 sh2 x) -> IxSOf Concrete sh1 -> Concrete ('TKS2 (sh1 ++ sh2) x) Source #

tsscatter :: forall (shm :: [Nat]) (shn :: [Nat]) (shp :: [Nat]) (x :: TK). (KnownShS shm, KnownShS shn, KnownShS shp, KnownSTK x) => Concrete ('TKS2 (shm ++ shn) x) -> (IxSOf Concrete shm -> IxSOf Concrete shp) -> Concrete ('TKS2 (shp ++ shn) x) Source #

tsscatter1 :: forall (n2 :: Nat) (shn :: [Nat]) (shp :: [Nat]) (x :: TK). (KnownNat n2, KnownShS shn, KnownShS shp, KnownSTK x) => Concrete ('TKS2 (n2 ': shn) x) -> (IntOf Concrete -> IxSOf Concrete shp) -> Concrete ('TKS2 (shp ++ shn) x) Source #

tsgather :: forall (shm :: [Nat]) (shn :: [Nat]) (shp :: [Nat]) (x :: TK). (KnownShS shm, KnownShS shn, KnownShS shp, KnownSTK x) => Concrete ('TKS2 (shp ++ shn) x) -> (IxSOf Concrete shm -> IxSOf Concrete shp) -> Concrete ('TKS2 (shm ++ shn) x) Source #

tsgather1 :: forall (n2 :: Nat) (shn :: [Nat]) (shp :: [Nat]) (x :: TK). (KnownNat n2, KnownShS shn, KnownShS shp, KnownSTK x) => Concrete ('TKS2 (shp ++ shn) x) -> (IntOf Concrete -> IxSOf Concrete shp) -> Concrete ('TKS2 (n2 ': shn) x) Source #

txindex :: forall (sh1 :: [Maybe Nat]) (sh2 :: [Maybe Nat]) (x :: TK). (KnownShX sh1, KnownShX sh2, KnownSTK x) => Concrete ('TKX2 (sh1 ++ sh2) x) -> IxXOf Concrete sh1 -> Concrete ('TKX2 sh2 x) Source #

txindex0 :: forall (sh1 :: [Maybe Nat]) (x :: TK). (KnownShX sh1, KnownSTK x) => Concrete ('TKX2 sh1 x) -> IxXOf Concrete sh1 -> Concrete ('TKX2 ('[] :: [Maybe Nat]) x) Source #

txoneHot :: forall (sh1 :: [Maybe Nat]) (sh2 :: [Maybe Nat]) (x :: TK). (KnownShX sh1, KnownShX sh2, KnownSTK x, BoolOf (PrimalOf Concrete) ~ BoolOf Concrete, EqH (PrimalOf Concrete) ('TKScalar Int64), ConvertTensor Concrete) => IShX sh1 -> Concrete ('TKX2 sh2 x) -> IxXOf Concrete sh1 -> Concrete ('TKX2 (sh1 ++ sh2) x) Source #

txscatter :: forall (shm :: [Maybe Nat]) (shn :: [Maybe Nat]) (shp :: [Maybe Nat]) (x :: TK). (KnownShX shm, KnownShX shn, KnownShX shp, KnownSTK x) => IShX (shp ++ shn) -> Concrete ('TKX2 (shm ++ shn) x) -> (IxXOf Concrete shm -> IxXOf Concrete shp) -> Concrete ('TKX2 (shp ++ shn) x) Source #

txscatter1 :: forall (n2 :: Nat) (shn :: [Maybe Nat]) (shp :: [Maybe Nat]) (x :: TK). (KnownNat n2, KnownShX shn, KnownShX shp, KnownSTK x) => IShX (shp ++ shn) -> Concrete ('TKX2 ('Just n2 ': shn) x) -> (IntOf Concrete -> IxXOf Concrete shp) -> Concrete ('TKX2 (shp ++ shn) x) Source #

txgather :: forall (shm :: [Maybe Nat]) (shn :: [Maybe Nat]) (shp :: [Maybe Nat]) (x :: TK). (KnownShX shm, KnownShX shn, KnownShX shp, KnownSTK x) => IShX (shm ++ shn) -> Concrete ('TKX2 (shp ++ shn) x) -> (IxXOf Concrete shm -> IxXOf Concrete shp) -> Concrete ('TKX2 (shm ++ shn) x) Source #

txgather1 :: forall (n2 :: Nat) (shn :: [Maybe Nat]) (shp :: [Maybe Nat]) (x :: TK). (KnownNat n2, KnownShX shn, KnownShX shp, KnownSTK x) => SNat n2 -> Concrete ('TKX2 (shp ++ shn) x) -> (IntOf Concrete -> IxXOf Concrete shp) -> Concrete ('TKX2 ('Just n2 ': shn) x) Source #

trfloor :: forall r r2 (n :: Nat). (GoodScalar r, RealFrac r, GoodScalar r2, Integral r2) => Concrete (TKR n r) -> Concrete (TKR n r2) Source #

trfromIntegral :: forall r1 r2 (n :: Nat). (GoodScalar r1, Integral r1, GoodScalar r2) => Concrete (TKR n r1) -> Concrete (TKR n r2) Source #

trcast :: forall r1 r2 (n :: Nat). (RealFrac r1, GoodScalar r1, RealFrac r2, GoodScalar r2) => Concrete (TKR n r1) -> Concrete (TKR n r2) Source #

trminIndex :: forall (n :: Natural) r r2. (GoodScalar r, GoodScalar r2) => Concrete (TKR (1 + n) r) -> Concrete (TKR n r2) Source #

trmaxIndex :: forall (n :: Natural) r r2. (GoodScalar r, GoodScalar r2) => Concrete (TKR (1 + n) r) -> Concrete (TKR n r2) Source #

triota :: GoodScalar r => Int -> Concrete (TKR 1 r) Source #

tsfloor :: forall r r2 (sh :: [Nat]). (GoodScalar r, RealFrac r, GoodScalar r2, Integral r2) => Concrete (TKS sh r) -> Concrete (TKS sh r2) Source #

tsfromIntegral :: forall r1 r2 (sh :: [Nat]). (GoodScalar r1, Integral r1, GoodScalar r2) => Concrete (TKS sh r1) -> Concrete (TKS sh r2) Source #

tscast :: forall r1 r2 (sh :: [Nat]). (RealFrac r1, GoodScalar r1, RealFrac r2, GoodScalar r2) => Concrete (TKS sh r1) -> Concrete (TKS sh r2) Source #

tsminIndex :: forall (n :: Nat) (sh :: [Nat]) r r2. (GoodScalar r, GoodScalar r2) => Concrete (TKS (n ': sh) r) -> Concrete (TKS (Init (n ': sh)) r2) Source #

tsmaxIndex :: forall (n :: Nat) (sh :: [Nat]) r r2. (GoodScalar r, GoodScalar r2) => Concrete (TKS (n ': sh) r) -> Concrete (TKS (Init (n ': sh)) r2) Source #

tsiota :: forall (n :: Nat) r. (KnownNat n, GoodScalar r) => Concrete (TKS '[n] r) Source #

txfloor :: forall r r2 (sh :: [Maybe Nat]). (GoodScalar r, RealFrac r, GoodScalar r2, Integral r2) => Concrete (TKX sh r) -> Concrete (TKX sh r2) Source #

txfromIntegral :: forall r1 r2 (sh :: [Maybe Nat]). (GoodScalar r1, Integral r1, GoodScalar r2) => Concrete (TKX sh r1) -> Concrete (TKX sh r2) Source #

txcast :: forall r1 r2 (sh :: [Maybe Nat]). (RealFrac r1, GoodScalar r1, RealFrac r2, GoodScalar r2) => Concrete (TKX sh r1) -> Concrete (TKX sh r2) Source #

txminIndex :: forall (mn :: Maybe Nat) (sh :: [Maybe Nat]) r r2. (GoodScalar r, GoodScalar r2) => Concrete (TKX (mn ': sh) r) -> Concrete (TKX (Init (mn ': sh)) r2) Source #

txmaxIndex :: forall (mn :: Maybe Nat) (sh :: [Maybe Nat]) r r2. (GoodScalar r, GoodScalar r2) => Concrete (TKX (mn ': sh) r) -> Concrete (TKX (Init (mn ': sh)) r2) Source #

txiota :: forall (n :: Nat) r. (KnownNat n, GoodScalar r) => Concrete (TKX '['Just n] r) Source #

tkfloor :: (GoodScalar r, RealFrac r, GoodScalar r2, Integral r2) => Concrete ('TKScalar r) -> Concrete ('TKScalar r2) Source #

tkfromIntegral :: (GoodScalar r1, Integral r1, GoodScalar r2) => Concrete ('TKScalar r1) -> Concrete ('TKScalar r2) Source #

tkcast :: (RealFrac r1, GoodScalar r1, RealFrac r2, GoodScalar r2) => Concrete ('TKScalar r1) -> Concrete ('TKScalar r2) Source #

trappend :: forall (n :: Natural) (x :: TK). KnownSTK x => Concrete ('TKR2 (1 + n) x) -> Concrete ('TKR2 (1 + n) x) -> Concrete ('TKR2 (1 + n) x) Source #

trslice :: forall (n :: Natural) (x :: TK). KnownSTK x => Int -> Int -> Concrete ('TKR2 (1 + n) x) -> Concrete ('TKR2 (1 + n) x) Source #

trreverse :: forall (n :: Natural) (x :: TK). KnownSTK x => Concrete ('TKR2 (1 + n) x) -> Concrete ('TKR2 (1 + n) x) Source #

trtranspose :: forall (n :: Nat) (x :: TK). KnownSTK x => PermR -> Concrete ('TKR2 n x) -> Concrete ('TKR2 n x) Source #

trreshape :: forall (n :: Nat) (m :: Nat) (x :: TK). KnownSTK x => IShR m -> Concrete ('TKR2 n x) -> Concrete ('TKR2 m x) Source #

tsappend :: forall (m :: Nat) (n :: Nat) (sh :: [Nat]) (x :: TK). KnownSTK x => Concrete ('TKS2 (m ': sh) x) -> Concrete ('TKS2 (n ': sh) x) -> Concrete ('TKS2 ((m + n) ': sh) x) Source #

tsslice :: forall (i :: Nat) (n :: Nat) (k :: Nat) (sh :: [Natural]) (x :: TK). KnownSTK x => SNat i -> SNat n -> SNat k -> Concrete ('TKS2 (((i + n) + k) ': sh) x) -> Concrete ('TKS2 (n ': sh) x) Source #

tsreverse :: forall (n :: Nat) (sh :: [Nat]) (x :: TK). KnownSTK x => Concrete ('TKS2 (n ': sh) x) -> Concrete ('TKS2 (n ': sh) x) Source #

tstranspose :: forall (perm :: [Natural]) (sh :: [Nat]) (x :: TK). (IsPermutation perm, Rank perm <= Rank sh, KnownSTK x) => Perm perm -> Concrete ('TKS2 sh x) -> Concrete ('TKS2 (PermutePrefix perm sh) x) Source #

tsreshape :: forall (sh :: [Natural]) (sh2 :: [Natural]) (x :: TK). (Product sh ~ Product sh2, KnownSTK x) => ShS sh2 -> Concrete ('TKS2 sh x) -> Concrete ('TKS2 sh2 x) Source #

txappend :: forall (m :: Nat) (n :: Nat) (sh :: [Maybe Nat]) (x :: TK). KnownSTK x => Concrete ('TKX2 ('Just m ': sh) x) -> Concrete ('TKX2 ('Just n ': sh) x) -> Concrete ('TKX2 ('Just (m + n) ': sh) x) Source #

txslice :: forall (i :: Nat) (n :: Nat) (k :: Nat) (sh :: [Maybe Natural]) (x :: TK). KnownSTK x => SNat i -> SNat n -> SNat k -> Concrete ('TKX2 ('Just ((i + n) + k) ': sh) x) -> Concrete ('TKX2 ('Just n ': sh) x) Source #

txreverse :: forall (mn :: Maybe Nat) (sh :: [Maybe Nat]) (x :: TK). KnownSTK x => Concrete ('TKX2 (mn ': sh) x) -> Concrete ('TKX2 (mn ': sh) x) Source #

txtranspose :: forall (perm :: [Natural]) (sh :: [Maybe Nat]) (x :: TK). (IsPermutation perm, Rank perm <= Rank sh, KnownSTK x) => Perm perm -> Concrete ('TKX2 sh x) -> Concrete ('TKX2 (PermutePrefix perm sh) x) Source #

txreshape :: forall (sh :: [Maybe Nat]) (sh2 :: [Maybe Nat]) (x :: TK). KnownSTK x => IShX sh2 -> Concrete ('TKX2 sh x) -> Concrete ('TKX2 sh2 x) Source #

trbuild1 :: forall (n :: Nat) (x :: TK). (KnownNat n, KnownSTK x) => Int -> (IntOf Concrete -> Concrete ('TKR2 n x)) -> Concrete ('TKR2 (1 + n) x) Source #

trmap0N :: forall (n :: Nat) (x :: TK) (x1 :: TK). (KnownNat n, KnownSTK x, KnownSTK x1) => (Concrete ('TKR2 0 x1) -> Concrete ('TKR2 0 x)) -> Concrete ('TKR2 n x1) -> Concrete ('TKR2 n x) Source #

trzipWith0N :: forall (n :: Nat) (x :: TK) (x1 :: TK) (x2 :: TK). (KnownNat n, KnownSTK x, KnownSTK x1, KnownSTK x2) => (Concrete ('TKR2 0 x1) -> Concrete ('TKR2 0 x2) -> Concrete ('TKR2 0 x)) -> Concrete ('TKR2 n x1) -> Concrete ('TKR2 n x2) -> Concrete ('TKR2 n x) Source #

tsbuild1 :: forall (k :: Nat) (sh :: [Nat]) (x :: TK). (KnownNat k, KnownShS sh, KnownSTK x) => (IntOf Concrete -> Concrete ('TKS2 sh x)) -> Concrete ('TKS2 (k ': sh) x) Source #

tsmap0N :: forall (sh :: [Nat]) (x :: TK) (x1 :: TK). (KnownShS sh, KnownSTK x, KnownSTK x1) => (Concrete ('TKS2 ('[] :: [Nat]) x1) -> Concrete ('TKS2 ('[] :: [Nat]) x)) -> Concrete ('TKS2 sh x1) -> Concrete ('TKS2 sh x) Source #

tszipWith0N :: forall (sh :: [Nat]) (x :: TK) (x1 :: TK) (x2 :: TK). (KnownShS sh, KnownSTK x, KnownSTK x1, KnownSTK x2) => (Concrete ('TKS2 ('[] :: [Nat]) x1) -> Concrete ('TKS2 ('[] :: [Nat]) x2) -> Concrete ('TKS2 ('[] :: [Nat]) x)) -> Concrete ('TKS2 sh x1) -> Concrete ('TKS2 sh x2) -> Concrete ('TKS2 sh x) Source #

txbuild1 :: forall (k :: Nat) (sh :: [Maybe Nat]) (x :: TK). (KnownNat k, KnownShX sh, KnownSTK x) => (IntOf Concrete -> Concrete ('TKX2 sh x)) -> Concrete ('TKX2 ('Just k ': sh) x) Source #

tbuild1 :: forall (y :: TK) (k :: Nat). ConvertTensor Concrete => SNat k -> SingletonTK y -> (IntOf Concrete -> Concrete y) -> Concrete (BuildTensorKind k y) Source #

tmapAccumRDer :: forall (accy :: TK) (by :: TK) (ey :: TK) (k :: Nat). Proxy Concrete -> SNat k -> FullShapeTK accy -> FullShapeTK by -> FullShapeTK ey -> HFunOf Concrete ('TKProduct accy ey) ('TKProduct accy by) -> HFunOf Concrete ('TKProduct (ADTensorKind ('TKProduct accy ey)) ('TKProduct accy ey)) (ADTensorKind ('TKProduct accy by)) -> HFunOf Concrete ('TKProduct (ADTensorKind ('TKProduct accy by)) ('TKProduct accy ey)) (ADTensorKind ('TKProduct accy ey)) -> Concrete accy -> Concrete (BuildTensorKind k ey) -> Concrete ('TKProduct accy (BuildTensorKind k by)) Source #

tmapAccumLDer :: forall (accy :: TK) (by :: TK) (ey :: TK) (k :: Nat). Proxy Concrete -> SNat k -> FullShapeTK accy -> FullShapeTK by -> FullShapeTK ey -> HFunOf Concrete ('TKProduct accy ey) ('TKProduct accy by) -> HFunOf Concrete ('TKProduct (ADTensorKind ('TKProduct accy ey)) ('TKProduct accy ey)) (ADTensorKind ('TKProduct accy by)) -> HFunOf Concrete ('TKProduct (ADTensorKind ('TKProduct accy by)) ('TKProduct accy ey)) (ADTensorKind ('TKProduct accy ey)) -> Concrete accy -> Concrete (BuildTensorKind k ey) -> Concrete ('TKProduct accy (BuildTensorKind k by)) Source #

tApply :: forall (x :: TK) (z :: TK). HFunOf Concrete x z -> Concrete x -> Concrete z Source #

tlambda :: forall (x :: TK) (z :: TK). FullShapeTK x -> HFun x z -> HFunOf Concrete x z Source #

tgrad :: forall (x :: TK) r. FullShapeTK x -> HFun x ('TKScalar r) -> HFunOf Concrete x (ADTensorKind x) Source #

tvjp :: forall (x :: TK) (z :: TK). FullShapeTK x -> HFun x z -> HFunOf Concrete ('TKProduct (ADTensorKind z) x) (ADTensorKind x) Source #

tjvp :: forall (x :: TK) (z :: TK). FullShapeTK x -> HFun x z -> HFunOf Concrete ('TKProduct (ADTensorKind x) x) (ADTensorKind z) Source #

tprimalPart :: forall (y :: TK). Concrete y -> PrimalOf Concrete y Source #

tdualPart :: forall (y :: TK). SingletonTK y -> Concrete y -> DualOf Concrete y Source #

tfromPrimal :: forall (y :: TK). SingletonTK y -> PrimalOf Concrete y -> Concrete y Source #

tfromDual :: forall (y :: TK). DualOf Concrete y -> Concrete y Source #

tScale :: forall (y :: TK). (Num (Concrete y), Num (PrimalOf Concrete y)) => SingletonTK y -> PrimalOf Concrete y -> DualOf Concrete y -> DualOf Concrete y Source #

tsum :: forall (z :: TK) (k :: Nat). ConvertTensor Concrete => SNat k -> SingletonTK z -> Concrete (BuildTensorKind k z) -> Concrete z Source #

treplicate :: forall (z :: TK) (k :: Nat). ConvertTensor Concrete => SNat k -> SingletonTK z -> Concrete z -> Concrete (BuildTensorKind k z) Source #

tindexBuild :: forall (z :: TK) (k :: Nat). ConvertTensor Concrete => SNat k -> SingletonTK z -> Concrete (BuildTensorKind k z) -> IntOf Concrete -> Concrete z Source #

treplTarget :: forall (y :: TK). (forall r. GoodScalar r => r) -> FullShapeTK y -> Concrete y Source #

tdefTarget :: forall (y :: TK). FullShapeTK y -> Concrete y Source #

taddTarget :: forall (y :: TK). SingletonTK y -> Concrete y -> Concrete y -> Concrete y Source #

tmultTarget :: forall (y :: TK). SingletonTK y -> Concrete y -> Concrete y -> Concrete y Source #

tsum0Target :: forall (y :: TK). FullShapeTK y -> Concrete y -> Concrete ('TKScalar Double) Source #

tdot0Target :: forall (y :: TK). FullShapeTK y -> Concrete y -> Concrete y -> Concrete ('TKScalar Double) Source #

xmcast :: forall (x :: TK) (sh :: [Maybe Nat]) (sh2 :: [Maybe Nat]). (KnownSTK x, KnownShX sh, Rank sh ~ Rank sh2, ConvertTensor Concrete) => StaticShX sh2 -> Concrete ('TKX2 sh x) -> Concrete ('TKX2 sh2 x) Source #

Methods

ttlet :: forall (x :: TK) (z :: TK). Concrete x -> (Concrete x -> Concrete z) -> Concrete z Source #

ttletPrimal :: forall (x :: TK) (z :: TK). PrimalOf Concrete x -> (PrimalOf Concrete x -> Concrete z) -> Concrete z Source #

toShare :: forall (y :: TK). Concrete y -> ShareOf Concrete y Source #

tunshare :: forall (y :: TK). ShareOf Concrete y -> Concrete y Source #

tappend :: forall (m :: Nat) (n :: Nat) (y :: TK). BaseTensor Concrete => SNat m -> SNat n -> SingletonTK y -> Concrete (BuildTensorKind m y) -> Concrete (BuildTensorKind n y) -> Concrete (BuildTensorKind (m + n) y) Source #

tD :: forall (y :: TK). BaseTensor Concrete => SingletonTK y -> PrimalOf Concrete y -> DualOf Concrete y -> Concrete y Source #

tfold :: forall (yn :: TK) (ym :: TK) (k :: Nat). BaseTensor Concrete => SNat k -> SingletonTK yn -> SingletonTK ym -> (forall (f :: Target). ADReady f => f yn -> f ym -> f yn) -> Concrete yn -> Concrete (BuildTensorKind k ym) -> Concrete yn Source #

tscan :: forall (yn :: TK) (ym :: TK) (k :: Nat). BaseTensor Concrete => SNat k -> SingletonTK yn -> SingletonTK ym -> (forall (f :: Target). ADReady f => f yn -> f ym -> f yn) -> Concrete yn -> Concrete (BuildTensorKind k ym) -> Concrete (BuildTensorKind (1 + k) yn) Source #

Methods

tshare :: forall (y :: TK). Concrete y -> Concrete y Source #

tunpair :: forall (x :: TK) (z :: TK). Concrete ('TKProduct x z) -> (Concrete x, Concrete z) Source #

tunravelToListShare :: forall (y :: TK) (k :: Nat). (BaseTensor Concrete, ConvertTensor Concrete) => SNat k -> SingletonTK y -> Concrete (BuildTensorKind k y) -> [Concrete y] Source #