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