def test_geo(): # Build list of stations stations = build_station_list() # Create list of tuples of station name and distance from Cambridge stations_from_cambridge = [] for i in range(len(stations_by_distance(stations, (52.2053, 0.1218)))): stations_from_cambridge.append( stations_by_distance(stations, (52.2053, 0.1218))[i]) closest = stations_from_cambridge[0] assert closest[0] == "Cambridge Jesus Lock"
def test_stations_by_distance(): result = stations_by_distance(build_station_list(), (52.2053, 0.1218)) result_1 = result[0] result_2 = result[-1] assert len(stations_by_distance(build_station_list(), (52.2053, 0.1218))) > 0 assert result_1[1] == 0.840237595667494 assert result_2[1] == 467.53431870130544 assert type(result) == list assert type(result_1) == tuple assert type(result_2) == tuple assert type(result_1[1]) == float assert type(result_2[1]) == float
def test_stations_by_distance(): m = stations_by_distance(stations, (52.2053, 0.1218)) assert type(m) == list for i in range(len(m)): assert type(m[i][1]) == float assert type(m[i]) == tuple assert m[i][1] > 0
def run(): """Requirements for Task 1B""" cam_coord = (52.2053, 0.1218) #coordinates of Cambridge city centre #build station list stations = build_station_list() #calculate the distances to coordinates distances_to_cam = stations_by_distance(stations, cam_coord) #10 closest will be the first 10 items in the list close10 = distances_to_cam[:10] #reverse the order and take the first 10 items of the re-orderd list distances_to_cam = sorted_by_key(distances_to_cam, 1, reverse=True) far10 = distances_to_cam[:10] #format outputs close10formatted = [] far10formatted = [] for i in close10: close10formatted.append((i[0].name, i[0].town, i[1])) for i in far10: far10formatted.append((i[0].name, i[0].town, i[1])) print("Closest 10 stations to Cambride:") for i in close10formatted: print(i) print("") print("Furthest 10 stations from Cambridge:") for i in far10formatted: print(i)
def run(): """ Prints a list of tuples (station name, town, distance) for the 10 closest and the 10 furthest stations from the Cambridge city centre, (52.2053, 0.1218). """ stations = build_station_list() sorted_stations = stations_by_distance(stations, (52.2053, 0.1218)) print("The closest 10 stations are: {}".format(sorted_stations[:10])) print("The furthest 10 stations are: {}".format(sorted_stations[-10:]))
def test_stations_by_distance(): """Uses the generated stations, and checks to see if it was correctly sorted by distance """ stations = generate_test_station() stations_list = stations_by_distance(stations, (0, 0)) """The coordinates of the generated stations are such that the distance from (0,0) is incresing with the station number""" for i in range(len(stations_list)): assert stations_list[i][0].name == f"Station {i+1}"
def test_stations_by_distance(): stations = gen_stations() distances = geo.stations_by_distance(stations, (0, 0)) assert distances[0][0] == stations[2] assert round(distances[0][1] - 5674.419005723288) == 0 assert distances[4][0] == stations[1] assert round(distances[4][1] - 5876.221687663879) == 0
def run(): """ Requirement for Task 1B""" stations = build_station_list() stations_distance = stations_by_distance(stations, (52.2053, 0.1218)) print("10 Closest Entries: ", stations_distance[:10]) print("\n") print("10 Furthest Entries", stations_distance[-10:])
def test_geo_stations_by_distance(): # Build list of stations stations = build_station_list() # Use Cambridge City Centre (52.2053, 0.1218) distance_sorted = geo.stations_by_distance(stations, (52.2053, 0.1218)) assert distance_sorted[0][0].town == "Cambridge"
def test_stations_by_distance(): #Builds station list stations = build_station_list() centre = (0, 0) sorted_stations = geo.stations_by_distance(stations, centre) #Checks that list exists and in order assert len(sorted_stations) > 0 for i in range(1, len(sorted_stations)): assert sorted_stations[i][1] >= sorted_stations[i - 1][1]
def test_stations_by_distance(): s = build_station_list() p = (0.0, 0.0) a = stations_by_distance(s, p) assert a[0][2] <= a[-1][2] for item in a: assert type(item) == tuple assert type(item[0]) == str assert type(item[2]) == float
def run(): # Build list of stations stations = build_station_list() #state coordinate p=(52.2053, 0.1218) x=stations_by_distance(stations,p) #print nearest 10 stations print (x[:10]) #print furthest 10 stations print (x[-10:])
def run(): stations = build_station_list() coord_camcity = (52.2053, 0.1218) stations_list = stations_by_distance(stations, coord_camcity) converted_list = convert(stations_list) closest_10 = converted_list[:10] furthest_10 = converted_list[-10:] print(f"{closest_10}\n{furthest_10}")
def run(): """Requirements for Task 1B""" # Build list of stations stations = build_station_list() point = (52.2053, 0.1218) list_of_stations = stations_by_distance(stations, point) closest = list_of_stations[:10] furthest = list_of_stations[-10:] print("10 closest station to point P(52.2053, 0.1218): {}".format(closest)) print( "10 furthest station to point P(52.2053, 0.1218): {}".format(furthest))
def run(): # Build list of stations stations = build_station_list() p = (52.2053, 0.1218) distances = stations_by_distance(stations, p) station_names = [] for (station, distance) in distances: details = (station.name, station.town, distance) station_names.append(details) print(station_names[:10]) print(station_names[-10:])
def run(): "Requirements for Task 1B" #Builds a list of stations stations = stationdata.build_station_list(use_cache=True) #builds list of tuples of the stations with their distances from the coordinate stations_names_distances = geo.stations_by_distance(stations, (52.2053,0.1218)) #prints the 10 stations that are closest to the coordinate print("CLOSEST 10 STATIONS:", stations_names_distances[:10]) #prints the 10 stations that are furthest from the coordinate print("FURTHEST 10 STATIONS:", stations_names_distances[-10:])
def test_stations_by_distance(): # Build list of stations stations = build_station_list() p=(52.2053, 0.1218) x=stations_by_distance(stations,p) NoneType = type(None) #assert that the data types of each element in the tuples are correct and that they are sorted by distance for n in range(len(x)): assert isinstance(x[n][0],str) assert isinstance(x[n][1],str) or isinstance(x[n][1],NoneType) assert isinstance(x[n][2],float) if n!=(len(x)-1): assert x[n][2]<=x[n+1][2]
def test_stations_by_distance(): # Build list of stations stations = build_station_list() given_latitude=52.2053/180*(np.pi) given_longitude=0.1218/180*(np.pi) p=[given_latitude,given_longitude] distance=stations_by_distance(stations,p) test_list=[] for i in range (len(distance)): x=(distance[i][0].name, distance[i][0].town, distance[i][1]) test_list.append(x) assert test_list[0]==('Cambridge Jesus Lock', 'Cambridge', 0.8402364350834995)
def run(): # Build list of stations stations = build_station_list() given_latitude = 52.2053 / 180 * (np.pi) given_longitude = 0.1218 / 180 * (np.pi) p = [given_latitude, given_longitude] distance = stations_by_distance(stations, p) test_list = [] for i in range(len(distance)): x = (distance[i][0].name, distance[i][0].town, distance[i][1]) test_list.append(x) print(test_list[:10]) print(test_list[-10:])
def run(): """Requirements for Task 1B""" # Build list of stations stations = build_station_list() # Making station-distance list around Cambridge test_case = stations_by_distance(stations, (52.2053, 0.1218)) x = [0]*len(test_case) #Creating a new list to store distances, names and towns of stations around Cambridge for i in range(len(test_case)): x[i] = (test_case[i][0].name, test_case[i][0].town, test_case[i][1]) print("First Ten Entries") print(x[:10]) print("Last Ten Entries") print(x[-10:])
def run(): #Input coordinates of Cambridge city centre Reference_coordinate = (52.2053, 0.1218) #Create list of tuples (station name, distance) TheList = stations_by_distance (build_station_list(), Reference_coordinate) #Create list of tuples (station name, town, distance) for the 10 closest and furthest stations closest = [(s.name, s.town, d) for s, d in TheList[:10]] furthest = [(s.name, s.town, d) for s, d in TheList[-10:]] print ("The closest 10 stations are:") print (closest) print ("The furthest 10 stations are:") print (furthest)
def run(): """Requirements for Task 1B""" print("*** Task 1B: CUED Part IA Flood Warning System ***") # Build list of stations stations = build_station_list() # Create list of tuples of station name and distance from Cambridge stations_from_cambridge = [] stations_from_cambridge = stations_by_distance(stations, (52.2053, 0.1218)) # Prints the 10 closest stations to Cambridge print("Closest 10 Stations to Cambridge:") print(stations_from_cambridge[:10]) # Prints the 10 furthers stations from Cambridge print("Furthest 10 Stations from Cambridge:") print(stations_from_cambridge[-10:])
def run(): """Requirements for Task 1B""" # Build list of stations stations = build_station_list() # Sort the stations by distance from cambridge centre p = (52.2053, 0.1218) sorted_stations = stations_by_distance(stations, p) # Print the closest and furthest 10 stations = [] for station in sorted_stations: stations.append((station[0].name, station[0].town, station[1])) print(stations[:10]) print(stations[-10:])
def run(): """Requirements for Task 1B Prints a list of tuples (station name, town, distance) for the 10 closest and the 10 furthest stations from the Cambridge city centre, (52.2053, 0.1218)""" # Define the coordinates of Cambridge City Centre Cambridge_City_Centre = (52.2053, 0.1218) # Sort the stations by their distances to CCC stations_dis_order = stations_by_distance( build_station_list(), Cambridge_City_Centre) # Display the closest ten stations print([(station.name, station.town, dis) for station, dis in stations_dis_order[:10]]) # Display the farthest ten stations print([(station.name, station.town, dis) for station, dis in stations_dis_order[-10:]])
def run(): ''' Testing for stations_by_distance ''' # generate stations list stations = build_station_list() # get distance p_cam_center = (52.2053, 0.1218) output = stations_by_distance(stations, p_cam_center) # change each element from (obj, dis) to (name, town, dis) output = [(station.name, station.town, distance) for station, distance in output] # do the output print(output[:10]) print() print(output[-10:]) return [output[:10], output[-10:]]
def run(): """Requirements for Task 1B""" # Build list of stations and distances stations_distances = stations_by_distance(build_station_list(), (52.2053, 0.1218)) # initialize output lists output_closest = [] output_furthest = [] # get name and town and distance of the ten closest stations for pair in stations_distances[:10]: output_closest.append((pair[0].name, pair[0].town, pair[1])) # get name and town and distance of the ten furthest stations for pair in stations_distances[-10:]: output_furthest.append((pair[0].name, pair[0].town, pair[1])) print(output_closest, output_furthest)
def test_stations_by_distance(): # Create a station s_id = "test-s-id" m_id = "test-m-id" label = "some station" coord = (-2.0, 4.0) trange = (-2.3, 3.4445) river = "River X" town = "My Town" s = MonitoringStation(s_id, m_id, label, coord, trange, river, town) #Build an empty list for storing tuples later Example_build_list = [] Example_build_list.append(s) #calling the function to be tested Example_list = stations_by_distance(Example_build_list, (2.0, -4.0)) #testing the values of the 2 elements in the tuple in the list for s, d in Example_list[:]: assert s.name == "some station" assert d == 994.3960016965921
def test_stations_by_distance_returns_given_stations_in_order_of_distance_from_a_coordinate_p( ): stations = [] coords = [(-10.0, 0.0), (5.0, 5.0), (9.9, 9.9), (0.0, 0.0)] for i in range(len(coords)): # Create stations s_id = "test-s-id-" + str(i) m_id = "test-m-id-" + str(i) label = "some station " + str(i) coord = coords[i] trange = (-2.3, 3.4445) river = "River " + str(i) town = "My Town " + str(i) stations.append( MonitoringStation(s_id, m_id, label, coord, trange, river, town)) p = (10.0, 10.0) actual_sorted_stations = geo.stations_by_distance(stations, p) expected_sorted_stations = [(stations[2], haversine(p, stations[2].coord)), (stations[1], haversine(p, stations[1].coord)), (stations[3], haversine(p, stations[3].coord)), (stations[0], haversine(p, stations[0].coord))] assert expected_sorted_stations == actual_sorted_stations
#!/usr/bin/env python3 # -*- coding: utf-8 -*- """ Created on Tue Jan 23 18:22:24 2018 @author: Heisenberg """ from floodsystem.stationdata import build_station_list from floodsystem.geo import stations_by_distance stations = build_station_list() p = (52.2053, 0.1218) x = stations_by_distance(stations, p) #Find first 10 stations print("The closest 10 stations are:") print() for i in range(10): y = x[i][0] print(y.name) print(y.town) print(x[i][1]) print() #Find first 10 stations print("The furthest 10 stations are:") print() for i in range(10):
def test_stations_by_distance(): result = stations_by_distance(stations, p=(0, 0)) for i in range(1, len(result)): x = result[i] y = result[i - 1] assert x[2] >= y[2]