MaplePrimes - answers and comments on Question, Newton Rhapson - this one

evaluate f at point x

acer — Mon, 14 Apr 2008 22:38:33 Z

You're using f/D(f) as the correction term. But you need both of those operators f and D(f) to actually be evaluated at the point x.

Also, you can't have f be a parameter of procedure NR1 as well as a local variable. I deleted it as the latter.

> NR1:= proc(f,x0,N)
> local x,k:
>  x := x0:
>  for k to N do:
>    x := x-f(x)/D(f)(x)
>  end do:
>   evalf(x):
>  end proc:

> f:= x-> x^2-2:

> NR1(f,1,10);
                                  1.414213562

acer

Newton-Raphson

Robert Israel — Mon, 14 Apr 2008 22:47:27 Z

There are several problems with your procedure.

1) You have both a formal parameter f and a local variable f.
Get rid of the local variable.

2) You need f(x)/D(f)(x) instead of f/D(f).

3) It's probably a good idea to use floating point throughout on this.
I've seen students crash Maple in a Newton-Raphson loop, getting rational numbers
with huge numerators and denominators. So make it

x := evalf(x - f(x)/D(f)(x));

Newton's method again

adnan06 — Sat, 24 May 2008 23:49:38 Z

Hi all,

The discussion here is very interesting and useful. I still have a question regarding the Newton's method iteration or any other iteration. how can I implement the proc above for a function like : f(x) = sqrt(x-r) for x>= r and f(x) = - sqrt(r-x) for x<= r, where r is any ( choosen) real number. I know this function does not converge. and I want to see the result as output=plot.

Thanks to all

Without procedures

Jabz — Wed, 25 Feb 2009 18:15:29 Z

Hi all the discussions above have procedures.

Is it possible to code in Newton's Method without using procedures?

Newton's method

alec — Wed, 25 Feb 2009 22:39:14 Z

Without using a procedure, it can be done just by executing the body of a procedure.

For example, if you need to find a root of x^4+3*x^3-x-10=0 correct to 8 decimal places, with initial approximation x0=-3.2, that can be done as

f:=x->x^4+3*x^3-x-10:
x:=-3.2:
n:=8:
while f(x-0.5*0.1^n)*f(x+0.5*0.1^n)>0 do 
    x:=x-f(x)/D(f)(x) od;

                          x := -3.206173582

                          x := -3.206142669

However, if you need to do that more than once, it is more conveniet to use it in the form of a procedure,

Newt:=proc (f,x0,n) 
    local x; 
    x:=x0; 
    while f(x-0.5*0.1^n)*f(x+0.5*0.1^n)>0 do 
        x:=x-f(x)/D(f)(x) 
    od 
end:

In this case, if you need to find another root, with the initial approximation x0=1.4, correct to 8 decimal places, that can be done as

Newt(f, 1.4 ,8); 
                             1.375064696

Alec

Re: Without procedures

acer — Wed, 25 Feb 2009 23:10:03 Z

Do you mean that you want the solving method to not be implemented as a (new) procedure?

Or do you perhaps mean that you want f to be an expression rather than a procedure or operator? In that case, the function applications could be replaced by 2-argument eval calls, or unapply could be used to produce an operator equivalent at the start of the code. Eg, instead of,

> f := x -> cos(Pi+x) -x: # the input

> f(1.1);
                                 -1.553596121

could be,

> f := cos(Pi+x) -x: # the input

> var := indets(f,And(name,Non(constant)));
                                  var := {x}

> if nops(var) <> 1 then error "expecting univariate expression"; end if;

> eval( f, var[1]=1.1 );
                                 -1.553596121

> F := unapply(f, var[1]);
                             F := x -> -cos(x) - x

> F(1.1);
                                 -1.553596121

acer