Modify the functions for the bisection and false-position

Answer the following questions by modifying the scripts given at the bottom or creating new .m files is asked. Answer as many of the questions if possible.
1)Modify the functions for the bisection and false-position techniques of finding a root of an equation (see below questions) so that the number of iterations can be determined and displayed. (The count should only be displayed after the loop is completed, not for each iteration.) In the script file call your modified functions to determine the number of times the loop runs under the following conditions.

1.Use the bisection method with the equation f(x) = x3 +2×2 – x -2 with 0 and 1.3 as the guesses of the bracket and an error of 0.00001.

2.Use the false position method with the equation f(x) = x3 +2×2 – x -2 with 0 and 1.3 as the guesses of the bracket and an error of 0.00001.

3.Use the bisection method with the equation f(x) = x10 – 1 with 0 and 1.3 as the guesses of the bracket and an error of 0.00001.

4.Use the false position method with the equation f(x) = x10 – 1 with 0 and 1.3 as the guesses of the bracket and an error of 0.00001.

Plot both functions in the range of x from -0.5 to 1.4 with step of 0.02. Add comments to your script file that explain why there may be a difference in number of times the loop runs between two functions and the two methods. Hint: draw or print the two plots. Then by hand predict the first four or five new guesses for each algorithm. Think about how fast these new guesses are approaching the root in respect to the shape of the curve

Biscetion Function::::

function [root,calcerror] = bisrch(funct,low, high, error)

function that uses bisection (sometimes called binary) search to find the
root of the equation between low and high values
input: function of x
low which is the guess of the low value of x
high which is the guess of the high value of x
error which is the how close to 0 will be acceptable
output: root – the value of x which evaluates to within the error
calcerror – how far f(root is from 0)
processing: Set number of roots = 0. Determine a middle value for
x – xm=(low + high)/2 and calculate f(xm). If absolute
value of f(xm)< error, set root = xm, set logical variable to false, and set nroot = 1. Else if sign of f(xm) = sign of f(low), then set low = xm. Otherwise set low = xm. Repeat until high-low < error or logical variable is false notfound = true; % set logical variable to true diff = (high-low); % calculate difference between high and low nroot = 0; % set number of roots to 0 while (notfound & diff >0.00000001)
xm = (low + high)/2; % calculate middle value of x
fxm = funct(xm); % calculate f(xmiddle)
flow = funct(low); % calculate f(xlow)
if fxm == 0 | abs(fxm)< error % root found root = xm; nroot = 1; notfound = false; calcerror = abs(0 - fxm); elseif sign(flow) == sign(fxm) low = xm; else high = xm; end % end if diff = high - low; end % end loop if nroot == 0 disp('Root was not found in range given') disp('Try again with new values') root = []; calcerror = []; else disp('A root was found') end False Position Function::: function [fproot,zeroerror] = falsepos(func, low, high, accepterror) function to find the root of an equation using false position method and two guesses. input: function, low value for a guess, high value for a guess, and acceptable error for root. output: The root or an empty matrixif the root is not found. processing: Find a possibility for the root by creating a line between low value high value. New possibility is where the line intersects the x-axis. New possibility may be calculated by the equation xnew = xhigh - ((f(xhigh)(xlow -xhigh))/(f(xlow) - f(xhigh)) Then f(xnew) will be calculated. If f(xnew) is equal to 0, set root to xnew and set logical variable to false. Otherwise compare the sign of f(xnew) is the same as the sign of low. If it the same, then set low to xnew, set high to xnew. Repeat until root is found or difference between xlow and xhigh is less than 0.0000001. notfound = true; diff = abs(high - low); fproot =[]; while (notfound & diff > 0.00000001 )
flow = func(low);
fhigh = func(high);
xnew = high – ((fhigh)*(low – high))/(flow – fhigh);
fnew = func(xnew);
if abs(fnew) < accepterror fproot = xnew; notfound = false; zeroerror = fnew; elseif sign(fnew) == sign(flow) low = xnew; else high = xnew; end diff = abs(high - low); end if notfound disp('No roots were found in this range!') disp('Try again with new guesses') end

find the cost of your paper