






from math import radians as angle_to_radians
from math import sin

# Acceleration Constant on Earth (unit m/s^2)
a	: int      =				9.8_06_65






def        lowerCamelCase__   (					__lowerCamelCase    :  float						,	__lowerCamelCase    :  float	):

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

  if not isinstance(__lowerCamelCase						,	(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        lowerCamelCase__   (					__lowerCamelCase    :  float						,	__lowerCamelCase    :  float	):
  check_args(__lowerCamelCase						,	__lowerCamelCase	)
  __UpperCAmelCase							:			List[Any]     =						angle_to_radians(2 * angle	)
  return round(init_velocity**2 * sin(__lowerCamelCase	) / g						,	2	)






def        lowerCamelCase__   (					__lowerCamelCase    :  float						,	__lowerCamelCase    :  float	):
  check_args(__lowerCamelCase						,	__lowerCamelCase	)
  __UpperCAmelCase							:			str     =						angle_to_radians(__lowerCamelCase	)
  return round(init_velocity**2 * sin(__lowerCamelCase	) ** 2 / (2 * g)						,	2	)






def        lowerCamelCase__   (					__lowerCamelCase    :  float						,	__lowerCamelCase    :  float	):
  check_args(__lowerCamelCase						,	__lowerCamelCase	)
  __UpperCAmelCase							:			int     =						angle_to_radians(__lowerCamelCase	)
  return round(2 * init_velocity * sin(__lowerCamelCase	) / g						,	2	)






def        lowerCamelCase__   (					):
  __UpperCAmelCase   ,				__UpperCAmelCase							:			Optional[int]     =						25, 20
  assert horizontal_distance(__lowerCamelCase						,	__lowerCamelCase	) == 4_0.9_7
  assert max_height(__lowerCamelCase						,	__lowerCamelCase	) == 3.7_3
  assert total_time(__lowerCamelCase						,	__lowerCamelCase	) == 1.7_4


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

       testmod()

       # Get input from user
       a	: Dict      =				float(input("Initial Velocity: ").strip())

       # Get input from user
       a	: List[Any]      =				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 typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


a	: Union[str, Any]      =				{
    "configuration_mobilenet_v1": [
        "MOBILENET_V1_PRETRAINED_CONFIG_ARCHIVE_MAP",
        "MobileNetV1Config",
        "MobileNetV1OnnxConfig",
    ],
}

try:
       if not is_vision_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       a	: int      =				["MobileNetV1FeatureExtractor"]
       a	: int      =				["MobileNetV1ImageProcessor"]

try:
       if not is_torch_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       a	: int      =				[
           "MOBILENET_V1_PRETRAINED_MODEL_ARCHIVE_LIST",
           "MobileNetV1ForImageClassification",
           "MobileNetV1Model",
           "MobileNetV1PreTrainedModel",
           "load_tf_weights_in_mobilenet_v1",
       ]


if TYPE_CHECKING:
       from .configuration_mobilenet_va import (
           MOBILENET_V1_PRETRAINED_CONFIG_ARCHIVE_MAP,
           MobileNetVaConfig,
           MobileNetVaOnnxConfig,
       )

       try:
              if not is_vision_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .feature_extraction_mobilenet_va import MobileNetVaFeatureExtractor
              from .image_processing_mobilenet_va import MobileNetVaImageProcessor

       try:
              if not is_torch_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_mobilenet_va import (
                  MOBILENET_V1_PRETRAINED_MODEL_ARCHIVE_LIST,
                  MobileNetVaForImageClassification,
                  MobileNetVaModel,
                  MobileNetVaPreTrainedModel,
                  load_tf_weights_in_mobilenet_va,
              )


else:
       import sys

       a	: str      =				_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)


