2-мерные массивы: Вызов конструктора портит данные в других экземплярах

/* CPP */
#include <iostream.h>
#include <fstream.h>
#include <iomanip.h>
#include <stdlib.h>
#include "myprj.hpp"
 
#define MAXVAR 20
#define MAXCUBES 1048576
#define INPUTFILENAME "part1.txt"
 
// 3 @10 = 11 @2 this value 11 means dont care,  bDNT
// 1 @10 = 01 @2 this value 01 means X,          bTRU
// 2 @10 = 10 @2 this value 10 means X-BAR,      bBAR
 
 
nlNodeList Complement(nlNodeList arg_F);
 
int main(void)
{
// ================= Prerare to read data ========
    cout << "\n=================================================================\n";
    cout << "                                                 MinGW2.95 " << __STDC_VERSION__ << "\n";
 
    ifstream inputFile;
    inputFile.open(INPUTFILENAME);
    if (!inputFile) 
    {
        cout << "Error reading input file: " << INPUTFILENAME << "\n";
        return 1;
    }
    cout << "Reading input file: " << INPUTFILENAME << "\n";
    
// ================= INIT ========================= 
 
    short int iVar;                     // 1 to MAXVAR = 20
    long int  iCubeCountF;              // 1 to MAXCUBES = 2^20
    long int  iCubeCountG;
    long int j1, j2, j3 = 0;            // counters 
    long int tmp = 0;
    
    inputFile >> iVar;
    inputFile >> iCubeCountF;
    iCubeCountG = iCubeCountF;
    
    cout << iVar << " varaibles were used, " << iCubeCountF << " cubes are listed in the input file";
 
    int *p_CubeLenF = new int[iCubeCountF+1];           // cube lengthes of F, F is as comes from the input
    int *p_CubeLenG = new int[iCubeCountG+1];           // cube lengthes of G, G is decoded into 00, 01, 11 notations
    int **pp_CubeF;                                 // size: iCubeCountF by p_CubeLenF[]
    int **pp_CubeG;                                 // size: iCubeCountF by iVar, filled with 3@10=11@2 by default
    pp_CubeF = new int *[iCubeCountF+1];
    pp_CubeG = new int *[iCubeCountG+1];
 
    for (long int j1 = 1; j1 < iCubeCountF+1 ; j1++ )       // Read data from the input and fill F and G
    {
        inputFile >> p_CubeLenF[j1];
        p_CubeLenG[j1] = iVar;
        pp_CubeF[j1] = new int [ p_CubeLenF[j1]+1 ];
        pp_CubeG[j1] = new int [ iVar+1 ];
        for (int j2 = 1; j2 < p_CubeLenG[j1]+1 ; j2++ )
        {
            pp_CubeG[j1][j2] = bDNT;                                 // 3 @10 = 11 @2- value 11 means dont care, bDNT
        };      
        for (int j2 = 1; j2 < p_CubeLenF[j1]+1 ; j2++ )
        {
            inputFile >> pp_CubeF[j1][j2];
            if ( pp_CubeF[j1][j2] > 0 ) 
                {
                     pp_CubeG[j1][ abs ( pp_CubeF[j1][j2] ) ] = bTRU;   // 1 @10 = 01 @2- value 01 means X, bTRU
                }
            if ( pp_CubeF[j1][j2] < 0 ) 
                {
                     pp_CubeG[j1][ abs ( pp_CubeF[j1][j2] ) ] = bBAR;   // 2 @10 = 10 @2- value 10 means X-BAR, bBAR
                }
            if ( pp_CubeF[j1][j2] == 0 ) { ; };                         // pp_CubeF[j1][j2] can not be zero due to convention   
        };
        ;
    }
// ========== End of INIT. F and G ready =========================
 
    nlNodeList A = nlNodeList(iCubeCountG, iVar);
    
    for (long int j1 = 1; j1 < A.listLength+1 ; j1++ )
    {
        for (int j2 = 1; j2 < A.listWidth+1 ; j2++ )
        {
            A.nlWrite(j1, j2, pp_CubeG[j1][j2] );
        };      
    }
    
    A.nlDisplayPCN();
    cout << "\nThe PCN cubes of A are displayed above this line.\n" ;
    cout << "\n" ;
     
    nlNodeList B1 = nlNodeList(1,1);
    B1 = Complement(A);
    B1.nlDisplayPCN();
    cout << "\nThe B1 is above.\n" ;
    
 
 
    cin.get();
 
 
 
 
// ========== CLEAR ===========================
    for (long int j1 = 1; j1 < iCubeCountF+1 ; j1++ )
    {
        delete [] pp_CubeF[ p_CubeLenF[j1] ];
    } 
    for (int j1 = 1; j1 < iCubeCountG+1 ; j1++ )
    {
        delete [] pp_CubeG[ p_CubeLenG[j1] ];
    } 
    delete [] p_CubeLenF;
    delete [] pp_CubeF;
    delete [] p_CubeLenG;
    delete [] pp_CubeG;
    inputFile.close();
    return 0;
}
 
 
nlNodeList Complement(nlNodeList arg_F)
{
    // 1. Check if F is simple enough
    
    int ifFsimple = 0;
    nlNodeList resultNL = nlNodeList(1, arg_F.listWidth, bNULL);
    
    //      1.1. Check if there were a 11..11 line
        for (long int j1 = 1; j1 < arg_F.listLength+1 ; j1++ )
        {
            int tmp = 0;
            for (int j2 = 1; j2 < arg_F.listWidth+1 ; j2++ )
                {
                    tmp = tmp + abs( arg_F.nlRead(j1,j2) - bDNT ) ; // diff with "11"
                };
            
            if (tmp == 0) 
                {
                    ifFsimple = 1;
                    resultNL = nlNodeList(1, arg_F.listWidth, bNULL);
                            cout << "\n==Complement result if 111111 line\n";
                            resultNL.nlDisplayPCN();
                            cin.get();
                    return resultNL; // no need to examine others
                }
        };
 
    //      1.2. Check if Length is zero
        if ( arg_F.listLength == 0)
        {
            ifFsimple = 1;
            resultNL = nlNodeList(1, arg_F.listWidth, bDNT );
                cout << "\n==Complement result at Zero length\n";
                resultNL.nlDisplayPCN();
                cin.get();
            return resultNL;
        };
    
    //      1.3. Check if Length is one
        if ( arg_F.listLength == 1)
        {
            ifFsimple = 1;
            resultNL = ComplementSingleLine(arg_F);
                cout << "\n==Complement result at Singleline and its result ... \n";
                resultNL.nlDisplayPCN();
                cin.get();
            return resultNL;
        };
        
    // 2. Find most binate X
    
        int splitX = 0;
        splitX = PickUpSplitVar(arg_F);
    
    // 3. Recursive call
                        arg_F.nlDisplay();
    
        
        nlNodeList nlCofFXTRU = Cofactor(arg_F, splitX, bTRU);
        nlNodeList nlCofFXBAR = Cofactor(arg_F, splitX, bBAR);
        
        nlNodeList nlP = Complement(nlCofFXTRU);
        nlNodeList nlN = Complement(nlCofFXBAR);
        
        nlNodeList nlXTRU = ExpandXtoLine(splitX, arg_F.listWidth, bTRU);
        nlNodeList nlXBAR = ExpandXtoLine(splitX, arg_F.listWidth, bBAR);
        
    
    
    // 4. ( AND(x, P) ) OR ( AND(xbar, Pbar) )
    
        nlNodeList nlXP = ANDBlockAndLine(nlXTRU, nlP);
        nlNodeList nlXN = ANDBlockAndLine(nlXBAR, nlN);
        
        resultNL = ORAppendTwoBlocks(nlXP, nlXN);
                
    
    cout << "\n=Complement result\n";
    resultNL.nlDisplayPCN();
    cin.get();
    return resultNL;
 
}

/* H E A D E R */
 
#define bDNT 3
#define bTRU 1
#define bBAR 2
#define bNULL 0
 
/* The 2D arrays carry numbers 0, 1, 2, 3 (bNULL, bTRU, bBAR, bDNT) 
   which are interpreted as "00", "01", "10" and "11" */
 
#include <stdio.h>
 
#define SILENTDEBUGMODE 0
#define SILENTDEBUGMODE2 0
 
 
/* 
   =======================================================================================================================
   ===          NON CLASS MEMBERS                       ======================
   =======================================================================================================================
*/
 
int inttopcn(int arg_int)
{
    return 10*div(arg_int,2).quot+div(arg_int,2).rem; // switch from 0,1,2,3 notation to 00,01,10,11
};
 
int pcntoint(int arg_pcn)
{
    return 2*div(arg_pcn,10).quot+div(arg_pcn,10).rem; // switch from 00,01,10,11 notation to 0,1,2,3 
};
 
int pcnand(int arg_pcn1, int arg_pcn2) // just AND operation over 00,01,10,11 notations 
{
    int tmp2 = 0;
    int tmp = inttopcn(arg_pcn1) * 100 + inttopcn(arg_pcn2);
    switch (tmp){
        case         00: tmp2 = 00; break;
        
        case  01*100+01: tmp2 = 01; break;
        case  01*100+10: tmp2 = 00; break;
        case  01*100+11: tmp2 = 01; break;
        
        case  10*100+01: tmp2 = 00; break;
        case  10*100+10: tmp2 = 10; break;
        case  10*100+11: tmp2 = 10; break;
        
        case  11*100+01: tmp2 = 01; break;
        case  11*100+10: tmp2 = 10; break;
        case  11*100+11: tmp2 = 11; break;
        
        default:     tmp2 =  0; 
        };
    return pcntoint(tmp2);
};

/* 
   ===========================================
   ===          CLASS MEMBERS                           =======================
   ============================================
*/
 
class nlNodeList 
{
   public:
        long int listLength;
        short int listWidth;
        int **pp_C;
          nlNodeList(long int arg_nlLen, int arg_nlVar, int arg_nlDefault);
          ~nlNodeList(void);
          void nlWrite(long int arg_a, int arg_b, int arg_value);
          int nlRead(long int arg_a, int arg_b);
          void nlDisplay(void);
          void nlDisplayPCN(void);
};  
    
nlNodeList::nlNodeList(long int arg_nlLen, int arg_nlVar, int arg_nlDefault = bDNT) 
{   // nlNodeList class constructor. The 3rd param sets the elements to be 3 = "11" by default.
    listLength = arg_nlLen;
    listWidth = arg_nlVar;
    pp_C = new int *[arg_nlLen+1];
    for (long int jc1 = 1; jc1 < arg_nlLen+1 ; jc1++ )
        {
            pp_C[jc1] = new int [ arg_nlVar+1 ];
            for (int jc2 = 1; jc2 < arg_nlVar+1 ; jc2++ )
            {
                pp_C[jc1][jc2] = arg_nlDefault;             // bDNT = 3 = "11"
            };
        };
    return;
};
 
nlNodeList::~nlNodeList(void) 
{   // nlNodeList class destructor. Unallocates the memory.
    for (long int jc1 = 1; jc1 < listLength+1 ; jc1++ )
    {
        delete [] pp_C[ jc1 ];
    } 
    delete [] pp_C;
    return;
};
 
//---------------------------------------------------------------------------
 
void nlNodeList::nlWrite(long int arg_a, int arg_b, int arg_value)
{
    pp_C[arg_a][arg_b] = arg_value;
    return;
};
 
int nlNodeList::nlRead(long int arg_a, int arg_b)
{
    return pp_C[arg_a][arg_b];
};
 
void nlNodeList::nlDisplay(void)
{
    for (long int jc11 = 1; jc11 < listLength+1 ; jc11++ )
    {
        cout << "\n";
        for (int jc21 = 1; jc21 < listWidth+1 ; jc21++ )
        {
            cout << setw(1) << setfill( '0' ) << nlRead(jc11, jc21) << " " ;
        };      
    }
    return;
};
 
void nlNodeList::nlDisplayPCN(void)
{   // same as nlDisplay, but in 00, 01, 10, 11 notation
    for (long int jc11 = 1; jc11 < listLength+1 ; jc11++ )
    {
        cout << "\n";
        for (int jc21 = 1; jc21 < listWidth+1 ; jc21++ )
        {
            cout << setw(2) << setfill( '0' ) << inttopcn( nlRead(jc11, jc21) ) << " " ;
        };      
    }
    return;
};
 
/*  ========================================================
*/
 
 
nlNodeList CloneNodeList(nlNodeList arg_nlA) 
{
    if (SILENTDEBUGMODE == 0) 
    {
        cout << "\nCloneNodeList called...";
        cout << "\n  Original NL to be cloned\n";
        arg_nlA.nlDisplay();
        cout << "\n   (a) A(1,1) is " << arg_nlA.nlRead(1,1) << "\n";
    }
    long int tmp1, tmp2;
    
    tmp1 = arg_nlA.listLength; // a bit more complicated code to make sure where nlA had gotten spoilt
    tmp2 = arg_nlA.listWidth;
                cout << "(" << tmp1 << "," << tmp2 << ")";
                cout << "\n    (b) A(1,1) is  " << arg_nlA.nlRead(1,1) << "\n";
    
    nlNodeList nlC = nlNodeList( tmp1 , tmp2 );
                cout << "\n    (c) A(1,1) is " << arg_nlA.nlRead(1,1) << "\n"; // New constructor fflushes ARG-nlA values into bDNT = 3.
                arg_nlA.nlDisplay();
    for (long int j1 = 1; j1 < tmp1+1 ; j1++ )
    {
        for (int j2 = 1; j2 < tmp2+1 ; j2++ )
        {   
            nlC.nlWrite(j1,j2, arg_nlA.nlRead(j1,j2) );
        };
    };
    
    if (SILENTDEBUGMODE == 0) 
    {
        cout << "\nCloneNodeList returning...";
        cout << "\n  Output NL which was cloned\n";
        nlC.nlDisplay();
    }
    return nlC;
};
 
//------------------------------------------
 
nlNodeList StrikeOutFirstLine(nlNodeList arg_nlA)
{
    if (SILENTDEBUGMODE == 0) 
    {
        cout << "\nStrikeOutFirstLine called...";
        cout << "\n  Original NL to be StrikeOutFirstLined\n";
        arg_nlA.nlDisplay();
    }
    
    nlNodeList nlC = nlNodeList( arg_nlA.listLength - 1, arg_nlA.listWidth); // magic one
    for (long int j1 = 1; j1 < nlC.listLength+1 ; j1++ )
    {
        for (int j2 = 1; j2 < nlC.listWidth+1 ; j2++ )
        {
            nlC.nlWrite(j1,j2, arg_nlA.nlRead(j1+1,j2) ); // magic one
        };
    };
    if (SILENTDEBUGMODE == 0)   
    {
        cout << "\nStrikeOutFirstLine returning...";
        cout << "\n  Output NL which was StrikeOutFirstLined\n";
        nlC.nlDisplay();
    }
    return nlC;
};
 
//-------------------------------------------------------
 
 
nlNodeList ORAppendTwoBlocks(nlNodeList arg_nlA, nlNodeList arg_nlB)
{
    if (SILENTDEBUGMODE == 0) 
    {
        puts("\nORAppendTwoBlocks called...");
        cout << "\n  Original NLs to be ORAppendTwoBlocks\n";
        arg_nlA.nlDisplay();
        arg_nlB.nlDisplay();
    }
    
    if (arg_nlA.listWidth != arg_nlA.listWidth) 
    {
        cout << "\nORAppendTwoBlocks interrupts due to the size mismatch...";
        cin.get();
        exit(1);
        return nlNodeList(0,0);
        
    }
    
    nlNodeList nlC = nlNodeList( arg_nlA.listLength + arg_nlB.listLength , arg_nlA.listWidth);
    long int tmp;
    for (long int j1 = 1; j1 < arg_nlA.listLength+1 ; j1++ )
    {
        if ( arg_nlA.listLength == 0) continue; 
        for (int j2 = 1; j2 < arg_nlA.listWidth+1 ; j2++ )
        {
            nlC.nlWrite(j1,j2, arg_nlA.nlRead(j1,j2) );
        };
        tmp = j1;   
    };
    for (long int j1 = 1; j1 < arg_nlB.listLength+1 ; j1++ )
    {
        if ( arg_nlB.listLength == 0) continue;
        for (int j2 = 1; j2 < arg_nlB.listWidth+1 ; j2++ )
        {
            nlC.nlWrite(j1+tmp,j2, arg_nlB.nlRead(j1,j2) );
        };  
    };  
    if (SILENTDEBUGMODE == 0) 
    {
        puts("\nORAppendTwoBlocks returning...");
        cout << "\n  Output NL which was ORAppendTwoBlocked\n";
        nlC.nlDisplay();
    }
    return nlC;
};
 
//---------------------------------------------------------------
 
nlNodeList ANDTwoLines(nlNodeList arg_nlA, long int arg_indexA, nlNodeList arg_nlB, long int arg_indexB)
{
    if (SILENTDEBUGMODE == 0) 
    {
        puts("\nANDTwoLines called...");
        cout << "\n  Original NL1 to be ANDTwoLines, at " << arg_indexA << "\n";
        arg_nlA.nlDisplay();
        cout << "\n  Original NL2 to be ANDTwoLines, at " << arg_indexB << "\n";
        arg_nlB.nlDisplay();
    }
 
    int envirMaxVar = arg_nlA.listWidth;
    nlNodeList nlC = nlNodeList(1, envirMaxVar);
    for (int j1 = 1; j1 < envirMaxVar+1 ; j1++ )
    {
        nlC.nlWrite(1, j1, pcnand( arg_nlA.nlRead(arg_indexA, j1), arg_nlB.nlRead(arg_indexB, j1) ) );
    }
    if (SILENTDEBUGMODE == 0) 
    {
        puts("\nANDTwoLines returning...");
        cout << "\n  Output NL which was ANDTwoLines\n";
        nlC.nlDisplay();
    }
    return nlC;
};
 
//-----------------------------------------------------
 
nlNodeList ANDBlockAndLine(nlNodeList arg_nlA, nlNodeList arg_nlB)
{
    // FIRST arg_nlA must be a single line
    if (SILENTDEBUGMODE == 0) 
    {
        puts("\nANDBlockAndLine called...");
        cout << "\n  Original NL1 to be ANDBlockAndLine\n";
        arg_nlA.nlDisplay();
        cout << "\n  Original NL2 to be ANDBlockAndLine\n";
        arg_nlB.nlDisplay();
    }
    
    nlNodeList nlC = nlNodeList(0,0);
    if (arg_nlA.listLength != 1) 
    {
        cout << "\nANDBlockAndLine interrupts due to the size mismatch...";
        cout << "\nFirst argument to be a line and is ...";
        arg_nlA.nlDisplayPCN();
        cout << "\nSecond argument is ...";
        arg_nlB.nlDisplayPCN();
        
        cin.get();
        exit(1);
        return nlC;
    }
    
    int envirMaxVar = arg_nlB.listWidth;
    nlC = nlNodeList(1, envirMaxVar);
    for (long int j1 = 1; j1 < arg_nlB.listLength+1 ; j1++ )
    {
        for (int j2 = 1; j2 < arg_nlB.listWidth+1 ; j2++ )
        {
            nlC.nlWrite(j1,j2, pcnand( arg_nlB.nlRead(j1,j2) , arg_nlA.nlRead(1,j2) ) );
        };
    };
    if (SILENTDEBUGMODE == 0) 
    {
        puts("\nANDBlockAndLine returning...");
        cout << "\n  Output NL which was ANDBlockAndLined\n";
        nlC.nlDisplay();
    }
    return nlC;
};
 
//-------------------------------------------------
 
 
nlNodeList ExtractOneLine(nlNodeList arg_nlAexol, long int arg_indexA)
{
    if (SILENTDEBUGMODE == 0)
    {
        puts("\nExtractOneLine called...");
        cout << "\n  Original NL1 to be ExtractOneLined, at " << arg_indexA << "\n";
        arg_nlAexol.nlDisplay();
    }
    int envirMaxVar = arg_nlAexol.listWidth;
    nlNodeList nlC = nlNodeList(1, envirMaxVar);
    for (int j1 = 1; j1 < envirMaxVar+1 ; j1++ )
    {
        nlC.nlWrite(1, j1, arg_nlAexol.nlRead(arg_indexA, j1 ) );
    }
   cout << " Extracted line is -- ";
   nlC.nlDisplayPCN();
   
    if (SILENTDEBUGMODE == 0) 
    {
        puts("\nExtractOneLine returning...");
        cout << "\n  Output NL which was ExtractOneLined\n";
        nlC.nlDisplay();
    }
    return nlC;
};
 
//-------------------------------------------------------
 
nlNodeList ExpandXtoLine(int arg_indexX, int arg_envirMaxVar, int arg_bool)
{
    if (SILENTDEBUGMODE == 0) 
    {
        puts("\nExpandXtoLine called...");
        cout << "\n  Original index to be ExpandXtoLined, is " << arg_indexX << ", and TRU(1)/BAR(2) is " << arg_bool << "\n";
    }
    nlNodeList nlC = nlNodeList(1, arg_envirMaxVar, bDNT);
    nlC.nlWrite(1, arg_indexX, arg_bool );
    if (SILENTDEBUGMODE == 0) 
    {
        puts("\nExpandXtoLine returning...");
        cout << "\n  Output NL which was ExpandXtoLined\n";
        nlC.nlDisplay();
    }
    return nlC;
};
 
//-----------------------------------------------
 
nlNodeList KillZeroLines(nlNodeList arg_nlA)
{
    if (SILENTDEBUGMODE == 0) 
    {
        puts("\nKillZeroLines called...");
        cout << "\n  Original NL to be KillZeroLined\n";
        arg_nlA.nlDisplay();
    }
    int flag = 0;
    nlNodeList nlC = nlNodeList(1, arg_nlA.listWidth); // initiate with 1, so use StrikeOutFirstLine at last 
    for (long int j1 = 1; j1 < arg_nlA.listLength+1 ; j1++ )
    {
        flag = 1;
        for (int j2 = 1; j2 < arg_nlA.listWidth+1 ; j2++ )
        {
            if (arg_nlA.nlRead(j1,j2) == bNULL ) flag = flag*0;
        };
        
        if (flag != 0 )  nlC = ORAppendTwoBlocks(nlC, ExtractOneLine(arg_nlA, j1) );
    }
    
    nlNodeList nlD = StrikeOutFirstLine(nlC);
    nlC = CloneNodeList(nlD);
    if (SILENTDEBUGMODE == 0) 
    {
        puts("\nKillZeroLines returning...");
        cout << "\n  Output NL which was KillZeroLined\n";
        nlC.nlDisplay();
    }
    return nlC;
};
 
//-----------------------------------------------
 
nlNodeList Cofactor(nlNodeList arg_nlA, int arg_indexX, int arg_bool)
{
    if (SILENTDEBUGMODE == 0) 
    {
        puts("\nCofactor called...");
        cout << "\n  Original NL to be Cofactored wrt to " << arg_indexX << ", and TRU(1)/BAR(2) is " << arg_bool << "\n";
        arg_nlA.nlDisplay();
    }
    nlNodeList nlC = CloneNodeList(arg_nlA);
    for (long int j1 = 1; j1 < arg_nlA.listLength+1 ; j1++ )
    {
        if  ( arg_bool == bTRU ) 
            {
                if  ( arg_nlA.nlRead(j1, arg_indexX) == bBAR ) nlC.nlWrite(j1, arg_indexX, bNULL);
                if  ( arg_nlA.nlRead(j1, arg_indexX) == bTRU ) nlC.nlWrite(j1, arg_indexX, bDNT );
            }
        if  ( arg_bool == bBAR )
            {
                if  ( arg_nlA.nlRead(j1, arg_indexX) == bBAR ) nlC.nlWrite(j1, arg_indexX, bDNT );
                if  ( arg_nlA.nlRead(j1, arg_indexX) == bTRU ) nlC.nlWrite(j1, arg_indexX, bNULL);
            }       
    }
    
    nlNodeList nlD = KillZeroLines(nlC);
    nlC = CloneNodeList(nlD);
    if (SILENTDEBUGMODE == 0) 
    {
        puts("\nCofactor returning...");
        cout << "\n  Output NL which was Cofactored wrt to " << arg_indexX << ", and TRU(1)/BAR(2) is " << arg_bool << "\n";
        nlC.nlDisplay();
    }
    return nlC;
};
 
 
//---------------------------------------------------
 
nlNodeList ComplementSingleLine(nlNodeList arg_nlA)
{
    if (SILENTDEBUGMODE == 0)   
    {
        puts("\nComplementSingleLine called...");
        cout << "\n  Original NL to be ComplementSingleLined\n";
        arg_nlA.nlDisplay();
    }
    nlNodeList nlC = nlNodeList(1, arg_nlA.listWidth, bNULL);       // initiate with 1, so use StrikeOutFirstLine at last 
    
    if ( arg_nlA.listLength != 1 )
        {
            cout << " Complementing error. More than one cube found. ";
            cin.get();
            exit(1);
            return nlC;
        };
    
    // We have a line 11 10 01 11 ... 01
    // Here 11 is skipped, 10 turns to 01, 01 turns to 10.
    
    for (int j1 = 1; j1 < arg_nlA.listWidth+1  ; j1++)
        {
            //cout << "nlC is ";
            //nlC.nlDisplay();
            int tmp = 0;
            if ( arg_nlA.nlRead(1, j1) == bDNT ) continue;
            if ( arg_nlA.nlRead(1, j1) == bTRU ) { tmp = bBAR; };
            if ( arg_nlA.nlRead(1, j1) == bBAR ) { tmp = bTRU; };
            if ( arg_nlA.nlRead(1, j1) == bNULL) continue;
            
            nlNodeList nlB = ExpandXtoLine(j1, arg_nlA.listWidth, tmp );
            //cout << "nlB is ";
            //nlB.nlDisplay();
            nlNodeList nlD = ORAppendTwoBlocks(nlC, nlB);
            //cout << "nlD is ";
            //nlD.nlDisplay();
            nlC = CloneNodeList(nlD);
        };
    
    nlNodeList nlD = StrikeOutFirstLine(nlC);
    nlC = CloneNodeList(nlD);
    
    puts("\nComplementSingleLine returning ...\n");
    cout << "\nThis line is ... ";
    arg_nlA.nlDisplayPCN();
    cout << "\nThe result is ... ";
    nlC.nlDisplayPCN();
    cout << "\n ==Ok";
    
    if (SILENTDEBUGMODE == 0)   
    {
        puts("\nComplementSingleLine returning...");
        cout << "\n  Output NL which was ComplementSingleLined\n";
        nlC.nlDisplay();
    }
    //cin.get();
    return nlC;
};
 
//-------------------------------------------
 
int PickUpSplitVar(nlNodeList arg_nlA)
{
        /*
        Priority List to Be Done
        1) Binate
            *1.1) Most popular
             1.2) Min abs( bTRU - bBAR ) value
             1.3) The smallest index
        2) Unate
             2.1) Most popular
             2.2) The smallest index
    
        Now uses 1.1 and the largest index
        */
    if (SILENTDEBUGMODE == 0)
    {
        puts("\nPickUpSplitVar called...");
        cout << "\n  Original NL to be analysed for PickUpSplitVar\n";
        arg_nlA.nlDisplay();
    }
    long int tmp;
    int indexX;
    
    nlNodeList nlRankPopular = nlNodeList(1, arg_nlA.listWidth, bNULL); // to carry the ranks
    
 
    // 1.1 Find most popular
    
    for (int j2 = 1; j2 < arg_nlA.listWidth+1 ; j2++ )
    {
        tmp = 0;
        indexX = 0;
 
        for (long int j1 = 1; j1 < arg_nlA.listLength+1 ; j1++ )
        {
            if  ( (arg_nlA.nlRead(j1,j2) == bTRU ) || (arg_nlA.nlRead(j1,j2) == bBAR ) ) 
                {
                    tmp = tmp + 1 ;
                    nlRankPopular.nlWrite(1, j2, tmp);
                };
        }
    }
    
    for (int j2 = 1; j2 < arg_nlA.listWidth+1 ; j2++ )
    {
        if ( nlRankPopular.nlRead(1, j2) > tmp ) 
            {
                tmp = nlRankPopular.nlRead(1, j2);
                indexX = j2;
            }
    }
    
    // End of 1.1 Find most popular 
    
    if ( indexX == 0 ) indexX = 1;
 
 
    if (SILENTDEBUGMODE == 0)   
    {
        cout << "\nPickUpSplitVar returning with result - " << indexX << ", the ranks were found - ";
        nlRankPopular.nlDisplay();
        cout << "\n  For the matrix ";
        arg_nlA.nlDisplayPCN();
        cin.get();
    }
 
    return indexX;
 
}
 
//-------------------------------------

5
3
3 2 3 4
2 -1 5
3 1 -3 -4

class nlNodeList
{
public:
    int listLength;
    int listWidth;
 
    nlNodeList(int arg_nlLen, int arg_nlVar, int arg_nlDefault);
 
    nlNodeList(nlNodeList const & other);
    nlNodeList & operator=(nlNodeList const & other);
 
    ~nlNodeList(void);
    void nlWrite(int arg_a, int arg_b, int arg_value);
    int  nlRead(int arg_a, int arg_b);
    void nlDisplay(void);
    void nlDisplayPCN(void);
 
private:
    void swap(nlNodeList & other);
 
    int ** pp_C;
};
 
void nlNodeList::swap(nlNodeList & other)
{
    int ** pp = other.pp_C;
    other.pp_C = pp_C;
    pp_C = pp;
    int lLen = other.listLength;
    other.listLength = listLength;
    listLength = lLen;
    int lWid = other.listWidth;
    other.listWidth = listWidth;
    listWidth = lWid;
}
 
nlNodeList::nlNodeList(int arg_nlLen, int arg_nlVar, int arg_nlDefault = bDNT)
    : listLength(arg_nlLen), listWidth(arg_nlVar)
    , pp_C(new int *[arg_nlLen + 1])
{
    // nlNodeList class constructor. The 3rd param sets the elements to be 3 = "11" by default.
    for(int jc1 = 1; jc1 < listLength + 1; jc1++ )
    {
        pp_C[jc1] = new int [ listWidth + 1 ];
        for(int jc2 = 1; jc2 < listWidth + 1; jc2++ )
        {
            pp_C[jc1][jc2] = arg_nlDefault;             // bDNT = 3 = "11"
        }
    }
}
 
nlNodeList::nlNodeList(nlNodeList const & other)
    : listLength(other.listLength), listWidth(other.listWidth)
    , pp_C(new int *[listLength + 1])
{
    for(int jc1 = 1; jc1 < listLength + 1 ; jc1++ )
    {
        pp_C[jc1] = new int[listWidth + 1];
        for(int jc2 = 1; jc2 < listWidth + 1; jc2++ )
        {
            pp_C[jc1][jc2] = other.pp_C[jc1][jc2];              // bDNT = 3 = "11"
        }
    }
}
 
nlNodeList & nlNodeList::operator=(nlNodeList const & other)
{
    if(this != &other)
    {
        nlNodeList(other).swap(*this);
    }
    return *this;
}
 
nlNodeList::~nlNodeList(void)
{
    // nlNodeList class destructor. Unallocates the memory.
    for(int jc1 = 1; jc1 < listLength + 1 ; jc1++ )
    {
        delete [] pp_C[ jc1 ];
    }
    delete [] pp_C;
}