






from __future__ import annotations

from math import pi, pow






def  UpperCAmelCase__						(    lowerCamelCase	:			int | float    ):


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






def  UpperCAmelCase__						(    lowerCamelCase	:			float			,lowerCamelCase	:			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(__UpperCamelCase			,2    ) * (3 * radius - height)






def  UpperCAmelCase__						(    lowerCamelCase	:			float			,lowerCamelCase	:			float			,lowerCamelCase	:			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(__UpperCamelCase			,__UpperCamelCase    )    )

   lowerCamelCase									=(
       (radius_a - radius_a + centers_distance)
       * (radius_a + radius_a - centers_distance)
       / (2 * centers_distance)
   )
   lowerCamelCase									=(
       (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  UpperCAmelCase__						(    lowerCamelCase	:			float			,lowerCamelCase	:			float			,lowerCamelCase	:			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(__UpperCamelCase			,__UpperCamelCase    )    )

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






def  UpperCAmelCase__						(    lowerCamelCase	:			float			,lowerCamelCase	:			float			,lowerCamelCase	:			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__						(    lowerCamelCase	:			float			,lowerCamelCase	:			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__						(    lowerCamelCase	:			float			,lowerCamelCase	:			float    ):


   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  UpperCAmelCase__						(    lowerCamelCase	:			float			,lowerCamelCase	:			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__						(    lowerCamelCase	:			float			,lowerCamelCase	:			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__						(    lowerCamelCase	:			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(__UpperCamelCase			,3    )






def  UpperCAmelCase__						(    lowerCamelCase	:			float    ):


   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  UpperCAmelCase__						(    lowerCamelCase	:			float			,lowerCamelCase	:			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(__UpperCamelCase			,2    ) * height * pi






def  UpperCAmelCase__						(    lowerCamelCase	:			float			,lowerCamelCase	:			float			,lowerCamelCase	:			float    ):


   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  UpperCAmelCase__						(    lowerCamelCase	:			float			,lowerCamelCase	:			float			,lowerCamelCase	:			float    ):


   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  UpperCAmelCase__						(    lowerCamelCase	:			float			,lowerCamelCase	:			float    ):


   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  UpperCAmelCase__						(    ):
   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_torch_available, is_vision_available


__lowercase    =				{
    '''configuration_videomae''': ['''VIDEOMAE_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''VideoMAEConfig'''],
}

try:
				if not is_torch_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				__lowercase    =				[
				    '''VIDEOMAE_PRETRAINED_MODEL_ARCHIVE_LIST''',
				    '''VideoMAEForPreTraining''',
				    '''VideoMAEModel''',
				    '''VideoMAEPreTrainedModel''',
				    '''VideoMAEForVideoClassification''',
				]

try:
				if not is_vision_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				__lowercase    =				['''VideoMAEFeatureExtractor''']
				__lowercase    =				['''VideoMAEImageProcessor''']

if TYPE_CHECKING:
				from .configuration_videomae import VIDEOMAE_PRETRAINED_CONFIG_ARCHIVE_MAP, VideoMAEConfig

				try:
								if not is_torch_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_videomae import (
								    VIDEOMAE_PRETRAINED_MODEL_ARCHIVE_LIST,
								    VideoMAEForPreTraining,
								    VideoMAEForVideoClassification,
								    VideoMAEModel,
								    VideoMAEPreTrainedModel,
								)

				try:
								if not is_vision_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .feature_extraction_videomae import VideoMAEFeatureExtractor
								from .image_processing_videomae import VideoMAEImageProcessor

else:
				import sys

				__lowercase    =				_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)



