C, C++, Java, Data Structure, Numerical Analysis Programming

Continuous distribution(weibull,uniform,triangle) implementation

2011-10-23T09:52:00.000-07:00

#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

2011-10-20T07:13:00.000-07:00

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

2011-10-20T07:11:00.001-07:00

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

2011-10-20T06:29:00.000-07:00

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 Graphics : Line clipping of right boundary only using Liang Barsky algo

2011-10-17T07:14:00.000-07:00

#include<graphics.h>
int main()
{
int x1,y1,x2,y2,x,y,dx,dy;
int xmin,xmax,ymin,ymax;
float u,p,q;
int gd=DETECT,gm;
initgraph(&gd,&gm,"c:\\tc");
xmin=ymin=100;
xmax=ymax=300;
x1=150;y1=150; x2=350; y2=200;
rectangle(xmin,ymin,xmax,ymax);
line(x1,y1,x2,y2);
u=(float)(xmax-x1)/(x2-x1);
dx=x2-x1;
dy=y2-y1;
x=x1+(int)(dx*u);
y=y1+(int)(dy*u);
getch();
cleardevice();
rectangle(xmin,ymin,xmax,ymax);
line(x1,y1,x,y);
getch();
return 0;
}

C Graphics : Shearing in 2D transformation

2011-10-16T04:50:00.000-07:00

void shearing(int *x,int *y,double shx,double shy)

{

double trans[3][3]={1,0,0,0,1,0,0,0,1};

double a[3][1]={0,0,1};

double c[3][1];

int i,j,k;

trans[0][1]=shx;

trans[1][0]=shy;

a[0][0]=*x;

a[0][1]=*y;

for(i=0;i<3;i++)

{

for(j=0;j<1;j++)

{

c[i][j]=0;

for(k=0;k<3;k++)

{

c[i][j]+=trans[i][k]*a[k][j];

}

}

}

*x=c[0][0];

*y=c[1][0];

}

C Graphics : Scaling in 2D transformation

2011-10-16T04:46:00.001-07:00

void scale(int *x,int *y,double sx,double sy)

{

double trans[3][3]={1,0,0,0,1,0,0,0,1};

double a[3][1]={0,0,1};

double c[3][1];

int i,j,k;

trans[0][0]=sx;

trans[1][1]=sy;

a[0][0]=*x;

a[0][1]=*y;

for(i=0;i<3;i++)

{

for(j=0;j<1;j++)

{

c[i][j]=0;

for(k=0;k<3;k++)

{

c[i][j]+=trans[i][k]*a[k][j];

}

}

}

*x=c[0][0];

*y=c[1][0];

}

C Graphics : Rotation in 2D transformation

2011-10-16T04:45:00.001-07:00

void rotate(int *x,int *y,double th)

{

double trans[3][3]={1,0,0,0,1,0,0,0,1};

double a[3][1]={0,0,1};

double c[3][1];

int i,j,k;

th=th*M_PI/180;

trans[0][0]=cos(th);

trans[0][1]=-sin(th);

trans[1][0]=sin(th);

trans[1][1]=cos(th);

a[0][0]=*x;

a[1][0]=*y;

for(i=0;i<3;i++)

{

for(j=0;j<1;j++)

{

c[i][j]=0;

for(k=0;k<3;k++)

{

c[i][j]+=trans[i][k]*a[k][j];

}

}

}

*x=abs(c[0][0]);

*y=abs(c[1][0]);

}

C Graphics : Translation in 2D transformation

2011-10-16T04:39:00.001-07:00

void transalate(int *x,int *y,int tx,int ty)

{

int trans[3][3]={1,0,0,0,1,0,0,0,1};

int a[3][1]={0,0,1};

int c[3][1];

int i,j,k;

trans[0][2]=tx;

trans[1][2]=ty;

a[0][0]=*x;

a[0][1]=*y;

for(i=0;i<3;i++)

{

for(j=0;j<1;j++)

{

c[i][j]=0;

for(k=0;k<3;k++)

{

c[i][j]+=trans[i][k]*a[k][j];

}

}

}

*x=c[0][0];

*y=c[1][0];

}

C Graphics : Flood Fill Function

2011-09-12T10:47:00.000-07:00

void flood_fill(int x,int y,int fc,int bc)
{
int color=getpixel(x,y);
if(color==bc)
{
putpixel(x,y,12);
  flood_fill(x,y+1,fc,bc);
  flood_fill(x+1,y,fc,bc);
  flood_fill(x,y-1,fc,bc);
  flood_fill(x-1,y,fc,bc);
}
}

C Graphics : Ellipse Generation

2011-09-12T10:01:00.000-07:00

void midpoint_ellipse(int xaxis,int yaxis,int a,int b)
{
int x=0,y=b;
int aa=a*a,bb=b*b;
int aa2=2*a*a,bb2=2*b*b;

float p=b*b-a*a*b+0.25*a*a;

draw_ellipse(xaxis,yaxis,x,y);
while(bb2*x<=aa2*y)
{

x++;
if(p<=0)
{
p=p+bb2*x+bb;
}
else
{
y--;
p=p+bb2*x+bb-aa2*y;
}
draw_ellipse(xaxis,yaxis,x,y);
x=-x;
draw_ellipse(xaxis,yaxis,x,y);
x=-x;

}//end while

x=a;
y=0;
draw_ellipse(xaxis,yaxis,x,y);
p=aa+bb2*a+bb*0.25;
//p=bb*(x+0.5)*(x+0.5)+aa*(y-1)*(y-1)-aa*bb;

while(bb2*x>aa2*y) {
y++;
//fy=fy-aa2;
if(p>0)
{
p=p+aa-aa2*y;
}
else
{
x--;
p=p+bb2*x-aa2*y+aa;
}
draw_ellipse(xaxis,yaxis,x,y);
y=-y;
draw_ellipse(xaxis,yaxis,x,y);
y=-y;

}

}

void draw_ellipse(int xaxis,int yaxis,int x,int y)
{
putpixel(xaxis+x,yaxis+y,4);
putpixel(xaxis-x,yaxis+y,4);
putpixel(xaxis+x,yaxis-y,4);
putpixel(xaxis-x,yaxis-y,4);
}

C Graphics : DDA Line Draw

2011-09-10T10:34:00.001-07:00

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

void dda_line(int x1,int y1,int x2,int y2);

int main(void)
{
/* request auto detection */
int gdriver = DETECT, gmode, errorcode;

/* initialize graphics mode */
initgraph(&gdriver, &gmode, "c:\\tc");

/* read result of initialization */
errorcode = graphresult();

if (errorcode != grOk) /* an error occurred */
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1); /* return with error code */
}

getch();
return(0);
}

void dda_line(int x1,int y1,int x2,int y2)
{
int dx,dy,step;
float x,y,ix,iy;
dx=x2-x1;
dy=y2-y1;

if(abs(dx)>abs(dy))
step=abs(dx);
else
step=abs(dy);

ix=dx/(float)step;
iy=dy/(float)step;

x=x1;
y=y1;
putpixel(x,y,1);
while(step-->0)
{
x=x+ix;
y=y+iy;

putpixel(x,y,1);
}

}

C Graphics : Mid-Point Circle Draw

2011-09-10T10:10:00.000-07:00

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

void draw_circle(int,int,int);
void main()
{
int gd=DETECT,gm;
int r;
int xcen,ycen;
initgraph(&gd,&gm,"c:\\tc\\");

//clrscr();
printf("enter radius :");
scanf("%d",&r);
printf("enter circle centre coordinate :");
scanf("%d%d",&xcen,&ycen);

draw_circle(xcen,ycen,r);

getch();
}
void draw_circle(int xcen,int ycen,int r)
{
int x,y,p;
x=0;
y=r;
p=1-r;
putpixel(xcen+x,ycen+y,12);
putpixel(xcen-x,ycen+y,12);
putpixel(xcen+x,ycen-y,12);
putpixel(xcen-x,ycen-y,12);
putpixel(xcen+y,ycen+x,12);
putpixel(xcen+y,ycen-x,12);
putpixel(xcen-y,ycen+x,12);
putpixel(xcen-y,ycen+x,12);
while(x<=y)
{
if(p<0)
p=p+2*x+1;
else
{
p=p+2*(x-y)+1;
y--;
}
x++;
putpixel(xcen+x,ycen+y,10);
putpixel(xcen-x,ycen+y,11);
putpixel(xcen+x,ycen-y,12);
putpixel(xcen-x,ycen-y,11);
putpixel(xcen+y,ycen+x,14);
putpixel(xcen+y,ycen-x,11);
putpixel(xcen-y,ycen-x,13);
putpixel(xcen-y,ycen+x,11);
}
}

Java Programming - Calculator in swing

2010-10-31T03:39:00.000-07:00

.......................................................
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class GuiCalculator
{
String o="+";
double d1=0.0,d2=0.0;

JFrame jf;
Container c;
JTextField tf;
JButton b1,b2,b3,b4,b5,b6,b7,b8,b9,b10,b11,b12,b13,b14,b15,b16,b17;
public GuiCalculator()
{
jf=new JFrame("Calculator");
jf.setSize(400,500);
jf.setResizable(false);

jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
tf=new JTextField("",12);

c=jf.getContentPane();
//GridBagLayout gb=new GridBagLayout();
//gb.addLayoutComponent(tf);
c.setLayout(null);
tf.setColumns(12);
tf.setHorizontalAlignment(JTextField.RIGHT);
tf.setFont(new Font("Font.TIMESNEWROMAN",Font.BOLD,36));
c.add(tf);
b1=new JButton("1");
b2=new JButton("2");
b3=new JButton("3");
b4=new JButton("4");
b5=new JButton("5");
b6=new JButton("6");
b7=new JButton("7");
b8=new JButton("8");
b9=new JButton("9");
b10=new JButton("0");
b11=new JButton(".");
b12=new JButton("=");
b13=new JButton("+");
b14=new JButton("-");
b15=new JButton("x");
b16=new JButton("/");
b17=new JButton("");
tf.setBounds(20,10,330,50);
b1.setBounds(10,120,60,35);
b2.setBounds(110,120,60,35);
b3.setBounds(210,120,60,35);
b4.setBounds(310,120,60,35);
b5.setBounds(10,220,60,35);
b6.setBounds(110,220,60,35);
b7.setBounds(210,220,60,35);
b8.setBounds(310,220,60,35);
b9.setBounds(10,320,60,35);
b10.setBounds(110,320,60,35);
b11.setBounds(210,320,60,35);
b12.setBounds(310,320,60,35);
b13.setBounds(10,420,60,35);
b14.setBounds(110,420,60,35);
b15.setBounds(210,420,60,35);
b16.setBounds(310,420,60,35);
b17.setBounds(310,420,60,35);

//c.setLayout(new GridLayout(4,4));
b1.addActionListener(new Perform());
b2.addActionListener(new Perform());
b3.addActionListener(new Perform());
b4.addActionListener(new Perform());
b5.addActionListener(new Perform());
b6.addActionListener(new Perform());
b7.addActionListener(new Perform());
b8.addActionListener(new Perform());
b9.addActionListener(new Perform());
b10.addActionListener(new Perform());
b11.addActionListener(new Perform());
b12.addActionListener(new Perform());
b13.addActionListener(new Perform());
b14.addActionListener(new Perform());
b15.addActionListener(new Perform());
b16.addActionListener(new Perform());

c.add(b1);
c.add(b2);
c.add(b3);
c.add(b4);
c.add(b5);
c.add(b6);
c.add(b7);
c.add(b8);
c.add(b9);
c.add(b10);
c.add(b11);
c.add(b12);
c.add(b13);
c.add(b14);
c.add(b15);
c.add(b16);
c.add(b17);
jf.setVisible(true);

}

class Perform implements ActionListener
{
//String o="+";
//double d1=0.0,d2=0.0;

public void actionPerformed(ActionEvent e)
{
String s=e.getActionCommand();
int j=-1;
if(Character.isDigit(s.charAt(0)))
j=Integer.parseInt(s);
for(int i=0;i<=9;i++)
if(i==j)
tf.setText(tf.getText()+s);
if((s.equals("+"))||(s.equals("-"))||(s.equals("x"))||(s.equals("/")))
{
if(!(tf.getText().equals("")))
d1=Double.parseDouble(tf.getText());
o=s;
tf.setText("");
}
if(s.equals("="))
{
d2=Double.parseDouble(tf.getText());
if(o.equals("+"))
tf.setText(String.valueOf(d1+d2));
if(o.equals("-"))
tf.setText(String.valueOf(d1-d2));
if(o.equals("x"))
tf.setText(String.valueOf(d1*d2));
if(o.equals("/"))
tf.setText(String.valueOf(d1/d2));

}
}
}
public static void main(String args[])
{
GuiCalculator gui=new GuiCalculator();
}
}

my stuff - welcome to amrendra world

2010-10-07T11:49:00.000-07:00

****************************************

cwg hockey match and me

C Program Of NA Using Guass Sedial Method

2010-08-19T07:16:00.002-07:00

//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

2010-08-19T07:16:00.001-07:00

/*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

2010-08-19T07:15:00.002-07:00

/* 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

2010-08-19T07:15:00.001-07:00

/* 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

2010-08-19T07:14:00.001-07:00

/*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

2010-08-19T07:13:00.002-07:00

/*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

2010-08-19T07:13:00.001-07:00

/*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

2010-08-19T07:12:00.000-07:00

/*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

2010-08-19T07:10:00.000-07:00

/* 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

2010-08-19T07:08:00.000-07:00

/* 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