def addEdge(graph, vertexa, vertexb, weight=0): """ Agrega un arco entre los vertices vertexa ---- vertexb, con peso weight. Si el grafo es no dirigido se adiciona dos veces el mismo arco, en el mismo orden Si el grafo es dirigido se adiciona solo el arco vertexa --> vertexb """ try: # Se crea el arco edge = e.newEdge(vertexa, vertexb, weight) #Se obtienen las listas de adyacencias de cada vertice #Se anexa a cada lista el arco correspondiente entrya = map.get(graph['vertices'], vertexa) lt.addLast(entrya['value'], edge) if (not graph['directed']): entryb = map.get(graph['vertices'], vertexb) lt.addLast(entryb['value'], edge) else: degree = map.get(graph['indegree'], vertexb) map.put(graph['indegree'], vertexb, degree['value'] + 1) graph['edges'] += 1 return graph except: return None
def stronglyConnected(self, idscc, verta, vertb): """ Dados dos vértices, informa si están fuertemente conectados o no. """ if m.get(idscc, verta)['value'] == m.get(idscc, vertb)['value']: return True return False
def add_gen(catalog, row): generos = catalog['generos'] split_gen = row['genres'].split('|') for i in split_gen: if map.contains(generos, i, compareByKey): map.get(generos, i, compareByKey)['peliculas'] += 1 else: x = new_gen(row['genres']) map.put(generos, i, x, compareByKey)
def relax(search, edge): v = e.either(edge) w = e.other(edge, v) visited_v = map.get(search['visitedMap'], v)['value'] visited_w = map.get(search['visitedMap'], w)['value'] if visited_w['distTo'] > (visited_v['distTo'] + e.weight(edge)): distToW = visited_v['distTo'] + e.weight(edge) map.put(search['visitedMap'], w, {'marked':True,'edgeTo':edge,'distTo':distToW}) if minpq.contains(search['minpq'], w): minpq.decreasePriority(search['minpq'], w, distToW) else: minpq.insert(search['minpq'], w, distToW)
def get_movies_by_title(catalog, name): x = map.get(catalog['MovieMap_title'], name, compareByKey) if x: vote = x['vote_average'] votos_totales = x['vote_count'] director_id = x['id'] director = map.get(catalog['Directors_id'], director_id, compareByKey)['name'] return ('El numero de votos es: ', str(votos_totales), '\nEl promedio de votos es: ', str(vote), '\nEl director de la pelicula es: ', str(director)) else: return 'No se encontro la pelicula'
def get_director_info(catalog, name): director = map.get(catalog['Directors_name'], name, compareByKey) if director: num_peli = lt.size(director['DirectorMovies']) vote_aver = director['sum_aver'] / num_peli peliculas = [] for i in range(1, num_peli + 1): id = lt.getElement(director['DirectorMovies'], i) peliculas.append( map.get(catalog['MovieMap_id'], id, compareByKey)['title']) return ('El director ', name, 'a dirigido ', str(num_peli), ' peliculas con un voto promedio de ', str(vote_aver), ' las peliculas del director son:\n', str(peliculas)) else: return 'No se encontro el director'
def bfs (search, source): queue = q.newQueue() q.enqueue(queue, source) while not (q.isEmpty(queue)): v = q.dequeue (queue) visited_v = map.get(search['visitedMap'], v)['value'] adjs = g.adjacents(search['graph'], v) adjs_iter = it.newIterator (adjs) while (it.hasNext(adjs_iter)): w = it.next (adjs_iter) print(w) visited_w = map.get(search['visitedMap'], w) if visited_w == None: map.put(search['visitedMap'], w, {'marked':True, 'edgeTo':v}) q.enqueue(queue, w)
def addEdge(graph, vertexa, vertexb, weight=0): """ Agrega un arco entre los vertices vertexa ---- vertexb, con peso weight """ # Se crea el arco edge = e.newEdge(vertexa, vertexb, weight) #Se obtienen las listas de adyacencias de cada vertice entrya = map.get(graph['vertices'], vertexa) entryb = map.get(graph['vertices'], vertexb) #Se anexa a cada lista el arco correspondiente lt.addLast(entrya['value'], edge) lt.addLast(entryb['value'], edge) graph['edges'] += 1
def degree(graph, vertex): """ Retorna el numero de arcos asociados al vertice vertex """ element = map.get(graph['vertices'], vertex) lst = element['value'] return (lt.size(lst))
def getBooksCountByYearRange(catalog, years): """ Retorna la cantidad de libros por rating para un rango de años """ startYear = strToDate(years.split(" ")[0], '%Y-%m-%d') endYear = strToDate(years.split(" ")[1], '%Y-%m-%d') yearList = tree.valueRange(catalog['yearsTree'], startYear, endYear, greater) counter = 0 cities = map.newMap(40009, maptype='PROBING') if yearList: iteraYear = it.newIterator(yearList) while it.hasNext(iteraYear): yearElement = it.next(iteraYear) #print(yearElement['year'],yearElement['count']) counter += yearElement['count'] keys = map.keySet(yearElement['ratingMap']) for i in range(1, lt.size(keys)): city_key = lt.getElement(keys, i) city = map.get(cities, city_key, compareByKey) if city: city['Accidentes'] += 1 else: ciudad = {'ciudad': city_key, 'Accidentes': 1} map.put(cities, ciudad['ciudad'], ciudad, compareByKey) total = {'total_Accidentes': counter} map.put(cities, 'total', total, compareByKey) return cities return None
def addYearTree(catalog, row): """ Adiciona el libro al arbol anual key=original_publication_year """ yearText = row['Start_Time'] if row['Start_Time']: yearText = row['Start_Time'][0:row['Start_Time'].index(' ')] year = strToDate(yearText, '%Y-%m-%d') yearNode = tree.get(catalog['yearsTree'], year, greater) if yearNode: yearNode['count'] += 1 sev = int(row['Severity']) yearNode['severity'][sev] += 1 city = row['City'] ratingCount = map.get(yearNode['ratingMap'], city, compareByKey) if ratingCount: ratingCount['Accidentes'] += 1 else: ciudad = {'Ciudad': row['City'], 'Accidentes': 1} map.put(yearNode['ratingMap'], ciudad['Ciudad'], ciudad, compareByKey) state = row['State'] state_count = tree.get(yearNode['state'], state, greater) if state_count: state_count['Accidentes'] += 1 else: estado = {'Estado': row['State'], 'Accidentes': 1} tree.put(yearNode['state'], estado['Estado'], estado, greater) else: yearNode = newYear(year, row) catalog['yearsTree'] = tree.put(catalog['yearsTree'], year, yearNode, greater)
def test_LoadTable(self): table_capacity = 171 book_map = ht.newMap(capacity=table_capacity, maptype='CHAINING', comparefunction=self.compare_book_id) booksfile = cf.data_dir + 'GoodReads/books-small.csv' self.assertEqual(ht.size(book_map), 0) self.assertTrue(ht.isEmpty(book_map)) input_file = csv.DictReader(open(booksfile)) for book in input_file: ht.put(book_map, book['book_id'], book) self.assertEqual(ht.size(book_map), 149) self.assertTrue(ht.contains(book_map, '100')) entry = ht.get(book_map, '100') self.assertIsNotNone(entry) self.assertEqual(entry['value']['book_id'], '100') ht.remove(book_map, '100') self.assertEqual(ht.size(book_map), 148) self.assertFalse(ht.contains(book_map, '100')) lst_keys = ht.keySet(book_map) self.assertFalse(lt.isEmpty(lst_keys)) self.assertEqual(lt.size(lst_keys), 148) lst_values = ht.valueSet(book_map) self.assertFalse(lt.isEmpty(lst_values)) self.assertEqual(lt.size(lst_values), 148)
def path(mapa,lista, source, dst): if source == dst: return lista vertice= map.get(mapa, source) anterior= vertice['edgeTo'] lt.addFirst(lista, anterior) path(mapa,lista,anterior,dst)
def test_LoadTable(self): self.assertEqual(ht.size(self.book_map), 0) self.assertTrue(ht.isEmpty(self.book_map)) input_file = csv.DictReader(open(self.booksfile)) for book in input_file: ht.put(self.book_map, book['book_id'], book, self.compare_book_id) self.assertEqual(ht.size(self.book_map), 149) self.assertTrue(ht.contains(self.book_map, '100', self.compare_book_id)) entry = ht.get(self.book_map, '100', self.compare_book_id) self.assertIsNotNone(entry) self.assertEqual(entry['value']['book_id'], '100') ht.remove(self.book_map, '100', self.compare_book_id) self.assertEqual(ht.size(self.book_map), 148) self.assertFalse( ht.contains(self.book_map, '100', self.compare_book_id)) lst_keys = ht.keySet(self.book_map) self.assertFalse(lt.isEmpty(lst_keys)) self.assertEqual(lt.size(lst_keys), 148) lst_values = ht.valueSet(self.book_map) self.assertFalse(lt.isEmpty(lst_values)) self.assertEqual(lt.size(lst_values), 148)
def getAccidentsByDateRange (catalog, dates): startDate = strToDate(dates.split(" ")[0],'%Y-%m-%d') endDate = strToDate(dates.split(" ")[1],'%Y-%m-%d') dateList = tree.valueRange(catalog['dateTree'], startDate, endDate, greater) # print(dateList) #hol= lt.getElement(dateList,13) #print(hol) iteraDates = it.newIterator(dateList) cities = {} count = 0 while it.hasNext(iteraDates): dateElement = it.next(iteraDates) if dateElement: citiesList = map.keySet(dateElement['cityMap']) iteraCities = it.newIterator(citiesList) while it.hasNext(iteraCities): cityKey = it.next(iteraCities) new = map.get(dateElement['cityMap'],cityKey,compareByKey) count += new if cityKey in cities.keys(): cities[cityKey] += new else: cities[cityKey]=new #response += ''+str(cityKey) + ':' + str(map.get(dateElement['cityMap'],cityKey,compareByKey)) + '\n' response = 'Total de accidentes en el rango: '+str(count)+'\n' for i in cities: response += str(i)+": "+str(cities[i])+"\n" #print (i, cities[i]) #response += str(i[0])+": "+str(i[1])+"\n" return response
def addDirector(catalog, row): """ Adiciona un director al mapa """ movies = catalog['idMap'] directors = catalog['directors'] id = row['id'] movie = map.get(movies, id, compareByKey) average = float(movie['vote_average']) movieTitle = movie['title'] director = map.get(directors, row['director_name'], compareByKey) if director: updateDirector(director, average, movieTitle) else: director = newDirector(row, average, movieTitle) map.put(directors, director['name'], director, compareByKey)
def trips_per_dates(catalog, init_date, last_date): ''' Función que responde el requerimiento 2; para un rango de fechas devuelve la cantidad de viajes totales por ciudad ''' # Esta es la que usamos para responder el req 2 , se devulve un dict con llaves = ciudades y value = suma de todas las cantidades response = {} date_1 = strToDate(init_date, '%m/%d/%Y') date_2 = strToDate(last_date, '%m/%d/%Y') range_list = tree.valueRange(catalog['date_city_trips'], date_1, date_2, greater) #print(range_list) #print(type(range_list)) iterator_range = it.newIterator(range_list) while it.hasNext(iterator_range): Element = it.next(iterator_range) elkeys = map.keySet(Element) iterator_keys = it.newIterator(elkeys) while it.hasNext(iterator_keys): city = it.next(iterator_keys) count = map.get(Element, city)['value'] if city in response: r = response[city] w = r + count response[city] = w else: response[city] = count return response
def addDate_city_trips(catalog, row): ''' Función que construye el árbol RBT de fechas. Cada nodo del árbol es a su vez un mapa de hash con cantidad de viajes indexados por ciudad ''' # Añadimos las fechas al RBT con un value igual a un map con ciudad y values = cantidad de viajes d = row['start_date'] # row del archivo trip.csv t = d.split(" ")[0] date = strToDate(t, '%m/%d/%Y') #print(date) id_station = row['start_station_id'] city_trip = tree.get(catalog['date_city_trips'], date, greater) #print(city_trip) city = station_id_city(catalog, id_station) if city_trip: if map.contains(city_trip, city): u = map.get(city_trip, city)['value'] u += 1 map.put(city_trip, city, u) catalog['date_city_trips'] = tree.put(catalog['date_city_trips'], date, city_trip, greater) else: map.put(city_trip, city, 1) catalog['date_city_trips'] = tree.put(catalog['date_city_trips'], date, city_trip, greater) else: city_trip = map.newMap(capacity=5, prime=3, maptype='CHAINING', comparefunction=compareByKey) map.put(city_trip, city, 1) catalog['date_city_trips'] = tree.put(catalog['date_city_trips'], date, city_trip, greater)
def addCityStations(catalog, row): ''' Función que va construyendo un mapa de ciudades, añadiendo a cada ciudad una lista con sus estaciones respectivas. Cada estación contiene un diccionario con su ID, Nombre, y Dock Count. ''' #Vamos actualizando el mapa de ciudades, añadiendo la estación a la ciudad respectiva cityStationsMap = catalog['cities'] station = { 'id': row['id'], 'name': row['name'], 'dock_count': row['dock_count'] } if map.contains(cityStationsMap, row['city']) == False: stationsList = lt.newList(datastructure='ARRAY_LIST') lt.addLast(stationsList, station) map.put(cityStationsMap, row['city'], stationsList) if map.contains(cityStationsMap, row['city']) == True: stationsList = map.get(cityStationsMap, row['city'])['value'] lt.addLast(stationsList, station) map.put(cityStationsMap, row['city'], stationsList) #Añadimos la estación al mapa de ids con value de nombres de las estaciones y su ciudad stationsIdName = catalog['stationIds'] dicct = {'Name': row['name'], 'City': row['city']} map.put(stationsIdName, row['id'], dicct)
def cargar_viajes_dia(catalog): lista_tem = catalog['list_temepratura'] mapa = catalog['fecha_tally_viajes'] for i in range(1, lt.size(lista_tem)): elemento = lt.getElement(lista_tem, i) fecha = elemento['dia'] fech_map = map.get(mapa, fecha) elemento['total'] = fech_map['total']
def get_generos(catalog, gen): genero = map.get(catalog['generos'], gen, compareByKey) if genero: numero = genero['peliculas'] return ('El genero ', gen, 'tiene ', str(numero), 'peliculas relacionadas') else: return 'No se encontro el genero'
def containsVertex(graph, vertex): """ Verifica si el grafo contiene un vertice """ try: return map.get(graph['vertices'], vertex) != None except: return None
def increasePriority(minPQ, index, priority): val = map.get(minPQ['qpMap'], index) if val == None: raise Exception("Index [" + index + "] doesn't exist") elem = minPQ['pq'][val['value']] elem['priority'] = priority minPQ['pq'][val['value']] = elem sink(minPQ, val['value'])
def addMovieMapVoteData(catalog, row): """ Adiciona información a una película """ movies = catalog['moviesMap'] movie = map.get(movies, row["id"], comparemovies) if movie: model.addMovieMapVoteData(movie, row)
def addDirectorVoteData(catalog, name, row): directors = catalog['directors'] director = map.get(directors, name, compareByKey) if director: if row["id"] in director["movies_id"]: lt.addLast(director['movie_titles'], row['title']) lt.addLast(director['movies_id'], row['id']) director['sum_average_rating'] += float(row['vote_average'])
def pathTo(search, v): if hasPathTo(search, v)==False: return None path= stk.newStack() while v != search['s']: stk.push(path,v) v = map.get(search['visitedMap'],v)['value']['edgeTo'] stk.push(path,search['s']) return path
def dfs (search, v): adjs = g.adjacents(search['graph'],v) adjs_iter = it.newIterator (adjs) while (it.hasNext(adjs_iter)): w = it.next (adjs_iter) visited_w = map.get(search['visitedMap'], w) if visited_w == None: map.put(search['visitedMap'], w, {'marked':True, 'edgeTo':v}) dfs(search, w)
def station_id_city(catalog, station_id): ''' Función que devuelve la ciudad en la que está ubicada una estación, recibiendo como input el id de la estación ''' # Funcion auxiliar a addDate_city_trips que me devuelve la ciudad a partir del id de una estacion stations_ids = catalog['stationIds'] y = map.get(stations_ids, station_id) city = y['value']['City'] return city
def Add_station_list(catalog, row): if map.contains(catalog['map_station'], row['city']) == None: value = lt.newList() map.put(catalog['map_station'], row['city'], value) dic = { 'city_id': row['id'], 'dock_count': row['dock_count'], 'city': row['city'] } lista = map.get(catalog['map_station'], row['city']) lt.addFirst(lista, dic) else: lista = map.get(catalog['map_station'], row['city']) dic = { 'city_id': row['id'], 'dock_count': row['dock_count'], 'city': row['city'] } lt.addFirst(lista, dic)
def pathTo(search, v): if hasPathTo(search, v) == False: return None path = stk.newStack() while v != search['s']: visited_v = map.get(search['visitedMap'], v)['value'] edge = visited_v['edgeTo'] stk.push(path, edge) v = e.either(edge) return path