algorithm/Python
1
0
Fork 0
mirror of https://github.com/TheAlgorithms/Python.git synced 2025-07-22 05:03:56 +08:00
Code Issues Packages Projects Releases Wiki Activity

psf/black code formatting (#1277)

Browse Source
This commit is contained in:
William Zhang
2019-10-05 01:14:13 -04:00
committed by Christian Clauss
parent 07f04a2e55
commit 9eac17a408
291 changed files with 6014 additions and 4571 deletions
Download Patch File Download Diff File Expand all files Collapse all files

158
linear_algebra/src/lib.py
View File

@ -45,13 +45,15 @@ class Vector(object):
changeComponent(pos,value) : changes the specified component.
TODO: compare-operator
"""
def __init__(self,components=[]):
def __init__(self, components=[]):
"""
input: components or nothing
simple constructor for init the vector
"""
self.__components = list(components)
def set(self,components):
def set(self, components):
"""
input: new components
changes the components of the vector.
@ -61,34 +63,39 @@ class Vector(object):
self.__components = list(components)
else:
raise Exception("please give any vector")
def __str__(self):
"""
returns a string representation of the vector
"""
return "(" + ",".join(map(str, self.__components)) + ")"
def component(self,i):
def component(self, i):
"""
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) :
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):
"""
returns the size of the vector
"""
return len(self.__components)
def eulidLength(self):
"""
returns the eulidean length of the vector
"""
summe = 0
for c in self.__components:
summe += c**2
summe += c ** 2
return math.sqrt(summe)
def __add__(self,other):
def __add__(self, other):
"""
input: other vector
assumes: other vector has the same size
@ -100,7 +107,8 @@ class Vector(object):
return Vector(result)
else:
raise Exception("must have the same size")
def __sub__(self,other):
def __sub__(self, other):
"""
input: other vector
assumes: other vector has the same size
@ -110,73 +118,80 @@ class Vector(object):
if size == len(other):
result = [self.__components[i] - other.component(i) for i in range(size)]
return result
else: # error case
else: # error case
raise Exception("must have the same size")
def __mul__(self,other):
def __mul__(self, other):
"""
mul implements the scalar multiplication
and the dot-product
"""
if isinstance(other,float) or isinstance(other,int):
ans = [c*other for c in self.__components]
if isinstance(other, float) or isinstance(other, int):
ans = [c * other for c in self.__components]
return ans
elif (isinstance(other,Vector) and (len(self) == len(other))):
elif isinstance(other, Vector) and (len(self) == len(other)):
size = len(self)
summe = 0
for i in range(size):
summe += self.__components[i] * other.component(i)
return summe
else: # error case
else: # error case
raise Exception("invalide operand!")
def copy(self):
"""
copies this vector and returns it.
"""
return Vector(self.__components)
def changeComponent(self,pos,value):
def changeComponent(self, pos, value):
"""
input: an index (pos) and a value
changes the specified component (pos) with the
'value'
"""
#precondition
assert (-len(self.__components) <= pos < len(self.__components))
# precondition
assert -len(self.__components) <= pos < len(self.__components)
self.__components[pos] = value
def zeroVector(dimension):
"""
returns a zero-vector of size 'dimension'
"""
#precondition
assert(isinstance(dimension,int))
return Vector([0]*dimension)
"""
# precondition
assert isinstance(dimension, int)
return Vector([0] * dimension)
def unitBasisVector(dimension,pos):
def unitBasisVector(dimension, pos):
"""
returns a unit basis vector with a One
at index 'pos' (indexing at 0)
"""
#precondition
assert(isinstance(dimension,int) and (isinstance(pos,int)))
ans = [0]*dimension
# precondition
assert isinstance(dimension, int) and (isinstance(pos, int))
ans = [0] * dimension
ans[pos] = 1
return Vector(ans)
def axpy(scalar,x,y):
def axpy(scalar, x, y):
"""
input: a 'scalar' and two vectors 'x' and 'y'
output: a vector
computes the axpy operation
"""
# precondition
assert(isinstance(x,Vector) and (isinstance(y,Vector)) \
and (isinstance(scalar,int) or isinstance(scalar,float)))
return (x*scalar + y)
assert (
isinstance(x, Vector)
and (isinstance(y, Vector))
and (isinstance(scalar, int) or isinstance(scalar, float))
)
return x * scalar + y
def randomVector(N,a,b):
def randomVector(N, a, b):
"""
input: size (N) of the vector.
random range (a,b)
@ -184,7 +199,7 @@ def randomVector(N,a,b):
random integer components between 'a' and 'b'.
"""
random.seed(None)
ans = [random.randint(a,b) for i in range(N)]
ans = [random.randint(a, b) for i in range(N)]
return Vector(ans)
@ -205,7 +220,8 @@ class Matrix(object):
operator + : implements the matrix-addition.
operator - _ implements the matrix-subtraction
"""
def __init__(self,matrix,w,h):
def __init__(self, matrix, w, h):
"""
simple constructor for initialzes
the matrix with components.
@ -213,6 +229,7 @@ class Matrix(object):
self.__matrix = matrix
self.__width = w
self.__height = h
def __str__(self):
"""
returns a string representation of this
@ -222,102 +239,113 @@ class Matrix(object):
for i in range(self.__height):
ans += "|"
for j in range(self.__width):
if j < self.__width -1:
if j < self.__width - 1:
ans += str(self.__matrix[i][j]) + ","
else:
ans += str(self.__matrix[i][j]) + "|\n"
return ans
def changeComponent(self,x,y, value):
def changeComponent(self, x, y, value):
"""
changes the x-y component of this matrix
"""
if x >= 0 and x < self.__height and y >= 0 and y < self.__width:
self.__matrix[x][y] = value
else:
raise Exception ("changeComponent: indices out of bounds")
def component(self,x,y):
raise Exception("changeComponent: indices out of bounds")
def component(self, x, y):
"""
returns the specified (x,y) component
"""
if x >= 0 and x < self.__height and y >= 0 and y < self.__width:
return self.__matrix[x][y]
else:
raise Exception ("changeComponent: indices out of bounds")
raise Exception("changeComponent: indices out of bounds")
def width(self):
"""
getter for the width
"""
return self.__width
def height(self):
"""
getter for the height
"""
return self.__height
def __mul__(self,other):
def __mul__(self, other):
"""
implements the matrix-vector multiplication.
implements the matrix-scalar multiplication
"""
if isinstance(other, Vector): # vector-matrix
if (len(other) == self.__width):
if isinstance(other, Vector): # vector-matrix
if len(other) == self.__width:
ans = zeroVector(self.__height)
for i in range(self.__height):
summe = 0
for j in range(self.__width):
summe += other.component(j) * self.__matrix[i][j]
ans.changeComponent(i,summe)
ans.changeComponent(i, summe)
summe = 0
return ans
else:
raise Exception("vector must have the same size as the " + "number of columns of the matrix!")
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)
def __add__(self,other):
raise Exception(
"vector must have the same size as the "
+ "number of columns of the matrix!"
)
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)
def __add__(self, other):
"""
implements the matrix-addition.
"""
if (self.__width == other.width() and self.__height == other.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))
row.append(self.__matrix[i][j] + other.component(i, j))
matrix.append(row)
return Matrix(matrix,self.__width,self.__height)
return Matrix(matrix, self.__width, self.__height)
else:
raise Exception("matrix must have the same dimension!")
def __sub__(self,other):
def __sub__(self, other):
"""
implements the matrix-subtraction.
"""
if (self.__width == other.width() and self.__height == other.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))
row.append(self.__matrix[i][j] - other.component(i, j))
matrix.append(row)
return Matrix(matrix,self.__width,self.__height)
return Matrix(matrix, self.__width, self.__height)
else:
raise Exception("matrix must have the same dimension!")
def squareZeroMatrix(N):
"""
returns a square zero-matrix of dimension NxN
"""
ans = [[0]*N for i in range(N)]
return Matrix(ans,N,N)
def randomMatrix(W,H,a,b):
ans = [[0] * N for i in range(N)]
return Matrix(ans, N, N)
def randomMatrix(W, H, a, b):
"""
returns a random matrix WxH with integer components
between 'a' and 'b'
"""
random.seed(None)
matrix = [[random.randint(a,b) for j in range(W)] for i in range(H)]
return Matrix(matrix,W,H)
matrix = [[random.randint(a, b) for j in range(W)] for i in range(H)]
return Matrix(matrix, W, H)

129
linear_algebra/src/tests.py
View File

@ -11,123 +11,144 @@ This file contains the test-suite for the linear algebra library.
import unittest
from lib import Matrix, Vector, axpy, squareZeroMatrix, unitBasisVector, zeroVector
class Test(unittest.TestCase):
def test_component(self):
"""
test for method component
"""
x = Vector([1,2,3])
self.assertEqual(x.component(0),1)
self.assertEqual(x.component(2),3)
x = Vector([1, 2, 3])
self.assertEqual(x.component(0), 1)
self.assertEqual(x.component(2), 3)
try:
y = Vector()
self.assertTrue(False)
except:
self.assertTrue(True)
def test_str(self):
"""
test for toString() method
"""
x = Vector([0,0,0,0,0,1])
self.assertEqual(str(x),"(0,0,0,0,0,1)")
x = Vector([0, 0, 0, 0, 0, 1])
self.assertEqual(str(x), "(0,0,0,0,0,1)")
def test_size(self):
"""
test for size()-method
"""
x = Vector([1,2,3,4])
self.assertEqual(len(x),4)
x = Vector([1, 2, 3, 4])
self.assertEqual(len(x), 4)
def test_euclidLength(self):
"""
test for the eulidean length
"""
x = Vector([1,2])
self.assertAlmostEqual(x.eulidLength(),2.236,3)
x = Vector([1, 2])
self.assertAlmostEqual(x.eulidLength(), 2.236, 3)
def test_add(self):
"""
test for + operator
"""
x = Vector([1,2,3])
y = Vector([1,1,1])
self.assertEqual((x+y).component(0),2)
self.assertEqual((x+y).component(1),3)
self.assertEqual((x+y).component(2),4)
x = Vector([1, 2, 3])
y = Vector([1, 1, 1])
self.assertEqual((x + y).component(0), 2)
self.assertEqual((x + y).component(1), 3)
self.assertEqual((x + y).component(2), 4)
def test_sub(self):
"""
test for - operator
"""
x = Vector([1,2,3])
y = Vector([1,1,1])
self.assertEqual((x-y).component(0),0)
self.assertEqual((x-y).component(1),1)
self.assertEqual((x-y).component(2),2)
x = Vector([1, 2, 3])
y = Vector([1, 1, 1])
self.assertEqual((x - y).component(0), 0)
self.assertEqual((x - y).component(1), 1)
self.assertEqual((x - y).component(2), 2)
def test_mul(self):
"""
test for * operator
"""
x = Vector([1,2,3])
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)
x = Vector([1, 2, 3])
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):
"""
test for the global function zeroVector(...)
"""
self.assertTrue(str(zeroVector(10)).count("0") == 10)
def test_unitBasisVector(self):
"""
test for the global function unitBasisVector(...)
"""
self.assertEqual(str(unitBasisVector(3,1)),"(0,1,0)")
self.assertEqual(str(unitBasisVector(3, 1)), "(0,1,0)")
def test_axpy(self):
"""
test for the global function axpy(...) (operation)
"""
x = Vector([1,2,3])
y = Vector([1,0,1])
self.assertEqual(str(axpy(2,x,y)),"(3,4,7)")
x = Vector([1, 2, 3])
y = Vector([1, 0, 1])
self.assertEqual(str(axpy(2, x, y)), "(3,4,7)")
def test_copy(self):
"""
test for the copy()-method
"""
x = Vector([1,0,0,0,0,0])
x = Vector([1, 0, 0, 0, 0, 0])
y = x.copy()
self.assertEqual(str(x),str(y))
self.assertEqual(str(x), str(y))
def test_changeComponent(self):
"""
test for the changeComponent(...)-method
"""
x = Vector([1,0,0])
x.changeComponent(0,0)
x.changeComponent(1,1)
self.assertEqual(str(x),"(0,1,0)")
x = Vector([1, 0, 0])
x.changeComponent(0, 0)
x.changeComponent(1, 1)
self.assertEqual(str(x), "(0,1,0)")
def test_str_matrix(self):
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))
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__mul__matrix(self):
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))
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):
A = Matrix([[1,2,3],[2,4,5],[6,7,8]],3,3)
A.changeComponent(0,2,5)
self.assertEqual("|1,2,5|\n|2,4,5|\n|6,7,8|\n",str(A))
A = Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]], 3, 3)
A.changeComponent(0, 2, 5)
self.assertEqual("|1,2,5|\n|2,4,5|\n|6,7,8|\n", str(A))
def test_component_matrix(self):
A = Matrix([[1,2,3],[2,4,5],[6,7,8]],3,3)
self.assertEqual(7,A.component(2,1),0.01)
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):
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))
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):
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))
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):
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)))
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)),
)
if __name__ == "__main__":
unittest.main()