/**CFile****************************************************************
FileName [mvcLits.c]
PackageName [MVSIS 2.0: Multi-valued logic synthesis system.]
Synopsis [Literal counting/updating procedures.]
Author [MVSIS Group]
Affiliation [UC Berkeley]
Date [Ver. 1.0. Started - February 1, 2003.]
Revision [$Id: mvcLits.c,v 1.4 2003/04/03 06:31:50 alanmi Exp $]
***********************************************************************/
#include "mvc.h"
ABC_NAMESPACE_IMPL_START
////////////////////////////////////////////////////////////////////////
/// DECLARATIONS ///
////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////
/// FUNCTION DEFINITIONS ///
////////////////////////////////////////////////////////////////////////
/**Function*************************************************************
Synopsis [Find the any literal that occurs more than once.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
int Mvc_CoverAnyLiteral( Mvc_Cover_t * pCover, Mvc_Cube_t * pMask )
{
Mvc_Cube_t * pCube;
int nWord, nBit, i;
int nLitsCur;
int fUseFirst = 0;
// go through each literal
if ( fUseFirst )
{
for ( i = 0; i < pCover->nBits; i++ )
if ( !pMask || Mvc_CubeBitValue(pMask,i) )
{
// get the word and bit of this literal
nWord = Mvc_CubeWhichWord(i);
nBit = Mvc_CubeWhichBit(i);
// go through all the cubes
nLitsCur = 0;
Mvc_CoverForEachCube( pCover, pCube )
if ( pCube->pData[nWord] & (1<<nBit) )
{
nLitsCur++;
if ( nLitsCur > 1 )
return i;
}
}
}
else
{
for ( i = pCover->nBits - 1; i >=0; i-- )
if ( !pMask || Mvc_CubeBitValue(pMask,i) )
{
// get the word and bit of this literal
nWord = Mvc_CubeWhichWord(i);
nBit = Mvc_CubeWhichBit(i);
// go through all the cubes
nLitsCur = 0;
Mvc_CoverForEachCube( pCover, pCube )
if ( pCube->pData[nWord] & (1<<nBit) )
{
nLitsCur++;
if ( nLitsCur > 1 )
return i;
}
}
}
return -1;
}
/**Function*************************************************************
Synopsis [Find the most often occurring literal.]
Description [Find the most often occurring literal among those
that occur more than once.]
SideEffects []
SeeAlso []
***********************************************************************/
int Mvc_CoverBestLiteral( Mvc_Cover_t * pCover, Mvc_Cube_t * pMask )
{
Mvc_Cube_t * pCube;
int nWord, nBit;
int i, iMax, nLitsMax, nLitsCur;
int fUseFirst = 1;
// go through each literal
iMax = -1;
nLitsMax = -1;
for ( i = 0; i < pCover->nBits; i++ )
if ( !pMask || Mvc_CubeBitValue(pMask,i) )
{
// get the word and bit of this literal
nWord = Mvc_CubeWhichWord(i);
nBit = Mvc_CubeWhichBit(i);
// go through all the cubes
nLitsCur = 0;
Mvc_CoverForEachCube( pCover, pCube )
if ( pCube->pData[nWord] & (1<<nBit) )
nLitsCur++;
// check if this is the best literal
if ( fUseFirst )
{
if ( nLitsMax < nLitsCur )
{
nLitsMax = nLitsCur;
iMax = i;
}
}
else
{
if ( nLitsMax <= nLitsCur )
{
nLitsMax = nLitsCur;
iMax = i;
}
}
}
if ( nLitsMax > 1 )
return iMax;
return -1;
}
/**Function*************************************************************
Synopsis [Find the most often occurring literal.]
Description [Find the most often occurring literal among those
that occur more than once.]
SideEffects []
SeeAlso []
***********************************************************************/
int Mvc_CoverWorstLiteral( Mvc_Cover_t * pCover, Mvc_Cube_t * pMask )
{
Mvc_Cube_t * pCube;
int nWord, nBit;
int i, iMin, nLitsMin, nLitsCur;
int fUseFirst = 1;
// go through each literal
iMin = -1;
nLitsMin = 1000000;
for ( i = 0; i < pCover->nBits; i++ )
if ( !pMask || Mvc_CubeBitValue(pMask,i) )
{
// get the word and bit of this literal
nWord = Mvc_CubeWhichWord(i);
nBit = Mvc_CubeWhichBit(i);
// go through all the cubes
nLitsCur = 0;
Mvc_CoverForEachCube( pCover, pCube )
if ( pCube->pData[nWord] & (1<<nBit) )
nLitsCur++;
// skip the literal that does not occur or occurs once
if ( nLitsCur < 2 )
continue;
// check if this is the best literal
if ( fUseFirst )
{
if ( nLitsMin > nLitsCur )
{
nLitsMin = nLitsCur;
iMin = i;
}
}
else
{
if ( nLitsMin >= nLitsCur )
{
nLitsMin = nLitsCur;
iMin = i;
}
}
}
if ( nLitsMin < 1000000 )
return iMin;
return -1;
}
/**Function*************************************************************
Synopsis []
Description []
SideEffects []
SeeAlso []
***********************************************************************/
Mvc_Cover_t * Mvc_CoverBestLiteralCover( Mvc_Cover_t * pCover, Mvc_Cover_t * pSimple )
{
Mvc_Cover_t * pCoverNew;
Mvc_Cube_t * pCubeNew;
Mvc_Cube_t * pCubeS;
int iLitBest;
// create the new cover
pCoverNew = Mvc_CoverClone( pCover );
// get the new cube
pCubeNew = Mvc_CubeAlloc( pCoverNew );
// clean the cube
Mvc_CubeBitClean( pCubeNew );
// get the first cube of pSimple
assert( Mvc_CoverReadCubeNum(pSimple) == 1 );
pCubeS = Mvc_CoverReadCubeHead( pSimple );
// find the best literal among those of pCubeS
iLitBest = Mvc_CoverBestLiteral( pCover, pCubeS );
// insert this literal into the cube
Mvc_CubeBitInsert( pCubeNew, iLitBest );
// add the cube to the cover
Mvc_CoverAddCubeTail( pCoverNew, pCubeNew );
return pCoverNew;
}
/**Function*************************************************************
Synopsis []
Description []
SideEffects []
SeeAlso []
***********************************************************************/
int Mvc_CoverFirstCubeFirstLit( Mvc_Cover_t * pCover )
{
Mvc_Cube_t * pCube;
int iBit, Value;
// get the first cube
pCube = Mvc_CoverReadCubeHead( pCover );
// get the first literal
Mvc_CubeForEachBit( pCover, pCube, iBit, Value )
if ( Value )
return iBit;
return -1;
}
/**Function*************************************************************
Synopsis [Returns the number of literals in the cover.]
Description [Allocates storage for literal counters and fills it up
using the current information.]
SideEffects []
SeeAlso []
***********************************************************************/
int Mvc_CoverCountLiterals( Mvc_Cover_t * pCover )
{
Mvc_Cube_t * pCube;
int nWord, nBit;
int i, CounterTot, CounterCur;
// allocate/clean the storage for literals
// Mvc_CoverAllocateArrayLits( pCover );
// memset( pCover->pLits, 0, pCover->nBits * sizeof(int) );
// go through each literal
CounterTot = 0;
for ( i = 0; i < pCover->nBits; i++ )
{
// get the word and bit of this literal
nWord = Mvc_CubeWhichWord(i);
nBit = Mvc_CubeWhichBit(i);
// go through all the cubes
CounterCur = 0;
Mvc_CoverForEachCube( pCover, pCube )
if ( pCube->pData[nWord] & (1<<nBit) )
CounterCur++;
CounterTot += CounterCur;
}
return CounterTot;
}
/**Function*************************************************************
Synopsis [Returns the number of literals in the cover.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
int Mvc_CoverIsOneLiteral( Mvc_Cover_t * pCover )
{
Mvc_Cube_t * pCube;
int iBit, Counter, Value;
if ( Mvc_CoverReadCubeNum(pCover) != 1 )
return 0;
pCube = Mvc_CoverReadCubeHead(pCover);
// count literals
Counter = 0;
Mvc_CubeForEachBit( pCover, pCube, iBit, Value )
{
if ( Value )
{
if ( Counter++ )
return 0;
}
}
return 1;
}
////////////////////////////////////////////////////////////////////////
/// END OF FILE ///
////////////////////////////////////////////////////////////////////////
ABC_NAMESPACE_IMPL_END