ldiv + amending tests

jfalcou · Feb 10, 2025 · fbae813 · fbae813
1 parent c22d8a9
commit fbae813
Show file tree

Hide file tree

Showing 4 changed files with 55 additions and 18 deletions.
diff --git a/include/kyosu/functions/ldiv.hpp b/include/kyosu/functions/ldiv.hpp
@@ -8,22 +8,40 @@
 #pragma once
 #include <kyosu/details/callable.hpp>
 #include <kyosu/functions/rec.hpp>
+#include <kyosu/functions/mul.hpp>
 
 namespace kyosu
 {
   template<typename Options>
-  struct ldiv_t : eve::strict_elementwise_callable<ldiv_t, Options>
+  struct ldiv_t : eve::strict_tuple_callable<ldiv_t, Options>
   {
-    template<typename Z0, typename Z1>
-    requires(concepts::cayley_dickson<Z0> || concepts::cayley_dickson<Z1>)
-      KYOSU_FORCEINLINE constexpr auto operator()(Z0 const& z0, Z1 const & z1) const noexcept -> decltype(z0+z1)
-    { return kyosu::rec(z0)*z1; }
+    template<typename... Ts>       struct result       { using type = expected_result_t<eve::add,Ts...>; };
+    template<concepts::real... Ts> struct result<Ts...>{ using type = eve::common_value_t<Ts...>; };
 
-    template<concepts::real V0, concepts::real V1>
-    KYOSU_FORCEINLINE constexpr auto operator()(V0 v0, V1 v1) const noexcept -> decltype(v0+v1)
-    { return v1/v0; }
+    template<typename T0, typename T1, typename... Ts>
+    requires(eve::same_lanes_or_scalar<T0, T1, Ts...>)
+    EVE_FORCEINLINE expected_result_t<eve::div,T0,T1,Ts...> constexpr operator()(T0 t0, T1 t1, Ts...ts) const noexcept
+    {
+      return KYOSU_CALL(t0,t1,ts...);
+    }
 
-    KYOSU_CALLABLE_OBJECT(ldiv_t, ldiv_);
+    template<concepts::real T0, concepts::real... Ts>
+    requires(eve::same_lanes_or_scalar<T0, Ts...>)
+      EVE_FORCEINLINE eve::common_value_t<T0,Ts...> constexpr operator()(T0 t0, Ts...ts) const noexcept
+    {
+      if constexpr(sizeof...(Ts) == 0)
+        return eve::rec(t0);
+      else
+        return eve::rec(t0)*(ts * ... );
+    }
+
+    template<kumi::non_empty_product_type Tup>
+    requires(eve::same_lanes_or_scalar_tuple<Tup>)
+    EVE_FORCEINLINE constexpr
+    kumi::apply_traits_t<result,Tup>
+    operator()(Tup const& t) const noexcept requires(kumi::size_v<Tup> >= 2) { return KYOSU_CALL(t); }
+
+     KYOSU_CALLABLE_OBJECT(ldiv_t, ldiv_);
 };
 
 //======================================================================================================================
@@ -65,3 +83,19 @@ namespace kyosu
 //! @}
 //======================================================================================================================
 }
+namespace kyosu::_
+{
+  template<eve::callable_options O, typename T0, typename... Ts>
+  EVE_FORCEINLINE constexpr auto ldiv_(KYOSU_DELAY(), O const&, T0 const& v0, Ts const&... vs) noexcept
+  {
+    return rec(v0)*(vs * ... );
+  }
+
+  template<eve::conditional_expr C, eve::callable_options O, typename T0, typename... Ts>
+  EVE_FORCEINLINE constexpr auto ldiv_(KYOSU_DELAY(), C const& cond, O const&, T0 const& v0, Ts const&... vs) noexcept
+  {
+//    expected_result_t<eve::div,T0,Ts...> that(v0);
+    auto that = ldiv(v0, vs...);
+    return eve::detail::mask_op(cond, eve::detail::return_2nd, v0, that);
+  }
+}
diff --git a/test/unit/function/add.cpp b/test/unit/function/add.cpp
@@ -16,9 +16,9 @@ TTS_CASE_WITH ( "Check kyosu::add over real"
               )
 (auto r0, auto r1)
 {
-  TTS_EQUAL(kyosu::add(r0, r1), eve::add(r0, r1));
-  TTS_EQUAL(kyosu::add(r0, r1, r1), eve::add(r0, r1, r1));
-  TTS_EQUAL(kyosu::add(kumi::tuple{r0, r1, r1}), eve::add(r0, r1, r1));
+  TTS_RELATIVE_EQUAL(kyosu::add(r0, r1), eve::add(r0, r1), tts::prec<T>());
+  TTS_RELATIVE_EQUAL(kyosu::add(r0, r1, r1), eve::add(r0, r1, r1), tts::prec<T>());
+  TTS_ERELATIVE_QUAL(kyosu::add(kumi::tuple{r0, r1, r1}), eve::add(r0, r1, r1), tts::prec<T>());
 };
 
 TTS_CASE_WITH ( "Check kyosu::add over complex"

diff --git a/test/unit/function/ldiv.cpp b/test/unit/function/ldiv.cpp
@@ -14,9 +14,9 @@ TTS_CASE_WITH ( "Check kyosu::ldiv over real"
                              ,tts::randoms(-10,10)
                              )
               )
-(auto r0, auto r1)
+<typename T>(T r0, T r1)
 {
-  TTS_EQUAL(kyosu::ldiv(r0, r1), r1/r0);
+  TTS_RELATIVE_EQUAL(kyosu::ldiv(r0, r1), r1/r0, tts::prec<T>());
 };
 
 TTS_CASE_WITH ( "Check kyosu::ldiv over complex"
@@ -46,4 +46,6 @@ TTS_CASE_WITH ( "Check kyosu::ldiv over quaternion"
   auto q0 = type(r0,i0,j0,k0);
   auto q1 = type(r1,i1,j1,k1);
   TTS_RELATIVE_EQUAL(kyosu::ldiv(q0, q1), kyosu::conj(q0)*q1/kyosu::sqr_abs(q0) , tts::prec<T>());
+  TTS_RELATIVE_EQUAL(kyosu::ldiv(q0, q1, r0), kyosu::ldiv(q0, (q1*r0)) , 1e-7);
+  TTS_RELATIVE_EQUAL(kyosu::div(kumi::tuple{q0, q1, r0}), (q0/(q1*r0)) , 1e-7);
 };
diff --git a/test/unit/function/mul.cpp b/test/unit/function/mul.cpp
@@ -33,7 +33,7 @@ TTS_CASE_WITH ( "Check kyosu::mul over complex"
   auto c1 = kyosu::complex(r1,i1);
   TTS_RELATIVE_EQUAL(kyosu::mul(c0, c1), (c0*c1), tts::prec<T>());
   TTS_RELATIVE_EQUAL(kyosu::mul(c0, c1, r1), (c0*c1*r1), tts::prec<T>());
-  TTS_RELATIVE_EQUAL(kyosu::mul(r0, c1, r1), (r0*c1*r1), tts::prec<T>());
+  TTS_RELATIVE_EQUAL(kyosu::mul(r0, c1, r1), ((r0*c1)*r1), tts::prec<T>());
 };
 
 TTS_CASE_WITH ( "Check kyosu::mul over quaternion"
@@ -48,8 +48,9 @@ TTS_CASE_WITH ( "Check kyosu::mul over quaternion"
 {
   using type = kyosu::quaternion_t<T>;
   auto q0 = type(r0,i0,j0,k0);
+  auto pr = tts::prec<T>(1.0e-3, 1.0e-6);
   auto q1 = type(r1,i1,j1,k1);
-  TTS_RELATIVE_EQUAL(kyosu::mul(q0, q1), (q0*q1) , 1e-6);
-  TTS_RELATIVE_EQUAL(kyosu::mul(q0, q1, r0), (q0*q1*r0) , 1e-6);
-  TTS_RELATIVE_EQUAL(kyosu::mul(kumi::tuple{q0, q1, r0}), (q0*q1*r0) , 1e-6);
+  TTS_RELATIVE_EQUAL(kyosu::mul(q0, q1), (q0*q1) , pr);
+  TTS_RELATIVE_EQUAL(kyosu::mul(q0, q1, r0), (q0*q1*r0) , pr);
+  TTS_RELATIVE_EQUAL(kyosu::mul(kumi::tuple{q0, q1, r0}), (q0*q1*r0) , pr);
 };