{-# LANGUAGE AllowAmbiguousTypes, OverloadedLists #-}
{-# OPTIONS_GHC -fplugin GHC.TypeLits.KnownNat.Solver #-}
{-# OPTIONS_GHC -fplugin GHC.TypeLits.Normalise #-}
-- | The tensor operations intended for the casual library user.
--
-- The less user-friendly
-- prototypes of most of these operation can be found in "HordeAd.Core.Ops"
-- where some additional rarely used operations reside.
-- All these operations, together with instances of numerical classes
-- such as @Num@, @Fractional@, @IntegralH@, @RealFloatH@, @EqH@ and others
-- (see class instances of type 'HordeAd.Core.Ast.AstTensor' for the full list),
-- are a major part of the high-level API of the horde-ad library,
-- which is relatively orthogonal to the other major part,
-- the differentiation interface exposed in "HordeAd.ADEngine".
module HordeAd.OpsTensor
  ( -- * Shape manipulation
    rshape, rlength, rsize, rwidth
  , sshape, slength, ssize, swidth
  , xshape, xlength, xsize, xwidth
  , tsize, tftk
    -- * Constructing arrays from concrete values, lists and vectors
  , rconcrete, rscalar, rrepl, ringestData, rfromListLinear
  , sconcrete, sscalar, srepl, singestData, sfromListLinear
  , xconcrete, xscalar, xrepl, xingestData, xfromListLinear
  , kconcrete
  , rfromList, rfromVector, rfromVector0N, rfromList0N, runravelToList
  , sfromList, sfromVector, sfromVector0N, sfromList0N, sunravelToList
  , xfromList, xfromVector, xfromVector0N, xfromList0N, xunravelToList
    -- * Main array operations
  , tunit, tlet, ifH, minH, maxH, tpair, tproject1, tproject2
  , rsum, rsum0, rdot0, rdot1In, rmatvecmul, rmatmul2, rreplicate, rreplicate0N
  , ssum, ssum0, sdot0, sdot1In, smatvecmul, smatmul2, sreplicate, sreplicate0N
  , xsum, xsum0, xdot0, xdot1In, xmatvecmul, xmatmul2, xreplicate, xreplicate0N
  , rindex, (!), rindex0, roneHot, rscatter, rscatter1, rgather, rgather1
  , sindex, (!$), sindex0, soneHot, sscatter, sscatter1, sgather, sgather1
  , xindex, xindex0, xoneHot, xscatter, xscatter1, xgather, xgather1
  , rtr, rtranspose, rflatten, rreshape
  , str, stranspose, sflatten, sreshape
  , xtr, xtranspose, xflatten, xreshape
   -- * Auxiliary array operations
  , rfloor, rfromIntegral, rcast, rminIndex, rmaxIndex, riota
  , sfloor, sfromIntegral, scast, sminIndex, smaxIndex, siota
  , xfloor, xfromIntegral, xcast, xminIndex, xmaxIndex, xiota
  , kfloor, kfromIntegral, kcast
  , rappend, rconcat, rslice, runcons, rreverse
  , sappend, sslice, suncons, sreverse
  , xappend, xappend0, xconcat, xslice, xuncons, xreverse
    -- * Array operations derived from @build@
  , rbuild, rbuild1, rmap, rmap1, rmap0N, rzipWith, rzipWith1, rzipWith0N
  , rzipWith3, rzipWith31, rzipWith30N, rzipWith4, rzipWith41, rzipWith40N
  , sbuild, sbuild1, smap, smap1, smap0N, szipWith, szipWith1, szipWith0N
  , szipWith3, szipWith31, szipWith30N, szipWith4, szipWith41, szipWith40N
  , xbuild, xbuild1
    -- * Array operations derived from @mapAccum@
  , rfold, rscan, sfold, sscan, xfold, xscan, tmapAccumR, tmapAccumL
    -- * Array operations producing derivatives
  , kgrad, rvjp, rjvp, svjp, sjvp
    -- * Operations dealing with dual numbers
  , rprimalPart, rdualPart, rfromPrimal, rfromDual, rScale
  , sprimalPart, sdualPart, sfromPrimal, sfromDual, sScale
  , xprimalPart, xdualPart, xfromPrimal, xfromDual, xScale
  , kprimalPart, kdualPart, kfromPrimal, kfromDual, kScale
    -- * Array operations that utilize unwinding of nested arrays
  , treplTarget, tdefTarget, taddTarget, tmultTarget, tsum0Target, tdot0Target
    -- * Minimal re-exports to make this module a higher level replacement for "HordeAd.Core.Ops"
  , ADReady
  , LetTensor, BaseTensor
  ) where

import Prelude

import Data.Int (Int64)
import Data.List.NonEmpty (NonEmpty)
import Data.List.NonEmpty qualified as NonEmpty
import Data.Proxy (Proxy (Proxy))
import Data.Type.Equality (gcastWith, (:~:))
import Data.Vector.Generic qualified as V
import Data.Vector.Strict qualified as Data.Vector
import GHC.TypeLits
  (KnownNat, OrderingI (..), cmpNat, type (+), type (-), type (<=))

import Data.Array.Nested (type (++))
import Data.Array.Nested qualified as Nested
import Data.Array.Nested.Mixed.Shape
import Data.Array.Nested.Permutation qualified as Permutation
import Data.Array.Nested.Ranked.Shape
import Data.Array.Nested.Shaped.Shape
import Data.Array.Nested.Types (Init, unsafeCoerceRefl)

import HordeAd.Core.CarriersConcrete
import HordeAd.Core.ConvertTensor
import HordeAd.Core.Ops
import HordeAd.Core.TensorKind
import HordeAd.Core.Types

rconcrete :: (GoodScalar r, BaseTensor target)
          => Nested.Ranked n r -> target (TKR n r)
rconcrete :: forall r (target :: Target) (n :: Nat).
(GoodScalar r, BaseTensor target) =>
Ranked n r -> target (TKR n r)
rconcrete = Ranked n r -> target (TKR n r)
forall r (n :: Nat). GoodScalar r => Ranked n r -> target (TKR n r)
forall (target :: Target) r (n :: Nat).
(BaseTensor target, GoodScalar r) =>
Ranked n r -> target (TKR n r)
trconcrete
rscalar :: (GoodScalar r, BaseTensor target)
        => r -> target (TKR 0 r)
rscalar :: forall r (target :: Target).
(GoodScalar r, BaseTensor target) =>
r -> target (TKR 0 r)
rscalar r
r = Ranked 0 r -> target (TKR 0 r)
forall r (target :: Target) (n :: Nat).
(GoodScalar r, BaseTensor target) =>
Ranked n r -> target (TKR n r)
rconcrete (Ranked 0 r -> target (TKR 0 r)) -> Ranked 0 r -> target (TKR 0 r)
forall a b. (a -> b) -> a -> b
$ r -> Ranked 0 r
forall a. Elt a => a -> Ranked 0 a
Nested.rscalar r
r
rrepl :: forall n r target. (GoodScalar r, BaseTensor target)
      => IShR n -> r -> target (TKR n r)
rrepl :: forall (n :: Nat) r (target :: Target).
(GoodScalar r, BaseTensor target) =>
IShR n -> r -> target (TKR n r)
rrepl IShR n
sh r
a = FullShapeTK (TKR n r) -> Concrete (TKR n r) -> target (TKR n r)
forall (y :: TK). FullShapeTK y -> Concrete y -> target y
forall (target :: Target) (y :: TK).
BaseTensor target =>
FullShapeTK y -> Concrete y -> target y
tconcrete (IShR n -> FullShapeTK (TKScalar r) -> FullShapeTK (TKR n r)
forall (n :: Nat) (x :: TK).
IShR n -> FullShapeTK x -> FullShapeTK (TKR2 n x)
FTKR IShR n
sh FullShapeTK (TKScalar r)
forall r. GoodScalar r => FullShapeTK (TKScalar r)
FTKScalar)
                       (RepConcrete (TKR n r) -> Concrete (TKR n r)
forall (y :: TK). RepConcrete y -> Concrete y
Concrete (RepConcrete (TKR n r) -> Concrete (TKR n r))
-> RepConcrete (TKR n r) -> Concrete (TKR n r)
forall a b. (a -> b) -> a -> b
$ IShR n -> r -> Ranked n r
forall (n :: Nat) a. PrimElt a => IShR n -> a -> Ranked n a
Nested.rreplicateScal IShR n
sh r
a)
ringestData :: forall n r target. (GoodScalar r, BaseTensor target)
            => IShR n -> [r] -> target (TKR n r)
ringestData :: forall (n :: Nat) r (target :: Target).
(GoodScalar r, BaseTensor target) =>
IShR n -> [r] -> target (TKR n r)
ringestData IShR n
sh [r]
l =
  FullShapeTK (TKR n r) -> Concrete (TKR n r) -> target (TKR n r)
forall (y :: TK). FullShapeTK y -> Concrete y -> target y
forall (target :: Target) (y :: TK).
BaseTensor target =>
FullShapeTK y -> Concrete y -> target y
tconcrete (IShR n -> FullShapeTK (TKScalar r) -> FullShapeTK (TKR n r)
forall (n :: Nat) (x :: TK).
IShR n -> FullShapeTK x -> FullShapeTK (TKR2 n x)
FTKR IShR n
sh FullShapeTK (TKScalar r)
forall r. GoodScalar r => FullShapeTK (TKScalar r)
FTKScalar) (RepConcrete (TKR n r) -> Concrete (TKR n r)
forall (y :: TK). RepConcrete y -> Concrete y
Concrete (RepConcrete (TKR n r) -> Concrete (TKR n r))
-> RepConcrete (TKR n r) -> Concrete (TKR n r)
forall a b. (a -> b) -> a -> b
$ IShR n -> [r] -> Ranked n r
forall a (n :: Nat). PrimElt a => IShR n -> [a] -> Ranked n a
Nested.rfromListPrimLinear IShR n
sh [r]
l)
-- | Create a tensor from a list of individual underlying scalar values.
--
-- An operation with the same name is used in @ox-arrays@ to represent
-- pretty-printed concrete arrays. The types agree, so the same representation
-- results in analogous horde-ad array when this operation is used instead.
rfromListLinear :: forall n r target. (GoodScalar r, BaseTensor target)
                => IShR n -> NonEmpty r -> target (TKR n r)
rfromListLinear :: forall (n :: Nat) r (target :: Target).
(GoodScalar r, BaseTensor target) =>
IShR n -> NonEmpty r -> target (TKR n r)
rfromListLinear IShR n
sh = IShR n -> [r] -> target (TKR n r)
forall (n :: Nat) r (target :: Target).
(GoodScalar r, BaseTensor target) =>
IShR n -> [r] -> target (TKR n r)
ringestData IShR n
sh ([r] -> target (TKR n r))
-> (NonEmpty r -> [r]) -> NonEmpty r -> target (TKR n r)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty r -> [r]
forall a. NonEmpty a -> [a]
NonEmpty.toList

sconcrete :: (GoodScalar r, BaseTensor target)
          => Nested.Shaped sh r -> target (TKS sh r)
sconcrete :: forall r (target :: Target) (sh :: [Nat]).
(GoodScalar r, BaseTensor target) =>
Shaped sh r -> target (TKS sh r)
sconcrete = Shaped sh r -> target (TKS sh r)
forall r (sh :: [Nat]).
GoodScalar r =>
Shaped sh r -> target (TKS sh r)
forall (target :: Target) r (sh :: [Nat]).
(BaseTensor target, GoodScalar r) =>
Shaped sh r -> target (TKS sh r)
tsconcrete
sscalar :: (GoodScalar r, BaseTensor target)
        => r -> target (TKS '[] r)
sscalar :: forall r (target :: Target).
(GoodScalar r, BaseTensor target) =>
r -> target (TKS ('[] @Nat) r)
sscalar r
r = Shaped ('[] @Nat) r -> target (TKS ('[] @Nat) r)
forall r (target :: Target) (sh :: [Nat]).
(GoodScalar r, BaseTensor target) =>
Shaped sh r -> target (TKS sh r)
sconcrete (Shaped ('[] @Nat) r -> target (TKS ('[] @Nat) r))
-> Shaped ('[] @Nat) r -> target (TKS ('[] @Nat) r)
forall a b. (a -> b) -> a -> b
$ r -> Shaped ('[] @Nat) r
forall a. Elt a => a -> Shaped ('[] @Nat) a
Nested.sscalar r
r
srepl :: (KnownShS sh, GoodScalar r, BaseTensor target)
      => r -> target (TKS sh r)
srepl :: forall (sh :: [Nat]) r (target :: Target).
(KnownShS sh, GoodScalar r, BaseTensor target) =>
r -> target (TKS sh r)
srepl = Shaped sh r -> target (TKS sh r)
forall r (target :: Target) (sh :: [Nat]).
(GoodScalar r, BaseTensor target) =>
Shaped sh r -> target (TKS sh r)
sconcrete (Shaped sh r -> target (TKS sh r))
-> (r -> Shaped sh r) -> r -> target (TKS sh r)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ShS sh -> r -> Shaped sh r
forall a (sh :: [Nat]). PrimElt a => ShS sh -> a -> Shaped sh a
Nested.sreplicateScal ShS sh
forall (sh :: [Nat]). KnownShS sh => ShS sh
knownShS
singestData :: (KnownShS sh, GoodScalar r, BaseTensor target)
            => [r] -> target (TKS sh r)
singestData :: forall (sh :: [Nat]) r (target :: Target).
(KnownShS sh, GoodScalar r, BaseTensor target) =>
[r] -> target (TKS sh r)
singestData [r]
l = Shaped sh r -> target (TKS sh r)
forall r (target :: Target) (sh :: [Nat]).
(GoodScalar r, BaseTensor target) =>
Shaped sh r -> target (TKS sh r)
sconcrete (Shaped sh r -> target (TKS sh r))
-> Shaped sh r -> target (TKS sh r)
forall a b. (a -> b) -> a -> b
$ ShS sh -> [r] -> Shaped sh r
forall a (sh :: [Nat]). PrimElt a => ShS sh -> [a] -> Shaped sh a
Nested.sfromListPrimLinear ShS sh
forall (sh :: [Nat]). KnownShS sh => ShS sh
knownShS [r]
l
-- | Create a tensor from a list of individual underlying scalar values.
--
-- An operation with the same name is used in @ox-arrays@ to represent
-- pretty-printed concrete arrays. The types agree, so the same representation
-- results in analogous horde-ad array when this operation is used instead.
sfromListLinear :: forall sh r target. (GoodScalar r, BaseTensor target)
                => ShS sh -> NonEmpty r -> target (TKS sh r)
sfromListLinear :: forall (sh :: [Nat]) r (target :: Target).
(GoodScalar r, BaseTensor target) =>
ShS sh -> NonEmpty r -> target (TKS sh r)
sfromListLinear ShS sh
sh = Shaped sh r -> target (TKS sh r)
forall r (target :: Target) (sh :: [Nat]).
(GoodScalar r, BaseTensor target) =>
Shaped sh r -> target (TKS sh r)
sconcrete (Shaped sh r -> target (TKS sh r))
-> (NonEmpty r -> Shaped sh r) -> NonEmpty r -> target (TKS sh r)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ShS sh -> [r] -> Shaped sh r
forall a (sh :: [Nat]). PrimElt a => ShS sh -> [a] -> Shaped sh a
Nested.sfromListPrimLinear ShS sh
sh ([r] -> Shaped sh r)
-> (NonEmpty r -> [r]) -> NonEmpty r -> Shaped sh r
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty r -> [r]
forall a. NonEmpty a -> [a]
NonEmpty.toList

xconcrete :: (GoodScalar r, BaseTensor target)
          => Nested.Mixed sh r -> target (TKX sh r)
xconcrete :: forall r (target :: Target) (sh :: [Maybe Nat]).
(GoodScalar r, BaseTensor target) =>
Mixed sh r -> target (TKX sh r)
xconcrete = Mixed sh r -> target (TKX sh r)
forall r (sh :: [Maybe Nat]).
GoodScalar r =>
Mixed sh r -> target (TKX sh r)
forall (target :: Target) r (sh :: [Maybe Nat]).
(BaseTensor target, GoodScalar r) =>
Mixed sh r -> target (TKX sh r)
txconcrete
xscalar :: (GoodScalar r, BaseTensor target)
        => r -> target (TKX '[] r)
xscalar :: forall r (target :: Target).
(GoodScalar r, BaseTensor target) =>
r -> target (TKX ('[] @(Maybe Nat)) r)
xscalar r
r = Mixed ('[] @(Maybe Nat)) r -> target (TKX ('[] @(Maybe Nat)) r)
forall r (target :: Target) (sh :: [Maybe Nat]).
(GoodScalar r, BaseTensor target) =>
Mixed sh r -> target (TKX sh r)
xconcrete (Mixed ('[] @(Maybe Nat)) r -> target (TKX ('[] @(Maybe Nat)) r))
-> Mixed ('[] @(Maybe Nat)) r -> target (TKX ('[] @(Maybe Nat)) r)
forall a b. (a -> b) -> a -> b
$ r -> Mixed ('[] @(Maybe Nat)) r
forall a. Elt a => a -> Mixed ('[] @(Maybe Nat)) a
Nested.mscalar r
r
xrepl :: forall sh r target. (GoodScalar r, BaseTensor target)
      => IShX sh -> r -> target (TKX sh r)
xrepl :: forall (sh :: [Maybe Nat]) r (target :: Target).
(GoodScalar r, BaseTensor target) =>
IShX sh -> r -> target (TKX sh r)
xrepl IShX sh
sh r
a = FullShapeTK (TKX sh r) -> Concrete (TKX sh r) -> target (TKX sh r)
forall (y :: TK). FullShapeTK y -> Concrete y -> target y
forall (target :: Target) (y :: TK).
BaseTensor target =>
FullShapeTK y -> Concrete y -> target y
tconcrete (IShX sh -> FullShapeTK (TKScalar r) -> FullShapeTK (TKX sh r)
forall (sh :: [Maybe Nat]) (x :: TK).
IShX sh -> FullShapeTK x -> FullShapeTK (TKX2 sh x)
FTKX IShX sh
sh FullShapeTK (TKScalar r)
forall r. GoodScalar r => FullShapeTK (TKScalar r)
FTKScalar)
                       (RepConcrete (TKX sh r) -> Concrete (TKX sh r)
forall (y :: TK). RepConcrete y -> Concrete y
Concrete (RepConcrete (TKX sh r) -> Concrete (TKX sh r))
-> RepConcrete (TKX sh r) -> Concrete (TKX sh r)
forall a b. (a -> b) -> a -> b
$ IShX sh -> r -> Mixed sh r
forall (sh :: [Maybe Nat]) a.
PrimElt a =>
IShX sh -> a -> Mixed sh a
Nested.mreplicateScal IShX sh
sh r
a)
xingestData :: forall sh r target. (GoodScalar r, BaseTensor target)
            => IShX sh -> [r] -> target (TKX sh r)
xingestData :: forall (sh :: [Maybe Nat]) r (target :: Target).
(GoodScalar r, BaseTensor target) =>
IShX sh -> [r] -> target (TKX sh r)
xingestData IShX sh
sh [r]
l =
  FullShapeTK (TKX sh r) -> Concrete (TKX sh r) -> target (TKX sh r)
forall (y :: TK). FullShapeTK y -> Concrete y -> target y
forall (target :: Target) (y :: TK).
BaseTensor target =>
FullShapeTK y -> Concrete y -> target y
tconcrete (IShX sh -> FullShapeTK (TKScalar r) -> FullShapeTK (TKX sh r)
forall (sh :: [Maybe Nat]) (x :: TK).
IShX sh -> FullShapeTK x -> FullShapeTK (TKX2 sh x)
FTKX IShX sh
sh FullShapeTK (TKScalar r)
forall r. GoodScalar r => FullShapeTK (TKScalar r)
FTKScalar) (RepConcrete (TKX sh r) -> Concrete (TKX sh r)
forall (y :: TK). RepConcrete y -> Concrete y
Concrete (RepConcrete (TKX sh r) -> Concrete (TKX sh r))
-> RepConcrete (TKX sh r) -> Concrete (TKX sh r)
forall a b. (a -> b) -> a -> b
$ IShX sh -> [r] -> Mixed sh r
forall a (sh :: [Maybe Nat]).
PrimElt a =>
IShX sh -> [a] -> Mixed sh a
Nested.mfromListPrimLinear IShX sh
sh [r]
l)
xfromListLinear :: forall sh r target. (GoodScalar r, BaseTensor target)
                => IShX sh -> NonEmpty r -> target (TKX sh r)
xfromListLinear :: forall (sh :: [Maybe Nat]) r (target :: Target).
(GoodScalar r, BaseTensor target) =>
IShX sh -> NonEmpty r -> target (TKX sh r)
xfromListLinear IShX sh
sh = IShX sh -> [r] -> target (TKX sh r)
forall (sh :: [Maybe Nat]) r (target :: Target).
(GoodScalar r, BaseTensor target) =>
IShX sh -> [r] -> target (TKX sh r)
xingestData IShX sh
sh ([r] -> target (TKX sh r))
-> (NonEmpty r -> [r]) -> NonEmpty r -> target (TKX sh r)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty r -> [r]
forall a. NonEmpty a -> [a]
NonEmpty.toList

kconcrete :: (GoodScalar r, BaseTensor target)
          => r -> target (TKScalar r)
kconcrete :: forall r (target :: Target).
(GoodScalar r, BaseTensor target) =>
r -> target (TKScalar r)
kconcrete = r -> target (TKScalar r)
forall r. GoodScalar r => r -> target (TKScalar r)
forall (target :: Target) r.
(BaseTensor target, GoodScalar r) =>
r -> target (TKScalar r)
tkconcrete

-- | Create a tensor from a list treated as the outermost dimension,
-- going through strict boxed vectors, because laziness is risky with
-- impurity, e.g., it easily perturbs results of fragile tests.
rfromList :: (KnownNat n, KnownSTK x, BaseTensor target)
          => NonEmpty (target (TKR2 n x)) -> target (TKR2 (1 + n) x)
rfromList :: forall (n :: Nat) (x :: TK) (target :: Target).
(KnownNat n, KnownSTK x, BaseTensor target) =>
NonEmpty (target (TKR2 n x)) -> target (TKR2 (1 + n) x)
rfromList = Vector (target (TKR2 n x)) -> target (TKR2 (1 + n) x)
forall (n :: Nat) (x :: TK).
(KnownNat n, KnownSTK x) =>
Vector (target (TKR2 n x)) -> target (TKR2 (1 + n) x)
forall (target :: Target) (n :: Nat) (x :: TK).
(BaseTensor target, KnownNat n, KnownSTK x) =>
Vector (target (TKR2 n x)) -> target (TKR2 (1 + n) x)
trfromVector (Vector (target (TKR2 n x)) -> target (TKR2 (1 + n) x))
-> (NonEmpty (target (TKR2 n x)) -> Vector (target (TKR2 n x)))
-> NonEmpty (target (TKR2 n x))
-> target (TKR2 (1 + n) x)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [target (TKR2 n x)] -> Vector (target (TKR2 n x))
forall (v :: Type -> Type) a. Vector v a => [a] -> v a
V.fromList ([target (TKR2 n x)] -> Vector (target (TKR2 n x)))
-> (NonEmpty (target (TKR2 n x)) -> [target (TKR2 n x)])
-> NonEmpty (target (TKR2 n x))
-> Vector (target (TKR2 n x))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty (target (TKR2 n x)) -> [target (TKR2 n x)]
forall a. NonEmpty a -> [a]
NonEmpty.toList
-- | Create a tensor from a non-empty strict boxed vector treated
-- as the outermost dimension.
rfromVector :: (KnownNat n, KnownSTK x, BaseTensor target)
            => Data.Vector.Vector (target (TKR2 n x))
            -> target (TKR2 (1 + n) x)
rfromVector :: forall (n :: Nat) (x :: TK) (target :: Target).
(KnownNat n, KnownSTK x, BaseTensor target) =>
Vector (target (TKR2 n x)) -> target (TKR2 (1 + n) x)
rfromVector = Vector (target (TKR2 n x)) -> target (TKR2 (1 + n) x)
forall (n :: Nat) (x :: TK).
(KnownNat n, KnownSTK x) =>
Vector (target (TKR2 n x)) -> target (TKR2 (1 + n) x)
forall (target :: Target) (n :: Nat) (x :: TK).
(BaseTensor target, KnownNat n, KnownSTK x) =>
Vector (target (TKR2 n x)) -> target (TKR2 (1 + n) x)
trfromVector
rfromVector0N :: forall n x target. (KnownSTK x, BaseTensor target)
              => IShR n -> Data.Vector.Vector (target (TKR2 0 x))
              -> target (TKR2 n x)
rfromVector0N :: forall (n :: Nat) (x :: TK) (target :: Target).
(KnownSTK x, BaseTensor target) =>
IShR n -> Vector (target (TKR2 0 x)) -> target (TKR2 n x)
rfromVector0N = IShR n -> Vector (target (TKR2 0 x)) -> target (TKR2 n x)
forall (n :: Nat) (x :: TK).
KnownSTK x =>
IShR n -> Vector (target (TKR2 0 x)) -> target (TKR2 n x)
forall (target :: Target) (n :: Nat) (x :: TK).
(BaseTensor target, KnownSTK x) =>
IShR n -> Vector (target (TKR2 0 x)) -> target (TKR2 n x)
trfromVector0N
rfromList0N :: forall n x target. (KnownSTK x, BaseTensor target)
            => IShR n -> [target (TKR2 0 x)]
            -> target (TKR2 n x)
rfromList0N :: forall (n :: Nat) (x :: TK) (target :: Target).
(KnownSTK x, BaseTensor target) =>
IShR n -> [target (TKR2 0 x)] -> target (TKR2 n x)
rfromList0N IShR n
sh = IShR n -> Vector (target (TKR2 0 x)) -> target (TKR2 n x)
forall (n :: Nat) (x :: TK).
KnownSTK x =>
IShR n -> Vector (target (TKR2 0 x)) -> target (TKR2 n x)
forall (target :: Target) (n :: Nat) (x :: TK).
(BaseTensor target, KnownSTK x) =>
IShR n -> Vector (target (TKR2 0 x)) -> target (TKR2 n x)
trfromVector0N IShR n
sh (Vector (target (TKR2 0 x)) -> target (TKR2 n x))
-> ([target (TKR2 0 x)] -> Vector (target (TKR2 0 x)))
-> [target (TKR2 0 x)]
-> target (TKR2 n x)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [target (TKR2 0 x)] -> Vector (target (TKR2 0 x))
forall (v :: Type -> Type) a. Vector v a => [a] -> v a
V.fromList
-- | Unravel a tensor into a list of its immediate subtensors.
--
-- Warning: during computation, sharing between the elements
-- of the resulting list is likely to be lost, so it needs to be ensured
-- by explicit sharing, e.g., 'ttlet'.
runravelToList :: forall n x target.
                  (KnownSTK x, KnownNat n, BaseTensor target)
               => target (TKR2 (1 + n) x) -> [target (TKR2 n x)]
runravelToList :: forall (n :: Nat) (x :: TK) (target :: Target).
(KnownSTK x, KnownNat n, BaseTensor target) =>
target (TKR2 (1 + n) x) -> [target (TKR2 n x)]
runravelToList = target (TKR2 (1 + n) x) -> [target (TKR2 n x)]
forall (n :: Nat) (x :: TK).
(KnownNat n, KnownSTK x) =>
target (TKR2 (1 + n) x) -> [target (TKR2 n x)]
forall (target :: Target) (n :: Nat) (x :: TK).
(BaseTensor target, KnownNat n, KnownSTK x) =>
target (TKR2 (1 + n) x) -> [target (TKR2 n x)]
trunravelToList

-- | Create a tensor from a list treated as the outermost dimension,
-- going through strict boxed vectors, because laziness is risky with
-- impurity, e.g., it easily perturbs results of fragile tests.
sfromList :: (KnownNat n, KnownShS sh, KnownSTK x, BaseTensor target)
          => NonEmpty (target (TKS2 sh x)) -> target (TKS2 (n ': sh) x)
sfromList :: forall (n :: Nat) (sh :: [Nat]) (x :: TK) (target :: Target).
(KnownNat n, KnownShS sh, KnownSTK x, BaseTensor target) =>
NonEmpty (target (TKS2 sh x)) -> target (TKS2 ((':) @Nat n sh) x)
sfromList = Vector (target (TKS2 sh x)) -> target (TKS2 ((':) @Nat n sh) x)
forall (n :: Nat) (sh :: [Nat]) (x :: TK).
(KnownNat n, KnownShS sh, KnownSTK x) =>
Vector (target (TKS2 sh x)) -> target (TKS2 ((':) @Nat n sh) x)
forall (target :: Target) (n :: Nat) (sh :: [Nat]) (x :: TK).
(BaseTensor target, KnownNat n, KnownShS sh, KnownSTK x) =>
Vector (target (TKS2 sh x)) -> target (TKS2 ((':) @Nat n sh) x)
tsfromVector (Vector (target (TKS2 sh x)) -> target (TKS2 ((':) @Nat n sh) x))
-> (NonEmpty (target (TKS2 sh x)) -> Vector (target (TKS2 sh x)))
-> NonEmpty (target (TKS2 sh x))
-> target (TKS2 ((':) @Nat n sh) x)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [target (TKS2 sh x)] -> Vector (target (TKS2 sh x))
forall (v :: Type -> Type) a. Vector v a => [a] -> v a
V.fromList ([target (TKS2 sh x)] -> Vector (target (TKS2 sh x)))
-> (NonEmpty (target (TKS2 sh x)) -> [target (TKS2 sh x)])
-> NonEmpty (target (TKS2 sh x))
-> Vector (target (TKS2 sh x))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty (target (TKS2 sh x)) -> [target (TKS2 sh x)]
forall a. NonEmpty a -> [a]
NonEmpty.toList
-- | Create a tensor from a non-empty strict boxed vector treated
-- as the outermost dimension.
sfromVector :: (KnownNat n, KnownShS sh, KnownSTK x, BaseTensor target)
            => Data.Vector.Vector (target (TKS2 sh x))
            -> target (TKS2 (n ': sh) x)
sfromVector :: forall (n :: Nat) (sh :: [Nat]) (x :: TK) (target :: Target).
(KnownNat n, KnownShS sh, KnownSTK x, BaseTensor target) =>
Vector (target (TKS2 sh x)) -> target (TKS2 ((':) @Nat n sh) x)
sfromVector = Vector (target (TKS2 sh x)) -> target (TKS2 ((':) @Nat n sh) x)
forall (n :: Nat) (sh :: [Nat]) (x :: TK).
(KnownNat n, KnownShS sh, KnownSTK x) =>
Vector (target (TKS2 sh x)) -> target (TKS2 ((':) @Nat n sh) x)
forall (target :: Target) (n :: Nat) (sh :: [Nat]) (x :: TK).
(BaseTensor target, KnownNat n, KnownShS sh, KnownSTK x) =>
Vector (target (TKS2 sh x)) -> target (TKS2 ((':) @Nat n sh) x)
tsfromVector
sfromVector0N :: (KnownShS sh, KnownSTK x, BaseTensor target)
              => Data.Vector.Vector (target (TKS2 '[] x))
              -> target (TKS2 sh x)
sfromVector0N :: forall (sh :: [Nat]) (x :: TK) (target :: Target).
(KnownShS sh, KnownSTK x, BaseTensor target) =>
Vector (target (TKS2 ('[] @Nat) x)) -> target (TKS2 sh x)
sfromVector0N = Vector (target (TKS2 ('[] @Nat) x)) -> target (TKS2 sh x)
forall (sh :: [Nat]) (x :: TK).
(KnownShS sh, KnownSTK x) =>
Vector (target (TKS2 ('[] @Nat) x)) -> target (TKS2 sh x)
forall (target :: Target) (sh :: [Nat]) (x :: TK).
(BaseTensor target, KnownShS sh, KnownSTK x) =>
Vector (target (TKS2 ('[] @Nat) x)) -> target (TKS2 sh x)
tsfromVector0N
sfromList0N :: (KnownShS sh, KnownSTK x, BaseTensor target)
            => [target (TKS2 '[] x)]
            -> target (TKS2 sh x)
sfromList0N :: forall (sh :: [Nat]) (x :: TK) (target :: Target).
(KnownShS sh, KnownSTK x, BaseTensor target) =>
[target (TKS2 ('[] @Nat) x)] -> target (TKS2 sh x)
sfromList0N = Vector (target (TKS2 ('[] @Nat) x)) -> target (TKS2 sh x)
forall (sh :: [Nat]) (x :: TK).
(KnownShS sh, KnownSTK x) =>
Vector (target (TKS2 ('[] @Nat) x)) -> target (TKS2 sh x)
forall (target :: Target) (sh :: [Nat]) (x :: TK).
(BaseTensor target, KnownShS sh, KnownSTK x) =>
Vector (target (TKS2 ('[] @Nat) x)) -> target (TKS2 sh x)
tsfromVector0N (Vector (target (TKS2 ('[] @Nat) x)) -> target (TKS2 sh x))
-> ([target (TKS2 ('[] @Nat) x)]
    -> Vector (target (TKS2 ('[] @Nat) x)))
-> [target (TKS2 ('[] @Nat) x)]
-> target (TKS2 sh x)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [target (TKS2 ('[] @Nat) x)] -> Vector (target (TKS2 ('[] @Nat) x))
forall (v :: Type -> Type) a. Vector v a => [a] -> v a
V.fromList
-- | Unravel a tensor into a list of its immediate subtensors.
--
-- Warning: during computation, sharing between the elements
-- of the resulting list is likely to be lost, so it needs to be ensured
-- by explicit sharing, e.g., 'ttlet'.
sunravelToList :: (KnownNat n, KnownShS sh, KnownSTK x, BaseTensor target)
               => target (TKS2 (n ': sh) x) -> [target (TKS2 sh x)]
sunravelToList :: forall (n :: Nat) (sh :: [Nat]) (x :: TK) (target :: Target).
(KnownNat n, KnownShS sh, KnownSTK x, BaseTensor target) =>
target (TKS2 ((':) @Nat n sh) x) -> [target (TKS2 sh x)]
sunravelToList = target (TKS2 ((':) @Nat n sh) x) -> [target (TKS2 sh x)]
forall (n :: Nat) (sh :: [Nat]) (x :: TK).
(KnownNat n, KnownShS sh, KnownSTK x) =>
target (TKS2 ((':) @Nat n sh) x) -> [target (TKS2 sh x)]
forall (target :: Target) (n :: Nat) (sh :: [Nat]) (x :: TK).
(BaseTensor target, KnownNat n, KnownShS sh, KnownSTK x) =>
target (TKS2 ((':) @Nat n sh) x) -> [target (TKS2 sh x)]
tsunravelToList

-- | Create a tensor from a list treated as the outermost dimension,
-- going through strict boxed vectors, because laziness is risky with
-- impurity, e.g., it easily perturbs results of fragile tests.
xfromList :: (KnownNat n, KnownShX sh, KnownSTK x, BaseTensor target)
          => NonEmpty (target (TKX2 sh x)) -> target (TKX2 (Just n ': sh) x)
xfromList :: forall (n :: Nat) (sh :: [Maybe Nat]) (x :: TK) (target :: Target).
(KnownNat n, KnownShX sh, KnownSTK x, BaseTensor target) =>
NonEmpty (target (TKX2 sh x))
-> target (TKX2 ((':) @(Maybe Nat) ('Just @Nat n) sh) x)
xfromList = Vector (target (TKX2 sh x))
-> target (TKX2 ((':) @(Maybe Nat) ('Just @Nat n) sh) x)
forall (n :: Nat) (sh :: [Maybe Nat]) (x :: TK).
(KnownNat n, KnownShX sh, KnownSTK x) =>
Vector (target (TKX2 sh x))
-> target (TKX2 ((':) @(Maybe Nat) ('Just @Nat n) sh) x)
forall (target :: Target) (n :: Nat) (sh :: [Maybe Nat]) (x :: TK).
(BaseTensor target, KnownNat n, KnownShX sh, KnownSTK x) =>
Vector (target (TKX2 sh x))
-> target (TKX2 ((':) @(Maybe Nat) ('Just @Nat n) sh) x)
txfromVector (Vector (target (TKX2 sh x))
 -> target (TKX2 ((':) @(Maybe Nat) ('Just @Nat n) sh) x))
-> (NonEmpty (target (TKX2 sh x)) -> Vector (target (TKX2 sh x)))
-> NonEmpty (target (TKX2 sh x))
-> target (TKX2 ((':) @(Maybe Nat) ('Just @Nat n) sh) x)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [target (TKX2 sh x)] -> Vector (target (TKX2 sh x))
forall (v :: Type -> Type) a. Vector v a => [a] -> v a
V.fromList ([target (TKX2 sh x)] -> Vector (target (TKX2 sh x)))
-> (NonEmpty (target (TKX2 sh x)) -> [target (TKX2 sh x)])
-> NonEmpty (target (TKX2 sh x))
-> Vector (target (TKX2 sh x))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty (target (TKX2 sh x)) -> [target (TKX2 sh x)]
forall a. NonEmpty a -> [a]
NonEmpty.toList
-- | Create a tensor from a non-empty strict boxed vector treated
-- as the outermost dimension.
xfromVector :: (KnownNat n, KnownShX sh, KnownSTK x, BaseTensor target)
            => Data.Vector.Vector (target (TKX2 sh x))
            -> target (TKX2 (Just n ': sh) x)
xfromVector :: forall (n :: Nat) (sh :: [Maybe Nat]) (x :: TK) (target :: Target).
(KnownNat n, KnownShX sh, KnownSTK x, BaseTensor target) =>
Vector (target (TKX2 sh x))
-> target (TKX2 ((':) @(Maybe Nat) ('Just @Nat n) sh) x)
xfromVector = Vector (target (TKX2 sh x))
-> target (TKX2 ((':) @(Maybe Nat) ('Just @Nat n) sh) x)
forall (n :: Nat) (sh :: [Maybe Nat]) (x :: TK).
(KnownNat n, KnownShX sh, KnownSTK x) =>
Vector (target (TKX2 sh x))
-> target (TKX2 ((':) @(Maybe Nat) ('Just @Nat n) sh) x)
forall (target :: Target) (n :: Nat) (sh :: [Maybe Nat]) (x :: TK).
(BaseTensor target, KnownNat n, KnownShX sh, KnownSTK x) =>
Vector (target (TKX2 sh x))
-> target (TKX2 ((':) @(Maybe Nat) ('Just @Nat n) sh) x)
txfromVector
xfromVector0N :: forall sh x target. (KnownSTK x, BaseTensor target)
              => IShX sh -> Data.Vector.Vector (target (TKX2 '[] x))
              -> target (TKX2 sh x)
xfromVector0N :: forall (sh :: [Maybe Nat]) (x :: TK) (target :: Target).
(KnownSTK x, BaseTensor target) =>
IShX sh
-> Vector (target (TKX2 ('[] @(Maybe Nat)) x))
-> target (TKX2 sh x)
xfromVector0N = IShX sh
-> Vector (target (TKX2 ('[] @(Maybe Nat)) x))
-> target (TKX2 sh x)
forall (sh :: [Maybe Nat]) (x :: TK).
KnownSTK x =>
IShX sh
-> Vector (target (TKX2 ('[] @(Maybe Nat)) x))
-> target (TKX2 sh x)
forall (target :: Target) (sh :: [Maybe Nat]) (x :: TK).
(BaseTensor target, KnownSTK x) =>
IShX sh
-> Vector (target (TKX2 ('[] @(Maybe Nat)) x))
-> target (TKX2 sh x)
txfromVector0N
xfromList0N :: forall sh x target. (KnownSTK x, BaseTensor target)
            => IShX sh -> [target (TKX2 '[] x)]
            -> target (TKX2 sh x)
xfromList0N :: forall (sh :: [Maybe Nat]) (x :: TK) (target :: Target).
(KnownSTK x, BaseTensor target) =>
IShX sh
-> [target (TKX2 ('[] @(Maybe Nat)) x)] -> target (TKX2 sh x)
xfromList0N IShX sh
sh = IShX sh
-> Vector (target (TKX2 ('[] @(Maybe Nat)) x))
-> target (TKX2 sh x)
forall (sh :: [Maybe Nat]) (x :: TK).
KnownSTK x =>
IShX sh
-> Vector (target (TKX2 ('[] @(Maybe Nat)) x))
-> target (TKX2 sh x)
forall (target :: Target) (sh :: [Maybe Nat]) (x :: TK).
(BaseTensor target, KnownSTK x) =>
IShX sh
-> Vector (target (TKX2 ('[] @(Maybe Nat)) x))
-> target (TKX2 sh x)
txfromVector0N IShX sh
sh (Vector (target (TKX2 ('[] @(Maybe Nat)) x)) -> target (TKX2 sh x))
-> ([target (TKX2 ('[] @(Maybe Nat)) x)]
    -> Vector (target (TKX2 ('[] @(Maybe Nat)) x)))
-> [target (TKX2 ('[] @(Maybe Nat)) x)]
-> target (TKX2 sh x)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [target (TKX2 ('[] @(Maybe Nat)) x)]
-> Vector (target (TKX2 ('[] @(Maybe Nat)) x))
forall (v :: Type -> Type) a. Vector v a => [a] -> v a
V.fromList
-- | Unravel a tensor into a list of its immediate subtensors.
--
-- Warning: during computation, sharing between the elements
-- of the resulting list is likely to be lost, so it needs to be ensured
-- by explicit sharing, e.g., 'ttlet'.
xunravelToList :: (KnownNat n, KnownShX sh, KnownSTK x, BaseTensor target)
               => target (TKX2 (Just n ': sh) x) -> [target (TKX2 sh x)]
xunravelToList :: forall (n :: Nat) (sh :: [Maybe Nat]) (x :: TK) (target :: Target).
(KnownNat n, KnownShX sh, KnownSTK x, BaseTensor target) =>
target (TKX2 ((':) @(Maybe Nat) ('Just @Nat n) sh) x)
-> [target (TKX2 sh x)]
xunravelToList = target (TKX2 ((':) @(Maybe Nat) ('Just @Nat n) sh) x)
-> [target (TKX2 sh x)]
forall (n :: Nat) (sh :: [Maybe Nat]) (x :: TK).
(KnownNat n, KnownShX sh, KnownSTK x) =>
target (TKX2 ((':) @(Maybe Nat) ('Just @Nat n) sh) x)
-> [target (TKX2 sh x)]
forall (target :: Target) (n :: Nat) (sh :: [Maybe Nat]) (x :: TK).
(BaseTensor target, KnownNat n, KnownShX sh, KnownSTK x) =>
target (TKX2 ((':) @(Maybe Nat) ('Just @Nat n) sh) x)
-> [target (TKX2 sh x)]
txunravelToList

tunit :: BaseTensor target
      => target TKUnit
tunit :: forall (target :: Target). BaseTensor target => target TKUnit
tunit = Z1 -> target TKUnit
forall r (target :: Target).
(GoodScalar r, BaseTensor target) =>
r -> target (TKScalar r)
kconcrete Z1
Z1

tlet :: forall x z target. LetTensor target
     => target x -> (target x -> target z) -> target z
tlet :: forall (x :: TK) (z :: TK) (target :: Target).
LetTensor target =>
target x -> (target x -> target z) -> target z
tlet = target x -> (target x -> target z) -> target z
forall (x :: TK) (z :: TK).
target x -> (target x -> target z) -> target z
forall (target :: Target) (x :: TK) (z :: TK).
LetTensor target =>
target x -> (target x -> target z) -> target z
ttlet

-- | The operation is potentially strict in all arguments.
ifH :: (KnownSTK y, Boolean (BoolOf target), BaseTensor target)
    => BoolOf target -> target y -> target y -> target y
ifH :: forall (y :: TK) (target :: Target).
(KnownSTK y, Boolean (BoolOf target), BaseTensor target) =>
BoolOf target -> target y -> target y -> target y
ifH = SingletonTK y -> BoolOf target -> target y -> target y -> target y
forall (y :: TK).
Boolean (BoolOf target) =>
SingletonTK y -> BoolOf target -> target y -> target y -> target y
forall (target :: Target) (y :: TK).
(BaseTensor target, Boolean (BoolOf target)) =>
SingletonTK y -> BoolOf target -> target y -> target y -> target y
tcond SingletonTK y
forall (y :: TK). KnownSTK y => SingletonTK y
knownSTK
minH :: (KnownSTK y, OrdH target y, BaseTensor target)
     => target y -> target y -> target y
minH :: forall (y :: TK) (target :: Target).
(KnownSTK y, OrdH target y, BaseTensor target) =>
target y -> target y -> target y
minH target y
u target y
v = BoolOf target -> target y -> target y -> target y
forall (y :: TK) (target :: Target).
(KnownSTK y, Boolean (BoolOf target), BaseTensor target) =>
BoolOf target -> target y -> target y -> target y
ifH (target y
u target y -> target y -> BoolOf target
forall (f :: Target) (y :: TK). OrdH f y => f y -> f y -> BoolOf f
<=. target y
v) target y
u target y
v
maxH :: (KnownSTK y, OrdH target y, BaseTensor target)
     => target y -> target y -> target y
maxH :: forall (y :: TK) (target :: Target).
(KnownSTK y, OrdH target y, BaseTensor target) =>
target y -> target y -> target y
maxH target y
u target y
v = BoolOf target -> target y -> target y -> target y
forall (y :: TK) (target :: Target).
(KnownSTK y, Boolean (BoolOf target), BaseTensor target) =>
BoolOf target -> target y -> target y -> target y
ifH (target y
u target y -> target y -> BoolOf target
forall (f :: Target) (y :: TK). OrdH f y => f y -> f y -> BoolOf f
>=. target y
v) target y
u target y
v

rsum :: (KnownNat n, KnownSTK x, BaseTensor target)
     => target (TKR2 (1 + n) x) -> target (TKR2 n x)
rsum :: forall (n :: Nat) (x :: TK) (target :: Target).
(KnownNat n, KnownSTK x, BaseTensor target) =>
target (TKR2 (1 + n) x) -> target (TKR2 n x)
rsum = target (TKR2 (1 + n) x) -> target (TKR2 n x)
forall (n :: Nat) (x :: TK).
(KnownNat n, KnownSTK x) =>
target (TKR2 (1 + n) x) -> target (TKR2 n x)
forall (target :: Target) (n :: Nat) (x :: TK).
(BaseTensor target, KnownNat n, KnownSTK x) =>
target (TKR2 (1 + n) x) -> target (TKR2 n x)
trsum
rsum0 :: (KnownNat n, KnownSTK x, BaseTensor target)
      => target (TKR2 n x) -> target (TKR2 0 x)
rsum0 :: forall (n :: Nat) (x :: TK) (target :: Target).
(KnownNat n, KnownSTK x, BaseTensor target) =>
target (TKR2 n x) -> target (TKR2 0 x)
rsum0 = target (TKR2 n x) -> target (TKR2 0 x)
forall (n :: Nat) (x :: TK).
(KnownNat n, KnownSTK x) =>
target (TKR2 n x) -> target (TKR2 0 x)
forall (target :: Target) (n :: Nat) (x :: TK).
(BaseTensor target, KnownNat n, KnownSTK x) =>
target (TKR2 n x) -> target (TKR2 0 x)
trsum0
rdot0 :: ( KnownNat n, GoodScalar r, BaseTensor target)
      => target (TKR n r) -> target (TKR n r) -> target (TKR 0 r)
rdot0 :: forall (n :: Nat) r (target :: Target).
(KnownNat n, GoodScalar r, BaseTensor target) =>
target (TKR n r) -> target (TKR n r) -> target (TKR 0 r)
rdot0 = target (TKR n r) -> target (TKR n r) -> target (TKR 0 r)
forall (n :: Nat) r.
(KnownNat n, GoodScalar r) =>
target (TKR n r) -> target (TKR n r) -> target (TKR 0 r)
forall (target :: Target) (n :: Nat) r.
(BaseTensor target, KnownNat n, GoodScalar r) =>
target (TKR n r) -> target (TKR n r) -> target (TKR 0 r)
trdot0
rdot1In :: (KnownNat n, GoodScalar r, BaseTensor target)
        => target (TKR (1 + n) r) -> target (TKR (1 + n) r)
        -> target (TKR n r)
rdot1In :: forall (n :: Nat) r (target :: Target).
(KnownNat n, GoodScalar r, BaseTensor target) =>
target (TKR (1 + n) r)
-> target (TKR (1 + n) r) -> target (TKR n r)
rdot1In = target (TKR (1 + n) r)
-> target (TKR (1 + n) r) -> target (TKR n r)
forall (n :: Nat) r.
(KnownNat n, GoodScalar r) =>
target (TKR (1 + n) r)
-> target (TKR (1 + n) r) -> target (TKR n r)
forall (target :: Target) (n :: Nat) r.
(BaseTensor target, KnownNat n, GoodScalar r) =>
target (TKR (1 + n) r)
-> target (TKR (1 + n) r) -> target (TKR n r)
trdot1In
rmatvecmul :: (GoodScalar r, BaseTensor target)
           => target (TKR 2 r) -> target (TKR 1 r) -> target (TKR 1 r)
rmatvecmul :: forall r (target :: Target).
(GoodScalar r, BaseTensor target) =>
target (TKR 2 r) -> target (TKR 1 r) -> target (TKR 1 r)
rmatvecmul = target (TKR 2 r) -> target (TKR 1 r) -> target (TKR 1 r)
forall r.
GoodScalar r =>
target (TKR 2 r) -> target (TKR 1 r) -> target (TKR 1 r)
forall (target :: Target) r.
(BaseTensor target, GoodScalar r) =>
target (TKR 2 r) -> target (TKR 1 r) -> target (TKR 1 r)
trmatvecmul
rmatmul2 :: (GoodScalar r, BaseTensor target)
         => target (TKR 2 r) -> target (TKR 2 r) -> target (TKR 2 r)
rmatmul2 :: forall r (target :: Target).
(GoodScalar r, BaseTensor target) =>
target (TKR 2 r) -> target (TKR 2 r) -> target (TKR 2 r)
rmatmul2 = target (TKR 2 r) -> target (TKR 2 r) -> target (TKR 2 r)
forall r.
GoodScalar r =>
target (TKR 2 r) -> target (TKR 2 r) -> target (TKR 2 r)
forall (target :: Target) r.
(BaseTensor target, GoodScalar r) =>
target (TKR 2 r) -> target (TKR 2 r) -> target (TKR 2 r)
trmatmul2
-- | Copy the given tensor along the new, outermost dimension.
rreplicate :: (KnownNat n, KnownSTK x, BaseTensor target)
           => Int -> target (TKR2 n x) -> target (TKR2 (1 + n) x)
rreplicate :: forall (n :: Nat) (x :: TK) (target :: Target).
(KnownNat n, KnownSTK x, BaseTensor target) =>
Int -> target (TKR2 n x) -> target (TKR2 (1 + n) x)
rreplicate = Int -> target (TKR2 n x) -> target (TKR2 (1 + n) x)
forall (n :: Nat) (x :: TK).
(KnownNat n, KnownSTK x) =>
Int -> target (TKR2 n x) -> target (TKR2 (1 + n) x)
forall (target :: Target) (n :: Nat) (x :: TK).
(BaseTensor target, KnownNat n, KnownSTK x) =>
Int -> target (TKR2 n x) -> target (TKR2 (1 + n) x)
trreplicate
rreplicate0N :: (KnownNat n, KnownSTK x, BaseTensor target)
             => IShR n -> target (TKR2 0 x) -> target (TKR2 n x)
rreplicate0N :: forall (n :: Nat) (x :: TK) (target :: Target).
(KnownNat n, KnownSTK x, BaseTensor target) =>
IShR n -> target (TKR2 0 x) -> target (TKR2 n x)
rreplicate0N = IShR n -> target (TKR2 0 x) -> target (TKR2 n x)
forall (n :: Nat) (x :: TK).
(KnownNat n, KnownSTK x) =>
IShR n -> target (TKR2 0 x) -> target (TKR2 n x)
forall (target :: Target) (n :: Nat) (x :: TK).
(BaseTensor target, KnownNat n, KnownSTK x) =>
IShR n -> target (TKR2 0 x) -> target (TKR2 n x)
trreplicate0N

ssum :: (KnownNat n, KnownShS sh, KnownSTK x, BaseTensor target)
     => target (TKS2 (n ': sh) x) -> target (TKS2 sh x)
ssum :: forall (n :: Nat) (sh :: [Nat]) (x :: TK) (target :: Target).
(KnownNat n, KnownShS sh, KnownSTK x, BaseTensor target) =>
target (TKS2 ((':) @Nat n sh) x) -> target (TKS2 sh x)
ssum = target (TKS2 ((':) @Nat n sh) x) -> target (TKS2 sh x)
forall (n :: Nat) (sh :: [Nat]) (x :: TK).
(KnownNat n, KnownShS sh, KnownSTK x) =>
target (TKS2 ((':) @Nat n sh) x) -> target (TKS2 sh x)
forall (target :: Target) (n :: Nat) (sh :: [Nat]) (x :: TK).
(BaseTensor target, KnownNat n, KnownShS sh, KnownSTK x) =>
target (TKS2 ((':) @Nat n sh) x) -> target (TKS2 sh x)
tssum
ssum0 :: (KnownShS sh, KnownSTK x, BaseTensor target)
      => target (TKS2 sh x) -> target (TKS2 '[] x)
ssum0 :: forall (sh :: [Nat]) (x :: TK) (target :: Target).
(KnownShS sh, KnownSTK x, BaseTensor target) =>
target (TKS2 sh x) -> target (TKS2 ('[] @Nat) x)
ssum0 = target (TKS2 sh x) -> target (TKS2 ('[] @Nat) x)
forall (sh :: [Nat]) (x :: TK).
(KnownShS sh, KnownSTK x) =>
target (TKS2 sh x) -> target (TKS2 ('[] @Nat) x)
forall (target :: Target) (sh :: [Nat]) (x :: TK).
(BaseTensor target, KnownShS sh, KnownSTK x) =>
target (TKS2 sh x) -> target (TKS2 ('[] @Nat) x)
tssum0
sdot0 :: (KnownShS sh, GoodScalar r, BaseTensor target)
      => target (TKS sh r) -> target (TKS sh r) -> target (TKS '[] r)
sdot0 :: forall (sh :: [Nat]) r (target :: Target).
(KnownShS sh, GoodScalar r, BaseTensor target) =>
target (TKS sh r) -> target (TKS sh r) -> target (TKS ('[] @Nat) r)
sdot0 = target (TKS sh r) -> target (TKS sh r) -> target (TKS ('[] @Nat) r)
forall (sh :: [Nat]) r.
(KnownShS sh, GoodScalar r) =>
target (TKS sh r) -> target (TKS sh r) -> target (TKS ('[] @Nat) r)
forall (target :: Target) (sh :: [Nat]) r.
(BaseTensor target, KnownShS sh, GoodScalar r) =>
target (TKS sh r) -> target (TKS sh r) -> target (TKS ('[] @Nat) r)
tsdot0
sdot1In :: (KnownShS sh, KnownNat n, GoodScalar r, BaseTensor target)
        => target (TKS (sh ++ '[n]) r) -> target (TKS (sh ++ '[n]) r)
        -> target (TKS sh r)
sdot1In :: forall (sh :: [Nat]) (n :: Nat) r (target :: Target).
(KnownShS sh, KnownNat n, GoodScalar r, BaseTensor target) =>
target (TKS ((++) @Nat sh ((':) @Nat n ('[] @Nat))) r)
-> target (TKS ((++) @Nat sh ((':) @Nat n ('[] @Nat))) r)
-> target (TKS sh r)
sdot1In @sh @n = forall (target :: Target) (sh :: [Nat]) r (n :: Nat).
(BaseTensor target, KnownShS sh, GoodScalar r) =>
SNat n
-> target (TKS ((++) @Nat sh ((':) @Nat n ('[] @Nat))) r)
-> target (TKS ((++) @Nat sh ((':) @Nat n ('[] @Nat))) r)
-> target (TKS sh r)
tsdot1In @_ @sh (forall (n :: Nat). KnownNat n => SNat n
SNat @n)
smatvecmul :: (KnownNat m, KnownNat n, GoodScalar r, BaseTensor target)
           => target (TKS '[m, n] r) -> target (TKS '[n] r)
           -> target (TKS '[m] r)
smatvecmul :: forall (m :: Nat) (n :: Nat) r (target :: Target).
(KnownNat m, KnownNat n, GoodScalar r, BaseTensor target) =>
target (TKS ((':) @Nat m ((':) @Nat n ('[] @Nat))) r)
-> target (TKS ((':) @Nat n ('[] @Nat)) r)
-> target (TKS ((':) @Nat m ('[] @Nat)) r)
smatvecmul = target (TKS ((':) @Nat m ((':) @Nat n ('[] @Nat))) r)
-> target (TKS ((':) @Nat n ('[] @Nat)) r)
-> target (TKS ((':) @Nat m ('[] @Nat)) r)
forall (m :: Nat) (n :: Nat) r.
(KnownNat m, KnownNat n, GoodScalar r) =>
target (TKS ((':) @Nat m ((':) @Nat n ('[] @Nat))) r)
-> target (TKS ((':) @Nat n ('[] @Nat)) r)
-> target (TKS ((':) @Nat m ('[] @Nat)) r)
forall (target :: Target) (m :: Nat) (n :: Nat) r.
(BaseTensor target, KnownNat m, KnownNat n, GoodScalar r) =>
target (TKS ((':) @Nat m ((':) @Nat n ('[] @Nat))) r)
-> target (TKS ((':) @Nat n ('[] @Nat)) r)
-> target (TKS ((':) @Nat m ('[] @Nat)) r)
tsmatvecmul
smatmul2 :: ( KnownNat m, KnownNat n, KnownNat p
            , GoodScalar r, BaseTensor target )
         => target (TKS '[m, n] r) -> target (TKS '[n, p] r)
         -> target (TKS '[m, p] r)
smatmul2 :: forall (m :: Nat) (n :: Nat) (p :: Nat) r (target :: Target).
(KnownNat m, KnownNat n, KnownNat p, GoodScalar r,
 BaseTensor target) =>
target (TKS ((':) @Nat m ((':) @Nat n ('[] @Nat))) r)
-> target (TKS ((':) @Nat n ((':) @Nat p ('[] @Nat))) r)
-> target (TKS ((':) @Nat m ((':) @Nat p ('[] @Nat))) r)
smatmul2 = target (TKS ((':) @Nat m ((':) @Nat n ('[] @Nat))) r)
-> target (TKS ((':) @Nat n ((':) @Nat p ('[] @Nat))) r)
-> target (TKS ((':) @Nat m ((':) @Nat p ('[] @Nat))) r)
forall (m :: Nat) (n :: Nat) (p :: Nat) r.
(KnownNat m, KnownNat n, KnownNat p, GoodScalar r) =>
target (TKS ((':) @Nat m ((':) @Nat n ('[] @Nat))) r)
-> target (TKS ((':) @Nat n ((':) @Nat p ('[] @Nat))) r)
-> target (TKS ((':) @Nat m ((':) @Nat p ('[] @Nat))) r)
forall (target :: Target) (m :: Nat) (n :: Nat) (p :: Nat) r.
(BaseTensor target, KnownNat m, KnownNat n, KnownNat p,
 GoodScalar r) =>
target (TKS ((':) @Nat m ((':) @Nat n ('[] @Nat))) r)
-> target (TKS ((':) @Nat n ((':) @Nat p ('[] @Nat))) r)
-> target (TKS ((':) @Nat m ((':) @Nat p ('[] @Nat))) r)
tsmatmul2
sreplicate :: (KnownNat k, KnownShS sh, KnownSTK x, BaseTensor target)
           => target (TKS2 sh x) -> target (TKS2 (k ': sh) x)
sreplicate :: forall (k :: Nat) (sh :: [Nat]) (x :: TK) (target :: Target).
(KnownNat k, KnownShS sh, KnownSTK x, BaseTensor target) =>
target (TKS2 sh x) -> target (TKS2 ((':) @Nat k sh) x)
sreplicate = SNat k
-> ShS sh -> target (TKS2 sh x) -> target (TKS2 ((':) @Nat k sh) x)
forall (sh :: [Nat]) (k :: Nat) (x :: TK).
KnownSTK x =>
SNat k
-> ShS sh -> target (TKS2 sh x) -> target (TKS2 ((':) @Nat k sh) x)
forall (target :: Target) (sh :: [Nat]) (k :: Nat) (x :: TK).
(BaseTensor target, KnownSTK x) =>
SNat k
-> ShS sh -> target (TKS2 sh x) -> target (TKS2 ((':) @Nat k sh) x)
tsreplicate SNat k
forall (n :: Nat). KnownNat n => SNat n
SNat ShS sh
forall (sh :: [Nat]). KnownShS sh => ShS sh
knownShS
sreplicate0N :: (KnownShS sh, KnownSTK x, BaseTensor target)
             => target (TKS2 '[] x) -> target (TKS2 sh x)
sreplicate0N :: forall (sh :: [Nat]) (x :: TK) (target :: Target).
(KnownShS sh, KnownSTK x, BaseTensor target) =>
target (TKS2 ('[] @Nat) x) -> target (TKS2 sh x)
sreplicate0N = ShS sh -> target (TKS2 ('[] @Nat) x) -> target (TKS2 sh x)
forall (sh :: [Nat]) (x :: TK).
KnownSTK x =>
ShS sh -> target (TKS2 ('[] @Nat) x) -> target (TKS2 sh x)
forall (target :: Target) (sh :: [Nat]) (x :: TK).
(BaseTensor target, KnownSTK x) =>
ShS sh -> target (TKS2 ('[] @Nat) x) -> target (TKS2 sh x)
tsreplicate0N ShS sh
forall (sh :: [Nat]). KnownShS sh => ShS sh
knownShS

xsum :: (KnownNat n, KnownShX sh, KnownSTK x, BaseTensor target)
     => target (TKX2 (Just n ': sh) x) -> target (TKX2 sh x)
xsum :: forall (n :: Nat) (sh :: [Maybe Nat]) (x :: TK) (target :: Target).
(KnownNat n, KnownShX sh, KnownSTK x, BaseTensor target) =>
target (TKX2 ((':) @(Maybe Nat) ('Just @Nat n) sh) x)
-> target (TKX2 sh x)
xsum = target (TKX2 ((':) @(Maybe Nat) ('Just @Nat n) sh) x)
-> target (TKX2 sh x)
forall (n :: Nat) (sh :: [Maybe Nat]) (x :: TK).
(KnownNat n, KnownShX sh, KnownSTK x) =>
target (TKX2 ((':) @(Maybe Nat) ('Just @Nat n) sh) x)
-> target (TKX2 sh x)
forall (target :: Target) (n :: Nat) (sh :: [Maybe Nat]) (x :: TK).
(BaseTensor target, KnownNat n, KnownShX sh, KnownSTK x) =>
target (TKX2 ((':) @(Maybe Nat) ('Just @Nat n) sh) x)
-> target (TKX2 sh x)
txsum
xsum0 :: (KnownShX sh, KnownSTK x, BaseTensor target, ConvertTensor target)
      => target (TKX2 sh x) -> target (TKX2 '[] x)
xsum0 :: forall (sh :: [Maybe Nat]) (x :: TK) (target :: Target).
(KnownShX sh, KnownSTK x, BaseTensor target,
 ConvertTensor target) =>
target (TKX2 sh x) -> target (TKX2 ('[] @(Maybe Nat)) x)
xsum0 = target (TKX2 sh x) -> target (TKX2 ('[] @(Maybe Nat)) x)
forall (sh :: [Maybe Nat]) (x :: TK).
(KnownShX sh, KnownSTK x, ConvertTensor target) =>
target (TKX2 sh x) -> target (TKX2 ('[] @(Maybe Nat)) x)
forall (target :: Target) (sh :: [Maybe Nat]) (x :: TK).
(BaseTensor target, KnownShX sh, KnownSTK x,
 ConvertTensor target) =>
target (TKX2 sh x) -> target (TKX2 ('[] @(Maybe Nat)) x)
txsum0
xdot0 :: ( KnownShX sh, GoodScalar r
         , BaseTensor target, ConvertTensor target )
      => target (TKX sh r) -> target (TKX sh r) -> target (TKX '[] r)
xdot0 :: forall (sh :: [Maybe Nat]) r (target :: Target).
(KnownShX sh, GoodScalar r, BaseTensor target,
 ConvertTensor target) =>
target (TKX sh r)
-> target (TKX sh r) -> target (TKX ('[] @(Maybe Nat)) r)
xdot0 = target (TKX sh r)
-> target (TKX sh r) -> target (TKX ('[] @(Maybe Nat)) r)
forall (sh :: [Maybe Nat]) r.
(KnownShX sh, GoodScalar r, ConvertTensor target) =>
target (TKX sh r)
-> target (TKX sh r) -> target (TKX ('[] @(Maybe Nat)) r)
forall (target :: Target) (sh :: [Maybe Nat]) r.
(BaseTensor target, KnownShX sh, GoodScalar r,
 ConvertTensor target) =>
target (TKX sh r)
-> target (TKX sh r) -> target (TKX ('[] @(Maybe Nat)) r)
txdot0
xdot1In :: (KnownShX sh, KnownNat n, GoodScalar r, BaseTensor target)
        => target (TKX (sh ++ '[Just n]) r)
        -> target (TKX (sh ++ '[Just n]) r)
        -> target (TKX sh r)
xdot1In :: forall (sh :: [Maybe Nat]) (n :: Nat) r (target :: Target).
(KnownShX sh, KnownNat n, GoodScalar r, BaseTensor target) =>
target
  (TKX
     ((++)
        @(Maybe Nat)
        sh
        ((':) @(Maybe Nat) ('Just @Nat n) ('[] @(Maybe Nat))))
     r)
-> target
     (TKX
        ((++)
           @(Maybe Nat)
           sh
           ((':) @(Maybe Nat) ('Just @Nat n) ('[] @(Maybe Nat))))
        r)
-> target (TKX sh r)
xdot1In @sh @n = forall (target :: Target) (sh :: [Maybe Nat]) r (n :: Nat).
(BaseTensor target, KnownShX sh, GoodScalar r) =>
SNat n
-> target
     (TKX
        ((++)
           @(Maybe Nat)
           sh
           ((':) @(Maybe Nat) ('Just @Nat n) ('[] @(Maybe Nat))))
        r)
-> target
     (TKX
        ((++)
           @(Maybe Nat)
           sh
           ((':) @(Maybe Nat) ('Just @Nat n) ('[] @(Maybe Nat))))
        r)
-> target (TKX sh r)
txdot1In @_ @sh (forall (n :: Nat). KnownNat n => SNat n
SNat @n)
xmatvecmul :: forall mm mn r target.
              (GoodScalar r, BaseTensor target, ConvertTensor target)
           => Nested.SMayNat Int SNat mm -> Nested.SMayNat Int SNat mn
           -> target (TKX '[mm, mn] r) -> target (TKX '[mn] r)
           -> target (TKX '[mm] r)
xmatvecmul :: forall (mm :: Maybe Nat) (mn :: Maybe Nat) r (target :: Target).
(GoodScalar r, BaseTensor target, ConvertTensor target) =>
SMayNat @Nat Int SNat mm
-> SMayNat @Nat Int SNat mn
-> target
     (TKX
        ((':) @(Maybe Nat) mm ((':) @(Maybe Nat) mn ('[] @(Maybe Nat)))) r)
-> target (TKX ((':) @(Maybe Nat) mn ('[] @(Maybe Nat))) r)
-> target (TKX ((':) @(Maybe Nat) mm ('[] @(Maybe Nat))) r)
xmatvecmul = SMayNat @Nat Int SNat mm
-> SMayNat @Nat Int SNat mn
-> target
     (TKX
        ((':) @(Maybe Nat) mm ((':) @(Maybe Nat) mn ('[] @(Maybe Nat)))) r)
-> target (TKX ((':) @(Maybe Nat) mn ('[] @(Maybe Nat))) r)
-> target (TKX ((':) @(Maybe Nat) mm ('[] @(Maybe Nat))) r)
forall (mm :: Maybe Nat) (mn :: Maybe Nat) r.
(GoodScalar r, ConvertTensor target) =>
SMayNat @Nat Int SNat mm
-> SMayNat @Nat Int SNat mn
-> target
     (TKX
        ((':) @(Maybe Nat) mm ((':) @(Maybe Nat) mn ('[] @(Maybe Nat)))) r)
-> target (TKX ((':) @(Maybe Nat) mn ('[] @(Maybe Nat))) r)
-> target (TKX ((':) @(Maybe Nat) mm ('[] @(Maybe Nat))) r)
forall (target :: Target) (mm :: Maybe Nat) (mn :: Maybe Nat) r.
(BaseTensor target, GoodScalar r, ConvertTensor target) =>
SMayNat @Nat Int SNat mm
-> SMayNat @Nat Int SNat mn
-> target
     (TKX
        ((':) @(Maybe Nat) mm ((':) @(Maybe Nat) mn ('[] @(Maybe Nat)))) r)
-> target (TKX ((':) @(Maybe Nat) mn ('[] @(Maybe Nat))) r)
-> target (TKX ((':) @(Maybe Nat) mm ('[] @(Maybe Nat))) r)
txmatvecmul
xmatmul2 :: ( KnownNat m, KnownNat n, KnownNat p
            , GoodScalar r, BaseTensor target, ConvertTensor target )
         => target (TKX '[Just m, Just n] r)
         -> target (TKX '[Just n, Just p] r)
         -> target (TKX '[Just m, Just p] r)
xmatmul2 :: forall (m :: Nat) (n :: Nat) (p :: Nat) r (target :: Target).
(KnownNat m, KnownNat n, KnownNat p, GoodScalar r,
 BaseTensor target, ConvertTensor target) =>
target
  (TKX
     ((':)
        @(Maybe Nat)
        ('Just @Nat m)
        ((':) @(Maybe Nat) ('Just @Nat n) ('[] @(Maybe Nat))))
     r)
-> target
     (TKX
        ((':)
           @(Maybe Nat)
           ('Just @Nat n)
           ((':) @(Maybe Nat) ('Just @Nat p) ('[] @(Maybe Nat))))
        r)
-> target
     (TKX
        ((':)
           @(Maybe Nat)
           ('Just @Nat m)
           ((':) @(Maybe Nat) ('Just @Nat p) ('[] @(Maybe Nat))))
        r)
xmatmul2 = target
  (TKX
     ((':)
        @(Maybe Nat)
        ('Just @Nat m)
        ((':) @(Maybe Nat) ('Just @Nat n) ('[] @(Maybe Nat))))
     r)
-> target
     (TKX
        ((':)
           @(Maybe Nat)
           ('Just @Nat n)
           ((':) @(Maybe Nat) ('Just @Nat p) ('[] @(Maybe Nat))))
        r)
-> target
     (TKX
        ((':)
           @(Maybe Nat)
           ('Just @Nat m)
           ((':) @(Maybe Nat) ('Just @Nat p) ('[] @(Maybe Nat))))
        r)
forall (m :: Nat) (n :: Nat) (p :: Nat) r.
(KnownNat m, KnownNat n, KnownNat p, GoodScalar r,
 ConvertTensor target) =>
target
  (TKX
     ((':)
        @(Maybe Nat)
        ('Just @Nat m)
        ((':) @(Maybe Nat) ('Just @Nat n) ('[] @(Maybe Nat))))
     r)
-> target
     (TKX
        ((':)
           @(Maybe Nat)
           ('Just @Nat n)
           ((':) @(Maybe Nat) ('Just @Nat p) ('[] @(Maybe Nat))))
        r)
-> target
     (TKX
        ((':)
           @(Maybe Nat)
           ('Just @Nat m)
           ((':) @(Maybe Nat) ('Just @Nat p) ('[] @(Maybe Nat))))
        r)
forall (target :: Target) (m :: Nat) (n :: Nat) (p :: Nat) r.
(BaseTensor target, KnownNat m, KnownNat n, KnownNat p,
 GoodScalar r, ConvertTensor target) =>
target
  (TKX
     ((':)
        @(Maybe Nat)
        ('Just @Nat m)
        ((':) @(Maybe Nat) ('Just @Nat n) ('[] @(Maybe Nat))))
     r)
-> target
     (TKX
        ((':)
           @(Maybe Nat)
           ('Just @Nat n)
           ((':) @(Maybe Nat) ('Just @Nat p) ('[] @(Maybe Nat))))
        r)
-> target
     (TKX
        ((':)
           @(Maybe Nat)
           ('Just @Nat m)
           ((':) @(Maybe Nat) ('Just @Nat p) ('[] @(Maybe Nat))))
        r)
txmatmul2
xreplicate :: (KnownNat k, KnownShX sh, KnownSTK x, BaseTensor target)
           => target (TKX2 sh x) -> target (TKX2 (Just k ': sh) x)
xreplicate :: forall (k :: Nat) (sh :: [Maybe Nat]) (x :: TK) (target :: Target).
(KnownNat k, KnownShX sh, KnownSTK x, BaseTensor target) =>
target (TKX2 sh x)
-> target (TKX2 ((':) @(Maybe Nat) ('Just @Nat k) sh) x)
xreplicate = SNat k
-> StaticShX sh
-> target (TKX2 sh x)
-> target (TKX2 ((':) @(Maybe Nat) ('Just @Nat k) sh) x)
forall (sh :: [Maybe Nat]) (k :: Nat) (x :: TK).
KnownSTK x =>
SNat k
-> StaticShX sh
-> target (TKX2 sh x)
-> target (TKX2 ((':) @(Maybe Nat) ('Just @Nat k) sh) x)
forall (target :: Target) (sh :: [Maybe Nat]) (k :: Nat) (x :: TK).
(BaseTensor target, KnownSTK x) =>
SNat k
-> StaticShX sh
-> target (TKX2 sh x)
-> target (TKX2 ((':) @(Maybe Nat) ('Just @Nat k) sh) x)
txreplicate SNat k
forall (n :: Nat). KnownNat n => SNat n
SNat StaticShX sh
forall (sh :: [Maybe Nat]). KnownShX sh => StaticShX sh
knownShX
xreplicate0N :: (KnownShX sh, KnownSTK x, BaseTensor target)
             => IShX sh -> target (TKX2 '[] x) -> target (TKX2 sh x)
xreplicate0N :: forall (sh :: [Maybe Nat]) (x :: TK) (target :: Target).
(KnownShX sh, KnownSTK x, BaseTensor target) =>
IShX sh -> target (TKX2 ('[] @(Maybe Nat)) x) -> target (TKX2 sh x)
xreplicate0N = IShX sh -> target (TKX2 ('[] @(Maybe Nat)) x) -> target (TKX2 sh x)
forall (sh :: [Maybe Nat]) (x :: TK).
(KnownShX sh, KnownSTK x) =>
IShX sh -> target (TKX2 ('[] @(Maybe Nat)) x) -> target (TKX2 sh x)
forall (target :: Target) (sh :: [Maybe Nat]) (x :: TK).
(BaseTensor target, KnownShX sh, KnownSTK x) =>
IShX sh -> target (TKX2 ('[] @(Maybe Nat)) x) -> target (TKX2 sh x)
txreplicate0N

-- | First index is for outermost dimension; empty index means identity,
-- if index is out of bounds, the result is defined and is @def@, which is @0@.
-- The same holds for all operations with indexes.
rindex, (!) :: (KnownNat m, KnownNat n, KnownSTK x, BaseTensor target)
            => target (TKR2 (m + n) x) -> IxROf target m -> target (TKR2 n x)
rindex :: forall (m :: Nat) (n :: Nat) (x :: TK) (target :: Target).
(KnownNat m, KnownNat n, KnownSTK x, BaseTensor target) =>
target (TKR2 (m + n) x) -> IxROf target m -> target (TKR2 n x)
rindex = target (TKR2 (m + n) x) -> IxROf target m -> target (TKR2 n x)
forall (m :: Nat) (n :: Nat) (x :: TK).
(KnownNat m, KnownNat n, KnownSTK x) =>
target (TKR2 (m + n) x) -> IxROf target m -> target (TKR2 n x)
forall (target :: Target) (m :: Nat) (n :: Nat) (x :: TK).
(BaseTensor target, KnownNat m, KnownNat n, KnownSTK x) =>
target (TKR2 (m + n) x) -> IxROf target m -> target (TKR2 n x)
trindex
infixl 9 !
! :: forall (m :: Nat) (n :: Nat) (x :: TK) (target :: Target).
(KnownNat m, KnownNat n, KnownSTK x, BaseTensor target) =>
target (TKR2 (m + n) x) -> IxROf target m -> target (TKR2 n x)
(!) = target (TKR2 (m + n) x) -> IxROf target m -> target (TKR2 n x)
forall (m :: Nat) (n :: Nat) (x :: TK) (target :: Target).
(KnownNat m, KnownNat n, KnownSTK x, BaseTensor target) =>
target (TKR2 (m + n) x) -> IxROf target m -> target (TKR2 n x)
rindex  -- prefix form better when type applications are necessary
rindex0 :: (KnownNat m, KnownSTK x, BaseTensor target)
        => target (TKR2 m x) -> IxROf target m -> target (TKR2 0 x)
rindex0 :: forall (m :: Nat) (x :: TK) (target :: Target).
(KnownNat m, KnownSTK x, BaseTensor target) =>
target (TKR2 m x) -> IxROf target m -> target (TKR2 0 x)
rindex0 = target (TKR2 m x) -> IxROf target m -> target (TKR2 0 x)
forall (m :: Nat) (x :: TK).
(KnownNat m, KnownSTK x) =>
target (TKR2 m x) -> IxROf target m -> target (TKR2 0 x)
forall (target :: Target) (m :: Nat) (x :: TK).
(BaseTensor target, KnownNat m, KnownSTK x) =>
target (TKR2 m x) -> IxROf target m -> target (TKR2 0 x)
trindex0
roneHot :: ( KnownNat m, KnownNat n, KnownSTK x
           , BoolOf (PrimalOf target) ~ BoolOf target
           , EqH (PrimalOf target) (TKScalar Int64), BaseTensor target)
        => IShR m -> target (TKR2 n x) -> IxROf target m
        -> target (TKR2 (m + n) x)
roneHot :: forall (m :: Nat) (n :: Nat) (x :: TK) (target :: Target).
(KnownNat m, KnownNat n, KnownSTK x,
 (BoolOf (PrimalOf target) :: Type) ~ (BoolOf target :: Type),
 EqH (PrimalOf target) (TKScalar Int64), BaseTensor target) =>
IShR m
-> target (TKR2 n x) -> IxROf target m -> target (TKR2 (m + n) x)
roneHot = IShR m
-> target (TKR2 n x) -> IxROf target m -> target (TKR2 (m + n) x)
forall (m :: Nat) (n :: Nat) (x :: TK).
(KnownNat m, KnownNat n, KnownSTK x,
 (BoolOf (PrimalOf target) :: Type) ~ (BoolOf target :: Type),
 EqH (PrimalOf target) (TKScalar Int64)) =>
IShR m
-> target (TKR2 n x) -> IxROf target m -> target (TKR2 (m + n) x)
forall (target :: Target) (m :: Nat) (n :: Nat) (x :: TK).
(BaseTensor target, KnownNat m, KnownNat n, KnownSTK x,
 (BoolOf (PrimalOf target) :: Type) ~ (BoolOf target :: Type),
 EqH (PrimalOf target) (TKScalar Int64)) =>
IShR m
-> target (TKR2 n x) -> IxROf target m -> target (TKR2 (m + n) x)
troneHot
rscatter :: (KnownNat m, KnownNat n, KnownNat p, KnownSTK x, BaseTensor target)
         => IShR (p + n) -> target (TKR2 (m + n) x)
         -> (IxROf target m -> IxROf target p)
         -> target (TKR2 (p + n) x)
rscatter :: forall (m :: Nat) (n :: Nat) (p :: Nat) (x :: TK)
       (target :: Target).
(KnownNat m, KnownNat n, KnownNat p, KnownSTK x,
 BaseTensor target) =>
IShR (p + n)
-> target (TKR2 (m + n) x)
-> (IxROf target m -> IxROf target p)
-> target (TKR2 (p + n) x)
rscatter = IShR (p + n)
-> target (TKR2 (m + n) x)
-> (IxROf target m -> IxROf target p)
-> target (TKR2 (p + n) x)
forall (m :: Nat) (n :: Nat) (p :: Nat) (x :: TK).
(KnownNat m, KnownNat n, KnownNat p, KnownSTK x) =>
IShR (p + n)
-> target (TKR2 (m + n) x)
-> (IxROf target m -> IxROf target p)
-> target (TKR2 (p + n) x)
forall (target :: Target) (m :: Nat) (n :: Nat) (p :: Nat)
       (x :: TK).
(BaseTensor target, KnownNat m, KnownNat n, KnownNat p,
 KnownSTK x) =>
IShR (p + n)
-> target (TKR2 (m + n) x)
-> (IxROf target m -> IxROf target p)
-> target (TKR2 (p + n) x)
trscatter
-- | Build a tensor by adding up tensors of rank @n@ taken from
-- the second argument and inserted in a zero tensor
-- at indexes of length @p@.
-- The semantics of the operation permits index out of bounds
-- and then no tensor is added at such an index.
rscatter1 :: (KnownNat n, KnownNat p, KnownSTK x, BaseTensor target)
          => IShR (p + n) -> target (TKR2 (1 + n) x)
          -> (IntOf target -> IxROf target p)
          -> target (TKR2 (p + n) x)
rscatter1 :: forall (n :: Nat) (p :: Nat) (x :: TK) (target :: Target).
(KnownNat n, KnownNat p, KnownSTK x, BaseTensor target) =>
IShR (p + n)
-> target (TKR2 (1 + n) x)
-> (IntOf target -> IxROf target p)
-> target (TKR2 (p + n) x)
rscatter1 = IShR (p + n)
-> target (TKR2 (1 + n) x)
-> (IntOf target -> IxROf target p)
-> target (TKR2 (p + n) x)
forall (n :: Nat) (p :: Nat) (x :: TK).
(KnownNat n, KnownNat p, KnownSTK x) =>
IShR (p + n)
-> target (TKR2 (1 + n) x)
-> (IntOf target -> IxROf target p)
-> target (TKR2 (p + n) x)
forall (target :: Target) (n :: Nat) (p :: Nat) (x :: TK).
(BaseTensor target, KnownNat n, KnownNat p, KnownSTK x) =>
IShR (p + n)
-> target (TKR2 (1 + n) x)
-> (IntOf target -> IxROf target p)
-> target (TKR2 (p + n) x)
trscatter1
rgather :: (KnownNat m, KnownNat n, KnownNat p, KnownSTK x, BaseTensor target)
        => IShR (m + n) -> target (TKR2 (p + n) x)
        -> (IxROf target m -> IxROf target p)
        -> target (TKR2 (m + n) x)
rgather :: forall (m :: Nat) (n :: Nat) (p :: Nat) (x :: TK)
       (target :: Target).
(KnownNat m, KnownNat n, KnownNat p, KnownSTK x,
 BaseTensor target) =>
IShR (m + n)
-> target (TKR2 (p + n) x)
-> (IxROf target m -> IxROf target p)
-> target (TKR2 (m + n) x)
rgather = IShR (m + n)
-> target (TKR2 (p + n) x)
-> (IxROf target m -> IxROf target p)
-> target (TKR2 (m + n) x)
forall (m :: Nat) (n :: Nat) (p :: Nat) (x :: TK).
(KnownNat m, KnownNat n, KnownNat p, KnownSTK x) =>
IShR (m + n)
-> target (TKR2 (p + n) x)
-> (IxROf target m -> IxROf target p)
-> target (TKR2 (m + n) x)
forall (target :: Target) (m :: Nat) (n :: Nat) (p :: Nat)
       (x :: TK).
(BaseTensor target, KnownNat m, KnownNat n, KnownNat p,
 KnownSTK x) =>
IShR (m + n)
-> target (TKR2 (p + n) x)
-> (IxROf target m -> IxROf target p)
-> target (TKR2 (m + n) x)
trgather
-- | Build a tensor by collecting tensors of rank @n@ obtained by indexing
-- in the second argument at the given indexes of length @p@.
-- The semantics of the operation permits index out of bounds
-- and the result of such indexing is @def@, which is @0@.
rgather1 :: (KnownNat n, KnownNat p, KnownSTK x, BaseTensor target)
         => Int -> target (TKR2 (p + n) x)
         -> (IntOf target -> IxROf target p)
         -> target (TKR2 (1 + n) x)
rgather1 :: forall (n :: Nat) (p :: Nat) (x :: TK) (target :: Target).
(KnownNat n, KnownNat p, KnownSTK x, BaseTensor target) =>
Int
-> target (TKR2 (p + n) x)
-> (IntOf target -> IxROf target p)
-> target (TKR2 (1 + n) x)
rgather1 = Int
-> target (TKR2 (p + n) x)
-> (IntOf target -> IxROf target p)
-> target (TKR2 (1 + n) x)
forall (n :: Nat) (p :: Nat) (x :: TK).
(KnownNat n, KnownNat p, KnownSTK x) =>
Int
-> target (TKR2 (p + n) x)
-> (IntOf target -> IxROf target p)
-> target (TKR2 (1 + n) x)
forall (target :: Target) (n :: Nat) (p :: Nat) (x :: TK).
(BaseTensor target, KnownNat n, KnownNat p, KnownSTK x) =>
Int
-> target (TKR2 (p + n) x)
-> (IntOf target -> IxROf target p)
-> target (TKR2 (1 + n) x)
trgather1

sindex, (!$) :: (KnownShS shm, KnownShS shn, KnownSTK x, BaseTensor target)
             => target (TKS2 (shm ++ shn) x) -> IxSOf target shm
             -> target (TKS2 shn x)
sindex :: forall (shm :: [Nat]) (shn :: [Nat]) (x :: TK) (target :: Target).
(KnownShS shm, KnownShS shn, KnownSTK x, BaseTensor target) =>
target (TKS2 ((++) @Nat shm shn) x)
-> IxSOf target shm -> target (TKS2 shn x)
sindex = target (TKS2 ((++) @Nat shm shn) x)
-> IxSOf target shm -> target (TKS2 shn x)
forall (shm :: [Nat]) (shn :: [Nat]) (x :: TK).
(KnownShS shm, KnownShS shn, KnownSTK x) =>
target (TKS2 ((++) @Nat shm shn) x)
-> IxSOf target shm -> target (TKS2 shn x)
forall (target :: Target) (shm :: [Nat]) (shn :: [Nat]) (x :: TK).
(BaseTensor target, KnownShS shm, KnownShS shn, KnownSTK x) =>
target (TKS2 ((++) @Nat shm shn) x)
-> IxSOf target shm -> target (TKS2 shn x)
tsindex
infixl 9 !$
!$ :: forall (shm :: [Nat]) (shn :: [Nat]) (x :: TK) (target :: Target).
(KnownShS shm, KnownShS shn, KnownSTK x, BaseTensor target) =>
target (TKS2 ((++) @Nat shm shn) x)
-> IxSOf target shm -> target (TKS2 shn x)
(!$) = target (TKS2 ((++) @Nat shm shn) x)
-> IxSOf target shm -> target (TKS2 shn x)
forall (shm :: [Nat]) (shn :: [Nat]) (x :: TK) (target :: Target).
(KnownShS shm, KnownShS shn, KnownSTK x, BaseTensor target) =>
target (TKS2 ((++) @Nat shm shn) x)
-> IxSOf target shm -> target (TKS2 shn x)
sindex  -- prefix form better when type applications are necessary
sindex0 :: (KnownShS sh1, KnownSTK x, BaseTensor target)
        => target (TKS2 sh1 x) -> IxSOf target sh1
        -> target (TKS2 '[] x)
sindex0 :: forall (sh1 :: [Nat]) (x :: TK) (target :: Target).
(KnownShS sh1, KnownSTK x, BaseTensor target) =>
target (TKS2 sh1 x)
-> IxSOf target sh1 -> target (TKS2 ('[] @Nat) x)
sindex0 = target (TKS2 sh1 x)
-> IxSOf target sh1 -> target (TKS2 ('[] @Nat) x)
forall (sh1 :: [Nat]) (x :: TK).
(KnownShS sh1, KnownSTK x) =>
target (TKS2 sh1 x)
-> IxSOf target sh1 -> target (TKS2 ('[] @Nat) x)
forall (target :: Target) (sh1 :: [Nat]) (x :: TK).
(BaseTensor target, KnownShS sh1, KnownSTK x) =>
target (TKS2 sh1 x)
-> IxSOf target sh1 -> target (TKS2 ('[] @Nat) x)
tsindex0
soneHot :: ( KnownShS sh1, KnownShS sh2, KnownSTK x
           , BoolOf (PrimalOf target) ~ BoolOf target
           , EqH (PrimalOf target) (TKScalar Int64), BaseTensor target )
        => target (TKS2 sh2 x) -> IxSOf target sh1
        -> target (TKS2 (sh1 ++ sh2) x)
soneHot :: forall (sh1 :: [Nat]) (sh2 :: [Nat]) (x :: TK) (target :: Target).
(KnownShS sh1, KnownShS sh2, KnownSTK x,
 (BoolOf (PrimalOf target) :: Type) ~ (BoolOf target :: Type),
 EqH (PrimalOf target) (TKScalar Int64), BaseTensor target) =>
target (TKS2 sh2 x)
-> IxSOf target sh1 -> target (TKS2 ((++) @Nat sh1 sh2) x)
soneHot = target (TKS2 sh2 x)
-> IxSOf target sh1 -> target (TKS2 ((++) @Nat sh1 sh2) x)
forall (sh1 :: [Nat]) (sh2 :: [Nat]) (x :: TK).
(KnownShS sh1, KnownShS sh2, KnownSTK x,
 (BoolOf (PrimalOf target) :: Type) ~ (BoolOf target :: Type),
 EqH (PrimalOf target) (TKScalar Int64)) =>
target (TKS2 sh2 x)
-> IxSOf target sh1 -> target (TKS2 ((++) @Nat sh1 sh2) x)
forall (target :: Target) (sh1 :: [Nat]) (sh2 :: [Nat]) (x :: TK).
(BaseTensor target, KnownShS sh1, KnownShS sh2, KnownSTK x,
 (BoolOf (PrimalOf target) :: Type) ~ (BoolOf target :: Type),
 EqH (PrimalOf target) (TKScalar Int64)) =>
target (TKS2 sh2 x)
-> IxSOf target sh1 -> target (TKS2 ((++) @Nat sh1 sh2) x)
tsoneHot
sscatter
  :: (KnownShS shm, KnownShS shn, KnownShS shp, KnownSTK x, BaseTensor target)
  => target (TKS2 (shm ++ shn) x)
  -> (IxSOf target shm -> IxSOf target shp)
  -> target (TKS2 (shp ++ shn) x)
sscatter :: forall (shm :: [Nat]) (shn :: [Nat]) (shp :: [Nat]) (x :: TK)
       (target :: Target).
(KnownShS shm, KnownShS shn, KnownShS shp, KnownSTK x,
 BaseTensor target) =>
target (TKS2 ((++) @Nat shm shn) x)
-> (IxSOf target shm -> IxSOf target shp)
-> target (TKS2 ((++) @Nat shp shn) x)
sscatter @shm @shn @shp = forall (target :: Target) (shm :: [Nat]) (shn :: [Nat])
       (shp :: [Nat]) (x :: TK).
(BaseTensor target, KnownShS shm, KnownShS shn, KnownShS shp,
 KnownSTK x) =>
target (TKS2 ((++) @Nat shm shn) x)
-> (IxSOf target shm -> IxSOf target shp)
-> target (TKS2 ((++) @Nat shp shn) x)
tsscatter @_ @shm @shn @shp
sscatter1
  :: (KnownNat n2, KnownShS shn, KnownShS shp, KnownSTK x, BaseTensor target)
  => target (TKS2 (n2 ': shn) x)
  -> (IntOf target -> IxSOf target shp)
  -> target (TKS2 (shp ++ shn) x)
sscatter1 :: forall (n2 :: Nat) (shn :: [Nat]) (shp :: [Nat]) (x :: TK)
       (target :: Target).
(KnownNat n2, KnownShS shn, KnownShS shp, KnownSTK x,
 BaseTensor target) =>
target (TKS2 ((':) @Nat n2 shn) x)
-> (IntOf target -> IxSOf target shp)
-> target (TKS2 ((++) @Nat shp shn) x)
sscatter1 = target (TKS2 ((':) @Nat n2 shn) x)
-> (IntOf target -> IxSOf target shp)
-> target (TKS2 ((++) @Nat shp shn) x)
forall (n2 :: Nat) (shn :: [Nat]) (shp :: [Nat]) (x :: TK).
(KnownNat n2, KnownShS shn, KnownShS shp, KnownSTK x) =>
target (TKS2 ((':) @Nat n2 shn) x)
-> (IntOf target -> IxSOf target shp)
-> target (TKS2 ((++) @Nat shp shn) x)
forall (target :: Target) (n2 :: Nat) (shn :: [Nat]) (shp :: [Nat])
       (x :: TK).
(BaseTensor target, KnownNat n2, KnownShS shn, KnownShS shp,
 KnownSTK x) =>
target (TKS2 ((':) @Nat n2 shn) x)
-> (IntOf target -> IxSOf target shp)
-> target (TKS2 ((++) @Nat shp shn) x)
tsscatter1
sgather
  :: (KnownShS shm, KnownShS shn, KnownShS shp, KnownSTK x, BaseTensor target)
  => target (TKS2 (shp ++ shn) x)
  -> (IxSOf target shm -> IxSOf target shp)
  -> target (TKS2 (shm ++ shn) x)
sgather :: forall (shm :: [Nat]) (shn :: [Nat]) (shp :: [Nat]) (x :: TK)
       (target :: Target).
(KnownShS shm, KnownShS shn, KnownShS shp, KnownSTK x,
 BaseTensor target) =>
target (TKS2 ((++) @Nat shp shn) x)
-> (IxSOf target shm -> IxSOf target shp)
-> target (TKS2 ((++) @Nat shm shn) x)
sgather @shm @shn @shp = forall (target :: Target) (shm :: [Nat]) (shn :: [Nat])
       (shp :: [Nat]) (x :: TK).
(BaseTensor target, KnownShS shm, KnownShS shn, KnownShS shp,
 KnownSTK x) =>
target (TKS2 ((++) @Nat shp shn) x)
-> (IxSOf target shm -> IxSOf target shp)
-> target (TKS2 ((++) @Nat shm shn) x)
tsgather @_ @shm @shn @shp
sgather1
  :: (KnownNat n2, KnownShS shn, KnownShS shp, KnownSTK x, BaseTensor target)
  => target (TKS2 (shp ++ shn) x)
  -> (IntOf target -> IxSOf target shp)
  -> target (TKS2 (n2 ': shn) x)
sgather1 :: forall (n2 :: Nat) (shn :: [Nat]) (shp :: [Nat]) (x :: TK)
       (target :: Target).
(KnownNat n2, KnownShS shn, KnownShS shp, KnownSTK x,
 BaseTensor target) =>
target (TKS2 ((++) @Nat shp shn) x)
-> (IntOf target -> IxSOf target shp)
-> target (TKS2 ((':) @Nat n2 shn) x)
sgather1 = target (TKS2 ((++) @Nat shp shn) x)
-> (IntOf target -> IxSOf target shp)
-> target (TKS2 ((':) @Nat n2 shn) x)
forall (n2 :: Nat) (shn :: [Nat]) (shp :: [Nat]) (x :: TK).
(KnownNat n2, KnownShS shn, KnownShS shp, KnownSTK x) =>
target (TKS2 ((++) @Nat shp shn) x)
-> (IntOf target -> IxSOf target shp)
-> target (TKS2 ((':) @Nat n2 shn) x)
forall (target :: Target) (n2 :: Nat) (shn :: [Nat]) (shp :: [Nat])
       (x :: TK).
(BaseTensor target, KnownNat n2, KnownShS shn, KnownShS shp,
 KnownSTK x) =>
target (TKS2 ((++) @Nat shp shn) x)
-> (IntOf target -> IxSOf target shp)
-> target (TKS2 ((':) @Nat n2 shn) x)
tsgather1

xindex :: (KnownShX sh1, KnownShX sh2, KnownSTK x, BaseTensor target)
       => target (TKX2 (sh1 ++ sh2) x) -> IxXOf target sh1
       -> target (TKX2 sh2 x)
xindex :: forall (sh1 :: [Maybe Nat]) (sh2 :: [Maybe Nat]) (x :: TK)
       (target :: Target).
(KnownShX sh1, KnownShX sh2, KnownSTK x, BaseTensor target) =>
target (TKX2 ((++) @(Maybe Nat) sh1 sh2) x)
-> IxXOf target sh1 -> target (TKX2 sh2 x)
xindex = target (TKX2 ((++) @(Maybe Nat) sh1 sh2) x)
-> IxXOf target sh1 -> target (TKX2 sh2 x)
forall (sh1 :: [Maybe Nat]) (sh2 :: [Maybe Nat]) (x :: TK).
(KnownShX sh1, KnownShX sh2, KnownSTK x) =>
target (TKX2 ((++) @(Maybe Nat) sh1 sh2) x)
-> IxXOf target sh1 -> target (TKX2 sh2 x)
forall (target :: Target) (sh1 :: [Maybe Nat]) (sh2 :: [Maybe Nat])
       (x :: TK).
(BaseTensor target, KnownShX sh1, KnownShX sh2, KnownSTK x) =>
target (TKX2 ((++) @(Maybe Nat) sh1 sh2) x)
-> IxXOf target sh1 -> target (TKX2 sh2 x)
txindex
xindex0 :: (KnownShX sh1, KnownSTK x, BaseTensor target)
        => target (TKX2 sh1 x) -> IxXOf target sh1
        -> target (TKX2 '[] x)
xindex0 :: forall (sh1 :: [Maybe Nat]) (x :: TK) (target :: Target).
(KnownShX sh1, KnownSTK x, BaseTensor target) =>
target (TKX2 sh1 x)
-> IxXOf target sh1 -> target (TKX2 ('[] @(Maybe Nat)) x)
xindex0 = target (TKX2 sh1 x)
-> IxXOf target sh1 -> target (TKX2 ('[] @(Maybe Nat)) x)
forall (sh1 :: [Maybe Nat]) (x :: TK).
(KnownShX sh1, KnownSTK x) =>
target (TKX2 sh1 x)
-> IxXOf target sh1 -> target (TKX2 ('[] @(Maybe Nat)) x)
forall (target :: Target) (sh1 :: [Maybe Nat]) (x :: TK).
(BaseTensor target, KnownShX sh1, KnownSTK x) =>
target (TKX2 sh1 x)
-> IxXOf target sh1 -> target (TKX2 ('[] @(Maybe Nat)) x)
txindex0
xoneHot :: ( KnownShX sh1, KnownShX sh2, KnownSTK x
           , BoolOf (PrimalOf target) ~ BoolOf target
           , EqH (PrimalOf target) (TKScalar Int64)
           , BaseTensor target, ConvertTensor target )
        => IShX sh1 -> target (TKX2 sh2 x) -> IxXOf target sh1
        -> target (TKX2 (sh1 ++ sh2) x)
xoneHot :: forall (sh1 :: [Maybe Nat]) (sh2 :: [Maybe Nat]) (x :: TK)
       (target :: Target).
(KnownShX sh1, KnownShX sh2, KnownSTK x,
 (BoolOf (PrimalOf target) :: Type) ~ (BoolOf target :: Type),
 EqH (PrimalOf target) (TKScalar Int64), BaseTensor target,
 ConvertTensor target) =>
IShX sh1
-> target (TKX2 sh2 x)
-> IxXOf target sh1
-> target (TKX2 ((++) @(Maybe Nat) sh1 sh2) x)
xoneHot = IShX sh1
-> target (TKX2 sh2 x)
-> IxXOf target sh1
-> target (TKX2 ((++) @(Maybe Nat) sh1 sh2) x)
forall (sh1 :: [Maybe Nat]) (sh2 :: [Maybe Nat]) (x :: TK).
(KnownShX sh1, KnownShX sh2, KnownSTK x,
 (BoolOf (PrimalOf target) :: Type) ~ (BoolOf target :: Type),
 EqH (PrimalOf target) (TKScalar Int64), ConvertTensor target) =>
IShX sh1
-> target (TKX2 sh2 x)
-> IxXOf target sh1
-> target (TKX2 ((++) @(Maybe Nat) sh1 sh2) x)
forall (target :: Target) (sh1 :: [Maybe Nat]) (sh2 :: [Maybe Nat])
       (x :: TK).
(BaseTensor target, KnownShX sh1, KnownShX sh2, KnownSTK x,
 (BoolOf (PrimalOf target) :: Type) ~ (BoolOf target :: Type),
 EqH (PrimalOf target) (TKScalar Int64), ConvertTensor target) =>
IShX sh1
-> target (TKX2 sh2 x)
-> IxXOf target sh1
-> target (TKX2 ((++) @(Maybe Nat) sh1 sh2) x)
txoneHot
xscatter :: ( KnownShX shm, KnownShX shn, KnownShX shp, KnownSTK x
            , BaseTensor target )
         => IShX (shp ++ shn) -> target (TKX2 (shm ++ shn) x)
         -> (IxXOf target shm -> IxXOf target shp)
         -> target (TKX2 (shp ++ shn) x)
xscatter :: forall (shm :: [Maybe Nat]) (shn :: [Maybe Nat])
       (shp :: [Maybe Nat]) (x :: TK) (target :: Target).
(KnownShX shm, KnownShX shn, KnownShX shp, KnownSTK x,
 BaseTensor target) =>
IShX ((++) @(Maybe Nat) shp shn)
-> target (TKX2 ((++) @(Maybe Nat) shm shn) x)
-> (IxXOf target shm -> IxXOf target shp)
-> target (TKX2 ((++) @(Maybe Nat) shp shn) x)
xscatter @shm @shn @shp = forall (target :: Target) (shm :: [Maybe Nat]) (shn :: [Maybe Nat])
       (shp :: [Maybe Nat]) (x :: TK).
(BaseTensor target, KnownShX shm, KnownShX shn, KnownShX shp,
 KnownSTK x) =>
IShX ((++) @(Maybe Nat) shp shn)
-> target (TKX2 ((++) @(Maybe Nat) shm shn) x)
-> (IxXOf target shm -> IxXOf target shp)
-> target (TKX2 ((++) @(Maybe Nat) shp shn) x)
txscatter @_ @shm @shn @shp
xscatter1 :: ( KnownNat n2, KnownShX shn, KnownShX shp, KnownSTK x
             , BaseTensor target )
          => IShX (shp ++ shn) -> target (TKX2 (Just n2 ': shn) x)
          -> (IntOf target -> IxXOf target shp)
          -> target (TKX2 (shp ++ shn) x)
xscatter1 :: forall (n2 :: Nat) (shn :: [Maybe Nat]) (shp :: [Maybe Nat])
       (x :: TK) (target :: Target).
(KnownNat n2, KnownShX shn, KnownShX shp, KnownSTK x,
 BaseTensor target) =>
IShX ((++) @(Maybe Nat) shp shn)
-> target (TKX2 ((':) @(Maybe Nat) ('Just @Nat n2) shn) x)
-> (IntOf target -> IxXOf target shp)
-> target (TKX2 ((++) @(Maybe Nat) shp shn) x)
xscatter1 = IShX ((++) @(Maybe Nat) shp shn)
-> target (TKX2 ((':) @(Maybe Nat) ('Just @Nat n2) shn) x)
-> (IntOf target -> IxXOf target shp)
-> target (TKX2 ((++) @(Maybe Nat) shp shn) x)
forall (n2 :: Nat) (shn :: [Maybe Nat]) (shp :: [Maybe Nat])
       (x :: TK).
(KnownNat n2, KnownShX shn, KnownShX shp, KnownSTK x) =>
IShX ((++) @(Maybe Nat) shp shn)
-> target (TKX2 ((':) @(Maybe Nat) ('Just @Nat n2) shn) x)
-> (IntOf target -> IxXOf target shp)
-> target (TKX2 ((++) @(Maybe Nat) shp shn) x)
forall (target :: Target) (n2 :: Nat) (shn :: [Maybe Nat])
       (shp :: [Maybe Nat]) (x :: TK).
(BaseTensor target, KnownNat n2, KnownShX shn, KnownShX shp,
 KnownSTK x) =>
IShX ((++) @(Maybe Nat) shp shn)
-> target (TKX2 ((':) @(Maybe Nat) ('Just @Nat n2) shn) x)
-> (IntOf target -> IxXOf target shp)
-> target (TKX2 ((++) @(Maybe Nat) shp shn) x)
txscatter1
xgather :: ( KnownShX shm, KnownShX shn, KnownShX shp, KnownSTK x
           , BaseTensor target )
        => IShX (shm ++ shn)
        -> target (TKX2 (shp ++ shn) x)
        -> (IxXOf target shm -> IxXOf target shp)
        -> target (TKX2 (shm ++ shn) x)
xgather :: forall (shm :: [Maybe Nat]) (shn :: [Maybe Nat])
       (shp :: [Maybe Nat]) (x :: TK) (target :: Target).
(KnownShX shm, KnownShX shn, KnownShX shp, KnownSTK x,
 BaseTensor target) =>
IShX ((++) @(Maybe Nat) shm shn)
-> target (TKX2 ((++) @(Maybe Nat) shp shn) x)
-> (IxXOf target shm -> IxXOf target shp)
-> target (TKX2 ((++) @(Maybe Nat) shm shn) x)
xgather @shm @shn @shp = forall (target :: Target) (shm :: [Maybe Nat]) (shn :: [Maybe Nat])
       (shp :: [Maybe Nat]) (x :: TK).
(BaseTensor target, KnownShX shm, KnownShX shn, KnownShX shp,
 KnownSTK x) =>
IShX ((++) @(Maybe Nat) shm shn)
-> target (TKX2 ((++) @(Maybe Nat) shp shn) x)
-> (IxXOf target shm -> IxXOf target shp)
-> target (TKX2 ((++) @(Maybe Nat) shm shn) x)
txgather @_ @shm @shn @shp
xgather1 :: ( KnownNat n2, KnownShX shn, KnownShX shp, KnownSTK x
            , BaseTensor target )
         => SNat n2 -> target (TKX2 (shp ++ shn) x)
         -> (IntOf target -> IxXOf target shp)
         -> target (TKX2 (Just n2 ': shn) x)
xgather1 :: forall (n2 :: Nat) (shn :: [Maybe Nat]) (shp :: [Maybe Nat])
       (x :: TK) (target :: Target).
(KnownNat n2, KnownShX shn, KnownShX shp, KnownSTK x,
 BaseTensor target) =>
SNat n2
-> target (TKX2 ((++) @(Maybe Nat) shp shn) x)
-> (IntOf target -> IxXOf target shp)
-> target (TKX2 ((':) @(Maybe Nat) ('Just @Nat n2) shn) x)
xgather1 = SNat n2
-> target (TKX2 ((++) @(Maybe Nat) shp shn) x)
-> (IntOf target -> IxXOf target shp)
-> target (TKX2 ((':) @(Maybe Nat) ('Just @Nat n2) shn) x)
forall (n2 :: Nat) (shn :: [Maybe Nat]) (shp :: [Maybe Nat])
       (x :: TK).
(KnownNat n2, KnownShX shn, KnownShX shp, KnownSTK x) =>
SNat n2
-> target (TKX2 ((++) @(Maybe Nat) shp shn) x)
-> (IntOf target -> IxXOf target shp)
-> target (TKX2 ((':) @(Maybe Nat) ('Just @Nat n2) shn) x)
forall (target :: Target) (n2 :: Nat) (shn :: [Maybe Nat])
       (shp :: [Maybe Nat]) (x :: TK).
(BaseTensor target, KnownNat n2, KnownShX shn, KnownShX shp,
 KnownSTK x) =>
SNat n2
-> target (TKX2 ((++) @(Maybe Nat) shp shn) x)
-> (IntOf target -> IxXOf target shp)
-> target (TKX2 ((':) @(Maybe Nat) ('Just @Nat n2) shn) x)
txgather1

-- | Transpose according to the permutation.
rtranspose :: forall n x target. (KnownSTK x, BaseTensor target)
           => Permutation.PermR -> target (TKR2 n x) -> target (TKR2 n x)
rtranspose :: forall (n :: Nat) (x :: TK) (target :: Target).
(KnownSTK x, BaseTensor target) =>
PermR -> target (TKR2 n x) -> target (TKR2 n x)
rtranspose = PermR -> target (TKR2 n x) -> target (TKR2 n x)
forall (n :: Nat) (x :: TK).
KnownSTK x =>
PermR -> target (TKR2 n x) -> target (TKR2 n x)
forall (target :: Target) (n :: Nat) (x :: TK).
(BaseTensor target, KnownSTK x) =>
PermR -> target (TKR2 n x) -> target (TKR2 n x)
trtranspose
-- | Change the shape of the tensor to the given one.
rreshape :: forall n m x target. (KnownSTK x, BaseTensor target)
         => IShR m -> target (TKR2 n x) -> target (TKR2 m x)
rreshape :: forall (n :: Nat) (m :: Nat) (x :: TK) (target :: Target).
(KnownSTK x, BaseTensor target) =>
IShR m -> target (TKR2 n x) -> target (TKR2 m x)
rreshape = IShR m -> target (TKR2 n x) -> target (TKR2 m x)
forall (n :: Nat) (m :: Nat) (x :: TK).
KnownSTK x =>
IShR m -> target (TKR2 n x) -> target (TKR2 m x)
forall (target :: Target) (n :: Nat) (m :: Nat) (x :: TK).
(BaseTensor target, KnownSTK x) =>
IShR m -> target (TKR2 n x) -> target (TKR2 m x)
trreshape
stranspose :: ( Permutation.KnownPerm perm, Permutation.IsPermutation perm
              , Rank perm <= Rank sh, KnownSTK x, BaseTensor target )
           => target (TKS2 sh x)
           -> target (TKS2 (Permutation.PermutePrefix perm sh) x)
stranspose :: forall (perm :: [Nat]) (sh :: [Nat]) (x :: TK) (target :: Target).
(KnownPerm perm, IsPermutation perm,
 (<=) @Nat (Rank @Nat perm) (Rank @Nat sh), KnownSTK x,
 BaseTensor target) =>
target (TKS2 sh x) -> target (TKS2 (PermutePrefix @Nat perm sh) x)
stranspose @perm = Perm perm
-> target (TKS2 sh x)
-> target (TKS2 (PermutePrefix @Nat perm sh) x)
forall (perm :: [Nat]) (sh :: [Nat]) (x :: TK).
(IsPermutation perm, (<=) @Nat (Rank @Nat perm) (Rank @Nat sh),
 KnownSTK x) =>
Perm perm
-> target (TKS2 sh x)
-> target (TKS2 (PermutePrefix @Nat perm sh) x)
forall (target :: Target) (perm :: [Nat]) (sh :: [Nat]) (x :: TK).
(BaseTensor target, IsPermutation perm,
 (<=) @Nat (Rank @Nat perm) (Rank @Nat sh), KnownSTK x) =>
Perm perm
-> target (TKS2 sh x)
-> target (TKS2 (PermutePrefix @Nat perm sh) x)
tstranspose (forall (l :: [Nat]). KnownPerm l => Perm l
Permutation.makePerm @perm)
sreshape :: ( Nested.Product sh ~ Nested.Product sh2, KnownShS sh2
            , KnownSTK x, BaseTensor target )
         => target (TKS2 sh x) -> target (TKS2 sh2 x)
sreshape :: forall (sh :: [Nat]) (sh2 :: [Nat]) (x :: TK) (target :: Target).
((Product sh :: Nat) ~ (Product sh2 :: Nat), KnownShS sh2,
 KnownSTK x, BaseTensor target) =>
target (TKS2 sh x) -> target (TKS2 sh2 x)
sreshape = ShS sh2 -> target (TKS2 sh x) -> target (TKS2 sh2 x)
forall (sh :: [Nat]) (sh2 :: [Nat]) (x :: TK).
((Product sh :: Nat) ~ (Product sh2 :: Nat), KnownSTK x) =>
ShS sh2 -> target (TKS2 sh x) -> target (TKS2 sh2 x)
forall (target :: Target) (sh :: [Nat]) (sh2 :: [Nat]) (x :: TK).
(BaseTensor target, (Product sh :: Nat) ~ (Product sh2 :: Nat),
 KnownSTK x) =>
ShS sh2 -> target (TKS2 sh x) -> target (TKS2 sh2 x)
tsreshape ShS sh2
forall (sh :: [Nat]). KnownShS sh => ShS sh
knownShS
xtranspose :: ( Permutation.KnownPerm perm, Permutation.IsPermutation perm
              , Rank perm <= Rank sh, KnownSTK x, BaseTensor target )
           => target (TKX2 sh x)
           -> target (TKX2 (Permutation.PermutePrefix perm sh) x)
xtranspose :: forall (perm :: [Nat]) (sh :: [Maybe Nat]) (x :: TK)
       (target :: Target).
(KnownPerm perm, IsPermutation perm,
 (<=) @Nat (Rank @Nat perm) (Rank @(Maybe Nat) sh), KnownSTK x,
 BaseTensor target) =>
target (TKX2 sh x)
-> target (TKX2 (PermutePrefix @(Maybe Nat) perm sh) x)
xtranspose @perm = Perm perm
-> target (TKX2 sh x)
-> target (TKX2 (PermutePrefix @(Maybe Nat) perm sh) x)
forall (perm :: [Nat]) (sh :: [Maybe Nat]) (x :: TK).
(IsPermutation perm,
 (<=) @Nat (Rank @Nat perm) (Rank @(Maybe Nat) sh), KnownSTK x) =>
Perm perm
-> target (TKX2 sh x)
-> target (TKX2 (PermutePrefix @(Maybe Nat) perm sh) x)
forall (target :: Target) (perm :: [Nat]) (sh :: [Maybe Nat])
       (x :: TK).
(BaseTensor target, IsPermutation perm,
 (<=) @Nat (Rank @Nat perm) (Rank @(Maybe Nat) sh), KnownSTK x) =>
Perm perm
-> target (TKX2 sh x)
-> target (TKX2 (PermutePrefix @(Maybe Nat) perm sh) x)
txtranspose (forall (l :: [Nat]). KnownPerm l => Perm l
Permutation.makePerm @perm)
xreshape :: forall sh sh2 x target. (KnownSTK x, BaseTensor target)
         => IShX sh2 -> target (TKX2 sh x) -> target (TKX2 sh2 x)
xreshape :: forall (sh :: [Maybe Nat]) (sh2 :: [Maybe Nat]) (x :: TK)
       (target :: Target).
(KnownSTK x, BaseTensor target) =>
IShX sh2 -> target (TKX2 sh x) -> target (TKX2 sh2 x)
xreshape = IShX sh2 -> target (TKX2 sh x) -> target (TKX2 sh2 x)
forall (sh :: [Maybe Nat]) (sh2 :: [Maybe Nat]) (x :: TK).
KnownSTK x =>
IShX sh2 -> target (TKX2 sh x) -> target (TKX2 sh2 x)
forall (target :: Target) (sh :: [Maybe Nat]) (sh2 :: [Maybe Nat])
       (x :: TK).
(BaseTensor target, KnownSTK x) =>
IShX sh2 -> target (TKX2 sh x) -> target (TKX2 sh2 x)
txreshape

rfloor :: ( GoodScalar r, RealFrac r, GoodScalar r2, Integral r2
          , BaseTensor target )
       => target (TKR n r) -> target (TKR n r2)
rfloor :: forall r r2 (target :: Target) (n :: Nat).
(GoodScalar r, RealFrac r, GoodScalar r2, Integral r2,
 BaseTensor target) =>
target (TKR n r) -> target (TKR n r2)
rfloor = target (TKR n r) -> target (TKR n r2)
forall r r2 (n :: Nat).
(GoodScalar r, RealFrac r, GoodScalar r2, Integral r2) =>
target (TKR n r) -> target (TKR n r2)
forall (target :: Target) r r2 (n :: Nat).
(BaseTensor target, GoodScalar r, RealFrac r, GoodScalar r2,
 Integral r2) =>
target (TKR n r) -> target (TKR n r2)
trfloor
rfromIntegral :: (GoodScalar r1, Integral r1, GoodScalar r2, BaseTensor target)
              => target (TKR n r1) -> target (TKR n r2)
rfromIntegral :: forall r1 r2 (target :: Target) (n :: Nat).
(GoodScalar r1, Integral r1, GoodScalar r2, BaseTensor target) =>
target (TKR n r1) -> target (TKR n r2)
rfromIntegral = target (TKR n r1) -> target (TKR n r2)
forall r1 r2 (n :: Nat).
(GoodScalar r1, Integral r1, GoodScalar r2) =>
target (TKR n r1) -> target (TKR n r2)
forall (target :: Target) r1 r2 (n :: Nat).
(BaseTensor target, GoodScalar r1, Integral r1, GoodScalar r2) =>
target (TKR n r1) -> target (TKR n r2)
trfromIntegral
rcast :: ( RealFrac r1, GoodScalar r1, RealFrac r2, GoodScalar r2
         , BaseTensor target )
      => target (TKR n r1) -> target (TKR n r2)
rcast :: forall r1 r2 (target :: Target) (n :: Nat).
(RealFrac r1, GoodScalar r1, RealFrac r2, GoodScalar r2,
 BaseTensor target) =>
target (TKR n r1) -> target (TKR n r2)
rcast = target (TKR n r1) -> target (TKR n r2)
forall r1 r2 (n :: Nat).
(RealFrac r1, GoodScalar r1, RealFrac r2, GoodScalar r2) =>
target (TKR n r1) -> target (TKR n r2)
forall (target :: Target) r1 r2 (n :: Nat).
(BaseTensor target, RealFrac r1, GoodScalar r1, RealFrac r2,
 GoodScalar r2) =>
target (TKR n r1) -> target (TKR n r2)
trcast
rminIndex, rmaxIndex  -- partial
  :: forall n r r2 target. (GoodScalar r, GoodScalar r2, BaseTensor target)
  => target (TKR (1 + n) r) -> target (TKR n r2)
rminIndex :: forall (n :: Nat) r r2 (target :: Target).
(GoodScalar r, GoodScalar r2, BaseTensor target) =>
target (TKR (1 + n) r) -> target (TKR n r2)
rminIndex = target (TKR (1 + n) r) -> target (TKR n r2)
forall (n :: Nat) r r2.
(GoodScalar r, GoodScalar r2) =>
target (TKR (1 + n) r) -> target (TKR n r2)
forall (target :: Target) (n :: Nat) r r2.
(BaseTensor target, GoodScalar r, GoodScalar r2) =>
target (TKR (1 + n) r) -> target (TKR n r2)
trminIndex
rmaxIndex :: forall (n :: Nat) r r2 (target :: Target).
(GoodScalar r, GoodScalar r2, BaseTensor target) =>
target (TKR (1 + n) r) -> target (TKR n r2)
rmaxIndex = target (TKR (1 + n) r) -> target (TKR n r2)
forall (n :: Nat) r r2.
(GoodScalar r, GoodScalar r2) =>
target (TKR (1 + n) r) -> target (TKR n r2)
forall (target :: Target) (n :: Nat) r r2.
(BaseTensor target, GoodScalar r, GoodScalar r2) =>
target (TKR (1 + n) r) -> target (TKR n r2)
trmaxIndex
riota :: (GoodScalar r, BaseTensor target)
      => Int -> target (TKR 1 r)  -- from 0 to n - 1
riota :: forall r (target :: Target).
(GoodScalar r, BaseTensor target) =>
Int -> target (TKR 1 r)
riota = Int -> target (TKR 1 r)
forall r. GoodScalar r => Int -> target (TKR 1 r)
forall (target :: Target) r.
(BaseTensor target, GoodScalar r) =>
Int -> target (TKR 1 r)
triota

sfloor :: ( GoodScalar r, RealFrac r, GoodScalar r2, Integral r2
          , BaseTensor target )
       => target (TKS sh r) -> target (TKS sh r2)
sfloor :: forall r r2 (target :: Target) (sh :: [Nat]).
(GoodScalar r, RealFrac r, GoodScalar r2, Integral r2,
 BaseTensor target) =>
target (TKS sh r) -> target (TKS sh r2)
sfloor = target (TKS sh r) -> target (TKS sh r2)
forall r r2 (sh :: [Nat]).
(GoodScalar r, RealFrac r, GoodScalar r2, Integral r2) =>
target (TKS sh r) -> target (TKS sh r2)
forall (target :: Target) r r2 (sh :: [Nat]).
(BaseTensor target, GoodScalar r, RealFrac r, GoodScalar r2,
 Integral r2) =>
target (TKS sh r) -> target (TKS sh r2)
tsfloor
sfromIntegral :: (GoodScalar r1, Integral r1, GoodScalar r2, BaseTensor target)
              => target (TKS sh r1) -> target (TKS sh r2)
sfromIntegral :: forall r1 r2 (target :: Target) (sh :: [Nat]).
(GoodScalar r1, Integral r1, GoodScalar r2, BaseTensor target) =>
target (TKS sh r1) -> target (TKS sh r2)
sfromIntegral = target (TKS sh r1) -> target (TKS sh r2)
forall r1 r2 (sh :: [Nat]).
(GoodScalar r1, Integral r1, GoodScalar r2) =>
target (TKS sh r1) -> target (TKS sh r2)
forall (target :: Target) r1 r2 (sh :: [Nat]).
(BaseTensor target, GoodScalar r1, Integral r1, GoodScalar r2) =>
target (TKS sh r1) -> target (TKS sh r2)
tsfromIntegral
scast :: ( RealFrac r1, GoodScalar r1, RealFrac r2, GoodScalar r2
         , BaseTensor target )
      => target (TKS sh r1) -> target (TKS sh r2)
scast :: forall r1 r2 (target :: Target) (sh :: [Nat]).
(RealFrac r1, GoodScalar r1, RealFrac r2, GoodScalar r2,
 BaseTensor target) =>
target (TKS sh r1) -> target (TKS sh r2)
scast = target (TKS sh r1) -> target (TKS sh r2)
forall r1 r2 (sh :: [Nat]).
(RealFrac r1, GoodScalar r1, RealFrac r2, GoodScalar r2) =>
target (TKS sh r1) -> target (TKS sh r2)
forall (target :: Target) r1 r2 (sh :: [Nat]).
(BaseTensor target, RealFrac r1, GoodScalar r1, RealFrac r2,
 GoodScalar r2) =>
target (TKS sh r1) -> target (TKS sh r2)
tscast
sminIndex, smaxIndex  -- partial
  :: forall n sh r r2 target. (GoodScalar r, GoodScalar r2, BaseTensor target)
  => target (TKS (n ': sh) r) -> target (TKS (Init (n ': sh)) r2)
sminIndex :: forall (n :: Nat) (sh :: [Nat]) r r2 (target :: Target).
(GoodScalar r, GoodScalar r2, BaseTensor target) =>
target (TKS ((':) @Nat n sh) r)
-> target (TKS (Init @Nat ((':) @Nat n sh)) r2)
sminIndex = target (TKS ((':) @Nat n sh) r)
-> target (TKS (Init @Nat ((':) @Nat n sh)) r2)
forall (n :: Nat) (sh :: [Nat]) r r2.
(GoodScalar r, GoodScalar r2) =>
target (TKS ((':) @Nat n sh) r)
-> target (TKS (Init @Nat ((':) @Nat n sh)) r2)
forall (target :: Target) (n :: Nat) (sh :: [Nat]) r r2.
(BaseTensor target, GoodScalar r, GoodScalar r2) =>
target (TKS ((':) @Nat n sh) r)
-> target (TKS (Init @Nat ((':) @Nat n sh)) r2)
tsminIndex
smaxIndex :: forall (n :: Nat) (sh :: [Nat]) r r2 (target :: Target).
(GoodScalar r, GoodScalar r2, BaseTensor target) =>
target (TKS ((':) @Nat n sh) r)
-> target (TKS (Init @Nat ((':) @Nat n sh)) r2)
smaxIndex = target (TKS ((':) @Nat n sh) r)
-> target (TKS (Init @Nat ((':) @Nat n sh)) r2)
forall (n :: Nat) (sh :: [Nat]) r r2.
(GoodScalar r, GoodScalar r2) =>
target (TKS ((':) @Nat n sh) r)
-> target (TKS (Init @Nat ((':) @Nat n sh)) r2)
forall (target :: Target) (n :: Nat) (sh :: [Nat]) r r2.
(BaseTensor target, GoodScalar r, GoodScalar r2) =>
target (TKS ((':) @Nat n sh) r)
-> target (TKS (Init @Nat ((':) @Nat n sh)) r2)
tsmaxIndex
siota :: (KnownNat n, GoodScalar r, BaseTensor target)
      => target (TKS '[n] r)  -- from 0 to n - 1
siota :: forall (n :: Nat) r (target :: Target).
(KnownNat n, GoodScalar r, BaseTensor target) =>
target (TKS ((':) @Nat n ('[] @Nat)) r)
siota = target (TKS ((':) @Nat n ('[] @Nat)) r)
forall (n :: Nat) r.
(KnownNat n, GoodScalar r) =>
target (TKS ((':) @Nat n ('[] @Nat)) r)
forall (target :: Target) (n :: Nat) r.
(BaseTensor target, KnownNat n, GoodScalar r) =>
target (TKS ((':) @Nat n ('[] @Nat)) r)
tsiota

xfloor :: ( GoodScalar r, RealFrac r, GoodScalar r2, Integral r2
          , BaseTensor target )
       => target (TKX sh r) -> target (TKX sh r2)
xfloor :: forall r r2 (target :: Target) (sh :: [Maybe Nat]).
(GoodScalar r, RealFrac r, GoodScalar r2, Integral r2,
 BaseTensor target) =>
target (TKX sh r) -> target (TKX sh r2)
xfloor = target (TKX sh r) -> target (TKX sh r2)
forall r r2 (sh :: [Maybe Nat]).
(GoodScalar r, RealFrac r, GoodScalar r2, Integral r2) =>
target (TKX sh r) -> target (TKX sh r2)
forall (target :: Target) r r2 (sh :: [Maybe Nat]).
(BaseTensor target, GoodScalar r, RealFrac r, GoodScalar r2,
 Integral r2) =>
target (TKX sh r) -> target (TKX sh r2)
txfloor
xfromIntegral :: (GoodScalar r1, Integral r1, GoodScalar r2, BaseTensor target)
              => target (TKX sh r1) -> target (TKX sh r2)
xfromIntegral :: forall r1 r2 (target :: Target) (sh :: [Maybe Nat]).
(GoodScalar r1, Integral r1, GoodScalar r2, BaseTensor target) =>
target (TKX sh r1) -> target (TKX sh r2)
xfromIntegral = target (TKX sh r1) -> target (TKX sh r2)
forall r1 r2 (sh :: [Maybe Nat]).
(GoodScalar r1, Integral r1, GoodScalar r2) =>
target (TKX sh r1) -> target (TKX sh r2)
forall (target :: Target) r1 r2 (sh :: [Maybe Nat]).
(BaseTensor target, GoodScalar r1, Integral r1, GoodScalar r2) =>
target (TKX sh r1) -> target (TKX sh r2)
txfromIntegral
xcast :: ( RealFrac r1, GoodScalar r1, RealFrac r2, GoodScalar r2
         , BaseTensor target )
      => target (TKX sh r1) -> target (TKX sh r2)
xcast :: forall r1 r2 (target :: Target) (sh :: [Maybe Nat]).
(RealFrac r1, GoodScalar r1, RealFrac r2, GoodScalar r2,
 BaseTensor target) =>
target (TKX sh r1) -> target (TKX sh r2)
xcast = target (TKX sh r1) -> target (TKX sh r2)
forall r1 r2 (sh :: [Maybe Nat]).
(RealFrac r1, GoodScalar r1, RealFrac r2, GoodScalar r2) =>
target (TKX sh r1) -> target (TKX sh r2)
forall (target :: Target) r1 r2 (sh :: [Maybe Nat]).
(BaseTensor target, RealFrac r1, GoodScalar r1, RealFrac r2,
 GoodScalar r2) =>
target (TKX sh r1) -> target (TKX sh r2)
txcast
xminIndex, xmaxIndex  -- partial
  :: forall mn sh r r2 target. (GoodScalar r, GoodScalar r2, BaseTensor target)
  => target (TKX (mn ': sh) r) -> target (TKX (Init (mn ': sh)) r2)
xminIndex :: forall (mn :: Maybe Nat) (sh :: [Maybe Nat]) r r2
       (target :: Target).
(GoodScalar r, GoodScalar r2, BaseTensor target) =>
target (TKX ((':) @(Maybe Nat) mn sh) r)
-> target (TKX (Init @(Maybe Nat) ((':) @(Maybe Nat) mn sh)) r2)
xminIndex = target (TKX ((':) @(Maybe Nat) mn sh) r)
-> target (TKX (Init @(Maybe Nat) ((':) @(Maybe Nat) mn sh)) r2)
forall (mn :: Maybe Nat) (sh :: [Maybe Nat]) r r2.
(GoodScalar r, GoodScalar r2) =>
target (TKX ((':) @(Maybe Nat) mn sh) r)
-> target (TKX (Init @(Maybe Nat) ((':) @(Maybe Nat) mn sh)) r2)
forall (target :: Target) (mn :: Maybe Nat) (sh :: [Maybe Nat]) r
       r2.
(BaseTensor target, GoodScalar r, GoodScalar r2) =>
target (TKX ((':) @(Maybe Nat) mn sh) r)
-> target (TKX (Init @(Maybe Nat) ((':) @(Maybe Nat) mn sh)) r2)
txminIndex
xmaxIndex :: forall (mn :: Maybe Nat) (sh :: [Maybe Nat]) r r2
       (target :: Target).
(GoodScalar r, GoodScalar r2, BaseTensor target) =>
target (TKX ((':) @(Maybe Nat) mn sh) r)
-> target (TKX (Init @(Maybe Nat) ((':) @(Maybe Nat) mn sh)) r2)
xmaxIndex = target (TKX ((':) @(Maybe Nat) mn sh) r)
-> target (TKX (Init @(Maybe Nat) ((':) @(Maybe Nat) mn sh)) r2)
forall (mn :: Maybe Nat) (sh :: [Maybe Nat]) r r2.
(GoodScalar r, GoodScalar r2) =>
target (TKX ((':) @(Maybe Nat) mn sh) r)
-> target (TKX (Init @(Maybe Nat) ((':) @(Maybe Nat) mn sh)) r2)
forall (target :: Target) (mn :: Maybe Nat) (sh :: [Maybe Nat]) r
       r2.
(BaseTensor target, GoodScalar r, GoodScalar r2) =>
target (TKX ((':) @(Maybe Nat) mn sh) r)
-> target (TKX (Init @(Maybe Nat) ((':) @(Maybe Nat) mn sh)) r2)
txmaxIndex
xiota :: (KnownNat n, GoodScalar r, BaseTensor target)
      => target (TKX '[Just n] r)  -- from 0 to n - 1
xiota :: forall (n :: Nat) r (target :: Target).
(KnownNat n, GoodScalar r, BaseTensor target) =>
target
  (TKX ((':) @(Maybe Nat) ('Just @Nat n) ('[] @(Maybe Nat))) r)
xiota = target
  (TKX ((':) @(Maybe Nat) ('Just @Nat n) ('[] @(Maybe Nat))) r)
forall (n :: Nat) r.
(KnownNat n, GoodScalar r) =>
target
  (TKX ((':) @(Maybe Nat) ('Just @Nat n) ('[] @(Maybe Nat))) r)
forall (target :: Target) (n :: Nat) r.
(BaseTensor target, KnownNat n, GoodScalar r) =>
target
  (TKX ((':) @(Maybe Nat) ('Just @Nat n) ('[] @(Maybe Nat))) r)
txiota

kfloor :: ( GoodScalar r, RealFrac r, GoodScalar r2, Integral r2
          , BaseTensor target )
       => target (TKScalar r) -> target (TKScalar r2)
kfloor :: forall r r2 (target :: Target).
(GoodScalar r, RealFrac r, GoodScalar r2, Integral r2,
 BaseTensor target) =>
target (TKScalar r) -> target (TKScalar r2)
kfloor = target (TKScalar r) -> target (TKScalar r2)
forall r r2.
(GoodScalar r, RealFrac r, GoodScalar r2, Integral r2) =>
target (TKScalar r) -> target (TKScalar r2)
forall (target :: Target) r r2.
(BaseTensor target, GoodScalar r, RealFrac r, GoodScalar r2,
 Integral r2) =>
target (TKScalar r) -> target (TKScalar r2)
tkfloor
kfromIntegral :: (GoodScalar r1, Integral r1, GoodScalar r2, BaseTensor target)
              => target (TKScalar r1) -> target (TKScalar r2)
kfromIntegral :: forall r1 r2 (target :: Target).
(GoodScalar r1, Integral r1, GoodScalar r2, BaseTensor target) =>
target (TKScalar r1) -> target (TKScalar r2)
kfromIntegral = target (TKScalar r1) -> target (TKScalar r2)
forall r1 r2.
(GoodScalar r1, Integral r1, GoodScalar r2) =>
target (TKScalar r1) -> target (TKScalar r2)
forall (target :: Target) r1 r2.
(BaseTensor target, GoodScalar r1, Integral r1, GoodScalar r2) =>
target (TKScalar r1) -> target (TKScalar r2)
tkfromIntegral
kcast :: ( RealFrac r1, GoodScalar r1, RealFrac r2, GoodScalar r2
         , BaseTensor target )
      => target (TKScalar r1) -> target (TKScalar r2)
kcast :: forall r1 r2 (target :: Target).
(RealFrac r1, GoodScalar r1, RealFrac r2, GoodScalar r2,
 BaseTensor target) =>
target (TKScalar r1) -> target (TKScalar r2)
kcast = target (TKScalar r1) -> target (TKScalar r2)
forall r1 r2.
(RealFrac r1, GoodScalar r1, RealFrac r2, GoodScalar r2) =>
target (TKScalar r1) -> target (TKScalar r2)
forall (target :: Target) r1 r2.
(BaseTensor target, RealFrac r1, GoodScalar r1, RealFrac r2,
 GoodScalar r2) =>
target (TKScalar r1) -> target (TKScalar r2)
tkcast

-- | Append two arrays along the outermost dimension.
-- All dimensions, except the outermost, must be the same.
rappend :: forall n x target. (KnownSTK x, BaseTensor target)
        => target (TKR2 (1 + n) x) -> target (TKR2 (1 + n) x)
        -> target (TKR2 (1 + n) x)
rappend :: forall (n :: Nat) (x :: TK) (target :: Target).
(KnownSTK x, BaseTensor target) =>
target (TKR2 (1 + n) x)
-> target (TKR2 (1 + n) x) -> target (TKR2 (1 + n) x)
rappend = target (TKR2 (1 + n) x)
-> target (TKR2 (1 + n) x) -> target (TKR2 (1 + n) x)
forall (n :: Nat) (x :: TK).
KnownSTK x =>
target (TKR2 (1 + n) x)
-> target (TKR2 (1 + n) x) -> target (TKR2 (1 + n) x)
forall (target :: Target) (n :: Nat) (x :: TK).
(BaseTensor target, KnownSTK x) =>
target (TKR2 (1 + n) x)
-> target (TKR2 (1 + n) x) -> target (TKR2 (1 + n) x)
trappend
rconcat :: forall n x target. (KnownSTK x, BaseTensor target)
        => NonEmpty (target (TKR2 (1 + n) x)) -> target (TKR2 (1 + n) x)
rconcat :: forall (n :: Nat) (x :: TK) (target :: Target).
(KnownSTK x, BaseTensor target) =>
NonEmpty (target (TKR2 (1 + n) x)) -> target (TKR2 (1 + n) x)
rconcat = (target (TKR2 (1 + n) x)
 -> target (TKR2 (1 + n) x) -> target (TKR2 (1 + n) x))
-> NonEmpty (target (TKR2 (1 + n) x)) -> target (TKR2 (1 + n) x)
forall a. (a -> a -> a) -> NonEmpty a -> a
forall (t :: Type -> Type) a.
Foldable t =>
(a -> a -> a) -> t a -> a
foldr1 target (TKR2 (1 + n) x)
-> target (TKR2 (1 + n) x) -> target (TKR2 (1 + n) x)
forall (n :: Nat) (x :: TK) (target :: Target).
(KnownSTK x, BaseTensor target) =>
target (TKR2 (1 + n) x)
-> target (TKR2 (1 + n) x) -> target (TKR2 (1 + n) x)
rappend
-- | Extract a slice of an array along the outermost dimension.
-- The extracted slice must fall within the dimension.
rslice :: forall n x target. (KnownSTK x, BaseTensor target)
       => Int -> Int -> target (TKR2 (1 + n) x) -> target (TKR2 (1 + n) x)
rslice :: forall (n :: Nat) (x :: TK) (target :: Target).
(KnownSTK x, BaseTensor target) =>
Int -> Int -> target (TKR2 (1 + n) x) -> target (TKR2 (1 + n) x)
rslice = Int -> Int -> target (TKR2 (1 + n) x) -> target (TKR2 (1 + n) x)
forall (n :: Nat) (x :: TK).
KnownSTK x =>
Int -> Int -> target (TKR2 (1 + n) x) -> target (TKR2 (1 + n) x)
forall (target :: Target) (n :: Nat) (x :: TK).
(BaseTensor target, KnownSTK x) =>
Int -> Int -> target (TKR2 (1 + n) x) -> target (TKR2 (1 + n) x)
trslice
runcons :: (KnownNat n, KnownSTK x, BaseTensor target)
        => target (TKR2 (1 + n) x)
        -> Maybe (target (TKR2 n x), target (TKR2 (1 + n) x))
runcons :: forall (n :: Nat) (x :: TK) (target :: Target).
(KnownNat n, KnownSTK x, BaseTensor target) =>
target (TKR2 (1 + n) x)
-> Maybe (target (TKR2 n x), target (TKR2 (1 + n) x))
runcons target (TKR2 (1 + n) x)
v = case target (TKR2 (1 + n) x) -> IShR (1 + n)
forall (n :: Nat) (x :: TK).
KnownSTK x =>
target (TKR2 n x) -> IShR n
forall (target :: Target) (n :: Nat) (x :: TK).
(BaseTensor target, KnownSTK x) =>
target (TKR2 n x) -> IShR n
rshape target (TKR2 (1 + n) x)
v of
              Int
len :$: ShR n Int
_ -> (target (TKR2 n x), target (TKR2 (1 + n) x))
-> Maybe (target (TKR2 n x), target (TKR2 (1 + n) x))
forall a. a -> Maybe a
Just (target (TKR2 (1 + n) x)
v target (TKR2 (1 + n) x)
-> IxR 1 (IntOf target) -> target (TKR2 n x)
forall (m :: Nat) (n :: Nat) (x :: TK) (target :: Target).
(KnownNat m, KnownNat n, KnownSTK x, BaseTensor target) =>
target (TKR2 (m + n) x) -> IxROf target m -> target (TKR2 n x)
! [Item (IxR 1 (IntOf target))
IntOf target
0], Int -> Int -> target (TKR2 (1 + n) x) -> target (TKR2 (1 + n) x)
forall (n :: Nat) (x :: TK) (target :: Target).
(KnownSTK x, BaseTensor target) =>
Int -> Int -> target (TKR2 (1 + n) x) -> target (TKR2 (1 + n) x)
rslice Int
1 (Int
len Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1) target (TKR2 (1 + n) x)
v)
-- | Reverse elements of the outermost dimension.
rreverse :: forall n x target. (KnownSTK x, BaseTensor target)
         => target (TKR2 (1 + n) x) -> target (TKR2 (1 + n) x)
rreverse :: forall (n :: Nat) (x :: TK) (target :: Target).
(KnownSTK x, BaseTensor target) =>
target (TKR2 (1 + n) x) -> target (TKR2 (1 + n) x)
rreverse = target (TKR2 (1 + n) x) -> target (TKR2 (1 + n) x)
forall (n :: Nat) (x :: TK).
KnownSTK x =>
target (TKR2 (1 + n) x) -> target (TKR2 (1 + n) x)
forall (target :: Target) (n :: Nat) (x :: TK).
(BaseTensor target, KnownSTK x) =>
target (TKR2 (1 + n) x) -> target (TKR2 (1 + n) x)
trreverse

sappend :: forall m n sh x target. (KnownSTK x, BaseTensor target)
        => target (TKS2 (m ': sh) x) -> target (TKS2 (n ': sh) x)
        -> target (TKS2 ((m + n) ': sh) x)
sappend :: forall (m :: Nat) (n :: Nat) (sh :: [Nat]) (x :: TK)
       (target :: Target).
(KnownSTK x, BaseTensor target) =>
target (TKS2 ((':) @Nat m sh) x)
-> target (TKS2 ((':) @Nat n sh) x)
-> target (TKS2 ((':) @Nat (m + n) sh) x)
sappend = target (TKS2 ((':) @Nat m sh) x)
-> target (TKS2 ((':) @Nat n sh) x)
-> target (TKS2 ((':) @Nat (m + n) sh) x)
forall (m :: Nat) (n :: Nat) (sh :: [Nat]) (x :: TK).
KnownSTK x =>
target (TKS2 ((':) @Nat m sh) x)
-> target (TKS2 ((':) @Nat n sh) x)
-> target (TKS2 ((':) @Nat (m + n) sh) x)
forall (target :: Target) (m :: Nat) (n :: Nat) (sh :: [Nat])
       (x :: TK).
(BaseTensor target, KnownSTK x) =>
target (TKS2 ((':) @Nat m sh) x)
-> target (TKS2 ((':) @Nat n sh) x)
-> target (TKS2 ((':) @Nat (m + n) sh) x)
tsappend
sslice :: forall i n k sh x target. (KnownSTK x, BaseTensor target)
       => SNat i -> SNat n -> SNat k
       -> target (TKS2 (i + n + k ': sh) x) -> target (TKS2 (n ': sh) x)
sslice :: forall (i :: Nat) (n :: Nat) (k :: Nat) (sh :: [Nat]) (x :: TK)
       (target :: Target).
(KnownSTK x, BaseTensor target) =>
SNat i
-> SNat n
-> SNat k
-> target (TKS2 ((':) @Nat ((i + n) + k) sh) x)
-> target (TKS2 ((':) @Nat n sh) x)
sslice = SNat i
-> SNat n
-> SNat k
-> target (TKS2 ((':) @Nat ((i + n) + k) sh) x)
-> target (TKS2 ((':) @Nat n sh) x)
forall (i :: Nat) (n :: Nat) (k :: Nat) (sh :: [Nat]) (x :: TK).
KnownSTK x =>
SNat i
-> SNat n
-> SNat k
-> target (TKS2 ((':) @Nat ((i + n) + k) sh) x)
-> target (TKS2 ((':) @Nat n sh) x)
forall (target :: Target) (i :: Nat) (n :: Nat) (k :: Nat)
       (sh :: [Nat]) (x :: TK).
(BaseTensor target, KnownSTK x) =>
SNat i
-> SNat n
-> SNat k
-> target (TKS2 ((':) @Nat ((i + n) + k) sh) x)
-> target (TKS2 ((':) @Nat n sh) x)
tsslice
suncons :: (KnownNat n, KnownShS sh, KnownSTK x, BaseTensor target)
        => target (TKS2 (n ': sh) x)
        -> Maybe (target (TKS2 sh x), target (TKS2 (n - 1 ': sh) x))
suncons :: forall (n :: Nat) (sh :: [Nat]) (x :: TK) (target :: Target).
(KnownNat n, KnownShS sh, KnownSTK x, BaseTensor target) =>
target (TKS2 ((':) @Nat n sh) x)
-> Maybe
     (target (TKS2 sh x), target (TKS2 ((':) @Nat (n - 1) sh) x))
suncons @n target (TKS2 ((':) @Nat n sh) x)
v = case Proxy @Nat 1 -> Proxy @Nat n -> OrderingI @Nat 1 n
forall (a :: Nat) (b :: Nat) (proxy1 :: Nat -> Type)
       (proxy2 :: Nat -> Type).
(KnownNat a, KnownNat b) =>
proxy1 a -> proxy2 b -> OrderingI @Nat a b
cmpNat (forall (t :: Nat). Proxy @Nat t
forall {k} (t :: k). Proxy @k t
Proxy @1) (forall (t :: Nat). Proxy @Nat t
forall {k} (t :: k). Proxy @k t
Proxy @n) of
 OrderingI @Nat 1 n
EQI -> (target (TKS2 sh x), target (TKS2 ((':) @Nat 0 sh) x))
-> Maybe (target (TKS2 sh x), target (TKS2 ((':) @Nat 0 sh) x))
forall a. a -> Maybe a
Just ( target (TKS2 ((':) @Nat n sh) x)
target (TKS2 ((++) @Nat ((':) @Nat 1 ('[] @Nat)) sh) x)
v target (TKS2 ((++) @Nat ((':) @Nat 1 ('[] @Nat)) sh) x)
-> IxSOf target ((':) @Nat 1 ('[] @Nat)) -> target (TKS2 sh x)
forall (shm :: [Nat]) (shn :: [Nat]) (x :: TK) (target :: Target).
(KnownShS shm, KnownShS shn, KnownSTK x, BaseTensor target) =>
target (TKS2 ((++) @Nat shm shn) x)
-> IxSOf target shm -> target (TKS2 shn x)
!$ (IntOf target
0 IntOf target
-> IxS ('[] @Nat) (IntOf target)
-> IxSOf target ((':) @Nat 1 ('[] @Nat))
forall {sh1 :: [Nat]} {i} (n :: Nat) (sh :: [Nat]).
(KnownNat n, ((':) @Nat n sh :: [Nat]) ~ (sh1 :: [Nat])) =>
i -> IxS sh i -> IxS sh1 i
:.$ IxS ('[] @Nat) (IntOf target)
forall (sh :: [Nat]) i.
((sh :: [Nat]) ~ ('[] @Nat :: [Nat])) =>
IxS sh i
ZIS)
             , forall (i :: Nat) (n :: Nat) (k :: Nat) (sh :: [Nat]) (x :: TK)
       (target :: Target).
(KnownSTK x, BaseTensor target) =>
SNat i
-> SNat n
-> SNat k
-> target (TKS2 ((':) @Nat ((i + n) + k) sh) x)
-> target (TKS2 ((':) @Nat n sh) x)
sslice @1 @(n - 1) @0 SNat 1
forall (n :: Nat). KnownNat n => SNat n
SNat SNat 0
SNat (n - 1)
forall (n :: Nat). KnownNat n => SNat n
SNat SNat 0
forall (n :: Nat). KnownNat n => SNat n
SNat target (TKS2 ((':) @Nat n sh) x)
target (TKS2 ((':) @Nat ((1 + (n - 1)) + 0) sh) x)
v )
 OrderingI @Nat 1 n
LTI -> (target (TKS2 sh x), target (TKS2 ((':) @Nat (n - 1) sh) x))
-> Maybe
     (target (TKS2 sh x), target (TKS2 ((':) @Nat (n - 1) sh) x))
forall a. a -> Maybe a
Just ( target (TKS2 ((':) @Nat n sh) x)
target (TKS2 ((++) @Nat ((':) @Nat n ('[] @Nat)) sh) x)
v target (TKS2 ((++) @Nat ((':) @Nat n ('[] @Nat)) sh) x)
-> IxSOf target ((':) @Nat n ('[] @Nat)) -> target (TKS2 sh x)
forall (shm :: [Nat]) (shn :: [Nat]) (x :: TK) (target :: Target).
(KnownShS shm, KnownShS shn, KnownSTK x, BaseTensor target) =>
target (TKS2 ((++) @Nat shm shn) x)
-> IxSOf target shm -> target (TKS2 shn x)
!$ (IntOf target
0 IntOf target
-> IxS ('[] @Nat) (IntOf target)
-> IxSOf target ((':) @Nat n ('[] @Nat))
forall {sh1 :: [Nat]} {i} (n :: Nat) (sh :: [Nat]).
(KnownNat n, ((':) @Nat n sh :: [Nat]) ~ (sh1 :: [Nat])) =>
i -> IxS sh i -> IxS sh1 i
:.$ IxS ('[] @Nat) (IntOf target)
forall (sh :: [Nat]) i.
((sh :: [Nat]) ~ ('[] @Nat :: [Nat])) =>
IxS sh i
ZIS)
             , forall (i :: Nat) (n :: Nat) (k :: Nat) (sh :: [Nat]) (x :: TK)
       (target :: Target).
(KnownSTK x, BaseTensor target) =>
SNat i
-> SNat n
-> SNat k
-> target (TKS2 ((':) @Nat ((i + n) + k) sh) x)
-> target (TKS2 ((':) @Nat n sh) x)
sslice @1 @(n - 1) @0 SNat 1
forall (n :: Nat). KnownNat n => SNat n
SNat SNat (n - 1)
forall (n :: Nat). KnownNat n => SNat n
SNat SNat 0
forall (n :: Nat). KnownNat n => SNat n
SNat target (TKS2 ((':) @Nat n sh) x)
target (TKS2 ((':) @Nat ((1 + (n - 1)) + 0) sh) x)
v )
 OrderingI @Nat 1 n
_ -> Maybe (target (TKS2 sh x), target (TKS2 ((':) @Nat (n - 1) sh) x))
forall a. Maybe a
Nothing
sreverse :: forall n sh x target. (KnownSTK x, BaseTensor target)
         => target (TKS2 (n ': sh) x) -> target (TKS2 (n ': sh) x)
sreverse :: forall (n :: Nat) (sh :: [Nat]) (x :: TK) (target :: Target).
(KnownSTK x, BaseTensor target) =>
target (TKS2 ((':) @Nat n sh) x)
-> target (TKS2 ((':) @Nat n sh) x)
sreverse = target (TKS2 ((':) @Nat n sh) x)
-> target (TKS2 ((':) @Nat n sh) x)
forall (n :: Nat) (sh :: [Nat]) (x :: TK).
KnownSTK x =>
target (TKS2 ((':) @Nat n sh) x)
-> target (TKS2 ((':) @Nat n sh) x)
forall (target :: Target) (n :: Nat) (sh :: [Nat]) (x :: TK).
(BaseTensor target, KnownSTK x) =>
target (TKS2 ((':) @Nat n sh) x)
-> target (TKS2 ((':) @Nat n sh) x)
tsreverse

xappend :: forall m n sh x target. (KnownSTK x, BaseTensor target)
        => target (TKX2 (Just m ': sh) x) -> target (TKX2 (Just n ': sh) x)
        -> target (TKX2 (Just (m + n) ': sh) x)
xappend :: forall (m :: Nat) (n :: Nat) (sh :: [Maybe Nat]) (x :: TK)
       (target :: Target).
(KnownSTK x, BaseTensor target) =>
target (TKX2 ((':) @(Maybe Nat) ('Just @Nat m) sh) x)
-> target (TKX2 ((':) @(Maybe Nat) ('Just @Nat n) sh) x)
-> target (TKX2 ((':) @(Maybe Nat) ('Just @Nat (m + n)) sh) x)
xappend = target (TKX2 ((':) @(Maybe Nat) ('Just @Nat m) sh) x)
-> target (TKX2 ((':) @(Maybe Nat) ('Just @Nat n) sh) x)
-> target (TKX2 ((':) @(Maybe Nat) ('Just @Nat (m + n)) sh) x)
forall (m :: Nat) (n :: Nat) (sh :: [Maybe Nat]) (x :: TK).
KnownSTK x =>
target (TKX2 ((':) @(Maybe Nat) ('Just @Nat m) sh) x)
-> target (TKX2 ((':) @(Maybe Nat) ('Just @Nat n) sh) x)
-> target (TKX2 ((':) @(Maybe Nat) ('Just @Nat (m + n)) sh) x)
forall (target :: Target) (m :: Nat) (n :: Nat) (sh :: [Maybe Nat])
       (x :: TK).
(BaseTensor target, KnownSTK x) =>
target (TKX2 ((':) @(Maybe Nat) ('Just @Nat m) sh) x)
-> target (TKX2 ((':) @(Maybe Nat) ('Just @Nat n) sh) x)
-> target (TKX2 ((':) @(Maybe Nat) ('Just @Nat (m + n)) sh) x)
txappend
xappend0 :: forall sh x target.
            (KnownSTK x, BaseTensor target, ConvertTensor target)
         => target (TKX2 (Nothing ': sh) x) -> target (TKX2 (Nothing ': sh) x)
         -> target (TKX2 (Nothing ': sh) x)
xappend0 :: forall (sh :: [Maybe Nat]) (x :: TK) (target :: Target).
(KnownSTK x, BaseTensor target, ConvertTensor target) =>
target (TKX2 ((':) @(Maybe Nat) ('Nothing @Nat) sh) x)
-> target (TKX2 ((':) @(Maybe Nat) ('Nothing @Nat) sh) x)
-> target (TKX2 ((':) @(Maybe Nat) ('Nothing @Nat) sh) x)
xappend0 target (TKX2 ((':) @(Maybe Nat) ('Nothing @Nat) sh) x)
a target (TKX2 ((':) @(Maybe Nat) ('Nothing @Nat) sh) x)
b = case target (TKX2 ((':) @(Maybe Nat) ('Nothing @Nat) sh) x)
-> IShX ((':) @(Maybe Nat) ('Nothing @Nat) sh)
forall (sh :: [Maybe Nat]) (x :: TK).
KnownSTK x =>
target (TKX2 sh x) -> IShX sh
forall (target :: Target) (sh :: [Maybe Nat]) (x :: TK).
(BaseTensor target, KnownSTK x) =>
target (TKX2 sh x) -> IShX sh
xshape target (TKX2 ((':) @(Maybe Nat) ('Nothing @Nat) sh) x)
a of
  SMayNat @Nat Int SNat n
mmsnat :$% ShX sh Int
sh ->
    Int
-> (forall (n :: Nat).
    KnownNat n =>
    SNat n -> target (TKX2 ((':) @(Maybe Nat) ('Nothing @Nat) sh) x))
-> target (TKX2 ((':) @(Maybe Nat) ('Nothing @Nat) sh) x)
forall r.
Int -> (forall (n :: Nat). KnownNat n => SNat n -> r) -> r
withSNat (SMayNat @Nat Int SNat n -> Int
forall (n :: Maybe Nat). SMayNat @Nat Int SNat n -> Int
fromSMayNat' SMayNat @Nat Int SNat n
mmsnat) ((forall (n :: Nat).
  KnownNat n =>
  SNat n -> target (TKX2 ((':) @(Maybe Nat) ('Nothing @Nat) sh) x))
 -> target (TKX2 ((':) @(Maybe Nat) ('Nothing @Nat) sh) x))
-> (forall (n :: Nat).
    KnownNat n =>
    SNat n -> target (TKX2 ((':) @(Maybe Nat) ('Nothing @Nat) sh) x))
-> target (TKX2 ((':) @(Maybe Nat) ('Nothing @Nat) sh) x)
forall a b. (a -> b) -> a -> b
$ \SNat n
msnat ->
    Int
-> (forall (n :: Nat).
    KnownNat n =>
    SNat n -> target (TKX2 ((':) @(Maybe Nat) ('Nothing @Nat) sh) x))
-> target (TKX2 ((':) @(Maybe Nat) ('Nothing @Nat) sh) x)
forall r.
Int -> (forall (n :: Nat). KnownNat n => SNat n -> r) -> r
withSNat (IShX ((':) @(Maybe Nat) ('Nothing @Nat) sh) -> Int
forall (sh :: [Maybe Nat]) i. ShX sh i -> Int
shxLength (IShX ((':) @(Maybe Nat) ('Nothing @Nat) sh) -> Int)
-> IShX ((':) @(Maybe Nat) ('Nothing @Nat) sh) -> Int
forall a b. (a -> b) -> a -> b
$ target (TKX2 ((':) @(Maybe Nat) ('Nothing @Nat) sh) x)
-> IShX ((':) @(Maybe Nat) ('Nothing @Nat) sh)
forall (sh :: [Maybe Nat]) (x :: TK).
KnownSTK x =>
target (TKX2 sh x) -> IShX sh
forall (target :: Target) (sh :: [Maybe Nat]) (x :: TK).
(BaseTensor target, KnownSTK x) =>
target (TKX2 sh x) -> IShX sh
xshape target (TKX2 ((':) @(Maybe Nat) ('Nothing @Nat) sh) x)
b) ((forall (n :: Nat).
  KnownNat n =>
  SNat n -> target (TKX2 ((':) @(Maybe Nat) ('Nothing @Nat) sh) x))
 -> target (TKX2 ((':) @(Maybe Nat) ('Nothing @Nat) sh) x))
-> (forall (n :: Nat).
    KnownNat n =>
    SNat n -> target (TKX2 ((':) @(Maybe Nat) ('Nothing @Nat) sh) x))
-> target (TKX2 ((':) @(Maybe Nat) ('Nothing @Nat) sh) x)
forall a b. (a -> b) -> a -> b
$ \SNat n
nsnat ->
    let sh0 :: StaticShX ((':) @(Maybe Nat) ('Nothing @Nat) sh)
sh0 = () -> SMayNat @Nat () SNat ('Nothing @Nat)
forall {k} i (f :: k -> Type). i -> SMayNat @k i f ('Nothing @k)
Nested.SUnknown () SMayNat @Nat () SNat ('Nothing @Nat)
-> StaticShX sh -> StaticShX ((':) @(Maybe Nat) ('Nothing @Nat) sh)
forall {sh1 :: [Maybe Nat]} (n :: Maybe Nat) (sh :: [Maybe Nat]).
(((':) @(Maybe Nat) n sh :: [Maybe Nat]) ~ (sh1 :: [Maybe Nat])) =>
SMayNat @Nat () SNat n -> StaticShX sh -> StaticShX sh1
:!% ShX sh Int -> StaticShX sh
forall (sh :: [Maybe Nat]) i. ShX sh i -> StaticShX sh
ssxFromShX ShX sh Int
sh
        sha :: StaticShX ((':) @(Maybe Nat) ('Just @Nat n) sh)
sha = SNat n -> SMayNat @Nat () SNat ('Just @Nat n)
forall {k} (f :: k -> Type) (n1 :: k) i.
f n1 -> SMayNat @k i f ('Just @k n1)
Nested.SKnown SNat n
msnat SMayNat @Nat () SNat ('Just @Nat n)
-> StaticShX sh -> StaticShX ((':) @(Maybe Nat) ('Just @Nat n) sh)
forall {sh1 :: [Maybe Nat]} (n :: Maybe Nat) (sh :: [Maybe Nat]).
(((':) @(Maybe Nat) n sh :: [Maybe Nat]) ~ (sh1 :: [Maybe Nat])) =>
SMayNat @Nat () SNat n -> StaticShX sh -> StaticShX sh1
:!% ShX sh Int -> StaticShX sh
forall (sh :: [Maybe Nat]) i. ShX sh i -> StaticShX sh
ssxFromShX ShX sh Int
sh
        shb :: StaticShX ((':) @(Maybe Nat) ('Just @Nat n) sh)
shb = SNat n -> SMayNat @Nat () SNat ('Just @Nat n)
forall {k} (f :: k -> Type) (n1 :: k) i.
f n1 -> SMayNat @k i f ('Just @k n1)
Nested.SKnown SNat n
nsnat SMayNat @Nat () SNat ('Just @Nat n)
-> StaticShX sh -> StaticShX ((':) @(Maybe Nat) ('Just @Nat n) sh)
forall {sh1 :: [Maybe Nat]} (n :: Maybe Nat) (sh :: [Maybe Nat]).
(((':) @(Maybe Nat) n sh :: [Maybe Nat]) ~ (sh1 :: [Maybe Nat])) =>
SMayNat @Nat () SNat n -> StaticShX sh -> StaticShX sh1
:!% ShX sh Int -> StaticShX sh
forall (sh :: [Maybe Nat]) i. ShX sh i -> StaticShX sh
ssxFromShX ShX sh Int
sh
    in StaticShX sh
-> (KnownShX sh =>
    target (TKX2 ((':) @(Maybe Nat) ('Nothing @Nat) sh) x))
-> target (TKX2 ((':) @(Maybe Nat) ('Nothing @Nat) sh) x)
forall (sh :: [Maybe Nat]) r.
StaticShX sh -> (KnownShX sh => r) -> r
withKnownShX (ShX sh Int -> StaticShX sh
forall (sh :: [Maybe Nat]) i. ShX sh i -> StaticShX sh
ssxFromShX ShX sh Int
sh) ((KnownShX sh =>
  target (TKX2 ((':) @(Maybe Nat) ('Nothing @Nat) sh) x))
 -> target (TKX2 ((':) @(Maybe Nat) ('Nothing @Nat) sh) x))
-> (KnownShX sh =>
    target (TKX2 ((':) @(Maybe Nat) ('Nothing @Nat) sh) x))
-> target (TKX2 ((':) @(Maybe Nat) ('Nothing @Nat) sh) x)
forall a b. (a -> b) -> a -> b
$
       StaticShX ((':) @(Maybe Nat) ('Nothing @Nat) sh)
-> target (TKX2 ((':) @(Maybe Nat) ('Just @Nat (n + n)) sh) x)
-> target (TKX2 ((':) @(Maybe Nat) ('Nothing @Nat) sh) x)
forall (x :: TK) (sh :: [Maybe Nat]) (sh2 :: [Maybe Nat]).
(KnownSTK x, KnownShX sh,
 (Rank @(Maybe Nat) sh :: Nat) ~ (Rank @(Maybe Nat) sh2 :: Nat),
 ConvertTensor target) =>
StaticShX sh2 -> target (TKX2 sh x) -> target (TKX2 sh2 x)
forall (target :: Target) (x :: TK) (sh :: [Maybe Nat])
       (sh2 :: [Maybe Nat]).
(BaseTensor target, KnownSTK x, KnownShX sh,
 (Rank @(Maybe Nat) sh :: Nat) ~ (Rank @(Maybe Nat) sh2 :: Nat),
 ConvertTensor target) =>
StaticShX sh2 -> target (TKX2 sh x) -> target (TKX2 sh2 x)
xmcast StaticShX ((':) @(Maybe Nat) ('Nothing @Nat) sh)
sh0 (target (TKX2 ((':) @(Maybe Nat) ('Just @Nat (n + n)) sh) x)
 -> target (TKX2 ((':) @(Maybe Nat) ('Nothing @Nat) sh) x))
-> target (TKX2 ((':) @(Maybe Nat) ('Just @Nat (n + n)) sh) x)
-> target (TKX2 ((':) @(Maybe Nat) ('Nothing @Nat) sh) x)
forall a b. (a -> b) -> a -> b
$ target (TKX2 ((':) @(Maybe Nat) ('Just @Nat n) sh) x)
-> target (TKX2 ((':) @(Maybe Nat) ('Just @Nat n) sh) x)
-> target (TKX2 ((':) @(Maybe Nat) ('Just @Nat (n + n)) sh) x)
forall (m :: Nat) (n :: Nat) (sh :: [Maybe Nat]) (x :: TK)
       (target :: Target).
(KnownSTK x, BaseTensor target) =>
target (TKX2 ((':) @(Maybe Nat) ('Just @Nat m) sh) x)
-> target (TKX2 ((':) @(Maybe Nat) ('Just @Nat n) sh) x)
-> target (TKX2 ((':) @(Maybe Nat) ('Just @Nat (m + n)) sh) x)
xappend (StaticShX ((':) @(Maybe Nat) ('Just @Nat n) sh)
-> target (TKX2 ((':) @(Maybe Nat) ('Nothing @Nat) sh) x)
-> target (TKX2 ((':) @(Maybe Nat) ('Just @Nat n) sh) x)
forall (x :: TK) (sh :: [Maybe Nat]) (sh2 :: [Maybe Nat]).
(KnownSTK x, KnownShX sh,
 (Rank @(Maybe Nat) sh :: Nat) ~ (Rank @(Maybe Nat) sh2 :: Nat),
 ConvertTensor target) =>
StaticShX sh2 -> target (TKX2 sh x) -> target (TKX2 sh2 x)
forall (target :: Target) (x :: TK) (sh :: [Maybe Nat])
       (sh2 :: [Maybe Nat]).
(BaseTensor target, KnownSTK x, KnownShX sh,
 (Rank @(Maybe Nat) sh :: Nat) ~ (Rank @(Maybe Nat) sh2 :: Nat),
 ConvertTensor target) =>
StaticShX sh2 -> target (TKX2 sh x) -> target (TKX2 sh2 x)
xmcast StaticShX ((':) @(Maybe Nat) ('Just @Nat n) sh)
sha target (TKX2 ((':) @(Maybe Nat) ('Nothing @Nat) sh) x)
a) (StaticShX ((':) @(Maybe Nat) ('Just @Nat n) sh)
-> target (TKX2 ((':) @(Maybe Nat) ('Nothing @Nat) sh) x)
-> target (TKX2 ((':) @(Maybe Nat) ('Just @Nat n) sh) x)
forall (x :: TK) (sh :: [Maybe Nat]) (sh2 :: [Maybe Nat]).
(KnownSTK x, KnownShX sh,
 (Rank @(Maybe Nat) sh :: Nat) ~ (Rank @(Maybe Nat) sh2 :: Nat),
 ConvertTensor target) =>
StaticShX sh2 -> target (TKX2 sh x) -> target (TKX2 sh2 x)
forall (target :: Target) (x :: TK) (sh :: [Maybe Nat])
       (sh2 :: [Maybe Nat]).
(BaseTensor target, KnownSTK x, KnownShX sh,
 (Rank @(Maybe Nat) sh :: Nat) ~ (Rank @(Maybe Nat) sh2 :: Nat),
 ConvertTensor target) =>
StaticShX sh2 -> target (TKX2 sh x) -> target (TKX2 sh2 x)
xmcast StaticShX ((':) @(Maybe Nat) ('Just @Nat n) sh)
shb target (TKX2 ((':) @(Maybe Nat) ('Nothing @Nat) sh) x)
b)
xconcat :: forall sh x target.
           (KnownSTK x, BaseTensor target, ConvertTensor target)
        => NonEmpty (target (TKX2 (Nothing ': sh) x))
        -> target (TKX2 (Nothing ': sh) x)
xconcat :: forall (sh :: [Maybe Nat]) (x :: TK) (target :: Target).
(KnownSTK x, BaseTensor target, ConvertTensor target) =>
NonEmpty (target (TKX2 ((':) @(Maybe Nat) ('Nothing @Nat) sh) x))
-> target (TKX2 ((':) @(Maybe Nat) ('Nothing @Nat) sh) x)
xconcat = (target (TKX2 ((':) @(Maybe Nat) ('Nothing @Nat) sh) x)
 -> target (TKX2 ((':) @(Maybe Nat) ('Nothing @Nat) sh) x)
 -> target (TKX2 ((':) @(Maybe Nat) ('Nothing @Nat) sh) x))
-> NonEmpty
     (target (TKX2 ((':) @(Maybe Nat) ('Nothing @Nat) sh) x))
-> target (TKX2 ((':) @(Maybe Nat) ('Nothing @Nat) sh) x)
forall a. (a -> a -> a) -> NonEmpty a -> a
forall (t :: Type -> Type) a.
Foldable t =>
(a -> a -> a) -> t a -> a
foldr1 target (TKX2 ((':) @(Maybe Nat) ('Nothing @Nat) sh) x)
-> target (TKX2 ((':) @(Maybe Nat) ('Nothing @Nat) sh) x)
-> target (TKX2 ((':) @(Maybe Nat) ('Nothing @Nat) sh) x)
forall (sh :: [Maybe Nat]) (x :: TK) (target :: Target).
(KnownSTK x, BaseTensor target, ConvertTensor target) =>
target (TKX2 ((':) @(Maybe Nat) ('Nothing @Nat) sh) x)
-> target (TKX2 ((':) @(Maybe Nat) ('Nothing @Nat) sh) x)
-> target (TKX2 ((':) @(Maybe Nat) ('Nothing @Nat) sh) x)
xappend0
xslice :: forall i n k sh x target. (KnownSTK x, BaseTensor target)
       => SNat i -> SNat n -> SNat k
       -> target (TKX2 (Just (i + n + k) ': sh) x)
       -> target (TKX2 (Just n ': sh) x)
xslice :: forall (i :: Nat) (n :: Nat) (k :: Nat) (sh :: [Maybe Nat])
       (x :: TK) (target :: Target).
(KnownSTK x, BaseTensor target) =>
SNat i
-> SNat n
-> SNat k
-> target
     (TKX2 ((':) @(Maybe Nat) ('Just @Nat ((i + n) + k)) sh) x)
-> target (TKX2 ((':) @(Maybe Nat) ('Just @Nat n) sh) x)
xslice = SNat i
-> SNat n
-> SNat k
-> target
     (TKX2 ((':) @(Maybe Nat) ('Just @Nat ((i + n) + k)) sh) x)
-> target (TKX2 ((':) @(Maybe Nat) ('Just @Nat n) sh) x)
forall (i :: Nat) (n :: Nat) (k :: Nat) (sh :: [Maybe Nat])
       (x :: TK).
KnownSTK x =>
SNat i
-> SNat n
-> SNat k
-> target
     (TKX2 ((':) @(Maybe Nat) ('Just @Nat ((i + n) + k)) sh) x)
-> target (TKX2 ((':) @(Maybe Nat) ('Just @Nat n) sh) x)
forall (target :: Target) (i :: Nat) (n :: Nat) (k :: Nat)
       (sh :: [Maybe Nat]) (x :: TK).
(BaseTensor target, KnownSTK x) =>
SNat i
-> SNat n
-> SNat k
-> target
     (TKX2 ((':) @(Maybe Nat) ('Just @Nat ((i + n) + k)) sh) x)
-> target (TKX2 ((':) @(Maybe Nat) ('Just @Nat n) sh) x)
txslice
xuncons :: (KnownNat n, KnownShX sh, KnownSTK x, BaseTensor target)
        => target (TKX2 (Just n ': sh) x)
        -> Maybe (target (TKX2 sh x), target (TKX2 (Just (n - 1) ': sh) x))
xuncons :: forall (n :: Nat) (sh :: [Maybe Nat]) (x :: TK) (target :: Target).
(KnownNat n, KnownShX sh, KnownSTK x, BaseTensor target) =>
target (TKX2 ((':) @(Maybe Nat) ('Just @Nat n) sh) x)
-> Maybe
     (target (TKX2 sh x),
      target (TKX2 ((':) @(Maybe Nat) ('Just @Nat (n - 1)) sh) x))
xuncons @n target (TKX2 ((':) @(Maybe Nat) ('Just @Nat n) sh) x)
v = case Proxy @Nat 1 -> Proxy @Nat n -> OrderingI @Nat 1 n
forall (a :: Nat) (b :: Nat) (proxy1 :: Nat -> Type)
       (proxy2 :: Nat -> Type).
(KnownNat a, KnownNat b) =>
proxy1 a -> proxy2 b -> OrderingI @Nat a b
cmpNat (forall (t :: Nat). Proxy @Nat t
forall {k} (t :: k). Proxy @k t
Proxy @1) (forall (t :: Nat). Proxy @Nat t
forall {k} (t :: k). Proxy @k t
Proxy @n) of
  OrderingI @Nat 1 n
EQI -> (target (TKX2 sh x),
 target (TKX2 ((':) @(Maybe Nat) ('Just @Nat 0) sh) x))
-> Maybe
     (target (TKX2 sh x),
      target (TKX2 ((':) @(Maybe Nat) ('Just @Nat 0) sh) x))
forall a. a -> Maybe a
Just ( target (TKX2 ((':) @(Maybe Nat) ('Just @Nat n) sh) x)
target
  (TKX2
     ((++)
        @(Maybe Nat)
        ((':) @(Maybe Nat) ('Just @Nat 1) ('[] @(Maybe Nat)))
        sh)
     x)
v target
  (TKX2
     ((++)
        @(Maybe Nat)
        ((':) @(Maybe Nat) ('Just @Nat 1) ('[] @(Maybe Nat)))
        sh)
     x)
-> IxXOf
     target ((':) @(Maybe Nat) ('Just @Nat 1) ('[] @(Maybe Nat)))
-> target (TKX2 sh x)
forall (sh1 :: [Maybe Nat]) (sh2 :: [Maybe Nat]) (x :: TK)
       (target :: Target).
(KnownShX sh1, KnownShX sh2, KnownSTK x, BaseTensor target) =>
target (TKX2 ((++) @(Maybe Nat) sh1 sh2) x)
-> IxXOf target sh1 -> target (TKX2 sh2 x)
`xindex` (IntOf target
0 IntOf target
-> IxX ('[] @(Maybe Nat)) (IntOf target)
-> IxXOf
     target ((':) @(Maybe Nat) ('Just @Nat 1) ('[] @(Maybe Nat)))
forall {sh1 :: [Maybe Nat]} {i} (n :: Maybe Nat)
       (sh :: [Maybe Nat]).
(((':) @(Maybe Nat) n sh :: [Maybe Nat]) ~ (sh1 :: [Maybe Nat])) =>
i -> IxX sh i -> IxX sh1 i
:.% IxX ('[] @(Maybe Nat)) (IntOf target)
forall (sh :: [Maybe Nat]) i.
((sh :: [Maybe Nat]) ~ ('[] @(Maybe Nat) :: [Maybe Nat])) =>
IxX sh i
ZIX)
              , forall (i :: Nat) (n :: Nat) (k :: Nat) (sh :: [Maybe Nat])
       (x :: TK) (target :: Target).
(KnownSTK x, BaseTensor target) =>
SNat i
-> SNat n
-> SNat k
-> target
     (TKX2 ((':) @(Maybe Nat) ('Just @Nat ((i + n) + k)) sh) x)
-> target (TKX2 ((':) @(Maybe Nat) ('Just @Nat n) sh) x)
xslice @1 @(n - 1) @0 SNat 1
forall (n :: Nat). KnownNat n => SNat n
SNat SNat 0
SNat (n - 1)
forall (n :: Nat). KnownNat n => SNat n
SNat SNat 0
forall (n :: Nat). KnownNat n => SNat n
SNat target (TKX2 ((':) @(Maybe Nat) ('Just @Nat n) sh) x)
target
  (TKX2 ((':) @(Maybe Nat) ('Just @Nat ((1 + (n - 1)) + 0)) sh) x)
v )
  OrderingI @Nat 1 n
LTI -> (target (TKX2 sh x),
 target (TKX2 ((':) @(Maybe Nat) ('Just @Nat (n - 1)) sh) x))
-> Maybe
     (target (TKX2 sh x),
      target (TKX2 ((':) @(Maybe Nat) ('Just @Nat (n - 1)) sh) x))
forall a. a -> Maybe a
Just ( target (TKX2 ((':) @(Maybe Nat) ('Just @Nat n) sh) x)
target
  (TKX2
     ((++)
        @(Maybe Nat)
        ((':) @(Maybe Nat) ('Just @Nat n) ('[] @(Maybe Nat)))
        sh)
     x)
v target
  (TKX2
     ((++)
        @(Maybe Nat)
        ((':) @(Maybe Nat) ('Just @Nat n) ('[] @(Maybe Nat)))
        sh)
     x)
-> IxXOf
     target ((':) @(Maybe Nat) ('Just @Nat n) ('[] @(Maybe Nat)))
-> target (TKX2 sh x)
forall (sh1 :: [Maybe Nat]) (sh2 :: [Maybe Nat]) (x :: TK)
       (target :: Target).
(KnownShX sh1, KnownShX sh2, KnownSTK x, BaseTensor target) =>
target (TKX2 ((++) @(Maybe Nat) sh1 sh2) x)
-> IxXOf target sh1 -> target (TKX2 sh2 x)
`xindex` (IntOf target
0 IntOf target
-> IxX ('[] @(Maybe Nat)) (IntOf target)
-> IxXOf
     target ((':) @(Maybe Nat) ('Just @Nat n) ('[] @(Maybe Nat)))
forall {sh1 :: [Maybe Nat]} {i} (n :: Maybe Nat)
       (sh :: [Maybe Nat]).
(((':) @(Maybe Nat) n sh :: [Maybe Nat]) ~ (sh1 :: [Maybe Nat])) =>
i -> IxX sh i -> IxX sh1 i
:.% IxX ('[] @(Maybe Nat)) (IntOf target)
forall (sh :: [Maybe Nat]) i.
((sh :: [Maybe Nat]) ~ ('[] @(Maybe Nat) :: [Maybe Nat])) =>
IxX sh i
ZIX)
              , forall (i :: Nat) (n :: Nat) (k :: Nat) (sh :: [Maybe Nat])
       (x :: TK) (target :: Target).
(KnownSTK x, BaseTensor target) =>
SNat i
-> SNat n
-> SNat k
-> target
     (TKX2 ((':) @(Maybe Nat) ('Just @Nat ((i + n) + k)) sh) x)
-> target (TKX2 ((':) @(Maybe Nat) ('Just @Nat n) sh) x)
xslice @1 @(n - 1) @0 SNat 1
forall (n :: Nat). KnownNat n => SNat n
SNat SNat (n - 1)
forall (n :: Nat). KnownNat n => SNat n
SNat SNat 0
forall (n :: Nat). KnownNat n => SNat n
SNat target (TKX2 ((':) @(Maybe Nat) ('Just @Nat n) sh) x)
target
  (TKX2 ((':) @(Maybe Nat) ('Just @Nat ((1 + (n - 1)) + 0)) sh) x)
v )
  OrderingI @Nat 1 n
_ -> Maybe
  (target (TKX2 sh x),
   target (TKX2 ((':) @(Maybe Nat) ('Just @Nat (n - 1)) sh) x))
forall a. Maybe a
Nothing
xreverse :: forall mn sh x target. (KnownSTK x, BaseTensor target)
         => target (TKX2 (mn ': sh) x) -> target (TKX2 (mn ': sh) x)
xreverse :: forall (mn :: Maybe Nat) (sh :: [Maybe Nat]) (x :: TK)
       (target :: Target).
(KnownSTK x, BaseTensor target) =>
target (TKX2 ((':) @(Maybe Nat) mn sh) x)
-> target (TKX2 ((':) @(Maybe Nat) mn sh) x)
xreverse = target (TKX2 ((':) @(Maybe Nat) mn sh) x)
-> target (TKX2 ((':) @(Maybe Nat) mn sh) x)
forall (mn :: Maybe Nat) (sh :: [Maybe Nat]) (x :: TK).
KnownSTK x =>
target (TKX2 ((':) @(Maybe Nat) mn sh) x)
-> target (TKX2 ((':) @(Maybe Nat) mn sh) x)
forall (target :: Target) (mn :: Maybe Nat) (sh :: [Maybe Nat])
       (x :: TK).
(BaseTensor target, KnownSTK x) =>
target (TKX2 ((':) @(Maybe Nat) mn sh) x)
-> target (TKX2 ((':) @(Maybe Nat) mn sh) x)
txreverse

rbuild1 :: (KnownNat n, KnownSTK x, BaseTensor target)
        => Int  -- ^ width of the outermost dimension of the created tensor
        -> (IntOf target -> target (TKR2 n x))  -- ^ the function to build with
        -> target (TKR2 (1 + n) x)
rbuild1 :: forall (n :: Nat) (x :: TK) (target :: Target).
(KnownNat n, KnownSTK x, BaseTensor target) =>
Int
-> (IntOf target -> target (TKR2 n x)) -> target (TKR2 (1 + n) x)
rbuild1 = Int
-> (IntOf target -> target (TKR2 n x)) -> target (TKR2 (1 + n) x)
forall (n :: Nat) (x :: TK).
(KnownNat n, KnownSTK x) =>
Int
-> (IntOf target -> target (TKR2 n x)) -> target (TKR2 (1 + n) x)
forall (target :: Target) (n :: Nat) (x :: TK).
(BaseTensor target, KnownNat n, KnownSTK x) =>
Int
-> (IntOf target -> target (TKR2 n x)) -> target (TKR2 (1 + n) x)
trbuild1
rmap :: (KnownNat m, KnownNat n, KnownSTK x, KnownSTK x2, BaseTensor target)
     => (target (TKR2 n x) -> target (TKR2 n x2))  -- ^ the function to map with
     -> target (TKR2 (m + n) x)  -- ^ the tensor to map over
     -> target (TKR2 (m + n) x2)
rmap :: forall (m :: Nat) (n :: Nat) (x :: TK) (x2 :: TK)
       (target :: Target).
(KnownNat m, KnownNat n, KnownSTK x, KnownSTK x2,
 BaseTensor target) =>
(target (TKR2 n x) -> target (TKR2 n x2))
-> target (TKR2 (m + n) x) -> target (TKR2 (m + n) x2)
rmap target (TKR2 n x) -> target (TKR2 n x2)
f target (TKR2 (m + n) x)
v = IShR (m + n)
-> (IxROf target m -> target (TKR2 n x2))
-> target (TKR2 (m + n) x2)
forall (m :: Nat) (n :: Nat) (x :: TK) (target :: Target).
(KnownNat m, KnownNat n, KnownSTK x, BaseTensor target) =>
IShR (m + n)
-> (IxROf target m -> target (TKR2 n x)) -> target (TKR2 (m + n) x)
rbuild (target (TKR2 (m + n) x) -> IShR (m + n)
forall (n :: Nat) (x :: TK).
KnownSTK x =>
target (TKR2 n x) -> IShR n
forall (target :: Target) (n :: Nat) (x :: TK).
(BaseTensor target, KnownSTK x) =>
target (TKR2 n x) -> IShR n
rshape target (TKR2 (m + n) x)
v) (\IxROf target m
ix -> target (TKR2 n x) -> target (TKR2 n x2)
f (target (TKR2 (m + n) x)
v target (TKR2 (m + n) x) -> IxROf target m -> target (TKR2 n x)
forall (m :: Nat) (n :: Nat) (x :: TK) (target :: Target).
(KnownNat m, KnownNat n, KnownSTK x, BaseTensor target) =>
target (TKR2 (m + n) x) -> IxROf target m -> target (TKR2 n x)
! IxROf target m
ix))
rmap1 :: (KnownNat n, KnownSTK x, KnownSTK x2, BaseTensor target)
      => (target (TKR2 n x) -> target (TKR2 n x2))
            -- ^ the function to map with
      -> target (TKR2 (1 + n) x)  -- ^ the tensor to map over
      -> target (TKR2 (1 + n) x2)
rmap1 :: forall (n :: Nat) (x :: TK) (x2 :: TK) (target :: Target).
(KnownNat n, KnownSTK x, KnownSTK x2, BaseTensor target) =>
(target (TKR2 n x) -> target (TKR2 n x2))
-> target (TKR2 (1 + n) x) -> target (TKR2 (1 + n) x2)
rmap1 target (TKR2 n x) -> target (TKR2 n x2)
f target (TKR2 (1 + n) x)
u = Int
-> (PrimalOf target (TKScalar Int64) -> target (TKR2 n x2))
-> target (TKR2 (1 + n) x2)
forall (n :: Nat) (x :: TK) (target :: Target).
(KnownNat n, KnownSTK x, BaseTensor target) =>
Int
-> (IntOf target -> target (TKR2 n x)) -> target (TKR2 (1 + n) x)
rbuild1 (target (TKR2 (1 + n) x) -> Int
forall (n :: Nat) (x :: TK).
KnownSTK x =>
target (TKR2 (1 + n) x) -> Int
forall (target :: Target) (n :: Nat) (x :: TK).
(BaseTensor target, KnownSTK x) =>
target (TKR2 (1 + n) x) -> Int
rwidth target (TKR2 (1 + n) x)
u) (\PrimalOf target (TKScalar Int64)
i -> target (TKR2 n x) -> target (TKR2 n x2)
f (target (TKR2 (1 + n) x)
u target (TKR2 (1 + n) x)
-> IxR 1 (PrimalOf target (TKScalar Int64)) -> target (TKR2 n x)
forall (m :: Nat) (n :: Nat) (x :: TK) (target :: Target).
(KnownNat m, KnownNat n, KnownSTK x, BaseTensor target) =>
target (TKR2 (m + n) x) -> IxROf target m -> target (TKR2 n x)
! [Item (IxR 1 (PrimalOf target (TKScalar Int64)))
PrimalOf target (TKScalar Int64)
i]))
rmap0N :: (KnownNat n, KnownSTK x, KnownSTK x1, BaseTensor target)
       => (target (TKR2 0 x1) -> target (TKR2 0 x))
            -- ^ the function to map with
       -> target (TKR2 n x1)  -- ^ the tensor to map over
       -> target (TKR2 n x)
rmap0N :: forall (n :: Nat) (x :: TK) (x1 :: TK) (target :: Target).
(KnownNat n, KnownSTK x, KnownSTK x1, BaseTensor target) =>
(target (TKR2 0 x1) -> target (TKR2 0 x))
-> target (TKR2 n x1) -> target (TKR2 n x)
rmap0N = (target (TKR2 0 x1) -> target (TKR2 0 x))
-> target (TKR2 n x1) -> target (TKR2 n x)
forall (n :: Nat) (x :: TK) (x1 :: TK).
(KnownNat n, KnownSTK x, KnownSTK x1) =>
(target (TKR2 0 x1) -> target (TKR2 0 x))
-> target (TKR2 n x1) -> target (TKR2 n x)
forall (target :: Target) (n :: Nat) (x :: TK) (x1 :: TK).
(BaseTensor target, KnownNat n, KnownSTK x, KnownSTK x1) =>
(target (TKR2 0 x1) -> target (TKR2 0 x))
-> target (TKR2 n x1) -> target (TKR2 n x)
trmap0N
rzipWith :: ( KnownNat m, KnownNat n1, KnownNat n2, KnownNat n, KnownSTK x
            , KnownSTK x1, KnownSTK x2, BaseTensor target )
         => IShR (m + n)  -- ^ the shape of the resulting tensor
         -> (target (TKR2 n1 x1) -> target (TKR2 n2 x2) -> target (TKR2 n x))
              -- ^ the function to zip with
         -> target (TKR2 (m + n1) x1)  -- ^ the first tensor to zip over
         -> target (TKR2 (m + n2) x2)  -- ^ the second tensor to zip over
         -> target (TKR2 (m + n) x)
rzipWith :: forall (m :: Nat) (n1 :: Nat) (n2 :: Nat) (n :: Nat) (x :: TK)
       (x1 :: TK) (x2 :: TK) (target :: Target).
(KnownNat m, KnownNat n1, KnownNat n2, KnownNat n, KnownSTK x,
 KnownSTK x1, KnownSTK x2, BaseTensor target) =>
IShR (m + n)
-> (target (TKR2 n1 x1)
    -> target (TKR2 n2 x2) -> target (TKR2 n x))
-> target (TKR2 (m + n1) x1)
-> target (TKR2 (m + n2) x2)
-> target (TKR2 (m + n) x)
rzipWith IShR (m + n)
sh target (TKR2 n1 x1) -> target (TKR2 n2 x2) -> target (TKR2 n x)
f target (TKR2 (m + n1) x1)
u target (TKR2 (m + n2) x2)
v = IShR (m + n)
-> (IxROf target m -> target (TKR2 n x)) -> target (TKR2 (m + n) x)
forall (m :: Nat) (n :: Nat) (x :: TK) (target :: Target).
(KnownNat m, KnownNat n, KnownSTK x, BaseTensor target) =>
IShR (m + n)
-> (IxROf target m -> target (TKR2 n x)) -> target (TKR2 (m + n) x)
rbuild IShR (m + n)
sh (\IxROf target m
ix -> target (TKR2 n1 x1) -> target (TKR2 n2 x2) -> target (TKR2 n x)
f (target (TKR2 (m + n1) x1)
u target (TKR2 (m + n1) x1) -> IxROf target m -> target (TKR2 n1 x1)
forall (m :: Nat) (n :: Nat) (x :: TK) (target :: Target).
(KnownNat m, KnownNat n, KnownSTK x, BaseTensor target) =>
target (TKR2 (m + n) x) -> IxROf target m -> target (TKR2 n x)
! IxROf target m
ix) (target (TKR2 (m + n2) x2)
v target (TKR2 (m + n2) x2) -> IxROf target m -> target (TKR2 n2 x2)
forall (m :: Nat) (n :: Nat) (x :: TK) (target :: Target).
(KnownNat m, KnownNat n, KnownSTK x, BaseTensor target) =>
target (TKR2 (m + n) x) -> IxROf target m -> target (TKR2 n x)
! IxROf target m
ix))
rzipWith1 :: ( KnownNat n1, KnownNat n2, KnownNat n, KnownSTK x
             , KnownSTK x1, KnownSTK x2, BaseTensor target)
          => (target (TKR2 n1 x1) -> target (TKR2 n2 x2) -> target (TKR2 n x))
               -- ^ the function to zip with
          -> target (TKR2 (1 + n1) x1)  -- ^ the first tensor to zip over
          -> target (TKR2 (1 + n2) x2)  -- ^ the second tensor to zip over
          -> target (TKR2 (1 + n) x)
rzipWith1 :: forall (n1 :: Nat) (n2 :: Nat) (n :: Nat) (x :: TK) (x1 :: TK)
       (x2 :: TK) (target :: Target).
(KnownNat n1, KnownNat n2, KnownNat n, KnownSTK x, KnownSTK x1,
 KnownSTK x2, BaseTensor target) =>
(target (TKR2 n1 x1) -> target (TKR2 n2 x2) -> target (TKR2 n x))
-> target (TKR2 (1 + n1) x1)
-> target (TKR2 (1 + n2) x2)
-> target (TKR2 (1 + n) x)
rzipWith1 target (TKR2 n1 x1) -> target (TKR2 n2 x2) -> target (TKR2 n x)
f target (TKR2 (1 + n1) x1)
u target (TKR2 (1 + n2) x2)
v = Int
-> (PrimalOf target (TKScalar Int64) -> target (TKR2 n x))
-> target (TKR2 (1 + n) x)
forall (n :: Nat) (x :: TK) (target :: Target).
(KnownNat n, KnownSTK x, BaseTensor target) =>
Int
-> (IntOf target -> target (TKR2 n x)) -> target (TKR2 (1 + n) x)
rbuild1 (target (TKR2 (1 + n1) x1) -> Int
forall (n :: Nat) (x :: TK).
KnownSTK x =>
target (TKR2 (1 + n) x) -> Int
forall (target :: Target) (n :: Nat) (x :: TK).
(BaseTensor target, KnownSTK x) =>
target (TKR2 (1 + n) x) -> Int
rwidth target (TKR2 (1 + n1) x1)
u) (\PrimalOf target (TKScalar Int64)
i -> target (TKR2 n1 x1) -> target (TKR2 n2 x2) -> target (TKR2 n x)
f (target (TKR2 (1 + n1) x1)
u target (TKR2 (1 + n1) x1)
-> IxR 1 (PrimalOf target (TKScalar Int64)) -> target (TKR2 n1 x1)
forall (m :: Nat) (n :: Nat) (x :: TK) (target :: Target).
(KnownNat m, KnownNat n, KnownSTK x, BaseTensor target) =>
target (TKR2 (m + n) x) -> IxROf target m -> target (TKR2 n x)
! [Item (IxR 1 (PrimalOf target (TKScalar Int64)))
PrimalOf target (TKScalar Int64)
i]) (target (TKR2 (1 + n2) x2)
v target (TKR2 (1 + n2) x2)
-> IxR 1 (PrimalOf target (TKScalar Int64)) -> target (TKR2 n2 x2)
forall (m :: Nat) (n :: Nat) (x :: TK) (target :: Target).
(KnownNat m, KnownNat n, KnownSTK x, BaseTensor target) =>
target (TKR2 (m + n) x) -> IxROf target m -> target (TKR2 n x)
! [Item (IxR 1 (PrimalOf target (TKScalar Int64)))
PrimalOf target (TKScalar Int64)
i]))
rzipWith0N :: ( KnownNat n, KnownSTK x, KnownSTK x1, KnownSTK x2
              , BaseTensor target )
           => (target (TKR2 0 x1) -> target (TKR2 0 x2) -> target (TKR2 0 x))
                -- ^ the function to zip with
           -> target (TKR2 n x1)  -- ^ the first tensor to zip over
           -> target (TKR2 n x2)  -- ^ the second tensor to zip over
           -> target (TKR2 n x)
rzipWith0N :: forall (n :: Nat) (x :: TK) (x1 :: TK) (x2 :: TK)
       (target :: Target).
(KnownNat n, KnownSTK x, KnownSTK x1, KnownSTK x2,
 BaseTensor target) =>
(target (TKR2 0 x1) -> target (TKR2 0 x2) -> target (TKR2 0 x))
-> target (TKR2 n x1) -> target (TKR2 n x2) -> target (TKR2 n x)
rzipWith0N  = (target (TKR2 0 x1) -> target (TKR2 0 x2) -> target (TKR2 0 x))
-> target (TKR2 n x1) -> target (TKR2 n x2) -> target (TKR2 n x)
forall (n :: Nat) (x :: TK) (x1 :: TK) (x2 :: TK).
(KnownNat n, KnownSTK x, KnownSTK x1, KnownSTK x2) =>
(target (TKR2 0 x1) -> target (TKR2 0 x2) -> target (TKR2 0 x))
-> target (TKR2 n x1) -> target (TKR2 n x2) -> target (TKR2 n x)
forall (target :: Target) (n :: Nat) (x :: TK) (x1 :: TK)
       (x2 :: TK).
(BaseTensor target, KnownNat n, KnownSTK x, KnownSTK x1,
 KnownSTK x2) =>
(target (TKR2 0 x1) -> target (TKR2 0 x2) -> target (TKR2 0 x))
-> target (TKR2 n x1) -> target (TKR2 n x2) -> target (TKR2 n x)
trzipWith0N
rzipWith3 :: ( KnownNat m, KnownNat n1, KnownNat n2, KnownNat n3
             , KnownNat n, KnownSTK x
             , KnownSTK x1, KnownSTK x2, KnownSTK x3, BaseTensor target )
          => IShR (m + n)  -- ^ the shape of the resulting tensor
          -> (target (TKR2 n1 x1) -> target (TKR2 n2 x2) -> target (TKR2 n3 x3)
              -> target (TKR2 n x))  -- ^ the function to zip with
          -> target (TKR2 (m + n1) x1)  -- ^ the first tensor to zip over
          -> target (TKR2 (m + n2) x2)  -- ^ the second tensor to zip over
          -> target (TKR2 (m + n3) x3)  -- ^ the third tensor to zip over
          -> target (TKR2 (m + n) x)
rzipWith3 :: forall (m :: Nat) (n1 :: Nat) (n2 :: Nat) (n3 :: Nat) (n :: Nat)
       (x :: TK) (x1 :: TK) (x2 :: TK) (x3 :: TK) (target :: Target).
(KnownNat m, KnownNat n1, KnownNat n2, KnownNat n3, KnownNat n,
 KnownSTK x, KnownSTK x1, KnownSTK x2, KnownSTK x3,
 BaseTensor target) =>
IShR (m + n)
-> (target (TKR2 n1 x1)
    -> target (TKR2 n2 x2) -> target (TKR2 n3 x3) -> target (TKR2 n x))
-> target (TKR2 (m + n1) x1)
-> target (TKR2 (m + n2) x2)
-> target (TKR2 (m + n3) x3)
-> target (TKR2 (m + n) x)
rzipWith3 IShR (m + n)
sh target (TKR2 n1 x1)
-> target (TKR2 n2 x2) -> target (TKR2 n3 x3) -> target (TKR2 n x)
f target (TKR2 (m + n1) x1)
u target (TKR2 (m + n2) x2)
v target (TKR2 (m + n3) x3)
w = IShR (m + n)
-> (IxROf target m -> target (TKR2 n x)) -> target (TKR2 (m + n) x)
forall (m :: Nat) (n :: Nat) (x :: TK) (target :: Target).
(KnownNat m, KnownNat n, KnownSTK x, BaseTensor target) =>
IShR (m + n)
-> (IxROf target m -> target (TKR2 n x)) -> target (TKR2 (m + n) x)
rbuild IShR (m + n)
sh (\IxROf target m
ix -> target (TKR2 n1 x1)
-> target (TKR2 n2 x2) -> target (TKR2 n3 x3) -> target (TKR2 n x)
f (target (TKR2 (m + n1) x1)
u target (TKR2 (m + n1) x1) -> IxROf target m -> target (TKR2 n1 x1)
forall (m :: Nat) (n :: Nat) (x :: TK) (target :: Target).
(KnownNat m, KnownNat n, KnownSTK x, BaseTensor target) =>
target (TKR2 (m + n) x) -> IxROf target m -> target (TKR2 n x)
! IxROf target m
ix) (target (TKR2 (m + n2) x2)
v target (TKR2 (m + n2) x2) -> IxROf target m -> target (TKR2 n2 x2)
forall (m :: Nat) (n :: Nat) (x :: TK) (target :: Target).
(KnownNat m, KnownNat n, KnownSTK x, BaseTensor target) =>
target (TKR2 (m + n) x) -> IxROf target m -> target (TKR2 n x)
! IxROf target m
ix) (target (TKR2 (m + n3) x3)
w target (TKR2 (m + n3) x3) -> IxROf target m -> target (TKR2 n3 x3)
forall (m :: Nat) (n :: Nat) (x :: TK) (target :: Target).
(KnownNat m, KnownNat n, KnownSTK x, BaseTensor target) =>
target (TKR2 (m + n) x) -> IxROf target m -> target (TKR2 n x)
! IxROf target m
ix))
rzipWith31 :: ( KnownNat n1, KnownNat n2, KnownNat n3, KnownNat n, KnownSTK x
              , KnownSTK x1, KnownSTK x2, KnownSTK x3, BaseTensor target )
           => (target (TKR2 n1 x1) -> target (TKR2 n2 x2) -> target (TKR2 n3 x3)
               -> target (TKR2 n x))  -- ^ the function to zip with
           -> target (TKR2 (1 + n1) x1)  -- ^ the first tensor to zip over
           -> target (TKR2 (1 + n2) x2)  -- ^ the second tensor to zip over
           -> target (TKR2 (1 + n3) x3)  -- ^ the third tensor to zip over
           -> target (TKR2 (1 + n) x)
rzipWith31 :: forall (n1 :: Nat) (n2 :: Nat) (n3 :: Nat) (n :: Nat) (x :: TK)
       (x1 :: TK) (x2 :: TK) (x3 :: TK) (target :: Target).
(KnownNat n1, KnownNat n2, KnownNat n3, KnownNat n, KnownSTK x,
 KnownSTK x1, KnownSTK x2, KnownSTK x3, BaseTensor target) =>
(target (TKR2 n1 x1)
 -> target (TKR2 n2 x2) -> target (TKR2 n3 x3) -> target (TKR2 n x))
-> target (TKR2 (1 + n1) x1)
-> target (TKR2 (1 + n2) x2)
-> target (TKR2 (1 + n3) x3)
-> target (TKR2 (1 + n) x)
rzipWith31 target (TKR2 n1 x1)
-> target (TKR2 n2 x2) -> target (TKR2 n3 x3) -> target (TKR2 n x)
f target (TKR2 (1 + n1) x1)
u target (TKR2 (1 + n2) x2)
v target (TKR2 (1 + n3) x3)
w =
  Int
-> (PrimalOf target (TKScalar Int64) -> target (TKR2 n x))
-> target (TKR2 (1 + n) x)
forall (n :: Nat) (x :: TK) (target :: Target).
(KnownNat n, KnownSTK x, BaseTensor target) =>
Int
-> (IntOf target -> target (TKR2 n x)) -> target (TKR2 (1 + n) x)
rbuild1 (target (TKR2 (1 + n1) x1) -> Int
forall (n :: Nat) (x :: TK).
KnownSTK x =>
target (TKR2 (1 + n) x) -> Int
forall (target :: Target) (n :: Nat) (x :: TK).
(BaseTensor target, KnownSTK x) =>
target (TKR2 (1 + n) x) -> Int
rwidth target (TKR2 (1 + n1) x1)
u) (\PrimalOf target (TKScalar Int64)
i -> target (TKR2 n1 x1)
-> target (TKR2 n2 x2) -> target (TKR2 n3 x3) -> target (TKR2 n x)
f (target (TKR2 (1 + n1) x1)
u target (TKR2 (1 + n1) x1)
-> IxR 1 (PrimalOf target (TKScalar Int64)) -> target (TKR2 n1 x1)
forall (m :: Nat) (n :: Nat) (x :: TK) (target :: Target).
(KnownNat m, KnownNat n, KnownSTK x, BaseTensor target) =>
target (TKR2 (m + n) x) -> IxROf target m -> target (TKR2 n x)
! [Item (IxR 1 (PrimalOf target (TKScalar Int64)))
PrimalOf target (TKScalar Int64)
i]) (target (TKR2 (1 + n2) x2)
v target (TKR2 (1 + n2) x2)
-> IxR 1 (PrimalOf target (TKScalar Int64)) -> target (TKR2 n2 x2)
forall (m :: Nat) (n :: Nat) (x :: TK) (target :: Target).
(KnownNat m, KnownNat n, KnownSTK x, BaseTensor target) =>
target (TKR2 (m + n) x) -> IxROf target m -> target (TKR2 n x)
! [Item (IxR 1 (PrimalOf target (TKScalar Int64)))
PrimalOf target (TKScalar Int64)
i]) (target (TKR2 (1 + n3) x3)
w target (TKR2 (1 + n3) x3)
-> IxR 1 (PrimalOf target (TKScalar Int64)) -> target (TKR2 n3 x3)
forall (m :: Nat) (n :: Nat) (x :: TK) (target :: Target).
(KnownNat m, KnownNat n, KnownSTK x, BaseTensor target) =>
target (TKR2 (m + n) x) -> IxROf target m -> target (TKR2 n x)
! [Item (IxR 1 (PrimalOf target (TKScalar Int64)))
PrimalOf target (TKScalar Int64)
i]))
rzipWith30N :: ( KnownNat n, KnownSTK x
               , KnownSTK x1, KnownSTK x2, KnownSTK x3, BaseTensor target )
            => (target (TKR2 0 x1) -> target (TKR2 0 x2) -> target (TKR2 0 x3)
                -> target (TKR2 0 x))  -- ^ the function to zip with
            -> target (TKR2 n x1)  -- ^ the first tensor to zip over
            -> target (TKR2 n x2)  -- ^ the second tensor to zip over
            -> target (TKR2 n x3)  -- ^ the third tensor to zip over
            -> target (TKR2 n x)
rzipWith30N :: forall (n :: Nat) (x :: TK) (x1 :: TK) (x2 :: TK) (x3 :: TK)
       (target :: Target).
(KnownNat n, KnownSTK x, KnownSTK x1, KnownSTK x2, KnownSTK x3,
 BaseTensor target) =>
(target (TKR2 0 x1)
 -> target (TKR2 0 x2) -> target (TKR2 0 x3) -> target (TKR2 0 x))
-> target (TKR2 n x1)
-> target (TKR2 n x2)
-> target (TKR2 n x3)
-> target (TKR2 n x)
rzipWith30N target (TKR2 0 x1)
-> target (TKR2 0 x2) -> target (TKR2 0 x3) -> target (TKR2 0 x)
f target (TKR2 n x1)
u target (TKR2 n x2)
v target (TKR2 n x3)
w =
  IShR (n + 0)
-> (IxROf target n -> target (TKR2 0 x)) -> target (TKR2 (n + 0) x)
forall (m :: Nat) (n :: Nat) (x :: TK) (target :: Target).
(KnownNat m, KnownNat n, KnownSTK x, BaseTensor target) =>
IShR (m + n)
-> (IxROf target m -> target (TKR2 n x)) -> target (TKR2 (m + n) x)
rbuild (target (TKR2 n x2) -> IShR n
forall (n :: Nat) (x :: TK).
KnownSTK x =>
target (TKR2 n x) -> IShR n
forall (target :: Target) (n :: Nat) (x :: TK).
(BaseTensor target, KnownSTK x) =>
target (TKR2 n x) -> IShR n
rshape target (TKR2 n x2)
v) (\IxROf target n
ix -> target (TKR2 0 x1)
-> target (TKR2 0 x2) -> target (TKR2 0 x3) -> target (TKR2 0 x)
f (target (TKR2 n x1) -> IxROf target n -> target (TKR2 0 x1)
forall (m :: Nat) (x :: TK) (target :: Target).
(KnownNat m, KnownSTK x, BaseTensor target) =>
target (TKR2 m x) -> IxROf target m -> target (TKR2 0 x)
rindex0 target (TKR2 n x1)
u IxROf target n
ix) (target (TKR2 n x2) -> IxROf target n -> target (TKR2 0 x2)
forall (m :: Nat) (x :: TK) (target :: Target).
(KnownNat m, KnownSTK x, BaseTensor target) =>
target (TKR2 m x) -> IxROf target m -> target (TKR2 0 x)
rindex0 target (TKR2 n x2)
v IxROf target n
ix) (target (TKR2 n x3) -> IxROf target n -> target (TKR2 0 x3)
forall (m :: Nat) (x :: TK) (target :: Target).
(KnownNat m, KnownSTK x, BaseTensor target) =>
target (TKR2 m x) -> IxROf target m -> target (TKR2 0 x)
rindex0 target (TKR2 n x3)
w IxROf target n
ix))
rzipWith4 :: ( KnownNat m
             , KnownNat n1, KnownNat n2, KnownNat n3, KnownNat n4
             , KnownNat n, KnownSTK x
             , KnownSTK x1, KnownSTK x2, KnownSTK x3, KnownSTK x4
             , BaseTensor target )
          => IShR (m + n)  -- ^ the shape of the resulting tensor
          -> (target (TKR2 n1 x1) -> target (TKR2 n2 x2)
              -> target (TKR2 n3 x3) -> target (TKR2 n4 x4)
              -> target (TKR2 n x))  -- ^ the function to zip with
          -> target (TKR2 (m + n1) x1)  -- ^ the first tensor to zip over
          -> target (TKR2 (m + n2) x2)  -- ^ the second tensor to zip over
          -> target (TKR2 (m + n3) x3)  -- ^ the third tensor to zip over
          -> target (TKR2 (m + n4) x4)  -- ^ the fourth tensor to zip over
          -> target (TKR2 (m + n) x)
rzipWith4 :: forall (m :: Nat) (n1 :: Nat) (n2 :: Nat) (n3 :: Nat) (n4 :: Nat)
       (n :: Nat) (x :: TK) (x1 :: TK) (x2 :: TK) (x3 :: TK) (x4 :: TK)
       (target :: Target).
(KnownNat m, KnownNat n1, KnownNat n2, KnownNat n3, KnownNat n4,
 KnownNat n, KnownSTK x, KnownSTK x1, KnownSTK x2, KnownSTK x3,
 KnownSTK x4, BaseTensor target) =>
IShR (m + n)
-> (target (TKR2 n1 x1)
    -> target (TKR2 n2 x2)
    -> target (TKR2 n3 x3)
    -> target (TKR2 n4 x4)
    -> target (TKR2 n x))
-> target (TKR2 (m + n1) x1)
-> target (TKR2 (m + n2) x2)
-> target (TKR2 (m + n3) x3)
-> target (TKR2 (m + n4) x4)
-> target (TKR2 (m + n) x)
rzipWith4 IShR (m + n)
sh target (TKR2 n1 x1)
-> target (TKR2 n2 x2)
-> target (TKR2 n3 x3)
-> target (TKR2 n4 x4)
-> target (TKR2 n x)
f target (TKR2 (m + n1) x1)
u target (TKR2 (m + n2) x2)
v target (TKR2 (m + n3) x3)
w target (TKR2 (m + n4) x4)
x =
  IShR (m + n)
-> (IxROf target m -> target (TKR2 n x)) -> target (TKR2 (m + n) x)
forall (m :: Nat) (n :: Nat) (x :: TK) (target :: Target).
(KnownNat m, KnownNat n, KnownSTK x, BaseTensor target) =>
IShR (m + n)
-> (IxROf target m -> target (TKR2 n x)) -> target (TKR2 (m + n) x)
rbuild IShR (m + n)
sh (\IxROf target m
ix -> target (TKR2 n1 x1)
-> target (TKR2 n2 x2)
-> target (TKR2 n3 x3)
-> target (TKR2 n4 x4)
-> target (TKR2 n x)
f (target (TKR2 (m + n1) x1)
u target (TKR2 (m + n1) x1) -> IxROf target m -> target (TKR2 n1 x1)
forall (m :: Nat) (n :: Nat) (x :: TK) (target :: Target).
(KnownNat m, KnownNat n, KnownSTK x, BaseTensor target) =>
target (TKR2 (m + n) x) -> IxROf target m -> target (TKR2 n x)
! IxROf target m
ix) (target (TKR2 (m + n2) x2)
v target (TKR2 (m + n2) x2) -> IxROf target m -> target (TKR2 n2 x2)
forall (m :: Nat) (n :: Nat) (x :: TK) (target :: Target).
(KnownNat m, KnownNat n, KnownSTK x, BaseTensor target) =>
target (TKR2 (m + n) x) -> IxROf target m -> target (TKR2 n x)
! IxROf target m
ix) (target (TKR2 (m + n3) x3)
w target (TKR2 (m + n3) x3) -> IxROf target m -> target (TKR2 n3 x3)
forall (m :: Nat) (n :: Nat) (x :: TK) (target :: Target).
(KnownNat m, KnownNat n, KnownSTK x, BaseTensor target) =>
target (TKR2 (m + n) x) -> IxROf target m -> target (TKR2 n x)
! IxROf target m
ix) (target (TKR2 (m + n4) x4)
x target (TKR2 (m + n4) x4) -> IxROf target m -> target (TKR2 n4 x4)
forall (m :: Nat) (n :: Nat) (x :: TK) (target :: Target).
(KnownNat m, KnownNat n, KnownSTK x, BaseTensor target) =>
target (TKR2 (m + n) x) -> IxROf target m -> target (TKR2 n x)
! IxROf target m
ix))
rzipWith41 :: ( KnownNat n1, KnownNat n2, KnownNat n3, KnownNat n4
              , KnownNat n, KnownSTK x
              , KnownSTK x1, KnownSTK x2, KnownSTK x3, KnownSTK x4
              , BaseTensor target )
           => (target (TKR2 n1 x1) -> target (TKR2 n2 x2)
               -> target (TKR2 n3 x3) -> target (TKR2 n4 x4)
               -> target (TKR2 n x))  -- ^ the function to zip with
           -> target (TKR2 (1 + n1) x1)  -- ^ the first tensor to zip over
           -> target (TKR2 (1 + n2) x2)  -- ^ the second tensor to zip over
           -> target (TKR2 (1 + n3) x3)  -- ^ the third tensor to zip over
           -> target (TKR2 (1 + n4) x4)  -- ^ the fourth tensor to zip over
           -> target (TKR2 (1 + n) x)
rzipWith41 :: forall (n1 :: Nat) (n2 :: Nat) (n3 :: Nat) (n4 :: Nat) (n :: Nat)
       (x :: TK) (x1 :: TK) (x2 :: TK) (x3 :: TK) (x4 :: TK)
       (target :: Target).
(KnownNat n1, KnownNat n2, KnownNat n3, KnownNat n4, KnownNat n,
 KnownSTK x, KnownSTK x1, KnownSTK x2, KnownSTK x3, KnownSTK x4,
 BaseTensor target) =>
(target (TKR2 n1 x1)
 -> target (TKR2 n2 x2)
 -> target (TKR2 n3 x3)
 -> target (TKR2 n4 x4)
 -> target (TKR2 n x))
-> target (TKR2 (1 + n1) x1)
-> target (TKR2 (1 + n2) x2)
-> target (TKR2 (1 + n3) x3)
-> target (TKR2 (1 + n4) x4)
-> target (TKR2 (1 + n) x)
rzipWith41 target (TKR2 n1 x1)
-> target (TKR2 n2 x2)
-> target (TKR2 n3 x3)
-> target (TKR2 n4 x4)
-> target (TKR2 n x)
f target (TKR2 (1 + n1) x1)
u target (TKR2 (1 + n2) x2)
v target (TKR2 (1 + n3) x3)
w target (TKR2 (1 + n4) x4)
x =
  Int
-> (PrimalOf target (TKScalar Int64) -> target (TKR2 n x))
-> target (TKR2 (1 + n) x)
forall (n :: Nat) (x :: TK) (target :: Target).
(KnownNat n, KnownSTK x, BaseTensor target) =>
Int
-> (IntOf target -> target (TKR2 n x)) -> target (TKR2 (1 + n) x)
rbuild1 (target (TKR2 (1 + n1) x1) -> Int
forall (n :: Nat) (x :: TK).
KnownSTK x =>
target (TKR2 (1 + n) x) -> Int
forall (target :: Target) (n :: Nat) (x :: TK).
(BaseTensor target, KnownSTK x) =>
target (TKR2 (1 + n) x) -> Int
rwidth target (TKR2 (1 + n1) x1)
u) (\PrimalOf target (TKScalar Int64)
i -> target (TKR2 n1 x1)
-> target (TKR2 n2 x2)
-> target (TKR2 n3 x3)
-> target (TKR2 n4 x4)
-> target (TKR2 n x)
f (target (TKR2 (1 + n1) x1)
u target (TKR2 (1 + n1) x1)
-> IxR 1 (PrimalOf target (TKScalar Int64)) -> target (TKR2 n1 x1)
forall (m :: Nat) (n :: Nat) (x :: TK) (target :: Target).
(KnownNat m, KnownNat n, KnownSTK x, BaseTensor target) =>
target (TKR2 (m + n) x) -> IxROf target m -> target (TKR2 n x)
! [Item (IxR 1 (PrimalOf target (TKScalar Int64)))
PrimalOf target (TKScalar Int64)
i]) (target (TKR2 (1 + n2) x2)
v target (TKR2 (1 + n2) x2)
-> IxR 1 (PrimalOf target (TKScalar Int64)) -> target (TKR2 n2 x2)
forall (m :: Nat) (n :: Nat) (x :: TK) (target :: Target).
(KnownNat m, KnownNat n, KnownSTK x, BaseTensor target) =>
target (TKR2 (m + n) x) -> IxROf target m -> target (TKR2 n x)
! [Item (IxR 1 (PrimalOf target (TKScalar Int64)))
PrimalOf target (TKScalar Int64)
i]) (target (TKR2 (1 + n3) x3)
w target (TKR2 (1 + n3) x3)
-> IxR 1 (PrimalOf target (TKScalar Int64)) -> target (TKR2 n3 x3)
forall (m :: Nat) (n :: Nat) (x :: TK) (target :: Target).
(KnownNat m, KnownNat n, KnownSTK x, BaseTensor target) =>
target (TKR2 (m + n) x) -> IxROf target m -> target (TKR2 n x)
! [Item (IxR 1 (PrimalOf target (TKScalar Int64)))
PrimalOf target (TKScalar Int64)
i]) (target (TKR2 (1 + n4) x4)
x target (TKR2 (1 + n4) x4)
-> IxR 1 (PrimalOf target (TKScalar Int64)) -> target (TKR2 n4 x4)
forall (m :: Nat) (n :: Nat) (x :: TK) (target :: Target).
(KnownNat m, KnownNat n, KnownSTK x, BaseTensor target) =>
target (TKR2 (m + n) x) -> IxROf target m -> target (TKR2 n x)
! [Item (IxR 1 (PrimalOf target (TKScalar Int64)))
PrimalOf target (TKScalar Int64)
i]))
rzipWith40N :: ( KnownNat n, KnownSTK x
               , KnownSTK x1, KnownSTK x2, KnownSTK x3, KnownSTK x4
               , BaseTensor target )
            => (target (TKR2 0 x1) -> target (TKR2 0 x2)
                -> target (TKR2 0 x3) -> target (TKR2 0 x4)
                -> target (TKR2 0 x))  -- ^ the function to zip with
            -> target (TKR2 n x1)  -- ^ the first tensor to zip over
            -> target (TKR2 n x2)  -- ^ the second tensor to zip over
            -> target (TKR2 n x3)  -- ^ the third tensor to zip over
            -> target (TKR2 n x4)  -- ^ the fourth tensor to zip over
            -> target (TKR2 n x)
rzipWith40N :: forall (n :: Nat) (x :: TK) (x1 :: TK) (x2 :: TK) (x3 :: TK)
       (x4 :: TK) (target :: Target).
(KnownNat n, KnownSTK x, KnownSTK x1, KnownSTK x2, KnownSTK x3,
 KnownSTK x4, BaseTensor target) =>
(target (TKR2 0 x1)
 -> target (TKR2 0 x2)
 -> target (TKR2 0 x3)
 -> target (TKR2 0 x4)
 -> target (TKR2 0 x))
-> target (TKR2 n x1)
-> target (TKR2 n x2)
-> target (TKR2 n x3)
-> target (TKR2 n x4)
-> target (TKR2 n x)
rzipWith40N target (TKR2 0 x1)
-> target (TKR2 0 x2)
-> target (TKR2 0 x3)
-> target (TKR2 0 x4)
-> target (TKR2 0 x)
f target (TKR2 n x1)
u target (TKR2 n x2)
v target (TKR2 n x3)
w target (TKR2 n x4)
x =
  IShR (n + 0)
-> (IxROf target n -> target (TKR2 0 x)) -> target (TKR2 (n + 0) x)
forall (m :: Nat) (n :: Nat) (x :: TK) (target :: Target).
(KnownNat m, KnownNat n, KnownSTK x, BaseTensor target) =>
IShR (m + n)
-> (IxROf target m -> target (TKR2 n x)) -> target (TKR2 (m + n) x)
rbuild (target (TKR2 n x2) -> IShR n
forall (n :: Nat) (x :: TK).
KnownSTK x =>
target (TKR2 n x) -> IShR n
forall (target :: Target) (n :: Nat) (x :: TK).
(BaseTensor target, KnownSTK x) =>
target (TKR2 n x) -> IShR n
rshape target (TKR2 n x2)
v) (\IxROf target n
ix -> target (TKR2 0 x1)
-> target (TKR2 0 x2)
-> target (TKR2 0 x3)
-> target (TKR2 0 x4)
-> target (TKR2 0 x)
f (target (TKR2 n x1) -> IxROf target n -> target (TKR2 0 x1)
forall (m :: Nat) (x :: TK) (target :: Target).
(KnownNat m, KnownSTK x, BaseTensor target) =>
target (TKR2 m x) -> IxROf target m -> target (TKR2 0 x)
rindex0 target (TKR2 n x1)
u IxROf target n
ix) (target (TKR2 n x2) -> IxROf target n -> target (TKR2 0 x2)
forall (m :: Nat) (x :: TK) (target :: Target).
(KnownNat m, KnownSTK x, BaseTensor target) =>
target (TKR2 m x) -> IxROf target m -> target (TKR2 0 x)
rindex0 target (TKR2 n x2)
v IxROf target n
ix) (target (TKR2 n x3) -> IxROf target n -> target (TKR2 0 x3)
forall (m :: Nat) (x :: TK) (target :: Target).
(KnownNat m, KnownSTK x, BaseTensor target) =>
target (TKR2 m x) -> IxROf target m -> target (TKR2 0 x)
rindex0 target (TKR2 n x3)
w IxROf target n
ix)
                              (target (TKR2 n x4) -> IxROf target n -> target (TKR2 0 x4)
forall (m :: Nat) (x :: TK) (target :: Target).
(KnownNat m, KnownSTK x, BaseTensor target) =>
target (TKR2 m x) -> IxROf target m -> target (TKR2 0 x)
rindex0 target (TKR2 n x4)
x IxROf target n
ix))

sbuild1 :: (KnownNat k, KnownShS sh, KnownSTK x, BaseTensor target)
        => (IntOf target -> target (TKS2 sh x))  -- ^ the function to build with
        -> target (TKS2 (k ': sh) x)
sbuild1 :: forall (k :: Nat) (sh :: [Nat]) (x :: TK) (target :: Target).
(KnownNat k, KnownShS sh, KnownSTK x, BaseTensor target) =>
(IntOf target -> target (TKS2 sh x))
-> target (TKS2 ((':) @Nat k sh) x)
sbuild1 = (IntOf target -> target (TKS2 sh x))
-> target (TKS2 ((':) @Nat k sh) x)
forall (k :: Nat) (sh :: [Nat]) (x :: TK).
(KnownNat k, KnownShS sh, KnownSTK x) =>
(IntOf target -> target (TKS2 sh x))
-> target (TKS2 ((':) @Nat k sh) x)
forall (target :: Target) (k :: Nat) (sh :: [Nat]) (x :: TK).
(BaseTensor target, KnownNat k, KnownShS sh, KnownSTK x) =>
(IntOf target -> target (TKS2 sh x))
-> target (TKS2 ((':) @Nat k sh) x)
tsbuild1
smap :: ( KnownShS (Take m sh), KnownShS (Drop m sh), KnownShS sh
        , KnownSTK x, KnownSTK x2
        , BaseTensor target )
     => (target (TKS2 (Drop m sh) x) -> target (TKS2 (Drop m sh) x2))
          -- ^ the function to map with
     -> target (TKS2 sh x)  -- ^ the tensor to map over
     -> target (TKS2 sh x2)
smap :: forall (m :: Nat) (sh :: [Nat]) (x :: TK) (x2 :: TK)
       (target :: Target).
(KnownShS (Take @Nat m sh), KnownShS (Drop @Nat m sh), KnownShS sh,
 KnownSTK x, KnownSTK x2, BaseTensor target) =>
(target (TKS2 (Drop @Nat m sh) x)
 -> target (TKS2 (Drop @Nat m sh) x2))
-> target (TKS2 sh x) -> target (TKS2 sh x2)
smap @m @sh target (TKS2 (Drop @Nat m sh) x)
-> target (TKS2 (Drop @Nat m sh) x2)
f target (TKS2 sh x)
v = (:~:) @[Nat] sh ((++) @Nat (Take @Nat m sh) (Drop @Nat m sh))
-> (((sh :: [Nat])
     ~ ((++) @Nat (Take @Nat m sh) (Drop @Nat m sh) :: [Nat])) =>
    target (TKS2 sh x2))
-> target (TKS2 sh x2)
forall {k} (a :: k) (b :: k) r.
(:~:) @k a b -> (((a :: k) ~ (b :: k)) => r) -> r
gcastWith ((:~:) @[Nat] sh ((++) @Nat (Take @Nat m sh) (Drop @Nat m sh))
forall {k} (a :: k) (b :: k). (:~:) @k a b
unsafeCoerceRefl
                             :: sh :~: Take m sh ++ Drop m sh)
                  ((((sh :: [Nat])
   ~ ((++) @Nat (Take @Nat m sh) (Drop @Nat m sh) :: [Nat])) =>
  target (TKS2 sh x2))
 -> target (TKS2 sh x2))
-> (((sh :: [Nat])
     ~ ((++) @Nat (Take @Nat m sh) (Drop @Nat m sh) :: [Nat])) =>
    target (TKS2 sh x2))
-> target (TKS2 sh x2)
forall a b. (a -> b) -> a -> b
$ (IxSOf target (Take @Nat m sh)
 -> target (TKS2 (Drop @Nat m sh) x2))
-> target (TKS2 sh x2)
forall (m :: Nat) (sh :: [Nat]) (x :: TK) (target :: Target).
(KnownShS (Take @Nat m sh), KnownShS sh, KnownSTK x,
 BaseTensor target) =>
(IxSOf target (Take @Nat m sh) -> target (TKS2 (Drop @Nat m sh) x))
-> target (TKS2 sh x)
sbuild (\IxSOf target (Take @Nat m sh)
ix -> target (TKS2 (Drop @Nat m sh) x)
-> target (TKS2 (Drop @Nat m sh) x2)
f (target (TKS2 sh x)
target (TKS2 ((++) @Nat (Take @Nat m sh) (Drop @Nat m sh)) x)
v target (TKS2 ((++) @Nat (Take @Nat m sh) (Drop @Nat m sh)) x)
-> IxSOf target (Take @Nat m sh)
-> target (TKS2 (Drop @Nat m sh) x)
forall (shm :: [Nat]) (shn :: [Nat]) (x :: TK) (target :: Target).
(KnownShS shm, KnownShS shn, KnownSTK x, BaseTensor target) =>
target (TKS2 ((++) @Nat shm shn) x)
-> IxSOf target shm -> target (TKS2 shn x)
!$ IxSOf target (Take @Nat m sh)
ix))
smap1 :: (KnownNat n, KnownShS sh, KnownSTK x, KnownSTK x2, BaseTensor target)
      => (target (TKS2 sh x) -> target (TKS2 sh x2))
           -- ^ the function to map with
      -> target (TKS2 (n ': sh) x)  -- ^ the tensor to map over
      -> target (TKS2 (n ': sh) x2)
smap1 :: forall (n :: Nat) (sh :: [Nat]) (x :: TK) (x2 :: TK)
       (target :: Target).
(KnownNat n, KnownShS sh, KnownSTK x, KnownSTK x2,
 BaseTensor target) =>
(target (TKS2 sh x) -> target (TKS2 sh x2))
-> target (TKS2 ((':) @Nat n sh) x)
-> target (TKS2 ((':) @Nat n sh) x2)
smap1 target (TKS2 sh x) -> target (TKS2 sh x2)
f target (TKS2 ((':) @Nat n sh) x)
u = (IntOf target -> target (TKS2 sh x2))
-> target (TKS2 ((':) @Nat n sh) x2)
forall (k :: Nat) (sh :: [Nat]) (x :: TK) (target :: Target).
(KnownNat k, KnownShS sh, KnownSTK x, BaseTensor target) =>
(IntOf target -> target (TKS2 sh x))
-> target (TKS2 ((':) @Nat k sh) x)
sbuild1 (\IntOf target
i -> target (TKS2 sh x) -> target (TKS2 sh x2)
f (target (TKS2 ((':) @Nat n sh) x)
target (TKS2 ((++) @Nat ((':) @Nat n ('[] @Nat)) sh) x)
u target (TKS2 ((++) @Nat ((':) @Nat n ('[] @Nat)) sh) x)
-> IxSOf target ((':) @Nat n ('[] @Nat)) -> target (TKS2 sh x)
forall (shm :: [Nat]) (shn :: [Nat]) (x :: TK) (target :: Target).
(KnownShS shm, KnownShS shn, KnownSTK x, BaseTensor target) =>
target (TKS2 ((++) @Nat shm shn) x)
-> IxSOf target shm -> target (TKS2 shn x)
!$ (IntOf target
i IntOf target
-> IxS ('[] @Nat) (IntOf target)
-> IxSOf target ((':) @Nat n ('[] @Nat))
forall {sh1 :: [Nat]} {i} (n :: Nat) (sh :: [Nat]).
(KnownNat n, ((':) @Nat n sh :: [Nat]) ~ (sh1 :: [Nat])) =>
i -> IxS sh i -> IxS sh1 i
:.$ IxS ('[] @Nat) (IntOf target)
forall (sh :: [Nat]) i.
((sh :: [Nat]) ~ ('[] @Nat :: [Nat])) =>
IxS sh i
ZIS)))
smap0N :: (KnownShS sh, KnownSTK x1, KnownSTK x, BaseTensor target)
       => (target (TKS2 '[] x1) -> target (TKS2 '[] x))
            -- ^ the function to map with
       -> target (TKS2 sh x1)  -- ^ the tensor to map over
       -> target (TKS2 sh x)
smap0N :: forall (sh :: [Nat]) (x1 :: TK) (x :: TK) (target :: Target).
(KnownShS sh, KnownSTK x1, KnownSTK x, BaseTensor target) =>
(target (TKS2 ('[] @Nat) x1) -> target (TKS2 ('[] @Nat) x))
-> target (TKS2 sh x1) -> target (TKS2 sh x)
smap0N = (target (TKS2 ('[] @Nat) x1) -> target (TKS2 ('[] @Nat) x))
-> target (TKS2 sh x1) -> target (TKS2 sh x)
forall (sh :: [Nat]) (x :: TK) (x1 :: TK).
(KnownShS sh, KnownSTK x, KnownSTK x1) =>
(target (TKS2 ('[] @Nat) x1) -> target (TKS2 ('[] @Nat) x))
-> target (TKS2 sh x1) -> target (TKS2 sh x)
forall (target :: Target) (sh :: [Nat]) (x :: TK) (x1 :: TK).
(BaseTensor target, KnownShS sh, KnownSTK x, KnownSTK x1) =>
(target (TKS2 ('[] @Nat) x1) -> target (TKS2 ('[] @Nat) x))
-> target (TKS2 sh x1) -> target (TKS2 sh x)
tsmap0N
szipWith :: ( KnownShS (Drop m sh1), KnownShS (Drop m sh2), KnownShS (Take m sh)
            , KnownSTK x, KnownSTK x1, KnownSTK x2, KnownShS sh
            , sh1 ~ Take m sh ++ Drop m sh1
            , sh2 ~ Take m sh ++ Drop m sh2, BaseTensor target )
         => (target (TKS2 (Drop m sh1) x1) -> target (TKS2 (Drop m sh2) x2)
             -> target (TKS2 (Drop m sh) x))  -- ^ the function to zip with
         -> target (TKS2 sh1 x1)  -- ^ the first tensor to zip over
         -> target (TKS2 sh2 x2)  -- ^ the second tensor to zip over
         -> target (TKS2 sh x)
szipWith :: forall (m :: Nat) (sh1 :: [Nat]) (sh2 :: [Nat]) (sh :: [Nat])
       (x :: TK) (x1 :: TK) (x2 :: TK) (target :: Target).
(KnownShS (Drop @Nat m sh1), KnownShS (Drop @Nat m sh2),
 KnownShS (Take @Nat m sh), KnownSTK x, KnownSTK x1, KnownSTK x2,
 KnownShS sh,
 (sh1 :: [Nat])
 ~ ((++) @Nat (Take @Nat m sh) (Drop @Nat m sh1) :: [Nat]),
 (sh2 :: [Nat])
 ~ ((++) @Nat (Take @Nat m sh) (Drop @Nat m sh2) :: [Nat]),
 BaseTensor target) =>
(target (TKS2 (Drop @Nat m sh1) x1)
 -> target (TKS2 (Drop @Nat m sh2) x2)
 -> target (TKS2 (Drop @Nat m sh) x))
-> target (TKS2 sh1 x1)
-> target (TKS2 sh2 x2)
-> target (TKS2 sh x)
szipWith target (TKS2 (Drop @Nat m sh1) x1)
-> target (TKS2 (Drop @Nat m sh2) x2)
-> target (TKS2 (Drop @Nat m sh) x)
f target (TKS2 sh1 x1)
u target (TKS2 sh2 x2)
v = (IxSOf target (Take @Nat m sh) -> target (TKS2 (Drop @Nat m sh) x))
-> target (TKS2 sh x)
forall (m :: Nat) (sh :: [Nat]) (x :: TK) (target :: Target).
(KnownShS (Take @Nat m sh), KnownShS sh, KnownSTK x,
 BaseTensor target) =>
(IxSOf target (Take @Nat m sh) -> target (TKS2 (Drop @Nat m sh) x))
-> target (TKS2 sh x)
sbuild (\IxSOf target (Take @Nat m sh)
ix -> target (TKS2 (Drop @Nat m sh1) x1)
-> target (TKS2 (Drop @Nat m sh2) x2)
-> target (TKS2 (Drop @Nat m sh) x)
f (target (TKS2 sh1 x1)
target (TKS2 ((++) @Nat (Take @Nat m sh) (Drop @Nat m sh1)) x1)
u target (TKS2 ((++) @Nat (Take @Nat m sh) (Drop @Nat m sh1)) x1)
-> IxSOf target (Take @Nat m sh)
-> target (TKS2 (Drop @Nat m sh1) x1)
forall (shm :: [Nat]) (shn :: [Nat]) (x :: TK) (target :: Target).
(KnownShS shm, KnownShS shn, KnownSTK x, BaseTensor target) =>
target (TKS2 ((++) @Nat shm shn) x)
-> IxSOf target shm -> target (TKS2 shn x)
!$ IxSOf target (Take @Nat m sh)
ix) (target (TKS2 sh2 x2)
target (TKS2 ((++) @Nat (Take @Nat m sh) (Drop @Nat m sh2)) x2)
v target (TKS2 ((++) @Nat (Take @Nat m sh) (Drop @Nat m sh2)) x2)
-> IxSOf target (Take @Nat m sh)
-> target (TKS2 (Drop @Nat m sh2) x2)
forall (shm :: [Nat]) (shn :: [Nat]) (x :: TK) (target :: Target).
(KnownShS shm, KnownShS shn, KnownSTK x, BaseTensor target) =>
target (TKS2 ((++) @Nat shm shn) x)
-> IxSOf target shm -> target (TKS2 shn x)
!$ IxSOf target (Take @Nat m sh)
ix))
szipWith1 :: ( KnownNat n, KnownShS sh1, KnownShS sh2, KnownShS sh
             , KnownSTK x, KnownSTK x1, KnownSTK x2, BaseTensor target )
          => (target (TKS2 sh1 x1) -> target (TKS2 sh2 x2)
              -> target (TKS2 sh x))  -- ^ the function to zip with
          -> target (TKS2 (n ': sh1) x1)  -- ^ the first tensor to zip over
          -> target (TKS2 (n ': sh2) x2)  -- ^ the second tensor to zip over
          -> target (TKS2 (n ': sh) x)
szipWith1 :: forall (n :: Nat) (sh1 :: [Nat]) (sh2 :: [Nat]) (sh :: [Nat])
       (x :: TK) (x1 :: TK) (x2 :: TK) (target :: Target).
(KnownNat n, KnownShS sh1, KnownShS sh2, KnownShS sh, KnownSTK x,
 KnownSTK x1, KnownSTK x2, BaseTensor target) =>
(target (TKS2 sh1 x1)
 -> target (TKS2 sh2 x2) -> target (TKS2 sh x))
-> target (TKS2 ((':) @Nat n sh1) x1)
-> target (TKS2 ((':) @Nat n sh2) x2)
-> target (TKS2 ((':) @Nat n sh) x)
szipWith1 target (TKS2 sh1 x1) -> target (TKS2 sh2 x2) -> target (TKS2 sh x)
f target (TKS2 ((':) @Nat n sh1) x1)
u target (TKS2 ((':) @Nat n sh2) x2)
v = (IntOf target -> target (TKS2 sh x))
-> target (TKS2 ((':) @Nat n sh) x)
forall (k :: Nat) (sh :: [Nat]) (x :: TK) (target :: Target).
(KnownNat k, KnownShS sh, KnownSTK x, BaseTensor target) =>
(IntOf target -> target (TKS2 sh x))
-> target (TKS2 ((':) @Nat k sh) x)
sbuild1 (\IntOf target
i -> target (TKS2 sh1 x1) -> target (TKS2 sh2 x2) -> target (TKS2 sh x)
f (target (TKS2 ((':) @Nat n sh1) x1)
target (TKS2 ((++) @Nat ((':) @Nat n ('[] @Nat)) sh1) x1)
u target (TKS2 ((++) @Nat ((':) @Nat n ('[] @Nat)) sh1) x1)
-> IxSOf target ((':) @Nat n ('[] @Nat)) -> target (TKS2 sh1 x1)
forall (shm :: [Nat]) (shn :: [Nat]) (x :: TK) (target :: Target).
(KnownShS shm, KnownShS shn, KnownSTK x, BaseTensor target) =>
target (TKS2 ((++) @Nat shm shn) x)
-> IxSOf target shm -> target (TKS2 shn x)
!$ (IntOf target
i IntOf target
-> IxS ('[] @Nat) (IntOf target)
-> IxSOf target ((':) @Nat n ('[] @Nat))
forall {sh1 :: [Nat]} {i} (n :: Nat) (sh :: [Nat]).
(KnownNat n, ((':) @Nat n sh :: [Nat]) ~ (sh1 :: [Nat])) =>
i -> IxS sh i -> IxS sh1 i
:.$ IxS ('[] @Nat) (IntOf target)
forall (sh :: [Nat]) i.
((sh :: [Nat]) ~ ('[] @Nat :: [Nat])) =>
IxS sh i
ZIS))
                                   (target (TKS2 ((':) @Nat n sh2) x2)
target (TKS2 ((++) @Nat ((':) @Nat n ('[] @Nat)) sh2) x2)
v target (TKS2 ((++) @Nat ((':) @Nat n ('[] @Nat)) sh2) x2)
-> IxSOf target ((':) @Nat n ('[] @Nat)) -> target (TKS2 sh2 x2)
forall (shm :: [Nat]) (shn :: [Nat]) (x :: TK) (target :: Target).
(KnownShS shm, KnownShS shn, KnownSTK x, BaseTensor target) =>
target (TKS2 ((++) @Nat shm shn) x)
-> IxSOf target shm -> target (TKS2 shn x)
!$ (IntOf target
i IntOf target
-> IxS ('[] @Nat) (IntOf target)
-> IxSOf target ((':) @Nat n ('[] @Nat))
forall {sh1 :: [Nat]} {i} (n :: Nat) (sh :: [Nat]).
(KnownNat n, ((':) @Nat n sh :: [Nat]) ~ (sh1 :: [Nat])) =>
i -> IxS sh i -> IxS sh1 i
:.$ IxS ('[] @Nat) (IntOf target)
forall (sh :: [Nat]) i.
((sh :: [Nat]) ~ ('[] @Nat :: [Nat])) =>
IxS sh i
ZIS)))
szipWith0N :: ( KnownShS sh, KnownSTK x, KnownSTK x1, KnownSTK x2
              , BaseTensor target )
           => (target (TKS2 '[] x1) -> target (TKS2 '[] x2)
               -> target (TKS2 '[] x))  -- ^ the function to zip with
           -> target (TKS2 sh x1)  -- ^ the first tensor to zip over
           -> target (TKS2 sh x2)  -- ^ the second tensor to zip over
           -> target (TKS2 sh x)
szipWith0N :: forall (sh :: [Nat]) (x :: TK) (x1 :: TK) (x2 :: TK)
       (target :: Target).
(KnownShS sh, KnownSTK x, KnownSTK x1, KnownSTK x2,
 BaseTensor target) =>
(target (TKS2 ('[] @Nat) x1)
 -> target (TKS2 ('[] @Nat) x2) -> target (TKS2 ('[] @Nat) x))
-> target (TKS2 sh x1) -> target (TKS2 sh x2) -> target (TKS2 sh x)
szipWith0N = (target (TKS2 ('[] @Nat) x1)
 -> target (TKS2 ('[] @Nat) x2) -> target (TKS2 ('[] @Nat) x))
-> target (TKS2 sh x1) -> target (TKS2 sh x2) -> target (TKS2 sh x)
forall (sh :: [Nat]) (x :: TK) (x1 :: TK) (x2 :: TK).
(KnownShS sh, KnownSTK x, KnownSTK x1, KnownSTK x2) =>
(target (TKS2 ('[] @Nat) x1)
 -> target (TKS2 ('[] @Nat) x2) -> target (TKS2 ('[] @Nat) x))
-> target (TKS2 sh x1) -> target (TKS2 sh x2) -> target (TKS2 sh x)
forall (target :: Target) (sh :: [Nat]) (x :: TK) (x1 :: TK)
       (x2 :: TK).
(BaseTensor target, KnownShS sh, KnownSTK x, KnownSTK x1,
 KnownSTK x2) =>
(target (TKS2 ('[] @Nat) x1)
 -> target (TKS2 ('[] @Nat) x2) -> target (TKS2 ('[] @Nat) x))
-> target (TKS2 sh x1) -> target (TKS2 sh x2) -> target (TKS2 sh x)
tszipWith0N
szipWith3 :: ( KnownShS (Drop m sh1), KnownShS (Drop m sh2)
             , KnownShS (Drop m sh3), KnownShS (Take m sh), KnownShS sh
             , KnownSTK x, KnownSTK x1, KnownSTK x2, KnownSTK x3
             , sh1 ~ Take m sh ++ Drop m sh1
             , sh2 ~ Take m sh ++ Drop m sh2
             , sh3 ~ Take m sh ++ Drop m sh3, BaseTensor target )
          => (target (TKS2 (Drop m sh1) x1) -> target (TKS2 (Drop m sh2) x2)
              -> target (TKS2 (Drop m sh3) x3)
              -> target (TKS2 (Drop m sh) x))  -- ^ the function to zip with
          -> target (TKS2 sh1 x1)  -- ^ the first tensor to zip over
          -> target (TKS2 sh2 x2)  -- ^ the second tensor to zip over
          -> target (TKS2 sh3 x3)  -- ^ the third tensor to zip over
          -> target (TKS2 sh x)
szipWith3 :: forall (m :: Nat) (sh1 :: [Nat]) (sh2 :: [Nat]) (sh3 :: [Nat])
       (sh :: [Nat]) (x :: TK) (x1 :: TK) (x2 :: TK) (x3 :: TK)
       (target :: Target).
(KnownShS (Drop @Nat m sh1), KnownShS (Drop @Nat m sh2),
 KnownShS (Drop @Nat m sh3), KnownShS (Take @Nat m sh), KnownShS sh,
 KnownSTK x, KnownSTK x1, KnownSTK x2, KnownSTK x3,
 (sh1 :: [Nat])
 ~ ((++) @Nat (Take @Nat m sh) (Drop @Nat m sh1) :: [Nat]),
 (sh2 :: [Nat])
 ~ ((++) @Nat (Take @Nat m sh) (Drop @Nat m sh2) :: [Nat]),
 (sh3 :: [Nat])
 ~ ((++) @Nat (Take @Nat m sh) (Drop @Nat m sh3) :: [Nat]),
 BaseTensor target) =>
(target (TKS2 (Drop @Nat m sh1) x1)
 -> target (TKS2 (Drop @Nat m sh2) x2)
 -> target (TKS2 (Drop @Nat m sh3) x3)
 -> target (TKS2 (Drop @Nat m sh) x))
-> target (TKS2 sh1 x1)
-> target (TKS2 sh2 x2)
-> target (TKS2 sh3 x3)
-> target (TKS2 sh x)
szipWith3 target (TKS2 (Drop @Nat m sh1) x1)
-> target (TKS2 (Drop @Nat m sh2) x2)
-> target (TKS2 (Drop @Nat m sh3) x3)
-> target (TKS2 (Drop @Nat m sh) x)
f target (TKS2 sh1 x1)
u target (TKS2 sh2 x2)
v target (TKS2 sh3 x3)
w = (IxSOf target (Take @Nat m sh) -> target (TKS2 (Drop @Nat m sh) x))
-> target (TKS2 sh x)
forall (m :: Nat) (sh :: [Nat]) (x :: TK) (target :: Target).
(KnownShS (Take @Nat m sh), KnownShS sh, KnownSTK x,
 BaseTensor target) =>
(IxSOf target (Take @Nat m sh) -> target (TKS2 (Drop @Nat m sh) x))
-> target (TKS2 sh x)
sbuild (\IxSOf target (Take @Nat m sh)
ix -> target (TKS2 (Drop @Nat m sh1) x1)
-> target (TKS2 (Drop @Nat m sh2) x2)
-> target (TKS2 (Drop @Nat m sh3) x3)
-> target (TKS2 (Drop @Nat m sh) x)
f (target (TKS2 sh1 x1)
target (TKS2 ((++) @Nat (Take @Nat m sh) (Drop @Nat m sh1)) x1)
u target (TKS2 ((++) @Nat (Take @Nat m sh) (Drop @Nat m sh1)) x1)
-> IxSOf target (Take @Nat m sh)
-> target (TKS2 (Drop @Nat m sh1) x1)
forall (shm :: [Nat]) (shn :: [Nat]) (x :: TK) (target :: Target).
(KnownShS shm, KnownShS shn, KnownSTK x, BaseTensor target) =>
target (TKS2 ((++) @Nat shm shn) x)
-> IxSOf target shm -> target (TKS2 shn x)
!$ IxSOf target (Take @Nat m sh)
ix) (target (TKS2 sh2 x2)
target (TKS2 ((++) @Nat (Take @Nat m sh) (Drop @Nat m sh2)) x2)
v target (TKS2 ((++) @Nat (Take @Nat m sh) (Drop @Nat m sh2)) x2)
-> IxSOf target (Take @Nat m sh)
-> target (TKS2 (Drop @Nat m sh2) x2)
forall (shm :: [Nat]) (shn :: [Nat]) (x :: TK) (target :: Target).
(KnownShS shm, KnownShS shn, KnownSTK x, BaseTensor target) =>
target (TKS2 ((++) @Nat shm shn) x)
-> IxSOf target shm -> target (TKS2 shn x)
!$ IxSOf target (Take @Nat m sh)
ix) (target (TKS2 sh3 x3)
target (TKS2 ((++) @Nat (Take @Nat m sh) (Drop @Nat m sh3)) x3)
w target (TKS2 ((++) @Nat (Take @Nat m sh) (Drop @Nat m sh3)) x3)
-> IxSOf target (Take @Nat m sh)
-> target (TKS2 (Drop @Nat m sh3) x3)
forall (shm :: [Nat]) (shn :: [Nat]) (x :: TK) (target :: Target).
(KnownShS shm, KnownShS shn, KnownSTK x, BaseTensor target) =>
target (TKS2 ((++) @Nat shm shn) x)
-> IxSOf target shm -> target (TKS2 shn x)
!$ IxSOf target (Take @Nat m sh)
ix))
szipWith31 :: ( KnownNat n
              , KnownShS sh1, KnownShS sh2, KnownShS sh3, KnownShS sh
              , KnownSTK x, KnownSTK x1, KnownSTK x2, KnownSTK x3
              , BaseTensor target )
           => (target (TKS2 sh1 x1) -> target (TKS2 sh2 x2)
               -> target (TKS2 sh3 x3)
               -> target (TKS2 sh x))  -- ^ the function to zip with
           -> target (TKS2 (n ': sh1) x1)  -- ^ the first tensor to zip over
           -> target (TKS2 (n ': sh2) x2)  -- ^ the second tensor to zip over
           -> target (TKS2 (n ': sh3) x3)  -- ^ the third tensor to zip over
           -> target (TKS2 (n ': sh) x)
szipWith31 :: forall (n :: Nat) (sh1 :: [Nat]) (sh2 :: [Nat]) (sh3 :: [Nat])
       (sh :: [Nat]) (x :: TK) (x1 :: TK) (x2 :: TK) (x3 :: TK)
       (target :: Target).
(KnownNat n, KnownShS sh1, KnownShS sh2, KnownShS sh3, KnownShS sh,
 KnownSTK x, KnownSTK x1, KnownSTK x2, KnownSTK x3,
 BaseTensor target) =>
(target (TKS2 sh1 x1)
 -> target (TKS2 sh2 x2)
 -> target (TKS2 sh3 x3)
 -> target (TKS2 sh x))
-> target (TKS2 ((':) @Nat n sh1) x1)
-> target (TKS2 ((':) @Nat n sh2) x2)
-> target (TKS2 ((':) @Nat n sh3) x3)
-> target (TKS2 ((':) @Nat n sh) x)
szipWith31 target (TKS2 sh1 x1)
-> target (TKS2 sh2 x2)
-> target (TKS2 sh3 x3)
-> target (TKS2 sh x)
f target (TKS2 ((':) @Nat n sh1) x1)
u target (TKS2 ((':) @Nat n sh2) x2)
v target (TKS2 ((':) @Nat n sh3) x3)
w = (IntOf target -> target (TKS2 sh x))
-> target (TKS2 ((':) @Nat n sh) x)
forall (k :: Nat) (sh :: [Nat]) (x :: TK) (target :: Target).
(KnownNat k, KnownShS sh, KnownSTK x, BaseTensor target) =>
(IntOf target -> target (TKS2 sh x))
-> target (TKS2 ((':) @Nat k sh) x)
sbuild1 (\IntOf target
i -> target (TKS2 sh1 x1)
-> target (TKS2 sh2 x2)
-> target (TKS2 sh3 x3)
-> target (TKS2 sh x)
f (target (TKS2 ((':) @Nat n sh1) x1)
target (TKS2 ((++) @Nat ((':) @Nat n ('[] @Nat)) sh1) x1)
u target (TKS2 ((++) @Nat ((':) @Nat n ('[] @Nat)) sh1) x1)
-> IxSOf target ((':) @Nat n ('[] @Nat)) -> target (TKS2 sh1 x1)
forall (shm :: [Nat]) (shn :: [Nat]) (x :: TK) (target :: Target).
(KnownShS shm, KnownShS shn, KnownSTK x, BaseTensor target) =>
target (TKS2 ((++) @Nat shm shn) x)
-> IxSOf target shm -> target (TKS2 shn x)
!$ (IntOf target
i IntOf target
-> IxS ('[] @Nat) (IntOf target)
-> IxSOf target ((':) @Nat n ('[] @Nat))
forall {sh1 :: [Nat]} {i} (n :: Nat) (sh :: [Nat]).
(KnownNat n, ((':) @Nat n sh :: [Nat]) ~ (sh1 :: [Nat])) =>
i -> IxS sh i -> IxS sh1 i
:.$ IxS ('[] @Nat) (IntOf target)
forall (sh :: [Nat]) i.
((sh :: [Nat]) ~ ('[] @Nat :: [Nat])) =>
IxS sh i
ZIS))
                                      (target (TKS2 ((':) @Nat n sh2) x2)
target (TKS2 ((++) @Nat ((':) @Nat n ('[] @Nat)) sh2) x2)
v target (TKS2 ((++) @Nat ((':) @Nat n ('[] @Nat)) sh2) x2)
-> IxSOf target ((':) @Nat n ('[] @Nat)) -> target (TKS2 sh2 x2)
forall (shm :: [Nat]) (shn :: [Nat]) (x :: TK) (target :: Target).
(KnownShS shm, KnownShS shn, KnownSTK x, BaseTensor target) =>
target (TKS2 ((++) @Nat shm shn) x)
-> IxSOf target shm -> target (TKS2 shn x)
!$ (IntOf target
i IntOf target
-> IxS ('[] @Nat) (IntOf target)
-> IxSOf target ((':) @Nat n ('[] @Nat))
forall {sh1 :: [Nat]} {i} (n :: Nat) (sh :: [Nat]).
(KnownNat n, ((':) @Nat n sh :: [Nat]) ~ (sh1 :: [Nat])) =>
i -> IxS sh i -> IxS sh1 i
:.$ IxS ('[] @Nat) (IntOf target)
forall (sh :: [Nat]) i.
((sh :: [Nat]) ~ ('[] @Nat :: [Nat])) =>
IxS sh i
ZIS))
                                      (target (TKS2 ((':) @Nat n sh3) x3)
target (TKS2 ((++) @Nat ((':) @Nat n ('[] @Nat)) sh3) x3)
w target (TKS2 ((++) @Nat ((':) @Nat n ('[] @Nat)) sh3) x3)
-> IxSOf target ((':) @Nat n ('[] @Nat)) -> target (TKS2 sh3 x3)
forall (shm :: [Nat]) (shn :: [Nat]) (x :: TK) (target :: Target).
(KnownShS shm, KnownShS shn, KnownSTK x, BaseTensor target) =>
target (TKS2 ((++) @Nat shm shn) x)
-> IxSOf target shm -> target (TKS2 shn x)
!$ (IntOf target
i IntOf target
-> IxS ('[] @Nat) (IntOf target)
-> IxSOf target ((':) @Nat n ('[] @Nat))
forall {sh1 :: [Nat]} {i} (n :: Nat) (sh :: [Nat]).
(KnownNat n, ((':) @Nat n sh :: [Nat]) ~ (sh1 :: [Nat])) =>
i -> IxS sh i -> IxS sh1 i
:.$ IxS ('[] @Nat) (IntOf target)
forall (sh :: [Nat]) i.
((sh :: [Nat]) ~ ('[] @Nat :: [Nat])) =>
IxS sh i
ZIS)))
szipWith30N :: ( KnownShS sh, KnownSTK x, KnownSTK x1, KnownSTK x2, KnownSTK x3
               , BaseTensor target )
            => (target (TKS2 '[] x1) -> target (TKS2 '[] x2)
                -> target (TKS2 '[] x3)
                -> target (TKS2 '[] x))  -- ^ the function to zip with
            -> target (TKS2 sh x1)  -- ^ the first tensor to zip over
            -> target (TKS2 sh x2)  -- ^ the second tensor to zip over
            -> target (TKS2 sh x3)  -- ^ the third tensor to zip over
            -> target (TKS2 sh x)
szipWith30N :: forall (sh :: [Nat]) (x :: TK) (x1 :: TK) (x2 :: TK) (x3 :: TK)
       (target :: Target).
(KnownShS sh, KnownSTK x, KnownSTK x1, KnownSTK x2, KnownSTK x3,
 BaseTensor target) =>
(target (TKS2 ('[] @Nat) x1)
 -> target (TKS2 ('[] @Nat) x2)
 -> target (TKS2 ('[] @Nat) x3)
 -> target (TKS2 ('[] @Nat) x))
-> target (TKS2 sh x1)
-> target (TKS2 sh x2)
-> target (TKS2 sh x3)
-> target (TKS2 sh x)
szipWith30N @sh target (TKS2 ('[] @Nat) x1)
-> target (TKS2 ('[] @Nat) x2)
-> target (TKS2 ('[] @Nat) x3)
-> target (TKS2 ('[] @Nat) x)
f target (TKS2 sh x1)
u target (TKS2 sh x2)
v target (TKS2 sh x3)
w =
  (:~:) @[Nat] (Drop @Nat (Rank @Nat sh) sh) ('[] @Nat)
-> (((Drop @Nat (Rank @Nat sh) sh :: [Nat])
     ~ ('[] @Nat :: [Nat])) =>
    target (TKS2 sh x))
-> target (TKS2 sh x)
forall {k} (a :: k) (b :: k) r.
(:~:) @k a b -> (((a :: k) ~ (b :: k)) => r) -> r
gcastWith ((:~:) @[Nat] (Drop @Nat (Rank @Nat sh) sh) ('[] @Nat)
forall {k} (a :: k) (b :: k). (:~:) @k a b
unsafeCoerceRefl :: Drop (Rank sh) sh :~: '[])
  ((((Drop @Nat (Rank @Nat sh) sh :: [Nat]) ~ ('[] @Nat :: [Nat])) =>
  target (TKS2 sh x))
 -> target (TKS2 sh x))
-> (((Drop @Nat (Rank @Nat sh) sh :: [Nat])
     ~ ('[] @Nat :: [Nat])) =>
    target (TKS2 sh x))
-> target (TKS2 sh x)
forall a b. (a -> b) -> a -> b
$ (:~:) @[Nat] (Take @Nat (Rank @Nat sh) sh) sh
-> (((Take @Nat (Rank @Nat sh) sh :: [Nat]) ~ (sh :: [Nat])) =>
    target (TKS2 sh x))
-> target (TKS2 sh x)
forall {k} (a :: k) (b :: k) r.
(:~:) @k a b -> (((a :: k) ~ (b :: k)) => r) -> r
gcastWith ((:~:) @[Nat] (Take @Nat (Rank @Nat sh) sh) sh
forall {k} (a :: k) (b :: k). (:~:) @k a b
unsafeCoerceRefl :: Take (Rank sh) sh :~: sh)
  ((((Take @Nat (Rank @Nat sh) sh :: [Nat]) ~ (sh :: [Nat])) =>
  target (TKS2 sh x))
 -> target (TKS2 sh x))
-> (((Take @Nat (Rank @Nat sh) sh :: [Nat]) ~ (sh :: [Nat])) =>
    target (TKS2 sh x))
-> target (TKS2 sh x)
forall a b. (a -> b) -> a -> b
$ forall (m :: Nat) (sh :: [Nat]) (x :: TK) (target :: Target).
(KnownShS (Take @Nat m sh), KnownShS sh, KnownSTK x,
 BaseTensor target) =>
(IxSOf target (Take @Nat m sh) -> target (TKS2 (Drop @Nat m sh) x))
-> target (TKS2 sh x)
sbuild @(Rank sh) (\IxSOf target (Take @Nat (Rank @Nat sh) sh)
ix -> target (TKS2 ('[] @Nat) x1)
-> target (TKS2 ('[] @Nat) x2)
-> target (TKS2 ('[] @Nat) x3)
-> target (TKS2 ('[] @Nat) x)
f (target (TKS2 sh x1)
-> IxSOf target sh -> target (TKS2 ('[] @Nat) x1)
forall (sh1 :: [Nat]) (x :: TK) (target :: Target).
(KnownShS sh1, KnownSTK x, BaseTensor target) =>
target (TKS2 sh1 x)
-> IxSOf target sh1 -> target (TKS2 ('[] @Nat) x)
sindex0 target (TKS2 sh x1)
u IxSOf target sh
IxSOf target (Take @Nat (Rank @Nat sh) sh)
ix)
                                (target (TKS2 sh x2)
-> IxSOf target sh -> target (TKS2 ('[] @Nat) x2)
forall (sh1 :: [Nat]) (x :: TK) (target :: Target).
(KnownShS sh1, KnownSTK x, BaseTensor target) =>
target (TKS2 sh1 x)
-> IxSOf target sh1 -> target (TKS2 ('[] @Nat) x)
sindex0 target (TKS2 sh x2)
v IxSOf target sh
IxSOf target (Take @Nat (Rank @Nat sh) sh)
ix)
                                (target (TKS2 sh x3)
-> IxSOf target sh -> target (TKS2 ('[] @Nat) x3)
forall (sh1 :: [Nat]) (x :: TK) (target :: Target).
(KnownShS sh1, KnownSTK x, BaseTensor target) =>
target (TKS2 sh1 x)
-> IxSOf target sh1 -> target (TKS2 ('[] @Nat) x)
sindex0 target (TKS2 sh x3)
w IxSOf target sh
IxSOf target (Take @Nat (Rank @Nat sh) sh)
ix))
szipWith4 :: ( KnownShS (Drop m sh1), KnownShS (Drop m sh2)
             , KnownShS (Drop m sh3), KnownShS (Drop m sh4)
             , KnownShS (Take m sh), KnownShS sh
             , KnownSTK x, KnownSTK x1, KnownSTK x2, KnownSTK x3, KnownSTK x4
             , sh1 ~ Take m sh ++ Drop m sh1
             , sh2 ~ Take m sh ++ Drop m sh2
             , sh3 ~ Take m sh ++ Drop m sh3
             , sh4 ~ Take m sh ++ Drop m sh4, BaseTensor target )
          => (target (TKS2 (Drop m sh1) x1) -> target (TKS2 (Drop m sh2) x2)
              -> target (TKS2 (Drop m sh3) x3) -> target (TKS2 (Drop m sh4) x4)
              -> target (TKS2 (Drop m sh) x))  -- ^ the function to zip with
          -> target (TKS2 sh1 x1)  -- ^ the first tensor to zip over
          -> target (TKS2 sh2 x2)  -- ^ the second tensor to zip over
          -> target (TKS2 sh3 x3)  -- ^ the third tensor to zip over
          -> target (TKS2 sh4 x4)  -- ^ the fourth tensor to zip over
          -> target (TKS2 sh x)
szipWith4 :: forall (m :: Nat) (sh1 :: [Nat]) (sh2 :: [Nat]) (sh3 :: [Nat])
       (sh4 :: [Nat]) (sh :: [Nat]) (x :: TK) (x1 :: TK) (x2 :: TK)
       (x3 :: TK) (x4 :: TK) (target :: Target).
(KnownShS (Drop @Nat m sh1), KnownShS (Drop @Nat m sh2),
 KnownShS (Drop @Nat m sh3), KnownShS (Drop @Nat m sh4),
 KnownShS (Take @Nat m sh), KnownShS sh, KnownSTK x, KnownSTK x1,
 KnownSTK x2, KnownSTK x3, KnownSTK x4,
 (sh1 :: [Nat])
 ~ ((++) @Nat (Take @Nat m sh) (Drop @Nat m sh1) :: [Nat]),
 (sh2 :: [Nat])
 ~ ((++) @Nat (Take @Nat m sh) (Drop @Nat m sh2) :: [Nat]),
 (sh3 :: [Nat])
 ~ ((++) @Nat (Take @Nat m sh) (Drop @Nat m sh3) :: [Nat]),
 (sh4 :: [Nat])
 ~ ((++) @Nat (Take @Nat m sh) (Drop @Nat m sh4) :: [Nat]),
 BaseTensor target) =>
(target (TKS2 (Drop @Nat m sh1) x1)
 -> target (TKS2 (Drop @Nat m sh2) x2)
 -> target (TKS2 (Drop @Nat m sh3) x3)
 -> target (TKS2 (Drop @Nat m sh4) x4)
 -> target (TKS2 (Drop @Nat m sh) x))
-> target (TKS2 sh1 x1)
-> target (TKS2 sh2 x2)
-> target (TKS2 sh3 x3)
-> target (TKS2 sh4 x4)
-> target (TKS2 sh x)
szipWith4 target (TKS2 (Drop @Nat m sh1) x1)
-> target (TKS2 (Drop @Nat m sh2) x2)
-> target (TKS2 (Drop @Nat m sh3) x3)
-> target (TKS2 (Drop @Nat m sh4) x4)
-> target (TKS2 (Drop @Nat m sh) x)
f target (TKS2 sh1 x1)
u target (TKS2 sh2 x2)
v target (TKS2 sh3 x3)
w target (TKS2 sh4 x4)
x =
  (IxSOf target (Take @Nat m sh) -> target (TKS2 (Drop @Nat m sh) x))
-> target (TKS2 sh x)
forall (m :: Nat) (sh :: [Nat]) (x :: TK) (target :: Target).
(KnownShS (Take @Nat m sh), KnownShS sh, KnownSTK x,
 BaseTensor target) =>
(IxSOf target (Take @Nat m sh) -> target (TKS2 (Drop @Nat m sh) x))
-> target (TKS2 sh x)
sbuild (\IxSOf target (Take @Nat m sh)
ix -> target (TKS2 (Drop @Nat m sh1) x1)
-> target (TKS2 (Drop @Nat m sh2) x2)
-> target (TKS2 (Drop @Nat m sh3) x3)
-> target (TKS2 (Drop @Nat m sh4) x4)
-> target (TKS2 (Drop @Nat m sh) x)
f (target (TKS2 sh1 x1)
target (TKS2 ((++) @Nat (Take @Nat m sh) (Drop @Nat m sh1)) x1)
u target (TKS2 ((++) @Nat (Take @Nat m sh) (Drop @Nat m sh1)) x1)
-> IxSOf target (Take @Nat m sh)
-> target (TKS2 (Drop @Nat m sh1) x1)
forall (shm :: [Nat]) (shn :: [Nat]) (x :: TK) (target :: Target).
(KnownShS shm, KnownShS shn, KnownSTK x, BaseTensor target) =>
target (TKS2 ((++) @Nat shm shn) x)
-> IxSOf target shm -> target (TKS2 shn x)
!$ IxSOf target (Take @Nat m sh)
ix) (target (TKS2 sh2 x2)
target (TKS2 ((++) @Nat (Take @Nat m sh) (Drop @Nat m sh2)) x2)
v target (TKS2 ((++) @Nat (Take @Nat m sh) (Drop @Nat m sh2)) x2)
-> IxSOf target (Take @Nat m sh)
-> target (TKS2 (Drop @Nat m sh2) x2)
forall (shm :: [Nat]) (shn :: [Nat]) (x :: TK) (target :: Target).
(KnownShS shm, KnownShS shn, KnownSTK x, BaseTensor target) =>
target (TKS2 ((++) @Nat shm shn) x)
-> IxSOf target shm -> target (TKS2 shn x)
!$ IxSOf target (Take @Nat m sh)
ix) (target (TKS2 sh3 x3)
target (TKS2 ((++) @Nat (Take @Nat m sh) (Drop @Nat m sh3)) x3)
w target (TKS2 ((++) @Nat (Take @Nat m sh) (Drop @Nat m sh3)) x3)
-> IxSOf target (Take @Nat m sh)
-> target (TKS2 (Drop @Nat m sh3) x3)
forall (shm :: [Nat]) (shn :: [Nat]) (x :: TK) (target :: Target).
(KnownShS shm, KnownShS shn, KnownSTK x, BaseTensor target) =>
target (TKS2 ((++) @Nat shm shn) x)
-> IxSOf target shm -> target (TKS2 shn x)
!$ IxSOf target (Take @Nat m sh)
ix) (target (TKS2 sh4 x4)
target (TKS2 ((++) @Nat (Take @Nat m sh) (Drop @Nat m sh4)) x4)
x target (TKS2 ((++) @Nat (Take @Nat m sh) (Drop @Nat m sh4)) x4)
-> IxSOf target (Take @Nat m sh)
-> target (TKS2 (Drop @Nat m sh4) x4)
forall (shm :: [Nat]) (shn :: [Nat]) (x :: TK) (target :: Target).
(KnownShS shm, KnownShS shn, KnownSTK x, BaseTensor target) =>
target (TKS2 ((++) @Nat shm shn) x)
-> IxSOf target shm -> target (TKS2 shn x)
!$ IxSOf target (Take @Nat m sh)
ix))
szipWith41 :: ( KnownNat n
              , KnownShS sh1, KnownShS sh2, KnownShS sh3, KnownShS sh4
              , KnownShS sh
              , KnownSTK x, KnownSTK x1, KnownSTK x2, KnownSTK x3, KnownSTK x4
              , BaseTensor target )
           => (target (TKS2 sh1 x1) -> target (TKS2 sh2 x2)
               -> target (TKS2 sh3 x3) -> target (TKS2 sh4 x4)
               -> target (TKS2 sh x))  -- ^ the function to zip with
           -> target (TKS2 (n ': sh1) x1)  -- ^ the first tensor to zip over
           -> target (TKS2 (n ': sh2) x2)  -- ^ the second tensor to zip over
           -> target (TKS2 (n ': sh3) x3)  -- ^ the third tensor to zip over
           -> target (TKS2 (n ': sh4) x4)  -- ^ the fourth tensor to zip over
           -> target (TKS2 (n ': sh) x)
szipWith41 :: forall (n :: Nat) (sh1 :: [Nat]) (sh2 :: [Nat]) (sh3 :: [Nat])
       (sh4 :: [Nat]) (sh :: [Nat]) (x :: TK) (x1 :: TK) (x2 :: TK)
       (x3 :: TK) (x4 :: TK) (target :: Target).
(KnownNat n, KnownShS sh1, KnownShS sh2, KnownShS sh3,
 KnownShS sh4, KnownShS sh, KnownSTK x, KnownSTK x1, KnownSTK x2,
 KnownSTK x3, KnownSTK x4, BaseTensor target) =>
(target (TKS2 sh1 x1)
 -> target (TKS2 sh2 x2)
 -> target (TKS2 sh3 x3)
 -> target (TKS2 sh4 x4)
 -> target (TKS2 sh x))
-> target (TKS2 ((':) @Nat n sh1) x1)
-> target (TKS2 ((':) @Nat n sh2) x2)
-> target (TKS2 ((':) @Nat n sh3) x3)
-> target (TKS2 ((':) @Nat n sh4) x4)
-> target (TKS2 ((':) @Nat n sh) x)
szipWith41 target (TKS2 sh1 x1)
-> target (TKS2 sh2 x2)
-> target (TKS2 sh3 x3)
-> target (TKS2 sh4 x4)
-> target (TKS2 sh x)
f target (TKS2 ((':) @Nat n sh1) x1)
u target (TKS2 ((':) @Nat n sh2) x2)
v target (TKS2 ((':) @Nat n sh3) x3)
w target (TKS2 ((':) @Nat n sh4) x4)
x = (IntOf target -> target (TKS2 sh x))
-> target (TKS2 ((':) @Nat n sh) x)
forall (k :: Nat) (sh :: [Nat]) (x :: TK) (target :: Target).
(KnownNat k, KnownShS sh, KnownSTK x, BaseTensor target) =>
(IntOf target -> target (TKS2 sh x))
-> target (TKS2 ((':) @Nat k sh) x)
sbuild1 (\IntOf target
i -> target (TKS2 sh1 x1)
-> target (TKS2 sh2 x2)
-> target (TKS2 sh3 x3)
-> target (TKS2 sh4 x4)
-> target (TKS2 sh x)
f (target (TKS2 ((':) @Nat n sh1) x1)
target (TKS2 ((++) @Nat ((':) @Nat n ('[] @Nat)) sh1) x1)
u target (TKS2 ((++) @Nat ((':) @Nat n ('[] @Nat)) sh1) x1)
-> IxSOf target ((':) @Nat n ('[] @Nat)) -> target (TKS2 sh1 x1)
forall (shm :: [Nat]) (shn :: [Nat]) (x :: TK) (target :: Target).
(KnownShS shm, KnownShS shn, KnownSTK x, BaseTensor target) =>
target (TKS2 ((++) @Nat shm shn) x)
-> IxSOf target shm -> target (TKS2 shn x)
!$ (IntOf target
i IntOf target
-> IxS ('[] @Nat) (IntOf target)
-> IxSOf target ((':) @Nat n ('[] @Nat))
forall {sh1 :: [Nat]} {i} (n :: Nat) (sh :: [Nat]).
(KnownNat n, ((':) @Nat n sh :: [Nat]) ~ (sh1 :: [Nat])) =>
i -> IxS sh i -> IxS sh1 i
:.$ IxS ('[] @Nat) (IntOf target)
forall (sh :: [Nat]) i.
((sh :: [Nat]) ~ ('[] @Nat :: [Nat])) =>
IxS sh i
ZIS))
                                        (target (TKS2 ((':) @Nat n sh2) x2)
target (TKS2 ((++) @Nat ((':) @Nat n ('[] @Nat)) sh2) x2)
v target (TKS2 ((++) @Nat ((':) @Nat n ('[] @Nat)) sh2) x2)
-> IxSOf target ((':) @Nat n ('[] @Nat)) -> target (TKS2 sh2 x2)
forall (shm :: [Nat]) (shn :: [Nat]) (x :: TK) (target :: Target).
(KnownShS shm, KnownShS shn, KnownSTK x, BaseTensor target) =>
target (TKS2 ((++) @Nat shm shn) x)
-> IxSOf target shm -> target (TKS2 shn x)
!$ (IntOf target
i IntOf target
-> IxS ('[] @Nat) (IntOf target)
-> IxSOf target ((':) @Nat n ('[] @Nat))
forall {sh1 :: [Nat]} {i} (n :: Nat) (sh :: [Nat]).
(KnownNat n, ((':) @Nat n sh :: [Nat]) ~ (sh1 :: [Nat])) =>
i -> IxS sh i -> IxS sh1 i
:.$ IxS ('[] @Nat) (IntOf target)
forall (sh :: [Nat]) i.
((sh :: [Nat]) ~ ('[] @Nat :: [Nat])) =>
IxS sh i
ZIS))
                                        (target (TKS2 ((':) @Nat n sh3) x3)
target (TKS2 ((++) @Nat ((':) @Nat n ('[] @Nat)) sh3) x3)
w target (TKS2 ((++) @Nat ((':) @Nat n ('[] @Nat)) sh3) x3)
-> IxSOf target ((':) @Nat n ('[] @Nat)) -> target (TKS2 sh3 x3)
forall (shm :: [Nat]) (shn :: [Nat]) (x :: TK) (target :: Target).
(KnownShS shm, KnownShS shn, KnownSTK x, BaseTensor target) =>
target (TKS2 ((++) @Nat shm shn) x)
-> IxSOf target shm -> target (TKS2 shn x)
!$ (IntOf target
i IntOf target
-> IxS ('[] @Nat) (IntOf target)
-> IxSOf target ((':) @Nat n ('[] @Nat))
forall {sh1 :: [Nat]} {i} (n :: Nat) (sh :: [Nat]).
(KnownNat n, ((':) @Nat n sh :: [Nat]) ~ (sh1 :: [Nat])) =>
i -> IxS sh i -> IxS sh1 i
:.$ IxS ('[] @Nat) (IntOf target)
forall (sh :: [Nat]) i.
((sh :: [Nat]) ~ ('[] @Nat :: [Nat])) =>
IxS sh i
ZIS))
                                        (target (TKS2 ((':) @Nat n sh4) x4)
target (TKS2 ((++) @Nat ((':) @Nat n ('[] @Nat)) sh4) x4)
x target (TKS2 ((++) @Nat ((':) @Nat n ('[] @Nat)) sh4) x4)
-> IxSOf target ((':) @Nat n ('[] @Nat)) -> target (TKS2 sh4 x4)
forall (shm :: [Nat]) (shn :: [Nat]) (x :: TK) (target :: Target).
(KnownShS shm, KnownShS shn, KnownSTK x, BaseTensor target) =>
target (TKS2 ((++) @Nat shm shn) x)
-> IxSOf target shm -> target (TKS2 shn x)
!$ (IntOf target
i IntOf target
-> IxS ('[] @Nat) (IntOf target)
-> IxSOf target ((':) @Nat n ('[] @Nat))
forall {sh1 :: [Nat]} {i} (n :: Nat) (sh :: [Nat]).
(KnownNat n, ((':) @Nat n sh :: [Nat]) ~ (sh1 :: [Nat])) =>
i -> IxS sh i -> IxS sh1 i
:.$ IxS ('[] @Nat) (IntOf target)
forall (sh :: [Nat]) i.
((sh :: [Nat]) ~ ('[] @Nat :: [Nat])) =>
IxS sh i
ZIS)))
szipWith40N :: ( KnownShS sh, KnownSTK x
               , KnownSTK x1, KnownSTK x2, KnownSTK x3, KnownSTK x4
               , BaseTensor target )
            => (target (TKS2 '[] x1) -> target (TKS2 '[] x2)
                -> target (TKS2 '[] x3) -> target (TKS2 '[] x4)
                -> target (TKS2 '[] x))  -- ^ the function to zip with
            -> target (TKS2 sh x1)  -- ^ the first tensor to zip over
            -> target (TKS2 sh x2)  -- ^ the second tensor to zip over
            -> target (TKS2 sh x3)  -- ^ the third tensor to zip over
            -> target (TKS2 sh x4)  -- ^ the fourth tensor to zip over
            -> target (TKS2 sh x)
szipWith40N :: forall (sh :: [Nat]) (x :: TK) (x1 :: TK) (x2 :: TK) (x3 :: TK)
       (x4 :: TK) (target :: Target).
(KnownShS sh, KnownSTK x, KnownSTK x1, KnownSTK x2, KnownSTK x3,
 KnownSTK x4, BaseTensor target) =>
(target (TKS2 ('[] @Nat) x1)
 -> target (TKS2 ('[] @Nat) x2)
 -> target (TKS2 ('[] @Nat) x3)
 -> target (TKS2 ('[] @Nat) x4)
 -> target (TKS2 ('[] @Nat) x))
-> target (TKS2 sh x1)
-> target (TKS2 sh x2)
-> target (TKS2 sh x3)
-> target (TKS2 sh x4)
-> target (TKS2 sh x)
szipWith40N @sh target (TKS2 ('[] @Nat) x1)
-> target (TKS2 ('[] @Nat) x2)
-> target (TKS2 ('[] @Nat) x3)
-> target (TKS2 ('[] @Nat) x4)
-> target (TKS2 ('[] @Nat) x)
f target (TKS2 sh x1)
u target (TKS2 sh x2)
v target (TKS2 sh x3)
w target (TKS2 sh x4)
x =
  (:~:) @[Nat] (Drop @Nat (Rank @Nat sh) sh) ('[] @Nat)
-> (((Drop @Nat (Rank @Nat sh) sh :: [Nat])
     ~ ('[] @Nat :: [Nat])) =>
    target (TKS2 sh x))
-> target (TKS2 sh x)
forall {k} (a :: k) (b :: k) r.
(:~:) @k a b -> (((a :: k) ~ (b :: k)) => r) -> r
gcastWith ((:~:) @[Nat] (Drop @Nat (Rank @Nat sh) sh) ('[] @Nat)
forall {k} (a :: k) (b :: k). (:~:) @k a b
unsafeCoerceRefl :: Drop (Rank sh) sh :~: '[])
  ((((Drop @Nat (Rank @Nat sh) sh :: [Nat]) ~ ('[] @Nat :: [Nat])) =>
  target (TKS2 sh x))
 -> target (TKS2 sh x))
-> (((Drop @Nat (Rank @Nat sh) sh :: [Nat])
     ~ ('[] @Nat :: [Nat])) =>
    target (TKS2 sh x))
-> target (TKS2 sh x)
forall a b. (a -> b) -> a -> b
$ (:~:) @[Nat] (Take @Nat (Rank @Nat sh) sh) sh
-> (((Take @Nat (Rank @Nat sh) sh :: [Nat]) ~ (sh :: [Nat])) =>
    target (TKS2 sh x))
-> target (TKS2 sh x)
forall {k} (a :: k) (b :: k) r.
(:~:) @k a b -> (((a :: k) ~ (b :: k)) => r) -> r
gcastWith ((:~:) @[Nat] (Take @Nat (Rank @Nat sh) sh) sh
forall {k} (a :: k) (b :: k). (:~:) @k a b
unsafeCoerceRefl :: Take (Rank sh) sh :~: sh)
  ((((Take @Nat (Rank @Nat sh) sh :: [Nat]) ~ (sh :: [Nat])) =>
  target (TKS2 sh x))
 -> target (TKS2 sh x))
-> (((Take @Nat (Rank @Nat sh) sh :: [Nat]) ~ (sh :: [Nat])) =>
    target (TKS2 sh x))
-> target (TKS2 sh x)
forall a b. (a -> b) -> a -> b
$ forall (m :: Nat) (sh :: [Nat]) (x :: TK) (target :: Target).
(KnownShS (Take @Nat m sh), KnownShS sh, KnownSTK x,
 BaseTensor target) =>
(IxSOf target (Take @Nat m sh) -> target (TKS2 (Drop @Nat m sh) x))
-> target (TKS2 sh x)
sbuild @(Rank sh) (\IxSOf target (Take @Nat (Rank @Nat sh) sh)
ix -> target (TKS2 ('[] @Nat) x1)
-> target (TKS2 ('[] @Nat) x2)
-> target (TKS2 ('[] @Nat) x3)
-> target (TKS2 ('[] @Nat) x4)
-> target (TKS2 ('[] @Nat) x)
f (target (TKS2 sh x1)
-> IxSOf target sh -> target (TKS2 ('[] @Nat) x1)
forall (sh1 :: [Nat]) (x :: TK) (target :: Target).
(KnownShS sh1, KnownSTK x, BaseTensor target) =>
target (TKS2 sh1 x)
-> IxSOf target sh1 -> target (TKS2 ('[] @Nat) x)
sindex0 target (TKS2 sh x1)
u IxSOf target sh
IxSOf target (Take @Nat (Rank @Nat sh) sh)
ix)
                                (target (TKS2 sh x2)
-> IxSOf target sh -> target (TKS2 ('[] @Nat) x2)
forall (sh1 :: [Nat]) (x :: TK) (target :: Target).
(KnownShS sh1, KnownSTK x, BaseTensor target) =>
target (TKS2 sh1 x)
-> IxSOf target sh1 -> target (TKS2 ('[] @Nat) x)
sindex0 target (TKS2 sh x2)
v IxSOf target sh
IxSOf target (Take @Nat (Rank @Nat sh) sh)
ix)
                                (target (TKS2 sh x3)
-> IxSOf target sh -> target (TKS2 ('[] @Nat) x3)
forall (sh1 :: [Nat]) (x :: TK) (target :: Target).
(KnownShS sh1, KnownSTK x, BaseTensor target) =>
target (TKS2 sh1 x)
-> IxSOf target sh1 -> target (TKS2 ('[] @Nat) x)
sindex0 target (TKS2 sh x3)
w IxSOf target sh
IxSOf target (Take @Nat (Rank @Nat sh) sh)
ix)
                                (target (TKS2 sh x4)
-> IxSOf target sh -> target (TKS2 ('[] @Nat) x4)
forall (sh1 :: [Nat]) (x :: TK) (target :: Target).
(KnownShS sh1, KnownSTK x, BaseTensor target) =>
target (TKS2 sh1 x)
-> IxSOf target sh1 -> target (TKS2 ('[] @Nat) x)
sindex0 target (TKS2 sh x4)
x IxSOf target sh
IxSOf target (Take @Nat (Rank @Nat sh) sh)
ix))

xbuild1 :: (KnownNat k, KnownShX sh, KnownSTK x, BaseTensor target)
        => (IntOf target -> target (TKX2 sh x))  -- ^ the function to build with
        -> target (TKX2 (Just k ': sh) x)
xbuild1 :: forall (k :: Nat) (sh :: [Maybe Nat]) (x :: TK) (target :: Target).
(KnownNat k, KnownShX sh, KnownSTK x, BaseTensor target) =>
(IntOf target -> target (TKX2 sh x))
-> target (TKX2 ((':) @(Maybe Nat) ('Just @Nat k) sh) x)
xbuild1 = (IntOf target -> target (TKX2 sh x))
-> target (TKX2 ((':) @(Maybe Nat) ('Just @Nat k) sh) x)
forall (k :: Nat) (sh :: [Maybe Nat]) (x :: TK).
(KnownNat k, KnownShX sh, KnownSTK x) =>
(IntOf target -> target (TKX2 sh x))
-> target (TKX2 ((':) @(Maybe Nat) ('Just @Nat k) sh) x)
forall (target :: Target) (k :: Nat) (sh :: [Maybe Nat]) (x :: TK).
(BaseTensor target, KnownNat k, KnownShX sh, KnownSTK x) =>
(IntOf target -> target (TKX2 sh x))
-> target (TKX2 ((':) @(Maybe Nat) ('Just @Nat k) sh) x)
txbuild1
-- xmap and other special cases of build can be defined by the user.

rfold
  :: ( KnownNat n, KnownNat m, KnownSTK xn, KnownSTK xm
     , BaseTensor target, LetTensor target )
  => (forall f. ADReady f => f (TKR2 n xn) -> f (TKR2 m xm) -> f (TKR2 n xn))
       -- ^ the function to fold with
  -> target (TKR2 n xn)  -- ^ the initial accumulator
  -> target (TKR2 (1 + m) xm)  -- ^ the inputs
  -> target (TKR2 n xn)
{-# INLINE rfold #-}
rfold :: forall (n :: Nat) (m :: Nat) (xn :: TK) (xm :: TK)
       (target :: Target).
(KnownNat n, KnownNat m, KnownSTK xn, KnownSTK xm,
 BaseTensor target, LetTensor target) =>
(forall (f :: Target).
 ADReady f =>
 f (TKR2 n xn) -> f (TKR2 m xm) -> f (TKR2 n xn))
-> target (TKR2 n xn)
-> target (TKR2 (1 + m) xm)
-> target (TKR2 n xn)
rfold forall (f :: Target).
ADReady f =>
f (TKR2 n xn) -> f (TKR2 m xm) -> f (TKR2 n xn)
f target (TKR2 n xn)
acc0 target (TKR2 (1 + m) xm)
es =
  Int
-> (forall (n :: Nat). KnownNat n => SNat n -> target (TKR2 n xn))
-> target (TKR2 n xn)
forall r.
Int -> (forall (n :: Nat). KnownNat n => SNat n -> r) -> r
withSNat (target (TKR2 (1 + m) xm) -> Int
forall (n :: Nat) (x :: TK).
KnownSTK x =>
target (TKR2 (1 + n) x) -> Int
forall (target :: Target) (n :: Nat) (x :: TK).
(BaseTensor target, KnownSTK x) =>
target (TKR2 (1 + n) x) -> Int
rwidth target (TKR2 (1 + m) xm)
es) ((forall (n :: Nat). KnownNat n => SNat n -> target (TKR2 n xn))
 -> target (TKR2 n xn))
-> (forall (n :: Nat). KnownNat n => SNat n -> target (TKR2 n xn))
-> target (TKR2 n xn)
forall a b. (a -> b) -> a -> b
$ \SNat n
k -> SNat n
-> SingletonTK (TKR2 n xn)
-> SingletonTK (TKR2 m xm)
-> (forall (f :: Target).
    ADReady f =>
    f (TKR2 n xn) -> f (TKR2 m xm) -> f (TKR2 n xn))
-> target (TKR2 n xn)
-> target (BuildTensorKind n (TKR2 m xm))
-> target (TKR2 n xn)
forall (yn :: TK) (ym :: TK) (k :: Nat).
BaseTensor target =>
SNat k
-> SingletonTK yn
-> SingletonTK ym
-> (forall (f :: Target). ADReady f => f yn -> f ym -> f yn)
-> target yn
-> target (BuildTensorKind k ym)
-> target yn
forall (target :: Target) (yn :: TK) (ym :: TK) (k :: Nat).
(LetTensor target, BaseTensor target) =>
SNat k
-> SingletonTK yn
-> SingletonTK ym
-> (forall (f :: Target). ADReady f => f yn -> f ym -> f yn)
-> target yn
-> target (BuildTensorKind k ym)
-> target yn
tfold SNat n
k SingletonTK (TKR2 n xn)
forall (y :: TK). KnownSTK y => SingletonTK y
knownSTK SingletonTK (TKR2 m xm)
forall (y :: TK). KnownSTK y => SingletonTK y
knownSTK f (TKR2 n xn) -> f (TKR2 m xm) -> f (TKR2 n xn)
forall (f :: Target).
ADReady f =>
f (TKR2 n xn) -> f (TKR2 m xm) -> f (TKR2 n xn)
f target (TKR2 n xn)
acc0 target (BuildTensorKind n (TKR2 m xm))
target (TKR2 (1 + m) xm)
es
rscan
  :: ( KnownNat n, KnownNat m, KnownSTK xn, KnownSTK xm
     , BaseTensor target, LetTensor target )
  => (forall f. ADReady f => f (TKR2 n xn) -> f (TKR2 m xm) -> f (TKR2 n xn))
       -- ^ the function to fold with
  -> target (TKR2 n xn)  -- ^ the initial accumulator
  -> target (TKR2 (1 + m) xm)  -- ^ the inputs
  -> target (TKR2 (1 + n) xn)
{-# INLINE rscan #-}
rscan :: forall (n :: Nat) (m :: Nat) (xn :: TK) (xm :: TK)
       (target :: Target).
(KnownNat n, KnownNat m, KnownSTK xn, KnownSTK xm,
 BaseTensor target, LetTensor target) =>
(forall (f :: Target).
 ADReady f =>
 f (TKR2 n xn) -> f (TKR2 m xm) -> f (TKR2 n xn))
-> target (TKR2 n xn)
-> target (TKR2 (1 + m) xm)
-> target (TKR2 (1 + n) xn)
rscan forall (f :: Target).
ADReady f =>
f (TKR2 n xn) -> f (TKR2 m xm) -> f (TKR2 n xn)
f target (TKR2 n xn)
acc0 target (TKR2 (1 + m) xm)
es =
  Int
-> (forall (n :: Nat).
    KnownNat n =>
    SNat n -> target (TKR2 (1 + n) xn))
-> target (TKR2 (1 + n) xn)
forall r.
Int -> (forall (n :: Nat). KnownNat n => SNat n -> r) -> r
withSNat (target (TKR2 (1 + m) xm) -> Int
forall (n :: Nat) (x :: TK).
KnownSTK x =>
target (TKR2 (1 + n) x) -> Int
forall (target :: Target) (n :: Nat) (x :: TK).
(BaseTensor target, KnownSTK x) =>
target (TKR2 (1 + n) x) -> Int
rwidth target (TKR2 (1 + m) xm)
es) ((forall (n :: Nat).
  KnownNat n =>
  SNat n -> target (TKR2 (1 + n) xn))
 -> target (TKR2 (1 + n) xn))
-> (forall (n :: Nat).
    KnownNat n =>
    SNat n -> target (TKR2 (1 + n) xn))
-> target (TKR2 (1 + n) xn)
forall a b. (a -> b) -> a -> b
$ \SNat n
k -> SNat n
-> SingletonTK (TKR2 n xn)
-> SingletonTK (TKR2 m xm)
-> (forall (f :: Target).
    ADReady f =>
    f (TKR2 n xn) -> f (TKR2 m xm) -> f (TKR2 n xn))
-> target (TKR2 n xn)
-> target (BuildTensorKind n (TKR2 m xm))
-> target (BuildTensorKind (1 + n) (TKR2 n xn))
forall (yn :: TK) (ym :: TK) (k :: Nat).
BaseTensor target =>
SNat k
-> SingletonTK yn
-> SingletonTK ym
-> (forall (f :: Target). ADReady f => f yn -> f ym -> f yn)
-> target yn
-> target (BuildTensorKind k ym)
-> target (BuildTensorKind (1 + k) yn)
forall (target :: Target) (yn :: TK) (ym :: TK) (k :: Nat).
(LetTensor target, BaseTensor target) =>
SNat k
-> SingletonTK yn
-> SingletonTK ym
-> (forall (f :: Target). ADReady f => f yn -> f ym -> f yn)
-> target yn
-> target (BuildTensorKind k ym)
-> target (BuildTensorKind (1 + k) yn)
tscan SNat n
k SingletonTK (TKR2 n xn)
forall (y :: TK). KnownSTK y => SingletonTK y
knownSTK SingletonTK (TKR2 m xm)
forall (y :: TK). KnownSTK y => SingletonTK y
knownSTK f (TKR2 n xn) -> f (TKR2 m xm) -> f (TKR2 n xn)
forall (f :: Target).
ADReady f =>
f (TKR2 n xn) -> f (TKR2 m xm) -> f (TKR2 n xn)
f target (TKR2 n xn)
acc0 target (BuildTensorKind n (TKR2 m xm))
target (TKR2 (1 + m) xm)
es
sfold
  :: ( KnownNat k, KnownShS sh, KnownShS shm, KnownSTK xn, KnownSTK xm
     , BaseTensor target, LetTensor target )
  => (forall f. ADReady f
      => f (TKS2 sh xn) -> f (TKS2 shm xm) -> f (TKS2 sh xn))
       -- ^ the function to fold with
  -> target (TKS2 sh xn)  -- ^ the initial accumulator
  -> target (TKS2 (k ': shm) xm)  -- ^ the inputs
  -> target (TKS2 sh xn)
{-# INLINE sfold #-}
sfold :: forall (k :: Nat) (sh :: [Nat]) (shm :: [Nat]) (xn :: TK)
       (xm :: TK) (target :: Target).
(KnownNat k, KnownShS sh, KnownShS shm, KnownSTK xn, KnownSTK xm,
 BaseTensor target, LetTensor target) =>
(forall (f :: Target).
 ADReady f =>
 f (TKS2 sh xn) -> f (TKS2 shm xm) -> f (TKS2 sh xn))
-> target (TKS2 sh xn)
-> target (TKS2 ((':) @Nat k shm) xm)
-> target (TKS2 sh xn)
sfold @k = SNat k
-> SingletonTK (TKS2 sh xn)
-> SingletonTK (TKS2 shm xm)
-> (forall (f :: Target).
    ((((BoolOf (PrimalOf f) :: Type) ~ (BoolOf f :: Type),
       (BaseTensor f, ConvertTensor f, Boolean (BoolOf f),
        AllTargetShow f, CommonTargetEqOrd f),
       (BaseTensor (PrimalOf f), ConvertTensor (PrimalOf f),
        Boolean (BoolOf (PrimalOf f)), AllTargetShow (PrimalOf f),
        CommonTargetEqOrd (PrimalOf f))),
      ((BoolOf (PrimalOf (ShareOf f)) :: Type)
       ~ (BoolOf (ShareOf f) :: Type),
       (BaseTensor (ShareOf f), ConvertTensor (ShareOf f),
        Boolean (BoolOf (ShareOf f)), AllTargetShow (ShareOf f),
        CommonTargetEqOrd (ShareOf f)),
       (BaseTensor (PrimalOf (ShareOf f)),
        ConvertTensor (PrimalOf (ShareOf f)),
        Boolean (BoolOf (PrimalOf (ShareOf f))),
        AllTargetShow (PrimalOf (ShareOf f)),
        CommonTargetEqOrd (PrimalOf (ShareOf f)))),
      ShareTensor (ShareOf f), ShareTensor (PrimalOf (ShareOf f)),
      (ShareOf (ShareOf f) :: Target) ~ (ShareOf f :: Target)),
     LetTensor f) =>
    f (TKS2 sh xn) -> f (TKS2 shm xm) -> f (TKS2 sh xn))
-> target (TKS2 sh xn)
-> target (BuildTensorKind k (TKS2 shm xm))
-> target (TKS2 sh xn)
forall (yn :: TK) (ym :: TK) (k :: Nat).
BaseTensor target =>
SNat k
-> SingletonTK yn
-> SingletonTK ym
-> (forall (f :: Target). ADReady f => f yn -> f ym -> f yn)
-> target yn
-> target (BuildTensorKind k ym)
-> target yn
forall (target :: Target) (yn :: TK) (ym :: TK) (k :: Nat).
(LetTensor target, BaseTensor target) =>
SNat k
-> SingletonTK yn
-> SingletonTK ym
-> (forall (f :: Target). ADReady f => f yn -> f ym -> f yn)
-> target yn
-> target (BuildTensorKind k ym)
-> target yn
tfold (forall (n :: Nat). KnownNat n => SNat n
SNat @k) SingletonTK (TKS2 sh xn)
forall (y :: TK). KnownSTK y => SingletonTK y
knownSTK SingletonTK (TKS2 shm xm)
forall (y :: TK). KnownSTK y => SingletonTK y
knownSTK
sscan
  :: ( KnownNat k, KnownShS sh, KnownShS shm, KnownSTK xn, KnownSTK xm
     , BaseTensor target, LetTensor target )
  => (forall f. ADReady f
      => f (TKS2 sh xn) -> f (TKS2 shm xm) -> f (TKS2 sh xn))
       -- ^ the function to scan with
  -> target (TKS2 sh xn)  -- ^ the initial accumulator
  -> target (TKS2 (k ': shm) xm)  -- ^ the inputs
  -> target (TKS2 (1 + k ': sh) xn)
{-# INLINE sscan #-}
sscan :: forall (k :: Nat) (sh :: [Nat]) (shm :: [Nat]) (xn :: TK)
       (xm :: TK) (target :: Target).
(KnownNat k, KnownShS sh, KnownShS shm, KnownSTK xn, KnownSTK xm,
 BaseTensor target, LetTensor target) =>
(forall (f :: Target).
 ADReady f =>
 f (TKS2 sh xn) -> f (TKS2 shm xm) -> f (TKS2 sh xn))
-> target (TKS2 sh xn)
-> target (TKS2 ((':) @Nat k shm) xm)
-> target (TKS2 ((':) @Nat (1 + k) sh) xn)
sscan @k = SNat k
-> SingletonTK (TKS2 sh xn)
-> SingletonTK (TKS2 shm xm)
-> (forall (f :: Target).
    ((((BoolOf (PrimalOf f) :: Type) ~ (BoolOf f :: Type),
       (BaseTensor f, ConvertTensor f, Boolean (BoolOf f),
        AllTargetShow f, CommonTargetEqOrd f),
       (BaseTensor (PrimalOf f), ConvertTensor (PrimalOf f),
        Boolean (BoolOf (PrimalOf f)), AllTargetShow (PrimalOf f),
        CommonTargetEqOrd (PrimalOf f))),
      ((BoolOf (PrimalOf (ShareOf f)) :: Type)
       ~ (BoolOf (ShareOf f) :: Type),
       (BaseTensor (ShareOf f), ConvertTensor (ShareOf f),
        Boolean (BoolOf (ShareOf f)), AllTargetShow (ShareOf f),
        CommonTargetEqOrd (ShareOf f)),
       (BaseTensor (PrimalOf (ShareOf f)),
        ConvertTensor (PrimalOf (ShareOf f)),
        Boolean (BoolOf (PrimalOf (ShareOf f))),
        AllTargetShow (PrimalOf (ShareOf f)),
        CommonTargetEqOrd (PrimalOf (ShareOf f)))),
      ShareTensor (ShareOf f), ShareTensor (PrimalOf (ShareOf f)),
      (ShareOf (ShareOf f) :: Target) ~ (ShareOf f :: Target)),
     LetTensor f) =>
    f (TKS2 sh xn) -> f (TKS2 shm xm) -> f (TKS2 sh xn))
-> target (TKS2 sh xn)
-> target (BuildTensorKind k (TKS2 shm xm))
-> target (BuildTensorKind (1 + k) (TKS2 sh xn))
forall (yn :: TK) (ym :: TK) (k :: Nat).
BaseTensor target =>
SNat k
-> SingletonTK yn
-> SingletonTK ym
-> (forall (f :: Target). ADReady f => f yn -> f ym -> f yn)
-> target yn
-> target (BuildTensorKind k ym)
-> target (BuildTensorKind (1 + k) yn)
forall (target :: Target) (yn :: TK) (ym :: TK) (k :: Nat).
(LetTensor target, BaseTensor target) =>
SNat k
-> SingletonTK yn
-> SingletonTK ym
-> (forall (f :: Target). ADReady f => f yn -> f ym -> f yn)
-> target yn
-> target (BuildTensorKind k ym)
-> target (BuildTensorKind (1 + k) yn)
tscan (forall (n :: Nat). KnownNat n => SNat n
SNat @k) SingletonTK (TKS2 sh xn)
forall (y :: TK). KnownSTK y => SingletonTK y
knownSTK SingletonTK (TKS2 shm xm)
forall (y :: TK). KnownSTK y => SingletonTK y
knownSTK
xfold
  :: ( KnownNat k, KnownShX sh, KnownShX shm, KnownSTK xn, KnownSTK xm
     , BaseTensor target, LetTensor target )
  => (forall f. ADReady f
      => f (TKX2 sh xn) -> f (TKX2 shm xm) -> f (TKX2 sh xn))
       -- ^ the function to scan with
  -> target (TKX2 sh xn)  -- ^ the initial accumulator
  -> target (BuildTensorKind k (TKX2 shm xm))  -- ^ the inputs
  -> target (TKX2 sh xn)
{-# INLINE xfold #-}
xfold :: forall (k :: Nat) (sh :: [Maybe Nat]) (shm :: [Maybe Nat])
       (xn :: TK) (xm :: TK) (target :: Target).
(KnownNat k, KnownShX sh, KnownShX shm, KnownSTK xn, KnownSTK xm,
 BaseTensor target, LetTensor target) =>
(forall (f :: Target).
 ADReady f =>
 f (TKX2 sh xn) -> f (TKX2 shm xm) -> f (TKX2 sh xn))
-> target (TKX2 sh xn)
-> target (BuildTensorKind k (TKX2 shm xm))
-> target (TKX2 sh xn)
xfold @k = SNat k
-> SingletonTK (TKX2 sh xn)
-> SingletonTK (TKX2 shm xm)
-> (forall (f :: Target).
    ((((BoolOf (PrimalOf f) :: Type) ~ (BoolOf f :: Type),
       (BaseTensor f, ConvertTensor f, Boolean (BoolOf f),
        AllTargetShow f, CommonTargetEqOrd f),
       (BaseTensor (PrimalOf f), ConvertTensor (PrimalOf f),
        Boolean (BoolOf (PrimalOf f)), AllTargetShow (PrimalOf f),
        CommonTargetEqOrd (PrimalOf f))),
      ((BoolOf (PrimalOf (ShareOf f)) :: Type)
       ~ (BoolOf (ShareOf f) :: Type),
       (BaseTensor (ShareOf f), ConvertTensor (ShareOf f),
        Boolean (BoolOf (ShareOf f)), AllTargetShow (ShareOf f),
        CommonTargetEqOrd (ShareOf f)),
       (BaseTensor (PrimalOf (ShareOf f)),
        ConvertTensor (PrimalOf (ShareOf f)),
        Boolean (BoolOf (PrimalOf (ShareOf f))),
        AllTargetShow (PrimalOf (ShareOf f)),
        CommonTargetEqOrd (PrimalOf (ShareOf f)))),
      ShareTensor (ShareOf f), ShareTensor (PrimalOf (ShareOf f)),
      (ShareOf (ShareOf f) :: Target) ~ (ShareOf f :: Target)),
     LetTensor f) =>
    f (TKX2 sh xn) -> f (TKX2 shm xm) -> f (TKX2 sh xn))
-> target (TKX2 sh xn)
-> target (BuildTensorKind k (TKX2 shm xm))
-> target (TKX2 sh xn)
forall (yn :: TK) (ym :: TK) (k :: Nat).
BaseTensor target =>
SNat k
-> SingletonTK yn
-> SingletonTK ym
-> (forall (f :: Target). ADReady f => f yn -> f ym -> f yn)
-> target yn
-> target (BuildTensorKind k ym)
-> target yn
forall (target :: Target) (yn :: TK) (ym :: TK) (k :: Nat).
(LetTensor target, BaseTensor target) =>
SNat k
-> SingletonTK yn
-> SingletonTK ym
-> (forall (f :: Target). ADReady f => f yn -> f ym -> f yn)
-> target yn
-> target (BuildTensorKind k ym)
-> target yn
tfold (forall (n :: Nat). KnownNat n => SNat n
SNat @k) SingletonTK (TKX2 sh xn)
forall (y :: TK). KnownSTK y => SingletonTK y
knownSTK SingletonTK (TKX2 shm xm)
forall (y :: TK). KnownSTK y => SingletonTK y
knownSTK
xscan
  :: ( KnownNat k, KnownShX sh, KnownShX shm, KnownSTK xn, KnownSTK xm
     , BaseTensor target, LetTensor target )
  => (forall f. ADReady f
      => f (TKX2 sh xn) -> f (TKX2 shm xm) -> f (TKX2 sh xn))
       -- ^ the function to scan with
  -> target (TKX2 sh xn)  -- ^ the initial accumulator
  -> target (BuildTensorKind k (TKX2 shm xm))  -- ^ the inputs
  -> target (BuildTensorKind (1 + k) (TKX2 sh xn))
{-# INLINE xscan #-}
xscan :: forall (k :: Nat) (sh :: [Maybe Nat]) (shm :: [Maybe Nat])
       (xn :: TK) (xm :: TK) (target :: Target).
(KnownNat k, KnownShX sh, KnownShX shm, KnownSTK xn, KnownSTK xm,
 BaseTensor target, LetTensor target) =>
(forall (f :: Target).
 ADReady f =>
 f (TKX2 sh xn) -> f (TKX2 shm xm) -> f (TKX2 sh xn))
-> target (TKX2 sh xn)
-> target (BuildTensorKind k (TKX2 shm xm))
-> target (BuildTensorKind (1 + k) (TKX2 sh xn))
xscan @k = SNat k
-> SingletonTK (TKX2 sh xn)
-> SingletonTK (TKX2 shm xm)
-> (forall (f :: Target).
    ((((BoolOf (PrimalOf f) :: Type) ~ (BoolOf f :: Type),
       (BaseTensor f, ConvertTensor f, Boolean (BoolOf f),
        AllTargetShow f, CommonTargetEqOrd f),
       (BaseTensor (PrimalOf f), ConvertTensor (PrimalOf f),
        Boolean (BoolOf (PrimalOf f)), AllTargetShow (PrimalOf f),
        CommonTargetEqOrd (PrimalOf f))),
      ((BoolOf (PrimalOf (ShareOf f)) :: Type)
       ~ (BoolOf (ShareOf f) :: Type),
       (BaseTensor (ShareOf f), ConvertTensor (ShareOf f),
        Boolean (BoolOf (ShareOf f)), AllTargetShow (ShareOf f),
        CommonTargetEqOrd (ShareOf f)),
       (BaseTensor (PrimalOf (ShareOf f)),
        ConvertTensor (PrimalOf (ShareOf f)),
        Boolean (BoolOf (PrimalOf (ShareOf f))),
        AllTargetShow (PrimalOf (ShareOf f)),
        CommonTargetEqOrd (PrimalOf (ShareOf f)))),
      ShareTensor (ShareOf f), ShareTensor (PrimalOf (ShareOf f)),
      (ShareOf (ShareOf f) :: Target) ~ (ShareOf f :: Target)),
     LetTensor f) =>
    f (TKX2 sh xn) -> f (TKX2 shm xm) -> f (TKX2 sh xn))
-> target (TKX2 sh xn)
-> target (BuildTensorKind k (TKX2 shm xm))
-> target (BuildTensorKind (1 + k) (TKX2 sh xn))
forall (yn :: TK) (ym :: TK) (k :: Nat).
BaseTensor target =>
SNat k
-> SingletonTK yn
-> SingletonTK ym
-> (forall (f :: Target). ADReady f => f yn -> f ym -> f yn)
-> target yn
-> target (BuildTensorKind k ym)
-> target (BuildTensorKind (1 + k) yn)
forall (target :: Target) (yn :: TK) (ym :: TK) (k :: Nat).
(LetTensor target, BaseTensor target) =>
SNat k
-> SingletonTK yn
-> SingletonTK ym
-> (forall (f :: Target). ADReady f => f yn -> f ym -> f yn)
-> target yn
-> target (BuildTensorKind k ym)
-> target (BuildTensorKind (1 + k) yn)
tscan (forall (n :: Nat). KnownNat n => SNat n
SNat @k) SingletonTK (TKX2 sh xn)
forall (y :: TK). KnownSTK y => SingletonTK y
knownSTK SingletonTK (TKX2 shm xm)
forall (y :: TK). KnownSTK y => SingletonTK y
knownSTK

-- | Reverse derivative.
--
-- The function argument needs to be quantified,
-- because otherwise in the ADVal instance one could put an illegal
-- @DeltaInput@ there, confusing different levels of contangents.
kgrad :: forall x r target. BaseTensor target
      => (forall f. ADReady f => f x -> f (TKScalar r))  -- ^ x |-> TKScalar r
      -> FullShapeTK x  -- ^ shape of x and dx
      -> target x  -- ^ input x
      -> target (ADTensorKind x)  -- ^ gradient dx
kgrad :: forall (x :: TK) r (target :: Target).
BaseTensor target =>
(forall (f :: Target). ADReady f => f x -> f (TKScalar r))
-> FullShapeTK x -> target x -> target (ADTensorKind x)
kgrad forall (f :: Target). ADReady f => f x -> f (TKScalar r)
f FullShapeTK x
xftk =
  \ !target x
es -> HFunOf target x (ADTensorKind x)
-> target x -> target (ADTensorKind x)
forall (x :: TK) (z :: TK).
HFunOf target x z -> target x -> target z
forall (target :: Target) (x :: TK) (z :: TK).
BaseTensor target =>
HFunOf target x z -> target x -> target z
tApply (forall (target :: Target) (x :: TK) r.
BaseTensor target =>
FullShapeTK x
-> HFun x (TKScalar r) -> HFunOf target x (ADTensorKind x)
tgrad @target FullShapeTK x
xftk ((forall (f :: Target). ADReady f => f x -> f (TKScalar r))
-> HFun x (TKScalar r)
forall (x :: TK) (z :: TK).
(forall (f :: Target). ADReady f => f x -> f z) -> HFun x z
HFun f x -> f (TKScalar r)
forall (f :: Target). ADReady f => f x -> f (TKScalar r)
f)) target x
es
rvjp :: forall n x r target. BaseTensor target
     => (forall f. ADReady f => f x -> f (TKR2 n r))  -- ^ x |-> z
     -> FullShapeTK x  -- ^ shape of x and dx
     -> target x  -- ^ input x
     -> target (ADTensorKind (TKR2 n r))  -- ^ incoming cotangent dz
     -> target (ADTensorKind x)  -- ^ gradient dx
rvjp :: forall (n :: Nat) (x :: TK) (r :: TK) (target :: Target).
BaseTensor target =>
(forall (f :: Target). ADReady f => f x -> f (TKR2 n r))
-> FullShapeTK x
-> target x
-> target (ADTensorKind (TKR2 n r))
-> target (ADTensorKind x)
rvjp forall (f :: Target). ADReady f => f x -> f (TKR2 n r)
f FullShapeTK x
xftk =
  \ !target x
es !target (ADTensorKind (TKR2 n r))
dt -> HFunOf
  target (TKProduct (TKR2 n (ADTensorKind r)) x) (ADTensorKind x)
-> target (TKProduct (TKR2 n (ADTensorKind r)) x)
-> target (ADTensorKind x)
forall (x :: TK) (z :: TK).
HFunOf target x z -> target x -> target z
forall (target :: Target) (x :: TK) (z :: TK).
BaseTensor target =>
HFunOf target x z -> target x -> target z
tApply (forall (target :: Target) (x :: TK) (z :: TK).
BaseTensor target =>
FullShapeTK x
-> HFun x z
-> HFunOf target (TKProduct (ADTensorKind z) x) (ADTensorKind x)
tvjp @target FullShapeTK x
xftk (HFun x (TKR2 n r)
 -> HFunOf
      target (TKProduct (ADTensorKind (TKR2 n r)) x) (ADTensorKind x))
-> HFun x (TKR2 n r)
-> HFunOf
     target (TKProduct (ADTensorKind (TKR2 n r)) x) (ADTensorKind x)
forall a b. (a -> b) -> a -> b
$ (forall (f :: Target). ADReady f => f x -> f (TKR2 n r))
-> HFun x (TKR2 n r)
forall (x :: TK) (z :: TK).
(forall (f :: Target). ADReady f => f x -> f z) -> HFun x z
HFun f x -> f (TKR2 n r)
forall (f :: Target). ADReady f => f x -> f (TKR2 n r)
f) (target (TKR2 n (ADTensorKind r))
-> target x -> target (TKProduct (TKR2 n (ADTensorKind r)) x)
forall (x :: TK) (z :: TK).
target x -> target z -> target (TKProduct x z)
forall (target :: Target) (x :: TK) (z :: TK).
BaseTensor target =>
target x -> target z -> target (TKProduct x z)
tpair target (ADTensorKind (TKR2 n r))
target (TKR2 n (ADTensorKind r))
dt target x
es)
rjvp :: forall n x r target. BaseTensor target
     => (forall f. ADReady f => f x -> f (TKR2 n r))  -- ^ x |-> z
     -> FullShapeTK x  -- ^ shape of x and dx
     -> target x  -- ^ input x
     -> target (ADTensorKind x)  -- ^ incoming tangent dx
     -> target (ADTensorKind (TKR2 n r))  -- ^ derivative dz
rjvp :: forall (n :: Nat) (x :: TK) (r :: TK) (target :: Target).
BaseTensor target =>
(forall (f :: Target). ADReady f => f x -> f (TKR2 n r))
-> FullShapeTK x
-> target x
-> target (ADTensorKind x)
-> target (ADTensorKind (TKR2 n r))
rjvp forall (f :: Target). ADReady f => f x -> f (TKR2 n r)
f FullShapeTK x
xftk =
  \ !target x
es !target (ADTensorKind x)
ds -> HFunOf
  target (TKProduct (ADTensorKind x) x) (TKR2 n (ADTensorKind r))
-> target (TKProduct (ADTensorKind x) x)
-> target (TKR2 n (ADTensorKind r))
forall (x :: TK) (z :: TK).
HFunOf target x z -> target x -> target z
forall (target :: Target) (x :: TK) (z :: TK).
BaseTensor target =>
HFunOf target x z -> target x -> target z
tApply (forall (target :: Target) (x :: TK) (z :: TK).
BaseTensor target =>
FullShapeTK x
-> HFun x z
-> HFunOf target (TKProduct (ADTensorKind x) x) (ADTensorKind z)
tjvp @target FullShapeTK x
xftk (HFun x (TKR2 n r)
 -> HFunOf
      target (TKProduct (ADTensorKind x) x) (ADTensorKind (TKR2 n r)))
-> HFun x (TKR2 n r)
-> HFunOf
     target (TKProduct (ADTensorKind x) x) (ADTensorKind (TKR2 n r))
forall a b. (a -> b) -> a -> b
$ (forall (f :: Target). ADReady f => f x -> f (TKR2 n r))
-> HFun x (TKR2 n r)
forall (x :: TK) (z :: TK).
(forall (f :: Target). ADReady f => f x -> f z) -> HFun x z
HFun f x -> f (TKR2 n r)
forall (f :: Target). ADReady f => f x -> f (TKR2 n r)
f) (target (ADTensorKind x)
-> target x -> target (TKProduct (ADTensorKind x) x)
forall (x :: TK) (z :: TK).
target x -> target z -> target (TKProduct x z)
forall (target :: Target) (x :: TK) (z :: TK).
BaseTensor target =>
target x -> target z -> target (TKProduct x z)
tpair target (ADTensorKind x)
ds target x
es)
svjp :: forall sh x r target. BaseTensor target
     => (forall f. ADReady f => f x -> f (TKS2 sh r))  -- ^ x |-> z
     -> FullShapeTK x  -- ^ shape of x and dx
     -> target x  -- ^ input x
     -> target (ADTensorKind (TKS2 sh r))  -- ^ incoming cotangent dz
     -> target (ADTensorKind x)  -- ^ gradient dx
svjp :: forall (sh :: [Nat]) (x :: TK) (r :: TK) (target :: Target).
BaseTensor target =>
(forall (f :: Target). ADReady f => f x -> f (TKS2 sh r))
-> FullShapeTK x
-> target x
-> target (ADTensorKind (TKS2 sh r))
-> target (ADTensorKind x)
svjp forall (f :: Target). ADReady f => f x -> f (TKS2 sh r)
f FullShapeTK x
xftk =
  \ !target x
es !target (ADTensorKind (TKS2 sh r))
dt -> HFunOf
  target (TKProduct (TKS2 sh (ADTensorKind r)) x) (ADTensorKind x)
-> target (TKProduct (TKS2 sh (ADTensorKind r)) x)
-> target (ADTensorKind x)
forall (x :: TK) (z :: TK).
HFunOf target x z -> target x -> target z
forall (target :: Target) (x :: TK) (z :: TK).
BaseTensor target =>
HFunOf target x z -> target x -> target z
tApply (forall (target :: Target) (x :: TK) (z :: TK).
BaseTensor target =>
FullShapeTK x
-> HFun x z
-> HFunOf target (TKProduct (ADTensorKind z) x) (ADTensorKind x)
tvjp @target FullShapeTK x
xftk (HFun x (TKS2 sh r)
 -> HFunOf
      target (TKProduct (ADTensorKind (TKS2 sh r)) x) (ADTensorKind x))
-> HFun x (TKS2 sh r)
-> HFunOf
     target (TKProduct (ADTensorKind (TKS2 sh r)) x) (ADTensorKind x)
forall a b. (a -> b) -> a -> b
$ (forall (f :: Target). ADReady f => f x -> f (TKS2 sh r))
-> HFun x (TKS2 sh r)
forall (x :: TK) (z :: TK).
(forall (f :: Target). ADReady f => f x -> f z) -> HFun x z
HFun f x -> f (TKS2 sh r)
forall (f :: Target). ADReady f => f x -> f (TKS2 sh r)
f) (target (TKS2 sh (ADTensorKind r))
-> target x -> target (TKProduct (TKS2 sh (ADTensorKind r)) x)
forall (x :: TK) (z :: TK).
target x -> target z -> target (TKProduct x z)
forall (target :: Target) (x :: TK) (z :: TK).
BaseTensor target =>
target x -> target z -> target (TKProduct x z)
tpair target (ADTensorKind (TKS2 sh r))
target (TKS2 sh (ADTensorKind r))
dt target x
es)
sjvp :: forall sh x r target. BaseTensor target
     => (forall f. ADReady f => f x -> f (TKS2 sh r))
     -> FullShapeTK x  -- ^ shape of x and dx
     -> target x  -- ^ input x
     -> target (ADTensorKind x)  -- ^ incoming tangent dx
     -> target (ADTensorKind (TKS2 sh r))  -- ^ derivative dz
sjvp :: forall (sh :: [Nat]) (x :: TK) (r :: TK) (target :: Target).
BaseTensor target =>
(forall (f :: Target). ADReady f => f x -> f (TKS2 sh r))
-> FullShapeTK x
-> target x
-> target (ADTensorKind x)
-> target (ADTensorKind (TKS2 sh r))
sjvp forall (f :: Target). ADReady f => f x -> f (TKS2 sh r)
f FullShapeTK x
xftk =
  \ !target x
es !target (ADTensorKind x)
ds -> HFunOf
  target (TKProduct (ADTensorKind x) x) (TKS2 sh (ADTensorKind r))
-> target (TKProduct (ADTensorKind x) x)
-> target (TKS2 sh (ADTensorKind r))
forall (x :: TK) (z :: TK).
HFunOf target x z -> target x -> target z
forall (target :: Target) (x :: TK) (z :: TK).
BaseTensor target =>
HFunOf target x z -> target x -> target z
tApply (forall (target :: Target) (x :: TK) (z :: TK).
BaseTensor target =>
FullShapeTK x
-> HFun x z
-> HFunOf target (TKProduct (ADTensorKind x) x) (ADTensorKind z)
tjvp @target FullShapeTK x
xftk (HFun x (TKS2 sh r)
 -> HFunOf
      target (TKProduct (ADTensorKind x) x) (ADTensorKind (TKS2 sh r)))
-> HFun x (TKS2 sh r)
-> HFunOf
     target (TKProduct (ADTensorKind x) x) (ADTensorKind (TKS2 sh r))
forall a b. (a -> b) -> a -> b
$ (forall (f :: Target). ADReady f => f x -> f (TKS2 sh r))
-> HFun x (TKS2 sh r)
forall (x :: TK) (z :: TK).
(forall (f :: Target). ADReady f => f x -> f z) -> HFun x z
HFun f x -> f (TKS2 sh r)
forall (f :: Target). ADReady f => f x -> f (TKS2 sh r)
f) (target (ADTensorKind x)
-> target x -> target (TKProduct (ADTensorKind x) x)
forall (x :: TK) (z :: TK).
target x -> target z -> target (TKProduct x z)
forall (target :: Target) (x :: TK) (z :: TK).
BaseTensor target =>
target x -> target z -> target (TKProduct x z)
tpair target (ADTensorKind x)
ds target x
es)

-- These take @target@ first, because they change the target.
rprimalPart :: BaseTensor target
            => target (TKR2 n x) -> PrimalOf target (TKR2 n x)
rprimalPart :: forall (target :: Target) (n :: Nat) (x :: TK).
BaseTensor target =>
target (TKR2 n x) -> PrimalOf target (TKR2 n x)
rprimalPart = target (TKR2 n x) -> PrimalOf target (TKR2 n x)
forall (y :: TK). target y -> PrimalOf target y
forall (target :: Target) (y :: TK).
BaseTensor target =>
target y -> PrimalOf target y
tprimalPart
rdualPart :: (BaseTensor target, KnownNat n, KnownSTK x)
          => target (TKR2 n x) -> DualOf target (TKR2 n x)
rdualPart :: forall (target :: Target) (n :: Nat) (x :: TK).
(BaseTensor target, KnownNat n, KnownSTK x) =>
target (TKR2 n x) -> DualOf target (TKR2 n x)
rdualPart = SingletonTK (TKR2 n x)
-> target (TKR2 n x) -> DualOf target (TKR2 n x)
forall (y :: TK). SingletonTK y -> target y -> DualOf target y
forall (target :: Target) (y :: TK).
BaseTensor target =>
SingletonTK y -> target y -> DualOf target y
tdualPart SingletonTK (TKR2 n x)
forall (y :: TK). KnownSTK y => SingletonTK y
knownSTK
rfromPrimal :: (BaseTensor target, KnownNat n, KnownSTK x)
            => PrimalOf target (TKR2 n x) -> target (TKR2 n x)
rfromPrimal :: forall (target :: Target) (n :: Nat) (x :: TK).
(BaseTensor target, KnownNat n, KnownSTK x) =>
PrimalOf target (TKR2 n x) -> target (TKR2 n x)
rfromPrimal = SingletonTK (TKR2 n x)
-> PrimalOf target (TKR2 n x) -> target (TKR2 n x)
forall (y :: TK). SingletonTK y -> PrimalOf target y -> target y
forall (target :: Target) (y :: TK).
BaseTensor target =>
SingletonTK y -> PrimalOf target y -> target y
tfromPrimal SingletonTK (TKR2 n x)
forall (y :: TK). KnownSTK y => SingletonTK y
knownSTK
rfromDual :: BaseTensor target
          => DualOf target (TKR2 n x) -> target (TKR2 n x)
rfromDual :: forall (target :: Target) (n :: Nat) (x :: TK).
BaseTensor target =>
DualOf target (TKR2 n x) -> target (TKR2 n x)
rfromDual = DualOf target (TKR2 n x) -> target (TKR2 n x)
forall (y :: TK). DualOf target y -> target y
forall (target :: Target) (y :: TK).
BaseTensor target =>
DualOf target y -> target y
tfromDual
rScale :: ( BaseTensor target, KnownNat n, GoodScalar r
          , Num (target (TKR n r)), Num (PrimalOf target (TKR n r)) )
       => PrimalOf target (TKR n r) -> DualOf target (TKR n r)
       -> DualOf target (TKR n r)
rScale :: forall (target :: Target) (n :: Nat) r.
(BaseTensor target, KnownNat n, GoodScalar r,
 Num (target (TKR n r)), Num (PrimalOf target (TKR n r))) =>
PrimalOf target (TKR n r)
-> DualOf target (TKR n r) -> DualOf target (TKR n r)
rScale @target = forall (target :: Target) (y :: TK).
(BaseTensor target, Num (target y), Num (PrimalOf target y)) =>
SingletonTK y
-> PrimalOf target y -> DualOf target y -> DualOf target y
tScale @target SingletonTK (TKR n r)
forall (y :: TK). KnownSTK y => SingletonTK y
knownSTK

sprimalPart :: BaseTensor target
            => target (TKS2 sh x) -> PrimalOf target (TKS2 sh x)
sprimalPart :: forall (target :: Target) (sh :: [Nat]) (x :: TK).
BaseTensor target =>
target (TKS2 sh x) -> PrimalOf target (TKS2 sh x)
sprimalPart = target (TKS2 sh x) -> PrimalOf target (TKS2 sh x)
forall (y :: TK). target y -> PrimalOf target y
forall (target :: Target) (y :: TK).
BaseTensor target =>
target y -> PrimalOf target y
tprimalPart
sdualPart :: (BaseTensor target, KnownShS sh, KnownSTK x)
          => target (TKS2 sh x) -> DualOf target (TKS2 sh x)
sdualPart :: forall (target :: Target) (sh :: [Nat]) (x :: TK).
(BaseTensor target, KnownShS sh, KnownSTK x) =>
target (TKS2 sh x) -> DualOf target (TKS2 sh x)
sdualPart = SingletonTK (TKS2 sh x)
-> target (TKS2 sh x) -> DualOf target (TKS2 sh x)
forall (y :: TK). SingletonTK y -> target y -> DualOf target y
forall (target :: Target) (y :: TK).
BaseTensor target =>
SingletonTK y -> target y -> DualOf target y
tdualPart SingletonTK (TKS2 sh x)
forall (y :: TK). KnownSTK y => SingletonTK y
knownSTK
sfromPrimal :: (BaseTensor target, KnownShS sh, KnownSTK x)
            => PrimalOf target (TKS2 sh x) -> target (TKS2 sh x)
sfromPrimal :: forall (target :: Target) (sh :: [Nat]) (x :: TK).
(BaseTensor target, KnownShS sh, KnownSTK x) =>
PrimalOf target (TKS2 sh x) -> target (TKS2 sh x)
sfromPrimal = SingletonTK (TKS2 sh x)
-> PrimalOf target (TKS2 sh x) -> target (TKS2 sh x)
forall (y :: TK). SingletonTK y -> PrimalOf target y -> target y
forall (target :: Target) (y :: TK).
BaseTensor target =>
SingletonTK y -> PrimalOf target y -> target y
tfromPrimal SingletonTK (TKS2 sh x)
forall (y :: TK). KnownSTK y => SingletonTK y
knownSTK
sfromDual :: BaseTensor target
          => DualOf target (TKS2 sh x) -> target (TKS2 sh x)
sfromDual :: forall (target :: Target) (sh :: [Nat]) (x :: TK).
BaseTensor target =>
DualOf target (TKS2 sh x) -> target (TKS2 sh x)
sfromDual = DualOf target (TKS2 sh x) -> target (TKS2 sh x)
forall (y :: TK). DualOf target y -> target y
forall (target :: Target) (y :: TK).
BaseTensor target =>
DualOf target y -> target y
tfromDual
sScale :: ( BaseTensor target, KnownShS sh, GoodScalar r
          , Num (target (TKS sh r)), Num (PrimalOf target (TKS sh r)) )
       => PrimalOf target (TKS sh r) -> DualOf target (TKS sh r)
       -> DualOf target (TKS sh r)
sScale :: forall (target :: Target) (sh :: [Nat]) r.
(BaseTensor target, KnownShS sh, GoodScalar r,
 Num (target (TKS sh r)), Num (PrimalOf target (TKS sh r))) =>
PrimalOf target (TKS sh r)
-> DualOf target (TKS sh r) -> DualOf target (TKS sh r)
sScale @target = forall (target :: Target) (y :: TK).
(BaseTensor target, Num (target y), Num (PrimalOf target y)) =>
SingletonTK y
-> PrimalOf target y -> DualOf target y -> DualOf target y
tScale @target SingletonTK (TKS sh r)
forall (y :: TK). KnownSTK y => SingletonTK y
knownSTK

xprimalPart :: BaseTensor target
            => target (TKX2 sh x) -> PrimalOf target (TKX2 sh x)
xprimalPart :: forall (target :: Target) (sh :: [Maybe Nat]) (x :: TK).
BaseTensor target =>
target (TKX2 sh x) -> PrimalOf target (TKX2 sh x)
xprimalPart = target (TKX2 sh x) -> PrimalOf target (TKX2 sh x)
forall (y :: TK). target y -> PrimalOf target y
forall (target :: Target) (y :: TK).
BaseTensor target =>
target y -> PrimalOf target y
tprimalPart
xdualPart :: (BaseTensor target, KnownShX sh, KnownSTK x)
          => target (TKX2 sh x) -> DualOf target (TKX2 sh x)
xdualPart :: forall (target :: Target) (sh :: [Maybe Nat]) (x :: TK).
(BaseTensor target, KnownShX sh, KnownSTK x) =>
target (TKX2 sh x) -> DualOf target (TKX2 sh x)
xdualPart = SingletonTK (TKX2 sh x)
-> target (TKX2 sh x) -> DualOf target (TKX2 sh x)
forall (y :: TK). SingletonTK y -> target y -> DualOf target y
forall (target :: Target) (y :: TK).
BaseTensor target =>
SingletonTK y -> target y -> DualOf target y
tdualPart SingletonTK (TKX2 sh x)
forall (y :: TK). KnownSTK y => SingletonTK y
knownSTK
xfromPrimal :: (BaseTensor target, KnownShX sh, KnownSTK x)
            => PrimalOf target (TKX2 sh x) -> target (TKX2 sh x)
xfromPrimal :: forall (target :: Target) (sh :: [Maybe Nat]) (x :: TK).
(BaseTensor target, KnownShX sh, KnownSTK x) =>
PrimalOf target (TKX2 sh x) -> target (TKX2 sh x)
xfromPrimal = SingletonTK (TKX2 sh x)
-> PrimalOf target (TKX2 sh x) -> target (TKX2 sh x)
forall (y :: TK). SingletonTK y -> PrimalOf target y -> target y
forall (target :: Target) (y :: TK).
BaseTensor target =>
SingletonTK y -> PrimalOf target y -> target y
tfromPrimal SingletonTK (TKX2 sh x)
forall (y :: TK). KnownSTK y => SingletonTK y
knownSTK
xfromDual :: BaseTensor target
          => DualOf target (TKX2 sh x) -> target (TKX2 sh x)
xfromDual :: forall (target :: Target) (sh :: [Maybe Nat]) (x :: TK).
BaseTensor target =>
DualOf target (TKX2 sh x) -> target (TKX2 sh x)
xfromDual = DualOf target (TKX2 sh x) -> target (TKX2 sh x)
forall (y :: TK). DualOf target y -> target y
forall (target :: Target) (y :: TK).
BaseTensor target =>
DualOf target y -> target y
tfromDual
xScale :: ( BaseTensor target, KnownShX sh, GoodScalar r
          , Num (target (TKX sh r)), Num (PrimalOf target (TKX sh r)) )
       => PrimalOf target (TKX sh r) -> DualOf target (TKX sh r)
       -> DualOf target (TKX sh r)
xScale :: forall (target :: Target) (sh :: [Maybe Nat]) r.
(BaseTensor target, KnownShX sh, GoodScalar r,
 Num (target (TKX sh r)), Num (PrimalOf target (TKX sh r))) =>
PrimalOf target (TKX sh r)
-> DualOf target (TKX sh r) -> DualOf target (TKX sh r)
xScale @target = forall (target :: Target) (y :: TK).
(BaseTensor target, Num (target y), Num (PrimalOf target y)) =>
SingletonTK y
-> PrimalOf target y -> DualOf target y -> DualOf target y
tScale @target SingletonTK (TKX sh r)
forall (y :: TK). KnownSTK y => SingletonTK y
knownSTK

kprimalPart :: BaseTensor target
            => target (TKScalar r) -> PrimalOf target (TKScalar r)
kprimalPart :: forall (target :: Target) r.
BaseTensor target =>
target (TKScalar r) -> PrimalOf target (TKScalar r)
kprimalPart = target (TKScalar r) -> PrimalOf target (TKScalar r)
forall (y :: TK). target y -> PrimalOf target y
forall (target :: Target) (y :: TK).
BaseTensor target =>
target y -> PrimalOf target y
tprimalPart
kdualPart :: (BaseTensor target, GoodScalar r)
          => target (TKScalar r) -> DualOf target (TKScalar r)
kdualPart :: forall (target :: Target) r.
(BaseTensor target, GoodScalar r) =>
target (TKScalar r) -> DualOf target (TKScalar r)
kdualPart = SingletonTK (TKScalar r)
-> target (TKScalar r) -> DualOf target (TKScalar r)
forall (y :: TK). SingletonTK y -> target y -> DualOf target y
forall (target :: Target) (y :: TK).
BaseTensor target =>
SingletonTK y -> target y -> DualOf target y
tdualPart SingletonTK (TKScalar r)
forall (y :: TK). KnownSTK y => SingletonTK y
knownSTK
kfromPrimal :: (BaseTensor target, GoodScalar r)
            => PrimalOf target (TKScalar r) -> target (TKScalar r)
kfromPrimal :: forall (target :: Target) r.
(BaseTensor target, GoodScalar r) =>
PrimalOf target (TKScalar r) -> target (TKScalar r)
kfromPrimal = SingletonTK (TKScalar r)
-> PrimalOf target (TKScalar r) -> target (TKScalar r)
forall (y :: TK). SingletonTK y -> PrimalOf target y -> target y
forall (target :: Target) (y :: TK).
BaseTensor target =>
SingletonTK y -> PrimalOf target y -> target y
tfromPrimal SingletonTK (TKScalar r)
forall (y :: TK). KnownSTK y => SingletonTK y
knownSTK
kfromDual :: BaseTensor target
          => DualOf target (TKScalar r) -> target (TKScalar r)
kfromDual :: forall (target :: Target) r.
BaseTensor target =>
DualOf target (TKScalar r) -> target (TKScalar r)
kfromDual = DualOf target (TKScalar r) -> target (TKScalar r)
forall (y :: TK). DualOf target y -> target y
forall (target :: Target) (y :: TK).
BaseTensor target =>
DualOf target y -> target y
tfromDual
kScale :: ( BaseTensor target, GoodScalar r
          , Num (target (TKScalar r)), Num (PrimalOf target (TKScalar r)) )
       => PrimalOf target (TKScalar r) -> DualOf target (TKScalar r)
       -> DualOf target (TKScalar r)
kScale :: forall (target :: Target) r.
(BaseTensor target, GoodScalar r, Num (target (TKScalar r)),
 Num (PrimalOf target (TKScalar r))) =>
PrimalOf target (TKScalar r)
-> DualOf target (TKScalar r) -> DualOf target (TKScalar r)
kScale @target = forall (target :: Target) (y :: TK).
(BaseTensor target, Num (target y), Num (PrimalOf target y)) =>
SingletonTK y
-> PrimalOf target y -> DualOf target y -> DualOf target y
tScale @target SingletonTK (TKScalar r)
forall (y :: TK). KnownSTK y => SingletonTK y
knownSTK