Esempio n. 1
1
  public static double dnbinom_mu(double x, double size, double mu, boolean give_log) {
    /* originally, just set  prob :=  size / (size + mu)  and called dbinom_raw(),
     * but that suffers from cancellation when   mu << size  */
    double ans, p;

    if (DoubleVector.isNaN(x) || DoubleVector.isNaN(size) || DoubleVector.isNaN(mu)) {
      return x + size + mu;
    }

    if (mu < 0 || size < 0) {
      return DoubleVector.NaN;
    }

    // R_D_nonint_check(x);

    if (SignRank.R_D_nonint(x, true, give_log)) {
      // MATHLIB_WARNING("non-integer x = %f", x);
      // How to warn??
      return SignRank.R_D__0(true, give_log);
    }

    if (x < 0 || !DoubleVector.isFinite(x)) {
      return SignRank.R_D__0(true, give_log);
    }
    x = SignRank.R_D_forceint(x);

    if (x == 0) /* be accerate, both for n << mu, and n >> mu :*/ {
      return SignRank.R_D_exp(
          size * (size < mu ? Math.log(size / (size + mu)) : Math.log1p(-mu / (size + mu))),
          true,
          give_log);
    }
    if (x < 1e-10 * size) {
        /* don't use dbinom_raw() but MM's formula: */
      /* FIXME --- 1e-8 shows problem; rather use algdiv() from ./toms708.c */
      return SignRank.R_D_exp(
          x * Math.log(size * mu / (size + mu))
              - mu
              - org.apache.commons.math.special.Gamma.logGamma(x + 1)
              + Math.log1p(x * (x - 1) / (2 * size)),
          true,
          give_log);
    }
    /* else: no unnecessary cancellation inside dbinom_raw, when
     * x_ = size and n_ = x+size are so close that n_ - x_ loses accuracy
     */
    ans = dbinom_raw(size, x + size, size / (size + mu), mu / (size + mu), give_log);
    p = ((double) size) / (size + x);
    return ((give_log) ? Math.log(p) + ans : p * ans);
  }
  /** Computes the probability <SPAN CLASS="MATH"><I>p</I>(<I>x</I>)</SPAN>. */
  public static double prob(double n, double p, int x) {
    final int SLIM = 15; // To avoid overflow
    final double MAXEXP = (Num.DBL_MAX_EXP - 1) * Num.LN2; // To avoid overflow
    final double MINEXP = (Num.DBL_MIN_EXP - 1) * Num.LN2; // To avoid underflow
    double y;

    if (p < 0.0 || p > 1.0) throw new IllegalArgumentException("p not in [0, 1]");
    if (n <= 0.0) throw new IllegalArgumentException("n <= 0.0");
    if (x < 0) return 0.0;
    if (p >= 1.0) { // In fact, p == 1
      if (x == 0) return 1.0;
      else return 0.0;
    }
    if (p <= 0.0) // In fact, p == 0
    return 0.0;

    y =
        Num.lnGamma(n + x)
            - (Num.lnFactorial(x) + Num.lnGamma(n))
            + n * Math.log(p)
            + x * Math.log1p(-p);

    if (y >= MAXEXP) throw new IllegalArgumentException("term overflow");
    return Math.exp(y);
  }
 /** {@inheritDoc} */
 public OpenMapRealVector mapLog1pToSelf() {
   Iterator iter = entries.iterator();
   while (iter.hasNext()) {
     iter.advance();
     entries.put(iter.key(), Math.log1p(iter.value()));
   }
   return this;
 }
 private static float[] ComputeGamma(int[] lo, int[] md, int[] hi) {
   float[] array = new float[3];
   for (int i = 0; i < 3; i++) {
     if (lo[i] < md[i] && md[i] < hi[i]) {
       double log =
           Math.log1p(/*0.5, */ (double) (((float) (md[i] - lo[i])) / ((float) (hi[i] - lo[i]))));
       array[i] = (log > 10.0) ? ((float) 10.0) : ((log < 0.1) ? ((float) 0.1) : ((float) log));
     } else {
       array[i] = 1f;
     }
   }
   return array;
 }
Esempio n. 5
0
 public static double pnbeta2(
     double x, double o_x, double a, double b, double ncp, boolean lower_tail, boolean log_p) {
   double ans = pnbeta_raw(x, o_x, a, b, ncp);
   /* return R_DT_val(ans), but we want to warn about cancellation here */
   if (lower_tail) {
     return log_p ? Math.log(ans) : ans;
   } else {
     if (ans > 1 - 1e-10) {
       return (DoubleVector.NaN);
     }
     ans = Math.min(ans, 1.0); /* Precaution */
     return log_p ? Math.log1p(-ans) : (1 - ans);
   }
 }
 /**
  * Computes the inverse of the distribution function.
  *
  * @param xi
  * @param beta
  * @param tau
  * @param y
  * @return
  */
 public static double inverseF(double xi, double beta, double tau, double y) {
   if (tau <= 0.0) throw new InvalidParameterException("tau <= 0");
   if (y < 0.0 || y > 1.0) throw new InvalidParameterException("y not in [0,1]");
   if (y <= 0.0) return beta;
   if (y >= 1.0 && xi >= 0) {
     return Double.POSITIVE_INFINITY;
   }
   if (y >= 1.0 && xi < 0) {
     return beta - tau / xi;
   }
   if (xi == 0) {
     return beta - tau * Math.log1p(-y);
   }
   return beta + tau / xi * (-1 + Math.pow(1 - y, -xi));
 }
Esempio n. 7
0
 private double calculateWeight(JobInProgress job, TaskType taskType) {
   if (!isRunnable(job)) {
     return 0;
   } else {
     double weight = 1.0;
     if (sizeBasedWeight) {
       // Set weight based on runnable tasks
       weight = Math.log1p(runnableTasks(job, taskType)) / Math.log(2);
     }
     weight *= getPriorityFactor(job.getPriority());
     if (weightAdjuster != null) {
       // Run weight through the user-supplied weightAdjuster
       weight = weightAdjuster.adjustWeight(job, taskType, weight);
     }
     return weight;
   }
 }
Esempio n. 8
0
  public static void main(String[] args) {
    for (int i = 0; i <= 10; i++) {
      System.out.println((int) Math.pow(2, i)); // üs alma
    }
    System.out.println("\n1024 karekökü : " + (int) Math.sqrt(1204)); // karekö alma
    System.out.println(" - 45 in mutlak deðerini alalým : " + Math.abs(-45));
    System.out.println("3.55 üst deðere yuvarla : " + Math.ceil(3.55));
    System.out.println("3.55 alt degerini bulalým : " + Math.floor(3.55));

    System.out.println("35 ve 155 arasýndaki büyük sayi : " + Math.max(35, 155));
    System.out.println("25 ve 244 arasýndaki küþük sayi : " + Math.min(25, 244));

    System.out.println(
        "rastgele sayi : " + Math.random()); // dönecek deðer 0 ile 1 arasýnda double deðer döner.
    System.out.println(
        "rastgele çýkan sayýyý 10 ile çarpýmsonucu : " + (int) (Math.random() * 100));

    Random r = new Random();
    int a = r.nextInt(100);
    float f = r.nextFloat();

    System.out.println("Sonucumuz : " + a);
    System.out.println(
        "randon sýnýfýnda rastgele float deðer: " + f); // 0 ile 1 arasý bir float deðer verir.

    System.out.println("1.5 radyan : " + Math.toDegrees(1.5) + " derecedir");
    System.out.println("45 derece : " + Math.toRadians(45) + " radyandýr.");

    System.out.println("sin 90 = " + Math.sin(Math.toRadians(90)));
    System.out.println("cos 55 = " + Math.cos(Math.toRadians(55)));

    System.out.println("Argsin 0.47 = " + Math.toDegrees(Math.asin(0.47)));
    System.out.println("ArgCos 0.57 = " + Math.toDegrees(Math.acos(0.57)));

    System.out.println("ln e  = " + Math.log(Math.E));
    System.out.println("log10(5) = " + Math.log10(5));
    System.out.println("ln(7+1) = " + Math.log1p(7));
  }
 /**
  * Return the probability density for a particular point.
  *
  * @param x The point at which the density should be computed.
  * @return The pdf at point x.
  * @since 2.1
  */
 @Override
 public double density(double x) {
   recomputeZ();
   if (x < 0 || x > 1) {
     return 0;
   } else if (x == 0) {
     if (alpha < 1) {
       throw MathRuntimeException.createIllegalArgumentException(
           "Cannot compute beta density at 0 when alpha = {0,number}", alpha);
     }
     return 0;
   } else if (x == 1) {
     if (beta < 1) {
       throw MathRuntimeException.createIllegalArgumentException(
           "Cannot compute beta density at 1 when beta = %.3g", beta);
     }
     return 0;
   } else {
     double logX = Math.log(x);
     double log1mX = Math.log1p(-x);
     return Math.exp((alpha - 1) * logX + (beta - 1) * log1mX - z);
   }
 }
Esempio n. 10
0
  public static double dbinom_raw(double x, double n, double p, double q, boolean give_log) {
    double lf, lc;

    if (p == 0) {
      return ((x == 0) ? SignRank.R_D__1(true, give_log) : SignRank.R_D__0(true, give_log));
    }
    if (q == 0) {
      return ((x == n) ? SignRank.R_D__1(true, give_log) : SignRank.R_D__0(true, give_log));
    }

    if (x == 0) {
      if (n == 0) {
        return SignRank.R_D__1(true, give_log);
      }
      lc = (p < 0.1) ? -bd0(n, n * q) - n * p : n * Math.log(q);
      return (SignRank.R_D_exp(lc, true, give_log));
    }
    if (x == n) {
      lc = (q < 0.1) ? -bd0(n, n * p) - n * q : n * Math.log(p);
      return (SignRank.R_D_exp(lc, true, give_log));
    }
    if (x < 0 || x > n) {
      return (SignRank.R_D__0(true, give_log));
    }

    /* n*p or n*q can underflow to zero if n and p or q are small.  This
    used to occur in dbeta, and gives NaN as from R 2.3.0.  */
    lc = stirlerr(n) - stirlerr(x) - stirlerr(n - x) - bd0(x, n * p) - bd0(n - x, n * q);

    /* f = (M_2PI*x*(n-x))/n; could overflow or underflow */
    /* Upto R 2.7.1:
     * lf = log(M_2PI) + log(x) + log(n-x) - log(n);
     * -- following is much better for  x << n : */
    lf = Math.log(2.0 * Math.PI) + Math.log(x) + Math.log1p(-x / n);

    return SignRank.R_D_exp(lc - 0.5 * lf, true, give_log);
  }
Esempio n. 11
0
 static {
   for (int i = 0; i < 0x10000; i++) logTable[i] = (float) Math.log1p(i);
 }
 // To add/remove functions change evaluateOperator() and registration
 public double evaluateFunction(String fncnam, ArgParser fncargs) throws ArithmeticException {
   switch (Character.toLowerCase(fncnam.charAt(0))) {
     case 'a':
       {
         if (fncnam.equalsIgnoreCase("abs")) {
           return Math.abs(fncargs.next());
         }
         if (fncnam.equalsIgnoreCase("acos")) {
           return Math.acos(fncargs.next());
         }
         if (fncnam.equalsIgnoreCase("asin")) {
           return Math.asin(fncargs.next());
         }
         if (fncnam.equalsIgnoreCase("atan")) {
           return Math.atan(fncargs.next());
         }
       }
       break;
     case 'c':
       {
         if (fncnam.equalsIgnoreCase("cbrt")) {
           return Math.cbrt(fncargs.next());
         }
         if (fncnam.equalsIgnoreCase("ceil")) {
           return Math.ceil(fncargs.next());
         }
         if (fncnam.equalsIgnoreCase("cos")) {
           return Math.cos(fncargs.next());
         }
         if (fncnam.equalsIgnoreCase("cosh")) {
           return Math.cosh(fncargs.next());
         }
       }
       break;
     case 'e':
       {
         if (fncnam.equalsIgnoreCase("exp")) {
           return Math.exp(fncargs.next());
         }
         if (fncnam.equalsIgnoreCase("expm1")) {
           return Math.expm1(fncargs.next());
         }
       }
       break;
     case 'f':
       {
         if (fncnam.equalsIgnoreCase("floor")) {
           return Math.floor(fncargs.next());
         }
       }
       break;
     case 'g':
       {
         //              if(fncnam.equalsIgnoreCase("getExponent"   )) { return
         // Math.getExponent(fncargs.next());                } needs Java 6
       }
       break;
     case 'l':
       {
         if (fncnam.equalsIgnoreCase("log")) {
           return Math.log(fncargs.next());
         }
         if (fncnam.equalsIgnoreCase("log10")) {
           return Math.log10(fncargs.next());
         }
         if (fncnam.equalsIgnoreCase("log1p")) {
           return Math.log1p(fncargs.next());
         }
       }
       break;
     case 'm':
       {
         if (fncnam.equalsIgnoreCase("max")) {
           return Math.max(fncargs.next(), fncargs.next());
         }
         if (fncnam.equalsIgnoreCase("min")) {
           return Math.min(fncargs.next(), fncargs.next());
         }
       }
       break;
     case 'n':
       {
         //              if(fncnam.equalsIgnoreCase("nextUp"        )) { return Math.nextUp
         // (fncargs.next());                } needs Java 6
       }
       break;
     case 'r':
       {
         if (fncnam.equalsIgnoreCase("random")) {
           return Math.random();
         } // impure
         if (fncnam.equalsIgnoreCase("round")) {
           return Math.round(fncargs.next());
         }
         if (fncnam.equalsIgnoreCase("roundHE")) {
           return Math.rint(fncargs.next());
         } // round half-even
       }
       break;
     case 's':
       {
         if (fncnam.equalsIgnoreCase("signum")) {
           return Math.signum(fncargs.next());
         }
         if (fncnam.equalsIgnoreCase("sin")) {
           return Math.sin(fncargs.next());
         }
         if (fncnam.equalsIgnoreCase("sinh")) {
           return Math.sinh(fncargs.next());
         }
         if (fncnam.equalsIgnoreCase("sqrt")) {
           return Math.sqrt(fncargs.next());
         }
       }
       break;
     case 't':
       {
         if (fncnam.equalsIgnoreCase("tan")) {
           return Math.tan(fncargs.next());
         }
         if (fncnam.equalsIgnoreCase("tanh")) {
           return Math.tanh(fncargs.next());
         }
         if (fncnam.equalsIgnoreCase("toDegrees")) {
           return Math.toDegrees(fncargs.next());
         }
         if (fncnam.equalsIgnoreCase("toRadians")) {
           return Math.toRadians(fncargs.next());
         }
       }
       break;
     case 'u':
       {
         if (fncnam.equalsIgnoreCase("ulp")) {
           return Math.ulp(fncargs.next());
         }
       }
       break;
       // no default
   }
   throw new UnsupportedOperationException(
       "MathEval internal function setup is incorrect - internal function \""
           + fncnam
           + "\" not handled");
 }
Esempio n. 13
0
  @Override
  public Object visit(RealUnaryExpression n, Void arg) {
    Double doubleObject = (Double) n.getOperand().accept(this, null);
    double doubleVal = doubleObject.doubleValue();

    Operator op = n.getOperator();
    switch (op) {
      case ABS:
        return Math.abs(doubleVal);
      case ACOS:
        return Math.acos(doubleVal);
      case ASIN:
        return Math.asin(doubleVal);
      case ATAN:
        return Math.atan(doubleVal);
      case CBRT:
        return Math.cbrt(doubleVal);
      case CEIL:
        return Math.ceil(doubleVal);
      case COS:
        return Math.cos(doubleVal);
      case COSH:
        return Math.cosh(doubleVal);
      case EXP:
        return Math.exp(doubleVal);
      case EXPM1:
        return Math.expm1(doubleVal);
      case FLOOR:
        return Math.floor(doubleVal);
      case LOG:
        return Math.log(doubleVal);
      case LOG10:
        return Math.log10(doubleVal);
      case LOG1P:
        return Math.log1p(doubleVal);
      case NEG:
        return -doubleVal;
      case NEXTUP:
        return Math.nextUp(doubleVal);
      case RINT:
        return Math.rint(doubleVal);
      case SIGNUM:
        return Math.signum(doubleVal);
      case SIN:
        return Math.sin(doubleVal);
      case SINH:
        return Math.sinh(doubleVal);
      case SQRT:
        return Math.sqrt(doubleVal);
      case TAN:
        return Math.tan(doubleVal);
      case TANH:
        return Math.tanh(doubleVal);
      case TODEGREES:
        return Math.toDegrees(doubleVal);
      case TORADIANS:
        return Math.toRadians(doubleVal);
      case ULP:
        return Math.ulp(doubleVal);

      default:
        log.warn("RealUnaryExpression: unimplemented operator: " + op);
        return null;
    }
  }
Esempio n. 14
0
 public static double R_Log1_Exp(double x, boolean lower_tail, boolean log_p) {
   return ((x) > -Math.log(2.0) ? Math.log(-Math.expm1(x)) : Math.log1p(-Math.exp(x)));
 }
Esempio n. 15
0
 public static double R_D_LExp(double x, boolean lower_tail, boolean log_p) {
   return (log_p ? R_Log1_Exp(x, lower_tail, log_p) : Math.log1p(-x));
 }
Esempio n. 16
0
 public static double R_D_Clog(double p, boolean lower_tail, boolean log_p) {
   return (log_p ? Math.log1p(-(p)) : (0.5 - (p) + 0.5));
 }
Esempio n. 17
0
  public static double pnbeta_raw(double x, double o_x, double a, double b, double ncp) {
    /* o_x  == 1 - x  but maybe more accurate */

    /* change errmax and itrmax if desired;
     * original (AS 226, R84) had  (errmax; itrmax) = (1e-6; 100) */
    final double errmax = 1.0e-9;
    final int itrmax = 10000; /* 100 is not enough for pf(ncp=200)
    see PR#11277 */

    double[] temp = new double[1];
    double[] tmp_c = new double[1];
    int[] ierr = new int[1];
    double a0, ax, lbeta, c, errbd, x0;
    int j;

    double ans, gx, q, sumq;

    if (ncp < 0. || a <= 0. || b <= 0.) {
      return DoubleVector.NaN;
    }

    if (x < 0. || o_x > 1. || (x == 0. && o_x == 1.)) {
      return 0.;
    }
    if (x > 1. || o_x < 0. || (x == 1. && o_x == 0.)) {
      return 1.;
    }

    c = ncp / 2.;

    /* initialize the series */

    x0 = Math.floor(Math.max(c - 7. * Math.sqrt(c), 0.));
    a0 = a + x0;
    lbeta =
        org.apache.commons.math.special.Gamma.logGamma(a0)
            + org.apache.commons.math.special.Gamma.logGamma(b)
            - org.apache.commons.math.special.Gamma.logGamma(a0 + b);
    /* temp = pbeta_raw(x, a0, b, TRUE, FALSE), but using (x, o_x): */
    Utils.bratio(a0, b, x, o_x, temp, tmp_c, ierr, false);

    gx =
        Math.exp(
            a0 * Math.log(x)
                + b * (x < .5 ? Math.log1p(-x) : Math.log(o_x))
                - lbeta
                - Math.log(a0));
    if (a0 > a) {
      q = Math.exp(-c + x0 * Math.log(c) - org.apache.commons.math.special.Gamma.logGamma(x0 + 1.));
    } else {
      q = Math.exp(-c);
    }

    sumq = 1. - q;
    ans = ax = q * temp[0];

    /* recurse over subsequent terms until convergence is achieved */
    j = (int) x0;
    do {
      j++;
      temp[0] -= gx;
      gx *= x * (a + b + j - 1.) / (a + j);
      q *= c / j;
      sumq -= q;
      ax = temp[0] * q;
      ans += ax;
      errbd = (temp[0] - gx) * sumq;
    } while (errbd > errmax && j < itrmax + x0);

    if (errbd > errmax) {
      // ML_ERROR(ME_PRECISION, "pnbeta");
    }
    if (j >= itrmax + x0) {
      // ML_ERROR(ME_NOCONV, "pnbeta");
    }

    return ans;
  }
Esempio n. 18
0
 /**
  * Calculates base e logarithm for the given value.
  *
  * @param d value
  * @return base e logarithm for d
  */
 private double ln(final double d) {
   return d == 0 ? 0 : Math.log1p(Math.abs(d));
 }