[PATCH] HP/SGI extensions to ext/functional-numeric (+ valarray problem)

Paolo Carlini pcarlini@unitus.it
Wed Jan 2 13:07:00 GMT 2002


Hi,

this is the next round. In fact we are almost done, only a few bits belonging to
stl_tempbuf.h and stl_tree.h still are to be dealt with. Do you have any
particula suggestion for the most suited ext/ name? Perhaps ext/misc ?

The reason why I'm CC-ing Gaby too is that today, after a dozen of patches to
the C++ front-end by Nathan Sidwell, I'm seeing a couple of regressions in
valarray tests, in particular, binary_closure.cc and valarray.cc (of course both
with and *without* the present patch). Both those tests fail to build. For
instance, for valarray.cc:

/usr/local/gcc-temp/include/g++-v3/bits/valarray_meta.h: In function
   `std::_Expr<std::_BinClos<std::minus, std::_ValArray, std::_ValArray, _Tp,
   _Tp>, _Tp> std::operator-(const std::valarray<_Tp>&, const
   std::valarray<_Tp>&) [with _Tp = double]':
valarray.cc:40:   instantiated from here
/usr/local/gcc-temp/include/g++-v3/bits/valarray_meta.h:444: `
   std::_BinClos<_Oper, std::_ValArray, std::_ValArray, _Tp,
   _Tp>::_BinClos(const std::valarray<_Tp>&, const std::valarray<_Tp>&) [with
   _Oper = std::minus, _Tp = double]' is private
/usr/local/gcc-temp/include/g++-v3/bits/std_valarray.h:688: within this context
/usr/local/gcc-temp/include/g++-v3/bits/valarray_meta.h: In function
   `std::_Expr<std::_UnFunClos<std::_Expr, _Dom>, typename _Dom::value_type>
   std::abs(const std::_Expr<_Dom1, typename _Dom1::value_type>&) [with _Dom =
   std::_BinClos<std::minus, std::_ValArray, std::_ValArray, double, double>]':
valarray.cc:40:   instantiated from here
/usr/local/gcc-temp/include/g++-v3/bits/valarray_meta.h:86: `
   std::_UnFunClos<std::_Expr, _Dom>::_UnFunClos(const _Dom&, typename
   std::_UnFunBase<_Dom>::value_type (*)(typename
   std::_UnFunBase<_Dom>::value_type)) [with _Dom = std::_BinClos<std::minus,
   std::_ValArray, std::_ValArray, double, double>]' is private
/usr/local/gcc-temp/include/g++-v3/bits/valarray_meta.h:958: within this
   context

Is anyone able to reproduce this? I hope so!

Anyway, these are my tentative Changelog and the patch:

2002-01-02  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>.

diff -urN libstdc++-v3-orig/include/Makefile.am libstdc++-v3/include/Makefile.am

--- libstdc++-v3-orig/include/Makefile.am Tue Jan  1 11:56:58 2002
+++ libstdc++-v3/include/Makefile.am Wed Jan  2 13:48:38 2002
@@ -173,10 +173,12 @@
 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 \
diff -urN libstdc++-v3-orig/include/Makefile.in libstdc++-v3/include/Makefile.in

--- libstdc++-v3-orig/include/Makefile.in Tue Jan  1 11:58:22 2002
+++ libstdc++-v3/include/Makefile.in Wed Jan  2 14:44:52 2002
@@ -303,10 +303,12 @@
 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 \
diff -urN libstdc++-v3-orig/include/backward/algo.h
libstdc++-v3/include/backward/algo.h
--- libstdc++-v3-orig/include/backward/algo.h Mon Dec 31 17:48:05 2001
+++ libstdc++-v3/include/backward/algo.h Wed Jan  2 14:29:52 2002
@@ -63,6 +63,7 @@
 #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;
@@ -128,8 +129,6 @@
 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;
@@ -138,6 +137,10 @@
 using __gnu_cxx::is_heap;
 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 */

diff -urN libstdc++-v3-orig/include/backward/function.h
libstdc++-v3/include/backward/function.h
--- libstdc++-v3-orig/include/backward/function.h Wed Jun 27 19:09:52 2001
+++ libstdc++-v3/include/backward/function.h Wed Jan  2 14:35:00 2002
@@ -60,6 +60,7 @@
 #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;
@@ -68,7 +69,6 @@
 using std::minus;
 using std::multiplies;
 using std::divides;
-using std::identity_element;
 using std::modulus;
 using std::negate;
 using std::equal_to;
@@ -88,25 +88,9 @@
 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;
@@ -117,8 +101,27 @@
 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 */

diff -urN libstdc++-v3-orig/include/bits/stl_function.h
libstdc++-v3/include/bits/stl_function.h
--- libstdc++-v3-orig/include/bits/stl_function.h Thu Dec  6 21:29:31 2001
+++ libstdc++-v3/include/bits/stl_function.h Wed Jan  2 14:10:04 2002
@@ -162,25 +162,6 @@
 };
 /** @}  */

-/** 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
@@ -433,88 +414,6 @@
 }
 /** @}  */

-/** 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
@@ -576,23 +475,12 @@
 }
 /** @}  */

-
-// 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 {
@@ -614,191 +502,6 @@
   }
 };

-/** @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.
@@ -989,9 +692,7 @@


 // 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)())
@@ -1026,22 +727,6 @@
 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
diff -urN libstdc++-v3-orig/include/bits/stl_numeric.h
libstdc++-v3/include/bits/stl_numeric.h
--- libstdc++-v3-orig/include/bits/stl_numeric.h Fri Nov  2 18:38:11 2001
+++ libstdc++-v3/include/bits/stl_numeric.h Wed Jan  2 13:46:55 2002
@@ -206,67 +206,6 @@
       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 */
diff -urN libstdc++-v3-orig/include/ext/CVS/Entries
libstdc++-v3/include/ext/CVS/Entries
--- libstdc++-v3-orig/include/ext/CVS/Entries Wed Jan  2 13:16:21 2002
+++ libstdc++-v3/include/ext/CVS/Entries Wed Jan  2 13:40:12 2002
@@ -9,4 +9,6 @@
 /memory/1.1/Tue Jan  1 19:33:08 2002//
 /ropeimpl.h/1.13/Tue Jan  1 10:53:47 2002//
 /stl_rope.h/1.15/Tue Jan  1 10:54:34 2002//
+/functional/0/dummy timestamp//
+/numeric/0/dummy timestamp//
 D
diff -urN libstdc++-v3-orig/include/ext/functional
libstdc++-v3/include/ext/functional
--- libstdc++-v3-orig/include/ext/functional Thu Jan  1 01:00:00 1970
+++ libstdc++-v3/include/ext/functional Wed Jan  2 15:28:43 2002
@@ -0,0 +1,389 @@
+// 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 */
+
diff -urN libstdc++-v3-orig/include/ext/numeric libstdc++-v3/include/ext/numeric

--- libstdc++-v3-orig/include/ext/numeric Thu Jan  1 01:00:00 1970
+++ libstdc++-v3/include/ext/numeric Wed Jan  2 15:29:51 2002
@@ -0,0 +1,130 @@
+// 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 */
+
diff -urN libstdc++-v3-orig/include/ext/ropeimpl.h
libstdc++-v3/include/ext/ropeimpl.h
--- libstdc++-v3-orig/include/ext/ropeimpl.h Tue Jan  1 11:53:47 2002
+++ libstdc++-v3/include/ext/ropeimpl.h Wed Jan  2 14:49:42 2002
@@ -51,6 +51,7 @@

 #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
 {
diff -urN libstdc++-v3-orig/testsuite/ext/headers.cc
libstdc++-v3/testsuite/ext/headers.cc
--- libstdc++-v3-orig/testsuite/ext/headers.cc Tue Jan  1 12:03:11 2002
+++ libstdc++-v3/testsuite/ext/headers.cc Wed Jan  2 14:44:02 2002
@@ -24,10 +24,12 @@
 // 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>





More information about the Libstdc++ mailing list