from math import pi, sqrt, tan





def  _lowerCamelCase					(   a_				: float):
			if side_length < 0:
						raise ValueError('''surface_area_cube() only accepts non-negative values''')
			return 6 * side_length**2





def  _lowerCamelCase					(   a_				: float						,			a_				: float						,			a_				: float):
			if length < 0 or breadth < 0 or height < 0:
						raise ValueError('''surface_area_cuboid() only accepts non-negative values''')
			return 2 * ((length * breadth) + (breadth * height) + (length * height))





def  _lowerCamelCase					(   a_				: float):
			if radius < 0:
						raise ValueError('''surface_area_sphere() only accepts non-negative values''')
			return 4 * pi * radius**2





def  _lowerCamelCase					(   a_				: float):
			if radius < 0:
						raise ValueError('''surface_area_hemisphere() only accepts non-negative values''')
			return 3 * pi * radius**2





def  _lowerCamelCase					(   a_				: float						,			a_				: float):
			if radius < 0 or height < 0:
						raise ValueError('''surface_area_cone() only accepts non-negative values''')
			return pi * radius * (radius + (height**2 + radius**2) ** 0.5)





def  _lowerCamelCase					(   a_				: float						,			a_				: float						,			a_				: float):
			if radius_a < 0 or radius_a < 0 or height < 0:
						raise ValueError(
						    '''surface_area_conical_frustum() only accepts non-negative values''')
			lowerCamelCase						:List[str]						  =     (height**2 + (radius_a - radius_a) ** 2) ** 0.5
			return pi * ((slant_height * (radius_a + radius_a)) + radius_a**2 + radius_a**2)





def  _lowerCamelCase					(   a_				: float						,			a_				: float):
			if radius < 0 or height < 0:
						raise ValueError('''surface_area_cylinder() only accepts non-negative values''')
			return 2 * pi * radius * (height + radius)





def  _lowerCamelCase					(   a_				: float						,			a_				: float):
			if torus_radius < 0 or tube_radius < 0:
						raise ValueError('''surface_area_torus() only accepts non-negative values''')
			if torus_radius < tube_radius:
						raise ValueError(
						    '''surface_area_torus() does not support spindle or self intersecting tori''')
			return 4 * pow(a_						,			2) * torus_radius * tube_radius





def  _lowerCamelCase					(   a_				: float						,			a_				: float):
			if length < 0 or width < 0:
						raise ValueError('''area_rectangle() only accepts non-negative values''')
			return length * width





def  _lowerCamelCase					(   a_				: float):
			if side_length < 0:
						raise ValueError('''area_square() only accepts non-negative values''')
			return side_length**2





def  _lowerCamelCase					(   a_				: float						,			a_				: float):
			if base < 0 or height < 0:
						raise ValueError('''area_triangle() only accepts non-negative values''')
			return (base * height) / 2





def  _lowerCamelCase					(   a_				: float						,			a_				: float						,			a_				: float):
			if sidea < 0 or sidea < 0 or sidea < 0:
						raise ValueError('''area_triangle_three_sides() only accepts non-negative values''')
			elif sidea + sidea < sidea or sidea + sidea < sidea or sidea + sidea < sidea:
						raise ValueError('''Given three sides do not form a triangle''')
			lowerCamelCase						:str						  =     (sidea + sidea + sidea) / 2
			lowerCamelCase						:Union[str, Any]						  =     sqrt(
			    semi_perimeter
			    * (semi_perimeter - sidea)
			    * (semi_perimeter - sidea)
			    * (semi_perimeter - sidea))
			return area





def  _lowerCamelCase					(   a_				: float						,			a_				: float):
			if base < 0 or height < 0:
						raise ValueError('''area_parallelogram() only accepts non-negative values''')
			return base * height





def  _lowerCamelCase					(   a_				: float						,			a_				: float						,			a_				: float):
			if basea < 0 or basea < 0 or height < 0:
						raise ValueError('''area_trapezium() only accepts non-negative values''')
			return 1 / 2 * (basea + basea) * height





def  _lowerCamelCase					(   a_				: float):
			if radius < 0:
						raise ValueError('''area_circle() only accepts non-negative values''')
			return pi * radius**2





def  _lowerCamelCase					(   a_				: float						,			a_				: float):
			if radius_x < 0 or radius_y < 0:
						raise ValueError('''area_ellipse() only accepts non-negative values''')
			return pi * radius_x * radius_y





def  _lowerCamelCase					(   a_				: float						,			a_				: float):
			if diagonal_a < 0 or diagonal_a < 0:
						raise ValueError('''area_rhombus() only accepts non-negative values''')
			return 1 / 2 * diagonal_a * diagonal_a





def  _lowerCamelCase					(   a_				: int						,			a_				: float):
			if not isinstance(a_						,			a_) or sides < 3:
						raise ValueError(
						    '''area_reg_polygon() only accepts integers greater than or \
equal to three as number of sides''')
			elif length < 0:
						raise ValueError(
						    '''area_reg_polygon() only accepts non-negative values as \
length of a side''')
			return (sides * length**2) / (4 * tan(pi / sides))
			return (sides * length**2) / (4 * tan(pi / sides))


if __name__ == "__main__":
			import doctest

			doctest.testmod(verbose=True)  # verbose so we can see methods missing tests

			print("""[DEMO] Areas of various geometric shapes: \n""")
			print(F'Rectangle: {area_rectangle(10, 20) = }')
			print(F'Square: {area_square(10) = }')
			print(F'Triangle: {area_triangle(10, 10) = }')
			print(F'Triangle: {area_triangle_three_sides(5, 12, 13) = }')
			print(F'Parallelogram: {area_parallelogram(10, 20) = }')
			print(F'Rhombus: {area_rhombus(10, 20) = }')
			print(F'Trapezium: {area_trapezium(10, 20, 30) = }')
			print(F'Circle: {area_circle(20) = }')
			print(F'Ellipse: {area_ellipse(10, 20) = }')
			print("""\nSurface Areas of various geometric shapes: \n""")
			print(F'Cube: {surface_area_cube(20) = }')
			print(F'Cuboid: {surface_area_cuboid(10, 20, 30) = }')
			print(F'Sphere: {surface_area_sphere(20) = }')
			print(F'Hemisphere: {surface_area_hemisphere(20) = }')
			print(F'Cone: {surface_area_cone(10, 20) = }')
			print(F'Conical Frustum: {surface_area_conical_frustum(10, 20, 30) = }')
			print(F'Cylinder: {surface_area_cylinder(10, 20) = }')
			print(F'Torus: {surface_area_torus(20, 10) = }')
			print(F'Equilateral Triangle: {area_reg_polygon(3, 10) = }')
			print(F'Square: {area_reg_polygon(4, 10) = }')
			print(F'Reqular Pentagon: {area_reg_polygon(5, 10) = }')




import math





def  _lowerCamelCase					(   a_				: int):

			if 1 < number < 4:
						# 2 and 3 are primes
						return True
			elif number < 2 or number % 2 == 0 or number % 3 == 0:
						# Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
						return False

			# All primes number are in format of 6k +/- 1
			for i in range(5						,			int(math.sqrt(a_) + 1)						,			6):
						if number % i == 0 or number % (i + 2) == 0:
									return False
			return True





def  _lowerCamelCase					(   a_				: float = 0.1):
			lowerCamelCase						:Dict						  =     3
			lowerCamelCase						:List[Any]						  =     3

			while primes / (2 * j - 1) >= ratio:
						for i in range(j * j + j + 1						,			(j + 2) * (j + 2)						,			j + 1):
									primes += is_prime(a_)
						j += 2
			return j


if __name__ == "__main__":
			import doctest

			doctest.testmod()



