test/math/QuaternionTestCase.cpp

#include "math/QuaternionTestCase.hpp"

// Registers the fixture into the 'registry'
CPPUNIT_TEST_SUITE_REGISTRATION( QuaternionTestCase );


void QuaternionTestCase::setUp(){
    q1[0] = 1.0;
    q1[1] = 0.0;
    q1[2] = 0.0;
    q1[3] = 0.0;

    q2[0] = 0.0;
    q2[1] = 0.6;
    q2[2] = 0.0;
    q2[3] = 0.8;

    q3[0] = 0.5;
    q3[1] = 0.5;
    q3[2] = 0.5;
    q3[3] = 0.5;

    q4[0] = 0.0;
    q4[1] = -0.6;
    q4[2] = 0.0;
    q4[3] = -0.8;
        
}

void QuaternionTestCase::testConstructors(){
    Vec4 v;
    v[0] = 0.0;
    v[1] = 0.6;
    v[2] = 0.0;
    v[3] = 0.8;

    //construct from a vector
    Quat4d tmp1(v);

    CPPUNIT_ASSERT(tmp1 == q2);

    //copy constructor
    Quat4d tmp2(q1);
    CPPUNIT_ASSERT(tmp2 == q1);

    //copy assignment
    Quat4d tmp3;
    tmp3 = q4;
    CPPUNIT_ASSERT(tmp3 == q4);

    //construct from w, x, y, z
    Quat4d tmp4(0.0, -0.6, 0.0, -0.8);

    CPPUNIT_ASSERT(tmp4 == q4);
    
}

void QuaternionTestCase::testArithmetic(){
    Quat4d qd3(1, 1, 2, 1);
    Quat4d qd4(1, 1, 1, 2);
    
    //test mul
    Quat4d qda3L = qd3;
    qda3L.mul(2.0);
    CPPUNIT_ASSERT_EQUAL( Quat4d(2,2,4,2) , qda3L );
    
    Quat4d qda5R = 2.0  * qd4;
    qda5R.div(qd4);
    CPPUNIT_ASSERT_EQUAL( Quat4d(2.0, 0.0, 0.0, 0.0) , qda5R );    

}

void QuaternionTestCase::testOperators(){

    Quat4d qd0(1, 1, 1, 1);
    Quat4d qd1(2, 1, 1, 1);
    Quat4d qd2(1, 2, 1, 1);
    Quat4d qd3(1, 1, 2, 1);
    Quat4d qd4(1, 1, 1, 2);


    Quat4d qda2Q = qd2 - qd0;
    Quat4d qda3L = qd3 * 2.0;
    Quat4d qda3R = 2.0 * qd3;
    Quat4d qda3Q = qd3 * qd0;
    Quat4d qda4L = qd4 / 2.0;
    Quat4d qda4R = 2.0 / qd4;
    Quat4d qda4Q = qd4 / qd0;
    Quat4d qda5L = qda4L * 2.0;
    Quat4d qda5R = qda4R * qd4;
    Quat4d qda5Q = qda4Q * qd0;    
    
    CPPUNIT_ASSERT_EQUAL( Quat4d(0,1,0,0) , qda2Q );
    CPPUNIT_ASSERT_EQUAL( Quat4d(2,2,4,2) , qda3L );
    CPPUNIT_ASSERT_EQUAL( Quat4d(2,2,4,2) , qda3R );
    CPPUNIT_ASSERT_EQUAL( Quat4d(-3,3,3,1) , qda3Q );
    CPPUNIT_ASSERT_EQUAL( Quat4d(0.5,0.5,0.5,1) , qda4L );
    //CPPUNIT_ASSERT_EQUAL( 2.0 * qd4.inverse() , qda4R );
    CPPUNIT_ASSERT_EQUAL( Quat4d(1.25,0.25,-0.25,0.25) , qda4Q );
    CPPUNIT_ASSERT_EQUAL( qd4 , qda5L );
    CPPUNIT_ASSERT_EQUAL( Quat4d(2.0, 0.0, 0.0, 0.0) , qda5R );
    CPPUNIT_ASSERT_EQUAL( qd4 , qda5Q );

    Quat4d quat0(1, 1, 1, 1);

    Quat4d quat1a = quat0;
    Quat4d quat1s = quat0;
    Quat4d quat1p = quat0;
    Quat4d quat1d = quat0;
    
    quat1a += 2.0;
    quat1s -= 2.0;
    quat1p *= 2.0;
    quat1d /= 2.0;
    
    CPPUNIT_ASSERT_EQUAL( Quat4d(3,1,1,1) , quat1a );
    CPPUNIT_ASSERT_EQUAL( Quat4d(-1,1,1,1) , quat1s );
    CPPUNIT_ASSERT_EQUAL( Quat4d(2,2,2,2) , quat1p );
    CPPUNIT_ASSERT_EQUAL( Quat4d(0.5,0.5,0.5,0.5) , quat1d );

}

void QuaternionTestCase::testAccessEntries(){
    CPPUNIT_ASSERT_DOUBLES_EQUAL(q1.w(), 1.0, oopse::epsilon);
    CPPUNIT_ASSERT_DOUBLES_EQUAL(q2.x(), 0.6, oopse::epsilon);
    CPPUNIT_ASSERT_DOUBLES_EQUAL(q3.y(), 0.5, oopse::epsilon);
    CPPUNIT_ASSERT_DOUBLES_EQUAL(q4.z(), -0.8, oopse::epsilon);

    Quat4d tmp;

    tmp.w() = 0.0;
    tmp.x() = -0.6;
    tmp.y() = 0.0;
    tmp.z() = -0.8;
    
    CPPUNIT_ASSERT(tmp == q4);


}

void QuaternionTestCase::testOtherMemberFunctions(){        
    //test inverse
    CPPUNIT_ASSERT(q2.inverse() == q4);

    //test conjugate
    CPPUNIT_ASSERT(q2 == q4.conjugate());

    //test toRotationMatrix3
    SquareMatrix<double, 3> rotMat;

    rotMat(0,0) = -0.28;
    rotMat(0,1) =  0;
    rotMat(0,2) =  0.96;

    rotMat(1,0) =  0.0;
    rotMat(1,1) = -1.0;
    rotMat(1,2) =  0.0;

    rotMat(2,0) = 0.96;
    rotMat(2,1) = 0;
    rotMat(2,2) = 0.28;

    CPPUNIT_ASSERT(rotMat == q4.toRotationMatrix3());

}
Revision:	1603
Committed:	Tue Oct 19 21:28:55 2004 UTC (19 years, 8 months ago) by tim
File size:	3749 byte(s)
Log Message:	more bugs get fixed at math library
#	Content
1	#include "math/QuaternionTestCase.hpp"
2
3	// Registers the fixture into the 'registry'
4	CPPUNIT_TEST_SUITE_REGISTRATION( QuaternionTestCase );
5
6
7	void QuaternionTestCase::setUp(){
8	q1[0] = 1.0;
9	q1[1] = 0.0;
10	q1[2] = 0.0;
11	q1[3] = 0.0;
12
13	q2[0] = 0.0;
14	q2[1] = 0.6;
15	q2[2] = 0.0;
16	q2[3] = 0.8;
17
18	q3[0] = 0.5;
19	q3[1] = 0.5;
20	q3[2] = 0.5;
21	q3[3] = 0.5;
22
23	q4[0] = 0.0;
24	q4[1] = -0.6;
25	q4[2] = 0.0;
26	q4[3] = -0.8;
27
28	}
29
30	void QuaternionTestCase::testConstructors(){
31	Vec4 v;
32	v[0] = 0.0;
33	v[1] = 0.6;
34	v[2] = 0.0;
35	v[3] = 0.8;
36
37	//construct from a vector
38	Quat4d tmp1(v);
39
40	CPPUNIT_ASSERT(tmp1 == q2);
41
42	//copy constructor
43	Quat4d tmp2(q1);
44	CPPUNIT_ASSERT(tmp2 == q1);
45
46	//copy assignment
47	Quat4d tmp3;
48	tmp3 = q4;
49	CPPUNIT_ASSERT(tmp3 == q4);
50
51	//construct from w, x, y, z
52	Quat4d tmp4(0.0, -0.6, 0.0, -0.8);
53
54	CPPUNIT_ASSERT(tmp4 == q4);
55
56	}
57
58	void QuaternionTestCase::testArithmetic(){
59	Quat4d qd3(1, 1, 2, 1);
60	Quat4d qd4(1, 1, 1, 2);
61
62	//test mul
63	Quat4d qda3L = qd3;
64	qda3L.mul(2.0);
65	CPPUNIT_ASSERT_EQUAL( Quat4d(2,2,4,2) , qda3L );
66
67	Quat4d qda5R = 2.0 * qd4;
68	qda5R.div(qd4);
69	CPPUNIT_ASSERT_EQUAL( Quat4d(2.0, 0.0, 0.0, 0.0) , qda5R );
70
71	}
72
73	void QuaternionTestCase::testOperators(){
74
75	Quat4d qd0(1, 1, 1, 1);
76	Quat4d qd1(2, 1, 1, 1);
77	Quat4d qd2(1, 2, 1, 1);
78	Quat4d qd3(1, 1, 2, 1);
79	Quat4d qd4(1, 1, 1, 2);
80
81
82	Quat4d qda2Q = qd2 - qd0;
83	Quat4d qda3L = qd3 * 2.0;
84	Quat4d qda3R = 2.0 * qd3;
85	Quat4d qda3Q = qd3 * qd0;
86	Quat4d qda4L = qd4 / 2.0;
87	Quat4d qda4R = 2.0 / qd4;
88	Quat4d qda4Q = qd4 / qd0;
89	Quat4d qda5L = qda4L * 2.0;
90	Quat4d qda5R = qda4R * qd4;
91	Quat4d qda5Q = qda4Q * qd0;
92
93	CPPUNIT_ASSERT_EQUAL( Quat4d(0,1,0,0) , qda2Q );
94	CPPUNIT_ASSERT_EQUAL( Quat4d(2,2,4,2) , qda3L );
95	CPPUNIT_ASSERT_EQUAL( Quat4d(2,2,4,2) , qda3R );
96	CPPUNIT_ASSERT_EQUAL( Quat4d(-3,3,3,1) , qda3Q );
97	CPPUNIT_ASSERT_EQUAL( Quat4d(0.5,0.5,0.5,1) , qda4L );
98	//CPPUNIT_ASSERT_EQUAL( 2.0 * qd4.inverse() , qda4R );
99	CPPUNIT_ASSERT_EQUAL( Quat4d(1.25,0.25,-0.25,0.25) , qda4Q );
100	CPPUNIT_ASSERT_EQUAL( qd4 , qda5L );
101	CPPUNIT_ASSERT_EQUAL( Quat4d(2.0, 0.0, 0.0, 0.0) , qda5R );
102	CPPUNIT_ASSERT_EQUAL( qd4 , qda5Q );
103
104	Quat4d quat0(1, 1, 1, 1);
105
106	Quat4d quat1a = quat0;
107	Quat4d quat1s = quat0;
108	Quat4d quat1p = quat0;
109	Quat4d quat1d = quat0;
110
111	quat1a += 2.0;
112	quat1s -= 2.0;
113	quat1p *= 2.0;
114	quat1d /= 2.0;
115
116	CPPUNIT_ASSERT_EQUAL( Quat4d(3,1,1,1) , quat1a );
117	CPPUNIT_ASSERT_EQUAL( Quat4d(-1,1,1,1) , quat1s );
118	CPPUNIT_ASSERT_EQUAL( Quat4d(2,2,2,2) , quat1p );
119	CPPUNIT_ASSERT_EQUAL( Quat4d(0.5,0.5,0.5,0.5) , quat1d );
120
121	}
122
123	void QuaternionTestCase::testAccessEntries(){
124	CPPUNIT_ASSERT_DOUBLES_EQUAL(q1.w(), 1.0, oopse::epsilon);
125	CPPUNIT_ASSERT_DOUBLES_EQUAL(q2.x(), 0.6, oopse::epsilon);
126	CPPUNIT_ASSERT_DOUBLES_EQUAL(q3.y(), 0.5, oopse::epsilon);
127	CPPUNIT_ASSERT_DOUBLES_EQUAL(q4.z(), -0.8, oopse::epsilon);
128
129	Quat4d tmp;
130
131	tmp.w() = 0.0;
132	tmp.x() = -0.6;
133	tmp.y() = 0.0;
134	tmp.z() = -0.8;
135
136	CPPUNIT_ASSERT(tmp == q4);
137
138
139	}
140
141	void QuaternionTestCase::testOtherMemberFunctions(){
142	//test inverse
143	CPPUNIT_ASSERT(q2.inverse() == q4);
144
145	//test conjugate
146	CPPUNIT_ASSERT(q2 == q4.conjugate());
147
148	//test toRotationMatrix3
149	SquareMatrix<double, 3> rotMat;
150
151	rotMat(0,0) = -0.28;
152	rotMat(0,1) = 0;
153	rotMat(0,2) = 0.96;
154
155	rotMat(1,0) = 0.0;
156	rotMat(1,1) = -1.0;
157	rotMat(1,2) = 0.0;
158
159	rotMat(2,0) = 0.96;
160	rotMat(2,1) = 0;
161	rotMat(2,2) = 0.28;
162
163	CPPUNIT_ASSERT(rotMat == q4.toRotationMatrix3());
164
165	}