Safe Haskell	None
Language	GHC2024

HordeAd.Core.CarriersConcrete

Contents

RepConcrete and its operations
Concrete and its operations
Orphan instances

Description

Tensor operations implementation using the ox-arrays package. These definitions, mostly class instances, are needed to make concrete arrays a valid carrier for a tensor class algebra (instance) defined in HordeAd.Core.OpsConcrete.

Synopsis

type family RepConcrete (y :: TK) where ...
tftkG :: forall (y :: TK). SingletonTK y -> RepConcrete y -> FullShapeTK y
eltDictRep :: forall (y :: TK). SingletonTK y -> Dict KnownElt (RepConcrete y)
showDictRep :: forall (y :: TK). SingletonTK y -> Dict Show (RepConcrete y)
newtype Concrete (y :: TK) = Concrete {
- unConcrete :: RepConcrete y
}
rtoVector :: forall r (n :: Nat). GoodScalar r => Concrete (TKR n r) -> Vector r
stoVector :: forall r (sh :: [Nat]). GoodScalar r => Concrete (TKS sh r) -> Vector r
xtoVector :: forall r (sh :: [Maybe Nat]). GoodScalar r => Concrete (TKX sh r) -> Vector r

RepConcrete and its operations

type family RepConcrete (y :: TK) where ... Source #

The type family that represents tensor kinds in concrete arrays.

Equations

RepConcrete ('TKScalar r) = r
RepConcrete ('TKR2 n x) = Ranked n (RepConcrete x)
RepConcrete ('TKS2 sh x) = Shaped sh (RepConcrete x)
RepConcrete ('TKX2 sh x) = Mixed sh (RepConcrete x)
RepConcrete ('TKProduct x z) = (RepConcrete x, RepConcrete z)

tftkG :: forall (y :: TK). SingletonTK y -> RepConcrete y -> FullShapeTK y Source #

Computing full shape tensor kinds for concrete arrays.

eltDictRep :: forall (y :: TK). SingletonTK y -> Dict KnownElt (RepConcrete y) Source #

showDictRep :: forall (y :: TK). SingletonTK y -> Dict Show (RepConcrete y) Source #

Concrete and its operations

newtype Concrete (y :: TK) Source #

A newtype wrapper over RepConcrete. It's needed because RepConcrete can't be partially applied. This type also lets us work around the woes with defining Show for the RepConcrete type family. It gives us a concrete thing to attach a Show instance to.

Constructors

Concrete
Fields unConcrete :: RepConcrete y

Instances

Instances details

ConvertTensor Concrete Source #

Instance details

Defined in HordeAd.Core.OpsConcrete

Methods

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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 #

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 #

ShareTensor Concrete Source #

Instance details

Defined in HordeAd.Core.OpsConcrete

Methods

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

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

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

GoodScalar r => EqH Concrete ('TKScalar r) Source #

Instance details

(GoodScalar r, PrimElt r, RealFloat r, FloatElt r) => RealFloat (Mixed sh r) Source #
Instance details Methods floatRadix :: Mixed sh r -> Integer # floatDigits :: Mixed sh r -> Int # floatRange :: Mixed sh r -> (Int, Int) # decodeFloat :: Mixed sh r -> (Integer, Int) # encodeFloat :: Integer -> Int -> Mixed sh r # exponent :: Mixed sh r -> Int # significand :: Mixed sh r -> Mixed sh r # scaleFloat :: Int -> Mixed sh r -> Mixed sh r # isNaN :: Mixed sh r -> Bool # isInfinite :: Mixed sh r -> Bool # isDenormalized :: Mixed sh r -> Bool # isNegativeZero :: Mixed sh r -> Bool # isIEEE :: Mixed sh r -> Bool # atan2 :: Mixed sh r -> Mixed sh r -> Mixed sh r #
(GoodScalar r, PrimElt r, RealFloat r, FloatElt r) => RealFloat (Ranked n r) Source #
Instance details Methods floatRadix :: Ranked n r -> Integer # floatDigits :: Ranked n r -> Int # floatRange :: Ranked n r -> (Int, Int) # decodeFloat :: Ranked n r -> (Integer, Int) # encodeFloat :: Integer -> Int -> Ranked n r # exponent :: Ranked n r -> Int # significand :: Ranked n r -> Ranked n r # scaleFloat :: Int -> Ranked n r -> Ranked n r # isNaN :: Ranked n r -> Bool # isInfinite :: Ranked n r -> Bool # isDenormalized :: Ranked n r -> Bool # isNegativeZero :: Ranked n r -> Bool # isIEEE :: Ranked n r -> Bool # atan2 :: Ranked n r -> Ranked n r -> Ranked n r #
(GoodScalar r, PrimElt r, RealFloat r, FloatElt r) => RealFloat (Shaped sh r) Source #
Instance details Methods floatRadix :: Shaped sh r -> Integer # floatDigits :: Shaped sh r -> Int # floatRange :: Shaped sh r -> (Int, Int) # decodeFloat :: Shaped sh r -> (Integer, Int) # encodeFloat :: Integer -> Int -> Shaped sh r # exponent :: Shaped sh r -> Int # significand :: Shaped sh r -> Shaped sh r # scaleFloat :: Int -> Shaped sh r -> Shaped sh r # isNaN :: Shaped sh r -> Bool # isInfinite :: Shaped sh r -> Bool # isDenormalized :: Shaped sh r -> Bool # isNegativeZero :: Shaped sh r -> Bool # isIEEE :: Shaped sh r -> Bool # atan2 :: Shaped sh r -> Shaped sh r -> Shaped sh r #
GoodScalar r => Real (Mixed sh r) Source #
Instance details Methods toRational :: Mixed sh r -> Rational #
GoodScalar r => Real (Ranked n r) Source #
Instance details Methods toRational :: Ranked n r -> Rational #
GoodScalar r => Real (Shaped sh r) Source #
Instance details Methods toRational :: Shaped sh r -> Rational #
(GoodScalar r, FloatElt r) => RealFrac (Mixed sh r) Source #
Instance details Methods properFraction :: Integral b => Mixed sh r -> (b, Mixed sh r) # truncate :: Integral b => Mixed sh r -> b # round :: Integral b => Mixed sh r -> b # ceiling :: Integral b => Mixed sh r -> b # floor :: Integral b => Mixed sh r -> b #
(GoodScalar r, FloatElt r) => RealFrac (Ranked n r) Source #
Instance details Methods properFraction :: Integral b => Ranked n r -> (b, Ranked n r) # truncate :: Integral b => Ranked n r -> b # round :: Integral b => Ranked n r -> b # ceiling :: Integral b => Ranked n r -> b # floor :: Integral b => Ranked n r -> b #
(GoodScalar r, RealFrac r, FloatElt r) => RealFrac (Shaped sh r) Source #
Instance details Methods properFraction :: Integral b => Shaped sh r -> (b, Shaped sh r) # truncate :: Integral b => Shaped sh r -> b # round :: Integral b => Shaped sh r -> b # ceiling :: Integral b => Shaped sh r -> b # floor :: Integral b => Shaped sh r -> b #
(IntElt r, PrimElt r, Eq r, Num r) => IntegralH (Mixed sh r) Source #
Instance details Methods quotH :: Mixed sh r -> Mixed sh r -> Mixed sh r Source # remH :: Mixed sh r -> Mixed sh r -> Mixed sh r Source #
(IntElt r, PrimElt r, Eq r, Num r) => IntegralH (Ranked n r) Source #
Instance details Methods quotH :: Ranked n r -> Ranked n r -> Ranked n r Source # remH :: Ranked n r -> Ranked n r -> Ranked n r Source #
(IntElt r, PrimElt r, Eq r, Num r) => IntegralH (Shaped sh r) Source #
Instance details Methods quotH :: Shaped sh r -> Shaped sh r -> Shaped sh r Source # remH :: Shaped sh r -> Shaped sh r -> Shaped sh r Source #
(PrimElt r, FloatElt r) => RealFloatH (Mixed sh r) Source #
Instance details Methods atan2H :: Mixed sh r -> Mixed sh r -> Mixed sh r Source #
(PrimElt r, FloatElt r) => RealFloatH (Ranked n r) Source #
Instance details Methods atan2H :: Ranked n r -> Ranked n r -> Ranked n r Source #
(PrimElt r, FloatElt r) => RealFloatH (Shaped sh r) Source #
Instance details Methods atan2H :: Shaped sh r -> Shaped sh r -> Shaped sh r Source #

RepConcrete and its operations

Concrete and its operations

Instances

Orphan instances