


'''simple docstring'''
from __future__ import annotations

from math import pi, pow



def 				lowerCAmelCase__	(       UpperCAmelCase     ):






       """simple docstring"""





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



def 				lowerCAmelCase__	(       UpperCAmelCase    ,       UpperCAmelCase     ):






       """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(lowercase_    ,       2     ) * (3 * radius - height)



def 				lowerCAmelCase__	(       UpperCAmelCase    ,       UpperCAmelCase    ,       UpperCAmelCase     ):






       """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(lowercase_    ,       lowercase_     )     )

       snake_case__					:	Any          =					(
           (radius_a - radius_a + centers_distance)
           * (radius_a + radius_a - centers_distance)
           / (2 * centers_distance)
       )
       snake_case__					:	Union[str, Any]          =					(
           (radius_a - radius_a + centers_distance)
           * (radius_a + radius_a - centers_distance)
           / (2 * centers_distance)
       )

       return vol_spherical_cap(lowercase_    ,       lowercase_     ) + vol_spherical_cap(lowercase_    ,       lowercase_     )



def 				lowerCAmelCase__	(       UpperCAmelCase    ,       UpperCAmelCase    ,       UpperCAmelCase     ):






       """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(lowercase_    ,       lowercase_     )     )

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



def 				lowerCAmelCase__	(       UpperCAmelCase    ,       UpperCAmelCase    ,       UpperCAmelCase     ):






       """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__	(       UpperCAmelCase    ,       UpperCAmelCase     ):






       """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__	(       UpperCAmelCase    ,       UpperCAmelCase     ):






       """simple docstring"""





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



def 				lowerCAmelCase__	(       UpperCAmelCase    ,       UpperCAmelCase     ):






       """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__	(       UpperCAmelCase    ,       UpperCAmelCase     ):






       """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__	(       UpperCAmelCase     ):






       """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(lowercase_    ,       3     )



def 				lowerCAmelCase__	(       UpperCAmelCase     ):






       """simple docstring"""





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



def 				lowerCAmelCase__	(       UpperCAmelCase    ,       UpperCAmelCase     ):






       """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(lowercase_    ,       2     ) * height * pi



def 				lowerCAmelCase__	(       UpperCAmelCase    ,       UpperCAmelCase    ,       UpperCAmelCase     ):






       """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(lowercase_    ,       2     ) - pow(lowercase_    ,       2     )) * height



def 				lowerCAmelCase__	(       UpperCAmelCase    ,       UpperCAmelCase    ,       UpperCAmelCase     ):






       """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(lowercase_    ,       2     ) + pow(lowercase_    ,       2     ) + radius_a * radius_a)
       )



def 				lowerCAmelCase__	(       UpperCAmelCase    ,       UpperCAmelCase     ):






       """simple docstring"""





       if torus_radius < 0 or tube_radius < 0:
              raise ValueError("""vol_torus() only accepts non-negative values"""     )
       return 2 * pow(lowercase_    ,       2     ) * torus_radius * pow(lowercase_    ,       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 numpy as np






def 						_lowercase						(      lowercase_    ):



		'''simple docstring'''







		_snake_case			,       _snake_case      			=			a.shape
		_snake_case      			=			min(lowercase_		,				lowercase_    )
		_snake_case      			=			np.eye(lowercase_    )
		_snake_case      			=			a.copy()

		for k in range(t - 1    ):
				# select a column of modified matrix A':
				_snake_case      			=			r[k:, [k]]
				# construct first basis vector
				_snake_case      			=			np.zeros_like(lowercase_    )
				_snake_case      			=			1.0
				# determine scaling factor
				_snake_case      			=			np.linalg.norm(lowercase_    )
				# construct vector v for Householder reflection
				_snake_case      			=			x + np.sign(x[0]    ) * alpha * ea
				v /= np.linalg.norm(lowercase_    )

				# construct the Householder matrix
				_snake_case      			=			np.eye(m - k    ) - 2.0 * v @ v.T
				# pad with ones and zeros as necessary
				_snake_case      			=			np.block([[np.eye(lowercase_    ), np.zeros((k, m - k)    )], [np.zeros((m - k, k)    ), q_k]]    )

				_snake_case      			=			q @ q_k.T
				_snake_case      			=			q_k @ r

		return q, r


if __name__ == "__main__":
						import doctest

						doctest.testmod()





