PROGRAM 2


//  FILENAME:  TTABLE.H
//  THIS IS THE DECLARATION FOR THE TRUTH_TABLE CLASS.
#include 
#include 
#include 
#include 
#include 
#include 
#include 
class TRUTH_TABLE
{
    public:
        //  CONSTRUCTER.
        TRUTH_TABLE ();
        //  DESTRUCTER.
        ~TRUTH_TABLE ();
        //  OPEN DATA FILE CONTAINING THE TRUTH TABLE'S FUNCTION
        //  AND AN OUT FILE, CONTAINING THE TRUTH TABLE.
        OPEN_FILES ();
        //  GET FUNCTION FROM THE DATA FILE.  PUT THE VARIABLES IN A CHAR
        //  ARRAY AND THE NUMBERS IN A INTEGER ARRAY.  ALSO, DETERMINE
        //  THE NUMBER OF COLS.
        GET_FUNCTION ();
        //  INITIALIZE SUMS TO 0.
        INITIALIZE_SUMS ();
        //  PRINT HEADING AND SUB-HEADINGS.
        DRAW_HEADINGS ();
        //  DRAW TRUTH TABLE.
        DRAW_TTABLE ();
        //  DRAW AN EDGE OF THE TRUTH TABLE.
        DRAW_EDGE_BOX (int ROW, int COL, int LINE_COUNT);
        //  DRAW THE MIDDLE PART OF THE TRUTH TABLE.
        DRAW_MIDDLE_BOX (int ROW, int COL);
        //  DRAW A BOX PART.
        DRAW_BOXPART (int BOX_PART);
        //  DRAW THE CURRENT ROW AT THE LEFT OF THE TRUTH TABLE.
        DRAW_ROW (int ROW);
        //  DRAW THE 1'S AND 0'S IN FOR THE SUM PART OF THE BOX.
        DRAW_SUMS (int ROW);
        //  DRAW THE CURRENT PAGE AT THE BOTTOM OF THE TRUTH TABLE.
        DRAW_PAGE (int PAGE_COUNT, int LINE_COUNT);
        //  DRAW A 0 OR A 1 IN INDIVIDUAL BOXES OF THE TRUTH TABLE.
        DRAW_01 (int ROW, int COL);
        //  CLOSE DATA FILE AND OUT FILE.
        CLOSE_FILES ();
    private:
        //  THE STRING FUNCTION.
        char FUNCTION [4025];
        //  THE VARIABLES OF THE FUNCTION.
        char VARIABLES [11];
        //  THE SUMS OF THE FUNCTION.
        int SUMS [1024];
        //  TOTAL NUMBER OF COLUMNS IN TRUTH TABLE.
        int TOTAL_COLS;
        //  TOTAL NUMBER OF ROWS IN TRUTH TABLE + 1.
        int TOTAL_ROWS;
        //  MAXIMUM NUMBER OF BAR LINES.
        int MAX_LINES;
        //  FILE POINTER TO DATA FILE.
        ifstream FILEPTR1;
        //  FILE POINTER TO OUT FILE.
        ofstream FILEPTR2;
};
//  THIS IS THE IMPLEMENTATION FOR THE TRUTH_TABLE CLASS.
//  CONSTRUTER.
TRUTH_TABLE :: TRUTH_TABLE ()
{
    //  INITIALIZE TOTAL_COLS, FILEPTR1, AND FILEPTR2 TO 0.
    TOTAL_COLS = 0;
    TOTAL_ROWS = 0;
    MAX_LINES = 0;
}
//  DESTRUCTER.
TRUTH_TABLE :: ~TRUTH_TABLE ()
{
}
//  OPEN DATA FILE CONTAINING THE FUNCTION OF THE TRUTH TABLE AND
//  AN OUT FILE, CONTAINING THE TRUTH TABLE.
TRUTH_TABLE :: OPEN_FILES ()
{
    //  DECLARE VARIABLES FOR FILES, ASSIGN THEM NAMES, AND OPEN FILES.
    char DATA_FILE [25];
    char OUT_FILE [25];
    strcpy (DATA_FILE, "TTABLE.DAT");
    strcpy (OUT_FILE, "TTABLE.OUT");
    FILEPTR1.open (DATA_FILE, ios :: in);
    FILEPTR2.open (OUT_FILE, ios :: out);
    //  IF THERE IS A PROBLEM WITH FILES, PRINT ERROR MESSAGE AND QUIT.
    if (!FILEPTR1 || !FILEPTR2)
    {
        cout << "ERROR OPENING ONE OF THE FILES." << endl;
        exit (0);
    }
    return 0;
}
//  INTIALIZE SUMS.
TRUTH_TABLE :: INITIALIZE_SUMS ()
{
    //  INITIALIZE ALL SUMS TO 0.  LATER, SOME OF THESE VALUES WILL
    //  CHANGE TO 1'S (DEPENDING ON THE FUNCTION).
    for (int I = 0; I <= 1023; I++)
    {
        SUMS [I] = 0;
    }
    return 0;
}
//  GET FUNCTION FROM THE TRUTH TABLE, PLACE THE VARIABLES IN A CHAR ARRAY
//  AND THE NUMBERS IN A INTEGER ARRAY.  ALSO DETERMINE THE NUMBER OF COLS.
TRUTH_TABLE :: GET_FUNCTION ()
{
    //  THIS VARIABLE COUNTS THE NUMBER OF VARIABLES IN THE TRUTH
    //  TABLE.  IT WILL BE USED TO DETERMINE THE NUMBER OF COLS
    //  LATER ON.
    int COUNT_VARIABLES = 0;
    //  COUNTS THE NUMBER OF DIGITS IN EACH NUMBER OF THE SUMS.
    int COUNT_DIGITS = 0;
    //  THIS VARIABLE HOLDS EACH NUMBER OF THE SUMS TEMPORARILY AS
    //  A CHARACTER STRING.  IT WILL BE CHANGED TO A INTEGER.
    char NUMBER [10];
    //  THIS VARIABLE HOLDS EACH NUMBER OF THE SUMS TEMPORARILY AS
    //  A INTEGER BEFORE IT IS GIVEN TO THE INTEGER ARRAY VARIABLE (SUMS).
    int ANUMBER;
    //  INITIALIZE ALL SUMS TO 0.
    INITIALIZE_SUMS ();
    //  GET THE FUNCTION FROM THE DATA FILE.
    FILEPTR1 >> FUNCTION;
    //  PUT THE LETTERS OF THE FUNCTION IN THE VARIABLE'S CHAR STRING.
    //  PUT THE NUMBERS OF THE FUNCTION IN SUMS' INTEGER ARRAY.
    for (int I = 0; FUNCTION [I] != '\0'; I++)
    {
        //  IF CURRENT FUNCTION CHARACTER IS A LETTER,
        //  PUT IT IN THE VARIABLE'S CHAR STRING AND
        //  INCREMENT THE VARIABLE COUNT BY 1.
        if ((FUNCTION [I] <= 122 && FUNCTION [I] >= 97) ||
            (FUNCTION [I] <= 90 && FUNCTION [I] >= 65))
        {
            VARIABLES [COUNT_VARIABLES] = FUNCTION [I];
            COUNT_VARIABLES = COUNT_VARIABLES + 1;
        }
        //  IF CURRENT FUNCTION CHAR IS A DIGIT, PUT IT IN
        //  THE SUM'S INTEGER ARRAY.
        else if (FUNCTION [I] <= 57  && FUNCTION [I] >= 48)
        {
            //  PUT THE CURRENT NUMBER OF THE FUNCTION
            //  TEMPORARILY IN A CHAR STRING CALLED NUMBER.
            NUMBER [COUNT_DIGITS] = FUNCTION [I];
            //  INCREMENT THE DIGIT COUNT BY 1.
            COUNT_DIGITS = COUNT_DIGITS + 1;
            //  IF THE NEXT CHARACTER IS A ',', THEN USE
            //  THE FUNCTION ATOI TO TRANFER THE STRING
            //  TO AN INTEGER VALUE.  THEN, MAKE THE SUM'S
            //  INTEGER ARRAY = TO 1 FOR THAT NUMBER AND
            //  MAKE COUNT DIGITS = TO 0.
            if (FUNCTION [I + 1] == ','  || FUNCTION [I + 1] == ')')
            {
                NUMBER [COUNT_DIGITS] = '\0';
                ANUMBER = atoi (NUMBER);
                SUMS [ANUMBER] = 1;
                COUNT_DIGITS = 0;
            }
        }
    }
    //  PUT '\0' IN THE LAST CHARACTER OF THE VARIABLE STRING.
    VARIABLES [COUNT_VARIABLES] = FUNCTION [I];
    //  THE TOTAL COLS OF THE TRUTH TABLE WILL BE EQUAL TO THIS NUMBER.
    TOTAL_COLS = COUNT_VARIABLES - 1;
    return 0;
}
//  PRINT SUB-HEADINGS AND HEADINGS.
TRUTH_TABLE :: DRAW_HEADINGS ()
{
    //  WRITE THE FUNCTION TO THE OUT FILE.
    FILEPTR2 << FUNCTION << endl << endl;
    //  WRITE 'ROW' TO THE OUT FILE.
    FILEPTR2 << "  ROW  ";
    //  WRITE THE VARIABLES AT THE TOP OF THE TRUTH TABLE IN THE OUT
    //  FILE.
    for (int COL = 1; COL <= TOTAL_COLS; COL++)
    {
        FILEPTR2 << VARIABLES [COL] << "   ";
    }
    //  WRITE THE FUNCTION NAME AT THE TOP END OF THE TRUTH
    //  TABLE OF THE OUT FILE.
    FILEPTR2 << VARIABLES [0];
    //  SKIP A LINE IN THE OUT FILE.
    FILEPTR2 << endl;
    return 0;
}
//  DRAW TRUTH TABLE.
TRUTH_TABLE :: DRAW_TTABLE ()
{
    //  THIS VARIABLE COUNTS THE LINE BARS OF THE TRUTH TABLE.
    int LINE_COUNT;
    //  THIS VARIABLES COUNTS THE PAGES OF EACH TRUTH TABLE.
    int PAGE_COUNT;
    //  SET MAXIMUM NUMBER OF LINES TO 29.
    MAX_LINES = 27;
    //  THIS VARIABLE HOLDS THE TYPE OF TRUTH TABLE CHARACTER.
    //  EXAMPLE, 1 = 'Ú', 2 = '¿', ETC..
    int BOX_PART;
    //  GET FUNCTION FROM THE DATA FILE.
    GET_FUNCTION ();
    //  SKIP LINE IN OUT FILE.
    //  QUIT LOOP WHEN THERE IS AN END OF FILE MARKER.
    while (FILEPTR1.eof () != 1)
    {
        //  INITIALIZE PAGE COUNT TO 0.
        PAGE_COUNT = 0;
        //  TOTAL NUMBER OF ROWS + 1.
        TOTAL_ROWS = pow (2, TOTAL_COLS);
        //  IF THE TOTAL COLUMNS VALUE IS OUT OF RANGE (1 TO 10),
        //  DISPLAY ERROR MESSAGE AND QUIT.
        if ((TOTAL_COLS < 2) || (TOTAL_COLS > 10))
        {
            cout << "ERROR, ROWS IS NOT IN THE RANGE 2 TO 12." << endl;
            exit (0);
        }
        //  LINE COUNT INITIALIZES TO 0.
        LINE_COUNT = 0;
        //  PUT SUB-HEADING AND HEADING IN OUTFILE.
        DRAW_HEADINGS ();
        //  THE NEXT THREE FOR LOOPS WITH WRITE THE TRUTH TABLE
        //  TO THE OUT FILE.
        for (int ROW = 0; ROW <= (TOTAL_ROWS - 1); ROW++)
        {
            //  ADD ONE TO LINE COUNT.
            LINE_COUNT++;
            //  WRITE SOME BLANK SPACES TO OUT FILE SO THAT
            //  TRUTH TABLE DOES NOT START TOO CLOSE TO THE
            //  EDGE OF PAPER WHEN IT IS FINALLY PRINTED OUT.
            FILEPTR2 << "     ";
            //  WRITE THE START OR THE MIDDLE LINES OF THE
            //  TRUTH TABLE.
            for (int COL = 1; COL <= TOTAL_COLS + 1; COL++)
            {
                DRAW_EDGE_BOX (ROW, COL, LINE_COUNT);
            }
            //  SKIP LINE IN OUT FILE.
            FILEPTR2 << endl;
            //  WRITE THE MIDDLE PORTION OF THE TRUTH TABLE CELL.
            DRAW_MIDDLE_BOX (ROW, COL);
            //  SKIP LINE IN OUT FILE.
            FILEPTR2 << endl;
            //  IF LINE COUNT = 29 OR ROW = 2^ TOTAL_COLS THEN
            //  WRITE THE ENDING LINE OF THE TRUTH TABLE.
            if ((LINE_COUNT == MAX_LINES) || (ROW == (TOTAL_ROWS - 1)))
            {
                //  SKIP SOME SPACES IN OUT FILE.
                FILEPTR2 << "     ";
                //  WRITE ENDING LINE TO TRUTH TABLE.
                for (int COL = 1; COL <= TOTAL_COLS + 1; COL++)
                {
                    DRAW_EDGE_BOX (TOTAL_ROWS, COL, (LINE_COUNT + 1));
                }
                //  INCREMENT PAGE COUNT;
                PAGE_COUNT = PAGE_COUNT + 1;
                //  DRAW PAGE AT BOTTOM OF THE TRUTH TABLE.
                DRAW_PAGE (PAGE_COUNT, LINE_COUNT);
                //  PUT SUB-HEADINGS AND HEADINGS IN THE OUTFILE.
                if (LINE_COUNT == MAX_LINES)
                {
                    DRAW_HEADINGS ();
                }
                //  INITIALIZE LINE COUNT TO 0.
                LINE_COUNT = 0;
            }
        }
        //  GET NEXT FUNCTION FROM THE DATA FILE.
        GET_FUNCTION ();
    }
    return 0;
}
//  DRAW AN EDGE OF THE TRUTH TABLE.
TRUTH_TABLE :: DRAW_EDGE_BOX (int ROW, int COL, int LINE_COUNT)
{
    //  WRITE ONE OF 9 POSSIBLE LINES OF THE TRUTH TABLE ACCORDING
    //  TO ROW, COL, AND LINE COUNT.
    //  EXAMPLE, ROW = 0, LINE_COUNT = 1, COL = 1, THE IF
    //  STATEMENT WILL WRITE 'ÚÄÄÄ'
    if ((ROW == 0 || LINE_COUNT == 1) && COL == 1)
    {
        DRAW_BOXPART (1);
        DRAW_BOXPART (2);
        DRAW_BOXPART (2);
        DRAW_BOXPART (2);
    }
    else if ((ROW == 0 || LINE_COUNT == 1) && COL == TOTAL_COLS + 1)
    {
        DRAW_BOXPART (3);
        DRAW_BOXPART (2);
        DRAW_BOXPART (2);
        DRAW_BOXPART (2);
        DRAW_BOXPART (4);
    }
    else if ((ROW == 0 || LINE_COUNT == 1) && COL != 1 && COL != (TOTAL_COLS + 1))
    {
        DRAW_BOXPART (3);
        DRAW_BOXPART (2);
        DRAW_BOXPART (2);
        DRAW_BOXPART (2);
    }
    else if (ROW == TOTAL_ROWS  && COL == 1)
    {
        DRAW_BOXPART (8);
        DRAW_BOXPART (2);
        DRAW_BOXPART (2);
        DRAW_BOXPART (2);
    }
    else if (ROW == TOTAL_ROWS && COL == (TOTAL_COLS + 1))
    {
        DRAW_BOXPART (9);
        DRAW_BOXPART (2);
        DRAW_BOXPART (2);
        DRAW_BOXPART (2);
        DRAW_BOXPART (10);
    }
    else if (ROW == TOTAL_ROWS && COL != 1 && COL != (TOTAL_COLS + 1))
    {
        DRAW_BOXPART (9);
        DRAW_BOXPART (2);
        DRAW_BOXPART (2);
        DRAW_BOXPART (2);
    }
    else if (ROW != 0 && ROW != TOTAL_ROWS && COL == 1)
    {
        DRAW_BOXPART (5);
        DRAW_BOXPART (2);
        DRAW_BOXPART (2);
        DRAW_BOXPART (2);
    }
    else if (ROW != 0 && ROW != TOTAL_ROWS && COL == (TOTAL_COLS + 1))
    {
        DRAW_BOXPART (6);
        DRAW_BOXPART (2);
        DRAW_BOXPART (2);
        DRAW_BOXPART (2);
        DRAW_BOXPART (7);
    }
    else if (ROW != 0 && ROW != TOTAL_ROWS && COL != 1 && COL != (TOTAL_COLS + 1))
    {
        DRAW_BOXPART (6);
        DRAW_BOXPART (2);
        DRAW_BOXPART (2);
        DRAW_BOXPART (2);
    }
    return 0;
}
//  DRAW THE MIDDLE PART OF THE TRUTH TABLE.
TRUTH_TABLE :: DRAW_MIDDLE_BOX (int ROW, int COL)
{
    //  WRITES THE CURRENT ROW TO THE LEFT OF THE TRUTH TABLE BOX.
    DRAW_ROW (ROW);
    //  WRITES THE MIDDLE PART OF THE BOX
    //  EXAMPE, ROW = 0, COL = 0, WRITE '³ 0 ³ 0 ³' TO TRUTH TABLE.
    for (int LINES = 1; LINES <= COL; LINES++)
    {
        //  DRAW MIDDLE BOX PART.
        DRAW_BOXPART (11);
        //  FILL THE MIDDLE PART OF THE TRUTH TABLE WITH
        //  0, 1, OR A SPACE.
        for (int SPACES = 1; SPACES <= 3; SPACES++)
        {
            //  IF SPACE = 2, WRITE 0 OR 1 TO THE
            //  CURRENT CELL OF THE TRUTH TABLE.
            //  IF SPACE = 1 OR 3, WRITE A SPACE TO
            //  THE CURRENT CELL OF THE TRUTH TABLE.
            if ((SPACES == 2) && (LINES <= TOTAL_COLS))
            {
                DRAW_01 (ROW, LINES);
            }
            else if ((SPACES == 2) && (LINES == COL - 1))
            {
                DRAW_SUMS (ROW);
            }
            else
            {
                FILEPTR2 << " ";
            }
        }
    }
    return 0;
}
//  DRAW A BOX PART OF THE TRUTH TABLE.
TRUTH_TABLE :: DRAW_BOXPART (int BOX_PART)
{
    //  WRITES 1 OF 11 DIFFERENT BOX PARTS OF THE TRUTH TABLE.
    //  FOR EXAMPLE, WRITE 'Ú' OF TRUTH TABLE IF BOX_PART VALUE = 1.
    switch (BOX_PART)
    {
        case (1) : {
                       FILEPTR2 << "Ú";
                       break;
                   }
        case (2) : {
                       FILEPTR2 << "Ä";
                       break;
                   }
        case (3) : {
                       FILEPTR2 << "Â";
                       break;
                   }
        case (4) : {
                       FILEPTR2 << "¿";
                       break;
                   }
        case (5) : {
                       FILEPTR2 << "Ã";
                       break;
                   }
        case (6) : {
                       FILEPTR2 << "Å";
                       break;
                   }
        case (7) : {
                       FILEPTR2 << "´";
                       break;
                   }
        case (8) : {
                       FILEPTR2 << "À";
                       break;
                   }
        case (9) : {
                       FILEPTR2 << "Á";
                       break;
                   }
        case (10) : {
                        FILEPTR2 << "Ù";
                        break;
                    }
        case (11) : {
                        FILEPTR2 << "³";
                    }
    }
    return 0;
}
//  DRAW THE CURRENT ROW TO THE LEFT OF THE TRUTH TABLE.
TRUTH_TABLE :: DRAW_ROW (int ROW)
{
    //  KEEP THE ROWS PERFECTLY ALIGNED AND WRITE ROW TO LEFT OF
    //  TRUTH TABLE.
    FILEPTR2.setf (ios :: showpoint);
    FILEPTR2 << setw (4) << ROW << " ";
    return 0;
}
//  WRITE 1 OR 0 IN THE SUMS BOX (WHICH IS THE LAST COL OF BOXES).
TRUTH_TABLE :: DRAW_SUMS (int ROW)
{
    FILEPTR2 << SUMS [ROW];
    return 0;
}
//  DRAW CURRENT PAGE AT BOTTOM OF THE TRUTH TABLE.
TRUTH_TABLE :: DRAW_PAGE (int PAGE_COUNT, int LINE_COUNT)
{
    //  THIS IF STATEMENT MAKES SURE THAT THE PAGE NUMBER IS ON EVERY
    //  60TH LINE OF THE OUT FILE.
    if (MAX_LINES != LINE_COUNT)
    {
        for (int I = 1; I <= (2 * MAX_LINES - 2 * LINE_COUNT); I++)
        {
            FILEPTR2 << "\n";
        }
    }
    FILEPTR2 << "\n                                        PAGE ";
    FILEPTR2 << PAGE_COUNT << "\n\f\n";
    return 0;
}
//  DRAW 0 OR 1 TO INDIVIDUAL BOXES OF THE TRUTH TABLE.
TRUTH_TABLE :: DRAW_01 (int ROW, int COL)
{
    //  BITMASK FOR ROW VALUE.
    int BITMASK;
    BITMASK = pow (2, TOTAL_COLS - COL);
    //  AND THE ROW & BITMASK TOGETHER.  IF THEY ARE GREATER THAN OR EQUAL
    //  TO 1, WRITE A 1 TO THE TRUTH TABLE BOX.  IF THEY ARE LESS THAN
    //  1, WRITE A 0 TO THE TRUTH TABLE BOX.
    if ((ROW & BITMASK) >= 1)
    {
        FILEPTR2 << 1;
    }
    else
    {
        FILEPTR2 << 0;
    }
    return 0;
}
//  CLOSE DATA FILE AND OUT FILE.
TRUTH_TABLE :: CLOSE_FILES ()
{
    FILEPTR1.close ();
    FILEPTR2.close ();
    return 0;
}
//  FILENAME:  PROGRAM2.CPP     AUTHOR:  ANTHONY F. ORTIZ
//  THIS PROGRAM DRAWS A TRUTH TABLE USING A CLASS CALLED TRUTH_TABLE.
int main ()
{
    //  CLEAR THE SCREEN, OPEN THE DATA FILE AND OUT FILE, DRAW THE
    //  TRUTH TABLE, CLOSE THE DATA FILE AND OUT FILE, WRITE A
    //  QUICK MESSAGE TO THE SCREEN, AND QUIT THE PROGRAM.
    clrscr ();
    TRUTH_TABLE TT;
    TT.OPEN_FILES ();
    TT.DRAW_TTABLE ();
    TT.CLOSE_FILES ();
    cout << "TRUTH TABLE DONE." << endl;
    return 0;
}

//  DATA FILE:  TTABLE.DAT

    F(a,b)=ä(0,3)

//  OUTFILE:  TTABLE.OUT

F(a,b)=ä(0,3)

  ROW  a   b   F
     ÚÄÄÄÂÄÄÄÂÄÄÄ¿
   0 ³ 0 ³ 0 ³ 1 ³   
     ÃÄÄÄÅÄÄÄÅÄÄÄ´
   1 ³ 0 ³ 1 ³ 0 ³   
     ÃÄÄÄÅÄÄÄÅÄÄÄ´
   2 ³ 1 ³ 0 ³ 0 ³   
     ÃÄÄÄÅÄÄÄÅÄÄÄ´
   3 ³ 1 ³ 1 ³ 1 ³   
     ÀÄÄÄÁÄÄÄÁÄÄÄÙ














































                                        PAGE 1





BACK TO CS3430 PAGE.