




"""simple docstring"""





from __future__ import annotations

from math import pi, pow

def 		lowerCAmelCase				(			lowerCamelCase		):
						'''simple docstring'''


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

def 		lowerCAmelCase				(			lowerCamelCase   ,      lowerCamelCase		):
						'''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   ,      lowerCamelCase   ,      lowerCamelCase		):
						'''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		)		)

						snake_case__							:       Dict				      =       (
						    (radius_a - radius_a + centers_distance)
						    * (radius_a + radius_a - centers_distance)
						    / (2 * centers_distance)
						)
						snake_case__							:       Optional[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   ,      lowerCamelCase   ,      lowerCamelCase		):
						'''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   ,      lowerCamelCase   ,      lowerCamelCase		):
						'''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   ,      lowerCamelCase		):
						'''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   ,      lowerCamelCase		):
						'''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   ,      lowerCamelCase		):
						'''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   ,      lowerCamelCase		):
						'''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		):
						'''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		):
						'''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   ,      lowerCamelCase		):
						'''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   ,      lowerCamelCase   ,      lowerCamelCase		):
						'''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   ,      lowerCamelCase   ,      lowerCamelCase		):
						'''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   ,      lowerCamelCase		):
						'''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"""





from typing import TYPE_CHECKING

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


_lowercase						   =     {
    """configuration_utils""": ["""GenerationConfig"""],
    """streamers""": ["""TextIteratorStreamer""", """TextStreamer"""],
}

try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							_lowercase						   =     [
							    """Constraint""",
							    """ConstraintListState""",
							    """DisjunctiveConstraint""",
							    """PhrasalConstraint""",
							]
							_lowercase						   =     [
							    """BeamHypotheses""",
							    """BeamScorer""",
							    """BeamSearchScorer""",
							    """ConstrainedBeamSearchScorer""",
							]
							_lowercase						   =     [
							    """EpsilonLogitsWarper""",
							    """EtaLogitsWarper""",
							    """ForcedBOSTokenLogitsProcessor""",
							    """ForcedEOSTokenLogitsProcessor""",
							    """HammingDiversityLogitsProcessor""",
							    """InfNanRemoveLogitsProcessor""",
							    """LogitsProcessor""",
							    """LogitsProcessorList""",
							    """LogitsWarper""",
							    """MinLengthLogitsProcessor""",
							    """MinNewTokensLengthLogitsProcessor""",
							    """NoBadWordsLogitsProcessor""",
							    """NoRepeatNGramLogitsProcessor""",
							    """PrefixConstrainedLogitsProcessor""",
							    """RepetitionPenaltyLogitsProcessor""",
							    """SequenceBiasLogitsProcessor""",
							    """EncoderRepetitionPenaltyLogitsProcessor""",
							    """TemperatureLogitsWarper""",
							    """TopKLogitsWarper""",
							    """TopPLogitsWarper""",
							    """TypicalLogitsWarper""",
							    """EncoderNoRepeatNGramLogitsProcessor""",
							    """ExponentialDecayLengthPenalty""",
							    """LogitNormalization""",
							]
							_lowercase						   =     [
							    """MaxNewTokensCriteria""",
							    """MaxLengthCriteria""",
							    """MaxTimeCriteria""",
							    """StoppingCriteria""",
							    """StoppingCriteriaList""",
							    """validate_stopping_criteria""",
							]
							_lowercase						   =     [
							    """GenerationMixin""",
							    """top_k_top_p_filtering""",
							    """GreedySearchEncoderDecoderOutput""",
							    """GreedySearchDecoderOnlyOutput""",
							    """SampleEncoderDecoderOutput""",
							    """SampleDecoderOnlyOutput""",
							    """BeamSearchEncoderDecoderOutput""",
							    """BeamSearchDecoderOnlyOutput""",
							    """BeamSampleEncoderDecoderOutput""",
							    """BeamSampleDecoderOnlyOutput""",
							    """ContrastiveSearchEncoderDecoderOutput""",
							    """ContrastiveSearchDecoderOnlyOutput""",
							]

try:
							if not is_tf_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							_lowercase						   =     [
							    """TFForcedBOSTokenLogitsProcessor""",
							    """TFForcedEOSTokenLogitsProcessor""",
							    """TFLogitsProcessor""",
							    """TFLogitsProcessorList""",
							    """TFLogitsWarper""",
							    """TFMinLengthLogitsProcessor""",
							    """TFNoBadWordsLogitsProcessor""",
							    """TFNoRepeatNGramLogitsProcessor""",
							    """TFRepetitionPenaltyLogitsProcessor""",
							    """TFTemperatureLogitsWarper""",
							    """TFTopKLogitsWarper""",
							    """TFTopPLogitsWarper""",
							    """TFForceTokensLogitsProcessor""",
							    """TFSuppressTokensAtBeginLogitsProcessor""",
							    """TFSuppressTokensLogitsProcessor""",
							]
							_lowercase						   =     [
							    """TFGenerationMixin""",
							    """tf_top_k_top_p_filtering""",
							    """TFGreedySearchDecoderOnlyOutput""",
							    """TFGreedySearchEncoderDecoderOutput""",
							    """TFSampleEncoderDecoderOutput""",
							    """TFSampleDecoderOnlyOutput""",
							    """TFBeamSearchEncoderDecoderOutput""",
							    """TFBeamSearchDecoderOnlyOutput""",
							    """TFBeamSampleEncoderDecoderOutput""",
							    """TFBeamSampleDecoderOnlyOutput""",
							    """TFContrastiveSearchEncoderDecoderOutput""",
							    """TFContrastiveSearchDecoderOnlyOutput""",
							]

try:
							if not is_flax_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							_lowercase						   =     [
							    """FlaxForcedBOSTokenLogitsProcessor""",
							    """FlaxForcedEOSTokenLogitsProcessor""",
							    """FlaxLogitsProcessor""",
							    """FlaxLogitsProcessorList""",
							    """FlaxLogitsWarper""",
							    """FlaxMinLengthLogitsProcessor""",
							    """FlaxTemperatureLogitsWarper""",
							    """FlaxTopKLogitsWarper""",
							    """FlaxTopPLogitsWarper""",
							]
							_lowercase						   =     [
							    """FlaxGenerationMixin""",
							    """FlaxGreedySearchOutput""",
							    """FlaxSampleOutput""",
							    """FlaxBeamSearchOutput""",
							]

if TYPE_CHECKING:
							from .configuration_utils import GenerationConfig
							from .streamers import TextIteratorStreamer, TextStreamer

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .beam_constraints import Constraint, ConstraintListState, DisjunctiveConstraint, PhrasalConstraint
														from .beam_search import BeamHypotheses, BeamScorer, BeamSearchScorer, ConstrainedBeamSearchScorer
														from .logits_process import (
														    EncoderNoRepeatNGramLogitsProcessor,
														    EncoderRepetitionPenaltyLogitsProcessor,
														    EpsilonLogitsWarper,
														    EtaLogitsWarper,
														    ExponentialDecayLengthPenalty,
														    ForcedBOSTokenLogitsProcessor,
														    ForcedEOSTokenLogitsProcessor,
														    HammingDiversityLogitsProcessor,
														    InfNanRemoveLogitsProcessor,
														    LogitNormalization,
														    LogitsProcessor,
														    LogitsProcessorList,
														    LogitsWarper,
														    MinLengthLogitsProcessor,
														    MinNewTokensLengthLogitsProcessor,
														    NoBadWordsLogitsProcessor,
														    NoRepeatNGramLogitsProcessor,
														    PrefixConstrainedLogitsProcessor,
														    RepetitionPenaltyLogitsProcessor,
														    SequenceBiasLogitsProcessor,
														    TemperatureLogitsWarper,
														    TopKLogitsWarper,
														    TopPLogitsWarper,
														    TypicalLogitsWarper,
														)
														from .stopping_criteria import (
														    MaxLengthCriteria,
														    MaxNewTokensCriteria,
														    MaxTimeCriteria,
														    StoppingCriteria,
														    StoppingCriteriaList,
														    validate_stopping_criteria,
														)
														from .utils import (
														    BeamSampleDecoderOnlyOutput,
														    BeamSampleEncoderDecoderOutput,
														    BeamSearchDecoderOnlyOutput,
														    BeamSearchEncoderDecoderOutput,
														    ContrastiveSearchDecoderOnlyOutput,
														    ContrastiveSearchEncoderDecoderOutput,
														    GenerationMixin,
														    GreedySearchDecoderOnlyOutput,
														    GreedySearchEncoderDecoderOutput,
														    SampleDecoderOnlyOutput,
														    SampleEncoderDecoderOutput,
														    top_k_top_p_filtering,
														)

							try:
														if not is_tf_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .tf_logits_process import (
														    TFForcedBOSTokenLogitsProcessor,
														    TFForcedEOSTokenLogitsProcessor,
														    TFForceTokensLogitsProcessor,
														    TFLogitsProcessor,
														    TFLogitsProcessorList,
														    TFLogitsWarper,
														    TFMinLengthLogitsProcessor,
														    TFNoBadWordsLogitsProcessor,
														    TFNoRepeatNGramLogitsProcessor,
														    TFRepetitionPenaltyLogitsProcessor,
														    TFSuppressTokensAtBeginLogitsProcessor,
														    TFSuppressTokensLogitsProcessor,
														    TFTemperatureLogitsWarper,
														    TFTopKLogitsWarper,
														    TFTopPLogitsWarper,
														)
														from .tf_utils import (
														    TFBeamSampleDecoderOnlyOutput,
														    TFBeamSampleEncoderDecoderOutput,
														    TFBeamSearchDecoderOnlyOutput,
														    TFBeamSearchEncoderDecoderOutput,
														    TFContrastiveSearchDecoderOnlyOutput,
														    TFContrastiveSearchEncoderDecoderOutput,
														    TFGenerationMixin,
														    TFGreedySearchDecoderOnlyOutput,
														    TFGreedySearchEncoderDecoderOutput,
														    TFSampleDecoderOnlyOutput,
														    TFSampleEncoderDecoderOutput,
														    tf_top_k_top_p_filtering,
														)

							try:
														if not is_flax_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .flax_logits_process import (
														    FlaxForcedBOSTokenLogitsProcessor,
														    FlaxForcedEOSTokenLogitsProcessor,
														    FlaxLogitsProcessor,
														    FlaxLogitsProcessorList,
														    FlaxLogitsWarper,
														    FlaxMinLengthLogitsProcessor,
														    FlaxTemperatureLogitsWarper,
														    FlaxTopKLogitsWarper,
														    FlaxTopPLogitsWarper,
														)
														from .flax_utils import FlaxBeamSearchOutput, FlaxGenerationMixin, FlaxGreedySearchOutput, FlaxSampleOutput
else:
							import sys

							_lowercase						   =     _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)


