mplusa 0.0.3__tar.gz → 0.0.4__tar.gz

mplusa-0.0.4/PKG-INFO

@@ -0,0 +1,46 @@
+Metadata-Version: 2.4
+Name: mplusa
+Version: 0.0.4
+Summary: A library for calculations in tropical and arctic semirings.
+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
+        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.
+Project-URL: homepage, https://github.com/Hadelekw/mplusa
+Project-URL: documentation, https://maksymilian-wiekiera.fyi/mplusa/0.0.4.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 Python library for calculations in tropical algebra (also known as (min, +) and (max, +) algebra). For the full list of the library's capabilities refer to the [documentation](http://maksymilian-wiekiera.fyi/mplusa/0_0_4.html).
+
+# Contributing
+The library is open for all contributions. If you want to contribute to its development, please refer to the guidelines to verify the code standards before making a pull request. Developments from all areas of tropical mathematics are welcome.
+
+# Installation
+The easiest way to install the library is to use pip.
+
+``` pip install mplusa ```
+
+The only automatically installed dependency is [NumPy](https://numpy.org). Otherwise the library does make use of [Matplotlib](https://matplotlib.org/) for visualisations but it is not a required dependency and needs to be installed separately in case the user wants to use these capabilities.

mplusa-0.0.4/README.md

@@ -0,0 +1,12 @@
+# MPlusA
+**MPlusA** is a Python library for calculations in tropical algebra (also known as (min, +) and (max, +) algebra). For the full list of the library's capabilities refer to the [documentation](http://maksymilian-wiekiera.fyi/mplusa/0_0_4.html).
+
+# Contributing
+The library is open for all contributions. If you want to contribute to its development, please refer to the guidelines to verify the code standards before making a pull request. Developments from all areas of tropical mathematics are welcome.
+
+# Installation
+The easiest way to install the library is to use pip.
+
+``` pip install mplusa ```
+
+The only automatically installed dependency is [NumPy](https://numpy.org). Otherwise the library does make use of [Matplotlib](https://matplotlib.org/) for visualisations but it is not a required dependency and needs to be installed separately in case the user wants to use these capabilities.

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

@@ -1,6 +1,6 @@
 [project]
 name = "mplusa"
-version = "0.0.3"
+version = "0.0.4"
 authors = [
     {name="Maksymilian Wiekiera", email="maksymilian3563@gmail.com"}
 ]
@@ -18,4 +18,4 @@ license = {file="LICENSE"}
 
 [project.urls]
 homepage = "https://github.com/Hadelekw/mplusa"
-documentation = "https://hadelekw.github.io/mplusa-docs.html"
+documentation = "https://maksymilian-wiekiera.fyi/mplusa/0.0.4.html"

mplusa-0.0.4/src/mplusa/maxplus/__init__.py

@@ -0,0 +1,4 @@
+from .maxplus import *
+from .domain import *
+from . import geometry
+from . import visualize

mplusa-0.0.4/src/mplusa/maxplus/domain.py

@@ -0,0 +1,27 @@
+import numpy as np
+
+import math
+from typing import Any
+from collections.abc import Collection
+
+
+class ArcticNumberMeta(type):
+    def __instancecheck__(self, instance: Any, /) -> bool:
+        if isinstance(instance, float|int|np.floating|np.integer):
+            if instance < math.inf:
+                return True
+        return False
+
+
+class ArcticNumber(metaclass=ArcticNumberMeta):
+    pass
+
+
+def validate_domain(value : Any) -> None:
+    if isinstance(value, Collection):
+        for item in value:
+            validate_domain(item)
+        return
+    if isinstance(value, ArcticNumber):
+        return
+    raise ValueError('Value out of domain.')

mplusa-0.0.4/src/mplusa/maxplus/geometry.py

@@ -0,0 +1,214 @@
+import numpy as np
+
+import math
+from collections.abc import Collection
+
+from .domain import validate_domain
+from .maxplus import add, mult, add_matrices
+
+
+def project_point(point : tuple) -> tuple:
+    validate_domain(point)
+    return tuple((point[i] - point[0]) for i in range(1, len(point)))
+
+
+def point_type(point : Collection, vertices : Collection, indexing_start : int = 0) -> Collection:
+    result = [[] for _ in range(len(vertices))]
+    point = np.array(point)
+    vertices = np.array(vertices)
+    for i, vertex in enumerate(vertices):
+        comparison = add(*(vertex - point))
+        for j in range(len(vertex)):
+            if vertex[j] - point[j] == comparison:
+                result[j].append(indexing_start + i)
+    return result
+
+
+def tconv(points : Collection[Collection]) -> list:
+    result = []
+    for point in points:
+        T = point_type(point, list(filter(lambda v: v != point, points)))
+        if [] in T:
+            result.append(point)
+    return result
+
+
+def line_segment(start_point : Collection, end_point : Collection, sort=True, unique=True) -> np.ndarray:
+    x = np.array(start_point)
+    y = np.array(end_point)
+    result = []
+    for i in range(len(x)):
+        if y[i] <= x[i]:
+            result.append(add_matrices((y[i] - x[i]) + x, y))
+        else:
+            result.append(add_matrices((x[i] - y[i]) + y, x))
+    result = list(map(tuple, result))
+    if unique:
+        result = list(set(result))
+    if sort:
+        result = sort_line_segment(result, tuple(start_point))
+    return np.array(result)
+
+
+def sort_line_segment(points : list[tuple], start_point : tuple) -> list:
+    points.remove(start_point)
+    stack = [start_point]
+    while points:
+        # The line segments in tropical geometry have limited slopes and are always convex
+        # Therefore the closest point (in Euclidean sense) is the next point in order
+        distances = {
+            math.sqrt(
+                sum(
+                    (p[i] - stack[-1][i])**2 for i in range(len(start_point))
+                )
+            ): p for p in points
+        }
+        stack.append(distances[min(distances.keys())])
+        points.remove(stack[-1])
+    return stack
+
+
+class ConvexCone:
+
+    def __init__(self, *vectors : Collection[float|int]) -> None:
+        validate_domain(vectors)
+        self.vectors = np.array(vectors)  # generators of the cone
+        self.vector_count = self.vectors.shape[0]
+        self.dimensions = self.vectors.shape[1]
+
+    def get_point(self, constants : Collection[float|int]) -> np.ndarray:
+        if len(constants) != self.vector_count:
+            raise ValueError('The number of constants not equal the number of generators of the cone.')
+        result = np.array([-math.inf for _ in range(self.dimensions)])
+        for constant, vector in zip(constants, self.vectors):
+            result = add_matrices(result, vector + constant)  # Addition here is tropical multiplication
+        return result
+
+    def sample_points(self, constants_collection : Collection[np.ndarray]) -> np.ndarray:
+        result = []
+        grid = np.meshgrid(*constants_collection)
+        for constants in np.nditer(grid):
+            result.append(self.get_point([float(s) for s in constants]))
+        result = np.array(result)
+        return result
+
+
+class Hyperplane:
+    """ An implementation of a tropical hyperplane structure. """
+
+    def __init__(self, *coefficients : float) -> None:
+        validate_domain(coefficients)
+        self.coefficients = coefficients
+        self.dimension = len(coefficients)
+
+    def get_value(self, point : Collection[float]) -> float:
+        """ Calculate the value which the hyperplane achieves at a given point. """
+        if len(point) != self.dimension:
+            raise ValueError('The amount of the point\'s coordinates and the coefficients differs.')
+        result = add(*[mult(c, p) for c, p in zip(self.coefficients, point)])
+        return result
+
+    def get_apex(self) -> tuple:
+        """ Returns the coordinates of the point that serves as the apex of the hyperplane. """
+        return tuple([-coefficient for coefficient in self.coefficients])
+
+
+def hyperplane_from_apex(point : Collection[float|int]) -> Hyperplane:
+    return Hyperplane(*[-coordinate for coordinate in point])
+
+
+class AbstractPolytope:
+    """ An implementation of a tropical polytope structure. """
+
+    def __init__(self, faces_collection : list, normalize_points : bool = False) -> None:
+        if normalize_points:
+            faces_collection[0] = [(0, *face) for face in faces_collection[0]]
+        self.dimension = len(faces_collection[0][0]) - 1  # The dimension is defined by the coordinates of the first point
+        self.structure = {}
+        for rank, faces in enumerate(faces_collection):
+            validate_domain(faces)
+            self.structure[rank] = np.array(faces)
+        self._validate_vertices_dimension()
+
+    def _validate_vertices_dimension(self) -> None:
+        for vertex in self.structure[0]:
+            if len(vertex) - 1 != self.dimension:
+                raise ValueError('Incorrect dimension of the vertices\' coordinates.')
+
+    @property
+    def vertices(self) -> np.ndarray:
+        """ Returns all points generating the tropical polytope. """
+        return self.structure[0]
+
+    @property
+    def pseudovertices(self) -> np.ndarray:
+        """ Returns all points that are generated by the tropical polytope. """
+        result = []
+        for line_segment in self.get_all_line_segments():
+            for point in line_segment:
+                if not np.any(np.all(self.vertices == point, axis=1)):  # if point not in vertices
+                    result.append(point)
+        return np.array(result)
+
+    @property
+    def edges(self) -> list:
+        """ Returns all the edges (given as a pair of points) which build the tropical polytope. """
+        result = []
+        for vertices_identifiers in self.structure[1]:
+            result.append([])
+            for identifier in vertices_identifiers:
+                result[-1].append(self.vertices[identifier])
+        return result
+
+    def get_line_segments(self, edge_index : int, sort : bool = True) -> np.ndarray:
+        """ Returns a list of points belonging to a line segment of the polytope. """
+        start_point, end_point = self.edges[edge_index]
+        return np.array(line_segment(start_point, end_point, sort=sort))
+
+    def get_all_line_segments(self) -> list:
+        """ Returns all line segments building the polytope. """
+        result = []
+        for i in range(len(self.structure[1])):
+            result.append(self.get_line_segments(i, sort=True))
+        return result
+
+    def _verify_facet_definition(self, point : Collection) -> bool:
+        """ Verify if a point is facet-defining in the polynomial. """
+        T = point_type(point, self.vertices)
+        union = []
+        for t in T:
+            union.extend(t)
+        union = list(set(union))
+        if len(union) >= self.dimension:
+            return True
+        else:
+            return False
+
+    def get_apices(self) -> list:
+        """ Returns an array of apices corresponding to the polynomial-defining half-spaces. """
+        result = []
+        for pseudovertex in self.pseudovertices:
+            if self._verify_facet_definition(pseudovertex):
+                result.append(pseudovertex)
+        return result
+
+    def get_hyperplanes(self) -> list:
+        """ Returns a list of the facet-defining hyperplanes. """
+        result = []
+        for apex in self.get_apices():
+            result.append(hyperplane_from_apex(apex))
+        return result
+
+
+class Polytope2D(AbstractPolytope):
+
+    def __init__(self, *points : Collection) -> None:
+        self.dimension = len(points[0]) - 1
+        faces_collection = [list(points)]
+        edges = []
+        for i in range(1, len(points)):
+            edges.append((i - 1, i))
+        edges.append((len(points) - 1, 0))
+        faces_collection.append(edges)
+        faces_collection.append([tuple(range(len(edges)))])
+        super().__init__(faces_collection)

{mplusa-0.0.3/src/mplusa → mplusa-0.0.4/src/mplusa/maxplus}/maxplus.py

@@ -3,28 +3,26 @@ import numpy as np
 import math
 import string
 
-from . import utils
+from .domain import validate_domain
+from .. import utils
 
 
-def add(*args) -> float:
-    if math.inf in args:
-        raise ValueError('Value out of domain.')
+def add(*args : float) -> float:
+    validate_domain(args)
     return max(args)
 
 
-def mult(*args) -> float:
-    if math.inf in args:
-        raise ValueError('Value out of domain.')
+def mult(*args : float) -> float:
+    validate_domain(args)
     return sum(args) if -math.inf not in args else -math.inf
 
 
-def power(a : float,
-          k : int) -> float:
+def power(a : float, k : int) -> float:
     return mult(*[a for _ in range(k)])
 
 
-def modulo(a : float,
-           t : int) -> float:
+def modulo(a : float, t : int) -> float:
+    validate_domain([a, t])
     if a < 0 or t < 0:
         raise ValueError('The modulo operator is only defined for positive numbers.')
     if a == -math.inf:
@@ -36,20 +34,12 @@ def modulo(a : float,
     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 add_matrices(A : np.ndarray, B : np.ndarray) -> np.ndarray:
+    validate_domain([A, B])
+    return np.maximum(A, B)
 
 
-def mult_matrices(A : np.ndarray,
-                  B : np.ndarray) -> np.ndarray:
+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]))
@@ -59,10 +49,7 @@ def mult_matrices(A : np.ndarray,
     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.')
+def power_matrix(A : np.ndarray, k : int) -> np.ndarray:
     if k == 0:
         result = unit_matrix(A.shape[0], A.shape[1])
     else:
@@ -72,8 +59,7 @@ def power_matrix(A : np.ndarray,
     return result
 
 
-def modulo_matrices(A : np.ndarray,
-                    b : np.ndarray) -> np.ndarray:
+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]:
@@ -87,31 +73,92 @@ def modulo_matrices(A : np.ndarray,
     return result
 
 
-def unit_matrix(width : int,
-                height : int) -> np.ndarray:
+def mult_arrays(A : np.ndarray, B : np.ndarray) -> np.ndarray:
+    """
+    Performs arctic tensor multiplication of NumPy arrays of any shape.
+    The operation is defined as:
+
+    A_{i_0, ..., i_k} * B_{j_0, ..., j_k} = C_{i_0, ..., i_k, j_0, ..., j_k}
+
+    where each element of C is calculated by arctic multiplication of the values in the arrays.
+    """
+    result = np.zeros((*A.shape, *B.shape))
+    for i, value in np.ndenumerate(A):
+        for j, other_value in np.ndenumerate(B):
+            result[*i, *j] = mult(value, other_value)
+    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:
+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]
+    result = add_matrices(series[0], series[1])
+    for i in range(iterations):
+        series.append(power_matrix(A, i))
+        result = add_matrices(result, series[-1])
+        if np.all(series[-1] - series[-2] > 0):  # If the values of the matrix are growing
+            break
+    return result
+
+
+def kleene_plus(A : np.ndarray, iterations : int = 1000) -> np.ndarray:
+    if A.shape[0] != A.shape[1]:
+        raise ValueError('Matrix is not square.')
+    series = [A.copy()]
+    result = series[0]
+    for i in range(1, iterations):
+        series.append(power_matrix(A, i))
+        result = add_matrices(result, series[-1])
+        if np.all(series[-1] - series[-2] > 0):  # If the values of the matrix are growing
+            break
+    return result
+
+
+def power_algorithm(A : np.ndarray, x_0 : np.ndarray|None = None, iterations : int = 1000) -> tuple:
+    if x_0 is None:
+        x_0 = np.ones((A.shape[1], 1))
+    xs = [x_0]
+    for i in range(iterations):
+        xs.append(mult_matrices(A, xs[i]))
+        for j in range(len(xs) - 1):
+            if len(np.unique(xs[-1] - xs[j])) == 1:
+                p = len(xs) - 1
+                q = j
+                c = float(np.unique(xs[-1] - xs[j])[0])
+                return p, q, c, xs
+    raise ValueError(f'Unable to find the values using the power algorithm within {iterations} iterations.')
+
+
+def eigenvalue(A : np.ndarray) -> float:
+    p, q, c, _ = power_algorithm(A)
+    return c / (p - q)
+
+
+def eigenvector(A : np.ndarray) -> np.ndarray:
+    p, q, c, xs = power_algorithm(A)
+    eigenvalue = c / (p - q)
+    result = np.ones_like(xs[0]) * math.inf
+    for i in range(1, p - q + 1):
+        result = add_matrices(result, power(eigenvalue, (p - q - i)) + xs[q + i - 1])
+    return result
 
 
 class MultivariatePolynomial:
-    """ An implementation of an arctic polynomial with multiple variables. """
+    """ An implementation of a tropical polynomial with multiple variables. """
 
     def __init__(self, coefficients : np.ndarray) -> None:
+        validate_domain(coefficients)
         self.coefficients = coefficients
         self.dimensions = len(self.coefficients.shape) + 1
         self._symbols = string.ascii_lowercase
@@ -121,7 +168,7 @@ class MultivariatePolynomial:
             raise ValueError('The amount of variables and coefficients differs.')
         result = [-math.inf]
         for indices, coefficient in np.ndenumerate(self.coefficients):
-            powers = []
+            powers : list[float] = []
             for variable_index, i in enumerate(indices):
                 powers.append(power(variables[variable_index], i))
             result.append(mult(coefficient, *powers))
@@ -145,7 +192,7 @@ class MultivariatePolynomial:
             result += ') + '
         return result[:-3]
 
-    def get_hyperplanes(self) -> list:
+    def get_linear_hyperplanes(self) -> list[list[float|int]]:
         """ Returns a list of coefficients of a linear equation for every hyperplane building the polynomial. """
         result = []
         for indices, coefficient in np.ndenumerate(self.coefficients):
@@ -168,18 +215,16 @@ class MultivariatePolynomial:
 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.')
+    def __init__(self, *coefficients : float|int) -> None:
+        validate_domain(coefficients)
         super().__init__(np.array(coefficients))
 
-    def get_line_intersections(self) -> list:
+    def get_line_intersections(self) -> list[list[float|int]]:
         """ Returns a list of intersection points for the lines building the polynomial. """
         result = []
-        lines = self.get_hyperplanes()  # Hyperplanes are lines in this case
+        lines = self.get_linear_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()
+            _ = 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])]
@@ -188,12 +233,12 @@ class Polynomial(MultivariatePolynomial):
         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). """
+    def get_roots(self) -> tuple[list[float|int], list[int]]:
+        """ Returns lists of roots of the polynomial and of their respective ranks (the amount of monomials attaining the value). """
         result = {}
         points = self.get_line_intersections()
         for point in points:
-            if not point[0] in result:
+            if point[0] not in result:
                 result[point[0]] = 1
             else:
                 result[point[0]] += 1

mplusa-0.0.4/src/mplusa/maxplus/visualize.py

@@ -0,0 +1,65 @@
+import matplotlib.pyplot as plt
+from matplotlib.ticker import MaxNLocator
+
+from .geometry import AbstractPolytope, project_point
+
+
+def hasse_diagram(polytope : AbstractPolytope) -> None:
+    """ Draws and shows the Hasse diagram of the given polytope using matplotlib. """
+    _, ax = plt.subplots()
+    ax.set_xticks([])
+    ax.yaxis.set_major_locator(MaxNLocator(integer=True))
+    ax.yaxis.tick_right()
+    ax.yaxis.set_label_position('right')
+    ax.set_ylabel('Rank')
+    for spine in ['top', 'left', 'bottom']:
+        ax.spines[spine].set_visible(False)
+    width = max(map(len, polytope.structure.values()))
+    layers = {}
+    for rank, layer in polytope.structure.items():
+        points = []
+        for i, connections in enumerate(layer):
+            x = (i * width) / (len(layer) - 1) if len(layer) > 1 else width / 2
+            points.append((x, rank))
+            if rank > 0:
+                for connection in connections:
+                    ax.plot(
+                        [x, layers[rank - 1][connection][0]],
+                        [rank, layers[rank - 1][connection][1]],
+                        color='black'
+                    )
+        layers[rank] = points
+        for i, point in enumerate(points):
+            ax.text(
+                point[0], point[1], str(i),
+                ha='center', va='center', fontsize=10,
+                bbox={
+                    'facecolor': 'white',
+                    'edgecolor': 'black',
+                    'boxstyle': 'circle',
+                }
+            )
+    plt.show()
+
+
+def draw_polytope2D(polytope : AbstractPolytope) -> None:
+    """ Draws a given polytope on a 2-dimensional surface using matplotlib. """
+    if polytope.dimension < 2:
+        raise NotImplementedError('Projection of polytopes of lesser dimensions not implemented currently.')
+    if polytope.dimension != 2:
+        raise ValueError('The polytope cannot be projected onto a 2-dimensional surface.')
+    vertices = list(map(project_point, polytope.vertices))
+    plt.scatter(
+        [vertex[0] for vertex in vertices],
+        [vertex[1] for vertex in vertices],
+        color='black'
+    )
+    line_segments = polytope.get_all_line_segments()
+    for line_segment in line_segments:
+        line_segment = list(map(project_point, line_segment))
+        plt.plot(
+            [vertex[0] for vertex in line_segment],
+            [vertex[1] for vertex in line_segment],
+            color='black'
+        )
+    plt.show()

mplusa-0.0.4/src/mplusa/minplus/__init__.py

@@ -0,0 +1,4 @@
+from .minplus import *
+from .domain import *
+from . import geometry
+from . import visualize

mplusa-0.0.4/src/mplusa/minplus/domain.py

@@ -0,0 +1,27 @@
+import numpy as np
+
+import math
+from typing import Any
+from collections.abc import Collection
+
+
+class TropicalNumberMeta(type):
+    def __instancecheck__(self, instance: Any, /) -> bool:
+        if isinstance(instance, float|int|np.floating|np.integer):
+            if instance > -math.inf:
+                return True
+        return False
+
+
+class TropicalNumber(metaclass=TropicalNumberMeta):
+    pass
+
+
+def validate_domain(value : Any) -> None:
+    if isinstance(value, Collection):
+        for item in value:
+            validate_domain(item)
+        return
+    if isinstance(value, TropicalNumber):
+        return
+    raise ValueError('Value out of domain.')