src/test/java/jp/sfjp/mikutoga/math/MkQuatTest.java

   1 /*
   2  */
   3
   4 package jp.sfjp.mikutoga.math;
   5
   6 import org.junit.After;
   7 import org.junit.AfterClass;
   8 import org.junit.Before;
   9 import org.junit.BeforeClass;
  10 import org.junit.Test;
  11 import static org.junit.Assert.*;
  12
  13 /**
  14  *
  15  */
  16 public strictfp class MkQuatTest {
  17
  18     private static final double RAD_90DEG = StrictMath.PI / 2.0;
  19     private static final double RAD_60DEG = StrictMath.PI / 3.0;
  20     private static final double RAD_45DEG = StrictMath.PI / 4.0;
  21     private static final double RAD_30DEG = StrictMath.PI / 6.0;
  22     private static final double RAD_15DEG = StrictMath.PI / 12.0;
  23     private static final double EPSILON = StrictMath.ulp(1.0);
  24
  25     public MkQuatTest() {
  26     }
  27
  28     @BeforeClass
  29     public static void setUpClass() {
  30     }
  31
  32     @AfterClass
  33     public static void tearDownClass() {
  34     }
  35
  36     @Before
  37     public void setUp() {
  38     }
  39
  40     @After
  41     public void tearDown() {
  42     }
  43
  44     private void assert0UlpEquals(double expected, double result){
  45         assertUlpEquals(expected, result, 0);
  46         return;
  47     }
  48
  49     private void assertUlpEquals(double expected, double result, int ulpNum){
  50         double ulpExpected = StrictMath.ulp(expected);
  51         double ulpResult   = StrictMath.ulp(result);
  52         double ulp = StrictMath.max(ulpExpected, ulpResult);
  53         double delta = ulp * ulpNum;
  54
  55         try{
  56             assertEquals(expected, result, delta);
  57         }catch(AssertionError e){
  58             double dist = StrictMath.abs(expected - result);
  59             String msg = e.getMessage();
  60             msg += " ULP * " + (dist / ulp);
  61             AssertionError err = new AssertionError(msg);
  62             err.initCause(e);
  63             throw err;
  64         }
  65
  66         return;
  67     }
  68
  69     /**
  70      * Test of constructor, of class MkQuat.
  71      */
  72     @Test
  73     public void testCons() {
  74         System.out.println("constructor");
  75
  76         MkQuat qq;
  77
  78         qq = new MkQuat();
  79         assert0UlpEquals(0.0, qq.getQ1());
  80         assert0UlpEquals(0.0, qq.getQ2());
  81         assert0UlpEquals(0.0, qq.getQ3());
  82         assert0UlpEquals(1.0, qq.getQW());
  83
  84         qq.setQ1(2.0);
  85         assert0UlpEquals(2.0, qq.getQ1());
  86         assert0UlpEquals(0.0, qq.getQ2());
  87         assert0UlpEquals(0.0, qq.getQ3());
  88         assert0UlpEquals(1.0, qq.getQW());
  89
  90         qq.setQ2(3.0);
  91         assert0UlpEquals(2.0, qq.getQ1());
  92         assert0UlpEquals(3.0, qq.getQ2());
  93         assert0UlpEquals(0.0, qq.getQ3());
  94         assert0UlpEquals(1.0, qq.getQW());
  95
  96         qq.setQ3(4.0);
  97         assert0UlpEquals(2.0, qq.getQ1());
  98         assert0UlpEquals(3.0, qq.getQ2());
  99         assert0UlpEquals(4.0, qq.getQ3());
 100         assert0UlpEquals(1.0, qq.getQW());
 101
 102         qq.setQW(5.0);
 103         assert0UlpEquals(2.0, qq.getQ1());
 104         assert0UlpEquals(3.0, qq.getQ2());
 105         assert0UlpEquals(4.0, qq.getQ3());
 106         assert0UlpEquals(5.0, qq.getQW());
 107
 108         qq.setQ123W(6.0, 7.0, 8.0, 9.0);
 109         assert0UlpEquals(6.0, qq.getQ1());
 110         assert0UlpEquals(7.0, qq.getQ2());
 111         assert0UlpEquals(8.0, qq.getQ3());
 112         assert0UlpEquals(9.0, qq.getQW());
 113
 114         qq = new MkQuat(0.1, 0.2, 0.3, 0.4);
 115         assert0UlpEquals(0.1, qq.getQ1());
 116         assert0UlpEquals(0.2, qq.getQ2());
 117         assert0UlpEquals(0.3, qq.getQ3());
 118         assert0UlpEquals(0.4, qq.getQW());
 119
 120         MkQuat qqx = new MkQuat(1.0, 2.0, 3.0, 4.0);
 121         qq = new MkQuat(qqx);
 122         assert0UlpEquals(1.0, qq.getQ1());
 123         assert0UlpEquals(2.0, qq.getQ2());
 124         assert0UlpEquals(3.0, qq.getQ3());
 125         assert0UlpEquals(4.0, qq.getQW());
 126
 127         return;
 128     }
 129
 130     /**
 131      * Test of mul method, of class MkQuat.
 132      */
 133     @Test
 134     public void testMul() {
 135         System.out.println("mul");
 136
 137         MkQuat qqa;
 138         MkQuat qqb;
 139         MkQuat result;
 140
 141         result = new MkQuat();
 142
 143         qqa = new MkQuat(1.0, 2.0, 3.0, 4.0);
 144         qqb = new MkQuat(5.0, 6.0, 7.0, 8.0);
 145         MkQuat.mul(qqa, qqb, result);
 146         assert0UlpEquals(24.0, result.getQ1());
 147         assert0UlpEquals(48.0, result.getQ2());
 148         assert0UlpEquals(48.0, result.getQ3());
 149         assert0UlpEquals(-6.0, result.getQW());
 150
 151         qqa = new MkQuat(1.0, 2.0, 3.0, 4.0);
 152         qqb = new MkQuat(6.0, 7.0, 8.0, 9.0);
 153         MkQuat.mul(qqa, qqb, result);
 154         assert0UlpEquals(28.0, result.getQ1());
 155         assert0UlpEquals(56.0, result.getQ2());
 156         assert0UlpEquals(54.0, result.getQ3());
 157         assert0UlpEquals(-8.0, result.getQW());
 158
 159         EulerYXZ eu = new EulerYXZ();
 160         qqa.setEulerYXZ(0.0, RAD_60DEG, 0.0);
 161         qqb.setEulerYXZ(RAD_30DEG, 0.0, 0.0);
 162         MkQuat.mul(qqa, qqb, result);
 163         result.toEulerYXZ(eu, 0.0);
 164         assertUlpEquals(RAD_30DEG, eu.getXRot(), 1);
 165         assertUlpEquals(RAD_60DEG, eu.getYRot(), 0);
 166         assertEquals(0.0, eu.getZRot(), EPSILON);
 167
 168         qqa.setEulerYXZ(0.0, RAD_15DEG, 0.0);
 169         qqb.setEulerYXZ(0.0, RAD_30DEG, 0.0);
 170         MkQuat.mul(qqa, qqb, result);
 171         result.toEulerYXZ(eu, 0.0);
 172         assert0UlpEquals(0.0, eu.getXRot());
 173         assert0UlpEquals(RAD_45DEG, eu.getYRot());
 174         assert0UlpEquals(0.0, eu.getZRot());
 175
 176         return;
 177     }
 178
 179     /**
 180      * Test of conjugate method, of class MkQuat.
 181      */
 182     @Test
 183     public void testConjugate() {
 184         System.out.println("conjugate");
 185
 186         MkQuat qq;
 187         MkQuat result;
 188
 189         qq = new MkQuat(1.0, 2.0, 3.0, 4.0);
 190         result = new MkQuat();
 191         MkQuat.conjugate(qq, result);
 192         assert0UlpEquals(-1.0, result.getQ1());
 193         assert0UlpEquals(-2.0, result.getQ2());
 194         assert0UlpEquals(-3.0, result.getQ3());
 195         assert0UlpEquals(4.0, result.getQW());
 196
 197         return;
 198     }
 199
 200     /**
 201      * Test of normalize method, of class MkQuat.
 202      */
 203     @Test
 204     public void testNormalize() {
 205         System.out.println("normalize");
 206
 207         MkQuat qq;
 208         MkQuat result;
 209
 210         qq = new MkQuat();
 211         result = new MkQuat();
 212         MkQuat.normalize(qq, result);
 213         assert0UlpEquals(0.0, result.getQ1());
 214         assert0UlpEquals(0.0, result.getQ2());
 215         assert0UlpEquals(0.0, result.getQ3());
 216         assert0UlpEquals(1.0, result.getQW());
 217
 218         qq = new MkQuat(2.0, 2.0, 2.0, 2.0);
 219         MkQuat.normalize(qq, result);
 220         assert0UlpEquals(0.5, result.getQ1());
 221         assert0UlpEquals(0.5, result.getQ2());
 222         assert0UlpEquals(0.5, result.getQ3());
 223         assert0UlpEquals(0.5, result.getQW());
 224
 225         return;
 226     }
 227
 228     /**
 229      * Test of inverse method, of class MkQuat.
 230      */
 231     @Test
 232     public void testInverse() {
 233         System.out.println("inverse");
 234
 235         MkQuat qq;
 236         MkQuat result;
 237
 238         qq = new MkQuat();
 239         result = new MkQuat();
 240         MkQuat.inverse(qq, result);
 241         assert0UlpEquals(0.0, result.getQ1());
 242         assert0UlpEquals(0.0, result.getQ2());
 243         assert0UlpEquals(0.0, result.getQ3());
 244         assert0UlpEquals(1.0, result.getQW());
 245
 246         qq = new MkQuat(2.0, 2.0, 2.0, 2.0);
 247         MkQuat.inverse(qq, result);
 248         assert0UlpEquals(-0.125, result.getQ1());
 249         assert0UlpEquals(-0.125, result.getQ2());
 250         assert0UlpEquals(-0.125, result.getQ3());
 251         assert0UlpEquals(0.125, result.getQW());
 252
 253         return;
 254     }
 255
 256     /**
 257      * Test of abs method, of class MkQuat.
 258      */
 259     @Test
 260     public void testAbs() {
 261         System.out.println("abs");
 262
 263         MkQuat qq;
 264
 265         qq = new MkQuat();
 266         assert0UlpEquals(1.0, qq.abs());
 267
 268         qq = new MkQuat(0.0, 0.0, 0.0, 0.0);
 269         assert0UlpEquals(0.0, qq.abs());
 270
 271         qq = new MkQuat(1.0, 2.0, 0.0, 2.0);
 272         assert0UlpEquals(3.0, qq.abs());
 273
 274         qq = new MkQuat(2.0, 2.0, 2.0, 2.0);
 275         assert0UlpEquals(4.0, qq.abs());
 276
 277         return;
 278     }
 279
 280     /**
 281      * Test of setPos3D method, of class MkQuat.
 282      */
 283     @Test
 284     public void testReadPos3D_3args() {
 285         System.out.println("readPos3D");
 286
 287         MkQuat qq;
 288
 289         qq = new MkQuat(9, 9, 9, 9);
 290         qq.setPos3D(1.0, 2.0, 3.0);
 291         assert0UlpEquals(1.0, qq.getQ1());
 292         assert0UlpEquals(2.0, qq.getQ2());
 293         assert0UlpEquals(3.0, qq.getQ3());
 294         assert0UlpEquals(0.0, qq.getQW());
 295
 296         return;
 297     }
 298
 299     /**
 300      * Test of setPos3D method, of class MkQuat.
 301      */
 302     @Test
 303     public void testReadPos3D_MkPos3D() {
 304         System.out.println("readPos3D");
 305
 306         MkQuat qq;
 307         MkPos3D pos;
 308
 309         qq = new MkQuat(9, 9, 9, 9);
 310         pos = new MkPos3D(1.0, 2.0, 3.0);
 311         qq.setPos3D(pos);
 312         assert0UlpEquals(1.0, qq.getQ1());
 313         assert0UlpEquals(2.0, qq.getQ2());
 314         assert0UlpEquals(3.0, qq.getQ3());
 315         assert0UlpEquals(0.0, qq.getQW());
 316
 317         return;
 318     }
 319
 320     /**
 321      * Test of setEulerYXZ method, of class MkQuat.
 322      */
 323     @Test
 324     public void testReadEulerYXZ_3args() {
 325         System.out.println("readEulerYXZ");
 326
 327         MkQuat qq;
 328
 329         qq = new MkQuat(9, 9, 9, 9);
 330         qq.setEulerYXZ(0.0, 0.0, 0.0);
 331         assert0UlpEquals(0.0, qq.getQ1());
 332         assert0UlpEquals(0.0, qq.getQ2());
 333         assert0UlpEquals(0.0, qq.getQ3());
 334         assert0UlpEquals(1.0, qq.getQW());
 335
 336         return;
 337     }
 338
 339     /**
 340      * Test of setEulerYXZ method, of class MkQuat.
 341      */
 342     @Test
 343     public void testReadEulerYXZ_EulerYXZ() {
 344         System.out.println("readEulerYXZ");
 345
 346         MkQuat qq;
 347         EulerYXZ yxz;
 348
 349         qq = new MkQuat(9, 9, 9, 9);
 350         yxz = new EulerYXZ();
 351         qq.setEulerYXZ(yxz);
 352         assert0UlpEquals(0.0, qq.getQ1());
 353         assert0UlpEquals(0.0, qq.getQ2());
 354         assert0UlpEquals(0.0, qq.getQ3());
 355         assert0UlpEquals(1.0, qq.getQW());
 356
 357         return;
 358     }
 359
 360     /**
 361      * Test of toEulerYXZ method, of class MkQuat.
 362      */
 363     @Test
 364     public void testToEulerYXZ_EulerYXZ_double() {
 365         System.out.println("toEulerYXZ");
 366
 367         EulerYXZ eu;
 368         MkQuat qq;
 369
 370         qq = new MkQuat();
 371
 372         qq.setEulerYXZ(1.0, 2.0, 3.0);
 373         eu = new EulerYXZ();
 374         qq.toEulerYXZ(eu, 0.0);
 375         assertUlpEquals(1.0, eu.getXRot(), 1);
 376         assertUlpEquals(2.0, eu.getYRot(), 2);
 377         assertUlpEquals(3.0, eu.getZRot(), 0);
 378
 379         // ジンバルロック
 380
 381         qq.setEulerYXZ(RAD_90DEG, 0.0, 0.0);
 382         qq.toEulerYXZ(eu, 0.0);
 383         assert0UlpEquals(RAD_90DEG, eu.getXRot());
 384         assert0UlpEquals(0.0, eu.getYRot());
 385         assert0UlpEquals(0.0, eu.getZRot());
 386
 387         qq.setEulerYXZ(RAD_90DEG, RAD_30DEG, 0.0);
 388         qq.toEulerYXZ(eu, 0.0);
 389         assert0UlpEquals(RAD_90DEG, eu.getXRot());
 390         assert0UlpEquals(0.0, eu.getYRot());
 391         assertUlpEquals(-RAD_30DEG, eu.getZRot(), 1);
 392
 393         qq.toEulerYXZ(eu, RAD_15DEG);
 394         assert0UlpEquals(RAD_90DEG, eu.getXRot());
 395         assert0UlpEquals(RAD_15DEG, eu.getYRot());
 396         assertUlpEquals(-RAD_15DEG, eu.getZRot(), 2);
 397
 398         qq.setEulerYXZ(-RAD_90DEG, RAD_30DEG, 0.0);
 399         qq.toEulerYXZ(eu, 0.0);
 400         assert0UlpEquals(-RAD_90DEG, eu.getXRot());
 401         assert0UlpEquals(0.0, eu.getYRot());
 402         assertUlpEquals(RAD_30DEG, eu.getZRot(), 1);
 403
 404         qq.toEulerYXZ(eu, RAD_15DEG);
 405         assert0UlpEquals(-RAD_90DEG, eu.getXRot());
 406         assert0UlpEquals(RAD_15DEG, eu.getYRot());
 407         assertUlpEquals(RAD_15DEG, eu.getZRot(), 2);
 408
 409         qq.setEulerYXZ(RAD_90DEG, RAD_45DEG, 0.0);
 410         qq.toEulerYXZ(eu, 0.0);
 411         assert0UlpEquals(RAD_90DEG, eu.getXRot());
 412         assert0UlpEquals(0.0, eu.getYRot());
 413         assert0UlpEquals(-RAD_45DEG, eu.getZRot());
 414
 415         qq.setEulerYXZ(RAD_90DEG, RAD_45DEG, RAD_45DEG);
 416         qq.toEulerYXZ(eu, 0.0);
 417         assert0UlpEquals(RAD_90DEG, eu.getXRot());
 418         assert0UlpEquals(0.0, eu.getYRot());
 419         assertEquals(0.0, eu.getZRot(), EPSILON);
 420
 421         qq.setEulerYXZ(RAD_90DEG, RAD_30DEG, RAD_60DEG);
 422         qq.toEulerYXZ(eu, 0.0);
 423         assert0UlpEquals(RAD_90DEG, eu.getXRot());
 424         assert0UlpEquals(0.0, eu.getYRot());
 425         assert0UlpEquals(RAD_30DEG, eu.getZRot());
 426
 427         qq.setEulerYXZ(RAD_30DEG, RAD_45DEG, RAD_45DEG);
 428         qq.toEulerYXZ(eu, 0.0);
 429         assertUlpEquals(RAD_30DEG, eu.getXRot(), 1);
 430         assertUlpEquals(RAD_45DEG, eu.getYRot(), 1);
 431         assertUlpEquals(RAD_45DEG, eu.getZRot(), 1);
 432
 433         double xRad;
 434         double yRad;
 435         double zRad;
 436
 437         xRad = StrictMath.toRadians(95);
 438         yRad = StrictMath.toRadians(0);
 439         zRad = StrictMath.toRadians(0);
 440         qq.setEulerYXZ(xRad, yRad, zRad);
 441         qq.toEulerYXZ(eu, yRad);
 442         assertUlpEquals(StrictMath.toRadians(85), eu.getXRot(), 1);
 443         assertUlpEquals(StrictMath.toRadians(180), eu.getYRot(), 0);
 444         assertUlpEquals(StrictMath.toRadians(180), eu.getZRot(), 0);
 445
 446         return;
 447     }
 448
 449     /**
 450      * Test of critical case, of class MkQuat.
 451      */
 452     @Test
 453     public void testCritical() {
 454         System.out.println("critical");
 455
 456         EulerYXZ eu;
 457         MkQuat qq;
 458         double xRad;
 459         double yRad;
 460         double zRad;
 461
 462         qq = new MkQuat();
 463         eu = new EulerYXZ();
 464
 465         xRad = StrictMath.toRadians(89);
 466         yRad = StrictMath.toRadians(80);
 467         zRad = StrictMath.toRadians(41);
 468         qq.setEulerYXZ(xRad, yRad, zRad);
 469         qq.toEulerYXZ(eu, 0.0);
 470         assertUlpEquals(xRad, eu.getXRot(), 164);
 471         assertUlpEquals(yRad, eu.getYRot(), 143);
 472         assertUlpEquals(zRad, eu.getZRot(), 211);
 473
 474         // ジンバルロック判定境界ケース
 475         xRad = StrictMath.toRadians(90);
 476         yRad = StrictMath.toRadians(6);
 477         zRad = StrictMath.toRadians(7);
 478         qq.setEulerYXZ(xRad, yRad, zRad);
 479         qq.toEulerYXZ(eu, yRad);
 480         assert0UlpEquals(xRad, eu.getXRot());
 481         assert0UlpEquals(yRad, eu.getYRot());
 482         assert0UlpEquals(zRad, eu.getZRot());
 483
 484         xRad = StrictMath.toRadians(89.999);
 485         yRad = StrictMath.toRadians(89.999);
 486         zRad = StrictMath.toRadians(89.999);
 487         qq.setEulerYXZ(xRad, yRad, zRad);
 488         qq.toEulerYXZ(eu, yRad);
 489         assertUlpEquals(xRad, eu.getXRot(), 83029);
 490         assertUlpEquals(yRad, eu.getYRot(), 80108);
 491         assertUlpEquals(zRad, eu.getZRot(), 80108);
 492
 493         return;
 494     }
 495
 496     /**
 497      * Test of toEulerYXZ method, of class MkQuat.
 498      */
 499     @Test
 500     public void testToEulerYXZ_EulerYXZ() {
 501         System.out.println("toEulerYXZ");
 502
 503         EulerYXZ eu;
 504         MkQuat qq;
 505
 506         qq = new MkQuat();
 507
 508         qq.setEulerYXZ(1.0, 2.0, 3.0);
 509         eu = new EulerYXZ();
 510         qq.toEulerYXZ(eu);
 511         assertUlpEquals(1.0, eu.getXRot(), 1);
 512         assertUlpEquals(2.0, eu.getYRot(), 2);
 513         assertUlpEquals(3.0, eu.getZRot(), 0);
 514
 515         qq.setEulerYXZ(StrictMath.PI, 0.0, 0.0);
 516         qq.toEulerYXZ(eu);
 517         assertEquals(0.0, eu.getXRot(), EPSILON);
 518         assert0UlpEquals(StrictMath.PI, eu.getYRot());
 519         assert0UlpEquals(StrictMath.PI, eu.getZRot());
 520
 521         return;
 522     }
 523
 524     /**
 525      * Test of rotatePos method, of class MkQuat.
 526      */
 527     @Test
 528     public void testRotatePos() {
 529         System.out.println("rotatePos");
 530
 531         MkPos3D pos;
 532         MkPos3D result;
 533         MkQuat qq;
 534
 535         qq = new MkQuat();
 536
 537         pos = new MkPos3D(1.0, 1.0, 1.0);
 538         result = new MkPos3D();
 539
 540         // No Rotation
 541         qq.setEulerYXZ(0.0, 0.0, 0.0);
 542         qq.rotatePos(pos, result);
 543         assert0UlpEquals(1.0, result.getXpos());
 544         assert0UlpEquals(1.0, result.getYpos());
 545         assert0UlpEquals(1.0, result.getZpos());
 546
 547         // test Left Hand Rotation
 548         qq.setEulerYXZ(0.0, RAD_90DEG, 0.0);
 549         qq.rotatePos(pos, result);
 550         assertUlpEquals(1.0, result.getXpos(), 0);
 551         assertUlpEquals(1.0, result.getYpos(), 0);
 552         assertUlpEquals(-1.0, result.getZpos(), 2);
 553
 554         qq.setEulerYXZ(RAD_90DEG, 0.0, 0.0);
 555         qq.rotatePos(pos, result);
 556         assertUlpEquals(1.0, result.getXpos(), 0);
 557         assertUlpEquals(-1.0, result.getYpos(), 2);
 558         assertUlpEquals(1.0, result.getZpos(), 0);
 559
 560         qq.setEulerYXZ(0.0, 0.0, RAD_90DEG);
 561         qq.rotatePos(pos, result);
 562         assertUlpEquals(-1.0, result.getXpos(), 2);
 563         assertUlpEquals(1.0, result.getYpos(), 0);
 564         assertUlpEquals(1.0, result.getZpos(), 0);
 565
 566         // test Euler axis order
 567
 568         qq.setEulerYXZ(RAD_90DEG, RAD_90DEG, 0.0);
 569         qq.rotatePos(pos, result);
 570         assertUlpEquals(1.0, result.getXpos(), 2);
 571         assertUlpEquals(-1.0, result.getYpos(), 1);
 572         assertUlpEquals(-1.0, result.getZpos(), 1);
 573
 574         qq.setEulerYXZ(0.0, RAD_90DEG, RAD_90DEG);
 575         qq.rotatePos(pos, result);
 576         assertUlpEquals(1.0, result.getXpos(), 1);
 577         assertUlpEquals(1.0, result.getYpos(), 1);
 578         assertUlpEquals(1.0, result.getZpos(), 0);
 579
 580         qq.setEulerYXZ(RAD_90DEG, 0.0, RAD_90DEG);
 581         qq.rotatePos(pos, result);
 582         assertUlpEquals(-1.0, result.getXpos(), 1);
 583         assertUlpEquals(-1.0, result.getYpos(), 1);
 584         assertUlpEquals(1.0, result.getZpos(), 2);
 585
 586         pos = new MkPos3D(1.0, 2.0, 3.0);
 587
 588         qq.setEulerYXZ(0.0, RAD_90DEG, 0.0);
 589         qq.rotatePos(pos, result);
 590         assertUlpEquals(3.0, result.getXpos(), 0);
 591         assertUlpEquals(2.0, result.getYpos(), 0);
 592         assertUlpEquals(-1.0, result.getZpos(), 3);
 593
 594         qq.setEulerYXZ(RAD_90DEG, 0.0, 0.0);
 595         qq.rotatePos(pos, result);
 596         assertUlpEquals(1.0, result.getXpos(), 0);
 597         assertUlpEquals(-3.0, result.getYpos(), 0);
 598         assertUlpEquals(2.0, result.getZpos(), 2);
 599
 600         qq.setEulerYXZ(0.0, 0.0, RAD_90DEG);
 601         qq.rotatePos(pos, result);
 602         assertUlpEquals(-2.0, result.getXpos(), 0);
 603         assertUlpEquals(1.0, result.getYpos(), 2);
 604         assertUlpEquals(3.0, result.getZpos(), 0);
 605
 606         // rotate origin point
 607
 608         pos = new MkPos3D(0.0, 0.0, 0.0);
 609         qq.setEulerYXZ(RAD_15DEG, RAD_30DEG, RAD_45DEG);
 610         qq.rotatePos(pos, result);
 611         assert0UlpEquals(0.0, result.getXpos());
 612         assert0UlpEquals(0.0, result.getYpos());
 613         assert0UlpEquals(0.0, result.getZpos());
 614
 615         return;
 616     }
 617
 618     /**
 619      * Test of full matching, of class MkQuat.
 620      */
 621 //    @Test
 622     public void testFullMatch(){
 623         System.out.println("full match");
 624
 625         for(int ix = -5; ix <= 90; ix++){
 626             for(int iy = -5; iy <= 179; iy++){
 627                 for(int iz = -5; iz <= 179; iz++){
 628                     try{
 629                         rotTest(ix, iy, iz);
 630                     }catch(AssertionError e){
 631                         System.out.println(""+ix+":"+iy+":"+iz);
 632                         throw e;
 633                     }
 634                 }
 635             }
 636         }
 637
 638         return;
 639     }
 640
 641     /**
 642      * Test of full matching, of class MkQuat.
 643      */
 644 //    @Test
 645     public void testFullMatchRev(){
 646         System.out.println("full match rev");
 647
 648         for(int ix = -90; ix <= 5; ix++){
 649             for(int iy = -179; iy <= 5; iy++){
 650                 for(int iz = -179; iz <= 5; iz++){
 651                     try{
 652                         rotTest(ix, iy, iz);
 653                     }catch(AssertionError e){
 654                         System.out.println(""+ix+":"+iy+":"+iz);
 655                         throw e;
 656                     }
 657                 }
 658             }
 659         }
 660
 661         return;
 662     }
 663
 664     private void rotTest(double ix, double iy, double iz){
 665         EulerYXZ result;
 666         MkQuat qq;
 667
 668         qq = new MkQuat();
 669         result = new EulerYXZ();
 670
 671         double xRad = StrictMath.toRadians(ix);
 672         double yRad = StrictMath.toRadians(iy);
 673         double zRad = StrictMath.toRadians(iz);
 674
 675         qq.setEulerYXZ(xRad, yRad, zRad);
 676         qq.toEulerYXZ(result, yRad);
 677
 678         final double DELTA = EPSILON * 164;
 679
 680         assertEquals(xRad, result.getXRot(), DELTA);
 681         assertEquals(yRad, result.getYRot(), DELTA);
 682         assertEquals(zRad, result.getZRot(), DELTA);
 683
 684         return;
 685     }
 686
 687     /**
 688      * Test of toString method, of class MkQuat.
 689      */
 690     @Test
 691     public void testToString() {
 692         System.out.println("toString");
 693
 694         MkQuat qq;
 695
 696         qq = new MkQuat(-0.0, Double.MIN_NORMAL, Double.MAX_EXPONENT, StrictMath.PI);
 697         assertEquals("q1=-0.0 q2=2.2250738585072014E-308 q3=1023.0 w=3.141592653589793", qq.toString());
 698
 699         return;
 700     }
 701
 702 }