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) = x³ +2x² - 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) = x³ +2x² - 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) = x¹⁰ - 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) = x¹⁰ - 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