Straight Line Fit Using Least Squares Estimate

 #include<stdio.h>  
 #include<math.h>  
   
 void main()  
 {  
       float x[100],y[100],xy[100],xsquare[100],m,sumx,sumy,sumxy,sumxsq,a,b;  
         
       int i,j,k;  
   
   
       sumx=sumy=sumxy=sumxsq=0;  
       printf("\n\t\t\tLeast Square Method To Fit A Staright Line");  
       printf("\n=========================================================================================================================\n");  
       printf("\t\t\tEnter the value of m(number of terms) ");  
       scanf("%f",&m);  
       printf("\n=========================================================================================================================\n");  
       printf("\t\t\tEnter all the value of X \n");  
       for(i=0;i<m;i++)  
       {  
             printf("\tx[%d]=",i);  
             scanf("%f",&x[i]);  
             xsquare[i]=x[i]*x[i];//xsquare being calculated here  
             sumx=sumx+x[i];//summation of x  
             sumxsq=sumxsq+xsquare[i];//summation of x square calculated  
       }  
       printf("\n=========================================================================================================================\n");  
       printf("\t\t\tEnter all the value of Y \n");  
       for(i=0;i<m;i++)  
       {  
             printf("\ty[%d]=",i);  
             scanf("%f",&y[i]);  
             xy[i]=x[i]*y[i];//x*y being calculated  
             sumy=sumy+y[i];// summation of Y calculated  
             sumxy=sumxy+xy[i];//summation of XY calculated  
       }  
       a=((sumy*sumxsq)-(sumx*sumxy))/((m*sumxsq)-(sumx*sumx));  
       b=((m*sumxy)-(sumx*sumy))/((m*sumxsq)-(sumx*sumx));  
       printf("\n=========================================================================================================================\n\n");  
         
       printf("\t\t\tValue of a=%4.3f\tvalue of b=%4.3f\n",a,b);  
         
       printf("\n\t\t\tThus equation will be y=%4.3f + %4.3fx\n\n",a,b);  
         
       getchar();  
 }  
   

Fourth Order Runge-Kutta Method For Differential Equation

 #include<stdio.h>  
 #include<math.h>  
 float funct(float,float);  
 void main()  
 {  
      float y0,yprime,k1,k2,k3,k4;  
      float h,x,iter,x0;  
      printf("\n\t\t\tFourth Order Runge-Kutta Method To Solve Differential Equation");  
      printf("\n=========================================================================================================================\n");  
      printf("\t\t\tEnter the value of h(the interval) ");  
      scanf("%f",&h);  
      printf("\n=========================================================================================================================\n");  
      printf("\t\t\tEnter the value of X(for which you need value of y) ");  
      scanf("%f",&x);  
      printf("\n=========================================================================================================================\n");  
      printf("\t\t\tEnter the intital value y0 ");  
      scanf("%f",&y0);  
      printf("\n=========================================================================================================================\n");  
      printf("\t\t\tEnter the intital value x0 ");  
      scanf("%f",&x0);  
      for(iter=x0;iter<=x;iter=iter + h)  
      {  
           k1=funct(iter,y0);  
           k2=funct(iter+(h/2),y0+(k1*h)/2);  
           k3=funct(iter+((h/2)),y0+(k2*h)/2);  
           k4=funct(iter+h,y0+(k3*h));  
           yprime=y0+((h/6)*(k1+2*(k2+k3)+k4));  
           printf("\n\tValue of X=%f then Value of Y=%f ",iter,y0);  
           y0=yprime;  
      }  
      getchar();  
 }  
 float funct(float x,float y)  
 {  
      return ((x-y)/(x+y));  
 }  

Euler's Method For Numerical Differentiation

 #include<stdio.h>  
 #include<math.h>  
 float funct(float,float);  
 void main()  
 {  
      float y0,yprime;  
      float h,x,iter,x0;  
      printf("\n\t\t\tEuler's Method To Solve Differential Equation");  
      printf("\n=================================================================================================================\n");  
      printf("\t\t\tEnter the value of h(the interval) ");  
      scanf("%f",&h);  
      printf("\n=================================================================================================================\n");  
      printf("\t\t\tEnter the value of X(for which you need value of y) ");  
      scanf("%f",&x);  
      printf("\n=================================================================================================================\n");  
      printf("\t\t\tEnter the intital value y0 ");  
      scanf("%f",&y0);  
      printf("\n=================================================================================================================\n");  
      printf("\t\t\tEnter the intital value x0 ");  
      scanf("%f",&x0);  
      for(iter=x0;iter<=x;iter=iter + h)  
      {  
           yprime=y0+(h*funct(iter,y0));  
           printf("\nWhen X=%f then Y=%f",iter,y0);  
           y0=yprime;  
      }  
      getchar();  
 }  
 float funct(float x,float y)  
 {  
      return ((x-y)/(x+y));  
 }  

Simpson's 3/8th Rule

 #include<stdio.h>  
 float integrate(float);  
 void main()  
 {  
      float a,b,h,n,sum=0;  
      int i;  
      printf("\n\tINTEGRATION THROUGH SIMPSON' 3/8 RULE");  
      printf("\n\t====================================");  
      printf("\n\nEnter the upper limit a ");  
      scanf("%f",&a);  
      printf("\n\nEnter the lower limit b ");  
      scanf("%f",&b);  
      printf("\n\nEnter the number of sub-intervals ");  
      scanf("%f",&n);  
      h=(b-a)/n;  
      sum=integrate(a)+integrate(b);  
      for(i=1;i<n;i++)  
      {  
           if(i%3==0)  
                sum=sum+(2*integrate(a+i*h));  
           else  
                sum=sum+(3*integrate(a+i*h));  
      }  
      sum=sum*((3*h)/8);  
      printf("\nThe value of integral is %f",sum);  
 }  
 float integrate(float n)  
 {  
      return 1/(1+(n*n));  
 }  

Simpson's 1/3rd Rule

 #include<stdio.h>  
 float integrate(float);  
 void main()  
 {  
      float a,b,h,n,sum=0;  
      int i;  
      printf("\n\tINTEGRATION THROUGH SIMPSON' 1/3 RULE");  
      printf("\n\t====================================");  
      printf("\n\nEnter the upper limit a ");  
      scanf("%f",&a);  
      printf("\n\nEnter the lower limit b ");  
      scanf("%f",&b);  
      printf("\n\nEnter the number of sub-intervals ");  
      scanf("%f",&n);  
      h=(b-a)/n;  
      sum=integrate(a)+integrate(b);  
      for(i=1;i<n;i++)  
      {  
           if(i%2==0)  
                sum=sum+(2*integrate(a+i*h));  
           else  
                sum=sum+(4*integrate(a+i*h));  
      }  
      sum=sum*(h/3);  
      printf("\nThe value of integral is %f",sum);  
 }  
 float integrate(float n)  
 {  
      return 1/(1+(n*n));  
 }  

Trapezoidal Method Of Numerical Integration

 #include<stdio.h>  
 float integrate(float);  
 void main()  
 {  
      float a,b,h,n,i,sum=0;  
      printf("\n\tINTEGRATION THROUGH TRAPEZOIDAL RULE");  
      printf("\n\t====================================");  
      printf("\n\nEnter the upper limit a ");  
      scanf("%f",&a);  
      printf("\n\nEnter the lower limit b ");  
      scanf("%f",&b);  
      printf("\n\nEnter the number of sub-intervals ");  
      scanf("%f",&n);  
      h=(b-a)/n;  
      sum=integrate(a)+integrate(b);  
      for(i=1;i<n;i++)  
           sum=sum+(2*integrate(a+i));  
      sum=sum*(h/2);  
      printf("\nThe value of integral is %f",sum);  
 }  
 float integrate(float n)  
 {  
      return 1/(1+(n*n));  
 }  

Lagrange's Interpolation Formula

 #include<stdio.h>  
 #include<math.h>  
 void main()  
 {  
      float ax[10],y[10];  
      float x,numsum=1,densum=1,k;  
      int i,j,n;  
      printf("Enter the number of terms ");  
      scanf("%d",&n);  
      printf("\n=======================================================\n");  
      printf("Enter the array ax ");  
      for(i=0;i<n;i++)  
      {  
           printf("\nEnter the value of ax[%d] = ",i);  
           scanf("%f",&ax[i]);  
      }  
      printf("\n=======================================================\n");  
      for(i=0;i<n;i++)  
      {  
           printf("Enter the value of y[%d] = ",i);  
           scanf("%f",&y[i]);  
      }  
      printf("\nEnter the interpolation point ");  
      scanf("%f",&x);  
      k=0;  
      for(i=0;i<n;i++)  
      {  
           numsum=1;  
           densum=1;  
           for(j=0;j<n;j++)  
           {  
                if(i!=j)  
                {  
                     numsum=numsum*(x-ax[j]);  
                     densum=densum*(ax[i]-ax[j]);  
                }  
           }  
           k=k+(numsum/densum)*y[i];  
      }  
      printf("\nValue at %f is %f ",x,k);  
      getchar();  
 }  

Bessels Interpolation Formula

1:  #include<stdio.h>  
2:  #include<math.h>  
3:  float factorial(int);  
4:  void main()  
5:  {  
6:       float ax[10],y[10];  
7:       float dy[10][10],u,h,x,a,sum=0,sum2,sum3,l,prod=1,prod2=1;  
8:       int i,j,k,m,n,fact,mid=0;  
9:       int diff1,diff2,num_minus;  
10:       printf("\n\t\t\tBessel Interpolation");  
11:       printf("\n=========================================================================================================================\n");  
12:       printf("Enter the number of terms \n");  
13:       scanf("%d",&n);  
14:       printf("\n=========================================================================================================================\n");  
15:       printf("\t\t\tEnter the array x\n");  
16:       for(i=0;i<n;i++)  
17:       {  
18:            printf("Enter the value of ax[%d] = ",i);  
19:            scanf("%f",&ax[i]);  
20:       }  
21:       printf("\n=========================================================================================================================\n");  
22:       printf("\t\t\tEnter the array Y\n");  
23:       for(i=0;i<n;i++)  
24:       {  
25:            printf("Enter the value of y[%d] = ",i);  
26:            scanf("%f",&y[i]);  
27:       }  
28:       printf("\n=========================================================================================================================\n");  
29:       printf("\nEnter the interpolation point ");  
30:       scanf("%f",&x);  
31:       h=ax[1]-ax[0];  
32:       for(i=0;i<n;i++)  
33:       {  
34:            for(j=0;j<=n;j++)  
35:                 dy[i][j]=-1;  
36:       }  
37:       for(i=0;i<n;i++)  
38:       {  
39:            dy[i][0]=y[i];  
40:       }  
41:       k=1;  
42:       j=1;  
43:       while(j<n)  
44:       {  
45:            i=1;  
46:            while(i<=n-k)  
47:            {  
48:                 dy[i-1][j]=dy[i][j-1]-dy[i-1][j-1];  
49:                 i++;  
50:            }  
51:            j++;  
52:            k++;  
53:       }  
54:       i=0;  
55:       printf("\n=========================================================================================================================\n");  
56:       printf("\ty");  
57:       for(i=1;i<n;i++)  
58:            printf("   d^%dy",i);  
59:       printf("\n");  
60:       for(i=0;i<n;i++)  
61:       {  
62:            for(j=0;j<n-i;j++)  
63:            {  
64:                 if(dy[i][j]==-1.0)  
65:                      printf(" _ ");  
66:                 else  
67:                      printf("  %-7.4f",dy[i][j]);  
68:            }  
69:            printf("\n");  
70:       }  
71:       i=0;  
72:       do{  
73:            i++;  
74:       }while(ax[i]<x);  
75:       i--;  
76:       u=(x-ax[i])/h;  
77:       sum=(y[i]+y[i+1])/2;  
78:       sum2=sum3=0;  
79:       diff1=i;  
80:       diff2=i-1;  
81:       num_minus=1;  
82:       prod2=1;  
83:       prod=1;  
84:       for(i=1;i<n;i++)  
85:       {  
86:            a=u;  
87:            if(i%2!=0)  
88:            {  
89:                 if(diff1<0)  
90:                      prod=0;  
91:                 else  
92:                      prod=(((a-0.5)*prod2)/factorial(i))*dy[diff1][i];  
93:                 sum=sum+prod;  
94:            }  
95:            else  
96:            {  
97:                 prod2=a;  
98:                 if(i>2)  
99:                      prod2=prod2*(u+1);  
100:                 for(j=1;j<=num_minus;j++)  
101:                 {  
102:                      prod2=prod2*(a-j);  
103:                 }  
104:                 num_minus++;  
105:                 prod=prod2/factorial(i);  
106:                 if(diff2<0)  
107:                      sum3=0;  
108:                 else  
109:                      sum3=(dy[diff1][i]+dy[diff2][i])/2;  
110:                 prod=prod*sum3;  
111:                 diff1=diff2;  
112:                 diff2=diff2-1;  
113:                 sum=sum+prod;  
114:            }  
115:       }  
116:       printf("\nValue at %6.4f is %f ",x,sum);  
117:       getchar();  
118:  }  
119:  float factorial(int x)  
120:  {  
121:       int i,j=1;  
122:       for(i=1;i<=x;i++)  
123:            j=j*i;  
124:       return j;  
125:  }  

Laplace-Everett's Formula

1:  #include<stdio.h>  
2:  #include<math.h>  
3:  float factorial(int);  
4:  void main()  
5:  {  
6:       float ax[10],y[10];  
7:       float dy[10][10],u,h,x,a,sum=0,sum1=0,sum2=0,l,w,o,p,s,m;  
8:       int i,j,k,n,fact;  
9:       printf("\n\t\tLaPlace-Everett Formula");  
10:       printf("\n=======================================================\n");  
11:       printf("Enter the number of terms\n ");  
12:       scanf("%d",&n);  
13:       printf("\n=======================================================\n");  
14:       printf("Enter the array ax ");  
15:       for(i=0;i<n;i++)  
16:       {  
17:            printf("Enter the value of ax[%d] = ",i);  
18:            scanf("%f",&ax[i]);  
19:       }  
20:       printf("\n=======================================================\n");  
21:       for(i=0;i<n;i++)  
22:       {  
23:            printf("Enter the value of y[%d] = ",i);  
24:            scanf("%f",&y[i]);  
25:       }  
26:       printf("\nEnter the interpolation point ");  
27:       scanf("%f",&x);  
28:       h=ax[1]-ax[0];  
29:       for(i=0;i<n;i++)  
30:       {  
31:            for(j=0;j<=n;j++)  
32:                 dy[i][j]=-1;  
33:       }  
34:       for(i=0;i<n;i++)  
35:       {  
36:            dy[i][0]=y[i];  
37:       }  
38:       k=1;  
39:       j=1;  
40:       while(j<n)  
41:       {  
42:            i=1;  
43:            while(i<=n-k)  
44:            {  
45:                 dy[i-1][j]=dy[i][j-1]-dy[i-1][j-1];  
46:                 i++;  
47:            }  
48:            j++;  
49:            k++;  
50:       }  
51:       i=0;  
52:       printf("\n================================================================================\n");  
53:       printf("\ty");  
54:       for(i=1;i<n;i++)  
55:            printf("\td^%dy",i);  
56:       printf("\n");  
57:       for(i=0;i<n;i++)  
58:       {  
59:            for(j=0;j<n-i;j++)  
60:            {  
61:                 if(dy[i][j]==-1.0)  
62:                      printf("\t_");  
63:                 else  
64:                      printf("\t%-4.4f",dy[i][j]);  
65:            }  
66:            printf("\n");  
67:       }  
68:       i=0;  
69:       do{  
70:            i=i+1;  
71:       }while(ax[i]<x);  
72:       i--;  
73:       u=(x-ax[i])/h;  
74:       w=1-u;  
75:       sum1=sum1+u*(dy[i+1][0]);  
76:       sum2=sum2+w*(dy[i][0]);  
77:       k=2;  
78:       o=1;  
79:       s=3;  
80:       for(j=i;j>=0;j--)  
81:       {  
82:            p=u;  
83:            for(m=1;m<=o;m++)  
84:            {  
85:                 p=p*(pow(u,2)-pow(m,2));  
86:            }  
87:            o++;  
88:            p=(p/factorial(s))*dy[j][k];  
89:            sum1=sum1+p;  
90:            k=k+2;  
91:            if(k>=n)  
92:                 break;  
93:       }  
94:       k=2;  
95:       o=1;  
96:       s=3;  
97:       for(j=i-1;j>=0;j--)  
98:       {  
99:            p=w;  
100:            for(m=1;m<=o;m++)  
101:            {  
102:                 p=p*(pow(w,2)-pow(m,2));  
103:            }  
104:            p=(p/factorial(s))*dy[j][k];  
105:            sum2=sum2+p;  
106:            o++;  
107:            k=k+2;  
108:            if(k>=n)  
109:                 break;  
110:       }  
111:       sum=sum1+sum2;  
112:       printf("\nValue at %f is %f ",x,sum);  
113:       getchar();  
114:  }  
115:  float factorial(int x)  
116:  {  
117:       int i,j=1;  
118:       for(i=1;i<=x;i++)  
119:            j=j*i;       
120:       return j;  
121:  }  

Gauss Backward Difference Formula

#include<stdio.h>
#include<math.h>
float factorial(int);
void main()
{
        float ax[10],y[10];
        float dy[10][10],u,h,x,a,sum=0,l,oddprod=1,evenprod=1;
        int i,j,k,n,mid=0;
        printf("\n\t\tGauss Forward Difference Formula");
        printf("\n=======================================================\n");
        printf("Enter the number of terms ");
        scanf("%d",&n);
        printf("\n=======================================================\n");
        printf("Enter the array ax\n");
        for(i=0;i<n;i++)
        {
                printf("Enter the value of ax[%d] = ",i);
                scanf("%f",&ax[i]);
        }
        printf("\n=======================================================\n");
        for(i=0;i<n;i++)
        {
                printf("Enter the value of y[%d] = ",i);
                scanf("%f",&y[i]);
                
        }
        printf("\nEnter the interpolation point ");
        scanf("%f",&x);
        h=ax[1]-ax[0];
        for(i=0;i<n;i++)
        {
                for(j=0;j<=n;j++)
                        dy[i][j]=-1;
                
        }
        for(i=0;i<n;i++)
        {
                dy[i][0]=y[i];
        }
        
        k=1;
        j=1;
        while(j<n)
        {
                i=1;
                while(i<=n-k)
                {
                        dy[i-1][j]=dy[i][j-1]-dy[i-1][j-1];
                        i++;
                }
                j++;
                k++;
        }
        i=0;
        printf("\n================================================================================\n");
        printf("\ty");
        for(i=1;i<n;i++)
                printf("\td^%dy",i);
        printf("\n");
        for(i=0;i<n;i++)
        {
                for(j=0;j<n;j++)
                {
                        if(dy[i][j]==-1.0)
                                printf("\t_");
                        else
                                printf("\t%-6.3f",dy[i][j]);
                }
                printf("\n");
        }
        i=0;
        do{
                i++;
        }while(ax[i]<x);
        mid=i;
        u=(x-ax[mid])/h;
        sum=sum+y[mid]+(u*dy[mid-1][1]);
        mid=mid-1;
        for(i=2;i<n;i++)
        {
                
                if(i%2==1)
                {
                        oddprod=1;
                        for(l=1;l<=i/2;l++)
                        {
                                oddprod=oddprod*(u-l);
                                        
                        }
                        mid-=1;
                        sum=sum + (((evenprod*u*oddprod)/factorial(i))*dy[mid][i]);
                        
                }
                else
                {
                        evenprod=1;
                        for(l=1;l<=i/2;l++)
                        {
                                evenprod=evenprod*(u+l);
                                        
                        }
                        
                        sum=sum + (((oddprod*u*evenprod)/factorial(i))*dy[mid][i]);
                        
                        
                }
                
        }
        
        printf("\nValue at %6.3f is %6.3f ",x,sum);
        getchar();
}

float factorial(int x)
{
        int i,j=1;
        for(i=1;i<=x;i++)
                j=j*i;
        return j;

}

Gauss Central Difference Formula(Forward)

1:  #include<stdio.h>  
2:  #include<math.h>  
3:  float factorial(int);  
4:  void main()  
5:  {  
6:       float ax[10],y[10];  
7:       float dy[10][10],u,h,x,a,sum=0,l,olda=1;  
8:       int i,j,k,n,mid=0;  
9:       printf("\n\t\tGauss Forward Difference Formula");  
10:       printf("\n=======================================================\n");  
11:       printf("Enter the number of terms ");  
12:       scanf("%d",&n);  
13:       printf("\n=======================================================\n");  
14:       printf("Enter the array ax \n");  
15:       for(i=0;i<n;i++)  
16:       {  
17:            printf("Enter the value of ax[%d] = ",i);  
18:            scanf("%f",&ax[i]);  
19:       }  
20:       printf("\n=======================================================\n");  
21:       for(i=0;i<n;i++)  
22:       {  
23:            printf("Enter the value of y[%d] = ",i);  
24:            scanf("%f",&y[i]);  
25:       }  
26:       printf("\nEnter the interpolation point ");  
27:       scanf("%f",&x);  
28:       h=ax[1]-ax[0];  
29:       for(i=0;i<n;i++)  
30:       {  
31:            for(j=0;j<=n;j++)  
32:                 dy[i][j]=-1;  
33:       }  
34:       for(i=0;i<n;i++)  
35:       {  
36:            dy[i][0]=y[i];  
37:       }  
38:       k=1;  
39:       j=1;  
40:       while(j<n)  
41:       {  
42:            i=1;  
43:            while(i<=n-k)  
44:            {  
45:                 dy[i-1][j]=dy[i][j-1]-dy[i-1][j-1];  
46:                 i++;  
47:            }  
48:            j++;  
49:            k++;  
50:       }  
51:       i=0;  
52:       printf("\n================================================================================\n");  
53:       printf("\ty");  
54:       for(i=1;i<n;i++)  
55:            printf("\td^%dy",i);  
56:       printf("\n");  
57:       for(i=0;i<n;i++)  
58:       {  
59:            for(j=0;j<=n;j++)  
60:            {  
61:                 if(dy[i][j]==-1.0)  
62:                      printf("\t_");  
63:                 else  
64:                      printf("\t%-4.4f",dy[i][j]);  
65:            }  
66:            printf("\n");  
67:       }  
68:       i=0;  
69:       do{  
70:            i++;  
71:       }while(ax[i]<x);  
72:       i--;  
73:       mid=i;  
74:       u=(x-ax[mid])/h;  
75:       sum=sum+y[mid]+(u*dy[mid][1]);  
76:       a=u;  
77:       for(i=2;i<n;i++)  
78:       {  
79:            a=u;  
80:            if(i%2==1)  
81:            {  
82:                 sum=sum + ((olda/factorial(i))*dy[mid][i]);  
83:            }  
84:            else  
85:            {  
86:                 for(l=1;l<=i/2;l++)  
87:                 {  
88:                      a=a*(u-l);  
89:                 }  
90:                 if(i>=3)  
91:                      a=a*(u+1);  
92:                 mid-=1;  
93:                 sum=sum + ((a/factorial(i))*dy[mid][i]);  
94:                 olda=a;  
95:            }  
96:       }  
97:       printf("\nValue at %f is %f ",x,sum);  
98:       getchar();  
99:  }  
100:  float factorial(int x)  
101:  {  
102:       int i,j=1;  
103:       for(i=1;i<=x;i++)  
104:            j=j*i;  
105:       return j;  
106:  }  

Bisection Method

 #include<stdio.h>  
 #include<math.h>  
 #include<conio.h>  
 #define EPS 0.0000005  
 float funct(float x);  
 int c,iter;  
 void main()  
 {  
 float x1,x2,f1,f2,f0,x0,root;  
 printf("Enter the number of iterations ");  
 scanf("%d",&iter);  
 //find positive root  
 for(x2=1;x2<=5.00;x2=x2+.1)  
 {  
       f2=funct(x2);  
       if(f2>0)  
       {  
             break;  
       }  
 }  
 //find the negative root  
 for(x1=x2-.1;x1>0;x1=x1-.1)  
 {  
       f1=funct(x1);  
       if(f1<0)  
             break;  
 }  
 x2=x0=0;  
 for(c=1;c<=iter;c++)  
 {  
       printf("\n ITERATION= %d",c);  
       printf("\t: ROOT= %f\tX1=%f\tX2=%f",x0,x1,x2);  
       x0=(x1+x2)/2;  
       f0=funct(x0);  
       if(f0==0)  
       {  
         //      root=x0;  
             break;  
       }  
       if(funct(x2)*funct(x0)<0)  
       {  
             x1=x0;  
       }  
       else if(funct(x1)*funct(x0)<0)  
       {  
             x2=x0;  
       }  
       if(fabs((x1-x2)/x1)<EPS)  
             break;  
 }  
 printf("\n============================================================");  
 printf("\n\tROOT=%7.4f",x0);  
 printf("\n\tITERATION=%d",c-1);  
 getch();  
 }  
 float funct(float x)  
 {  
 return(15*x*x-7*x-36);  
 }  

Regula Falsi or False Position Method

 #include<stdio.h>  
 #include<math.h>  
 #include<conio.h>  
 #define EPS 0.0000005  
 float funct(float x);  
 int c,iter;  
 void main()  
 {  
 float x1,x2,f1,f2,f0,x0,root;  
 printf("Enter the number of iterations ");  
 scanf("%d",&iter);  
 //find positive root  

 for(x2=1;x2<=5.00;x2=x2+.1)  
 {  
       f2=funct(x2);  
       if(f2>0)  
       {  
             break;  
       }  
 }  
 //find the negative root  
 for(x1=x2-.1;x1>0;x1=x1-.1)  
 {  
       f1=funct(x1);  
       if(f1<0)  
             break;  
 }  
 x2=x0=0;  
 for(c=1;c<=iter;c++)  
 {  
       printf("\n ITERATION= %d",c);  
       printf("\t: ROOT= %f\tX1=%f\tX2=%f",x0,x1,x2);  
       x0=x1-funct(x1)*((x2-x1)/funct(x2)-funct(x1));  
       f0=funct(x0);  
       if(f0==0)  
       {  
             break;  
       }  
       if(funct(x0)*funct(x1)<0)  
       {  
             x2=x0;  
       }  
       else  
       {  
             x1=x0;  
       }  
       if(fabs((x1-x2)/x1)<EPS)  
             break;  
 }  
 printf("\n===========================================");  
 printf("\n\tROOT=%7.4f",x0);  
 printf("\n\tITERATION=%d",c-1);  
 getch();  
 }  
 float funct(float x)  
 {  
 return(x*x-x-2);  
 }