Implement Bisection method to find all the possible roots of the given function and verify it with built-in functions scipy.optimize.root() in the SciPy library. Given Functions are: y= f(x)=x^2-x-1 y= f(x)=x^3-x^2-2x+1 follow the template please : import numpy as np import matplotlib.pyplot as plt def plot_function(func, a, b): """ This function plot the graph of the input func within the given interval [a,b). """ # Your code goes here def midpoint_approx(func, a, b, N): '''Compute the Midpoint Approximation of Definite Integral of a function over the interval [a,b]. Parameters ---------- func : function Vectorized function of one variable a , b : numbers Endpoints of the interval [a,b] N : integer Number of subintervals of equal length in the partition of [a,b] Returns ------- float Approximation of the definite integral by Midpoint Approximation. ''' # Your code goes here return result if __name__ == "__main__": # 1st Function to be integrated func_1 = lambda x : x/(x**2 + 1) # Indefinite Integral of the function antiderivative_1 = # Your code goes here # 2nd Function to be integrated func_2 = lambda x : np.exp(x) # Indefinite Integral of the function antiderivative_2 = # Your code goes here # End points for 1st Function a1 = 0; b1 = 0; # Change the values as required # End points for 2nd Function a2 = 0; b2 = 0; # Change the values as required # Call the function to Plot the graph of the functions # Your code goes here # Number of partition for 1st Function N1 = 0 # Change the value as required # Number of partition for 2nd Function N2 = 0 # Change the value as required # Call midpont_method to compute Midpoint Approximation: midpoint_approx_1 = # Your code for 1st function midpoint_approx_2 = # Your code for 2nd function # Calculate the true value of the definite integral definite_integral_1 = antiderivative_1(b1) - antiderivative_1(a1) # For 1st Function definite_integral_2 = antiderivative_2(b2) - antiderivative_2(a2) # For 2nd Function # Calculate the absolute error between the approximate value and true value error_1 = np.abs(midpoint_approx_1 - definite_integral_1) # For 1st Function error_2 = np.abs(midpoint_approx_2 - definite_integral_2) # For 2nd Function print("Midpoint Approximation for 1st Function = {:0.6f}".format(midpoint_approx_1)) print("Actual Value for 1st Function = {:0.6f}".format(definite_integral_1)) print("Absolute error between the above methods ={:0.8f}".format(error_1)) print("Midpoint Approximation for 2nd Function = {:0.6f}".format(midpoint_approx_2)) print("Actual Value for 2nd Function = {:0.6f}".format(definite_integral_2)) print("Absolute error between the above methods ={:0.8f}".format(error_2))

Implement Newton-Raphson method to find all the possible roots of the given function and verify it with built-in functions scipy.optimize.root() in the SciPy library. Given Functions are: y= f(x)=x^2-x-1 y= f(x)=x^3-x^2-2x+1 follow the template please : # Root Finding Method import math import numpy as np import scipy as sp import matplotlib.pyplot as plt def plot_function(func, a, b): """ This function plot the graph of the input func within the given interval [a,b). """ # Your code goes here def newton_method(func, grad, x0, tol=1e-6, max_iter=100): '''Approximate solution of f(x)=0 by Newton-Raphson's method. Parameters ---------- func : function Function value for which we are searching for a solution f(x)=0, grad: function Gradient value of function f(x) x0 : number Initial guess for a solution f(x)=0. tol : number Stopping criteria is abs(f(x)) < tol. max_iter : integer Maximum number of iterations of Newton's method. Returns ------- xn : root Example -------- >>> fun = lambda x: x**2 - x - 1 >>> grad = lambda x: 2*x - 1 >>> root = newton_method(fun, grad, 1, max_iter=20) ''' # Main Loop starts here iter_count = 1 while iter_count <= max_iter: # Your code goes here iter_count += 1 print("Warning! Exceeded the maximum number of iterations.") return root # Main Driver Function: if __name__ == "__main__": # Define the 1st Function for which the root is to be found func = lambda x: x**2 - x - 1 # Define the gradient of the Function grad = lambda x: 2*x -1 # Uncomment the next two lines to use the 2nd Function #func = lambda x: x**3 - x**2 - 2*x + 1 #grad = lambda x: 3*x**2 - 2*x -2 # Call plot_function to plot graph of the function # Your code goes here x0 = 0 # Initial guess for 1st (change the value as required) # Call the Newton's method for 1st root our_root_1 = # Your code goes here # Call SciPy method (reference method) for 1st root sp_result_1 = sp.optimize.root(func, x0) sp_root_1 = sp_result_1.x.item() # Call the Newton's method for 2nd root x0 = 0 # Initial guess for 2nd root (change the value as required) our_root_2 = # Your code goes here # Call SciPy method (reference method) for 2nd root sp_result_2 = sp.optimize.root(func, x0) sp_root_2 = sp_result_2.x.item() # Print the result print("1st root found by Newton's Method = {:0.8f}.".format(our_root_1)) print("1st root found by SciPy = {:0.8f}".format(sp_root_1)) print("2nd root found by Newton's Method = {:0.8f}.".format(our_root_2)) print("2nd root found by SciPy = {:0.8f}".format(sp_root_2))

y= f(x)=x^2-x-1 y= f(x)=x^3-x^2-2x+1 Write Python codes to plot the given function using Matplotlib library. This will give an idea where the roots of the given function are located.

Compute two iterations for the function f(x) = x3 – 5x + 1 = 0 using the secant method, in which the real roots of the equation f(x) lies in the interval (0, 1).

Wrie a python program to use a function that computes the roots of a quadratic equation