code: 
  '''simple docstring'''
  from math import radians as angle_to_radians
  from math import sin
  
  # Acceleration Constant on Earth (unit m/s^2)
  lowercase__						=			9.8_06_65
  
  
  
  
  def       _UpperCamelCase	(					SCREAMING_SNAKE_CASE__   ,					SCREAMING_SNAKE_CASE__ )     ->       None:
  
  
  		'''simple docstring'''
  
  
  		if not isinstance(SCREAMING_SNAKE_CASE__   ,					(int, float) ):
  				raise TypeError('''Invalid velocity. Should be a positive number.''' )
  
  		if not isinstance(SCREAMING_SNAKE_CASE__   ,					(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       _UpperCamelCase	(					SCREAMING_SNAKE_CASE__   ,					SCREAMING_SNAKE_CASE__ )     ->       float:
  
  
  		'''simple docstring'''
  
  
  		check_args(SCREAMING_SNAKE_CASE__   ,					SCREAMING_SNAKE_CASE__ )
  		snake_case     :					Any     =	angle_to_radians(2 * angle )
  		return round(init_velocity**2 * sin(SCREAMING_SNAKE_CASE__ ) / g   ,					2 )
  
  
  
  
  def       _UpperCamelCase	(					SCREAMING_SNAKE_CASE__   ,					SCREAMING_SNAKE_CASE__ )     ->       float:
  
  
  		'''simple docstring'''
  
  
  		check_args(SCREAMING_SNAKE_CASE__   ,					SCREAMING_SNAKE_CASE__ )
  		snake_case     :					Tuple     =	angle_to_radians(SCREAMING_SNAKE_CASE__ )
  		return round(init_velocity**2 * sin(SCREAMING_SNAKE_CASE__ ) ** 2 / (2 * g)   ,					2 )
  
  
  
  
  def       _UpperCamelCase	(					SCREAMING_SNAKE_CASE__   ,					SCREAMING_SNAKE_CASE__ )     ->       float:
  
  
  		'''simple docstring'''
  
  
  		check_args(SCREAMING_SNAKE_CASE__   ,					SCREAMING_SNAKE_CASE__ )
  		snake_case     :					Tuple     =	angle_to_radians(SCREAMING_SNAKE_CASE__ )
  		return round(2 * init_velocity * sin(SCREAMING_SNAKE_CASE__ ) / g   ,					2 )
  
  
  
  
  def       _UpperCamelCase	(					)     ->       None:
  
  
  		'''simple docstring'''
  
  
  		snake_case ,snake_case     :					Union[str, Any]     =	25, 20
  		assert horizontal_distance(SCREAMING_SNAKE_CASE__   ,					SCREAMING_SNAKE_CASE__ ) == 40.97
  		assert max_height(SCREAMING_SNAKE_CASE__   ,					SCREAMING_SNAKE_CASE__ ) == 3.73
  		assert total_time(SCREAMING_SNAKE_CASE__   ,					SCREAMING_SNAKE_CASE__ ) == 1.74
  
  
  if __name__ == "__main__":
  						from doctest import testmod
  
  						testmod()
  
  						# Get input from user
  						lowercase__						=			float(input("Initial Velocity: ").strip())
  
  						# Get input from user
  						lowercase__						=			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]")
  
  
  
style_context: 
  '''simple docstring'''
  import numpy as np
  
  
  
  
  def       _UpperCamelCase	(					SCREAMING_SNAKE_CASE__ )     ->       Optional[Any]:
  
  
  		'''simple docstring'''
  
  
  		snake_case ,snake_case     :					str     =	a.shape
  		snake_case     :					Union[str, Any]     =	min(SCREAMING_SNAKE_CASE__   ,					SCREAMING_SNAKE_CASE__ )
  		snake_case     :					List[Any]     =	np.eye(SCREAMING_SNAKE_CASE__ )
  		snake_case     :					Union[str, Any]     =	a.copy()
  
  		for k in range(t - 1 ):
  				# select a column of modified matrix A':
  				snake_case     :					Union[str, Any]     =	r[k:, [k]]
  				# construct first basis vector
  				snake_case     :					str     =	np.zeros_like(SCREAMING_SNAKE_CASE__ )
  				snake_case     :					List[str]     =	1.0
  				# determine scaling factor
  				snake_case     :					int     =	np.linalg.norm(SCREAMING_SNAKE_CASE__ )
  				# construct vector v for Householder reflection
  				snake_case     :					Optional[int]     =	x + np.sign(x[0] ) * alpha * ea
  				v /= np.linalg.norm(SCREAMING_SNAKE_CASE__ )
  
  				# construct the Householder matrix
  				snake_case     :					Tuple     =	np.eye(m - k ) - 2.0 * v @ v.T
  				# pad with ones and zeros as necessary
  				snake_case     :					int     =	np.block([[np.eye(SCREAMING_SNAKE_CASE__ ), np.zeros((k, m - k) )], [np.zeros((m - k, k) ), q_k]] )
  
  				snake_case     :					int     =	q @ q_k.T
  				snake_case     :					Dict     =	q_k @ r
  
  		return q, r
  
  
  if __name__ == "__main__":
  						import doctest
  
  						doctest.testmod()
  
  
  