#include "exor.h"

Include dependency graph for exorList.c:

Classes
struct	que

Functions
int	GetDistance (Cube pC1, Cube pC2)
	EXTERNAL FUNCTIONS ///.

int	GetDistancePlus (Cube pC1, Cube pC2)

void	ExorVar (Cube *pC, int Var, varvalue Val)

void	AddToFreeCubes (Cube *pC)
	FREE CUBE LIST MANIPULATION FUNCTIONS ///.

Cube *	GetFreeCube ()

int	ExorLinkCubeIteratorStart (Cube *pGroup, Cube pC1, Cube *pC2, cubedist Dist)
	ExorLink Functions.

int	ExorLinkCubeIteratorNext (Cube **pGroup)

int	ExorLinkCubeIteratorPick (Cube **pGroup, int g)

void	ExorLinkCubeIteratorCleanUp (int fTakeLastGroup)

int	IterativelyApplyExorLink2 (char fDistEnable)
	FUNCTIONS OF THIS MODULE ///.

int	IterativelyApplyExorLink3 (char fDistEnable)

int	IterativelyApplyExorLink4 (char fDistEnable)

int	CheckForCloseCubes (Cube *p, int fAddCube)

int	CheckAndInsert (Cube *p)
	Iterative ExorLink Operation ///.

void	UndoRecentChanges ()

int	IteratorCubePairStart (cubedist Dist, Cube ppC1, Cube ppC2)

int	IteratorCubePairNext ()

int	AllocateCubeSets (int nVarsIn, int nVarsOut)
	CUBE SET MANIPULATION PROCEDURES ///.

void	DelocateCubeSets ()

void	CubeInsert (Cube *p)
	Insertion Operators ///.

Cube *	CubeExtract (Cube *p)

Cube *	IterCubeSetStart ()
	Cube Set Iterator ///.

Cube *	IterCubeSetNext ()

int	AllocateQueques (int nPlaces)

void	DelocateQueques ()

void	PrintQuequeStats ()

int	GetQuequeStats (cubedist Dist)

int	GetPosDiff (int PosBeg, int PosEnd)

Variables
ABC_NAMESPACE_IMPL_START cinfo	g_CoverInfo
	EXTERNAL VARIABLES ///.

unsigned char	BitCount []

int	s_nPosAlloc
	EXPORTED VARIABLES /// /////////////////////////////////////////////////////////////////////`.

int	s_nPosMax [3]

int	s_fDecreaseLiterals = 0

Cube *	s_q

int	s_Distance

int	s_DiffVarNum

int	s_DiffVarValueP_old

int	s_DiffVarValueP_new

int	s_DiffVarValueQ

Cube *	s_pCubeLast
	CUBE ITERATOR ///.

Function Documentation

◆ AddToFreeCubes()

void AddToFreeCubes ( Cube * pC )

extern

FREE CUBE LIST MANIPULATION FUNCTIONS ///.

Definition at line 157 of file exorCubes.c.

{
    assert( p );
    assert( p->Prev == NULL ); // the cube should not be in use
    assert( p->Next == NULL );
    assert( p->ID );
 
    p->Next = s_CubesFree;
    s_CubesFree = p;
 
    // set the ID of the cube to 0, 
    // so that cube pair garbage collection could recognize it as different
    p->ID = 0;
 
    g_CoverInfo.nCubesFree++;
}

Here is the caller graph for this function:

◆ AllocateCubeSets()

int AllocateCubeSets	(	int	nVarsIn,
		int	nVarsOut )

CUBE SET MANIPULATION PROCEDURES ///.

Memory Allocation/Delocation ///

Definition at line 792 of file exorList.c.

{
    s_List = NULL;
 
    // clean other data
    s_fDistEnable2 = 1;
    s_fDistEnable3 = 0;
    s_fDistEnable4 = 0;
    memset( s_CubeGroup, 0, sizeof(void *) * 5 );
    memset( s_fInserted, 0, sizeof(int) * 5 );
    s_fDecreaseLiterals = 0;
    s_cEnquequed = 0;
    s_cAttempts = 0;
    s_cReshapes = 0;
    s_nCubesBefore = 0;
    s_Gain = 0;
    s_GainTotal = 0;
    s_GroupCounter = 0;
    s_GroupBest = 0;
    s_pC1 = s_pC2 = NULL;
 
    return 4;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AllocateQueques()

int AllocateQueques ( int nPlaces )

Definition at line 1112 of file exorList.c.

{
    int i;
    s_nPosAlloc  = nPlaces;
 
    for ( i = 0; i < 3; i++ )
    {
        // clean data
        memset( &s_Que[i], 0, sizeof(que) );
 
        s_Que[i].pC1 = (Cube**) ABC_ALLOC( Cube*, nPlaces );
        s_Que[i].pC2 = (Cube**) ABC_ALLOC( Cube*, nPlaces );
        s_Que[i].ID1 = (byte*) ABC_ALLOC( byte, nPlaces );
        s_Que[i].ID2 = (byte*) ABC_ALLOC( byte, nPlaces );
 
        if ( s_Que[i].pC1==NULL || s_Que[i].pC2==NULL || s_Que[i].ID1==NULL || s_Que[i].ID2==NULL )
            return 0;
 
        s_nPosMax[i] = 0;
        s_Que[i].fEmpty = 1;
    }
 
    return nPlaces * (sizeof(Cube*) + sizeof(Cube*) + 2*sizeof(byte) );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CheckAndInsert()

int CheckAndInsert ( Cube * p )

Iterative ExorLink Operation ///.

Definition at line 270 of file exorList.c.

{
//  return CheckForCloseCubes( p, 1 );
    CubeInsert( p );
    return 0;
}

Here is the call graph for this function:

◆ CheckForCloseCubes()

int CheckForCloseCubes	(	Cube *	p,
		int	fAddCube )

Definition at line 643 of file exorList.c.

{
    // start the new range
    NewRangeReset();
 
    for ( s_q = s_List; s_q; s_q = s_q->Next )
    {
        s_Distance = GetDistancePlus( p, s_q );
        if ( s_Distance > 4 )
        {
        }
        else if ( s_Distance == 4 )
        {
            if ( s_fDistEnable4 ) 
                NewRangeInsertCubePair( DIST4, p, s_q );
        }
        else if ( s_Distance == 3 )
        {
            if ( s_fDistEnable3 ) 
                NewRangeInsertCubePair( DIST3, p, s_q );
        }
        else if ( s_Distance == 2 )
        { 
            if ( s_fDistEnable2 ) 
                NewRangeInsertCubePair( DIST2, p, s_q );
        }
        else if ( s_Distance == 1 )
        {   // extract the cube from the data structure
            // store the changes
            s_ChangeStore.fInput = (s_DiffVarNum != -1);
            s_ChangeStore.p      = p;
            s_ChangeStore.PrevQa = s_q->a;
            s_ChangeStore.PrevPa = p->a;
            s_ChangeStore.PrevQq = s_q->q;
            s_ChangeStore.PrevPq = p->q;
            s_ChangeStore.PrevPz = p->z;
            s_ChangeStore.Var    = s_DiffVarNum;
            s_ChangeStore.Value  = s_DiffVarValueQ;
            s_ChangeStore.PrevID = s_q->ID;
 
            CubeExtract( s_q );
            // perform the EXOR of the two cubes and write the result into p
 
            // it is important that the resultant cube is written into p!!!
 
            if ( s_DiffVarNum == -1 )
            {
                int i;
                // exor the output part
                p->z = 0;
                for ( i = 0; i < g_CoverInfo.nWordsOut; i++ )
                {
                    p->pCubeDataOut[i] ^= s_q->pCubeDataOut[i];
                    p->z += BIT_COUNT(p->pCubeDataOut[i]);
                }
            }
            else
            {
                // the cube has already been updated by GetDistancePlus()
 
                // modify the parameters of the number of literals in the new cube
//              p->a += s_UpdateLiterals[ s_DiffVarValueP ][ s_DiffVarValueQ ];
                if ( s_DiffVarValueP_old == VAR_NEG || s_DiffVarValueP_old == VAR_POS )
                    p->a--;
                if ( s_DiffVarValueP_new == VAR_NEG || s_DiffVarValueP_new == VAR_POS )
                    p->a++;
                p->q = ComputeQCostBits(p);
            }
 
            // move q to the free cube list
            AddToFreeCubes( s_q );
 
            // make sure that nobody with use the pairs created so far
//          NewRangeReset();
            // call the function again for the new cube
            return 1 + CheckForCloseCubes( p, 1 );
        }
        else // if ( Distance == 0 )
        {   // extract the second cube from the data structure and add them both to the free list
            AddToFreeCubes( p );
            AddToFreeCubes( CubeExtract( s_q ) );
 
            // make sure that nobody with use the pairs created so far
            NewRangeReset();
            return 2;
        }
    }
    
    // add the cube to the data structure if needed
    if ( fAddCube )
        CubeInsert( p );
 
    // add temporarily stored new range of cube pairs to the queque
    NewRangeAdd();
 
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CubeExtract()

Cube * CubeExtract ( Cube * p )

Definition at line 843 of file exorList.c.

{
//  assert( p->Prev && p->Next ); // can be done only with rings
    assert( p->ID );
 
//  if ( s_List == p )
//      s_List = p->Next;
//  if ( p->Prev )
//      p->Prev->Next = p->Next;
 
    if ( s_List == p )
        s_List = p->Next;
    else
        p->Prev->Next = p->Next;
 
    if ( p->Next )
        p->Next->Prev = p->Prev;
 
    p->Prev = NULL;
    p->Next = NULL;
 
    g_CoverInfo.nCubesInUse--;
    return p;
}

Here is the caller graph for this function:

◆ CubeInsert()

void CubeInsert ( Cube * p )

Insertion Operators ///.

Definition at line 824 of file exorList.c.

{
    assert( p->Prev == NULL && p->Next == NULL );
    assert( p->ID );
 
    if ( s_List == NULL )
        s_List = p;
    else
    {
        p->Next = s_List;
 
        s_List->Prev = p;
        s_List = p;
    }
 
    g_CoverInfo.nCubesInUse++;
}

Here is the caller graph for this function:

◆ DelocateCubeSets()

void DelocateCubeSets ( )

Definition at line 816 of file exorList.c.

817{

818}

Here is the caller graph for this function:

◆ DelocateQueques()

void DelocateQueques ( )

Definition at line 1139 of file exorList.c.

{
    int i;
    for ( i = 0; i < 3; i++ )
    {
        ABC_FREE( s_Que[i].pC1 );
        ABC_FREE( s_Que[i].pC2 );
        ABC_FREE( s_Que[i].ID1 );
        ABC_FREE( s_Que[i].ID2 );
    }
}

Here is the caller graph for this function:

◆ ExorLinkCubeIteratorCleanUp()

void ExorLinkCubeIteratorCleanUp ( int fTakeLastGroup )

extern

Definition at line 710 of file exorLink.c.

{
    int c;
    assert( fWorking );
 
    // put cubes back
    // set the cube pointers to zero
    if ( fTakeLastGroup == 0 )
        for ( c = 0; c < nCubesInGroup; c++ )
        {
            ELCubes[c]->fMark = 0;
            AddToFreeCubes( ELCubes[c] );
            ELCubes[c] = NULL;
        }
    else
        for ( c = 0; c < nCubesInGroup; c++ )
        if ( ELCubes[c] )
        {
            ELCubes[c]->fMark = 0;
            if ( (LastGroup & s_BitMasks[c]) == 0 ) // does not belong to the last group
                AddToFreeCubes( ELCubes[c] );
            ELCubes[c] = NULL;
        }
 
    // set the cube groups to zero
    VisitedGroups = 0;
    // shut down the iterator
    fWorking = 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ExorLinkCubeIteratorNext()

int ExorLinkCubeIteratorNext ( Cube ** pGroup )

extern

Definition at line 560 of file exorLink.c.

{
    int i, c;
 
    // check that everything is okey
    assert( fWorking );
 
    if ( nVisitedGroups == nGroups ) 
    // we have iterated through all groups
        return 0;
 
    // find the min/max cost group
    if ( fMinLitGroupsFirst[nDist] ) 
//  if ( nCubes == 4 ) 
    { // find the minimum cost
        // go through all groups
        GroupCostBest = LARGE_NUM;
        for ( i = 0; i < nGroups; i++ )
            if ( !(VisitedGroups & s_BitMasks[i]) && GroupCostBest > GroupCosts[i] )
            {
                GroupCostBest = GroupCosts[i];
                GroupCostBestNum = i;
            }
        assert( GroupCostBest != LARGE_NUM );
    }
    else 
    { // find the maximum cost
        // go through all groups
        GroupCostBest = -1;
        for ( i = 0; i < nGroups; i++ )
            if ( !(VisitedGroups & s_BitMasks[i]) && GroupCostBest < GroupCosts[i] )
            {
                GroupCostBest = GroupCosts[i];
                GroupCostBestNum = i;
            }
        assert( GroupCostBest != -1 );
    }
 
    // create the cubes needed for the group, if they are not created already
    LastGroup = 0;
    for ( c = 0; c < nCubes; c++ )
    {
        CubeNum = s_ELGroupRules[nDist][GroupCostBestNum][c];
        LastGroup |= s_BitMasks[CubeNum];
 
        if ( ELCubes[CubeNum] == NULL ) // this cube does not exist
        {
            // bring a cube from the free cube list
            ELCubes[CubeNum] = GetFreeCube();
 
            // copy the input bit data into the cube 
            for ( i = 0; i < g_CoverInfo.nWordsIn; i++ )
                ELCubes[CubeNum]->pCubeDataIn[i] = DammyBitData[i];
 
            // copy the output bit data into the cube
            NewZ = 0;
            if ( DiffVars[0] >= 0 ) // the output is not involved in ExorLink
            {
                for ( i = 0; i < g_CoverInfo.nWordsOut; i++ )
                    ELCubes[CubeNum]->pCubeDataOut[i] = pCA->pCubeDataOut[i];
                NewZ = pCA->z;
            }
            else // the output is involved
            { // determine where the output information comes from
                Value = s_ELCubeRules[nDist][CubeNum][nDiffVarsIn];
                if ( Value == vs0 )
                    for ( i = 0; i < g_CoverInfo.nWordsOut; i++ )
                    {
                        Temp = pCA->pCubeDataOut[i];
                        ELCubes[CubeNum]->pCubeDataOut[i] = Temp;
                        NewZ += BIT_COUNT(Temp);
                    }
                else if ( Value == vs1 )
                    for ( i = 0; i < g_CoverInfo.nWordsOut; i++ )
                    {
                        Temp = pCB->pCubeDataOut[i];
                        ELCubes[CubeNum]->pCubeDataOut[i] = Temp;
                        NewZ += BIT_COUNT(Temp);
                    }
                else if ( Value == vsX )
                    for ( i = 0; i < g_CoverInfo.nWordsOut; i++ )
                    {
                        Temp = pCA->pCubeDataOut[i] ^ pCB->pCubeDataOut[i];
                        ELCubes[CubeNum]->pCubeDataOut[i] = Temp;
                        NewZ += BIT_COUNT(Temp);
                    }
            }
 
            // set the variables that should be there
            for ( i = 0; i < nDiffVarsIn; i++ )
            {
                Value = DiffVarValues[i][ s_ELCubeRules[nDist][CubeNum][i] ];
                ELCubes[CubeNum]->pCubeDataIn[ DiffVarWords[i] ] |= ( Value << DiffVarBits[i] );
            }
 
            // set the number of literals and output ones
            ELCubes[CubeNum]->a = StartingLiterals + CubeLiterals[CubeNum];
            ELCubes[CubeNum]->z = NewZ;
            ELCubes[CubeNum]->q = ComputeQCostBits( ELCubes[CubeNum] );
            assert( NewZ != 255 );
 
            // assign the ID
            ELCubes[CubeNum]->ID = g_CoverInfo.cIDs++;
            // skip through zero-ID
            if ( g_CoverInfo.cIDs == 256 )
                g_CoverInfo.cIDs = 1;
 
        }
        // prepare the return array
        pGroup[c] = ELCubes[CubeNum];
    }
 
    // mark this group as visited 
    VisitedGroups |= s_BitMasks[ GroupCostBestNum ];
    // set the next visited group number and
    // increment the counter of visited groups
    GroupOrder[ nVisitedGroups++ ] = GroupCostBestNum;
    return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ExorLinkCubeIteratorPick()

int ExorLinkCubeIteratorPick	(	Cube **	pGroup,
		int	g )

extern

Definition at line 682 of file exorLink.c.

{
    int GroupNum, c;
 
    assert( fWorking );
    assert( g >= 0 && g < nGroups );
    assert( VisitedGroups & s_BitMasks[g] );
 
    GroupNum = GroupOrder[g];
    // form the group
    LastGroup = 0;
    for ( c = 0; c < nCubes; c++ )
    {
        CubeNum = s_ELGroupRules[nDist][GroupNum][c];
 
        // remember this group as the last one
        LastGroup |= s_BitMasks[CubeNum];
 
        assert( ELCubes[CubeNum] != NULL ); // this cube should exist
        // prepare the return array
        pGroup[c] = ELCubes[CubeNum];
    }
    return 1;
}

◆ ExorLinkCubeIteratorStart()

int ExorLinkCubeIteratorStart	(	Cube **	pGroup,
		Cube *	pC1,
		Cube *	pC2,
		cubedist	Dist )

extern

ExorLink Functions.

FUNCTION DEFINTIONS ///.

FUNCTIONS OF THIS MODULE ///

Definition at line 376 of file exorLink.c.

{
    int i, c;
 
    // check that everything is okey
    assert( pC1 != NULL );
    assert( pC2 != NULL );
    assert( !fWorking );
 
    nDist = Dist;
    nCubes = Dist + 2;
    nCubesInGroup = s_ELnCubes[nDist];
    nGroups = s_ELnGroups[Dist];
    pCA = pC1;
    pCB = pC2;
    // find what variables are different in these two cubes
    // FindDiffVars returns DiffVars[0] < 0, if the output is different
    nDifferentVars = FindDiffVars( DiffVars, pCA, pCB );
    if ( nCubes != nDifferentVars )
    {
//      cout << "ExorLinkCubeIterator(): Distance mismatch";
//      cout << " nCubes = " << nCubes << " nDiffVars = " << nDifferentVars << endl;
        fWorking = 0;
        return 0;
    }
 
    // copy the input variable cube data into DammyBitData[]
    for ( i = 0; i < g_CoverInfo.nWordsIn; i++ )
        DammyBitData[i] = pCA->pCubeDataIn[i];
 
    // find the number of different input variables
    nDiffVarsIn = ( DiffVars[0] >= 0 )? nCubes: nCubes-1;
    // assign the pointer to the place where the number of diff input vars is stored
    pDiffVars   = ( DiffVars[0] >= 0 )? DiffVars: DiffVars+1;
    // find the bit offsets and remove different variables
    for ( i = 0; i < nDiffVarsIn; i++ )
    {
        DiffVarWords[i] = ((2*pDiffVars[i]) >> LOGBPI) ;
        DiffVarBits[i]  = ((2*pDiffVars[i]) & BPIMASK);
        // clear this position
        DammyBitData[ DiffVarWords[i] ] &= ~( 3 << DiffVarBits[i] );
    }
 
    // extract the values from the cubes and create the mask of literals
    MaskLiterals = 0;
    // initialize the base for literal counts
    StartingLiterals = pCA->a;
    for ( i = 0, BitShift = 0; i < nDiffVarsIn; i++, BitShift++ )
    {
        DiffVarValues[i][0] = ( pCA->pCubeDataIn[DiffVarWords[i]] >> DiffVarBits[i] ) & 3;
        if ( DiffVarValues[i][0] != VAR_ABS )
        {
            MaskLiterals |= ( 1 << BitShift );
            // update the base for literal counts
            StartingLiterals--;
        }
        BitShift++;
 
        DiffVarValues[i][1] = ( pCB->pCubeDataIn[DiffVarWords[i]] >> DiffVarBits[i] ) & 3;
        if ( DiffVarValues[i][1] != VAR_ABS )
            MaskLiterals |= ( 1 << BitShift );
        BitShift++;
 
        DiffVarValues[i][2] = DiffVarValues[i][0] ^ DiffVarValues[i][1];
        if ( DiffVarValues[i][2] != VAR_ABS )
            MaskLiterals |= ( 1 << BitShift );
        BitShift++;
    }
 
    // count the number of additional literals in each cube of the group
    for ( i = 0; i < nCubesInGroup; i++ )
        CubeLiterals[i] = BitCount[ MaskLiterals & s_CubeLitMasks[Dist][i] ];
 
    // compute the costs of all groups
    for ( i = 0; i < nGroups; i++ )
        // go over all cubes in the group
        for ( GroupCosts[i] = 0, c = 0; c < nCubes; c++ )
            GroupCosts[i] += CubeLiterals[ s_ELGroupRules[Dist][i][c] ];
 
    // find the best cost group
    if ( fMinLitGroupsFirst[Dist] ) 
    { // find the minimum cost group
        GroupCostBest = LARGE_NUM;
        for ( i = 0; i < nGroups; i++ )
            if ( GroupCostBest > GroupCosts[i] )
            {
                GroupCostBest = GroupCosts[i];
                GroupCostBestNum = i;
            }
    }
    else 
    { // find the maximum cost group
        GroupCostBest = -1;
        for ( i = 0; i < nGroups; i++ )
            if ( GroupCostBest < GroupCosts[i] )
            {
                GroupCostBest = GroupCosts[i];
                GroupCostBestNum = i;
            }
    }
 
    // create the cubes with min number of literals needed for the group
    LastGroup = 0;
    for ( c = 0; c < nCubes; c++ )
    {
        CubeNum = s_ELGroupRules[Dist][GroupCostBestNum][c];
        LastGroup |= s_BitMasks[CubeNum];
 
        // bring a cube from the free cube list
        ELCubes[CubeNum] = GetFreeCube();
 
        // copy the input bit data into the cube 
        for ( i = 0; i < g_CoverInfo.nWordsIn; i++ )
            ELCubes[CubeNum]->pCubeDataIn[i] = DammyBitData[i];
 
        // copy the output bit data into the cube
        NewZ = 0;
        if ( DiffVars[0] >= 0 ) // the output is not involved in ExorLink
        {
            for ( i = 0; i < g_CoverInfo.nWordsOut; i++ )
                ELCubes[CubeNum]->pCubeDataOut[i] = pCA->pCubeDataOut[i];
            NewZ = pCA->z;
        }
        else // the output is involved
        { // determine where the output information comes from
            Value = s_ELCubeRules[Dist][CubeNum][nDiffVarsIn];
            if ( Value == vs0 )
                for ( i = 0; i < g_CoverInfo.nWordsOut; i++ )
                {
                    Temp = pCA->pCubeDataOut[i];
                    ELCubes[CubeNum]->pCubeDataOut[i] = Temp;
                    NewZ += BIT_COUNT(Temp);
                }
            else if ( Value == vs1 )
                for ( i = 0; i < g_CoverInfo.nWordsOut; i++ )
                {
                    Temp = pCB->pCubeDataOut[i];
                    ELCubes[CubeNum]->pCubeDataOut[i] = Temp;
                    NewZ += BIT_COUNT(Temp);
                }
            else if ( Value == vsX )
                for ( i = 0; i < g_CoverInfo.nWordsOut; i++ )
                {
                    Temp = pCA->pCubeDataOut[i] ^ pCB->pCubeDataOut[i];
                    ELCubes[CubeNum]->pCubeDataOut[i] = Temp;
                    NewZ += BIT_COUNT(Temp);
                }
        }
 
        // set the variables that should be there
        for ( i = 0; i < nDiffVarsIn; i++ )
        {
            Value = DiffVarValues[i][ s_ELCubeRules[Dist][CubeNum][i] ];
            ELCubes[CubeNum]->pCubeDataIn[ DiffVarWords[i] ] |= ( Value << DiffVarBits[i] );
        }
 
        // set the number of literals
        ELCubes[CubeNum]->a = StartingLiterals + CubeLiterals[CubeNum];
        ELCubes[CubeNum]->z = NewZ;
        ELCubes[CubeNum]->q = ComputeQCostBits( ELCubes[CubeNum] );
 
        // assign the ID
        ELCubes[CubeNum]->ID = g_CoverInfo.cIDs++;
        // skip through zero-ID
        if ( g_CoverInfo.cIDs == 256 )
            g_CoverInfo.cIDs = 1;
 
        // prepare the return array
        pGroup[c] = ELCubes[CubeNum];
    }
 
    // mark this group as visited 
    VisitedGroups |= s_BitMasks[ GroupCostBestNum ];
    // set the first visited group number
    GroupOrder[0] = GroupCostBestNum;
    // increment the counter of visited groups
    nVisitedGroups = 1;
    fWorking = 1;
    return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ExorVar()

void ExorVar	(	Cube *	pC,
		int	Var,
		varvalue	Val )

extern

Definition at line 197 of file exorBits.c.

{
    int Bit = (Var<<1);
    pC->pCubeDataIn[VarWord(Bit)] ^= ( Val << VarBit(Bit) );
}

Here is the caller graph for this function:

◆ GetDistance()

int GetDistance	(	Cube *	pC1,
		Cube *	pC2 )

extern

EXTERNAL FUNCTIONS ///.

Definition at line 214 of file exorBits.c.

{
    int i;
    DiffVarCounter = 0;
 
    for ( i = 0; i < g_CoverInfo.nWordsIn; i++ )
    {
        Temp1 = pC1->pCubeDataIn[i] ^ pC2->pCubeDataIn[i];
        Temp2 = (Temp1|(Temp1>>1)) & DIFFERENT;
 
        // count how many bits are one in this var difference
        DiffVarCounter  += BIT_COUNT(Temp2);
        if ( DiffVarCounter > 4 )
            return 5;
    }
    // check whether the output parts are different
    for ( i = 0; i < g_CoverInfo.nWordsOut; i++ )
        if ( pC1->pCubeDataOut[i] ^ pC2->pCubeDataOut[i] )
        {
            DiffVarCounter++;
            break;
        }
    return DiffVarCounter;
}

◆ GetDistancePlus()

int GetDistancePlus	(	Cube *	pC1,
		Cube *	pC2 )

extern

Definition at line 246 of file exorBits.c.

{
    int i;
 
    DiffVarCounter = 0;
    LastNonZeroWordNum = -1;
    for ( i = 0; i < g_CoverInfo.nWordsIn; i++ )
    {
        Temp1 = pC1->pCubeDataIn[i] ^ pC2->pCubeDataIn[i];
        Temp2 = (Temp1|(Temp1>>1)) & DIFFERENT;
 
        // save the value of var difference, in case 
        // the distance is one and we need to return the var number
        if ( Temp2 )
        {
            LastNonZeroWordNum = i;
            LastNonZeroWord = Temp2;
        }
 
        // count how many bits are one in this var difference
        DiffVarCounter  += BIT_COUNT(Temp2);
        if ( DiffVarCounter > 4 )
            return 5;
    }
    // check whether the output parts are different
    for ( i = 0; i < g_CoverInfo.nWordsOut; i++ )
        if ( pC1->pCubeDataOut[i] ^ pC2->pCubeDataOut[i] )
        {
            DiffVarCounter++;
            break;
        }
 
    if ( DiffVarCounter == 1 )
    {
        if ( LastNonZeroWordNum == -1 ) // the output is the only different variable
            s_DiffVarNum = -1;
        else
        {
            Temp = (LastNonZeroWord>>2);
            for ( i = 0; Temp; Temp>>=2, i++ );
            s_DiffVarNum = LastNonZeroWordNum*BPI/2 + i;
 
            // save the old var value
            s_DiffVarValueP_old = GetVar( pC1, s_DiffVarNum );
            s_DiffVarValueQ = GetVar( pC2, s_DiffVarNum );
 
            // EXOR this value with the corresponding value in p cube           
            ExorVar( pC1, s_DiffVarNum, (varvalue)s_DiffVarValueQ );
 
            s_DiffVarValueP_new = GetVar( pC1, s_DiffVarNum );
        }
    }
 
    return DiffVarCounter;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetFreeCube()

Cube * GetFreeCube ( )

extern

Definition at line 174 of file exorCubes.c.

{
    Cube * p;
    assert( s_CubesFree );
    p = s_CubesFree;
    s_CubesFree = s_CubesFree->Next;
    p->Next = NULL;
    g_CoverInfo.nCubesFree--;
    return p;
}

Here is the caller graph for this function:

◆ GetPosDiff()

int GetPosDiff	(	int	PosBeg,
		int	PosEnd )

Definition at line 928 of file exorList.c.

{
    return (PosEnd - PosBeg + s_nPosAlloc) % s_nPosAlloc;
}

Here is the caller graph for this function:

◆ GetQuequeStats()

int GetQuequeStats ( cubedist Dist )

Definition at line 998 of file exorList.c.

{
    return GetPosDiff( s_Que[Dist].PosOut, s_Que[Dist].PosIn );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IterativelyApplyExorLink2()

int IterativelyApplyExorLink2 ( char fDistEnable )

FUNCTIONS OF THIS MODULE ///.

Definition at line 277 of file exorList.c.

{
    int z;
 
    // this var is specific to ExorLink-2
    s_Dist = (cubedist)0;
 
    // enable pair accumulation
    s_fDistEnable2 = fDistEnable & 1;
    s_fDistEnable3 = fDistEnable & 2;
    s_fDistEnable4 = fDistEnable & 4;
 
    // initialize counters
    s_cEnquequed = GetQuequeStats( s_Dist );
    s_cAttempts  = 0;
    s_cReshapes  = 0;
 
    // remember the number of cubes before minimization
    s_nCubesBefore = g_CoverInfo.nCubesInUse;
 
    for ( z = IteratorCubePairStart( s_Dist, &s_pC1, &s_pC2 ); z; z = IteratorCubePairNext() )
    {
        s_cAttempts++;
        // start ExorLink of the given Distance
        if ( ExorLinkCubeIteratorStart( s_CubeGroup, s_pC1, s_pC2, s_Dist ) )
        {
            // extract old cubes from storage (to prevent EXORing with their derivitives)
            CubeExtract( s_pC1 );
            CubeExtract( s_pC2 );
 
            // mark the current position in the cube pair queques
            MarkSet();
 
            // check the first group (generated by ExorLinkCubeIteratorStart())
            if ( CheckForCloseCubes( s_CubeGroup[0], 0 ) ) 
            {  // the first cube leads to improvement - it is already inserted
                CheckForCloseCubes( s_CubeGroup[1], 1 ); // insert the second cube
                goto SUCCESS;
            }
            if ( CheckForCloseCubes( s_CubeGroup[1], 0 ) ) 
            {  // the second cube leads to improvement - it is already inserted
                CheckForCloseCubes( s_CubeGroup[0], 1 ); // insert the first cube
//              CheckAndInsert( s_CubeGroup[0] );
                goto SUCCESS;
            }
            // the first group does not lead to improvement
 
            // rewind to the previously marked position in the cube pair queques
            MarkRewind();
 
            // generate the second group
            ExorLinkCubeIteratorNext( s_CubeGroup );
 
            // check the second group
            if ( CheckForCloseCubes( s_CubeGroup[0], 0 ) ) 
            { // the first cube leads to improvement - it is already inserted
                CheckForCloseCubes( s_CubeGroup[1], 1 ); // insert the second cube
                goto SUCCESS;
            }
            if ( CheckForCloseCubes( s_CubeGroup[1], 0 ) ) 
            { // the second cube leads to improvement - it is already inserted
                CheckForCloseCubes( s_CubeGroup[0], 1 ); // insert the first cube
//              CheckAndInsert( s_CubeGroup[0] );
                goto SUCCESS;
            }
            // the second group does not lead to improvement
 
            // decide whether to accept the second group, depending on literals
            if ( s_fDecreaseLiterals )
            {
                if ( g_CoverInfo.fUseQCost ? 
                     s_CubeGroup[0]->q + s_CubeGroup[1]->q >= s_pC1->q + s_pC2->q :
                     s_CubeGroup[0]->a + s_CubeGroup[1]->a >= s_pC1->a + s_pC2->a ) 
                // the group increases literals
                { // do not take the last group
                            
                    // rewind to the previously marked position in the cube pair queques
                    MarkRewind();
 
                    // return the old cubes back to storage
                    CubeInsert( s_pC1 );
                    CubeInsert( s_pC2 );
                    // clean the results of generating ExorLinked cubes
                    ExorLinkCubeIteratorCleanUp( 0 );
                    continue;
                }
            }
 
            // take the last group
            // there is no need to test these cubes again,
            // because they have been tested and did not yield any improvement
            CubeInsert( s_CubeGroup[0] );
            CubeInsert( s_CubeGroup[1] );
//          CheckForCloseCubes( s_CubeGroup[0], 1 ); 
//          CheckForCloseCubes( s_CubeGroup[1], 1 ); 
 
SUCCESS:
            // clean the results of generating ExorLinked cubes
            ExorLinkCubeIteratorCleanUp( 1 ); // take the last group
            // free old cubes
            AddToFreeCubes( s_pC1 );
            AddToFreeCubes( s_pC2 );
            // increate the counter
            s_cReshapes++;
        }
    }
    // print the report
    if ( g_CoverInfo.Verbosity == 2 )
    {
    printf( "ExLink-%d", 2 );
    printf( ": Que= %5d", s_cEnquequed );
    printf( "  Att= %4d", s_cAttempts );
    printf( "  Resh= %4d", s_cReshapes );
    printf( "  NoResh= %4d", s_cAttempts - s_cReshapes );
    printf( "  Cubes= %3d", g_CoverInfo.nCubesInUse );
    printf( "  (%d)", s_nCubesBefore - g_CoverInfo.nCubesInUse );
    printf( "  Lits= %5d", CountLiterals() );
    printf( "  QCost = %6d", CountQCost() );
    printf( "\n" );
    }
 
    // return the number of cubes gained in the process
    return s_nCubesBefore - g_CoverInfo.nCubesInUse;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IterativelyApplyExorLink3()

int IterativelyApplyExorLink3 ( char fDistEnable )

Definition at line 405 of file exorList.c.

{
    int z, c, d;
    // this var is specific to ExorLink-3
    s_Dist = (cubedist)1;
 
    // enable pair accumulation
    s_fDistEnable2 = fDistEnable & 1;
    s_fDistEnable3 = fDistEnable & 2;
    s_fDistEnable4 = fDistEnable & 4;
 
    // initialize counters
    s_cEnquequed = GetQuequeStats( s_Dist );
    s_cAttempts  = 0;
    s_cReshapes  = 0;
 
    // remember the number of cubes before minimization
    s_nCubesBefore = g_CoverInfo.nCubesInUse;
 
    for ( z = IteratorCubePairStart( s_Dist, &s_pC1, &s_pC2 ); z; z = IteratorCubePairNext() )
    {
        s_cAttempts++;
        // start ExorLink of the given Distance
        if ( ExorLinkCubeIteratorStart( s_CubeGroup, s_pC1, s_pC2, s_Dist ) )
        {
            // extract old cubes from storage (to prevent EXORing with their derivitives)
            CubeExtract( s_pC1 );
            CubeExtract( s_pC2 );
 
            // mark the current position in the cube pair queques
            MarkSet();
 
            // check cube groups one by one
            s_GroupCounter = 0;
            do  
            {   // check the cubes of this group one by one
                for ( c = 0; c < 3; c++ )
                if ( !s_CubeGroup[c]->fMark ) // this cube has not yet been checked
                {
                    s_Gain = CheckForCloseCubes( s_CubeGroup[c], 0 ); // do not insert the cube, by default
                    if ( s_Gain ) 
                    { // this cube leads to improvement or reshaping - it is already inserted
 
                        // decide whether to accept this group based on literal count
                        if ( s_fDecreaseLiterals && s_Gain == 1 )
                        if ( g_CoverInfo.fUseQCost ?
                             s_CubeGroup[0]->q + s_CubeGroup[1]->q + s_CubeGroup[2]->q > s_pC1->q + s_pC2->q + s_ChangeStore.PrevQq :
                             s_CubeGroup[0]->a + s_CubeGroup[1]->a + s_CubeGroup[2]->a > s_pC1->a + s_pC2->a + s_ChangeStore.PrevQa 
                           ) // the group increases literals
                        { // do not take this group
                            // remember the group
                            s_GroupBest = s_GroupCounter;
                            // undo changes to be able to continue checking other groups
                            UndoRecentChanges();
                            break;
                        }
 
                        // take this group
                        for ( d = 0; d < 3; d++ ) // insert other cubes
                            if ( d != c )
                            {
                                CheckForCloseCubes( s_CubeGroup[d], 1 ); 
//                              if ( s_CubeGroup[d]->fMark )
//                                  CheckAndInsert( s_CubeGroup[d] );
//                                  CheckOnlyOneCube( s_CubeGroup[d] );
//                                  CheckForCloseCubes( s_CubeGroup[d], 1 ); 
//                              else
//                                  CheckForCloseCubes( s_CubeGroup[d], 1 ); 
                            }
 
                        // clean the results of generating ExorLinked cubes
                        ExorLinkCubeIteratorCleanUp( 1 ); // take the last group
                        // free old cubes
                        AddToFreeCubes( s_pC1 );
                        AddToFreeCubes( s_pC2 );
                        // update the counter
                        s_cReshapes++;
                        goto END_OF_LOOP;
                    }
                    else // mark the cube as checked
                        s_CubeGroup[c]->fMark = 1;
                }
                // the group is not taken - find the new group
                s_GroupCounter++;
                                        
                // rewind to the previously marked position in the cube pair queques
                MarkRewind();
            } 
            while ( ExorLinkCubeIteratorNext( s_CubeGroup ) );
            // none of the groups leads to improvement
 
            // return the old cubes back to storage
            CubeInsert( s_pC1 );
            CubeInsert( s_pC2 );
            // clean the results of generating ExorLinked cubes
            ExorLinkCubeIteratorCleanUp( 0 );
        }
END_OF_LOOP: {}
    }
 
    // print the report
    if ( g_CoverInfo.Verbosity == 2 )
    {
    printf( "ExLink-%d", 3 );
    printf( ": Que= %5d", s_cEnquequed );
    printf( "  Att= %4d", s_cAttempts );
    printf( "  Resh= %4d", s_cReshapes );
    printf( "  NoResh= %4d", s_cAttempts - s_cReshapes );
    printf( "  Cubes= %3d", g_CoverInfo.nCubesInUse );
    printf( "  (%d)", s_nCubesBefore - g_CoverInfo.nCubesInUse );
    printf( "  Lits= %5d", CountLiterals() );
    printf( "  QCost = %6d", CountQCost() );
    printf( "\n" );
    }
 
    // return the number of cubes gained in the process
    return s_nCubesBefore - g_CoverInfo.nCubesInUse;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IterativelyApplyExorLink4()

int IterativelyApplyExorLink4 ( char fDistEnable )

Definition at line 524 of file exorList.c.

{
    int z, c;
    // this var is specific to ExorLink-4
    s_Dist = (cubedist)2;
 
    // enable pair accumulation
    s_fDistEnable2 = fDistEnable & 1;
    s_fDistEnable3 = fDistEnable & 2;
    s_fDistEnable4 = fDistEnable & 4;
 
    // initialize counters
    s_cEnquequed = GetQuequeStats( s_Dist );
    s_cAttempts  = 0;
    s_cReshapes  = 0;
 
    // remember the number of cubes before minimization
    s_nCubesBefore = g_CoverInfo.nCubesInUse;
 
    for ( z = IteratorCubePairStart( s_Dist, &s_pC1, &s_pC2 ); z; z = IteratorCubePairNext() )
    {
        s_cAttempts++;
        // start ExorLink of the given Distance
        if ( ExorLinkCubeIteratorStart( s_CubeGroup, s_pC1, s_pC2, s_Dist ) )
        {
            // extract old cubes from storage (to prevent EXORing with their derivitives)
            CubeExtract( s_pC1 );
            CubeExtract( s_pC2 );
 
            // mark the current position in the cube pair queques
            MarkSet();
 
            // check cube groups one by one
            do  
            {   // check the cubes of this group one by one
                s_GainTotal = 0;
                for ( c = 0; c < 4; c++ )
                if ( !s_CubeGroup[c]->fMark ) // this cube has not yet been checked
                {
                    s_Gain = CheckForCloseCubes( s_CubeGroup[c], 0 ); // do not insert the cube, by default
                    // if the cube leads to gain, it is already inserted
                    s_fInserted[c] = (int)(s_Gain>0);
                    // increment the total gain
                    s_GainTotal += s_Gain;
                }
                else
                    s_fInserted[c] = 0; // the cube has already been checked - it is not inserted
 
                if ( s_GainTotal == 0 ) // the group does not lead to any gain
                { // mark the cubes
                    for ( c = 0; c < 4; c++ )
                        s_CubeGroup[c]->fMark = 1;
                }
                else if ( s_GainTotal == 1 ) // the group does not lead to substantial gain, too
                { 
                    // undo changes to be able to continue checking groups
                    UndoRecentChanges();
                    // mark those cubes that were not inserted
                    for ( c = 0; c < 4; c++ )
                        s_CubeGroup[c]->fMark = !s_fInserted[c];
                }
                else // if ( s_GainTotal > 1 ) // the group reshapes or improves
                { // accept the group
                    for ( c = 0; c < 4; c++ ) // insert other cubes
                        if ( !s_fInserted[c] )
                            CheckForCloseCubes( s_CubeGroup[c], 1 ); 
//                          CheckAndInsert( s_CubeGroup[c] );
                    // clean the results of generating ExorLinked cubes
                    ExorLinkCubeIteratorCleanUp( 1 ); // take the last group
                    // free old cubes
                    AddToFreeCubes( s_pC1 );
                    AddToFreeCubes( s_pC2 );
                    // update the counter
                    s_cReshapes++;
                    goto END_OF_LOOP;
                }
                                        
                // rewind to the previously marked position in the cube pair queques
                MarkRewind();
            } 
            while ( ExorLinkCubeIteratorNext( s_CubeGroup ) );
            // none of the groups leads to improvement
 
            // return the old cubes back to storage
            CubeInsert( s_pC1 );
            CubeInsert( s_pC2 );
            // clean the results of generating ExorLinked cubes
            ExorLinkCubeIteratorCleanUp( 0 );
        }
END_OF_LOOP: {}
    }
 
    // print the report
    if ( g_CoverInfo.Verbosity == 2 )
    {
    printf( "ExLink-%d", 4 );
    printf( ": Que= %5d", s_cEnquequed );
    printf( "  Att= %4d", s_cAttempts );
    printf( "  Resh= %4d", s_cReshapes );
    printf( "  NoResh= %4d", s_cAttempts - s_cReshapes );
    printf( "  Cubes= %3d", g_CoverInfo.nCubesInUse );
    printf( "  (%d)", s_nCubesBefore - g_CoverInfo.nCubesInUse );
    printf( "  Lits= %5d", CountLiterals() );
    printf( "  QCost = %6d", CountQCost() );
    printf( "\n" );
    }
 
    // return the number of cubes gained in the process
    return s_nCubesBefore - g_CoverInfo.nCubesInUse;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IteratorCubePairNext()

int IteratorCubePairNext ( )

Definition at line 1073 of file exorList.c.

{
    int fEntryFound = 0;
    assert( s_Iter.fStarted );
 
    // go through the entries while there is something in the queque
    for ( pQ = &s_Que[ s_Iter.Dist ]; pQ->PosOut != s_Iter.PosStop; pQ->PosOut = (pQ->PosOut+1)%s_nPosAlloc )
    {
        p1 = pQ->pC1[ pQ->PosOut ];
        p2 = pQ->pC2[ pQ->PosOut ];
 
        // check whether the entry is valid
        if ( p1->ID == pQ->ID1[ pQ->PosOut ] && 
             p2->ID == pQ->ID2[ pQ->PosOut ] ) //&&
             //p1->x + p1->y + p2->x + p2->y > s_Iter.CutValue )
        {
             fEntryFound = 1;
             break;
        }
    }
 
    if ( fEntryFound )
    { // write the result into the pick-up place
        *(s_Iter.ppC1) = pQ->pC1[ pQ->PosOut ];
        *(s_Iter.ppC2) = pQ->pC2[ pQ->PosOut ];
 
        pQ->PosOut = (pQ->PosOut+1)%s_nPosAlloc;
    }
    else // iteration has finished
        s_Iter.fStarted = 0;
 
    return fEntryFound;
}

Here is the caller graph for this function:

◆ IteratorCubePairStart()

int IteratorCubePairStart	(	cubedist	Dist,
		Cube **	ppC1,
		Cube **	ppC2 )

Definition at line 1023 of file exorList.c.

{
    int fEntryFound;
 
    assert( s_Iter.fStarted == 0 );
    assert( CubeDist >= 0 && CubeDist <= 2 );
 
    s_Iter.fStarted = 1;
    s_Iter.Dist = CubeDist;
    s_Iter.ppC1 = ppC1;
    s_Iter.ppC2 = ppC2;
 
    s_Iter.PosStop = s_Que[ CubeDist ].PosIn;
 
    // determine the cut value
//  s_Iter.CutValue = s_nLiteralsInUse/s_nCubesInUse/2;
    s_Iter.CutValue = -1;
 
    fEntryFound = 0;
    // go through the entries while there is something in the queque
    for ( pQ = &s_Que[ CubeDist ]; pQ->PosOut != s_Iter.PosStop; pQ->PosOut = (pQ->PosOut+1)%s_nPosAlloc )
    {
        p1 = pQ->pC1[ pQ->PosOut ];
        p2 = pQ->pC2[ pQ->PosOut ];
 
        // check whether the entry is valid
        if ( p1->ID == pQ->ID1[ pQ->PosOut ] && 
             p2->ID == pQ->ID2[ pQ->PosOut ] ) //&&
             //p1->x + p1->y + p2->x + p2->y > s_Iter.CutValue )
        {
             fEntryFound = 1;
             break;
        }
    }
 
    if ( fEntryFound )
    { // write the result into the pick-up place
        *ppC1 = pQ->pC1[ pQ->PosOut ];
        *ppC2 = pQ->pC2[ pQ->PosOut ];
 
        pQ->PosOut = (pQ->PosOut+1)%s_nPosAlloc;
    }
    else
        s_Iter.fStarted = 0;
    return fEntryFound;
}

Here is the caller graph for this function:

◆ IterCubeSetNext()

Cube * IterCubeSetNext ( )

Definition at line 892 of file exorList.c.

{
    assert( s_pCubeLast );
    return ( s_pCubeLast = s_pCubeLast->Next );
}

Here is the caller graph for this function:

◆ IterCubeSetStart()

Cube * IterCubeSetStart ( )

Cube Set Iterator ///.

EXTERNAL FUNCTIONS ///.

Definition at line 880 of file exorList.c.

{
    assert( s_pCubeLast == NULL );
 
    // check whether the List has cubes
    if ( s_List == NULL )
        return NULL;
 
    return ( s_pCubeLast = s_List );
}

Here is the caller graph for this function:

◆ PrintQuequeStats()

void PrintQuequeStats ( )

Definition at line 985 of file exorList.c.

{
/*
    cout << endl << "Queque statistics: ";
    cout << " Alloc = " << s_nPosAlloc;
    cout << "   DIST2 = " << GetPosDiff( s_Que[0].PosOut, s_Que[0].PosIn );
    cout << "   DIST3 = " << GetPosDiff( s_Que[1].PosOut, s_Que[1].PosIn );
    cout << "   DIST4 = " << GetPosDiff( s_Que[2].PosOut, s_Que[2].PosIn );
    cout << endl;
    cout << endl;
*/
}

◆ UndoRecentChanges()

void UndoRecentChanges ( )

Definition at line 750 of file exorList.c.

{
    Cube * p, * q;
    // get back cube q that was deleted
    q = GetFreeCube();
    // restore the ID
    q->ID = s_ChangeStore.PrevID;
    // insert the cube into storage again
    CubeInsert( q );
 
    // extract cube p
    p = CubeExtract( s_ChangeStore.p );
 
    // modify it back
    if ( s_ChangeStore.fInput ) // the input has changed
    {
        ExorVar( p, s_ChangeStore.Var, (varvalue)s_ChangeStore.Value );
        p->a = s_ChangeStore.PrevPa;
        p->q = s_ChangeStore.PrevPq;
        // p->z did not change
    }
    else // if ( s_ChangeStore.fInput ) // the output has changed
    {
        int i;
        for ( i = 0; i < g_CoverInfo.nWordsOut; i++ )
            p->pCubeDataOut[i] ^= q->pCubeDataOut[i];
        p->z = s_ChangeStore.PrevPz;
        // p->a did not change
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

◆ BitCount

unsigned char BitCount[]

extern

Definition at line 138 of file exorBits.c.

◆ CutValue

int CutValue

Definition at line 1017 of file exorList.c.

◆ Dist

cubedist Dist

Definition at line 1012 of file exorList.c.

◆ fInput

int fInput

Definition at line 221 of file exorList.c.

◆ fStarted

int fStarted

Definition at line 1011 of file exorList.c.

◆ g_CoverInfo

ABC_NAMESPACE_IMPL_START cinfo g_CoverInfo

extern

EXTERNAL VARIABLES ///.

CFile****************************************************************

FileName [exorList.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Exclusive sum-of-product minimization.]

Synopsis [Cube lists.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - June 20, 2005.]

Revision [

Id: exorList.c,v 1.0 2005/06/20 00:00:00 alanmi Exp

]

                                                            ///
            Implementation of EXORCISM - 4                  ///
        An Exclusive Sum-of-Product Minimizer               ///
                                                            ///
         Alan Mishchenko  <alanmi@ee.pdx.edu>               ///
                                                            ///

                                                            ///
           Iterative Cube Set Minimization                  ///
            Iterative ExorLink Procedure                    ///
            Support of Cube Pair Queques                    ///
                                                            ///

Ver. 1.0. Started - July 18, 2000. Last update - July 20, 2000 /// Ver. 1.1. Started - July 24, 2000. Last update - July 29, 2000 /// Ver. 1.2. Started - July 30, 2000. Last update - July 31, 2000 /// Ver. 1.4. Started - Aug 10, 2000. Last update - Aug 26, 2000 /// Ver. 1.5. Started - Aug 30, 2000. Last update - Aug 30, 2000 /// Ver. 1.6. Started - Sep 11, 2000. Last update - Sep 15, 2000 /// Ver. 1.7. Started - Sep 20, 2000. Last update - Sep 23, 2000 /// ///

This software was tested with the BDD package "CUDD", v.2.3.0 /// by Fabio Somenzi /// http://vlsi.colorado.edu/~fabio/ ///

EXTERNAL VARIABLES ///.

EXTERNAL FUNCTIONS ///.

MACRO DEFINITIONS ///.

CFile****************************************************************

FileName [exor.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Exclusive sum-of-product minimization.]

Synopsis [Main procedure.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - June 20, 2005.]

Revision [

Id: exor.c,v 1.0 2005/06/20 00:00:00 alanmi Exp

]

                                                            ///
            Implementation of EXORCISM - 4                  ///
        An Exclusive Sum-of-Product Minimizer               ///
         Alan Mishchenko  <alanmi@ee.pdx.edu>               ///
                                                            ///

                                                            ///
                   Main Module                              ///
          ESOP Minimization Task Coordinator                ///
                                                            ///
    1) interprets command line                              ///  
    2) calls the approapriate reading procedure             ///
    3) calls the minimization module                        ///
                                                            ///

Ver. 1.0. Started - July 18, 2000. Last update - July 20, 2000 /// Ver. 1.1. Started - July 24, 2000. Last update - July 29, 2000 /// Ver. 1.4. Started - Aug 10, 2000. Last update - Aug 26, 2000 /// Ver. 1.6. Started - Sep 11, 2000. Last update - Sep 15, 2000 /// Ver. 1.7. Started - Sep 20, 2000. Last update - Sep 23, 2000 /// ///

This software was tested with the BDD package "CUDD", v.2.3.0 /// by Fabio Somenzi /// http://vlsi.colorado.edu/~fabio/ ///

Definition at line 58 of file exor.c.

◆ p

Cube* p

Definition at line 222 of file exorList.c.

◆ PosStop

int PosStop

Definition at line 1015 of file exorList.c.

◆ ppC1

Cube** ppC1

Definition at line 1013 of file exorList.c.

◆ ppC2

Cube** ppC2

Definition at line 1014 of file exorList.c.

◆ PrevID

int PrevID

Definition at line 230 of file exorList.c.

◆ PrevPa

int PrevPa

Definition at line 224 of file exorList.c.

◆ PrevPq

int PrevPq

Definition at line 226 of file exorList.c.

◆ PrevPz

int PrevPz

Definition at line 227 of file exorList.c.

◆ PrevQa

int PrevQa

Definition at line 223 of file exorList.c.

◆ PrevQq

int PrevQq

Definition at line 225 of file exorList.c.

◆ s_DiffVarNum

int s_DiffVarNum

Definition at line 638 of file exorList.c.

◆ s_DiffVarValueP_new

int s_DiffVarValueP_new

Definition at line 640 of file exorList.c.

◆ s_DiffVarValueP_old

int s_DiffVarValueP_old

Definition at line 639 of file exorList.c.

◆ s_DiffVarValueQ

int s_DiffVarValueQ

Definition at line 641 of file exorList.c.

◆ s_Distance

int s_Distance

Definition at line 637 of file exorList.c.

◆ s_fDecreaseLiterals

int s_fDecreaseLiterals = 0

Definition at line 247 of file exorList.c.

◆ s_nPosAlloc

int s_nPosAlloc

EXPORTED VARIABLES /// /////////////////////////////////////////////////////////////////////`.

Definition at line 179 of file exorList.c.

◆ s_nPosMax

int s_nPosMax[3]

Definition at line 181 of file exorList.c.

◆ s_pCubeLast

Cube* s_pCubeLast

CUBE ITERATOR ///.

Definition at line 874 of file exorList.c.

◆ s_q

Cube* s_q

Definition at line 636 of file exorList.c.

◆ Value

int Value

Definition at line 229 of file exorList.c.

◆ Var

int Var

Definition at line 228 of file exorList.c.

Classes

Functions

Variables

Function Documentation

◆ AddToFreeCubes()

◆ AllocateCubeSets()

◆ AllocateQueques()

◆ CheckAndInsert()

◆ CheckForCloseCubes()

◆ CubeExtract()

◆ CubeInsert()

◆ DelocateCubeSets()

◆ DelocateQueques()

◆ ExorLinkCubeIteratorCleanUp()

◆ ExorLinkCubeIteratorNext()

◆ ExorLinkCubeIteratorPick()

◆ ExorLinkCubeIteratorStart()

◆ ExorVar()

◆ GetDistance()

◆ GetDistancePlus()

◆ GetFreeCube()

◆ GetPosDiff()

◆ GetQuequeStats()

◆ IterativelyApplyExorLink2()

◆ IterativelyApplyExorLink3()

◆ IterativelyApplyExorLink4()

◆ IteratorCubePairNext()

◆ IteratorCubePairStart()

◆ IterCubeSetNext()

◆ IterCubeSetStart()

◆ PrintQuequeStats()

◆ UndoRecentChanges()

Variable Documentation

◆ BitCount

◆ CutValue

◆ Dist

◆ fInput

◆ fStarted

◆ g_CoverInfo

◆ p

◆ PosStop

◆ ppC1

◆ ppC2

◆ PrevID

◆ PrevPa

◆ PrevPq

◆ PrevPz

◆ PrevQa

◆ PrevQq

◆ s_DiffVarNum

◆ s_DiffVarValueP_new

◆ s_DiffVarValueP_old

◆ s_DiffVarValueQ

◆ s_Distance

◆ s_fDecreaseLiterals

◆ s_nPosAlloc

◆ s_nPosMax

◆ s_pCubeLast

◆ s_q

◆ Value

◆ Var