






from math import radians as angle_to_radians
from math import sin

# Acceleration Constant on Earth (unit m/s^2)
a    =       9.8_06_65
def       a__						(  A		,				A					):

   # Ensure valid instance
   if not isinstance(A		,				(int, float)					):
      raise TypeError("""Invalid velocity. Should be a positive number."""					)

   if not isinstance(A		,				(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__						(  A		,				A					):
   check_args(A		,				A					)
   lowercase__						:	int         = angle_to_radians(2 * angle					)
   return round(init_velocity**2 * sin(A					) / g		,				2					)
def       a__						(  A		,				A					):
   check_args(A		,				A					)
   lowercase__						:	List[str]         = angle_to_radians(A					)
   return round(init_velocity**2 * sin(A					) ** 2 / (2 * g)		,				2					)
def       a__						(  A		,				A					):
   check_args(A		,				A					)
   lowercase__						:	Optional[int]         = angle_to_radians(A					)
   return round(2 * init_velocity * sin(A					) / g		,				2					)
def       a__						(  ):
   lowercase__     ,					lowercase__						:	Tuple         = 25, 20
   assert horizontal_distance(A		,				A					) == 4_0.9_7
   assert max_height(A		,				A					) == 3.7_3
   assert total_time(A		,				A					) == 1.7_4


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]')










from __future__ import annotations

from collections.abc import Iterator
from typing import Any
class        __snake_case:



 def __init__(	self   :   Union[str, Any] ,		UpperCAmelCase__   :   Any	):

    """simple docstring"""






    lowercase__						:	Any         = data
    lowercase__						:	Node | None         = None







 def __str__(	self   :   Dict	):

    """simple docstring"""






    return f'''{self.data}'''
class        __snake_case:



 def __init__(	self   :   Optional[Any]	):

    """simple docstring"""






    lowercase__						:	Node | None         = None
    lowercase__						:	Node | None         = None



 def __iter__(	self   :   Any	):

    """simple docstring"""






    lowercase__						:	Any         = self.front
    while node:
       yield node.data
       lowercase__						:	List[str]         = node.next



 def __len__(	self   :   Union[str, Any]	):

    """simple docstring"""






    return len(tuple(iter(self	)	)	)



 def __str__(	self   :   Optional[Any]	):

    """simple docstring"""






    return " <- ".join(str(UpperCAmelCase__	) for item in self	)



 def 						UpperCAmelCase    (	self   :   List[str]	):

    """simple docstring"""






    return len(self	) == 0



 def 						UpperCAmelCase    (	self   :   Optional[int] ,		UpperCAmelCase__   :   Any	):

    """simple docstring"""






    lowercase__						:	List[str]         = Node(UpperCAmelCase__	)
    if self.is_empty():
       lowercase__						:	List[Any]         = node
    else:
       assert isinstance(self.rear ,		UpperCAmelCase__	)
       lowercase__						:	Any         = node
       lowercase__						:	Union[str, Any]         = node



 def 						UpperCAmelCase    (	self   :   List[Any]	):

    """simple docstring"""






    if self.is_empty():
       raise IndexError("""dequeue from empty queue"""	)
    assert isinstance(self.front ,		UpperCAmelCase__	)
    lowercase__						:	Tuple         = self.front
    lowercase__						:	Any         = self.front.next
    if self.front is None:
       lowercase__						:	List[Any]         = None
    return node.data







 def 						UpperCAmelCase    (	self   :   Optional[Any]	):

    """simple docstring"""






    lowercase__						:	List[Any]         = None


if __name__ == "__main__":
 from doctest import testmod

 testmod()


