Newton's method - how to make the computational performance faster?

I have used a while loop in the algorithm. Once the absolute error is less than the specified tolerance (tol), the while loop stops and the function is expected to output one solution, even though many solutions exist. I have tried x^3 + 8x -18=0 with a starting guess 2. It should take two iterations to obtain the solution, but I cannot figure out why the computational perfomance is very slow when executing the function.

function moisolver
syms x
func=input('Enter the function f(x) which is equal zero:');
xn=input('Enter your initial guess:');

% The function func is switched to a function handle class
Dfunc=jacobian(func,x);
Dfunc=matlabFunction(Dfunc);

% The derivative dfuncd is switched to a function handle class
dfuncd=diff(func);
Dfuncd=jacobian(dfuncd,x);
Dfuncd=matlabFunction(Dfuncd);

% The tolerance is defined. The abs_error, counter and the vector
% storing the approximated solutions during the iteration process, are
% initialized
tol=10^(-1);
abs_error=1;
counter=1;
vec=xn;

while abs_error>=tol
    counter=1+counter;
%     xn is the iterative solution
    xn=xn-Dfunc(xn)/Dfuncd(xn);
%     An expanding vector veczero is added with xn
    veczero=zeros(1,counter)+xn;
%     The former solutions are redefined in veczero. Notice that the
%     last element in veczero is defined as the last obtained solution
    veczero(1:counter-1)=vec;
%     vec is redefined
    vec=veczero;
%     The absolute error is calculated
    abs_error=abs(vec(end)-vec(end-1));
end
solution=vec(end);
fprintf('The solution is %.2f.\n',solution)
fprintf('The computer generated %d iterations to obtain the solution.\n',counter)

Answer 1

[Matt J]

If the goal is to find a root of func, then the update formula for Newton's method should be

   xn=xn-func(xn)./Dfunc(x)

This method of accumulating the solutions

   veczero=zeros(1,counter)+xn;

is also hurting you in multiple ways. You should be pre-allocating memory for vec prior to the loop. You should also not be using vector addition to append xn to vec, when a scalar assignment operation will do the same thing much less expensively.

    vec(counter)=xn;

[John]

I found out that there was a main problem with the function used to switch the expressions to function handle class. I fixed it by prompting the user to enter both the equation and the derivative as function handle class by applying @(x)f(x). So now the code is as following

function moisolver
func=input('Enter the function f(x) which is equal zero in the form @(x)f(x):');
dfunc=input('Enter the derivative:');
xn=input('Enter your initial guess:');

% The tolerance is defined. The abs_error, counter and the vector
% storing the approximated solutions during the iteration process, are
% initialized
tol=10^(-2);
abs_error=1;
counter=1;
vec=xn;
while abs_error>=tol
    counter=1+counter;
%     xn is the iterative solution
    xn=xn-func(xn)/dfunc(xn);
%     vec is defined
    vec(counter)=xn;
%     The absolute error is calculated
    abs_error=abs(vec(end)-vec(end-1));
end
solution=vec(end);
fprintf('The solution is %.4f.\n',solution)
fprintf('The computer generated %d iterations to obtain the solution.\n',counter)

I just want to know if it is possible to switch the class of the derivative (assuming that the derivative is determined in sym class, rather than prompting the user to enter it) from sym to function handle

[Matt J]

I don't have the Symbolic Math Toolbox, but I don't know why

 dfunc = matlabFunction(diff(func)); %func is class sym

wouldn't have worked.

[bym]

seems to work fine for me... (R2008b)

    matlabFunction(diff(func))

ans = 

      @(x)3.*x.^2+8

[John]

it did work for me (R2012a)