PyPI - kap - Versions diffs - 0.2.0__tar.gz → 0.2.2__tar.gz - Mend

kap 0.2.0tar.gz → 0.2.2tar.gz

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (16) hide show

{kap-0.2.0 → kap-0.2.2}/PKG-INFO +23 -4
{kap-0.2.0 → kap-0.2.2}/README.md +17 -2
kap-0.2.2/kap/_version.py +1 -0
{kap-0.2.0 → kap-0.2.2}/kap/assignment.py +24 -12
{kap-0.2.0 → kap-0.2.2}/kap.egg-info/PKG-INFO +23 -4
{kap-0.2.0 → kap-0.2.2}/setup.cfg +3 -0
kap-0.2.0/kap/_version.py +0 -1
{kap-0.2.0 → kap-0.2.2}/LICENSE.txt +0 -0
{kap-0.2.0 → kap-0.2.2}/kap/__init__.py +0 -0
{kap-0.2.0 → kap-0.2.2}/kap/_types.py +0 -0
{kap-0.2.0 → kap-0.2.2}/kap.egg-info/SOURCES.txt +0 -0
{kap-0.2.0 → kap-0.2.2}/kap.egg-info/dependency_links.txt +0 -0
{kap-0.2.0 → kap-0.2.2}/kap.egg-info/not-zip-safe +0 -0
{kap-0.2.0 → kap-0.2.2}/kap.egg-info/requires.txt +0 -0
{kap-0.2.0 → kap-0.2.2}/kap.egg-info/top_level.txt +0 -0
{kap-0.2.0 → kap-0.2.2}/setup.py +0 -0

{kap-0.2.0 → kap-0.2.2}/PKG-INFO RENAMED Viewed

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: kap
-Version: 0.2.0
+Version: 0.2.2
 Summary: Gabrovšek's Multiple Hungarian method for solving k-Assignment Problem.
 Home-page: https://github.com/inspiros/kap
 Author: Hoang-Nhat Tran (inspiros)
@@ -20,16 +20,20 @@ Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Operating System :: OS Independent
 Classifier: Topic :: Scientific/Engineering :: Mathematics
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
 Requires-Dist: numpy
+Dynamic: license-file
 ``kap``: $k$-Assignment Problem Solver
 ======
-[![Build wheels](https://github.com/inspiros/kap/actions/workflows/build_wheels.yml/badge.svg)](https://github.com/inspiros/kap/actions) [![PyPI](https://img.shields.io/pypi/v/kap)](https://pypi.org/project/kap) [![Downloads](https://static.pepy.tech/badge/kap)](https://pepy.tech/project/kap) [![License](https://img.shields.io/github/license/inspiros/kap)](https://github.com/inspiros/kap/blob/master/LICENSE.txt)
+[![Build wheels](https://github.com/inspiros/kap/actions/workflows/build_wheels.yml/badge.svg)](https://github.com/inspiros/kap/actions) [![PyPI](https://img.shields.io/pypi/v/kap)](https://pypi.org/project/kap) [![Downloads](https://static.pepy.tech/badge/kap)](https://pepy.tech/project/kap) [![License](https://img.shields.io/github/license/inspiros/kap)](https://github.com/inspiros/kap/blob/master/LICENSE.txt) [![DOI](https://zenodo.org/badge/731651337.svg)](https://zenodo.org/doi/10.5281/zenodo.10449790)
 This project implements **Boštjan Gabrovšek**'s Multiple Hungarian Methods for solving the **$k$-Assignment Problem**
 (or **$k$-Partite Graph Matching Problem**), described in [this paper](https://www.mdpi.com/2227-7390/8/11/2050).
@@ -43,7 +47,7 @@ This project implements **Boštjan Gabrovšek**'s Multiple Hungarian Methods for
 It is also traditionally referred to as **Multidimensional Assignment Problem**.
 <p align="center">
-    <img src="https://raw.githubusercontent.com/inspiros/kap/master/resources/tripartite_matching_example.png" width="300">
+    <img src="https://raw.githubusercontent.com/inspiros/kap/master/resources/tripartite_matching_example.svg" width="300">
 </p>
 Formally, we seek a $k$-assignment of a given $k$-partite weighted graph $G = (V, E, \omega)$ with the minimum weight:
@@ -177,6 +181,21 @@ print("Total cost:", sum(matching_result.matching_costs))
 These code blocks are extracted from [examples](examples).
+## Citation
+```bibtex
+@software{inspiros_2024_10449791,
+  author       = {Hoang-Nhat Tran},
+  title        = {inspiros/kap: v0.2.1},
+  month        = jan,
+  year         = 2024,
+  publisher    = {Zenodo},
+  version      = {v0.2.1},
+  doi          = {10.5281/zenodo.10449791},
+  url          = {https://doi.org/10.5281/zenodo.10449791}
+}
+```
 ## License
 MIT licensed. See [LICENSE.txt](LICENSE.txt).

{kap-0.2.0 → kap-0.2.2}/README.md RENAMED Viewed

@@ -1,6 +1,6 @@
 ``kap``: $k$-Assignment Problem Solver
 ======
-[![Build wheels](https://github.com/inspiros/kap/actions/workflows/build_wheels.yml/badge.svg)](https://github.com/inspiros/kap/actions) [![PyPI](https://img.shields.io/pypi/v/kap)](https://pypi.org/project/kap) [![Downloads](https://static.pepy.tech/badge/kap)](https://pepy.tech/project/kap) [![License](https://img.shields.io/github/license/inspiros/kap)](https://github.com/inspiros/kap/blob/master/LICENSE.txt)
+[![Build wheels](https://github.com/inspiros/kap/actions/workflows/build_wheels.yml/badge.svg)](https://github.com/inspiros/kap/actions) [![PyPI](https://img.shields.io/pypi/v/kap)](https://pypi.org/project/kap) [![Downloads](https://static.pepy.tech/badge/kap)](https://pepy.tech/project/kap) [![License](https://img.shields.io/github/license/inspiros/kap)](https://github.com/inspiros/kap/blob/master/LICENSE.txt) [![DOI](https://zenodo.org/badge/731651337.svg)](https://zenodo.org/doi/10.5281/zenodo.10449790)
 This project implements **Boštjan Gabrovšek**'s Multiple Hungarian Methods for solving the **$k$-Assignment Problem**
 (or **$k$-Partite Graph Matching Problem**), described in [this paper](https://www.mdpi.com/2227-7390/8/11/2050).
@@ -14,7 +14,7 @@ This project implements **Boštjan Gabrovšek**'s Multiple Hungarian Methods for
 It is also traditionally referred to as **Multidimensional Assignment Problem**.
 <p align="center">
-    <img src="https://raw.githubusercontent.com/inspiros/kap/master/resources/tripartite_matching_example.png" width="300">
+    <img src="https://raw.githubusercontent.com/inspiros/kap/master/resources/tripartite_matching_example.svg" width="300">
 </p>
 Formally, we seek a $k$-assignment of a given $k$-partite weighted graph $G = (V, E, \omega)$ with the minimum weight:
@@ -148,6 +148,21 @@ print("Total cost:", sum(matching_result.matching_costs))
 These code blocks are extracted from [examples](examples).
+## Citation
+```bibtex
+@software{inspiros_2024_10449791,
+  author       = {Hoang-Nhat Tran},
+  title        = {inspiros/kap: v0.2.1},
+  month        = jan,
+  year         = 2024,
+  publisher    = {Zenodo},
+  version      = {v0.2.1},
+  doi          = {10.5281/zenodo.10449791},
+  url          = {https://doi.org/10.5281/zenodo.10449791}
+}
+```
 ## License
 MIT licensed. See [LICENSE.txt](LICENSE.txt).

kap-0.2.2/kap/_version.py ADDED Viewed

	@@ -0,0 +1 @@
1	+ __version__ = '0.2.2'

{kap-0.2.0 → kap-0.2.2}/kap/assignment.py RENAMED Viewed

@@ -182,7 +182,7 @@ class KPartiteGraph:
                     cost_ij[:, n_matches_12 + n_free_1:] = cost_i2[:, free_2]
                     quotient_cost_matrices.append(cost_ij)
                 else:
-                    quotient_cost_matrices.append(self[i, j].clone())
+                    quotient_cost_matrices.append(self[i, j].copy())
         quotient_node_indices = KPartiteNamedNodeList()
         for i in range(self.n_partites - 1):
@@ -486,7 +486,8 @@ def _Em_loop(G: KPartiteGraph,
              first_partite_pair: Tuple[int, int],
              maximize: bool = False,
              max_iter: int = 100,
-             backend: str = "scipy") -> Tuple[KPartiteGraph, float]:
+             backend: str = "scipy",
+             random_state: np.random.RandomState = np.random.RandomState()) -> Tuple[KPartiteGraph, float]:
     best_Gq = G_init
     best_score = G_init.vertices_cost()
     best_vertices = G_init.vertices()
@@ -495,8 +496,8 @@ def _Em_loop(G: KPartiteGraph,
     # undeterministic steepest descent
     for iteration in range(max_iter):
         improvement_achieved = False
-        for p1, p2 in np.random.permutation(list(filter(lambda _: _ != best_first_partites_pair,
-                                                        itertools.combinations(range(G.n_partites), r=2)))):
+        for p1, p2 in random_state.permutation(list(filter(lambda _: _ != best_first_partites_pair,
+                                                           itertools.combinations(range(G.n_partites), r=2)))):
             fixed_vertices = list(filter(lambda _: (_[0][0], _[1][0]) == (p1, p2), best_vertices))
             M = [[_[0][1], _[1][1]] for _ in fixed_vertices]
             Gq = G.quotient(p1, p2, M)
@@ -521,11 +522,14 @@ def solve_Em(G: KPartiteGraph,
              maximize: bool = False,
              max_iter: int = 100,
              n_trials: int = 1,
-             backend: str = "scipy") -> KPartiteGraph:
+             backend: str = "scipy",
+             random_state: Optional[Union[np.random.RandomState, int]] = None) -> KPartiteGraph:
     if max_iter <= 0:
         raise ValueError(f"max_iter must be a positive integer. Got {max_iter}.")
     if n_trials <= 0:
         raise ValueError(f"n_trials must be a positive integer. Got {n_trials}.")
+    if not isinstance(random_state, np.random.RandomState):
+        random_state = np.random.RandomState(random_state)
     # init with Bm
     Gq, choices = solve_Bm(G, maximize,
@@ -537,7 +541,7 @@ def solve_Em(G: KPartiteGraph,
     for ti in range(n_trials):
         Gq, score = _Em_loop(G, Gq, best_first_partites_pair, maximize, max_iter,
-                             backend=backend)
+                             backend=backend, random_state=random_state)
         if (score < best_score and not maximize) or (score > best_score and maximize):
             best_Gq = Gq
             best_score = score
@@ -548,9 +552,12 @@ def solve_Em(G: KPartiteGraph,
 def solve_Fm(G: KPartiteGraph,
              maximize: bool = False,
              max_iter: int = 100,
-             backend: str = "scipy") -> KPartiteGraph:
+             backend: str = "scipy",
+             random_state: Optional[Union[np.random.RandomState, int]] = None) -> KPartiteGraph:
     if max_iter <= 0:
         raise ValueError(f"max_iter must be a positive integer. Got {max_iter}.")
+    if not isinstance(random_state, np.random.RandomState):
+        random_state = np.random.RandomState(random_state)
     # init with Bm
     Gq, choices = solve_Bm(G, maximize,
@@ -566,7 +573,7 @@ def solve_Fm(G: KPartiteGraph,
     for iteration in range(max_iter):
         improvement_achieved = False
-        rand_ind = np.random.randint(0, len(best_Gq_list))
+        rand_ind = random_state.randint(0, len(best_Gq_list))
         best_Gq = best_Gq_list[rand_ind]
         best_edges = best_edges_list[rand_ind]
         best_first_partites_pair = best_first_partites_pair_list[rand_ind]
@@ -597,7 +604,7 @@ def solve_Fm(G: KPartiteGraph,
         if not improvement_achieved:
             break
     if len(best_Gq_list):
-        rand_ind = np.random.randint(0, len(best_Gq_list))
+        rand_ind = random_state.randint(0, len(best_Gq_list))
         best_Gq = best_Gq_list[rand_ind]
     return best_Gq
@@ -608,7 +615,8 @@ def k_assignment(cost_matrices: Sequence[Array2DLike],
                  n_trials: int = 1,
                  maximize: bool = False,
                  return_free: bool = False,
-                 backend: str = "scipy") -> AssignmentResult:
+                 backend: str = "scipy",
+                 random_state: Optional[Union[np.random.RandomState, int]] = None) -> AssignmentResult:
     r"""
     Solve the k-Assignment Problem using Gabrovšek's multiple Hungarian methods,
     described in ref. [1]_. This function call the Linear Assignment Problem solver
@@ -630,6 +638,10 @@ def k_assignment(cost_matrices: Sequence[Array2DLike],
         backend (str): The backend used to solve the linear assignment problem.
             Supported backends are "scipy", "lap", "lapjv", "lapsolver", "munkres".
             Defaults to "scipy".
+        random_state (RandomState, int, optional): Controls the pseudo random
+            number generation for shuffling or choosing random partites pair in
+            Em and Fm algorithms. Pass an int for reproducible output across
+            multiple function calls. Defaults to None.
     Returns:
         matching_results: A namedtuple of ``matches``, ``matching_costs``,
@@ -688,11 +700,11 @@ def k_assignment(cost_matrices: Sequence[Array2DLike],
         return Gq.reconstruct(return_free=return_free)
     elif algo == "e":
         Gq = solve_Em(G, maximize, max_iter, n_trials,
-                      backend=backend)
+                      backend=backend, random_state=random_state)
         return Gq.reconstruct(return_free=return_free)
     elif algo == "f":
         Gq = solve_Fm(G, maximize, max_iter,
-                      backend=backend)
+                      backend=backend, random_state=random_state)
         return Gq.reconstruct(return_free=return_free)
     else:
         raise ValueError("algo must be either Am | Bm | Cm | Dm | Em | Fm "

{kap-0.2.0 → kap-0.2.2}/kap.egg-info/PKG-INFO RENAMED Viewed

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: kap
-Version: 0.2.0
+Version: 0.2.2
 Summary: Gabrovšek's Multiple Hungarian method for solving k-Assignment Problem.
 Home-page: https://github.com/inspiros/kap
 Author: Hoang-Nhat Tran (inspiros)
@@ -20,16 +20,20 @@ Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Operating System :: OS Independent
 Classifier: Topic :: Scientific/Engineering :: Mathematics
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
 Requires-Dist: numpy
+Dynamic: license-file
 ``kap``: $k$-Assignment Problem Solver
 ======
-[![Build wheels](https://github.com/inspiros/kap/actions/workflows/build_wheels.yml/badge.svg)](https://github.com/inspiros/kap/actions) [![PyPI](https://img.shields.io/pypi/v/kap)](https://pypi.org/project/kap) [![Downloads](https://static.pepy.tech/badge/kap)](https://pepy.tech/project/kap) [![License](https://img.shields.io/github/license/inspiros/kap)](https://github.com/inspiros/kap/blob/master/LICENSE.txt)
+[![Build wheels](https://github.com/inspiros/kap/actions/workflows/build_wheels.yml/badge.svg)](https://github.com/inspiros/kap/actions) [![PyPI](https://img.shields.io/pypi/v/kap)](https://pypi.org/project/kap) [![Downloads](https://static.pepy.tech/badge/kap)](https://pepy.tech/project/kap) [![License](https://img.shields.io/github/license/inspiros/kap)](https://github.com/inspiros/kap/blob/master/LICENSE.txt) [![DOI](https://zenodo.org/badge/731651337.svg)](https://zenodo.org/doi/10.5281/zenodo.10449790)
 This project implements **Boštjan Gabrovšek**'s Multiple Hungarian Methods for solving the **$k$-Assignment Problem**
 (or **$k$-Partite Graph Matching Problem**), described in [this paper](https://www.mdpi.com/2227-7390/8/11/2050).
@@ -43,7 +47,7 @@ This project implements **Boštjan Gabrovšek**'s Multiple Hungarian Methods for
 It is also traditionally referred to as **Multidimensional Assignment Problem**.
 <p align="center">
-    <img src="https://raw.githubusercontent.com/inspiros/kap/master/resources/tripartite_matching_example.png" width="300">
+    <img src="https://raw.githubusercontent.com/inspiros/kap/master/resources/tripartite_matching_example.svg" width="300">
 </p>
 Formally, we seek a $k$-assignment of a given $k$-partite weighted graph $G = (V, E, \omega)$ with the minimum weight:
@@ -177,6 +181,21 @@ print("Total cost:", sum(matching_result.matching_costs))
 These code blocks are extracted from [examples](examples).
+## Citation
+```bibtex
+@software{inspiros_2024_10449791,
+  author       = {Hoang-Nhat Tran},
+  title        = {inspiros/kap: v0.2.1},
+  month        = jan,
+  year         = 2024,
+  publisher    = {Zenodo},
+  version      = {v0.2.1},
+  doi          = {10.5281/zenodo.10449791},
+  url          = {https://doi.org/10.5281/zenodo.10449791}
+}
+```
 ## License
 MIT licensed. See [LICENSE.txt](LICENSE.txt).

{kap-0.2.0 → kap-0.2.2}/setup.cfg RENAMED Viewed

@@ -24,6 +24,9 @@ classifiers =
 	Programming Language :: Python :: 3.9
 	Programming Language :: Python :: 3.10
 	Programming Language :: Python :: 3.11
+	Programming Language :: Python :: 3.12
+	Programming Language :: Python :: 3.13
+	Programming Language :: Python :: 3.14
 	Operating System :: OS Independent
 	Topic :: Scientific/Engineering :: Mathematics
 keywords = k-assignment, k-partite-matching, linear-assignment, bi-partite-matching, hungarian