C++ Programming Tutorial

 
 
 
 

Image

 /*************************************************************************

           A C++ Program to estimate the value of Second Derivative of the
       function at the given points from the given data using Central
       Difference Formula of Order Two.

  *************************************************************************/


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



 //------------------------  Global Variables  ---------------------------//



 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 = 3  |  max. n = 12 ]\";

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

         cin>>n;

         if(n<3 || 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<3 || 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 2 :\";

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

       gotoxy(8,13);
       cout<<\"f\\\"(x) ÷ [f(x+h)-2f(x)+f(x-h)]/h^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[0] || x>=xn[(n-1)])
        {
           error_flag=1;

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

         else
        {
           int index=0;

           index=get_index(x);

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

           d2fx=((fxph-(2*fx)+fxmh)/(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 to estimate the Integral value of the function at the given points from the given data using Trapezoidal Rule

  2. Program to illustrate the implementation of X-Direction Shear Transformation

  3. Program to construct Newtons Divided Difference Interpolation Formula from the given distinct data points and estimate the value of the function

  4. Program to implement the Kurskals Algorithm to solve Minimum Cost Spanning Tree Problem (MST)

  5. Program to estimate the Integral value of a given function using Gussian Quadrature Rule

  6. Program to perform operator overloading converting one class object to another

  7. Program to display string triangle

  8. Program to illustrate the use of call-by-value method in functions

  9. School management system

  10. Program to implement the Binary search Algorithm

  11. Program to illustrate the difference b/w passing the whole array and the single array element as a parameter to a function

  12. Program to construct Newtons Backward Difference Interpolation Formula from the given distinct equally spaced data points

  13. Program of stack to traverse in inorder, postorder and preorder

  14. Unary Operator ++ Operator Overloading

  15. FUNCTION WITH ALIAS NAME OR REFERENCE VARIABLE IN C++

  16. Program to illustrate the implementation of Scaling Transformation

  17. Program to illustrate the multi-level inheritance

  18. Program to compute nCr

  19. Program to illustrate adding values to the contents of variables whose addresses are in pointers

  20. Program to print the factorial of first five elements of the fibonacci series