code: 
  
  
  
  from math import radians as angle_to_radians
  from math import sin
  
  # Acceleration Constant on Earth (unit m/s^2)
  __UpperCAmelCase      = 9.8_06_65
  def 	UpperCamelCase			(     snake_case__ :					float ,  snake_case__ :					float			)			->  None:
  
     # Ensure valid instance
     if not isinstance(snake_case__ ,  (int, float)			):
        raise TypeError('Invalid velocity. Should be a positive number.'			)
  
     if not isinstance(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			(     snake_case__ :					float ,  snake_case__ :					float			)			->  float:
     check_args(snake_case__ ,  snake_case__			)
     UpperCamelCase					:						Tuple					=			angle_to_radians(2 * angle			)
     return round(init_velocity**2 * sin(snake_case__			) / g ,  2			)
  def 	UpperCamelCase			(     snake_case__ :					float ,  snake_case__ :					float			)			->  float:
     check_args(snake_case__ ,  snake_case__			)
     UpperCamelCase					:						str					=			angle_to_radians(snake_case__			)
     return round(init_velocity**2 * sin(snake_case__			) ** 2 / (2 * g) ,  2			)
  def 	UpperCamelCase			(     snake_case__ :					float ,  snake_case__ :					float			)			->  float:
     check_args(snake_case__ ,  snake_case__			)
     UpperCamelCase					:						int					=			angle_to_radians(snake_case__			)
     return round(2 * init_velocity * sin(snake_case__			) / g ,  2			)
  def 	UpperCamelCase			(     )			->  None:
     UpperCamelCase			,  UpperCamelCase					:						List[str]					=			25, 20
     assert horizontal_distance(snake_case__ ,  snake_case__			) == 40.97
     assert max_height(snake_case__ ,  snake_case__			) == 3.73
     assert total_time(snake_case__ ,  snake_case__			) == 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]""")
  
  
  
  
style_context: 
  
  
  
  from typing import Optional, Tuple
  
  from ...tokenization_utils_fast import PreTrainedTokenizerFast
  from ...utils import logging
  from .tokenization_openai import OpenAIGPTTokenizer
  
  
  __UpperCAmelCase      = logging.get_logger(__name__)
  
  __UpperCAmelCase      = {'''vocab_file''': '''vocab.json''', '''merges_file''': '''merges.txt''', '''tokenizer_file''': '''tokenizer.json'''}
  
  __UpperCAmelCase      = {
      '''vocab_file''': {'''openai-gpt''': '''https://huggingface.co/openai-gpt/resolve/main/vocab.json'''},
      '''merges_file''': {'''openai-gpt''': '''https://huggingface.co/openai-gpt/resolve/main/merges.txt'''},
      '''tokenizer_file''': {'''openai-gpt''': '''https://huggingface.co/openai-gpt/resolve/main/tokenizer.json'''},
  }
  
  __UpperCAmelCase      = {
      '''openai-gpt''': 512,
  }
  
  
  
  class        lowerCAmelCase_	(						a__							):
         UpperCAmelCase__       :      Union[str, Any]       =						VOCAB_FILES_NAMES
         UpperCAmelCase__       :      int       =						PRETRAINED_VOCAB_FILES_MAP
         UpperCAmelCase__       :      Optional[int]       =						PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
         UpperCAmelCase__       :      Optional[int]       =						["input_ids", "attention_mask"]
         UpperCAmelCase__       :      Tuple       =						OpenAIGPTTokenizer
         def __init__(    self,    SCREAMING_SNAKE_CASE_=None,    SCREAMING_SNAKE_CASE_=None,    SCREAMING_SNAKE_CASE_=None,    SCREAMING_SNAKE_CASE_="<unk>",    **SCREAMING_SNAKE_CASE_ )  ->	List[str]:
            super().__init__(SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_,    tokenizer_file=SCREAMING_SNAKE_CASE_,    unk_token=SCREAMING_SNAKE_CASE_,    **SCREAMING_SNAKE_CASE_ )
         @property
         def       snake_case_ (    self )  ->	Dict:
            return True
  
  
  
  
  
  
         def       snake_case_ (    self,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_ = None )  ->	Tuple[str]:
            UpperCamelCase					:						List[Any]					=			self._tokenizer.model.save(SCREAMING_SNAKE_CASE_,    name=SCREAMING_SNAKE_CASE_ )
            return tuple(SCREAMING_SNAKE_CASE_ )
  
  
  
  