






"""simple docstring"""





from __future__ import annotations

from math import pi, pow






def 							A(    snake_case_						):
       """simple docstring"""





       if side_length < 0:
              raise ValueError("vol_cube() only accepts non-negative values"						)
       return pow(snake_case_		,  3						)






def 							A(    snake_case_		,  snake_case_						):
       """simple docstring"""





       if height < 0 or radius < 0:
              raise ValueError("vol_spherical_cap() only accepts non-negative values"						)
       # Volume is 1/3 pi * height squared * (3 * radius - height)
       return 1 / 3 * pi * pow(snake_case_		,  2						) * (3 * radius - height)






def 							A(    snake_case_		,  snake_case_		,  snake_case_						):
       """simple docstring"""





       if radius_a < 0 or radius_a < 0 or centers_distance < 0:
              raise ValueError("vol_spheres_intersect() only accepts non-negative values"						)
       if centers_distance == 0:
              return vol_sphere(min(snake_case_		,  snake_case_						)						)

       lowercase__:							Optional[Any]         =     (
           (radius_a - radius_a + centers_distance)
           * (radius_a + radius_a - centers_distance)
           / (2 * centers_distance)
       )
       lowercase__:							int         =     (
           (radius_a - radius_a + centers_distance)
           * (radius_a + radius_a - centers_distance)
           / (2 * centers_distance)
       )

       return vol_spherical_cap(snake_case_		,  snake_case_						) + vol_spherical_cap(snake_case_		,  snake_case_						)






def 							A(    snake_case_		,  snake_case_		,  snake_case_						):
       """simple docstring"""





       if radius_a <= 0 or radius_a <= 0 or centers_distance < 0:
              raise ValueError(
                  "vol_spheres_union() only accepts non-negative values, non-zero radius"						)

       if centers_distance == 0:
              return vol_sphere(max(snake_case_		,  snake_case_						)						)

       return (
           vol_sphere(snake_case_						)
           + vol_sphere(snake_case_						)
           - vol_spheres_intersect(snake_case_		,  snake_case_		,  snake_case_						)
       )






def 							A(    snake_case_		,  snake_case_		,  snake_case_						):
       """simple docstring"""





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






def 							A(    snake_case_		,  snake_case_						):
       """simple docstring"""





       if height < 0 or area_of_base < 0:
              raise ValueError("vol_cone() only accepts non-negative values"						)
       return area_of_base * height / 3.0






def 							A(    snake_case_		,  snake_case_						):
       """simple docstring"""





       if height < 0 or radius < 0:
              raise ValueError("vol_right_circ_cone() only accepts non-negative values"						)
       return pi * pow(snake_case_		,  2						) * height / 3.0






def 							A(    snake_case_		,  snake_case_						):
       """simple docstring"""





       if height < 0 or area_of_base < 0:
              raise ValueError("vol_prism() only accepts non-negative values"						)
       return float(area_of_base * height						)






def 							A(    snake_case_		,  snake_case_						):
       """simple docstring"""





       if height < 0 or area_of_base < 0:
              raise ValueError("vol_pyramid() only accepts non-negative values"						)
       return area_of_base * height / 3.0






def 							A(    snake_case_						):
       """simple docstring"""





       if radius < 0:
              raise ValueError("vol_sphere() only accepts non-negative values"						)
       # Volume is 4/3 * pi * radius cubed
       return 4 / 3 * pi * pow(snake_case_		,  3						)






def 							A(    snake_case_						):
       """simple docstring"""





       if radius < 0:
              raise ValueError("vol_hemisphere() only accepts non-negative values"						)
       # Volume is radius cubed * pi * 2/3
       return pow(snake_case_		,  3						) * pi * 2 / 3






def 							A(    snake_case_		,  snake_case_						):
       """simple docstring"""





       if height < 0 or radius < 0:
              raise ValueError("vol_circular_cylinder() only accepts non-negative values"						)
       # Volume is radius squared * height * pi
       return pow(snake_case_		,  2						) * height * pi






def 							A(    snake_case_		,  snake_case_		,  snake_case_						):
       """simple docstring"""





       if inner_radius < 0 or outer_radius < 0 or height < 0:
              raise ValueError(
                  "vol_hollow_circular_cylinder() only accepts non-negative values"						)
       if outer_radius <= inner_radius:
              raise ValueError("outer_radius must be greater than inner_radius"						)
       return pi * (pow(snake_case_		,  2						) - pow(snake_case_		,  2						)) * height






def 							A(    snake_case_		,  snake_case_		,  snake_case_						):
       """simple docstring"""





       if radius_a < 0 or radius_a < 0 or height < 0:
              raise ValueError("vol_conical_frustum() only accepts non-negative values"						)
       return (
           1
           / 3
           * pi
           * height
           * (pow(snake_case_		,  2						) + pow(snake_case_		,  2						) + radius_a * radius_a)
       )






def 							A(    snake_case_		,  snake_case_						):
       """simple docstring"""





       if torus_radius < 0 or tube_radius < 0:
              raise ValueError("vol_torus() only accepts non-negative values"						)
       return 2 * pow(snake_case_		,  2						) * torus_radius * pow(snake_case_		,  2						)






def 							A(    ):
       """simple docstring"""





       print("Volumes:"						)
       print(F"""Cube: {vol_cube(2						) = }"""						)  # = 8
       print(F"""Cuboid: {vol_cuboid(2		,  2		,  2						) = }"""						)  # = 8
       print(F"""Cone: {vol_cone(2		,  2						) = }"""						)  # ~= 1.33
       print(F"""Right Circular Cone: {vol_right_circ_cone(2		,  2						) = }"""						)  # ~= 8.38
       print(F"""Prism: {vol_prism(2		,  2						) = }"""						)  # = 4
       print(F"""Pyramid: {vol_pyramid(2		,  2						) = }"""						)  # ~= 1.33
       print(F"""Sphere: {vol_sphere(2						) = }"""						)  # ~= 33.5
       print(F"""Hemisphere: {vol_hemisphere(2						) = }"""						)  # ~= 16.75
       print(F"""Circular Cylinder: {vol_circular_cylinder(2		,  2						) = }"""						)  # ~= 25.1
       print(F"""Torus: {vol_torus(2		,  2						) = }"""						)  # ~= 157.9
       print(F"""Conical Frustum: {vol_conical_frustum(2		,  2		,  4						) = }"""						)  # ~= 58.6
       print(F"""Spherical cap: {vol_spherical_cap(1		,  2						) = }"""						)  # ~= 5.24
       print(F"""Spheres intersetion: {vol_spheres_intersect(2		,  2		,  1						) = }"""						)  # ~= 21.21
       print(F"""Spheres union: {vol_spheres_union(2		,  2		,  1						) = }"""						)  # ~= 45.81
       print(
           F"""Hollow Circular Cylinder: {vol_hollow_circular_cylinder(1		,  2		,  3						) = }"""						)  # ~= 28.3


if __name__ == "__main__":
  main()











'''simple docstring'''


from collections import OrderedDict
from typing import Any, List, Mapping, Optional

from ... import PreTrainedTokenizer, TensorType, is_torch_available
from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfigWithPast, PatchingSpec
from ...utils import logging


lowercase											=      logging.get_logger(__name__)

lowercase											=      {
    '''gpt2''': '''https://huggingface.co/gpt2/resolve/main/config.json''',
    '''gpt2-medium''': '''https://huggingface.co/gpt2-medium/resolve/main/config.json''',
    '''gpt2-large''': '''https://huggingface.co/gpt2-large/resolve/main/config.json''',
    '''gpt2-xl''': '''https://huggingface.co/gpt2-xl/resolve/main/config.json''',
    '''distilgpt2''': '''https://huggingface.co/distilgpt2/resolve/main/config.json''',
}







class 						UpperCAmelCase						(		__a):


 '''simple docstring'''




 __magic_name__       :			str	=   "gpt2"
 __magic_name__       :			str	=   ["past_key_values"]
 __magic_name__       :			Dict	=   {
     "hidden_size": "n_embd",
     "max_position_embeddings": "n_positions",
     "num_attention_heads": "n_head",
     "num_hidden_layers": "n_layer",
 }




 def __init__( self				,	lowerCAmelCase_=5_0_2_5_7				,	lowerCAmelCase_=1_0_2_4				,	lowerCAmelCase_=7_6_8				,	lowerCAmelCase_=1_2				,	lowerCAmelCase_=1_2				,	lowerCAmelCase_=None				,	lowerCAmelCase_="gelu_new"				,	lowerCAmelCase_=0.1				,	lowerCAmelCase_=0.1				,	lowerCAmelCase_=0.1				,	lowerCAmelCase_=1e-5				,	lowerCAmelCase_=0.0_2				,	lowerCAmelCase_="cls_index"				,	lowerCAmelCase_=True				,	lowerCAmelCase_=None				,	lowerCAmelCase_=True				,	lowerCAmelCase_=0.1				,	lowerCAmelCase_=True				,	lowerCAmelCase_=True				,	lowerCAmelCase_=5_0_2_5_6				,	lowerCAmelCase_=5_0_2_5_6				,	lowerCAmelCase_=False				,	lowerCAmelCase_=False				,	**lowerCAmelCase_				,	)			->   Dict:



      """simple docstring"""







      a_									=vocab_size
      a_									=n_positions
      a_									=n_embd
      a_									=n_layer
      a_									=n_head
      a_									=n_inner
      a_									=activation_function
      a_									=resid_pdrop
      a_									=embd_pdrop
      a_									=attn_pdrop
      a_									=layer_norm_epsilon
      a_									=initializer_range
      a_									=summary_type
      a_									=summary_use_proj
      a_									=summary_activation
      a_									=summary_first_dropout
      a_									=summary_proj_to_labels
      a_									=scale_attn_weights
      a_									=use_cache
      a_									=scale_attn_by_inverse_layer_idx
      a_									=reorder_and_upcast_attn

      a_									=bos_token_id
      a_									=eos_token_id

      super().__init__(bos_token_id=lowerCAmelCase_				,	eos_token_id=lowerCAmelCase_				,	**lowerCAmelCase_)







class 						UpperCAmelCase						(		__a):


 '''simple docstring'''




 def __init__( self				,	lowerCAmelCase_				,	lowerCAmelCase_ = "default"				,	lowerCAmelCase_ = None				,	lowerCAmelCase_ = False				,	)			->   List[str]:



      """simple docstring"""







      super().__init__(lowerCAmelCase_				,	task=lowerCAmelCase_				,	patching_specs=lowerCAmelCase_				,	use_past=lowerCAmelCase_)
      if not getattr(self._config				,	"pad_token_id"				,	lowerCAmelCase_):
           # TODO: how to do that better?
           a_									=0




 @property
 def    lowercase_	( self)			->   Mapping[str, Mapping[int, str]]:



      """simple docstring"""







      a_									=OrderedDict({"input_ids": {0: "batch", 1: "sequence"}})
      if self.use_past:
           self.fill_with_past_key_values_(lowerCAmelCase_				,	direction="inputs")
           a_									={0: "batch", 1: "past_sequence + sequence"}
      else:
           a_									={0: "batch", 1: "sequence"}

      return common_inputs




 @property
 def    lowercase_	( self)			->   int:



      """simple docstring"""







      return self._config.n_layer




 @property
 def    lowercase_	( self)			->   int:



      """simple docstring"""







      return self._config.n_head




 def    lowercase_	( self				,	lowerCAmelCase_				,	lowerCAmelCase_ = -1				,	lowerCAmelCase_ = -1				,	lowerCAmelCase_ = False				,	lowerCAmelCase_ = None				,	)			->   Mapping[str, Any]:



      """simple docstring"""







      a_									=super(lowerCAmelCase_				,	self).generate_dummy_inputs(
          lowerCAmelCase_				,	batch_size=lowerCAmelCase_				,	seq_length=lowerCAmelCase_				,	is_pair=lowerCAmelCase_				,	framework=lowerCAmelCase_)

      # We need to order the input in the way they appears in the forward()
      a_									=OrderedDict({"input_ids": common_inputs["input_ids"]})

      # Need to add the past_keys
      if self.use_past:
           if not is_torch_available():
                raise ValueError("Cannot generate dummy past_keys inputs without PyTorch installed.")
           else:
                import torch

                a_		,    a_									=common_inputs["input_ids"].shape
                # Not using the same length for past_key_values
                a_									=seqlen + 2
                a_									=(
                    batch,
                    self.num_attention_heads,
                    past_key_values_length,
                    self._config.hidden_size // self.num_attention_heads,
                )
                a_									=[
                    (torch.zeros(lowerCAmelCase_), torch.zeros(lowerCAmelCase_)) for _ in range(self.num_layers)
                ]

      a_									=common_inputs["attention_mask"]
      if self.use_past:
           a_									=ordered_inputs["attention_mask"].dtype
           a_									=torch.cat(
               [ordered_inputs["attention_mask"], torch.ones(lowerCAmelCase_				,	lowerCAmelCase_				,	dtype=lowerCAmelCase_)]				,	dim=1)

      return ordered_inputs




 @property
 def    lowercase_	( self)			->   int:



      """simple docstring"""







      return 1_3


