00001
00021 #ifndef __VEC_FLT_H__
00022 #define __VEC_FLT_H__
00023
00027
00028 #include <stdio.h>
00029
00033
00037
00038 typedef struct Vec_Flt_t_ Vec_Flt_t;
00039 struct Vec_Flt_t_
00040 {
00041 int nCap;
00042 int nSize;
00043 float * pArray;
00044 };
00045
00049
00050 #define Vec_FltForEachEntry( vVec, Entry, i ) \
00051 for ( i = 0; (i < Vec_FltSize(vVec)) && (((Entry) = Vec_FltEntry(vVec, i)), 1); i++ )
00052 #define Vec_FltForEachEntryStart( vVec, Entry, i, Start ) \
00053 for ( i = Start; (i < Vec_FltSize(vVec)) && (((Entry) = Vec_FltEntry(vVec, i)), 1); i++ )
00054 #define Vec_FltForEachEntryStartStop( vVec, Entry, i, Start, Stop ) \
00055 for ( i = Start; (i < Stop) && (((Entry) = Vec_FltEntry(vVec, i)), 1); i++ )
00056 #define Vec_FltForEachEntryReverse( vVec, pEntry, i ) \
00057 for ( i = Vec_FltSize(vVec) - 1; (i >= 0) && (((pEntry) = Vec_FltEntry(vVec, i)), 1); i-- )
00058
00062
00074 static inline Vec_Flt_t * Vec_FltAlloc( int nCap )
00075 {
00076 Vec_Flt_t * p;
00077 p = ALLOC( Vec_Flt_t, 1 );
00078 if ( nCap > 0 && nCap < 16 )
00079 nCap = 16;
00080 p->nSize = 0;
00081 p->nCap = nCap;
00082 p->pArray = p->nCap? ALLOC( float, p->nCap ) : NULL;
00083 return p;
00084 }
00085
00097 static inline Vec_Flt_t * Vec_FltStart( int nSize )
00098 {
00099 Vec_Flt_t * p;
00100 p = Vec_FltAlloc( nSize );
00101 p->nSize = nSize;
00102 memset( p->pArray, 0, sizeof(float) * nSize );
00103 return p;
00104 }
00105
00117 static inline Vec_Flt_t * Vec_FltAllocArray( float * pArray, int nSize )
00118 {
00119 Vec_Flt_t * p;
00120 p = ALLOC( Vec_Flt_t, 1 );
00121 p->nSize = nSize;
00122 p->nCap = nSize;
00123 p->pArray = pArray;
00124 return p;
00125 }
00126
00138 static inline Vec_Flt_t * Vec_FltAllocArrayCopy( float * pArray, int nSize )
00139 {
00140 Vec_Flt_t * p;
00141 p = ALLOC( Vec_Flt_t, 1 );
00142 p->nSize = nSize;
00143 p->nCap = nSize;
00144 p->pArray = ALLOC( float, nSize );
00145 memcpy( p->pArray, pArray, sizeof(float) * nSize );
00146 return p;
00147 }
00148
00160 static inline Vec_Flt_t * Vec_FltDup( Vec_Flt_t * pVec )
00161 {
00162 Vec_Flt_t * p;
00163 p = ALLOC( Vec_Flt_t, 1 );
00164 p->nSize = pVec->nSize;
00165 p->nCap = pVec->nCap;
00166 p->pArray = p->nCap? ALLOC( float, p->nCap ) : NULL;
00167 memcpy( p->pArray, pVec->pArray, sizeof(float) * pVec->nSize );
00168 return p;
00169 }
00170
00182 static inline Vec_Flt_t * Vec_FltDupArray( Vec_Flt_t * pVec )
00183 {
00184 Vec_Flt_t * p;
00185 p = ALLOC( Vec_Flt_t, 1 );
00186 p->nSize = pVec->nSize;
00187 p->nCap = pVec->nCap;
00188 p->pArray = pVec->pArray;
00189 pVec->nSize = 0;
00190 pVec->nCap = 0;
00191 pVec->pArray = NULL;
00192 return p;
00193 }
00194
00206 static inline void Vec_FltFree( Vec_Flt_t * p )
00207 {
00208 FREE( p->pArray );
00209 FREE( p );
00210 }
00211
00223 static inline float * Vec_FltReleaseArray( Vec_Flt_t * p )
00224 {
00225 float * pArray = p->pArray;
00226 p->nCap = 0;
00227 p->nSize = 0;
00228 p->pArray = NULL;
00229 return pArray;
00230 }
00231
00243 static inline float * Vec_FltArray( Vec_Flt_t * p )
00244 {
00245 return p->pArray;
00246 }
00247
00259 static inline int Vec_FltSize( Vec_Flt_t * p )
00260 {
00261 return p->nSize;
00262 }
00263
00275 static inline float Vec_FltEntry( Vec_Flt_t * p, int i )
00276 {
00277 assert( i >= 0 && i < p->nSize );
00278 return p->pArray[i];
00279 }
00280
00292 static inline void Vec_FltWriteEntry( Vec_Flt_t * p, int i, float Entry )
00293 {
00294 assert( i >= 0 && i < p->nSize );
00295 p->pArray[i] = Entry;
00296 }
00297
00309 static inline void Vec_FltAddToEntry( Vec_Flt_t * p, int i, float Addition )
00310 {
00311 assert( i >= 0 && i < p->nSize );
00312 p->pArray[i] += Addition;
00313 }
00314
00326 static inline float Vec_FltEntryLast( Vec_Flt_t * p )
00327 {
00328 return p->pArray[p->nSize-1];
00329 }
00330
00342 static inline void Vec_FltGrow( Vec_Flt_t * p, int nCapMin )
00343 {
00344 if ( p->nCap >= nCapMin )
00345 return;
00346 p->pArray = REALLOC( float, p->pArray, nCapMin );
00347 p->nCap = nCapMin;
00348 }
00349
00361 static inline void Vec_FltFill( Vec_Flt_t * p, int nSize, float Entry )
00362 {
00363 int i;
00364 Vec_FltGrow( p, nSize );
00365 for ( i = 0; i < nSize; i++ )
00366 p->pArray[i] = Entry;
00367 p->nSize = nSize;
00368 }
00369
00381 static inline void Vec_FltFillExtra( Vec_Flt_t * p, int nSize, float Entry )
00382 {
00383 int i;
00384 if ( p->nSize >= nSize )
00385 return;
00386 Vec_FltGrow( p, nSize );
00387 for ( i = p->nSize; i < nSize; i++ )
00388 p->pArray[i] = Entry;
00389 p->nSize = nSize;
00390 }
00391
00403 static inline void Vec_FltShrink( Vec_Flt_t * p, int nSizeNew )
00404 {
00405 assert( p->nSize >= nSizeNew );
00406 p->nSize = nSizeNew;
00407 }
00408
00420 static inline void Vec_FltClear( Vec_Flt_t * p )
00421 {
00422 p->nSize = 0;
00423 }
00424
00436 static inline void Vec_FltPush( Vec_Flt_t * p, float Entry )
00437 {
00438 if ( p->nSize == p->nCap )
00439 {
00440 if ( p->nCap < 16 )
00441 Vec_FltGrow( p, 16 );
00442 else
00443 Vec_FltGrow( p, 2 * p->nCap );
00444 }
00445 p->pArray[p->nSize++] = Entry;
00446 }
00447
00459 static inline void Vec_FltPushOrder( Vec_Flt_t * p, float Entry )
00460 {
00461 int i;
00462 if ( p->nSize == p->nCap )
00463 {
00464 if ( p->nCap < 16 )
00465 Vec_FltGrow( p, 16 );
00466 else
00467 Vec_FltGrow( p, 2 * p->nCap );
00468 }
00469 p->nSize++;
00470 for ( i = p->nSize-2; i >= 0; i-- )
00471 if ( p->pArray[i] > Entry )
00472 p->pArray[i+1] = p->pArray[i];
00473 else
00474 break;
00475 p->pArray[i+1] = Entry;
00476 }
00477
00489 static inline int Vec_FltPushUnique( Vec_Flt_t * p, float Entry )
00490 {
00491 int i;
00492 for ( i = 0; i < p->nSize; i++ )
00493 if ( p->pArray[i] == Entry )
00494 return 1;
00495 Vec_FltPush( p, Entry );
00496 return 0;
00497 }
00498
00510 static inline float Vec_FltPop( Vec_Flt_t * p )
00511 {
00512 assert( p->nSize > 0 );
00513 return p->pArray[--p->nSize];
00514 }
00515
00527 static inline int Vec_FltFind( Vec_Flt_t * p, float Entry )
00528 {
00529 int i;
00530 for ( i = 0; i < p->nSize; i++ )
00531 if ( p->pArray[i] == Entry )
00532 return i;
00533 return -1;
00534 }
00535
00547 static inline int Vec_FltRemove( Vec_Flt_t * p, float Entry )
00548 {
00549 int i;
00550 for ( i = 0; i < p->nSize; i++ )
00551 if ( p->pArray[i] == Entry )
00552 break;
00553 if ( i == p->nSize )
00554 return 0;
00555 assert( i < p->nSize );
00556 for ( i++; i < p->nSize; i++ )
00557 p->pArray[i-1] = p->pArray[i];
00558 p->nSize--;
00559 return 1;
00560 }
00561
00573 static inline int Vec_FltSortCompare1( float * pp1, float * pp2 )
00574 {
00575
00576 if ( *pp1 < *pp2 )
00577 return -1;
00578 if ( *pp1 > *pp2 )
00579 return 1;
00580 return 0;
00581 }
00582
00594 static inline int Vec_FltSortCompare2( float * pp1, float * pp2 )
00595 {
00596
00597 if ( *pp1 > *pp2 )
00598 return -1;
00599 if ( *pp1 < *pp2 )
00600 return 1;
00601 return 0;
00602 }
00603
00615 static inline void Vec_FltSort( Vec_Flt_t * p, int fReverse )
00616 {
00617 if ( fReverse )
00618 qsort( (void *)p->pArray, p->nSize, sizeof(float),
00619 (int (*)(const void *, const void *)) Vec_FltSortCompare2 );
00620 else
00621 qsort( (void *)p->pArray, p->nSize, sizeof(float),
00622 (int (*)(const void *, const void *)) Vec_FltSortCompare1 );
00623 }
00624
00628
00629 #endif
00630
