chawza · December 14, 2024 04:56 · chawza · Dec 14, 2024
diff --git a/get_distance.py b/get_distance.py
 from math import radians, cos, sin, asin, sqrt
 import numpy as np
 import random

 import time
 from functools import wraps

 import time
 from functools import wraps

 def get_lat():
    return random.uniform(-90, 90)

 def get_long():
    return random.uniform(-180, 180)

 def benchmark(function):
    @wraps(function)
    def wrapper(*args, **kwargs):
        times = []
        res = None
        N_times = 100_000

        for _ in range(100_000):
            start = time.time()
            res = function(*args, **kwargs)
            end = time.time()
            delta = end - start
            times.append(delta)

        total = sum(times)
        avg = total / N_times

        print(f'total: {sum(times):.6f}')
        print(f'avg: {avg:.6f}')

        return res

    return wrapper

 def get_distance(start_point: tuple[float, float], end_point: tuple[float, float]) -> float:
    """
    Calculate the distance between two geographical locations in kilometers.

    :param start_point: A tuple containing the latitude and longitude of the starting point.
    :param end_point: A tuple containing the latitude and longitude of the ending point.
    :return: The distance between the two points in kilometers.
    """
    # Convert degrees to radians
    start_lat = radians(start_point[0])
    start_lon = radians(start_point[1])
    end_lat = radians(end_point[0])
    end_lon = radians(end_point[1])

    # Haversine formula
    dlon = end_lon - start_lon
    dlat = end_lat - start_lat
    a = sin(dlat / 2) ** 2 + cos(start_lat) * cos(end_lat) * sin(dlon / 2) ** 2
    c = 2 * asin(sqrt(a))

    # Calculate distance in kilometers
    earth_radius = 6371
    distance = earth_radius * c

    return distance


 def get_distances_multiple(start_point: tuple[float, float], end_points: list[tuple[float, float]]) -> np.array:
    """
    Calculate the distances between a starting point and multiple ending points in kilometers.

    :param start_point: A tuple containing the latitude and longitude of the starting point.
    :param end_points: A list of tuples containing the latitude and longitude of the ending points.
    :return: An array of distances between the starting point and each ending point in kilometers.
    """
    # Convert degrees to radians
    start_lat = radians(start_point[0])
    start_lon = radians(start_point[1])
    end_lats = np.array([radians(end_point[0]) for end_point in end_points])
    end_lons = np.array([radians(end_point[1]) for end_point in end_points])

    # Haversine formula
    dlon = np.subtract(end_lons, start_lon)
    dlat = np.subtract(end_lats, start_lat)
    a = np.sin(dlat / 2) ** 2 + np.cos(start_lat) * np.cos(end_lats) * np.sin(dlon / 2) ** 2
    c = 2 * np.asin(np.sqrt(a))

    # Calculate distance in kilometers
    earth_radius = 6371
    distances = earth_radius * c

    return distances

 def main():

    points = [
        (get_lat(), get_long())
        for _ in range(1000)
    ]

    target = random.choice(points)


    @benchmark
    def test1():
        result_1 = [get_distance(target, a) for a in points]
        return result_1

    @benchmark
    def test2():
        result_2 = get_distances_multiple(target, points)
        return result_2

    res_1 = test1()
    res_2 = test2()

    comp = res_1 == res_2

    print(f'Same: ', len(list(_ for _ in comp if _ == True)))
    diff_values = [(a, b) for a,b in zip(res_1, res_2) if a != b]
    print(f'Difference: ', len(diff_values))

    for a, b in diff_values:
        print(f'{a:>20} {b:>20}')

 if __name__ == '__main__':
    main()
	from math import radians, cos, sin, asin, sqrt
	import numpy as np
	import random

	import time
	from functools import wraps

	import time
	from functools import wraps

	def get_lat():
	return random.uniform(-90, 90)

	def get_long():
	return random.uniform(-180, 180)

	def benchmark(function):
	@wraps(function)
	def wrapper(args, *kwargs):
	times = []
	res = None
	N_times = 100_000

	for _ in range(100_000):
	start = time.time()
	res = function(args, *kwargs)
	end = time.time()
	delta = end - start
	times.append(delta)

	total = sum(times)
	avg = total / N_times

	print(f'total: {sum(times):.6f}')
	print(f'avg: {avg:.6f}')

	return res

	return wrapper

	def get_distance(start_point: tuple[float, float], end_point: tuple[float, float]) -> float:
	"""
	Calculate the distance between two geographical locations in kilometers.

	:param start_point: A tuple containing the latitude and longitude of the starting point.
	:param end_point: A tuple containing the latitude and longitude of the ending point.
	:return: The distance between the two points in kilometers.
	"""
	# Convert degrees to radians
	start_lat = radians(start_point[0])
	start_lon = radians(start_point[1])
	end_lat = radians(end_point[0])
	end_lon = radians(end_point[1])

	# Haversine formula
	dlon = end_lon - start_lon
	dlat = end_lat - start_lat
	a = sin(dlat / 2) ** 2 + cos(start_lat) * cos(end_lat) * sin(dlon / 2) ** 2
	c = 2 * asin(sqrt(a))

	# Calculate distance in kilometers
	earth_radius = 6371
	distance = earth_radius * c

	return distance


	def get_distances_multiple(start_point: tuple[float, float], end_points: list[tuple[float, float]]) -> np.array:
	"""
	Calculate the distances between a starting point and multiple ending points in kilometers.

	:param start_point: A tuple containing the latitude and longitude of the starting point.
	:param end_points: A list of tuples containing the latitude and longitude of the ending points.
	:return: An array of distances between the starting point and each ending point in kilometers.
	"""
	# Convert degrees to radians
	start_lat = radians(start_point[0])
	start_lon = radians(start_point[1])
	end_lats = np.array([radians(end_point[0]) for end_point in end_points])
	end_lons = np.array([radians(end_point[1]) for end_point in end_points])

	# Haversine formula
	dlon = np.subtract(end_lons, start_lon)
	dlat = np.subtract(end_lats, start_lat)
	a = np.sin(dlat / 2) ** 2 + np.cos(start_lat) * np.cos(end_lats) * np.sin(dlon / 2) ** 2
	c = 2 * np.asin(np.sqrt(a))

	# Calculate distance in kilometers
	earth_radius = 6371
	distances = earth_radius * c

	return distances

	def main():

	points = [
	(get_lat(), get_long())
	for _ in range(1000)
	]

	target = random.choice(points)


	@benchmark
	def test1():
	result_1 = [get_distance(target, a) for a in points]
	return result_1

	@benchmark
	def test2():
	result_2 = get_distances_multiple(target, points)
	return result_2

	res_1 = test1()
	res_2 = test2()

	comp = res_1 == res_2

	print(f'Same: ', len(list(_ for _ in comp if _ == True)))
	diff_values = [(a, b) for a,b in zip(res_1, res_2) if a != b]
	print(f'Difference: ', len(diff_values))

	for a, b in diff_values:
	print(f'{a:>20} {b:>20}')

	if __name__ == '__main__':
	main()