[algorithm.syn] Reformat functions to not end in "(" for consistency.

Author: Dawn Perchik

source/algorithms.tex

@@ -262,26 +262,26 @@
 
   // \ref{alg.search}, search
   template<class ForwardIterator1, class ForwardIterator2>
-    constexpr ForwardIterator1 search(
-      ForwardIterator1 first1, ForwardIterator1 last1,
-      ForwardIterator2 first2, ForwardIterator2 last2);
+    constexpr ForwardIterator1
+      search(ForwardIterator1 first1, ForwardIterator1 last1,
+             ForwardIterator2 first2, ForwardIterator2 last2);
   template<class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
-    constexpr ForwardIterator1 search(
-      ForwardIterator1 first1, ForwardIterator1 last1,
-      ForwardIterator2 first2, ForwardIterator2 last2,
-      BinaryPredicate pred);
+    constexpr ForwardIterator1
+      search(ForwardIterator1 first1, ForwardIterator1 last1,
+             ForwardIterator2 first2, ForwardIterator2 last2,
+             BinaryPredicate pred);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
-    ForwardIterator1 search(
-      ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}
-      ForwardIterator1 first1, ForwardIterator1 last1,
-      ForwardIterator2 first2, ForwardIterator2 last2);
+    ForwardIterator1
+      search(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}
+             ForwardIterator1 first1, ForwardIterator1 last1,
+             ForwardIterator2 first2, ForwardIterator2 last2);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
            class BinaryPredicate>
-    ForwardIterator1 search(
-      ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}
-      ForwardIterator1 first1, ForwardIterator1 last1,
-      ForwardIterator2 first2, ForwardIterator2 last2,
-      BinaryPredicate pred);
+    ForwardIterator1
+      search(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}
+             ForwardIterator1 first1, ForwardIterator1 last1,
+             ForwardIterator2 first2, ForwardIterator2 last2,
+             BinaryPredicate pred);
   template<class ForwardIterator, class Size, class T>
     constexpr ForwardIterator search_n(ForwardIterator first, ForwardIterator last,
                                        Size count, const T& value);
@@ -330,9 +330,9 @@
                              ForwardIterator1 first, ForwardIterator1 last,
                              ForwardIterator2 result, Predicate pred);
   template<class BidirectionalIterator1, class BidirectionalIterator2>
-    constexpr BidirectionalIterator2 copy_backward(
-      BidirectionalIterator1 first, BidirectionalIterator1 last,
-      BidirectionalIterator2 result);
+    constexpr BidirectionalIterator2
+      copy_backward(BidirectionalIterator1 first, BidirectionalIterator1 last,
+                    BidirectionalIterator2 result);
 
   // \ref{alg.move}, move
   template<class InputIterator, class OutputIterator>
@@ -344,9 +344,9 @@
                           ForwardIterator1 first, ForwardIterator1 last,
                           ForwardIterator2 result);
   template<class BidirectionalIterator1, class BidirectionalIterator2>
-    constexpr BidirectionalIterator2 move_backward(
-      BidirectionalIterator1 first, BidirectionalIterator1 last,
-      BidirectionalIterator2 result);
+    constexpr BidirectionalIterator2
+      move_backward(BidirectionalIterator1 first, BidirectionalIterator1 last,
+                    BidirectionalIterator2 result);
 
   // \ref{alg.swap}, swap
   template<class ForwardIterator1, class ForwardIterator2>
@@ -531,14 +531,14 @@
                            ForwardIterator middle,
                            ForwardIterator last);
   template<class ForwardIterator, class OutputIterator>
-    constexpr OutputIterator rotate_copy(
-      ForwardIterator first, ForwardIterator middle,
-      ForwardIterator last, OutputIterator result);
+    constexpr OutputIterator
+      rotate_copy(ForwardIterator first, ForwardIterator middle,
+                  ForwardIterator last, OutputIterator result);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
-    ForwardIterator2 rotate_copy(
-      ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}
-      ForwardIterator1 first, ForwardIterator1 middle,
-      ForwardIterator1 last, ForwardIterator2 result);
+    ForwardIterator2
+      rotate_copy(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}
+                  ForwardIterator1 first, ForwardIterator1 middle,
+                  ForwardIterator1 last, ForwardIterator2 result);
 
   // \ref{alg.random.sample}, sample
   template<class PopulationIterator, class SampleIterator,
@@ -643,30 +643,30 @@
                       RandomAccessIterator middle,
                       RandomAccessIterator last, Compare comp);
   template<class InputIterator, class RandomAccessIterator>
-    RandomAccessIterator partial_sort_copy(
-      InputIterator first, InputIterator last,
-      RandomAccessIterator result_first,
-      RandomAccessIterator result_last);
+    RandomAccessIterator
+      partial_sort_copy(InputIterator first, InputIterator last,
+                        RandomAccessIterator result_first,
+                        RandomAccessIterator result_last);
   template<class InputIterator, class RandomAccessIterator, class Compare>
-    RandomAccessIterator partial_sort_copy(
-      InputIterator first, InputIterator last,
-      RandomAccessIterator result_first,
-      RandomAccessIterator result_last,
-      Compare comp);
+    RandomAccessIterator
+      partial_sort_copy(InputIterator first, InputIterator last,
+                        RandomAccessIterator result_first,
+                        RandomAccessIterator result_last,
+                        Compare comp);
   template<class ExecutionPolicy, class ForwardIterator, class RandomAccessIterator>
-    RandomAccessIterator partial_sort_copy(
-      ExecutionPolicy&& exec,  // see \ref{algorithms.parallel.overloads}
-      ForwardIterator first, ForwardIterator last,
-      RandomAccessIterator result_first,
-      RandomAccessIterator result_last);
+    RandomAccessIterator
+      partial_sort_copy(ExecutionPolicy&& exec,  // see \ref{algorithms.parallel.overloads}
+                        ForwardIterator first, ForwardIterator last,
+                        RandomAccessIterator result_first,
+                        RandomAccessIterator result_last);
   template<class ExecutionPolicy, class ForwardIterator, class RandomAccessIterator,
            class Compare>
-    RandomAccessIterator partial_sort_copy(
-      ExecutionPolicy&& exec,  // see \ref{algorithms.parallel.overloads}
-      ForwardIterator first, ForwardIterator last,
-      RandomAccessIterator result_first,
-      RandomAccessIterator result_last,
-      Compare comp);
+    RandomAccessIterator
+      partial_sort_copy(ExecutionPolicy&& exec,  // see \ref{algorithms.parallel.overloads}
+                        ForwardIterator first, ForwardIterator last,
+                        RandomAccessIterator result_first,
+                        RandomAccessIterator result_last,
+                        Compare comp);
   template<class ForwardIterator>
     constexpr bool is_sorted(ForwardIterator first, ForwardIterator last);
   template<class ForwardIterator, class Compare>
@@ -820,79 +820,79 @@
                               ForwardIterator result, Compare comp);
 
   template<class InputIterator1, class InputIterator2, class OutputIterator>
-    constexpr OutputIterator set_intersection(
-      InputIterator1 first1, InputIterator1 last1,
-      InputIterator2 first2, InputIterator2 last2,
-      OutputIterator result);
+    constexpr OutputIterator
+      set_intersection(InputIterator1 first1, InputIterator1 last1,
+                       InputIterator2 first2, InputIterator2 last2,
+                       OutputIterator result);
   template<class InputIterator1, class InputIterator2, class OutputIterator, class Compare>
-    constexpr OutputIterator set_intersection(
-      InputIterator1 first1, InputIterator1 last1,
-      InputIterator2 first2, InputIterator2 last2,
-      OutputIterator result, Compare comp);
+    constexpr OutputIterator
+      set_intersection(InputIterator1 first1, InputIterator1 last1,
+                       InputIterator2 first2, InputIterator2 last2,
+                       OutputIterator result, Compare comp);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
            class ForwardIterator>
-    ForwardIterator set_intersection(
-      ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}
-      ForwardIterator1 first1, ForwardIterator1 last1,
-      ForwardIterator2 first2, ForwardIterator2 last2,
-      ForwardIterator result);
+    ForwardIterator
+      set_intersection(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}
+                       ForwardIterator1 first1, ForwardIterator1 last1,
+                       ForwardIterator2 first2, ForwardIterator2 last2,
+                       ForwardIterator result);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
            class ForwardIterator, class Compare>
-    ForwardIterator set_intersection(
-      ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}
-      ForwardIterator1 first1, ForwardIterator1 last1,
-      ForwardIterator2 first2, ForwardIterator2 last2,
-      ForwardIterator result, Compare comp);
+    ForwardIterator
+      set_intersection(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}
+                       ForwardIterator1 first1, ForwardIterator1 last1,
+                       ForwardIterator2 first2, ForwardIterator2 last2,
+                       ForwardIterator result, Compare comp);
 
   template<class InputIterator1, class InputIterator2, class OutputIterator>
-    constexpr OutputIterator set_difference(
-      InputIterator1 first1, InputIterator1 last1,
-      InputIterator2 first2, InputIterator2 last2,
-      OutputIterator result);
+    constexpr OutputIterator
+      set_difference(InputIterator1 first1, InputIterator1 last1,
+                     InputIterator2 first2, InputIterator2 last2,
+                     OutputIterator result);
   template<class InputIterator1, class InputIterator2, class OutputIterator, class Compare>
-    constexpr OutputIterator set_difference(
-      InputIterator1 first1, InputIterator1 last1,
-      InputIterator2 first2, InputIterator2 last2,
-      OutputIterator result, Compare comp);
+    constexpr OutputIterator
+      set_difference(InputIterator1 first1, InputIterator1 last1,
+                     InputIterator2 first2, InputIterator2 last2,
+                     OutputIterator result, Compare comp);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
            class ForwardIterator>
-    ForwardIterator set_difference(
-      ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}
-      ForwardIterator1 first1, ForwardIterator1 last1,
-      ForwardIterator2 first2, ForwardIterator2 last2,
-      ForwardIterator result);
+    ForwardIterator
+      set_difference(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}
+                     ForwardIterator1 first1, ForwardIterator1 last1,
+                     ForwardIterator2 first2, ForwardIterator2 last2,
+                     ForwardIterator result);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
            class ForwardIterator, class Compare>
-    ForwardIterator set_difference(
-      ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}
-      ForwardIterator1 first1, ForwardIterator1 last1,
-      ForwardIterator2 first2, ForwardIterator2 last2,
-      ForwardIterator result, Compare comp);
+    ForwardIterator
+      set_difference(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}
+                     ForwardIterator1 first1, ForwardIterator1 last1,
+                     ForwardIterator2 first2, ForwardIterator2 last2,
+                     ForwardIterator result, Compare comp);
 
   template<class InputIterator1, class InputIterator2, class OutputIterator>
-    constexpr OutputIterator set_symmetric_difference(
-      InputIterator1 first1, InputIterator1 last1,
-      InputIterator2 first2, InputIterator2 last2,
-      OutputIterator result);
+    constexpr OutputIterator
+      set_symmetric_difference(InputIterator1 first1, InputIterator1 last1,
+                               InputIterator2 first2, InputIterator2 last2,
+                               OutputIterator result);
   template<class InputIterator1, class InputIterator2, class OutputIterator, class Compare>
-    constexpr OutputIterator set_symmetric_difference(
-      InputIterator1 first1, InputIterator1 last1,
-      InputIterator2 first2, InputIterator2 last2,
-      OutputIterator result, Compare comp);
+    constexpr OutputIterator
+      set_symmetric_difference(InputIterator1 first1, InputIterator1 last1,
+                               InputIterator2 first2, InputIterator2 last2,
+                               OutputIterator result, Compare comp);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
            class ForwardIterator>
-    ForwardIterator set_symmetric_difference(
-      ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}
-      ForwardIterator1 first1, ForwardIterator1 last1,
-      ForwardIterator2 first2, ForwardIterator2 last2,
-      ForwardIterator result);
+    ForwardIterator
+      set_symmetric_difference(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}
+                               ForwardIterator1 first1, ForwardIterator1 last1,
+                               ForwardIterator2 first2, ForwardIterator2 last2,
+                               ForwardIterator result);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
            class ForwardIterator, class Compare>
-    ForwardIterator set_symmetric_difference(
-      ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}
-      ForwardIterator1 first1, ForwardIterator1 last1,
-      ForwardIterator2 first2, ForwardIterator2 last2,
-      ForwardIterator result, Compare comp);
+    ForwardIterator
+      set_symmetric_difference(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}
+                               ForwardIterator1 first1, ForwardIterator1 last1,
+                               ForwardIterator2 first2, ForwardIterator2 last2,
+                               ForwardIterator result, Compare comp);
 
   // \ref{alg.heap.operations}, heap operations
   template<class RandomAccessIterator>
@@ -1019,26 +1019,26 @@
 
   // \ref{alg.lex.comparison}, lexicographical comparison
   template<class InputIterator1, class InputIterator2>
-    constexpr bool lexicographical_compare(
-      InputIterator1 first1, InputIterator1 last1,
-      InputIterator2 first2, InputIterator2 last2);
+    constexpr bool
+      lexicographical_compare(InputIterator1 first1, InputIterator1 last1,
+                              InputIterator2 first2, InputIterator2 last2);
   template<class InputIterator1, class InputIterator2, class Compare>
-    constexpr bool lexicographical_compare(
-      InputIterator1 first1, InputIterator1 last1,
-      InputIterator2 first2, InputIterator2 last2,
-      Compare comp);
+    constexpr bool
+      lexicographical_compare(InputIterator1 first1, InputIterator1 last1,
+                              InputIterator2 first2, InputIterator2 last2,
+                              Compare comp);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
-    bool lexicographical_compare(
-      ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}
-      ForwardIterator1 first1, ForwardIterator1 last1,
-      ForwardIterator2 first2, ForwardIterator2 last2);
+    bool
+      lexicographical_compare(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}
+                              ForwardIterator1 first1, ForwardIterator1 last1,
+                              ForwardIterator2 first2, ForwardIterator2 last2);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
            class Compare>
-    bool lexicographical_compare(
-      ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}
-      ForwardIterator1 first1, ForwardIterator1 last1,
-      ForwardIterator2 first2, ForwardIterator2 last2,
-      Compare comp);
+    bool
+      lexicographical_compare(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}
+                              ForwardIterator1 first1, ForwardIterator1 last1,
+                              ForwardIterator2 first2, ForwardIterator2 last2,
+                              Compare comp);
 
   // \ref{alg.3way}, three-way comparison algorithms
   template<class T, class U>