def addConnection(analyzer, origin, destination, distance):
"""
Adiciona un arco entre dos cables
"""
edge = gr.getEdge(analyzer['connections'], origin, destination)
if edge is None:
gr.addEdge(analyzer['connections'], origin, destination, distance)
return analyzer
def addConnection(graph, originVertex, destinationvertex, duration):
edge = gr.getEdge(graph, originVertex, destinationvertex)
if edge is None:
weight = [duration, 1]
gr.addEdge(graph, originVertex, destinationvertex, weight)
else:
edge['weight'][0] = (edge['weight'][0]*edge['weight'][1] + duration)/(edge['weight'][1] + 1)
edge['weight'][1] += 1
def addEdge(analyzer, origen, destino, duracion):
"""
Adiciona un arco entre dos estaciones
"""
edge = gr.getEdge(analyzer["graph"], origen, destino)
if edge is None:
gr.addEdge(analyzer["graph"], origen, destino, duracion)
return analyzer
def addEdge(analyzer, origin, destination, weight):
"""
Adiciona un arco entre dos estaciones
"""
edge = gr.getEdge(analyzer['connections'], origin, destination)
if edge is None:
gr.addEdge(analyzer['connections'], origin, destination, weight)
return analyzer
def addConnection(citibike, origin, destination, duration):
"""
Adiciona un arco entre dos estaciones
"""
edge = gr.getEdge(citibike["graph"], origin, destination)
if edge is None:
gr.addEdge(citibike["graph"], origin, destination, duration)
return citibike
def addRoute(citibike, start, end, duration):
edge = gr.getEdge(citibike['connections'], start, end)
if edge is None:
gr.addEdge(citibike['connections'], start, end, duration)
else:
gr.addEdgeCount(citibike['connections'], edge)
def addConnection(graph, origin, destination, distance,cable_name):
"""
Adiciona un arco entre dos landing points
"""
edge = gr.getEdge(graph, origin, destination)
if edge is None:
gr.addEdge(graph, origin, destination, distance, cable_name)
return graph
def addConnection(citibike, reference_tab, origin, destination):
"""
Adiciona un arco entre dos estaciones
"""
edge = gr.getEdge(citibike["grafo"], origin, destination)
if edge is None:
duration = promedio(reference_tab, origin, destination)
gr.addEdge(citibike["grafo"], origin, destination, duration)
return citibike
def addConnection(citibike, origin, destination, duration):
"""
Adiciona un arco entre dos estaciones
"""
edge = gr.getEdge(citibike ['graph'], origin, destination)
if edge is None:
wieght=[duration,1]
gr.addEdge(analyzer['graph'], origin, destination, wieght)
return citibike
def addEdge(analyzer, origin, destination, distance):
edge = gr.getEdge(analyzer['connections_origin_destination'], origin,
destination)
if edge is None:
gr.addEdge(analyzer['connections_origin_destination'], origin,
destination, distance)
return analyzer
def addConnection(citibike, origin, destination, duration, usertype, group):
edge = gr.getEdge(citibike["graph"], origin, destination)
if edge is None:
gr.addEdge(citibike["graph"], origin, destination, duration)
else:
e.updateAverageWeight(citibike["graph"], edge, duration, destination)
e.updateUserType(edge, usertype, group)
return citibike
def addConnection(citibike, start, finish, duration):
"""
Adiciona un arco entre dos estaciones
"""
edge = gr.getEdge(citibike['graph'], start, duration)
if edge is None:
gr.addEdge(citibike['graph'], start, finish, duration)
else:
e.updateAverageWeight(edge, duration)
return citibike
def fusion_internet(analyzer):
lstpoints = m.valueSet(analyzer['landing_points'])
for key in lt.iterator(lstpoints):
punto = key["conexiones"]
for subvertice1 in lt.iterator(punto):
for subvertice2 in lt.iterator(punto):
if subvertice1 != subvertice2:
gr.addEdge(analyzer["connections_internet"],
subvertice1['vertice'], subvertice2['vertice'],
0.1)
def addConnection(citibike, origin, destination, duration):
"""
Adiciona un arco entre dos estaciones.
Si el arco ya existe, se actualiza su peso promedio.
"""
edge = gr.getEdge(citibike['graph'], origin, destination)
if edge is None:
gr.addEdge(citibike['graph'], origin, destination, duration)
else:
e.updateAverageWeight(edge, duration)
def addConection(analyzer, connection):
"""
Agrega un landingPoint
"""
lt.addLast(analyzer['connectionsLst'],connection)
#error dato
edge = gr.getEdge(analyzer['connections'], connection['\ufefforigin'], connection['destination'])
if edge is None:
gr.addEdge(analyzer['connections'], connection['\ufefforigin'], connection['destination'], formatKM(connection['cable_length']))
return analyzer
def addArco(analyzer, origin, destination, duration):
"""
Adiciona un arco entre dos estaciones
"""
edge = gr.getEdge(analyzer['grafo'], origin, destination)
if edge is None:
gr.addEdge(analyzer['grafo'], origin, destination, duration)
else:
updateAverageWeight(edge, duration)
return analyzer
def addConnection(citibike, origin, destination, duration):
"""
Adiciona un arco entre dos estaciones
"""
edge = gr.getEdge(citibike['connections'], origin, destination)
if edge is None:
gr.addEdge(citibike['connections'], origin, destination, duration)
else:
ed.averageWeight(edge, duration)
return citibike
def addConnectionDia(citibike, origin, destination, duration):
"""
Adiciona un arco entre dos estaciones
"""
edge = gr.getEdge(citibike["Day"], origin, destination)
if edge is None:
gr.addEdge(citibike["Day"], origin, destination, duration)
else:
updateAverageWeight(edge, duration)
return citibike
def addConnection(catalog, origin, destination, duration):
"""
Adiciona un arco entre dos estaciones
"""
edge = gr.getEdge(catalog['graph'], origin, destination)
if edge is None:
gr.addEdge(catalog['graph'], origin, destination, duration)
else:
e.updateAverageWeight(edge, duration)
return catalog
def addConnection(analyzer, origen, destino, distancia, connection):
"""
Crea conexiones entre landing points (arcos)
"""
grafo = analyzer['connections']
try:
gr.addEdge(grafo, origen, destino, distancia)
return analyzer
except Exception as exp:
error.reraise(exp, 'model:addConnection')
def addConnection(analyzer, origin, destination, duration):
"""
Adiciona un arco entre dos estaciones. Si el arco existe se actualiza su peso con el promedio.
"""
edge = gr.getEdge(analyzer['connections'], origin, destination)
if edge is None:
gr.addEdge(analyzer['connections'], origin, destination, duration)
else:
e.updateAverageWeight(edge, duration)
return analyzer
def addConnection(Analyzer, origin, destination, duration):
"""
Adiciona un arco entre dos estaciones
"""
edge = gr.getEdge(Analyzer['grafos'], origin, destination)
if edge is None:
gr.addEdge(Analyzer['grafos'], origin, destination, duration)
else:
ed.averageWeight(edge,duration)
return Analyzer
def addConnection2(citibike, origin, destination, years, subscriber):
edge3 = gr.getEdge(citibike["customers"], origin, destination)
if edge3 is None:
gr.addEdge(citibike["customers"], origin, destination, years)
edge3 = gr.getEdge(citibike["customers"], origin, destination)
edge3["division"] = 1
else:
diferencial = incremental(edge3["weight"], edge3["division"], years)
edge3["division"] += 1
edge3["weight"] = int(diferencial)
return citibike
def AñadirConeccion(analyzer, origin, destination, duration):
"""
Adiciona un arco entre dos estaciones
"""
edge = gr.getEdge(analyzer["graph"], origin, destination)
if edge is None:
gr.addEdge(analyzer["graph"], origin, destination, duration)
else:
edge["weight"] = (edge["weight"] + int(duration)) / 2
return analyzer
def addConnection(Inite, community1, community2, duration):
edge = gr.getEdge(Inite["Graph"], community1, community2)
if edge is None:
gr.addEdge(Inite["Graph"], community1, community2, duration)
edge = gr.getEdge(Inite["Graph"], community1, community2)
edge["division"] = 1
else:
duracion = incremental(edge["weight"], edge["division"], duration)
edge["division"] += 1
edge["weight"] = duracion
return Inite
def Añadir_conexion(Taxis, origin, destination, duration):
edge = gr.getEdge(Taxis["communityAreas"], origin, destination)
if edge is None:
splitOrig = origin.split(" - ")
splitDest = destination.split(" - ")
if splitOrig[0] != splitDest[0]:
gr.addEdge(Taxis["communityAreas"], origin, destination, duration)
else:
pass
else:
ed.updateAverageWeight(edge, duration)
return Taxis
def addConnection(analyzer, origin, destination, duration):
"""
Adiciona un arco entre dos estaciones
"""
edge = gr.getEdge(analyzer["trips"], origin, destination)
if edge is None:
gr.addEdge(analyzer["trips"], origin, destination, duration)
else:
weight = e.weight(edge)
prom = (duration + weight) / 2
edge['weight'] = prom
return analyzer
def addConnection(graph, origin, destination, duration):
"""
Adiciona un arco entre dos community areas
"""
edge = gr.getEdge(graph, origin, destination)
if edge is None:
gr.addEdge(graph, origin, destination, duration)
else:
weight = e.weight(edge)
prom = (duration + weight)/2
edge['weight'] = prom
return graph
def req4(catalog):
grafo = catalog["connections"]
initSearch = prim.initSearch(grafo)
search = prim.prim(grafo, initSearch, "Washington, D.C.")
mst = gr.newGraph(datastructure="ADJ_LIST",
size=3000,
directed=False,
comparefunction=compareIds)
landing_points = mp.newMap(numelements=1249,
maptype="PROBING",
loadfactor=0.3)
vertices = mp.keySet(search["marked"])
for vertice in lt.iterator(vertices):
lp = vertice.split("|")[0]
mp.put(landing_points, lp, None)
gr.insertVertex(mst, vertice)
listaArcos = mp.keySet(search["edgeTo"])
pesoTotal = 0
for verticeB in lt.iterator(listaArcos):
verticeA = mp.get(search["edgeTo"], verticeB)["value"]["vertexA"]
peso = mp.get(search["edgeTo"], verticeB)["value"]["weight"]
gr.addEdge(mst, verticeA, verticeB, peso)
pesoTotal += peso
dfsSearch = dfs.DepthFirstSearch(mst, "Washington, D.C.")
maxArcos = 0
arcos = None
for vertice in lt.iterator(vertices):
pathTo = dfs.pathTo(dfsSearch, vertice)
if pathTo:
numArcos = lt.size(pathTo)
if numArcos > maxArcos:
maxArcos = numArcos
arcos = pathTo
numLanding_points = gr.numEdges(mst) + 1
return numLanding_points, pesoTotal, arcos
def conexion_lp(analyzer):
paises=mp.keySet(analyzer['vertices_paises'])
for i in range(lt.size(paises)):
pais=lt.getElement(paises,i)
lista_vertices=me.getValue(mp.get(analyzer['vertices_paises'],pais))
for j in range(lt.size(lista_vertices)):
vertice1=lt.getElement(lista_vertices,j)
for h in range(lt.size(lista_vertices)):
vertice2=lt.getElement(lista_vertices,h)
if vertice1[0] == vertice2[0]:
if gr.getEdge(analyzer['connections'],vertice1,vertice2)==None:
gr.addEdge(analyzer['connections'],vertice1,vertice2,0.1)
gr.addEdge(analyzer['connections'],vertice2,vertice1,0.1)
