Version abc50904

1 files changed, 0 insertions, 345 deletions

diff --git a/src/sop/mvc/mvcLits.c b/src/sop/mvc/mvcLits.c
deleted file mode 100644
index 98211719..00000000
--- a/src/sop/mvc/mvcLits.c
+++ /dev/null
@@ -1,345 +0,0 @@
-/**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"
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFITIONS                           ///
-////////////////////////////////////////////////////////////////////////
-
-/**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                                ///
-////////////////////////////////////////////////////////////////////////
-
-