Apply Matthias' corrections to <experimental/simd> synopsis

Author: jaredhoberock

data_parallel_types.html

@@ -44,16 +44,17 @@ <h1><ins>Header <code>&lt;experimental/simd&gt;</code> synopsis</ins></h1>
 
 namespace std::experimental {
 inline namespace parallelism_v2 {
-namespace simd_abi {
-
-  struct scalar {};
-  template&lt;int N&gt; struct fixed_size {};
-  template&lt;class T&gt; inline constexpr int max_fixed_size = <em>implementation-defined</em>;
-  template&lt;class T&gt; using compatible = <em>implementation-defined</em>;
-  template&lt;class T&gt; using native = <em>implementation-defined</em>;
-
-  template&lt;class T, size_t N&gt; struct deduce { using type = <em>see-below</em>; };
-  template&lt;class T, size_t N&gt; using deduce_t = typename deduce&lt;T, N&gt;::type;
+  namespace simd_abi {
+  
+    struct scalar {};
+    template&lt;int N&gt; struct fixed_size {};
+    template&lt;class T&gt; inline constexpr int max_fixed_size = <em>implementation-defined</em>;
+    template&lt;class T&gt; using compatible = <em>implementation-defined</em>;
+    template&lt;class T&gt; using native = <em>implementation-defined</em>;
+  
+    template&lt;class T, size_t N&gt; struct deduce { using type = <em>see-below</em>; };
+    template&lt;class T, size_t N&gt; using deduce_t = typename deduce&lt;T, N&gt;::type;
+  }
 
   struct element_aligned_tag {};
   struct vector_aligned_tag {};
@@ -62,7 +63,7 @@ <h1><ins>Header <code>&lt;experimental/simd&gt;</code> synopsis</ins></h1>
   inline constexpr vector_aligned_tag vector_aligned{};
   template&lt;size_t N&gt; inline constexpr overaligned_tag&lt;N&gt; overaligned{};
 
-  <cxx-ref insynopsis="" to="parallel.simd.traits"></cxx-ref> traits
+  <cxx-ref insynopsis="" to="parallel.simd.traits"></cxx-ref>
   template&lt;class T&gt; struct is_abi_tag;
   template&lt;class T&gt; inline constexpr bool is_abi_tag_v = is_abi_tag&lt;T&gt;::value;
 
@@ -83,17 +84,17 @@ <h1><ins>Header <code>&lt;experimental/simd&gt;</code> synopsis</ins></h1>
   template&lt;class T, class U = typename T::value_type&gt;
   inline constexpr size_t memory_alignment_v = memory_alignment&lt;T,U&gt;::value;
 
-  <cxx-ref insynopsis="" to="parallel.simd.class"></cxx-ref> class template simd
+  <cxx-ref insynopsis="" to="parallel.simd.class"></cxx-ref>
   template&lt;class T, class Abi = simd_abi::compatible&lt;T&gt;&gt; class simd;
-  template&lt;class T&gt; using native_simd&lt;T, simd_abi::native&lt;T&gt;&gt;;
+  template&lt;class T&gt; using native_simd = simd&lt;T, simd_abi::native&lt;T&gt;&gt;;
   template&lt;class T, int N&gt; using fixed_size_simd = simd&lt;T, simd_abi::fixed_size&lt;N&gt;&gt;;
 
-  <cxx-ref insynopsis="" to="parallel.simd.mask.class"></cxx-ref> class template simd_mask
+  <cxx-ref insynopsis="" to="parallel.simd.mask.class"></cxx-ref>
   template&lt;class T, class Abi = simd_abi::compatible&lt;T&gt;&gt; class simd_mask;
-  template&lt;class T&gt; using native_simd_mask&lt;T, simd_abi::native&lt;T&gt;&gt;;
+  template&lt;class T&gt; using native_simd_mask = simd_mask&lt;T, simd_abi::native&lt;T&gt;&gt;;
   template&lt;class T, int N&gt; using fixed_size_simd_mask = simd_mask&lt;T, simd_abi::fixed_size&lt;N&gt;&gt;;
 
-  <cxx-ref insynopsis="" to="parallel.simd.casts"></cxx-ref> casts
+  <cxx-ref insynopsis="" to="parallel.simd.casts"></cxx-ref>
   template&lt;class T, class U, class Abi&gt; <em>see-below</em> simd_cast(const simd&lt;U, Abi&gt;&);
   template&lt;class T, class U, class Abi&gt; <em>see-below</em> static_simd_cast(const simd&lt;U, Abi&gt;&);
 
@@ -116,11 +117,11 @@ <h1><ins>Header <code>&lt;experimental/simd&gt;</code> synopsis</ins></h1>
     array&lt;V, simd_size_v&lt;typename V::value_type, Abi&gt; / V::size()&gt; split(const simd_mask&lt;typename V::value_type, Abi&gt;&);
 
   template&lt;class T, class... Abis&gt;
-    simd&lt;T, simd_abi::deduce_t&gt;T, (simd_size_v&lt;T, Abis&gt; + ...)&gt;&gt; concat(const simd&lt;T, Abis&gt;&...);
+    simd&lt;T, simd_abi::deduce_t&lt;T, (simd_size_v&lt;T, Abis&gt; + ...)&gt;&gt; concat(const simd&lt;T, Abis&gt;&...);
   template&lt;class T, class... Abis&gt;
-    simd_mask&lt;T, simd_abi::deduce_t&gt;T, (simd_size_v&lt;T, Abis&gt; + ...)&gt;&gt; concat(const simd_mask&lt;T, Abis&gt;&...);
+    simd_mask&lt;T, simd_abi::deduce_t&lt;T, (simd_size_v&lt;T, Abis&gt; + ...)&gt;&gt; concat(const simd_mask&lt;T, Abis&gt;&...);
 
-  <cxx-ref insynopsys="" to="parallel.simd.mask.reductions"></cxx-ref> reductions
+  // <cxx-ref insynopsys="" to="parallel.simd.mask.reductions"></cxx-ref> reductions
   template&lt;class T, class Abi&gt; bool all_of(const simd_mask&lt;T, Abi&gt;&) noexcept;
   template&lt;class T, class Abi&gt; bool any_of(const simd_mask&lt;T, Abi&gt;&) noexcept;
   template&lt;class T, class Abi&gt; bool none_of(const simd_mask&lt;T, Abi&gt;&) noexcept;
@@ -137,11 +138,11 @@ <h1><ins>Header <code>&lt;experimental/simd&gt;</code> synopsis</ins></h1>
   int find_first_set(<em>see-below</em>) noexcept;
   int find_last_set(<em>see-below</em>) noexcept;
 
-  <cxx-ref insynopsis="" to="parallel.simd.whereexpr"></cxx-ref> where expressions
+  <cxx-ref insynopsis="" to="parallel.simd.whereexpr"></cxx-ref>
   template&lt;class M, class T&gt; class const_where_expression;
   template&lt;class M, class T&gt; class where_expression;
 
-  <cxx-ref insynopsis="" to="parallel.simd.mask.where"></cxx-ref> masked assignment
+  <cxx-ref insynopsis="" to="parallel.simd.mask.where"></cxx-ref>
   template&lt;class T&gt; struct nodeduce { using type = T; }; // exposition only
   template&lt;class T&gt; using nodeduce_t = typename nodeduce&lt;T&gt;::type; // exposition only
 
@@ -157,6 +158,9 @@ <h1><ins>Header <code>&lt;experimental/simd&gt;</code> synopsis</ins></h1>
   template&lt;class T, class Abi&gt;
   const_where_expression&lt;simd_mask&lt;T, Abi&gt;, simd_mask&lt;T, Abi&gt;&gt; where(const nodeduce_t&lt;simd_mask&lt;T, Abit&gt;&gt;&, const simd_mask&lt;T, Abi&gt;&) noexcept;
 
+  template&lt;class T&gt;
+  where_expression&lt;bool, T&gt; where(<em>see-below</em> k, T& d) noexcept;
+
   template&lt;class T&gt;
   const_where_expression&lt;bool, T&gt; where(<em>see-below</em> k, const T& d) noexcept;
 
@@ -168,28 +172,27 @@ <h1><ins>Header <code>&lt;experimental/simd&gt;</code> synopsis</ins></h1>
   typename V::value_type reduce(const const_where_expression&lt;M, V&gt;& x,
                                 typename V::value_type identity_element, BinaryOperation binary_op);
   template&lt;class M, class V&gt;
-  typename V::value_type reduce(const const_where_expression&lt;M, V&gt; x, plus&lt;&gt; binary_op = {});
+  typename V::value_type reduce(const const_where_expression&lt;M, V&gt;& x, plus&lt;&gt; binary_op = {});
   template&lt;class M, class V&gt;
-  typename V::value_type reduce(const const_where_expression&lt;M, V&gt; x, multiplies&lt;&gt; binary_op = {});
+  typename V::value_type reduce(const const_where_expression&lt;M, V&gt;& x, multiplies&lt;&gt; binary_op);
   template&lt;class M, class V&gt;
-  typename V::value_type reduce(const const_where_expression&lt;M, V&gt; x, bit_and&lt;&gt; binary_op = {});
+  typename V::value_type reduce(const const_where_expression&lt;M, V&gt;& x, bit_and&lt;&gt; binary_op);
   template&lt;class M, class V&gt;
-  typename V::value_type reduce(const const_where_expression&lt;M, V&gt; x, bit_or&lt;&gt; binary_op = {});
+  typename V::value_type reduce(const const_where_expression&lt;M, V&gt;& x, bit_or&lt;&gt; binary_op);
   template&lt;class M, class V&gt;
-  typename V::value_type reduce(const const_where_expression&lt;M, V&gt; x, bit_xor&lt;&gt; binary_op = {});
+  typename V::value_type reduce(const const_where_expression&lt;M, V&gt;& x, bit_xor&lt;&gt; binary_op);
 
   template&lt;class T, class Abi&gt; T hmin(const simd&lt;T, abi&gt;&);
   template&lt;class T, class Abi&gt; typename V::value_type hmin(const const_where_expression&lt;M, V&gt;&);
   template&lt;class T, class Abi&gt; T hmax(const simd&lt;T, abi&gt;&);
   template&lt;class T, class Abi&gt; typename V::value_type hmax(const const_where_expression&lt;M, V&gt;&);
 
-  <cxx-ref insynopsis="" to="parallel.simd.alg"></cxx-ref> algorithms
+  <cxx-ref insynopsis="" to="parallel.simd.alg"></cxx-ref>
   template&lt;class T, class Abi&gt; simd&lt;T, Abi&gt; min(const simd&lt;T, Abi&gt;& a, const simd&lt;T, Abi&gt;& b) noexcept;
   template&lt;class T, class Abi&gt; simd&lt;T, Abi&gt; max(const simd&lt;T, Abi&gt;& a, const simd&lt;T, Abi&gt;& b) noexcept;
-  template&lt;class T, class Abi&gt; simd&lt;T, Abi&gt; minmax(const simd&lt;T, Abi&gt;& a, const simd&lt;T, Abi&gt;& b) noexcept;
+  template&lt;class T, class Abi&gt; pair&lt;simd&lt;T, Abi&gt;, simd&lt;T, Abi&gt;&gt; minmax(const simd&lt;T, Abi&gt;& a, const simd&lt;T, Abi&gt;& b) noexcept;
   template&lt;class T, class Abi&gt; simd&lt;T, Abi&gt; clamp(const simd&lt;T, Abi&gt;& v, const simd&lt;T, Abi&gt;& lo, const simd&lt;T, Abi&gt;& hi) noexcept;
 }
-}
 }
     </pre>
     </ins>