{-# OPTIONS_GHC -fno-cse #-}
module Torch.Indef.Dynamic.Tensor.Math.Reduce.Floating
( mean, mean_
, std, std_
, var, var_
, norm, norm_
, renorm, renorm_
, dist
, meanall
, varall
, stdall
, normall
) where
import Control.Monad.Managed
import System.IO.Unsafe
import Torch.Indef.Types
import Torch.Indef.Dynamic.Tensor (empty)
import qualified Torch.Sig.Tensor.Math.Reduce.Floating as Sig
mean :: Dynamic
-> Word
-> Dynamic
mean t d = unsafeDupablePerformIO $ do
let r = empty
_meanKeepDims r t d
pure r
{-# NOINLINE mean #-}
mean_ :: Dynamic
-> Word
-> IO ()
mean_ t = _meanKeepDims t t
_meanKeepDims :: Dynamic -> Dynamic
-> Word
-> IO ()
_meanKeepDims r t d = _mean r t d keep
_mean :: Dynamic -> Dynamic
-> Word
-> KeepDim -> IO ()
_mean r t d b = with2DynamicState r t $ \s' r' t' ->
Sig.c_mean s' r' t' (fromIntegral d) (fromIntegral $ fromEnum b)
std
:: Dynamic
-> Word
-> KeepDim
-> Bool
-> Dynamic
std t a b c = unsafeDupablePerformIO $ do
let r = empty
_std r t a b c
pure r
{-# NOINLINE std #-}
std_ :: Dynamic
-> Word
-> KeepDim -> Bool -> IO ()
std_ t = _std t t
_std :: Dynamic -> Dynamic
-> Word
-> KeepDim -> Bool -> IO ()
_std r t a b c = with2DynamicState r t $ \s' r' t' ->
Sig.c_std s' r' t' (fromIntegral a) (fromIntegral $ fromEnum b) (toEnum $ fromEnum c)
var :: Dynamic
-> Word
-> KeepDim -> Bool -> Dynamic
var t a b c = unsafeDupablePerformIO $ do
let r = empty
_var r t a b c
pure r
{-# NOINLINE var #-}
var_ :: Dynamic
-> Word
-> KeepDim -> Bool -> IO ()
var_ t = _var t t
_var :: Dynamic -> Dynamic
-> Word
-> KeepDim -> Bool -> IO ()
_var r t a b c = with2DynamicState r t $ \s' r' t' -> Sig.c_var s' r' t' (fromIntegral a) (fromIntegral $ fromEnum b) (fromIntegral $ fromEnum c)
norm :: Dynamic -> HsReal
-> Word
-> Dynamic
norm t p d = unsafeDupablePerformIO $ do
let r = empty
_normKeepDims r t p d
pure r
{-# NOINLINE norm #-}
norm_ :: Dynamic -> HsReal
-> Word
-> IO ()
norm_ t = _normKeepDims t t
_normKeepDims :: Dynamic -> Dynamic -> HsReal
-> Word
-> IO ()
_normKeepDims r t p d = _norm r t p d keep
_norm :: Dynamic -> Dynamic -> HsReal
-> Word
-> KeepDim -> IO ()
_norm r t p d k = with2DynamicState r t $ \s' r' t' -> Sig.c_norm s' r' t' (hs2cReal p) (fromIntegral d) (fromIntegral $ fromEnum k)
renorm
:: Dynamic
-> HsReal
-> Int
-> HsReal
-> Dynamic
renorm x p dim mn = unsafeDupablePerformIO $ do
let res = empty
_renorm res x p dim mn
pure res
{-# NOINLINE renorm #-}
renorm_ :: Dynamic -> HsReal -> Int -> HsReal -> IO ()
renorm_ t = _renorm t t
_renorm :: Dynamic -> Dynamic -> HsReal -> Int -> HsReal -> IO ()
_renorm r t v a v0 = with2DynamicState r t $ \s' r' t' -> Sig.c_renorm s' r' t' (hs2cReal v) (fromIntegral a) (hs2cReal v0)
dist
:: Dynamic
-> Dynamic
-> HsReal
-> HsAccReal
dist r t v = unsafeDupablePerformIO $ with2DynamicState r t $ \s' r' t' -> fmap c2hsAccReal $ Sig.c_dist s' r' t' (hs2cReal v)
{-# NOINLINE dist #-}
meanall :: Dynamic -> HsAccReal
meanall t = unsafeDupablePerformIO $ flip with (pure . c2hsAccReal) $ do
s' <- managedState
t' <- managedTensor t
liftIO $ Sig.c_meanall s' t'
{-# NOINLINE meanall #-}
varall :: Dynamic -> Int -> HsAccReal
varall t v = unsafeDupablePerformIO $ flip with (pure . c2hsAccReal) $ do
s' <- managedState
t' <- managedTensor t
liftIO $ Sig.c_varall s' t' (fromIntegral v)
{-# NOINLINE varall #-}
stdall :: Dynamic -> Int -> HsAccReal
stdall t v = unsafeDupablePerformIO $ flip with (pure . c2hsAccReal) $ do
s' <- managedState
t' <- managedTensor t
liftIO $ Sig.c_stdall s' t' (fromIntegral v)
{-# NOINLINE stdall #-}
normall
:: Dynamic
-> HsReal
-> HsAccReal
normall t v = unsafeDupablePerformIO $ flip with (pure . c2hsAccReal) $ do
s' <- managedState
t' <- managedTensor t
liftIO $ Sig.c_normall s' t' (hs2cReal v)
{-# NOINLINE normall #-}