Examples of BitVector

cern.colt.bitvector.BitVector
Fixed sized (non resizable) bitvector. Upon instance construction a bitvector is told to hold a fixed number of bits - it's size. The size can be any number (need not be a power of 2 or so). The bits of a BitVector are indexed by nonnegative integers. Any attempt to access a bit at an index<0 || index>=size() will throw an IndexOutOfBoundsException.
Individual indexed bits can be examined, set, or cleared. Subranges can quickly be extracted, copied and replaced. Quick iteration over subranges is provided by optimized internal iterators (forEach() methods). One BitVector may be used to modify the contents of another BitVector through logical AND, OR, XOR and other similar operations.
All operations consider the bits 0..size()-1 and nothing else. Operations involving two bitvectors (like AND, OR, XOR, etc.) will throw an IllegalArgumentException if the secondary bit vector has a size smaller than the receiver.
A BitVector is never automatically resized, but it can manually be grown or shrinked via setSize(...).
For use cases that need to store several bits per information entity, quick accessors are provided that interpret subranges as 64 bit long integers.
Why this class? Fist, boolean[] take one byte per stored bit. This class takes one bit per stored bit. Second, many applications find the semantics of java.util.BitSet not particularly helpful for their needs. Third, operations working on all bits of a bitvector are extremely quick. For example, on NT, Pentium Pro 200 Mhz, SunJDK1.2.2, java -classic, for two bitvectors A,B (both much larger than processor cache), the following results are obtained.
- A.and(B) i.e. A=A & B --> runs at about 35 MB/sec
- A.cardinality(), i.e. determining the selectivity, the number of bits in state "true" --> runs at about 80 MB/sec
- Similar performance for or, xor, andNot, not, copy, replace, partFromTo, indexOf, clear etc.
If you need extremely quick access to individual bits: Although getting and setting individual bits with methods get(...), set(...) and put(...)is quick, it is even quicker (but not safe) to use getQuick(...) and putQuick(...) or even QuickBitVector.
Note that this implementation is not synchronized. @author wolfgang.hoschek@cern.ch @version 1.01, 11/10/99 @see QuickBitVector @see BitMatrix @see java.util.BitSet
com.google.uzaygezen.core.BitVector
Represents a fixed-size bit set. Two bit vectors are equal iff they have the same size and they represent the same bit pattern. In general a bit vector can talk to any other bit vector as long as they have the same size; with the exception of {@link #equals}, {@link #hashCode}, {@link #copyFromSection(BitVector,int)}, {@link #copySectionFrom} and {@link #grayCodeRank}, all other methods accepting a {@link BitVector} parameterfail if the bit vector parameter has a different size. @author Mehmet Akin @author Daniel Aioanei
de.lmu.ifi.dbs.elki.data.BitVector
Provides a BitVector wrapping a BitSet. @author Arthur Zimek
lupos.misc.BitVector
net.agkn.hll.util.BitVector
A vector (array) of bits that is accessed in units ("registers") of width bits which are stored as 64bit "words" (longs). In this context a register is at most 64bits. @author rgrzywinski
net.wimpi.modbus.util.BitVector
Class that implements a collection for bits, storing them packed into bytes. Per default the access operations will index from the LSB (rightmost) bit. @author Dieter Wimberger @version 1.2rc1 (09/11/2004)
net.wimpi.modbusme.util.BitVector
Class that implements a collection for bits, storing them packed into bytes. Per default the access operations will index from the LSB (rightmost) bit. @author Dieter Wimberger @version 1.2rc1 (09/11/2004)
org.apache.drill.exec.vector.BitVector
Bit implements a vector of bit-width values. Elements in the vector are accessed by position from the logical start of the vector. The width of each element is 1 bit. The equivalent Java primitive is an int containing the value '0' or '1'.
org.apache.lucene.util.BitVector
Optimized implementation of a vector of bits. This is more-or-less like java.util.BitSet, but also includes the following:
- a count() method, which efficiently computes the number of one bits;
- optimized read from and write to disk;
- inlinable get() method;
- store and load, as bit set or d-gaps, depending on sparseness;
plan_runner.storage.BitVector
Optimized implementation of a vector of bits. This is more-or-less like java.util.BitSet, but also includes the following: a count() method, which efficiently computes the number of one bits; optimized read from and write to disk; inlinable get() method; @author Doug Cutting @version $Id: BitVector.java,v 1.4 2004/03/29 22:48:05 cutting Exp $
uk.ac.ucl.panda.indexing.io.BitVector
Optimized implementation of a vector of bits. This is more-or-less like java.util.BitSet, but also includes the following:
- a count() method, which efficiently computes the number of one bits;
- optimized read from and write to disk;
- inlinable get() method;
- store and load, as bit set or d-gaps, depending on sparseness;
@version $Id: BitVector.java 564236 2007-08-09 15:21:19Z gsingers $
umontreal.iro.lecuyer.util.BitVector
This class implements vectors of bits and the operations needed to use them. The vectors can be of arbitrary length. The operations provided are all the binary operations available to the int and long primitive types in Java.
All bit operations are present in two forms: a normal form and a self form. The normal form returns a newly created object containing the result, while the self form puts the result in the calling object (this). The return value of the self form is the calling object itself. This is done to allow easier manipulation of the results, making it possible to chain operations.

Examples of lupos.misc.BitVector

      public Bindings next() {
        final Bindings b = itb.next();
        if (b != null) {
          final Iterator<BitVector> ibv = bloomFilters.iterator();
          for (final Variable v : vars) {
            final BitVector bv = ibv.next();
            Literal literal = b.get(v);
            if(literal!=null){
              bv.set((Math.abs(literal.hashCode()) % NUMBEROFBITSFORBLOOMFILTER));
            }
          }
          if (!itb.hasNext()) {
            for (final TriplePattern tp : ctp) {
              // inform triple patterns of bloom filter!
              int i = 0;
              for (final Item item : tp) {
                if (item.isVariable()) {
                  final Iterator<BitVector> ibv2 = bloomFilters
                      .iterator();
                  for (final Variable v : vars) {
                    final BitVector bloomFilter = ibv2
                        .next();
                    if (v.equals(item)) {
                      BitVector[] bfa = tp
                          .getBloomFilters();
                      if (bfa == null) {
                        bfa = new BitVector[3];
                        bfa[i] = bloomFilter;
                      } else {
                        if (bfa[i] != null) {
                          if (!bfa[i]
                              .equals(bloomFilter))
                            for (int j = 0; j < bloomFilter
                                .size(); j++)
                              if (!bloomFilter
                                  .get(j))
                                bfa[i].clear(j);
                        } else
                          bfa[i] = bloomFilter;
                      }

View Full Code Here

Examples of lupos.misc.BitVector

  public Object evaluate(Object[] args) throws TypeErrorException {
    if(args.length==3){
      String value = args[0].toString();
      BigInteger bitVector = Helper.getInteger(args[1]);
      int bitVectorSize = Helper.getInteger(args[2]).intValue();
      BitVector bv = BitVector.getBitVector(bitVector, bitVectorSize);
      if(bv.get(Math.abs(value.hashCode() % bitVectorSize))){
        return Boolean.TRUE;
      } else {
        return Boolean.FALSE;
      }
    } else {

View Full Code Here

Examples of lupos.misc.BitVector

          if(!this.surelyBoundVariablesInServiceCall.contains(variable)){
            result += "((bound("+variable+") && ";
          }
          result +="<http://www.ifis.uni-luebeck.de/functions/BitVectorFilter>("+variable;
          result +=",";
          BitVector bv = new BitVector(FederatedQueryBitVectorJoinNonStandardSPARQL.bitvectorSize);
          while (bindingsIterator.hasNext()) {
            Bindings b = bindingsIterator.next();
            Literal literal = variable.getLiteral(b);
            if(literal!=null){
              oneOrMoreResults=true;
              bv.set(Math.abs(literal.toString().hashCode() % FederatedQueryBitVectorJoinNonStandardSPARQL.bitvectorSize));
            }
          }
          result += bv.getBigInteger().toString()+","+FederatedQueryBitVectorJoinNonStandardSPARQL.bitvectorSize+")";
          if(!this.surelyBoundVariablesInServiceCall.contains(variable)) {
            result += " ))||";
            result += " !bound("+variable+") ";
          }
          if(it.hasNext())

View Full Code Here

Examples of net.agkn.hll.util.BitVector


        // register width 4 (the minimum size)
        { // scoped locally for sanity
            final int regwidth = 4;
            final HLL hll = new HLL(log2m, regwidth, 128/*explicitThreshold, arbitrary, unused*/, 256/*sparseThreshold, arbitrary, unused*/, HLLType.FULL);
            final BitVector bitVector = (BitVector)getInternalState(hll, "probabilisticStorage")/*for testing convenience*/;


            // lower-bounds of the register
            hll.addRaw(0x000000000000001L/*'j'=1*/);
            assertEquals(bitVector.getRegister(1/*'j'*/), 0);


            hll.addRaw(0x0000000000000012L/*'j'=2*/);
            assertEquals(bitVector.getRegister(2/*'j'*/), 1);


            hll.addRaw(0x0000000000000023L/*'j'=3*/);
            assertEquals(bitVector.getRegister(3/*'j'*/), 2);


            hll.addRaw(0x0000000000000044L/*'j'=4*/);
            assertEquals(bitVector.getRegister(4/*'j'*/), 3);


            hll.addRaw(0x0000000000000085L/*'j'=5*/);
            assertEquals(bitVector.getRegister(5/*'j'*/), 4);


            // upper-bounds of the register
            // NOTE:  bear in mind that BitVector itself does ensure that
            //        overflow of a register is prevented
            hll.addRaw(0x0000000000010006L/*'j'=6*/);
            assertEquals(bitVector.getRegister(6/*'j'*/), 13);


            hll.addRaw(0x0000000000020007L/*'j'=7*/);
            assertEquals(bitVector.getRegister(7/*'j'*/), 14);


            hll.addRaw(0x0000000000040008L/*'j'=8*/);
            assertEquals(bitVector.getRegister(8/*'j'*/), 15);


            hll.addRaw(0x0000000000080009L/*'j'=9*/);
            assertEquals(bitVector.getRegister(9/*'j'*/), 15/*overflow*/);


            // sanity checks to ensure that no other bits above the lowest-set
            // bit matters
            // NOTE:  same as case 'j = 6' above
            hll.addRaw(0x000000000003000AL/*'j'=10*/);
            assertEquals(bitVector.getRegister(10/*'j'*/), 13);


            hll.addRaw(0x000000000011000BL/*'j'=11*/);
            assertEquals(bitVector.getRegister(11/*'j'*/), 13);
        }


        // register width 5
        { // scoped locally for sanity
            final int regwidth = 5;
            final HLL hll = new HLL(log2m, regwidth, 128/*explicitThreshold, arbitrary, unused*/, 256/*sparseThreshold, arbitrary, unused*/, HLLType.FULL);
            final BitVector bitVector = (BitVector)getInternalState(hll, "probabilisticStorage")/*for testing convenience*/;


            // lower-bounds of the register
            hll.addRaw(0x0000000000000001L/*'j'=1*/);
            assertEquals(bitVector.getRegister(1/*'j'*/), 0);


            hll.addRaw(0x0000000000000012L/*'j'=2*/);
            assertEquals(bitVector.getRegister(2/*'j'*/), 1);


            hll.addRaw(0x0000000000000023L/*'j'=3*/);
            assertEquals(bitVector.getRegister(3/*'j'*/), 2);


            hll.addRaw(0x0000000000000044L/*'j'=4*/);
            assertEquals(bitVector.getRegister(4/*'j'*/), 3);


            hll.addRaw(0x0000000000000085L/*'j'=5*/);
            assertEquals(bitVector.getRegister(5/*'j'*/), 4);


            // upper-bounds of the register
            // NOTE:  bear in mind that BitVector itself does ensure that
            //        overflow of a register is prevented
            hll.addRaw(0x0000000100000006L/*'j'=6*/);
            assertEquals(bitVector.getRegister(6/*'j'*/), 29);


            hll.addRaw(0x0000000200000007L/*'j'=7*/);
            assertEquals(bitVector.getRegister(7/*'j'*/), 30);


            hll.addRaw(0x0000000400000008L/*'j'=8*/);
            assertEquals(bitVector.getRegister(8/*'j'*/), 31);


            hll.addRaw(0x0000000800000009L/*'j'=9*/);
            assertEquals(bitVector.getRegister(9/*'j'*/), 31/*overflow*/);
        }
    }

View Full Code Here

Examples of net.agkn.hll.util.BitVector

        final int regwidth = 5;
        final int log2m = 4/*16 registers per counter*/;
        final int m = 1 << log2m;


        final HLL hll = new HLL(log2m, regwidth, 128/*explicitThreshold, arbitrary, unused*/, 256/*sparseThreshold, arbitrary, unused*/, HLLType.FULL);
        final BitVector bitVector = (BitVector)getInternalState(hll, "probabilisticStorage")/*for testing convenience*/;
        for(int i=0; i<m; i++)
            bitVector.setRegister(i, i);


        hll.clear();
        for(int i=0; i<m; i++){
            assertEquals(bitVector.getRegister(i), 0L/*default value of register*/);
        }
    }

View Full Code Here

Examples of net.agkn.hll.util.BitVector

    // Assertion Helpers
    /**
     * Asserts that the two HLLs are register-wise equal.
     */
    private static void assertElementsEqual(final HLL hllA, final HLL hllB) {
        final BitVector bitVectorA = (BitVector)getInternalState(hllA, "probabilisticStorage")/*for testing convenience*/;
        final BitVector bitVectorB = (BitVector)getInternalState(hllA, "probabilisticStorage")/*for testing convenience*/;


        final LongIterator iterA = bitVectorA.registerIterator();
        final LongIterator iterB = bitVectorB.registerIterator();


        for(;iterA.hasNext() && iterB.hasNext();) {
            assertEquals(iterA.next(), iterB.next());
        }
        assertFalse(iterA.hasNext());

View Full Code Here

Examples of net.agkn.hll.util.BitVector

                break;
            case SPARSE:
                this.sparseProbabilisticStorage = new Int2ByteOpenHashMap();
                break;
            case FULL:
                this.probabilisticStorage = new BitVector(regwidth, m);
                break;
            default:
                throw new RuntimeException("Unsupported HLL type " + type);
        }
    }

View Full Code Here

Examples of net.wimpi.modbus.util.BitVector

   *
   * @param count the number of response bits as int.
   */
  public void setBitCount(int count) {
    m_BitCount = count;
    m_Discretes = new BitVector(count);
    //set correct length, without counting unitid and fc
    setDataLength(m_Discretes.byteSize() + 1);
  }//setBitCount

View Full Code Here

Examples of net.wimpi.modbusme.util.BitVector

    m_ReadCoilsRequest.setUnitID(unitid);
    m_ReadCoilsRequest.setReference(ref);
    m_ReadCoilsRequest.setBitCount(count);
    m_Transaction.setRequest(m_ReadCoilsRequest);
    m_Transaction.execute();
    BitVector bv = ((ReadCoilsResponse) m_Transaction.getResponse()).getCoils();
    bv.forceSize(count);
    return bv;
  }//readCoils

View Full Code Here

Examples of org.apache.drill.exec.vector.BitVector

    defBuilder
        .setMajorType(typeBuilder.build());
    MaterializedField field = MaterializedField.create(defBuilder.build());


    // Create a new value vector for 1024 integers
    BitVector v = new BitVector(field, allocator);
    BitVector.Mutator m = v.getMutator();
    v.allocateNew(1024);


    // Put and set a few values
    m.set(0, 1);
    m.set(1, 0);
    m.set(100, 0);
    m.set(1022, 1);
    assertEquals(1, v.getAccessor().get(0));
    assertEquals(0, v.getAccessor().get(1));
    assertEquals(0, v.getAccessor().get(100));
    assertEquals(1, v.getAccessor().get(1022));


    // test setting the same value twice
    m.set(0, 1);
    m.set(0, 1);
    m.set(1, 0);
    m.set(1, 0);
    assertEquals(1, v.getAccessor().get(0));
    assertEquals(0, v.getAccessor().get(1));


    // test toggling the values
    m.set(0, 0);
    m.set(1, 1);
    assertEquals(0, v.getAccessor().get(0));
    assertEquals(1, v.getAccessor().get(1));


    // Ensure unallocated space returns 0
    assertEquals(0, v.getAccessor().get(3));
  }

View Full Code Here

0 1 2 3 4 5

TOP

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.