





from __future__ import annotations

from math import pi, pow



def   __lowercase  ( _SCREAMING_SNAKE_CASE      )					->  int:


      '''simple docstring'''


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



def   __lowercase  ( _SCREAMING_SNAKE_CASE					,		_SCREAMING_SNAKE_CASE      )					->  Dict:


      '''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(_UpperCAmelCase					,		2      ) * (3 * radius - height)



def   __lowercase  ( _SCREAMING_SNAKE_CASE					,		_SCREAMING_SNAKE_CASE					,		_SCREAMING_SNAKE_CASE      )					->  Optional[int]:


      '''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(_UpperCAmelCase					,		_UpperCAmelCase      )      )

      SCREAMING_SNAKE_CASE						=		(
          (radius_a - radius_a + centers_distance)
          * (radius_a + radius_a - centers_distance)
          / (2 * centers_distance)
      )
      SCREAMING_SNAKE_CASE						=		(
          (radius_a - radius_a + centers_distance)
          * (radius_a + radius_a - centers_distance)
          / (2 * centers_distance)
      )

      return vol_spherical_cap(_UpperCAmelCase					,		_UpperCAmelCase      ) + vol_spherical_cap(_UpperCAmelCase					,		_UpperCAmelCase      )



def   __lowercase  ( _SCREAMING_SNAKE_CASE					,		_SCREAMING_SNAKE_CASE					,		_SCREAMING_SNAKE_CASE      )					->  str:


      '''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(_UpperCAmelCase					,		_UpperCAmelCase      )      )

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



def   __lowercase  ( _SCREAMING_SNAKE_CASE					,		_SCREAMING_SNAKE_CASE					,		_SCREAMING_SNAKE_CASE      )					->  Optional[int]:


      '''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   __lowercase  ( _SCREAMING_SNAKE_CASE					,		_SCREAMING_SNAKE_CASE      )					->  List[str]:


      '''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   __lowercase  ( _SCREAMING_SNAKE_CASE					,		_SCREAMING_SNAKE_CASE      )					->  List[Any]:


      '''simple docstring'''


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



def   __lowercase  ( _SCREAMING_SNAKE_CASE					,		_SCREAMING_SNAKE_CASE      )					->  Tuple:


      '''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   __lowercase  ( _SCREAMING_SNAKE_CASE					,		_SCREAMING_SNAKE_CASE      )					->  int:


      '''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   __lowercase  ( _SCREAMING_SNAKE_CASE      )					->  Optional[int]:


      '''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(_UpperCAmelCase					,		3      )



def   __lowercase  ( _SCREAMING_SNAKE_CASE      )					->  Dict:


      '''simple docstring'''


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



def   __lowercase  ( _SCREAMING_SNAKE_CASE					,		_SCREAMING_SNAKE_CASE      )					->  List[str]:


      '''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(_UpperCAmelCase					,		2      ) * height * pi



def   __lowercase  ( _SCREAMING_SNAKE_CASE					,		_SCREAMING_SNAKE_CASE					,		_SCREAMING_SNAKE_CASE      )					->  Union[str, Any]:


      '''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(_UpperCAmelCase					,		2      ) - pow(_UpperCAmelCase					,		2      )) * height



def   __lowercase  ( _SCREAMING_SNAKE_CASE					,		_SCREAMING_SNAKE_CASE					,		_SCREAMING_SNAKE_CASE      )					->  List[str]:


      '''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(_UpperCAmelCase					,		2      ) + pow(_UpperCAmelCase					,		2      ) + radius_a * radius_a)
      )



def   __lowercase  ( _SCREAMING_SNAKE_CASE					,		_SCREAMING_SNAKE_CASE      )					->  int:


      '''simple docstring'''


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



def   __lowercase  ( )					->  List[str]:


      '''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"""

import os
from shutil import copyfile
from typing import List, Optional, Tuple

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import is_sentencepiece_available, logging


if is_sentencepiece_available():
		from .tokenization_xglm import XGLMTokenizer
else:
		_lowerCamelCase	:      Union[str, Any]   =							None


_lowerCamelCase	:      Optional[Any]   =							logging.get_logger(__name__)

_lowerCamelCase	:      Tuple   =							{'vocab_file': 'sentencepiece.bpe.model', 'tokenizer_file': 'tokenizer.json'}

_lowerCamelCase	:      Union[str, Any]   =							{
    'vocab_file': {
        'facebook/xglm-564M': 'https://huggingface.co/facebook/xglm-564M/resolve/main/sentencepiece.bpe.model',
    },
    'tokenizer_file': {
        'facebook/xglm-564M': 'https://huggingface.co/facebook/xglm-564M/resolve/main/tokenizer.json',
    },
}

_lowerCamelCase	:      Dict   =							{
    'facebook/xglm-564M': 2048,
}

class 							lowercase   (     __UpperCAmelCase):
				__lowerCAmelCase     :     Optional[int]								= VOCAB_FILES_NAMES
				__lowerCAmelCase     :     Tuple								= PRETRAINED_VOCAB_FILES_MAP
				__lowerCAmelCase     :     List[Any]								= PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
				__lowerCAmelCase     :     Union[str, Any]								= ["""input_ids""", """attention_mask"""]
				__lowerCAmelCase     :     List[str]								= XGLMTokenizer







				def __init__(				self :       str   ,  _lowerCamelCase :       int=None   ,  _lowerCamelCase :       Any=None   ,  _lowerCamelCase :       List[str]="<s>"   ,  _lowerCamelCase :       int="</s>"   ,  _lowerCamelCase :       Any="</s>"   ,  _lowerCamelCase :       Optional[int]="<s>"   ,  _lowerCamelCase :       List[Any]="<unk>"   ,  _lowerCamelCase :       Optional[int]="<pad>"   ,  **_lowerCamelCase :       List[Any]   ,  ):



					"""simple docstring"""

					A_	:					Tuple						 =		7
					A_	:					Dict						 =		[F"""<madeupword{i}>""" for i in range(self.num_madeup_words							)]

					A_	:					str						 =		kwargs.get('''additional_special_tokens'''   ,  []							)
					kwargs["additional_special_tokens"] += [
					    word for word in madeup_words if word not in kwargs["additional_special_tokens"]
					]

					super().__init__(
					    _lowerCamelCase   ,  tokenizer_file=_lowerCamelCase   ,  bos_token=_lowerCamelCase   ,  eos_token=_lowerCamelCase   ,  sep_token=_lowerCamelCase   ,  cls_token=_lowerCamelCase   ,  unk_token=_lowerCamelCase   ,  pad_token=_lowerCamelCase   ,  **_lowerCamelCase   ,  )

					A_	:					Tuple						 =		vocab_file
					A_	:					str						 =		False if not self.vocab_file else True







				def        a_	(				self :       List[Any]   ,  _lowerCamelCase :       List[int]   ,  _lowerCamelCase :       Optional[List[int]] = None							):



					"""simple docstring"""

					if token_ids_a is None:
						return [self.sep_token_id] + token_ids_a
					A_	:					List[Any]						 =		[self.sep_token_id]
					return sep + token_ids_a + sep + sep + token_ids_a







				def        a_	(				self :       List[str]   ,  _lowerCamelCase :       List[int]   ,  _lowerCamelCase :       Optional[List[int]] = None							):



					"""simple docstring"""

					A_	:					Dict						 =		[self.sep_token_id]

					if token_ids_a is None:
						return len(sep + token_ids_a							) * [0]
					return len(sep + token_ids_a + sep + sep + token_ids_a							) * [0]







				def        a_	(				self :       List[str]   ,  _lowerCamelCase :       str   ,  _lowerCamelCase :       Optional[str] = None							):



					"""simple docstring"""

					if not self.can_save_slow_tokenizer:
						raise ValueError(
						    '''Your fast tokenizer does not have the necessary information to save the vocabulary for a slow '''
						    '''tokenizer.'''							)

					if not os.path.isdir(_lowerCamelCase							):
						logger.error(F"""Vocabulary path ({save_directory}) should be a directory."""							)
						return
					A_	:					Tuple						 =		os.path.join(
					    _lowerCamelCase   ,  (filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''vocab_file''']							)

					if os.path.abspath(self.vocab_file							) != os.path.abspath(_lowerCamelCase							):
						copyfile(self.vocab_file   ,  _lowerCamelCase							)

					return (out_vocab_file,)





