code: 
  
  
  
  
  from __future__ import annotations
  
  from math import pi, pow
  def 						lowerCAmelCase_       (	__a )       ->			float:
  
  
  
  
  
  							"""simple docstring"""
  
  
  
  
  
  							if side_length < 0:
  														raise ValueError('''vol_cube() only accepts non-negative values''' )
  							return pow(__a	,	3 )
  def 						lowerCAmelCase_       (	__a	,	__a )       ->			float:
  
  
  
  
  
  							"""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(__a	,	2 ) * (3 * radius - height)
  def 						lowerCAmelCase_       (	__a	,	__a	,	__a )       ->			float:
  
  
  
  
  
  							"""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(__a	,	__a ) )
  
  							SCREAMING_SNAKE_CASE			: Dict	     =(
  							    (radius_a - radius_a + centers_distance)
  							    * (radius_a + radius_a - centers_distance)
  							    / (2 * centers_distance)
  							)
  							SCREAMING_SNAKE_CASE			: Tuple	     =(
  							    (radius_a - radius_a + centers_distance)
  							    * (radius_a + radius_a - centers_distance)
  							    / (2 * centers_distance)
  							)
  
  							return vol_spherical_cap(__a	,	__a ) + vol_spherical_cap(__a	,	__a )
  def 						lowerCAmelCase_       (	__a	,	__a	,	__a )       ->			float:
  
  
  
  
  
  							"""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(__a	,	__a ) )
  
  							return (
  							    vol_sphere(__a )
  							    + vol_sphere(__a )
  							    - vol_spheres_intersect(__a	,	__a	,	__a )
  							)
  def 						lowerCAmelCase_       (	__a	,	__a	,	__a )       ->			float:
  
  
  
  
  
  							"""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 						lowerCAmelCase_       (	__a	,	__a )       ->			float:
  
  
  
  
  
  							"""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 						lowerCAmelCase_       (	__a	,	__a )       ->			float:
  
  
  
  
  
  							"""simple docstring"""
  
  
  
  
  
  							if height < 0 or radius < 0:
  														raise ValueError('''vol_right_circ_cone() only accepts non-negative values''' )
  							return pi * pow(__a	,	2 ) * height / 3.0
  def 						lowerCAmelCase_       (	__a	,	__a )       ->			float:
  
  
  
  
  
  							"""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 						lowerCAmelCase_       (	__a	,	__a )       ->			float:
  
  
  
  
  
  							"""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 						lowerCAmelCase_       (	__a )       ->			float:
  
  
  
  
  
  							"""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(__a	,	3 )
  def 						lowerCAmelCase_       (	__a )       ->			float:
  
  
  
  
  
  							"""simple docstring"""
  
  
  
  
  
  							if radius < 0:
  														raise ValueError('''vol_hemisphere() only accepts non-negative values''' )
  							# Volume is radius cubed * pi * 2/3
  							return pow(__a	,	3 ) * pi * 2 / 3
  def 						lowerCAmelCase_       (	__a	,	__a )       ->			float:
  
  
  
  
  
  							"""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(__a	,	2 ) * height * pi
  def 						lowerCAmelCase_       (	__a	,	__a	,	__a )       ->			float:
  
  
  
  
  
  							"""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(__a	,	2 ) - pow(__a	,	2 )) * height
  def 						lowerCAmelCase_       (	__a	,	__a	,	__a )       ->			float:
  
  
  
  
  
  							"""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(__a	,	2 ) + pow(__a	,	2 ) + radius_a * radius_a)
  							)
  def 						lowerCAmelCase_       (	__a	,	__a )       ->			float:
  
  
  
  
  
  							"""simple docstring"""
  
  
  
  
  
  							if torus_radius < 0 or tube_radius < 0:
  														raise ValueError('''vol_torus() only accepts non-negative values''' )
  							return 2 * pow(__a	,	2 ) * torus_radius * pow(__a	,	2 )
  def 						lowerCAmelCase_       (	)       ->			List[Any]:
  
  
  
  
  
  							"""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()
  
  
  
  
  
  
  
style_context: 
  
  
  
  
  import os
  from shutil import copyfile
  from typing import List, Optional, Tuple
  
  from ...tokenization_utils_fast import AddedToken, PreTrainedTokenizerFast
  from ...utils import logging
  
  
  _A							    =	logging.get_logger(__name__)
  
  _A							    =	{"""vocab_file""": """spiece.model""", """tokenizer_file""": """tokenizer.json"""}
  
  _A							    =	{
      """vocab_file""": {
          """TsinghuaAI/CPM-Generate""": """https://huggingface.co/TsinghuaAI/CPM-Generate/resolve/main/spiece.model""",
      },
      """tokenizer_file""": {
          """TsinghuaAI/CPM-Generate""": """https://huggingface.co/TsinghuaAI/CPM-Generate/resolve/main/tokenizer.json""",
      },
  }
  
  
  class 							_lowerCAmelCase		(     UpperCamelCase__	):
  
  
  
  
  				def __init__( self		,		snake_case_=None		,		snake_case_=None		,		snake_case_=False		,		snake_case_=True		,		snake_case_=False		,		snake_case_="<s>"		,		snake_case_="</s>"		,		snake_case_="<unk>"		,		snake_case_="<sep>"		,		snake_case_="<pad>"		,		snake_case_="<cls>"		,		snake_case_="<mask>"		,		snake_case_=["<eop>", "<eod>"]		,		**snake_case_		,		)    ->      str:
  											SCREAMING_SNAKE_CASE			: Optional[int]	     =AddedToken(snake_case_		,		lstrip=snake_case_		,		rstrip=snake_case_							) if isinstance(snake_case_		,		snake_case_							) else mask_token
  
  											super().__init__(
  											    vocab_file=snake_case_		,		tokenizer_file=snake_case_		,		do_lower_case=snake_case_		,		remove_space=snake_case_		,		keep_accents=snake_case_		,		bos_token=snake_case_		,		eos_token=snake_case_		,		unk_token=snake_case_		,		sep_token=snake_case_		,		pad_token=snake_case_		,		cls_token=snake_case_		,		mask_token=snake_case_		,		additional_special_tokens=snake_case_		,		**snake_case_		,		)
  
  											SCREAMING_SNAKE_CASE			: Dict	     =3
  											SCREAMING_SNAKE_CASE			: Dict	     =do_lower_case
  											SCREAMING_SNAKE_CASE			: int	     =remove_space
  											SCREAMING_SNAKE_CASE			: Optional[Any]	     =keep_accents
  											SCREAMING_SNAKE_CASE			: Tuple	     =vocab_file
  											SCREAMING_SNAKE_CASE			: Optional[Any]	     =False if not self.vocab_file else True
  
  											try:
  																		import jieba
  											except ModuleNotFoundError as error:
  																		raise error.__class__(
  																		    '''You need to install jieba to use CpmTokenizer or CpmTokenizerFast. '''
  																		    '''See https://pypi.org/project/jieba/ for installation.'''							)
  											SCREAMING_SNAKE_CASE			: str	     =jieba
  											SCREAMING_SNAKE_CASE			: Dict	     =str.maketrans(''' \n'''		,		'''\u2582\u2583'''							)
  
  
  
  
  				def     __a		( self		,		snake_case_		,		snake_case_ = None							)    ->      List[int]:
  											SCREAMING_SNAKE_CASE			: Dict	     =[self.sep_token_id]
  											SCREAMING_SNAKE_CASE			: Any	     =[self.cls_token_id]
  											if token_ids_a is None:
  																		return token_ids_a + sep + cls
  											return token_ids_a + sep + token_ids_a + sep + cls
  
  
  
  
  				def     __a		( self		,		snake_case_		,		snake_case_ = None							)    ->      List[int]:
  											SCREAMING_SNAKE_CASE			: Union[str, Any]	     =[self.sep_token_id]
  											SCREAMING_SNAKE_CASE			: Union[str, Any]	     =[2]
  
  											if token_ids_a is None:
  																		return len(token_ids_a + sep							) * [0] + cls_segment_id
  											return len(token_ids_a + sep							) * [0] + len(token_ids_a + sep							) * [1] + cls_segment_id
  
  
  
  
  				def     __a		( self		,		snake_case_		,		snake_case_ = None							)    ->      Tuple[str]:
  											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(snake_case_							):
  																		logger.error(F'Vocabulary path ({save_directory}) should be a directory'							)
  																		return
  											SCREAMING_SNAKE_CASE			: Union[str, Any]	     =os.path.join(
  											    snake_case_		,		(filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''vocab_file''']							)
  
  											if os.path.abspath(self.vocab_file							) != os.path.abspath(snake_case_							):
  																		copyfile(self.vocab_file		,		snake_case_							)
  
  											return (out_vocab_file,)
  
  
  
  
  				def     __a		( self		,		snake_case_		,		*snake_case_		,		**snake_case_							)    ->      Optional[Any]:
  											SCREAMING_SNAKE_CASE			: int	     =[
  											    ''' '''.join([x.translate(self.translator							) for x in self.jieba.cut(snake_case_		,		cut_all=snake_case_							)]							)
  											    for text in batch_text_or_text_pairs
  											]
  											return super()._batch_encode_plus(snake_case_		,		*snake_case_		,		**snake_case_							)
  
  
  
  
  
  
  
  				def     __a		( self		,		*snake_case_		,		**snake_case_							)    ->      str:
  											SCREAMING_SNAKE_CASE			: List[Any]	     =super()._decode(*snake_case_		,		**snake_case_							)
  											SCREAMING_SNAKE_CASE			: List[Any]	     =text.replace(''' '''		,		''''''							).replace('''\u2582'''		,		''' '''							).replace('''\u2583'''		,		'''\n'''							)
  											return text
  
  
  
  
  
  
  