00001 
00002 
00003 
00004 
00005 
00006 
00007 
00008 
00009 
00010 
00011 
00012 
00013 
00014 
00015 
00016 
00017 
00018 
00019 
00020 
00021 
00022 
00023 
00024 
00025 
00026 
00027 
00028 
00029 
00030 
00031 
00032 
00033 
00034 
00035 
00036 
00037 
00038 
00039 
00040 
00041 
00042 
00043 
00044 
00045 
00046 
00047 
00048 
00049 
00050 
00051 
00052 
00053 
00054 
00055 
00062 #ifndef _EXT_FUNCTIONAL
00063 #define _EXT_FUNCTIONAL
00064 
00065 #pragma GCC system_header
00066 #include <functional>
00067 
00068 namespace __gnu_cxx
00069 {
00070 using std::unary_function;
00071 using std::binary_function;
00072 using std::mem_fun1_t;
00073 using std::const_mem_fun1_t;
00074 using std::mem_fun1_ref_t;
00075 using std::const_mem_fun1_ref_t;
00076 
00086 
00087 template <class _Tp> inline _Tp identity_element(std::plus<_Tp>) {
00088   return _Tp(0);
00089 }
00091 template <class _Tp> inline _Tp identity_element(std::multiplies<_Tp>) {
00092   return _Tp(1);
00093 }
00122 
00123 template <class _Operation1, class _Operation2>
00124 class unary_compose
00125   : public unary_function<typename _Operation2::argument_type,
00126                typename _Operation1::result_type> 
00127 {
00128 protected:
00129   _Operation1 _M_fn1;
00130   _Operation2 _M_fn2;
00131 public:
00132   unary_compose(const _Operation1& __x, const _Operation2& __y) 
00133     : _M_fn1(__x), _M_fn2(__y) {}
00134   typename _Operation1::result_type
00135   operator()(const typename _Operation2::argument_type& __x) const {
00136     return _M_fn1(_M_fn2(__x));
00137   }
00138 };
00139 
00141 template <class _Operation1, class _Operation2>
00142 inline unary_compose<_Operation1,_Operation2> 
00143 compose1(const _Operation1& __fn1, const _Operation2& __fn2)
00144 {
00145   return unary_compose<_Operation1,_Operation2>(__fn1, __fn2);
00146 }
00147 
00149 template <class _Operation1, class _Operation2, class _Operation3>
00150 class binary_compose
00151   : public unary_function<typename _Operation2::argument_type,
00152                           typename _Operation1::result_type> {
00153 protected:
00154   _Operation1 _M_fn1;
00155   _Operation2 _M_fn2;
00156   _Operation3 _M_fn3;
00157 public:
00158   binary_compose(const _Operation1& __x, const _Operation2& __y, 
00159                  const _Operation3& __z) 
00160     : _M_fn1(__x), _M_fn2(__y), _M_fn3(__z) { }
00161   typename _Operation1::result_type
00162   operator()(const typename _Operation2::argument_type& __x) const {
00163     return _M_fn1(_M_fn2(__x), _M_fn3(__x));
00164   }
00165 };
00166 
00168 template <class _Operation1, class _Operation2, class _Operation3>
00169 inline binary_compose<_Operation1, _Operation2, _Operation3> 
00170 compose2(const _Operation1& __fn1, const _Operation2& __fn2, 
00171          const _Operation3& __fn3)
00172 {
00173   return binary_compose<_Operation1,_Operation2,_Operation3>
00174     (__fn1, __fn2, __fn3);
00175 }
00184 template <class _Tp> struct identity : public std::_Identity<_Tp> {};
00185 
00196 
00197 template <class _Pair> struct select1st : public std::_Select1st<_Pair> {};
00199 template <class _Pair> struct select2nd : public std::_Select2nd<_Pair> {};
00202 
00203 template <class _Arg1, class _Arg2>
00204 struct _Project1st : public binary_function<_Arg1, _Arg2, _Arg1> {
00205   _Arg1 operator()(const _Arg1& __x, const _Arg2&) const { return __x; }
00206 };
00207 
00208 template <class _Arg1, class _Arg2>
00209 struct _Project2nd : public binary_function<_Arg1, _Arg2, _Arg2> {
00210   _Arg2 operator()(const _Arg1&, const _Arg2& __y) const { return __y; }
00211 };
00212 
00221 
00222 template <class _Arg1, class _Arg2> 
00223 struct project1st : public _Project1st<_Arg1, _Arg2> {};
00224 
00226 template <class _Arg1, class _Arg2>
00227 struct project2nd : public _Project2nd<_Arg1, _Arg2> {};
00230 
00231 template <class _Result>
00232 struct _Constant_void_fun {
00233   typedef _Result result_type;
00234   result_type _M_val;
00235 
00236   _Constant_void_fun(const result_type& __v) : _M_val(__v) {}
00237   const result_type& operator()() const { return _M_val; }
00238 };  
00239 
00240 template <class _Result, class _Argument>
00241 struct _Constant_unary_fun {
00242   typedef _Argument argument_type;
00243   typedef  _Result  result_type;
00244   result_type _M_val;
00245 
00246   _Constant_unary_fun(const result_type& __v) : _M_val(__v) {}
00247   const result_type& operator()(const _Argument&) const { return _M_val; }
00248 };
00249 
00250 template <class _Result, class _Arg1, class _Arg2>
00251 struct _Constant_binary_fun {
00252   typedef  _Arg1   first_argument_type;
00253   typedef  _Arg2   second_argument_type;
00254   typedef  _Result result_type;
00255   _Result _M_val;
00256 
00257   _Constant_binary_fun(const _Result& __v) : _M_val(__v) {}
00258   const result_type& operator()(const _Arg1&, const _Arg2&) const {
00259     return _M_val;
00260   }
00261 };
00262 
00277 
00278 template <class _Result>
00279 struct constant_void_fun : public _Constant_void_fun<_Result> {
00280   constant_void_fun(const _Result& __v) : _Constant_void_fun<_Result>(__v) {}
00281 };  
00282 
00284 template <class _Result,
00285           class _Argument = _Result>
00286 struct constant_unary_fun : public _Constant_unary_fun<_Result, _Argument>
00287 {
00288   constant_unary_fun(const _Result& __v)
00289     : _Constant_unary_fun<_Result, _Argument>(__v) {}
00290 };
00291 
00293 template <class _Result,
00294           class _Arg1 = _Result,
00295           class _Arg2 = _Arg1>
00296 struct constant_binary_fun
00297   : public _Constant_binary_fun<_Result, _Arg1, _Arg2>
00298 {
00299   constant_binary_fun(const _Result& __v)
00300     : _Constant_binary_fun<_Result, _Arg1, _Arg2>(__v) {}
00301 };
00302 
00304 template <class _Result>
00305 inline constant_void_fun<_Result> constant0(const _Result& __val)
00306 {
00307   return constant_void_fun<_Result>(__val);
00308 }
00309 
00311 template <class _Result>
00312 inline constant_unary_fun<_Result,_Result> constant1(const _Result& __val)
00313 {
00314   return constant_unary_fun<_Result,_Result>(__val);
00315 }
00316 
00318 template <class _Result>
00319 inline constant_binary_fun<_Result,_Result,_Result> 
00320 constant2(const _Result& __val)
00321 {
00322   return constant_binary_fun<_Result,_Result,_Result>(__val);
00323 }
00332 class subtractive_rng : public unary_function<unsigned int, unsigned int> {
00333 private:
00334   unsigned int _M_table[55];
00335   size_t _M_index1;
00336   size_t _M_index2;
00337 public:
00339   unsigned int operator()(unsigned int __limit) {
00340     _M_index1 = (_M_index1 + 1) % 55;
00341     _M_index2 = (_M_index2 + 1) % 55;
00342     _M_table[_M_index1] = _M_table[_M_index1] - _M_table[_M_index2];
00343     return _M_table[_M_index1] % __limit;
00344   }
00345 
00346   void _M_initialize(unsigned int __seed)
00347   {
00348     unsigned int __k = 1;
00349     _M_table[54] = __seed;
00350     size_t __i;
00351     for (__i = 0; __i < 54; __i++) {
00352         size_t __ii = (21 * (__i + 1) % 55) - 1;
00353         _M_table[__ii] = __k;
00354         __k = __seed - __k;
00355         __seed = _M_table[__ii];
00356     }
00357     for (int __loop = 0; __loop < 4; __loop++) {
00358         for (__i = 0; __i < 55; __i++)
00359             _M_table[__i] = _M_table[__i] - _M_table[(1 + __i + 30) % 55];
00360     }
00361     _M_index1 = 0;
00362     _M_index2 = 31;
00363   }
00364 
00366   subtractive_rng(unsigned int __seed) { _M_initialize(__seed); }
00368   subtractive_rng() { _M_initialize(161803398u); }
00369 };
00370 
00371 
00372 
00373 
00374 
00375 template <class _Ret, class _Tp, class _Arg>
00376 inline mem_fun1_t<_Ret,_Tp,_Arg> mem_fun1(_Ret (_Tp::*__f)(_Arg))
00377   { return mem_fun1_t<_Ret,_Tp,_Arg>(__f); }
00378 
00379 template <class _Ret, class _Tp, class _Arg>
00380 inline const_mem_fun1_t<_Ret,_Tp,_Arg> mem_fun1(_Ret (_Tp::*__f)(_Arg) const)
00381   { return const_mem_fun1_t<_Ret,_Tp,_Arg>(__f); }
00382 
00383 template <class _Ret, class _Tp, class _Arg>
00384 inline mem_fun1_ref_t<_Ret,_Tp,_Arg> mem_fun1_ref(_Ret (_Tp::*__f)(_Arg))
00385   { return mem_fun1_ref_t<_Ret,_Tp,_Arg>(__f); }
00386 
00387 template <class _Ret, class _Tp, class _Arg>
00388 inline const_mem_fun1_ref_t<_Ret,_Tp,_Arg>
00389 mem_fun1_ref(_Ret (_Tp::*__f)(_Arg) const)
00390   { return const_mem_fun1_ref_t<_Ret,_Tp,_Arg>(__f); }
00391 
00392 } 
00393 
00394 #endif 
00395