From 324d73c29a22766063df46f9e35a3cbe719a83c2 Mon Sep 17 00:00:00 2001 From: Alan Mishchenko Date: Sat, 27 Apr 2013 15:23:12 -0700 Subject: New fast extract. --- src/misc/vec/vecHsh.h | 360 ++++++++++++++++++++++++++++++++++++++ src/misc/vec/vecInt.h | 18 ++ src/misc/vec/vecQue.h | 4 + src/misc/vec/vecVec.h | 3 +- src/misc/vec/vecWec.h | 476 ++++++++++++++++++++++++++++++++++++++++++++++++++ 5 files changed, 860 insertions(+), 1 deletion(-) create mode 100644 src/misc/vec/vecHsh.h create mode 100644 src/misc/vec/vecWec.h (limited to 'src/misc') diff --git a/src/misc/vec/vecHsh.h b/src/misc/vec/vecHsh.h new file mode 100644 index 00000000..04f1e9f2 --- /dev/null +++ b/src/misc/vec/vecHsh.h @@ -0,0 +1,360 @@ +/**CFile**************************************************************** + + FileName [vecHsh.h] + + SystemName [ABC: Logic synthesis and verification system.] + + PackageName [Resizable arrays.] + + Synopsis [Hashing vector entries.] + + Author [Alan Mishchenko] + + Affiliation [UC Berkeley] + + Date [Ver. 1.0. Started - June 20, 2005.] + + Revision [$Id: vecHsh.h,v 1.00 2005/06/20 00:00:00 alanmi Exp $] + +***********************************************************************/ + +#ifndef ABC__misc__vec__vecHsh_h +#define ABC__misc__vec__vecHsh_h + + +//////////////////////////////////////////////////////////////////////// +/// INCLUDES /// +//////////////////////////////////////////////////////////////////////// + +#include + +ABC_NAMESPACE_HEADER_START + + +//////////////////////////////////////////////////////////////////////// +/// PARAMETERS /// +//////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////// +/// BASIC TYPES /// +//////////////////////////////////////////////////////////////////////// + +typedef struct Hsh_IntObj_t_ Hsh_IntObj_t; +struct Hsh_IntObj_t_ +{ + int iData; + int iNext; +}; + +typedef struct Hsh_IntMan_t_ Hsh_IntMan_t; +struct Hsh_IntMan_t_ +{ + int nSize; // data size + Vec_Int_t * vData; // data storage + Vec_Int_t * vTable; // hash table + Vec_Wrd_t * vObjs; // hash objects +}; + + + +typedef struct Hsh_VecObj_t_ Hsh_VecObj_t; +struct Hsh_VecObj_t_ +{ + int nSize; + int iNext; + int pArray[0]; +}; + +typedef struct Hsh_VecMan_t_ Hsh_VecMan_t; +struct Hsh_VecMan_t_ +{ + Vec_Int_t * vTable; // hash table + Vec_Int_t * vData; // data storage + Vec_Int_t * vMap; // mapping entries into data; + Vec_Int_t vTemp; // temporary array +}; + +//////////////////////////////////////////////////////////////////////// +/// MACRO DEFINITIONS /// +//////////////////////////////////////////////////////////////////////// + +static inline unsigned * Hsh_IntData( Hsh_IntMan_t * p, int iData ) { return (unsigned *)Vec_IntEntryP( p->vData, p->nSize * iData ); } +static inline Hsh_IntObj_t * Hsh_IntObj( Hsh_IntMan_t * p, int iObj ) { return iObj == -1 ? NULL : (Hsh_IntObj_t *)Vec_WrdEntryP( p->vObjs, iObj ); } +static inline word Hsh_IntWord( int iData, int iNext ) { Hsh_IntObj_t Obj = {iData, iNext}; return *((word *)&Obj); } + +static inline Hsh_VecObj_t * Hsh_VecObj( Hsh_VecMan_t * p, int i ) { return i == -1 ? NULL : (Hsh_VecObj_t *)Vec_IntEntryP(p->vData, Vec_IntEntry(p->vMap, i)); } + +//////////////////////////////////////////////////////////////////////// +/// FUNCTION DEFINITIONS /// +//////////////////////////////////////////////////////////////////////// + +/**Function************************************************************* + + Synopsis [Hashing data entries composed of nSize integers.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline Hsh_IntMan_t * Hsh_IntManStart( Vec_Int_t * vData, int nSize, int nEntries ) +{ + Hsh_IntMan_t * p; + p = ABC_CALLOC( Hsh_IntMan_t, 1 ); + p->nSize = nSize; + p->vData = vData; + p->vTable = Vec_IntStartFull( Abc_PrimeCudd(nEntries) ); + p->vObjs = Vec_WrdAlloc( nEntries ); + return p; +} +static inline void Hsh_IntManStop( Hsh_IntMan_t * p ) +{ + Vec_IntFree( p->vTable ); + Vec_WrdFree( p->vObjs ); + ABC_FREE( p ); +} + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline int Hsh_IntManHash( unsigned * pData, int nSize, int nTableSize ) +{ + static int s_Primes[7] = { 4177, 5147, 5647, 6343, 7103, 7873, 8147 }; + unsigned char * pDataC = (unsigned char *)pData; + int c, nChars = nSize * 4; + unsigned Key = 0; + for ( c = 0; c < nChars; c++ ) + Key += pDataC[c] * s_Primes[c % 7]; + return (int)(Key % nTableSize); +} +static inline int Hsh_IntManAdd( Hsh_IntMan_t * p, int iData ) +{ + Hsh_IntObj_t * pObj; + unsigned * pData = Hsh_IntData( p, iData ); + int i, * pPlace; + if ( Vec_WrdSize(p->vObjs) > Vec_IntSize(p->vTable) ) + { + Vec_IntFill( p->vTable, Abc_PrimeCudd(2*Vec_IntSize(p->vTable)), -1 ); + for ( i = 0; i < Vec_WrdSize(p->vObjs); i++ ) + { + pPlace = Vec_IntEntryP( p->vTable, Hsh_IntManHash(Hsh_IntData(p, i), p->nSize, Vec_IntSize(p->vTable)) ); + Hsh_IntObj(p, i)->iNext = *pPlace; *pPlace = i; + } + } + pPlace = Vec_IntEntryP( p->vTable, Hsh_IntManHash(pData, p->nSize, Vec_IntSize(p->vTable)) ); + for ( ; (pObj = Hsh_IntObj(p, *pPlace)); pPlace = &pObj->iNext ) + if ( !memcmp( pData, Hsh_IntData(p, pObj->iData), sizeof(int) * p->nSize ) ) + return (word *)pObj - Vec_WrdArray(p->vObjs); + *pPlace = Vec_WrdSize(p->vObjs); + Vec_WrdPush( p->vObjs, Hsh_IntWord(iData, -1) ); + return Vec_WrdSize(p->vObjs)-1; +} + +/**Function************************************************************* + + Synopsis [Hashes data by value.] + + Description [Array vData contains data entries, each of 'nSize' integers. + The resulting array contains the indexes of unique data entries.] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline Vec_Int_t * Hsh_IntManHashArray( Vec_Int_t * vData, int nSize ) +{ + Hsh_IntMan_t * p; + Vec_Int_t * vRes = Vec_IntAlloc( 100 ); + int i, nEntries = Vec_IntSize(vData) / nSize; + assert( Vec_IntSize(vData) % nSize == 0 ); + p = Hsh_IntManStart( vData, nSize, nEntries ); + for ( i = 0; i < nEntries; i++ ) + Vec_IntPush( vRes, Hsh_IntManAdd(p, i) ); + Hsh_IntManStop( p ); + return vRes; +} + +/**Function************************************************************* + + Synopsis [Test procedure.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline void Hsh_IntManHashArrayTest() +{ + Vec_Int_t * vData = Vec_IntAlloc( 10 ); + Vec_Int_t * vRes; + Vec_IntPush( vData, 12 ); + Vec_IntPush( vData, 17 ); + Vec_IntPush( vData, 13 ); + Vec_IntPush( vData, 12 ); + Vec_IntPush( vData, 15 ); + Vec_IntPush( vData, 3 ); + Vec_IntPush( vData, 16 ); + Vec_IntPush( vData, 16 ); + Vec_IntPush( vData, 12 ); + Vec_IntPush( vData, 17 ); + Vec_IntPush( vData, 12 ); + Vec_IntPush( vData, 12 ); + + vRes = Hsh_IntManHashArray( vData, 2 ); + + Vec_IntPrint( vData ); + Vec_IntPrint( vRes ); + + Vec_IntFree( vData ); + Vec_IntFree( vRes ); +} + + + + + +/**Function************************************************************* + + Synopsis [Hashing integer arrays.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline Hsh_VecMan_t * Hsh_VecManStart( int nEntries ) +{ + Hsh_VecMan_t * p; + p = ABC_CALLOC( Hsh_VecMan_t, 1 ); + p->vTable = Vec_IntStartFull( Abc_PrimeCudd(nEntries) ); + p->vData = Vec_IntAlloc( nEntries * 4 ); + p->vMap = Vec_IntAlloc( nEntries ); + return p; +} +static inline void Hsh_VecManStop( Hsh_VecMan_t * p ) +{ + Vec_IntFree( p->vTable ); + Vec_IntFree( p->vData ); + Vec_IntFree( p->vMap ); + ABC_FREE( p ); +} +static inline Vec_Int_t * Hsh_VecReadEntry( Hsh_VecMan_t * p, int i ) +{ + Hsh_VecObj_t * pObj = Hsh_VecObj( p, i ); + p->vTemp.nSize = p->vTemp.nCap = pObj->nSize; + p->vTemp.pArray = (int*)pObj + 2; + return &p->vTemp; +} +static inline int Hsh_VecSize( Hsh_VecMan_t * p ) +{ + return Vec_IntSize(p->vMap); +} + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline int Hsh_VecManHash( Vec_Int_t * vVec, int nTableSize ) +{ + static unsigned s_Primes[7] = {4177, 5147, 5647, 6343, 7103, 7873, 8147}; + unsigned Key = 0; + int i, Entry; + Vec_IntForEachEntry( vVec, Entry, i ) + Key += (unsigned)Entry * s_Primes[i % 7]; + return (int)(Key % nTableSize); +} +static inline int Hsh_VecManAdd( Hsh_VecMan_t * p, Vec_Int_t * vVec ) +{ + Hsh_VecObj_t * pObj; + int i, Ent, * pPlace; + if ( Vec_IntSize(p->vMap) > Vec_IntSize(p->vTable) ) + { + Vec_IntFill( p->vTable, Abc_PrimeCudd(2*Vec_IntSize(p->vTable)), -1 ); + for ( i = 0; i < Vec_IntSize(p->vMap); i++ ) + { + pPlace = Vec_IntEntryP( p->vTable, Hsh_VecManHash(Hsh_VecReadEntry(p, i), Vec_IntSize(p->vTable)) ); + Hsh_VecObj(p, i)->iNext = *pPlace; *pPlace = i; + } + } + pPlace = Vec_IntEntryP( p->vTable, Hsh_VecManHash(vVec, Vec_IntSize(p->vTable)) ); + for ( ; (pObj = Hsh_VecObj(p, *pPlace)); pPlace = &pObj->iNext ) + if ( pObj->nSize == Vec_IntSize(vVec) && !memcmp( pObj->pArray, Vec_IntArray(vVec), sizeof(int) * pObj->nSize ) ) + return *pPlace; + *pPlace = Vec_IntSize(p->vMap); + assert( Vec_IntSize(p->vData) % 2 == 0 ); + Vec_IntPush( p->vMap, Vec_IntSize(p->vData) ); + Vec_IntPush( p->vData, Vec_IntSize(vVec) ); + Vec_IntPush( p->vData, -1 ); + Vec_IntForEachEntry( vVec, Ent, i ) + Vec_IntPush( p->vData, Ent ); + if ( Vec_IntSize(vVec) & 1 ) + Vec_IntPush( p->vData, -1 ); + return Vec_IntSize(p->vMap) - 1; +} + +/**Function************************************************************* + + Synopsis [Test procedure.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline void Hsh_VecManHashTest() +{ + Hsh_VecMan_t * p; + Vec_Int_t * vTemp; + Vec_Int_t * vRes = Vec_IntAlloc( 1000 ); + int i; + + p = Hsh_VecManStart( 5 ); + for ( i = 0; i < 20; i++ ) + { + vTemp = Vec_IntStartNatural( i ); + Vec_IntPush( vRes, Hsh_VecManAdd( p, vTemp ) ); + Vec_IntFree( vTemp ); + } + for ( ; i > 0; i-- ) + { + vTemp = Vec_IntStartNatural( i ); + Vec_IntPush( vRes, Hsh_VecManAdd( p, vTemp ) ); + Vec_IntFree( vTemp ); + } + Vec_IntPrint( vRes ); + Vec_IntFree( vRes ); + + Hsh_VecManStop( p ); +} + + +#endif + +//////////////////////////////////////////////////////////////////////// +/// END OF FILE /// +//////////////////////////////////////////////////////////////////////// + diff --git a/src/misc/vec/vecInt.h b/src/misc/vec/vecInt.h index 9744a031..60352a0f 100644 --- a/src/misc/vec/vecInt.h +++ b/src/misc/vec/vecInt.h @@ -1193,6 +1193,24 @@ static inline int Vec_IntUniqify( Vec_Int_t * p ) p->nSize = k; return RetValue; } +static inline int Vec_IntCountDuplicates( Vec_Int_t * p ) +{ + int RetValue; + Vec_Int_t * pDup = Vec_IntDup( p ); + Vec_IntUniqify( pDup ); + RetValue = Vec_IntSize(p) - Vec_IntSize(pDup); + Vec_IntFree( pDup ); + return RetValue; +} +static inline int Vec_IntCheckUniqueSmall( Vec_Int_t * p ) +{ + int i, k; + for ( i = 0; i < p->nSize; i++ ) + for ( k = i+1; k < p->nSize; k++ ) + if ( p->pArray[i] == p->pArray[k] ) + return 0; + return 1; +} /**Function************************************************************* diff --git a/src/misc/vec/vecQue.h b/src/misc/vec/vecQue.h index aaa1c01d..1b6bc4bb 100644 --- a/src/misc/vec/vecQue.h +++ b/src/misc/vec/vecQue.h @@ -140,6 +140,10 @@ static inline int Vec_QueTop( Vec_Que_t * p ) { return Vec_QueSize(p) > 0 ? p->pHeap[1] : -1; } +static inline float Vec_QueTopCost( Vec_Que_t * p ) +{ + return Vec_QueSize(p) > 0 ? Vec_QueCost(p, p->pHeap[1]) : -ABC_INFINITY; +} /**Function************************************************************* diff --git a/src/misc/vec/vecVec.h b/src/misc/vec/vecVec.h index d935be0f..f8f36d8b 100644 --- a/src/misc/vec/vecVec.h +++ b/src/misc/vec/vecVec.h @@ -253,6 +253,7 @@ static inline int Vec_VecCap( Vec_Vec_t * p ) ***********************************************************************/ static inline int Vec_VecLevelSize( Vec_Vec_t * p, int i ) { + assert( i >= 0 && i < p->nSize ); return Vec_PtrSize( (Vec_Ptr_t *)p->pArray[i] ); } @@ -617,7 +618,7 @@ static inline void Vec_VecPrintInt( Vec_Vec_t * p, int fSkipSingles ) int i, k, Entry; Vec_VecForEachEntryInt( p, Entry, i, k ) { - if ( Vec_VecLevelSize(p, i) == 1 ) + if ( fSkipSingles && Vec_VecLevelSize(p, i) == 1 ) break; if ( k == 0 ) printf( " %4d : {", i ); diff --git a/src/misc/vec/vecWec.h b/src/misc/vec/vecWec.h new file mode 100644 index 00000000..49ecb3da --- /dev/null +++ b/src/misc/vec/vecWec.h @@ -0,0 +1,476 @@ +/**CFile**************************************************************** + + FileName [vecWec.h] + + SystemName [ABC: Logic synthesis and verification system.] + + PackageName [Resizable arrays.] + + Synopsis [Resizable vector of resizable vectors.] + + Author [Alan Mishchenko] + + Affiliation [UC Berkeley] + + Date [Ver. 1.0. Started - June 20, 2005.] + + Revision [$Id: vecWec.h,v 1.00 2005/06/20 00:00:00 alanmi Exp $] + +***********************************************************************/ + +#ifndef ABC__misc__vec__vecWec_h +#define ABC__misc__vec__vecWec_h + + +//////////////////////////////////////////////////////////////////////// +/// INCLUDES /// +//////////////////////////////////////////////////////////////////////// + +#include + +ABC_NAMESPACE_HEADER_START + + +//////////////////////////////////////////////////////////////////////// +/// PARAMETERS /// +//////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////// +/// BASIC TYPES /// +//////////////////////////////////////////////////////////////////////// + +typedef struct Vec_Wec_t_ Vec_Wec_t; +struct Vec_Wec_t_ +{ + int nCap; + int nSize; + Vec_Int_t * pArray; +}; + +//////////////////////////////////////////////////////////////////////// +/// MACRO DEFINITIONS /// +//////////////////////////////////////////////////////////////////////// + +// iterators through levels +#define Vec_WecForEachLevel( vGlob, vVec, i ) \ + for ( i = 0; (i < Vec_WecSize(vGlob)) && (((vVec) = Vec_WecEntry(vGlob, i)), 1); i++ ) +#define Vec_WecForEachLevelStart( vGlob, vVec, i, LevelStart ) \ + for ( i = LevelStart; (i < Vec_WecSize(vGlob)) && (((vVec) = Vec_WecEntry(vGlob, i)), 1); i++ ) +#define Vec_WecForEachLevelStop( vGlob, vVec, i, LevelStop ) \ + for ( i = 0; (i < LevelStop) && (((vVec) = Vec_WecEntry(vGlob, i)), 1); i++ ) +#define Vec_WecForEachLevelStartStop( vGlob, vVec, i, LevelStart, LevelStop ) \ + for ( i = LevelStart; (i < LevelStop) && (((vVec) = Vec_WecEntry(vGlob, i)), 1); i++ ) +#define Vec_WecForEachLevelReverse( vGlob, vVec, i ) \ + for ( i = Vec_WecSize(vGlob)-1; (i >= 0) && (((vVec) = Vec_WecEntry(vGlob, i)), 1); i-- ) +#define Vec_WecForEachLevelReverseStartStop( vGlob, vVec, i, LevelStart, LevelStop ) \ + for ( i = LevelStart-1; (i >= LevelStop) && (((vVec) = Vec_WecEntry(vGlob, i)), 1); i-- ) +#define Vec_WecForEachLevelTwo( vGlob1, vGlob2, vVec1, vVec2, i ) \ + for ( i = 0; (i < Vec_WecSize(vGlob1)) && (((vVec1) = Vec_WecEntry(vGlob1, i)), 1) && (((vVec2) = Vec_WecEntry(vGlob2, i)), 1); i++ ) + +//////////////////////////////////////////////////////////////////////// +/// FUNCTION DEFINITIONS /// +//////////////////////////////////////////////////////////////////////// + +/**Function************************************************************* + + Synopsis [Allocates a vector with the given capacity.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline Vec_Wec_t * Vec_WecAlloc( int nCap ) +{ + Vec_Wec_t * p; + p = ABC_ALLOC( Vec_Wec_t, 1 ); + if ( nCap > 0 && nCap < 8 ) + nCap = 8; + p->nSize = 0; + p->nCap = nCap; + p->pArray = p->nCap? ABC_CALLOC( Vec_Int_t, p->nCap ) : NULL; + return p; +} +static inline Vec_Wec_t * Vec_WecStart( int nSize ) +{ + Vec_Wec_t * p; + p = Vec_WecAlloc( nSize ); + p->nSize = nSize; + return p; +} + +/**Function************************************************************* + + Synopsis [Resizes the vector to the given capacity.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline void Vec_WecGrow( Vec_Wec_t * p, int nCapMin ) +{ + if ( p->nCap >= nCapMin ) + return; + p->pArray = ABC_REALLOC( Vec_Int_t, p->pArray, nCapMin ); + memset( p->pArray + p->nCap, 0, sizeof(Vec_Int_t) * (nCapMin - p->nCap) ); + p->nCap = nCapMin; +} + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline Vec_Int_t * Vec_WecEntry( Vec_Wec_t * p, int i ) +{ + assert( i >= 0 && i < p->nSize ); + return p->pArray + i; +} +static inline Vec_Int_t * Vec_WecEntryLast( Vec_Wec_t * p ) +{ + assert( p->nSize > 0 ); + return p->pArray + p->nSize - 1; +} +static inline int Vec_WecEntryEntry( Vec_Wec_t * p, int i, int k ) +{ + return Vec_IntEntry( Vec_WecEntry(p, i), k ); +} + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline int Vec_WecCap( Vec_Wec_t * p ) +{ + return p->nCap; +} +static inline int Vec_WecSize( Vec_Wec_t * p ) +{ + return p->nSize; +} +static inline int Vec_WecLevelSize( Vec_Wec_t * p, int i ) +{ + assert( i >= 0 && i < p->nSize ); + return Vec_IntSize( p->pArray + i ); +} +static inline int Vec_WecSizeSize( Vec_Wec_t * p ) +{ + Vec_Int_t * vVec; + int i, Counter = 0; + Vec_WecForEachLevel( p, vVec, i ) + Counter += Vec_IntSize(vVec); + return Counter; +} +static inline int Vec_WecSizeUsed( Vec_Wec_t * p ) +{ + Vec_Int_t * vVec; + int i, Counter = 0; + Vec_WecForEachLevel( p, vVec, i ) + Counter += (int)(Vec_IntSize(vVec) > 0); + return Counter; +} + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline void Vec_WecShrink( Vec_Wec_t * p, int nSizeNew ) +{ + assert( p->nSize >= nSizeNew ); + p->nSize = nSizeNew; +} + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline void Vec_WecClear( Vec_Wec_t * p ) +{ + Vec_Int_t * vVec; + int i; + Vec_WecForEachLevel( p, vVec, i ) + Vec_IntClear( vVec ); +} + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline void Vec_WecPush( Vec_Wec_t * p, int Level, int Entry ) +{ + if ( p->nSize < Level + 1 ) + { + Vec_WecGrow( p, Level + 1 ); + p->nSize = Level + 1; + } + Vec_IntPush( Vec_WecEntry(p, Level), Entry ); +} +static inline Vec_Int_t * Vec_WecPushLevel( Vec_Wec_t * p ) +{ + Vec_WecGrow( p, ++p->nSize ); + return Vec_WecEntryLast( p ); +} + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline double Vec_WecMemory( Vec_Wec_t * p ) +{ + int i; + double Mem; + if ( p == NULL ) return 0.0; + Mem = sizeof(Vec_Int_t) * Vec_WecCap(p); + for ( i = 0; i < p->nSize; i++ ) + Mem += sizeof(int) * Vec_IntCap( Vec_WecEntry(p, i) ); + return Mem; +} + +/**Function************************************************************* + + Synopsis [Frees the vector.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline void Vec_WecFree( Vec_Wec_t * p ) +{ + Vec_Int_t * vVec; + int i; + Vec_WecForEachLevel( p, vVec, i ) + ABC_FREE( vVec->pArray ); + ABC_FREE( p->pArray ); + ABC_FREE( p ); +} +static inline void Vec_WecFreeP( Vec_Wec_t ** p ) +{ + if ( *p == NULL ) + return; + Vec_WecFree( *p ); + *p = NULL; +} + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline void Vec_WecPushUnique( Vec_Wec_t * p, int Level, int Entry ) +{ + if ( p->nSize < Level + 1 ) + Vec_WecPush( p, Level, Entry ); + else + Vec_IntPushUnique( Vec_WecEntry(p, Level), Entry ); +} + +/**Function************************************************************* + + Synopsis [Frees the vector.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline Vec_Wec_t * Vec_WecDup( Vec_Wec_t * p ) +{ + Vec_Wec_t * vNew; + Vec_Int_t * vVec; + int i, k, Entry; + vNew = Vec_WecAlloc( Vec_WecSize(p) ); + Vec_WecForEachLevel( p, vVec, i ) + Vec_IntForEachEntry( vVec, Entry, k ) + Vec_WecPush( vNew, i, Entry ); + return vNew; +} + +/**Function************************************************************* + + Synopsis [Comparison procedure for two arrays.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static int Vec_WecSortCompare1( Vec_Int_t * p1, Vec_Int_t * p2 ) +{ + if ( Vec_IntSize(p1) < Vec_IntSize(p2) ) + return -1; + if ( Vec_IntSize(p1) > Vec_IntSize(p2) ) + return 1; + return 0; +} +static int Vec_WecSortCompare2( Vec_Int_t * p1, Vec_Int_t * p2 ) +{ + if ( Vec_IntSize(p1) > Vec_IntSize(p2) ) + return -1; + if ( Vec_IntSize(p1) < Vec_IntSize(p2) ) + return 1; + return 0; +} + +/**Function************************************************************* + + Synopsis [Sorting the entries by their integer value.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline void Vec_WecSort( Vec_Wec_t * p, int fReverse ) +{ + if ( fReverse ) + qsort( (void *)p->pArray, p->nSize, sizeof(Vec_Int_t), + (int (*)(const void *, const void *)) Vec_WecSortCompare2 ); + else + qsort( (void *)p->pArray, p->nSize, sizeof(Vec_Int_t), + (int (*)(const void *, const void *)) Vec_WecSortCompare1 ); +} + +/**Function************************************************************* + + Synopsis [Comparison procedure for two integers.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static int Vec_WecSortCompare3( Vec_Int_t * p1, Vec_Int_t * p2 ) +{ + if ( Vec_IntEntry(p1,0) < Vec_IntEntry(p2,0) ) + return -1; + if ( Vec_IntEntry(p1,0) > Vec_IntEntry(p2,0) ) + return 1; + return 0; +} +static int Vec_WecSortCompare4( Vec_Int_t * p1, Vec_Int_t * p2 ) +{ + if ( Vec_IntEntry(p1,0) > Vec_IntEntry(p2,0) ) + return -1; + if ( Vec_IntEntry(p1,0) < Vec_IntEntry(p2,0) ) + return 1; + return 0; +} + +/**Function************************************************************* + + Synopsis [Sorting the entries by their integer value.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline void Vec_WecSortByFirstInt( Vec_Wec_t * p, int fReverse ) +{ + if ( fReverse ) + qsort( (void *)p->pArray, p->nSize, sizeof(Vec_Int_t), + (int (*)(const void *, const void *)) Vec_WecSortCompare4 ); + else + qsort( (void *)p->pArray, p->nSize, sizeof(Vec_Int_t), + (int (*)(const void *, const void *)) Vec_WecSortCompare3 ); +} + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline void Vec_WecPrint( Vec_Wec_t * p, int fSkipSingles ) +{ + Vec_Int_t * vVec; + int i, k, Entry; + Vec_WecForEachLevel( p, vVec, i ) + { + if ( fSkipSingles && Vec_IntSize(vVec) == 1 ) + break; + printf( " %4d : {", i ); + Vec_IntForEachEntry( vVec, Entry, k ) + printf( " %d", Entry ); + printf( " }\n" ); + } +} + +ABC_NAMESPACE_HEADER_END + +#endif + +//////////////////////////////////////////////////////////////////////// +/// END OF FILE /// +//////////////////////////////////////////////////////////////////////// + -- cgit v1.2.3