mathdatech/Python
1
0
Fork 0
mirror of https://github.com/TheAlgorithms/Python.git synced 2024-11-23 21:11:08 +00:00
Code Issues Packages Projects Releases Wiki Activity

Rewrite parts of Vector and Matrix (#5362)

Browse Source 
* Rewrite parts of Vector and Matrix methods

* Refactor determinant method and add unit tests

Refactor determinant method to create separate minor and cofactor
methods.
Add respective unit tests for new methods.
Rename methods using snake case to follow Python naming conventions.

* Reorganize Vector and Matrix methods

* Update linear_algebra/README.md

Co-authored-by: John Law <johnlaw.po@gmail.com>

* Fix punctuation and wording

* Apply suggestions from code review

Co-authored-by: John Law <johnlaw.po@gmail.com>

Co-authored-by: John Law <johnlaw.po@gmail.com>
This commit is contained in:
Tianyi Zheng 2021-10-27 03:48:43 +00:00 committed by GitHub
parent 8285913e81
commit fe5c711ce6
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
4 changed files with 292 additions and 222 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
knapsack/README.md
View File

@ -17,7 +17,7 @@ The knapsack problem has been studied for more than a century, with early works
## Documentation
This module uses docstrings to enable the use of Python's in-built `help(...)` function.
For instance, try `help(Vector)`, `help(unitBasisVector)`, and `help(CLASSNAME.METHODNAME)`.
For instance, try `help(Vector)`, `help(unit_basis_vector)`, and `help(CLASSNAME.METHODNAME)`.
---

44
linear_algebra/README.md
View File

@ -10,56 +10,56 @@ This module contains classes and functions for doing linear algebra.
-
- This class represents a vector of arbitrary size and related operations.
**Overview about the methods:**
**Overview of the methods:**
- constructor(components : list) : init the vector
- set(components : list) : changes the vector components.
- constructor(components) : init the vector
- set(components) : changes the vector components.
- \_\_str\_\_() : toString method
- component(i : int): gets the i-th component (start by 0)
- component(i): gets the i-th component (0-indexed)
- \_\_len\_\_() : gets the size / length of the vector (number of components)
- euclidLength() : returns the eulidean length of the vector.
- euclidean_length() : returns the eulidean length of the vector
- operator + : vector addition
- operator - : vector subtraction
- operator * : scalar multiplication and dot product
- copy() : copies this vector and returns it.
- changeComponent(pos,value) : changes the specified component.
- copy() : copies this vector and returns it
- change_component(pos,value) : changes the specified component
- function zeroVector(dimension)
- function zero_vector(dimension)
- returns a zero vector of 'dimension'
- function unitBasisVector(dimension,pos)
- returns a unit basis vector with a One at index 'pos' (indexing at 0)
- function axpy(scalar,vector1,vector2)
- function unit_basis_vector(dimension, pos)
- returns a unit basis vector with a one at index 'pos' (0-indexed)
- function axpy(scalar, vector1, vector2)
- computes the axpy operation
- function randomVector(N,a,b)
- returns a random vector of size N, with random integer components between 'a' and 'b'.
- function random_vector(N, a, b)
- returns a random vector of size N, with random integer components between 'a' and 'b' inclusive
### class Matrix
-
- This class represents a matrix of arbitrary size and operations on it.
**Overview about the methods:**
**Overview of the methods:**
- \_\_str\_\_() : returns a string representation
- operator * : implements the matrix vector multiplication
implements the matrix-scalar multiplication.
- changeComponent(x,y,value) : changes the specified component.
- component(x,y) : returns the specified component.
- change_component(x, y, value) : changes the specified component.
- component(x, y) : returns the specified component.
- width() : returns the width of the matrix
- height() : returns the height of the matrix
- determinate() : returns the determinate of the matrix if it is square
- determinant() : returns the determinant of the matrix if it is square
- operator + : implements the matrix-addition.
- operator - _ implements the matrix-subtraction
- operator - : implements the matrix-subtraction
- function squareZeroMatrix(N)
- function square_zero_matrix(N)
- returns a square zero-matrix of dimension NxN
- function randomMatrix(W,H,a,b)
- returns a random matrix WxH with integer components between 'a' and 'b'
- function random_matrix(W, H, a, b)
- returns a random matrix WxH with integer components between 'a' and 'b' inclusive
---
## Documentation
This module uses docstrings to enable the use of Python's in-built `help(...)` function.
For instance, try `help(Vector)`, `help(unitBasisVector)`, and `help(CLASSNAME.METHODNAME)`.
For instance, try `help(Vector)`, `help(unit_basis_vector)`, and `help(CLASSNAME.METHODNAME)`.
---

372
linear_algebra/src/lib.py
View File

@ -10,13 +10,13 @@ with linear algebra in python.
Overview:
- class Vector
- function zeroVector(dimension)
- function unitBasisVector(dimension,pos)
- function axpy(scalar,vector1,vector2)
- function randomVector(N,a,b)
- function zero_vector(dimension)
- function unit_basis_vector(dimension, pos)
- function axpy(scalar, vector1, vector2)
- function random_vector(N, a, b)
- class Matrix
- function squareZeroMatrix(N)
- function randomMatrix(W,H,a,b)
- function square_zero_matrix(N)
- function random_matrix(W, H, a, b)
"""
from __future__ import annotations
@ -30,20 +30,23 @@ class Vector:
This class represents a vector of arbitrary size.
You need to give the vector components.
Overview about the methods:
Overview of the methods:
constructor(components : list) : init the vector
set(components : list) : changes the vector components.
__str__() : toString method
component(i : int): gets the i-th component (start by 0)
__len__() : gets the size of the vector (number of components)
euclidLength() : returns the euclidean length of the vector.
operator + : vector addition
operator - : vector subtraction
operator * : scalar multiplication and dot product
copy() : copies this vector and returns it.
changeComponent(pos,value) : changes the specified component.
TODO: compare-operator
__init__(components: Collection[float] | None): init the vector
__len__(): gets the size of the vector (number of components)
__str__(): returns a string representation
__add__(other: Vector): vector addition
__sub__(other: Vector): vector subtraction
__mul__(other: float): scalar multiplication
__mul__(other: Vector): dot product
set(components: Collection[float]): changes the vector components
copy(): copies this vector and returns it
component(i): gets the i-th component (0-indexed)
change_component(pos: int, value: float): changes specified component
euclidean_length(): returns the euclidean length of the vector
magnitude(): returns the magnitude of the vector
angle(other: Vector, deg: bool): returns the angle between two vectors
TODO: compare-operator
"""
def __init__(self, components: Collection[float] | None = None) -> None:
@ -55,47 +58,17 @@ class Vector:
components = []
self.__components = list(components)
def set(self, components: Collection[float]) -> None:
"""
input: new components
changes the components of the vector.
replace the components with newer one.
"""
if len(components) > 0:
self.__components = list(components)
else:
raise Exception("please give any vector")
def __str__(self) -> str:
"""
returns a string representation of the vector
"""
return "(" + ",".join(map(str, self.__components)) + ")"
def component(self, i: int) -> float:
"""
input: index (start at 0)
output: the i-th component of the vector.
"""
if type(i) is int and -len(self.__components) <= i < len(self.__components):
return self.__components[i]
else:
raise Exception("index out of range")
def __len__(self) -> int:
"""
returns the size of the vector
"""
return len(self.__components)
def euclidLength(self) -> float:
def __str__(self) -> str:
"""
returns the euclidean length of the vector
returns a string representation of the vector
"""
summe: float = 0
for c in self.__components:
summe += c ** 2
return math.sqrt(summe)
return "(" + ",".join(map(str, self.__components)) + ")"
def __add__(self, other: Vector) -> Vector:
"""
@ -139,15 +112,57 @@ class Vector:
if isinstance(other, float) or isinstance(other, int):
ans = [c * other for c in self.__components]
return Vector(ans)
elif isinstance(other, Vector) and (len(self) == len(other)):
elif isinstance(other, Vector) and len(self) == len(other):
size = len(self)
summe: float = 0
for i in range(size):
summe += self.__components[i] * other.component(i)
return summe
prods = [self.__components[i] * other.component(i) for i in range(size)]
return sum(prods)
else: # error case
raise Exception("invalid operand!")
def set(self, components: Collection[float]) -> None:
"""
input: new components
changes the components of the vector.
replaces the components with newer one.
"""
if len(components) > 0:
self.__components = list(components)
else:
raise Exception("please give any vector")
def copy(self) -> Vector:
"""
copies this vector and returns it.
"""
return Vector(self.__components)
def component(self, i: int) -> float:
"""
input: index (0-indexed)
output: the i-th component of the vector.
"""
if type(i) is int and -len(self.__components) <= i < len(self.__components):
return self.__components[i]
else:
raise Exception("index out of range")
def change_component(self, pos: int, value: float) -> None:
"""
input: an index (pos) and a value
changes the specified component (pos) with the
'value'
"""
# precondition
assert -len(self.__components) <= pos < len(self.__components)
self.__components[pos] = value
def euclidean_length(self) -> float:
"""
returns the euclidean length of the vector
"""
squares = [c ** 2 for c in self.__components]
return math.sqrt(sum(squares))
def magnitude(self) -> float:
"""
Magnitude of a Vector
@ -156,7 +171,8 @@ class Vector:
5.385164807134504
"""
return sum([i ** 2 for i in self.__components]) ** (1 / 2)
squares = [c ** 2 for c in self.__components]
return math.sqrt(sum(squares))
def angle(self, other: Vector, deg: bool = False) -> float:
"""
@ -178,24 +194,8 @@ class Vector:
else:
return math.acos(num / den)
def copy(self) -> Vector:
"""
copies this vector and returns it.
"""
return Vector(self.__components)
def changeComponent(self, pos: int, value: float) -> None:
"""
input: an index (pos) and a value
changes the specified component (pos) with the
'value'
"""
# precondition
assert -len(self.__components) <= pos < len(self.__components)
self.__components[pos] = value
def zeroVector(dimension: int) -> Vector:
def zero_vector(dimension: int) -> Vector:
"""
returns a zero-vector of size 'dimension'
"""
@ -204,7 +204,7 @@ def zeroVector(dimension: int) -> Vector:
return Vector([0] * dimension)
def unitBasisVector(dimension: int, pos: int) -> Vector:
def unit_basis_vector(dimension: int, pos: int) -> Vector:
"""
returns a unit basis vector with a One
at index 'pos' (indexing at 0)
@ -225,13 +225,13 @@ def axpy(scalar: float, x: Vector, y: Vector) -> Vector:
# precondition
assert (
isinstance(x, Vector)
and (isinstance(y, Vector))
and isinstance(y, Vector)
and (isinstance(scalar, int) or isinstance(scalar, float))
)
return x * scalar + y
def randomVector(N: int, a: int, b: int) -> Vector:
def random_vector(n: int, a: int, b: int) -> Vector:
"""
input: size (N) of the vector.
random range (a,b)
@ -239,26 +239,30 @@ def randomVector(N: int, a: int, b: int) -> Vector:
random integer components between 'a' and 'b'.
"""
random.seed(None)
ans = [random.randint(a, b) for _ in range(N)]
ans = [random.randint(a, b) for _ in range(n)]
return Vector(ans)
class Matrix:
"""
class: Matrix
This class represents a arbitrary matrix.
This class represents an arbitrary matrix.
Overview about the methods:
Overview of the methods:
__str__() : returns a string representation
operator * : implements the matrix vector multiplication
implements the matrix-scalar multiplication.
changeComponent(x,y,value) : changes the specified component.
component(x,y) : returns the specified component.
width() : returns the width of the matrix
height() : returns the height of the matrix
operator + : implements the matrix-addition.
operator - _ implements the matrix-subtraction
__init__():
__str__(): returns a string representation
__add__(other: Matrix): matrix addition
__sub__(other: Matrix): matrix subtraction
__mul__(other: float): scalar multiplication
__mul__(other: Vector): vector multiplication
height() : returns height
width() : returns width
component(x: int, y: int): returns specified component
change_component(x: int, y: int, value: float): changes specified component
minor(x: int, y: int): returns minor along (x, y)
cofactor(x: int, y: int): returns cofactor along (x, y)
determinant() : returns determinant
"""
def __init__(self, matrix: list[list[float]], w: int, h: int) -> None:
@ -285,62 +289,37 @@ class Matrix:
ans += str(self.__matrix[i][j]) + "|\n"
return ans
def changeComponent(self, x: int, y: int, value: float) -> None:
def __add__(self, other: Matrix) -> Matrix:
"""
changes the x-y component of this matrix
implements the matrix-addition.
"""
if 0 <= x < self.__height and 0 <= y < self.__width:
self.__matrix[x][y] = value
if self.__width == other.width() and self.__height == other.height():
matrix = []
for i in range(self.__height):
row = [
self.__matrix[i][j] + other.component(i, j)
for j in range(self.__width)
]
matrix.append(row)
return Matrix(matrix, self.__width, self.__height)
else:
raise Exception("changeComponent: indices out of bounds")
raise Exception("matrix must have the same dimension!")
def component(self, x: int, y: int) -> float:
def __sub__(self, other: Matrix) -> Matrix:
"""
returns the specified (x,y) component
implements the matrix-subtraction.
"""
if 0 <= x < self.__height and 0 <= y < self.__width:
return self.__matrix[x][y]
if self.__width == other.width() and self.__height == other.height():
matrix = []
for i in range(self.__height):
row = [
self.__matrix[i][j] - other.component(i, j)
for j in range(self.__width)
]
matrix.append(row)
return Matrix(matrix, self.__width, self.__height)
else:
raise Exception("changeComponent: indices out of bounds")
def width(self) -> int:
"""
getter for the width
"""
return self.__width
def height(self) -> int:
"""
getter for the height
"""
return self.__height
def determinate(self) -> float:
"""
returns the determinate of an nxn matrix using Laplace expansion
"""
if self.__height == self.__width and self.__width >= 2:
total = 0
if self.__width > 2:
for x in range(0, self.__width):
for y in range(0, self.__height):
total += (
self.__matrix[x][y]
* (-1) ** (x + y)
* Matrix(
self.__matrix[0:x] + self.__matrix[x + 1 :],
self.__width - 1,
self.__height - 1,
).determinate()
)
else:
return (
self.__matrix[0][0] * self.__matrix[1][1]
- self.__matrix[0][1] * self.__matrix[1][0]
)
return total
else:
raise Exception("matrix is not square")
raise Exception("matrices must have the same dimension!")
@overload
def __mul__(self, other: float) -> Matrix:
@ -355,20 +334,20 @@ class Matrix:
implements the matrix-vector multiplication.
implements the matrix-scalar multiplication
"""
if isinstance(other, Vector): # vector-matrix
if isinstance(other, Vector): # matrix-vector
if len(other) == self.__width:
ans = zeroVector(self.__height)
ans = zero_vector(self.__height)
for i in range(self.__height):
summe: float = 0
for j in range(self.__width):
summe += other.component(j) * self.__matrix[i][j]
ans.changeComponent(i, summe)
summe = 0
prods = [
self.__matrix[i][j] * other.component(j)
for j in range(self.__width)
]
ans.change_component(i, sum(prods))
return ans
else:
raise Exception(
"vector must have the same size as the "
+ "number of columns of the matrix!"
"number of columns of the matrix!"
)
elif isinstance(other, int) or isinstance(other, float): # matrix-scalar
matrix = [
@ -377,52 +356,95 @@ class Matrix:
]
return Matrix(matrix, self.__width, self.__height)
def __add__(self, other: Matrix) -> Matrix:
def height(self) -> int:
"""
implements the matrix-addition.
getter for the height
"""
if self.__width == other.width() and self.__height == other.height():
matrix = []
for i in range(self.__height):
row = []
for j in range(self.__width):
row.append(self.__matrix[i][j] + other.component(i, j))
matrix.append(row)
return Matrix(matrix, self.__width, self.__height)
return self.__height
def width(self) -> int:
"""
getter for the width
"""
return self.__width
def component(self, x: int, y: int) -> float:
"""
returns the specified (x,y) component
"""
if 0 <= x < self.__height and 0 <= y < self.__width:
return self.__matrix[x][y]
else:
raise Exception("matrix must have the same dimension!")
raise Exception("change_component: indices out of bounds")
def __sub__(self, other: Matrix) -> Matrix:
def change_component(self, x: int, y: int, value: float) -> None:
"""
implements the matrix-subtraction.
changes the x-y component of this matrix
"""
if self.__width == other.width() and self.__height == other.height():
matrix = []
for i in range(self.__height):
row = []
for j in range(self.__width):
row.append(self.__matrix[i][j] - other.component(i, j))
matrix.append(row)
return Matrix(matrix, self.__width, self.__height)
if 0 <= x < self.__height and 0 <= y < self.__width:
self.__matrix[x][y] = value
else:
raise Exception("matrix must have the same dimension!")
raise Exception("change_component: indices out of bounds")
def minor(self, x: int, y: int) -> float:
"""
returns the minor along (x, y)
"""
if self.__height != self.__width:
raise Exception("Matrix is not square")
minor = self.__matrix[:x] + self.__matrix[x + 1 :]
for i in range(len(minor)):
minor[i] = minor[i][:y] + minor[i][y + 1 :]
return Matrix(minor, self.__width - 1, self.__height - 1).determinant()
def cofactor(self, x: int, y: int) -> float:
"""
returns the cofactor (signed minor) along (x, y)
"""
if self.__height != self.__width:
raise Exception("Matrix is not square")
if 0 <= x < self.__height and 0 <= y < self.__width:
return (-1) ** (x + y) * self.minor(x, y)
else:
raise Exception("Indices out of bounds")
def determinant(self) -> float:
"""
returns the determinant of an nxn matrix using Laplace expansion
"""
if self.__height != self.__width:
raise Exception("Matrix is not square")
if self.__height < 1:
raise Exception("Matrix has no element")
elif self.__height == 1:
return self.__matrix[0][0]
elif self.__height == 2:
return (
self.__matrix[0][0] * self.__matrix[1][1]
- self.__matrix[0][1] * self.__matrix[1][0]
)
else:
cofactor_prods = [
self.__matrix[0][y] * self.cofactor(0, y) for y in range(self.__width)
]
return sum(cofactor_prods)
def squareZeroMatrix(N: int) -> Matrix:
def square_zero_matrix(n: int) -> Matrix:
"""
returns a square zero-matrix of dimension NxN
"""
ans: list[list[float]] = [[0] * N for _ in range(N)]
return Matrix(ans, N, N)
ans: list[list[float]] = [[0] * n for _ in range(n)]
return Matrix(ans, n, n)
def randomMatrix(W: int, H: int, a: int, b: int) -> Matrix:
def random_matrix(width: int, height: int, a: int, b: int) -> Matrix:
"""
returns a random matrix WxH with integer components
between 'a' and 'b'
"""
random.seed(None)
matrix: list[list[float]] = [
[random.randint(a, b) for _ in range(W)] for _ in range(H)
[random.randint(a, b) for _ in range(width)] for _ in range(height)
]
return Matrix(matrix, W, H)
return Matrix(matrix, width, height)

96
linear_algebra/src/test_linear_algebra.py
View File

@ -8,13 +8,20 @@ This file contains the test-suite for the linear algebra library.
"""
import unittest
from .lib import Matrix, Vector, axpy, squareZeroMatrix, unitBasisVector, zeroVector
from .lib import (
Matrix,
Vector,
axpy,
square_zero_matrix,
unit_basis_vector,
zero_vector,
)
class Test(unittest.TestCase):
def test_component(self) -> None:
"""
test for method component
test for method component()
"""
x = Vector([1, 2, 3])
self.assertEqual(x.component(0), 1)
@ -23,24 +30,24 @@ class Test(unittest.TestCase):
def test_str(self) -> None:
"""
test for toString() method
test for method toString()
"""
x = Vector([0, 0, 0, 0, 0, 1])
self.assertEqual(str(x), "(0,0,0,0,0,1)")
def test_size(self) -> None:
"""
test for size()-method
test for method size()
"""
x = Vector([1, 2, 3, 4])
self.assertEqual(len(x), 4)
def test_euclidLength(self) -> None:
"""
test for the eulidean length
test for method euclidean_length()
"""
x = Vector([1, 2])
self.assertAlmostEqual(x.euclidLength(), 2.236, 3)
self.assertAlmostEqual(x.euclidean_length(), 2.236, 3)
def test_add(self) -> None:
"""
@ -67,26 +74,26 @@ class Test(unittest.TestCase):
test for * operator
"""
x = Vector([1, 2, 3])
a = Vector([2, -1, 4]) # for test of dot-product
a = Vector([2, -1, 4]) # for test of dot product
b = Vector([1, -2, -1])
self.assertEqual(str(x * 3.0), "(3.0,6.0,9.0)")
self.assertEqual((a * b), 0)
def test_zeroVector(self) -> None:
"""
test for the global function zeroVector(...)
test for global function zero_vector()
"""
self.assertTrue(str(zeroVector(10)).count("0") == 10)
self.assertTrue(str(zero_vector(10)).count("0") == 10)
def test_unitBasisVector(self) -> None:
"""
test for the global function unitBasisVector(...)
test for global function unit_basis_vector()
"""
self.assertEqual(str(unitBasisVector(3, 1)), "(0,1,0)")
self.assertEqual(str(unit_basis_vector(3, 1)), "(0,1,0)")
def test_axpy(self) -> None:
"""
test for the global function axpy(...) (operation)
test for global function axpy() (operation)
"""
x = Vector([1, 2, 3])
y = Vector([1, 0, 1])
@ -94,7 +101,7 @@ class Test(unittest.TestCase):
def test_copy(self) -> None:
"""
test for the copy()-method
test for method copy()
"""
x = Vector([1, 0, 0, 0, 0, 0])
y = x.copy()
@ -102,53 +109,94 @@ class Test(unittest.TestCase):
def test_changeComponent(self) -> None:
"""
test for the changeComponent(...)-method
test for method change_component()
"""
x = Vector([1, 0, 0])
x.changeComponent(0, 0)
x.changeComponent(1, 1)
x.change_component(0, 0)
x.change_component(1, 1)
self.assertEqual(str(x), "(0,1,0)")
def test_str_matrix(self) -> None:
"""
test for Matrix method str()
"""
A = Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]], 3, 3)
self.assertEqual("|1,2,3|\n|2,4,5|\n|6,7,8|\n", str(A))
def test_determinate(self) -> None:
def test_minor(self) -> None:
"""
test for determinate()
test for Matrix method minor()
"""
A = Matrix([[1, 1, 4, 5], [3, 3, 3, 2], [5, 1, 9, 0], [9, 7, 7, 9]], 4, 4)
self.assertEqual(-376, A.determinate())
A = Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]], 3, 3)
minors = [[-3, -14, -10], [-5, -10, -5], [-2, -1, 0]]
for x in range(A.height()):
for y in range(A.width()):
self.assertEqual(minors[x][y], A.minor(x, y))
def test_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]]
for x in range(A.height()):
for y in range(A.width()):
self.assertEqual(cofactors[x][y], A.cofactor(x, y))
def test_determinant(self) -> None:
"""
test for Matrix method determinant()
"""
A = Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]], 3, 3)
self.assertEqual(-5, A.determinant())
def test__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])
self.assertEqual("(14,32,50)", str(A * x))
self.assertEqual("|2,4,6|\n|8,10,12|\n|14,16,18|\n", str(A * 2))
def test_changeComponent_matrix(self) -> None:
def test_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.changeComponent(0, 2, 5)
A.change_component(0, 2, 5)
self.assertEqual("|1,2,5|\n|2,4,5|\n|6,7,8|\n", str(A))
def test_component_matrix(self) -> None:
"""
test for Matrix method component()
"""
A = Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]], 3, 3)
self.assertEqual(7, A.component(2, 1), 0.01)
def test__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)
self.assertEqual("|2,4,10|\n|4,8,10|\n|12,14,18|\n", str(A + B))
def test__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)
self.assertEqual("|0,0,-4|\n|0,0,0|\n|0,0,-2|\n", str(A - B))
def test_squareZeroMatrix(self) -> None:
"""
test for global function square_zero_matrix()
"""
self.assertEqual(
"|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",
str(squareZeroMatrix(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",
str(square_zero_matrix(5)),
)