[Andrew Polyakov] Added code samples for numpy testing

Author: AndrewPolyakov1

utbot-python/samples/samples/numpy/example_gauss.py

@@ -0,0 +1,71 @@
+import numpy as np
+
+
+def solve_linear_system(matrix: np.ndarray) -> np.ndarray:
+    """
+    Solve a linear system of equations using Gaussian elimination with partial pivoting
+
+    Args:
+    - matrix: Coefficient matrix with the last column representing the constants.
+
+    Returns:
+    - Solution vector.
+
+    Raises:
+    - ValueError: If the matrix is not correct (i.e., singular).
+
+    https://courses.engr.illinois.edu/cs357/su2013/lect.htm Lecture 7
+
+    Example:
+    >>> A = np.array([[2, 1, -1], [-3, -1, 2], [-2, 1, 2]], dtype=float)
+    >>> B = np.array([8, -11, -3], dtype=float)
+    >>> solution = solve_linear_system(np.column_stack((A, B)))
+    >>> np.allclose(solution, np.array([2., 3., -1.]))
+    True
+    >>> solve_linear_system(np.array([[0, 0], [0, 0]],  dtype=float))
+    array([nan, nan])
+    """
+    ab = np.copy(matrix)
+    num_of_rows = ab.shape[0]
+    num_of_columns = ab.shape[1] - 1
+    x_lst: list[float] = []
+
+    for column_num in range(num_of_rows):
+        for i in range(column_num, num_of_columns):
+            if abs(ab[i][column_num]) > abs(ab[column_num][column_num]):
+                ab[[column_num, i]] = ab[[i, column_num]]
+                if ab[column_num, column_num] == 0.0:
+                    raise ValueError("Matrix is not correct")
+            else:
+                pass
+        if column_num != 0:
+            for i in range(column_num, num_of_rows):
+                ab[i, :] -= (
+                        ab[i, column_num - 1]
+                        / ab[column_num - 1, column_num - 1]
+                        * ab[column_num - 1, :]
+                )
+
+    for column_num in range(num_of_rows):
+        for i in range(column_num, num_of_columns):
+            if abs(ab[i][column_num]) > abs(ab[column_num][column_num]):
+                ab[[column_num, i]] = ab[[i, column_num]]
+                if ab[column_num, column_num] == 0.0:
+                    raise ValueError("Matrix is not correct")
+            else:
+                pass
+        if column_num != 0:
+            for i in range(column_num, num_of_rows):
+                ab[i, :] -= (
+                        ab[i, column_num - 1]
+                        / ab[column_num - 1, column_num - 1]
+                        * ab[column_num - 1, :]
+                )
+
+    for column_num in range(num_of_rows - 1, -1, -1):
+        x = ab[column_num, -1] / ab[column_num, column_num]
+        x_lst.insert(0, x)
+        for i in range(column_num - 1, -1, -1):
+            ab[i, -1] -= ab[i, column_num] * x
+
+    return np.asarray(x_lst)

utbot-python/samples/samples/numpy/example_linear_algebra.py

@@ -0,0 +1,24 @@
+import numpy as np
+
+
+def lower_upper_decomposition(table: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
+    rows, columns = np.shape(table)
+    if rows != columns:
+        msg = (
+            "'table' has to be of square shaped array but got a "
+            f"{rows}x{columns} array:\n{table}"
+        )
+        raise ValueError(msg)
+    lower = np.zeros((rows, columns))
+    upper = np.zeros((rows, columns))
+    for i in range(columns):
+        for j in range(i):
+            total = np.sum(lower[i, :i] * upper[:i, j])
+            if upper[j][j] == 0:
+                raise ArithmeticError("No LU decomposition exists")
+            lower[i][j] = (table[i][j] - total) / upper[j][j]
+        lower[i][i] = 1
+        for j in range(i, columns):
+            total = np.sum(lower[i, :i] * upper[:i, j])
+            upper[i][j] = table[i][j] - total
+    return lower, upper

utbot-python/samples/samples/numpy/example_matrices.py

@@ -0,0 +1,37 @@
+import numpy as np
+
+
+def _is_matrix_spd(matrix: np.ndarray) -> bool:
+    """
+    Returns True if input matrix is symmetric positive definite.
+    Returns False otherwise.
+
+    For a matrix to be SPD, all eigenvalues must be positive.
+
+    >>> import numpy as np
+    >>> matrix = np.array([
+    ... [4.12401784, -5.01453636, -0.63865857],
+    ... [-5.01453636, 12.33347422, -3.40493586],
+    ... [-0.63865857, -3.40493586,  5.78591885]])
+    >>> _is_matrix_spd(matrix)
+    True
+    >>> matrix = np.array([
+    ... [0.34634879,  1.96165514,  2.18277744],
+    ... [0.74074469, -1.19648894, -1.34223498],
+    ... [-0.7687067 ,  0.06018373, -1.16315631]])
+    >>> _is_matrix_spd(matrix)
+    False
+    """
+    # Ensure matrix is square.
+    assert np.shape(matrix)[0] == np.shape(matrix)[1]
+
+    # If matrix not symmetric, exit right away.
+    if np.allclose(matrix, matrix.T) is False:
+        return False
+
+    # Get eigenvalues and eignevectors for a symmetric matrix.
+    eigen_values, _ = np.linalg.eigh(matrix)
+
+    # Check sign of all eigenvalues.
+    # np.all returns a value of type np.bool_
+    return bool(np.all(eigen_values > 0))

utbot-python/samples/samples/numpy/example_matrix_rank.py

@@ -0,0 +1,76 @@
+def rank_of_matrix(matrix: list[list[int | float]]) -> int:
+    """
+    Finds the rank of a matrix.
+    Args:
+        matrix: The matrix as a list of lists.
+    Returns:
+        The rank of the matrix.
+    Example:
+    >>> matrix1 = [[1, 2, 3],
+    ...            [4, 5, 6],
+    ...            [7, 8, 9]]
+    >>> rank_of_matrix(matrix1)
+    2
+    >>> matrix2 = [[1, 0, 0],
+    ...            [0, 1, 0],
+    ...            [0, 0, 0]]
+    >>> rank_of_matrix(matrix2)
+    2
+    >>> matrix3 = [[1, 2, 3, 4],
+    ...            [5, 6, 7, 8],
+    ...            [9, 10, 11, 12]]
+    >>> rank_of_matrix(matrix3)
+    2
+    >>> rank_of_matrix([[2,3,-1,-1],
+    ...                [1,-1,-2,4],
+    ...                [3,1,3,-2],
+    ...                [6,3,0,-7]])
+    4
+    >>> rank_of_matrix([[2,1,-3,-6],
+    ...                [3,-3,1,2],
+    ...                [1,1,1,2]])
+    3
+    >>> rank_of_matrix([[2,-1,0],
+    ...                [1,3,4],
+    ...                [4,1,-3]])
+    3
+    >>> rank_of_matrix([[3,2,1],
+    ...                [-6,-4,-2]])
+    1
+    >>> rank_of_matrix([[],[]])
+    0
+    >>> rank_of_matrix([[1]])
+    1
+    >>> rank_of_matrix([[]])
+    0
+    """
+
+    rows = len(matrix)
+    columns = len(matrix[0])
+    rank = min(rows, columns)
+
+    for row in range(rank):
+        # Check if diagonal element is not zero
+        if matrix[row][row] != 0:
+            # Eliminate all the elements below the diagonal
+            for col in range(row + 1, rows):
+                multiplier = matrix[col][row] / matrix[row][row]
+                for i in range(row, columns):
+                    matrix[col][i] -= multiplier * matrix[row][i]
+        else:
+            # Find a non-zero diagonal element to swap rows
+            reduce = True
+            for i in range(row + 1, rows):
+                if matrix[i][row] != 0:
+                    matrix[row], matrix[i] = matrix[i], matrix[row]
+                    reduce = False
+                    break
+            if reduce:
+                rank -= 1
+                for i in range(rows):
+                    matrix[i][row] = matrix[i][rank]
+
+            # Reduce the row pointer by one to stay on the same row
+            row -= 1
+
+    return rank

utbot-python/samples/samples/numpy/example_norm.py

@@ -0,0 +1,23 @@
+import numpy as np
+from numpy import ndarray
+
+
+def norm_squared(vector: ndarray) -> float:
+    """
+    Return the squared second norm of vector
+    norm_squared(v) = sum(x * x for x in v)
+
+    Args:
+        vector (ndarray): input vector
+
+    Returns:
+        float: squared second norm of vector
+
+    >>> norm_squared([1, 2])
+    5
+    >>> norm_squared(np.asarray([1, 2]))
+    5
+    >>> norm_squared([0, 0])
+    0
+    """
+    return np.dot(vector, vector)

utbot-python/samples/samples/numpy/example_simple.py

@@ -0,0 +1,7 @@
+import numpy as np
+
+
+def function_to_test_default(a: np.ndarray):
+    if a.shape == (2, 1,):
+        return 2
+    return a.shape