Revision 5b9e0ba4
Added by Leszek Koltunski about 1 year ago
src/main/java/org/distorted/objectlib/tablebases/TBCuboid323.java | ||
---|---|---|
40 | 40 |
{6,7,4,2,5,3,1,0} |
41 | 41 |
}; |
42 | 42 |
|
43 |
private static boolean mFixedEdgeIsDown; |
|
44 |
private int[][] mAngles; |
|
45 |
|
|
46 | 43 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
47 |
|
|
48 |
public static void initialize() |
|
49 |
{ |
|
50 |
mFixedEdgeIsDown = true; |
|
51 |
} |
|
52 |
|
|
53 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
54 |
// We must have perm[1]==1 or perm[1]==3, depending on if inPlace==true; |
|
55 |
// remove this extraneous perm member. |
|
44 |
// remove perm[1] which is always equal to 1. |
|
56 | 45 |
|
57 | 46 |
public static int[] edgePermTo7(int[] perm) |
58 | 47 |
{ |
59 | 48 |
int[] ret = new int[7]; |
60 | 49 |
|
61 |
ret[0] = perm[0]; |
|
62 |
ret[1] = perm[2]; |
|
63 |
ret[2] = perm[3]; |
|
64 |
ret[3] = perm[4]; |
|
65 |
ret[4] = perm[5]; |
|
66 |
ret[5] = perm[6]; |
|
67 |
ret[6] = perm[7]; |
|
68 |
|
|
69 |
int val = perm[1]; |
|
70 |
|
|
71 |
for(int i=0; i<7; i++) |
|
72 |
if( ret[i]>val ) ret[i]--; |
|
50 |
ret[0] = perm[0]; if( ret[0]>1 ) ret[0]--; |
|
51 |
ret[1] = perm[2]; if( ret[1]>1 ) ret[1]--; |
|
52 |
ret[2] = perm[3]; if( ret[2]>1 ) ret[2]--; |
|
53 |
ret[3] = perm[4]; if( ret[3]>1 ) ret[3]--; |
|
54 |
ret[4] = perm[5]; if( ret[4]>1 ) ret[4]--; |
|
55 |
ret[5] = perm[6]; if( ret[5]>1 ) ret[5]--; |
|
56 |
ret[6] = perm[7]; if( ret[6]>1 ) ret[6]--; |
|
73 | 57 |
|
74 | 58 |
return ret; |
75 | 59 |
} |
... | ... | |
77 | 61 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
78 | 62 |
// reverse the above |
79 | 63 |
|
80 |
private static int[] edgePermTo8(int[] perm, boolean inPlace)
|
|
64 |
private static int[] edgePermTo8(int[] perm) |
|
81 | 65 |
{ |
82 | 66 |
int[] ret = new int[8]; |
83 |
int val = inPlace ? 1:3; |
|
84 | 67 |
|
85 |
ret[0] = perm[0]; if( ret[0]>=val ) ret[0]++;
|
|
86 |
ret[1] = val;
|
|
87 |
ret[2] = perm[1]; if( ret[2]>=val ) ret[2]++;
|
|
88 |
ret[3] = perm[2]; if( ret[3]>=val ) ret[3]++;
|
|
89 |
ret[4] = perm[3]; if( ret[4]>=val ) ret[4]++;
|
|
90 |
ret[5] = perm[4]; if( ret[5]>=val ) ret[5]++;
|
|
91 |
ret[6] = perm[5]; if( ret[6]>=val ) ret[6]++;
|
|
92 |
ret[7] = perm[6]; if( ret[7]>=val ) ret[7]++;
|
|
68 |
ret[0] = perm[0]; if( ret[0]>=1 ) ret[0]++;
|
|
69 |
ret[1] = 1;
|
|
70 |
ret[2] = perm[1]; if( ret[2]>=1 ) ret[2]++;
|
|
71 |
ret[3] = perm[2]; if( ret[3]>=1 ) ret[3]++;
|
|
72 |
ret[4] = perm[3]; if( ret[4]>=1 ) ret[4]++;
|
|
73 |
ret[5] = perm[4]; if( ret[5]>=1 ) ret[5]++;
|
|
74 |
ret[6] = perm[5]; if( ret[6]>=1 ) ret[6]++;
|
|
75 |
ret[7] = perm[6]; if( ret[7]>=1 ) ret[7]++;
|
|
93 | 76 |
|
94 | 77 |
return ret; |
95 | 78 |
} |
... | ... | |
105 | 88 |
|
106 | 89 |
public TBCuboid323(OperatingSystemInterface os) |
107 | 90 |
{ |
108 |
super(os,new int[] {R.raw.cu_323_pruning6,R.raw.cu_323_pruning7}, new int[] {R.raw.cu_323_pruning17,R.raw.cu_323_pruning18});
|
|
91 |
super(os,new int[] {R.raw.cu_323_pruning7,R.raw.cu_323_pruning8}, new int[] {R.raw.cu_323_pruning18});
|
|
109 | 92 |
} |
110 | 93 |
|
111 | 94 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
112 | 95 |
|
113 | 96 |
int[][] getBasicAngles() |
114 | 97 |
{ |
115 |
if( mAngles==null ) |
|
116 |
{ |
|
117 |
int[] tmp2 = {2,2,2}; |
|
118 |
int[] tmp4 = {4,4}; |
|
119 |
mAngles = new int[][] { tmp2,tmp4,tmp2 }; |
|
120 |
} |
|
121 |
|
|
122 |
return mAngles; |
|
98 |
int[] tmp2 = {2,2,2}; |
|
99 |
int[] tmp4 = {4,4}; |
|
100 |
return new int[][] { tmp2,tmp4,tmp2 }; |
|
123 | 101 |
} |
124 | 102 |
|
125 | 103 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
... | ... | |
174 | 152 |
|
175 | 153 |
boolean[][] getRotatable() |
176 | 154 |
{ |
177 |
return new boolean[][] { {true,false,true},{true,false},{true,false,true} };
|
|
155 |
return new boolean[][] { {true,false,true},{false,true},{true,true,false} };
|
|
178 | 156 |
} |
179 | 157 |
|
180 | 158 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
181 | 159 |
// specifically for the tablebase |
182 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
183 |
// edge1 (i.e. the edge which is initially in the lower front) needs to stay in front. |
|
184 |
|
|
185 |
@Override |
|
186 |
int[] newMove(int axis, int layer, int angle) |
|
187 |
{ |
|
188 |
if( axis==2 && layer==2 ) mFixedEdgeIsDown = !mFixedEdgeIsDown; |
|
189 |
if( axis==1 ) |
|
190 |
{ |
|
191 |
if( angle==3 ) angle=-1; |
|
192 |
|
|
193 |
if( layer==0 && mFixedEdgeIsDown ) return new int[] { axis, 2, angle }; |
|
194 |
if( layer==1 && !mFixedEdgeIsDown ) return new int[] { axis, 1, angle }; |
|
195 |
} |
|
196 |
|
|
197 |
int maxAngle = mAngles[axis][layer]; |
|
198 |
angle = maxAngle-angle; |
|
199 |
if( angle> 0.5f*maxAngle ) angle -= maxAngle; |
|
200 |
|
|
201 |
return new int[] { axis, (1<<layer), angle }; |
|
202 |
} |
|
203 |
|
|
204 | 160 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
205 | 161 |
// 8!*8!/4 --> https://www.jaapsch.net/puzzles/domino.htm |
206 | 162 |
|
... | ... | |
220 | 176 |
|
221 | 177 |
int[] getMidPruningLevels() |
222 | 178 |
{ |
223 |
return new int[] {6,7};
|
|
179 |
return new int[] {7,8};
|
|
224 | 180 |
} |
225 | 181 |
|
226 | 182 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
227 | 183 |
|
228 | 184 |
int[] getHighPruningLevels() |
229 | 185 |
{ |
230 |
return null;//new int[] {17,18};
|
|
186 |
return new int[] {18};
|
|
231 | 187 |
} |
232 | 188 |
|
233 | 189 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
... | ... | |
256 | 212 |
|
257 | 213 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
258 | 214 |
|
259 |
public static boolean isFrontEdgeInItsPlace(int[] perm)
|
|
215 |
private int centersInverted(int[] quats)
|
|
260 | 216 |
{ |
261 |
return perm[1]==1; |
|
262 |
} |
|
263 |
|
|
264 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
265 |
|
|
266 |
private void normalizeQuats(int[] quats) |
|
267 |
{ |
|
268 |
int mult=0; |
|
269 |
|
|
270 |
switch(quats[9]) |
|
271 |
{ |
|
272 |
case 0: case 5: return; |
|
273 |
case 4: case 7: mult=2; break; |
|
274 |
case 1: case 3: mult=3; break; |
|
275 |
case 2: case 6: mult=4; break; |
|
276 |
} |
|
277 |
|
|
278 |
for(int i=0; i<16; i++) quats[i] = getMultQuat(mult,quats[i]); |
|
217 |
int q = quats[16]; |
|
218 |
return (q==0 || q==2 || q==3 || q==4) ? 0 : 1; |
|
279 | 219 |
} |
280 | 220 |
|
281 | 221 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
282 | 222 |
|
283 |
public static int[] quatsFromPermutations(int[] corner, int[] edge8) |
|
223 |
public static int[] quatsFromPermutations(int[] corner, int[] edge8, int centers)
|
|
284 | 224 |
{ |
285 | 225 |
int[] quats = new int[18]; |
286 | 226 |
|
... | ... | |
295 | 235 |
quats[i+8] = q; |
296 | 236 |
} |
297 | 237 |
|
238 |
if( centers==0 ) |
|
239 |
{ |
|
240 |
quats[16]=0; |
|
241 |
quats[17]=0; |
|
242 |
} |
|
243 |
else |
|
244 |
{ |
|
245 |
quats[16]=5; |
|
246 |
quats[17]=5; |
|
247 |
} |
|
248 |
|
|
298 | 249 |
return quats; |
299 | 250 |
} |
300 | 251 |
|
... | ... | |
316 | 267 |
|
317 | 268 |
public int[] getQuats(int index) |
318 | 269 |
{ |
319 |
int cornerPermNum = index%40320;
|
|
270 |
int cornerPermNum = (index%40320);
|
|
320 | 271 |
index /= 40320; |
321 |
boolean inPlace = ((index%2)==0);
|
|
272 |
int centers = (index%2);
|
|
322 | 273 |
int edgePermNum = index/2; |
323 | 274 |
|
324 | 275 |
int[] corner_perm = new int[8]; |
325 | 276 |
TablebaseHelpers.getPermutationFromNum(corner_perm,8,cornerPermNum); |
326 | 277 |
int[] edge_perm7 = new int[7]; |
327 | 278 |
TablebaseHelpers.getPermutationFromNum(edge_perm7,7,edgePermNum); |
328 |
int[] edge_perm8 = edgePermTo8(edge_perm7,inPlace);
|
|
279 |
int[] edge_perm8 = edgePermTo8(edge_perm7); |
|
329 | 280 |
/* |
330 | 281 |
TablebaseHelpers.displayTable(corner_perm, "CORNER"); |
331 | 282 |
TablebaseHelpers.displayTable(edge_perm8, "EDGE8"); |
... | ... | |
333 | 284 |
android.util.Log.e("D", "inPlace="+inPlace); |
334 | 285 |
*/ |
335 | 286 |
|
336 |
return quatsFromPermutations(corner_perm,edge_perm8); |
|
287 |
return quatsFromPermutations(corner_perm,edge_perm8,centers);
|
|
337 | 288 |
} |
338 | 289 |
|
339 | 290 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
340 | 291 |
|
341 | 292 |
public int getIndex(int[] quats) |
342 | 293 |
{ |
343 |
normalizeQuats(quats); |
|
344 |
|
|
345 | 294 |
int[] corner_perm = new int[8]; |
346 | 295 |
cornerFromQuats(corner_perm,quats); |
347 | 296 |
int[] edge_perm8 = new int[8]; |
... | ... | |
350 | 299 |
|
351 | 300 |
int corner_perm_num = TablebaseHelpers.computePermutationNum(corner_perm); |
352 | 301 |
int edge_perm_num = TablebaseHelpers.computePermutationNum(edge_perm7); |
353 |
boolean inPlace = isFrontEdgeInItsPlace(edge_perm8);
|
|
302 |
int centers = centersInverted(quats);
|
|
354 | 303 |
|
355 |
return corner_perm_num + 40320*( (inPlace?0:1) + 2*edge_perm_num);
|
|
304 |
return corner_perm_num + 40320*( centers + 2*edge_perm_num);
|
|
356 | 305 |
} |
357 | 306 |
} |
358 | 307 |
|
Also available in: Unified diff
CU_323 solver: new schema.