current community

your communities

more stack exchange communities

company blog
Stack Exchange Inbox Reputation and Badges
tour help
Mathematica Stack Exchange is a question and answer site for users of Wolfram Mathematica. Join them; it only takes a minute:

Sign up
Here's how it works:
  1. Anybody can ask a question
  2. Anybody can answer
  3. The best answers are voted up and rise to the top
up vote 1 down vote favorite
1

I'm trying to write a program for finding the root of f(x)=e^x+sin(x)-4 by Newton's Method but I'm instructed to not use the built in function and write the code from scratch. I'm pretty new to this and this is what I've come up with so far. I'm curious about what I need to fix to make it better/work.

f[x_]:= Exp[x]+Sin[x]-4 (* This is my starting function *)
g[x_]:= x-(f[x]/f'[x])  (* Formula for Newton's Method *)
count=0;
maxiterations=100; (* Max times function will run *)
TOL=10^(-8); (* Tolerance for stopping condition *)
xprevious=1.0; (* This is my initial guess *)

While[Abs[xcurrent-xprevious] >= TOL && count <= maxiterations,
 {count++, xcurrent=g[xcurrent]}]

(* While my current and previous guess are above my tolerance and I haven't gone over 
my max iterations program will continue to run, adding one to the count each time and
putting xcurrent into the Newton's Method Equation *)

Obviously I am having some troubles with this code. What do I need to do to fix it?

share|improve this question

closed as off-topic by Szabolcs, Dr. belisarius, MarcoB, Jens, thank_you Oct 7 '15 at 2:07

This question appears to be off-topic. The users who voted to close gave this specific reason:

  • "This question arises due to a simple mistake such as a trivial syntax error, incorrect capitalization, spelling mistake, or other typographical error and is unlikely to help any future visitors, or else it is easily found in the documentation." – Szabolcs, Dr. belisarius, MarcoB, Jens, thank_you
If this question can be reworded to fit the rules in the help center, please edit the question.
2  
The first thing you need to do is read a few tutorials and at least get familiar with the basic syntax. Go to the documentation centre, click Common How-Tos at the bottom and read the first few. "f(x_)" is not a function in Mathematica. – Szabolcs Oct 6 '15 at 19:32
    
functions use square brackets. Euler's e is written with a capital E. Built-in keywords always start with a capital (sin -> Sin) – Sjoerd C. de Vries Oct 6 '15 at 19:35
    
Sorry I do know that I just typed it in wrong. – J_Smith88 Oct 6 '15 at 19:36
    
Related: (59877), (93957) – Michael E2 Oct 7 '15 at 0:16
up vote 1 down vote

For a beginner one hint:

f[x_] = Exp[x] + Sin[x] - 4 // N;
NestList[(# - f[#]/f'[#]) &, 1, 5]
{1, 1.1351, 1.12999, 1.12998, 1.12998, 1.12998}

Please read the documentation

share|improve this answer
    
Or NestWhileList[(# - f[#]/f'[#]) &, 1, TOL < Abs[#1 - #2] &, 2] – march Oct 6 '15 at 19:40
    
@ march I said "one hint":) – user31001 Oct 6 '15 at 20:08
    
Or just FixedPointList[# - f[#]/f'[#] &, 1.] or FixedPoint[# - f[#]/f'[#] &, 1.] – Bob Hanlon Oct 6 '15 at 20:09
    
Oh I see, I guess I gave away the answer you were hinting at. :) Oh, and @BobHanlon is piling on with more hints! – march Oct 6 '15 at 20:11
1  
@march life's a bitch! – user31001 Oct 6 '15 at 20:20
up vote 1 down vote

I think it is reasonable to try to produce correct and robust code that will apply Newton's algorithm for finding a zero of a differentiable function of one real variable while maintaining the OP's procedural style.

For robustness, a clear distinction will be made between arguments and localized ancillary variables. The arguments will be

  • f, the function for which a zero is sought
  • guess, the initial guess for the location of the root
  • maxiter, the maximum number of iteration to performed before giving up
  • tolerance, the distance between two iterates of the root that is considered good enough to terminate the solver. This will an optional argument with the default of 1.*^-8 as specified by the OP.

The solver uses Newton's formula to derive a pure function iterator from the function passed to it. That Mathematica can do this symbolically is a great advantage.

The solver will return $Failed if fails to converge after maxiter iterations.

solver[f : (_Function | _Symbol),
     guess_?NumericQ,
     maxiter_Integer /; maxiter > 0,
     tolerance : _?NumericQ : 1.*^-8] /; .1 > tolerance > 0. :=
   Module[{iter, count, xprevious, xcurrent},
     iter = (# - f[#]/f'[#] &);
     count = 0;
     xcurrent = guess;
     xprevious = guess + 2.;
     While[Abs[xcurrent - xprevious] >= tolerance && count <= maxiter,
       xcurrent = iter[xprevious = xcurrent];
       count++];
     If[count <= maxiter, xcurrent, $Failed]]

Let's see if the solver can solve the OP's example problem, i.e., finding a root near 1. for the function 

f[x_] := Exp[x] + Sin[x] - 4

 With[{x = solver[f, 1., 5]}, {x, f[x]}]

{1.12998, 0.}

Here it finds $\sqrt{2}$

Module[{f = #^2 - 2. &, x}, x = solver[f, 1., 6, 1.*^-15]; {x, f[x]}]

{1.41421, -4.44089*10^-16}
share|improve this answer

Not the answer you're looking for? Browse other questions tagged or ask your own question.