P2663R7 Interleaved complex values support in std::simd

Author: mattkretz

source/numerics.tex

@@ -16056,12 +16056,17 @@
 \end{note}
 
 \pnum
-The set of \defnadjx{vectorizable}{types}{type} comprises all standard integer
-types, character types, and the types \tcode{float} and
-\tcode{double}\iref{basic.fundamental}.
-In addition, \tcode{std::float16_t}, \tcode{std::float32_t}, and
-\tcode{std::float64_t} are vectorizable types if
-defined\iref{basic.extended.fp}.
+The set of \defnadjx{vectorizable}{types}{type} comprises
+\begin{itemize}
+ \item
+   all standard integer types, character types, and the types \tcode{float} and
+   \tcode{double}\iref{basic.fundamental};
+ \item
+   \tcode{std::float16_t}, \tcode{std::float32_t}, and \tcode{std::float64_t}
+   if defined\iref{basic.extended.fp}; and
+ \item
+   \tcode{complex<T>} where \tcode{T} is a vectorizable floating-point type.
+\end{itemize}
 
 \pnum
 The term \defnadj{data-parallel}{type} refers to all enabled specializations of
@@ -16130,8 +16135,14 @@
 
 template<class V>
   concept @\defexposconceptnc{simd-floating-point}@ =                                      // \expos
-    @\libconcept{same_as}@<V, basic_simd<typename V::value_type, typename V::abi_type>> &&
-    is_default_constructible_v<V> && @\libconcept{floating_point}@<typename V::value_type>;
+    @\exposconcept{simd-type}@<V> && @\libconcept{floating_point}@<typename V::value_type>;
+
+template<class V>
+  using @\exposidnc{simd-complex-value-type}@ = typename V::value_type::value_type; // \expos
+
+template<class V>
+  concept @\defexposconceptnc{simd-complex}@ =                                             // \expos
+  @\exposconcept{simd-type}@<V> && @\libconcept{same_as}@<typename V::value_type, complex<@\exposid{simd-complex-value-type}@<V>>>;
 
 template<class... Ts>
   concept @\defexposconceptnc{math-floating-point}@ =                                      // \expos
@@ -16778,6 +16789,47 @@
   template<@\exposconcept{simd-type}@ V>
     constexpr rebind_simd_t<make_signed_t<typename V::value_type>, V>
     popcount(const V& v) noexcept;
+
+  // \ref{simd.complex.math}, simd complex math
+  template<@\exposconcept{simd-complex}@ V>
+    constexpr rebind_simd_t<@\exposid{simd-complex-value-type<V>}@, V> real(const V&) noexcept;
+
+  template<@\exposconcept{simd-complex}@ V>
+    constexpr rebind_simd_t<@\exposid{simd-complex-value-type<V>}@, V> imag(const V&) noexcept;
+
+  template<@\exposconcept{simd-complex}@ V>
+    constexpr rebind_simd_t<@\exposid{simd-complex-value-type<V>}@, V> abs(const V&);
+
+  template<@\exposconcept{simd-complex}@ V>
+    constexpr rebind_simd_t<@\exposid{simd-complex-value-type<V>}@, V> arg(const V&);
+
+  template<@\exposconcept{simd-complex}@ V>
+    constexpr rebind_simd_t<@\exposid{simd-complex-value-type<V>}@, V> norm(const V&);
+
+  template<@\exposconcept{simd-complex}@ V> constexpr V conj(const V&);
+  template<@\exposconcept{simd-complex}@ V> constexpr V proj(const V&);
+  template<@\exposconcept{simd-complex}@ V> constexpr V exp(const V& v);
+  template<@\exposconcept{simd-complex}@ V> constexpr V log(const V& v);
+  template<@\exposconcept{simd-complex}@ V> constexpr V log10(const V& v);
+
+  template<@\exposconcept{simd-complex}@ V> constexpr V sqrt(const V& v);
+  template<@\exposconcept{simd-complex}@ V> constexpr V sin(const V& v);
+  template<@\exposconcept{simd-complex}@ V> constexpr V asin(const V& v);
+  template<@\exposconcept{simd-complex}@ V> constexpr V cos(const V& v);
+  template<@\exposconcept{simd-complex}@ V> constexpr V acos(const V& v);
+  template<@\exposconcept{simd-complex}@ V> constexpr V tan(const V& v);
+  template<@\exposconcept{simd-complex}@ V> constexpr V atan(const V& v);
+  template<@\exposconcept{simd-complex}@ V> constexpr V sinh(const V& v);
+  template<@\exposconcept{simd-complex}@ V> constexpr V asinh(const V& v);
+  template<@\exposconcept{simd-complex}@ V> constexpr V cosh(const V& v);
+  template<@\exposconcept{simd-complex}@ V> constexpr V acosh(const V& v);
+  template<@\exposconcept{simd-complex}@ V> constexpr V tanh(const V& v);
+  template<@\exposconcept{simd-complex}@ V> constexpr V atanh(const V& v);
+
+  template<@\exposconcept{simd-floating-point}@ V>
+    rebind_simd_t<complex<typename V::value_type>, V> polar(const V& x, const V& y = {});
+
+  template<@\exposconcept{simd-complex}@ V> constexpr V pow(const V& x, const V& y);
 }
 \end{codeblock}
 
@@ -16951,6 +17003,8 @@
       constexpr basic_simd(R&& range, simd_flags<Flags...> = {});
     template<class R, class... Flags>
       constexpr basic_simd(R&& range, const mask_type& mask, simd_flags<Flags...> = {});
+    template<@\exposid{simd-floating-point}@ V>
+      constexpr explicit(@\seebelow@) basic_simd(const V& reals, const V& imags = {}) noexcept;
 
     // \ref{simd.subscr}, \tcode{basic_simd} subscript operators
     constexpr value_type operator[](@\exposid{simd-size-type}@) const;
@@ -17001,6 +17055,14 @@
     friend constexpr mask_type operator>(const basic_simd&, const basic_simd&) noexcept;
     friend constexpr mask_type operator<(const basic_simd&, const basic_simd&) noexcept;
 
+    // \ref{simd.complex.access}, \tcode{basic_simd} complex-value accessors
+    constexpr auto real() const noexcept;
+    constexpr auto imag() const noexcept;
+    template<@\exposid{simd-floating-point}@ V>
+      constexpr void real(const V& v) noexcept;
+    template<@\exposid{simd-floating-point}@ V>
+      constexpr void imag(const V& v) noexcept;
+
     // \ref{simd.cond}, \tcode{basic_simd} exposition only conditional operators
     friend constexpr basic_simd @\exposid{simd-select-impl}@( // \expos
       const mask_type&, const basic_simd&, const basic_simd&) noexcept;
@@ -17026,14 +17088,16 @@
    specializations} if such a specialization is enabled.
 \end{itemize}
 
-If \tcode{basic_simd<T, Abi>} is disabled, the specialization has a
+If \tcode{basic_simd<T, Abi>} is disabled, then the specialization has a
 deleted default constructor, deleted destructor, deleted copy constructor, and
 deleted copy assignment.
 In addition only the \tcode{value_type}, \tcode{abi_type}, and
 \tcode{mask_type} members are present.
 
-If \tcode{basic_simd<T, Abi>} is enabled, \tcode{basic_simd<T, Abi>} is
-trivially copyable.
+If \tcode{basic_simd<T, Abi>} is enabled, then \tcode{basic_simd<T, Abi>} is
+trivially copyable, default-initialization of an object of such a type
+default-initializes all elements, and value-initialization value-initializes
+all elements\iref{dcl.init.general}.
 
 \pnum
 \recommended
@@ -17214,6 +17278,34 @@
 ranges::size(r)>}.
 \end{itemdescr}
 
+\begin{itemdecl}
+template<@\exposconcept{simd-floating-point}@ V>
+  constexpr explicit(@\seebelow@)
+  basic_simd(const V& reals, const V& imags = {}) noexcept;
+\end{itemdecl}
+
+\begin{itemdescr}
+\pnum
+\constraints
+\begin{itemize}
+ \item
+   \tcode{\exposconcept{simd-complex}<basic_simd>} is modeled, and
+ \item
+   \tcode{V::size() == size()} is \tcode{true}.
+\end{itemize}
+
+\pnum
+\effects
+Initializes the $i^\text{th}$ element with \tcode{value_type(reals[$i$],
+imags[$i$])} for all $i$ in the range \range{0}{size()}.
+
+\pnum
+\remarks
+The expression inside \tcode{explicit} evaluates to \tcode{false} if and only
+if the floating-point conversion rank of \tcode{T::value_type} is greater than
+or equal to the floating-point conversion rank of \tcode{V::value_type}.
+\end{itemdescr}
+
 \rSec3[simd.subscr]{\tcode{basic_simd} subscript operator}
 
 \begin{itemdecl}
@@ -17504,6 +17596,55 @@
 operation.
 \end{itemdescr}
 
+\rSec3[simd.complex.access]{\tcode{simd} complex accessors}
+
+\begin{itemdecl}
+constexpr auto real() const noexcept;
+constexpr auto imag() const noexcept;
+\end{itemdecl}
+
+\begin{itemdescr}
+\pnum
+\constraints
+\tcode{\exposconcept{simd-complex}<basic_simd>} is modeled.
+
+\pnum
+\returns
+An object of type \tcode{rebind_simd_t<typename T::value_type, basic_simd>}
+where the $i^\text{th}$ element is initialized to the result of
+\tcode{\placeholder{cmplx-func}(operator[]($i$))} for all $i$ in the range
+\range{0}{size()}, where \placeholder{cmplx-func} is the corresponding function
+from \tcode{<complex>}.
+\end{itemdescr}
+
+\begin{itemdecl}
+template<@\exposconcept{simd-floating-point}@ V>
+  constexpr void real(const V& v) noexcept;
+template<@\exposconcept{simd-floating-point}@ V>
+  constexpr void imag(const V& v) noexcept;
+\end{itemdecl}
+
+\begin{itemdescr}
+\pnum
+\constraints
+\begin{itemize}
+ \item
+   \tcode{\exposconcept{simd-complex}<basic_simd>} is modeled,
+ \item
+   \tcode{\libconcept{same_as}<typename V::value_type, typename T::value_type>}
+   is modeled, and
+ \item
+   \tcode{V::size() == size()} is \tcode{true}.
+\end{itemize}
+
+\pnum
+\effects
+Replaces each element of the \tcode{basic_simd} object such that the
+$i^\text{th}$ element is replaced with \tcode{value_type(v[$i$],
+operator[]($i$).imag())} or \tcode{value_type(operator[]($i$).real(), v[$i$])}
+for \tcode{real} and \tcode{imag} respectively, for all $i$ in the range \range{0}{size()}.
+\end{itemdescr}
+
 \rSec3[simd.cond]{\tcode{basic_simd} exposition only conditional operators}
 
 \begin{itemdecl}
@@ -18638,6 +18779,79 @@
 function from \tcode{<bit>}.
 \end{itemdescr}
 
+\rSec3[simd.complex.math]{\tcode{simd} complex math}
+
+\begin{itemdecl}
+template<@\exposconcept{simd-complex}@ V>
+  constexpr rebind_simd_t<@\exposid{simd-complex-value-type<V>}@, V> real(const V&) noexcept;
+template<@\exposconcept{simd-complex}@ V>
+  constexpr rebind_simd_t<@\exposid{simd-complex-value-type<V>}@, V> imag(const V&) noexcept;
+
+template<@\exposconcept{simd-complex}@ V>
+  constexpr rebind_simd_t<@\exposid{simd-complex-value-type<V>}@, V> abs(const V&);
+template<@\exposconcept{simd-complex}@ V>
+  constexpr rebind_simd_t<@\exposid{simd-complex-value-type<V>}@, V> arg(const V&);
+template<@\exposconcept{simd-complex}@ V>
+  constexpr rebind_simd_t<@\exposid{simd-complex-value-type<V>}@, V> norm(const V&);
+template<@\exposconcept{simd-complex}@ V> constexpr V conj(const V&);
+template<@\exposconcept{simd-complex}@ V> constexpr V proj(const V&);
+
+template<@\exposconcept{simd-complex}@ V> constexpr V exp(const V& v);
+template<@\exposconcept{simd-complex}@ V> constexpr V log(const V& v);
+template<@\exposconcept{simd-complex}@ V> constexpr V log10(const V& v);
+
+template<@\exposconcept{simd-complex}@ V> constexpr V sqrt(const V& v);
+template<@\exposconcept{simd-complex}@ V> constexpr V sin(const V& v);
+template<@\exposconcept{simd-complex}@ V> constexpr V asin(const V& v);
+template<@\exposconcept{simd-complex}@ V> constexpr V cos(const V& v);
+template<@\exposconcept{simd-complex}@ V> constexpr V acos(const V& v);
+template<@\exposconcept{simd-complex}@ V> constexpr V tan(const V& v);
+template<@\exposconcept{simd-complex}@ V> constexpr V atan(const V& v);
+template<@\exposconcept{simd-complex}@ V> constexpr V sinh(const V& v);
+template<@\exposconcept{simd-complex}@ V> constexpr V asinh(const V& v);
+template<@\exposconcept{simd-complex}@ V> constexpr V cosh(const V& v);
+template<@\exposconcept{simd-complex}@ V> constexpr V acosh(const V& v);
+template<@\exposconcept{simd-complex}@ V> constexpr V tanh(const V& v);
+template<@\exposconcept{simd-complex}@ V> constexpr V atanh(const V& v);
+\end{itemdecl}
+
+\begin{itemdescr}
+\pnum
+\returns
+A \tcode{basic_simd} object \tcode{ret} where the $i^\text{th}$ element is
+initialized to the result of \tcode{\placeholder{cmplx-func}(v[$i$])} for all
+$i$ in the range \range{0}{V::size()}, where \placeholder{cmplx-func} is the
+corresponding function from \tcode{<complex>}. If in an invocation of
+\placeholder{cmplx-func} for index $i$ a domain, pole, or range error would
+occur, the value of \tcode{ret[$i$]} is unspecified.
+
+\pnum
+\remarks
+It is unspecified whether \tcode{errno}\iref{errno} is accessed.
+\end{itemdescr}
+
+\begin{itemdecl}
+template<@\exposconcept{simd-floating-point}@ V>
+  rebind_simd_t<complex<typename V::value_type>, V> polar(const V& x, const V& y = {});
+
+template<@\exposconcept{simd-complex}@ V> constexpr V pow(const V& x, const V& y);
+\end{itemdecl}
+
+\begin{itemdescr}
+\pnum
+\returns
+A \tcode{basic_simd} object \tcode{ret} where the $i^\text{th}$ element is
+initialized to the result of \tcode{\placeholder{cmplx-func}(x[$i$], y[$i$])}
+for all $i$ in the range \range{0}{V::size()}, where \placeholder{cmplx-func}
+is the corresponding function from \tcode{<complex>}. If in an invocation of
+\placeholder{cmplx-func} for index $i$ a domain, pole, or range error would
+occur, the value of \tcode{ret[$i$]} is unspecified.
+
+\pnum
+\remarks
+It is unspecified whether \tcode{errno}\iref{errno} is accessed.
+\end{itemdescr}
+
 \rSec2[simd.mask.class]{Class template \tcode{basic_simd_mask}}
 
 \rSec3[simd.mask.overview]{Class template \tcode{basic_simd_mask} overview}

source/support.tex

@@ -783,6 +783,7 @@
 #define @\defnlibxname{cpp_lib_shared_timed_mutex}@                201402L // also in \libheader{shared_mutex}
 #define @\defnlibxname{cpp_lib_shift}@                             202202L // also in \libheader{algorithm}
 #define @\defnlibxname{cpp_lib_simd}@                              202502L // also in \libheader{simd}
+#define @\defnlibxname{cpp_lib_simd_complex}@                      202502L // also in \libheader{simd}
 #define @\defnlibxname{cpp_lib_smart_ptr_for_overwrite}@           202002L // also in \libheader{memory}
 #define @\defnlibxname{cpp_lib_smart_ptr_owner_equality}@          202306L // also in \libheader{memory}
 #define @\defnlibxname{cpp_lib_source_location}@                   201907L // freestanding, also in \libheader{source_location}