public static double qnbeta( double p, double a, double b, double ncp, boolean lower_tail, boolean log_p) { final double accu = 1e-15; final double Eps = 1e-14; /* must be > accu */ double ux, lx, nx, pp; if (DoubleVector.isNaN(p) || DoubleVector.isNaN(a) || DoubleVector.isNaN(b) || DoubleVector.isNaN(ncp)) { return p + a + b + ncp; } if (!DoubleVector.isFinite(a)) { return DoubleVector.NaN; } if (ncp < 0. || a <= 0. || b <= 0.) { return DoubleVector.NaN; } // R_Q_P01_boundaries(p, 0, 1); if ((log_p && p > 0) || (!log_p && (p < 0 || p > 1))) { return DoubleVector.NaN; } if (p == SignRank.R_DT_0(lower_tail, log_p)) { return 0.0; } if (p == SignRank.R_DT_1(lower_tail, log_p)) { return 1.0; } // end of R_Q_P01_boundaries p = Normal.R_DT_qIv(p, log_p ? 1.0 : 0.0, lower_tail ? 1.0 : 0.0); /* Invert pnbeta(.) : * 1. finding an upper and lower bound */ if (p > 1 - SignRank.DBL_EPSILON) { return 1.0; } pp = Math.min(1 - SignRank.DBL_EPSILON, p * (1 + Eps)); for (ux = 0.5; ux < 1 - SignRank.DBL_EPSILON && pnbeta(ux, a, b, ncp, true, false) < pp; ux = 0.5 * (1 + ux)) ; pp = p * (1 - Eps); for (lx = 0.5; lx > Double.MIN_VALUE && pnbeta(lx, a, b, ncp, true, false) > pp; lx *= 0.5) ; /* 2. interval (lx,ux) halving : */ do { nx = 0.5 * (lx + ux); if (pnbeta(nx, a, b, ncp, true, false) > p) { ux = nx; } else { lx = nx; } } while ((ux - lx) / nx > accu); return 0.5 * (ux + lx); }
public static double qnbinom( double p, double size, double prob, boolean lower_tail, boolean log_p) { double P, Q, mu, sigma, gamma, y; double[] z = new double[1]; if (DoubleVector.isNaN(p) || DoubleVector.isNaN(size) || DoubleVector.isNaN(prob)) { return p + size + prob; } if (prob <= 0 || prob > 1 || size <= 0) { return DoubleVector.NaN; } /* FIXME: size = 0 is well defined ! */ if (prob == 1) { return 0; } // R_Q_P01_boundaries(p, 0, ML_POSINF); // #define R_Q_P01_boundaries(p, _LEFT_, _RIGHT_) // This macro is defined in /src/nmath/dpq.h if (log_p) { if (p > 0) { return DoubleVector.NaN; } if (p == 0) { /* upper bound*/ return lower_tail ? Double.POSITIVE_INFINITY : 0; } if (p == Double.NEGATIVE_INFINITY) { return lower_tail ? 0 : Double.POSITIVE_INFINITY; } } else { /* !log_p */ if (p < 0 || p > 1) { return DoubleVector.NaN; } if (p == 0) { return lower_tail ? 0 : Double.POSITIVE_INFINITY; } if (p == 1) { return lower_tail ? Double.POSITIVE_INFINITY : 0; } } Q = 1.0 / prob; P = (1.0 - prob) * Q; mu = size * P; sigma = Math.sqrt(size * P * Q); gamma = (Q + P) / sigma; /* Note : "same" code in qpois.c, qbinom.c, qnbinom.c -- * FIXME: This is far from optimal [cancellation for p ~= 1, etc]: */ if (!lower_tail || log_p) { // p = R_DT_qIv(p); /* need check again (cancellation!): */ p = Normal.R_DT_qIv(p, lower_tail ? 1.0 : 0.0, log_p ? 1.0 : 0.0); if (p == SignRank.R_DT_0(lower_tail, log_p)) { return 0; } if (p == SignRank.R_DT_1(lower_tail, log_p)) { return Double.POSITIVE_INFINITY; } } /* temporary hack --- FIXME --- */ if (p + 1.01 * SignRank.DBL_EPSILON >= 1.) { return Double.POSITIVE_INFINITY; } /* y := approx.value (Cornish-Fisher expansion) : */ z[0] = Distributions.qnorm(p, 0., 1., /*lower_tail*/ true, /*log_p*/ false); y = Math.floor(mu + sigma * (z[0] + gamma * (z[0] * z[0] - 1) / 6) + 0.5); z[0] = Distributions.pnbinom(y, (int) size, prob, /*lower_tail*/ true, /*log_p*/ false); /* fuzz to ensure left continuity: */ p *= 1 - 64 * SignRank.DBL_EPSILON; /* If the C-F value is not too large a simple search is OK */ if (y < 1e5) { return do_search(y, z, p, size, prob, 1); } /* Otherwise be a bit cleverer in the search */ { double incr = Math.floor(y * 0.001), oldincr; do { oldincr = incr; y = do_search(y, z, p, size, prob, incr); incr = Math.max(1, Math.floor(incr / 100)); } while (oldincr > 1 && incr > y * 1e-15); return y; } }
public static double qsignrank(double x, double n, boolean lower_tail, boolean log_p) { double f, p, q; if (Double.isNaN(x) || Double.isNaN(n)) { return (x + n); } if (Double.isInfinite(x) || Double.isInfinite(n)) { return Double.NaN; } if ((log_p && x > 0) || (!log_p && (x < 0 || x > 1))) { return Double.NaN; } n = Math.floor(n + 0.5); if (n <= 0) { return Double.NaN; } if (x == R_DT_0(lower_tail, log_p)) { return (0); } if (x == R_DT_1(lower_tail, log_p)) { return (n * (n + 1) / 2); } if (log_p || !lower_tail) { // x = R_DT_qIv(x); /* lower_tail,non-log "p" */ x = Normal.R_DT_qIv(x, log_p ? 1. : 0., lower_tail ? 1. : 0.); } w_init_maybe((int) n); f = Math.exp(-n * Math.log(2.)); p = 0; q = 0; if (x <= 0.5) { x = x - 10 * DBL_EPSILON; for (; ; ) { p += csignrank((int) q, (int) n) * f; if (p >= x) { break; } q++; } } else { x = 1 - x + 10 * DBL_EPSILON; for (; ; ) { p += csignrank((int) q, (int) n) * f; if (p > x) { q = n * (n + 1) / 2 - q; break; } q++; } } return (q); }