Example usage for java.lang Long numberOfTrailingZeros

List of usage examples for java.lang Long numberOfTrailingZeros

Introduction

In this page you can find the example usage for java.lang Long numberOfTrailingZeros.

Prototype

@HotSpotIntrinsicCandidate
public static int numberOfTrailingZeros(long i) 

Source Link

Document

Returns the number of zero bits following the lowest-order ("rightmost") one-bit in the two's complement binary representation of the specified long value.

Usage

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;
}