nice-commit

[Daniel B. <bo...@us...>]

Update of /cvsroot/nice/Nice/src/mlsub/typing/lowlevel
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv27800/src/mlsub/typing/lowlevel

Modified Files:
	BitVector.java 
Log Message:
Revert to 1.4 for now, since later optimizations have changed behaviour 
(having a vector longer than the size, it seems), which are problematic now 
that we need BitMatrix.transpose again. Need to investigate why.


Index: BitVector.java
===================================================================
RCS file: /cvsroot/nice/Nice/src/mlsub/typing/lowlevel/BitVector.java,v
retrieving revision 1.8
retrieving revision 1.9
diff -C2 -d -r1.8 -r1.9
*** BitVector.java	6 Sep 2003 11:31:10 -0000	1.8
--- BitVector.java	26 Mar 2004 16:03:19 -0000	1.9
***************
*** 359,379 ****
        n = bits2length;
      }
! 
!     if (n<=1)
!     {
!        andW(0, ~(S1.getW(0) & S2.getW(0)) | S3.getW(0));
!     }
!     else
!     {
!       int bits3length = S3.length();
!       if (bits3length > n) {
!         bits3length = n;
!       }
! 
!       for (int i = 0; i < bits3length; i++) 
!         bits1[i] &= ~(S1.bits1[i] & S2.bits1[i]) | S3.getW(i);
! 
!       for (int i = bits3length; i < n; i++)       
!         bits1[i] &= ~(S1.bits1[i] & S2.bits1[i]);
      }
    }
--- 359,365 ----
        n = bits2length;
      }
!     int bits3length = S3.length();
!     for (int i = 0; i < n; i++) {
!       andW(i, ~(S1.getW(i) & S2.getW(i)) | (i < bits3length ? S3.getW(i) : 0L));
      }
    }
***************
*** 387,399 ****
      }
      int setLength = set.nonZeroLength();
!     if (setLength > 1) {
!       ensureCapacity(bitIndex(setLength-1));
!       for (int i = setLength; i-- > 0 ;) {
!         bits1[i] |= set.bits1[i];
!       }
      }
!     else
!     {
!       orW(0, set.getW(0));
      }
    }
--- 373,381 ----
      }
      int setLength = set.nonZeroLength();
!     if (setLength > 0) {
!       ensureCapacity(bitIndex(setLength-1));// this might cause some problem...
      }
!     for (int i = setLength; i-- > 0 ;) {
!       orW(i, set.getW(i));
      }
    }
***************
*** 441,445 ****
    /*
     * If there are some trailing zeros, don't count them
-    * result is greater or equal to 1
     */
    private int nonZeroLength() {
--- 423,426 ----
***************
*** 448,452 ****
      
      int n = bits1.length;
!     while (n > 1 && bits1[n-1] == 0L) { n--; }
      return n;
    }
--- 429,433 ----
      
      int n = bits1.length;
!     while (n > 0 && bits1[n-1] == 0L) { n--; }
      return n;
    }
***************
*** 539,552 ****
      else
        {
! 	int n = nonZeroLength();
! 	if (n <= 1)
!         {
! 	  result.bits0 = bits1[0];
! 	}
! 	else
! 	{
! 	  result.bits1 = new long[n];
! 	  System.arraycopy(bits1, 0, result.bits1, 0, n);
! 	}
        }
      return result;
--- 520,527 ----
      else
        {
! 	// optim: shrink to nonZeroLength()?
! 	int n = length();
! 	result.bits1 = new long[n];
! 	System.arraycopy(bits1, 0, result.bits1, 0, n);
        }
      return result;
***************
*** 616,628 ****
    static /* XXX: work around Symantec JIT bug: comment static */
    int chunkLowestSetBit(long chunk) {
!     int bit = 0;
!     chunk &= -chunk; //fix sign bit
!     if ((chunk & 0xffffffff00000000L) != 0 )  bit += 32;
!     if ((chunk & 0xffff0000ffff0000L) != 0 )  bit += 16;
!     if ((chunk & 0xff00ff00ff00ff00L) != 0 )  bit += 8;
!     if ((chunk & 0xf0f0f0f0f0f0f0f0L) != 0 )  bit += 4;
!     if ((chunk & 0xccccccccccccccccL) != 0 )  bit += 2;
!     if ((chunk & 0xaaaaaaaaaaaaaaaaL) != 0 )  bit += 1;
!     return bit;
    }
  
--- 591,606 ----
    static /* XXX: work around Symantec JIT bug: comment static */
    int chunkLowestSetBit(long chunk) {
!     if (chunk == 0L) {
!       return 64;
!     } else {
!       int bit = 0;
!       if ((chunk & 0xffffffffL) == 0) { bit += 32; chunk >>>= 32; }
!       if ((chunk &     0xffffL) == 0) { bit += 16; chunk >>>= 16; }
!       if ((chunk &       0xffL) == 0) { bit +=  8; chunk >>>=  8; }
!       if ((chunk &        0xfL) == 0) { bit +=  4; chunk >>>=  4; }
!       if ((chunk &        0x3L) == 0) { bit +=  2; chunk >>>=  2; }
!       if ((chunk &        0x1L) == 0) { bit++; }
!       return bit;
!     }
    }
  
***************
*** 634,649 ****
     **/
    final public int getLowestSetBit() {
!     if (bits1 == null)
!     {
!       if (bits0 != 0L)
!         return chunkLowestSetBit(bits0);
!     }	
!     else
!     {
!       int n = bits1.length;
!       for (int i = 0; i < n; i++) {
!         long chunk = bits1[i];
!         if (chunk != 0L)
!           return (i << BITS_PER_UNIT) + chunkLowestSetBit(chunk);
        }
      }
--- 612,620 ----
     **/
    final public int getLowestSetBit() {
!     int n = length();
!     for (int i = 0; i < n; i++) {
!       long chunk = getW(i);
!       if (chunk != 0L) {
!         return (i << BITS_PER_UNIT) + chunkLowestSetBit(chunk);
        }
      }
***************
*** 687,691 ****
            return UNDEFINED_INDEX;
          }
!         chunk = bits1[i];
        }
      }
--- 658,662 ----
            return UNDEFINED_INDEX;
          }
!         chunk = getW(i);
        }
      }
***************
*** 697,701 ****
     **/
    public int getNextBit(int i) {
!     return getLowestSetBit(i + 1);
    }
      
--- 668,677 ----
     **/
    public int getNextBit(int i) {
!     int result = getLowestSetBit(i + 1);
!     if (result < 0) {
!       return UNDEFINED_INDEX;
!     } else {
!       return result;
!     }
    }
      
***************
*** 839,860 ****
    final public void truncate(int newSize) {
      int i = subscript(newSize);
!     if (bits1 == null)
!     {
!       if (i == 0)
! 	bits0 &= (1L << (newSize & MASK)) - 1;
!       return;
!     }
!     int bitsLength = nonZeroLength();
!     if (i < bitsLength)
        andW(i, (1L << (newSize & MASK)) - 1);
! 
!     int newlength = Math.min(bitsLength, i+1);
! 
!     if (newlength < bits1.length)
!     {
!       long[] newBits = new long[newlength];
!       System.arraycopy(bits1, 0, newBits, 0, newlength);
!       bits1 = newBits;
      }
    }
  
--- 815,826 ----
    final public void truncate(int newSize) {
      int i = subscript(newSize);
!     int bitsLength = length();
!     if (i < bitsLength) {
        andW(i, (1L << (newSize & MASK)) - 1);
!       for (i++; i < bitsLength; i++) {
!         bits1[i] = 0L;
!       }
      }
+     // XXX: should shrink the vector to lower memory usage ?
    }