List of usage examples for java.lang Long numberOfLeadingZeros
@HotSpotIntrinsicCandidate public static int numberOfLeadingZeros(long i)
From source file:org.elasticsearch.common.geo.GeoUtils.java
/** * Calculate the number of levels needed for a specific precision. Quadtree * cells will not exceed the specified size (diagonal) of the precision. * @param meters Maximum size of cells in meters (must greater than zero) * @return levels need to achieve precision *///from w w w . j a v a 2 s . c om public static int quadTreeLevelsForPrecision(double meters) { assert meters >= 0; if (meters == 0) { return QuadPrefixTree.MAX_LEVELS_POSSIBLE; } else { final double ratio = 1 + (EARTH_POLAR_DISTANCE / EARTH_EQUATOR); // cell ratio final double width = Math.sqrt((meters * meters) / (ratio * ratio)); // convert to cell width final long part = Math.round(Math.ceil(EARTH_EQUATOR / width)); final int level = Long.SIZE - Long.numberOfLeadingZeros(part) - 1; // (log_2) return (part <= (1l << level)) ? level : (level + 1); // adjust level } }
From source file:org.renjin.parser.NumericLiterals.java
/** * Finds the closest double-precision floating point number to the given decimal string, parsed by * {@link #parseDoubleDecimal(CharSequence, int, int, int, char)} above. * * <p>This implementation is based on OpenJDK's {@code com.sun.misc.FloatingDecimal.ASCIIToBinaryBuffer.doubleValue()}, * but included here nearly verbatim to avoid a dependency on an internal SDK class. The original code * is copyright 1996, 2013, Oracle and/or its affiliates and licensed under the GPL v2.</p></p> * * @param in the input string/*from ww w .j av a2s. com*/ * @param sign the sign, -1 or +1, parsed above in {@link #parseDouble(CharSequence, int, int, char, boolean)} * @param startIndex the index at which to start parsing * @param endIndex the index, exclusive, at which to stop parsing * @param decimalPoint the decimal point character to use. Generally either '.' or ',' * @return the number as a {@code double}, or {@code NA} if the string is malformatted. */ public static double doubleValue(boolean isNegative, int decExponent, char[] digits, int nDigits) { int kDigits = Math.min(nDigits, MAX_DECIMAL_DIGITS + 1); // // convert the lead kDigits to a long integer. // // (special performance hack: start to do it using int) int iValue = (int) digits[0] - (int) '0'; int iDigits = Math.min(kDigits, INT_DECIMAL_DIGITS); for (int i = 1; i < iDigits; i++) { iValue = iValue * 10 + (int) digits[i] - (int) '0'; } long lValue = (long) iValue; for (int i = iDigits; i < kDigits; i++) { lValue = lValue * 10L + (long) ((int) digits[i] - (int) '0'); } double dValue = (double) lValue; int exp = decExponent - kDigits; // // lValue now contains a long integer with the value of // the first kDigits digits of the number. // dValue contains the (double) of the same. // if (nDigits <= MAX_DECIMAL_DIGITS) { // // possibly an easy case. // We know that the digits can be represented // exactly. And if the exponent isn't too outrageous, // the whole thing can be done with one operation, // thus one rounding error. // Note that all our constructors trim all leading and // trailing zeros, so simple values (including zero) // will always end up here // if (exp == 0 || dValue == 0.0) { return (isNegative) ? -dValue : dValue; // small floating integer } else if (exp >= 0) { if (exp <= MAX_SMALL_TEN) { // // Can get the answer with one operation, // thus one roundoff. // double rValue = dValue * SMALL_10_POW[exp]; return (isNegative) ? -rValue : rValue; } int slop = MAX_DECIMAL_DIGITS - kDigits; if (exp <= MAX_SMALL_TEN + slop) { // // We can multiply dValue by 10^(slop) // and it is still "small" and exact. // Then we can multiply by 10^(exp-slop) // with one rounding. // dValue *= SMALL_10_POW[slop]; double rValue = dValue * SMALL_10_POW[exp - slop]; return (isNegative) ? -rValue : rValue; } // // Else we have a hard case with a positive exp. // } else { if (exp >= -MAX_SMALL_TEN) { // // Can get the answer in one division. // double rValue = dValue / SMALL_10_POW[-exp]; return (isNegative) ? -rValue : rValue; } // // Else we have a hard case with a negative exp. // } } // // Harder cases: // The sum of digits plus exponent is greater than // what we think we can do with one error. // // Start by approximating the right answer by, // naively, scaling by powers of 10. // if (exp > 0) { if (decExponent > MAX_DECIMAL_EXPONENT + 1) { // // Lets face it. This is going to be // Infinity. Cut to the chase. // return (isNegative) ? Double.NEGATIVE_INFINITY : Double.POSITIVE_INFINITY; } if ((exp & 15) != 0) { dValue *= SMALL_10_POW[exp & 15]; } if ((exp >>= 4) != 0) { int j; for (j = 0; exp > 1; j++, exp >>= 1) { if ((exp & 1) != 0) { dValue *= BIG_10_POW[j]; } } // // The reason for the weird exp > 1 condition // in the above loop was so that the last multiply // would get unrolled. We handle it here. // It could overflow. // double t = dValue * BIG_10_POW[j]; if (Double.isInfinite(t)) { // // It did overflow. // Look more closely at the result. // If the exponent is just one too large, // then use the maximum finite as our estimate // value. Else call the result infinity // and punt it. // ( I presume this could happen because // rounding forces the result here to be // an ULP or two larger than // Double.MAX_VALUE ). // t = dValue / 2.0; t *= BIG_10_POW[j]; if (Double.isInfinite(t)) { return (isNegative) ? Double.NEGATIVE_INFINITY : Double.POSITIVE_INFINITY; } t = Double.MAX_VALUE; } dValue = t; } } else if (exp < 0) { exp = -exp; if (decExponent < MIN_DECIMAL_EXPONENT - 1) { // // Lets face it. This is going to be // zero. Cut to the chase. // return (isNegative) ? -0.0 : 0.0; } if ((exp & 15) != 0) { dValue /= SMALL_10_POW[exp & 15]; } if ((exp >>= 4) != 0) { int j; for (j = 0; exp > 1; j++, exp >>= 1) { if ((exp & 1) != 0) { dValue *= TINY_10_POW[j]; } } // // The reason for the weird exp > 1 condition // in the above loop was so that the last multiply // would get unrolled. We handle it here. // It could underflow. // double t = dValue * TINY_10_POW[j]; if (t == 0.0) { // // It did underflow. // Look more closely at the result. // If the exponent is just one too small, // then use the minimum finite as our estimate // value. Else call the result 0.0 // and punt it. // ( I presume this could happen because // rounding forces the result here to be // an ULP or two less than // Double.MIN_VALUE ). // t = dValue * 2.0; t *= TINY_10_POW[j]; if (t == 0.0) { return (isNegative) ? -0.0 : 0.0; } t = Double.MIN_VALUE; } dValue = t; } } // // dValue is now approximately the result. // The hard part is adjusting it, by comparison // with FDBigInteger arithmetic. // Formulate the EXACT big-number result as // bigD0 * 10^exp // if (nDigits > MAX_NDIGITS) { nDigits = MAX_NDIGITS + 1; digits[MAX_NDIGITS] = '1'; } FDBigInteger bigD0 = new FDBigInteger(lValue, digits, kDigits, nDigits); exp = decExponent - nDigits; long ieeeBits = Double.doubleToRawLongBits(dValue); // IEEE-754 bits of double candidate final int B5 = Math.max(0, -exp); // powers of 5 in bigB, value is not modified inside correctionLoop final int D5 = Math.max(0, exp); // powers of 5 in bigD, value is not modified inside correctionLoop bigD0 = bigD0.multByPow52(D5, 0); bigD0.makeImmutable(); // prevent bigD0 modification inside correctionLoop FDBigInteger bigD = null; int prevD2 = 0; correctionLoop: while (true) { // here ieeeBits can't be NaN, Infinity or zero int binexp = (int) (ieeeBits >>> EXP_SHIFT); long bigBbits = ieeeBits & SIGNIF_BIT_MASK; if (binexp > 0) { bigBbits |= FRACT_HOB; } else { // Normalize denormalized numbers. assert bigBbits != 0L : bigBbits; // doubleToBigInt(0.0) int leadingZeros = Long.numberOfLeadingZeros(bigBbits); int shift = leadingZeros - (63 - EXP_SHIFT); bigBbits <<= shift; binexp = 1 - shift; } binexp -= EXP_BIAS; int lowOrderZeros = Long.numberOfTrailingZeros(bigBbits); bigBbits >>>= lowOrderZeros; final int bigIntExp = binexp - EXP_SHIFT + lowOrderZeros; final int bigIntNBits = EXP_SHIFT + 1 - lowOrderZeros; // // Scale bigD, bigB appropriately for // big-integer operations. // Naively, we multiply by powers of ten // and powers of two. What we actually do // is keep track of the powers of 5 and // powers of 2 we would use, then factor out // common divisors before doing the work. // int B2 = B5; // powers of 2 in bigB int D2 = D5; // powers of 2 in bigD int Ulp2; // powers of 2 in halfUlp. if (bigIntExp >= 0) { B2 += bigIntExp; } else { D2 -= bigIntExp; } Ulp2 = B2; // shift bigB and bigD left by a number s. t. // halfUlp is still an integer. int hulpbias; if (binexp <= -EXP_BIAS) { // This is going to be a denormalized number // (if not actually zero). // half an ULP is at 2^-(DoubleConsts.EXP_BIAS+EXP_SHIFT+1) hulpbias = binexp + lowOrderZeros + EXP_BIAS; } else { hulpbias = 1 + lowOrderZeros; } B2 += hulpbias; D2 += hulpbias; // if there are common factors of 2, we might just as well // factor them out, as they add nothing useful. int common2 = Math.min(B2, Math.min(D2, Ulp2)); B2 -= common2; D2 -= common2; Ulp2 -= common2; // do multiplications by powers of 5 and 2 FDBigInteger bigB = FDBigInteger.valueOfMulPow52(bigBbits, B5, B2); if (bigD == null || prevD2 != D2) { bigD = bigD0.leftShift(D2); prevD2 = D2; } // // to recap: // bigB is the scaled-big-int version of our floating-point // candidate. // bigD is the scaled-big-int version of the exact value // as we understand it. // halfUlp is 1/2 an ulp of bigB, except for special cases // of exact powers of 2 // // the plan is to compare bigB with bigD, and if the difference // is less than halfUlp, then we're satisfied. Otherwise, // use the ratio of difference to halfUlp to calculate a fudge // factor to add to the floating value, then go 'round again. // FDBigInteger diff; int cmpResult; boolean overvalue; if ((cmpResult = bigB.cmp(bigD)) > 0) { overvalue = true; // our candidate is too big. diff = bigB.leftInplaceSub(bigD); // bigB is not user further - reuse if ((bigIntNBits == 1) && (bigIntExp > -EXP_BIAS + 1)) { // candidate is a normalized exact power of 2 and // is too big (larger than Double.MIN_NORMAL). We will be subtracting. // For our purposes, ulp is the ulp of the // next smaller range. Ulp2 -= 1; if (Ulp2 < 0) { // rats. Cannot de-scale ulp this far. // must scale diff in other direction. Ulp2 = 0; diff = diff.leftShift(1); } } } else if (cmpResult < 0) { overvalue = false; // our candidate is too small. diff = bigD.rightInplaceSub(bigB); // bigB is not user further - reuse } else { // the candidate is exactly right! // this happens with surprising frequency break correctionLoop; } cmpResult = diff.cmpPow52(B5, Ulp2); if ((cmpResult) < 0) { // difference is small. // this is close enough break correctionLoop; } else if (cmpResult == 0) { // difference is exactly half an ULP // round to some other value maybe, then finish if ((ieeeBits & 1) != 0) { // half ties to even ieeeBits += overvalue ? -1 : 1; // nextDown or nextUp } break correctionLoop; } else { // difference is non-trivial. // could scale addend by ratio of difference to // halfUlp here, if we bothered to compute that difference. // Most of the time ( I hope ) it is about 1 anyway. ieeeBits += overvalue ? -1 : 1; // nextDown or nextUp if (ieeeBits == 0 || ieeeBits == EXP_BIT_MASK) { // 0.0 or Double.POSITIVE_INFINITY break correctionLoop; // oops. Fell off end of range. } continue; // try again. } } if (isNegative) { ieeeBits |= SIGN_BIT_MASK; } return Double.longBitsToDouble(ieeeBits); }
From source file:uk.co.modularaudio.util.math.FastMath.java
public final static int log2(final long n) { if (n <= 0) throw new IllegalArgumentException(); return 63 - Long.numberOfLeadingZeros(n); }