mwc-random-0.15.2.0: Fast, high quality pseudo random number generation

Copyright | (c) 2012 Aleksey Khudyakov
License | BSD3
Maintainer | bos@serpentine.com
Stability | experimental
Portability | portable
Safe Haskell | None
Language | Haskell2010

System.Random.MWC.CondensedTable

Contents

- Condensed tables
- Constructors for tables
  - Disrete distributions
- References

Description

Table-driven generation of random variates. This approach can generate random variates in O(1) time for the supported distributions, at a modest cost in initialization time.

Synopsis

- data CondensedTable (v :: Type -> Type) a
- type CondensedTableV = CondensedTable Vector
- type CondensedTableU = CondensedTable Vector
- genFromTable :: forall g m (v :: Type -> Type) a. (StatefulGen g m, Vector v a) => CondensedTable v a -> g -> m a
- tableFromProbabilities :: (Vector v (a, Word32), Vector v (a, Double), Vector v a, Vector v Word32) => v (a, Double) -> CondensedTable v a
- tableFromWeights :: (Vector v (a, Word32), Vector v (a, Double), Vector v a, Vector v Word32) => v (a, Double) -> CondensedTable v a
- tableFromIntWeights :: (Vector v (a, Word32), Vector v a, Vector v Word32) => v (a, Word32) -> CondensedTable v a
- tablePoisson :: Double -> CondensedTableU Int
- tableBinomial :: Int -> Double -> CondensedTableU Int

# Condensed tables

data CondensedTable (v :: Type -> Type) a #

A lookup table for arbitrary discrete distributions. It allows the generation of random variates in O(1). Note that probability is quantized in units of `1/2^32`, and all distributions with infinite support (e.g. Poisson) should be truncated.

type CondensedTableV = CondensedTable Vector #

A `CondensedTable` that uses boxed vectors, and is able to hold any type of element.

type CondensedTableU = CondensedTable Vector #

A `CondensedTable` that uses unboxed vectors.

genFromTable :: forall g m (v :: Type -> Type) a. (StatefulGen g m, Vector v a) => CondensedTable v a -> g -> m a #

Generate a random value using a condensed table.

# Constructors for tables

tableFromProbabilities :: (Vector v (a, Word32), Vector v (a, Double), Vector v a, Vector v Word32) => v (a, Double) -> CondensedTable v a #

Generate a condensed lookup table from a list of outcomes with given probabilities. The vector should be non-empty and the probabilities should be non-negative and sum to 1. If this is not the case, this algorithm will construct a table for some distribution that may bear no resemblance to what you intended.

tableFromWeights :: (Vector v (a, Word32), Vector v (a, Double), Vector v a, Vector v Word32) => v (a, Double) -> CondensedTable v a #

Same as `tableFromProbabilities` but treats number as weights not probilities. Non-positive weights are discarded, and those remaining are normalized to 1.

tableFromIntWeights :: (Vector v (a, Word32), Vector v a, Vector v Word32) => v (a, Word32) -> CondensedTable v a #

Generate a condensed lookup table from integer weights. Weights should sum to `2^32` at least approximately. This function will correct small deviations from `2^32` such as arising from rounding errors. But for large deviations it's likely to product incorrect result with terrible performance.

## Disrete distributions

tablePoisson :: Double -> CondensedTableU Int #

Create a lookup table for the Poisson distribution. Note that table construction may have significant cost. For λ < 100 it takes as much time to build table as generation of 1000-30000 variates.

tableBinomial #

Arguments

:: Int | Number of tries
-> Double | Probability of success
-> CondensedTableU Int |

Create a lookup table for the binomial distribution.

# References

- Wang, J.; Tsang, W. W.; G. Marsaglia (2004), Fast Generation of Discrete Random Variables, /Journal of Statistical Software, American Statistical Association/, vol. 11(i03). http://ideas.repec.org/a/jss/jstsof/11i03.html