In [118]:

    

import pysal as ps
import time
import numpy as np

try:
    reload(network)
except:
    import network
    
try:
    reload(util)
except:
    import util


    

In [119]:

    

N = network.Network(ps.examples.get_path('geodanet/streets.shp'))


    

In [120]:

    

N.node_distance_matrix()


    

In [121]:

    

#Check that the nodes are all account for in the alldistances dict
assert(N.alldistances.keys() == N.node_list)


    

In [122]:

    

error = False
for k, v in N.alldistances.iteritems():
    predlists = v[1]
    distances = v[0]
    
    #Confirm that distance to self is 0
    assert(distances[k] == 0)
    
    #Confirm that the destination for all previous lists is directly adjacent to the current root    
    for p, plists in predlists.iteritems():
        try:
            assert(plists[-1] == k)
        except:
            print k, plists, p
            error = True
            break
            
    #Confirm that all nodes have a path to all other nodes
    try:
        assert(N.node_list == predlists.keys())
    except:
        print k, sorted(set(N.node_list).difference(set(predlists.keys())))
        error = True
        break
    
    if error == True:
        break


    

In [123]:

    

N.alldistances[215][0][229]


    

    
Out[123]:





4377.18710187358

In [124]:

    

N.alldistances[229][0][215]


    

    
Out[124]:





4377.18710187358

In [126]:

    

N.alldistances[215][1][229]


    

    
Out[126]:





[119, 116, 228, 20, 174, 173, 175, 60, 214, 76, 215]

In [127]:

    

N.alldistances[229][1][215]


    

    
Out[127]:





[76, 214, 60, 175, 173, 174, 20, 228, 116, 119, 229]

In [135]:

    

#The shortest path from A to B must equal B to A in an undirected graph
assert(N.alldistances[215][1][229][:-1] == N.alldistances[229][1][215][:-1][::-1])


    

In [ ]:

    




    

In [65]:

    

len(N.alldistances[0][1])


    

    
Out[65]:





169

In [67]:

    

len(N.alldistances)


    

    
Out[67]:





230

In [68]:

    

N.alldistances.keys()


    

    
Out[68]:





[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,
 25,
 26,
 27,
 28,
 29,
 30,
 31,
 32,
 33,
 34,
 35,
 36,
 37,
 38,
 39,
 40,
 41,
 42,
 43,
 44,
 45,
 46,
 47,
 48,
 49,
 50,
 51,
 52,
 53,
 54,
 55,
 56,
 57,
 58,
 59,
 60,
 61,
 62,
 63,
 64,
 65,
 66,
 67,
 68,
 69,
 70,
 71,
 72,
 73,
 74,
 75,
 76,
 77,
 78,
 79,
 80,
 81,
 82,
 83,
 84,
 85,
 86,
 87,
 88,
 89,
 90,
 91,
 92,
 93,
 94,
 95,
 96,
 97,
 98,
 99,
 100,
 101,
 102,
 103,
 104,
 105,
 106,
 107,
 108,
 109,
 110,
 111,
 112,
 113,
 114,
 115,
 116,
 117,
 118,
 119,
 120,
 121,
 122,
 123,
 124,
 125,
 126,
 127,
 128,
 129,
 130,
 131,
 132,
 133,
 134,
 135,
 136,
 137,
 138,
 139,
 140,
 141,
 142,
 143,
 144,
 145,
 146,
 147,
 148,
 149,
 150,
 151,
 152,
 153,
 154,
 155,
 156,
 157,
 158,
 159,
 160,
 161,
 162,
 163,
 164,
 165,
 166,
 167,
 168,
 169,
 170,
 171,
 172,
 173,
 174,
 175,
 176,
 177,
 178,
 179,
 180,
 181,
 182,
 183,
 184,
 185,
 186,
 187,
 188,
 189,
 190,
 191,
 192,
 193,
 194,
 195,
 196,
 197,
 198,
 199,
 200,
 201,
 202,
 203,
 204,
 205,
 206,
 207,
 208,
 209,
 210,
 211,
 212,
 213,
 214,
 215,
 216,
 217,
 218,
 219,
 220,
 221,
 222,
 223,
 224,
 225,
 226,
 227,
 228,
 229]

In [136]:

    

Is = N.alldistances.keys()
for i in Is[0:-1]:
    for j in Is[i+1:]:
        dij = N.alldistances[i][0][j]
        dji = N.alldistances[j][0][i]
        if (dij - dji) / dji > 0.001:
            print i,j, dij, dji
        try:
            pij = N.alldistances[i][1][j]
        except:
            print i,j,  'missing path'
        try:
            pji = N.alldistances[j][1][i]
        except:
            print j,i, 'missing path'


    

In [ ]: