def getaccidentrange(analyzer,minkey,maxkey):
accidentsdate=analyzer['dateIndex']
dates= om.values(accidentsdate,minkey,maxkey)
categoria=lt.newList()
categoriamax=None
lt.addLast(categoria,0)
lt.addLast(categoria,0)
lt.addLast(categoria,0)
lt.addLast(categoria,0)
cantidad=0
for i in range(1,lt.size(dates)+1):
fecha=lt.getElement(dates,i)
for a in range(1,lt.size(fecha)+1):
cantidad += 1
accidente=lt.getElement(fecha,a)
severidad=int(accidente['Severity'])
value=lt.getElement(categoria,severidad)
lt.insertElement(categoria, value+1,severidad)
if cantidad==1:
categoriamax=severidad
elif value+1>lt.getElement(categoria,categoriamax):
categoriamax=severidad
return categoria,cantidad,categoriamax
def plotMinimumCostPathMap(analyzer, vertexa, vertexb):
"""
Crea un mapa interactivo de la ruta de costo mínimo entre dos
puntos de conexión
"""
lstvertexs = controller.getMinimumCostPathVertexs(analyzer, vertexb)
lstcoordinates = controller.getPathCoordinates(analyzer, lstvertexs)
origincoords = lt.firstElement(lstcoordinates)
destcoords = lt.lastElement(lstcoordinates)
originpos = lt.isPresent(lstcoordinates, origincoords)
destpos = lt.isPresent(lstcoordinates, destcoords)
lt.removeFirst(lstcoordinates)
lt.removeLast(lstcoordinates)
map = folium.Map(origincoords, zoom_start=2.5)
for location in lt.iterator(lstcoordinates):
folium.Marker(location).add_to(map)
lt.insertElement(lstcoordinates, origincoords, originpos)
lt.insertElement(lstcoordinates, destcoords, destpos)
folium.Marker(origincoords,
str(vertexa.replace('-', ', ')),
icon=folium.Icon(icon='flag', color='red')).add_to(map)
folium.Marker(destcoords,
str(vertexb.replace('-', ', ')),
icon=folium.Icon(icon='flag', color='red')).add_to(map)
folium.PolyLine(lstcoordinates['elements'],
color="grey",
weight=2.5,
opacity=0.75).add_to(map)
map.save("map3.html")
def insert(heap, element):
"""
Guarda la pareja llave-valor en el heap. Lo guarda en la última
posición y luego hace swim del elemento
Args:
heap: El arreglo con la informacion
element: El elemento a guardar
Returns:
El heap con el nuevo elemento
Raises:
Exception
"""
try:
heap['size'] += 1
lt.insertElement(heap['elements'], element, heap['size'])
swim(heap, heap['size'])
return heap
except Exception as exp:
error.reraise(exp, 'heap:insert')
def insert(iheap, key, index):
"""
Inserta la llave key con prioridad index
Args:
iheap: El heap indexado
Returns:
El iheap con la nueva paraja indexada
Raises:
Exception
"""
try:
if not map.contains(iheap['qpMap'], key):
iheap['size'] += 1
lt.insertElement(iheap['elements'], {
'key': key,
'index': index
}, iheap['size'])
map.put(iheap['qpMap'], key, iheap['size'])
swim(iheap, iheap['size'])
return iheap
except Exception as exp:
error.reraise(exp, 'indexheap:newindexheap')
def getaccidenthourrange (analyzer,minkey,maxkey):
accidentshour=analyzer['hourIndex']
mintime = (60*int(minkey[0:2]))+int(minkey[3:5])
maxtime = (60*int(maxkey[0:2]))+int(maxkey[3:5])
hours= om.values(accidentshour,mintime,maxtime)
categoria=lt.newList()
lt.addLast(categoria,0)
lt.addLast(categoria,0)
lt.addLast(categoria,0)
lt.addLast(categoria,0)
cantidad=0
for i in range(1,lt.size(hours)+1):
hora=lt.getElement(hours,i)
for a in range(1,lt.size(hora)+1):
cantidad += 1
accidente=lt.getElement(hora,a)
severidad=int(accidente['Severity'])
valor=lt.getElement(categoria,severidad)
lt.insertElement(categoria,valor+1,severidad)
return categoria,cantidad
def test_insertElement_array(alt, books):
assert lt.isEmpty(alt) is True
assert lt.size(alt) == 0
lt.insertElement(alt, books[0], 1)
assert lt.size(alt) == 1
lt.insertElement(alt, books[1], 2)
assert lt.size(alt) == 2
lt.insertElement(alt, books[2], 1)
assert lt.size(alt) == 3
book = lt.getElement(alt, 1)
assert book == books[2]
book = lt.getElement(alt, 2)
assert book == books[0]
def estacionesCriticas(analyzer):
cuenta= 0
estaciones= gr.vertices(analyzer["graph"])
listaEntrada= lt.newList("ARRAY_LIST", comparestations)
listaSalida= lt.newList("ARRAY_LIST", comparestations)
listaSolitarias= lt.newList("ARRAY_LIST", comparestations)
entradasConcurridas= lt.newList("ARRAY_LIST", compareSizes)
salidasConcurridas= lt.newList("ARRAY_LIST", compareSizes)
estacionesSolitarias= lt.newList("ARRAY_LIST", compareSizes)
while cuenta<lt.size(estaciones):
estacion= lt.getElement(estaciones, cuenta)
entrada= gr.indegree(analyzer["graph"], estacion)
lt.addFirst(entradasConcurridas,entrada)
salida= gr.outdegree(analyzer["graph"], estacion)
lt.addFirst(salidasConcurridas,salida)
bidireccional= gr.degree(analyzer["graph"], estacion)
lt.addFirst(estacionesSolitarias,bidireccional)
cuenta+= 1
entradasOrg= sel.selectionSort(entradasConcurridas,lessequal)
salidasOrg= sel.selectionSort(salidasConcurridas,lessequal)
solitariasOrg= sel.selectionSort(estacionesSolitarias,lessequal)
for conteo in range(0,3):
if entrada == lt.getElement(entradasOrg, conteo):
lt.insertElement(listaEntrada, estacion, conteo)
if salida == lt.getElement(salidasOrg, conteo):
lt.insertElement(listaSalida, estacion, conteo)
if bidireccional == lt.getElement(solitariasOrg, conteo):
lt.insertElement(listaSolitarias, estacion, conteo)
if lt.size(listaEntrada) > 3:
lt.removeLast(listaEntrada)
if lt.size(listaSalida) > 3:
lt.removeLast(listaSalida)
if lt.size(listaSolitarias) > 3:
lt.removeLast(listaSolitarias)
return (listaEntrada, listaSalida, listaSolitarias)
def insertelement(lst, element, pos):
return lt.insertElement(lst, element, pos)
def insertarElemento(lst, elemento, pos):
lt.insertElement(lst, elemento, pos)
