lucky.c File Reference

#include "luckyInt.h"

Go to the source code of this file.

Data Structures
struct	cycleCtr

Functions
ABC_NAMESPACE_IMPL_START int	memCompare (word *x, word *y, int nVars)
int	compareWords1 (const void *a, const void *b)
void	sortAndUnique1 (word *a, Abc_TtStore_t *p)
int	compareWords2 (const void **x, const void **y)
int	compareWords (const void **a, const void **b)
int	compareWords3 (const void **x, const void **y)
void	sortAndUnique (word **a, Abc_TtStore_t *p)
cycleCtr *	setCycleCtrPtr ()
void	freeCycleCtr (cycleCtr *x)
word **	makeArray (Abc_TtStore_t *p)
void	freeArray (word **a, Abc_TtStore_t *p)
word *	makeArrayB (word **a, int nFuncs)
void	freeArrayB (word *b)
void	printCCtrInfo (cycleCtr *cCtr, int nFuncs)
int	minimalInitialFlip1 (word *pInOut, int nVars)
int	minimalFlip1 (word *pInOut, word *pMinimal, word *PDuplicat, int nVars)
int	minimalSwap1 (word *pInOut, word *pMinimal, word *PDuplicat, int nVars)
int	minimalInitialFlip (word *pInOut, int nVars, unsigned *p_uCanonPhase)
int	minimalFlip (word *pInOut, word *pMinimal, word *PDuplicat, int nVars, unsigned *p_uCanonPhase)
void	swapInfoAdjacentVars (int iVar, char *pCanonPerm, unsigned *p_uCanonPhase)
int	minimalSwap (word *pInOut, word *pMinimal, word *PDuplicat, int nVars, char *pCanonPerm, char *tempArray, unsigned *p_uCanonPhase)
void	luckyCanonicizer (word *pInOut, word *pAux, word *pAux1, int nVars, char *pCanonPerm, char *tempArray, unsigned *p_uCanonPhase)
unsigned	luckyCanonicizer1_simple (word *pInOut, word *pAux, word *pAux1, int nVars, char *pCanonPerm, unsigned CanonPhase)
void	luckyCanonicizer_final (word *pInOut, word *pAux, word *pAux1, int nVars)
unsigned	Kit_TruthSemiCanonicize_new_internal (word *pInOut, int nVars, char *pCanonPerm)
unsigned	Kit_TruthSemiCanonicize_new (unsigned *pInOut, unsigned *pAux, int nVars, char *pCanonPerm)

Function Documentation

int compareWords	(	const void **	a,
		const void **	b
	)

Definition at line 73 of file lucky.c.

{
     if( memcmp(*(word**)a,*(word**)b,sizeof(word)*1) > 0 )
         return 1;
     else
         return ( memcmp(*(word**)a,*(word**)b,sizeof(word)*1) < 0 ) ? -1: 0;       
}

int compareWords1	(	const void *	a,
		const void *	b
	)

Definition at line 37 of file lucky.c.

 {
     if( *(word*)a > *(word*)b )
         return 1;
     else
         return( *(word*)a < *(word*)b ) ? -1: 0;
     
 }

int compareWords2	(	const void **	x,
		const void **	y
	)

Definition at line 62 of file lucky.c.

{
    
    if(**(word**)x > **(word**)y)
        return 1;
    else if(**(word**)x < **(word**)y)
        return -1;
    else
        return 0;   
    
}

int compareWords3	(	const void **	x,
		const void **	y
	)

Definition at line 80 of file lucky.c.

{
    return memCompare(*(word**)x, *(word**)y, 16);   
} 

void freeArray	(	word **	a,
		Abc_TtStore_t *	p
	)

Definition at line 133 of file lucky.c.

{
    int i;
    for(i=0;i<p->nFuncs;i++)
        free(a[i]);
    free(a);
}

void freeArrayB

(

word *

b

)

Definition at line 151 of file lucky.c.

{
    free(b);
}

void freeCycleCtr

(

cycleCtr *

x

)

Definition at line 116 of file lucky.c.

{
    free(x);
}

unsigned Kit_TruthSemiCanonicize_new	(	unsigned *	pInOut,
		unsigned *	pAux,
		int	nVars,
		char *	pCanonPerm
	)

Definition at line 611 of file lucky.c.

{
    unsigned Result;
    if ( nVars < 6 )
    {
         word Temp = ((word)pInOut[0] << 32) | (word)pInOut[0];
         Result = Kit_TruthSemiCanonicize_new_internal( &Temp, nVars, pCanonPerm );
         pInOut[0] = (unsigned)Temp;
    }
    else
         Result = Kit_TruthSemiCanonicize_new_internal( (word *)pInOut, nVars, pCanonPerm );
    return Result;
}

unsigned Kit_TruthSemiCanonicize_new_internal	(	word *	pInOut,
		int	nVars,
		char *	pCanonPerm
	)

Definition at line 599 of file lucky.c.

{
    word pAux[1024], pAux1[1024];
    char tempArray[16];
    unsigned CanonPhase;
    assert( nVars <= 16 );
    CanonPhase = Kit_TruthSemiCanonicize_Yasha( pInOut, nVars, pCanonPerm );
    luckyCanonicizer(pInOut, pAux, pAux1, nVars, pCanonPerm, tempArray, &CanonPhase);
    return CanonPhase;
}

void luckyCanonicizer	(	word *	pInOut,
		word *	pAux,
		word *	pAux1,
		int	nVars,
		char *	pCanonPerm,
		char *	tempArray,
		unsigned *	p_uCanonPhase
	)

Definition at line 564 of file lucky.c.

{
    int counter=1;
    assert( nVars <= 16 );
    while(counter>0 )   //  && cycles < 10 if we wanna limit cycles
    {
        counter=0;
        counter += minimalInitialFlip(pInOut, nVars, p_uCanonPhase);
        counter += minimalFlip(pInOut, pAux, pAux1, nVars, p_uCanonPhase);
        counter += minimalSwap(pInOut, pAux, pAux1, nVars, pCanonPerm, tempArray, p_uCanonPhase);   
    }
}

unsigned luckyCanonicizer1_simple	(	word *	pInOut,
		word *	pAux,
		word *	pAux1,
		int	nVars,
		char *	pCanonPerm,
		unsigned	CanonPhase
	)

Definition at line 577 of file lucky.c.

{
    int counter=1;
    assert( nVars <= 16 );
    while(counter>0 )   //  && cycles < 10 if we wanna limit cycles
    {
        counter=0;
        counter += minimalInitialFlip1(pInOut, nVars);
        counter += minimalFlip1(pInOut, pAux, pAux1, nVars);
        counter += minimalSwap1(pInOut, pAux, pAux1, nVars);    
    }
    return CanonPhase;
}

void luckyCanonicizer_final	(	word *	pInOut,
		word *	pAux,
		word *	pAux1,
		int	nVars
	)

Definition at line 591 of file lucky.c.

{
    Kit_TruthSemiCanonicize_Yasha_simple( pInOut, nVars, NULL );
    luckyCanonicizer1_simple(pInOut, pAux, pAux1, nVars, NULL, 0);
}

word** makeArray

(

Abc_TtStore_t *

p

)

Definition at line 120 of file lucky.c.

{
    int i;
    word** a;
    a = (word**)malloc(sizeof(word*)*(p->nFuncs));
    for(i=0;i<p->nFuncs;i++)
    {
        a[i] = (word*)malloc(sizeof(word)*(p->nWords));
        memcpy(a[i],p->pFuncs[i],sizeof(word)*(p->nWords));

    }
    return a;
}

word* makeArrayB	(	word **	a,
		int	nFuncs
	)

Definition at line 141 of file lucky.c.

{
    int i;
    word* b;
    b = (word*)malloc(sizeof(word)*(nFuncs));
    for(i=0;i<nFuncs;i++)
        b[i] = a[i][0];

    return b;
}

ABC_NAMESPACE_IMPL_START int memCompare	(	word *	x,
		word *	y,
		int	nVars
	)

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

FileName [lucky.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Semi-canonical form computation package.]

Synopsis [Truth table minimization procedures.]

Author [Jake]

Date [Started - August 2012]

Definition at line 22 of file lucky.c.

{
    int i;
    for(i=Kit_TruthWordNum_64bit( nVars )-1;i>=0;i--)
    {
        if(x[i]==y[i])
            continue;
        else if(x[i]>y[i])
            return 1;
        else
            return -1;
    }
    return 0;
}

int minimalFlip	(	word *	pInOut,
		word *	pMinimal,
		word *	PDuplicat,
		int	nVars,
		unsigned *	p_uCanonPhase
	)

Definition at line 378 of file lucky.c.

{
    int i;
    unsigned minTemp = *p_uCanonPhase;
    int blockSize = Kit_TruthWordNum_64bit( nVars )*sizeof(word);
    memcpy(pMinimal, pInOut, blockSize);
    memcpy(PDuplicat, pInOut, blockSize);       //////////////need one more unsigned!!!!!!!!!!!!!
    Kit_TruthChangePhase_64bit( pInOut, nVars, 0 );
    *p_uCanonPhase ^= (unsigned)1;
    for(i=1;i<nVars;i++)
    {
        if( memCompare(pMinimal,pInOut,nVars) == 1)
        {
            memcpy(pMinimal, pInOut, blockSize);
            minTemp = *p_uCanonPhase;
        }
        else
        {
            memcpy(pInOut, pMinimal, blockSize);
            *p_uCanonPhase = minTemp;
        }
        Kit_TruthChangePhase_64bit( pInOut, nVars, i );
        *p_uCanonPhase ^= (1 << i);
    }
    if( memCompare(pMinimal,pInOut,nVars) == -1)
    {
        memcpy(pInOut, pMinimal, blockSize);
        *p_uCanonPhase = minTemp;
    }
    if(memcmp(pInOut,PDuplicat,blockSize) == 0) 
        return 0;
    else
        return 1;
}

int minimalFlip1	(	word *	pInOut,
		word *	pMinimal,
		word *	PDuplicat,
		int	nVars
	)

Definition at line 301 of file lucky.c.

{
    int i;
    int blockSize = Kit_TruthWordNum_64bit( nVars )*sizeof(word);
    memcpy(pMinimal, pInOut, blockSize);
    memcpy(PDuplicat, pInOut, blockSize);
    Kit_TruthChangePhase_64bit( pInOut, nVars, 0 );
    for(i=1;i<nVars;i++)
    {
        if( memCompare(pMinimal,pInOut,nVars) == 1)
        {
            memcpy(pMinimal, pInOut, blockSize);
            Kit_TruthChangePhase_64bit( pInOut, nVars, i );
        }
        else
        {
            memcpy(pInOut, pMinimal, blockSize);
            Kit_TruthChangePhase_64bit( pInOut, nVars, i );
        }
    }
    if( memCompare(pMinimal,pInOut,nVars) == -1)
        memcpy(pInOut, pMinimal, blockSize);
    if(memcmp(pInOut,PDuplicat,blockSize) == 0)
        return 0;
    else
        return 1;
}

int minimalInitialFlip	(	word *	pInOut,
		int	nVars,
		unsigned *	p_uCanonPhase
	)

Definition at line 362 of file lucky.c.

{
    word oneWord=1;
    if(  (pInOut[Kit_TruthWordNum_64bit( nVars ) -1]>>63) & oneWord )
    {
        Kit_TruthNot_64bit( pInOut, nVars );
        *p_uCanonPhase ^= (1 << nVars);
        return 1;
    }
    return 0;
}

int minimalInitialFlip1	(	word *	pInOut,
		int	nVars
	)

Definition at line 286 of file lucky.c.

{
    word oneWord=1;
    if(  (pInOut[Kit_TruthWordNum_64bit( nVars ) -1]>>63) & oneWord )
    {
        Kit_TruthNot_64bit( pInOut, nVars );
        return 1;
    }
    return 0;
}

int minimalSwap	(	word *	pInOut,
		word *	pMinimal,
		word *	PDuplicat,
		int	nVars,
		char *	pCanonPerm,
		char *	tempArray,
		unsigned *	p_uCanonPhase
	)

Definition at line 475 of file lucky.c.

{
    int i;  
    int blockSizeWord = Kit_TruthWordNum_64bit( nVars )*sizeof(word);
    int blockSizeChar = nVars *sizeof(char);
    unsigned TempuCanonPhase = *p_uCanonPhase;
    memcpy(pMinimal, pInOut, blockSizeWord);
    memcpy(PDuplicat, pInOut, blockSizeWord);
    memcpy(tempArray, pCanonPerm, blockSizeChar);  
    Kit_TruthSwapAdjacentVars_64bit( pInOut, nVars, 0 );
    swapInfoAdjacentVars(0, pCanonPerm, p_uCanonPhase);
    for(i=1;i<nVars-1;i++)
    {
        if( memCompare(pMinimal,pInOut,nVars) == 1)
        {
            memcpy(pMinimal, pInOut, blockSizeWord);
            memcpy(tempArray, pCanonPerm, blockSizeChar);
            TempuCanonPhase = *p_uCanonPhase;
            
        }
        else
        {
            memcpy(pInOut, pMinimal, blockSizeWord);
            memcpy(pCanonPerm, tempArray, blockSizeChar);
            *p_uCanonPhase = TempuCanonPhase;
        }
        Kit_TruthSwapAdjacentVars_64bit( pInOut, nVars, i );
        swapInfoAdjacentVars(i, pCanonPerm, p_uCanonPhase);
    }
    if( memCompare(pMinimal,pInOut,nVars) == -1)
    {
        memcpy(pInOut, pMinimal, blockSizeWord);
        memcpy(pCanonPerm, tempArray, blockSizeChar);
        *p_uCanonPhase = TempuCanonPhase;
    }
    if(memcmp(pInOut,PDuplicat,blockSizeWord) == 0)
        return 0;
    else
        return 1;
}

int minimalSwap1	(	word *	pInOut,
		word *	pMinimal,
		word *	PDuplicat,
		int	nVars
	)

Definition at line 332 of file lucky.c.

{
    int i;
    int blockSize = Kit_TruthWordNum_64bit( nVars )*sizeof(word);
    memcpy(pMinimal, pInOut, blockSize);
    memcpy(PDuplicat, pInOut, blockSize);
    Kit_TruthSwapAdjacentVars_64bit( pInOut, nVars, 0 );
    for(i=1;i<nVars-1;i++)
    {
        if( memCompare(pMinimal,pInOut,nVars) == 1)
        {
            memcpy(pMinimal, pInOut, blockSize);
            Kit_TruthSwapAdjacentVars_64bit( pInOut, nVars, i );
        }
        else
        {
            memcpy(pInOut, pMinimal, blockSize);
            Kit_TruthSwapAdjacentVars_64bit( pInOut, nVars, i );
        }
    }
    if( memCompare(pMinimal,pInOut,nVars) == -1)
        memcpy(pInOut, pMinimal, blockSize);
    if(memcmp(pInOut,PDuplicat,blockSize) == 0)
        return 0;
    else
        return 1;
}

void printCCtrInfo	(	cycleCtr *	cCtr,
		int	nFuncs
	)

Definition at line 276 of file lucky.c.

{
    printf("maxNCycles = %d\n",cCtr->maxNCycles);
    printf("minNCycles = %d\n",cCtr->minNCycles);
    printf("average NCycles = %.3f\n",cCtr->totalCycles/(double)nFuncs);
}

cycleCtr* setCycleCtrPtr

(

)

Definition at line 108 of file lucky.c.

{
     cycleCtr* x = (cycleCtr*) malloc(sizeof(cycleCtr));
     x->totalCycles=0;
     x->maxNCycles=0;
     x->minNCycles=111111111;
     return x;
}

void sortAndUnique	(	word **	a,
		Abc_TtStore_t *	p
	)

Definition at line 84 of file lucky.c.

{
     int i, count=1, WordsPtrN = p->nFuncs;
     word* tempWordPtr;
     qsort(a,WordsPtrN,sizeof(word*),(int(*)(const void *,const void *))compareWords3);
     tempWordPtr = a[0];
     for(i=1;i<WordsPtrN;i++)   
         if(memcmp(a[i],tempWordPtr,sizeof(word)*(p->nWords)) != 0)
         {
             a[count] = a[i];
             tempWordPtr = a[i];
             count++;
         }
         p->nFuncs = count;
}

void sortAndUnique1	(	word *	a,
		Abc_TtStore_t *	p
	)

Definition at line 46 of file lucky.c.

 {
     int i, count=1, WordsN = p->nFuncs;
     word tempWord;
     qsort(a,WordsN,sizeof(word),compareWords1);
     tempWord = a[0];
     for(i=1;i<WordsN;i++)  
         if(tempWord != a[i])
         {
             a[count] = a[i];
             tempWord = a[i];
             count++;
         }
         p->nFuncs = count;
}

void swapInfoAdjacentVars	(	int	iVar,
		char *	pCanonPerm,
		unsigned *	p_uCanonPhase
	)

Definition at line 414 of file lucky.c.

{
    char Temp = pCanonPerm[iVar];
    pCanonPerm[iVar] = pCanonPerm[iVar+1];
    pCanonPerm[iVar+1] = Temp;
    
    // if the polarity of variables is different, swap them
    if ( ((*p_uCanonPhase & (1 << iVar)) > 0) != ((*p_uCanonPhase & (1 << (iVar+1))) > 0) )
    {
        *p_uCanonPhase ^= (1 << iVar);
        *p_uCanonPhase ^= (1 << (iVar+1));
    }
            
}