Package nl.tudelft.simulation.jstats.math

Class ProbMath

    • Field Summary

      Fields 
      Modifier and Type Field Description
      static double[] FACTORIAL_DOUBLE
      stored values of n! as a double value.
      static long[] FACTORIAL_LONG
      stored values of n! as a long value.
      static double[] POW2_DOUBLE
      stored values of a^n as a double value.
      static long[] POW2_LONG
      stored values of 2^n as a long value.

    • Method Summary

      All Methods Static Methods Concrete Methods 
      Modifier and Type Method Description
      static double beta​(double z, double w)
      Calculates Beta(z, w) where Beta(z, w) = Γ(z) Γ(w) / Γ(z + w).
      static long comb​(int n, int k)
      computes the combinations of n over k as a long.
      static long comb​(long n, long k)
      computes the combinations of n over k as a long.
      static double combinations​(int n, int k)
      computes the combinations of n over k.
      static double combinations​(long n, long k)
      computes the combinations of n over k.
      static double erf​(double z)
      Approximates erf(z) using a Taylor series.
      The Taylor series for erf(z) for abs(z) < 0.5 that is used is:
          erf(z) = (exp(-z2) / √π) Σ [ 2z2n + 1 / (2n + 1)!!]
      The Taylor series for erf(z) for abs(z) > 3.7 that is used is:
          erf(z) = 1 - (exp(-z2) / √π) Σ [ (-1)n (2n - 1)!! z-(2n + 1) / 2n]
      See https://mathworld.wolfram.com/Erf.html.
      static double erfInv​(double y)
      Approximates erf-1(p) based on http://www.naic.edu/~jeffh/inverse_cerf.c code.
      static long fac​(int n)
      Compute n factorial as a long.
      static long fac​(long n)
      Compute n factorial as a long.
      static double factorial​(int n)
      Compute n factorial as a double.
      static double factorial​(long n)
      Compute n factorial as a double.
      static double gamma​(double x)
      Calculates gamma(x).
      static double gammaln​(double xx)
      Calculates ln(gamma(x)).
      static long perm​(int n, int k)
      Computes the k-permutations of n as a long.
      static long perm​(long n, long k)
      Computes the k-permutations of n as a long.
      static double permutations​(int n, int k)
      Compute the k-permutations of n.
      static double permutations​(long n, long k)
      Compute the k-permutations of n.

    • Field Detail

      • FACTORIAL_DOUBLE

        public static final double[] FACTORIAL_DOUBLE
        stored values of n! as a double value.

      • FACTORIAL_LONG

        public static final long[] FACTORIAL_LONG
        stored values of n! as a long value.

      • POW2_DOUBLE

        public static final double[] POW2_DOUBLE
        stored values of a^n as a double value.

      • POW2_LONG

        public static final long[] POW2_LONG
        stored values of 2^n as a long value.

    • Method Detail

      • factorial

        public static double factorial​(int n)
        Compute n factorial as a double. fac(n) = n * (n-1) * (n-2) * ... 2 * 1.
        Parameters:
        n - int; the value to calculate n! for
        Returns:
        double; n factorial

      • factorial

        public static double factorial​(long n)
        Compute n factorial as a double. fac(n) = n * (n-1) * (n-2) * ... 2 * 1.
        Parameters:
        n - long; the value to calculate n! for
        Returns:
        double; n factorial

      • fac

        public static long fac​(int n)
        Compute n factorial as a long. fac(n) = n * (n-1) * (n-2) * ... 2 * 1.
        Parameters:
        n - int; the value to calculate n! for
        Returns:
        double; n factorial

      • fac

        public static long fac​(long n)
        Compute n factorial as a long. fac(n) = n * (n-1) * (n-2) * ... 2 * 1.
        Parameters:
        n - long; the value to calculate n! for
        Returns:
        double; n factorial

      • permutations

        public static double permutations​(int n,
                                  int k)
        Compute the k-permutations of n.
        Parameters:
        n - int; the first parameter
        k - int; the second parameter
        Returns:
        the k-permutations of n

      • permutations

        public static double permutations​(long n,
                                  long k)
        Compute the k-permutations of n.
        Parameters:
        n - long; the first parameter
        k - long; the second parameter
        Returns:
        the k-permutations of n

      • perm

        public static long perm​(int n,
                        int k)
        Computes the k-permutations of n as a long.
        Parameters:
        n - int; the first parameter
        k - int; the second parameter
        Returns:
        the k-permutations of n

      • perm

        public static long perm​(long n,
                        long k)
        Computes the k-permutations of n as a long.
        Parameters:
        n - long; the first parameter
        k - long; the second parameter
        Returns:
        the k-permutations of n

      • combinations

        public static double combinations​(int n,
                                  int k)
        computes the combinations of n over k.
        Parameters:
        n - int; the first parameter
        k - int; the second parameter
        Returns:
        the combinations of n over k

      • combinations

        public static double combinations​(long n,
                                  long k)
        computes the combinations of n over k.
        Parameters:
        n - long; the first parameter
        k - long; the second parameter
        Returns:
        the combinations of n over k

      • comb

        public static long comb​(int n,
                        int k)
        computes the combinations of n over k as a long.
        Parameters:
        n - int; the first parameter
        k - int; the second parameter
        Returns:
        the combinations of n over k

      • comb

        public static long comb​(long n,
                        long k)
        computes the combinations of n over k as a long.
        Parameters:
        n - long; the first parameter
        k - long; the second parameter
        Returns:
        the combinations of n over k

      • erf

        public static double erf​(double z)
        Approximates erf(z) using a Taylor series.
        The Taylor series for erf(z) for abs(z) < 0.5 that is used is:
            erf(z) = (exp(-z2) / √π) Σ [ 2z2n + 1 / (2n + 1)!!]
        The Taylor series for erf(z) for abs(z) > 3.7 that is used is:
            erf(z) = 1 - (exp(-z2) / √π) Σ [ (-1)n (2n - 1)!! z-(2n + 1) / 2n]
        See https://mathworld.wolfram.com/Erf.html.
        For 0.5 < z < 3.7 it approximates erf(z) using the following Taylor series:
            erf(z) = (2/√π) (z - z3/3 + z5/10 - z7/42 + z9/216 - ...)
        The factors are given by https://oeis.org/A007680, which evaluates to a(n) = (2n+1)n!. See https://en.wikipedia.org/wiki/Error_function.
        Parameters:
        z - double; the value to calculate the error function for
        Returns:
        erf(z)

      • erfInv

        public static double erfInv​(double y)
        Approximates erf-1(p) based on http://www.naic.edu/~jeffh/inverse_cerf.c code.
        Parameters:
        y - double; the cumulative probability to calculate the inverse error function for
        Returns:
        erf-1(p)

      • gammaln

        public static double gammaln​(double xx)
        Calculates ln(gamma(x)). Java version of gammln function in Numerical Recipes in C, p.214.
        Parameters:
        xx - double; the value to calculate the gamma function for
        Returns:
        double; gamma(x)
        Throws:
        IllegalArgumentException - when x is < 0

      • gamma

        public static double gamma​(double x)
        Calculates gamma(x). Based on the gammln function in Numerical Recipes in C, p.214.
        Parameters:
        x - double; the value to calculate the gamma function for
        Returns:
        double; gamma(x)
        Throws:
        IllegalArgumentException - when x is < 0

      • beta

        public static double beta​(double z,
                          double w)
        Calculates Beta(z, w) where Beta(z, w) = Γ(z) Γ(w) / Γ(z + w).
        Parameters:
        z - double; beta function parameter 1
        w - ; beta function parameter 2
        Returns:
        double; beta(z, w)
        Throws:
        IllegalArgumentException - when one of the parameters is < 0