commit 673c1a118ae05b8d0c8d34ea15ef4dc0ab9acc2e Author: Leszek Koltunski Date: Mon Apr 17 02:26:54 2023 +0200 CU_323 solver: progress diff --git a/src/main/java/org/distorted/solvers/SolverCuboid323.java b/src/main/java/org/distorted/solvers/SolverCuboid323.java index 7d290dce..a1d32c9f 100644 --- a/src/main/java/org/distorted/solvers/SolverCuboid323.java +++ b/src/main/java/org/distorted/solvers/SolverCuboid323.java @@ -16,6 +16,7 @@ import org.distorted.objectlib.helpers.OperatingSystemInterface; import org.distorted.objectlib.main.ObjectSignatures; import org.distorted.objectlib.main.TwistyObject; import org.distorted.objectlib.tablebases.ImplementedTablebasesList; +import org.distorted.objectlib.tablebases.TablebaseHelpers; import org.distorted.objectlib.tablebases.TablebasesAbstract; /////////////////////////////////////////////////////////////////////////////////////////////////// @@ -34,137 +35,53 @@ public class SolverCuboid323 extends SolverTablebase private boolean mUpper; /////////////////////////////////////////////////////////////////////////////////////////////////// +// if mUpper==true, then the edge3 is the 'half-fixed' front edge. Remove it from the permutation. +// Otherwise edge1 is the one; remove it. - private int edgeIs(int[] edge, int i0, int i1) - { - int c0 = mFaceColors[i0]; - int c1 = mFaceColors[i1]; - - if( edge[0]==c0 && edge[1]==c1 ) return 0; - if( edge[0]==c1 && edge[1]==c0 ) return 1; - return 2; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private int retEdgePermutation(int[] output, int[][] edges) + private int[] correctEdgePerm(int[] perm) { - for(int i=0; i<4; i++) output[i] = -1; + int val; + int[] ret = new int[7]; - for(int i=0; i<4; i++) + if( mUpper ) { - int edge0 = edgeIs(edges[i],1,5); - if( edge0==0 ) output[0]=i; - else if( edge0==1 ) return ERROR_EDGE_TWISTED; - - int edge1 = edgeIs(edges[i],1,4); - if( edge1==0 ) output[1]=i; - else if( edge1==1 ) return ERROR_EDGE_TWISTED; - - int edge2 = edgeIs(edges[i],0,5); - if( edge2==0 ) output[2]=i; - else if( edge2==1 ) return ERROR_EDGE_TWISTED; - - int edge3 = edgeIs(edges[i],0,4); - if( edge3==0 ) output[3]=i; - else if( edge3==1 ) return ERROR_EDGE_TWISTED; + ret[0] = perm[0]; + ret[1] = perm[1]; + ret[2] = perm[2]; + ret[3] = perm[4]; + ret[4] = perm[5]; + ret[5] = perm[6]; + ret[6] = perm[7]; + + val = perm[3]; } -/* - if( output[0]==-1 ) return ERROR_EDGE_15_MISSING; - if( output[1]==-1 ) return ERROR_EDGE_14_MISSING; - if( output[2]==-1 ) return ERROR_EDGE_05_MISSING; - if( output[3]==-1 ) return ERROR_EDGE_04_MISSING; -*/ - return 0; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private int cornerIs(int[] corner, int i0, int i1, int i2) - { - int c0 = mFaceColors[i0]; - int c1 = mFaceColors[i1]; - int c2 = mFaceColors[i2]; - - if( corner[0]==c0 && corner[1]==c1 && corner[2]==c2 ) return 0; - - if( corner[0]==c0 && corner[1]==c2 && corner[2]==c1 || - corner[0]==c1 && corner[1]==c0 && corner[2]==c2 || - corner[0]==c1 && corner[1]==c2 && corner[2]==c0 || - corner[0]==c2 && corner[1]==c0 && corner[2]==c1 || - corner[0]==c2 && corner[1]==c1 && corner[2]==c0 ) return 1; - - return 2; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private int retCornerPermutation(int[] output, int[][] corners) - { - for(int i=0; i<8; i++) output[i] = -1; - - for(int i=0; i<8; i++) + else { - int corner7 = cornerIs(corners[i],2,4,0); - if( corner7==0 ) output[7]=i; - else if( corner7==1 ) return ERROR_CORNER_TWISTED; - - int corner6 = cornerIs(corners[i],2,0,5); - if( corner6==0 ) output[6]=i; - else if( corner6==1 ) return ERROR_CORNER_TWISTED; - - int corner5 = cornerIs(corners[i],3,0,4); - if( corner5==0 ) output[5]=i; - else if( corner5==1 ) return ERROR_CORNER_TWISTED; - - int corner4 = cornerIs(corners[i],3,5,0); - if( corner4==0 ) output[4]=i; - else if( corner4==1 ) return ERROR_CORNER_TWISTED; - - int corner3 = cornerIs(corners[i],2,1,4); - if( corner3==0 ) output[3]=i; - else if( corner3==1 ) return ERROR_CORNER_TWISTED; - - int corner2 = cornerIs(corners[i],2,5,1); - if( corner2==0 ) output[2]=i; - else if( corner2==1 ) return ERROR_CORNER_TWISTED; + ret[0] = perm[0]; + ret[1] = perm[2]; + ret[2] = perm[3]; + ret[3] = perm[4]; + ret[4] = perm[5]; + ret[5] = perm[6]; + ret[6] = perm[7]; + + val = perm[1]; + } - int corner1 = cornerIs(corners[i],3,4,1); - if( corner1==0 ) output[1]=i; - else if( corner1==1 ) return ERROR_CORNER_TWISTED; + for(int i=0; i<7; i++) + if( ret[i]>val ) ret[i]--; - int corner0 = cornerIs(corners[i],3,1,5); - if( corner0==0 ) output[0]=i; - else if( corner0==1 ) return ERROR_CORNER_TWISTED; - } -/* - if( output[0]==-1 ) return ERROR_CORNER_135_MISSING; - if( output[1]==-1 ) return ERROR_CORNER_134_MISSING; - if( output[2]==-1 ) return ERROR_CORNER_125_MISSING; - if( output[3]==-1 ) return ERROR_CORNER_124_MISSING; - if( output[4]==-1 ) return ERROR_CORNER_035_MISSING; - if( output[5]==-1 ) return ERROR_CORNER_034_MISSING; - if( output[6]==-1 ) return ERROR_CORNER_025_MISSING; - if( output[7]==-1 ) return ERROR_CORNER_024_MISSING; -*/ - return 0; + return ret; } /////////////////////////////////////////////////////////////////////////////////////////////////// +// 0 or 1, depending on if the 'half-fixed' front edge is in its place or not. +// if the 'half-fixed' edge is the upped front one ( i.e. mUpper==true) than it can be in its +// place or not; if mUpper==false it always must be in its place. - private int[] correctEdgePerm(int[] perm) + private boolean isFrontEdgeInItsPlace(int[][] edges) { - int[] ret = new int[3]; - - ret[0] = perm[0]; - ret[1] = perm[2]; - ret[2] = perm[3]; - - if( ret[0]>1 ) ret[0]--; - if( ret[1]>1 ) ret[1]--; - if( ret[2]>1 ) ret[2]--; - - return ret; + return (!mUpper || edges[3][1]==mFaceColors[2]); } /////////////////////////////////////////////////////////////////////////////////////////////////// @@ -217,10 +134,11 @@ public class SolverCuboid323 extends SolverTablebase int c0 = mFaceColors[f0]; int c1 = mFaceColors[f1]; - for(int[] edge : edges) + for(int i=0; i<8; i++ ) { - if( edge[0]==c0 && edge[1]==c1 ) - return 0; + int[] edge = edges[i]; + + if( edge[0]==c0 && edge[1]==c1 ) return i; if( edge[0]==c1 && edge[1]==c0 ) { mErrorColor1 = c0; @@ -242,9 +160,11 @@ public class SolverCuboid323 extends SolverTablebase int c1 = mFaceColors[f1]; int c2 = mFaceColors[f2]; - for(int[] corner : corners ) + for(int i=0; i<8; i++) { - if( corner[0]==c0 && corner[1]==c1 && corner[2]==c2 ) return 0; + int[] corner = corners[i]; + + if( corner[0]==c0 && corner[1]==c1 && corner[2]==c2 ) return i; if( (corner[0]==c1 && corner[1]==c2 && corner[2]==c0 ) || (corner[0]==c2 && corner[1]==c0 && corner[2]==c1 ) ) { @@ -263,52 +183,32 @@ public class SolverCuboid323 extends SolverTablebase //////////////////////////////////////////////////////////////////////////////////////// - private int checkAllEdgesPresent(int[][] edges) + private int retEdgePermutation(int[] output, int[][] edges) { - int result; - - result = edgePresent(edges,0,2); - if( result<0 ) return result; - result = edgePresent(edges,1,2); - if( result<0 ) return result; - result = edgePresent(edges,4,2); - if( result<0 ) return result; - result = edgePresent(edges,5,2); - if( result<0 ) return result; - result = edgePresent(edges,0,3); - if( result<0 ) return result; - result = edgePresent(edges,1,3); - if( result<0 ) return result; - result = edgePresent(edges,4,3); - if( result<0 ) return result; - result = edgePresent(edges,5,3); - if( result<0 ) return result; + int[][] e = { {5,3}, {4,3}, {5,2}, {4,2}, {1,3}, {1,2}, {0,3}, {0,2} }; + + for(int i=0; i<8; i++) + { + int[] ee = e[i]; + output[i] = edgePresent(edges,ee[0],ee[1]); + if( output[i]<0 ) return output[i]; + } return 0; } //////////////////////////////////////////////////////////////////////////////////////// - private int checkAllCornersPresent(int[][] corners) + private int retCornerPermutation(int[] output, int[][] corners) { - int result; - - result = cornerPresent(corners,0,4,2); - if( result<0 ) return result; - result = cornerPresent(corners,5,0,2); - if( result<0 ) return result; - result = cornerPresent(corners,1,5,2); - if( result<0 ) return result; - result = cornerPresent(corners,4,1,2); - if( result<0 ) return result; - result = cornerPresent(corners,4,0,3); - if( result<0 ) return result; - result = cornerPresent(corners,0,5,3); - if( result<0 ) return result; - result = cornerPresent(corners,5,1,3); - if( result<0 ) return result; - result = cornerPresent(corners,1,4,3); - if( result<0 ) return result; + int[][] c = { {5,1,3}, {1,4,3}, {1,5,2}, {4,1,2}, {0,5,3}, {4,0,3}, {5,0,2}, {0,4,2} }; + + for(int i=0; i<8; i++) + { + int[] cc = c[i]; + output[i] = cornerPresent(corners,cc[0],cc[1],cc[2]); + if( output[i]<0 ) return output[i]; + } return 0; } @@ -428,36 +328,34 @@ public class SolverCuboid323 extends SolverTablebase getCenters(object,centers); for(int i=0; i<8; i++) android.util.Log.e("D", "corner: "+i+" : "+corners[i][0]+" "+corners[i][1]+" "+corners[i][2]); +for(int i=0; i<8; i++) android.util.Log.e("D", "edge: "+i+" : "+edges[i][0]+" "+edges[i][1]); int result0 = computeFaceColors(corners, edges, centers); if( result0<0 ) return result0; - int result1 = checkAllEdgesPresent(edges); + int[] corner_perm = new int[8]; + int result1 = retCornerPermutation(corner_perm,corners); if( result1<0 ) return result1; - int result2 = checkAllCornersPresent(corners); - if( result2<0 ) return result2; - android.util.Log.e("D", "upper: "+mUpper); for(int i=0; i<6; i++) android.util.Log.e("D", "face color: "+mFaceColors[i]); -/* - int[] corner_perm = new int[8]; - int result1 = retCornerPermutation(corner_perm,corners); - if( result1<0 ) return result1; int[] edge_perm = new int[8]; int result2 = retEdgePermutation(edge_perm,edges); if( result2<0 ) return result2; - int[] edge_perm2 = correctEdgePerm(edge_perm); // edge1 is fixed! + TablebaseHelpers.displayTable(corner_perm, "CORNER PERM"); + TablebaseHelpers.displayTable(edge_perm, "EDGE PERM"); + + int[] edge_perm2 = correctEdgePerm(edge_perm); // edge1 (lower) or edge3 (upper) is fixed! int corner_perm_num = TablebaseHelpers.computePermutationNum(corner_perm); int edge_perm_num = TablebaseHelpers.computePermutationNum(edge_perm2); + boolean inPlace = isFrontEdgeInItsPlace(edges); - return edge_perm_num + 6*corner_perm_num; +android.util.Log.e("D", "corner_perm_num: "+corner_perm_num+" edge_perm_num: "+edge_perm_num+" inPlace: "+inPlace); - */ - return 0; + return corner_perm_num + 20160*( (inPlace?0:1) + 2*edge_perm_num); } ///////////////////////////////////////////////////////////////////////////////////////////////////