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

Ruff pandas vet (#10281)

Browse Source 
* Python linting: Add ruff rules for Pandas-vet and Pytest-style

* updating DIRECTORY.md

---------

Co-authored-by: github-actions <${GITHUB_ACTOR}@users.noreply.github.com>
This commit is contained in:
Christian Clauss
2023-10-11 20:30:02 +02:00
committed by GitHub
parent d5323dbaee
commit 3f094fe49d
28 changed files with 260 additions and 241 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
linear_algebra/src/lib.py
View File

@ -200,7 +200,8 @@ def unit_basis_vector(dimension: int, pos: int) -> Vector:
at index 'pos' (indexing at 0)
"""
# precondition
assert isinstance(dimension, int) and (isinstance(pos, int))
assert isinstance(dimension, int)
assert isinstance(pos, int)
ans = [0] * dimension
ans[pos] = 1
return Vector(ans)
@ -213,11 +214,9 @@ def axpy(scalar: float, x: Vector, y: Vector) -> Vector:
computes the axpy operation
"""
# precondition
assert (
isinstance(x, Vector)
and isinstance(y, Vector)
and (isinstance(scalar, (int, float)))
)
assert isinstance(x, Vector)
assert isinstance(y, Vector)
assert isinstance(scalar, (int, float))
return x * scalar + y

7
linear_algebra/src/schur_complement.py
View File

@ -1,6 +1,7 @@
import unittest
import numpy as np
import pytest
def schur_complement(
@ -70,14 +71,14 @@ class TestSchurComplement(unittest.TestCase):
det_a = np.linalg.det(a)
det_s = np.linalg.det(s)
self.assertAlmostEqual(det_x, det_a * det_s)
assert np.is_close(det_x, det_a * det_s)
def test_improper_a_b_dimensions(self) -> None:
a = np.array([[1, 2, 1], [2, 1, 2], [3, 2, 4]])
b = np.array([[0, 3], [3, 0], [2, 3]])
c = np.array([[2, 1], [6, 3]])
with self.assertRaises(ValueError):
with pytest.raises(ValueError):
schur_complement(a, b, c)
def test_improper_b_c_dimensions(self) -> None:
@ -85,7 +86,7 @@ class TestSchurComplement(unittest.TestCase):
b = np.array([[0, 3], [3, 0], [2, 3]])
c = np.array([[2, 1, 3], [6, 3, 5]])
with self.assertRaises(ValueError):
with pytest.raises(ValueError):
schur_complement(a, b, c)

69
linear_algebra/src/test_linear_algebra.py
View File

@ -8,6 +8,8 @@ This file contains the test-suite for the linear algebra library.
"""
import unittest
import pytest
from .lib import (
Matrix,
Vector,
@ -24,8 +26,8 @@ class Test(unittest.TestCase):
test for method component()
"""
x = Vector([1, 2, 3])
self.assertEqual(x.component(0), 1)
self.assertEqual(x.component(2), 3)
assert x.component(0) == 1
assert x.component(2) == 3
_ = Vector()
def test_str(self) -> None:
@ -33,14 +35,14 @@ class Test(unittest.TestCase):
test for method toString()
"""
x = Vector([0, 0, 0, 0, 0, 1])
self.assertEqual(str(x), "(0,0,0,0,0,1)")
assert str(x) == "(0,0,0,0,0,1)"
def test_size(self) -> None:
"""
test for method size()
"""
x = Vector([1, 2, 3, 4])
self.assertEqual(len(x), 4)
assert len(x) == 4
def test_euclidean_length(self) -> None:
"""
@ -50,10 +52,10 @@ class Test(unittest.TestCase):
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])
self.assertAlmostEqual(x.euclidean_length(), 2.236, 3)
self.assertAlmostEqual(y.euclidean_length(), 7.416, 3)
self.assertEqual(z.euclidean_length(), 0)
self.assertAlmostEqual(w.euclidean_length(), 7.616, 3)
assert x.euclidean_length() == pytest.approx(2.236, abs=1e-3)
assert y.euclidean_length() == pytest.approx(7.416, abs=1e-3)
assert z.euclidean_length() == 0
assert w.euclidean_length() == pytest.approx(7.616, abs=1e-3)
def test_add(self) -> None:
"""
@ -61,9 +63,9 @@ class Test(unittest.TestCase):
"""
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)
assert (x + y).component(0) == 2
assert (x + y).component(1) == 3
assert (x + y).component(2) == 4
def test_sub(self) -> None:
"""
@ -71,9 +73,9 @@ class Test(unittest.TestCase):
"""
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)
assert (x - y).component(0) == 0
assert (x - y).component(1) == 1
assert (x - y).component(2) == 2
def test_mul(self) -> None:
"""
@ -82,20 +84,20 @@ class Test(unittest.TestCase):
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)
assert str(x * 3.0) == "(3.0,6.0,9.0)"
assert a * b == 0
def test_zero_vector(self) -> None:
"""
test for global function zero_vector()
"""
self.assertEqual(str(zero_vector(10)).count("0"), 10)
assert str(zero_vector(10)).count("0") == 10
def test_unit_basis_vector(self) -> None:
"""
test for global function unit_basis_vector()
"""
self.assertEqual(str(unit_basis_vector(3, 1)), "(0,1,0)")
assert str(unit_basis_vector(3, 1)) == "(0,1,0)"
def test_axpy(self) -> None:
"""
@ -103,7 +105,7 @@ class Test(unittest.TestCase):
"""
x = Vector([1, 2, 3])
y = Vector([1, 0, 1])
self.assertEqual(str(axpy(2, x, y)), "(3,4,7)")
assert str(axpy(2, x, y)) == "(3,4,7)"
def test_copy(self) -> None:
"""
@ -111,7 +113,7 @@ class Test(unittest.TestCase):
"""
x = Vector([1, 0, 0, 0, 0, 0])
y = x.copy()
self.assertEqual(str(x), str(y))
assert str(x) == str(y)
def test_change_component(self) -> None:
"""
@ -120,14 +122,14 @@ class Test(unittest.TestCase):
x = Vector([1, 0, 0])
x.change_component(0, 0)
x.change_component(1, 1)
self.assertEqual(str(x), "(0,1,0)")
assert 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))
assert str(a) == "|1,2,3|\n|2,4,5|\n|6,7,8|\n"
def test_minor(self) -> None:
"""
@ -137,7 +139,7 @@ class Test(unittest.TestCase):
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))
assert minors[x][y] == a.minor(x, y)
def test_cofactor(self) -> None:
"""
@ -147,14 +149,14 @@ class Test(unittest.TestCase):
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))
assert 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())
assert a.determinant() == -5
def test__mul__matrix(self) -> None:
"""
@ -162,8 +164,8 @@ class Test(unittest.TestCase):
"""
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))
assert str(a * x) == "(14,32,50)"
assert str(a * 2) == "|2,4,6|\n|8,10,12|\n|14,16,18|\n"
def test_change_component_matrix(self) -> None:
"""
@ -171,14 +173,14 @@ class Test(unittest.TestCase):
"""
a = Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]], 3, 3)
a.change_component(0, 2, 5)
self.assertEqual("|1,2,5|\n|2,4,5|\n|6,7,8|\n", str(a))
assert str(a) == "|1,2,5|\n|2,4,5|\n|6,7,8|\n"
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)
assert a.component(2, 1) == 7, 0.01
def test__add__matrix(self) -> None:
"""
@ -186,7 +188,7 @@ class Test(unittest.TestCase):
"""
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))
assert str(a + b) == "|2,4,10|\n|4,8,10|\n|12,14,18|\n"
def test__sub__matrix(self) -> None:
"""
@ -194,15 +196,14 @@ class Test(unittest.TestCase):
"""
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))
assert str(a - b) == "|0,0,-4|\n|0,0,0|\n|0,0,-2|\n"
def test_square_zero_matrix(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(square_zero_matrix(5)),
assert str(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"
)