'''simple docstring'''


from __future__ import annotations

from math import pi, pow


def 					_lowerCamelCase    (      lowerCamelCase_					:							int | float   ):



     """simple docstring"""





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


def 					_lowerCamelCase    (      lowerCamelCase_					:							float	,     lowerCamelCase_					:							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(lowerCamelCase_	,     2   ) * (3 * radius - height)


def 					_lowerCamelCase    (      lowerCamelCase_					:							float	,     lowerCamelCase_					:							float	,     lowerCamelCase_					:							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(lowerCamelCase_	,     lowerCamelCase_   )   )

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

     return vol_spherical_cap(lowerCamelCase_	,     lowerCamelCase_   ) + vol_spherical_cap(lowerCamelCase_	,     lowerCamelCase_   )


def 					_lowerCamelCase    (      lowerCamelCase_					:							float	,     lowerCamelCase_					:							float	,     lowerCamelCase_					:							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(lowerCamelCase_	,     lowerCamelCase_   )   )

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


def 					_lowerCamelCase    (      lowerCamelCase_					:							float	,     lowerCamelCase_					:							float	,     lowerCamelCase_					:							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    (      lowerCamelCase_					:							float	,     lowerCamelCase_					:							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    (      lowerCamelCase_					:							float	,     lowerCamelCase_					:							float   ):



     """simple docstring"""





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


def 					_lowerCamelCase    (      lowerCamelCase_					:							float	,     lowerCamelCase_					:							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    (      lowerCamelCase_					:							float	,     lowerCamelCase_					:							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    (      lowerCamelCase_					:							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(lowerCamelCase_	,     3   )


def 					_lowerCamelCase    (      lowerCamelCase_					:							float   ):



     """simple docstring"""





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


def 					_lowerCamelCase    (      lowerCamelCase_					:							float	,     lowerCamelCase_					:							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(lowerCamelCase_	,     2   ) * height * pi


def 					_lowerCamelCase    (      lowerCamelCase_					:							float	,     lowerCamelCase_					:							float	,     lowerCamelCase_					:							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(lowerCamelCase_	,     2   ) - pow(lowerCamelCase_	,     2   )) * height


def 					_lowerCamelCase    (      lowerCamelCase_					:							float	,     lowerCamelCase_					:							float	,     lowerCamelCase_					:							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(lowerCamelCase_	,     2   ) + pow(lowerCamelCase_	,     2   ) + radius_a * radius_a)
     )


def 					_lowerCamelCase    (      lowerCamelCase_					:							float	,     lowerCamelCase_					:							float   ):



     """simple docstring"""





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


def 					_lowerCamelCase    (      ):



     """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 argparse
import logging

import datasets
from tokenizers import Tokenizer, decoders, normalizers, pre_tokenizers, processors
from tokenizers.models import Unigram
from tokenizers.trainers import UnigramTrainer

from transformers import AlbertTokenizerFast


snake_case__     :			Optional[int]      			=  logging.getLogger(__name__)


def 					_lowerCamelCase    (      ):



     """simple docstring"""





     UpperCAmelCase_							:   List[Any]   =      argparse.ArgumentParser(description='Train a unigram tokenizer on the wikitext dataset.'   )
     parser.add_argument(
         '--dataset_name'	,     type=lowerCamelCase_	,     default='wikitext'	,     help='Name of the training. Explore datasets at: hf.co/datasets.'	,     )
     parser.add_argument(
         '--dataset_config'	,     type=lowerCamelCase_	,     default='wikitext-103-raw-v1'	,     help='Configuration name of the dataset.'   )
     parser.add_argument(
         '--batch_size'	,     type=lowerCamelCase_	,     default=1000	,     help='Batch size during training.'	,     )
     parser.add_argument(
         '--vocab_size'	,     type=lowerCamelCase_	,     default=10048	,     help='Size of the desired vocabulary.'	,     )
     parser.add_argument(
         '--limit'	,     default=lowerCamelCase_	,     type=lowerCamelCase_	,     help='Limit the number of shards (used for debugging).'	,     )
     parser.add_argument(
         '--export_to_hub'	,     action='store_true'	,     )

     UpperCAmelCase_							:   str   =      parser.parse_args()
     return args


def 					_lowerCamelCase    (      lowerCamelCase_					:							Dict   ):



     """simple docstring"""





     UpperCAmelCase_							:   List[Any]   =      datasets.load_dataset(args.dataset_name	,     args.dataset_config	,     split='train'   )

     if args.limit is not None:
          UpperCAmelCase_							:   Union[str, Any]   =      min(len(lowerCamelCase_   )	,     args.limit   )
          UpperCAmelCase_							:   int   =      dataset.select(range(lowerCamelCase_   )   )
          logger.info(F'''Limiting the dataset to {args.limit} entries.'''   )

     def batch_iterator():
          for i in range(0	,     len(lowerCamelCase_   )	,     args.batch_size   ):
               yield dataset[i : i + args.batch_size]["text"]

    # Prepare the tokenizer.
     UpperCAmelCase_							:   Optional[Any]   =      Tokenizer(Unigram()   )
     UpperCAmelCase_							:   Union[str, Any]   =      normalizers.Sequence([normalizers.Replace('``'	,     '"'   ), normalizers.Replace('\'\''	,     '"'   )]   )
     UpperCAmelCase_							:   Any   =      pre_tokenizers.Metaspace()

     # Prepare the trainer.
     UpperCAmelCase_							:   Tuple   =      UnigramTrainer(
         unk_token='<unk>'	,     special_tokens=['[CLS]', '[SEP]', '<unk>', '<pad>', '[MASK]']	,     vocab_size=args.vocab_size	,     )

     logger.info('Training the tokenizer.'   )
     tokenizer.train_from_iterator(batch_iterator()	,     trainer=lowerCamelCase_   )
     logger.info('Tokenizer training complete!'   )

     UpperCAmelCase_							:   List[str]   =      tokenizer.token_to_id('[CLS]'   )
     UpperCAmelCase_							:   Optional[int]   =      tokenizer.token_to_id('[SEP]'   )
     UpperCAmelCase_							:   Optional[Any]   =      processors.TemplateProcessing(
         single='[CLS]:0 $A:0 [SEP]:0'	,     pair='[CLS]:0 $A:0 [SEP]:0 $B:1 [SEP]:1'	,     special_tokens=[
             ('[CLS]', cls_token_id),
             ('[SEP]', sep_token_id),
         ]	,     )
     UpperCAmelCase_							:   Any   =      decoders.Metaspace()

     if args.export_to_hub:
          logger.info('Exporting the trained tokenzier to Hub.'   )
          UpperCAmelCase_							:   str   =      AlbertTokenizerFast(tokenizer_object=lowerCamelCase_   )
          new_tokenizer.push_to_hub('unigram-tokenizer-dataset'   )


if __name__ == "__main__":
 snake_case__     :			Optional[Any]      			=  parse_args()
 main(args)






