
from __future__ import annotations

from math import pi, pow

def 					SCREAMING_SNAKE_CASE  (   __UpperCamelCase			:    int | float							)			->							float:

				"""simple docstring"""







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

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

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

				A__	:						Tuple								=				(
				    (radius_a - radius_a + centers_distance)
				    * (radius_a + radius_a - centers_distance)
				    / (2 * centers_distance)
				)
				A__	:						Dict								=				(
				    (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 					SCREAMING_SNAKE_CASE  (   __UpperCamelCase			:    float				,    __UpperCamelCase			:    float				,    __UpperCamelCase			:    float							)			->							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(__UpperCamelCase				,    __UpperCamelCase							)							)

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

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

				"""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 					SCREAMING_SNAKE_CASE  (   __UpperCamelCase			:    float				,    __UpperCamelCase			:    float							)			->							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 					SCREAMING_SNAKE_CASE  (   __UpperCamelCase			:    float				,    __UpperCamelCase			:    float							)			->							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 					SCREAMING_SNAKE_CASE  (   __UpperCamelCase			:    float							)			->							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(__UpperCamelCase				,    3							)

def 					SCREAMING_SNAKE_CASE  (   __UpperCamelCase			:    float							)			->							float:

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

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

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

def 					SCREAMING_SNAKE_CASE  (   __UpperCamelCase			:    float				,    __UpperCamelCase			:    float							)			->							float:

				"""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 					SCREAMING_SNAKE_CASE  (   )			->							Union[str, 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()

from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available


_SCREAMING_SNAKE_CASE     :   Optional[Any]							 =      {
    'configuration_flaubert': ['FLAUBERT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'FlaubertConfig', 'FlaubertOnnxConfig'],
    'tokenization_flaubert': ['FlaubertTokenizer'],
}

try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					_SCREAMING_SNAKE_CASE     :   Tuple							 =      [
					    'FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST',
					    'FlaubertForMultipleChoice',
					    'FlaubertForQuestionAnswering',
					    'FlaubertForQuestionAnsweringSimple',
					    'FlaubertForSequenceClassification',
					    'FlaubertForTokenClassification',
					    'FlaubertModel',
					    'FlaubertWithLMHeadModel',
					    'FlaubertPreTrainedModel',
					]

try:
					if not is_tf_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					_SCREAMING_SNAKE_CASE     :   Dict							 =      [
					    'TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST',
					    'TFFlaubertForMultipleChoice',
					    'TFFlaubertForQuestionAnsweringSimple',
					    'TFFlaubertForSequenceClassification',
					    'TFFlaubertForTokenClassification',
					    'TFFlaubertModel',
					    'TFFlaubertPreTrainedModel',
					    'TFFlaubertWithLMHeadModel',
					]


if TYPE_CHECKING:
					from .configuration_flaubert import FLAUBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, FlaubertConfig, FlaubertOnnxConfig
					from .tokenization_flaubert import FlaubertTokenizer

					try:
										if not is_torch_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_flaubert import (
										    FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
										    FlaubertForMultipleChoice,
										    FlaubertForQuestionAnswering,
										    FlaubertForQuestionAnsweringSimple,
										    FlaubertForSequenceClassification,
										    FlaubertForTokenClassification,
										    FlaubertModel,
										    FlaubertPreTrainedModel,
										    FlaubertWithLMHeadModel,
										)

					try:
										if not is_tf_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_tf_flaubert import (
										    TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
										    TFFlaubertForMultipleChoice,
										    TFFlaubertForQuestionAnsweringSimple,
										    TFFlaubertForSequenceClassification,
										    TFFlaubertForTokenClassification,
										    TFFlaubertModel,
										    TFFlaubertPreTrainedModel,
										    TFFlaubertWithLMHeadModel,
										)

else:
					import sys

					_SCREAMING_SNAKE_CASE     :   List[Any]							 =      _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)