+2002-01-03 Paolo Carlini <pcarlini@unitus.it>
+
+ * include/bits/stl_numeric.h (power + helpers, iota): Move to...
+ * include/ext/numeric: ...here, new file.
+ * include/bits/stl_function.h (identity_element, unary_compose,
+ binary_compose, compose1, compose2, identity, select1st,
+ select2nd, project1st + helper, project2nd + helper,
+ constant_void_fun + helper, constant_unary_fun + helper,
+ costant_binary_fun + helper, constant0, constant1, constant2,
+ subtractive_rng, mem_fun1, mem_fun1_ref): Move to...
+ * include/ext/functional: ...here, new file.
+ * include/Makefile.am (ext_headers): Add new files.
+ * include/Makefile.in: Regenerate.
+ * testsuite/ext/headers.cc: Include <ext/numeric> and
+ <ext/functional>.
+ * include/backward/algo.h: Include <ext/numeric>, tweak.
+ * include/backward/function.h: Include <ext/functional>, tweak.
+ * include/ext/ropeimpl.h: Include <ext/numeric>.
+
Thu Jan 3 11:05:41 2002 Jeffrey A Law (law@redhat.com)
* config/os/hpux/bits/os_defines.h: Prefix __strtoll and
ext_builddir = ./ext
ext_headers = \
${ext_srcdir}/algorithm \
+ ${ext_srcdir}/functional \
${ext_srcdir}/hash_map \
${ext_srcdir}/hash_set \
${ext_srcdir}/iterator \
${ext_srcdir}/memory \
+ ${ext_srcdir}/numeric \
${ext_srcdir}/rope \
${ext_srcdir}/ropeimpl.h \
${ext_srcdir}/slist \
ext_builddir = ./ext
ext_headers = \
${ext_srcdir}/algorithm \
+ ${ext_srcdir}/functional \
${ext_srcdir}/hash_map \
${ext_srcdir}/hash_set \
${ext_srcdir}/iterator \
${ext_srcdir}/memory \
+ ${ext_srcdir}/numeric \
${ext_srcdir}/rope \
${ext_srcdir}/ropeimpl.h \
${ext_srcdir}/slist \
#include <bits/stl_algo.h>
#include <bits/stl_numeric.h>
#include <ext/algorithm>
+#include <ext/numeric>
// Names from <stl_algo.h>
using std::for_each;
using std::inner_product;
using std::partial_sum;
using std::adjacent_difference;
-using std::power;
-using std::iota;
// Names from ext/algorithm
using __gnu_cxx::random_sample;
using __gnu_cxx::count; // Extension returning void
using __gnu_cxx::count_if; // Extension returning void
+// Names from ext/numeric
+using __gnu_cxx::power;
+using __gnu_cxx::iota;
+
#endif /* _CPP_BACKWARD_ALGO_H */
// Local Variables:
#include <bits/c++config.h>
#include <stddef.h>
#include <bits/stl_function.h>
+#include <ext/functional>
// Names from stl_function.h
using std::unary_function;
using std::minus;
using std::multiplies;
using std::divides;
-using std::identity_element;
using std::modulus;
using std::negate;
using std::equal_to;
using std::binder2nd;
using std::bind1st;
using std::bind2nd;
-using std::unary_compose;
-using std::binary_compose;
-using std::compose1;
-using std::compose2;
using std::pointer_to_unary_function;
using std::pointer_to_binary_function;
using std::ptr_fun;
-using std::identity;
-using std::select1st;
-using std::select2nd;
-using std::project1st;
-using std::project2nd;
-using std::constant_void_fun;
-using std::constant_unary_fun;
-using std::constant_binary_fun;
-using std::constant0;
-using std::constant1;
-using std::constant2;
-using std::subtractive_rng;
using std::mem_fun_t;
using std::const_mem_fun_t;
using std::mem_fun_ref_t;
using std::const_mem_fun1_ref_t;
using std::mem_fun;
using std::mem_fun_ref;
-using std::mem_fun1;
-using std::mem_fun1_ref;
+
+// Names from ext/functional
+using __gnu_cxx::identity_element;
+using __gnu_cxx::unary_compose;
+using __gnu_cxx::binary_compose;
+using __gnu_cxx::compose1;
+using __gnu_cxx::compose2;
+using __gnu_cxx::identity;
+using __gnu_cxx::select1st;
+using __gnu_cxx::select2nd;
+using __gnu_cxx::project1st;
+using __gnu_cxx::project2nd;
+using __gnu_cxx::constant_void_fun;
+using __gnu_cxx::constant_unary_fun;
+using __gnu_cxx::constant_binary_fun;
+using __gnu_cxx::constant0;
+using __gnu_cxx::constant1;
+using __gnu_cxx::constant2;
+using __gnu_cxx::subtractive_rng;
+using __gnu_cxx::mem_fun1;
+using __gnu_cxx::mem_fun1_ref;
#endif /* _CPP_BACKWARD_FUNCTION_H */
};
/** @} */
-/** The @c identity_element functions are not part of the C++ standard; SGI
- * provided them as an extension. Its argument is an operation, and its
- * return value is the identity element for that operation. It is overloaded
- * for addition and multiplication, and you can overload it for your own
- * nefarious operations.
- *
- * @addtogroup SGIextensions
- * @{
-*/
-/// An \link SGIextensions SGI extension \endlink.
-template <class _Tp> inline _Tp identity_element(plus<_Tp>) {
- return _Tp(0);
-}
-/// An \link SGIextensions SGI extension \endlink.
-template <class _Tp> inline _Tp identity_element(multiplies<_Tp>) {
- return _Tp(1);
-}
-/** @} */
-
// 20.3.3 comparisons
/** @defgroup s20_3_3_comparisons Comparison Classes
* The library provides six wrapper functors for all the basic comparisons
}
/** @} */
-/** As an extension to the binders, SGI provided composition functors and
- * wrapper functions to aid in their creation. The @c unary_compose
- * functor is constructed from two functions/functors, @c f and @c g.
- * Calling @c operator() with a single argument @c x returns @c f(g(x)).
- * The function @c compose1 takes the two functions and constructs a
- * @c unary_compose variable for you.
- *
- * @c binary_compose is constructed from three functors, @c f, @c g1,
- * and @c g2. Its @c operator() returns @c f(g1(x),g2(x)). The function
- * @compose2 takes f, g1, and g2, and constructs the @c binary_compose
- * instance for you. For example, if @c f returns an int, then
- * \code
- * int answer = (compose2(f,g1,g2))(x);
- * \endcode
- * is equivalent to
- * \code
- * int temp1 = g1(x);
- * int temp2 = g2(x);
- * int answer = f(temp1,temp2);
- * \endcode
- * But the first form is more compact, and can be passed around as a
- * functor to other algorithms.
- *
- * @addtogroup SGIextensions
- * @{
-*/
-/// An \link SGIextensions SGI extension \endlink.
-template <class _Operation1, class _Operation2>
-class unary_compose
- : public unary_function<typename _Operation2::argument_type,
- typename _Operation1::result_type>
-{
-protected:
- _Operation1 _M_fn1;
- _Operation2 _M_fn2;
-public:
- unary_compose(const _Operation1& __x, const _Operation2& __y)
- : _M_fn1(__x), _M_fn2(__y) {}
- typename _Operation1::result_type
- operator()(const typename _Operation2::argument_type& __x) const {
- return _M_fn1(_M_fn2(__x));
- }
-};
-
-/// An \link SGIextensions SGI extension \endlink.
-template <class _Operation1, class _Operation2>
-inline unary_compose<_Operation1,_Operation2>
-compose1(const _Operation1& __fn1, const _Operation2& __fn2)
-{
- return unary_compose<_Operation1,_Operation2>(__fn1, __fn2);
-}
-
-/// An \link SGIextensions SGI extension \endlink.
-template <class _Operation1, class _Operation2, class _Operation3>
-class binary_compose
- : public unary_function<typename _Operation2::argument_type,
- typename _Operation1::result_type> {
-protected:
- _Operation1 _M_fn1;
- _Operation2 _M_fn2;
- _Operation3 _M_fn3;
-public:
- binary_compose(const _Operation1& __x, const _Operation2& __y,
- const _Operation3& __z)
- : _M_fn1(__x), _M_fn2(__y), _M_fn3(__z) { }
- typename _Operation1::result_type
- operator()(const typename _Operation2::argument_type& __x) const {
- return _M_fn1(_M_fn2(__x), _M_fn3(__x));
- }
-};
-
-/// An \link SGIextensions SGI extension \endlink.
-template <class _Operation1, class _Operation2, class _Operation3>
-inline binary_compose<_Operation1, _Operation2, _Operation3>
-compose2(const _Operation1& __fn1, const _Operation2& __fn2,
- const _Operation3& __fn3)
-{
- return binary_compose<_Operation1,_Operation2,_Operation3>
- (__fn1, __fn2, __fn3);
-}
-/** @} */
-
// 20.3.7 adaptors pointers functions
/** @defgroup s20_3_7_adaptors Adaptors for pointers to functions
* The advantage of function objects over pointers to functions is that
}
/** @} */
-
-// extension documented next
template <class _Tp>
struct _Identity : public unary_function<_Tp,_Tp> {
_Tp& operator()(_Tp& __x) const { return __x; }
const _Tp& operator()(const _Tp& __x) const { return __x; }
};
-/** As an extension, SGI provided a functor called @c identity. When a
- * functor is required but no operations are desired, this can be used as a
- * pass-through. Its @c operator() returns its argument unchanged.
- *
- * @addtogroup SGIextensions
-*/
-template <class _Tp> struct identity : public _Identity<_Tp> {};
-
-// extension documented next
template <class _Pair>
struct _Select1st : public unary_function<_Pair, typename _Pair::first_type> {
typename _Pair::first_type& operator()(_Pair& __x) const {
}
};
-/** @c select1st and @c select2nd are extensions provided by SGI. Their
- * @c operator()s
- * take a @c std::pair as an argument, and return either the first member
- * or the second member, respectively. They can be used (especially with
- * the composition functors) to "strip" data from a sequence before
- * performing the remainder of an algorithm.
- *
- * @addtogroup SGIextensions
- * @{
-*/
-/// An \link SGIextensions SGI extension \endlink.
-template <class _Pair> struct select1st : public _Select1st<_Pair> {};
-/// An \link SGIextensions SGI extension \endlink.
-template <class _Pair> struct select2nd : public _Select2nd<_Pair> {};
-/** @} */
-
-// extension documented next
-template <class _Arg1, class _Arg2>
-struct _Project1st : public binary_function<_Arg1, _Arg2, _Arg1> {
- _Arg1 operator()(const _Arg1& __x, const _Arg2&) const { return __x; }
-};
-
-template <class _Arg1, class _Arg2>
-struct _Project2nd : public binary_function<_Arg1, _Arg2, _Arg2> {
- _Arg2 operator()(const _Arg1&, const _Arg2& __y) const { return __y; }
-};
-
-/** The @c operator() of the @c project1st functor takes two arbitrary
- * arguments and returns the first one, while @c project2nd returns the
- * second one. They are extensions provided by SGI.
- *
- * @addtogroup SGIextensions
- * @{
-*/
-/// An \link SGIextensions SGI extension \endlink.
-template <class _Arg1, class _Arg2>
-struct project1st : public _Project1st<_Arg1, _Arg2> {};
-
-/// An \link SGIextensions SGI extension \endlink.
-template <class _Arg1, class _Arg2>
-struct project2nd : public _Project2nd<_Arg1, _Arg2> {};
-/** @} */
-
-// extension documented next
-template <class _Result>
-struct _Constant_void_fun {
- typedef _Result result_type;
- result_type _M_val;
-
- _Constant_void_fun(const result_type& __v) : _M_val(__v) {}
- const result_type& operator()() const { return _M_val; }
-};
-
-template <class _Result, class _Argument>
-struct _Constant_unary_fun {
- typedef _Argument argument_type;
- typedef _Result result_type;
- result_type _M_val;
-
- _Constant_unary_fun(const result_type& __v) : _M_val(__v) {}
- const result_type& operator()(const _Argument&) const { return _M_val; }
-};
-
-template <class _Result, class _Arg1, class _Arg2>
-struct _Constant_binary_fun {
- typedef _Arg1 first_argument_type;
- typedef _Arg2 second_argument_type;
- typedef _Result result_type;
- _Result _M_val;
-
- _Constant_binary_fun(const _Result& __v) : _M_val(__v) {}
- const result_type& operator()(const _Arg1&, const _Arg2&) const {
- return _M_val;
- }
-};
-
-/** These three functors are each constructed from a single arbitrary
- * variable/value. Later, their @c operator()s completely ignore any
- * arguments passed, and return the stored value.
- * - @c constant_void_fun's @c operator() takes no arguments
- * - @c constant_unary_fun's @c operator() takes one argument (ignored)
- * - @c constant_binary_fun's @c operator() takes two arguments (ignored)
- *
- * The helper creator functions @c constant0, @c constant1, and
- * @c constant2 each take a "result" argument and construct variables of
- * the appropriate functor type.
- *
- * @addtogroup SGIextensions
- * @{
-*/
-/// An \link SGIextensions SGI extension \endlink.
-template <class _Result>
-struct constant_void_fun : public _Constant_void_fun<_Result> {
- constant_void_fun(const _Result& __v) : _Constant_void_fun<_Result>(__v) {}
-};
-
-/// An \link SGIextensions SGI extension \endlink.
-template <class _Result,
- class _Argument = _Result>
-struct constant_unary_fun : public _Constant_unary_fun<_Result, _Argument>
-{
- constant_unary_fun(const _Result& __v)
- : _Constant_unary_fun<_Result, _Argument>(__v) {}
-};
-
-/// An \link SGIextensions SGI extension \endlink.
-template <class _Result,
- class _Arg1 = _Result,
- class _Arg2 = _Arg1>
-struct constant_binary_fun
- : public _Constant_binary_fun<_Result, _Arg1, _Arg2>
-{
- constant_binary_fun(const _Result& __v)
- : _Constant_binary_fun<_Result, _Arg1, _Arg2>(__v) {}
-};
-
-/// An \link SGIextensions SGI extension \endlink.
-template <class _Result>
-inline constant_void_fun<_Result> constant0(const _Result& __val)
-{
- return constant_void_fun<_Result>(__val);
-}
-
-/// An \link SGIextensions SGI extension \endlink.
-template <class _Result>
-inline constant_unary_fun<_Result,_Result> constant1(const _Result& __val)
-{
- return constant_unary_fun<_Result,_Result>(__val);
-}
-
-/// An \link SGIextensions SGI extension \endlink.
-template <class _Result>
-inline constant_binary_fun<_Result,_Result,_Result>
-constant2(const _Result& __val)
-{
- return constant_binary_fun<_Result,_Result,_Result>(__val);
-}
-/** @} */
-
-/** The @c subtractive_rng class is documented on
- * <a href="http://www.sgi.com/tech/stl/">SGI's site</a>.
- * Note that this code assumes that @c int is 32 bits.
- *
- * @ingroup SGIextensions
-*/
-class subtractive_rng : public unary_function<unsigned int, unsigned int> {
-private:
- unsigned int _M_table[55];
- size_t _M_index1;
- size_t _M_index2;
-public:
- /// Returns a number less than the argument.
- unsigned int operator()(unsigned int __limit) {
- _M_index1 = (_M_index1 + 1) % 55;
- _M_index2 = (_M_index2 + 1) % 55;
- _M_table[_M_index1] = _M_table[_M_index1] - _M_table[_M_index2];
- return _M_table[_M_index1] % __limit;
- }
-
- void _M_initialize(unsigned int __seed)
- {
- unsigned int __k = 1;
- _M_table[54] = __seed;
- size_t __i;
- for (__i = 0; __i < 54; __i++) {
- size_t __ii = (21 * (__i + 1) % 55) - 1;
- _M_table[__ii] = __k;
- __k = __seed - __k;
- __seed = _M_table[__ii];
- }
- for (int __loop = 0; __loop < 4; __loop++) {
- for (__i = 0; __i < 55; __i++)
- _M_table[__i] = _M_table[__i] - _M_table[(1 + __i + 30) % 55];
- }
- _M_index1 = 0;
- _M_index2 = 31;
- }
-
- /// Ctor allowing you to initialize the seed.
- subtractive_rng(unsigned int __seed) { _M_initialize(__seed); }
- /// Default ctor; initializes its state with some number you don't see.
- subtractive_rng() { _M_initialize(161803398u); }
-};
-
-
// 20.3.8 adaptors pointers members
/** @defgroup s20_3_8_memadaptors Adaptors for pointers to members
* There are a total of 16 = 2^4 function objects in this family.
// Mem_fun adaptor helper functions. There are only two:
-// mem_fun and mem_fun_ref. (mem_fun1 and mem_fun1_ref
-// are provided for backward compatibility, but they are no longer
-// part of the C++ standard.)
+// mem_fun and mem_fun_ref.
template <class _Ret, class _Tp>
inline mem_fun_t<_Ret,_Tp> mem_fun(_Ret (_Tp::*__f)())
mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const)
{ return const_mem_fun1_ref_t<_Ret,_Tp,_Arg>(__f); }
-template <class _Ret, class _Tp, class _Arg>
-inline mem_fun1_t<_Ret,_Tp,_Arg> mem_fun1(_Ret (_Tp::*__f)(_Arg))
- { return mem_fun1_t<_Ret,_Tp,_Arg>(__f); }
-
-template <class _Ret, class _Tp, class _Arg>
-inline const_mem_fun1_t<_Ret,_Tp,_Arg> mem_fun1(_Ret (_Tp::*__f)(_Arg) const)
- { return const_mem_fun1_t<_Ret,_Tp,_Arg>(__f); }
-
-template <class _Ret, class _Tp, class _Arg>
-inline mem_fun1_ref_t<_Ret,_Tp,_Arg> mem_fun1_ref(_Ret (_Tp::*__f)(_Arg))
- { return mem_fun1_ref_t<_Ret,_Tp,_Arg>(__f); }
-
-template <class _Ret, class _Tp, class _Arg>
-inline const_mem_fun1_ref_t<_Ret,_Tp,_Arg>
-mem_fun1_ref(_Ret (_Tp::*__f)(_Arg) const)
- { return const_mem_fun1_ref_t<_Ret,_Tp,_Arg>(__f); }
/** @} */
} // namespace std
return ++__result;
}
- // Returns __x ** __n, where __n >= 0. _Note that "multiplication"
- // is required to be associative, but not necessarily commutative.
-
-
- template<typename _Tp, typename _Integer, typename _MonoidOperation>
- _Tp
- __power(_Tp __x, _Integer __n, _MonoidOperation __monoid_op)
- {
- if (__n == 0)
- return identity_element(__monoid_op);
- else {
- while ((__n & 1) == 0) {
- __n >>= 1;
- __x = __monoid_op(__x, __x);
- }
-
- _Tp __result = __x;
- __n >>= 1;
- while (__n != 0) {
- __x = __monoid_op(__x, __x);
- if ((__n & 1) != 0)
- __result = __monoid_op(__result, __x);
- __n >>= 1;
- }
- return __result;
- }
- }
-
- template<typename _Tp, typename _Integer>
- inline _Tp
- __power(_Tp __x, _Integer __n)
- { return __power(__x, __n, multiplies<_Tp>()); }
-
- // Alias for the internal name __power. Note that power is an extension,
- // not part of the C++ standard.
-
- template<typename _Tp, typename _Integer, typename _MonoidOperation>
- inline _Tp
- power(_Tp __x, _Integer __n, _MonoidOperation __monoid_op)
- { return __power(__x, __n, __monoid_op); }
-
- template<typename _Tp, typename _Integer>
- inline _Tp
- power(_Tp __x, _Integer __n)
- { return __power(__x, __n); }
-
- // iota is not part of the C++ standard. It is an extension.
-
- template<typename _ForwardIter, typename _Tp>
- void
- iota(_ForwardIter __first, _ForwardIter __last, _Tp __value)
- {
- // concept requirements
- __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter>)
- __glibcpp_function_requires(_ConvertibleConcept<_Tp,
- typename iterator_traits<_ForwardIter>::value_type>)
-
- while (__first != __last)
- *__first++ = __value++;
- }
-
} // namespace std
#endif /* _CPP_BITS_STL_NUMERIC_H */
--- /dev/null
+// Functional extensions -*- C++ -*-
+
+// Copyright (C) 2002 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING. If not, write to the Free
+// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction. Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License. This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation. Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose. It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation. Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose. It is provided "as is" without express or implied warranty.
+ */
+
+#ifndef _EXT_FUNCTIONAL
+#define _EXT_FUNCTIONAL
+
+#pragma GCC system_header
+#include <bits/std_functional.h>
+
+namespace __gnu_cxx
+{
+using std::unary_function;
+using std::binary_function;
+using std::mem_fun1_t;
+using std::const_mem_fun1_t;
+using std::mem_fun1_ref_t;
+using std::const_mem_fun1_ref_t;
+
+/** The @c identity_element functions are not part of the C++ standard; SGI
+ * provided them as an extension. Its argument is an operation, and its
+ * return value is the identity element for that operation. It is overloaded
+ * for addition and multiplication, and you can overload it for your own
+ * nefarious operations.
+ *
+ * @addtogroup SGIextensions
+ * @{
+*/
+/// An \link SGIextensions SGI extension \endlink.
+template <class _Tp> inline _Tp identity_element(std::plus<_Tp>) {
+ return _Tp(0);
+}
+/// An \link SGIextensions SGI extension \endlink.
+template <class _Tp> inline _Tp identity_element(std::multiplies<_Tp>) {
+ return _Tp(1);
+}
+/** @} */
+
+/** As an extension to the binders, SGI provided composition functors and
+ * wrapper functions to aid in their creation. The @c unary_compose
+ * functor is constructed from two functions/functors, @c f and @c g.
+ * Calling @c operator() with a single argument @c x returns @c f(g(x)).
+ * The function @c compose1 takes the two functions and constructs a
+ * @c unary_compose variable for you.
+ *
+ * @c binary_compose is constructed from three functors, @c f, @c g1,
+ * and @c g2. Its @c operator() returns @c f(g1(x),g2(x)). The function
+ * @compose2 takes f, g1, and g2, and constructs the @c binary_compose
+ * instance for you. For example, if @c f returns an int, then
+ * \code
+ * int answer = (compose2(f,g1,g2))(x);
+ * \endcode
+ * is equivalent to
+ * \code
+ * int temp1 = g1(x);
+ * int temp2 = g2(x);
+ * int answer = f(temp1,temp2);
+ * \endcode
+ * But the first form is more compact, and can be passed around as a
+ * functor to other algorithms.
+ *
+ * @addtogroup SGIextensions
+ * @{
+*/
+/// An \link SGIextensions SGI extension \endlink.
+template <class _Operation1, class _Operation2>
+class unary_compose
+ : public unary_function<typename _Operation2::argument_type,
+ typename _Operation1::result_type>
+{
+protected:
+ _Operation1 _M_fn1;
+ _Operation2 _M_fn2;
+public:
+ unary_compose(const _Operation1& __x, const _Operation2& __y)
+ : _M_fn1(__x), _M_fn2(__y) {}
+ typename _Operation1::result_type
+ operator()(const typename _Operation2::argument_type& __x) const {
+ return _M_fn1(_M_fn2(__x));
+ }
+};
+
+/// An \link SGIextensions SGI extension \endlink.
+template <class _Operation1, class _Operation2>
+inline unary_compose<_Operation1,_Operation2>
+compose1(const _Operation1& __fn1, const _Operation2& __fn2)
+{
+ return unary_compose<_Operation1,_Operation2>(__fn1, __fn2);
+}
+
+/// An \link SGIextensions SGI extension \endlink.
+template <class _Operation1, class _Operation2, class _Operation3>
+class binary_compose
+ : public unary_function<typename _Operation2::argument_type,
+ typename _Operation1::result_type> {
+protected:
+ _Operation1 _M_fn1;
+ _Operation2 _M_fn2;
+ _Operation3 _M_fn3;
+public:
+ binary_compose(const _Operation1& __x, const _Operation2& __y,
+ const _Operation3& __z)
+ : _M_fn1(__x), _M_fn2(__y), _M_fn3(__z) { }
+ typename _Operation1::result_type
+ operator()(const typename _Operation2::argument_type& __x) const {
+ return _M_fn1(_M_fn2(__x), _M_fn3(__x));
+ }
+};
+
+/// An \link SGIextensions SGI extension \endlink.
+template <class _Operation1, class _Operation2, class _Operation3>
+inline binary_compose<_Operation1, _Operation2, _Operation3>
+compose2(const _Operation1& __fn1, const _Operation2& __fn2,
+ const _Operation3& __fn3)
+{
+ return binary_compose<_Operation1,_Operation2,_Operation3>
+ (__fn1, __fn2, __fn3);
+}
+/** @} */
+
+/** As an extension, SGI provided a functor called @c identity. When a
+ * functor is required but no operations are desired, this can be used as a
+ * pass-through. Its @c operator() returns its argument unchanged.
+ *
+ * @addtogroup SGIextensions
+*/
+template <class _Tp> struct identity : public std::_Identity<_Tp> {};
+
+/** @c select1st and @c select2nd are extensions provided by SGI. Their
+ * @c operator()s
+ * take a @c std::pair as an argument, and return either the first member
+ * or the second member, respectively. They can be used (especially with
+ * the composition functors) to "strip" data from a sequence before
+ * performing the remainder of an algorithm.
+ *
+ * @addtogroup SGIextensions
+ * @{
+*/
+/// An \link SGIextensions SGI extension \endlink.
+template <class _Pair> struct select1st : public std::_Select1st<_Pair> {};
+/// An \link SGIextensions SGI extension \endlink.
+template <class _Pair> struct select2nd : public std::_Select2nd<_Pair> {};
+/** @} */
+
+// extension documented next
+template <class _Arg1, class _Arg2>
+struct _Project1st : public binary_function<_Arg1, _Arg2, _Arg1> {
+ _Arg1 operator()(const _Arg1& __x, const _Arg2&) const { return __x; }
+};
+
+template <class _Arg1, class _Arg2>
+struct _Project2nd : public binary_function<_Arg1, _Arg2, _Arg2> {
+ _Arg2 operator()(const _Arg1&, const _Arg2& __y) const { return __y; }
+};
+
+/** The @c operator() of the @c project1st functor takes two arbitrary
+ * arguments and returns the first one, while @c project2nd returns the
+ * second one. They are extensions provided by SGI.
+ *
+ * @addtogroup SGIextensions
+ * @{
+*/
+
+/// An \link SGIextensions SGI extension \endlink.
+template <class _Arg1, class _Arg2>
+struct project1st : public _Project1st<_Arg1, _Arg2> {};
+
+/// An \link SGIextensions SGI extension \endlink.
+template <class _Arg1, class _Arg2>
+struct project2nd : public _Project2nd<_Arg1, _Arg2> {};
+/** @} */
+
+// extension documented next
+template <class _Result>
+struct _Constant_void_fun {
+ typedef _Result result_type;
+ result_type _M_val;
+
+ _Constant_void_fun(const result_type& __v) : _M_val(__v) {}
+ const result_type& operator()() const { return _M_val; }
+};
+
+template <class _Result, class _Argument>
+struct _Constant_unary_fun {
+ typedef _Argument argument_type;
+ typedef _Result result_type;
+ result_type _M_val;
+
+ _Constant_unary_fun(const result_type& __v) : _M_val(__v) {}
+ const result_type& operator()(const _Argument&) const { return _M_val; }
+};
+
+template <class _Result, class _Arg1, class _Arg2>
+struct _Constant_binary_fun {
+ typedef _Arg1 first_argument_type;
+ typedef _Arg2 second_argument_type;
+ typedef _Result result_type;
+ _Result _M_val;
+
+ _Constant_binary_fun(const _Result& __v) : _M_val(__v) {}
+ const result_type& operator()(const _Arg1&, const _Arg2&) const {
+ return _M_val;
+ }
+};
+
+/** These three functors are each constructed from a single arbitrary
+ * variable/value. Later, their @c operator()s completely ignore any
+ * arguments passed, and return the stored value.
+ * - @c constant_void_fun's @c operator() takes no arguments
+ * - @c constant_unary_fun's @c operator() takes one argument (ignored)
+ * - @c constant_binary_fun's @c operator() takes two arguments (ignored)
+ *
+ * The helper creator functions @c constant0, @c constant1, and
+ * @c constant2 each take a "result" argument and construct variables of
+ * the appropriate functor type.
+ *
+ * @addtogroup SGIextensions
+ * @{
+*/
+/// An \link SGIextensions SGI extension \endlink.
+template <class _Result>
+struct constant_void_fun : public _Constant_void_fun<_Result> {
+ constant_void_fun(const _Result& __v) : _Constant_void_fun<_Result>(__v) {}
+};
+
+/// An \link SGIextensions SGI extension \endlink.
+template <class _Result,
+ class _Argument = _Result>
+struct constant_unary_fun : public _Constant_unary_fun<_Result, _Argument>
+{
+ constant_unary_fun(const _Result& __v)
+ : _Constant_unary_fun<_Result, _Argument>(__v) {}
+};
+
+/// An \link SGIextensions SGI extension \endlink.
+template <class _Result,
+ class _Arg1 = _Result,
+ class _Arg2 = _Arg1>
+struct constant_binary_fun
+ : public _Constant_binary_fun<_Result, _Arg1, _Arg2>
+{
+ constant_binary_fun(const _Result& __v)
+ : _Constant_binary_fun<_Result, _Arg1, _Arg2>(__v) {}
+};
+
+/// An \link SGIextensions SGI extension \endlink.
+template <class _Result>
+inline constant_void_fun<_Result> constant0(const _Result& __val)
+{
+ return constant_void_fun<_Result>(__val);
+}
+
+/// An \link SGIextensions SGI extension \endlink.
+template <class _Result>
+inline constant_unary_fun<_Result,_Result> constant1(const _Result& __val)
+{
+ return constant_unary_fun<_Result,_Result>(__val);
+}
+
+/// An \link SGIextensions SGI extension \endlink.
+template <class _Result>
+inline constant_binary_fun<_Result,_Result,_Result>
+constant2(const _Result& __val)
+{
+ return constant_binary_fun<_Result,_Result,_Result>(__val);
+}
+/** @} */
+
+/** The @c subtractive_rng class is documented on
+ * <a href="http://www.sgi.com/tech/stl/">SGI's site</a>.
+ * Note that this code assumes that @c int is 32 bits.
+ *
+ * @ingroup SGIextensions
+*/
+class subtractive_rng : public unary_function<unsigned int, unsigned int> {
+private:
+ unsigned int _M_table[55];
+ size_t _M_index1;
+ size_t _M_index2;
+public:
+ /// Returns a number less than the argument.
+ unsigned int operator()(unsigned int __limit) {
+ _M_index1 = (_M_index1 + 1) % 55;
+ _M_index2 = (_M_index2 + 1) % 55;
+ _M_table[_M_index1] = _M_table[_M_index1] - _M_table[_M_index2];
+ return _M_table[_M_index1] % __limit;
+ }
+
+ void _M_initialize(unsigned int __seed)
+ {
+ unsigned int __k = 1;
+ _M_table[54] = __seed;
+ size_t __i;
+ for (__i = 0; __i < 54; __i++) {
+ size_t __ii = (21 * (__i + 1) % 55) - 1;
+ _M_table[__ii] = __k;
+ __k = __seed - __k;
+ __seed = _M_table[__ii];
+ }
+ for (int __loop = 0; __loop < 4; __loop++) {
+ for (__i = 0; __i < 55; __i++)
+ _M_table[__i] = _M_table[__i] - _M_table[(1 + __i + 30) % 55];
+ }
+ _M_index1 = 0;
+ _M_index2 = 31;
+ }
+
+ /// Ctor allowing you to initialize the seed.
+ subtractive_rng(unsigned int __seed) { _M_initialize(__seed); }
+ /// Default ctor; initializes its state with some number you don't see.
+ subtractive_rng() { _M_initialize(161803398u); }
+};
+
+// Mem_fun adaptor helper functions mem_fun1 and mem_fun1_ref,
+// provided for backward compatibility, they are no longer part of
+// the C++ standard.
+
+template <class _Ret, class _Tp, class _Arg>
+inline mem_fun1_t<_Ret,_Tp,_Arg> mem_fun1(_Ret (_Tp::*__f)(_Arg))
+ { return mem_fun1_t<_Ret,_Tp,_Arg>(__f); }
+
+template <class _Ret, class _Tp, class _Arg>
+inline const_mem_fun1_t<_Ret,_Tp,_Arg> mem_fun1(_Ret (_Tp::*__f)(_Arg) const)
+ { return const_mem_fun1_t<_Ret,_Tp,_Arg>(__f); }
+
+template <class _Ret, class _Tp, class _Arg>
+inline mem_fun1_ref_t<_Ret,_Tp,_Arg> mem_fun1_ref(_Ret (_Tp::*__f)(_Arg))
+ { return mem_fun1_ref_t<_Ret,_Tp,_Arg>(__f); }
+
+template <class _Ret, class _Tp, class _Arg>
+inline const_mem_fun1_ref_t<_Ret,_Tp,_Arg>
+mem_fun1_ref(_Ret (_Tp::*__f)(_Arg) const)
+ { return const_mem_fun1_ref_t<_Ret,_Tp,_Arg>(__f); }
+
+} // namespace __gnu_cxx
+
+#endif /* _EXT_FUNCTIONAL */
+
--- /dev/null
+// Numeric extensions -*- C++ -*-
+
+// Copyright (C) 2002 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING. If not, write to the Free
+// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction. Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License. This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation. Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose. It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation. Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose. It is provided "as is" without express or implied warranty.
+ */
+
+#ifndef _EXT_NUMERIC
+#define _EXT_NUMERIC
+
+#pragma GCC system_header
+#include <bits/concept_check.h>
+#include <bits/std_numeric.h>
+
+#include <ext/functional> // For identity_element
+
+namespace __gnu_cxx
+{
+ // Returns __x ** __n, where __n >= 0. _Note that "multiplication"
+ // is required to be associative, but not necessarily commutative.
+
+ template<typename _Tp, typename _Integer, typename _MonoidOperation>
+ _Tp
+ __power(_Tp __x, _Integer __n, _MonoidOperation __monoid_op)
+ {
+ if (__n == 0)
+ return identity_element(__monoid_op);
+ else {
+ while ((__n & 1) == 0) {
+ __n >>= 1;
+ __x = __monoid_op(__x, __x);
+ }
+
+ _Tp __result = __x;
+ __n >>= 1;
+ while (__n != 0) {
+ __x = __monoid_op(__x, __x);
+ if ((__n & 1) != 0)
+ __result = __monoid_op(__result, __x);
+ __n >>= 1;
+ }
+ return __result;
+ }
+ }
+
+ template<typename _Tp, typename _Integer>
+ inline _Tp
+ __power(_Tp __x, _Integer __n)
+ { return __power(__x, __n, std::multiplies<_Tp>()); }
+
+ // Alias for the internal name __power. Note that power is an extension,
+ // not part of the C++ standard.
+
+ template<typename _Tp, typename _Integer, typename _MonoidOperation>
+ inline _Tp
+ power(_Tp __x, _Integer __n, _MonoidOperation __monoid_op)
+ { return __power(__x, __n, __monoid_op); }
+
+ template<typename _Tp, typename _Integer>
+ inline _Tp
+ power(_Tp __x, _Integer __n)
+ { return __power(__x, __n); }
+
+ // iota is not part of the C++ standard. It is an extension.
+
+ template<typename _ForwardIter, typename _Tp>
+ void
+ iota(_ForwardIter __first, _ForwardIter __last, _Tp __value)
+ {
+ // concept requirements
+ __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter>)
+ __glibcpp_function_requires(_ConvertibleConcept<_Tp,
+ typename std::iterator_traits<_ForwardIter>::value_type>)
+
+ while (__first != __last)
+ *__first++ = __value++;
+ }
+
+} // namespace __gnu_cxx
+
+#endif /* _EXT_NUMERIC */
+
#include <ext/algorithm> // For copy_n and lexicographical_compare_3way
#include <ext/memory> // For uninitialized_copy_n
+#include <ext/numeric> // For power
namespace __gnu_cxx
{
// subdirectory that are meant to be directly included.
#include <ext/algorithm>
+#include <ext/functional>
#include <ext/hash_map>
#include <ext/hash_set>
#include <ext/iterator>
#include <ext/memory>
+#include <ext/numeric>
#include <ext/rope>
#include <ext/slist>