






'''simple docstring'''






from math import pi, sqrt, tan




def        _SCREAMING_SNAKE_CASE  (				A  :       float  )    -> float:







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




def        _SCREAMING_SNAKE_CASE  (				A  :       float  ,		A  :       float  ,		A  :       float  )    -> float:







   """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        _SCREAMING_SNAKE_CASE  (				A  :       float  )    -> float:







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




def        _SCREAMING_SNAKE_CASE  (				A  :       float  )    -> float:







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




def        _SCREAMING_SNAKE_CASE  (				A  :       float  ,		A  :       float  )    -> float:







   """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        _SCREAMING_SNAKE_CASE  (				A  :       float  ,		A  :       float  ,		A  :       float  )    -> float:







   """simple docstring"""
   if radius_a < 0 or radius_a < 0 or height < 0:
      raise ValueError(
          'surface_area_conical_frustum() only accepts non-negative values'  )
   __snake_case				:      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        _SCREAMING_SNAKE_CASE  (				A  :       float  ,		A  :       float  )    -> float:







   """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        _SCREAMING_SNAKE_CASE  (				A  :       float  ,		A  :       float  )    -> float:







   """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        _SCREAMING_SNAKE_CASE  (				A  :       float  ,		A  :       float  )    -> float:







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




def        _SCREAMING_SNAKE_CASE  (				A  :       float  )    -> float:







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




def        _SCREAMING_SNAKE_CASE  (				A  :       float  ,		A  :       float  )    -> float:







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




def        _SCREAMING_SNAKE_CASE  (				A  :       float  ,		A  :       float  ,		A  :       float  )    -> float:







   """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'  )
   __snake_case				:      List[Any]     							= (sidea + sidea + sidea) / 2
   __snake_case				:      int     							= sqrt(
       semi_perimeter
       * (semi_perimeter - sidea)
       * (semi_perimeter - sidea)
       * (semi_perimeter - sidea)  )
   return area




def        _SCREAMING_SNAKE_CASE  (				A  :       float  ,		A  :       float  )    -> float:







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




def        _SCREAMING_SNAKE_CASE  (				A  :       float  ,		A  :       float  ,		A  :       float  )    -> float:







   """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        _SCREAMING_SNAKE_CASE  (				A  :       float  )    -> float:







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




def        _SCREAMING_SNAKE_CASE  (				A  :       float  ,		A  :       float  )    -> float:







   """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        _SCREAMING_SNAKE_CASE  (				A  :       float  ,		A  :       float  )    -> float:







   """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        _SCREAMING_SNAKE_CASE  (				A  :       int  ,		A  :       float  )    -> float:







   """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(1_0, 2_0) = }''')
      print(f'''Square: {area_square(1_0) = }''')
      print(f'''Triangle: {area_triangle(1_0, 1_0) = }''')
      print(f'''Triangle: {area_triangle_three_sides(5, 1_2, 1_3) = }''')
      print(f'''Parallelogram: {area_parallelogram(1_0, 2_0) = }''')
      print(f'''Rhombus: {area_rhombus(1_0, 2_0) = }''')
      print(f'''Trapezium: {area_trapezium(1_0, 2_0, 3_0) = }''')
      print(f'''Circle: {area_circle(2_0) = }''')
      print(f'''Ellipse: {area_ellipse(1_0, 2_0) = }''')
      print('''\nSurface Areas of various geometric shapes: \n''')
      print(f'''Cube: {surface_area_cube(2_0) = }''')
      print(f'''Cuboid: {surface_area_cuboid(1_0, 2_0, 3_0) = }''')
      print(f'''Sphere: {surface_area_sphere(2_0) = }''')
      print(f'''Hemisphere: {surface_area_hemisphere(2_0) = }''')
      print(f'''Cone: {surface_area_cone(1_0, 2_0) = }''')
      print(f'''Conical Frustum: {surface_area_conical_frustum(1_0, 2_0, 3_0) = }''')
      print(f'''Cylinder: {surface_area_cylinder(1_0, 2_0) = }''')
      print(f'''Torus: {surface_area_torus(2_0, 1_0) = }''')
      print(f'''Equilateral Triangle: {area_reg_polygon(3, 1_0) = }''')
      print(f'''Square: {area_reg_polygon(4, 1_0) = }''')
      print(f'''Reqular Pentagon: {area_reg_polygon(5, 1_0) = }''')







'''simple docstring'''






import unittest

from transformers import load_tool
from transformers.utils import is_torch_available


if is_torch_available():
      import torch

from transformers.testing_utils import require_torch

from .test_tools_common import ToolTesterMixin




@require_torch
class a_    (    unittest.TestCase		,      UpperCamelCase_							):







   def     SCREAMING_SNAKE_CASE__					(self)			->      List[Any]:
      """simple docstring"""






      __snake_case				:      List[str]     							= load_tool('text-to-speech')
      self.tool.setup()







   def     SCREAMING_SNAKE_CASE__					(self)			->      Optional[Any]:
      """simple docstring"""






      torch.manual_seed(0)
      __snake_case				:      Dict     							= self.tool('hey')
      __snake_case				:      List[Any]     							= result.to_raw()
      self.assertTrue(
          torch.allclose(
              resulting_tensor[:3]					,   torch.tensor([-0.0_005_966_668_832_115_829, -0.0_003_657_640_190_795_064, -0.00_013_439_502_799_883_485])					,   ))







   def     SCREAMING_SNAKE_CASE__					(self)			->      List[Any]:
      """simple docstring"""






      torch.manual_seed(0)
      __snake_case				:      Any     							= self.tool('hey')
      __snake_case				:      Any     							= result.to_raw()
      self.assertTrue(
          torch.allclose(
              resulting_tensor[:3]					,   torch.tensor([-0.0_005_966_668_832_115_829, -0.0_003_657_640_190_795_064, -0.00_013_439_502_799_883_485])					,   ))