From 95081f0b5b47daf00ef468d0b55c3f32571dea30 Mon Sep 17 00:00:00 2001
From: jtlap <jtlapreste@gmail.com>
Date: Sat, 18 May 2024 19:49:37 +0200
Subject: [PATCH] #1749 - Applying same_lanes_or_scalar to some modules

---
 include/eve/module/bessel/regular/cyl_bessel_in.hpp    | 5 +++--
 include/eve/module/bessel/regular/cyl_bessel_jn.hpp    | 4 +++-
 include/eve/module/bessel/regular/cyl_bessel_kn.hpp    | 5 +++--
 include/eve/module/bessel/regular/cyl_bessel_yn.hpp    | 5 +++--
 include/eve/module/bessel/regular/sph_bessel_jn.hpp    | 5 +++--
 include/eve/module/bessel/regular/sph_bessel_yn.hpp    | 4 +++-
 include/eve/module/combinatorial/regular/fibonacci.hpp | 4 +++-
 include/eve/module/combinatorial/regular/gcd.hpp       | 1 +
 include/eve/module/combinatorial/regular/lcm.hpp       | 4 +++-
 include/eve/module/elliptic/regular/ellint_1.hpp       | 4 +++-
 include/eve/module/elliptic/regular/ellint_2.hpp       | 4 +++-
 include/eve/module/elliptic/regular/ellint_d.hpp       | 4 +++-
 include/eve/module/elliptic/regular/ellint_rc.hpp      | 4 +++-
 include/eve/module/elliptic/regular/ellint_rd.hpp      | 4 +++-
 include/eve/module/elliptic/regular/ellint_rf.hpp      | 6 ++++--
 include/eve/module/elliptic/regular/ellint_rg.hpp      | 6 ++++--
 include/eve/module/elliptic/regular/ellint_rj.hpp      | 5 +++--
 include/eve/module/polynomial/regular/gegenbauer.hpp   | 2 ++
 include/eve/module/polynomial/regular/hermite.hpp      | 3 +++
 include/eve/module/polynomial/regular/jacobi.hpp       | 2 ++
 include/eve/module/polynomial/regular/laguerre.hpp     | 2 ++
 include/eve/module/polynomial/regular/legendre.hpp     | 3 +++
 include/eve/module/polynomial/regular/tchebytchev.hpp  | 2 ++
 include/eve/module/special/regular/beta.hpp            | 4 +++-
 include/eve/module/special/regular/betainc.hpp         | 7 ++++---
 include/eve/module/special/regular/betainc_inv.hpp     | 5 +++--
 include/eve/module/special/regular/exp_int.hpp         | 4 +++-
 include/eve/module/special/regular/gamma_p.hpp         | 4 ++--
 include/eve/module/special/regular/gamma_p_inv.hpp     | 5 +++--
 include/eve/module/special/regular/lbeta.hpp           | 4 +++-
 include/eve/traits/overload.hpp                        | 1 +
 31 files changed, 87 insertions(+), 35 deletions(-)

diff --git a/include/eve/module/bessel/regular/cyl_bessel_in.hpp b/include/eve/module/bessel/regular/cyl_bessel_in.hpp
index 42b6ad9739..e95ba6b994 100644
--- 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
index b18905fe53..513ef9c1a9 100644
--- 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
index 7ef2fe3134..371938ec9d 100644
--- 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
index 99217ad297..8ab32cbd69 100644
--- 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
index 9f7128b04a..09b2e7f140 100644
--- 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
index 2ab45503b3..be6fea4553 100644
--- 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
index 3272130dab..480227176a 100644
--- 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
index 9fc53b2468..99ba9cd7a4 100644
--- 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
index c1e17701a5..50ede6eec0 100644
--- 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
index ea9b47a734..1b35e7fd4d 100644
--- 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
index 9f2b669f82..3fc872b4bd 100644
--- 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
index cf602d3f94..b760ffdbd5 100644
--- 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
index 765b477c08..09348262c9 100644
--- 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
index defa090728..fcda19af6c 100644
--- 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
index 0d3d5dadb1..54131c811a 100644
--- 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
index 9d96737969..1ea53be2b9 100644
--- 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
index 3d17ef2f11..5099276b7a 100644
--- 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
index 5446342ad2..19218c4d59 100644
--- 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
index edcc1af3fc..84b6cacb6b 100644
--- 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
index 7e1d1a85f8..f633853f6d 100644
--- 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
index 3b804c67b4..754f094028 100644
--- 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
index d8f7237f71..a3e1cd9a4f 100644
--- 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
index 60f985b959..9ef3a0a5b3 100644
--- 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
index 73dbcd3b9d..75cface0d4 100644
--- 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
index 1c2c40c9b3..525690295c 100644
--- 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
index 35f2958d2d..7aad27644e 100644
--- 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
index dee8151544..0036bbf24b 100644
--- 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
index c5386652ab..5a98b24f3e 100644
--- 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
index 79d8defec8..888865fd05 100644
--- 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
index cff0c6d941..149fb6baac 100644
--- 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
index 7077181fae..fd22591eaa 100644
--- 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>