Revision bf5c802b
Added by Leszek Koltunski over 1 year ago
| src/main/java/org/distorted/objectlib/tablebases/Tablebase.java | ||
|---|---|---|
| 57 | 57 |
{
|
| 58 | 58 |
int indexToInsert = index/5; |
| 59 | 59 |
byte actualInserted = (byte)(value%3); |
| 60 |
byte val = mPackedTable[indexToInsert];
|
|
| 60 |
int val = mPackedTable[indexToInsert] & 0xff; // convert to 'unsigned'
|
|
| 61 | 61 |
|
| 62 |
int b4 = val%3; val/=3; |
|
| 63 |
int b3 = val%3; val/=3; |
|
| 64 |
int b2 = val%3; val/=3; |
|
| 62 |
int b0 = val%3; val/=3; |
|
| 65 | 63 |
int b1 = val%3; val/=3; |
| 66 |
int b0 = val%3; |
|
| 64 |
int b2 = val%3; val/=3; |
|
| 65 |
int b3 = val%3; val/=3; |
|
| 66 |
int b4 = val%3; |
|
| 67 | 67 |
|
| 68 | 68 |
switch(index%5) |
| 69 | 69 |
{
|
| ... | ... | |
| 74 | 74 |
case 4: b4 = actualInserted; break; |
| 75 | 75 |
} |
| 76 | 76 |
|
| 77 |
mPackedTable[indexToInsert] = (byte)(b4 + 3*(b3 + 3*(b2 + 3*(b1 + 3*b0))));
|
|
| 77 |
mPackedTable[indexToInsert] = (byte)(b0 + 3*(b1 + 3*(b2 + 3*(b3 + 3*b4))));
|
|
| 78 | 78 |
} |
| 79 | 79 |
|
| 80 | 80 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| ... | ... | |
| 82 | 82 |
byte retrievePacked(int index) |
| 83 | 83 |
{
|
| 84 | 84 |
int indexToRetrieve = index/5; |
| 85 |
byte val = mPackedTable[indexToRetrieve]; |
|
| 86 |
|
|
| 87 |
byte b4 = (byte)(val%3); val/=3; |
|
| 88 |
byte b3 = (byte)(val%3); val/=3; |
|
| 89 |
byte b2 = (byte)(val%3); val/=3; |
|
| 90 |
byte b1 = (byte)(val%3); val/=3; |
|
| 91 |
byte b0 = (byte)(val%3); |
|
| 92 |
|
|
| 93 |
switch(index%5) |
|
| 94 |
{
|
|
| 95 |
case 0: return b0; |
|
| 96 |
case 1: return b1; |
|
| 97 |
case 2: return b2; |
|
| 98 |
case 3: return b3; |
|
| 99 |
case 4: return b4; |
|
| 100 |
} |
|
| 101 |
|
|
| 102 |
return 0; |
|
| 85 |
int val = mPackedTable[indexToRetrieve] & 0xff; // convert to 'unsigned' |
|
| 86 |
int offset = (index%5); |
|
| 87 |
|
|
| 88 |
if(offset==0) return (byte)(val%3); |
|
| 89 |
val/=3; |
|
| 90 |
if(offset==1) return (byte)(val%3); |
|
| 91 |
val/=3; |
|
| 92 |
if(offset==2) return (byte)(val%3); |
|
| 93 |
val/=3; |
|
| 94 |
if(offset==3) return (byte)(val%3); |
|
| 95 |
val/=3; |
|
| 96 |
return (byte)(val%3); |
|
| 103 | 97 |
} |
| 104 | 98 |
|
| 105 | 99 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| ... | ... | |
| 114 | 108 |
byte unpacked = retrieveUnpacked(i); |
| 115 | 109 |
insertPacked(i,unpacked); |
| 116 | 110 |
} |
| 111 |
|
|
| 112 |
for(int i=0; i<size; i++) |
|
| 113 |
{
|
|
| 114 |
byte unpacked = retrieveUnpacked(i); |
|
| 115 |
byte packed = retrievePacked(i); |
|
| 116 |
|
|
| 117 |
String m = "index="+i+" offset="+(i%5)+" unpacked="+unpacked+" packed="+packed; |
|
| 118 |
if( ((unpacked%3) != packed) ) android.util.Log.e("D", m);
|
|
| 119 |
else android.util.Log.d("D", m);
|
|
| 120 |
} |
|
| 117 | 121 |
} |
| 118 | 122 |
} |
| src/main/java/org/distorted/objectlib/tablebases/TablebasesCreator.java | ||
|---|---|---|
| 14 | 14 |
import org.distorted.library.type.Static4D; |
| 15 | 15 |
import org.distorted.objectlib.helpers.QuatGroupGenerator; |
| 16 | 16 |
|
| 17 |
import java.util.ArrayList; |
|
| 18 |
|
|
| 17 | 19 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 18 | 20 |
|
| 19 | 21 |
public abstract class TablebasesCreator |
| ... | ... | |
| 256 | 258 |
|
| 257 | 259 |
insertingLevel++; |
| 258 | 260 |
|
| 259 |
// android.util.Log.e("D", "inserted "+numInserted+" positions at level "+insertingLevel);
|
|
| 261 |
android.util.Log.e("D", "inserted "+numInserted+" positions at level "+insertingLevel);
|
|
| 260 | 262 |
} |
| 261 | 263 |
while( numInserted>0 ); |
| 264 |
|
|
| 265 |
mTablebase.pack(); |
|
| 262 | 266 |
} |
| 263 | 267 |
|
| 264 | 268 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 265 | 269 |
|
| 266 |
private void setupMove(int[] move, int axis, int layer, int angle)
|
|
| 270 |
private void addMove(ArrayList<int[]> moves, int axis, int layer, int angle)
|
|
| 267 | 271 |
{
|
| 268 | 272 |
int maxAngle = mAngles[axis][layer]; |
| 269 | 273 |
angle = maxAngle-angle; |
| 270 | 274 |
if( angle> 0.5f*maxAngle ) angle -= maxAngle; |
| 271 | 275 |
|
| 272 |
move[0] = axis; |
|
| 273 |
move[1] = (1<<layer); |
|
| 274 |
move[2] = angle; |
|
| 276 |
int[] move = new int[] { axis, (1<<layer), angle };
|
|
| 277 |
moves.add(move); |
|
| 278 |
} |
|
| 279 |
|
|
| 280 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 281 |
|
|
| 282 |
private int[][] convertMoves(ArrayList<int[]> moves) |
|
| 283 |
{
|
|
| 284 |
int len = moves.size(); |
|
| 285 |
int[][] ret = new int[len][]; |
|
| 286 |
for(int i=0; i<len; i++) ret[i] = moves.get(i); |
|
| 287 |
return ret; |
|
| 275 | 288 |
} |
| 276 | 289 |
|
| 277 | 290 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| ... | ... | |
| 279 | 292 |
public int[][] solution(int index) |
| 280 | 293 |
{
|
| 281 | 294 |
byte level = mTablebase.retrieveUnpacked(index); |
| 282 |
int[][] moves = level>0 ? new int[level][3] : null; |
|
| 283 |
int currMove = 0; |
|
| 295 |
ArrayList<int[]> moves = new ArrayList<>(); |
|
| 284 | 296 |
int quatBasis = 0; |
| 285 | 297 |
int[] quats = getQuats(index); |
| 286 | 298 |
int numQuats = quats.length; |
| 287 | 299 |
int[] tmpQuats = new int[numQuats]; |
| 288 | 300 |
boolean[] belongs = new boolean[mNumCubits]; |
| 289 | 301 |
|
| 290 |
while(level>0)
|
|
| 302 |
while(index!=0)
|
|
| 291 | 303 |
{
|
| 292 | 304 |
for(int ax=0; ax<mNumAxis; ax++) |
| 293 | 305 |
{
|
| ... | ... | |
| 323 | 335 |
int childIndex = getIndex(tmpQuats); |
| 324 | 336 |
byte newLevel = mTablebase.retrieveUnpacked(childIndex); |
| 325 | 337 |
|
| 326 |
if( newLevel==level-1 )
|
|
| 338 |
if( (newLevel%3) == ((level-1)%3) )
|
|
| 327 | 339 |
{
|
| 328 |
setupMove(moves[currMove],ax,layer,angle); |
|
| 329 |
currMove++; |
|
| 330 |
|
|
| 340 |
addMove(moves,ax,layer,angle); |
|
| 331 | 341 |
angle=maxAngle; |
| 332 | 342 |
layer=numLayers; |
| 333 | 343 |
ax=mNumAxis; |
| 334 | 344 |
index = childIndex; |
| 335 |
level = newLevel;
|
|
| 345 |
level = (level==0 ? 2 : (byte)(level-1));
|
|
| 336 | 346 |
} |
| 337 | 347 |
} |
| 338 | 348 |
} |
| ... | ... | |
| 344 | 354 |
quats = getQuats(index); |
| 345 | 355 |
} |
| 346 | 356 |
|
| 347 |
return moves;
|
|
| 357 |
return convertMoves(moves);
|
|
| 348 | 358 |
} |
| 349 | 359 |
} |
Also available in: Unified diff
Pyraminx Duo solver: improve unpacked DB. Packed still doesn't work.