/ - Diff - TwistyPuzzleLib - Distorted Android

« Previous | Next »

Revision a6956092

Added by Leszek Koltunski 10 months ago

ID a69560925236cadd1080cbe8ccb2c8e71ce90d05
Parent f9aa2b72
Child 215d497c

Lots of bugfixes. Solving the white cross rotated by one move works now.

     class MitmTable
+    {
       private final int mBytesPerEntry;
       private final int mBitsPerQuat;
       private final int mNumCubits;
       private final boolean[] mUseCubit;
       private final MitmTableDataStructure mData;
       private int mBytesPerEntry;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       MitmTable(int numCubits, int numQuats)
-...
         mNumCubits = numCubits;
         double tmp = Math.log(numQuats) / Math.log(2);
         mBitsPerQuat = (int)Math.ceil(tmp);
         double numBytes = numCubits*mBitsPerQuat/8.0;
         mBytesPerEntry = (int)Math.ceil(numBytes);  // this many bytes will be needed to store one position
         mUseCubit = new boolean[mNumCubits];
         mData = new MitmTableDataStructure();
+        }
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private String getQuatString(int[] quats)
       static String getQuatString(int[] quats)
+        {
         StringBuilder sb = new StringBuilder();
-...
         return sb.toString();
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       static String getMultiQuatString(int[][] quats)
+        {
         StringBuilder sb = new StringBuilder();
         for( int[] quat : quats)
+          {
           sb.append('[');
           int len = quat==null ? 0 : quat.length;
           for( int q=0; q<len; q++ )
+            {
             sb.append(quat[q]);
             if(q<len-1) sb.append(',');
+            }
           sb.append(']');
           sb.append(' ');
+          }
         return sb.toString();
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private String getSigString(byte[] sig)
       static String getSigString(byte[] sig)
+        {
         StringBuilder sb = new StringBuilder();
-...
         return mBytesPerEntry;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       void setupSize(int[][] endQuats)
+        {
         int numUsedCubits = 0;
         for(int e=0; e<mNumCubits; e++)
+          {
           if( endQuats[e]!=null )
+            {
             numUsedCubits++;
             mUseCubit[e] = true;
+            }
           else
+            {
             mUseCubit[e] = false;
+            }
+          }
         double numBytes = numUsedCubits*mBitsPerQuat/8.0;
         mBytesPerEntry = (int)Math.ceil(numBytes);  // this many bytes will be needed to store one position
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       void build(SolvedObject object, int len)
-...
         boolean thereIsNext;
         int branching = object.getBranchingFactor();
         int[] backward = new int[lenb];
         int[] quats = object.getCubitQuats();
         int[] rem = new int[mNumCubits];
         for(int c=0; c<mNumCubits; c++) rem[c] = quats[c];
         do
+          {
-...
           if( reached!=null )
+            {
             object.setUpStartingQuats(rem);
             int[] forward = new int[lenf];
             int numMoves = reachForward(object,reached,forward,lenf);
             return joinSequences(forward,numMoves,backward);
             return joinSequences(object,forward,numMoves,backward);
+            }
           thereIsNext = getNext(endQuats,indices);
+          }
         while( thereIsNext );
         object.setUpStartingQuats(rem);
         return null;
+        }
-...
             ret[0] = m;
             int numMoves = reachForwardRecursive(object,quats,ret,1,len-1);
             object.backMove(m);
             if( numMoves>=0 ) return numMoves+1;
+            }
+          }
-...
         if( l1==l2 )
+          {
           for(int i=0; i<l1; i++)
             if( q1[i]!=q2[i] ) return false;
+            {
             int a1 = q1[i];
             int a2 = q2[i];
             if( a1!=a2 && a1>=0 && a2>=0 ) return false;
+            }
           return true;
+          }
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private int[] joinSequences(int[] forward, int lenf, int[] backward)
       private int[] joinSequences(SolvedObject object, int[] forward, int lenf, int[] backward)
+        {
         int lenb = backward.length;
-...
         ret[0] = lenf+lenb;
         for(int i=0; i<lenf; i++) ret[1+i     ] = forward[i];
         for(int i=0; i<lenb; i++) ret[1+i+lenf] = backward[i];
         for(int i=0; i<lenb; i++) ret[1+i+lenf] = object.invertMove(backward[i]);
         return ret;
+        }
-...
+        {
         byte[] ret = new byte[mBytesPerEntry];
         for(int q=0; q<mNumCubits; q++)
+          {
           int index = q*mBitsPerQuat/8;
           int offset= q*mBitsPerQuat-index*8;
           int quat  = quats[q];
           int remaining = mBitsPerQuat;
           while(remaining>0)
         for(int c=0, i=0; c<mNumCubits; c++)
           if( mUseCubit[c] )
+            {
             int toBeWritten = remaining+offset>8 ? 8-offset : remaining;
             writePackedByte(ret,index,offset,toBeWritten,remaining,quat);
             remaining -= toBeWritten;
             offset = 0;
             index++;
             int mask = (1<<remaining)-1;
             quat &= mask;
             int index = i*mBitsPerQuat/8;
             int offset= i*mBitsPerQuat-index*8;
             i++;
             int quat  = quats[c];
             int remaining = mBitsPerQuat;
             while(remaining>0)
+              {
               int toBeWritten = remaining+offset>8 ? 8-offset : remaining;
               writePackedByte(ret,index,offset,toBeWritten,remaining,quat);
               remaining -= toBeWritten;
               offset = 0;
               index++;
               int mask = (1<<remaining)-1;
               quat &= mask;
+              }
+            }
+          }
         return ret;
+        }
-...
+        {
         int[] ret = new int[mNumCubits];
         for(int q=0; q<mNumCubits; q++)
         for(int c=0,i=0; c<mNumCubits; c++)
+          {
           int index = q*mBitsPerQuat/8;
           int offset= q*mBitsPerQuat-index*8;
           int index = i*mBitsPerQuat/8;
           int offset= i*mBitsPerQuat-index*8;
           int remaining = mBitsPerQuat;
           while(remaining>0)
           if( mUseCubit[c] )
+            {
             while(remaining>0)
+              {
               byte sig = signature[index];
               int toBeRead = remaining+offset>8 ? 8-offset : remaining;
               readPackedByte(ret,c,toBeRead,sig,offset);
               remaining -= toBeRead;
               offset = 0;
               index++;
+              }
             i++;
+            }
           else
+            {
             byte sig = signature[index];
             int toBeRead = remaining+offset>8 ? 8-offset : remaining;
             readPackedByte(ret,q,toBeRead,sig,offset);
             remaining -= toBeRead;
             offset = 0;
             index++;
             ret[c] = -1;
+            }
+          }

src/main/java/org/distorted/objectlib/algsolvers/MitmTableDataStructure.java
50	50
51	51	///////////////////////////////////////////////////////////////////////////////////////////////////
52	52
53		boolean add(byte[] bytes)
	53	void add(byte[] bytes)
54	54	{
55		return mData.add(new ByteArray(bytes));
	55	mData.add(new ByteArray(bytes));
56	56	}
57	57	}

src/main/java/org/distorted/objectlib/algsolvers/PhaseSolutionFinder.java
45	45
46	46	void prepareForSolution(int[] startingQuats)
47	47	{
48		mForwardDepth = computeForwardDepth();
49	48	mObject.setUpStartingQuats(startingQuats);
50	49	}
51	50
...	...
53	52
54	53	void prepareForPhase(int[][] endQuats)
55	54	{
	55	mForwardDepth = computeForwardDepth(endQuats);
56	56	mBackwardDepth = computeBackwardDepth(endQuats);
57	57	}
58	58
59	59	///////////////////////////////////////////////////////////////////////////////////////////////////
60	60
61		private int computeForwardDepth()
	61	private int computeForwardDepth(int[][] endQuats)
62	62	{
	63	mTable.setupSize(endQuats);
63	64	int bytesPerEntry = mTable.getBytesPerEntry();
64	65	int branchingFactor = mObject.getBranchingFactor();
65	66	int numEntries = MAX_MEMORY/bytesPerEntry;

       private final int mNumQuats;
       private final int mBranchingFactor;
       private final int[][] mMoveTable;
       private final int[] mMoveInterts;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
         mBranchingFactor= computeBranchingFactor();
         mMoveTable      = computeMoveTable();
         int[] quatF     = computeQuatForward();
         int[] quatB     = computeQuatBackward();
         mMoveInterts    = computeMoveInverts();
         mQuatMult = new int[mNumQuats][mNumQuats];
         for(int i=0; i<mNumQuats; i++)
           for(int j=0; j<mNumQuats; j++) mQuatMult[i][j] = mulQuat(i,j);
         int[] quatF = computeQuatForward();
         int[] quatB = computeQuatBackward();
         mCubits = new SolvedObjectCubit(mOrigPos,mAxis,cuts,mQuats,mQuatMult,mMoveTable,quatF,quatB);
+        }
-...
         return true;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       int invertMove(int moveIndex)
+        {
         return mMoveInterts[moveIndex];
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // note the minus in front of the sin() - we rotate counterclockwise
     // when looking towards the direction where the axis increases in values.
       private int makeQuaternionIndex(Static3D axis, int angleInDegrees)
       private int makeQuaternionIndex(int axisIndex, int angleInDegrees)
+        {
         while( angleInDegrees<0 ) angleInDegrees += 360;
         angleInDegrees %= 360;
-...
         float cosA = (float)Math.cos(Math.PI*angleInDegrees/360);
         float sinA =-(float)Math.sqrt(1-cosA*cosA);
         Static3D axis = mAxis[axisIndex];
         float axisX = axis.get0();
         float axisY = axis.get1();
         float axisZ = axis.get2();
-...
         return ret;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private int[] computeMoveInverts()
+        {
         int[] ret = new int[mBranchingFactor];
         for(int i=0; i<mBranchingFactor; i++)
+          {
           int[] move = mMoveTable[i];
           int ax = move[0];
           int row= move[1];
           int ang= move[2];
           int bas= mBasicAngles[ax][row];
           for(int j=0; j<mBranchingFactor; j++)
+            {
             int[] move2 = mMoveTable[j];
             int ax2 = move2[0];
             int row2= move2[1];
             int ang2= move2[2];
             if( ax==ax2 && row==row2 && ang+ang2==bas )
+              {
               ret[i] = j;
               break;
+              }
+            }
+          }
         return ret;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private int[][] computeMoveTable()
-...
+          {
           int[] move = mMoveTable[i];
           int axis   = move[0];
           int row    = move[1];
           int angle  = move[2];
           ret[i] = makeQuaternionIndex(mAxis[axis],angle);
           int basic  = mBasicAngles[axis][row];
           ret[i] = makeQuaternionIndex(axis,-angle*(360/basic));
+          }
         return ret;
-...
+          {
           int[] move = mMoveTable[i];
           int axis   = move[0];
           int angle  =-move[2];
           ret[i] = makeQuaternionIndex(mAxis[axis],angle);
           int row    = move[1];
           int angle  = move[2];
           int basic  = mBasicAngles[axis][row];
           ret[i] = makeQuaternionIndex(axis,angle*(360/basic));
+          }
         return ret;

src/main/java/org/distorted/objectlib/algsolvers/SolvedObjectCubit.java
78	78	for(int c=0; c<mNumCubits; c++)
79	79	{
80	80	int q = mRotQuats[c];
81		int ji = mData[c].jumpIndices[q];
82		int bitmap = mData[ji].rotRowBitmaps[axisIndex];
83		if( (bitmap&rowBitmap) != 0 ) mRotQuats[c] = mQuatMult[quatIndex][q];
	81
	82	if( q>=0 )
	83	{
	84	int ji = mData[c].jumpIndices[q];
	85	int bitmap = mData[ji].rotRowBitmaps[axisIndex];
	86	if( (bitmap&rowBitmap) != 0 ) mRotQuats[c] = mQuatMult[quatIndex][q];
	87	}
84	88	}
85	89	}
86	90
...	...
116	120	}
117	121
118	122	///////////////////////////////////////////////////////////////////////////////////////////////////
	123	// here we set the indices of cubits we don't care about at the moment to -1.
119	124
120	125	void setUpQuats(int[][] quats, int[] indices)
121	126	{
122	127	for(int c=0; c<mNumCubits; c++)
123	128	{
124	129	int[] q = quats[c];
125		if( q!=null ) mRotQuats[c] = q[indices[c]];
	130	mRotQuats[c] = q!=null ? q[indices[c]] : -1;
126	131	}
127	132	}
128	133

Also available in: Unified diff

Project

General

Profile

TwistyPuzzleLib

Revision a6956092

Added by Leszek Koltunski 10 months ago