mplusa 0.0.1__py3-none-any.whl → 0.0.4__py3-none-any.whl

mplusa/minplus/geometry.py

@@ -0,0 +1,214 @@
+import numpy as np
+
+import math
+from collections.abc import Collection
+
+from .domain import validate_domain
+from .minplus 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/minplus/minplus.py

@@ -0,0 +1,245 @@
+import numpy as np
+
+import math
+import string
+
+from .domain import validate_domain
+from .. import utils
+
+
+def add(*args : float) -> float:
+    validate_domain(args)
+    return min(args)
+
+
+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:
+    return mult(*[a for _ in range(k)])
+
+
+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:
+        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:
+    validate_domain([A, B])
+    return np.minimum(A, B)
+
+
+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 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 mult_arrays(A : np.ndarray, B : np.ndarray) -> np.ndarray:
+    """
+    Performs tropical 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 tropical 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:
+    if A.shape[0] != A.shape[1]:
+        raise ValueError('Matrix is not square.')
+    series = [
+        unit_matrix(A.shape[0], A.shape[1]),
+        A.copy()
+    ]
+    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 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
+
+    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 : list[float] = []
+            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_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):
+            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 : float|int) -> None:
+        validate_domain(coefficients)
+        super().__init__(np.array(coefficients))
+
+    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_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()
+        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[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 point[0] not in result:
+                result[point[0]] = 1
+            else:
+                result[point[0]] += 1
+        return list(result.keys()), list(result.values())

mplusa/minplus/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/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.4.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,17 @@
+mplusa/__init__.py,sha256=8D1JvAZfjHkQ1DOqrxLyXWMEfROgGwf8Y41-rSX51cY,44
+mplusa/utils.py,sha256=Q5gXJJ06N1Nt65Ept3qRreWvyBC552DsiEkAHHT2IWE,168
+mplusa/maxplus/__init__.py,sha256=EWuzzBdP7UJqWuJGTz3OTAMbN_gOvO3QOWOdVFLTWHA,92
+mplusa/maxplus/domain.py,sha256=h5ggcrlPWH8b1EsxJ1OZmIt49IGcOqQHYqqYltUaXoE,654
+mplusa/maxplus/geometry.py,sha256=IEnRup5wLjB0A2o9MWVsRw6V0gMCp7lVC7evlk72PDo,8097
+mplusa/maxplus/maxplus.py,sha256=mqfbH-GNsIOW0IicwcK6y6VMBmBVRZGzD8k-69ZDPTo,8758
+mplusa/maxplus/visualize.py,sha256=HfMyVCsw3sB6o-5wPGHaIEiePwaDRXb9pynAqVoB4l0,2467
+mplusa/minplus/__init__.py,sha256=w2DjNCWlMKCd9Lxr7PSl1CXLPxbFec84OrpyhRPCVB8,92
+mplusa/minplus/domain.py,sha256=cepeADI6_pY5eF7ufVH4udKN8J_7Z--Qhi6ONDe-QCQ,663
+mplusa/minplus/geometry.py,sha256=InE_5tUkMbQl9nalgsaDb0eBrrWmLiAPbmNxOCKEnAw,8096
+mplusa/minplus/minplus.py,sha256=ANNZBh4GLpDsAwVt7O91_W3NuNds9jwEJki8o35cBvY,8752
+mplusa/minplus/visualize.py,sha256=HfMyVCsw3sB6o-5wPGHaIEiePwaDRXb9pynAqVoB4l0,2467
+mplusa-0.0.4.dist-info/licenses/LICENSE,sha256=x1S-x_tM1tAmndGsdQKT4DU9LnstfQRgS4befak4XdA,1063
+mplusa-0.0.4.dist-info/METADATA,sha256=qWqe_Ca3GvdEjJJPNYIx6VvxYzIninQcz3p83iEpMQI,2675
+mplusa-0.0.4.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+mplusa-0.0.4.dist-info/top_level.txt,sha256=W5b7P8CkZ-DB3-2K0Rcf0T0tpEuWLCbZBaVgrd7FEcM,7
+mplusa-0.0.4.dist-info/RECORD,,

{mplusa-0.0.1.dist-info → mplusa-0.0.4.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.9.1)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any