1 /**CFile****************************************************************
2
3 FileName [vecFlt.h]
4
5 SystemName [ABC: Logic synthesis and verification system.]
6
7 PackageName [Resizable arrays.]
8
9 Synopsis [Resizable arrays of floats.]
10
11 Author [Aaron P. Hurst]
12
13 Affiliation [UC Berkeley]
14
15 Date [Ver. 1.0. Started - June 20, 2005.]
16
17 Revision [$Id: vecInt.h,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
18
19 ***********************************************************************/
20
21 #ifndef ABC__misc__vec__vecFlt_h
22 #define ABC__misc__vec__vecFlt_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_Flt_t_ Vec_Flt_t;
43 struct Vec_Flt_t_
44 {
45 int nCap;
46 int nSize;
47 float * pArray;
48 };
49
50 ////////////////////////////////////////////////////////////////////////
51 /// MACRO DEFINITIONS ///
52 ////////////////////////////////////////////////////////////////////////
53
54 #define Vec_FltForEachEntry( vVec, Entry, i ) \
55 for ( i = 0; (i < Vec_FltSize(vVec)) && (((Entry) = Vec_FltEntry(vVec, i)), 1); i++ )
56 #define Vec_FltForEachEntryStart( vVec, Entry, i, Start ) \
57 for ( i = Start; (i < Vec_FltSize(vVec)) && (((Entry) = Vec_FltEntry(vVec, i)), 1); i++ )
58 #define Vec_FltForEachEntryStartStop( vVec, Entry, i, Start, Stop ) \
59 for ( i = Start; (i < Stop) && (((Entry) = Vec_FltEntry(vVec, i)), 1); i++ )
60 #define Vec_FltForEachEntryReverse( vVec, pEntry, i ) \
61 for ( i = Vec_FltSize(vVec) - 1; (i >= 0) && (((pEntry) = Vec_FltEntry(vVec, i)), 1); i-- )
62
63 ////////////////////////////////////////////////////////////////////////
64 /// FUNCTION DEFINITIONS ///
65 ////////////////////////////////////////////////////////////////////////
66
67 /**Function*************************************************************
68
69 Synopsis [Allocates a vector with the given capacity.]
70
71 Description []
72
73 SideEffects []
74
75 SeeAlso []
76
77 ***********************************************************************/
Vec_FltAlloc(int nCap)78 static inline Vec_Flt_t * Vec_FltAlloc( int nCap )
79 {
80 Vec_Flt_t * p;
81 p = ABC_ALLOC( Vec_Flt_t, 1 );
82 if ( nCap > 0 && nCap < 16 )
83 nCap = 16;
84 p->nSize = 0;
85 p->nCap = nCap;
86 p->pArray = p->nCap? ABC_ALLOC( float, p->nCap ) : NULL;
87 return p;
88 }
Vec_FltAllocExact(int nCap)89 static inline Vec_Flt_t * Vec_FltAllocExact( int nCap )
90 {
91 Vec_Flt_t * p;
92 assert( nCap >= 0 );
93 p = ABC_ALLOC( Vec_Flt_t, 1 );
94 p->nSize = 0;
95 p->nCap = nCap;
96 p->pArray = p->nCap? ABC_ALLOC( float, p->nCap ) : NULL;
97 return p;
98 }
99
100 /**Function*************************************************************
101
102 Synopsis [Allocates a vector with the given size and cleans it.]
103
104 Description []
105
106 SideEffects []
107
108 SeeAlso []
109
110 ***********************************************************************/
Vec_FltStart(int nSize)111 static inline Vec_Flt_t * Vec_FltStart( int nSize )
112 {
113 Vec_Flt_t * p;
114 p = Vec_FltAlloc( nSize );
115 p->nSize = nSize;
116 memset( p->pArray, 0, sizeof(float) * (size_t)nSize );
117 return p;
118 }
Vec_FltStartFull(int nSize)119 static inline Vec_Flt_t * Vec_FltStartFull( int nSize )
120 {
121 Vec_Flt_t * p;
122 p = Vec_FltAlloc( nSize );
123 p->nSize = nSize;
124 memset( p->pArray, 0xFF, sizeof(float) * (size_t)nSize );
125 return p;
126 }
127
128 /**Function*************************************************************
129
130 Synopsis [Creates the vector from a float array of the given size.]
131
132 Description []
133
134 SideEffects []
135
136 SeeAlso []
137
138 ***********************************************************************/
Vec_FltAllocArray(float * pArray,int nSize)139 static inline Vec_Flt_t * Vec_FltAllocArray( float * pArray, int nSize )
140 {
141 Vec_Flt_t * p;
142 p = ABC_ALLOC( Vec_Flt_t, 1 );
143 p->nSize = nSize;
144 p->nCap = nSize;
145 p->pArray = pArray;
146 return p;
147 }
148
149 /**Function*************************************************************
150
151 Synopsis [Creates the vector from a float array of the given size.]
152
153 Description []
154
155 SideEffects []
156
157 SeeAlso []
158
159 ***********************************************************************/
Vec_FltAllocArrayCopy(float * pArray,int nSize)160 static inline Vec_Flt_t * Vec_FltAllocArrayCopy( float * pArray, int nSize )
161 {
162 Vec_Flt_t * p;
163 p = ABC_ALLOC( Vec_Flt_t, 1 );
164 p->nSize = nSize;
165 p->nCap = nSize;
166 p->pArray = ABC_ALLOC( float, nSize );
167 memcpy( p->pArray, pArray, sizeof(float) * (size_t)nSize );
168 return p;
169 }
170
171 /**Function*************************************************************
172
173 Synopsis [Duplicates the float array.]
174
175 Description []
176
177 SideEffects []
178
179 SeeAlso []
180
181 ***********************************************************************/
Vec_FltDup(Vec_Flt_t * pVec)182 static inline Vec_Flt_t * Vec_FltDup( Vec_Flt_t * pVec )
183 {
184 Vec_Flt_t * p;
185 p = ABC_ALLOC( Vec_Flt_t, 1 );
186 p->nSize = pVec->nSize;
187 p->nCap = pVec->nCap;
188 p->pArray = p->nCap? ABC_ALLOC( float, p->nCap ) : NULL;
189 memcpy( p->pArray, pVec->pArray, sizeof(float) * (size_t)pVec->nSize );
190 return p;
191 }
192
193 /**Function*************************************************************
194
195 Synopsis [Transfers the array into another vector.]
196
197 Description []
198
199 SideEffects []
200
201 SeeAlso []
202
203 ***********************************************************************/
Vec_FltDupArray(Vec_Flt_t * pVec)204 static inline Vec_Flt_t * Vec_FltDupArray( Vec_Flt_t * pVec )
205 {
206 Vec_Flt_t * p;
207 p = ABC_ALLOC( Vec_Flt_t, 1 );
208 p->nSize = pVec->nSize;
209 p->nCap = pVec->nCap;
210 p->pArray = pVec->pArray;
211 pVec->nSize = 0;
212 pVec->nCap = 0;
213 pVec->pArray = NULL;
214 return p;
215 }
216
217 /**Function*************************************************************
218
219 Synopsis []
220
221 Description []
222
223 SideEffects []
224
225 SeeAlso []
226
227 ***********************************************************************/
Vec_FltZero(Vec_Flt_t * p)228 static inline void Vec_FltZero( Vec_Flt_t * p )
229 {
230 p->pArray = NULL;
231 p->nSize = 0;
232 p->nCap = 0;
233 }
Vec_FltErase(Vec_Flt_t * p)234 static inline void Vec_FltErase( Vec_Flt_t * p )
235 {
236 ABC_FREE( p->pArray );
237 p->nSize = 0;
238 p->nCap = 0;
239 }
Vec_FltFree(Vec_Flt_t * p)240 static inline void Vec_FltFree( Vec_Flt_t * p )
241 {
242 ABC_FREE( p->pArray );
243 ABC_FREE( p );
244 }
245
246 /**Function*************************************************************
247
248 Synopsis []
249
250 Description []
251
252 SideEffects []
253
254 SeeAlso []
255
256 ***********************************************************************/
Vec_FltFreeP(Vec_Flt_t ** p)257 static inline void Vec_FltFreeP( Vec_Flt_t ** p )
258 {
259 if ( *p == NULL )
260 return;
261 ABC_FREE( (*p)->pArray );
262 ABC_FREE( (*p) );
263 }
264
265 /**Function*************************************************************
266
267 Synopsis []
268
269 Description []
270
271 SideEffects []
272
273 SeeAlso []
274
275 ***********************************************************************/
Vec_FltReleaseArray(Vec_Flt_t * p)276 static inline float * Vec_FltReleaseArray( Vec_Flt_t * p )
277 {
278 float * pArray = p->pArray;
279 p->nCap = 0;
280 p->nSize = 0;
281 p->pArray = NULL;
282 return pArray;
283 }
284
285 /**Function*************************************************************
286
287 Synopsis []
288
289 Description []
290
291 SideEffects []
292
293 SeeAlso []
294
295 ***********************************************************************/
Vec_FltArray(Vec_Flt_t * p)296 static inline float * Vec_FltArray( Vec_Flt_t * p )
297 {
298 return p->pArray;
299 }
Vec_FltArrayP(Vec_Flt_t * p)300 static inline float ** Vec_FltArrayP( Vec_Flt_t * p )
301 {
302 return &p->pArray;
303 }
304
305 /**Function*************************************************************
306
307 Synopsis []
308
309 Description []
310
311 SideEffects []
312
313 SeeAlso []
314
315 ***********************************************************************/
Vec_FltSize(Vec_Flt_t * p)316 static inline int Vec_FltSize( Vec_Flt_t * p )
317 {
318 return p->nSize;
319 }
320
321 /**Function*************************************************************
322
323 Synopsis []
324
325 Description []
326
327 SideEffects []
328
329 SeeAlso []
330
331 ***********************************************************************/
Vec_FltCap(Vec_Flt_t * p)332 static inline int Vec_FltCap( Vec_Flt_t * p )
333 {
334 return p->nCap;
335 }
336
337 /**Function*************************************************************
338
339 Synopsis []
340
341 Description []
342
343 SideEffects []
344
345 SeeAlso []
346
347 ***********************************************************************/
Vec_FltMemory(Vec_Flt_t * p)348 static inline double Vec_FltMemory( Vec_Flt_t * p )
349 {
350 return !p ? 0.0 : 1.0 * sizeof(float) * (size_t)p->nCap + sizeof(Vec_Flt_t);
351 }
352
353 /**Function*************************************************************
354
355 Synopsis []
356
357 Description []
358
359 SideEffects []
360
361 SeeAlso []
362
363 ***********************************************************************/
Vec_FltEntry(Vec_Flt_t * p,int i)364 static inline float Vec_FltEntry( Vec_Flt_t * p, int i )
365 {
366 assert( i >= 0 && i < p->nSize );
367 return p->pArray[i];
368 }
Vec_FltEntryP(Vec_Flt_t * p,int i)369 static inline float * Vec_FltEntryP( Vec_Flt_t * p, int i )
370 {
371 assert( i >= 0 && i < p->nSize );
372 return p->pArray + i;
373 }
374
375 /**Function*************************************************************
376
377 Synopsis []
378
379 Description []
380
381 SideEffects []
382
383 SeeAlso []
384
385 ***********************************************************************/
Vec_FltWriteEntry(Vec_Flt_t * p,int i,float Entry)386 static inline void Vec_FltWriteEntry( Vec_Flt_t * p, int i, float Entry )
387 {
388 assert( i >= 0 && i < p->nSize );
389 p->pArray[i] = Entry;
390 }
391
392 /**Function*************************************************************
393
394 Synopsis []
395
396 Description []
397
398 SideEffects []
399
400 SeeAlso []
401
402 ***********************************************************************/
Vec_FltAddToEntry(Vec_Flt_t * p,int i,float Addition)403 static inline void Vec_FltAddToEntry( Vec_Flt_t * p, int i, float Addition )
404 {
405 assert( i >= 0 && i < p->nSize );
406 p->pArray[i] += Addition;
407 }
408
409 /**Function*************************************************************
410
411 Synopsis []
412
413 Description []
414
415 SideEffects []
416
417 SeeAlso []
418
419 ***********************************************************************/
Vec_FltUpdateEntry(Vec_Flt_t * p,int i,float Value)420 static inline void Vec_FltUpdateEntry( Vec_Flt_t * p, int i, float Value )
421 {
422 if ( Vec_FltEntry( p, i ) < Value )
423 Vec_FltWriteEntry( p, i, Value );
424 }
425
426 /**Function*************************************************************
427
428 Synopsis []
429
430 Description []
431
432 SideEffects []
433
434 SeeAlso []
435
436 ***********************************************************************/
Vec_FltEntryLast(Vec_Flt_t * p)437 static inline float Vec_FltEntryLast( Vec_Flt_t * p )
438 {
439 return p->pArray[p->nSize-1];
440 }
441
442 /**Function*************************************************************
443
444 Synopsis [Resizes the vector to the given capacity.]
445
446 Description []
447
448 SideEffects []
449
450 SeeAlso []
451
452 ***********************************************************************/
Vec_FltGrow(Vec_Flt_t * p,int nCapMin)453 static inline void Vec_FltGrow( Vec_Flt_t * p, int nCapMin )
454 {
455 if ( p->nCap >= nCapMin )
456 return;
457 p->pArray = ABC_REALLOC( float, p->pArray, nCapMin );
458 p->nCap = nCapMin;
459 }
460
461 /**Function*************************************************************
462
463 Synopsis [Fills the vector with given number of entries.]
464
465 Description []
466
467 SideEffects []
468
469 SeeAlso []
470
471 ***********************************************************************/
Vec_FltFill(Vec_Flt_t * p,int nSize,float Entry)472 static inline void Vec_FltFill( Vec_Flt_t * p, int nSize, float Entry )
473 {
474 int i;
475 Vec_FltGrow( p, nSize );
476 for ( i = 0; i < nSize; i++ )
477 p->pArray[i] = Entry;
478 p->nSize = nSize;
479 }
480
481 /**Function*************************************************************
482
483 Synopsis [Fills the vector with given number of entries.]
484
485 Description []
486
487 SideEffects []
488
489 SeeAlso []
490
491 ***********************************************************************/
Vec_FltFillExtra(Vec_Flt_t * p,int nSize,float Fill)492 static inline void Vec_FltFillExtra( Vec_Flt_t * p, int nSize, float Fill )
493 {
494 int i;
495 if ( nSize <= p->nSize )
496 return;
497 if ( nSize > 2 * p->nCap )
498 Vec_FltGrow( p, nSize );
499 else if ( nSize > p->nCap )
500 Vec_FltGrow( p, 2 * p->nCap );
501 for ( i = p->nSize; i < nSize; i++ )
502 p->pArray[i] = Fill;
503 p->nSize = nSize;
504 }
505
506 /**Function*************************************************************
507
508 Synopsis []
509
510 Description []
511
512 SideEffects []
513
514 SeeAlso []
515
516 ***********************************************************************/
Vec_FltShrink(Vec_Flt_t * p,int nSizeNew)517 static inline void Vec_FltShrink( Vec_Flt_t * p, int nSizeNew )
518 {
519 assert( p->nSize >= nSizeNew );
520 p->nSize = nSizeNew;
521 }
522
523 /**Function*************************************************************
524
525 Synopsis []
526
527 Description []
528
529 SideEffects []
530
531 SeeAlso []
532
533 ***********************************************************************/
Vec_FltClear(Vec_Flt_t * p)534 static inline void Vec_FltClear( Vec_Flt_t * p )
535 {
536 p->nSize = 0;
537 }
538
539 /**Function*************************************************************
540
541 Synopsis []
542
543 Description []
544
545 SideEffects []
546
547 SeeAlso []
548
549 ***********************************************************************/
Vec_FltPush(Vec_Flt_t * p,float Entry)550 static inline void Vec_FltPush( Vec_Flt_t * p, float Entry )
551 {
552 if ( p->nSize == p->nCap )
553 {
554 if ( p->nCap < 16 )
555 Vec_FltGrow( p, 16 );
556 else
557 Vec_FltGrow( p, 2 * p->nCap );
558 }
559 p->pArray[p->nSize++] = Entry;
560 }
561
562 /**Function*************************************************************
563
564 Synopsis []
565
566 Description []
567
568 SideEffects []
569
570 SeeAlso []
571
572 ***********************************************************************/
Vec_FltPushOrder(Vec_Flt_t * p,float Entry)573 static inline void Vec_FltPushOrder( Vec_Flt_t * p, float Entry )
574 {
575 int i;
576 if ( p->nSize == p->nCap )
577 {
578 if ( p->nCap < 16 )
579 Vec_FltGrow( p, 16 );
580 else
581 Vec_FltGrow( p, 2 * p->nCap );
582 }
583 p->nSize++;
584 for ( i = p->nSize-2; i >= 0; i-- )
585 if ( p->pArray[i] > Entry )
586 p->pArray[i+1] = p->pArray[i];
587 else
588 break;
589 p->pArray[i+1] = Entry;
590 }
591
592 /**Function*************************************************************
593
594 Synopsis []
595
596 Description []
597
598 SideEffects []
599
600 SeeAlso []
601
602 ***********************************************************************/
Vec_FltPushUnique(Vec_Flt_t * p,float Entry)603 static inline int Vec_FltPushUnique( Vec_Flt_t * p, float Entry )
604 {
605 int i;
606 for ( i = 0; i < p->nSize; i++ )
607 if ( p->pArray[i] == Entry )
608 return 1;
609 Vec_FltPush( p, Entry );
610 return 0;
611 }
612
613 /**Function*************************************************************
614
615 Synopsis [Returns the last entry and removes it from the list.]
616
617 Description []
618
619 SideEffects []
620
621 SeeAlso []
622
623 ***********************************************************************/
Vec_FltPop(Vec_Flt_t * p)624 static inline float Vec_FltPop( Vec_Flt_t * p )
625 {
626 assert( p->nSize > 0 );
627 return p->pArray[--p->nSize];
628 }
629
630 /**Function*************************************************************
631
632 Synopsis [Find entry.]
633
634 Description []
635
636 SideEffects []
637
638 SeeAlso []
639
640 ***********************************************************************/
Vec_FltFind(Vec_Flt_t * p,float Entry)641 static inline int Vec_FltFind( Vec_Flt_t * p, float Entry )
642 {
643 int i;
644 for ( i = 0; i < p->nSize; i++ )
645 if ( p->pArray[i] == Entry )
646 return i;
647 return -1;
648 }
649
650 /**Function*************************************************************
651
652 Synopsis []
653
654 Description []
655
656 SideEffects []
657
658 SeeAlso []
659
660 ***********************************************************************/
Vec_FltRemove(Vec_Flt_t * p,float Entry)661 static inline int Vec_FltRemove( Vec_Flt_t * p, float Entry )
662 {
663 int i;
664 for ( i = 0; i < p->nSize; i++ )
665 if ( p->pArray[i] == Entry )
666 break;
667 if ( i == p->nSize )
668 return 0;
669 assert( i < p->nSize );
670 for ( i++; i < p->nSize; i++ )
671 p->pArray[i-1] = p->pArray[i];
672 p->nSize--;
673 return 1;
674 }
675
676 /**Function*************************************************************
677
678 Synopsis [Find entry.]
679
680 Description []
681
682 SideEffects []
683
684 SeeAlso []
685
686 ***********************************************************************/
Vec_FltFindMax(Vec_Flt_t * p)687 static inline float Vec_FltFindMax( Vec_Flt_t * p )
688 {
689 int i;
690 float Best;
691 if ( p->nSize == 0 )
692 return 0;
693 Best = p->pArray[0];
694 for ( i = 1; i < p->nSize; i++ )
695 if ( Best < p->pArray[i] )
696 Best = p->pArray[i];
697 return Best;
698 }
Vec_FltFindMin(Vec_Flt_t * p)699 static inline float Vec_FltFindMin( Vec_Flt_t * p )
700 {
701 int i;
702 float Best;
703 if ( p->nSize == 0 )
704 return 0;
705 Best = p->pArray[0];
706 for ( i = 1; i < p->nSize; i++ )
707 if ( Best > p->pArray[i] )
708 Best = p->pArray[i];
709 return Best;
710 }
711
712 /**Function*************************************************************
713
714 Synopsis [Checks if two vectors are equal.]
715
716 Description []
717
718 SideEffects []
719
720 SeeAlso []
721
722 ***********************************************************************/
Vec_FltEqual(Vec_Flt_t * p1,Vec_Flt_t * p2)723 static inline int Vec_FltEqual( Vec_Flt_t * p1, Vec_Flt_t * p2 )
724 {
725 int i;
726 if ( p1->nSize != p2->nSize )
727 return 0;
728 for ( i = 0; i < p1->nSize; i++ )
729 if ( p1->pArray[i] != p2->pArray[i] )
730 return 0;
731 return 1;
732 }
733
734 /**Function*************************************************************
735
736 Synopsis []
737
738 Description []
739
740 SideEffects []
741
742 SeeAlso []
743
744 ***********************************************************************/
Vec_FltPrint(Vec_Flt_t * vVec)745 static inline void Vec_FltPrint( Vec_Flt_t * vVec )
746 {
747 int i; float Entry;
748 printf( "Vector has %d entries: {", Vec_FltSize(vVec) );
749 Vec_FltForEachEntry( vVec, Entry, i )
750 printf( " %f", Entry );
751 printf( " }\n" );
752 }
753
754 /**Function*************************************************************
755
756 Synopsis [Comparison procedure for two floats.]
757
758 Description []
759
760 SideEffects []
761
762 SeeAlso []
763
764 ***********************************************************************/
Vec_FltSortCompare1(float * pp1,float * pp2)765 static int Vec_FltSortCompare1( float * pp1, float * pp2 )
766 {
767 // for some reason commenting out lines (as shown) led to crashing of the release version
768 if ( *pp1 < *pp2 )
769 return -1;
770 if ( *pp1 > *pp2 ) //
771 return 1;
772 return 0; //
773 }
774
775 /**Function*************************************************************
776
777 Synopsis [Comparison procedure for two floats.]
778
779 Description []
780
781 SideEffects []
782
783 SeeAlso []
784
785 ***********************************************************************/
Vec_FltSortCompare2(float * pp1,float * pp2)786 static int Vec_FltSortCompare2( float * pp1, float * pp2 )
787 {
788 // for some reason commenting out lines (as shown) led to crashing of the release version
789 if ( *pp1 > *pp2 )
790 return -1;
791 if ( *pp1 < *pp2 ) //
792 return 1;
793 return 0; //
794 }
795
796 /**Function*************************************************************
797
798 Synopsis [Sorting the entries by their value.]
799
800 Description []
801
802 SideEffects []
803
804 SeeAlso []
805
806 ***********************************************************************/
Vec_FltSort(Vec_Flt_t * p,int fReverse)807 static inline void Vec_FltSort( Vec_Flt_t * p, int fReverse )
808 {
809 if ( fReverse )
810 qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(float),
811 (int (*)(const void *, const void *)) Vec_FltSortCompare2 );
812 else
813 qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(float),
814 (int (*)(const void *, const void *)) Vec_FltSortCompare1 );
815 }
816
817 ////////////////////////////////////////////////////////////////////////
818 /// END OF FILE ///
819 ////////////////////////////////////////////////////////////////////////
820
821
822
823 ABC_NAMESPACE_HEADER_END
824
825 #endif
826
827