def 					_snake_case	(  __snake_case  ,     __snake_case						):
					# "extended trapezoidal rule"
					# int(f) = dx/2 * (f1 + 2f2 + ... + fn)
					_UpperCamelCase			     =     (boundary[1] - boundary[0]) / steps
					_UpperCamelCase			     =     boundary[0]
					_UpperCamelCase			     =     boundary[1]
					_UpperCamelCase			     =     make_points(__snake_case  ,     __snake_case  ,     __snake_case						)
					_UpperCamelCase			     =     0.0
					y += (h / 2.0) * f(__snake_case						)
					for i in x_i:
										# print(i)
										y += h * f(__snake_case						)
					y += (h / 2.0) * f(__snake_case						)
					return y
def 					_snake_case	(  __snake_case  ,     __snake_case  ,     __snake_case						):
					_UpperCamelCase			     =     a + h
					while x < (b - h):
										yield x
										_UpperCamelCase			     =     x + h
def 					_snake_case	(  __snake_case						):  # enter your function here
					_UpperCamelCase			     =     (x - 0) * (x - 0)
					return y
def 					_snake_case	(  ):
					_UpperCamelCase			     =     0.0  # Lower bound of integration
					_UpperCamelCase			     =     1.0  # Upper bound of integration
					_UpperCamelCase			     =     10.0  # define number of steps or resolution
					_UpperCamelCase			     =     [a, b]  # define boundary of integration
					_UpperCamelCase			     =     method_a(__snake_case  ,     __snake_case						)
					print(f"""y = {y}"""						)


if __name__ == "__main__":
					main()

import math
class     lowerCAmelCase_     :







							def __init__(   self      :     Tuple ,			_A      :     int=0		):  # a graph with Node 0,1,...,N-1
												_UpperCamelCase			     =     n
												_UpperCamelCase			     =     [
												    [math.inf for j in range(0 ,			_A		)] for i in range(0 ,			_A		)
												]  # adjacency matrix for weight
												_UpperCamelCase			     =     [
												    [math.inf for j in range(0 ,			_A		)] for i in range(0 ,			_A		)
												]  # dp[i][j] stores minimum distance from i to j







							def  UpperCamelCase_						(   self      :     Dict ,			_A      :     str ,			_A      :     List[str] ,			_A      :     Optional[Any]		):
												_UpperCamelCase			     =     w







							def  UpperCamelCase_						(   self      :     Optional[int]		):
												for k in range(0 ,			self.n		):
																	for i in range(0 ,			self.n		):
																						for j in range(0 ,			self.n		):
																											_UpperCamelCase			     =     min(self.dp[i][j] ,			self.dp[i][k] + self.dp[k][j]		)







							def  UpperCamelCase_						(   self      :     List[str] ,			_A      :     Optional[int] ,			_A      :     Optional[int]		):
												return self.dp[u][v]


if __name__ == "__main__":
					_lowerCAmelCase       =		Graph(5)
					graph.add_edge(0, 2, 9)
					graph.add_edge(0, 4, 10)
					graph.add_edge(1, 3, 5)
					graph.add_edge(2, 3, 7)
					graph.add_edge(3, 0, 10)
					graph.add_edge(3, 1, 2)
					graph.add_edge(3, 2, 1)
					graph.add_edge(3, 4, 6)
					graph.add_edge(4, 1, 3)
					graph.add_edge(4, 2, 4)
					graph.add_edge(4, 3, 9)
					graph.floyd_warshall()
					graph.show_min(1, 4)
					graph.show_min(0, 3)
