munkres-1.1.2/0000755000076500000240000000000013431602031013054 5ustar bmcstaff00000000000000munkres-1.1.2/CHANGELOG.md0000644000076500000240000001104213431601707014674 0ustar bmcstaff00000000000000# Change Log, munkres.py Version 1.1.2 (February, 2019) - Removed `NoReturn` type annotations, to allow compatibility with Python 3.5 releases prior to 3.5.4. Thanks to @jackwilsdon for catching that issue. Version 1.1.1 (February, 2019) - Version bump to get past a PyPI publishing issue. (Can't republish partially published 1.1.0.) Version 1.1.0 (February, 2019) - Only supports Python 3.5 or better, from this version forward (since Python 2 is at end of life in 11 months). - Added `typing` type hints. - Updated docs to use `pdoc`, since `epydoc` is pretty much dead. Version 1.0.12 (June, 2017) - Merged [Pull Request #11](https://github.com/bmc/munkres/pull/11), from [@brunokim](https://github.com/brunokim), which simplifies conversion of a profit matrix to a cost matrix, in the default case. - Merged [Pull Request #7](https://github.com/bmc/munkres/pull/7), from [@mdxs](https://github.com/mdxs), which fixes a message. - Added more tests. Version 1.0.11 (June, 2017) - Docs are now generated with [pdoc](https://github.com/BurntSushi/pdoc). - Merged [Pull Request 24](https://github.com/bmc/munkres/pull/24), from [@czlee](https://github.com/czlee): - Change to step 4: When it looks for a uncovered zero, rather than starting at row 0, column 0, it starts where it left off, i.e. at the last uncovered zero it found. Since it doesn't start at (0,0), when it gets to the last column it now loops around to the first, and exits unsuccessfully if it got back to where it started. This change reduces this reduces the solving time for (certain) large matrices. For instance, in tests, solving a matrix of size 394×394 goes from about 2 minutes to about 4 seconds. - Since Python 3 started cracking down on unnatural comparisons, the `DISALLOWED` constant added in [Pull Request 19](https://github.com/bmc/munkres/issues/19) no longer works. (It raises a TypeError for unorderable types, as is expected in Python 3.) Since this constant is meant to act like infinity, this modification just changes the two lines where it would otherwise try to make an illegal (in Python 3) comparison between a number and `DISALLOWED_OBJ()` and gets it to behave as if `DISALLOWED` is always larger. - Added Travis CI integration. - Added some unit tests. See `tests` and `tests/README.md`. Version 1.0.10 (May, 2017) - Updated `setup.py` to produce a wheel. Version 1.0.9 (Jan, 2017) - Fixed URL to original implementation. Addresses [Issue #4](https://github.com/bmc/munkres/issues/4). - Fixes from [@kylemcdonald](https://github.com/kylemcdonald): - `print_matrix()` no longer crashes on 0. Fixes [Issue #1](https://github.com/bmc/munkres/issues/4). - Fixed bug where step 3 could quit early. Fixes [Issue #16](https://github.com/bmc/munkres/issues/16). - Added step 2 break for a small optimization. - Added time bound to README. Addresses [Issue #15](https://github.com/bmc/munkres/issues/15). - Versioning will now adhere to [semantic version specification](http://semver.org). Version 1.0.8 (June, 2016) - License is now ASL. Version 1.0.7 (December, 2014) Fix from Stephan Porz (s.porz /at/ uni-bonn.de): - Fix pad_matrix: pad_value now actually used Version 1.0.6 (December, 2013) Fixes from Markus Padourek (markus.padourek /at/ gmail.com): - sys.maxsize fix and bump to 1.0.6 - Updated to Python 3.x Version 1.0.5.3 (2 August, 2009) - Fixed documentation of print_matrix() in module docs. Version 1.0.5.2 (30 June, 2008): - Incorporated some suggestions optimizations from Mark Summerfield (mark /at/ qtrac.eu) - Munkres.make_cost_matrix() is now deprecated, in favor of a module-level function. - The module now provides a print_matrix() convenience function. - Fixed some bugs related to the padding of non-square matrics. Version 1.0.5.1 (26 June, 2008) - Some minor doc changes. Version 1.0.5 (26 June, 2008) - Now handles non-square cost matrices by padding them with zeros. - Converted Epydocs to use reStructuredText. Version 1.0.4 (13 June, 2008) - Minor bug fix in main (tester) program in munkres.py Version 1.0.3 (16 March, 2008) - Minor change to prevent shadowing of built-in min() function. Thanks to Nelson Castillo (nelson /at/ emqbit.com) for pointing it out. Version 1.0.2 (21 February, 2008) - Fixed an overindexing bug reported by Chris Willmore (willmc rpi.edu) Version 1.0.1 (16 February, 2008) - Documentation now processed by Epydoc. Version 1.0 (January, 2008) - Initial release. munkres-1.1.2/LICENSE.md0000644000076500000240000000106413430604716014474 0ustar bmcstaff00000000000000Copyright © 2008-2019 Brian M. Clapper Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. munkres-1.1.2/MANIFEST.in0000644000076500000240000000010613430610152014611 0ustar bmcstaff00000000000000recursive-include test *.md include LICENSE.md README.md CHANGELOG.md munkres-1.1.2/PKG-INFO0000644000076500000240000000204513431602031014152 0ustar bmcstaff00000000000000Metadata-Version: 2.1 Name: munkres Version: 1.1.2 Summary: Munkres (Hungarian) algorithm for the Assignment Problem Home-page: http://software.clapper.org/munkres/ Author: Brian Clapper Author-email: bmc@clapper.org License: Apache Software License Description: Introduction ============ The Munkres module provides an implementation of the Munkres algorithm (also called the Hungarian algorithm or the Kuhn-Munkres algorithm), useful for solving the Assignment Problem. For complete usage documentation, see: http://software.clapper.org/munkres/ Platform: UNKNOWN Classifier: Intended Audience :: Developers Classifier: Intended Audience :: Science/Research Classifier: License :: OSI Approved :: Apache Software License Classifier: Operating System :: OS Independent Classifier: Programming Language :: Python Classifier: Topic :: Scientific/Engineering :: Mathematics Classifier: Topic :: Software Development :: Libraries :: Python Modules Description-Content-Type: text/markdown munkres-1.1.2/README.md0000644000076500000240000000270413430611444014345 0ustar bmcstaff00000000000000Munkres implementation for Python --------------------------------- ## Introduction The Munkres module provides an O(n^3) implementation of the Munkres algorithm (also called the [Hungarian algorithm][] or the Kuhn-Munkres algorithm). The algorithm models an assignment problem as an NxM cost matrix, where each element represents the cost of assigning the ith worker to the jth job, and it figures out the least-cost solution, choosing a single item from each row and column in the matrix, such that no row and no column are used more than once. This particular implementation is based on . [Hungarian algorithm]: http://en.wikipedia.org/wiki/Hungarian_algorithm See the docs on the [project page][] for more details. **WARNING**: As of version 1.1.0, _munkres_ no longer supports Python 2. If you need to use this package with Python 2, install an earlier version. See [the installation instructions](http://software.clapper.org/munkres/#installing) for details. [project page]: http://software.clapper.org/munkres/ ## Copyright © 2008-2019 Brian M. Clapper ## License Licensed under the Apache License, Version 2.0. See [LICENSE](LICENSE.md) for details. munkres-1.1.2/munkres.egg-info/0000755000076500000240000000000013431602031016232 5ustar bmcstaff00000000000000munkres-1.1.2/munkres.egg-info/PKG-INFO0000644000076500000240000000204513431602027017335 0ustar bmcstaff00000000000000Metadata-Version: 2.1 Name: munkres Version: 1.1.2 Summary: Munkres (Hungarian) algorithm for the Assignment Problem Home-page: http://software.clapper.org/munkres/ Author: Brian Clapper Author-email: bmc@clapper.org License: Apache Software License Description: Introduction ============ The Munkres module provides an implementation of the Munkres algorithm (also called the Hungarian algorithm or the Kuhn-Munkres algorithm), useful for solving the Assignment Problem. For complete usage documentation, see: http://software.clapper.org/munkres/ Platform: UNKNOWN Classifier: Intended Audience :: Developers Classifier: Intended Audience :: Science/Research Classifier: License :: OSI Approved :: Apache Software License Classifier: Operating System :: OS Independent Classifier: Programming Language :: Python Classifier: Topic :: Scientific/Engineering :: Mathematics Classifier: Topic :: Software Development :: Libraries :: Python Modules Description-Content-Type: text/markdown munkres-1.1.2/munkres.egg-info/SOURCES.txt0000644000076500000240000000035313431602030020116 0ustar bmcstaff00000000000000CHANGELOG.md LICENSE.md MANIFEST.in README.md munkres.py setup.cfg setup.py munkres.egg-info/PKG-INFO munkres.egg-info/SOURCES.txt munkres.egg-info/dependency_links.txt munkres.egg-info/top_level.txt test/README.md test/test_munkres.pymunkres-1.1.2/munkres.egg-info/dependency_links.txt0000644000076500000240000000000113431602027022305 0ustar bmcstaff00000000000000 munkres-1.1.2/munkres.egg-info/top_level.txt0000644000076500000240000000001013431602027020760 0ustar bmcstaff00000000000000munkres munkres-1.1.2/munkres.py0000644000076500000240000004414613431601624015132 0ustar bmcstaff00000000000000""" Introduction ============ The Munkres module provides an implementation of the Munkres algorithm (also called the Hungarian algorithm or the Kuhn-Munkres algorithm), useful for solving the Assignment Problem. For complete usage documentation, see: http://software.clapper.org/munkres/ """ __docformat__ = 'markdown' # --------------------------------------------------------------------------- # Imports # --------------------------------------------------------------------------- import sys import copy from typing import Union, NewType, Sequence, Tuple, Optional, Callable # --------------------------------------------------------------------------- # Exports # --------------------------------------------------------------------------- __all__ = ['Munkres', 'make_cost_matrix', 'DISALLOWED'] # --------------------------------------------------------------------------- # Globals # --------------------------------------------------------------------------- AnyNum = NewType('AnyNum', Union[int, float]) Matrix = NewType('Matrix', Sequence[Sequence[AnyNum]]) # Info about the module __version__ = "1.1.2" __author__ = "Brian Clapper, bmc@clapper.org" __url__ = "http://software.clapper.org/munkres/" __copyright__ = "(c) 2008-2019 Brian M. Clapper" __license__ = "Apache Software License" # Constants class DISALLOWED_OBJ(object): pass DISALLOWED = DISALLOWED_OBJ() DISALLOWED_PRINTVAL = "D" # --------------------------------------------------------------------------- # Exceptions # --------------------------------------------------------------------------- class UnsolvableMatrix(Exception): """ Exception raised for unsolvable matrices """ pass # --------------------------------------------------------------------------- # Classes # --------------------------------------------------------------------------- class Munkres: """ Calculate the Munkres solution to the classical assignment problem. See the module documentation for usage. """ def __init__(self): """Create a new instance""" self.C = None self.row_covered = [] self.col_covered = [] self.n = 0 self.Z0_r = 0 self.Z0_c = 0 self.marked = None self.path = None def pad_matrix(self, matrix: Matrix, pad_value: int=0) -> Matrix: """ Pad a possibly non-square matrix to make it square. **Parameters** - `matrix` (list of lists of numbers): matrix to pad - `pad_value` (`int`): value to use to pad the matrix **Returns** a new, possibly padded, matrix """ max_columns = 0 total_rows = len(matrix) for row in matrix: max_columns = max(max_columns, len(row)) total_rows = max(max_columns, total_rows) new_matrix = [] for row in matrix: row_len = len(row) new_row = row[:] if total_rows > row_len: # Row too short. Pad it. new_row += [pad_value] * (total_rows - row_len) new_matrix += [new_row] while len(new_matrix) < total_rows: new_matrix += [[pad_value] * total_rows] return new_matrix def compute(self, cost_matrix: Matrix) -> Sequence[Tuple[int, int]]: """ Compute the indexes for the lowest-cost pairings between rows and columns in the database. Returns a list of `(row, column)` tuples that can be used to traverse the matrix. **WARNING**: This code handles square and rectangular matrices. It does *not* handle irregular matrices. **Parameters** - `cost_matrix` (list of lists of numbers): The cost matrix. If this cost matrix is not square, it will be padded with zeros, via a call to `pad_matrix()`. (This method does *not* modify the caller's matrix. It operates on a copy of the matrix.) **Returns** A list of `(row, column)` tuples that describe the lowest cost path through the matrix """ self.C = self.pad_matrix(cost_matrix) self.n = len(self.C) self.original_length = len(cost_matrix) self.original_width = len(cost_matrix[0]) self.row_covered = [False for i in range(self.n)] self.col_covered = [False for i in range(self.n)] self.Z0_r = 0 self.Z0_c = 0 self.path = self.__make_matrix(self.n * 2, 0) self.marked = self.__make_matrix(self.n, 0) done = False step = 1 steps = { 1 : self.__step1, 2 : self.__step2, 3 : self.__step3, 4 : self.__step4, 5 : self.__step5, 6 : self.__step6 } while not done: try: func = steps[step] step = func() except KeyError: done = True # Look for the starred columns results = [] for i in range(self.original_length): for j in range(self.original_width): if self.marked[i][j] == 1: results += [(i, j)] return results def __copy_matrix(self, matrix: Matrix) -> Matrix: """Return an exact copy of the supplied matrix""" return copy.deepcopy(matrix) def __make_matrix(self, n: int, val: AnyNum) -> Matrix: """Create an *n*x*n* matrix, populating it with the specific value.""" matrix = [] for i in range(n): matrix += [[val for j in range(n)]] return matrix def __step1(self) -> int: """ For each row of the matrix, find the smallest element and subtract it from every element in its row. Go to Step 2. """ C = self.C n = self.n for i in range(n): vals = [x for x in self.C[i] if x is not DISALLOWED] if len(vals) == 0: # All values in this row are DISALLOWED. This matrix is # unsolvable. raise UnsolvableMatrix( "Row {0} is entirely DISALLOWED.".format(i) ) minval = min(vals) # Find the minimum value for this row and subtract that minimum # from every element in the row. for j in range(n): if self.C[i][j] is not DISALLOWED: self.C[i][j] -= minval return 2 def __step2(self) -> int: """ Find a zero (Z) in the resulting matrix. If there is no starred zero in its row or column, star Z. Repeat for each element in the matrix. Go to Step 3. """ n = self.n for i in range(n): for j in range(n): if (self.C[i][j] == 0) and \ (not self.col_covered[j]) and \ (not self.row_covered[i]): self.marked[i][j] = 1 self.col_covered[j] = True self.row_covered[i] = True break self.__clear_covers() return 3 def __step3(self) -> int: """ Cover each column containing a starred zero. If K columns are covered, the starred zeros describe a complete set of unique assignments. In this case, Go to DONE, otherwise, Go to Step 4. """ n = self.n count = 0 for i in range(n): for j in range(n): if self.marked[i][j] == 1 and not self.col_covered[j]: self.col_covered[j] = True count += 1 if count >= n: step = 7 # done else: step = 4 return step def __step4(self) -> int: """ Find a noncovered zero and prime it. If there is no starred zero in the row containing this primed zero, Go to Step 5. Otherwise, cover this row and uncover the column containing the starred zero. Continue in this manner until there are no uncovered zeros left. Save the smallest uncovered value and Go to Step 6. """ step = 0 done = False row = 0 col = 0 star_col = -1 while not done: (row, col) = self.__find_a_zero(row, col) if row < 0: done = True step = 6 else: self.marked[row][col] = 2 star_col = self.__find_star_in_row(row) if star_col >= 0: col = star_col self.row_covered[row] = True self.col_covered[col] = False else: done = True self.Z0_r = row self.Z0_c = col step = 5 return step def __step5(self) -> int: """ Construct a series of alternating primed and starred zeros as follows. Let Z0 represent the uncovered primed zero found in Step 4. Let Z1 denote the starred zero in the column of Z0 (if any). Let Z2 denote the primed zero in the row of Z1 (there will always be one). Continue until the series terminates at a primed zero that has no starred zero in its column. Unstar each starred zero of the series, star each primed zero of the series, erase all primes and uncover every line in the matrix. Return to Step 3 """ count = 0 path = self.path path[count][0] = self.Z0_r path[count][1] = self.Z0_c done = False while not done: row = self.__find_star_in_col(path[count][1]) if row >= 0: count += 1 path[count][0] = row path[count][1] = path[count-1][1] else: done = True if not done: col = self.__find_prime_in_row(path[count][0]) count += 1 path[count][0] = path[count-1][0] path[count][1] = col self.__convert_path(path, count) self.__clear_covers() self.__erase_primes() return 3 def __step6(self) -> int: """ Add the value found in Step 4 to every element of each covered row, and subtract it from every element of each uncovered column. Return to Step 4 without altering any stars, primes, or covered lines. """ minval = self.__find_smallest() events = 0 # track actual changes to matrix for i in range(self.n): for j in range(self.n): if self.C[i][j] is DISALLOWED: continue if self.row_covered[i]: self.C[i][j] += minval events += 1 if not self.col_covered[j]: self.C[i][j] -= minval events += 1 if self.row_covered[i] and not self.col_covered[j]: events -= 2 # change reversed, no real difference if (events == 0): raise UnsolvableMatrix("Matrix cannot be solved!") return 4 def __find_smallest(self) -> AnyNum: """Find the smallest uncovered value in the matrix.""" minval = sys.maxsize for i in range(self.n): for j in range(self.n): if (not self.row_covered[i]) and (not self.col_covered[j]): if self.C[i][j] is not DISALLOWED and minval > self.C[i][j]: minval = self.C[i][j] return minval def __find_a_zero(self, i0: int = 0, j0: int = 0) -> Tuple[int, int]: """Find the first uncovered element with value 0""" row = -1 col = -1 i = i0 n = self.n done = False while not done: j = j0 while True: if (self.C[i][j] == 0) and \ (not self.row_covered[i]) and \ (not self.col_covered[j]): row = i col = j done = True j = (j + 1) % n if j == j0: break i = (i + 1) % n if i == i0: done = True return (row, col) def __find_star_in_row(self, row: Sequence[AnyNum]) -> int: """ Find the first starred element in the specified row. Returns the column index, or -1 if no starred element was found. """ col = -1 for j in range(self.n): if self.marked[row][j] == 1: col = j break return col def __find_star_in_col(self, col: Sequence[AnyNum]) -> int: """ Find the first starred element in the specified row. Returns the row index, or -1 if no starred element was found. """ row = -1 for i in range(self.n): if self.marked[i][col] == 1: row = i break return row def __find_prime_in_row(self, row) -> int: """ Find the first prime element in the specified row. Returns the column index, or -1 if no starred element was found. """ col = -1 for j in range(self.n): if self.marked[row][j] == 2: col = j break return col def __convert_path(self, path: Sequence[Sequence[int]], count: int) -> None: for i in range(count+1): if self.marked[path[i][0]][path[i][1]] == 1: self.marked[path[i][0]][path[i][1]] = 0 else: self.marked[path[i][0]][path[i][1]] = 1 def __clear_covers(self) -> None: """Clear all covered matrix cells""" for i in range(self.n): self.row_covered[i] = False self.col_covered[i] = False def __erase_primes(self) -> None: """Erase all prime markings""" for i in range(self.n): for j in range(self.n): if self.marked[i][j] == 2: self.marked[i][j] = 0 # --------------------------------------------------------------------------- # Functions # --------------------------------------------------------------------------- def make_cost_matrix( profit_matrix: Matrix, inversion_function: Optional[Callable[[AnyNum], AnyNum]] = None ) -> Matrix: """ Create a cost matrix from a profit matrix by calling `inversion_function()` to invert each value. The inversion function must take one numeric argument (of any type) and return another numeric argument which is presumed to be the cost inverse of the original profit value. If the inversion function is not provided, a given cell's inverted value is calculated as `max(matrix) - value`. This is a static method. Call it like this: from munkres import Munkres cost_matrix = Munkres.make_cost_matrix(matrix, inversion_func) For example: from munkres import Munkres cost_matrix = Munkres.make_cost_matrix(matrix, lambda x : sys.maxsize - x) **Parameters** - `profit_matrix` (list of lists of numbers): The matrix to convert from profit to cost values. - `inversion_function` (`function`): The function to use to invert each entry in the profit matrix. **Returns** A new matrix representing the inversion of `profix_matrix`. """ if not inversion_function: maximum = max(max(row) for row in profit_matrix) inversion_function = lambda x: maximum - x cost_matrix = [] for row in profit_matrix: cost_matrix.append([inversion_function(value) for value in row]) return cost_matrix def print_matrix(matrix: Matrix, msg: Optional[str] = None) -> None: """ Convenience function: Displays the contents of a matrix of integers. **Parameters** - `matrix` (list of lists of numbers): The matrix to print - `msg` (`str`): Optional message to print before displaying the matrix """ import math if msg is not None: print(msg) # Calculate the appropriate format width. width = 0 for row in matrix: for val in row: if val is DISALLOWED: val = DISALLOWED_PRINTVAL width = max(width, len(str(val))) # Make the format string format = ('%%%d' % width) # Print the matrix for row in matrix: sep = '[' for val in row: if val is DISALLOWED: formatted = ((format + 's') % DISALLOWED_PRINTVAL) else: formatted = ((format + 'd') % val) sys.stdout.write(sep + formatted) sep = ', ' sys.stdout.write(']\n') # --------------------------------------------------------------------------- # Main # --------------------------------------------------------------------------- if __name__ == '__main__': matrices = [ # Square ([[400, 150, 400], [400, 450, 600], [300, 225, 300]], 850), # expected cost # Rectangular variant ([[400, 150, 400, 1], [400, 450, 600, 2], [300, 225, 300, 3]], 452), # expected cost # Square ([[10, 10, 8], [9, 8, 1], [9, 7, 4]], 18), # Rectangular variant ([[10, 10, 8, 11], [9, 8, 1, 1], [9, 7, 4, 10]], 15), # Rectangular with DISALLOWED ([[4, 5, 6, DISALLOWED], [1, 9, 12, 11], [DISALLOWED, 5, 4, DISALLOWED], [12, 12, 12, 10]], 20), # DISALLOWED to force pairings ([[1, DISALLOWED, DISALLOWED, DISALLOWED], [DISALLOWED, 2, DISALLOWED, DISALLOWED], [DISALLOWED, DISALLOWED, 3, DISALLOWED], [DISALLOWED, DISALLOWED, DISALLOWED, 4]], 10)] m = Munkres() for cost_matrix, expected_total in matrices: print_matrix(cost_matrix, msg='cost matrix') indexes = m.compute(cost_matrix) total_cost = 0 for r, c in indexes: x = cost_matrix[r][c] total_cost += x print(('(%d, %d) -> %d' % (r, c, x))) print(('lowest cost=%d' % total_cost)) assert expected_total == total_cost munkres-1.1.2/setup.cfg0000644000076500000240000000013413431602031014673 0ustar bmcstaff00000000000000[sdist] formats = gztar [bdist_wheel] universal = 1 [egg_info] tag_build = tag_date = 0 munkres-1.1.2/setup.py0000644000076500000240000000600113430607423014574 0ustar bmcstaff00000000000000#!/usr/bin/env python # # Distutils setup script for Munkres # --------------------------------------------------------------------------- from setuptools import setup import re import os import sys from distutils.cmd import Command from abc import abstractmethod if sys.version_info[0:2] < (3, 5): columns = int(os.environ.get('COLUMNS', '80')) - 1 msg = ('As of version 1.1.0, this munkres package no longer supports ' + 'Python 2. Either upgrade to Python 3.5 or better, or use an ' + 'older version of munkres (e.g., 1.0.12).') sys.stderr.write(msg + '\n') raise Exception(msg) # Load the module. here = os.path.dirname(os.path.abspath(sys.argv[0])) def import_from_file(file, name): # See https://stackoverflow.com/a/19011259/53495 import importlib.machinery import importlib.util loader = importlib.machinery.SourceFileLoader(name, file) spec = importlib.util.spec_from_loader(loader.name, loader) mod = importlib.util.module_from_spec(spec) loader.exec_module(mod) return mod mf = os.path.join(here, 'munkres.py') munkres = import_from_file(mf, 'munkres') long_description = munkres.__doc__ version = str(munkres.__version__) (author, email) = re.match('^(.*),\s*(.*)$', munkres.__author__).groups() url = munkres.__url__ license = munkres.__license__ API_DOCS_BUILD = 'apidocs' class CommandHelper(Command): user_options = [] def __init__(self, dist): Command.__init__(self, dist) def initialize_options(self): pass def finalize_options(self): pass @abstractmethod def run(self): pass class Doc(CommandHelper): description = 'create the API docs' def run(self): os.environ['PYTHONPATH'] = '.' cmd = 'pdoc --html --html-dir {} --overwrite --html-no-source munkres'.format( API_DOCS_BUILD ) print('+ {}'.format(cmd)) rc = os.system(cmd) if rc != 0: raise Exception("Failed to run pdoc. rc={}".format(rc)) class Test(CommandHelper): def run(self): import nose try: os.chdir('test') nose.run() finally: os.chdir(here) # Run setup setup( name="munkres", version=version, description="Munkres (Hungarian) algorithm for the Assignment Problem", long_description=long_description, long_description_content_type='text/markdown', url=url, license=license, author=author, author_email=email, py_modules=["munkres"], cmdclass = { 'doc': Doc, 'docs': Doc, 'apidoc': Doc, 'apidocs': Doc, 'test': Test }, classifiers = [ 'Intended Audience :: Developers', 'Intended Audience :: Science/Research', 'License :: OSI Approved :: Apache Software License', 'Operating System :: OS Independent', 'Programming Language :: Python', 'Topic :: Scientific/Engineering :: Mathematics', 'Topic :: Software Development :: Libraries :: Python Modules' ] ) munkres-1.1.2/test/0000755000076500000240000000000013431602031014033 5ustar bmcstaff00000000000000munkres-1.1.2/test/README.md0000644000076500000240000000022413124474351015323 0ustar bmcstaff00000000000000The tests in this directory are intended to be run via [Nose][]. ``` pip install nose nosetests ``` [Nose]: http://nose.readthedocs.io/en/latest/ munkres-1.1.2/test/test_munkres.py0000644000076500000240000001056313124510011017130 0ustar bmcstaff00000000000000from munkres import Munkres, DISALLOWED, UnsolvableMatrix import munkres from nose.tools import assert_equals, raises m = Munkres() def _get_cost(matrix): indices = m.compute(matrix) return sum([matrix[row][column] for row, column in indices]) def test_documented_example(): ''' Test the matrix in the documented example. ''' matrix = [[5, 9, 1], [10, 3, 2], [8, 7, 4]] cost = _get_cost(matrix) assert_equals(cost, 12) def test_5_x_5(): matrix = [[12, 9, 27, 10, 23], [7, 13, 13, 30, 19], [25, 18, 26, 11, 26], [9, 28, 26, 23, 13], [16, 16, 24, 6, 9]] cost = _get_cost(matrix) assert_equals(cost, 51) def test_10_x_10(): matrix = [[37, 34, 29, 26, 19, 8, 9, 23, 19, 29], [9, 28, 20, 8, 18, 20, 14, 33, 23, 14], [15, 26, 12, 28, 6, 17, 9, 13, 21, 7], [2, 8, 38, 36, 39, 5, 36, 2, 38, 27], [30, 3, 33, 16, 21, 39, 7, 23, 28, 36], [7, 5, 19, 22, 36, 36, 24, 19, 30, 2], [34, 20, 13, 36, 12, 33, 9, 10, 23, 5], [7, 37, 22, 39, 33, 39, 10, 3, 13, 26], [21, 25, 23, 39, 31, 37, 32, 33, 38, 1], [17, 34, 40, 10, 29, 37, 40, 3, 25, 3]] cost = _get_cost(matrix) assert_equals(cost, 66) def test_20_x_20(): matrix = [[5, 4, 3, 9, 8, 9, 3, 5, 6, 9, 4, 10, 3, 5, 6, 6, 1, 8, 10, 2], [10, 9, 9, 2, 8, 3, 9, 9, 10, 1, 7, 10, 8, 4, 2, 1, 4, 8, 4, 8], [10, 4, 4, 3, 1, 3, 5, 10, 6, 8, 6, 8, 4, 10, 7, 2, 4, 5, 1, 8], [2, 1, 4, 2, 3, 9, 3, 4, 7, 3, 4, 1, 3, 2, 9, 8, 6, 5, 7, 8], [3, 4, 4, 1, 4, 10, 1, 2, 6, 4, 5, 10, 2, 2, 3, 9, 10, 9, 9, 10], [1, 10, 1, 8, 1, 3, 1, 7, 1, 1, 2, 1, 2, 6, 3, 3, 4, 4, 8, 6], [1, 8, 7, 10, 10, 3, 4, 6, 1, 6, 6, 4, 9, 6, 9, 6, 4, 5, 4, 7], [8, 10, 3, 9, 4, 9, 3, 3, 4, 6, 4, 2, 6, 7, 7, 4, 4, 3, 4, 7], [1, 3, 8, 2, 6, 9, 2, 7, 4, 8, 10, 8, 10, 5, 1, 3, 10, 10, 2, 9], [2, 4, 1, 9, 2, 9, 7, 8, 2, 1, 4, 10, 5, 2, 7, 6, 5, 7, 2, 6], [4, 5, 1, 4, 2, 3, 3, 4, 1, 8, 8, 2, 6, 9, 5, 9, 6, 3, 9, 3], [3, 1, 1, 8, 6, 8, 8, 7, 9, 3, 2, 1, 8, 2, 4, 7, 3, 1, 2, 4], [5, 9, 8, 6, 10, 4, 10, 3, 4, 10, 10, 10, 1, 7, 8, 8, 7, 7, 8, 8], [1, 4, 6, 1, 6, 1, 2, 10, 5, 10, 2, 6, 2, 4, 5, 5, 3, 5, 1, 5], [5, 6, 9, 10, 6, 6, 10, 6, 4, 1, 5, 3, 9, 5, 2, 10, 9, 9, 5, 1], [10, 9, 4, 6, 9, 5, 3, 7, 10, 1, 6, 8, 1, 1, 10, 9, 5, 7, 7, 5], [2, 6, 6, 6, 6, 2, 9, 4, 7, 5, 3, 2, 10, 3, 4, 5, 10, 9, 1, 7], [5, 2, 4, 9, 8, 4, 8, 2, 4, 1, 3, 7, 6, 8, 1, 6, 8, 8, 10, 10], [9, 6, 3, 1, 8, 5, 7, 8, 7, 2, 1, 8, 2, 8, 3, 7, 4, 8, 7, 7], [8, 4, 4, 9, 7, 10, 6, 2, 1, 5, 8, 5, 1, 1, 1, 9, 1, 3, 5, 3]] cost = _get_cost(matrix) assert_equals(cost, 22) def test_disallowed(): matrix = [[5, 9, DISALLOWED], [10, DISALLOWED, 2], [8, DISALLOWED, 4]] cost = _get_cost(matrix) assert_equals(cost, 19) def test_profit(): profit_matrix = [[94, 66, 100, 18, 48], [51, 63, 97, 79, 11], [37, 53, 57, 78, 28], [59, 43, 97, 88, 48], [52, 19, 89, 60, 60]] import sys cost_matrix = munkres.make_cost_matrix( profit_matrix, lambda cost: sys.maxsize - cost ) indices = m.compute(cost_matrix) profit = sum([profit_matrix[row][column] for row, column in indices]) assert_equals(profit, 392) def test_irregular(): matrix = [[12, 26, 17], [49, 43, 36, 10, 5], [97, 9, 66, 34], [52, 42, 19, 36], [15, 93, 55, 80]] cost = _get_cost(matrix) assert_equals(cost, 43) def test_rectangular(): matrix = [[34, 26, 17, 12], [43, 43, 36, 10], [97, 47, 66, 34], [52, 42, 19, 36], [15, 93, 55, 80]] padded_matrix = m.pad_matrix(matrix, 0) padded_cost = _get_cost(padded_matrix) cost = _get_cost(matrix) assert_equals(padded_cost, cost) assert_equals(cost, 70) @raises(UnsolvableMatrix) def test_unsolvable(): matrix = [[5, 9, DISALLOWED], [10, DISALLOWED, 2], [DISALLOWED, DISALLOWED, DISALLOWED]] m.compute(matrix)