mplusa 0.0.1__tar.gz → 0.0.3__tar.gz

{mplusa-0.0.1/src/mplusa.egg-info → mplusa-0.0.3}/PKG-INFO

@@ -1,8 +1,8 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: mplusa
-Version: 0.0.1
+Version: 0.0.3
 Summary: A library for calculations in tropical and arctic semirings.
-Author-email: "Maksymilian W." <maksymilian3563@gmail.com>
+Author-email: Maksymilian Wiekiera <maksymilian3563@gmail.com>
 License: Copyright (c) 2025 Maksymilian Wiekiera
         
         Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -23,46 +23,60 @@ License: Copyright (c) 2025 Maksymilian Wiekiera
         OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
         SOFTWARE.
 Project-URL: homepage, https://github.com/Hadelekw/mplusa
+Project-URL: documentation, https://hadelekw.github.io/mplusa-docs.html
 Classifier: Programming Language :: Python :: 3
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy>=2.2.3
+Dynamic: license-file
 
 # MPlusA
 ---
-**MPlusA** is a small Python library for tropical algebra (also known as $(\min, +)$ and $(\max, +)$ algebra). It provides the definitions of basic operations on numbers and NumPy arrays, as well as a basic implementation of tropical polynomials.
+**MPlusA** is a small Python library for tropical algebra (also known as (min, +) and (max, +) algebra). It provides the definitions of basic operations on numbers and NumPy arrays, as well as a basic implementation of tropical polynomials.
 
 Any improvements or fixes are always welcome.
 
 ## How to use
-After having installed the library one can import one of the two modules the package consists of (`minplus` and `maxplus`) and use the full array of its capabilities. The functions are essentially the same between the modules. The list below is a full list of the library's capabilities.
+After having installed the library one can import one of the two modules the package consists of (`minplus` and `maxplus`) and use the full array of its capabilities. The functions are essentially the same between the modules.
 
 **`add(*args) -> Real`**
 	Tropical addition. Essentially an alias for Python's `min` function.
+
 **`mult(*args) -> Real`**
 	Tropical multiplication. Essentially an alias for Python's `sum` function.
+
 **`add_matrices(A : np.ndarray, B : np.ndarray) -> np.ndarray`**
 	Tropical addition of NumPy arrays. The summed matrices have to be of the same shape.
+
 **`mult_matrices(A : np.ndarray, B : np.ndarray) -> np.ndarray`**
 	Tropical multiplication of NumPy arrays. The multiplied matrices have to be of sizes MxN and NxP and their order matters. The result is of shape MxP.
+
 **`modulo(a : Real, t : int) -> Real`**
 	Tropical modulo operator. It can be understood as the difference between the number $a$ and $t^k$ where $k$ is the largest integer that satisfies $a \geq t^k$.
+
 **`modulo_matrices(A : np.ndarray, b : np.ndarray) -> np.ndarray`**
 	Tropical modulo operator for NumPy arrays. The input matrices should be of size MxN and Mx1. The result is an MxN matrix.
+
 **`power(a : real, k : int) -> Real`**
 	Tropical power operator.  Applies the multiplication k times.
+
 **`power_matrix(A : np.ndarray, k : int) -> np.ndarray`**
 	Tropical power operator for NumPy arrays. It multiplies the matrix k times.
+
 **`unit_matrix(width : int, height : int) -> np.ndarray`**
 	Creates a tropical unit matrix of given width and height.
+
 **`star(A : np.ndarray) -> np.ndarray`**
-	Definition of a unique operator of tropical algebra, usually denoted as $\mathbf{A}^*$. It returns the value to which an infinite recursive sum of matrices converges. The input matrix has to be square and the series created in the process of calculating the value needs to be convergent.
+	Definition of an unary operator of unique to tropical algebra, usually denoted as $\mathbf{A}^*$. It returns the value to which an infinite recursive sum of matrices converges. The input matrix has to be square and the series created in the process of calculating the value needs to be convergent.
+
 **`Polynomial(*coefficients)`**
-	This is a class that implements basic single-variable tropical polynomials. Calling an object of this class allows to take a value the polynomial takes at a given point, it also implements function `get_hypersurface` which returns a list of its roots.
+	This is a class that implements basic single-variable tropical polynomials. Calling an object of this class allows to take a value the polynomial takes at a given point.
+
+For the full list of capabilities, refer to the [documentation](https://hadelekw.github.io/mplusa-docs.html)
 
-### Example code
+## Example code
 ```
 import numpy as np
 from mplusa import minplus

{mplusa-0.0.1 → mplusa-0.0.3}/README.md

@@ -1,36 +1,48 @@
 # MPlusA
 ---
-**MPlusA** is a small Python library for tropical algebra (also known as $(\min, +)$ and $(\max, +)$ algebra). It provides the definitions of basic operations on numbers and NumPy arrays, as well as a basic implementation of tropical polynomials.
+**MPlusA** is a small Python library for tropical algebra (also known as (min, +) and (max, +) algebra). It provides the definitions of basic operations on numbers and NumPy arrays, as well as a basic implementation of tropical polynomials.
 
 Any improvements or fixes are always welcome.
 
 ## How to use
-After having installed the library one can import one of the two modules the package consists of (`minplus` and `maxplus`) and use the full array of its capabilities. The functions are essentially the same between the modules. The list below is a full list of the library's capabilities.
+After having installed the library one can import one of the two modules the package consists of (`minplus` and `maxplus`) and use the full array of its capabilities. The functions are essentially the same between the modules.
 
 **`add(*args) -> Real`**
 	Tropical addition. Essentially an alias for Python's `min` function.
+
 **`mult(*args) -> Real`**
 	Tropical multiplication. Essentially an alias for Python's `sum` function.
+
 **`add_matrices(A : np.ndarray, B : np.ndarray) -> np.ndarray`**
 	Tropical addition of NumPy arrays. The summed matrices have to be of the same shape.
+
 **`mult_matrices(A : np.ndarray, B : np.ndarray) -> np.ndarray`**
 	Tropical multiplication of NumPy arrays. The multiplied matrices have to be of sizes MxN and NxP and their order matters. The result is of shape MxP.
+
 **`modulo(a : Real, t : int) -> Real`**
 	Tropical modulo operator. It can be understood as the difference between the number $a$ and $t^k$ where $k$ is the largest integer that satisfies $a \geq t^k$.
+
 **`modulo_matrices(A : np.ndarray, b : np.ndarray) -> np.ndarray`**
 	Tropical modulo operator for NumPy arrays. The input matrices should be of size MxN and Mx1. The result is an MxN matrix.
+
 **`power(a : real, k : int) -> Real`**
 	Tropical power operator.  Applies the multiplication k times.
+
 **`power_matrix(A : np.ndarray, k : int) -> np.ndarray`**
 	Tropical power operator for NumPy arrays. It multiplies the matrix k times.
+
 **`unit_matrix(width : int, height : int) -> np.ndarray`**
 	Creates a tropical unit matrix of given width and height.
+
 **`star(A : np.ndarray) -> np.ndarray`**
-	Definition of a unique operator of tropical algebra, usually denoted as $\mathbf{A}^*$. It returns the value to which an infinite recursive sum of matrices converges. The input matrix has to be square and the series created in the process of calculating the value needs to be convergent.
+	Definition of an unary operator of unique to tropical algebra, usually denoted as $\mathbf{A}^*$. It returns the value to which an infinite recursive sum of matrices converges. The input matrix has to be square and the series created in the process of calculating the value needs to be convergent.
+
 **`Polynomial(*coefficients)`**
-	This is a class that implements basic single-variable tropical polynomials. Calling an object of this class allows to take a value the polynomial takes at a given point, it also implements function `get_hypersurface` which returns a list of its roots.
+	This is a class that implements basic single-variable tropical polynomials. Calling an object of this class allows to take a value the polynomial takes at a given point.
+
+For the full list of capabilities, refer to the [documentation](https://hadelekw.github.io/mplusa-docs.html)
 
-### Example code
+## Example code
 ```
 import numpy as np
 from mplusa import minplus

{mplusa-0.0.1 → mplusa-0.0.3}/pyproject.toml

@@ -1,8 +1,8 @@
 [project]
 name = "mplusa"
-version = "0.0.1"
+version = "0.0.3"
 authors = [
-    {name="Maksymilian W.", email="maksymilian3563@gmail.com"}
+    {name="Maksymilian Wiekiera", email="maksymilian3563@gmail.com"}
 ]
 description = "A library for calculations in tropical and arctic semirings."
 readme = "README.md"
@@ -18,3 +18,4 @@ license = {file="LICENSE"}
 
 [project.urls]
 homepage = "https://github.com/Hadelekw/mplusa"
+documentation = "https://hadelekw.github.io/mplusa-docs.html"

mplusa-0.0.3/src/mplusa/maxplus.py

@@ -0,0 +1,200 @@
+import numpy as np
+
+import math
+import string
+
+from . import utils
+
+
+def add(*args) -> float:
+    if math.inf in args:
+        raise ValueError('Value out of domain.')
+    return max(args)
+
+
+def mult(*args) -> float:
+    if math.inf in args:
+        raise ValueError('Value out of domain.')
+    return sum(args) if -math.inf not in args else -math.inf
+
+
+def power(a : float,
+          k : int) -> float:
+    return mult(*[a for _ in range(k)])
+
+
+def modulo(a : float,
+           t : int) -> float:
+    if a < 0 or t < 0:
+        raise ValueError('The modulo operator is only defined for positive numbers.')
+    if a == -math.inf:
+        return -math.inf
+    if a == 0:
+        return 0
+    if t == -math.inf or t == 0:
+        return a
+    return a - (a // t) * t
+
+
+def add_matrices(A : np.ndarray,
+                 B : np.ndarray) -> np.ndarray:
+    if A.shape != B.shape:
+        raise ValueError('Given matrices have different shapes.')
+    result = np.copy(A)
+    shape = A.shape
+    for i in range(shape[0]):
+        for j in range(shape[1]):
+            result[i, j] = add(result[i, j], B[i, j])
+    return result
+
+
+def mult_matrices(A : np.ndarray,
+                  B : np.ndarray) -> np.ndarray:
+    if A.shape[1] != B.shape[0]:
+        raise ValueError('Given matrices are not of MxN and NxP shapes.')
+    result = np.zeros((A.shape[0], B.shape[1]))
+    for i in range(A.shape[0]):
+        for j in range(B.shape[1]):
+            result[i, j] = add(*[mult(A[i, k], B[k, j]) for k in range(A.shape[1])])
+    return result
+
+
+def power_matrix(A : np.ndarray,
+                 k : int) -> np.ndarray:
+    if np.any(np.diagonal(A) != 0):
+        raise ValueError('Matrix contains non-zero values on the diagonal.')
+    if k == 0:
+        result = unit_matrix(A.shape[0], A.shape[1])
+    else:
+        result = A.copy()
+        for _ in range(k):
+            result = mult_matrices(A, result)
+    return result
+
+
+def modulo_matrices(A : np.ndarray,
+                    b : np.ndarray) -> np.ndarray:
+    if b.shape[1] != 1:
+        raise ValueError('Given matrix b is not a vertical vector of shape Mx1')
+    if A.shape[0] != b.shape[0]:
+        raise ValueError('Given matrix b does not have an Mx1 shape against the MxN matrix A.')
+    if np.any(A < 0) or np.any(b < 0):
+        raise ValueError('Given matrices contain negative values.')
+    result = np.zeros(A.shape)
+    for i in range(A.shape[0]):
+        for j in range(A.shape[1]):
+            result[i, j] = modulo(A[i, j], b[i])
+    return result
+
+
+def unit_matrix(width : int,
+                height : int) -> np.ndarray:
+    result = np.eye(width, height)
+    result[result == 0] = -math.inf
+    result[result == 1] = 0
+    return result
+
+
+def kleene_star(A : np.ndarray,
+                iterations : int = 1000) -> np.ndarray:
+    if A.shape[0] != A.shape[1]:
+        raise ValueError('Matrix is not square.')
+    series = [
+        unit_matrix(A.shape[0], A.shape[1]),
+        A.copy()
+    ]
+    for _ in range(iterations):
+        series.append(add_matrices(series[-1], mult_matrices(series[-1], series[-2])))
+    return series[-1]
+
+
+class MultivariatePolynomial:
+    """ An implementation of an arctic polynomial with multiple variables. """
+
+    def __init__(self, coefficients : np.ndarray) -> None:
+        self.coefficients = coefficients
+        self.dimensions = len(self.coefficients.shape) + 1
+        self._symbols = string.ascii_lowercase
+
+    def __call__(self, *variables : float) -> float:
+        if len(variables) != self.dimensions - 1:
+            raise ValueError('The amount of variables and coefficients differs.')
+        result = [-math.inf]
+        for indices, coefficient in np.ndenumerate(self.coefficients):
+            powers = []
+            for variable_index, i in enumerate(indices):
+                powers.append(power(variables[variable_index], i))
+            result.append(mult(coefficient, *powers))
+        result = add(*result)
+        return float(result)
+
+    def __str__(self) -> str:
+        result = ''
+        for indices, coefficient in np.ndenumerate(self.coefficients):
+            if coefficient.is_integer():
+                result += '(' + str(int(coefficient))
+            elif coefficient > -math.inf:
+                result += '(' + str(coefficient)
+            else:
+                result += '(-∞'
+            for variable_index, i in enumerate(indices):
+                if i > 1:
+                    result += ' * ' + self._symbols[variable_index] + '^' + str(i)
+                elif i == 1:
+                    result += ' * ' + self._symbols[variable_index]
+            result += ') + '
+        return result[:-3]
+
+    def get_hyperplanes(self) -> list:
+        """ Returns a list of coefficients of a linear equation for every hyperplane building the polynomial. """
+        result = []
+        for indices, coefficient in np.ndenumerate(self.coefficients):
+            if coefficient == -math.inf:
+                continue
+            hyperplane = [float(coefficient)]
+            hyperplane.extend(indices)
+            hyperplane.append(1)  # The coefficient of the last dimension (e.g. Z in 3D)
+            result.append(
+                list(
+                    map(
+                        lambda x: int(x) if x.is_integer() else float(x),
+                        hyperplane
+                    )
+                )
+            )
+        return result
+
+
+class Polynomial(MultivariatePolynomial):
+    """ An implementation of a tropical polynomial with a single variable. """
+
+    def __init__(self, *coefficients) -> None:
+        for value in coefficients:
+            if not isinstance(value, float|int) or value == math.inf:
+                raise ValueError('Coefficient value out of domain.')
+        super().__init__(np.array(coefficients))
+
+    def get_line_intersections(self) -> list:
+        """ Returns a list of intersection points for the lines building the polynomial. """
+        result = []
+        lines = self.get_hyperplanes()  # Hyperplanes are lines in this case
+        for line in lines:  # Change the form of the equation to a + bx from a + bx + cy
+            line.pop()
+        lines = filter(lambda x: len(x) == 2, utils.powerset(lines))
+        for line_1, line_2 in lines:
+            point = [(line_2[0] - line_1[0]) / (line_1[1] - line_2[1])]
+            point.append(line_1[0] + line_1[1] * point[0])
+            result.append(tuple(point))
+        result = list(filter(lambda point: round(point[1], 8) == round(self(point[0]), 8), result))  # Filter out the points not belonging to the polynomial
+        return result
+
+    def get_roots(self) -> tuple:
+        """ Returns lists of roots of the polynomial and of their respective ranks (amount of monomials attaining the value). """
+        result = {}
+        points = self.get_line_intersections()
+        for point in points:
+            if not point[0] in result:
+                result[point[0]] = 1
+            else:
+                result[point[0]] += 1
+        return list(result.keys()), list(result.values())

mplusa-0.0.3/src/mplusa/minplus.py

@@ -0,0 +1,200 @@
+import numpy as np
+
+import math
+import string
+
+from . import utils
+
+
+def add(*args) -> float:
+    if -math.inf in args:
+        raise ValueError('Value out of domain.')
+    return min(args)
+
+
+def mult(*args) -> float:
+    if -math.inf in args:
+        raise ValueError('Value out of domain.')
+    return sum(args) if math.inf not in args else math.inf
+
+
+def power(a : float,
+          k : int) -> float:
+    return mult(*[a for _ in range(k)])
+
+
+def modulo(a : float,
+           t : int) -> float:
+    if a < 0 or t < 0:
+        raise ValueError('The modulo operator is only defined for positive numbers.')
+    if a == math.inf:
+        return math.inf
+    if a == 0:
+        return 0
+    if t == math.inf or t == 0:
+        return a
+    return a - (a // t) * t
+
+
+def add_matrices(A : np.ndarray,
+                 B : np.ndarray) -> np.ndarray:
+    if A.shape != B.shape:
+        raise ValueError('Given matrices have different shapes.')
+    result = np.copy(A)
+    shape = A.shape
+    for i in range(shape[0]):
+        for j in range(shape[1]):
+            result[i, j] = add(result[i, j], B[i, j])
+    return result
+
+
+def mult_matrices(A : np.ndarray,
+                  B : np.ndarray) -> np.ndarray:
+    if A.shape[1] != B.shape[0]:
+        raise ValueError('Given matrices are not of MxN and NxP shapes.')
+    result = np.zeros((A.shape[0], B.shape[1]))
+    for i in range(A.shape[0]):
+        for j in range(B.shape[1]):
+            result[i, j] = add(*[mult(A[i, k], B[k, j]) for k in range(A.shape[1])])
+    return result
+
+
+def power_matrix(A : np.ndarray,
+                 k : int) -> np.ndarray:
+    if np.any(np.diagonal(A) != 0):
+        raise ValueError('Matrix contains non-zero values on the diagonal.')
+    if k == 0:
+        result = unit_matrix(A.shape[0], A.shape[1])
+    else:
+        result = A.copy()
+        for _ in range(k):
+            result = mult_matrices(A, result)
+    return result
+
+
+def modulo_matrices(A : np.ndarray,
+                    b : np.ndarray) -> np.ndarray:
+    if b.shape[1] != 1:
+        raise ValueError('Given matrix b is not a vertical vector of shape Mx1')
+    if A.shape[0] != b.shape[0]:
+        raise ValueError('Given matrix b does not have an Mx1 shape against the MxN matrix A.')
+    if np.any(A < 0) or np.any(b < 0):
+        raise ValueError('Given matrices contain negative values.')
+    result = np.zeros(A.shape)
+    for i in range(A.shape[0]):
+        for j in range(A.shape[1]):
+            result[i, j] = modulo(A[i, j], b[i])
+    return result
+
+
+def unit_matrix(width : int,
+                height : int) -> np.ndarray:
+    result = np.eye(width, height)
+    result[result == 0] = math.inf
+    result[result == 1] = 0
+    return result
+
+
+def kleene_star(A : np.ndarray,
+                iterations : int = 1000) -> np.ndarray:
+    if A.shape[0] != A.shape[1]:
+        raise ValueError('Matrix is not square.')
+    series = [
+        unit_matrix(A.shape[0], A.shape[1]),
+        A.copy()
+    ]
+    for _ in range(iterations):
+        series.append(add_matrices(series[-1], mult_matrices(series[-1], series[-2])))
+    return series[-1]
+
+
+class MultivariatePolynomial:
+    """ An implementation of a tropical polynomial with multiple variables. """
+
+    def __init__(self, coefficients : np.ndarray) -> None:
+        self.coefficients = coefficients
+        self.dimensions = len(self.coefficients.shape) + 1
+        self._symbols = string.ascii_lowercase
+
+    def __call__(self, *variables : float) -> float:
+        if len(variables) != self.dimensions - 1:
+            raise ValueError('The amount of variables and coefficients differs.')
+        result = [math.inf]
+        for indices, coefficient in np.ndenumerate(self.coefficients):
+            powers = []
+            for variable_index, i in enumerate(indices):
+                powers.append(power(variables[variable_index], i))
+            result.append(mult(coefficient, *powers))
+        result = add(*result)
+        return float(result)
+
+    def __str__(self) -> str:
+        result = ''
+        for indices, coefficient in np.ndenumerate(self.coefficients):
+            if coefficient.is_integer():
+                result += '(' + str(int(coefficient))
+            elif coefficient < math.inf:
+                result += '(' + str(coefficient)
+            else:
+                result += '(∞'
+            for variable_index, i in enumerate(indices):
+                if i > 1:
+                    result += ' * ' + self._symbols[variable_index] + '^' + str(i)
+                elif i == 1:
+                    result += ' * ' + self._symbols[variable_index]
+            result += ') + '
+        return result[:-3]
+
+    def get_hyperplanes(self) -> list:
+        """ Returns a list of coefficients of a linear equation for every hyperplane building the polynomial. """
+        result = []
+        for indices, coefficient in np.ndenumerate(self.coefficients):
+            if coefficient == math.inf:
+                continue
+            hyperplane = [float(coefficient)]
+            hyperplane.extend(indices)
+            hyperplane.append(1)  # The coefficient of the last dimension (e.g. Z in 3D)
+            result.append(
+                list(
+                    map(
+                        lambda x: int(x) if x.is_integer() else float(x),
+                        hyperplane
+                    )
+                )
+            )
+        return result
+
+
+class Polynomial(MultivariatePolynomial):
+    """ An implementation of a tropical polynomial with a single variable. """
+
+    def __init__(self, *coefficients) -> None:
+        for value in coefficients:
+            if not isinstance(value, float|int) or value == -math.inf:
+                raise ValueError('Coefficient value out of domain.')
+        super().__init__(np.array(coefficients))
+
+    def get_line_intersections(self) -> list:
+        """ Returns a list of intersection points for the lines building the polynomial. """
+        result = []
+        lines = self.get_hyperplanes()  # Hyperplanes are lines in this case
+        for line in lines:  # Change the form of the equation to a + bx from a + bx + cy
+            line.pop()
+        lines = filter(lambda x: len(x) == 2, utils.powerset(lines))
+        for line_1, line_2 in lines:
+            point = [(line_2[0] - line_1[0]) / (line_1[1] - line_2[1])]
+            point.append(line_1[0] + line_1[1] * point[0])
+            result.append(tuple(point))
+        result = list(filter(lambda point: round(point[1], 8) == round(self(point[0]), 8), result))  # Filter out the points not belonging to the polynomial
+        return result
+
+    def get_roots(self) -> tuple:
+        """ Returns lists of roots of the polynomial and of their respective ranks (amount of monomials attaining the value). """
+        result = {}
+        points = self.get_line_intersections()
+        for point in points:
+            if not point[0] in result:
+                result[point[0]] = 1
+            else:
+                result[point[0]] += 1
+        return list(result.keys()), list(result.values())

mplusa-0.0.3/src/mplusa/utils.py

@@ -0,0 +1,5 @@
+from itertools import chain, combinations
+
+def powerset(iterable):
+    s = list(iterable)
+    return chain.from_iterable(combinations(s, r) for r in range(len(s) + 1))

{mplusa-0.0.1 → mplusa-0.0.3/src/mplusa.egg-info}/PKG-INFO

@@ -1,8 +1,8 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: mplusa
-Version: 0.0.1
+Version: 0.0.3
 Summary: A library for calculations in tropical and arctic semirings.
-Author-email: "Maksymilian W." <maksymilian3563@gmail.com>
+Author-email: Maksymilian Wiekiera <maksymilian3563@gmail.com>
 License: Copyright (c) 2025 Maksymilian Wiekiera
         
         Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -23,46 +23,60 @@ License: Copyright (c) 2025 Maksymilian Wiekiera
         OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
         SOFTWARE.
 Project-URL: homepage, https://github.com/Hadelekw/mplusa
+Project-URL: documentation, https://hadelekw.github.io/mplusa-docs.html
 Classifier: Programming Language :: Python :: 3
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy>=2.2.3
+Dynamic: license-file
 
 # MPlusA
 ---
-**MPlusA** is a small Python library for tropical algebra (also known as $(\min, +)$ and $(\max, +)$ algebra). It provides the definitions of basic operations on numbers and NumPy arrays, as well as a basic implementation of tropical polynomials.
+**MPlusA** is a small Python library for tropical algebra (also known as (min, +) and (max, +) algebra). It provides the definitions of basic operations on numbers and NumPy arrays, as well as a basic implementation of tropical polynomials.
 
 Any improvements or fixes are always welcome.
 
 ## How to use
-After having installed the library one can import one of the two modules the package consists of (`minplus` and `maxplus`) and use the full array of its capabilities. The functions are essentially the same between the modules. The list below is a full list of the library's capabilities.
+After having installed the library one can import one of the two modules the package consists of (`minplus` and `maxplus`) and use the full array of its capabilities. The functions are essentially the same between the modules.
 
 **`add(*args) -> Real`**
 	Tropical addition. Essentially an alias for Python's `min` function.
+
 **`mult(*args) -> Real`**
 	Tropical multiplication. Essentially an alias for Python's `sum` function.
+
 **`add_matrices(A : np.ndarray, B : np.ndarray) -> np.ndarray`**
 	Tropical addition of NumPy arrays. The summed matrices have to be of the same shape.
+
 **`mult_matrices(A : np.ndarray, B : np.ndarray) -> np.ndarray`**
 	Tropical multiplication of NumPy arrays. The multiplied matrices have to be of sizes MxN and NxP and their order matters. The result is of shape MxP.
+
 **`modulo(a : Real, t : int) -> Real`**
 	Tropical modulo operator. It can be understood as the difference between the number $a$ and $t^k$ where $k$ is the largest integer that satisfies $a \geq t^k$.
+
 **`modulo_matrices(A : np.ndarray, b : np.ndarray) -> np.ndarray`**
 	Tropical modulo operator for NumPy arrays. The input matrices should be of size MxN and Mx1. The result is an MxN matrix.
+
 **`power(a : real, k : int) -> Real`**
 	Tropical power operator.  Applies the multiplication k times.
+
 **`power_matrix(A : np.ndarray, k : int) -> np.ndarray`**
 	Tropical power operator for NumPy arrays. It multiplies the matrix k times.
+
 **`unit_matrix(width : int, height : int) -> np.ndarray`**
 	Creates a tropical unit matrix of given width and height.
+
 **`star(A : np.ndarray) -> np.ndarray`**
-	Definition of a unique operator of tropical algebra, usually denoted as $\mathbf{A}^*$. It returns the value to which an infinite recursive sum of matrices converges. The input matrix has to be square and the series created in the process of calculating the value needs to be convergent.
+	Definition of an unary operator of unique to tropical algebra, usually denoted as $\mathbf{A}^*$. It returns the value to which an infinite recursive sum of matrices converges. The input matrix has to be square and the series created in the process of calculating the value needs to be convergent.
+
 **`Polynomial(*coefficients)`**
-	This is a class that implements basic single-variable tropical polynomials. Calling an object of this class allows to take a value the polynomial takes at a given point, it also implements function `get_hypersurface` which returns a list of its roots.
+	This is a class that implements basic single-variable tropical polynomials. Calling an object of this class allows to take a value the polynomial takes at a given point.
+
+For the full list of capabilities, refer to the [documentation](https://hadelekw.github.io/mplusa-docs.html)
 
-### Example code
+## Example code
 ```
 import numpy as np
 from mplusa import minplus

{mplusa-0.0.1 → mplusa-0.0.3}/src/mplusa.egg-info/SOURCES.txt

@@ -4,6 +4,7 @@ pyproject.toml
 src/mplusa/__init__.py
 src/mplusa/maxplus.py
 src/mplusa/minplus.py
+src/mplusa/utils.py
 src/mplusa.egg-info/PKG-INFO
 src/mplusa.egg-info/SOURCES.txt
 src/mplusa.egg-info/dependency_links.txt

mplusa-0.0.1/src/mplusa/maxplus.py

@@ -1,161 +0,0 @@
-import math
-import numpy as np
-from numbers import Real
-
-
-def add(*args) -> Real:
-    return max(args)
-
-
-def mult(*args) -> Real:
-    return sum(args) if -math.inf not in args else -math.inf
-
-
-def add_matrices(A : np.ndarray,
-                 B : np.ndarray) -> np.ndarray:
-    if A.shape != B.shape:
-        raise ValueError(
-            'Maxplus.add_matrices: given matrices ' +\
-            'are of different shape (A: {}, B: {}).'.format(A.shape, B.shape)
-        )
-    result = np.copy(A)
-    shape = A.shape
-    for i in range(shape[0]):
-        for j in range(shape[1]):
-            result[i, j] = add(result[i, j], B[i, j])
-    return result
-
-
-def mult_matrices(A : np.ndarray,
-                  B : np.ndarray) -> np.ndarray:
-    if A.shape[1] != B.shape[0]:
-        raise ValueError(
-            'Maxplus.mult_matrices: given matrices ' +\
-            'are of shapes not given as MxN and NxP (A: {}, B: {}).'.format(
-                A.shape, B.shape
-            )
-        )
-    result = np.zeros((A.shape[0], B.shape[1]))
-    for i in range(A.shape[0]):
-        for j in range(B.shape[1]):
-            result[i, j] = add(*[mult(A[i, k], B[k, j]) for k in range(A.shape[1])])
-    return result
-
-
-def modulo(a : Real,
-           t : int) -> Real:
-    if a == -math.inf:
-        return -math.inf
-    if a == 0:
-        return 0
-    if t == -math.inf or t == 0:
-        return a
-    return a - (a // t) * t
-
-
-def modulo_matrices(A : np.ndarray,
-                    b : np.ndarray) -> np.ndarray:
-    if b.shape[1] != 1:
-        raise ValueError(
-            'Maxplus.modulo_matrices: given matrix b ' +\
-            'is not a properly formated vector (has shape of {}).'.format(
-                b.shape
-            )
-        )
-    if A.shape[0] != b.shape[0]:
-        raise ValueError(
-            'Maxplus.modulo_matrices: given matrix b ' +\
-            'does not have an Mx1 shape against MxN matrix A (A: {}, b: {}).'.format(
-                A.shape, b.shape
-            )
-        )
-    if np.any(A < 0) or np.any(b < 0):
-        raise ValueError(
-            'Maxplus.modulo_matrices: matrices contain negative values.'
-        )
-    result = np.zeros(A.shape)
-    for i in range(A.shape[0]):
-        for j in range(A.shape[1]):
-            result[i, j] = modulo(A[i, j], b[i])
-    return result
-
-
-def power(a : Real,
-          k : int) -> Real:
-    return mult(*[a for _ in range(k)])
-
-
-def power_matrix(A : np.ndarray,
-                 k : int) -> np.ndarray:
-    if np.any(np.diagonal(A) != 0):
-        raise ValueError(
-            'Maxplus.power_matrix: matrix contains non-zero values on diagonal.'
-        )
-    if k == 0:
-        result = unit_matrix(A.shape[0], A.shape[1])
-    else:
-        result = A.copy()
-        for _ in range(k):
-            result = mult_matrices(A, result)
-    return result
-
-
-def unit_matrix(width : int,
-                height : int) -> np.ndarray:
-    if width < 0 or height < 0:
-        raise ValueError(
-            'Maxplus.unit_matrix: invalid width or height.'
-        )
-    result = np.eye(width, height)
-    result[result == 0] = -math.inf
-    result[result == 1] = 0
-    return result
-
-
-def star(A : np.ndarray,
-         iterations : int = 1000,
-         eps : float = 0.001) -> np.ndarray:
-    if A.shape[0] != A.shape[1]:
-        raise ValueError(
-            'Maxplus.star: matrix is not square.'
-        )
-    series = [
-        unit_matrix(A.shape[0], A.shape[1]),
-        A.copy()
-    ]
-    for i in range(2, iterations):
-        series.append(add_matrices(series[-1], series[-2]))
-        # Very basic check if the series is convergent.
-        if abs(np.max(series[-1] - series[-2])) < eps:
-            break
-    else:
-        raise ValueError(
-            'Maxplus.star: the series for this matrix is not convergent ' +\
-            '(within the limits of iterations and decimal places).'
-        )
-    return series[-1]
-
-
-class Polynomial:
-    """ A simple implementation of a single-variable arctic polynomial. """
-
-    def __init__(self, *coefficients) -> None:
-        for value in coefficients:
-            if not isinstance(value, Real) or value == math.inf:
-                raise ValueError(
-                    'Maxplus.Polynomial.__init__: coefficient value out of domain.'
-                )
-        self.coefficients = coefficients[::-1]
-
-    def __call__(self, x : float) -> float:
-        return add(*[mult(coefficient, power(x, i)) for i, coefficient in enumerate(self.coefficients)])
-
-    def get_hypersurface(self) -> list[float]:
-        result = []
-        candidates = [c2 - c1 for c1, c2 in zip(self.coefficients[1:], self.coefficients[:-1])]
-        for candidate in candidates:
-            if not isinstance(candidate, Real) or candidate == math.inf:
-                continue
-            if abs(self(candidate) - self(candidate - 1)) != abs(self(candidate) - self(candidate + 1)):
-                result.append(candidate)
-        return result

mplusa-0.0.1/src/mplusa/minplus.py

@@ -1,161 +0,0 @@
-import math
-import numpy as np
-from numbers import Real
-
-
-def add(*args) -> Real:
-    return min(args)
-
-
-def mult(*args) -> Real:
-    return sum(args) if math.inf not in args else math.inf
-
-
-def add_matrices(A : np.ndarray,
-                 B : np.ndarray) -> np.ndarray:
-    if A.shape != B.shape:
-        raise ValueError(
-            'Minplus.add_matrices: given matrices ' +\
-            'are of different shape (A: {}, B: {}).'.format(A.shape, B.shape)
-        )
-    result = np.copy(A)
-    shape = A.shape
-    for i in range(shape[0]):
-        for j in range(shape[1]):
-            result[i, j] = add(result[i, j], B[i, j])
-    return result
-
-
-def mult_matrices(A : np.ndarray,
-                  B : np.ndarray) -> np.ndarray:
-    if A.shape[1] != B.shape[0]:
-        raise ValueError(
-            'Minplus.mult_matrices: given matrices ' +\
-            'are of shapes not given as MxN and NxP (A: {}, B: {}).'.format(
-                A.shape, B.shape
-            )
-        )
-    result = np.zeros((A.shape[0], B.shape[1]))
-    for i in range(A.shape[0]):
-        for j in range(B.shape[1]):
-            result[i, j] = add(*[mult(A[i, k], B[k, j]) for k in range(A.shape[1])])
-    return result
-
-
-def modulo(a : Real,
-           t : int) -> Real:
-    if a == math.inf:
-        return math.inf
-    if a == 0:
-        return 0
-    if t == math.inf or t == 0:
-        return a
-    return a - (a // t) * t
-
-
-def modulo_matrices(A : np.ndarray,
-                    b : np.ndarray) -> np.ndarray:
-    if b.shape[1] != 1:
-        raise ValueError(
-            'Minplus.modulo_matrices: given matrix b ' +\
-            'is not a properly formated vector (has shape of {}).'.format(
-                b.shape
-            )
-        )
-    if A.shape[0] != b.shape[0]:
-        raise ValueError(
-            'Minplus.modulo_matrices: given matrix b ' +\
-            'does not have an Mx1 shape against MxN matrix A (A: {}, b: {}).'.format(
-                A.shape, b.shape
-            )
-        )
-    if np.any(A < 0) or np.any(b < 0):
-        raise ValueError(
-            'Minplus.modulo_matrices: matrices contain negative values.'
-        )
-    result = np.zeros(A.shape)
-    for i in range(A.shape[0]):
-        for j in range(A.shape[1]):
-            result[i, j] = modulo(A[i, j], b[i])
-    return result
-
-
-def power(a : Real,
-          k : int) -> Real:
-    return mult(*[a for _ in range(k)])
-
-
-def power_matrix(A : np.ndarray,
-                 k : int) -> np.ndarray:
-    if np.any(np.diagonal(A) != 0):
-        raise ValueError(
-            'Minplus.power_matrix: matrix contains non-zero values on diagonal.'
-        )
-    if k == 0:
-        result = unit_matrix(A.shape[0], A.shape[1])
-    else:
-        result = A.copy()
-        for _ in range(k):
-            result = mult_matrices(A, result)
-    return result
-
-
-def unit_matrix(width : int,
-                height : int) -> np.ndarray:
-    if width < 0 or height < 0:
-        raise ValueError(
-            'Minplus.unit_matrix: invalid width or height.'
-        )
-    result = np.eye(width, height)
-    result[result == 0] = math.inf
-    result[result == 1] = 0
-    return result
-
-
-def star(A : np.ndarray,
-         iterations : int = 1000,
-         eps : float = 0.001) -> np.ndarray:
-    if A.shape[0] != A.shape[1]:
-        raise ValueError(
-            'Minplus.star: matrix is not square.'
-        )
-    series = [
-        unit_matrix(A.shape[0], A.shape[1]),
-        A.copy()
-    ]
-    for i in range(2, iterations):
-        series.append(add_matrices(series[-1], series[-2]))
-        # Very basic check if the series is convergent.
-        if abs(np.max(series[-1] - series[-2])) < eps:
-            break
-    else:
-        raise ValueError(
-            'Minplus.star: the series for this matrix is not convergent ' +\
-            '(within the limits of iterations and decimal places).'
-        )
-    return series[-1]
-
-
-class Polynomial:
-    """ A simple implementation of a single-variable tropical polynomial. """
-
-    def __init__(self, *coefficients) -> None:
-        for value in coefficients:
-            if not isinstance(value, Real) or value == -math.inf:
-                raise ValueError(
-                    'Minplus.Polynomial.__init__: coefficient value out of domain.'
-                )
-        self.coefficients = coefficients[::-1]
-
-    def __call__(self, x : float) -> float:
-        return add(*[mult(coefficient, power(x, i)) for i, coefficient in enumerate(self.coefficients)])
-
-    def get_hypersurface(self) -> list[float]:
-        result = []
-        candidates = [c2 - c1 for c1, c2 in zip(self.coefficients[1:], self.coefficients[:-1])]
-        for candidate in candidates:
-            if not isinstance(candidate, Real) or candidate == -math.inf:
-                continue
-            if abs(self(candidate) - self(candidate - 1)) != abs(self(candidate) - self(candidate + 1)):
-                result.append(candidate)
-        return result