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