mvc.h File Reference

#include <stdio.h>
#include "misc/extra/extra.h"

Go to the source code of this file.

Data Structures
struct	MvcCubeStruct
struct	MvcListStruct
struct	MvcCoverStruct
struct	MvcDataStruct
struct	MvcManagerStruct

Macros
#define	BITS_PER_WORD   32
	INCLUDES ///. More...
#define	BITS_PER_WORD_MINUS   31
#define	BITS_PER_WORD_LOG   5
#define	BITS_DISJOINT   ((Mvc_CubeWord_t)0x55555555)
#define	BITS_FULL   ((Mvc_CubeWord_t)0xffffffff)
#define	Mvc_CubeReadNext(Cube)   ((Cube)->pNext)
	MACRO DEFINITIONS ///. More...
#define	Mvc_CubeReadNextP(Cube)   (&(Cube)->pNext)
#define	Mvc_CubeReadLast(Cube)   ((Cube)->iLast)
#define	Mvc_CubeReadSize(Cube)   ((Cube)->nOnes)
#define	Mvc_CubeSetNext(Cube, Next)   ((Cube)->pNext = (Next))
#define	Mvc_CubeSetLast(Cube, Last)   ((Cube)->iLast = (Last))
#define	Mvc_CubeSetSize(Cube, Size)   ((Cube)->nOnes = (Size))
#define	Mvc_Cube1Words(Cube)   ((Cube)->iLast == 0)
#define	Mvc_Cube2Words(Cube)   ((Cube)->iLast == 1)
#define	Mvc_CubeNWords(Cube)   ((Cube)->iLast > 1)
#define	Mvc_CubeWhichWord(Bit)   ((Bit) >> BITS_PER_WORD_LOG)
#define	Mvc_CubeWhichBit(Bit)   ((Bit) & BITS_PER_WORD_MINUS)
#define	Mvc_CubeBitValue(Cube, Bit)   (((Cube)->pData[Mvc_CubeWhichWord(Bit)] & (((Mvc_CubeWord_t)1)<<(Mvc_CubeWhichBit(Bit)))) > 0)
#define	Mvc_CubeBitInsert(Cube, Bit)   ((Cube)->pData[Mvc_CubeWhichWord(Bit)] |= (((Mvc_CubeWord_t)1)<<(Mvc_CubeWhichBit(Bit))))
#define	Mvc_CubeBitRemove(Cube, Bit)   ((Cube)->pData[Mvc_CubeWhichWord(Bit)] &= ~(((Mvc_CubeWord_t)1)<<(Mvc_CubeWhichBit(Bit))))
#define	Mvc_CubeVarValue(Cube, Var)   (((Cube)->pData[Mvc_CubeWhichWord(2*(Var))] >> (Mvc_CubeWhichBit(2*(Var)))) & ((Mvc_CubeWord_t)3))
#define	Mvc_Cube1BitClean(Cube)   ((Cube)->pData[0] = 0)
#define	Mvc_Cube2BitClean(Cube)
#define	Mvc_CubeNBitClean(Cube)
#define	Mvc_CubeBitCleanUnused(Cube)   ((Cube)->pData[(Cube)->iLast] &= (BITS_FULL >> (Cube)->nUnused))
#define	Mvc_Cube1BitFill(Cube)   (Cube)->pData[0] = (BITS_FULL >> (Cube)->nUnused);
#define	Mvc_Cube2BitFill(Cube)
#define	Mvc_CubeNBitFill(Cube)
#define	Mvc_Cube1BitNot(Cube)   ((Cube)->pData[0] ^= (BITS_FULL >> (Cube)->nUnused))
#define	Mvc_Cube2BitNot(Cube)
#define	Mvc_CubeNBitNot(Cube)
#define	Mvc_Cube1BitCopy(Cube1, Cube2)   (((Cube1)->pData[0]) = ((Cube2)->pData[0]))
#define	Mvc_Cube2BitCopy(Cube1, Cube2)
#define	Mvc_CubeNBitCopy(Cube1, Cube2)
#define	Mvc_Cube1BitOr(CubeR, Cube1, Cube2)   (((CubeR)->pData[0]) = ((Cube1)->pData[0] | (Cube2)->pData[0]))
#define	Mvc_Cube2BitOr(CubeR, Cube1, Cube2)
#define	Mvc_CubeNBitOr(CubeR, Cube1, Cube2)
#define	Mvc_Cube1BitExor(CubeR, Cube1, Cube2)   (((CubeR)->pData[0]) = ((Cube1)->pData[0] ^ (Cube2)->pData[0]))
#define	Mvc_Cube2BitExor(CubeR, Cube1, Cube2)
#define	Mvc_CubeNBitExor(CubeR, Cube1, Cube2)
#define	Mvc_Cube1BitAnd(CubeR, Cube1, Cube2)   (((CubeR)->pData[0]) = ((Cube1)->pData[0] & (Cube2)->pData[0]))
#define	Mvc_Cube2BitAnd(CubeR, Cube1, Cube2)
#define	Mvc_CubeNBitAnd(CubeR, Cube1, Cube2)
#define	Mvc_Cube1BitSharp(CubeR, Cube1, Cube2)   (((CubeR)->pData[0]) = ((Cube1)->pData[0] & ~((Cube2)->pData[0])))
#define	Mvc_Cube2BitSharp(CubeR, Cube1, Cube2)
#define	Mvc_CubeNBitSharp(CubeR, Cube1, Cube2)
#define	Mvc_Cube1BitEmpty(Res, Cube)   (Res = ((Cube)->pData[0] == 0))
#define	Mvc_Cube2BitEmpty(Res, Cube)   (Res = ((Cube)->pData[0] == 0 && (Cube)->pData[1] == 0))
#define	Mvc_CubeNBitEmpty(Res, Cube)
#define	Mvc_Cube1BitEqual(Res, Cube1, Cube2)   (Res = (((Cube1)->pData[0]) == ((Cube2)->pData[0])))
#define	Mvc_Cube2BitEqual(Res, Cube1, Cube2)
#define	Mvc_CubeNBitEqual(Res, Cube1, Cube2)
#define	Mvc_Cube1BitLess(Res, Cube1, Cube2)   (Res = (((Cube1)->pData[0]) < ((Cube2)->pData[0])))
#define	Mvc_Cube2BitLess(Res, Cube1, Cube2)
#define	Mvc_CubeNBitLess(Res, Cube1, Cube2)
#define	Mvc_Cube1BitMore(Res, Cube1, Cube2)   (Res = (((Cube1)->pData[0]) > ((Cube2)->pData[0])))
#define	Mvc_Cube2BitMore(Res, Cube1, Cube2)
#define	Mvc_CubeNBitMore(Res, Cube1, Cube2)
#define	Mvc_Cube1BitNotImpl(Res, Cube1, Cube2)   (Res = (((Cube1)->pData[0]) & ~((Cube2)->pData[0])))
#define	Mvc_Cube2BitNotImpl(Res, Cube1, Cube2)
#define	Mvc_CubeNBitNotImpl(Res, Cube1, Cube2)
#define	Mvc_Cube1BitDisjoint(Res, Cube1, Cube2)   (Res = ((((Cube1)->pData[0]) & ((Cube2)->pData[0])) == 0 ))
#define	Mvc_Cube2BitDisjoint(Res, Cube1, Cube2)
#define	Mvc_CubeNBitDisjoint(Res, Cube1, Cube2)
#define	Mvc_Cube1BitEqualUnderMask(Res, Cube1, Cube2, Mask)   (Res = ((((Cube1)->pData[0]) & ((Mask)->pData[0])) == (((Cube2)->pData[0]) & ((Mask)->pData[0]))))
#define	Mvc_Cube2BitEqualUnderMask(Res, Cube1, Cube2, Mask)
#define	Mvc_CubeNBitEqualUnderMask(Res, Cube1, Cube2, Mask)
#define	Mvc_Cube1BitEqualOutsideMask(Res, Cube1, Cube2, Mask)   (Res = ((((Cube1)->pData[0]) | ((Mask)->pData[0])) == (((Cube2)->pData[0]) | ((Mask)->pData[0]))))
#define	Mvc_Cube2BitEqualOutsideMask(Res, Cube1, Cube2, Mask)
#define	Mvc_CubeNBitEqualOutsideMask(Res, Cube1, Cube2, Mask)
#define	Mvc_Cube1BitIntersectUnderMask(Res, Cube1, Cube2, Mask)   (Res = ((((Cube1)->pData[0]) & ((Cube2)->pData[0]) & ((Mask)->pData[0])) > 0))
#define	Mvc_Cube2BitIntersectUnderMask(Res, Cube1, Cube2, Mask)
#define	Mvc_CubeNBitIntersectUnderMask(Res, Cube1, Cube2, Mask)
#define	Mvc_Cube1BitNotImplUnderMask(Res, Cube1, Cube2, Mask)   (Res = (((Mask)->pData[0]) & ((Cube1)->pData[0]) & ~((Cube2)->pData[0])))
#define	Mvc_Cube2BitNotImplUnderMask(Res, Cube1, Cube2, Mask)
#define	Mvc_CubeNBitNotImplUnderMask(Res, Cube1, Cube2, Mask)
#define	Mvc_CubeBitClean(Cube)
#define	Mvc_CubeBitFill(Cube)
#define	Mvc_CubeBitNot(Cube)
#define	Mvc_CubeBitCopy(Cube1, Cube2)
#define	Mvc_CubeBitOr(CubeR, Cube1, Cube2)
#define	Mvc_CubeBitExor(CubeR, Cube1, Cube2)
#define	Mvc_CubeBitAnd(CubeR, Cube1, Cube2)
#define	Mvc_CubeBitSharp(CubeR, Cube1, Cube2)
#define	Mvc_CubeBitEmpty(Res, Cube)
#define	Mvc_CubeBitEqual(Res, Cube1, Cube2)
#define	Mvc_CubeBitLess(Res, Cube1, Cube2)
#define	Mvc_CubeBitMore(Res, Cube1, Cube2)
#define	Mvc_CubeBitNotImpl(Res, Cube1, Cube2)
#define	Mvc_CubeBitDisjoint(Res, Cube1, Cube2)
#define	Mvc_CubeBitEqualUnderMask(Res, Cube1, Cube2, Mask)
#define	Mvc_CubeBitEqualOutsideMask(Res, Cube1, Cube2, Mask)
#define	Mvc_CubeBitIntersectUnderMask(Res, Cube1, Cube2, Mask)
#define	Mvc_CubeBitNotImplUnderMask(Res, Cube1, Cube2, Mask)
#define	Mvc_ListAddCubeHead(pList, pCube)
#define	Mvc_ListAddCubeTail(pList, pCube)
#define	Mvc_ListDeleteCube(pList, pPrev, pCube)
#define	Mvc_CoverAddCubeHead(pCover, pCube)
#define	Mvc_CoverAddCubeTail(pCover, pCube)
#define	Mvc_CoverDeleteCube(pCover, pPrev, pCube)
#define	Mvc_ListForEachCube(List, Cube)
#define	Mvc_ListForEachCubeSafe(List, Cube, Cube2)
#define	Mvc_CoverForEachCube(Cover, Cube)
#define	Mvc_CoverForEachCubeWithIndex(Cover, Cube, Index)
#define	Mvc_CoverForEachCubeSafe(Cover, Cube, Cube2)
#define	Mvc_CoverForEachCubeStart(Start, Cube)
#define	Mvc_CoverForEachCubeStartSafe(Start, Cube, Cube2)
#define	Mvc_CubeForEachBit(Cover, Cube, iBit, Value)
#define	Mvc_CubeForEachVarValue(Cover, Cube, iVar, Value)
#define	MEM_ALLOC(Manager, Type, Size)   ((Type *)ABC_ALLOC( char, (Size) * sizeof(Type) ))
#define	MEM_FREE(Manager, Type, Size, Pointer)   if ( Pointer ) { ABC_FREE(Pointer); Pointer = NULL; }

Typedefs
typedef unsigned int	Mvc_CubeWord_t
	STRUCTURE DEFINITIONS ///. More...
typedef struct MvcCubeStruct	Mvc_Cube_t
typedef struct MvcListStruct	Mvc_List_t
typedef struct MvcCoverStruct	Mvc_Cover_t
typedef struct MvcDataStruct	Mvc_Data_t
typedef struct MvcManagerStruct	Mvc_Manager_t

Functions
int	Mvc_CoverReadWordNum (Mvc_Cover_t *pCover)
	FUNCTION DEFINITIONS ///. More...
int	Mvc_CoverReadBitNum (Mvc_Cover_t *pCover)
int	Mvc_CoverReadCubeNum (Mvc_Cover_t *pCover)
Mvc_Cube_t *	Mvc_CoverReadCubeHead (Mvc_Cover_t *pCover)
Mvc_Cube_t *	Mvc_CoverReadCubeTail (Mvc_Cover_t *pCover)
Mvc_List_t *	Mvc_CoverReadCubeList (Mvc_Cover_t *pCover)
int	Mvc_ListReadCubeNum (Mvc_List_t *pList)
Mvc_Cube_t *	Mvc_ListReadCubeHead (Mvc_List_t *pList)
Mvc_Cube_t *	Mvc_ListReadCubeTail (Mvc_List_t *pList)
void	Mvc_CoverSetCubeNum (Mvc_Cover_t *pCover, int nItems)
void	Mvc_CoverSetCubeHead (Mvc_Cover_t *pCover, Mvc_Cube_t *pCube)
void	Mvc_CoverSetCubeTail (Mvc_Cover_t *pCover, Mvc_Cube_t *pCube)
void	Mvc_CoverSetCubeList (Mvc_Cover_t *pCover, Mvc_List_t *pList)
int	Mvc_CoverIsEmpty (Mvc_Cover_t *pCover)
int	Mvc_CoverIsTautology (Mvc_Cover_t *pCover)
int	Mvc_CoverIsBinaryBuffer (Mvc_Cover_t *pCover)
void	Mvc_CoverMakeEmpty (Mvc_Cover_t *pCover)
void	Mvc_CoverMakeTautology (Mvc_Cover_t *pCover)
Mvc_Cover_t *	Mvc_CoverCreateEmpty (Mvc_Cover_t *pCover)
Mvc_Cover_t *	Mvc_CoverCreateTautology (Mvc_Cover_t *pCover)
Mvc_Cover_t *	Mvc_CoverAlloc (Mvc_Manager_t *pMem, int nBits)
	DECLARATIONS ///. More...
Mvc_Cover_t *	Mvc_CoverCreateConst (Mvc_Manager_t *pMem, int nBits, int Phase)
Mvc_Cover_t *	Mvc_CoverClone (Mvc_Cover_t *pCover)
Mvc_Cover_t *	Mvc_CoverDup (Mvc_Cover_t *pCover)
void	Mvc_CoverFree (Mvc_Cover_t *pCover)
void	Mvc_CoverAllocateMask (Mvc_Cover_t *pCover)
void	Mvc_CoverAllocateArrayLits (Mvc_Cover_t *pCover)
void	Mvc_CoverAllocateArrayCubes (Mvc_Cover_t *pCover)
void	Mvc_CoverDeallocateMask (Mvc_Cover_t *pCover)
void	Mvc_CoverDeallocateArrayLits (Mvc_Cover_t *pCover)
Mvc_Cube_t *	Mvc_CubeAlloc (Mvc_Cover_t *pCover)
	DECLARATIONS ///. More...
Mvc_Cube_t *	Mvc_CubeDup (Mvc_Cover_t *pCover, Mvc_Cube_t *pCube)
void	Mvc_CubeFree (Mvc_Cover_t *pCover, Mvc_Cube_t *pCube)
void	Mvc_CubeBitRemoveDcs (Mvc_Cube_t *pCube)
int	Mvc_CubeCompareInt (Mvc_Cube_t *pC1, Mvc_Cube_t *pC2, Mvc_Cube_t *pMask)
	DECLARATIONS ///. More...
int	Mvc_CubeCompareSizeAndInt (Mvc_Cube_t *pC1, Mvc_Cube_t *pC2, Mvc_Cube_t *pMask)
int	Mvc_CubeCompareIntUnderMask (Mvc_Cube_t *pC1, Mvc_Cube_t *pC2, Mvc_Cube_t *pMask)
int	Mvc_CubeCompareIntOutsideMask (Mvc_Cube_t *pC1, Mvc_Cube_t *pC2, Mvc_Cube_t *pMask)
int	Mvc_CubeCompareIntOutsideAndUnderMask (Mvc_Cube_t *pC1, Mvc_Cube_t *pC2, Mvc_Cube_t *pMask)
Mvc_Cover_t *	Mvc_CoverDivisor (Mvc_Cover_t *pCover)
	FUNCTION DEFINITIONS ///. More...
void	Mvc_CoverDivide (Mvc_Cover_t *pCover, Mvc_Cover_t *pDiv, Mvc_Cover_t **ppQuo, Mvc_Cover_t **ppRem)
	FUNCTION DEFINITIONS ///. More...
void	Mvc_CoverDivideInternal (Mvc_Cover_t *pCover, Mvc_Cover_t *pDiv, Mvc_Cover_t **ppQuo, Mvc_Cover_t **ppRem)
void	Mvc_CoverDivideByLiteral (Mvc_Cover_t *pCover, Mvc_Cover_t *pDiv, Mvc_Cover_t **ppQuo, Mvc_Cover_t **ppRem)
void	Mvc_CoverDivideByCube (Mvc_Cover_t *pCover, Mvc_Cover_t *pDiv, Mvc_Cover_t **ppQuo, Mvc_Cover_t **ppRem)
void	Mvc_CoverDivideByLiteralQuo (Mvc_Cover_t *pCover, int iLit)
void	Mvc_ListAddCubeHead_ (Mvc_List_t *pList, Mvc_Cube_t *pCube)
	DECLARATIONS ///. More...
void	Mvc_ListAddCubeTail_ (Mvc_List_t *pList, Mvc_Cube_t *pCube)
void	Mvc_ListDeleteCube_ (Mvc_List_t *pList, Mvc_Cube_t *pPrev, Mvc_Cube_t *pCube)
void	Mvc_CoverAddCubeHead_ (Mvc_Cover_t *pCover, Mvc_Cube_t *pCube)
void	Mvc_CoverAddCubeTail_ (Mvc_Cover_t *pCover, Mvc_Cube_t *pCube)
void	Mvc_CoverDeleteCube_ (Mvc_Cover_t *pCover, Mvc_Cube_t *pPrev, Mvc_Cube_t *pCube)
void	Mvc_CoverAddDupCubeHead (Mvc_Cover_t *pCover, Mvc_Cube_t *pCube)
void	Mvc_CoverAddDupCubeTail (Mvc_Cover_t *pCover, Mvc_Cube_t *pCube)
void	Mvc_CoverAddLiteralsOfCube (Mvc_Cover_t *pCover, Mvc_Cube_t *pCube)
void	Mvc_CoverDeleteLiteralsOfCube (Mvc_Cover_t *pCover, Mvc_Cube_t *pCube)
void	Mvc_CoverList2Array (Mvc_Cover_t *pCover)
void	Mvc_CoverArray2List (Mvc_Cover_t *pCover)
Mvc_Cube_t *	Mvc_ListGetTailFromHead (Mvc_Cube_t *pHead)
void	Mvc_CoverPrint (Mvc_Cover_t *pCover)
	FUNCTION DEFINITIONS ///. More...
void	Mvc_CubePrint (Mvc_Cover_t *pCover, Mvc_Cube_t *pCube)
void	Mvc_CoverPrintMv (Mvc_Data_t *pData, Mvc_Cover_t *pCover)
void	Mvc_CubePrintMv (Mvc_Data_t *pData, Mvc_Cover_t *pCover, Mvc_Cube_t *pCube)
void	Mvc_CoverSort (Mvc_Cover_t *pCover, Mvc_Cube_t *pMask, int(*pCompareFunc)(Mvc_Cube_t *, Mvc_Cube_t *, Mvc_Cube_t *))
	FuNCTION DEFINITIONS ///. More...
void	Mvc_CoverSupport (Mvc_Cover_t *pCover, Mvc_Cube_t *pSupp)
	FUNCTION DEFINITIONS ///. More...
int	Mvc_CoverSupportSizeBinary (Mvc_Cover_t *pCover)
int	Mvc_CoverSupportVarBelongs (Mvc_Cover_t *pCover, int iVar)
void	Mvc_CoverCommonCube (Mvc_Cover_t *pCover, Mvc_Cube_t *pComCube)
int	Mvc_CoverIsCubeFree (Mvc_Cover_t *pCover)
void	Mvc_CoverMakeCubeFree (Mvc_Cover_t *pCover)
Mvc_Cover_t *	Mvc_CoverCommonCubeCover (Mvc_Cover_t *pCover)
int	Mvc_CoverCheckSuppContainment (Mvc_Cover_t *pCover1, Mvc_Cover_t *pCover2)
int	Mvc_CoverSetCubeSizes (Mvc_Cover_t *pCover)
int	Mvc_CoverGetCubeSize (Mvc_Cube_t *pCube)
int	Mvc_CoverCountCubePairDiffs (Mvc_Cover_t *pCover, unsigned char pDiffs[])
Mvc_Cover_t *	Mvc_CoverRemap (Mvc_Cover_t *pCover, int *pVarsRem, int nVarsRem)
void	Mvc_CoverInverse (Mvc_Cover_t *pCover)
Mvc_Cover_t *	Mvc_CoverRemoveDontCareLits (Mvc_Cover_t *pCover)
Mvc_Cover_t *	Mvc_CoverCofactor (Mvc_Cover_t *pCover, int iValue, int iValueOther)
Mvc_Cover_t *	Mvc_CoverFlipVar (Mvc_Cover_t *pCover, int iValue0, int iValue1)
Mvc_Cover_t *	Mvc_CoverUnivQuantify (Mvc_Cover_t *p, int iValueA0, int iValueA1, int iValueB0, int iValueB1)
Mvc_Cover_t **	Mvc_CoverCofactors (Mvc_Data_t *pData, Mvc_Cover_t *pCover, int iVar)
int	Mvr_CoverCountLitsWithValue (Mvc_Data_t *pData, Mvc_Cover_t *pCover, int iVar, int iValue)
Mvc_Cover_t *	Mvc_CoverTranspose (Mvc_Cover_t *pCover)
int	Mvc_UtilsCheckUnusedZeros (Mvc_Cover_t *pCover)
int	Mvc_CoverAnyLiteral (Mvc_Cover_t *pCover, Mvc_Cube_t *pMask)
	DECLARATIONS ///. More...
int	Mvc_CoverBestLiteral (Mvc_Cover_t *pCover, Mvc_Cube_t *pMask)
int	Mvc_CoverWorstLiteral (Mvc_Cover_t *pCover, Mvc_Cube_t *pMask)
Mvc_Cover_t *	Mvc_CoverBestLiteralCover (Mvc_Cover_t *pCover, Mvc_Cover_t *pSimple)
int	Mvc_CoverFirstCubeFirstLit (Mvc_Cover_t *pCover)
int	Mvc_CoverCountLiterals (Mvc_Cover_t *pCover)
int	Mvc_CoverIsOneLiteral (Mvc_Cover_t *pCover)
Mvc_Cover_t *	Mvc_CoverAlgebraicMultiply (Mvc_Cover_t *pCover1, Mvc_Cover_t *pCover2)
	DECLARATIONS ///. More...
Mvc_Cover_t *	Mvc_CoverAlgebraicSubtract (Mvc_Cover_t *pCover1, Mvc_Cover_t *pCover2)
int	Mvc_CoverAlgebraicEqual (Mvc_Cover_t *pCover1, Mvc_Cover_t *pCover2)
Mvc_Cover_t *	Mvc_CoverBooleanOr (Mvc_Cover_t *pCover1, Mvc_Cover_t *pCover2)
	DECLARATIONS ///. More...
Mvc_Cover_t *	Mvc_CoverBooleanAnd (Mvc_Data_t *p, Mvc_Cover_t *pCover1, Mvc_Cover_t *pCover2)
int	Mvc_CoverBooleanEqual (Mvc_Data_t *p, Mvc_Cover_t *pCover1, Mvc_Cover_t *pCover2)
int	Mvc_CoverContain (Mvc_Cover_t *pCover)
	FUNCTION DEFINITIONS ///. More...
int	Mvc_CoverTautology (Mvc_Data_t *p, Mvc_Cover_t *pCover)
Mvc_Cover_t *	Mvc_CoverComplement (Mvc_Data_t *p, Mvc_Cover_t *pCover)
Mvc_Cover_t *	Mvc_CoverSharp (Mvc_Data_t *p, Mvc_Cover_t *pA, Mvc_Cover_t *pB)
int	Mvc_CoverDist0Cubes (Mvc_Data_t *pData, Mvc_Cube_t *pA, Mvc_Cube_t *pB)
void	Mvc_CoverIntersectCubes (Mvc_Data_t *pData, Mvc_Cover_t *pC1, Mvc_Cover_t *pC2)
int	Mvc_CoverIsIntersecting (Mvc_Data_t *pData, Mvc_Cover_t *pC1, Mvc_Cover_t *pC2)
void	Mvc_CoverAppendCubes (Mvc_Cover_t *pC1, Mvc_Cover_t *pC2)
void	Mvc_CoverCopyAndAppendCubes (Mvc_Cover_t *pC1, Mvc_Cover_t *pC2)
void	Mvc_CoverRemoveCubes (Mvc_Cover_t *pC)
void	Mvc_CoverMinimizeByReshape (Mvc_Data_t *pData, Mvc_Cover_t *pCover)
void	Mvc_CoverDist1Merge (Mvc_Data_t *p, Mvc_Cover_t *pCover)
void	Mvc_ManagerFree (Mvc_Manager_t *p)
Mvc_Manager_t *	Mvc_ManagerStart ()
	DECLARATIONS ///. More...
Mvc_Manager_t *	Mvc_ManagerAllocCover ()
Mvc_Manager_t *	Mvc_ManagerAllocCube (int nWords)
Mvc_Manager_t *	Mvc_ManagerFreeCover (Mvc_Cover_t *pCover)
Mvc_Manager_t *	Mvc_ManagerFreeCube (Mvc_Cover_t *pCube, int nWords)

Macro Definition Documentation

#define BITS_DISJOINT   ((Mvc_CubeWord_t)0x55555555)

Definition at line 44 of file mvc.h.

#define BITS_FULL   ((Mvc_CubeWord_t)0xffffffff)

Definition at line 45 of file mvc.h.

#define BITS_PER_WORD   32

INCLUDES ///.

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

FileName [mvc.h]

PackageName [MVSIS 2.0: Multi-valued logic synthesis system.]

Synopsis [Data structure for MV cube/cover manipulation.]

Author [MVSIS Group]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - February 1, 2003.]

Revision [

Id:

mvc.h,v 1.10 2003/05/02 23:23:59 wjiang Exp

]PARAMETERS ///

Definition at line 41 of file mvc.h.

#define BITS_PER_WORD_LOG   5

Definition at line 43 of file mvc.h.

#define BITS_PER_WORD_MINUS   31

Definition at line 42 of file mvc.h.

#define MEM_ALLOC	(		Manager,
			Type,
			Size
	)		((Type *)ABC_ALLOC( char, (Size) * sizeof(Type) ))

Definition at line 567 of file mvc.h.

#define MEM_FREE	(		Manager,
			Type,
			Size,
			Pointer
	)		if ( Pointer ) { ABC_FREE(Pointer); Pointer = NULL; }

Definition at line 568 of file mvc.h.

#define Mvc_CoverAddCubeHead	(		pCover,
			pCube
	)

Value:

{\
    Mvc_List_t * pList = &pCover->lCubes;\
    Mvc_ListAddCubeHead( pList, pCube );\
}

Definition at line 496 of file mvc.h.

#define Mvc_CoverAddCubeTail	(		pCover,
			pCube
	)

Value:

{\
    Mvc_List_t * pList = &pCover->lCubes;\
    Mvc_ListAddCubeTail( pList, pCube );\
}

Definition at line 501 of file mvc.h.

#define Mvc_CoverDeleteCube	(		pCover,
			pPrev,
			pCube
	)

Value:

{\
    Mvc_List_t * pList = &pCover->lCubes;\
    Mvc_ListDeleteCube( pList, pPrev, pCube );\
}

Definition at line 506 of file mvc.h.

#define Mvc_CoverForEachCube	(		Cover,
			Cube
	)

Value:

for ( Cube = (Cover)->lCubes.pHead;\
          Cube;\
          Cube = Cube->pNext )

Definition at line 528 of file mvc.h.

#define Mvc_CoverForEachCubeSafe	(		Cover,
			Cube,
			Cube2
	)

Value:

for ( Cube = (Cover)->lCubes.pHead, Cube2 = (Cube? Cube->pNext: NULL);\
          Cube;\
          Cube = Cube2, Cube2 = (Cube? Cube->pNext: NULL) )

Definition at line 536 of file mvc.h.

#define Mvc_CoverForEachCubeStart	(		Start,
			Cube
	)

Value:

for ( Cube = Start;\
          Cube;\
          Cube = Cube->pNext )

Definition at line 542 of file mvc.h.

#define Mvc_CoverForEachCubeStartSafe	(		Start,
			Cube,
			Cube2
	)

Value:

for ( Cube = Start, Cube2 = (Cube? Cube->pNext: NULL);\
          Cube;\
          Cube = Cube2, Cube2 = (Cube? Cube->pNext: NULL) )

Definition at line 546 of file mvc.h.

#define Mvc_CoverForEachCubeWithIndex	(		Cover,
			Cube,
			Index
	)

Value:

for ( Index = 0, Cube = (Cover)->lCubes.pHead;\
          Cube;\
          Index++, Cube = Cube->pNext )

Definition at line 532 of file mvc.h.

#define Mvc_Cube1BitAnd	(		CubeR,
			Cube1,
			Cube2
	)		(((CubeR)->pData[0]) = ((Cube1)->pData[0] & (Cube2)->pData[0]))

Definition at line 227 of file mvc.h.

#define Mvc_Cube1BitClean

(

Cube

)

((Cube)->pData[0] = 0)

Definition at line 147 of file mvc.h.

#define Mvc_Cube1BitCopy	(		Cube1,
			Cube2
	)		(((Cube1)->pData[0]) = ((Cube2)->pData[0]))

Definition at line 191 of file mvc.h.

#define Mvc_Cube1BitDisjoint	(		Res,
			Cube1,
			Cube2
	)		(Res = ((((Cube1)->pData[0]) & ((Cube2)->pData[0])) == 0 ))

Definition at line 315 of file mvc.h.

#define Mvc_Cube1BitEmpty	(		Res,
			Cube
	)		(Res = ((Cube)->pData[0] == 0))

Definition at line 251 of file mvc.h.

#define Mvc_Cube1BitEqual	(		Res,
			Cube1,
			Cube2
	)		(Res = (((Cube1)->pData[0]) == ((Cube2)->pData[0])))

Definition at line 263 of file mvc.h.

#define Mvc_Cube1BitEqualOutsideMask	(		Res,
			Cube1,
			Cube2,
			Mask
	)		(Res = ((((Cube1)->pData[0]) | ((Mask)->pData[0])) == (((Cube2)->pData[0]) | ((Mask)->pData[0]))))

Definition at line 341 of file mvc.h.

#define Mvc_Cube1BitEqualUnderMask	(		Res,
			Cube1,
			Cube2,
			Mask
	)		(Res = ((((Cube1)->pData[0]) & ((Mask)->pData[0])) == (((Cube2)->pData[0]) & ((Mask)->pData[0]))))

Definition at line 328 of file mvc.h.

#define Mvc_Cube1BitExor	(		CubeR,
			Cube1,
			Cube2
	)		(((CubeR)->pData[0]) = ((Cube1)->pData[0] ^ (Cube2)->pData[0]))

Definition at line 215 of file mvc.h.

#define Mvc_Cube1BitFill

(

Cube

)

(Cube)->pData[0] = (BITS_FULL >> (Cube)->nUnused);

Definition at line 164 of file mvc.h.

#define Mvc_Cube1BitIntersectUnderMask	(		Res,
			Cube1,
			Cube2,
			Mask
	)		(Res = ((((Cube1)->pData[0]) & ((Cube2)->pData[0]) & ((Mask)->pData[0])) > 0))

Definition at line 354 of file mvc.h.

#define Mvc_Cube1BitLess	(		Res,
			Cube1,
			Cube2
	)		(Res = (((Cube1)->pData[0]) < ((Cube2)->pData[0])))

Definition at line 276 of file mvc.h.

#define Mvc_Cube1BitMore	(		Res,
			Cube1,
			Cube2
	)		(Res = (((Cube1)->pData[0]) > ((Cube2)->pData[0])))

Definition at line 289 of file mvc.h.

#define Mvc_Cube1BitNot

(

Cube

)

((Cube)->pData[0] ^= (BITS_FULL >> (Cube)->nUnused))

Definition at line 178 of file mvc.h.

#define Mvc_Cube1BitNotImpl	(		Res,
			Cube1,
			Cube2
	)		(Res = (((Cube1)->pData[0]) & ~((Cube2)->pData[0])))

Definition at line 302 of file mvc.h.

#define Mvc_Cube1BitNotImplUnderMask	(		Res,
			Cube1,
			Cube2,
			Mask
	)		(Res = (((Mask)->pData[0]) & ((Cube1)->pData[0]) & ~((Cube2)->pData[0])))

Definition at line 367 of file mvc.h.

#define Mvc_Cube1BitOr	(		CubeR,
			Cube1,
			Cube2
	)		(((CubeR)->pData[0]) = ((Cube1)->pData[0] | (Cube2)->pData[0]))

Definition at line 203 of file mvc.h.

#define Mvc_Cube1BitSharp	(		CubeR,
			Cube1,
			Cube2
	)		(((CubeR)->pData[0]) = ((Cube1)->pData[0] & ~((Cube2)->pData[0])))

Definition at line 239 of file mvc.h.

#define Mvc_Cube1Words

(

Cube

)

((Cube)->iLast == 0)

Definition at line 131 of file mvc.h.

#define Mvc_Cube2BitAnd	(		CubeR,
			Cube1,
			Cube2
	)

Value:

((((CubeR)->pData[0]) = ((Cube1)->pData[0] & (Cube2)->pData[0])),\
         (((CubeR)->pData[1]) = ((Cube1)->pData[1] & (Cube2)->pData[1])))

Definition at line 229 of file mvc.h.

#define Mvc_Cube2BitClean

(

Cube

)

Value:

(((Cube)->pData[0] = 0),\
          ((Cube)->pData[1] = 0))

Definition at line 149 of file mvc.h.

#define Mvc_Cube2BitCopy	(		Cube1,
			Cube2
	)

Value:

((((Cube1)->pData[0]) = ((Cube2)->pData[0])),\
         (((Cube1)->pData[1])=  ((Cube2)->pData[1])))

Definition at line 193 of file mvc.h.

#define Mvc_Cube2BitDisjoint	(		Res,
			Cube1,
			Cube2
	)

Value:

(Res = (((((Cube1)->pData[0]) &  ((Cube2)->pData[0])) == 0 ) &&\
         ((((Cube1)->pData[1]) &  ((Cube2)->pData[1])) == 0 )))

Definition at line 317 of file mvc.h.

#define Mvc_Cube2BitEmpty	(		Res,
			Cube
	)		(Res = ((Cube)->pData[0] == 0 && (Cube)->pData[1] == 0))

Definition at line 253 of file mvc.h.

#define Mvc_Cube2BitEqual	(		Res,
			Cube1,
			Cube2
	)

Value:

(Res = ((((Cube1)->pData[0]) == ((Cube2)->pData[0])) &&\
         (((Cube1)->pData[1]) == ((Cube2)->pData[1]))))

Definition at line 265 of file mvc.h.

#define Mvc_Cube2BitEqualOutsideMask	(		Res,
			Cube1,
			Cube2,
			Mask
	)

Value:

(Res = (((((Cube1)->pData[0]) | ((Mask)->pData[0])) == (((Cube2)->pData[0]) | ((Mask)->pData[0])))  &&\
         ((((Cube1)->pData[1]) | ((Mask)->pData[1])) == (((Cube2)->pData[1]) | ((Mask)->pData[1])))))

Definition at line 343 of file mvc.h.

#define Mvc_Cube2BitEqualUnderMask	(		Res,
			Cube1,
			Cube2,
			Mask
	)

Value:

(Res = (((((Cube1)->pData[0]) & ((Mask)->pData[0])) == (((Cube2)->pData[0]) & ((Mask)->pData[0])))  &&\
         ((((Cube1)->pData[1]) & ((Mask)->pData[1])) == (((Cube2)->pData[1]) & ((Mask)->pData[1])))))

Definition at line 330 of file mvc.h.

#define Mvc_Cube2BitExor	(		CubeR,
			Cube1,
			Cube2
	)

Value:

((((CubeR)->pData[0]) = ((Cube1)->pData[0] ^ (Cube2)->pData[0])),\
         (((CubeR)->pData[1]) = ((Cube1)->pData[1] ^ (Cube2)->pData[1])))

Definition at line 217 of file mvc.h.

#define Mvc_Cube2BitFill

(

Cube

)

Value:

(((Cube)->pData[0] =  BITS_FULL),\
          ((Cube)->pData[1] = (BITS_FULL >> (Cube)->nUnused)))

Definition at line 166 of file mvc.h.

#define Mvc_Cube2BitIntersectUnderMask	(		Res,
			Cube1,
			Cube2,
			Mask
	)

Value:

(Res = (((((Cube1)->pData[0]) & ((Cube2)->pData[0]) & ((Mask)->pData[0])) > 0) ||\
         ((((Cube1)->pData[1]) & ((Cube2)->pData[1]) & ((Mask)->pData[1])) > 0)))

Definition at line 356 of file mvc.h.

#define Mvc_Cube2BitLess	(		Res,
			Cube1,
			Cube2
	)

Value:

(Res = ((((Cube1)->pData[0]) <  ((Cube2)->pData[0])) ||\
        ((((Cube1)->pData[0]) == ((Cube2)->pData[0])) && (((Cube1)->pData[1]) <  ((Cube2)->pData[1])))))

Definition at line 278 of file mvc.h.

#define Mvc_Cube2BitMore	(		Res,
			Cube1,
			Cube2
	)

Value:

(Res = ((((Cube1)->pData[0]) >  ((Cube2)->pData[0])) ||\
        ((((Cube1)->pData[0]) == ((Cube2)->pData[0])) && (((Cube1)->pData[1]) >  ((Cube2)->pData[1])))))

Definition at line 291 of file mvc.h.

#define Mvc_Cube2BitNot

(

Cube

)

Value:

(((Cube)->pData[0] ^=  BITS_FULL),\
          ((Cube)->pData[1] ^= (BITS_FULL >> (Cube)->nUnused)))

Definition at line 180 of file mvc.h.

#define Mvc_Cube2BitNotImpl	(		Res,
			Cube1,
			Cube2
	)

Value:

(Res = ((((Cube1)->pData[0]) & ~((Cube2)->pData[0])) ||\
         (((Cube1)->pData[1]) & ~((Cube2)->pData[1]))))

Definition at line 304 of file mvc.h.

#define Mvc_Cube2BitNotImplUnderMask	(		Res,
			Cube1,
			Cube2,
			Mask
	)

Value:

(Res = ((((Mask)->pData[0]) & ((Cube1)->pData[0]) & ~((Cube2)->pData[0])) ||\
         (((Mask)->pData[1]) & ((Cube1)->pData[1]) & ~((Cube2)->pData[1]))))

Definition at line 369 of file mvc.h.

#define Mvc_Cube2BitOr	(		CubeR,
			Cube1,
			Cube2
	)

Value:

((((CubeR)->pData[0]) = ((Cube1)->pData[0] | (Cube2)->pData[0])),\
         (((CubeR)->pData[1]) = ((Cube1)->pData[1] | (Cube2)->pData[1])))

Definition at line 205 of file mvc.h.

#define Mvc_Cube2BitSharp	(		CubeR,
			Cube1,
			Cube2
	)

Value:

((((CubeR)->pData[0]) = ((Cube1)->pData[0] & ~((Cube2)->pData[0]))),\
         (((CubeR)->pData[1]) = ((Cube1)->pData[1] & ~((Cube2)->pData[1]))))

Definition at line 241 of file mvc.h.

#define Mvc_Cube2Words

(

Cube

)

((Cube)->iLast == 1)

Definition at line 132 of file mvc.h.

#define Mvc_CubeBitAnd	(		CubeR,
			Cube1,
			Cube2
	)

Value:

if ( Mvc_Cube1Words(Cube1) )     { Mvc_Cube1BitAnd( CubeR, Cube1, Cube2 ); }\
    else if ( Mvc_Cube2Words(Cube1) ){ Mvc_Cube2BitAnd( CubeR, Cube1, Cube2 ); }\
    else                             { Mvc_CubeNBitAnd( CubeR, Cube1, Cube2 ); }

Definition at line 405 of file mvc.h.

#define Mvc_CubeBitClean

(

Cube

)

Value:

if ( Mvc_Cube1Words(Cube) )      { Mvc_Cube1BitClean( Cube ); }\
    else if ( Mvc_Cube2Words(Cube) ) { Mvc_Cube2BitClean( Cube ); }\
    else                             { Mvc_CubeNBitClean( Cube ); }

Definition at line 381 of file mvc.h.

#define Mvc_CubeBitCleanUnused

(

Cube

)

((Cube)->pData[(Cube)->iLast] &= (BITS_FULL >> (Cube)->nUnused))

Definition at line 160 of file mvc.h.

#define Mvc_CubeBitCopy	(		Cube1,
			Cube2
	)

Value:

if ( Mvc_Cube1Words(Cube1) )     { Mvc_Cube1BitCopy( Cube1, Cube2 ); }\
    else if ( Mvc_Cube2Words(Cube1) ){ Mvc_Cube2BitCopy( Cube1, Cube2 ); }\
    else                             { Mvc_CubeNBitCopy( Cube1, Cube2 ); }

Definition at line 393 of file mvc.h.

#define Mvc_CubeBitDisjoint	(		Res,
			Cube1,
			Cube2
	)

Value:

if ( Mvc_Cube1Words(Cube1) )     { Mvc_Cube1BitDisjoint( Res, Cube1, Cube2 ); }\
    else if ( Mvc_Cube2Words(Cube1) ){ Mvc_Cube2BitDisjoint( Res, Cube1, Cube2 ); }\
    else                             { Mvc_CubeNBitDisjoint( Res, Cube1, Cube2 ); }

Definition at line 433 of file mvc.h.

#define Mvc_CubeBitEmpty	(		Res,
			Cube
	)

Value:

if ( Mvc_Cube1Words(Cube) )      { Mvc_Cube1BitEmpty( Res, Cube ); }\
    else if ( Mvc_Cube2Words(Cube) ) { Mvc_Cube2BitEmpty( Res, Cube ); }\
    else                             { Mvc_CubeNBitEmpty( Res, Cube ); }

Definition at line 413 of file mvc.h.

#define Mvc_CubeBitEqual	(		Res,
			Cube1,
			Cube2
	)

Value:

if ( Mvc_Cube1Words(Cube1) )     { Mvc_Cube1BitEqual( Res, Cube1, Cube2 ); }\
    else if ( Mvc_Cube2Words(Cube1) ){ Mvc_Cube2BitEqual( Res, Cube1, Cube2 ); }\
    else                             { Mvc_CubeNBitEqual( Res, Cube1, Cube2 ); }

Definition at line 417 of file mvc.h.

#define Mvc_CubeBitEqualOutsideMask	(		Res,
			Cube1,
			Cube2,
			Mask
	)

Value:

if ( Mvc_Cube1Words(Cube1) )     { Mvc_Cube1BitEqualOutsideMask( Res, Cube1, Cube2, Mask ); }\
    else if ( Mvc_Cube2Words(Cube1) ){ Mvc_Cube2BitEqualOutsideMask( Res, Cube1, Cube2, Mask ); }\
    else                             { Mvc_CubeNBitEqualOutsideMask( Res, Cube1, Cube2, Mask ); }

Definition at line 441 of file mvc.h.

#define Mvc_CubeBitEqualUnderMask	(		Res,
			Cube1,
			Cube2,
			Mask
	)

Value:

if ( Mvc_Cube1Words(Cube1) )     { Mvc_Cube1BitEqualUnderMask( Res, Cube1, Cube2, Mask ); }\
    else if ( Mvc_Cube2Words(Cube1) ){ Mvc_Cube2BitEqualUnderMask( Res, Cube1, Cube2, Mask ); }\
    else                             { Mvc_CubeNBitEqualUnderMask( Res, Cube1, Cube2, Mask ); }

Definition at line 437 of file mvc.h.

#define Mvc_CubeBitExor	(		CubeR,
			Cube1,
			Cube2
	)

Value:

if ( Mvc_Cube1Words(Cube1) )     { Mvc_Cube1BitExor( CubeR, Cube1, Cube2 ); }\
    else if ( Mvc_Cube2Words(Cube1) ){ Mvc_Cube2BitExor( CubeR, Cube1, Cube2 ); }\
    else                             { Mvc_CubeNBitExor( CubeR, Cube1, Cube2 ); }

Definition at line 401 of file mvc.h.

#define Mvc_CubeBitFill

(

Cube

)

Value:

if ( Mvc_Cube1Words(Cube) )      { Mvc_Cube1BitFill( Cube ); }\
    else if ( Mvc_Cube2Words(Cube) ) { Mvc_Cube2BitFill( Cube ); }\
    else                             { Mvc_CubeNBitFill( Cube ); }

Definition at line 385 of file mvc.h.

#define Mvc_CubeBitInsert	(		Cube,
			Bit
	)		((Cube)->pData[Mvc_CubeWhichWord(Bit)] |= (((Mvc_CubeWord_t)1)<<(Mvc_CubeWhichBit(Bit))))

Definition at line 139 of file mvc.h.

#define Mvc_CubeBitIntersectUnderMask	(		Res,
			Cube1,
			Cube2,
			Mask
	)

Value:

if ( Mvc_Cube1Words(Cube1) )     { Mvc_Cube1BitIntersectUnderMask( Res, Cube1, Cube2, Mask ); }\
    else if ( Mvc_Cube2Words(Cube1) ){ Mvc_Cube2BitIntersectUnderMask( Res, Cube1, Cube2, Mask ); }\
    else                             { Mvc_CubeNBitIntersectUnderMask( Res, Cube1, Cube2, Mask ); }

Definition at line 445 of file mvc.h.

#define Mvc_CubeBitLess	(		Res,
			Cube1,
			Cube2
	)

Value:

if ( Mvc_Cube1Words(Cube1) )     { Mvc_Cube1BitLess( Res, Cube1, Cube2 ); }\
    else if ( Mvc_Cube2Words(Cube1) ){ Mvc_Cube2BitLess( Res, Cube1, Cube2 ); }\
    else                             { Mvc_CubeNBitLess( Res, Cube1, Cube2 ); }

Definition at line 421 of file mvc.h.

#define Mvc_CubeBitMore	(		Res,
			Cube1,
			Cube2
	)

Value:

if ( Mvc_Cube1Words(Cube1) )     { Mvc_Cube1BitMore( Res, Cube1, Cube2 ); }\
    else if ( Mvc_Cube2Words(Cube1) ){ Mvc_Cube2BitMore( Res, Cube1, Cube2 ); }\
    else                             { Mvc_CubeNBitMore( Res, Cube1, Cube2 ); }

Definition at line 425 of file mvc.h.

#define Mvc_CubeBitNot

(

Cube

)

Value:

if ( Mvc_Cube1Words(Cube) )      { Mvc_Cube1BitNot( Cube ); }\
    else if ( Mvc_Cube2Words(Cube) ) { Mvc_Cube2BitNot( Cube ); }\
    else                             { Mvc_CubeNBitNot( Cube ); }

Definition at line 389 of file mvc.h.

#define Mvc_CubeBitNotImpl	(		Res,
			Cube1,
			Cube2
	)

Value:

if ( Mvc_Cube1Words(Cube1) )     { Mvc_Cube1BitNotImpl( Res, Cube1, Cube2 ); }\
    else if ( Mvc_Cube2Words(Cube1) ){ Mvc_Cube2BitNotImpl( Res, Cube1, Cube2 ); }\
    else                             { Mvc_CubeNBitNotImpl( Res, Cube1, Cube2 ); }

Definition at line 429 of file mvc.h.

#define Mvc_CubeBitNotImplUnderMask	(		Res,
			Cube1,
			Cube2,
			Mask
	)

Value:

if ( Mvc_Cube1Words(Cube1) )     { Mvc_Cube1BitNotImplUnderMask( Res, Cube1, Cube2, Mask ); }\
    else if ( Mvc_Cube2Words(Cube1) ){ Mvc_Cube2BitNotImplUnderMask( Res, Cube1, Cube2, Mask ); }\
    else                             { Mvc_CubeNBitNotImplUnderMask( Res, Cube1, Cube2, Mask ); }

Definition at line 449 of file mvc.h.

#define Mvc_CubeBitOr	(		CubeR,
			Cube1,
			Cube2
	)

Value:

if ( Mvc_Cube1Words(Cube1) )     { Mvc_Cube1BitOr( CubeR, Cube1, Cube2 ); }\
    else if ( Mvc_Cube2Words(Cube1) ){ Mvc_Cube2BitOr( CubeR, Cube1, Cube2 ); }\
    else                             { Mvc_CubeNBitOr( CubeR, Cube1, Cube2 ); }

Definition at line 397 of file mvc.h.

#define Mvc_CubeBitRemove	(		Cube,
			Bit
	)		((Cube)->pData[Mvc_CubeWhichWord(Bit)] &= ~(((Mvc_CubeWord_t)1)<<(Mvc_CubeWhichBit(Bit))))

Definition at line 140 of file mvc.h.

#define Mvc_CubeBitSharp	(		CubeR,
			Cube1,
			Cube2
	)

Value:

if ( Mvc_Cube1Words(Cube1) )     { Mvc_Cube1BitSharp( CubeR, Cube1, Cube2 ); }\
    else if ( Mvc_Cube2Words(Cube1) ){ Mvc_Cube2BitSharp( CubeR, Cube1, Cube2 ); }\
    else                             { Mvc_CubeNBitSharp( CubeR, Cube1, Cube2 ); }

Definition at line 409 of file mvc.h.

#define Mvc_CubeBitValue	(		Cube,
			Bit
	)		(((Cube)->pData[Mvc_CubeWhichWord(Bit)] & (((Mvc_CubeWord_t)1)<<(Mvc_CubeWhichBit(Bit)))) > 0)

Definition at line 138 of file mvc.h.

#define Mvc_CubeForEachBit	(		Cover,
			Cube,
			iBit,
			Value
	)

Value:

for ( iBit = 0;\
          iBit < Cover->nBits && ((Value = Mvc_CubeBitValue(Cube,iBit))>=0);\
          iBit++ )

Definition at line 553 of file mvc.h.

#define Mvc_CubeForEachVarValue	(		Cover,
			Cube,
			iVar,
			Value
	)

Value:

for ( iVar = 0;\
          iVar < Cover->nBits/2 && (Value = Mvc_CubeVarValue(Cube,iVar));\
          iVar++ )

Definition at line 558 of file mvc.h.

#define Mvc_CubeNBitAnd	(		CubeR,
			Cube1,
			Cube2
	)

Value:

{\
    int _i_;\
    for (_i_ = (Cube1)->iLast; _i_ >= 0; _i_--)\
        (((CubeR)->pData[_i_]) = ((Cube1)->pData[_i_] & (Cube2)->pData[_i_]));\
}

Definition at line 232 of file mvc.h.

#define Mvc_CubeNBitClean

(

Cube

)

Value:

{\
    int _i_;\
    for( _i_ = (Cube)->iLast; _i_ >= 0; _i_--)\
           (Cube)->pData[_i_] = 0;\
}

Definition at line 152 of file mvc.h.

#define Mvc_CubeNBitCopy	(		Cube1,
			Cube2
	)

Value:

{\
    int _i_;\
    for (_i_ = (Cube1)->iLast; _i_ >= 0; _i_--)\
        ((Cube1)->pData[_i_]) = ((Cube2)->pData[_i_]);\
}

Definition at line 196 of file mvc.h.

#define Mvc_CubeNBitDisjoint	(		Res,
			Cube1,
			Cube2
	)

Value:

{\
    int _i_; Res = 1;\
    for (_i_ = (Cube1)->iLast; _i_ >= 0; _i_--)\
        if (((Cube1)->pData[_i_]) & ((Cube2)->pData[_i_]))\
             { Res = 0; break; }\
}

Definition at line 320 of file mvc.h.

#define Mvc_CubeNBitEmpty	(		Res,
			Cube
	)

Value:

{\
    int _i_; Res = 1;\
    for (_i_ = (Cube)->iLast; _i_ >= 0; _i_--)\
        if ( (Cube)->pData[_i_] )\
           { Res = 0; break; }\
}

Definition at line 255 of file mvc.h.

#define Mvc_CubeNBitEqual	(		Res,
			Cube1,
			Cube2
	)

Value:

{\
    int _i_; Res = 1;\
    for (_i_ = (Cube1)->iLast; _i_ >= 0; _i_--)\
         if (((Cube1)->pData[_i_]) != ((Cube2)->pData[_i_]))\
              { Res = 0; break; }\
}

Definition at line 268 of file mvc.h.

#define Mvc_CubeNBitEqualOutsideMask	(		Res,
			Cube1,
			Cube2,
			Mask
	)

Value:

{\
    int _i_; Res = 1;\
    for (_i_ = (Cube1)->iLast; _i_ >= 0; _i_--)\
        if ((((Cube1)->pData[_i_]) | ((Mask)->pData[_i_])) != (((Cube2)->pData[_i_]) | ((Mask)->pData[_i_])))\
            { Res = 0; break; }\
}

Definition at line 346 of file mvc.h.

#define Mvc_CubeNBitEqualUnderMask	(		Res,
			Cube1,
			Cube2,
			Mask
	)

Value:

{\
    int _i_; Res = 1;\
    for (_i_ = (Cube1)->iLast; _i_ >= 0; _i_--)\
        if ((((Cube1)->pData[_i_]) & ((Mask)->pData[_i_])) != (((Cube2)->pData[_i_]) & ((Mask)->pData[_i_])))\
            { Res = 0; break; }\
}

Definition at line 333 of file mvc.h.

#define Mvc_CubeNBitExor	(		CubeR,
			Cube1,
			Cube2
	)

Value:

{\
    int _i_;\
    for (_i_ = (Cube1)->iLast; _i_ >= 0; _i_--)\
        (((CubeR)->pData[_i_]) = ((Cube1)->pData[_i_] ^ (Cube2)->pData[_i_]));\
}

Definition at line 220 of file mvc.h.

#define Mvc_CubeNBitFill

(

Cube

)

Value:

{\
    int _i_;\
    (Cube)->pData[(Cube)->iLast] = (BITS_FULL >> (Cube)->nUnused);\
    for( _i_ = (Cube)->iLast - 1; _i_ >= 0; _i_-- )\
        (Cube)->pData[_i_] =  BITS_FULL;\
}

Definition at line 169 of file mvc.h.

#define Mvc_CubeNBitIntersectUnderMask	(		Res,
			Cube1,
			Cube2,
			Mask
	)

Value:

{\
    int _i_; Res = 0;\
    for (_i_ = (Cube1)->iLast; _i_ >= 0; _i_--)\
        if (((Cube1)->pData[_i_]) & ((Cube2)->pData[_i_]) & ((Mask)->pData[_i_]))\
           { Res = 1; break; }\
}

Definition at line 359 of file mvc.h.

#define Mvc_CubeNBitLess	(		Res,
			Cube1,
			Cube2
	)

Value:

{\
    int _i_; Res = 1;\
    for (_i_ = (Cube1)->iLast; _i_ >= 0; _i_--)\
         if (((Cube1)->pData[_i_]) >= ((Cube2)->pData[_i_]))\
             { Res = 0; break; }\
}

Definition at line 281 of file mvc.h.

#define Mvc_CubeNBitMore	(		Res,
			Cube1,
			Cube2
	)

Value:

{\
    int _i_; Res = 1;\
    for (_i_ = (Cube1)->iLast; _i_ >= 0; _i_--)\
        if (((Cube1)->pData[_i_]) <= ((Cube2)->pData[_i_]))\
             { Res = 0; break; }\
}

Definition at line 294 of file mvc.h.

#define Mvc_CubeNBitNot

(

Cube

)

Value:

{\
    int _i_;\
    (Cube)->pData[(Cube)->iLast] ^= (BITS_FULL >> (Cube)->nUnused);\
    for( _i_ = (Cube)->iLast - 1; _i_ >= 0; _i_-- )\
        (Cube)->pData[_i_] ^=  BITS_FULL;\
}

Definition at line 183 of file mvc.h.

#define Mvc_CubeNBitNotImpl	(		Res,
			Cube1,
			Cube2
	)

Value:

{\
    int _i_; Res = 0;\
    for (_i_ = (Cube1)->iLast; _i_ >= 0; _i_--)\
        if (((Cube1)->pData[_i_]) & ~((Cube2)->pData[_i_]))\
            { Res = 1; break; }\
}

Definition at line 307 of file mvc.h.

#define Mvc_CubeNBitNotImplUnderMask	(		Res,
			Cube1,
			Cube2,
			Mask
	)

Value:

{\
    int _i_; Res = 0;\
    for (_i_ = (Cube1)->iLast; _i_ >= 0; _i_--)\
        if (((Mask)->pData[_i_]) & ((Cube1)->pData[_i_]) & ~((Cube2)->pData[_i_]))\
            { Res = 1; break; }\
}

Definition at line 372 of file mvc.h.

#define Mvc_CubeNBitOr	(		CubeR,
			Cube1,
			Cube2
	)

Value:

{\
    int _i_;\
    for (_i_ = (Cube1)->iLast; _i_ >= 0; _i_--)\
        (((CubeR)->pData[_i_]) = ((Cube1)->pData[_i_] | (Cube2)->pData[_i_]));\
}

Definition at line 208 of file mvc.h.

#define Mvc_CubeNBitSharp	(		CubeR,
			Cube1,
			Cube2
	)

Value:

{\
    int _i_;\
    for (_i_ = (Cube1)->iLast; _i_ >= 0; _i_--)\
        (((CubeR)->pData[_i_]) = ((Cube1)->pData[_i_] & ~(Cube2)->pData[_i_]));\
}

Definition at line 244 of file mvc.h.

#define Mvc_CubeNWords

(

Cube

)

((Cube)->iLast > 1)

Definition at line 133 of file mvc.h.

#define Mvc_CubeReadLast

(

Cube

)

((Cube)->iLast)

Definition at line 123 of file mvc.h.

#define Mvc_CubeReadNext

(

Cube

)

((Cube)->pNext)

MACRO DEFINITIONS ///.

Definition at line 121 of file mvc.h.

#define Mvc_CubeReadNextP

(

Cube

)

(&(Cube)->pNext)

Definition at line 122 of file mvc.h.

#define Mvc_CubeReadSize

(

Cube

)

((Cube)->nOnes)

Definition at line 124 of file mvc.h.

#define Mvc_CubeSetLast	(		Cube,
			Last
	)		((Cube)->iLast = (Last))

Definition at line 127 of file mvc.h.

#define Mvc_CubeSetNext	(		Cube,
			Next
	)		((Cube)->pNext = (Next))

Definition at line 126 of file mvc.h.

#define Mvc_CubeSetSize	(		Cube,
			Size
	)		((Cube)->nOnes = (Size))

Definition at line 128 of file mvc.h.

#define Mvc_CubeVarValue	(		Cube,
			Var
	)		(((Cube)->pData[Mvc_CubeWhichWord(2*(Var))] >> (Mvc_CubeWhichBit(2*(Var)))) & ((Mvc_CubeWord_t)3))

Definition at line 142 of file mvc.h.

#define Mvc_CubeWhichBit

(

Bit

)

((Bit) & BITS_PER_WORD_MINUS)

Definition at line 136 of file mvc.h.

#define Mvc_CubeWhichWord

(

Bit

)

((Bit) >> BITS_PER_WORD_LOG)

Definition at line 135 of file mvc.h.

#define Mvc_ListAddCubeHead	(		pList,
			pCube
	)

Value:

{\
        if ( pList->pHead == NULL )\
        {\
            Mvc_CubeSetNext( pCube, NULL );\
            pList->pHead = pCube;\
            pList->pTail = pCube;\
        }\
        else\
        {\
            Mvc_CubeSetNext( pCube, pList->pHead );\
            pList->pHead = pCube;\
        }\
        pList->nItems++;\
    }

Definition at line 456 of file mvc.h.

#define Mvc_ListAddCubeTail	(		pList,
			pCube
	)

Value:

{\
        if ( pList->pHead == NULL )\
            pList->pHead = pCube;\
        else\
            Mvc_CubeSetNext( pList->pTail, pCube );\
        pList->pTail    = pCube;\
        Mvc_CubeSetNext( pCube, NULL );\
        pList->nItems++;\
    }

Definition at line 471 of file mvc.h.

#define Mvc_ListDeleteCube	(		pList,
			pPrev,
			pCube
	)

Value:

{\
    if ( pPrev == NULL )\
        pList->pHead = pCube->pNext;\
    else\
        pPrev->pNext = pCube->pNext;\
    if ( pList->pTail == pCube )\
    {\
        assert( pCube->pNext == NULL );\
        pList->pTail = pPrev;\
    }\
    pList->nItems--;\
}

Definition at line 481 of file mvc.h.

#define Mvc_ListForEachCube	(		List,
			Cube
	)

Value:

for ( Cube = List->pHead;\
          Cube;\
          Cube = Cube->pNext )

Definition at line 518 of file mvc.h.

#define Mvc_ListForEachCubeSafe	(		List,
			Cube,
			Cube2
	)

Value:

for ( Cube = List->pHead, Cube2 = (Cube? Cube->pNext: NULL);\
          Cube;\
          Cube = Cube2, Cube2 = (Cube? Cube->pNext: NULL) )

Definition at line 522 of file mvc.h.

Typedef Documentation

typedef struct MvcCoverStruct Mvc_Cover_t

Definition at line 58 of file mvc.h.

typedef struct MvcCubeStruct Mvc_Cube_t

Definition at line 56 of file mvc.h.

typedef unsigned int Mvc_CubeWord_t

STRUCTURE DEFINITIONS ///.

Definition at line 55 of file mvc.h.

typedef struct MvcDataStruct Mvc_Data_t

Definition at line 59 of file mvc.h.

typedef struct MvcListStruct Mvc_List_t

Definition at line 57 of file mvc.h.

typedef struct MvcManagerStruct Mvc_Manager_t

Definition at line 60 of file mvc.h.

Function Documentation

void Mvc_CoverAddCubeHead_	(	Mvc_Cover_t *	pCover,
		Mvc_Cube_t *	pCube
	)

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 121 of file mvcList.c.

{
    Mvc_List_t * pList = &pCover->lCubes;
    if ( pList->pHead == NULL )
    {
        Mvc_CubeSetNext( pCube, NULL );
        pList->pHead = pCube;
        pList->pTail = pCube;
    }
    else
    {
        Mvc_CubeSetNext( pCube, pList->pHead );
        pList->pHead = pCube;
    }
    pList->nItems++;
}

void Mvc_CoverAddCubeTail_	(	Mvc_Cover_t *	pCover,
		Mvc_Cube_t *	pCube
	)

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 149 of file mvcList.c.

{
    Mvc_List_t * pList = &pCover->lCubes;

    if ( pList->pHead == NULL )
        pList->pHead = pCube;
    else
        Mvc_CubeSetNext( pList->pTail, pCube );
    pList->pTail    = pCube;
    Mvc_CubeSetNext( pCube, NULL );
    pList->nItems++;
}

void Mvc_CoverAddDupCubeHead	(	Mvc_Cover_t *	pCover,
		Mvc_Cube_t *	pCube
	)

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 202 of file mvcList.c.

{
    Mvc_Cube_t * pCubeNew;
    pCubeNew = Mvc_CubeAlloc( pCover );
    Mvc_CubeBitCopy( pCubeNew, pCube );
    Mvc_CoverAddCubeHead( pCover, pCubeNew );
}

void Mvc_CoverAddDupCubeTail	(	Mvc_Cover_t *	pCover,
		Mvc_Cube_t *	pCube
	)

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 221 of file mvcList.c.

{
    Mvc_Cube_t * pCubeNew;
    // copy the cube as part of this cover
    pCubeNew = Mvc_CubeAlloc( pCover );
    Mvc_CubeBitCopy( pCubeNew, pCube );
    // clean the last bits of the new cube
//    pCubeNew->pData[pCubeNew->iLast] &= (BITS_FULL >> pCubeNew->nUnused);
    // add the cube at the end
    Mvc_CoverAddCubeTail( pCover, pCubeNew );
}

void Mvc_CoverAddLiteralsOfCube	(	Mvc_Cover_t *	pCover,
		Mvc_Cube_t *	pCube
	)

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 245 of file mvcList.c.

{
//    int iBit, Value;
//    assert( pCover->pLits );
//    Mvc_CubeForEachBit( pCover, pCube, iBit, Value )
//        if ( Value )
//            pCover->pLits[iBit] += Value;
}

int Mvc_CoverAlgebraicEqual	(	Mvc_Cover_t *	pCover1,
		Mvc_Cover_t *	pCover2
	)

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 134 of file mvcOpAlg.c.

{
    Mvc_Cube_t * pCube1, * pCube2;
    int fFound;
    int CompResult;

    // covers should be the same base
    assert( pCover1->nBits == pCover2->nBits );
    // iterate through the cubes
    Mvc_CoverForEachCube( pCover1, pCube1 )
    {
        fFound = 0;
        Mvc_CoverForEachCube( pCover2, pCube2 )
        {
            Mvc_CubeBitEqual( CompResult, pCube1, pCube2 );
            if ( CompResult )
            {
                fFound = 1;
                break;
            }
        }
        if ( !fFound )
            return 0;
    }
    return 1;
}

Mvc_Cover_t* Mvc_CoverAlgebraicMultiply	(	Mvc_Cover_t *	pCover1,
		Mvc_Cover_t *	pCover2
	)

DECLARATIONS ///.

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

FileName [mvcOperAlg.c]

PackageName [MVSIS 2.0: Multi-valued logic synthesis system.]

Synopsis [Miscellaneous operations on covers.]

Author [MVSIS Group]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - February 1, 2003.]

Revision [

Id:

mvcOpAlg.c,v 1.4 2003/04/26 20:41:36 alanmi Exp

]FUNCTION DEFINITIONS /// Function*************************************************************

Synopsis [Multiplies two disjoint-support covers.]

Description []

SideEffects []

SeeAlso []

Definition at line 43 of file mvcOpAlg.c.

{
    Mvc_Cover_t * pCover;
    Mvc_Cube_t * pCube1, * pCube2, * pCube;
    int CompResult;

    // covers should be the same base
    assert( pCover1->nBits == pCover2->nBits );
    // make sure that supports do not overlap
    Mvc_CoverAllocateMask( pCover1 );
    Mvc_CoverAllocateMask( pCover2 );
    Mvc_CoverSupport( pCover1, pCover1->pMask );
    Mvc_CoverSupport( pCover2, pCover2->pMask );
    // check if the cubes are bit-wise disjoint
    Mvc_CubeBitDisjoint( CompResult, pCover1->pMask, pCover2->pMask );
    if ( !CompResult )
        printf( "Mvc_CoverMultiply(): Cover supports are not disjoint!\n" );

    // iterate through the cubes
    pCover = Mvc_CoverClone( pCover1 );
    Mvc_CoverForEachCube( pCover1, pCube1 )
        Mvc_CoverForEachCube( pCover2, pCube2 )
        { 
            // create the product cube
            pCube = Mvc_CubeAlloc( pCover );
            // set the product cube equal to the product of the two cubes
            Mvc_CubeBitOr( pCube, pCube1, pCube2 );
            // add the cube to the cover
            Mvc_CoverAddCubeTail( pCover, pCube );
        }
    return pCover;
}

Mvc_Cover_t* Mvc_CoverAlgebraicSubtract	(	Mvc_Cover_t *	pCover1,
		Mvc_Cover_t *	pCover2
	)

Function*************************************************************

Synopsis [Subtracts the second cover from the first.]

Description []

SideEffects []

SeeAlso []

Definition at line 88 of file mvcOpAlg.c.

{
    Mvc_Cover_t * pCover;
    Mvc_Cube_t * pCube1, * pCube2, * pCube;
    int fFound;
    int CompResult;

    // covers should be the same base
    assert( pCover1->nBits == pCover2->nBits );

    // iterate through the cubes
    pCover = Mvc_CoverClone( pCover1 );
    Mvc_CoverForEachCube( pCover1, pCube1 )
    {
        fFound = 0;
        Mvc_CoverForEachCube( pCover2, pCube2 )
        {
            Mvc_CubeBitEqual( CompResult, pCube1, pCube2 );
            if ( CompResult )
            {
                fFound = 1;
                break;
            }
        }
        if ( !fFound )
        { 
            // create the copy of the cube
            pCube = Mvc_CubeDup( pCover, pCube1 );
            // add the cube copy to the cover
            Mvc_CoverAddCubeTail( pCover, pCube );
        }
    }
    return pCover;
}

Mvc_Cover_t* Mvc_CoverAlloc	(	Mvc_Manager_t *	pMem,
		int	nBits
	)

DECLARATIONS ///.

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

FileName [mvcCover.c]

PackageName [MVSIS 2.0: Multi-valued logic synthesis system.]

Synopsis [Basic procedures to manipulate unate cube covers.]

Author [MVSIS Group]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - February 1, 2003.]

Revision [

Id:

mvcCover.c,v 1.5 2003/04/09 18:02:05 alanmi Exp

]FUNCTION DEFINITIONS /// Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 43 of file mvcCover.c.

{
    Mvc_Cover_t * p;
    int nBitsInUnsigned;

    nBitsInUnsigned  = 8 * sizeof(Mvc_CubeWord_t);
#ifdef USE_SYSTEM_MEMORY_MANAGEMENT
    p                = (Mvc_Cover_t *)ABC_ALLOC( char, sizeof(Mvc_Cover_t) );
#else
    p                = (Mvc_Cover_t *)Extra_MmFixedEntryFetch( pMem->pManC );
#endif
    p->pMem          = pMem;
    p->nBits         = nBits;
    p->nWords        = nBits / nBitsInUnsigned + (int)(nBits % nBitsInUnsigned > 0);
    p->nUnused       = p->nWords * nBitsInUnsigned - p->nBits;
    p->lCubes.nItems = 0;
    p->lCubes.pHead  = NULL;
    p->lCubes.pTail  = NULL;
    p->nCubesAlloc   = 0;
    p->pCubes        = NULL;
    p->pMask         = NULL;
    p->pLits         = NULL;
    return p;
}

void Mvc_CoverAllocateArrayCubes

(

Mvc_Cover_t *

pCover

)

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 202 of file mvcCover.c.

{ 
    if ( pCover->nCubesAlloc < pCover->lCubes.nItems )
    {
        if ( pCover->nCubesAlloc > 0 )
            MEM_FREE( pCover->pMem, Mvc_Cube_t *, pCover->nCubesAlloc, pCover->pCubes );
        pCover->nCubesAlloc = pCover->lCubes.nItems;
        pCover->pCubes = MEM_ALLOC( pCover->pMem, Mvc_Cube_t *, pCover->nCubesAlloc );
    }
}

void Mvc_CoverAllocateArrayLits

(

Mvc_Cover_t *

pCover

)

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 185 of file mvcCover.c.

{ 
    if ( pCover->pLits == NULL )
        pCover->pLits = MEM_ALLOC( pCover->pMem, int, pCover->nBits );
}

void Mvc_CoverAllocateMask

(

Mvc_Cover_t *

pCover

)

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 168 of file mvcCover.c.

{ 
    if ( pCover->pMask == NULL )
        pCover->pMask = Mvc_CubeAlloc( pCover );
}

int Mvc_CoverAnyLiteral	(	Mvc_Cover_t *	pCover,
		Mvc_Cube_t *	pMask
	)

DECLARATIONS ///.

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

]FUNCTION DEFINITIONS /// Function*************************************************************

Synopsis [Find the any literal that occurs more than once.]

Description []

SideEffects []

SeeAlso []

Definition at line 43 of file mvcLits.c.

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

void Mvc_CoverAppendCubes	(	Mvc_Cover_t *	pC1,
		Mvc_Cover_t *	pC2
	)

void Mvc_CoverArray2List

(

Mvc_Cover_t *

pCover

)

Function*************************************************************

Synopsis [Transfers the cubes from the array into list.]

Description []

SideEffects []

SeeAlso []

Definition at line 310 of file mvcList.c.

{
    Mvc_Cube_t * pCube;
    int nCubes, i;

    assert( pCover->pCubes );

    nCubes = Mvc_CoverReadCubeNum(pCover);
    if ( nCubes == 0 )
        return;
    if ( nCubes == 1 )
    {
        pCube    = pCover->pCubes[0];
        pCube->pNext = NULL;
        pCover->lCubes.pHead = pCover->lCubes.pTail = pCube;
        return;
    }
    // set up the first cube
    pCube = pCover->pCubes[0];
    pCover->lCubes.pHead = pCube;
    // set up the last cube
    pCube = pCover->pCubes[nCubes-1];
    pCube->pNext = NULL;
    pCover->lCubes.pTail = pCube;

    // link all cubes starting from the first one
    for ( i = 0; i < nCubes - 1; i++ )
        pCover->pCubes[i]->pNext = pCover->pCubes[i+1];
}

int Mvc_CoverBestLiteral	(	Mvc_Cover_t *	pCover,
		Mvc_Cube_t *	pMask
	)

Function*************************************************************

Synopsis [Find the most often occurring literal.]

Description [Find the most often occurring literal among those that occur more than once.]

SideEffects []

SeeAlso []

Definition at line 104 of file mvcLits.c.

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

Mvc_Cover_t* Mvc_CoverBestLiteralCover	(	Mvc_Cover_t *	pCover,
		Mvc_Cover_t *	pSimple
	)

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 223 of file mvcLits.c.

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

Mvc_Cover_t* Mvc_CoverBooleanAnd	(	Mvc_Data_t *	p,
		Mvc_Cover_t *	pCover1,
		Mvc_Cover_t *	pCover2
	)

int Mvc_CoverBooleanEqual	(	Mvc_Data_t *	p,
		Mvc_Cover_t *	pCover1,
		Mvc_Cover_t *	pCover2
	)

Mvc_Cover_t* Mvc_CoverBooleanOr	(	Mvc_Cover_t *	pCover1,
		Mvc_Cover_t *	pCover2
	)

DECLARATIONS ///.

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

FileName [mvcProc.c]

PackageName [MVSIS 2.0: Multi-valued logic synthesis system.]

Synopsis [Various boolean procedures working with covers.]

Author [MVSIS Group]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - February 1, 2003.]

Revision [

Id:

mvcOpBool.c,v 1.4 2003/04/16 01:55:37 alanmi Exp

]FUNCTION DEFINITIONS /// Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 43 of file mvcOpBool.c.

{
    Mvc_Cover_t * pCover;
    Mvc_Cube_t * pCube, * pCubeCopy;
    // make sure the covers are compatible
    assert( pCover1->nBits == pCover2->nBits );
    // clone the cover
    pCover = Mvc_CoverClone( pCover1 );
    // create the cubes by making pair-wise products
    // of cubes in pCover1 and pCover2
    Mvc_CoverForEachCube( pCover1, pCube )
    {
        pCubeCopy = Mvc_CubeDup( pCover, pCube );
        Mvc_CoverAddCubeTail( pCover, pCubeCopy );
    }
    Mvc_CoverForEachCube( pCover2, pCube )
    {
        pCubeCopy = Mvc_CubeDup( pCover, pCube );
        Mvc_CoverAddCubeTail( pCover, pCubeCopy );
    }
    return pCover;
}

int Mvc_CoverCheckSuppContainment	(	Mvc_Cover_t *	pCover1,
		Mvc_Cover_t *	pCover2
	)

Function*************************************************************

Synopsis [Returns 1 if the support of cover2 is contained in the support of cover1.]

Description []

SideEffects []

SeeAlso []

Definition at line 247 of file mvcUtils.c.

{
    int Result;
    assert( pCover1->nBits == pCover2->nBits );
    // set the supports
    Mvc_CoverAllocateMask( pCover1 );
    Mvc_CoverSupport( pCover1, pCover1->pMask );
    Mvc_CoverAllocateMask( pCover2 );
    Mvc_CoverSupport( pCover2, pCover2->pMask );
    // check the containment
    Mvc_CubeBitNotImpl( Result, pCover2->pMask, pCover1->pMask );
    return !Result;
}

Mvc_Cover_t* Mvc_CoverClone

(

Mvc_Cover_t *

p

)

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 79 of file mvcCover.c.

{
    Mvc_Cover_t * pCover;
#ifdef USE_SYSTEM_MEMORY_MANAGEMENT
    pCover                = (Mvc_Cover_t *)ABC_ALLOC( char, sizeof(Mvc_Cover_t) );
#else
    pCover                = (Mvc_Cover_t *)Extra_MmFixedEntryFetch( p->pMem->pManC );
#endif
    pCover->pMem          = p->pMem;
    pCover->nBits         = p->nBits;
    pCover->nWords        = p->nWords;
    pCover->nUnused       = p->nUnused;
    pCover->lCubes.nItems = 0;
    pCover->lCubes.pHead  = NULL;
    pCover->lCubes.pTail  = NULL;
    pCover->nCubesAlloc   = 0;
    pCover->pCubes        = NULL;
    pCover->pMask         = NULL;
    pCover->pLits         = NULL;
    return pCover;
}

Mvc_Cover_t* Mvc_CoverCofactor	(	Mvc_Cover_t *	p,
		int	iValue,
		int	iValueOther
	)

Function*************************************************************

Synopsis [Returns the cofactor w.r.t. to a binary var.]

Description []

SideEffects []

SeeAlso []

Definition at line 518 of file mvcUtils.c.

{
    Mvc_Cover_t * pCover;
    Mvc_Cube_t * pCube, * pCubeCopy;
    // clone the cover
    pCover = Mvc_CoverClone( p );
    // copy the cube list
    Mvc_CoverForEachCube( p, pCube )
        if ( Mvc_CubeBitValue( pCube, iValue ) )
        {
            pCubeCopy = Mvc_CubeDup( pCover, pCube );
            Mvc_CoverAddCubeTail( pCover, pCubeCopy );
            Mvc_CubeBitInsert( pCubeCopy, iValueOther );
        }
    return pCover;
}

Mvc_Cover_t** Mvc_CoverCofactors	(	Mvc_Data_t *	pData,
		Mvc_Cover_t *	pCover,
		int	iVar
	)

void Mvc_CoverCommonCube	(	Mvc_Cover_t *	pCover,
		Mvc_Cube_t *	pComCube
	)

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 155 of file mvcUtils.c.

{
    Mvc_Cube_t * pCube;
    // clean the support
    Mvc_CubeBitFill( pComCube );
    // collect the support
    Mvc_CoverForEachCube( pCover, pCube )
        Mvc_CubeBitAnd( pComCube, pComCube, pCube );
}

Mvc_Cover_t* Mvc_CoverCommonCubeCover

(

Mvc_Cover_t *

pCover

)

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 220 of file mvcUtils.c.

{
    Mvc_Cover_t * pRes;
    Mvc_Cube_t * pCube;
    // create the new cover
    pRes = Mvc_CoverClone( pCover );
    // get the new cube
    pCube = Mvc_CubeAlloc( pRes );
    // get the common cube
    Mvc_CoverCommonCube( pCover, pCube );
    // add the cube to the cover
    Mvc_CoverAddCubeTail( pRes, pCube );
    return pRes;
}

Mvc_Cover_t* Mvc_CoverComplement	(	Mvc_Data_t *	p,
		Mvc_Cover_t *	pCover
	)

int Mvc_CoverContain

(

Mvc_Cover_t *

pCover

)

FUNCTION DEFINITIONS ///.

Function*************************************************************

Synopsis [Removes the contained cubes.]

Description [Returns 1 if the cover has been changed.]

SideEffects []

SeeAlso []

Definition at line 47 of file mvcContain.c.

{
    int nCubes;
    nCubes = Mvc_CoverReadCubeNum( pCover );
    if ( nCubes < 2 )
        return 0;
    Mvc_CoverSetCubeSizes(pCover);
    Mvc_CoverSort( pCover, NULL, Mvc_CubeCompareSizeAndInt );
    Mvc_CoverRemoveDuplicates( pCover );
    if ( nCubes > 1 )
        Mvc_CoverRemoveContained( pCover );
    return (nCubes != Mvc_CoverReadCubeNum(pCover));
}

void Mvc_CoverCopyAndAppendCubes	(	Mvc_Cover_t *	pC1,
		Mvc_Cover_t *	pC2
	)

int Mvc_CoverCountCubePairDiffs	(	Mvc_Cover_t *	pCover,
		unsigned char	pDiffs[]
	)

Function*************************************************************

Synopsis [Counts the differences in each cube pair in the cover.]

Description [Takes the cover (pCover) and the array where the diff counters go (pDiffs). The array pDiffs should have as many entries as there are different pairs of cubes in the cover: n(n-1)/2. Fills out the array pDiffs with the following info: For each cube pair, included in the array is the number of literals in both cubes after they are made cube ABC_FREE.]

SideEffects []

SeeAlso []

Definition at line 342 of file mvcUtils.c.

{
    Mvc_Cube_t * pCube1;
    Mvc_Cube_t * pCube2;
    Mvc_Cube_t * pMask;
    unsigned char * pByte, * pByteStart, * pByteStop;
    int nBytes, nOnes;
    int nCubePairs;

    // allocate a temporary mask
    pMask = Mvc_CubeAlloc( pCover );
    // get the number of unsigned chars in the cube's bit strings
    nBytes = pCover->nBits / (8 * sizeof(unsigned char)) + (int)(pCover->nBits % (8 * sizeof(unsigned char)) > 0);
    // iterate through the cubes
    nCubePairs = 0;
    Mvc_CoverForEachCube( pCover, pCube1 )
    {
        Mvc_CoverForEachCubeStart( Mvc_CubeReadNext(pCube1), pCube2 )
        {
            // find the bit-wise exor of cubes
            Mvc_CubeBitExor( pMask, pCube1, pCube2 );
            // set the starting and stopping positions
            pByteStart = (unsigned char *)pMask->pData;
            pByteStop  = pByteStart + nBytes;
            // clean the counter of ones
            nOnes = 0;
            // iterate through the positions
            for ( pByte = pByteStart; pByte < pByteStop; pByte++ )
                nOnes += bit_count[*pByte];
            // set the nOnes
            pDiffs[nCubePairs++] = nOnes;
        }
    }
    // deallocate the mask
    Mvc_CubeFree( pCover, pMask );
    return 1;
}

int Mvc_CoverCountLiterals

(

Mvc_Cover_t *

pCover

)

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 []

Definition at line 287 of file mvcLits.c.

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

Mvc_Cover_t* Mvc_CoverCreateConst	(	Mvc_Manager_t *	pMem,
		int	nBits,
		int	Phase
	)

Mvc_Cover_t* Mvc_CoverCreateEmpty

(

Mvc_Cover_t *

pCover

)

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 202 of file mvcApi.c.

{
    Mvc_Cover_t * pCoverNew;
    pCoverNew = Mvc_CoverAlloc( pCover->pMem, pCover->nBits );
    return pCoverNew;
}

Mvc_Cover_t* Mvc_CoverCreateTautology

(

Mvc_Cover_t *

pCover

)

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 220 of file mvcApi.c.

{
    Mvc_Cube_t * pCubeNew;
    Mvc_Cover_t * pCoverNew;
    pCoverNew = Mvc_CoverAlloc( pCover->pMem, pCover->nBits );
    pCubeNew = Mvc_CubeAlloc( pCoverNew );
    Mvc_CubeBitFill( pCubeNew );
    Mvc_CoverAddCubeTail( pCoverNew, pCubeNew );
    return pCoverNew;
}

void Mvc_CoverDeallocateArrayLits

(

Mvc_Cover_t *

pCover

)

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 241 of file mvcCover.c.

{ 
    if ( pCover->pLits )
    {
        MEM_FREE( pCover->pMem, int, pCover->nBits, pCover->pLits );
        pCover->pLits = NULL;
    }
}

void Mvc_CoverDeallocateMask

(

Mvc_Cover_t *

pCover

)

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 224 of file mvcCover.c.

{ 
    Mvc_CubeFree( pCover, pCover->pMask );
    pCover->pMask = NULL;
}

void Mvc_CoverDeleteCube_	(	Mvc_Cover_t *	pCover,
		Mvc_Cube_t *	pPrev,
		Mvc_Cube_t *	pCube
	)

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 173 of file mvcList.c.

{
    Mvc_List_t * pList = &pCover->lCubes;
 
    if ( pPrev == NULL ) // deleting the head cube
        pList->pHead = Mvc_CubeReadNext(pCube);
    else
        pPrev->pNext = pCube->pNext;
    if ( pList->pTail == pCube ) // deleting the tail cube
    {
        assert( Mvc_CubeReadNext(pCube) == NULL );
        pList->pTail = pPrev;
    }
    pList->nItems--;
}

void Mvc_CoverDeleteLiteralsOfCube	(	Mvc_Cover_t *	pCover,
		Mvc_Cube_t *	pCube
	)

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 265 of file mvcList.c.

{
//    int iBit, Value;
//    assert( pCover->pLits );
//    Mvc_CubeForEachBit( pCover, pCube, iBit, Value )
//        if ( Value )
//            pCover->pLits[iBit] -= Value;
}

int Mvc_CoverDist0Cubes	(	Mvc_Data_t *	pData,
		Mvc_Cube_t *	pA,
		Mvc_Cube_t *	pB
	)

void Mvc_CoverDist1Merge	(	Mvc_Data_t *	p,
		Mvc_Cover_t *	pCover
	)

void Mvc_CoverDivide	(	Mvc_Cover_t *	pCover,
		Mvc_Cover_t *	pDiv,
		Mvc_Cover_t **	ppQuo,
		Mvc_Cover_t **	ppRem
	)

FUNCTION DEFINITIONS ///.

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 47 of file mvcDivide.c.

{
    // check the number of cubes
    if ( Mvc_CoverReadCubeNum( pCover ) < Mvc_CoverReadCubeNum( pDiv ) )
    {
        *ppQuo = NULL;
        *ppRem = NULL;
        return;
    }

    // make sure that support of pCover contains that of pDiv
    if ( !Mvc_CoverCheckSuppContainment( pCover, pDiv ) )
    {
        *ppQuo = NULL;
        *ppRem = NULL;
        return;
    }

    // perform the general division
    Mvc_CoverDivideInternal( pCover, pDiv, ppQuo, ppRem );
}

void Mvc_CoverDivideByCube	(	Mvc_Cover_t *	pCover,
		Mvc_Cover_t *	pDiv,
		Mvc_Cover_t **	ppQuo,
		Mvc_Cover_t **	ppRem
	)

Function*************************************************************

Synopsis [Divides the cover by a cube.]

Description []

SideEffects []

SeeAlso []

Definition at line 269 of file mvcDivide.c.

{
    Mvc_Cover_t * pQuo, * pRem;
    Mvc_Cube_t * pCubeC, * pCubeD, * pCubeCopy;
    int CompResult;

    // get the only cube of D
    assert( Mvc_CoverReadCubeNum(pDiv) == 1 );

    // start the quotient and the remainder
    pQuo = Mvc_CoverAlloc( pCover->pMem, pCover->nBits );
    pRem = Mvc_CoverAlloc( pCover->pMem, pCover->nBits );

    // get the first and only cube of the divisor
    pCubeD = Mvc_CoverReadCubeHead( pDiv );

    // iterate through the cubes in the cover
    Mvc_CoverForEachCube( pCover, pCubeC )
    {
        // check the containment of literals from pCubeD in pCube
        Mvc_Cube2BitNotImpl( CompResult, pCubeD, pCubeC );
        if ( !CompResult )
        { // this cube belongs to the quotient
            // alloc the cube
            pCubeCopy = Mvc_CubeAlloc( pQuo );
            // clean the support of D
            Mvc_CubeBitSharp( pCubeCopy, pCubeC, pCubeD );
            // add the cube to the quotient
            Mvc_CoverAddCubeTail( pQuo, pCubeCopy );
        }
        else
        { 
            // copy the cube
            pCubeCopy = Mvc_CubeDup( pRem, pCubeC );
            // add the cube to the remainder
            Mvc_CoverAddCubeTail( pRem, pCubeCopy );
        }
    }
    // return the results
    *ppRem = pRem;
    *ppQuo = pQuo;
}

void Mvc_CoverDivideByLiteral	(	Mvc_Cover_t *	pCover,
		Mvc_Cover_t *	pDiv,
		Mvc_Cover_t **	ppQuo,
		Mvc_Cover_t **	ppRem
	)

Function*************************************************************

Synopsis [Divides the cover by a literal.]

Description []

SideEffects []

SeeAlso []

Definition at line 323 of file mvcDivide.c.

{
    Mvc_Cover_t * pQuo, * pRem;
    Mvc_Cube_t * pCubeC, * pCubeCopy;
    int iLit;

    // get the only cube of D
    assert( Mvc_CoverReadCubeNum(pDiv) == 1 );

    // start the quotient and the remainder
    pQuo = Mvc_CoverAlloc( pCover->pMem, pCover->nBits );
    pRem = Mvc_CoverAlloc( pCover->pMem, pCover->nBits );

    // get the first and only literal in the divisor cube
    iLit = Mvc_CoverFirstCubeFirstLit( pDiv );

    // iterate through the cubes in the cover
    Mvc_CoverForEachCube( pCover, pCubeC )
    {
        // copy the cube
        pCubeCopy = Mvc_CubeDup( pCover, pCubeC );
        // add the cube to the quotient or to the remainder depending on the literal
        if ( Mvc_CubeBitValue( pCubeCopy, iLit ) )
        {   // remove the literal
            Mvc_CubeBitRemove( pCubeCopy, iLit );
            // add the cube ot the quotient
            Mvc_CoverAddCubeTail( pQuo, pCubeCopy );
        }
        else
        {   // add the cube ot the remainder
            Mvc_CoverAddCubeTail( pRem, pCubeCopy );
        }
    }
    // return the results
    *ppRem = pRem;
    *ppQuo = pQuo;
}

void Mvc_CoverDivideByLiteralQuo	(	Mvc_Cover_t *	pCover,
		int	iLit
	)

Function*************************************************************

Synopsis [Derives the quotient of division by literal.]

Description [Reduces the cover to be the equal to the result of division of the given cover by the literal.]

SideEffects []

SeeAlso []

Definition at line 374 of file mvcDivide.c.

{
    Mvc_Cube_t * pCube, * pCube2, * pPrev;
    // delete those cubes that do not have this literal
    // remove this literal from other cubes
    pPrev = NULL;
    Mvc_CoverForEachCubeSafe( pCover, pCube, pCube2 )
    {
        if ( Mvc_CubeBitValue( pCube, iLit ) == 0 )
        { // delete the cube from the cover
            Mvc_CoverDeleteCube( pCover, pPrev, pCube );
            Mvc_CubeFree( pCover, pCube );
            // don't update the previous cube
        }
        else
        { // delete this literal from the cube
            Mvc_CubeBitRemove( pCube, iLit );
            // update the previous cube
            pPrev = pCube;
        }
    }
}

void Mvc_CoverDivideInternal	(	Mvc_Cover_t *	pCover,
		Mvc_Cover_t *	pDiv,
		Mvc_Cover_t **	ppQuo,
		Mvc_Cover_t **	ppRem
	)

Function*************************************************************

Synopsis [Merge the cubes inside the groups.]

Description []

SideEffects []

SeeAlso []

Definition at line 81 of file mvcDivide.c.

{
    Mvc_Cover_t * pQuo, * pRem;
    Mvc_Cube_t * pCubeC, * pCubeD, * pCubeCopy;
    Mvc_Cube_t * pCube1, * pCube2;
    int * pGroups, nGroups;    // the cube groups
    int nCubesC, nCubesD, nMerges, iCubeC, iCubeD;
    int iMerge = -1; // Suppress "might be used uninitialized"
    int fSkipG, GroupSize, g, c, RetValue;
    int nCubes;

    // get cover sizes
    nCubesD = Mvc_CoverReadCubeNum( pDiv );
    nCubesC = Mvc_CoverReadCubeNum( pCover );

    // check trivial cases
    if ( nCubesD == 1 )
    {
        if ( Mvc_CoverIsOneLiteral( pDiv ) )
            Mvc_CoverDivideByLiteral( pCover, pDiv, ppQuo, ppRem );
        else
            Mvc_CoverDivideByCube( pCover, pDiv, ppQuo, ppRem );
        return;
    }

    // create the divisor and the remainder 
    pQuo = Mvc_CoverAlloc( pCover->pMem, pCover->nBits );
    pRem = Mvc_CoverAlloc( pCover->pMem, pCover->nBits );

    // get the support of the divisor
    Mvc_CoverAllocateMask( pDiv );
    Mvc_CoverSupport( pDiv, pDiv->pMask );

    // sort the cubes of the divisor
    Mvc_CoverSort( pDiv, NULL, Mvc_CubeCompareInt );
    // sort the cubes of the cover
    Mvc_CoverSort( pCover, pDiv->pMask, Mvc_CubeCompareIntOutsideAndUnderMask );

    // allocate storage for cube groups
    pGroups = MEM_ALLOC( pCover->pMem, int, nCubesC + 1 );

    // mask contains variables in the support of Div
    // split the cubes into groups using the mask
    Mvc_CoverList2Array( pCover );
    Mvc_CoverList2Array( pDiv );
    pGroups[0] = 0;
    nGroups    = 1;
    for ( c = 1; c < nCubesC; c++ )
    {
        // get the cubes
        pCube1 = pCover->pCubes[c-1];
        pCube2 = pCover->pCubes[c  ];
        // compare the cubes
        Mvc_CubeBitEqualOutsideMask( RetValue, pCube1, pCube2, pDiv->pMask );
        if ( !RetValue )
            pGroups[nGroups++] = c;
    }
    // finish off the last group
    pGroups[nGroups] = nCubesC;

    // consider each group separately and decide
    // whether it can produce a quotient cube
    nCubes = 0;
    for ( g = 0; g < nGroups; g++ )
    {
        // if the group has less than nCubesD cubes, 
        // there is no way it can produce the quotient cube
        // copy the cubes to the remainder
        GroupSize = pGroups[g+1] - pGroups[g];
        if ( GroupSize < nCubesD )
        {
            for ( c = pGroups[g]; c < pGroups[g+1]; c++ )
            {
                pCubeCopy = Mvc_CubeDup( pRem, pCover->pCubes[c] );
                Mvc_CoverAddCubeTail( pRem, pCubeCopy );
                nCubes++;
            }
            continue;
        }

        // mark the cubes as those that should be added to the remainder
        for ( c = pGroups[g]; c < pGroups[g+1]; c++ )
            Mvc_CubeSetSize( pCover->pCubes[c], 1 );

        // go through the cubes in the group and at the same time
        // go through the cubes in the divisor
        iCubeD  = 0;
        iCubeC  = 0;
        pCubeD  = pDiv->pCubes[iCubeD++];
        pCubeC  = pCover->pCubes[pGroups[g]+iCubeC++];
        fSkipG  = 0;
        nMerges = 0;

        while ( 1 )
        {
            // compare the topmost cubes in F and in D
            RetValue = Mvc_CubeCompareIntUnderMask( pCubeC, pCubeD, pDiv->pMask );
            // cube are ordered in increasing order of their int value
            if ( RetValue == -1 ) // pCubeC is above pCubeD
            {  // cube in C should be added to the remainder
                // check that there is enough cubes in the group
                if ( GroupSize - iCubeC < nCubesD - nMerges )
                {
                    fSkipG = 1;
                    break;
                }
                // get the next cube in the cover
                pCubeC = pCover->pCubes[pGroups[g]+iCubeC++];
                continue;
            }
            if ( RetValue == 1 ) // pCubeD is above pCubeC
            { // given cube in D does not have a corresponding cube in the cover
                fSkipG = 1;
                break;
            }
            // mark the cube as the one that should NOT be added to the remainder
            Mvc_CubeSetSize( pCubeC, 0 );
            // remember this merged cube
            iMerge = iCubeC-1;
            nMerges++;

            // stop if we considered the last cube of the group
            if ( iCubeD == nCubesD )
                break;

            // advance the cube of the divisor
            assert( iCubeD < nCubesD );
            pCubeD = pDiv->pCubes[iCubeD++];

            // advance the cube of the group
            assert( pGroups[g]+iCubeC < nCubesC );
            pCubeC = pCover->pCubes[pGroups[g]+iCubeC++];
        }

        if ( fSkipG )
        { 
            // the group has failed, add all the cubes to the remainder
            for ( c = pGroups[g]; c < pGroups[g+1]; c++ )
            {
                pCubeCopy = Mvc_CubeDup( pRem, pCover->pCubes[c] );
                Mvc_CoverAddCubeTail( pRem, pCubeCopy );
                nCubes++;
            }
            continue;
        }

        // the group has worked, add left-over cubes to the remainder
        for ( c = pGroups[g]; c < pGroups[g+1]; c++ )
        {
            pCubeC = pCover->pCubes[c];
            if ( Mvc_CubeReadSize(pCubeC) )
            {
                pCubeCopy = Mvc_CubeDup( pRem, pCubeC );
                Mvc_CoverAddCubeTail( pRem, pCubeCopy );
                nCubes++;
            }
        }

        // create the quotient cube
        pCube1 = Mvc_CubeAlloc( pQuo );
        Mvc_CubeBitSharp( pCube1, pCover->pCubes[pGroups[g]+iMerge], pDiv->pMask );
        // add the cube to the quotient
        Mvc_CoverAddCubeTail( pQuo, pCube1 );
        nCubes += nCubesD;
    }
    assert( nCubes == nCubesC );

    // deallocate the memory
    MEM_FREE( pCover->pMem, int, nCubesC + 1, pGroups );

    // return the results
    *ppRem = pRem;
    *ppQuo = pQuo;
//    Mvc_CoverVerifyDivision( pCover, pDiv, pQuo, pRem );
}

Mvc_Cover_t* Mvc_CoverDivisor

(

Mvc_Cover_t *

pCover

)

FUNCTION DEFINITIONS ///.

Function*************************************************************

Synopsis [Returns the quick divisor of the cover.]

Description [Returns NULL, if there is not divisor other than trivial.]

SideEffects []

SeeAlso []

Definition at line 46 of file mvcDivisor.c.

{
    Mvc_Cover_t * pKernel;
    if ( Mvc_CoverReadCubeNum(pCover) <= 1 )
        return NULL;
    // allocate the literal array and count literals
    if ( Mvc_CoverAnyLiteral( pCover, NULL ) == -1 )
        return NULL;
    // duplicate the cover
    pKernel = Mvc_CoverDup(pCover);
    // perform the kerneling
    Mvc_CoverDivisorZeroKernel( pKernel );
    assert( Mvc_CoverReadCubeNum(pKernel) );
    return pKernel;
}

Mvc_Cover_t* Mvc_CoverDup

(

Mvc_Cover_t *

p

)

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 112 of file mvcCover.c.

{
    Mvc_Cover_t * pCover;
    Mvc_Cube_t * pCube, * pCubeCopy;
    // clone the cover
    pCover = Mvc_CoverClone( p );
    // copy the cube list
    Mvc_CoverForEachCube( p, pCube )
    {
        pCubeCopy = Mvc_CubeDup( p, pCube );
        Mvc_CoverAddCubeTail( pCover, pCubeCopy );
    }
    return pCover;
}

int Mvc_CoverFirstCubeFirstLit

(

Mvc_Cover_t *

pCover

)

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 261 of file mvcLits.c.

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

Mvc_Cover_t* Mvc_CoverFlipVar	(	Mvc_Cover_t *	p,
		int	iValue0,
		int	iValue1
	)

Function*************************************************************

Synopsis [Returns the cover, in which the binary var is complemented.]

Description []

SideEffects []

SeeAlso []

Definition at line 546 of file mvcUtils.c.

{
    Mvc_Cover_t * pCover;
    Mvc_Cube_t * pCube, * pCubeCopy;
    int Value0, Value1, Temp;

    assert( iValue0 + 1 == iValue1 ); // should be adjacent

    // clone the cover
    pCover = Mvc_CoverClone( p );
    // copy the cube list
    Mvc_CoverForEachCube( p, pCube )
    {
        pCubeCopy = Mvc_CubeDup( pCover, pCube );
        Mvc_CoverAddCubeTail( pCover, pCubeCopy );

        // get the bits
        Value0 = Mvc_CubeBitValue( pCubeCopy, iValue0 );
        Value1 = Mvc_CubeBitValue( pCubeCopy, iValue1 );

        // if both bits are one, nothing to swap
        if ( Value0 && Value1 )
            continue;
        // cannot be both zero because they belong to the same var
        assert( Value0 || Value1 ); 

        // swap the bits
        Temp   = Value0;
        Value0 = Value1;
        Value1 = Temp;

        // set the bits after the swap
        if ( Value0 )
            Mvc_CubeBitInsert( pCubeCopy, iValue0 );
        else
            Mvc_CubeBitRemove( pCubeCopy, iValue0 );

        if ( Value1 )
            Mvc_CubeBitInsert( pCubeCopy, iValue1 );
        else
            Mvc_CubeBitRemove( pCubeCopy, iValue1 );
    }
    return pCover;
}

void Mvc_CoverFree

(

Mvc_Cover_t *

p

)

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 138 of file mvcCover.c.

{
    Mvc_Cube_t * pCube, * pCube2;
    // recycle cube list
    Mvc_CoverForEachCubeSafe( p, pCube, pCube2 )
        Mvc_CubeFree( p, pCube );
    // recycle other pointers
    Mvc_CubeFree( p, p->pMask );
    MEM_FREE( p->pMem, Mvc_Cube_t *, p->nCubesAlloc, p->pCubes );
    MEM_FREE( p->pMem, int,          p->nBits,       p->pLits  );

#ifdef USE_SYSTEM_MEMORY_MANAGEMENT
    ABC_FREE( p );
#else
    Extra_MmFixedEntryRecycle( p->pMem->pManC, (char *)p );
#endif
}

int Mvc_CoverGetCubeSize

(

Mvc_Cube_t *

pCube

)

Function*************************************************************

Synopsis [Counts the cube sizes.]

Description []

SideEffects []

SeeAlso []

Definition at line 308 of file mvcUtils.c.

{
    unsigned char * pByte, * pByteStart, * pByteStop;
    int nOnes, nBytes, nBits;
    // get the number of unsigned chars in the cube's bit strings
    nBits = (pCube->iLast + 1) * sizeof(Mvc_CubeWord_t) * 8 - pCube->nUnused;
    nBytes = nBits / (8 * sizeof(unsigned char)) + (int)(nBits % (8 * sizeof(unsigned char)) > 0);
    // clean the counter of ones
    nOnes = 0;
    // set the starting and stopping positions
    pByteStart = (unsigned char *)pCube->pData;
    pByteStop  = pByteStart + nBytes;
    // iterate through the positions
    for ( pByte = pByteStart; pByte < pByteStop; pByte++ )
        nOnes += bit_count[*pByte];
    return nOnes;
}

void Mvc_CoverIntersectCubes	(	Mvc_Data_t *	pData,
		Mvc_Cover_t *	pC1,
		Mvc_Cover_t *	pC2
	)

void Mvc_CoverInverse

(

Mvc_Cover_t *

pCover

)

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 477 of file mvcUtils.c.

{
    Mvc_Cube_t * pCube;
    // complement the cubes
    Mvc_CoverForEachCube( pCover, pCube )
        Mvc_CubeBitNot( pCube );
}

int Mvc_CoverIsBinaryBuffer

(

Mvc_Cover_t *

pCover

)

Function*************************************************************

Synopsis [Returns 1 if the cover is a binary buffer.]

Description []

SideEffects []

SeeAlso []

Definition at line 135 of file mvcApi.c.

{
    Mvc_Cube_t * pCube;
    if ( pCover->nBits != 2 )
        return 0;
    if ( Mvc_CoverReadCubeNum(pCover) != 1 )
        return 0;
    pCube = pCover->lCubes.pHead;
    if ( Mvc_CubeBitValue(pCube, 0) == 0 && Mvc_CubeBitValue(pCube, 1) == 1 )
        return 1;
    return 0;
}

int Mvc_CoverIsCubeFree

(

Mvc_Cover_t *

pCover

)

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 176 of file mvcUtils.c.

{
    int Result;
    // get the common cube
    Mvc_CoverAllocateMask( pCover );
    Mvc_CoverCommonCube( pCover, pCover->pMask );
    // check whether the common cube is empty
    Mvc_CubeBitEmpty( Result, pCover->pMask );
    return Result;
}

int Mvc_CoverIsEmpty

(

Mvc_Cover_t *

pCover

)

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 93 of file mvcApi.c.

{
    return Mvc_CoverReadCubeNum(pCover) == 0;
}

int Mvc_CoverIsIntersecting	(	Mvc_Data_t *	pData,
		Mvc_Cover_t *	pC1,
		Mvc_Cover_t *	pC2
	)

int Mvc_CoverIsOneLiteral

(

Mvc_Cover_t *

pCover

)

Function*************************************************************

Synopsis [Returns the number of literals in the cover.]

Description []

SideEffects []

SeeAlso []

Definition at line 324 of file mvcLits.c.

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

int Mvc_CoverIsTautology

(

Mvc_Cover_t *

pCover

)

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 109 of file mvcApi.c.

{
    Mvc_Cube_t * pCube;
    int iBit, Value;

    if ( Mvc_CoverReadCubeNum(pCover) != 1 )
        return 0;

    pCube = Mvc_CoverReadCubeHead( pCover );
    Mvc_CubeForEachBit( pCover, pCube, iBit, Value )
        if ( Value == 0 )
            return 0;
    return 1;
}

void Mvc_CoverList2Array

(

Mvc_Cover_t *

pCover

)

Function*************************************************************

Synopsis [Transfers the cubes from the list into the array.]

Description []

SideEffects []

SeeAlso []

Definition at line 286 of file mvcList.c.

{
    Mvc_Cube_t * pCube;
    int Counter;
    // resize storage if necessary
    Mvc_CoverAllocateArrayCubes( pCover );
    // iterate through the cubes
    Counter = 0;
    Mvc_CoverForEachCube( pCover, pCube )
        pCover->pCubes[ Counter++ ] = pCube;
    assert( Counter == Mvc_CoverReadCubeNum(pCover) );
}

void Mvc_CoverMakeCubeFree

(

Mvc_Cover_t *

pCover

)

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 198 of file mvcUtils.c.

{
    Mvc_Cube_t * pCube;
    // get the common cube
    Mvc_CoverAllocateMask( pCover );
    Mvc_CoverCommonCube( pCover, pCover->pMask );
    // remove this cube from the cubes in the cover
    Mvc_CoverForEachCube( pCover, pCube )
        Mvc_CubeBitSharp( pCube, pCube, pCover->pMask );
}

void Mvc_CoverMakeEmpty

(

Mvc_Cover_t *

pCover

)

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 160 of file mvcApi.c.

{
    Mvc_Cube_t * pCube, * pCube2;
    Mvc_CoverForEachCubeSafe( pCover, pCube, pCube2 )
        Mvc_CubeFree( pCover, pCube );
    pCover->lCubes.nItems = 0;
    pCover->lCubes.pHead = NULL;
    pCover->lCubes.pTail = NULL;
}

void Mvc_CoverMakeTautology

(

Mvc_Cover_t *

pCover

)

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 181 of file mvcApi.c.

{
    Mvc_Cube_t * pCubeNew;
    Mvc_CoverMakeEmpty( pCover );
    pCubeNew = Mvc_CubeAlloc( pCover );
    Mvc_CubeBitFill( pCubeNew );
    Mvc_CoverAddCubeTail( pCover, pCubeNew );
}

void Mvc_CoverMinimizeByReshape	(	Mvc_Data_t *	pData,
		Mvc_Cover_t *	pCover
	)

void Mvc_CoverPrint

(

Mvc_Cover_t *

pCover

)

FUNCTION DEFINITIONS ///.

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 47 of file mvcPrint.c.

{
    Mvc_Cube_t * pCube;
    int i;
    // print general statistics
    printf( "The cover contains %d cubes (%d bits and %d words)\n", 
        pCover->lCubes.nItems, pCover->nBits, pCover->nWords );
    // iterate through the cubes
    Mvc_CoverForEachCube( pCover, pCube )
        Mvc_CubePrint( pCover, pCube );

    if ( pCover->pLits )
    {
        for ( i = 0; i < pCover->nBits; i++ )
            printf( " %d", pCover->pLits[i] );
        printf( "\n" ); 
    }
    printf( "End of cover printout\n" ); 
}

void Mvc_CoverPrintMv	(	Mvc_Data_t *	pData,
		Mvc_Cover_t *	pCover
	)

int Mvc_CoverReadBitNum

(

Mvc_Cover_t *

pCover

)

Definition at line 44 of file mvcApi.c.

{ return pCover->nBits;          }

Mvc_Cube_t* Mvc_CoverReadCubeHead

(

Mvc_Cover_t *

pCover

)

Definition at line 46 of file mvcApi.c.

{ return pCover->lCubes.pHead;  }

Mvc_List_t* Mvc_CoverReadCubeList

(

Mvc_Cover_t *

pCover

)

Definition at line 48 of file mvcApi.c.

{ return &pCover->lCubes;        }

int Mvc_CoverReadCubeNum

(

Mvc_Cover_t *

pCover

)

Definition at line 45 of file mvcApi.c.

{ return pCover->lCubes.nItems; }

Mvc_Cube_t* Mvc_CoverReadCubeTail

(

Mvc_Cover_t *

pCover

)

Definition at line 47 of file mvcApi.c.

{ return pCover->lCubes.pTail;  }

int Mvc_CoverReadWordNum

(

Mvc_Cover_t *

pCover

)

FUNCTION DEFINITIONS ///.

FUNCTION DEFINITIONS ///.

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

FileName [mvcApi.c]

PackageName [MVSIS 2.0: Multi-valued logic synthesis system.]

Synopsis []

Author [MVSIS Group]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - February 1, 2003.]

Revision [

Id:

mvcApi.c,v 1.4 2003/04/03 06:31:48 alanmi Exp

]FUNCTION DEFINITIONS /// Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 43 of file mvcApi.c.

{ return pCover->nWords;         }

Mvc_Cover_t* Mvc_CoverRemap	(	Mvc_Cover_t *	p,
		int *	pVarsRem,
		int	nVarsRem
	)

Function*************************************************************

Synopsis [Creates a new cover containing some literals of the old cover.]

Description [Creates the new cover containing the given number (nVarsRem) literals of the old cover. All the bits of the new cover are initialized to "1". The selected bits from the old cover are copied on top. The numbers of the selected bits to copy are given in the array pVarsRem. The i-set entry in this array is the index of the bit in the old cover which goes to the i-th place in the new cover. If the i-th entry in pVarsRem is -1, it means that the i-th bit does not change (remains composed of all 1's). This is a useful feature to speed up remapping covers, which are known to depend only on a subset of input variables.]

SideEffects []

SeeAlso []

Definition at line 400 of file mvcUtils.c.

{
    Mvc_Cover_t * pCover;
    Mvc_Cube_t * pCube, * pCubeCopy;
    int i;
    // clone the cover
    pCover = Mvc_CoverAlloc( p->pMem, nVarsRem );
    // copy the cube list
    Mvc_CoverForEachCube( p, pCube )
    {
        pCubeCopy = Mvc_CubeAlloc( pCover );
        //Mvc_CubeBitClean( pCubeCopy );   //changed by wjiang
        Mvc_CubeBitFill( pCubeCopy );      //changed by wjiang
        Mvc_CoverAddCubeTail( pCover, pCubeCopy );
    }
    // copy the corresponding columns
    for ( i = 0; i < nVarsRem; i++ )
    {
        if (pVarsRem[i] < 0) 
            continue;     //added by wjiang
        assert( pVarsRem[i] >= 0 && pVarsRem[i] < p->nBits );
        Mvc_CoverCopyColumn( p, pCover, pVarsRem[i], i );
    }
    return pCover;
}

void Mvc_CoverRemoveCubes

(

Mvc_Cover_t *

pC

)

Mvc_Cover_t* Mvc_CoverRemoveDontCareLits

(

Mvc_Cover_t *

pCover

)

Function*************************************************************

Synopsis [This function dups the cover and removes DC literals from cubes.]

Description []

SideEffects []

SeeAlso []

Definition at line 496 of file mvcUtils.c.

{
    Mvc_Cover_t * pCoverNew;
    Mvc_Cube_t * pCube;

    pCoverNew = Mvc_CoverDup( pCover );
    Mvc_CoverForEachCube( pCoverNew, pCube )
        Mvc_CubeBitRemoveDcs( pCube );
    return pCoverNew;
}

void Mvc_CoverSetCubeHead	(	Mvc_Cover_t *	pCover,
		Mvc_Cube_t *	pCube
	)

Definition at line 78 of file mvcApi.c.

{ pCover->lCubes.pHead = pCube;   }

void Mvc_CoverSetCubeList	(	Mvc_Cover_t *	pCover,
		Mvc_List_t *	pList
	)

Definition at line 80 of file mvcApi.c.

{ pCover->lCubes = *pList;        }

void Mvc_CoverSetCubeNum	(	Mvc_Cover_t *	pCover,
		int	nItems
	)

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 77 of file mvcApi.c.

{ pCover->lCubes.nItems = nItems; }

int Mvc_CoverSetCubeSizes

(

Mvc_Cover_t *

pCover

)

Function*************************************************************

Synopsis [Counts the cube sizes.]

Description []

SideEffects []

SeeAlso []

Definition at line 272 of file mvcUtils.c.

{
    Mvc_Cube_t * pCube;
    unsigned char * pByte, * pByteStart, * pByteStop;
    int nBytes, nOnes;

    // get the number of unsigned chars in the cube's bit strings
    nBytes = pCover->nBits / (8 * sizeof(unsigned char)) + (int)(pCover->nBits % (8 * sizeof(unsigned char)) > 0);
    // iterate through the cubes
    Mvc_CoverForEachCube( pCover, pCube )
    {
        // clean the counter of ones
        nOnes = 0;
        // set the starting and stopping positions
        pByteStart = (unsigned char *)pCube->pData;
        pByteStop  = pByteStart + nBytes;
        // iterate through the positions
        for ( pByte = pByteStart; pByte < pByteStop; pByte++ )
            nOnes += bit_count[*pByte];
        // set the nOnes
        Mvc_CubeSetSize( pCube, nOnes );
    }
    return 1;
}

void Mvc_CoverSetCubeTail	(	Mvc_Cover_t *	pCover,
		Mvc_Cube_t *	pCube
	)

Definition at line 79 of file mvcApi.c.

{ pCover->lCubes.pTail = pCube;   }

Mvc_Cover_t* Mvc_CoverSharp	(	Mvc_Data_t *	p,
		Mvc_Cover_t *	pA,
		Mvc_Cover_t *	pB
	)

void Mvc_CoverSort	(	Mvc_Cover_t *	pCover,
		Mvc_Cube_t *	pMask,
		int(*)(Mvc_Cube_t *, Mvc_Cube_t *, Mvc_Cube_t *)	pCompareFunc
	)

FuNCTION DEFINITIONS ///.

Function*************************************************************

Synopsis [Sorts cubes using the given cost function.]

Description []

SideEffects []

SeeAlso []

Definition at line 47 of file mvcSort.c.

{
    Mvc_Cube_t * pHead;
    int nCubes;
    // one cube does not need sorting
    nCubes = Mvc_CoverReadCubeNum(pCover);
    if ( nCubes <= 1 )
        return;
    // sort the cubes 
    pHead = Mvc_CoverSort_rec( Mvc_CoverReadCubeHead(pCover), nCubes, pMask, pCompareFunc ); 
    // insert the sorted list into the cover
    Mvc_CoverSetCubeHead( pCover, pHead );
    Mvc_CoverSetCubeTail( pCover, Mvc_ListGetTailFromHead(pHead) );
    // make sure that the list is sorted in the increasing order
    assert( pCompareFunc( Mvc_CoverReadCubeHead(pCover), Mvc_CoverReadCubeTail(pCover), pMask ) <= 0 );
}

void Mvc_CoverSupport	(	Mvc_Cover_t *	pCover,
		Mvc_Cube_t *	pSupp
	)

FUNCTION DEFINITIONS ///.

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 58 of file mvcUtils.c.

{
    Mvc_Cube_t * pCube;
    // clean the support
    Mvc_CubeBitClean( pSupp );
    // collect the support
    Mvc_CoverForEachCube( pCover, pCube )
        Mvc_CubeBitOr( pSupp, pSupp, pCube );
}

int Mvc_CoverSupportSizeBinary

(

Mvc_Cover_t *

pCover

)

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 100 of file mvcUtils.c.

{
    Mvc_Cube_t * pSupp;
    int Counter, i, v0, v1;
    // compute the support
    pSupp = Mvc_CubeAlloc( pCover );
    Mvc_CoverSupportAnd( pCover, pSupp );
    Counter = pCover->nBits/2;
    for ( i = 0; i < pCover->nBits/2; i++ )
    {
        v0 = Mvc_CubeBitValue( pSupp, 2*i   );
        v1 = Mvc_CubeBitValue( pSupp, 2*i+1 );
        if ( v0 && v1 )
            Counter--;
    }
    Mvc_CubeFree( pCover, pSupp );
    return Counter;
}

int Mvc_CoverSupportVarBelongs	(	Mvc_Cover_t *	pCover,
		int	iVar
	)

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 130 of file mvcUtils.c.

{
    Mvc_Cube_t * pSupp;
    int RetValue, v0, v1;
    // compute the support
    pSupp = Mvc_CubeAlloc( pCover );
    Mvc_CoverSupportAnd( pCover, pSupp );
    v0 = Mvc_CubeBitValue( pSupp, 2*iVar   );
    v1 = Mvc_CubeBitValue( pSupp, 2*iVar+1 );
    RetValue = (int)( !v0 || !v1 );
    Mvc_CubeFree( pCover, pSupp );
    return RetValue;
}

int Mvc_CoverTautology	(	Mvc_Data_t *	p,
		Mvc_Cover_t *	pCover
	)

Mvc_Cover_t* Mvc_CoverTranspose

(

Mvc_Cover_t *

pCover

)

Function*************************************************************

Synopsis [Transposes the cube cover.]

Description [Returns the cube cover that looks like a transposed matrix, compared to the matrix derived from the original cover.]

SideEffects []

SeeAlso []

Definition at line 804 of file mvcUtils.c.

{
    Mvc_Cover_t * pRes;
    Mvc_Cube_t * pCubeRes, * pCube;
    int nWord, nBit, i, iCube;

    pRes = Mvc_CoverAlloc( pCover->pMem, Mvc_CoverReadCubeNum(pCover) );
    for ( i = 0; i < pCover->nBits; i++ )
    {
        // get the word and bit of this literal
        nWord = Mvc_CubeWhichWord(i);
        nBit  = Mvc_CubeWhichBit(i);
        // get the transposed cube
        pCubeRes = Mvc_CubeAlloc( pRes );
        Mvc_CubeBitClean( pCubeRes );
        iCube = 0;
        Mvc_CoverForEachCube( pCover, pCube )
        {
            if ( pCube->pData[nWord] & (1<<nBit) )
                Mvc_CubeBitInsert( pCubeRes, iCube );
            iCube++;
        }
        Mvc_CoverAddCubeTail( pRes, pCubeRes ); 
    }
    return pRes;
}

Mvc_Cover_t* Mvc_CoverUnivQuantify	(	Mvc_Cover_t *	p,
		int	iValueA0,
		int	iValueA1,
		int	iValueB0,
		int	iValueB1
	)

Function*************************************************************

Synopsis [Returns the cover derived by universal quantification.]

Description [Returns the cover computed by universal quantification as follows: CoverNew = Univ(B) [Cover & (A==B)]. Removes the second binary var from the support (given by values iValueB0 and iValueB1). Leaves the first binary variable (given by values iValueA0 and iValueA1) in the support.]

SideEffects []

SeeAlso []

Definition at line 606 of file mvcUtils.c.

{
    Mvc_Cover_t * pCover;
    Mvc_Cube_t * pCube, * pCubeCopy;
    int ValueA0, ValueA1, ValueB0, ValueB1;

    // clone the cover
    pCover = Mvc_CoverClone( p );
    // copy the cube list
    Mvc_CoverForEachCube( p, pCube )
    {
        // get the bits
        ValueA0 = Mvc_CubeBitValue( pCube, iValueA0 );
        ValueA1 = Mvc_CubeBitValue( pCube, iValueA1 );
        ValueB0 = Mvc_CubeBitValue( pCube, iValueB0 );
        ValueB1 = Mvc_CubeBitValue( pCube, iValueB1 );

        // cannot be both zero because they belong to the same var
        assert( ValueA0 || ValueA1 ); 
        assert( ValueB0 || ValueB1 ); 

        // if the values of this var are different, do not add the cube
        if ( ValueA0 != ValueB0 && ValueA1 != ValueB1 )
            continue;

        // create the cube
        pCubeCopy = Mvc_CubeDup( pCover, pCube );
        Mvc_CoverAddCubeTail( pCover, pCubeCopy );

        // insert 1's into for the first var, if both have this value
        if ( ValueA0 && ValueB0 )
            Mvc_CubeBitInsert( pCubeCopy, iValueA0 );
        else
            Mvc_CubeBitRemove( pCubeCopy, iValueA0 );

        if ( ValueA1 && ValueB1 )
            Mvc_CubeBitInsert( pCubeCopy, iValueA1 );
        else
            Mvc_CubeBitRemove( pCubeCopy, iValueA1 );
            
        // insert 1's into for the second var (the cover does not depend on it)
        Mvc_CubeBitInsert( pCubeCopy, iValueB0 );
        Mvc_CubeBitInsert( pCubeCopy, iValueB1 );
    }
    return pCover;
}

int Mvc_CoverWorstLiteral	(	Mvc_Cover_t *	pCover,
		Mvc_Cube_t *	pMask
	)

Function*************************************************************

Synopsis [Find the most often occurring literal.]

Description [Find the most often occurring literal among those that occur more than once.]

SideEffects []

SeeAlso []

Definition at line 162 of file mvcLits.c.

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

Mvc_Cube_t* Mvc_CubeAlloc

(

Mvc_Cover_t *

pCover

)

DECLARATIONS ///.

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

FileName [mvcCube.c]

PackageName [MVSIS 2.0: Multi-valued logic synthesis system.]

Synopsis [Manipulating unate cubes.]

Author [MVSIS Group]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - February 1, 2003.]

Revision [

Id:

mvcCube.c,v 1.4 2003/04/03 06:31:49 alanmi Exp

]FUNCTION DEFINITIONS /// Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 43 of file mvcCube.c.

{
    Mvc_Cube_t * pCube;

    assert( pCover->nWords >= 0 );
    // allocate the cube
#ifdef USE_SYSTEM_MEMORY_MANAGEMENT
    if ( pCover->nWords == 0 )
        pCube = (Mvc_Cube_t *)ABC_ALLOC( char, sizeof(Mvc_Cube_t) );
    else
        pCube = (Mvc_Cube_t *)ABC_ALLOC( char,  sizeof(Mvc_Cube_t) + sizeof(Mvc_CubeWord_t) * (pCover->nWords - 1) );
#else
    switch( pCover->nWords )
    {
    case 0:
    case 1:
        pCube = (Mvc_Cube_t *)Extra_MmFixedEntryFetch( pCover->pMem->pMan1 );
        break;
    case 2:
        pCube = (Mvc_Cube_t *)Extra_MmFixedEntryFetch( pCover->pMem->pMan2 );
        break;
    case 3:
    case 4:
        pCube = (Mvc_Cube_t *)Extra_MmFixedEntryFetch( pCover->pMem->pMan4 );
        break;
    default:
        pCube = (Mvc_Cube_t *)ABC_ALLOC( char, sizeof(Mvc_Cube_t) + sizeof(Mvc_CubeWord_t) * (pCover->nWords - 1) );
        break;
    }
#endif
    // set the parameters charactering this cube
    if ( pCover->nWords == 0 )
        pCube->iLast   = pCover->nWords;
    else
        pCube->iLast   = pCover->nWords - 1;
    pCube->nUnused = pCover->nUnused;
    return pCube;
}

void Mvc_CubeBitRemoveDcs

(

Mvc_Cube_t *

pCube

)

Function*************************************************************

Synopsis [Removes the don't-care variable from the cube.]

Description []

SideEffects []

SeeAlso []

Definition at line 159 of file mvcCube.c.

{
    unsigned Mask;
    int i;
    for ( i = Mvc_CubeReadLast(pCube); i >= 0; i-- )
    {
        // detect those variables that are different (not DCs)
        Mask = (pCube->pData[i] ^ (pCube->pData[i] >> 1)) & BITS_DISJOINT; 
        // create the mask of all that are different
        Mask |= (Mask << 1);
        // remove other bits from the set
        pCube->pData[i] &= Mask;
    }
}

int Mvc_CubeCompareInt	(	Mvc_Cube_t *	pC1,
		Mvc_Cube_t *	pC2,
		Mvc_Cube_t *	pMask
	)

DECLARATIONS ///.

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

FileName [mvcCompare.c]

PackageName [MVSIS 2.0: Multi-valued logic synthesis system.]

Synopsis [Various cube comparison functions.]

Author [MVSIS Group]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - February 1, 2003.]

Revision [

Id:

mvcCompare.c,v 1.5 2003/04/03 23:25:41 alanmi Exp

]FUNCTION DEFINITIONS /// Function*************************************************************

Synopsis [Compares two cubes according to their integer value.]

Description []

SideEffects []

SeeAlso []

Definition at line 43 of file mvcCompare.c.

{
    if ( Mvc_Cube1Words(pC1) )
    {
        if ( pC1->pData[0] < pC2->pData[0] )
            return -1;
        if ( pC1->pData[0] > pC2->pData[0] )
            return 1;
        return 0;
    }
    else if ( Mvc_Cube2Words(pC1) )
    {
        if ( pC1->pData[1] < pC2->pData[1] )
            return -1;
        if ( pC1->pData[1] > pC2->pData[1] )
            return 1;
        if ( pC1->pData[0] < pC2->pData[0] )
            return -1;
        if ( pC1->pData[0] > pC2->pData[0] )
            return 1;
        return 0;
    }
    else                            
    {
        int i = Mvc_CubeReadLast(pC1);
        for(; i >= 0; i--)
        {
            if ( pC1->pData[i] < pC2->pData[i] )
                return -1;
            if ( pC1->pData[i] > pC2->pData[i] )
                return 1;
        }
        return 0;
    }
}

int Mvc_CubeCompareIntOutsideAndUnderMask	(	Mvc_Cube_t *	pC1,
		Mvc_Cube_t *	pC2,
		Mvc_Cube_t *	pMask
	)

Function*************************************************************

Synopsis [Compares the cubes (1) outside the mask, (2) under the mask.]

Description []

SideEffects []

SeeAlso []

Definition at line 265 of file mvcCompare.c.

{
    unsigned uBits1, uBits2;

    if ( Mvc_Cube1Words(pC1) )
    {
        // compare the cubes outside the mask
        uBits1 = pC1->pData[0] & ~(pMask->pData[0]);
        uBits2 = pC2->pData[0] & ~(pMask->pData[0]);
        if ( uBits1 < uBits2 )
            return -1;
        if ( uBits1 > uBits2 )
            return 1;

        // compare the cubes under the mask
        uBits1 = pC1->pData[0] & pMask->pData[0];
        uBits2 = pC2->pData[0] & pMask->pData[0];
        if ( uBits1 < uBits2 )
            return -1;
        if ( uBits1 > uBits2 )
            return 1;
        // cubes are equal
        // should never happen
        assert( 0 );
        return 0;
    }
    else if ( Mvc_Cube2Words(pC1) )
    {
        // compare the cubes outside the mask
        uBits1 = pC1->pData[1] & ~(pMask->pData[1]);
        uBits2 = pC2->pData[1] & ~(pMask->pData[1]);
        if ( uBits1 < uBits2 )
            return -1;
        if ( uBits1 > uBits2 )
            return 1;

        uBits1 = pC1->pData[0] & ~(pMask->pData[0]);
        uBits2 = pC2->pData[0] & ~(pMask->pData[0]);
        if ( uBits1 < uBits2 )
            return -1;
        if ( uBits1 > uBits2 )
            return 1;

        // compare the cubes under the mask
        uBits1 = pC1->pData[1] & pMask->pData[1];
        uBits2 = pC2->pData[1] & pMask->pData[1];
        if ( uBits1 < uBits2 )
            return -1;
        if ( uBits1 > uBits2 )
            return 1;

        uBits1 = pC1->pData[0] & pMask->pData[0];
        uBits2 = pC2->pData[0] & pMask->pData[0];
        if ( uBits1 < uBits2 )
            return -1;
        if ( uBits1 > uBits2 )
            return 1;

        // cubes are equal
        // should never happen
        assert( 0 );
        return 0;
    }
    else                            
    {
        int i;

        // compare the cubes outside the mask
        for( i = Mvc_CubeReadLast(pC1); i >= 0; i-- )
        {
            uBits1 = pC1->pData[i] & ~(pMask->pData[i]);
            uBits2 = pC2->pData[i] & ~(pMask->pData[i]);
            if ( uBits1 < uBits2 )
                return -1;
            if ( uBits1 > uBits2 )
                return 1;
        }
        // compare the cubes under the mask
        for( i = Mvc_CubeReadLast(pC1); i >= 0; i-- )
        {
            uBits1 = pC1->pData[i] & pMask->pData[i];
            uBits2 = pC2->pData[i] & pMask->pData[i];
            if ( uBits1 < uBits2 )
                return -1;
            if ( uBits1 > uBits2 )
                return 1;
        }
/*
        {
            Mvc_Cover_t * pCover;
            pCover = Mvc_CoverAlloc( NULL, 96 );
            Mvc_CubePrint( pCover, pC1 );
            Mvc_CubePrint( pCover, pC2 );
            Mvc_CubePrint( pCover, pMask );
        }
*/
        // cubes are equal
        // should never happen
        assert( 0 );
        return 0;
    }
}

int Mvc_CubeCompareIntOutsideMask	(	Mvc_Cube_t *	pC1,
		Mvc_Cube_t *	pC2,
		Mvc_Cube_t *	pMask
	)

Function*************************************************************

Synopsis [Compares two cubes under the mask.]

Description []

SideEffects []

SeeAlso []

Definition at line 205 of file mvcCompare.c.

{
    unsigned uBits1, uBits2;

    // compare the cubes under the mask
    if ( Mvc_Cube1Words(pC1) )
    {
        uBits1 = pC1->pData[0] | pMask->pData[0];
        uBits2 = pC2->pData[0] | pMask->pData[0];
        if ( uBits1 < uBits2 )
            return -1;
        if ( uBits1 > uBits2 )
            return 1;
        // cubes are equal
        return 0;
    }
    else if ( Mvc_Cube2Words(pC1) )
    {
        uBits1 = pC1->pData[1] | pMask->pData[1];
        uBits2 = pC2->pData[1] | pMask->pData[1];
        if ( uBits1 < uBits2 )
            return -1;
        if ( uBits1 > uBits2 )
            return 1;
        uBits1 = pC1->pData[0] | pMask->pData[0];
        uBits2 = pC2->pData[0] | pMask->pData[0];
        if ( uBits1 < uBits2 )
            return -1;
        if ( uBits1 > uBits2 )
            return 1;
        return 0;
    }
    else                            
    {
        int i = Mvc_CubeReadLast(pC1);
        for(; i >= 0; i--)
        {
            uBits1 = pC1->pData[i] | pMask->pData[i];
            uBits2 = pC2->pData[i] | pMask->pData[i];
            if ( uBits1 < uBits2 )
                return -1;
            if ( uBits1 > uBits2 )
                return 1;
        }
        return 0;
    }
}

int Mvc_CubeCompareIntUnderMask	(	Mvc_Cube_t *	pC1,
		Mvc_Cube_t *	pC2,
		Mvc_Cube_t *	pMask
	)

Function*************************************************************

Synopsis [Compares two cubes under the mask.]

Description []

SideEffects []

SeeAlso []

Definition at line 146 of file mvcCompare.c.

{
    unsigned uBits1, uBits2;

    // compare the cubes under the mask
    if ( Mvc_Cube1Words(pC1) )
    {
        uBits1 = pC1->pData[0] & pMask->pData[0];
        uBits2 = pC2->pData[0] & pMask->pData[0];
        if ( uBits1 < uBits2 )
            return -1;
        if ( uBits1 > uBits2 )
            return 1;
        // cubes are equal
        return 0;
    }
    else if ( Mvc_Cube2Words(pC1) )
    {
        uBits1 = pC1->pData[1] & pMask->pData[1];
        uBits2 = pC2->pData[1] & pMask->pData[1];
        if ( uBits1 < uBits2 )
            return -1;
        if ( uBits1 > uBits2 )
            return 1;
        uBits1 = pC1->pData[0] & pMask->pData[0];
        uBits2 = pC2->pData[0] & pMask->pData[0];
        if ( uBits1 < uBits2 )
            return -1;
        if ( uBits1 > uBits2 )
            return 1;
        return 0;
    }
    else                            
    {
        int i = Mvc_CubeReadLast(pC1);
        for(; i >= 0; i--)
        {
            uBits1 = pC1->pData[i] & pMask->pData[i];
            uBits2 = pC2->pData[i] & pMask->pData[i];
            if ( uBits1 < uBits2 )
                return -1;
            if ( uBits1 > uBits2 )
                return 1;
        }
        return 0;
    }
}

int Mvc_CubeCompareSizeAndInt	(	Mvc_Cube_t *	pC1,
		Mvc_Cube_t *	pC2,
		Mvc_Cube_t *	pMask
	)

Function*************************************************************

Synopsis [Compares the cubes (1) by size, (2) by integer value.]

Description []

SideEffects []

SeeAlso []

Definition at line 91 of file mvcCompare.c.

{
    // compare the cubes by size
    if ( Mvc_CubeReadSize( pC1 ) < Mvc_CubeReadSize( pC2 ) )
        return 1;
    if ( Mvc_CubeReadSize( pC1 ) > Mvc_CubeReadSize( pC2 ) )
        return -1;
    // the cubes have the same size

    // compare the cubes as integers
    if ( Mvc_Cube1Words( pC1 ) )
    {
        if ( pC1->pData[0] < pC2->pData[0] )
            return -1;
        if ( pC1->pData[0] > pC2->pData[0] )
            return 1;
        return 0;
    }
    else if ( Mvc_Cube2Words( pC1 ) )
    {
        if ( pC1->pData[1] < pC2->pData[1] )
            return -1;
        if ( pC1->pData[1] > pC2->pData[1] )
            return 1;
        if ( pC1->pData[0] < pC2->pData[0] )
            return -1;
        if ( pC1->pData[0] > pC2->pData[0] )
            return 1;
        return 0;
    }
    else                            
    {
        int i = Mvc_CubeReadLast( pC1 );
        for(; i >= 0; i--)
        {
            if ( pC1->pData[i] < pC2->pData[i] )
                return -1;
            if ( pC1->pData[i] > pC2->pData[i] )
                return 1;
        }
        return 0;
    }
}

Mvc_Cube_t* Mvc_CubeDup	(	Mvc_Cover_t *	pCover,
		Mvc_Cube_t *	pCube
	)

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 94 of file mvcCube.c.

{
    Mvc_Cube_t * pCubeCopy;
    pCubeCopy = Mvc_CubeAlloc( pCover );
    Mvc_CubeBitCopy( pCubeCopy, pCube );
    return pCubeCopy;
}

void Mvc_CubeFree	(	Mvc_Cover_t *	pCover,
		Mvc_Cube_t *	pCube
	)

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 114 of file mvcCube.c.

{
    if ( pCube == NULL )
        return;

    // verify the parameters charactering this cube
    assert( pCube->iLast == 0 || ((int)pCube->iLast) == pCover->nWords - 1 );
    assert( ((int)pCube->nUnused) == pCover->nUnused );

    // deallocate the cube
#ifdef USE_SYSTEM_MEMORY_MANAGEMENT
    ABC_FREE( pCube );
#else
    switch( pCover->nWords )
    {
    case 0:
    case 1:
        Extra_MmFixedEntryRecycle( pCover->pMem->pMan1, (char *)pCube );
        break;
    case 2:
        Extra_MmFixedEntryRecycle( pCover->pMem->pMan2, (char *)pCube );
        break;
    case 3:
    case 4:
        Extra_MmFixedEntryRecycle( pCover->pMem->pMan4, (char *)pCube );
        break;
    default:
        ABC_FREE( pCube );
        break;
    }
#endif
}

void Mvc_CubePrint	(	Mvc_Cover_t *	pCover,
		Mvc_Cube_t *	pCube
	)

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 79 of file mvcPrint.c.

{
    int iBit, Value;
    // iterate through the literals
//    printf( "Size = %2d   ", Mvc_CubeReadSize(pCube) );
    Mvc_CubeForEachBit( pCover, pCube, iBit, Value )
        printf( "%c", '0' + Value );
    printf( "\n" );
}

void Mvc_CubePrintMv	(	Mvc_Data_t *	pData,
		Mvc_Cover_t *	pCover,
		Mvc_Cube_t *	pCube
	)

void Mvc_ListAddCubeHead_	(	Mvc_List_t *	pList,
		Mvc_Cube_t *	pCube
	)

DECLARATIONS ///.

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

FileName [mvcList.c]

PackageName [MVSIS 2.0: Multi-valued logic synthesis system.]

Synopsis [Manipulating list of cubes in the cover.]

Author [MVSIS Group]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - February 1, 2003.]

Revision [

Id:

mvcList.c,v 1.4 2003/04/03 06:31:50 alanmi Exp

]FUNCTION DEFINITIONS /// Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 43 of file mvcList.c.

{
    if ( pList->pHead == NULL )
    {
        Mvc_CubeSetNext( pCube, NULL );
        pList->pHead = pCube;
        pList->pTail = pCube;
    }
    else
    {
        Mvc_CubeSetNext( pCube, pList->pHead );
        pList->pHead = pCube;
    }
    pList->nItems++;
}

void Mvc_ListAddCubeTail_	(	Mvc_List_t *	pList,
		Mvc_Cube_t *	pCube
	)

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 71 of file mvcList.c.

{
    if ( pList->pHead == NULL )
        pList->pHead = pCube;
    else
        Mvc_CubeSetNext( pList->pTail, pCube );
    pList->pTail    = pCube;
    Mvc_CubeSetNext( pCube, NULL );
    pList->nItems++;
}

void Mvc_ListDeleteCube_	(	Mvc_List_t *	pList,
		Mvc_Cube_t *	pPrev,
		Mvc_Cube_t *	pCube
	)

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 94 of file mvcList.c.

{
    if ( pPrev == NULL ) // deleting the head cube
        pList->pHead = Mvc_CubeReadNext(pCube);
    else
        pPrev->pNext = pCube->pNext;
    if ( pList->pTail == pCube ) // deleting the tail cube
    {
        assert( Mvc_CubeReadNext(pCube) == NULL );
        pList->pTail = pPrev;
    }
    pList->nItems--;
}

Mvc_Cube_t* Mvc_ListGetTailFromHead

(

Mvc_Cube_t *

pHead

)

Function*************************************************************

Synopsis [Returns the tail of the linked list given by the head.]

Description []

SideEffects []

SeeAlso []

Definition at line 351 of file mvcList.c.

{
    Mvc_Cube_t * pCube, * pTail;
    for ( pTail = pCube = pHead; 
          pCube; 
          pTail = pCube, pCube = Mvc_CubeReadNext(pCube) );
    return pTail;
}

Mvc_Cube_t* Mvc_ListReadCubeHead

(

Mvc_List_t *

pList

)

Definition at line 63 of file mvcApi.c.

{ return pList->pHead;  }

int Mvc_ListReadCubeNum

(

Mvc_List_t *

pList

)

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 62 of file mvcApi.c.

{ return pList->nItems; }

Mvc_Cube_t* Mvc_ListReadCubeTail

(

Mvc_List_t *

pList

)

Definition at line 64 of file mvcApi.c.

{ return pList->pTail;  }

Mvc_Manager_t* Mvc_ManagerAllocCover

(

)

Mvc_Manager_t* Mvc_ManagerAllocCube

(

int

nWords

)

void Mvc_ManagerFree

(

Mvc_Manager_t *

p

)

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 67 of file mvcMan.c.

{
    Extra_MmFixedStop( p->pMan1 );
    Extra_MmFixedStop( p->pMan2 );
    Extra_MmFixedStop( p->pMan4 );
    Extra_MmFixedStop( p->pManC );
    ABC_FREE( p );
}

Mvc_Manager_t* Mvc_ManagerFreeCover

(

Mvc_Cover_t *

pCover

)

Mvc_Manager_t* Mvc_ManagerFreeCube	(	Mvc_Cover_t *	pCube,
		int	nWords
	)

Mvc_Manager_t* Mvc_ManagerStart

(

)

DECLARATIONS ///.

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

FileName [mvcMan.c]

PackageName [MVSIS 2.0: Multi-valued logic synthesis system.]

Synopsis [Procedures working with the MVC memory manager.]

Author [MVSIS Group]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - February 1, 2003.]

Revision [

Id:

mvcMan.c,v 1.3 2003/03/19 19:50:26 alanmi Exp

]FUNCTION DEFINITIONS /// Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 44 of file mvcMan.c.

{
    Mvc_Manager_t * p;
    p = ABC_ALLOC( Mvc_Manager_t, 1 );
    memset( p, 0, sizeof(Mvc_Manager_t) );
    p->pMan1 = Extra_MmFixedStart( sizeof(Mvc_Cube_t)                              );
    p->pMan2 = Extra_MmFixedStart( sizeof(Mvc_Cube_t) +     sizeof(Mvc_CubeWord_t) );
    p->pMan4 = Extra_MmFixedStart( sizeof(Mvc_Cube_t) + 3 * sizeof(Mvc_CubeWord_t) );
    p->pManC = Extra_MmFixedStart( sizeof(Mvc_Cover_t) );
    return p;
}

int Mvc_UtilsCheckUnusedZeros

(

Mvc_Cover_t *

pCover

)

Function*************************************************************

Synopsis [Checks that the cubes of the cover have 0's in unused bits.]

Description []

SideEffects []

SeeAlso []

Definition at line 842 of file mvcUtils.c.

{
    unsigned Unsigned;
    Mvc_Cube_t * pCube;
    int nCubes;

    nCubes = 0;
    Mvc_CoverForEachCube( pCover, pCube )
    {
        if ( pCube->nUnused == 0 )
            continue;

        Unsigned = ( pCube->pData[pCube->iLast] & 
                    (BITS_FULL << (32-pCube->nUnused)) );
        if( Unsigned )
        {
            printf( "Cube %2d out of %2d contains dirty bits.\n", nCubes, 
                Mvc_CoverReadCubeNum(pCover) );
        }
        nCubes++;
    }
    return 1;
}

int Mvr_CoverCountLitsWithValue	(	Mvc_Data_t *	pData,
		Mvc_Cover_t *	pCover,
		int	iVar,
		int	iValue
	)