module Torch.Indef.Dynamic.Tensor.Random.TH
( _random , random
, _clampedRandom , clampedRandom
, _cappedRandom , cappedRandom
, _geometric , geometric
, _bernoulli , bernoulli
, _bernoulli_FloatTensor , bernoulli_FloatTensor
, _bernoulli_DoubleTensor , bernoulli_DoubleTensor
, _uniform , uniform
, _normal , normal
, _normal_means , normal_means
, _normal_stddevs , normal_stddevs
, _normal_means_stddevs , normal_means_stddevs
, _exponential , exponential
, _standard_gamma , standard_gamma
, _cauchy , cauchy
, _logNormal , logNormal
, _multinomial
, _multinomialAliasSetup
, _multinomialAliasDraw
, OpenUnit, openUnit, openUnitValue
, ClosedUnit, closedUnit, closedUnitValue
, Positive, positive, positiveValue
, Ord2Tuple, ord2Tuple, ord2TupleValue
) where
import Foreign hiding (with, new)
import Foreign.Ptr
import GHC.Word
import Numeric.Dimensions
import Control.Monad.Managed
import Torch.Types.Numeric
import Torch.Indef.Types
import Torch.Indef.Dynamic.Tensor
import qualified Torch.Sig.Tensor.Random.TH as Sig
import qualified Torch.Sig.Types as Sig
import qualified Torch.Sig.Types.Global as Sig
import qualified Torch.Types.TH as TH
random :: Dims (d::[Nat]) -> Generator -> IO Dynamic
random d g = withInplace (`_random` g) d
clampedRandom
:: Dims (d::[Nat])
-> Generator
-> Ord2Tuple Integer
-> IO Dynamic
clampedRandom d g bs = flip withInplace d $ \t -> _clampedRandom t g bs
cappedRandom
:: Dims (d::[Nat])
-> Generator
-> Word64
-> IO Dynamic
cappedRandom d g a = flip withInplace d $ \t -> _cappedRandom t g a
geometric
:: Dims (d::[Nat])
-> Generator
-> OpenUnit HsAccReal
-> IO Dynamic
geometric d g p = flip withInplace d $ \t -> _geometric t g (openUnitValue p)
bernoulli
:: Dims (d::[Nat])
-> Generator
-> ClosedUnit HsAccReal
-> IO Dynamic
bernoulli d g a = flip withInplace d $ \t -> _bernoulli t g (closedUnitValue a)
bernoulli_FloatTensor
:: Dims (d::[Nat])
-> Generator
-> TH.FloatDynamic
-> IO Dynamic
bernoulli_FloatTensor d g a = flip withInplace d $ \t -> _bernoulli_FloatTensor t g a
bernoulli_DoubleTensor
:: Dims (d::[Nat])
-> Generator
-> TH.DoubleDynamic
-> IO Dynamic
bernoulli_DoubleTensor d g a = flip withInplace d $ \t -> _bernoulli_DoubleTensor t g a
uniform
:: Dims (d::[Nat])
-> Generator
-> Ord2Tuple HsAccReal
-> IO Dynamic
uniform d g tup = flip withInplace d $ \t -> _uniform t g tup
normal
:: Dims (d::[Nat])
-> Generator
-> HsAccReal
-> Positive HsAccReal
-> IO Dynamic
normal d g a b = flip withInplace d $ \t -> _normal t g a b
normal_means
:: Dims (d::[Nat])
-> Generator
-> Dynamic
-> Positive HsAccReal
-> IO Dynamic
normal_means d g m b = flip withInplace d $ \t -> _normal_means t g m b
normal_stddevs
:: Dims (d::[Nat])
-> Generator
-> HsAccReal
-> Dynamic
-> IO Dynamic
normal_stddevs d g a s = flip withInplace d $ \t -> _normal_stddevs t g a s
normal_means_stddevs
:: Dims (d::[Nat])
-> Generator
-> Dynamic
-> Dynamic
-> IO Dynamic
normal_means_stddevs d g m s = flip withInplace d $ \t -> _normal_means_stddevs t g m s
exponential
:: Dims (d::[Nat])
-> Generator
-> HsAccReal
-> IO Dynamic
exponential d g a = flip withInplace d $ \t -> _exponential t g a
standard_gamma
:: Dims (d::[Nat])
-> Generator
-> Dynamic
-> IO Dynamic
standard_gamma d g a = flip withInplace d $ \t -> _standard_gamma t g a
cauchy
:: Dims (d::[Nat])
-> Generator
-> HsAccReal
-> HsAccReal
-> IO Dynamic
cauchy d g a b = flip withInplace d $ \t -> _cauchy t g a b
logNormal
:: Dims (d::[Nat])
-> Generator
-> HsAccReal
-> Positive HsAccReal
-> IO Dynamic
logNormal d g a b = flip withInplace d $ \t -> _logNormal t g a b
_random t g = tenGen t g Sig.c_random
_clampedRandom r g tup = withLift $ Sig.c_clampedRandom
<$> managedState
<*> managedTensor r
<*> managedGen g
<*> pure (fromIntegral a)
<*> pure (fromIntegral b)
where
(a, b) = ord2TupleValue tup
_cappedRandom r g a = withLift $ Sig.c_cappedRandom
<$> managedState
<*> managedTensor r
<*> managedGen g
<*> pure (fromIntegral a)
_geometric r g a = withLift $ Sig.c_geometric
<$> managedState
<*> managedTensor r
<*> managedGen g
<*> pure (hs2cAccReal a)
_bernoulli r g a = withLift $ Sig.c_bernoulli
<$> managedState
<*> managedTensor r
<*> managedGen g
<*> pure (hs2cAccReal a)
_bernoulli_FloatTensor r g a = tenGenTen r g (snd $ TH.floatDynamicState a) Sig.c_bernoulli_FloatTensor
_bernoulli_DoubleTensor r g a = tenGenTen r g (snd $ TH.doubleDynamicState a) Sig.c_bernoulli_DoubleTensor
_uniform :: Dynamic -> Generator -> Ord2Tuple HsAccReal -> IO ()
_uniform r g tup = withLift $ Sig.c_uniform
<$> managedState
<*> managedTensor r
<*> managedGen g
<*> pure (hs2cAccReal a)
<*> pure (hs2cAccReal b)
where
(a, b) = ord2TupleValue tup
_normal :: Dynamic -> Generator -> HsAccReal -> Positive HsAccReal -> IO ()
_normal r g a b = withLift $ Sig.c_normal
<$> managedState
<*> managedTensor r
<*> managedGen g
<*> pure (hs2cAccReal a)
<*> pure (hs2cAccReal $ positiveValue b)
_normal_means :: Dynamic -> Generator -> Dynamic -> Positive HsAccReal -> IO ()
_normal_means r g m v = withLift $ Sig.c_normal_means
<$> managedState
<*> managedTensor r
<*> managed (withForeignPtr . Sig.rng $ g)
<*> managedTensor m
<*> pure (Sig.hs2cAccReal $ positiveValue v)
_normal_stddevs :: Dynamic -> Generator -> HsAccReal -> Dynamic -> IO ()
_normal_stddevs r g v m = withLift $ Sig.c_normal_stddevs
<$> managedState
<*> managedTensor r
<*> managed (withForeignPtr . Sig.rng $ g)
<*> pure (Sig.hs2cAccReal v)
<*> managedTensor m
_normal_means_stddevs :: Dynamic -> Generator -> Dynamic -> Dynamic -> IO ()
_normal_means_stddevs r g a b = withLift $ Sig.c_normal_means_stddevs
<$> managedState
<*> managedTensor r
<*> managed (withForeignPtr . Sig.rng $ g)
<*> managedTensor a
<*> managedTensor b
_exponential :: Dynamic -> Generator -> HsAccReal -> IO ()
_exponential r g v = withLift $ Sig.c_exponential
<$> managedState
<*> managedTensor r
<*> managed (withForeignPtr . Sig.rng $ g)
<*> pure (Sig.hs2cAccReal v)
_standard_gamma :: Dynamic -> Generator -> Dynamic -> IO ()
_standard_gamma r g m = withLift $ Sig.c_standard_gamma
<$> managedState
<*> managedTensor r
<*> managed (withForeignPtr . Sig.rng $ g)
<*> managedTensor m
_cauchy :: Dynamic -> Generator -> HsAccReal -> HsAccReal -> IO ()
_cauchy r g a b = withLift $ Sig.c_cauchy
<$> managedState
<*> managedTensor r
<*> managed (withForeignPtr . Sig.rng $ g)
<*> pure (Sig.hs2cAccReal a)
<*> pure (Sig.hs2cAccReal b)
_logNormal :: Dynamic -> Generator -> HsAccReal -> Positive HsAccReal -> IO ()
_logNormal r g a b = withLift $ Sig.c_logNormal
<$> managedState
<*> managedTensor r
<*> managed (withForeignPtr . Sig.rng $ g)
<*> pure (Sig.hs2cAccReal a)
<*> pure (Sig.hs2cAccReal $ positiveValue b)
_multinomial :: LongDynamic -> Generator -> Dynamic -> Int -> Int -> IO ()
_multinomial r g t a b = withLift $ Sig.c_multinomial
<$> managedState
<*> managed (withForeignPtr . snd . Sig.longDynamicState $ r)
<*> managed (withForeignPtr . Sig.rng $ g)
<*> managedTensor t
<*> pure (fromIntegral a)
<*> pure (fromIntegral b)
_multinomialAliasSetup :: Dynamic -> LongDynamic -> Dynamic -> IO ()
_multinomialAliasSetup r l t = withLift $ Sig.c_multinomialAliasSetup
<$> managedState
<*> managedTensor r
<*> managed (withForeignPtr . snd . Sig.longDynamicState $ l)
<*> managedTensor t
_multinomialAliasDraw :: LongDynamic -> Generator -> LongDynamic -> Dynamic -> IO ()
_multinomialAliasDraw r g l t = withLift $ Sig.c_multinomialAliasDraw
<$> managedState
<*> managed (withForeignPtr . snd . Sig.longDynamicState $ r)
<*> managed (withForeignPtr . Sig.rng $ g)
<*> managed (withForeignPtr . snd . Sig.longDynamicState $ l)
<*> managedTensor t
tenGen
:: Dynamic
-> Generator
-> (Ptr CState -> Ptr CTensor -> Ptr CGenerator -> IO x)
-> IO x
tenGen r g fn = withLift $ fn
<$> managedState
<*> managedTensor r
<*> managedGen g
tenGenTen
:: Dynamic
-> Generator
-> ForeignPtr a
-> (Ptr CState -> Ptr CTensor -> Ptr CGenerator -> Ptr a -> IO x)
-> IO x
tenGenTen r g t fn = withLift $ fn
<$> managedState
<*> managedTensor r
<*> managedGen g
<*> managed (withForeignPtr t)