Example usage for org.apache.commons.math3.util FastMath log1p

Introduction

In this page you can find the example usage for org.apache.commons.math3.util FastMath log1p.

Prototype

public static double log1p(final double x) 

Source Link

Document

Computes log(1 + x).

Usage

From source file:it.unibo.alchemist.model.implementations.timedistributions.ExponentialTime.java

private double uniformToExponential(final double lambda) {
    return -FastMath.log1p(-rand.nextDouble()) / lambda;
}

---

From source file:de.tuberlin.uebb.jbop.example.DSCompilerOnlyCompose.java

@Override
public void log1p(final double[] operand, final double[] result) {

    // create the function value and derivatives
    final double[] function = new double[1 + order];
    function[0] = FastMath.log1p(operand[0]);
    if (order > 0) {
        final double inv = 1.0 / (1.0 + operand[0]);
        double xk = inv;
        for (int i = 1; i <= order; ++i) {
            function[i] = xk;/*from  w  ww.j  av  a 2 s.  c o m*/
            xk *= -i * inv;
        }
    }

    // apply function composition
    compose(operand, function, result);

}

---

From source file:de.tuberlin.uebb.jbop.example.DSCompiler.java

@Override
@Optimizable// w ww .j a va 2s  .  c om
@StrictLoops
public void log1p(final double[] operand, final double[] result) {

    // create the function value and derivatives
    final double[] function = new double[1 + order];
    function[0] = FastMath.log1p(operand[0]);
    if (order > 0) {
        final double inv = 1.0 / (1.0 + operand[0]);
        double xk = inv;
        for (int i = 1; i <= order; ++i) {
            function[i] = xk;
            xk *= -i * inv;
        }
    }

    // apply function composition
    compose(operand, function, result);

}

---

From source file:org.esa.beam.util.math.FastMathPerformance.java

public void testLog1p() {
    System.gc();/*from w  w  w  . j a v a  2s.  co m*/
    double x = 0;
    long time = System.nanoTime();
    for (int i = 0; i < RUNS; i++)
        x += StrictMath.log1p(Math.PI + i/* 1.0 + i/1e9 */);
    long strictMath = System.nanoTime() - time;

    System.gc();
    double y = 0;
    time = System.nanoTime();
    for (int i = 0; i < RUNS; i++)
        y += FastMath.log1p(Math.PI + i/* 1.0 + i/1e9 */);
    long fastTime = System.nanoTime() - time;

    System.gc();
    double z = 0;
    time = System.nanoTime();
    for (int i = 0; i < RUNS; i++)
        z += Math.log1p(Math.PI + i/* 1.0 + i/1e9 */);
    long mathTime = System.nanoTime() - time;

    report("log1p", x + y + z, strictMath, fastTime, mathTime);
}

---

From source file:statalign.utils.BetaDistribution.java

/** {@inheritDoc} */
@Override/*from   w  w w  .  j a v a  2 s  . c o m*/
public double density(double x) {
    recomputeZ();
    if (x < 0 || x > 1) {
        return 0;
    } else if (x == 0) {
        if (alpha < 1) {
            throw new NumberIsTooSmallException(
                    LocalizedFormats.CANNOT_COMPUTE_BETA_DENSITY_AT_0_FOR_SOME_ALPHA, alpha, 1, false);
        }
        return 0;
    } else if (x == 1) {
        if (beta < 1) {
            throw new NumberIsTooSmallException(LocalizedFormats.CANNOT_COMPUTE_BETA_DENSITY_AT_1_FOR_SOME_BETA,
                    beta, 1, false);
        }
        return 0;
    } else {
        double logX = FastMath.log(x);
        double log1mX = FastMath.log1p(-x);
        return FastMath.exp((alpha - 1) * logX + (beta - 1) * log1mX - z);
    }
}

---

From source file:statalign.utils.GammaDistribution.java

/** {@inheritDoc} */
@Override//  www  .ja v a2  s  . c om
public double density(double x) {
    /* The present method must return the value of
     *
     *     1       x a     - x
     * ---------- (-)  exp(---)
     * x Gamma(a)  b        b
     *
     * where a is the shape parameter, and b the scale parameter.
     * Substituting the Lanczos approximation of Gamma(a) leads to the
     * following expression of the density
     *
     * a              e            1         y      a
     * - sqrt(------------------) ---- (-----------)  exp(a - y + g),
     * x      2 pi (a + g + 0.5)  L(a)  a + g + 0.5
     *
     * where y = x / b. The above formula is the "natural" computation, which
     * is implemented when no overflow is likely to occur. If overflow occurs
     * with the natural computation, the following identity is used. It is
     * based on the BOOST library
     * http://www.boost.org/doc/libs/1_35_0/libs/math/doc/sf_and_dist/html/math_toolkit/special/sf_gamma/igamma.html
     * Formula (15) needs adaptations, which are detailed below.
     *
     *       y      a
     * (-----------)  exp(a - y + g)
     *  a + g + 0.5
     *                              y - a - g - 0.5    y (g + 0.5)
     *               = exp(a log1pm(---------------) - ----------- + g),
     *                                a + g + 0.5      a + g + 0.5
     *
     *  where log1pm(z) = log(1 + z) - z. Therefore, the value to be
     *  returned is
     *
     * a              e            1
     * - sqrt(------------------) ----
     * x      2 pi (a + g + 0.5)  L(a)
     *                              y - a - g - 0.5    y (g + 0.5)
     *               * exp(a log1pm(---------------) - ----------- + g).
     *                                a + g + 0.5      a + g + 0.5
     */
    if (x < 0) {
        return 0;
    }
    final double y = x / scale;
    if ((y <= minY) || (FastMath.log(y) >= maxLogY)) {
        /*
         * Overflow.
         */
        final double aux1 = (y - shiftedShape) / shiftedShape;
        final double aux2 = shape * (FastMath.log1p(aux1) - aux1);
        final double aux3 = -y * (Gamma.LANCZOS_G + 0.5) / shiftedShape + Gamma.LANCZOS_G + aux2;
        return densityPrefactor2 / x * FastMath.exp(aux3);
    }
    /*
     * Natural calculation.
     */
    return densityPrefactor1 * FastMath.exp(-y) * FastMath.pow(y, shape - 1);
}

---