move f$vk_dot_product to runtime-common (#1422)

Author: Shamzik

builtin-functions/kphp-light/stdlib/array-functions.txt

@@ -183,7 +183,5 @@ function array_combine ($keys ::: array, $values ::: array) ::: ^2;
 
 function array_column ($a ::: array, $column_key, $index_key = null) ::: array< ^1[*][*] > | false;
 
-// ===== UNSUPPORTED =====
-
 /** @kphp-extern-func-info stub cpp_template_call */
 function vk_dot_product ($a ::: array, $b ::: array) ::: ^1[*] | ^2[*];

runtime-common/stdlib/array/array-functions.h

@@ -6,10 +6,12 @@
 
 #include <cstdint>
 #include <limits>
+#include <numeric>
 #include <tuple>
 
 #include "common/type_traits/function_traits.h"
 #include "common/type_traits/list_of_types.h"
+#include "common/vector-product.h"
 #include "runtime-common/core/runtime-core.h"
 
 inline constexpr int64_t SORT_REGULAR = 0;
@@ -1167,3 +1169,51 @@ auto f$array_column(const Optional<T>& a, const mixed& column_key,
 
   return f$array_column(a.val(), column_key, index_key);
 }
+
+template<class T>
+T vk_dot_product_sparse(const array<T>& a, const array<T>& b) noexcept {
+  T result = T();
+  for (const auto& it : a) {
+    const auto* b_val = b.find_value(it);
+    if (b_val && !f$is_null(*b_val)) {
+      result += it.get_value() * (*b_val);
+    }
+  }
+  return result;
+}
+
+template<class T>
+T vk_dot_product_dense(const array<T>& a, const array<T>& b) noexcept {
+  static_assert(!std::is_same<T, int>{}, "int is forbidden");
+
+  T result = T();
+  int64_t size = min(a.count(), b.count());
+  for (int64_t i = 0; i < size; i++) {
+    result += a.get_value(i) * b.get_value(i);
+  }
+  return result;
+}
+
+template<>
+inline int64_t vk_dot_product_dense<int64_t>(const array<int64_t>& a, const array<int64_t>& b) noexcept {
+  const int64_t size = min(a.count(), b.count());
+  const int64_t* ap = a.get_const_vector_pointer();
+  const int64_t* bp = b.get_const_vector_pointer();
+  return std::inner_product(ap, ap + size, bp, 0L);
+}
+
+template<>
+inline double vk_dot_product_dense<double>(const array<double>& a, const array<double>& b) noexcept {
+  int64_t size = min(a.count(), b.count());
+  const double* ap = a.get_const_vector_pointer();
+  const double* bp = b.get_const_vector_pointer();
+  return __dot_product(ap, bp, static_cast<int>(size));
+}
+
+template<class T>
+T f$vk_dot_product(const array<T>& a, const array<T>& b) noexcept {
+  if (a.is_vector() && b.is_vector()) {
+    return vk_dot_product_dense<T>(a, b);
+  }
+  return vk_dot_product_sparse<T>(a, b);
+}

runtime-light/stdlib/array/array-functions.h

@@ -402,8 +402,3 @@ kphp::coro::task<> f$uksort(array<T>& a, Comparator compare) {
     co_return a.ksort(std::move(compare));
   }
 }
-
-template<class T>
-T f$vk_dot_product(const array<T>& /*unused*/, const array<T>& /*unused*/) {
-  kphp::log::error("call to unsupported function");
-}

runtime/array_functions.h

@@ -4,10 +4,7 @@
 
 #pragma once
 
-#include <numeric>
-
 #include "common/type_traits/function_traits.h"
-#include "common/vector-product.h"
 #include "runtime-common/core/runtime-core.h"
 #include "runtime-common/stdlib/array/array-functions.h"
 #include "runtime/math_functions.h"
@@ -178,54 +175,6 @@ void f$shuffle(array<T>& a) {
   a = std::move(result);
 }
 
-template<class T>
-T vk_dot_product_sparse(const array<T>& a, const array<T>& b) {
-  T result = T();
-  for (const auto& it : a) {
-    const auto* b_val = b.find_value(it);
-    if (b_val && !f$is_null(*b_val)) {
-      result += it.get_value() * (*b_val);
-    }
-  }
-  return result;
-}
-
-template<class T>
-T vk_dot_product_dense(const array<T>& a, const array<T>& b) {
-  static_assert(!std::is_same<T, int>{}, "int is forbidden");
-
-  T result = T();
-  int64_t size = min(a.count(), b.count());
-  for (int64_t i = 0; i < size; i++) {
-    result += a.get_value(i) * b.get_value(i);
-  }
-  return result;
-}
-
-template<>
-inline int64_t vk_dot_product_dense<int64_t>(const array<int64_t>& a, const array<int64_t>& b) {
-  const int64_t size = min(a.count(), b.count());
-  const int64_t* ap = a.get_const_vector_pointer();
-  const int64_t* bp = b.get_const_vector_pointer();
-  return std::inner_product(ap, ap + size, bp, 0L);
-}
-
-template<>
-inline double vk_dot_product_dense<double>(const array<double>& a, const array<double>& b) {
-  int64_t size = min(a.count(), b.count());
-  const double* ap = a.get_const_vector_pointer();
-  const double* bp = b.get_const_vector_pointer();
-  return __dot_product(ap, bp, static_cast<int>(size));
-}
-
-template<class T>
-T f$vk_dot_product(const array<T>& a, const array<T>& b) {
-  if (a.is_vector() && b.is_vector()) {
-    return vk_dot_product_dense<T>(a, b);
-  }
-  return vk_dot_product_sparse<T>(a, b);
-}
-
 template<typename Result, typename U, typename Comparator>
 Result array_functions_impl_::async_sort([[maybe_unused]] array<U>& arr, [[maybe_unused]] Comparator comparator, [[maybe_unused]] bool renumber) noexcept {
   struct async_sort_stub_class {};

tests/phpt/array/037_vk_dot_product.php

@@ -0,0 +1,4 @@
+@ok
+<php?
+
+var_dump(vk_dot_product([1, 2, 3], [4, 5, 6]));