def _get_heuristic_value(chunk: str, mapper: Dict[str, str],
tf_idf_values: Dict[str,
float], path: List[str]) -> float:
processed_chunk = mapper.get(chunk)
if processed_chunk is None:
raise UndefinedChunkError('Chunk omitted during pre-processing.')
vectorized_chunk = vectorize_sentence(processed_chunk)[0]
avg_tf_idf = sum(tf_idf_values.values()) / len(tf_idf_values)
tf_idf_score = 0
for word in word_tokenize(processed_chunk):
if tf_idf_values.get(word) is None:
tf_idf_score += avg_tf_idf
else:
tf_idf_score += tf_idf_values[word]
distances = []
for prev_chunk in path:
vectorized_prev_chunk = vectorize_sentence(prev_chunk)[0]
distance = find_distance(vectorized_chunk, vectorized_prev_chunk)
distances.append(distance)
heuristic_val = tf_idf_score + min(distances)
return heuristic_val
def guess_key_size(ciphertext):
average_distances = []
for keysize in range(2, 41):
distances_list = []
chunks = [ciphertext[i:i+keysize] for i in range(0, len(ciphertext), keysize)]
while True:
try:
chunk_1 = chunks[0]
chunk_2 = chunks[1]
new_distance = find_distance(chunk_1, chunk_2)
distances_list.append(new_distance/keysize)
del chunks[0]
del chunks[1]
except Exception as e:
break
result = {
'key': keysize,
'avg distance': sum(distances_list) / len(distances_list)
}
average_distances.append(result)
possible_keys = sorted(average_distances, key=lambda x: x['avg distance'])[:1]
return [possible_key["key"] for possible_key in possible_keys]
def create_dataset(self, data_dict, business_names, date_range):
for name in business_names:
business_dict = self.gen_json_data(name)
for date in date_range:
data_dict[date].append(business_dict)
# Add in random availabilities
for date in date_range: # each date key
# each dict in the date key val array
for i in range(len(data_dict[date])):
# each stylist in stylist arr
for j in range(len(data_dict[date][i]["stylists"])):
# iterate the dicts
for key, value in data_dict[date][i]["stylists"][j][
"availability"].items():
data_dict[date][i]["stylists"][j]["availability"][
key] = random.randint(0, 1)
image_urls = self.query_photos(num=20, query='salon')
addresses = self.gen_random_addresses(num=20,
city="San Francisco",
state="CA")
for date in date_range:
for i in range(len(data_dict[date])):
data_dict[date][i]["imageurl"] = image_urls[i]
data_dict[date][i]["location"] = addresses[i]
latlong_coords = address_to_latlong(
data_dict[date][i]["location"])
data_dict[date][i]["distance"] = find_distance(self.location,
latlong_coords,
unit='mi')
self.output_data = data_dict
def basic(collection, k, threshold):
clusters: List[List[Tuple[str, tuple]]] = [[collection[0]]]
for x in collection[1:]:
arg_min_index = arg_min(x, clusters)
if find_distance(
x, clusters[arg_min_index]) > threshold and len(clusters) < k:
clusters.append([x])
else:
clusters[arg_min_index].append(x)
return clusters
def main():
graph = input.get_graph()
# Test Input:
# 1.
print(utils.find_distance(graph, ['A', 'B', 'C']))
# 2.
print(utils.find_distance(graph, ['A', 'D']))
# 3.
print(utils.find_distance(graph, ['A', 'D', 'C']))
# 4.
print(utils.find_distance(graph, ['A', 'E', 'B', 'C', 'D']))
# 5.
print(utils.find_distance(graph, ['A', 'E', 'D']))
# 6.
print(utils.find_routes_max_stops(graph, 'C', 'C', 3))
# 7.
print(utils.find_routes_equal_stops(graph, 'A', 'C', 4))
def process_odom(self, odom_data: Odometry) -> None:
"""
Receive an odometry reading and check if the robot is in the center of the map.
"""
if not self.initialized:
# Set the starting pose when the bot first spawns in
self.starting_pose = odom_data.pose.pose
self.initialized = True
else:
# If the starting pose exists, check whether the bot is within
# a certain radius of the starting position
distance = find_distance(self.starting_pose, odom_data.pose.pose)
if distance < C.CENTER_RADIUS:
self.conditions["IN_CENTER"] = True
else:
self.conditions["IN_CENTER"] = False
self.update_controller_states(self.get_next_state())
def calculate_velocity_odom(self, odom_data: Odometry) -> Twist:
"""
Calculate a velocity for the robot to navigate to the center of the map.
"""
bot_vel = Twist()
# Calculate the angular displacement from the bot's current orientation
# to where its original spawn point was
angle_offset = find_angle_offset(odom_data.pose.pose,
self.starting_pose)
bot_vel.angular.z = C.KP_ANG * angle_offset
if abs(angle_offset) < (np.pi / 4):
# Only move forward if the bot is facing the spawn point
distance = find_distance(odom_data.pose.pose, self.starting_pose)
bot_vel.linear.x = C.KP_LIN * distance
return bot_vel
def two_pass(collection, k, threshold):
clusters: List[List[Tuple[str, tuple]]] = [[collection[0]]]
Y = []
for x in collection[1:]:
arg_min_index = arg_min(x, clusters)
if find_distance(
x, clusters[arg_min_index]) > threshold and len(clusters) < k:
clusters.append([x])
else:
Y.append(x)
for y in Y:
arg_min_index = arg_min(y, clusters)
clusters[arg_min_index].append(y)
return clusters