test_linear_algebra.py

"""
Created on Mon Feb 26 15:40:07 2018

@author: Christian Bender
@license: MIT-license

This file contains the test-suite for the linear algebra library.
"""

importunittest

importpytest

from .libimport (
Matrix,
Vector,
axpy,
square_zero_matrix,
unit_basis_vector,
zero_vector,
)


classTest(unittest.TestCase):
deftest_component(self) ->None:
"""
 test for method component()
 """
x=Vector([1, 2, 3])
assertx.component(0) ==1
assertx.component(2) ==3
_=Vector()

deftest_str(self) ->None:
"""
 test for method toString()
 """
x=Vector([0, 0, 0, 0, 0, 1])
assertstr(x) =="(0,0,0,0,0,1)"

deftest_size(self) ->None:
"""
 test for method size()
 """
x=Vector([1, 2, 3, 4])
assertlen(x) ==4

deftest_euclidean_length(self) ->None:
"""
 test for method euclidean_length()
 """
x=Vector([1, 2])
y=Vector([1, 2, 3, 4, 5])
z=Vector([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
w=Vector([1, -1, 1, -1, 2, -3, 4, -5])
assertx.euclidean_length() ==pytest.approx(2.236, abs=1e-3)
asserty.euclidean_length() ==pytest.approx(7.416, abs=1e-3)
assertz.euclidean_length() ==0
assertw.euclidean_length() ==pytest.approx(7.616, abs=1e-3)

deftest_add(self) ->None:
"""
 test for + operator
 """
x=Vector([1, 2, 3])
y=Vector([1, 1, 1])
assert (x+y).component(0) ==2
assert (x+y).component(1) ==3
assert (x+y).component(2) ==4

deftest_sub(self) ->None:
"""
 test for - operator
 """
x=Vector([1, 2, 3])
y=Vector([1, 1, 1])
assert (x-y).component(0) ==0
assert (x-y).component(1) ==1
assert (x-y).component(2) ==2

deftest_mul(self) ->None:
"""
 test for * operator
 """
x=Vector([1, 2, 3])
a=Vector([2, -1, 4]) # for test of dot product
b=Vector([1, -2, -1])
assertstr(x*3.0) =="(3.0,6.0,9.0)"
asserta*b==0

deftest_zero_vector(self) ->None:
"""
 test for global function zero_vector()
 """
assertstr(zero_vector(10)).count("0") ==10

deftest_unit_basis_vector(self) ->None:
"""
 test for global function unit_basis_vector()
 """
assertstr(unit_basis_vector(3, 1)) =="(0,1,0)"

deftest_axpy(self) ->None:
"""
 test for global function axpy() (operation)
 """
x=Vector([1, 2, 3])
y=Vector([1, 0, 1])
assertstr(axpy(2, x, y)) =="(3,4,7)"

deftest_copy(self) ->None:
"""
 test for method copy()
 """
x=Vector([1, 0, 0, 0, 0, 0])
y=x.copy()
assertstr(x) ==str(y)

deftest_change_component(self) ->None:
"""
 test for method change_component()
 """
x=Vector([1, 0, 0])
x.change_component(0, 0)
x.change_component(1, 1)
assertstr(x) =="(0,1,0)"

deftest_str_matrix(self) ->None:
"""
 test for Matrix method str()
 """
a=Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]], 3, 3)
assertstr(a) =="|1,2,3|\n|2,4,5|\n|6,7,8|\n"

deftest_minor(self) ->None:
"""
 test for Matrix method minor()
 """
a=Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]], 3, 3)
minors= [[-3, -14, -10], [-5, -10, -5], [-2, -1, 0]]
forxinrange(a.height()):
foryinrange(a.width()):
assertminors[x][y] ==a.minor(x, y)

deftest_cofactor(self) ->None:
"""
 test for Matrix method cofactor()
 """
a=Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]], 3, 3)
cofactors= [[-3, 14, -10], [5, -10, 5], [-2, 1, 0]]
forxinrange(a.height()):
foryinrange(a.width()):
assertcofactors[x][y] ==a.cofactor(x, y)

deftest_determinant(self) ->None:
"""
 test for Matrix method determinant()
 """
a=Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]], 3, 3)
asserta.determinant() ==-5

deftest__mul__matrix(self) ->None:
"""
 test for Matrix * operator
 """
a=Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]], 3, 3)
x=Vector([1, 2, 3])
assertstr(a*x) =="(14,32,50)"
assertstr(a*2) =="|2,4,6|\n|8,10,12|\n|14,16,18|\n"

deftest_change_component_matrix(self) ->None:
"""
 test for Matrix method change_component()
 """
a=Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]], 3, 3)
a.change_component(0, 2, 5)
assertstr(a) =="|1,2,5|\n|2,4,5|\n|6,7,8|\n"

deftest_component_matrix(self) ->None:
"""
 test for Matrix method component()
 """
a=Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]], 3, 3)
asserta.component(2, 1) ==7, "0.01"

deftest__add__matrix(self) ->None:
"""
 test for Matrix + operator
 """
a=Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]], 3, 3)
b=Matrix([[1, 2, 7], [2, 4, 5], [6, 7, 10]], 3, 3)
assertstr(a+b) =="|2,4,10|\n|4,8,10|\n|12,14,18|\n"

deftest__sub__matrix(self) ->None:
"""
 test for Matrix - operator
 """
a=Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]], 3, 3)
b=Matrix([[1, 2, 7], [2, 4, 5], [6, 7, 10]], 3, 3)
assertstr(a-b) =="|0,0,-4|\n|0,0,0|\n|0,0,-2|\n"

deftest_square_zero_matrix(self) ->None:
"""
 test for global function square_zero_matrix()
 """
assertstr(square_zero_matrix(5)) == (
"|0,0,0,0,0|\n|0,0,0,0,0|\n|0,0,0,0,0|\n|0,0,0,0,0|\n|0,0,0,0,0|\n"
 )


if__name__=="__main__":
unittest.main()