Copyright | Copyright (c) 2015 Christopher Chalmers <c.chalmers@me.com> |
---|---|
License | BSD3 |
Maintainer | Christopher Chalmers <c.chalmers@me.com> |
Stability | experimental |
Portability | CPP |
Safe Haskell | None |
Language | Haskell2010 |
Standard PCG Random Number Generator with chosen streams, written in pure haskell. See http://www.pcg-random.org for details.
import Control.Monad.ST import System.Random.PCG.Pure three :: [Double] three = runST $ do g <- create a <- uniform g b <- uniform g c <- uniform g return [a,b,c]
Synopsis
- data Gen s
- type GenIO = Gen RealWorld
- type GenST = Gen
- create :: PrimMonad m => m (Gen (PrimState m))
- createSystemRandom :: IO GenIO
- initialize :: PrimMonad m => Word64 -> Word64 -> m (Gen (PrimState m))
- withSystemRandom :: (GenIO -> IO a) -> IO a
- class Variate a where
- advance :: PrimMonad m => Word64 -> Gen (PrimState m) -> m ()
- retract :: PrimMonad m => Word64 -> Gen (PrimState m) -> m ()
- type FrozenGen = SetSeq
- save :: PrimMonad m => Gen (PrimState m) -> m SetSeq
- restore :: PrimMonad m => FrozenGen -> m (Gen (PrimState m))
- seed :: SetSeq
- initFrozen :: Word64 -> Word64 -> SetSeq
- uniformW8 :: Generator g m => g -> m Word8
- uniformW16 :: Generator g m => g -> m Word16
- uniformW32 :: Generator g m => g -> m Word32
- uniformW64 :: Generator g m => g -> m Word64
- uniformI8 :: Generator g m => g -> m Int8
- uniformI16 :: Generator g m => g -> m Int16
- uniformI32 :: Generator g m => g -> m Int32
- uniformI64 :: Generator g m => g -> m Int64
- uniformF :: Generator g m => g -> m Float
- uniformD :: Generator g m => g -> m Double
- uniformBool :: Generator g m => g -> m Bool
- uniformRW8 :: Generator g m => (Word8, Word8) -> g -> m Word8
- uniformRW16 :: Generator g m => (Word16, Word16) -> g -> m Word16
- uniformRW32 :: Generator g m => (Word32, Word32) -> g -> m Word32
- uniformRW64 :: Generator g m => (Word64, Word64) -> g -> m Word64
- uniformRI8 :: Generator g m => (Int8, Int8) -> g -> m Int8
- uniformRI16 :: Generator g m => (Int16, Int16) -> g -> m Int16
- uniformRI32 :: Generator g m => (Int32, Int32) -> g -> m Int32
- uniformRI64 :: Generator g m => (Int64, Int64) -> g -> m Int64
- uniformRF :: Generator g m => (Float, Float) -> g -> m Float
- uniformRD :: Generator g m => (Double, Double) -> g -> m Double
- uniformRBool :: Generator g m => (Bool, Bool) -> g -> m Bool
- uniformBW8 :: Generator g m => Word8 -> g -> m Word8
- uniformBW16 :: Generator g m => Word16 -> g -> m Word16
- uniformBW32 :: Generator g m => Word32 -> g -> m Word32
- uniformBW64 :: Generator g m => Word64 -> g -> m Word64
- uniformBI8 :: Generator g m => Int8 -> g -> m Int8
- uniformBI16 :: Generator g m => Int16 -> g -> m Int16
- uniformBI32 :: Generator g m => Int32 -> g -> m Int32
- uniformBI64 :: Generator g m => Int64 -> g -> m Int64
- uniformBF :: Generator g m => Float -> g -> m Float
- uniformBD :: Generator g m => Double -> g -> m Double
- uniformBBool :: Generator g m => Bool -> g -> m Bool
- data SetSeq
- next' :: SetSeq -> (Word32, SetSeq)
- advanceSetSeq :: Word64 -> FrozenGen -> FrozenGen
Gen
State of the random number generator
createSystemRandom :: IO GenIO Source #
Seed with system random number. (/dev/urandom
on Unix-like
systems and CryptAPI on Windows).
initialize :: PrimMonad m => Word64 -> Word64 -> m (Gen (PrimState m)) Source #
Initialize a generator a single word.
>>>
initialize 0 0 >>= save
SetSeq 6364136223846793006 1
withSystemRandom :: (GenIO -> IO a) -> IO a Source #
Seed with system random number. (/dev/urandom
on Unix-like
systems and CryptAPI on Windows).
Getting random numbers
class Variate a where Source #
uniform :: Generator g m => g -> m a Source #
Generate a uniformly distributed random vairate.
- Use entire range for integral types.
- Use (0,1] range for floating types.
uniformR :: Generator g m => (a, a) -> g -> m a Source #
Generate a uniformly distributed random vairate in the given range.
- Use inclusive range for integral types.
- Use (a,b] range for floating types.
uniformB :: Generator g m => a -> g -> m a Source #
Generate a uniformly distributed random vairate in the range
[0,b). For integral types the bound must be less than the max bound
of Word32
(4294967295). Behaviour is undefined for negative
bounds.
Instances
Variate Bool Source # | |
Variate Double Source # | |
Variate Float Source # | |
Variate Int Source # | |
Variate Int8 Source # | |
Variate Int16 Source # | |
Variate Int32 Source # | |
Variate Int64 Source # | |
Variate Word Source # | |
Variate Word8 Source # | |
Variate Word16 Source # | |
Variate Word32 Source # | |
Variate Word64 Source # | |
(Variate a, Variate b) => Variate (a, b) Source # | |
(Variate a, Variate b, Variate c) => Variate (a, b, c) Source # | |
(Variate a, Variate b, Variate c, Variate d) => Variate (a, b, c, d) Source # | |
advance :: PrimMonad m => Word64 -> Gen (PrimState m) -> m () Source #
Advance the given generator n steps in log(n) time. (Note that a
"step" is a single random 32-bit (or less) Variate
. Data types
such as Double
or Word64
require two "steps".)
>>>
create >>= \g -> replicateM_ 1000 (uniformW32 g) >> uniformW32 g
3640764222>>>
create >>= \g -> replicateM_ 500 (uniformD g) >> uniformW32 g
3640764222>>>
create >>= \g -> advance 1000 g >> uniformW32 g
3640764222
retract :: PrimMonad m => Word64 -> Gen (PrimState m) -> m () Source #
Retract the given generator n steps in log(2^64-n) time. This
is just advance (-n)
.
>>>
create >>= \g -> replicateM 3 (uniformW32 g)
[355248013,41705475,3406281715]>>>
create >>= \g -> retract 1 g >> replicateM 3 (uniformW32 g)
[19683962,355248013,41705475]
Seeds
initFrozen :: Word64 -> Word64 -> SetSeq Source #
Create a new generator from two words.
>>>
initFrozen 0 0
SetSeq 6364136223846793006 1
Type restricted versions
uniform
uniformW16 :: Generator g m => g -> m Word16 Source #
uniformW32 :: Generator g m => g -> m Word32 Source #
uniformW64 :: Generator g m => g -> m Word64 Source #
uniformI16 :: Generator g m => g -> m Int16 Source #
uniformI32 :: Generator g m => g -> m Int32 Source #
uniformI64 :: Generator g m => g -> m Int64 Source #
uniformBool :: Generator g m => g -> m Bool Source #
uniformR
uniformB
Pure
The multiple sequence varient of the pcg random number generator.
Instances
Eq SetSeq Source # | |
Data SetSeq Source # | |
Defined in System.Random.PCG.Pure gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SetSeq -> c SetSeq # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SetSeq # toConstr :: SetSeq -> Constr # dataTypeOf :: SetSeq -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SetSeq) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SetSeq) # gmapT :: (forall b. Data b => b -> b) -> SetSeq -> SetSeq # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SetSeq -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SetSeq -> r # gmapQ :: (forall d. Data d => d -> u) -> SetSeq -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SetSeq -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SetSeq -> m SetSeq # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SetSeq -> m SetSeq # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SetSeq -> m SetSeq # | |
Ord SetSeq Source # | |
Show SetSeq Source # | |
Generic SetSeq Source # | |
Storable SetSeq Source # | |
RandomGen FrozenGen Source # | |
type Rep SetSeq Source # | |
Defined in System.Random.PCG.Pure type Rep SetSeq = D1 (MetaData "SetSeq" "System.Random.PCG.Pure" "pcg-random-0.1.3.6-inplace" False) (C1 (MetaCons "SetSeq" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) SourceUnpack SourceStrict DecidedStrict) (Rec0 Word64) :*: S1 (MetaSel (Nothing :: Maybe Symbol) SourceUnpack SourceStrict DecidedStrict) (Rec0 Word64))) |