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