/ - Diff - TwistyPuzzleLib - Distorted Android

src/main/java/org/distorted/objectlib/tablebases/TBDino6.java
20	20	private static final int SOLVED2 = 17977621; // quats (0,10,0,10, 11,11,11,11, 0,10,0,10)
21	21
22	22	private OperatingSystemInterface mOS;
	23	private int[] perm11;
23	24
24	25	///////////////////////////////////////////////////////////////////////////////////////////////////
25	26
...	...
35	36	super(os,new int[] {R.raw.dino_3_pruning3,R.raw.dino_3_pruning4},new int[] {R.raw.dino_3_pruning10});
36	37
37	38	mOS = os;
	39	perm11 = new int[11];
38	40	}
39	41
40	42	///////////////////////////////////////////////////////////////////////////////////////////////////
...	...
97	99	public static int getIndexFromPerm(int[] perm)
98	100	{
99	101	int[] perm11 = new int[11];
100
101		for(int i=0; i<11; i++)
102		{
103		if( perm[i+1]<=0 ) return -1;
104		perm11[i] = perm[i+1]-1;
105		}
106
	102	for(int i=0; i<11; i++) perm11[i] = perm[i+1]-1;
107	103	return TablebaseHelpers.computeEvenPermutationNum(perm11);
108	104	}
109	105
...	...
111	107
112	108	int[] getQuats(int index)
113	109	{
114		int[] perm11 = new int[11];
115	110	TablebaseHelpers.getEvenPermutationFromNum(perm11,index);
116		int[] perm = new int[12];
117		for(int i=1; i<12; i++) perm[i] = perm11[i-1]+1;
118		return getQuatsFromPerm(perm);
	111	int[] perm12 = new int[12];
	112	for(int i=1; i<12; i++) perm12[i] = perm11[i-1]+1;
	113	return getQuatsFromPerm(perm12);
119	114	}
120	115
121	116	///////////////////////////////////////////////////////////////////////////////////////////////////
...	...
124	119	{
125	120	normalizeQuats(quats);
126	121	int[] perm = getPermFromQuats(quats);
127		int ret = getIndexFromPerm(perm);
128	122
129		if( ret<0 )
	123	for(int i=0; i<11; i++)
130	124	{
131		if( mOS!=null )
	125	if( perm[i+1]<=0 )
132	126	{
133		StringBuilder sb = new StringBuilder();
134
135		for(int i=0; i<12; i++)
	127	if( mOS!=null )
136	128	{
137		sb.append(quats[i]);
138		sb.append(' ');
	129	StringBuilder sb = new StringBuilder();
	130	for(int j=0; j<12; j++) { sb.append(quats[j]); sb.append(' '); }
	131	mOS.reportError("TBDino6 getIndex: "+sb+" lastSolvingIndex: "+mLastSolvingIndex);
139	132	}
140
141		mOS.reportError("TBDino6 getIndex: "+sb);
	133	return 0;
142	134	}
143		return 0;
	135
	136	perm11[i] = perm[i+1]-1;
144	137	}
145	138
146		return ret;
	139	return TablebaseHelpers.computeEvenPermutationNum(perm11);
147	140	}
148	141	}
149	142

       private int[][] mQuatMult;
       private int[] mInvertedQuat;
       private ArrayList<int[]> mMoves;
       Tablebase mTablebase;
       boolean mInitialized;
       int mLastSolvingIndex;
       final int mScalingFactor;
       final int mNumAxis;
-...
+        {
         if( !mInitialized ) return null;
         if( mMoves==null ) mMoves = new ArrayList<>();
         else               mMoves.clear();
         int[] data = new int[4];
         byte level = mTablebase.retrievePacked(index);
         ArrayList<int[]> moves = new ArrayList<>();
         int[] quats = getQuats(index);
         int numQuats = quats.length;
         int[] tmpQuats = new int[numQuats];
         mLastSolvingIndex = index;
         while( !isSolved(index) )
+          {
-...
               if( ((newLevel-level+1)%3) == 0 )
+                {
                 int[] tmpMove = newMove(ax,layer,angle);
                 moves.add(tmpMove);
                 mMoves.add(tmpMove);
                 index = childIndex;
                 level = (level==0 ? 2 : (byte)(level-1));
                 found = true;
-...
+            }
+          }
         int[][] ret = convertMovesFromArray(moves);
         int[][] ret = convertMovesFromArray(mMoves);
         return extraInfo(ret,extra);
+        }
-...
       public void test(OperatingSystemInterface os)
+        {
         /*
         int index = 252373232;
         int[] q = getQuats(index);
         TablebaseHelpers.displayTable(q , "QUATS ");
         */
         int[] extra = new int[4];
         for(int i=6525000; i<19958400; i++)
+          {
           int[][] sol = solution(i,extra,os);
           if( (i%1000)==0 ) android.util.Log.e("D ", "solving: "+i);
+          }
+        }
+    }

src/main/java/org/distorted/objectlib/tablebases/TablebasesPruning.java
445	445
446	446	public int[][] solution(int index, int[] extra, OperatingSystemInterface osi)
447	447	{
	448	mLastSolvingIndex = index;
448	449	if( isSolved(index) ) return null;
449	450	int lastA=-1, lastR=0;
450	451	int[][] highMoves = traverseBlock(index,mHighTables,lastA,lastR);

Project

General

Profile

TwistyPuzzleLib

Revision 766bf4c4

Added by Leszek Koltunski 9 months ago