List of usage examples for java.lang Long numberOfTrailingZeros
@HotSpotIntrinsicCandidate public static int numberOfTrailingZeros(long i)
From source file:com.idylwood.utils.MathUtils.java
public static final int precision(final double d) { final long l = Double.doubleToLongBits(d); return Math.max(0, (53 - Long.numberOfTrailingZeros(l))); }
From source file:hybridewah.HybridBitmap.java
/** * get the locations of the true values as one vector. (may use more memory * than iterator())/*from ww w . ja va 2 s . c om*/ * * @return the positions */ public int[] getPositions() { int[] v = new int[this.cardinality()]; if (this.verbatim) { int ntz = 0; long data = 0; int vpos = 0; int pos = 1; for (int i = 0; i < this.actualsizeinwords; i++) { data = this.buffer[i]; //if (data > 0) { while (data != 0) { ntz = Long.numberOfTrailingZeros(data); data ^= (1l << ntz); v[vpos++] = 1 + ntz + pos; // v.add(new Integer(1+ntz + pos)); } pos += 64; //} } return v; } else { final EWAHIterator i = new EWAHIterator(this.buffer, this.actualsizeinwords); int pos = 1; int ntz; int vpos = 0; while (i.hasNext()) { RunningLengthWord localrlw = i.next(); if (localrlw.getRunningBit()) { for (int j = 0; j < localrlw.getRunningLength(); ++j) { for (int c = 0; c < wordinbits; ++c) // v.add(new Integer(pos++)); v[vpos++] = pos++; } } else { pos += wordinbits * localrlw.getRunningLength(); } for (int j = 0; j < localrlw.getNumberOfLiteralWords(); ++j) { long data = i.buffer()[i.literalWords() + j]; while (data != 0) { ntz = Long.numberOfTrailingZeros(data); data ^= (1l << ntz); v[vpos++] = 1 + ntz + pos; // v.add(new Integer(1+ntz + pos)); } pos += wordinbits; } } return v; } }
From source file:hybridewah.HybridBitmap.java
/** * get the locations of the true values as one vector and add the offset to return the position including the offset. (may use more memory * than iterator())//from ww w . j a v a2s. c om * * @return the positions */ public List<Integer> getPositions(int offset) { final ArrayList<Integer> v = new ArrayList<Integer>(); if (this.verbatim) { int ntz = 0; long data = 0; for (int i = 0; i < this.actualsizeinwords; i++) { data = this.buffer[i]; //if (data > 0) { while (data != 0) { ntz = Long.numberOfTrailingZeros(data); data ^= (1l << ntz); v.add(new Integer(1 + ntz + (i * wordinbits)) + offset); } //} } return v; } else { final EWAHIterator i = new EWAHIterator(this.buffer, this.actualsizeinwords); int pos = 1; while (i.hasNext()) { RunningLengthWord localrlw = i.next(); if (localrlw.getRunningBit()) { for (int j = 0; j < localrlw.getRunningLength(); ++j) { for (int c = 0; c < wordinbits; ++c) v.add(new Integer(pos++) + offset); } } else { pos += wordinbits * localrlw.getRunningLength(); } for (int j = 0; j < localrlw.getNumberOfLiteralWords(); ++j) { long data = i.buffer()[i.literalWords() + j]; while (data != 0) { final int ntz = Long.numberOfTrailingZeros(data); data ^= (1l << ntz); v.add(new Integer(ntz + pos) + offset); } pos += wordinbits; } } while ((v.size() > 0) && (v.get(v.size() - 1).intValue() >= this.sizeinbits)) v.remove(v.size() - 1); return v; } }
From source file:hybridewah.HybridBitmap.java
/** * Populate an array of (sorted integers) corresponding to the location of the * set bits.// ww w .j a v a 2s . c om * * @return the array containing the location of the set bits */ public int[] toArray() { int[] ans = new int[this.cardinality()]; int inanspos = 0; int pos = 0; final EWAHIterator i = new EWAHIterator(this.buffer, this.actualsizeinwords); while (i.hasNext()) { RunningLengthWord localrlw = i.next(); if (localrlw.getRunningBit()) { for (int j = 0; j < localrlw.getRunningLength(); ++j) { for (int c = 0; c < wordinbits; ++c) { ans[inanspos++] = pos++; } } } else { pos += wordinbits * localrlw.getRunningLength(); } for (int j = 0; j < localrlw.getNumberOfLiteralWords(); ++j) { long data = i.buffer()[i.literalWords() + j]; if (!usetrailingzeros) { for (int c = 0; c < wordinbits; ++c) { if ((data & (1l << c)) != 0) ans[inanspos++] = c + pos; } pos += wordinbits; } else { while (data != 0) { final int ntz = Long.numberOfTrailingZeros(data); data ^= (1l << ntz); ans[inanspos++] = ntz + pos; } pos += wordinbits; } } } return ans; }
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 www . j a v a 2s . c o m*/ * @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:structuredoutputcbr.adaptation.Adaptation.java
/** * Return a nCk of the exercises <Gosper's Hack> * @param exercises The exercises of the retrieved case. * @param k Of combinations to be generated. * @return A list of list which all possible combinations. *//*from w ww .ja v a2 s. co m*/ private ArrayList nCr(ArrayList exercises, int k) { ArrayList result = new ArrayList(); int x = (1 << k) - 1; int limit = (1 << exercises.size()); while (x < limit) { long y = x; ArrayList combination = new ArrayList(); for (int i = Long.numberOfTrailingZeros(y); y != 0; i = Long.numberOfTrailingZeros(y)) { combination.add(exercises.get(i)); y &= ~(1 << i); } result.add(combination); int c = x & -x; int r = x + c; x = (((r ^ x) >>> 2) / c) | r; } return result; }