In [2]:

    

%matplotlib inline

import numpy as np
import networkx as nx
import matplotlib.pyplot as plt


    

In [116]:

    

class FinancialNetwork:
    def __init__(self, g, th, N, E):
        self.g = g
        self.th = th
        self.N = N
        self.E = E
        self.a = np.zeros(N)
        self.e = np.zeros(N)
        self.invest = np.zeros(N)
        self.l = np.zeros(N)
        self.c = np.zeros(N)
        self.d = np.zeros(N)
        self.b = np.zeros(N)
        self.A = E/(1-th)
        self.I = th*self.A
        
    def set_assets(self):
        for i in range(self.N):
            self.e[i] = self.e_j_wave(i) + self.e_j_hat(i)
            self.invest[i] = self.iinvest(i)
            self.a[i] = self.e[i] + self.invest[i]
            self.c[i] = self.g*self.a[i]
            self.b[i] = self.get_bank(i)  
            self.d[i] = self.a[i] - self.c[i] - self.b[i]  
            self.l[i] = self.c[i] + self.d[i] + self.b[i]  
    
    def e_j_wave(self, i):
        i_j = self.iinvest(i)
        b_j = self.get_bank(i)
        if b_j - i_j > 0:
            e_j_wave = b_j - i_j
        else:
            e_j_wave = 0
        return e_j_wave
    
    def e_j_hat(self, i):
        e_j_sum = 0
        for j in range(self.N):
            e_j_sum += self.e_j_wave(j)
        e_j_sum = float(e_j_sum)
        k_sum = 0
        for j in range(25):
            k_sum += G.degree(j)
        k_sum = float(k_sum)
        k_j = float(G.degree(i))
        e_j_hat = (self.E - e_j_sum)*k_j/k_sum
        return e_j_hat
    
    def iinvest(self, i):
        G = self.network
        w = self.weight()
        iinvest = w*G.out_degree(i)
        return iinvest
    
    def get_bank(self, i):
        G = self.network
        w = self.weight()
        get_bank = w*G.in_degree(i)
        return get_bank
    
    def weight(self):
        G = self.network
        z = 0
        for i in range(25):
            z += G.degree(i)
        z = float(z)
        w = self.I/z
        return w      
    
    def set_rn(self, p):
        N = self.N
        G = nx.DiGraph()
        G.add_nodes_from([i for i in range(N)])
        for i in range(N):
            for j in range(N):
                if i != j:
                    y = np.random.choice([0, 1], p=[p, 1-p])
                    if y == 0:
                        G.add_edge(i,j,weight=1)
        self.network = G
        return self.network
    
    def set_sf(self, m_0, m_in, m_out):
        N = self.N
        G = nx.DiGraph()
        G.add_nodes_from([i for i in range(m_0)])
        for i in range(m_0):
            for j in range(m_0):
                if i != j:
                    G.add_edge(i,j,weight=1)
        k = 1
        while m_0+k == N-1:
            G.add_node(m_0 + k)
            for i in range(m_0 + k -1):
                k_in_sum = G.in_degree(i)
                k_out_sum = G.out_degree(i)
            
            print m_0 + k
            while G.in_degree(m_0 + k) != m_in:
                for i in range(m_0 + k -1):
                    p_in = G.in_degree(i)/k_in_sum
                    y_in = np.random.choice([0, 1], p=[p_in, 1-p_in])
                    if y_in == 0:
                        G.add_edge(i, m_0 + k, weight=1)
            
            while G.out_degree(m_0 + k) != m_out:
                    p_out = G.out_degree(i)/k_out_sum
                    y_out = np.random.choice([0, 1], p=[p_out, 1-p_out])
                    if y_in == 0:
                        G.add_edge(m_0 + i, k, weight=1)
            k += 1
        self.network = G
        return self.network
    
    def plot(self):
        pos = nx.spring_layout(G)
        nx.draw_circular(G)
        plt.show()


    

In [117]:

    

FN = FinancialNetwork(0.08, 0.3, 25, 100000)


    

In [118]:

    

FN.set_rn(0.3)


    

    
Out[118]:





<networkx.classes.digraph.DiGraph at 0x1089cfe10>

In [119]:

    

FN.set_sf(5, 2, 3)


    

    
Out[119]:





<networkx.classes.digraph.DiGraph at 0x1089cf050>

In [ ]:

    




    

In [85]:

    

FN.set_assets()


    

In [87]:

    

sum(FN.e)


    

    
Out[87]:





99999.999999999985

In [ ]:

    

n.main()


    

In [53]:

    

G = nx.DiGraph()
G.add_nodes_from([i for i in range(25)])
for i in range(25):
    for j in range(25):
        if i != j:
            y = np.random.choice([0, 1], p=[0.3, 0.7])
            if y == 0:
                G.add_edge(i,j,weight=1)


    

In [101]:

    

pos = nx.spring_layout(G)

nx.draw_circular(G)

plt.show()


    

In [45]:

    

y = np.random.choice([0, 1], 0.1)


    

In [46]:

    

G[3]


    

    
Out[46]:





{1: {'weight': 1},
 4: {'weight': 1},
 5: {'weight': 1},
 9: {'weight': 1},
 12: {'weight': 1},
 13: {'weight': 1},
 14: {'weight': 1},
 15: {'weight': 1},
 21: {'weight': 1},
 22: {'weight': 1},
 24: {'weight': 1}}

In [69]:

    

k = 0
for i in range(25):
    k += G.degree(i)
k


    

    
Out[69]:





334

In [62]:

    

G.nodes()


    

    
Out[62]:





[0,
 1,
 2,
 3,
 4,
 5,
 6,
 7,
 8,
 9,
 10,
 11,
 12,
 13,
 14,
 15,
 16,
 17,
 18,
 19,
 20,
 21,
 22,
 23,
 24]

In [68]:

    

G.number_of_edges()


    

    
Out[68]:





167

In [95]:

    

G = nx.DiGraph()
G.add_nodes_from([i for i in range(5)])


    

In [100]:

    

for i in range(100):
    G.add_edge(1,2,weight=1)
G.add_edge(1,2,weight=1)
G.add_edge(2,3,weight=1)


    

In [102]:

    

G.in_degree(2)


    

    
Out[102]:





1

In [ ]: