Examples of cern.colt.bitvector.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

  }
  
  @Test
  public final void testIntersects()
  {
    BitVector A=new BitVector(100),B=new BitVector(100);
    Assert.assertFalse(GDLearnerGraph.intersects(A, B));
    A.set(10);
    Assert.assertFalse(GDLearnerGraph.intersects(A, B));
    B.set(10);
    Assert.assertTrue(GDLearnerGraph.intersects(A, B));
    A.clear(10);
    A.set(71);A.set(72);B.set(72);
    Assert.assertTrue(GDLearnerGraph.intersects(A, B));
    A.clear(72);
    Assert.assertFalse(GDLearnerGraph.intersects(A, B));
  }

View Full Code Here

    Map<Label,Integer> inputToInt = new TreeMap<Label,Integer>();
                for(Label str:getAlphabet()) inputToInt.put(str, num++);
    for(Entry<CmpVertex,Map<Label,TARGET_A_TYPE>> entry:graph.transitionMatrix.entrySet())
      if (filter.stateToConsider(entry.getKey()))
      {// ignoring irrelevant-states, for efficiency
        BitVector 
          acceptVector = new BitVector(getAlphabet().size()),
          rejectVector = new BitVector(getAlphabet().size());
        for(Entry<Label,TARGET_A_TYPE> transition:entry.getValue().entrySet())
          for(CmpVertex vert:graph.getTargets(transition.getValue()))
          {
            
            if (!vert.isAccept())
              rejectVector.set(inputToInt.get(transition.getKey()));
            else
              acceptVector.set(inputToInt.get(transition.getKey()));
          }
        inputsAccepted.put(entry.getKey(), acceptVector);
        inputsRejected.put(entry.getKey(), rejectVector);

View Full Code Here


      @Override
      public void handleEntry(Entry<CmpVertex, Map<Label, List<CmpVertex>>> entryA, @SuppressWarnings("unused") int threadNo)
      {// we are never called with entryA which has been filtered out.
        Collection<Entry<Label,List<CmpVertex>>> rowA_collection = matrixInverse.transitionMatrix.get(entryA.getKey()).entrySet();// the "inverse" row
        BitVector inputsAcceptedFromA = inputsAccepted.get(entryA.getKey()), inputsRejectedFromA = inputsRejected.get(entryA.getKey());
        
        // Now iterate through states, pre-filtered during construction of matrixInverse but in the same order 
        // because they are ordered by their IDs and we are using a TreeMap to store 'em.
        Iterator<Entry<CmpVertex,Map<Label,List<CmpVertex>>>> stateB_It = matrixInverse.transitionMatrix.entrySet().iterator();
        while(stateB_It.hasNext())
        {
          Entry<CmpVertex,Map<Label,List<CmpVertex>>> stateB = stateB_It.next();// stateB should not have been filtered out by construction of matrixInverse
          int currentStatePair = vertexToIntNR(stateB.getKey(),entryA.getKey());
          assert prevStatePairNumber < 0 || currentStatePair == prevStatePairNumber+1;prevStatePairNumber=currentStatePair;
          
          // Note that we are iterating state pairs consecutively in an increasing order and 
          // different threads handle non-intersecting ranges of them, hence most of the time,
          // there should be no "cache thrashing".
          BitVector B_accepted=inputsAccepted.get(stateB.getKey()),B_rejected=inputsRejected.get(stateB.getKey());
          if (!AbstractLearnerGraph.checkCompatible(stateB.getKey(), entryA.getKey(), pairCompatibility) ||// relevant in two cases: 
              // (A) if we do not filter any states initially; this is the case where there are states 
              // without outgoing transitions which may be incompatible due to different labelling.
              // (B) some pairs of states are recorded as incompatible
              intersects(inputsAcceptedFromA,B_rejected) || intersects(inputsRejectedFromA,B_accepted))

View Full Code Here

    int num =0;
    Map<String,Integer> inputToInt = new TreeMap<String,Integer>();for(String str:getAlphabet()) inputToInt.put(str, num++);
    for(Entry<CmpVertex,Map<String,TARGET_A_TYPE>> entry:graph.transitionMatrix.entrySet())
      if (filter.stateToConsider(entry.getKey()))
      {// ignoring irrelevant-states, for efficiency
        BitVector 
          acceptVector = new BitVector(getAlphabet().size()),
          rejectVector = new BitVector(getAlphabet().size());
        for(Entry<String,TARGET_A_TYPE> transition:entry.getValue().entrySet())
          for(CmpVertex vert:graph.getTargets(transition.getValue()))
          {
            
            if (!vert.isAccept())
              rejectVector.set(inputToInt.get(transition.getKey()));
            else
              acceptVector.set(inputToInt.get(transition.getKey()));
          }
        inputsAccepted.put(entry.getKey(), acceptVector);
        inputsRejected.put(entry.getKey(), rejectVector);

View Full Code Here


      @Override
      public void handleEntry(Entry<CmpVertex, Map<String, List<CmpVertex>>> entryA, @SuppressWarnings("unused") int threadNo) 
      {// we are never called with entryA which has been filtered out.
        Collection<Entry<String,List<CmpVertex>>> rowA_collection = matrixInverse.transitionMatrix.get(entryA.getKey()).entrySet();// the "inverse" row
        BitVector inputsAcceptedFromA = inputsAccepted.get(entryA.getKey()), inputsRejectedFromA = inputsRejected.get(entryA.getKey());
        
        // Now iterate through states, pre-filtered during construction of matrixInverse but in the same order 
        // because they are ordered by their IDs and we are using a TreeMap to store 'em.
        Iterator<Entry<CmpVertex,Map<String,List<CmpVertex>>>> stateB_It = matrixInverse.transitionMatrix.entrySet().iterator();
        while(stateB_It.hasNext())
        {
          Entry<CmpVertex,Map<String,List<CmpVertex>>> stateB = stateB_It.next();// stateB should not have been filtered out by construction of matrixInverse
          int currentStatePair = vertexToIntNR(stateB.getKey(),entryA.getKey());
          assert prevStatePairNumber < 0 || currentStatePair == prevStatePairNumber+1;prevStatePairNumber=currentStatePair;
          
          // Note that we are iterating state pairs consecutively in an increasing order and 
          // different threads handle non-intersecting ranges of them, hence most of the time,
          // there should be no "cache thrashing".
          BitVector B_accepted=inputsAccepted.get(stateB.getKey()),B_rejected=inputsRejected.get(stateB.getKey());
          if (!AbstractLearnerGraph.checkCompatible(stateB.getKey(), entryA.getKey(), pairCompatibility) ||// relevant in two cases: 
              // (A) if we do not filter any states initially; this is the case where there are states 
              // without outgoing transitions which may be incompatible due to different labelling.
              // (B) some pairs of states are recorded as incompatible
              intersects(inputsAcceptedFromA,B_rejected) || intersects(inputsRejectedFromA,B_accepted))

View Full Code Here

  }
  
  @Test
  public final void testIntersects()
  {
    BitVector A=new BitVector(100),B=new BitVector(100);
    Assert.assertFalse(GDLearnerGraph.intersects(A, B));
    A.set(10);
    Assert.assertFalse(GDLearnerGraph.intersects(A, B));
    B.set(10);
    Assert.assertTrue(GDLearnerGraph.intersects(A, B));
    A.clear(10);
    A.set(71);A.set(72);B.set(72);
    Assert.assertTrue(GDLearnerGraph.intersects(A, B));
    A.clear(72);
    Assert.assertFalse(GDLearnerGraph.intersects(A, B));
  }

View Full Code Here

    int num =0;
    Map<String,Integer> inputToInt = new TreeMap<String,Integer>();for(String str:getAlphabet()) inputToInt.put(str, num++);
    for(Entry<CmpVertex,Map<String,TARGET_A_TYPE>> entry:graph.transitionMatrix.entrySet())
      if (filter.stateToConsider(entry.getKey()))
      {// ignoring irrelevant-states, for efficiency
        BitVector 
          acceptVector = new BitVector(getAlphabet().size()),
          rejectVector = new BitVector(getAlphabet().size());
        for(Entry<String,TARGET_A_TYPE> transition:entry.getValue().entrySet())
          for(CmpVertex vert:graph.getTargets(transition.getValue()))
          {
            
            if (!vert.isAccept())
              rejectVector.set(inputToInt.get(transition.getKey()));
            else
              acceptVector.set(inputToInt.get(transition.getKey()));
          }
        inputsAccepted.put(entry.getKey(), acceptVector);
        inputsRejected.put(entry.getKey(), rejectVector);

View Full Code Here

      int prevStatePairNumber =-1;


      public void handleEntry(Entry<CmpVertex, Map<String, List<CmpVertex>>> entryA, @SuppressWarnings("unused") int threadNo) 
      {// we are never called with entryA which has been filtered out.
        Collection<Entry<String,List<CmpVertex>>> rowA_collection = matrixInverse.transitionMatrix.get(entryA.getKey()).entrySet();// the "inverse" row
        BitVector inputsAcceptedFromA = inputsAccepted.get(entryA.getKey()), inputsRejectedFromA = inputsRejected.get(entryA.getKey());
        
        // Now iterate through states, pre-filtered during construction of matrixInverse but in the same order 
        // because they are ordered by their IDs and we are using a TreeMap to store 'em.
        Iterator<Entry<CmpVertex,Map<String,List<CmpVertex>>>> stateB_It = matrixInverse.transitionMatrix.entrySet().iterator();
        while(stateB_It.hasNext())
        {
          Entry<CmpVertex,Map<String,List<CmpVertex>>> stateB = stateB_It.next();// stateB should not have been filtered out by construction of matrixInverse
          int currentStatePair = vertexToIntNR(stateB.getKey(),entryA.getKey());
          assert prevStatePairNumber < 0 || currentStatePair == prevStatePairNumber+1;prevStatePairNumber=currentStatePair;
          
          // Note that we are iterating state pairs consecutively in an increasing order and 
          // different threads handle non-intersecting ranges of them, hence most of the time,
          // there should be no "cache thrashing".
          BitVector B_accepted=inputsAccepted.get(stateB.getKey()),B_rejected=inputsRejected.get(stateB.getKey());
          if (!AbstractLearnerGraph.checkCompatible(stateB.getKey(), entryA.getKey(), incompatibles) ||// relevant in two cases: 
              // (A) if we do not filter any states initially; this is the case where there are states 
              // without outgoing transitions which may be incompatible due to different labelling.
              // (B) some pairs of states are recorded as incompatible
              intersects(inputsAcceptedFromA,B_rejected) || intersects(inputsRejectedFromA,B_accepted))

View Full Code Here

    int num =0;
    Map<String,Integer> inputToInt = new TreeMap<String,Integer>();for(String str:getAlphabet()) inputToInt.put(str, num++);
    for(Entry<CmpVertex,Map<String,TARGET_A_TYPE>> entry:graph.transitionMatrix.entrySet())
      if (filter.stateToConsider(entry.getKey()))
      {// ignoring irrelevant-states, for efficiency
        BitVector 
          acceptVector = new BitVector(getAlphabet().size()),
          rejectVector = new BitVector(getAlphabet().size());
        for(Entry<String,TARGET_A_TYPE> transition:entry.getValue().entrySet())
          for(CmpVertex vert:graph.getTargets(transition.getValue()))
          {
            
            if (!vert.isAccept())
              rejectVector.set(inputToInt.get(transition.getKey()));
            else
              acceptVector.set(inputToInt.get(transition.getKey()));
          }
        inputsAccepted.put(entry.getKey(), acceptVector);
        inputsRejected.put(entry.getKey(), rejectVector);

View Full Code Here


      @Override
      public void handleEntry(Entry<CmpVertex, Map<String, List<CmpVertex>>> entryA, @SuppressWarnings("unused") int threadNo) 
      {// we are never called with entryA which has been filtered out.
        Collection<Entry<String,List<CmpVertex>>> rowA_collection = matrixInverse.transitionMatrix.get(entryA.getKey()).entrySet();// the "inverse" row
        BitVector inputsAcceptedFromA = inputsAccepted.get(entryA.getKey()), inputsRejectedFromA = inputsRejected.get(entryA.getKey());
        
        // Now iterate through states, pre-filtered during construction of matrixInverse but in the same order 
        // because they are ordered by their IDs and we are using a TreeMap to store 'em.
        Iterator<Entry<CmpVertex,Map<String,List<CmpVertex>>>> stateB_It = matrixInverse.transitionMatrix.entrySet().iterator();
        while(stateB_It.hasNext())
        {
          Entry<CmpVertex,Map<String,List<CmpVertex>>> stateB = stateB_It.next();// stateB should not have been filtered out by construction of matrixInverse
          int currentStatePair = vertexToIntNR(stateB.getKey(),entryA.getKey());
          assert prevStatePairNumber < 0 || currentStatePair == prevStatePairNumber+1;prevStatePairNumber=currentStatePair;
          
          // Note that we are iterating state pairs consecutively in an increasing order and 
          // different threads handle non-intersecting ranges of them, hence most of the time,
          // there should be no "cache thrashing".
          BitVector B_accepted=inputsAccepted.get(stateB.getKey()),B_rejected=inputsRejected.get(stateB.getKey());
          if (!AbstractLearnerGraph.checkCompatible(stateB.getKey(), entryA.getKey(), pairCompatibility) ||// relevant in two cases: 
              // (A) if we do not filter any states initially; this is the case where there are states 
              // without outgoing transitions which may be incompatible due to different labelling.
              // (B) some pairs of states are recorded as incompatible
              intersects(inputsAcceptedFromA,B_rejected) || intersects(inputsRejectedFromA,B_accepted))

View Full Code Here

0 1 2

TOP

Related Classes of cern.colt.bitvector.BitVector

cern.colt.list.MinMaxNumberList

statechum.analysis.learning.linear.GDLearnerGraph

statechum.analysis.learning.linear.TestLinear

statechum.analysis.learning.rpnicore.GDLearnerGraph

statechum.analysis.learning.rpnicore.Linear

statechum.analysis.learning.rpnicore.TestLinear

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.