rawmath 0.1.0__tar.gz

rawmath-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 PeagazinhoAI
+
+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.

rawmath-0.1.0/PKG-INFO

@@ -0,0 +1,60 @@
+Metadata-Version: 2.4
+Name: rawmath
+Version: 0.1.0
+Summary: A from-scratch mathematics library for Python.
+Author: PeagazinhoAI
+License-Expression: MIT
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# RawMath
+
+A from-scratch mathematics library for Python.
+
+RawMath implements mathematical structures and operations directly from their
+definitions, with a focus on clarity, independence, and understanding the
+mathematics behind the implementation.
+
+## Requirements
+
+- Python 3.10+
+
+## Installation
+
+RawMath is currently under development.
+
+For local development:
+
+    python -m pip install -e .
+
+## Quick Start
+
+    from rawmath import Matrix
+
+    A = Matrix([
+        [1, 2],
+        [3, 4],
+    ])
+
+    B = Matrix([
+        [5, 6],
+        [7, 8],
+    ])
+
+    print(A + B)
+
+## Status
+
+RawMath is currently in pre-alpha development. The API may change between
+versions.
+
+## License
+
+RawMath is licensed under the MIT License.

rawmath-0.1.0/README.md

@@ -0,0 +1,44 @@
+# RawMath
+
+A from-scratch mathematics library for Python.
+
+RawMath implements mathematical structures and operations directly from their
+definitions, with a focus on clarity, independence, and understanding the
+mathematics behind the implementation.
+
+## Requirements
+
+- Python 3.10+
+
+## Installation
+
+RawMath is currently under development.
+
+For local development:
+
+    python -m pip install -e .
+
+## Quick Start
+
+    from rawmath import Matrix
+
+    A = Matrix([
+        [1, 2],
+        [3, 4],
+    ])
+
+    B = Matrix([
+        [5, 6],
+        [7, 8],
+    ])
+
+    print(A + B)
+
+## Status
+
+RawMath is currently in pre-alpha development. The API may change between
+versions.
+
+## License
+
+RawMath is licensed under the MIT License.

rawmath-0.1.0/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ['setuptools>=77']
+build-backend = 'setuptools.build_meta'
+
+[project]
+name = 'rawmath'
+version = '0.1.0'
+description = 'A from-scratch mathematics library for Python.'
+readme = 'README.md'
+requires-python = '>=3.10'
+license = 'MIT'
+
+authors = [
+    { name = 'PeagazinhoAI' }
+]
+
+dependencies = []
+
+classifiers = [
+    'Development Status :: 2 - Pre-Alpha',
+    'Intended Audience :: Developers',
+    'Intended Audience :: Science/Research',
+    'Programming Language :: Python :: 3',
+    'Topic :: Scientific/Engineering :: Mathematics',
+]
+
+[tool.setuptools.packages.find]
+where = ['src']

rawmath-0.1.0/setup.cfg

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

rawmath-0.1.0/src/rawmath/__init__.py

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

rawmath-0.1.0/src/rawmath/models/matrix.py

@@ -0,0 +1,251 @@
+from __future__ import annotations
+from typing import Any
+
+from ..types.functions import OrderedPair
+from ..types.matrix import MatrixData
+
+
+class Matrix:
+    def __init__(
+        self,
+        data: MatrixData | OrderedPair,
+        edgeitems: int = 3,
+        threshold: int = 1000
+    ) -> None:
+        self.edgeitems = edgeitems
+        self.threshold = threshold
+
+        self._ignite(data=data)
+        self._class_name = type(self).__name__
+
+    def __str__(self) -> str:
+        return self._format_matrix()
+
+    def __repr__(self) -> str:
+        return self._format_matrix(debug=True)
+
+    def __setitem__(
+        self, key: tuple[int, int], value: Any
+    ) -> None:
+        i, j = key
+
+        self._matrix[i][j] = value
+
+    def __getitem__(self, key: int) -> list[Any]:
+        return self._matrix[key]
+
+    def __eq__(self, value: Matrix) -> bool:
+        return self._matrix == value._matrix
+
+    def __ne__(self, value: Matrix) -> bool:
+        return self._matrix != value._matrix
+
+    def __neg__(self) -> Matrix:
+        result = [
+            [-element for element in row] for row in self._matrix
+        ]
+
+        return Matrix(result)
+
+    def __add__(self, other: Matrix) -> Matrix:
+        if self.m != other.m or self.n != other.n:
+            raise ValueError('matrices must have the same dimensions')
+
+        result = [
+            [x + y for x, y in zip(row_a, row_b)]
+            for row_a, row_b in zip(self._matrix, other._matrix)
+        ]
+
+        return Matrix(result)
+
+    def __sub__(self, other: Matrix) -> Matrix:
+        return self + (-other)
+
+    def _ignite(self, data: MatrixData | OrderedPair) -> None:
+        if isinstance(data, tuple):
+            self.m, self.n = data
+
+            self._matrix = [
+                [0.0 for _ in range(self.n)]
+                for _ in range(self.m)
+            ]
+
+            return
+
+        rows_length = []
+        for row in data:
+            for element in row:
+                if not isinstance(element, (int, float)):
+                    raise TypeError('matrix elements must be numeric')
+
+            rows_length.append(len(row))
+
+        if len(set(rows_length)) > 1:
+            raise ValueError('all matrix rows must have the same length')
+
+        if len(rows_length) == 0 or rows_length[0] == 0:
+            raise ValueError('matrix data cannot be empty')
+
+        self._matrix = data
+        self.m = len(self._matrix)
+        self.n = rows_length[0]
+
+    def _format_matrix(self, debug: bool = False) -> str:
+        name = self._class_name
+        padding = '\n' + ' '*(len(name) + 1)
+
+        summarize = self.elements >= self.threshold
+        rows = self._matrix
+
+        if summarize:
+            rows = (
+                rows[:self.edgeitems] + rows[-self.edgeitems:]
+            )
+
+        visible_rows = []
+        for row in rows:
+            if summarize:
+                row = (
+                    row[:self.edgeitems] + ['...'] + row[-self.edgeitems:]
+                )
+
+            visible_rows.append(row)
+
+        widths = [0]*len(visible_rows[0])
+        for row in visible_rows:
+            for column, value in enumerate(row):
+                value_width = len(str(value))
+
+                if value_width > widths[column]:
+                    widths[column] = value_width
+
+        formatted_rows = []
+        for index, row in enumerate(visible_rows):
+            formatted_values = []
+
+            for column, value in enumerate(row):
+                formatted_values.append(
+                    f'{value:>{widths[column]}}'
+                )
+
+            clean_row = '  '.join(formatted_values)
+            clean_row = '[ ' + clean_row + ' ]'
+
+            formatted_rows.append(clean_row)
+
+            if summarize and index == self.edgeitems - 1:
+                formatted_rows.append('...'.center(len(clean_row)))
+
+        final_str = padding.join(formatted_rows)
+        shape = f', shape={self.shape}' if debug else ''
+
+        return f'{name}({final_str}{shape})'
+
+    @property
+    def shape(self) -> OrderedPair:
+        return self.m, self.n
+
+    @property
+    def elements(self) -> int:
+        return self.m*self.n
+
+    @property
+    def is_square(self) -> bool:
+        return self.shape[0] == self.shape[1]
+
+    @property
+    def order(self) -> int | None:
+        return self.shape[0] if self.is_square else None
+
+    @property
+    def main_diagonal(self) -> list[Any] | None:
+        result = None
+
+        if self.is_square:
+            result = [
+                self._matrix[n][n] for n in range(self.order)
+            ]
+
+        return result
+
+    @property
+    def anti_diagonal(self) -> list[Any] | None:
+        result = None
+
+        if self.is_square:
+            order = self.order
+
+            result = [
+                self._matrix[order - n][n - 1]
+                for n in range(order, 0, -1)
+            ]
+
+        return result
+
+    @property
+    def secondary_diagonal(self) -> list[Any] | None:
+        return self.anti_diagonal
+
+    @property
+    def counter_diagonal(self) -> list[Any] | None:
+        return self.anti_diagonal
+
+    @property
+    def reverse_diagonal(self) -> list[Any] | None:
+        return self.anti_diagonal
+
+    @property
+    def is_diagonal(self) -> bool:
+        result = False
+
+        if self.is_square:
+            _sum = 0
+
+            for i_index, row in enumerate(self._matrix):
+                for j_index, element in enumerate(row):
+                    if i_index != j_index:
+                        _sum += abs(element)
+
+            result = not bool(_sum)
+
+        return result
+
+    @property
+    def is_identity(self) -> bool:
+        result = False
+
+        if self.is_square and self.is_diagonal:
+            _count = 0
+
+            for element in self.main_diagonal:
+                if element == 1:
+                    _count += 1
+
+            result = _count == self.order
+
+        return result
+
+    @property
+    def is_unit(self) -> bool:
+        return self.is_identity
+
+    @property
+    def is_row(self) -> bool:
+        return self.shape[0] == 1
+
+    @property
+    def is_column(self) -> bool:
+        return self.shape[1] == 1
+
+    @property
+    def is_null(self) -> bool:
+        _sum = 0
+
+        for row in self._matrix:
+            for element in row:
+                _sum += abs(element)
+
+        return not bool(_sum)
+
+    def is_opposite(self, target: Matrix) -> bool:
+        return (self + target).is_null

rawmath-0.1.0/src/rawmath/types/functions.py

@@ -0,0 +1 @@
+type OrderedPair = tuple[int, int]

rawmath-0.1.0/src/rawmath/types/matrix.py

@@ -0,0 +1,3 @@
+from typing import Any
+
+type MatrixData = list[list[Any, Any]]

rawmath-0.1.0/src/rawmath.egg-info/PKG-INFO

@@ -0,0 +1,60 @@
+Metadata-Version: 2.4
+Name: rawmath
+Version: 0.1.0
+Summary: A from-scratch mathematics library for Python.
+Author: PeagazinhoAI
+License-Expression: MIT
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# RawMath
+
+A from-scratch mathematics library for Python.
+
+RawMath implements mathematical structures and operations directly from their
+definitions, with a focus on clarity, independence, and understanding the
+mathematics behind the implementation.
+
+## Requirements
+
+- Python 3.10+
+
+## Installation
+
+RawMath is currently under development.
+
+For local development:
+
+    python -m pip install -e .
+
+## Quick Start
+
+    from rawmath import Matrix
+
+    A = Matrix([
+        [1, 2],
+        [3, 4],
+    ])
+
+    B = Matrix([
+        [5, 6],
+        [7, 8],
+    ])
+
+    print(A + B)
+
+## Status
+
+RawMath is currently in pre-alpha development. The API may change between
+versions.
+
+## License
+
+RawMath is licensed under the MIT License.

rawmath-0.1.0/src/rawmath.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE
+README.md
+pyproject.toml
+src/rawmath/__init__.py
+src/rawmath.egg-info/PKG-INFO
+src/rawmath.egg-info/SOURCES.txt
+src/rawmath.egg-info/dependency_links.txt
+src/rawmath.egg-info/top_level.txt
+src/rawmath/models/__init__.py
+src/rawmath/models/matrix.py
+src/rawmath/types/__init__.py
+src/rawmath/types/functions.py
+src/rawmath/types/matrix.py
+tests/test_matrix.py

rawmath-0.1.0/src/rawmath.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

rawmath-0.1.0/src/rawmath.egg-info/top_level.txt

@@ -0,0 +1 @@
+rawmath

rawmath-0.1.0/tests/test_matrix.py

@@ -0,0 +1,765 @@
+import pytest
+
+from rawmath import Matrix
+
+
+def test_create_matrix_shape() -> None:
+    matrix = Matrix([
+        [1, 2],
+        [3, 4],
+    ])
+
+    assert matrix.shape == (2, 2)
+
+
+def test_create_matrix_elements() -> None:
+    matrix = Matrix([
+        [1, 2],
+        [3, 4],
+    ])
+
+    assert matrix.elements == 4
+
+
+def test_create_null_matrix_from_dimensions_shape() -> None:
+    matrix = Matrix((2, 3))
+
+    assert matrix.shape == (2, 3)
+
+
+def test_create_null_matrix_from_dimensions_is_null() -> None:
+    matrix = Matrix((2, 3))
+
+    assert matrix.is_null
+
+
+def test_reject_non_numeric_element() -> None:
+    with pytest.raises(TypeError):
+        Matrix([
+            [1, 2],
+            [3, 'hello'],
+        ])
+
+
+def test_reject_irregular_rows() -> None:
+    with pytest.raises(ValueError):
+        Matrix([
+            [1, 2],
+            [3],
+        ])
+
+
+def test_reject_empty_matrix() -> None:
+    with pytest.raises(ValueError):
+        Matrix([])
+
+
+def test_reject_single_empty_row() -> None:
+    with pytest.raises(ValueError):
+        Matrix([
+            [],
+        ])
+
+
+def test_reject_multiple_empty_rows() -> None:
+    with pytest.raises(ValueError):
+        Matrix([
+            [],
+            [],
+        ])
+
+
+def test_shape_rectangular_matrix() -> None:
+    matrix = Matrix([
+        [1, 2, 3],
+        [4, 5, 6],
+    ])
+
+    assert matrix.shape == (2, 3)
+
+
+def test_elements_rectangular_matrix() -> None:
+    matrix = Matrix([
+        [1, 2, 3],
+        [4, 5, 6],
+    ])
+
+    assert matrix.elements == 6
+
+
+def test_square_matrix() -> None:
+    matrix = Matrix([
+        [1, 2],
+        [3, 4],
+    ])
+
+    assert matrix.is_square
+
+
+def test_non_square_matrix() -> None:
+    matrix = Matrix([
+        [1, 2, 3],
+        [4, 5, 6],
+    ])
+
+    assert not matrix.is_square
+
+
+def test_square_matrix_order() -> None:
+    matrix = Matrix([
+        [1, 2],
+        [3, 4],
+    ])
+
+    assert matrix.order == 2
+
+
+def test_non_square_matrix_order() -> None:
+    matrix = Matrix([
+        [1, 2, 3],
+        [4, 5, 6],
+    ])
+
+    assert matrix.order is None
+
+
+def test_row_matrix() -> None:
+    matrix = Matrix([
+        [1, 2, 3],
+    ])
+
+    assert matrix.is_row
+
+
+def test_non_row_matrix() -> None:
+    matrix = Matrix([
+        [1, 2],
+        [3, 4],
+    ])
+
+    assert not matrix.is_row
+
+
+def test_column_matrix() -> None:
+    matrix = Matrix([
+        [1],
+        [2],
+        [3],
+    ])
+
+    assert matrix.is_column
+
+
+def test_non_column_matrix() -> None:
+    matrix = Matrix([
+        [1, 2],
+        [3, 4],
+    ])
+
+    assert not matrix.is_column
+
+
+def test_one_by_one_is_row() -> None:
+    matrix = Matrix([
+        [7],
+    ])
+
+    assert matrix.is_row
+
+
+def test_one_by_one_is_column() -> None:
+    matrix = Matrix([
+        [7],
+    ])
+
+    assert matrix.is_column
+
+
+def test_one_by_one_is_square() -> None:
+    matrix = Matrix([
+        [7],
+    ])
+
+    assert matrix.is_square
+
+
+def test_one_by_one_order() -> None:
+    matrix = Matrix([
+        [7],
+    ])
+
+    assert matrix.order == 1
+
+
+def test_main_diagonal() -> None:
+    matrix = Matrix([
+        [1, 2, 3],
+        [4, 5, 6],
+        [7, 8, 9],
+    ])
+
+    assert matrix.main_diagonal == [1, 5, 9]
+
+
+def test_main_diagonal_one_by_one() -> None:
+    matrix = Matrix([
+        [7],
+    ])
+
+    assert matrix.main_diagonal == [7]
+
+
+def test_main_diagonal_non_square() -> None:
+    matrix = Matrix([
+        [1, 2, 3],
+        [4, 5, 6],
+    ])
+
+    assert matrix.main_diagonal is None
+
+
+def test_anti_diagonal() -> None:
+    matrix = Matrix([
+        [1, 2, 3],
+        [4, 5, 6],
+        [7, 8, 9],
+    ])
+
+    assert matrix.anti_diagonal == [3, 5, 7]
+
+
+def test_anti_diagonal_one_by_one() -> None:
+    matrix = Matrix([
+        [7],
+    ])
+
+    assert matrix.anti_diagonal == [7]
+
+
+def test_anti_diagonal_non_square() -> None:
+    matrix = Matrix([
+        [1, 2, 3],
+        [4, 5, 6],
+    ])
+
+    assert matrix.anti_diagonal is None
+
+
+def test_secondary_diagonal_alias() -> None:
+    matrix = Matrix([
+        [1, 2],
+        [3, 4],
+    ])
+
+    assert matrix.secondary_diagonal == matrix.anti_diagonal
+
+
+def test_counter_diagonal_alias() -> None:
+    matrix = Matrix([
+        [1, 2],
+        [3, 4],
+    ])
+
+    assert matrix.counter_diagonal == matrix.anti_diagonal
+
+
+def test_reverse_diagonal_alias() -> None:
+    matrix = Matrix([
+        [1, 2],
+        [3, 4],
+    ])
+
+    assert matrix.reverse_diagonal == matrix.anti_diagonal
+
+
+def test_diagonal_matrix() -> None:
+    matrix = Matrix([
+        [2, 0, 0],
+        [0, 5, 0],
+        [0, 0, -3],
+    ])
+
+    assert matrix.is_diagonal
+
+
+def test_zero_diagonal_matrix() -> None:
+    matrix = Matrix([
+        [0, 0],
+        [0, 0],
+    ])
+
+    assert matrix.is_diagonal
+
+
+def test_non_diagonal_matrix() -> None:
+    matrix = Matrix([
+        [1, 2],
+        [0, 1],
+    ])
+
+    assert not matrix.is_diagonal
+
+
+def test_non_square_is_not_diagonal() -> None:
+    matrix = Matrix([
+        [1, 0, 0],
+        [0, 1, 0],
+    ])
+
+    assert not matrix.is_diagonal
+
+
+def test_identity_matrix() -> None:
+    matrix = Matrix([
+        [1, 0, 0],
+        [0, 1, 0],
+        [0, 0, 1],
+    ])
+
+    assert matrix.is_identity
+
+
+def test_non_identity_diagonal_matrix() -> None:
+    matrix = Matrix([
+        [2, 0],
+        [0, 2],
+    ])
+
+    assert not matrix.is_identity
+
+
+def test_non_diagonal_is_not_identity() -> None:
+    matrix = Matrix([
+        [1, 1],
+        [0, 1],
+    ])
+
+    assert not matrix.is_identity
+
+
+def test_non_square_is_not_identity() -> None:
+    matrix = Matrix([
+        [1, 0, 0],
+        [0, 1, 0],
+    ])
+
+    assert not matrix.is_identity
+
+
+def test_one_by_one_identity() -> None:
+    matrix = Matrix([
+        [1],
+    ])
+
+    assert matrix.is_identity
+
+
+def test_unit_alias() -> None:
+    matrix = Matrix([
+        [1, 0],
+        [0, 1],
+    ])
+
+    assert matrix.is_unit
+
+
+def test_null_matrix() -> None:
+    matrix = Matrix([
+        [0, 0],
+        [0, 0],
+    ])
+
+    assert matrix.is_null
+
+
+def test_non_null_matrix() -> None:
+    matrix = Matrix([
+        [0, 0],
+        [0, 1],
+    ])
+
+    assert not matrix.is_null
+
+
+def test_negative_matrix_is_not_null() -> None:
+    matrix = Matrix([
+        [0, -1],
+        [0, 0],
+    ])
+
+    assert not matrix.is_null
+
+
+def test_get_first_row() -> None:
+    matrix = Matrix([
+        [1, 2],
+        [3, 4],
+    ])
+
+    assert matrix[0] == [1, 2]
+
+
+def test_get_second_row() -> None:
+    matrix = Matrix([
+        [1, 2],
+        [3, 4],
+    ])
+
+    assert matrix[1] == [3, 4]
+
+
+def test_setitem() -> None:
+    matrix = Matrix([
+        [1, 2],
+        [3, 4],
+    ])
+
+    matrix[0, 1] = 10
+
+    assert matrix[0][1] == 10
+
+
+def test_setitem_negative_value() -> None:
+    matrix = Matrix([
+        [1, 2],
+        [3, 4],
+    ])
+
+    matrix[1, 0] = -20
+
+    assert matrix[1][0] == -20
+
+
+def test_setitem_float() -> None:
+    matrix = Matrix([
+        [1, 2],
+        [3, 4],
+    ])
+
+    matrix[0, 0] = 1.5
+
+    assert matrix[0][0] == 1.5
+
+
+def test_equal_matrices() -> None:
+    a = Matrix([
+        [1, 2],
+        [3, 4],
+    ])
+
+    b = Matrix([
+        [1, 2],
+        [3, 4],
+    ])
+
+    assert a == b
+
+
+def test_different_matrices_are_not_equal() -> None:
+    a = Matrix([
+        [1, 2],
+        [3, 4],
+    ])
+
+    b = Matrix([
+        [1, 2],
+        [3, 5],
+    ])
+
+    assert not (a == b)
+
+
+def test_different_matrices() -> None:
+    a = Matrix([
+        [1, 2],
+        [3, 4],
+    ])
+
+    b = Matrix([
+        [1, 2],
+        [3, 5],
+    ])
+
+    assert a != b
+
+
+def test_equal_matrices_are_not_different() -> None:
+    a = Matrix([
+        [1, 2],
+        [3, 4],
+    ])
+
+    b = Matrix([
+        [1, 2],
+        [3, 4],
+    ])
+
+    assert not (a != b)
+
+
+def test_negative_matrix() -> None:
+    matrix = Matrix([
+        [1, -2],
+        [3, 4],
+    ])
+
+    assert -matrix == Matrix([
+        [-1, 2],
+        [-3, -4],
+    ])
+
+
+def test_double_negative_matrix() -> None:
+    matrix = Matrix([
+        [1, -2],
+        [3, 4],
+    ])
+
+    assert -(-matrix) == matrix
+
+
+def test_negative_null_matrix() -> None:
+    matrix = Matrix([
+        [0, 0],
+        [0, 0],
+    ])
+
+    assert -matrix == matrix
+
+
+def test_opposite_matrices() -> None:
+    a = Matrix([
+        [1, -2],
+        [3, 4],
+    ])
+
+    b = Matrix([
+        [-1, 2],
+        [-3, -4],
+    ])
+
+    assert a.is_opposite(b)
+
+
+def test_non_opposite_matrices() -> None:
+    a = Matrix([
+        [1, 2],
+        [3, 4],
+    ])
+
+    b = Matrix([
+        [-1, -2],
+        [-3, -5],
+    ])
+
+    assert not a.is_opposite(b)
+
+
+def test_null_matrix_is_opposite_to_itself() -> None:
+    matrix = Matrix([
+        [0, 0],
+        [0, 0],
+    ])
+
+    assert matrix.is_opposite(matrix)
+
+
+def test_matrix_addition() -> None:
+    a = Matrix([
+        [1, 2],
+        [3, 4],
+    ])
+
+    b = Matrix([
+        [5, 6],
+        [7, 8],
+    ])
+
+    assert a + b == Matrix([
+        [6, 8],
+        [10, 12],
+    ])
+
+
+def test_matrix_addition_with_negative_values() -> None:
+    a = Matrix([
+        [-1, 2],
+        [3, -4],
+    ])
+
+    b = Matrix([
+        [5, -6],
+        [-7, 8],
+    ])
+
+    assert a + b == Matrix([
+        [4, -4],
+        [-4, 4],
+    ])
+
+
+def test_matrix_addition_with_null_matrix() -> None:
+    a = Matrix([
+        [1, 2],
+        [3, 4],
+    ])
+
+    null = Matrix((2, 2))
+
+    assert a + null == a
+
+
+def test_matrix_addition_commutative() -> None:
+    a = Matrix([
+        [1, 2],
+        [3, 4],
+    ])
+
+    b = Matrix([
+        [5, 6],
+        [7, 8],
+    ])
+
+    assert a + b == b + a
+
+
+def test_addition_different_row_count() -> None:
+    a = Matrix([
+        [1, 2],
+    ])
+
+    b = Matrix([
+        [1, 2],
+        [3, 4],
+    ])
+
+    with pytest.raises(ValueError):
+        a + b
+
+
+def test_addition_different_column_count() -> None:
+    a = Matrix([
+        [1, 2],
+        [3, 4],
+    ])
+
+    b = Matrix([
+        [1, 2, 3],
+        [4, 5, 6],
+    ])
+
+    with pytest.raises(ValueError):
+        a + b
+
+
+def test_matrix_subtraction() -> None:
+    a = Matrix([
+        [10, -4, 7],
+        [3, 8, -2],
+    ])
+
+    b = Matrix([
+        [6, 2, -3],
+        [-5, 1, 4],
+    ])
+
+    assert a - b == Matrix([
+        [4, -6, 10],
+        [8, 7, -6],
+    ])
+
+
+def test_matrix_subtraction_from_itself() -> None:
+    matrix = Matrix([
+        [1, 2],
+        [3, 4],
+    ])
+
+    assert (matrix - matrix).is_null
+
+
+def test_matrix_subtraction_null_matrix() -> None:
+    matrix = Matrix([
+        [1, 2],
+        [3, 4],
+    ])
+
+    null = Matrix((2, 2))
+
+    assert matrix - null == matrix
+
+
+def test_subtraction_different_row_count() -> None:
+    a = Matrix([
+        [1, 2],
+    ])
+
+    b = Matrix([
+        [1, 2],
+        [3, 4],
+    ])
+
+    with pytest.raises(ValueError):
+        a - b
+
+
+def test_subtraction_different_column_count() -> None:
+    a = Matrix([
+        [1, 2],
+        [3, 4],
+    ])
+
+    b = Matrix([
+        [1, 2, 3],
+        [4, 5, 6],
+    ])
+
+    with pytest.raises(ValueError):
+        a - b
+
+
+def test_str_matrix() -> None:
+    matrix = Matrix([
+        [1, 2],
+        [3, 4],
+    ])
+
+    assert str(matrix) == (
+        'Matrix([ 1  2 ]\n'
+        '       [ 3  4 ])'
+    )
+
+
+def test_repr_contains_shape() -> None:
+    matrix = Matrix([
+        [1, 2],
+        [3, 4],
+    ])
+
+    assert 'shape=(2, 2)' in repr(matrix)
+
+
+def test_str_does_not_contain_shape() -> None:
+    matrix = Matrix([
+        [1, 2],
+        [3, 4],
+    ])
+
+    assert 'shape=' not in str(matrix)
+
+
+def test_large_matrix_is_summarized() -> None:
+    matrix = Matrix(
+        [[0 for _ in range(40)] for _ in range(40)]
+    )
+
+    assert '...' in str(matrix)
+
+
+def test_small_matrix_is_not_summarized() -> None:
+    matrix = Matrix([
+        [1, 2],
+        [3, 4],
+    ])
+
+    assert '...' not in str(matrix)