valarray_after.h

00001 // The template and inlines for the -*- C++ -*- internal _Meta class. 00002 00003 // Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 00004 // Free Software Foundation, Inc. 00005 // 00006 // This file is part of the GNU ISO C++ Library. This library is free 00007 // software; you can redistribute it and/or modify it under the 00008 // terms of the GNU General Public License as published by the 00009 // Free Software Foundation; either version 2, or (at your option) 00010 // any later version. 00011 00012 // This library is distributed in the hope that it will be useful, 00013 // but WITHOUT ANY WARRANTY; without even the implied warranty of 00014 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 00015 // GNU General Public License for more details. 00016 00017 // You should have received a copy of the GNU General Public License along 00018 // with this library; see the file COPYING. If not, write to the Free 00019 // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, 00020 // USA. 00021 00022 // As a special exception, you may use this file as part of a free software 00023 // library without restriction. Specifically, if other files instantiate 00024 // templates or use macros or inline functions from this file, or you compile 00025 // this file and link it with other files to produce an executable, this 00026 // file does not by itself cause the resulting executable to be covered by 00027 // the GNU General Public License. This exception does not however 00028 // invalidate any other reasons why the executable file might be covered by 00029 // the GNU General Public License. 00030 00031 // Written by Gabriel Dos Reis <Gabriel.Dos-Reis@cmla.ens-cachan.fr> 00032 00033 /** @file valarray_meta.h 00034 * This is an internal header file, included by other library headers. 00035 * You should not attempt to use it directly. 00036 */ 00037 00038 #ifndef _VALARRAY_AFTER_H 00039 #define _VALARRAY_AFTER_H 1 00040 00041 #pragma GCC system_header 00042 00043 namespace std 00044 { 00045 // 00046 // gslice_array closure. 00047 // 00048 template<class _Dom> 00049 class _GBase 00050 { 00051 public: 00052 typedef typename _Dom::value_type value_type; 00053 00054 _GBase (const _Dom& __e, const valarray<size_t>& __i) 00055 : _M_expr (__e), _M_index(__i) {} 00056 00057 value_type 00058 operator[] (size_t __i) const 00059 { return _M_expr[_M_index[__i]]; } 00060 00061 size_t 00062 size () const 00063 { return _M_index.size(); } 00064 00065 private: 00066 const _Dom& _M_expr; 00067 const valarray<size_t>& _M_index; 00068 }; 00069 00070 template<typename _Tp> 00071 class _GBase<_Array<_Tp> > 00072 { 00073 public: 00074 typedef _Tp value_type; 00075 00076 _GBase (_Array<_Tp> __a, const valarray<size_t>& __i) 00077 : _M_array (__a), _M_index(__i) {} 00078 00079 value_type 00080 operator[] (size_t __i) const 00081 { return _M_array._M_data[_M_index[__i]]; } 00082 00083 size_t 00084 size () const 00085 { return _M_index.size(); } 00086 00087 private: 00088 const _Array<_Tp> _M_array; 00089 const valarray<size_t>& _M_index; 00090 }; 00091 00092 template<class _Dom> 00093 struct _GClos<_Expr, _Dom> 00094 : _GBase<_Dom> 00095 { 00096 typedef _GBase<_Dom> _Base; 00097 typedef typename _Base::value_type value_type; 00098 00099 _GClos (const _Dom& __e, const valarray<size_t>& __i) 00100 : _Base (__e, __i) {} 00101 }; 00102 00103 template<typename _Tp> 00104 struct _GClos<_ValArray, _Tp> 00105 : _GBase<_Array<_Tp> > 00106 { 00107 typedef _GBase<_Array<_Tp> > _Base; 00108 typedef typename _Base::value_type value_type; 00109 00110 _GClos (_Array<_Tp> __a, const valarray<size_t>& __i) 00111 : _Base (__a, __i) {} 00112 }; 00113 00114 // 00115 // indirect_array closure 00116 // 00117 template<class _Dom> 00118 class _IBase 00119 { 00120 public: 00121 typedef typename _Dom::value_type value_type; 00122 00123 _IBase (const _Dom& __e, const valarray<size_t>& __i) 00124 : _M_expr (__e), _M_index (__i) {} 00125 00126 value_type 00127 operator[] (size_t __i) const 00128 { return _M_expr[_M_index[__i]]; } 00129 00130 size_t size() const { return _M_index.size(); } 00131 00132 private: 00133 const _Dom& _M_expr; 00134 const valarray<size_t>& _M_index; 00135 }; 00136 00137 template<class _Dom> 00138 struct _IClos<_Expr, _Dom> 00139 : _IBase<_Dom> 00140 { 00141 typedef _IBase<_Dom> _Base; 00142 typedef typename _Base::value_type value_type; 00143 00144 _IClos (const _Dom& __e, const valarray<size_t>& __i) 00145 : _Base (__e, __i) {} 00146 }; 00147 00148 template<typename _Tp> 00149 struct _IClos<_ValArray, _Tp> 00150 : _IBase<valarray<_Tp> > 00151 { 00152 typedef _IBase<valarray<_Tp> > _Base; 00153 typedef _Tp value_type; 00154 00155 _IClos (const valarray<_Tp>& __a, const valarray<size_t>& __i) 00156 : _Base (__a, __i) {} 00157 }; 00158 00159 // 00160 // class _Expr 00161 // 00162 template<class _Clos, typename _Tp> 00163 class _Expr 00164 { 00165 public: 00166 typedef _Tp value_type; 00167 00168 _Expr(const _Clos&); 00169 00170 const _Clos& operator()() const; 00171 00172 value_type operator[](size_t) const; 00173 valarray<value_type> operator[](slice) const; 00174 valarray<value_type> operator[](const gslice&) const; 00175 valarray<value_type> operator[](const valarray<bool>&) const; 00176 valarray<value_type> operator[](const valarray<size_t>&) const; 00177 00178 _Expr<_UnClos<__unary_plus, std::_Expr, _Clos>, value_type> 00179 operator+() const; 00180 00181 _Expr<_UnClos<__negate, std::_Expr, _Clos>, value_type> 00182 operator-() const; 00183 00184 _Expr<_UnClos<__bitwise_not, std::_Expr, _Clos>, value_type> 00185 operator~() const; 00186 00187 _Expr<_UnClos<__logical_not, std::_Expr, _Clos>, bool> 00188 operator!() const; 00189 00190 size_t size() const; 00191 value_type sum() const; 00192 00193 valarray<value_type> shift(int) const; 00194 valarray<value_type> cshift(int) const; 00195 00196 value_type min() const; 00197 value_type max() const; 00198 00199 valarray<value_type> apply(value_type (*)(const value_type&)) const; 00200 valarray<value_type> apply(value_type (*)(value_type)) const; 00201 00202 private: 00203 const _Clos _M_closure; 00204 }; 00205 00206 template<class _Clos, typename _Tp> 00207 inline 00208 _Expr<_Clos, _Tp>::_Expr(const _Clos& __c) : _M_closure(__c) {} 00209 00210 template<class _Clos, typename _Tp> 00211 inline const _Clos& 00212 _Expr<_Clos, _Tp>::operator()() const 00213 { return _M_closure; } 00214 00215 template<class _Clos, typename _Tp> 00216 inline _Tp 00217 _Expr<_Clos, _Tp>::operator[](size_t __i) const 00218 { return _M_closure[__i]; } 00219 00220 template<class _Clos, typename _Tp> 00221 inline valarray<_Tp> 00222 _Expr<_Clos, _Tp>::operator[](slice __s) const 00223 { return _M_closure[__s]; } 00224 00225 template<class _Clos, typename _Tp> 00226 inline valarray<_Tp> 00227 _Expr<_Clos, _Tp>::operator[](const gslice& __gs) const 00228 { return _M_closure[__gs]; } 00229 00230 template<class _Clos, typename _Tp> 00231 inline valarray<_Tp> 00232 _Expr<_Clos, _Tp>::operator[](const valarray<bool>& __m) const 00233 { return _M_closure[__m]; } 00234 00235 template<class _Clos, typename _Tp> 00236 inline valarray<_Tp> 00237 _Expr<_Clos, _Tp>::operator[](const valarray<size_t>& __i) const 00238 { return _M_closure[__i]; } 00239 00240 template<class _Clos, typename _Tp> 00241 inline size_t 00242 _Expr<_Clos, _Tp>::size() const 00243 { return _M_closure.size (); } 00244 00245 template<class _Clos, typename _Tp> 00246 inline valarray<_Tp> 00247 _Expr<_Clos, _Tp>::shift(int __n) const 00248 { return valarray<_Tp>(_M_closure).shift(__n); } 00249 00250 template<class _Clos, typename _Tp> 00251 inline valarray<_Tp> 00252 _Expr<_Clos, _Tp>::cshift(int __n) const 00253 { return valarray<_Tp>(_M_closure).cshift(__n); } 00254 00255 template<class _Clos, typename _Tp> 00256 inline valarray<_Tp> 00257 _Expr<_Clos, _Tp>::apply(_Tp __f(const _Tp&)) const 00258 { return valarray<_Tp>(_M_closure).apply(__f); } 00259 00260 template<class _Clos, typename _Tp> 00261 inline valarray<_Tp> 00262 _Expr<_Clos, _Tp>::apply(_Tp __f(_Tp)) const 00263 { return valarray<_Tp>(_M_closure).apply(__f); } 00264 00265 // XXX: replace this with a more robust summation algorithm. 00266 template<class _Clos, typename _Tp> 00267 inline _Tp 00268 _Expr<_Clos, _Tp>::sum() const 00269 { 00270 size_t __n = _M_closure.size(); 00271 if (__n == 0) 00272 return _Tp(); 00273 else 00274 { 00275 _Tp __s = _M_closure[--__n]; 00276 while (__n != 0) 00277 __s += _M_closure[--__n]; 00278 return __s; 00279 } 00280 } 00281 00282 template<class _Clos, typename _Tp> 00283 inline _Tp 00284 _Expr<_Clos, _Tp>::min() const 00285 { return __valarray_min(_M_closure); } 00286 00287 template<class _Clos, typename _Tp> 00288 inline _Tp 00289 _Expr<_Clos, _Tp>::max() const 00290 { return __valarray_max(_M_closure); } 00291 00292 template<class _Dom, typename _Tp> 00293 inline _Expr<_UnClos<__logical_not, _Expr, _Dom>, bool> 00294 _Expr<_Dom, _Tp>::operator!() const 00295 { 00296 typedef _UnClos<__logical_not, std::_Expr, _Dom> _Closure; 00297 return _Expr<_Closure, _Tp>(_Closure(this->_M_closure)); 00298 } 00299 00300 #define _DEFINE_EXPR_UNARY_OPERATOR(_Op, _Name) \ 00301 template<class _Dom, typename _Tp> \ 00302 inline _Expr<_UnClos<_Name, std::_Expr, _Dom>, _Tp> \ 00303 _Expr<_Dom, _Tp>::operator _Op() const \ 00304 { \ 00305 typedef _UnClos<_Name, std::_Expr, _Dom> _Closure; \ 00306 return _Expr<_Closure, _Tp>(_Closure(this->_M_closure)); \ 00307 } 00308 00309 _DEFINE_EXPR_UNARY_OPERATOR(+, __unary_plus) 00310 _DEFINE_EXPR_UNARY_OPERATOR(-, __negate) 00311 _DEFINE_EXPR_UNARY_OPERATOR(~, __bitwise_not) 00312 00313 #undef _DEFINE_EXPR_UNARY_OPERATOR 00314 00315 #define _DEFINE_EXPR_BINARY_OPERATOR(_Op, _Name) \ 00316 template<class _Dom1, class _Dom2> \ 00317 inline _Expr<_BinClos<_Name, _Expr, _Expr, _Dom1, _Dom2>, \ 00318 typename __fun<_Name, typename _Dom1::value_type>::result_type> \ 00319 operator _Op(const _Expr<_Dom1, typename _Dom1::value_type>& __v, \ 00320 const _Expr<_Dom2, typename _Dom2::value_type>& __w) \ 00321 { \ 00322 typedef typename _Dom1::value_type _Arg; \ 00323 typedef typename __fun<_Name, _Arg>::result_type _Value; \ 00324 typedef _BinClos<_Name, _Expr, _Expr, _Dom1, _Dom2> _Closure; \ 00325 return _Expr<_Closure, _Value>(_Closure(__v(), __w())); \ 00326 } \ 00327 \ 00328 template<class _Dom> \ 00329 inline _Expr<_BinClos<_Name, _Expr, _Constant, _Dom, \ 00330 typename _Dom::value_type>, \ 00331 typename __fun<_Name, typename _Dom::value_type>::result_type> \ 00332 operator _Op(const _Expr<_Dom, typename _Dom::value_type>& __v, \ 00333 const typename _Dom::value_type& __t) \ 00334 { \ 00335 typedef typename _Dom::value_type _Arg; \ 00336 typedef typename __fun<_Name, _Arg>::result_type _Value; \ 00337 typedef _BinClos<_Name, _Expr, _Constant, _Dom, _Arg> _Closure; \ 00338 return _Expr<_Closure, _Value>(_Closure(__v(), __t)); \ 00339 } \ 00340 \ 00341 template<class _Dom> \ 00342 inline _Expr<_BinClos<_Name, _Constant, _Expr, \ 00343 typename _Dom::value_type, _Dom>, \ 00344 typename __fun<_Name, typename _Dom::value_type>::result_type> \ 00345 operator _Op(const typename _Dom::value_type& __t, \ 00346 const _Expr<_Dom, typename _Dom::value_type>& __v) \ 00347 { \ 00348 typedef typename _Dom::value_type _Arg; \ 00349 typedef typename __fun<_Name, _Arg>::result_type _Value; \ 00350 typedef _BinClos<_Name, _Constant, _Expr, _Arg, _Dom> _Closure; \ 00351 return _Expr<_Closure, _Value>(_Closure(__t, __v())); \ 00352 } \ 00353 \ 00354 template<class _Dom> \ 00355 inline _Expr<_BinClos<_Name, _Expr, _ValArray, \ 00356 _Dom, typename _Dom::value_type>, \ 00357 typename __fun<_Name, typename _Dom::value_type>::result_type> \ 00358 operator _Op(const _Expr<_Dom,typename _Dom::value_type>& __e, \ 00359 const valarray<typename _Dom::value_type>& __v) \ 00360 { \ 00361 typedef typename _Dom::value_type _Arg; \ 00362 typedef typename __fun<_Name, _Arg>::result_type _Value; \ 00363 typedef _BinClos<_Name, _Expr, _ValArray, _Dom, _Arg> _Closure; \ 00364 return _Expr<_Closure, _Value>(_Closure(__e(), __v)); \ 00365 } \ 00366 \ 00367 template<class _Dom> \ 00368 inline _Expr<_BinClos<_Name, _ValArray, _Expr, \ 00369 typename _Dom::value_type, _Dom>, \ 00370 typename __fun<_Name, typename _Dom::value_type>::result_type> \ 00371 operator _Op(const valarray<typename _Dom::value_type>& __v, \ 00372 const _Expr<_Dom, typename _Dom::value_type>& __e) \ 00373 { \ 00374 typedef typename _Dom::value_type _Tp; \ 00375 typedef typename __fun<_Name, _Tp>::result_type _Value; \ 00376 typedef _BinClos<_Name, _ValArray, _Expr, _Tp, _Dom> _Closure; \ 00377 return _Expr<_Closure, _Value>(_Closure(__v, __e ())); \ 00378 } 00379 00380 _DEFINE_EXPR_BINARY_OPERATOR(+, __plus) 00381 _DEFINE_EXPR_BINARY_OPERATOR(-, __minus) 00382 _DEFINE_EXPR_BINARY_OPERATOR(*, __multiplies) 00383 _DEFINE_EXPR_BINARY_OPERATOR(/, __divides) 00384 _DEFINE_EXPR_BINARY_OPERATOR(%, __modulus) 00385 _DEFINE_EXPR_BINARY_OPERATOR(^, __bitwise_xor) 00386 _DEFINE_EXPR_BINARY_OPERATOR(&, __bitwise_and) 00387 _DEFINE_EXPR_BINARY_OPERATOR(|, __bitwise_or) 00388 _DEFINE_EXPR_BINARY_OPERATOR(<<, __shift_left) 00389 _DEFINE_EXPR_BINARY_OPERATOR(>>, __shift_right) 00390 _DEFINE_EXPR_BINARY_OPERATOR(&&, __logical_and) 00391 _DEFINE_EXPR_BINARY_OPERATOR(||, __logical_or) 00392 _DEFINE_EXPR_BINARY_OPERATOR(==, __equal_to) 00393 _DEFINE_EXPR_BINARY_OPERATOR(!=, __not_equal_to) 00394 _DEFINE_EXPR_BINARY_OPERATOR(<, __less) 00395 _DEFINE_EXPR_BINARY_OPERATOR(>, __greater) 00396 _DEFINE_EXPR_BINARY_OPERATOR(<=, __less_equal) 00397 _DEFINE_EXPR_BINARY_OPERATOR(>=, __greater_equal) 00398 00399 #undef _DEFINE_EXPR_BINARY_OPERATOR 00400 00401 #define _DEFINE_EXPR_UNARY_FUNCTION(_Name) \ 00402 template<class _Dom> \ 00403 inline _Expr<_UnClos<__##_Name, _Expr, _Dom>, \ 00404 typename _Dom::value_type> \ 00405 _Name(const _Expr<_Dom, typename _Dom::value_type>& __e) \ 00406 { \ 00407 typedef typename _Dom::value_type _Tp; \ 00408 typedef _UnClos<__##_Name, _Expr, _Dom> _Closure; \ 00409 return _Expr<_Closure, _Tp>(_Closure(__e())); \ 00410 } \ 00411 \ 00412 template<typename _Tp> \ 00413 inline _Expr<_UnClos<__##_Name, _ValArray, _Tp>, _Tp> \ 00414 _Name(const valarray<_Tp>& __v) \ 00415 { \ 00416 typedef _UnClos<__##_Name, _ValArray, _Tp> _Closure; \ 00417 return _Expr<_Closure, _Tp>(_Closure(__v)); \ 00418 } 00419 00420 _DEFINE_EXPR_UNARY_FUNCTION(abs) 00421 _DEFINE_EXPR_UNARY_FUNCTION(cos) 00422 _DEFINE_EXPR_UNARY_FUNCTION(acos) 00423 _DEFINE_EXPR_UNARY_FUNCTION(cosh) 00424 _DEFINE_EXPR_UNARY_FUNCTION(sin) 00425 _DEFINE_EXPR_UNARY_FUNCTION(asin) 00426 _DEFINE_EXPR_UNARY_FUNCTION(sinh) 00427 _DEFINE_EXPR_UNARY_FUNCTION(tan) 00428 _DEFINE_EXPR_UNARY_FUNCTION(tanh) 00429 _DEFINE_EXPR_UNARY_FUNCTION(atan) 00430 _DEFINE_EXPR_UNARY_FUNCTION(exp) 00431 _DEFINE_EXPR_UNARY_FUNCTION(log) 00432 _DEFINE_EXPR_UNARY_FUNCTION(log10) 00433 _DEFINE_EXPR_UNARY_FUNCTION(sqrt) 00434 00435 #undef _DEFINE_EXPR_UNARY_FUNCTION 00436 00437 #define _DEFINE_EXPR_BINARY_FUNCTION(_Fun) \ 00438 template<class _Dom1, class _Dom2> \ 00439 inline _Expr<_BinClos<__##_Fun, _Expr, _Expr, _Dom1, _Dom2>, \ 00440 typename _Dom1::value_type> \ 00441 _Fun(const _Expr<_Dom1, typename _Dom1::value_type>& __e1, \ 00442 const _Expr<_Dom2, typename _Dom2::value_type>& __e2) \ 00443 { \ 00444 typedef typename _Dom1::value_type _Tp; \ 00445 typedef _BinClos<__##_Fun, _Expr, _Expr, _Dom1, _Dom2> _Closure; \ 00446 return _Expr<_Closure, _Tp>(_Closure(__e1(), __e2())); \ 00447 } \ 00448 \ 00449 template<class _Dom> \ 00450 inline _Expr<_BinClos<__##_Fun, _Expr, _ValArray, _Dom, \ 00451 typename _Dom::value_type>, \ 00452 typename _Dom::value_type> \ 00453 _Fun(const _Expr<_Dom, typename _Dom::value_type>& __e, \ 00454 const valarray<typename _Dom::value_type>& __v) \ 00455 { \ 00456 typedef typename _Dom::value_type _Tp; \ 00457 typedef _BinClos<__##_Fun, _Expr, _ValArray, _Dom, _Tp> _Closure; \ 00458 return _Expr<_Closure, _Tp>(_Closure(__e(), __v)); \ 00459 } \ 00460 \ 00461 template<class _Dom> \ 00462 inline _Expr<_BinClos<__##_Fun, _ValArray, _Expr, \ 00463 typename _Dom::value_type, _Dom>, \ 00464 typename _Dom::value_type> \ 00465 _Fun(const valarray<typename _Dom::valarray>& __v, \ 00466 const _Expr<_Dom, typename _Dom::value_type>& __e) \ 00467 { \ 00468 typedef typename _Dom::value_type _Tp; \ 00469 typedef _BinClos<__##_Fun, _ValArray, _Expr, _Tp, _Dom> _Closure; \ 00470 return _Expr<_Closure, _Tp>(_Closure(__v, __e())); \ 00471 } \ 00472 \ 00473 template<class _Dom> \ 00474 inline _Expr<_BinClos<__##_Fun, _Expr, _Constant, _Dom, \ 00475 typename _Dom::value_type>, \ 00476 typename _Dom::value_type> \ 00477 _Fun(const _Expr<_Dom, typename _Dom::value_type>& __e, \ 00478 const typename _Dom::value_type& __t) \ 00479 { \ 00480 typedef typename _Dom::value_type _Tp; \ 00481 typedef _BinClos<__##_Fun, _Expr, _Constant, _Dom, _Tp> _Closure;\ 00482 return _Expr<_Closure, _Tp>(_Closure(__e(), __t)); \ 00483 } \ 00484 \ 00485 template<class _Dom> \ 00486 inline _Expr<_BinClos<__##_Fun, _Constant, _Expr, \ 00487 typename _Dom::value_type, _Dom>, \ 00488 typename _Dom::value_type> \ 00489 _Fun(const typename _Dom::value_type& __t, \ 00490 const _Expr<_Dom, typename _Dom::value_type>& __e) \ 00491 { \ 00492 typedef typename _Dom::value_type _Tp; \ 00493 typedef _BinClos<__##_Fun, _Constant, _Expr, _Tp, _Dom> _Closure; \ 00494 return _Expr<_Closure, _Tp>(_Closure(__t, __e())); \ 00495 } \ 00496 \ 00497 template<typename _Tp> \ 00498 inline _Expr<_BinClos<__##_Fun, _ValArray, _ValArray, _Tp, _Tp>, _Tp> \ 00499 _Fun(const valarray<_Tp>& __v, const valarray<_Tp>& __w) \ 00500 { \ 00501 typedef _BinClos<__##_Fun, _ValArray, _ValArray, _Tp, _Tp> _Closure; \ 00502 return _Expr<_Closure, _Tp>(_Closure(__v, __w)); \ 00503 } \ 00504 \ 00505 template<typename _Tp> \ 00506 inline _Expr<_BinClos<__##_Fun, _ValArray, _Constant, _Tp, _Tp>, _Tp> \ 00507 _Fun(const valarray<_Tp>& __v, const _Tp& __t) \ 00508 { \ 00509 typedef _BinClos<__##_Fun, _ValArray, _Constant, _Tp, _Tp> _Closure; \ 00510 return _Expr<_Closure, _Tp>(_Closure(__v, __t)); \ 00511 } \ 00512 \ 00513 template<typename _Tp> \ 00514 inline _Expr<_BinClos<__##_Fun, _Constant, _ValArray, _Tp, _Tp>, _Tp> \ 00515 _Fun(const _Tp& __t, const valarray<_Tp>& __v) \ 00516 { \ 00517 typedef _BinClos<__##_Fun, _Constant, _ValArray, _Tp, _Tp> _Closure; \ 00518 return _Expr<_Closure, _Tp>(_Closure(__t, __v)); \ 00519 } 00520 00521 _DEFINE_EXPR_BINARY_FUNCTION(atan2) 00522 _DEFINE_EXPR_BINARY_FUNCTION(pow) 00523 00524 #undef _DEFINE_EXPR_BINARY_FUNCTION 00525 00526 } // std:: 00527 00528 #endif /* _CPP_VALARRAY_AFTER_H */ 00529 00530 // Local Variables: 00531 // mode:c++ 00532 // End:

Generated on Sun Jul 25 00:12:34 2004 for libstdc++ source by doxygen 1.3.7