update documentation

.vscode/settings.json

@@ -1,6 +1,6 @@
 {
     "[python]": {
-        "editor.defaultFormatter": "ms-python.black-formatter"
+        "editor.defaultFormatter": "charliermarsh.ruff"
     },
     "python.formatting.provider": "none",
     "cSpell.words": [

docs/api.rst

@@ -1 +1,8 @@
 .. py:module:: zmodn
+
+Modular Arithmetic
+==================
+
+.. python-apigen-group:: modular-arithmetic
+
+

docs/conf.py

@@ -190,14 +190,6 @@
 autodoc_typehints_description_target = "documented"
 autodoc_typehints_format = "short"
 
-autodoc_type_aliases = {
-    "ElementLike": "~typing.ElementLike",
-    "IterableLike": "~typing.IterableLike",
-    "ArrayLike": "~typing.ArrayLike",
-    "ShapeLike": "~typing.ShapeLike",
-    "DTypeLike": "~typing.DTypeLike",
-    "PolyLike": "~typing.PolyLike",
-}
 
 ipython_execlines = ["import math", "import numpy as np", "import zmodn"]
 
@@ -220,7 +212,7 @@
 # -- Sphinx Immaterial configs -------------------------------------------------
 
 python_apigen_modules = {
-    "zmodn": "api/zmodn.",
+    "zmodn": "api/",
 }
 
 python_apigen_default_groups = [
@@ -254,7 +246,6 @@
 python_apigen_show_base_classes = True
 
 # Python domain directive configuration
-python_type_aliases = autodoc_type_aliases
 python_module_names_to_strip_from_xrefs = ["collections.abc"]
 
 # General API configuration

docs/getting-started.rst

@@ -11,10 +11,10 @@ The last stable release is available on PyPI and can be installed with pip:
     pip install zmodn
     zmodn.__version__
 
-Create a :obj:`Zmodn` instance
+Create a :obj:`~.zmodn.Zmodn` instance
 ------------------------------
 
-The :obj:`Zmodn` class is the main interface to the library. It represents a set of integers modulo a given modulus. The
+The :obj:`zmodn` class is the main interface to the library. It represents a set of integers modulo a given modulus. The
 modulus must be a positive integer. The representatives of the set are given as a list of integers or a single integer.
 In this example, we create a :obj:`Zmodn` instance representing the set of integers modulo 5 with representatives 1, 2,
 3, 4, and 5 (which are equivalent to 1, 2, 3, 4, and 0 modulo 5, respectively):

docs/index.rst

@@ -121,5 +121,6 @@ If this library was useful to you in your research, please cite us. Following th
 .. toctree::
    :caption: API Reference
    :hidden:
+   :maxdepth: 2
 
    api.rst

pyproject.toml

@@ -8,8 +8,14 @@ readme = "README.md"
 [tool.poetry.dependencies]
 python = "^3.11"
 numpy = { version = "^1.26.1", python = ">=3.11,<3.13" }
+
+
+[tool.poetry.group.dev.dependencies]
 pre-commit = "^3.5.0"
-pytest = "^7.4.3"
+pytest = "^8.0.2"
+pymdown-extensions = "^10.7"
+clang = "^17.0.6"
+sphinx-jinja = "^2.0.2"
 
 [tool.black]
 line-length = 120

zmodn/__init__.py

@@ -1,4 +1,4 @@
 import sys
-from .zmodn import Zmodn
+from ._zmodn import Zmodn
 
 sys.modules["Zmodn"] = Zmodn

zmodn/zmodn.py → zmodn/_zmodn.py

@@ -7,6 +7,13 @@
 
 
 class Zmodn:
+    r"""
+    Does not work for matrices.Computes the modular inverse of the Zmodn object using the extended Euclidean algorithm.
+
+    Group:
+        Modular Arithmetic
+    """
+
     def __init__(self, matrix_integers, module):
         validated_matrix = validate_matrix(matrix_integers)
         if not validated_matrix:
@@ -65,23 +72,26 @@ def _check_invertible_matrix(self, matrix):
 
     @property
     def classes(self):
-        return [self.__class__(int(element), self.module) for element in self.representatives]
+        r"""
+        Returns the representatives of the Zmodn object as a list.
+
+        Returns:
+            list: List of integers
+        """
+        return [
+            self.__class__(int(element), self.module)
+            for element in self.representatives
+        ]
 
     def mod_inv(self):
         r"""
-        Does not work for matrices
-
-        Arguments:
-            self (Zmodn): Zmodn object
+        Does not work for matrices.Computes the modular inverse of the Zmodn object using the extended Euclidean algorithm.
 
         Returns:
             Zmodn: Zmodn object
 
         Raises:
             ValueError: If the Zmodn object has more than one representative
-
-        Group:
-            Modular arithmetic
         """
         integers_array = np.array(self.representatives).astype(int)
         repr_inverse = vectorize_modular_inverse(integers_array, self.module)
@@ -94,38 +104,50 @@ def inv(self):
         self._check_square_matrix(matrix)
         determinant = self._check_invertible_matrix(matrix)
         adjoint = adjoint_matrix(matrix).astype(int)
-        multiplier = int(self.__class__(1, self.module) / self.__class__(determinant, self.module))
+        multiplier = int(
+            self.__class__(1, self.module) / self.__class__(determinant, self.module)
+        )
         inverse_matrix = multiplier * adjoint
         return self.__class__(inverse_matrix.tolist(), self.module)
 
     @implements(np.add)
     def __add__(self, other):
         self._check_module_and_type(other)
-        repr_sum = (np.array(self.representatives) + np.array(other.representatives)) % self.module
+        repr_sum = (
+            np.array(self.representatives) + np.array(other.representatives)
+        ) % self.module
         return self.__class__(repr_sum.tolist(), self.module)
 
     @implements(np.subtract)
     def __sub__(self, other):
         self._check_module_and_type(other)
-        repr_sub = (np.array(self.representatives) - np.array(other.representatives)) % self.module
+        repr_sub = (
+            np.array(self.representatives) - np.array(other.representatives)
+        ) % self.module
         return self.__class__(repr_sub.tolist(), self.module)
 
     @implements(np.multiply)
     def __mul__(self, other):
         self._check_module_and_type(other)
-        repr_mul = (np.array(self.representatives) * np.array(other.representatives)) % self.module
+        repr_mul = (
+            np.array(self.representatives) * np.array(other.representatives)
+        ) % self.module
         return self.__class__(repr_mul.tolist(), self.module)
 
     @implements(np.dot)
     def __matmul__(self, other):
         self._check_module_and_type(other)
-        repr_mul = (np.array(self.representatives) @ np.array(other.representatives)) % self.module
+        repr_mul = (
+            np.array(self.representatives) @ np.array(other.representatives)
+        ) % self.module
         return self.__class__(repr_mul.tolist(), self.module)
 
     @implements(np.divide)
     def __truediv__(self, other):
         self._check_module_and_type(other)
-        repr_div = (np.array(self.representatives) * np.array(other.mod_inv().representatives)) % self.module
+        repr_div = (
+            np.array(self.representatives) * np.array(other.mod_inv().representatives)
+        ) % self.module
         return self.__class__(repr_div.tolist(), self.module)
 
     @implements(np.power)
@@ -204,5 +226,7 @@ def __bool__(self):
 
     def __int__(self):
         if self.representatives.size != 1:
-            raise ValueError("Cannot convert Zmodn object with more than one representative to an integer")
+            raise ValueError(
+                "Cannot convert Zmodn object with more than one representative to an integer"
+            )
         return int(self.representatives[0])