/** * Generates a random value from the {@link BinomialDistribution Binomial Distribution}. * * @param numberOfTrials number of trials of the Binomial distribution * @param probabilityOfSuccess probability of success of the Binomial distribution * @return random value sampled from the Binomial(numberOfTrials, probabilityOfSuccess) distribution */ public int nextBinomial(int numberOfTrials, double probabilityOfSuccess) { return new BinomialDistribution(getRandomGenerator(), numberOfTrials, probabilityOfSuccess).sample(); }
final BinomialDistribution distribution = new BinomialDistribution(null, numberOfTrials, probability); switch (alternativeHypothesis) { case GREATER_THAN: return 1 - distribution.cumulativeProbability(numberOfSuccesses - 1); case LESS_THAN: return distribution.cumulativeProbability(numberOfSuccesses); case TWO_SIDED: int criticalValueLow = 0; double pLow = distribution.probability(criticalValueLow); double pHigh = distribution.probability(criticalValueHigh);
BinomialDistribution binomial = new BinomialDistribution(1000, 0.5); int lowerBound = binomial.inverseCumulativeProbability(0.000001); int upperBound = binomial.inverseCumulativeProbability(0.999999); assertLessThan(foo, upperBound); assertGreaterThan(foo, lowerBound); binomial = new BinomialDistribution(1000, 2.0 / 3.0); lowerBound = binomial.inverseCumulativeProbability(0.000001); upperBound = binomial.inverseCumulativeProbability(0.999999); assertLessThan(foo, upperBound); assertGreaterThan(foo, lowerBound);
int totalNew = testCount + newTrainInGen; IntegerDistribution dist = new BinomialDistribution(random, totalNew, TEST_FRACTION); checkDiscreteProbability(testCount, dist);
/** Calculate a p-value for Fisher's Exact Test. */ private double test(int a, int b, int c, int d) { BinomialDistribution dist = new BinomialDistribution(b + c, 0.5); double pValue = dist.cumulativeProbability(c); return pValue; }
@Test public void logPmfIsCorrectForKnownVectorValues() { double p = 0.25; int n = 100; int k1 = 20; int k2 = 80; BinomialVertex testBinomialVertex = new BinomialVertex(new long[]{1, 2}, p, n); BinomialDistribution distribution = new BinomialDistribution(n, p); double actual = testBinomialVertex.logPmf(new int[]{k1, k2}); double expected = distribution.logProbability(k1) + distribution.logProbability(k2); assertEquals(expected, actual, 1e-6); } }
/** * @param param * number of trials * @param param2 * prob. of success * @return binomial distribution */ protected BinomialDistribution getBinomialDistribution(int param, double param2) { if (binomial == null || binomial.getNumberOfTrials() != param || binomial.getProbabilityOfSuccess() != param2) { binomial = new BinomialDistribution(param, param2); } return binomial; }
@Override public final void compute() { if (input[0].isDefined() && input[1].isDefined() && input[2].isDefined() && input[3].isDefined()) { int param = (int) Math.round(a.getDouble()); double param2 = b.getDouble(); int val = (int) Math.round(c.getDouble()); try { BinomialDistribution dist = getBinomialDistribution(param, param2); if (isCumulative.getBoolean()) { num.setValue(dist.cumulativeProbability(val)); // P(X <= // val) } else { num.setValue(dist.probability(val)); // P(X = val) } } catch (Exception e) { Log.debug(e.getMessage()); num.setUndefined(); } } else { num.setUndefined(); } }
@Override public int nextInt() { curr++; outdegree = bg.sample(); successors.clear(); if (! loops) successors.add(curr); for(int i = 0; i < outdegree; i++) while(! successors.add(random.nextInt(n))); if (! loops) successors.remove(curr); successorArray = IntArrays.grow(successorArray, outdegree); successors.toArray(successorArray); IntArrays.quickSort(successorArray, 0, outdegree); return curr; }
/** {@inheritDoc} */ public double probability(int x) { final double logProbability = logProbability(x); return logProbability == Double.NEGATIVE_INFINITY ? 0 : FastMath.exp(logProbability); }
@Override public final void compute() { if (input[0].isDefined() && input[1].isDefined() && input[2].isDefined()) { int param = (int) Math.round(a.getDouble()); double param2 = b.getDouble(); try { BinomialDistribution dist = getBinomialDistribution(param, param2); double sum = 0; for (int i = 0; i < list.size(); i++) { sum += dist.probability( (int) Math.round(list.get(i).evaluateDouble())); } num.setValue(sum); } catch (Exception e) { Log.debug(e.getMessage()); num.setUndefined(); } } else { num.setUndefined(); } }
@Override public final void compute() { if (input[0].isDefined() && input[1].isDefined() && input[2].isDefined()) { int param = (int) Math.round(a.getDouble()); double param2 = b.getDouble(); double val = c.getDouble(); try { BinomialDistribution dist = getBinomialDistribution(param, param2); // subtract eps to fix eg // InverseBinomial[10,1/10,617003001/625000000] // https://www.geogebra.org/m/d23dHjw2 double result = dist.inverseCumulativeProbability(val - 1E-14); // eg InversePascal[1,1,1] returns 2147483647 if (result > param) { num.setValue(param); } else { num.setValue(result); } } catch (Exception e) { num.setUndefined(); } } else { num.setUndefined(); } }
int count = yellowCount + redCount; assertGreater(count, 0); IntegerDistribution dist = new BinomialDistribution(RandomManager.getRandom(), count, 0.9); if ("r+".equals(nodeID)) {
/** * get a peptide score based on peakDepth. */ public double getScore(ProductIonSet productIonSet, int peakDepth, int splitSize) { List<PeakSet> depthPeakSetList = getDepthPeakSetList(peakDepth, splitSize); PeakSet allDepthPeakSet = new PeakSet(); for (PeakSet depthPeakSet : depthPeakSetList) { allDepthPeakSet.addAll(depthPeakSet); } ProductIonSet matchedSet = getMatchedSet(productIonSet, allDepthPeakSet); int N = productIonSet.size(); int n = matchedSet.size(); double p = getProbability(peakDepth, splitSize); BinomialDistribution distribution = new BinomialDistribution(N, p); // get cumulative probability which n-1 < x <= N, that means n <= x <= N double cumulative = distribution.cumulativeProbability(n-1, N); return (-10) * Math.log10(cumulative); }
@Test public void logPmfIsCorrectForKnownScalarValues() { double p = 0.25; int n = 5; BinomialVertex testBinomialVertex = new BinomialVertex(p, n); BinomialDistribution distribution = new BinomialDistribution(n, p); for (int i = 0; i < n; i++) { double actual = testBinomialVertex.logPmf(i); double expected = distribution.logProbability(i); assertEquals(expected, actual, 1e-6); } }
/** {@inheritDoc} */ public double probability(int x) { final double logProbability = logProbability(x); return logProbability == Double.NEGATIVE_INFINITY ? 0 : Math.exp(logProbability); }
long[] idx = idxIter.next(); org.apache.commons.math3.distribution.BinomialDistribution binomialDistribution = new org.apache.commons.math3.distribution.BinomialDistribution( (RandomGenerator) Nd4j.getRandom(), numberOfTrials, p.getDouble(idx)); ret.putScalar(idx, binomialDistribution.sample()); new org.apache.commons.math3.distribution.BinomialDistribution( (RandomGenerator) Nd4j.getRandom(), numberOfTrials, probabilityOfSuccess); for (int i = 0; i < len; i++) { ret.putScalar(idxIter.next(), binomialDistribution.sample());
BinomialDistribution binomial = new BinomialDistribution(1000, 2.0 / 3.0); int lowerBound = binomial.inverseCumulativeProbability(0.000001); int upperBound = binomial.inverseCumulativeProbability(0.999999); assertLessThan(group2Ran, upperBound); assertGreaterThan(group2Ran, lowerBound);
final BinomialDistribution distribution = new BinomialDistribution(null, numberOfTrials, probability); switch (alternativeHypothesis) { case GREATER_THAN: return 1 - distribution.cumulativeProbability(numberOfSuccesses - 1); case LESS_THAN: return distribution.cumulativeProbability(numberOfSuccesses); case TWO_SIDED: int criticalValueLow = 0; double pLow = distribution.probability(criticalValueLow); double pHigh = distribution.probability(criticalValueHigh);
@Override public Object doWork(Object first, Object second) throws IOException{ if(null == first){ throw new IOException(String.format(Locale.ROOT,"Invalid expression %s - null found for the first value",toExpression(constructingFactory))); } if(null == second){ throw new IOException(String.format(Locale.ROOT,"Invalid expression %s - null found for the second value",toExpression(constructingFactory))); } Number numberOfTrials = (Number)first; Number successProb = (Number)second; return new BinomialDistribution(numberOfTrials.intValue(), successProb.doubleValue()); } }