Class LargeMeanPoissonSampler

    • Field Detail

      • MAX_MEAN

        private static final double MAX_MEAN
        Upper bound to avoid truncation.
        See Also:
        Constant Field Values
      • 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.
      • 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 Detail

      • LargeMeanPoissonSampler

        public LargeMeanPoissonSampler​(UniformRandomProvider rng,
                                       double mean)
        Parameters:
        rng - Generator of uniformly distributed random numbers.
        mean - Mean.
        Throws:
        java.lang.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:
        java.lang.IllegalArgumentException - if lambdaFractional < 0 || lambdaFractional >= 1.
    • Method Detail

      • sample

        public int sample()
        Creates an int sample.
        Specified by:
        sample in interface DiscreteSampler
        Returns:
        a sample.
      • getFactorialLog

        private double getFactorialLog​(int n)
        Compute the natural logarithm of the factorial of n.
        Parameters:
        n - Argument.
        Returns:
        log(n!)
        Throws:
        java.lang.IllegalArgumentException - if n < 0.
      • toString

        public java.lang.String toString()
        Overrides:
        toString in class java.lang.Object
      • of

        public static SharedStateDiscreteSampler of​(UniformRandomProvider rng,
                                                    double mean)
        Creates a new Poisson distribution sampler.
        Parameters:
        rng - Generator of uniformly distributed random numbers.
        mean - Mean.
        Returns:
        the sampler
        Throws:
        java.lang.IllegalArgumentException - if mean < 1 or mean > 0.5 * Integer.MAX_VALUE.
        Since:
        1.3