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 D2fx[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>>D2fx;

         convert_ie_to_pe(Fx,0);
         convert_ie_to_pe(D2fx,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 4 :\";

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

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

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

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

       char Choice=NULL;

       long double x=0;
       long double d2fx=0;
       long double actual_d2fx=0;

       int error_flag=0;

       do
      {
         Choice=NULL;

         x=0;
         d2fx=0;
         actual_d2fx=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)];

           d2fx=((-fxp2h+(16*fxph)-(30*fx)+(16*fxmh)-fxm2h)/(12*h*h));

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

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

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

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

         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 that provides an example of dynamic memory allocation

  2. Program that list of letters should be an alphabetical list of upper case letters followed by an alphabetical list of lower case letters

  3. Program that prints all the even numbers b/w 0 to 50 ( using while, do-while and for loop )

  4. Program to illustrate the use of inline functions

  5. Program to draw a C-Curve of nth order

  6. Program that find the distance between two points in 2D and 3D space using function overloading

  7. Program to show the projection of 3D objects using Orthographics Projection Parallel onto xy-plane

  8. Program that takes input of vector elements and performs multiplication operation, and input/output (&gt;&gt;, &lt;&lt;) using operator overloading

  9. Program to find the value of sin at any given angle

  10. Program to multiply 2 polynomial functions

  11. Program that computes and displays the factorial of the given number using recursion

  12. Program to read a Non-Linear function in one variable, then evaluate it and display its result

  13. Program to show the implementation of None-or-All Character Clipping Strategy (Text Clipping Example)

  14. Program that maintains library shop stock using link list

  15. Program for Fahrenheit to Celcius using Class

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

  17. Program to show the Urdu Alphabets using Matrix Method

  18. Text Animation in Graphics Screen

  19. Program to estimate the Differential value of the function at the given point from the given data using Mid-Point Method

  20. Program of Binary Search Tree Operations