'''simple docstring'''


import math
import random
from typing import Any

from .hill_climbing import SearchProblem





def       lowerCAmelCase					(		UpperCamelCase__				:   Optional[int]    ,					UpperCamelCase__				:   bool = True    ,					UpperCamelCase__				:   float = math.inf    ,					UpperCamelCase__				:   float = -math.inf    ,					UpperCamelCase__				:   float = math.inf    ,					UpperCamelCase__				:   float = -math.inf    ,					UpperCamelCase__				:   bool = False    ,					UpperCamelCase__				:   float = 1_0_0    ,					UpperCamelCase__				:   float = 0.01    ,					UpperCamelCase__				:   float = 1    ,					):


	"""simple docstring"""
	__UpperCAmelCase							=			False
	__UpperCAmelCase							=			search_prob
	__UpperCAmelCase							=			start_temperate
	__UpperCAmelCase							=			[]
	__UpperCAmelCase							=			0
	__UpperCAmelCase							=			None

	while not search_end:
		__UpperCAmelCase							=			current_state.score()
		if best_state is None or current_score > best_state.score():
			__UpperCAmelCase							=			current_state
		scores.append(UpperCamelCase__       )
		iterations += 1
		__UpperCAmelCase							=			None
		__UpperCAmelCase							=			current_state.get_neighbors()
		while (
		    next_state is None and neighbors
		):  # till we do not find a neighbor that we can move to
			__UpperCAmelCase							=			random.randint(0    ,					len(UpperCamelCase__       ) - 1       )  # picking a random neighbor
			__UpperCAmelCase							=			neighbors.pop(UpperCamelCase__       )
			__UpperCAmelCase							=			picked_neighbor.score() - current_score

			if (
			    picked_neighbor.x > max_x
			    or picked_neighbor.x < min_x
			    or picked_neighbor.y > max_y
			    or picked_neighbor.y < min_y
			):
				continue  # neighbor outside our bounds

			if not find_max:
				__UpperCAmelCase							=			change * -1  # in case we are finding minimum
			if change > 0:  # improves the solution
				__UpperCAmelCase							=			picked_neighbor
			else:
				__UpperCAmelCase							=			(math.e) ** (
				    change / current_temp
				)  # probability generation function
				if random.random() < probability:  # random number within probability
					__UpperCAmelCase							=			picked_neighbor
		__UpperCAmelCase							=			current_temp - (current_temp * rate_of_decrease)

		if current_temp < threshold_temp or next_state is None:
			# temperature below threshold, or could not find a suitable neighbor
			__UpperCAmelCase							=			True
		else:
			__UpperCAmelCase							=			next_state

	if visualization:
		from matplotlib import pyplot as plt

		plt.plot(range(UpperCamelCase__       )    ,					UpperCamelCase__       )
		plt.xlabel('''Iterations'''       )
		plt.ylabel('''Function values'''       )
		plt.show()
	return best_state


if __name__ == "__main__":





					def       lowerCAmelCase					(		UpperCamelCase__				:   Any    ,					UpperCamelCase__				:   List[str]       ):


						"""simple docstring"""
						return (x**2) + (y**2)

					# starting the problem with initial coordinates (12, 47)
					__lowerCAmelCase	:       List[Any]						       =	SearchProblem(x=12, y=47, step_size=1, function_to_optimize=test_fa)
					__lowerCAmelCase	:       List[str]						       =	simulated_annealing(
					    prob, find_max=False, max_x=100, min_x=5, max_y=50, min_y=-5, visualization=True
					)
					print(
					    "The minimum score for f(x, y) = x^2 + y^2 with the domain 100 > x > 5 "
					    F"""and 50 > y > - 5 found via hill climbing: {local_min.score()}"""
					)

					# starting the problem with initial coordinates (12, 47)
					__lowerCAmelCase	:       List[str]						       =	SearchProblem(x=12, y=47, step_size=1, function_to_optimize=test_fa)
					__lowerCAmelCase	:       int						       =	simulated_annealing(
					    prob, find_max=True, max_x=100, min_x=5, max_y=50, min_y=-5, visualization=True
					)
					print(
					    "The maximum score for f(x, y) = x^2 + y^2 with the domain 100 > x > 5 "
					    F"""and 50 > y > - 5 found via hill climbing: {local_min.score()}"""
					)





					def       lowerCAmelCase					(		UpperCamelCase__				:   Optional[Any]    ,					UpperCamelCase__				:   Union[str, Any]       ):


						"""simple docstring"""
						return (3 * x**2) - (6 * y)

					__lowerCAmelCase	:       Union[str, Any]						       =	SearchProblem(x=3, y=4, step_size=1, function_to_optimize=test_fa)
					__lowerCAmelCase	:       Optional[Any]						       =	simulated_annealing(prob, find_max=False, visualization=True)
					print(
					    "The minimum score for f(x, y) = 3*x^2 - 6*y found via hill climbing: "
					    F"""{local_min.score()}"""
					)

					__lowerCAmelCase	:       Union[str, Any]						       =	SearchProblem(x=3, y=4, step_size=1, function_to_optimize=test_fa)
					__lowerCAmelCase	:       List[str]						       =	simulated_annealing(prob, find_max=True, visualization=True)





					print(
					    "The maximum score for f(x, y) = 3*x^2 - 6*y found via hill climbing: "
					    F"""{local_min.score()}"""
					)

'''simple docstring'''


import requests
from bsa import BeautifulSoup





def       lowerCAmelCase					(		UpperCamelCase__				:   str = "AAPL"       ):


	"""simple docstring"""
	__UpperCAmelCase							=			f"""https://in.finance.yahoo.com/quote/{symbol}?s={symbol}"""
	__UpperCAmelCase							=			BeautifulSoup(requests.get(UpperCamelCase__       ).text    ,					'''html.parser'''       )
	__UpperCAmelCase							=			'''My(6px) Pos(r) smartphone_Mt(6px)'''
	return soup.find('''div'''    ,					class_=class_       ).find('''span'''       ).text


if __name__ == "__main__":
					for symbol in "AAPL AMZN IBM GOOG MSFT ORCL".split():
										print(F"""Current {symbol:<4} stock price is {stock_price(symbol):>8}""")
