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); |
| src/main/java/org/distorted/objectlib/tablebases/TablebasesAbstract.java | ||
|---|---|---|
| 166 | 166 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 167 | 167 |
// remember about the double cover or unit quaternions! |
| 168 | 168 |
|
| 169 |
private int mulQuat(int q1, int q2)
|
|
| 169 |
public static int mulQuat(int q1, int q2, Static4D[] quats)
|
|
| 170 | 170 |
{
|
| 171 |
Static4D result = QuatHelper.quatMultiply(mQuats[q1],mQuats[q2]); |
|
| 171 |
int numQuats = quats.length; |
|
| 172 |
Static4D result = QuatHelper.quatMultiply(quats[q1],quats[q2]); |
|
| 172 | 173 |
|
| 173 | 174 |
float rX = result.get0(); |
| 174 | 175 |
float rY = result.get1(); |
| ... | ... | |
| 178 | 179 |
final float MAX_ERROR = 0.1f; |
| 179 | 180 |
float dX,dY,dZ,dW; |
| 180 | 181 |
|
| 181 |
for(int i=0; i<mNumQuats; i++)
|
|
| 182 |
for(int i=0; i<numQuats; i++)
|
|
| 182 | 183 |
{
|
| 183 |
dX = mQuats[i].get0() - rX;
|
|
| 184 |
dY = mQuats[i].get1() - rY;
|
|
| 185 |
dZ = mQuats[i].get2() - rZ;
|
|
| 186 |
dW = mQuats[i].get3() - rW;
|
|
| 184 |
dX = quats[i].get0() - rX;
|
|
| 185 |
dY = quats[i].get1() - rY;
|
|
| 186 |
dZ = quats[i].get2() - rZ;
|
|
| 187 |
dW = quats[i].get3() - rW;
|
|
| 187 | 188 |
|
| 188 | 189 |
if( dX<MAX_ERROR && dX>-MAX_ERROR && |
| 189 | 190 |
dY<MAX_ERROR && dY>-MAX_ERROR && |
| 190 | 191 |
dZ<MAX_ERROR && dZ>-MAX_ERROR && |
| 191 | 192 |
dW<MAX_ERROR && dW>-MAX_ERROR ) return i; |
| 192 | 193 |
|
| 193 |
dX = mQuats[i].get0() + rX;
|
|
| 194 |
dY = mQuats[i].get1() + rY;
|
|
| 195 |
dZ = mQuats[i].get2() + rZ;
|
|
| 196 |
dW = mQuats[i].get3() + rW;
|
|
| 194 |
dX = quats[i].get0() + rX;
|
|
| 195 |
dY = quats[i].get1() + rY;
|
|
| 196 |
dZ = quats[i].get2() + rZ;
|
|
| 197 |
dW = quats[i].get3() + rW;
|
|
| 197 | 198 |
|
| 198 | 199 |
if( dX<MAX_ERROR && dX>-MAX_ERROR && |
| 199 | 200 |
dY<MAX_ERROR && dY>-MAX_ERROR && |
| ... | ... | |
| 218 | 219 |
|
| 219 | 220 |
if( index1<mNumQuats && index2<mNumQuats ) |
| 220 | 221 |
{
|
| 221 |
if( mQuatMult[index1][index2]==-1 ) mQuatMult[index1][index2] = mulQuat(index1,index2); |
|
| 222 |
if( mQuatMult[index1][index2]==-1 ) mQuatMult[index1][index2] = mulQuat(index1,index2, mQuats);
|
|
| 222 | 223 |
return mQuatMult[index1][index2]; |
| 223 | 224 |
} |
| 224 | 225 |
|
Also available in: Unified diff
CU_323 solver: corrections.