mirror of
https://github.com/TheAlgorithms/Python.git
synced 2025-07-05 17:34:49 +08:00
Rewrite parts of Vector and Matrix (#5362)
* 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
@ -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)
|
||||
|
||||
Reference in New Issue
Block a user