


from math import pi, sqrt, tan




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




def    snake_case_     (  snake_case			,							snake_case			,							snake_case     )  ->				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    snake_case_     (  snake_case     )  ->				float:
       if radius < 0:
              raise ValueError('surface_area_sphere() only accepts non-negative values'     )
       return 4 * pi * radius**2




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




def    snake_case_     (  snake_case			,							snake_case     )  ->				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    snake_case_     (  snake_case			,							snake_case			,							snake_case     )  ->				float:
       if radius_a < 0 or radius_a < 0 or height < 0:
              raise ValueError(
                  'surface_area_conical_frustum() only accepts non-negative values'     )
       lowercase__:   Tuple  			=   (height**2 + (radius_a - radius_a) ** 2) ** 0.5
       return pi * ((slant_height * (radius_a + radius_a)) + radius_a**2 + radius_a**2)




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




def    snake_case_     (  snake_case			,							snake_case     )  ->				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(snake_case			,							2     ) * torus_radius * tube_radius




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




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




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




def    snake_case_     (  snake_case			,							snake_case			,							snake_case     )  ->				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'     )
       lowercase__:   Optional[int]  			=   (sidea + sidea + sidea) / 2
       lowercase__:   List[Any]  			=   sqrt(
           semi_perimeter
           * (semi_perimeter - sidea)
           * (semi_perimeter - sidea)
           * (semi_perimeter - sidea)     )
       return area




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




def    snake_case_     (  snake_case			,							snake_case			,							snake_case     )  ->				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    snake_case_     (  snake_case     )  ->				float:
       if radius < 0:
              raise ValueError('area_circle() only accepts non-negative values'     )
       return pi * radius**2




def    snake_case_     (  snake_case			,							snake_case     )  ->				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    snake_case_     (  snake_case			,							snake_case     )  ->				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    snake_case_     (  snake_case			,							snake_case     )  ->				float:
       if not isinstance(snake_case			,							snake_case     ) 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) = }''')






from __future__ import annotations

from collections.abc import Callable

__lowerCAmelCase		       =							list[list[float | int]]




def    snake_case_     (  snake_case			,							snake_case     )  ->				Matrix:
       lowercase__:   int  			=   len(snake_case     )
       lowercase__:   Matrix  			=   [[0 for _ in range(size + 1     )] for _ in range(snake_case     )]
       lowercase__:   int
       lowercase__:   int
       lowercase__:   int
       lowercase__:   int
       lowercase__:   int
       lowercase__:   float

       for row in range(snake_case     ):
              for col in range(snake_case     ):
                     lowercase__:   List[Any]  			=   matrix[row][col]

              lowercase__:   Optional[int]  			=   vector[row][0]

       lowercase__:   str  			=   0
       lowercase__:   Any  			=   0
       while row < size and col < size:
              # pivoting
              lowercase__:   List[Any]  			=   max((abs(augmented[rowa][col]     ), rowa) for rowa in range(snake_case			,							snake_case     )     )[
                  1
              ]
              if augmented[pivot_row][col] == 0:
                     col += 1
                     continue
              else:
                     lowercase__			,						lowercase__:   Optional[int]  			=   augmented[pivot_row], augmented[row]

              for rowa in range(row + 1			,							snake_case     ):
                     lowercase__:   Any  			=   augmented[rowa][col] / augmented[row][col]
                     lowercase__:   int  			=   0
                     for cola in range(col + 1			,							size + 1     ):
                            augmented[rowa][cola] -= augmented[row][cola] * ratio

              row += 1
              col += 1

       # back substitution
       for col in range(1			,							snake_case     ):
              for row in range(snake_case     ):
                     lowercase__:   Union[str, Any]  			=   augmented[row][col] / augmented[col][col]
                     for cola in range(snake_case			,							size + 1     ):
                            augmented[row][cola] -= augmented[col][cola] * ratio

    # round to get rid of numbers like 2.000000000000004
       return [
           [round(augmented[row][size] / augmented[row][row]			,							10     )] for row in range(snake_case     )
       ]




def    snake_case_     (  snake_case     )  ->				Callable[[int], int]:
       lowercase__:   int  			=   len(snake_case     )
       lowercase__:   Matrix  			=   [[0 for _ in range(snake_case     )] for _ in range(snake_case     )]
       lowercase__:   Matrix  			=   [[0] for _ in range(snake_case     )]
       lowercase__:   Matrix
       lowercase__:   int
       lowercase__:   int
       lowercase__:   int

       for x_val, y_val in enumerate(snake_case     ):
              for col in range(snake_case     ):
                     lowercase__:   List[str]  			=   (x_val + 1) ** (size - col - 1)
              lowercase__:   str  			=   y_val

       lowercase__:   Optional[int]  			=   solve(snake_case			,							snake_case     )

       def interpolated_func(snake_case     ) -> int:
              return sum(
                  round(coeffs[x_val][0]     ) * (var ** (size - x_val - 1))
                  for x_val in range(snake_case     )     )

       return interpolated_func




def    snake_case_     (  snake_case     )  ->				int:
       return (
           1
           - variable
           + variable**2
           - variable**3
           + variable**4
           - variable**5
           + variable**6
           - variable**7
           + variable**8
           - variable**9
           + variable**10
       )




def    snake_case_     (  snake_case = question_function			,							snake_case = 10     )  ->				int:
       lowercase__:   list[int]  			=   [func(snake_case     ) for x_val in range(1			,							order + 1     )]

       lowercase__:   list[Callable[[int], int]]  			=   [
           interpolate(data_points[:max_coeff]     ) for max_coeff in range(1			,							order + 1     )
       ]

       lowercase__:   int  			=   0
       lowercase__:   Callable[[int], int]
       lowercase__:   int

       for poly in polynomials:
              lowercase__:   List[str]  			=   1
              while func(snake_case     ) == poly(snake_case     ):
                     x_val += 1

              ret += poly(snake_case     )

       return ret


if __name__ == "__main__":
 print(F'''{solution() = }''')


