





"""simple docstring"""





from __future__ import annotations

from math import pi, pow


def       UpperCAmelCase__							(  SCREAMING_SNAKE_CASE					:						Optional[Any]      ) ->    str:







      '''simple docstring'''




      if side_length < 0:
            raise ValueError("""vol_cube() only accepts non-negative values"""      )
      return pow(snake_case__							,						3      )


def       UpperCAmelCase__							(  SCREAMING_SNAKE_CASE					:						Optional[int]							,						SCREAMING_SNAKE_CASE					:						Tuple      ) ->    List[str]:







      '''simple docstring'''




      if height < 0 or radius < 0:
            raise ValueError("""vol_spherical_cap() only accepts non-negative values"""      )
      # Volume is 1/3 pi * height squared * (3 * radius - height)
      return 1 / 3 * pi * pow(snake_case__							,						2      ) * (3 * radius - height)


def       UpperCAmelCase__							(  SCREAMING_SNAKE_CASE					:						Dict							,						SCREAMING_SNAKE_CASE					:						Any							,						SCREAMING_SNAKE_CASE					:						Dict      ) ->    List[Any]:







      '''simple docstring'''




      if radius_a < 0 or radius_a < 0 or centers_distance < 0:
            raise ValueError("""vol_spheres_intersect() only accepts non-negative values"""      )
      if centers_distance == 0:
            return vol_sphere(min(snake_case__							,						snake_case__      )      )

      lowerCAmelCase  						=	(
          (radius_a - radius_a + centers_distance)
          * (radius_a + radius_a - centers_distance)
          / (2 * centers_distance)
      )
      lowerCAmelCase  						=	(
          (radius_a - radius_a + centers_distance)
          * (radius_a + radius_a - centers_distance)
          / (2 * centers_distance)
      )

      return vol_spherical_cap(snake_case__							,						snake_case__      ) + vol_spherical_cap(snake_case__							,						snake_case__      )


def       UpperCAmelCase__							(  SCREAMING_SNAKE_CASE					:						Union[str, Any]							,						SCREAMING_SNAKE_CASE					:						Union[str, Any]							,						SCREAMING_SNAKE_CASE					:						Any      ) ->    Union[str, Any]:







      '''simple docstring'''




      if radius_a <= 0 or radius_a <= 0 or centers_distance < 0:
            raise ValueError(
                """vol_spheres_union() only accepts non-negative values, non-zero radius"""      )

      if centers_distance == 0:
            return vol_sphere(max(snake_case__							,						snake_case__      )      )

      return (
          vol_sphere(snake_case__      )
          + vol_sphere(snake_case__      )
          - vol_spheres_intersect(snake_case__							,						snake_case__							,						snake_case__      )
      )


def       UpperCAmelCase__							(  SCREAMING_SNAKE_CASE					:						Optional[Any]							,						SCREAMING_SNAKE_CASE					:						List[str]							,						SCREAMING_SNAKE_CASE					:						List[str]      ) ->    Optional[Any]:







      '''simple docstring'''




      if width < 0 or height < 0 or length < 0:
            raise ValueError("""vol_cuboid() only accepts non-negative values"""      )
      return float(width * height * length      )


def       UpperCAmelCase__							(  SCREAMING_SNAKE_CASE					:						Any							,						SCREAMING_SNAKE_CASE					:						str      ) ->    Any:







      '''simple docstring'''




      if height < 0 or area_of_base < 0:
            raise ValueError("""vol_cone() only accepts non-negative values"""      )
      return area_of_base * height / 3.0


def       UpperCAmelCase__							(  SCREAMING_SNAKE_CASE					:						Dict							,						SCREAMING_SNAKE_CASE					:						Dict      ) ->    List[str]:







      '''simple docstring'''




      if height < 0 or radius < 0:
            raise ValueError("""vol_right_circ_cone() only accepts non-negative values"""      )
      return pi * pow(snake_case__							,						2      ) * height / 3.0


def       UpperCAmelCase__							(  SCREAMING_SNAKE_CASE					:						Any							,						SCREAMING_SNAKE_CASE					:						Any      ) ->    Optional[int]:







      '''simple docstring'''




      if height < 0 or area_of_base < 0:
            raise ValueError("""vol_prism() only accepts non-negative values"""      )
      return float(area_of_base * height      )


def       UpperCAmelCase__							(  SCREAMING_SNAKE_CASE					:						Any							,						SCREAMING_SNAKE_CASE					:						Union[str, Any]      ) ->    Union[str, Any]:







      '''simple docstring'''




      if height < 0 or area_of_base < 0:
            raise ValueError("""vol_pyramid() only accepts non-negative values"""      )
      return area_of_base * height / 3.0


def       UpperCAmelCase__							(  SCREAMING_SNAKE_CASE					:						Tuple      ) ->    str:







      '''simple docstring'''




      if radius < 0:
            raise ValueError("""vol_sphere() only accepts non-negative values"""      )
      # Volume is 4/3 * pi * radius cubed
      return 4 / 3 * pi * pow(snake_case__							,						3      )


def       UpperCAmelCase__							(  SCREAMING_SNAKE_CASE					:						List[str]      ) ->    Dict:







      '''simple docstring'''




      if radius < 0:
            raise ValueError("""vol_hemisphere() only accepts non-negative values"""      )
      # Volume is radius cubed * pi * 2/3
      return pow(snake_case__							,						3      ) * pi * 2 / 3


def       UpperCAmelCase__							(  SCREAMING_SNAKE_CASE					:						Any							,						SCREAMING_SNAKE_CASE					:						Dict      ) ->    List[Any]:







      '''simple docstring'''




      if height < 0 or radius < 0:
            raise ValueError("""vol_circular_cylinder() only accepts non-negative values"""      )
      # Volume is radius squared * height * pi
      return pow(snake_case__							,						2      ) * height * pi


def       UpperCAmelCase__							(  SCREAMING_SNAKE_CASE					:						str							,						SCREAMING_SNAKE_CASE					:						Any							,						SCREAMING_SNAKE_CASE					:						Dict      ) ->    List[Any]:







      '''simple docstring'''




      if inner_radius < 0 or outer_radius < 0 or height < 0:
            raise ValueError(
                """vol_hollow_circular_cylinder() only accepts non-negative values"""      )
      if outer_radius <= inner_radius:
            raise ValueError("""outer_radius must be greater than inner_radius"""      )
      return pi * (pow(snake_case__							,						2      ) - pow(snake_case__							,						2      )) * height


def       UpperCAmelCase__							(  SCREAMING_SNAKE_CASE					:						Optional[Any]							,						SCREAMING_SNAKE_CASE					:						Optional[Any]							,						SCREAMING_SNAKE_CASE					:						Optional[Any]      ) ->    List[Any]:







      '''simple docstring'''




      if radius_a < 0 or radius_a < 0 or height < 0:
            raise ValueError("""vol_conical_frustum() only accepts non-negative values"""      )
      return (
          1
          / 3
          * pi
          * height
          * (pow(snake_case__							,						2      ) + pow(snake_case__							,						2      ) + radius_a * radius_a)
      )


def       UpperCAmelCase__							(  SCREAMING_SNAKE_CASE					:						Union[str, Any]							,						SCREAMING_SNAKE_CASE					:						str      ) ->    List[Any]:







      '''simple docstring'''




      if torus_radius < 0 or tube_radius < 0:
            raise ValueError("""vol_torus() only accepts non-negative values"""      )
      return 2 * pow(snake_case__							,						2      ) * torus_radius * pow(snake_case__							,						2      )


def       UpperCAmelCase__							(  ) ->    List[Any]:







      '''simple docstring'''




      print("""Volumes:"""      )
      print(F'Cube: {vol_cube(2      ) = }'      )  # = 8
      print(F'Cuboid: {vol_cuboid(2							,						2							,						2      ) = }'      )  # = 8
      print(F'Cone: {vol_cone(2							,						2      ) = }'      )  # ~= 1.33
      print(F'Right Circular Cone: {vol_right_circ_cone(2							,						2      ) = }'      )  # ~= 8.38
      print(F'Prism: {vol_prism(2							,						2      ) = }'      )  # = 4
      print(F'Pyramid: {vol_pyramid(2							,						2      ) = }'      )  # ~= 1.33
      print(F'Sphere: {vol_sphere(2      ) = }'      )  # ~= 33.5
      print(F'Hemisphere: {vol_hemisphere(2      ) = }'      )  # ~= 16.75
      print(F'Circular Cylinder: {vol_circular_cylinder(2							,						2      ) = }'      )  # ~= 25.1
      print(F'Torus: {vol_torus(2							,						2      ) = }'      )  # ~= 157.9
      print(F'Conical Frustum: {vol_conical_frustum(2							,						2							,						4      ) = }'      )  # ~= 58.6
      print(F'Spherical cap: {vol_spherical_cap(1							,						2      ) = }'      )  # ~= 5.24
      print(F'Spheres intersetion: {vol_spheres_intersect(2							,						2							,						1      ) = }'      )  # ~= 21.21
      print(F'Spheres union: {vol_spheres_union(2							,						2							,						1      ) = }'      )  # ~= 45.81
      print(
          F'Hollow Circular Cylinder: {vol_hollow_circular_cylinder(1							,						2							,						3      ) = }'      )  # ~= 28.3


if __name__ == "__main__":
       main()













"""simple docstring"""





from scipy.constants import g


def       UpperCAmelCase__							(  SCREAMING_SNAKE_CASE					:						float							,						SCREAMING_SNAKE_CASE					:						float      ):







      '''simple docstring'''




      if mass < 0:
            # handling of negative values of mass
            raise ValueError("""The mass of a body cannot be negative"""      )
      if height < 0:
            # handling of negative values of height
            raise ValueError("""The height above the ground cannot be negative"""      )
      return mass * g * height


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

       testmod(name="potential_energy")






