jpayne@68: package bloom;
jpayne@68: 
jpayne@68: import java.io.Serializable;
jpayne@68: import java.util.Locale;
jpayne@68: import java.util.concurrent.atomic.AtomicInteger;
jpayne@68: import java.util.concurrent.atomic.AtomicIntegerArray;
jpayne@68: 
jpayne@68: import dna.AminoAcid;
jpayne@68: import shared.Shared;
jpayne@68: import shared.Tools;
jpayne@68: import structures.ByteBuilder;
jpayne@68: 
jpayne@68: /**
jpayne@68:  * @author Brian Bushnell
jpayne@68:  * @date Jul 5, 2012
jpayne@68:  */
jpayne@68: public abstract class KCountArray implements Serializable {
jpayne@68: 	
jpayne@68: 	/**
jpayne@68: 	 * 
jpayne@68: 	 */
jpayne@68: 	private static final long serialVersionUID = 1590374813059942002L;
jpayne@68: 
jpayne@68: 	public static KCountArray makeNew(long cells_, int cbits_){
jpayne@68: 		return makeNew(cells_, cbits_, 1);
jpayne@68: 	}
jpayne@68: 	
jpayne@68: 	public static KCountArray makeNew(long cells_, int cbits_, int hashes_){
jpayne@68: 		return makeNew(cells_, cbits_, hashes_, null, 0);
jpayne@68: 	}
jpayne@68: 	
jpayne@68: 	//TODO: Get rid of keys_ arg.
jpayne@68: 	public static KCountArray makeNew(long cells_, int cbits_, int hashes_, KCountArray prefilter, int prefilterLimit_){
jpayne@68: 		KCountArray kca=new KCountArray7MTA(cells_, cbits_, hashes_, prefilter, prefilterLimit_);
jpayne@68: 		kca.initialize();
jpayne@68: 		return kca;
jpayne@68: 	}
jpayne@68: 		
jpayne@68: 	protected KCountArray(final long cells_, int cbits_){
jpayne@68: 		assert(cbits_<=32);
jpayne@68: 		assert(Integer.bitCount(cbits_)==1);
jpayne@68: 		assert(Long.bitCount(cells_)==1) || this.getClass()==KCountArray7MT.class : this.getClass();
jpayne@68: 		
jpayne@68: 		numArrays=64;
jpayne@68: 		arrayBits=31-Integer.numberOfLeadingZeros(numArrays);
jpayne@68: 		arrayMask=numArrays-1;
jpayne@68: 		
jpayne@68: 		while(cbits_*cells_<32*numArrays){
jpayne@68: 			assert(false) : cells_+", "+cbits_+", "+numArrays+", "+(cbits_*cells_)+"<"+(32*numArrays);
jpayne@68: 			cbits_*=2;
jpayne@68: 		} //Increases bits per cell so that at minimum each array is size 1
jpayne@68: 		
jpayne@68: 		assert(cbits_<=32);
jpayne@68: 		
jpayne@68: 		cells=cells_;
jpayne@68: 		cellBits=cbits_;
jpayne@68: 		valueMask=(cellBits==32 ? Integer.MAX_VALUE : ~((-1)<<cellBits));
jpayne@68: 		maxValue=min(Integer.MAX_VALUE, ~((-1)<<min(cellBits,31)));
jpayne@68: 		cellsPerWord=32/cellBits;
jpayne@68: 		indexShift=Integer.numberOfTrailingZeros(cellsPerWord);
jpayne@68: 		cellMask=cellsPerWord-1;
jpayne@68: 		
jpayne@68: 		if(verbose){
jpayne@68: 			System.out.println(description());
jpayne@68: 		}
jpayne@68: 	}
jpayne@68: 
jpayne@68: 	protected KCountArray(final long cells_, int cbits_, int arrays_){
jpayne@68: 		assert(cbits_<=32);
jpayne@68: 		assert(Integer.bitCount(cbits_)==1);
jpayne@68: 		assert(Long.bitCount(cells_)==1) || this.getClass()==KCountArray7MT.class || this.getClass()==KCountArray7MTA.class || this.getClass()==KCountArray8MT.class;
jpayne@68: 
jpayne@68: 		numArrays=arrays_;
jpayne@68: 		assert(Integer.bitCount(numArrays)==1) : numArrays+", "+cells_+", "+cbits_;
jpayne@68: 		arrayBits=31-Integer.numberOfLeadingZeros(numArrays);
jpayne@68: 		arrayMask=numArrays-1;
jpayne@68: 
jpayne@68: 		while(cbits_*cells_<32*numArrays){
jpayne@68: 			assert(false) : cells_+", "+cbits_+", "+numArrays+", "+(cbits_*cells_)+"<"+(32*numArrays);
jpayne@68: 			cbits_*=2;
jpayne@68: 		} //Increases bits per cell so that at minimum each array is size 1
jpayne@68: 
jpayne@68: 		assert(cbits_<=32) : "Why?";
jpayne@68: 
jpayne@68: 		cells=cells_;
jpayne@68: 		cellBits=cbits_;
jpayne@68: 		valueMask=(cellBits==32 ? Integer.MAX_VALUE : ~((-1)<<cellBits));
jpayne@68: 		maxValue=min(Integer.MAX_VALUE, ~((-1)<<min(cellBits,31)));
jpayne@68: 		cellsPerWord=32/cellBits;
jpayne@68: 		indexShift=Integer.numberOfTrailingZeros(cellsPerWord);
jpayne@68: 		cellMask=cellsPerWord-1;
jpayne@68: 
jpayne@68: 		if(verbose){
jpayne@68: 			System.out.println(description());
jpayne@68: 		}
jpayne@68: 	}
jpayne@68: 
jpayne@68: 	public abstract int read(long key);
jpayne@68: 	public int read(long keys[]){throw new RuntimeException("Unimplemented.");}
jpayne@68: 	public final int read(long key, int k, boolean makeCanonical){return read(makeCanonical ? makeCanonical2(key, k) : key);}
jpayne@68: 
jpayne@68: 	public abstract void write(long key, int value);
jpayne@68: 
jpayne@68: 	//TODO:  Consider adding a boolean for return old value.
jpayne@68: 	public final void increment(long key){increment(key, 1);}
jpayne@68: 	public final void decrement(long key){decrement(key, 1);}
jpayne@68: 
jpayne@68: 	/** Returns nothing for simplicity. */
jpayne@68: 	public abstract void increment(long key, int incr);
jpayne@68: 	
jpayne@68: 	/** Returns unincremented value */
jpayne@68: 	public abstract int incrementAndReturnUnincremented(long key, int incr);
jpayne@68: 	
jpayne@68: //	/** Returns unincremented value */
jpayne@68: //	public final int incrementAndReturnUnincremented(Kmer kmer, int incr){
jpayne@68: //		return incrementAndReturnUnincremented(kmer.xor(), incr);
jpayne@68: //	}
jpayne@68: 	
jpayne@68: 	//For long kmers.
jpayne@68: 	public int incrementAndReturnUnincremented(long[] keys, int incr){
jpayne@68: 		throw new RuntimeException("Unimplemented.");
jpayne@68: 	}
jpayne@68: 	
jpayne@68: 	/** Optional method. */
jpayne@68: 	public void decrement(long key, int incr){
jpayne@68: 		throw new RuntimeException("This class "+getClass().getName()+" does not support decrement.");
jpayne@68: 	}
jpayne@68: 	
jpayne@68: 	public final int readPrecise(long key, int k, boolean makeCanonical){
jpayne@68: 		assert(k<=32);
jpayne@68: 		int b=read(makeCanonical ? makeCanonical2(key, k) : key);
jpayne@68: 		if(b<1){return b;}
jpayne@68: 		int a=readLeft(key, k, makeCanonical);
jpayne@68: 		if(a>=b){return b;}
jpayne@68: 		int c=readRight(key, k, makeCanonical);
jpayne@68: 		if(c>=b){return b;}
jpayne@68: 		return (int)(((long)a+(long)c)/2);
jpayne@68: //		return max(a, c);
jpayne@68: //		int mid=Tools.min(a, b, c);
jpayne@68: //		System.out.println("a="+a+", b="+b+", c="+c+" -> "+mid);
jpayne@68: //		return mid;
jpayne@68: 	}
jpayne@68: 	
jpayne@68: 	public final int readPreciseMin(long key, int k, boolean makeCanonical){
jpayne@68: 		assert(k<=32);
jpayne@68: 		int b=read(makeCanonical ? makeCanonical2(key, k) : key);
jpayne@68: 		if(b<1){return b;}
jpayne@68: 		int a=readLeft(key, k, makeCanonical);
jpayne@68: 		if(a<1){return a;}
jpayne@68: 		int c=readRight(key, k, makeCanonical);
jpayne@68: 		return Tools.min(a, b, c);
jpayne@68: 	}
jpayne@68: 	
jpayne@68: 	/**
jpayne@68: 	 * @param key Kmer to evaluate
jpayne@68: 	 * @return Sum of counts of all 4 possible left-adjacent kmers
jpayne@68: 	 */
jpayne@68: 	public int readLeft(long key, int k, boolean makeCanonical){throw new RuntimeException("Unsupported.");}
jpayne@68: 	/**
jpayne@68: 	 * @param key Kmer to evaluate
jpayne@68: 	 * @return Sum of counts of all 4 possible right-adjacent kmers
jpayne@68: 	 */
jpayne@68: 	public int readRight(long key, int k, boolean makeCanonical){throw new RuntimeException("Unsupported.");}
jpayne@68: 	/**
jpayne@68: 	 * @param key Kmer to evaluate
jpayne@68: 	 * @return Array of counts of all 4 possible left-adjacent kmers
jpayne@68: 	 */
jpayne@68: 	public int[] readAllLeft(final long key, final int k, boolean makeCanonical, int[] rvec){throw new RuntimeException("Unsupported.");}
jpayne@68: 	/**
jpayne@68: 	 * @param key Kmer to evaluate
jpayne@68: 	 * @return Array of counts of all 4 possible right-adjacent kmers
jpayne@68: 	 */
jpayne@68: 	public int[] readAllRight(final long key, final int k, boolean makeCanonical, int[] rvec){throw new RuntimeException("Unsupported.");}
jpayne@68: 	
jpayne@68: 	public void increment(long[] keys){
jpayne@68: 		synchronized(this){
jpayne@68: 			for(long key : keys){
jpayne@68: 				increment(key);
jpayne@68: 			}
jpayne@68: 		}
jpayne@68: 	}
jpayne@68: 	
jpayne@68: 	public abstract long[] transformToFrequency();
jpayne@68: 	public final long[] transformToFrequency(int[][] matrix){
jpayne@68: 		long[] freq=new long[100000];
jpayne@68: 		int maxFreq=freq.length-1;
jpayne@68: 
jpayne@68: 		if(cellBits!=32){
jpayne@68: 			assert(cellBits>0);
jpayne@68: 			for(int[] array : matrix){
jpayne@68: 				for(int i=0; i<array.length; i++){
jpayne@68: 					int word=array[i];
jpayne@68: 					int j=cellsPerWord;
jpayne@68: 					//				System.out.println("initial: word = "+word+", j = "+Integer.toHexString(j)+", cellbits="+cellBits);
jpayne@68: 					for(; word!=0; j--){
jpayne@68: 						int x=word&valueMask;
jpayne@68: 						int x2=(int)min(x, maxFreq);
jpayne@68: 						freq[x2]++;
jpayne@68: 						word=(word>>>cellBits);
jpayne@68: 						//					System.out.println("word = "+word+", j = "+Integer.toHexString(j)+", cellbits="+cellBits);
jpayne@68: 					}
jpayne@68: 					freq[0]+=j;
jpayne@68: 				}
jpayne@68: 			}
jpayne@68: 		}else{
jpayne@68: 			for(int[] array : matrix){
jpayne@68: 				for(int i=0; i<array.length; i++){
jpayne@68: 					int word=array[i];
jpayne@68: 					int x2=(int)min(word, maxFreq);
jpayne@68: 					freq[x2]++;
jpayne@68: 				}
jpayne@68: 			}
jpayne@68: 		}
jpayne@68: 		return freq;
jpayne@68: 	}
jpayne@68: 	
jpayne@68: 	public final long[] transformToFrequency(AtomicIntegerArray[] matrix){
jpayne@68: 		long[] freq=new long[100000];
jpayne@68: 		int maxFreq=freq.length-1;
jpayne@68: 
jpayne@68: 		if(cellBits!=32){
jpayne@68: 			assert(cellBits>0);
jpayne@68: 			for(AtomicIntegerArray array : matrix){
jpayne@68: 				for(int i=0; i<array.length(); i++){
jpayne@68: 					int word=array.get(i);
jpayne@68: 					int j=cellsPerWord;
jpayne@68: 					//				System.out.println("initial: word = "+word+", j = "+Integer.toHexString(j)+", cellbits="+cellBits);
jpayne@68: 					for(; word!=0; j--){
jpayne@68: 						int x=word&valueMask;
jpayne@68: 						int x2=(int)min(x, maxFreq);
jpayne@68: 						freq[x2]++;
jpayne@68: 						word=(word>>>cellBits);
jpayne@68: 						//					System.out.println("word = "+word+", j = "+Integer.toHexString(j)+", cellbits="+cellBits);
jpayne@68: 					}
jpayne@68: 					freq[0]+=j;
jpayne@68: 				}
jpayne@68: 			}
jpayne@68: 		}else{
jpayne@68: 			for(AtomicIntegerArray array : matrix){
jpayne@68: 				for(int i=0; i<array.length(); i++){
jpayne@68: 					int word=array.get(i);
jpayne@68: 					int x2=(int)min(word, maxFreq);
jpayne@68: 					freq[x2]++;
jpayne@68: 				}
jpayne@68: 			}
jpayne@68: 		}
jpayne@68: 		return freq;
jpayne@68: 	}
jpayne@68: 	
jpayne@68: 	public final ByteBuilder description(){
jpayne@68: 		ByteBuilder sb=new ByteBuilder();
jpayne@68: 		long words=cells/cellsPerWord;
jpayne@68: 		int wordsPerArray=(int)(words/numArrays);
jpayne@68: 		sb.append("cells:   \t"+cells).append('\n');
jpayne@68: 		sb.append("cellBits:\t"+cellBits).append('\n');
jpayne@68: 		sb.append("valueMask:\t"+Long.toHexString(valueMask)).append('\n');
jpayne@68: 		sb.append("maxValue:\t"+maxValue).append('\n');
jpayne@68: 		sb.append("cellsPerWord:\t"+cellsPerWord).append('\n');
jpayne@68: 		sb.append("indexShift:\t"+indexShift).append('\n');
jpayne@68: 		sb.append("words:   \t"+words).append('\n');
jpayne@68: 		sb.append("wordsPerArray:\t"+wordsPerArray).append('\n');
jpayne@68: 		sb.append("numArrays:\t"+numArrays).append('\n');
jpayne@68: 		sb.append("Memory:   \t"+mem()).append('\n');
jpayne@68: 		sb.append("Usage:    \t"+String.format(Locale.ROOT, "%.3f%%",usedFraction()*100));
jpayne@68: 		return sb;
jpayne@68: 	}
jpayne@68: 	
jpayne@68: 	public final String toShortString(){
jpayne@68: 		return "mem = "+mem()+"   \tcells = "+toKMG(cells)+"   \tused = "+String.format(Locale.ROOT, "%.3f%%",usedFraction()*100);
jpayne@68: 	}
jpayne@68: 	
jpayne@68: 	public final String toShortString(int hashes){
jpayne@68: 		return ("hashes = "+hashes+"   \t ")+
jpayne@68: 				"mem = "+mem()+"   \tcells = "+toKMG(cells)+"   \tused = "+String.format(Locale.ROOT, "%.3f%%",usedFraction()*100);
jpayne@68: 	}
jpayne@68: 
jpayne@68: 	@Override
jpayne@68: 	public final String toString(){
jpayne@68: 		return description().toString();
jpayne@68: 	}
jpayne@68: 	
jpayne@68: 	public abstract CharSequence toContentsString();
jpayne@68: 	
jpayne@68: 	public abstract double usedFraction();
jpayne@68: 	
jpayne@68: 	public abstract double usedFraction(int mindepth);
jpayne@68: 	
jpayne@68: 	public abstract long cellsUsed(int mindepth);
jpayne@68: 	
jpayne@68: 	public final double estimateUniqueKmers(int hashes){
jpayne@68: 		double f=usedFraction();
jpayne@68: 		double f2=(1-Math.pow(1-f, 1.0/hashes));
jpayne@68: 		double n=(-cells)*Math.log(1-f2);
jpayne@68: 		return n;
jpayne@68: 	}
jpayne@68: 	
jpayne@68: 	public final double estimateUniqueKmers(int hashes, int mindepth){
jpayne@68: //		assert(false) : this.getClass().getName();
jpayne@68: 		double f=usedFraction(mindepth);
jpayne@68: 		double f2=(1-Math.pow(1-f, 1.0/hashes));
jpayne@68: 		double n=(-cells)*Math.log(1-f2);
jpayne@68: 		return n;
jpayne@68: 	}
jpayne@68: 	
jpayne@68: 	public final double estimateUniqueKmersFromUsedFraction(int hashes, double usedFraction){
jpayne@68: 		double f=usedFraction;
jpayne@68: 		double f2=(1-Math.pow(1-f, 1.0/hashes));
jpayne@68: 		double n=(-cells)*Math.log(1-f2);
jpayne@68: 		return n;
jpayne@68: 	}
jpayne@68: 	
jpayne@68: 	public final String mem(){
jpayne@68: 		long mem=(cells*cellBits)/8;
jpayne@68: 		if(mem<(1<<20)){
jpayne@68: 			return (String.format(Locale.ROOT, "%.2f KB", mem*1d/(1<<10)));
jpayne@68: 		}else if(mem<(1<<30)){
jpayne@68: 			return (String.format(Locale.ROOT, "%.2f MB", mem*1d/(1<<20)));
jpayne@68: 		}else{
jpayne@68: 			return (String.format(Locale.ROOT, "%.2f GB", mem*1d/(1<<30)));
jpayne@68: 		}
jpayne@68: 	}
jpayne@68: 	
jpayne@68: 	public static String toKMG(long x){
jpayne@68: 		double div=1;
jpayne@68: 		String ext="";
jpayne@68: 		if(x>10000000000L){
jpayne@68: 			div=1000000000L;
jpayne@68: 			ext="B";
jpayne@68: 		}else if(x>10000000){
jpayne@68: 			div=1000000;
jpayne@68: 			ext="M";
jpayne@68: 		}else if(x>100000){
jpayne@68: 			div=1000;
jpayne@68: 			ext="K";
jpayne@68: 		}
jpayne@68: 		return String.format(Locale.ROOT, "%.2f", x/div)+ext;
jpayne@68: 	}
jpayne@68: 	
jpayne@68: 	static final AtomicIntegerArray[] allocMatrix(final int numArrays, final int wordsPerArray){
jpayne@68: 		final AtomicIntegerArray[] matrix=new AtomicIntegerArray[numArrays];
jpayne@68: 		final AllocThread[] array=new AllocThread[Tools.min(Tools.max(Shared.threads()/2, 1), numArrays)];
jpayne@68: 		final AtomicInteger next=new AtomicInteger(0);
jpayne@68: 		for(int i=0; i<array.length; i++){
jpayne@68: 			array[i]=new AllocThread(matrix, next, wordsPerArray);
jpayne@68: 		}
jpayne@68: 		for(int i=0; i<array.length; i++){array[i].start();}
jpayne@68: 		for(AllocThread at : array){
jpayne@68: 			while(at.getState()!=Thread.State.TERMINATED){
jpayne@68: 				try {
jpayne@68: 					at.join();
jpayne@68: 				} catch (InterruptedException e) {
jpayne@68: 					// TODO Auto-generated catch block
jpayne@68: 					e.printStackTrace();
jpayne@68: 				}
jpayne@68: 			}
jpayne@68: 		}
jpayne@68: 		return matrix;
jpayne@68: 	}
jpayne@68: 	
jpayne@68: 	private static class AllocThread extends Thread{
jpayne@68: 		
jpayne@68: 		AllocThread(AtomicIntegerArray[] matrix_, AtomicInteger next_, int wordsPerArray_){
jpayne@68: 			matrix=matrix_;
jpayne@68: 			next=next_;
jpayne@68: 			wordsPerArray=wordsPerArray_;
jpayne@68: 		}
jpayne@68: 		
jpayne@68: 		@Override
jpayne@68: 		public void run(){
jpayne@68: 			int x=next.getAndIncrement();
jpayne@68: 			while(x<matrix.length){
jpayne@68: 				matrix[x]=new AtomicIntegerArray(wordsPerArray);
jpayne@68: 				x=next.getAndIncrement();
jpayne@68: 			}
jpayne@68: 		}
jpayne@68: 		
jpayne@68: 		private final AtomicIntegerArray[] matrix;
jpayne@68: 		private final AtomicInteger next;
jpayne@68: 		private final int wordsPerArray;
jpayne@68: 		
jpayne@68: 	}
jpayne@68: 	
jpayne@68: 	
jpayne@68: //	long hash(long x, int y){throw new RuntimeException("Not supported.");}
jpayne@68: 	abstract long hash(long x, int y);
jpayne@68: 	
jpayne@68: 	public static final int min(int x, int y){return x<y ? x : y;}
jpayne@68: 	public static final int max(int x, int y){return x>y ? x : y;}
jpayne@68: 	public static final long min(long x, long y){return x<y ? x : y;}
jpayne@68: 	public static final long max(long x, long y){return x>y ? x : y;}
jpayne@68: 	
jpayne@68: 	/** Any necessary initialization. */
jpayne@68: 	public void initialize(){}
jpayne@68: 	
jpayne@68: 	/** Any necessary shutdown steps. */
jpayne@68: 	public void shutdown(){}
jpayne@68: 	
jpayne@68: 	public final long cells;
jpayne@68: 	public final int cellBits;
jpayne@68: 	/** Originally this was different than valueMask in the case that valueMask was negative, but now they are the same. */
jpayne@68: 	public final int maxValue;
jpayne@68: 	
jpayne@68: 	protected final int cellsPerWord;
jpayne@68: 	protected final int indexShift;
jpayne@68: 	protected final int cellMask;
jpayne@68: 	protected final int valueMask;
jpayne@68: 	
jpayne@68: 	protected static int minArrays=calcMinArrays();
jpayne@68: 	protected final int arrayBits;
jpayne@68: 	protected final int numArrays;
jpayne@68: 	protected final int arrayMask;
jpayne@68: 	
jpayne@68: 	public static boolean verbose=false;
jpayne@68: 	
jpayne@68: 	private static final int calcMinArrays(){
jpayne@68: 		int x=Tools.max(Shared.threads(), 2);
jpayne@68: 		while(Integer.bitCount(x)!=1){x++;}
jpayne@68: 		return x;
jpayne@68: 	}
jpayne@68: 	
jpayne@68: 	public static final boolean isCanonical(long key, int k){
jpayne@68: 		assert(k>3 && k<=32);
jpayne@68: 		long b=AminoAcid.reverseComplementBinaryFast(key, k);
jpayne@68: 		return key>=b;
jpayne@68: 	}
jpayne@68: 	
jpayne@68: 	/** Assumes that the key is not canonical */
jpayne@68: 	public static final long makeCanonical(final long key, final int k){
jpayne@68: 		assert(k>3 && k<=32);
jpayne@68: //		assert(!isCanonical(key, k));
jpayne@68: 		final long r=AminoAcid.reverseComplementBinaryFast(key, k);
jpayne@68: 		assert(r>=key);
jpayne@68: //		assert(isCanonical(r, k));
jpayne@68: //		assert(AminoAcid.reverseComplementBinaryFast(r, k)==key);
jpayne@68: 		return r;
jpayne@68: 	}
jpayne@68: 	
jpayne@68: 	
jpayne@68: 	public static final long makeCanonical2(final long key, final int k){
jpayne@68: 		assert(k>3 && k<=32);
jpayne@68: 		if(isCanonical(key, k)){return key;}
jpayne@68: 		long r=AminoAcid.reverseComplementBinaryFast(key, k);
jpayne@68: //		assert(isCanonical(r, k)) : k+"\n"+Long.toBinaryString(key)+"\n"+Long.toBinaryString(r)+"\n"+Long.toBinaryString(AminoAcid.reverseComplementBinaryFast(r, k));
jpayne@68: //		assert(AminoAcid.reverseComplementBinaryFast(r, k)==key) : k+"\n"+Long.toBinaryString(key)+"\n"+Long.toBinaryString(r)+"\n"+Long.toBinaryString(AminoAcid.reverseComplementBinaryFast(r, k));
jpayne@68: 		return r;
jpayne@68: 	}
jpayne@68: 	
jpayne@68: 	public KCountArray prefilter(){
jpayne@68: 		throw new RuntimeException("TODO: Override");
jpayne@68: 	}
jpayne@68: 	
jpayne@68: 	public void purgeFilter(){
jpayne@68: 		throw new RuntimeException("TODO: Override");
jpayne@68: 	}
jpayne@68: 	
jpayne@68: 	/** Increases accuracy of overloaded multi-bit tables */
jpayne@68: 	public static boolean LOCKED_INCREMENT=false;
jpayne@68: 	public static boolean SET_LOCKED_INCREMENT=false;
jpayne@68: 	
jpayne@68: }