simplified

Author: iamrjindal

src/DistancePruningTable.java

@@ -0,0 +1,176 @@
+import java.io.Serializable;
+
+/**
+ * Class that fits 8 bit values (reached or not reached)
+ * into each byte in a list of bytes.
+ * Minimises memory by using one long array (only 8bytes setup cost)
+ * at the cost of increased complexity of implementation
+ * @author Ranulf Green
+ *
+ */
+public class DistancePruningTable implements Serializable{
+	/*
+	 * NOTE:
+	 * never attempt to run both tables at the same time since this will lead to
+	 * a huge memory requirment >400Mbytes
+	 */
+	long[] list;
+	int width;
+	int height;
+	int length;
+	int depth;
+	/**
+	 * design for phase 2 pruning table with only two dimentions
+	 * @param width
+	 * @param height
+	 */
+	public DistancePruningTable(int width, int height){
+		long l = (width*height)/8;
+		long m = (width*height)%8;
+		if( m==0){
+			length = (int) l;
+		}else{
+			length = (int) (l+1);
+		}
+		list = new long[length];
+		this.width = width;
+		this.height = height;
+
+	}
+	/**
+	 * design for phase1 pruning table with three dimensions.
+	 * uses 240Mbytes of memory so will require extended heap space
+	 * @param width
+	 * @param height
+	 * @param depth
+	 */
+	public DistancePruningTable(long width, long height, long depth){
+		long l = (width*height*depth)/8;
+		long m = (width*height*depth)%8;
+		if(m==0){
+			length = (int) l;
+		}else{
+			length = (int) (l+1);
+		}
+		list = new long[length];
+		this.width = (int) width;
+		this.height = (int) height;
+		this.depth = (int) depth;
+	}
+	public DistancePruningTable(long[] list, int width, int height, int depth){
+		this.list = list;
+		this.width = (int) width;
+		this.height = (int) height;
+		this.depth = (int) depth;
+
+	}
+	public DistancePruningTable(long[] list, int width, int height){
+		this.list = list;
+		this.width = (int) width;
+		this.height = (int) height;
+	
+		
+	}
+
+
+
+
+
+
+
+	public static int computeMask(long ww){
+		int bit = (int) (ww%8);
+		switch (bit){
+			case 0:
+				return 1;
+			case 1:
+				return 2;
+			case 2:
+				return 4;
+			case 3:
+				return 8;
+			case 4:
+				return 16;
+			case 5:
+				return 32;
+			case 6:
+				return 64;
+			case 7:
+				return 128;
+
+
+		}
+
+		return 99999;
+
+	}
+
+
+	private void st(long windowplace, int distance){
+
+		int w = (int) (windowplace/8);
+		long window = list[w];
+		// each window (long) is a 64 bit mask and we need to split into 6 bit chunks so we can record a distance in each one rather than a simple match
+
+
+		list[w] = (byte) (window | computeMask(windowplace));
+	}
+
+	public void setReached(int hPlace, int vPlace, int dPlace, int distance){  // EO  CO  UD
+		long ww = ((long)(width*height)*dPlace + width*vPlace + hPlace);
+		st(ww, distance);
+	}
+
+	public void setReached(int hPlace, int vPlace, int distance){
+		long ww = (width*vPlace + hPlace);
+		st(ww, distance);
+	}
+
+	private boolean gt(long windowplace){
+		int w = (int) (windowplace/8);
+		long window = list[w];
+
+
+		int mask = computeMask(windowplace);
+		if ((window & mask) == mask){
+			return true;
+		}else{
+			return false;
+		}
+	}
+
+	public boolean getReached(int hPlace, int vPlace, int dPlace){   // EO  CO  UD
+		long ww = ((long)(width*height)*dPlace + width*vPlace + hPlace);
+		return gt(ww);
+
+	}
+
+	public boolean getReached(int hPlace, int vPlace){
+		long ww = (width*vPlace + hPlace);
+		return gt(ww);
+
+	}
+
+	public void printTable(){
+		for(int i=0;i<list.length;i++){
+			if(list[i]<0){
+				System.out.print((256+list[i]) + " ");
+			}else{
+				System.out.print((list[i]) + " ");
+			}
+		}
+	}
+	public long get(int index){
+		return list[index];
+	}
+	public void set(int index, byte value){
+		list[index] = value;
+	}
+	public int getSize(){
+		return list.length;
+	}
+	public long[] getTable(){
+		return list;
+	}
+	
+}

src/Tester.java

@@ -4,43 +4,43 @@ public class Tester {
 	public static void main(String[] argv){
 
 
-		int i = 0;
+		long i = 0;
 
 		long m = 7;
 
 		System.out.println(8%8);
 
-		i = i | PruningTable.computeMask(m);
+		//i = i | PruningTable.computeMask(m);
 
-		//i = i | 128;
+		i = i |  (long) Math.pow(2,60);
 
-		String s1 = String.format("%8s", Integer.toBinaryString(i & 0xFF)).replace(' ', '0');
+		String s1 = String.format("%64s", Long.toBinaryString(i & 0xFFFFFFFFFFFFFFFFL)).replace(' ', '0');
 		System.out.println(s1); // 10000001
 
 
-		Random r = new Random(System.currentTimeMillis());
-
-		int iters = 10;
-
-		long time = System.currentTimeMillis();
-		for(int j=0;j<iters;j++){
-
-			Cube x = Cube.getRandomCube(r);
-            subCubedCube cc = new subCubedCube((Cube) x.deepCopy());
-            CoOrdinateCube cube = new CoOrdinateCube(cc);
-            TwoPhaseSolver test = new TwoPhaseSolver(cube, cc);
-
-			if(!test.solve()){
-				System.out.println("ERROR");
-				System.exit(0b0);
-			}
-			System.out.println("OUTPUT CUBE: \n");
-			//x.printCube();
-		}
-
-
-
-		System.out.println("AVG TIME(millisec): " + (System.currentTimeMillis()-time)/iters);
+//		Random r = new Random(System.currentTimeMillis());
+//
+//		int iters = 10;
+//
+//		long time = System.currentTimeMillis();
+//		for(int j=0;j<iters;j++){
+//
+//			Cube x = Cube.getRandomCube(r);
+//            subCubedCube cc = new subCubedCube((Cube) x.deepCopy());
+//            CoOrdinateCube cube = new CoOrdinateCube(cc);
+//            TwoPhaseSolver test = new TwoPhaseSolver(cube, cc);
+//
+//			if(!test.solve()){
+//				System.out.println("ERROR");
+//				System.exit(0b0);
+//			}
+//			System.out.println("OUTPUT CUBE: \n");
+//			//x.printCube();
+//		}
+//
+//
+//
+//		System.out.println("AVG TIME(millisec): " + (System.currentTimeMillis()-time)/iters);
 	}
 
 }