Mercurial > pygame
annotate test/math_test.py @ 3172:d1b367fc08bc tests-returncode
Use a return code of 1 when the tests fail.
| author | Thomas Kluyver <takowl@gmail.com> |
|---|---|
| date | Wed, 09 Jan 2013 10:13:57 +0000 |
| parents | 28685c84e251 |
| children |
| rev | line source |
|---|---|
| 2024 | 1 # -*- coding: utf-8 -*- |
| 2 | |
| 1994 | 3 if __name__ == '__main__': |
| 4 import sys | |
| 5 import os | |
| 6 pkg_dir = os.path.split(os.path.abspath(__file__))[0] | |
| 7 parent_dir, pkg_name = os.path.split(pkg_dir) | |
| 8 is_pygame_pkg = (pkg_name == 'tests' and | |
| 9 os.path.split(parent_dir)[1] == 'pygame') | |
| 10 if not is_pygame_pkg: | |
| 11 sys.path.insert(0, parent_dir) | |
| 12 else: | |
| 13 is_pygame_pkg = __name__.startswith('pygame.tests.') | |
| 14 | |
| 15 if is_pygame_pkg: | |
| 16 from pygame.tests.test_utils import test_not_implemented, unittest | |
| 17 else: | |
| 18 from test.test_utils import test_not_implemented, unittest | |
| 19 | |
| 20 import math | |
| 21 import pygame.math | |
| 22 from pygame.math import Vector2, Vector3 | |
| 23 from time import clock | |
| 24 from random import random | |
| 25 import gc | |
| 26 | |
| 27 class Vector2TypeTest(unittest.TestCase): | |
| 28 def setUp(self): | |
| 29 # gc.collect() | |
| 30 self.zeroVec = Vector2() | |
| 31 self.e1 = Vector2(1, 0) | |
| 32 self.e2 = Vector2(0, 1) | |
| 33 # self.t1 = (random(), random()) | |
| 34 self.t1 = (1.2, 3.4) | |
| 35 self.l1 = list(self.t1) | |
| 36 self.v1 = Vector2(self.t1) | |
| 37 # self.t2 = (random(), random()) | |
| 38 self.t2 = (5.6, 7.8) | |
| 39 self.l2 = list(self.t2) | |
| 40 self.v2 = Vector2(self.t2) | |
| 41 # self.s1 = random() | |
| 42 # self.s2 = random() | |
| 43 self.s1 = 5.6 | |
| 44 self.s2 = 7.8 | |
| 45 def tearDown(self): | |
| 46 pygame.math.disable_swizzling() | |
| 47 | |
| 48 | |
| 49 def testConstructionDefault(self): | |
| 50 v = Vector2() | |
| 51 self.assertEqual(v.x, 0.) | |
| 52 self.assertEqual(v.y, 0.) | |
| 53 | |
| 54 def testConstructionXY(self): | |
| 55 v = Vector2(1.2, 3.4) | |
| 56 self.assertEqual(v.x, 1.2) | |
| 57 self.assertEqual(v.y, 3.4) | |
| 58 | |
| 59 def testConstructionTuple(self): | |
| 60 v = Vector2((1.2, 3.4)) | |
| 61 self.assertEqual(v.x, 1.2) | |
| 62 self.assertEqual(v.y, 3.4) | |
| 63 | |
| 64 def testConstructionList(self): | |
| 65 v = Vector2([1.2, 3.4]) | |
| 66 self.assertEqual(v.x, 1.2) | |
| 67 self.assertEqual(v.y, 3.4) | |
| 68 | |
| 69 def testConstructionVector2(self): | |
| 70 v = Vector2(Vector2(1.2, 3.4)) | |
| 71 self.assertEqual(v.x, 1.2) | |
| 72 self.assertEqual(v.y, 3.4) | |
| 73 | |
| 74 def testAttributAccess(self): | |
| 75 tmp = self.v1.x | |
| 76 self.assertEqual(tmp, self.v1.x) | |
| 77 self.assertEqual(tmp, self.v1[0]) | |
| 78 tmp = self.v1.y | |
| 79 self.assertEqual(tmp, self.v1.y) | |
| 80 self.assertEqual(tmp, self.v1[1]) | |
| 81 self.v1.x = 3.141 | |
| 82 self.assertEqual(self.v1.x, 3.141) | |
| 83 self.v1.y = 3.141 | |
| 84 self.assertEqual(self.v1.y, 3.141) | |
| 2024 | 85 def assign_nonfloat(): |
| 86 v = Vector2() | |
| 87 v.x = "spam" | |
| 88 self.assertRaises(TypeError, assign_nonfloat) | |
| 89 | |
| 1994 | 90 |
| 91 def testSequence(self): | |
| 92 v = Vector2(1.2, 3.4) | |
|
2007
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
93 Vector2()[:] |
| 1994 | 94 self.assertEqual(len(v), 2) |
| 95 self.assertEqual(v[0], 1.2) | |
| 96 self.assertEqual(v[1], 3.4) | |
| 97 self.assertRaises(IndexError, lambda : v[2]) | |
| 98 self.assertEqual(v[-1], 3.4) | |
| 99 self.assertEqual(v[-2], 1.2) | |
| 100 self.assertRaises(IndexError, lambda : v[-3]) | |
| 101 self.assertEqual(v[:], [1.2, 3.4]) | |
| 102 self.assertEqual(v[1:], [3.4]) | |
| 103 self.assertEqual(v[:1], [1.2]) | |
| 104 self.assertEqual(list(v), [1.2, 3.4]) | |
| 105 self.assertEqual(tuple(v), (1.2, 3.4)) | |
| 106 v[0] = 5.6 | |
| 107 v[1] = 7.8 | |
| 108 self.assertEqual(v.x, 5.6) | |
| 109 self.assertEqual(v.y, 7.8) | |
| 110 v[:] = [9.1, 11.12] | |
| 111 self.assertEqual(v.x, 9.1) | |
| 112 self.assertEqual(v.y, 11.12) | |
| 113 def overpopulate(): | |
| 114 v = Vector2() | |
| 115 v[:] = [1, 2, 3] | |
| 116 self.assertRaises(ValueError, overpopulate) | |
| 117 def underpopulate(): | |
| 118 v = Vector2() | |
| 119 v[:] = [1] | |
| 120 self.assertRaises(ValueError, underpopulate) | |
| 2024 | 121 def assign_nonfloat(): |
| 122 v = Vector2() | |
| 123 v[0] = "spam" | |
| 124 self.assertRaises(TypeError, assign_nonfloat) | |
| 1994 | 125 |
|
2007
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
126 def testExtendedSlicing(self): |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
127 # deletion |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
128 def delSlice(vec, start=None, stop=None, step=None): |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
129 if start is not None and stop is not None and step is not None: |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
130 del vec[start:stop:step] |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
131 elif start is not None and stop is None and step is not None: |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
132 del vec[start::step] |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
133 elif start is None and stop is None and step is not None: |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
134 del vec[::step] |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
135 v = Vector2(self.v1) |
| 2024 | 136 self.assertRaises(TypeError, delSlice, v, None, None, 2) |
| 137 self.assertRaises(TypeError, delSlice, v, 1, None, 2) | |
| 138 self.assertRaises(TypeError, delSlice, v, 1, 2, 1) | |
|
2007
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
139 |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
140 # assignment |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
141 v = Vector2(self.v1) |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
142 v[::2] = [-1] |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
143 self.assertEqual(v, [-1, self.v1.y]) |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
144 v = Vector2(self.v1) |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
145 v[::-2] = [10] |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
146 self.assertEqual(v, [self.v1.x, 10]) |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
147 v = Vector2(self.v1) |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
148 v[::-1] = v |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
149 self.assertEqual(v, [self.v1.y, self.v1.x]) |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
150 a = Vector2(self.v1) |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
151 b = Vector2(self.v1) |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
152 c = Vector2(self.v1) |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
153 a[1:2] = [2.2] |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
154 b[slice(1,2)] = [2.2] |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
155 c[1:2:] = (2.2,) |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
156 self.assertEqual(a, b) |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
157 self.assertEqual(a, c) |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
158 self.assertEqual(type(a), type(self.v1)) |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
159 self.assertEqual(type(b), type(self.v1)) |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
160 self.assertEqual(type(c), type(self.v1)) |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
161 |
| 1994 | 162 def testAdd(self): |
| 163 v3 = self.v1 + self.v2 | |
| 164 self.assert_(isinstance(v3, type(self.v1))) | |
| 165 self.assertEqual(v3.x, self.v1.x + self.v2.x) | |
| 166 self.assertEqual(v3.y, self.v1.y + self.v2.y) | |
| 167 v3 = self.v1 + self.t2 | |
| 168 self.assert_(isinstance(v3, type(self.v1))) | |
| 169 self.assertEqual(v3.x, self.v1.x + self.t2[0]) | |
| 170 self.assertEqual(v3.y, self.v1.y + self.t2[1]) | |
| 171 v3 = self.v1 + self.l2 | |
| 172 self.assert_(isinstance(v3, type(self.v1))) | |
| 173 self.assertEqual(v3.x, self.v1.x + self.l2[0]) | |
| 174 self.assertEqual(v3.y, self.v1.y + self.l2[1]) | |
| 175 v3 = self.t1 + self.v2 | |
| 176 self.assert_(isinstance(v3, type(self.v1))) | |
| 177 self.assertEqual(v3.x, self.t1[0] + self.v2.x) | |
| 178 self.assertEqual(v3.y, self.t1[1] + self.v2.y) | |
| 179 v3 = self.l1 + self.v2 | |
| 180 self.assert_(isinstance(v3, type(self.v1))) | |
| 181 self.assertEqual(v3.x, self.l1[0] + self.v2.x) | |
| 182 self.assertEqual(v3.y, self.l1[1] + self.v2.y) | |
| 183 | |
| 184 def testSub(self): | |
| 185 v3 = self.v1 - self.v2 | |
| 186 self.assert_(isinstance(v3, type(self.v1))) | |
| 187 self.assertEqual(v3.x, self.v1.x - self.v2.x) | |
| 188 self.assertEqual(v3.y, self.v1.y - self.v2.y) | |
| 189 v3 = self.v1 - self.t2 | |
| 190 self.assert_(isinstance(v3, type(self.v1))) | |
| 191 self.assertEqual(v3.x, self.v1.x - self.t2[0]) | |
| 192 self.assertEqual(v3.y, self.v1.y - self.t2[1]) | |
| 193 v3 = self.v1 - self.l2 | |
| 194 self.assert_(isinstance(v3, type(self.v1))) | |
| 195 self.assertEqual(v3.x, self.v1.x - self.l2[0]) | |
| 196 self.assertEqual(v3.y, self.v1.y - self.l2[1]) | |
| 197 v3 = self.t1 - self.v2 | |
| 198 self.assert_(isinstance(v3, type(self.v1))) | |
| 199 self.assertEqual(v3.x, self.t1[0] - self.v2.x) | |
| 200 self.assertEqual(v3.y, self.t1[1] - self.v2.y) | |
| 201 v3 = self.l1 - self.v2 | |
| 202 self.assert_(isinstance(v3, type(self.v1))) | |
| 203 self.assertEqual(v3.x, self.l1[0] - self.v2.x) | |
| 204 self.assertEqual(v3.y, self.l1[1] - self.v2.y) | |
| 205 | |
| 206 def testScalarMultiplication(self): | |
| 207 v = self.s1 * self.v1 | |
| 208 self.assert_(isinstance(v, type(self.v1))) | |
| 209 self.assertEqual(v.x, self.s1 * self.v1.x) | |
| 210 self.assertEqual(v.y, self.s1 * self.v1.y) | |
| 211 v = self.v1 * self.s2 | |
| 212 self.assertEqual(v.x, self.v1.x * self.s2) | |
| 213 self.assertEqual(v.y, self.v1.y * self.s2) | |
| 214 | |
| 215 def testScalarDivision(self): | |
| 216 v = self.v1 / self.s1 | |
| 217 self.assert_(isinstance(v, type(self.v1))) | |
| 218 self.assertAlmostEqual(v.x, self.v1.x / self.s1) | |
| 219 self.assertAlmostEqual(v.y, self.v1.y / self.s1) | |
| 220 v = self.v1 // self.s2 | |
| 221 self.assert_(isinstance(v, type(self.v1))) | |
| 222 self.assertEqual(v.x, self.v1.x // self.s2) | |
| 223 self.assertEqual(v.y, self.v1.y // self.s2) | |
| 224 | |
| 225 def testBool(self): | |
| 226 self.assertEqual(bool(self.zeroVec), False) | |
| 227 self.assertEqual(bool(self.v1), True) | |
| 228 self.assert_(not self.zeroVec) | |
| 229 self.assert_(self.v1) | |
| 230 | |
| 231 def testUnary(self): | |
| 232 v = +self.v1 | |
| 233 self.assert_(isinstance(v, type(self.v1))) | |
| 234 self.assertEqual(v.x, self.v1.x) | |
| 235 self.assertEqual(v.y, self.v1.y) | |
| 236 self.assertNotEqual(id(v), id(self.v1)) | |
| 237 v = -self.v1 | |
| 238 self.assert_(isinstance(v, type(self.v1))) | |
| 239 self.assertEqual(v.x, -self.v1.x) | |
| 240 self.assertEqual(v.y, -self.v1.y) | |
| 241 self.assertNotEqual(id(v), id(self.v1)) | |
| 242 | |
| 243 def testCompare(self): | |
| 244 int_vec = Vector2(3, -2) | |
| 245 flt_vec = Vector2(3.0, -2.0) | |
| 246 zero_vec = Vector2(0, 0) | |
| 247 self.assertEqual(int_vec == flt_vec, True) | |
| 248 self.assertEqual(int_vec != flt_vec, False) | |
| 249 self.assertEqual(int_vec != zero_vec, True) | |
| 250 self.assertEqual(flt_vec == zero_vec, False) | |
| 251 self.assertEqual(int_vec == (3, -2), True) | |
| 252 self.assertEqual(int_vec != (3, -2), False) | |
| 253 self.assertEqual(int_vec != [0, 0], True) | |
| 254 self.assertEqual(int_vec == [0, 0], False) | |
| 255 self.assertEqual(int_vec != 5, True) | |
| 256 self.assertEqual(int_vec == 5, False) | |
| 257 self.assertEqual(int_vec != [3, -2, 0], True) | |
| 258 self.assertEqual(int_vec == [3, -2, 0], False) | |
| 259 | |
| 260 def testStr(self): | |
| 261 v = Vector2(1.2, 3.4) | |
| 262 self.assertEqual(str(v), "[1.2, 3.4]") | |
| 263 | |
| 264 def testRepr(self): | |
| 265 v = Vector2(1.2, 3.4) | |
| 266 self.assertEqual(v.__repr__(), "<Vector2(1.2, 3.4)>") | |
| 267 self.assertEqual(v, Vector2(v.__repr__())) | |
| 268 | |
| 269 def testIter(self): | |
| 270 it = self.v1.__iter__() | |
|
2007
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
271 # support py2.x and 3.x |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
272 if hasattr(it, "next"): |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
273 next_ = it.next |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
274 elif hasattr(it, "__next__"): |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
275 next_ = it.__next__ |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
276 else: |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
277 self.fail("Iterator has neither a 'next' nor a '__next__' method.") |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
278 self.assertEqual(next_(), self.v1[0]) |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
279 self.assertEqual(next_(), self.v1[1]) |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
280 self.assertRaises(StopIteration, lambda : next_()) |
| 1994 | 281 it1 = self.v1.__iter__() |
| 282 it2 = self.v1.__iter__() | |
| 283 self.assertNotEqual(id(it1), id(it2)) | |
| 284 self.assertEqual(id(it1), id(it1.__iter__())) | |
| 285 self.assertEqual(list(it1), list(it2)); | |
| 286 self.assertEqual(list(self.v1.__iter__()), self.l1) | |
| 287 idx = 0 | |
| 288 for val in self.v1: | |
| 289 self.assertEqual(val, self.v1[idx]) | |
| 290 idx += 1 | |
| 291 | |
| 292 def test_rotate(self): | |
| 293 v1 = Vector2(1, 0) | |
| 294 v2 = v1.rotate(90) | |
| 295 v3 = v1.rotate(90 + 360) | |
| 296 self.assertEqual(v1.x, 1) | |
| 297 self.assertEqual(v1.y, 0) | |
| 298 self.assertEqual(v2.x, 0) | |
| 299 self.assertEqual(v2.y, 1) | |
| 300 self.assertEqual(v3.x, v2.x) | |
| 301 self.assertEqual(v3.y, v2.y) | |
| 302 v1 = Vector2(-1, -1) | |
| 303 v2 = v1.rotate(-90) | |
| 304 self.assertEqual(v2.x, -1) | |
| 305 self.assertEqual(v2.y, 1) | |
| 306 v2 = v1.rotate(360) | |
| 307 self.assertEqual(v1.x, v2.x) | |
| 308 self.assertEqual(v1.y, v2.y) | |
| 309 v2 = v1.rotate(0) | |
| 310 self.assertEqual(v1.x, v2.x) | |
| 311 self.assertEqual(v1.y, v2.y) | |
| 312 | |
| 313 def test_rotate_ip(self): | |
| 314 v = Vector2(1, 0) | |
| 315 self.assertEqual(v.rotate_ip(90), None) | |
| 316 self.assertEqual(v.x, 0) | |
| 317 self.assertEqual(v.y, 1) | |
| 318 v = Vector2(-1, -1) | |
| 319 v.rotate_ip(-90) | |
| 320 self.assertEqual(v.x, -1) | |
| 321 self.assertEqual(v.y, 1) | |
| 322 | |
| 323 def test_normalize(self): | |
| 324 v = self.v1.normalize() | |
| 325 # length is 1 | |
| 326 self.assertAlmostEqual(v.x * v.x + v.y * v.y, 1.) | |
| 327 # v1 is unchanged | |
| 328 self.assertEqual(self.v1.x, self.l1[0]) | |
| 329 self.assertEqual(self.v1.y, self.l1[1]) | |
| 330 # v2 is paralell to v1 | |
| 331 self.assertAlmostEqual(self.v1.x * v.y - self.v1.y * v.x, 0.) | |
|
2035
28685c84e251
as/from_polar/spherical now also use degrees instead of radians
lorenz
parents:
2024
diff
changeset
|
332 self.assertRaises(ValueError, lambda : self.zeroVec.normalize()) |
| 1994 | 333 |
| 334 def test_normalize_ip(self): | |
| 335 v = +self.v1 | |
| 336 # v has length != 1 before normalizing | |
| 337 self.assertNotEqual(v.x * v.x + v.y * v.y, 1.) | |
| 338 # inplace operations should return None | |
| 339 self.assertEqual(v.normalize_ip(), None) | |
| 340 # length is 1 | |
| 341 self.assertAlmostEqual(v.x * v.x + v.y * v.y, 1.) | |
| 342 # v2 is paralell to v1 | |
| 343 self.assertAlmostEqual(self.v1.x * v.y - self.v1.y * v.x, 0.) | |
|
2035
28685c84e251
as/from_polar/spherical now also use degrees instead of radians
lorenz
parents:
2024
diff
changeset
|
344 self.assertRaises(ValueError, lambda : self.zeroVec.normalize_ip()) |
| 1994 | 345 |
| 346 def test_is_normalized(self): | |
| 347 self.assertEqual(self.v1.is_normalized(), False) | |
| 348 v = self.v1.normalize() | |
| 349 self.assertEqual(v.is_normalized(), True) | |
| 350 self.assertEqual(self.e2.is_normalized(), True) | |
| 351 self.assertEqual(self.zeroVec.is_normalized(), False) | |
| 352 | |
| 353 def test_cross(self): | |
| 354 self.assertEqual(self.v1.cross(self.v2), | |
| 355 self.v1.x * self.v2.y - self.v1.y * self.v2.x) | |
| 356 self.assertEqual(self.v1.cross(self.l2), | |
| 357 self.v1.x * self.l2[1] - self.v1.y * self.l2[0]) | |
| 358 self.assertEqual(self.v1.cross(self.t2), | |
| 359 self.v1.x * self.t2[1] - self.v1.y * self.t2[0]) | |
| 360 self.assertEqual(self.v1.cross(self.v2), -self.v2.cross(self.v1)) | |
| 361 self.assertEqual(self.v1.cross(self.v1), 0) | |
| 362 | |
| 363 def test_dot(self): | |
| 364 self.assertEqual(self.v1.dot(self.v2), | |
| 365 self.v1.x * self.v2.x + self.v1.y * self.v2.y) | |
| 366 self.assertEqual(self.v1.dot(self.l2), | |
| 367 self.v1.x * self.l2[0] + self.v1.y * self.l2[1]) | |
| 368 self.assertEqual(self.v1.dot(self.t2), | |
| 369 self.v1.x * self.t2[0] + self.v1.y * self.t2[1]) | |
| 370 self.assertEqual(self.v1.dot(self.v2), self.v2.dot(self.v1)) | |
| 371 self.assertEqual(self.v1.dot(self.v2), self.v1 * self.v2) | |
| 372 | |
| 373 def test_angle_to(self): | |
| 374 self.assertEqual(self.v1.rotate(self.v1.angle_to(self.v2)).normalize(), | |
| 375 self.v2.normalize()) | |
| 376 self.assertEqual(Vector2(1, 1).angle_to((-1, 1)), 90) | |
| 377 self.assertEqual(Vector2(1, 0).angle_to((0, -1)), -90) | |
| 378 self.assertEqual(Vector2(1, 0).angle_to((-1, 1)), 135) | |
| 379 self.assertEqual(abs(Vector2(1, 0).angle_to((-1, 0))), 180) | |
| 380 | |
| 381 def test_scale_to_length(self): | |
| 382 v = Vector2(1, 1) | |
| 383 v.scale_to_length(2.5) | |
| 384 self.assertEqual(v, Vector2(2.5, 2.5) / math.sqrt(2)) | |
|
2035
28685c84e251
as/from_polar/spherical now also use degrees instead of radians
lorenz
parents:
2024
diff
changeset
|
385 self.assertRaises(ValueError, lambda : self.zeroVec.scale_to_length(1)) |
| 1994 | 386 self.assertEqual(v.scale_to_length(0), None) |
| 387 self.assertEqual(v, self.zeroVec) | |
| 388 | |
| 389 def test_length(self): | |
| 390 self.assertEqual(Vector2(3, 4).length(), 5) | |
| 391 self.assertEqual(Vector2(-3, 4).length(), 5) | |
| 392 self.assertEqual(self.zeroVec.length(), 0) | |
| 393 | |
| 394 def test_length_squared(self): | |
| 395 self.assertEqual(Vector2(3, 4).length_squared(), 25) | |
| 396 self.assertEqual(Vector2(-3, 4).length_squared(), 25) | |
| 397 self.assertEqual(self.zeroVec.length_squared(), 0) | |
| 398 | |
| 399 def test_reflect(self): | |
| 400 v = Vector2(1, -1) | |
| 401 n = Vector2(0, 1) | |
| 402 self.assertEqual(v.reflect(n), Vector2(1, 1)) | |
| 403 self.assertEqual(v.reflect(3*n), v.reflect(n)) | |
| 404 self.assertEqual(v.reflect(-v), -v) | |
|
2035
28685c84e251
as/from_polar/spherical now also use degrees instead of radians
lorenz
parents:
2024
diff
changeset
|
405 self.assertRaises(ValueError, lambda : v.reflect(self.zeroVec)) |
| 1994 | 406 |
| 407 def test_reflect_ip(self): | |
| 408 v1 = Vector2(1, -1) | |
| 409 v2 = Vector2(v1) | |
| 410 n = Vector2(0, 1) | |
| 411 self.assertEqual(v2.reflect_ip(n), None) | |
| 412 self.assertEqual(v2, Vector2(1, 1)) | |
| 413 v2 = Vector2(v1) | |
| 414 v2.reflect_ip(3*n) | |
| 415 self.assertEqual(v2, v1.reflect(n)) | |
| 416 v2 = Vector2(v1) | |
| 417 v2.reflect_ip(-v1) | |
| 418 self.assertEqual(v2, -v1) | |
|
2035
28685c84e251
as/from_polar/spherical now also use degrees instead of radians
lorenz
parents:
2024
diff
changeset
|
419 self.assertRaises(ValueError, lambda : v2.reflect_ip(Vector2())) |
| 1994 | 420 |
| 421 def test_distance_to(self): | |
| 422 diff = self.v1 - self.v2 | |
| 423 self.assertEqual(self.e1.distance_to(self.e2), math.sqrt(2)) | |
| 424 self.assertEqual(self.v1.distance_to(self.v2), | |
| 425 math.sqrt(diff.x * diff.x + diff.y * diff.y)) | |
| 426 self.assertEqual(self.v1.distance_to(self.v1), 0) | |
| 427 self.assertEqual(self.v1.distance_to(self.v2), | |
| 428 self.v2.distance_to(self.v1)) | |
| 429 | |
| 430 def test_distance_squared_to(self): | |
| 431 diff = self.v1 - self.v2 | |
| 432 self.assertEqual(self.e1.distance_squared_to(self.e2), 2) | |
| 433 self.assertEqual(self.v1.distance_squared_to(self.v2), | |
| 434 diff.x * diff.x + diff.y * diff.y) | |
| 435 self.assertEqual(self.v1.distance_squared_to(self.v1), 0) | |
| 436 self.assertEqual(self.v1.distance_squared_to(self.v2), | |
| 437 self.v2.distance_squared_to(self.v1)) | |
| 438 | |
| 439 def testSwizzle(self): | |
| 440 self.assertEquals(hasattr(pygame.math, "enable_swizzling"), True) | |
| 441 self.assertEquals(hasattr(pygame.math, "disable_swizzling"), True) | |
| 442 # swizzling disabled by default | |
| 443 self.assertRaises(AttributeError, lambda : self.v1.yx) | |
| 444 pygame.math.enable_swizzling() | |
| 445 | |
| 446 self.assertEqual(self.v1.yx, (self.v1.y, self.v1.x)) | |
| 447 self.assertEqual(self.v1.xxyyxy, (self.v1.x, self.v1.x, self.v1.y, | |
| 448 self.v1.y, self.v1.x, self.v1.y)) | |
| 449 self.v1.xy = self.t2 | |
| 450 self.assertEqual(self.v1, self.t2) | |
| 451 self.v1.yx = self.t2 | |
| 452 self.assertEqual(self.v1, (self.t2[1], self.t2[0])) | |
| 453 self.assertEqual(type(self.v1), Vector2) | |
| 454 def invalidSwizzleX(): | |
| 455 Vector2().xx = (1, 2) | |
| 456 def invalidSwizzleY(): | |
| 457 Vector2().yy = (1, 2) | |
| 458 self.assertRaises(AttributeError, invalidSwizzleX) | |
| 459 self.assertRaises(AttributeError, invalidSwizzleY) | |
| 460 def invalidAssignment(): | |
| 461 Vector2().xy = 3 | |
| 462 self.assertRaises(TypeError, invalidAssignment) | |
| 2024 | 463 def unicodeAttribute(): |
| 464 getattr(Vector2(), "ä") | |
| 465 self.assertRaises(AttributeError, unicodeAttribute) | |
| 1994 | 466 |
| 467 def test_elementwise(self): | |
| 468 # behaviour for "elementwise op scalar" | |
| 469 self.assertEqual(self.v1.elementwise() + self.s1, | |
| 470 (self.v1.x + self.s1, self.v1.y + self.s1)) | |
| 471 self.assertEqual(self.v1.elementwise() - self.s1, | |
| 472 (self.v1.x - self.s1, self.v1.y - self.s1)) | |
| 473 self.assertEqual(self.v1.elementwise() * self.s2, | |
| 474 (self.v1.x * self.s2, self.v1.y * self.s2)) | |
| 475 self.assertEqual(self.v1.elementwise() / self.s2, | |
| 476 (self.v1.x / self.s2, self.v1.y / self.s2)) | |
| 477 self.assertEqual(self.v1.elementwise() // self.s1, | |
| 478 (self.v1.x // self.s1, self.v1.y // self.s1)) | |
| 479 self.assertEqual(self.v1.elementwise() ** self.s1, | |
| 480 (self.v1.x ** self.s1, self.v1.y ** self.s1)) | |
| 481 self.assertEqual(self.v1.elementwise() % self.s1, | |
| 482 (self.v1.x % self.s1, self.v1.y % self.s1)) | |
| 483 self.assertEqual(self.v1.elementwise() > self.s1, | |
| 484 self.v1.x > self.s1 and self.v1.y > self.s1) | |
| 485 self.assertEqual(self.v1.elementwise() < self.s1, | |
| 486 self.v1.x < self.s1 and self.v1.y < self.s1) | |
| 487 self.assertEqual(self.v1.elementwise() == self.s1, | |
| 488 self.v1.x == self.s1 and self.v1.y == self.s1) | |
| 489 self.assertEqual(self.v1.elementwise() != self.s1, | |
| 490 self.v1.x != self.s1 and self.v1.y != self.s1) | |
| 491 self.assertEqual(self.v1.elementwise() >= self.s1, | |
| 492 self.v1.x >= self.s1 and self.v1.y >= self.s1) | |
| 493 self.assertEqual(self.v1.elementwise() <= self.s1, | |
| 494 self.v1.x <= self.s1 and self.v1.y <= self.s1) | |
| 495 self.assertEqual(self.v1.elementwise() != self.s1, | |
| 496 self.v1.x != self.s1 and self.v1.y != self.s1) | |
| 497 # behaviour for "scalar op elementwise" | |
| 498 self.assertEqual(5 + self.v1.elementwise(), Vector2(5, 5) + self.v1) | |
| 499 self.assertEqual(3.5 - self.v1.elementwise(), Vector2(3.5, 3.5) - self.v1) | |
| 500 self.assertEqual(7.5 * self.v1.elementwise() , 7.5 * self.v1) | |
| 501 self.assertEqual(-3.5 / self.v1.elementwise(), (-3.5 / self.v1.x, -3.5 / self.v1.y)) | |
| 502 self.assertEqual(-3.5 // self.v1.elementwise(), (-3.5 // self.v1.x, -3.5 // self.v1.y)) | |
| 503 self.assertEqual(-3.5 ** self.v1.elementwise(), (-3.5 ** self.v1.x, -3.5 ** self.v1.y)) | |
| 504 self.assertEqual(3 % self.v1.elementwise(), (3 % self.v1.x, 3 % self.v1.y)) | |
| 505 self.assertEqual(2 < self.v1.elementwise(), 2 < self.v1.x and 2 < self.v1.y) | |
| 506 self.assertEqual(2 > self.v1.elementwise(), 2 > self.v1.x and 2 > self.v1.y) | |
| 507 self.assertEqual(1 == self.v1.elementwise(), 1 == self.v1.x and 1 == self.v1.y) | |
| 508 self.assertEqual(1 != self.v1.elementwise(), 1 != self.v1.x and 1 != self.v1.y) | |
| 509 self.assertEqual(2 <= self.v1.elementwise(), 2 <= self.v1.x and 2 <= self.v1.y) | |
| 510 self.assertEqual(-7 >= self.v1.elementwise(), -7 >= self.v1.x and -7 >= self.v1.y) | |
| 511 self.assertEqual(-7 != self.v1.elementwise(), -7 != self.v1.x and -7 != self.v1.y) | |
| 512 | |
| 513 # behaviour for "elementwise op vector" | |
| 514 self.assertEqual(type(self.v1.elementwise() * self.v2), type(self.v1)) | |
| 515 self.assertEqual(self.v1.elementwise() + self.v2, self.v1 + self.v2) | |
| 516 self.assertEqual(self.v1.elementwise() + self.v2, self.v1 + self.v2) | |
| 517 self.assertEqual(self.v1.elementwise() - self.v2, self.v1 - self.v2) | |
| 518 self.assertEqual(self.v1.elementwise() * self.v2, (self.v1.x * self.v2.x, self.v1.y * self.v2.y)) | |
| 519 self.assertEqual(self.v1.elementwise() / self.v2, (self.v1.x / self.v2.x, self.v1.y / self.v2.y)) | |
| 520 self.assertEqual(self.v1.elementwise() // self.v2, (self.v1.x // self.v2.x, self.v1.y // self.v2.y)) | |
| 521 self.assertEqual(self.v1.elementwise() ** self.v2, (self.v1.x ** self.v2.x, self.v1.y ** self.v2.y)) | |
| 522 self.assertEqual(self.v1.elementwise() % self.v2, (self.v1.x % self.v2.x, self.v1.y % self.v2.y)) | |
| 523 self.assertEqual(self.v1.elementwise() > self.v2, self.v1.x > self.v2.x and self.v1.y > self.v2.y) | |
| 524 self.assertEqual(self.v1.elementwise() < self.v2, self.v1.x < self.v2.x and self.v1.y < self.v2.y) | |
| 525 self.assertEqual(self.v1.elementwise() >= self.v2, self.v1.x >= self.v2.x and self.v1.y >= self.v2.y) | |
| 526 self.assertEqual(self.v1.elementwise() <= self.v2, self.v1.x <= self.v2.x and self.v1.y <= self.v2.y) | |
| 527 self.assertEqual(self.v1.elementwise() == self.v2, self.v1.x == self.v2.x and self.v1.y == self.v2.y) | |
| 528 self.assertEqual(self.v1.elementwise() != self.v2, self.v1.x != self.v2.x and self.v1.y != self.v2.y) | |
| 529 # behaviour for "vector op elementwise" | |
| 530 self.assertEqual(self.v2 + self.v1.elementwise(), self.v2 + self.v1) | |
| 531 self.assertEqual(self.v2 - self.v1.elementwise(), self.v2 - self.v1) | |
| 532 self.assertEqual(self.v2 * self.v1.elementwise(), (self.v2.x * self.v1.x, self.v2.y * self.v1.y)) | |
| 533 self.assertEqual(self.v2 / self.v1.elementwise(), (self.v2.x / self.v1.x, self.v2.y / self.v1.y)) | |
| 534 self.assertEqual(self.v2 // self.v1.elementwise(), (self.v2.x // self.v1.x, self.v2.y // self.v1.y)) | |
| 535 self.assertEqual(self.v2 ** self.v1.elementwise(), (self.v2.x ** self.v1.x, self.v2.y ** self.v1.y)) | |
| 536 self.assertEqual(self.v2 % self.v1.elementwise(), (self.v2.x % self.v1.x, self.v2.y % self.v1.y)) | |
| 537 self.assertEqual(self.v2 < self.v1.elementwise(), self.v2.x < self.v1.x and self.v2.y < self.v1.y) | |
| 538 self.assertEqual(self.v2 > self.v1.elementwise(), self.v2.x > self.v1.x and self.v2.y > self.v1.y) | |
| 539 self.assertEqual(self.v2 <= self.v1.elementwise(), self.v2.x <= self.v1.x and self.v2.y <= self.v1.y) | |
| 540 self.assertEqual(self.v2 >= self.v1.elementwise(), self.v2.x >= self.v1.x and self.v2.y >= self.v1.y) | |
| 541 self.assertEqual(self.v2 == self.v1.elementwise(), self.v2.x == self.v1.x and self.v2.y == self.v1.y) | |
| 542 self.assertEqual(self.v2 != self.v1.elementwise(), self.v2.x != self.v1.x and self.v2.y != self.v1.y) | |
| 543 | |
| 544 # behaviour for "elementwise op elementwise" | |
| 545 self.assertEqual(self.v2.elementwise() + self.v1.elementwise(), self.v2 + self.v1) | |
| 546 self.assertEqual(self.v2.elementwise() - self.v1.elementwise(), self.v2 - self.v1) | |
| 547 self.assertEqual(self.v2.elementwise() * self.v1.elementwise(), (self.v2.x * self.v1.x, self.v2.y * self.v1.y)) | |
| 548 self.assertEqual(self.v2.elementwise() / self.v1.elementwise(), (self.v2.x / self.v1.x, self.v2.y / self.v1.y)) | |
| 549 self.assertEqual(self.v2.elementwise() // self.v1.elementwise(), (self.v2.x // self.v1.x, self.v2.y // self.v1.y)) | |
| 550 self.assertEqual(self.v2.elementwise() ** self.v1.elementwise(), (self.v2.x ** self.v1.x, self.v2.y ** self.v1.y)) | |
| 551 self.assertEqual(self.v2.elementwise() % self.v1.elementwise(), (self.v2.x % self.v1.x, self.v2.y % self.v1.y)) | |
| 552 self.assertEqual(self.v2.elementwise() < self.v1.elementwise(), self.v2.x < self.v1.x and self.v2.y < self.v1.y) | |
| 553 self.assertEqual(self.v2.elementwise() > self.v1.elementwise(), self.v2.x > self.v1.x and self.v2.y > self.v1.y) | |
| 554 self.assertEqual(self.v2.elementwise() <= self.v1.elementwise(), self.v2.x <= self.v1.x and self.v2.y <= self.v1.y) | |
| 555 self.assertEqual(self.v2.elementwise() >= self.v1.elementwise(), self.v2.x >= self.v1.x and self.v2.y >= self.v1.y) | |
| 556 self.assertEqual(self.v2.elementwise() == self.v1.elementwise(), self.v2.x == self.v1.x and self.v2.y == self.v1.y) | |
| 557 self.assertEqual(self.v2.elementwise() != self.v1.elementwise(), self.v2.x != self.v1.x and self.v2.y != self.v1.y) | |
| 558 | |
| 559 # other behaviour | |
| 560 self.assertEqual(abs(self.v1.elementwise()), (abs(self.v1.x), abs(self.v1.y))) | |
| 561 self.assertEqual(-self.v1.elementwise(), -self.v1) | |
| 562 self.assertEqual(+self.v1.elementwise(), +self.v1) | |
| 563 self.assertEqual(bool(self.v1.elementwise()), bool(self.v1)) | |
| 564 self.assertEqual(bool(Vector2().elementwise()), bool(Vector2())) | |
| 565 self.assertEqual(self.zeroVec.elementwise() ** 0, (1, 1)) | |
| 566 self.assertRaises(ValueError, lambda : pow(Vector2(-1, 0).elementwise(), 1.2)) | |
| 567 self.assertRaises(ZeroDivisionError, lambda : self.zeroVec.elementwise() ** -1) | |
| 568 | |
| 569 def test_elementwise(self): | |
| 570 v1 = self.v1 | |
| 571 v2 = self.v2 | |
| 572 s1 = self.s1 | |
| 573 s2 = self.s2 | |
| 574 # behaviour for "elementwise op scalar" | |
| 575 self.assertEqual(v1.elementwise() + s1, (v1.x + s1, v1.y + s1)) | |
| 576 self.assertEqual(v1.elementwise() - s1, (v1.x - s1, v1.y - s1)) | |
| 577 self.assertEqual(v1.elementwise() * s2, (v1.x * s2, v1.y * s2)) | |
| 578 self.assertEqual(v1.elementwise() / s2, (v1.x / s2, v1.y / s2)) | |
| 579 self.assertEqual(v1.elementwise() // s1, (v1.x // s1, v1.y // s1)) | |
| 580 self.assertEqual(v1.elementwise() ** s1, (v1.x ** s1, v1.y ** s1)) | |
| 581 self.assertEqual(v1.elementwise() % s1, (v1.x % s1, v1.y % s1)) | |
| 582 self.assertEqual(v1.elementwise() > s1, v1.x > s1 and v1.y > s1) | |
| 583 self.assertEqual(v1.elementwise() < s1, v1.x < s1 and v1.y < s1) | |
| 584 self.assertEqual(v1.elementwise() == s1, v1.x == s1 and v1.y == s1) | |
| 585 self.assertEqual(v1.elementwise() != s1, v1.x != s1 and v1.y != s1) | |
| 586 self.assertEqual(v1.elementwise() >= s1, v1.x >= s1 and v1.y >= s1) | |
| 587 self.assertEqual(v1.elementwise() <= s1, v1.x <= s1 and v1.y <= s1) | |
| 588 self.assertEqual(v1.elementwise() != s1, v1.x != s1 and v1.y != s1) | |
| 589 # behaviour for "scalar op elementwise" | |
| 590 self.assertEqual(s1 + v1.elementwise(), (s1 + v1.x, s1 + v1.y)) | |
| 591 self.assertEqual(s1 - v1.elementwise(), (s1 - v1.x, s1 - v1.y)) | |
| 592 self.assertEqual(s1 * v1.elementwise(), (s1 * v1.x, s1 * v1.y)) | |
| 593 self.assertEqual(s1 / v1.elementwise(), (s1 / v1.x, s1 / v1.y)) | |
| 594 self.assertEqual(s1 // v1.elementwise(), (s1 // v1.x, s1 // v1.y)) | |
| 595 self.assertEqual(s1 ** v1.elementwise(), (s1 ** v1.x, s1 ** v1.y)) | |
| 596 self.assertEqual(s1 % v1.elementwise(), (s1 % v1.x, s1 % v1.y)) | |
| 597 self.assertEqual(s1 < v1.elementwise(), s1 < v1.x and s1 < v1.y) | |
| 598 self.assertEqual(s1 > v1.elementwise(), s1 > v1.x and s1 > v1.y) | |
| 599 self.assertEqual(s1 == v1.elementwise(), s1 == v1.x and s1 == v1.y) | |
| 600 self.assertEqual(s1 != v1.elementwise(), s1 != v1.x and s1 != v1.y) | |
| 601 self.assertEqual(s1 <= v1.elementwise(), s1 <= v1.x and s1 <= v1.y) | |
| 602 self.assertEqual(s1 >= v1.elementwise(), s1 >= v1.x and s1 >= v1.y) | |
| 603 self.assertEqual(s1 != v1.elementwise(), s1 != v1.x and s1 != v1.y) | |
| 604 | |
| 605 # behaviour for "elementwise op vector" | |
| 606 self.assertEqual(type(v1.elementwise() * v2), type(v1)) | |
| 607 self.assertEqual(v1.elementwise() + v2, v1 + v2) | |
| 608 self.assertEqual(v1.elementwise() - v2, v1 - v2) | |
| 609 self.assertEqual(v1.elementwise() * v2, (v1.x * v2.x, v1.y * v2.y)) | |
| 610 self.assertEqual(v1.elementwise() / v2, (v1.x / v2.x, v1.y / v2.y)) | |
| 611 self.assertEqual(v1.elementwise() // v2, (v1.x // v2.x, v1.y // v2.y)) | |
| 612 self.assertEqual(v1.elementwise() ** v2, (v1.x ** v2.x, v1.y ** v2.y)) | |
| 613 self.assertEqual(v1.elementwise() % v2, (v1.x % v2.x, v1.y % v2.y)) | |
| 614 self.assertEqual(v1.elementwise() > v2, v1.x > v2.x and v1.y > v2.y) | |
| 615 self.assertEqual(v1.elementwise() < v2, v1.x < v2.x and v1.y < v2.y) | |
| 616 self.assertEqual(v1.elementwise() >= v2, v1.x >= v2.x and v1.y >= v2.y) | |
| 617 self.assertEqual(v1.elementwise() <= v2, v1.x <= v2.x and v1.y <= v2.y) | |
| 618 self.assertEqual(v1.elementwise() == v2, v1.x == v2.x and v1.y == v2.y) | |
| 619 self.assertEqual(v1.elementwise() != v2, v1.x != v2.x and v1.y != v2.y) | |
| 620 # behaviour for "vector op elementwise" | |
| 621 self.assertEqual(v2 + v1.elementwise(), v2 + v1) | |
| 622 self.assertEqual(v2 - v1.elementwise(), v2 - v1) | |
| 623 self.assertEqual(v2 * v1.elementwise(), (v2.x * v1.x, v2.y * v1.y)) | |
| 624 self.assertEqual(v2 / v1.elementwise(), (v2.x / v1.x, v2.y / v1.y)) | |
| 625 self.assertEqual(v2 // v1.elementwise(), (v2.x // v1.x, v2.y // v1.y)) | |
| 626 self.assertEqual(v2 ** v1.elementwise(), (v2.x ** v1.x, v2.y ** v1.y)) | |
| 627 self.assertEqual(v2 % v1.elementwise(), (v2.x % v1.x, v2.y % v1.y)) | |
| 628 self.assertEqual(v2 < v1.elementwise(), v2.x < v1.x and v2.y < v1.y) | |
| 629 self.assertEqual(v2 > v1.elementwise(), v2.x > v1.x and v2.y > v1.y) | |
| 630 self.assertEqual(v2 <= v1.elementwise(), v2.x <= v1.x and v2.y <= v1.y) | |
| 631 self.assertEqual(v2 >= v1.elementwise(), v2.x >= v1.x and v2.y >= v1.y) | |
| 632 self.assertEqual(v2 == v1.elementwise(), v2.x == v1.x and v2.y == v1.y) | |
| 633 self.assertEqual(v2 != v1.elementwise(), v2.x != v1.x and v2.y != v1.y) | |
| 634 | |
| 635 # behaviour for "elementwise op elementwise" | |
| 636 self.assertEqual(v2.elementwise() + v1.elementwise(), v2 + v1) | |
| 637 self.assertEqual(v2.elementwise() - v1.elementwise(), v2 - v1) | |
| 638 self.assertEqual(v2.elementwise() * v1.elementwise(), (v2.x * v1.x, v2.y * v1.y)) | |
| 639 self.assertEqual(v2.elementwise() / v1.elementwise(), (v2.x / v1.x, v2.y / v1.y)) | |
| 640 self.assertEqual(v2.elementwise() // v1.elementwise(), (v2.x // v1.x, v2.y // v1.y)) | |
| 641 self.assertEqual(v2.elementwise() ** v1.elementwise(), (v2.x ** v1.x, v2.y ** v1.y)) | |
| 642 self.assertEqual(v2.elementwise() % v1.elementwise(), (v2.x % v1.x, v2.y % v1.y)) | |
| 643 self.assertEqual(v2.elementwise() < v1.elementwise(), v2.x < v1.x and v2.y < v1.y) | |
| 644 self.assertEqual(v2.elementwise() > v1.elementwise(), v2.x > v1.x and v2.y > v1.y) | |
| 645 self.assertEqual(v2.elementwise() <= v1.elementwise(), v2.x <= v1.x and v2.y <= v1.y) | |
| 646 self.assertEqual(v2.elementwise() >= v1.elementwise(), v2.x >= v1.x and v2.y >= v1.y) | |
| 647 self.assertEqual(v2.elementwise() == v1.elementwise(), v2.x == v1.x and v2.y == v1.y) | |
| 648 self.assertEqual(v2.elementwise() != v1.elementwise(), v2.x != v1.x and v2.y != v1.y) | |
| 649 | |
| 650 # other behaviour | |
| 651 self.assertEqual(abs(v1.elementwise()), (abs(v1.x), abs(v1.y))) | |
| 652 self.assertEqual(-v1.elementwise(), -v1) | |
| 653 self.assertEqual(+v1.elementwise(), +v1) | |
| 654 self.assertEqual(bool(v1.elementwise()), bool(v1)) | |
| 655 self.assertEqual(bool(Vector2().elementwise()), bool(Vector2())) | |
| 656 self.assertEqual(self.zeroVec.elementwise() ** 0, (1, 1)) | |
| 657 self.assertRaises(ValueError, lambda : pow(Vector2(-1, 0).elementwise(), 1.2)) | |
| 658 self.assertRaises(ZeroDivisionError, lambda : self.zeroVec.elementwise() ** -1) | |
| 2024 | 659 self.assertRaises(ZeroDivisionError, lambda : self.zeroVec.elementwise() ** -1) |
| 660 self.assertRaises(ZeroDivisionError, lambda : Vector2(1,1).elementwise() / 0) | |
| 661 self.assertRaises(ZeroDivisionError, lambda : Vector2(1,1).elementwise() // 0) | |
| 662 self.assertRaises(ZeroDivisionError, lambda : Vector2(1,1).elementwise() % 0) | |
| 663 self.assertRaises(ZeroDivisionError, lambda : Vector2(1,1).elementwise() / self.zeroVec) | |
| 664 self.assertRaises(ZeroDivisionError, lambda : Vector2(1,1).elementwise() // self.zeroVec) | |
| 665 self.assertRaises(ZeroDivisionError, lambda : Vector2(1,1).elementwise() % self.zeroVec) | |
| 666 self.assertRaises(ZeroDivisionError, lambda : 2 / self.zeroVec.elementwise()) | |
| 667 self.assertRaises(ZeroDivisionError, lambda : 2 // self.zeroVec.elementwise()) | |
| 668 self.assertRaises(ZeroDivisionError, lambda : 2 % self.zeroVec.elementwise()) | |
| 1994 | 669 |
| 670 def test_slerp(self): | |
|
2035
28685c84e251
as/from_polar/spherical now also use degrees instead of radians
lorenz
parents:
2024
diff
changeset
|
671 self.assertRaises(ValueError, lambda : self.zeroVec.slerp(self.v1, .5)) |
|
28685c84e251
as/from_polar/spherical now also use degrees instead of radians
lorenz
parents:
2024
diff
changeset
|
672 self.assertRaises(ValueError, lambda : self.v1.slerp(self.zeroVec, .5)) |
|
28685c84e251
as/from_polar/spherical now also use degrees instead of radians
lorenz
parents:
2024
diff
changeset
|
673 self.assertRaises(ValueError, |
|
2006
6a532cb218dd
removed iterator versions of vector.slerp() and .lerp() in favour of a parametrized version.
lorenz
parents:
1997
diff
changeset
|
674 lambda : self.zeroVec.slerp(self.zeroVec, .5)) |
| 1994 | 675 v1 = Vector2(1, 0) |
| 676 v2 = Vector2(0, 1) | |
|
2006
6a532cb218dd
removed iterator versions of vector.slerp() and .lerp() in favour of a parametrized version.
lorenz
parents:
1997
diff
changeset
|
677 steps = 10 |
| 1994 | 678 angle_step = v1.angle_to(v2) / steps |
|
2007
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
679 for i, u in ((i, v1.slerp(v2, i/float(steps))) for i in range(steps+1)): |
| 1994 | 680 self.assertAlmostEqual(u.length(), 1) |
|
2006
6a532cb218dd
removed iterator versions of vector.slerp() and .lerp() in favour of a parametrized version.
lorenz
parents:
1997
diff
changeset
|
681 self.assertAlmostEqual(v1.angle_to(u), i * angle_step) |
| 1994 | 682 self.assertEqual(u, v2) |
| 683 | |
| 684 v1 = Vector2(100, 0) | |
| 685 v2 = Vector2(0, 10) | |
| 686 radial_factor = v2.length() / v1.length() | |
|
2007
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
687 for i, u in ((i, v1.slerp(v2, -i/float(steps))) for i in range(steps+1)): |
|
2006
6a532cb218dd
removed iterator versions of vector.slerp() and .lerp() in favour of a parametrized version.
lorenz
parents:
1997
diff
changeset
|
688 self.assertAlmostEqual(u.length(), (v2.length() - v1.length()) * (float(i)/steps) + v1.length()) |
| 1994 | 689 self.assertEqual(u, v2) |
| 2024 | 690 self.assertEqual(v1.slerp(v1, .5), v1) |
| 691 self.assertEqual(v2.slerp(v2, .5), v2) | |
| 692 self.assertRaises(ValueError, lambda : v1.slerp(-v1, 0.5)) | |
| 1994 | 693 |
| 694 def test_lerp(self): | |
|
2006
6a532cb218dd
removed iterator versions of vector.slerp() and .lerp() in favour of a parametrized version.
lorenz
parents:
1997
diff
changeset
|
695 """TODO""" |
| 1994 | 696 pass |
| 697 | |
| 698 def test_polar(self): | |
| 699 v = Vector2() | |
| 700 v.from_polar(self.v1.as_polar()) | |
| 701 self.assertEqual(self.v1, v) | |
| 702 self.assertEqual(self.e1.as_polar(), (1, 0)) | |
|
2035
28685c84e251
as/from_polar/spherical now also use degrees instead of radians
lorenz
parents:
2024
diff
changeset
|
703 self.assertEqual(self.e2.as_polar(), (1, 90)) |
|
28685c84e251
as/from_polar/spherical now also use degrees instead of radians
lorenz
parents:
2024
diff
changeset
|
704 self.assertEqual((2 * self.e2).as_polar(), (2, 90)) |
| 1994 | 705 self.assertRaises(TypeError, lambda : v.from_polar((None, None))) |
| 706 self.assertRaises(TypeError, lambda : v.from_polar("ab")) | |
| 707 self.assertRaises(TypeError, lambda : v.from_polar((None, 1))) | |
| 708 self.assertRaises(TypeError, lambda : v.from_polar((1, 2, 3))) | |
| 709 self.assertRaises(TypeError, lambda : v.from_polar((1,))) | |
| 710 self.assertRaises(TypeError, lambda : v.from_polar(1, 2)) | |
|
2035
28685c84e251
as/from_polar/spherical now also use degrees instead of radians
lorenz
parents:
2024
diff
changeset
|
711 v.from_polar((.5, 90)) |
| 1994 | 712 self.assertEqual(v, .5 * self.e2) |
| 2024 | 713 v.from_polar((1, 0)) |
| 714 self.assertEqual(v, self.e1) | |
| 1994 | 715 |
| 716 | |
| 717 | |
| 718 | |
| 719 | |
| 720 class Vector3TypeTest(unittest.TestCase): | |
| 721 def setUp(self): | |
| 722 # gc.collect() | |
| 723 self.zeroVec = Vector3() | |
| 724 self.e1 = Vector3(1, 0, 0) | |
| 725 self.e2 = Vector3(0, 1, 0) | |
| 726 self.e3 = Vector3(0, 0, 1) | |
| 727 # self.t1 = (random(), random()) | |
| 728 self.t1 = (1.2, 3.4, 9.6) | |
| 729 self.l1 = list(self.t1) | |
| 730 self.v1 = Vector3(self.t1) | |
| 731 # self.t2 = (random(), random()) | |
| 732 self.t2 = (5.6, 7.8, 2.1) | |
| 733 self.l2 = list(self.t2) | |
| 734 self.v2 = Vector3(self.t2) | |
| 735 # self.s1 = random() | |
| 736 # self.s2 = random() | |
| 737 self.s1 = 5.6 | |
| 738 self.s2 = 7.8 | |
| 739 | |
| 740 def testConstructionDefault(self): | |
| 741 v = Vector3() | |
| 742 self.assertEqual(v.x, 0.) | |
| 743 self.assertEqual(v.y, 0.) | |
| 744 self.assertEqual(v.z, 0.) | |
| 745 | |
| 746 | |
| 747 def testConstructionXYZ(self): | |
| 748 v = Vector3(1.2, 3.4, 9.6) | |
| 749 self.assertEqual(v.x, 1.2) | |
| 750 self.assertEqual(v.y, 3.4) | |
| 751 self.assertEqual(v.z, 9.6) | |
| 752 | |
| 753 def testConstructionTuple(self): | |
| 754 v = Vector3((1.2, 3.4, 9.6)) | |
| 755 self.assertEqual(v.x, 1.2) | |
| 756 self.assertEqual(v.y, 3.4) | |
| 757 self.assertEqual(v.z, 9.6) | |
| 758 | |
| 759 def testConstructionList(self): | |
| 760 v = Vector3([1.2, 3.4, -9.6]) | |
| 761 self.assertEqual(v.x, 1.2) | |
| 762 self.assertEqual(v.y, 3.4) | |
| 763 self.assertEqual(v.z, -9.6) | |
| 764 | |
| 765 def testConstructionVector3(self): | |
| 766 v = Vector3(Vector3(1.2, 3.4, -9.6)) | |
| 767 self.assertEqual(v.x, 1.2) | |
| 768 self.assertEqual(v.y, 3.4) | |
| 769 self.assertEqual(v.z, -9.6) | |
| 770 | |
| 771 def testAttributAccess(self): | |
| 772 tmp = self.v1.x | |
| 773 self.assertEqual(tmp, self.v1.x) | |
| 774 self.assertEqual(tmp, self.v1[0]) | |
| 775 tmp = self.v1.y | |
| 776 self.assertEqual(tmp, self.v1.y) | |
| 777 self.assertEqual(tmp, self.v1[1]) | |
| 778 tmp = self.v1.z | |
| 779 self.assertEqual(tmp, self.v1.z) | |
| 780 self.assertEqual(tmp, self.v1[2]) | |
| 781 self.v1.x = 3.141 | |
| 782 self.assertEqual(self.v1.x, 3.141) | |
| 783 self.v1.y = 3.141 | |
| 784 self.assertEqual(self.v1.y, 3.141) | |
| 785 self.v1.z = 3.141 | |
| 786 self.assertEqual(self.v1.z, 3.141) | |
| 2024 | 787 def assign_nonfloat(): |
| 788 v = Vector2() | |
| 789 v.x = "spam" | |
| 790 self.assertRaises(TypeError, assign_nonfloat) | |
| 1994 | 791 |
| 792 def testSequence(self): | |
| 793 v = Vector3(1.2, 3.4, -9.6) | |
| 794 self.assertEqual(len(v), 3) | |
| 795 self.assertEqual(v[0], 1.2) | |
| 796 self.assertEqual(v[1], 3.4) | |
| 797 self.assertEqual(v[2], -9.6) | |
| 798 self.assertRaises(IndexError, lambda : v[3]) | |
| 799 self.assertEqual(v[-1], -9.6) | |
| 800 self.assertEqual(v[-2], 3.4) | |
| 801 self.assertEqual(v[-3], 1.2) | |
| 802 self.assertRaises(IndexError, lambda : v[-4]) | |
| 803 self.assertEqual(v[:], [1.2, 3.4, -9.6]) | |
| 804 self.assertEqual(v[1:], [3.4, -9.6]) | |
| 805 self.assertEqual(v[:1], [1.2]) | |
| 806 self.assertEqual(v[:-1], [1.2, 3.4]) | |
| 807 self.assertEqual(v[1:2], [3.4]) | |
| 808 self.assertEqual(list(v), [1.2, 3.4, -9.6]) | |
| 809 self.assertEqual(tuple(v), (1.2, 3.4, -9.6)) | |
| 810 v[0] = 5.6 | |
| 811 v[1] = 7.8 | |
| 812 v[2] = -2.1 | |
| 813 self.assertEqual(v.x, 5.6) | |
| 814 self.assertEqual(v.y, 7.8) | |
| 815 self.assertEqual(v.z, -2.1) | |
| 816 v[:] = [9.1, 11.12, -13.41] | |
| 817 self.assertEqual(v.x, 9.1) | |
| 818 self.assertEqual(v.y, 11.12) | |
| 819 self.assertEqual(v.z, -13.41) | |
| 820 def overpopulate(): | |
| 821 v = Vector3() | |
| 822 v[:] = [1, 2, 3, 4] | |
| 823 self.assertRaises(ValueError, overpopulate) | |
| 824 def underpopulate(): | |
| 825 v = Vector3() | |
| 826 v[:] = [1] | |
| 827 self.assertRaises(ValueError, underpopulate) | |
| 2024 | 828 def assign_nonfloat(): |
| 829 v = Vector2() | |
| 830 v[0] = "spam" | |
| 831 self.assertRaises(TypeError, assign_nonfloat) | |
| 1994 | 832 |
|
2007
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
833 def testExtendedSlicing(self): |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
834 # deletion |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
835 def delSlice(vec, start=None, stop=None, step=None): |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
836 if start is not None and stop is not None and step is not None: |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
837 del vec[start:stop:step] |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
838 elif start is not None and stop is None and step is not None: |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
839 del vec[start::step] |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
840 elif start is None and stop is None and step is not None: |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
841 del vec[::step] |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
842 v = Vector3(self.v1) |
| 2024 | 843 self.assertRaises(TypeError, delSlice, v, None, None, 2) |
| 844 self.assertRaises(TypeError, delSlice, v, 1, None, 2) | |
| 845 self.assertRaises(TypeError, delSlice, v, 1, 2, 1) | |
|
2007
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
846 |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
847 # assignment |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
848 v = Vector3(self.v1) |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
849 v[::2] = [-1.1, -2.2] |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
850 self.assertEqual(v, [-1.1, self.v1.y, -2.2]) |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
851 v = Vector3(self.v1) |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
852 v[::-2] = [10, 20] |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
853 self.assertEqual(v, [20, self.v1.y, 10]) |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
854 v = Vector3(self.v1) |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
855 v[::-1] = v |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
856 self.assertEqual(v, [self.v1.z, self.v1.y, self.v1.x]) |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
857 a = Vector3(self.v1) |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
858 b = Vector3(self.v1) |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
859 c = Vector3(self.v1) |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
860 a[1:2] = [2.2] |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
861 b[slice(1,2)] = [2.2] |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
862 c[1:2:] = (2.2,) |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
863 self.assertEqual(a, b) |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
864 self.assertEqual(a, c) |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
865 self.assertEqual(type(a), type(self.v1)) |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
866 self.assertEqual(type(b), type(self.v1)) |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
867 self.assertEqual(type(c), type(self.v1)) |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
868 |
| 1994 | 869 def testAdd(self): |
| 870 v3 = self.v1 + self.v2 | |
| 871 self.assert_(isinstance(v3, type(self.v1))) | |
| 872 self.assertEqual(v3.x, self.v1.x + self.v2.x) | |
| 873 self.assertEqual(v3.y, self.v1.y + self.v2.y) | |
| 874 self.assertEqual(v3.z, self.v1.z + self.v2.z) | |
| 875 v3 = self.v1 + self.t2 | |
| 876 self.assert_(isinstance(v3, type(self.v1))) | |
| 877 self.assertEqual(v3.x, self.v1.x + self.t2[0]) | |
| 878 self.assertEqual(v3.y, self.v1.y + self.t2[1]) | |
| 879 self.assertEqual(v3.z, self.v1.z + self.t2[2]) | |
| 880 v3 = self.v1 + self.l2 | |
| 881 self.assert_(isinstance(v3, type(self.v1))) | |
| 882 self.assertEqual(v3.x, self.v1.x + self.l2[0]) | |
| 883 self.assertEqual(v3.y, self.v1.y + self.l2[1]) | |
| 884 self.assertEqual(v3.z, self.v1.z + self.l2[2]) | |
| 885 v3 = self.t1 + self.v2 | |
| 886 self.assert_(isinstance(v3, type(self.v1))) | |
| 887 self.assertEqual(v3.x, self.t1[0] + self.v2.x) | |
| 888 self.assertEqual(v3.y, self.t1[1] + self.v2.y) | |
| 889 self.assertEqual(v3.z, self.t1[2] + self.v2.z) | |
| 890 v3 = self.l1 + self.v2 | |
| 891 self.assert_(isinstance(v3, type(self.v1))) | |
| 892 self.assertEqual(v3.x, self.l1[0] + self.v2.x) | |
| 893 self.assertEqual(v3.y, self.l1[1] + self.v2.y) | |
| 894 self.assertEqual(v3.z, self.l1[2] + self.v2.z) | |
| 895 | |
| 896 def testSub(self): | |
| 897 v3 = self.v1 - self.v2 | |
| 898 self.assert_(isinstance(v3, type(self.v1))) | |
| 899 self.assertEqual(v3.x, self.v1.x - self.v2.x) | |
| 900 self.assertEqual(v3.y, self.v1.y - self.v2.y) | |
| 901 self.assertEqual(v3.z, self.v1.z - self.v2.z) | |
| 902 v3 = self.v1 - self.t2 | |
| 903 self.assert_(isinstance(v3, type(self.v1))) | |
| 904 self.assertEqual(v3.x, self.v1.x - self.t2[0]) | |
| 905 self.assertEqual(v3.y, self.v1.y - self.t2[1]) | |
| 906 self.assertEqual(v3.z, self.v1.z - self.t2[2]) | |
| 907 v3 = self.v1 - self.l2 | |
| 908 self.assert_(isinstance(v3, type(self.v1))) | |
| 909 self.assertEqual(v3.x, self.v1.x - self.l2[0]) | |
| 910 self.assertEqual(v3.y, self.v1.y - self.l2[1]) | |
| 911 self.assertEqual(v3.z, self.v1.z - self.l2[2]) | |
| 912 v3 = self.t1 - self.v2 | |
| 913 self.assert_(isinstance(v3, type(self.v1))) | |
| 914 self.assertEqual(v3.x, self.t1[0] - self.v2.x) | |
| 915 self.assertEqual(v3.y, self.t1[1] - self.v2.y) | |
| 916 self.assertEqual(v3.z, self.t1[2] - self.v2.z) | |
| 917 v3 = self.l1 - self.v2 | |
| 918 self.assert_(isinstance(v3, type(self.v1))) | |
| 919 self.assertEqual(v3.x, self.l1[0] - self.v2.x) | |
| 920 self.assertEqual(v3.y, self.l1[1] - self.v2.y) | |
| 921 self.assertEqual(v3.z, self.l1[2] - self.v2.z) | |
| 922 | |
| 923 def testScalarMultiplication(self): | |
| 924 v = self.s1 * self.v1 | |
| 925 self.assert_(isinstance(v, type(self.v1))) | |
| 926 self.assertEqual(v.x, self.s1 * self.v1.x) | |
| 927 self.assertEqual(v.y, self.s1 * self.v1.y) | |
| 928 self.assertEqual(v.z, self.s1 * self.v1.z) | |
| 929 v = self.v1 * self.s2 | |
| 930 self.assertEqual(v.x, self.v1.x * self.s2) | |
| 931 self.assertEqual(v.y, self.v1.y * self.s2) | |
| 932 self.assertEqual(v.z, self.v1.z * self.s2) | |
| 933 | |
| 934 def testScalarDivision(self): | |
| 935 v = self.v1 / self.s1 | |
| 936 self.assert_(isinstance(v, type(self.v1))) | |
| 937 self.assertAlmostEqual(v.x, self.v1.x / self.s1) | |
| 938 self.assertAlmostEqual(v.y, self.v1.y / self.s1) | |
| 939 self.assertAlmostEqual(v.z, self.v1.z / self.s1) | |
| 940 v = self.v1 // self.s2 | |
| 941 self.assert_(isinstance(v, type(self.v1))) | |
| 942 self.assertEqual(v.x, self.v1.x // self.s2) | |
| 943 self.assertEqual(v.y, self.v1.y // self.s2) | |
| 944 self.assertEqual(v.z, self.v1.z // self.s2) | |
| 945 | |
| 946 def testBool(self): | |
| 947 self.assertEqual(bool(self.zeroVec), False) | |
| 948 self.assertEqual(bool(self.v1), True) | |
| 949 self.assert_(not self.zeroVec) | |
| 950 self.assert_(self.v1) | |
| 951 | |
| 952 def testUnary(self): | |
| 953 v = +self.v1 | |
| 954 self.assert_(isinstance(v, type(self.v1))) | |
| 955 self.assertEqual(v.x, self.v1.x) | |
| 956 self.assertEqual(v.y, self.v1.y) | |
| 957 self.assertEqual(v.z, self.v1.z) | |
| 958 self.assertNotEqual(id(v), id(self.v1)) | |
| 959 v = -self.v1 | |
| 960 self.assert_(isinstance(v, type(self.v1))) | |
| 961 self.assertEqual(v.x, -self.v1.x) | |
| 962 self.assertEqual(v.y, -self.v1.y) | |
| 963 self.assertEqual(v.z, -self.v1.z) | |
| 964 self.assertNotEqual(id(v), id(self.v1)) | |
| 965 | |
| 966 def testCompare(self): | |
| 967 int_vec = Vector3(3, -2, 13) | |
| 968 flt_vec = Vector3(3.0, -2.0, 13.) | |
| 969 zero_vec = Vector3(0, 0, 0) | |
| 970 self.assertEqual(int_vec == flt_vec, True) | |
| 971 self.assertEqual(int_vec != flt_vec, False) | |
| 972 self.assertEqual(int_vec != zero_vec, True) | |
| 973 self.assertEqual(flt_vec == zero_vec, False) | |
| 974 self.assertEqual(int_vec == (3, -2, 13), True) | |
| 975 self.assertEqual(int_vec != (3, -2, 13), False) | |
| 976 self.assertEqual(int_vec != [0, 0], True) | |
| 977 self.assertEqual(int_vec == [0, 0], False) | |
| 978 self.assertEqual(int_vec != 5, True) | |
| 979 self.assertEqual(int_vec == 5, False) | |
| 980 self.assertEqual(int_vec != [3, -2, 0, 1], True) | |
| 981 self.assertEqual(int_vec == [3, -2, 0, 1], False) | |
| 982 | |
| 983 def testStr(self): | |
| 984 v = Vector3(1.2, 3.4, 5.6) | |
| 985 self.assertEqual(str(v), "[1.2, 3.4, 5.6]") | |
| 986 | |
| 987 def testRepr(self): | |
| 988 v = Vector3(1.2, 3.4, -9.6) | |
| 989 self.assertEqual(v.__repr__(), "<Vector3(1.2, 3.4, -9.6)>") | |
| 990 self.assertEqual(v, Vector3(v.__repr__())) | |
| 991 | |
| 992 def testIter(self): | |
| 993 it = self.v1.__iter__() | |
|
2007
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
994 # support py2.x and 3.x |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
995 if hasattr(it, "next"): |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
996 next_ = it.next |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
997 elif hasattr(it, "__next__"): |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
998 next_ = it.__next__ |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
999 else: |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
1000 self.fail("Iterator has neither a 'next' nor a '__next__' method.") |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
1001 self.assertEqual(next_(), self.v1[0]) |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
1002 self.assertEqual(next_(), self.v1[1]) |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
1003 self.assertEqual(next_(), self.v1[2]) |
|
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
1004 self.assertRaises(StopIteration, lambda : next_()) |
| 1994 | 1005 it1 = self.v1.__iter__() |
| 1006 it2 = self.v1.__iter__() | |
| 1007 self.assertNotEqual(id(it1), id(it2)) | |
| 1008 self.assertEqual(id(it1), id(it1.__iter__())) | |
| 1009 self.assertEqual(list(it1), list(it2)); | |
| 1010 self.assertEqual(list(self.v1.__iter__()), self.l1) | |
| 1011 idx = 0 | |
| 1012 for val in self.v1: | |
| 1013 self.assertEqual(val, self.v1[idx]) | |
| 1014 idx += 1 | |
| 1015 | |
| 1016 def test_rotate(self): | |
| 1017 v1 = Vector3(1, 0, 0) | |
| 1018 axis = Vector3(0, 1, 0) | |
| 1019 v2 = v1.rotate(90, axis) | |
| 1020 v3 = v1.rotate(90 + 360, axis) | |
| 1021 self.assertEqual(v1.x, 1) | |
| 1022 self.assertEqual(v1.y, 0) | |
| 1023 self.assertEqual(v1.z, 0) | |
| 1024 self.assertEqual(v2.x, 0) | |
| 1025 self.assertEqual(v2.y, 0) | |
| 1026 self.assertEqual(v2.z, -1) | |
| 1027 self.assertEqual(v3.x, v2.x) | |
| 1028 self.assertEqual(v3.y, v2.y) | |
| 1029 self.assertEqual(v3.z, v2.z) | |
| 1030 v1 = Vector3(-1, -1, -1) | |
| 1031 v2 = v1.rotate(-90, axis) | |
| 1032 self.assertEqual(v2.x, 1) | |
| 1033 self.assertEqual(v2.y, -1) | |
| 1034 self.assertEqual(v2.z, -1) | |
| 1035 v2 = v1.rotate(360, axis) | |
| 1036 self.assertEqual(v1.x, v2.x) | |
| 1037 self.assertEqual(v1.y, v2.y) | |
| 1038 self.assertEqual(v1.z, v2.z) | |
| 1039 v2 = v1.rotate(0, axis) | |
| 1040 self.assertEqual(v1.x, v2.x) | |
| 1041 self.assertEqual(v1.y, v2.y) | |
| 1042 self.assertEqual(v1.z, v2.z) | |
| 1043 | |
| 1044 def test_rotate_ip(self): | |
| 1045 v = Vector3(1, 0) | |
| 1046 axis = Vector3(0, 1, 0) | |
| 1047 self.assertEqual(v.rotate_ip(90, axis), None) | |
| 1048 self.assertEqual(v.x, 0) | |
| 1049 self.assertEqual(v.y, 0) | |
| 1050 self.assertEqual(v.z, -1) | |
| 1051 v = Vector3(-1, -1, 1) | |
| 1052 v.rotate_ip(-90, axis) | |
| 1053 self.assertEqual(v.x, -1) | |
| 1054 self.assertEqual(v.y, -1) | |
| 1055 self.assertEqual(v.z, -1) | |
| 1056 | |
| 1997 | 1057 def test_rotate_x(self): |
| 1058 v1 = Vector3(1, 0, 0) | |
| 1059 v2 = v1.rotate_x(90) | |
| 1060 v3 = v1.rotate_x(90 + 360) | |
| 1061 self.assertEqual(v1.x, 1) | |
| 1062 self.assertEqual(v1.y, 0) | |
| 1063 self.assertEqual(v1.z, 0) | |
| 1064 self.assertEqual(v2.x, 1) | |
| 1065 self.assertEqual(v2.y, 0) | |
| 1066 self.assertEqual(v2.z, 0) | |
| 1067 self.assertEqual(v3.x, v2.x) | |
| 1068 self.assertEqual(v3.y, v2.y) | |
| 1069 self.assertEqual(v3.z, v2.z) | |
| 1070 v1 = Vector3(-1, -1, -1) | |
| 1071 v2 = v1.rotate_x(-90) | |
| 1072 self.assertEqual(v2.x, -1) | |
| 1073 self.assertAlmostEqual(v2.y, -1) | |
| 1074 self.assertAlmostEqual(v2.z, 1) | |
| 1075 v2 = v1.rotate_x(360) | |
| 1076 self.assertAlmostEqual(v1.x, v2.x) | |
| 1077 self.assertAlmostEqual(v1.y, v2.y) | |
| 1078 self.assertAlmostEqual(v1.z, v2.z) | |
| 1079 v2 = v1.rotate_x(0) | |
| 1080 self.assertEqual(v1.x, v2.x) | |
| 1081 self.assertAlmostEqual(v1.y, v2.y) | |
| 1082 self.assertAlmostEqual(v1.z, v2.z) | |
| 1083 | |
| 1084 def test_rotate_x_ip(self): | |
| 1085 v = Vector3(1, 0, 0) | |
| 1086 self.assertEqual(v.rotate_x_ip(90), None) | |
| 1087 self.assertEqual(v.x, 1) | |
| 1088 self.assertEqual(v.y, 0) | |
| 1089 self.assertEqual(v.z, 0) | |
| 1090 v = Vector3(-1, -1, 1) | |
| 1091 v.rotate_x_ip(-90) | |
| 1092 self.assertEqual(v.x, -1) | |
| 1093 self.assertAlmostEqual(v.y, 1) | |
| 1094 self.assertAlmostEqual(v.z, 1) | |
| 1095 | |
| 1096 def test_rotate_y(self): | |
| 1097 v1 = Vector3(1, 0, 0) | |
| 1098 v2 = v1.rotate_y(90) | |
| 1099 v3 = v1.rotate_y(90 + 360) | |
| 1100 self.assertEqual(v1.x, 1) | |
| 1101 self.assertEqual(v1.y, 0) | |
| 1102 self.assertEqual(v1.z, 0) | |
| 1103 self.assertAlmostEqual(v2.x, 0) | |
| 1104 self.assertEqual(v2.y, 0) | |
| 1105 self.assertAlmostEqual(v2.z, -1) | |
| 1106 self.assertAlmostEqual(v3.x, v2.x) | |
| 1107 self.assertEqual(v3.y, v2.y) | |
| 1108 self.assertAlmostEqual(v3.z, v2.z) | |
| 1109 v1 = Vector3(-1, -1, -1) | |
| 1110 v2 = v1.rotate_y(-90) | |
| 1111 self.assertAlmostEqual(v2.x, 1) | |
| 1112 self.assertEqual(v2.y, -1) | |
| 1113 self.assertAlmostEqual(v2.z, -1) | |
| 1114 v2 = v1.rotate_y(360) | |
| 1115 self.assertAlmostEqual(v1.x, v2.x) | |
| 1116 self.assertEqual(v1.y, v2.y) | |
| 1117 self.assertAlmostEqual(v1.z, v2.z) | |
| 1118 v2 = v1.rotate_y(0) | |
| 1119 self.assertEqual(v1.x, v2.x) | |
| 1120 self.assertEqual(v1.y, v2.y) | |
| 1121 self.assertEqual(v1.z, v2.z) | |
| 1122 | |
| 1123 def test_rotate_y_ip(self): | |
| 1124 v = Vector3(1, 0, 0) | |
| 1125 self.assertEqual(v.rotate_y_ip(90), None) | |
| 1126 self.assertAlmostEqual(v.x, 0) | |
| 1127 self.assertEqual(v.y, 0) | |
| 1128 self.assertAlmostEqual(v.z, -1) | |
| 1129 v = Vector3(-1, -1, 1) | |
| 1130 v.rotate_y_ip(-90) | |
| 1131 self.assertAlmostEqual(v.x, -1) | |
| 1132 self.assertEqual(v.y, -1) | |
| 1133 self.assertAlmostEqual(v.z, -1) | |
| 1134 | |
| 1135 def test_rotate_z(self): | |
| 1136 v1 = Vector3(1, 0, 0) | |
| 1137 v2 = v1.rotate_z(90) | |
| 1138 v3 = v1.rotate_z(90 + 360) | |
| 1139 self.assertEqual(v1.x, 1) | |
| 1140 self.assertEqual(v1.y, 0) | |
| 1141 self.assertEqual(v1.z, 0) | |
| 1142 self.assertAlmostEqual(v2.x, 0) | |
| 1143 self.assertAlmostEqual(v2.y, 1) | |
| 1144 self.assertEqual(v2.z, 0) | |
| 1145 self.assertAlmostEqual(v3.x, v2.x) | |
| 1146 self.assertAlmostEqual(v3.y, v2.y) | |
| 1147 self.assertEqual(v3.z, v2.z) | |
| 1148 v1 = Vector3(-1, -1, -1) | |
| 1149 v2 = v1.rotate_z(-90) | |
| 1150 self.assertAlmostEqual(v2.x, -1) | |
| 1151 self.assertAlmostEqual(v2.y, 1) | |
| 1152 self.assertEqual(v2.z, -1) | |
| 1153 v2 = v1.rotate_z(360) | |
| 1154 self.assertAlmostEqual(v1.x, v2.x) | |
| 1155 self.assertAlmostEqual(v1.y, v2.y) | |
| 1156 self.assertEqual(v1.z, v2.z) | |
| 1157 v2 = v1.rotate_z(0) | |
| 1158 self.assertAlmostEqual(v1.x, v2.x) | |
| 1159 self.assertAlmostEqual(v1.y, v2.y) | |
| 1160 self.assertEqual(v1.z, v2.z) | |
| 1161 | |
| 1162 def test_rotate_z_ip(self): | |
| 1163 v = Vector3(1, 0, 0) | |
| 1164 self.assertEqual(v.rotate_z_ip(90), None) | |
| 1165 self.assertAlmostEqual(v.x, 0) | |
| 1166 self.assertAlmostEqual(v.y, 1) | |
| 1167 self.assertEqual(v.z, 0) | |
| 1168 v = Vector3(-1, -1, 1) | |
| 1169 v.rotate_z_ip(-90) | |
| 1170 self.assertAlmostEqual(v.x, -1) | |
| 1171 self.assertAlmostEqual(v.y, 1) | |
| 1172 self.assertEqual(v.z, 1) | |
| 1173 | |
| 1994 | 1174 def test_normalize(self): |
| 1175 v = self.v1.normalize() | |
| 1176 # length is 1 | |
| 1177 self.assertAlmostEqual(v.x * v.x + v.y * v.y + v.z * v.z, 1.) | |
| 1178 # v1 is unchanged | |
| 1179 self.assertEqual(self.v1.x, self.l1[0]) | |
| 1180 self.assertEqual(self.v1.y, self.l1[1]) | |
| 1181 self.assertEqual(self.v1.z, self.l1[2]) | |
| 1182 # v2 is paralell to v1 (tested via cross product) | |
| 1183 cross = ((self.v1.y * v.z - self.v1.z * v.y) ** 2 + | |
| 1184 (self.v1.z * v.x - self.v1.x * v.z) ** 2 + | |
| 1185 (self.v1.x * v.y - self.v1.y * v.x) ** 2) | |
| 1186 self.assertAlmostEqual(cross, 0.) | |
|
2035
28685c84e251
as/from_polar/spherical now also use degrees instead of radians
lorenz
parents:
2024
diff
changeset
|
1187 self.assertRaises(ValueError, lambda : self.zeroVec.normalize()) |
| 1994 | 1188 |
| 1189 def test_normalize_ip(self): | |
| 1190 v = +self.v1 | |
| 1191 # v has length != 1 before normalizing | |
| 1192 self.assertNotEqual(v.x * v.x + v.y * v.y + v.z * v.z, 1.) | |
| 1193 # inplace operations should return None | |
| 1194 self.assertEqual(v.normalize_ip(), None) | |
| 1195 # length is 1 | |
| 1196 self.assertAlmostEqual(v.x * v.x + v.y * v.y + v.z * v.z, 1.) | |
| 1197 # v2 is paralell to v1 (tested via cross product) | |
| 1198 cross = ((self.v1.y * v.z - self.v1.z * v.y) ** 2 + | |
| 1199 (self.v1.z * v.x - self.v1.x * v.z) ** 2 + | |
| 1200 (self.v1.x * v.y - self.v1.y * v.x) ** 2) | |
| 1201 self.assertAlmostEqual(cross, 0.) | |
|
2035
28685c84e251
as/from_polar/spherical now also use degrees instead of radians
lorenz
parents:
2024
diff
changeset
|
1202 self.assertRaises(ValueError, lambda : self.zeroVec.normalize_ip()) |
| 1994 | 1203 |
| 1204 def test_is_normalized(self): | |
| 1205 self.assertEqual(self.v1.is_normalized(), False) | |
| 1206 v = self.v1.normalize() | |
| 1207 self.assertEqual(v.is_normalized(), True) | |
| 1208 self.assertEqual(self.e2.is_normalized(), True) | |
| 1209 self.assertEqual(self.zeroVec.is_normalized(), False) | |
| 1210 | |
| 1211 def test_cross(self): | |
| 1212 def cross(a, b): | |
| 1213 return Vector3(a[1] * b[2] - a[2] * b[1], | |
| 1214 a[2] * b[0] - a[0] * b[2], | |
| 1215 a[0] * b[1] - a[1] * b[0]) | |
| 1216 self.assertEqual(self.v1.cross(self.v2), cross(self.v1, self.v2)) | |
| 1217 self.assertEqual(self.v1.cross(self.l2), cross(self.v1, self.l2)) | |
| 1218 self.assertEqual(self.v1.cross(self.t2), cross(self.v1, self.t2)) | |
| 1219 self.assertEqual(self.v1.cross(self.v2), -self.v2.cross(self.v1)) | |
| 1220 self.assertEqual(self.v1.cross(self.v1), self.zeroVec) | |
| 1221 | |
| 1222 def test_dot(self): | |
| 1223 self.assertAlmostEqual(self.v1.dot(self.v2), | |
| 1224 self.v1.x * self.v2.x + self.v1.y * self.v2.y + self.v1.z * self.v2.z) | |
| 1225 self.assertAlmostEqual(self.v1.dot(self.l2), | |
| 1226 self.v1.x * self.l2[0] + self.v1.y * self.l2[1] + self.v1.z * self.l2[2]) | |
| 1227 self.assertAlmostEqual(self.v1.dot(self.t2), | |
| 1228 self.v1.x * self.t2[0] + self.v1.y * self.t2[1] + self.v1.z * self.t2[2]) | |
| 1229 self.assertAlmostEqual(self.v1.dot(self.v2), self.v2.dot(self.v1)) | |
| 1230 self.assertAlmostEqual(self.v1.dot(self.v2), self.v1 * self.v2) | |
| 1231 | |
| 1232 def test_angle_to(self): | |
| 1233 self.assertEqual(Vector3(1, 1, 0).angle_to((-1, 1, 0)), 90) | |
| 1234 self.assertEqual(Vector3(1, 0, 0).angle_to((0, 0, -1)), 90) | |
| 1235 self.assertEqual(Vector3(1, 0, 0).angle_to((-1, 0, 1)), 135) | |
| 1236 self.assertEqual(abs(Vector3(1, 0, 1).angle_to((-1, 0, -1))), 180) | |
| 1237 # if we rotate v1 by the angle_to v2 around their cross product | |
| 1238 # we should look in the same direction | |
| 1239 self.assertEqual(self.v1.rotate(self.v1.angle_to(self.v2), self.v1.cross(self.v2)).normalize(), | |
| 1240 self.v2.normalize()) | |
| 1241 | |
| 1242 def test_scale_to_length(self): | |
| 1243 v = Vector3(1, 1, 1) | |
| 1244 v.scale_to_length(2.5) | |
| 1245 self.assertEqual(v, Vector3(2.5, 2.5, 2.5) / math.sqrt(3)) | |
|
2035
28685c84e251
as/from_polar/spherical now also use degrees instead of radians
lorenz
parents:
2024
diff
changeset
|
1246 self.assertRaises(ValueError, lambda : self.zeroVec.scale_to_length(1)) |
| 1994 | 1247 self.assertEqual(v.scale_to_length(0), None) |
| 1248 self.assertEqual(v, self.zeroVec) | |
| 1249 | |
| 1250 def test_length(self): | |
| 1251 self.assertEqual(Vector3(3, 4, 5).length(), math.sqrt(3 * 3 + 4 * 4 + 5 * 5)) | |
| 1252 self.assertEqual(Vector3(-3, 4, 5).length(), math.sqrt(-3 * -3 + 4 * 4 + 5 * 5)) | |
| 1253 self.assertEqual(self.zeroVec.length(), 0) | |
| 1254 | |
| 1255 def test_length_squared(self): | |
| 1256 self.assertEqual(Vector3(3, 4, 5).length_squared(), 3 * 3 + 4 * 4 + 5 * 5) | |
| 1257 self.assertEqual(Vector3(-3, 4, 5).length_squared(), -3 * -3 + 4 * 4 + 5 * 5) | |
| 1258 self.assertEqual(self.zeroVec.length_squared(), 0) | |
| 1259 | |
| 1260 def test_reflect(self): | |
| 1261 v = Vector3(1, -1, 1) | |
| 1262 n = Vector3(0, 1, 0) | |
| 1263 self.assertEqual(v.reflect(n), Vector3(1, 1, 1)) | |
| 1264 self.assertEqual(v.reflect(3*n), v.reflect(n)) | |
| 1265 self.assertEqual(v.reflect(-v), -v) | |
|
2035
28685c84e251
as/from_polar/spherical now also use degrees instead of radians
lorenz
parents:
2024
diff
changeset
|
1266 self.assertRaises(ValueError, lambda : v.reflect(self.zeroVec)) |
| 1994 | 1267 |
| 1268 def test_reflect_ip(self): | |
| 1269 v1 = Vector3(1, -1, 1) | |
| 1270 v2 = Vector3(v1) | |
| 1271 n = Vector3(0, 1, 0) | |
| 1272 self.assertEqual(v2.reflect_ip(n), None) | |
| 1273 self.assertEqual(v2, Vector3(1, 1, 1)) | |
| 1274 v2 = Vector3(v1) | |
| 1275 v2.reflect_ip(3*n) | |
| 1276 self.assertEqual(v2, v1.reflect(n)) | |
| 1277 v2 = Vector3(v1) | |
| 1278 v2.reflect_ip(-v1) | |
| 1279 self.assertEqual(v2, -v1) | |
|
2035
28685c84e251
as/from_polar/spherical now also use degrees instead of radians
lorenz
parents:
2024
diff
changeset
|
1280 self.assertRaises(ValueError, lambda : v2.reflect_ip(self.zeroVec)) |
| 1994 | 1281 |
| 1282 def test_distance_to(self): | |
| 1283 diff = self.v1 - self.v2 | |
| 1284 self.assertEqual(self.e1.distance_to(self.e2), math.sqrt(2)) | |
| 1285 self.assertEqual(self.v1.distance_to(self.v2), | |
| 1286 math.sqrt(diff.x * diff.x + diff.y * diff.y + diff.z * diff.z)) | |
| 1287 self.assertEqual(self.v1.distance_to(self.v1), 0) | |
| 1288 self.assertEqual(self.v1.distance_to(self.v2), | |
| 1289 self.v2.distance_to(self.v1)) | |
| 1290 | |
| 1291 def test_distance_squared_to(self): | |
| 1292 diff = self.v1 - self.v2 | |
| 1293 self.assertEqual(self.e1.distance_squared_to(self.e2), 2) | |
| 1294 self.assertEqual(self.v1.distance_squared_to(self.v2), | |
| 1295 diff.x * diff.x + diff.y * diff.y + diff.z * diff.z) | |
| 1296 self.assertEqual(self.v1.distance_squared_to(self.v1), 0) | |
| 1297 self.assertEqual(self.v1.distance_squared_to(self.v2), | |
| 1298 self.v2.distance_squared_to(self.v1)) | |
| 1299 | |
| 1300 def testSwizzle(self): | |
| 1301 self.assertEquals(hasattr(pygame.math, "enable_swizzling"), True) | |
| 1302 self.assertEquals(hasattr(pygame.math, "disable_swizzling"), True) | |
| 1303 # swizzling disabled by default | |
| 1304 self.assertRaises(AttributeError, lambda : self.v1.yx) | |
| 1305 pygame.math.enable_swizzling() | |
| 1306 | |
|
2013
3b778c6f8cde
fixed bug in swizzle code (you were only able to get x and y so far).
lorenz
parents:
2007
diff
changeset
|
1307 self.assertEqual(self.v1.yxz, (self.v1.y, self.v1.x, self.v1.z)) |
|
3b778c6f8cde
fixed bug in swizzle code (you were only able to get x and y so far).
lorenz
parents:
2007
diff
changeset
|
1308 self.assertEqual(self.v1.xxyyzzxyz, (self.v1.x, self.v1.x, self.v1.y, |
|
3b778c6f8cde
fixed bug in swizzle code (you were only able to get x and y so far).
lorenz
parents:
2007
diff
changeset
|
1309 self.v1.y, self.v1.z, self.v1.z, |
|
3b778c6f8cde
fixed bug in swizzle code (you were only able to get x and y so far).
lorenz
parents:
2007
diff
changeset
|
1310 self.v1.x, self.v1.y, self.v1.z)) |
| 1994 | 1311 self.v1.xyz = self.t2 |
| 1312 self.assertEqual(self.v1, self.t2) | |
| 1313 self.v1.zxy = self.t2 | |
| 1314 self.assertEqual(self.v1, (self.t2[1], self.t2[2], self.t2[0])) | |
| 1315 self.v1.yz = self.t2[:2] | |
| 1316 self.assertEqual(self.v1, (self.t2[1], self.t2[0], self.t2[1])) | |
| 1317 self.assertEqual(type(self.v1), Vector3) | |
| 1318 def invalidSwizzleX(): | |
| 1319 Vector3().xx = (1, 2) | |
| 1320 def invalidSwizzleY(): | |
| 1321 Vector3().yy = (1, 2) | |
| 1322 def invalidSwizzleZ(): | |
| 1323 Vector3().zz = (1, 2) | |
| 1324 def invalidSwizzleW(): | |
| 1325 Vector3().ww = (1, 2) | |
| 1326 self.assertRaises(AttributeError, invalidSwizzleX) | |
| 1327 self.assertRaises(AttributeError, invalidSwizzleY) | |
| 1328 self.assertRaises(AttributeError, invalidSwizzleZ) | |
| 1329 self.assertRaises(AttributeError, invalidSwizzleW) | |
| 1330 def invalidAssignment(): | |
| 1331 Vector3().xy = 3 | |
| 1332 self.assertRaises(TypeError, invalidAssignment) | |
| 1333 | |
| 1334 def test_elementwise(self): | |
| 1335 # behaviour for "elementwise op scalar" | |
| 1336 self.assertEqual(self.v1.elementwise() + self.s1, | |
| 1337 (self.v1.x + self.s1, self.v1.y + self.s1, self.v1.z + self.s1)) | |
| 1338 self.assertEqual(self.v1.elementwise() - self.s1, | |
| 1339 (self.v1.x - self.s1, self.v1.y - self.s1, self.v1.z - self.s1)) | |
| 1340 self.assertEqual(self.v1.elementwise() * self.s2, | |
| 1341 (self.v1.x * self.s2, self.v1.y * self.s2, self.v1.z * self.s2)) | |
| 1342 self.assertEqual(self.v1.elementwise() / self.s2, | |
| 1343 (self.v1.x / self.s2, self.v1.y / self.s2, self.v1.z / self.s2)) | |
| 1344 self.assertEqual(self.v1.elementwise() // self.s1, | |
| 1345 (self.v1.x // self.s1, self.v1.y // self.s1, self.v1.z // self.s1)) | |
| 1346 self.assertEqual(self.v1.elementwise() ** self.s1, | |
| 1347 (self.v1.x ** self.s1, self.v1.y ** self.s1, self.v1.z ** self.s1)) | |
| 1348 self.assertEqual(self.v1.elementwise() % self.s1, | |
| 1349 (self.v1.x % self.s1, self.v1.y % self.s1, self.v1.z % self.s1)) | |
| 1350 self.assertEqual(self.v1.elementwise() > self.s1, | |
| 1351 self.v1.x > self.s1 and self.v1.y > self.s1 and self.v1.z > self.s1) | |
| 1352 self.assertEqual(self.v1.elementwise() < self.s1, | |
| 1353 self.v1.x < self.s1 and self.v1.y < self.s1 and self.v1.z < self.s1) | |
| 1354 self.assertEqual(self.v1.elementwise() == self.s1, | |
| 1355 self.v1.x == self.s1 and self.v1.y == self.s1 and self.v1.z == self.s1) | |
| 1356 self.assertEqual(self.v1.elementwise() != self.s1, | |
| 1357 self.v1.x != self.s1 and self.v1.y != self.s1 and self.v1.z != self.s1) | |
| 1358 self.assertEqual(self.v1.elementwise() >= self.s1, | |
| 1359 self.v1.x >= self.s1 and self.v1.y >= self.s1 and self.v1.z >= self.s1) | |
| 1360 self.assertEqual(self.v1.elementwise() <= self.s1, | |
| 1361 self.v1.x <= self.s1 and self.v1.y <= self.s1 and self.v1.z <= self.s1) | |
| 1362 # behaviour for "scalar op elementwise" | |
| 1363 self.assertEqual(5 + self.v1.elementwise(), Vector3(5, 5, 5) + self.v1) | |
| 1364 self.assertEqual(3.5 - self.v1.elementwise(), Vector3(3.5, 3.5, 3.5) - self.v1) | |
| 1365 self.assertEqual(7.5 * self.v1.elementwise() , 7.5 * self.v1) | |
| 1366 self.assertEqual(-3.5 / self.v1.elementwise(), (-3.5 / self.v1.x, -3.5 / self.v1.y, -3.5 / self.v1.z)) | |
| 1367 self.assertEqual(-3.5 // self.v1.elementwise(), (-3.5 // self.v1.x, -3.5 // self.v1.y, -3.5 // self.v1.z)) | |
| 1368 self.assertEqual(-3.5 ** self.v1.elementwise(), (-3.5 ** self.v1.x, -3.5 ** self.v1.y, -3.5 ** self.v1.z)) | |
| 1369 self.assertEqual(3 % self.v1.elementwise(), (3 % self.v1.x, 3 % self.v1.y, 3 % self.v1.z)) | |
| 1370 self.assertEqual(2 < self.v1.elementwise(), 2 < self.v1.x and 2 < self.v1.y and 2 < self.v1.z) | |
| 1371 self.assertEqual(2 > self.v1.elementwise(), 2 > self.v1.x and 2 > self.v1.y and 2 > self.v1.z) | |
| 1372 self.assertEqual(1 == self.v1.elementwise(), 1 == self.v1.x and 1 == self.v1.y and 1 == self.v1.z) | |
| 1373 self.assertEqual(1 != self.v1.elementwise(), 1 != self.v1.x and 1 != self.v1.y and 1 != self.v1.z) | |
| 1374 self.assertEqual(2 <= self.v1.elementwise(), 2 <= self.v1.x and 2 <= self.v1.y and 2 <= self.v1.z) | |
| 1375 self.assertEqual(-7 >= self.v1.elementwise(), -7 >= self.v1.x and -7 >= self.v1.y and -7 >= self.v1.z) | |
| 1376 self.assertEqual(-7 != self.v1.elementwise(), -7 != self.v1.x and -7 != self.v1.y and -7 != self.v1.z) | |
| 1377 | |
| 1378 # behaviour for "elementwise op vector" | |
| 1379 self.assertEqual(type(self.v1.elementwise() * self.v2), type(self.v1)) | |
| 1380 self.assertEqual(self.v1.elementwise() + self.v2, self.v1 + self.v2) | |
| 1381 self.assertEqual(self.v1.elementwise() + self.v2, self.v1 + self.v2) | |
| 1382 self.assertEqual(self.v1.elementwise() - self.v2, self.v1 - self.v2) | |
| 1383 self.assertEqual(self.v1.elementwise() * self.v2, (self.v1.x * self.v2.x, self.v1.y * self.v2.y, self.v1.z * self.v2.z)) | |
| 1384 self.assertEqual(self.v1.elementwise() / self.v2, (self.v1.x / self.v2.x, self.v1.y / self.v2.y, self.v1.z / self.v2.z)) | |
| 1385 self.assertEqual(self.v1.elementwise() // self.v2, (self.v1.x // self.v2.x, self.v1.y // self.v2.y, self.v1.z // self.v2.z)) | |
| 1386 self.assertEqual(self.v1.elementwise() ** self.v2, (self.v1.x ** self.v2.x, self.v1.y ** self.v2.y, self.v1.z ** self.v2.z)) | |
| 1387 self.assertEqual(self.v1.elementwise() % self.v2, (self.v1.x % self.v2.x, self.v1.y % self.v2.y, self.v1.z % self.v2.z)) | |
| 1388 self.assertEqual(self.v1.elementwise() > self.v2, self.v1.x > self.v2.x and self.v1.y > self.v2.y and self.v1.z > self.v2.z) | |
| 1389 self.assertEqual(self.v1.elementwise() < self.v2, self.v1.x < self.v2.x and self.v1.y < self.v2.y and self.v1.z < self.v2.z) | |
| 1390 self.assertEqual(self.v1.elementwise() >= self.v2, self.v1.x >= self.v2.x and self.v1.y >= self.v2.y and self.v1.z >= self.v2.z) | |
| 1391 self.assertEqual(self.v1.elementwise() <= self.v2, self.v1.x <= self.v2.x and self.v1.y <= self.v2.y and self.v1.z <= self.v2.z) | |
| 1392 self.assertEqual(self.v1.elementwise() == self.v2, self.v1.x == self.v2.x and self.v1.y == self.v2.y and self.v1.z == self.v2.z) | |
| 1393 self.assertEqual(self.v1.elementwise() != self.v2, self.v1.x != self.v2.x and self.v1.y != self.v2.y and self.v1.z != self.v2.z) | |
| 1394 # behaviour for "vector op elementwise" | |
| 1395 self.assertEqual(self.v2 + self.v1.elementwise(), self.v2 + self.v1) | |
| 1396 self.assertEqual(self.v2 - self.v1.elementwise(), self.v2 - self.v1) | |
| 1397 self.assertEqual(self.v2 * self.v1.elementwise(), (self.v2.x * self.v1.x, self.v2.y * self.v1.y, self.v2.z * self.v1.z)) | |
| 1398 self.assertEqual(self.v2 / self.v1.elementwise(), (self.v2.x / self.v1.x, self.v2.y / self.v1.y, self.v2.z / self.v1.z)) | |
| 1399 self.assertEqual(self.v2 // self.v1.elementwise(), (self.v2.x // self.v1.x, self.v2.y // self.v1.y, self.v2.z // self.v1.z)) | |
| 1400 self.assertEqual(self.v2 ** self.v1.elementwise(), (self.v2.x ** self.v1.x, self.v2.y ** self.v1.y, self.v2.z ** self.v1.z)) | |
| 1401 self.assertEqual(self.v2 % self.v1.elementwise(), (self.v2.x % self.v1.x, self.v2.y % self.v1.y, self.v2.z % self.v1.z)) | |
| 1402 self.assertEqual(self.v2 < self.v1.elementwise(), self.v2.x < self.v1.x and self.v2.y < self.v1.y and self.v2.z < self.v1.z) | |
| 1403 self.assertEqual(self.v2 > self.v1.elementwise(), self.v2.x > self.v1.x and self.v2.y > self.v1.y and self.v2.z > self.v1.z) | |
| 1404 self.assertEqual(self.v2 <= self.v1.elementwise(), self.v2.x <= self.v1.x and self.v2.y <= self.v1.y and self.v2.z <= self.v1.z) | |
| 1405 self.assertEqual(self.v2 >= self.v1.elementwise(), self.v2.x >= self.v1.x and self.v2.y >= self.v1.y and self.v2.z >= self.v1.z) | |
| 1406 self.assertEqual(self.v2 == self.v1.elementwise(), self.v2.x == self.v1.x and self.v2.y == self.v1.y and self.v2.z == self.v1.z) | |
| 1407 self.assertEqual(self.v2 != self.v1.elementwise(), self.v2.x != self.v1.x and self.v2.y != self.v1.y and self.v2.z != self.v1.z) | |
| 1408 | |
| 1409 # behaviour for "elementwise op elementwise" | |
| 1410 self.assertEqual(self.v2.elementwise() + self.v1.elementwise(), self.v2 + self.v1) | |
| 1411 self.assertEqual(self.v2.elementwise() - self.v1.elementwise(), self.v2 - self.v1) | |
| 1412 self.assertEqual(self.v2.elementwise() * self.v1.elementwise(), | |
| 1413 (self.v2.x * self.v1.x, self.v2.y * self.v1.y, self.v2.z * self.v1.z)) | |
| 1414 self.assertEqual(self.v2.elementwise() / self.v1.elementwise(), | |
| 1415 (self.v2.x / self.v1.x, self.v2.y / self.v1.y, self.v2.z / self.v1.z)) | |
| 1416 self.assertEqual(self.v2.elementwise() // self.v1.elementwise(), | |
| 1417 (self.v2.x // self.v1.x, self.v2.y // self.v1.y, self.v2.z // self.v1.z)) | |
| 1418 self.assertEqual(self.v2.elementwise() ** self.v1.elementwise(), | |
| 1419 (self.v2.x ** self.v1.x, self.v2.y ** self.v1.y, self.v2.z ** self.v1.z)) | |
| 1420 self.assertEqual(self.v2.elementwise() % self.v1.elementwise(), | |
| 1421 (self.v2.x % self.v1.x, self.v2.y % self.v1.y, self.v2.z % self.v1.z)) | |
| 1422 self.assertEqual(self.v2.elementwise() < self.v1.elementwise(), | |
| 1423 self.v2.x < self.v1.x and self.v2.y < self.v1.y and self.v2.z < self.v1.z) | |
| 1424 self.assertEqual(self.v2.elementwise() > self.v1.elementwise(), | |
| 1425 self.v2.x > self.v1.x and self.v2.y > self.v1.y and self.v2.z > self.v1.z) | |
| 1426 self.assertEqual(self.v2.elementwise() <= self.v1.elementwise(), | |
| 1427 self.v2.x <= self.v1.x and self.v2.y <= self.v1.y and self.v2.z <= self.v1.z) | |
| 1428 self.assertEqual(self.v2.elementwise() >= self.v1.elementwise(), | |
| 1429 self.v2.x >= self.v1.x and self.v2.y >= self.v1.y and self.v2.z >= self.v1.z) | |
| 1430 self.assertEqual(self.v2.elementwise() == self.v1.elementwise(), | |
| 1431 self.v2.x == self.v1.x and self.v2.y == self.v1.y and self.v2.z == self.v1.z) | |
| 1432 self.assertEqual(self.v2.elementwise() != self.v1.elementwise(), | |
| 1433 self.v2.x != self.v1.x and self.v2.y != self.v1.y and self.v2.z != self.v1.z) | |
| 1434 | |
| 1435 # other behaviour | |
| 1436 self.assertEqual(abs(self.v1.elementwise()), (abs(self.v1.x), abs(self.v1.y), abs(self.v1.z))) | |
| 1437 self.assertEqual(-self.v1.elementwise(), -self.v1) | |
| 1438 self.assertEqual(+self.v1.elementwise(), +self.v1) | |
| 1439 self.assertEqual(bool(self.v1.elementwise()), bool(self.v1)) | |
| 1440 self.assertEqual(bool(Vector3().elementwise()), bool(Vector3())) | |
| 1441 self.assertEqual(self.zeroVec.elementwise() ** 0, (1, 1, 1)) | |
| 1442 self.assertRaises(ValueError, lambda : pow(Vector3(-1, 0, 0).elementwise(), 1.2)) | |
| 1443 self.assertRaises(ZeroDivisionError, lambda : self.zeroVec.elementwise() ** -1) | |
| 2024 | 1444 self.assertRaises(ZeroDivisionError, lambda : Vector3(1,1,1).elementwise() / 0) |
| 1445 self.assertRaises(ZeroDivisionError, lambda : Vector3(1,1,1).elementwise() // 0) | |
| 1446 self.assertRaises(ZeroDivisionError, lambda : Vector3(1,1,1).elementwise() % 0) | |
| 1447 self.assertRaises(ZeroDivisionError, lambda : Vector3(1,1,1).elementwise() / self.zeroVec) | |
| 1448 self.assertRaises(ZeroDivisionError, lambda : Vector3(1,1,1).elementwise() // self.zeroVec) | |
| 1449 self.assertRaises(ZeroDivisionError, lambda : Vector3(1,1,1).elementwise() % self.zeroVec) | |
| 1450 self.assertRaises(ZeroDivisionError, lambda : 2 / self.zeroVec.elementwise()) | |
| 1451 self.assertRaises(ZeroDivisionError, lambda : 2 // self.zeroVec.elementwise()) | |
| 1452 self.assertRaises(ZeroDivisionError, lambda : 2 % self.zeroVec.elementwise()) | |
| 1453 | |
| 1454 | |
| 1994 | 1455 def test_slerp(self): |
|
2035
28685c84e251
as/from_polar/spherical now also use degrees instead of radians
lorenz
parents:
2024
diff
changeset
|
1456 self.assertRaises(ValueError, lambda : self.zeroVec.slerp(self.v1, .5)) |
|
28685c84e251
as/from_polar/spherical now also use degrees instead of radians
lorenz
parents:
2024
diff
changeset
|
1457 self.assertRaises(ValueError, lambda : self.v1.slerp(self.zeroVec, .5)) |
|
28685c84e251
as/from_polar/spherical now also use degrees instead of radians
lorenz
parents:
2024
diff
changeset
|
1458 self.assertRaises(ValueError, |
|
2006
6a532cb218dd
removed iterator versions of vector.slerp() and .lerp() in favour of a parametrized version.
lorenz
parents:
1997
diff
changeset
|
1459 lambda : self.zeroVec.slerp(self.zeroVec, .5)) |
|
6a532cb218dd
removed iterator versions of vector.slerp() and .lerp() in favour of a parametrized version.
lorenz
parents:
1997
diff
changeset
|
1460 steps = 10 |
| 1994 | 1461 angle_step = self.e1.angle_to(self.e2) / steps |
|
2007
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
1462 for i, u in ((i, self.e1.slerp(self.e2, i/float(steps))) for i in range(steps+1)): |
| 1994 | 1463 self.assertAlmostEqual(u.length(), 1) |
|
2006
6a532cb218dd
removed iterator versions of vector.slerp() and .lerp() in favour of a parametrized version.
lorenz
parents:
1997
diff
changeset
|
1464 self.assertAlmostEqual(self.e1.angle_to(u), i * angle_step) |
| 1994 | 1465 self.assertEqual(u, self.e2) |
| 1466 | |
| 1467 v1 = Vector3(100, 0, 0) | |
| 1468 v2 = Vector3(0, 10, 7) | |
| 1469 radial_factor = v2.length() / v1.length() | |
|
2007
07d8a41f1593
reimplemented Vector2(Vector2().__repr__()) to support unicode (and thus Py3)
lorenz
parents:
2006
diff
changeset
|
1470 for i, u in ((i, v1.slerp(v2, -i/float(steps))) for i in range(steps+1)): |
|
2006
6a532cb218dd
removed iterator versions of vector.slerp() and .lerp() in favour of a parametrized version.
lorenz
parents:
1997
diff
changeset
|
1471 self.assertAlmostEqual(u.length(), (v2.length() - v1.length()) * (float(i)/steps) + v1.length()) |
| 1994 | 1472 self.assertEqual(u, v2) |
| 2024 | 1473 self.assertEqual(v1.slerp(v1, .5), v1) |
| 1474 self.assertEqual(v2.slerp(v2, .5), v2) | |
| 1475 self.assertRaises(ValueError, lambda : v1.slerp(-v1, 0.5)) | |
| 1994 | 1476 |
|
2006
6a532cb218dd
removed iterator versions of vector.slerp() and .lerp() in favour of a parametrized version.
lorenz
parents:
1997
diff
changeset
|
1477 def test_lerp(self): |
|
6a532cb218dd
removed iterator versions of vector.slerp() and .lerp() in favour of a parametrized version.
lorenz
parents:
1997
diff
changeset
|
1478 """TODO""" |
|
6a532cb218dd
removed iterator versions of vector.slerp() and .lerp() in favour of a parametrized version.
lorenz
parents:
1997
diff
changeset
|
1479 pass |
|
6a532cb218dd
removed iterator versions of vector.slerp() and .lerp() in favour of a parametrized version.
lorenz
parents:
1997
diff
changeset
|
1480 |
| 1994 | 1481 def test_spherical(self): |
| 1482 v = Vector3() | |
| 1483 v.from_spherical(self.v1.as_spherical()) | |
| 1484 self.assertEqual(self.v1, v) | |
|
2035
28685c84e251
as/from_polar/spherical now also use degrees instead of radians
lorenz
parents:
2024
diff
changeset
|
1485 self.assertEqual(self.e1.as_spherical(), (1, 90, 0)) |
|
28685c84e251
as/from_polar/spherical now also use degrees instead of radians
lorenz
parents:
2024
diff
changeset
|
1486 self.assertEqual(self.e2.as_spherical(), (1, 90, 90)) |
| 1994 | 1487 self.assertEqual(self.e3.as_spherical(), (1, 0, 0)) |
|
2035
28685c84e251
as/from_polar/spherical now also use degrees instead of radians
lorenz
parents:
2024
diff
changeset
|
1488 self.assertEqual((2 * self.e2).as_spherical(), (2, 90, 90)) |
| 1994 | 1489 self.assertRaises(TypeError, lambda : v.from_spherical((None, None, None))) |
| 1490 self.assertRaises(TypeError, lambda : v.from_spherical("abc")) | |
| 1491 self.assertRaises(TypeError, lambda : v.from_spherical((None, 1, 2))) | |
| 1492 self.assertRaises(TypeError, lambda : v.from_spherical((1, 2, 3, 4))) | |
| 1493 self.assertRaises(TypeError, lambda : v.from_spherical((1, 2))) | |
| 1494 self.assertRaises(TypeError, lambda : v.from_spherical(1, 2, 3)) | |
|
2035
28685c84e251
as/from_polar/spherical now also use degrees instead of radians
lorenz
parents:
2024
diff
changeset
|
1495 v.from_spherical((.5, 90, 90)) |
| 1994 | 1496 self.assertEqual(v, .5 * self.e2) |
| 1497 | |
| 1498 | |
| 1499 | |
| 1500 | |
| 1501 | |
| 1502 | |
| 1503 if __name__ == '__main__': | |
| 1504 unittest.main() |