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(89.999);
 495         yRad = toRadians(89.999);
 496         zRad = toRadians(89.999);
 497         qq.setEulerYXZ(xRad, yRad, zRad);
 498         qq.toEulerYXZ(eu, yRad);
 499         assertUlpEquals(xRad, eu.getXRot(), 83029);
 500         assertUlpEquals(yRad, eu.getYRot(), 91782);
 501         assertUlpEquals(zRad, eu.getZRot(), 91782);
 502
 503         return;
 504     }
 505
 506     /**
 507      * Test of toEulerYXZ method, of class MkQuat.
 508      */
 509     @Test
 510     public void testToEulerYXZ_EulerYXZ() {
 511         System.out.println("toEulerYXZ");
 512
 513         EulerYXZ eu;
 514         MkQuat qq;
 515
 516         qq = new MkQuat();
 517
 518         qq.setEulerYXZ(1.0, 2.0, 3.0);
 519         eu = new EulerYXZ();
 520         qq.toEulerYXZ(eu);
 521         assertUlpEquals(1.0, eu.getXRot(), 1);
 522         assertUlpEquals(2.0, eu.getYRot(), 2);
 523         assertUlpEquals(3.0, eu.getZRot(), 0);
 524
 525         qq.setEulerYXZ(StrictMath.PI, 0.0, 0.0);
 526         qq.toEulerYXZ(eu);
 527         assertEquals(0.0, eu.getXRot(), EPSILON);
 528         assert0UlpEquals(StrictMath.PI, eu.getYRot());
 529         assert0UlpEquals(StrictMath.PI, eu.getZRot());
 530
 531         return;
 532     }
 533
 534     /**
 535      * Test of rotatePos method, of class MkQuat.
 536      */
 537     @Test
 538     public void testRotatePos() {
 539         System.out.println("rotatePos");
 540
 541         MkPos3D pos;
 542         MkPos3D result;
 543         MkQuat qq;
 544
 545         qq = new MkQuat();
 546
 547         pos = new MkPos3D(1.0, 1.0, 1.0);
 548         result = new MkPos3D();
 549
 550         // No Rotation
 551         qq.setEulerYXZ(0.0, 0.0, 0.0);
 552         qq.rotatePos(pos, result);
 553         assert0UlpEquals(1.0, result.getXpos());
 554         assert0UlpEquals(1.0, result.getYpos());
 555         assert0UlpEquals(1.0, result.getZpos());
 556
 557         // test Left Hand Rotation
 558         qq.setEulerYXZ(0.0, RAD_90DEG, 0.0);
 559         qq.rotatePos(pos, result);
 560         assertUlpEquals(1.0, result.getXpos(), 0);
 561         assertUlpEquals(1.0, result.getYpos(), 0);
 562         assertUlpEquals(-1.0, result.getZpos(), 2);
 563
 564         qq.setEulerYXZ(RAD_90DEG, 0.0, 0.0);
 565         qq.rotatePos(pos, result);
 566         assertUlpEquals(1.0, result.getXpos(), 0);
 567         assertUlpEquals(-1.0, result.getYpos(), 2);
 568         assertUlpEquals(1.0, result.getZpos(), 0);
 569
 570         qq.setEulerYXZ(0.0, 0.0, RAD_90DEG);
 571         qq.rotatePos(pos, result);
 572         assertUlpEquals(-1.0, result.getXpos(), 2);
 573         assertUlpEquals(1.0, result.getYpos(), 0);
 574         assertUlpEquals(1.0, result.getZpos(), 0);
 575
 576         // test Euler axis order
 577
 578         qq.setEulerYXZ(RAD_90DEG, RAD_90DEG, 0.0);
 579         qq.rotatePos(pos, result);
 580         assertUlpEquals(1.0, result.getXpos(), 2);
 581         assertUlpEquals(-1.0, result.getYpos(), 1);
 582         assertUlpEquals(-1.0, result.getZpos(), 1);
 583
 584         qq.setEulerYXZ(0.0, RAD_90DEG, RAD_90DEG);
 585         qq.rotatePos(pos, result);
 586         assertUlpEquals(1.0, result.getXpos(), 1);
 587         assertUlpEquals(1.0, result.getYpos(), 1);
 588         assertUlpEquals(1.0, result.getZpos(), 0);
 589
 590         qq.setEulerYXZ(RAD_90DEG, 0.0, RAD_90DEG);
 591         qq.rotatePos(pos, result);
 592         assertUlpEquals(-1.0, result.getXpos(), 1);
 593         assertUlpEquals(-1.0, result.getYpos(), 1);
 594         assertUlpEquals(1.0, result.getZpos(), 2);
 595
 596         pos = new MkPos3D(1.0, 2.0, 3.0);
 597
 598         qq.setEulerYXZ(0.0, RAD_90DEG, 0.0);
 599         qq.rotatePos(pos, result);
 600         assertUlpEquals(3.0, result.getXpos(), 0);
 601         assertUlpEquals(2.0, result.getYpos(), 0);
 602         assertUlpEquals(-1.0, result.getZpos(), 3);
 603
 604         qq.setEulerYXZ(RAD_90DEG, 0.0, 0.0);
 605         qq.rotatePos(pos, result);
 606         assertUlpEquals(1.0, result.getXpos(), 0);
 607         assertUlpEquals(-3.0, result.getYpos(), 0);
 608         assertUlpEquals(2.0, result.getZpos(), 2);
 609
 610         qq.setEulerYXZ(0.0, 0.0, RAD_90DEG);
 611         qq.rotatePos(pos, result);
 612         assertUlpEquals(-2.0, result.getXpos(), 0);
 613         assertUlpEquals(1.0, result.getYpos(), 2);
 614         assertUlpEquals(3.0, result.getZpos(), 0);
 615
 616         // rotate origin point
 617
 618         pos = new MkPos3D(0.0, 0.0, 0.0);
 619         qq.setEulerYXZ(RAD_15DEG, RAD_30DEG, RAD_45DEG);
 620         qq.rotatePos(pos, result);
 621         assert0UlpEquals(0.0, result.getXpos());
 622         assert0UlpEquals(0.0, result.getYpos());
 623         assert0UlpEquals(0.0, result.getZpos());
 624
 625         return;
 626     }
 627
 628     /**
 629      * Test of full matching, of class MkQuat.
 630      */
 631 //    @Test
 632     public void testFullMatch(){
 633         System.out.println("full match");
 634
 635         for(int ix = -5; ix <= 90; ix++){
 636             for(int iy = -5; iy <= 179; iy++){
 637                 for(int iz = -5; iz <= 179; iz++){
 638                     try{
 639                         rotTest(ix, iy, iz);
 640                     }catch(AssertionError e){
 641                         System.out.println(""+ix+":"+iy+":"+iz);
 642                         throw e;
 643                     }
 644                 }
 645             }
 646         }
 647
 648         return;
 649     }
 650
 651     /**
 652      * Test of full matching, of class MkQuat.
 653      */
 654 //    @Test
 655     public void testFullMatchRev(){
 656         System.out.println("full match rev");
 657
 658         for(int ix = -90; ix <= 5; ix++){
 659             for(int iy = -179; iy <= 5; iy++){
 660                 for(int iz = -179; iz <= 5; iz++){
 661                     try{
 662                         rotTest(ix, iy, iz);
 663                     }catch(AssertionError e){
 664                         System.out.println(""+ix+":"+iy+":"+iz);
 665                         throw e;
 666                     }
 667                 }
 668             }
 669         }
 670
 671         return;
 672     }
 673
 674     private void rotTest(double ix, double iy, double iz){
 675         EulerYXZ result;
 676         MkQuat qq;
 677
 678         qq = new MkQuat();
 679         result = new EulerYXZ();
 680
 681         double xRad = toRadians(ix);
 682         double yRad = toRadians(iy);
 683         double zRad = toRadians(iz);
 684
 685         qq.setEulerYXZ(xRad, yRad, zRad);
 686         qq.toEulerYXZ(result, yRad);
 687
 688         final double DELTA = EPSILON * 164;
 689
 690         assertEquals(xRad, result.getXRot(), DELTA);
 691         assertEquals(yRad, result.getYRot(), DELTA);
 692         assertEquals(zRad, result.getZRot(), DELTA);
 693
 694         return;
 695     }
 696
 697     /**
 698      * Test of toString method, of class MkQuat.
 699      */
 700     @Test
 701     public void testToString() {
 702         System.out.println("toString");
 703
 704         MkQuat qq;
 705
 706         qq = new MkQuat(-0.0, Double.MIN_NORMAL, Double.MAX_EXPONENT, StrictMath.PI);
 707         assertEquals("q1=-0.0 q2=2.2250738585072014E-308 q3=1023.0 w=3.141592653589793", qq.toString());
 708
 709         return;
 710     }
 711
 712 }