



'''simple docstring'''




def       __lowerCamelCase  (					_lowercase	,				_lowercase		)      ->			Tuple:
							# "extended trapezoidal rule"
							# int(f) = dx/2 * (f1 + 2f2 + ... + fn)
							UpperCAmelCase     :		List[str]							     =		(boundary[1] - boundary[0]) / steps
							UpperCAmelCase     :		Optional[int]							     =		boundary[0]
							UpperCAmelCase     :		Tuple							     =		boundary[1]
							UpperCAmelCase     :		Optional[int]							     =		make_points(_lowercase	,				_lowercase	,				_lowercase		)
							UpperCAmelCase     :		Tuple							     =		0.0
							y += (h / 2.0) * f(_lowercase		)
							for i in x_i:
														# print(i)
														y += h * f(_lowercase		)
							y += (h / 2.0) * f(_lowercase		)
							return y



def       __lowerCamelCase  (					_lowercase	,				_lowercase	,				_lowercase		)      ->			Optional[int]:
							UpperCAmelCase     :		Union[str, Any]							     =		a + h
							while x < (b - h):
														yield x
														UpperCAmelCase     :		str							     =		x + h



def       __lowerCamelCase  (					_lowercase		)      ->			List[str]:  # enter your function here
							UpperCAmelCase     :		Optional[Any]							     =		(x - 0) * (x - 0)
							return y



def       __lowerCamelCase  (					)      ->			List[Any]:
							UpperCAmelCase     :		Optional[int]							     =		0.0  # Lower bound of integration
							UpperCAmelCase     :		str							     =		1.0  # Upper bound of integration
							UpperCAmelCase     :		Optional[int]							     =		10.0  # define number of steps or resolution
							UpperCAmelCase     :		Optional[int]							     =		[a, b]  # define boundary of integration
							UpperCAmelCase     :		List[Any]							     =		method_a(_lowercase	,				_lowercase		)
							print(F'''y = {y}'''		)


if __name__ == "__main__":
							main()






'''simple docstring'''




def       __lowerCamelCase  (					_lowercase	,				_lowercase		)      ->			int:
							if b == 0:
														return 1
							if (b % 2) == 0:
														return actual_power(_lowercase	,				int(b / 2		)		) * actual_power(_lowercase	,				int(b / 2		)		)
							else:
														return a * actual_power(_lowercase	,				int(b / 2		)		) * actual_power(_lowercase	,				int(b / 2		)		)



def       __lowerCamelCase  (					_lowercase	,				_lowercase		)      ->			float:
							if b < 0:
														return 1 / actual_power(_lowercase	,				_lowercase		)
							return actual_power(_lowercase	,				_lowercase		)


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

