From ac7d637f44fca7801dbaabba777bf630d3a4bd06 Mon Sep 17 00:00:00 2001
From: wjdrlduq1234 <50209510+wjdrlduq1234@users.noreply.github.com>
Date: Fri, 12 Jul 2019 02:07:24 +0900
Subject: [PATCH 01/19] define path length

---
 kmapper/kmapper.py | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/kmapper/kmapper.py b/kmapper/kmapper.py
index ded4d635..d28930ce 100644
--- a/kmapper/kmapper.py
+++ b/kmapper/kmapper.py
@@ -898,3 +898,26 @@ def blend(X_blend, pred_fun, folder, X_data, y):
         X = X_blend
 
         return X
+
+    def digitize_relationship(
+        self,
+        X,
+    ):
+        """Let members a, b each in nodes n, m. And define path length r of a and b; least number of edges that connect a, b. 
+           If a and b is connected by same node, then r is 0. And if a and b is not connected, then r is -1.
+           This function print out Dataframe that every r of the data mapped.
+           It's meaningful to digitize relationship.
+        
+        Parameters
+        ----------
+
+        X : Numpy Array
+            The data mapped
+
+        Returns
+        -------
+        lens : Dataframe
+            every path length of the data mapped.       
+            
+            
+            

From 497f003d9d7e77ea197129c1003dc9875407097a Mon Sep 17 00:00:00 2001
From: Kiyuob Jung <50209510+wjdrlduq1234@users.noreply.github.com>
Date: Fri, 12 Jul 2019 04:53:23 +0900
Subject: [PATCH 02/19] definition outline

---
 kmapper/kmapper.py | 40 ++++++++++++++++++++++++++++++++++++----
 1 file changed, 36 insertions(+), 4 deletions(-)

diff --git a/kmapper/kmapper.py b/kmapper/kmapper.py
index d28930ce..2508f448 100644
--- a/kmapper/kmapper.py
+++ b/kmapper/kmapper.py
@@ -898,14 +898,40 @@ def blend(X_blend, pred_fun, folder, X_data, y):
         X = X_blend
 
         return X
-
-    def digitize_relationship(
+    
+    def path_length(
         self,
         X,
+        a,
+        b
     ):
         """Let members a, b each in nodes n, m. And define path length r of a and b; least number of edges that connect a, b. 
            If a and b is connected by same node, then r is 0. And if a and b is not connected, then r is -1.
-           This function print out Dataframe that every r of the data mapped.
+        
+        Parameters
+        ----------
+        X : Numpy Array
+            The data mapped
+        a : a member
+        b : a member
+        
+        Returns
+        -------
+        r : int
+            path length r of a and b
+        
+        """
+        
+        
+        
+        return r
+        
+        
+    def digitize_relationship(
+        self,
+        X,
+    ):
+        """This function print out Dataframe that every path length of the data mapped.
            It's meaningful to digitize relationship.
         
         Parameters
@@ -916,8 +942,14 @@ def digitize_relationship(
 
         Returns
         -------
-        lens : Dataframe
+        result : Dataframe
             every path length of the data mapped.       
+        """
+        
+        
+        
+        result.index, result.columns = 
+        return result
             
             
             

From b79f2cd5876258c910397b1d8ed29da3d1c061ea Mon Sep 17 00:00:00 2001
From: Kiyuob Jung <50209510+wjdrlduq1234@users.noreply.github.com>
Date: Mon, 15 Jul 2019 21:56:07 +0900
Subject: [PATCH 03/19] full values; just 0, 1, -1

I can full values only 0, 1. I'll think it more how can I obtain more than 2. (-1 is easy)
---
 kmapper/kmapper.py | 84 ++++++++++++++++++++++++----------------------
 1 file changed, 44 insertions(+), 40 deletions(-)

diff --git a/kmapper/kmapper.py b/kmapper/kmapper.py
index 2508f448..00951887 100644
--- a/kmapper/kmapper.py
+++ b/kmapper/kmapper.py
@@ -899,45 +899,18 @@ def blend(X_blend, pred_fun, folder, X_data, y):
 
         return X
     
-    def path_length(
-        self,
-        X,
-        a,
-        b
-    ):
-        """Let members a, b each in nodes n, m. And define path length r of a and b; least number of edges that connect a, b. 
-           If a and b is connected by same node, then r is 0. And if a and b is not connected, then r is -1.
-        
-        Parameters
-        ----------
-        X : Numpy Array
-            The data mapped
-        a : a member
-        b : a member
-        
-        Returns
-        -------
-        r : int
-            path length r of a and b
-        
-        """
-        
-        
-        
-        return r
-        
-        
+    
     def digitize_relationship(
-        self,
-        X,
-    ):
-        """This function print out Dataframe that every path length of the data mapped.
-           It's meaningful to digitize relationship.
-        
+            self,
+            graph,
+        ):
+        """Let members a, b each in nodes n, m. And define path length r of a and b; least number of edges that connect a, b. 
+           If a and b is connected by same node, then r is 0. And if a and b is not connected, then r is -1
+           This function print out Dataframe that every path length of the data mapped. It's meaningful to digitize relationship.
+
         Parameters
         ----------
-
-        X : Numpy Array
+        graph : Dictionary
             The data mapped
 
         Returns
@@ -945,10 +918,41 @@ def digitize_relationship(
         result : Dataframe
             every path length of the data mapped.       
         """
-        
-        
-        
-        result.index, result.columns = 
+
+        # From graph, we can obtain nodes and links
+        nodes = graph.get('nodes')
+        nodes_k = list(nodes)
+        nodes_v = list(nodes.values())
+        links = graph.get('links')
+
+        # Made array for grouping linked node
+        relative = []
+        for node in nodes_k:
+            members = nodes.get(node)
+            linked = [members]
+            other_nodes = links.get(node)
+            if not other_nodes == None:
+                for other_node in other_nodes:
+                    linked.append(nodes.get(other_node))
+            relative.append(linked)
+
+        # Using a definition of path length, obtain the value between order pairs.
+        dict = {}
+        for linked in relative:
+            core_node = linked[0]
+            for node in linked:
+                for element in itertools.product(core_node, node):
+                    dict[element] = 1
+            for element in itertools.product(core_node, core_node):
+                    dict[element] = 0
+
+        # Creating dataframe. Note we use the data index for index, columns of result.  
+        result = pd.Series(dict).unstack()
+        result = pd.DataFrame(result)
+        result.index, result.columns = Data.index, Data.index
+
+        # 'Nan' mean the order pairs be unrelated; path length is -1.
+        result.fillna(-1)
         return result
             
             

From 1efed32e5fb28524e319573d59da9e81a8ee2949 Mon Sep 17 00:00:00 2001
From: Kiyuob Jung <50209510+wjdrlduq1234@users.noreply.github.com>
Date: Mon, 15 Jul 2019 22:18:09 +0900
Subject: [PATCH 04/19] prevention of confusion

prevention of confusion
# It has to be solved how to obtaion path length more than 2...
---
 kmapper/kmapper.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/kmapper/kmapper.py b/kmapper/kmapper.py
index 00951887..bd83d92d 100644
--- a/kmapper/kmapper.py
+++ b/kmapper/kmapper.py
@@ -945,7 +945,9 @@ def digitize_relationship(
                     dict[element] = 1
             for element in itertools.product(core_node, core_node):
                     dict[element] = 0
-
+        
+        # It has to be solved how to obtaion path length more than 2...
+        
         # Creating dataframe. Note we use the data index for index, columns of result.  
         result = pd.Series(dict).unstack()
         result = pd.DataFrame(result)

From b9accec2b937d39017f7b25b8eb531b775a98098 Mon Sep 17 00:00:00 2001
From: Kiyuob Jung <50209510+wjdrlduq1234@users.noreply.github.com>
Date: Tue, 16 Jul 2019 16:16:06 +0900
Subject: [PATCH 05/19] final code; digitize_relationship

---
 kmapper/kmapper.py | 118 ++++++++++++++++++++++++---------------------
 1 file changed, 62 insertions(+), 56 deletions(-)

diff --git a/kmapper/kmapper.py b/kmapper/kmapper.py
index bd83d92d..fa43a03d 100644
--- a/kmapper/kmapper.py
+++ b/kmapper/kmapper.py
@@ -7,6 +7,7 @@
 import os
 import sys
 import warnings
+import networkx as nx
 
 from jinja2 import Environment, FileSystemLoader, Template
 import numpy as np
@@ -901,61 +902,66 @@ def blend(X_blend, pred_fun, folder, X_data, y):
     
     
     def digitize_relationship(
-            self,
-            graph,
-        ):
-        """Let members a, b each in nodes n, m. And define path length r of a and b; least number of edges that connect a, b. 
-           If a and b is connected by same node, then r is 0. And if a and b is not connected, then r is -1
-           This function print out Dataframe that every path length of the data mapped. It's meaningful to digitize relationship.
-
-        Parameters
-        ----------
-        graph : Dictionary
-            The data mapped
+        self,
+        graph,
+        index,
+    ):
+    """Let members a, b each in nodes n, m. And define path length r of a and b; least number of edges that connect a, b. 
+       If a and b is connected by same node, then r is 0. And if a and b is not connected, then r is -1
+       This function print out Dataframe that every path length of the data mapped. It's meaningful to digitize relationship.
+        
+    Parameters
+    ----------
+    graph : Dictionary
+        The data mapped
+    index : list
+        Index of the data 
+    
+    Returns
+    -------
+    result : Dataframe
+        every path length of the data mapped.      
+     
+    """
 
-        Returns
-        -------
-        result : Dataframe
-            every path length of the data mapped.       
-        """
+    # From graph, we can obtain nodes and links
+    nodes = graph.get('nodes')
+    nodes_k = list(nodes)
+    nodes_v = list(nodes.values())
+    links = graph.get('links')
+    
+    # Made array for grouping linked node
+    relative = []
+    for node in nodes_k:
+        members = nodes.get(node)
+        linked = [members]
+        other_nodes = links.get(node)
+        if not other_nodes == None:
+            for other_node in other_nodes:
+                linked.append(nodes.get(other_node))
+        relative.append(linked)
+    
+    # Creating graph for using networkx module
+    G = nx.Graph()
+    for node in nodes_v:
+        nx.add_path(G, node)
+    
+    # Using a definition of path length, obtain the value between order pairs.
+    dict = {}
+    for member in range(len(index)):
+        for other_member in range(len(index)):
+            try:
+                dict[(member, other_member)] = nx.shortest_path_length(G, 
+                                                                       source=member, 
+                                                                       target=other_member, 
+                                                                       method='dijkstra')
+            except (nx.NetworkXNoPath):
+                dict[(member, other_member)] = -1
+                    
+    # Creating dataframe. Note we use the data index for index, columns of result.  
+    result = pd.Series(dict).unstack()
+    result = pd.DataFrame(result)
+    result.index, result.columns = index, index
+
+    return result
 
-        # From graph, we can obtain nodes and links
-        nodes = graph.get('nodes')
-        nodes_k = list(nodes)
-        nodes_v = list(nodes.values())
-        links = graph.get('links')
-
-        # Made array for grouping linked node
-        relative = []
-        for node in nodes_k:
-            members = nodes.get(node)
-            linked = [members]
-            other_nodes = links.get(node)
-            if not other_nodes == None:
-                for other_node in other_nodes:
-                    linked.append(nodes.get(other_node))
-            relative.append(linked)
-
-        # Using a definition of path length, obtain the value between order pairs.
-        dict = {}
-        for linked in relative:
-            core_node = linked[0]
-            for node in linked:
-                for element in itertools.product(core_node, node):
-                    dict[element] = 1
-            for element in itertools.product(core_node, core_node):
-                    dict[element] = 0
-        
-        # It has to be solved how to obtaion path length more than 2...
-        
-        # Creating dataframe. Note we use the data index for index, columns of result.  
-        result = pd.Series(dict).unstack()
-        result = pd.DataFrame(result)
-        result.index, result.columns = Data.index, Data.index
-
-        # 'Nan' mean the order pairs be unrelated; path length is -1.
-        result.fillna(-1)
-        return result
-            
-            
-            

From 3adf4006d4a3a7b7742fe6cec01fabb3a0134761 Mon Sep 17 00:00:00 2001
From: Kiyuob Jung <50209510+wjdrlduq1234@users.noreply.github.com>
Date: Tue, 16 Jul 2019 16:54:49 +0900
Subject: [PATCH 06/19] Consider members in same node

---
 kmapper/kmapper.py | 129 ++++++++++++++++++++++++---------------------
 1 file changed, 68 insertions(+), 61 deletions(-)

diff --git a/kmapper/kmapper.py b/kmapper/kmapper.py
index fa43a03d..4943ede1 100644
--- a/kmapper/kmapper.py
+++ b/kmapper/kmapper.py
@@ -8,6 +8,7 @@
 import sys
 import warnings
 import networkx as nx
+import itertools
 
 from jinja2 import Environment, FileSystemLoader, Template
 import numpy as np
@@ -902,66 +903,72 @@ def blend(X_blend, pred_fun, folder, X_data, y):
     
     
     def digitize_relationship(
-        self,
-        graph,
-        index,
-    ):
-    """Let members a, b each in nodes n, m. And define path length r of a and b; least number of edges that connect a, b. 
-       If a and b is connected by same node, then r is 0. And if a and b is not connected, then r is -1
-       This function print out Dataframe that every path length of the data mapped. It's meaningful to digitize relationship.
-        
-    Parameters
-    ----------
-    graph : Dictionary
-        The data mapped
-    index : list
-        Index of the data 
-    
-    Returns
-    -------
-    result : Dataframe
-        every path length of the data mapped.      
-     
-    """
+            self,
+            graph,
+            index,
+        ):
+        """Let members a, b each in nodes n, m. And define path length r of a and b; least number of edges that connect a, b. 
+           If a and b is connected by same node, then r is 0. And if a and b is not connected, then r is -1
+           This function print out Dataframe that every path length of the data mapped. It's meaningful to digitize relationship.
 
-    # From graph, we can obtain nodes and links
-    nodes = graph.get('nodes')
-    nodes_k = list(nodes)
-    nodes_v = list(nodes.values())
-    links = graph.get('links')
-    
-    # Made array for grouping linked node
-    relative = []
-    for node in nodes_k:
-        members = nodes.get(node)
-        linked = [members]
-        other_nodes = links.get(node)
-        if not other_nodes == None:
-            for other_node in other_nodes:
-                linked.append(nodes.get(other_node))
-        relative.append(linked)
-    
-    # Creating graph for using networkx module
-    G = nx.Graph()
-    for node in nodes_v:
-        nx.add_path(G, node)
-    
-    # Using a definition of path length, obtain the value between order pairs.
-    dict = {}
-    for member in range(len(index)):
-        for other_member in range(len(index)):
-            try:
-                dict[(member, other_member)] = nx.shortest_path_length(G, 
-                                                                       source=member, 
-                                                                       target=other_member, 
-                                                                       method='dijkstra')
-            except (nx.NetworkXNoPath):
-                dict[(member, other_member)] = -1
-                    
-    # Creating dataframe. Note we use the data index for index, columns of result.  
-    result = pd.Series(dict).unstack()
-    result = pd.DataFrame(result)
-    result.index, result.columns = index, index
-
-    return result
+        Parameters
+        ----------
+        graph : Dictionary
+            The data mapped
+        index : list
+            Index of the data 
+
+        Returns
+        -------
+        result : Dataframe
+            every path length of the data mapped.      
+
+        """
+
+        # From graph, we can obtain nodes and links
+        nodes = graph.get('nodes')
+        nodes_k = list(nodes)
+        nodes_v = list(nodes.values())
+        links = graph.get('links')
+
+        # Made array for grouping linked node
+        relative = []
+        for node in nodes_k:
+            members = nodes.get(node)
+            linked = [members]
+            other_nodes = links.get(node)
+            if not other_nodes == None:
+                for other_node in other_nodes:
+                    linked.append(nodes.get(other_node))
+            relative.append(linked)
+
+        # Creating graph for using networkx module
+        G = nx.Graph()
+        for node in nodes_v:
+            nx.add_path(G, node)
+
+        # Using a definition of path length, obtain the value between order pairs.
+        dict = {}
+        for member in range(len(index)):
+            for other_member in range(len(index)):
+                try:
+                    dict[(member, other_member)] = int(nx.shortest_path_length(G, 
+                                                                           source=member, 
+                                                                           target=other_member, 
+                                                                           method='dijkstra')) - 1
+                except (nx.NetworkXNoPath):
+                    dict[(member, other_member)] = -1
+
+        # Consider members in same node
+        for linked in relative:
+            core_node = linked[0]
+            for element in itertools.product(core_node, core_node):
+                    dict[element] = 0
+
+        # Creating dataframe. Note we use the data index for index, columns of result.  
+        result = pd.Series(dict).unstack()
+        result = pd.DataFrame(result)
+        result.index, result.columns = index, index
+
+        return result
 

From 1b4c8bc64a83a0f798af6347c470b31c3a793a10 Mon Sep 17 00:00:00 2001
From: Kiyuob Jung <50209510+wjdrlduq1234@users.noreply.github.com>
Date: Tue, 16 Jul 2019 16:55:57 +0900
Subject: [PATCH 07/19] intend

---
 kmapper/kmapper.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/kmapper/kmapper.py b/kmapper/kmapper.py
index 4943ede1..b7951e8d 100644
--- a/kmapper/kmapper.py
+++ b/kmapper/kmapper.py
@@ -953,9 +953,9 @@ def digitize_relationship(
             for other_member in range(len(index)):
                 try:
                     dict[(member, other_member)] = int(nx.shortest_path_length(G, 
-                                                                           source=member, 
-                                                                           target=other_member, 
-                                                                           method='dijkstra')) - 1
+                                                                               source=member, 
+                                                                               target=other_member, 
+                                                                               method='dijkstra')) - 1
                 except (nx.NetworkXNoPath):
                     dict[(member, other_member)] = -1
 

From 5b0e17b0ba269b668217e6ef1f1e0612bbdbc741 Mon Sep 17 00:00:00 2001
From: Kiyuob Jung <50209510+wjdrlduq1234@users.noreply.github.com>
Date: Tue, 16 Jul 2019 17:05:31 +0900
Subject: [PATCH 08/19] delete  core_node = linked[0]

---
 kmapper/kmapper.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/kmapper/kmapper.py b/kmapper/kmapper.py
index b7951e8d..1e0d5f74 100644
--- a/kmapper/kmapper.py
+++ b/kmapper/kmapper.py
@@ -961,8 +961,7 @@ def digitize_relationship(
 
         # Consider members in same node
         for linked in relative:
-            core_node = linked[0]
-            for element in itertools.product(core_node, core_node):
+            for element in itertools.product(linked[0], linked[0]):
                     dict[element] = 0
 
         # Creating dataframe. Note we use the data index for index, columns of result.  

From 250f5127dfecfe96a1f18f3bf026d0bf162307b2 Mon Sep 17 00:00:00 2001
From: Kiyuob Jung <50209510+wjdrlduq1234@users.noreply.github.com>
Date: Tue, 16 Jul 2019 17:06:06 +0900
Subject: [PATCH 09/19] intend

---
 kmapper/kmapper.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/kmapper/kmapper.py b/kmapper/kmapper.py
index 1e0d5f74..2bfe8ca5 100644
--- a/kmapper/kmapper.py
+++ b/kmapper/kmapper.py
@@ -962,7 +962,7 @@ def digitize_relationship(
         # Consider members in same node
         for linked in relative:
             for element in itertools.product(linked[0], linked[0]):
-                    dict[element] = 0
+                dict[element] = 0
 
         # Creating dataframe. Note we use the data index for index, columns of result.  
         result = pd.Series(dict).unstack()

From 843518d1ca3ad887972ebe61b1844548750757b6 Mon Sep 17 00:00:00 2001
From: Kiyuob Jung <50209510+wjdrlduq1234@users.noreply.github.com>
Date: Tue, 16 Jul 2019 18:51:18 +0900
Subject: [PATCH 10/19] delete ,

---
 kmapper/kmapper.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/kmapper/kmapper.py b/kmapper/kmapper.py
index 2bfe8ca5..e8584727 100644
--- a/kmapper/kmapper.py
+++ b/kmapper/kmapper.py
@@ -905,7 +905,7 @@ def blend(X_blend, pred_fun, folder, X_data, y):
     def digitize_relationship(
             self,
             graph,
-            index,
+            index
         ):
         """Let members a, b each in nodes n, m. And define path length r of a and b; least number of edges that connect a, b. 
            If a and b is connected by same node, then r is 0. And if a and b is not connected, then r is -1

From f5e94d0066a53f69617c842291a08ab55b832e13 Mon Sep 17 00:00:00 2001
From: Kiyuob Jung <50209510+wjdrlduq1234@users.noreply.github.com>
Date: Tue, 16 Jul 2019 18:57:45 +0900
Subject: [PATCH 11/19] import pandas

---
 kmapper/kmapper.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/kmapper/kmapper.py b/kmapper/kmapper.py
index e8584727..264a9343 100644
--- a/kmapper/kmapper.py
+++ b/kmapper/kmapper.py
@@ -9,6 +9,7 @@
 import warnings
 import networkx as nx
 import itertools
+import pandas as pd
 
 from jinja2 import Environment, FileSystemLoader, Template
 import numpy as np

From 871750d838611a984d1610d42d3c48eae15fc596 Mon Sep 17 00:00:00 2001
From: Kiyuob Jung <50209510+wjdrlduq1234@users.noreply.github.com>
Date: Tue, 16 Jul 2019 19:00:21 +0900
Subject: [PATCH 12/19] fix problem

---
 kmapper/kmapper.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/kmapper/kmapper.py b/kmapper/kmapper.py
index 264a9343..7c683b7c 100644
--- a/kmapper/kmapper.py
+++ b/kmapper/kmapper.py
@@ -902,7 +902,6 @@ def blend(X_blend, pred_fun, folder, X_data, y):
 
         return X
     
-    
     def digitize_relationship(
             self,
             graph,

From 169edc0aca58459996c23a779f2b45aee890c867 Mon Sep 17 00:00:00 2001
From: Kiyuob Jung <50209510+wjdrlduq1234@users.noreply.github.com>
Date: Tue, 16 Jul 2019 19:33:45 +0900
Subject: [PATCH 13/19] Is problem from 'self'?

---
 kmapper/kmapper.py | 10 ++--------
 1 file changed, 2 insertions(+), 8 deletions(-)

diff --git a/kmapper/kmapper.py b/kmapper/kmapper.py
index 7c683b7c..25e015a2 100644
--- a/kmapper/kmapper.py
+++ b/kmapper/kmapper.py
@@ -902,11 +902,7 @@ def blend(X_blend, pred_fun, folder, X_data, y):
 
         return X
     
-    def digitize_relationship(
-            self,
-            graph,
-            index
-        ):
+    def digitize_relationship(graph, index):
         """Let members a, b each in nodes n, m. And define path length r of a and b; least number of edges that connect a, b. 
            If a and b is connected by same node, then r is 0. And if a and b is not connected, then r is -1
            This function print out Dataframe that every path length of the data mapped. It's meaningful to digitize relationship.
@@ -916,7 +912,7 @@ def digitize_relationship(
         graph : Dictionary
             The data mapped
         index : list
-            Index of the data 
+            Index of original data 
 
         Returns
         -------
@@ -924,7 +920,6 @@ def digitize_relationship(
             every path length of the data mapped.      
 
         """
-
         # From graph, we can obtain nodes and links
         nodes = graph.get('nodes')
         nodes_k = list(nodes)
@@ -968,6 +963,5 @@ def digitize_relationship(
         result = pd.Series(dict).unstack()
         result = pd.DataFrame(result)
         result.index, result.columns = index, index
-
         return result
 

From 2bcb940cd531ce2789b845509b6a16be9129f570 Mon Sep 17 00:00:00 2001
From: Kiyuob Jung <50209510+wjdrlduq1234@users.noreply.github.com>
Date: Tue, 16 Jul 2019 19:40:39 +0900
Subject: [PATCH 14/19] add 'self'

---
 kmapper/kmapper.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/kmapper/kmapper.py b/kmapper/kmapper.py
index 25e015a2..9ec789a8 100644
--- a/kmapper/kmapper.py
+++ b/kmapper/kmapper.py
@@ -902,7 +902,7 @@ def blend(X_blend, pred_fun, folder, X_data, y):
 
         return X
     
-    def digitize_relationship(graph, index):
+    def digitize_relationship(self, graph, index):
         """Let members a, b each in nodes n, m. And define path length r of a and b; least number of edges that connect a, b. 
            If a and b is connected by same node, then r is 0. And if a and b is not connected, then r is -1
            This function print out Dataframe that every path length of the data mapped. It's meaningful to digitize relationship.

From d1d7c2f5c2dabdacdb622b9dd37925dc87b96e5e Mon Sep 17 00:00:00 2001
From: Kiyuob Jung <50209510+wjdrlduq1234@users.noreply.github.com>
Date: Wed, 17 Jul 2019 03:12:31 +0900
Subject: [PATCH 15/19] weight lightening

I deleted a few 'for phrases'.
---
 kmapper/kmapper.py | 25 ++++++++++++-------------
 1 file changed, 12 insertions(+), 13 deletions(-)

diff --git a/kmapper/kmapper.py b/kmapper/kmapper.py
index 9ec789a8..fcd1ce45 100644
--- a/kmapper/kmapper.py
+++ b/kmapper/kmapper.py
@@ -943,25 +943,24 @@ def digitize_relationship(self, graph, index):
             nx.add_path(G, node)
 
         # Using a definition of path length, obtain the value between order pairs.
-        dict = {}
+        result = {}
         for member in range(len(index)):
             for other_member in range(len(index)):
                 try:
-                    dict[(member, other_member)] = int(nx.shortest_path_length(G, 
-                                                                               source=member, 
-                                                                               target=other_member, 
-                                                                               method='dijkstra')) - 1
+                    if member == other_member:
+                        result[(member, other_member)] = 0
+                    else:
+                        result[(member, other_member)] = int(nx.shortest_path_length(G, 
+                                                                                     source=member, 
+                                                                                     target=other_member, 
+                                                                                     method='dijkstra')) - 1
                 except (nx.NetworkXNoPath):
-                    dict[(member, other_member)] = -1
-
-        # Consider members in same node
-        for linked in relative:
-            for element in itertools.product(linked[0], linked[0]):
-                dict[element] = 0
+                    pass
 
         # Creating dataframe. Note we use the data index for index, columns of result.  
-        result = pd.Series(dict).unstack()
-        result = pd.DataFrame(result)
+        result = pd.Series(result).unstack()
+        result = pd.DataFrame(result).fillna(-1)    # Nan means no relationship.
         result.index, result.columns = index, index
+
         return result
 

From bcc64ec1f63fa22d24085e78576d2a1b40668fed Mon Sep 17 00:00:00 2001
From: Kiyuob Jung <50209510+wjdrlduq1234@users.noreply.github.com>
Date: Wed, 17 Jul 2019 03:18:09 +0900
Subject: [PATCH 16/19] weight lightening

I deleted the unnecessary instructions.
---
 kmapper/kmapper.py | 20 +-------------------
 1 file changed, 1 insertion(+), 19 deletions(-)

diff --git a/kmapper/kmapper.py b/kmapper/kmapper.py
index fcd1ce45..1cdcb309 100644
--- a/kmapper/kmapper.py
+++ b/kmapper/kmapper.py
@@ -8,7 +8,6 @@
 import sys
 import warnings
 import networkx as nx
-import itertools
 import pandas as pd
 
 from jinja2 import Environment, FileSystemLoader, Template
@@ -920,26 +919,9 @@ def digitize_relationship(self, graph, index):
             every path length of the data mapped.      
 
         """
-        # From graph, we can obtain nodes and links
-        nodes = graph.get('nodes')
-        nodes_k = list(nodes)
-        nodes_v = list(nodes.values())
-        links = graph.get('links')
-
-        # Made array for grouping linked node
-        relative = []
-        for node in nodes_k:
-            members = nodes.get(node)
-            linked = [members]
-            other_nodes = links.get(node)
-            if not other_nodes == None:
-                for other_node in other_nodes:
-                    linked.append(nodes.get(other_node))
-            relative.append(linked)
-
         # Creating graph for using networkx module
         G = nx.Graph()
-        for node in nodes_v:
+        for node in list(graph.get('nodes').values()):
             nx.add_path(G, node)
 
         # Using a definition of path length, obtain the value between order pairs.

From 561df44a2b9c7b09fb6abedd26985b1142f59ab3 Mon Sep 17 00:00:00 2001
From: Kiyuob Jung <50209510+wjdrlduq1234@users.noreply.github.com>
Date: Tue, 23 Jul 2019 01:23:49 +0900
Subject: [PATCH 17/19] example

example
---
 kmapper/kmapper.py | 22 ++++++++++++++++++++--
 1 file changed, 20 insertions(+), 2 deletions(-)

diff --git a/kmapper/kmapper.py b/kmapper/kmapper.py
index 1cdcb309..2ae78b9f 100644
--- a/kmapper/kmapper.py
+++ b/kmapper/kmapper.py
@@ -904,7 +904,7 @@ def blend(X_blend, pred_fun, folder, X_data, y):
     def digitize_relationship(self, graph, index):
         """Let members a, b each in nodes n, m. And define path length r of a and b; least number of edges that connect a, b. 
            If a and b is connected by same node, then r is 0. And if a and b is not connected, then r is -1
-           This function print out Dataframe that every path length of the data mapped. It's meaningful to digitize relationship.
+           This function print out Dataframe that every path length of the data mapped. 
 
         Parameters
         ----------
@@ -917,7 +917,25 @@ def digitize_relationship(self, graph, index):
         -------
         result : Dataframe
             every path length of the data mapped.      
-
+            
+        Examples
+        --------
+        >>> from sklearn.datasets import load_iris
+        >>> import kmapper as km
+        >>> # Data setting
+        >>> inverse_data = load_iris().get('data')
+        >>> index = []
+        >>> for name in load_iris().get('target_names'):
+        >>>     for x in range(50):
+        >>>        y = '%s_%s' % (name, x)
+        >>>        index.append(y)
+        >>> # creating graph
+        >>> mapper = km.KeplerMapper(verbose=0)
+        >>> projected_data = mapper.project(inverse_data, projection="knn_distance_2", distance_matrix='euclidean')
+        >>> graph = mapper.map(projected_data, cover=km.Cover(n_cubes=3, perc_overlap=0.2))
+        >>> # digitize_relationship
+        >>> km.digitize_relationship(graph, index)
+        
         """
         # Creating graph for using networkx module
         G = nx.Graph()

From 4d0459cc93c7bdd7e179bc2c517c89b21579684e Mon Sep 17 00:00:00 2001
From: Kiyuob Jung <50209510+wjdrlduq1234@users.noreply.github.com>
Date: Tue, 23 Jul 2019 01:25:35 +0900
Subject: [PATCH 18/19] example

---
 kmapper/kmapper.py | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/kmapper/kmapper.py b/kmapper/kmapper.py
index 2ae78b9f..879fd080 100644
--- a/kmapper/kmapper.py
+++ b/kmapper/kmapper.py
@@ -922,6 +922,7 @@ def digitize_relationship(self, graph, index):
         --------
         >>> from sklearn.datasets import load_iris
         >>> import kmapper as km
+        >>> 
         >>> # Data setting
         >>> inverse_data = load_iris().get('data')
         >>> index = []
@@ -929,10 +930,12 @@ def digitize_relationship(self, graph, index):
         >>>     for x in range(50):
         >>>        y = '%s_%s' % (name, x)
         >>>        index.append(y)
+        >>> 
         >>> # creating graph
         >>> mapper = km.KeplerMapper(verbose=0)
         >>> projected_data = mapper.project(inverse_data, projection="knn_distance_2", distance_matrix='euclidean')
         >>> graph = mapper.map(projected_data, cover=km.Cover(n_cubes=3, perc_overlap=0.2))
+        >>> 
         >>> # digitize_relationship
         >>> km.digitize_relationship(graph, index)
         

From 08150592d55980fb05d2c613b497348299f98f75 Mon Sep 17 00:00:00 2001
From: Kiyuob Jung <50209510+wjdrlduq1234@users.noreply.github.com>
Date: Tue, 23 Jul 2019 04:22:21 +0900
Subject: [PATCH 19/19] Override Graphs to Apply Algorithms

---
 kmapper/kmapper.py | 22 ++++++++++++++++++----
 1 file changed, 18 insertions(+), 4 deletions(-)

diff --git a/kmapper/kmapper.py b/kmapper/kmapper.py
index 879fd080..ec0d2918 100644
--- a/kmapper/kmapper.py
+++ b/kmapper/kmapper.py
@@ -940,10 +940,24 @@ def digitize_relationship(self, graph, index):
         >>> km.digitize_relationship(graph, index)
         
         """
-        # Creating graph for using networkx module
-        G = nx.Graph()
-        for node in list(graph.get('nodes').values()):
-            nx.add_path(G, node)
+        # Obtain information of node from graph; output from the `map` method.
+        nodes = graph.get('nodes')
+        nodes_k = list(nodes)
+        nodes_v = list(nodes.values())
+
+
+        # Creating MultiGraph for using networkx module
+        G = nx.MultiGraph()
+        for x in range(len(nodes_k)):
+            G.add_node(tuple(nodes_v[x]), nodes=nodes_k[x])
+
+        # Adding path between nodes
+        for node in nodes_k:
+            members = tuple(nodes.get(node))
+            other_nodes = links.get(node)
+            if not other_nodes == None:
+                for other_node in other_nodes:
+                    nx.add_path(G, [members, tuple(nodes.get(other_node))])
 
         # Using a definition of path length, obtain the value between order pairs.
         result = {}