Root finding algorithms on scalar functions that:Group of answer choicesalways find all the rootsyield an approximate root to the function within a specified residual valueall of the above statements are truenone of the above statements are true

Which method can be used to find out the roots of any arbitrary function?Select one:a. func()b. roots()c.arb()d.fsolve()

MATLAB has only one built-in function for finding roots : fzero. (The Optimization Toolbox has more).To find out about it, start up Matlab and typehelp fzeroThis hybrid algorithm is due to Richard Brent (1946-), emeritus Professor of Computer Science, ANU.A simplified version called fzerotx can be found in the Asst2 folder. A description of the method as wellas the code is given in Sections 4.6 & 4.8 of the textbook. You can use fzerogui from the Asst2 folder to seehow the algorithm works.a. Modify fzerotx to return, in addition to the computed root, the number of iterations taken.b. Try your modified fzerotx on the following problems and see how it performs in terms of reliability andnumber of iterations.• Find the first 2 positive solutions of the equationsin x = cos(2x 2 )• try it on the function f (x) = 1/(x − π) on the interval [0,5] and comment.• try it on the function f (x) = 1 − (1 + 3x) exp(−3x) on the interval [-1,1] and comment.c. Exactly what kind of stopping criterion does fzerotx use?d. (Tricky) Answer Q4.7 in the textbook (Numerical Computing with MATLAB by Moler)

For the function 𝑔(𝑡)=4𝑡4−4𝑡g(t)=4t 4 −4 t , which of the following statements are true?I. lim⁡𝑡→0𝑔(𝑡)=−1II. lim⁡𝑡→∞𝑔(𝑡)=−∞III. 𝑔(𝑡) has 2 roots.​ I.  t→0lim​ g(t)=−1II.  t→∞lim​ g(t)=−∞III. g(t) has 2 roots.​ A.I onlyB.II onlyC.III onlyD.I and II onlyE.I, II, and III

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))

For a smoothly-varying function with a single unknown root, how important is the initial guess of that root? Explain why it is/isn’t important.