"""simple docstring"""


from __future__ import annotations

from math import pi, pow







def    UpperCAmelCase       (						UpperCAmelCase   )							-> float:
     if side_length < 0:
          raise ValueError('vol_cube() only accepts non-negative values'   )
     return pow(SCREAMING_SNAKE_CASE__		,   3   )







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







def    UpperCAmelCase       (						UpperCAmelCase		,   UpperCAmelCase		,   UpperCAmelCase   )							-> float:
     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(SCREAMING_SNAKE_CASE__		,   SCREAMING_SNAKE_CASE__   )   )

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

     return vol_spherical_cap(SCREAMING_SNAKE_CASE__		,   SCREAMING_SNAKE_CASE__   ) + vol_spherical_cap(SCREAMING_SNAKE_CASE__		,   SCREAMING_SNAKE_CASE__   )







def    UpperCAmelCase       (						UpperCAmelCase		,   UpperCAmelCase		,   UpperCAmelCase   )							-> float:

     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(SCREAMING_SNAKE_CASE__		,   SCREAMING_SNAKE_CASE__   )   )

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







def    UpperCAmelCase       (						UpperCAmelCase		,   UpperCAmelCase		,   UpperCAmelCase   )							-> float:
     if width < 0 or height < 0 or length < 0:
          raise ValueError('vol_cuboid() only accepts non-negative values'   )
     return float(width * height * length   )







def    UpperCAmelCase       (						UpperCAmelCase		,   UpperCAmelCase   )							-> float:
     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    UpperCAmelCase       (						UpperCAmelCase		,   UpperCAmelCase   )							-> float:
     if height < 0 or radius < 0:
          raise ValueError('vol_right_circ_cone() only accepts non-negative values'   )
     return pi * pow(SCREAMING_SNAKE_CASE__		,   2   ) * height / 3.0







def    UpperCAmelCase       (						UpperCAmelCase		,   UpperCAmelCase   )							-> float:
     if height < 0 or area_of_base < 0:
          raise ValueError('vol_prism() only accepts non-negative values'   )
     return float(area_of_base * height   )







def    UpperCAmelCase       (						UpperCAmelCase		,   UpperCAmelCase   )							-> float:
     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    UpperCAmelCase       (						UpperCAmelCase   )							-> float:
     if radius < 0:
          raise ValueError('vol_sphere() only accepts non-negative values'   )
     # Volume is 4/3 * pi * radius cubed
     return 4 / 3 * pi * pow(SCREAMING_SNAKE_CASE__		,   3   )







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







def    UpperCAmelCase       (						UpperCAmelCase		,   UpperCAmelCase   )							-> float:
     if height < 0 or radius < 0:
          raise ValueError('vol_circular_cylinder() only accepts non-negative values'   )
     # Volume is radius squared * height * pi
     return pow(SCREAMING_SNAKE_CASE__		,   2   ) * height * pi







def    UpperCAmelCase       (						UpperCAmelCase		,   UpperCAmelCase		,   UpperCAmelCase   )							-> float:
     # Volume - (outer_radius squared - inner_radius squared) * pi * height
     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(SCREAMING_SNAKE_CASE__		,   2   ) - pow(SCREAMING_SNAKE_CASE__		,   2   )) * height







def    UpperCAmelCase       (						UpperCAmelCase		,   UpperCAmelCase		,   UpperCAmelCase   )							-> float:
     # Volume is 1/3 * pi * height *
     #           (radius_1 squared + radius_2 squared + radius_1 * radius_2)
     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(SCREAMING_SNAKE_CASE__		,   2   ) + pow(SCREAMING_SNAKE_CASE__		,   2   ) + radius_a * radius_a)
     )







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







def    UpperCAmelCase       (						)							-> Optional[Any]:
     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 typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


snake_case_  :							Any            =	{
    "configuration_dpr": ["DPR_PRETRAINED_CONFIG_ARCHIVE_MAP", "DPRConfig"],
    "tokenization_dpr": [
        "DPRContextEncoderTokenizer",
        "DPRQuestionEncoderTokenizer",
        "DPRReaderOutput",
        "DPRReaderTokenizer",
    ],
}


try:
					if not is_tokenizers_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					snake_case_  :							str            =	[
					    "DPRContextEncoderTokenizerFast",
					    "DPRQuestionEncoderTokenizerFast",
					    "DPRReaderTokenizerFast",
					]

try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					snake_case_  :							Optional[int]            =	[
					    "DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST",
					    "DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST",
					    "DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST",
					    "DPRContextEncoder",
					    "DPRPretrainedContextEncoder",
					    "DPRPreTrainedModel",
					    "DPRPretrainedQuestionEncoder",
					    "DPRPretrainedReader",
					    "DPRQuestionEncoder",
					    "DPRReader",
					]

try:
					if not is_tf_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					snake_case_  :							Dict            =	[
					    "TF_DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST",
					    "TF_DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST",
					    "TF_DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST",
					    "TFDPRContextEncoder",
					    "TFDPRPretrainedContextEncoder",
					    "TFDPRPretrainedQuestionEncoder",
					    "TFDPRPretrainedReader",
					    "TFDPRQuestionEncoder",
					    "TFDPRReader",
					]


if TYPE_CHECKING:
					from .configuration_dpr import DPR_PRETRAINED_CONFIG_ARCHIVE_MAP, DPRConfig
					from .tokenization_dpr import (
					    DPRContextEncoderTokenizer,
					    DPRQuestionEncoderTokenizer,
					    DPRReaderOutput,
					    DPRReaderTokenizer,
					)

					try:
										if not is_tokenizers_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .tokenization_dpr_fast import (
										    DPRContextEncoderTokenizerFast,
										    DPRQuestionEncoderTokenizerFast,
										    DPRReaderTokenizerFast,
										)

					try:
										if not is_torch_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_dpr import (
										    DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST,
										    DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST,
										    DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST,
										    DPRContextEncoder,
										    DPRPretrainedContextEncoder,
										    DPRPreTrainedModel,
										    DPRPretrainedQuestionEncoder,
										    DPRPretrainedReader,
										    DPRQuestionEncoder,
										    DPRReader,
										)

					try:
										if not is_tf_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_tf_dpr import (
										    TF_DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST,
										    TF_DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST,
										    TF_DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST,
										    TFDPRContextEncoder,
										    TFDPRPretrainedContextEncoder,
										    TFDPRPretrainedQuestionEncoder,
										    TFDPRPretrainedReader,
										    TFDPRQuestionEncoder,
										    TFDPRReader,
										)

else:
					import sys

					snake_case_  :							List[str]            =	_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)





