Merge pull request #66 from MunchLab/mapper_graph

Added a basic mapper graph class skeleton

Author: lizliz

README.md

@@ -40,5 +40,4 @@ The code is a compilation of work done by [Elizabeth Munch](http://www.elizabeth
 
 ## Contact Information
 
-- [Liz Munch](http://www.elizabethmunch.com): [muncheli@msu.edu](mailto:muncheli@msu.edu)
-- [Danielle Barnes](https://github.com/barnesd8): [barnesd8@msu.edu](mailto:barnesd8@msu.edu)
+- [Liz Munch](http://www.elizabethmunch.com): [muncheli@msu.edu](mailto:muncheli@msu.edu)

cereeberus/cereeberus/__init__.py

@@ -2,4 +2,5 @@
 
 from .reeb.reebgraph import ReebGraph
 from .reeb.merge import MergeTree
+from .reeb.mapper import MapperGraph
 from .reeb.embeddedgraph import EmbeddedGraph

cereeberus/cereeberus/data/ex_mappergraphs.py

@@ -0,0 +1,87 @@
+from cereeberus import ReebGraph, MapperGraph
+from cereeberus.data import ex_graphs
+
+def torus(delta = .1, seed=None):
+    '''
+    Returns the Mapper graph of a simple upright torus as a MapperGraph class. 
+
+    Parameters:
+        delta (float): Optional. The delta value to use for the Mapper graph.
+        seed (int): Optional. The seed to use for the random number generator, which only controls the layout function.
+
+    Returns:
+        Mapper: The mapper graph of the torus.
+
+    
+    .. figure:: ../../images/torus_mapper.png
+        :figwidth: 400px
+
+    '''
+    return ReebGraph(ex_graphs.torus_graph(), seed=seed).to_mapper(delta = delta)
+
+def dancing_man(delta = .1, seed=None):
+    '''
+    Returns the Mapper graph of the dancing man as a MapperGraph class. 
+
+    Parameters:
+
+        seed (int): Optional. The seed to use for the random number generator, which only controls the layout function.
+
+    Returns:
+        MapperGraph: The mapper graph of the dancing man.
+    
+    .. figure:: ../../images/dancing_man_mapper.png
+        :figwidth: 400px
+
+    '''
+    return ReebGraph(ex_graphs.dancing_man(), seed=seed).to_mapper(delta = delta)
+
+def juggling_man(delta = .1, seed=None):
+    '''
+    Returns a modified mapper graph of the juggling man as a MapperGraph class. Some vertex locations were moved to make them integers. 
+
+    Parameters:
+        seed (int): Optional. The seed to use for the random number generator, which only controls the layout function.
+
+    Returns:
+        MapperGraph: The mapper graph of the juggling man.
+    
+    .. figure:: ../../images/juggling_man_mapper.png
+        :figwidth: 400px
+
+    '''
+    R = ReebGraph(ex_graphs.juggling_man(), seed=seed)
+    R.f[9] = 7
+    R.f[8] = 6
+    R.f[10] = 5
+
+    return R.to_mapper(delta = delta)
+
+def simple_loops(delta = .1, seed=None):
+    '''
+    Returns the mapper graph of the simple loops example.
+
+    Parameters:
+        seed (int): Optional. The seed to use for the random number generator, which only controls the layout function.
+
+    Returns:
+        MapperGraph: The mapper graph of the simple loops example.
+    
+    .. figure:: ../../images/simple_loops_mapper.png
+        :figwidth: 400px
+
+    '''
+    return ReebGraph(ex_graphs.simple_loops(), seed=seed).to_mapper()
+
+def simple_loops_unordered(seed=None):
+    '''
+    Returns the mapper graph of the unordered simple loops example.
+
+    Parameters:
+        seed (int): Optional. The seed to use for the random number generator, which only controls the layout function.
+
+    Returns:
+        MapperGraph: The mapper graph of the simple loops example.
+
+    '''
+    return ReebGraph(ex_graphs.simple_loops_unordered(), seed=seed).to_mapper()

cereeberus/cereeberus/data/ex_reebgraphs.py

@@ -2,91 +2,74 @@
 from cereeberus.data import ex_graphs
 
 def torus(seed=None):
-    def torus(seed=None):
-        '''
-        Returns the Reeb graph of a simple upright torus as a ReebGraph class. 
-
-        Parameters:
-            seed (int): Optional. The seed to use for the random number generator, which only controls the layout function.
-
-        Returns:
-            ReebGraph: The Reeb graph of the torus.
-        
-        .. figure:: images/torus.png
-            :figwidth: 200px
-
-        '''
-        return ReebGraph(ex_graphs.torus_graph(), seed=seed)
-
-    def dancing_man(seed=None):
-        '''
-        Returns the Reeb graph of the dancing man as a ReebGraph class. 
-
-        Parameters:
-            seed (int): Optional. The seed to use for the random number generator, which only controls the layout function.
-
-        Returns:
-            ReebGraph: The Reeb graph of the dancing man.
-        '''
-        return ReebGraph(ex_graphs.dancing_man(), seed=seed)
-
-    def juggling_man(seed=None):
-        '''
-        Returns the Reeb graph of the juggling man as a ReebGraph class. 
-
-        Parameters:
-            seed (int): Optional. The seed to use for the random number generator, which only controls the layout function.
-
-        Returns:
-            ReebGraph: The Reeb graph of the juggling man.
-        '''
-        return ReebGraph(ex_graphs.juggling_man(), seed=seed)
-
-    def simple_loops(seed=None):
-        '''
-        Returns the Reeb graph of the simple loops example.
-
-        Parameters:
-            seed (int): Optional. The seed to use for the random number generator, which only controls the layout function.
-
-        Returns:
-            ReebGraph: The Reeb graph of the simple loops example.
-        '''
-        return ReebGraph(ex_graphs.simple_loops(), seed=seed)
+    '''
+    Returns the Reeb graph of a simple upright torus as a ReebGraph class. 
 
-    def simple_loops_unordered(seed=None):
-        '''
-        Returns the Reeb graph of the simple loops example.
+    Parameters:
+        seed (int): Optional. The seed to use for the random number generator, which only controls the layout function.
 
-        Parameters:
-            seed (int): Optional. The seed to use for the random number generator, which only controls the layout function.
+    Returns:
+        ReebGraph: The Reeb graph of the torus.
+    
+    .. figure:: ../../images/torus.png
+        :figwidth: 400px
 
-        Returns:
-            ReebGraph: The Reeb graph of the simple loops example.
-        '''
-        return ReebGraph(ex_graphs.simple_loops_unordered(), seed=seed)
+    '''
     return ReebGraph(ex_graphs.torus_graph(), seed=seed)
 
 def dancing_man(seed=None):
     '''
     Returns the Reeb graph of the dancing man as a ReebGraph class. 
+
+    Parameters:
+        seed (int): Optional. The seed to use for the random number generator, which only controls the layout function.
+
+    Returns:
+        ReebGraph: The Reeb graph of the dancing man.
+    
+    .. figure:: ../../images/dancing_man.png
+        :figwidth: 400px
     '''
     return ReebGraph(ex_graphs.dancing_man(), seed=seed)
 
 def juggling_man(seed=None):
     '''
     Returns the Reeb graph of the juggling man as a ReebGraph class. 
+
+    Parameters:
+        seed (int): Optional. The seed to use for the random number generator, which only controls the layout function.
+
+    Returns:
+        ReebGraph: The Reeb graph of the juggling man.
+
+    .. figure:: ../../images/juggling_man.png
+        :figwidth: 400px
     '''
     return ReebGraph(ex_graphs.juggling_man(), seed=seed)
 
 def simple_loops(seed=None):
     '''
-    Returns the Reeb graph of the simple loops example
+    Returns the Reeb graph of the simple loops example.
+
+    Parameters:
+        seed (int): Optional. The seed to use for the random number generator, which only controls the layout function.
+
+    Returns:
+        ReebGraph: The Reeb graph of the simple loops example.
+
+    .. figure:: ../../images/simple_loops.png
+        :figwidth: 400px
     '''
     return ReebGraph(ex_graphs.simple_loops(), seed=seed)
 
 def simple_loops_unordered(seed=None):
     '''
-    Returns the Reeb graph of the simple loops example
+    Returns the Reeb graph of the simple loops example.
+
+    Parameters:
+        seed (int): Optional. The seed to use for the random number generator, which only controls the layout function.
+
+    Returns:
+        ReebGraph: The Reeb graph of the simple loops example.
     '''
     return ReebGraph(ex_graphs.simple_loops_unordered(), seed=seed)

cereeberus/cereeberus/reeb/__init__.py

@@ -1 +1 @@
-__all__ = ['reebgraph', 'merge']
+__all__ = ['reebgraph', 'merge', 'mapper', 'embeddedgraph']

cereeberus/cereeberus/reeb/mapper.py

@@ -0,0 +1,97 @@
+from cereeberus import ReebGraph
+
+class MapperGraph(ReebGraph):
+    """
+    A mapper graph structure. This inherits the properties of the Reeb graph in that it is a graph with a function given on the vertices, but with some additional requirements.
+
+    - The values are integers in some range, [n_low, n_low+1, \cdots, n_high], although we consider the funciton values to be [\delta * n_low, \delta* (n_low+1), \cdots, \delta * n_high] for a stored delta 
+    - If an edge crosses a value, it has a vertex (so that the inverse image of any integer is only vertices, not interiors of edges)
+    - An internal delta is stored so that this can be interpreted as function values [\delta * n_low, \delta* (n_low+1), \cdots, \delta * n_high] 
+    """
+
+    def __init__(self, 
+                 G=None, f={}, delta = None, seed = None, verbose=False):
+
+        # Check that $f$ values are only integers
+        if not all([isinstance(f[v], int) for v in f]):
+            raise ValueError("Function values must be integers.")
+        if delta is None:
+            self.delta = 1
+        else: 
+            self.delta = delta 
+
+        super().__init__(G, f, seed, verbose)
+
+        self.mapperify()
+
+    def add_edge(self, u, v, reset_pos=True):
+        """
+        Add an edge to the graph. This will also update the internal structure to make sure it satisfies the mapper properties.
+        """
+        super().add_edge(u, v, reset_pos)
+        self.mapperify()
+
+
+
+    def mapperify(self):
+        """
+        Take the internal structure and make sure it satisfies the requirement that all edges have adjacent function values. 
+        """
+
+        # If we're initializing with nothing, this should pass. 
+        # Note that if self.n_low is None, then self.n_high and self.delta
+        # are both None as well but I am not currently checking that.
+        try:
+            n_low = min(self.f.values())
+            n_high = max(self.f.values())
+
+        except:
+            return
+        
+        last_vert_name = max(self.nodes())
+        
+        for i in range(n_low,n_high+1):
+            e_list = [e for e in self.edges() if self.f[e[0]] < i and self.f[e[1]] > i]
+
+            for e in e_list:
+                w_name = self.next_vert_name(last_vert_name)
+                self.subdivide_edge(*e,w_name, i)
+
+                last_vert_name = w_name
+            
+    
+    def add_node(self, vertex, f_vertex, reset_pos=True):
+
+        """
+        Same as adding a node in Reeb, but with the additional requirement that the function value is an integer.
+        """
+
+        if not isinstance(f_vertex, int):
+            raise ValueError("Function values must be integers.")
+        return super().add_node(vertex, f_vertex, reset_pos)
+    
+
+
+    def set_pos_from_f(self, seed=None, verbose=False):
+
+        """
+        Same as the Reeb graph function, but we want to draw the vertex locations at delta*function value.
+        """
+        super().set_pos_from_f(seed, verbose)
+
+        for v in self.nodes():
+            self.pos_f[v] = (self.pos_f[v][0],self.delta * self.f[v])
+
+    def induced_subgraph(self, nodes):
+        """
+        Returns the subgraph of the mapper graph induced by the nodes in the list nodes.
+
+        Parameters:
+            nodes (list): The list of nodes to include in the subgraph.
+        
+        Returns:
+            MapperGraph
+        """
+        R = super().induced_subgraph(nodes)
+        return R.to_mapper(self.delta)
+