C PROGRAM FOR NUMERICAL METHODS UNIT 1

BISECTION METHOD ALGORITHM, FLOWCHART AND CODE IN C

Bisection method is an iterative implementation of the ‘Intermediate Value Theorem‘ to find the
real roots of a nonlinear function. According to the theorem “If a function f(x)=0 is continuous in
an interval (a, b), such that f(a) and f(b) are of opposite nature or opposite signs, then there exists
at least one or an odd number of roots between a and b.”
Using C program for bisection method is one of the simplest computer programming approach to
find the solution of nonlinear equations. It requires two initial guesses and is a closed bracket
method. Bisection method never fails!
The programming effort for Bisection Method in C language is simple and easy. The convergence
is linear, slow but steady. The overall accuracy obtained is very good, so bisection method is more
reliable in comparison to the Newton Raphson method or the Regula-Falsi method.

Features of Bisection Method:

 Type – closed bracket

 No. of initial guesses – 2
 Convergence – linear
 Rate of convergence – slow but steady
 Accuracy – good
 Programming effort – easy
 Approach – middle point

Bisection Method Algorithm:

1. Start
2. Read x0, x1, err
*Here x1 and x2 are initial guesses
e is the absolute error i.e. the desired degree of accuracy*
3. Compute: f1 = f(x0) and f2 = f(x1)
4. If (f0*f1) > 0, then display initial guesses are wrong and goto (11).
Otherwise continue.
5. X2 = (x0 + x1)/2
6. If ( [ (x1 – x2) ] > e ), then display x2 and goto (11).
* Here [ ] refers to the modulus sign. *
7. Else, f2 = f(x2)
8. If ((f2*f0) > 0), then x0 = x2 and f0 = f2.
9. Else, x1 = x2 and f1 = f2.

COMPILED BY: ER.SARBESH CHAUDHARY 1

C PROGRAM FOR NUMERICAL METHODS UNIT 1

10. Goto (5).

*Now the loop continues with new values.*
11. Stop

Bisection Method Flowchart:

COMPILED BY: ER.SARBESH CHAUDHARY 2

C PROGRAM FOR NUMERICAL METHODS UNIT 1

Below is a source code in C program for bisection method to find a root of the nonlinear
function x^3 – 4*x – 9. The initial guesses taken are a and b. The calculation is done until the
following condition is satisfied:

|a-b| < 0.0005 OR If (a+b)/2 < 0.0005 (or both equal to zero)
where, (a+b)/2 is the middle point value.

Variables:

 i – a counter variable which keeps track of the no. of iterations performed

 x2 – the value of root at the nth iteration
 x0, x1 – the limits within which the root lies
 err – allowed error
 x1 – the value of root at (n+1)th iteration

f(x) = x^3 – 4*x – 9

Source Code for Bisection Method in C:

1. #include<stdio.h> /*including header files*/
2. #include<conio.h>
3. #include<math.h>
4. #define err 0.0005 /*defining the error term*/
5. #define f(x) x*x*x-4*x-9 /*defining the function f(x)*/
6. void main()
7. {
8. int i=1; /*declaring variables*/
9. float x0,x1,x2;
10. double f0,f1,f2;
11. printf("\nEnter the value of x0: ");
12. scanf("%f",&x0); /*generating input/output statements*/
13. printf("\nEnter the value of x1: ");
14. scanf("%f",&x1);
15. printf("\n---------------------------------------------------
------------\n");
16. printf("\nIteration x0\t x1\t x2\t f0\t f1\t
f2\n"); /*generating the tabular form*/
17. printf("\n---------------------------------------------------
----------\n");
18. do /*initialization of do loop*/
19. {

COMPILED BY: ER.SARBESH CHAUDHARY 3

C PROGRAM FOR NUMERICAL METHODS UNIT 1

20. f0=f(x0);
21. f1=f(x1);
22. x2=(x0+x1)/2;
23. f2=f(x2); /*assigning of values*/
24. printf("\n%d\t%f %f %f %lf %lf %lf",i,x0,x1,x2,f0,f1,f2);
/*values of the process*/
25. if(f0*f2<0) /*the main process*/
26. x1=x2;
27. else
28. x0=x2;
29. i++;
30. }while(fabs(f2)>err); /*check if the error term is met*/
31. printf("\n--------------------------------------\n");
32. printf("Approximate Root: %f",x2); /*final answer*/
33. getch();
34. }
Input/Output:

REGULA FALSI Method ALGORITHM, FLOWCHART AND CODE IN C

Regula Falsi method, also known as the false position method, is the oldest approach to find the
real root of a function. It is a closed bracket method and closely resembles the bisection method.

The C Program for regula falsi method requires two initial guesses of opposite nature. Like
the secant method, interpolation is done to find the new values for successive iterations, but in
this method one interval always remains constant.

COMPILED BY: ER.SARBESH CHAUDHARY 4

C PROGRAM FOR NUMERICAL METHODS UNIT 1

The programming effort for Regula Falsi or False Position Method in C language is simple and
easy. The convergence is of first order and it is guaranteed. In manual approach, the method of
false position may be slow, but it is found superior to the bisection method.

Features of Regula Falsi Method:

 Type – closed bracket
 No. of initial guesses – 2
 Convergence – linear
 Rate of convergence – slow
 Accuracy – good
 Programming effort – easy
 Approach – interpolation
Regula Falsi Method Algorithm:
1. Start
2. Read values of x0, x1, e and N
*Here x0 and x1 are the two initial guesses
e is the degree of accuracy or the absolute error i.e. the stopping criteria*
3. N is the count value.
4. Computer function values f(x0) and f(x1)
5. Check whether the product of f(x0) and f(x1) is negative or not.
If it is positive take another initial guesses.
If it is negative then goto step 5.
6. Determine:
x = [x0*f(x1) – x1*f(x0)] / (f(x1) – f(x0))
7. Check whether the product of f(x1) and f(x) is negative or not.
If it is negative, then assign x0 = x;
If it is positive, assign x1 = x;
8. Check whether the value of f(x) is greater than 0.00001 or not.
If yes, goto step 5.
If no, goto step 8.
*Here the value 0.00001 is the desired degree of accuracy, and hence the stopping
criteria.*
9. Display the root as x.
10. Stop

COMPILED BY: ER.SARBESH CHAUDHARY 5

C PROGRAM FOR NUMERICAL METHODS UNIT 1

Regula Falsi Method Flowchart:

Below is a short and simple source code in C program for regula falsi method to find the root
of cos(x) – x*e^x. Here, x0 and x1 are the initial guesses taken.

Variables:

 itr – a counter which keeps track of the no. of iterations performed

COMPILED BY: ER.SARBESH CHAUDHARY 6

C PROGRAM FOR NUMERICAL METHODS UNIT 1

 maxmitr – maximum number of iterations to be performed

 x0, x1 – the limits within which the root lies
 x2 – the value of root at nth iteration
 x3 – the value of root at (n+1)th iteration
 allerr – allowed error
 x – value of root at nth iteration in the regula function
 f(x0), f(x1) – the values of f(x) at x0 and x1 respectively

f(x) = x^3-2*x-5

Source Code for Regula Falsi Method in C:

1. #include<stdio.h>
2. #include<conio.h>
3. #include<math.h> /*included header files*/
4. #define esp 0.0001 /*defining error term*/
5. #define f(x) x*x*x-2*x-5 /*defining the function*/
6. void main()
7. {
8. float x0,x1,x2,f1,f2,f0;
9. int count=1;
10. do
11. {
12. printf("\n Enter the value of x0: ");
13. scanf("%f",&x0); /*loop to get x0*/
14. }while(f(x0)>0);
15. do
16. {
17. printf("\n Enter the value of x1: ");
18. scanf("%f",&x1); /*loop to get x1*/
19. }while(f(x1)<0);
20. printf("\n
****************************************************** \n");
21. printf(" n x0\t x1\t x2\t f0\t f1\t
f2");
22. printf("\n
****************************************************** \n");
/*formatting the output*/
23. do
24. {
25. f0=f(x0);
26. f1=f(x1);

COMPILED BY: ER.SARBESH CHAUDHARY 7

C PROGRAM FOR NUMERICAL METHODS UNIT 1

27. x2=x0-((f0*(x1-x0))/(f1-f0)); /*working formula

loop*/
28. f2=f(x2);
29. printf("\n %d %f %f %f %f %f
%f",count,x0,x1,x2,f0,f1,f2);
30. if(f0*f2<0)
31. x1=x2;
32. else
33. x0=x2;
34. count++;
35. }while(fabs(f2)>esp);
36. printf("\n
****************************************************** \n");
37. printf("\n\n Approximate Root = %f",x2); /*final answer*/
38. getch();
39. }

Input/Output:

NEWTON RAPHSON METHOD ALGORITHM, FLOWCHART AND CODE IN C

Newton Raphson method, also called the Newton’s method, is the fastest and simplest approach
of all methods to find the real root of a nonlinear function. It is an open bracket approach,
requiring only one initial guess. This method is quite often used to improve the results obtained
from other iterative approaches.

COMPILED BY: ER.SARBESH CHAUDHARY 8

C PROGRAM FOR NUMERICAL METHODS UNIT 1

The convergence is fastest of all the root-finding methods we have discussed in Code with C. The
algorithm and flowchart for Newton Raphson method given below is suitable for not only find the
roots of a nonlinear equation, but the roots of algebraic and transcendental equations as well.

The overall approach of Newton’s method is more useful in case of large values the first derivative
of f(X) i.e f'(X). The iterative formula for Newton Raphson method is:

[highlight color=”yellow”]Xn+1 = Xn – f(Xn)/f'(Xn)[/highlight]

Features of Newton’s Method:

 Type – open bracket

 No. of initial guesses – 1
 Convergence – quadratic
 Rate of convergence – faster
 Accuracy – good
 Programming effort – easy
 Approach – Taylor’s series

Limitations of Newton-Raphson Method:

 Finding the f'(x) i.e. the first derivative of f(x) can be difficult if f(x) is complicated.
 When f'(xn) tends to zero i.e. the first derivative of f(xn) tends to zero, Newton-Raphson
method gives no solution.
 Near local maxima or local minima, there is infinite oscillation resulting in slow
convergence.
 In Newton’s method C program, if the initial guess is far from the desired root, then the
method may converge to some other roots.
 If root jumping occurs, the intended solution is not obtained.
Newton Raphson Method Algorithm:

COMPILED BY: ER.SARBESH CHAUDHARY 9

C PROGRAM FOR NUMERICAL METHODS UNIT 1

Newton Raphson Method Flowchart:

Below is a very short and simple source code in C program for Newton’s method to find the root
of x^2+2*x – 2
.Variables:
 itr – a counter which keeps track of the no. of iterations performed
 z=df(x) – the derivative of f(x) with respect to x
 x0 – the value of root at nth iteration
 xn – the value of root at (n+1)th iteration
 err – allowed error

f(x) = x^2+2*x – 2

Source Code for Newton Raphson Method in C:

1.
2. #include<stdio.h>

COMPILED BY: ER.SARBESH CHAUDHARY 10

C PROGRAM FOR NUMERICAL METHODS UNIT 1

3. #include<conio.h>
4. #include<math.h> /*header files included*/
5. float f(float x) /*declaring the function f(x)*/
6. {
7. float y;
8. y=x*x+2*x-2;
9. return y;
10. }
11. float f1(float x) /*declaring the function f'(x)*/
12. {
13. float z;
14. z=2*x+2;
15. return z;
16. }
17. void main()
18. {
19. int n=0;
20. float x0,xn,err=1,h;
21. printf("\nEnter the initial value of x = "); /*asking for the
intial value of x*/
22. scanf("%f",&x0);
23. printf("\n n\t xn \t\t f(xn)\t\t f'(xn)\t\tx(n+1)\n");
/*designing the table*/
24. while(fabs(err)>.000001)
25. {
26. h=-(f(x0)/f1(x0)); /*working formula*/
27. xn=x0+h;
28. err=xn-x0;
29. printf("\n %d\t %.10f\t %.10f\t %.10f\t
%.10f\n",n,x0,f(x0),f1(x0),xn); /*formatting values in output*/
30. x0=xn;
31. n++;
32. }
33. printf("\n One real root of the given equation is %.5f (correct
upto 5 decimal places)",xn); /*printing the final answer*/
34. getch();
35. }

COMPILED BY: ER.SARBESH CHAUDHARY 11

C PROGRAM FOR NUMERICAL METHODS UNIT 1

Input/Output:

SECANT METHOD ALGORITHM, FLOWCHART AND CODE IN C

Secant method is the most effective approach to find the root of a function. It is based
on Newton-Raphson method, and being free from derivative it can be used as an alternative to
Newton’s method. The C program for Secant method requires two initial guesses, and the method
overall is open bracket type. Also, the secant method is an improvement over the Regula-Falsi
method as approximation is done by a secant line during each iterative operation.
The programming effort for Secant Method in C is a bit tedious, but it’s the most effective of all
other method to find the root of a function. Here, at each iteration, two of the most recent
approximations of the root are utilized to find out the next approximation. Also, in secant method,
it is not mandatory that the interval should contain the root.
The secant method is faster than the bisection method as well as the regula-falsi method. The rate
of convergence is fast; once the secant method converges, its rate of convergence is 1.618, which
is quite high. Although convergence is not guaranteed in this method, this method is the most
economical one giving definitely rapid rate of convergence at low cost.

Features of Secant Method:

 Type – open bracket
 No. of initial guesses – 2
 Convergence – super linear
 Rate of convergence – faster
 Accuracy – good
 Programming effort – tedious
 Approach – interpolation

Secant Method Algorithm:

1. Start

COMPILED BY: ER.SARBESH CHAUDHARY 12

C PROGRAM FOR NUMERICAL METHODS UNIT 1

2. Get values of x0, x1 and e

*Here x0 and x1 are the two initial guesses
e is the stopping criteria, absolute error or the desired degree of accuracy*
3. Compute f(x0) and f(x1)
4. Compute x2 = [x0*f(x1) – x1*f(x0)] / [f(x1) – f(x0)]
5. Test for accuracy of x2
If [ (x2 – x1)/x2 ] > e, *Here [ ] is used as modulus sign*
then assign x0 = x1 and x1 = x2 and goto step 4
6. Else, goto step 7
7. Display the required root as x2.
8. Stop
Secant Method Flowchart:

COMPILED BY: ER.SARBESH CHAUDHARY 13

C PROGRAM FOR NUMERICAL METHODS UNIT 1

Below is a short and simple C programming source code for Secant method to find the root
of x^3-8x-5
f(x) = x^3-8x-5

Source Code for Secant Method in C:

1. #include<stdio.h>
2. float f(float x)
3. {
4. return(x*x*x-8*x-5); // f(x)= x^3-8x-5
5. }
6. float main()
7. {
8. float x0,x1,x2,err;
9. int count=1,itr;
10. printf("\n\nEnter the values of x0 and x1:\n"); //(a,b) must
contain the solution.
11. scanf("%f%f",&x0,&x1);
12. printf("Enter the values of allowed error and maximun number
of iterations:\n");
13. scanf("%f %d",&err,&itr);
14. do
15. {
16. if(f(x0)==f(x1))
17. {
18. printf("\nSolution cannot be found as the values of a and b
are same.\n");
19. return;
20. }
21. x2=(x0*f(x1)-x1*f(x0))/(f(x1)-f(x0));
22. x0=x1;
23. x1=x2;
24. printf("Iteration No-%d x=%f\n",count,x2);
25. count++;
26. if(count==itr)
27. {
28. break;
29. }
30. } while(fabs(f(x2))>err);
31. printf("\n The required solution is %.4f\n",x2);
32. }

COMPILED BY: ER.SARBESH CHAUDHARY 14

C PROGRAM FOR NUMERICAL METHODS UNIT 1

Input/Output:

When the values for a and b, the initial guesses, are entered same, the solution can’t be obtained.
In such case, enter different values for a and b such that f(a) and f(b) are not equal.

FIXED POINT ITERATION METHOD ALGORITHM, FLOWCHART AND CODE IN C

Fixed point iteration method is commonly known as the iteration method. It is one of the most
common methods used to find the real roots of a function. The C program for fixed point iteration
method is more particularly useful for locating the real roots of an equation given in the form of
an infinite series. So, this method can be used for finding the solution of arithmetic series,
geometric series, Taylor’s series and other forms of infinite series.
This method is linearly convergent with somewhat slower rate of convergence, similar to
the bisection method. It is based on modification approach to find the fixed point. It is commonly
referred to as simple enclosure method or open bracket method.
Like other methods to find the root of a function, the programming effort for Iteration Method in
C is easy, short and simple. Just like the Newton-Raphson method, it requires only one initial guess,
and the equation is solved by the assumed approximation.

COMPILED BY: ER.SARBESH CHAUDHARY 15

C PROGRAM FOR NUMERICAL METHODS UNIT 1

Iterations and modifications are successively continued with the updated approximations of the
guess. Iterative method gives good accuracy overall just like the other methods.

Features of Fixed Point Iteration Method:

 Type – open bracket
 No. of initial guesses – 1
 Convergence – linear
 Rate of convergence – fast
 Accuracy – good
 Programming effort – easy
 Approach – modification

Fixed Point Iteration Method Algorithm:

1. Start
2. Read values of x0 and err.
*Here x0 is the initial approximation
err is the absolute error or the desired degree of accuracy, also the stopping criteria*
3. If [gd(x)]>=1, display “The equation is not convergent “and go to step 7
4. *Here [ ] refers to the modulus sign & gd(x) refers to derivative of g(x)*
5. Calculate x1 = g(x0)

1. If [x1 – x0] <= e, goto step 6.

*Here [ ] refers to the modulus sign*
2. Else, assign x0 = x1 and goto step 4.
3. Display x1 as the root.
4. Stop

COMPILED BY: ER.SARBESH CHAUDHARY 16

C PROGRAM FOR NUMERICAL METHODS UNIT 1

Fixed Point Iteration Method Flowchart:

Below is a source code in C program for iteration method to find the root of e-x-x. The desired
degree of accuracy in the program can be achieved by continuing the iteration i.e. by increasing the
maximum number of iterations.

f(x) = e-x-x

Source Code for Fixed Point Iteration Method in C:

1. #include<conio.h>
2. #include<stdio.h>
3. #include<math.h>
4. #define g(x) (exp(-x))

COMPILED BY: ER.SARBESH CHAUDHARY 17

C PROGRAM FOR NUMERICAL METHODS UNIT 1

5. #define gd(x) -(exp(-x))

6. #define e 0.001
7. int main(void)
8. {
9. float x0,x1,f1, error ;
10. int i=1;
11. printf("Using Fixed Point Method / Iterative Method to find
root of exp(-x)-x=0\n");
12. printf("Enter value for x0\n");
13. printf("x0: ");
14. scanf("%f",&x0);
15. if(fabs(gd(x0))>1)
16. {
17. printf("\nThe equation is not convergent");
18. goto c;
19. }
20. else
21. {
22. printf("steps \tx0 \tx1=g(x0) \tError\n");
23. printf("\n-------------------------------------------\n");
24. b:x1=g(x0);
25. error=fabs(x1-x0);
26. printf("%d \t%.6f \t%.6f \t%.6f\n",i,x0,x1,error);
27. i++;
28. }
29. if(fabs((x1-x0))<=e)
30. {
31. printf("\n===========================================\n");
32. printf("The root is %.6f",x0);
33. goto c;
34. }
35. else
36. {
37. x0=x1;
38. goto b;
39. }
40. c:
41. getch();
42. }

COMPILED BY: ER.SARBESH CHAUDHARY 18

C PROGRAM FOR NUMERICAL METHODS UNIT 1

Input/Output:

HORNER'S RULE ALGORITHM, FLOWCHART AND CODE IN C

According to Horne’s rule the quadratic (i.e. degree 2) polynomial

y = c1 x2 + c2 x + c3

can be rearranged as

y = (c1 x + c2) x + c3

The same pattern can be applied to a cubic (degree 3) polynomial

y = c1 x3 + c2 x2 + c3 x + c4
y = (c1 x2 + c2x + c3) x + c4

Factoring the quadratic term inside the parenthesis gives

y = ( (c1 x + c2) x + c3) x + c4

This pattern is called Horner's rule for evaluating a polynomial. For hand calculation of low degree,
it makes sense to use direct computation of the polynomial in its standard form. To evaluate a
polynomial in a computer program, Horner's rule makes more sense, especially if speed and
accuracy are important and the degree of the polynomial is large.

COMPILED BY: ER.SARBESH CHAUDHARY 19

C PROGRAM FOR NUMERICAL METHODS UNIT 1

Horner’s method Algorithm

Step 1: Start
Step 2: Input (integer / float) the coefficients of a polynomial of degree n
Step 3:Read all the coeff. till n=0
Step 4: Input x (integer / float)
Step 5: Read x
Step 6: [Initialize] fx = 0 and calculate sum=(sum+a[i])*x
Step 7: Repeat step 6 until I is greater than or equal to 0
Step 8: [Output] Print the value of fx
Step 9: Stop
Horner’s method Flowchart

COMPILED BY: ER.SARBESH CHAUDHARY 20

C PROGRAM FOR NUMERICAL METHODS UNIT 1

Below is a source code in C program for Horner’s method to evakluate the polynomial,

f(x) = anxn + an−1xn−1 + . . . + a2x2 + a1x0 + a0

Source Code for Horner’s Method in C:

1. #include <stdio.h>
2. int main()
3. {
4. float a[100],sum=0,x;
5. int n,i;
6. printf("\nEnter degree of the polynomial X :: ");
7. scanf("%d",&n);
8. printf("\nEnter coefficient's of the polynomial X :: \n");
9. for(i=n;i>=0;i--)
10. {
11. printf("\nEnter Coefficient of [ X^%d ] :: ",i);
12. scanf("%f",&a[i]);
13. }
14. printf("\nEnter the value of X :: ");
15. scanf("%f",&x);
16. for(i=n;i>0;i--)
17. {
18. sum=(sum+a[i])*x;
19. }
20. sum=sum+a[0];
21. printf("\nValue of the polynomial is = [ %f ]\n",sum);
22. return 0;
23. }

Input/Output:

THE END
COMPILED BY: ER.SARBESH CHAUDHARY 21