

from __future__ import annotations

from math import pi, pow

def 				A_					(							a					):

      """simple docstring"""



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

def 				A_					(							a   ,				a					):

      """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(a   ,				2					) * (3 * radius - height)

def 				A_					(							a   ,				a   ,				a					):

      """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(a   ,				a					)					)

      SCREAMING_SNAKE_CASE_			:					List[Any]          =       (
          (radius_a - radius_a + centers_distance)
          * (radius_a + radius_a - centers_distance)
          / (2 * centers_distance)
      )
      SCREAMING_SNAKE_CASE_			:					Optional[int]          =       (
          (radius_a - radius_a + centers_distance)
          * (radius_a + radius_a - centers_distance)
          / (2 * centers_distance)
      )

      return vol_spherical_cap(a   ,				a					) + vol_spherical_cap(a   ,				a					)

def 				A_					(							a   ,				a   ,				a					):

      """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(a   ,				a					)					)

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

def 				A_					(							a   ,				a   ,				a					):

      """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 				A_					(							a   ,				a					):

      """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 				A_					(							a   ,				a					):

      """simple docstring"""



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

def 				A_					(							a   ,				a					):

      """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 				A_					(							a   ,				a					):

      """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 				A_					(							a					):

      """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(a   ,				3					)

def 				A_					(							a					):

      """simple docstring"""



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

def 				A_					(							a   ,				a					):

      """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(a   ,				2					) * height * pi

def 				A_					(							a   ,				a   ,				a					):

      """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(a   ,				2					) - pow(a   ,				2					)) * height

def 				A_					(							a   ,				a   ,				a					):

      """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(a   ,				2					) + pow(a   ,				2					) + radius_a * radius_a)
      )

def 				A_					(							a   ,				a					):

      """simple docstring"""



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

def 				A_					(							):

      """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()









from math import sqrt

def 				A_					(							a					):

      """simple docstring"""



      SCREAMING_SNAKE_CASE_			:					List[str]          =       [1]
      for i in range(2   ,				int(sqrt(a					)					) + 1   ,				1					):
            if number % i == 0:
                  values.append(a					)
                  if int(number // i					) != i:
                        values.append(int(number // i					)					)
      return sorted(a					)

def 				A_					(							a					):

      """simple docstring"""



      return sum(factors(a					)					) > n

def 				A_					(							a					):

      """simple docstring"""



      SCREAMING_SNAKE_CASE_			:					Union[str, Any]          =       factors(a					)
      SCREAMING_SNAKE_CASE_			:					Optional[int]          =       len(a					)
      SCREAMING_SNAKE_CASE_			:					Optional[int]          =       [[0 for i in range(number + 1					)] for j in range(r + 1					)]
      for i in range(r + 1					):
            SCREAMING_SNAKE_CASE_			:					Optional[int]          =       True

      for i in range(1   ,				number + 1					):
            SCREAMING_SNAKE_CASE_			:					Optional[Any]          =       False

      for i in range(1   ,				r + 1					):
            for j in range(1   ,				number + 1					):
                  if j < values[i - 1]:
                        SCREAMING_SNAKE_CASE_			:					Dict          =       subset[i - 1][j]
                  else:
                        SCREAMING_SNAKE_CASE_			:					List[str]          =       subset[i - 1][j] or subset[i - 1][j - values[i - 1]]

      return subset[r][number] != 0

def 				A_					(							a					):

      """simple docstring"""



      return abundant(a					) and not semi_perfect(a					)


if __name__ == "__main__":
    import doctest

    doctest.testmod(verbose=True)
    for number in (69, 70, 71):
        print(F'{number} is {"" if weird(number) else "not "}weird.')






