Use IntVec fewer places (prefer native arrays)

Author: JohnMount

Count/src/com/mzlabs/count/divideandconquer/SplitNode.java

@@ -4,7 +4,7 @@
 
 import com.mzlabs.count.NonNegativeIntegralCounter;
 import com.mzlabs.count.op.IntFunc;
-import com.mzlabs.count.op.IntVecFn;
+import com.mzlabs.count.op.CachableCalculation;
 import com.mzlabs.count.op.Reducer;
 import com.mzlabs.count.op.Sequencer;
 import com.mzlabs.count.op.SolnCache;
@@ -14,7 +14,7 @@
 import com.mzlabs.count.op.iter.SeqLE;
 import com.mzlabs.count.util.IntVec;
 
-final class SplitNode implements NonNegativeIntegralCounter,IntVecFn {
+final class SplitNode implements NonNegativeIntegralCounter,CachableCalculation {
 	private final NonNegativeIntegralCounter leftSubSystem;
 	private final NonNegativeIntegralCounter rightSubSystem;
 	private final int[][] A;
@@ -64,11 +64,11 @@ public boolean obviouslyEmpty(final int[] bIn) {
 	}
 
 	@Override
-	public BigInteger eval(final IntVec b) {
+	public BigInteger eval(final int[] b) {
 		final int[] bound = new int[nEntangled];
 		for(int ii=0;ii<nEntangled;++ii) {
 			final int i = entangledRows[ii];
-			bound[ii] = b.get(i);
+			bound[ii] = b[i];
 			if(zeroOne) {
 				int rowSum = 0;
 				for(int j=0;j<n;++j) {
@@ -88,10 +88,10 @@ public BigInteger f(final int[] x) {
 				final int[] b2 = new int[m];
 				for(int i=0;i<m;++i) {
 					if(usesRow[0][i]) {
-						b1[i] = b.get(i);
+						b1[i] = b[i];
 					}
 					if(usesRow[1][i]) {
-						b2[i] = b.get(i);
+						b2[i] = b[i];
 					}
 				}
 				final int[] counter = new int[nEntangled];
@@ -100,7 +100,7 @@ public BigInteger f(final int[] x) {
 					for(int ii=0;ii<nEntangled;++ii) {
 						final int i = entangledRows[ii];
 						b1[i] = counter[ii];
-						b2[i] = b.get(i) - counter[ii];
+						b2[i] = b[i] - counter[ii];
 					}
 					// b1 + b2 == b
 					// add sub1*sub2 terms, but try to avoid calculating sub(i) if sub(1-i) is obviously zero
@@ -126,7 +126,7 @@ public BigInteger f(final int[] x) {
 
 	@Override
 	public BigInteger countNonNegativeSolutions(final int[] b) {
-		return cache.evalCached(this,new IntVec(b));
+		return cache.evalCached(this,b);
 	}
 
 

Count/src/com/mzlabs/count/op/CachableCalculation.java

@@ -0,0 +1,7 @@
+package com.mzlabs.count.op;
+
+import java.math.BigInteger;
+
+public interface CachableCalculation {
+	BigInteger eval(int[] x);
+}

Count/src/com/mzlabs/count/op/IntVecFn.java

@@ -1,9 +1,9 @@
 package com.mzlabs.count.op;
 
 import java.math.BigInteger;
+import java.util.Arrays;
 
 import com.mzlabs.count.op.impl.RecNode;
-import com.mzlabs.count.util.IntVec;
 
 public final class SolnCache {
 	private final int nsub = 100;
@@ -19,16 +19,16 @@ public SolnCache() {
 	/**
 	 * Look for a cached value of f(x), if none such create a record, block on the record and compute f(x) (so only one attempt to compute f(x))
 	 * @param f
-	 * @param x
+	 * @param x not null, x.length>0
 	 * @return
 	 */
-	public BigInteger evalCached(final IntVecFn f, final IntVec x) {
-		int subi = x.hashCode%nsub;
+	public BigInteger evalCached(final CachableCalculation f, final int[] x) {
+		int subi = Arrays.hashCode(x)%nsub;
 		if(subi<0) {
 			subi += nsub;
 		}
 		final RecNode store = stores[subi];
-		final RecNode newHolder = new RecNode(x.get(x.dim()-1));
+		final RecNode newHolder = new RecNode(x[x.length-1]);
 		final RecNode cached;
 		synchronized (newHolder) {
 			synchronized(store) {

Count/src/com/mzlabs/count/op/SolnCache.java

@@ -2,7 +2,6 @@
 
 import java.math.BigInteger;
 
-import com.mzlabs.count.util.IntVec;
 
 /**
  * prefix tree on integer vectors (trying to cut down number of flyweight objects)
@@ -86,17 +85,17 @@ private void put(final RecNode x) {
 	 * @param newNode not null with key==x.get(x.dim()-1) (possible mutex locked)
 	 * @return terminal node to hold value (newNode if there was allocation)
 	 */
-	private static RecNode lookupAlloc(RecNode nd, final IntVec x, final RecNode newNode) {
-		final int n = x.dim();
+	private static RecNode lookupAlloc(RecNode nd, final int[] x, final RecNode newNode) {
+		final int n = x.length;
 		if(n<=0) {
 			throw new IllegalArgumentException("empty x");
 		}
-		if(newNode.key!=x.get(n-1)) {
+		if(newNode.key!=x[n-1]) {
 			throw new IllegalArgumentException("bad new key");
 		}
 		int firstPosn = 0;
 		while(true) {
-			final int key = x.get(firstPosn);
+			final int key = x[firstPosn];
 			RecNode sub = nd.get(key);
 			if(firstPosn>=n-1) {
 				// at terminal case
@@ -123,7 +122,7 @@ private static RecNode lookupAlloc(RecNode nd, final IntVec x, final RecNode new
 	 * @param newNode
 	 * @return
 	 */
-	public RecNode lookupAlloc(final IntVec x, final RecNode newNode) {
+	public RecNode lookupAlloc(final int[] x, final RecNode newNode) {
 		return lookupAlloc(this,x,newNode);
 	}
 

Count/src/com/mzlabs/count/op/impl/RecNode.java

@@ -8,7 +8,7 @@
 import com.mzlabs.count.CountingProblem;
 import com.mzlabs.count.NonNegativeIntegralCounter;
 import com.mzlabs.count.divideandconquer.DivideAndConquerCounter;
-import com.mzlabs.count.op.IntVecFn;
+import com.mzlabs.count.op.CachableCalculation;
 import com.mzlabs.count.op.SolnCache;
 import com.mzlabs.count.op.iter.SeqLE;
 import com.mzlabs.count.op.iter.SeqLT;
@@ -47,7 +47,7 @@
  * @author johnmount
  *
  */
-public final class ZeroOneCounter implements NonNegativeIntegralCounter,IntVecFn {
+public final class ZeroOneCounter implements NonNegativeIntegralCounter,CachableCalculation {
 	private final CountingProblem prob;
 	private final int m;
 	private final ZeroOneStore zeroOneCounts;
@@ -175,17 +175,17 @@ public String toString() {
 	 * @return number of non-negative integer solutions x to A x == b
 	 */
 	@Override
-	public BigInteger eval(final IntVec b) {
+	public BigInteger eval(final int[] b) {
 		BigInteger result = BigInteger.ZERO;
-		final IBPair[] group = zeroOneCounts.lookup(b);
+		final IBPair[] group = zeroOneCounts.lookup(new IntVec(b));
 		if(null!=group) {
 			final int[] bprime = new int[m];
 			for(final IBPair gi: group) {
 				final IntVec r = gi.key;
 				boolean goodR = true;
 				int sum = 0;
 				for(int i=0;i<m;++i) {
-					final int diff = b.get(i) - r.get(i);
+					final int diff = b[i] - r.get(i);
 					if(diff<0) {
 						goodR = false;
 						break;
@@ -195,14 +195,16 @@ public BigInteger eval(final IntVec b) {
 					sum += bpi;
 				}
 				if(goodR) {
-					final BigInteger nzone = gi.value;
+					final BigInteger nzone = gi.value;  // not zero by cache conditions
 					if(sum<=0) { // A x = 0, has one non-negative solution (since a second positive solution would give us a ray of solutions, and we know we are bounded).
 						result = result.add(nzone);
 					} else {
 						final Permutation tobprimeNorm = prob.toNormalForm(bprime);
 						final int[] bprimeNorm = tobprimeNorm.apply(bprime);
 						final BigInteger subsoln = countNonNegativeSolutions(bprimeNorm);
-						result = result.add(nzone.multiply(subsoln));
+						if(subsoln.compareTo(BigInteger.ZERO)!=0) {
+							result = result.add(nzone.multiply(subsoln));
+						}
 					}
 				}
 			}
@@ -228,14 +230,14 @@ public BigInteger countNonNegativeSolutions(final int[] bIn) {
 			}
 			sum += bi;
 		}
-		if(obviouslyEmpty(bIn)) {
+		if(!prob.admissableB(bIn)) {
 			return BigInteger.ZERO;
 		}
-		if(sum<=0) {
+		if(sum<=0) {  // if A x = 0 has either 1, zero or +infinity solutions- we are bounded it is zero or one (and therefore 1 in this case).
 			return BigInteger.ONE;
 		}
 		final Permutation perm = prob.toNormalForm(bIn);
-		final IntVec bNormal = new IntVec(perm.apply(bIn));
+		final int[] bNormal = perm.apply(bIn);
 		final BigInteger result = cache.evalCached(this,bNormal);
 		return result;
 	}