stl_algo.h (__median, [...]): Doxygenate.

2002-02-10  Jonathan Wakely  <cow@compsoc.man.ac.uk>

	* include/bits/stl_algo.h (__median, for_each, find, find_if,
	adjacent_find, count, count_if, search, search_n, swap_ranges,
	transform, replace, replace_if, replace_copy, replace_copy_if,
	generate, generate_n, remove_copy, remove_copy_if, remove, remove_if,
	unique, unique_copy, reverse, reverse_copy):  Doxygenate.

From-SVN: r49652

libstdc++-v3/ChangeLog

+2002-02-10  Jonathan Wakely  <cow@compsoc.man.ac.uk>
+
+	* include/bits/stl_algo.h (__median, for_each, find, find_if,
+	adjacent_find, count, count_if, search, search_n, swap_ranges,
+	transform, replace, replace_if, replace_copy, replace_copy_if,
+	generate, generate_n, remove_copy, remove_copy_if, remove, remove_if,
+	unique, unique_copy, reverse, reverse_copy):  Doxygenate.
+
 2002-02-08   Benjamin Kosnik  <bkoz@redhat.com>
 
 	* include/bits/locale_facets.h

libstdc++-v3/include/bits/stl_algo.h

-// Algorithm implimentation -*- C++ -*-
+// Algorithm implementation -*- C++ -*-
 
 // Copyright (C) 2001, 2002 Free Software Foundation, Inc.
 //
@@ -69,8 +69,18 @@
 namespace std
 {
 
-  // __median (an extension, not present in the C++ standard).
-
+  /**
+   *  @brief Find the median of three values.
+   *  @param  a  A value.
+   *  @param  b  A value.
+   *  @param  c  A value.
+   *  @return One of @p a, @p b or @p c.
+   *
+   *  If @c {l,m,n} is some convolution of @p {a,b,c} such that @c l<=m<=n
+   *  then the value returned will be @c m.
+   *  This is an SGI extension.
+   *  @ingroup SGIextensions
+  */
   template<typename _Tp>
   inline const _Tp&
     __median(const _Tp& __a, const _Tp& __b, const _Tp& __c)
@@ -92,6 +102,19 @@ namespace std
 	return __b;
     }
 
+  /**
+   *  @brief Find the median of three values using a predicate for comparison.
+   *  @param  a     A value.
+   *  @param  b     A value.
+   *  @param  c     A value.
+   *  @param  comp  A binary predicate.
+   *  @return One of @p a, @p b or @p c.
+   *
+   *  If @c {l,m,n} is some convolution of @p {a,b,c} such that @p comp(l,m)
+   *  and @p comp(m,n) are both true then the value returned will be @c m.
+   *  This is an SGI extension.
+   *  @ingroup SGIextensions
+  */
   template<typename _Tp, typename _Compare>
     inline const _Tp&
     __median(const _Tp& __a, const _Tp& __b, const _Tp& __c, _Compare __comp)
@@ -113,7 +136,18 @@ namespace std
 	return __b;
     }
 
-  // for_each.  Apply a function to every element of a range.
+  /**
+   *  @brief Apply a function to every element of a sequence.
+   *  @param  first  An input iterator.
+   *  @param  last   An input iterator.
+   *  @param  f      A unary function object.
+   *  @return   @p f.
+   *
+   *  Applies the function object @p f to each element in the range
+   *  @p [first,last).
+   *  @p f must not modify its argument.
+   *  If @p f has a return value it is ignored.
+  */
   template<typename _InputIter, typename _Function>
     _Function
     for_each(_InputIter __first, _InputIter __last, _Function __f)
@@ -125,8 +159,11 @@ namespace std
       return __f;
     }
 
-  // find and find_if.
-
+  /**
+   *  @maint
+   *  This is an overload used by find() for the Input Iterator case.
+   *  @endmaint
+  */
   template<typename _InputIter, typename _Tp>
     inline _InputIter
     find(_InputIter __first, _InputIter __last,
@@ -138,6 +175,11 @@ namespace std
       return __first;
     }
 
+  /**
+   *  @maint
+   *  This is an overload used by find_if() for the Input Iterator case.
+   *  @endmaint
+  */
   template<typename _InputIter, typename _Predicate>
     inline _InputIter
     find_if(_InputIter __first, _InputIter __last,
@@ -149,6 +191,11 @@ namespace std
       return __first;
     }
 
+  /**
+   *  @maint
+   *  This is an overload used by find() for the RAI case.
+   *  @endmaint
+  */
   template<typename _RandomAccessIter, typename _Tp>
     _RandomAccessIter
     find(_RandomAccessIter __first, _RandomAccessIter __last,
@@ -188,6 +235,11 @@ namespace std
       }
     }
 
+  /**
+   *  @maint
+   *  This is an overload used by find_if() for the RAI case.
+   *  @endmaint
+  */
   template<typename _RandomAccessIter, typename _Predicate>
     _RandomAccessIter
     find_if(_RandomAccessIter __first, _RandomAccessIter __last,
@@ -227,6 +279,14 @@ namespace std
       }
     }
 
+  /**
+   *  @brief Find the first occurrence of a value in a sequence.
+   *  @param  first  An input iterator.
+   *  @param  last   An input iterator.
+   *  @param  val    The value to find.
+   *  @return   The first iterator @c i in the range @p [first,last)
+   *  such that @c *i == @p val, or @p last if no such iterator exists.
+  */
   template<typename _InputIter, typename _Tp>
     inline _InputIter
     find(_InputIter __first, _InputIter __last,
@@ -239,6 +299,14 @@ namespace std
       return find(__first, __last, __val, __iterator_category(__first));
     }
 
+  /**
+   *  @brief Find the first element in a sequence for which a predicate is true.
+   *  @param  first  An input iterator.
+   *  @param  last   An input iterator.
+   *  @param  pred   A predicate.
+   *  @return   The first iterator @c i in the range @p [first,last)
+   *  such that @p pred(*i) is true, or @p last if no such iterator exists.
+  */
   template<typename _InputIter, typename _Predicate>
     inline _InputIter
     find_if(_InputIter __first, _InputIter __last,
@@ -251,8 +319,14 @@ namespace std
       return find_if(__first, __last, __pred, __iterator_category(__first));
     }
 
-  // adjacent_find.
-
+  /**
+   *  @brief Find two adjacent values in a sequence that are equal.
+   *  @param  first  A forward iterator.
+   *  @param  last   A forward iterator.
+   *  @return   The first iterator @c i such that @c i and @c i+1 are both
+   *  valid iterators in @p [first,last) and such that @c *i == @c *(i+1),
+   *  or @p last if no such iterator exists.
+  */
   template<typename _ForwardIter>
     _ForwardIter
     adjacent_find(_ForwardIter __first, _ForwardIter __last)
@@ -272,6 +346,16 @@ namespace std
       return __last;
     }
 
+  /**
+   *  @brief Find two adjacent values in a sequence using a predicate.
+   *  @param  first         A forward iterator.
+   *  @param  last          A forward iterator.
+   *  @param  binary_pred   A binary predicate.
+   *  @return   The first iterator @c i such that @c i and @c i+1 are both
+   *  valid iterators in @p [first,last) and such that
+   *  @p binary_pred(*i,*(i+1)) is true, or @p last if no such iterator
+   *  exists.
+  */
   template<typename _ForwardIter, typename _BinaryPredicate>
     _ForwardIter
     adjacent_find(_ForwardIter __first, _ForwardIter __last,
@@ -293,8 +377,14 @@ namespace std
       return __last;
     }
 
-  // count and count_if.
-
+  /**
+   *  @brief Count the number of copies of a value in a sequence.
+   *  @param  first  An input iterator.
+   *  @param  last   An input iterator.
+   *  @param  value  The value to be counted.
+   *  @return   The number of iterators @c i in the range @p [first,last)
+   *  for which @c *i == @p value
+  */
   template<typename _InputIter, typename _Tp>
     typename iterator_traits<_InputIter>::difference_type
     count(_InputIter __first, _InputIter __last, const _Tp& __value)
@@ -311,6 +401,14 @@ namespace std
       return __n;
     }
 
+  /**
+   *  @brief Count the elements of a sequence for which a predicate is true.
+   *  @param  first  An input iterator.
+   *  @param  last   An input iterator.
+   *  @param  pred   A predicate.
+   *  @return   The number of iterators @c i in the range @p [first,last)
+   *  for which @p pred(*i) is true.
+  */
   template<typename _InputIter, typename _Predicate>
     typename iterator_traits<_InputIter>::difference_type
     count_if(_InputIter __first, _InputIter __last, _Predicate __pred)
@@ -327,8 +425,29 @@ namespace std
     }
 
 
-  // search.
-
+  /**
+   *  @brief Search a sequence for a matching sub-sequence.
+   *  @param  first1  A forward iterator.
+   *  @param  last1   A forward iterator.
+   *  @param  first2  A forward iterator.
+   *  @param  last2   A forward iterator.
+   *  @return   The first iterator @c i in the range
+   *  @p [first1,last1-(last2-first2)) such that @c *(i+N) == @p *(first2+N)
+   *  for each @c N in the range @p [0,last2-first2), or @p last1 if no
+   *  such iterator exists.
+   *
+   *  Searches the range @p [first1,last1) for a sub-sequence that compares
+   *  equal value-by-value with the sequence given by @p [first2,last2) and
+   *  returns an iterator to the first element of the sub-sequence, or
+   *  @p last1 if the sub-sequence is not found.
+   *
+   *  Because the sub-sequence must lie completely within the range
+   *  @p [first1,last1) it must start at a position less than
+   *  @p last1-(last2-first2) where @p last2-first2 is the length of the
+   *  sub-sequence.
+   *  This means that the returned iterator @c i will be in the range
+   *  @p [first1,last1-(last2-first2))
+  */
   template<typename _ForwardIter1, typename _ForwardIter2>
     _ForwardIter1
     search(_ForwardIter1 __first1, _ForwardIter1 __last1,
@@ -381,6 +500,26 @@ namespace std
       return __first1;
     }
 
+  /**
+   *  @brief Search a sequence for a matching sub-sequence using a predicate.
+   *  @param  first1     A forward iterator.
+   *  @param  last1      A forward iterator.
+   *  @param  first2     A forward iterator.
+   *  @param  last2      A forward iterator.
+   *  @param  predicate  A binary predicate.
+   *  @return   The first iterator @c i in the range
+   *  @p [first1,last1-(last2-first2)) such that
+   *  @p predicate(*(i+N),*(first2+N)) is true for each @c N in the range
+   *  @p [0,last2-first2), or @p last1 if no such iterator exists.
+   *
+   *  Searches the range @p [first1,last1) for a sub-sequence that compares
+   *  equal value-by-value with the sequence given by @p [first2,last2),
+   *  using @p predicate to determine equality, and returns an iterator
+   *  to the first element of the sub-sequence, or @p last1 if no such
+   *  iterator exists.
+   *
+   *  @see search(_ForwardIter1, _ForwardIter1, _ForwardIter2, _ForwardIter2)
+  */
   template<typename _ForwardIter1, typename _ForwardIter2, typename _BinaryPred>
     _ForwardIter1
     search(_ForwardIter1 __first1, _ForwardIter1 __last1,
@@ -442,8 +581,19 @@ namespace std
       return __first1;
     }
 
-  // search_n.  Search for __count consecutive copies of __val.
-
+  /**
+   *  @brief Search a sequence for a number of consecutive values.
+   *  @param  first  A forward iterator.
+   *  @param  last   A forward iterator.
+   *  @param  count  The number of consecutive values.
+   *  @param  val    The value to find.
+   *  @return   The first iterator @c i in the range @p [first,last-count)
+   *  such that @c *(i+N) == @p val for each @c N in the range @p [0,count),
+   *  or @p last if no such iterator exists.
+   *
+   *  Searches the range @p [first,last) for @p count consecutive elements
+   *  equal to @p val.
+  */
   template<typename _ForwardIter, typename _Integer, typename _Tp>
     _ForwardIter
     search_n(_ForwardIter __first, _ForwardIter __last,
@@ -476,6 +626,21 @@ namespace std
       }
     }
 
+  /**
+   *  @brief Search a sequence for a number of consecutive values using a
+   *         predicate.
+   *  @param  first        A forward iterator.
+   *  @param  last         A forward iterator.
+   *  @param  count        The number of consecutive values.
+   *  @param  val          The value to find.
+   *  @param  binary_pred  A binary predicate.
+   *  @return   The first iterator @c i in the range @p [first,last-count)
+   *  such that @p binary_pred(*(i+N),val) is true for each @c N in the
+   *  range @p [0,count), or @p last if no such iterator exists.
+   *
+   *  Searches the range @p [first,last) for @p count consecutive elements
+   *  for which the predicate returns true.
+  */
   template<typename _ForwardIter, typename _Integer, typename _Tp,
            typename _BinaryPred>
     _ForwardIter
@@ -519,8 +684,17 @@ namespace std
       }
     }
 
-  // swap_ranges
-
+  /**
+   *  @brief Swap the elements of two sequences.
+   *  @param  first1  A forward iterator.
+   *  @param  last1   A forward iterator.
+   *  @param  first2  A forward iterator.
+   *  @return   An iterator equal to @p first2+(last1-first1).
+   *
+   *  Swaps each element in the range @p [first1,last1) with the
+   *  corresponding element in the range @p [first2,(last1-first1)).
+   *  The ranges must not overlap.
+  */
   template<typename _ForwardIter1, typename _ForwardIter2>
     _ForwardIter2
     swap_ranges(_ForwardIter1 __first1, _ForwardIter1 __last1,
@@ -541,8 +715,21 @@ namespace std
       return __first2;
     }
 
-  // transform
-
+  /**
+   *  @brief Perform an operation on a sequence.
+   *  @param  first     An input iterator.
+   *  @param  last      An input iterator.
+   *  @param  result    An output iterator.
+   *  @param  unary_op  A unary operator.
+   *  @return   An output iterator equal to @p result+(last-first).
+   *
+   *  Applies the operator to each element in the input range and assigns
+   *  the results to successive elements of the output sequence.
+   *  Evaluates @p *(result+N)=unary_op(*(first+N)) for each @c N in the
+   *  range @p [0,last-first).
+   *
+   *  @p unary_op must not alter its argument.
+  */
   template<typename _InputIter, typename _OutputIter, typename _UnaryOperation>
     _OutputIter
     transform(_InputIter __first, _InputIter __last,
@@ -561,6 +748,23 @@ namespace std
       return __result;
     }
 
+  /**
+   *  @brief Perform an operation on corresponding elements of two sequences.
+   *  @param  first1     An input iterator.
+   *  @param  last1      An input iterator.
+   *  @param  first2     An input iterator.
+   *  @param  result     An output iterator.
+   *  @param  binary_op  A binary operator.
+   *  @return   An output iterator equal to @p result+(last-first).
+   *
+   *  Applies the operator to the corresponding elements in the two
+   *  input ranges and assigns the results to successive elements of the
+   *  output sequence.
+   *  Evaluates @p *(result+N)=binary_op(*(first1+N),*(first2+N)) for each
+   *  @c N in the range @p [0,last1-first1).
+   *
+   *  @p binary_op must not alter either of its arguments.
+  */
   template<typename _InputIter1, typename _InputIter2, typename _OutputIter,
 	   typename _BinaryOperation>
     _OutputIter
@@ -582,8 +786,18 @@ namespace std
       return __result;
     }
 
-  // replace, replace_if, replace_copy, replace_copy_if
-
+  /**
+   *  @brief Replace each occurrence of one value in a sequence with another
+   *         value.
+   *  @param  first      A forward iterator.
+   *  @param  last       A forward iterator.
+   *  @param  old_value  The value to be replaced.
+   *  @param  new_value  The replacement value.
+   *  @return   replace() returns no value.
+   *
+   *  For each iterator @c i in the range @p [first,last) if @c *i ==
+   *  @p old_value then the assignment @c *i = @p new_value is performed.
+  */
   template<typename _ForwardIter, typename _Tp>
     void
     replace(_ForwardIter __first, _ForwardIter __last,
@@ -601,6 +815,18 @@ namespace std
 	  *__first = __new_value;
     }
 
+  /**
+   *  @brief Replace each value in a sequence for which a predicate returns
+   *         true with another value.
+   *  @param  first      A forward iterator.
+   *  @param  last       A forward iterator.
+   *  @param  pred       A predicate.
+   *  @param  new_value  The replacement value.
+   *  @return   replace_if() returns no value.
+   *
+   *  For each iterator @c i in the range @p [first,last) if @p pred(*i)
+   *  is true then the assignment @c *i = @p new_value is performed.
+  */
   template<typename _ForwardIter, typename _Predicate, typename _Tp>
     void
     replace_if(_ForwardIter __first, _ForwardIter __last,
@@ -618,6 +844,20 @@ namespace std
 	  *__first = __new_value;
     }
 
+  /**
+   *  @brief Copy a sequence, replacing each element of one value with another
+   *         value.
+   *  @param  first      An input iterator.
+   *  @param  last       An input iterator.
+   *  @param  result     An output iterator.
+   *  @param  old_value  The value to be replaced.
+   *  @param  new_value  The replacement value.
+   *  @return   The end of the output sequence, @p result+(last-first).
+   *
+   *  Copies each element in the input range @p [first,last) to the
+   *  output range @p [result,result+(last-first)) replacing elements
+   *  equal to @p old_value with @p new_value.
+  */
   template<typename _InputIter, typename _OutputIter, typename _Tp>
     _OutputIter
     replace_copy(_InputIter __first, _InputIter __last,
@@ -636,6 +876,20 @@ namespace std
       return __result;
     }
 
+  /**
+   *  @brief Copy a sequence, replacing each value for which a predicate
+   *         returns true with another value.
+   *  @param  first      An input iterator.
+   *  @param  last       An input iterator.
+   *  @param  result     An output iterator.
+   *  @param  pred       A predicate.
+   *  @param  new_value  The replacement value.
+   *  @return   The end of the output sequence, @p result+(last-first).
+   *
+   *  Copies each element in the range @p [first,last) to the range
+   *  @p [result,result+(last-first)) replacing elements for which
+   *  @p pred returns true with @p new_value.
+  */
   template<typename _InputIter, typename _OutputIter, typename _Predicate,
            typename _Tp>
     _OutputIter
@@ -655,8 +909,17 @@ namespace std
       return __result;
     }
 
-  // generate and generate_n
-
+  /**
+   *  @brief Assign the result of a function object to each value in a
+   *         sequence.
+   *  @param  first  A forward iterator.
+   *  @param  last   A forward iterator.
+   *  @param  gen    A function object taking no arguments.
+   *  @return   generate() returns no value.
+   *
+   *  Performs the assignment @c *i = @p gen() for each @c i in the range
+   *  @p [first,last).
+  */
   template<typename _ForwardIter, typename _Generator>
     void
     generate(_ForwardIter __first, _ForwardIter __last, _Generator __gen)
@@ -670,6 +933,17 @@ namespace std
 	*__first = __gen();
     }
 
+  /**
+   *  @brief Assign the result of a function object to each value in a
+   *         sequence.
+   *  @param  first  A forward iterator.
+   *  @param  n      The length of the sequence.
+   *  @param  gen    A function object taking no arguments.
+   *  @return   The end of the sequence, @p first+n
+   *
+   *  Performs the assignment @c *i = @p gen() for each @c i in the range
+   *  @p [first,first+n).
+  */
   template<typename _OutputIter, typename _Size, typename _Generator>
     _OutputIter
     generate_n(_OutputIter __first, _Size __n, _Generator __gen)
@@ -685,8 +959,19 @@ namespace std
       return __first;
     }
 
-  // remove, remove_if, remove_copy, remove_copy_if
-
+  /**
+   *  @brief Copy a sequence, removing elements of a given value.
+   *  @param  first   An input iterator.
+   *  @param  last    An input iterator.
+   *  @param  result  An output iterator.
+   *  @param  value   The value to be removed.
+   *  @return   An iterator designating the end of the resulting sequence.
+   *
+   *  Copies each element in the range @p [first,last) not equal to @p value
+   *  to the range beginning at @p result.
+   *  remove_copy() is stable, so the relative order of elements that are
+   *  copied is unchanged.
+  */
   template<typename _InputIter, typename _OutputIter, typename _Tp>
     _OutputIter
     remove_copy(_InputIter __first, _InputIter __last,
@@ -707,6 +992,20 @@ namespace std
       return __result;
     }
 
+  /**
+   *  @brief Copy a sequence, removing elements for which a predicate is true.
+   *  @param  first   An input iterator.
+   *  @param  last    An input iterator.
+   *  @param  result  An output iterator.
+   *  @param  pred    A predicate.
+   *  @return   An iterator designating the end of the resulting sequence.
+   *
+   *  Copies each element in the range @p [first,last) for which
+   *  @p pred returns true to the range beginning at @p result.
+   *
+   *  remove_copy_if() is stable, so the relative order of elements that are
+   *  copied is unchanged.
+  */
   template<typename _InputIter, typename _OutputIter, typename _Predicate>
     _OutputIter
     remove_copy_if(_InputIter __first, _InputIter __last,
@@ -727,6 +1026,22 @@ namespace std
       return __result;
     }
 
+  /**
+   *  @brief Remove elements from a sequence.
+   *  @param  first  An input iterator.
+   *  @param  last   An input iterator.
+   *  @param  value  The value to be removed.
+   *  @return   An iterator designating the end of the resulting sequence.
+   *
+   *  All elements equal to @p value are removed from the range
+   *  @p [first,last).
+   *
+   *  remove() is stable, so the relative order of elements that are
+   *  not removed is unchanged.
+   *
+   *  Elements between the end of the resulting sequence and @p last
+   *  are still present, but their value is unspecified.
+  */
   template<typename _ForwardIter, typename _Tp>
     _ForwardIter
     remove(_ForwardIter __first, _ForwardIter __last,
@@ -745,6 +1060,22 @@ namespace std
 			       : remove_copy(++__i, __last, __first, __value);
     }
 
+  /**
+   *  @brief Remove elements from a sequence using a predicate.
+   *  @param  first  A forward iterator.
+   *  @param  last   A forward iterator.
+   *  @param  pred   A predicate.
+   *  @return   An iterator designating the end of the resulting sequence.
+   *
+   *  All elements for which @p pred returns true are removed from the range
+   *  @p [first,last).
+   *
+   *  remove_if() is stable, so the relative order of elements that are
+   *  not removed is unchanged.
+   *
+   *  Elements between the end of the resulting sequence and @p last
+   *  are still present, but their value is unspecified.
+  */
   template<typename _ForwardIter, typename _Predicate>
     _ForwardIter
     remove_if(_ForwardIter __first, _ForwardIter __last,
@@ -761,6 +1092,12 @@ namespace std
 			       : remove_copy_if(++__i, __last, __first, __pred);
     }
 
+  /**
+   *  @maint
+   *  This is an uglified unique_copy(_InputIter, _InputIter, _OutputIter)
+   *  overloaded for output iterators.
+   *  @endmaint
+  */
   template<typename _InputIter, typename _OutputIter>
     _OutputIter
     __unique_copy(_InputIter __first, _InputIter __last,
@@ -778,6 +1115,12 @@ namespace std
       return ++__result;
     }
 
+  /**
+   *  @maint
+   *  This is an uglified unique_copy(_InputIter, _InputIter, _OutputIter)
+   *  overloaded for forward iterators.
+   *  @endmaint
+  */
   template<typename _InputIter, typename _ForwardIter>
     _ForwardIter
     __unique_copy(_InputIter __first, _InputIter __last,
@@ -792,6 +1135,17 @@ namespace std
       return ++__result;
     }
 
+  /**
+   *  @brief Copy a sequence, removing consecutive duplicate values.
+   *  @param  first   An input iterator.
+   *  @param  last    An input iterator.
+   *  @param  result  An output iterator.
+   *  @return   An iterator designating the end of the resulting sequence.
+   *
+   *  Copies each element in the range @p [first,last) to the range
+   *  beginning at @p result, except that only the first element is copied
+   *  from groups of consecutive elements that compare equal.
+  */
   template<typename _InputIter, typename _OutputIter>
     inline _OutputIter
     unique_copy(_InputIter __first, _InputIter __last,
@@ -810,6 +1164,13 @@ namespace std
       return __unique_copy(__first, __last, __result, _IterType());
     }
 
+  /**
+   *  @maint
+   *  This is an uglified
+   *  unique_copy(_InputIter, _InputIter, _OutputIter, _BinaryPredicate)
+   *  overloaded for output iterators.
+   *  @endmaint
+  */
   template<typename _InputIter, typename _OutputIter, typename _BinaryPredicate>
     _OutputIter
     __unique_copy(_InputIter __first, _InputIter __last,
@@ -832,6 +1193,13 @@ namespace std
       return ++__result;
     }
 
+  /**
+   *  @maint
+   *  This is an uglified
+   *  unique_copy(_InputIter, _InputIter, _OutputIter, _BinaryPredicate)
+   *  overloaded for forward iterators.
+   *  @endmaint
+  */
   template<typename _InputIter, typename _ForwardIter, typename _BinaryPredicate>
     _ForwardIter
     __unique_copy(_InputIter __first, _InputIter __last,
@@ -850,6 +1218,21 @@ namespace std
       return ++__result;
     }
 
+  /**
+   *  @brief Copy a sequence, removing consecutive values using a predicate.
+   *  @param  first        An input iterator.
+   *  @param  last         An input iterator.
+   *  @param  result       An output iterator.
+   *  @param  binary_pred  A binary predicate.
+   *  @return   An iterator designating the end of the resulting sequence.
+   *
+   *  Copies each element in the range @p [first,last) to the range
+   *  beginning at @p result, except that only the first element is copied
+   *  from groups of consecutive elements for which @p binary_pred returns
+   *  true.
+   *  unique_copy() is stable, so the relative order of elements that are
+   *  copied is unchanged.
+  */
   template<typename _InputIter, typename _OutputIter, typename _BinaryPredicate>
     inline _OutputIter
     unique_copy(_InputIter __first, _InputIter __last,
@@ -868,6 +1251,19 @@ namespace std
 __result, __binary_pred, _IterType());
     }
 
+  /**
+   *  @brief Remove consecutive duplicate values from a sequence.
+   *  @param  first  A forward iterator.
+   *  @param  last   A forward iterator.
+   *  @return  An iterator designating the end of the resulting sequence.
+   *
+   *  Removes all but the first element from each group of consecutive
+   *  values that compare equal.
+   *  unique() is stable, so the relative order of elements that are
+   *  not removed is unchanged.
+   *  Elements between the end of the resulting sequence and @p last
+   *  are still present, but their value is unspecified.
+  */
   template<typename _ForwardIter>
     _ForwardIter
     unique(_ForwardIter __first, _ForwardIter __last)
@@ -881,6 +1277,20 @@ __result, __binary_pred, _IterType());
 	  return unique_copy(__first, __last, __first);
     }
 
+  /**
+   *  @brief Remove consecutive values from a sequence using a predicate.
+   *  @param  first        A forward iterator.
+   *  @param  last         A forward iterator.
+   *  @param  binary_pred  A binary predicate.
+   *  @return  An iterator designating the end of the resulting sequence.
+   *
+   *  Removes all but the first element from each group of consecutive
+   *  values for which @p binary_pred returns true.
+   *  unique() is stable, so the relative order of elements that are
+   *  not removed is unchanged.
+   *  Elements between the end of the resulting sequence and @p last
+   *  are still present, but their value is unspecified.
+  */
   template<typename _ForwardIter, typename _BinaryPredicate>
     _ForwardIter
     unique(_ForwardIter __first, _ForwardIter __last,
@@ -896,6 +1306,12 @@ __result, __binary_pred, _IterType());
       return unique_copy(__first, __last, __first, __binary_pred);
     }
 
+  /**
+   *  @maint
+   *  This is an uglified reverse(_BidirectionalIter, _BidirectionalIter)
+   *  overloaded for bidirectional iterators.
+   *  @endmaint
+  */
   template<typename _BidirectionalIter>
     void
     __reverse(_BidirectionalIter __first, _BidirectionalIter __last,
@@ -908,6 +1324,12 @@ __result, __binary_pred, _IterType());
 		  iter_swap(__first++, __last);
     }
 
+  /**
+   *  @maint
+   *  This is an uglified reverse(_BidirectionalIter, _BidirectionalIter)
+   *  overloaded for bidirectional iterators.
+   *  @endmaint
+  */
   template<typename _RandomAccessIter>
     void
     __reverse(_RandomAccessIter __first, _RandomAccessIter __last,
@@ -917,6 +1339,17 @@ __result, __binary_pred, _IterType());
 	    iter_swap(__first++, --__last);
     }
 
+  /**
+   *  @brief Reverse a sequence.
+   *  @param  first  A bidirectional iterator.
+   *  @param  last   A bidirectional iterator.
+   *  @return   reverse() returns no value.
+   *
+   *  Reverses the order of the elements in the range @p [first,last),
+   *  so that the first element becomes the last etc.
+   *  For every @c i such that @p 0<=i<=(last-first)/2), @p reverse()
+   *  swaps @p *(first+i) and @p *(last-(i+1))
+  */
   template<typename _BidirectionalIter>
     inline void
     reverse(_BidirectionalIter __first, _BidirectionalIter __last)
@@ -927,6 +1360,21 @@ __result, __binary_pred, _IterType());
 	  __reverse(__first, __last, __iterator_category(__first));
     }
 
+  /**
+   *  @brief Copy a sequence, reversing its elements.
+   *  @param  first   A bidirectional iterator.
+   *  @param  last    A bidirectional iterator.
+   *  @param  result  An output iterator.
+   *  @return  An iterator designating the end of the resulting sequence.
+   *
+   *  Copies the elements in the range @p [first,last) to the range
+   *  @p [result,result+(last-first)) such that the order of the
+   *  elements is reversed.
+   *  For every @c i such that @p 0<=i<=(last-first), @p reverse_copy()
+   *  performs the assignment @p *(result+(last-first)-i) = *(first+i).
+   *  The ranges @p [first,last) and @p [result,result+(last-first))
+   *  must not overlap.
+  */
   template<typename _BidirectionalIter, typename _OutputIter>
     _OutputIter
     reverse_copy(_BidirectionalIter __first, _BidirectionalIter __last,
@@ -3327,6 +3775,3 @@ __result, __binary_pred, _IterType());
 
 #endif /* __GLIBCPP_INTERNAL_ALGO_H */
 
-// Local Variables:
-// mode:C++
-// End: