Revision 398f2870
Added by Leszek Koltunski about 1 year ago
src/main/java/org/distorted/objectlib/tablebases/TBCuboid323.java | ||
---|---|---|
188 | 188 |
if( axis==2 && layer==2 ) mFixedEdgeIsDown = !mFixedEdgeIsDown; |
189 | 189 |
if( axis==1 ) |
190 | 190 |
{ |
191 |
if( angle==3 ) angle=-1; |
|
192 |
|
|
191 | 193 |
if( layer==0 && mFixedEdgeIsDown ) return new int[] { axis, 2, angle }; |
192 | 194 |
if( layer==1 && !mFixedEdgeIsDown ) return new int[] { axis, 1, angle }; |
193 | 195 |
} |
... | ... | |
195 | 197 |
int maxAngle = mAngles[axis][layer]; |
196 | 198 |
angle = maxAngle-angle; |
197 | 199 |
if( angle> 0.5f*maxAngle ) angle -= maxAngle; |
200 |
|
|
198 | 201 |
return new int[] { axis, (1<<layer), angle }; |
199 | 202 |
} |
200 | 203 |
|
... | ... | |
243 | 246 |
|
244 | 247 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
245 | 248 |
|
246 |
private int findIndex(int[] table, int value) |
|
249 |
private static int findIndex(int[] table, int value)
|
|
247 | 250 |
{ |
248 | 251 |
for(int i=0; i<8; i++) |
249 | 252 |
if( table[i]==value ) return i; |
... | ... | |
260 | 263 |
|
261 | 264 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
262 | 265 |
|
263 |
private void correctQuats(int[] quats)
|
|
266 |
private void normalizeQuats(int[] quats)
|
|
264 | 267 |
{ |
265 | 268 |
int mult=0; |
266 | 269 |
|
... | ... | |
275 | 278 |
for(int i=0; i<16; i++) quats[i] = getMultQuat(mult,quats[i]); |
276 | 279 |
} |
277 | 280 |
|
281 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
282 |
|
|
283 |
public static int[] quatsFromPermutations(int[] corner, int[] edge8) |
|
284 |
{ |
|
285 |
int[] quats = new int[18]; |
|
286 |
|
|
287 |
for(int i=0; i<8; i++) |
|
288 |
{ |
|
289 |
int q = CORNER_MAP[i][corner[i]]; |
|
290 |
quats[i] = q; |
|
291 |
} |
|
292 |
for(int i=0; i<8; i++) |
|
293 |
{ |
|
294 |
int q = EDGE_MAP[i][edge8[i]]; |
|
295 |
quats[i+8] = q; |
|
296 |
} |
|
297 |
|
|
298 |
return quats; |
|
299 |
} |
|
300 |
|
|
301 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
302 |
|
|
303 |
public static void cornerFromQuats(int[] corner_perm, int[] quats) |
|
304 |
{ |
|
305 |
for(int i=0; i<8; i++) corner_perm[i] = findIndex( CORNER_MAP[i], quats[i]); |
|
306 |
} |
|
307 |
|
|
308 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
309 |
|
|
310 |
public static void edgeFromQuats(int[] edge_perm, int[] quats) |
|
311 |
{ |
|
312 |
for(int i=0; i<8; i++) edge_perm[i] = findIndex( EDGE_MAP[i], quats[i+8]); |
|
313 |
} |
|
314 |
|
|
278 | 315 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
279 | 316 |
|
280 | 317 |
public int[] getQuats(int index) |
... | ... | |
295 | 332 |
TablebaseHelpers.displayTable(edge_perm7, "EDGE7"); |
296 | 333 |
android.util.Log.e("D", "inPlace="+inPlace); |
297 | 334 |
*/ |
298 |
int[] quats = new int[18]; |
|
299 | 335 |
|
300 |
for(int i=0; i<8; i++) |
|
301 |
{ |
|
302 |
int q = CORNER_MAP[i][corner_perm[i]]; |
|
303 |
quats[i] = q; |
|
304 |
} |
|
305 |
for(int i=0; i<8; i++) |
|
306 |
{ |
|
307 |
int q = EDGE_MAP[i][edge_perm8[i]]; |
|
308 |
quats[i+8] = q; |
|
309 |
} |
|
310 |
|
|
311 |
return quats; |
|
336 |
return quatsFromPermutations(corner_perm,edge_perm8); |
|
312 | 337 |
} |
313 | 338 |
|
314 | 339 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
315 | 340 |
|
316 | 341 |
public int getIndex(int[] quats) |
317 | 342 |
{ |
343 |
normalizeQuats(quats); |
|
344 |
|
|
318 | 345 |
int[] corner_perm = new int[8]; |
346 |
cornerFromQuats(corner_perm,quats); |
|
319 | 347 |
int[] edge_perm8 = new int[8]; |
320 |
|
|
321 |
correctQuats(quats); |
|
322 |
|
|
323 |
for(int i=0; i<8; i++) |
|
324 |
{ |
|
325 |
corner_perm[i] = findIndex( CORNER_MAP[i], quats[i ]); |
|
326 |
edge_perm8[i] = findIndex( EDGE_MAP[i] , quats[i+8]); |
|
327 |
} |
|
328 |
|
|
329 |
int[] edge_perm7 = edgePermTo7(edge_perm8); |
|
348 |
edgeFromQuats(edge_perm8,quats); |
|
349 |
int[] edge_perm7 = edgePermTo7(edge_perm8); |
|
330 | 350 |
|
331 | 351 |
int corner_perm_num = TablebaseHelpers.computePermutationNum(corner_perm); |
332 | 352 |
int edge_perm_num = TablebaseHelpers.computePermutationNum(edge_perm7); |
Also available in: Unified diff
CU_323 solver: corrections.