C Code

/*
---------------------------------------------------------------------------
Algo2-5.c   C program for implementing Algorithm 2.5
Algorithm translated to  C  by: Dr. Norman Fahrer
IBM and Macintosh verification by: Daniel Mathews

NUMERICAL METHODS: C Programs, (c) John H. Mathews 1995
To accompany the text:
NUMERICAL METHODS for Mathematics, Science and Engineering, 2nd Ed, 1992
Prentice Hall, Englewood Cliffs, New Jersey, 07632, U.S.A.
Prentice Hall, Inc.; USA, Canada, Mexico ISBN 0-13-624990-6
Prentice Hall, International Editions:   ISBN 0-13-625047-5
This free software is compliments of the author.
E-mail address:       "mathews@fullerton.edu"

Algorithm 2.5 (Newton-Raphson Iteration).
Section   2.4, Newton-Raphson and Secant Methods, Page 84
---------------------------------------------------------------------------
*/
/*
---------------------------------------------------------------------------

Algorithm 2.5 (Newton-Raphson Iteration). To find a root
f(x) = 0 given one initial approximation  p_0  and using the iteration

                                                  f(p_(k-1))  
      p_k  =  p_(k-1)  -  -------------     for k = 1, 2, ...  
                                                 f'(p_(k-1))  

---------------------------------------------------------------------------
*/

/* User has to supply a function named :  ffunction
   and its first derivative :            dffunction

   An example is included in this program */

#include<stdio.h>
#include<stdlib.h>
#include<math.h>


/*  define prototype for USER-SUPPLIED function f(x)  */

    double ffunction(double x);
    double dffunction(double x);


/*  EXAMPLE for "ffunction"   */

    double ffunction(double x)

    {
        return ( pow(x,3) - 3 * x + 2 );
    }

/*  EXAMPLE for "dffunction" , first derivative of ffunction. */

    double dffunction(double x)

    {
        return ( 3 * pow(x,2) - 3 );
    }


/* -------------------------------------------------------- */

/*  Main program for algorithm 2.5  */

    void main()

{
    double Delta = 1E-6;       /* Tolerance  */
    double Epsilon = 1E-6;     /* Tolerance  */
    double Small = 1E-6;       /* Tolerance  */

    int Max = 99;  /* Maximum number of iterations  */
    int Cond = 0;  /* Condition fo loop termination */
    int K;         /* Counter for loop              */

    double P0;    /* INPUT : Must be close to the root */
    double P1;    /* New iterate    */
    double Y0;    /* Function value */
    double Y1;    /* Function value */
    double Df;    /* Derivative     */
    double Dp;
    double RelErr;


    printf("----------------------------------------------\n");
    printf("Please enter initial approximation of root !\n");
    scanf("%lf",&P0);
    printf("----------------------------------------------\n");
    printf("Initial value for root: %lf\n",P0);

    Y0 = dffunction(P0);

    for ( K = 1; K <= Max ; K++) {

        if(Cond) break;

        Df = dffunction(P0);      /* Compute the derivative  */

         if( Df == 0) {       /* Check division by zero */
             Cond = 1;
             Dp   = 0;
         }

         else Dp = Y0/Df;

        P1 = P0 - Dp;       /* New iterate */
        Y1 = ffunction(P1);   /* New function value */

        RelErr = 2 * fabs(Dp) / ( fabs(P1) + Small );  /* Relative error */

        if( (RelErr < Delta)  && (fabs(Y1) < Epsilon) ) { /* Check for   */

            if( Cond != 1) Cond = 2;                      /* convergence */

        }

        P0 = P1;
        Y0 = Y1;
    }

    printf("----------------------------------------------\n");
    printf("The current %d -th iterate is %lf\n",K-1, P1);
    printf("Consecutive iterates differ by %lf\n",Dp);
    printf("The value of f(x) is %lf\n",Y1);
    printf("----------------------------------------------\n");

if(Cond == 0) printf("The maximum number of iterations was exceeded !\n");

if(Cond == 1) printf("Division by zero was encountered !\n");

if(Cond == 2) printf("The root was found with the desired tolerance !\n");

    printf("----------------------------------------------\n");

}   /* End of main program */

(c) John H. Mathews 2004