code: 
  
  
  
  
  
  
  """simple docstring"""
  
  
  
  
  
  
  import unittest
  
  from transformers.image_processing_utils import get_size_dict
  class 						__lowerCAmelCase   (			unittest.TestCase       ):
  
  
  
  
  
  
  
    '''simple docstring'''
  
  
    def 					UpperCamelCase__   (      self:		str					):
       # Test a dict with the wrong keys raises an error
       UpperCamelCase_     ={"wrong_key": 224}
       with self.assertRaises(UpperCamelCase_					):
          get_size_dict(UpperCamelCase_					)
  
       UpperCamelCase_     ={"height": 224}
       with self.assertRaises(UpperCamelCase_					):
          get_size_dict(UpperCamelCase_					)
  
       UpperCamelCase_     ={"width": 224, "shortest_edge": 224}
       with self.assertRaises(UpperCamelCase_					):
          get_size_dict(UpperCamelCase_					)
  
       # Test a dict with the correct keys is returned as is
       UpperCamelCase_     ={"height": 224, "width": 224}
       UpperCamelCase_     =get_size_dict(UpperCamelCase_					)
       self.assertEqual(UpperCamelCase_				,			UpperCamelCase_					)
  
       UpperCamelCase_     ={"shortest_edge": 224}
       UpperCamelCase_     =get_size_dict(UpperCamelCase_					)
       self.assertEqual(UpperCamelCase_				,			{"shortest_edge": 224}					)
  
       UpperCamelCase_     ={"longest_edge": 224, "shortest_edge": 224}
       UpperCamelCase_     =get_size_dict(UpperCamelCase_					)
       self.assertEqual(UpperCamelCase_				,			{"longest_edge": 224, "shortest_edge": 224}					)
  
       # Test a single int value which  represents (size, size)
       UpperCamelCase_     =get_size_dict(224					)
       self.assertEqual(UpperCamelCase_				,			{"height": 224, "width": 224}					)
  
       # Test a single int value which represents the shortest edge
       UpperCamelCase_     =get_size_dict(224				,			default_to_square=UpperCamelCase_					)
       self.assertEqual(UpperCamelCase_				,			{"shortest_edge": 224}					)
  
       # Test a tuple of ints which represents (height, width)
       UpperCamelCase_     =get_size_dict((150, 200)					)
       self.assertEqual(UpperCamelCase_				,			{"height": 150, "width": 200}					)
  
       # Test a tuple of ints which represents (width, height)
       UpperCamelCase_     =get_size_dict((150, 200)				,			height_width_order=UpperCamelCase_					)
       self.assertEqual(UpperCamelCase_				,			{"height": 200, "width": 150}					)
  
       # Test an int representing the shortest edge and max_size which represents the longest edge
       UpperCamelCase_     =get_size_dict(224				,			max_size=256				,			default_to_square=UpperCamelCase_					)
       self.assertEqual(UpperCamelCase_				,			{"shortest_edge": 224, "longest_edge": 256}					)
  
       # Test int with default_to_square=True and max_size fails
       with self.assertRaises(UpperCamelCase_					):
          get_size_dict(224				,			max_size=256				,			default_to_square=UpperCamelCase_					)
  
style_context: 
  
  
  
  
  
  
  """simple docstring"""
  
  
  
  
  
  
  from math import radians as angle_to_radians
  from math import sin
  
  # Acceleration Constant on Earth (unit m/s^2)
  A_			  =    9.80665
  
  
  
  
  def 						_UpperCamelCase			(  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 						_UpperCamelCase			(  A    ,       A			):
     check_args(A    ,       A			)
     UpperCamelCase_     =angle_to_radians(2 * angle			)
     return round(init_velocity**2 * sin(A			) / g    ,       2			)
  
  
  
  
  def 						_UpperCamelCase			(  A    ,       A			):
     check_args(A    ,       A			)
     UpperCamelCase_     =angle_to_radians(A			)
     return round(init_velocity**2 * sin(A			) ** 2 / (2 * g)    ,       2			)
  
  
  
  
  def 						_UpperCamelCase			(  A    ,       A			):
     check_args(A    ,       A			)
     UpperCamelCase_     =angle_to_radians(A			)
     return round(2 * init_velocity * sin(A			) / g    ,       2			)
  
  
  
  
  def 						_UpperCamelCase			(  ):
     UpperCamelCase_    ,							UpperCamelCase_     =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
      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]''')
  