





from __future__ import annotations

from numpy import array, cos, cross, floataa, radians, sin
from numpy.typing import NDArray







def   __lowerCamelCase   (				__a  :float       ,	__a  :float       ,	__a  :bool = False       )						->							list[float]:






		"""simple docstring"""

		if radian_mode:
				return [magnitude * cos(__a       ), magnitude * sin(__a       )]
		return [magnitude * cos(radians(__a       )       ), magnitude * sin(radians(__a       )       )]







def   __lowerCamelCase   (				__a  :NDArray[floataa]       ,	__a  :NDArray[floataa]       ,	__a  :float = 1_0**-1       )						->							bool:






		"""simple docstring"""

		A__     =  cross(__a       ,	__a       )
		A__     =  sum(__a       )
		return abs(__a       ) < eps


if __name__ == "__main__":
					# Test to check if it works
					A       :   List[str]					= array(
					    [
					        polar_force(718.4, 1_8_0 - 3_0),
					        polar_force(879.54, 4_5),
					        polar_force(1_0_0, -9_0),
					    ]
					)

					A       :   NDArray[floataa]					= array([[0, 0], [0, 0], [0, 0]])

					assert in_static_equilibrium(forces, location)

					# Problem 1 in image_data/2D_problems.jpg
					A       :   Union[str, Any]					= array(
					    [
					        polar_force(3_0 * 9.81, 1_5),
					        polar_force(2_1_5, 1_8_0 - 4_5),
					        polar_force(2_6_4, 9_0 - 3_0),
					    ]
					)

					A       :   int					= array([[0, 0], [0, 0], [0, 0]])

					assert in_static_equilibrium(forces, location)

					# Problem in image_data/2D_problems_1.jpg
					A       :   Optional[int]					= array([[0, -2_0_0_0], [0, -1_2_0_0], [0, 1_5_6_0_0], [0, -1_2_4_0_0]])

					A       :   Optional[int]					= array([[0, 0], [6, 0], [1_0, 0], [1_2, 0]])

					assert in_static_equilibrium(forces, location)

					import doctest

					doctest.testmod()










def   __lowerCamelCase   (				__a  :int       ,	__a  :int       )						->							Optional[Any]:






		"""simple docstring"""

		if b == 0:
				return 1
		if (b % 2) == 0:
				return actual_power(__a       ,	int(b / 2       )       ) * actual_power(__a       ,	int(b / 2       )       )
		else:
				return a * actual_power(__a       ,	int(b / 2       )       ) * actual_power(__a       ,	int(b / 2       )       )







def   __lowerCamelCase   (				__a  :int       ,	__a  :int       )						->							float:






		"""simple docstring"""

		if b < 0:
				return 1 / actual_power(__a       ,	__a       )
		return actual_power(__a       ,	__a       )


if __name__ == "__main__":
					print(power(-2, -3))



