C++ Programming Tutorial

 
 
 
 

Image

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

      A C++ Program to read a Non-Linear equation in one variable, then
      evaluate it using Bisection Method and display its kD accurate root.

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


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

 const int max_size=30;

 int top=-1;
 int accuracy=0;
 int iterations=0;

 long double a=0;
 long double b=0;
 long double x=0;

 char Non_linear_equation[100]={NULL};
 char Stack[max_size][max_size]={NULL};
 char Postfix_expression[max_size][max_size]={NULL};



 //-----------------------  Function Prototypes  -------------------------//



 void push(const char *);
 void convert_infix_expression_to_postfix_expression(const char *);

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

 void show_screen( );
 void clear_screen( );
 void get_input_non_linear_equation( );
 void apply_bisection_method( );
 void show_result( );



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



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

       show_screen( );
       get_input_non_linear_equation( );
       apply_bisection_method( );
       show_result( );

       getch( );
       return 0;
    }



 //----------------------  Function Definitions  -------------------------//




 //--------------------------  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_infix_expression_to_postfix_expression(const char*)  ----//


 void convert_infix_expression_to_postfix_expression(const char* Expression)
    {
       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[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[count_2],pop( ));

                   count_2++;
                }
              }

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

                   count_2++;
                }
              }

           push(Symbol_scanned);
        }

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

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

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


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


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

       int count_1=-1;

       char Symbol_scanned[30]={NULL};

       do
      {
         count_1++;

         strcpy(Symbol_scanned,Postfix_expression[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;
    }


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


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

       textbackground(1);
       cprintf(\" Bisection Method \");
       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(3,8+count);
         cout<<\"                                                                            \";
      }

       gotoxy(1,2);
    }


 //------------------- get_input_non_linear_equation( )  -----------------//


 void get_input_non_linear_equation( )
    {
       gotoxy(4,11);
       cout<<\"Non-Linear Equation with One Variable:\";

       gotoxy(4,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(4,14);
       cout<<\"Enter the Function with variabel x = f(x) = \";
       cin>>Non_linear_equation;

       gotoxy(4,19);
       cout<<\"Interval [a,b] where the root x lies :\";

       gotoxy(4,20);
       cout<<\"ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ\";

       gotoxy(4,22);
       cout<<\"Enter the value of a  =  \";
       cin>>a;

       gotoxy(4,24);
       cout<<\"Enter the value of b  =  \";
       cin>>b;

       gotoxy(4,28);
       cout<<\"Enter the number of accuracy required = k =  \";
       cin>>accuracy;

       gotoxy(1,2);
    }


 //---------  calculate_number_of_iterations_for_kd_accuracy( )  ---------//


 const int calculate_number_of_iterations_for_kd_accuracy( )
    {
       long double iterations=0;

       iterations=((log10l(2)+log10l(b-a)+accuracy)/log10l(2));

       return ceill(iterations);
    }


 //---------------------  apply_bisection_method( )  ---------------------//


 void apply_bisection_method( )
    {
       clear_screen( );

       gotoxy(4,10);
       cout<<\"Solution :\";

       gotoxy(4,11);
       cout<<\"ÍÍÍÍÍÍÍÍÍÍ\";

       convert_infix_expression_to_postfix_expression(Non_linear_equation);

       int k=calculate_number_of_iterations_for_kd_accuracy( );

       iterations=k;

       gotoxy(4,13);
       cout<<\"ÚÄÄÂÄÄÄÄÄÄÄÄÄÄÄÄÄÂÄÄÄÄÄÄÄÄÄÄÄÄÄÂÄÄÄÄÄÄÄÄÄÄÄÄÄÂÄÄÄÄÄÄÄÄÄÄÄÄÄÂÄÄÄÄÄÄÄÄÄÄÄÄÄ¿\";

       gotoxy(4,14);
       cout<<\"³n ³      a      ³     Xm      ³      b      ³    f(Xm)    ³  Accuracy   ³\";

       gotoxy(4,15);
       cout<<\"ÃÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄ\";

       gotoxy(4,16);
       cout<<\"³  ³             ³             ³             ³             ³             ³\";

       long double a=::a;
       long double b=::b;
       long double old_x=0;
       long double new_x=x;
       long double fx=0;
       long double fa=0;

       int x_cord=4;
       int y_cord=17;

       for(int count_1=1;count_1<=k;count_1++)
      {
         gotoxy(x_cord,y_cord);
         cout<<\"³  ³             ³             ³             ³             ³             ³\";

         gotoxy(x_cord,(y_cord+1));
         cout<<\"³  ³             ³             ³             ³             ³             ³\";

         old_x=new_x;
         new_x=((a+b)/2);

         gotoxy((x_cord+1),y_cord);
         cout<<count_1;

         gotoxy((x_cord+4),y_cord);
         cout<<a;

         gotoxy((x_cord+18),y_cord);
         cout<<new_x;

         gotoxy((x_cord+32),y_cord);
         cout<<b;

         fx=evaluate_postfix_expression(new_x);
         fa=evaluate_postfix_expression(a);

         gotoxy((x_cord+46),y_cord);
         cout<<fx;

         gotoxy((x_cord+60),y_cord);
         cout<<(new_x-old_x);

         if(fx==0)
        break;

         else if((fa*fx)<0)
        b=new_x;

         else
        a=new_x;

         y_cord+=2;

         if((count_1%12)==0 && count_1<k)
        {
           y_cord=17;

           gotoxy(30,44);
           cout<<\"Press any key to continue...\";
           getch( );

           for(int count_2=1;count_2<25;count_2++)
              {
             gotoxy(3,(16+count_2));
             cout<<\"                                                                            \";
              }
        }
      }

       gotoxy(x_cord,y_cord);
       cout<<\"ÀÄÄÁÄÄÄÄÄÄÄÄÄÄÄÄÄÁÄÄÄÄÄÄÄÄÄÄÄÄÄÁÄÄÄÄÄÄÄÄÄÄÄÄÄÁÄÄÄÄÄÄÄÄÄÄÄÄÄÁÄÄÄÄÄÄÄÄÄÄÄÄÄÙ\";

       x=new_x;

       gotoxy(30,44);
       cout<<\"Press any key to continue...\";
       getch( );
    }


 //---------------------------  show_result( )  --------------------------//


 void show_result( )
    {
       clear_screen( );

       gotoxy(6,10);
       cout<<\"Function of Non-Linear Equation :\";

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

       gotoxy(10,13);
       cout<<\"f(x)  =  \"<<Non_linear_equation;

       gotoxy(6,17);
       cout<<\"Interval [a,b]  =  [ \"<<a<<\" , \"<<b<<\" ]\";

       gotoxy(6,19);
       cout<<\"Accuracy Required = kD =  \"<<accuracy<<\"D\";

       gotoxy(6,25);
       cout<<\"Required Root :\";

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

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

       gotoxy(10,30);
       cout<<\"Number of Iterations  =  \"<<iterations;

       gotoxy(1,2);
    }

    Related Post:
  1. Program that takes input of 2 matrix rows and columns data and displays addition of it using + operator overloading

  2. Program to show the use of Bitwise Operator Right Shift ( &gt;&gt; )

  3. Program to construct Natural Cubic Spline Interpolant from the given data

  4. Matrix Addition Program

  5. Program simulate the working of Pre-Processor

  6. Program to add two integers without using + operator

  7. Program to illustrate the implementation of Translation Transformation

  8. Program that differentiate b/w the variables of the storage class Auto and Static along with global variables

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

  10. Program to convert infix expression to postfix / suffix expression using paranthesize

  11. Program to create a circular linked list

  12. Stacks code in C++

  13. Program to illustrate object initialization and assignment by default member wise copy

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

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

  16. Program to help Umar in this task. Represent each city by one lowercase character. Thus, you can have at most 26 different cities to visit....

  17. Program for Operator Overloading and Friend Function concept

  18. Program to implement the Kurskals Algorithm to solve Minimum Cost Spanning Tree Problem (MST) using Graphics with Mouse Support

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

  20. Program of LL Parser