Continuous distribution(weibull,uniform,triangle) implementation

#include<stdio.h>
#include<conio.h>
#include<math.h>
void triangular();
void weibull();
void lognormal();
void uniform();
void main()
{
 int c;
 clrscr();
 printf("choose distribution system:");
 printf("\n1:Triangular distribution");
 printf("\n2:Weibull distribution ");
 printf("\n3:Lognormal distribution");
 printf("\n4:Uniform distribution");
 printf("enter ur choice:");
 scanf("%d",&c);
 clrscr();
 switch(c)
 {
 case 1:
 triangular();
 break;
 case 2:
 weibull();
 break;
 case 3:
 normal();
 break;
 case 4:
 uniform();
 break;
 default:
 printf("invalid selection");
 exit(0);
 }
 getch();
}
void triangular()
{
 double x,a,b,c;
 printf("enter d value of x, a, b & c:  ");
scanf(" %lf %lf %lf %lf",&x, &a, &b, &c);

printf(" f(%.2f) = %f",x,f(x,a,b,c));

printf(" F(%.2f) = %f",x,F(x,a,b,c));
double f(double x, double a, double b, double c)
{


if(a <= x && x <= b)
{

return (2*(x-a))/((b-a)*(c-a));
}
else if( b < x && x <= c)
{
return 2*(c-x)/((c-b)*(c-a));
}
else
return 0;

}

double F(double x, double a, double b, double c)
{
if(x<=a)
return 0;

else if( a{

return ( (x-a)*(x-a)/((b-a)*(c-a)) );

}
else if(b < x && x <= c )
{

return (1 - (c-x)*(c-x)/((c-b)*(c-a)));

}
else if(x>c)
return 1;
}
}

void weibull()
{
int x;
double v,a,b;
printf("enter d value of x, location, shape & scale:  ");
scanf(" %d %lf %lf %lf",&x, &v, &b, &a);

printf(" f(%d) = %f",x,f(x,v,a,b));

printf(" F(%d) = %f",x,F(x,v,a,b));
double f(int x, double v, double a, double b)
{

if(x< v)
return 0;

else
{
return b/a*(pow((x-v)/a,b-1))*exp(-pow((x-v)/a,b));

}

}

double F(int x, double v, double a, double b)
{
if(xreturn 0;

else
{

return (1 - exp(-pow((x-v)/a,b)));

}

}
void lognormal()
{
int sigma,x,u;
printf("enter sigma,x,u");
scanf("%d%d%d",&sigma,&x,&u);
if(x>0)
printf("pdf=%.3lf",(1/(sqrt(2*PI)*sigma*x))*exp(-pow((log(x)-u),2)/(2*sigma*sigma)));
}
void uniform()
{
int a,x,b;
printf("enter the value for a,x,b:");
scanf("%d%d%d",&a,&x,&b);
printf(" f(%d) = %f",x,f(x,a,b));

printf(" F(%d) = %f",x,F(x,a,b));
double f(int x, double v, double a, double b)
{
if(a<=x && x<=b)
return (1/(b-a));
else
return 0;
}
double F(int x, double v, double a, double b)
{
if(xreturn 0;
else if(a<=x && xreturn((x-a)/(b-a));
else if(x>=b)
return 1;
}
}

Bernouli distribution implementation

void bernouli()
{
double p;
printf("bernouli distribution implementation:\n");
printf("enter success probability");
scanf("%lf",&p);
printf("\nmean =%.3lf",p);
printf("\tvariance =%.3lf",p*(1-p));

}

Poisson distribution implementation

void poisson()
{
int x;
double a;
printf("poisson distribution implementation:\n");
printf("enter x & a:");
scanf("%d%lf",&x,&a);
if(x>0)
printf("pmf=%.3lf",(exp(-a)*pow(a,x))/fact(x));
}

Binomial distribution implementation

void binomial()
{
int n,x;
double p;
printf("binomial distribution implementation:\n");
printf("enter n,x,p");
scanf("%d%d%lf",&n,&x,&p);
if(x>0)
printf("\npmf=%.3lf",(fact(n)/(fact(x)*fact(n-x)))*pow(p,x)*pow((1-p),(n-x)));
printf("\nmean=%.3lf \t variance=%.3lf",n*p,n*p*(1-p));
}
void neg_binomial()
{
int y,k;
double p;
printf("negative binomial distribution:\n");
printf("enter y,k and p for kth success (y>k)");
scanf("%d%d%lf",&y,&k,&p);
if(y>k)
printf("pmf=%.3lf",(fact(y-1)/(fact(k-1)*fact(y-k)))*pow((1-p),(y-k))*pow(p,k));

}

C Program Of NA Using Guass Sedial Method

//Gauss Seidal method
# include <stdio.h>
# include <conio.h>
# include <math.h>
# define MAXIT 50
# define EPS .000001
void main()
{
float a[10][10],b[10],x[10],sum,x0[10];
int i,j,n,count=0;
clrscr();
printf("Enter Number of equation : ");
scanf("%d",&n);
printf("Enter Coefficients row by row \n");
printf("One row in each line\n");
for(i=1;i<=n;i++)
for(j=1;j<=n;j++)
scanf("%f",&a[i][j]);
printf("Enter vector elements\n");
for(i=1;i<=n;i++)
{
x0[i]=x[i]=0;
scanf("%f",&b[i]);
}
printf("N\t");
for(i=1;i<=n;i++)
printf("X%d \t",i);
printf("\n");
printf("-------------------------------------------------------------------\n");
s: printf("%d\t",count+1);
for(i=1;i<=n;i++)
{
sum=0;
for(j=1;j<=n;j++)
{
if(i==j)
continue;
else
sum=sum+(a[i][j]*x[j]);
}
x[i]=(b[i]-sum)/a[i][i];
printf("%f \t",x[i]);
}
count++;
if(fabs(x[n]-x0[n])>EPS && count<MAXIT)
{
for(i=1;i<=n;i++)
x0[i]=x[i];
printf("\n");
goto s;
}
else
{
printf("\n----------------------------------------------\nSolution : \n");
for(i=1;i<=n;i++)
printf("X%d = %3.4f\t",i,x[i]);
}
getch();
}

OUTPUT

Enter Number of equation : 4
Enter Coefficients row by row
One row in each line
10 -2 -1 -1
-2 10 -1 -1
-1 -1 10 -2
-1 -1 -2 10
Enter vector elements
3 15 27 -9
N X1 X2 X3 X4
-------------------------------------------------------------------
1 0.300000 1.560000 2.886000 -0.136800
2 0.886920 1.952304 2.956562 -0.024765
3 0.983641 1.989908 2.992402 -0.004165
4 0.996805 1.998185 2.998666 -0.000768
5 0.999427 1.999675 2.999757 -0.000138
6 0.999897 1.999941 2.999956 -0.000025
7 0.999981 1.999989 2.999992 -0.000004
8 0.999997 1.999998 2.999999 -0.000001
9 0.999999 2.000000 3.000000 -0.000000
---------------------------------------------------------------------
Solution :
X1 = 1.0000 X2 = 2.0000 X3 = 3.0000 X4 = -0.0000

C Program Of NA Using Euler Method

/*Euler method */
# include <stdio.h>
# include <conio.h>
void main()
{
int c=0;
float x,y,xp,h,dy,i,n;
float f(float,float);
clrscr();
printf("Solution by Euler Method\n");
printf("Enter initial Boundry condition x,y : ");
scanf("%f%f",&x,&y);
printf("Enter Value of X at which Y is required : ");
scanf("%f",&xp);
printf("Enter Interval ,h : ");
scanf("%f",&h);
printf(" No. \t X\t f(x,y) \t Y\n");
printf("----------------------------------------------------------\n");
for(i=x;i<=xp;i=i+h)
{
c++;
n=y+h*f(i,y);
printf("%2d\t %2.3f\t %5.5f\t %5.6f\n",c,i,f(i,y),n);
y=n;
}
printf("----------------------------------------------------------\n");
printf("Value of y @ %f is %f",xp,n);
getch();
}
float f(float x,float y)
{
return (y-x)/(y+x);
}
OUTPUT
Solution by Euler Method
Enter initial Boundry condition x,y : 1 2
Enter Value of X at which Y is required : 2
Enter Interval ,h : .25
No. X f(x,y) Y
----------------------------------------------------------
1 1.000 0.33333 2.083333
2 1.250 0.25000 2.145833
3 1.500 0.17714 2.190119
4 1.750 0.11170 2.218045
5 2.000 0.05169 2.230968
----------------------------------------------------------
Value of y @ 2.000000 is 2.230968

C Program Of NA Using Runga-Kutta Mthod Of 4th Order

/* Runge-kutta method of 4th order to solve 10*dy/dx=(x*x)+(y*y)*/
# include <stdio.h>
# include <conio.h>
void main()
{
int c=0;
float x,y0,xp,h,i,y1,m1,m2,m3,m4;
float f(float,float);
clrscr();
printf("Solution by Runge kutta 2nd order Method\n");
printf("Enter initial Boundry condition x,y : ");
scanf("%f%f",&x,&y0);
printf("Enter Value of X at which Y is required : ");
scanf("%f",&xp);
printf("Enter Interval ,h : ");
scanf("%f",&h);
printf(" No. X\t m1 \t m2\t m3 \t m4 \t Y\n");
printf("-------------------------------------------------------------------\n");
for(i=x;i<=xp;i=i+h)
{
c++;
m1=h*f(i,y0);
m2=h*f(i+(h/2),y0+(m1/2));
m3=h*f(i+(h/2),y0+(m2/2));
m4=h*f(i+h,y0+m3);
y1=y0+((m1+2*m2+2*m3+m4)/6);
printf("%2d %5.6f %5.6f %5.6f %5.6f %5.6f %5.6f\n",c,i,m1,m2,m3,m4,y1);
y0=y1;
}
getch();
}
float f(float x,float y)
{
return ((x*x)+(y*y))/10;
}



OUTPUT



Solution by Runge kutta 2nd order Method
Enter initial Boundry condition x,y : 0 1
Enter Value of X at which Y is required : .09


Enter Interval ,h : .03
No. X m1 m2 m3 m4 Y
-------------------------------------------------------------------------------
1 0.000000 0.003000 0.003010 0.003010 0.003021 1.003010
2 0.030000 0.003021 0.003033 0.003033 0.003047 1.006043
3 0.060000 0.003047 0.003062 0.003062 0.003079 1.009106
4 0.090000 0.003079 0.003097 0.003097 0.003117 1.012204

C Program Of NA Using Runga-Kutta Method

/* Runge-kutta method of 2nd order */
# include <stdio.h>
# include <conio.h>
void main()
{
int c=0;
float x,y0,xp,h,i,y1,m1,m2;
float f(float,float);
clrscr();
printf("Solution by Runge kutta 2nd order Method\n");
printf("Enter initial Boundry condition x,y : ");
scanf("%f%f",&x,&y0);
printf("Enter Value of X at which Y is required : ");
scanf("%f",&xp);
printf("Enter Interval ,h : ");
scanf("%f",&h);
printf(" No. \t X\t m1 \t m2\t Y\n");
printf("-------------------------------------------------------------------\n");
for(i=x;i<=xp;i=i+h)
{
c++;
m1=h*f(i,y0);
m2=h*f(i+h,y0+m1);
y1=y0+(.5*(m1+m2));
printf("%2d\t%5.6f\t%5.6f\t%5.6f\t %5.6f\n",c,i,m1,m2,y1);
y0=y1;
}
getch();
}
float f(float x,float y)
{
return (y-x);
}
OUTPUT
Solution by Runge kutta 2nd order Method
Enter initial Boundry condition x,y : 0 2
Enter Value of X at which Y is required : .1
Enter Interval ,h : .1
No. X m1 m2 Y
--------------------------------------------------------------------
1 0.000000 0.200000 0.210000 2.205000
2 0.100000 0.210500 0.221550 2.421025

C Program Of NA Using Simpson 3/8 Rule

/*Simpson 3/8 rule */
# include <stdio.h>
# include <conio.h>
# define MAX 20
void main()
{
int j,n=0;
float x[MAX],y[MAX],sum=0,h,res,lb,ub,i;
clrscr();
printf("Solution of 1/(1+x)dx using Simpson's 3/8 rule \n");
printf ("Enter initial value : ");
scanf("%f",&lb);
printf("Enter final value : ");
scanf("%f",&ub);
printf("Enter no. of Subinterval : ");
scanf("%f",&h);
h=(ub-lb)/h;
for(i=lb;i<=ub;i=i+h)
{
x[n]=i;
y[n]=1/(1+x[n]);
n++;
}
printf("No.\t X\t\tY=1/(1+x)\n");
printf("---------------------------------------\n");
sum=y[0]+y[n-1];
for(j=0;j<n;j++)
printf("%d\t%f\t%f\n",j,x[j],y[j]);
printf("---------------------------------------\n");
for(j=1;j<n-1;j++)
{
if(j%3==0)
sum=sum+y[j]*2;
else
sum=sum+y[j]*3;
}
res=((3*h)/8)*sum;
printf("\nIntegral from %f to %f when h = %f is = %f",x[0],x[n-1],h,res);
getch();
}

OUTPUT

Solution of 1/(1+x)dx using Simpson's 3/8 rule
Enter initial value : 6
Enter final value : 15
Enter no. of Subinterval : 8
No. X Y=1/(1+x)
---------------------------------------
0 6.000000 0.142857
1 7.125000 0.123077
2 8.250000 0.108108
3 9.375000 0.096386
4 10.500000 0.086957
5 11.625000 0.079208
6 12.750000 0.072727
7 13.875000 0.067227
8 15.000000 0.062500
---------------------------------------

Integral from 6.000000 to 15.000000 when h = 1.125000 is = 0.817303

C Program Of NA Using Simpson 1/3 Rule

/*Simpson 1/3 Rule */
# include <stdio.h>
# include <conio.h>
# define MAX 20
void main()
{
int i,j,n;
float x[MAX],y[MAX],sum=0,h,res;
clrscr();
printf("Solution of 1/(1+x)dx using Simpson's 1/3 rule \n");
printf("Enter Number of data points : ");
scanf("%d",&n);
printf("Enter value of table value set by set\n");
for(i=1;i<=n;i++)
{
scanf("%f",&x[i]);
y[i]=1/(x[i]+1);
}
printf("X \t\t Y\n");
for(i=1;i<=n;i++)
printf("%f\t%f\n",x[i],y[i]);
h=x[2]-x[1];
printf("\nSegment Interval `h':=0.25\n");
sum=sum+y[1]+y[n];
for(i=2;i<n;i++)
{
if(i%2==0)
sum=sum+y[i]*4;
else
sum=sum+y[i]*2;
}
res=sum*(0.25/3);
printf ("Integral from %3.2f to %3.2f is : = %f",x[1],x[n],res);
getch();
}
OUTPUT
Solution of 1/(1+x)dx using Simpson's 1/3 rule
Enter Number of data points : 5
Enter value of table value for x column
0 .25 .50 .75 1
X Y
0.000000 1.000000
0.250000 0.800000
0.500000 0.666667
0.750000 0.571429
1.000000 0.500000

Segment Interval `h':=0.25
Integral from 0.00 to 1.00 is : = 0.693254

C Program Of NA Using Trapezoidal Interpolation

/*Trapezoidal rule */
# include <stdio.h>
# include <conio.h>
# define MAX 20
void main()
{
int i,j,n;
float x[MAX],y[MAX],sum=0,h,res;
clrscr();
printf("Solution using Trapezoidal rule \n");
printf("Enter Number of data points : ");
scanf("%d",&n);
printf("Enter value of table value set by set\n");
for(i=1;i<=n;i++)
{
printf("Enter value of x[%d] and y[%d] ",i,i);
scanf("%f%f",&x[i],&y[i]);
}
h=x[2]-x[1];
printf("\nInterval :=%f\n",h);
sum=y[1]+y[n];
for(i=2;i<n;i++)
sum=sum+y[i]*2;

res=sum*(h/2);
printf ("Integral from %3.2f to %3.2f is : = %f",x[1],x[n],res);
getch();
}
OUTPUT :-
Solution using Trapezoidal rule
Enter Number of data points : 6
Enter value of table value set by set
Enter value of x[1] and y[1] 7.47 1.93
Enter value of x[2] and y[2] 7.48 1.95
Enter value of x[3] and y[3] 7.49 1.98
Enter value of x[4] and y[4] 7.50 2.01
Enter value of x[5] and y[5] 7.51 2.03
Enter value of x[6] and y[6] 7.52 2.06

Interval :=0.010000
Integral from 7.47 to 7.52 is : = 0.099652

C Program Of NA Using Langrange’s Interpolation

/*Lagrange’s Interpolation */
# include <stdio.h>
# include <conio.h>
# define MAX 20
void main()
{
int i,j,n;
float x[MAX],f[MAX],lf=1,sum=0,xp;
clrscr();
printf("Lagrange's Interpolation\n");
printf("Enter No. of Data points : ");
scanf("%d",&n);
printf("Enter data points x(i) and function value f(i)\n");
printf("(One set in each line)\n");
for(i=1;i<=n;i++)
scanf("%f%f",&x[i],&f[i]);

printf("Enter Value of x at which Interpolation is required : ");
scanf("%f",&xp);
for(i=1;i<=n;i++)
{
lf=1;
for(j=1;j<=n;j++)
{
if(i!=j)
lf=lf*((xp-x[j])/(x[i]-x[j]));
}
sum=sum+lf*f[i];
}
printf("Interpolated Function value : \n");
printf("at x = %5.2f is %f \n",xp,sum);
getch();
}
OUTPUT
Lagrange's Interpolation
Enter No. of Data points : 4
Enter data points x(i) and function value f(i)
(One set in each line)
0 3
1 9
3 17
5 39
Enter Value of x at which Interpolation is required : 2
Interpolated Function value : at x = 2.00 is 12.700000

C Program Of NA Using Divide Deference

/* Newton Divided difference formula */
# include <stdio.h>
# include <conio.h>
# define MAX 20
void main()
{
int i,j,n;
float x[MAX],fx[MAX][MAX],xp,u,sum=0;
printf("Newton Divided Difference formula \n");
printf("Enter No. of data points : ");
scanf("%d",&n);
printf("Enter values of X and f(x) set by set each at once \n");
for(i=1;i<=n;i++)
scanf("%f%f",&x[i],&fx[i][1]);
printf("Enter value of X at which interpolation is required : ");
scanf("%f",&xp);
for(i=2;i<=n;i++)
for(j=1;j<=n-i+1;j++)
fx[j][i]=(fx[j+1][i-1]-fx[j][i-1])/(x[j+i-1]-x[j]);
printf("-------------------------------------------------------------------\n");
printf("X F(x) ");
for(i=1;i<n;i++)
printf("y%d ",i);
printf("\n-----------------------------------------------------------------\n");
for(i=1;i<=n;i++)
{
printf("%4.2f\t ",x[i]);
for(j=1;j<=n-i+1;j++)
printf("%4.2f ",fx[i][j]);
printf("\n");
}
printf("\n-----------------------------------------------------------------\n");
sum=fx[1][1];
for(i=2;i<=n;i++)
{
u=1;
for(j=1;j<i;j++)
u=u*(xp-x[j]);
u=u*fx[1][i];
sum=sum+u;
}
printf("For %3.2f Interpolated value = %4.2f",xp,sum);
getch();
}
OUTPUT
Newton Divided Difference formula
Enter No. of data points : 5
Enter values of X and f(x) set by set each at once
-1 3
0 -6
3 39
6 822
7 1611
Enter value of X at which interpolation is required : 4
------------------------------------------------------------------------------
X F(x) y1 y2 y3 y4
-----------------------------------------------------------------------------
-1.00 3.00 -9.00 6.00 5.00 1.00
0.00 -6.00 15.00 41.00 13.00
3.00 39.00 261.00 132.00
6.00 822.00 789.00
7.00 1611.00
-----------------------------------------------------------------------------
For 4.00 Interpolated value = 138.00

C Program Of NA Using Backward Interpolation

/* Backward Interpolation */
# include <stdio.h<
# include <conio.h<
# define MAX 20
void main()
{
int i,j,n;
float x[MAX],fx[MAX][MAX],u,xp,sum,p;
clrscr();
printf("\t\t\t BACKWARD INTERPOLATION\n");
printf("-------------------------------------------------------------------\n");
printf("Enter number of data points : ");
scanf("%d",&n);
// reading independant & dependant value
printf("Enter data values set by set \n");
for(i=1;i<=n;i++)
scanf("%f%f",&x[i],&fx[i][1]);
printf("Enter value of X at which interpolation is required : ");
scanf("%f",&xp);
u=(xp-x[n])/(x[2]-x[1]);
// generating table
for(i=2;i<=n;i++)
for(j=i;j<=n;j++)
fx[j][i]=fx[j][i-1]-fx[j-1][i-1];
// printing table
printf("-------------------------------------------------------------------\n");
printf("X F(x) ");
for(i=1;i<n;i++)
printf("y%d ",i);
printf("\n-----------------------------------------------------------------\n");
for(i=1;i<=n;i++)
{
printf("%4.2f ",x[i]);
for(j=1;j<=i;j++)
printf("%6.2f ",fx[i][j]);

printf("\n");
}
printf("-----------------------------------------------------------------\n");
// calculting interpolated value
sum=fx[n][1]+fx[n][2]*u;
for(i=2;i<n;i++)
{
p=u;
for(j=1;j<i;j++)
p=p*(u+j);
p=p/fact(i);
sum=sum+p*fx[n][i+1];
}
printf("Value of U := %5.2f\n",u);
printf("Interpolation value := %4.4f\n",sum);
getch();

}
int fact(int n)
{
int i,f=1;
for(i=1;i<=n;i++)
f=f*i;
return f;
}
OUTPUT
BACKKWARD INTERPOLATION
------------------------------------------------------------------------------
Enter number of data points : 7
Enter data values set by set
3 13
4 21
5 31
6 43
7 57
8 73
9 91
Enter value of X at which interpolation is required : 10
------------------------------------------------------------------------------
X F(x) y1 y2 y3 y4 y5 y6
-----------------------------------------------------------------------------
3.00 13.00
4.00 21.00 8.00
5.00 31.00 10.00 2.00
6.00 43.00 12.00 2.00 0.00
7.00 57.00 14.00 2.00 0.00 0.00
8.00 73.00 16.00 2.00 0.00 0.00 0.00
9.00 91.00 18.00 2.00 0.00 0.00 0.00 0.00
------------------------------------------------------------------------------
Value of U := 1.00
Interpolation value := 111.0000

C Program Of NA Using Forward Interpolation

/* Forward Interpolation */
# include <stdio.h>
# include <conio.h>
# define MAX 20
void main()
{
int i,j,n;
float x[MAX],fx[MAX][MAX],u,xp,sum,p;
clrscr();
printf("\t\t\t FORWARD INTERPOLATION\n");
printf("-------------------------------------------------------------------\n");
printf("Enter number of data points : ");
scanf("%d",&n);
// reading independant & dependant value
printf("Enter data values set by set \n");
for(i=1;i<=n;i++)
scanf("%f%f",&x[i],&fx[i][1]);
printf("Enter value of X at which interpolation is required : ");
scanf("%f",&xp);
u=(xp-x[1])/(x[2]-x[1]);
// generating table
for(i=2;i<=n;i++)
for(j=1;j<=n-i+1;j++)
fx[j][i]=fx[j+1][i-1]-fx[j][i-1];
// printing table
printf("-------------------------------------------------------------------\n");
printf("X F(x) ");
for(i=1;i printf("y%d ",i);
printf("\n-----------------------------------------------------------------\n");
for(i=1;i<=n;i++)
{
printf("%4.2f ",x[i]);
for(j=1;j<=n-i+1;j++)
printf("%6.2f ",fx[i][j]);

printf("\n");
}
printf("-------------------------------------------------------------------\n");
//calculting interpolated value
sum=fx[1][1]+fx[1][2]*u;
for(i=2;i<n;i++)
{
p=u;
for(j=1;j<i;j++)
p=p*(u-j);
p=p/fact(i);
sum=sum+p*fx[1][i+1];
}
printf("Value of U := %5.2f\n",u);
printf("Interpolation value := %4.4f\n",sum);
getch();
}
int fact(int n)
{
int i,f=1;
for(i=1;i<=n;i++)
f=f*i;
return f;
}

OUTPUT :-
FORWARD INTERPOLATION
------------------------------------------------------------------------------
Enter number of data points : 6
Enter data values set by set
.20 1.65
.22 1.66
.24 1.68
.26 1.69
.28 1.70
.30 1.71
Enter value of X at which interpolation is required : .23
------------------------------------------------------------------------------
X F(x) y1 y2 y3 y4 y5
-----------------------------------------------------------------------------
0.20 1.65 0.01 0.01 -0.02 0.03 -0.04
0.22 1.66 0.02 -0.01 0.01 -0.01
0.24 1.68 0.01 -0.00 0.00
0.26 1.69 0.01 0.00
0.28 1.70 0.01
0.30 1.71
------------------------------------------------------------------------------
Value of U := 1.50
Interpolation value := 1.6712

C Program Of NA Using Guass Animation

/*Gauss Elimination */
# include <stdio.h>
# include <conio.h>
# include <math.h>
# define MAX 10
void main()
{
int i,j,n,k;
float mat[MAX][MAX],x[MAX],temp,pivot,sum=0;
clrscr();
printf("\t\t\t GAUSS ELIMINITION METHOD\n");
printf("-------------------------------------------------------------------\n");
printf("Enter No of Equtions : ");
scanf("%d",&n);
printf("Enter Coefficients of Eqution \n");
for(i=1;i<=n;i++)
for(j=1;j<=n;j++)
scanf("%f",&mat[i][j]);
printf("Enter Constant value\n");
for(i=1;i<=n;i++)
{
scanf("%f",&mat[i][n+1]);
x[i]=mat[i][n+1];
}
for(i=2;i<=n;i++)
{
for(j=i;j<=n;j++)
{
pivot=mat[j][i-1]/mat[i-1][i-1];
for(k=i-1;k<=n+1;k++)
mat[j][k]=mat[j][k]-pivot*mat[i-1][k];
}
}
printf("Eliminated matrix as :- \n");
for(i=1;i<=n;i++)
{
for(j=1;j<=n+1;j++)
printf("\t%.2f",mat[i][j]);
printf("\n");
}
for(i=1;i<=n;i++)
{
if(mat[i][i]==0)
{
printf("Since diagonal element become zero\n Hence solution is not possible\n");
exit(1);
}
}
printf("Solution : \n");
for(i=0;i {
sum=0;
for(j=n;j>n-i;j--)
sum=sum+mat[n-i][j];

x[n-i]=(mat[n-i][n+1]-sum*x[n])/mat[n-i][n-i];
printf("X%d = %4.2f\n",n-i,x[n-i]);
}

getch();
}

OUTPUT :-


GAUSS ELIMINITION METHOD
------------------------------------------------------------------------------
Enter No of Equtions : 3
Enter Coefficients of Eqution
4 3 -2
1 1 1
3 -2 1
Enter Constant value
5 3 2
Eliminated matrix as :-
4.00 3.00 -2.00 5.00
0.00 0.25 1.50 1.75
0.00 0.00 28.00 28.00
Solution :
X3 = 1.00
X2 = 1.00
X1 = 1.00

C Program Of NA Using Raphson Method

/*Newton Raphson*/
# include <stdio.h>
# include <conio.h>
# include <math.h>
# define EPS .00001
# define f(x) x*x+x-2
# define f_(x) 2*x+1
void main()
{
int n=0;
float f0,f1,x0,x1;
clrscr();
printf(" Solution of Equation x%c+x-2 through Newton raphson method",253);
printf("\nEnter Initial Guess : ");
scanf("%f",&x0);
f0=f(x0);
f1=f_(x0);
x1=(x0-(f0/f1));
printf("No\t x0\t\t f(x0)\t\t f'(x0)\t\t x1\n");
printf("-------------------------------------------------------------------\n");
while(fabs(x1-x0)/x1>EPS)
{
n++;
printf("%d\t%f\t\%f\t%f\t%f\n",n,x0,f0,f1,x1);
x0=x1;
f0=f(x0);
f1=f_(x0);
x1=(x0-(f0/f1));
}
printf("-------------------------------------------------------------------\n");
printf("Root = %f \n",x0);
printf("Function value = %f\n",f(x0));
printf("-------------------------------------------------------------------\n");
getch();
}
OUTPUT
Solution of Equation x²+x-2 through Newton raphson method
Enter Initial Guess : 0
No x0 f(x0) f'(x0) x1
--------------------------------------------------------------------------
1 0.000000 -2.000000 1.000000 2.000000
2 2.000000 4.000000 5.000000 1.200000
3 1.200000 0.640000 3.400000 1.011765
4 1.011765 0.035433 3.023530 1.000046
5 1.000046 0.000137 3.000092 1.000000
--------------------------------------------------------------------------
Root = 1.000000
Function value = 0.000000