def test_heapSort_time(self):
print('test 10000 numbers:')
arr1 = [randint(1, 500) for i in range(10000)]
count1 = time_decorator(heap_sort)(arr1)
print('average time cost:', count1, 's')
arr2 = [i for i in range(10000)]
count2 = time_decorator(heap_sort)(arr2)
print('best time cost:', count2, 's')
def test_InsertSort_time(self):
print('test 1000 numbers')
arr1 = [randint(1, 500) for i in range(1000)]
count1 = time_decorator(insertSort)(arr1)
print('average time cost:', count1, 's')
arr2 = [i for i in range(1000)]
count2 = time_decorator(insertSort)(arr2)
print('best time cost:', count2, 's')
arr3 = [i for i in range(1000, -1, -1)]
count3 = time_decorator(insertSort)(arr3)
print('worst time cost:', count3, 's')
# Generate some useful slices
year_races = races[races["year"] == year_id]
year_driver_standings = driver_standings[driver_standings["raceId"].isin(
year_races.index)].sort_values(by="raceId")
year_constructor_standings = constructor_standings[
constructor_standings["raceId"].isin(
year_races.index)].sort_values(by="raceId")
year_results = results[results["raceId"].isin(year_races.index)]
year_laps = lap_times[lap_times["raceId"].isin(year_races.index)]
year_qualifying = qualifying[qualifying["raceId"].isin(year_races.index)]
year_fastest_lap_data = fastest_lap_data[fastest_lap_data["raceId"].isin(
year_races.index)]
# Generate WDC plot
generate_wdc_plot = time_decorator(generate_wdc_plot)
wdc_plot = generate_wdc_plot(year_driver_standings, year_results)
# Generate constructor's plot
generate_wcc_plot = time_decorator(generate_wcc_plot)
constructors_plot = generate_wcc_plot(year_constructor_standings, year_results)
# Generate position vs mean lap time rank plot
generate_mltr_position_scatter = time_decorator(generate_mltr_position_scatter)
position_mltr_scatter = generate_mltr_position_scatter(
year_fastest_lap_data, year_results, year_driver_standings,
year_constructor_standings)
# Generate mean finish start position vs WDC finish position scatter plot
generate_msp_position_scatter = time_decorator(generate_msp_position_scatter)
msp_position_scatter = generate_msp_position_scatter(year_results,
driver_results = results[results["driverId"] == driver_id]
driver_driver_standings = driver_standings[driver_standings["driverId"] ==
driver_id]
driver_rids = driver_results["raceId"].unique()
driver_races = races[races.index.isin(driver_rids)].sort_values(
by=["year", "raceId"])
driver_years = driver_races["year"].unique()
driver_fastest_lap_data = fastest_lap_data[fastest_lap_data["driver_id"] ==
driver_id]
logging.info(
f"Generating layout for mode DRIVER in driver, driver_id={driver_id}")
# Position plot
generate_positions_plot = time_decorator(generate_positions_plot)
positions_plot, positions_source = generate_positions_plot(
driver_years, driver_driver_standings, driver_results,
driver_fastest_lap_data, driver_id)
# Mark constructor changes
mark_team_changes = time_decorator(mark_team_changes)
mark_team_changes(driver_years, driver_results, [positions_plot],
[positions_source])
# Circuit performance table
generate_circuit_performance_table = time_decorator(
generate_circuit_performance_table)
circuit_performance_table = generate_circuit_performance_table(
driver_results, driver_races, driver_id)
constructor_id = 6 # Ferrari
constructor_results = results[results["constructorId"] == constructor_id]
constructor_constructor_standings = constructor_standings[
constructor_standings["constructorId"] == constructor_id]
constructor_rids = constructor_results["raceId"].unique()
constructor_races = races[races.index.isin(constructor_rids)].sort_values(
by=["year", "raceId"])
constructor_years = constructor_races[constructor_races.index.isin(
constructor_constructor_standings["raceId"])]
constructor_years = constructor_years["year"].unique()
constructor_fastest_lap_data = fastest_lap_data[
fastest_lap_data["constructor_id"] == constructor_id]
# Position plot
generate_positions_plot = time_decorator(generate_positions_plot)
positions_plot, positions_source = generate_positions_plot(
constructor_years, constructor_constructor_standings, constructor_results,
constructor_fastest_lap_data, constructor_id)
# Positions bar plot
generate_finishing_positions_bar_plot = time_decorator(
generate_finishing_position_bar_plot)
positions_bar_plot = generate_finishing_positions_bar_plot(constructor_results)
# WCC bar plot
generate_wcc_position_bar_plot = time_decorator(generate_wcc_position_bar_plot)
wcc_bar_plot = generate_wcc_position_bar_plot(positions_source)
# Win plot
generate_win_plot = time_decorator(generate_win_plot)
year_fastest_lap_data = fastest_lap_data[fastest_lap_data["raceId"].isin(
year_rids)]
yd_fastest_lap_data = year_fastest_lap_data[year_fastest_lap_data["driver_id"]
== driver_id]
yd_races = year_races
constructor_results_idxs = []
for idx, results_row in yd_results.iterrows():
cid = results_row["constructorId"]
rid = results_row["raceId"]
constructor_results_idxs.extend(year_results[
(year_results["raceId"] == rid)
& (year_results["constructorId"] == cid)].index.values.tolist())
constructor_results = year_results.loc[constructor_results_idxs]
# More focused WDC plot
generate_wdc_plot = time_decorator(generate_wdc_plot)
wdc_plot = generate_wdc_plot(year_races, year_driver_standings, year_results,
driver_id)
# Positions plot
generate_positions_plot = time_decorator(generate_positions_plot)
positions_plot, positions_source = generate_positions_plot(
yd_driver_standings, yd_results, yd_fastest_lap_data, year_id, driver_id)
# Win plot
generate_win_plot = time_decorator(generate_win_plot)
win_plot = generate_win_plot(positions_source, year_results)
# Finishing position bar plot
generate_finishing_position_bar_plot = time_decorator(
generate_finishing_position_bar_plot)
race = races[(races["circuitId"] == circuit_id) & (races["year"] == year_id)]
rid = race.index.values[0]
race_results = results[results["raceId"] == rid]
ycd_results = race_results[race_results["driverId"] == driver_id]
race_laps = lap_times[lap_times["raceId"] == rid]
ycd_laps = race_laps[race_laps["driverId"] == driver_id]
ycd_pit_stop_data = pit_stop_data[(pit_stop_data["raceId"] == rid)
& (pit_stop_data["driverId"] == driver_id)]
race_quali = quali[quali["raceId"] == rid]
ycd_fastest_lap_data = fastest_lap_data[(fastest_lap_data["raceId"] == rid) & (
fastest_lap_data["driver_id"] == driver_id)]
year_driver_standings = driver_standings[driver_standings["raceId"].isin(
year_races.index.values)]
# Gap plot
generate_gap_plot = time_decorator(generate_gap_plot)
gap_plot, cached_driver_map = generate_gap_plot(race_laps, race_results,
driver_id)
# Position plot
generate_position_plot = time_decorator(generate_position_plot)
position_plot = generate_position_plot(race_laps, race_results,
cached_driver_map, driver_id)
# Lap time plot
generate_lap_time_plot = time_decorator(generate_lap_time_plot)
lap_time_plot = generate_lap_time_plot(race_laps, race_results,
cached_driver_map, driver_id)
plots = [gap_plot, position_plot, lap_time_plot]
def test_mergeSort_time(self):
arr1 = [randint(1,500) for i in range(10000)]
count1 = time_decorator(mergeSort)(arr1,0,len(arr1)-1)
print('average time cost:',count1,'s')
& (lap_times["driverId"] == did)]
cc_lap_time_idxs.extend(lt_slice.index.values.tolist())
driver_standings_slice = driver_standings[
(driver_standings["raceId"] == rid)
& (driver_standings["driverId"] == did)]
cc_driver_standings_idxs.extend(
driver_standings_slice.index.values.tolist())
cc_fastest_lap_data = circuit_fastest_lap_data.loc[cc_fastest_lap_data_idxs]
cc_lap_times = lap_times.loc[cc_lap_time_idxs]
cc_driver_standings = driver_standings.loc[cc_driver_standings_idxs]
cc_constructor_standings = constructor_standings[
(constructor_standings["constructorId"] == constructor_id)
& (constructor_standings["raceId"].isin(cc_rids))]
# Positions plot
generate_positions_plot = time_decorator(generate_positions_plot)
positions_plot, positions_source = generate_positions_plot(
cc_years, cc_fastest_lap_data, constructor_results,
cc_constructor_standings, cc_races, constructor_id)
# Win plot
generate_win_plot = time_decorator(generate_win_plot)
win_plot = generate_win_plot(positions_source, constructor_id)
# Lap time distribution plot
generate_lap_time_distribution_plot = time_decorator(generate_lap_time_plot)
lap_time_distribution_plot = generate_lap_time_distribution_plot(
cc_lap_times, cc_rids, circuit_id, constructor_id)
# Finish position bar plot
generate_finishing_position_bar_plot = time_decorator(
qualifying = load_qualifying()
results = load_results()
driver_standings = load_driver_standings()
circuit_id = 14 # Monza
circuit_races = races[races["circuitId"] == circuit_id]
circuit_rids = circuit_races.index
circuit_years = sorted(circuit_races["year"].values.tolist())
circuit_fastest_lap_data = fastest_lap_data[fastest_lap_data["raceId"].isin(circuit_rids)]
circuit_quali = qualifying[qualifying["raceId"].isin(circuit_rids)]
circuit_results = results[results["raceId"].isin(circuit_rids)]
circuit_driver_standings = driver_standings[driver_standings["raceId"].isin(circuit_rids)]
# Generate times plot
generate_times_plot = time_decorator(generate_times_plot)
times_plot = generate_times_plot(circuit_years, circuit_quali, circuit_fastest_lap_data, circuit_races,
circuit_results, circuit_id)
# Generate DNF plot
generate_dnf_plot = time_decorator(generate_dnf_plot)
dnf_plot = generate_dnf_plot(circuit_years, circuit_results, circuit_races, circuit_id)
# Generate starting position minus finish position plot
generate_spmfp_plot = time_decorator(generate_spmfp_plot)
spmfp_plot = generate_spmfp_plot(circuit_years, circuit_races, circuit_results)
# Start pos vs finish pos scatter
generate_spvfp_scatter = time_decorator(generate_spvfp_scatter)
spvfp_scatter = generate_spvfp_scatter(circuit_results, circuit_races, circuit_driver_standings)
