398 lines
12 KiB
Python
398 lines
12 KiB
Python
"""Test of mathematics module.
|
|
|
|
:Date: 2019-12-20
|
|
|
|
.. module:: test_mathematics
|
|
:platform: *nix, Windows
|
|
:synopsis: Test of mathematics module.
|
|
|
|
.. moduleauthor:: Daniel Weschke <daniel.weschke@directbox.de>
|
|
"""
|
|
import unittest
|
|
|
|
import os
|
|
import sys
|
|
sys.path.insert(0, os.path.abspath('../pylib'))
|
|
|
|
import math
|
|
from mathematics import vector, matrix
|
|
|
|
class TestGeometry(unittest.TestCase):
|
|
|
|
#
|
|
# vector
|
|
# NOTE: vector: scalar != 1 element vector
|
|
#
|
|
|
|
def test_vector(self):
|
|
self.assertEqual(
|
|
vector(),
|
|
[])
|
|
self.assertEqual(
|
|
vector([1, 0, 0, 1]),
|
|
[1, 0, 0, 1])
|
|
|
|
def test_vector_mul_vs(self):
|
|
self.assertEqual(
|
|
vector([1, 2, 3]) * 4,
|
|
[4, 8, 12])
|
|
self.assertEqual(
|
|
vector([-1, -2, -3]) * 4,
|
|
[-4, -8, -12])
|
|
self.assertEqual(
|
|
vector([1, 2, 3]) * -4,
|
|
[-4, -8, -12])
|
|
self.assertEqual(
|
|
vector([-1, -2, -3]) * -4,
|
|
[4, 8, 12])
|
|
|
|
def test_vector_mul_vv(self):
|
|
self.assertEqual(
|
|
vector([1, 2, 3]) * vector([1, 2, 3]),
|
|
14)
|
|
self.assertEqual(
|
|
vector([-1, -2, -3]) * vector([1, 2, 3]),
|
|
-14)
|
|
self.assertEqual(
|
|
vector([1, 2, 3]) * vector([-1, -2, -3]),
|
|
-14)
|
|
self.assertEqual(
|
|
vector([-1, -2, -3]) * vector([-1, -2, -3]),
|
|
14)
|
|
|
|
def test_vector_mul_vm(self):
|
|
r"""
|
|
.. math::
|
|
&
|
|
\begin{bmatrix}
|
|
1 & 2 & 3
|
|
\end{bmatrix}
|
|
\cdot
|
|
\begin{bmatrix}
|
|
1 & 2 & 3 \\
|
|
4 & 5 & 6 \\
|
|
7 & 8 & 9
|
|
\end{bmatrix}
|
|
\\
|
|
=&
|
|
\begin{bmatrix}
|
|
1+8+21 & 2+10+24 & 3+12+27
|
|
\end{bmatrix}
|
|
\\
|
|
=&
|
|
\begin{bmatrix}
|
|
30 & 36 & 42
|
|
\end{bmatrix}
|
|
"""
|
|
self.assertEqual(
|
|
vector([1, 2, 3]) * matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]),
|
|
[30, 36, 42])
|
|
self.assertEqual(
|
|
vector([-1, -2, -3]) * matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]),
|
|
[-30, -36, -42])
|
|
self.assertEqual(
|
|
vector([1, 2, 3]) * matrix([[-1, -2, -3], [-4, -5, -6], [-7, -8, -9]]),
|
|
[-30, -36, -42])
|
|
self.assertEqual(
|
|
vector([-1, -2, -3]) * matrix([[-1, -2, -3], [-4, -5, -6], [-7, -8, -9]]),
|
|
[30, 36, 42])
|
|
|
|
def test_vector_rmul_sv(self):
|
|
self.assertEqual(
|
|
4 * vector([1, 2, 3]),
|
|
[4, 8, 12])
|
|
self.assertEqual(
|
|
-4 * vector([1, 2, 3]),
|
|
[-4, -8, -12])
|
|
self.assertEqual(
|
|
4 * vector([-1, -2, -3]),
|
|
[-4, -8, -12])
|
|
self.assertEqual(
|
|
-4 * vector([-1, -2, -3]),
|
|
[4, 8, 12])
|
|
|
|
def test_vector_rmul_mv(self):
|
|
# 2d list * vector, matrix * vector see matrix.__mul__
|
|
self.assertEqual(
|
|
[[1, 2, 3], [4, 5, 6], [7, 8, 9]] * vector([1, 2, 3]),
|
|
[14, 32, 50])
|
|
self.assertEqual(
|
|
[[-1, -2, -3], [-4, -5, -6], [-7, -8, -9]] * vector([1, 2, 3]),
|
|
[-14, -32, -50])
|
|
self.assertEqual(
|
|
[[1, 2, 3], [4, 5, 6], [7, 8, 9]] * vector([-1, -2, -3]),
|
|
[-14, -32, -50])
|
|
self.assertEqual(
|
|
[[-1, -2, -3], [-4, -5, -6], [-7, -8, -9]] * vector([-1, -2, -3]),
|
|
[14, 32, 50])
|
|
|
|
def test_vector_abs(self):
|
|
self.assertEqual(
|
|
abs(vector([0.6, 0.8])),
|
|
1)
|
|
self.assertEqual(
|
|
abs(vector([3, 4])),
|
|
5)
|
|
|
|
def test_vector_full(self):
|
|
self.assertEqual(
|
|
vector.full(3, 7),
|
|
[7, 7, 7])
|
|
|
|
def test_vector_zeros(self):
|
|
self.assertEqual(
|
|
vector.zeros(3),
|
|
[0, 0, 0])
|
|
self.assertEqual(
|
|
vector.zeros((3)),
|
|
[0, 0, 0])
|
|
self.assertEqual(
|
|
vector.zeros(-1),
|
|
[])
|
|
|
|
def test_vector_ones(self):
|
|
self.assertEqual(
|
|
vector.ones(3),
|
|
[1, 1, 1])
|
|
self.assertEqual(
|
|
vector.ones((3)),
|
|
[1, 1, 1])
|
|
self.assertEqual(
|
|
vector.ones(-1),
|
|
[])
|
|
|
|
def test_vector_random(self):
|
|
obj = vector.random(3)
|
|
self.assertEqual(
|
|
len(obj),
|
|
3)
|
|
|
|
def test_vector_normalize(self):
|
|
v = vector.normalize(vector([3, 4]))
|
|
self.assertEqual(
|
|
v,
|
|
[0.6, 0.8])
|
|
self.assertEqual(
|
|
abs(v),
|
|
1)
|
|
|
|
def test_vector_rotate_x(self):
|
|
# rotation of vector coordinate system about x axis
|
|
|
|
# vector points to x -> vector points to x still
|
|
self.assertEqual( vector([1, 0, 0, 1]).rotate_x(math.pi/2), [1, 0, 0, 1])
|
|
# vector points to y -> vector points to -z
|
|
[self.assertAlmostEqual(i, j) for i, j in zip(vector([0, 1, 0, 1]).rotate_x(math.pi/2), [0, 0, 1, 1])]
|
|
# vector points to z -> vector points to y
|
|
[self.assertAlmostEqual(i, j) for i, j in zip(vector([0, 0, 1, 1]).rotate_x(math.pi/2), [0, -1, 0, 1])]
|
|
|
|
def test_vector_rotate_y(self):
|
|
# rotation of vector coordinate system about y axis
|
|
|
|
# vector points to x ->, vector points to z
|
|
[self.assertAlmostEqual(i, j) for i, j in zip(vector([1, 0, 0, 1]).rotate_y(math.pi/2), [0, 0, -1, 1])]
|
|
# vector points to y -> vector points to y still
|
|
self.assertEqual( vector([0, 1, 0, 1]).rotate_y(math.pi/2), [0, 1, 0, 1])
|
|
# vector points to z -> vector points to -x
|
|
[self.assertAlmostEqual(i, j) for i, j in zip(vector([0, 0, 1, 1]).rotate_y(math.pi/2), [1, 0, 0, 1])]
|
|
|
|
def test_vector_rotate_z(self):
|
|
# rotation of vector coordinate system about z axis
|
|
|
|
# vector points to x ->, vector points to z
|
|
[self.assertAlmostEqual(i, j) for i, j in zip(vector([1, 0, 0, 1]).rotate_z(math.pi/2), [0, 1, 0, 1])]
|
|
# vector points to y -> vector points to
|
|
[self.assertAlmostEqual(i, j) for i, j in zip(vector([0, 1, 0, 1]).rotate_z(math.pi/2), [-1, 0, 0, 1])]
|
|
# vector points to z -> vector points to z still
|
|
self.assertEqual( vector([0, 0, 1, 1]).rotate_z(math.pi/2), [0, 0, 1, 1])
|
|
|
|
#
|
|
# matrix
|
|
# NOTE: matrix: scalar != 1x1 matrix
|
|
#
|
|
|
|
def test_matrix_mul_ms(self):
|
|
self.assertEqual(
|
|
matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) * 4,
|
|
[[4, 8, 12], [16, 20, 24], [28, 32, 36]])
|
|
self.assertEqual(
|
|
matrix([[-1, -2, -3], [-4, -5, -6], [-7, -8, -9]]) * 4,
|
|
[[-4, -8, -12], [-16, -20, -24], [-28, -32, -36]])
|
|
self.assertEqual(
|
|
matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) * -4,
|
|
[[-4, -8, -12], [-16, -20, -24], [-28, -32, -36]])
|
|
self.assertEqual(
|
|
matrix([[-1, -2, -3], [-4, -5, -6], [-7, -8, -9]]) * -4,
|
|
[[4, 8, 12], [16, 20, 24], [28, 32, 36]])
|
|
|
|
def test_matrix_mul_mv(self):
|
|
r"""
|
|
.. math::
|
|
\begin{bmatrix}
|
|
1 & 2 & 3 \\
|
|
4 & 5 & 6 \\
|
|
7 & 8 & 9
|
|
\end{bmatrix}
|
|
\cdot
|
|
\begin{bmatrix}
|
|
1 \\
|
|
2 \\
|
|
3
|
|
\end{bmatrix}
|
|
=
|
|
\begin{bmatrix}
|
|
1+4+9 \\
|
|
4+10+18 \\
|
|
7+16+27
|
|
\end{bmatrix}
|
|
=
|
|
\begin{bmatrix}
|
|
14 \\
|
|
32 \\
|
|
50
|
|
\end{bmatrix}
|
|
"""
|
|
self.assertEqual(
|
|
matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) * vector([1, 2, 3]),
|
|
[14, 32, 50])
|
|
self.assertEqual(
|
|
matrix([[-1, -2, -3], [-4, -5, -6], [-7, -8, -9]]) * vector([1, 2, 3]),
|
|
[-14, -32, -50])
|
|
self.assertEqual(
|
|
matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) * vector([-1, -2, -3]),
|
|
[-14, -32, -50])
|
|
self.assertEqual(
|
|
matrix([[-1, -2, -3], [-4, -5, -6], [-7, -8, -9]]) * vector([-1, -2, -3]),
|
|
[14, 32, 50])
|
|
|
|
self.assertEqual(
|
|
matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) * matrix([[1], [2], [3]]),
|
|
[[14], [32], [50]])
|
|
self.assertEqual(
|
|
matrix([[-1, -2, -3], [-4, -5, -6], [-7, -8, -9]]) * matrix([[1], [2], [3]]),
|
|
[[-14], [-32], [-50]])
|
|
self.assertEqual(
|
|
matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) * matrix([[-1], [-2], [-3]]),
|
|
[[-14], [-32], [-50]])
|
|
self.assertEqual(
|
|
matrix([[-1, -2, -3], [-4, -5, -6], [-7, -8, -9]]) * matrix([[-1], [-2], [-3]]),
|
|
[[14], [32], [50]])
|
|
|
|
def test_matrix_mul_vm(self):
|
|
# matrix-vector * matrix, vector * matrix see vector.__mul__
|
|
self.assertEqual(
|
|
matrix([[1, 2, 3]]) * matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]),
|
|
[[30, 36, 42]])
|
|
self.assertEqual(
|
|
matrix([[-1, -2, -3]]) * matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]),
|
|
[[-30, -36, -42]])
|
|
self.assertEqual(
|
|
matrix([[1, 2, 3]]) * matrix([[-1, -2, -3], [-4, -5, -6], [-7, -8, -9]]),
|
|
[[-30, -36, -42]])
|
|
self.assertEqual(
|
|
matrix([[-1, -2, -3]]) * matrix([[-1, -2, -3], [-4, -5, -6], [-7, -8, -9]]),
|
|
[[30, 36, 42]])
|
|
|
|
def test_matrix_mul_mm(self):
|
|
r"""
|
|
.. math::
|
|
&
|
|
\begin{bmatrix}
|
|
1 & 2 & 3 \\
|
|
4 & 5 & 6 \\
|
|
7 & 8 & 9
|
|
\end{bmatrix}
|
|
\cdot
|
|
\begin{bmatrix}
|
|
11 & 12 & 13 \\
|
|
14 & 15 & 16 \\
|
|
17 & 18 & 19
|
|
\end{bmatrix}
|
|
\\
|
|
=&
|
|
\begin{bmatrix}
|
|
11+28+51 & 12+30+54 & 13+32+57 \\
|
|
44+70+102 & 48+75+108 & 52+80+114 \\
|
|
77+112+153 & 84+120+162 & 91+128+171
|
|
\end{bmatrix}
|
|
\\
|
|
=&
|
|
\begin{bmatrix}
|
|
90 & 96 & 102 \\
|
|
216 & 231 & 246 \\
|
|
342 & 366 & 390
|
|
\end{bmatrix}
|
|
|
|
interesting
|
|
|
|
.. math::
|
|
90 \xrightarrow{+6} 96 \xrightarrow{+6} 102 \quad &\Big| \sum\{1, 2, 3\} = 6 \\
|
|
216 \xrightarrow{+15} 231 \xrightarrow{+15} 246 \quad &\Big| \sum\{4, 5, 6\} = 15 \\
|
|
342 \xrightarrow{+24} 366 \xrightarrow{+24} 390 \quad &\Big| \sum\{7, 8, 9\} = 24
|
|
|
|
.. math::
|
|
90 \xrightarrow{+126} 216 \xrightarrow{+126} 342 \quad &\Big| \sum\{11, 14, 17\} = 42 = 126/3 \\
|
|
96 \xrightarrow{+135} 231 \xrightarrow{+135} 366 \quad &\Big| \sum\{12, 15, 18\} = 45 = 135/3 \\
|
|
102 \xrightarrow{+144} 246 \xrightarrow{+144} 390 \quad &\Big| \sum\{13, 16, 19\} = 48 = 144/3
|
|
"""
|
|
self.assertEqual(
|
|
matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) * matrix([[11, 12, 13], [14, 15, 16], [17, 18, 19]]),
|
|
[[90, 96, 102], [216, 231, 246], [342, 366, 390]])
|
|
self.assertEqual(
|
|
matrix([[-1, -2, -3], [-4, -5, -6], [-7, -8, -9]]) * matrix([[11, 12, 13], [14, 15, 16], [17, 18, 19]]),
|
|
[[-90, -96, -102], [-216, -231, -246], [-342, -366, -390]])
|
|
self.assertEqual(
|
|
matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) * matrix([[-11, -12, -13], [-14, -15, -16], [-17, -18, -19]]),
|
|
[[-90, -96, -102], [-216, -231, -246], [-342, -366, -390]])
|
|
self.assertEqual(
|
|
matrix([[-1, -2, -3], [-4, -5, -6], [-7, -8, -9]]) * matrix([[-11, -12, -13], [-14, -15, -16], [-17, -18, -19]]),
|
|
[[90, 96, 102], [216, 231, 246], [342, 366, 390]])
|
|
|
|
def test_matrix_rmul_sm(self):
|
|
self.assertEqual(
|
|
4 * matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]),
|
|
[[4, 8, 12], [16, 20, 24], [28, 32, 36]])
|
|
self.assertEqual(
|
|
-4 * matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]),
|
|
[[-4, -8, -12], [-16, -20, -24], [-28, -32, -36]])
|
|
self.assertEqual(
|
|
4 * matrix([[-1, -2, -3], [-4, -5, -6], [-7, -8, -9]]),
|
|
[[-4, -8, -12], [-16, -20, -24], [-28, -32, -36]])
|
|
self.assertEqual(
|
|
-4 * matrix([[-1, -2, -3], [-4, -5, -6], [-7, -8, -9]]),
|
|
[[4, 8, 12], [16, 20, 24], [28, 32, 36]])
|
|
|
|
def test_matrix_rmul_vm(self):
|
|
# 1d list * matrix, vector * matrix see vector.__mul__
|
|
self.assertEqual(
|
|
[1, 2, 3] * matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]),
|
|
[30, 36, 42])
|
|
self.assertEqual(
|
|
[-1, -2, -3] * matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]),
|
|
[-30, -36, -42])
|
|
self.assertEqual(
|
|
[1, 2, 3] * matrix([[-1, -2, -3], [-4, -5, -6], [-7, -8, -9]]),
|
|
[-30, -36, -42])
|
|
self.assertEqual(
|
|
[-1, -2, -3] * matrix([[-1, -2, -3], [-4, -5, -6], [-7, -8, -9]]),
|
|
[30, 36, 42])
|
|
|
|
def test_matrix_rmul_mm(self):
|
|
# 2d list * matrix, matrix * matrix see matrix.__mul__
|
|
self.assertEqual(
|
|
[[1, 2, 3], [4, 5, 6], [7, 8, 9]] * matrix([[11, 12, 13], [14, 15, 16], [17, 18, 19]]),
|
|
[[90, 96, 102], [216, 231, 246], [342, 366, 390]])
|
|
self.assertEqual(
|
|
[[-1, -2, -3], [-4, -5, -6], [-7, -8, -9]] * matrix([[11, 12, 13], [14, 15, 16], [17, 18, 19]]),
|
|
[[-90, -96, -102], [-216, -231, -246], [-342, -366, -390]])
|
|
self.assertEqual(
|
|
[[1, 2, 3], [4, 5, 6], [7, 8, 9]] * matrix([[-11, -12, -13], [-14, -15, -16], [-17, -18, -19]]),
|
|
[[-90, -96, -102], [-216, -231, -246], [-342, -366, -390]])
|
|
self.assertEqual(
|
|
[[-1, -2, -3], [-4, -5, -6], [-7, -8, -9]] * matrix([[-11, -12, -13], [-14, -15, -16], [-17, -18, -19]]),
|
|
[[90, 96, 102], [216, 231, 246], [342, 366, 390]])
|
|
|
|
|
|
if __name__ == '__main__':
|
|
unittest.main(verbosity=2)
|