linear-algebra-toolkit 0.1.0__tar.gz

linear_algebra_toolkit-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Max B.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

linear_algebra_toolkit-0.1.0/MANIFEST.in

@@ -0,0 +1,4 @@
+include README.md
+include LICENSE
+recursive-include examples *.py
+recursive-include tests *.py

linear_algebra_toolkit-0.1.0/PKG-INFO

@@ -0,0 +1,140 @@
+Metadata-Version: 2.4
+Name: linear-algebra-toolkit
+Version: 0.1.0
+Summary: Educational pure-Python vector and matrix objects for linear algebra experiments.
+Author: Max B.
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/maxboro/linear-algebra-toolkit
+Project-URL: Repository, https://github.com/maxboro/linear-algebra-toolkit
+Project-URL: Issues, https://github.com/maxboro/linear-algebra-toolkit/issues
+Keywords: linear algebra,matrix,vector,education,math
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Education
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Linear Algebra Toolkit
+
+`linear-algebra-toolkit` is a small pure-Python package for experimenting with
+core linear algebra operations without NumPy or other numerical libraries.
+
+The codebase is intentionally simple and explicit. It is best suited for
+learning, reading through the implementation, and running small examples rather
+than for high-performance scientific computing.
+
+## Installation
+
+Install the published package from PyPI with:
+
+```bash
+python -m pip install linear-algebra-toolkit
+```
+
+If you are working from a local checkout, install the project in editable mode
+with:
+
+```bash
+python -m pip install -e .
+```
+
+## What the project provides
+
+- A `Vector` type for one-dimensional numeric data.
+- A `Matrix` type for two-dimensional numeric data.
+- Operator overloads for addition, subtraction, element-wise multiplication and
+  division, and linear algebra products through `@`.
+- A couple of small utility helpers used by the core objects.
+- No runtime dependencies outside the Python standard library.
+
+## Design goals
+
+- Keep the implementation readable and easy to inspect.
+- Avoid hidden abstractions so the math stays visible in plain Python.
+- Provide a compact codebase that is easy to test and extend.
+
+## Quick start
+
+Import the public objects directly from the package:
+
+```python
+from linear_algebra_toolkit import Matrix, Vector
+
+vector = Vector([3, 4])
+other = Vector([1, 2])
+matrix = Matrix([[1, 2], [3, 4]])
+
+print(vector + other)       # Vector([4, 6], n elements=2)
+print(vector @ other)       # 11
+print(matrix @ vector)      # Vector([11, 25], n elements=2)
+print(vector.normalized)    # Vector([0.6, 0.8], n elements=2)
+print(vector.as_row_matrix())
+```
+
+## Supported operations
+
+### Vector
+
+- Construction from a non-empty list of `int` and `float` values.
+- `+` and `-` with vectors of the same shape.
+- `+` and `-` with compatible row matrices (`1 x n`) and column matrices (`n x 1`).
+- `*` and `/` with scalars.
+- Element-wise `*` and `/` with another vector of the same shape.
+- `@` with another vector for the dot product.
+- `@` with a compatible matrix.
+- Norms through `norm(mode="euclidean" | "manhattan" | "max")`.
+- `normalized`, `abs(vector)`, `round(vector, ndigits)`,
+  `as_row_matrix()`, and `as_col_matrix()`.
+
+### Matrix
+
+- Construction from a non-empty rectangular list of rows.
+- `+` and `-` with matrices of the same shape.
+- `+` and `-` with compatible vectors represented as a row or column.
+- `*` and `/` with scalars.
+- Element-wise `*` and `/` with another matrix of the same shape.
+- `@` with another compatible matrix.
+- `@` with a compatible vector.
+- `T` for transpose, `norm()` for the Frobenius norm,
+  `get_row_elements()`, `get_col_elements()`, and `get_flatten_elements()`.
+
+## Behavior notes
+
+- Only plain Python `int` and `float` values are accepted.
+- Division goes through `zero_aware_division()`. With the current default
+  configuration, dividing by zero returns `0` instead of raising an exception.
+- The project is educational in scope and prioritizes clarity over performance.
+
+## Running tests
+
+From a repository checkout:
+
+```bash
+python -m unittest discover -s tests
+```
+
+## Repository examples
+
+The repository includes a few small scripts in `examples/` that demonstrate the
+API. From the repository root you can run them like this:
+
+```bash
+python -m examples.vector_plus_vector
+python -m examples.vector_dot_product
+python -m examples.matrix_dot_vector
+python -m examples.vector_as_matrix
+```
+
+## Repository layout
+
+- `linear_algebra_toolkit/objects.py` contains the `Vector` and `Matrix` implementations.
+- `linear_algebra_toolkit/utils.py` contains small shared helpers.
+- `tests/` contains the unit tests for the public behavior.
+- `examples/` contains runnable usage examples.

linear_algebra_toolkit-0.1.0/README.md

@@ -0,0 +1,117 @@
+# Linear Algebra Toolkit
+
+`linear-algebra-toolkit` is a small pure-Python package for experimenting with
+core linear algebra operations without NumPy or other numerical libraries.
+
+The codebase is intentionally simple and explicit. It is best suited for
+learning, reading through the implementation, and running small examples rather
+than for high-performance scientific computing.
+
+## Installation
+
+Install the published package from PyPI with:
+
+```bash
+python -m pip install linear-algebra-toolkit
+```
+
+If you are working from a local checkout, install the project in editable mode
+with:
+
+```bash
+python -m pip install -e .
+```
+
+## What the project provides
+
+- A `Vector` type for one-dimensional numeric data.
+- A `Matrix` type for two-dimensional numeric data.
+- Operator overloads for addition, subtraction, element-wise multiplication and
+  division, and linear algebra products through `@`.
+- A couple of small utility helpers used by the core objects.
+- No runtime dependencies outside the Python standard library.
+
+## Design goals
+
+- Keep the implementation readable and easy to inspect.
+- Avoid hidden abstractions so the math stays visible in plain Python.
+- Provide a compact codebase that is easy to test and extend.
+
+## Quick start
+
+Import the public objects directly from the package:
+
+```python
+from linear_algebra_toolkit import Matrix, Vector
+
+vector = Vector([3, 4])
+other = Vector([1, 2])
+matrix = Matrix([[1, 2], [3, 4]])
+
+print(vector + other)       # Vector([4, 6], n elements=2)
+print(vector @ other)       # 11
+print(matrix @ vector)      # Vector([11, 25], n elements=2)
+print(vector.normalized)    # Vector([0.6, 0.8], n elements=2)
+print(vector.as_row_matrix())
+```
+
+## Supported operations
+
+### Vector
+
+- Construction from a non-empty list of `int` and `float` values.
+- `+` and `-` with vectors of the same shape.
+- `+` and `-` with compatible row matrices (`1 x n`) and column matrices (`n x 1`).
+- `*` and `/` with scalars.
+- Element-wise `*` and `/` with another vector of the same shape.
+- `@` with another vector for the dot product.
+- `@` with a compatible matrix.
+- Norms through `norm(mode="euclidean" | "manhattan" | "max")`.
+- `normalized`, `abs(vector)`, `round(vector, ndigits)`,
+  `as_row_matrix()`, and `as_col_matrix()`.
+
+### Matrix
+
+- Construction from a non-empty rectangular list of rows.
+- `+` and `-` with matrices of the same shape.
+- `+` and `-` with compatible vectors represented as a row or column.
+- `*` and `/` with scalars.
+- Element-wise `*` and `/` with another matrix of the same shape.
+- `@` with another compatible matrix.
+- `@` with a compatible vector.
+- `T` for transpose, `norm()` for the Frobenius norm,
+  `get_row_elements()`, `get_col_elements()`, and `get_flatten_elements()`.
+
+## Behavior notes
+
+- Only plain Python `int` and `float` values are accepted.
+- Division goes through `zero_aware_division()`. With the current default
+  configuration, dividing by zero returns `0` instead of raising an exception.
+- The project is educational in scope and prioritizes clarity over performance.
+
+## Running tests
+
+From a repository checkout:
+
+```bash
+python -m unittest discover -s tests
+```
+
+## Repository examples
+
+The repository includes a few small scripts in `examples/` that demonstrate the
+API. From the repository root you can run them like this:
+
+```bash
+python -m examples.vector_plus_vector
+python -m examples.vector_dot_product
+python -m examples.matrix_dot_vector
+python -m examples.vector_as_matrix
+```
+
+## Repository layout
+
+- `linear_algebra_toolkit/objects.py` contains the `Vector` and `Matrix` implementations.
+- `linear_algebra_toolkit/utils.py` contains small shared helpers.
+- `tests/` contains the unit tests for the public behavior.
+- `examples/` contains runnable usage examples.

linear_algebra_toolkit-0.1.0/examples/matrix_dot_vector.py

@@ -0,0 +1,10 @@
+"""
+python -m examples.matrix_dot_vector
+"""
+from linear_algebra_toolkit import Vector, Matrix
+
+vec1 = Vector([5, 6])
+mat1 = Matrix([[1, 2], [3, 4]])
+
+print(vec1)
+print("mat1 @ vec1", mat1 @ vec1)

linear_algebra_toolkit-0.1.0/examples/matrix_plus_matrix.py

@@ -0,0 +1,21 @@
+"""
+python -m examples.matrix_plus_matrix
+"""
+from linear_algebra_toolkit import Matrix
+
+
+mat1 = Matrix([
+    [1, 2, 3],
+    [1, 2, 3]
+])
+mat2 = Matrix([
+    [1, 0, 3],
+    [1, 0, 3]
+])
+
+print("vec1 + mat1", mat1 + mat2)
+print("vec1 + mat2", mat1 + mat2)
+
+print("vec1 - mat1", mat1 - mat2)
+print("vec1 - mat2", mat1 - mat2)
+

linear_algebra_toolkit-0.1.0/examples/matrix_plus_vector.py

@@ -0,0 +1,14 @@
+"""
+python -m examples.matrix_plus_vector
+"""
+from linear_algebra_toolkit import Vector, Matrix
+
+vec1 = Vector([1, 2, 3])
+mat1 = Matrix([[1, 2, 3]])
+mat2 = Matrix([[1], [2], [3]])
+
+print("mat1 + vec1", mat1 + vec1)
+print("mat2 + vec1", mat2 + vec1)
+
+print("mat1 - vec1", mat1 - vec1)
+print("mat2 - vec1", mat2 - vec1)

linear_algebra_toolkit-0.1.0/examples/vector_as_matrix.py

@@ -0,0 +1,10 @@
+"""
+python -m examples.vector_as_matrix
+"""
+from linear_algebra_toolkit import Vector, Matrix
+
+vec1 = Vector([1, 2, 3])
+
+print("vec1", vec1)
+print("vec1 as_row_matrix", vec1.as_row_matrix())
+print("vec1 as_col_matrix", vec1.as_col_matrix())

linear_algebra_toolkit-0.1.0/examples/vector_dot_matrix.py

@@ -0,0 +1,9 @@
+"""
+python -m examples.vector_dot_matrix
+"""
+from linear_algebra_toolkit import Vector, Matrix
+
+vec1 = Vector([5, 6])
+mat1 = Matrix([[1, 2], [3, 4]])
+
+print("vec1 @ mat1", vec1 @ mat1)

linear_algebra_toolkit-0.1.0/examples/vector_dot_product.py

@@ -0,0 +1,11 @@
+"""
+python -m examples.vector_dot_product
+"""
+from linear_algebra_toolkit import Vector
+
+vec1 = Vector([1, 2, 3])
+vec2 = Vector([1, 0, 3])
+
+print("vec1", vec1)
+print("vec1", vec2)
+print("vec1 @ vec2", vec1 @ vec2)

linear_algebra_toolkit-0.1.0/examples/vector_minus_vector.py

@@ -0,0 +1,11 @@
+"""
+python -m examples.vector_minus_vector
+"""
+from linear_algebra_toolkit import Vector
+
+vec1 = Vector([1, 2, 3])
+vec2 = Vector([1, 0, 3])
+
+print("vec1", vec1)
+print("vec1", vec2)
+print("vec1 - vec2", vec1 - vec2)

linear_algebra_toolkit-0.1.0/examples/vector_plus_matrix.py

@@ -0,0 +1,14 @@
+"""
+python -m examples.vector_plus_matrix
+"""
+from linear_algebra_toolkit import Vector, Matrix
+
+vec1 = Vector([1, 2, 3])
+mat1 = Matrix([[1, 2, 3]])
+mat2 = Matrix([[1], [2], [3]])
+
+print("vec1 + mat1", vec1 + mat1)
+print("vec1 + mat2", vec1 + mat2)
+
+print("vec1 - mat1", vec1 - mat1)
+print("vec1 - mat2", vec1 - mat2)

linear_algebra_toolkit-0.1.0/examples/vector_plus_vector.py

@@ -0,0 +1,11 @@
+"""
+python -m examples.vector_plus_vector
+"""
+from linear_algebra_toolkit import Vector
+
+vec1 = Vector([1, 2, 3])
+vec2 = Vector([1, 0, 3])
+
+print("vec1", vec1)
+print("vec1", vec2)
+print("vec1 + vec2", vec1 + vec2)

linear_algebra_toolkit-0.1.0/linear_algebra_toolkit/__init__.py

@@ -0,0 +1 @@
+from .objects import Vector, Matrix

linear_algebra_toolkit-0.1.0/linear_algebra_toolkit/objects.py

@@ -0,0 +1,393 @@
+"""Core linear algebra objects used throughout the toolkit.
+
+The module exposes lightweight ``Vector`` and ``Matrix`` classes designed for
+educational use and implemented without third-party numerical libraries.
+"""
+
+import math
+from abc import ABC, abstractmethod
+from typing import Any, List
+
+from .utils import zero_aware_division, vector_dot_product
+
+
+class LAObject(ABC):
+    """Base class for objects that support additive arithmetic."""
+
+    @abstractmethod
+    def additive_operation(self, other, sign):
+        """Implement addition or subtraction against another object.
+
+        Args:
+            other: The value to combine with ``self``.
+            sign: ``1`` for addition and ``-1`` for subtraction.
+        """
+        pass
+
+    def __add__(self, other):
+        return self.additive_operation(other, sign = 1)
+
+    def __sub__(self, other):
+        return self.additive_operation(other, sign = -1)
+
+
+class Vector(LAObject):
+    """One-dimensional numeric object with basic linear algebra operations.
+
+    Vectors support:
+    - addition and subtraction with vectors of the same length
+    - addition and subtraction with ``1 x n`` or ``n x 1`` matrices
+    - scalar and element-wise multiplication and division
+    - dot products with vectors and multiplication by compatible matrices
+    - common norms, normalization, and conversion to matrix form
+    """
+
+    def __init__(self, vector_elements: List[Any]):
+        """Create a vector from a non-empty list of numeric values."""
+        if not isinstance(vector_elements, list):
+            raise TypeError("Should be a list")
+        if len(vector_elements) == 0:
+            raise ValueError("Empty vectors are not allowed")
+
+        for element in vector_elements:
+            if not isinstance(element, (int, float)):
+                raise TypeError("Should be an int or float")
+
+        self.n = len(vector_elements)
+        self._vector_elements = vector_elements
+
+    @property
+    def vector_elements(self):
+        """Return the stored vector elements."""
+        return self._vector_elements
+
+    def __repr__(self):
+        return f"Vector({self.vector_elements}, n elements={self.n})"
+
+    def _require_other_vector(self, other):
+        if not isinstance(other, Vector):
+            raise RuntimeError("Operation is possible only among Vectors")
+
+    def _require_similar_shape(self, other):
+        if self.n != other.n:
+            raise RuntimeError(f"Need to be with similar shapes {self.n} != {other.n}")
+
+    @staticmethod
+    def _create_none_list(n):
+        new_list = [None for _ in range(n)]
+        return new_list
+
+    @property
+    def shape(self):
+        """Return the vector shape as a one-item tuple."""
+        return (self.n,)
+
+    def __eq__(self, other):
+        if not isinstance(other, Vector):
+            return NotImplemented
+        return self.vector_elements == other.vector_elements
+
+    def __ne__(self, other):
+        if not isinstance(other, Vector):
+            return NotImplemented
+        return self.vector_elements != other.vector_elements
+
+    def __round__(self, ndigits: int = None):
+        result = self._create_none_list(self.n)
+        for n_ind in range(self.n):
+            result[n_ind] = round(self.vector_elements[n_ind], ndigits)
+        return Vector(result)
+
+    def additive_operation(self, other, sign):
+        if isinstance(other, Vector):
+            self._require_similar_shape(other)
+
+            result = self._create_none_list(self.n)
+            for n_ind in range(self.n):
+                result[n_ind] = self.vector_elements[n_ind] + sign * other.vector_elements[n_ind]
+            return Vector(result)
+        elif isinstance(other, Matrix):
+            if other.shape[0] == 1:
+                return self.as_row_matrix() + sign * other
+            elif other.shape[1] == 1:
+                return self.as_col_matrix() + sign * other
+            else:
+                raise ValueError(f"Operation cannot be performed for shape of other {other.shape}, must be mx1, 1xn")
+        else:
+            raise TypeError("Other should be Vector or Matrix")
+
+    def __mul__(self, other):
+        result = self._create_none_list(self.n)
+        if isinstance(other, (int, float)):
+            for n_ind in range(self.n):
+                result[n_ind] = self.vector_elements[n_ind] * other
+        elif isinstance(other, Vector):
+            # Hadamard product
+            self._require_similar_shape(other)
+            for n_ind in range(self.n):
+                result[n_ind] = self.vector_elements[n_ind] * other.vector_elements[n_ind]
+        else:
+            raise TypeError("Not supported")
+        return Vector(result)
+
+    def __truediv__(self, other):
+        result = self._create_none_list(self.n)
+        if isinstance(other, (int, float)):
+            for n_ind in range(self.n):
+                result[n_ind] = zero_aware_division(self.vector_elements[n_ind], other)
+        elif isinstance(other, Vector):
+            # element wise
+            self._require_similar_shape(other)
+            for n_ind in range(self.n):
+                result[n_ind] = zero_aware_division(self.vector_elements[n_ind], other.vector_elements[n_ind])
+        else:
+            raise TypeError("Not supported")
+        return Vector(result)
+
+    def __rmul__(self, other):
+        return self.__mul__(other)
+
+    def __matmul__(self, other):
+        if isinstance(other, Vector):
+            return vector_dot_product(self.vector_elements, other.vector_elements)
+        elif isinstance(other, Matrix):
+            if self.n != other.m:
+                raise ValueError(f"{self.n} != {other.m}")
+            result_elements = []
+            for ind in range(other.n):
+                matrix_row_elements = other.get_col_elements(ind)
+                row_dot_product = vector_dot_product(self.vector_elements, matrix_row_elements)
+                result_elements.append(row_dot_product)
+            return Vector(result_elements)
+        else:
+            raise TypeError("Other should be Matrix or Vector")
+
+    def norm(self, mode="euclidean"):
+        """Return the vector norm for the requested mode.
+
+        Supported modes are ``"euclidean"``, ``"manhattan"``, and ``"max"``.
+        """
+        if mode == "euclidean":
+            return math.sqrt(sum([x**2 for x in self.vector_elements]))
+        elif mode == "manhattan":
+            return sum([abs(x) for x in self.vector_elements])
+        elif mode == "max":
+            return max([abs(x) for x in self.vector_elements])
+        else:
+            raise ValueError("Mode can be 'euclidean' or 'manhattan' or 'max'")
+            
+
+    def __len__(self):
+        return len(self.vector_elements)
+
+    @property
+    def normalized(self):
+        """Return a copy scaled to have Euclidean norm equal to ``1``."""
+        current_norm = self.norm(mode="euclidean")
+        if current_norm == 0:
+            raise ValueError("Cannot normalize zero vector")
+        norm_coef = 1 / current_norm
+        return self.__mul__(norm_coef)
+
+    def __abs__(self):
+        new_vector_elements = [abs(x) for x in self.vector_elements]
+        return Vector(new_vector_elements)
+
+    def as_row_matrix(self) -> "Matrix":
+        """Return the vector as a ``1 x n`` matrix."""
+        return Matrix([self.vector_elements.copy()])
+    
+    def as_col_matrix(self) -> "Matrix":
+        """Return the vector as a ``n x 1`` matrix."""
+        matrix_elements = [[element] for element in self.vector_elements]
+        return Matrix(matrix_elements)
+
+
+class Matrix(LAObject):
+    """Two-dimensional numeric object with basic matrix operations.
+
+    Matrices support:
+    - addition and subtraction with matrices of the same shape
+    - addition and subtraction with compatible row or column vectors
+    - scalar and element-wise multiplication and division
+    - matrix-matrix and matrix-vector multiplication
+    - transpose, flattening, absolute value, and the Frobenius norm
+    """
+
+    def __init__(self, matrix_elements: List[List[Any]]):
+        """Create a matrix from a non-empty rectangular list of rows."""
+        if not isinstance(matrix_elements, list):
+            raise TypeError("Should be a list")
+        if len(matrix_elements) == 0:
+            raise ValueError("Empty matrixes are not allowed")
+
+        n = None
+        for row in matrix_elements:
+            if not isinstance(row, list):
+                raise TypeError("Should be a list")
+            if len(row) == 0:
+                raise ValueError("Empty matrix are not allowed")
+            for element in row:
+                if not isinstance(element, (int, float)):
+                    raise TypeError("Should be an int or float")
+            if n is None:
+                n = len(row)
+            elif n != len(row):
+                raise ValueError("incorrect shape")
+
+        self.m = len(matrix_elements)
+        self.n = n
+        self._matrix_elements = matrix_elements
+
+    @property
+    def matrix_elements(self):
+        """Return the stored matrix elements."""
+        return self._matrix_elements
+
+    def __repr__(self):
+        return f"Matrix({self.matrix_elements}, shape={self.m}x{self.n})"
+
+    def _require_other_matrix(self, other):
+        if not isinstance(other, Matrix):
+            raise RuntimeError("Operation is possible only among Matrixes")
+
+    def _require_similar_shape(self, other):
+        if self.shape != other.shape:
+            raise RuntimeError(f"Need to be with similar shapes {self.shape} != {other.shape}")
+
+    @staticmethod
+    def _create_none_list(m, n):
+        new_list = [[None for _ in range(n)] for _ in range(m)]
+        return new_list
+
+    @property
+    def shape(self):
+        """Return the matrix shape as ``(rows, columns)``."""
+        return (self.m, self.n)
+
+    def __eq__(self, other):
+        if not isinstance(other, Matrix):
+            return NotImplemented
+        return self.matrix_elements == other.matrix_elements
+
+    def __ne__(self, other):
+        if not isinstance(other, Matrix):
+            return NotImplemented
+        return self.matrix_elements != other.matrix_elements
+
+    def __round__(self, ndigits: int = None):
+        result = self._create_none_list(self.m, self.n)
+        for m_ind in range(self.m):
+            for n_ind in range(self.n):
+                result[m_ind][n_ind] = round(self.matrix_elements[m_ind][n_ind], ndigits)
+        return Matrix(result)
+    
+    def additive_operation(self, other, sign):
+        if isinstance(other, Vector):
+            return sign * other + self
+        elif isinstance(other, Matrix):
+            self._require_similar_shape(other)
+
+            result = self._create_none_list(self.m, self.n)
+            for m_ind in range(self.m):
+                for n_ind in range(self.n):
+                    result[m_ind][n_ind] = self.matrix_elements[m_ind][n_ind] + sign * other.matrix_elements[m_ind][n_ind]
+            return Matrix(result)
+        else:
+            raise TypeError("Other should be Vector or Matrix")
+
+    def __mul__(self, other):
+        result = self._create_none_list(self.m, self.n)
+        if isinstance(other, (int, float)):
+            for m_ind in range(self.m):
+                for n_ind in range(self.n):
+                    result[m_ind][n_ind] = self.matrix_elements[m_ind][n_ind] * other
+        elif isinstance(other, Matrix):
+            # Hadamard product
+            self._require_similar_shape(other)
+            for m_ind in range(self.m):
+                for n_ind in range(self.n):
+                    result[m_ind][n_ind] = self.matrix_elements[m_ind][n_ind] * other.matrix_elements[m_ind][n_ind]
+        else:
+            raise TypeError("Not supported")
+        return Matrix(result)
+
+    def __truediv__(self, other):
+        result = self._create_none_list(self.m, self.n)
+        if isinstance(other, (int, float)):
+            for m_ind in range(self.m):
+                for n_ind in range(self.n):
+                    result[m_ind][n_ind] = zero_aware_division(self.matrix_elements[m_ind][n_ind], other)
+        elif isinstance(other, Matrix):
+            self._require_similar_shape(other)
+            for m_ind in range(self.m):
+                for n_ind in range(self.n):
+                    result[m_ind][n_ind] = zero_aware_division(self.matrix_elements[m_ind][n_ind], other.matrix_elements[m_ind][n_ind])
+        else:
+            raise TypeError("Not supported")
+        return Matrix(result)
+
+    def __rmul__(self, other):
+        return self.__mul__(other)
+
+    def get_row_elements(self, index: int) -> list:
+        """Return a copy of the row at ``index``."""
+        return self.matrix_elements[index].copy()
+
+    def get_col_elements(self, index: int) -> list:
+        """Return a copy of the column at ``index``."""
+        col_elements = []
+        for row in self.matrix_elements:
+            col_elements.append(row[index])
+        return col_elements
+
+    def __matmul__(self, other):
+        if isinstance(other, Matrix):
+            if self.n != other.m:
+                raise RuntimeError(f"Incompatible shape {self.n} != {other.m}")
+
+            result = self._create_none_list(self.m, other.n)
+            for m_ind in range(self.m):
+                for n_ind in range(other.n):
+                    self_row = self.get_row_elements(m_ind)
+                    other_col = other.get_col_elements(n_ind)
+                    dot_product = vector_dot_product(self_row, other_col)
+                    result[m_ind][n_ind] = dot_product
+            return Matrix(result)
+        elif isinstance(other, Vector):
+            if self.n != other.n:
+                raise ValueError(f"{self.n} != {other.n}")
+            result_elements = []
+            for self_row in self.matrix_elements:
+                row_dot_product = vector_dot_product(self_row, other.vector_elements)
+                result_elements.append(row_dot_product)
+            return Vector(result_elements)
+        else:
+            raise TypeError("Other should be Matrix or Vector")
+
+    def get_flatten_elements(self) -> list:
+        """Return the matrix elements flattened in row-major order."""
+        elements = []
+        for row in self.matrix_elements:
+            for value in row:
+                elements.append(value)
+        return elements
+
+    def norm(self):
+        """Return the Frobenius norm of the matrix."""
+        flatten = self.get_flatten_elements()
+        result = math.sqrt(sum([x**2 for x in flatten]))
+        return result
+
+    @property
+    def T(self):
+        """Return the transpose of the matrix."""
+        result = self._create_none_list(self.n, self.m)
+        for m_ind in range(self.m):
+            for n_ind in range(self.n):
+                result[n_ind][m_ind] = self.matrix_elements[m_ind][n_ind]
+        return Matrix(result)
+
+    def __abs__(self):
+        new_vector_elements = [[abs(x) for x in row] for row in self.matrix_elements]
+        return Matrix(new_vector_elements)

linear_algebra_toolkit-0.1.0/linear_algebra_toolkit/utils.py

@@ -0,0 +1,26 @@
+"""Utility helpers shared by the vector and matrix implementations."""
+
+ZERO_DIVISION_TO_ZERO = True
+
+
+def zero_aware_division(dividend, divisor):
+    """Divide two numbers while handling zero divisors consistently.
+
+    When ``ZERO_DIVISION_TO_ZERO`` is enabled, dividing by zero returns ``0``
+    instead of raising ``ZeroDivisionError``.
+    """
+    if divisor == 0 and ZERO_DIVISION_TO_ZERO:
+        return 0
+    else:
+        return dividend / divisor
+
+
+def vector_dot_product(vec1: list, vec2: list):
+    """Return the dot product of two equally sized numeric sequences."""
+    if len(vec1) != len(vec2):
+        raise RuntimeError(f"Vector len should be equal {len(vec1)} != {len(vec2)}")
+
+    result = 0
+    for ind in range(len(vec1)):
+        result += vec1[ind] * vec2[ind]
+    return result

linear_algebra_toolkit-0.1.0/linear_algebra_toolkit.egg-info/PKG-INFO

@@ -0,0 +1,140 @@
+Metadata-Version: 2.4
+Name: linear-algebra-toolkit
+Version: 0.1.0
+Summary: Educational pure-Python vector and matrix objects for linear algebra experiments.
+Author: Max B.
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/maxboro/linear-algebra-toolkit
+Project-URL: Repository, https://github.com/maxboro/linear-algebra-toolkit
+Project-URL: Issues, https://github.com/maxboro/linear-algebra-toolkit/issues
+Keywords: linear algebra,matrix,vector,education,math
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Education
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Linear Algebra Toolkit
+
+`linear-algebra-toolkit` is a small pure-Python package for experimenting with
+core linear algebra operations without NumPy or other numerical libraries.
+
+The codebase is intentionally simple and explicit. It is best suited for
+learning, reading through the implementation, and running small examples rather
+than for high-performance scientific computing.
+
+## Installation
+
+Install the published package from PyPI with:
+
+```bash
+python -m pip install linear-algebra-toolkit
+```
+
+If you are working from a local checkout, install the project in editable mode
+with:
+
+```bash
+python -m pip install -e .
+```
+
+## What the project provides
+
+- A `Vector` type for one-dimensional numeric data.
+- A `Matrix` type for two-dimensional numeric data.
+- Operator overloads for addition, subtraction, element-wise multiplication and
+  division, and linear algebra products through `@`.
+- A couple of small utility helpers used by the core objects.
+- No runtime dependencies outside the Python standard library.
+
+## Design goals
+
+- Keep the implementation readable and easy to inspect.
+- Avoid hidden abstractions so the math stays visible in plain Python.
+- Provide a compact codebase that is easy to test and extend.
+
+## Quick start
+
+Import the public objects directly from the package:
+
+```python
+from linear_algebra_toolkit import Matrix, Vector
+
+vector = Vector([3, 4])
+other = Vector([1, 2])
+matrix = Matrix([[1, 2], [3, 4]])
+
+print(vector + other)       # Vector([4, 6], n elements=2)
+print(vector @ other)       # 11
+print(matrix @ vector)      # Vector([11, 25], n elements=2)
+print(vector.normalized)    # Vector([0.6, 0.8], n elements=2)
+print(vector.as_row_matrix())
+```
+
+## Supported operations
+
+### Vector
+
+- Construction from a non-empty list of `int` and `float` values.
+- `+` and `-` with vectors of the same shape.
+- `+` and `-` with compatible row matrices (`1 x n`) and column matrices (`n x 1`).
+- `*` and `/` with scalars.
+- Element-wise `*` and `/` with another vector of the same shape.
+- `@` with another vector for the dot product.
+- `@` with a compatible matrix.
+- Norms through `norm(mode="euclidean" | "manhattan" | "max")`.
+- `normalized`, `abs(vector)`, `round(vector, ndigits)`,
+  `as_row_matrix()`, and `as_col_matrix()`.
+
+### Matrix
+
+- Construction from a non-empty rectangular list of rows.
+- `+` and `-` with matrices of the same shape.
+- `+` and `-` with compatible vectors represented as a row or column.
+- `*` and `/` with scalars.
+- Element-wise `*` and `/` with another matrix of the same shape.
+- `@` with another compatible matrix.
+- `@` with a compatible vector.
+- `T` for transpose, `norm()` for the Frobenius norm,
+  `get_row_elements()`, `get_col_elements()`, and `get_flatten_elements()`.
+
+## Behavior notes
+
+- Only plain Python `int` and `float` values are accepted.
+- Division goes through `zero_aware_division()`. With the current default
+  configuration, dividing by zero returns `0` instead of raising an exception.
+- The project is educational in scope and prioritizes clarity over performance.
+
+## Running tests
+
+From a repository checkout:
+
+```bash
+python -m unittest discover -s tests
+```
+
+## Repository examples
+
+The repository includes a few small scripts in `examples/` that demonstrate the
+API. From the repository root you can run them like this:
+
+```bash
+python -m examples.vector_plus_vector
+python -m examples.vector_dot_product
+python -m examples.matrix_dot_vector
+python -m examples.vector_as_matrix
+```
+
+## Repository layout
+
+- `linear_algebra_toolkit/objects.py` contains the `Vector` and `Matrix` implementations.
+- `linear_algebra_toolkit/utils.py` contains small shared helpers.
+- `tests/` contains the unit tests for the public behavior.
+- `examples/` contains runnable usage examples.

linear_algebra_toolkit-0.1.0/linear_algebra_toolkit.egg-info/SOURCES.txt

@@ -0,0 +1,22 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+examples/matrix_dot_vector.py
+examples/matrix_plus_matrix.py
+examples/matrix_plus_vector.py
+examples/vector_as_matrix.py
+examples/vector_dot_matrix.py
+examples/vector_dot_product.py
+examples/vector_minus_vector.py
+examples/vector_plus_matrix.py
+examples/vector_plus_vector.py
+linear_algebra_toolkit/__init__.py
+linear_algebra_toolkit/objects.py
+linear_algebra_toolkit/utils.py
+linear_algebra_toolkit.egg-info/PKG-INFO
+linear_algebra_toolkit.egg-info/SOURCES.txt
+linear_algebra_toolkit.egg-info/dependency_links.txt
+linear_algebra_toolkit.egg-info/top_level.txt
+tests/test_objects.py
+tests/test_utils.py

linear_algebra_toolkit-0.1.0/linear_algebra_toolkit.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

linear_algebra_toolkit-0.1.0/linear_algebra_toolkit.egg-info/top_level.txt

@@ -0,0 +1 @@
+linear_algebra_toolkit

linear_algebra_toolkit-0.1.0/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["setuptools>=77.0.3"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "linear-algebra-toolkit"
+version = "0.1.0"
+description = "Educational pure-Python vector and matrix objects for linear algebra experiments."
+readme = "README.md"
+requires-python = ">=3.8"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [
+    {name = "Max B."}
+]
+keywords = ["linear algebra", "matrix", "vector", "education", "math"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Education",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Topic :: Education",
+    "Topic :: Scientific/Engineering :: Mathematics",
+]
+dependencies = []
+
+[project.urls]
+Homepage = "https://github.com/maxboro/linear-algebra-toolkit"
+Repository = "https://github.com/maxboro/linear-algebra-toolkit"
+Issues = "https://github.com/maxboro/linear-algebra-toolkit/issues"
+
+[tool.setuptools]
+packages = ["linear_algebra_toolkit"]

linear_algebra_toolkit-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

linear_algebra_toolkit-0.1.0/tests/test_objects.py

@@ -0,0 +1,205 @@
+import math
+import unittest
+
+from linear_algebra_toolkit import Matrix, Vector
+
+
+class VectorTests(unittest.TestCase):
+    def test_vector_constructor_validates_input(self):
+        with self.assertRaises(TypeError):
+            Vector((1, 2, 3))
+
+        with self.assertRaises(ValueError):
+            Vector([])
+
+        with self.assertRaises(TypeError):
+            Vector([1, "x"])
+
+    def test_vector_shape_len_round_abs_and_matrix_views(self):
+        vector = Vector([1.234, -2.345, 3.456])
+
+        self.assertEqual(vector.shape, (3,))
+        self.assertEqual(len(vector), 3)
+        self.assertEqual(round(vector, 2), Vector([1.23, -2.35, 3.46]))
+        self.assertEqual(abs(vector), Vector([1.234, 2.345, 3.456]))
+        self.assertEqual(vector.as_row_matrix(), Matrix([[1.234, -2.345, 3.456]]))
+        self.assertEqual(vector.as_col_matrix(), Matrix([[1.234], [-2.345], [3.456]]))
+
+    def test_vector_add_and_subtract_vectors(self):
+        left = Vector([1, 2, 3])
+        right = Vector([4, 5, 6])
+
+        self.assertEqual(left + right, Vector([5, 7, 9]))
+        self.assertEqual(left - right, Vector([-3, -3, -3]))
+
+    def test_vector_add_and_subtract_row_and_column_matrices(self):
+        vector = Vector([1, 2, 3])
+        row_matrix = Matrix([[4, 5, 6]])
+        col_matrix = Matrix([[4], [5], [6]])
+
+        self.assertEqual(vector + row_matrix, Matrix([[5, 7, 9]]))
+        self.assertEqual(vector - row_matrix, Matrix([[-3, -3, -3]]))
+        self.assertEqual(vector + col_matrix, Matrix([[5], [7], [9]]))
+        self.assertEqual(vector - col_matrix, Matrix([[-3], [-3], [-3]]))
+
+    def test_vector_add_rejects_invalid_operands(self):
+        with self.assertRaises(RuntimeError):
+            Vector([1, 2]) + Vector([1])
+
+        with self.assertRaises(ValueError):
+            Vector([1, 2]) + Matrix([[1, 2], [3, 4]])
+
+        with self.assertRaises(TypeError):
+            Vector([1, 2]) + 1
+
+    def test_vector_multiply_and_divide(self):
+        left = Vector([2, 4, 6])
+        right = Vector([1, 2, 3])
+        divisor = Vector([2, 0, 3])
+
+        self.assertEqual(left * 2, Vector([4, 8, 12]))
+        self.assertEqual(3 * right, Vector([3, 6, 9]))
+        self.assertEqual(left * right, Vector([2, 8, 18]))
+        self.assertEqual(left / 2, Vector([1.0, 2.0, 3.0]))
+        self.assertEqual(left / divisor, Vector([1.0, 0, 2.0]))
+
+        with self.assertRaises(TypeError):
+            left * Matrix([[1, 2, 3]])
+
+    def test_vector_dot_products_and_matrix_product(self):
+        vector = Vector([5, 6])
+        other_vector = Vector([1, 0])
+        matrix = Matrix([[1, 2], [3, 4]])
+
+        self.assertEqual(vector @ other_vector, 5)
+        self.assertEqual(vector @ matrix, Vector([23, 34]))
+
+    def test_vector_matmul_rejects_incompatible_shapes(self):
+        with self.assertRaises(ValueError):
+            Vector([1, 2]) @ Matrix([[1, 2, 3]])
+
+        with self.assertRaises(TypeError):
+            Vector([1, 2]) @ 1
+
+    def test_vector_norms_and_normalized(self):
+        vector = Vector([3, 4])
+        normalized = vector.normalized
+
+        self.assertEqual(vector.norm(), 5.0)
+        self.assertEqual(vector.norm(mode="manhattan"), 7)
+        self.assertEqual(vector.norm(mode="max"), 4)
+        self.assertAlmostEqual(normalized.vector_elements[0], 0.6)
+        self.assertAlmostEqual(normalized.vector_elements[1], 0.8)
+        self.assertAlmostEqual(normalized.norm(), 1.0)
+
+        with self.assertRaises(ValueError):
+            vector.norm(mode="unknown")
+
+        with self.assertRaises(ValueError):
+            Vector([0, 0]).normalized
+
+
+class MatrixTests(unittest.TestCase):
+    def test_matrix_constructor_validates_shape(self):
+        with self.assertRaises(TypeError):
+            Matrix((1, 2))
+
+        with self.assertRaises(ValueError):
+            Matrix([])
+
+        with self.assertRaises(TypeError):
+            Matrix([1, 2])
+
+        with self.assertRaises(ValueError):
+            Matrix([[1, 2], []])
+
+        with self.assertRaises(ValueError):
+            Matrix([[1, 2], [3]])
+
+    def test_matrix_shape_round_abs_transpose_and_flatten(self):
+        matrix = Matrix([[1.234, -2.345], [-3.456, 4.567]])
+
+        self.assertEqual(matrix.shape, (2, 2))
+        self.assertEqual(round(matrix, 2), Matrix([[1.23, -2.35], [-3.46, 4.57]]))
+        self.assertEqual(abs(matrix), Matrix([[1.234, 2.345], [3.456, 4.567]]))
+        self.assertEqual(matrix.T, Matrix([[1.234, -3.456], [-2.345, 4.567]]))
+        self.assertEqual(matrix.get_flatten_elements(), [1.234, -2.345, -3.456, 4.567])
+
+    def test_matrix_add_and_subtract_matrices(self):
+        left = Matrix([[1, 2], [3, 4]])
+        right = Matrix([[5, 6], [7, 8]])
+
+        self.assertEqual(left + right, Matrix([[6, 8], [10, 12]]))
+        self.assertEqual(left - right, Matrix([[-4, -4], [-4, -4]]))
+
+    def test_matrix_add_and_subtract_vectors(self):
+        row_matrix = Matrix([[1, 2, 3]])
+        col_matrix = Matrix([[1], [2], [3]])
+        vector = Vector([4, 5, 6])
+
+        self.assertEqual(row_matrix + vector, Matrix([[5, 7, 9]]))
+        self.assertEqual(row_matrix - vector, Matrix([[-3, -3, -3]]))
+        self.assertEqual(col_matrix + vector, Matrix([[5], [7], [9]]))
+        self.assertEqual(col_matrix - vector, Matrix([[-3], [-3], [-3]]))
+
+    def test_matrix_add_rejects_invalid_shapes(self):
+        with self.assertRaises(RuntimeError):
+            Matrix([[1, 2]]) + Matrix([[1], [2]])
+
+        with self.assertRaises(ValueError):
+            Matrix([[1, 2], [3, 4]]) + Vector([1, 2])
+
+        with self.assertRaises(TypeError):
+            Matrix([[1, 2]]) + 1
+
+    def test_matrix_multiply_and_divide(self):
+        left = Matrix([[2, 4], [6, 8]])
+        right = Matrix([[1, 2], [3, 4]])
+        divisor = Matrix([[2, 0], [3, 4]])
+
+        self.assertEqual(left * 2, Matrix([[4, 8], [12, 16]]))
+        self.assertEqual(3 * right, Matrix([[3, 6], [9, 12]]))
+        self.assertEqual(left * right, Matrix([[2, 8], [18, 32]]))
+        self.assertEqual(left / 2, Matrix([[1.0, 2.0], [3.0, 4.0]]))
+        self.assertEqual(left / divisor, Matrix([[1.0, 0], [2.0, 2.0]]))
+
+        with self.assertRaises(TypeError):
+            left / Vector([1, 2])
+
+    def test_matrix_products(self):
+        left = Matrix([[1, 2], [3, 4]])
+        right = Matrix([[5, 6], [7, 8]])
+        vector = Vector([5, 6])
+
+        self.assertEqual(left @ right, Matrix([[19, 22], [43, 50]]))
+        self.assertEqual(left @ vector, Vector([17, 39]))
+
+    def test_matrix_matmul_rejects_incompatible_shapes(self):
+        with self.assertRaises(RuntimeError):
+            Matrix([[1, 2]]) @ Matrix([[1, 2]])
+
+        with self.assertRaises(ValueError):
+            Matrix([[1, 2, 3]]) @ Vector([1, 2])
+
+        with self.assertRaises(TypeError):
+            Matrix([[1, 2]]) @ 1
+
+    def test_matrix_row_and_column_access_return_copies(self):
+        matrix = Matrix([[1, 2], [3, 4]])
+
+        row = matrix.get_row_elements(0)
+        column = matrix.get_col_elements(1)
+
+        row[0] = 99
+        column[0] = 88
+
+        self.assertEqual(matrix, Matrix([[1, 2], [3, 4]]))
+
+    def test_matrix_norm(self):
+        matrix = Matrix([[1, 2], [3, 4]])
+
+        self.assertAlmostEqual(matrix.norm(), math.sqrt(30))
+
+
+if __name__ == "__main__":
+    unittest.main()

linear_algebra_toolkit-0.1.0/tests/test_utils.py

@@ -0,0 +1,19 @@
+import unittest
+
+from linear_algebra_toolkit.utils import zero_aware_division, vector_dot_product
+
+
+class UtilsTests(unittest.TestCase):
+    def test_zero_aware_division_returns_zero_for_zero_divisor(self):
+        self.assertEqual(zero_aware_division(5, 0), 0)
+        self.assertEqual(zero_aware_division(9, 3), 3)
+
+    def test_vector_dot_product(self):
+        self.assertEqual(vector_dot_product([1, 2, 3], [4, 5, 6]), 32)
+
+        with self.assertRaises(RuntimeError):
+            vector_dot_product([1, 2], [1])
+
+
+if __name__ == "__main__":
+    unittest.main()