Revision 62b9f665
Added by Leszek Koltunski 12 months ago
| src/main/java/org/distorted/objectlib/tablebases/TablebasesAbstract.java | ||
|---|---|---|
| 39 | 39 |
Tablebase mTablebase; |
| 40 | 40 |
boolean mInitialized; |
| 41 | 41 |
|
| 42 |
final Static4D[] mQuats;
|
|
| 42 |
final float[][] mQuats;
|
|
| 43 | 43 |
final int mScalingFactor; |
| 44 | 44 |
final int mNumAxis; |
| 45 | 45 |
final float[][] mPosition; |
| ... | ... | |
| 74 | 74 |
mNumAxis = mAxis.length; |
| 75 | 75 |
mNumLayers = new int[mNumAxis]; |
| 76 | 76 |
for(int i=0; i<mNumAxis; i++) mNumLayers[i] = mAngles[i].length; |
| 77 |
mQuats = QuatGroupGenerator.computeGroup(mAxis,mAngles); |
|
| 78 |
mNumQuats = mQuats.length; |
|
| 77 |
|
|
| 78 |
Static4D[] quats = QuatGroupGenerator.computeGroup(mAxis,mAngles); |
|
| 79 |
mNumQuats = quats.length; |
|
| 80 |
mQuats = new float[mNumQuats][]; |
|
| 81 |
|
|
| 82 |
for(int i=0; i<mNumQuats; i++) |
|
| 83 |
{
|
|
| 84 |
Static4D q = quats[i]; |
|
| 85 |
mQuats[i] = new float[] {q.get0(),q.get1(),q.get2(),q.get3()};
|
|
| 86 |
} |
|
| 87 |
|
|
| 79 | 88 |
mPosition = getPosition(); |
| 80 | 89 |
mNumCubits = mPosition.length; |
| 81 | 90 |
mRotatable = getRotatable(); |
| ... | ... | |
| 135 | 144 |
|
| 136 | 145 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 137 | 146 |
|
| 138 |
int computeRow(float[] pos, int quat, int axisIndex)
|
|
| 147 |
void computeRow(float[] pos, int quat, int[] output)
|
|
| 139 | 148 |
{
|
| 140 |
int ret=0; |
|
| 141 | 149 |
int len = pos.length/3; |
| 142 |
Static3D axis = mAxis[axisIndex]; |
|
| 143 |
float axisX = axis.get0(); |
|
| 144 |
float axisY = axis.get1(); |
|
| 145 |
float axisZ = axis.get2(); |
|
| 146 |
float casted; |
|
| 147 |
Static4D q = mQuats[quat]; |
|
| 150 |
float[] q = mQuats[quat]; |
|
| 151 |
int num = output.length; |
|
| 148 | 152 |
|
| 149 | 153 |
for(int i=0; i<len; i++) |
| 150 | 154 |
{
|
| 151 | 155 |
QuatHelper.rotateVectorByQuat(mTmp,pos[3*i],pos[3*i+1],pos[3*i+2],1.0f,q); |
| 152 |
casted = mTmp[0]*axisX + mTmp[1]*axisY + mTmp[2]*axisZ; |
|
| 153 |
ret |= computeSingleRow(axisIndex,casted); |
|
| 154 |
} |
|
| 155 | 156 |
|
| 156 |
return ret; |
|
| 157 |
for(int j=0; j<num; j++) |
|
| 158 |
{
|
|
| 159 |
output[j] = 0; |
|
| 160 |
Static3D axis = mAxis[j]; |
|
| 161 |
float axisX = axis.get0(); |
|
| 162 |
float axisY = axis.get1(); |
|
| 163 |
float axisZ = axis.get2(); |
|
| 164 |
float casted = mTmp[0]*axisX + mTmp[1]*axisY + mTmp[2]*axisZ; |
|
| 165 |
output[j] |= computeSingleRow(j,casted); |
|
| 166 |
} |
|
| 167 |
} |
|
| 157 | 168 |
} |
| 158 | 169 |
|
| 159 | 170 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| ... | ... | |
| 173 | 184 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 174 | 185 |
// remember about the double cover or unit quaternions! |
| 175 | 186 |
|
| 176 |
public static int mulQuat(int q1, int q2, Static4D[] quats)
|
|
| 187 |
public static int mulQuat(int q1, int q2, float[][] quats)
|
|
| 177 | 188 |
{
|
| 178 | 189 |
int numQuats = quats.length; |
| 179 |
Static4D result = QuatHelper.quatMultiply(quats[q1],quats[q2]);
|
|
| 190 |
float[] result = QuatHelper.quatMultiply(quats[q1],quats[q2]);
|
|
| 180 | 191 |
|
| 181 |
float rX = result.get0();
|
|
| 182 |
float rY = result.get1();
|
|
| 183 |
float rZ = result.get2();
|
|
| 184 |
float rW = result.get3();
|
|
| 192 |
float rX = result[0];
|
|
| 193 |
float rY = result[1];
|
|
| 194 |
float rZ = result[2];
|
|
| 195 |
float rW = result[3];
|
|
| 185 | 196 |
|
| 186 | 197 |
final float MAX_ERROR = 0.1f; |
| 187 | 198 |
float dX,dY,dZ,dW; |
| 188 | 199 |
|
| 189 | 200 |
for(int i=0; i<numQuats; i++) |
| 190 | 201 |
{
|
| 191 |
dX = quats[i].get0() - rX; |
|
| 192 |
dY = quats[i].get1() - rY; |
|
| 193 |
dZ = quats[i].get2() - rZ; |
|
| 194 |
dW = quats[i].get3() - rW; |
|
| 202 |
float[] q = quats[i]; |
|
| 203 |
dX = q[0] - rX; |
|
| 204 |
dY = q[1] - rY; |
|
| 205 |
dZ = q[2] - rZ; |
|
| 206 |
dW = q[3] - rW; |
|
| 195 | 207 |
|
| 196 | 208 |
if( dX<MAX_ERROR && dX>-MAX_ERROR && |
| 197 | 209 |
dY<MAX_ERROR && dY>-MAX_ERROR && |
| 198 | 210 |
dZ<MAX_ERROR && dZ>-MAX_ERROR && |
| 199 | 211 |
dW<MAX_ERROR && dW>-MAX_ERROR ) return i; |
| 200 | 212 |
|
| 201 |
dX = quats[i].get0() + rX;
|
|
| 202 |
dY = quats[i].get1() + rY;
|
|
| 203 |
dZ = quats[i].get2() + rZ;
|
|
| 204 |
dW = quats[i].get3() + rW;
|
|
| 213 |
dX = q[0] + rX;
|
|
| 214 |
dY = q[1] + rY;
|
|
| 215 |
dZ = q[2] + rZ;
|
|
| 216 |
dW = q[3] + rW;
|
|
| 205 | 217 |
|
| 206 | 218 |
if( dX<MAX_ERROR && dX>-MAX_ERROR && |
| 207 | 219 |
dY<MAX_ERROR && dY>-MAX_ERROR && |
| ... | ... | |
| 269 | 281 |
byte newLevel = (byte)(level+1); |
| 270 | 282 |
int quatBasis = 0; |
| 271 | 283 |
|
| 272 |
for(int ax=0; ax<mNumAxis; ax++) |
|
| 273 |
for(int cubit=0; cubit<mNumCubits; cubit++) |
|
| 274 |
mRotRow[cubit][ax] = computeRow(mPosition[cubit],quats[cubit],ax); |
|
| 284 |
for(int cubit=0; cubit<mNumCubits; cubit++) computeRow(mPosition[cubit],quats[cubit],mRotRow[cubit]); |
|
| 275 | 285 |
|
| 276 | 286 |
for(int ax=0; ax<mNumAxis; ax++) |
| 277 | 287 |
{
|
| ... | ... | |
| 472 | 482 |
data[2]=1; |
| 473 | 483 |
data[3]=1; |
| 474 | 484 |
|
| 475 |
for(int ax=0; ax<mNumAxis; ax++) |
|
| 476 |
for(int cubit=0; cubit<mNumCubits; cubit++) |
|
| 477 |
mRotRow[cubit][ax] = computeRow(mPosition[cubit],quats[cubit],ax); |
|
| 485 |
for(int cubit=0; cubit<mNumCubits; cubit++) computeRow(mPosition[cubit],quats[cubit],mRotRow[cubit]); |
|
| 478 | 486 |
|
| 479 | 487 |
for(int s=0; s<mScalingFactor && !found; s++) |
| 480 | 488 |
{
|
| ... | ... | |
| 578 | 586 |
data[2]=1; |
| 579 | 587 |
data[3]=1; |
| 580 | 588 |
|
| 581 |
for(int ax=0; ax<mNumAxis; ax++) |
|
| 582 |
for(int cubit=0; cubit<mNumCubits; cubit++) |
|
| 583 |
mRotRow[cubit][ax] = computeRow(mPosition[cubit],quats[cubit],ax); |
|
| 589 |
for(int cubit=0; cubit<mNumCubits; cubit++) computeRow(mPosition[cubit],quats[cubit],mRotRow[cubit]); |
|
| 584 | 590 |
|
| 585 | 591 |
for(int s=0; s<mScalingFactor; s++) |
| 586 | 592 |
{
|
Also available in: Unified diff
speedup