C ++ principle paradigm

# Define formula_header
# Include <string>
# Include <stack>
# Include <vector>
# Include <iostream>
Using namespace STD;
Class formulabase
{
PRIVATE:
Int numvar; // The number of the variables in the formula
Bool Variables [100]; // to store the value of the variables
String sourceformula;
String normalcformula;
String normaldformula;
String dualformula;
Vector <char> vctofvar;
Vector <char> vctofpoland;
Stack <char> STK;
Bool isvar (char ch) const;
Void addmin (INT minterm );
Void addmax (INT maxterm );
Bool compute (INT minterm );
Void getinversepoland ();
Int countterms (int n );
Void assign (INT minterm );
Stack <bool> boolstk;
Public:
Formulabase ();
Formulabase (const formulabase & RHs );
~ Formulabase ();
Void getsource ();
String generatenormalc ();
String generatenormald ();
String getdual ();
Void printsource () const {cout <sourceformula <Endl ;}
Void printdnormal () const {cout <normaldformula <Endl ;}
Void printcnormal () const {cout <normalcformula <Endl ;}
Void printdual () const {cout <dualformula <Endl ;}
// Void printtruthtable ();

 

};

# Include "formula_header.h" // →? Why ???? Too many characters ??????... ▼ △ ???♀
Formulabase: formulabase ()
{
For (INT I = 0; I <100; I ++) variables [I] = false;
Numvar = 0;
}
Formulabase: formulabase (const formulabase & RHs)
{
Sourceformula = RHS. sourceformula;
For (INT I = 0; I <100; I ++) variables [I] = false;
Numvar = 0;
}
Formulabase ::~ Formulabase ()
{

While (! STK. Empty () STK. Pop ();
Vctofvar. Clear ();
Vctofpoland. Clear ();
}
Int formulabase: countterms (int n)
{
If (n = 0)
{
Cout <"invalid input! "<Endl;
Exit (0 );
}
Switch (N)
{
Case 1: return 2;
Case 2: return 4;
Default:
{
Int Tempa = 2, tempb = 2;
For (INT I = 2; I <= N; I * = 2) Tempa * = Tempa;
I/= 2;
If (I = N) return Tempa;
I = n-I;
For (Int J = 2; j <= I; j * = 2) tempb * = tempb;

For (J/= 2; j <I; j ++) tempb * = 2;
Tempb * = Tempa;
Return tempb;
}
}
 

}
Bool formulabase: isvar (char ch) const
{
If (CH> = 'A' & Ch <= 'Z ')
Return true;
Return false;
}
Void formulabase: getsource ()
{
Cout <"input the source formula:" <Endl;
Cin> sourceformula;
/* If (! Isvalid (sourceformula ))
Cout <"invalid input! "
"Operate again:" <Endl;
Cin> sourceformula ;*/

}
Void formulabase: getinversepoland ()
{
 
Char temp, temp1;
For (INT I = 0; sourceformula [I]! = '/0'; I ++)
{
Temp = sourceformula [I];
If (isvar (temp ))
{
If (! Variables [temp])
{
Numvar ++;
Vctofvar. push_back (temp );
Variables [temp] = true;
}
Vctofpoland. push_back (temp );

}
Else
Switch (temp)
{
Case '→': Case 'others ':
Case 'handler ':
Case '⊙ ':
While (! STK. Empty ())
{
If (STK. Top () = temp)
{
Vctofpoland. push_back (temp );
STK. Pop ();
}
Else break;
}
STK. Push (temp );
Break;
Case '(': Case '! ':
STK. Push (temp );
Break;
Case '+ ':
While (! STK. Empty ())
{
If (STK. Top ()! = '(')
{
Temp1 = STK. Top ();
Vctofpoland. push_back (temp1 );
STK. Pop ();
}
Else break;
}
STK. Push (temp );
Break;
Case '*':
While (! STK. Empty ())
{
Temp1 = STK. Top ();
If (STK. Top () = '*' | STK. Top () = '! ')
{
Vctofpoland. push_back (temp1 );
STK. Pop ();
}
Else
Break;
}
STK. Push (temp );
Break;

Case ')':
While (! STK. Empty ())
{
If (STK. Top ()! = '(')
{
Temp1 = STK. Top ();
Vctofpoland. push_back (temp1 );
STK. Pop ();
}
Else break;
}
If (STK. Empty () Exit (0 );
STK. Pop (); // pop the operator '('

Break;

}
}
While (! STK. Empty ())
{
Temp1 = STK. Top ();
Vctofpoland. push_back (temp1 );
STK. Pop ();
}
}
Void formulabase: Assign (INT minterm)
{
Int temp = minterm;
Vector <char>: const_iterator itr = vctofvar. Begin ();
For (; itr! = Vctofvar. End (); itr ++)
{

Variables [* itr] = bool (temp & 1 );
Temp = temp> 1;
}

}

Bool formulabase: Compute (INT minterm)
{
Assign (minterm );
Char temp;
Bool valuea, valueb;
Vector <char>: const_iterator itr = vctofpoland. Begin ();
While (itr! = Vctofpoland. End ())
{
Temp = * itr;
If (isvar (temp) boolstk. Push (variables [temp]);
Else
Switch (temp)
{
Case '+ ':
{
If (boolstk. Size () <2) Exit (0 );
Valuea = boolstk. Top ();
Boolstk. Pop ();
Valueb = boolstk. Top ();
Boolstk. Pop ();
Valuea = valuea | valueb;
Boolstk. Push (valuea );

}
Break;
Case '*':
{
If (boolstk. Size () <2) Exit (0 );
Valuea = boolstk. Top ();
Boolstk. Pop ();
Valueb = boolstk. Top ();
Boolstk. Pop ();
Valuea = valuea & valueb;
Boolstk. Push (valuea );

}
Break;
Case '! ':
{
If (boolstk. Empty () Exit (0 );
Valuea =! (Boolstk. Top ());
Boolstk. Pop ();
Boolstk. Push (valuea );

}
Break;
Case '→ ':
{
If (boolstk. Size () <2) Exit (0 );
Valuea = boolstk. Top ();
Boolstk. Pop ();
Valueb = boolstk. Top ();
Boolstk. Pop ();
Valuea = (! Valuea) | valueb;
Boolstk. Push (valuea );

}
Break;
Case 'handler ':
{
If (boolstk. Size () <2) Exit (0 );
Valuea = boolstk. Top ();
Boolstk. Pop ();
Valueb = boolstk. Top ();
Boolstk. Pop ();
Valuea =! (Valuea & valueb );
Boolstk. Push (valuea );

}
Break;
Case 'handler ':
{
If (boolstk. Size () <2) Exit (0 );
Valuea = boolstk. Top ();
Boolstk. Pop ();
Valueb = boolstk. Top ();
Boolstk. Pop ();
Valuea =! (Valuea | valueb );
Boolstk. Push (valuea );

}
Break;
Case 'handler ':
{
If (boolstk. Size () <2) Exit (0 );
Valuea = boolstk. Top ();
Boolstk. Pop ();
Valueb = boolstk. Top ();
Boolstk. Pop ();
Valuea = (! Valuea & valueb) | (valuea &&! Valueb );
Boolstk. Push (valuea );

}
Break;
Case '⊙ ':
{
If (boolstk. Size () <2) Exit (0 );
Valuea = boolstk. Top ();
Boolstk. Pop ();
Valueb = boolstk. Top ();
Boolstk. Pop ();
Valuea = (valuea & valueb) | (! Valuea &&! Valueb );
Boolstk. Push (valuea );

}
Break;

 

}
Itr ++;
}
If (boolstk. Size ()! = 1)
{
Cout <"error in computing the value of minterm" <Endl;
Exit (0 );
}
Valuea = boolstk. Top ();
Boolstk. Pop ();
Return valuea;
 
 
}
Void formulabase: addmin (INT minterm)
{
Int temp = minterm;
Vector <char>: const_iterator itr = vctofvar. Begin ();
Normalcformula + = '(';
While (itr! = Vctofvar. End ())
{
If (! Variables [* itr])
Normalcformula + = '! ';
Normalcformula + = * itr;
Normalcformula + = '*';
Itr ++;

}
Normalcformula + = "/B) + ";
}
Void formulabase: addmax (INT maxterm)
{
Int temp = maxterm;
Vector <char>: const_iterator itr = vctofvar. Begin ();
Normaldformula + = '(';
While (itr! = Vctofvar. End ())
{
If (variables [* itr])
Normaldformula + = '! ';
Normaldformula + = * itr;
Normaldformula + = '+ ';
Itr ++;

}
Normaldformula + = "/B )*";
}

String formulabase: generatenormalc ()
{
If (vctofpoland. Size () = 0) // This oeration has not been done yet!
Getinversepoland ();
Cout <"here! "<Endl;
Int n = countterms (numvar );
Cout <n <"countterms" <Endl;
Normalcformula = '';
For (INT I = 0; I <n; I ++)
{
If (compute (I) addmin (I );

}
Normalcformula + = "/B ";
Return normalcformula;

}
String formulabase: generatenormald ()
{
If (vctofpoland. Size () = 0) // this operation has not been done yet !!
Getinversepoland ();
Int n = countterms (numvar );
Normaldformula = '';
For (INT I = 0; I <n; I ++)
{
If (! Compute (I) addmax (I );
}
Normaldformula + = "/B ";
Return normaldformula;
 
}

String formulabase: getdual ()
{
Int I = 0;
Char temp;
Dualformula = '';
While (temp = sourceformula [I])! = '/0 ')
{
Switch (temp)
{
Case '! ':
{
I ++;
Dualformula + = sourceformula [I];
Break;
}
Case '+': dualformula + = '*'; break;
Case '*': dualformula + = '+'; break;

Case '(': case') ': dualformula + = sourceformula [I];
Break;
Default:
If (isvar (temp ))
{
Dualformula + = '! ';
Dualformula + = temp;
}
Else
{
Cout <"error! "<Endl;
Exit (0 );
}
}
I ++;
}
Return dualformula;
}
/* Void formulabase: printtruthtable () // a const function is unable to call a nonconst Function !!!
{
Int I = 0;
Int COUNT = countterms (numvar );
Cout <"Truth Table/N ";
For (I = 0; I <= numvar; I ++) cout <"___";
Cout <Endl;
// For (I = 0; I <numvar; I ++) cout <'|' <vctofvar [I];
// Cout <"| f |" <Endl;
For (I = 0; I <= numvar; I ++) cout <"___";
Cout <Endl;
For (I = 0; I <count; I ++)
{
Int temp = I;
For (Int J = 0; j <numvar; j ++)
{
If (bool (temp & 1) cout <"| 1 ";
Else cout <"| 0 ";
Temp = temp> 1;
}
If (this-> compute (I) cout <"| 1 ";
Else cout <"| 0 ";
Cout <'|' <Endl;
For (int K = 0; k <= numvar; k ++) cout <"___";
Cout <Endl;
}

}
*/