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 #define Vec_WecForEachLevelDouble( vGlob, vVec1, vVec2, i ) \
72 for ( i = 0; (i < Vec_WecSize(vGlob)) && (((vVec1) = Vec_WecEntry(vGlob, i)), 1) && (((vVec2) = Vec_WecEntry(vGlob, i+1)), 1); i += 2 )
73
74 ////////////////////////////////////////////////////////////////////////
75 /// FUNCTION DEFINITIONS ///
76 ////////////////////////////////////////////////////////////////////////
77
78 /**Function*************************************************************
79
80 Synopsis [Allocates a vector with the given capacity.]
81
82 Description []
83
84 SideEffects []
85
86 SeeAlso []
87
88 ***********************************************************************/
Vec_WecAlloc(int nCap)89 static inline Vec_Wec_t * Vec_WecAlloc( int nCap )
90 {
91 Vec_Wec_t * p;
92 p = ABC_ALLOC( Vec_Wec_t, 1 );
93 if ( nCap > 0 && nCap < 8 )
94 nCap = 8;
95 p->nSize = 0;
96 p->nCap = nCap;
97 p->pArray = p->nCap? ABC_CALLOC( Vec_Int_t, p->nCap ) : NULL;
98 return p;
99 }
Vec_WecAllocExact(int nCap)100 static inline Vec_Wec_t * Vec_WecAllocExact( int nCap )
101 {
102 Vec_Wec_t * p;
103 assert( nCap >= 0 );
104 p = ABC_ALLOC( Vec_Wec_t, 1 );
105 p->nSize = 0;
106 p->nCap = nCap;
107 p->pArray = p->nCap? ABC_CALLOC( Vec_Int_t, p->nCap ) : NULL;
108 return p;
109 }
Vec_WecStart(int nSize)110 static inline Vec_Wec_t * Vec_WecStart( int nSize )
111 {
112 Vec_Wec_t * p;
113 p = Vec_WecAlloc( nSize );
114 p->nSize = nSize;
115 return p;
116 }
117
118 /**Function*************************************************************
119
120 Synopsis [Resizes the vector to the given capacity.]
121
122 Description []
123
124 SideEffects []
125
126 SeeAlso []
127
128 ***********************************************************************/
Vec_WecGrow(Vec_Wec_t * p,int nCapMin)129 static inline void Vec_WecGrow( Vec_Wec_t * p, int nCapMin )
130 {
131 if ( p->nCap >= nCapMin )
132 return;
133 p->pArray = ABC_REALLOC( Vec_Int_t, p->pArray, nCapMin );
134 memset( p->pArray + p->nCap, 0, sizeof(Vec_Int_t) * (size_t)(nCapMin - p->nCap) );
135 p->nCap = nCapMin;
136 }
Vec_WecInit(Vec_Wec_t * p,int nSize)137 static inline void Vec_WecInit( Vec_Wec_t * p, int nSize )
138 {
139 Vec_WecGrow( p, nSize );
140 p->nSize = nSize;
141 }
142
143 /**Function*************************************************************
144
145 Synopsis []
146
147 Description []
148
149 SideEffects []
150
151 SeeAlso []
152
153 ***********************************************************************/
Vec_WecEntry(Vec_Wec_t * p,int i)154 static inline Vec_Int_t * Vec_WecEntry( Vec_Wec_t * p, int i )
155 {
156 assert( i >= 0 && i < p->nSize );
157 return p->pArray + i;
158 }
Vec_WecEntryLast(Vec_Wec_t * p)159 static inline Vec_Int_t * Vec_WecEntryLast( Vec_Wec_t * p )
160 {
161 assert( p->nSize > 0 );
162 return p->pArray + p->nSize - 1;
163 }
Vec_WecEntryEntry(Vec_Wec_t * p,int i,int k)164 static inline int Vec_WecEntryEntry( Vec_Wec_t * p, int i, int k )
165 {
166 return Vec_IntEntry( Vec_WecEntry(p, i), k );
167 }
168
169 /**Function*************************************************************
170
171 Synopsis []
172
173 Description []
174
175 SideEffects []
176
177 SeeAlso []
178
179 ***********************************************************************/
Vec_WecArray(Vec_Wec_t * p)180 static inline Vec_Int_t * Vec_WecArray( Vec_Wec_t * p )
181 {
182 return p->pArray;
183 }
Vec_WecLevelId(Vec_Wec_t * p,Vec_Int_t * vLevel)184 static inline int Vec_WecLevelId( Vec_Wec_t * p, Vec_Int_t * vLevel )
185 {
186 assert( p->pArray <= vLevel && vLevel < p->pArray + p->nSize );
187 return vLevel - p->pArray;
188 }
189
190 /**Function*************************************************************
191
192 Synopsis []
193
194 Description []
195
196 SideEffects []
197
198 SeeAlso []
199
200 ***********************************************************************/
Vec_WecCap(Vec_Wec_t * p)201 static inline int Vec_WecCap( Vec_Wec_t * p )
202 {
203 return p->nCap;
204 }
Vec_WecSize(Vec_Wec_t * p)205 static inline int Vec_WecSize( Vec_Wec_t * p )
206 {
207 return p->nSize;
208 }
Vec_WecLevelSize(Vec_Wec_t * p,int i)209 static inline int Vec_WecLevelSize( Vec_Wec_t * p, int i )
210 {
211 assert( i >= 0 && i < p->nSize );
212 return Vec_IntSize( p->pArray + i );
213 }
Vec_WecSizeSize(Vec_Wec_t * p)214 static inline int Vec_WecSizeSize( Vec_Wec_t * p )
215 {
216 Vec_Int_t * vVec;
217 int i, Counter = 0;
218 Vec_WecForEachLevel( p, vVec, i )
219 Counter += Vec_IntSize(vVec);
220 return Counter;
221 }
Vec_WecSizeUsed(Vec_Wec_t * p)222 static inline int Vec_WecSizeUsed( Vec_Wec_t * p )
223 {
224 Vec_Int_t * vVec;
225 int i, Counter = 0;
226 Vec_WecForEachLevel( p, vVec, i )
227 Counter += (int)(Vec_IntSize(vVec) > 0);
228 return Counter;
229 }
Vec_WecSizeUsedLimits(Vec_Wec_t * p,int iStart,int iStop)230 static inline int Vec_WecSizeUsedLimits( Vec_Wec_t * p, int iStart, int iStop )
231 {
232 Vec_Int_t * vVec;
233 int i, Counter = 0;
234 Vec_WecForEachLevelStartStop( p, vVec, i, iStart, iStop )
235 Counter += (int)(Vec_IntSize(vVec) > 0);
236 return Counter;
237 }
238
239 /**Function*************************************************************
240
241 Synopsis []
242
243 Description []
244
245 SideEffects []
246
247 SeeAlso []
248
249 ***********************************************************************/
Vec_WecShrink(Vec_Wec_t * p,int nSizeNew)250 static inline void Vec_WecShrink( Vec_Wec_t * p, int nSizeNew )
251 {
252 Vec_Int_t * vVec; int i;
253 Vec_WecForEachLevelStart( p, vVec, i, nSizeNew )
254 Vec_IntShrink( vVec, 0 );
255 assert( p->nSize >= nSizeNew );
256 p->nSize = nSizeNew;
257 }
258
259 /**Function*************************************************************
260
261 Synopsis []
262
263 Description []
264
265 SideEffects []
266
267 SeeAlso []
268
269 ***********************************************************************/
Vec_WecClear(Vec_Wec_t * p)270 static inline void Vec_WecClear( Vec_Wec_t * p )
271 {
272 Vec_Int_t * vVec;
273 int i;
274 Vec_WecForEachLevel( p, vVec, i )
275 Vec_IntClear( vVec );
276 p->nSize = 0;
277 }
278
279 /**Function*************************************************************
280
281 Synopsis []
282
283 Description []
284
285 SideEffects []
286
287 SeeAlso []
288
289 ***********************************************************************/
Vec_WecPush(Vec_Wec_t * p,int Level,int Entry)290 static inline void Vec_WecPush( Vec_Wec_t * p, int Level, int Entry )
291 {
292 if ( p->nSize < Level + 1 )
293 {
294 Vec_WecGrow( p, Abc_MaxInt(2*p->nSize, Level + 1) );
295 p->nSize = Level + 1;
296 }
297 Vec_IntPush( Vec_WecEntry(p, Level), Entry );
298 }
Vec_WecPushLevel(Vec_Wec_t * p)299 static inline Vec_Int_t * Vec_WecPushLevel( Vec_Wec_t * p )
300 {
301 if ( p->nSize == p->nCap )
302 {
303 if ( p->nCap < 16 )
304 Vec_WecGrow( p, 16 );
305 else
306 Vec_WecGrow( p, 2 * p->nCap );
307 }
308 ++p->nSize;
309 return Vec_WecEntryLast( p );
310 }
Vec_WecInsertLevel(Vec_Wec_t * p,int i)311 static inline Vec_Int_t * Vec_WecInsertLevel( Vec_Wec_t * p, int i )
312 {
313 Vec_Int_t * pTemp;
314 if ( p->nSize == p->nCap )
315 {
316 if ( p->nCap < 16 )
317 Vec_WecGrow( p, 16 );
318 else
319 Vec_WecGrow( p, 2 * p->nCap );
320 }
321 ++p->nSize;
322 assert( i >= 0 && i < p->nSize );
323 for ( pTemp = p->pArray + p->nSize - 2; pTemp >= p->pArray + i; pTemp-- )
324 pTemp[1] = pTemp[0];
325 Vec_IntZero( p->pArray + i );
326 return p->pArray + i;
327 }
328
329 /**Function*************************************************************
330
331 Synopsis []
332
333 Description []
334
335 SideEffects []
336
337 SeeAlso []
338
339 ***********************************************************************/
Vec_WecMemory(Vec_Wec_t * p)340 static inline double Vec_WecMemory( Vec_Wec_t * p )
341 {
342 int i;
343 double Mem;
344 if ( p == NULL ) return 0.0;
345 Mem = sizeof(Vec_Int_t) * Vec_WecCap(p);
346 for ( i = 0; i < p->nSize; i++ )
347 Mem += sizeof(int) * (size_t)Vec_IntCap( Vec_WecEntry(p, i) );
348 return Mem;
349 }
350
351 /**Function*************************************************************
352
353 Synopsis [Frees the vector.]
354
355 Description []
356
357 SideEffects []
358
359 SeeAlso []
360
361 ***********************************************************************/
Vec_WecZero(Vec_Wec_t * p)362 static inline void Vec_WecZero( Vec_Wec_t * p )
363 {
364 p->pArray = NULL;
365 p->nSize = 0;
366 p->nCap = 0;
367 }
Vec_WecErase(Vec_Wec_t * p)368 static inline void Vec_WecErase( Vec_Wec_t * p )
369 {
370 int i;
371 for ( i = 0; i < p->nCap; i++ )
372 ABC_FREE( p->pArray[i].pArray );
373 ABC_FREE( p->pArray );
374 p->nSize = 0;
375 p->nCap = 0;
376 }
Vec_WecFree(Vec_Wec_t * p)377 static inline void Vec_WecFree( Vec_Wec_t * p )
378 {
379 Vec_WecErase( p );
380 ABC_FREE( p );
381 }
Vec_WecFreeP(Vec_Wec_t ** p)382 static inline void Vec_WecFreeP( Vec_Wec_t ** p )
383 {
384 if ( *p == NULL )
385 return;
386 Vec_WecFree( *p );
387 *p = NULL;
388 }
389
390 /**Function*************************************************************
391
392 Synopsis []
393
394 Description []
395
396 SideEffects []
397
398 SeeAlso []
399
400 ***********************************************************************/
Vec_WecPushUnique(Vec_Wec_t * p,int Level,int Entry)401 static inline void Vec_WecPushUnique( Vec_Wec_t * p, int Level, int Entry )
402 {
403 if ( p->nSize < Level + 1 )
404 Vec_WecPush( p, Level, Entry );
405 else
406 Vec_IntPushUnique( Vec_WecEntry(p, Level), Entry );
407 }
408
409 /**Function*************************************************************
410
411 Synopsis [Frees the vector.]
412
413 Description []
414
415 SideEffects []
416
417 SeeAlso []
418
419 ***********************************************************************/
Vec_WecDup(Vec_Wec_t * p)420 static inline Vec_Wec_t * Vec_WecDup( Vec_Wec_t * p )
421 {
422 Vec_Wec_t * vNew;
423 Vec_Int_t * vVec;
424 int i, k, Entry;
425 vNew = Vec_WecAlloc( Vec_WecSize(p) );
426 Vec_WecForEachLevel( p, vVec, i )
427 Vec_IntForEachEntry( vVec, Entry, k )
428 Vec_WecPush( vNew, i, Entry );
429 return vNew;
430 }
431
432 /**Function*************************************************************
433
434 Synopsis [Sorting by array size.]
435
436 Description []
437
438 SideEffects []
439
440 SeeAlso []
441
442 ***********************************************************************/
Vec_WecSortCompare1(Vec_Int_t * p1,Vec_Int_t * p2)443 static int Vec_WecSortCompare1( Vec_Int_t * p1, Vec_Int_t * p2 )
444 {
445 if ( Vec_IntSize(p1) < Vec_IntSize(p2) )
446 return -1;
447 if ( Vec_IntSize(p1) > Vec_IntSize(p2) )
448 return 1;
449 return 0;
450 }
Vec_WecSortCompare2(Vec_Int_t * p1,Vec_Int_t * p2)451 static int Vec_WecSortCompare2( Vec_Int_t * p1, Vec_Int_t * p2 )
452 {
453 if ( Vec_IntSize(p1) > Vec_IntSize(p2) )
454 return -1;
455 if ( Vec_IntSize(p1) < Vec_IntSize(p2) )
456 return 1;
457 return 0;
458 }
Vec_WecSort(Vec_Wec_t * p,int fReverse)459 static inline void Vec_WecSort( Vec_Wec_t * p, int fReverse )
460 {
461 if ( fReverse )
462 qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(Vec_Int_t),
463 (int (*)(const void *, const void *)) Vec_WecSortCompare2 );
464 else
465 qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(Vec_Int_t),
466 (int (*)(const void *, const void *)) Vec_WecSortCompare1 );
467 }
468
469
470 /**Function*************************************************************
471
472 Synopsis [Sorting by the first entry.]
473
474 Description []
475
476 SideEffects []
477
478 SeeAlso []
479
480 ***********************************************************************/
Vec_WecSortCompare3(Vec_Int_t * p1,Vec_Int_t * p2)481 static int Vec_WecSortCompare3( Vec_Int_t * p1, Vec_Int_t * p2 )
482 {
483 if ( Vec_IntEntry(p1,0) < Vec_IntEntry(p2,0) )
484 return -1;
485 if ( Vec_IntEntry(p1,0) > Vec_IntEntry(p2,0) )
486 return 1;
487 return 0;
488 }
Vec_WecSortCompare4(Vec_Int_t * p1,Vec_Int_t * p2)489 static int Vec_WecSortCompare4( Vec_Int_t * p1, Vec_Int_t * p2 )
490 {
491 if ( Vec_IntEntry(p1,0) > Vec_IntEntry(p2,0) )
492 return -1;
493 if ( Vec_IntEntry(p1,0) < Vec_IntEntry(p2,0) )
494 return 1;
495 return 0;
496 }
Vec_WecSortByFirstInt(Vec_Wec_t * p,int fReverse)497 static inline void Vec_WecSortByFirstInt( Vec_Wec_t * p, int fReverse )
498 {
499 if ( fReverse )
500 qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(Vec_Int_t),
501 (int (*)(const void *, const void *)) Vec_WecSortCompare4 );
502 else
503 qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(Vec_Int_t),
504 (int (*)(const void *, const void *)) Vec_WecSortCompare3 );
505 }
506
507 /**Function*************************************************************
508
509 Synopsis [Sorting by the last entry.]
510
511 Description []
512
513 SideEffects []
514
515 SeeAlso []
516
517 ***********************************************************************/
Vec_WecSortCompare5(Vec_Int_t * p1,Vec_Int_t * p2)518 static int Vec_WecSortCompare5( Vec_Int_t * p1, Vec_Int_t * p2 )
519 {
520 if ( Vec_IntEntryLast(p1) < Vec_IntEntryLast(p2) )
521 return -1;
522 if ( Vec_IntEntryLast(p1) > Vec_IntEntryLast(p2) )
523 return 1;
524 return 0;
525 }
Vec_WecSortCompare6(Vec_Int_t * p1,Vec_Int_t * p2)526 static int Vec_WecSortCompare6( Vec_Int_t * p1, Vec_Int_t * p2 )
527 {
528 if ( Vec_IntEntryLast(p1) > Vec_IntEntryLast(p2) )
529 return -1;
530 if ( Vec_IntEntryLast(p1) < Vec_IntEntryLast(p2) )
531 return 1;
532 return 0;
533 }
Vec_WecSortByLastInt(Vec_Wec_t * p,int fReverse)534 static inline void Vec_WecSortByLastInt( Vec_Wec_t * p, int fReverse )
535 {
536 if ( fReverse )
537 qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(Vec_Int_t),
538 (int (*)(const void *, const void *)) Vec_WecSortCompare6 );
539 else
540 qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(Vec_Int_t),
541 (int (*)(const void *, const void *)) Vec_WecSortCompare5 );
542 }
543
544 /**Function*************************************************************
545
546 Synopsis []
547
548 Description []
549
550 SideEffects []
551
552 SeeAlso []
553
554 ***********************************************************************/
Vec_WecPrint(Vec_Wec_t * p,int fSkipSingles)555 static inline void Vec_WecPrint( Vec_Wec_t * p, int fSkipSingles )
556 {
557 Vec_Int_t * vVec;
558 int i, k, Entry;
559 Vec_WecForEachLevel( p, vVec, i )
560 {
561 if ( fSkipSingles && Vec_IntSize(vVec) == 1 )
562 continue;
563 printf( " %4d : {", i );
564 Vec_IntForEachEntry( vVec, Entry, k )
565 printf( " %d", Entry );
566 printf( " }\n" );
567 }
568 }
Vec_WecPrintLits(Vec_Wec_t * p)569 static inline void Vec_WecPrintLits( Vec_Wec_t * p )
570 {
571 Vec_Int_t * vVec;
572 int i, k, iLit;
573 Vec_WecForEachLevel( p, vVec, i )
574 {
575 printf( " %4d : %2d {", i, Vec_IntSize(vVec) );
576 Vec_IntForEachEntry( vVec, iLit, k )
577 printf( " %c%d", Abc_LitIsCompl(iLit) ? '-' : '+', Abc_Lit2Var(iLit) );
578 printf( " }\n" );
579 }
580 }
581
582 /**Function*************************************************************
583
584 Synopsis [Derives the set of equivalence classes.]
585
586 Description []
587
588 SideEffects []
589
590 SeeAlso []
591
592 ***********************************************************************/
Vec_WecCreateClasses(Vec_Int_t * vMap)593 static inline Vec_Wec_t * Vec_WecCreateClasses( Vec_Int_t * vMap )
594 {
595 Vec_Wec_t * vClasses;
596 int i, Entry;
597 vClasses = Vec_WecStart( Vec_IntFindMax(vMap) + 1 );
598 Vec_IntForEachEntry( vMap, Entry, i )
599 Vec_WecPush( vClasses, Entry, i );
600 return vClasses;
601 }
602
603 /**Function*************************************************************
604
605 Synopsis []
606
607 Description []
608
609 SideEffects []
610
611 SeeAlso []
612
613 ***********************************************************************/
Vec_WecCountNonTrivial(Vec_Wec_t * p,int * pnUsed)614 static inline int Vec_WecCountNonTrivial( Vec_Wec_t * p, int * pnUsed )
615 {
616 Vec_Int_t * vClass;
617 int i, nClasses = 0;
618 *pnUsed = 0;
619 Vec_WecForEachLevel( p, vClass, i )
620 {
621 if ( Vec_IntSize(vClass) < 2 )
622 continue;
623 nClasses++;
624 (*pnUsed) += Vec_IntSize(vClass);
625 }
626 return nClasses;
627 }
628
629 /**Function*************************************************************
630
631 Synopsis []
632
633 Description []
634
635 SideEffects []
636
637 SeeAlso []
638
639 ***********************************************************************/
Vec_WecCollectFirsts(Vec_Wec_t * p)640 static inline Vec_Int_t * Vec_WecCollectFirsts( Vec_Wec_t * p )
641 {
642 Vec_Int_t * vFirsts, * vLevel;
643 int i;
644 vFirsts = Vec_IntAlloc( Vec_WecSize(p) );
645 Vec_WecForEachLevel( p, vLevel, i )
646 if ( Vec_IntSize(vLevel) > 0 )
647 Vec_IntPush( vFirsts, Vec_IntEntry(vLevel, 0) );
648 return vFirsts;
649 }
650
651 /**Function*************************************************************
652
653 Synopsis []
654
655 Description []
656
657 SideEffects []
658
659 SeeAlso []
660
661 ***********************************************************************/
Vec_WecConvertToVecPtr(Vec_Wec_t * p)662 static inline Vec_Ptr_t * Vec_WecConvertToVecPtr( Vec_Wec_t * p )
663 {
664 Vec_Ptr_t * vCopy;
665 Vec_Int_t * vLevel;
666 int i;
667 vCopy = Vec_PtrAlloc( Vec_WecSize(p) );
668 Vec_WecForEachLevel( p, vLevel, i )
669 Vec_PtrPush( vCopy, Vec_IntDup(vLevel) );
670 return vCopy;
671 }
672
673
674 /**Function*************************************************************
675
676 Synopsis [Temporary vector marking.]
677
678 Description [The vector should be static when the marking is used.]
679
680 SideEffects []
681
682 SeeAlso []
683
684 ***********************************************************************/
Vec_WecIntHasMark(Vec_Int_t * vVec)685 static inline int Vec_WecIntHasMark( Vec_Int_t * vVec ) { return (vVec->nCap >> 30) & 1; }
Vec_WecIntSetMark(Vec_Int_t * vVec)686 static inline void Vec_WecIntSetMark( Vec_Int_t * vVec ) { vVec->nCap |= (1<<30); }
Vec_WecIntXorMark(Vec_Int_t * vVec)687 static inline void Vec_WecIntXorMark( Vec_Int_t * vVec ) { vVec->nCap ^= (1<<30); }
Vec_WecMarkLevels(Vec_Wec_t * vCubes,Vec_Int_t * vLevels)688 static inline void Vec_WecMarkLevels( Vec_Wec_t * vCubes, Vec_Int_t * vLevels )
689 {
690 Vec_Int_t * vCube;
691 int i;
692 Vec_WecForEachLevelVec( vLevels, vCubes, vCube, i )
693 {
694 assert( !Vec_WecIntHasMark( vCube ) );
695 Vec_WecIntXorMark( vCube );
696 }
697 }
Vec_WecUnmarkLevels(Vec_Wec_t * vCubes,Vec_Int_t * vLevels)698 static inline void Vec_WecUnmarkLevels( Vec_Wec_t * vCubes, Vec_Int_t * vLevels )
699 {
700 Vec_Int_t * vCube;
701 int i;
702 Vec_WecForEachLevelVec( vLevels, vCubes, vCube, i )
703 {
704 assert( Vec_WecIntHasMark( vCube ) );
705 Vec_WecIntXorMark( vCube );
706 }
707 }
708
709 /**Function*************************************************************
710
711 Synopsis [Removes 0-size vectors.]
712
713 Description []
714
715 SideEffects []
716
717 SeeAlso []
718
719 ***********************************************************************/
Vec_WecRemoveEmpty(Vec_Wec_t * vCubes)720 static inline void Vec_WecRemoveEmpty( Vec_Wec_t * vCubes )
721 {
722 Vec_Int_t * vCube;
723 int i, k = 0;
724 Vec_WecForEachLevel( vCubes, vCube, i )
725 if ( Vec_IntSize(vCube) > 0 )
726 vCubes->pArray[k++] = *vCube;
727 else
728 ABC_FREE( vCube->pArray );
729 for ( i = k; i < Vec_WecSize(vCubes); i++ )
730 Vec_IntZero( Vec_WecEntry(vCubes, i) );
731 Vec_WecShrink( vCubes, k );
732 // Vec_WecSortByFirstInt( vCubes, 0 );
733 }
734
735
736 ABC_NAMESPACE_HEADER_END
737
738 #endif
739
740 ////////////////////////////////////////////////////////////////////////
741 /// END OF FILE ///
742 ////////////////////////////////////////////////////////////////////////
743
744