Java Code Examples for com.google.common.math.DoubleMath#log2()

@Override
public SortedSet<Renaming> calculateScores(
		final Multiset<NGram<String>> ngrams,
		final Set<String> alternatives, final Scope scope) {
	final SortedSet<Renaming> scoreMap = Sets.newTreeSet();

	for (final String identifierName : alternatives) {
		double score = 0;
		for (final Entry<NGram<String>> ngram : ngrams.entrySet()) {
			try {
				final NGram<String> identNGram = NGram.substituteTokenWith(
						ngram.getElement(), WILDCARD_TOKEN, identifierName);
				final double ngramScore = scoreNgram(identNGram);
				score += DoubleMath.log2(ngramScore) * ngram.getCount();
			} catch (final Throwable e) {
				LOGGER.warning(ExceptionUtils.getFullStackTrace(e));
			}
		}
		scoreMap.add(new Renaming(identifierName, (addScopePriors(
				identifierName, scope) - score) / ngrams.size(), ngrams
				.size() / ngramLM.getN(), scope));
	}

	return scoreMap;
}
 

/**
 * Predict the max-likelihood tokens given the ngrams.
 * 
 * @param ngrams
 * @param alternatives
 * @return
 */
@Override
public SortedSet<Renaming> calculateScores(
		final Multiset<NGram<String>> ngrams,
		final Set<String> alternatives, final Scope scope) {
	final SortedSet<Renaming> suggestions = Sets.newTreeSet();

	for (final String alternative : alternatives) {
		double score = 0;
		for (final NGram<String> ngram : ngrams) {
			score += DoubleMath.log2(getNgramLM().getProbabilityFor(
					NGram.substituteTokenWith(ngram, WILDCARD_TOKEN,
							alternative)));
		}
		suggestions.add(new Renaming(alternative, -score, 1, null));
	}
	return suggestions;
}
 

public static double log2SumOfExponentials(final double... values) {
	if (values.length == 1) {
		return values[0];
	}
	final double max = max(values);
	double sum = 0.0;
	for (final double value : values) {
		if (value != Double.NEGATIVE_INFINITY) {
			sum += Math.pow(2, value - max);
		}
	}
	return max + DoubleMath.log2(sum);
}
 

/**
 * Get the probability of a specific renaming happening (taking at least
 * one of the suggestions).
 * 
 * @param suggestions
 * @return
 */
public double getLogProbOfNotRenaming() {
	double logProbNotRename = 0;
	for (final Suggestion sg : suggestions) {
		final double pNotRename = sg.getProbNotRename();
		checkArgument(pNotRename <= 1, pNotRename
				+ " should be in the probability range");
		checkArgument(pNotRename >= 0, pNotRename
				+ " should be in the probability range");
		logProbNotRename += DoubleMath.log2(pNotRename);
	}
	return logProbNotRename;
}
 

private double addGrammarPrior(final String identifierName,
		final Scope scope) {
	if (!USE_GRAMMAR) {
		return 0;
	}
	final double prob = gp.getMLProbability(identifierName,
			Pair.create(scope.astNodeType, scope.astParentNodeType));
	if (prob > 0) {
		return -DoubleMath.log2(prob);
	} else if (!this.isTrueUNK(identifierName)) {
		return 6;
	} else {
		return 0;
	}
}
 

private double addTypePrior(final String identifierName, final Scope scope) {
	if (!USE_TYPES) {
		return 0;
	}
	final double prob = tp.getMLProbability(identifierName, scope.type);
	if (prob > 0) {
		return -DoubleMath.log2(prob);
	} else if (!this.isTrueUNK(identifierName)) {
		return 6;
	} else {
		return 0;
	}
}
 

@Override
protected double addScopePriors(final String identifierName,
		final Scope scope) {
	final double prob = gp.getMLProbability(identifierName,
			Pair.create(scope.astNodeType, scope.astParentNodeType));
	if (prob > 0) {
		return -DoubleMath.log2(prob);
	} else if (!this.isTrueUNK(identifierName)) {
		return 100;
	} else {
		return 0;
	}
}
 

@Override
public double addScopePriors(final String identifierName, final Scope scope) {
	final double prob = tp.getMLProbability(identifierName, scope.type);
	if (prob > 0) {
		return -DoubleMath.log2(prob);
	} else if (!this.isTrueUNK(identifierName)) {
		return 100;
	} else {
		return 0;
	}
}
 

public static double log2SumOfExponentials(final double... values) {
	if (values.length == 1) {
		return values[0];
	}
	final double max = max(values);
	double sum = 0.0;
	for (final double value : values) {
		if (value != Double.NEGATIVE_INFINITY) {
			sum += Math.pow(2, value - max);
		}
	}
	return max + DoubleMath.log2(sum);
}
 

@Override
protected float evaluate(float arg) {
	return (float)DoubleMath.log2(arg);
}
 

public static double getLog2Prob(int x, double p) {
	final double logP = DoubleMath.log2(p);
	final double log1_p = DoubleMath.log2(1 - p);
	return (x - 1) * log1_p + logP;
}
 

@Test
public void should_calculate_log_2() {
    int result6 = DoubleMath.log2(10, RoundingMode.UP);
    assertThat(result6, equalTo(4));
}
 

@Test(expected = ArithmeticException.class)
public void whenLog2DoubleValues_shouldThrowArithmeticExceptionIfRoundingNotDefinedButNecessary() {
    DoubleMath.log2(30, RoundingMode.UNNECESSARY);
}
 

@Test
public void whenLog2DoubleValues_shouldog2ThemAndReturnTheResultForFloorRounding() {
    int result = DoubleMath.log2(30, RoundingMode.FLOOR);
    assertEquals(4, result);
}
 

@Test
public void whenLog2DoubleValues_shouldLog2ThemAndReturnTheResultForCeilingRounding() {
    int result = DoubleMath.log2(30, RoundingMode.CEILING);
    assertEquals(5, result);
}
 

@Test
public void whenLog2Double_shouldReturnResult() {
    double result = DoubleMath.log2(4);
    assertEquals(2, result, 0);
}
 

public static double getLog2Prob(int x, double p) {
	final double logP = DoubleMath.log2(p);
	final double log1_p = DoubleMath.log2(1 - p);
	return (x - 1) * log1_p + logP;
}
 

/**
 * Code ported from LingPipe This method returns the log of the sum of the
 * natural exponentiated values in the specified array. Mathematically, the
 * result is
 *
 * <blockquote>
 *
 * <pre>
 * logSumOfExponentials(xs) = log <big><big>( &Sigma;</big></big><sub>i</sub> exp(xs[i]) <big><big>)</big></big>
 * </pre>
 *
 * </blockquote>
 *
 * But the result is not calculated directly. Instead, the calculation
 * performed is:
 *
 * <blockquote>
 *
 * <pre>
 * logSumOfExponentials(xs) = max(xs) + log <big><big>( &Sigma;</big></big><sub>i</sub> exp(xs[i] - max(xs)) <big><big>)</big></big>
 * </pre>
 *
 * </blockquote>
 *
 * which produces the same result, but is much more arithmetically stable,
 * because the largest value for which <code>exp()</code> is calculated is
 * 0.0.
 *
 * <p>
 * Values of {@code Double.NEGATIVE_INFINITY} are treated as having
 * exponentials of 0 and logs of negative infinity. That is, they are
 * ignored for the purposes of this computation.
 *
 * @param values
 *            Array of values.
 * @return The log of the sum of the exponentiated values in the array.
 */
public static double log2SumOfExponentials(final Collection<Double> values) {
	if (values.size() == 1) {
		return values.iterator().next();
	}
	final double max = max(values);
	double sum = 0.0;
	for (final double value : values) {
		if (value != Double.NEGATIVE_INFINITY) {
			sum += Math.pow(2, value - max);
		}
	}
	return max + DoubleMath.log2(sum);
}
 

/**
 * Code ported from LingPipe This method returns the log of the sum of the
 * natural exponentiated values in the specified array. Mathematically, the
 * result is
 *
 * <blockquote>
 *
 * <pre>
 * logSumOfExponentials(xs) = log <big><big>( &Sigma;</big></big><sub>i</sub> exp(xs[i]) <big><big>)</big></big>
 * </pre>
 *
 * </blockquote>
 *
 * But the result is not calculated directly. Instead, the calculation
 * performed is:
 *
 * <blockquote>
 *
 * <pre>
 * logSumOfExponentials(xs) = max(xs) + log <big><big>( &Sigma;</big></big><sub>i</sub> exp(xs[i] - max(xs)) <big><big>)</big></big>
 * </pre>
 *
 * </blockquote>
 *
 * which produces the same result, but is much more arithmetically stable,
 * because the largest value for which <code>exp()</code> is calculated is
 * 0.0.
 *
 * <p>
 * Values of {@code Double.NEGATIVE_INFINITY} are treated as having
 * exponentials of 0 and logs of negative infinity. That is, they are
 * ignored for the purposes of this computation.
 *
 * @param values
 *            Array of values.
 * @return The log of the sum of the exponentiated values in the array.
 */
public static double log2SumOfExponentials(final Collection<Double> values) {
	if (values.size() == 1) {
		return values.iterator().next();
	}
	final double max = max(values);
	double sum = 0.0;
	for (final double value : values) {
		if (value != Double.NEGATIVE_INFINITY) {
			sum += Math.pow(2, value - max);
		}
	}
	return max + DoubleMath.log2(sum);
}