





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



def 		A_				(     _lowerCAmelCase							,   _lowerCAmelCase							,   _lowerCAmelCase     )						-> Tuple:
 UpperCamelCase	:					int       	=   a + h
 while x < (b - h):
  yield x
  UpperCamelCase	:					Any       	=   x + h



def 		A_				(     _lowerCAmelCase     )						-> Optional[Any]:  # enter your function here
 UpperCamelCase	:					Union[str, Any]       	=   (x - 0) * (x - 0)
 return y



def 		A_				(     )						-> Dict:
 UpperCamelCase	:					Optional[int]       	=   0.0  # Lower bound of integration
 UpperCamelCase	:					Dict       	=   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	:					int       	=   method_a(_lowerCAmelCase							,   _lowerCAmelCase     )
 print(F"""y = {y}"""     )


if __name__ == "__main__":
    main()





'''simple docstring'''





from __future__ import annotations

import math




def lowerCAmelCase  (__A  ,	__A):



     """simple docstring"""



     _a      =  u
     for i in range(1  ,	__A):
          _a      =  temp * (u - i)
     return temp




def lowerCAmelCase  ():



     """simple docstring"""



     _a      =  int(input('''enter the numbers of values: '''))
     _a      =  []
     for _ in range(__A):
          y.append([])
     for i in range(__A):
          for j in range(__A):
               y[i].append(__A)
               _a      =  0

     print('''enter the values of parameters in a list: ''')
     _a      =  list(map(__A  ,	input().split()))

     print('''enter the values of corresponding parameters: ''')
     for i in range(__A):
          _a      =  float(input())

     _a      =  int(input('''enter the value to interpolate: '''))
     _a      =  (value - x[0]) / (x[1] - x[0])

     # for calculating forward difference table

     for i in range(1  ,	__A):
          for j in range(n - i):
               _a      =  y[j + 1][i - 1] - y[j][i - 1]

     _a      =  y[0][0]
     for i in range(1  ,	__A):
          summ += (ucal(__A  ,	__A) * y[0][i]) / math.factorial(__A)

     print(F'''the value at {value} is {summ}''')


if __name__ == "__main__":
  main()



