#1749 - Applying same_lanes_or_scalar to some modules

jfalcou · May 18, 2024 · 95081f0 · 95081f0
1 parent bf9a87f
commit 95081f0
Show file tree

Hide file tree

Showing 31 changed files with 87 additions and 35 deletions.
diff --git a/include/eve/module/bessel/regular/cyl_bessel_in.hpp b/include/eve/module/bessel/regular/cyl_bessel_in.hpp
@@ -17,8 +17,9 @@ namespace eve
   struct cyl_bessel_in_t : strict_elementwise_callable<cyl_bessel_in_t, Options>
   {
     template<eve::value N, eve::floating_value T>
-    EVE_FORCEINLINE constexpr
-    as_wide_as_t<T, N> operator()(N n, T x) const  { return EVE_DISPATCH_CALL(n, x); }
+    requires (same_lanes_or_scalar<N, T>)
+    EVE_FORCEINLINE constexpr as_wide_as_t<T, N> operator()(N n, T x) const noexcept
+    { return EVE_DISPATCH_CALL(n, x); }
 
     EVE_CALLABLE_OBJECT(cyl_bessel_in_t, cyl_bessel_in_);
   };

diff --git a/include/eve/module/bessel/regular/cyl_bessel_jn.hpp b/include/eve/module/bessel/regular/cyl_bessel_jn.hpp
@@ -17,8 +17,10 @@ namespace eve
   struct cyl_bessel_jn_t : strict_elementwise_callable<cyl_bessel_jn_t, Options>
   {
     template<eve::value N, eve::floating_value T>
+    requires (same_lanes_or_scalar<N, T>)
     EVE_FORCEINLINE constexpr
-    as_wide_as_t<T, N> operator()(N n, T x) const  { return EVE_DISPATCH_CALL(n, x); }
+    as_wide_as_t<T, N> operator()(N n, T x) const
+    { return EVE_DISPATCH_CALL(n, x); }
 
     EVE_CALLABLE_OBJECT(cyl_bessel_jn_t, cyl_bessel_jn_);
   };

diff --git a/include/eve/module/bessel/regular/cyl_bessel_kn.hpp b/include/eve/module/bessel/regular/cyl_bessel_kn.hpp
@@ -17,8 +17,9 @@ namespace eve
   struct cyl_bessel_kn_t : strict_elementwise_callable<cyl_bessel_kn_t, Options>
   {
     template<eve::value N, eve::floating_value T>
-    EVE_FORCEINLINE constexpr
-    as_wide_as_t<T, N> operator()(N n, T x) const  { return EVE_DISPATCH_CALL(n, x); }
+    requires (same_lanes_or_scalar<N, T>)
+    EVE_FORCEINLINE constexpr as_wide_as_t<T, N> operator()(N n, T x) const noexcept
+    { return EVE_DISPATCH_CALL(n, x); }
 
     EVE_CALLABLE_OBJECT(cyl_bessel_kn_t, cyl_bessel_kn_);
   };

diff --git a/include/eve/module/bessel/regular/cyl_bessel_yn.hpp b/include/eve/module/bessel/regular/cyl_bessel_yn.hpp
@@ -17,8 +17,9 @@ namespace eve
   struct cyl_bessel_yn_t : strict_elementwise_callable<cyl_bessel_yn_t, Options>
   {
     template<eve::value N, eve::floating_value T>
-    EVE_FORCEINLINE constexpr
-    as_wide_as_t<T, N> operator()(N n, T x) const  { return EVE_DISPATCH_CALL(n, x); }
+    requires (same_lanes_or_scalar<N, T>)
+    EVE_FORCEINLINE constexpr as_wide_as_t<T, N> operator()(N n, T x) const noexcept
+    { return EVE_DISPATCH_CALL(n, x); }
 
     EVE_CALLABLE_OBJECT(cyl_bessel_yn_t, cyl_bessel_yn_);
   };

diff --git a/include/eve/module/bessel/regular/sph_bessel_jn.hpp b/include/eve/module/bessel/regular/sph_bessel_jn.hpp
@@ -17,8 +17,9 @@ namespace eve
   struct sph_bessel_jn_t : strict_elementwise_callable<sph_bessel_jn_t, Options>
   {
     template<eve::value N, eve::floating_value T>
-    EVE_FORCEINLINE constexpr
-    as_wide_as_t<T, N> operator()(N n, T x) const  { return EVE_DISPATCH_CALL(n, x); }
+    requires (same_lanes_or_scalar<N, T>)
+    EVE_FORCEINLINE constexpr as_wide_as_t<T, N> operator()(N n, T x) const noexcept
+    { return EVE_DISPATCH_CALL(n, x); }
 
     EVE_CALLABLE_OBJECT(sph_bessel_jn_t, sph_bessel_jn_);
   };

diff --git a/include/eve/module/bessel/regular/sph_bessel_yn.hpp b/include/eve/module/bessel/regular/sph_bessel_yn.hpp
@@ -17,8 +17,10 @@ namespace eve
   struct sph_bessel_yn_t : strict_elementwise_callable<sph_bessel_yn_t, Options>
   {
     template<eve::value N, eve::floating_value T>
+    requires (same_lanes_or_scalar<N, T>)
     EVE_FORCEINLINE constexpr
-    as_wide_as_t<T, N> operator()(N n, T x) const  { return EVE_DISPATCH_CALL(n, x); }
+    as_wide_as_t<T, N> operator()(N n, T x) const noexcept
+    { return EVE_DISPATCH_CALL(n, x); }
 
     EVE_CALLABLE_OBJECT(sph_bessel_yn_t, sph_bessel_yn_);
   };

diff --git a/include/eve/module/combinatorial/regular/fibonacci.hpp b/include/eve/module/combinatorial/regular/fibonacci.hpp
@@ -20,8 +20,10 @@ template<typename Options>
 struct fibonacci_t : strict_elementwise_callable<fibonacci_t, Options>
 {
   template<eve::unsigned_value N, floating_value T0,  floating_value T1>
+  requires (same_lanes_or_scalar<N, T0, T1>)
   constexpr EVE_FORCEINLINE as_wide_as_t<common_value_t<T0, T1>, N>
-  operator()(N n, T0 t0, T1 t1) const noexcept { return EVE_DISPATCH_CALL(n, t0, t1); }
+  operator()(N n, T0 t0, T1 t1) const noexcept
+  { return EVE_DISPATCH_CALL(n, t0, t1); }
 
   EVE_CALLABLE_OBJECT(fibonacci_t, fibonacci_);
 };

diff --git a/include/eve/module/combinatorial/regular/gcd.hpp b/include/eve/module/combinatorial/regular/gcd.hpp
@@ -19,6 +19,7 @@ template<typename Options>
 struct gcd_t : elementwise_callable<gcd_t, Options, raw_option>
 {
   template<eve::ordered_value T, ordered_value U>
+  requires (same_lanes_or_scalar<T, U>)
   constexpr EVE_FORCEINLINE
   common_value_t<T, U> operator()(T v, U w) const noexcept
   { return EVE_DISPATCH_CALL(v, w); }

diff --git a/include/eve/module/combinatorial/regular/lcm.hpp b/include/eve/module/combinatorial/regular/lcm.hpp
@@ -21,8 +21,10 @@ namespace eve
   struct lcm_t : elementwise_callable<lcm_t, Options>
   {
     template<eve::value T, eve::value U>
+    requires (same_lanes_or_scalar<T, U>)
     constexpr EVE_FORCEINLINE
-    common_value_t<T, U> operator()(T v, U w) const noexcept { return EVE_DISPATCH_CALL(v, w); }
+    common_value_t<T, U> operator()(T v, U w) const noexcept
+    { return EVE_DISPATCH_CALL(v, w); }
 
     EVE_CALLABLE_OBJECT(lcm_t, lcm_);
   };

diff --git a/include/eve/module/elliptic/regular/ellint_1.hpp b/include/eve/module/elliptic/regular/ellint_1.hpp
@@ -25,8 +25,10 @@ namespace eve
     T operator()(T a) const noexcept { return EVE_DISPATCH_CALL(a); }
 
     template<eve::floating_ordered_value T0, eve::floating_ordered_value T1>
+    requires (same_lanes_or_scalar<T0, T1>)
     constexpr EVE_FORCEINLINE
-    eve::common_value_t<T0, T1> operator()(T0 a, T1 b) const noexcept { return EVE_DISPATCH_CALL(a, b); }
+    eve::common_value_t<T0, T1> operator()(T0 a, T1 b) const noexcept
+    { return EVE_DISPATCH_CALL(a, b); }
 
     EVE_CALLABLE_OBJECT(ellint_1_t, ellint_1_);
   };

diff --git a/include/eve/module/elliptic/regular/ellint_2.hpp b/include/eve/module/elliptic/regular/ellint_2.hpp
@@ -26,8 +26,10 @@ namespace eve
     T operator()(T a) const noexcept { return EVE_DISPATCH_CALL(a); }
 
     template<eve::floating_ordered_value T0, eve::floating_ordered_value T1>
+    requires (same_lanes_or_scalar<T0, T1>)
     constexpr EVE_FORCEINLINE
-    eve::common_value_t<T0, T1> operator()(T0 a, T1 b) const noexcept { return EVE_DISPATCH_CALL(a, b); }
+    eve::common_value_t<T0, T1> operator()(T0 a, T1 b) const noexcept
+    { return EVE_DISPATCH_CALL(a, b); }
 
     EVE_CALLABLE_OBJECT(ellint_2_t, ellint_2_);
   };

diff --git a/include/eve/module/elliptic/regular/ellint_d.hpp b/include/eve/module/elliptic/regular/ellint_d.hpp
@@ -25,8 +25,10 @@ namespace eve
     T operator()(T a) const noexcept { return EVE_DISPATCH_CALL(a); }
 
     template<eve::floating_ordered_value T0, eve::floating_ordered_value T1>
+    requires (same_lanes_or_scalar<T0, T1>)
     constexpr EVE_FORCEINLINE
-    eve::common_value_t<T0, T1> operator()(T0 a, T1 b) const noexcept { return EVE_DISPATCH_CALL(a, b); }
+    eve::common_value_t<T0, T1> operator()(T0 a, T1 b) const noexcept
+    { return EVE_DISPATCH_CALL(a, b); }
 
     EVE_CALLABLE_OBJECT(ellint_d_t, ellint_d_);
   };

diff --git a/include/eve/module/elliptic/regular/ellint_rc.hpp b/include/eve/module/elliptic/regular/ellint_rc.hpp
@@ -21,8 +21,10 @@ namespace eve
   struct ellint_rc_t : elementwise_callable<ellint_rc_t, Options>
   {
     template<eve::floating_ordered_value T0, eve::floating_ordered_value T1>
+    requires (same_lanes_or_scalar<T0, T1>)
     constexpr EVE_FORCEINLINE
-    eve::common_value_t<T0, T1> operator()(T0 a, T1 b) const noexcept { return EVE_DISPATCH_CALL(a, b); }
+    eve::common_value_t<T0, T1> operator()(T0 a, T1 b) const noexcept
+    { return EVE_DISPATCH_CALL(a, b); }
 
     EVE_CALLABLE_OBJECT(ellint_rc_t, ellint_rc_);
   };

diff --git a/include/eve/module/elliptic/regular/ellint_rd.hpp b/include/eve/module/elliptic/regular/ellint_rd.hpp
@@ -21,8 +21,10 @@ namespace eve
   struct ellint_rd_t : elementwise_callable<ellint_rd_t, Options, raw_option>
   {
     template<eve::floating_ordered_value T0, eve::floating_ordered_value T1, eve::floating_ordered_value T2>
+    requires (same_lanes_or_scalar<T0, T1, T2>)
     constexpr EVE_FORCEINLINE
-    eve::common_value_t<T0, T1, T2> operator()(T0 a, T1 b, T2 c) const noexcept { return EVE_DISPATCH_CALL(a, b, c); }
+    eve::common_value_t<T0, T1, T2> operator()(T0 a, T1 b, T2 c) const noexcept
+   { return EVE_DISPATCH_CALL(a, b, c); }
 
     EVE_CALLABLE_OBJECT(ellint_rd_t, ellint_rd_);
   };

diff --git a/include/eve/module/elliptic/regular/ellint_rf.hpp b/include/eve/module/elliptic/regular/ellint_rf.hpp
@@ -21,8 +21,10 @@ namespace eve
   struct ellint_rf_t : elementwise_callable<ellint_rf_t, Options, raw_option>
   {
      template<eve::floating_ordered_value T0, eve::floating_ordered_value T1, eve::floating_ordered_value T2>
-    constexpr EVE_FORCEINLINE
-    eve::common_value_t<T0, T1, T2> operator()(T0 a, T1 b, T2 c) const noexcept { return EVE_DISPATCH_CALL(a, b, c); }
+     requires (same_lanes_or_scalar<T0, T1, T2>)
+     constexpr EVE_FORCEINLINE
+     eve::common_value_t<T0, T1, T2> operator()(T0 a, T1 b, T2 c) const noexcept
+    { return EVE_DISPATCH_CALL(a, b, c); }
 
     EVE_CALLABLE_OBJECT(ellint_rf_t, ellint_rf_);
   };

diff --git a/include/eve/module/elliptic/regular/ellint_rg.hpp b/include/eve/module/elliptic/regular/ellint_rg.hpp
@@ -22,9 +22,11 @@ namespace eve
   template<typename Options>
   struct ellint_rg_t : elementwise_callable<ellint_rg_t, Options, raw_option>
   {
-     template<eve::floating_ordered_value T0, eve::floating_ordered_value T1, eve::floating_ordered_value T2>
+    template<eve::floating_ordered_value T0, eve::floating_ordered_value T1, eve::floating_ordered_value T2>
+    requires (same_lanes_or_scalar<T0, T1, T2>)
     constexpr EVE_FORCEINLINE
-    eve::common_value_t<T0, T1, T2> operator()(T0 a, T1 b, T2 c) const noexcept { return EVE_DISPATCH_CALL(a, b, c); }
+    eve::common_value_t<T0, T1, T2> operator()(T0 a, T1 b, T2 c) const noexcept
+   { return EVE_DISPATCH_CALL(a, b, c); }
 
     EVE_CALLABLE_OBJECT(ellint_rg_t, ellint_rg_);
   };

diff --git a/include/eve/module/elliptic/regular/ellint_rj.hpp b/include/eve/module/elliptic/regular/ellint_rj.hpp
@@ -23,8 +23,9 @@ namespace eve
   template<typename Options>
   struct ellint_rj_t : elementwise_callable<ellint_rj_t, Options, raw_option>
   {
-     template<eve::floating_ordered_value T0, eve::floating_ordered_value T1
-              , eve::floating_ordered_value T2, eve::floating_ordered_value T3>
+    template<eve::floating_ordered_value T0, eve::floating_ordered_value T1,
+             eve::floating_ordered_value T2, eve::floating_ordered_value T3>
+    requires (same_lanes_or_scalar<T0, T1, T2, T3>)
     constexpr EVE_FORCEINLINE
     eve::common_value_t<T0, T1, T2, T3> operator()(T0 a, T1 b, T2 c, T3 d) const noexcept
     { return EVE_DISPATCH_CALL(a, b, c, d); }

diff --git a/include/eve/module/polynomial/regular/gegenbauer.hpp b/include/eve/module/polynomial/regular/gegenbauer.hpp
@@ -17,12 +17,14 @@ namespace eve
   struct gegenbauer_t : strict_elementwise_callable<gegenbauer_t, Options>
   {
     template<eve::floating_ordered_value ...Ts>
+    requires (same_lanes_or_scalar<Ts...>)
     constexpr EVE_FORCEINLINE
     eve::common_value_t<Ts ...> operator()(Ts...b) const noexcept
     {
       return EVE_DISPATCH_CALL(b...);
     }
     template<eve::integral_value T0, eve::floating_ordered_value ...Ts>
+    requires (same_lanes_or_scalar<T0, Ts...>)
     constexpr EVE_FORCEINLINE
     as_wide_as_t<eve::common_value_t<Ts ...>, T0> operator()(T0 a, Ts...b) const noexcept
     {

diff --git a/include/eve/module/polynomial/regular/hermite.hpp b/include/eve/module/polynomial/regular/hermite.hpp
@@ -17,18 +17,21 @@ namespace eve
   struct hermite_t : strict_elementwise_callable<hermite_t, Options, successor_option>
   {
     template<eve::floating_ordered_value ...Ts>
+    requires (same_lanes_or_scalar<Ts...>)
     constexpr EVE_FORCEINLINE
     eve::common_value_t<Ts ...> operator()(Ts...b) const noexcept
     {
       return EVE_DISPATCH_CALL(b...);
     }
     template<eve::integral_value T0, eve::floating_ordered_value ...Ts>
+    requires (same_lanes_or_scalar<T0, Ts...>)
     constexpr EVE_FORCEINLINE
     as_wide_as_t<eve::common_value_t<Ts ...>, T0> operator()(T0 a, Ts...b) const noexcept
     {
       return EVE_DISPATCH_CALL(a, b...);
     }
     template<eve::integral_value T0, eve::integral_value T1, eve::floating_ordered_value ...Ts>
+    requires (same_lanes_or_scalar<T0, T1, Ts...>)
     constexpr EVE_FORCEINLINE
     as_wide_as_t<eve::common_value_t<Ts ...>, eve::common_value_t<T0, T1>> operator()(T0 a, T1 b, Ts...c) const noexcept
     {

diff --git a/include/eve/module/polynomial/regular/jacobi.hpp b/include/eve/module/polynomial/regular/jacobi.hpp
@@ -16,12 +16,14 @@ namespace eve
   struct jacobi_t : strict_elementwise_callable<jacobi_t, Options>
   {
     template<eve::floating_ordered_value ...Ts>
+    requires (same_lanes_or_scalar<Ts...>)
     constexpr EVE_FORCEINLINE
     eve::common_value_t<Ts ...> operator()(Ts...b) const noexcept
     {
       return EVE_DISPATCH_CALL(b...);
     }
     template<eve::integral_value T0, eve::floating_ordered_value ...Ts>
+    requires (same_lanes_or_scalar<T0, Ts...>)
     constexpr EVE_FORCEINLINE
     as_wide_as_t<eve::common_value_t<Ts ...>, T0> operator()(T0 a, Ts...b) const noexcept
     {

diff --git a/include/eve/module/polynomial/regular/laguerre.hpp b/include/eve/module/polynomial/regular/laguerre.hpp
@@ -17,12 +17,14 @@ namespace eve
   struct laguerre_t : strict_elementwise_callable<laguerre_t, Options, associated_option>
   {
     template<eve::integral_value N, eve::floating_value T>
+    requires (same_lanes_or_scalar<N, T>)
     constexpr EVE_FORCEINLINE eve::as_wide_as_t<T, N> operator()(N n, T t) const
     {
       return EVE_DISPATCH_CALL(n,t);
     }
 
     template<eve::integral_value N, eve::integral_value M, eve::floating_value T>
+    requires (same_lanes_or_scalar<N, M, T>)
     constexpr EVE_FORCEINLINE eve::as_wide_as_t<T, common_value_t<M,N>> operator()(N n, M m, T t) const
     {
       return EVE_DISPATCH_CALL(n, m, t);

diff --git a/include/eve/module/polynomial/regular/legendre.hpp b/include/eve/module/polynomial/regular/legendre.hpp
@@ -20,18 +20,21 @@ namespace eve
                                                   >
   {
     template<eve::floating_ordered_value ...Ts>
+    requires (same_lanes_or_scalar<Ts...>)
     constexpr EVE_FORCEINLINE
     eve::common_value_t<Ts ...> operator()(Ts...b) const noexcept
     {
       return EVE_DISPATCH_CALL(b...);
     }
     template<eve::integral_value T0, eve::floating_ordered_value ...Ts>
+    requires (same_lanes_or_scalar<T0, Ts...>)
     constexpr EVE_FORCEINLINE
     as_wide_as_t<eve::common_value_t<Ts ...>, T0> operator()(T0 a, Ts...b) const noexcept
     {
       return EVE_DISPATCH_CALL(a, b...);
     }
     template<eve::integral_value T0, eve::integral_value T1, eve::floating_ordered_value ...Ts>
+    requires (same_lanes_or_scalar<T0, T1, Ts...>)
     constexpr EVE_FORCEINLINE
     as_wide_as_t<eve::common_value_t<Ts ...>, eve::common_value_t<T0, T1>> operator()(T0 a, T1 b, Ts...c) const noexcept
     {

diff --git a/include/eve/module/polynomial/regular/tchebytchev.hpp b/include/eve/module/polynomial/regular/tchebytchev.hpp
@@ -19,12 +19,14 @@ namespace eve
                                                     >
   {
     template<eve::floating_ordered_value ...Ts>
+    requires (same_lanes_or_scalar<Ts...>)
     constexpr EVE_FORCEINLINE
     eve::common_value_t<Ts ...> operator()(Ts...b) const noexcept
     {
       return EVE_DISPATCH_CALL(b...);
     }
     template<eve::integral_value T0, eve::floating_ordered_value ...Ts>
+    requires (same_lanes_or_scalar<T0, Ts...>)
     constexpr EVE_FORCEINLINE
     as_wide_as_t<eve::common_value_t<Ts ...>, T0> operator()(T0 a, Ts...b) const noexcept
     {

diff --git a/include/eve/module/special/regular/beta.hpp b/include/eve/module/special/regular/beta.hpp
@@ -20,8 +20,10 @@ namespace eve
   struct beta_t : elementwise_callable<beta_t, Options>
   {
     template<eve::floating_ordered_value T0, eve::floating_ordered_value T1>
+    requires (same_lanes_or_scalar<T0, T1>)
     EVE_FORCEINLINE constexpr
-    eve::common_value_t<T0, T1> operator()(T0 a, T1 b) const noexcept { return EVE_DISPATCH_CALL(a, b); }
+    eve::common_value_t<T0, T1> operator()(T0 a, T1 b) const noexcept
+    { return EVE_DISPATCH_CALL(a, b); }
 
     EVE_CALLABLE_OBJECT(beta_t, beta_);
   };

diff --git a/include/eve/module/special/regular/betainc.hpp b/include/eve/module/special/regular/betainc.hpp
@@ -22,9 +22,10 @@ template<typename Options>
 struct betainc_t : elementwise_callable<betainc_t, Options>
 {
   template<eve::floating_ordered_value T0, eve::floating_ordered_value T1, eve::floating_ordered_value T2>
-  constexpr EVE_FORCEINLINE
-  eve::common_value_t<T0, T1, T2>
-  operator()(T0 a, T1 b, T2 c) const noexcept { return EVE_DISPATCH_CALL(a, b, c); }
+  requires (same_lanes_or_scalar<T0, T1, T2>)
+  constexpr EVE_FORCEINLINE eve::common_value_t<T0, T1, T2>
+  operator()(T0 a, T1 b, T2 c) const noexcept
+  { return EVE_DISPATCH_CALL(a, b, c); }
 
   EVE_CALLABLE_OBJECT(betainc_t, betainc_);
 };

diff --git a/include/eve/module/special/regular/betainc_inv.hpp b/include/eve/module/special/regular/betainc_inv.hpp
@@ -24,8 +24,9 @@ namespace eve
   struct betainc_inv_t : elementwise_callable<betainc_inv_t, Options>
   {
     template<eve::floating_ordered_value T0, eve::floating_ordered_value T1, eve::floating_ordered_value T2>
-    EVE_FORCEINLINE constexpr
-    eve::common_value_t<T0, T1, T2> operator()(T0 a, T1 b, T2 c) const noexcept { return EVE_DISPATCH_CALL(a, b, c); }
+    requires (same_lanes_or_scalar<T0, T1, T2>)
+    EVE_FORCEINLINE constexpr eve::common_value_t<T0, T1, T2> operator()(T0 a, T1 b, T2 c) const noexcept
+    { return EVE_DISPATCH_CALL(a, b, c); }
 
     EVE_CALLABLE_OBJECT(betainc_inv_t, betainc_inv_);
   };

diff --git a/include/eve/module/special/regular/exp_int.hpp b/include/eve/module/special/regular/exp_int.hpp
@@ -21,7 +21,9 @@ template<typename Options>
 struct exp_int_t : strict_elementwise_callable<exp_int_t, Options, saturated_option>
 {
   template<eve::floating_ordered_value T, eve::ordered_value I>
-  EVE_FORCEINLINE  constexpr eve::as_wide_as_t<T, I>  operator()(I n, T v) const noexcept { return EVE_DISPATCH_CALL(n, v); }
+  requires (same_lanes_or_scalar<I, T>)
+  EVE_FORCEINLINE  constexpr eve::as_wide_as_t<T, I>  operator()(I n, T v) const noexcept
+  { return EVE_DISPATCH_CALL(n, v); }
 
   template<eve::floating_ordered_value T>
   EVE_FORCEINLINE constexpr T operator()(T v) const noexcept { return EVE_DISPATCH_CALL(v); }

diff --git a/include/eve/module/special/regular/gamma_p.hpp b/include/eve/module/special/regular/gamma_p.hpp
@@ -22,8 +22,8 @@ template<typename Options>
 struct gamma_p_t : elementwise_callable<gamma_p_t, Options>
 {
   template<eve::floating_ordered_value T0, eve::floating_ordered_value T1>
-  EVE_FORCEINLINE  eve::common_value_t<T0, T1>
-  operator()(T0 a, T1 b) const  noexcept
+  requires (same_lanes_or_scalar<T0, T1>)
+  EVE_FORCEINLINE  eve::common_value_t<T0, T1> operator()(T0 a, T1 b) const  noexcept
   { return EVE_DISPATCH_CALL(a, b); }
 
   EVE_CALLABLE_OBJECT(gamma_p_t, gamma_p_);

diff --git a/include/eve/module/special/regular/gamma_p_inv.hpp b/include/eve/module/special/regular/gamma_p_inv.hpp
@@ -24,8 +24,9 @@ template<typename Options>
 struct gamma_p_inv_t : elementwise_callable<gamma_p_inv_t, Options>
 {
   template<eve::floating_ordered_value T0, eve::floating_ordered_value T1>
-  EVE_FORCEINLINE
-  eve::common_value_t<T0, T1> operator()(T0 a, T1 b) const  noexcept { return EVE_DISPATCH_CALL(a, b); }
+  requires (same_lanes_or_scalar<T0, T1>)
+  EVE_FORCEINLINE constexpr eve::common_value_t<T0, T1> operator()(T0 a, T1 b) const noexcept
+  { return EVE_DISPATCH_CALL(a, b); }
 
   EVE_CALLABLE_OBJECT(gamma_p_inv_t, gamma_p_inv_);
 };

diff --git a/include/eve/module/special/regular/lbeta.hpp b/include/eve/module/special/regular/lbeta.hpp
@@ -18,8 +18,10 @@ template<typename Options>
 struct lbeta_t : elementwise_callable<lbeta_t, Options>
 {
   template<eve::floating_ordered_value T0, eve::floating_ordered_value T1>
+  requires (same_lanes_or_scalar<T0, T1>)
   EVE_FORCEINLINE constexpr
-  eve::common_value_t<T0, T1> operator()(T0 a, T1 b) const  noexcept { return EVE_DISPATCH_CALL(a, b); }
+  eve::common_value_t<T0, T1> operator()(T0 a, T1 b) const  noexcept
+  { return EVE_DISPATCH_CALL(a, b); }
 
   EVE_CALLABLE_OBJECT(lbeta_t, lbeta_);
 };

diff --git a/include/eve/traits/overload.hpp b/include/eve/traits/overload.hpp
@@ -10,3 +10,4 @@
 #include <eve/traits/overload/protocol.hpp>
 #include <eve/traits/overload/supports.hpp>
 #include <eve/traits/overload/default_behaviors.hpp>
+#include <eve/traits/same_lanes.hpp>