


from math import pi, sqrt, tan




def 	a_      (    SCREAMING_SNAKE_CASE__					:      float     ):
       '''simple docstring'''





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




def 	a_      (    SCREAMING_SNAKE_CASE__					:      float		,			SCREAMING_SNAKE_CASE__					:      float		,			SCREAMING_SNAKE_CASE__					:      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 	a_      (    SCREAMING_SNAKE_CASE__					:      float     ):
       '''simple docstring'''





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




def 	a_      (    SCREAMING_SNAKE_CASE__					:      float     ):
       '''simple docstring'''





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




def 	a_      (    SCREAMING_SNAKE_CASE__					:      float		,			SCREAMING_SNAKE_CASE__					:      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 	a_      (    SCREAMING_SNAKE_CASE__					:      float		,			SCREAMING_SNAKE_CASE__					:      float		,			SCREAMING_SNAKE_CASE__					:      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'     )
       _lowerCamelCase       :		Dict		=(height**2 + (radius_a - radius_a) ** 2) ** 0.5
       return pi * ((slant_height * (radius_a + radius_a)) + radius_a**2 + radius_a**2)




def 	a_      (    SCREAMING_SNAKE_CASE__					:      float		,			SCREAMING_SNAKE_CASE__					:      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 	a_      (    SCREAMING_SNAKE_CASE__					:      float		,			SCREAMING_SNAKE_CASE__					:      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(SCREAMING_SNAKE_CASE__		,			2     ) * torus_radius * tube_radius




def 	a_      (    SCREAMING_SNAKE_CASE__					:      float		,			SCREAMING_SNAKE_CASE__					:      float     ):
       '''simple docstring'''





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




def 	a_      (    SCREAMING_SNAKE_CASE__					:      float     ):
       '''simple docstring'''





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




def 	a_      (    SCREAMING_SNAKE_CASE__					:      float		,			SCREAMING_SNAKE_CASE__					:      float     ):
       '''simple docstring'''





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




def 	a_      (    SCREAMING_SNAKE_CASE__					:      float		,			SCREAMING_SNAKE_CASE__					:      float		,			SCREAMING_SNAKE_CASE__					:      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'     )
       _lowerCamelCase       :		Dict		=(sidea + sidea + sidea) / 2
       _lowerCamelCase       :		int		=sqrt(
           semi_perimeter
           * (semi_perimeter - sidea)
           * (semi_perimeter - sidea)
           * (semi_perimeter - sidea)     )
       return area




def 	a_      (    SCREAMING_SNAKE_CASE__					:      float		,			SCREAMING_SNAKE_CASE__					:      float     ):
       '''simple docstring'''





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




def 	a_      (    SCREAMING_SNAKE_CASE__					:      float		,			SCREAMING_SNAKE_CASE__					:      float		,			SCREAMING_SNAKE_CASE__					:      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 	a_      (    SCREAMING_SNAKE_CASE__					:      float     ):
       '''simple docstring'''





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




def 	a_      (    SCREAMING_SNAKE_CASE__					:      float		,			SCREAMING_SNAKE_CASE__					:      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 	a_      (    SCREAMING_SNAKE_CASE__					:      float		,			SCREAMING_SNAKE_CASE__					:      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 	a_      (    SCREAMING_SNAKE_CASE__					:      int		,			SCREAMING_SNAKE_CASE__					:      float     ):
       '''simple docstring'''





       if not isinstance(SCREAMING_SNAKE_CASE__		,			SCREAMING_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 ...configuration_utils import PretrainedConfig
from ...utils import logging


lowerCamelCase											=       logging.get_logger(__name__)

lowerCamelCase											=       {
    'transfo-xl-wt103': 'https://huggingface.co/transfo-xl-wt103/resolve/main/config.json',
}




class A  (   UpperCamelCase_     ):
      UpperCamelCase__							:  Dict      ='transfo-xl'
      UpperCamelCase__							:  int      =['mems']
      UpperCamelCase__							:  List[str]      ={
          'n_token': 'vocab_size',
          'hidden_size': 'd_model',
          'num_attention_heads': 'n_head',
          'num_hidden_layers': 'n_layer',
      }






      def __init__(					self						:     Tuple			,   lowercase_						:     List[Any]=26_7735			,   lowercase_						:     List[Any]=[2_0000, 4_0000, 20_0000]			,   lowercase_						:     Tuple=1024			,   lowercase_						:     Optional[int]=1024			,   lowercase_						:     str=16			,   lowercase_						:     int=64			,   lowercase_						:     Any=4096			,   lowercase_						:     List[Any]=4			,   lowercase_						:     List[Any]=False			,   lowercase_						:     List[str]=18			,   lowercase_						:     Tuple=1600			,   lowercase_						:     List[str]=1000			,   lowercase_						:     Any=True			,   lowercase_						:     str=True			,   lowercase_						:     Optional[int]=0			,   lowercase_						:     List[Any]=-1			,   lowercase_						:     Optional[int]=True			,   lowercase_						:     Any=0.1			,   lowercase_						:     Tuple=0.0			,   lowercase_						:     str=True			,   lowercase_						:     Union[str, Any]="normal"			,   lowercase_						:     Dict=0.01			,   lowercase_						:     Optional[Any]=0.01			,   lowercase_						:     List[Any]=0.02			,   lowercase_						:     List[Any]=1E-5			,   lowercase_						:     Tuple=0			,   **lowercase_						:     Tuple			,   )					->						Dict:
             """simple docstring"""




             _lowerCamelCase       :		Optional[Any]		=vocab_size
             _lowerCamelCase       :		Optional[Any]		=[]
             self.cutoffs.extend(lowercase_ )
             if proj_share_all_but_first:
                    _lowerCamelCase       :		List[str]		=[False] + [True] * len(self.cutoffs )
             else:
                    _lowerCamelCase       :		str		=[False] + [False] * len(self.cutoffs )
             _lowerCamelCase       :		str		=d_model
             _lowerCamelCase       :		str		=d_embed
             _lowerCamelCase       :		str		=d_head
             _lowerCamelCase       :		Dict		=d_inner
             _lowerCamelCase       :		Union[str, Any]		=div_val
             _lowerCamelCase       :		Dict		=pre_lnorm
             _lowerCamelCase       :		Tuple		=n_layer
             _lowerCamelCase       :		Optional[Any]		=n_head
             _lowerCamelCase       :		List[Any]		=mem_len
             _lowerCamelCase       :		List[Any]		=same_length
             _lowerCamelCase       :		Optional[int]		=attn_type
             _lowerCamelCase       :		List[str]		=clamp_len
             _lowerCamelCase       :		int		=sample_softmax
             _lowerCamelCase       :		List[Any]		=adaptive
             _lowerCamelCase       :		List[str]		=dropout
             _lowerCamelCase       :		Any		=dropatt
             _lowerCamelCase       :		Dict		=untie_r
             _lowerCamelCase       :		List[Any]		=init
             _lowerCamelCase       :		List[str]		=init_range
             _lowerCamelCase       :		int		=proj_init_std
             _lowerCamelCase       :		Optional[int]		=init_std
             _lowerCamelCase       :		Tuple		=layer_norm_epsilon
             super().__init__(eos_token_id=lowercase_			,   **lowercase_ )






      @property
      def        lowerCamelCase       (					self						:     List[str] )					->						Dict:
             """simple docstring"""




             logger.info(F'''The model {self.model_type} is one of the few models that has no sequence length limit.''' )
             return -1






      @max_position_embeddings.setter
      def        lowerCamelCase       (					self						:     int			,   lowercase_						:     int )					->						List[str]:
             """simple docstring"""




             raise NotImplementedError(
                 F'''The model {self.model_type} is one of the few models that has no sequence length limit.''' )


