luckyInt.h File Reference

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
#include <math.h>
#include <time.h>
#include "misc/util/abc_global.h"
#include "lucky.h"

Include dependency graph for luckyInt.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	Abc_TtStore_t
struct	varInfo
struct	swapInfo

Macros
#define	_RUNNING_ABC_

Functions
int	memCompare (word *x, word *y, int nVars)
int	Kit_TruthWordNum_64bit (int nVars)
Abc_TtStore_t *	setTtStore (char *pFileInput)
void	Abc_TruthStoreFree (Abc_TtStore_t *p)
void	Kit_TruthChangePhase_64bit (word *pInOut, int nVars, int iVar)
void	Kit_TruthNot_64bit (word *pIn, int nVars)
void	Kit_TruthCopy_64bit (word *pOut, word *pIn, int nVars)
void	Kit_TruthSwapAdjacentVars_64bit (word *pInOut, int nVars, int iVar)
int	Kit_TruthCountOnes_64bit (word *pIn, int nVars)
void	simpleMinimal (word *x, word *pAux, word *minimal, permInfo *pi, int nVars)
permInfo *	setPermInfoPtr (int var)
void	freePermInfoPtr (permInfo *x)
void	Kit_TruthSemiCanonicize_Yasha_simple (word *pInOut, int nVars, int *pStore)
unsigned	Kit_TruthSemiCanonicize_Yasha (word *pInOut, int nVars, char *pCanonPerm)
unsigned	Kit_TruthSemiCanonicize_Yasha1 (word *pInOut, int nVars, char *pCanonPerm, int *pStore)
word	luckyCanonicizer_final_fast_6Vars (word InOut, int *pStore, char *pCanonPerm, unsigned *pCanonPhase)
word	luckyCanonicizer_final_fast_6Vars1 (word InOut, int *pStore, char *pCanonPerm, unsigned *pCanonPhase)
unsigned	adjustInfoAfterSwap (char *pCanonPerm, unsigned uCanonPhase, int iVar, unsigned info)
void	resetPCanonPermArray_6Vars (char *x)
void	swap_ij (word *f, int totalVars, int varI, int varJ)

Macro Definition Documentation

_RUNNING_ABC_

#define _RUNNING_ABC_

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

FileName [luckyInt.h]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Semi-canonical form computation package.]

Synopsis [Internal declarations.]

Author [Jake]

Date [Started - August 2012]

Definition at line 28 of file luckyInt.h.

Function Documentation

Abc_TruthStoreFree()

void Abc_TruthStoreFree ( Abc_TtStore_t * p )

extern

Definition at line 115 of file luckyRead.c.

{
    free( p->pFuncs[0] );
    free( p->pFuncs );
    free( p );
}

Here is the call graph for this function:

adjustInfoAfterSwap()

unsigned adjustInfoAfterSwap ( char * pCanonPerm, unsigned uCanonPhase, int iVar, unsigned info )

extern

Definition at line 51 of file luckyFast6.c.

{   
    if(info<4)
        return (uCanonPhase ^= (info << iVar));
    else
    {
        char temp;
        uCanonPhase ^= ((info-4) << iVar);
        temp=pCanonPerm[iVar];
        pCanonPerm[iVar]=pCanonPerm[iVar+1];
        pCanonPerm[iVar+1]=temp;
        if ( ((uCanonPhase & (1 << iVar)) > 0) != ((uCanonPhase & (1 << (iVar+1))) > 0) )
        {
            uCanonPhase ^= (1 << iVar);
            uCanonPhase ^= (1 << (iVar+1));
        }
        return uCanonPhase; 
    }
 
 
}

Here is the caller graph for this function:

freePermInfoPtr()

void freePermInfoPtr ( permInfo * x )

extern

Definition at line 126 of file luckySimple.c.

{
    free(x->flipArray);
    free(x->swapArray);
    free(x);
}

Kit_TruthChangePhase_64bit()

void Kit_TruthChangePhase_64bit ( word * pInOut, int nVars, int iVar )

extern

Definition at line 100 of file luckySwap.c.

{
    int nWords = Kit_TruthWordNum_64bit( nVars );
    int i, Step,SizeOfBlock;
    word Temp[512];
    
    assert( iVar < nVars );
    if(iVar<=5)
    {
        for ( i = 0; i < nWords; i++ )
            pInOut[i] = ((pInOut[i] & mask0[iVar]) << (1<<(iVar))) | ((pInOut[i] & ~mask0[iVar]) >> (1<<(iVar)));
    }
    else
    {
        Step = (1 << (iVar - 6));
        SizeOfBlock = sizeof(word)*Step;
        for ( i = 0; i < nWords; i += 2*Step )
        {   
            memcpy(Temp,pInOut,(size_t)SizeOfBlock);
            memcpy(pInOut,pInOut+Step,(size_t)SizeOfBlock);
            memcpy(pInOut+Step,Temp,(size_t)SizeOfBlock);
            //          Temp = pInOut[i];
            //          pInOut[i] = pInOut[Step+i];
            //          pInOut[Step+i] = Temp;          
            pInOut += 2*Step;
        }
    }
    
}

Here is the call graph for this function:

Here is the caller graph for this function:

Kit_TruthCopy_64bit()

void Kit_TruthCopy_64bit ( word * pOut, word * pIn, int nVars )

extern

Definition at line 136 of file luckySwap.c.

{ 
    memcpy(pOut,pIn,Kit_TruthWordNum_64bit(nVars)*sizeof(word));
}

Here is the call graph for this function:

Here is the caller graph for this function:

Kit_TruthCountOnes_64bit()

int Kit_TruthCountOnes_64bit ( word * pIn, int nVars )

extern

Definition at line 49 of file luckySwap.c.

{
    int w, Counter = 0;
    for ( w = Kit_TruthWordNum_64bit(nVars)-1; w >= 0; w-- )
        Counter += Kit_WordCountOnes_64bit(pIn[w]);
    return Counter;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Kit_TruthNot_64bit()

void Kit_TruthNot_64bit ( word * pIn, int nVars )

extern

Definition at line 130 of file luckySwap.c.

{
    int w;
    for ( w = Kit_TruthWordNum_64bit(nVars)-1; w >= 0; w-- )
        pIn[w] = ~pIn[w];
}

Here is the call graph for this function:

Here is the caller graph for this function:

Kit_TruthSemiCanonicize_Yasha()

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

extern

Definition at line 186 of file luckySwap.c.

{
    int pStore[16];
    int nWords = Kit_TruthWordNum_64bit( nVars );
    int i, Temp, fChange, nOnes;
    unsigned  uCanonPhase=0;
    assert( nVars <= 16 );
    
    nOnes = Kit_TruthCountOnes_64bit(pInOut, nVars);
    
    if ( (nOnes > nWords * 32) )
    {
        uCanonPhase |= (1 << nVars);
        Kit_TruthNot_64bit( pInOut, nVars );
        nOnes = nWords*64 - nOnes;
    }
    
    // collect the minterm counts
    Kit_TruthCountOnesInCofs_64bit( pInOut, nVars, pStore );
    
    // canonicize phase
    for ( i = 0; i < nVars; i++ )
    {
        if ( pStore[i] >= nOnes-pStore[i])
            continue;
        uCanonPhase |= (1 << i);
        pStore[i] = nOnes-pStore[i]; 
        Kit_TruthChangePhase_64bit( pInOut, nVars, i );
    }  
    
    do {
        fChange = 0;
        for ( i = 0; i < nVars-1; i++ )
        {
            if ( pStore[i] <= pStore[i+1] )
                continue;            
            fChange = 1;
            
            Temp = pCanonPerm[i];
            pCanonPerm[i] = pCanonPerm[i+1];
            pCanonPerm[i+1] = Temp;
            
            Temp = pStore[i];
            pStore[i] = pStore[i+1];
            pStore[i+1] = Temp;
            
            // if the polarity of variables is different, swap them
            if ( ((uCanonPhase & (1 << i)) > 0) != ((uCanonPhase & (1 << (i+1))) > 0) )
            {
                uCanonPhase ^= (1 << i);
                uCanonPhase ^= (1 << (i+1));
            }
            
            Kit_TruthSwapAdjacentVars_64bit( pInOut, nVars, i );            
        }
    } while ( fChange );
    return uCanonPhase;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Kit_TruthSemiCanonicize_Yasha1()

unsigned Kit_TruthSemiCanonicize_Yasha1 ( word * pInOut, int nVars, char * pCanonPerm, int * pStore )

extern

Definition at line 245 of file luckySwap.c.

{
    int nWords = Kit_TruthWordNum_64bit( nVars );
    int i, fChange, nOnes;
    int Temp;
    unsigned  uCanonPhase=0;
    assert( nVars <= 16 );
    
    nOnes = Kit_TruthCountOnes_64bit(pInOut, nVars);
    if ( nOnes == nWords * 32 )
        uCanonPhase |= (1 << (nVars+2));
    
    else if ( (nOnes > nWords * 32) )
    {
        uCanonPhase |= (1 << nVars);
        Kit_TruthNot_64bit( pInOut, nVars );
        nOnes = nWords*64 - nOnes;
    }
    
    // collect the minterm counts
    Kit_TruthCountOnesInCofs_64bit( pInOut, nVars, pStore );
    
    // canonicize phase
    for ( i = 0; i < nVars; i++ )
    {
        if (  2*pStore[i]  == nOnes)
        {
            uCanonPhase |= (1 << (nVars+1));
            continue;
        }
        if ( pStore[i] > nOnes-pStore[i])
            continue;
        uCanonPhase |= (1 << i);
        pStore[i] = nOnes-pStore[i]; 
        Kit_TruthChangePhase_64bit( pInOut, nVars, i );
    }  
    
    do {
        fChange = 0;
        for ( i = 0; i < nVars-1; i++ )
        {
            if ( pStore[i] <= pStore[i+1] )
                continue;            
            fChange = 1;
            
            Temp = pCanonPerm[i];
            pCanonPerm[i] = pCanonPerm[i+1];
            pCanonPerm[i+1] = Temp;
            
            Temp = pStore[i];
            pStore[i] = pStore[i+1];
            pStore[i+1] = Temp;
            
            // if the polarity of variables is different, swap them
            if ( ((uCanonPhase & (1 << i)) > 0) != ((uCanonPhase & (1 << (i+1))) > 0) )
            {
                uCanonPhase ^= (1 << i);
                uCanonPhase ^= (1 << (i+1));
            }
            
            Kit_TruthSwapAdjacentVars_64bit( pInOut, nVars, i );            
        }
    } while ( fChange );
    return uCanonPhase;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Kit_TruthSemiCanonicize_Yasha_simple()

void Kit_TruthSemiCanonicize_Yasha_simple ( word * pInOut, int nVars, int * pStore )

extern

Definition at line 358 of file luckySwap.c.

{
    int nWords = Kit_TruthWordNum_64bit( nVars );
    int i, Temp, fChange, nOnes; 
    assert( nVars <= 16 );
    
    nOnes = Kit_TruthCountOnes_64bit(pInOut, nVars);
    
    if ( (nOnes > nWords * 32) )
    { 
        Kit_TruthNot_64bit( pInOut, nVars );
        nOnes = nWords*64 - nOnes;
    }
    
    // collect the minterm counts
    Kit_TruthCountOnesInCofs_64bit( pInOut, nVars, pStore );
    
    // canonicize phase
    for ( i = 0; i < nVars; i++ )
    {
        if ( pStore[i] >= nOnes-pStore[i])
            continue;        
        pStore[i] = nOnes-pStore[i]; 
        Kit_TruthChangePhase_64bit( pInOut, nVars, i );
    }  
    
    do {
        fChange = 0;
        for ( i = 0; i < nVars-1; i++ )
        {
            if ( pStore[i] <= pStore[i+1] )
                continue;            
            fChange = 1;            
            
            Temp = pStore[i];
            pStore[i] = pStore[i+1];
            pStore[i+1] = Temp;
            
            Kit_TruthSwapAdjacentVars_64bit( pInOut, nVars, i );            
        }
    } while ( fChange ); 
}

Here is the call graph for this function:

Here is the caller graph for this function:

Kit_TruthSwapAdjacentVars_64bit()

void Kit_TruthSwapAdjacentVars_64bit ( word * pInOut, int nVars, int iVar )

extern

Definition at line 141 of file luckySwap.c.

{
    int i, Step, Shift, SizeOfBlock;                   //
    word temp[256];                   // to make only pInOut possible
    static word PMasks[5][3] = {
        { ABC_CONST(0x9999999999999999), ABC_CONST(0x2222222222222222), ABC_CONST(0x4444444444444444) },
        { ABC_CONST(0xC3C3C3C3C3C3C3C3), ABC_CONST(0x0C0C0C0C0C0C0C0C), ABC_CONST(0x3030303030303030) },
        { ABC_CONST(0xF00FF00FF00FF00F), ABC_CONST(0x00F000F000F000F0), ABC_CONST(0x0F000F000F000F00) },
        { ABC_CONST(0xFF0000FFFF0000FF), ABC_CONST(0x0000FF000000FF00), ABC_CONST(0x00FF000000FF0000) },
        { ABC_CONST(0xFFFF00000000FFFF), ABC_CONST(0x00000000FFFF0000), ABC_CONST(0x0000FFFF00000000) }
    };
    int nWords = Kit_TruthWordNum_64bit( nVars ); 
    
    assert( iVar < nVars - 1 );
    if ( iVar < 5 )
    {
        Shift = (1 << iVar);
        for ( i = 0; i < nWords; i++ )
            pInOut[i] = (pInOut[i] & PMasks[iVar][0]) | ((pInOut[i] & PMasks[iVar][1]) << Shift) | ((pInOut[i] & PMasks[iVar][2]) >> Shift);
    }
    else if ( iVar > 5 )
    {
        Step = 1 << (iVar - 6);
        SizeOfBlock = sizeof(word)*Step;
        pInOut += 2*Step;
        for(i=2*Step; i<nWords; i+=4*Step)
        {           
            memcpy(temp,pInOut-Step,(size_t)SizeOfBlock);
            memcpy(pInOut-Step,pInOut,(size_t)SizeOfBlock);
            memcpy(pInOut,temp,(size_t)SizeOfBlock);
            pInOut += 4*Step;
        }
    }
    else // if ( iVar == 5 )
    {
        for ( i = 0; i < nWords; i += 2 )
        {
            temp[0] = pInOut[i+1] << 32;
            pInOut[i+1] ^= (temp[0] ^ pInOut[i]) >> 32;
            pInOut[i] = (pInOut[i] & 0x00000000FFFFFFFF) | temp[0];
            
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Kit_TruthWordNum_64bit()

int Kit_TruthWordNum_64bit ( int nVars )

extern

Definition at line 36 of file luckySwap.c.

{ return nVars <= 6 ? 1 : (1 << (nVars - 6));}

Here is the caller graph for this function:

luckyCanonicizer_final_fast_6Vars()

word luckyCanonicizer_final_fast_6Vars ( word InOut, int * pStore, char * pCanonPerm, unsigned * pCanonPhase )

extern

Definition at line 265 of file luckyFast6.c.

{
    (* pCanonPhase) = Kit_TruthSemiCanonicize_Yasha1( &InOut, 6, pCanonPerm, pStore);
    return Extra_Truth6MinimumRoundMany1(InOut, pStore, pCanonPerm, pCanonPhase); 
}

Here is the call graph for this function:

Here is the caller graph for this function:

luckyCanonicizer_final_fast_6Vars1()

word luckyCanonicizer_final_fast_6Vars1 ( word InOut, int * pStore, char * pCanonPerm, unsigned * pCanonPhase )

extern

Definition at line 270 of file luckyFast6.c.

{
    (* pCanonPhase) = Kit_TruthSemiCanonicize_Yasha1( &InOut, 6, pCanonPerm, pStore);
    InOut = Extra_Truth6MinimumRoundMany1(InOut, pStore, pCanonPerm, pCanonPhase);
    Kit_TruthChangePhase_64bit( &InOut, 6, 5 );
    Kit_TruthChangePhase_64bit( &InOut, 6, 4 );
    Kit_TruthChangePhase_64bit( &InOut, 6, 3 );
    Kit_TruthChangePhase_64bit( &InOut, 6, 2 );
    Kit_TruthChangePhase_64bit( &InOut, 6, 1 );        
    Kit_TruthChangePhase_64bit( &InOut, 6, 0 );
    (*pCanonPhase) ^= 0x3F;
    return Extra_Truth6MinimumRoundMany1(InOut, pStore, pCanonPerm, pCanonPhase); 
}

Here is the call graph for this function:

Here is the caller graph for this function:

memCompare()

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

extern

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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

resetPCanonPermArray_6Vars()

void resetPCanonPermArray_6Vars ( char * x )

extern

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

FileName [luckyFast6.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Semi-canonical form computation package.]

Synopsis [Truth table minimization procedures for 6 vars.]

Author [Jake]

Date [Started - September 2012]

Definition at line 21 of file luckyFast6.c.

{
    x[0]='a';
    x[1]='b';
    x[2]='c';
    x[3]='d';
    x[4]='e';
    x[5]='f';
}

setPermInfoPtr()

permInfo * setPermInfoPtr ( int var )

extern

Definition at line 110 of file luckySimple.c.

{
    permInfo* x;
    x = (permInfo*) malloc(sizeof(permInfo));
    x->flipCtr=0;
    x->varN = var; 
    x->totalFlips=(1<<var)-1;
    x->swapCtr=0;
    x->totalSwaps=factorial(var)-1;
    x->flipArray = (int*) malloc(sizeof(int)*x->totalFlips);
    x->swapArray = (int*) malloc(sizeof(int)*x->totalSwaps);
    fillInSwapArray(x);
    fillInFlipArray(x);
    return x;
}

setTtStore()

Abc_TtStore_t * setTtStore ( char * pFileInput )

extern

Definition at line 319 of file luckyRead.c.

{
    int nVars, nTruths;
    Abc_TtStore_t * p;
    // figure out how many truth table and how many variables
    Abc_TruthGetParams( pFileInput, &nVars, &nTruths );
    // allocate data-structure
    p = Abc_TruthStoreAlloc( nVars, nTruths );
 
    Abc_TruthStoreRead( pFileInput, p );
    return p;
}

Here is the call graph for this function:

simpleMinimal()

void simpleMinimal ( word * x, word * pAux, word * minimal, permInfo * pi, int nVars )

extern

Definition at line 156 of file luckySimple.c.

{
    int i,j=0;
    Kit_TruthCopy_64bit( pAux, x, nVars );
    Kit_TruthNot_64bit( x, nVars );
    
    minWord(x, pAux, minimal, nVars);
    
    for(i=pi->totalSwaps-1;i>=0;i--)
    {
        Kit_TruthSwapAdjacentVars_64bit(x, nVars, pi->swapArray[i]);
        Kit_TruthSwapAdjacentVars_64bit(pAux, nVars, pi->swapArray[i]);
        minWord3(x, pAux, minimal, nVars);
    }
    for(j=pi->totalFlips-1;j>=0;j--)
    {
        Kit_TruthSwapAdjacentVars_64bit(x, nVars, 0);
        Kit_TruthSwapAdjacentVars_64bit(pAux, nVars, 0);
        Kit_TruthChangePhase_64bit(x, nVars, pi->flipArray[j]);
        Kit_TruthChangePhase_64bit(pAux, nVars, pi->flipArray[j]);
        minWord3(x, pAux, minimal, nVars);
        for(i=pi->totalSwaps-1;i>=0;i--)
        {
            Kit_TruthSwapAdjacentVars_64bit(x, nVars, pi->swapArray[i]);
            Kit_TruthSwapAdjacentVars_64bit(pAux, nVars, pi->swapArray[i]);
            minWord3(x, pAux, minimal, nVars);
        }
    } 
    Kit_TruthCopy_64bit( x, minimal, nVars );    
}

swap_ij()

void swap_ij ( word * f, int totalVars, int varI, int varJ )

extern

Definition at line 88 of file luckySwapIJ.c.

{
    if (varI == varJ)
        return;
    else if(varI>varJ)
        swap_ij( f,totalVars,varJ,varI);
    else if((varI <= 4) && (varJ <= 5))
        swap_ij_case1(f,totalVars, varI, varJ);
    else if((varI <= 5) && (varJ > 5))
        swap_ij_case2(f,totalVars, varI, varJ);
    else if((varI > 5) && (varJ > 5))
        swap_ij_case3(f,totalVars,varI,varJ);
}

Here is the call graph for this function:

Here is the caller graph for this function: