/src/base/abc/abcSop.c
C | 1322 lines | 697 code | 64 blank | 561 comment | 246 complexity | 22c0fa41d381fe34fb803e81e02479d1 MD5 | raw file
Possible License(s): BSD-3-Clause
- /**CFile****************************************************************
- FileName [abcSop.c]
- SystemName [ABC: Logic synthesis and verification system.]
- PackageName [Network and node package.]
- Synopsis [Implementation of a simple SOP representation of nodes.]
- Author [Alan Mishchenko]
-
- Affiliation [UC Berkeley]
- Date [Ver. 1.0. Started - June 20, 2005.]
- Revision [$Id: abcSop.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
- ***********************************************************************/
- #include "abc.h"
- ABC_NAMESPACE_IMPL_START
- /*
- The SOPs in this package are represented using char * strings.
- For example, the SOP of the node:
- .names c d0 d1 MUX
- 01- 1
- 1-1 1
- is the string: "01- 1\n1-1 1\n" where '\n' is a single char.
- */
- ////////////////////////////////////////////////////////////////////////
- /// DECLARATIONS ///
- ////////////////////////////////////////////////////////////////////////
- ////////////////////////////////////////////////////////////////////////
- /// FUNCTION DEFINITIONS ///
- ////////////////////////////////////////////////////////////////////////
- /**Function*************************************************************
- Synopsis [Registers the cube string with the network.]
- Description []
-
- SideEffects []
- SeeAlso []
- ***********************************************************************/
- char * Abc_SopRegister( Mem_Flex_t * pMan, const char * pName )
- {
- char * pRegName;
- if ( pName == NULL ) return NULL;
- pRegName = Mem_FlexEntryFetch( pMan, strlen(pName) + 1 );
- strcpy( pRegName, pName );
- return pRegName;
- }
- /**Function*************************************************************
- Synopsis [Creates the constant 1 cover with the given number of variables and cubes.]
- Description []
-
- SideEffects []
- SeeAlso []
- ***********************************************************************/
- char * Abc_SopStart( Mem_Flex_t * pMan, int nCubes, int nVars )
- {
- char * pSopCover, * pCube;
- int i, Length;
- Length = nCubes * (nVars + 3);
- pSopCover = Mem_FlexEntryFetch( pMan, Length + 1 );
- memset( pSopCover, '-', Length );
- pSopCover[Length] = 0;
- for ( i = 0; i < nCubes; i++ )
- {
- pCube = pSopCover + i * (nVars + 3);
- pCube[nVars + 0] = ' ';
- pCube[nVars + 1] = '1';
- pCube[nVars + 2] = '\n';
- }
- return pSopCover;
- }
- /**Function*************************************************************
- Synopsis [Creates the constant 1 cover with 0 variables.]
- Description []
-
- SideEffects []
- SeeAlso []
- ***********************************************************************/
- char * Abc_SopCreateConst1( Mem_Flex_t * pMan )
- {
- return Abc_SopRegister( pMan, " 1\n" );
- }
- /**Function*************************************************************
- Synopsis [Creates the constant 1 cover with 0 variables.]
- Description []
-
- SideEffects []
- SeeAlso []
- ***********************************************************************/
- char * Abc_SopCreateConst0( Mem_Flex_t * pMan )
- {
- return Abc_SopRegister( pMan, " 0\n" );
- }
- /**Function*************************************************************
- Synopsis [Creates the AND2 cover.]
- Description []
-
- SideEffects []
- SeeAlso []
- ***********************************************************************/
- char * Abc_SopCreateAnd2( Mem_Flex_t * pMan, int fCompl0, int fCompl1 )
- {
- char Buffer[6];
- Buffer[0] = '1' - fCompl0;
- Buffer[1] = '1' - fCompl1;
- Buffer[2] = ' ';
- Buffer[3] = '1';
- Buffer[4] = '\n';
- Buffer[5] = 0;
- return Abc_SopRegister( pMan, Buffer );
- }
- /**Function*************************************************************
- Synopsis [Creates the multi-input AND cover.]
- Description []
-
- SideEffects []
- SeeAlso []
- ***********************************************************************/
- char * Abc_SopCreateAnd( Mem_Flex_t * pMan, int nVars, int * pfCompl )
- {
- char * pSop;
- int i;
- pSop = Abc_SopStart( pMan, 1, nVars );
- for ( i = 0; i < nVars; i++ )
- pSop[i] = '1' - (pfCompl? pfCompl[i] : 0);
- pSop[nVars + 1] = '1';
- return pSop;
- }
- /**Function*************************************************************
- Synopsis [Creates the multi-input NAND cover.]
- Description []
-
- SideEffects []
- SeeAlso []
- ***********************************************************************/
- char * Abc_SopCreateNand( Mem_Flex_t * pMan, int nVars )
- {
- char * pSop;
- int i;
- pSop = Abc_SopStart( pMan, 1, nVars );
- for ( i = 0; i < nVars; i++ )
- pSop[i] = '1';
- pSop[nVars + 1] = '0';
- return pSop;
- }
- /**Function*************************************************************
- Synopsis [Creates the multi-input OR cover.]
- Description []
-
- SideEffects []
- SeeAlso []
- ***********************************************************************/
- char * Abc_SopCreateOr( Mem_Flex_t * pMan, int nVars, int * pfCompl )
- {
- char * pSop;
- int i;
- pSop = Abc_SopStart( pMan, 1, nVars );
- for ( i = 0; i < nVars; i++ )
- pSop[i] = '0' + (pfCompl? pfCompl[i] : 0);
- pSop[nVars + 1] = '0';
- return pSop;
- }
- /**Function*************************************************************
- Synopsis [Creates the multi-input OR cover.]
- Description []
-
- SideEffects []
- SeeAlso []
- ***********************************************************************/
- char * Abc_SopCreateOrMultiCube( Mem_Flex_t * pMan, int nVars, int * pfCompl )
- {
- char * pSop, * pCube;
- int i;
- pSop = Abc_SopStart( pMan, nVars, nVars );
- i = 0;
- Abc_SopForEachCube( pSop, nVars, pCube )
- {
- pCube[i] = '1' - (pfCompl? pfCompl[i] : 0);
- i++;
- }
- return pSop;
- }
- /**Function*************************************************************
- Synopsis [Creates the multi-input NOR cover.]
- Description []
-
- SideEffects []
- SeeAlso []
- ***********************************************************************/
- char * Abc_SopCreateNor( Mem_Flex_t * pMan, int nVars )
- {
- char * pSop;
- int i;
- pSop = Abc_SopStart( pMan, 1, nVars );
- for ( i = 0; i < nVars; i++ )
- pSop[i] = '0';
- return pSop;
- }
- /**Function*************************************************************
- Synopsis [Creates the multi-input XOR cover.]
- Description []
-
- SideEffects []
- SeeAlso []
- ***********************************************************************/
- char * Abc_SopCreateXor( Mem_Flex_t * pMan, int nVars )
- {
- assert( nVars == 2 );
- return Abc_SopRegister(pMan, "01 1\n10 1\n");
- }
- /**Function*************************************************************
- Synopsis [Creates the multi-input XOR cover (special case).]
- Description []
-
- SideEffects []
- SeeAlso []
- ***********************************************************************/
- char * Abc_SopCreateXorSpecial( Mem_Flex_t * pMan, int nVars )
- {
- char * pSop;
- pSop = Abc_SopCreateAnd( pMan, nVars, NULL );
- pSop[nVars+1] = 'x';
- assert( pSop[nVars+2] == '\n' );
- return pSop;
- }
- /**Function*************************************************************
- Synopsis [Creates the multi-input XNOR cover.]
- Description []
-
- SideEffects []
- SeeAlso []
- ***********************************************************************/
- char * Abc_SopCreateNxor( Mem_Flex_t * pMan, int nVars )
- {
- assert( nVars == 2 );
- return Abc_SopRegister(pMan, "11 1\n00 1\n");
- }
- /**Function*************************************************************
- Synopsis [Creates the MUX cover.]
- Description [The first input of MUX is the control. The second input
- is DATA1. The third input is DATA0.]
-
- SideEffects []
- SeeAlso []
- ***********************************************************************/
- char * Abc_SopCreateMux( Mem_Flex_t * pMan )
- {
- return Abc_SopRegister(pMan, "11- 1\n0-1 1\n");
- }
- /**Function*************************************************************
- Synopsis [Creates the inv cover.]
- Description []
-
- SideEffects []
- SeeAlso []
- ***********************************************************************/
- char * Abc_SopCreateInv( Mem_Flex_t * pMan )
- {
- return Abc_SopRegister(pMan, "0 1\n");
- }
- /**Function*************************************************************
- Synopsis [Creates the buf cover.]
- Description []
-
- SideEffects []
- SeeAlso []
- ***********************************************************************/
- char * Abc_SopCreateBuf( Mem_Flex_t * pMan )
- {
- return Abc_SopRegister(pMan, "1 1\n");
- }
- /**Function*************************************************************
- Synopsis [Creates the arbitrary cover from the truth table.]
- Description []
-
- SideEffects []
- SeeAlso []
- ***********************************************************************/
- char * Abc_SopCreateFromTruth( Mem_Flex_t * pMan, int nVars, unsigned * pTruth )
- {
- char * pSop, * pCube;
- int nMints, Counter, i, k;
- // count the number of true minterms
- Counter = 0;
- nMints = (1 << nVars);
- for ( i = 0; i < nMints; i++ )
- Counter += ((pTruth[i>>5] & (1 << (i&31))) > 0);
- // SOP is not well-defined if the truth table is constant 0
- assert( Counter > 0 );
- if ( Counter == 0 )
- return NULL;
- // start the cover
- pSop = Abc_SopStart( pMan, Counter, nVars );
- // create true minterms
- Counter = 0;
- for ( i = 0; i < nMints; i++ )
- if ( (pTruth[i>>5] & (1 << (i&31))) > 0 )
- {
- pCube = pSop + Counter * (nVars + 3);
- for ( k = 0; k < nVars; k++ )
- pCube[k] = '0' + ((i & (1 << k)) > 0);
- Counter++;
- }
- return pSop;
- }
- /**Function*************************************************************
- Synopsis [Creates the cover from the ISOP computed from TT.]
- Description []
-
- SideEffects []
- SeeAlso []
- ***********************************************************************/
- char * Abc_SopCreateFromIsop( Mem_Flex_t * pMan, int nVars, Vec_Int_t * vCover )
- {
- char * pSop, * pCube;
- int i, k, Entry, Literal;
- assert( Vec_IntSize(vCover) > 0 );
- if ( Vec_IntSize(vCover) == 0 )
- return NULL;
- // start the cover
- pSop = Abc_SopStart( pMan, Vec_IntSize(vCover), nVars );
- // create cubes
- Vec_IntForEachEntry( vCover, Entry, i )
- {
- pCube = pSop + i * (nVars + 3);
- for ( k = 0; k < nVars; k++ )
- {
- Literal = 3 & (Entry >> (k << 1));
- if ( Literal == 1 )
- pCube[k] = '0';
- else if ( Literal == 2 )
- pCube[k] = '1';
- else if ( Literal != 0 )
- assert( 0 );
- }
- }
- return pSop;
- }
- /**Function*************************************************************
- Synopsis [Creates the cover from the ISOP computed from TT.]
- Description []
-
- SideEffects []
- SeeAlso []
- ***********************************************************************/
- void Abc_SopToIsop( char * pSop, Vec_Int_t * vCover )
- {
- char * pCube;
- int k, nVars, Entry;
- nVars = Abc_SopGetVarNum( pSop );
- assert( nVars > 0 );
- // create cubes
- Vec_IntClear( vCover );
- for ( pCube = pSop; *pCube; pCube += nVars + 3 )
- {
- Entry = 0;
- for ( k = nVars - 1; k >= 0; k-- )
- if ( pCube[k] == '0' )
- Entry = (Entry << 2) | 1;
- else if ( pCube[k] == '1' )
- Entry = (Entry << 2) | 2;
- else if ( pCube[k] == '-' )
- Entry = (Entry << 2);
- else
- assert( 0 );
- Vec_IntPush( vCover, Entry );
- }
- }
- /**Function*************************************************************
- Synopsis [Reads the number of cubes in the cover.]
- Description []
-
- SideEffects []
- SeeAlso []
- ***********************************************************************/
- int Abc_SopGetCubeNum( char * pSop )
- {
- char * pCur;
- int nCubes = 0;
- if ( pSop == NULL )
- return 0;
- for ( pCur = pSop; *pCur; pCur++ )
- nCubes += (*pCur == '\n');
- return nCubes;
- }
- /**Function*************************************************************
- Synopsis [Reads the number of SOP literals in the cover.]
- Description []
-
- SideEffects []
- SeeAlso []
- ***********************************************************************/
- int Abc_SopGetLitNum( char * pSop )
- {
- char * pCur;
- int nLits = 0;
- if ( pSop == NULL )
- return 0;
- for ( pCur = pSop; *pCur; pCur++ )
- {
- nLits -= (*pCur == '\n');
- nLits += (*pCur == '0' || *pCur == '1');
- }
- return nLits;
- }
- /**Function*************************************************************
- Synopsis [Reads the number of variables in the cover.]
- Description []
-
- SideEffects []
- SeeAlso []
- ***********************************************************************/
- int Abc_SopGetVarNum( char * pSop )
- {
- char * pCur;
- for ( pCur = pSop; *pCur != '\n'; pCur++ )
- if ( *pCur == 0 )
- return -1;
- return pCur - pSop - 2;
- }
- /**Function*************************************************************
- Synopsis [Reads the phase of the cover.]
- Description []
-
- SideEffects []
- SeeAlso []
- ***********************************************************************/
- int Abc_SopGetPhase( char * pSop )
- {
- int nVars = Abc_SopGetVarNum( pSop );
- if ( pSop[nVars+1] == '0' || pSop[nVars+1] == 'n' )
- return 0;
- if ( pSop[nVars+1] == '1' || pSop[nVars+1] == 'x' )
- return 1;
- assert( 0 );
- return -1;
- }
- /**Function*************************************************************
- Synopsis [Returns the i-th literal of the cover.]
- Description []
-
- SideEffects []
- SeeAlso []
- ***********************************************************************/
- int Abc_SopGetIthCareLit( char * pSop, int i )
- {
- char * pCube;
- int nVars;
- nVars = Abc_SopGetVarNum( pSop );
- Abc_SopForEachCube( pSop, nVars, pCube )
- if ( pCube[i] != '-' )
- return pCube[i] - '0';
- return -1;
- }
- /**Function*************************************************************
- Synopsis []
- Description []
-
- SideEffects []
- SeeAlso []
- ***********************************************************************/
- void Abc_SopComplement( char * pSop )
- {
- char * pCur;
- for ( pCur = pSop; *pCur; pCur++ )
- if ( *pCur == '\n' )
- {
- if ( *(pCur - 1) == '0' )
- *(pCur - 1) = '1';
- else if ( *(pCur - 1) == '1' )
- *(pCur - 1) = '0';
- else if ( *(pCur - 1) == 'x' )
- *(pCur - 1) = 'n';
- else if ( *(pCur - 1) == 'n' )
- *(pCur - 1) = 'x';
- else
- assert( 0 );
- }
- }
- /**Function*************************************************************
- Synopsis []
- Description []
-
- SideEffects []
- SeeAlso []
- ***********************************************************************/
- void Abc_SopComplementVar( char * pSop, int iVar )
- {
- char * pCube;
- int nVars = Abc_SopGetVarNum(pSop);
- assert( iVar < nVars );
- Abc_SopForEachCube( pSop, nVars, pCube )
- {
- if ( pCube[iVar] == '0' )
- pCube[iVar] = '1';
- else if ( pCube[iVar] == '1' )
- pCube[iVar] = '0';
- }
- }
- /**Function*************************************************************
- Synopsis []
- Description []
-
- SideEffects []
- SeeAlso []
- ***********************************************************************/
- int Abc_SopIsComplement( char * pSop )
- {
- char * pCur;
- for ( pCur = pSop; *pCur; pCur++ )
- if ( *pCur == '\n' )
- return (int)(*(pCur - 1) == '0' || *(pCur - 1) == 'n');
- assert( 0 );
- return 0;
- }
- /**Function*************************************************************
- Synopsis [Checks if the cover is constant 0.]
- Description []
-
- SideEffects []
- SeeAlso []
- ***********************************************************************/
- int Abc_SopIsConst0( char * pSop )
- {
- return pSop[0] == ' ' && pSop[1] == '0';
- }
- /**Function*************************************************************
- Synopsis [Checks if the cover is constant 1.]
- Description []
-
- SideEffects []
- SeeAlso []
- ***********************************************************************/
- int Abc_SopIsConst1( char * pSop )
- {
- return pSop[0] == ' ' && pSop[1] == '1';
- }
- /**Function*************************************************************
- Synopsis [Checks if the cover is constant 1.]
- Description []
-
- SideEffects []
- SeeAlso []
- ***********************************************************************/
- int Abc_SopIsBuf( char * pSop )
- {
- if ( pSop[4] != 0 )
- return 0;
- if ( (pSop[0] == '1' && pSop[2] == '1') || (pSop[0] == '0' && pSop[2] == '0') )
- return 1;
- return 0;
- }
- /**Function*************************************************************
- Synopsis [Checks if the cover is constant 1.]
- Description []
-
- SideEffects []
- SeeAlso []
- ***********************************************************************/
- int Abc_SopIsInv( char * pSop )
- {
- if ( pSop[4] != 0 )
- return 0;
- if ( (pSop[0] == '0' && pSop[2] == '1') || (pSop[0] == '1' && pSop[2] == '0') )
- return 1;
- return 0;
- }
- /**Function*************************************************************
- Synopsis [Checks if the cover is AND with possibly complemented inputs.]
- Description []
-
- SideEffects []
- SeeAlso []
- ***********************************************************************/
- int Abc_SopIsAndType( char * pSop )
- {
- char * pCur;
- if ( Abc_SopGetCubeNum(pSop) != 1 )
- return 0;
- for ( pCur = pSop; *pCur != ' '; pCur++ )
- if ( *pCur == '-' )
- return 0;
- if ( pCur[1] != '1' )
- return 0;
- return 1;
- }
- /**Function*************************************************************
- Synopsis [Checks if the cover is OR with possibly complemented inputs.]
- Description []
-
- SideEffects []
- SeeAlso []
- ***********************************************************************/
- int Abc_SopIsOrType( char * pSop )
- {
- char * pCube, * pCur;
- int nVars, nLits;
- nVars = Abc_SopGetVarNum( pSop );
- if ( nVars != Abc_SopGetCubeNum(pSop) )
- return 0;
- Abc_SopForEachCube( pSop, nVars, pCube )
- {
- // count the number of literals in the cube
- nLits = 0;
- for ( pCur = pCube; *pCur != ' '; pCur++ )
- nLits += ( *pCur != '-' );
- if ( nLits != 1 )
- return 0;
- }
- return 1;
- }
- /**Function*************************************************************
- Synopsis []
- Description []
-
- SideEffects []
- SeeAlso []
- ***********************************************************************/
- int Abc_SopIsExorType( char * pSop )
- {
- char * pCur;
- for ( pCur = pSop; *pCur; pCur++ )
- if ( *pCur == '\n' )
- return (int)(*(pCur - 1) == 'x' || *(pCur - 1) == 'n');
- assert( 0 );
- return 0;
- }
- /**Function*************************************************************
- Synopsis []
- Description []
-
- SideEffects []
- SeeAlso []
- ***********************************************************************/
- int Abc_SopCheck( char * pSop, int nFanins )
- {
- char * pCubes, * pCubesOld;
- int fFound0 = 0, fFound1 = 0;
- // check the logic function of the node
- for ( pCubes = pSop; *pCubes; pCubes++ )
- {
- // get the end of the next cube
- for ( pCubesOld = pCubes; *pCubes != ' '; pCubes++ );
- // compare the distance
- if ( pCubes - pCubesOld != nFanins )
- {
- fprintf( stdout, "Abc_SopCheck: SOP has a mismatch between its cover size (%d) and its fanin number (%d).\n",
- (int)(ABC_PTRDIFF_T)(pCubes - pCubesOld), nFanins );
- return 0;
- }
- // check the output values for this cube
- pCubes++;
- if ( *pCubes == '0' )
- fFound0 = 1;
- else if ( *pCubes == '1' )
- fFound1 = 1;
- else if ( *pCubes != 'x' && *pCubes != 'n' )
- {
- fprintf( stdout, "Abc_SopCheck: SOP has a strange character (%c) in the output part of its cube.\n", *pCubes );
- return 0;
- }
- // check the last symbol (new line)
- pCubes++;
- if ( *pCubes != '\n' )
- {
- fprintf( stdout, "Abc_SopCheck: SOP has a cube without new line in the end.\n" );
- return 0;
- }
- }
- if ( fFound0 && fFound1 )
- {
- fprintf( stdout, "Abc_SopCheck: SOP has cubes in both phases.\n" );
- return 0;
- }
- return 1;
- }
- /**Function*************************************************************
- Synopsis [Derives SOP from the truth table representation.]
- Description [Truth table is expected to be in the hexadecimal notation.]
-
- SideEffects []
- SeeAlso []
- ***********************************************************************/
- char * Abc_SopFromTruthBin( char * pTruth )
- {
- char * pSopCover, * pCube;
- int nTruthSize, nVars, Digit, Length, Mint, i, b;
- Vec_Int_t * vMints;
- // get the number of variables
- nTruthSize = strlen(pTruth);
- nVars = Abc_Base2Log( nTruthSize );
- if ( nTruthSize != (1 << (nVars)) )
- {
- printf( "String %s does not look like a truth table of a %d-variable function.\n", pTruth, nVars );
- return NULL;
- }
- // collect the on-set minterms
- vMints = Vec_IntAlloc( 100 );
- for ( i = 0; i < nTruthSize; i++ )
- {
- if ( pTruth[i] >= '0' && pTruth[i] <= '1' )
- Digit = pTruth[i] - '0';
- else
- {
- Vec_IntFree( vMints );
- printf( "String %s does not look like a binary representation of the truth table.\n", pTruth );
- return NULL;
- }
- if ( Digit == 1 )
- Vec_IntPush( vMints, nTruthSize - 1 - i );
- }
- if ( Vec_IntSize( vMints ) == 0 || Vec_IntSize( vMints ) == nTruthSize )
- {
- Vec_IntFree( vMints );
- printf( "Cannot create constant function.\n" );
- return NULL;
- }
- // create the SOP representation of the minterms
- Length = Vec_IntSize(vMints) * (nVars + 3);
- pSopCover = ABC_ALLOC( char, Length + 1 );
- pSopCover[Length] = 0;
- Vec_IntForEachEntry( vMints, Mint, i )
- {
- pCube = pSopCover + i * (nVars + 3);
- for ( b = 0; b < nVars; b++ )
- if ( Mint & (1 << (nVars-1-b)) )
- // if ( Mint & (1 << b) )
- pCube[b] = '1';
- else
- pCube[b] = '0';
- pCube[nVars + 0] = ' ';
- pCube[nVars + 1] = '1';
- pCube[nVars + 2] = '\n';
- }
- Vec_IntFree( vMints );
- return pSopCover;
- }
- /**Function*************************************************************
- Synopsis [Derives SOP from the truth table representation.]
- Description [Truth table is expected to be in the hexadecimal notation.]
-
- SideEffects []
- SeeAlso []
- ***********************************************************************/
- char * Abc_SopFromTruthHex( char * pTruth )
- {
- char * pSopCover, * pCube;
- int nTruthSize, nVars, Digit, Length, Mint, i, b;
- Vec_Int_t * vMints;
- // get the number of variables
- nTruthSize = strlen(pTruth);
- nVars = (nTruthSize < 2) ? 2 : Abc_Base2Log(nTruthSize) + 2;
- if ( nTruthSize != (1 << (nVars-2)) )
- {
- printf( "String %s does not look like a truth table of a %d-variable function.\n", pTruth, nVars );
- return NULL;
- }
- // collect the on-set minterms
- vMints = Vec_IntAlloc( 100 );
- for ( i = 0; i < nTruthSize; i++ )
- {
- if ( pTruth[i] >= '0' && pTruth[i] <= '9' )
- Digit = pTruth[i] - '0';
- else if ( pTruth[i] >= 'a' && pTruth[i] <= 'f' )
- Digit = 10 + pTruth[i] - 'a';
- else if ( pTruth[i] >= 'A' && pTruth[i] <= 'F' )
- Digit = 10 + pTruth[i] - 'A';
- else
- {
- printf( "String %s does not look like a hexadecimal representation of the truth table.\n", pTruth );
- return NULL;
- }
- for ( b = 0; b < 4; b++ )
- if ( Digit & (1 << b) )
- Vec_IntPush( vMints, 4*(nTruthSize-1-i)+b );
- }
- // create the SOP representation of the minterms
- Length = Vec_IntSize(vMints) * (nVars + 3);
- pSopCover = ABC_ALLOC( char, Length + 1 );
- pSopCover[Length] = 0;
- Vec_IntForEachEntry( vMints, Mint, i )
- {
- pCube = pSopCover + i * (nVars + 3);
- for ( b = 0; b < nVars; b++ )
- // if ( Mint & (1 << (nVars-1-b)) )
- if ( Mint & (1 << b) )
- pCube[b] = '1';
- else
- pCube[b] = '0';
- pCube[nVars + 0] = ' ';
- pCube[nVars + 1] = '1';
- pCube[nVars + 2] = '\n';
- }
- /*
- // create TT representation
- {
- extern void Bdc_ManDecomposeTest( unsigned uTruth, int nVars );
- unsigned uTruth = 0;
- int nVarsAll = 4;
- assert( nVarsAll == 4 );
- assert( nVars <= nVarsAll );
- Vec_IntForEachEntry( vMints, Mint, i )
- uTruth |= (1 << Mint);
- // uTruth = uTruth | (uTruth << 8) | (uTruth << 16) | (uTruth << 24);
- uTruth = uTruth | (uTruth << 16);
- Bdc_ManDecomposeTest( uTruth, nVarsAll );
- }
- */
- Vec_IntFree( vMints );
- return pSopCover;
- }
- /**Function*************************************************************
- Synopsis [Creates one encoder node.]
- Description [Produces MV-SOP for BLIF-MV representation.]
-
- SideEffects []
- SeeAlso []
- ***********************************************************************/
- char * Abc_SopEncoderPos( Mem_Flex_t * pMan, int iValue, int nValues )
- {
- char Buffer[32];
- assert( iValue < nValues );
- sprintf( Buffer, "d0\n%d 1\n", iValue );
- return Abc_SopRegister( pMan, Buffer );
- }
- /**Function*************************************************************
- Synopsis [Creates one encoder node.]
- Description [Produces MV-SOP for BLIF-MV representation.]
-
- SideEffects []
- SeeAlso []
- ***********************************************************************/
- char * Abc_SopEncoderLog( Mem_Flex_t * pMan, int iBit, int nValues )
- {
- char * pResult;
- Vec_Str_t * vSop;
- int v, Counter, fFirst = 1, nBits = Abc_Base2Log(nValues);
- assert( iBit < nBits );
- // count the number of literals
- Counter = 0;
- for ( v = 0; v < nValues; v++ )
- Counter += ( (v & (1 << iBit)) > 0 );
- // create the cover
- vSop = Vec_StrAlloc( 100 );
- Vec_StrPrintStr( vSop, "d0\n" );
- if ( Counter > 1 )
- Vec_StrPrintStr( vSop, "(" );
- for ( v = 0; v < nValues; v++ )
- if ( v & (1 << iBit) )
- {
- if ( fFirst )
- fFirst = 0;
- else
- Vec_StrPush( vSop, ',' );
- Vec_StrPrintNum( vSop, v );
- }
- if ( Counter > 1 )
- Vec_StrPrintStr( vSop, ")" );
- Vec_StrPrintStr( vSop, " 1\n" );
- Vec_StrPush( vSop, 0 );
- pResult = Abc_SopRegister( pMan, Vec_StrArray(vSop) );
- Vec_StrFree( vSop );
- return pResult;
- }
- /**Function*************************************************************
- Synopsis [Creates the decoder node.]
- Description [Produces MV-SOP for BLIF-MV representation.]
-
- SideEffects []
- SeeAlso []
- ***********************************************************************/
- char * Abc_SopDecoderPos( Mem_Flex_t * pMan, int nValues )
- {
- char * pResult;
- Vec_Str_t * vSop;
- int i, k;
- assert( nValues > 1 );
- vSop = Vec_StrAlloc( 100 );
- for ( i = 0; i < nValues; i++ )
- {
- for ( k = 0; k < nValues; k++ )
- {
- if ( k == i )
- Vec_StrPrintStr( vSop, "1 " );
- else
- Vec_StrPrintStr( vSop, "- " );
- }
- Vec_StrPrintNum( vSop, i );
- Vec_StrPush( vSop, '\n' );
- }
- Vec_StrPush( vSop, 0 );
- pResult = Abc_SopRegister( pMan, Vec_StrArray(vSop) );
- Vec_StrFree( vSop );
- return pResult;
- }
- /**Function*************************************************************
- Synopsis [Creates the decover node.]
- Description [Produces MV-SOP for BLIF-MV representation.]
-
- SideEffects []
- SeeAlso []
- ***********************************************************************/
- char * Abc_SopDecoderLog( Mem_Flex_t * pMan, int nValues )
- {
- char * pResult;
- Vec_Str_t * vSop;
- int i, b, nBits = Abc_Base2Log(nValues);
- assert( nValues > 1 && nValues <= (1<<nBits) );
- vSop = Vec_StrAlloc( 100 );
- for ( i = 0; i < nValues; i++ )
- {
- for ( b = 0; b < nBits; b++ )
- {
- Vec_StrPrintNum( vSop, (int)((i & (1 << b)) > 0) );
- Vec_StrPush( vSop, ' ' );
- }
- Vec_StrPrintNum( vSop, i );
- Vec_StrPush( vSop, '\n' );
- }
- Vec_StrPush( vSop, 0 );
- pResult = Abc_SopRegister( pMan, Vec_StrArray(vSop) );
- Vec_StrFree( vSop );
- return pResult;
- }
- /**Function*************************************************************
- Synopsis [Computes truth table of the node.]
-
- Description []
-
- SideEffects []
- SeeAlso []
- ***********************************************************************/
- word Abc_SopToTruth( char * pSop, int nInputs )
- {
- static word Truth[8] = {
- ABC_CONST(0xAAAAAAAAAAAAAAAA),
- ABC_CONST(0xCCCCCCCCCCCCCCCC),
- ABC_CONST(0xF0F0F0F0F0F0F0F0),
- ABC_CONST(0xFF00FF00FF00FF00),
- ABC_CONST(0xFFFF0000FFFF0000),
- ABC_CONST(0xFFFFFFFF00000000),
- ABC_CONST(0x0000000000000000),
- ABC_CONST(0xFFFFFFFFFFFFFFFF)
- };
- word Cube, Result = 0;
- int v, lit = 0;
- int nVars = Abc_SopGetVarNum(pSop);
- assert( nVars >= 0 && nVars <= 6 );
- assert( nVars == nInputs );
- do {
- Cube = Truth[7];
- for ( v = 0; v < nVars; v++, lit++ )
- {
- if ( pSop[lit] == '1' )
- Cube &= Truth[v];
- else if ( pSop[lit] == '0' )
- Cube &= ~Truth[v];
- else if ( pSop[lit] != '-' )
- assert( 0 );
- }
- Result |= Cube;
- assert( pSop[lit] == ' ' );
- lit++;
- lit++;
- assert( pSop[lit] == '\n' );
- lit++;
- } while ( pSop[lit] );
- if ( Abc_SopIsComplement(pSop) )
- Result = ~Result;
- return Result;
- }
- /**Function*************************************************************
- Synopsis [Computes truth table of the node.]
-
- Description []
-
- SideEffects []
- SeeAlso []
- ***********************************************************************/
- void Abc_SopToTruth7( char * pSop, int nInputs, word r[2] )
- {
- static word Truth[7][2] = {
- {ABC_CONST(0xAAAAAAAAAAAAAAAA),ABC_CONST(0xAAAAAAAAAAAAAAAA)},
- {ABC_CONST(0xCCCCCCCCCCCCCCCC),ABC_CONST(0xCCCCCCCCCCCCCCCC)},
- {ABC_CONST(0xF0F0F0F0F0F0F0F0),ABC_CONST(0xF0F0F0F0F0F0F0F0)},
- {ABC_CONST(0xFF00FF00FF00FF00),ABC_CONST(0xFF00FF00FF00FF00)},
- {ABC_CONST(0xFFFF0000FFFF0000),ABC_CONST(0xFFFF0000FFFF0000)},
- {ABC_CONST(0xFFFFFFFF00000000),ABC_CONST(0xFFFFFFFF00000000)},
- {ABC_CONST(0x0000000000000000),ABC_CONST(0xFFFFFFFFFFFFFFFF)},
- };
- word Cube[2];
- int v, lit = 0;
- int nVars = Abc_SopGetVarNum(pSop);
- assert( nVars >= 0 && nVars <= 7 );
- assert( nVars == nInputs );
- r[0] = r[1] = 0;
- do {
- Cube[0] = Cube[1] = ~(word)0;
- for ( v = 0; v < nVars; v++, lit++ )
- {
- if ( pSop[lit] == '1' )
- {
- Cube[0] &= Truth[v][0];
- Cube[1] &= Truth[v][1];
- }
- else if ( pSop[lit] == '0' )
- {
- Cube[0] &= ~Truth[v][0];
- Cube[1] &= ~Truth[v][1];
- }
- else if ( pSop[lit] != '-' )
- assert( 0 );
- }
- r[0] |= Cube[0];
- r[1] |= Cube[1];
- assert( pSop[lit] == ' ' );
- lit++;
- lit++;
- assert( pSop[lit] == '\n' );
- lit++;
- } while ( pSop[lit] );
- if ( Abc_SopIsComplement(pSop) )
- {
- r[0] = ~r[0];
- r[1] = ~r[1];
- }
- }
- /**Function*************************************************************
- Synopsis [Computes truth table of the node.]
-
- Description []
-
- SideEffects []
- SeeAlso []
- ***********************************************************************/
- void Abc_SopToTruthBig( char * pSop, int nInputs, word ** pVars, word * pCube, word * pRes )
- {
- int nVars = Abc_SopGetVarNum(pSop);
- int nWords = nVars <= 6 ? 1 : 1 << (nVars-6);
- int v, i, lit = 0;
- assert( nVars >= 0 && nVars <= 16 );
- assert( nVars == nInputs );
- for ( i = 0; i < nWords; i++ )
- pRes[i] = 0;
- do {
- for ( i = 0; i < nWords; i++ )
- pCube[i] = ~(word)0;
- for ( v = 0; v < nVars; v++, lit++ )
- {
- if ( pSop[lit] == '1' )
- {
- for ( i = 0; i < nWords; i++ )
- pCube[i] &= pVars[v][i];
- }
- else if ( pSop[lit] == '0' )
- {
- for ( i = 0; i < nWords; i++ )
- pCube[i] &= ~pVars[v][i];
- }
- else if ( pSop[lit] != '-' )
- assert( 0 );
- }
- for ( i = 0; i < nWords; i++ )
- pRes[i] |= pCube[i];
- assert( pSop[lit] == ' ' );
- lit++;
- lit++;
- assert( pSop[lit] == '\n' );
- lit++;
- } while ( pSop[lit] );
- if ( Abc_SopIsComplement(pSop) )
- {
- for ( i = 0; i < nWords; i++ )
- pRes[i] = ~pRes[i];
- }
- }
- ////////////////////////////////////////////////////////////////////////
- /// END OF FILE ///
- ////////////////////////////////////////////////////////////////////////
- ABC_NAMESPACE_IMPL_END