abc-master
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros
vecWec.h
Go to the documentation of this file.
1 /**CFile****************************************************************
2 
3  FileName [vecWec.h]
4 
5  SystemName [ABC: Logic synthesis and verification system.]
6 
7  PackageName [Resizable arrays.]
8 
9  Synopsis [Resizable vector of resizable vectors.]
10 
11  Author [Alan Mishchenko]
12 
13  Affiliation [UC Berkeley]
14 
15  Date [Ver. 1.0. Started - June 20, 2005.]
16 
17  Revision [$Id: vecWec.h,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
18 
19 ***********************************************************************/
20 
21 #ifndef ABC__misc__vec__vecWec_h
22 #define ABC__misc__vec__vecWec_h
23 
24 
25 ////////////////////////////////////////////////////////////////////////
26 /// INCLUDES ///
27 ////////////////////////////////////////////////////////////////////////
28 
29 #include <stdio.h>
30 
31 ABC_NAMESPACE_HEADER_START
32 
33 
34 ////////////////////////////////////////////////////////////////////////
35 /// PARAMETERS ///
36 ////////////////////////////////////////////////////////////////////////
37 
38 ////////////////////////////////////////////////////////////////////////
39 /// BASIC TYPES ///
40 ////////////////////////////////////////////////////////////////////////
41 
42 typedef struct Vec_Wec_t_ Vec_Wec_t;
43 struct Vec_Wec_t_
44 {
45  int nCap;
46  int nSize;
47  Vec_Int_t * pArray;
48 };
49 
50 ////////////////////////////////////////////////////////////////////////
51 /// MACRO DEFINITIONS ///
52 ////////////////////////////////////////////////////////////////////////
53 
54 // iterators through levels
55 #define Vec_WecForEachLevel( vGlob, vVec, i ) \
56  for ( i = 0; (i < Vec_WecSize(vGlob)) && (((vVec) = Vec_WecEntry(vGlob, i)), 1); i++ )
57 #define Vec_WecForEachLevelVec( vLevels, vGlob, vVec, i ) \
58  for ( i = 0; (i < Vec_IntSize(vLevels)) && (((vVec) = Vec_WecEntry(vGlob, Vec_IntEntry(vLevels, i))), 1); i++ )
59 #define Vec_WecForEachLevelStart( vGlob, vVec, i, LevelStart ) \
60  for ( i = LevelStart; (i < Vec_WecSize(vGlob)) && (((vVec) = Vec_WecEntry(vGlob, i)), 1); i++ )
61 #define Vec_WecForEachLevelStop( vGlob, vVec, i, LevelStop ) \
62  for ( i = 0; (i < LevelStop) && (((vVec) = Vec_WecEntry(vGlob, i)), 1); i++ )
63 #define Vec_WecForEachLevelStartStop( vGlob, vVec, i, LevelStart, LevelStop ) \
64  for ( i = LevelStart; (i < LevelStop) && (((vVec) = Vec_WecEntry(vGlob, i)), 1); i++ )
65 #define Vec_WecForEachLevelReverse( vGlob, vVec, i ) \
66  for ( i = Vec_WecSize(vGlob)-1; (i >= 0) && (((vVec) = Vec_WecEntry(vGlob, i)), 1); i-- )
67 #define Vec_WecForEachLevelReverseStartStop( vGlob, vVec, i, LevelStart, LevelStop ) \
68  for ( i = LevelStart-1; (i >= LevelStop) && (((vVec) = Vec_WecEntry(vGlob, i)), 1); i-- )
69 #define Vec_WecForEachLevelTwo( vGlob1, vGlob2, vVec1, vVec2, i ) \
70  for ( i = 0; (i < Vec_WecSize(vGlob1)) && (((vVec1) = Vec_WecEntry(vGlob1, i)), 1) && (((vVec2) = Vec_WecEntry(vGlob2, i)), 1); i++ )
71 
72 ////////////////////////////////////////////////////////////////////////
73 /// FUNCTION DEFINITIONS ///
74 ////////////////////////////////////////////////////////////////////////
75 
76 /**Function*************************************************************
77 
78  Synopsis [Allocates a vector with the given capacity.]
79 
80  Description []
81 
82  SideEffects []
83 
84  SeeAlso []
85 
86 ***********************************************************************/
87 static inline Vec_Wec_t * Vec_WecAlloc( int nCap )
88 {
89  Vec_Wec_t * p;
90  p = ABC_ALLOC( Vec_Wec_t, 1 );
91  if ( nCap > 0 && nCap < 8 )
92  nCap = 8;
93  p->nSize = 0;
94  p->nCap = nCap;
95  p->pArray = p->nCap? ABC_CALLOC( Vec_Int_t, p->nCap ) : NULL;
96  return p;
97 }
98 static inline Vec_Wec_t * Vec_WecStart( int nSize )
99 {
100  Vec_Wec_t * p;
101  p = Vec_WecAlloc( nSize );
102  p->nSize = nSize;
103  return p;
104 }
105 
106 /**Function*************************************************************
107 
108  Synopsis [Resizes the vector to the given capacity.]
109 
110  Description []
111 
112  SideEffects []
113 
114  SeeAlso []
115 
116 ***********************************************************************/
117 static inline void Vec_WecGrow( Vec_Wec_t * p, int nCapMin )
118 {
119  if ( p->nCap >= nCapMin )
120  return;
121  p->pArray = ABC_REALLOC( Vec_Int_t, p->pArray, nCapMin );
122  memset( p->pArray + p->nCap, 0, sizeof(Vec_Int_t) * (nCapMin - p->nCap) );
123  p->nCap = nCapMin;
124 }
125 static inline void Vec_WecInit( Vec_Wec_t * p, int nSize )
126 {
127  Vec_WecGrow( p, nSize );
128  p->nSize = nSize;
129 }
130 
131 /**Function*************************************************************
132 
133  Synopsis []
134 
135  Description []
136 
137  SideEffects []
138 
139  SeeAlso []
140 
141 ***********************************************************************/
142 static inline Vec_Int_t * Vec_WecEntry( Vec_Wec_t * p, int i )
143 {
144  assert( i >= 0 && i < p->nSize );
145  return p->pArray + i;
146 }
147 static inline Vec_Int_t * Vec_WecEntryLast( Vec_Wec_t * p )
148 {
149  assert( p->nSize > 0 );
150  return p->pArray + p->nSize - 1;
151 }
152 static inline int Vec_WecEntryEntry( Vec_Wec_t * p, int i, int k )
153 {
154  return Vec_IntEntry( Vec_WecEntry(p, i), k );
155 }
156 
157 /**Function*************************************************************
158 
159  Synopsis []
160 
161  Description []
162 
163  SideEffects []
164 
165  SeeAlso []
166 
167 ***********************************************************************/
168 static inline Vec_Int_t * Vec_WecArray( Vec_Wec_t * p )
169 {
170  return p->pArray;
171 }
172 static inline int Vec_WecLevelId( Vec_Wec_t * p, Vec_Int_t * vLevel )
173 {
174  assert( p->pArray <= vLevel && vLevel < p->pArray + p->nSize );
175  return vLevel - p->pArray;
176 }
177 
178 /**Function*************************************************************
179 
180  Synopsis []
181 
182  Description []
183 
184  SideEffects []
185 
186  SeeAlso []
187 
188 ***********************************************************************/
189 static inline int Vec_WecCap( Vec_Wec_t * p )
190 {
191  return p->nCap;
192 }
193 static inline int Vec_WecSize( Vec_Wec_t * p )
194 {
195  return p->nSize;
196 }
197 static inline int Vec_WecLevelSize( Vec_Wec_t * p, int i )
198 {
199  assert( i >= 0 && i < p->nSize );
200  return Vec_IntSize( p->pArray + i );
201 }
202 static inline int Vec_WecSizeSize( Vec_Wec_t * p )
203 {
204  Vec_Int_t * vVec;
205  int i, Counter = 0;
206  Vec_WecForEachLevel( p, vVec, i )
207  Counter += Vec_IntSize(vVec);
208  return Counter;
209 }
210 static inline int Vec_WecSizeUsed( Vec_Wec_t * p )
211 {
212  Vec_Int_t * vVec;
213  int i, Counter = 0;
214  Vec_WecForEachLevel( p, vVec, i )
215  Counter += (int)(Vec_IntSize(vVec) > 0);
216  return Counter;
217 }
218 static inline int Vec_WecSizeUsedLimits( Vec_Wec_t * p, int iStart, int iStop )
219 {
220  Vec_Int_t * vVec;
221  int i, Counter = 0;
222  Vec_WecForEachLevelStartStop( p, vVec, i, iStart, iStop )
223  Counter += (int)(Vec_IntSize(vVec) > 0);
224  return Counter;
225 }
226 
227 /**Function*************************************************************
228 
229  Synopsis []
230 
231  Description []
232 
233  SideEffects []
234 
235  SeeAlso []
236 
237 ***********************************************************************/
238 static inline void Vec_WecShrink( Vec_Wec_t * p, int nSizeNew )
239 {
240  assert( p->nSize >= nSizeNew );
241  p->nSize = nSizeNew;
242 }
243 
244 /**Function*************************************************************
245 
246  Synopsis []
247 
248  Description []
249 
250  SideEffects []
251 
252  SeeAlso []
253 
254 ***********************************************************************/
255 static inline void Vec_WecClear( Vec_Wec_t * p )
256 {
257  Vec_Int_t * vVec;
258  int i;
259  Vec_WecForEachLevel( p, vVec, i )
260  Vec_IntClear( vVec );
261  p->nSize = 0;
262 }
263 
264 /**Function*************************************************************
265 
266  Synopsis []
267 
268  Description []
269 
270  SideEffects []
271 
272  SeeAlso []
273 
274 ***********************************************************************/
275 static inline void Vec_WecPush( Vec_Wec_t * p, int Level, int Entry )
276 {
277  if ( p->nSize < Level + 1 )
278  {
279  Vec_WecGrow( p, Abc_MaxInt(2*p->nCap, Level + 1) );
280  p->nSize = Level + 1;
281  }
282  Vec_IntPush( Vec_WecEntry(p, Level), Entry );
283 }
284 static inline Vec_Int_t * Vec_WecPushLevel( Vec_Wec_t * p )
285 {
286  if ( p->nSize == p->nCap )
287  {
288  if ( p->nCap < 16 )
289  Vec_WecGrow( p, 16 );
290  else
291  Vec_WecGrow( p, 2 * p->nCap );
292  }
293  ++p->nSize;
294  return Vec_WecEntryLast( p );
295 }
296 
297 /**Function*************************************************************
298 
299  Synopsis []
300 
301  Description []
302 
303  SideEffects []
304 
305  SeeAlso []
306 
307 ***********************************************************************/
308 static inline double Vec_WecMemory( Vec_Wec_t * p )
309 {
310  int i;
311  double Mem;
312  if ( p == NULL ) return 0.0;
313  Mem = sizeof(Vec_Int_t) * Vec_WecCap(p);
314  for ( i = 0; i < p->nSize; i++ )
315  Mem += sizeof(int) * Vec_IntCap( Vec_WecEntry(p, i) );
316  return Mem;
317 }
318 
319 /**Function*************************************************************
320 
321  Synopsis [Frees the vector.]
322 
323  Description []
324 
325  SideEffects []
326 
327  SeeAlso []
328 
329 ***********************************************************************/
330 static inline void Vec_WecZero( Vec_Wec_t * p )
331 {
332  p->pArray = NULL;
333  p->nSize = 0;
334  p->nCap = 0;
335 }
336 static inline void Vec_WecErase( Vec_Wec_t * p )
337 {
338  int i;
339  for ( i = 0; i < p->nCap; i++ )
340  ABC_FREE( p->pArray[i].pArray );
341  ABC_FREE( p->pArray );
342  p->nSize = 0;
343  p->nCap = 0;
344 }
345 static inline void Vec_WecFree( Vec_Wec_t * p )
346 {
347  Vec_WecErase( p );
348  ABC_FREE( p );
349 }
350 static inline void Vec_WecFreeP( Vec_Wec_t ** p )
351 {
352  if ( *p == NULL )
353  return;
354  Vec_WecFree( *p );
355  *p = NULL;
356 }
357 
358 /**Function*************************************************************
359 
360  Synopsis []
361 
362  Description []
363 
364  SideEffects []
365 
366  SeeAlso []
367 
368 ***********************************************************************/
369 static inline void Vec_WecPushUnique( Vec_Wec_t * p, int Level, int Entry )
370 {
371  if ( p->nSize < Level + 1 )
372  Vec_WecPush( p, Level, Entry );
373  else
374  Vec_IntPushUnique( Vec_WecEntry(p, Level), Entry );
375 }
376 
377 /**Function*************************************************************
378 
379  Synopsis [Frees the vector.]
380 
381  Description []
382 
383  SideEffects []
384 
385  SeeAlso []
386 
387 ***********************************************************************/
388 static inline Vec_Wec_t * Vec_WecDup( Vec_Wec_t * p )
389 {
390  Vec_Wec_t * vNew;
391  Vec_Int_t * vVec;
392  int i, k, Entry;
393  vNew = Vec_WecAlloc( Vec_WecSize(p) );
394  Vec_WecForEachLevel( p, vVec, i )
395  Vec_IntForEachEntry( vVec, Entry, k )
396  Vec_WecPush( vNew, i, Entry );
397  return vNew;
398 }
399 
400 /**Function*************************************************************
401 
402  Synopsis [Sorting by array size.]
403 
404  Description []
405 
406  SideEffects []
407 
408  SeeAlso []
409 
410 ***********************************************************************/
411 static int Vec_WecSortCompare1( Vec_Int_t * p1, Vec_Int_t * p2 )
412 {
413  if ( Vec_IntSize(p1) < Vec_IntSize(p2) )
414  return -1;
415  if ( Vec_IntSize(p1) > Vec_IntSize(p2) )
416  return 1;
417  return 0;
418 }
419 static int Vec_WecSortCompare2( Vec_Int_t * p1, Vec_Int_t * p2 )
420 {
421  if ( Vec_IntSize(p1) > Vec_IntSize(p2) )
422  return -1;
423  if ( Vec_IntSize(p1) < Vec_IntSize(p2) )
424  return 1;
425  return 0;
426 }
427 static inline void Vec_WecSort( Vec_Wec_t * p, int fReverse )
428 {
429  if ( fReverse )
430  qsort( (void *)p->pArray, p->nSize, sizeof(Vec_Int_t),
431  (int (*)(const void *, const void *)) Vec_WecSortCompare2 );
432  else
433  qsort( (void *)p->pArray, p->nSize, sizeof(Vec_Int_t),
434  (int (*)(const void *, const void *)) Vec_WecSortCompare1 );
435 }
436 
437 
438 /**Function*************************************************************
439 
440  Synopsis [Sorting by the first entry.]
441 
442  Description []
443 
444  SideEffects []
445 
446  SeeAlso []
447 
448 ***********************************************************************/
449 static int Vec_WecSortCompare3( Vec_Int_t * p1, Vec_Int_t * p2 )
450 {
451  if ( Vec_IntEntry(p1,0) < Vec_IntEntry(p2,0) )
452  return -1;
453  if ( Vec_IntEntry(p1,0) > Vec_IntEntry(p2,0) )
454  return 1;
455  return 0;
456 }
457 static int Vec_WecSortCompare4( Vec_Int_t * p1, Vec_Int_t * p2 )
458 {
459  if ( Vec_IntEntry(p1,0) > Vec_IntEntry(p2,0) )
460  return -1;
461  if ( Vec_IntEntry(p1,0) < Vec_IntEntry(p2,0) )
462  return 1;
463  return 0;
464 }
465 static inline void Vec_WecSortByFirstInt( Vec_Wec_t * p, int fReverse )
466 {
467  if ( fReverse )
468  qsort( (void *)p->pArray, p->nSize, sizeof(Vec_Int_t),
469  (int (*)(const void *, const void *)) Vec_WecSortCompare4 );
470  else
471  qsort( (void *)p->pArray, p->nSize, sizeof(Vec_Int_t),
472  (int (*)(const void *, const void *)) Vec_WecSortCompare3 );
473 }
474 
475 /**Function*************************************************************
476 
477  Synopsis [Sorting by the last entry.]
478 
479  Description []
480 
481  SideEffects []
482 
483  SeeAlso []
484 
485 ***********************************************************************/
486 static int Vec_WecSortCompare5( Vec_Int_t * p1, Vec_Int_t * p2 )
487 {
488  if ( Vec_IntEntryLast(p1) < Vec_IntEntryLast(p2) )
489  return -1;
490  if ( Vec_IntEntryLast(p1) > Vec_IntEntryLast(p2) )
491  return 1;
492  return 0;
493 }
494 static int Vec_WecSortCompare6( Vec_Int_t * p1, Vec_Int_t * p2 )
495 {
496  if ( Vec_IntEntryLast(p1) > Vec_IntEntryLast(p2) )
497  return -1;
498  if ( Vec_IntEntryLast(p1) < Vec_IntEntryLast(p2) )
499  return 1;
500  return 0;
501 }
502 static inline void Vec_WecSortByLastInt( Vec_Wec_t * p, int fReverse )
503 {
504  if ( fReverse )
505  qsort( (void *)p->pArray, p->nSize, sizeof(Vec_Int_t),
506  (int (*)(const void *, const void *)) Vec_WecSortCompare6 );
507  else
508  qsort( (void *)p->pArray, p->nSize, sizeof(Vec_Int_t),
509  (int (*)(const void *, const void *)) Vec_WecSortCompare5 );
510 }
511 
512 /**Function*************************************************************
513 
514  Synopsis []
515 
516  Description []
517 
518  SideEffects []
519 
520  SeeAlso []
521 
522 ***********************************************************************/
523 static inline void Vec_WecPrint( Vec_Wec_t * p, int fSkipSingles )
524 {
525  Vec_Int_t * vVec;
526  int i, k, Entry;
527  Vec_WecForEachLevel( p, vVec, i )
528  {
529  if ( fSkipSingles && Vec_IntSize(vVec) == 1 )
530  continue;
531  printf( " %4d : {", i );
532  Vec_IntForEachEntry( vVec, Entry, k )
533  printf( " %d", Entry );
534  printf( " }\n" );
535  }
536 }
537 
538 /**Function*************************************************************
539 
540  Synopsis [Derives the set of equivalence classes.]
541 
542  Description []
543 
544  SideEffects []
545 
546  SeeAlso []
547 
548 ***********************************************************************/
549 static inline Vec_Wec_t * Vec_WecCreateClasses( Vec_Int_t * vMap )
550 {
551  Vec_Wec_t * vClasses;
552  int i, Entry;
553  vClasses = Vec_WecStart( Vec_IntFindMax(vMap) + 1 );
554  Vec_IntForEachEntry( vMap, Entry, i )
555  Vec_WecPush( vClasses, Entry, i );
556  return vClasses;
557 }
558 
559 /**Function*************************************************************
560 
561  Synopsis []
562 
563  Description []
564 
565  SideEffects []
566 
567  SeeAlso []
568 
569 ***********************************************************************/
570 static inline int Vec_WecCountNonTrivial( Vec_Wec_t * p, int * pnUsed )
571 {
572  Vec_Int_t * vClass;
573  int i, nClasses = 0;
574  *pnUsed = 0;
575  Vec_WecForEachLevel( p, vClass, i )
576  {
577  if ( Vec_IntSize(vClass) < 2 )
578  continue;
579  nClasses++;
580  (*pnUsed) += Vec_IntSize(vClass);
581  }
582  return nClasses;
583 }
584 
585 /**Function*************************************************************
586 
587  Synopsis []
588 
589  Description []
590 
591  SideEffects []
592 
593  SeeAlso []
594 
595 ***********************************************************************/
596 static inline Vec_Int_t * Vec_WecCollectFirsts( Vec_Wec_t * p )
597 {
598  Vec_Int_t * vFirsts, * vLevel;
599  int i;
600  vFirsts = Vec_IntAlloc( Vec_WecSize(p) );
601  Vec_WecForEachLevel( p, vLevel, i )
602  if ( Vec_IntSize(vLevel) > 0 )
603  Vec_IntPush( vFirsts, Vec_IntEntry(vLevel, 0) );
604  return vFirsts;
605 }
606 
607 /**Function*************************************************************
608 
609  Synopsis []
610 
611  Description []
612 
613  SideEffects []
614 
615  SeeAlso []
616 
617 ***********************************************************************/
618 static inline Vec_Ptr_t * Vec_WecConvertToVecPtr( Vec_Wec_t * p )
619 {
620  Vec_Ptr_t * vCopy;
621  Vec_Int_t * vLevel;
622  int i;
623  vCopy = Vec_PtrAlloc( Vec_WecSize(p) );
624  Vec_WecForEachLevel( p, vLevel, i )
625  Vec_PtrPush( vCopy, Vec_IntDup(vLevel) );
626  return vCopy;
627 }
628 
629 
630 /**Function*************************************************************
631 
632  Synopsis [Temporary vector marking.]
633 
634  Description [The vector should be static when the marking is used.]
635 
636  SideEffects []
637 
638  SeeAlso []
639 
640 ***********************************************************************/
641 static inline int Vec_WecIntHasMark( Vec_Int_t * vVec ) { return (vVec->nCap >> 30) & 1; }
642 static inline void Vec_WecIntSetMark( Vec_Int_t * vVec ) { vVec->nCap |= (1<<30); }
643 static inline void Vec_WecIntXorMark( Vec_Int_t * vVec ) { vVec->nCap ^= (1<<30); }
644 static inline void Vec_WecMarkLevels( Vec_Wec_t * vCubes, Vec_Int_t * vLevels )
645 {
646  Vec_Int_t * vCube;
647  int i;
648  Vec_WecForEachLevelVec( vLevels, vCubes, vCube, i )
649  {
650  assert( !Vec_WecIntHasMark( vCube ) );
651  Vec_WecIntXorMark( vCube );
652  }
653 }
654 static inline void Vec_WecUnmarkLevels( Vec_Wec_t * vCubes, Vec_Int_t * vLevels )
655 {
656  Vec_Int_t * vCube;
657  int i;
658  Vec_WecForEachLevelVec( vLevels, vCubes, vCube, i )
659  {
660  assert( Vec_WecIntHasMark( vCube ) );
661  Vec_WecIntXorMark( vCube );
662  }
663 }
664 
665 /**Function*************************************************************
666 
667  Synopsis [Removes 0-size vectors.]
668 
669  Description []
670 
671  SideEffects []
672 
673  SeeAlso []
674 
675 ***********************************************************************/
676 static inline void Vec_WecRemoveEmpty( Vec_Wec_t * vCubes )
677 {
678  Vec_Int_t * vCube;
679  int i, k = 0;
680  Vec_WecForEachLevel( vCubes, vCube, i )
681  if ( Vec_IntSize(vCube) > 0 )
682  vCubes->pArray[k++] = *vCube;
683  else
684  ABC_FREE( vCube->pArray );
685  for ( i = k; i < Vec_WecSize(vCubes); i++ )
686  Vec_IntZero( Vec_WecEntry(vCubes, i) );
687  Vec_WecShrink( vCubes, k );
688 // Vec_WecSortByFirstInt( vCubes, 0 );
689 }
690 
691 
692 ABC_NAMESPACE_HEADER_END
693 
694 #endif
695 
696 ////////////////////////////////////////////////////////////////////////
697 /// END OF FILE ///
698 ////////////////////////////////////////////////////////////////////////
699 
memset
char * memset()
Vec_WecShrink
static void Vec_WecShrink(Vec_Wec_t *p, int nSizeNew)
Definition: vecWec.h:238
Vec_WecRemoveEmpty
static void Vec_WecRemoveEmpty(Vec_Wec_t *vCubes)
Definition: vecWec.h:676
Vec_WecSort
static void Vec_WecSort(Vec_Wec_t *p, int fReverse)
Definition: vecWec.h:427
Vec_Wec_t_
Definition: vecWec.h:43
Vec_Ptr_t
typedefABC_NAMESPACE_HEADER_START struct Vec_Ptr_t_ Vec_Ptr_t
INCLUDES ///.
Definition: vecPtr.h:42
Vec_WecLevelSize
static int Vec_WecLevelSize(Vec_Wec_t *p, int i)
Definition: vecWec.h:197
Vec_WecAlloc
static Vec_Wec_t * Vec_WecAlloc(int nCap)
FUNCTION DEFINITIONS ///.
Definition: vecWec.h:87
Vec_WecSortByLastInt
static void Vec_WecSortByLastInt(Vec_Wec_t *p, int fReverse)
Definition: vecWec.h:502
Vec_Wec_t
typedefABC_NAMESPACE_HEADER_START struct Vec_Wec_t_ Vec_Wec_t
INCLUDES ///.
Definition: vecWec.h:42
Vec_WecCollectFirsts
static Vec_Int_t * Vec_WecCollectFirsts(Vec_Wec_t *p)
Definition: vecWec.h:596
Vec_IntDup
static Vec_Int_t * Vec_IntDup(Vec_Int_t *pVec)
Definition: vecInt.h:214
Vec_Wec_t_::nSize
int nSize
Definition: vecWec.h:46
p
static Llb_Mgr_t * p
Definition: llb3Image.c:950
Vec_Int_t
typedefABC_NAMESPACE_IMPL_START struct Vec_Int_t_ Vec_Int_t
DECLARATIONS ///.
Definition: bblif.c:37
Vec_WecConvertToVecPtr
static Vec_Ptr_t * Vec_WecConvertToVecPtr(Vec_Wec_t *p)
Definition: vecWec.h:618
ABC_REALLOC
#define ABC_REALLOC(type, obj, num)
Definition: abc_global.h:233
Vec_WecFree
static void Vec_WecFree(Vec_Wec_t *p)
Definition: vecWec.h:345
Vec_WecMarkLevels
static void Vec_WecMarkLevels(Vec_Wec_t *vCubes, Vec_Int_t *vLevels)
Definition: vecWec.h:644
Vec_WecSortCompare6
static int Vec_WecSortCompare6(Vec_Int_t *p1, Vec_Int_t *p2)
Definition: vecWec.h:494
Vec_WecStart
static Vec_Wec_t * Vec_WecStart(int nSize)
Definition: vecWec.h:98
Vec_WecMemory
static double Vec_WecMemory(Vec_Wec_t *p)
Definition: vecWec.h:308
Vec_WecPushLevel
static Vec_Int_t * Vec_WecPushLevel(Vec_Wec_t *p)
Definition: vecWec.h:284
Vec_WecUnmarkLevels
static void Vec_WecUnmarkLevels(Vec_Wec_t *vCubes, Vec_Int_t *vLevels)
Definition: vecWec.h:654
Vec_WecSortCompare2
static int Vec_WecSortCompare2(Vec_Int_t *p1, Vec_Int_t *p2)
Definition: vecWec.h:419
Vec_PtrPush
static void Vec_PtrPush(Vec_Ptr_t *p, void *Entry)
Definition: vecPtr.h:606
ABC_ALLOC
#define ABC_ALLOC(type, num)
Definition: abc_global.h:229
Vec_WecSizeUsed
static int Vec_WecSizeUsed(Vec_Wec_t *p)
Definition: vecWec.h:210
Abc_MaxInt
static int Abc_MaxInt(int a, int b)
Definition: abc_global.h:238
Vec_WecSize
static int Vec_WecSize(Vec_Wec_t *p)
Definition: vecWec.h:193
Vec_WecCap
static int Vec_WecCap(Vec_Wec_t *p)
Definition: vecWec.h:189
Vec_Wec_t_::nCap
int nCap
Definition: vecWec.h:45
Vec_WecZero
static void Vec_WecZero(Vec_Wec_t *p)
Definition: vecWec.h:330
Vec_WecClear
static void Vec_WecClear(Vec_Wec_t *p)
Definition: vecWec.h:255
Vec_WecForEachLevelStartStop
#define Vec_WecForEachLevelStartStop(vGlob, vVec, i, LevelStart, LevelStop)
Definition: vecWec.h:63
Vec_IntZero
static void Vec_IntZero(Vec_Int_t *p)
Definition: vecInt.h:260
Vec_WecForEachLevel
#define Vec_WecForEachLevel(vGlob, vVec, i)
MACRO DEFINITIONS ///.
Definition: vecWec.h:55
Vec_IntAlloc
static Vec_Int_t * Vec_IntAlloc(int nCap)
FUNCTION DEFINITIONS ///.
Definition: bblif.c:149
Vec_WecErase
static void Vec_WecErase(Vec_Wec_t *p)
Definition: vecWec.h:336
Vec_IntEntry
static int Vec_IntEntry(Vec_Int_t *p, int i)
Definition: bblif.c:268
Vec_IntFindMax
static int Vec_IntFindMax(Vec_Int_t *p)
Definition: vecInt.h:996
Vec_WecEntryEntry
static int Vec_WecEntryEntry(Vec_Wec_t *p, int i, int k)
Definition: vecWec.h:152
Vec_IntPush
static void Vec_IntPush(Vec_Int_t *p, int Entry)
Definition: bblif.c:468
Counter
static int Counter
Definition: extraBddMisc.c:1877
ABC_NAMESPACE_HEADER_START
#define ABC_NAMESPACE_HEADER_START
NAMESPACES ///.
Definition: abc_global.h:105
Vec_WecDup
static Vec_Wec_t * Vec_WecDup(Vec_Wec_t *p)
Definition: vecWec.h:388
Vec_IntCap
static int Vec_IntCap(Vec_Int_t *p)
Definition: vecInt.h:368
Vec_WecPrint
static void Vec_WecPrint(Vec_Wec_t *p, int fSkipSingles)
Definition: vecWec.h:523
Vec_WecIntSetMark
static void Vec_WecIntSetMark(Vec_Int_t *vVec)
Definition: vecWec.h:642
ABC_NAMESPACE_HEADER_END
#define ABC_NAMESPACE_HEADER_END
Definition: abc_global.h:106
Vec_WecSortCompare4
static int Vec_WecSortCompare4(Vec_Int_t *p1, Vec_Int_t *p2)
Definition: vecWec.h:457
Vec_WecArray
static Vec_Int_t * Vec_WecArray(Vec_Wec_t *p)
Definition: vecWec.h:168
Vec_WecForEachLevelVec
#define Vec_WecForEachLevelVec(vLevels, vGlob, vVec, i)
Definition: vecWec.h:57
Vec_WecEntry
static Vec_Int_t * Vec_WecEntry(Vec_Wec_t *p, int i)
Definition: vecWec.h:142
Vec_IntEntryLast
static int Vec_IntEntryLast(Vec_Int_t *p)
Definition: bblif.c:319
Vec_WecSortCompare3
static int Vec_WecSortCompare3(Vec_Int_t *p1, Vec_Int_t *p2)
Definition: vecWec.h:449
Vec_IntSize
static int Vec_IntSize(Vec_Int_t *p)
Definition: bblif.c:252
Vec_PtrAlloc
static Vec_Ptr_t * Vec_PtrAlloc(int nCap)
FUNCTION DEFINITIONS ///.
Definition: vecPtr.h:83
Vec_WecEntryLast
static Vec_Int_t * Vec_WecEntryLast(Vec_Wec_t *p)
Definition: vecWec.h:147
Vec_WecPushUnique
static void Vec_WecPushUnique(Vec_Wec_t *p, int Level, int Entry)
Definition: vecWec.h:369
ABC_FREE
#define ABC_FREE(obj)
Definition: abc_global.h:232
Vec_WecLevelId
static int Vec_WecLevelId(Vec_Wec_t *p, Vec_Int_t *vLevel)
Definition: vecWec.h:172
Vec_WecIntXorMark
static void Vec_WecIntXorMark(Vec_Int_t *vVec)
Definition: vecWec.h:643
Vec_WecIntHasMark
static int Vec_WecIntHasMark(Vec_Int_t *vVec)
Definition: vecWec.h:641
Vec_WecGrow
static void Vec_WecGrow(Vec_Wec_t *p, int nCapMin)
Definition: vecWec.h:117
ABC_CALLOC
#define ABC_CALLOC(type, num)
Definition: abc_global.h:230
Vec_WecFreeP
static void Vec_WecFreeP(Vec_Wec_t **p)
Definition: vecWec.h:350
assert
#define assert(ex)
Definition: util_old.h:213
Vec_WecSortCompare5
static int Vec_WecSortCompare5(Vec_Int_t *p1, Vec_Int_t *p2)
Definition: vecWec.h:486
Vec_WecCountNonTrivial
static int Vec_WecCountNonTrivial(Vec_Wec_t *p, int *pnUsed)
Definition: vecWec.h:570
Vec_IntPushUnique
static int Vec_IntPushUnique(Vec_Int_t *p, int Entry)
Definition: vecInt.h:832
Vec_IntClear
static void Vec_IntClear(Vec_Int_t *p)
Definition: bblif.c:452
Vec_Wec_t_::pArray
Vec_Int_t * pArray
Definition: vecWec.h:47
Vec_IntForEachEntry
#define Vec_IntForEachEntry(vVec, Entry, i)
MACRO DEFINITIONS ///.
Definition: vecInt.h:54
Vec_WecSortByFirstInt
static void Vec_WecSortByFirstInt(Vec_Wec_t *p, int fReverse)
Definition: vecWec.h:465
Vec_WecSizeUsedLimits
static int Vec_WecSizeUsedLimits(Vec_Wec_t *p, int iStart, int iStop)
Definition: vecWec.h:218
Vec_WecSortCompare1
static int Vec_WecSortCompare1(Vec_Int_t *p1, Vec_Int_t *p2)
Definition: vecWec.h:411
Vec_WecCreateClasses
static Vec_Wec_t * Vec_WecCreateClasses(Vec_Int_t *vMap)
Definition: vecWec.h:549
Vec_WecSizeSize
static int Vec_WecSizeSize(Vec_Wec_t *p)
Definition: vecWec.h:202
Vec_WecInit
static void Vec_WecInit(Vec_Wec_t *p, int nSize)
Definition: vecWec.h:125
Vec_WecPush
static void Vec_WecPush(Vec_Wec_t *p, int Level, int Entry)
Definition: vecWec.h:275