horde-ad-0.1.0.0: Higher Order Reverse Derivatives Efficiently - Automatic Differentiation
Safe HaskellNone
LanguageGHC2024

HordeAd.OpsTensor

Description

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 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.

Synopsis

Shape manipulation

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

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

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

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

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

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

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

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

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

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

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

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

tsize :: forall (y :: TK). BaseTensor target => SingletonTK y -> target y -> Int Source #

tftk :: forall (y :: TK). BaseTensor target => SingletonTK y -> target y -> FullShapeTK y Source #

Constructing arrays from concrete values, lists and vectors

rconcrete :: forall r target (n :: Nat). (GoodScalar r, BaseTensor target) => Ranked n r -> target (TKR n r) Source #

rscalar :: (GoodScalar r, BaseTensor target) => r -> target (TKR 0 r) Source #

rrepl :: forall (n :: Nat) r target. (GoodScalar r, BaseTensor target) => IShR n -> r -> target (TKR n r) Source #

ringestData :: forall (n :: Nat) r target. (GoodScalar r, BaseTensor target) => IShR n -> [r] -> target (TKR n r) Source #

rfromListLinear :: forall (n :: Nat) r target. (GoodScalar r, BaseTensor target) => IShR n -> NonEmpty r -> target (TKR n r) Source #

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.

sconcrete :: forall r target (sh :: [Nat]). (GoodScalar r, BaseTensor target) => Shaped sh r -> target (TKS sh r) Source #

sscalar :: (GoodScalar r, BaseTensor target) => r -> target (TKS ('[] :: [Nat]) r) Source #

srepl :: forall (sh :: [Nat]) r target. (KnownShS sh, GoodScalar r, BaseTensor target) => r -> target (TKS sh r) Source #

singestData :: forall (sh :: [Nat]) r target. (KnownShS sh, GoodScalar r, BaseTensor target) => [r] -> target (TKS sh r) Source #

sfromListLinear :: forall (sh :: [Nat]) r target. (GoodScalar r, BaseTensor target) => ShS sh -> NonEmpty r -> target (TKS sh r) Source #

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.

xconcrete :: forall r target (sh :: [Maybe Nat]). (GoodScalar r, BaseTensor target) => Mixed sh r -> target (TKX sh r) Source #

xscalar :: (GoodScalar r, BaseTensor target) => r -> target (TKX ('[] :: [Maybe Nat]) r) Source #

xrepl :: forall (sh :: [Maybe Nat]) r target. (GoodScalar r, BaseTensor target) => IShX sh -> r -> target (TKX sh r) Source #

xingestData :: forall (sh :: [Maybe Nat]) r target. (GoodScalar r, BaseTensor target) => IShX sh -> [r] -> target (TKX sh r) Source #

xfromListLinear :: forall (sh :: [Maybe Nat]) r target. (GoodScalar r, BaseTensor target) => IShX sh -> NonEmpty r -> target (TKX sh r) Source #

kconcrete :: (GoodScalar r, BaseTensor target) => r -> target ('TKScalar r) Source #

rfromList :: forall (n :: Nat) (x :: TK) target. (KnownNat n, KnownSTK x, BaseTensor target) => NonEmpty (target ('TKR2 n x)) -> target ('TKR2 (1 + n) x) Source #

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.

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

Create a tensor from a non-empty strict boxed vector treated as the outermost dimension.

rfromVector0N :: forall (n :: Nat) (x :: TK) target. (KnownSTK x, BaseTensor target) => IShR n -> Vector (target ('TKR2 0 x)) -> target ('TKR2 n x) Source #

rfromList0N :: forall (n :: Nat) (x :: TK) target. (KnownSTK x, BaseTensor target) => IShR n -> [target ('TKR2 0 x)] -> target ('TKR2 n x) Source #

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

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.

sfromList :: forall (n :: Nat) (sh :: [Nat]) (x :: TK) target. (KnownNat n, KnownShS sh, KnownSTK x, BaseTensor target) => NonEmpty (target ('TKS2 sh x)) -> target ('TKS2 (n ': sh) x) Source #

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.

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

Create a tensor from a non-empty strict boxed vector treated as the outermost dimension.

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

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

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

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.

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

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.

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

Create a tensor from a non-empty strict boxed vector treated as the outermost dimension.

xfromVector0N :: forall (sh :: [Maybe Nat]) (x :: TK) target. (KnownSTK x, BaseTensor target) => IShX sh -> Vector (target ('TKX2 ('[] :: [Maybe Nat]) x)) -> target ('TKX2 sh x) Source #

xfromList0N :: forall (sh :: [Maybe Nat]) (x :: TK) target. (KnownSTK x, BaseTensor target) => IShX sh -> [target ('TKX2 ('[] :: [Maybe Nat]) x)] -> target ('TKX2 sh x) Source #

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

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.

Main array operations

tunit :: BaseTensor target => target TKUnit Source #

tlet :: forall (x :: TK) (z :: TK) target. LetTensor target => target x -> (target x -> target z) -> target z Source #

ifH :: forall (y :: TK) target. (KnownSTK y, Boolean (BoolOf target), BaseTensor target) => BoolOf target -> target y -> target y -> target y Source #

The operation is potentially strict in all arguments.

minH :: forall (y :: TK) target. (KnownSTK y, OrdH target y, BaseTensor target) => target y -> target y -> target y Source #

maxH :: forall (y :: TK) target. (KnownSTK y, OrdH target y, BaseTensor target) => target y -> target y -> target y Source #

tpair :: forall (x :: TK) (z :: TK). BaseTensor target => target x -> target z -> target ('TKProduct x z) Source #

tproject1 :: forall (x :: TK) (z :: TK). BaseTensor target => target ('TKProduct x z) -> target x Source #

tproject2 :: forall (x :: TK) (z :: TK). BaseTensor target => target ('TKProduct x z) -> target z Source #

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

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

rdot0 :: forall (n :: Nat) r target. (KnownNat n, GoodScalar r, BaseTensor target) => target (TKR n r) -> target (TKR n r) -> target (TKR 0 r) Source #

rdot1In :: forall (n :: Nat) r target. (KnownNat n, GoodScalar r, BaseTensor target) => target (TKR (1 + n) r) -> target (TKR (1 + n) r) -> target (TKR n r) Source #

rmatvecmul :: (GoodScalar r, BaseTensor target) => target (TKR 2 r) -> target (TKR 1 r) -> target (TKR 1 r) Source #

rmatmul2 :: (GoodScalar r, BaseTensor target) => target (TKR 2 r) -> target (TKR 2 r) -> target (TKR 2 r) Source #

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

Copy the given tensor along the new, outermost dimension.

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

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

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

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

sdot1In :: forall (sh :: [Nat]) (n :: Nat) r target. (KnownShS sh, KnownNat n, GoodScalar r, BaseTensor target) => target (TKS (sh ++ '[n]) r) -> target (TKS (sh ++ '[n]) r) -> target (TKS sh r) Source #

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

smatmul2 :: forall (m :: Nat) (n :: Nat) (p :: Nat) r target. (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) Source #

sreplicate :: forall (k :: Nat) (sh :: [Nat]) (x :: TK) target. (KnownNat k, KnownShS sh, KnownSTK x, BaseTensor target) => target ('TKS2 sh x) -> target ('TKS2 (k ': sh) x) Source #

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

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

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

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

xdot1In :: forall (sh :: [Maybe Nat]) (n :: Nat) r target. (KnownShX sh, KnownNat n, GoodScalar r, BaseTensor target) => target (TKX (sh ++ '['Just n]) r) -> target (TKX (sh ++ '['Just n]) r) -> target (TKX sh r) Source #

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

xmatmul2 :: forall (m :: Nat) (n :: Nat) (p :: Nat) r target. (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) Source #

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

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

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

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.

(!) :: forall (m :: Nat) (n :: Nat) (x :: TK) target. (KnownNat m, KnownNat n, KnownSTK x, BaseTensor target) => target ('TKR2 (m + n) x) -> IxROf target m -> target ('TKR2 n x) infixl 9 Source #

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.

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

roneHot :: forall (m :: Nat) (n :: Nat) (x :: TK) target. (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) Source #

rscatter :: forall (m :: Nat) (n :: Nat) (p :: Nat) (x :: TK) 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) Source #

rscatter1 :: forall (n :: Nat) (p :: Nat) (x :: TK) 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) Source #

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.

rgather :: forall (m :: Nat) (n :: Nat) (p :: Nat) (x :: TK) 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) Source #

rgather1 :: forall (n :: Nat) (p :: Nat) (x :: TK) 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) Source #

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.

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

(!$) :: forall (shm :: [Nat]) (shn :: [Nat]) (x :: TK) target. (KnownShS shm, KnownShS shn, KnownSTK x, BaseTensor target) => target ('TKS2 (shm ++ shn) x) -> IxSOf target shm -> target ('TKS2 shn x) infixl 9 Source #

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

soneHot :: forall (sh1 :: [Nat]) (sh2 :: [Nat]) (x :: TK) target. (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) Source #

sscatter :: forall (shm :: [Nat]) (shn :: [Nat]) (shp :: [Nat]) (x :: TK) target. (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) Source #

sscatter1 :: forall (n2 :: Nat) (shn :: [Nat]) (shp :: [Nat]) (x :: TK) target. (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) Source #

sgather :: forall (shm :: [Nat]) (shn :: [Nat]) (shp :: [Nat]) (x :: TK) target. (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) Source #

sgather1 :: forall (n2 :: Nat) (shn :: [Nat]) (shp :: [Nat]) (x :: TK) target. (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) Source #

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

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

xoneHot :: forall (sh1 :: [Maybe Nat]) (sh2 :: [Maybe Nat]) (x :: TK) target. (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) Source #

xscatter :: forall (shm :: [Maybe Nat]) (shn :: [Maybe Nat]) (shp :: [Maybe Nat]) (x :: TK) target. (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) Source #

xscatter1 :: forall (n2 :: Nat) (shn :: [Maybe Nat]) (shp :: [Maybe Nat]) (x :: TK) target. (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) Source #

xgather :: forall (shm :: [Maybe Nat]) (shn :: [Maybe Nat]) (shp :: [Maybe Nat]) (x :: TK) target. (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) Source #

xgather1 :: forall (n2 :: Nat) (shn :: [Maybe Nat]) (shp :: [Maybe Nat]) (x :: TK) target. (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) Source #

rtr :: forall (n :: Natural) (x :: TK) target. (KnownSTK x, BaseTensor target) => target ('TKR2 (2 + n) x) -> target ('TKR2 (2 + n) x) Source #

rtranspose :: forall (n :: Nat) (x :: TK) target. (KnownSTK x, BaseTensor target) => PermR -> target ('TKR2 n x) -> target ('TKR2 n x) Source #

Transpose according to the permutation.

rflatten :: forall (n :: Nat) (x :: TK) target. (KnownSTK x, BaseTensor target) => target ('TKR2 n x) -> target ('TKR2 1 x) Source #

rreshape :: forall (n :: Nat) (m :: Nat) (x :: TK) target. (KnownSTK x, BaseTensor target) => IShR m -> target ('TKR2 n x) -> target ('TKR2 m x) Source #

Change the shape of the tensor to the given one.

str :: forall (n :: Nat) (m :: Nat) (sh :: [Nat]) (x :: TK) target. (KnownSTK x, BaseTensor target) => target ('TKS2 (n ': (m ': sh)) x) -> target ('TKS2 (m ': (n ': sh)) x) Source #

stranspose :: forall (perm :: [Nat]) (sh :: [Nat]) (x :: TK) target. (KnownPerm perm, IsPermutation perm, Rank perm <= Rank sh, KnownSTK x, BaseTensor target) => target ('TKS2 sh x) -> target ('TKS2 (PermutePrefix perm sh) x) Source #

sflatten :: forall (sh :: [Nat]) (x :: TK) target. (KnownShS sh, KnownSTK x, BaseTensor target) => target ('TKS2 sh x) -> target ('TKS2 '[Product sh] x) Source #

sreshape :: forall (sh :: [Natural]) (sh2 :: [Natural]) (x :: TK) target. (Product sh ~ Product sh2, KnownShS sh2, KnownSTK x, BaseTensor target) => target ('TKS2 sh x) -> target ('TKS2 sh2 x) Source #

xtr :: forall (n :: Nat) (m :: Nat) (sh :: [Maybe Nat]) (x :: TK) target. (KnownSTK x, BaseTensor target) => target ('TKX2 ('Just n ': ('Just m ': sh)) x) -> target ('TKX2 ('Just m ': ('Just n ': sh)) x) Source #

xtranspose :: forall (perm :: [Nat]) (sh :: [Maybe Nat]) (x :: TK) target. (KnownPerm perm, IsPermutation perm, Rank perm <= Rank sh, KnownSTK x, BaseTensor target) => target ('TKX2 sh x) -> target ('TKX2 (PermutePrefix perm sh) x) Source #

xflatten :: forall (sh :: [Maybe Nat]) (x :: TK) target. (KnownSTK x, BaseTensor target) => target ('TKX2 sh x) -> target ('TKX2 '['Nothing :: Maybe Nat] x) Source #

xreshape :: forall (sh :: [Maybe Nat]) (sh2 :: [Maybe Nat]) (x :: TK) target. (KnownSTK x, BaseTensor target) => IShX sh2 -> target ('TKX2 sh x) -> target ('TKX2 sh2 x) Source #

Auxiliary array operations

rfloor :: forall r r2 target (n :: Nat). (GoodScalar r, RealFrac r, GoodScalar r2, Integral r2, BaseTensor target) => target (TKR n r) -> target (TKR n r2) Source #

rfromIntegral :: forall r1 r2 target (n :: Nat). (GoodScalar r1, Integral r1, GoodScalar r2, BaseTensor target) => target (TKR n r1) -> target (TKR n r2) Source #

rcast :: forall r1 r2 target (n :: Nat). (RealFrac r1, GoodScalar r1, RealFrac r2, GoodScalar r2, BaseTensor target) => target (TKR n r1) -> target (TKR n r2) Source #

rminIndex :: forall (n :: Natural) r r2 target. (GoodScalar r, GoodScalar r2, BaseTensor target) => target (TKR (1 + n) r) -> target (TKR n r2) Source #

rmaxIndex :: forall (n :: Natural) r r2 target. (GoodScalar r, GoodScalar r2, BaseTensor target) => target (TKR (1 + n) r) -> target (TKR n r2) Source #

riota :: (GoodScalar r, BaseTensor target) => Int -> target (TKR 1 r) Source #

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

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

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

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

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

siota :: forall (n :: Nat) r target. (KnownNat n, GoodScalar r, BaseTensor target) => target (TKS '[n] r) Source #

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

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

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

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

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

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

kfloor :: (GoodScalar r, RealFrac r, GoodScalar r2, Integral r2, BaseTensor target) => target ('TKScalar r) -> target ('TKScalar r2) Source #

kfromIntegral :: (GoodScalar r1, Integral r1, GoodScalar r2, BaseTensor target) => target ('TKScalar r1) -> target ('TKScalar r2) Source #

kcast :: (RealFrac r1, GoodScalar r1, RealFrac r2, GoodScalar r2, BaseTensor target) => target ('TKScalar r1) -> target ('TKScalar r2) Source #

rappend :: forall (n :: Natural) (x :: TK) target. (KnownSTK x, BaseTensor target) => target ('TKR2 (1 + n) x) -> target ('TKR2 (1 + n) x) -> target ('TKR2 (1 + n) x) Source #

Append two arrays along the outermost dimension. All dimensions, except the outermost, must be the same.

rconcat :: forall (n :: Natural) (x :: TK) target. (KnownSTK x, BaseTensor target) => NonEmpty (target ('TKR2 (1 + n) x)) -> target ('TKR2 (1 + n) x) Source #

rslice :: forall (n :: Natural) (x :: TK) target. (KnownSTK x, BaseTensor target) => Int -> Int -> target ('TKR2 (1 + n) x) -> target ('TKR2 (1 + n) x) Source #

Extract a slice of an array along the outermost dimension. The extracted slice must fall within the dimension.

runcons :: forall (n :: Nat) (x :: TK) target. (KnownNat n, KnownSTK x, BaseTensor target) => target ('TKR2 (1 + n) x) -> Maybe (target ('TKR2 n x), target ('TKR2 (1 + n) x)) Source #

rreverse :: forall (n :: Natural) (x :: TK) target. (KnownSTK x, BaseTensor target) => target ('TKR2 (1 + n) x) -> target ('TKR2 (1 + n) x) Source #

Reverse elements of the outermost dimension.

sappend :: forall (m :: Nat) (n :: Nat) (sh :: [Nat]) (x :: TK) target. (KnownSTK x, BaseTensor target) => target ('TKS2 (m ': sh) x) -> target ('TKS2 (n ': sh) x) -> target ('TKS2 ((m + n) ': sh) x) Source #

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

suncons :: forall (n :: Nat) (sh :: [Nat]) (x :: TK) target. (KnownNat n, KnownShS sh, KnownSTK x, BaseTensor target) => target ('TKS2 (n ': sh) x) -> Maybe (target ('TKS2 sh x), target ('TKS2 ((n - 1) ': sh) x)) Source #

sreverse :: forall (n :: Nat) (sh :: [Nat]) (x :: TK) target. (KnownSTK x, BaseTensor target) => target ('TKS2 (n ': sh) x) -> target ('TKS2 (n ': sh) x) Source #

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

xappend0 :: forall (sh :: [Maybe Nat]) (x :: TK) target. (KnownSTK x, BaseTensor target, ConvertTensor target) => target ('TKX2 (('Nothing :: Maybe Nat) ': sh) x) -> target ('TKX2 (('Nothing :: Maybe Nat) ': sh) x) -> target ('TKX2 (('Nothing :: Maybe Nat) ': sh) x) Source #

xconcat :: forall (sh :: [Maybe Nat]) (x :: TK) target. (KnownSTK x, BaseTensor target, ConvertTensor target) => NonEmpty (target ('TKX2 (('Nothing :: Maybe Nat) ': sh) x)) -> target ('TKX2 (('Nothing :: Maybe Nat) ': sh) x) Source #

xslice :: forall (i :: Nat) (n :: Nat) (k :: Nat) (sh :: [Maybe Natural]) (x :: TK) 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) Source #

xuncons :: forall (n :: Nat) (sh :: [Maybe Nat]) (x :: TK) target. (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)) Source #

xreverse :: forall (mn :: Maybe Nat) (sh :: [Maybe Nat]) (x :: TK) target. (KnownSTK x, BaseTensor target) => target ('TKX2 (mn ': sh) x) -> target ('TKX2 (mn ': sh) x) Source #

Array operations derived from build

rbuild Source #

Arguments

:: forall (m :: Nat) (n :: Nat) (x :: TK) target. (KnownNat m, KnownNat n, KnownSTK x, BaseTensor target) 
=> IShR (m + n)

the shape of the resulting tensor

-> (IxROf target m -> target ('TKR2 n x))

the function to build with

-> target ('TKR2 (m + n) x) 

rbuild1 Source #

Arguments

:: forall (n :: Nat) (x :: TK) target. (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) 

rmap Source #

Arguments

:: forall (m :: Nat) (n :: Nat) (x :: TK) (x2 :: TK) target. (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) 

rmap1 Source #

Arguments

:: forall (n :: Nat) (x :: TK) (x2 :: TK) target. (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) 

rmap0N Source #

Arguments

:: forall (n :: Nat) (x :: TK) (x1 :: TK) target. (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) 

rzipWith Source #

Arguments

:: forall (m :: Nat) (n1 :: Nat) (n2 :: Nat) (n :: Nat) (x :: TK) (x1 :: TK) (x2 :: TK) target. (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) 

rzipWith1 Source #

Arguments

:: forall (n1 :: Nat) (n2 :: Nat) (n :: Nat) (x :: TK) (x1 :: TK) (x2 :: TK) 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))

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) 

rzipWith0N Source #

Arguments

:: forall (n :: Nat) (x :: TK) (x1 :: TK) (x2 :: TK) target. (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) 

rzipWith3 Source #

Arguments

:: forall (m :: Nat) (n1 :: Nat) (n2 :: Nat) (n3 :: Nat) (n :: Nat) (x :: TK) (x1 :: TK) (x2 :: TK) (x3 :: TK) target. (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) 

rzipWith31 Source #

Arguments

:: forall (n1 :: Nat) (n2 :: Nat) (n3 :: Nat) (n :: Nat) (x :: TK) (x1 :: TK) (x2 :: TK) (x3 :: TK) 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))

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) 

rzipWith30N Source #

Arguments

:: forall (n :: Nat) (x :: TK) (x1 :: TK) (x2 :: TK) (x3 :: TK) 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))

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) 

rzipWith4 Source #

Arguments

:: forall (m :: Nat) (n1 :: Nat) (n2 :: Nat) (n3 :: Nat) (n4 :: Nat) (n :: Nat) (x :: TK) (x1 :: TK) (x2 :: TK) (x3 :: TK) (x4 :: TK) 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)

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) 

rzipWith41 Source #

Arguments

:: forall (n1 :: Nat) (n2 :: Nat) (n3 :: Nat) (n4 :: Nat) (n :: Nat) (x :: TK) (x1 :: TK) (x2 :: TK) (x3 :: TK) (x4 :: TK) 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))

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) 

rzipWith40N Source #

Arguments

:: forall (n :: Nat) (x :: TK) (x1 :: TK) (x2 :: TK) (x3 :: TK) (x4 :: TK) 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))

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) 

sbuild Source #

Arguments

:: forall (m :: Nat) (sh :: [Nat]) (x :: TK) target. (KnownShS (Take m sh), KnownShS sh, KnownSTK x, BaseTensor target) 
=> (IxSOf target (Take m sh) -> target ('TKS2 (Drop m sh) x))

the function to build with

-> target ('TKS2 sh x) 

sbuild1 Source #

Arguments

:: forall (k :: Nat) (sh :: [Nat]) (x :: TK) target. (KnownNat k, KnownShS sh, KnownSTK x, BaseTensor target) 
=> (IntOf target -> target ('TKS2 sh x))

the function to build with

-> target ('TKS2 (k ': sh) x) 

smap Source #

Arguments

:: forall (m :: Nat) (sh :: [Nat]) (x :: TK) (x2 :: TK) target. (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) 

smap1 Source #

Arguments

:: forall (n :: Nat) (sh :: [Nat]) (x :: TK) (x2 :: TK) target. (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) 

smap0N Source #

Arguments

:: forall (sh :: [Nat]) (x1 :: TK) (x :: TK) target. (KnownShS sh, KnownSTK x1, KnownSTK x, BaseTensor target) 
=> (target ('TKS2 ('[] :: [Nat]) x1) -> target ('TKS2 ('[] :: [Nat]) x))

the function to map with

-> target ('TKS2 sh x1)

the tensor to map over

-> target ('TKS2 sh x) 

szipWith Source #

Arguments

:: forall (m :: Nat) (sh1 :: [Nat]) (sh2 :: [Nat]) (sh :: [Nat]) (x :: TK) (x1 :: TK) (x2 :: TK) target. (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) 

szipWith1 Source #

Arguments

:: forall (n :: Nat) (sh1 :: [Nat]) (sh2 :: [Nat]) (sh :: [Nat]) (x :: TK) (x1 :: TK) (x2 :: TK) 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))

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) 

szipWith0N Source #

Arguments

:: forall (sh :: [Nat]) (x :: TK) (x1 :: TK) (x2 :: TK) target. (KnownShS sh, KnownSTK x, KnownSTK x1, KnownSTK x2, BaseTensor target) 
=> (target ('TKS2 ('[] :: [Nat]) x1) -> target ('TKS2 ('[] :: [Nat]) x2) -> target ('TKS2 ('[] :: [Nat]) 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) 

szipWith3 Source #

Arguments

:: forall (m :: Nat) (sh1 :: [Nat]) (sh2 :: [Nat]) (sh3 :: [Nat]) (sh :: [Nat]) (x :: TK) (x1 :: TK) (x2 :: TK) (x3 :: TK) target. (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) 

szipWith31 Source #

Arguments

:: forall (n :: Nat) (sh1 :: [Nat]) (sh2 :: [Nat]) (sh3 :: [Nat]) (sh :: [Nat]) (x :: TK) (x1 :: TK) (x2 :: TK) (x3 :: TK) 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))

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) 

szipWith30N Source #

Arguments

:: forall (sh :: [Nat]) (x :: TK) (x1 :: TK) (x2 :: TK) (x3 :: TK) 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))

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) 

szipWith4 Source #

Arguments

:: forall (m :: Nat) (sh1 :: [Nat]) (sh2 :: [Nat]) (sh3 :: [Nat]) (sh4 :: [Nat]) (sh :: [Nat]) (x :: TK) (x1 :: TK) (x2 :: TK) (x3 :: TK) (x4 :: TK) target. (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) 

szipWith41 Source #

Arguments

:: forall (n :: Nat) (sh1 :: [Nat]) (sh2 :: [Nat]) (sh3 :: [Nat]) (sh4 :: [Nat]) (sh :: [Nat]) (x :: TK) (x1 :: TK) (x2 :: TK) (x3 :: TK) (x4 :: TK) 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))

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) 

szipWith40N Source #

Arguments

:: forall (sh :: [Nat]) (x :: TK) (x1 :: TK) (x2 :: TK) (x3 :: TK) (x4 :: TK) 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))

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) 

xbuild Source #

Arguments

:: forall (m :: Nat) (sh :: [Maybe Nat]) (x :: TK) target. (KnownShX (Take m sh), KnownSTK x, BaseTensor target, ConvertTensor target) 
=> IShX sh

the shape of the resulting tensor

-> (IxXOf target (Take m sh) -> target ('TKX2 (Drop m sh) x))

the function to build with

-> target ('TKX2 sh x) 

xbuild1 Source #

Arguments

:: forall (k :: Nat) (sh :: [Maybe Nat]) (x :: TK) target. (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) 

Array operations derived from mapAccum

rfold Source #

Arguments

:: forall (n :: Nat) (m :: Nat) (xn :: TK) (xm :: TK) 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))

the function to fold with

-> target ('TKR2 n xn)

the initial accumulator

-> target ('TKR2 (1 + m) xm)

the inputs

-> target ('TKR2 n xn) 

rscan Source #

Arguments

:: forall (n :: Nat) (m :: Nat) (xn :: TK) (xm :: TK) 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))

the function to fold with

-> target ('TKR2 n xn)

the initial accumulator

-> target ('TKR2 (1 + m) xm)

the inputs

-> target ('TKR2 (1 + n) xn) 

sfold Source #

Arguments

:: forall (k :: Nat) (sh :: [Nat]) (shm :: [Nat]) (xn :: TK) (xm :: TK) 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))

the function to fold with

-> target ('TKS2 sh xn)

the initial accumulator

-> target ('TKS2 (k ': shm) xm)

the inputs

-> target ('TKS2 sh xn) 

sscan Source #

Arguments

:: forall (k :: Nat) (sh :: [Nat]) (shm :: [Nat]) (xn :: TK) (xm :: TK) 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))

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) 

xfold Source #

Arguments

:: forall (k :: Nat) (sh :: [Maybe Nat]) (shm :: [Maybe Nat]) (xn :: TK) (xm :: TK) 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))

the function to scan with

-> target ('TKX2 sh xn)

the initial accumulator

-> target (BuildTensorKind k ('TKX2 shm xm))

the inputs

-> target ('TKX2 sh xn) 

xscan Source #

Arguments

:: forall (k :: Nat) (sh :: [Maybe Nat]) (shm :: [Maybe Nat]) (xn :: TK) (xm :: TK) 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))

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)) 

tmapAccumR Source #

Arguments

:: forall (accy :: TK) (by :: TK) (ey :: TK) (k :: Nat) target. BaseTensor target 
=> Proxy target 
-> SNat k

length of the input

-> FullShapeTK accy

shape of the accumulator

-> FullShapeTK by

shape of the output

-> FullShapeTK ey

shape of an individual input

-> (forall (f :: Target). ADReady f => f accy -> f ey -> f ('TKProduct accy by))

the function to mapAccum with

-> target accy

the initial accumulator

-> target (BuildTensorKind k ey)

the inputs

-> target ('TKProduct accy (BuildTensorKind k by)) 

A strict right mapAccum.

tmapAccumL Source #

Arguments

:: forall (accy :: TK) (by :: TK) (ey :: TK) (k :: Nat) target. BaseTensor target 
=> Proxy target 
-> SNat k

length of the input

-> FullShapeTK accy

shape of the accumulator

-> FullShapeTK by

shape of the output

-> FullShapeTK ey

shape of an individual input

-> (forall (f :: Target). ADReady f => f accy -> f ey -> f ('TKProduct accy by))

the function to mapAccum with

-> target accy

the initial accumulator

-> target (BuildTensorKind k ey)

the inputs

-> target ('TKProduct accy (BuildTensorKind k by)) 

A strict left mapAccum.

Array operations producing derivatives

kgrad Source #

Arguments

:: forall (x :: TK) r target. BaseTensor target 
=> (forall (f :: Target). 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

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.

rvjp Source #

Arguments

:: forall (n :: Nat) (x :: TK) (r :: TK) target. BaseTensor target 
=> (forall (f :: Target). 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

rjvp Source #

Arguments

:: forall (n :: Nat) (x :: TK) (r :: TK) target. BaseTensor target 
=> (forall (f :: Target). 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

svjp Source #

Arguments

:: forall (sh :: [Nat]) (x :: TK) (r :: TK) target. BaseTensor target 
=> (forall (f :: Target). 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

sjvp Source #

Arguments

:: forall (sh :: [Nat]) (x :: TK) (r :: TK) target. BaseTensor target 
=> (forall (f :: Target). 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

Operations dealing with dual numbers

rprimalPart :: forall target (n :: Nat) (x :: TK). BaseTensor target => target ('TKR2 n x) -> PrimalOf target ('TKR2 n x) Source #

rdualPart :: forall target (n :: Nat) (x :: TK). (BaseTensor target, KnownNat n, KnownSTK x) => target ('TKR2 n x) -> DualOf target ('TKR2 n x) Source #

rfromPrimal :: forall target (n :: Nat) (x :: TK). (BaseTensor target, KnownNat n, KnownSTK x) => PrimalOf target ('TKR2 n x) -> target ('TKR2 n x) Source #

rfromDual :: forall target (n :: Nat) (x :: TK). BaseTensor target => DualOf target ('TKR2 n x) -> target ('TKR2 n x) Source #

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) Source #

sprimalPart :: forall target (sh :: [Nat]) (x :: TK). BaseTensor target => target ('TKS2 sh x) -> PrimalOf target ('TKS2 sh x) Source #

sdualPart :: forall target (sh :: [Nat]) (x :: TK). (BaseTensor target, KnownShS sh, KnownSTK x) => target ('TKS2 sh x) -> DualOf target ('TKS2 sh x) Source #

sfromPrimal :: forall target (sh :: [Nat]) (x :: TK). (BaseTensor target, KnownShS sh, KnownSTK x) => PrimalOf target ('TKS2 sh x) -> target ('TKS2 sh x) Source #

sfromDual :: forall target (sh :: [Nat]) (x :: TK). BaseTensor target => DualOf target ('TKS2 sh x) -> target ('TKS2 sh x) Source #

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) Source #

xprimalPart :: forall target (sh :: [Maybe Nat]) (x :: TK). BaseTensor target => target ('TKX2 sh x) -> PrimalOf target ('TKX2 sh x) Source #

xdualPart :: forall target (sh :: [Maybe Nat]) (x :: TK). (BaseTensor target, KnownShX sh, KnownSTK x) => target ('TKX2 sh x) -> DualOf target ('TKX2 sh x) Source #

xfromPrimal :: forall target (sh :: [Maybe Nat]) (x :: TK). (BaseTensor target, KnownShX sh, KnownSTK x) => PrimalOf target ('TKX2 sh x) -> target ('TKX2 sh x) Source #

xfromDual :: forall target (sh :: [Maybe Nat]) (x :: TK). BaseTensor target => DualOf target ('TKX2 sh x) -> target ('TKX2 sh x) Source #

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) Source #

kprimalPart :: BaseTensor target => target ('TKScalar r) -> PrimalOf target ('TKScalar r) Source #

kdualPart :: (BaseTensor target, GoodScalar r) => target ('TKScalar r) -> DualOf target ('TKScalar r) Source #

kfromPrimal :: (BaseTensor target, GoodScalar r) => PrimalOf target ('TKScalar r) -> target ('TKScalar r) Source #

kfromDual :: BaseTensor target => DualOf target ('TKScalar r) -> target ('TKScalar r) Source #

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) Source #

Array operations that utilize unwinding of nested arrays

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

Construct tensors with the given constant in each cell.

tdefTarget :: forall (y :: TK). BaseTensor target => FullShapeTK y -> target y Source #

Construct tensors with def in each cell.

taddTarget :: forall (y :: TK). BaseTensor target => SingletonTK y -> target y -> target y -> target y Source #

Add pointwise all corresponding tensors within nested product, if any.

Requires duplicable arguments or a ShareTensor instance.

tmultTarget :: forall (y :: TK). BaseTensor target => SingletonTK y -> target y -> target y -> target y Source #

Multiply pointwise all corresponding tensors within nested products, if any.

Requires duplicable arguments or a ShareTensor instance.

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

Sum all dimensions of each component and then sum it all. Ignore all tensors with non-differentiable elements.

Requires duplicable arguments or a ShareTensor instance.

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

Dot product each component and then sum it all. Ignore all tensors with non-differentiable elements.

Requires duplicable arguments or a ShareTensor instance.

Minimal re-exports to make this module a higher level replacement for HordeAd.Core.Ops

type ADReady (target :: Target) = (ADReadyNoLet target, LetTensor target) Source #

class LetTensor (target :: Target) Source #

Minimal complete definition

ttlet, ttletPrimal, toShare

Instances

Instances details
LetTensor Concrete Source # 
Instance details

Defined in HordeAd.Core.OpsConcrete

Methods

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

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

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

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

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

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

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

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

(ADReadyNoLet target, ShareTensor target, ShareTensor (PrimalOf target)) => LetTensor (ADVal target) Source # 
Instance details

Defined in HordeAd.Core.OpsADVal

Methods

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

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

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

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

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

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

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

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

AstSpan s => LetTensor (AstNoSimplify s) Source # 
Instance details

Defined in HordeAd.Core.OpsAst

Methods

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

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

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

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

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

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

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

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

AstSpan s => LetTensor (AstNoVectorize s) Source # 
Instance details

Defined in HordeAd.Core.OpsAst

Methods

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

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

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

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

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

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

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

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

AstSpan s => LetTensor (AstTensor 'AstMethodLet s) Source # 
Instance details

Defined in HordeAd.Core.OpsAst

Methods

ttlet :: forall (x :: TK) (z :: TK). AstTensor 'AstMethodLet s x -> (AstTensor 'AstMethodLet s x -> AstTensor 'AstMethodLet s z) -> AstTensor 'AstMethodLet s z Source #

ttletPrimal :: forall (x :: TK) (z :: TK). PrimalOf (AstTensor 'AstMethodLet s) x -> (PrimalOf (AstTensor 'AstMethodLet s) x -> AstTensor 'AstMethodLet s z) -> AstTensor 'AstMethodLet s z Source #

toShare :: forall (y :: TK). AstTensor 'AstMethodLet s y -> ShareOf (AstTensor 'AstMethodLet s) y Source #

tunshare :: forall (y :: TK). ShareOf (AstTensor 'AstMethodLet s) y -> AstTensor 'AstMethodLet s y Source #

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

tD :: forall (y :: TK). BaseTensor (AstTensor 'AstMethodLet s) => SingletonTK y -> PrimalOf (AstTensor 'AstMethodLet s) y -> DualOf (AstTensor 'AstMethodLet s) y -> AstTensor 'AstMethodLet s y Source #

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

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

class (Num (IntOf target), IntegralH (IntOf target), TensorSupports Num Num target, TensorSupports RealFloatAndFloatElt Floating target, TensorSupports RealFloatAndFloatElt RealFloatH target, TensorSupports IntegralHAndIntElt IntegralH target, TensorSupportsR Num Num target, TensorSupportsR RealFloatAndFloatElt Floating target, TensorSupportsR RealFloatAndFloatElt RealFloatH target, TensorSupportsR IntegralHAndIntElt IntegralH target, TensorSupportsS Num Num target, TensorSupportsS RealFloatAndFloatElt Floating target, TensorSupportsS RealFloatAndFloatElt RealFloatH target, TensorSupportsS IntegralHAndIntElt IntegralH target, TensorSupportsX Num Num target, TensorSupportsX RealFloatAndFloatElt Floating target, TensorSupportsX RealFloatAndFloatElt RealFloatH target, TensorSupportsX IntegralHAndIntElt IntegralH target) => BaseTensor (target :: Target) Source #

The superclasses indicate that it's not only a container array, but also a mathematical tensor, sporting numeric operations.

Minimal complete definition

rshape, sshape, xshape, tftk, tpair, tproject1, tproject2, tcond, trconcrete, tsconcrete, txconcrete, tkconcrete, tconcrete, tfromVector, trsum, trreplicate, tssum, tsreplicate, txsum, txreplicate, trindex, trscatter, trgather, tsindex, tsscatter, tsgather, txindex, txscatter, txgather, trfloor, trfromIntegral, trcast, trminIndex, trmaxIndex, triota, tsfloor, tsfromIntegral, tscast, tsminIndex, tsmaxIndex, tsiota, txfloor, txfromIntegral, txcast, txminIndex, txmaxIndex, txiota, tkfloor, tkfromIntegral, tkcast, trappend, trslice, trreverse, trtranspose, trreshape, tsappend, tsslice, tsreverse, tstranspose, tsreshape, txappend, txslice, txreverse, txtranspose, txreshape, trbuild1, tsbuild1, txbuild1, tmapAccumRDer, tmapAccumLDer, tApply, tlambda, tgrad, tvjp, tjvp, tprimalPart, tdualPart, tfromPrimal, tfromDual, treplTarget, tdefTarget, taddTarget, tmultTarget, tsum0Target, tdot0Target

Instances

Instances details
BaseTensor Concrete Source # 
Instance details

Defined in HordeAd.Core.OpsConcrete

Methods

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

(ADReadyNoLet target, ShareTensor target, ShareTensor (PrimalOf target)) => BaseTensor (ADVal target) Source # 
Instance details

Defined in HordeAd.Core.OpsADVal

Methods

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

AstSpan s => BaseTensor (AstNoSimplify s) Source # 
Instance details

Defined in HordeAd.Core.OpsAst

Methods

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

AstSpan s => BaseTensor (AstNoVectorize s) Source # 
Instance details

Defined in HordeAd.Core.OpsAst

Methods

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

AstSpan s => BaseTensor (AstRaw s) Source # 
Instance details

Defined in HordeAd.Core.OpsAst

Methods

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

tgrad :: forall (x :: TK) r. FullShapeTK x -> HFun x ('TKScalar r) -> HFunOf (AstRaw s) x (ADTensorKind x) Source #

tvjp :: forall (x :: TK) (z :: TK). FullShapeTK x -> HFun x z -> HFunOf (AstRaw s) ('TKProduct (ADTensorKind z) x) (ADTensorKind x) Source #

tjvp :: forall (x :: TK) (z :: TK). FullShapeTK x -> HFun x z -> HFunOf (AstRaw s) ('TKProduct (ADTensorKind x) x) (ADTensorKind z) Source #

tprimalPart :: forall (y :: TK). AstRaw s y -> PrimalOf (AstRaw s) y Source #

tdualPart :: forall (y :: TK). SingletonTK y -> AstRaw s y -> DualOf (AstRaw s) y Source #

tfromPrimal :: forall (y :: TK). SingletonTK y -> PrimalOf (AstRaw s) y -> AstRaw s y Source #

tfromDual :: forall (y :: TK). DualOf (AstRaw s) y -> AstRaw s y Source #

tScale :: forall (y :: TK). (Num (AstRaw s y), Num (PrimalOf (AstRaw s) y)) => SingletonTK y -> PrimalOf (AstRaw s) y -> DualOf (AstRaw s) y -> DualOf (AstRaw s) y Source #

tsum :: forall (z :: TK) (k :: Nat). ConvertTensor (AstRaw s) => SNat k -> SingletonTK z -> AstRaw s (BuildTensorKind k z) -> AstRaw s z Source #

treplicate :: forall (z :: TK) (k :: Nat). ConvertTensor (AstRaw s) => SNat k -> SingletonTK z -> AstRaw s z -> AstRaw s (BuildTensorKind k z) Source #

tindexBuild :: forall (z :: TK) (k :: Nat). ConvertTensor (AstRaw s) => SNat k -> SingletonTK z -> AstRaw s (BuildTensorKind k z) -> IntOf (AstRaw s) -> AstRaw s z Source #

treplTarget :: forall (y :: TK). (forall r. GoodScalar r => r) -> FullShapeTK y -> AstRaw s y Source #

tdefTarget :: forall (y :: TK). FullShapeTK y -> AstRaw s y Source #

taddTarget :: forall (y :: TK). SingletonTK y -> AstRaw s y -> AstRaw s y -> AstRaw s y Source #

tmultTarget :: forall (y :: TK). SingletonTK y -> AstRaw s y -> AstRaw s y -> AstRaw s y Source #

tsum0Target :: forall (y :: TK). FullShapeTK y -> AstRaw s y -> AstRaw s ('TKScalar Double) Source #

tdot0Target :: forall (y :: TK). FullShapeTK y -> AstRaw s y -> AstRaw s y -> AstRaw s ('TKScalar Double) Source #

xmcast :: forall (x :: TK) (sh :: [Maybe Nat]) (sh2 :: [Maybe Nat]). (KnownSTK x, KnownShX sh, Rank sh ~ Rank sh2, ConvertTensor (AstRaw s)) => StaticShX sh2 -> AstRaw s ('TKX2 sh x) -> AstRaw s ('TKX2 sh2 x) Source #

AstSpan s => BaseTensor (AstTensor 'AstMethodLet s) Source #

The checks and error messages in these functions result in complete shape-checking of the ranked and mixed user code (shaped is already fully checked by the Haskell type system).

Instance details

Defined in HordeAd.Core.OpsAst

Methods

rshape :: forall (n :: Nat) (x :: TK). KnownSTK x => AstTensor 'AstMethodLet s ('TKR2 n x) -> IShR n Source #

rlength :: forall (n :: Nat) (x :: TK). KnownSTK x => AstTensor 'AstMethodLet s ('TKR2 n x) -> Int Source #

rsize :: forall (n :: Nat) (x :: TK). KnownSTK x => AstTensor 'AstMethodLet s ('TKR2 n x) -> Int Source #

rwidth :: forall (n :: Natural) (x :: TK). KnownSTK x => AstTensor 'AstMethodLet s ('TKR2 (1 + n) x) -> Int Source #

sshape :: forall (sh :: [Nat]) (x :: TK). KnownSTK x => AstTensor 'AstMethodLet s ('TKS2 sh x) -> ShS sh Source #

slength :: forall (sh :: [Nat]) (x :: TK). KnownSTK x => AstTensor 'AstMethodLet s ('TKS2 sh x) -> Int Source #

ssize :: forall (sh :: [Nat]) (x :: TK). KnownSTK x => AstTensor 'AstMethodLet s ('TKS2 sh x) -> Int Source #

swidth :: forall (n :: Nat) (sh :: [Nat]) (x :: TK). KnownSTK x => AstTensor 'AstMethodLet s ('TKS2 (n ': sh) x) -> Int Source #

xshape :: forall (sh :: [Maybe Nat]) (x :: TK). KnownSTK x => AstTensor 'AstMethodLet s ('TKX2 sh x) -> IShX sh Source #

xlength :: forall (sh :: [Maybe Nat]) (x :: TK). KnownSTK x => AstTensor 'AstMethodLet s ('TKX2 sh x) -> Int Source #

xsize :: forall (sh :: [Maybe Nat]) (x :: TK). KnownSTK x => AstTensor 'AstMethodLet s ('TKX2 sh x) -> Int Source #

xwidth :: forall (mn :: Maybe Nat) (sh :: [Maybe Nat]) (x :: TK). KnownSTK x => AstTensor 'AstMethodLet s ('TKX2 (mn ': sh) x) -> Int Source #

tsize :: forall (y :: TK). SingletonTK y -> AstTensor 'AstMethodLet s y -> Int Source #

tftk :: forall (y :: TK). SingletonTK y -> AstTensor 'AstMethodLet s y -> FullShapeTK y Source #

tpair :: forall (x :: TK) (z :: TK). AstTensor 'AstMethodLet s x -> AstTensor 'AstMethodLet s z -> AstTensor 'AstMethodLet s ('TKProduct x z) Source #

tproject1 :: forall (x :: TK) (z :: TK). AstTensor 'AstMethodLet s ('TKProduct x z) -> AstTensor 'AstMethodLet s x Source #

tproject2 :: forall (x :: TK) (z :: TK). AstTensor 'AstMethodLet s ('TKProduct x z) -> AstTensor 'AstMethodLet s z Source #

tcond :: forall (y :: TK). Boolean (BoolOf (AstTensor 'AstMethodLet s)) => SingletonTK y -> BoolOf (AstTensor 'AstMethodLet s) -> AstTensor 'AstMethodLet s y -> AstTensor 'AstMethodLet s y -> AstTensor 'AstMethodLet s y Source #

trconcrete :: forall r (n :: Nat). GoodScalar r => Ranked n r -> AstTensor 'AstMethodLet s (TKR n r) Source #

tsconcrete :: forall r (sh :: [Nat]). GoodScalar r => Shaped sh r -> AstTensor 'AstMethodLet s (TKS sh r) Source #

txconcrete :: forall r (sh :: [Maybe Nat]). GoodScalar r => Mixed sh r -> AstTensor 'AstMethodLet s (TKX sh r) Source #

tkconcrete :: GoodScalar r => r -> AstTensor 'AstMethodLet s ('TKScalar r) Source #

tconcrete :: forall (y :: TK). FullShapeTK y -> Concrete y -> AstTensor 'AstMethodLet s y Source #

trfromVector :: forall (n :: Nat) (x :: TK). (KnownNat n, KnownSTK x) => Vector (AstTensor 'AstMethodLet s ('TKR2 n x)) -> AstTensor 'AstMethodLet s ('TKR2 (1 + n) x) Source #

trfromVector0N :: forall (n :: Nat) (x :: TK). KnownSTK x => IShR n -> Vector (AstTensor 'AstMethodLet s ('TKR2 0 x)) -> AstTensor 'AstMethodLet s ('TKR2 n x) Source #

trunravelToList :: forall (n :: Nat) (x :: TK). (KnownNat n, KnownSTK x) => AstTensor 'AstMethodLet s ('TKR2 (1 + n) x) -> [AstTensor 'AstMethodLet s ('TKR2 n x)] Source #

tsfromVector :: forall (n :: Nat) (sh :: [Nat]) (x :: TK). (KnownNat n, KnownShS sh, KnownSTK x) => Vector (AstTensor 'AstMethodLet s ('TKS2 sh x)) -> AstTensor 'AstMethodLet s ('TKS2 (n ': sh) x) Source #

tsfromVector0N :: forall (sh :: [Nat]) (x :: TK). (KnownShS sh, KnownSTK x) => Vector (AstTensor 'AstMethodLet s ('TKS2 ('[] :: [Nat]) x)) -> AstTensor 'AstMethodLet s ('TKS2 sh x) Source #

tsunravelToList :: forall (n :: Nat) (sh :: [Nat]) (x :: TK). (KnownNat n, KnownShS sh, KnownSTK x) => AstTensor 'AstMethodLet s ('TKS2 (n ': sh) x) -> [AstTensor 'AstMethodLet s ('TKS2 sh x)] Source #

txfromVector :: forall (n :: Nat) (sh :: [Maybe Nat]) (x :: TK). (KnownNat n, KnownShX sh, KnownSTK x) => Vector (AstTensor 'AstMethodLet s ('TKX2 sh x)) -> AstTensor 'AstMethodLet s ('TKX2 ('Just n ': sh) x) Source #

txfromVector0N :: forall (sh :: [Maybe Nat]) (x :: TK). KnownSTK x => IShX sh -> Vector (AstTensor 'AstMethodLet s ('TKX2 ('[] :: [Maybe Nat]) x)) -> AstTensor 'AstMethodLet s ('TKX2 sh x) Source #

txunravelToList :: forall (n :: Nat) (sh :: [Maybe Nat]) (x :: TK). (KnownNat n, KnownShX sh, KnownSTK x) => AstTensor 'AstMethodLet s ('TKX2 ('Just n ': sh) x) -> [AstTensor 'AstMethodLet s ('TKX2 sh x)] Source #

tfromVector :: forall (y :: TK) (k :: Nat). SNat k -> SingletonTK y -> Vector (AstTensor 'AstMethodLet s y) -> AstTensor 'AstMethodLet s (BuildTensorKind k y) Source #

tfromListR :: forall (y :: TK) (k :: Nat). SingletonTK y -> ListR k (AstTensor 'AstMethodLet s y) -> AstTensor 'AstMethodLet s (BuildTensorKind k y) Source #

trsum :: forall (n :: Nat) (x :: TK). (KnownNat n, KnownSTK x) => AstTensor 'AstMethodLet s ('TKR2 (1 + n) x) -> AstTensor 'AstMethodLet s ('TKR2 n x) Source #

trsum0 :: forall (n :: Nat) (x :: TK). (KnownNat n, KnownSTK x) => AstTensor 'AstMethodLet s ('TKR2 n x) -> AstTensor 'AstMethodLet s ('TKR2 0 x) Source #

trdot0 :: forall (n :: Nat) r. (KnownNat n, GoodScalar r) => AstTensor 'AstMethodLet s (TKR n r) -> AstTensor 'AstMethodLet s (TKR n r) -> AstTensor 'AstMethodLet s (TKR 0 r) Source #

trdot1In :: forall (n :: Nat) r. (KnownNat n, GoodScalar r) => AstTensor 'AstMethodLet s (TKR (1 + n) r) -> AstTensor 'AstMethodLet s (TKR (1 + n) r) -> AstTensor 'AstMethodLet s (TKR n r) Source #

trmatvecmul :: GoodScalar r => AstTensor 'AstMethodLet s (TKR 2 r) -> AstTensor 'AstMethodLet s (TKR 1 r) -> AstTensor 'AstMethodLet s (TKR 1 r) Source #

trmatmul2 :: GoodScalar r => AstTensor 'AstMethodLet s (TKR 2 r) -> AstTensor 'AstMethodLet s (TKR 2 r) -> AstTensor 'AstMethodLet s (TKR 2 r) Source #

trreplicate :: forall (n :: Nat) (x :: TK). (KnownNat n, KnownSTK x) => Int -> AstTensor 'AstMethodLet s ('TKR2 n x) -> AstTensor 'AstMethodLet s ('TKR2 (1 + n) x) Source #

trreplicate0N :: forall (n :: Nat) (x :: TK). (KnownNat n, KnownSTK x) => IShR n -> AstTensor 'AstMethodLet s ('TKR2 0 x) -> AstTensor 'AstMethodLet s ('TKR2 n x) Source #

tssum :: forall (n :: Nat) (sh :: [Nat]) (x :: TK). (KnownNat n, KnownShS sh, KnownSTK x) => AstTensor 'AstMethodLet s ('TKS2 (n ': sh) x) -> AstTensor 'AstMethodLet s ('TKS2 sh x) Source #

tssum0 :: forall (sh :: [Nat]) (x :: TK). (KnownShS sh, KnownSTK x) => AstTensor 'AstMethodLet s ('TKS2 sh x) -> AstTensor 'AstMethodLet s ('TKS2 ('[] :: [Nat]) x) Source #

tsdot0 :: forall (sh :: [Nat]) r. (KnownShS sh, GoodScalar r) => AstTensor 'AstMethodLet s (TKS sh r) -> AstTensor 'AstMethodLet s (TKS sh r) -> AstTensor 'AstMethodLet s (TKS ('[] :: [Nat]) r) Source #

tsdot1In :: forall (sh :: [Nat]) r (n :: Nat). (KnownShS sh, GoodScalar r) => SNat n -> AstTensor 'AstMethodLet s (TKS (sh ++ '[n]) r) -> AstTensor 'AstMethodLet s (TKS (sh ++ '[n]) r) -> AstTensor 'AstMethodLet s (TKS sh r) Source #

tsmatvecmul :: forall (m :: Nat) (n :: Nat) r. (KnownNat m, KnownNat n, GoodScalar r) => AstTensor 'AstMethodLet s (TKS '[m, n] r) -> AstTensor 'AstMethodLet s (TKS '[n] r) -> AstTensor 'AstMethodLet s (TKS '[m] r) Source #

tsmatmul2 :: forall (m :: Nat) (n :: Nat) (p :: Nat) r. (KnownNat m, KnownNat n, KnownNat p, GoodScalar r) => AstTensor 'AstMethodLet s (TKS '[m, n] r) -> AstTensor 'AstMethodLet s (TKS '[n, p] r) -> AstTensor 'AstMethodLet s (TKS '[m, p] r) Source #

tsreplicate :: forall (sh :: [Nat]) (k :: Nat) (x :: TK). KnownSTK x => SNat k -> ShS sh -> AstTensor 'AstMethodLet s ('TKS2 sh x) -> AstTensor 'AstMethodLet s ('TKS2 (k ': sh) x) Source #

tsreplicate0N :: forall (sh :: [Nat]) (x :: TK). KnownSTK x => ShS sh -> AstTensor 'AstMethodLet s ('TKS2 ('[] :: [Nat]) x) -> AstTensor 'AstMethodLet s ('TKS2 sh x) Source #

txsum :: forall (n :: Nat) (sh :: [Maybe Nat]) (x :: TK). (KnownNat n, KnownShX sh, KnownSTK x) => AstTensor 'AstMethodLet s ('TKX2 ('Just n ': sh) x) -> AstTensor 'AstMethodLet s ('TKX2 sh x) Source #

txsum0 :: forall (sh :: [Maybe Nat]) (x :: TK). (KnownShX sh, KnownSTK x, ConvertTensor (AstTensor 'AstMethodLet s)) => AstTensor 'AstMethodLet s ('TKX2 sh x) -> AstTensor 'AstMethodLet s ('TKX2 ('[] :: [Maybe Nat]) x) Source #

txdot0 :: forall (sh :: [Maybe Nat]) r. (KnownShX sh, GoodScalar r, ConvertTensor (AstTensor 'AstMethodLet s)) => AstTensor 'AstMethodLet s (TKX sh r) -> AstTensor 'AstMethodLet s (TKX sh r) -> AstTensor 'AstMethodLet s (TKX ('[] :: [Maybe Nat]) r) Source #

txdot1In :: forall (sh :: [Maybe Nat]) r (n :: Nat). (KnownShX sh, GoodScalar r) => SNat n -> AstTensor 'AstMethodLet s (TKX (sh ++ '['Just n]) r) -> AstTensor 'AstMethodLet s (TKX (sh ++ '['Just n]) r) -> AstTensor 'AstMethodLet s (TKX sh r) Source #

txmatvecmul :: forall (mm :: Maybe Nat) (mn :: Maybe Nat) r. (GoodScalar r, ConvertTensor (AstTensor 'AstMethodLet s)) => SMayNat Int SNat mm -> SMayNat Int SNat mn -> AstTensor 'AstMethodLet s (TKX '[mm, mn] r) -> AstTensor 'AstMethodLet s (TKX '[mn] r) -> AstTensor 'AstMethodLet s (TKX '[mm] r) Source #

txmatmul2 :: forall (m :: Nat) (n :: Nat) (p :: Nat) r. (KnownNat m, KnownNat n, KnownNat p, GoodScalar r, ConvertTensor (AstTensor 'AstMethodLet s)) => AstTensor 'AstMethodLet s (TKX '['Just m, 'Just n] r) -> AstTensor 'AstMethodLet s (TKX '['Just n, 'Just p] r) -> AstTensor 'AstMethodLet s (TKX '['Just m, 'Just p] r) Source #

txreplicate :: forall (sh :: [Maybe Nat]) (k :: Nat) (x :: TK). KnownSTK x => SNat k -> StaticShX sh -> AstTensor 'AstMethodLet s ('TKX2 sh x) -> AstTensor 'AstMethodLet s ('TKX2 ('Just k ': sh) x) Source #

txreplicate0N :: forall (sh :: [Maybe Nat]) (x :: TK). (KnownShX sh, KnownSTK x) => IShX sh -> AstTensor 'AstMethodLet s ('TKX2 ('[] :: [Maybe Nat]) x) -> AstTensor 'AstMethodLet s ('TKX2 sh x) Source #

trindex :: forall (m :: Nat) (n :: Nat) (x :: TK). (KnownNat m, KnownNat n, KnownSTK x) => AstTensor 'AstMethodLet s ('TKR2 (m + n) x) -> IxROf (AstTensor 'AstMethodLet s) m -> AstTensor 'AstMethodLet s ('TKR2 n x) Source #

trindex0 :: forall (m :: Nat) (x :: TK). (KnownNat m, KnownSTK x) => AstTensor 'AstMethodLet s ('TKR2 m x) -> IxROf (AstTensor 'AstMethodLet s) m -> AstTensor 'AstMethodLet s ('TKR2 0 x) Source #

troneHot :: forall (m :: Nat) (n :: Nat) (x :: TK). (KnownNat m, KnownNat n, KnownSTK x, BoolOf (PrimalOf (AstTensor 'AstMethodLet s)) ~ BoolOf (AstTensor 'AstMethodLet s), EqH (PrimalOf (AstTensor 'AstMethodLet s)) ('TKScalar Int64)) => IShR m -> AstTensor 'AstMethodLet s ('TKR2 n x) -> IxROf (AstTensor 'AstMethodLet s) m -> AstTensor 'AstMethodLet s ('TKR2 (m + n) x) Source #

trscatter :: forall (m :: Nat) (n :: Nat) (p :: Nat) (x :: TK). (KnownNat m, KnownNat n, KnownNat p, KnownSTK x) => IShR (p + n) -> AstTensor 'AstMethodLet s ('TKR2 (m + n) x) -> (IxROf (AstTensor 'AstMethodLet s) m -> IxROf (AstTensor 'AstMethodLet s) p) -> AstTensor 'AstMethodLet s ('TKR2 (p + n) x) Source #

trscatter1 :: forall (n :: Nat) (p :: Nat) (x :: TK). (KnownNat n, KnownNat p, KnownSTK x) => IShR (p + n) -> AstTensor 'AstMethodLet s ('TKR2 (1 + n) x) -> (IntOf (AstTensor 'AstMethodLet s) -> IxROf (AstTensor 'AstMethodLet s) p) -> AstTensor 'AstMethodLet s ('TKR2 (p + n) x) Source #

trgather :: forall (m :: Nat) (n :: Nat) (p :: Nat) (x :: TK). (KnownNat m, KnownNat n, KnownNat p, KnownSTK x) => IShR (m + n) -> AstTensor 'AstMethodLet s ('TKR2 (p + n) x) -> (IxROf (AstTensor 'AstMethodLet s) m -> IxROf (AstTensor 'AstMethodLet s) p) -> AstTensor 'AstMethodLet s ('TKR2 (m + n) x) Source #

trgather1 :: forall (n :: Nat) (p :: Nat) (x :: TK). (KnownNat n, KnownNat p, KnownSTK x) => Int -> AstTensor 'AstMethodLet s ('TKR2 (p + n) x) -> (IntOf (AstTensor 'AstMethodLet s) -> IxROf (AstTensor 'AstMethodLet s) p) -> AstTensor 'AstMethodLet s ('TKR2 (1 + n) x) Source #

tsindex :: forall (shm :: [Nat]) (shn :: [Nat]) (x :: TK). (KnownShS shm, KnownShS shn, KnownSTK x) => AstTensor 'AstMethodLet s ('TKS2 (shm ++ shn) x) -> IxSOf (AstTensor 'AstMethodLet s) shm -> AstTensor 'AstMethodLet s ('TKS2 shn x) Source #

tsindex0 :: forall (sh1 :: [Nat]) (x :: TK). (KnownShS sh1, KnownSTK x) => AstTensor 'AstMethodLet s ('TKS2 sh1 x) -> IxSOf (AstTensor 'AstMethodLet s) sh1 -> AstTensor 'AstMethodLet s ('TKS2 ('[] :: [Nat]) x) Source #

tsoneHot :: forall (sh1 :: [Nat]) (sh2 :: [Nat]) (x :: TK). (KnownShS sh1, KnownShS sh2, KnownSTK x, BoolOf (PrimalOf (AstTensor 'AstMethodLet s)) ~ BoolOf (AstTensor 'AstMethodLet s), EqH (PrimalOf (AstTensor 'AstMethodLet s)) ('TKScalar Int64)) => AstTensor 'AstMethodLet s ('TKS2 sh2 x) -> IxSOf (AstTensor 'AstMethodLet s) sh1 -> AstTensor 'AstMethodLet s ('TKS2 (sh1 ++ sh2) x) Source #

tsscatter :: forall (shm :: [Nat]) (shn :: [Nat]) (shp :: [Nat]) (x :: TK). (KnownShS shm, KnownShS shn, KnownShS shp, KnownSTK x) => AstTensor 'AstMethodLet s ('TKS2 (shm ++ shn) x) -> (IxSOf (AstTensor 'AstMethodLet s) shm -> IxSOf (AstTensor 'AstMethodLet s) shp) -> AstTensor 'AstMethodLet s ('TKS2 (shp ++ shn) x) Source #

tsscatter1 :: forall (n2 :: Nat) (shn :: [Nat]) (shp :: [Nat]) (x :: TK). (KnownNat n2, KnownShS shn, KnownShS shp, KnownSTK x) => AstTensor 'AstMethodLet s ('TKS2 (n2 ': shn) x) -> (IntOf (AstTensor 'AstMethodLet s) -> IxSOf (AstTensor 'AstMethodLet s) shp) -> AstTensor 'AstMethodLet s ('TKS2 (shp ++ shn) x) Source #

tsgather :: forall (shm :: [Nat]) (shn :: [Nat]) (shp :: [Nat]) (x :: TK). (KnownShS shm, KnownShS shn, KnownShS shp, KnownSTK x) => AstTensor 'AstMethodLet s ('TKS2 (shp ++ shn) x) -> (IxSOf (AstTensor 'AstMethodLet s) shm -> IxSOf (AstTensor 'AstMethodLet s) shp) -> AstTensor 'AstMethodLet s ('TKS2 (shm ++ shn) x) Source #

tsgather1 :: forall (n2 :: Nat) (shn :: [Nat]) (shp :: [Nat]) (x :: TK). (KnownNat n2, KnownShS shn, KnownShS shp, KnownSTK x) => AstTensor 'AstMethodLet s ('TKS2 (shp ++ shn) x) -> (IntOf (AstTensor 'AstMethodLet s) -> IxSOf (AstTensor 'AstMethodLet s) shp) -> AstTensor 'AstMethodLet s ('TKS2 (n2 ': shn) x) Source #

txindex :: forall (sh1 :: [Maybe Nat]) (sh2 :: [Maybe Nat]) (x :: TK). (KnownShX sh1, KnownShX sh2, KnownSTK x) => AstTensor 'AstMethodLet s ('TKX2 (sh1 ++ sh2) x) -> IxXOf (AstTensor 'AstMethodLet s) sh1 -> AstTensor 'AstMethodLet s ('TKX2 sh2 x) Source #

txindex0 :: forall (sh1 :: [Maybe Nat]) (x :: TK). (KnownShX sh1, KnownSTK x) => AstTensor 'AstMethodLet s ('TKX2 sh1 x) -> IxXOf (AstTensor 'AstMethodLet s) sh1 -> AstTensor 'AstMethodLet s ('TKX2 ('[] :: [Maybe Nat]) x) Source #

txoneHot :: forall (sh1 :: [Maybe Nat]) (sh2 :: [Maybe Nat]) (x :: TK). (KnownShX sh1, KnownShX sh2, KnownSTK x, BoolOf (PrimalOf (AstTensor 'AstMethodLet s)) ~ BoolOf (AstTensor 'AstMethodLet s), EqH (PrimalOf (AstTensor 'AstMethodLet s)) ('TKScalar Int64), ConvertTensor (AstTensor 'AstMethodLet s)) => IShX sh1 -> AstTensor 'AstMethodLet s ('TKX2 sh2 x) -> IxXOf (AstTensor 'AstMethodLet s) sh1 -> AstTensor 'AstMethodLet s ('TKX2 (sh1 ++ sh2) x) Source #

txscatter :: forall (shm :: [Maybe Nat]) (shn :: [Maybe Nat]) (shp :: [Maybe Nat]) (x :: TK). (KnownShX shm, KnownShX shn, KnownShX shp, KnownSTK x) => IShX (shp ++ shn) -> AstTensor 'AstMethodLet s ('TKX2 (shm ++ shn) x) -> (IxXOf (AstTensor 'AstMethodLet s) shm -> IxXOf (AstTensor 'AstMethodLet s) shp) -> AstTensor 'AstMethodLet s ('TKX2 (shp ++ shn) x) Source #

txscatter1 :: forall (n2 :: Nat) (shn :: [Maybe Nat]) (shp :: [Maybe Nat]) (x :: TK). (KnownNat n2, KnownShX shn, KnownShX shp, KnownSTK x) => IShX (shp ++ shn) -> AstTensor 'AstMethodLet s ('TKX2 ('Just n2 ': shn) x) -> (IntOf (AstTensor 'AstMethodLet s) -> IxXOf (AstTensor 'AstMethodLet s) shp) -> AstTensor 'AstMethodLet s ('TKX2 (shp ++ shn) x) Source #

txgather :: forall (shm :: [Maybe Nat]) (shn :: [Maybe Nat]) (shp :: [Maybe Nat]) (x :: TK). (KnownShX shm, KnownShX shn, KnownShX shp, KnownSTK x) => IShX (shm ++ shn) -> AstTensor 'AstMethodLet s ('TKX2 (shp ++ shn) x) -> (IxXOf (AstTensor 'AstMethodLet s) shm -> IxXOf (AstTensor 'AstMethodLet s) shp) -> AstTensor 'AstMethodLet s ('TKX2 (shm ++ shn) x) Source #

txgather1 :: forall (n2 :: Nat) (shn :: [Maybe Nat]) (shp :: [Maybe Nat]) (x :: TK). (KnownNat n2, KnownShX shn, KnownShX shp, KnownSTK x) => SNat n2 -> AstTensor 'AstMethodLet s ('TKX2 (shp ++ shn) x) -> (IntOf (AstTensor 'AstMethodLet s) -> IxXOf (AstTensor 'AstMethodLet s) shp) -> AstTensor 'AstMethodLet s ('TKX2 ('Just n2 ': shn) x) Source #

trfloor :: forall r r2 (n :: Nat). (GoodScalar r, RealFrac r, GoodScalar r2, Integral r2) => AstTensor 'AstMethodLet s (TKR n r) -> AstTensor 'AstMethodLet s (TKR n r2) Source #

trfromIntegral :: forall r1 r2 (n :: Nat). (GoodScalar r1, Integral r1, GoodScalar r2) => AstTensor 'AstMethodLet s (TKR n r1) -> AstTensor 'AstMethodLet s (TKR n r2) Source #

trcast :: forall r1 r2 (n :: Nat). (RealFrac r1, GoodScalar r1, RealFrac r2, GoodScalar r2) => AstTensor 'AstMethodLet s (TKR n r1) -> AstTensor 'AstMethodLet s (TKR n r2) Source #

trminIndex :: forall (n :: Natural) r r2. (GoodScalar r, GoodScalar r2) => AstTensor 'AstMethodLet s (TKR (1 + n) r) -> AstTensor 'AstMethodLet s (TKR n r2) Source #

trmaxIndex :: forall (n :: Natural) r r2. (GoodScalar r, GoodScalar r2) => AstTensor 'AstMethodLet s (TKR (1 + n) r) -> AstTensor 'AstMethodLet s (TKR n r2) Source #

triota :: GoodScalar r => Int -> AstTensor 'AstMethodLet s (TKR 1 r) Source #

tsfloor :: forall r r2 (sh :: [Nat]). (GoodScalar r, RealFrac r, GoodScalar r2, Integral r2) => AstTensor 'AstMethodLet s (TKS sh r) -> AstTensor 'AstMethodLet s (TKS sh r2) Source #

tsfromIntegral :: forall r1 r2 (sh :: [Nat]). (GoodScalar r1, Integral r1, GoodScalar r2) => AstTensor 'AstMethodLet s (TKS sh r1) -> AstTensor 'AstMethodLet s (TKS sh r2) Source #

tscast :: forall r1 r2 (sh :: [Nat]). (RealFrac r1, GoodScalar r1, RealFrac r2, GoodScalar r2) => AstTensor 'AstMethodLet s (TKS sh r1) -> AstTensor 'AstMethodLet s (TKS sh r2) Source #

tsminIndex :: forall (n :: Nat) (sh :: [Nat]) r r2. (GoodScalar r, GoodScalar r2) => AstTensor 'AstMethodLet s (TKS (n ': sh) r) -> AstTensor 'AstMethodLet s (TKS (Init (n ': sh)) r2) Source #

tsmaxIndex :: forall (n :: Nat) (sh :: [Nat]) r r2. (GoodScalar r, GoodScalar r2) => AstTensor 'AstMethodLet s (TKS (n ': sh) r) -> AstTensor 'AstMethodLet s (TKS (Init (n ': sh)) r2) Source #

tsiota :: forall (n :: Nat) r. (KnownNat n, GoodScalar r) => AstTensor 'AstMethodLet s (TKS '[n] r) Source #

txfloor :: forall r r2 (sh :: [Maybe Nat]). (GoodScalar r, RealFrac r, GoodScalar r2, Integral r2) => AstTensor 'AstMethodLet s (TKX sh r) -> AstTensor 'AstMethodLet s (TKX sh r2) Source #

txfromIntegral :: forall r1 r2 (sh :: [Maybe Nat]). (GoodScalar r1, Integral r1, GoodScalar r2) => AstTensor 'AstMethodLet s (TKX sh r1) -> AstTensor 'AstMethodLet s (TKX sh r2) Source #

txcast :: forall r1 r2 (sh :: [Maybe Nat]). (RealFrac r1, GoodScalar r1, RealFrac r2, GoodScalar r2) => AstTensor 'AstMethodLet s (TKX sh r1) -> AstTensor 'AstMethodLet s (TKX sh r2) Source #

txminIndex :: forall (mn :: Maybe Nat) (sh :: [Maybe Nat]) r r2. (GoodScalar r, GoodScalar r2) => AstTensor 'AstMethodLet s (TKX (mn ': sh) r) -> AstTensor 'AstMethodLet s (TKX (Init (mn ': sh)) r2) Source #

txmaxIndex :: forall (mn :: Maybe Nat) (sh :: [Maybe Nat]) r r2. (GoodScalar r, GoodScalar r2) => AstTensor 'AstMethodLet s (TKX (mn ': sh) r) -> AstTensor 'AstMethodLet s (TKX (Init (mn ': sh)) r2) Source #

txiota :: forall (n :: Nat) r. (KnownNat n, GoodScalar r) => AstTensor 'AstMethodLet s (TKX '['Just n] r) Source #

tkfloor :: (GoodScalar r, RealFrac r, GoodScalar r2, Integral r2) => AstTensor 'AstMethodLet s ('TKScalar r) -> AstTensor 'AstMethodLet s ('TKScalar r2) Source #

tkfromIntegral :: (GoodScalar r1, Integral r1, GoodScalar r2) => AstTensor 'AstMethodLet s ('TKScalar r1) -> AstTensor 'AstMethodLet s ('TKScalar r2) Source #

tkcast :: (RealFrac r1, GoodScalar r1, RealFrac r2, GoodScalar r2) => AstTensor 'AstMethodLet s ('TKScalar r1) -> AstTensor 'AstMethodLet s ('TKScalar r2) Source #

trappend :: forall (n :: Natural) (x :: TK). KnownSTK x => AstTensor 'AstMethodLet s ('TKR2 (1 + n) x) -> AstTensor 'AstMethodLet s ('TKR2 (1 + n) x) -> AstTensor 'AstMethodLet s ('TKR2 (1 + n) x) Source #

trslice :: forall (n :: Natural) (x :: TK). KnownSTK x => Int -> Int -> AstTensor 'AstMethodLet s ('TKR2 (1 + n) x) -> AstTensor 'AstMethodLet s ('TKR2 (1 + n) x) Source #

trreverse :: forall (n :: Natural) (x :: TK). KnownSTK x => AstTensor 'AstMethodLet s ('TKR2 (1 + n) x) -> AstTensor 'AstMethodLet s ('TKR2 (1 + n) x) Source #

trtranspose :: forall (n :: Nat) (x :: TK). KnownSTK x => PermR -> AstTensor 'AstMethodLet s ('TKR2 n x) -> AstTensor 'AstMethodLet s ('TKR2 n x) Source #

trreshape :: forall (n :: Nat) (m :: Nat) (x :: TK). KnownSTK x => IShR m -> AstTensor 'AstMethodLet s ('TKR2 n x) -> AstTensor 'AstMethodLet s ('TKR2 m x) Source #

tsappend :: forall (m :: Nat) (n :: Nat) (sh :: [Nat]) (x :: TK). KnownSTK x => AstTensor 'AstMethodLet s ('TKS2 (m ': sh) x) -> AstTensor 'AstMethodLet s ('TKS2 (n ': sh) x) -> AstTensor 'AstMethodLet s ('TKS2 ((m + n) ': sh) x) Source #

tsslice :: forall (i :: Nat) (n :: Nat) (k :: Nat) (sh :: [Natural]) (x :: TK). KnownSTK x => SNat i -> SNat n -> SNat k -> AstTensor 'AstMethodLet s ('TKS2 (((i + n) + k) ': sh) x) -> AstTensor 'AstMethodLet s ('TKS2 (n ': sh) x) Source #

tsreverse :: forall (n :: Nat) (sh :: [Nat]) (x :: TK). KnownSTK x => AstTensor 'AstMethodLet s ('TKS2 (n ': sh) x) -> AstTensor 'AstMethodLet s ('TKS2 (n ': sh) x) Source #

tstranspose :: forall (perm :: [Natural]) (sh :: [Nat]) (x :: TK). (IsPermutation perm, Rank perm <= Rank sh, KnownSTK x) => Perm perm -> AstTensor 'AstMethodLet s ('TKS2 sh x) -> AstTensor 'AstMethodLet s ('TKS2 (PermutePrefix perm sh) x) Source #

tsreshape :: forall (sh :: [Natural]) (sh2 :: [Natural]) (x :: TK). (Product sh ~ Product sh2, KnownSTK x) => ShS sh2 -> AstTensor 'AstMethodLet s ('TKS2 sh x) -> AstTensor 'AstMethodLet s ('TKS2 sh2 x) Source #

txappend :: forall (m :: Nat) (n :: Nat) (sh :: [Maybe Nat]) (x :: TK). KnownSTK x => AstTensor 'AstMethodLet s ('TKX2 ('Just m ': sh) x) -> AstTensor 'AstMethodLet s ('TKX2 ('Just n ': sh) x) -> AstTensor 'AstMethodLet s ('TKX2 ('Just (m + n) ': sh) x) Source #

txslice :: forall (i :: Nat) (n :: Nat) (k :: Nat) (sh :: [Maybe Natural]) (x :: TK). KnownSTK x => SNat i -> SNat n -> SNat k -> AstTensor 'AstMethodLet s ('TKX2 ('Just ((i + n) + k) ': sh) x) -> AstTensor 'AstMethodLet s ('TKX2 ('Just n ': sh) x) Source #

txreverse :: forall (mn :: Maybe Nat) (sh :: [Maybe Nat]) (x :: TK). KnownSTK x => AstTensor 'AstMethodLet s ('TKX2 (mn ': sh) x) -> AstTensor 'AstMethodLet s ('TKX2 (mn ': sh) x) Source #

txtranspose :: forall (perm :: [Natural]) (sh :: [Maybe Nat]) (x :: TK). (IsPermutation perm, Rank perm <= Rank sh, KnownSTK x) => Perm perm -> AstTensor 'AstMethodLet s ('TKX2 sh x) -> AstTensor 'AstMethodLet s ('TKX2 (PermutePrefix perm sh) x) Source #

txreshape :: forall (sh :: [Maybe Nat]) (sh2 :: [Maybe Nat]) (x :: TK). KnownSTK x => IShX sh2 -> AstTensor 'AstMethodLet s ('TKX2 sh x) -> AstTensor 'AstMethodLet s ('TKX2 sh2 x) Source #

trbuild1 :: forall (n :: Nat) (x :: TK). (KnownNat n, KnownSTK x) => Int -> (IntOf (AstTensor 'AstMethodLet s) -> AstTensor 'AstMethodLet s ('TKR2 n x)) -> AstTensor 'AstMethodLet s ('TKR2 (1 + n) x) Source #

trmap0N :: forall (n :: Nat) (x :: TK) (x1 :: TK). (KnownNat n, KnownSTK x, KnownSTK x1) => (AstTensor 'AstMethodLet s ('TKR2 0 x1) -> AstTensor 'AstMethodLet s ('TKR2 0 x)) -> AstTensor 'AstMethodLet s ('TKR2 n x1) -> AstTensor 'AstMethodLet s ('TKR2 n x) Source #

trzipWith0N :: forall (n :: Nat) (x :: TK) (x1 :: TK) (x2 :: TK). (KnownNat n, KnownSTK x, KnownSTK x1, KnownSTK x2) => (AstTensor 'AstMethodLet s ('TKR2 0 x1) -> AstTensor 'AstMethodLet s ('TKR2 0 x2) -> AstTensor 'AstMethodLet s ('TKR2 0 x)) -> AstTensor 'AstMethodLet s ('TKR2 n x1) -> AstTensor 'AstMethodLet s ('TKR2 n x2) -> AstTensor 'AstMethodLet s ('TKR2 n x) Source #

tsbuild1 :: forall (k :: Nat) (sh :: [Nat]) (x :: TK). (KnownNat k, KnownShS sh, KnownSTK x) => (IntOf (AstTensor 'AstMethodLet s) -> AstTensor 'AstMethodLet s ('TKS2 sh x)) -> AstTensor 'AstMethodLet s ('TKS2 (k ': sh) x) Source #

tsmap0N :: forall (sh :: [Nat]) (x :: TK) (x1 :: TK). (KnownShS sh, KnownSTK x, KnownSTK x1) => (AstTensor 'AstMethodLet s ('TKS2 ('[] :: [Nat]) x1) -> AstTensor 'AstMethodLet s ('TKS2 ('[] :: [Nat]) x)) -> AstTensor 'AstMethodLet s ('TKS2 sh x1) -> AstTensor 'AstMethodLet s ('TKS2 sh x) Source #

tszipWith0N :: forall (sh :: [Nat]) (x :: TK) (x1 :: TK) (x2 :: TK). (KnownShS sh, KnownSTK x, KnownSTK x1, KnownSTK x2) => (AstTensor 'AstMethodLet s ('TKS2 ('[] :: [Nat]) x1) -> AstTensor 'AstMethodLet s ('TKS2 ('[] :: [Nat]) x2) -> AstTensor 'AstMethodLet s ('TKS2 ('[] :: [Nat]) x)) -> AstTensor 'AstMethodLet s ('TKS2 sh x1) -> AstTensor 'AstMethodLet s ('TKS2 sh x2) -> AstTensor 'AstMethodLet s ('TKS2 sh x) Source #

txbuild1 :: forall (k :: Nat) (sh :: [Maybe Nat]) (x :: TK). (KnownNat k, KnownShX sh, KnownSTK x) => (IntOf (AstTensor 'AstMethodLet s) -> AstTensor 'AstMethodLet s ('TKX2 sh x)) -> AstTensor 'AstMethodLet s ('TKX2 ('Just k ': sh) x) Source #

tbuild1 :: forall (y :: TK) (k :: Nat). ConvertTensor (AstTensor 'AstMethodLet s) => SNat k -> SingletonTK y -> (IntOf (AstTensor 'AstMethodLet s) -> AstTensor 'AstMethodLet s y) -> AstTensor 'AstMethodLet s (BuildTensorKind k y) Source #

tmapAccumRDer :: forall (accy :: TK) (by :: TK) (ey :: TK) (k :: Nat). Proxy (AstTensor 'AstMethodLet s) -> SNat k -> FullShapeTK accy -> FullShapeTK by -> FullShapeTK ey -> HFunOf (AstTensor 'AstMethodLet s) ('TKProduct accy ey) ('TKProduct accy by) -> HFunOf (AstTensor 'AstMethodLet s) ('TKProduct (ADTensorKind ('TKProduct accy ey)) ('TKProduct accy ey)) (ADTensorKind ('TKProduct accy by)) -> HFunOf (AstTensor 'AstMethodLet s) ('TKProduct (ADTensorKind ('TKProduct accy by)) ('TKProduct accy ey)) (ADTensorKind ('TKProduct accy ey)) -> AstTensor 'AstMethodLet s accy -> AstTensor 'AstMethodLet s (BuildTensorKind k ey) -> AstTensor 'AstMethodLet s ('TKProduct accy (BuildTensorKind k by)) Source #

tmapAccumLDer :: forall (accy :: TK) (by :: TK) (ey :: TK) (k :: Nat). Proxy (AstTensor 'AstMethodLet s) -> SNat k -> FullShapeTK accy -> FullShapeTK by -> FullShapeTK ey -> HFunOf (AstTensor 'AstMethodLet s) ('TKProduct accy ey) ('TKProduct accy by) -> HFunOf (AstTensor 'AstMethodLet s) ('TKProduct (ADTensorKind ('TKProduct accy ey)) ('TKProduct accy ey)) (ADTensorKind ('TKProduct accy by)) -> HFunOf (AstTensor 'AstMethodLet s) ('TKProduct (ADTensorKind ('TKProduct accy by)) ('TKProduct accy ey)) (ADTensorKind ('TKProduct accy ey)) -> AstTensor 'AstMethodLet s accy -> AstTensor 'AstMethodLet s (BuildTensorKind k ey) -> AstTensor 'AstMethodLet s ('TKProduct accy (BuildTensorKind k by)) Source #

tApply :: forall (x :: TK) (z :: TK). HFunOf (AstTensor 'AstMethodLet s) x z -> AstTensor 'AstMethodLet s x -> AstTensor 'AstMethodLet s z Source #

tlambda :: forall (x :: TK) (z :: TK). FullShapeTK x -> HFun x z -> HFunOf (AstTensor 'AstMethodLet s) x z Source #

tgrad :: forall (x :: TK) r. FullShapeTK x -> HFun x ('TKScalar r) -> HFunOf (AstTensor 'AstMethodLet s) x (ADTensorKind x) Source #

tvjp :: forall (x :: TK) (z :: TK). FullShapeTK x -> HFun x z -> HFunOf (AstTensor 'AstMethodLet s) ('TKProduct (ADTensorKind z) x) (ADTensorKind x) Source #

tjvp :: forall (x :: TK) (z :: TK). FullShapeTK x -> HFun x z -> HFunOf (AstTensor 'AstMethodLet s) ('TKProduct (ADTensorKind x) x) (ADTensorKind z) Source #

tprimalPart :: forall (y :: TK). AstTensor 'AstMethodLet s y -> PrimalOf (AstTensor 'AstMethodLet s) y Source #

tdualPart :: forall (y :: TK). SingletonTK y -> AstTensor 'AstMethodLet s y -> DualOf (AstTensor 'AstMethodLet s) y Source #

tfromPrimal :: forall (y :: TK). SingletonTK y -> PrimalOf (AstTensor 'AstMethodLet s) y -> AstTensor 'AstMethodLet s y Source #

tfromDual :: forall (y :: TK). DualOf (AstTensor 'AstMethodLet s) y -> AstTensor 'AstMethodLet s y Source #

tScale :: forall (y :: TK). (Num (AstTensor 'AstMethodLet s y), Num (PrimalOf (AstTensor 'AstMethodLet s) y)) => SingletonTK y -> PrimalOf (AstTensor 'AstMethodLet s) y -> DualOf (AstTensor 'AstMethodLet s) y -> DualOf (AstTensor 'AstMethodLet s) y Source #

tsum :: forall (z :: TK) (k :: Nat). ConvertTensor (AstTensor 'AstMethodLet s) => SNat k -> SingletonTK z -> AstTensor 'AstMethodLet s (BuildTensorKind k z) -> AstTensor 'AstMethodLet s z Source #

treplicate :: forall (z :: TK) (k :: Nat). ConvertTensor (AstTensor 'AstMethodLet s) => SNat k -> SingletonTK z -> AstTensor 'AstMethodLet s z -> AstTensor 'AstMethodLet s (BuildTensorKind k z) Source #

tindexBuild :: forall (z :: TK) (k :: Nat). ConvertTensor (AstTensor 'AstMethodLet s) => SNat k -> SingletonTK z -> AstTensor 'AstMethodLet s (BuildTensorKind k z) -> IntOf (AstTensor 'AstMethodLet s) -> AstTensor 'AstMethodLet s z Source #

treplTarget :: forall (y :: TK). (forall r. GoodScalar r => r) -> FullShapeTK y -> AstTensor 'AstMethodLet s y Source #

tdefTarget :: forall (y :: TK). FullShapeTK y -> AstTensor 'AstMethodLet s y Source #

taddTarget :: forall (y :: TK). SingletonTK y -> AstTensor 'AstMethodLet s y -> AstTensor 'AstMethodLet s y -> AstTensor 'AstMethodLet s y Source #

tmultTarget :: forall (y :: TK). SingletonTK y -> AstTensor 'AstMethodLet s y -> AstTensor 'AstMethodLet s y -> AstTensor 'AstMethodLet s y Source #

tsum0Target :: forall (y :: TK). FullShapeTK y -> AstTensor 'AstMethodLet s y -> AstTensor 'AstMethodLet s ('TKScalar Double) Source #

tdot0Target :: forall (y :: TK). FullShapeTK y -> AstTensor 'AstMethodLet s y -> AstTensor 'AstMethodLet s y -> AstTensor 'AstMethodLet s ('TKScalar Double) Source #

xmcast :: forall (x :: TK) (sh :: [Maybe Nat]) (sh2 :: [Maybe Nat]). (KnownSTK x, KnownShX sh, Rank sh ~ Rank sh2, ConvertTensor (AstTensor 'AstMethodLet s)) => StaticShX sh2 -> AstTensor 'AstMethodLet s ('TKX2 sh x) -> AstTensor 'AstMethodLet s ('TKX2 sh2 x) Source #