Merge branch 'master' into master

Author: tmelorc

MANIFEST.in

@@ -0,0 +1,2 @@
+include *.txt
+include *.md

README.md

@@ -1,14 +1,19 @@
 [![PyPI version](https://badge.fury.io/py/persim.svg)](https://badge.fury.io/py/persim)
 [![Downloads](https://pypip.in/download/persim/badge.svg)](https://pypi.python.org/pypi/persim/) 
+[![Conda Version](https://img.shields.io/conda/vn/conda-forge/persim.svg)](https://anaconda.org/conda-forge/persim)
+[![Conda Downloads](https://img.shields.io/conda/dn/conda-forge/persim.svg)](https://anaconda.org/conda-forge/persim)
 [![Build Status](https://travis-ci.org/scikit-tda/persim.svg?branch=master)](https://travis-ci.org/scikit-tda/persim)
 [![codecov](https://codecov.io/gh/scikit-tda/persim/branch/master/graph/badge.svg)](https://codecov.io/gh/scikit-tda/persim)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+
 <img align="right" width="40" height="40" src="https://imgur.com/8p6VwFm.jpg">
 
 Persim is a Python package for many tools used in analyzing Persistence Diagrams.  It currently houses implementations of 
 
 - Persistence Images
 - Bottleneck distance
+- Modified Gromov&ndash;Hausdorff distance
 - Sliced Wasserstein Kernel
 - Heat Kernel
 - Diagram plotting

RELEASE.txt

@@ -1,3 +1,13 @@
+0.1.1
+    - Fix bug in Wasserstein and bottleneck distance.
+
+0.1.0
+    - Include Wasserstein distance.
+
+0.0.10
+    - Add license and README to distributed packages
+0.0.9
+    - Include modified Gromov--Hausdorff distance
 0.0.8
     - Include diagram plotting
     - revamped documentation

docs/index.rst

@@ -4,6 +4,7 @@ Persim is a Python package for many tools used in analyzing Persistence Diagrams
 
 - Persistence Images
 - Bottleneck distance
+- Modified Gromov--Hausdorff distance
 - Sliced Wasserstein Kernel
 - Heat Kernel
 - Diagram plotting

docs/reference/index.rst

@@ -9,9 +9,11 @@ Distances
     :toctree: stubs
     :nosignatures:
 
+    persim.wasserstein
     persim.bottleneck
     persim.sliced_wasserstein
     persim.heat
+    persim.gromov_hausdorff
 
 
 Persistence Images

persim/__init__.py

@@ -1,8 +1,9 @@
 from .images import *
 from .sliced_wasserstein import *
 from .bottleneck import *
+from .wasserstein import *
 from .heat import *
+from .gromov_hausdorff import *
 from .visuals import *
-from .plot import *
 
 from ._version import __version__

persim/_version.py

@@ -1 +1 @@
-__version__ = "0.0.8"
+__version__ = "0.1.2"

persim/bottleneck.py

@@ -1,6 +1,7 @@
 """
 
-    Implementation of the bottleneck distance
+    Implementation of the bottleneck distance using binary
+    search and the Hopcroft-Karp algorithm
 
     Author: Chris Tralie
 
@@ -10,15 +11,19 @@
 
 from bisect import bisect_left
 from hopcroftkarp import HopcroftKarp
+import warnings
 
 __all__ = ["bottleneck"]
 
+
 def bottleneck(dgm1, dgm2, matching=False):
     """
     Perform the Bottleneck distance matching between persistence diagrams.
     Assumes first two columns of S and T are the coordinates of the persistence
     points, but allows for other coordinate columns (which are ignored in
-    diagonal matching)
+    diagonal matching).
+
+    See the `distances` notebook for an example of how to use this.
 
     Parameters
     -----------
@@ -27,28 +32,46 @@ def bottleneck(dgm1, dgm2, matching=False):
     dgm2: Nx(>=2) 
         array of birth/death paris for PD 2
     matching: bool, default False
-        if True, return matching information
+        if True, return matching infromation and cross-similarity matrix
 
     Returns
     --------
 
     d: float
         bottleneck distance between dgm1 and dgm2
-    matching: tuples of matched indices
-        if input `matching=True`, then return matching
-    D: (N+M)x(N+M) cross-similarity matrix
-        if input `matching=True`, then return D
+    (matching, D): Only returns if `matching=True`
+        (tuples of matched indices, (N+M)x(N+M) cross-similarity matrix)
     """
 
     return_matching = matching
 
     S = np.array(dgm1)
-    S = S[np.isfinite(S[:, 1]), :]
+    M = min(S.shape[0], S.size)
+    if S.size > 0:
+        S = S[np.isfinite(S[:, 1]), :]
+        if S.shape[0] < M:
+            warnings.warn(
+                "dgm1 has points with non-finite death times;"+
+                "ignoring those points"
+            )
+            M = S.shape[0]
     T = np.array(dgm2)
-    T = T[np.isfinite(T[:, 1]), :]
-
-    N = S.shape[0]
-    M = T.shape[0]
+    N = min(T.shape[0], T.size)
+    if T.size > 0:
+        T = T[np.isfinite(T[:, 1]), :]
+        if T.shape[0] < N:
+            warnings.warn(
+                "dgm2 has points with non-finite death times;"+
+                "ignoring those points"
+            )
+            N = T.shape[0]
+
+    if M == 0:
+        S = np.array([[0, 0]])
+        M = 1
+    if N == 0:
+        T = np.array([[0, 0]])
+        N = 1
 
     # Step 1: Compute CSM between S and T, including points on diagonal
     # L Infinity distance
@@ -60,21 +83,19 @@ def bottleneck(dgm1, dgm2, matching=False):
 
     # Put diagonal elements into the matrix, being mindful that Linfinity
     # balls meet the diagonal line at a diamond vertex
-    D = np.zeros((N + M, N + M))
-    D[0:N, 0:M] = DUL
-    UR = np.max(D) * np.ones((N, N))
+    D = np.zeros((M + N, M + N))
+    D[0:M, 0:N] = DUL
+    UR = np.max(D) * np.ones((M, M))
     np.fill_diagonal(UR, 0.5 * (S[:, 1] - S[:, 0]))
-    D[0:N, M::] = UR
-    UL = np.max(D) * np.ones((M, M))
+    D[0:M, N::] = UR
+    UL = np.max(D) * np.ones((N, N))
     np.fill_diagonal(UL, 0.5 * (T[:, 1] - T[:, 0]))
-    D[N::, 0:M] = UL
+    D[M::, 0:N] = UL
 
     # Step 2: Perform a binary search + Hopcroft Karp to find the
     # bottleneck distance
-    N = D.shape[0]
-    ds = np.unique(D.flatten())
-    ds = ds[ds > 0]
-    ds = np.sort(ds)
+    M = D.shape[0]
+    ds = np.sort(np.unique(D.flatten()))
     bdist = ds[-1]
     matching = {}
     while len(ds) >= 1:
@@ -83,18 +104,18 @@ def bottleneck(dgm1, dgm2, matching=False):
             idx = bisect_left(range(ds.size), int(ds.size / 2))
         d = ds[idx]
         graph = {}
-        for i in range(N):
-            graph["%s" % i] = {j for j in range(N) if D[i, j] <= d}
+        for i in range(M):
+            graph["%s" % i] = {j for j in range(M) if D[i, j] <= d}
         res = HopcroftKarp(graph).maximum_matching()
-        if len(res) == 2 * N and d < bdist:
+        if len(res) == 2 * M and d <= bdist:
             bdist = d
             matching = res
             ds = ds[0:idx]
         else:
-            ds = ds[idx + 1 : :]
+            ds = ds[idx + 1::]
 
     if return_matching:
-        matchidx = [(i, matching["%i" % i]) for i in range(N)]
+        matchidx = [(i, matching["%i" % i]) for i in range(M)]
         return bdist, (matchidx, D)
     else:
         return bdist