PyCMatrix 1.0.0__py3-none-any.whl

matrix/__init__.py

@@ -0,0 +1,3 @@
+from .matrix import Matrix
+
+__all__ = ["Matrix"]

matrix/arithmetic.py

@@ -0,0 +1,216 @@
+from math import (
+    exp     as mathexp,
+    log     as mathlog,
+    sqrt    as mathsqrt,
+    sin     as mathsin,
+    cos     as mathcos,
+    tan     as mathtan,
+    sinh    as mathsinh,
+    cosh    as mathcosh,
+    tanh    as mathtanh
+
+    )
+import builtins
+
+def add(matrix, other):
+    if not matrix.isEqualOrder(other):
+        raise ValueError()
+
+    rows, cols = matrix.order
+
+    result = [
+        [
+            matrix.m[i][j] + other.m[i][j]
+            for j in range(cols)
+        ]
+        for i in range(rows)
+    ]
+
+    return type(matrix)(result)
+
+
+def subtract(matrix, other):
+    if not matrix.isEqualOrder(other):
+        raise ValueError()
+
+    rows, cols = matrix.order
+
+    result = [
+        [
+            matrix.m[i][j] - other.m[i][j]
+            for j in range(cols)
+        ]
+        for i in range(rows)
+    ]
+
+    return type(matrix)(result)
+
+
+def multiply(matrix, other):
+    # Scalar multiplication
+    if isinstance(other, (int, float, complex)):
+        return type(matrix)(
+            [
+                [matrix.m[i][j] * other for j in range(matrix.order[1])]
+                for i in range(matrix.order[0])
+            ]
+        )
+
+    if not matrix.isMultiplicable(other):
+        raise ValueError()
+
+    rows = matrix.order[0]
+    cols = other.order[1]
+
+    result = [
+        [
+            builtins.sum(
+                matrix.m[i][k] * other.m[k][j]
+                for k in range(matrix.order[1])
+            )
+            for j in range(cols)
+        ]
+        for i in range(rows)
+    ]
+
+    return type(matrix)(result)
+
+
+def elementwise_multiply(matrix, other):
+    if not matrix.isEqualOrder(other):
+        raise ValueError()
+
+    rows, cols = matrix.order
+
+    result = [
+        [
+            matrix.m[i][j] * other.m[i][j]
+            for j in range(cols)
+        ]
+        for i in range(rows)
+    ]
+
+    return type(matrix)(result)
+
+
+def divide(matrix, other):
+    if other == 0:
+        raise ZeroDivisionError("division by zero")
+
+    return type(matrix)(
+        [
+            [matrix.m[i][j] / other for j in range(matrix.order[1])]
+            for i in range(matrix.order[0])
+        ]
+    )
+
+
+def negate(matrix):
+    return type(matrix)(
+        [
+            [-matrix.m[i][j] for j in range(matrix.order[1])]
+            for i in range(matrix.order[0])
+        ]
+    )
+
+
+def power(matrix, raised_to):
+    if isinstance(raised_to, int) and raised_to > 0:
+        I = type(matrix).identity(matrix.order[0])
+
+        for _ in range(raised_to):
+            I = I * matrix
+
+        return I
+
+
+def apply(matrix, function):
+    rows, cols = matrix.order
+
+    result = [
+        [
+            function(matrix.m[i][j])
+            for j in range(cols)
+        ]
+        for i in range(rows)
+    ]
+
+    return type(matrix)(result)
+
+
+def exp(matrix):
+    return apply(matrix, mathexp)
+
+def log(matrix):
+    return apply(matrix, mathlog)
+
+def sqrt(matrix):
+    return apply(matrix, mathsqrt)
+
+def abs(matrix):
+    return apply(matrix, builtins.abs)
+
+def sin(matrix):
+    return apply(matrix, mathsin)
+
+def cos(matrix):
+    return apply(matrix, mathcos)
+
+def tan(matrix):
+    return apply(matrix, mathtan)
+
+def sinh(matrix):
+    return apply(matrix, mathsinh)
+
+def cosh(matrix):
+    return apply(matrix, mathcosh)
+
+def tanh(matrix):
+    return apply(matrix, mathtanh)
+
+def sum(matrix):
+    return builtins.sum(
+        matrix.m[i][j]
+        for i in range(matrix.order[0])
+        for j in range(matrix.order[1])
+    )
+
+def mean(matrix):
+    rows, cols = matrix.order
+    return matrix.sum() / (rows * cols)
+
+def min(matrix):
+    return builtins.min(
+        matrix.m[i][j]
+        for i in range(matrix.order[0])
+        for j in range(matrix.order[1])
+    )
+
+
+def max(matrix):
+    return builtins.max(
+        matrix.m[i][j]
+        for i in range(matrix.order[0])
+        for j in range(matrix.order[1])
+    )
+
+
+def prod(matrix):
+    result = 1
+
+    for i in range(matrix.order[0]):
+        for j in range(matrix.order[1]):
+            result *= matrix.m[i][j]
+
+    return result
+
+
+def norm_squared(matrix):
+    return builtins.sum(
+        matrix.m[i][j] ** 2
+        for i in range(matrix.order[0])
+        for j in range(matrix.order[1])
+    )
+
+def norm(matrix):
+    return mathsqrt(norm_squared(matrix))

matrix/bool.py

@@ -0,0 +1,91 @@
+def is_square(matrix):
+    rows, cols = matrix.order
+    return rows == cols
+
+
+def is_diagonal(matrix):
+    if not is_square(matrix):
+        return False
+
+    rows, cols = matrix.order
+
+    values = {
+        matrix.m[i][j]
+        for i in range(rows)
+        for j in range(cols)
+        if i != j
+    }
+
+    return values == {0}
+
+
+def is_column(matrix):
+    return matrix.order[1] == 1
+
+
+def is_row(matrix):
+    return matrix.order[0] == 1
+
+
+def is_scalar(matrix):
+    if not is_diagonal(matrix):
+        return False
+
+    rows, cols = matrix.order
+
+    values = {
+        matrix.m[i][j]
+        for i in range(rows)
+        for j in range(cols)
+        if i == j
+    }
+
+    return len(values) == 1
+
+
+def is_identity(matrix):
+    if not is_diagonal(matrix):
+        return False
+
+    rows, cols = matrix.order
+
+    values = {
+        matrix.m[i][j]
+        for i in range(rows)
+        for j in range(cols)
+        if i == j
+    }
+
+    return values == {1}
+
+
+def is_zero(matrix):
+    rows, cols = matrix.order
+
+    values = {
+        matrix.m[i][j]
+        for i in range(rows)
+        for j in range(cols)
+    }
+
+    return values == {0}
+
+
+def is_symmetric(matrix):
+    return matrix == matrix.transpose
+
+
+def is_skew_symmetric(matrix):
+    return -1 * matrix == matrix.transpose
+
+
+def is_invertible(matrix):
+    return matrix.isSqrMatrix and matrix.determinant != 0
+
+
+def is_singular(matrix):
+    return matrix.determinant == 0
+
+
+def is_non_singular(matrix):
+    return matrix.determinant != 0

matrix/constructors.py

@@ -0,0 +1,115 @@
+import random
+_rng = random.Random()
+
+def one(matrix_class, rows, cols=None):
+    if cols is None:
+        cols = rows
+
+    return matrix_class([
+        [1 for _ in range(cols)]
+        for _ in range(rows)
+    ])
+
+
+def zero(matrix_class, rows, cols=None):
+    if cols is None:
+        cols = rows
+
+    return matrix_class([
+        [0 for _ in range(cols)]
+        for _ in range(rows)
+    ])
+
+
+def identity(matrix_class, n):
+    return matrix_class([
+        [1 if i == j else 0 for j in range(n)]
+        for i in range(n)
+    ])
+
+
+def constant(matrix_class, rows, cols=None, value=0):
+    if cols is None:
+        cols = rows
+
+    return matrix_class([
+        [value for _ in range(cols)]
+        for _ in range(rows)
+    ])
+
+def diagonal(matrix_class, diag_list):
+    n = len(diag_list)
+
+    return matrix_class([
+        [diag_list[i] if i == j else 0 for j in range(n)]
+        for i in range(n)
+    ])
+
+def random_matrix(matrix_class, rows, cols=None, low=0, high=10):
+    if cols is None:
+        cols = rows
+
+    return matrix_class([
+        [random.randint(low, high) for _ in range(cols)]
+        for _ in range(rows)
+    ])
+
+def elementwise(matrix_class, rows, cols=None, func=lambda i, j: 0):
+    if cols is None:
+        cols = rows
+
+    return matrix_class([
+        [func(i, j) for j in range(cols)]
+        for i in range(rows)
+    ])
+
+def from_string(
+    matrix_class,
+    my_string,
+    dtype=float,
+    row_sep='\n'
+):
+    s = my_string.strip()
+
+    char_list = [
+        char
+        for char in s
+        if char.isdigit() or char in ' .+-j' + row_sep
+    ]
+
+    clean_string = "".join(char_list)
+
+    matrix_data = [
+        [
+            dtype(value)
+            for value in row.split()
+            if value
+        ]
+        for row in clean_string.split(row_sep)
+        if row.strip()
+    ]
+
+    return matrix_class(matrix_data)
+
+
+def random_uniform(cls, rows, cols=None, low=-1.0, high=1.0):
+    if cols is None:
+        cols = rows
+
+    if rows <= 0 or cols <= 0:
+        raise ValueError("matrix dimensions must be positive")
+
+    if low >= high:
+        raise ValueError("low must be less than high")
+
+    return cls([
+        [
+            _rng.uniform(low, high)
+            for _ in range(cols)
+        ]
+        for _ in range(rows)
+    ])
+
+def seed(value=None):
+    _rng.seed(value)
+

matrix/manipulation.py

@@ -0,0 +1,145 @@
+import copy
+
+def insert_row(matrix, row_mat):
+    cols = matrix.order[1]
+
+    if len(row_mat) == cols:
+        matrix.m.append(row_mat)
+    else:
+        raise ValueError(
+            "Length Error! length of rowMat is not suitable for this Matrix."
+        )
+
+
+def insert_col(matrix, col_mat):
+    rows = matrix.order[0]
+
+    if len(col_mat) == rows:
+        for i in range(rows):
+            matrix.m[i].append(col_mat[i])
+    else:
+        raise ValueError(
+            "Length Error! length of colMat is not suitable for this Matrix."
+        )
+
+
+def delete_row(matrix, row_index, inplace=False):
+    rows = matrix.order[0]
+    result = copy.deepcopy(matrix.m)
+
+    if 0 <= row_index < rows:
+        result.pop(row_index)
+
+        if inplace:
+            matrix.m = result
+        else:
+            return type(matrix)(result)
+    else:
+        raise ValueError(
+            f"Index Error! index out of range {row_index} for 0 to {rows}"
+        )
+
+
+def delete_col(matrix, col_index, inplace=False):
+    rows, cols = matrix.order
+    result = copy.deepcopy(matrix.m)
+
+    if 0 <= col_index < cols:
+        for row in range(rows):
+            result[row].pop(col_index)
+
+        if inplace:
+            matrix.m = result
+        else:
+            return type(matrix)(result)
+    else:
+        raise ValueError(
+            f"Index Error! index out of range {col_index} for 0 to {cols}"
+        )
+
+
+def get_row(matrix, row_index):
+    rows = matrix.order[0]
+
+    if 0 <= row_index < rows:
+        return matrix.m[row_index]
+    else:
+        raise ValueError()
+
+
+def get_col(matrix, col_index):
+    rows, cols = matrix.order
+
+    if 0 <= col_index < cols:
+        return [matrix.m[i][col_index] for i in range(rows)]
+    else:
+        raise ValueError()
+    
+def flatten(matrix):
+    result = [
+        value
+        for row in matrix.m
+        for value in row
+    ]
+
+    return type(matrix)([result])
+
+def reshape(matrix, rows, cols):
+    if rows <= 0 or cols <= 0:
+        raise ValueError("matrix dimensions must be positive")
+
+    if rows * cols != matrix.order[0] * matrix.order[1]:
+        raise ValueError(
+            "cannot reshape matrix: element count must remain unchanged"
+        )
+
+    values = [
+        value
+        for row in matrix.m
+        for value in row
+    ]
+
+    result = [
+        values[i * cols:(i + 1) * cols]
+        for i in range(rows)
+    ]
+
+    return type(matrix)(result)
+
+def swap_rows(matrix, row1, row2, inplace=False):
+    rows, cols = matrix.order
+
+    if not 0 <= row1 < rows:
+        raise IndexError("invalid row index")
+
+    if not 0 <= row2 < rows:
+        raise IndexError("invalid row index")
+
+    target = matrix if inplace else type(matrix)(copy.deepcopy(matrix.m))
+
+    target.m[row1], target.m[row2] = (
+        target.m[row2],
+        target.m[row1]
+    )
+
+    return target
+
+def swap_cols(matrix, col1, col2, inplace=False):
+    rows, cols = matrix.order
+
+    if not 0 <= col1 < cols:
+        raise IndexError("invalid column index")
+
+    if not 0 <= col2 < cols:
+        raise IndexError("invalid column index")
+
+    target = matrix if inplace else type(matrix)(copy.deepcopy(matrix.m))
+
+    for i in range(rows):
+        target.m[i][col1], target.m[i][col2] = (
+            target.m[i][col2],
+            target.m[i][col1]
+        )
+
+    return target
+