


"""simple docstring"""





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 :	float       ,      _snake_case :	float       ,      _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 :	float       ,      _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 :	float       ,      _snake_case :	float       ,      _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'''	)
      lowerCAmelCase    :		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 :	float       ,      _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 :	float       ,      _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 :	float       ,      _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 :	float       ,      _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 :	float       ,      _snake_case :	float       ,      _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'''	)
      lowerCAmelCase    :		Tuple				=      (sidea + sidea + sidea) / 2
      lowerCAmelCase    :		Dict				=      sqrt(
          semi_perimeter
          * (semi_perimeter - sidea)
          * (semi_perimeter - sidea)
          * (semi_perimeter - sidea)	)
      return area


def    _snake_case  (  _snake_case :	float       ,      _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 :	float       ,      _snake_case :	float       ,      _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 :	float       ,      _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 :	float       ,      _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 :	int       ,      _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) = }""")






"""simple docstring"""





from __future__ import annotations

from decimal import Decimal

from numpy import array


def    _snake_case  (  _snake_case :	list[list[float]]	):
      lowerCAmelCase    :		str				=      Decimal

      # Check if the provided matrix has 2 rows and 2 columns
      # since this implementation only works for 2x2 matrices
      if len(_snake_case	) == 2 and len(matrix[0]	) == 2 and len(matrix[1]	) == 2:
            # Calculate the determinant of the matrix
            lowerCAmelCase    :		int				=      float(
                d(matrix[0][0]	) * d(matrix[1][1]	) - d(matrix[1][0]	) * d(matrix[0][1]	)	)
            if determinant == 0:
                  raise ValueError('''This matrix has no inverse.'''	)

            # Creates a copy of the matrix with swapped positions of the elements
            lowerCAmelCase    :		Optional[int]				=      [[0.0, 0.0], [0.0, 0.0]]
            lowerCAmelCase,					lowerCAmelCase    :		List[Any]				=      matrix[1][1], matrix[0][0]
            lowerCAmelCase,					lowerCAmelCase    :		Union[str, Any]				=      -matrix[1][0], -matrix[0][1]

            # Calculate the inverse of the matrix
            return [
                [(float(d(_snake_case	)	) / determinant) or 0.0 for n in row] for row in swapped_matrix
            ]
      elif (
          len(_snake_case	) == 3
          and len(matrix[0]	) == 3
          and len(matrix[1]	) == 3
          and len(matrix[2]	) == 3
      ):
            # Calculate the determinant of the matrix using Sarrus rule
            lowerCAmelCase    :		int				=      float(
                (
                    (d(matrix[0][0]	) * d(matrix[1][1]	) * d(matrix[2][2]	))
                    + (d(matrix[0][1]	) * d(matrix[1][2]	) * d(matrix[2][0]	))
                    + (d(matrix[0][2]	) * d(matrix[1][0]	) * d(matrix[2][1]	))
                )
                - (
                    (d(matrix[0][2]	) * d(matrix[1][1]	) * d(matrix[2][0]	))
                    + (d(matrix[0][1]	) * d(matrix[1][0]	) * d(matrix[2][2]	))
                    + (d(matrix[0][0]	) * d(matrix[1][2]	) * d(matrix[2][1]	))
                )	)
            if determinant == 0:
                  raise ValueError('''This matrix has no inverse.'''	)

            # Creating cofactor matrix
            lowerCAmelCase    :		Dict				=      [
                [d(0.0	), d(0.0	), d(0.0	)],
                [d(0.0	), d(0.0	), d(0.0	)],
                [d(0.0	), d(0.0	), d(0.0	)],
            ]
            lowerCAmelCase    :		List[str]				=      (d(matrix[1][1]	) * d(matrix[2][2]	)) - (
                d(matrix[1][2]	) * d(matrix[2][1]	)
            )
            lowerCAmelCase    :		Dict				=      -(
                (d(matrix[1][0]	) * d(matrix[2][2]	)) - (d(matrix[1][2]	) * d(matrix[2][0]	))
            )
            lowerCAmelCase    :		str				=      (d(matrix[1][0]	) * d(matrix[2][1]	)) - (
                d(matrix[1][1]	) * d(matrix[2][0]	)
            )
            lowerCAmelCase    :		Any				=      -(
                (d(matrix[0][1]	) * d(matrix[2][2]	)) - (d(matrix[0][2]	) * d(matrix[2][1]	))
            )
            lowerCAmelCase    :		Any				=      (d(matrix[0][0]	) * d(matrix[2][2]	)) - (
                d(matrix[0][2]	) * d(matrix[2][0]	)
            )
            lowerCAmelCase    :		Optional[int]				=      -(
                (d(matrix[0][0]	) * d(matrix[2][1]	)) - (d(matrix[0][1]	) * d(matrix[2][0]	))
            )
            lowerCAmelCase    :		Optional[int]				=      (d(matrix[0][1]	) * d(matrix[1][2]	)) - (
                d(matrix[0][2]	) * d(matrix[1][1]	)
            )
            lowerCAmelCase    :		Dict				=      -(
                (d(matrix[0][0]	) * d(matrix[1][2]	)) - (d(matrix[0][2]	) * d(matrix[1][0]	))
            )
            lowerCAmelCase    :		List[Any]				=      (d(matrix[0][0]	) * d(matrix[1][1]	)) - (
                d(matrix[0][1]	) * d(matrix[1][0]	)
            )

            # Transpose the cofactor matrix (Adjoint matrix)
            lowerCAmelCase    :		str				=      array(_snake_case	)
            for i in range(3	):
                  for j in range(3	):
                        lowerCAmelCase    :		Optional[Any]				=      cofactor_matrix[j][i]

        # Inverse of the matrix using the formula (1/determinant) * adjoint matrix
            lowerCAmelCase    :		Tuple				=      array(_snake_case	)
            for i in range(3	):
                  for j in range(3	):
                        inverse_matrix[i][j] /= d(_snake_case	)

        # Calculate the inverse of the matrix
            return [[float(d(_snake_case	)	) or 0.0 for n in row] for row in inverse_matrix]
      raise ValueError('''Please provide a matrix of size 2x2 or 3x3.'''	)


