File: test_vector.py

package info (click to toggle)
pyrr 0.10.3-5
  • links: PTS, VCS
  • area: main
  • in suites: bookworm
  • size: 956 kB
  • sloc: python: 5,865; makefile: 132; sh: 23
file content (126 lines) | stat: -rw-r--r-- 3,847 bytes parent folder | download
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
try:
    import unittest2 as unittest
except:
    import unittest
import numpy as np
from pyrr import vector, vector3, vector4


class test_vector(unittest.TestCase):
    def test_import(self):
        import pyrr
        pyrr.vector
        from pyrr import vector

    def test_normalize_single_vector(self):
        result = vector3.normalize([1.,1.,1.])
        np.testing.assert_almost_equal(result, [0.57735, 0.57735, 0.57735], decimal=5)

    def test_normalize_batch(self):
        result = vector3.normalize([
            [1.,1.,1.],
            [-1.,-1.,-1.],
            [0.,2.,7.],
        ])
        expected = [
            [0.57735, 0.57735, 0.57735],
            [-0.57735,-0.57735,-0.57735],
            [0., 0.274721, 0.961524],
        ]
        np.testing.assert_almost_equal(result, expected, decimal=5)

    def test_squared_length_single_vector(self):
        result = vector3.squared_length([1.,1.,1.])
        np.testing.assert_almost_equal(result, 3., decimal=5)

    def test_squared_length_batch(self):
        result = vector3.squared_length([
            [1.,1.,1.],
            [-1.,-1.,-1.],
            [0.,2.,7.],
        ])
        expected = [
            3.,
            3.,
            53.,
        ]
        np.testing.assert_almost_equal(result, expected, decimal=5)

    def test_length_vector3(self):
        result = vector3.length([1.,1.,1.])
        np.testing.assert_almost_equal(result, 1.73205, decimal=5)

    def test_length_vector4(self):
        result = vector3.length([1.,1.,1.,1.])
        np.testing.assert_almost_equal(result, 2., decimal=5)

    def test_length_vector3_batch(self):
        result = vector3.length([
            [1.,1.,1.],
            [-1.,-1.,-1.],
            [0.,2.,7.],
        ])
        expected = [
            1.73205,
            1.73205,
            7.28011,
        ]
        np.testing.assert_almost_equal(result, expected, decimal=5)

    def test_set_length_vector3(self):
        result = vector3.set_length([1.,1.,1.],2.)
        expected = [1.15470,1.15470,1.15470]
        np.testing.assert_almost_equal(result, expected, decimal=5)

    def test_set_length_vector4(self):
        result = vector4.set_length([1.,1.,1.,1.],2.)
        expected = [1.,1.,1.,1.]
        np.testing.assert_almost_equal(result, expected, decimal=5)

    def test_set_length_batch_vector(self):
        result = vector3.set_length([
            [1.,1.,1.],
            [-1.,-1.,-1.],
            [0.,2.,7.],
            ], 2.0)
        expected = [
            [1.15470,1.15470,1.15470],
            [-1.15470,-1.15470,-1.15470],
            [0.,0.54944,1.92304],
        ]
        np.testing.assert_almost_equal(result, expected, decimal=5)

    def test_dot_adjacent(self):
        result = vector3.dot([1.,0.,0.], [0.,1.,0.])
        np.testing.assert_almost_equal(result, 0.0, decimal=5)

    def test_dot_parallel(self):
        result = vector3.dot([0.,1.,0.], [0.,1.,0.])
        np.testing.assert_almost_equal(result, 1.0, decimal=5)

    def test_dot_angle(self):
        result = vector3.dot([.2,.2,0.], [2.,-.2,0.])
        np.testing.assert_almost_equal(result, 0.36, decimal=5)

    def test_dot_batch(self):
        result = vector3.dot([
            [1.,0.,0.],
            [0.,1.,0.],
            [.2,.2,0.]
        ],[
            [0.,1.,0.],
            [0.,1.,0.],
            [2.,-.2,0.]
        ])
        expected = [0.,1.,0.36]
        np.testing.assert_almost_equal(result, expected, decimal=5)

    def test_interoplation(self):
        result = vector3.interpolate([0.,0.,0.], [1.,1.,1.], 0.5)
        np.testing.assert_almost_equal(result, [.5,.5,.5], decimal=5)

        result = vector3.interpolate([0.,0.,0.], [2.,2.,2.], 0.5)
        np.testing.assert_almost_equal(result, [1.,1.,1.], decimal=5)

if __name__ == '__main__':
    unittest.main()