mogutda 0.4.3__py3-none-any.whl

mogutda/__init__.py

@@ -0,0 +1,5 @@
+
+from .utils import *
+from .abssimcomplex import SimplicialComplex
+from .alphacomplex import AlphaComplex
+from .vrcomplex import VietorisRipsComplex

mogutda/abssimcomplex.py

@@ -0,0 +1,131 @@
+
+from itertools import combinations
+import warnings
+
+import numpy as np
+from scipy.sparse import dok_matrix
+from scipy.sparse.linalg import aslinearoperator
+from scipy.linalg.interpolative import estimate_rank
+import networkx as nx
+import matplotlib.pyplot as plt
+
+from .utils import faces
+
+
+class SimplicialComplex:
+    def __init__(self, simplices=[]):
+        self.import_simplices(simplices=simplices)
+
+    def import_simplices(self, simplices=[]):
+        # self.simplices = list(map(lambda simplex: tuple(sorted(simplex)), simplices))
+        self.simplices = [tuple(sorted(simplex)) for simplex in simplices]
+        self.face_set = faces(self.simplices)
+
+    def n_faces(self, n):
+        # return list(filter(lambda face: len(face) == n + 1, self.face_set))
+        return [face for face in self.face_set if len(face) == n+1]
+
+    def boundary_operator(self, i):
+        source_simplices = self.n_faces(i)
+        target_simplices = self.n_faces(i - 1)
+
+        if len(target_simplices) == 0:
+            S = dok_matrix((1, len(source_simplices)), dtype=np.float64)
+            S[0, 0:len(source_simplices)] = 1
+        else:
+            source_simplices_dict = {
+                source_simplices[j]: j for j in range(len(source_simplices))
+            }
+            target_simplices_dict = {
+                target_simplices[i]: i for i in range(len(target_simplices))
+            }
+
+            S = dok_matrix(
+                (len(target_simplices), len(source_simplices)), dtype=np.float64
+            )
+            for source_simplex in source_simplices:
+                for a in range(len(source_simplex)):
+                    target_simplex = source_simplex[:a] + source_simplex[(a + 1) :]
+                    i = target_simplices_dict[target_simplex]
+                    j = source_simplices_dict[source_simplex]
+                    S[i, j] = -1 if a % 2 == 1 else 1  # S[i, j] = (-1)**a
+        return S
+
+    def betti_number(self, i, eps=None):
+        boundop_i = self.boundary_operator(i)
+        boundop_ip1 = self.boundary_operator(i + 1)
+
+        if i == 0:
+            boundop_i_rank = 0
+        else:
+            if eps is None:
+                try:
+                    boundop_i_rank = np.linalg.matrix_rank(boundop_i.toarray())
+                except (np.linalg.LinAlgError, ValueError):
+                    boundop_i_rank = boundop_i.shape[1]
+            else:
+                boundop_i_rank = estimate_rank(aslinearoperator(boundop_i), eps)
+
+        if eps is None:
+            try:
+                boundop_ip1_rank = np.linalg.matrix_rank(boundop_ip1.toarray())
+            except (np.linalg.LinAlgError, ValueError):
+                boundop_ip1_rank = boundop_ip1.shape[1]
+        else:
+            boundop_ip1_rank = estimate_rank(aslinearoperator(boundop_ip1), eps)
+
+        return (boundop_i.shape[1] - boundop_i_rank) - boundop_ip1_rank
+
+    def euler_characteristics(self):
+        max_n = max(map(len, self.simplices))
+        return sum(
+            [(-1 if a % 2 == 1 else 1) * self.betti_number(a) for a in range(max_n)]
+        )
+
+    def generate_graph(self, simplices=None):
+        """ Generate edges and vertices in sets """
+        if len(self.simplices) == 0 and simplices is None:
+            raise Exception("No simplices to create a graph from. Please specify one.")
+        elif simplices is not None:
+            self.import_simplices(simplices=simplices)
+
+        vertices = set()
+        edges = set()
+
+        for simplex in self.simplices:
+            for vertex1, vertex2 in combinations(simplex, 2):
+                vertices.add(vertex1)
+                vertices.add(vertex2)
+                edges.add(tuple(sorted([vertex1, vertex2])))
+        return vertices, edges
+
+    def draw(self, vertex_labels=True, edge_labels=False):
+        """ Draw the Simplicial Complex """
+        vertices, edges = self.generate_graph()
+
+        if len(vertices) + len(edges) > 1000:
+            warnings.warn(
+                "The number of elements to draw exceeds 100. To still draw the plot, call the function with override_100_limit = True. "
+            )
+        else:
+            G = nx.Graph()
+            for vertex in vertices:
+                G.add_node(vertex)
+            for edge in edges:
+                G.add_edge(edge[0], edge[1])
+            pos = nx.spring_layout(G)
+
+            nx.draw(G, pos)
+
+            labels = {}
+            if vertex_labels is True:
+                for vertex in vertices:
+                    labels[vertex] = str(vertex)
+            nx.draw_networkx_labels(G, pos, labels, font_size=16)
+
+            if edge_labels is True:
+                edge_labels = {}
+                for edge in edges:
+                    edge_labels[edge] = "{}:{}".format(edge[0], edge[1])
+                nx.draw_networkx_edge_labels(G, pos, edge_labels, font_size=3)
+            plt.plot()

mogutda/alphacomplex.py

@@ -0,0 +1,71 @@
+
+from scipy.spatial import Delaunay, distance
+
+from .abssimcomplex import SimplicialComplex
+from .utils import facesiter, get_allpoints
+
+
+def calculate_distmatrix(points, labels, distfcn):
+    return {
+        (labels[i], labels[j]): distfcn(points[i], points[j])
+        for i in range(len(labels)) for j in range(len(labels))
+    }
+
+
+def contain_detachededges(simplex, distdict, epsilon):
+    if len(simplex) == 2:
+        return distdict[simplex[0], simplex[1]] > 2*epsilon
+    else:
+        for face in facesiter(simplex):
+            contained = contain_detachededges(face, distdict, epsilon)
+            if contained:
+                return True
+        return False
+
+
+class AlphaComplex(SimplicialComplex):
+    def __init__(
+            self,
+            points,
+            epsilon,
+            labels=None,
+            distfcn=distance.euclidean
+    ):
+        super(AlphaComplex, self).__init__()
+        self.pts = points
+        self.labels = (range(len(self.pts))
+                       if (labels is None or len(labels) != len(self.pts))
+                       else labels)
+        self.epsilon = epsilon
+        self.distfcn = distfcn
+        self.import_simplices(
+            self.construct_simplices(self.pts, self.labels, self.epsilon, self.distfcn)
+        )
+
+    def construct_simplices(self, points, labels, epsilon, distfcn):
+        distdict = calculate_distmatrix(points, labels, distfcn)
+
+        delaunayobj = Delaunay(points)
+
+        simplices = []
+        for simplexnda in delaunayobj.simplices:
+            simplex = tuple(simplexnda)
+
+            detached = [contain_detachededges(face, distdict, epsilon) for face in facesiter(simplex)]
+
+            if True in detached and len(simplex) > 2:
+                simplices += [
+                    face
+                    for face, notkeep in zip(facesiter(simplex), detached)
+                    if not notkeep
+                ]
+            else:
+                simplices.append(simplex)
+        # simplices = map(lambda simplex: tuple(sorted(simplex)), simplices)
+        simplices = [tuple(sorted(simplex)) for simplex in simplices]
+        simplices = list(set(simplices))
+
+        allpts = get_allpoints(simplices)
+        simplices += [(point,) for point in (set(labels)-allpts)]
+
+        return simplices

mogutda/utils.py

@@ -0,0 +1,27 @@
+
+from itertools import combinations
+
+
+def facesiter(simplex):
+    for i in range(len(simplex)):
+        yield simplex[:i] + simplex[(i + 1):]
+
+
+def flattening_simplex(simplices):
+    for simplex in simplices:
+        for point in simplex:
+            yield point
+
+
+def get_allpoints(simplices):
+    return set(flattening_simplex(simplices))
+
+
+def faces(simplices):
+    faceset = set()
+    for simplex in simplices:
+        numnodes = len(simplex)
+        for r in range(numnodes, 0, -1):
+            for face in combinations(simplex, r):
+                faceset.add(tuple(sorted(face)))
+    return faceset

mogutda/vrcomplex.py

@@ -0,0 +1,38 @@
+
+from itertools import product
+
+import networkx as nx
+from scipy.spatial import distance
+
+from .abssimcomplex import SimplicialComplex
+
+
+class VietorisRipsComplex(SimplicialComplex):
+    def __init__(
+            self,
+            points,
+            epsilon,
+            labels=None,
+            distfcn=distance.euclidean
+    ):
+        super(VietorisRipsComplex, self).__init__()
+        self.pts = points
+        self.labels = (list(range(len(self.pts)))
+                       if labels is None or len(labels) != len(self.pts)
+                       else labels)
+        self.epsilon = epsilon
+        self.distfcn = distfcn
+        self.network = self.construct_network(
+            self.pts, self.labels, self.epsilon, self.distfcn
+        )
+        self.import_simplices(map(tuple, nx.find_cliques(self.network)))
+
+    def construct_network(self, points, labels, epsilon, distfcn):
+        g = nx.Graph()
+        g.add_nodes_from(labels)
+        for pair in product(zip(points, labels), zip(points, labels)):
+            if pair[0][1] != pair[1][1]:
+                dist = distfcn(pair[0][0], pair[1][0])
+                if dist < epsilon:
+                    g.add_edge(pair[0][1], pair[1][1])
+        return g

mogutda-0.4.3.dist-info/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2018 Kwan Yuet Stephen Ho
+
+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.

mogutda-0.4.3.dist-info/METADATA

@@ -0,0 +1,182 @@
+Metadata-Version: 2.1
+Name: mogutda
+Version: 0.4.3
+Summary: Topological Data Analysis in Python
+Author-email: Kwan Yuet Stephen Ho <stephenhky@yahoo.com.hk>
+License: MIT
+Project-URL: Documentation, https://mogutda.readthedocs.io
+Project-URL: Repository, https://github.com/stephenhky/MoguTDA
+Project-URL: Issues, https://github.com/stephenhky/MoguTDA/issues
+Keywords: mogutda,numerical methods,topology,data,algebraic topology
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Topic :: Scientific/Engineering :: Physics
+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: License :: OSI Approved :: MIT License
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Information Technology
+Classifier: Intended Audience :: Science/Research
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.16.0
+Requires-Dist: scipy>=1.10.0
+Requires-Dist: networkx>=2.0
+Requires-Dist: matplotlib>=3.3.0
+Provides-Extra: test
+Requires-Dist: unittest; extra == "test"
+
+# `mogutda`: Topological Data Analysis in Python
+
+[![CircleCI](https://circleci.com/gh/stephenhky/MoguTDA.svg?style=svg)](https://circleci.com/gh/stephenhky/MoguTDA.svg)
+[![GitHub release](https://img.shields.io/github/release/stephenhky/MoguTDA.svg?maxAge=3600)](https://github.com/stephenhky/MoguTDA/releases)
+[![Documentation Status](https://readthedocs.org/projects/mogutda/badge/?version=latest)](https://mogutda.readthedocs.io/en/latest/?badge=latest)
+[![Updates](https://pyup.io/repos/github/stephenhky/MoguTDA/shield.svg)](https://pyup.io/repos/github/stephenhky/MoguTDA/)
+[![Python 3](https://pyup.io/repos/github/stephenhky/MoguTDA/python-3-shield.svg)](https://pyup.io/repos/github/stephenhky/MoguTDA/)
+[![pypi](https://img.shields.io/pypi/v/mogutda.svg?maxAge=3600)](https://pypi.org/project/mogutda/)
+[![download](https://img.shields.io/pypi/dm/mogutda.svg?maxAge=2592000&label=installs&color=%2327B1FF)](https://pypi.org/project/mogutda/)
+[![stars](https://img.shields.io/github/stars/stephenhky/MoguTDA.svg?style=social&label=Star&maxAge=60)](https://github.com/stephenhky/MoguTDA)
+
+
+## Introduction
+
+`mogutda` contains Python codes that demonstrate the numerical calculation
+of algebraic topology in an application to topological data analysis
+(TDA). Its core code is the numerical methods concerning implicial complex,
+and the estimation of homology and Betti numbers.
+
+Topological data analysis aims at studying the shapes of the data, and
+draw some insights from them. A lot of machine learning algorithms deal
+with distances, which are extremely useful, but they miss the
+information the data may carry from their geometry.
+
+## History
+
+The codes in this package were developed as a demonstration of a few posts of my blog.
+It was not designed to be a Python package but a pedagogical collection of codes.
+(See: [PyTDA](https://github.com/stephenhky/PyTDA).)
+However, the codes and the blog posts have been unexpectedly popular. Therefore,
+I modularized the code into the package [`mogu`](https://pypi.org/project/mogu/).
+(or corresponding repository: [MoguNumerics](https://github.com/stephenhky/MoguNumerics))
+However, `mogu` is simply a collection of unrelated numerical routines with a lot of
+dependencies, but the part of TDA can be quite independent.
+
+In order to provide other researchers and developers an independent package, which is compact (without
+unecessary alternative packages to load), and efficient, I decided to modularize
+the codes of TDA separately, and name this package `mogutda`.
+
+## Prerequisite
+
+It runs under Python 3.8, 3.9, 3.10, and 3.11.
+
+## Simple Tutorial: Simplicial Complex
+
+You can install by:
+
+```
+pip install mogutda
+```
+
+To establish a simplicial complex for a torus, type
+
+```
+import numpy as np
+from mogutda import SimplicialComplex
+
+torus_sc = [(1,2,4), (4,2,5), (2,3,5), (3,5,6), (5,6,1), (1,6,2), (6,7,2), (7,3,2),
+            (1,3,4), (3,4,6), (4,6,7), (4,5,7), (5,7,1), (7,3,1)]
+torus_c = SimplicialComplex(simplices=torus_sc)
+```
+
+To retrieve its Betti numbers, type:
+
+```
+print(torus_c.betti_number(0))   # print 1
+print(torus_c.betti_number(1))   # print 2
+print(torus_c.betti_number(2))   # print 1
+```
+
+## Demo Codes and Blog Entries
+
+Codes in this repository are demo codes for a few entries of my blog,
+[Everything about Data Analytics](https://datawarrior.wordpress.com/),
+and the corresponding entries are:
+
+* [Starting the Journey of Topological Data Analysis (TDA)](https://datawarrior.wordpress.com/2015/08/03/tda-1-starting-the-journey-of-topological-data-analysis-tda/) (August 3, 2015)
+* [Constructing Connectivities](https://datawarrior.wordpress.com/2015/09/14/tda-2-constructing-connectivities/) (September 14, 2015)
+* [Homology and Betti Numbers](https://datawarrior.wordpress.com/2015/11/03/tda-3-homology-and-betti-numbers/) (November 3, 2015)
+* [Topology in Physics and Computing](https://datawarrior.wordpress.com/2015/11/10/mathanalytics-6-topology-in-physics-and-computing/) (November 10, 2015)
+* [Persistence](https://datawarrior.wordpress.com/2015/12/20/tda-4-persistence/) (December 20, 2015)
+* [Topological Phases](https://datawarrior.wordpress.com/2016/10/06/topological-phases/) (October 6, 2016)
+* [moguTDA: Python package for Simplicial Complex](https://datawarrior.wordpress.com/2018/07/02/mogutda-python-package-for-simplicial-complex/) (July 2, 2018)
+
+## Wolfram Demonstration
+Richard Hennigan put a nice Wolfram Demonstration online explaining what
+the simplicial complexes are, and how homologies are defined:
+
+* [Simplicial Homology of the Alpha Complex](http://demonstrations.wolfram.com/SimplicialHomologyOfTheAlphaComplex/)
+
+## News
+
+* 09/19/2024: `mogutda` 0.4.3 released.
+* 07/16/2024: `mogutsa` 0.4.2 released.
+* 11/23/2023: `mogutda` 0.4.1 released.
+* 08/18/2023: `mogutda` 0.4.0 released.
+* 06/20/2023: `mogutda` 0.3.5 released.
+* 09/09/2022: `mogutda` 0.3.4 released.
+* 07/15/2021: `mogutda` 0.3.3 released.
+* 04/10/2021: `mogutda` 0.3.2 released.
+* 11/28/2020: `mogutda` 0.3.1 released.
+* 08/16/2020: `mogutda` 0.3.0 released.
+* 04/28/2020: `mogutda` 0.2.1 released.
+* 01/16/2020: `mogutda` 0.2.0 released.
+* 02/20/2019: `mogutda` 0.1.5 released.
+* 12/31/2018: `mogutda` 0.1.4 released.
+* 07/18/2018: `mogutda` 0.1.3 released.
+* 07/02/2018: `mogutda` 0.1.2 released.
+* 06/13/2018: `mogutda` 0.1.1 released.
+* 06/11/2018: `mogutda` 0.1.0 released.
+
+## Other TDA Packages
+
+It is recommended that for real application, you should use the following packages
+for efficiency, because my codes serve the pedagogical purpose only.
+
+### C++
+* [Dionysus](http://www.mrzv.org/software/dionysus/)
+* [PHAT](https://bitbucket.org/phat-code/phat)
+
+### Python
+* [Dionysus](http://www.mrzv.org/software/dionysus/python/overview.html)
+
+### R
+* [TDA](https://cran.r-project.org/web/packages/TDA/index.html) (article: [\[arXiv\]](http://arxiv.org/abs/1411.1830))
+
+## Contributions
+
+If you want to contribute, feel free to fork the repository, and submit
+a pull request whenever you are ready.
+
+If you spot any bugs or issues, go to the [Issue](https://github.com/stephenhky/MoguTDA) page.
+
+I may not approve pull request immediately if your suggested change is big.
+If you want to incorporate something big, please discuss with me first.
+
+## References
+* Afra J. Zomorodian. *Topology for Computing* (New York, NY: Cambridge University Press, 2009). [\[Amazon\]](https://www.amazon.com/Computing-Cambridge-Monographs-Computational-Mathematics/dp/0521136091)
+* Afra J. Zomorodian. "Topological Data Analysis," *Proceedings of Symposia in Applied Mathematics* (2011). [\[link\]](http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.261.1298)
+* Afra Zomorodian, Gunnar Carlsson, “Computing Persistent Homology,” *Discrete Comput. Geom.* 33, 249-274 (2005). [\[pdf\]](http://geometry.stanford.edu/papers/zc-cph-05/zc-cph-05.pdf)
+* Gunnar Carlsson, “Topology and Data”, *Bull. Amer. Math. Soc.* 46, 255-308 (2009). [\[link\]](http://www.ams.org/journals/bull/2009-46-02/S0273-0979-09-01249-X/)
+* Jeffrey Ray, Marcello Trovati, "A Survey of Topological Data Analysis (TDA) Methods Implemented in Python," in *Advances in Intelligent Networking and Collaborative Systems*, Springer (2018).
+* P. Y. Lum, G. Singh, A. Lehman, T. Ishkanov, M. Vejdemo-Johansson, M. Alagappan, J. Carlsson, G. Carlsson, “Extracting insights from the shape of complex data using topology”, *Sci. Rep.* 3, 1236 (2013). [\[link\]](http://www.nature.com/srep/2013/130207/srep01236/full/srep01236.html)
+* Robert Ghrist, “Barcodes: The persistent topology of data,” *Bull. Amer. Math. Soc.* 45, 1-15 (2008). [\[pdf\]](http://www.ams.org/journals/bull/2008-45-01/S0273-0979-07-01191-3/S0273-0979-07-01191-3.pdf)
+
+## Links
+
+* PyPI: [https://pypi.org/project/mogutda/](https://pypi.org/project/mogutda/)
+* Documentation: [https://mogutda.readthedocs.io/](https://mogutda.readthedocs.io/)
+* Bug Reports: [https://github.com/stephenhky/MoguTDA/issues](https://github.com/stephenhky/MoguTDA/issues)

mogutda-0.4.3.dist-info/RECORD

@@ -0,0 +1,10 @@
+mogutda/__init__.py,sha256=vKhNOC6bE6kRNh-dAEb0GWnmvbpf75TFLHadBLd3Bno,149
+mogutda/abssimcomplex.py,sha256=3_E5SbQMf1kBXtS4vwRGLV5sin-Slv64URbnCfUaJEo,4857
+mogutda/alphacomplex.py,sha256=eBGv-ZgcfAJnVCaMKfBQ-PV-Mk7gK34yYM13dWj-tTc,2293
+mogutda/utils.py,sha256=1KDTfo8ClLueGPLXn-l1rxWTfLqxsjtDMsX0nQGK89E,606
+mogutda/vrcomplex.py,sha256=0FE9h4yRbf1DgdQtYvfm-J5j7oeO0JlZPmp0L06le24,1220
+mogutda-0.4.3.dist-info/LICENSE,sha256=3paJBNa5qA0n3pWiu0x3NMUOpzN_ypGIWKQ3YImmz_o,1063
+mogutda-0.4.3.dist-info/METADATA,sha256=npkQgBI5dewlRCx2Wg-yRrJ4eQacovAno6ps8B3_AR8,9279
+mogutda-0.4.3.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+mogutda-0.4.3.dist-info/top_level.txt,sha256=K_S8S2ArTcepp_xCda5D_91jTHd04raVcOt7dX6vmHw,8
+mogutda-0.4.3.dist-info/RECORD,,

mogutda-0.4.3.dist-info/WHEEL

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

mogutda-0.4.3.dist-info/top_level.txt

@@ -0,0 +1 @@
+mogutda