0|P a g e

2012

NACP LAB PRACTICAL FILE

SUBMITTED BY:RISHI RAUSHAN

10-CSS-54
COMP. ENGG.
2nd YEAR (4th SEM.)
JAMIA MILLIA ISLAMIA

TABLE OF CONTENTS
TABLE OF CONTENTS .............................................................................................................................................. 1
PROGRAM TO CALCULATE SUM AND AVERAGE OF 100 NATURAL NUMBERS ........................................................ 2
PROGRAM TO FIND PRODUCT OF 1ST 'N' NATURAL NUMBERS .............................................................................. 3
FIBBONACCI SERIES ................................................................................................................................................ 4
GENERATING PRIME NO. BETWEEN 1 AND 100 ...................................................................................................... 5
GENERATE PRIME NOS. BETWEEN 1 AND 100 EXCEPT THOSE DIVISIBLE BY 5 ........................................................ 6
CALCULATION OF SINE SERIES ................................................................................................................................ 8
CALCULATION OF COSINE SERIES ........................................................................................................................... 9
PROGRAM TO FIND OUT AVERAGE MARKS OF STUDENTS ................................................................................... 10
STANDARD DEVIATION AND VARIATION .............................................................................................................. 12
ADDTION OF MATRIX ............................................................................................................................................ 13
MULTIPLICATION OF MATRIX ............................................................................................................................... 15
BISECTION METHOD ............................................................................................................................................. 17
NEWTON RAPHSON .............................................................................................................................................. 19
REGULA-FALSI METHOD ....................................................................................................................................... 21
NEWTON GREGORY FORWARD INTERPOLATION ................................................................................................. 23
NEWTON GREGORY BACKWARD INTERPOLATION ............................................................................................... 25
LAGRANGE METHOD OF INTERPOLATION ............................................................................................................ 27
NEWTON DIVIDED DIFFERENCE METHOD ............................................................................................................ 29
TRAPEZOIDAL RULE .............................................................................................................................................. 32
SIMPSON 1/3 RULE ............................................................................................................................................... 34
SIMPSON 3/8 RULE ............................................................................................................................................... 36
WEEDEL'S RULE .................................................................................................................................................... 38
GAUSS ELIMINATION METHOD ............................................................................................................................ 40
GAUSS JORDAN METHOD ..................................................................................................................................... 42
GAUSS SIEDAL METHOD ....................................................................................................................................... 44
CURVE FITTING - STRAIGHT LINE........................................................................................................................... 46
RUNGA-KUTA METHOD ........................................................................................................................................ 48
FUNCTION SUB PROGRAM ................................................................................................................................... 49
PROGRAM TO CALCULATE VALUE OF GIVEN FUNCTIONEXP(X*X*X*SIN(2*X)FROM 0.0 TO 1.2 USING SIMPSONS 1/3 AND
3/8 RULES RESPECTIVELY ...................................................................................................................................... 51
PARABOLIC FIT BY LEAST SQUARES ....................................................................................................................... 53
CROUTS METHOD ................................................................................................................................................ 58
MILNE'S PREDICTOR CORRECTOR ......................................................................................................................... 64
NUMERICAL DOUBLE INTEGRATION 67
ROMBERG INTEGRAL ..70

PROGRAM TO CALCULATE SUM AND AVERAGE OF 100 NATURAL NUMBERS

# include<stdio.h>
# include<conio.h>
void main( )
{
int i, n=100,sum=0, p;
float avg;
for (i=1;i<=n;i++)
{
p=i*i ;
sum=sum+p;
}
avg =sum/(i-1);
printf ("\n The sum is %d", sum);
printf ("\n The average is %f", avg);
OUTPUT:
The sum is 10670
The average is 106.000000

PROGRAM TO FIND PRODUCT OF 1ST 'N' NATURAL NUMBERS

#include<stdio.h>
#include<conio.h>
void main()
{
int i,n;
long int prod;
clrscr();
printf("\nEnter the value of n:\t");
scanf("%d",&n);
i=1,prod=1;
a5:
i=i+1;
prod=prod*i;
if(i<n)
goto a5;
printf("\nProduct of 1st %d natural
numbers:\t%ld",n,prod);
getch();
}
Output:
Enter the value of n: 5
Product of 1st 5 natural numbers: 120

FIBBONACCI SERIES
#include<stdio.h>
#include<conio.h>
#include<math.h>
void main()
{
clrscr();
int i;
double x1,x2,x;
x1=1;
x2=1;
printf("%12.0f\t%12.0f",x1,x2);
for(i=3;i<=25;i++)
{
x=x1+x2;
x1=x2;
x2=x;
printf("%12.0f",x);
}
getch();
}
OUTPUT:
1 1 2 3 5 8 13 21

GENERATING PRIME NO. BETWEEN 1 AND 100

#include<stdio.h>
#include<conio.h>
void main()
{ int i,j,count=0;
clrscr();
printf("\nprime nos. between 1 and 100\n");
for(i=1;i<=100;i++)
{ if(i==2)
i++;
j=2;
while(j<=(i/2))
{ if(i%j==0)
break;
j++;
}
if(j>(i/2))
{ count++;
printf("\t%d",i);
}
if(count%5==0)
printf("\n");
}
getch();
}
output:
prime nos. between 1 and 100
2 3 5 7 11
13 17 19 23 29
31 37 41 43 47
53 59 61 67 71
73 79 83 89 97

GENERATE PRIME NOS. BETWEEN 1 AND 100 EXCEPT THOSE DIVISIBLE BY

5
#include<stdio.h>
#include<conio.h>
void main()
{
clrscr();
int n1=1,n2=100,j,i,temp,k=0,flag=0;
for (i=n1;i<=n2;i++)
{
temp=i;
if (temp==2)
{
flag=1;
}
if (temp%5==0)
{
flag=0;
continue;
}
for (j=2;j<=temp/2;j++)
{
if (temp%j!=0)
{
flag=1;
}
else
{

flag=0;
break;
}
}
if (flag==1)
{
printf ("\t %d",temp);
}
}
OUTPUT:
2 3 7 11 13 17 19 23 29
31 37 41 43 47 53 59 61 67 71
73 79 83 89 97

CALCULATION OF SINE SERIES

#include<stdio.h>
#include<math.c>
#include<conio.h>
int fact (int a);
void main()
{
double x,sum1=0.0,sum2=0.0,sum=0.0;
int y,i;
clrscr();
printf("\nenter the value for x:");
scanf("%lf",&x);
for(i=1;i<=30;i=i+4)
sum1=sum1+((pow(x,i))/fact(i));
for(i=3;i<=30;i=i+4)
sum2=sum2+((pow(x,i))/fact(i));
sum=sum1-sum2;
printf("sum of cosine series cos(%lf)==%lf",x,sum);
getch();
} //END OF
MAIN
/* FUNCTION SUB PROGRAM */
int fact (int a)
{
int f=1,j;
if(a==0)
return(1);
else
{
for(j=1;j<=a;j++)
f=f*j;
return(f);
}
}
OUTPUT:
enter the value for x:1
sum of sine series sin(1.000000)==0.841471

CALCULATION OF COSINE SERIES

#include<stdio.h>
#include<math.h>
#include<conio.h>
long fact (int a);
void main()
{
double x,sum1=0.0,sum2=0.0,sum=0.0;
int y,i;
clrscr();
printf("\nenter the value for x:");
scanf("%lf",&x);
for(i=0;i<=30;i=i+4)
sum1=sum1+((pow(x,i))/fact(i));
for(i=2;i<=30;i=i+4)
sum2=sum2+((pow(x,i))/fact(i));
sum=sum1-sum2;
printf("sum of cosine series cos(%lf)==%lf",x,sum);
getch();
}
long fact (int a)
{
int j;
long f=1;
if(a==0)
return(1.0);
else
{
for(j=1;j<=a;j++)
f=f*j;
return(f);
}
}
OUTPUT:
enter the value for x:2
sum of cosine series cos(2.000000)==-1.350759

PROGRAM TO FIND OUT AVERAGE MARKS OF STUDENTS

#include<stdio.h>
#include<conio.h>
#include<math.h>
void main()
{
int stu[20][20],i,j,m,n,roll=0;
float avg[20],sum=0.0,max=0.0;
clrscr();
printf("\n Enter the number of students =");
scanf("%d",&n);
printf ("\n Enter the number of subjects =");
scanf ("%d",&m);
for(i=1;i<=n;i++)
{
printf("\n Enter marks for %d student =",i);
for(j=1;j<=m;j++)
{
printf("\n Subject %d",j);
scanf("%d",&stu[i][j]);
}
}
for(i=1;i<=n;i++)
{
printf("\n The average of the %d student =\n",i);
sum=0.0;
avg[i]=0.0;
for(j=1;j<=m;j++)
{
sum=sum+stu[i][j];
}
avg[i]=(sum/m-1);
printf("%f\n",avg[i]);
if(avg[i]>max)
{
max=avg[i];

roll=i;
}
}
printf("\n The topper of the class is student %d with average
=%f",roll,max);
getch();
}
OUTPUT:
Enter the number of students =3
Enter the number of subjects =5
Enter marks for 1 student
Subject 1=69
Subject 2=58
Subject 3=45
Subject 4=10
Subject 5=35
Enter marks for 2 student
Subject 1=47
Subject 2=25
Subject 3=16
Subject 4=97
Subject 5=46
Enter marks for 3 student
Subject 1=30
Subject 2=90
Subject 3=76
Subject 4=58
Subject 5=47
The average of the 1 student = 42.400002
The average of the 2 student = 45.200001
The average of the 3 student = 59.200001
The topper of the class is student 3 with average = 59.200001

STANDARD DEVIATION AND VARIATION

#include<stdio.h>
#include<conio.h>
#include<math.h>
void main()
{
clrscr();
int n;
float x[20],sum;
float am,var,sd;
int i;
printf("\n enter the no. of terms=");
scanf("%d",&n);
printf("\n enter %d values \n",n);
for(i=0;i<n;i++)
scanf("%f",&x[i]);
sum=0.0;
for(i=0;i<n;i++)
sum = sum+x[i];
am = sum/n;
sum = 0.0;
for(i=0;i<n;i++)
sum = sum+((x[i]-am)*(x[i]-am));
var = sum/n;
sd = sqrt(var);
printf("\n ARITHMETIC MEAN, STD. DEVIATION AND VARIANCE =");
printf("%f\t%f\t%f",am,var,sd);
getch();
}
OUTPUT:
Enter the no. of terms= 5
Enter 5 values
4
9
8
6
12
Arithmetic MEAN, STD. DEVIATION and VARIANCE =7.800000 ,7.360000 ,
2.712932

ADDTION OF MATRIX
#include<stdio.h>
#include<conio.h>
void main()
{
int mat1[10][10],mat2[10][10],mat3[10][10];
int i,j,m,n;
clrscr();
printf ("\n The number of rows are=");
scanf ("%d",&m);
printf ("\n The number of columns are=");
scanf ("%d",&n);
for (i=0;i<m;i++)
{
for (j=0;j<n;j++)
{
printf ("\n The matrix 1 is [%d][%d]=",i,j);
scanf ("%d",& mat1[i][j]);
}
}
for (i=0;i<m;i++)
{
for (j=0;j<n;j++)
{
printf ("\n The matrix 2is [%d][%d]=",i,j);
scanf ("%d",& mat2[i][j]);
}
}
for (i=0;i<m;i++)
{

for (j=0;j<n;j++)
{
mat3[i][j]= mat1[i][j]+mat2[i][j];
}
}
for (i=0;i<m;i++)
{
for (j=0;j<n;j++)
{
printf ("\n The resultant matrix is %d\n",mat3[i][j]);
}
printf ("\n");
}
}
OUTPUT:
The number of rows are=2
The number of columns are=2
The matrix 1 is [0][0]= 1
The matrix 1 is [0][1]= 2
The matrix 1 is [1][0]= 3
The matrix 1 is [1][1]= 4
The matrix 2 is [0][0]= 5
The matrix 2 is [0][1]= 6
The matrix 2 is [1][0]= 7
The matrix 2 is [1][1]= 8
The resultant matrix is
6 8
10 12

MULTIPLICATION OF MATRIX
#include<stdio.h>
#include<conio.h>
void main()
{int m,n,p,q,i,j,k;
int a[10][10],b[10][10],c[10][10];
clrscr();
printf("\nenter no. of row and col of matrix a:");
scanf("%d%d",&m,&n);
printf("\nenter no. of row and col of matrix b:");
scanf("%d%d",&p,&q);
if(n!=p)
{ printf("\nmatrix can't be multiplied\n");
goto end;
}
printf("\nenter matrix a\n");
for(i=0;i<m;i++)
{ for(j=0;j<n;j++)
scanf("%d",&a[i][j]);
}
printf("\nenter matrix b\n");
for(i=0;i<p;++i)
{ for(j=0;j<q;j++)
scanf("%d",&b[i][j]);
}
for(i=0;i<m;i++)
for(j=0;j<n;j++)
{ c[i][j]=0;

for(k=0;k<n;k++)
c[i][j]=c[i][j]+a[i][k]*b[k][j];
}
printf("the product ofmatrix is:");
for(i=0;i<m;i++)
{printf("\n");
for(j=0;j<q;j++)
printf("%3d",c[i][j]);
}
end:
getch();
}
output:
enter no. of row and col of matrix a:3 3
enter no. of row and col of matrix b:3 2
enter matrix a
0 1 2
1 2 3
2 3 4
enter matrix b
1 -2
-1 0
2 -1
the product ofmatrix is:
3 -2
5 -5
7 -8

BISECTION METHOD
#include<stdio.h>
#include<conio.h>
#include<math.h>
void main()
{ float fun(float m);
float x1,x2,x3,p,q,r;
int i=0;
clrscr();
l10: printf("\nequation:x*(exp(x)-1) ");
printf("\nenter the app value of x1,x2:");
scanf("%f %f",&x1,&x2);
if(fun(x1)*fun(x2)>0)
{ printf("\n wrong values entered...enter again:\n");
goto l10;}
else
printf("\n the root lies b/w %f & %f",x1,x2);
printf("\n n x1 x2 x3 f(x1) f(x2)
f(x3)");
l15: x3=(x1+x2)/2;
p=fun(x1);
q=fun(x2);
r=fun(x3);
i=i++;
printf("\n%d %f %f %f %f %f %f",i,x1,x2,x3,p,q,r);
if((p*r)>0)
x1=x3;
else
x2=x3;
if((fabs((x2-x1)/x2))<=0.001)
{printf("\n root of the equ is %f",x3);
getch();
exit(0);}

else goto l15;

}
float fun(float m)
{float g;
g=(m*(exp(m))-1);
return(g); }
/*output:
equation:x*(exp(x)-1)
enter the app value of x1,x2:0.5 1
the root lies b/w 0.500000 & 1.000000
n x1 x2 x3 f(x1) f(x2) f(x3)
1 0.500000 1.000000 0.750000 -0.175639 1.718282 0.587750
2 0.500000 0.750000 0.625000 -0.175639 0.587750 0.167654
3 0.500000 0.625000 0.562500 -0.175639 0.167654 -0.012782
4 0.562500 0.625000 0.593750 -0.012782 0.167654 0.075142
5 0.562500 0.593750 0.578125 -0.012782 0.075142 0.030619
6 0.562500 0.578125 0.570312 -0.012782 0.030619 0.008780
7 0.562500 0.570312 0.566406 -0.012782 0.008780 -0.002035
8 0.566406 0.570312 0.568359 -0.002035 0.008780 0.003364
9 0.566406 0.568359 0.567383 -0.002035 0.003364 0.000662
10 0.566406 0.567383 0.566895 -0.002035 0.000662 -0.000687
Root of the equ is 0.566895

NEWTON RAPHSON
#include<stdio.h>
#include<conio.h>
#include<math.h>
void main()
{float f(float a);
float df(float a);
int i=1;
float x0,x1,p,q;
float error =0.0001,delta =0.001;
clrscr();
printf("\n\nThe equation is X^3+1.2X^2-5X-7.2");
printf("\nenter the initial value of x0:");
scanf("%f",&x0);
printf("\n i x0 x1 f(x0) df(x0)\n ");
if (fabs (df(x0))<delta)
{printf("slope is very small and= %f",df(x0));}
else a10: p=f(x0);q=df(x0);
x1=x0-(p/q);
i++;
printf("\n %d\t%f\t%f\t%f\t%f\n",i,x0,x1,p,q);
if(fabs((x1-x0)/x1)<=error)
{printf("\nThe root of equation X^3+1.2X^2-5X-7.2 is
%f",x0);
getch();
exit(0);}
else
{x0=x1;

goto a10;}
}
/* Function sub program */
float f(float a)
{float g;
g = pow(a,3)+((1.2)*(pow(a,2)))-5*a-7.2;
return(g);}
float df(float a)
{float g1;
g1 = (3*pow(a,2))+(2.4*a)-5;
return(g1);
}
/*
output:
The equation is X^3+1.2X^2-5X-7.2
enter the initial value of x0:2
i x0 x1 f(x0) df(x0)
2 2.000000 2.372881 -4.400000 11.800000
3 2.372881 2.313010 1.052938 17.586615
4 2.313010 2.311227 0.029603 16.601265
5 2.311227 2.311225 0.000026 16.572248
The root of equation X^3+1.2X^2-5X-7.2 is 2.311227

REGULA-FALSI METHOD
#include<stdio.h>
#include<conio.h>
#include<math.h>
float f(float x)
{return(3*x-cos(x)-1);
}
void main()
{ float f(float x);
double x1,x2,m;
int c=0;
clrscr();
printf("\n enter the first approximation :");
scanf("%f",&x1);
printf("\n enter the second approximation :");
scanf("%f",&x2);
if(f(x1)*f(x2)<0.0)
{
m=(x1*f(x2)-x2*f(x1))/(f(x2)-f(x1));
while(fabs(f(m))>=0.0001)
{
c++;
if(f(x1)*f(m)<0.0)
x2=m;
else
x1=m;
m=((x1*f(x2))-(x2*f(x1)))/(f(x2)-f(x1));
printf("\n\n the %d,ilteration is %f ",c,m);

}
printf("\n\n the answer is repeated at %d ilteration
is %f",c,m);
}
else
printf("enter valid initial approximation :");
getch();
}
OUTPUT:
Enter the first approximation : 0
Enter the second approximation : 1
The 1,ilteration is 0.605959
The 2,ilteration is 0.607057
The 3,ilteration is 0.607100
The answer is repeated at 3 ilteration is 0.607100

NEWTON GREGORY FORWARD INTERPOLATION

#include<stdio.h>
#include<conio.h>
#include<math.h>
void main()
{
int n,i,j,k;
float
mx[10],my[10],x,y=0,h,p,diff[20][20],y1,y2,y3,y4;
clrscr();
printf("\nenter no. of terms:");
scanf("%d",&n);
printf("\nenter values x\ty:\n");
for(i=0;i<n;i++)
scanf("%f%f",&mx[i],&my[i]);
printf("\nenter value of x at which y is to be
calculated:");
scanf("%f",&x);
h=mx[1]-mx[0];
for(i=0;i<n-1;i++)
diff[i][1]=my[i+1]-my[i];
for(j=2;j<=4;j++)
for(i=0;i<n;i++)
diff[i][j]=diff[i+1][j-1]-diff[i][j-1];
i=0;
do
{i++;
}while(mx[i]<x);

i--;
p=(x-mx[i])/h;
y1=p*diff[i-1][1];
y2=p*(p+1)*diff[i-1][2]/2;
y3=(p+1)*p*(p-1)*diff[i-2][3]/6;
y4=(p+2)*(p+1)*p*(p-1)*diff[i-3][4]/24;
y=my[i]+y1+y2+y3+y4;
printf("\nwhen x=%6.4f,y=%6.8f",x,y);
getch();
}
OUTPUT:
enter no. of terms:5
enter values x y:
3 13
5 23
11 899
27 17315
34 35606
enter value of x at which y is to be calculated:7
when x=7.0000,y=899.00000000
programme no.24

NEWTON GREGORY BACKWARD INTERPOLATION

#include<stdio.h>
#include<conio.h>
#include<math.h>
void main()
{
int n,i,j,k;
float
mx[10],my[10],x,x0=0,y0,sum=0,fun=1,h,p,diff[20][20],y
1,y2,y3,y4;
clrscr();
printf("\nenter no. of terms:");
scanf("%d",&n);
printf("\nenter values x\ty:\n");
for(i=0;i<n;i++)
scanf("%f%f",&mx[i],&my[i]);
printf("\nenter value of x at which y is to be
calculated:");
scanf("%f",&x);
h=mx[1]-mx[0];
for(i=0;i<n-1;i++)
diff[i][1]=my[i+1]-my[i];
for(j=2;j<=4;j++)
for(i=0;i<n;i++)
diff[i][j]=diff[i+1][j-1]-diff[i][j-1];
i=0;
while(!mx[i]>x)
i++;

x0=mx[i];
y0=my[i];
p=(x-x0)/h;
sum=y0;
for(k=1;k<=4;k++)
{
fun=(fun*(p-(k-1)))/k;
sum=sum+fun*diff[i][k];
}
printf("\nwhen x=%6.4f,y=%6.8f",x,sum);
getch();
}
OUTPUT:
enter no. of terms:5
enter values x y:
20 41
40 103
60 168
80 218
100 235
enter value of x at which y is to be calculated:70
when x=70.0000,y=196.00000000

LAGRANGE METHOD OF INTERPOLATION

#include<stdio.h>
#include<conio.h>
#include<math.h>
#define max 50
void main()
{
float ax[max],ay[max],nr,dr,x,y=0;
int i,j,n;
clrscr();
printf("\nEnter No. of Points:");
scanf("%d",&n);
printf("\nEnter the given set of values:\nx\ty\n");
for(i=0;i<n;i++)
scanf("%f%f",&ax[i],&ay[i]);
printf("\nEnter the value of x at which f(x)is
required:");
scanf("%f",&x);
for(i=0;i<n;i++)
{
nr=dr=1;
for(j=0;j<n;j++)
if(j!=i)
{
nr*=x-ax[j];
dr*=ax[i]-ax[j];
}
y+=(nr/dr)*ay[i];

}
printf("\nwhen x=%5.2f then y=%5.2f",x,y);
getch();
}
output:
Enter No. of Points:6
Enter the given set of values:
x y
4 18
5 100
7 294
10 900
11 1210
13 2028
Enter the value of x at which f(x)is required:8
when x= 8.00 then y=445.62

NEWTON DIVIDED DIFFERENCE METHOD

#include<iostream.h>
#include<conio.h>
#include<math.h>
void main()
{
float ax[20], ay[20], diff[30],temp=1;
int n,j,m,z=0,A=0,k=0;
clrscr();
cout<<"Enter the number of points=";
cin>>n;
for (int i=0;i<n;i++)
{
cout<<"Enter ( x"<<i+1<<" ,y"<<i+1<<" )\n";
cin>>ax[i]>>ay[i];
}
cout<<"Enter the value of x=";
cin>>ax[n];
// creating difference table
for (i=0;i<n-1;i++)
{
diff[i]= (ay[i+1]-ay[i])/(ax[i+1]-ax[i]);
}
if(n>1)
{
m=n-1;
A=0;
for(j=0;j<n-2;j++)

{
for(z=0;z<m-1;i++,z++)
{
diff[i]= (diff[z+1+A]-diff[z+A])/(ax[z+j+2]-ax[z]);
}
A+=m;
m--;
}
}
//printing difference table
cout<<"\n difference table is as follows:\n";
for(z=0;z<i;z++)
cout<<"\n"<<diff[z];
// now calculating value of y for x
ay[n]=ay[0];
m=n;
A=0;
for (z=0;z<n-1;z++)
{
temp*=(ax[n]-ax[z]);
ay[n]+=temp*diff[z+A];
A+=m-2;
m--;
}
cout<<"\n\n The value of y for x = "<<ax[n]<<" is
:"<<ay[n];
getch();
}

OUTPUT:
Enter the number of points=5
Enter (x1 ,y1 ) 5 150
Enter (x2 ,y2 ) 7 392
Enter (x3 ,y3 ) 11 1452
Enter (x4 ,y4 ) 13 2366
Enter (x5 ,y5 ) 17 5202
Enter the value of x=9
The difference table is as follows:
121
265
457
709
24
32
42
1
1
0
The value of y for x = 9 is: 810

TRAPEZOIDAL RULE
#include<stdio.h>
#include<math.h>
#include<conio.h>
void main()
{
float fun(float);
float h , k1=0.0 ;
float x[20] , y[20];
int n , i;
clrscr();
printf("\nEnter number of parts : ");
scanf("%d" , &n);
printf("\nEnter lower and upper limits : ");
scanf("%f %f" , &x[0] , &x[n]);
y[0] = fun(x[0]);
h = (x[n] - x[0])/n ;
printf("\nx y");
printf("\n %8.5f %8.5f " , x[0] ,y[0]);
for(i=1 ; i < n ; i++)
{ x[i] = x[0] + i * h ;
y[i] = fun(x[i]);
printf("\n %8.5f %8.5f " , x[i] , y[i]);
k1 = k1 + 2 * y[i];
}
y[n] = fun(x[n]);
printf("\n %8.5f %8.5f " , x[n] , y[n]);
y[0] = (h / 2.0 ) * (y[0] + y[n] + k1 );

printf("\nresult = %f \n" , y[0]);

getch();
}
float fun(float x)
{
float g;
g = log(x);
return g;
}
OUTPUT :Enter number of parts : 6
lower and upper limits : 4 5.2
x y
4.00000 1.38629
4.24000 1.44456
4.48000 1.49962
4.72000 1.55181
4.96000 1.60141
5.20000 1.64866
result = 1.827570

SIMPSON 1/3 RULE

#include<stdio.h>
#include<math.h>
#include<conio.h>
void main()
{ float fun(float);
float h , k1=0.0 , k2=0.0 ;
float x[20] , y[20];
int n , i;
clrscr();
printf("\nEnter number of parts : ");
scanf("%d" , &n);
printf("\nEnter lower and upper limits :");
scanf("%f %f" , &x[0] , &x[n]);
y[0] = fun(x[0]);
h = (x[n] - x[0])/n ;
printf("\nx y");
printf("\n%8.5f %8.5f" , x[0] ,y[0]);
for(i=1 ; i < n ; i++)
{ x[i] = x[0] + i * h ;
y[i] = fun(x[i]);
printf("\n %8.5f %8.5f " , x[i] , y[i]);
if(i % 2 == 0)
k1 = k1 + 2 * y[i];
else
k2 = k2 + 4 * y[i];
}
y[n] = fun(x[n]);

printf("\n %8.5f %8.5f " , x[n] , y[n]);

y[0] = (h / 3.0 ) * (y[0] + y[n] + k1 + k2 );
printf("\nresult =%f \n" , y[0]);
getch();
}
float fun(float x)
{ float g;
g = sin(x) - log(x) + exp(x);
return g;
}
OUTPUT :Enter number of parts : 6
Enter lower and upper limits :0.2 1.4
x y
0.20000 3.02951
0.40000 2.79753
0.60000 2.89759
0.80000 3.16604
1.00000 3.55975
1.20000 4.06983
1.40000 4.70418
result = 4.052133

SIMPSON 3/8 RULE

#include<stdio.h>
#include<math.h>
#include<conio.h>
void main()
{ float fun(float);
float h , k1=0.0 , k2=0.0 ;
float x[20] , y[20];
int n , i;
clrscr();
printf("\nEnter number of parts : ");
scanf("%d" , &n);
printf("\nEnter lower and upper limits : ");
scanf("%f %f" , &x[0] , &x[n]);
y[0] = fun(x[0]);
h = (x[n] - x[0])/n ;
printf("\nx y");
printf("\n%8.5f %8.5f" , x[0] ,y[0]);
for(i=1 ; i < n ; i++)
{ x[i] = x[0] + i * h ;
y[i] = fun(x[i]);
printf("\n %8.5f %8.5f " , x[i] , y[i]);
if(i % 3 == 0)
k1 = k1 + 2 * y[i];
else
k2 = k2 + 3 * y[i];
}
y[n] = fun(x[n]);

printf("\n %8.5f %8.5f " , x[n] , y[n]);

y[0] = ((3 *h) / 8.0 ) * (y[0] + y[n] + k1 + k2 );
printf("\nresult =%f \n" , y[0]);
getch();
}
float fun(float x)
{ float g;
g = sin(x) - log(x) + exp(x);
return g;
}
OUTPUT : Enter number of part parts : 6
Enter lower and upper limits : 0.2 1.4
x y
0.20000 3.02951
0.40000 2.79753
0.60000 2.89759
0.80000 3.16604
1.00000 3.55975
1.20000 4.06983
1.40000 4.70418
result = 4.052991

WEEDEL'S RULE
#include<stdio.h>
#include<math.h>
#include<conio.h>
void main()
{ float fun(float);
float h , k1=0.0 , k2=0.0 , k3=0.0 , k4=0.0;
float x[20] , y[20];
int n , i;
clrscr();
printf("\nEnter number of parts : ");
scanf("%d" , &n);
printf("\nEnter lower and upper limits : ");
scanf("%f %f" , &x[0] , &x[n]);
y[0] = fun(x[0]);
h = (x[n] - x[0]) / n;
printf("\nx y");
printf("\n%8.5f %8.5f" , x[0] ,y[0]);
for(i=1 ; i < n ; i++)
{ x[i] = x[0] + i * h ;
y[i] = fun(x[i]);
printf("\n %8.5f %8.5f " , x[i] , y[i]);
if(i % 6 == 0)
k1 = k1 + 2 * y[i];
else if(i % 3 == 0)
k1 = k1 + 6 * y[i];
else if(i % 2 == 0)
k1 = k1 + y[i];

else
k4 = k4 + 5 * y[i];
}
y[n] = fun(x[n]);
printf("\n %8.5f %8.5f " , x[n] , y[n]);
y[0] = ((3 * h)/10) * (y[0] + y[n] + k1 + k2 + k3 +
k4);
printf("\nresult =%f \n" , y[0]);
getch();
}
float fun(float x)
{ float g;
g = sin(x) - log(x) + exp(x);
return g;
}
OUTPUT :Enter number of parts : 6
Enter lower and upper limits : 0.2 1.4
x y
0.20000 3.02951
0.40000 2.79753
0.60000 2.89759
0.80000 3.16604
1.00000 3.55975
1.20000 4.06983
1.40000 4.70418
result = 4.051446

GAUSS ELIMINATION METHOD

#include<stdio.h>
#include<conio.h>
#include<math.h>
#define n 3
void main()
{ float temp , s , matrix[n][n+1] , x[n];
int i , j , k;
clrscr();
printf("\nEnter the elements of the augment matrix row
wise
:\n");
for(i = 0 ; i < n ; i++)
for(j=0 ; j <= n ; j++)
scanf("%f" , &matrix[i][j]);
printf("\nmatrix:-");
for(i=0 ; i<n ; i++)
{ for(j=0 ;j<=n ;j++)
printf("%f\t",matrix[i][j]);
printf("\n");
}
/*now calculating the upper triangular matrix */
for(j=0 ; j < n-1 ; j++)
for(i=j+1 ; i < n ; i++)
{ temp = matrix[i][j] / matrix[j][j];
for(k = 0 ; k <= n ; k++)
matrix[i][k] -= matrix[j][k] * temp;
}

//now performing back substitution

for(i = n -1 ; i >= 0 ; i--)
{ s = 0;
for(j = i + 1 ; j < n ; j++)
s += matrix[i][j] * x[j];
x[i] = (matrix[i][n] - s) / matrix[i][i];
}
//now printing the result
printf("\nSolution is :-\n");
for(i = 0 ; i < n ; i++)
printf("\nx[%d]=%7.4f" , i+1 ,x[i]);
getch();
}
OUTPUT :Enter the elements of the augment matrix row wise :
3 1 -1 3
2 -8 1 -5
1 -2 9 8
matrix:3.000000 1.000000 -1.000000 3.000000
2.000000 -8.000000 1.000000 -5.000000
1.000000 -2.000000 9.000000 8.000000
Solution is :x[1]= 1.0000
x[2]= 1.0000
x[3]= 1.0000

GAUSS JORDAN METHOD

#include<stdio.h>
#include<conio.h>
#include<math.h>
#define n 3
void main()
{ float temp , matrix[n][n+1];
int i , j , k;
clrscr();
printf("\nEnter the elements of the augment matrix row
wise :\n");
for(i = 0 ; i < n ; i++)
for(j=0 ; j <= n ; j++)
scanf("%f" , &matrix[i][j]);
/*now calculating the digonal matrix */
for(j=0 ; j < n ; j++)
for(i=0 ; i < n ; i++)
if(j != i)
{ temp = matrix[i][j] / matrix[j][j];
for(k = 0 ; k <= n ; k++)
matrix[i][k] -= matrix[j][k] * temp;
}
/*now printing the matrix */
printf("\nThe digonal matrix is :--\n");
for(i = 0 ; i < n ; i++)
{ for(j=0 ; j <= n ; j++)
printf("\t%f" , matrix[i][j]);

printf("\n");
}
//now printing the result
printf("\nSolution is :-\n");
for(i = 0 ; i < n ; i++)
printf("\nx[%d]=%7.4f" , i+1
,matrix[i][n]/matrix[i][i]);
getch();
}
OUTPUT :Enter the elements of the augment matrix row wise :3 1 -1 3
2 -8 1 -5
1 -2 9 8
The digonal matrix is :-3.000000 0.000000 0.000000 3.000000
0.000000 -8.666667 0.000000 -8.666667
0.000000 0.000000 8.884615 8.884615
Solution is :x[1]= 1.0000
x[2]= 1.0000
x[3]= 1.0000

GAUSS SIEDAL METHOD

#include<stdio.h>
#include<conio.h>
#include<math.h>
#include<process.h>
void main()
{
float a[10][10],x[10],aerr, maxerr, t, s, err;
int i,j,itr,maxitr,n;
printf ("\n Enter the number of unknowns=");
scanf ("%d",&n);
for(i=1;i<=n;i++)
x[i]=0.0;
printf ("\n Enter the augmented matrix row wise=");
for (i=1;i<=n;i++)
for (j=1;j<=n+1;j++)
scanf ("%f",&a[i][j]);
printf ("\n Enter allowed error, max iteration=");
scanf ("%f %d",&aerr,&maxitr);
printf ("\n Iteration");
for (i=1;i<=n;i++)
printf ("\n x[%d]",i);
for (itr=1;itr<=maxitr;i++)
{
maxerr=0;
for (i=1;i<=n;i++)
{
s=0;
for (j=1;j<=n;j++)
if (j!=i)
s = s+a[i][j]*x[j];
t = (a[i][n+1]-s)/a[i][i];
err=fabs(x[i]-t);

if (err>maxerr)
maxerr=err;
x[i]=t;
}
printf ("%d",itr);
for (i=1;i<=n;i++)
printf ("%7.4f",x[i]);
if (maxerr<aerr)
{
for (i=1;i<=n;i++)
printf ("x[%d]=%7.4f",i,x[i]);
exit(0);
} }
}
OUTPUT:
Enter the number of unknowns = 3
Enter the augmented matrix row wise
20 1 -2 17
3 20 -1 -18
2 -3 20 25
Enter allowed error, max iteration=0.001 ,4
Iteration x[1]= 0.8500 -1.0275
x[2] = 1.01091 1.0025
x[3] = -0.9998 0.99981
1.0000 - 1.0000 1.0000
x[1]= 1.0000 x[2]=-1.0000 x[3]= 1.0000

CURVE FITTING - STRAIGHT LINE

# include<iostream.h>
# include<conio.h>
# include<math.h>
void main()
{
int i=0,ob;
float x[10],y[10],xy[10],x2[10],sum1=0,sum2=0,sum3=0,sum4=0;
double a,b;
printf("\n Enter the no. of observations :");
scanf(%d,&ob);
printf("\n Enter the values of x :\n");
for (i=0;i<ob;i++)
{
Printf("\n Enter the value of x[%d]",i+1);
Scanf(%f,&x[i]);
sum1+=x[i];
}
Printf(\n Enter the values of y :\n");
for (i=0;i<ob;i++)
{
Printf("\n Enter the value of y[%d]",i+1);
Scanf(%f,&y[i];
sum2+=y[i];
}
for(i=0;i<ob;i++)
{
xy[i]=x[i]*y[i];
sum3+=xy[i];
}
for(i=0;i<ob;i++)
{
x2[i]=x[i]*x[i];

sum4+=x2[i];
}
a=(sum2*sum4-sum3*sum1)/(ob*sum4-sum1*sum1);
b=(sum2-ob*a)/sum1;
printf("\n\n Equation of the STRAIGHT LINE of the form y=a+b*x
is );
printf("\n\n\t\t\t y=[%f] + [%f]x.a,b);
}
OUTPUT:
Enter the no. of observations : 5
Enter the values of x :
Enter the value of x1 : 1
Enter the value of x2 : 2
Enter the value of x3 : 3
Enter the value of x4 : 4
Enter the value of x5 : 5
Enter the values of y :
Enter the value of y1: 14
Enter the value of y2: 27
Enter the value of y3: 40
Enter the value of y4: 55
Enter the value of y5: 68
Equation of the STRAIGHT LINE of the form y=a+b*x is :
y=0 + 13.6*x

Runga-kuta Method
#include<stdio.h>
#include<conio.h>
#include<math.h>
void main()
{
float f(float x , float y);
float x0 = 0.1 , y0 = 1 , xn = 2, h =0.2 , k1 , k2 ,
k3 , k4 ;
int i , n ;
clrscr();
printf("\ndy/dx = (x^2 +y^2)/10 ");
printf("\ngiven y0=1 && x0= 0.1 && h=0.2 (in the range
x0 < x <
2.0)\n");
n = (xn - x0) / h;
for(i = 0 ; i <= 10 ; i++)
{
k1 = h * f(x0 , y0);
k2 = h * f((x0 + h)/2 , (y0 + k1)/2);
k3 = h * f((x0 + h)/2 , (y0 + k2)/2);
k4 = h * f(x0 + h , y0 + k3);
y0 = y0 + (1 / 6.0) * (k1 + 2*k2 + 2*k3 + k4);
printf("\nThe solution of differential equation is
when x =
%f y = %f \n" , x0 , y0);
x0 = x0 + h;
}

getch();
}
Function sub program
float f(float x , float y)
{
float g;
g = (x*x + y*y) / 10 ;
return g ;
}
OUTPUTdy/dx = (x^2 +y^2)/10
given y0=1 && x0= 0.1 && h=0.2 (in the range x0 < x
<2.0)

The solution of differential equation is when x

=0.100000 y = 1.010757

The solution of differential equation is when x

=0.300000 y = 1.023081

The solution of differential equation is when x

=0.500000 y = 1.037818

The solution of differential equation is when x

=0.700000 y = 1.055833

The solution of differential equation is when x

=0.900000 y = 1.078011

The solution of differential equation is when x

=1.100000 y = 1.105264

The solution of differential equation is when x

=1.300000 y = 1.138531

The solution of differential equation is when x

=1.500000 y = 1.178783

The solution of differential equation is when x

=1.700000 y = 1.227032

The solution of differential equation is when x

=1.900000 y = 1.284333

The solution of differential equation is when x

=2.100000 y = 1.351801

Program to calculate value of the given function exp(x*x*x*sin(2*x)from

0.0 to 1.2 using Simpsons 1/3 and 3/8 rule respectively
#include<stdio.h>
#include<conio.h>
#include<math.h>
void main()
{
float x[15],y[15],h,k1,k2,k3,k4,k5,k6;
int i,j,n;
clrscr();
printf("Enter value of n:\n");
scanf("%d",&n);
k1=k2=0.0,x[0]=0.0,x[n]=1.2,k4=0.0,k5=0.0;
h=(x[n]-x[0])/n;
for(i=1;i<n;i++)
x[i]=x[0]+i*h;
for(i=0;i<=n;i++)
y[i]=exp(pow(x[i],3)*sin(2*x[i]));
for(i=1;i<n;i++)
{
if(i%2==0)
k1=k1+y[i];

else
k2=k2+y[i];
}
k3=h*(y[0]+y[n]+2*k1+4*k2)/3;
printf("Value of integral using Simpsons 1/3 rule");
printf("%f",k3);
/*Simpsons 3/8 rule is as follows*/
for(j=1;j<n;j++)
{
if(j%3==0)
k4=k4+y[j];
else
k5=k5+y[j];
}
k6=((3.0*h)*(y[0]+y[n]+2*k4+3*k5))/8;
printf("\nValue of integral using Simpsons 3/8 rule is
%f",k6);
getch();
}
OUTPUTEnter value of n:
6
Value of integral using Simpsons 1/3 rule is 1.898555
Value of integral using Simpsons 3/8 rule is 1.894638

Parabolic fit by least squares

#include<stdio.h>
#include<conio.h>
float arr[3][4],x,y,xx,a,b,c;
int n;
void initialize()
{
int i,j;
for(i=0;i<3;i++)
for(j=0;j<4;j++)
arr[i][j]=0;
}
void readdata()
{
int i;
for(i=0;i<n;i++)
{
printf("Pair num %d\n",i+1);
scanf("%f %f",&x,&y);
xx=x*x;
arr[0][1]+=x;
arr[0][2]+=xx;
arr[1][2]+=x*xx;
arr[2][2]+=xx*xx;

arr[0][3]+=y;
arr[1][3]+=x*y;
arr[2][3]+=xx*y;
}
arr[1][0]=arr[0][1];
arr[1][1]=arr[0][2];
arr[2][0]=arr[1][1];
arr[2][1]=arr[1][2];
}
void displayaugmentedmatrix()
{
int i,j;
printf("The augmented matrix is \n");
for(i=0;i<3;i++)
{
for(j=0;j<4;j++)
{
printf("%9.4f",arr[i][j]);
}
printf("\n");
}
}
void applygaussjordon()
{

int i,j,k;
float t;
for(j=0;j<3;j++)
for(i=0;i<3;i++)
if(i!=j)
{
t=arr[i][j]/arr[j][j];
for(k=0;k<4;k++)
arr[i][k]-=arr[j][k]*t;
}
a=arr[0][3]/arr[0][0];
b=arr[1][3]/arr[1][1];
c=arr[2][3]/arr[2][2];
}
void displaybestfit()
{
printf("y=%f",a);
if(b>=0)
printf("+");
printf("%f x",b);
if(c>0)
printf("+");
printf("%f x^2",c);
}

void main()
{
clrscr();
printf("Enter the number of pairs of observed
values\n");
scanf("%d",&n);
initialize();
arr[0][0]=n;
readdata();
displayaugmentedmatrix();
applygaussjordon();
printf("The best fit curve is\n");
displaybestfit();
}
Enter the number of pairs of observed values
5
Pair num 1
0
1
Pair num 2
1
1.8
Pair num 3
2

1.3
Pair num 4
3
2.5
Pair num 5
4
6.3
The augmented matrix is
5.0000
10.0000

10.0000

30.0000

12.9000

30.0000 100.0000

37.1000

30.0000 100.0000 354.0000 130.3000

The best fit curve is
y=1.420001-1.070003 x+0.550001 x^2

CROUTS METHOD
# include<stdio.h>
# include<conio.h>
# define n 4
typedef float matrix[n][n];
matrix l,u,a;
float b[n],x[n],y[n];
void urow(int i)
{
float s;
int j,k;
for(j=i;j<n;j++)
{
s=0;
for(k=0;k<n-1;k++)
s+=u[k][j]*l[i][k];
u[i][j]=a[i][j]-s;
}
}

void lcol(int j)
{
float s;
int i,k;
for(i=j+1;i<n;i++)

{
s=0;
for(k=0;k<=j;k++)
s+=u[k][j]*l[i][k];
l[i][j]=(a[i][j]-s)/u[j][j];
}
}

void printmat(matrix m)
{
int i,j;
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
printf("%8.4f",m[i][j]);
printf("\n");
}
}

void readmat()
{
int i,j;
printf("Enter the elements of augmented matrix\n");
for(i=0;i<n;i++)
{

for(j=0;j<n;j++)
scanf("%f",&a[i][j]);
scanf("%f",&b[i]);
}
}

void solveLY_B()
{
int i,j;
float s;
for(i=0;i<n;i++)
{
s=0;
for(j=0;j<i;j++)
s+=l[i][j]*y[j];
y[i]=b[i]-s;
}
}

void solveUX_Y()
{
int i,j;
float s;
for(i=n-1;i>=0;i--)
{

s=0;
for(j=i+1;j<n;j++)
s+=u[i][j]*x[j];
x[i]=(y[i]-s)/u[i][i];
}
}

void main()
{
int i,j,m;
clrscr();
readmat();
for(i=0;i<n;i++)
l[i][i]=1.0;
for(m=0;m<n;m++)
{
urow(m);
if(m<n-1)
lcol(m);
}
printf("\n\t\tU\n");
printmat(u);
printf("\n\t\tL\n");
printmat(l);
solveLY_B();

solveUX_Y();
printf("The solution is:\n");
for(i=0;i<n;i++)
printf("x[%d]=%6.4f\n",i+1,x[i]);
getch();
}
OUTPUTEnter the elements of augmented matrix
5 1 1 1 4
1 7 1 4 6
1 1 6 1 -5
1 1 1 4 -6

U
5.0000

1.0000

1.0000

1.0000

0.0000

6.8000

0.8000

3.8000

0.0000

0.0000

5.7059

0.3529

0.0000

0.0000

0.0000

3.3093

L
1.0000

0.0000

0.0000

0.0000

0.2000

1.0000

0.0000

0.0000

0.2000

0.1176

1.0000

0.0000

0.2000

0.1176

0.1237

1.0000

The solution is:

x[1]=1.0000
x[2]=2.0000
x[3]=-1.0000
x[4]=-2.0000

MILNE'S PREDICTOR CORRECTOR

# include<stdio.h>
# include<conio.h>
# include<math.h>
float x[5],y[5],h;
float f(int i)
{
return x[i]-y[i]*y[i];
}
void correct()
{
y[4]=y[2]+(h/3)*(f(2)+4*f(3)+f(4));
printf("%23s %8.4f %8.4f \n","",y[4],f(4));
}
main()
{
float xr,aerr,yc;
int i;
clrscr();
puts("Enter the values of x0,xr,h,allowed error");
scanf("%f %f %f %f",&x[0],&xr,&h,&aerr);
puts("Enter the values of y[i],i=0,3");
for(i=0;i<=3;i++) scanf("%f",&y[i]);
for(i=1;i<=3;i++) x[i]=x[0]+i*h;
puts(" x

Predicated

Corrected");

puts("

f");

while(1)
{
if(x[3]==xr) return;
x[4]=x[3]+h;
y[4]=y[0]+(4*h/3)*(2*(f(1)+f(3))-f(2));
printf("%6.2f %8.4f %8.4f\n",x[4],y[4],f(4));
correct();
while(1)
{
yc=y[4];
correct();
if(fabs(yc-y[4])<=aerr)break;
}
for(i=0;i<=3;i++)
{
x[i]=x[i+1];
y[i]=y[i+1];
}
}
getch();
}

OUTPUT
Enter the values of x0,xr,h,allowed error
0 1 .2 .0001
Enter the values of y[i],i=0,3
0 .02 .0795 .1762
x

0.80

1.00

Predicated
y

0.3049

0.7070

0.4554

Corrected
y

0.3046

0.7072

0.3046

0.7072

0.4556

0.7925

0.4556

0.7925

0.7926

NUMERICAL DOUBLE INTEGRATION

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

float func(float x, float y)

{
//return(1/sqrt(pow(x,2)+pow(y,2)));
return(sin(x*y)/(1+x*y));
}

void main()
{
int i,j,x,y;
float h,k,a,b,c,d,xy[20][20],ax[20],ans;
clrscr();
printf("Integral a to b, integral c to d
(function) dxdy");
printf("\nEnter a,b,c,d,h,k where h,k are number
of parts for a,b & c,d resp\n");
fflush(stdin);
scanf("%f %f %f %f %f %f",&a,&b,&c,&d,&h,&k);
x=((b-a)/h)+0.5;
y=((d-c)/k)+0.5;

printf("\nx=%d,y=%d\n",x,y);
for(i=0;i<=x;i++)
{
for(j=0;j<=y;j++)
{
xy[i][j]=func(a+i*h,c+j*k);
printf("%0.4f

",xy[i][j]);

}
printf("\n");
}
for(i=0;i<=x;i++)
{
ax[i]=0;
for(j=0;j<=y;j++)
{
if(j==0 || j==y)
ax[i]+=xy[i][j];

Simpson of 1st row goes into A0 and then 2nd row into
A1 and so on upto An

else if(j%2==1)
ax[i]+=4*xy[i][j];
else
ax[i]+=2*xy[i][j];
}
ax[i]=(h/3)*ax[i];
printf("\nAx(%d)=%f",i,ax[i]);
}

ans=0;
for(i=0;i<=x;i++)
Now Simpson of vertical column of A[i],i.e., A1, A2, A3,..., An goes
into ans

{
if(i==0 || i==x)
ans+=ax[i];
else if(i%2==1)
ans+=4*ax[i];
else
ans+=2*ax[i];
}
ans=(k/3)*ans;

printf("\nValue of integral is %f",ans);

getch();
}

ROMBERG INTEGRATION
// Romberg
#include<stdio.h>
#include<conio.h>
#include<math.h>

#define fun(x) x/sin(x)

void main()
{
int i,j,k,n,p;
float h,y[50],a,b,ih,ir[50];
clrscr();

printf("Enter the upper, lower limits and the

value of n\n");
scanf("%f\t%f\t%d",&a,&b,&n);

for(i=0;i<=n;i++)
{
ih=0;
p=pow(2,i);

h=(b-a)/p;
for(j=0;j<=p;j++)
{
y[j]=a+j*h;
if(j!=0)
y[j]=y[j]/sin(y[j]);
else
y[0]=1;
if(j>0 && j<p)
ih=ih+2*(y[j]);
}
ih=ih+y[0]+y[p];
ih=ih*h/2;
ir[i]=ih;
printf("\n%f",ir[i]);
}
k=2;
while(n>=1)
{
p=pow(2,k);
for(i=0;i<n;i++)
ir[i]=(p*ir[i+1]-ir[i])/(p-1);
n--;
k=k+2;
}

printf("\nThe value of integral is %f",ir[0]);

getch();
}