/ - Diff - TwistyPuzzleLib - Distorted Android

« Previous | Next »

Revision aa0757b6

Added by Leszek Koltunski about 1 year ago

ID aa0757b6d8f7b60a2c886c4d1d20a48f44c500fc
Parent bdcb662f
Child b9633e5f

Progress with TablebasesPruning

         int twistNum = twist[0] + 3*(twist[2] + 3*(twist[3] + 3*(twist[4] + 3*(twist[5] + 3*twist[6]))));
         int permNum  = TablebaseHelpers.computePermutationNum(perm7);
     if( permNum<0 )
+      {
       android.util.Log.e("D", " permNum="+permNum );
       StringBuilder sb2 = new StringBuilder();
       for(int i=0; i<8; i++) { sb2.append(' '); sb2.append(perm8[i]); }
       android.util.Log.e("D", " perm8="+sb2 );
       StringBuilder sb3 = new StringBuilder();
       for(int i=0; i<8; i++) { sb3.append(' '); sb3.append(quats[i]); }
       android.util.Log.e("D", " quats="+sb3 );
+      }
         return twistNum + 729*permNum;
+        }
+    }

       private int traversePruningBlock(int[][] moves, PruningTable[] tables, int tableIndex, int index, int lastA, int lastR)
+        {
         int movesIndex = 1;
         int[] move = moves[movesIndex];
         int[] tmpQuats = new int[4];
         int[] move, tmpQuats = new int[mNumCubits];
         do
+          {
           move  = moves[movesIndex++];
           index = traverseDownTable(index,tables,tableIndex,lastA,lastR,move,tmpQuats);
           lastA = move[0];
           lastR = move[1];
           tableIndex--;
           movesIndex++;
           move = moves[movesIndex];
+          }
         while( tableIndex>=0 );
-...
             break;
+            }
         if( tableIndex<0 ) return null;
         if( tableIndex<0 )
+          {
           android.util.Log.e("D", "block doesn't contain index "+index);
           return null;
+          }
         int[][] ret = new int[tableIndex+2][4];
         ret[0][1] = tables[0].getLevel()-1;
-...
       private boolean jumpMidZeroRecursive(int index, int jump, int depth, int lastA, int lastR, int[][] solution)
+        {
         int[] quats  = getQuats(index);
         int numQuats = quats.length;
         int[] move   = solution[depth];
         int[] tmp    = new int[mNumCubits];
         int[] quats   = getQuats(index);
         int numQuats  = quats.length;
         int[] move    = solution[depth];
         int[] tmp     = new int[mNumCubits];
         int[][] rotRow= new int[mNumCubits][mNumAxis];
         move[0]=0;
         move[1]=0;
-...
         for(int ax=0; ax<mNumAxis; ax++)
           for(int cubit=0; cubit<mNumCubits; cubit++)
             mRotRow[cubit][ax] = computeRow(mPosition[cubit],quats[cubit],ax);
             rotRow[cubit][ax] = computeRow(mPosition[cubit],quats[cubit],ax);
         for(int s=0; s<mScalingFactor; s++)
+          {
-...
             System.arraycopy(quats, 0, tmp, 0, numQuats);
             for(int cubit=0; cubit<mNumCubits; cubit++)
               if( mRotRow[cubit][ax]==bitLayer )
               if( rotRow[cubit][ax]==bitLayer )
+                {
                 int currQuat = tmp[cubit];
                 int newQuat = getMultQuat(quat,currQuat);
-...
             if( childIndex==0 )
+              {
               android.util.Log.e("D", "1 jumped to mid: index="+childIndex);
               solution[0][0] = childIndex;
               solution[0][1] = 0;
               return true;
-...
             if( containingTable>=0 )
+              {
               android.util.Log.e("D", "2 jumped to mid: index="+childIndex);
               solution[0][0] = childIndex;
               solution[0][1] = mMidTables[containingTable].getLevel();
               return true;
-...
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // ret: [0][] --> (?,old depth,?,?) ; [1...N-1][] --> moves.
     // ret: [0][] --> (num moves,old depth,?,?) ; [1...N-1][] --> moves.
       private int[][] jumpToMidOrZero(int index, int maxJump, int lastA, int lastR)
+        {
         if( midTablesContain(index)>=0 ) return null;
         int[][] solution = new int[maxJump+1][4];
         for(int i=1; i<maxJump; i++)
           if( jumpMidZeroRecursive(index,i,1,lastA,lastR,solution) )
+            {
             solution[0][0] = i;
             return solution;
+            }
         return null;
+        }
-...
         int numQuats = quats.length;
         int[] move   = solution[depth];
         int[] tmp    = new int[mNumCubits];
         android.util.Log.e("D", "trying 0rec: index="+index);
         int[][]rotRow= new int[mNumCubits][mNumAxis];
         move[0]=0;
         move[1]=0;
-...
         for(int ax=0; ax<mNumAxis; ax++)
           for(int cubit=0; cubit<mNumCubits; cubit++)
             mRotRow[cubit][ax] = computeRow(mPosition[cubit],quats[cubit],ax);
             rotRow[cubit][ax] = computeRow(mPosition[cubit],quats[cubit],ax);
     /*
     if( index==1719861 )
+      {
     StringBuilder sb4 = new StringBuilder();
       for(int a=0; a<mNumAxis; a++)
+        {
           for(int c=0; c<mNumCubits; c++)
+            {
             sb4.append(mRotRow[c][a]);
             sb4.append(' ');
+            }
         sb4.append("\n");
+        }
       android.util.Log.e("D", "1 rotRows= \n"+sb4 );
+      }
     */
         for(int s=0; s<mScalingFactor; s++)
+          {
           int ax    = move[0];
-...
             System.arraycopy(quats, 0, tmp, 0, numQuats);
             for(int cubit=0; cubit<mNumCubits; cubit++)
               if( mRotRow[cubit][ax]==bitLayer )
               if( rotRow[cubit][ax]==bitLayer )
+                {
                 int currQuat = tmp[cubit];
                 int newQuat = getMultQuat(quat,currQuat);
                 tmp[cubit] = newQuat;
+                }
     /*
     if( depth==1 && ax==1 && layer==1 && move[2]==3 )
+      {
       StringBuilder sb2 = new StringBuilder();
       for(int i=0; i<8; i++) { sb2.append(' '); sb2.append(quats[i]); }
       android.util.Log.e("D", " quats= "+sb2 );
       StringBuilder sb3 = new StringBuilder();
       for(int i=0; i<8; i++) { sb3.append(' '); sb3.append(tmp[i]); }
       android.util.Log.e("D", " tmpQuats= "+sb3 );
       android.util.Log.e("D", " index= "+index );
+      }
     if( index==1719861 )
+      {
     StringBuilder sb4 = new StringBuilder();
       for(int a=0; a<mNumAxis; a++)
+        {
           for(int c=0; c<mNumCubits; c++)
+            {
             sb4.append(mRotRow[c][a]);
             sb4.append(' ');
+            }
         sb4.append("\n");
+        }
       android.util.Log.e("D", "2 rotRows= \n"+sb4 );
+      }
     */
             int childIndex = getIndex(tmp);
             if( childIndex==0 )
+              {
               android.util.Log.e("D", "END: ax="+ax+" layer="+layer+" angle: "+move[2]);
               return true;
+              }
             if( jump>1 && jumpZeroRecursive(childIndex, jump-1, depth+1, ax, layer, solution) )
+              {
               android.util.Log.e("D", "REC: ax="+ax+" layer="+layer+" angle: "+move[2]);
               return true;
+              }
             if( childIndex==0 ) return true;
             if( jump>1 && jumpZeroRecursive(childIndex, jump-1, depth+1, ax, layer, solution) ) return true;
+            }
           getNextAxisLayerAngleQuat(move);
-...
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // ret: [0][] --> (?,old depth,?,?) ; [1...N-1][] --> moves.
     // ret: [0][] --> (numMoves,old depth,?,?) ; [1...N-1][] --> moves.
       private int[][] jumpToZero(int index, int maxJump, int lastA, int lastR)
+        {
-...
         for(int i=1; i<maxJump; i++)
           if( jumpZeroRecursive(index,i,1,lastA,lastR,solution) )
+            {
             solution[0][0] = i;
             return solution;
+            }
         return null;
+        }
-...
       private int[][] concatenateMoves(int[][] high, int[][] jump1, int[][] mid, int[][] jump2)
+        {
         int len1 = high ==null ? 0 : high.length-1;
         int len2 = jump1==null ? 0 : jump1[0][1];
         int len2 = jump1==null ? 0 : jump1[0][0];
         int len3 = mid  ==null ? 0 : mid.length-1;
         int len4 = jump2==null ? 0 : jump2[0][1];
         int len4 = jump2==null ? 0 : jump2[0][0];
         int[][] moves = new int[len1+len2+len3+len4][];
         int index = 0;
-...
+          }
         else throw new RuntimeException("error traversing mid Tables");
     android.util.Log.e("D", "");
         int[][] jump2Moves = jumpToZero(index,mLowestMid-1,lastA,lastR);
         if( jump2Moves==null ) throw new RuntimeException("2 error jumping to 0");
         return concatenateMoves(highMoves,jump1Moves,midMoves,jump2Moves);

Also available in: Unified diff

Project

General

Profile

TwistyPuzzleLib

Revision aa0757b6

Added by Leszek Koltunski about 1 year ago