






def 		SCREAMING_SNAKE_CASE							( __lowerCAmelCase ,   __lowerCAmelCase      )			->     bool:
     UpperCamelCase__      :       List[Any]	    =  len(__lowerCAmelCase      )
     UpperCamelCase__      :       List[str]	    =  [[False] * (required_sum + 1) for _ in range(arr_len + 1      )]

     # for each arr value, a sum of zero(0) can be formed by not taking any element
     # hence True/1
     for i in range(arr_len + 1      ):
          UpperCamelCase__      :       Optional[int]	    =  True

     # sum is not zero and set is empty then false
     for i in range(1 ,   required_sum + 1      ):
          UpperCamelCase__      :       List[str]	    =  False

     for i in range(1 ,   arr_len + 1      ):
          for j in range(1 ,   required_sum + 1      ):
               if arr[i - 1] > j:
                    UpperCamelCase__      :       Tuple	    =  subset[i - 1][j]
               if arr[i - 1] <= j:
                    UpperCamelCase__      :       Any	    =  subset[i - 1][j] or subset[i - 1][j - arr[i - 1]]

     return subset[arr_len][required_sum]


if __name__ == "__main__":
 import doctest

 doctest.testmod()







def 		SCREAMING_SNAKE_CASE							( __lowerCAmelCase ,   __lowerCAmelCase      )			->     Any:
     # "extended trapezoidal rule"
     # int(f) = dx/2 * (f1 + 2f2 + ... + fn)
     UpperCamelCase__      :       int	    =  (boundary[1] - boundary[0]) / steps
     UpperCamelCase__      :       Optional[Any]	    =  boundary[0]
     UpperCamelCase__      :       List[Any]	    =  boundary[1]
     UpperCamelCase__      :       List[Any]	    =  make_points(__lowerCAmelCase ,   __lowerCAmelCase ,   __lowerCAmelCase      )
     UpperCamelCase__      :       int	    =  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 		SCREAMING_SNAKE_CASE							( __lowerCAmelCase ,   __lowerCAmelCase ,   __lowerCAmelCase      )			->     List[str]:
     UpperCamelCase__      :       Optional[int]	    =  a + h
     while x < (b - h):
          yield x
          UpperCamelCase__      :       Union[str, Any]	    =  x + h







def 		SCREAMING_SNAKE_CASE							( __lowerCAmelCase      )			->     Any:  # enter your function here
     UpperCamelCase__      :       Dict	    =  (x - 0) * (x - 0)
     return y







def 		SCREAMING_SNAKE_CASE							( )			->     Dict:
     UpperCamelCase__      :       List[Any]	    =  0.0  # Lower bound of integration
     UpperCamelCase__      :       Tuple	    =  1.0  # Upper bound of integration
     UpperCamelCase__      :       Any	    =  1_0.0  # define number of steps or resolution
     UpperCamelCase__      :       List[str]	    =  [a, b]  # define boundary of integration
     UpperCamelCase__      :       Any	    =  method_a(__lowerCAmelCase ,   __lowerCAmelCase      )
     print(f'y = {y}'      )


if __name__ == "__main__":
 main()