OSDN Git Service

ジンバルロック判定を改善
[mikutoga/TogaGem.git] / 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 }