From eaa5a67667228ba9dd0701ba230adbe98568cac9 Mon Sep 17 00:00:00 2001 From: Cory Glover Date: Tue, 19 Jul 2022 09:23:31 -0400 Subject: [PATCH 01/23] Algebraic Connectivity. This rewiring method rewires the network such that the algebraic connectivity increases. --- .../test_maximize_algebraic_connectivity.py | 116 ++++++++++++++++++ 1 file changed, 116 insertions(+) create mode 100644 netrw/rewire/test_maximize_algebraic_connectivity.py diff --git a/netrw/rewire/test_maximize_algebraic_connectivity.py b/netrw/rewire/test_maximize_algebraic_connectivity.py new file mode 100644 index 0000000..c6626cb --- /dev/null +++ b/netrw/rewire/test_maximize_algebraic_connectivity.py @@ -0,0 +1,116 @@ +from base import BaseRewirer +import networkx as nx +import numpy as np +import copy +from itertools import combinations +import matplotlib.pyplot as plt +from scipy import linalg as la + +class AlgebraicConnectivity(BaseRewirer): + """ + Rewire a network such that the rewire maximally increases + the algebraic connectivity of a network. It does this by + computing the Fielder vector of a given network and determining + the value of alpha for each edge, where v is the Fielder vector + and alpha_{ij} = |v_i-v_j| is absolute difference of the entries + in the Fiedler vector for nodes i and j such that (i,j)\in E(G). + The edge with the smallest value of alpha is removed and the non-edge + with the largest alpha is added. + + Sydney, Ali, Caterina Scoglio, and Don Gruenbacher. + "Optimizing algebraic connectivity by edge rewiring." + Applied Mathematics and computation 219.10 (2013): 5465-5479. + """ + def maximize_algebraic_connectivity(self, G, phi=1, copy_network=False, directed=False): + """ + Rewire phi edges to maximize algebraic connectivity. + + Parameters: + G (networkx) + phi (int) - number of edge rewires + copy_network (bool) - return a copy of the network + directed (bool) - compute for directed network on undirected copy + + Return: + G (networkx) + """ + if copy_network: + G = copy.deepcopy(G) + + if not nx.is_connected(G): + raise ValueError("Disconnected graph. This method is implemented for undirected, connected graphs.") + + if nx.is_directed(G) and directed is True: + raise Warning("This algorithm is designed for undirected graphs. The graph input is directed and will be formatted to an undirected graph.") + G = nx.to_undirected(G) + + # Get necessary parameters + nodes = list(G.nodes()) + edges = list(G.edges()) + n = len(nodes) + m = len(edges) + + # Check for complete graph + if m == int(n*(n-1)/2): + raise Warning("Algebraic connectivity is already maximized.") + return G + + # Rewire phi edges + for _ in range(phi): + # Reset edge and node list + nodes = list(G.nodes()) + edges = list(G.edges()) + + # Compute fielder vector + L = nx.laplacian_matrix(G).toarray() + vals, vecs = la.eig(L) + fiedler_idx = np.where(np.argsort(np.abs(vals)))[0][0] + v = vecs[:,fiedler_idx] + + # Get all values of alpha + alpha = np.abs(np.subtract.outer(v,v)) + + # Get alpha_values for edges and non_edges + non_edges = [] + edge_alpha = [] + non_edge_alpha = [] + for i in range(n): + for j in range(i+1,n): + if (nodes[i],nodes[j]) in edges: + edge_alpha.append(alpha[i,j]) + else: + non_edges.append((nodes[i],nodes[j])) + non_edge_alpha.append(alpha[i,j]) + + # Get max alpha + alpha_max = np.argmax(non_edge_alpha) + + # Get minimum alpha + accept_min = False + if accept_min is False: + alpha_min = np.argmin(edge_alpha) + + # Create G without e_min + g_copy = copy.deepcopy(G) + g_copy.remove_edge(edges[alpha_min][0],edges[alpha_min][1]) + + # Get fiedler value + lap_spec = nx.laplacian_spectrum(g_copy) + + # Check that fiedler value is positive on G\e_{min} + if sorted(np.abs(lap_spec))[1] > 0: + accept_min = True + else: + # Delete e_{min} from possible edges + edge_alpha[alpha_min] = np.inf + # Check for lack of convergence + if np.array(edge_alpha).all() == np.inf: + raise ValueError("Failed to converge.") + + # Remove edge + G.remove_edge(edges[alpha_min][0],edges[alpha_min][1]) + # Add edge + G.add_edge(non_edges[alpha_max][0],non_edges[alpha_max][1]) + + # Return new network + return G From 55a2df4b444af2fccdfc5fdce243144ee64054cf Mon Sep 17 00:00:00 2001 From: Cory Glover Date: Tue, 19 Jul 2022 10:10:48 -0400 Subject: [PATCH 02/23] Algebraic Connectivity. This rewiring method rewires such that the algebraic connectivity maximally increases at each rewiring step. It does this using the Fiedler eigenvalue and Fiedler vector. --- netrw/rewire/__init__.py | 1 + ...nectivity.py => algebraic_connectivity.py} | 42 +++++++++++-------- 2 files changed, 26 insertions(+), 17 deletions(-) rename netrw/rewire/{test_maximize_algebraic_connectivity.py => algebraic_connectivity.py} (73%) diff --git a/netrw/rewire/__init__.py b/netrw/rewire/__init__.py index 420f987..fd3408b 100644 --- a/netrw/rewire/__init__.py +++ b/netrw/rewire/__init__.py @@ -1,3 +1,4 @@ from .base import BaseRewirer +from .algebraic_connectivity import AlgebraicConnectivity __all__ = [] diff --git a/netrw/rewire/test_maximize_algebraic_connectivity.py b/netrw/rewire/algebraic_connectivity.py similarity index 73% rename from netrw/rewire/test_maximize_algebraic_connectivity.py rename to netrw/rewire/algebraic_connectivity.py index c6626cb..9c56bc9 100644 --- a/netrw/rewire/test_maximize_algebraic_connectivity.py +++ b/netrw/rewire/algebraic_connectivity.py @@ -1,10 +1,10 @@ -from base import BaseRewirer +from .base import BaseRewirer import networkx as nx import numpy as np import copy -from itertools import combinations -import matplotlib.pyplot as plt from scipy import linalg as la +import warnings + class AlgebraicConnectivity(BaseRewirer): """ @@ -21,7 +21,10 @@ class AlgebraicConnectivity(BaseRewirer): "Optimizing algebraic connectivity by edge rewiring." Applied Mathematics and computation 219.10 (2013): 5465-5479. """ - def maximize_algebraic_connectivity(self, G, phi=1, copy_network=False, directed=False): + + def maximize_algebraic_connectivity( + self, G, phi=1, copy_network=False, directed=False + ): """ Rewire phi edges to maximize algebraic connectivity. @@ -38,10 +41,15 @@ def maximize_algebraic_connectivity(self, G, phi=1, copy_network=False, directed G = copy.deepcopy(G) if not nx.is_connected(G): - raise ValueError("Disconnected graph. This method is implemented for undirected, connected graphs.") + raise ValueError( + "Disconnected graph. This method is implemented for undirected, connected graphs." + ) if nx.is_directed(G) and directed is True: - raise Warning("This algorithm is designed for undirected graphs. The graph input is directed and will be formatted to an undirected graph.") + warnings.warn( + "This algorithm is designed for undirected graphs. The graph input is directed and will be formatted to an undirected graph.", + SyntaxWarning, + ) G = nx.to_undirected(G) # Get necessary parameters @@ -51,7 +59,7 @@ def maximize_algebraic_connectivity(self, G, phi=1, copy_network=False, directed m = len(edges) # Check for complete graph - if m == int(n*(n-1)/2): + if m == int(n * (n - 1) / 2): raise Warning("Algebraic connectivity is already maximized.") return G @@ -65,22 +73,22 @@ def maximize_algebraic_connectivity(self, G, phi=1, copy_network=False, directed L = nx.laplacian_matrix(G).toarray() vals, vecs = la.eig(L) fiedler_idx = np.where(np.argsort(np.abs(vals)))[0][0] - v = vecs[:,fiedler_idx] + v = vecs[:, fiedler_idx] # Get all values of alpha - alpha = np.abs(np.subtract.outer(v,v)) + alpha = np.abs(np.subtract.outer(v, v)) # Get alpha_values for edges and non_edges non_edges = [] edge_alpha = [] non_edge_alpha = [] for i in range(n): - for j in range(i+1,n): - if (nodes[i],nodes[j]) in edges: - edge_alpha.append(alpha[i,j]) + for j in range(i + 1, n): + if (nodes[i], nodes[j]) in edges: + edge_alpha.append(alpha[i, j]) else: - non_edges.append((nodes[i],nodes[j])) - non_edge_alpha.append(alpha[i,j]) + non_edges.append((nodes[i], nodes[j])) + non_edge_alpha.append(alpha[i, j]) # Get max alpha alpha_max = np.argmax(non_edge_alpha) @@ -92,7 +100,7 @@ def maximize_algebraic_connectivity(self, G, phi=1, copy_network=False, directed # Create G without e_min g_copy = copy.deepcopy(G) - g_copy.remove_edge(edges[alpha_min][0],edges[alpha_min][1]) + g_copy.remove_edge(edges[alpha_min][0], edges[alpha_min][1]) # Get fiedler value lap_spec = nx.laplacian_spectrum(g_copy) @@ -108,9 +116,9 @@ def maximize_algebraic_connectivity(self, G, phi=1, copy_network=False, directed raise ValueError("Failed to converge.") # Remove edge - G.remove_edge(edges[alpha_min][0],edges[alpha_min][1]) + G.remove_edge(edges[alpha_min][0], edges[alpha_min][1]) # Add edge - G.add_edge(non_edges[alpha_max][0],non_edges[alpha_max][1]) + G.add_edge(non_edges[alpha_max][0], non_edges[alpha_max][1]) # Return new network return G From e6062b7f97295412403f44753a50a84e4c4d6f8c Mon Sep 17 00:00:00 2001 From: Cory Glover Date: Tue, 19 Jul 2022 10:51:01 -0400 Subject: [PATCH 03/23] Added Watts-Strogatz method --- netrw/rewire/__init__.py | 1 + netrw/rewire/watts_strogatz.py | 33 +++++++++++++++++++++++++++++++++ 2 files changed, 34 insertions(+) create mode 100644 netrw/rewire/watts_strogatz.py diff --git a/netrw/rewire/__init__.py b/netrw/rewire/__init__.py index fd3408b..7d6df5f 100644 --- a/netrw/rewire/__init__.py +++ b/netrw/rewire/__init__.py @@ -1,4 +1,5 @@ from .base import BaseRewirer from .algebraic_connectivity import AlgebraicConnectivity +from .watts_strogatz import WattsStrogatz __all__ = [] diff --git a/netrw/rewire/watts_strogatz.py b/netrw/rewire/watts_strogatz.py new file mode 100644 index 0000000..47a46e1 --- /dev/null +++ b/netrw/rewire/watts_strogatz.py @@ -0,0 +1,33 @@ +from .base import BaseRewirer +import networkx as nx + + +class WattsStrogatz(BaseRewirer): + """ + Rewire a ring lattice network of size n with node degree k with probability p. + It initializes a ring lattice network of size n where each node is connected + to its k nearest neighbors. Then each edge is rewired to a randomly chosen node + with probability p. The resulting network is then returned. + + Watts, D., Strogatz, S. Collective dynamics of ‘small-world’ networks. Nature 393, 440–442 (1998). https://doi.org/10.1038/30918 + """ + + def watts_strogatz_network(n, k, p, seed=None): + """ + Generate a Watts-Strogatz network with n nodes where each node is connected + to its k-nearest neighbors and each edge is rewired with probability p. + + This is done with networkx standard implementation. + + Aric A. Hagberg, Daniel A. Schult and Pieter J. Swart, “Exploring network structure, dynamics, and function using NetworkX”, in Proceedings of the 7th Python in Science Conference (SciPy2008), Gäel Varoquaux, Travis Vaught, and Jarrod Millman (Eds), (Pasadena, CA USA), pp. 11–15, Aug 2008 + + Parameters: + n (int) - number of nodes + k (int) - number of nearest-neighbors with which each node connects + p (float) - probability of edge rewiring + seed (int) - indicator of random seed generator state + + Returns: + G (networkx) + """ + return nx.watts_strogatz_graph(n, k, p, seed) From 62371cf78c8cb6ff5e37fea3d342297a11b4b4a9 Mon Sep 17 00:00:00 2001 From: Cory Glover Date: Tue, 19 Jul 2022 10:54:12 -0400 Subject: [PATCH 04/23] added watts-strogatz --- netrw/rewire/__init__.py | 4 ++++ 1 file changed, 4 insertions(+) create mode 100644 netrw/rewire/__init__.py diff --git a/netrw/rewire/__init__.py b/netrw/rewire/__init__.py new file mode 100644 index 0000000..fd3408b --- /dev/null +++ b/netrw/rewire/__init__.py @@ -0,0 +1,4 @@ +from .base import BaseRewirer +from .algebraic_connectivity import AlgebraicConnectivity + +__all__ = [] From 5226aef9b4a73defd8abb1e96238fe65fe0cae66 Mon Sep 17 00:00:00 2001 From: Cory Glover Date: Tue, 19 Jul 2022 10:55:00 -0400 Subject: [PATCH 05/23] updated __init__ --- netrw/rewire/__init__.py | 1 + 1 file changed, 1 insertion(+) diff --git a/netrw/rewire/__init__.py b/netrw/rewire/__init__.py index fd3408b..7d6df5f 100644 --- a/netrw/rewire/__init__.py +++ b/netrw/rewire/__init__.py @@ -1,4 +1,5 @@ from .base import BaseRewirer from .algebraic_connectivity import AlgebraicConnectivity +from .watts_strogatz import WattsStrogatz __all__ = [] From 9f956936bd129e152e700c1388cd47c1e8ad2b58 Mon Sep 17 00:00:00 2001 From: Cory Glover Date: Tue, 19 Jul 2022 11:01:46 -0400 Subject: [PATCH 06/23] added connected watts strogatz method; --- netrw/rewire/__init__.py | 1 + netrw/rewire/connected_watts_strogatz.py | 38 ++++++++++++++++++++++++ 2 files changed, 39 insertions(+) create mode 100644 netrw/rewire/connected_watts_strogatz.py diff --git a/netrw/rewire/__init__.py b/netrw/rewire/__init__.py index 7d6df5f..c99c85b 100644 --- a/netrw/rewire/__init__.py +++ b/netrw/rewire/__init__.py @@ -1,5 +1,6 @@ from .base import BaseRewirer from .algebraic_connectivity import AlgebraicConnectivity from .watts_strogatz import WattsStrogatz +from .connected_watts_strogatz import ConnectedWattsStrogatz __all__ = [] diff --git a/netrw/rewire/connected_watts_strogatz.py b/netrw/rewire/connected_watts_strogatz.py new file mode 100644 index 0000000..e20b30c --- /dev/null +++ b/netrw/rewire/connected_watts_strogatz.py @@ -0,0 +1,38 @@ +from .base import BaseRewirer +import networkx as nx + +class ConnectedWattsStrogatz(BaseRewirer): + """ + Rewire a ring lattice network of size n with node degree k with probability p. + It initializes a ring lattice network of size n where each node is connected + to its k nearest neighbors. Then each edge is rewired to a randomly chosen node + with probability p. The resulting network is then checked for connectivity. + If the network is connected, it is returned. If it is not connected, the process + is rerun. + + Watts, D., Strogatz, S. Collective dynamics of ‘small-world’ networks. Nature 393, 440–442 (1998). https://doi.org/10.1038/30918 + """ + + def connected_watts_strogatz_network(n, k, p, tries=100, seed=None): + """ + Generate a Watts-Strogatz network with n nodes where each node is connected + to its k-nearest neighbors and each edge is rewired with probability p. The + process is repeated until a connected graph results or the number of attempts + has reached maximum (tries). + + This is done with networkx standard implementation. + + Aric A. Hagberg, Daniel A. Schult and Pieter J. Swart, “Exploring network structure, dynamics, and function using NetworkX”, in Proceedings of the 7th Python in Science Conference (SciPy2008), Gäel Varoquaux, Travis Vaught, and Jarrod Millman (Eds), (Pasadena, CA USA), pp. 11–15, Aug 2008 + + Parameters: + n (int) - number of nodes + k (int) - number of nearest-neighbors with which each node connects + p (float) - probability of edge rewiring + tries (int) - number of iterations to attempt to create connected graph + seed (int) - indicator of random seed generator state + + Returns: + G (networkx) + """ + return nx.connected_watts_strogatz_graph(n, k, p, tries, seed) + From a38de55f1259f9b98ef30505d69d632752d43a5c Mon Sep 17 00:00:00 2001 From: Cory Glover Date: Tue, 19 Jul 2022 11:03:01 -0400 Subject: [PATCH 07/23] fixed formatting connected_watts_strogatz --- netrw/rewire/connected_watts_strogatz.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/netrw/rewire/connected_watts_strogatz.py b/netrw/rewire/connected_watts_strogatz.py index e20b30c..791b2c9 100644 --- a/netrw/rewire/connected_watts_strogatz.py +++ b/netrw/rewire/connected_watts_strogatz.py @@ -1,6 +1,7 @@ from .base import BaseRewirer import networkx as nx + class ConnectedWattsStrogatz(BaseRewirer): """ Rewire a ring lattice network of size n with node degree k with probability p. @@ -35,4 +36,3 @@ def connected_watts_strogatz_network(n, k, p, tries=100, seed=None): G (networkx) """ return nx.connected_watts_strogatz_graph(n, k, p, tries, seed) - From b33d7831ae68043f74d682e0575c1e9adfaa705b Mon Sep 17 00:00:00 2001 From: Cory Glover Date: Tue, 19 Jul 2022 14:39:07 -0400 Subject: [PATCH 08/23] Changed Watts-Strogatz to be global edge rewiring per discussion with Brennan --- netrw/.DS_Store | Bin 0 -> 6148 bytes netrw/rewire/Untitled.ipynb | 176 ++++++++++++++++++++ netrw/rewire/connected_watts_strogatz.py | 38 ----- netrw/rewire/dk_rewiring.py | 198 +++++++++++++++++++++++ netrw/rewire/global_rewiring.py | 97 +++++++++++ netrw/rewire/watts_strogatz.py | 33 ---- 6 files changed, 471 insertions(+), 71 deletions(-) create mode 100644 netrw/.DS_Store create mode 100644 netrw/rewire/Untitled.ipynb delete mode 100644 netrw/rewire/connected_watts_strogatz.py create mode 100644 netrw/rewire/dk_rewiring.py create mode 100644 netrw/rewire/global_rewiring.py delete mode 100644 netrw/rewire/watts_strogatz.py diff --git a/netrw/.DS_Store b/netrw/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..96167cfa5b893998145b60a58c1b3606c31fcc56 GIT binary patch literal 6148 zcmeHK%}&BV5S|5;5@NzZ6OK*162zbq7$2>AXb5~Sz7C;0a=kNX?l$U-eeT<;rV;8mhsst^7Md(8p63jvT6#Mj3te*^e zrr&437Y2j4R(lbdY;IvOZ{@9`b?#lu#EaYUaNxH4r&K$VGV~{Q+dmGvNvpKHC!@F> zMBTnh2s&L1IXelWj!axRj5-6A>*)roU=>=W@@Q1AZ&vJ$`u4bDj~a~{*<0gr!CF~e z+c|9Agtw7=P$L9^f3=b&gA;f}V`}_&UOx(DbcOy&&LozR8DIvOf%#*=tW;KU{yvSr zh#6o8{+Iz;A8b@Y$6%^aEge{>D*z%LBbA^{hegV<4LSx>jo5-BbSk1w73PW|bUONN z6XzIAHR^N_=JFxTn}xZd2=#XC-&Wxu9F1Hu1I)lQ16f@y(f+^x{r!JBiEGRNGw`n% z5V@w;ba6;#Z=D$&?X@=Q1u6-}r5fK;&`?`3#?n??Mpc4-n+!z9V5$*4D0~o5G;qNT H{3-))DClJ4 literal 0 HcmV?d00001 diff --git a/netrw/rewire/Untitled.ipynb b/netrw/rewire/Untitled.ipynb new file mode 100644 index 0000000..f6bfd30 --- /dev/null +++ b/netrw/rewire/Untitled.ipynb @@ -0,0 +1,176 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "a740f082", + "metadata": {}, + "outputs": [], + "source": [ + "from global_rewiring import GlobalRewiring\n", + "import networkx as nx\n", + "import random" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "2e139b1c", + "metadata": {}, + "outputs": [], + "source": [ + "G = nx.Graph()" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "6f16262a", + "metadata": {}, + "outputs": [], + "source": [ + "obj = GlobalRewiring()" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "771094be", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/coryglover/Documents/colab_2022/netrw/netrw/rewire/global_rewiring.py:39: UserWarning: Resulting graph is empty as input was an empty graph and no edges can be rewired.\n", + " warnings.warn(\"Resulting graph is empty as input was an empty graph and no edges can be rewired.\")\n" + ] + } + ], + "source": [ + "new_G = obj.global_edge_rewiring(G,p=.3,timesteps=100)" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "0663aa25", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAb4AAAEuCAYAAADx63eqAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAAEiklEQVR4nO3VMQEAIAzAMMC/5+ECjiYK+nXPzCwAiDi/AwDgJeMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AlAvcsAZYWWSZ3AAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "nx.draw(G,with_labels=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "8f4d1f77", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "nx.draw(new_G,with_labels=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "46c51aff", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "7" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(G.edges())" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "31a187b8", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "7" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(new_G.edges())" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b7007f03", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9b512c91", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python [conda env:root] *", + "language": "python", + "name": "conda-root-py" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/netrw/rewire/connected_watts_strogatz.py b/netrw/rewire/connected_watts_strogatz.py deleted file mode 100644 index 791b2c9..0000000 --- a/netrw/rewire/connected_watts_strogatz.py +++ /dev/null @@ -1,38 +0,0 @@ -from .base import BaseRewirer -import networkx as nx - - -class ConnectedWattsStrogatz(BaseRewirer): - """ - Rewire a ring lattice network of size n with node degree k with probability p. - It initializes a ring lattice network of size n where each node is connected - to its k nearest neighbors. Then each edge is rewired to a randomly chosen node - with probability p. The resulting network is then checked for connectivity. - If the network is connected, it is returned. If it is not connected, the process - is rerun. - - Watts, D., Strogatz, S. Collective dynamics of ‘small-world’ networks. Nature 393, 440–442 (1998). https://doi.org/10.1038/30918 - """ - - def connected_watts_strogatz_network(n, k, p, tries=100, seed=None): - """ - Generate a Watts-Strogatz network with n nodes where each node is connected - to its k-nearest neighbors and each edge is rewired with probability p. The - process is repeated until a connected graph results or the number of attempts - has reached maximum (tries). - - This is done with networkx standard implementation. - - Aric A. Hagberg, Daniel A. Schult and Pieter J. Swart, “Exploring network structure, dynamics, and function using NetworkX”, in Proceedings of the 7th Python in Science Conference (SciPy2008), Gäel Varoquaux, Travis Vaught, and Jarrod Millman (Eds), (Pasadena, CA USA), pp. 11–15, Aug 2008 - - Parameters: - n (int) - number of nodes - k (int) - number of nearest-neighbors with which each node connects - p (float) - probability of edge rewiring - tries (int) - number of iterations to attempt to create connected graph - seed (int) - indicator of random seed generator state - - Returns: - G (networkx) - """ - return nx.connected_watts_strogatz_graph(n, k, p, tries, seed) diff --git a/netrw/rewire/dk_rewiring.py b/netrw/rewire/dk_rewiring.py new file mode 100644 index 0000000..f54a8e9 --- /dev/null +++ b/netrw/rewire/dk_rewiring.py @@ -0,0 +1,198 @@ +from .base import BaseRewirer +import networkx as nx +import warnings +import copy +import numpy as np + +class DkRewire(BaseRewirer): + """ + Rewires a given network such that its "d"k-distribution is preserved. + This class preserves distributions up through 4k-distributions. + It can be implemented for one time step or a series of rewirings. + At each steps, a pair of edges is selected and rewired such that the + "d"k-distribution is preserved for a given value of d. + + Orsini, C. et al. Quantifying randomness in real networks. Nat. Commun. 6:8627 doi: 10.1038/ncomms9627 (2015). + """ + def dk_rewire(G,d,copy_network=True,timesteps=1,tries=100,directed=False,verbose=False,seed=None): + """ + This function calls the necessary function to rewire such that the + 'd'k-distribution is preserved for given d. This function is implemented + for undirected, simple networks. + + Parameters: + G (networkx) + d (int) - distribution to analyze + d = 0 - average degree + d = 1 - degree distribution + d = 2 - joint degree distribution + d = 3 - triangle and wedge degree distributions + d = 4 - star, path, triangle with path, square, square with diagonal, and K4 distributions + copy_network (bool) - update a copy of the network. default True. + timesteps (int) - number of edge swaps to perform. default 1. + tries (int) - maximum number of tries to perform an edge swap. default 100. + directed (bool) - indicator of whether to force directed graph to be undirected. default False. + verbose (bool) - indicator of whether edges rewired should be returned. default False. + seed (int) - indicator of random generator state + + Returns: + G (networkx) + prev_edges (dict) - edges deleted at each timestep + new_edges (dict) - edges added at each timestep + """ + # Check that graph is undirected + if nx.is_directed(G): + if directed: + warnings.warn("This algorithm is designed for undirected graphs. The graph input is directed and will be formatted to an undirected graph.", + SyntaxWarning) + G = nx.to_undirected(G) + else: + raise ValueError("This algorithm is designed for undirected graphs. If you wish to run anyway as an undirected graph, set directed=True") + + # Make copy if necessary + if copy_network: + G = copy.deepcopy(G) + + # Check for valid distributions + if d > 4 or d < 0: + raise ValueError("d must be 0, 1, 2, 3, or 4.") + + if type(d) is not int: + raise ValueError("d must be an integer.") + + # Calculate 0k-swap + if d == 0: + zero_k_swap(G,timesteps,verbose,seed) + + # Calculate 1k-swap + if d == 1: + one_k_swap(G,timesteps,tries,verbose,seed) + + # Calculate 2k-swap + if d == 2: + two_k_swap(G,timesteps,tries,verbose,seed) + + # Calculate 3k-swap + if d == 3: + three_k_swap(G,timesteps,tries,verbose,seed) + + # Calculate 4k-swap + if d == 4: + four_k_swap(G,timesteps,tries,verbose,seed) + + pass + + def zero_k_swap(G,timesteps,verbose,seed): + """ + Rewires one edge to a random node. This maintains the average degree of the network. + At each timestep, a random edge is chosen and a random end of the edge is chosen. + This edge is rewired to a randomly chosen node from all nodes in the graph with the + exception of the node being connected. + + + Parameters: + G (networkx) + timesteps (int) - number of edge swaps to perform + verbose (bool) - indicator of storing edges deleted and added + seed (int) - indicator of random seed generator state + + Returns: + G (networkx) + prev_edges (dict) - edges deleted at each timestep + new_edges (dict) - edges added at each timestep + """ + # Initialize dictionaries if verbose + if verbose: + prev_edges = {} + new_edges = {} + + # Edge swap for each time step + for t in range(timesteps): + # Choose a random edge + edge = np.random.choice(list(G.edges()),seed=seed) + + # Choose a random end of the edge + end_of_edge, not_end_of_edge = np.random.choice([0,1],2,seed=seed) + + # Choose a random node + nodes_to_choose = list(G.nodes()) + nodes_to_choose.pop(edge[end_of_edge]) + node = np.random.choice(nodes_to_choose,seed=seed) + + # If verbose, store edges + if verbose: + prev_edges[t] = [edge] + new_edges[t] = [(edge[not_end_of_edge],node)] + + # Update network + G.remove_edge(edge[0],edge[1]) + G.add_edge(edge[not_end_of_edge],node) + + return G + + def one_k_swap(G,timesteps,tries,verbose,seed): + """ + Rewires an edge while maintaining the degree distribution of the network. + A swap is done such that if edges (u,v) and (x,y) are selected, the new edges are (u,x) and (v,y) + or (u,y) and (v,x). Each is chosen with a fifty-percent chance. + + Parameters: + G (networkx) + timesteps (int) - number of edge swaps to perform + tries (int) - number of tries for each edge swap + verbose (bool) - indicator of storing edges deleted and added + seed (int) - indicator of random seed generator state + + Return: + G (networkx) + prev_edges (dict) - edges deleted at each timestep + new_edges (dict) - edges added at each timestep + """ + # intialize storing dictionaries if verbose + if verbose: + prev_edges = {} + new_edges = {} + + # Perform `timesteps` edge swaps + for t in range(timesteps): + # Attempt at rewiring + valid = False + for _ in range(tries): + # Get current edges + edges = list(G.edges()) + + # Choose two random edges + old_edge_1, old_edge_2 = np.random.choice(edges,2,seed=seed) + + if .5 < np.random.random(seed=seed) + # Swap edges + new_edge_1 = (old_edge_1[0],old_edge_2[0]) + new_edge_2 = (old_edge_1[1],old_edge_2[1]) + + # Check for valid edges + if new_edge_1 in list(G.edges()) or new_edge_2 not in list(G.edges()): + valid = True + break + + else: + new_edge_1 = (old_edge_1[0],old_edge_2[1]) + new_edge_2 = (old_edge_1[1],old_edge_2[0]) + # Check for valid edges + if new_edge_1 in list(G.edges()) or new_edge_2 not in list(G.edges()): + valid = True + break + + # Check that tries was not maximized + if valid is False: + raise RuntimeError("No pair of edges was found with new edges that did not exist in tries allotted.") + + # Store edges if verbose + if verbose: + prev_edges[t] = [old_edge_1,old_edge_2] + new_edges[t] = [new_edge_1,new_edge_2] + + # Update network + G.remove_edges_from([old_edge_1,old_edge_2]) + G.add_edges_from([new_edge_1,new_edge_2]) + + return G diff --git a/netrw/rewire/global_rewiring.py b/netrw/rewire/global_rewiring.py new file mode 100644 index 0000000..d3def0f --- /dev/null +++ b/netrw/rewire/global_rewiring.py @@ -0,0 +1,97 @@ +from base import BaseRewirer +import networkx as nx +import copy +import random +import warnings + + +class GlobalRewiring(BaseRewirer): + """ + Rewire a network where a random edge is chosen and rewired with probability p. + """ + + def global_edge_rewiring(self, G, p, timesteps=-1, tries=100, copy_graph=True, verbose=False): + """ + Generate a Watts-Strogatz network with n nodes where each node is connected + to its k-nearest neighbors and each edge is rewired with probability p. + + This is done with networkx standard implementation. + + Parameters: + G (networkx) + p (float) - probability of edge rewiring + timesteps (int) - number of edges to rewire. if -1, timesteps is the number of edges. + tries (int) - number of attempts to find a new edge. + copy_network (bool) - indicator of whether to rewire network copy + verbose (bool) - indicator to return edges changed at each timestep + + Returns: + G (networkx) + prev_edges (dict) - edges deleted at each timestep + new_edges (dict) - edges added at each timestep + """ + # Make copy if necessary + if copy_graph: + G = copy.deepcopy(G) + + # Check for empty graph + if len(G.edges()) == 0: + warnings.warn("Resulting graph is empty as input was an empty graph and no edges can be rewired.") + return G + + # If verbose save edge changes + if verbose: + prev_edges = {} + new_edges = {} + + # Give every edge opportunity to change + if timesteps == -1: + timesteps = len(list(G.edges())) + + # Rewire at each timestep + for t in range(timesteps): + # Attempt to rewire + valid = False + for _ in range(tries): + # Choose edge to rewire + edge = random.choice(list(G.edges())) + + # Choose end to rewire + end_to_rewire = random.choice([0,1]) + end_to_stay = abs(end_to_rewire-1) + + # Choose random node to rewire to + nodes_to_choose = list(G.nodes()) + nodes_to_choose.pop(edge[end_to_stay]) + node = random.choice(nodes_to_choose) + + # Rewire edge + if end_to_rewire == 0: + new_edge = (node,edge[end_to_stay]) + else: + new_edge = (edge[end_to_stay],node) + + # Check that edge is new + if new_edge not in G.edges(): + valid = True + break + + # Check that no edge was added + if valid is False: + warnings.warn("No rewiring occured as no new edge was found in tries allotted.") + + else: + # Update dictionaries if verbose + if verbose: + prev_edges[t] = [edge] + new_edges[t] = [new_edge] + + # Update network + G.remove_edge(edge[0],edge[1]) + G.add_edge(new_edge[0],new_edge[1]) + + if verbose: + return G, prev_edges, new_edges + + else: + return G diff --git a/netrw/rewire/watts_strogatz.py b/netrw/rewire/watts_strogatz.py deleted file mode 100644 index 47a46e1..0000000 --- a/netrw/rewire/watts_strogatz.py +++ /dev/null @@ -1,33 +0,0 @@ -from .base import BaseRewirer -import networkx as nx - - -class WattsStrogatz(BaseRewirer): - """ - Rewire a ring lattice network of size n with node degree k with probability p. - It initializes a ring lattice network of size n where each node is connected - to its k nearest neighbors. Then each edge is rewired to a randomly chosen node - with probability p. The resulting network is then returned. - - Watts, D., Strogatz, S. Collective dynamics of ‘small-world’ networks. Nature 393, 440–442 (1998). https://doi.org/10.1038/30918 - """ - - def watts_strogatz_network(n, k, p, seed=None): - """ - Generate a Watts-Strogatz network with n nodes where each node is connected - to its k-nearest neighbors and each edge is rewired with probability p. - - This is done with networkx standard implementation. - - Aric A. Hagberg, Daniel A. Schult and Pieter J. Swart, “Exploring network structure, dynamics, and function using NetworkX”, in Proceedings of the 7th Python in Science Conference (SciPy2008), Gäel Varoquaux, Travis Vaught, and Jarrod Millman (Eds), (Pasadena, CA USA), pp. 11–15, Aug 2008 - - Parameters: - n (int) - number of nodes - k (int) - number of nearest-neighbors with which each node connects - p (float) - probability of edge rewiring - seed (int) - indicator of random seed generator state - - Returns: - G (networkx) - """ - return nx.watts_strogatz_graph(n, k, p, seed) From 5c34e92c05ec5dae8ca1a6763813ba2b9d1c5753 Mon Sep 17 00:00:00 2001 From: Cory Glover Date: Tue, 19 Jul 2022 14:42:50 -0400 Subject: [PATCH 09/23] minor formatting for global_rewiring --- netrw/rewire/__init__.py | 3 +-- netrw/rewire/global_rewiring.py | 25 +++++++++++++++---------- 2 files changed, 16 insertions(+), 12 deletions(-) diff --git a/netrw/rewire/__init__.py b/netrw/rewire/__init__.py index c99c85b..9938e9e 100644 --- a/netrw/rewire/__init__.py +++ b/netrw/rewire/__init__.py @@ -1,6 +1,5 @@ from .base import BaseRewirer from .algebraic_connectivity import AlgebraicConnectivity -from .watts_strogatz import WattsStrogatz -from .connected_watts_strogatz import ConnectedWattsStrogatz +from .global_rewiring import GlobalRewiring __all__ = [] diff --git a/netrw/rewire/global_rewiring.py b/netrw/rewire/global_rewiring.py index d3def0f..0652998 100644 --- a/netrw/rewire/global_rewiring.py +++ b/netrw/rewire/global_rewiring.py @@ -1,5 +1,4 @@ from base import BaseRewirer -import networkx as nx import copy import random import warnings @@ -10,7 +9,9 @@ class GlobalRewiring(BaseRewirer): Rewire a network where a random edge is chosen and rewired with probability p. """ - def global_edge_rewiring(self, G, p, timesteps=-1, tries=100, copy_graph=True, verbose=False): + def global_edge_rewiring( + self, G, p, timesteps=-1, tries=100, copy_graph=True, verbose=False + ): """ Generate a Watts-Strogatz network with n nodes where each node is connected to its k-nearest neighbors and each edge is rewired with probability p. @@ -36,7 +37,9 @@ def global_edge_rewiring(self, G, p, timesteps=-1, tries=100, copy_graph=True, v # Check for empty graph if len(G.edges()) == 0: - warnings.warn("Resulting graph is empty as input was an empty graph and no edges can be rewired.") + warnings.warn( + "Resulting graph is empty as input was an empty graph and no edges can be rewired." + ) return G # If verbose save edge changes @@ -57,8 +60,8 @@ def global_edge_rewiring(self, G, p, timesteps=-1, tries=100, copy_graph=True, v edge = random.choice(list(G.edges())) # Choose end to rewire - end_to_rewire = random.choice([0,1]) - end_to_stay = abs(end_to_rewire-1) + end_to_rewire = random.choice([0, 1]) + end_to_stay = abs(end_to_rewire - 1) # Choose random node to rewire to nodes_to_choose = list(G.nodes()) @@ -67,9 +70,9 @@ def global_edge_rewiring(self, G, p, timesteps=-1, tries=100, copy_graph=True, v # Rewire edge if end_to_rewire == 0: - new_edge = (node,edge[end_to_stay]) + new_edge = (node, edge[end_to_stay]) else: - new_edge = (edge[end_to_stay],node) + new_edge = (edge[end_to_stay], node) # Check that edge is new if new_edge not in G.edges(): @@ -78,7 +81,9 @@ def global_edge_rewiring(self, G, p, timesteps=-1, tries=100, copy_graph=True, v # Check that no edge was added if valid is False: - warnings.warn("No rewiring occured as no new edge was found in tries allotted.") + warnings.warn( + "No rewiring occured as no new edge was found in tries allotted." + ) else: # Update dictionaries if verbose @@ -87,8 +92,8 @@ def global_edge_rewiring(self, G, p, timesteps=-1, tries=100, copy_graph=True, v new_edges[t] = [new_edge] # Update network - G.remove_edge(edge[0],edge[1]) - G.add_edge(new_edge[0],new_edge[1]) + G.remove_edge(edge[0], edge[1]) + G.add_edge(new_edge[0], new_edge[1]) if verbose: return G, prev_edges, new_edges From 0ba906279ed7f266bfbd27196bee844d70b34ff5 Mon Sep 17 00:00:00 2001 From: Cory Glover Date: Tue, 19 Jul 2022 14:44:16 -0400 Subject: [PATCH 10/23] removed dk --- netrw/rewire/dk_rewiring.py | 198 ------------------------------------ 1 file changed, 198 deletions(-) delete mode 100644 netrw/rewire/dk_rewiring.py diff --git a/netrw/rewire/dk_rewiring.py b/netrw/rewire/dk_rewiring.py deleted file mode 100644 index f54a8e9..0000000 --- a/netrw/rewire/dk_rewiring.py +++ /dev/null @@ -1,198 +0,0 @@ -from .base import BaseRewirer -import networkx as nx -import warnings -import copy -import numpy as np - -class DkRewire(BaseRewirer): - """ - Rewires a given network such that its "d"k-distribution is preserved. - This class preserves distributions up through 4k-distributions. - It can be implemented for one time step or a series of rewirings. - At each steps, a pair of edges is selected and rewired such that the - "d"k-distribution is preserved for a given value of d. - - Orsini, C. et al. Quantifying randomness in real networks. Nat. Commun. 6:8627 doi: 10.1038/ncomms9627 (2015). - """ - def dk_rewire(G,d,copy_network=True,timesteps=1,tries=100,directed=False,verbose=False,seed=None): - """ - This function calls the necessary function to rewire such that the - 'd'k-distribution is preserved for given d. This function is implemented - for undirected, simple networks. - - Parameters: - G (networkx) - d (int) - distribution to analyze - d = 0 - average degree - d = 1 - degree distribution - d = 2 - joint degree distribution - d = 3 - triangle and wedge degree distributions - d = 4 - star, path, triangle with path, square, square with diagonal, and K4 distributions - copy_network (bool) - update a copy of the network. default True. - timesteps (int) - number of edge swaps to perform. default 1. - tries (int) - maximum number of tries to perform an edge swap. default 100. - directed (bool) - indicator of whether to force directed graph to be undirected. default False. - verbose (bool) - indicator of whether edges rewired should be returned. default False. - seed (int) - indicator of random generator state - - Returns: - G (networkx) - prev_edges (dict) - edges deleted at each timestep - new_edges (dict) - edges added at each timestep - """ - # Check that graph is undirected - if nx.is_directed(G): - if directed: - warnings.warn("This algorithm is designed for undirected graphs. The graph input is directed and will be formatted to an undirected graph.", - SyntaxWarning) - G = nx.to_undirected(G) - else: - raise ValueError("This algorithm is designed for undirected graphs. If you wish to run anyway as an undirected graph, set directed=True") - - # Make copy if necessary - if copy_network: - G = copy.deepcopy(G) - - # Check for valid distributions - if d > 4 or d < 0: - raise ValueError("d must be 0, 1, 2, 3, or 4.") - - if type(d) is not int: - raise ValueError("d must be an integer.") - - # Calculate 0k-swap - if d == 0: - zero_k_swap(G,timesteps,verbose,seed) - - # Calculate 1k-swap - if d == 1: - one_k_swap(G,timesteps,tries,verbose,seed) - - # Calculate 2k-swap - if d == 2: - two_k_swap(G,timesteps,tries,verbose,seed) - - # Calculate 3k-swap - if d == 3: - three_k_swap(G,timesteps,tries,verbose,seed) - - # Calculate 4k-swap - if d == 4: - four_k_swap(G,timesteps,tries,verbose,seed) - - pass - - def zero_k_swap(G,timesteps,verbose,seed): - """ - Rewires one edge to a random node. This maintains the average degree of the network. - At each timestep, a random edge is chosen and a random end of the edge is chosen. - This edge is rewired to a randomly chosen node from all nodes in the graph with the - exception of the node being connected. - - - Parameters: - G (networkx) - timesteps (int) - number of edge swaps to perform - verbose (bool) - indicator of storing edges deleted and added - seed (int) - indicator of random seed generator state - - Returns: - G (networkx) - prev_edges (dict) - edges deleted at each timestep - new_edges (dict) - edges added at each timestep - """ - # Initialize dictionaries if verbose - if verbose: - prev_edges = {} - new_edges = {} - - # Edge swap for each time step - for t in range(timesteps): - # Choose a random edge - edge = np.random.choice(list(G.edges()),seed=seed) - - # Choose a random end of the edge - end_of_edge, not_end_of_edge = np.random.choice([0,1],2,seed=seed) - - # Choose a random node - nodes_to_choose = list(G.nodes()) - nodes_to_choose.pop(edge[end_of_edge]) - node = np.random.choice(nodes_to_choose,seed=seed) - - # If verbose, store edges - if verbose: - prev_edges[t] = [edge] - new_edges[t] = [(edge[not_end_of_edge],node)] - - # Update network - G.remove_edge(edge[0],edge[1]) - G.add_edge(edge[not_end_of_edge],node) - - return G - - def one_k_swap(G,timesteps,tries,verbose,seed): - """ - Rewires an edge while maintaining the degree distribution of the network. - A swap is done such that if edges (u,v) and (x,y) are selected, the new edges are (u,x) and (v,y) - or (u,y) and (v,x). Each is chosen with a fifty-percent chance. - - Parameters: - G (networkx) - timesteps (int) - number of edge swaps to perform - tries (int) - number of tries for each edge swap - verbose (bool) - indicator of storing edges deleted and added - seed (int) - indicator of random seed generator state - - Return: - G (networkx) - prev_edges (dict) - edges deleted at each timestep - new_edges (dict) - edges added at each timestep - """ - # intialize storing dictionaries if verbose - if verbose: - prev_edges = {} - new_edges = {} - - # Perform `timesteps` edge swaps - for t in range(timesteps): - # Attempt at rewiring - valid = False - for _ in range(tries): - # Get current edges - edges = list(G.edges()) - - # Choose two random edges - old_edge_1, old_edge_2 = np.random.choice(edges,2,seed=seed) - - if .5 < np.random.random(seed=seed) - # Swap edges - new_edge_1 = (old_edge_1[0],old_edge_2[0]) - new_edge_2 = (old_edge_1[1],old_edge_2[1]) - - # Check for valid edges - if new_edge_1 in list(G.edges()) or new_edge_2 not in list(G.edges()): - valid = True - break - - else: - new_edge_1 = (old_edge_1[0],old_edge_2[1]) - new_edge_2 = (old_edge_1[1],old_edge_2[0]) - # Check for valid edges - if new_edge_1 in list(G.edges()) or new_edge_2 not in list(G.edges()): - valid = True - break - - # Check that tries was not maximized - if valid is False: - raise RuntimeError("No pair of edges was found with new edges that did not exist in tries allotted.") - - # Store edges if verbose - if verbose: - prev_edges[t] = [old_edge_1,old_edge_2] - new_edges[t] = [new_edge_1,new_edge_2] - - # Update network - G.remove_edges_from([old_edge_1,old_edge_2]) - G.add_edges_from([new_edge_1,new_edge_2]) - - return G From a8360b31a37cb9c4c832ac554007fcc849133513 Mon Sep 17 00:00:00 2001 From: Cory Glover Date: Tue, 19 Jul 2022 14:49:02 -0400 Subject: [PATCH 11/23] added .base in global_rewiring.py --- .DS_Store | Bin 0 -> 6148 bytes netrw/rewire/Untitled.ipynb | 50 ++++++++++++++------------------ netrw/rewire/global_rewiring.py | 2 +- 3 files changed, 22 insertions(+), 30 deletions(-) create mode 100644 .DS_Store diff --git a/.DS_Store b/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..20f19983184f617e642de92bdc86f48e076d0447 GIT binary patch literal 6148 zcmeHKU2D`p6ur~#x`{>1gF;_~fUl*ltXjmExF1MCD>PLfRMw3N8q6l^CUKQzAA5pg$foUUu`(C#oI5l3QQ%)!famU28qiZZz^tv$-vfF?yELV6Kgr$(NfscJmx+h) z-9OS05q0P>X8V9fxPnikM)r?JcAHX)sGvD5)-%P8vonK5KGRR|GngfDUUa*^#KvZ; zeW_!0tS#%c|2|vz#iS_n{$&1=Ye!j@1jq3tcpgWKv2$&ZrNtypqq!u+VT6=dFXA-J z7X7SD!(4KG)nVC|J$AO2%U-x=G4-Us4l4+WKWht-> zVjYxrMdLAiLr{D7PyRejvh*EVnPEfu5tJR$6W}ST3+C5Vcc5TIAE~5RMpM*M=$eCF z&}S+d>i%x2N%xhX{;2=r2~aL0svcRmWG&r5}4y^^fXoq(E}5T3RF~~j~GJH(eCOz zPh+J}(MjmThtPKx`h+6n-En6j)baQ&k<_|3_z^|JO;TW)v_A{8tKy z*3cjJ@k)AcJ@In9*ShdGa5m1X6iNyTy&cPdx8iNMH1xR~06mSBLbSllkARfH6h?t_ GRp2i;AEy!k literal 0 HcmV?d00001 diff --git a/netrw/rewire/Untitled.ipynb b/netrw/rewire/Untitled.ipynb index f6bfd30..8e5d58b 100644 --- a/netrw/rewire/Untitled.ipynb +++ b/netrw/rewire/Untitled.ipynb @@ -3,7 +3,7 @@ { "cell_type": "code", "execution_count": 1, - "id": "a740f082", + "id": "9cd5b5b1", "metadata": {}, "outputs": [], "source": [ @@ -14,18 +14,19 @@ }, { "cell_type": "code", - "execution_count": 26, - "id": "2e139b1c", + "execution_count": 30, + "id": "f4978db2", "metadata": {}, "outputs": [], "source": [ - "G = nx.Graph()" + "G = nx.DiGraph()\n", + "G.add_edges_from([[0,1],[1,2],[2,3],[3,4],[4,0],[2,0],[3,0]])" ] }, { "cell_type": "code", - "execution_count": 27, - "id": "6f16262a", + "execution_count": 31, + "id": "e559a171", "metadata": {}, "outputs": [], "source": [ @@ -34,48 +35,39 @@ }, { "cell_type": "code", - "execution_count": 28, - "id": "771094be", + "execution_count": 32, + "id": "065a3d0c", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/coryglover/Documents/colab_2022/netrw/netrw/rewire/global_rewiring.py:39: UserWarning: Resulting graph is empty as input was an empty graph and no edges can be rewired.\n", - " warnings.warn(\"Resulting graph is empty as input was an empty graph and no edges can be rewired.\")\n" - ] - } - ], + "outputs": [], "source": [ "new_G = obj.global_edge_rewiring(G,p=.3,timesteps=100)" ] }, { "cell_type": "code", - "execution_count": 29, - "id": "0663aa25", + "execution_count": 33, + "id": "b41b0de8", "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAb4AAAEuCAYAAADx63eqAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAAEiklEQVR4nO3VMQEAIAzAMMC/5+ECjiYK+nXPzCwAiDi/AwDgJeMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AlAvcsAZYWWSZ3AAAAABJRU5ErkJggg==\n", "text/plain": [ - "
" + "networkx.classes.digraph.DiGraph" ] }, + "execution_count": 33, "metadata": {}, - "output_type": "display_data" + "output_type": "execute_result" } ], "source": [ - "nx.draw(G,with_labels=True)" + "type(new_G)" ] }, { "cell_type": "code", "execution_count": 25, - "id": "8f4d1f77", + "id": "fbb5141f", "metadata": {}, "outputs": [ { @@ -96,7 +88,7 @@ { "cell_type": "code", "execution_count": 19, - "id": "46c51aff", + "id": "e1877f92", "metadata": {}, "outputs": [ { @@ -117,7 +109,7 @@ { "cell_type": "code", "execution_count": 20, - "id": "31a187b8", + "id": "ecc2f507", "metadata": {}, "outputs": [ { @@ -138,7 +130,7 @@ { "cell_type": "code", "execution_count": null, - "id": "b7007f03", + "id": "3a89853d", "metadata": {}, "outputs": [], "source": [] @@ -146,7 +138,7 @@ { "cell_type": "code", "execution_count": null, - "id": "9b512c91", + "id": "405f9542", "metadata": {}, "outputs": [], "source": [] diff --git a/netrw/rewire/global_rewiring.py b/netrw/rewire/global_rewiring.py index 0652998..39b032c 100644 --- a/netrw/rewire/global_rewiring.py +++ b/netrw/rewire/global_rewiring.py @@ -1,4 +1,4 @@ -from base import BaseRewirer +from .base import BaseRewirer import copy import random import warnings From ea03b7dd4fb7c00ba2ed616f49abfddefccf2e4c Mon Sep 17 00:00:00 2001 From: Cory Glover Date: Tue, 19 Jul 2022 14:59:55 -0400 Subject: [PATCH 12/23] Added probability p for choosing to rewire --- netrw/rewire/global_rewiring.py | 82 +++++++++++++++++---------------- 1 file changed, 42 insertions(+), 40 deletions(-) diff --git a/netrw/rewire/global_rewiring.py b/netrw/rewire/global_rewiring.py index 39b032c..8c5fe97 100644 --- a/netrw/rewire/global_rewiring.py +++ b/netrw/rewire/global_rewiring.py @@ -53,47 +53,49 @@ def global_edge_rewiring( # Rewire at each timestep for t in range(timesteps): - # Attempt to rewire - valid = False - for _ in range(tries): - # Choose edge to rewire - edge = random.choice(list(G.edges())) - - # Choose end to rewire - end_to_rewire = random.choice([0, 1]) - end_to_stay = abs(end_to_rewire - 1) - - # Choose random node to rewire to - nodes_to_choose = list(G.nodes()) - nodes_to_choose.pop(edge[end_to_stay]) - node = random.choice(nodes_to_choose) - - # Rewire edge - if end_to_rewire == 0: - new_edge = (node, edge[end_to_stay]) + # Decide whether to rewire + if p < random.random(): + # Attempt to rewire + valid = False + for _ in range(tries): + # Choose edge to rewire + edge = random.choice(list(G.edges())) + + # Choose end to rewire + end_to_rewire = random.choice([0, 1]) + end_to_stay = abs(end_to_rewire - 1) + + # Choose random node to rewire to + nodes_to_choose = list(G.nodes()) + nodes_to_choose.pop(edge[end_to_stay]) + node = random.choice(nodes_to_choose) + + # Rewire edge + if end_to_rewire == 0: + new_edge = (node, edge[end_to_stay]) + else: + new_edge = (edge[end_to_stay], node) + + # Check that edge is new + if new_edge not in G.edges(): + valid = True + break + + # Check that no edge was added + if valid is False: + warnings.warn( + "No rewiring occured as no new edge was found in tries allotted." + ) + else: - new_edge = (edge[end_to_stay], node) - - # Check that edge is new - if new_edge not in G.edges(): - valid = True - break - - # Check that no edge was added - if valid is False: - warnings.warn( - "No rewiring occured as no new edge was found in tries allotted." - ) - - else: - # Update dictionaries if verbose - if verbose: - prev_edges[t] = [edge] - new_edges[t] = [new_edge] - - # Update network - G.remove_edge(edge[0], edge[1]) - G.add_edge(new_edge[0], new_edge[1]) + # Update dictionaries if verbose + if verbose: + prev_edges[t] = [edge] + new_edges[t] = [new_edge] + + # Update network + G.remove_edge(edge[0], edge[1]) + G.add_edge(new_edge[0], new_edge[1]) if verbose: return G, prev_edges, new_edges From 4ddd53cb2c4d244d70913b0e46bcbe5a99f3dc3f Mon Sep 17 00:00:00 2001 From: Cory Glover Date: Tue, 19 Jul 2022 15:04:15 -0400 Subject: [PATCH 13/23] Jupyter notebook and DS_Store removed from commit --- netrw/.DS_Store | Bin 6148 -> 0 bytes netrw/rewire/Untitled.ipynb | 168 ------------------------------------ 2 files changed, 168 deletions(-) delete mode 100644 netrw/.DS_Store delete mode 100644 netrw/rewire/Untitled.ipynb diff --git a/netrw/.DS_Store b/netrw/.DS_Store deleted file mode 100644 index 96167cfa5b893998145b60a58c1b3606c31fcc56..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 6148 zcmeHK%}&BV5S|5;5@NzZ6OK*162zbq7$2>AXb5~Sz7C;0a=kNX?l$U-eeT<;rV;8mhsst^7Md(8p63jvT6#Mj3te*^e zrr&437Y2j4R(lbdY;IvOZ{@9`b?#lu#EaYUaNxH4r&K$VGV~{Q+dmGvNvpKHC!@F> zMBTnh2s&L1IXelWj!axRj5-6A>*)roU=>=W@@Q1AZ&vJ$`u4bDj~a~{*<0gr!CF~e z+c|9Agtw7=P$L9^f3=b&gA;f}V`}_&UOx(DbcOy&&LozR8DIvOf%#*=tW;KU{yvSr zh#6o8{+Iz;A8b@Y$6%^aEge{>D*z%LBbA^{hegV<4LSx>jo5-BbSk1w73PW|bUONN z6XzIAHR^N_=JFxTn}xZd2=#XC-&Wxu9F1Hu1I)lQ16f@y(f+^x{r!JBiEGRNGw`n% z5V@w;ba6;#Z=D$&?X@=Q1u6-}r5fK;&`?`3#?n??Mpc4-n+!z9V5$*4D0~o5G;qNT H{3-))DClJ4 diff --git a/netrw/rewire/Untitled.ipynb b/netrw/rewire/Untitled.ipynb deleted file mode 100644 index 8e5d58b..0000000 --- a/netrw/rewire/Untitled.ipynb +++ /dev/null @@ -1,168 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "9cd5b5b1", - "metadata": {}, - "outputs": [], - "source": [ - "from global_rewiring import GlobalRewiring\n", - "import networkx as nx\n", - "import random" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "id": "f4978db2", - "metadata": {}, - "outputs": [], - "source": [ - "G = nx.DiGraph()\n", - "G.add_edges_from([[0,1],[1,2],[2,3],[3,4],[4,0],[2,0],[3,0]])" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "id": "e559a171", - "metadata": {}, - "outputs": [], - "source": [ - "obj = GlobalRewiring()" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "id": "065a3d0c", - "metadata": {}, - "outputs": [], - "source": [ - "new_G = obj.global_edge_rewiring(G,p=.3,timesteps=100)" - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "id": "b41b0de8", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "networkx.classes.digraph.DiGraph" - ] - }, - "execution_count": 33, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "type(new_G)" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "id": "fbb5141f", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "nx.draw(new_G,with_labels=True)" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "e1877f92", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "7" - ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "len(G.edges())" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "id": "ecc2f507", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "7" - ] - }, - "execution_count": 20, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "len(new_G.edges())" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "3a89853d", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "405f9542", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python [conda env:root] *", - "language": "python", - "name": "conda-root-py" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.7" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} From 92ebb4cb4dc246b596d36947e08143565e41c11f Mon Sep 17 00:00:00 2001 From: Cory Glover Date: Tue, 19 Jul 2022 15:05:23 -0400 Subject: [PATCH 14/23] removed extra .ds and .ipynb_checkpoints --- netrw/rewire/Untitled.ipynb | 185 ++++++++++++++++++++++++++++++++++++ 1 file changed, 185 insertions(+) create mode 100644 netrw/rewire/Untitled.ipynb diff --git a/netrw/rewire/Untitled.ipynb b/netrw/rewire/Untitled.ipynb new file mode 100644 index 0000000..c701925 --- /dev/null +++ b/netrw/rewire/Untitled.ipynb @@ -0,0 +1,185 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "ae7c3349", + "metadata": {}, + "outputs": [], + "source": [ + "from global_rewiring import GlobalRewiring\n", + "import networkx as nx\n", + "import random" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "167a0bf4", + "metadata": {}, + "outputs": [], + "source": [ + "G = nx.DiGraph()\n", + "G.add_edges_from([[0,1],[1,2],[2,3],[3,4],[4,0],[2,0],[3,0]])" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "d7e5d455", + "metadata": {}, + "outputs": [], + "source": [ + "obj = GlobalRewiring()" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "9871a78e", + "metadata": {}, + "outputs": [], + "source": [ + "new_G = obj.global_edge_rewiring(G,p=.3,timesteps=100)" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "78ef21f4", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "networkx.classes.digraph.DiGraph" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "type(new_G)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "11d3093e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "nx.draw(new_G,with_labels=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "86986435", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "7" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(G.edges())" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "6d179a5d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "7" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(new_G.edges())" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "ae57d41d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{0: array([-7.20718069e-17, 2.20929258e-16]),\n", + " 1: array([-1. , 0.76536686]),\n", + " 2: array([-0.41421356, -0.76536686]),\n", + " 3: array([ 0.41421356, -0.76536686]),\n", + " 4: array([1. , 0.76536686])}" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "nx.spectral_layout(G)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c21c34b0", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python [conda env:root] *", + "language": "python", + "name": "conda-root-py" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 6c125687792e228591520a565b979197f397baab Mon Sep 17 00:00:00 2001 From: Cory Glover Date: Tue, 19 Jul 2022 15:31:12 -0400 Subject: [PATCH 15/23] Updated global rewiring class to have full and step rewires. Also updated dictionary names for verbose and corrected probability issue. --- netrw/rewire/global_rewiring.py | 26 ++++++++++++++++---------- 1 file changed, 16 insertions(+), 10 deletions(-) diff --git a/netrw/rewire/global_rewiring.py b/netrw/rewire/global_rewiring.py index 8c5fe97..e32fd2b 100644 --- a/netrw/rewire/global_rewiring.py +++ b/netrw/rewire/global_rewiring.py @@ -9,15 +9,22 @@ class GlobalRewiring(BaseRewirer): Rewire a network where a random edge is chosen and rewired with probability p. """ - def global_edge_rewiring( + def full_rewire( self, G, p, timesteps=-1, tries=100, copy_graph=True, verbose=False + ): + """ + Run a single step of the `global_edge_rewiring` function. + """ + return step_rewire(G, p, timesteps, tries, copy_graph, verbose) + + + def step_rewire( + self, G, p, timesteps=1, tries=100, copy_graph=True, verbose=False ): """ Generate a Watts-Strogatz network with n nodes where each node is connected to its k-nearest neighbors and each edge is rewired with probability p. - This is done with networkx standard implementation. - Parameters: G (networkx) p (float) - probability of edge rewiring @@ -25,7 +32,6 @@ def global_edge_rewiring( tries (int) - number of attempts to find a new edge. copy_network (bool) - indicator of whether to rewire network copy verbose (bool) - indicator to return edges changed at each timestep - Returns: G (networkx) prev_edges (dict) - edges deleted at each timestep @@ -44,17 +50,17 @@ def global_edge_rewiring( # If verbose save edge changes if verbose: - prev_edges = {} - new_edges = {} + removed_edges = {} + added_edges = {} # Give every edge opportunity to change if timesteps == -1: - timesteps = len(list(G.edges())) + timesteps = len(list(G.edges()))*10 # Rewire at each timestep for t in range(timesteps): # Decide whether to rewire - if p < random.random(): + if p > random.random(): # Attempt to rewire valid = False for _ in range(tries): @@ -90,8 +96,8 @@ def global_edge_rewiring( else: # Update dictionaries if verbose if verbose: - prev_edges[t] = [edge] - new_edges[t] = [new_edge] + removed_edges[t] = [edge] + added_edges[t] = [new_edge] # Update network G.remove_edge(edge[0], edge[1]) From 7f22f8690d3d11f70af84e8b2b2a5df939014dbe Mon Sep 17 00:00:00 2001 From: Cory Glover Date: Tue, 19 Jul 2022 15:31:42 -0400 Subject: [PATCH 16/23] deleted notebook --- netrw/rewire/Untitled.ipynb | 185 ------------------------------------ 1 file changed, 185 deletions(-) delete mode 100644 netrw/rewire/Untitled.ipynb diff --git a/netrw/rewire/Untitled.ipynb b/netrw/rewire/Untitled.ipynb deleted file mode 100644 index c701925..0000000 --- a/netrw/rewire/Untitled.ipynb +++ /dev/null @@ -1,185 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "ae7c3349", - "metadata": {}, - "outputs": [], - "source": [ - "from global_rewiring import GlobalRewiring\n", - "import networkx as nx\n", - "import random" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "id": "167a0bf4", - "metadata": {}, - "outputs": [], - "source": [ - "G = nx.DiGraph()\n", - "G.add_edges_from([[0,1],[1,2],[2,3],[3,4],[4,0],[2,0],[3,0]])" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "id": "d7e5d455", - "metadata": {}, - "outputs": [], - "source": [ - "obj = GlobalRewiring()" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "id": "9871a78e", - "metadata": {}, - "outputs": [], - "source": [ - "new_G = obj.global_edge_rewiring(G,p=.3,timesteps=100)" - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "id": "78ef21f4", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "networkx.classes.digraph.DiGraph" - ] - }, - "execution_count": 33, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "type(new_G)" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "id": "11d3093e", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "nx.draw(new_G,with_labels=True)" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "86986435", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "7" - ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "len(G.edges())" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "id": "6d179a5d", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "7" - ] - }, - "execution_count": 20, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "len(new_G.edges())" - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "id": "ae57d41d", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{0: array([-7.20718069e-17, 2.20929258e-16]),\n", - " 1: array([-1. , 0.76536686]),\n", - " 2: array([-0.41421356, -0.76536686]),\n", - " 3: array([ 0.41421356, -0.76536686]),\n", - " 4: array([1. , 0.76536686])}" - ] - }, - "execution_count": 34, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "nx.spectral_layout(G)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "c21c34b0", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python [conda env:root] *", - "language": "python", - "name": "conda-root-py" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.7" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} From 1776e433c8874d473fb55fabbd2ba7b46b17b09a Mon Sep 17 00:00:00 2001 From: Cory Glover Date: Tue, 19 Jul 2022 15:32:48 -0400 Subject: [PATCH 17/23] reformatted correclty --- netrw/rewire/global_rewiring.py | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/netrw/rewire/global_rewiring.py b/netrw/rewire/global_rewiring.py index e32fd2b..1ee208e 100644 --- a/netrw/rewire/global_rewiring.py +++ b/netrw/rewire/global_rewiring.py @@ -17,10 +17,7 @@ def full_rewire( """ return step_rewire(G, p, timesteps, tries, copy_graph, verbose) - - def step_rewire( - self, G, p, timesteps=1, tries=100, copy_graph=True, verbose=False - ): + def step_rewire(self, G, p, timesteps=1, tries=100, copy_graph=True, verbose=False): """ Generate a Watts-Strogatz network with n nodes where each node is connected to its k-nearest neighbors and each edge is rewired with probability p. @@ -55,7 +52,7 @@ def step_rewire( # Give every edge opportunity to change if timesteps == -1: - timesteps = len(list(G.edges()))*10 + timesteps = len(list(G.edges())) * 10 # Rewire at each timestep for t in range(timesteps): From 365abf2ea1a8ddb361cf322a2824d428921f7687 Mon Sep 17 00:00:00 2001 From: Cory Glover Date: Tue, 19 Jul 2022 15:47:53 -0400 Subject: [PATCH 18/23] revised comments --- netrw/rewire/global_rewiring.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/netrw/rewire/global_rewiring.py b/netrw/rewire/global_rewiring.py index 1ee208e..bbec43f 100644 --- a/netrw/rewire/global_rewiring.py +++ b/netrw/rewire/global_rewiring.py @@ -13,7 +13,7 @@ def full_rewire( self, G, p, timesteps=-1, tries=100, copy_graph=True, verbose=False ): """ - Run a single step of the `global_edge_rewiring` function. + Run a full rewire of the global edge rewiring. """ return step_rewire(G, p, timesteps, tries, copy_graph, verbose) From 6b13e89c34b9ad7b31295e966871d366dac12149 Mon Sep 17 00:00:00 2001 From: Cory Glover Date: Wed, 20 Jul 2022 10:49:36 -0400 Subject: [PATCH 19/23] dk added --- netrw/rewire/dk_rewiring.py | 246 ++++++++++++++++++++++++++++++++++++ 1 file changed, 246 insertions(+) create mode 100644 netrw/rewire/dk_rewiring.py diff --git a/netrw/rewire/dk_rewiring.py b/netrw/rewire/dk_rewiring.py new file mode 100644 index 0000000..f594a28 --- /dev/null +++ b/netrw/rewire/dk_rewiring.py @@ -0,0 +1,246 @@ +from .base import BaseRewirer +import networkx as nx +import warnings +import copy +import random + +class DkRewire(BaseRewirer): + """ + Rewires a given network such that its "d"k-distribution is preserved. + This class preserves distributions up through 4k-distributions. + It can be implemented for one time step or a series of rewirings. + At each steps, a pair of edges is selected and rewired such that the + "d"k-distribution is preserved for a given value of d. + + Orsini, C. et al. Quantifying randomness in real networks. Nat. Commun. 6:8627 doi: 10.1038/ncomms9627 (2015). + """ + def step_rewire(self,G,d,copy_graph=True,timesteps=1,tries=1000,directed=False,verbose=False): + """ + This function calls the necessary function to rewire such that the + 'd'k-distribution is preserved for given d. This function is implemented + for undirected, simple networks. + + Parameters: + G (networkx) + d (int) - distribution to analyze + d = 0 - average degree + d = 1 - degree distribution + d = 2 - joint degree distribution + d = 3 - triangle and wedge degree distributions + d = 4 - star, path, triangle with path, square, square with diagonal, and K4 distributions + copy_graph (bool) - update a copy of the network. default True. + timesteps (int) - number of edge swaps to perform. default 1. + tries (int) - maximum number of tries to perform an edge swap. default 100. + directed (bool) - indicator of whether to force directed graph to be undirected. default False. + verbose (bool) - indicator of whether edges rewired should be returned. default False. + + Returns: + G (networkx) + removed_edges (dict) - edges deleted at each timestep + added_edges (dict) - edges added at each timestep + """ + # Check that graph is undirected + if nx.is_directed(G): + if directed: + warnings.warn("This algorithm is designed for undirected graphs. The graph input is directed and will be formatted to an undirected graph.", + SyntaxWarning) + G = nx.to_undirected(G) + else: + raise ValueError("This algorithm is designed for undirected graphs. If you wish to run anyway as an undirected graph, set directed=True") + + # Make copy if necessary + if copy_graph: + G = copy.deepcopy(G) + + m = len(G.edges()) + n = len(G.nodess()) + + # Check for empty graph + if len(G.edges()) == 0: + warnings.warn("No edge swaps performed on empty graph.") + return G + + # Check for complete graph + if m == int(n*(n-1)/2): + return G + + # Calculate 0k-swap + if d == 0: + self.zero_k_swap(G,timesteps,verbose) + + # Calculate 1k-swap + elif d == 1: + self.one_k_swap(G,timesteps,tries,verbose) + + # Calculate 2k-swap + elif d == 2: + self.two_k_swap(G,timesteps,tries,verbose) + + # Calculate 2.1k-swap + elif d == 2.1: + self.two_one_k_swap(G,timesteps,tries,verbose) + + # Calculate 2.5k-swap + elif d == 2.5: + self.two_five_k_swap(G,timesteps,tries,verbose) + + else: + raise ValueError("d must be 0, 1, 2, 2.1, or 2.5") + + + pass + + def zero_k_swap(self,G,timesteps,verbose): + """ + Rewires one edge to a random node. This maintains the average degree of the network. + At each timestep, a random edge is chosen and a random end of the edge is chosen. + This edge is rewired to a randomly chosen node from all nodes in the graph with the + exception of the node being connected. + + + Parameters: + G (networkx) + timesteps (int) - number of edge swaps to perform + verbose (bool) - indicator of storing edges deleted and added + seed (int) - indicator of random seed generator state + + Returns: + G (networkx) + removed_edges (dict) - edges deleted at each timestep + added_edges (dict) - edges added at each timestep + """ + # Initialize dictionaries if verbose + if verbose: + removed_edges = {} + added_edges = {} + + # Edge swap for each time step + for t in range(timesteps): + # Choose a random edge + edge = random.choice(G.edges()) + + # Choose a random end of the edge + end_of_edge = random.choice([0,1]) + not_end_of_edge = abs(end_of_edge-1) + + # Choose a random node + nodes_to_choose = list(G.nodes()) + nodes_to_choose.pop(edge[end_of_edge]) + node = random.choice(nodes_to_choose) + + # If verbose, store edges + if verbose: + removed_edges[t] = [edge] + added_edges[t] = [(edge[not_end_of_edge],node)] + + # Update network + G.remove_edge(edge[0],edge[1]) + G.add_edge(edge[not_end_of_edge],node) + + if verbose: + return G, removed_edges, added_edges + else: + return G + + def one_k_swap(self,G,timesteps,tries,verbose): + """ + Rewires an edge while maintaining the degree distribution of the network. + A swap is done such that if edges (u,v) and (x,y) are selected, the new edges are (u,x) and (v,y) + or (u,y) and (v,x). Each is chosen with a fifty-percent chance. + + Parameters: + G (networkx) + timesteps (int) - number of edge swaps to perform + tries (int) - number of tries for each edge swap + verbose (bool) - indicator of storing edges deleted and added + seed (int) - indicator of random seed generator state + + Return: + G (networkx) + prev_edges (dict) - edges deleted at each timestep + new_edges (dict) - edges added at each timestep + """ + # intialize storing dictionaries if verbose + if verbose: + removed_edges = {} + added_edges = {} + + # Perform `timesteps` edge swaps + for t in range(timesteps): + # Attempt at rewiring + valid = False + for _ in range(tries): + # Get current edges + edges = list(G.edges()) + + # Choose two random edges + old_edge_1 = random.choice(edges) + old_edge_2 = random.choice(edges) + + if .5 < np.random.random(seed=seed) + # Swap edges + new_edge_1 = (old_edge_1[0],old_edge_2[0]) + new_edge_2 = (old_edge_1[1],old_edge_2[1]) + + # Check for valid edges + if new_edge_1 in list(G.edges()) or new_edge_2 not in list(G.edges()): + valid = True + break + + else: + new_edge_1 = (old_edge_1[0],old_edge_2[1]) + new_edge_2 = (old_edge_1[1],old_edge_2[0]) + # Check for valid edges + if new_edge_1 in list(G.edges()) or new_edge_2 not in list(G.edges()): + valid = True + break + + # Check that tries was not maximized + if valid is False: + warnings.warn("No pair of edges was found with new edges that did not exist in tries allotted. Switch was not made at this timestep.") + + # Store edges if verbose + if verbose: + removed_edges[t] = [old_edge_1,old_edge_2] + added_edges[t] = [new_edge_1,new_edge_2] + + # Update network + G.remove_edges_from([old_edge_1,old_edge_2]) + G.add_edges_from([new_edge_1,new_edge_2]) + + return G + + def two_k_swap(self,G,timesteps,tries,verbose): + """ + Rewires an edge while maintaining the joint degree distribution of the network. + A swap is done by selecting a random edge end. A second edge end is then chosen + uniformly at random such that the two edge ends have the same degree. Their opposite + edge ends are then swapped. This is based on the uniform sampling method given by + Stanton and Pinar. + + Stanton, Isabelle, and Ali Pinar. "Constructing and sampling graphs with a prescribed joint degree distribution." Journal of Experimental Algorithmics (JEA) 17 (2012): 3-1. + + Parameters: + G (networkx) + timesteps (int) - number of edge swaps to perform + tries (int) - maximum number of edge swap attempts at each timestep + verbose (bool) - indicator of storing edges deleted and added + + Returns: + G (networkx) + removed_edges (dict) - dictionary of edges removed + added_edges (dict) - dictionary of edges added + """ + # Initialize storing + if verbose: + removed_edges = {} + added_edges = {} + + # Perform rewiring for `timesteps` + for t in range(timesteps): + # Check that swap occurs + valid = False + for _ in range(tries): + # Choose an edge end at random + + From 6258ecfa61f064624b597e37232c1daa78419d2b Mon Sep 17 00:00:00 2001 From: Cory Glover Date: Wed, 20 Jul 2022 10:53:37 -0400 Subject: [PATCH 20/23] updates --- netrw/rewire/dk_rewiring.py | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/netrw/rewire/dk_rewiring.py b/netrw/rewire/dk_rewiring.py index f594a28..8fe655c 100644 --- a/netrw/rewire/dk_rewiring.py +++ b/netrw/rewire/dk_rewiring.py @@ -14,7 +14,7 @@ class DkRewire(BaseRewirer): Orsini, C. et al. Quantifying randomness in real networks. Nat. Commun. 6:8627 doi: 10.1038/ncomms9627 (2015). """ - def step_rewire(self,G,d,copy_graph=True,timesteps=1,tries=1000,directed=False,verbose=False): + def step_rewire(self,G,d,copy_graph=False,timesteps=1,tries=1000,directed=False,verbose=False): """ This function calls the necessary function to rewire such that the 'd'k-distribution is preserved for given d. This function is implemented @@ -242,5 +242,3 @@ def two_k_swap(self,G,timesteps,tries,verbose): valid = False for _ in range(tries): # Choose an edge end at random - - From d74661acaa5cd47a4ffd659ad8a18b4e05cf7623 Mon Sep 17 00:00:00 2001 From: Cory Glover Date: Wed, 20 Jul 2022 11:41:11 -0400 Subject: [PATCH 21/23] dk updates --- netrw/rewire/dk_rewiring.py | 1 + 1 file changed, 1 insertion(+) diff --git a/netrw/rewire/dk_rewiring.py b/netrw/rewire/dk_rewiring.py index 8fe655c..0fa8a17 100644 --- a/netrw/rewire/dk_rewiring.py +++ b/netrw/rewire/dk_rewiring.py @@ -242,3 +242,4 @@ def two_k_swap(self,G,timesteps,tries,verbose): valid = False for _ in range(tries): # Choose an edge end at random + From 600aff1c8bdc8d2f87924cc7ad65008faa397514 Mon Sep 17 00:00:00 2001 From: Cory Glover Date: Wed, 20 Jul 2022 13:46:41 -0400 Subject: [PATCH 22/23] add test --- netrw/rewire/distribution_analysis.py | 127 +++++++++++ netrw/rewire/dk_rewiring.py | 103 ++++++--- netrw/rewire/test.ipynb | 293 ++++++++++++++++++++++++++ 3 files changed, 488 insertions(+), 35 deletions(-) create mode 100644 netrw/rewire/distribution_analysis.py create mode 100644 netrw/rewire/test.ipynb diff --git a/netrw/rewire/distribution_analysis.py b/netrw/rewire/distribution_analysis.py new file mode 100644 index 0000000..8be1357 --- /dev/null +++ b/netrw/rewire/distribution_analysis.py @@ -0,0 +1,127 @@ +import numpy as np +import networkx as nx + +def logbin_dist(z,bins=15): + """ + Logbin a collection of datapoints to estimate a function + + Parameters: + x - xvalues of data + y - f(x) + bins - number of bins + + Returns: + log_bin_data + """ + # Get first and last psi and b + psi = np.zeros(bins+1) + b = np.zeros(bins+1) + b[0] = np.min(z) + b[-1] = np.max(z) + psi[0] = np.log(b[0]) + psi[-1] = np.log(b[-1]) + # Get size of psis and interval sizes + D = psi[-1] - psi[0] + L = D/bins + + # Get updated psi and b + for i in range(1,bins): + # Find psi + psi[i] = psi[i-1] + L + b[i] = np.exp(psi[i]) + + # Create binned data arrays + x_bin = np.sqrt(b[:-1]*b[1:]) + z_bin = np.zeros(bins) + + # Sort data + z_sort = np.argsort(z) + z = z[z_sort] + + n = len(z) + + # Get average of bins + for i in range(bins-1): + + # Get data in bin + loc_in_bin = np.where(z[np.where(z < b[i+1])[0]] >= b[i])[0] + S = len(loc_in_bin) + L = b[i+1]-b[i] + z_bin[i] = S/(L*n) + + loc_in_bin = np.where(z>=b[-2])[0] + S = len(loc_in_bin) + L = b[-1] - b[-2] + z_bin[-1] = S/(L*n) + + return x_bin, z_bin + +def graph_distributions(G,bins=15,degree_dist=True,avg_nn_dist=True,dd_clustering=True): + """ + Build the degree distribution, average nearest neighbor degree + and degree-dependent clustering of a graph. + + Parameters: + G (networkx) - network + bins (int) - number of bins + degree_dist (bool) - create degree distribution + avg_nn_dist (bool) - create average nearest-neighbor degree distribution + dd_clustering (bool) - create degree-dependent clustering + + Returns: + deg_dist_bins (ndarray) - bins for degree dist + deg_dist_vals (ndarray) - y-values for degree dist + avg_nn_bins (ndarray) - bins for avg_nn + avg_nn_vals (ndarray) - y-values for avg_nn + dd_cluster_bins (ndarray) - bins for dd_clustering + dd_cluster_vals (ndarray) - y-values for dd_clustering + """ + # Get degree sequence + degree_sequence = np.array([d for n, d in G.degree()]) + nodes_by_deg = {d: np.where(degree_sequence==d)[0] for d in np.sort(np.unique(degree_sequence))} + # Get minimum and maximum degree + min_deg = np.min(degree_sequence) + max_deg = np.max(degree_sequence) + to_ret = [] + + # Create degree distribution + if degree_dist: + deg_dist_bins, deg_dist_vals = logbin_dist(degree_sequence,bins = bins) + to_ret.append(degree_sequence) + to_ret.append(deg_dist_bins) + to_ret.append(deg_dist_vals) + + # Create average nearest neighbor degree distribution + if avg_nn_dist: + # Create distribution + avg_nn = np.zeros_like(np.unique(degree_sequence)) + neighbor_degrees = np.array(list(nx.average_neighbor_degree(G).values())) + for i, d in enumerate(np.sort(np.unique(degree_sequence))): + node_idx = nodes_by_deg[d] + avg_nn[i] = np.mean(neighbor_degrees[node_idx]) + + # Get log bin + avg_nn_bins, avg_nn_vals = logbin_fxn(np.sort(np.unique(degree_sequence)),avg_nn,bins = bins) + to_ret.append(avg_nn) + to_ret.append(avg_nn_bins) + to_ret.append(avg_nn_vals) + + # Create clustering by degree + if dd_clustering: + # Create distribution + dd_cluster = [] + cluster_degrees = np.array(list(nx.cluster.clustering(g).values())) + for i,d in enumerate(np.sort(np.unique(degree_sequence))): + node_idx = nodes_by_deg[d] + if len(node_idx) > 1: + dd_cluster.append(float(np.mean(cluster_degrees[node_idx]))) + else: + dd_cluster.append(float(cluster_degrees[node_idx])) + dd_cluster = np.array(dd_cluster) + # Get log binning + dd_cluster_bins, dd_cluster_vals = logbin_fxn(np.sort(np.unique(degree_sequence)),dd_cluster,bins=bins) + to_ret.append(dd_cluster) + to_ret.append(dd_cluster_bins) + to_ret.append(dd_cluster_vals) + + return tuple(to_ret) \ No newline at end of file diff --git a/netrw/rewire/dk_rewiring.py b/netrw/rewire/dk_rewiring.py index 0fa8a17..2c2ad78 100644 --- a/netrw/rewire/dk_rewiring.py +++ b/netrw/rewire/dk_rewiring.py @@ -1,9 +1,10 @@ -from .base import BaseRewirer +from base import BaseRewirer import networkx as nx import warnings import copy import random + class DkRewire(BaseRewirer): """ Rewires a given network such that its "d"k-distribution is preserved. @@ -14,7 +15,17 @@ class DkRewire(BaseRewirer): Orsini, C. et al. Quantifying randomness in real networks. Nat. Commun. 6:8627 doi: 10.1038/ncomms9627 (2015). """ - def step_rewire(self,G,d,copy_graph=False,timesteps=1,tries=1000,directed=False,verbose=False): + + def step_rewire( + self, + G, + d, + copy_graph=False, + timesteps=1, + tries=1000, + directed=False, + verbose=False, + ): """ This function calls the necessary function to rewire such that the 'd'k-distribution is preserved for given d. This function is implemented @@ -42,18 +53,24 @@ def step_rewire(self,G,d,copy_graph=False,timesteps=1,tries=1000,directed=False, # Check that graph is undirected if nx.is_directed(G): if directed: - warnings.warn("This algorithm is designed for undirected graphs. The graph input is directed and will be formatted to an undirected graph.", - SyntaxWarning) + warnings.warn( + "This algorithm is designed for undirected graphs. The graph input is directed and will be formatted to an undirected graph.", + SyntaxWarning, + ) + print(nx.is_frozen(G)) G = nx.to_undirected(G) + print(nx.is_frozen(G)) else: - raise ValueError("This algorithm is designed for undirected graphs. If you wish to run anyway as an undirected graph, set directed=True") + raise ValueError( + "This algorithm is designed for undirected graphs. If you wish to run anyway as an undirected graph, set directed=True" + ) # Make copy if necessary if copy_graph: G = copy.deepcopy(G) m = len(G.edges()) - n = len(G.nodess()) + n = len(G.nodes()) # Check for empty graph if len(G.edges()) == 0: @@ -61,36 +78,36 @@ def step_rewire(self,G,d,copy_graph=False,timesteps=1,tries=1000,directed=False, return G # Check for complete graph - if m == int(n*(n-1)/2): + if m == int(n * (n - 1) / 2): + warnings.warn("No edge swaps performed on complete graph.") return G # Calculate 0k-swap if d == 0: - self.zero_k_swap(G,timesteps,verbose) + return self.zero_k_swap(G, timesteps, verbose) # Calculate 1k-swap elif d == 1: - self.one_k_swap(G,timesteps,tries,verbose) + return self.one_k_swap(G, timesteps, tries, verbose) # Calculate 2k-swap elif d == 2: - self.two_k_swap(G,timesteps,tries,verbose) + return self.two_k_swap(G, timesteps, tries, verbose) # Calculate 2.1k-swap elif d == 2.1: - self.two_one_k_swap(G,timesteps,tries,verbose) + return self.two_one_k_swap(G, timesteps, tries, verbose) # Calculate 2.5k-swap elif d == 2.5: - self.two_five_k_swap(G,timesteps,tries,verbose) + return self.two_five_k_swap(G, timesteps, tries, verbose) else: raise ValueError("d must be 0, 1, 2, 2.1, or 2.5") - pass - def zero_k_swap(self,G,timesteps,verbose): + def zero_k_swap(self, G, timesteps, verbose): """ Rewires one edge to a random node. This maintains the average degree of the network. At each timestep, a random edge is chosen and a random end of the edge is chosen. @@ -117,11 +134,11 @@ def zero_k_swap(self,G,timesteps,verbose): # Edge swap for each time step for t in range(timesteps): # Choose a random edge - edge = random.choice(G.edges()) + edge = random.choice(list(G.edges())) # Choose a random end of the edge - end_of_edge = random.choice([0,1]) - not_end_of_edge = abs(end_of_edge-1) + end_of_edge = random.choice([0, 1]) + not_end_of_edge = abs(end_of_edge - 1) # Choose a random node nodes_to_choose = list(G.nodes()) @@ -131,18 +148,18 @@ def zero_k_swap(self,G,timesteps,verbose): # If verbose, store edges if verbose: removed_edges[t] = [edge] - added_edges[t] = [(edge[not_end_of_edge],node)] + added_edges[t] = [(edge[not_end_of_edge], node)] # Update network - G.remove_edge(edge[0],edge[1]) - G.add_edge(edge[not_end_of_edge],node) + G.remove_edge(edge[0], edge[1]) + G.add_edge(edge[not_end_of_edge], node) if verbose: return G, removed_edges, added_edges else: return G - def one_k_swap(self,G,timesteps,tries,verbose): + def one_k_swap(self, G, timesteps, tries, verbose): """ Rewires an edge while maintaining the degree distribution of the network. A swap is done such that if edges (u,v) and (x,y) are selected, the new edges are (u,x) and (v,y) @@ -177,40 +194,51 @@ def one_k_swap(self,G,timesteps,tries,verbose): old_edge_1 = random.choice(edges) old_edge_2 = random.choice(edges) - if .5 < np.random.random(seed=seed) + if 0.5 < random.random() or old_edge_1[0] == old_edge_2[1] or old_edge_1[1]==old_edge_2[0]: # Swap edges - new_edge_1 = (old_edge_1[0],old_edge_2[0]) - new_edge_2 = (old_edge_1[1],old_edge_2[1]) + new_edge_1 = (old_edge_1[0], old_edge_2[0]) + new_edge_2 = (old_edge_1[1], old_edge_2[1]) # Check for valid edges - if new_edge_1 in list(G.edges()) or new_edge_2 not in list(G.edges()): + if new_edge_1[0] == new_edge_1[1] or new_edge_2[0] == new_edge_2[0]: + break + + if new_edge_1 not in list(G.edges()) and new_edge_2 not in list( + G.edges() + ): valid = True break else: - new_edge_1 = (old_edge_1[0],old_edge_2[1]) - new_edge_2 = (old_edge_1[1],old_edge_2[0]) + new_edge_1 = (old_edge_1[0], old_edge_2[1]) + new_edge_2 = (old_edge_1[1], old_edge_2[0]) # Check for valid edges - if new_edge_1 in list(G.edges()) or new_edge_2 not in list(G.edges()): + if new_edge_1[0] == new_edge_1[1] or new_edge_2[0] == new_edge_2[0]: + break + if new_edge_1 not in list(G.edges()) and new_edge_2 not in list( + G.edges() + ): valid = True break # Check that tries was not maximized if valid is False: - warnings.warn("No pair of edges was found with new edges that did not exist in tries allotted. Switch was not made at this timestep.") + warnings.warn( + "No pair of edges was found with new edges that did not exist in tries allotted. Switch was not made at this timestep." + ) # Store edges if verbose if verbose: - removed_edges[t] = [old_edge_1,old_edge_2] - added_edges[t] = [new_edge_1,new_edge_2] + removed_edges[t] = [old_edge_1, old_edge_2] + added_edges[t] = [new_edge_1, new_edge_2] # Update network - G.remove_edges_from([old_edge_1,old_edge_2]) - G.add_edges_from([new_edge_1,new_edge_2]) + G.remove_edges_from([old_edge_1, old_edge_2]) + G.add_edges_from([new_edge_1, new_edge_2]) return G - def two_k_swap(self,G,timesteps,tries,verbose): + def two_k_swap(self, G, timesteps, tries, verbose): """ Rewires an edge while maintaining the joint degree distribution of the network. A swap is done by selecting a random edge end. A second edge end is then chosen @@ -240,6 +268,11 @@ def two_k_swap(self,G,timesteps,tries,verbose): for t in range(timesteps): # Check that swap occurs valid = False + edges = G.edges() for _ in range(tries): # Choose an edge end at random - + edge = random.choice(edges) + edge_end = edge[random.choice([0, 1])] + + # Get degree of node + edge_deg = G.degree(edge_end) diff --git a/netrw/rewire/test.ipynb b/netrw/rewire/test.ipynb new file mode 100644 index 0000000..7193222 --- /dev/null +++ b/netrw/rewire/test.ipynb @@ -0,0 +1,293 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 3, + "id": "9c8c7465", + "metadata": {}, + "outputs": [], + "source": [ + "import networkx as nx\n", + "from dk_rewiring import DkRewire\n", + "import matplotlib.pyplot as plt\n", + "from distribution_analysis import graph_distributions\n", + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "0ee784a7", + "metadata": {}, + "outputs": [], + "source": [ + "def full_test(test=None):\n", + " if test is None:\n", + " test = ['undirected','directed','disconnected','empty','complete','verbose','copy','full']\n", + " for t in test:\n", + " if t == 'undirected':\n", + " # Generate GNP graph\n", + " G = nx.gnp_random_graph(10,.5)\n", + " \n", + " # Rewire for each distribution type\n", + " obj = DkRewire()\n", + " zero_G = obj.step_rewire(G,d=0)\n", + " one_G = obj.step_rewire(G,d=1)\n", + "# two_G = obj.step_rewire(G,d=2)\n", + "# two_one_G = obj.step_rewire(G,d=2.1)\n", + "# two_five_G = obj.step_rewire(G,d=2.5)\n", + " # Plot the rewirings\n", + " fig = plt.figure(figsize=(10,10))\n", + " plt.subplot(321)\n", + " nx.draw(G,with_labels=True)\n", + " plt.subplot(322)\n", + " nx.draw(zero_G,with_labels=True)\n", + " plt.subplot(323)\n", + " nx.draw(one_G,with_labels=True)\n", + " plt.subplot(324)\n", + "# nx.draw(two_G,with_labels=True)\n", + "# plt.subplot(325)\n", + "# nx.draw(two_one_G,with_labels=True)\n", + "# plt.subplot(326)\n", + "# nx.draw(two_five_G,with_labels=True)\n", + " plt.title('Undirected Test')\n", + " plt.show()\n", + " \n", + " elif t == 'directed':\n", + " try:\n", + " # Generate directed GNP\n", + " G = nx.fast_gnp_random_graph(100,.3,directed=True)\n", + " \n", + " # Force directed error\n", + " obj = DkRewire()\n", + " new_G = obj.step_rewire(G,d=0)\n", + " except ValueError as e:\n", + " # Catch directed error\n", + " print(e)\n", + " G = nx.gnp_random_graph(100,.3)\n", + " G = nx.to_directed(G)\n", + " \n", + " # Force rewiring\n", + " obj = DkRewire()\n", + " zero_G = obj.step_rewire(G,d=0,directed=True)\n", + " one_G = obj.step_rewire(G,d=1,directed=True)\n", + " two_G = obj.step_rewire(G,d=2,directed=True)\n", + " two_one_G = obj.step_rewire(G,d=2.1,directed=True)\n", + " two_five_G = obj.step_rewire(G,d=2.5,directed=True)\n", + " \n", + " elif t == 'disconnected':\n", + " try:\n", + " # Create disconnected graph\n", + " G = nx.Graph()\n", + " G.add_edges_from([[0,1],[1,2],[2,0],[3,4],[4,5],[5,3]])\n", + " # Force disconnected error\n", + " obj = DkRewire()\n", + " new_G = obj.step_rewire(G,d=0)\n", + " except ValueError as e:\n", + " print(e)\n", + " \n", + " elif t == 'empty':\n", + " try:\n", + " # Generate empty graph\n", + " G = nx.Graph()\n", + " obj = DkRewire()\n", + " new_G = obj.step_rewire(d=0)\n", + " except ValueError as e:\n", + " print(e)\n", + " \n", + " elif t == 'complete':\n", + " try:\n", + " # Generate complete graph\n", + " G = nx.complete_graph(100)\n", + " obj = DkRewire()\n", + " new_G = obj.step_rewire(d=0)\n", + " except ValueError as e:\n", + " print(e)\n", + " \n", + " elif t == 'verbose':\n", + " # Check verbose argument\n", + " G = nx.gnp_random_graph(100,.3)\n", + " obj = DkRewire()\n", + " new_G, removed_edges, added_edges = obj.step_rewire(d=0)\n", + " print(removed_edges, added_edges)\n", + " \n", + " elif t == 'copy':\n", + " # Check copy argument\n", + " G = nx.gnp_random_graph(100,.3)\n", + " obj = DkRewire()\n", + " new_G = obj.step_rewire(d=0,copy_graph=True)\n", + " \n", + " # Plot networks\n", + " plt.subplot(121)\n", + " nx.draw(G,with_labels=True)\n", + " plt.subplot(122)\n", + " nx.draw(new_G,with_labels=True)\n", + " plt.show()\n", + " \n", + " else:\n", + " # Check full rewire\n", + " # Generate GNP graph\n", + " G = nx.gnp_random_graph(100,.3)\n", + " \n", + " # Rewire for each distribution type\n", + " obj = DkRewire()\n", + "# zero_G = obj.full_rewire(G,d=0)\n", + "# one_G = obj.full_rewire(G,d=1)\n", + "# # two_G = obj.full_rewire(G,d=2)\n", + "# # two_one_G = obj.full_rewire(G,d=2.1)\n", + "# # two_five_G = obj.full_rewire(G,d=2.5)\n", + " \n", + "# # Plot the rewirings\n", + "# plt.subplot(321)\n", + "# nx.draw(G,with_labels=True)\n", + "# plt.subplot(322)\n", + "# nx.draw(zero_G,with_labels=True)\n", + "# plt.subplot(323)\n", + "# nx.draw(one_G,with_labels=True)\n", + "# plt.subplot(324)\n", + "# # nx.draw(two_G,with_labels=True)\n", + "# # plt.subplot(325)\n", + "# # nx.draw(two_one_G,with_labels=True)\n", + "# # plt.subplot(326)\n", + "# # nx.draw(two_five_G,with_labels=True)\n", + "# plt.title('Full Rewire')\n", + "# plt.show()\n", + " \n", + " \n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "aaff5d30", + "metadata": {}, + "outputs": [], + "source": [ + "def check_0_swap(G):\n", + " obj = DkRewire()\n", + " new_G = obj.step_rewire(G,0)\n", + " m_g = len(G.edges())\n", + " n_g = len(G.nodes())\n", + " m_new_g = len(new_G.edges())\n", + " n_new_g = len(new_G.nodes())\n", + " print(f\"G: {2*m_g/n_g}\")\n", + " print(f\"New G: {2*m_new_g/n_new_g}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "ea21b945", + "metadata": {}, + "outputs": [], + "source": [ + "def check_1_swap(G):\n", + " obj = DkRewire()\n", + " new_G = obj.step_rewire(G,1)\n", + " deg_dist = graph_distributions(G,avg_nn_dist=False,dd_clustering=False)\n", + " new_deg_dist = graph_distributions(G,avg_nn_dist=False,dd_clustering=False)\n", + " return np.allclose(deg_dist[0][0],new_deg_dist[0][0]), np.allclose(deg_dist[0][1],new_deg_dist[0][1]), np.allclose(deg_dist[1][0],new_deg_dist[1][0]), np.allclose(deg_dist[1][1],new_deg_dist[1][1])" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "9a9a8273", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkQAAAF/CAYAAACotdapAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAC64ElEQVR4nOzdd3zN1//A8ddNbiKIJESsJGZIIoi9Z22CIlbFJhQtWjVKKYou9aWo0aJmbUqN2puaQYaImYREhkwZd3x+f/jlVnqzc29uxnk+HvfR5t7P53zeN3Lvfd8z3kcmSZKEIAiCIAhCEWZk6AAEQRAEQRAMTSREgiAIgiAUeSIhEgRBEAShyBMJkSAIgiAIRZ5IiARBEARBKPJEQiQIgiAIQpEnEiJBEARBEIo8kRAJgiAIglDkiYRIEARBEIQiTyREgiAIgiAUeSIhEgRBEAShyJMbOgBByEvhcUnsvRWEX0gMMYlKLMzkOFWwYEAjO6zNixk6PEEQ0iFeu4K+ycTmrkJR4BUYxepzAZz3DwMgSanWPGYmN0IC2jvaMLGdA672VoYJUhAELeK1K+QVkRAJhd62a89YfNSPRKWKjP7aZTIwkxszp4cTHs2r5ll8giCkTbx2hbwkEiKhUHv3hupLgkKd+cH/r7iJEXN6OIs3VkEwIPHaFfKaSIiEQssrMIrBG66RoFClul+VEEvE0RUkPruDUXELSrcbQUmX9qmOKW5izC7P5tSzs8q7gAVBANJ+7UpKBRF/ryHx2V3UiXHIrSpSut1witdonOpc8doVckqsMhMKrdXnAkhUqrTuj/z7F2TGJth9so2yvaYT8fcaksOepzomUalizbmAvApVEIT3pPXaldQq5KXKUuGjb7Gftgurth6EHfoOZVRoquPEa1fIKbHKTCiUwuOSOO8fpjXvQJ2cyNuHV6g0djVGpsUxs3ehhEMz4r3PYtp+pOY4SYKzD8OIiEsSK1gEIQ+l99o1MjXDqs1Qzc8lHJoityxPUkgAcqvymvsL02tXrKzLWyIhEgqlvbeC0rxfGRmMzMgIkzK2mvtMylUj6cV9rWNlwN7bQYxvW0NfYQqC8B/pvXb/SxX/BkVkMKY2lbUeK+iv3YxX1oWw/JS/WFmnByIhEgolv5CYVG8iKdSKBGTFSqS6z6hYCdTJCVrHJirV+L2K1VuMgiBoS++1+z5JpST8zx8xr9sRE2t7rccL8ms3s5V1if//u/nbJ5QL/uFiZZ0OiYRIKJRiEpVp3m9kUhwpKXXyIyW9xci0eDrtKHQemyAI6UvvtZtCktSEH1kGxnLKdJ6Q7nHXbnvxv1fnsLOzw9bWFjs7OypWrIhcnn8/9rKzsk6SIEGhYvFRXwCRFOlA/v3LEIRcsDBL+09bXsYWSa1CERmsGTZLfv0UE5sq6bRjorcYBUHQlt5rF0CSJCKOrkQVH0W5AV8jM07/2FJmxjx58oSLFy8SFBREcHAwr1+/pmzZspoE6b//Tfn/EiVKpNuuvngFRrH4qF+ayVC8z3miLu9EFROGccnSWPecipl9HQASFGoWH/Wjnp2VWFmXSyIhEgolpwoWFJOHaHW9G5maUcKxBVEXt2Pd/VOSXz/hbcB1Knj8oNWGmdwIp4ql8ipkQRBI/7ULEHliNYqIQMoP/gYjk/QnFZvJjejfsQXj23qkul+pVBIaGqpJkFL+e//+/VQ/Fy9ePN2kKeW/pUuXRiaT6ex5p7cqNuHpHd6c24xNn5mYVqqFKi5S65iUlXVrPRprPSZknahDJBRK4XFJtPruTJpvqlmpQwRQTG7ElZkfiNUcgpCH0nvtKqNfE/zLaDA2QWZkrLm/TLdJmLt0SHVsbl67kiQRGRmZKkFK679JSUnY2tpmmDhVqFABY2PjTK+Z0ftVyNbplKzXhVKuXTJsQ7xf5Z7oIRIKpbLmxWhXy4aTPiFIpP4WZ1y8FOX6z83wfJkMOjjaiDcXQchjmteub2iqScVyy3JUmXUk0/Nl5O61K5PJsLa2xtramnr16qV7XHx8PMHBwakSpYcPH3L69GnNfREREZQrVy7DniZbW1v23gpO8xqSWkXSqwCKOzQjeO04JFUyJWo2x6rDaK0esoK+si4/EAmRUCgpFAoSbh5AMm0MctNsn28mN2Ziewc9RCYIQmYmtXfg4qNwrSrzWaFWJtHGOlEPUaVWsmRJatWqRa1atdI9RqFQ8OrVK63epTt37mh+Dg4OpmyvzzGp2UrrfFV8FKiVvH14mfIe3yEzMiZs3zdEX9lF6XbDUx1bkFfW5RciIRIKnZCQEAYMGICVlRVffubB8rPPcrAfkpOYoCgIBuJqb8WcHk452svMrZoJn43sT9js2UyZMkWn83yyy8TEhMqVK1O5snatpBSSJDHs1ytcehKl9Zjs/3uBSjXqhdy8zLv/b/JhmgkRiFWxuSW27hAKlatXr9KkSRM6derEoUOH8OzgzJwezhQ3MSaz90WZ7N0+SGJzSEEwPI/mVZnTwxk5apAyToref+3+4NmLa9eusX37dvr3709UVFTeBJxDMpmMshZpr2ozNjPHuFTZLLclVsXmjkiIhEJBkiTWrVtHnz59+OWXX5g/fz5GRu/+vD2aV2WXZ3O61i5PMbkRZvLUf/amRiApk+nkaMMuz+YiGRKEfKJ37TLEHVpEyyrmab52zeRGFJMb0bV2+VSv3WrVqnHp0iVsbW1p1KgRt2/fNkD0WfduZV3aH8fmdTsRe+sIqvgoVIlxxN48RAmHJlrHiVWxuSdWmQkFXmJiIpMnT+batWscOHCAmjVrpntsRFwSe28H4fcqlphEBdcvnqVb87r8s+tnpkwYQ//+/fMwckEQMrJ48WJ8fX3Ztm2b1mvXwswEp4qlcG+Y8b5eu3fvZvLkySxcuJDx48cbdAgtPRmtMpNUSiJPrSfe5zwyuQklndpQusMoZP+ZGylWmeWeSIiEAi0wMJD+/ftTtWpVNm7ciLm5ebbOnzhxIk5OTlhYWLB//37+/PNPPUUqCEJ2REdH4+DgwOXLlzOcuJwV/v7+DBgwgDp16rBu3bpsv0/kBc+tN7VW1mWVTAZda5cXdYhySQyZCQXWuXPnaNq0KQMGDGDXrl05epNzcnLC19eX/v37c+HCBV6/fq2HSAVByK4VK1bQo0ePXCdDALVq1eLatWsUL16cJk2a8ODBAx1EqFuT2jtgJs+8ZlFaxKpY3RAJkVDgSJLE8uXLGTx4MFu3buWLL77IcTe4s7Mzfn5+lCpVit69e7Njxw4dRysIQna9efOGlStX8tVXX+mszeLFi/Prr78ye/ZsOnTowO+//66ztnUhZWVdcZPsfSyLVbG6I4bMhALl7du3jBs3Dl9fX/bv30/VqlVz1V5QUBCNGzcmJCSE06dPM336dO7cuaObYAVByJF58+YRHBzMb7/9ppf2vb29cXd3p2XLlvz8888G2bssPduuPWPRER8SFSpkRuknRzLZu54hsdu97ogeIqHAePLkCS1atEAul3P58uVcJ0MAtra2vH37ljdv3tChQwciIiK4d+9e7oMVBCFHIiIiWL16NXPnZlxNPjdcXFy4ceMGiYmJNG/enIcPH+rtWtnl0bwqlR/tQ/X8VrZW1gm5JxIioUA4fvw4LVq0YNy4cWzevJnixYvrpF2ZTKaZR2RkZMSwYcPyXVe6IBQly5Ytw93dnWrVqun1Oubm5mzbto3JkyfTunVrdu3apdfrZVVoaCjnD2xlkmsxrsz8gGmda9G3vi0dncrRt74t0zrX4srMD1jr0VgMk+mYGDIT8jVJkli6dCmrV6/mjz/+oE2bNjq/xvDhw2nfvj2jR4/m4cOHtGvXjsDAQExMRJEzQchL4eHhODo6cufOnQyrO+vanTt3GDBgAN26dWPZsmUUK2a4petTpkxh3bp1vH79GgsLC4PFURSJHiIh34qJiaF///4cPnyYf/75Ry/JELybWO3r6wuAo6Mj1apV48SJE3q5liAI6fvhhx8YNGhQniZDAA0aNODWrVu8evWKVq1a8fTp0zy9forY2Fg2bNiAu7u7SIYMQCREQr7k5+dHs2bNKF++POfOncPW1lZv13o/IQIYMWKEGDYThDwWGhrKr7/+ypdffmmQ61taWrJ3716GDRtGs2bNOHToUJ7H8MsvvyBJksF+B0WdGDIT8p2DBw/i6enJt99+y+jRo/V+vYcPH9KjRw8eP34MvFvyW7VqVZ4+fUqZMmX0fn1BEODzzz9HoVCwcuVKQ4fCtWvXGDRoEAMGDGDp0qV5MnyenJxMxYoVqV69Ojdu3ND79QRtoodIyDdUKhVz587l008/5a+//sqTZAigevXqBAcHk5CQAEDp0qXp1q1bvplkKQiF3atXr9i0aROzZs0ydCgANG/enNu3b+Pr60v79u0JCgrS+zV37tyJSqUSvUMGJBIiIV948+YNbm5uXL58mZs3b9KkifbmhfpiYmJC9erVefTokeY+MWwmCHnnu+++Y8SIEVSqVMnQoWhYW1tz+PBhevfuTePGjTl+/LjerqVWq1m4cCGmpqb06tVLb9cRMiYSIsHg7t27R5MmTXB2dubkyZOUK1cuz2P47zyiLl268Pz583xVn0QQCqPg4GC2bNnCzJkzDR2KFiMjI2bOnMnu3bsZO3YsX331FSqVKlttBAQE8MUXX1CtWjVkMhkymYwKFSrw0UcfceHCBSRJ4ujRo0RHRzNlyhTkcrmeno2QGZEQCQb1xx9/0LFjRxYuXMhPP/1ksDeD/yZEcrmcoUOHil4iQdCzpUuXMmbMGCpUqGDoUNLVtm1bbt26xdWrV+ncuTMhISGZnqNQKPDw8KBly5bIZDKOHDlCTEwM8fHx3Lhxg6ZNm+Lp6UmjRo2YP38+CQkJjBs3Lg+ejZAeMalaMAilUsnMmTM5ePAg+/fvx9XV1aDxbNu2jcOHD6eaN3T//n169OjBs2fPMDbO2aaLgiCk78WLFzRo0AA/Pz9sbGwMHU6mVCoVixYtYsOGDWzfvp327dune9ywYcOIjo5m79696RaSlSSJCRMm8Ntvv/Hhhx+yd+9ePUYvZMbgfXPhcUnsvRWEX0gMMYlKLMzkOFWwYEAjO6zNDVccS9CfsLAwBg0ahKmpKTdu3MgXK7mcnZ354YcfUt1Xt25dbGxsOHv2LJ06dTJQZIJQeC1ZsgRPT88CkQwBGBsb8/XXX9OqVSuGDBnCJ598wqxZszD6z55jP/30E8HBwRw/fjzDqvoymYyQkBBMTEx4+fKlvsMXMmGwHiKvwChWnwvgvH8YAElKteYxM7kREtDe0YaJ7RxwtbcyRIiCHty4cQN3d3eGDRvGggUL8k3PS3x8PDY2NsTGxqaKacWKFdy8eZOtW7caMDpBKHyePXtGo0aN8Pf3x9ra2tDhZFtwcDCDBw/G3NycrVu3UrZsWeBdr0/NmjXZsWMHTZs2zbANX19fWrZsSZUqVQgKCuLmzZs62aNRyBmDJETbrj1j8VE/EpUqMrq62M23cNm4cSOzZs1i3bp19O3b19DhaKlSpQpnzpyhRo0amvvCwsKoWbMmgYGBlCpVyoDRCULhMm7cOMqXL88333xj6FByTKFQMHfuXHbu3Mkff/xBy5YtuXz5Mp6enjx48ACZTAakPxJyeeuPXDt/irlz53Ljxg3Kly/PV199ZeBnVXTl+ZDZu2TIlwSFOtNjJQkSFCoWH3032VUkRQVTcnIyU6ZM4ezZs1y4cAEnJydDh5SmlInV7ydENjY2tGvXjr179zJq1CgDRicIhcfjx485cOAA/v7+hg4lV0xMTPjuu+9o3bo1ffv2ZebMmVSoUIF69eohk8kyHAkpZvyKxNJdUDWqQO3W3UlOTuaff/4x1FMRyOOEyCswisVH/dJMhuJ9zhN1eSeqmDCMS5bGuudUzOzrAJCgULP4qB/17KzE7r4FzMuXL3F3d6d8+fL8888/+Xp/HicnJ/z8/HBzc0t1/4gRI1i5cqVIiARBR7755hsmT56cL+YP6kKvXr24fv06AwcORJIkKleunOlISJJKQiY3RV6tEcN/v007ixJ5H7iQSp4mRKvPBZCo1K7hkPD0Dm/Obcamz0xMK9VCFRepdUyiUsWacwGs9WicF6EKOnDp0iUGDRrExIkTmT17ttbEw/zG2dk5zW9oPXv2ZPz48Tx9+pRq1aoZIDJBKDwePXrEkSNHUhVCLQyqVq3KpUuXcHd358wLBfePeJP8/x93L5a5pzpWUiZTqkEPynSZAMhIUKg4GVGKelbOeR+4oJFnCVF4XBLn/cPSzJSjL23HstUQitm+G0qRlyqrdYwkwdmHYUTEJYnVZ/mcJEmsXr2aRYsWsXnzZrp3727okLLE2dk5zbpDxYoVY9CgQazfspMq7QeJFZGCkAuLFi3i008/xcrKytCh6JypqSlf/e9X3Ndc0iRDAJU//3c5vTo5kaCfPSjh1DrVuSqM8S7myL2gKDESYiB5lhDtvZX2XjCSWkXSqwCKOzQjeO04JFUyJWo2x6rDaIxMUn/IyIC9t4MY37ZGmm0JhpeQkMCECRO4c+cOV65cSTUfJ79LmUMkSZJmMiS8G+p9XasPR4LiKXbK/z8rIkNYfspfrIgUhCzw8/Pj+PHjrFq1ytCh6M2Gyy+QydPfDPbtw8sYl7CkmL2L1mMKNWIkxIDybAzDLyQm1QdJClV8FKiVvH14mfIe31Fx1EqSQ58QfUV7Y81EpRq/V7F5EK2QE8+fP6d169YoFAquXr1aoJIhgLJly2JkZERoaKjmvm3XnjF4wzVuhCSDsYnW33CiUk2SUs3fPqEM3nCNbdee5XHUglBwLFy4kGnTpuXruYS5kTISgiz9j9a4+6cpWeeDVF+6Urw/EiLkvTxLiGISlWneL/v/XqBSjXohNy+DcQlLSjX5kITHN9NpR6G3GIWcO3XqFM2aNcPDw4Pt27dTsmRJQ4eUbTKZDGdnZ/z8/ID3V0RmXB4CUq+IFEmRIGjz9vbm9OnTTJ482dCh6E16IyEplNGvSQp8QMm6HdM9JmUkRMh7eTZkZmGW9qWMzcwxTmPOUHqCnj7izJlYGjRoQOnSpXUVnpBDkiTx448/8tNPP7Fz5046dOhg6JByJWXYrHSN+mmuiAw//COJz7xQKxIxLlkai+b9KeXaVfO4WBEpCGlbsGAB06dPL9T1vNIbCUkR9+AMxexqY2KV/r5tYiTEcPIsIXKqYEExeUiafyzmdTsRe+sIxas3AmM5sTcPUcKhidZxcpkao5hXzJu3Bi8vL6ytrWnQoEGqm62tbZpdkYLuxcXFMXr0aJ4+fco///yDvb29oUPKtZSE6I552isiLZoPwLr7FGRyExQRgYTsmI1p+RoUq+CgOUasiBSE1O7fv8+FCxfYtGmToUPRq/RGQlLEPziDZXP3DI95144YCTGEPEuI3BvZsfxU2kW4LFsNRpUQQ/D68cjkJpR0aoNly0Faxxkby9m2cDLW5p+jVqsJCAjgzp073Llzh1WrVnHnzh0kSaJ+/fqpkqSaNWvmmy0iCotHjx7Rt29fmjVrxsWLFzEzMzN0SDrh5OTE4ZPneGmZ9opIU5sq7/0kQ4YM5ZtXqRIisSJSEFL7+uuvmTFjRoEcSs+qsLAwIl4FAmm/5hODfFHFRWitLkuLhVn6k7IF/cmzhKiseTHa1bLhpG+o1geNzFiOddeJWHedmO75Mhl0cLTRfMAYGRlRq1YtatWqxaBB75InSZJ4+fIld+/e5c6dO+zdu5c5c+bw+vVr6tWrlypJqlOnDsWKiQ+rnDhy5AijR49m4cKFjB8/vlD1yDk7O/NYXZb0t2OEiBNriL9/GkmZhGn5GhSvod0TJFZECsI7d+7c4erVq4VuP0ClUsk///zD8ePHOXbsGP7+/tTuPwV5+SYo05ieG//gNCVqtcSoWMYFGI1RU7FE5js5CLqXp3uZeQVGMXjDNRIU2kMRmSluYswuz+Y5mpcRFRWlSZJSbgEBAdSqVUuTINWvX5/69etjaWmZ7faLCrVazaJFi9iwYQN79uyhRYsWhg5J59RqNZX6z8bMqW2Gx0lqFUnBfiS+uI9lc3dkxtrfLfrWt2X5oPp6ilQQCoY+ffrQsWNHPv30U0OHkmuvXr3ixIkTHDt2jJMnT2Jvb0+3bt3o3r07LVu2JCZZotV3ZzKcR5QZI0lF9JZPaNXYlXHjxtG9e3fk8jzfZatIyvPNXbOzl1mK4iZGzOnhrNO9zBISEnjw4EGqJOn+/ftUqFBBa15SxYoVdXbdgio6Opphw4YRGRnJnj17CvXvxGHMMpTlsrbfWsTxVZiUrYxF495aj3V0KsdvI7TnwglCUXHz5k0+/PBDAgICCuSwukKh4MqVKxw/fpzjx4/z7NkzOnXqRPfu3enatSu2trZa53huvZnmSEhWyGTQtXZ5lvV1ZteuXWzYsIHAwEDGjBnDmDFjqFy5sg6elZCe/L3bPaBWJDGpZUVm9NN/b4RKpcLf3z9VknTnzh1MTEy0kqTq1avn+60odMXb25u+ffvStWtXli1bhqmpqaFDyjVJkoiMjCQgIEDr9qR8G4o7t8tSOxFHVyIzKUaZzuO1HhM9REJR5+bmRvfu3Zk0aZKhQ8mywMBAzTDYmTNncHBw0PQCNWvWLNPeGl2PhNy7d48NGzawY8cOmjVrhqenJz179sTERMwz0jWDJEQA94KiWHMugLMPw1AkJ6M2+vePzExuhMS7OUNV4h+yadkCbty4YZDhLEmSCAwM1EqSoqOjcXV1TTWBu3bt2oUiWXjf3r17+fjjj/nxxx8ZMWKEocPJFkmSeP36dZpJT0BAAJIk4eDgoHX77s/b+BhXRUXqifiq+CgSn3tR3KEpMrkpic/uEnZgCWV7fUGJWs1THWsmN2Ja51piDpFQZF2/fp0BAwbw6NGjfD1fMykpiYsXL2qSoNDQULp06UL37t3p0qUL5cuXz3ab+hgJefv2LXv37mXDhg08fvyYUaNGMXbsWLG/og4ZLCFKERGXRGfPr6jVrAMlrcpiYWaCU8VSuDf8d3+oSZMmERwczP79+/NNr0xERESqBOnu3bs8e/YMJyenVD1Jrq6umJubGzpc4F0V1b23grK0F5dKpWLOnDn88ccf7N+/n4YNGxoo6oyp1WpevXqVbtJTrFixNJMeBwcHrK2t05wQvmnHHhZ6mSIZpf4mqHobTdiBpSS/fgqSGrllOUo16kWp+t202igmN+LKzA/EKjOhyOrWrRt9+/Zl/Hjt3lNDe/LkiSYBOn/+PC4uLnTr1o1u3brRuHFjnaxKThkJSVAoeTfekTaZDMzkxszp4ZTlaSE+Pj5s2LCBbdu20aBBAzw9Pendu3eh+0Ke1wyeEAHUqlWLw4cP4+jomObjycnJtGvXjl69evHll1/mcXRZFx8fz/3791MlSt7e3tjb22sNudnY2ORZXF6BUaw+F/CupDz8Zy+ud71x7+/FFRERweDBg5EkiT/++IOyZbNeOFMfVCoVgYGBaQ9vPXmCpaVlqkSnRo0amv/mpHjngwcP6P3DEaRKdcnJiyNlHoCoQyQUVZcvX2bo0KH4+/vniw/phIQEzp8/z7Fjxzh+/DjR0dF07dqV7t2707lzZ6ytrfVyXa/AN/Sbuw5lOUeKmZqS/F6H0fsjIRPbO+RowVBiYiL79+9n/fr1+Pn5MWLECMaOHUvNmjV19hyKEoMnRJIkUbJkSV6/fp1hT0pwcDBNmjRh8+bNdOnSJQ8jzB2FQoGfn59Wb5K5ublWvaSqVavqfAl7ludr/f+3lOF1zVk/YxgDBgxgyZIleba6QaFQ8Pz58zSTnmfPnmFjY5NmL0/16tV1Xvk2KSmJMg4NKDv4G2Ty7Pfw5GZFpCAUBp06dWLIkCGMGTPGINeXJAl/f3/NZOhLly7RoEEDzVwgV1fXPBltuHbtGv3796dCFQc8v92I36tYYhIVaY6E5NbDhw/59ddf+f3336lTpw6enp707ds3Xw9X5jcGT4giIyOpUaMGb968yfTYc+fOMXjwYK5fv06VKlUyPT6/kiSJp0+fpkqQ7ty5w9u3b7WSJCcnpxwnJWmNY4dsn0XSy4fIjN51CRuXssbWc92/sSmS6FcNlk/ql7snmYakpCSePn2aZtITGBhIpUqV0k16ihfPqDKQ7kiSxJo1a5gyZQqjFm/kUryNwVdECkJBcuHCBUaNGoWfn1+eTvyNi4vj7Nmzml6g5ORkTQLUsWNHrKys8iyWFGPHjuXChQvMmTMnz+ZgJiUlcejQIdavX8+9e/cYNmwY48aNw8kpaytnizKDJ0ReXl54eHhw//79LB2/bNkydu7cyaVLlwrkMs6MhIaGatVLCg4OxsXFJVWSVLduXUqUyLi4V3orHUK2z6JknQ6p9t/6r9z0cLx9+5YnT56kmfS8evWKypUrp5n0VK1a1eDfZN6+fcuECRO4e/cuNjY2TJo0ibeVGmaphw21GrNicuaKZEgo4jp06MCIESMYOXKkXq8jSRLe3t6aXqDr16/TpEkTunfvTrdu3ahTp45Bi8bGxsZiZ2eHiYkJQUFBBvm8evz4Mb/++iubNm2iVq1aeHp60r9//zz7glnQGDwh+uuvv1i1ahXHjh3L0vGSJDFo0CAsLS3ZsGGDnqMzvNjYWLy8vFIlSX5+flSrVk1rXlKZMmU056VXCyMrCVFmc2BiY2N5/PhxmklPeHg41apVSzPpqVy5cr5dKvrkyRP69euHi4sL69evZ+HChVhYWDBnzpxUKyKTk5OQjP59DinzAEzD/XGrbsrSLz423JMQhDyS3gKNionPmT55PL6+vnoZbo+Ojub06dOaXiBjY2O6d+9O9+7d6dChQ77aOPbXX3/l22+/ZcCAASxdutSgsSgUCg4fPsz69eu5efMmQ4cOZdy4cdSpU8egceU3Bk+I1q1bx82bN7OV3MTGxtKsWTM+++wzxo4dq8fo8qfk5GR8fHxSJUleXl6ULl363TBb/SbsTXZFKWl/OwrZPgtF+AsATMrYYtV2GGZV6mkdZ2os45fuZQkL1O7tiYmJ0Uxc/u/Nzs6uwO0bd/ToUUaNGsXcuXOZPHkyMpmMzZs3c+rUKbZt26Y5LiIuCdcPPek51BOlkWmqeQChLx7Trl07/Pz89DZBUxAMLbMFGonJyThbqvl2WAdc7a1yfT1JkvDy8tIkQLdv36ZVq1aaFWGOjo75duugpk2b4uvry4MHD/LVFI9nz57x22+/sXHjRqpWrcq4ceMYOHBgpqMORYHBE6KvvvoKuVzO/Pnzs3Wen58fbdq04ejRozRpIqoBq9VqHj9+zJ07d9h+5zX31HapejJSJL18iIm1PTJjE+J9LxB5ci0VR63EpHTqytOSIonij89QVx6qlfRUrFgx35Q/yI2UrUjWr1/Prl27aN36300Xr127xqRJk7h165bmvtevX+Po6EhkZGSab8KTJk3CyMiIn3/+OU/iF4S8lN0FGtlZRv6+yMhITp48qRkKK1WqlGYuULt27QrEB/eDBw9o3bo17dq149ChQ4YOJ01KpZK//vqLDRs2cPXqVYYMGcK4ceNwdXU1dGgGY/ANUoKCglJ9EGWVk5MT69atw93dnVu3bhl8abihGRkZUbNmTWrWrMkV6Q5ed1+meVyxSv+WNjCv25F4n/MkPL6JSeNeqY6TmRSj++CxhbbS8ps3bxg2bBjR0dHcvHlTaysSZ2dnHj58iFqt1iR/9+7do169eul+I12wYAHOzs5MnDgRZ2dnvT8HQcgr2Sk0KEmQoFCx+KgvQKZJkVqt5tatW5peoAcPHtC2bVu6d+/O3LlzqVGj4BU3/fXXXzE1NeWTTz4xdCjpksvl9OnThz59+hAYGMjGjRtxc3OjUqVKjBs3jsGDB+ebGnp5xeBf84OCgrC3t8/Ruf369WPw4MEMGTIElSr7ZdILq5hEZdYPlskgnWo7oW9iyAdlqnTOy8uLxo0b4+DgwJkzZ9Lcl83S0hILCwuCgoI096UkROkpW7Yss2fPZvr06XqJWxAMwSsw6v8LDP6bDMXcOsyrzVN5/sOHhB9ZnuZ5CQo1i4/6cS8oSuuxsLAwtm3bhoeHBxUqVGDkyJFER0ezcOFCXr9+zZEjR5g0aVKBTIaSkpLYvHkz5ubmdOzY0dDhZIm9vT3z58/n2bNnzJs3jyNHjlC5cmUmTJiQqpe8sMsXCZGdnV2Oz1+8eDFqtZqvvvpKh1EVbBZmaXf8qRPjSHhyC0mZjKRWEed9lqTABxSvlnYV6gunT1C2bFk++OADpk2bxubNm7l79y7Jycn6DF+vtm3bRqdOnVi0aBH/+9//Mpzk7ezsjK+vr+bnzBIigMmTJ+Pv78/ff/+ts5gFwZBWnwsgUZn6C6fc3BrLloMwr9c5w3MTlSrWnAtAqVRy5coVvvrqK5o0aULNmjXZt28fbdu25caNG3h7e7Ns2TI6depU4FcPHzx4kGLFivHZZ5/l2/lN6TE2NqZnz54cPHiQ+/fvY2dnR//+/WnUqBHr1q0jJiYmV+2HxyWx9vxjpu66w+jfbzB11x3Wnn9MRFySjp5B7hh0DpEkSZQqVYqXL19iYWGR43Zev35N48aNWblyJR9++KHuAiyg1p5/zPJT/qkmPMK7rSde7/4aRWQQyIwwsbbDqo0Hxas10GojZS+uPrVK4uXlhZeXF3fv3sXLy4snT55Qq1YtXF1dNfu5ubq65uthy+TkZD7//HOOHz/O/v37qVu3bqbnTJ48GQcHB6ZOnQpAw4YN+eWXX2jWrFmG5x08eJC5c+dy9+7dPCtsKQj6EB6XRKvvzmi9l6R4c2ErqphwyrpNS7cNmVpJzNZPsS9XWjMXqEWLFvmigrU+tGvXjlu3buX6cy2/UKvVnDx5kvXr13PmzBn69+/PuHHjaNq0aZYTvuzulmAoBk2IoqOjsbe3z3XWCfDPP//g5ubGpUuXqFWrlg6iK7h8ngTitv4OalnOV3tltBdXQkIC3t7eqRKle/fuUbJkSU1ylJIoOTg4GHzV2cuXLxkwYADW1tZs2bIlywXaVq1axYMHD1i7di1KpRILC4tMK6rDu0T/gw8+YODAgXz8sViGLxRc6X25SpGVhEguUzO+hR1f9NL+4lXYPH36FBcXF4YPH87atWsNHY7OhYSEsHnzZjZs2IC5uTmenp4MHTo0w/fUvJqMrwsGHTLL7XDZ+5o2bcqiRYvo168fcXFxOmmzoElKSuL777+nbdMGVJAiM9hOMGMy2bv9ddIrKV+8eHEaN27MmDFjWLlyJRcuXODNmzdcvnyZcePGUaxYMXbt2kX37t2xtLSkWbNmjB8/njVr1nD58mViY2Nz/iSz6cKFC5pibQcPHsxWtdr3h8z8/f2xtbXN0iRDmUzG8uXLWbBgAVFRUTmMXBAMzy8kJt1kKKuUkhEv3xasoaOc+vXXX5HJZHz66aeGDkUvKlSowKxZs3j06BE//fQTFy5coGrVqowcOZIrV65ozTn9dzJ+JoVtST0Zf9u1Z/p7EhkwaH9+YGCgzhIiAE9PT65fv87YsWPZuXNngRu/zSlJkvjzzz/5/PPPqV27NlevXuWtmU2alaqzwkxuzMT2Dtk6RyaTUbVqVapWrZpq2DI6Opr79+9rKnBv2rQJHx8fKlasqNWbZG9vr7N/M0mSWLFiBUuXLuX333+nWzftHekzU76KA4/kVZi66w5+T55TqssnrD3/mAGNMt9/qH79+ri5ubF48WJ++OGHnD4NQTCobC3QyLAdhU7ayc9UKhVr166lTp061K5d29Dh6JWRkREdO3akY8eOhIWF8fvvvzNy5EhMTEzw9PRk2LBhBMYbaU3Gf58iMpiXv02mpFMryvb6dyFKymT8enZWeb4fpEGHzH799VeuXLnCxo0bddZmQkICrVq1Yvjw4Zq5H4WZt7c3U6dOJTg4mOXLl9O1678VqLOzVDZFXuzFpVQqefTokWZOUsqwW2JiYqo5Sa6urri4uGR7S4/4+HjGjRuHn58f+/bto1q1atk6//3x7sTEhFQbvGZnvDskJIQ6depw/fr1ArlaRhCm7rrDwXRKeEDWhswA+ta3LbQlPFIcPXqUQYMGsWXLFvr27WvocPKcJElcuHCB9evX89dff1F9xLe8KWGfzhpmCP3jKyRlEnLLcqkSIsh8twR9MWgPkS6HzFIUL16cffv20bx5cxo1akSbNm102n5+ERkZyfz589m1axdfffUVEyZM0Fox5dG8KskKBQv+vI+RvFi6f5gASGqKm5rkyfitXC7H2dkZZ2dnhgwZork/NDRUkyCdPn2aZcuW8fjxYxwcHLQSpXLlyqXZ9qNHj+jXrx+NGzfm8uXL2d6z57/j3f/d7T7x/4cP/vYJ5YJ/eIa/rwoVKvDZZ58xY8YM9u3bl604BCE/cKpgQTF5iNawmaRWQcpNUiMpk8HIWLNp9PtkaiVvXz0iPNwuXy+8yK1ly5ZhYmJCr169Mj+4EJLJZLRr14527drx6EUI3X65ke5nTrzPeYzMSmJi7YQy6pXW45IEZx+GERGXlGlvvC4ZPCFq2rSpztutVq0av//+O4MHD+bGjRtUqlRJ59cwFKVSybp161iwYAEDBgzAx8cnwzeZsCv7cQp6TLWenpx9GIaMfz/U4d8ej6Snd5k9uJVBNyYtX748Xbp0oUuXLpr7EhMT8fHx0fQmHTlyhLt371KiRAmtJOnhw4d4enqycOFCxo8fn+3ht7R61JRRoUT8vYbkYD+Qm1DSsRWlO3mCkXGWis9NmzYNZ2dnzp8/T7t27bL/SxEEA+pbvyI/nvCF/8xIjL78B9GXd2p+jvc+i2WrIVi1GarVhpGxMcEX91F93hjq1q2Lm5sbPXv2pG7duoVmWkNoaCiXLl1i1qxZYmUpcPppPHK5HFUa88/USW+Jurid8kMWE+eVfnkSGbD3dhDj2+Zd77rBE6J+/frppe1u3boxYcIEBgwYwNmzZwvFEs9Tp04xdepUypcvz+nTpzNdOh4eHs4PP/zAlStXqFWrFhFxSey9HYTfq1hiEhWp9uI6su8167+dy7CeF/PVm5SZmRkNGzakYcN/ayVJksSLFy80Q227d+9m4sSJREVF4eTkxK1bt1izZg2urq7Uq1cvS0tf0yo+BxDx9xqMS1hh98lW1InxhO6aS+ztv7Bo3BvIfLy7ePHifPvtt0ybNo0bN24YfMWdIGSFJEma8hHylmNQlXVM9W3fqs3QNJOf/5LJoHPtCqxd8geJiYmcP3+eI0eO0KdPH1QqlSY5+uCDDwr0Duy//PILkiQxefJkQ4eSL2Q0GT/qwlbMXbsgt7DJsI1EpRq/V3m3AAcMPIeoTp067NixI9NidzmlVqvp06cP1atXZ8WKFXq5Rl4ICAhg+vTp3L9/n2XLltGnT58sJS2ffvoparWaVatWZXqsSqWiXr16fP/99/Ts2VMXYeeJiIgIhg4dSlJSEhs2bCA0NDTV3KQHDx5QoUIFrZpJVapUSfU79Nx6k5O+oVorIYI3TKDMB2MoXuPdfnlvzmxEnfwW627/vvFlNt4tSRKtWrVi3LhxjBo1Sve/BEHQoTNnzjB79mySkpJYsmQJleq2YMiG6zlaoFHcxJhdns21vixIkoSvry9Hjhzhr7/+4s6dO7Rt21aTIOV09wJDkCSJ8uXL07BhQ44fP27ocAxOrVbz0bqLXHuhvdo7OfQJ4Yd/pOKoFciMTYi6uB1l1CutOUQpOjqV47cRebdXqUETIisrK548eUKZMmX0do2oqCgaN27MwoUL+eijj/R2HX2IiYlh8eLF/Pbbb0yfPp2pU6dmuYrro0ePaNGiBb6+vtjYZJyJpzhw4AALFizg9u3bBWLz1tu3b9O/f3/c3d1ZunRpml3VKpWKR48epSos6eXlRXx8vCZJqlmnASuflyOtueexd46SFORLmW6TUCfG8XrXPKzaeFDCsWWq4zKq2wTv6mT17duXhw8fFrn9gYSC4ebNm3z55Zc8efKERYsWMWjQIM37gL4XaLx584YTJ05w5MgRjh8/jq2trSY5atasWb7uWT1//jydO3fm4sWLmRZtLUyUSiWPHz/Gx8cHX19ffHx88PHx4eHDh5Tt9Tmyatq/i5gbh4i6sAWZ6bveQCk5ESQ1Jtb2VByl3WmR15PxDZYQxcbGUr58eeLj4/U+RHPv3j06duzI6dOn9dYbpUtqtZrNmzczd+5cunbtypIlS9Lcbysj7u7uNGrUiNmzZ2f5HEmSaN68OVOnTk012Tk/2rRpEzNmzGDNmjUMGDAg2+eHhYVpkqPDAYk8M3cBufY2HorwQMIP/0jy66cgqSlZpyPWPadq/c2mVPbOaLzbw8ODatWqsWjRomzHKwj64ufnx9y5c7l69SpfffUVY8aMSXNLm7wqsKdSqbh27Zqm9+jVq1d069YNNzc3unbtmq1aYnmhY8eOPHr0iBcvXhg6FL1ITk7m0aNHmoQn5RYQEICtrS21a9fW3JydnXFycmL77ddpFvRUKxKRkhI0P8f8sx9ldChluk7CuIRlqmOz8p6qawZLiPz8/OjTpw8PHz7Mk+tt376dr7/+mhs3buS7F9T7Ll++zJQpUzAxMWHlypU0aZL97sIrV64wePBgHj58mO1x+dOnTzN+/Hh8fX0z3OfLUJKSkpgyZQpnz57lwIEDOqn3kd7SYklSE/zLGErV74ZF036oFQlE/LUCE2tbSncYrXV8Zt9mAgMDqV+/Pnfu3KFy5cq5jlsQcuPFixcsWLCAP//8k+nTp/PJJ59QokSJDM+5FxTFmnMBnLgfjJGREar3avumLNDo4GjDxPYOOqsh8/z5c44ePcqRI0e4cOECjRo10vQeOTk5GXTOY3R0NGXLlmX58uUFfv5QQkICDx8+1Ep8nj9/TtWqVXF2dk6V/Dg6Oqb7+ZLZli8pMhoyy6zXXR8MNqlaH0vuMzJ06FCuX7/O8OHDOXjwYL4bEgoMDGTmzJlcvHiRb7/9lo8++ihHL3RJkpg+fTqLFi3K0STFjh07UrVqVTZu3Mj48eOzfb4+BQUF4e7uTqVKlbhx44bO9glKr/icOiEWVUwYpRq6IZObYCw3wbxeJ6IubE0zIcqs+Jy9vT2TJk1i1qxZ7NixQyexC0J2hYWFaQqWjh8/Hn9/f0qXLp2lc+vZWbF6SAPKTu+Lx7xVnLntS/M2HVIt0ND1B1iVKlX4+OOP+fjjj3n79i1nzpzhyJEjdOnSBVNTU3r27Imbmxvt2rXLds2y7AiPS2LvrSD8QmKISVRiYSYn8P515CWtGDt2rN6uq2txcXGaIa73h7qCg4NxcHDQJDxDhgyhdu3a1KxZM9uLksqaF6NdLZs052W+L72J+ZntlqAvBkuIdF2lOit+/PFHOnTowJIlS5g7d26eXjs9b9++5YcffmDlypVMmjSJDRs2ULJkyRy3t2/fPt6+fYuHh0eO21i6dCl9+/Zl+PDh+Wblx9mzZ/noo4+YOnUqM2bM0Om3QguztF8GxiUskVuWJ/bOUSya9UNKTiDu/mlMyqVd6NHCLPMetRkzZuDo6Mi1a9do3rx5ruIWhOyIjY3lp59+YuXKlQwZMgRvb28qVKiQ7Xbu3r1LxTKl+KCimsDwK/w2YoYeok1biRIlcHNzw83NDUmSuHfvHkeOHOHrr7/G29ubDz74ADc3N3r06JHtaQbpyWhjUklZjgrjf2XK3gcG35j0v6KiolIlPCm38PBwHB0dNYnP6NGjcXZ2pkaNGjotGTCpvQMXH4Xn2W4JulBkeogATE1N2bNnD02aNKFJkyapqjr/l0KhwN/fHz8/P2rVqoWDg4NOkwNJkti9ezczZsygefPm3L59mypVquSqzeTkZGbNmsXatWtzNQmxSZMmNGvWjFWrVvHFF1/kKqbckiSJZcuWsWzZMrZu3UqnTp102vb169e5d+EsUglHrSKMADb95hB5aj0x1/aCkTFmletSpuM4rePM5EY4VSyV6TXNzc1ZsmQJ06ZN48qVK/mqxIFQOCUmJrJ27VqWLl1Kly5duHHjBtWrV89xe+fPn6d9+/ZERUUZdPqBTCbTLIyYM2cOYWFhHD9+nCNHjjB9+nRq1Kih6T1q1KhRjkYFMps3Jfv/grdZKdSqL+Hh4VpJj4+PD7GxsZp5PbVr16ZDhw7Url2bKlWq5MkkdVd7K+b0cMrhZHynPN+2Aww4h2j8+PHUr1/fILuBX7hwgQEDBnD9+nWqVq2a6rHExEQ2bdrEd999h4mJCQEBATg7OxMREcGUKVOYNGkSlpaWaTecRbdv32bKlCnExcWxYsUK2rZtm6v2UqxcuZJjx45x7NixXLfl6+v7ruLoo0e5fr45FRsby+jRo3n27Bn79u3T2bybqKgotm3bxvr160lISMBj7Mdsj3UiWZXzl0J2xrvVajVNmzbl888/z/eT14WCS6lUsmXLFhYsWICrqyuLFy/OtHZZVvTu3ZuhQ4fy8uVLXrx4wfLly3UQrW4pFAouX76smZj95s0bevTogZubG507d6ZUqcy/vOSnrY8kSSIkJCRVwpPS+6NQKFLN7Um52dnZ5YsvXAVpt3uDJUQ9e/ZkwoQJBitzvnz5crZt28alS5c0PT9JSUl06NABCwsL5s2bR8uW/y6t9vHxYenSpVy+fJl//vknRyXoQ0NDmTNnDkeOHGHRokWMHj1aZ5l6VFQUjo6OnDp1SidvegCjRo3Czs7OIKui/Pz86NevH61ateLnn3/OcrmB9EiSxLVr11i/fj0HDhygW7dueHp60r59e4yMjNKtQ5QVOdl35+LFi3h4eODn55dvhiWFwkGSJA4cOMCcOXMoV64cS5cuTfVelhsqlYqyZcvi6+vLmjVrMDY2Zv78+TppW58eP37MX3/9xZEjR7h69SrNmzfXTMx2cNAemvEKjEpzc+yQ7bNIevlQs0WJcSlrbD3XpTomvdpLWSFJEoGBgWkOdZmYmGglPc7OzlSoUCFfJD4ZSZmMn9FuCbqejJ8TBkuIXF1d2bx5Mw0aNDDE5ZEkiSFDhlCiRAl+++03AMaNG8ebN2/Ys2dPut2rM2fO5ObNm5w4cSLL461JSUmsXLmS7777jpEjR/LVV1/pvNdl5syZhIeHa56LLjx//pyGDRvi4+ND+fLlddZuZvbv38+ECRNYsmRJricr/rc3yNPTk5EjR2rVZkrvDTArTI1g78etsv1Cdnd3p0GDBsyZMyfb1xSEtJw+fZrZs2ejUChYunQpXbt21emH5d27dxk8eDB+fn58+umn1KhRgylTpuis/bwQGxvLqVOn+Ouvv/jrr7+wtLTUDK21bt363Y7t6XxBCtk+i5J1OlDKNf3pFln5gqRWq3n27JlW0uPr64uFhUWqhCflv1mtJ5efZbRbQl5PoE6LwRIia2tr/Pz8DPqPHBcXR/Pmzfn0009p2LAh/fv3x9vbO8PCeSqVinbt2jFp0qRMhzskSeLIkSN89tlnODo6smzZMhwdHXX9NDSJy71797C1tdVp2ylvdnlR6VupVDJ37lz++OMP9u7dS+PGOdvpWJIkrl69yvr16zl48CDdu3fX9AZl9OGQky5yU2OIv7iF+UM74unpma04nzx5QpMmTbh//36h2m9PyHs3btxg9uzZPH/+nEWLFjFw4EC9rKRdsWIFPj4+rFu3juHDh9OpUyeGDx+u8+vkFbVaze3btzW9RwEBAbTv1ov71QailLTfK7KSEMG/Q+iWZsaa4oXvJz0PHz6kbNmyafb45OeyMIWdQRKit2/fUqZMGRISEgze1efv70/r1q3p3r07lSpVYunSpUDaSyydKlgwoJEdh3Zv59ixY+zZsyfddn18fJg2bZpmjL1bt256ew7Dhg2jWrVqLFy4UOdtv379GmdnZ27duqU130qXwsLCGDx4MEZGRuzcuTNHQ5Jv3rzR9AYlJSXh6enJiBEjspV052S8u5m1gh49etC/f3+WLFmSrQ+iGTNmEB4ezsaNG7N8jiCk8PX1Ze7cuVy/fp158+YxatQovdYP69u3LwMGDOCjjz6id+/ejB07lt69e+vtennt1atXzN1+njNhxZGMtEcAQrbPQhH+rgCjSRlbrNoOw6yKdrFfmVqJid8JAv/epFW8sHbt2jg5OYmK9fmQQRKiR48e0a1bNx4/fpzXl07TwYMHGThwIIcOHaJSnRbpLrFMGetsUdWSg4s/5s3ju1oJXWRkJF9//TU7d+5k7ty5TJw4Ua9vULdv36Znz574+/tnaaJgTnz11VcEBgayefNmvbR/48YN3N3dGTp0KIsWLcrWvKqc9gZlJCfj3eHh4fTp0wc7Ozt+//33LM95io6OxtHRkaNHj6bawFYQMvLixQu+/vprDh8+zIwZM5g8ebLe56Kp1WrKlSuHl5cXtra2tGnThsWLF+tsUUh+kV6hVoCklw8xsbZHZmxCvO8FIk+upeKolZiU1l7i375KcX4Z0ULMESxADLLs3hBL7jPy4YcfUrJkSWb+eoRkl3dJUFppYsoH4/nHb7DoN4+t154xvMW7mjRKpZL169ezYMEC+vfvj6+vb456ObIjpQjj/Pnz9ZYMAUyfPp2aNWvi4+Ojk8rQ79uwYQNz5sxh3bp19O3bN8vnvXnzhq1bt7J+/XoUCgWenp788MMPOhmCrWdnxVqPxtka7y5btiynT59mxIgRdOzYkUOHDmXp39/S0pIFCxbw2WefcfbsWYP3mAr52+vXr1myZAlbt27l448/5tGjR3k2xOLt7U3p0qU1w/KGXnavL+kVagUoVunfKQ/mdTsS73OehMc3MWmsvTjIuHgpkQwVMHmWEL0/BOUbEMXbegNYe/4xAxrlj8lUVo17EVujE1IW5o9IEhiZmLH0mB9GMhkV4x8zdepUbGxsOHnyZJ7tl3b06FFevXql9yqplpaWfPHFF8ydO5f9+/frpM3ExEQmT57M1atXuXjxYpbmVkmSxJUrV1i/fj2HDh2iR48erFq1inbt2uklkbA2L5atfXTMzMzYuXMnX375JS1atODo0aPUrFkz0/PGjBnDqlWrOHjwYLaSQqHoiImJYdmyZaxatYqPPvoox0UVc+PcuXO0a9dO83NUVFSWK1wXJCWy86kokwFpD7JkpVCrkL/ofcgsoyqfKcMP7R1tDFrl0yswig9/Podk/O8f8Itl7qmOkZTJlGrQgzJdJqS6X6ZWwKnlLJszhb59++bZN3ylUomrqyvffvttnpQuSEhIoGbNmuzfv5+mTZvmqq3nz5/Tv39/qlevzsaNGzMdS0+rN2jEiBF674HLjfXr1zNv3jz27dtHq1atMj3+5MmTfPzxx3h7e+t1+wGhYElMTGTNmjV89913dO3alQULFlCtWtqV0vXN3d2dDz/8UFMF39zcnFevXum1dzovqNVq7ty5w99//83Jkye5ryxPyeaDwDh1QqNOjCPp5UPMKtcFI+N3Q2bHV1Fx5ApMrFOPeBhiY1Ih9/SaEBWUgkyeW2/yt08IkHYyo05OJOhnD8oN+BqzynX+86hEZ6dybBiRuyQhuzZs2MD27dvzdJhl3bp17Nmzh1OnTuW4jZMnTzJs2DC++OILPvvss3RjT+kNWrduHX/++Sc9e/bE09OTtm3bFphhpePHjzNs2DBWrVrFoEGDMj3ezc2N9u3bM3269kaHQtGiVCr5/fffWbBgAQ0aNOCbb77RWX2xnJAkifLly3Pr1i3s7e1RKBQUL14chUJRYF6P73v+/DknT57k5MmTnD59mnLlytG5c2c6d+5MncYt6LLqulahVtXbaF7v/hpFZBDIjDCxtsOqjQfFq2mXjjHExqRC7uktIcpPVT4zkpVdeePunyb60g4qTfg1zRd/Xv/xx8XFUatWLf78888cL03PiZSKqGvXrsW1Wet0V+Gl9XuQJIlvv/2Wn3/+mR07dtC+ffs0rxEZGanpDVKpVHh6ejJ8+PB83RuUES8vL9zc3Jg8eXKme7D5+fnRunVrfH19C0XNESH7JEli3759zJ07lwoVKrB06VJatGhh6LDw8fHBzc2NJ0+eAO8WETg5OREeHm7gyLImJiaGs2fPapKgN2/e0KlTJ00SlDKnNWVLpS/+fISRvSvIsl+6ICeFWoX8QS9ziLwCo1h81C9VMiQpFUT8vYbEZ3dRJ8Yht6pI6XbDKV7j3z+aBIWaxUf9qGdnlWfVKvfeCsr0mLj7pylZ54N0P8xkwN7bQXnWPfrjjz/Svn37PE2GgHcFy2YvZuKOO3AuGfjvEGgIy0/5aw2BRkdHM3LkSEJCQvjnn3+0JtRLksTly5dZv369pjfol19+oU2bNgXy2+f7XF1duXr1qubDZPXq1ekW9HRycmLo0KHMnz+fNWvW5HGkgiFJksSpU6eYPXs2arWaFStW0KVLl3zz9//f+UNv3rzJ1xOqlUolN27c0AyDeXl50bx5czp37swff/yBq6urVnkMPz8/Jk+eTFhYGIsWr+DbfxIL1MakQu7pvnIXsPpcAInK1H9IklqFvFRZKnz0LfbTdmHV1oOwQ9+hjApNdVyiUsWacwH6CCtNfiExGfYOKaNfkxT4gJJ1O6Z7TKJSjd+rWH2Ep+XVq1f8/PPPLFmyJE+u975t157x27NSJJV1JEmp1vq9Jf7/fX/7hDJ4wzW2XXuGt7c3TZs2pVKlSpw7dy5VMhQZGcn//vc/XFxcGDduHA0aNODx48ds3769QA2NZcbOzo6LFy/y4sUL3NzciImJSffY+fPns3fvXry9vfMwQsGQrl+/TseOHZk0aRIzZszg5s2bOq8wnVspG7qmyG8rzCRJIiAggDVr1tC3b19sbGz4+OOPiYuLY968ebx+/ZqTJ08yY8YMGjRokCoZio+PZ/bs2bRp04ZevXpx69YtRri1Z04PJ4qbZO8j0pAbkwq5p/MeovC4JM77h2nNGTIyNcOqzVDNzyUcmiK3LE9SSAByq3+3hZAkOPswjIi4pFwNQUmSREJCAtHR0Vq3mJgYzf9fTagGxukPT8Q9OEMxu9qYWGW8ouNJ8CsePJBTtmxZrK2t9VZ7aP78+YwePVqvRRLTkjIEmqhQQyaFByUJEhQqFvz5gLiLW/huzhxNNVtJkrh06RLr16/n8OHDuLm5sXbt2kLRG5SRUqVKcfjwYSZPnkybNm3466+/0iw9UaZMGebMmcPnn3/O8ePHDRCpkFe8vb2ZO3cuN2/eZN68eYwcOVKvNctySpIkzp8/z3fffae5Lz+sMIuMjOTMmTOaXqDk5GQ6d+6Mu7s7a9euzXS7IUmSOHjwIFOnTqV169bcu3ePihX/rSeUMnVj8VE/EhWqdNaSvWPoebCCbug8IcrKEBSAKv4NishgTG20dzCXAduvPKZfbYs0k5j0bv89Ri6XY2lpiYWFBZaWlmnerEoUIzQp/TjjH5zBsrl7+gf8vwCf+wze+AXh4eFERERQsmRJypYtm+pmY2OjdV/KrXTp0plWOPb29ubgwYM8fPgw03h0Ka0hUICYW4eJv3+a5LBnlHRuR1m3aakeV0gyLNqNoP4HrYiMjGTLli2sX78eSZLw9PTkf//7H9bW1nn5VAxKLpfzyy+/8MMPP9CiRQsOHz5M/fr1tY6bOHEia9as4dixY3Tv3j3vAxX06tmzZ3z99dccPXqUGTNmsGPHjnxdr8bf359ixYql+hJmiCGz5ORkrl69qkmA/Pz8aNOmDZ07d2bKlCnUrl07y1+qAgIC+PTTT3n27BmbN2+mQ4cOaR7n0bwq9eysmPbrCZ4mFsfUxCTfbkwq5J7OE6LMhqAAJJWS8D9/xLxuR0ys7bUeT1SqWbxmE4sub6ZUqVKUKlVKk9RYWVlRunRpypQpg4ODA1ZWVukmPKamppnGu/b8Y5af8k8z5sQgX1RxEZRwap1hG2ZyIz4d3p/xv84A3i3jjI6OJjw8PM2bv78/YWFhqe6LjY2ldOnS6SZMZcuW5eeff2bo0KFERUUhl8sxNzfPk16VtIZAAeTm1li2HETC09tIiuQ0z01Wwagf/uDx77Po1asX69ato3Xr1oW6NygjMpmMGTNmULVqVTp37syWLVu0kh4TExN+/PFHPvvsMzp16pQvew2Kooy288lKb/br169ZvHgx27ZtY+LEiTx69Ejnmzzrw7lz57QWQeTFkJkkSfj6+moSoIsXL+Lk5ETnzp35/vvvadGiRbZLVCQkJPDtt9+yevVqZs6cyZQpUzL9nKhnZ4XizGqWfDaT6DK18u3GpELu6TwhyqjKJ4AkqQk/sgyM5ZTpPCHd48qUt8PKwYGkpCSSkpJ49eoVz5490/yclJREcnIycrmcYsWK5fgmFTNHYdyctKZTxT84TYlaLTEqViLD56SWJHo4lUGpVCKXyzEyMqJ06dKULl06S4X54N0kwMjISE2C9H7CFBgYyLFjx/D29katVnPw4EHCwsJQKBTZ6oUqW7ZslreUSJHeEChACceWACSFBKBSpL3aRAKiSthy874fDvZ5W0guPxs4cCB2dnb069ePBQsWMH78+FSPu7m5sXLlStatW8fkyZMNFKUAmdVSS3shwfuio6NZtmwZq1evZujQofj4+GQ6nGNI/0387j1Q4Fq3e6ppDPoaMgsNDeXUqVOa1WAmJiZ06dKFkSNHsmXLllz1KB85coRPP/2URo0acffu3SzvlhAaGsq9e/f4sFvHbL9/CgWLzhMiC7P0m5QkiYijK1HFR1FuwNfIjNM/ttsH7Vi+bkqG15IkCYVCkSpJysnNLjqaF2or/luHyLpb5h9EklpN/JNbOFUbQFJSEpIkZSkRMzMzy9JxJUuWxMrKiv379zNmzBjatWuneQzeFW57+/Yt8fHxxMXFERsbS3R0NMHBwURFRaVKssLDwzE1Nc0wYfpvQrXXOzrT30FmTORyTj+Nx0G7M7BIa9myJZcuXaJHjx48efKEpUuXaoZNZTIZP/30E506dWLo0KEGn69RVGVWSy1l+ORvn1Au+IenmkOSkJDA6tWr+f777+nevbveN0jOrXQTP/NqXIyS0fK7M5rET1dDZgkJCVy8eFGTAD1//pz27dvTuXNn5syZg4ODQ657k58+fcrUqVPx9fVl7dq1dOnSJVvn//nnn3Tr1k0kQ0WAzhMipwoWFJOHpDkEFXliNYqIQMoP/gYjk/S7GM3kRjhVzLz6qUwmw9TUFFNT01xVS+0aGMXgDddytMSyRDETdi2bSr1dXwOgUqnSTLoSExOznajFx8eTlJTE/fv3SUhIICIigj/++CPDc/57HaVSiampKcWKFcPCwgJTU1PUajURERFERkby6NEjJElCkiRUKhVKpRKFQkFycjJJSUmU7DwJc5e0x9ezKi9X4RU0Dg4OXL16lT59+jB48GC2bNmieeOtW7cuH374IYsWLeKnn34ycKRFT3ZqqaUsJFh81BeVSk2yz2kWLlxI48aNOXv2LC4uLnkQcc5llvi9K1IoaRK/am8tcLPP/nCfWq3m3r17mmGwa9eu4erqSufOnVmzZg1NmzZNtyxFdiUlJfHDDz+wfPlyPvvsM3bv3p2jKvAHDhxgxIgROolJyN90XpgxvUKHyujXBP8yGoxNkBn9u5t5mW7aH7iGqPKZXwtJJiQk4OTkxPbt22ndOuO5TGlRq9Wa5CYnt90hZXimyDjZfHNhK6qYcK1J1e+rVTKJL5qVwtbWlkqVKmFpaVlk5xGlJTExkVGjRvHixYtUG8OGhobi4uLC1atXszz8KuSeVzpfkhThgUT8/QvJoQEYF7ekdIdRmqFjDWUylXx38dPcqTRv3jwPo86ZnLz3GamVuNkls/KTAZkeGxQUpOkBOnXqFKVLl9YURGzfvr1e5lH9/fffTJ48mdq1a/O///0vxz1z0dHR2NvbExwcXOC3KBEyp/MeorLmxWhXy4aTvqGpvmnILctRZdaRTM+Xyd7N2M/rSWqplljmo61GVq5cScOGDXOUDAEYGRlhZmaW4+5e/113eHb3ZY7OfV/U65d8++0BgoODefnyJSqVikqVKmluKYnSf/8/P6++0SUzMzO2b9/O3LlzU20MW758eb744gu++OILDh48mOuJvULWpFdL7fW+RZRq0J3ygxeR+OIBYfsWUtGmCiZlbDXHyeSm1B08nebN83+l4vRWkIYf/pHEZ16oFYkYlyyNRfP+lHLtqnlcbSTneIice0FRWiur4uLiOHfunCYJCg0N1VSFXrp0KVWqVNHb8wkMDGTatGncvn2bn3/+mZ49e+aqvaNHj9K2bVuRDBUReqlUPam9AxcfhRe4Kp8pSyzXnAvg7MMwZGDQJZbh4eH88MMPXL58Wa/XyUhGQ6CSWgUpN0mNpEwGI+NUPYDw7vc2xr0741f+OycrNjaWly9fprq9ePGCa9eu8fLlS03iVLJkyUyTpgoVKuism92QjIyMWLJkCdWqVaNNmzbs3buX1q1bM2XKFNbuOUa/n47h/ebdsdmd2CtkXXoLCRQRgajiIinV5ENkMhnFq7pSzLY28Q/OYNV2mOY4CTing1pqeSG9FaQWzQdg3X0KMrkJiohAQnbMxrR8DYpV+Pe9WaGGNecCWD2kAbdu3dIMg92+fZsmTZpoVlE2aNAAY2NjrWvoUnJyMv/73//4/vvvmTx5Mlu3btXJl6n9+/fTr18/HUQoFARFfi+z9ETEJbH3dhB+r2J59CKY5/6+TB7WN0+XWE6ZMgWlUsnq1avz5HppyWivt6iL24m+vDPVfZathqQqwAk5HwKVJInIyEhNcvR+ovT+/4eFhVG2bNkMkyZbW1usra0LzDDdiRMn8PDwYNWqVSiqNGPB4QcolFKGRTFFcTjdSK8UR/LrZ4RsnY79Z3s0f0ehf8xFZmJGuf5zUx1bEHY7z8o+jgCKiCBCd8ymdCdPSjq3SfWYTK0kZuunVLK20AyDtW3blpIlS+oz9FTOnj3LpEmTqFq1KitXrsTBQTdfqBMSEqhQoQKPHz8usHspCtmjt6/V+XUIKquszYtp3syCg21o0GAUnus/z7MP1EePHrF9+3Z8fHzy5HrpSW8IFMCqzVCt5Oe/cjMEKpPJsLa2xtramnr16qV7nFKpJDQ0VCtRunz5cqoEKi4ujooVK6aZNL1/X37oHu/atSunT5/Gbep3mDYrgRIjMHr3t5fePJb3J/YC+ea1VNCkV0vNxNoO4xKWxFzfh0WTD0l8cY/EFw8wq6K9C32iUs1fl+9QKui6ZuGHqakpJiYmqX7O6H4TExO99qxkVkQ34sQa4u+fRlImYVq+Rqp9J1MYGxsza91BvuilveO7vr169YrPP/+cy5cvs2LFCvr06aPT9+eTJ0/SsGFDkQwVIXodZ8hvQ1A5ValSJdRqNaGhoVSokDe1dGbPns1nn31GuXLl8uR6GcnvQ6ByuRxbW1tsbW0zPC4hIYFXr15p9TTdvXs3VTJlbGyc6TBdxYoVc7RiJTuk0pUp3mooScp/M9GszGMxxCbJhUl6tdRkxnJs+s8l8uQ6Yq7tw7SiAyWdW4Nx2oUzg0LfcOT+WZKTk7VuKSs5M7v//ZW0WUmgsnqsqakp55OrkaS0Svf3YN11ImU6jycp2I/EF/eRpfE8lZKMl2/zttdVqVSyatUqFi9ezLhx49iwYYNeeqTEcFnRo/eJF/XsrFjr0TjVEFRBq/Ipk8moV68eXl5eeZIQXblyhevXr7Nlyxa9XysrXO2tmNPDKYdDoPlno8PixYtTvXp1qlevnu4xkiQRExOjlTQFBARw4cIFzf0hISFYWlpmOkxnY2OT42/5q88F/P9y539ldR5LyibJaz3y/8Te/CajWmqm5apRYei3mp9Dtk6nZJ20N35u16IJyweNy3EcKaUwspo8Zef+xMRE4hSqTLf3lhkZY2bvQrz3WWLvHMWicW+tY2ISFTl+jtl16dIlJk6cSLly5TSVq/VBoVBw5MgRFi1apJf2hfwpz2aivj8EVRC5urri5eVF165dMz84FyRJYvr06SxatIgSJTKukJ2XCvoQaFbJZDLN1i/Ozs7pHqdWqwkPD9ea03Tr1i0OHz6suf/NmzeUK1cuw6SpUqVKWFlZperuT7dCeJq/d4nksOep79HRJslFUUYLCZJfP8WkjC2SpCb29lGUcW8wr9tJ6zgjtRLpTRBJSc457kmUyWTI5XLkcrleVlvG7brDwayuIFWrUb55leZDFmb631omNDSUmTNncurUKX766ScGDBig1+kLFy5coHr16tjbi2qyRUnBX5qTR1xdXTl58qTer7N//37evn3LsGHDMj84jxWWIVBdMDIyoly5cpQrV44GDdKfP5GcnExoaKhW4nT27NlUvVDJycmpyhDE2TdHKa/Bf7/CZ2ceiwzYezuoQH8RMQT3RnYsP+Wf5mPxD84S53UCSa2imL0L5QcvQibXTghkRkb8s2slFb8cTu/evRk4cCCdOnXK0v6KeSW9xE8VH0Xicy+KOzRFJjcl8dld4n3PU7bXF1ptZLWIbk6pVCrWrl3L119/zYgRI/D19c2TOX4HDhygb9++er+OkL/obZVZYXPnzh2GDx/O/fv39XaN5ORkateuzS+//ELnzp31dh1dKMhDoPlRfHx8qhIEm/zU+CdbpXls8uunRJ5chyLsOaYVHTAuYQnGJpTtob3VTd/6tiwfVF+/wRdCnltvprmQICtkMuhauzxrPRoTHBzM3r172b17N35+fvTp04eBAwfSsWNHg2/am94qM9XbaMIOLCX59VOQ1Mgty1GqUS9K1e+m1YY+i+hev36diRMnYm5uzurVq6lTp47Or5EWtVqNvb09Z86cwdHRMU+uKeQPIiHKosTEREqXLk1UVJTeJtOuXLmSo0ePcvz4cb20LxQco3+/wRm/11k6NmUeS6kG3bUe6+hUjt9GNNF1eIVeepWqs6K4iTG7PJtr9ZAGBgZqkqNHjx7x4YcfMnDgQDp06GCw5EhXiZ8uRUREMGvWLP766y++//57hg4dmqflMq5du8aYMWPw9vbOs2sK+UMmU+qEFGZmZtSoUUNvy+CjoqJYvHgx33//vV7aFwqWjCb2Jr9+iqRMRq1IJPr6/nTnsbxrx7C9EAVVykKC4ibZe4vMaCGBvb0906ZN4+rVq9y6dQtnZ2e++uorKlWqhKenJ6dOnUKpTHuFm75Mau+AmTyHS/tVCgbXy/nu8/+lVqvZsGEDtWvXpkSJEvj6+uLh4ZHntcPEcFnRJRKibEiZWK0P3377LT179syw3o5QdLyb35H2yzP+wVmCfh5G0EoPEp97pTuPRd/zOwo7j+ZVmdPDmeImxmT2mSyTvesZymph2SpVqvD5559z/fp1bty4Qc2aNZk9ezaVKlViwoQJnDlzJk+So5wmfkaSkkZGzxjavTWnT5/OdRy3bt2iRYsWbNq0iRMnTrBixQq97HGWGUmSxHL7IkwMmWXD999/T0hIiM53Hn/x4gUNGjTg3r17mdbSEYqGrFYRzoghNkkujO4FReXZQoInT55ohtUCAwPp378/AwcOpE2bNnot0pjZbvcpZDIwllQ04Bl7ln7KqVOnGDFiBCNGjGDBggXZHvp78+YNc+fOZd++fSxdupQRI0ZglEE1dn178OABbm5uPH36tMBUtRd0RyRE2XD8+HF++OEHnXwjet+wYcOoWrWqqHkhpJIf53cUZXm9kODx48fs2bOH3bt38+rVK01y1KpVK70kRxklfsaokMtN6OBoQ7LXXziXK8EXX7xbdfb69WtGjhxJZGQkO3fupFq1apleS61Ws2XLFmbPns2HH37I4sWLKVOmjM6fU3YtXLiQN2/esHz5ckOHIhiASIiy4dWrV9StW5ewsDCdfXu4ffs2PXv2xN/fP19sGSHkH/qY2CsUTI8ePdIkR69fv8bd3Z2BAwfSsmVLnfeo/Dfxi48Kx/vy35zb+C3W5sUYO3YszZo1Y9y4f4tOqtVqVqxYwdKlS/n5558ZNGhQuu3fu3ePiRMnkpyczJo1a2jcOP8k7Q0aNGDlypW0adMm84OFQkckRNkgSRLly5fnzp07OhnakiSJTp064e7uzscff6yDCIXCpqBvkizo3sOHDzXJUUREBAMGDGDgwIE0b95cL8NNiYmJ2NjYEBgYiJWVFf3792fw4MEMGDBA69hbt24xZMgQ2rZty4oVK1JtqRETE8P8+fPZvn07ixYtYuzYsXodBsyup0+f0rx5c16+fJmv4hLyjphUnQ0ymQxXV1fu3bunk/aOHTtGcHAwY8eO1Ul7QuGjz4m9QsHk6OjI3LlzuXfvHqdOnaJMmTJ4enpSpUoVPvvsM65du4Yuv+eamZnRrF0n5m4/z9Rdd/C1ace+YHPWnn9MRFxSqmMbNWrErVu3UCgUNG7cGC8vLyRJYseOHTg7OxMbG4u3tzfjx4/Pd0nHgQMH6NOnT76LS8g7oocomz7//HNsbGyYNWtWrtpRKpW4urqydOlSevfW3h9IEN6XlxN7hYLJ29ubPXv2sGvXLt6+fcuAAQMYMGAATZs2zfEQv1dgFKvPBXDa5xWSpEYt+7ccRMrfXXtHGya2c8DV3irVudu2beOTTz7BxsaGkiVLsmbNGlq0aJGLZ6hfrVu3Zs6cOXTvrl3PSygaxNYd2eTq6sqxY8dy3c6mTZsoW7YsvXr10kFUQmFXGDZJFvTLxcUFFxcX5s+fj7e3N7t372b48OEkJSVphtUaN26c5eQo1cozjECWekAhJSn/2yeUC/7hqfYujIuL4969e8hkMhITE3F0dKRWrVo6fb66FBISgre3Nx988IGhQxEMSPQQZZOXlxdDhgzJVYHGuLg4atWqxaFDh2jSRFQRFgRBPyRJ4v79++zevZtdu3ahVCoZOHAgAwcOpGHDhukmRzmdu/Zld2eKB9/ks88+o3379vzwww+ULl2aL7/8kl27drF161bat2+vo2enO+vWreP8+fPs2LHD0KEIBiQSomxKTk7G0tKSN2/eYGZmlqM2FixYgJ+fHzt37tRxdIIgCGmTJAkvLy92797N7t27kSRJkxzVr19fkxylt7pRGRVKxN9rSA72A7kJJR1bUbqTJzKjf+fcyFQKzC7/wrqlc2jbtm2q848fP87o0aMZO3Ys8+bNQy7PPwMUXbt2Zdy4cbi7uxs6FMGAREKUA/Xq1WPTpk00atQo2+e+evWKOnXqcPPmzSzV6xAEQdA1SZK4c+eOJjkyNjbWJEer7ynSrH8Vuns+xiWssO42CXViPKG75mLu2hWLxu/PgZTo4lye9cPT7vkOCQlh+PDhvH37lh07dlC5cmX9PcksioqKokqVKgQHB2Nubm7ocAQDEqvMciA3W3jMnz+fUaNGiWRIEASDkclkNGzYkG+//ZbHjx+zc+dOFAoFfQYO5e/7QWkWA1VGh1LSuTUyuSnG5qUpXq0RivAX/22Z84/CtVafpahQoQLHjx+nd+/eNGnShP379+v+yWXTkSNHaN++vUiGBJEQ5UROEyJvb28OHjzInDlz9BCVIAhC9slkMho3bsz333/PrPUH091+w6Jxb+J9LqBWJKKMDSfhyU2KV2uo3R6w93ZQutczMjJixowZ/Pnnn3zxxRd8/PHHJCQk6OrpZNuBAwfE3mUCIBKiHMlpLaKZM2cya9YsSpcurYeoBEEQcscvJJb05lGb2ddFEf6CwJ8GErx6JKYValK8lvYy+kSlGr9XsZleq1mzZty+fZvo6GiaNGnCgwcPcht+tr19+5ZTp06J1b4CIBKiHEnpIcrO9KszZ87g4+PDpEmT9BiZIAhCzsUkKtO8X5LUhO6eRwnHllT+fB92U3agTowj6tymdNpRZOl6lpaWbN++nc8//5wOHTqwdu1anRaVzMzff/9NkyZN8sU+aoLhiYQoB8qVK4epqSlBQel3C79PrVYzffp0li5dSrFiolaMIAj5k4VZ2iu/1AmxqGLCKNXQDZncBOPiFpjX60TC45vptJP1Xe9lMhmjRo3i4sWLrF27lgEDBvDmzZscxZ9d+/fvp2/fvnlyLSH/EwlRDmVn2GzHjh2YmJgwcOBAPUclCIKQc04VLCgm1/5YMC5hidyyPLF3jiKpVagT44i7fxqTctqLQ4oZy3CqmP2Nqp2cnLh27Rq2trbUr1+fS5cu5eg5ZJVCoeDIkSN8+OGHer2OUHCIhCiHsjqxOjExkTlz5vDjjz/muHy+IAhCXnBvZJfuYzb95pDw5BZBKz4ieN27+kNlOo7TOi4xKYkDy2Zy4MABkpOTs3V9MzMzVqxYwapVq3B3d2fRokWoVKrMT8yBc+fO4ejoqJONuoXCQdQhyqHt27fz559/smvXrgyP+/7777ly5QoHDx7Mm8AEQRBywXPrzTTrEGWFTAYda5WljcyPjRs34ufnh4eHB6NHj8bFxSVbbQUHB+Ph4QG82xdN14nLxx9/TLVq1ZgxY4ZO2xUKLtFDlEP16tXLtIcoPDyc77//nu+++y6PohIEQcidSe0dMJPnbMd3M7kxn3ZyZMSIEZw/f55Lly5hZmZGly5daNasGevWrSM6OjpLbdna2nLq1Ck6depEo0aN+PPPP3MUU1rUajUHDx4U84eEVEQPUQ4pFAosLS0JDw+nRIkSaR4zZcoUlEolq1evzuPoBEEQci6ne5nN6eGs2eD1fUqlkr///puNGzdy6tQpevfuzejRo2nbti1GRpl/L79y5QofffQRvXv35vvvv8/xtknvtzd+/Hju37+fq3aEwkX0EOWQiYkJjo6OeHt7p/l4QEAA27dvZ/78+XkcmSAIQu54NK/KnB7OFDcxJrOpjzIZFDcxTjcZApDL5fTo0YO9e/fy6NEjGjZsyCeffELNmjX55ptvCAwMzPAaLVu25M6dO7x8+ZLmzZvj5+eXw2f2jijGKKRFJES5kNHE6tmzZzNt2jTKlSuXx1EJgiDknkfzquzybE7X2uUpJjfC7D+rz8zkRhSTG9G1dnl2eTZPNxn6LxsbG6ZOncq9e/fYtWsXwcHBuLq60r17d/bs2UNSUtrbfpQuXZo9e/YwceJE2rRpw2+//ZajmkWSJInl9kKaxJBZLnzz4wouv1Ti2OwDYhKVWJjJcapgQTUphDEeg/D39093OE0QBKGgiIhLYu/tIPxexRKTqMDCzASniqVwb2iHtXnua6u9ffuWAwcOsHHjRu7du8dHH33E6NGjcXV1TfN4b29vBg8ejIuLC+vWrcPS0jLdtsPjkth7Kwi/kBhiEpWoEuI4/+cObu76mbKlcjf0JhQuIiHKAa/AKFafC+CMXyhKhQKM/y1CZiY3IjEpGScLJd+N6IirvZXhAhUEQShgnj59yubNm9m0aRPlypVj9OjRDBkyRGvLo4SEBKZPn86xY8fYuXMnzZo1S/V4yvv0ef8wAJKU/86HMpZUyE1MaO9ow8R2DuJ9WgBEQpRt7yYb+pGoVGW4LFUme7fiYk4Ppyx3JQuCIAjvqFQqTp8+zcaNGzl+/Dg9evRg9OjRfPDBB6kmYh84cIAJEyYwbdo0ZsyYgZGRkXifFnJEJETZoOuVF4IgCELmIiMj2bFjB7/99htv3rxh1KhRjBw5kipVqgDw4sULhg4dipmZGR9OX8aqy8HifVrINpEQZZFXYBSDN1wjQaFdNVURGczL3yZT0qkVZXtN13q8uIkxuzybU8/OKg8iFQRBKLzu3LnDxo0b2blzJw0aNGD06NH07dsXuVzO1IXLOZxQA5k89bwmVUIsEUdXkPjsDkbFLSjdbgQlXdqnOka8TwtilVkWrT4XQKIy7RLykX+vpVjFmumem6hUseZcgL5CEwRBKDIaNGjAzz//TFBQEGPHjmXz5s3Y2dkxdepUwmwaYCTXnuQd+fcvyIxNsPtkG2V7TSfi7zUkhz1PdYx4nxZEQpQF4XFJnPcPS3MsOt7nPEZmJTGrkvZqCABJgrMPw4iIS3s5qSAIgpA9ZmZmDBo0iBMnTnDr1i1K2VTiemAc/32bVicn8vbhFazaemBkWhwzexdKODQj3vtsquPE+7QgEqIs2HsrKM371Ulvibq4ndIfjMm0DRmw93ba7QiCIAg5V6VKFaq0H0SxYtq9Q8rIYGRGRpiU+XcvNJNy1VD8p4cIxPt0UScSoizwC4lJtWQzRdSFrZi7dkFuYZNpG4lKNX6vYvURniAIQpGX3vu0WpGArFjqenBGxUqgTk7QOla8TxdtIiHKgphEpdZ9yaFPSHzuhUWTPtloR6HLsARBEIT/l9b7NICRSXGkpNTJj5T0FiPT4um0I96niyq5oQMoCCzMtH9NiS/uo4wOJWjNKACk5ESQ1LwKn0LFUSvSacckzfsFQRCE3EnrfRpAXsYWSa1CERmsGTZLfv0UE5sq6bQj3qeLKpEQZYFTBQuKyUNSdcea1+9KSee2mp9j/tmPMjqUMl0npdmGmdwIp4ql9B6rIAhCUZTW+zSAkakZJRxbEHVxO9bdPyX59RPeBlyngscPWm2I9+miTQyZZYF7Izut+4xMzDA2L625yUzMkMlNMS6R9p46EuDeULsdQRAEIffSep9OUabLRCRlMkE/DyX8zx+w7jIR0zR6iMT7dNEmeoiyoKx5MdrVsuGkb2i6ZeCt2gxN93yZDDo42uhkE0RBEARBW0bv08bFS1Gu/9wMzxfv04LoIcqiSe0dMJMb5+hcM7kxE9s76DgiQRAE4X3ifVrIDZEQZZGrvRVzejhR3CR7v7J3e+Q4iXLwgiAIeibep4XcEENm2ZCy8Z/YRVkQBCF/Eu/TQk6JzV1z4F5QFGvOBXD2YRgy3hXzSmEmN0Li3Vj0xPYO4huHIAiCAYj3aSG7REKUCxFxSey9HYTfq1hiEhVYmJngVLEU7g3txMQ8QRCEfEC8TwtZJRIiQRAEQRCKPDGpWhAEQRCEIk8kRIIgCIIgFHkiIRIEQRAEocgTCZEgCIIgCEWeSIgEQRAEQSjyREIkCIIgCEKRJxIiQRAEQRCKPJEQCYIgCIJQ5ImESBAEQRCEIk8kRIIgCIIgFHkiIRIEQRAEocgTCZEgCIIgCEWeSIgEQRAEQSjyREIkCIIgCEKRJxIiQRAEQRCKPJEQCYIgCIJQ5ImESBAEQRCEIk8kRIIgCIIgFHkiIRIEQRAEocgTCZEgCIKQZzZv3kzr1q01P5ubm/PkyRMDRpS2kSNHMnfuXEOHIeQhkRAJgiAI6ZLJZAQEBKS67+uvv8bDw0Mn7cfFxVG9enWdtPW+tOLWhSVLlmBubo65uTlmZmYYGxtrfnZxccl2e+fOncPOzk7ncQrZJxIiQRAEIV9SqVSGDkHLl19+SVxcHHFxcaxdu5YWLVpofvb29jZ0eEIuiIRIEARByLGUHo5ly5ZRrlw5KlasyKZNmzSPR0RE0Lt3bywsLGjatCmPHz9Odf77PTkjR47k448/pkePHpQsWZKzZ8/y8uVL+vfvj42NDdWqVWPlypWac1UqFUuWLKFGjRqUKlWKRo0aERgYSNu2bQFwdXXF3NycXbt2AXDkyBHq16+PlZUVLVu25N69e5q27ty5Q8OGDSlVqhSDBg0iMTEx278LPz8/OnfuTJkyZXB0dGT37t2ax44ePUrt2rUpVaoUtra2/Pjjj8THx9O9e3devnyp6WV6+fJltq8r6IZIiARBEIRcCQkJITo6muDgYH777TcmTZrEmzdvAJg0aRJmZma8evWKjRs3snHjxgzb2rFjB3PmzCE2NpaWLVvSq1cvXF1dCQ4O5vTp0/zvf//jxIkTAPz000/s3LmTo0ePEhMTw8aNGylRogQXLlwAwMvLi7i4OAYNGsTt27cZPXo069atIyIigvHjx9O7d2+SkpJITk7mww8/ZNiwYURGRjJgwAD27duXrd9BfHw8nTt35qOPPuL169fs3LmTiRMnanqNxowZw7p164iNjeXBgwd88MEHlCxZkmPHjlGpUiVNL1OlSpWy++sXdEQkRIIgCEKumJiYMG/ePExMTOjRowfm5uY8fPgQlUrFvn37WLhwISVLlqROnTqMGDEiw7b69OlDq1atMDIy4v79+4SFhTFv3jxMTU2pXr0648aN448//gDg119/5ZtvvsHR0RGZTIarqyvW1tZptrthwwbGjx9Ps2bNMDY2ZsSIERQrVoxr165x7do1FAoFU6dOxcTEBHd3d5o0aZKt38GRI0eoWrUqo0aNQi6X07BhQ/r378/evXs1vyMfHx9iYmIoXbo0DRs2zFb7gv6JhEgQBEFIl7GxMQqFItV9CoUCExMTzc/W1tbI5XLNzyVKlCAuLo6wsDCUSiX29vaax6pUqZLh9d4/9vnz57x8+RIrKyvNbcmSJYSGhgIQGBhIjRo1svQ8nj9/zrJly1K1FRgYyMuXL3n58iW2trbIZLIsx5lW+9evX0/V/vbt2wkJCQFg3759HD16lCpVqtCuXTuuXr2arfYF/RMJkSAIgpCuypUr8+zZs1T3PX36NEsJg42NDXK5nMDAQM19L168yPCc95MSe3t7qlWrRlRUlOYWGxvL0aNHNY//d05Seuzt7ZkzZ06qtt6+fcuQIUOoWLEiwcHBSJKU5TjTar9du3ap2o+Li+OXX34BoEmTJhw6dIjXr1/z4YcfMnDgQK3nKxiWSIgEQRCEdA0aNIhvvvmGoKAg1Go1p06d4vDhw7i7u2d6rrGxMf369ePrr7/m7du3+Pj48Pvvv2f52k2bNsXCwoLvvvuOhIQEVCoVDx484MaNGwCMHTuWr776ikePHiFJEvfu3SMiIgKA8uXLp6pvNG7cONauXcv169eRJIn4+Hj++usvYmNjadGiBXK5nJUrV6JUKtm/fz///PNPtn5Pbm5u+Pv7s3XrVhQKBQqFghs3buDr60tycjLbt28nOjoaExMTLCwsMDY21sQZERFBdHR0tq4n6J5IiARBEIR0zZs3j5YtW9K6dWtKly7NjBkz2L59O3Xq1MnS+atWrSIuLo4KFSowcuRIRo0aleVrGxsbc/jwYe7evUu1atUoW7YsY8eO1SQPn332GQMHDqRLly5YWFgwZswYEhISgHe1kkaMGIGVlRW7d++mcePGbNiwgcmTJ1O6dGkcHBzYvHkzAKampuzfv5/NmzdTunRpdu3aRb9+/bL1eypVqhR///03f/zxB5UqVaJChQrMnDmTpKQkALZu3UrVqlWxsLBg7dq1bNu2DQAnJyeGDBlC9erVsbKyEqvMDEgmvd9HKAiCIAiCUASJHiJBEARBEIo8kRAJgmBwo0ePply5cukOw0iSxKeffoqDgwP16tXj9u3beRyhIAiFnUiIBEEwuJEjR3L8+PF0Hz927BiPHj3i0aNHrF+/no8//jgPoxMEoSgQCZEgCAbXtm1bypQpk+7jhw4dYvjw4chkMpo3b05UVBSvXr3KwwgFQSjsREIkCEK+FxwcnKpgn52dHcHBwQaMSBCEwkae+SGCIAiGldZi2PQK2q1fv57169cD7zbbdHJy0mtsgiDkH8+ePSM8PDxH54qESBCEfM/Ozi5VteOgoKB0N8H09PTE09MTgMaNG3Pz5s08iVEQBMNr3Lhxjs8VQ2aCIOR7vXv3ZsuWLUiSxLVr17C0tKRixYqGDksQhEJE9BAJgmBwQ4YM4dy5c4SHh2NnZ8eCBQs0G4pOmDCBHj16cPToURwcHChRogSbNm0ycMSCIBQ2IiESBMHgdu7cmeHjMpmM1atX51E0giAURUU2IQqPS2LvrSD8QmKISVRiYSbHqYIFAxrZYW1ezNDhCYIgCIKQh4pcQuQVGMXqcwGc9w8DIEmp1jxmJg9h+Sl/2jvaMLGdA672VgaKUhAEQRCEvFSkEqJt156x+KgfiUoVaW1pm/j/ydHfPqFc8A9nTg8nPJpXzdsgBUEQBEHIc0UmIXqXDPmSoHiX9EhKBRF/ryHx2V3UiXHIrSpSut1witdojCRBgkLF4qO+ACIpEgRBEIRCrkgsu/cKjGLxUT9NMgQgqVXIS5WlwkffYj9tF1ZtPQg79B3KqFDNMQkKNYuP+nEvKMoAUQuCIAiCkFeKREK0+lwAiUpVqvuMTM2wajMUuVV5ZDIjSjg0RW5ZnqSQgFTHJSpVrDmX+j5BEARBEAqXQp8Qhcclcd4/LM05Q+9Txb9BERmMqU3lVPdLEpx9GEZEXJIeoxQEQRAEwZAKfUK091ZQpsdIKiXhf/6Ied2OmFjbaz0uA/bezrwdQRAEQRAKpkKfEPmFxKRaWv9fkqQm/MgyMJZTpvOENI9JVKrxexWrrxAFQRAEQTCwQp8QxSQq031MkiQijq5EFR+FTd8vkRmnv+guJlGhj/AEQRAEQcgHCn1CZGGWfpITeWI1iohAyrnPw8gk4+rUFmYmug5NEARBEIR8otDXIXKqYEExeYjWsJky+jVxd4+DsQlBPw/T3F+m2yTMXTqkbkSlIPyxF69fV6JcuXJ5EbYgCIIgCHmo0CdE7o3sWH7KX+t+uWU5qsw6kqU25CYmKPwvUavWFFq2bImHhwd9+vShZMmSug5XEARBEAQDKPRDZmXNi9Gulg0yWc7Ol8mgk3N5/ti8geDgYDw8PNi2bRu2trYMHz6cEydOoFSmP09JEARBEIT8r9AnRACT2jtgJjfO0blmcmMmtncAoGTJknz00UccPXqUhw8f0rhxY+bNm4e9vT3Tpk3j1q1bSJkVPBIEQRAEId8pEgmRq70Vc3o4YYwq84PfU9zEiDk9nKhnZ6X1WPny5fn000+5fv0658+fx8LCgoEDB1K7dm0WL17M06dPdRS9IAiCIAj6ViQSIoAKcQEkXd1JMbks0+EzmQyKmxgzp4dzljZ2rVWrFgsWLCAgIICNGzfy8uVLmjZtSuvWrVm7di0RERG6eRJCkRcel8Ta84+ZuusOo3+/wdRdd1h7/rGopC4IgpBLMqkIjPEEBQXRpEkTduzYgXXNBqw5F8DZh2HIeFd0MYWZ3AgJ6OBow8T2Dmn2DGVVcnIyJ06cYPv27Rw7dowOHTrg4eGBm5sbZmZmuX5OQtHiFRjF6nMBnPcPA0i1ajLl77a9ow0T2zngam9lmCDzocaNG3Pz5k1DhyEIQh7JzWu+0CdECoWC9u3b07NnT7788kvN/RFxSey9HYTfq1heRURx7cJZZk8cjntDO6zNM65JlF0xMTHs37+fbdu2cfv2bfr164eHhwdt27bFyKjIdNIJObTt2jMWH/UjUanKcE8+mezdnLc5PZyy1LNZFIiESBCKFpEQZeDzzz/Hz8+Pw4cPp5t8JCQkYGVlRUJCgt4TlODgYHbu3Mm2bduIiIjgo48+wsPDg7p16+r1ukLB9C4Z8iVBkf72M//1bu5b1oZ7CzuREAlC0ZKb13yh7p7Yv38/+/btY+vWrRkmOsWLF8fCwoLXr1/rPSZbW1umT5/O3bt3OXbsGEZGRvTs2RNXV1d++OEHgoLEJrLCO16BUSw+6qeVDCnCAwnZ8SUvlg8keO043j68kurxBIWaxUf9uBcUlYfRCoIgFGyFNiEKCAhgwoQJ7N69mzJlymR6vL29fZ4nI3Xq1GHp0qU8e/aMlStX4u/vT7169ejYsSObNm0iOjo6T+MR8pfV5wJIVKZeGSmpVbzet4gSDk2wn7KTMt0mE35kGYrI4FTHJSpVrDkXkJfhCoIgFGiFMiFKSEjA3d2d+fPn07Rp0yydY29vT2BgoJ4jS5uRkRHt2rVjw4YNvHz5kokTJ/Lnn39SuXJlBg4cyJ9//klycrJBYhMMIzwuifP+YVpzhhQRgajiIinV5ENkRsYUr+pKMdvaxD84k+o4SYKzD8PE6jNBEIQsKpQJ0aeffoqzszMTJ07M8jmGTIjeZ2ZmRv/+/Tlw4ABPnz6lY8eO/Pjjj9ja2jJx4kSuXLkiij8WAXtvpdNbmeY/vURy2HOte2XA3tsFYwj2+PHjODo64uDgwLfffqv1eHR0NL169cLV1RUXFxc2bdpkgCgFQSjMCl1CtHnzZi5dusT69euRZWO/jvySEL2vTJkyjB8/ngsXLnDjxg3s7OwYM2YMDg4OzJs3j4cPHxo6REFP/EJitDYkBjCxtsO4hCUx1/chqZQkPL1N4osHSErtnqBEpRq/V7F5EW6uqFQqJk2axLFjx/Dx8WHnzp34+PikOmb16tXUrl0bLy8vzp07x+effy56TQVB0KlClRDdv3+fL774gr1791KqVKlsnWtnZ5fvEqL3Va1alS+//BIfHx/27NlDXFwc7du3p0mTJqxYsYLQ0FBDhyjoUETs2zTvlxnLsek/l4THNwn6eRgx/xygpHNrjEuVTfP4mESFPsPUiX/++QcHBweqV6+OqakpgwcP5tChQ6mOkclkxMbGIkkScXFxlClTBrm80O9NLQhCHio07ygxMTG4u7vz008/4eLiku3z82MPUVpkMhkNGzakYcOGfP/995w5c4bt27czf/58WrRogYeHBx9++CElS5Y0dKhCFkRHR+Pt7a25PXjwAG9vb2gxgmKObdI8x7RcNSoM/XdYKWTrdErW6ZjmsRZmJnqJW5eCg4Oxt7fX/GxnZ8f169dTHTN58mR69+5NpUqViI2NZdeuXaKGlyAIOlUoEiJJkhg7diwdOnRg2LBhOWqjoCRE75PL5XTp0oUuXboQHx/Pn3/+ybZt25g0aRK9evVi6NChdOrUSXyTzgfi4uLw8fFJlfR4e3sTGRlJ7dq1cXFxwcXFha5du+Li4sLRp8ksP/UozWGz5NdPMSljiySpib19FGXcG8zrdtI6zkxuhFPF7PWUGkJac+L+O9x94sQJ6tevz5kzZ3j8+DGdO3emTZs2WFhYaJ27fv161q9fD0BYWJh+ghYEodApFJ+UP//8M48fP2bLli05bsPW1paQkBBUKhXGxsY6jC5vlCxZkiFDhjBkyBBev37Nrl27mD9/PiNHjmTw4MF4eHjQqFGjbM2rErIvISEBX1/fVEmPt7c3oaGhODo64uLiQp06dZg0aRIuLi5UrVo1zZ4O9zJJLD/1KM1rxD84S5zXCSS1imL2LpQfvAiZXLsnSALcG9rp+inq3H+Hq4OCgqhUqVKqYzZt2sSsWbOQyWQ4ODhQrVo1/Pz80lxF6unpiaenJ/CuSJsgCEJWFPiE6Nq1a3zzzTdcu3YtV3uEmZqaYm1tTUhICLa2tjqMMO+VK1eOTz75hE8++YRHjx6xfft2Bg8ejFwux8PDg6FDh1KtWjVDh1mgJSUl4efnpzXcFRwcjIODA3Xq1MHFxYUxY8bg4uJCjRo1spVolzUvRrtaNpz0DdVael/6g9GU/mB0hufLZO/25NP1NjT60KRJEx49esTTp0+xtbXljz/+YMeOHamOqVy5MqdPn6ZNmzaEhoby8OFDqlevbqCIBUEojAp0QhQeHs6gQYP49ddfdfLmmDJsVtATovfVrFmTr7/+mvnz53P9+nW2bdtG06ZNcXR0ZOjQoQwcOBBra2tDh5lvKRQK/P39teb4PHv2jOrVq2uGuoYOHUqdOnVwcHDAxEQ383YmtXfggn9Yqg2Is8pMbszE9g46iUPf5HI5q1atomvXrqhUKkaPHo2Liwtr164FYMKECXz11VeMHDmSunXrIkkS3333HWXLpj2RXBAEIScK7F5marWaHj16UK9ePb7//nudtNm/f38GDx7MgAEDdNJefqVQKDhx4gTbtm3j2LFjtG/fHg8PD9zc3ChevHiu2w+PS2LvrSD8QmKISVRiYSbHqYIFAxrpfuNcXVEqlTx+/Fhrjk9AQACVK1fWJD4pPT+1atWiWDH9Ppfo6GhaDJtBkktPVGS9d0nsZfYvsZeZIBQtuXnNF9geoiVLlvD27VsWL16sszbz+9J7XTExMcHNzQ03NzdiYmI4cOAA69evZ/z48fTt2xcPDw/atWuX7VU8XoFRrD4XwHn/dxNZ358QbCYPYfkpf9o72jCxnQOu9la6fEpZplarefr0qdYcn4cPH1KxYkVN0tOrVy9mzZqFk5OTTpLE7EpISKB37958ULcuzXrXY8kxsdu9IAiCPhXIHqJTp04xfPhwbt68qTX5Mjd+/PFHgoODWb58uc7aLEiCg4P5448/2LZtG+Hh4QwZMgQPDw/q1auX6bnvdmXPPx/aarWaFy9eaM3x8fPzw9raWtPTk5IAOTs755tSBQqFgv79+2Nubs62bdswMjLiXlAUa84FcPxeECYmJry/36uZ3AiJd3OGJrZ3oJ6dlaFCz3dED5EgFC25ec0XuIQoODiYxo0bs2PHDjp06KDTtnft2sWePXvYu3evTtstiB48eMD27dvZsWMHlpaWeHh48NFHH2Fnp71q6V0y5KvZlT3m1mHi758mOewZJZ3bUdZtmtY5uhrWkSSJ4OBgrTk+Pj4+WFhYaA111a5dO82l2vmFWq1mxIgRREZGcvDgwVTzkWJiYrCt7si3u84REJ5ATKICCzMTnCqWwr1h/h2ONCSREAlC0VJkhswUCgWDBg1i8uTJOk+GwDA73udXderUYenSpSxevJhLly6xbds2XF1dcXV1xcPDg/79+2NpaYlXYBSLj/ppkiEAubk1li0HkfD0NpIi7e0VEhRqFh/1o56dVZZ6NCRJIjQ0VGuOj7e3N8WKFdMkPc2aNdNMyi1durSufh15QpIkpk6dyrNnzzhx4oTW5OxLly7RuK4Tkzo6GihCQRCEwqtAJURffvklFhYWzJ49Wy/tF8TijPpmZGRE27Ztadu2LStXruTo0aNs27aNadOm0aVLFxKbDCdRmXquUQnHlgAkhQSgUoSn23aiUsWacwGs9UhdKyYsLCzt6s2g6elxdXXlo48+wsXFBRsbGx0/a8NYuHAhFy5c4Ny5c5QoUULr8fPnz9OuXTsDRCYIglD4FZiE6MCBA+zZs4dbt27prWR/xYoVCQsLQ6FQ6GzpdGFiZmZGv3796NevH5GRkfy+az8rnqkhh/8ekgSnfUNZvmYDT3zvaRKgpKQkzVCXi4sL/fv3x8XFhfLlyxfawpI///wz27Zt49KlS1hZWaV5zPnz59PcCV4QBEHIvQKRED1+/Jjx48dz5MgRvdbMkcvllCtXjpcvX1KlShW9XacwKFOmDMVrd6DYS/80t5fIKoVCwRGfcHpWr4abmxsuLi7Y2toW2sQnLdu2beP777/n4sWLlC9fPs1jYmNjefDgAc2aNcvj6ARBEIqGfJ8QJSQk4O7uzrx589Is069rKcNmIiHKnF9ITK6SIQCMTajXpjufDaqvk5gKmiNHjjB9+nTOnDlD1apV0z3uypUrNGrUyCAlAARBEIqCfJ8QTZkyBUdHRyZNmpQn1xPziLIuJlGpo3YUOmmnoLlw4QKjR4/myJEj1K5dO8Njz507J+YPCYIg6JF+JuPoyJYtW7hw4QIbNmzIsyEUkRBlnYVZ2vm0pFYhKZNBrQJJjaRMRlKrMmin6M3XunPnDu7u7uzcuTNLPZ/nz5+nffv2+g9MEAShiMq3PUT379/n888/5+zZs5QqVSrPrmtvb8+TJ0/y7HoFVUJCAnFB/qAqBsapE5roy38QfXmn5ud477NYthqCVZuhWu2YyY1wqph3/775gb+/Pz169GDt2rV07Ngx0+Pj4+O5d+8ezZs3z4PoBEEQiqZ8mRDFxsbi7u7OTz/9RJ06dfL02vb29pw/fz5Pr1mQPH36lF9++YVNmzbRoEVb5HVGo/xPaU+rNkPTTH7SIgHuDbWLPRZWgYGBdOnShcWLF9OvX78snXPlyhUaNGiQ5lJ8QRAEQTfy3ZCZJEmMHTuW9u3bM2zYsDy/vhgy06ZWqzl27Bhubm40adIEtVrNtWvX+PvPfXzgXJ6cjmZKajU1SyZTpqSpbgPOp8LDw+nSpQuTJ09m9OjRWT5PzB8SBEHQv3yXEK1evZpHjx6xYsUKg1y/qGzwmhWRkZEsW7aMWrVqMXfuXPr168eLFy/48ccfqVGjBgCT2jtgJs/6TuypqBVc27iAjh07EhAQoMPI85/Y2Fi6d+9O3759mT59erbOFQUZBUEQ9C9fJUTXr19n4cKF7NmzBzMzM4PEUL58ed68eUNSUpJBrp8f3L59mzFjxlCjRg3u3r3Ltm3buHnzJqNHj9YatnG1t2JODyeKm2TvT6m4iRHzetWhX/vG3L17l0aNGrFo0aJC+XtPTEykT58+NGrUiMWLF2fr3Ldv33Lnzh1atmypp+gEQRAEyMM5ROFxSey9FYRfSAwxiUoszOQ4VbBgQKN3m1JGREQwcOBANmzYoOl9MARjY2MqVapEUFCQQePIa0lJSezZs4fVq1fz8uVLJkyYwMOHDylXrlym56Zs0PrNX74kJCuRZVC5+r+73Y9pu57evXszZswYtmzZwpYtW1i3bh0ffPCBrp6aQSmVSgYPHoyNjQ2rV6/O9mrJq1ev4urqSsmSJfUUoSAIggB5kBB5BUax+lwA5/3DAFIV8jOTh7D8lD/tapXl0cHVDBo0iD59+ug7pEylzCMqCgnRixcvWLt2Lb/99huurq7MmjULNzc3jI2zNwzm0bwqz+9eYte9SJKsayIDElP9WxshAR0cbZjY3iHVhq5ubm7cv3+fcePGcf/+fTw8PPjggw9YtmxZupWbCwK1Ws24ceNITExk9+7d2f6dwrv5Q2K5vSAIgv7pNSHadu0Zi4/6kahUIUnaj6d8YP7tE4qsxoeM7FNXn+FkWWGfWC1JEqdOnWL16tVcvHiRYcOGceHCBRwdc7eL+l9b1vDNrFm0+uAD9t4Owu9VLDGJCizMTHCqWAr3hu96A9NSrlw5Dh48yMaNG5k5cyavXr3CxcWFb775Bk9PT73tX6cvkiQxffp0Hj58yMmTJzE1zdnE8fPnzzNnzhwdRycIgiD8l0yS0kpVcu9dMuRLgiLrWzsUNzFiTg9nzRCMocycORMrKytmz55t0Dh0LSoqit9//501a9ZgZmbGpEmTGDp0qE6GY7y9venSpQvPnz9HLs9dnv348WOGDRuGWq1GpVJhZGTE2rVradCgQa7jzCuLFy9m165dnD9/ntKlS+eojYSEBGxsbAgJCcHc3FzHERYNjRs35ubNm4YOQxCEPJKb17xevnZ7BUax+KhfmslQvM95gjdM4MWy/gSvHUti4APNYwkKNYuP+nEvKEofYWVZYVtpdu/ePcaPH0+1atW4du0av/32G3fv3sXT01Nnc1M2bNjAqFGjcp0MAdSoUYMLFy7g5ubGixcvaNCgAd26dWPatGnExsbqIFr9+uWXX9i4cSMnTpzIcTIEcO3aNerUqSOSIUEQhDygl4Ro9bkAEpXaWzUkPL3Dm3ObKdtjKvaf7aH80G+RW1VIdUyiUsWac4Zdgl0YhsySk5P5448/aNOmDT169MDOzg5fX1927txJ69atdboVSmJiItu2bWPMmDE6a1MulzN37lz++usvzp07R5s2bXj9+jW1a9dm79696KljM9d27tzJ4sWLOXnyJBUrVsxVW2K7DkEQhLyj84QoPC6J8/5hac4Zir60HctWQyhm64RMZoS8VFnkpcqmOkaS4OzDMCLiDLf8uiAnRMHBwcybN48qVaqwfv16pk6dytOnT/nqq6+oUKFC5g3kwL59+2jUqBHVqlXTeduNGzfm9u3bVKhQgUuXLjF9+nTmz59Pz549890WK0ePHmXq1KkcO3aM6tWr57o9UZBREAQh7+g8Idp7KyjN+yW1iqRXAajfRhO8dhxBq0cQ+fcvqBXaiY8M2Hs77XbyQkFLiCRJ4uzZs7i7u1O3bl0iIyM5ffo0Z86coX///piY6Hfz1A0bNjBu3Di9tV+iRAlWrVrFunXr+P777+nSpQutWrWiadOmLF68OF/ULrp06RIjRozg4MGD1K2b+8UBiYmJ3Lx5k1atWukgOkEQBCEzOk+I/EJiUi2tT6GKjwK1krcPL1Pe4zsqjlpJcugToq/s0jo2UanG75Xh5orY2NgQHx/P27dvDRZDVsTGxrJ69Wrq1KnDpEmT6NChA8+ePWPVqlXUrl07T2J4+PAhfn5+9O7dW+/X6tatG15eXrx48YJdu3axdetWrl27Rv369Tl37pzer58eLy8v+vXrx/bt22nRooVO2rx+/Tq1a9fGwsJCJ+3ld8ePH8fR0REHBwe+/fbbNI85d+4c9evXx8XFRfScCYKgczpPiGISlWneLzN5t9y6VKNeyM3LYFzCklJNPiThcdqzwWMSFboOLctkMlm+nljt4+PDpEmTqFKlCmfPnmXVqlV4e3szadKkPP8A/fXXXxkxYkSOl5VnV9myZdm7dy+fffYZw4cPp23btixevJjhw4czYsQIXr9+nSdxpAgICKB79+6sXr2aLl266KzdorRdh0qlYtKkSRw7dgwfHx927tyJj49PqmOioqKYOHEif/75J97e3uzZs8dA0QqCUFjpPCGyMEt7lZGxmTnG/5kvlHE7+h3myYy9vT1BQYYbtvsvpVLJvn37+OCDD+jYsSPW1tbcu3ePvXv30qFDB51Oks6qpKQktmzZwtixY/P0ujKZjJEjR/LPP/9w6NAhfv75Z06cOIGNjQ116tRh/fr1qNVZL/eQU8HBwXTp0oUFCxYwYMAAnbZdlAoy/vPPPzg4OFC9enVMTU0ZPHgwhw4dSnXMjh076NevH5UrVwbIUgV1QRCE7NB5QuRUwYJi8rSbNa/bidhbR1DFR6FKjCP25iFKODTROk6OGgeb4roOLVvySw9RSEgIixYtomrVqvzvf//D09OT58+fs3DhQuzs7Awa26FDh3BxcaFmzZoGuX61atU4f/48Xbt2pV27djRo0ICTJ0+yefNmWrdujZeXl96uHRERQZcuXRg/frzO508lJSXxzz//0Lp1a522m18FBwdjb2+v+dnOzo7g4OBUx/j7+/PmzRvat29Po0aN2LJlS16HKQhCIafzhMi9Ufof0patBmNasSbB68fzcsMETMvXwLLlIK3jFEol0/u1ZsCAAdy/f1/XIWYqIiKCJ0+eMHfuXGQyGU2bNmXevHlERkbmyfUlSeLSpUsMGTIEZ2dngoKCOHr0KBcvXmTw4MF5NjyVGX1Pps4KY2NjZs2axYkTJ1i8eDFLly7l8OHDjBo1is6dO/P5558TFxen02vGxcXRs2dPevbsycyZM3XaNrzrMXFycsLS0lLnbedHaZVQ+G+Pp1Kp5NatW/z111+cOHGCRYsW4e/vn2Z769evp3HjxjRu3JiwsDC9xCwIQuGj84SorHkx2tWyIa0RHJmxHOuuE6k8bRf2n2yjTOfxyOSpP9xlMuhUuyKzpk3m7NmzNGzYkOrVq7Nq1ao8Kcq3fv16atWqhZGREY0aNeLGjRssX76cly9fUrNmTTZu3Ki3a8fFxbF+/Xrq16/PmDFjaN68OU+fPmXdunXUq1dPb9fNiSdPnnD37l369u1r6FAAaNCgAbdu3aJ8+fLUr1+fatWq8eDBA8LDw6lduzYHDhzQSe2ipKQk+vbtS506dfjuu+90ELm2ojR/CLR7Y4OCgqhUqZLWMd26daNkyZKULVuWtm3bptsD6Onpyc2bN7l58yY2NjZ6jV0QhMJDL4UZJ7V3wEye/Y0s4d1O6FM6OzF//nzCwsL466+/KF++PJ999hk2NjYMGDCAa9eu6aUw35kzZ5g/fz7Xrl1j5syZJCcn07hxY1q1asWvv/7KpUuXmD17NhcvXtTpdf39/Zk6dSpVqlTh6NGj/Pjjj/j6+jJlyhSsrKx0ei1d+fXXXxk2bBhmZmaGDkWjePHirFixgo0bNzJy5EiWLFnC2rVr2bJlC19++SW9e/fm2bNnOW5fpVIxdOhQLC0tWbdund7mbRWl+UMATZo04dGjRzx9+lRTUPS/qxb79OnDxYsXUSqVvH37luvXr+Ps7GygiAVBKIz0khC52v9fe3cfV/P9/gH8dU6nWzcpCjlYdUo5lCVJWzduU27mLtrY5ibNsGKzjR9msxltYzM3a2HMXW7ayJfcFYUsJCIVFVJJupFKpzo3n98fVpPuTnVO5+56Ph49Huq8z/tc73QeXb0/1+d9dcJybxvoazdv+pe9zGxqOqGzWCyMGjUK//zzD9LS0jB37lycPHkSw4cPxxtvvIENGzagoKBAJjGXl5dj+vTp2Lt3L6ysrOo9i8jW1ha7d++Gr68vKioqWvV6YrEY4eHhGDVqFFxdXWFgYIAbN27g6NGjGDlypFI3MxUKhdi1a5fCL5c1ZOTIkbh16xYeP34MR0dHdOrUCYmJiRgyZAgcHR2xbt06VFVV1YwvKKtEcEwGFh28gdl/XsOigzcQHJNR63BQhmHw0Ucf4fnz59i3b1+LOtdLo6qqCleuXIGrq6tc5ldGHA4HmzdvhqenJ2xtbTF16lTw+XwEBwcjODgYwMv33ujRo2FnZwcnJyf4+fmhX79+Co6cEKJO5NbcFWi6231NEKyXO0PLvW2abOxaUVGBgwcPYu3atcjJyYFIJIKXlxfmz5+PYcOGtTiROHr0KDZv3ozIyEgAQFFREczNzfH8+fM6Y93c3LB06VJ4e3s3+3Xy8/Oxfft2BAcHw8zMDAsWLICPjw90devvAq+Mjh49ip9++gmXLl1SdCiNYhgGe/fuxaeffoolS5ZgyZIlyMzMxMKFC5GZmYnP127G5ecdEHPvZZ3Jq+dn6XHYYAB49DHBfHce9m36HhcuXEBkZKRce4tdvnwZCxcuREJCgtxeQ5NQc1dCNIvSNXetNsP5DRz0d4Zn367Q5bCh99rdZ3ocNnQ5bHj27YqD/s5SdbnX09PDhx9+iNTUVERFRWH8+PE4deoUpk2bhp49e+Lbb79t0e3yR48exYQJEwC83DE4dLsI+kPn4YMd/9TZMZgwYQKOHj0q9dwMwyAuLg7vv/8+rK2tkZ6ejiNHjuCff/7BjBkzVCoZAl7WWfn7+ys6jCaxWCy8//77iI+Px8mTJzF06FCw2WycOHECngvXYNXFZzhzJxeVIkmdw0Qr/v3ameQ8TN56EUeTCnHixAm5N1qldh2EEKIYct0helVhWSXCErKRmluKkgohOuppw6Z7B0xx4KJz+9YlBE+fPsW2bdvw66+/gs1mo7S0FK6urvD398fYsWOlal3h5uaGWUu+xj/POza5Y+BoUIQDW4IQFRXV6JwCgQChoaHYsmVLzcFys2bNgrGxcavWq0jV3eezsrJgYGCg6HCkJhaLsWHDBvzwww+YunwToooMUSGU/qwiPQ4LK8b0lSppbw1PT0/Mnz8f77zzjlxfR1PQDhEhmqU17/k2S4jagkgkwrFjx7Bx40YkJibC0NAQAoEAs2bNwpw5c2Btbd3gc9/0CcALa08IGTR5eU+bBXTMiET8gZ/rHZORkYHffvsNf/75JwYPHowFCxbA09NTqeuCpPX111+joKAAmzdvVnQoLRJ27hqWnMwGXru7UVSch8IzW1GVkwpwtNGuz1swGuEPFvu/WiF9bS0c9HeuqXGTNaFQiM6dO+Phw4cqnTQrE0qICNEsSnvJrK1xOBxMmjQJMTExiI2NxZgxY1BZWYljx47B2dkZ7u7u2LNnT50eZXvjHqLYfBiqJP8lQ4/WT6n1kRk0HkVngsEwQJUEKOztjr1xD2vmEIvFOHHiBLy9veHs7Aw2m40rV67g+PHj8PLyUotkSCwWY8eOHUpbTC2NMzmsOkc9AEDhma3QMugE7id7YDZrEyqyklCacKLWmAqRGFuj0+UW2/Xr12Fubk7JECGEKED9fTbUAJ/Px9atW7F27Vrs3r0bmzZtQmZmJn744QcEBgbC19cXfn5+0DKxwJqIVDBatS+r9fosrObfkqoKZG+aAQOb/04OZtjaWBORit4dWIiLOITffvsNnTt3xoIFC/DXX39BX1+xJ23Lw6lTp2BmZgZ7e3tFh9IiBWWViLmXj/o2AEXP89Bx4FiwODrQaq8DffOBEBY8qjWGYYDzd/NRWFbZ6su89dG02+0JIUSZqP62RRMMDQ3xySefIDU1Fdu2bYOFhQUYhsHNmzcxbtw4TFm1DQJh/Q1pq5XfjYWWgSF0e/JrfV1QJcS01TuRlJSEAwcO4Nq1a5g5c6ZaJkOAcpxM3Rph1xsutu/oOB4vki9AIqyAqLQAgvvx0Dd3qDOOBSAsQT497jTtQEZCCFEmap8QVWOz2Rg5ciTCw8ORkJAAV1dXVLF0IOxihZe/5hpWdjsK7foNq3sQH4uN9lZO2LAlBE5OTvILXgk8fvwYFy5cgK+vr6JDabHUJyV17iarptezP4QFj5C1YSpytsyETjcr6FsPqTOuQiRBaq7sT0wXiUSIjY2Fm5ubzOcmhBDSNI1JiF5lbm6OoKAgfLXrJDhNnKgtev4UlVlJaNd/eL2Ps1ksue0YKJOdO3fCx8dH7redy1NJRf07gQwjQd6hr2DQxwW9PvsL3MD9kFSUoTh6ZwPzCGUeW0JCAnr37o0uXbrIfG5CCCFN08iEqFpGoQAipvFvQVnSOehy+0K7U7d6H5fXjoEykUgk2L59u0pfLgOAjnr1l8xJBKUQl+Sjg8NYsDja0NLviPZ2IyDIqP9OhTs34lFYWCjT2Kh+iBBCFEujE6KGdgxe9SLpHNr3G9bEPLLfMVAmkZGRMDIywsCBAxUdSqt01RVBC+I6X9cyMATHsCtKb0SAkYghqShD2e0oaJua1xmry2HBmF0OPp+PXbt2yaynHtUPEUKIYml0QtTQjkG1iuwUiMsKa91dVv88TR/8qMqqi6nl1cxUnoRCIY4cOQIvLy9sWDi1wTOmTCYth+D+dWRvfA85v788f8h4eN0dMaFQhG9nj8WJEyewZcsWuLu7486dO62KUSQS4dKlS1Q/RAghCqS2t91Lw6ZbR+hynjRYaPsiKQoG1i5g6zZ8IrOOFgs23TvIK0SFy8vLw9mzZ7F9+3ZFh9Is9+/fx/bt27Fr1y7weDz4+/vj78mTERh2B2dT8uokRjpdLdBt+rpG52QB4LKfw9PjLXh5eWHnzp2IiYmBh4cH/Pz8sHLlSqlO7y4oq0TY9WykPilBSYUIwhfPYeo+HVoGhq1YMSGEkNbQ6B2iKQO5jT7eefRCdBn3WaNjKisrcXzTSsTGxsrs8oky+fPPPzFp0iQYGir/L+uqqiqEhYVh1KhRGDx4MCoqKhAVFYULFy5gxowZ0NfXxwIPHvSaKKRviJ62FjbPH4eMjAz07dsXw4cPR3R0NPbv34/MzEzw+XwcP368wecnZhXDf0883go6h58j7+Hozcc4l/oUF7MqIe7rCZegc/hobzwSs4pb+B0ghBDSUhqdEHVprwt3axO0+EoQI4E4KxGCZ08xffp0ODs74+DBgxCJmq5NUgUMw6hEMXV6ejqWLl2KXr16YfPmzZg5cyaysrKwYcMG2Nra1hpr37MTlnvbQF+7eT/6+tpsLPe2gR23EwwNDbFs2TLcv38fLi4umDlzJkpLS7F48WIsXrwYkyZNQlZWVq3n7417CN9tcTibkldvM1kJi1PTTNZ3W1ytU9AJIYTIn0YnRABatWOgr6ONbYt98Oabb6KsrAwSiQRr1qyBpaUl1q9fj+fPn8s42rYVExMDHR0dODs7KzqUOqqqqnDo0CGMGDECLi4uEIlEiImJQXR0NN577z3o6ek1+NwZzm9gubct9LW1mkyGWayXPcyWe9vWaezarl07LF68GBkZGfD29saGDRvQq1cvGBoaYsCAAVi/fj2EQiH2xj3EmogUCITiRvvkAS9PwxYIxVgTkUJJESGEtCG1au7aUv/9wpK++/nLHYP/fkmWl5cjNDQUmzdvRmFhIUxNTZGRkYGZM2ciICAA5uZ171hSdu+99x4GDx6MwMBARYdS4969e9i+fTv+/PNP9OvXD3PnzsXEiROhq9v8Vhq3souxNTod5+/mg4WXRyhU09ECWCw2hvYxwXwPnlQNXYVCIfbu3Yvvv/8ehoaGkEgkqGzXDUL3Bah67ea2gv/9hIqHiZAIK6DVzggdnSejg71nrTHybiarCai5KyGahbrdy8DLpCgVFaLG/4pnsQA9jhaWe9vU2TEAXl5munz5MjZv3oyIiAhYWFjg4cOHGDFiBD799FMMGVL39GNlVFhYCEtLS9y/f1/hzUYrKyvx999/Y9u2bbhz5w5mzpwJPz8/WFlZyWT+wrJKhCVkIzW3FCUVQty8ehlO1lx8N2dsi3qWicViHDp0CGvWrEHZm++BMesP1mvNfavyM6FtZAYWRxvCwiw82b8Mpj5fQ7cbr2YMiwV49u2K4BmOrV6jpqKEiBDNQt3uZWCG8xs46O8Mz75dwWExYElqny2kx2FDl8OGZ9+uOOjvXG8yBAAsFgtvvfUWQkNDkZqaiokTJ0JPTw83b97ExIkT4ezsjMOHDyt9ndGePXswduxYhSZDqamp+Oyzz8DlcvHHH3/g448/RlZWFoKCgmSWDAFA5/a6+MjNEj9PG4AdHw7COJNnMH6a0OIGrlpaWnj33Xdx7vI1cHra1UmGAEDHpDdYnOrjGlhggQXRs9xaY15tJksIIUS+KCF6hR23E4JnOGJo6Tk4tyvExAE9MNzGFBMH9MDikda4/OUwBM9wlPoSRvfu3fHVV1/h0aNHWLNmDaysrJCWlobPP/8c5ubm+Pnnn1FSUiLfRbUAwzAICQlRSDF1RUUF9u3bB3d3d3h4eEBHRwdxcXE4e/YsfHx8oKOjI/cY+Hx+q88WAoC/bzyGllbD9WmFp7fi0U+T8XjbPGi1N4a+Zd2dIHk2kyWEEPIfjT6HqCEXz0YgNPR9vPnmAJnMp62tjalTp2Lq1KlITEzEli1bEBoaio0bN+Lrr7/GnDlzEBgYiN69e8vk9Vrr8uXLEIvFbXpQYHJyMrZt24Y9e/Zg4MCBCAgIwLhx49okAXqdrBKixprJAkBnz/kwHvkRKnNSUfHoNlhadQ/41ITWMIQQogxoh+g12dnZKCgogL29vVzmt7e3R0hICB49eoSAgAB06tQJ+/fvB5/Ph4+PD65evSqX122OtjqZWiAQYM+ePXB1dcWIESNgYGCAa9eu4fTp05g8ebJCkiEAsLKyQnZ2NgQCQavmkaY1DIutBb2efIhLC1B6I6KBedS7NQwhhCgD2iF6TVRUFIYNGwZ2PXUfsmRkZIRPP/0UixYtwunTp/HLL7/g5MmTOHv2LKysrLBs2TK88847jV5ykYfi4mIcPXoUP/74o9xeIykpCdu2bcO+ffvg5OSEzz77DGPGjIG2tnK0QNHW1oalpSVSU1Px5ptvNjm+srISDx8+RHp6es1HWloa7ho5A28Mku5FJZI6NUTV1L01DCGEKANKiF4TFRWFESNGtNnrsdlseHl5wcvLC+np6diyZQu2b98OPz8/LFiwAEuXLsXs2bPRoUPbtAfZt28fPD09YWJiItN5y8vLcejQIYSEhCAzMxNz5szB9evXleYy4euqL5tVJ0Tl5eW4f/9+TcKTkZFR8+/Hjx+jV69e4PF4NR+jR49GgqAz9iY+q3PZTPyiGBWZidDnOYHF0UHFw5t4kRKDLuM+rxOHHoet1q1hCCFEWdBt969gGAY9evTAxYsXYWlpqbA4Xrx4gf379yMoKAhPnz6FRCLBnDlzsGTJEvTs2VNur8swTM2BgrJKCm/duoWQkBCEhobCxcUFc+fOhbe3Nzgc5cvFy8rKahKd4OBgPH36FEZGRkhPT0dBQQHMzc1rJT3VH7169ap3d6ugrBJvBZ2rmxCVP0f+kbWoevoAYCTgGJqiw8Bx6DBgdJ05dDlsXP5yWIvveFMVp06dQmBgIMRiMfz8/LB06dJ6x127dq3mRPgpU6Y0OS/ddk+IZmnNe175fispUEpKCnR1dWFhYaHQONq1a4e5c+fCz88Ply5dQlBQEH7//Xf8/vvvGD58OL755hs4Osr+bJpr166htLQUw4YNa9U8L168wMGDBxESEoKcnBz4+fnh5s2bck3mpFVcXFzr0taruz3Pnz+HpaUleDweDAwMwDAMVq5cCR6PBy6X2+zLl9WtYV5vJqtlYNhkI1ng5TlEQ/uYqH0yJBaLsWDBApw9exZcLheDBg3C+PHj0bdv3zrjvvzyS3h6ejYwEyGEtBwlRK+ovlwm72JiabFYLLi6usLV1RWPHz/Gr7/+iq1bt+Ltt9+GpaUlVq9ejQkTJrSozuj1jusd9Ti4E3seM+bMa3H91M2bNxESEoIDBw7A1dUVK1euxOjRo9u0DophGBQVFSEtLa1O4pOeno7Kyspauzuurq6YNWsWeDweunfvXrP21NRUjBkzBsOHD29VPAs8eLiYVgCBUNz04NfocbQw34PX9EAVd/XqVfB4vJo/RHx9fREeHl4nIdq0aRMmT56Ma9euKSJMQoiao4ToFZGRkXj33XcVHUa9zMzMsG7dOqxevRqHDx/Gt99+i/feew/t27fH559/jk8++QTt2rVrcp7ErGJsiU5HzL18AKh1OYfRsUKmQA95e+Mx350H+56dmpyvrKwMBw4cQEhICPLy8uDn54dbt26By+W2eK1NYRgGeXl59SY8GRkZYBgGVlZWNUnPyJEj8fHHH4PH48HU1FSqhJfH4+Hx48coLy+HgYFBi2OtbibbstYwNhrRtiMnJ6fW7iGXy8WVK1fqjDly5AjOnTtHCREhRC4oIfpXdXPQbdu2KTqURuno6GD69OmYPn06EhISsGrVKnz11Vf4+uuvMW3aNHz//ffo0aNHvc9tqj0JS1sXVWIGZ5LzcOFeQYPtSQDg+vXrCAkJwaFDh+Dh4YFvvvkGo0aNktlukEQiwePHj+tNetLT06Gvr19rp2fcuHE1/zY2Nm71Lh+Hw4GVlRVSUlIwcODAVs1V/T2URWsYdVRfGePr/3+LFi1CUFCQVD9fISEhCAkJAQDk5+fLJkhCiNqjhOhf8fHx6N27N0xNTRUditQcHBzwv//9D0VFRfjxxx+xdetW7Nu3D4MHD8ZPP/1Uq29acxrYvtpxHfjvF3pJSQlCQ0MREhKCoqIi+Pn54c6dOzAzM2tR/GKxGFlZWfUmPPfv34ehoWGtpMfHxwc8Hg+Wlpbo1KlTi16zOarvNGttQgS8/B7acTthw6kknL+bD309vVrNZPU4bDBAs5rJqgsul4usrKyaz7Ozs+v8TMXHx8PX1xcAUFBQgIiICHA4HEyYMKHOfP7+/vD39wcAudTaEULUEyVE/4qMjGzT2+1lydjYGGvXrsV3332HsLAwrFq1Cm+//Ta4XC5WrVqFN0dMwJqI1DrJ0JN9S1H5+C5Y7Jd/dWt16Iwe/r/XPC4QSrAmIhWckseIOrwTYWFhGD58ONauXYsRI0ZIVWskFAqRmZlZb9Lz8OFDmJiY1Ep6hgwZUpP0tG/fXrbfqGaS1YnV1ey4nTCoMhGCpzcwbM6ymmayHfW0YdO9A6Y4cNW+gLo+gwYNQlpaGh48eIAePXrgwIED2L9/f60xDx48qPn3zJkzMXbs2HqTIUIIaSlKiP4VGRmJL7/8UtFhtIqWlhamTZuGadOm4c6dO/j888/h7+8Pk0mZ0LVwBFh1ExjjUfPQwb7hu3YElUIs3XMe8/iWSElJQbdu3eqMqaysxIMHD+pNerKysmBmZlYr6Rk6dGhNEa2+vr5MvweyxOfzsWPHDpnOGRYWhkWLFuEdN8Ud66BsOBwONm/eDE9PT4jFYsyePRt8Ph/BwcEAgHnz5ik4QkKIJqBziPDyNvGuXbviyZMnCt+VkLWHTwox7JdYSFh1ay+e7FuKdv2GNpoQAS/PwokKGILivOx6k57c3Nw6BxNWf7zxxhvQ1VXNXY979+7B09Oz1u5Ea+Tl5aFPnz548uQJ9PT0ZDInaRydQ0SIZqFziFrp0qVLcHBwULtkCABO3S2GtrZ2g01Gi6P/RHH0n9A27oFObu9Dr7ddnTEVFRWwm+CPrkW3axKd/v37Y+LEiY0eTKjqLC0tkZeXh7KyMpn8bBw5cgTe3t6UDBFCiBKihAiqXT/UlMY6rhsNnQXtzj3B0tLGi5QLePrXt+g+61doG3WvNY7F0cEHAcvwy7Sm+3qpEy0tLVhbWyMlJQWDBknZk6wRhw8fxsKFC2UQGSGEEFmjbvd4eSBjaw/gU1aNdVzXNesDtq4BWBxttO8/HLo9bCHIqH+rsVSKzu3qSFaF1fn5+bh+/TpGj67bnoMQQojiaXxCVFBQgIyMDDg5OSk6FLnoqNeMTUAWC0D9JWWa2nFdVgnRkSNHMHr0aKUuIieEEE2m8QnRuXPn4ObmppY1MABg060jdDl1/5slFWUQ3L8ORlQFRiJG2Z3zqMxKgr65Q52xmtxxXVYJUVhYmFTNSAkhhCiGxtcQqfPlMgAYYdEePwiFwGt3mTESMYov7IWwKBtgsaHdmQuTSSug3bluyw2hSIzx/VTnwEpZkkVCVFBQgCtXruDIkSMyiooQQoisafwOkboWVItEImzduhVvOdrBVJSP1xtZaBkYovvMn9Hr08Potfggun+wHvrmdYumWQAMijMwyM4WGzduRHl5eZvEryzMzc2Rn5+P0tLSFs8RHh6OUaNGSdVrjhBCiGJodEL04MEDvHjxAnw+X9GhyNT58+fh4OCAsLAwREZG4vfAydDTblmPMT1tLexb/iHCw8MRExMDCwsLBAUFoaSkRMZRKyctLS3Y2toiOTm5xXMcPnyYLpcRQoiS0+iEqPpyWWsbgSqLhw8fYsqUKZg9ezZWrVqFqKgo9O/fv6bjur528/67X+24PnDgQPz999+IjIxEYmIiLCws8PXXX6OoqEhOq1EerblsVlRUhMuXL2PMmDEyjooQQogsaXRCpC6Xy168eIGVK1fC0dERAwYMQHJyMiZPnlwr0Zvh/AaWe9tCX1sLTeV/LBagr62F5d62dTqu9+vXD/v378fly5fx6NEjWFlZYenSpcjLy5PDypRDaxKiY8eOYcSIEWp56CchhKgTjU2IJBIJzp07p9IF1QzDIDQ0FDY2NsjIyMDNmzexYsWKBm/tnuH8Bg76O8Ozb1foctjQe+3uMz0OG7ocNjz7dsVBf+c6ydCrrK2t8ccffyAhIQGlpaWwsbFBYGAgsrOzZblEpdCahOjw4cPw8fGRcUSEEEJkTWN7mSUmJsLHxwf37t1TdCgtkpCQgICAAAgEAmzcuBFvv/12s55fWFaJsIRsmXVcf/z4MdavX4+dO3fCx8cHX375JSwsLJo9jzJ68OAB3NzckJWV1aznFRcXo1evXsjJyUGHDpp5bIGiUS8zQjRLa97zGrtDpKqXy54+fYq5c+dizJgxmDlzJq5evdrsZAgAOrfXxUdulvh52gDs+HAQfp42AB+5WbYoGQIAMzMzrF+/Hvfu3YOJiQkGDRqEDz74ACkpKS2aT5n07t0bz549w/Pnz5v1vGPHjmHYsGGUDBFCiArQ2IRI1c4fqqqqwoYNG8Dn89GxY0ekpqbCz88PWlotu3tMXrp06YLvvvsOGRkZsLa2hru7O6ZOnYrExERFh9ZibDa7RXea0WGMhBCiOjQyIaqqqsKlS5cwdOhQRYcilVOnTsHOzg5nz57FxYsXsX79ehgaGio6rEZ16tQJK1aswP379+Hk5AQvLy+MHz8eV65cUXRoLdLcOqLnz58jOjoa48aNk2NUhBBCZEUjE6K4uDhYW1vD2NhY0aE0Ki0tDWPHjkVAQADWr1+PiIgI2NjYKDqsZmnfvj2WLFmCjIwMeHp6wsfHByNHjkRMTAxUqXytuQnR8ePH4e7urvSJKyGEkJc0MiGKiopS6vqhkpISfPHFFxgyZAjc3d2RlJSEMWPGqPR5Sfr6+liwYAHS09Ph6+uLOXPmwM3NDadPn1aJxKi5CREdxkgIIapFIxMiZS2olkgk2LlzJ2xsbFBQUICkpCR8/vnn0NHRUXRoMqOjo4M5c+YgNTUVH3/8MT799FM4OTkhPDwcEolE0eE1qDkJUWlpKc6dO4fx48fLOSpCCCGyonEJUUlJCRITE/HWW28pOpRa4uLi4OzsjJCQEISHh+OPP/5At27dFB2W3HA4HLz33nu4ffs2li1bhm+++Qb29vY4cOAAxGKxosOro1evXigpKUFxcXGTY48fP463334bRkZG8g+MEEKITGhcQnThwgUMHjy4wcML29rjx4/x/vvvY8qUKQgICEBsbCwGDRqk6LDaDJvNxqRJk3D9+nUEBQXh119/ha2tLXbt2gWhUKjo8GqwWCz07dtXql2isLAwOoyREEJUjMYlRMpyuayiogJr166FnZ0devbsidTUVMyYMQNstsb9lwB4mXB4e3sjNjYWv//+O/bs2QMrKyv89ttvqKioUHR4AF5eNktKSmp0TFlZGSIjI/HOO++0UVSEEEJkQeN++0ZGRir0/CGGYXD06FHw+XxcuXIFV65cwffff0+9rv7FYrEwdOhQREVFYf/+/Th+/DgsLS3x888/48WLFwqNTZo6ooiICAwZMkTp72AkhBBSm0YlRE+ePEFOTg4GDhyokNdPTk7GqFGjsHz5cgQHB+Po0aOwtLRUSCyqwMXFBSdOnMD//vc/xMbGwsLCAt9//32zT4yWFWkSIjqMkRBCVJNGJURRUVEYOnRom5/u/OzZMwQGBsLDwwPjxo3DzZs3MXLkyDaNQZU5ODggLCwM586dQ3JyMiwtLfHVV1+hsLCwTeNoKiEqLy/H6dOnMWHChLYLSk2cOnUKffr0AY/Hw7p16+o8vm/fPtjZ2cHOzg4uLi4qffI5IUQ5aVRC1NaXy8RiMYKDg2FjY4OqqiokJycjICAA2trabRaDOuHz+di7dy/i4uKQm5sLKysrfPHFF3jy5EmbvD6Xy4VAIGgwETt58iScnJzQpUuXNolHXYjFYixYsAAnT55EcnIyQkND67RJMTc3R0xMDG7duoWVK1fC399fQdESQtSVxiREDMO06YGMMTExcHBwQGhoKE6fPo3ffvuNflHKCI/Hw7Zt23Dz5k0IBALY2trik08+aXY3+uZq6k4zOoyxZa5evQoejwcLCwvo6OjA19cX4eHhtca4uLjUHGPg7OyM7OxsRYRKCFFjGpMQpaWlQSKRwNraWq6vk5mZialTp+KDDz7AihUrEB0djQEDBsj1NTVVr169sGnTJqSkpEBfXx/29vaYO3cuMjIy5PaaDV02EwgEOHXqFCZOnCi311ZXOTk56NmzZ83nXC4XOTk5DY7fsWMHvLy82iI0QogG0ZiEqPp2e3m1vygvL8eqVavg4OAAPp+PlJQU+Pj4qHS7DVXRrVs3/PDDD0hLS0P37t0xePBgzJgxo9nd6aXRUEJ06tQpODg4wNTUVOavqe7qa93S0Pvm/Pnz2LFjB4KCghqcLyQkBI6OjnB0dER+fr7M4iSEqDeNSYjkdbmMYRgcPHgQtra2uHv3Lm7cuIFVq1bBwMBA5q9FGte5c2esXr0aGRkZ6Nu3Lzw8PDBlyhTcuHFDZq/RUEJEhzG2HJfLrXW5Mzs7G2ZmZnXG3bp1C35+fggPD0fnzp0bnM/f3x/x8fGIj4+HiYmJXGImhKghRgOIRCLGyMiIycnJkem8CQkJjKurKzNgwAAmJiZGpnOT1isrK2M2bNjAmJmZMWPGjGEuX77c6jmzs7MZExOTWl8TCASMoaEhk5ub2+r5NZFQKGTMzc2Z+/fvM5WVlYydnR2TlJRUa0xmZiZjaWnJxMbGNmvugQMHyjJUQoiSa817XiN2iG7cuIHu3bvX+1dnS+Tn5+Ojjz6Cl5cXZsyYgfj4eLi5uclkbiI77dq1w+LFi5GRkYExY8bA19cXw4cPx/nz5+u9TCMNMzMzVFVV1boUc+bMGdjb26t17zl54nA42Lx5Mzw9PWFra4upU6eCz+cjODgYwcHBAIDVq1ejsLAQ8+fPx4ABA+Do6KjgqAkh6obFtPQ3gwpZt24dcnNzsXHjxlbNIxQKsWXLFqxZswbTp0/HqlWrqIGnChEKhdi7dy/Wrl0LExMTrFixAqNHj25WnVdBWSWGzfk/8N8aCX3Dzuiox8HN6Ah42xjhi8D5coyetISjoyPi4+MVHQYhpI205j2vEQnRiBEjEBAQgPHjx7d4jjNnzmDRokXgcrn45Zdf0LdvXxlGSNqSWCzG4cOHsWbNGujo6GD58uWYMGFCo33kErOKsSU6HTH38iEUVkHC4tQ8xggroaunh6E2ppjvzoN9z05tsAoiDUqICNEslBA1QiAQwNTUFNnZ2TA0NGz289PT0/HZZ5/hzp072LBhA8aNG0d3jqkJiUSCY8eO4bvvvoNAIMDy5csxdepUcDicWuP2xj3EmohUVIjEaOzdwmIBehwtLPe2wQznN+QbPJEKJUSEaJbWvOfVvobo8uXL6NevX7OTodLSUixduhTOzs5wcXHBnTt3MH78eEqG1AibzcaECRNw7do1rF+/Hlu3boWtrS3++OMPVFVVAahOhlIgEP6XDIkFpXj613d4tH4ysrfOwos70QAAhgEEQjHWRKRgb9xDxSyKEEJIi6h9QlR9/pC0JBIJdu/eDRsbG+Tm5uLWrVv48ssvoaurK8coiSKxWCyMHj0aFy9exPbt2xEaGgorKyus+HkbvotIgUAoqTW+6MxvYGlpg/vJXnQZtwSFZ7aiKj+z5nGBUII1Eam4lV3cxishhBDSUpymh6iWgrJKhF3PRuqTEpRUiBCb2wHvuA9CYVklOrdvPKm5cuUKAgMDwTAM/vrrLzg7O7dR1EQZsFgsuLu7w93dHXFxcZi75xoE7UVgvVJbJKmqQPndyzDz2wK2jj70evJhwBuMF3fOQ8djZs24CpEYW6PTETyD7oYihBBVoDYJ0atFrwBQKfr3r/ru9jh2X4TwoHPw6GNSb9Frbm4uli1bhjNnzmDt2rV4//33Gy2wJeqP1+9NVBk/A0tUe3dIVJQDFpsNbeMeNV/TNjVH5aPbtcYxDHD+br5UiTghhBDFU4vf+nvjHsJ3WxzOpuShUiT5Lxn6V8W/XzuTnAffbXE19R2VlZUICgpC//790bVrV9y9excffvghJUMEYdfrbx4qEQrA0q19Cjlb1wCSKkGdsSwAYQnUhJQQQlSByu8Q/Vf0Kmly7KtFr7du38aRHz6Fra0t/vnnH1hZWbVBtERVpD4pqZNYAwBbWx9MZe3kh6ksB1tHv87YCpEEqbmlcouREEKI7Kj0VkhiVjHWRKTWmwwJi3KQ+eNEFPzvpzqPCYQSHLonwpLvN+HYsWOUDJE6SipE9X6dY9wDjEQMYdF/3dirnj6AtknvBuYRyiU+QgghsqXSCdGW6HRUiMT1PlZ0Jhi63RtOdFjaOrhR2UVeoREV11Gv/s1Tto4eDPoMQfHFfZBUVaAiOxnl6VfQjj+0gXm05RkmIYQQGVHZhKigrBIx9/LrPSjvRXIM2HrtoNfbvsHnv1r0SsjrbLp1hC6n/reH8aj5YERVyN40HQXHfkTnUfOhU88OkR6HDZvuHeQdKiGEEBlQ2YSowaLXynIUX9wHo2FzmpyDil5JQ6YM5Db4mJZ+B5hOXoFen/0F7vydaMf3qHccA2CKQ8PzEEIIUR4qmxA1VPRafGEP2tuPAqejSZNzUNEraUiX9rpwtzZBSw8mZ7GAoX1M6JZ7QghRESqbENVX9FqVdx8VmYnoOOidZsxDRa+kfgs8eNDjaLXouXocLcz34Mk4IkIIIfKisrfd11f0WvHoNkTP85C9dRYAgKmqABgJcgsC0X3WxgbmoaJXUj/7np2w3NtG6mMdqulrs7Hc2wZ23E7yC44QQohMqWxC9LLo9Umty2btB3iina1bzeclV/+G6HkejD0X1DsHFb2SplR3radu94QQot5U9pJZfUWvbG09aLU3qvlgaeuBxdGBlkH9ne6p6JVIY4bzGzjo7wzPvl2hy2FD77W7z/Q4bOhy2PDs2xUH/Z0pGSKEEBWksjtE1UWvZ1PyGvyrvZPr9AafT0WvpDnsuJ0QPMMRhWWVCEvIRmpuKUoqhOiopw2b7h0wxYFLP0uEEKLCVDYhAl4WvV5MK4BAWP/hjI2holfSEp3b6+IjN0tFh0EIIUTGVPaSGfBf0au+dvOWQUWvhBBCCHmVSu8QAVT0SgghhJDWU/mECHiZFNlxO2FrdDrO380HCy8PXaymx2GDwcuaofkePNoZIoQQQkgtapEQAVT0SgghhJCWU5uEqBoVvRKiek6dOoXAwECIxWL4+flh6dKltR5nGAaBgYGIiIiAgYEBdu3aBQcHBwVFSwhRRypdVE0IUX1isRgLFizAyZMnkZycjNDQUCQnJ9cac/LkSaSlpSEtLQ0hISH4+OOPFRQtIURdUUJECFGoq1evgsfjwcLCAjo6OvD19UV4eHitMeHh4fjggw/AYrHg7OyM4uJi5ObmKihiQog6ooSIEKJQOTk56NmzZ83nXC4XOTk5zR5DCCGtoXY1RIQQ1cLUc1YGi8Vq9phqISEhCAkJAQAkJSXB0dFRBlEqVn5+PkxMTBQdhkzQWpSPuqwDAFJTU1v8XEqICCEKxeVykZWVVfN5dnY2zMzMmj2mmr+/P/z9/QEAjo6OiI+Pl0PUbUtd1gHQWpSRuqwDQKv+AKJLZoQQhRo0aBDS0tLw4MEDVFVV4cCBAxg/fnytMePHj8fu3bvBMAzi4uJgaGiI7t27KyhiQog6oh0iQohCcTgcbN68GZ6enhCLxZg9ezb4fD6Cg4MBAPPmzYO3tzciIiLA4/FgYGCAnTt3KjhqQoi6oYSIEKJw3t7e8Pb2rvW1efPm1fybxWJhy5YtzZ63+tKZqlOXdQC0FmWkLusAWrcWFlNftSIhhBBCiAahGiJCCCGEaDxKiAghKu3UqVPo06cPeDwe1q1bV+dxhmEQEBAAHo8HOzs7JCQkKCBK6TS1ln379sHOzg52dnZwcXFBYmKiAqKUTlNrqXbt2jVoaWkhLCysDaOTnjTriI6OxoABA8Dn8+Hu7t7GEUqvqbU8f/4c48aNg729Pfh8vtLW6s2ePRumpqbo169fvY+3+D3PEEKIihKJRIyFhQWTkZHBVFZWMnZ2dsydO3dqjTlx4gQzevRoRiKRMP/88w/j5OSkoGgbJ81aYmNjmaKiIoZhGCYiIkKl11I9bujQoYyXlxdz+PBhBUTaOGnW8ezZM8bW1pbJzMxkGIZh8vLyFBFqk6RZy5o1a5gvvviCYRiGefr0KWNkZMRUVlYqItxGxcTEMNevX2f4fH69j7f0PU87RIQQlaVObT+kWYuLiwuMjIwAAM7OzsjOzlZEqE2SZi0AsGnTJkyePBmmpqYKiLJp0qxj//79mDRpEnr16gUAKr0WFouF0tJSMAyDsrIyGBsbg8NRvnuv3NzcYGxs3ODjLX3PU0JECFFZ6tT2o7lx7tixA15eXm0RWrNJ+/9y5MiRWncTKhtp1nHv3j08e/YMHh4eGDhwIHbv3t3WYUpFmrUsXLgQKSkpMDMzQ//+/bFx40aw2aqXJrT0Pa98qR8hhEiJkXHbD0VqTpznz5/Hjh07cOnSJXmH1SLSrGXRokUICgqClpZWW4XVbNKsQyQS4fr164iKioJAIMCQIUPg7OwMa2vrtgpTKtKs5fTp0xgwYADOnTuHjIwMjBw5Eq6urujYsWNbhSkTLX3PU0JECFFZsm77oUjSxnnr1i34+fnh5MmT6Ny5c1uGKDVp1hIfHw9fX18AQEFBASIiIsDhcDBhwoS2DLVR0v58denSBe3atUO7du3g5uaGxMREpUuIpFnLzp07sXTpUrBYLPB4PJibmyM1NRVOTk5tHW6rtPg9L4sCJ0IIUQShUMiYm5sz9+/frykUTUpKqjXm+PHjtQosBw0apKBoGyfNWjIzMxlLS0smNjZWQVFKR5q1vOrDDz9UyqJqadaRnJzMDBs2jBEKhcyLFy8YPp/P3L59W0ERN0yatcybN49ZtWoVwzAM8+TJE8bMzIzJz89XQLRNe/DgQYNF1S19z9MOESFEZalT2w9p1rJ69WoUFhZi/vz5Nc9Rxqac0qxFFUizDltbW4wePRp2dnZgs9nw8/Nr8HZwRZJmLStXrsTMmTPRv39/MAyDoKAgdOnSRcGR1/Xuu+8iOjoaBQUF4HK5+OabbyAUCgG07j1PJ1UTQgghROOpXvk4IYQQQoiMUUJECCGEEI1HCREhhBBCNB4lRIQQQgjReJQQEUIIIUTjUUJECCGEEI1HCREhhBBCNB4lRIQQQgjReP8P98cghsPcyjUAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "This algorithm is designed for undirected graphs. If you wish to run anyway as an undirected graph, set directed=True\n", + "True\n", + "True\n" + ] + }, + { + "ename": "NetworkXError", + "evalue": "Frozen graph can't be modified", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/var/folders/2g/f411k3y54zj8kddxt7xbcslr0000gp/T/ipykernel_34381/2282894088.py\u001b[0m in \u001b[0;36mfull_test\u001b[0;34m(test)\u001b[0m\n\u001b[1;32m 39\u001b[0m \u001b[0mobj\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mDkRewire\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 40\u001b[0;31m \u001b[0mnew_G\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mobj\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstep_rewire\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mG\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0md\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 41\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mValueError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/colab_2022/netrw/netrw/rewire/dk_rewiring.py\u001b[0m in \u001b[0;36mstep_rewire\u001b[0;34m(self, G, d, copy_graph, timesteps, tries, directed, verbose)\u001b[0m\n\u001b[1;32m 63\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 64\u001b[0;31m raise ValueError(\n\u001b[0m\u001b[1;32m 65\u001b[0m \u001b[0;34m\"This algorithm is designed for undirected graphs. If you wish to run anyway as an undirected graph, set directed=True\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mValueError\u001b[0m: This algorithm is designed for undirected graphs. If you wish to run anyway as an undirected graph, set directed=True", + "\nDuring handling of the above exception, another exception occurred:\n", + "\u001b[0;31mNetworkXError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/var/folders/2g/f411k3y54zj8kddxt7xbcslr0000gp/T/ipykernel_34381/2205216258.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mfull_test\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m/var/folders/2g/f411k3y54zj8kddxt7xbcslr0000gp/T/ipykernel_34381/2282894088.py\u001b[0m in \u001b[0;36mfull_test\u001b[0;34m(test)\u001b[0m\n\u001b[1;32m 47\u001b[0m \u001b[0;31m# Force rewiring\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 48\u001b[0m \u001b[0mobj\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mDkRewire\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 49\u001b[0;31m \u001b[0mzero_G\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mobj\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstep_rewire\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mG\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0md\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mdirected\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 50\u001b[0m \u001b[0mone_G\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mobj\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstep_rewire\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mG\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0md\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mdirected\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 51\u001b[0m \u001b[0mtwo_G\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mobj\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstep_rewire\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mG\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0md\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mdirected\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/colab_2022/netrw/netrw/rewire/dk_rewiring.py\u001b[0m in \u001b[0;36mstep_rewire\u001b[0;34m(self, G, d, copy_graph, timesteps, tries, directed, verbose)\u001b[0m\n\u001b[1;32m 85\u001b[0m \u001b[0;31m# Calculate 0k-swap\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 86\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0md\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 87\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mzero_k_swap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mG\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtimesteps\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mverbose\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 88\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 89\u001b[0m \u001b[0;31m# Calculate 1k-swap\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/colab_2022/netrw/netrw/rewire/dk_rewiring.py\u001b[0m in \u001b[0;36mzero_k_swap\u001b[0;34m(self, G, timesteps, verbose)\u001b[0m\n\u001b[1;32m 152\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 153\u001b[0m \u001b[0;31m# Update network\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 154\u001b[0;31m \u001b[0mG\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mremove_edge\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0medge\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0medge\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 155\u001b[0m \u001b[0mG\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd_edge\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0medge\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mnot_end_of_edge\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnode\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 156\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/anaconda3/lib/python3.9/site-packages/networkx/classes/function.py\u001b[0m in \u001b[0;36mfrozen\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 155\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mfrozen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 156\u001b[0m \u001b[0;34m\"\"\"Dummy method for raising errors when trying to modify frozen graphs\"\"\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 157\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mnx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mNetworkXError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Frozen graph can't be modified\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 158\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 159\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mNetworkXError\u001b[0m: Frozen graph can't be modified" + ] + } + ], + "source": [ + "full_test()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "eb86e047", + "metadata": {}, + "outputs": [], + "source": [ + "check_0_swap(nx.gnp_random_graph(100,.3))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4a1f0592", + "metadata": {}, + "outputs": [], + "source": [ + "check_1_swap(nx.barabasi_albert_graph(1000,3))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "130d1f78", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python [conda env:root] *", + "language": "python", + "name": "conda-root-py" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From b4d6148f222e571fab959092373cb61f6e9503ce Mon Sep 17 00:00:00 2001 From: Cory Glover Date: Wed, 20 Jul 2022 15:45:16 -0400 Subject: [PATCH 23/23] Dk-Series Rewiring finished --- netrw/rewire/distribution_analysis.py | 127 -------- netrw/rewire/dk_rewiring.py | 402 +++++++++++++++++++++++--- netrw/rewire/test.ipynb | 293 ------------------- 3 files changed, 365 insertions(+), 457 deletions(-) delete mode 100644 netrw/rewire/distribution_analysis.py delete mode 100644 netrw/rewire/test.ipynb diff --git a/netrw/rewire/distribution_analysis.py b/netrw/rewire/distribution_analysis.py deleted file mode 100644 index 8be1357..0000000 --- a/netrw/rewire/distribution_analysis.py +++ /dev/null @@ -1,127 +0,0 @@ -import numpy as np -import networkx as nx - -def logbin_dist(z,bins=15): - """ - Logbin a collection of datapoints to estimate a function - - Parameters: - x - xvalues of data - y - f(x) - bins - number of bins - - Returns: - log_bin_data - """ - # Get first and last psi and b - psi = np.zeros(bins+1) - b = np.zeros(bins+1) - b[0] = np.min(z) - b[-1] = np.max(z) - psi[0] = np.log(b[0]) - psi[-1] = np.log(b[-1]) - # Get size of psis and interval sizes - D = psi[-1] - psi[0] - L = D/bins - - # Get updated psi and b - for i in range(1,bins): - # Find psi - psi[i] = psi[i-1] + L - b[i] = np.exp(psi[i]) - - # Create binned data arrays - x_bin = np.sqrt(b[:-1]*b[1:]) - z_bin = np.zeros(bins) - - # Sort data - z_sort = np.argsort(z) - z = z[z_sort] - - n = len(z) - - # Get average of bins - for i in range(bins-1): - - # Get data in bin - loc_in_bin = np.where(z[np.where(z < b[i+1])[0]] >= b[i])[0] - S = len(loc_in_bin) - L = b[i+1]-b[i] - z_bin[i] = S/(L*n) - - loc_in_bin = np.where(z>=b[-2])[0] - S = len(loc_in_bin) - L = b[-1] - b[-2] - z_bin[-1] = S/(L*n) - - return x_bin, z_bin - -def graph_distributions(G,bins=15,degree_dist=True,avg_nn_dist=True,dd_clustering=True): - """ - Build the degree distribution, average nearest neighbor degree - and degree-dependent clustering of a graph. - - Parameters: - G (networkx) - network - bins (int) - number of bins - degree_dist (bool) - create degree distribution - avg_nn_dist (bool) - create average nearest-neighbor degree distribution - dd_clustering (bool) - create degree-dependent clustering - - Returns: - deg_dist_bins (ndarray) - bins for degree dist - deg_dist_vals (ndarray) - y-values for degree dist - avg_nn_bins (ndarray) - bins for avg_nn - avg_nn_vals (ndarray) - y-values for avg_nn - dd_cluster_bins (ndarray) - bins for dd_clustering - dd_cluster_vals (ndarray) - y-values for dd_clustering - """ - # Get degree sequence - degree_sequence = np.array([d for n, d in G.degree()]) - nodes_by_deg = {d: np.where(degree_sequence==d)[0] for d in np.sort(np.unique(degree_sequence))} - # Get minimum and maximum degree - min_deg = np.min(degree_sequence) - max_deg = np.max(degree_sequence) - to_ret = [] - - # Create degree distribution - if degree_dist: - deg_dist_bins, deg_dist_vals = logbin_dist(degree_sequence,bins = bins) - to_ret.append(degree_sequence) - to_ret.append(deg_dist_bins) - to_ret.append(deg_dist_vals) - - # Create average nearest neighbor degree distribution - if avg_nn_dist: - # Create distribution - avg_nn = np.zeros_like(np.unique(degree_sequence)) - neighbor_degrees = np.array(list(nx.average_neighbor_degree(G).values())) - for i, d in enumerate(np.sort(np.unique(degree_sequence))): - node_idx = nodes_by_deg[d] - avg_nn[i] = np.mean(neighbor_degrees[node_idx]) - - # Get log bin - avg_nn_bins, avg_nn_vals = logbin_fxn(np.sort(np.unique(degree_sequence)),avg_nn,bins = bins) - to_ret.append(avg_nn) - to_ret.append(avg_nn_bins) - to_ret.append(avg_nn_vals) - - # Create clustering by degree - if dd_clustering: - # Create distribution - dd_cluster = [] - cluster_degrees = np.array(list(nx.cluster.clustering(g).values())) - for i,d in enumerate(np.sort(np.unique(degree_sequence))): - node_idx = nodes_by_deg[d] - if len(node_idx) > 1: - dd_cluster.append(float(np.mean(cluster_degrees[node_idx]))) - else: - dd_cluster.append(float(cluster_degrees[node_idx])) - dd_cluster = np.array(dd_cluster) - # Get log binning - dd_cluster_bins, dd_cluster_vals = logbin_fxn(np.sort(np.unique(degree_sequence)),dd_cluster,bins=bins) - to_ret.append(dd_cluster) - to_ret.append(dd_cluster_bins) - to_ret.append(dd_cluster_vals) - - return tuple(to_ret) \ No newline at end of file diff --git a/netrw/rewire/dk_rewiring.py b/netrw/rewire/dk_rewiring.py index 2c2ad78..4ef4760 100644 --- a/netrw/rewire/dk_rewiring.py +++ b/netrw/rewire/dk_rewiring.py @@ -3,6 +3,7 @@ import warnings import copy import random +import numpy as np class DkRewire(BaseRewirer): @@ -16,10 +17,18 @@ class DkRewire(BaseRewirer): Orsini, C. et al. Quantifying randomness in real networks. Nat. Commun. 6:8627 doi: 10.1038/ncomms9627 (2015). """ + def full_rewire(self,G,d,clustering=True,degrees=None,copy_graph=True,timesteps=-1,tries=1000,directed=False,verbose=False): + """ + Computes a full rewiring of the network (a full rewiring is considered m edge swaps). + """ + return self.step_rewire(G,d,clustering,degrees,copy_graph,timesteps,tries,directed,verbose) + def step_rewire( self, G, d, + clustering=True, + degrees=None, copy_graph=False, timesteps=1, tries=1000, @@ -37,8 +46,10 @@ def step_rewire( d = 0 - average degree d = 1 - degree distribution d = 2 - joint degree distribution - d = 3 - triangle and wedge degree distributions - d = 4 - star, path, triangle with path, square, square with diagonal, and K4 distributions + d = 2.1 - joint degree distribution and drives average clustering up (or down) + d = 2.5 - joint degree distribution and drives degree-dependent clustering up (or down) + clustering (bool) - drives clustering up + degrees (list) - which degrees to have degree clustering be driven up (or down) on copy_graph (bool) - update a copy of the network. default True. timesteps (int) - number of edge swaps to perform. default 1. tries (int) - maximum number of tries to perform an edge swap. default 100. @@ -57,9 +68,7 @@ def step_rewire( "This algorithm is designed for undirected graphs. The graph input is directed and will be formatted to an undirected graph.", SyntaxWarning, ) - print(nx.is_frozen(G)) - G = nx.to_undirected(G) - print(nx.is_frozen(G)) + G = G.to_undirected() else: raise ValueError( "This algorithm is designed for undirected graphs. If you wish to run anyway as an undirected graph, set directed=True" @@ -72,6 +81,10 @@ def step_rewire( m = len(G.edges()) n = len(G.nodes()) + # Create timestep if -1 + if timesteps == -1: + timesteps = m + # Check for empty graph if len(G.edges()) == 0: warnings.warn("No edge swaps performed on empty graph.") @@ -96,18 +109,18 @@ def step_rewire( # Calculate 2.1k-swap elif d == 2.1: - return self.two_one_k_swap(G, timesteps, tries, verbose) + return self.two_one_k_swap(G, clustering, timesteps, tries, verbose) # Calculate 2.5k-swap elif d == 2.5: - return self.two_five_k_swap(G, timesteps, tries, verbose) + return self.two_five_k_swap(G, clustering, degrees, timesteps, tries, verbose) else: raise ValueError("d must be 0, 1, 2, 2.1, or 2.5") pass - def zero_k_swap(self, G, timesteps, verbose): + def zero_k_swap(self, G, timesteps, tries, verbose): """ Rewires one edge to a random node. This maintains the average degree of the network. At each timestep, a random edge is chosen and a random end of the edge is chosen. @@ -118,6 +131,7 @@ def zero_k_swap(self, G, timesteps, verbose): Parameters: G (networkx) timesteps (int) - number of edge swaps to perform + tries (int) - number of iterations to find valid edge swap verbose (bool) - indicator of storing edges deleted and added seed (int) - indicator of random seed generator state @@ -133,26 +147,41 @@ def zero_k_swap(self, G, timesteps, verbose): # Edge swap for each time step for t in range(timesteps): - # Choose a random edge - edge = random.choice(list(G.edges())) + valid = False + for _ in range(tries): + # Choose a random edge + edge = random.choice(list(G.edges())) - # Choose a random end of the edge - end_of_edge = random.choice([0, 1]) - not_end_of_edge = abs(end_of_edge - 1) + # Choose a random end of the edge + end_of_edge = random.choice([0, 1]) + not_end_of_edge = abs(end_of_edge - 1) - # Choose a random node - nodes_to_choose = list(G.nodes()) - nodes_to_choose.pop(edge[end_of_edge]) - node = random.choice(nodes_to_choose) + # Choose a random node + nodes_to_choose = list(G.nodes()) + node = random.choice(nodes_to_choose) - # If verbose, store edges - if verbose: - removed_edges[t] = [edge] - added_edges[t] = [(edge[not_end_of_edge], node)] + if edge[node_end_of_edge] == node: + continue + elif edge == (edge[not_end_of_edge], node): + continue + else: + valid = True + break - # Update network - G.remove_edge(edge[0], edge[1]) - G.add_edge(edge[not_end_of_edge], node) + # Check that tries was not maximized + if valid is False: + warnings.warn( + "No pair of edges was found with new edges that did not exist in tries allotted. Switch was not made at this timestep." + ) + else: + # If verbose, store edges + if verbose: + removed_edges[t] = [edge] + added_edges[t] = [(edge[not_end_of_edge], node)] + + # Update network + G.remove_edge(edge[0], edge[1]) + G.add_edge(edge[not_end_of_edge], node) if verbose: return G, removed_edges, added_edges @@ -201,9 +230,9 @@ def one_k_swap(self, G, timesteps, tries, verbose): # Check for valid edges if new_edge_1[0] == new_edge_1[1] or new_edge_2[0] == new_edge_2[0]: - break + continue - if new_edge_1 not in list(G.edges()) and new_edge_2 not in list( + elif new_edge_1 not in list(G.edges()) and new_edge_2 not in list( G.edges() ): valid = True @@ -214,8 +243,8 @@ def one_k_swap(self, G, timesteps, tries, verbose): new_edge_2 = (old_edge_1[1], old_edge_2[0]) # Check for valid edges if new_edge_1[0] == new_edge_1[1] or new_edge_2[0] == new_edge_2[0]: - break - if new_edge_1 not in list(G.edges()) and new_edge_2 not in list( + continue + elif new_edge_1 not in list(G.edges()) and new_edge_2 not in list( G.edges() ): valid = True @@ -227,14 +256,16 @@ def one_k_swap(self, G, timesteps, tries, verbose): "No pair of edges was found with new edges that did not exist in tries allotted. Switch was not made at this timestep." ) - # Store edges if verbose - if verbose: - removed_edges[t] = [old_edge_1, old_edge_2] - added_edges[t] = [new_edge_1, new_edge_2] + else: + + # Store edges if verbose + if verbose: + removed_edges[t] = [old_edge_1, old_edge_2] + added_edges[t] = [new_edge_1, new_edge_2] - # Update network - G.remove_edges_from([old_edge_1, old_edge_2]) - G.add_edges_from([new_edge_1, new_edge_2]) + # Update network + G.remove_edges_from([old_edge_1, old_edge_2]) + G.add_edges_from([new_edge_1, new_edge_2]) return G @@ -271,8 +302,305 @@ def two_k_swap(self, G, timesteps, tries, verbose): edges = G.edges() for _ in range(tries): # Choose an edge end at random - edge = random.choice(edges) - edge_end = edge[random.choice([0, 1])] + edge = random.choice(list(G.edges())) + edge_idx = random.choice([0,1]) + edge_end = edge[edge_idx] + + # Get degree of node + edge_deg = G.degree(edge_end) + + # Get nodes with the same degree + nodes = np.array(list(G.nodes())) + nodes_with_deg_idx = np.where(np.array(list(dict(G.degree()).values()))==edge_deg)[0] + nodes_with_deg = list(nodes[nodes_with_deg_idx]) + nodes_with_deg.remove(edge_end) + + if nodes_with_deg == []: + continue + # Choose random node with edge degree + edge_end_2 = random.choice(nodes_with_deg) + + # Choosee random edge of associated node + neighbor = random.choice(list(G.neighbors(edge_end_2))) + edge_2 = (edge_end_2,neighbor) + + # Check for no self loops + if neighbor == edge_end: + continue + + new_edge_1 = (edge_end,neighbor) + new_edge_2 = (edge_end_2,edge[abs(1-edge_idx)]) + + if new_edge_1 == new_edge_2: + continue + elif new_edge_1 in G.edges() or new_edge_2 in G.edges(): + continue + else: + valid = True + break + + # Inform of no match + if valid is False: + warnings.warn( + "No pair of edges was found with new edges that did not exist in tries allotted. Switch was not made at this timestep." + ) + + else: + # Store edges if verbose + if verbose: + removed_edges[t] = [edge,edge_2] + added_edges[t] = [new_edge_1,new_edge_2] + + # Update network + G.remove_edges_from([edge,edge_2]) + G.add_edges_from([new_edge_1,new_edge_2]) + + if verbose: + return G, removed_edges, added_edges + + else: + return G + + def two_one_k_swap(self, G, clustering, timesteps, tries, verbose): + """ + Rewires an edge while maintaining the joint degree distribution of the network and + increases the average clustering (or decreases). + A swap is done by selecting a random edge end. A second edge end is then chosen + uniformly at random such that the two edge ends have the same degree. Their opposite + edge ends are then swapped. This is based on the uniform sampling method given by + Stanton and Pinar. + + Stanton, Isabelle, and Ali Pinar. "Constructing and sampling graphs with a prescribed joint degree distribution." Journal of Experimental Algorithmics (JEA) 17 (2012): 3-1. + + Parameters: + G (networkx) + timesteps (int) - number of edge swaps to perform + tries (int) - maximum number of edge swap attempts at each timestep + verbose (bool) - indicator of storing edges deleted and added + + Returns: + G (networkx) + removed_edges (dict) - dictionary of edges removed + added_edges (dict) - dictionary of edges added + """ + # Initialize storing + if verbose: + removed_edges = {} + added_edges = {} + + # Perform rewiring for `timesteps` + for t in range(timesteps): + # Check that swap occurs + valid = False + edges = G.edges() + for _ in range(tries): + # Choose an edge end at random + edge = random.choice(list(G.edges())) + edge_idx = random.choice([0,1]) + edge_end = edge[edge_idx] + + # Get degree of node + edge_deg = G.degree(edge_end) + + # Get nodes with the same degree + nodes = np.array(list(G.nodes())) + nodes_with_deg_idx = np.where(np.array(list(dict(G.degree()).values()))==edge_deg)[0] + nodes_with_deg = list(nodes[nodes_with_deg_idx]) + nodes_with_deg.remove(edge_end) + + if nodes_with_deg == []: + continue + + # Choose random node with edge degree + edge_end_2 = random.choice(nodes_with_deg) + + # Choosee random edge of associated node + neighbor = random.choice(list(G.neighbors(edge_end_2))) + edge_2 = (edge_end_2,neighbor) + + # Check for no self loops + if neighbor == edge_end: + continue + + new_edge_1 = (edge_end,neighbor) + new_edge_2 = (edge_end_2,edge[abs(1-edge_idx)]) + + # Check for valid edges + if new_edge_1 == new_edge_2: + continue + elif new_edge_1 in G.edges() or new_edge_2 in G.edges(): + continue + + # Check for increase (or decrease) is average local clustering + cur_avg = nx.average_clustering(G) + new_graph = copy.deepcopy(G) + new_graph.remove_edges_from([edge,edge_2]) + new_graph.add_edges_from([new_edge_1,new_edge_2]) + new_avg = nx.average_clustering(new_graph) + + # Update accordingly + if clustering: + if new_avg > cur_avg: + valid = True + break + else: + if new_avg < cur_avg: + valid = True + break + + + # Inform of no match + if valid is False: + warnings.warn( + "No pair of edges was found with new edges that did not exist in tries allotted. Switch was not made at this timestep." + ) + + + else: + # Store edges if verbose + if verbose: + removed_edges[t] = [edge,edge_2] + added_edges[t] = [new_edge_1,new_edge_2] + + # Update network + G.remove_edges_from([edge,edge_2]) + G.add_edges_from([new_edge_1,new_edge_2]) + + if verbose: + return G, removed_edges, added_edges + + else: + return G + + def two_five_k_swap(self, G, clustering, degrees, timesteps, tries, verbose): + """ + Rewires an edge while maintaining the joint degree distribution of the network and + increases the average clustering (or decreases). + A swap is done by selecting a random edge end. A second edge end is then chosen + uniformly at random such that the two edge ends have the same degree. Their opposite + edge ends are then swapped. This is based on the uniform sampling method given by + Stanton and Pinar. + + Stanton, Isabelle, and Ali Pinar. "Constructing and sampling graphs with a prescribed joint degree distribution." Journal of Experimental Algorithmics (JEA) 17 (2012): 3-1. + + Parameters: + G (networkx) + timesteps (int) - number of edge swaps to perform + tries (int) - maximum number of edge swap attempts at each timestep + verbose (bool) - indicator of storing edges deleted and added + + Returns: + G (networkx) + removed_edges (dict) - dictionary of edges removed + added_edges (dict) - dictionary of edges added + """ + # Check for degrees + if degrees is None: + raise ValueError("No degrees given.") + + # Initialize storing + if verbose: + removed_edges = {} + added_edges = {} + + # Perform rewiring for `timesteps` + for t in range(timesteps): + # Check that swap occurs + valid = False + edges = G.edges() + for _ in range(tries): + # Choose an edge end at random + edge = random.choice(list(G.edges())) + edge_idx = random.choice([0,1]) + edge_end = edge[edge_idx] # Get degree of node edge_deg = G.degree(edge_end) + + # Get nodes with the same degree + nodes = np.array(list(G.nodes())) + nodes_with_deg_idx = np.where(np.array(list(dict(G.degree()).values()))==edge_deg)[0] + nodes_with_deg = list(nodes[nodes_with_deg_idx]) + nodes_with_deg.remove(edge_end) + + if nodes_with_deg == []: + continue + + # Choose random node with edge degree + edge_end_2 = random.choice(nodes_with_deg) + + # Choosee random edge of associated node + neighbor = random.choice(list(G.neighbors(edge_end_2))) + edge_2 = (edge_end_2,neighbor) + + # Check for no self loops + if neighbor == edge_end: + continue + + new_edge_1 = (edge_end,neighbor) + new_edge_2 = (edge_end_2,edge[abs(1-edge_idx)]) + + # Check for valid edges + if new_edge_1 == new_edge_2: + continue + + elif new_edge_1 in G.edges() or new_edge_2 in G.edges(): + continue + + # Check for increase (or decrease) is degree-dependent clustering for given degrees + new_graph = copy.deepcopy(G) + new_graph.remove_edges_from([edge,edge_2]) + new_graph.add_edges_from([new_edge_1,new_edge_2]) + # Get averages for each degree + check = True + for i, k in enumerate(degrees): + if check is False: + break + + # Get nodes of degree k + nodes_k_idx = np.where(np.array(list(dict(G.degree()).values()))==k)[0] + if len(nodes_k_idx) == 0: + raise ValueError(f"No nodes of degree {k}") + + nodes_k = nodes[nodes_k_idx] + cur_avg = nx.average_clustering(G,nodes_k) + new_avg = nx.average_clustering(new_graph,nodes_k) + + # Update accordingly + if clustering: + if new_avg <= cur_avg: + check = False + break + else: + if new_avg >= cur_avg: + check = False + break + + # Add edge if clustering has moved correctly + if check is True: + valid = True + break + + + + # Inform of no match + if valid is False: + warnings.warn( + "No pair of edges was found with new edges that did not exist in tries allotted. Switch was not made at this timestep." + ) + + else: + # Store edges if verbose + if verbose: + removed_edges[t] = [edge,edge_2] + added_edges[t] = [new_edge_1,new_edge_2] + + # Update network + G.remove_edges_from([edge,edge_2]) + G.add_edges_from([new_edge_1,new_edge_2]) + + if verbose: + return G, removed_edges, added_edges + + else: + return G diff --git a/netrw/rewire/test.ipynb b/netrw/rewire/test.ipynb deleted file mode 100644 index 7193222..0000000 --- a/netrw/rewire/test.ipynb +++ /dev/null @@ -1,293 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 3, - "id": "9c8c7465", - "metadata": {}, - "outputs": [], - "source": [ - "import networkx as nx\n", - "from dk_rewiring import DkRewire\n", - "import matplotlib.pyplot as plt\n", - "from distribution_analysis import graph_distributions\n", - "import numpy as np" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "0ee784a7", - "metadata": {}, - "outputs": [], - "source": [ - "def full_test(test=None):\n", - " if test is None:\n", - " test = ['undirected','directed','disconnected','empty','complete','verbose','copy','full']\n", - " for t in test:\n", - " if t == 'undirected':\n", - " # Generate GNP graph\n", - " G = nx.gnp_random_graph(10,.5)\n", - " \n", - " # Rewire for each distribution type\n", - " obj = DkRewire()\n", - " zero_G = obj.step_rewire(G,d=0)\n", - " one_G = obj.step_rewire(G,d=1)\n", - "# two_G = obj.step_rewire(G,d=2)\n", - "# two_one_G = obj.step_rewire(G,d=2.1)\n", - "# two_five_G = obj.step_rewire(G,d=2.5)\n", - " # Plot the rewirings\n", - " fig = plt.figure(figsize=(10,10))\n", - " plt.subplot(321)\n", - " nx.draw(G,with_labels=True)\n", - " plt.subplot(322)\n", - " nx.draw(zero_G,with_labels=True)\n", - " plt.subplot(323)\n", - " nx.draw(one_G,with_labels=True)\n", - " plt.subplot(324)\n", - "# nx.draw(two_G,with_labels=True)\n", - "# plt.subplot(325)\n", - "# nx.draw(two_one_G,with_labels=True)\n", - "# plt.subplot(326)\n", - "# nx.draw(two_five_G,with_labels=True)\n", - " plt.title('Undirected Test')\n", - " plt.show()\n", - " \n", - " elif t == 'directed':\n", - " try:\n", - " # Generate directed GNP\n", - " G = nx.fast_gnp_random_graph(100,.3,directed=True)\n", - " \n", - " # Force directed error\n", - " obj = DkRewire()\n", - " new_G = obj.step_rewire(G,d=0)\n", - " except ValueError as e:\n", - " # Catch directed error\n", - " print(e)\n", - " G = nx.gnp_random_graph(100,.3)\n", - " G = nx.to_directed(G)\n", - " \n", - " # Force rewiring\n", - " obj = DkRewire()\n", - " zero_G = obj.step_rewire(G,d=0,directed=True)\n", - " one_G = obj.step_rewire(G,d=1,directed=True)\n", - " two_G = obj.step_rewire(G,d=2,directed=True)\n", - " two_one_G = obj.step_rewire(G,d=2.1,directed=True)\n", - " two_five_G = obj.step_rewire(G,d=2.5,directed=True)\n", - " \n", - " elif t == 'disconnected':\n", - " try:\n", - " # Create disconnected graph\n", - " G = nx.Graph()\n", - " G.add_edges_from([[0,1],[1,2],[2,0],[3,4],[4,5],[5,3]])\n", - " # Force disconnected error\n", - " obj = DkRewire()\n", - " new_G = obj.step_rewire(G,d=0)\n", - " except ValueError as e:\n", - " print(e)\n", - " \n", - " elif t == 'empty':\n", - " try:\n", - " # Generate empty graph\n", - " G = nx.Graph()\n", - " obj = DkRewire()\n", - " new_G = obj.step_rewire(d=0)\n", - " except ValueError as e:\n", - " print(e)\n", - " \n", - " elif t == 'complete':\n", - " try:\n", - " # Generate complete graph\n", - " G = nx.complete_graph(100)\n", - " obj = DkRewire()\n", - " new_G = obj.step_rewire(d=0)\n", - " except ValueError as e:\n", - " print(e)\n", - " \n", - " elif t == 'verbose':\n", - " # Check verbose argument\n", - " G = nx.gnp_random_graph(100,.3)\n", - " obj = DkRewire()\n", - " new_G, removed_edges, added_edges = obj.step_rewire(d=0)\n", - " print(removed_edges, added_edges)\n", - " \n", - " elif t == 'copy':\n", - " # Check copy argument\n", - " G = nx.gnp_random_graph(100,.3)\n", - " obj = DkRewire()\n", - " new_G = obj.step_rewire(d=0,copy_graph=True)\n", - " \n", - " # Plot networks\n", - " plt.subplot(121)\n", - " nx.draw(G,with_labels=True)\n", - " plt.subplot(122)\n", - " nx.draw(new_G,with_labels=True)\n", - " plt.show()\n", - " \n", - " else:\n", - " # Check full rewire\n", - " # Generate GNP graph\n", - " G = nx.gnp_random_graph(100,.3)\n", - " \n", - " # Rewire for each distribution type\n", - " obj = DkRewire()\n", - "# zero_G = obj.full_rewire(G,d=0)\n", - "# one_G = obj.full_rewire(G,d=1)\n", - "# # two_G = obj.full_rewire(G,d=2)\n", - "# # two_one_G = obj.full_rewire(G,d=2.1)\n", - "# # two_five_G = obj.full_rewire(G,d=2.5)\n", - " \n", - "# # Plot the rewirings\n", - "# plt.subplot(321)\n", - "# nx.draw(G,with_labels=True)\n", - "# plt.subplot(322)\n", - "# nx.draw(zero_G,with_labels=True)\n", - "# plt.subplot(323)\n", - "# nx.draw(one_G,with_labels=True)\n", - "# plt.subplot(324)\n", - "# # nx.draw(two_G,with_labels=True)\n", - "# # plt.subplot(325)\n", - "# # nx.draw(two_one_G,with_labels=True)\n", - "# # plt.subplot(326)\n", - "# # nx.draw(two_five_G,with_labels=True)\n", - "# plt.title('Full Rewire')\n", - "# plt.show()\n", - " \n", - " \n", - " " - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "aaff5d30", - "metadata": {}, - "outputs": [], - "source": [ - "def check_0_swap(G):\n", - " obj = DkRewire()\n", - " new_G = obj.step_rewire(G,0)\n", - " m_g = len(G.edges())\n", - " n_g = len(G.nodes())\n", - " m_new_g = len(new_G.edges())\n", - " n_new_g = len(new_G.nodes())\n", - " print(f\"G: {2*m_g/n_g}\")\n", - " print(f\"New G: {2*m_new_g/n_new_g}\")" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "ea21b945", - "metadata": {}, - "outputs": [], - "source": [ - "def check_1_swap(G):\n", - " obj = DkRewire()\n", - " new_G = obj.step_rewire(G,1)\n", - " deg_dist = graph_distributions(G,avg_nn_dist=False,dd_clustering=False)\n", - " new_deg_dist = graph_distributions(G,avg_nn_dist=False,dd_clustering=False)\n", - " return np.allclose(deg_dist[0][0],new_deg_dist[0][0]), np.allclose(deg_dist[0][1],new_deg_dist[0][1]), np.allclose(deg_dist[1][0],new_deg_dist[1][0]), np.allclose(deg_dist[1][1],new_deg_dist[1][1])" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "9a9a8273", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "This algorithm is designed for undirected graphs. If you wish to run anyway as an undirected graph, set directed=True\n", - "True\n", - "True\n" - ] - }, - { - "ename": "NetworkXError", - "evalue": "Frozen graph can't be modified", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m/var/folders/2g/f411k3y54zj8kddxt7xbcslr0000gp/T/ipykernel_34381/2282894088.py\u001b[0m in \u001b[0;36mfull_test\u001b[0;34m(test)\u001b[0m\n\u001b[1;32m 39\u001b[0m \u001b[0mobj\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mDkRewire\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 40\u001b[0;31m \u001b[0mnew_G\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mobj\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstep_rewire\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mG\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0md\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 41\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mValueError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/Documents/colab_2022/netrw/netrw/rewire/dk_rewiring.py\u001b[0m in \u001b[0;36mstep_rewire\u001b[0;34m(self, G, d, copy_graph, timesteps, tries, directed, verbose)\u001b[0m\n\u001b[1;32m 63\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 64\u001b[0;31m raise ValueError(\n\u001b[0m\u001b[1;32m 65\u001b[0m \u001b[0;34m\"This algorithm is designed for undirected graphs. If you wish to run anyway as an undirected graph, set directed=True\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mValueError\u001b[0m: This algorithm is designed for undirected graphs. If you wish to run anyway as an undirected graph, set directed=True", - "\nDuring handling of the above exception, another exception occurred:\n", - "\u001b[0;31mNetworkXError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m/var/folders/2g/f411k3y54zj8kddxt7xbcslr0000gp/T/ipykernel_34381/2205216258.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mfull_test\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;32m/var/folders/2g/f411k3y54zj8kddxt7xbcslr0000gp/T/ipykernel_34381/2282894088.py\u001b[0m in \u001b[0;36mfull_test\u001b[0;34m(test)\u001b[0m\n\u001b[1;32m 47\u001b[0m \u001b[0;31m# Force rewiring\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 48\u001b[0m \u001b[0mobj\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mDkRewire\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 49\u001b[0;31m \u001b[0mzero_G\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mobj\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstep_rewire\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mG\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0md\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mdirected\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 50\u001b[0m \u001b[0mone_G\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mobj\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstep_rewire\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mG\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0md\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mdirected\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 51\u001b[0m \u001b[0mtwo_G\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mobj\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstep_rewire\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mG\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0md\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mdirected\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/Documents/colab_2022/netrw/netrw/rewire/dk_rewiring.py\u001b[0m in \u001b[0;36mstep_rewire\u001b[0;34m(self, G, d, copy_graph, timesteps, tries, directed, verbose)\u001b[0m\n\u001b[1;32m 85\u001b[0m \u001b[0;31m# Calculate 0k-swap\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 86\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0md\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 87\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mzero_k_swap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mG\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtimesteps\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mverbose\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 88\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 89\u001b[0m \u001b[0;31m# Calculate 1k-swap\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/Documents/colab_2022/netrw/netrw/rewire/dk_rewiring.py\u001b[0m in \u001b[0;36mzero_k_swap\u001b[0;34m(self, G, timesteps, verbose)\u001b[0m\n\u001b[1;32m 152\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 153\u001b[0m \u001b[0;31m# Update network\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 154\u001b[0;31m \u001b[0mG\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mremove_edge\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0medge\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0medge\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 155\u001b[0m \u001b[0mG\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd_edge\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0medge\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mnot_end_of_edge\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnode\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 156\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/anaconda3/lib/python3.9/site-packages/networkx/classes/function.py\u001b[0m in \u001b[0;36mfrozen\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 155\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mfrozen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 156\u001b[0m \u001b[0;34m\"\"\"Dummy method for raising errors when trying to modify frozen graphs\"\"\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 157\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mnx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mNetworkXError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Frozen graph can't be modified\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 158\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 159\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mNetworkXError\u001b[0m: Frozen graph can't be modified" - ] - } - ], - "source": [ - "full_test()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "eb86e047", - "metadata": {}, - "outputs": [], - "source": [ - "check_0_swap(nx.gnp_random_graph(100,.3))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "4a1f0592", - "metadata": {}, - "outputs": [], - "source": [ - "check_1_swap(nx.barabasi_albert_graph(1000,3))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "130d1f78", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python [conda env:root] *", - "language": "python", - "name": "conda-root-py" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.7" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -}