




from collections.abc import Callable
from math import pi, sqrt
from random import uniform
from statistics import mean




def        _SCREAMING_SNAKE_CASE      (		snake_case       )						->				str:

						# A local function to see if a dot lands in the circle.
						def is_in_circle(snake_case			,     snake_case       ) -> bool:
												_UpperCAmelCase      =			sqrt((x**2) + (y**2)       )
												# Our circle has a radius of 1, so a distance
												# greater than 1 would land outside the circle.
												return distance_from_centre <= 1

						# The proportion of guesses that landed in the circle
						_UpperCAmelCase      =			mean(
						    int(is_in_circle(uniform(-1.0			,     1.0       )			,     uniform(-1.0			,     1.0       )       )       )
						    for _ in range(snake_case       )       )
						# The ratio of the area for circle to square is pi/4.
						_UpperCAmelCase      =			proportion * 4
						print(f"The estimated value of pi is {pi_estimate}"       )
						print(f"The numpy value of pi is {pi}"       )
						print(f"The total error is {abs(pi - pi_estimate       )}"       )




def        _SCREAMING_SNAKE_CASE      (		snake_case			,     snake_case			,     snake_case = 0.0			,     snake_case = 1.0			,     )						->				float:
						return mean(
						    function_to_integrate(uniform(snake_case			,     snake_case       )       ) for _ in range(snake_case       )       ) * (max_value - min_value)




def        _SCREAMING_SNAKE_CASE      (		snake_case			,     snake_case = 0.0			,     snake_case = 1.0       )						->				None:

						def identity_function(snake_case       ) -> float:
												return x

						_UpperCAmelCase      =			area_under_curve_estimator(
						    snake_case			,     snake_case			,     snake_case			,     snake_case       )
						_UpperCAmelCase      =			(max_value * max_value - min_value * min_value) / 2

						print("""******************"""       )
						print(f"Estimating area under y=x where x varies from {min_value} to {max_value}"       )
						print(f"Estimated value is {estimated_value}"       )
						print(f"Expected value is {expected_value}"       )
						print(f"Total error is {abs(estimated_value - expected_value       )}"       )
						print("""******************"""       )




def        _SCREAMING_SNAKE_CASE      (		snake_case       )						->				None:

						def function_to_integrate(snake_case       ) -> float:
												return sqrt(4.0 - x * x       )

						_UpperCAmelCase      =			area_under_curve_estimator(
						    snake_case			,     snake_case			,     0.0			,     2.0       )

						print("""******************"""       )
						print("""Estimating pi using area_under_curve_estimator"""       )
						print(f"Estimated value is {estimated_value}"       )
						print(f"Expected value is {pi}"       )
						print(f"Total error is {abs(estimated_value - pi       )}"       )
						print("""******************"""       )


if __name__ == "__main__":
				import doctest

				doctest.testmod()





# Logistic Regression from scratch

# In[62]:

# In[63]:

# importing all the required libraries

import numpy as np
from matplotlib import pyplot as plt
from sklearn import datasets




def        _SCREAMING_SNAKE_CASE      (		snake_case       )						->				List[str]:
						return 1 / (1 + np.exp(-z       ))




def        _SCREAMING_SNAKE_CASE      (		snake_case			,     snake_case       )						->				Tuple:
						return (-y * np.log(snake_case       ) - (1 - y) * np.log(1 - h       )).mean()




def        _SCREAMING_SNAKE_CASE      (		snake_case			,     snake_case			,     snake_case       )						->				List[Any]:
						_UpperCAmelCase      =			np.dot(snake_case			,     snake_case       )
						return np.sum(y * scores - np.log(1 + np.exp(snake_case       )       )       )




def        _SCREAMING_SNAKE_CASE      (		snake_case			,     snake_case			,     snake_case			,     snake_case=7_0_0_0_0       )						->				Tuple:
						_UpperCAmelCase      =			np.zeros(x.shape[1]       )

						for iterations in range(snake_case       ):
												_UpperCAmelCase      =			np.dot(snake_case			,     snake_case       )
												_UpperCAmelCase      =			sigmoid_function(snake_case       )
												_UpperCAmelCase      =			np.dot(x.T			,     h - y       ) / y.size
												_UpperCAmelCase      =			theta - alpha * gradient  # updating the weights
												_UpperCAmelCase      =			np.dot(snake_case			,     snake_case       )
												_UpperCAmelCase      =			sigmoid_function(snake_case       )
												_UpperCAmelCase      =			cost_function(snake_case			,     snake_case       )
												if iterations % 1_0_0 == 0:
																		print(f"loss: {j} \t"       )  # printing the loss after every 100 iterations
						return theta


# In[68]:

if __name__ == "__main__":
				a													=			datasets.load_iris()
				a													=			iris.data[:, :2]
				a													=			(iris.target != 0) * 1

				a													=			0.1
				a													=			logistic_reg(alpha, x, y, max_iterations=70000)
				print("theta: ", theta)  # printing the theta i.e our weights vector




				def        _SCREAMING_SNAKE_CASE      (		snake_case       )						->				List[Any]:
										return sigmoid_function(
										    np.dot(snake_case			,     snake_case       )       )  # predicting the value of probability from the logistic regression algorithm

				plt.figure(figsize=(10, 6))
				plt.scatter(x[y == 0][:, 0], x[y == 0][:, 1], color="b", label="0")
				plt.scatter(x[y == 1][:, 0], x[y == 1][:, 1], color="r", label="1")
				((a)							,  (a))													=			(x[:, 0].min(), x[:, 0].max())
				((a)							,  (a))													=			(x[:, 1].min(), x[:, 1].max())
				((a)							,  (a))													=			np.meshgrid(np.linspace(xa_min, xa_max), np.linspace(xa_min, xa_max))
				a													=			np.c_[xxa.ravel(), xxa.ravel()]
				a													=			predict_prob(grid).reshape(xxa.shape)
				plt.contour(xxa, xxa, probs, [0.5], linewidths=1, colors="black")

				plt.legend()

				plt.show()