C++ Programming Tutorial

 
 
 
 

Image

 # include <iostream.h>
 # include   <stdlib.h>
 # include   <string.h>
 # include    <stdio.h>
 # include    <conio.h>
 # include     <math.h>

 const int max_size=13;

 int n=0;
 int top=-1;
 int choice=0;

 long double h=0;
 long double x0=0;

 long double xn[max_size]={0};
 long double fx[max_size]={0};

 char Fx[100]={NULL};
 char D4fx[100]={NULL};
 char Stack[30][30]={NULL};
 char Postfix_expression[2][30][30]={NULL};



 //------------------------  Funcion Prototypes  -------------------------//



 void push(const char *);
 void convert_ie_to_pe(const char *,const int);

 const char* pop( );
 const long double evaluate_postfix_expression(const long double,const int);

 void show_screen( );
 void clear_screen( );
 void get_input( );
 void estimate_dfx( );

 const int get_index(const long double);



 //------------------------------  main( )  ------------------------------//



 int main( )
    {
       clrscr( );
       textmode(C4350);

       show_screen( );
       get_input( );
       estimate_dfx( );

       return 0;
     }



 //------------------------  Funcion Definitions  ------------------------//




 //--------------------------  show_screen( )  ---------------------------//


 void show_screen( )
    {
       cprintf(\"\\n********************************************************************************\");
       cprintf(\"*************************-                             -************************\");
       cprintf(\"*------------------------- \");

       textbackground(1);
       cprintf(\" Numerical Differentiation \");
       textbackground(8);

       cprintf(\" ------------------------*\");
       cprintf(\"*-***********************-                             -**********************-*\");
       cprintf(\"*-****************************************************************************-*\");

       for(int count=0;count<42;count++)
      cprintf(\"*-*                                                                          *-*\");

       gotoxy(1,46);
       cprintf(\"*-****************************************************************************-*\");
       cprintf(\"*------------------------------------------------------------------------------*\");
       cprintf(\"********************************************************************************\");

       gotoxy(1,2);
    }


 //-------------------------  clear_screen( )  ---------------------------//


 void clear_screen( )
    {
       for(int count=0;count<37;count++)
      {
         gotoxy(5,8+count);
         cout<<\"                                                                        \";
      }

       gotoxy(1,2);
    }


 //--------------------------  push(const char*)  ------------------------//


 void push(const char* Operand)
    {
       if(top==(max_size-1))
      {
         cout<<\"Error : Stack is full.\"<<endl;
         cout<<\"\\n        Press any key to exit.\";

         getch( );
         exit(0);
      }

       else
      {
         top++;
         strcpy(Stack[top],Operand);
      }
    }


 //------------------------------  pop( )  -------------------------------//


 const char* pop( )
    {
       char Operand[40]={NULL};

       if(top==-1)
      {
         cout<<\"Error : Stack is empty.\"<<endl;
         cout<<\"\\n        Press any key to exit.\";

         getch( );
         exit(0);
      }

       else
      {
         strcpy(Operand,Stack[top]);
         strset(Stack[top],NULL);
         top--;
      }

       return Operand;
    }


 //----------------  convert_ie_to_pe(const char*,const int)  ------------//


 void convert_ie_to_pe(const char* Expression,const int index)
    {
       char Infix_expression[100]={NULL};
       char Symbol_scanned[30]={NULL};

       push(\"(\");
       strcpy(Infix_expression,Expression);
       strcat(Infix_expression,\"+0)\");

       int flag=0;
       int count_1=0;
       int count_2=0;
       int equation_length=strlen(Infix_expression);

       if(Infix_expression[0]==\'(\')
      flag=1;

       do
      {
         strset(Symbol_scanned,NULL);

         if(flag==0)
        {
           int count_3=0;

           do
              {
             Symbol_scanned[count_3]=Infix_expression[count_1];

             count_1++;
             count_3++;
              }
           while(count_1<=equation_length &&
               Infix_expression[count_1]!=\'(\' &&
                  Infix_expression[count_1]!=\'+\' &&
                 Infix_expression[count_1]!=\'-\' &&
                    Infix_expression[count_1]!=\'*\' &&
                       Infix_expression[count_1]!=\'/\' &&
                      Infix_expression[count_1]!=\'^\' &&
                         Infix_expression[count_1]!=\')\');


           flag=1;
        }

         else if(flag==1)
        {
           Symbol_scanned[0]=Infix_expression[count_1];

           count_1++;

           if(Infix_expression[count_1]!=\'(\' &&
             Infix_expression[count_1]!=\'^\' &&
                Infix_expression[count_1]!=\'*\' &&
                   Infix_expression[count_1]!=\'/\' &&
                  Infix_expression[count_1]!=\'+\' &&
                     Infix_expression[count_1]!=\'-\' &&
                    Infix_expression[count_1]!=\')\')
              flag=0;

           if(Infix_expression[count_1-1]==\'(\' &&
               (Infix_expression[count_1]==\'-\' ||
                 Infix_expression[count_1]==\'+\'))
              flag=0;
        }

         if(strcmp(Symbol_scanned,\"(\")==0)
        push(\"(\");

         else if(strcmp(Symbol_scanned,\")\")==0)
        {
           while(strcmp(Stack[top],\"(\")!=0)
              {
             strcpy(Postfix_expression[index][count_2],pop( ));

             count_2++;
              }

           pop( );
        }

         else if(strcmp(Symbol_scanned,\"^\")==0 ||
               strcmp(Symbol_scanned,\"+\")==0 ||
                 strcmp(Symbol_scanned,\"-\")==0 ||
                       strcmp(Symbol_scanned,\"*\")==0 ||
                         strcmp(Symbol_scanned,\"/\")==0)
        {
           if(strcmp(Symbol_scanned,\"^\")==0)
              {  }

           else if(strcmp(Symbol_scanned,\"*\")==0 ||
                          strcmp(Symbol_scanned,\"/\")==0)
              {
             while(strcmp(Stack[top],\"^\")==0 ||
                     strcmp(Stack[top],\"*\")==0 ||
                       strcmp(Stack[top],\"/\")==0)
                {
                   strcpy(Postfix_expression[index][count_2],pop( ));

                   count_2++;
                }
              }

           else if(strcmp(Symbol_scanned,\"+\")==0 ||
                    strcmp(Symbol_scanned,\"-\")==0)
              {
             while(strcmp(Stack[top],\"(\")!=0)
                {
                   strcpy(Postfix_expression[index][count_2],pop( ));

                   count_2++;
                }
              }

           push(Symbol_scanned);
        }

         else
        {
           strcat(Postfix_expression[index][count_2],Symbol_scanned);

           count_2++;
        }
      }
       while(strcmp(Stack[top],NULL)!=0);

       strcat(Postfix_expression[index][count_2],\"=\");
       count_2++;
    }


 //-----  evaluate_postfix_expression(const long double,const int)  ------//


 const long double evaluate_postfix_expression(
                    const long double x,const int index)
    {
       long double function_value=0;

       int count_1=-1;

       char Symbol_scanned[30]={NULL};

       do
      {
         count_1++;

         strcpy(Symbol_scanned,Postfix_expression[index][count_1]);

         if(strcmp(Symbol_scanned,\"^\")==0 ||
              strcmp(Symbol_scanned,\"*\")==0 ||
                strcmp(Symbol_scanned,\"/\")==0 ||
                  strcmp(Symbol_scanned,\"+\")==0 ||
                    strcmp(Symbol_scanned,\"-\")==0)

        {
           char Result[30]={NULL};
           char Operand[2][30]={NULL};

           strcpy(Operand[0],pop( ));
           strcpy(Operand[1],pop( ));

           long double operand[2]={0};
           long double result=0;

           char *endptr;

           for(int count_2=0;count_2<2;count_2++)
              {
             int flag=0;

             if(Operand[count_2][0]==\'-\')
                {
                   int length=strlen(Operand[count_2]);

                   for(int count_3=0;count_3<(length-1);count_3++)
                  Operand[count_2][count_3]=Operand[count_2][(count_3+1)];

                   Operand[count_2][count_3]=NULL;

                   flag=1;
                }

             if(strcmp(Operand[count_2],\"x\")==0)
                operand[count_2]=x;

             else if(strcmp(Operand[count_2],\"e\")==0)
                operand[count_2]=2.718282;

             else if(strcmp(Operand[count_2],\"sinx\")==0)
                operand[count_2]=sinl(x);

             else if(strcmp(Operand[count_2],\"cosx\")==0)
                operand[count_2]=cosl(x);

             else if(strcmp(Operand[count_2],\"tanx\")==0)
                operand[count_2]=tanl(x);

             else if(strcmp(Operand[count_2],\"lnx\")==0)
                operand[count_2]=logl(x);

             else if(strcmp(Operand[count_2],\"logx\")==0)
                operand[count_2]=log10l(x);

             else
                operand[count_2]=strtod(Operand[count_2],&endptr);

             if(flag)
                operand[count_2]*=-1;
              }

           switch(Symbol_scanned[0])
              {
             case \'^\' : result=powl(operand[1],operand[0]);
                    break;

             case \'*\' : result=operand[1]*operand[0];
                    break;

             case \'/\' : result=operand[1]/operand[0];
                    break;

             case \'+\' : result=operand[1]+operand[0];
                    break;

             case \'-\' : result=operand[1]-operand[0];
                    break;
              }

           gcvt(result,25,Result);

           push(Result);
        }

         else if(strcmp(Symbol_scanned,\"=\")!=0)
        push(Symbol_scanned);
      }
       while(strcmp(Symbol_scanned,\"=\")!=0);

       char Function_value[30]={NULL};
       char *endptr;

       strcpy(Function_value,pop( ));
       function_value=strtod(Function_value,&endptr);

       return function_value;
    }


 //-----------------------------  get_input( )  --------------------------//


 void get_input( )
    {
       do
      {
         clear_screen( );

         gotoxy(6,9);
         cout<<\"Number of Distinct Data Points :\";

         gotoxy(6,10);
         cout<<\"ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ\";

         gotoxy(27,13);
         cout<<\"[ min. n = 5  |  max. n = 12 ]\";

         gotoxy(6,12);
         cout<<\"Enter the max. number of distinct data points = n = \";

         cin>>n;

         if(n<5 || n>12)
        {
           gotoxy(12,25);
           cout<<\"Error : Wrong Input. Press <Esc> to exit or any other key\";

           gotoxy(12,26);
           cout<<\"        to try again.\";

           n=int(getche( ));

           if(n==27)
              exit(0);
        }
      }
       while(n<5 || n>12);

       gotoxy(6,16);
       cout<<\"Enter the value of x0 = \";

       cin>>x0;

       gotoxy(6,18);
       cout<<\"Enter the value of h = \";

       cin>>h;

       gotoxy(6,24);
       cout<<\"Input Mode :\";

       gotoxy(6,25);
       cout<<\"ÍÍÍÍÍÍÍÍÍÍÍÍ\";

       gotoxy(8,28);
       cout<<\"Press : \";

       gotoxy(10,30);
       cout<<\"- \'Y\' or <Enter> to enter function\";

       gotoxy(10,32);
       cout<<\"- \'N\' or <Any other key> to enter values of the function\";

       gotoxy(8,35);
       cout<<\"Enter your choice : \";

       char Choice=NULL;

       Choice=getch( );

       if(Choice==\'y\' || Choice==\'Y\' || int(Choice)==13)
      {
         choice=1;

         gotoxy(28,35);
         cout<<\"Y\";
      }

       else
      {
         gotoxy(28,35);
         cout<<\"N\";
      }

       gotoxy(25,43);
       cout<<\"Press any key to continue...\";

       getch( );

       if(choice)
      {
         clear_screen( );

         gotoxy(6,11);
         cout<<\"Non-Linear Function :\";

         gotoxy(6,12);
         cout<<\"ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ\";

         gotoxy(6,37);
         cout<<\"Note : Write the function with proper Braces ( ) e.g; 2x+3 as (2*x)+3\";

         gotoxy(6,40);
         cout<<\"Available Operators  :  ^ (raised to power) , * , / , + , -\";

         gotoxy(6,42);
         cout<<\"Available Operands   :  x , e , sinx , cosx , tanx , lnx , logx ,\";

         gotoxy(6,44);
         cout<<\"                        n = any number\";

         gotoxy(6,14);
         cout<<\"Enter the Function : f(x) = \";

         cin>>Fx;

         gotoxy(6,17);
         cout<<\"Enter the Differential Function : f\\\"\\\"(x) = \";

         cin>>D4fx;

         convert_ie_to_pe(Fx,0);
         convert_ie_to_pe(D4fx,1);
      }

       clear_screen( );

       gotoxy(6,9);
       cout<<\"Data Points & Values of Function :\";

       gotoxy(6,10);
       cout<<\"ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ\";

       gotoxy(25,12);
       cout<<\"ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÂÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿\";

       gotoxy(25,13);
       cout<<\"³       x       ³     f(x)      ³\";

       gotoxy(25,14);
       cout<<\"ÃÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ\";

       gotoxy(25,15);
       cout<<\"³               ³               ³\";

       for(int count_1=0;count_1<n;count_1++)
      {
         gotoxy(25,(wherey( )+1));
         cout<<\"³               ³               ³\";

         gotoxy(25,(wherey( )+1));
         cout<<\"³               ³               ³\";
      }

       gotoxy(25,(wherey( )+1));
       cout<<\"ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÁÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ\";

       xn[0]=x0;

       for(int count_2=0;count_2<(n-1);count_2++)
      xn[(count_2+1)]=(xn[count_2]+h);

       gotoxy(25,16);

       for(int count_3=0;count_3<n;count_3++)
      {
         gotoxy(27,wherey( ));
         cout<<xn[count_3];

         if(choice)
        {
           fx[count_3]=evaluate_postfix_expression(xn[count_3],0);

           gotoxy(43,wherey( ));
           cout<<fx[count_3];
        }

         else
        {
           gotoxy(43,wherey( ));
           cin>>fx[count_3];
        }

         if(choice)
        gotoxy(25,(wherey( )+2));

         else
        gotoxy(25,(wherey( )+1));
      }

       gotoxy(25,43);
       cout<<\"Press any key to continue...\";

       getch( );
    }


 //-------------------  get_index(const long double)  --------------------//


 const int get_index(const long double x)
    {
       for(int count=0;count<n;count++)
      {
         if(xn[count]==x)
        break;
      }

       return count;
    }


 //----------------------------  estimate_dfx( )  ------------------------//


 void estimate_dfx( )
    {
       clear_screen( );

       gotoxy(6,9);
       cout<<\"Centeral Difference Formula of Order 2 :\";

       gotoxy(6,10);
       cout<<\"ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ\";

       gotoxy(8,13);
       cout<<\"f\\\"\\\"(x) ÷ [f(x+2h)-4f(x+h)+6f(x)-4f(x-h)+f(x-2h)]/h^4\";

       gotoxy(6,17);
       cout<<\"Estimation of f\\\"\\\"(x) :\";

       gotoxy(6,18);
       cout<<\"ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ\";

       char Choice=NULL;

       long double x=0;
       long double d4fx=0;
       long double actual_d4fx=0;

       int error_flag=0;

       do
      {
         Choice=NULL;

         x=0;
         d4fx=0;
         actual_d4fx=0;
         error_flag=0;

         gotoxy(10,20);
         cout<<\"Enter the value of x = \";

         cin>>x;

         if(x<=xn[1] || x>=xn[(n-2)])
        {
           error_flag=1;

           gotoxy(10,23);
           cout<<\"Error: Please enter x greater than x(1) and less than x(n-1).\";
        }

         else
        {
           int index=0;

           index=get_index(x);

           long double fx=::fx[index];
           long double fxph=::fx[(index+1)];
           long double fxp2h=::fx[(index+2)];
           long double fxmh=::fx[(index-1)];
           long double fxm2h=::fx[(index-2)];

           d4fx=((fxp2h-(4*fxph)+(6*fx)-(4*fxmh)+fxm2h)/(powl(h,4)));

           gotoxy(10,23);
           cout<<\"The estimated value of f\\\"\\\"(\"<<x<<\")  ÷  \"<<d4fx;
        }

         if(choice && !error_flag)
        {
           actual_d4fx=evaluate_postfix_expression(x,1);

           gotoxy(10,25);
           cout<<\"The Actual value of f\\\"\\\"(\"<<x<<\")  =  \"<<actual_d4fx;

           gotoxy(10,28);
           cout<<\"Absolute Error = E(abs) =  \"<<fabs((actual_d4fx-d4fx));
        }

         gotoxy(15,42);
         cout<<\"Press <Esc> to exit or any other key to continue...\";

         Choice=getch( );

         if(int(Choice)!=27)
        {
           gotoxy(10,20);
           cout<<\"                                                    \";

           gotoxy(10,23);
           cout<<\"                                                              \";

           gotoxy(10,25);
           cout<<\"                                                    \";

           gotoxy(10,28);
           cout<<\"                                                    \";

           gotoxy(15,42);
           cout<<\"                                                    \";
        }

         else if(int(Choice)==27)
        exit(0);
      }
       while(1);
    }

    Related Post:
  1. Program to convert a decimal number into binary, octal and pental code

  2. Program to show the projection of 3D objects using Orthographics Parallel Projection w.r.t. xy-plane and along vector v

  3. Program to convert points to rectangle coordinates and polar coordinates

  4. Program to open file

  5. Program of Shortest Path for Given Source and Destination (using Dijkstras Algo.)

  6. Program to generate a triangular wave form according to a specified pair of Amplitude and Frequency

  7. Program to add two integers of any length

  8. Program to show a 3D object using Polygon-Mesh Representation

  9. Program to show the projection of 3D objects using Cavalier Oblique Parallel Projection onto xy-plane (i.e. angle=45 deg)

  10. Program that takes input of 2 matrix rows and columns data and displays addition of it using + operator overloading

  11. Menu driven telephone directory program

  12. Program to estimate the Integral value of the function at the given points from the given data using Simpsons 1/3 Rule

  13. Program that reads in a matrix and checks if it has the parity property

  14. Program of displaying product inventory by converting one class to another class

  15. Program of Flood fill algorithm

  16. Library system using pointers

  17. Program to read a Non-Linear equation in one variable, then evaluate it using Modified False-Position Method and display its kD accurate root

  18. Program to show the 3D Reflection Transformation along zx-plane

  19. Program to draw an Ellipsoid using Parametric Equations

  20. Program to illustrate the relationship b/w union and structure