





'''simple docstring'''

from math import pi, sqrt, tan

def 						__magic_name__       (							__UpperCAmelCase      )						->					float:

   '''simple docstring'''







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

def 						__magic_name__       (							__UpperCAmelCase							,	__UpperCAmelCase							,	__UpperCAmelCase      )						->					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 						__magic_name__       (							__UpperCAmelCase      )						->					float:

   '''simple docstring'''







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

def 						__magic_name__       (							__UpperCAmelCase      )						->					float:

   '''simple docstring'''







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

def 						__magic_name__       (							__UpperCAmelCase							,	__UpperCAmelCase      )						->					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 						__magic_name__       (							__UpperCAmelCase							,	__UpperCAmelCase							,	__UpperCAmelCase      )						->					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"""      )
   __SCREAMING_SNAKE_CASE      							=       (height**2 + (radius_a - radius_a) ** 2) ** 0.5
   return pi * ((slant_height * (radius_a + radius_a)) + radius_a**2 + radius_a**2)

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

def 						__magic_name__       (							__UpperCAmelCase							,	__UpperCAmelCase      )						->					float:

   '''simple docstring'''







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

def 						__magic_name__       (							__UpperCAmelCase      )						->					float:

   '''simple docstring'''







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

def 						__magic_name__       (							__UpperCAmelCase							,	__UpperCAmelCase      )						->					float:

   '''simple docstring'''







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

def 						__magic_name__       (							__UpperCAmelCase							,	__UpperCAmelCase							,	__UpperCAmelCase      )						->					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"""      )
   __SCREAMING_SNAKE_CASE      							=       (sidea + sidea + sidea) / 2
   __SCREAMING_SNAKE_CASE      							=       sqrt(
       semi_perimeter
       * (semi_perimeter - sidea)
       * (semi_perimeter - sidea)
       * (semi_perimeter - sidea)      )
   return area

def 						__magic_name__       (							__UpperCAmelCase							,	__UpperCAmelCase      )						->					float:

   '''simple docstring'''







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

def 						__magic_name__       (							__UpperCAmelCase							,	__UpperCAmelCase							,	__UpperCAmelCase      )						->					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 						__magic_name__       (							__UpperCAmelCase      )						->					float:

   '''simple docstring'''







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

def 						__magic_name__       (							__UpperCAmelCase							,	__UpperCAmelCase      )						->					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 						__magic_name__       (							__UpperCAmelCase							,	__UpperCAmelCase      )						->					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 						__magic_name__       (							__UpperCAmelCase							,	__UpperCAmelCase      )						->					float:

   '''simple docstring'''







   if not isinstance(__UpperCAmelCase							,	__UpperCAmelCase      ) 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'''

import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin


if is_torch_available():
    import torch

if is_vision_available():
    from PIL import Image

    from transformers import ChineseCLIPImageProcessor







class __a (   unittest.TestCase			):





   def __init__(					self				:			List[Any]				,lowerCamelCase				:			List[Any]				,lowerCamelCase				:			List[str]=7				,lowerCamelCase				:			List[str]=3				,lowerCamelCase				:			List[str]=18				,lowerCamelCase				:			Any=30				,lowerCamelCase				:			Optional[Any]=400				,lowerCamelCase				:			Optional[Any]=True				,lowerCamelCase				:			Optional[Any]=None				,lowerCamelCase				:			Optional[int]=True				,lowerCamelCase				:			int=None				,lowerCamelCase				:			str=True				,lowerCamelCase				:			Dict=[0.48_145_466, 0.4_578_275, 0.40_821_073]				,lowerCamelCase				:			List[str]=[0.26_862_954, 0.26_130_258, 0.27_577_711]				,lowerCamelCase				:			Tuple=True				,):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       size if size is not None else {"""height""": 224, """width""": 224}
      __SCREAMING_SNAKE_CASE      							=       crop_size if crop_size is not None else {"""height""": 18, """width""": 18}
      __SCREAMING_SNAKE_CASE      							=       parent
      __SCREAMING_SNAKE_CASE      							=       batch_size
      __SCREAMING_SNAKE_CASE      							=       num_channels
      __SCREAMING_SNAKE_CASE      							=       image_size
      __SCREAMING_SNAKE_CASE      							=       min_resolution
      __SCREAMING_SNAKE_CASE      							=       max_resolution
      __SCREAMING_SNAKE_CASE      							=       do_resize
      __SCREAMING_SNAKE_CASE      							=       size
      __SCREAMING_SNAKE_CASE      							=       do_center_crop
      __SCREAMING_SNAKE_CASE      							=       crop_size
      __SCREAMING_SNAKE_CASE      							=       do_normalize
      __SCREAMING_SNAKE_CASE      							=       image_mean
      __SCREAMING_SNAKE_CASE      							=       image_std
      __SCREAMING_SNAKE_CASE      							=       do_convert_rgb





   def      UpperCAmelCase__     (					self				:			Optional[int]    ):

      '''simple docstring'''

      return {
          "do_resize": self.do_resize,
          "size": self.size,
          "do_center_crop": self.do_center_crop,
          "crop_size": self.crop_size,
          "do_normalize": self.do_normalize,
          "image_mean": self.image_mean,
          "image_std": self.image_std,
          "do_convert_rgb": self.do_convert_rgb,
      }





   def      UpperCAmelCase__     (					self				:			int				,lowerCamelCase				:			Union[str, Any]=False				,lowerCamelCase				:			str=False				,lowerCamelCase				:			str=False    ):

      '''simple docstring'''

      assert not (numpify and torchify), "You cannot specify both numpy and PyTorch tensors at the same time"

      if equal_resolution:
         __SCREAMING_SNAKE_CASE      							=       []
         for i in range(self.batch_size    ):
            image_inputs.append(
                np.random.randint(
                    255				,size=(self.num_channels, self.max_resolution, self.max_resolution)				,dtype=np.uinta    )    )
      else:
         __SCREAMING_SNAKE_CASE      							=       []
         for i in range(self.batch_size    ):
            __SCREAMING_SNAKE_CASE							,     __SCREAMING_SNAKE_CASE      							=       np.random.choice(np.arange(self.min_resolution				,self.max_resolution    )				,2    )
            image_inputs.append(np.random.randint(255				,size=(self.num_channels, width, height)				,dtype=np.uinta    )    )

      if not numpify and not torchify:
         # PIL expects the channel dimension as last dimension
         __SCREAMING_SNAKE_CASE      							=       [Image.fromarray(np.moveaxis(lowerCamelCase				,0				,-1    )    ) for x in image_inputs]

      if torchify:
         __SCREAMING_SNAKE_CASE      							=       [torch.from_numpy(lowerCamelCase    ) for x in image_inputs]

      return image_inputs







@require_torch
@require_vision
class __a (   _snake_case,   unittest.TestCase			):
   __UpperCamelCase   : int	      =	ChineseCLIPImageProcessor if is_vision_available() else None





   def      UpperCAmelCase__     (					self				:			Any    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       ChineseCLIPImageProcessingTester(self				,do_center_crop=lowerCamelCase    )





   @property
   def      UpperCAmelCase__     (					self				:			Optional[int]    ):

      '''simple docstring'''

      return self.image_processor_tester.prepare_image_processor_dict()





   def      UpperCAmelCase__     (					self				:			Tuple    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       self.image_processing_class(**self.image_processor_dict    )
      self.assertTrue(hasattr(lowerCamelCase				,"""do_resize"""    )    )
      self.assertTrue(hasattr(lowerCamelCase				,"""size"""    )    )
      self.assertTrue(hasattr(lowerCamelCase				,"""do_center_crop"""    )    )
      self.assertTrue(hasattr(lowerCamelCase				,"""center_crop"""    )    )
      self.assertTrue(hasattr(lowerCamelCase				,"""do_normalize"""    )    )
      self.assertTrue(hasattr(lowerCamelCase				,"""image_mean"""    )    )
      self.assertTrue(hasattr(lowerCamelCase				,"""image_std"""    )    )
      self.assertTrue(hasattr(lowerCamelCase				,"""do_convert_rgb"""    )    )





   def      UpperCAmelCase__     (					self				:			List[Any]    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       self.image_processing_class.from_dict(self.image_processor_dict    )
      self.assertEqual(image_processor.size				,{"""height""": 224, """width""": 224}    )
      self.assertEqual(image_processor.crop_size				,{"""height""": 18, """width""": 18}    )

      __SCREAMING_SNAKE_CASE      							=       self.image_processing_class.from_dict(self.image_processor_dict				,size=42				,crop_size=84    )
      self.assertEqual(image_processor.size				,{"""shortest_edge""": 42}    )
      self.assertEqual(image_processor.crop_size				,{"""height""": 84, """width""": 84}    )





   def      UpperCAmelCase__     (					self				:			Dict    ):

      '''simple docstring'''

      pass





   def      UpperCAmelCase__     (					self				:			List[str]    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       self.image_processing_class(**self.image_processor_dict    )
      # create random PIL images
      __SCREAMING_SNAKE_CASE      							=       self.image_processor_tester.prepare_inputs(equal_resolution=lowerCamelCase    )
      for image in image_inputs:
         self.assertIsInstance(lowerCamelCase				,Image.Image    )

      # Test not batched input
      __SCREAMING_SNAKE_CASE      							=       image_processing(image_inputs[0]				,return_tensors="""pt"""    ).pixel_values
      self.assertEqual(
          encoded_images.shape				,(
              1,
              self.image_processor_tester.num_channels,
              self.image_processor_tester.crop_size["""height"""],
              self.image_processor_tester.crop_size["""width"""],
          )				,)

      # Test batched
      __SCREAMING_SNAKE_CASE      							=       image_processing(lowerCamelCase				,return_tensors="""pt"""    ).pixel_values
      self.assertEqual(
          encoded_images.shape				,(
              self.image_processor_tester.batch_size,
              self.image_processor_tester.num_channels,
              self.image_processor_tester.crop_size["""height"""],
              self.image_processor_tester.crop_size["""width"""],
          )				,)





   def      UpperCAmelCase__     (					self				:			Optional[int]    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       self.image_processing_class(**self.image_processor_dict    )
      # create random numpy tensors
      __SCREAMING_SNAKE_CASE      							=       self.image_processor_tester.prepare_inputs(equal_resolution=lowerCamelCase				,numpify=lowerCamelCase    )
      for image in image_inputs:
         self.assertIsInstance(lowerCamelCase				,np.ndarray    )

      # Test not batched input
      __SCREAMING_SNAKE_CASE      							=       image_processing(image_inputs[0]				,return_tensors="""pt"""    ).pixel_values
      self.assertEqual(
          encoded_images.shape				,(
              1,
              self.image_processor_tester.num_channels,
              self.image_processor_tester.crop_size["""height"""],
              self.image_processor_tester.crop_size["""width"""],
          )				,)

      # Test batched
      __SCREAMING_SNAKE_CASE      							=       image_processing(lowerCamelCase				,return_tensors="""pt"""    ).pixel_values
      self.assertEqual(
          encoded_images.shape				,(
              self.image_processor_tester.batch_size,
              self.image_processor_tester.num_channels,
              self.image_processor_tester.crop_size["""height"""],
              self.image_processor_tester.crop_size["""width"""],
          )				,)





   def      UpperCAmelCase__     (					self				:			str    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       self.image_processing_class(**self.image_processor_dict    )
      # create random PyTorch tensors
      __SCREAMING_SNAKE_CASE      							=       self.image_processor_tester.prepare_inputs(equal_resolution=lowerCamelCase				,torchify=lowerCamelCase    )
      for image in image_inputs:
         self.assertIsInstance(lowerCamelCase				,torch.Tensor    )

      # Test not batched input
      __SCREAMING_SNAKE_CASE      							=       image_processing(image_inputs[0]				,return_tensors="""pt"""    ).pixel_values
      self.assertEqual(
          encoded_images.shape				,(
              1,
              self.image_processor_tester.num_channels,
              self.image_processor_tester.crop_size["""height"""],
              self.image_processor_tester.crop_size["""width"""],
          )				,)

      # Test batched
      __SCREAMING_SNAKE_CASE      							=       image_processing(lowerCamelCase				,return_tensors="""pt"""    ).pixel_values
      self.assertEqual(
          encoded_images.shape				,(
              self.image_processor_tester.batch_size,
              self.image_processor_tester.num_channels,
              self.image_processor_tester.crop_size["""height"""],
              self.image_processor_tester.crop_size["""width"""],
          )				,)







@require_torch
@require_vision
class __a (   _snake_case,   unittest.TestCase			):
   __UpperCamelCase   : Optional[int]	      =	ChineseCLIPImageProcessor if is_vision_available() else None





   def      UpperCAmelCase__     (					self				:			Tuple    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       ChineseCLIPImageProcessingTester(self				,num_channels=4				,do_center_crop=lowerCamelCase    )
      __SCREAMING_SNAKE_CASE      							=       3





   @property
   def      UpperCAmelCase__     (					self				:			Dict    ):

      '''simple docstring'''

      return self.image_processor_tester.prepare_image_processor_dict()





   def      UpperCAmelCase__     (					self				:			int    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       self.image_processing_class(**self.image_processor_dict    )
      self.assertTrue(hasattr(lowerCamelCase				,"""do_resize"""    )    )
      self.assertTrue(hasattr(lowerCamelCase				,"""size"""    )    )
      self.assertTrue(hasattr(lowerCamelCase				,"""do_center_crop"""    )    )
      self.assertTrue(hasattr(lowerCamelCase				,"""center_crop"""    )    )
      self.assertTrue(hasattr(lowerCamelCase				,"""do_normalize"""    )    )
      self.assertTrue(hasattr(lowerCamelCase				,"""image_mean"""    )    )
      self.assertTrue(hasattr(lowerCamelCase				,"""image_std"""    )    )
      self.assertTrue(hasattr(lowerCamelCase				,"""do_convert_rgb"""    )    )





   def      UpperCAmelCase__     (					self				:			Tuple    ):

      '''simple docstring'''

      pass





   def      UpperCAmelCase__     (					self				:			Union[str, Any]    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       self.image_processing_class(**self.image_processor_dict    )
      # create random PIL images
      __SCREAMING_SNAKE_CASE      							=       self.image_processor_tester.prepare_inputs(equal_resolution=lowerCamelCase    )
      for image in image_inputs:
         self.assertIsInstance(lowerCamelCase				,Image.Image    )

      # Test not batched input
      __SCREAMING_SNAKE_CASE      							=       image_processing(image_inputs[0]				,return_tensors="""pt"""    ).pixel_values
      self.assertEqual(
          encoded_images.shape				,(
              1,
              self.expected_encoded_image_num_channels,
              self.image_processor_tester.crop_size["""height"""],
              self.image_processor_tester.crop_size["""width"""],
          )				,)

      # Test batched
      __SCREAMING_SNAKE_CASE      							=       image_processing(lowerCamelCase				,return_tensors="""pt"""    ).pixel_values
      self.assertEqual(
          encoded_images.shape				,(
              self.image_processor_tester.batch_size,
              self.expected_encoded_image_num_channels,
              self.image_processor_tester.crop_size["""height"""],
              self.image_processor_tester.crop_size["""width"""],
          )				,)





