diff options
Diffstat (limited to 'src/misc/vec')
| -rw-r--r-- | src/misc/vec/vec.h | 80 | ||||
| -rw-r--r-- | src/misc/vec/vecAtt.h | 391 | ||||
| -rw-r--r-- | src/misc/vec/vecFan.h | 374 | ||||
| -rw-r--r-- | src/misc/vec/vecFlt.h | 630 | ||||
| -rw-r--r-- | src/misc/vec/vecInt.h | 223 | ||||
| -rw-r--r-- | src/misc/vec/vecPtr.h | 290 | ||||
| -rw-r--r-- | src/misc/vec/vecStr.h | 88 | ||||
| -rw-r--r-- | src/misc/vec/vecVec.h | 114 |
8 files changed, 414 insertions, 1776 deletions
diff --git a/src/misc/vec/vec.h b/src/misc/vec/vec.h index a4bd4771..48c4b3c3 100644 --- a/src/misc/vec/vec.h +++ b/src/misc/vec/vec.h @@ -21,81 +21,19 @@ #ifndef __VEC_H__ #define __VEC_H__ -#ifdef __cplusplus -extern "C" { -#endif - -#ifdef _WIN32 -#define inline __inline // compatible with MS VS 6.0 -#pragma warning(disable : 4152) // warning C4152: nonstandard extension, function/data pointer conversion in expression -#pragma warning(disable : 4244) // warning C4244: '+=' : conversion from 'int ' to 'unsigned short ', possible loss of data -#pragma warning(disable : 4514) // warning C4514: 'Vec_StrPop' : unreferenced inline function has been removed -#pragma warning(disable : 4710) // warning C4710: function 'Vec_PtrGrow' not inlined -#endif - -#ifndef SINT64 -#define SINT64 - -#ifdef _WIN32 -typedef signed __int64 sint64; // compatible with MS VS 6.0 -#else -typedef long long sint64; -#endif - -#endif - //////////////////////////////////////////////////////////////////////// /// INCLUDES /// //////////////////////////////////////////////////////////////////////// -// this include should be the first one in the list -// it is used to catch memory leaks on Windows -#include "leaks.h" - -//////////////////////////////////////////////////////////////////////// -/// MACRO DEFINITIONS /// -//////////////////////////////////////////////////////////////////////// - -#ifndef ABS -#define ABS(a) ((a) < 0 ? -(a) : (a)) -#endif - -#ifndef MAX -#define MAX(a,b) ((a) > (b) ? (a) : (b)) -#endif - -#ifndef MIN -#define MIN(a,b) ((a) < (b) ? (a) : (b)) -#endif - -#ifndef ALLOC -#define ALLOC(type, num) ((type *) malloc(sizeof(type) * (num))) -#endif - -#ifndef FREE -#define FREE(obj) ((obj) ? (free((char *) (obj)), (obj) = 0) : 0) -#endif - -#ifndef REALLOC -#define REALLOC(type, obj, num) \ - ((obj) ? ((type *) realloc((char *)(obj), sizeof(type) * (num))) : \ - ((type *) malloc(sizeof(type) * (num)))) -#endif - -#ifndef PRT -#define PRT(a,t) printf("%s = ", (a)); printf("%6.2f sec\n", (float)(t)/(float)(CLOCKS_PER_SEC)) -#endif - -#ifndef PRTP -#define PRTP(a,t,T) printf("%s = ", (a)); printf("%6.2f sec (%6.2f %%)\n", (float)(t)/(float)(CLOCKS_PER_SEC), (T)? 100.0*(t)/(T) : 0.0) +#ifdef _WIN32 +#define inline __inline // compatible with MS VS 6.0 #endif +#include "vecFan.h" #include "vecInt.h" -#include "vecFlt.h" #include "vecStr.h" #include "vecPtr.h" #include "vecVec.h" -#include "vecAtt.h" //////////////////////////////////////////////////////////////////////// /// PARAMETERS /// @@ -106,16 +44,16 @@ typedef long long sint64; //////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// -/// FUNCTION DECLARATIONS /// +/// MACRO DEFITIONS /// //////////////////////////////////////////////////////////////////////// -#ifdef __cplusplus -} -#endif - -#endif +//////////////////////////////////////////////////////////////////////// +/// FUNCTION DECLARATIONS /// +//////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// /// END OF FILE /// //////////////////////////////////////////////////////////////////////// +#endif + diff --git a/src/misc/vec/vecAtt.h b/src/misc/vec/vecAtt.h deleted file mode 100644 index da7a8445..00000000 --- a/src/misc/vec/vecAtt.h +++ /dev/null @@ -1,391 +0,0 @@ -/**CFile**************************************************************** - - FileName [vecAtt.h] - - SystemName [ABC: Logic synthesis and verification system.] - - PackageName [Resizable arrays.] - - Synopsis [Array of user-specified attiributes.] - - Author [Alan Mishchenko] - - Affiliation [UC Berkeley] - - Date [Ver. 1.0. Started - June 20, 2005.] - - Revision [$Id: vecAtt.h,v 1.00 2005/06/20 00:00:00 alanmi Exp $] - -***********************************************************************/ - -#ifndef __Vec_Att_H__ -#define __Vec_Att_H__ - -//////////////////////////////////////////////////////////////////////// -/// INCLUDES /// -//////////////////////////////////////////////////////////////////////// - -#include <stdio.h> - -//////////////////////////////////////////////////////////////////////// -/// PARAMETERS /// -//////////////////////////////////////////////////////////////////////// - -// various attributes -typedef enum { - VEC_ATTR_NONE = 0, // 0 - VEC_ATTR_COPY, // 1 - VEC_ATTR_LOCAL_AIG, // 2 - VEC_ATTR_LOCAL_SOP, // 3 - VEC_ATTR_LOCAL_BDD, // 4 - VEC_ATTR_GLOBAL_AIG, // 5 - VEC_ATTR_GLOBAL_SOP, // 6 - VEC_ATTR_GLOBAL_BDD, // 7 - VEC_ATTR_LEVEL, // 8 - VEC_ATTR_LEVEL_REV, // 9 - VEC_ATTR_RETIME_LAG, // 10 - VEC_ATTR_FRAIG, // 11 - VEC_ATTR_MVVAR, // 12 - VEC_ATTR_DATA1, // 13 - VEC_ATTR_DATA2, // 14 - VEC_ATTR_TOTAL_NUM // 15 -} Vec_AttrType_t; - -//////////////////////////////////////////////////////////////////////// -/// BASIC TYPES /// -//////////////////////////////////////////////////////////////////////// - -typedef struct Vec_Att_t_ Vec_Att_t; -struct Vec_Att_t_ -{ - // storage for attributes - int nCap; // the size of array allocated - int * pArrayInt; // the integer attribute array - void ** pArrayPtr; // the pointer attribute array - // attribute specific info - void * pMan; // the manager for this attribute - void (*pFuncFreeMan) (void *); // the procedure to free the manager - void*(*pFuncStartObj)(void *); // the procedure to start one attribute - void (*pFuncFreeObj) (void *, void *); // the procedure to free one attribute -}; - -//////////////////////////////////////////////////////////////////////// -/// MACRO DEFINITIONS /// -//////////////////////////////////////////////////////////////////////// - -//////////////////////////////////////////////////////////////////////// -/// FUNCTION DEFINITIONS /// -//////////////////////////////////////////////////////////////////////// - -/**Function************************************************************* - - Synopsis [Allocates a vector with the given capacity.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -static inline Vec_Att_t * Vec_AttAlloc( - int fInteger, int nSize, void * pMan, - void (*pFuncFreeMan) (void *), - void*(*pFuncStartObj)(void *), - void (*pFuncFreeObj) (void *, void *) ) -{ - Vec_Att_t * p; - p = ALLOC( Vec_Att_t, 1 ); - memset( p, 0, sizeof(Vec_Att_t) ); - p->pMan = pMan; - p->pFuncFreeMan = pFuncFreeMan; - p->pFuncStartObj = pFuncStartObj; - p->pFuncFreeObj = pFuncFreeObj; - p->nCap = nSize? nSize : 16; - if ( fInteger ) - { - p->pArrayInt = ALLOC( int, p->nCap ); - memset( p->pArrayInt, 0xff, sizeof(int) * p->nCap ); - } - else - { - p->pArrayPtr = ALLOC( void *, p->nCap ); - memset( p->pArrayPtr, 0, sizeof(void *) * p->nCap ); - } - return p; -} - -/**Function************************************************************* - - Synopsis [Frees the vector.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -static inline void * Vec_AttFree( Vec_Att_t * p, int fFreeMan ) -{ - void * pMan; - if ( p == NULL ) - return NULL; - // free the attributes of objects - if ( p->pFuncFreeObj ) - { - int i; - if ( p->pArrayInt ) - { - for ( i = 0; i < p->nCap; i++ ) - if ( p->pArrayInt[i] ) - p->pFuncFreeObj( p->pMan, (void *)p->pArrayInt[i] ); - } - else - { - for ( i = 0; i < p->nCap; i++ ) - if ( p->pArrayPtr[i] ) - p->pFuncFreeObj( p->pMan, p->pArrayPtr[i] ); - } - } - // free the memory manager - pMan = fFreeMan? NULL : p->pMan; - if ( p->pMan && fFreeMan ) - p->pFuncFreeMan( p->pMan ); - FREE( p->pArrayInt ); - FREE( p->pArrayPtr ); - FREE( p ); - return pMan; -} - -/**Function************************************************************* - - Synopsis [Clears the vector.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -static inline void Vec_AttClear( Vec_Att_t * p ) -{ - // free the attributes of objects - if ( p->pFuncFreeObj ) - { - int i; - if ( p->pArrayInt ) - { - if ( p->pFuncFreeObj ) - for ( i = 0; i < p->nCap; i++ ) - if ( p->pArrayInt[i] ) - p->pFuncFreeObj( p->pMan, (void *)p->pArrayInt[i] ); - } - else - { - if ( p->pFuncFreeObj ) - for ( i = 0; i < p->nCap; i++ ) - if ( p->pArrayPtr[i] ) - p->pFuncFreeObj( p->pMan, p->pArrayPtr[i] ); - } - } - if ( p->pArrayInt ) - memset( p->pArrayInt, 0xff, sizeof(int) * p->nCap ); - else - memset( p->pArrayPtr, 0, sizeof(void *) * p->nCap ); - -} - -/**Function************************************************************* - - Synopsis [Deletes one entry from the attribute manager.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -static inline void Vec_AttFreeEntry( Vec_Att_t * p, int i ) -{ - if ( i >= p->nCap ) - return; - if ( p->pMan ) - { - if ( p->pArrayInt[i] && p->pFuncFreeObj ) - p->pFuncFreeObj( p->pMan, (void *)p->pArrayInt[i] ); - if ( p->pArrayPtr[i] && p->pFuncFreeObj ) - p->pFuncFreeObj( p->pMan, (void *)p->pArrayPtr[i] ); - } - if ( p->pArrayInt ) - p->pArrayInt[i] = ~(unsigned)0; - else - p->pArrayPtr[i] = NULL; -} - -/**Function************************************************************* - - Synopsis [Resizes the vector to the given capacity.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -static inline void Vec_AttGrow( Vec_Att_t * p, int nCapMin ) -{ - if ( p->nCap >= nCapMin ) - return; - if ( p->pArrayInt ) - { - p->pArrayInt = REALLOC( int, p->pArrayInt, nCapMin ); - memset( p->pArrayInt + p->nCap, 0xff, sizeof(int) * (nCapMin - p->nCap) ); - } - else - { - p->pArrayPtr = REALLOC( void *, p->pArrayPtr, nCapMin ); - memset( p->pArrayPtr + p->nCap, 0, sizeof(void *) * (nCapMin - p->nCap) ); - } - p->nCap = nCapMin; -} - -/**Function************************************************************* - - Synopsis [Writes the entry into its place.] - - Description [Only works if the manager is not defined.] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -static inline void Vec_AttWriteEntry( Vec_Att_t * p, int i, void * pEntry ) -{ - assert( p->pArrayPtr ); - assert( p->pFuncStartObj == NULL ); - if ( i >= p->nCap ) - Vec_AttGrow( p, (2 * p->nCap > i)? 2 * p->nCap : i + 10 ); - p->pArrayPtr[i] = pEntry; -} - -/**Function************************************************************* - - Synopsis [Writes the entry into its place.] - - Description [Only works if the manager is not defined.] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -static inline void Vec_AttWriteEntryInt( Vec_Att_t * p, int i, int Entry ) -{ - assert( p->pArrayInt ); - assert( p->pFuncStartObj == NULL ); - if ( i >= p->nCap ) - Vec_AttGrow( p, (2 * p->nCap > i)? 2 * p->nCap : i + 10 ); - p->pArrayInt[i] = Entry; -} - -/**Function************************************************************* - - Synopsis [Returns the entry.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -static inline void * Vec_AttEntry( Vec_Att_t * p, int i ) -{ - assert( p->pArrayPtr ); - if ( i >= p->nCap ) - Vec_AttGrow( p, (2 * p->nCap > i)? 2 * p->nCap : i + 10 ); - if ( p->pArrayPtr[i] == NULL && p->pFuncStartObj ) - p->pArrayPtr[i] = p->pFuncStartObj( p->pMan ); - return p->pArrayPtr[i]; -} - -/**Function************************************************************* - - Synopsis [Returns the entry.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -static inline int Vec_AttEntryInt( Vec_Att_t * p, int i ) -{ - assert( p->pArrayInt ); - assert( p->pMan == NULL ); - if ( i >= p->nCap ) - Vec_AttGrow( p, (2 * p->nCap > i)? 2 * p->nCap : i + 10 ); - return p->pArrayInt[i]; -} - -/**Function************************************************************* - - Synopsis [Returns the entry.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -static inline void * Vec_AttMan( Vec_Att_t * p ) -{ - return p->pMan; -} - -/**Function************************************************************* - - Synopsis [Returns the array of attributes.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -static inline void ** Vec_AttArray( Vec_Att_t * p ) -{ - return p->pArrayPtr; -} - -/**Function************************************************************* - - Synopsis [Returns the array of attributes.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -static inline int * Vec_AttArrayInt( Vec_Att_t * p ) -{ - return p->pArrayInt; -} - -#endif - - -//////////////////////////////////////////////////////////////////////// -/// END OF FILE /// -//////////////////////////////////////////////////////////////////////// - diff --git a/src/misc/vec/vecFan.h b/src/misc/vec/vecFan.h new file mode 100644 index 00000000..08d1d734 --- /dev/null +++ b/src/misc/vec/vecFan.h @@ -0,0 +1,374 @@ +/**CFile**************************************************************** + + FileName [vecFan.h] + + SystemName [ABC: Logic synthesis and verification system.] + + PackageName [Resizable arrays.] + + Synopsis [Resizable arrays of integers (fanins/fanouts) with memory management.] + + Author [Alan Mishchenko] + + Affiliation [UC Berkeley] + + Date [Ver. 1.0. Started - June 20, 2005.] + + Revision [$Id: vecFan.h,v 1.00 2005/06/20 00:00:00 alanmi Exp $] + +***********************************************************************/ + +#ifndef __VEC_FAN_H__ +#define __VEC_FAN_H__ + +//////////////////////////////////////////////////////////////////////// +/// INCLUDES /// +//////////////////////////////////////////////////////////////////////// + +#include <stdio.h> +#include "extra.h" + +//////////////////////////////////////////////////////////////////////// +/// PARAMETERS /// +//////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////// +/// BASIC TYPES /// +//////////////////////////////////////////////////////////////////////// + +typedef struct Abc_Fan_t_ Abc_Fan_t; +struct Abc_Fan_t_ // 1 word +{ + unsigned iFan : 24; // the ID of the object + unsigned nLats : 7; // the number of latches (up to 31) + unsigned fCompl : 1; // the complemented attribute +}; + +typedef struct Vec_Fan_t_ Vec_Fan_t; +struct Vec_Fan_t_ +{ + int nCap; + int nSize; + Abc_Fan_t * pArray; +}; + +//////////////////////////////////////////////////////////////////////// +/// MACRO DEFITIONS /// +//////////////////////////////////////////////////////////////////////// + +#define Vec_FanForEachEntry( vVec, Entry, i ) \ + for ( i = 0; (i < Vec_FanSize(vVec)) && (((Entry) = Vec_FanEntry(vVec, i)), 1); i++ ) + +//////////////////////////////////////////////////////////////////////// +/// FUNCTION DEFITIONS /// +//////////////////////////////////////////////////////////////////////// + +/**Function************************************************************* + + Synopsis [Converts an integer into the simple fanin structure.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline Abc_Fan_t Vec_Int2Fan( int iFan ) +{ + return *((Abc_Fan_t *)&iFan); +} + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline Abc_Fan_t * Vec_FanArray( Vec_Fan_t * p ) +{ + return p->pArray; +} + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline int Vec_FanSize( Vec_Fan_t * p ) +{ + return p->nSize; +} + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline Abc_Fan_t Vec_FanEntry( Vec_Fan_t * p, int i ) +{ + assert( i >= 0 && i < p->nSize ); + return p->pArray[i]; +} + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline void Vec_FanWriteEntry( Vec_Fan_t * p, int i, Abc_Fan_t Entry ) +{ + assert( i >= 0 && i < p->nSize ); + p->pArray[i] = Entry; +} + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline Abc_Fan_t Vec_FanEntryLast( Vec_Fan_t * p ) +{ + return p->pArray[p->nSize-1]; +} + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline void Vec_FanShrink( Vec_Fan_t * p, int nSizeNew ) +{ + assert( p->nSize >= nSizeNew ); + p->nSize = nSizeNew; +} + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline void Vec_FanClear( Vec_Fan_t * p ) +{ + p->nSize = 0; +} + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline void Vec_FanPush( Extra_MmStep_t * pMemMan, Vec_Fan_t * p, Abc_Fan_t Entry ) +{ + if ( p->nSize == p->nCap ) + { + Abc_Fan_t * pArray; + int i; + + if ( p->nSize == 0 ) + p->nCap = 1; + pArray = (Abc_Fan_t *)Extra_MmStepEntryFetch( pMemMan, p->nCap * 8 ); +// pArray = ALLOC( int, p->nCap * 2 ); + if ( p->pArray ) + { + for ( i = 0; i < p->nSize; i++ ) + pArray[i] = p->pArray[i]; + Extra_MmStepEntryRecycle( pMemMan, (char *)p->pArray, p->nCap * 4 ); +// free( p->pArray ); + } + p->nCap *= 2; + p->pArray = pArray; + } + p->pArray[p->nSize++] = Entry; +} + +/**Function************************************************************* + + Synopsis [Returns the last entry and removes it from the list.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline Abc_Fan_t Vec_FanPop( Vec_Fan_t * p ) +{ + assert( p->nSize > 0 ); + return p->pArray[--p->nSize]; +} + +/**Function************************************************************* + + Synopsis [Find entry.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline int Vec_FanFindEntry( Vec_Fan_t * p, unsigned iFan ) +{ + int i; + for ( i = 0; i < p->nSize; i++ ) + if ( p->pArray[i].iFan == iFan ) + return i; + return -1; +} + +/**Function************************************************************* + + Synopsis [Deletes entry.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline int Vec_FanDeleteEntry( Vec_Fan_t * p, unsigned iFan ) +{ +/* + int i, k, fFound = 0; + for ( i = k = 0; i < p->nSize; i++ ) + { + if ( p->pArray[i].iFan == iFan ) + fFound = 1; + else + p->pArray[k++] = p->pArray[i]; + } + p->nSize = k; + return fFound; +*/ + int i; + for ( i = 0; i < p->nSize; i++ ) + if ( p->pArray[i].iFan == iFan ) + break; + if ( i == p->nSize ) + return 0; + for ( i++; i < p->nSize; i++ ) + p->pArray[i-1] = p->pArray[i]; + p->nSize--; + return 1; +} + +/**Function************************************************************* + + Synopsis [Comparison procedure for two integers.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline int Vec_FanSortCompare1( int * pp1, int * pp2 ) +{ + // for some reason commenting out lines (as shown) led to crashing of the release version + if ( *pp1 < *pp2 ) + return -1; + if ( *pp1 > *pp2 ) // + return 1; + return 0; // +} + +/**Function************************************************************* + + Synopsis [Comparison procedure for two integers.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline int Vec_FanSortCompare2( int * pp1, int * pp2 ) +{ + // for some reason commenting out lines (as shown) led to crashing of the release version + if ( *pp1 > *pp2 ) + return -1; + if ( *pp1 < *pp2 ) // + return 1; + return 0; // +} + +/**Function************************************************************* + + Synopsis [Sorting the entries by their integer value.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline void Vec_FanSort( Vec_Fan_t * p, int fReverse ) +{ + if ( fReverse ) + qsort( (void *)p->pArray, p->nSize, sizeof(int), + (int (*)(const void *, const void *)) Vec_FanSortCompare2 ); + else + qsort( (void *)p->pArray, p->nSize, sizeof(int), + (int (*)(const void *, const void *)) Vec_FanSortCompare1 ); +} + +//////////////////////////////////////////////////////////////////////// +/// END OF FILE /// +//////////////////////////////////////////////////////////////////////// + +#endif + diff --git a/src/misc/vec/vecFlt.h b/src/misc/vec/vecFlt.h deleted file mode 100644 index 6b36ce84..00000000 --- a/src/misc/vec/vecFlt.h +++ /dev/null @@ -1,630 +0,0 @@ -/**CFile**************************************************************** - - FileName [vecFlt.h] - - SystemName [ABC: Logic synthesis and verification system.] - - PackageName [Resizable arrays.] - - Synopsis [Resizable arrays of floats.] - - Author [Aaron P. Hurst] - - Affiliation [UC Berkeley] - - Date [Ver. 1.0. Started - June 20, 2005.] - - Revision [$Id: vecInt.h,v 1.00 2005/06/20 00:00:00 alanmi Exp $] - -***********************************************************************/ - -#ifndef __VEC_FLT_H__ -#define __VEC_FLT_H__ - -//////////////////////////////////////////////////////////////////////// -/// INCLUDES /// -//////////////////////////////////////////////////////////////////////// - -#include <stdio.h> - -//////////////////////////////////////////////////////////////////////// -/// PARAMETERS /// -//////////////////////////////////////////////////////////////////////// - -//////////////////////////////////////////////////////////////////////// -/// BASIC TYPES /// -//////////////////////////////////////////////////////////////////////// - -typedef struct Vec_Flt_t_ Vec_Flt_t; -struct Vec_Flt_t_ -{ - int nCap; - int nSize; - float * pArray; -}; - -//////////////////////////////////////////////////////////////////////// -/// MACRO DEFINITIONS /// -//////////////////////////////////////////////////////////////////////// - -#define Vec_FltForEachEntry( vVec, Entry, i ) \ - for ( i = 0; (i < Vec_FltSize(vVec)) && (((Entry) = Vec_FltEntry(vVec, i)), 1); i++ ) -#define Vec_FltForEachEntryStart( vVec, Entry, i, Start ) \ - for ( i = Start; (i < Vec_FltSize(vVec)) && (((Entry) = Vec_FltEntry(vVec, i)), 1); i++ ) -#define Vec_FltForEachEntryStartStop( vVec, Entry, i, Start, Stop ) \ - for ( i = Start; (i < Stop) && (((Entry) = Vec_FltEntry(vVec, i)), 1); i++ ) -#define Vec_FltForEachEntryReverse( vVec, pEntry, i ) \ - for ( i = Vec_FltSize(vVec) - 1; (i >= 0) && (((pEntry) = Vec_FltEntry(vVec, i)), 1); i-- ) - -//////////////////////////////////////////////////////////////////////// -/// FUNCTION DEFINITIONS /// -//////////////////////////////////////////////////////////////////////// - -/**Function************************************************************* - - Synopsis [Allocates a vector with the given capacity.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -static inline Vec_Flt_t * Vec_FltAlloc( int nCap ) -{ - Vec_Flt_t * p; - p = ALLOC( Vec_Flt_t, 1 ); - if ( nCap > 0 && nCap < 16 ) - nCap = 16; - p->nSize = 0; - p->nCap = nCap; - p->pArray = p->nCap? ALLOC( float, p->nCap ) : NULL; - return p; -} - -/**Function************************************************************* - - Synopsis [Allocates a vector with the given size and cleans it.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -static inline Vec_Flt_t * Vec_FltStart( int nSize ) -{ - Vec_Flt_t * p; - p = Vec_FltAlloc( nSize ); - p->nSize = nSize; - memset( p->pArray, 0, sizeof(float) * nSize ); - return p; -} - -/**Function************************************************************* - - Synopsis [Creates the vector from a float array of the given size.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -static inline Vec_Flt_t * Vec_FltAllocArray( float * pArray, int nSize ) -{ - Vec_Flt_t * p; - p = ALLOC( Vec_Flt_t, 1 ); - p->nSize = nSize; - p->nCap = nSize; - p->pArray = pArray; - return p; -} - -/**Function************************************************************* - - Synopsis [Creates the vector from a float array of the given size.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -static inline Vec_Flt_t * Vec_FltAllocArrayCopy( float * pArray, int nSize ) -{ - Vec_Flt_t * p; - p = ALLOC( Vec_Flt_t, 1 ); - p->nSize = nSize; - p->nCap = nSize; - p->pArray = ALLOC( float, nSize ); - memcpy( p->pArray, pArray, sizeof(float) * nSize ); - return p; -} - -/**Function************************************************************* - - Synopsis [Duplicates the float array.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -static inline Vec_Flt_t * Vec_FltDup( Vec_Flt_t * pVec ) -{ - Vec_Flt_t * p; - p = ALLOC( Vec_Flt_t, 1 ); - p->nSize = pVec->nSize; - p->nCap = pVec->nCap; - p->pArray = p->nCap? ALLOC( float, p->nCap ) : NULL; - memcpy( p->pArray, pVec->pArray, sizeof(float) * pVec->nSize ); - return p; -} - -/**Function************************************************************* - - Synopsis [Transfers the array into another vector.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -static inline Vec_Flt_t * Vec_FltDupArray( Vec_Flt_t * pVec ) -{ - Vec_Flt_t * p; - p = ALLOC( Vec_Flt_t, 1 ); - p->nSize = pVec->nSize; - p->nCap = pVec->nCap; - p->pArray = pVec->pArray; - pVec->nSize = 0; - pVec->nCap = 0; - pVec->pArray = NULL; - return p; -} - -/**Function************************************************************* - - Synopsis [] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -static inline void Vec_FltFree( Vec_Flt_t * p ) -{ - FREE( p->pArray ); - FREE( p ); -} - -/**Function************************************************************* - - Synopsis [] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -static inline float * Vec_FltReleaseArray( Vec_Flt_t * p ) -{ - float * pArray = p->pArray; - p->nCap = 0; - p->nSize = 0; - p->pArray = NULL; - return pArray; -} - -/**Function************************************************************* - - Synopsis [] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -static inline float * Vec_FltArray( Vec_Flt_t * p ) -{ - return p->pArray; -} - -/**Function************************************************************* - - Synopsis [] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -static inline int Vec_FltSize( Vec_Flt_t * p ) -{ - return p->nSize; -} - -/**Function************************************************************* - - Synopsis [] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -static inline float Vec_FltEntry( Vec_Flt_t * p, int i ) -{ - assert( i >= 0 && i < p->nSize ); - return p->pArray[i]; -} - -/**Function************************************************************* - - Synopsis [] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -static inline void Vec_FltWriteEntry( Vec_Flt_t * p, int i, float Entry ) -{ - assert( i >= 0 && i < p->nSize ); - p->pArray[i] = Entry; -} - -/**Function************************************************************* - - Synopsis [] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -static inline void Vec_FltAddToEntry( Vec_Flt_t * p, int i, float Addition ) -{ - assert( i >= 0 && i < p->nSize ); - p->pArray[i] += Addition; -} - -/**Function************************************************************* - - Synopsis [] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -static inline float Vec_FltEntryLast( Vec_Flt_t * p ) -{ - return p->pArray[p->nSize-1]; -} - -/**Function************************************************************* - - Synopsis [Resizes the vector to the given capacity.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -static inline void Vec_FltGrow( Vec_Flt_t * p, int nCapMin ) -{ - if ( p->nCap >= nCapMin ) - return; - p->pArray = REALLOC( float, p->pArray, nCapMin ); - p->nCap = nCapMin; -} - -/**Function************************************************************* - - Synopsis [Fills the vector with given number of entries.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -static inline void Vec_FltFill( Vec_Flt_t * p, int nSize, float Entry ) -{ - int i; - Vec_FltGrow( p, nSize ); - for ( i = 0; i < nSize; i++ ) - p->pArray[i] = Entry; - p->nSize = nSize; -} - -/**Function************************************************************* - - Synopsis [Fills the vector with given number of entries.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -static inline void Vec_FltFillExtra( Vec_Flt_t * p, int nSize, float Entry ) -{ - int i; - if ( p->nSize >= nSize ) - return; - Vec_FltGrow( p, nSize ); - for ( i = p->nSize; i < nSize; i++ ) - p->pArray[i] = Entry; - p->nSize = nSize; -} - -/**Function************************************************************* - - Synopsis [] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -static inline void Vec_FltShrink( Vec_Flt_t * p, int nSizeNew ) -{ - assert( p->nSize >= nSizeNew ); - p->nSize = nSizeNew; -} - -/**Function************************************************************* - - Synopsis [] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -static inline void Vec_FltClear( Vec_Flt_t * p ) -{ - p->nSize = 0; -} - -/**Function************************************************************* - - Synopsis [] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -static inline void Vec_FltPush( Vec_Flt_t * p, float Entry ) -{ - if ( p->nSize == p->nCap ) - { - if ( p->nCap < 16 ) - Vec_FltGrow( p, 16 ); - else - Vec_FltGrow( p, 2 * p->nCap ); - } - p->pArray[p->nSize++] = Entry; -} - -/**Function************************************************************* - - Synopsis [] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -static inline void Vec_FltPushOrder( Vec_Flt_t * p, float Entry ) -{ - int i; - if ( p->nSize == p->nCap ) - { - if ( p->nCap < 16 ) - Vec_FltGrow( p, 16 ); - else - Vec_FltGrow( p, 2 * p->nCap ); - } - p->nSize++; - for ( i = p->nSize-2; i >= 0; i-- ) - if ( p->pArray[i] > Entry ) - p->pArray[i+1] = p->pArray[i]; - else - break; - p->pArray[i+1] = Entry; -} - -/**Function************************************************************* - - Synopsis [] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -static inline int Vec_FltPushUnique( Vec_Flt_t * p, float Entry ) -{ - int i; - for ( i = 0; i < p->nSize; i++ ) - if ( p->pArray[i] == Entry ) - return 1; - Vec_FltPush( p, Entry ); - return 0; -} - -/**Function************************************************************* - - Synopsis [Returns the last entry and removes it from the list.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -static inline float Vec_FltPop( Vec_Flt_t * p ) -{ - assert( p->nSize > 0 ); - return p->pArray[--p->nSize]; -} - -/**Function************************************************************* - - Synopsis [Find entry.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -static inline int Vec_FltFind( Vec_Flt_t * p, float Entry ) -{ - int i; - for ( i = 0; i < p->nSize; i++ ) - if ( p->pArray[i] == Entry ) - return i; - return -1; -} - -/**Function************************************************************* - - Synopsis [] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -static inline int Vec_FltRemove( Vec_Flt_t * p, float Entry ) -{ - int i; - for ( i = 0; i < p->nSize; i++ ) - if ( p->pArray[i] == Entry ) - break; - if ( i == p->nSize ) - return 0; - assert( i < p->nSize ); - for ( i++; i < p->nSize; i++ ) - p->pArray[i-1] = p->pArray[i]; - p->nSize--; - return 1; -} - -/**Function************************************************************* - - Synopsis [Comparison procedure for two floats.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -static inline int Vec_FltSortCompare1( float * pp1, float * pp2 ) -{ - // for some reason commenting out lines (as shown) led to crashing of the release version - if ( *pp1 < *pp2 ) - return -1; - if ( *pp1 > *pp2 ) // - return 1; - return 0; // -} - -/**Function************************************************************* - - Synopsis [Comparison procedure for two floats.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -static inline int Vec_FltSortCompare2( float * pp1, float * pp2 ) -{ - // for some reason commenting out lines (as shown) led to crashing of the release version - if ( *pp1 > *pp2 ) - return -1; - if ( *pp1 < *pp2 ) // - return 1; - return 0; // -} - -/**Function************************************************************* - - Synopsis [Sorting the entries by their value.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -static inline void Vec_FltSort( Vec_Flt_t * p, int fReverse ) -{ - if ( fReverse ) - qsort( (void *)p->pArray, p->nSize, sizeof(float), - (int (*)(const void *, const void *)) Vec_FltSortCompare2 ); - else - qsort( (void *)p->pArray, p->nSize, sizeof(float), - (int (*)(const void *, const void *)) Vec_FltSortCompare1 ); -} - -//////////////////////////////////////////////////////////////////////// -/// END OF FILE /// -//////////////////////////////////////////////////////////////////////// - -#endif - diff --git a/src/misc/vec/vecInt.h b/src/misc/vec/vecInt.h index 082ebe70..7556dd87 100644 --- a/src/misc/vec/vecInt.h +++ b/src/misc/vec/vecInt.h @@ -26,6 +26,7 @@ //////////////////////////////////////////////////////////////////////// #include <stdio.h> +#include "extra.h" //////////////////////////////////////////////////////////////////////// /// PARAMETERS /// @@ -44,20 +45,16 @@ struct Vec_Int_t_ }; //////////////////////////////////////////////////////////////////////// -/// MACRO DEFINITIONS /// +/// MACRO DEFITIONS /// //////////////////////////////////////////////////////////////////////// #define Vec_IntForEachEntry( vVec, Entry, i ) \ for ( i = 0; (i < Vec_IntSize(vVec)) && (((Entry) = Vec_IntEntry(vVec, i)), 1); i++ ) #define Vec_IntForEachEntryStart( vVec, Entry, i, Start ) \ for ( i = Start; (i < Vec_IntSize(vVec)) && (((Entry) = Vec_IntEntry(vVec, i)), 1); i++ ) -#define Vec_IntForEachEntryStartStop( vVec, Entry, i, Start, Stop ) \ - for ( i = Start; (i < Stop) && (((Entry) = Vec_IntEntry(vVec, i)), 1); i++ ) -#define Vec_IntForEachEntryReverse( vVec, pEntry, i ) \ - for ( i = Vec_IntSize(vVec) - 1; (i >= 0) && (((pEntry) = Vec_IntEntry(vVec, i)), 1); i-- ) //////////////////////////////////////////////////////////////////////// -/// FUNCTION DEFINITIONS /// +/// FUNCTION DEFITIONS /// //////////////////////////////////////////////////////////////////////// /**Function************************************************************* @@ -105,28 +102,6 @@ static inline Vec_Int_t * Vec_IntStart( int nSize ) /**Function************************************************************* - Synopsis [Allocates a vector with the given size and cleans it.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -static inline Vec_Int_t * Vec_IntStartNatural( int nSize ) -{ - Vec_Int_t * p; - int i; - p = Vec_IntAlloc( nSize ); - p->nSize = nSize; - for ( i = 0; i < nSize; i++ ) - p->pArray[i] = i; - return p; -} - -/**Function************************************************************* - Synopsis [Creates the vector from an integer array of the given size.] Description [] @@ -184,7 +159,7 @@ static inline Vec_Int_t * Vec_IntDup( Vec_Int_t * pVec ) Vec_Int_t * p; p = ALLOC( Vec_Int_t, 1 ); p->nSize = pVec->nSize; - p->nCap = pVec->nSize; + p->nCap = pVec->nCap; p->pArray = p->nCap? ALLOC( int, p->nCap ) : NULL; memcpy( p->pArray, pVec->pArray, sizeof(int) * pVec->nSize ); return p; @@ -328,26 +303,8 @@ static inline void Vec_IntWriteEntry( Vec_Int_t * p, int i, int Entry ) SeeAlso [] ***********************************************************************/ -static inline void Vec_IntAddToEntry( Vec_Int_t * p, int i, int Addition ) -{ - assert( i >= 0 && i < p->nSize ); - p->pArray[i] += Addition; -} - -/**Function************************************************************* - - Synopsis [] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ static inline int Vec_IntEntryLast( Vec_Int_t * p ) { - assert( p->nSize > 0 ); return p->pArray[p->nSize-1]; } @@ -367,7 +324,6 @@ static inline void Vec_IntGrow( Vec_Int_t * p, int nCapMin ) if ( p->nCap >= nCapMin ) return; p->pArray = REALLOC( int, p->pArray, nCapMin ); - assert( p->pArray ); p->nCap = nCapMin; } @@ -480,33 +436,6 @@ static inline void Vec_IntPush( Vec_Int_t * p, int Entry ) SeeAlso [] ***********************************************************************/ -static inline void Vec_IntPushFirst( Vec_Int_t * p, int Entry ) -{ - int i; - if ( p->nSize == p->nCap ) - { - if ( p->nCap < 16 ) - Vec_IntGrow( p, 16 ); - else - Vec_IntGrow( p, 2 * p->nCap ); - } - p->nSize++; - for ( i = p->nSize - 1; i >= 1; i-- ) - p->pArray[i] = p->pArray[i-1]; - p->pArray[0] = Entry; -} - -/**Function************************************************************* - - Synopsis [Inserts the entry while preserving the increasing order.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ static inline void Vec_IntPushOrder( Vec_Int_t * p, int Entry ) { int i; @@ -528,27 +457,6 @@ static inline void Vec_IntPushOrder( Vec_Int_t * p, int Entry ) /**Function************************************************************* - Synopsis [Inserts the entry while preserving the increasing order.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -static inline int Vec_IntPushUniqueOrder( Vec_Int_t * p, int Entry ) -{ - int i; - for ( i = 0; i < p->nSize; i++ ) - if ( p->pArray[i] == Entry ) - return 1; - Vec_IntPushOrder( p, Entry ); - return 0; -} - -/**Function************************************************************* - Synopsis [] Description [] @@ -570,31 +478,6 @@ static inline int Vec_IntPushUnique( Vec_Int_t * p, int Entry ) /**Function************************************************************* - Synopsis [Returns the pointer to the next nWords entries in the vector.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -static inline unsigned * Vec_IntFetch( Vec_Int_t * p, int nWords ) -{ - if ( nWords == 0 ) - return NULL; - assert( nWords > 0 ); - p->nSize += nWords; - if ( p->nSize > p->nCap ) - { -// Vec_IntGrow( p, 2 * p->nSize ); - return NULL; - } - return ((unsigned *)p->pArray) + p->nSize - nWords; -} - -/**Function************************************************************* - Synopsis [Returns the last entry and removes it from the list.] Description [] @@ -612,26 +495,6 @@ static inline int Vec_IntPop( Vec_Int_t * p ) /**Function************************************************************* - Synopsis [Find entry.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -static inline int Vec_IntFind( Vec_Int_t * p, int Entry ) -{ - int i; - for ( i = 0; i < p->nSize; i++ ) - if ( p->pArray[i] == Entry ) - return i; - return -1; -} - -/**Function************************************************************* - Synopsis [] Description [] @@ -641,19 +504,16 @@ static inline int Vec_IntFind( Vec_Int_t * p, int Entry ) SeeAlso [] ***********************************************************************/ -static inline int Vec_IntRemove( Vec_Int_t * p, int Entry ) +static inline void Vec_IntRemove( Vec_Int_t * p, int Entry ) { int i; for ( i = 0; i < p->nSize; i++ ) if ( p->pArray[i] == Entry ) break; - if ( i == p->nSize ) - return 0; assert( i < p->nSize ); for ( i++; i < p->nSize; i++ ) p->pArray[i-1] = p->pArray[i]; p->nSize--; - return 1; } /**Function************************************************************* @@ -757,78 +617,9 @@ static inline void Vec_IntSortUnsigned( Vec_Int_t * p ) (int (*)(const void *, const void *)) Vec_IntSortCompareUnsigned ); } -/**Function************************************************************* - - Synopsis [Returns the number of common entries.] - - Description [Assumes that the vectors are sorted in the increasing order.] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -static inline int Vec_IntTwoCountCommon( Vec_Int_t * vArr1, Vec_Int_t * vArr2 ) -{ - int * pBeg1 = vArr1->pArray; - int * pBeg2 = vArr2->pArray; - int * pEnd1 = vArr1->pArray + vArr1->nSize; - int * pEnd2 = vArr2->pArray + vArr2->nSize; - int Counter = 0; - while ( pBeg1 < pEnd1 && pBeg2 < pEnd2 ) - { - if ( *pBeg1 == *pBeg2 ) - pBeg1++, pBeg2++, Counter++; - else if ( *pBeg1 < *pBeg2 ) - pBeg1++; - else - pBeg2++; - } - return Counter; -} - -/**Function************************************************************* - - Synopsis [Returns the result of merging the two vectors.] - - Description [Assumes that the vectors are sorted in the increasing order.] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -static inline Vec_Int_t * Vec_IntTwoMerge( Vec_Int_t * vArr1, Vec_Int_t * vArr2 ) -{ - Vec_Int_t * vArr = Vec_IntAlloc( vArr1->nSize + vArr2->nSize ); - int * pBeg = vArr->pArray; - int * pBeg1 = vArr1->pArray; - int * pBeg2 = vArr2->pArray; - int * pEnd1 = vArr1->pArray + vArr1->nSize; - int * pEnd2 = vArr2->pArray + vArr2->nSize; - while ( pBeg1 < pEnd1 && pBeg2 < pEnd2 ) - { - if ( *pBeg1 == *pBeg2 ) - *pBeg++ = *pBeg1++, pBeg2++; - else if ( *pBeg1 < *pBeg2 ) - *pBeg++ = *pBeg1++; - else - *pBeg++ = *pBeg2++; - } - while ( pBeg1 < pEnd1 ) - *pBeg++ = *pBeg1++; - while ( pBeg2 < pEnd2 ) - *pBeg++ = *pBeg2++; - vArr->nSize = pBeg - vArr->pArray; - assert( vArr->nSize <= vArr->nCap ); - assert( vArr->nSize >= vArr1->nSize ); - assert( vArr->nSize >= vArr2->nSize ); - return vArr; -} - -#endif - //////////////////////////////////////////////////////////////////////// /// END OF FILE /// //////////////////////////////////////////////////////////////////////// +#endif + diff --git a/src/misc/vec/vecPtr.h b/src/misc/vec/vecPtr.h index 9595bc72..b1776441 100644 --- a/src/misc/vec/vecPtr.h +++ b/src/misc/vec/vecPtr.h @@ -26,6 +26,7 @@ //////////////////////////////////////////////////////////////////////// #include <stdio.h> +#include "extra.h" //////////////////////////////////////////////////////////////////////// /// PARAMETERS /// @@ -44,7 +45,7 @@ struct Vec_Ptr_t_ }; //////////////////////////////////////////////////////////////////////// -/// MACRO DEFINITIONS /// +/// MACRO DEFITIONS /// //////////////////////////////////////////////////////////////////////// // iterators through entries @@ -52,15 +53,11 @@ struct Vec_Ptr_t_ for ( i = 0; (i < Vec_PtrSize(vVec)) && (((pEntry) = Vec_PtrEntry(vVec, i)), 1); i++ ) #define Vec_PtrForEachEntryStart( vVec, pEntry, i, Start ) \ for ( i = Start; (i < Vec_PtrSize(vVec)) && (((pEntry) = Vec_PtrEntry(vVec, i)), 1); i++ ) -#define Vec_PtrForEachEntryStop( vVec, pEntry, i, Stop ) \ - for ( i = 0; (i < Stop) && (((pEntry) = Vec_PtrEntry(vVec, i)), 1); i++ ) -#define Vec_PtrForEachEntryStartStop( vVec, pEntry, i, Start, Stop ) \ - for ( i = Start; (i < Stop) && (((pEntry) = Vec_PtrEntry(vVec, i)), 1); i++ ) #define Vec_PtrForEachEntryReverse( vVec, pEntry, i ) \ for ( i = Vec_PtrSize(vVec) - 1; (i >= 0) && (((pEntry) = Vec_PtrEntry(vVec, i)), 1); i-- ) //////////////////////////////////////////////////////////////////////// -/// FUNCTION DEFINITIONS /// +/// FUNCTION DEFITIONS /// //////////////////////////////////////////////////////////////////////// /**Function************************************************************* @@ -292,23 +289,6 @@ static inline void * Vec_PtrEntry( Vec_Ptr_t * p, int i ) SeeAlso [] ***********************************************************************/ -static inline void ** Vec_PtrEntryP( Vec_Ptr_t * p, int i ) -{ - assert( i >= 0 && i < p->nSize ); - return p->pArray + i; -} - -/**Function************************************************************* - - Synopsis [] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ static inline void Vec_PtrWriteEntry( Vec_Ptr_t * p, int i, void * Entry ) { assert( i >= 0 && i < p->nSize ); @@ -328,7 +308,6 @@ static inline void Vec_PtrWriteEntry( Vec_Ptr_t * p, int i, void * Entry ) ***********************************************************************/ static inline void * Vec_PtrEntryLast( Vec_Ptr_t * p ) { - assert( p->nSize > 0 ); return p->pArray[p->nSize-1]; } @@ -387,11 +366,7 @@ static inline void Vec_PtrFillExtra( Vec_Ptr_t * p, int nSize, void * Entry ) int i; if ( p->nSize >= nSize ) return; - assert( p->nSize < nSize ); - if ( 2 * p->nSize > nSize ) - Vec_PtrGrow( p, 2 * nSize ); - else - Vec_PtrGrow( p, nSize ); + Vec_PtrGrow( p, nSize ); for ( i = p->nSize; i < nSize; i++ ) p->pArray[i] = Entry; p->nSize = nSize; @@ -399,40 +374,6 @@ static inline void Vec_PtrFillExtra( Vec_Ptr_t * p, int nSize, void * Entry ) /**Function************************************************************* - Synopsis [Returns the entry even if the place not exist.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -static inline void * Vec_PtrGetEntry( Vec_Ptr_t * p, int i ) -{ - Vec_PtrFillExtra( p, i + 1, NULL ); - return Vec_PtrEntry( p, i ); -} - -/**Function************************************************************* - - Synopsis [Inserts the entry even if the place does not exist.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -static inline void Vec_PtrSetEntry( Vec_Ptr_t * p, int i, void * Entry ) -{ - Vec_PtrFillExtra( p, i + 1, NULL ); - Vec_PtrWriteEntry( p, i, Entry ); -} - -/**Function************************************************************* - Synopsis [] Description [] @@ -466,25 +407,6 @@ static inline void Vec_PtrClear( Vec_Ptr_t * p ) /**Function************************************************************* - Synopsis [Copies the interger array.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -static inline void Vec_PtrCopy( Vec_Ptr_t * pDest, Vec_Ptr_t * pSour ) -{ - pDest->nSize = 0; - Vec_PtrGrow( pDest, pSour->nSize ); - memcpy( pDest->pArray, pSour->pArray, sizeof(void *) * pSour->nSize ); - pDest->nSize = pSour->nSize; -} - -/**Function************************************************************* - Synopsis [] Description [] @@ -546,26 +468,6 @@ static inline void * Vec_PtrPop( Vec_Ptr_t * p ) /**Function************************************************************* - Synopsis [Find entry.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -static inline int Vec_PtrFind( Vec_Ptr_t * p, void * Entry ) -{ - int i; - for ( i = 0; i < p->nSize; i++ ) - if ( p->pArray[i] == Entry ) - return i; - return -1; -} - -/**Function************************************************************* - Synopsis [] Description [] @@ -578,18 +480,10 @@ static inline int Vec_PtrFind( Vec_Ptr_t * p, void * Entry ) static inline void Vec_PtrRemove( Vec_Ptr_t * p, void * Entry ) { int i; - // delete assuming that it is closer to the end - for ( i = p->nSize - 1; i >= 0; i-- ) - if ( p->pArray[i] == Entry ) - break; - assert( i >= 0 ); -/* - // delete assuming that it is closer to the beginning for ( i = 0; i < p->nSize; i++ ) if ( p->pArray[i] == Entry ) break; assert( i < p->nSize ); -*/ for ( i++; i < p->nSize; i++ ) p->pArray[i-1] = p->pArray[i]; p->nSize--; @@ -627,186 +521,14 @@ static inline void Vec_PtrReorder( Vec_Ptr_t * p, int nItems ) ***********************************************************************/ static inline void Vec_PtrSort( Vec_Ptr_t * p, int (*Vec_PtrSortCompare)() ) { - if ( p->nSize < 2 ) - return; qsort( (void *)p->pArray, p->nSize, sizeof(void *), (int (*)(const void *, const void *)) Vec_PtrSortCompare ); } -/**Function************************************************************* - - Synopsis [Sorting the entries by their integer value.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -static inline void Vec_PtrUniqify( Vec_Ptr_t * p, int (*Vec_PtrSortCompare)() ) -{ - int i, k; - if ( p->nSize < 2 ) - return; - qsort( (void *)p->pArray, p->nSize, sizeof(void *), - (int (*)(const void *, const void *)) Vec_PtrSortCompare ); - for ( i = k = 1; i < p->nSize; i++ ) - if ( p->pArray[i] != p->pArray[i-1] ) - p->pArray[k++] = p->pArray[i]; - p->nSize = k; -} - - - -/**Function************************************************************* - - Synopsis [Allocates the array of simulation info.] - - Description [Allocates the array containing given number of entries, - each of which contains given number of unsigned words of simulation data. - The resulting array can be freed using regular procedure Vec_PtrFree(). - It is the responsibility of the user to ensure this array is never grown.] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -static inline Vec_Ptr_t * Vec_PtrAllocSimInfo( int nEntries, int nWords ) -{ - void ** pMemory; - unsigned * pInfo; - int i; - pMemory = (void **)ALLOC( char, (sizeof(void *) + sizeof(unsigned) * nWords) * nEntries ); - pInfo = (unsigned *)(pMemory + nEntries); - for ( i = 0; i < nEntries; i++ ) - pMemory[i] = pInfo + i * nWords; - return Vec_PtrAllocArray( pMemory, nEntries ); -} - -/**Function************************************************************* - - Synopsis [Cleans simulation info of each entry beginning with iWord.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -static inline void Vec_PtrCleanSimInfo( Vec_Ptr_t * vInfo, int iWord, int nWords ) -{ - int i; - for ( i = 0; i < vInfo->nSize; i++ ) - memset( (char*)Vec_PtrEntry(vInfo,i) + 4*iWord, 0, 4*(nWords-iWord) ); -} - -/**Function************************************************************* - - Synopsis [Resizes the array of simulation info.] - - Description [Doubles the number of objects for which siminfo is allocated.] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -static inline void Vec_PtrDoubleSimInfo( Vec_Ptr_t * vInfo ) -{ - Vec_Ptr_t * vInfoNew; - int nWords; - assert( Vec_PtrSize(vInfo) > 1 ); - // get the new array - nWords = (unsigned *)Vec_PtrEntry(vInfo,1) - (unsigned *)Vec_PtrEntry(vInfo,0); - vInfoNew = Vec_PtrAllocSimInfo( 2*Vec_PtrSize(vInfo), nWords ); - // copy the simulation info - memcpy( Vec_PtrEntry(vInfoNew,0), Vec_PtrEntry(vInfo,0), Vec_PtrSize(vInfo) * nWords * 4 ); - // replace the array - free( vInfo->pArray ); - vInfo->pArray = vInfoNew->pArray; - vInfo->nSize *= 2; - vInfo->nCap *= 2; - // free the old array - vInfoNew->pArray = NULL; - free( vInfoNew ); -} - -/**Function************************************************************* - - Synopsis [Resizes the array of simulation info.] - - Description [Doubles the number of simulation patterns stored for each object.] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -static inline void Vec_PtrReallocSimInfo( Vec_Ptr_t * vInfo ) -{ - Vec_Ptr_t * vInfoNew; - int nWords, i; - assert( Vec_PtrSize(vInfo) > 1 ); - // get the new array - nWords = (unsigned *)Vec_PtrEntry(vInfo,1) - (unsigned *)Vec_PtrEntry(vInfo,0); - vInfoNew = Vec_PtrAllocSimInfo( Vec_PtrSize(vInfo), 2*nWords ); - // copy the simulation info - for ( i = 0; i < vInfo->nSize; i++ ) - memcpy( Vec_PtrEntry(vInfoNew,i), Vec_PtrEntry(vInfo,i), nWords * 4 ); - // replace the array - free( vInfo->pArray ); - vInfo->pArray = vInfoNew->pArray; - // free the old array - vInfoNew->pArray = NULL; - free( vInfoNew ); -} - -/**Function************************************************************* - - Synopsis [Allocates the array of truth tables for the given number of vars.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -static inline Vec_Ptr_t * Vec_PtrAllocTruthTables( int nVars ) -{ - Vec_Ptr_t * p; - unsigned Masks[5] = { 0xAAAAAAAA, 0xCCCCCCCC, 0xF0F0F0F0, 0xFF00FF00, 0xFFFF0000 }; - unsigned * pTruth; - int i, k, nWords; - nWords = (nVars <= 5 ? 1 : (1 << (nVars - 5))); - p = Vec_PtrAllocSimInfo( nVars, nWords ); - for ( i = 0; i < nVars; i++ ) - { - pTruth = (unsigned *)p->pArray[i]; - if ( i < 5 ) - { - for ( k = 0; k < nWords; k++ ) - pTruth[k] = Masks[i]; - } - else - { - for ( k = 0; k < nWords; k++ ) - if ( k & (1 << (i-5)) ) - pTruth[k] = ~(unsigned)0; - else - pTruth[k] = 0; - } - } - return p; -} - -#endif - //////////////////////////////////////////////////////////////////////// /// END OF FILE /// //////////////////////////////////////////////////////////////////////// +#endif + diff --git a/src/misc/vec/vecStr.h b/src/misc/vec/vecStr.h index 47367bc6..311bda91 100644 --- a/src/misc/vec/vecStr.h +++ b/src/misc/vec/vecStr.h @@ -26,6 +26,7 @@ //////////////////////////////////////////////////////////////////////// #include <stdio.h> +#include "extra.h" //////////////////////////////////////////////////////////////////////// /// PARAMETERS /// @@ -44,14 +45,14 @@ struct Vec_Str_t_ }; //////////////////////////////////////////////////////////////////////// -/// MACRO DEFINITIONS /// +/// MACRO DEFITIONS /// //////////////////////////////////////////////////////////////////////// #define Vec_StrForEachEntry( vVec, Entry, i ) \ for ( i = 0; (i < Vec_StrSize(vVec)) && (((Entry) = Vec_StrEntry(vVec, i)), 1); i++ ) //////////////////////////////////////////////////////////////////////// -/// FUNCTION DEFINITIONS /// +/// FUNCTION DEFITIONS /// //////////////////////////////////////////////////////////////////////// /**Function************************************************************* @@ -302,7 +303,6 @@ static inline void Vec_StrWriteEntry( Vec_Str_t * p, int i, char Entry ) ***********************************************************************/ static inline char Vec_StrEntryLast( Vec_Str_t * p ) { - assert( p->nSize > 0 ); return p->pArray[p->nSize-1]; } @@ -401,80 +401,6 @@ static inline void Vec_StrPush( Vec_Str_t * p, char Entry ) p->pArray[p->nSize++] = Entry; } -/**Function******************************************************************** - - Synopsis [Finds the smallest integer larger of equal than the logarithm.] - - Description [Returns [Log10(Num)].] - - SideEffects [] - - SeeAlso [] - -******************************************************************************/ -static inline int Vec_StrBase10Log( unsigned Num ) -{ - int Res; - assert( Num >= 0 ); - if ( Num == 0 ) return 0; - if ( Num == 1 ) return 1; - for ( Res = 0, Num--; Num; Num /= 10, Res++ ); - return Res; -} /* end of Extra_Base2Log */ - -/**Function************************************************************* - - Synopsis [] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -static inline void Vec_StrPrintNum( Vec_Str_t * p, int Num ) -{ - int i, nDigits; - if ( Num < 0 ) - { - Vec_StrPush( p, '-' ); - Num = -Num; - } - if ( Num < 10 ) - { - Vec_StrPush( p, (char)('0' + Num) ); - return; - } - nDigits = Vec_StrBase10Log( Num ); - Vec_StrGrow( p, p->nSize + nDigits ); - for ( i = nDigits - 1; i >= 0; i-- ) - { - Vec_StrWriteEntry( p, p->nSize + i, (char)('0' + Num % 10) ); - Num /= 10; - } - assert( Num == 0 ); - p->nSize += nDigits; -} - -/**Function************************************************************* - - Synopsis [] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -static inline void Vec_StrPrintStr( Vec_Str_t * p, char * pStr ) -{ - int i, Length = strlen(pStr); - for ( i = 0; i < Length; i++ ) - Vec_StrPush( p, pStr[i] ); -} - /**Function************************************************************* Synopsis [Appends the string to the char vector.] @@ -568,16 +494,16 @@ static inline int Vec_StrSortCompare2( char * pp1, char * pp2 ) static inline void Vec_StrSort( Vec_Str_t * p, int fReverse ) { if ( fReverse ) - qsort( (void *)p->pArray, p->nSize, sizeof(char), + qsort( (void *)p->pArray, p->nSize, sizeof(int), (int (*)(const void *, const void *)) Vec_StrSortCompare2 ); else - qsort( (void *)p->pArray, p->nSize, sizeof(char), + qsort( (void *)p->pArray, p->nSize, sizeof(int), (int (*)(const void *, const void *)) Vec_StrSortCompare1 ); } -#endif - //////////////////////////////////////////////////////////////////////// /// END OF FILE /// //////////////////////////////////////////////////////////////////////// +#endif + diff --git a/src/misc/vec/vecVec.h b/src/misc/vec/vecVec.h index 55ffdf4f..0ad5fd1e 100644 --- a/src/misc/vec/vecVec.h +++ b/src/misc/vec/vecVec.h @@ -26,6 +26,7 @@ //////////////////////////////////////////////////////////////////////// #include <stdio.h> +#include "extra.h" //////////////////////////////////////////////////////////////////////// /// PARAMETERS /// @@ -44,27 +45,23 @@ struct Vec_Vec_t_ }; //////////////////////////////////////////////////////////////////////// -/// MACRO DEFINITIONS /// +/// MACRO DEFITIONS /// //////////////////////////////////////////////////////////////////////// // iterators through levels #define Vec_VecForEachLevel( vGlob, vVec, i ) \ - for ( i = 0; (i < Vec_VecSize(vGlob)) && (((vVec) = (Vec_Ptr_t*)Vec_VecEntry(vGlob, i)), 1); i++ ) + for ( i = 0; (i < Vec_VecSize(vGlob)) && (((vVec) = Vec_VecEntry(vGlob, i)), 1); i++ ) #define Vec_VecForEachLevelStart( vGlob, vVec, i, LevelStart ) \ - for ( i = LevelStart; (i < Vec_VecSize(vGlob)) && (((vVec) = (Vec_Ptr_t*)Vec_VecEntry(vGlob, i)), 1); i++ ) + for ( i = LevelStart; (i < Vec_VecSize(vGlob)) && (((vVec) = Vec_VecEntry(vGlob, i)), 1); i++ ) #define Vec_VecForEachLevelStartStop( vGlob, vVec, i, LevelStart, LevelStop ) \ - for ( i = LevelStart; (i <= LevelStop) && (((vVec) = (Vec_Ptr_t*)Vec_VecEntry(vGlob, i)), 1); i++ ) + for ( i = LevelStart; (i <= LevelStop) && (((vVec) = Vec_VecEntry(vGlob, i)), 1); i++ ) #define Vec_VecForEachLevelReverse( vGlob, vVec, i ) \ - for ( i = Vec_VecSize(vGlob) - 1; (i >= 0) && (((vVec) = (Vec_Ptr_t*)Vec_VecEntry(vGlob, i)), 1); i-- ) -#define Vec_VecForEachLevelReverseStartStop( vGlob, vVec, i, LevelStart, LevelStop ) \ - for ( i = LevelStart; (i >= LevelStop) && (((vVec) = (Vec_Ptr_t*)Vec_VecEntry(vGlob, i)), 1); i-- ) + for ( i = Vec_VecSize(vGlob) - 1; (i >= 0) && (((vVec) = Vec_VecEntry(vGlob, i)), 1); i-- ) // iteratores through entries #define Vec_VecForEachEntry( vGlob, pEntry, i, k ) \ for ( i = 0; i < Vec_VecSize(vGlob); i++ ) \ Vec_PtrForEachEntry( Vec_VecEntry(vGlob, i), pEntry, k ) -#define Vec_VecForEachEntryLevel( vGlob, pEntry, i, Level ) \ - Vec_PtrForEachEntry( Vec_VecEntry(vGlob, Level), pEntry, i ) #define Vec_VecForEachEntryStart( vGlob, pEntry, i, k, LevelStart ) \ for ( i = LevelStart; i < Vec_VecSize(vGlob); i++ ) \ Vec_PtrForEachEntry( Vec_VecEntry(vGlob, i), pEntry, k ) @@ -74,15 +71,9 @@ struct Vec_Vec_t_ #define Vec_VecForEachEntryReverse( vGlob, pEntry, i, k ) \ for ( i = 0; i < Vec_VecSize(vGlob); i++ ) \ Vec_PtrForEachEntryReverse( Vec_VecEntry(vGlob, i), pEntry, k ) -#define Vec_VecForEachEntryReverseReverse( vGlob, pEntry, i, k ) \ - for ( i = Vec_VecSize(vGlob) - 1; i >= 0; i-- ) \ - Vec_PtrForEachEntryReverse( Vec_VecEntry(vGlob, i), pEntry, k ) -#define Vec_VecForEachEntryReverseStart( vGlob, pEntry, i, k, LevelStart ) \ - for ( i = LevelStart; i >= 0; i-- ) \ - Vec_PtrForEachEntry( Vec_VecEntry(vGlob, i), pEntry, k ) //////////////////////////////////////////////////////////////////////// -/// FUNCTION DEFINITIONS /// +/// FUNCTION DEFITIONS /// //////////////////////////////////////////////////////////////////////// /**Function************************************************************* @@ -132,28 +123,6 @@ static inline Vec_Vec_t * Vec_VecStart( int nSize ) /**Function************************************************************* - Synopsis [Allocates a vector with the given capacity.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -static inline void Vec_VecExpand( Vec_Vec_t * p, int Level ) -{ - int i; - if ( p->nSize >= Level + 1 ) - return; - Vec_PtrGrow( (Vec_Ptr_t *)p, Level + 1 ); - for ( i = p->nSize; i <= Level; i++ ) - p->pArray[i] = Vec_PtrAlloc( 0 ); - p->nSize = Level + 1; -} - -/**Function************************************************************* - Synopsis [] Description [] @@ -265,7 +234,7 @@ static inline void Vec_VecPush( Vec_Vec_t * p, int Level, void * Entry ) p->pArray[i] = Vec_PtrAlloc( 0 ); p->nSize = Level + 1; } - Vec_PtrPush( (Vec_Ptr_t*)p->pArray[Level], Entry ); + Vec_PtrPush( p->pArray[Level], Entry ); } /**Function************************************************************* @@ -284,73 +253,12 @@ static inline void Vec_VecPushUnique( Vec_Vec_t * p, int Level, void * Entry ) if ( p->nSize < Level + 1 ) Vec_VecPush( p, Level, Entry ); else - Vec_PtrPushUnique( (Vec_Ptr_t*)p->pArray[Level], Entry ); -} - -/**Function************************************************************* - - Synopsis [Comparison procedure for two arrays.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -static inline int Vec_VecSortCompare1( Vec_Ptr_t ** pp1, Vec_Ptr_t ** pp2 ) -{ - if ( Vec_PtrSize(*pp1) < Vec_PtrSize(*pp2) ) - return -1; - if ( Vec_PtrSize(*pp1) > Vec_PtrSize(*pp2) ) - return 1; - return 0; -} - -/**Function************************************************************* - - Synopsis [Comparison procedure for two integers.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -static inline int Vec_VecSortCompare2( Vec_Ptr_t ** pp1, Vec_Ptr_t ** pp2 ) -{ - if ( Vec_PtrSize(*pp1) > Vec_PtrSize(*pp2) ) - return -1; - if ( Vec_PtrSize(*pp1) < Vec_PtrSize(*pp2) ) - return 1; - return 0; -} - -/**Function************************************************************* - - Synopsis [Sorting the entries by their integer value.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -static inline void Vec_VecSort( Vec_Vec_t * p, int fReverse ) -{ - if ( fReverse ) - qsort( (void *)p->pArray, p->nSize, sizeof(void *), - (int (*)(const void *, const void *)) Vec_VecSortCompare2 ); - else - qsort( (void *)p->pArray, p->nSize, sizeof(void *), - (int (*)(const void *, const void *)) Vec_VecSortCompare1 ); + Vec_PtrPushUnique( p->pArray[Level], Entry ); } -#endif - //////////////////////////////////////////////////////////////////////// /// END OF FILE /// //////////////////////////////////////////////////////////////////////// +#endif + |