from math import radians as angle_to_radians
from math import sin

# Acceleration Constant on Earth (unit m/s^2)
UpperCamelCase    				=		9.80_665

def      lowercase_							(     _lowerCamelCase				:			float						,      _lowerCamelCase				:			float):



    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      lowercase_							(     _lowerCamelCase				:			float						,      _lowerCamelCase				:			float):
    check_args(a__						,      a__)
    lowercase__					:  Optional[int]          =							angle_to_radians(2 * angle)
    return round(init_velocity**2 * sin(a__) / g						,      2)

def      lowercase_							(     _lowerCamelCase				:			float						,      _lowerCamelCase				:			float):
    check_args(a__						,      a__)
    lowercase__					:  Union[str, Any]          =							angle_to_radians(a__)
    return round(init_velocity**2 * sin(a__) ** 2 / (2 * g)						,      2)

def      lowercase_							(     _lowerCamelCase				:			float						,      _lowerCamelCase				:			float):
    check_args(a__						,      a__)
    lowercase__					:  Union[str, Any]          =							angle_to_radians(a__)
    return round(2 * init_velocity * sin(a__) / g						,      2)

def      lowercase_							(     ):
    lowercase__   ,  lowercase__					:  Optional[int]          =							25, 20
    assert horizontal_distance(a__						,      a__) == 40.97
    assert max_height(a__						,      a__) == 3.73
    assert total_time(a__						,      a__) == 1.74


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

      testmod()

      # Get input from user
      UpperCamelCase    				=		float(input('''Initial Velocity: ''').strip())

      # Get input from user
      UpperCamelCase    				=		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]")






"""simple docstring"""

import enum
import inspect
import warnings
from functools import wraps
from typing import Callable, Optional

from .logging import get_logger


a__			:						Optional[int]							=			set()
a__			:						str							=			get_logger(__name__)





def 					__UpperCamelCase (     a__:			Optional[str] = None      )					->      Dict:




					"""simple docstring"""



					def decorator(a__:			Callable      ):
										global _emitted_deprecation_warnings

										if inspect.isclass(a__      ):
															__lowercase        =      deprecated_class_or_function.__init__
															__lowercase        =      deprecated_class_or_function.__name__
										else:
															__lowercase        =      deprecated_class_or_function
															__lowercase        =      deprecated_function.__name__
															# Support deprecating __init__ class method: class name instead
															__lowercase        =      name if name != '''__init__''' else deprecated_function.__qualname__.split('''.'''      )[-2]

										__lowercase        =      (
										    f'''{name} is deprecated and will be removed in the next major version of datasets.''' + f''' {help_message}'''
										    if help_message
										    else ''''''
										)

										@wraps(a__      )
										def wrapper(*a__:			int			,						**a__:			int      ):
															__lowercase        =      hash(a__      )
															if func_hash not in _emitted_deprecation_warnings:
																				warnings.warn(a__			,						category=a__			,						stacklevel=2      )
																				_emitted_deprecation_warnings.add(a__      )
															return deprecated_function(*a__			,						**a__      )

										__lowercase        =      '''deprecated'''

										if inspect.isclass(a__      ):
															__lowercase        =      wrapper
															return deprecated_class_or_function
										else:
															return wrapper

					return decorator


class       _snake_case  (    enum.EnumMeta							):







						def __getattribute__(cls  ,				UpperCAmelCase_				)      ->    int:
											__lowercase        =      super().__getattribute__(UpperCAmelCase_				)
											if isinstance(UpperCAmelCase_  ,				enum.Enum				) and obj._on_access:
																obj._on_access()
											return obj







						def __getitem__(cls  ,				UpperCAmelCase_				)      ->    Union[str, Any]:
											__lowercase        =      super().__getitem__(UpperCAmelCase_				)
											if member._on_access:
																member._on_access()
											return member







						def __call__(cls  ,				UpperCAmelCase_  ,				UpperCAmelCase_=None  ,				*, UpperCAmelCase_=None  ,				UpperCAmelCase_=None  ,				UpperCAmelCase_=None  ,				UpperCAmelCase_=1				)      ->    List[Any]:
											__lowercase        =      super().__call__(UpperCAmelCase_  ,				UpperCAmelCase_  ,				module=UpperCAmelCase_  ,				qualname=UpperCAmelCase_  ,				type=UpperCAmelCase_  ,				start=UpperCAmelCase_				)
											if isinstance(UpperCAmelCase_  ,				enum.Enum				) and obj._on_access:
																obj._on_access()
											return obj



class       _snake_case  (    enum.Enum    ,      metaclass=UpperCamelCase							):







						def __new__(cls  ,				UpperCAmelCase_				)      ->    Optional[int]:
											__lowercase        =      object.__new__(cls				)
											__lowercase        =      value
											__lowercase        =      member.deprecate
											return member







						@property
						def 							_UpperCamelCase     (self				)      ->    Dict:
											return ""







						def 							_UpperCamelCase     (self				)      ->    Optional[Any]:
											__lowercase        =      f''' {self.help_message}''' if self.help_message else ''''''
											warnings.warn(
											    f'''\'{self.__objclass__.__name__}\' is deprecated and will be removed in the next major version of datasets.'''
											    + help_message  ,				UpperCAmelCase_  ,				stacklevel=3  ,				)


