Revision 6ab0bce9
Added by Leszek Koltunski about 1 year ago
src/main/java/org/distorted/objectlib/tablebases/TBCuboid323.java | ||
---|---|---|
16 | 16 |
|
17 | 17 |
public class TBCuboid323 extends TablebasesAbstract |
18 | 18 |
{ |
19 |
private static final int[][] CORNER_MAP = new int[][] |
|
20 |
{ |
|
21 |
{0,4,7,1,2,3,5,6}, |
|
22 |
{2,0,1,6,3,4,7,5}, |
|
23 |
{7,1,0,4,5,6,2,3}, |
|
24 |
{1,6,2,0,7,5,3,4}, |
|
25 |
{4,3,5,7,0,2,6,1}, |
|
26 |
{3,2,6,5,4,0,1,7}, |
|
27 |
{5,7,4,3,6,1,0,2}, |
|
28 |
{6,5,3,2,1,7,4,0} |
|
29 |
}; |
|
30 |
private static final int[][] EDGE_MAP = new int[][] |
|
31 |
{ |
|
32 |
{0,3,5,1,4,7,2,6}, |
|
33 |
{3,0,1,5,2,6,4,7}, |
|
34 |
{5,1,0,3,7,4,6,2}, |
|
35 |
{1,5,3,0,6,2,7,4}, |
|
36 |
{2,4,7,6,0,1,3,5}, |
|
37 |
{7,6,2,4,1,0,5,3}, |
|
38 |
{4,2,6,7,3,5,0,1}, |
|
39 |
{6,7,4,2,5,3,1,0} |
|
40 |
}; |
|
41 |
|
|
42 |
private static boolean mUpper; |
|
43 |
|
|
44 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
45 |
|
|
46 |
public static void setUpper(boolean upper) |
|
47 |
{ |
|
48 |
mUpper = upper; |
|
49 |
} |
|
50 |
|
|
51 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
52 |
// if mUpper==true, then the edge3 is the 'half-fixed' front edge. Remove it from the permutation. |
|
53 |
// Otherwise edge1 is the one; remove it. |
|
54 |
|
|
55 |
public static int[] edgePermTo7(int[] perm, boolean upper) |
|
56 |
{ |
|
57 |
int val; |
|
58 |
int[] ret = new int[7]; |
|
59 |
|
|
60 |
if( upper ) |
|
61 |
{ |
|
62 |
ret[0] = perm[0]; |
|
63 |
ret[1] = perm[1]; |
|
64 |
ret[2] = perm[2]; |
|
65 |
ret[3] = perm[4]; |
|
66 |
ret[4] = perm[5]; |
|
67 |
ret[5] = perm[6]; |
|
68 |
ret[6] = perm[7]; |
|
69 |
|
|
70 |
val = perm[3]; |
|
71 |
} |
|
72 |
else |
|
73 |
{ |
|
74 |
ret[0] = perm[0]; |
|
75 |
ret[1] = perm[2]; |
|
76 |
ret[2] = perm[3]; |
|
77 |
ret[3] = perm[4]; |
|
78 |
ret[4] = perm[5]; |
|
79 |
ret[5] = perm[6]; |
|
80 |
ret[6] = perm[7]; |
|
81 |
|
|
82 |
val = perm[1]; |
|
83 |
} |
|
84 |
|
|
85 |
for(int i=0; i<7; i++) |
|
86 |
if( ret[i]>val ) ret[i]--; |
|
87 |
|
|
88 |
return ret; |
|
89 |
} |
|
90 |
|
|
91 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
92 |
|
|
93 |
private static int[] edgePermTo8(int[] perm, boolean inPlace) |
|
94 |
{ |
|
95 |
int[] ret = new int[8]; |
|
96 |
|
|
97 |
if( mUpper ) |
|
98 |
{ |
|
99 |
int val = inPlace ? 3:1; |
|
100 |
ret[0] = perm[0]; if( ret[0]>=val ) ret[0]++; |
|
101 |
ret[1] = perm[1]; if( ret[1]>=val ) ret[1]++; |
|
102 |
ret[2] = perm[2]; if( ret[2]>=val ) ret[2]++; |
|
103 |
ret[3] = val; |
|
104 |
ret[4] = perm[3]; if( ret[4]>=val ) ret[4]++; |
|
105 |
ret[5] = perm[4]; if( ret[5]>=val ) ret[5]++; |
|
106 |
ret[6] = perm[5]; if( ret[6]>=val ) ret[6]++; |
|
107 |
ret[7] = perm[6]; if( ret[7]>=val ) ret[7]++; |
|
108 |
} |
|
109 |
else |
|
110 |
{ |
|
111 |
int val = inPlace ? 1:3; |
|
112 |
ret[0] = perm[0]; if( ret[0]>=val ) ret[0]++; |
|
113 |
ret[1] = val; |
|
114 |
ret[2] = perm[1]; if( ret[2]>=val ) ret[2]++; |
|
115 |
ret[3] = perm[2]; if( ret[3]>=val ) ret[3]++; |
|
116 |
ret[4] = perm[3]; if( ret[4]>=val ) ret[4]++; |
|
117 |
ret[5] = perm[4]; if( ret[5]>=val ) ret[5]++; |
|
118 |
ret[6] = perm[5]; if( ret[6]>=val ) ret[6]++; |
|
119 |
ret[7] = perm[6]; if( ret[7]>=val ) ret[7]++; |
|
120 |
} |
|
121 |
|
|
122 |
return ret; |
|
123 |
} |
|
124 |
|
|
125 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
126 |
|
|
19 | 127 |
public TBCuboid323() |
20 | 128 |
{ |
21 | 129 |
super(); |
... | ... | |
109 | 217 |
return 13; |
110 | 218 |
} |
111 | 219 |
|
220 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
221 |
|
|
222 |
private int findIndex(int[] table, int value) |
|
223 |
{ |
|
224 |
for(int i=0; i<8; i++) |
|
225 |
if( table[i]==value ) return i; |
|
226 |
|
|
227 |
return -1; |
|
228 |
} |
|
229 |
|
|
230 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
231 |
|
|
232 |
private boolean isFrontEdgeInItsPlace(int[] perm) |
|
233 |
{ |
|
234 |
return perm[mUpper ? 3 : 1]==0; |
|
235 |
} |
|
236 |
|
|
112 | 237 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
113 | 238 |
|
114 | 239 |
public int[] getQuats(int index) |
115 | 240 |
{ |
116 |
return null; |
|
241 |
int cornerPermNum = index%20160; |
|
242 |
index /= 20160; |
|
243 |
boolean inPlace = ((index%2)==0); |
|
244 |
int edgePermNum = index/2; |
|
245 |
|
|
246 |
int[] corner_perm = new int[8]; |
|
247 |
TablebaseHelpers.getPermutationFromNum(corner_perm,8,cornerPermNum); |
|
248 |
int[] edge_perm7 = new int[7]; |
|
249 |
TablebaseHelpers.getPermutationFromNum(edge_perm7,7,edgePermNum); |
|
250 |
int[] edge_perm8 = edgePermTo8(edge_perm7,inPlace); |
|
251 |
|
|
252 |
int[] quats = new int[18]; |
|
253 |
|
|
254 |
for(int i=0; i<8; i++) |
|
255 |
{ |
|
256 |
int q = CORNER_MAP[i][corner_perm[i]]; |
|
257 |
quats[i] = q; |
|
258 |
} |
|
259 |
for(int i=0; i<8; i++) |
|
260 |
{ |
|
261 |
int q = EDGE_MAP[i][edge_perm8[i]]; |
|
262 |
quats[i+8] = q; |
|
263 |
} |
|
264 |
|
|
265 |
return quats; |
|
117 | 266 |
} |
118 | 267 |
|
119 | 268 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
120 | 269 |
|
121 | 270 |
public int getIndex(int[] quats) |
122 | 271 |
{ |
123 |
return 0; |
|
272 |
int[] corner_perm = new int[8]; |
|
273 |
int[] edge_perm8 = new int[8]; |
|
274 |
|
|
275 |
for(int i=0; i<8; i++) |
|
276 |
{ |
|
277 |
corner_perm[i] = findIndex( CORNER_MAP[i], quats[i ]); |
|
278 |
edge_perm8[i] = findIndex( EDGE_MAP[i] , quats[i+8]); |
|
279 |
} |
|
280 |
|
|
281 |
int[] edge_perm7 = edgePermTo7(edge_perm8,mUpper); |
|
282 |
|
|
283 |
int corner_perm_num = TablebaseHelpers.computePermutationNum(corner_perm); |
|
284 |
int edge_perm_num = TablebaseHelpers.computePermutationNum(edge_perm7); |
|
285 |
boolean inPlace = isFrontEdgeInItsPlace(edge_perm8); |
|
286 |
|
|
287 |
return corner_perm_num + 20160*( (inPlace?0:1) + 2*edge_perm_num); |
|
124 | 288 |
} |
125 | 289 |
} |
126 | 290 |
|
Also available in: Unified diff
CU_323 solver: theoretically complete.