def create_sample(idx, points, reference_points): radius = points[idx, 3] point = points[idx, :3] directions_label = np.zeros(D, dtype="float32") for i in range(50, 201): assert idx + i < points.shape[0] - 1 distance = calculate_distance(point, points[idx + i, :3]) if distance > radius: print("forward: %.5f" % distance) forward_idx = idx + i break forward_d = find_direction_cat(point, points[forward_idx, :3], reference_points) directions_label[forward_d] = 0.5 for i in range(50, 201): assert idx - i > 0 distance = calculate_distance(point, points[idx - i, :3]) if distance > radius: print("backward: %.5f" % distance) backward_idx = idx - i break backward_d = find_direction_cat(point, points[backward_idx, :3], reference_points) directions_label[backward_d] = 0.5 return radius, directions_label
def test_calculate_distance(self): point1 = [0, 0] point2 = [2, 2] exp_dist = 2.82 distance = utils.calculate_distance(point1, point2) self.assertAlmostEqual(distance, exp_dist, places=1) point1 = [10, 10] point2 = [0, 6] exp_dist = 10.77 distance = utils.calculate_distance(point1, point2) self.assertAlmostEqual(distance, exp_dist, places=1)
def main(file, note_arr=None, plot_starts=False, plot_fft_indices=[]): actual_notes = [] if note_arr: actual_notes = note_arr song = AudioSegment.from_file(file) #song = song.high_pass_filter(80, order=4) starts = predict_note_starts(song, plot_starts) predicted_notes = predict_notes(song, starts, plot_fft_indices) print("") if actual_notes: print("Actual Notes") print(actual_notes) print("Predicted Notes") print(predicted_notes) if actual_notes: lev_distance = calculate_distance(predicted_notes, actual_notes) score = abs(len(actual_notes) - lev_distance) / len(actual_notes) print("Levenshtein distance: {}/{}".format(lev_distance, len(actual_notes))) return score
def random_search(): truck_x, truck_y = self.depo_coords if self.greedy: self.customer_info.sort(key=lambda x: x[1]) else: random.shuffle(self.customer_info) visited = set() total_distance_traveled = 0 all_truck_paths = [] for i in range(self.num_vehicles): capacity = self.vehicle_capacity truck_path = [0] for customer_idx, customer_demand, customer_x, customer_y in self.customer_info: if customer_idx in visited: continue if capacity - customer_demand < 0: continue visited.add(customer_idx) capacity -= customer_demand truck_path.append(customer_idx) total_distance_traveled += calculate_distance( truck_x, truck_y, customer_x, customer_y) truck_x = customer_x truck_y = customer_y if capacity == 0: break truck_path.append(0) #goes back to depot all_truck_paths.append(truck_path) return all_truck_paths, total_distance_traveled
def calculate_priority(self, is_current_state: bool) -> None: if not self.status.snitch_available: return 0 self.snitch = self.status.find_snitch() if self.snitch == None: return 0 distance = calculate_distance(self.status.position, self.snitch.position) return (0.5 - distance/200) + (3 * 0.125)
def width(self): """ Calculate the width, in statue miles. @return: width, in statute miles @rtype: C{float} """ return calculate_distance(self.min_lat, self.min_lon, self.min_lat, self.max_lon)
def height(self): """ Calculate the height, in statue miles. @return: height, in statute miles @rtype: C{float} """ return calculate_distance(self.min_lat, self.min_lon, self.max_lat, self.min_lon)
def main(file, note_file=None, note_starts_file=None, plot_starts=False, plot_fft_indices=[]): # If a note file and/or actual start times are supplied read them in actual_starts = [] if note_starts_file: with open(note_starts_file) as f: for line in f: actual_starts.append(float(line.strip())) actual_notes = [] if note_file: with open(note_file) as f: for line in f: actual_notes.append(line.strip()) song = AudioSegment.from_file(file) song = song.high_pass_filter(80, order=4) starts, ends, volumes = predict_note_starts(song, plot_starts, actual_starts) predicted_notes = predict_notes(song, starts, actual_notes, plot_fft_indices) track = 0 channel = 0 time = 0 # In beats duration = 0.3 # In beats tempo = 60 # In BPM volume = 100 # 0-127, as per the MIDI standard MyMIDI = MIDIFile( 1) # One track, defaults to format 1 (tempo track is created # automatically) MyMIDI.addTempo(track, time, tempo) # TODO(elliear): Modify duration to match start and end, and volume, and pitch for i, pitch in enumerate(degrees): MyMIDI.addNote(track, channel, pitch, time + i * 0.3, duration, volume) with open("major-scale.mid", "wb") as output_file: MyMIDI.writeFile(output_file) print("") if actual_notes: print("Actual Notes") print(actual_notes) print("Predicted Notes") print(predicted_notes) if actual_notes: lev_distance = calculate_distance(predicted_notes, actual_notes) print("Levenshtein distance: {}/{}".format(lev_distance, len(actual_notes)))
def calculate_total_distance(self, solution): total_distance_traveled = 0 for truck_locations in solution: for start, end in zip(truck_locations[:-1], truck_locations[1:]): _, _, start_x, start_y = self.customer_info[start] _, _, end_x, end_y = self.customer_info[end] total_distance_traveled += calculate_distance( start_x, start_y, end_x, end_y) return total_distance_traveled
def calculate_priority(self, is_current_state: bool): baby_pos = self.status.position seentanks = self.status.recently_seen_tanks(2) for tank in seentanks: in_danger = all((tank.is_aiming_at(baby_pos), tank.has_ammo(), calculate_distance(self.status.position, tank.current_pos()) < 35)) if in_danger: self.tank = tank return 0.75 return 0
def extract_distance_from_avg_vector(df): neg_posts = utils.get_abusive_df(df)['text'].tolist() pos_posts = utils.get_no_abusive_df(df)['text'].tolist() m_wiki = w2v.get_model(ROOT / "Embedding/wiki.he.word2vec.model") m_our = w2v.get_model(ROOT / "Embedding/our.corpus.word2vec.model") neg_matrix = helpers.create_vectors_array(neg_posts, m_our, m_wiki) pos_matrix = helpers.create_vectors_array(pos_posts, m_our, m_wiki) neg_avg_vec = np.mean(neg_matrix) pos_avg_vec = np.mean(pos_matrix) distance_type = 'euclidean' df_offensive_distance = pd.DataFrame( columns=['id', 'dist_avg_neg', 'dist_avg_pos']) df_offensive_distance['id'] = df['id'].tolist() df_offensive_distance['dist_avg_neg'] = df['text'].apply( lambda x: utils.calculate_distance( w2v.get_post_vector(m_our, m_wiki, x), neg_avg_vec, distance_type)) df_offensive_distance['dist_avg_pos'] = df['text'].apply( lambda x: utils.calculate_distance( w2v.get_post_vector(m_our, m_wiki, x), pos_avg_vec, distance_type)) return df_offensive_distance
def get_distance_df(df, column_name, sentence, distance_type='euclidean'): df_offensive_distance = pd.DataFrame(columns=['id', column_name]) df_offensive_distance['id'] = df['id'].tolist() m_wiki = w2v.get_model(ROOT + "/Embedding/wiki.he.word2vec.model") m_our = w2v.get_model(ROOT + "/Embedding/our.corpus.word2vec.model") df_offensive_distance[column_name] = df['text'].apply( lambda x: utils.calculate_distance(w2v.get_post_vector(m_our, m_wiki, x), w2v.get_post_vector(m_our, m_wiki, sentence), distance_type)) return df_offensive_distance
def calculate_distance_mode(pairs, df, ref, mode, measure, ref2=[]): """ From a set of pairs, calculate the distance of the offset of the pair in relation to the global offset. Parameters: ----------- pairs: list list containing tuples of IDs of norms [(id1,id2),(id3,id4)...] df: pandas.dataframe dataframe containing ids and embeddings of sentences ref: np.array vector containing the reference to measure the distance mode: string how vectors are combined (offset, concat or mean) measure: string measure to calculate the distance (euc or cos) ref2: np.array calculate the distance to a second reference Return: ------- list containing the distance and ids in the form [(dist, id1, id2), (dist, id2, id3),...] """ vdist = [] pb = progressbar.ProgressBar(len(pairs)) for i, pair in enumerate(pairs): id1, id2 = pair combined = utils.combine(pair, df, mode=mode) dist = utils.calculate_distance(combined, ref, measure=measure) if len(ref2) > 0: dist2 = utils.calculate_distance(combined, ref2, measure=measure) vdist.append((dist, dist2, id1, id2)) else: vdist.append((dist, id1, id2)) pb.update() #if i == 1000: break return vdist
def remove_clipping(xyz): index = [] for pts in range(0, len(xyz)): # calculate x index x = xyz[pts][0] y = xyz[pts][1] z = xyz[pts][2] # 0,-0.39098,0.13889 if calculate_distance(x, y, z, 0, -0.5910, 0.7389) > 1.5 or x > 0.5 or y > 0.5: index.append(pts) xyz = np.delete(xyz, index, axis=0) return xyz
def get_nearby_customers(customers, max_distance): ''' Get a list of customers inside radius provided from Dublin Office ''' nearby_customers = [] for customer in customers: current_coord = (customer['latitude'], customer['longitude']) if calculate_distance(current_coord, OFFICE_COORD) <= max_distance: nearby_customers.append(customer) return nearby_customers
def calculate_distance(self, point): """ Calculate the distance from this point to the given point, in statue miles. @param point: point to calculate distance to @type point: L{Point} @return: distance in statute miles @rtype: C{float} """ if point is self: return 0.0 return calculate_distance(self.lat, self.lon, point.lat, point.lon)
def insert(self, osm_object): center_x = self.center_point[0] center_y = self.center_point[1] angle_1, angle_2 = calculate_border_angles_to_object_and_point( center_x, center_y, osm_object, self.img_shape) ### почему??? # angle_1, angle_2 = calculate_border_angles_to_object_and_point(center_y, center_x, osm_object, self.img_shape) object_x, object_y = calculate_osm_object_center(osm_object) distance = calculate_distance((center_x, center_y), (object_x, object_y)) ### почему??? # distance = calculate_distance((center_x, center_y), (object_y, object_x)) diff_between_angles = abs(angle_2 - angle_1) # Перехода через 0 нет start_angle = min(angle_1, angle_2) end_angle = max(angle_1, angle_2) if diff_between_angles >= 180: # Есть переход через 0 start_angle = max(angle_1, angle_2) end_angle = min(angle_1, angle_2) sector_start_idx = int(start_angle / self.step_grad) sector_end_idx = int(end_angle / self.step_grad) if self.with_angle_penalty: sectors_count = abs(sector_start_idx - sector_end_idx) + 1 sector_penalty = 1 / sectors_count if diff_between_angles < 180: for sector_idx in range(sector_start_idx, sector_end_idx + 1): if not self.with_angle_penalty: self.sectors[sector_idx].append((distance, osm_object.tag)) else: self.sectors[sector_idx].append( (distance, osm_object.tag, sector_penalty)) else: for sector_idx in list(range(sector_start_idx, self.sectors_count)) + list( range(0, sector_end_idx)): if not self.with_angle_penalty: self.sectors[sector_idx].append((distance, osm_object.tag)) else: self.sectors[sector_idx].append( (distance, osm_object.tag, sector_penalty))
def perform(self): enemy = self.target if self.target else self.status.find_best_enemy_target( ) position = self.status.position next_heading = heading_from_to(position, enemy.current_pos()) # self.turret_controls.aim_left() self.turret_controls.aim_at_heading(next_heading) heading = self.status.turret_heading distance = calculate_distance(position, enemy.current_pos()) angle_allowed = (105 - distance) / 5 if within_degrees(angle_allowed, heading, next_heading): self.turret_controls.fire()
def bfs_search(): truck_x, truck_y = self.depo_coords visited = set() for i in range(self.num_vehicles): truck_visit = set() capacity, distance, truck_path = self.vehicle_map[i] while len(truck_visit) < self.num_customers: next_customer_distance = float("inf") next_customer_index = None for i in range(self.num_customers): customer_idx, customer_demand, customer_x, customer_y = self.customer_info[ i] if i in truck_visit or i in visited: continue if capacity - customer_demand < 0: truck_visit.add(customer_idx) continue customer_distance = calculate_distance( truck_x, truck_y, customer_x, customer_y) if customer_distance < next_customer_distance: #try reversing the order as well next_customer_index = customer_idx next_customer_distance = distance if not next_customer_index or capacity == 0: self.vehicle_map[i] = capacity, distance, truck_path break capacity -= customer_demand distance += customer_distance truck_path.add(next_customer_index) visited.add(next_customer_index) truck_visit.add(next_customer_index) truck_x = customer_x truck_y = customer_y return visited visited = bfs_search() if len(visited) < self.num_customers: return False all_truck_paths = [[] for x in self.num_vehicles] total_distance_traveled = 0 for vehicle_idx, _, distance, truck_path in self.vehicle_map.items( ): all_truck_paths[vehicle_idx] = truck_path total_distance_traveled += distance return all_truck_paths, total_distance_traveled
def print_kpt_L2_distance(model, dataloader, kpt_keys, study_name, evaluate_mode, input_size): kpt_distances = [] if evaluate_mode: validation_textfile = open('logs/rektnet_validation.txt', 'a') for x_batch, y_hm_batch, y_point_batch, _, image_shape in dataloader: x_batch = x_batch.to(device) y_hm_batch = y_hm_batch.to(device) y_point_batch = y_point_batch.to(device) output = model(x_batch) pred_points = output[1]*x_batch.shape[1] pred_points = pred_points.data.cpu().numpy() pred_points *= input_size target_points = y_point_batch*x_batch.shape[1] target_points = target_points.data.cpu().numpy() target_points *= input_size kpt_dis = calculate_distance(target_points, pred_points) ##### for validation knowledge of avg kpt mse vs BB size distribution ##### if evaluate_mode: height,width,_ = image_shape print(width.numpy()[0],height.numpy()[0]) print(kpt_dis) single_img_kpt_dis_sum = sum(kpt_dis) validation_textfile.write(f"{[width.numpy()[0],height.numpy()[0]]}:{single_img_kpt_dis_sum}\n") ########################################################################### kpt_distances.append(kpt_dis) if evaluate_mode: validation_textfile.close() final_stats, total_dist, final_stats_std = calculate_mean_distance(kpt_distances) print(f'Mean distance error of each keypoint is:') for i, kpt_key in enumerate(kpt_keys): print(f'\t{kpt_key}: {final_stats[i]}') print(f'Standard deviation of each keypoint is:') for i, kpt_key in enumerate(kpt_keys): print(f'\t{kpt_key}: {final_stats_std[i]}') print(f'Total distance error is: {total_dist}') ##### updating best result for optuna study ##### result = open("logs/" + study_name + ".txt", "w" ) result.write(str(total_dist)) result.close() ###########################################
def calculate_total_distance(self,solution_flat): total_distance_traveled = 0 _,_,start_x,start_y = self.customer_info[0] for l in solution_flat: if l == -1: _,_,end_x,end_y = self.customer_info[0] else: _,_,end_x,end_y = self.customer_info[l] total_distance_traveled += calculate_distance(start_x, start_y, end_x, end_y) start_x = end_x start_y = end_y return total_distance_traveled
def create_csv_network_with_word2vec(file_name, users_df): with open(file_name, 'w') as file: csv_writer = csv.writer(file) word2vec_our_model = word2vec.get_model( str(SOURCE / 'Embedding/our.corpus.word2vec.model')) word2vec_wiki_model = word2vec.get_model( str(SOURCE / 'Embedding/wiki.he.word2vec.model')) csv_writer.writerow(['Node A', 'Node B', 'Weight']) writers_list = users_df['writer'].tolist() for i, writer_1 in enumerate(writers_list): for j in range(i + 1, len(writers_list)): writer_2 = writers_list[j] writer_1_vector = word2vec.get_post_vector( word2vec_our_model, word2vec_wiki_model, users_df.loc[ users_df['writer'] == writer_1]['text'].item()) writer_2_vector = word2vec.get_post_vector( word2vec_our_model, word2vec_wiki_model, users_df.loc[ users_df['writer'] == writer_2]['text'].item()) csv_writer.writerow([ writer_1, writer_2, utils.calculate_distance(writer_1_vector, writer_2_vector) ])
def main(file, note_file=None, note_starts_file=None, plot_starts=False, plot_fft_indices=[]): # If a note file and/or actual start times are supplied read them in actual_starts = [] if note_starts_file: with open(note_starts_file) as f: for line in f: actual_starts.append(float(line.strip())) actual_notes = [] if note_file: with open(note_file) as f: for line in f: actual_notes.append(line.strip()) song = AudioSegment.from_file(file) song = song.high_pass_filter(80, order=4) starts = predict_note_starts(song, plot_starts, actual_starts) predicted_notes = predict_notes(song, starts, actual_notes, plot_fft_indices) print("") if actual_notes: print("Actual Notes") print(actual_notes) print("Predicted Notes") print(predicted_notes) if actual_notes: lev_distance = calculate_distance(predicted_notes, actual_notes) print("Levenshtein distance: {}/{}".format(lev_distance, len(actual_notes)))
def applyAugmentedComponents(homography, image_base_display, image_test_display): if DEBUG: print("Loading Points of Interest from Database") points_of_interest = db.load_db(DB_POI) if DEBUG: print("Calculating inverse homography") inverse = np.linalg.inv(homography) if DEBUG: print("Calculating important") heigth, width = image_test_display.shape[:2] xCenter = int(round(width / 2.0)) yCenter = int(round(heigth / 2.0)) if DEBUG: print("Placing center") disp.place_center(image_test_display, xCenter, yCenter) if DEBUG: print("Mapping center to original image") xOriginal, yOriginal = utils.map_coordinates(inverse, xCenter, yCenter) closest_point = { 'name': None, 'distance': 9999, 'x': 0, 'y': 0, 'originX': 0, 'originY': 0 } if DEBUG: print("Finding closest interest point") for name, point in points_of_interest.items(): dist = utils.calculate_distance(xOriginal, yOriginal, point['x'], point['y']) pX, pY = utils.map_coordinates(homography, point['x'], point['y']) print(dist, pX, pY, name, width, heigth) if (dist < closest_point['distance'] and pX >= 0 and pX < width and pY >= 0 and pY < heigth): closest_point['name'] = name closest_point['distance'] = dist closest_point['x'] = pX closest_point['y'] = pY closest_point['originX'] = point['x'] closest_point['originY'] = point['y'] if DEBUG: print("Calculationg real distance") if (closest_point['name'] is not None): distance_km = 290 * closest_point['distance'] / 57 if DEBUG: print("Placing closest point") if (closest_point['name'] is not None): if CIRCLE: disp.place_intereset_point(image_test_display, closest_point) else: pyr.calculate_pyramid(homography, image_test_display, closest_point['x'], closest_point['y']) disp.place_distance_and_name( image_test_display, closest_point, distance_km, ) if DEBUG: print("Placing compass") disp.place_compass(inverse, image_test_display, xCenter, yCenter, closest_point['x'], closest_point['y']) if DEBUG: print("Getting images of point") if (closest_point['name'] is not None): disp.create_slideshow(closest_point['name'], distance_km, IMAGE_FOLDER) cv.imshow("Augmented", image_test_display) cv.waitKey(0)
def search_operation(form, db, session): subject = form["subject"] day = form["0-day"] print form print session tutor_list = db.tutors.find({"%s"%subject:True, "%s"%day:True}) tutor_ret = [] # list of tutors to be returned #for each tutor on the new list, give them a score based on secondary features for tutor in tutor_list: print tutor if tutor["complete"] == 1: match_score = 0.0 email = tutor['email'] addresses = [] #find the days for which addresses work try: tutee_loc = form["0-address"] print tutor tutee_address = session[tutee_loc.capitalize() + "_Address"] print tutee_address tutee_start = float(form["0-start_hour"]) + (float(form["0-start_minute"]) * .01) if form["0-start_type"] == "PM": tutee_start += 12 tutee_end = float(form["0-end_hour"]) + (float(form["0-end_minute"]) * .01) if form["0-end_type"] == "PM": tutee_end += 12 best_time = -99999 for d in tutor['days'][day]: distances = [] print d['addresses'] for a in d['addresses']: tutor_address = tutor[a.capitalize() + "_Address"] print tutor_address dist = 0.0 if (tutor_address["zipcode"] == tutee_address["zipcode"]): dist += 4.0 distance = calculate_distance(tutor_address, tutee_address) dist += float(3 - distance) distances.append(dist) print distances score = max(distances) tutor_start = float(d["start_hour"]) + (float(d["start_min"]) *.01) if d["start_type"] == "PM": tutor_start += 12 tutor_end = float(d["end_hour"]) + (float(d["end_min"]) *.01) if d["end_type"] == "PM": tutor_end += 12 if (tutee_end > tutor_start): score += float(tutee_end - tutor_start) * 5 if (tutee_end > tutor_end): score -= float(tutee_end - tutor_end) * 5 if (tutee_start > tutor_start): score -= float(tutee_start - tutor_start) * 5 if (score > best_time): best_time = score match_score += best_time except: pass if tutor['school'] == session['school']: match_score += 1.0 # one point for going to the same school match_score += float(int(tutor['grade']) - int(session['grade']))/4 #An older tutor is preferable update_tutor(tutor['email'], {'match_score':match_score}, db) tutors = db.tutors.find({"match_score": {"$exists":True, "$nin":[0.0]}}) tutors.sort("match_score") tutor_ret = [] for t in tutors: tutor_ret.append(t) update_tutor(t['email'], {'match_score':0.0}, db) #clear the match scores of all return tutor_ret
def shortest_path_a_star(start_node, end_node, input_data_path, output_file): """Main function for A* shortest path `start_node` and `end_node` are ('key', 'value') format. `input_data_path` is a path to directory with nodes and edges layer. `output_file` is a path to the output shape file. """ # Read graph G = nx.Graph(nx.read_shp(input_data_path, strict=False, geom_attrs=True)) # Read and convert to Graph graph_summary(G) # Get start and end node start = get_nodes(G, start_node[0], start_node[1])[0] end = get_nodes(G, end_node[0], end_node[1])[0] print("Start node:") print_node(G, start) print("End node:") print_node(G, end) # Get landmark node landmark_nodes = get_nodes(G, 'landmark', 1) # for landmark_node in landmark_nodes: # print(G.node[landmark_node]['nodeID'], G.node[landmark_node]['landmark']) # Remove landmark that has bigger distance than the starting point to end #TODO: ???? # Get transit node current_node = start unvisited_landmarks = deepcopy(landmark_nodes) path = [start] finish = False while not finish: current_distance_to_end = calculate_distance(current_node, end) # order distance # get distance for all unvisited landmarks from the current node # landmark_distance_dict = {node: calculate_distance(current_node, node) for node in unvisited_landmarks} landmark_distance_dict = {node: calculate_distance(current_node, node) + calculate_distance(node, end) for node in unvisited_landmarks} # sort the distance sorted_landmark_distance_dict = sorted(landmark_distance_dict.items(), key=operator.itemgetter(1)) # No more landmarks, it means finish if len(sorted_landmark_distance_dict) == 0: finish = True for landmark_distance in sorted_landmark_distance_dict: # get landmark to end distance landmark_end_distance = calculate_distance(landmark_distance[0], end) # compare the `current_node to end distance` with the `landmark to end distance` # TODO: ???? if current_distance_to_end < landmark_end_distance or calculate_distance(current_node, landmark_distance[0]) > current_distance_to_end: # the current node distance finish = True continue else: path.append(landmark_distance[0]) current_node = landmark_distance[0] unvisited_landmarks.remove(current_node) finish = False break print('Path') path.append(end) for landmark_node in path: print(G.node[landmark_node]['nodeID'], G.node[landmark_node]['landmark'], landmark_node) # Build full path from the path using A* full_path = [] i = 0 for i in range(len(path) - 1): shortest_landmark_path = nx.astar_path(G, path[i], path[i+1], heuristic=calculate_distance, weight='length') full_path.extend(shortest_landmark_path[:-1]) # Adding end node full_path.append(end) # print('Full path') # for node in full_path: # print(G.node[node]['nodeID'], G.node[node]['landmark'], node) # Clean path from duplicated node, this algorithm work since the path is continue if len(full_path) != len(set(full_path)): unduplicate_path = [] skip = False current_node = None for node in full_path: if not skip: if full_path.count(node) == 1: # Always add node with single occurence unduplicate_path.append(node) else: # Add the first node that has more than one occurence unduplicate_path.append(node) # Mark skip as true for the next nodes skip = True # Store the first duplicate node current_node = node else: if node == current_node: # Found another current_node # Remove the skip flag skip = False current_node = None else: # Always skip until found another current_node pass full_path = unduplicate_path return full_path
def score(enemy): dist_score = calculate_distance(self.position, enemy.current_pos()) / 100 hp_score = enemy.health * 0.1 return dist_score * hp_score
m_earth = 5.972 * 10**24 M_0 = 1.989 * 10**30 astronomical_unit = 1.496 * 10**11 v0 = 3.0 * 10**4 G = 6.67408 * 10**(-11) step = 1.0 mass_coords = (0.0, 0.0) # starting conditions, x-y plane # start at "12 o'clock" x0 = 0.0 y0 = 1.0 * astronomical_unit vx0 = v0 vy0 = 0.0 r0 = calculate_distance((x0, y0), mass_coords) print(r0) # starting conditions x_starting_conds = np.array([x0, vx0]) y_starting_conds = np.array([y0, vy0]) print("x0:", x_starting_conds) print("y0:", y_starting_conds) # first step x_change = runkut_step(r0, vx0, M=M_0, h=step) y_change = runkut_step(r0, vy0, M=M_0, h=step) x_new_conds = x_starting_conds + x_change y_new_conds = y_starting_conds + y_change print("x1:", x_new_conds) print("y1:", y_new_conds)