Skip to content

Commit

Permalink
Merge pull request #1891 from Syntaf/doc_fix
Browse files Browse the repository at this point in the history 
Fix wording in certain parallel algorithm docs
  • Loading branch information
@hkaiser
hkaiser committed Dec 3, 2015
2 parents 7c70f2a + 10fbdf9 commit 5d0cd95
Show file tree
Hide file tree
Showing 11 changed files with 55 additions and 66 deletions.
8 changes: 4 additions & 4 deletions hpx/parallel/algorithms/adjacent_find.hpp
View file
Expand Up @@ -196,14 +196,14 @@ namespace hpx { namespace parallel { HPX_INLINE_NAMESPACE(v1)
/// if the elements should be treated as equal. The
/// signature should be equivalent to the following:
/// \code
/// bool pred(const Type1 &a, const Type2 &b);
/// bool pred(const Type1 &a, const Type1 &b);
/// \endcode \n
/// The signature does not need to have const &, but
/// the function must not modify the objects passed to
/// it. The types \a Type1 and \a Type2 must be such
/// that objects of types \a FwdIter1 and \a FwdIter2
/// it. The types \a Type1 must be such
/// that objects of type \a FwdIter
/// can be dereferenced and then implicitly converted
/// to \a Type1 and \a Type2 respectively.
/// to \a Type1 .
///
/// The comparison operations in the parallel \a adjacent_find invoked
/// with an execution policy object of type \a sequential_execution_policy
Expand Down
5 changes: 0 additions & 5 deletions hpx/parallel/algorithms/inner_product.hpp
View file
Expand Up @@ -127,11 +127,6 @@ namespace hpx { namespace parallel { HPX_INLINE_NAMESPACE(v1)
/// output iterator.
/// \tparam T The type of the value to be used as return)
/// values (deduced).
/// \tparam Op1 The type of the binary function object used for
/// the summation operation.
/// \tparam Op2 The type of the binary function object used for
/// the multiplication operation.
///
/// \param policy The execution policy to use for the scheduling of
/// the iterations.
/// \param first1 Refers to the beginning of the first sequence of
Expand Down
16 changes: 8 additions & 8 deletions hpx/parallel/algorithms/is_partitioned.hpp
View file
Expand Up @@ -135,18 +135,18 @@ namespace hpx { namespace parallel { HPX_INLINE_NAMESPACE(v1)
/// of that the algorithm will be applied to.
/// \param last Refers to the end of the sequence of elements of
/// that the algorithm will be applied to.
/// \param pred Refers to the binary predicate which returns a bool.
/// The signature of the function should be equivalent
/// to
/// \param pred Refers to the binary predicate which returns true
/// if the first argument should be treated as less than
/// the second argument. The signature of the function
/// should be equivalent to
/// \code
/// bool pred(const Type1 &a, const Type2 &b);
/// bool pred(const Type &a, const Type &b);
/// \endcode \n
/// The signature does not need to have const &, but
/// the function must not modify the objects passed to
/// it. The types \a Type1 and \a Type2 must be such
/// that objects of types \a InIter1 and \a InIter2 can
/// be dereferenced and then implicitly converted to
/// \a Type1 and \a Type2 respectively
/// it. The type \a Type must be such that objects of
/// types \a InIter can be dereferenced and then
/// implicitly converted to Type.
///
/// The predicate operations in the parallel \a is_partitioned algorithm invoked
/// with an execution policy object of type \a sequential_execution_policy
Expand Down
25 changes: 11 additions & 14 deletions hpx/parallel/algorithms/is_sorted.hpp
View file
Expand Up @@ -126,14 +126,13 @@ namespace hpx { namespace parallel { HPX_INLINE_NAMESPACE(v1)
/// the second argument. The signature of the function
/// should be equivalent to
/// \code
/// bool pred(const Type1 &a, const Type2 &b);
/// bool pred(const Type &a, const Type &b);
/// \endcode \n
/// The signature does not need to have const &, but
/// the function must not modify the objects passed to
/// it. The types \a Type1 and \a Type2 must be such
/// that objects of types \a InIter1 and \a InIter2 can
/// be dereferenced and then implicitly converted to
/// \a Type1 and \a Type2 respectively
/// it. The type \a Type must be such that objects of
/// types \a FwdIter can be dereferenced and then
/// implicitly converted to Type.
///
/// The comparison operations in the parallel \a is_sorted algorithm invoked
/// with an execution policy object of type \a sequential_execution_policy
Expand All @@ -149,11 +148,10 @@ namespace hpx { namespace parallel { HPX_INLINE_NAMESPACE(v1)
/// if the execution policy is of type \a task_execution_policy
/// and returns \a bool otherwise.
/// The \a is_sorted algorithm returns a bool if each element in
/// the sequence [first, last) is greater than or equal to the
/// previous element. If the range [first, last) contains less
/// than two elements, the function always returns true.
/// the sequence [first, last) satisfies the predicate passed.
/// If the range [first, last) contains less than two elements,
/// the function always returns true.
///

template <typename ExPolicy, typename FwdIter, typename Pred>
inline typename boost::enable_if<
is_execution_policy<ExPolicy>,
Expand Down Expand Up @@ -350,14 +348,13 @@ namespace hpx { namespace parallel { HPX_INLINE_NAMESPACE(v1)
/// the second argument. The signature of the function
/// should be equivalent to
/// \code
/// bool pred(const Type1 &a, const Type2 &b);
/// bool pred(const Type &a, const Type &b);
/// \endcode \n
/// The signature does not need to have const &, but
/// the function must not modify the objects passed to
/// it. The types \a Type1 and \a Type2 must be such
/// that objects of types \a InIter1 and \a InIter2 can
/// be dereferenced and then implicitly converted to
/// \a Type1 and \a Type2 respectively
/// it. The type \a Type must be such that objects of
/// types \a FwdIter can be dereferenced and then
/// implicitly converted to Type.
///
/// The comparison operations in the parallel \a is_sorted_until algorithm
/// invoked with an execution policy object of type
Expand Down
27 changes: 12 additions & 15 deletions hpx/parallel/algorithms/minmax.hpp
View file
Expand Up @@ -141,14 +141,13 @@ namespace hpx { namespace parallel { HPX_INLINE_NAMESPACE(v1)
/// of the predicate function should be equivalent to
/// the following:
/// \code
/// bool pred(const Type1 &a, const Type2 &b);
/// bool pred(const Type1 &a, const Type1 &b);
/// \endcode \n
/// The signature does not need to have const &, but
/// the function must not modify the objects passed to
/// it. The types \a Type1 and \a Type2 must be such
/// that objects of types \a InIter1 and \a InIter2 can
/// be dereferenced and then implicitly converted to
/// \a Type1 and \a Type2 respectively
/// it. The type \a Type1 must be such that objects of
/// type \a FwdIter can be dereferenced and then
/// implicitly converted to \a Type1.
///
/// The comparisons in the parallel \a min_element algorithm invoked with
/// an execution policy object of type \a sequential_execution_policy
Expand Down Expand Up @@ -373,14 +372,13 @@ namespace hpx { namespace parallel { HPX_INLINE_NAMESPACE(v1)
/// of the predicate function should be equivalent to
/// the following:
/// \code
/// bool pred(const Type1 &a, const Type2 &b);
/// bool pred(const Type1 &a, const Type1 &b);
/// \endcode \n
/// The signature does not need to have const &, but
/// the function must not modify the objects passed to
/// it. The types \a Type1 and \a Type2 must be such
/// that objects of types \a InIter1 and \a InIter2 can
/// be dereferenced and then implicitly converted to
/// \a Type1 and \a Type2 respectively
/// it. The type \a Type1 must be such that objects of
/// type \a FwdIter can be dereferenced and then
/// implicitly converted to \a Type1.
///
/// The comparisons in the parallel \a max_element algorithm invoked with
/// an execution policy object of type \a sequential_execution_policy
Expand Down Expand Up @@ -617,14 +615,13 @@ namespace hpx { namespace parallel { HPX_INLINE_NAMESPACE(v1)
/// of the predicate function should be equivalent to
/// the following:
/// \code
/// bool pred(const Type1 &a, const Type2 &b);
/// bool pred(const Type1 &a, const Type1 &b);
/// \endcode \n
/// The signature does not need to have const &, but
/// the function must not modify the objects passed to
/// it. The types \a Type1 and \a Type2 must be such
/// that objects of types \a InIter1 and \a InIter2 can
/// be dereferenced and then implicitly converted to
/// \a Type1 and \a Type2 respectively
/// it. The type \a Type1 must be such that objects of
/// type \a FwdIter can be dereferenced and then
/// implicitly converted to \a Type1.
///
/// The comparisons in the parallel \a minmax_element algorithm invoked with
/// an execution policy object of type \a sequential_execution_policy
Expand Down
4 changes: 2 additions & 2 deletions hpx/parallel/algorithms/reduce.hpp
View file
Expand Up @@ -112,10 +112,10 @@ namespace hpx { namespace parallel { HPX_INLINE_NAMESPACE(v1)
/// binary predicate. The signature of this predicate
/// should be equivalent to:
/// \code
/// Ret fun(const Type1 &a, const Type2 &b);
/// Ret fun(const Type1 &a, const Type1 &b);
/// \endcode \n
/// The signature does not need to have const&.
/// The types \a Type1, \a Type2, and \a Ret must be
/// The types \a Type1 \a Ret must be
/// such that an object of type \a InIter can be
/// dereferenced and then implicitly converted to any
/// of those types.
Expand Down
4 changes: 2 additions & 2 deletions hpx/parallel/algorithms/search.hpp
View file
Expand Up @@ -248,7 +248,7 @@ namespace hpx {namespace parallel { HPX_INLINE_NAMESPACE(v1)
/// The signature does not need to have const &, but
/// the function must not modify the objects passed to
/// it. The types \a Type1 and \a Type2 must be such
/// that objects of types \a InIter1 and \a InIter2 can
/// that objects of types \a FwdIter1 and \a FwdIter2 can
/// be dereferenced and then implicitly converted to
/// \a Type1 and \a Type2 respectively
///
Expand Down Expand Up @@ -526,7 +526,7 @@ namespace hpx {namespace parallel { HPX_INLINE_NAMESPACE(v1)
/// The signature does not need to have const &, but
/// the function must not modify the objects passed to
/// it. The types \a Type1 and \a Type2 must be such
/// that objects of types \a InIter1 and \a InIter2 can
/// that objects of types \a FwdIter1 and \a FwdIter2 can
/// be dereferenced and then implicitly converted to
/// \a Type1 and \a Type2 respectively
///
Expand Down
8 changes: 4 additions & 4 deletions hpx/parallel/algorithms/set_difference.hpp
View file
Expand Up @@ -155,14 +155,14 @@ namespace hpx { namespace parallel { HPX_INLINE_NAMESPACE(v1)
/// of the predicate function should be equivalent to
/// the following:
/// \code
/// bool pred(const Type1 &a, const Type2 &b);
/// bool pred(const Type1 &a, const Type1 &b);
/// \endcode \n
/// The signature does not need to have const &, but
/// the function must not modify the objects passed to
/// it. The types \a Type1 and \a Type2 must be such
/// that objects of types \a InIter1 and \a InIter2 can
/// it. The type \a Type1 must be such
/// that objects of type \a InIter can
/// be dereferenced and then implicitly converted to
/// \a Type1 and \a Type2 respectively
/// \a Type1
///
/// The application of function objects in parallel algorithm
/// invoked with a sequential execution policy object execute in sequential
Expand Down
8 changes: 4 additions & 4 deletions hpx/parallel/algorithms/set_intersection.hpp
View file
Expand Up @@ -150,14 +150,14 @@ namespace hpx { namespace parallel { HPX_INLINE_NAMESPACE(v1)
/// of the predicate function should be equivalent to
/// the following:
/// \code
/// bool pred(const Type1 &a, const Type2 &b);
/// bool pred(const Type1 &a, const Type1 &b);
/// \endcode \n
/// The signature does not need to have const &, but
/// the function must not modify the objects passed to
/// it. The types \a Type1 and \a Type2 must be such
/// that objects of types \a InIter1 and \a InIter2 can
/// it. The type \a Type1 must be such
/// that objects of type \a InIter can
/// be dereferenced and then implicitly converted to
/// \a Type1 and \a Type2 respectively
/// \a Type1
///
/// The application of function objects in parallel algorithm
/// invoked with a sequential execution policy object execute in sequential
Expand Down
8 changes: 4 additions & 4 deletions hpx/parallel/algorithms/set_symmetric_difference.hpp
View file
Expand Up @@ -158,14 +158,14 @@ namespace hpx { namespace parallel { HPX_INLINE_NAMESPACE(v1)
/// of the predicate function should be equivalent to
/// the following:
/// \code
/// bool pred(const Type1 &a, const Type2 &b);
/// bool pred(const Type1 &a, const Type1 &b);
/// \endcode \n
/// The signature does not need to have const &, but
/// the function must not modify the objects passed to
/// it. The types \a Type1 and \a Type2 must be such
/// that objects of types \a InIter1 and \a InIter2 can
/// it. The type \a Type1 must be such
/// that objects of type \a InIter can
/// be dereferenced and then implicitly converted to
/// \a Type1 and \a Type2 respectively
/// \a Type1
///
/// The application of function objects in parallel algorithm
/// invoked with a sequential execution policy object execute in sequential
Expand Down
8 changes: 4 additions & 4 deletions hpx/parallel/algorithms/set_union.hpp
View file
Expand Up @@ -152,14 +152,14 @@ namespace hpx { namespace parallel { HPX_INLINE_NAMESPACE(v1)
/// of the predicate function should be equivalent to
/// the following:
/// \code
/// bool pred(const Type1 &a, const Type2 &b);
/// bool pred(const Type1 &a, const Type1 &b);
/// \endcode \n
/// The signature does not need to have const &, but
/// the function must not modify the objects passed to
/// it. The types \a Type1 and \a Type2 must be such
/// that objects of types \a InIter1 and \a InIter2 can
/// it. The type \a Type1 must be such
/// that objects of type \a InIter can
/// be dereferenced and then implicitly converted to
/// \a Type1 and \a Type2 respectively
/// \a Type1
///
/// The application of function objects in parallel algorithm
/// invoked with a sequential execution policy object execute in sequential
Expand Down

0 comments on commit 5d0cd95

Please sign in to comment.