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