Revision 971a184e
Added by Leszek Koltunski about 1 year ago
| src/main/java/org/distorted/objectlib/tablebases/TablebasesAbstract.java | ||
|---|---|---|
| 348 | 348 |
|
| 349 | 349 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 350 | 350 |
|
| 351 |
private void getNextAxisLayerAngle(int[] data) |
|
| 351 |
private void getNextAxisLayerAngleQuat(int[] data)
|
|
| 352 | 352 |
{
|
| 353 | 353 |
int axis = data[0]; |
| 354 | 354 |
int layer= data[1]; |
| ... | ... | |
| 366 | 366 |
data[0] = (axis<mNumAxis-1) ? axis+1 : 0; |
| 367 | 367 |
} |
| 368 | 368 |
} |
| 369 |
|
|
| 370 |
data[3] = data[2]; |
|
| 371 |
for(int i=0; i<data[0]; i++) data[3] += (mAngles[i][0]-1); |
|
| 369 | 372 |
} |
| 370 | 373 |
|
| 371 | 374 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| ... | ... | |
| 374 | 377 |
{
|
| 375 | 378 |
if( !mInitialized ) return null; |
| 376 | 379 |
|
| 377 |
int[] data = new int[3];
|
|
| 380 |
int[] data = new int[4];
|
|
| 378 | 381 |
byte level = mTablebase.retrievePacked(index); |
| 379 | 382 |
ArrayList<int[]> moves = new ArrayList<>(); |
| 380 | 383 |
int[] quats = getQuats(index); |
| ... | ... | |
| 388 | 391 |
data[0]=0; |
| 389 | 392 |
data[1]=0; |
| 390 | 393 |
data[2]=1; |
| 394 |
data[3]=1; |
|
| 391 | 395 |
|
| 392 | 396 |
for(int ax=0; ax<mNumAxis; ax++) |
| 393 | 397 |
for(int cubit=0; cubit<mNumCubits; cubit++) |
| ... | ... | |
| 398 | 402 |
int ax = data[0]; |
| 399 | 403 |
int layer = data[1]; |
| 400 | 404 |
int angle = data[2]; |
| 405 |
int quat = data[3]; |
|
| 401 | 406 |
|
| 402 | 407 |
if( mRotatable[ax][layer] ) |
| 403 | 408 |
{
|
| 404 | 409 |
int bitLayer = (1<<layer); |
| 405 | 410 |
System.arraycopy(quats, 0, tmpQuats, 0, numQuats); |
| 406 |
int quat = ax*(mAngles[ax][0]-1) + angle; |
|
| 407 | 411 |
|
| 408 | 412 |
for(int cubit=0; cubit<mNumCubits; cubit++) |
| 409 | 413 |
if( mRotRow[cubit][ax]==bitLayer ) |
| ... | ... | |
| 425 | 429 |
} |
| 426 | 430 |
} |
| 427 | 431 |
|
| 428 |
getNextAxisLayerAngle(data); |
|
| 432 |
getNextAxisLayerAngleQuat(data);
|
|
| 429 | 433 |
} |
| 430 | 434 |
|
| 431 | 435 |
quats = getQuats(index); |
| ... | ... | |
| 446 | 450 |
{
|
| 447 | 451 |
if( !mInitialized ) return null; |
| 448 | 452 |
|
| 449 |
int[] data = new int[3];
|
|
| 453 |
int[] data = new int[4];
|
|
| 450 | 454 |
int level=0; |
| 451 | 455 |
int[][] moves = new int[depth][3]; |
| 452 | 456 |
int[] quats = getQuats(0); |
| ... | ... | |
| 460 | 464 |
data[0]=0; |
| 461 | 465 |
data[1]=0; |
| 462 | 466 |
data[2]=1; |
| 467 |
data[3]=1; |
|
| 463 | 468 |
|
| 464 | 469 |
int random = rnd.nextInt(mScalingFactor); |
| 465 |
for(int i=0; i<random; i++) getNextAxisLayerAngle(data); |
|
| 470 |
for(int i=0; i<random; i++) getNextAxisLayerAngleQuat(data);
|
|
| 466 | 471 |
|
| 467 | 472 |
for(int ax=0; ax<mNumAxis; ax++) |
| 468 | 473 |
for(int cubit=0; cubit<mNumCubits; cubit++) |
| ... | ... | |
| 473 | 478 |
int ax = data[0]; |
| 474 | 479 |
int layer = data[1]; |
| 475 | 480 |
int angle = data[2]; |
| 481 |
int quat = data[3]; |
|
| 476 | 482 |
|
| 477 | 483 |
if( mRotatable[ax][layer] ) |
| 478 | 484 |
{
|
| 479 | 485 |
int bitLayer = (1<<layer); |
| 480 | 486 |
System.arraycopy(quats, 0, tmpQuats, 0, numQuats); |
| 481 |
int quat = ax*(mAngles[ax][0]-1) + angle; |
|
| 482 | 487 |
|
| 483 | 488 |
for(int cubit=0; cubit<mNumCubits; cubit++) |
| 484 | 489 |
if( mRotRow[cubit][ax]==bitLayer ) |
| ... | ... | |
| 500 | 505 |
} |
| 501 | 506 |
} |
| 502 | 507 |
|
| 503 |
getNextAxisLayerAngle(data); |
|
| 508 |
getNextAxisLayerAngleQuat(data);
|
|
| 504 | 509 |
} |
| 505 | 510 |
|
| 506 | 511 |
if( !found ) |
| src/main/java/org/distorted/objectlib/tablebases/TablebasesCuboid232.java | ||
|---|---|---|
| 18 | 18 |
|
| 19 | 19 |
public class TablebasesCuboid232 extends TablebasesAbstract |
| 20 | 20 |
{
|
| 21 |
private static final int[][] CORNER_MAP = new int[][] |
|
| 22 |
{
|
|
| 23 |
{0,4,7,1,2,3,5,6},
|
|
| 24 |
{2,0,1,6,3,4,7,5},
|
|
| 25 |
{7,1,0,4,5,6,2,3},
|
|
| 26 |
{1,6,2,0,7,5,3,4},
|
|
| 27 |
{4,3,5,7,0,2,6,1},
|
|
| 28 |
{3,2,6,5,4,0,1,7},
|
|
| 29 |
{5,7,4,3,6,1,0,2},
|
|
| 30 |
{6,5,3,2,1,7,4,0}
|
|
| 31 |
}; |
|
| 32 |
|
|
| 33 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 34 |
|
|
| 21 | 35 |
public TablebasesCuboid232() |
| 22 | 36 |
{
|
| 23 | 37 |
super(); |
| ... | ... | |
| 27 | 41 |
|
| 28 | 42 |
public TablebasesCuboid232(Resources res) |
| 29 | 43 |
{
|
| 30 |
super(res,org.distorted.objectlib.R.raw.ivy_2_tablebase);
|
|
| 44 |
super(res,org.distorted.objectlib.R.raw.cu_232_tablebase);
|
|
| 31 | 45 |
} |
| 32 | 46 |
|
| 33 | 47 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| ... | ... | |
| 96 | 110 |
|
| 97 | 111 |
private void getCornerQuats(int[] output, int[] perm) |
| 98 | 112 |
{
|
| 99 |
|
|
| 113 |
for(int i=0; i<8; i++) |
|
| 114 |
output[i] = CORNER_MAP[i][perm[i]]; |
|
| 100 | 115 |
} |
| 101 | 116 |
|
| 102 | 117 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 103 | 118 |
|
| 104 |
private void getEdgeQuats(int[] output, int[] perm)
|
|
| 119 |
private int[] getCornerPerm(int[] quats)
|
|
| 105 | 120 |
{
|
| 121 |
int[] output = new int[8]; |
|
| 106 | 122 |
|
| 123 |
for(int i=0; i<8; i++) |
|
| 124 |
{
|
|
| 125 |
int quat = quats[i]; |
|
| 126 |
|
|
| 127 |
for(int j=0; j<8; j++) |
|
| 128 |
{
|
|
| 129 |
if( CORNER_MAP[i][j]==quat ) |
|
| 130 |
{
|
|
| 131 |
output[i]=j; |
|
| 132 |
break; |
|
| 133 |
} |
|
| 134 |
} |
|
| 135 |
} |
|
| 136 |
|
|
| 137 |
return output; |
|
| 107 | 138 |
} |
| 108 | 139 |
|
| 109 | 140 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 110 | 141 |
|
| 111 |
private int[] getCornerPerm(int[] quats)
|
|
| 142 |
private void getEdgeQuats(int[] output, int[] perm)
|
|
| 112 | 143 |
{
|
| 113 |
return null; |
|
| 144 |
switch(perm[0]) |
|
| 145 |
{
|
|
| 146 |
case 0: output[8] = 0; break; |
|
| 147 |
case 2: output[8] = 5; break; |
|
| 148 |
case 3: output[8] = 3; break; |
|
| 149 |
default: android.util.Log.e("D", "getEdgeQuats ERROR1");
|
|
| 150 |
} |
|
| 151 |
|
|
| 152 |
output[9] = 0; |
|
| 153 |
|
|
| 154 |
switch(perm[2]) |
|
| 155 |
{
|
|
| 156 |
case 0: output[10] = 5; break; |
|
| 157 |
case 2: output[10] = 0; break; |
|
| 158 |
case 3: output[10] = 1; break; |
|
| 159 |
default: android.util.Log.e("D", "getEdgeQuats ERROR2");
|
|
| 160 |
} |
|
| 161 |
|
|
| 162 |
switch(perm[3]) |
|
| 163 |
{
|
|
| 164 |
case 0: output[11] = 3; break; |
|
| 165 |
case 2: output[11] = 1; break; |
|
| 166 |
case 3: output[11] = 0; break; |
|
| 167 |
default: android.util.Log.e("D", "getEdgeQuats ERROR3");
|
|
| 168 |
} |
|
| 114 | 169 |
} |
| 115 | 170 |
|
| 116 | 171 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 117 | 172 |
|
| 118 | 173 |
private int[] getEdgePerm(int[] quats) |
| 119 | 174 |
{
|
| 120 |
return null; |
|
| 175 |
int[] output = new int[4]; |
|
| 176 |
|
|
| 177 |
switch(quats[8]) |
|
| 178 |
{
|
|
| 179 |
case 0: output[0] = 0; break; |
|
| 180 |
case 5: output[0] = 2; break; |
|
| 181 |
case 3: output[0] = 3; break; |
|
| 182 |
default: android.util.Log.e("D", "getEdgePerm ERROR1");
|
|
| 183 |
} |
|
| 184 |
|
|
| 185 |
output[1] = 1; |
|
| 186 |
|
|
| 187 |
switch(quats[10]) |
|
| 188 |
{
|
|
| 189 |
case 0: output[2] = 2; break; |
|
| 190 |
case 1: output[2] = 3; break; |
|
| 191 |
case 5: output[2] = 0; break; |
|
| 192 |
default: android.util.Log.e("D", "getEdgePerm ERROR2");
|
|
| 193 |
} |
|
| 194 |
|
|
| 195 |
switch(quats[11]) |
|
| 196 |
{
|
|
| 197 |
case 0: output[3] = 3; break; |
|
| 198 |
case 1: output[3] = 2; break; |
|
| 199 |
case 3: output[3] = 0; break; |
|
| 200 |
default: android.util.Log.e("D", "getEdgePerm ERROR3");
|
|
| 201 |
} |
|
| 202 |
|
|
| 203 |
return output; |
|
| 121 | 204 |
} |
| 122 | 205 |
|
| 123 | 206 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
Also available in: Unified diff
CU_232 solver: finished