Class LargeMeanPoissonSampler

java.lang.Object
org.apache.commons.rng.sampling.distribution.LargeMeanPoissonSampler
All Implemented Interfaces:
DiscreteSampler, SharedStateDiscreteSampler, SharedStateSampler<SharedStateDiscreteSampler>

public class LargeMeanPoissonSampler extends Object implements SharedStateDiscreteSampler
Sampler for the Poisson distribution.
  • For large means, we use the rejection algorithm described in
    Devroye, Luc. (1981).The Computer Generation of Poisson Random Variables
    Computing vol. 26 pp. 197-207.

This sampler is suitable for mean >= 40.

Sampling uses:

Since:
1.1
  • Field Details

    • MAX_MEAN

      private static final double MAX_MEAN
      Upper bound to avoid truncation.
      See Also:
    • NO_CACHE_FACTORIAL_LOG

      private static final InternalUtils.FactorialLog NO_CACHE_FACTORIAL_LOG
      Class to compute log(n!). This has no cached values.
    • NO_SMALL_MEAN_POISSON_SAMPLER

      private static final SharedStateDiscreteSampler NO_SMALL_MEAN_POISSON_SAMPLER
      Used when there is no requirement for a small mean Poisson sampler.
    • rng

      private final UniformRandomProvider rng
      Underlying source of randomness.
    • exponential

      private final SharedStateContinuousSampler exponential
      Exponential.
    • gaussian

      private final SharedStateContinuousSampler gaussian
      Gaussian.
    • factorialLog

      private final InternalUtils.FactorialLog factorialLog
      Local class to compute log(n!). This may have cached values.
    • lambda

      private final double lambda
      Algorithm constant: Math.floor(mean).
    • logLambda

      private final double logLambda
      Algorithm constant: Math.log(lambda).
    • logLambdaFactorial

      private final double logLambdaFactorial
      Algorithm constant: factorialLog((int) lambda).
    • delta

      private final double delta
      Algorithm constant: Math.sqrt(lambda * Math.log(32 * lambda / Math.PI + 1)).
    • halfDelta

      private final double halfDelta
      Algorithm constant: delta / 2.
    • sqrtLambdaPlusHalfDelta

      private final double sqrtLambdaPlusHalfDelta
      Algorithm constant: Math.sqrt(lambda + halfDelta).
    • twolpd

      private final double twolpd
      Algorithm constant: 2 * lambda + delta.
    • p1

      private final double p1
      Algorithm constant: a1 / aSum.
      • a1 = Math.sqrt(Math.PI * twolpd) * Math.exp(c1)
      • aSum = a1 + a2 + 1
    • p2

      private final double p2
      Algorithm constant: a2 / aSum.
      • a2 = (twolpd / delta) * Math.exp(-delta * (1 + delta) / twolpd)
      • aSum = a1 + a2 + 1
    • c1

      private final double c1
      Algorithm constant: 1 / (8 * lambda).
    • smallMeanPoissonSampler

      private final SharedStateDiscreteSampler smallMeanPoissonSampler
      The internal Poisson sampler for the lambda fraction.
  • Constructor Details

    • LargeMeanPoissonSampler

      public LargeMeanPoissonSampler(UniformRandomProvider rng, double mean)
      Create an instance.
      Parameters:
      rng - Generator of uniformly distributed random numbers.
      mean - Mean.
      Throws:
      IllegalArgumentException - if mean < 1 or mean > 0.5 * Integer.MAX_VALUE.
    • LargeMeanPoissonSampler

      LargeMeanPoissonSampler(UniformRandomProvider rng, LargeMeanPoissonSampler.LargeMeanPoissonSamplerState state, double lambdaFractional)
      Instantiates a sampler using a precomputed state.
      Parameters:
      rng - Generator of uniformly distributed random numbers.
      state - The state for lambda = (int)Math.floor(mean).
      lambdaFractional - The lambda fractional value (mean - (int)Math.floor(mean)).
      Throws:
      IllegalArgumentException - if lambdaFractional < 0 || lambdaFractional >= 1.
    • LargeMeanPoissonSampler

      private LargeMeanPoissonSampler(double mean, UniformRandomProvider rng)
      Parameters:
      mean - Mean.
      rng - Generator of uniformly distributed random numbers.
    • LargeMeanPoissonSampler

      private LargeMeanPoissonSampler(LargeMeanPoissonSampler.LargeMeanPoissonSamplerState state, double lambdaFractional, UniformRandomProvider rng)
      Instantiates a sampler using a precomputed state.
      Parameters:
      state - The state for lambda = (int)Math.floor(mean).
      lambdaFractional - The lambda fractional value (mean - (int)Math.floor(mean)).
      rng - Generator of uniformly distributed random numbers.
    • LargeMeanPoissonSampler

      private LargeMeanPoissonSampler(UniformRandomProvider rng, LargeMeanPoissonSampler source)
      Parameters:
      rng - Generator of uniformly distributed random numbers.
      source - Source to copy.
  • Method Details