2018-10-19 12:48:28 +00:00
|
|
|
"""
|
|
|
|
Created on Mon Feb 26 14:29:11 2018
|
|
|
|
|
|
|
|
@author: Christian Bender
|
|
|
|
@license: MIT-license
|
|
|
|
|
|
|
|
This module contains some useful classes and functions for dealing
|
|
|
|
with linear algebra in python.
|
|
|
|
|
|
|
|
Overview:
|
|
|
|
|
|
|
|
- class Vector
|
2021-10-27 03:48:43 +00:00
|
|
|
- function zero_vector(dimension)
|
|
|
|
- function unit_basis_vector(dimension, pos)
|
|
|
|
- function axpy(scalar, vector1, vector2)
|
|
|
|
- function random_vector(N, a, b)
|
2018-10-19 12:48:28 +00:00
|
|
|
- class Matrix
|
2021-10-27 03:48:43 +00:00
|
|
|
- function square_zero_matrix(N)
|
|
|
|
- function random_matrix(W, H, a, b)
|
2018-10-19 12:48:28 +00:00
|
|
|
"""
|
2021-09-07 11:37:03 +00:00
|
|
|
from __future__ import annotations
|
2018-10-19 12:48:28 +00:00
|
|
|
|
|
|
|
import math
|
|
|
|
import random
|
2021-09-07 11:37:03 +00:00
|
|
|
from typing import Collection, overload
|
2018-10-19 12:48:28 +00:00
|
|
|
|
|
|
|
|
2020-01-03 14:25:36 +00:00
|
|
|
class Vector:
|
2018-10-19 12:48:28 +00:00
|
|
|
"""
|
2020-09-10 08:31:26 +00:00
|
|
|
This class represents a vector of arbitrary size.
|
|
|
|
You need to give the vector components.
|
|
|
|
|
2021-10-27 03:48:43 +00:00
|
|
|
Overview of the methods:
|
|
|
|
|
|
|
|
__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
|
|
|
|
angle(other: Vector, deg: bool): returns the angle between two vectors
|
|
|
|
TODO: compare-operator
|
2018-10-19 12:48:28 +00:00
|
|
|
"""
|
2019-10-05 05:14:13 +00:00
|
|
|
|
2021-09-07 11:37:03 +00:00
|
|
|
def __init__(self, components: Collection[float] | None = None) -> None:
|
2018-10-19 12:48:28 +00:00
|
|
|
"""
|
2020-09-10 08:31:26 +00:00
|
|
|
input: components or nothing
|
|
|
|
simple constructor for init the vector
|
2018-10-19 12:48:28 +00:00
|
|
|
"""
|
2019-10-17 18:13:28 +00:00
|
|
|
if components is None:
|
|
|
|
components = []
|
2018-11-12 17:38:07 +00:00
|
|
|
self.__components = list(components)
|
2019-10-05 05:14:13 +00:00
|
|
|
|
2021-04-05 13:37:38 +00:00
|
|
|
def __len__(self) -> int:
|
2018-10-19 12:48:28 +00:00
|
|
|
"""
|
2020-09-10 08:31:26 +00:00
|
|
|
returns the size of the vector
|
2018-10-19 12:48:28 +00:00
|
|
|
"""
|
|
|
|
return len(self.__components)
|
2019-10-05 05:14:13 +00:00
|
|
|
|
2021-10-27 03:48:43 +00:00
|
|
|
def __str__(self) -> str:
|
2018-10-19 12:48:28 +00:00
|
|
|
"""
|
2021-10-27 03:48:43 +00:00
|
|
|
returns a string representation of the vector
|
2018-10-19 12:48:28 +00:00
|
|
|
"""
|
2021-10-27 03:48:43 +00:00
|
|
|
return "(" + ",".join(map(str, self.__components)) + ")"
|
2019-10-05 05:14:13 +00:00
|
|
|
|
2021-09-07 11:37:03 +00:00
|
|
|
def __add__(self, other: Vector) -> Vector:
|
2018-10-19 12:48:28 +00:00
|
|
|
"""
|
2020-09-10 08:31:26 +00:00
|
|
|
input: other vector
|
|
|
|
assumes: other vector has the same size
|
|
|
|
returns a new vector that represents the sum.
|
2018-10-19 12:48:28 +00:00
|
|
|
"""
|
2018-11-12 17:38:07 +00:00
|
|
|
size = len(self)
|
|
|
|
if size == len(other):
|
2018-11-12 18:03:22 +00:00
|
|
|
result = [self.__components[i] + other.component(i) for i in range(size)]
|
|
|
|
return Vector(result)
|
2018-10-19 12:48:28 +00:00
|
|
|
else:
|
|
|
|
raise Exception("must have the same size")
|
2019-10-05 05:14:13 +00:00
|
|
|
|
2021-09-07 11:37:03 +00:00
|
|
|
def __sub__(self, other: Vector) -> Vector:
|
2018-10-19 12:48:28 +00:00
|
|
|
"""
|
2020-09-10 08:31:26 +00:00
|
|
|
input: other vector
|
|
|
|
assumes: other vector has the same size
|
|
|
|
returns a new vector that represents the difference.
|
2018-10-19 12:48:28 +00:00
|
|
|
"""
|
2018-11-12 17:38:07 +00:00
|
|
|
size = len(self)
|
|
|
|
if size == len(other):
|
2018-11-12 18:03:22 +00:00
|
|
|
result = [self.__components[i] - other.component(i) for i in range(size)]
|
2019-10-24 10:39:51 +00:00
|
|
|
return Vector(result)
|
2019-10-05 05:14:13 +00:00
|
|
|
else: # error case
|
2018-10-19 12:48:28 +00:00
|
|
|
raise Exception("must have the same size")
|
2019-10-05 05:14:13 +00:00
|
|
|
|
2021-04-05 13:37:38 +00:00
|
|
|
@overload
|
2021-09-07 11:37:03 +00:00
|
|
|
def __mul__(self, other: float) -> Vector:
|
2021-04-05 13:37:38 +00:00
|
|
|
...
|
|
|
|
|
|
|
|
@overload
|
2021-09-07 11:37:03 +00:00
|
|
|
def __mul__(self, other: Vector) -> float:
|
2021-04-05 13:37:38 +00:00
|
|
|
...
|
|
|
|
|
2021-09-07 11:37:03 +00:00
|
|
|
def __mul__(self, other: float | Vector) -> float | Vector:
|
2018-10-19 12:48:28 +00:00
|
|
|
"""
|
2020-09-10 08:31:26 +00:00
|
|
|
mul implements the scalar multiplication
|
|
|
|
and the dot-product
|
2018-10-19 12:48:28 +00:00
|
|
|
"""
|
2019-10-05 05:14:13 +00:00
|
|
|
if isinstance(other, float) or isinstance(other, int):
|
|
|
|
ans = [c * other for c in self.__components]
|
2019-10-24 10:39:51 +00:00
|
|
|
return Vector(ans)
|
2021-10-27 03:48:43 +00:00
|
|
|
elif isinstance(other, Vector) and len(self) == len(other):
|
2018-11-12 17:38:07 +00:00
|
|
|
size = len(self)
|
2021-10-27 03:48:43 +00:00
|
|
|
prods = [self.__components[i] * other.component(i) for i in range(size)]
|
|
|
|
return sum(prods)
|
2019-10-05 05:14:13 +00:00
|
|
|
else: # error case
|
2019-10-17 18:13:28 +00:00
|
|
|
raise Exception("invalid operand!")
|
2019-10-05 05:14:13 +00:00
|
|
|
|
2021-10-27 03:48:43 +00:00
|
|
|
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
|
2021-10-12 09:51:27 +00:00
|
|
|
|
2021-10-31 14:16:02 +00:00
|
|
|
>>> Vector([2, 3, 4]).euclidean_length()
|
2021-10-12 09:51:27 +00:00
|
|
|
5.385164807134504
|
2021-10-31 14:16:02 +00:00
|
|
|
>>> Vector([1]).euclidean_length()
|
|
|
|
1.0
|
|
|
|
>>> Vector([0, -1, -2, -3, 4, 5, 6]).euclidean_length()
|
|
|
|
9.539392014169456
|
|
|
|
>>> Vector([]).euclidean_length()
|
|
|
|
Traceback (most recent call last):
|
|
|
|
...
|
|
|
|
Exception: Vector is empty
|
2021-10-12 09:51:27 +00:00
|
|
|
"""
|
2021-10-31 14:16:02 +00:00
|
|
|
if len(self.__components) == 0:
|
|
|
|
raise Exception("Vector is empty")
|
2021-10-27 03:48:43 +00:00
|
|
|
squares = [c ** 2 for c in self.__components]
|
|
|
|
return math.sqrt(sum(squares))
|
2021-10-12 09:51:27 +00:00
|
|
|
|
|
|
|
def angle(self, other: Vector, deg: bool = False) -> float:
|
|
|
|
"""
|
|
|
|
find angle between two Vector (self, Vector)
|
|
|
|
|
|
|
|
>>> Vector([3, 4, -1]).angle(Vector([2, -1, 1]))
|
|
|
|
1.4906464636572374
|
|
|
|
>>> Vector([3, 4, -1]).angle(Vector([2, -1, 1]), deg = True)
|
|
|
|
85.40775111366095
|
|
|
|
>>> Vector([3, 4, -1]).angle(Vector([2, -1]))
|
|
|
|
Traceback (most recent call last):
|
|
|
|
...
|
|
|
|
Exception: invalid operand!
|
|
|
|
"""
|
|
|
|
num = self * other
|
2021-10-31 14:16:02 +00:00
|
|
|
den = self.euclidean_length() * other.euclidean_length()
|
2021-10-12 09:51:27 +00:00
|
|
|
if deg:
|
|
|
|
return math.degrees(math.acos(num / den))
|
|
|
|
else:
|
|
|
|
return math.acos(num / den)
|
|
|
|
|
2019-10-05 05:14:13 +00:00
|
|
|
|
2021-10-27 03:48:43 +00:00
|
|
|
def zero_vector(dimension: int) -> Vector:
|
2018-10-19 12:48:28 +00:00
|
|
|
"""
|
2020-09-10 08:31:26 +00:00
|
|
|
returns a zero-vector of size 'dimension'
|
2019-10-05 05:14:13 +00:00
|
|
|
"""
|
|
|
|
# precondition
|
|
|
|
assert isinstance(dimension, int)
|
|
|
|
return Vector([0] * dimension)
|
2018-10-19 12:48:28 +00:00
|
|
|
|
|
|
|
|
2021-10-27 03:48:43 +00:00
|
|
|
def unit_basis_vector(dimension: int, pos: int) -> Vector:
|
2018-10-19 12:48:28 +00:00
|
|
|
"""
|
2020-09-10 08:31:26 +00:00
|
|
|
returns a unit basis vector with a One
|
|
|
|
at index 'pos' (indexing at 0)
|
2018-10-19 12:48:28 +00:00
|
|
|
"""
|
2019-10-05 05:14:13 +00:00
|
|
|
# precondition
|
|
|
|
assert isinstance(dimension, int) and (isinstance(pos, int))
|
|
|
|
ans = [0] * dimension
|
2018-11-12 17:38:07 +00:00
|
|
|
ans[pos] = 1
|
2018-10-19 12:48:28 +00:00
|
|
|
return Vector(ans)
|
|
|
|
|
2019-10-05 05:14:13 +00:00
|
|
|
|
2021-04-05 13:37:38 +00:00
|
|
|
def axpy(scalar: float, x: Vector, y: Vector) -> Vector:
|
2018-10-19 12:48:28 +00:00
|
|
|
"""
|
2020-09-10 08:31:26 +00:00
|
|
|
input: a 'scalar' and two vectors 'x' and 'y'
|
|
|
|
output: a vector
|
|
|
|
computes the axpy operation
|
2018-10-19 12:48:28 +00:00
|
|
|
"""
|
|
|
|
# precondition
|
2019-10-05 05:14:13 +00:00
|
|
|
assert (
|
|
|
|
isinstance(x, Vector)
|
2021-10-27 03:48:43 +00:00
|
|
|
and isinstance(y, Vector)
|
2019-10-05 05:14:13 +00:00
|
|
|
and (isinstance(scalar, int) or isinstance(scalar, float))
|
|
|
|
)
|
|
|
|
return x * scalar + y
|
|
|
|
|
2018-10-19 12:48:28 +00:00
|
|
|
|
2021-10-27 03:48:43 +00:00
|
|
|
def random_vector(n: int, a: int, b: int) -> Vector:
|
2018-10-19 12:48:28 +00:00
|
|
|
"""
|
2020-09-10 08:31:26 +00:00
|
|
|
input: size (N) of the vector.
|
|
|
|
random range (a,b)
|
|
|
|
output: returns a random vector of size N, with
|
|
|
|
random integer components between 'a' and 'b'.
|
2018-10-19 12:48:28 +00:00
|
|
|
"""
|
|
|
|
random.seed(None)
|
2021-10-27 03:48:43 +00:00
|
|
|
ans = [random.randint(a, b) for _ in range(n)]
|
2018-11-12 17:38:07 +00:00
|
|
|
return Vector(ans)
|
2018-10-19 12:48:28 +00:00
|
|
|
|
|
|
|
|
2020-01-03 14:25:36 +00:00
|
|
|
class Matrix:
|
2018-10-19 12:48:28 +00:00
|
|
|
"""
|
|
|
|
class: Matrix
|
2021-10-27 03:48:43 +00:00
|
|
|
This class represents an arbitrary matrix.
|
|
|
|
|
|
|
|
Overview of the methods:
|
|
|
|
|
|
|
|
__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
|
2018-10-19 12:48:28 +00:00
|
|
|
"""
|
2019-10-05 05:14:13 +00:00
|
|
|
|
2021-04-05 13:37:38 +00:00
|
|
|
def __init__(self, matrix: list[list[float]], w: int, h: int) -> None:
|
2018-10-19 12:48:28 +00:00
|
|
|
"""
|
2021-10-31 14:16:02 +00:00
|
|
|
simple constructor for initializing the matrix with components.
|
2018-10-19 12:48:28 +00:00
|
|
|
"""
|
|
|
|
self.__matrix = matrix
|
|
|
|
self.__width = w
|
|
|
|
self.__height = h
|
2019-10-05 05:14:13 +00:00
|
|
|
|
2021-04-05 13:37:38 +00:00
|
|
|
def __str__(self) -> str:
|
2018-10-19 12:48:28 +00:00
|
|
|
"""
|
2021-10-31 14:16:02 +00:00
|
|
|
returns a string representation of this matrix.
|
2018-10-19 12:48:28 +00:00
|
|
|
"""
|
|
|
|
ans = ""
|
|
|
|
for i in range(self.__height):
|
|
|
|
ans += "|"
|
|
|
|
for j in range(self.__width):
|
2019-10-05 05:14:13 +00:00
|
|
|
if j < self.__width - 1:
|
2018-10-19 12:48:28 +00:00
|
|
|
ans += str(self.__matrix[i][j]) + ","
|
|
|
|
else:
|
|
|
|
ans += str(self.__matrix[i][j]) + "|\n"
|
|
|
|
return ans
|
2019-10-05 05:14:13 +00:00
|
|
|
|
2021-10-27 03:48:43 +00:00
|
|
|
def __add__(self, other: Matrix) -> Matrix:
|
2018-10-19 12:48:28 +00:00
|
|
|
"""
|
2021-10-31 14:16:02 +00:00
|
|
|
implements matrix addition.
|
2018-10-19 12:48:28 +00:00
|
|
|
"""
|
2021-10-27 03:48:43 +00:00
|
|
|
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)
|
2018-10-19 12:48:28 +00:00
|
|
|
else:
|
2021-10-27 03:48:43 +00:00
|
|
|
raise Exception("matrix must have the same dimension!")
|
2019-10-05 05:14:13 +00:00
|
|
|
|
2021-10-27 03:48:43 +00:00
|
|
|
def __sub__(self, other: Matrix) -> Matrix:
|
2018-10-19 12:48:28 +00:00
|
|
|
"""
|
2021-10-31 14:16:02 +00:00
|
|
|
implements matrix subtraction.
|
2018-10-19 12:48:28 +00:00
|
|
|
"""
|
2021-10-27 03:48:43 +00:00
|
|
|
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)
|
2019-10-24 09:08:45 +00:00
|
|
|
else:
|
2021-10-27 03:48:43 +00:00
|
|
|
raise Exception("matrices must have the same dimension!")
|
2019-10-24 09:08:45 +00:00
|
|
|
|
2021-04-05 13:37:38 +00:00
|
|
|
@overload
|
2021-09-07 11:37:03 +00:00
|
|
|
def __mul__(self, other: float) -> Matrix:
|
2021-04-05 13:37:38 +00:00
|
|
|
...
|
|
|
|
|
|
|
|
@overload
|
|
|
|
def __mul__(self, other: Vector) -> Vector:
|
|
|
|
...
|
|
|
|
|
2021-09-07 11:37:03 +00:00
|
|
|
def __mul__(self, other: float | Vector) -> Vector | Matrix:
|
2018-10-19 12:48:28 +00:00
|
|
|
"""
|
2020-09-10 08:31:26 +00:00
|
|
|
implements the matrix-vector multiplication.
|
|
|
|
implements the matrix-scalar multiplication
|
2018-10-19 12:48:28 +00:00
|
|
|
"""
|
2021-10-27 03:48:43 +00:00
|
|
|
if isinstance(other, Vector): # matrix-vector
|
2019-10-05 05:14:13 +00:00
|
|
|
if len(other) == self.__width:
|
2021-10-27 03:48:43 +00:00
|
|
|
ans = zero_vector(self.__height)
|
2018-10-19 12:48:28 +00:00
|
|
|
for i in range(self.__height):
|
2021-10-27 03:48:43 +00:00
|
|
|
prods = [
|
|
|
|
self.__matrix[i][j] * other.component(j)
|
|
|
|
for j in range(self.__width)
|
|
|
|
]
|
|
|
|
ans.change_component(i, sum(prods))
|
2018-10-19 12:48:28 +00:00
|
|
|
return ans
|
|
|
|
else:
|
2019-10-05 05:14:13 +00:00
|
|
|
raise Exception(
|
|
|
|
"vector must have the same size as the "
|
2021-10-27 03:48:43 +00:00
|
|
|
"number of columns of the matrix!"
|
2019-10-05 05:14:13 +00:00
|
|
|
)
|
|
|
|
elif isinstance(other, int) or isinstance(other, float): # matrix-scalar
|
|
|
|
matrix = [
|
|
|
|
[self.__matrix[i][j] * other for j in range(self.__width)]
|
|
|
|
for i in range(self.__height)
|
|
|
|
]
|
|
|
|
return Matrix(matrix, self.__width, self.__height)
|
|
|
|
|
2021-10-27 03:48:43 +00:00
|
|
|
def height(self) -> int:
|
2018-10-19 12:48:28 +00:00
|
|
|
"""
|
2021-10-27 03:48:43 +00:00
|
|
|
getter for the height
|
2018-10-19 12:48:28 +00:00
|
|
|
"""
|
2021-10-27 03:48:43 +00:00
|
|
|
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]
|
2018-10-19 12:48:28 +00:00
|
|
|
else:
|
2021-10-27 03:48:43 +00:00
|
|
|
raise Exception("change_component: indices out of bounds")
|
2019-10-05 05:14:13 +00:00
|
|
|
|
2021-10-27 03:48:43 +00:00
|
|
|
def change_component(self, x: int, y: int, value: float) -> None:
|
2018-10-19 12:48:28 +00:00
|
|
|
"""
|
2021-10-27 03:48:43 +00:00
|
|
|
changes the x-y component of this matrix
|
2018-10-19 12:48:28 +00:00
|
|
|
"""
|
2021-10-27 03:48:43 +00:00
|
|
|
if 0 <= x < self.__height and 0 <= y < self.__width:
|
|
|
|
self.__matrix[x][y] = value
|
2018-10-19 12:48:28 +00:00
|
|
|
else:
|
2021-10-27 03:48:43 +00:00
|
|
|
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)
|
2019-10-05 05:14:13 +00:00
|
|
|
|
2018-10-19 12:48:28 +00:00
|
|
|
|
2021-10-27 03:48:43 +00:00
|
|
|
def square_zero_matrix(n: int) -> Matrix:
|
2018-10-19 12:48:28 +00:00
|
|
|
"""
|
2020-09-10 08:31:26 +00:00
|
|
|
returns a square zero-matrix of dimension NxN
|
2018-10-19 12:48:28 +00:00
|
|
|
"""
|
2021-10-27 03:48:43 +00:00
|
|
|
ans: list[list[float]] = [[0] * n for _ in range(n)]
|
|
|
|
return Matrix(ans, n, n)
|
2019-10-05 05:14:13 +00:00
|
|
|
|
|
|
|
|
2021-10-27 03:48:43 +00:00
|
|
|
def random_matrix(width: int, height: int, a: int, b: int) -> Matrix:
|
2018-10-19 12:48:28 +00:00
|
|
|
"""
|
2020-09-10 08:31:26 +00:00
|
|
|
returns a random matrix WxH with integer components
|
|
|
|
between 'a' and 'b'
|
2018-10-19 12:48:28 +00:00
|
|
|
"""
|
|
|
|
random.seed(None)
|
2021-04-05 13:37:38 +00:00
|
|
|
matrix: list[list[float]] = [
|
2021-10-27 03:48:43 +00:00
|
|
|
[random.randint(a, b) for _ in range(width)] for _ in range(height)
|
2021-04-05 13:37:38 +00:00
|
|
|
]
|
2021-10-27 03:48:43 +00:00
|
|
|
return Matrix(matrix, width, height)
|