Java Code Examples for java.util.BitSet#toLongArray()

public BitSet shiftRight(BitSet bits, int n) {
    long[] words = bits.toLongArray();
    // Expand array if there will be carry bits
    if (words[words.length - 1] >>> n > 0) {
        long[] tmp = new long[words.length + 1];
        System.arraycopy(words, 0, tmp, 0, words.length);
        words = tmp;
    }
    // Do the shift
    for (int i = words.length - 1; i > 0; i--) {
        words[i] <<= n; // Shift current word
        words[i] |= words[i - 1] >>> (64 - n); // Do the carry
    }
    words[0] <<= n; // shift [0] separately, since no carry
    return BitSet.valueOf(words);
}
 

public static void sched_setaffinity(final int pid, final BitSet affinity) {
    final CLibrary lib = CLibrary.INSTANCE;
    final cpu_set_t cpuset = new cpu_set_t();
    final int size = version.isSameOrNewer(VERSION_2_6) ? cpu_set_t.SIZE_OF_CPU_SET_T : NativeLong.SIZE;
    final long[] bits = affinity.toLongArray();
    for (int i = 0; i < bits.length; i++) {
        if (Platform.is64Bit()) {
            cpuset.__bits[i].setValue(bits[i]);
        } else {
            cpuset.__bits[i * 2].setValue(bits[i] & 0xFFFFFFFFL);
            cpuset.__bits[i * 2 + 1].setValue((bits[i] >>> 32) & 0xFFFFFFFFL);
        }
    }
    try {
        if (lib.sched_setaffinity(pid, size, cpuset) != 0) {
            throw new IllegalStateException("sched_setaffinity(" + pid + ", " + size +
                    ", 0x" + Utilities.toHexString(affinity) + ") failed; errno=" + Native.getLastError());
        }
    } catch (LastErrorException e) {
        throw new IllegalStateException("sched_setaffinity(" + pid + ", " + size +
                ", 0x" + Utilities.toHexString(affinity) + ") failed; errno=" + e.getErrorCode(), e);
    }
}
 

@Override
public final Cidr4 recreateKey(final BitSet bits, final int numElements) {

  if (bits.length() == 0) {
    return new Cidr4(0, numElements);
  }

  // Maximum of 32 bits in a Cidr4 (IPv4 based)
  int binary = (int) bits.toLongArray()[0];

  // Shift our bits over if we are not 32 bits long
  final int move = 32 - numElements;
  if (move > 0) {
    binary = binary << move;
  }

  return new Cidr4(binary, numElements);
}
 

public Rank9(BitSet set, long bitCount) {
    long[] bits = set.toLongArray();
    // One zero entry is needed at the end
    bits = Arrays.copyOf(bits, 1 + (int) ((bitCount + 63) / 64));
    this.bits = bits;
    long length = bits.length * 64;
    int numWords = (int) ((length + 63) / 64);
    final int numCounts = (int) ((length + 8 * 64 - 1) / (8 * 64)) * 2;
    counts = new long[numCounts + 1];
    long c = 0;
    int pos = 0;
    for (int i = 0; i < numWords; i += 8, pos += 2) {
        counts[pos] = c;
        c += Long.bitCount(bits[i]);
        for (int j = 1; j < 8; j++) {
            counts[pos + 1] |= (i + j <= numWords ? c - counts[pos] : 0x1ffL) << 9 * (j - 1);
            if (i + j < numWords) {
                c += Long.bitCount(bits[i + j]);
            }
        }
    }
    counts[numCounts] = c;
}
 

public NullComparator(BitSet mask, int count) {
  super();
  this.bigs = mask.toLongArray();
  if(mask.cardinality() == 0){
    mode = Mode.NONE;
    four = 0;
    eight = 0;
  }else{
    if(count > 64){
      mode = Mode.BIG;
      four = 0;
      eight = 0;
    }else if(count > 32){
      mode = Mode.EIGHT;
      four = 0;
      eight = bigs[0];
    } else {
      mode = Mode.FOUR;
      four = (int) bigs[0];
      eight = 0;
    }
  }

}
 

public Rank9(BitSet set, long bitCount) {
    long[] bits = set.toLongArray();
    // One zero entry is needed at the end
    bits = Arrays.copyOf(bits, 1 + (int) ((bitCount + 63) / 64));
    this.bits = bits;
    long length = bits.length * 64;
    int numWords = (int) ((length + 63) / 64);
    int numCounts = (int) ((length + 8 * 64 - 1) / (8 * 64)) * 2;
    counts = new long[numCounts + 1];
    long c = 0;
    int pos = 0;
    for (int i = 0; i < numWords; i += 8, pos += 2) {
        counts[pos] = c;
        c += Long.bitCount(bits[i]);
        for (int j = 1; j < 8; j++) {
            counts[pos + 1] |= (i + j <= numWords ? c - counts[pos] : 0x1ffL) << 9 * (j - 1);
            if (i + j < numWords) {
                c += Long.bitCount(bits[i + j]);
            }
        }
    }
    counts[numCounts] = c;
}
 

private int bitSetToInt(BitSet bitset){
	int intValue = 0;
	BitSet bitsetValue = bitset;
	long[] data = bitsetValue.toLongArray();
	if(data.length==1){
		intValue = (int) data[0];
	}
	return intValue;
}
 

private static String print(BitSet bitSet) {
  StringBuilder buf = new StringBuilder();
  for (long lv: bitSet.toLongArray()) {
    buf.insert(0, Long.toUnsignedString(lv, 2));
  }
  String b = buf.toString();
  int count = bitSet.cardinality();
  return "<html>0b" + ZERO_PAD.substring(b.length()) + b + "<br/> count: " + count;
}
 

public BitSet shiftLeft(BitSet bits, int n) {
	final long[] words = bits.toLongArray();
	// Do the shift
	for (int i = 0; i < words.length - 1; i++) {
		words[i] >>>= n; // Shift current word
		words[i] |= words[i + 1] << (64 - n); // Do the carry
	}
	words[words.length - 1] >>>= n; // shift [words.length-1] separately, since no carry
	return BitSet.valueOf(words);
}
 

@Override
public String toString(BitSet value) {
    StringBuilder builder = new StringBuilder();
    for ( long token : value.toLongArray() ) {
        if ( builder.length() > 0 ) {
            builder.append( DELIMITER );
        }
        builder.append( Long.toString( token, 2 ) );
    }
    return builder.toString();
}
 

@Test
public void testSortKeyTransform() {
  final Random rand = new Random(SEED);
  for (int i = 0; i < NUM_ITERATIONS; i++) {
    // generate random long values representative of 64-bit sort keys
    long val = rand.nextLong();
    final BitSet set = BitSet.valueOf(new long[] {val});
    // clear the first 12 bits of the random long because we truly only
    // get 52-bits of precision (the mantissa) within the IEEE 754 spec
    // which is what we have to work with for Redis Z-Scores
    for (int a = 0; a < 12; a++) {
      set.clear(a);
    }
    val = set.toLongArray()[0];
    // now we have long randomly representing the 52-bits of precision
    // we can work with within a z-score, let's cast to double and make
    // sure we can go back and forth between z-score and sort key
    final double originalScore = val;
    final byte[] originalSortKey = RedisUtils.getSortKey(originalScore);
    assertRepeatedTransform(originalScore, originalSortKey);
    // now check that it still maintains consistency for lower length
    // sort keys
    for (int length = originalSortKey.length - 1; length >= 0; length--) {

      final byte[] newOriginalSortKey = Arrays.copyOf(originalSortKey, length);
      final double newOriginalScore = RedisUtils.getScore(newOriginalSortKey);
      assertRepeatedTransform(newOriginalScore, newOriginalSortKey);
    }
  }
}
 

/**
 * Constructor
 * 
 * @param binary
 *            - binary value of this {@link VINT}, calculated from value if not specified
 * @param length
 *            - length of this {@link VINT}
 * @param value
 *            - value of this {@link VINT}
 */
public VINT(long binary, byte length, long value) {
    if (binary == 0L) {
        BitSet bs = BitSet.valueOf(new long[] { value });
        bs.set(length * BIT_IN_BYTE - length);
        this.binary = bs.toLongArray()[0];
    } else {
        this.binary = binary;
    }
    this.length = length;
    this.value = value;
}
 

/**
 * method to construct {@link VINT} based on its value
 * 
 * @param value
 *            - value of {@link VINT}
 * @return {@link VINT} corresponding to this value
 */
public static VINT fromValue(long value) {
    BitSet bs = BitSet.valueOf(new long[] { value });
    byte length = (byte) (1 + bs.length() / BIT_IN_BYTE);
    if (bs.length() == length * BIT_IN_BYTE) {
        length++;
    }
    bs.set(length * BIT_IN_BYTE - length);
    long binary = bs.toLongArray()[0];
    return new VINT(binary, length, value);
}
 

/**
 * Creates a hexademical representation of the bit set
 *
 * @param set the bit set to convert
 * @return the hexademical string representation
 */
public static String toHexString(final BitSet set) {
    ByteArrayOutputStream out = new ByteArrayOutputStream();
    PrintWriter writer = new PrintWriter(out);
    final long[] longs = set.toLongArray();
    for (long aLong : longs) {
        writer.write(Long.toHexString(aLong));
    }
    writer.flush();

    return new String(out.toByteArray(), java.nio.charset.StandardCharsets.UTF_8);
}
 

public static String toBinaryString(BitSet set) {
    ByteArrayOutputStream out = new ByteArrayOutputStream();
    PrintWriter writer = new PrintWriter(out);
    final long[] longs = set.toLongArray();
    for (long aLong : longs) {
        writer.write(Long.toBinaryString(aLong));
    }
    writer.flush();

    return new String(out.toByteArray(), java.nio.charset.StandardCharsets.UTF_8);
}
 

private byte[] sequenceCode(final double[] minValues, final int length) {

    final double[] minsPerDimension = new double[dimensionCount];
    Arrays.fill(minsPerDimension, 0.0);

    final double[] maxesPerDimension = new double[dimensionCount];
    Arrays.fill(maxesPerDimension, 1.0);

    long cs = 0L;

    for (int i = 0; i < length; i++) {

      final double[] centers = new double[dimensionCount];
      for (int j = 0; j < dimensionCount; j++) {
        centers[j] = (minsPerDimension[j] + maxesPerDimension[j]) / 2.0;
      }

      final BitSet bits = new BitSet(dimensionCount);
      for (int j = dimensionCount - 1; j >= 0; j--) {
        if (minValues[j] >= centers[j]) {
          bits.set(j);
        }
      }
      long bTerm = 0L;
      final long[] longs = bits.toLongArray();
      if (longs.length > 0) {
        bTerm = longs[0];
      }

      cs +=
          1L
              + ((bTerm * (((long) (Math.pow(nthPowerOfTwo, g - i))) - 1L))
                  / ((long) nthPowerOfTwo - 1));

      for (int j = 0; j < dimensionCount; j++) {
        if (minValues[j] < centers[j]) {
          maxesPerDimension[j] = centers[j];
        } else {
          minsPerDimension[j] = centers[j];
        }
      }
    }

    return ByteArrayUtils.longToByteArray(cs);
  }
 

public Set<Integer> getMatchingSlices(ByteString data, int start_slice, int end_slice)
{
  long t1=System.nanoTime();
  while(start_slice % 8 != 0) start_slice--;
  while(end_slice % 8 != 0) end_slice++;
  end_slice = Math.min(end_slice, slices);

  Set<Integer> hashes = getHashIndexes(data);

  BitSet matches = null;
  Set<Integer> match_set = new HashSet<Integer>();

  int count = end_slice - start_slice;
  byte[] b = new byte[count / 8];
  for(int x : hashes)
  {
    long pos = ((long)slices * (long)x + start_slice) / 8L; 
    long t1_read = System.nanoTime();
    long_map.getBytes(pos, b);
    TimeRecord.record(t1_read, "bloom_read");

    long t1_bits = System.nanoTime();
    BitSet bs = BitSet.valueOf(b);
    if (matches == null)
    {
      matches = bs;
    }
    else
    {
      matches.and(bs);
    }
    TimeRecord.record(t1_bits, "bloom_bitkelp");
    if (matches.isEmpty())
    {
      TimeRecord.record(t1,"bloom_getmatch_short");
      return match_set;
    }
  }

  long t1_list=System.nanoTime();

  /*
   * Reading one bit at a time is slow (it was actually taking measurable clock time on a pi 2).
   * So splitting the bitset into longs and on a non-zero checking all those bits.  Quite a bit faster.
   */
  long[] vals = matches.toLongArray();
  for(int idx = 0; idx<vals.length; idx++)
  {
    if (vals[idx] != 0)
    {
      int end = Math.min((idx+1) * 64, slices);
      for(int i= idx * 64; i<end; i++)
      {
        if (matches.get(i)) match_set.add(i + start_slice);
      }

    }

  }
  /*for(int i=0; i<slices; i++)
  {
    if (matches.get(i)) match_set.add(i + start_slice);
  }*/
  TimeRecord.record(t1_list, "bloom_list");
  TimeRecord.record(t1_list, "bloom_slices", slices);

  TimeRecord.record(t1,"bloom_getmatch");
  return match_set;

}