Merge pull request #5 from jaredhoberock/master

Final pre-Rapperswil changes

Author: jaredhoberock

algorithms.html

@@ -133,7 +133,10 @@ <h1>Effect of execution policies on algorithm execution</h1>
 
       <p>
         Algorithms invoked with an execution policy object of type <code>execution_policy</code>
-        execute internally as if invoked with the contained execution policy object.
+        execute internally as if invoked with <del>instances of type <code>sequential_execution_policy</code>,
+        <code>parallel_execution_policy</code>, or an implementation-defined execution policy type depending
+        on the dynamic value of the <code>execution_policy</code> object.</del>
+        <ins>the contained execution policy object.</ins>
       </p>
 
       <p>
@@ -148,8 +151,10 @@ <h1><code>ExecutionPolicy</code> algorithm overloads</h1>
       <p>
         Parallel algorithms coexist alongside their sequential counterparts as overloads
         distinguished by a formal template parameter named <code>ExecutionPolicy</code>. This
-        is the first template parameter and corresponds to the parallel algorithm's first function
-        parameter, whose type is <code>ExecutionPolicy&amp;&amp;</code>.
+        <del>template parameter corresponds to the parallel algorithm's first function parameter, whose
+        type is <code>ExecutionPolicy</code></del>
+        <ins>is the first template parameter and corresponds to the parallel algorithm's first function
+        parameter, whose type is <code>ExecutionPolicy&amp;&amp;</code></ins>.
       </p>
 
       <p>
@@ -158,16 +163,18 @@ <h1><code>ExecutionPolicy</code> algorithm overloads</h1>
       </p>
 
       <p>
-        Parallel algorithms shall not participate in overload resolution unless
-        <code>is_execution_policy&lt;ExecutionPolicy&gt;::value</code> is <code>true</code>.
+        Parallel algorithms
+        <del>have the requirement <code>is_execution_policy&lt;ExecutionPolicy&gt;::value</code> is <code>true</code></del>
+        <ins>shall not participate in overload resolution unless
+        <code>is_execution_policy&lt;ExecutionPolicy&gt;::value</code> is <code>true</code></ins>.
       </p>
 
       <p>The algorithms listed in <cxx-ref to="tab.parallel.algorithms"></cxx-ref> shall have <code>ExecutionPolicy</code> overloads.</p>
 
       <table is="cxx-table" id="tab.parallel.algorithms" class="list">
         <caption>Table of parallel algorithms</caption>
           <tr>
-            <td>adjacent_difference</td>
+            <td><ins>adjacent_difference</ins></td>
             <td>adjacent_find</td>
             <td>all_of</td>
             <td>any_of</td>
@@ -203,7 +210,7 @@ <h1><code>ExecutionPolicy</code> algorithm overloads</h1>
             <td>inclusive_scan</td>
           </tr>
           <tr>
-            <td>inner_product</td>
+            <td><ins>inner_product</ins></td>
             <td>inplace_merge</td>
             <td>is_heap</td>
             <td>is_heap_until</td>
@@ -378,9 +385,11 @@ <h1>For each</h1>
           its <code>Function</code> parameter, since parallelization may not permit efficient state
           accumulation.
 
-          Unlike its sequential form, the parallel overload of <code>for_each</code> requires
-          <code>Function</code> to meet the requirements of <code>CopyConstructible</code>, but not
-          <code>MoveConstructible</code>.
+          <ins>
+            Unlike its sequential form, the parallel overload of <code>for_each</code> requires
+            <code>Function</code> to meet the requirements of <code>CopyConstructible</code>, but not
+            <code>MoveConstructible</code>.
+          </ins>
         </cxx-notes>
       </cxx-function>
 
@@ -410,47 +419,49 @@ <h1>For each</h1>
         </cxx-effects>
 
         <cxx-returns>
-          <code>first + n</code> for non-negative values of <code>n</code> and <code>first</code> for negative values.
+          <code>first + n</code><ins> for non-negative values of <code>n</code> and <code>first</code> for negative values</ins>.
         </cxx-returns>
 
         <cxx-remarks>
           If <code>f</code> returns a result, the result is ignored.
         </cxx-remarks>
       </cxx-function>
 
-      <cxx-function>
-        <cxx-signature>
-        template&lt;class ExecutionPolicy,
-                 class InputIterator, class Size, class Function&gt;
-                 InputIterator for_each_n(ExecutionPolicy &amp;&amp; exec,
-                                          InputIterator first, Size n,
-                                          Function f);
-        </cxx-signature>
-
-        <cxx-effects>
-          Applies <code>f</code> to the result of dereferencing every iterator in the range
-          <code>[first,first + n)</code>, starting from <code>first</code> and proceeding to <code>first + n - 1</code>.
-
-          <cxx-note>
-            If the type of <code>first</code> satisfies the requirements of a mutable iterator,
-            <code>f</code> may apply nonconstant functions through the dereferenced iterator.
-          </cxx-note>
-        </cxx-effects>
-
-        <cxx-returns>
-          <code>first + n</code> for non-negative values of <code>n</code> and <code>first</code> for negative values.
-        </cxx-returns>
-
-        <cxx-remarks>
-          If <code>f</code> returns a result, the result is ignored.
-        </cxx-remarks>
-
-        <cxx-notes>
-          Unlike its sequential form, the parallel overload of <code>for_each_n</code> requires
-          <code>Function</code> to meet the requirements of <code>CopyConstructible</code>, but not
-          <code>MoveConstructible</code>.
-        </cxx-notes>
-      </cxx-function>
+      <ins>
+        <cxx-function>
+          <cxx-signature>
+          template&lt;class ExecutionPolicy,
+                   class InputIterator, class Size, class Function&gt;
+                   InputIterator for_each_n(ExecutionPolicy &amp;&amp; exec,
+                                            InputIterator first, Size n,
+                                            Function f);
+          </cxx-signature>
+
+          <cxx-effects>
+            Applies <code>f</code> to the result of dereferencing every iterator in the range
+            <code>[first,first + n)</code>, starting from <code>first</code> and proceeding to <code>first + n - 1</code>.
+
+            <cxx-note>
+              If the type of <code>first</code> satisfies the requirements of a mutable iterator,
+              <code>f</code> may apply nonconstant functions through the dereferenced iterator.
+            </cxx-note>
+          </cxx-effects>
+
+          <cxx-returns>
+          <code>first + n</code><ins> for non-negative values of <code>n</code> and <code>first</code> for negative values.
+          </cxx-returns>
+
+          <cxx-remarks>
+            If <code>f</code> returns a result, the result is ignored.
+          </cxx-remarks>
+
+          <cxx-notes>
+            Unlike its sequential form, the parallel overload of <code>for_each_n</code> requires
+            <code>Function</code> to meet the requirements of <code>CopyConstructible</code>, but not
+            <code>MoveConstructible</code>.
+          </cxx-notes>
+        </cxx-function>
+      </ins>
     </cxx-section>
 
     <cxx-section id="parallel.alg.novel.numeric.synop">
@@ -587,7 +598,7 @@ <h1>Reduce</h1>
 
         <cxx-notes>
           The primary difference between <code>reduce</code> and <code>accumulate</code> is that the behavior
-          of <code>reduce</code> may be non-deterministic for non-associative or non-commutative <code>binary_op</code>.
+          of <code>reduce</code> may be non-deterministic for non-associative or non-commutative <del><code>operator+</code></del><ins><code>binary_op</code></ins>.
         </cxx-notes>
       </cxx-function>
     </cxx-section>

execution_policies.html

@@ -12,18 +12,22 @@ <h1>In general</h1>
     <pre>std::vector&lt;int&gt; v = ...
 
 // standard sequential sort
-std::sort(vec.begin(), vec.end());                  
+<del>std::sort(vec.begin(), vec.end());</del>
+<ins>std::sort(std::begin(vec), std::end(vec));</ins>
 
 using namespace std::experimental::parallel;
 
 // explicitly sequential sort
-sort(seq, v.begin(), v.end());        
+<del>sort(seq, v.begin(), v.end());</del>
+<ins>sort(seq, std::begin(v), std::end(v));</ins>
 
 // permitting parallel execution
-sort(par, v.begin(), v.end());        
+<del>sort(par, v.begin(), v.end());</del>
+<ins>sort(par, std::begin(v), std::end(v));</ins>
 
 // permitting vectorization as well
-sort(vec, v.begin(), v.end());
+<del>sort(vec, v.begin(), v.end());</del>
+<ins>sort(vec, std::begin(v), std::end(v));</ins>
 
 // sort with dynamically-selected execution
 size_t threshold = ...
@@ -33,7 +37,8 @@ <h1>In general</h1>
   exec = par;
 }
 
-sort(exec, v.begin(), v.end());</pre>
+<del>sort(exec, v.begin(), v.end());</del>
+<ins>sort(exec, std::begin(v), std::end(v));</ins></pre>
     </cxx-example><pre>
 </pre> 
     <cxx-note>
@@ -172,15 +177,16 @@ <h1>Dynamic execution policy</h1>
     <cxx-example>
       <pre>std::vector&lt;float&gt; sort_me = ...
 
-using namespace std::experimental::parallel;
-execution_policy exec = seq;
+<ins>using namespace std::experimental::parallel;</ins>
+<del><code>std::</code></del>execution_policy exec = <del><code>std::</code></del>seq;
 
 if(sort_me.size() &gt; threshold)
 {
   exec = std::par;
 }
 
-std::sort(exec, sort_me.begin(), sort_me.end());</pre>
+<del>std::sort(exec, sort_me.begin(), sort_me.end());</del>
+<ins>std::sort(exec, std::begin(sort_me), std::end(sort_me));</ins></pre>
     </cxx-example>
 
     <p>Objects of type <code>execution_policy</code> shall be constructible and assignable from objects of
@@ -194,10 +200,17 @@ <h1><code>execution_policy</code> construct/assign</h1>
 
         <cxx-effects>Constructs an <code>execution_policy</code> object with a copy of <code>exec</code>'s state.</cxx-effects>
 
-        <cxx-remarks>
-          This constructor shall not participate in overload resolution unless
-          <code>is_execution_policy&lt;T&gt;::value</code> is <code>true</code>.
-        </cxx-remarks>
+        <del>
+          <cxx-requires>
+            <code>is_execution_policy&lt;T&gt;::value</code> is <code>true</code>.
+          </cxx-requires>
+        </del>
+        <ins>
+          <cxx-remarks>
+            This constructor shall not participate in overload resolution unless
+            <code>is_execution_policy&lt;T&gt;::value</code> is <code>true</code>.
+          </cxx-remarks>
+        </ins>
       </cxx-function>
 
       <cxx-function>
@@ -207,10 +220,17 @@ <h1><code>execution_policy</code> construct/assign</h1>
 
         <cxx-returns><code>*this</code>.
 
-        <cxx-remarks>
-          This operator shall not partipate in overload resolution unless
-          <code>is_execution_policy&lt;T&gt;::value</code> is <code>true</code>.
-        </cxx-remarks>
+        <del>
+          <cxx-requires>
+            <code>is_execution_policy&lt;T&gt;::value</code> is <code>true</code>.
+          </cxx-requires>
+        </del>
+        <ins>
+          <cxx-remarks>
+            This operator shall not partipate in overload resolution unless
+            <code>is_execution_policy&lt;T&gt;::value</code> is <code>true</code>.
+          </cxx-remarks>
+        </ins>
       </cxx-function>
     </cxx-section>
 
@@ -233,10 +253,17 @@ <h1><code>execution_policy</code> object access</h1>
 
         <cxx-returns>If <code>target_type() == typeid(T)</code>, a pointer to the stored execution policy object; otherwise a null pointer.</cxx-returns>
 
-        <cxx-remarks>
-          This function shall not participate in overload resolution unless
-          <code>is_execution_policy&lt;T&gt;</code> is <code>true</code>.
-        </cxx-remarks>
+        <del>
+          <cxx-requires>
+            <code>is_execution_policy&lt;T&gt;::value</code> is <code>true</code>.
+          </cxx-requires>
+        </del>
+        <ins>
+          <cxx-remarks>
+            This function shall not participate in overload resolution unless
+            <code>is_execution_policy&lt;T&gt;</code> is <code>true</code>.
+          </cxx-remarks>
+        </ins>
       </cxx-function>
 
     </cxx-section>

front_matter.html

@@ -1,6 +1,6 @@
 <cxx-titlepage stage="draft">
 <cxx-docnum>N3989</cxx-docnum>
-  <time pubdate="">2014-05-XX</time>
+  <time pubdate="">2014-05-23</time>
   <cxx-revises><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3960.pdf">N3960</a></cxx-revises>
   <cxx-editor>
     Jared Hoberock<br/>