code: 
  
  
  
  from __future__ import annotations
  
  
  
  
  
  
  class 	lowercase		:
  
  
  
  
  
  
  	"""simple docstring"""
  
  
  	def __init__(			self			:		Optional[Any]		,						__UpperCAmelCase			:		int  )    ->				None:
  							UpperCAmelCase_=     vertices
  							UpperCAmelCase_=     [[0] * vertices for _ in range(__UpperCAmelCase  )]
  
  
  
  
  	def 						_SCREAMING_SNAKE_CASE	(			self			:		Tuple		,						__UpperCAmelCase			:		list[int]  )    ->				None:
  							print("""Vertex \t Distance from Source"""  )
  							for vertex in range(self.vertices  ):
  													print(__UpperCAmelCase		,						"""\t\t"""		,						distances_from_source[vertex]  )
  
  
  
  
  	def 						_SCREAMING_SNAKE_CASE	(			self			:		List[Any]		,						__UpperCAmelCase			:		list[int]		,						__UpperCAmelCase			:		list[bool]  )    ->				int:
  							UpperCAmelCase_=     1E7
  							UpperCAmelCase_=     0
  
  							# Search not nearest vertex not in the shortest path tree
  							for vertex in range(self.vertices  ):
  													if distances_from_source[vertex] < minimum and visited[vertex] is False:
  																			UpperCAmelCase_=     distances_from_source[vertex]
  																			UpperCAmelCase_=     vertex
  							return min_index
  
  
  
  
  	def 						_SCREAMING_SNAKE_CASE	(			self			:		List[str]		,						__UpperCAmelCase			:		int  )    ->				None:
  							UpperCAmelCase_=     [int(1E7  )] * self.vertices  # distances from the source
  							UpperCAmelCase_=     0
  							UpperCAmelCase_=     [False] * self.vertices
  
  							for _ in range(self.vertices  ):
  													UpperCAmelCase_=     self.minimum_distance(__UpperCAmelCase		,						__UpperCAmelCase  )
  													UpperCAmelCase_=     True
  
  													# Update dist value of the adjacent vertices
  													# of the picked vertex only if the current
  													# distance is greater than new distance and
  													# the vertex in not in the shortest path tree
  													for v in range(self.vertices  ):
  																			if (
  																			    self.graph[u][v] > 0
  																			    and visited[v] is False
  																			    and distances[v] > distances[u] + self.graph[u][v]
  																			):
  																									UpperCAmelCase_=     distances[u] + self.graph[u][v]
  
  							self.print_solution(__UpperCAmelCase  )
  
  
  if __name__ == "__main__":
  	__A       					=		Graph(9)
  	__A       					=		[
  	    [0, 4, 0, 0, 0, 0, 0, 8, 0],
  	    [4, 0, 8, 0, 0, 0, 0, 11, 0],
  	    [0, 8, 0, 7, 0, 4, 0, 0, 2],
  	    [0, 0, 7, 0, 9, 14, 0, 0, 0],
  	    [0, 0, 0, 9, 0, 10, 0, 0, 0],
  	    [0, 0, 4, 14, 10, 0, 2, 0, 0],
  	    [0, 0, 0, 0, 0, 2, 0, 1, 6],
  	    [8, 11, 0, 0, 0, 0, 1, 0, 7],
  	    [0, 0, 2, 0, 0, 0, 6, 7, 0],
  	]
  	graph.dijkstra(0)
  
  
  
  
  
style_context: 
  
  
  
  from math import radians as angle_to_radians
  from math import sin
  
  # Acceleration Constant on Earth (unit m/s^2)
  __A       					=		9.8_0_6_6_5
  
  
  
  def  __a  (					lowerCAmelCase_     :      float    ,lowerCAmelCase_     :      float       )   ->				None:
  
  
  
  
  
  
  						'''simple docstring'''
  
  
  
  						if not isinstance(lowerCAmelCase_    ,(int, float)       ):
  												raise TypeError("""Invalid velocity. Should be a positive number."""       )
  
  						if not isinstance(lowerCAmelCase_    ,(int, float)       ):
  												raise TypeError("""Invalid angle. Range is 1-90 degrees."""       )
  
  						# Ensure valid angle
  						if angle > 90 or angle < 1:
  												raise ValueError("""Invalid angle. Range is 1-90 degrees."""       )
  
  						# Ensure valid velocity
  						if init_velocity < 0:
  												raise ValueError("""Invalid velocity. Should be a positive number."""       )
  
  
  
  def  __a  (					lowerCAmelCase_     :      float    ,lowerCAmelCase_     :      float       )   ->				float:
  
  
  
  
  
  
  						'''simple docstring'''
  
  
  
  						check_args(lowerCAmelCase_    ,lowerCAmelCase_       )
  						UpperCAmelCase_=     angle_to_radians(2 * angle       )
  						return round(init_velocity**2 * sin(lowerCAmelCase_       ) / g    ,2       )
  
  
  
  def  __a  (					lowerCAmelCase_     :      float    ,lowerCAmelCase_     :      float       )   ->				float:
  
  
  
  
  
  
  						'''simple docstring'''
  
  
  
  						check_args(lowerCAmelCase_    ,lowerCAmelCase_       )
  						UpperCAmelCase_=     angle_to_radians(lowerCAmelCase_       )
  						return round(init_velocity**2 * sin(lowerCAmelCase_       ) ** 2 / (2 * g)    ,2       )
  
  
  
  def  __a  (					lowerCAmelCase_     :      float    ,lowerCAmelCase_     :      float       )   ->				float:
  
  
  
  
  
  
  						'''simple docstring'''
  
  
  
  						check_args(lowerCAmelCase_    ,lowerCAmelCase_       )
  						UpperCAmelCase_=     angle_to_radians(lowerCAmelCase_       )
  						return round(2 * init_velocity * sin(lowerCAmelCase_       ) / g    ,2       )
  
  
  
  def  __a  (					)   ->				None:
  
  
  
  
  
  
  						'''simple docstring'''
  
  
  
  						UpperCAmelCase_,     UpperCAmelCase_=     25, 20
  						assert horizontal_distance(lowerCAmelCase_    ,lowerCAmelCase_       ) == 40.97
  						assert max_height(lowerCAmelCase_    ,lowerCAmelCase_       ) == 3.73
  						assert total_time(lowerCAmelCase_    ,lowerCAmelCase_       ) == 1.74
  
  
  if __name__ == "__main__":
  	from doctest import testmod
  
  	testmod()
  
  	# Get input from user
  	__A       					=		float(input('''Initial Velocity: ''').strip())
  
  	# Get input from user
  	__A       					=		float(input('''angle: ''').strip())
  
  	# Print results
  	print()
  	print('''Results: ''')
  	print(f'Horizontal Distance: {horizontal_distance(init_vel, angle)!s} [m]')
  	print(f'Maximum Height: {max_height(init_vel, angle)!s} [m]')
  	print(f'Total Time: {total_time(init_vel, angle)!s} [s]')
  
  
  
  
  