"""simple docstring"""

from __future__ import annotations

from math import pi, pow


def    lowerCAmelCase			(__UpperCamelCase							:    int | float			):
							"""simple docstring"""


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


def    lowerCAmelCase			(__UpperCamelCase							:    float							,					__UpperCamelCase							:    float			):
							"""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(__UpperCamelCase							,					2			) * (3 * radius - height)


def    lowerCAmelCase			(__UpperCamelCase							:    float							,					__UpperCamelCase							:    float							,					__UpperCamelCase							:    float			):
							"""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(__UpperCamelCase							,					__UpperCamelCase			)			)

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

							return vol_spherical_cap(__UpperCamelCase							,					__UpperCamelCase			) + vol_spherical_cap(__UpperCamelCase							,					__UpperCamelCase			)


def    lowerCAmelCase			(__UpperCamelCase							:    float							,					__UpperCamelCase							:    float							,					__UpperCamelCase							:    float			):
							"""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(__UpperCamelCase							,					__UpperCamelCase			)			)

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


def    lowerCAmelCase			(__UpperCamelCase							:    float							,					__UpperCamelCase							:    float							,					__UpperCamelCase							:    float			):
							"""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    lowerCAmelCase			(__UpperCamelCase							:    float							,					__UpperCamelCase							:    float			):
							"""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    lowerCAmelCase			(__UpperCamelCase							:    float							,					__UpperCamelCase							:    float			):
							"""simple docstring"""


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


def    lowerCAmelCase			(__UpperCamelCase							:    float							,					__UpperCamelCase							:    float			):
							"""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    lowerCAmelCase			(__UpperCamelCase							:    float							,					__UpperCamelCase							:    float			):
							"""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    lowerCAmelCase			(__UpperCamelCase							:    float			):
							"""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(__UpperCamelCase							,					3			)


def    lowerCAmelCase			(__UpperCamelCase							:    float			):
							"""simple docstring"""


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


def    lowerCAmelCase			(__UpperCamelCase							:    float							,					__UpperCamelCase							:    float			):
							"""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(__UpperCamelCase							,					2			) * height * pi


def    lowerCAmelCase			(__UpperCamelCase							:    float							,					__UpperCamelCase							:    float							,					__UpperCamelCase							:    float			):
							"""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(__UpperCamelCase							,					2			) - pow(__UpperCamelCase							,					2			)) * height


def    lowerCAmelCase			(__UpperCamelCase							:    float							,					__UpperCamelCase							:    float							,					__UpperCamelCase							:    float			):
							"""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(__UpperCamelCase							,					2			) + pow(__UpperCamelCase							,					2			) + radius_a * radius_a)
							)


def    lowerCAmelCase			(__UpperCamelCase							:    float							,					__UpperCamelCase							:    float			):
							"""simple docstring"""


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


def    lowerCAmelCase			():
							"""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"""

def    lowerCAmelCase			(__UpperCamelCase							:    list							,					__UpperCamelCase							:    int			):
							"""simple docstring"""


							for index, item in enumerate(__UpperCamelCase			):
														if item == target:
																					return index
							return -1


def    lowerCAmelCase			(__UpperCamelCase							:    list							,					__UpperCamelCase							:    int							,					__UpperCamelCase							:    int							,					__UpperCamelCase							:    int			):
							"""simple docstring"""


							if not (0 <= high < len(__UpperCamelCase			) and 0 <= low < len(__UpperCamelCase			)):
														raise Exception('''Invalid upper or lower bound!'''			)
							if high < low:
														return -1
							if sequence[low] == target:
														return low
							if sequence[high] == target:
														return high
							return rec_linear_search(__UpperCamelCase							,					low + 1							,					high - 1							,					__UpperCamelCase			)


if __name__ == "__main__":
				__lowercase    =				input('''Enter numbers separated by comma:\n''').strip()
				__lowercase    =				[int(item.strip()) for item in user_input.split(''',''')]

				__lowercase    =				int(input('''Enter a single number to be found in the list:\n''').strip())
				__lowercase    =				linear_search(sequence, target)
				if result != -1:
								print(f'''linear_search({sequence}, {target}) = {result}''')
				else:
								print(f'''{target} was not found in {sequence}''')



