





'''simple docstring'''







def  __UpperCamelCase						(						a     :			str  )			->Dict:
 snake_case					=      current_set.copy()
 for row_index, row in enumerate(_A  ):
  snake_case					=      row[0]
  for column_index, column in enumerate(_A  ):
   if magnitude == 0:
    snake_case					=      column
    continue
   snake_case					=      column / magnitude
    # Subtract to cancel term
 snake_case					=      current_set[0]
 snake_case					=      [first_row]
 snake_case					=      current_set[1::]
 for row in current_set:
  snake_case					=      []
  # If first term is 0, it is already in form we want, so we preserve it
  if row[0] == 0:
   final_set.append(_A  )
   continue
  for column_index in range(len(_A  )  ):
   temp_row.append(first_row[column_index] - row[column_index]  )
  final_set.append(_A  )
 # Create next recursion iteration set
 if len(final_set[0]  ) != 3:
  snake_case					=      final_set[0]
  snake_case					=      []
  snake_case					=      []
  for row in final_set[1::]:
   current_first_column.append(row[0]  )
   next_iteration.append(row[1::]  )
  snake_case					=      simplify(_A  )
  for i in range(len(_A  )  ):
   resultant[i].insert(0       , current_first_column[i]  )
  resultant.insert(0       , _A  )
  snake_case					=      resultant
 return final_set

def  __UpperCamelCase						(						a     :			str  )			->Union[str, Any]:







 if len(_A  ) == 0:
  raise IndexError('''solve_simultaneous() requires n lists of length n+1'''  )
 snake_case					=      len(_A  ) + 1
 if any(len(_A  ) != _length for item in equations  ):
  raise IndexError('''solve_simultaneous() requires n lists of length n+1'''  )
 for row in equations:
  if any(not isinstance(_A       , (int, float)  ) for column in row  ):
   raise ValueError('''solve_simultaneous() requires lists of integers'''  )
 if len(_A  ) == 1:
  return [equations[0][-1] / equations[0][0]]
 snake_case					=      equations.copy()
 if any(0 in row for row in data_set  ):
  snake_case					=      data_set.copy()
  snake_case					=      []
  for row_index, row in enumerate(_A  ):
   if 0 not in row:
    snake_case					=      data_set.pop(_A  )
    break
  if not full_row:
   raise ValueError('''solve_simultaneous() requires at least 1 full equation'''  )
  data_set.insert(0       , _A  )
 snake_case					=      data_set.copy()
 snake_case					=      simplify(_A  )
 snake_case					=      simplified[::-1]
 snake_case					=      []
 for row in simplified:
  snake_case					=      row[-1]
  if not solutions:
   if row[-2] == 0:
    solutions.append(0  )
    continue
   solutions.append(current_solution / row[-2]  )
   continue
  snake_case					=      row.copy()[: len(_A  ) - 1 :]
  while temp_row[0] == 0:
   temp_row.pop(0  )
  if len(_A  ) == 0:
   solutions.append(0  )
   continue
  snake_case					=      temp_row[1::]
  snake_case					=      temp_row[::-1]
  for column_index, column in enumerate(_A  ):
   current_solution -= column * solutions[column_index]
  solutions.append(_A  )
 snake_case					=      []
 for item in solutions:
  final.append(float(round(_A       , 5  )  )  )
 return final[::-1]


if __name__ == "__main__":
   import doctest

   doctest.testmod()
   _lowercase							    =      [
       [2, 1, 1, 1, 1, 4],
       [1, 2, 1, 1, 1, 5],
       [1, 1, 2, 1, 1, 6],
       [1, 1, 1, 2, 1, 7],
       [1, 1, 1, 1, 2, 8],
   ]
   print(solve_simultaneous(eq))
   print(solve_simultaneous([[4, 2]]))





'''simple docstring'''







from math import pi, sqrt, tan






def       lowercase					(_A       ):







       """simple docstring"""







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






def       lowercase					(_A ,    _A ,    _A       ):







       """simple docstring"""







       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       lowercase					(_A       ):







       """simple docstring"""







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






def       lowercase					(_A       ):







       """simple docstring"""







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






def       lowercase					(_A ,    _A       ):







       """simple docstring"""







       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       lowercase					(_A ,    _A ,    _A       ):







       """simple docstring"""







       if radius_a < 0 or radius_a < 0 or height < 0:
              raise ValueError(
                  'surface_area_conical_frustum() only accepts non-negative values'       )
       _lowerCAmelCase     :				int       =							(height**2 + (radius_a - radius_a) ** 2) ** 0.5
       return pi * ((slant_height * (radius_a + radius_a)) + radius_a**2 + radius_a**2)






def       lowercase					(_A ,    _A       ):







       """simple docstring"""







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






def       lowercase					(_A ,    _A       ):







       """simple docstring"""







       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       lowercase					(_A ,    _A       ):







       """simple docstring"""







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






def       lowercase					(_A       ):







       """simple docstring"""







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






def       lowercase					(_A ,    _A       ):







       """simple docstring"""







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






def       lowercase					(_A ,    _A ,    _A       ):







       """simple docstring"""







       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       lowercase					(_A ,    _A       ):







       """simple docstring"""







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






def       lowercase					(_A ,    _A ,    _A       ):







       """simple docstring"""







       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       lowercase					(_A       ):







       """simple docstring"""







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






def       lowercase					(_A ,    _A       ):







       """simple docstring"""







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






def       lowercase					(_A ,    _A       ):







       """simple docstring"""







       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       lowercase					(_A ,    _A       ):







       """simple docstring"""







       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) = }''')

