Merge pull request #64 from jaredhoberock/v2

Break up these long lines so that they don't spill into the margin

Author: jaredhoberock

data_parallel_types.html

@@ -74,7 +74,8 @@ <h1><ins>Header <code>&lt;experimental/simd&gt;</code> synopsis</ins></h1>
   template&lt;class T&gt; inline constexpr bool is_simd_mask_v = is_simd_mask&lt;T&gt;::value;
 
   template&lt;class T&gt; struct is_simd_flag_type;
-  template&lt;class T&gt; inline constexpr bool is_simd_flag_type_v = is_simd_flag_type&lt;T&gt;::value;
+  template&lt;class T&gt; inline constexpr bool is_simd_flag_type_v =
+    is_simd_flag_type&lt;T&gt;::value;
 
   template&lt;class T, class Abi = simd_abi::compatible&lt;T&gt;&gt; struct simd_size;
   template&lt;class T, class Abi = simd_abi::compatible&lt;T&gt;&gt;
@@ -92,34 +93,47 @@ <h1><ins>Header <code>&lt;experimental/simd&gt;</code> synopsis</ins></h1>
   <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 = 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;;
+  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>
   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;&);
 
   template&lt;class T, class Abi&gt;
-    fixed_size_simd&lt;T, simd_size_v&lt;T, Abi&gt;&gt; to_fixed_size(const simd&lt;T, Abi&gt;&) noexcept;
+    fixed_size_simd&lt;T, simd_size_v&lt;T, Abi&gt;&gt;
+      to_fixed_size(const simd&lt;T, Abi&gt;&) noexcept;
   template&lt;class T, class Abi&gt;
-    fixed_size_simd_mask&lt;T, simd_size_v&lt;T, Abi&gt;&gt; to_fixed_size(const simd_mask&lt;T, Abi&gt;&) noexcept;
-  template&lt;class T, int N&gt; native_simd&lt;T&gt; to_native(const fixed_size_simd&lt;T, N&gt;&) noexcept;
-  template&lt;class T, int N&gt; native_simd_mask&lt;T&gt; to_native(const fixed_size_simd_mask&lt;T, N&gt;&) noexcept;
-  template&lt;class T, int N&gt; simd&lt;T&gt; to_compatible(const fixed_size_simd&lt;T, N&gt;&) noexcept;
-  template&lt;class T, int N&gt; simd_mask&lt;T&gt; to_compatible(const fixed_size_simd_mask&lt;T, N&gt;&) noexcept;
+    fixed_size_simd_mask&lt;T, simd_size_v&lt;T, Abi&gt;&gt;
+      to_fixed_size(const simd_mask&lt;T, Abi&gt;&) noexcept;
+  template&lt;class T, int N&gt;
+    native_simd&lt;T&gt; to_native(const fixed_size_simd&lt;T, N&gt;&) noexcept;
+  template&lt;class T, int N&gt;
+    native_simd_mask&lt;T&gt; to_native(const fixed_size_simd_mask&lt;T, N&gt;&) noexcept;
+  template&lt;class T, int N&gt;
+    simd&lt;T&gt; to_compatible(const fixed_size_simd&lt;T, N&gt;&) noexcept;
+  template&lt;class T, int N&gt;
+    simd_mask&lt;T&gt; to_compatible(const fixed_size_simd_mask&lt;T, N&gt;&) noexcept;
 
   template&lt;size_t... Sizes, class T, class Abi&gt;
-    tuple&lt;simd&lt;T, simd_abi::deduce_t&lt;T, Sizes&gt;&gt;...&gt; split(const simd&lt;T, Abi&gt;&);
+    tuple&lt;simd&lt;T, simd_abi::deduce_t&lt;T, Sizes&gt;&gt;...&gt;
+      split(const simd&lt;T, Abi&gt;&);
   template&lt;size_t... Sizes, class T, class Abi&gt;
-    tuple&lt;simd_mask&lt;T, simd_mask_abi::deduce_t&lt;T, Sizes&gt;&gt;...&gt; split(const simd_mask&lt;T, Abi&gt;&);
+    tuple&lt;simd_mask&lt;T, simd_mask_abi::deduce_t&lt;T, Sizes&gt;&gt;...&gt;
+      split(const simd_mask&lt;T, Abi&gt;&);
   template&lt;class V, class Abi&gt;
-    array&lt;V, simd_size_v&lt;typename V::value_type, Abi&gt; / V::size()&gt; split(const simd&lt;typename V::value_type, Abi&gt;&);
+    array&lt;V, simd_size_v&lt;typename V::value_type, Abi&gt; / V::size()&gt;
+      split(const simd&lt;typename V::value_type, Abi&gt;&);
   template&lt;class V, class Abi&gt;
-    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;&);
+    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&lt;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&lt;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 insynopsis="" to="parallel.simd.mask.reductions"></cxx-ref>
   template&lt;class T, class Abi&gt; bool all_of(const simd_mask&lt;T, Abi&gt;&) noexcept;
@@ -147,51 +161,83 @@ <h1><ins>Header <code>&lt;experimental/simd&gt;</code> synopsis</ins></h1>
   template&lt;class T&gt; using nodeduce_t = typename nodeduce&lt;T&gt;::type; // exposition only
 
   template&lt;class T, class Abi&gt;
-    where_expression&lt;simd_mask&lt;T, Abi&gt;, simd&lt;T, Abi&gt;&gt; where(const typename simd&lt;T, Abi&gt;::mask_type&, simd&lt;T, Abi&gt;&) noexcept;
+    where_expression&lt;simd_mask&lt;T, Abi&gt;, simd&lt;T, Abi&gt;&gt;
+      where(const typename simd&lt;T, Abi&gt;::mask_type&, simd&lt;T, Abi&gt;&) noexcept;
 
   template&lt;class T, class Abi&gt;
-    const_where_expression&lt;simd_mask&lt;T, Abi&gt;, simd&lt;T, Abi&gt;&gt; where(const typename simd&lt;T, Abi&gt;::mask_type&, const simd&lt;T, Abi&gt;&) noexcept;
+    const_where_expression&lt;simd_mask&lt;T, Abi&gt;, simd&lt;T, Abi&gt;&gt;
+      where(const typename simd&lt;T, Abi&gt;::mask_type&, const simd&lt;T, Abi&gt;&) noexcept;
 
   template&lt;class T, class Abi&gt;
-    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;&, simd_mask&lt;T, Abi&gt;&) noexcept;
+    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;&, simd_mask&lt;T, Abi&gt;&) noexcept;
 
   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;
+    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;
+    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;
+    const_where_expression&lt;bool, T&gt;
+      where(<em>see below</em> k, const T& d) noexcept;
 
   <cxx-ref insynopsis="" to="parallel.simd.reductions"></cxx-ref>
   template&lt;class T, class Abi, class BinaryOperation = plus&lt;&gt;&gt;
-    T reduce(const simd&lt;T, Abi&gt;&, BinaryOperation = {});
+    T reduce(const simd&lt;T, Abi&gt;&,
+             BinaryOperation = {});
 
   template&lt;class M, class V, class BinaryOperation&gt;
     typename V::value_type reduce(const const_where_expression&lt;M, V&gt;& x,
-                                  typename V::value_type identity_element, BinaryOperation binary_op);
+                                  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;&);
+  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>
-  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; 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;
+  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;
+    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>
@@ -2179,9 +2225,11 @@ <h1><ins>Casts</ins></h1>
       <cxx-function>
         <cxx-signature><ins>
 template&lt;size_t... Sizes, class T, class Abi&gt;
-tuple&lt;simd&lt;T, simd_abi::deduce_t&lt;T, Sizes&gt;&gt;...&gt; split(const simd&lt;T, Abi&gt;& x);
+  tuple&lt;simd&lt;T, simd_abi::deduce_t&lt;T, Sizes&gt;&gt;...&gt;
+    split(const simd&lt;T, Abi&gt;& x);
 template&lt;size_t... Sizes, class T, class Abi&gt;
-tuple&lt;simd_mask&lt;T, simd_abi::deduce_t&lt;T, Sizes&gt;&gt;...&gt; split(const simd_mask&lt;T, Abi&gt;& x);
+  tuple&lt;simd_mask&lt;T, simd_abi::deduce_t&lt;T, Sizes&gt;&gt;...&gt;
+    split(const simd_mask&lt;T, Abi&gt;& x);
 </ins></cxx-signature>
 
         <cxx-returns>
@@ -2200,9 +2248,11 @@ <h1><ins>Casts</ins></h1>
       <cxx-function>
         <cxx-signature><ins>
 template&lt;class V, class Abi&gt;
-array&lt;V, simd_size_v&lt;typename V::value_type, Abi&gt; / V::size()&gt; split(const simd&lt;typename V::value_type, Abi&gt;& x);
+  array&lt;V, simd_size_v&lt;typename V::value_type, Abi&gt; / V::size()&gt;
+    split(const simd&lt;typename V::value_type, Abi&gt;& x);
 template&lt;class V, class Abi&gt;
-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;& x);
+  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;& x);
 </ins></cxx-signature>
 
         <cxx-returns>
@@ -2408,7 +2458,8 @@ <h1><ins>Class template <code>simd_mask</code> overview</ins></h1>
   explicit simd_mask(value_type) noexcept;
 
   <em>// implicit type conversion constructor</em>
-  template&lt;class U&gt; simd_mask(const simd_mask&lt;U, simd_abi::fixed_size&lt;size()&gt;&gt;&) noexcept;
+  template&lt;class U&gt;
+    simd_mask(const simd_mask&lt;U, simd_abi::fixed_size&lt;size()&gt;&gt;&) noexcept;
 
   <em>// load constructor</em>
   template&lt;class Flags&gt; simd_mask(const value_Type* mem, Flags);