← Back to branch summary

~mogurijin/pyeigen/py3k

« back to all changes in this revision

Viewing changes to test/test_rowvectorXf.py

  • Committer: Jussi Lepistö
  • Date: 2010-04-02 17:29:24 UTC
  • Revision ID: jussi.lepisto@iki.fi-20100402172924-kakeesz6ektcyjoy
- Variable-size matrices and vectors
- Code reorganization
- New properties and methods for various types: rows, cols, get/set_block, unit
- Prevent direct creation of iterator types
- Various other fixes & cleanup

Show diffs side-by-side

added added

removed removed

Lines of Context:
test/test_rowvectorXf.py
 
1
import math
 
2
import unittest
 
3
 
 
4
from pyeigen import MatrixXf, RowVectorXf, VectorXf
 
5
 
 
6
from settings import TEST_PRECISION
 
7
 
 
8
 
 
9
class TestRowVectorXfCreate(unittest.TestCase):
 
10
    def test_constructor_default(self):
 
11
        v = RowVectorXf()
 
12
        self.assertEqual(len(v), 0)
 
13
 
 
14
    def test_constructor_arguments(self):
 
15
        v = RowVectorXf(4)
 
16
        self.assertEqual(len(v), 4)
 
17
 
 
18
    def test_zero(self):
 
19
        v = RowVectorXf.zero(4)
 
20
        self.assertEqual(v.x, 0)
 
21
        self.assertEqual(v.y, 0)
 
22
        self.assertEqual(v.z, 0)
 
23
        self.assertEqual(v.w, 0)
 
24
 
 
25
    def test_ones(self):
 
26
        v = RowVectorXf.ones(4)
 
27
        self.assertEqual(v.x, 1)
 
28
        self.assertEqual(v.y, 1)
 
29
        self.assertEqual(v.z, 1)
 
30
        self.assertEqual(v.w, 1)
 
31
 
 
32
    def test_constant(self):
 
33
        v = RowVectorXf.constant(4, 2)
 
34
        self.assertEqual(v.x, 2)
 
35
        self.assertEqual(v.y, 2)
 
36
        self.assertEqual(v.z, 2)
 
37
        self.assertEqual(v.w, 2)
 
38
 
 
39
    def test_random(self):
 
40
        v = RowVectorXf.random(4)
 
41
        self.assert_(v.x > -1)
 
42
        self.assert_(v.x < 1)
 
43
        self.assert_(v.y > -1)
 
44
        self.assert_(v.y < 1)
 
45
        self.assert_(v.z > -1)
 
46
        self.assert_(v.z < 1)
 
47
        self.assert_(v.w > -1)
 
48
        self.assert_(v.w < 1)
 
49
 
 
50
class TestRowVectorXf(unittest.TestCase):
 
51
    def setUp(self):
 
52
        self.v1 = RowVectorXf(4)
 
53
        self.v1.set(-1, -2, -3, -4)
 
54
        self.v2 = RowVectorXf(4)
 
55
        self.v2.set(-5, -6, -7, -8)
 
56
 
 
57
    def test_set(self):
 
58
        self.v1.set(1, 2, 3, 4)
 
59
        self.assertEqual(self.v1.x, 1)
 
60
        self.assertEqual(self.v1.y, 2)
 
61
        self.assertEqual(self.v1.z, 3)
 
62
        self.assertEqual(self.v1.w, 4)
 
63
    
 
64
    def test_set_zero(self):
 
65
        self.v1.set_zero()
 
66
        self.assertEqual(self.v1.x, 0)
 
67
        self.assertEqual(self.v1.y, 0)
 
68
        self.assertEqual(self.v1.z, 0)
 
69
        self.assertEqual(self.v1.w, 0)
 
70
    
 
71
    def test_set_ones(self):
 
72
        self.v1.set_ones()
 
73
        self.assertEqual(self.v1.x, 1)
 
74
        self.assertEqual(self.v1.y, 1)
 
75
        self.assertEqual(self.v1.z, 1)
 
76
        self.assertEqual(self.v1.w, 1)
 
77
    
 
78
    def test_set_constant(self):
 
79
        self.v1.set_constant(2)
 
80
        self.assertEqual(self.v1.x, 2)
 
81
        self.assertEqual(self.v1.y, 2)
 
82
        self.assertEqual(self.v1.z, 2)
 
83
        self.assertEqual(self.v1.w, 2)
 
84
    
 
85
    def test_set_random(self):
 
86
        self.v1.set_random()
 
87
        self.assert_(self.v1.x > -1)
 
88
        self.assert_(self.v1.x < 1)
 
89
        self.assert_(self.v1.y > -1)
 
90
        self.assert_(self.v1.y < 1)
 
91
        self.assert_(self.v1.z > -1)
 
92
        self.assert_(self.v1.z < 1)
 
93
        self.assert_(self.v1.w > -1)
 
94
        self.assert_(self.v1.w < 1)
 
95
 
 
96
    def test_norm(self):
 
97
        v = RowVectorXf(4)
 
98
        v.set(1, 0, 0, 0)
 
99
        self.assertAlmostEqual(v.norm, 1.0, places=TEST_PRECISION)
 
100
        v = RowVectorXf(4)
 
101
        v.set(0, 1, 0, 0)
 
102
        self.assertAlmostEqual(v.norm, 1.0, places=TEST_PRECISION)
 
103
        v = RowVectorXf(4)
 
104
        v.set(0, 0, 1, 0)
 
105
        self.assertAlmostEqual(v.norm, 1.0, places=TEST_PRECISION)
 
106
        v = RowVectorXf(4)
 
107
        v.set(0, 0, 0, 1)
 
108
        self.assertAlmostEqual(v.norm, 1.0, places=TEST_PRECISION)
 
109
        v = RowVectorXf(4)
 
110
        v.set(1, 1, 1, 1)
 
111
        self.assertAlmostEqual(v.norm, math.sqrt(4), places=TEST_PRECISION)
 
112
 
 
113
    def test_norm_sq(self):
 
114
        v = RowVectorXf(4)
 
115
        v.set(1, 0, 0, 0)
 
116
        self.assertAlmostEqual(v.norm_sq, 1.0, places=TEST_PRECISION)
 
117
        v = RowVectorXf(4)
 
118
        v.set(0, 1, 0, 0)
 
119
        self.assertAlmostEqual(v.norm_sq, 1.0, places=TEST_PRECISION)
 
120
        v = RowVectorXf(4)
 
121
        v.set(0, 0, 1, 0)
 
122
        self.assertAlmostEqual(v.norm_sq, 1.0, places=TEST_PRECISION)
 
123
        v = RowVectorXf(4)
 
124
        v.set(0, 0, 0, 1)
 
125
        self.assertAlmostEqual(v.norm_sq, 1.0, places=TEST_PRECISION)
 
126
        v = RowVectorXf(4)
 
127
        v.set(1, 1, 1, 1)
 
128
        self.assertAlmostEqual(v.norm_sq, 4, places=TEST_PRECISION)
 
129
 
 
130
    def test_normalized(self):
 
131
        self.assertAlmostEqual(self.v1.normalized.norm, 1.0, places=TEST_PRECISION)
 
132
        self.assertAlmostEqual(self.v2.normalized.norm, 1.0, places=TEST_PRECISION)
 
133
 
 
134
    def test_transpose(self):
 
135
        rv1 = self.v1.transpose
 
136
        self.assertEqual(self.v1.x, rv1.x)
 
137
        self.assertEqual(self.v1.y, rv1.y)
 
138
        self.assertEqual(self.v1.z, rv1.z)
 
139
        self.assertEqual(self.v1.w, rv1.w)
 
140
 
 
141
        v = VectorXf(4)
 
142
        v.set(1, 2, 3, 4)
 
143
        self.v1.transpose = v
 
144
        self.assertEqual(self.v1.x, 1)
 
145
        self.assertEqual(self.v1.y, 2)
 
146
        self.assertEqual(self.v1.z, 3)
 
147
        self.assertEqual(self.v1.w, 4)
 
148
 
 
149
    def test_normalize(self):
 
150
        self.v1.normalize()
 
151
        self.v2.normalize()
 
152
        self.assertAlmostEqual(self.v1.norm, 1.0, places=TEST_PRECISION)
 
153
        self.assertAlmostEqual(self.v2.norm, 1.0, places=TEST_PRECISION)
 
154
 
 
155
    def test_is_approx(self):
 
156
        self.v1.set_zero()
 
157
        self.v2.set_zero()
 
158
        self.assert_(self.v1.is_approx(self.v2, 1))
 
159
 
 
160
        self.v1.set(0, 0, 0, 1)
 
161
        self.v2.set(0, 0, 0, 1.5)
 
162
        self.assert_(self.v1.is_approx(self.v2, 1))
 
163
        self.assertFalse(self.v1.is_approx(self.v2, 0.1))
 
164
 
 
165
    def test_add(self):
 
166
        v3 = self.v1 + self.v2
 
167
        self.assertEqual(v3.x, -6)
 
168
        self.assertEqual(v3.y, -8)
 
169
        self.assertEqual(v3.z, -10)
 
170
        self.assertEqual(v3.w, -12)
 
171
 
 
172
    def test_sub(self):
 
173
        v3 = self.v1 - self.v2
 
174
        self.assertEqual(v3.x, 4)
 
175
        self.assertEqual(v3.y, 4)
 
176
        self.assertEqual(v3.z, 4)
 
177
        self.assertEqual(v3.w, 4)
 
178
 
 
179
    def test_mul_scalar(self):
 
180
        v3 = self.v1 * 2
 
181
        self.assertEqual(v3.x, -2)
 
182
        self.assertEqual(v3.y, -4)
 
183
        self.assertEqual(v3.z, -6)
 
184
        self.assertEqual(v3.w, -8)
 
185
 
 
186
    def test_mul_matrix(self):
 
187
        m = MatrixXf(4, 4)
 
188
        m.set(1, 2, 3, 4,
 
189
              5, 6, 7, 8,
 
190
              9, 10, 11, 12,
 
191
              13, 14, 15, 16)
 
192
        v3 = self.v1 * m
 
193
        self.assertAlmostEqual(v3.x, -90, places=TEST_PRECISION)
 
194
        self.assertAlmostEqual(v3.y, -100, places=TEST_PRECISION)
 
195
        self.assertAlmostEqual(v3.z, -110, places=TEST_PRECISION)
 
196
        self.assertAlmostEqual(v3.w, -120, places=TEST_PRECISION)
 
197
 
 
198
    def test_div(self):
 
199
        v3 = self.v1 / 2
 
200
        self.assertEqual(v3.x, -0.5)
 
201
        self.assertEqual(v3.y, -1)
 
202
        self.assertEqual(v3.z, -1.5)
 
203
        self.assertEqual(v3.w, -2)
 
204
 
 
205
    def test_negative(self):
 
206
        v3 = -self.v1
 
207
        self.assertEqual(v3.x, 1)
 
208
        self.assertEqual(v3.y, 2)
 
209
        self.assertEqual(v3.z, 3)
 
210
        self.assertEqual(v3.w, 4)
 
211
        v4 = -v3
 
212
        self.assertEqual(v4.x, -1)
 
213
        self.assertEqual(v4.y, -2)
 
214
        self.assertEqual(v4.z, -3)
 
215
        self.assertEqual(v4.w, -4)
 
216
 
 
217
    def test_inplace_add(self):
 
218
        self.v1 += self.v2
 
219
        self.assertEqual(self.v1.x, -6)
 
220
        self.assertEqual(self.v1.y, -8)
 
221
        self.assertEqual(self.v1.z, -10)
 
222
        self.assertEqual(self.v1.w, -12)
 
223
 
 
224
    def test_inplace_sub(self):
 
225
        self.v1 -= self.v2
 
226
        self.assertEqual(self.v1.x, 4)
 
227
        self.assertEqual(self.v1.y, 4)
 
228
        self.assertEqual(self.v1.z, 4)
 
229
        self.assertEqual(self.v1.w, 4)
 
230
 
 
231
    def test_inplace_mul_scalar(self):
 
232
        self.v1 *= 2
 
233
        self.assertEqual(self.v1.x, -2)
 
234
        self.assertEqual(self.v1.y, -4)
 
235
        self.assertEqual(self.v1.z, -6)
 
236
        self.assertEqual(self.v1.w, -8)
 
237
 
 
238
    def test_inplace_mul_matrix(self):
 
239
        m = MatrixXf(4, 4)
 
240
        m.set(1, 2, 3, 4,
 
241
              5, 6, 7, 8,
 
242
              9, 10, 11, 12,
 
243
              13, 14, 15, 16)
 
244
        self.v1 *= m
 
245
        self.assertAlmostEqual(self.v1.x, -90, places=TEST_PRECISION)
 
246
        self.assertAlmostEqual(self.v1.y, -100, places=TEST_PRECISION)
 
247
        self.assertAlmostEqual(self.v1.z, -110, places=TEST_PRECISION)
 
248
        self.assertAlmostEqual(self.v1.w, -120, places=TEST_PRECISION)
 
249
 
 
250
    def test_inplace_div(self):
 
251
        self.v1 /= 2
 
252
        self.assertEqual(self.v1.x, -0.5)
 
253
        self.assertEqual(self.v1.y, -1)
 
254
        self.assertEqual(self.v1.z, -1.5)
 
255
        self.assertEqual(self.v1.w, -2)
 
256
 
 
257
    def test_len(self):
 
258
        self.assertEqual(len(self.v1), 4)
 
259
 
 
260
    def test_get_item(self):
 
261
        self.assertEqual(self.v1[0], self.v1.x)
 
262
        self.assertEqual(self.v1[1], self.v1.y)
 
263
        self.assertEqual(self.v1[2], self.v1.z)
 
264
        self.assertEqual(self.v1[3], self.v1.w)
 
265
 
 
266
    def test_get_slice(self):
 
267
        x, y, z, w = self.v1[:]
 
268
        self.assertEqual(x, self.v1.x)
 
269
        self.assertEqual(y, self.v1.y)
 
270
        self.assertEqual(z, self.v1.z)
 
271
        self.assertEqual(w, self.v1.w)
 
272
 
 
273
    def test_set_item(self):
 
274
        self.v1.x = 1
 
275
        self.v1.y = 2
 
276
        self.v1.z = 3
 
277
        self.v1.w = 4
 
278
        self.assertEqual(self.v1.x, 1)
 
279
        self.assertEqual(self.v1.y, 2)
 
280
        self.assertEqual(self.v1.z, 3)
 
281
        self.assertEqual(self.v1.w, 4)
 
282
        self.assertRaises(IndexError, self.v1.__setitem__, 4, 999.99)
 
283
        self.assertRaises(IndexError, self.v1.__setitem__, 100, 999.99)
 
284
        self.assertRaises(IndexError, self.v1.__setitem__, -5, 999.99)
 
285
        self.assertRaises(IndexError, self.v1.__setitem__, -100, 999.99)
 
286
        
 
287
    def test_set_slice(self):
 
288
        self.v1[:] = 1, 2, 3, 4
 
289
        self.assertEqual(self.v1.x, 1)
 
290
        self.assertEqual(self.v1.y, 2)
 
291
        self.assertEqual(self.v1.z, 3)
 
292
        self.assertEqual(self.v1.w, 4)
 
293
 
 
294
    def test_eq(self):
 
295
        self.assert_(self.v1 == self.v1)
 
296
        self.assertFalse(self.v1 == self.v2)
 
297
        
 
298
    def test_ne(self):
 
299
        self.assertFalse(self.v1 != self.v1)
 
300
        self.assert_(self.v1 != self.v2)
 
301
        
 
302
    def test_iter(self):
 
303
        for i, value in enumerate(self.v1):
 
304
            self.assertEqual(value, self.v1[i])
 
305
    
 
306
if __name__ == '__main__':
 
307
    unittest.main()