numkong 7.0.0 → 7.4.1

package/include/numkong/spatials.hpp

@@ -19,8 +19,8 @@ namespace ashvardanian::numkong {
 
 /**
  *  @brief Symmetric angular distance matrix: C[i,j] = angular(A[i], A[j])
- *  @param[in] a Matrix A [n_vectors x depth]
- *  @param[in] n_vectors Number of vectors (n)
+ *  @param[in] a Matrix A [vectors_count x depth]
+ *  @param[in] vectors_count Number of vectors (n)
  *  @param[in] depth Dimension of each vector (k)
  *  @param[in] a_stride_in_bytes Stride between vectors in A
  *  @param[out] c Output matrix C [n x n]
@@ -34,59 +34,59 @@ namespace ashvardanian::numkong {
  */
 template <numeric_dtype in_type_, numeric_dtype result_type_ = typename in_type_::angular_result_t,
           allow_simd_t allow_simd_ = prefer_simd_k>
-void angulars_symmetric(in_type_ const *a, std::size_t n_vectors, std::size_t depth, std::size_t a_stride_in_bytes,
+void angulars_symmetric(in_type_ const *a, std::size_t vectors_count, std::size_t depth, std::size_t a_stride_in_bytes,
                         result_type_ *c, std::size_t c_stride_in_bytes, std::size_t row_start = 0,
                         std::size_t row_count = std::numeric_limits<std::size_t>::max()) noexcept {
-    if (row_count == std::numeric_limits<std::size_t>::max()) row_count = n_vectors;
+    if (row_count == std::numeric_limits<std::size_t>::max()) row_count = vectors_count;
     constexpr bool dispatch = allow_simd_ == prefer_simd_k &&
                               std::is_same_v<result_type_, typename in_type_::angular_result_t>;
 
     if constexpr (std::is_same_v<in_type_, f64_t> && dispatch)
-        nk_angulars_symmetric_f64(&a->raw_, n_vectors, depth, a_stride_in_bytes, &c->raw_, c_stride_in_bytes, row_start,
-                                  row_count);
+        nk_angulars_symmetric_f64(&a->raw_, vectors_count, depth, a_stride_in_bytes, &c->raw_, c_stride_in_bytes,
+                                  row_start, row_count);
     else if constexpr (std::is_same_v<in_type_, f32_t> && dispatch)
-        nk_angulars_symmetric_f32(&a->raw_, n_vectors, depth, a_stride_in_bytes, &c->raw_, c_stride_in_bytes, row_start,
-                                  row_count);
+        nk_angulars_symmetric_f32(&a->raw_, vectors_count, depth, a_stride_in_bytes, &c->raw_, c_stride_in_bytes,
+                                  row_start, row_count);
     else if constexpr (std::is_same_v<in_type_, f16_t> && dispatch)
-        nk_angulars_symmetric_f16(&a->raw_, n_vectors, depth, a_stride_in_bytes, &c->raw_, c_stride_in_bytes, row_start,
-                                  row_count);
+        nk_angulars_symmetric_f16(&a->raw_, vectors_count, depth, a_stride_in_bytes, &c->raw_, c_stride_in_bytes,
+                                  row_start, row_count);
     else if constexpr (std::is_same_v<in_type_, bf16_t> && dispatch)
-        nk_angulars_symmetric_bf16(&a->raw_, n_vectors, depth, a_stride_in_bytes, &c->raw_, c_stride_in_bytes,
+        nk_angulars_symmetric_bf16(&a->raw_, vectors_count, depth, a_stride_in_bytes, &c->raw_, c_stride_in_bytes,
                                    row_start, row_count);
     else if constexpr (std::is_same_v<in_type_, e4m3_t> && dispatch)
-        nk_angulars_symmetric_e4m3(&a->raw_, n_vectors, depth, a_stride_in_bytes, &c->raw_, c_stride_in_bytes,
+        nk_angulars_symmetric_e4m3(&a->raw_, vectors_count, depth, a_stride_in_bytes, &c->raw_, c_stride_in_bytes,
                                    row_start, row_count);
     else if constexpr (std::is_same_v<in_type_, e5m2_t> && dispatch)
-        nk_angulars_symmetric_e5m2(&a->raw_, n_vectors, depth, a_stride_in_bytes, &c->raw_, c_stride_in_bytes,
+        nk_angulars_symmetric_e5m2(&a->raw_, vectors_count, depth, a_stride_in_bytes, &c->raw_, c_stride_in_bytes,
                                    row_start, row_count);
     else if constexpr (std::is_same_v<in_type_, e2m3_t> && dispatch)
-        nk_angulars_symmetric_e2m3(&a->raw_, n_vectors, depth, a_stride_in_bytes, &c->raw_, c_stride_in_bytes,
+        nk_angulars_symmetric_e2m3(&a->raw_, vectors_count, depth, a_stride_in_bytes, &c->raw_, c_stride_in_bytes,
                                    row_start, row_count);
     else if constexpr (std::is_same_v<in_type_, e3m2_t> && dispatch)
-        nk_angulars_symmetric_e3m2(&a->raw_, n_vectors, depth, a_stride_in_bytes, &c->raw_, c_stride_in_bytes,
+        nk_angulars_symmetric_e3m2(&a->raw_, vectors_count, depth, a_stride_in_bytes, &c->raw_, c_stride_in_bytes,
                                    row_start, row_count);
     else if constexpr (std::is_same_v<in_type_, i8_t> && dispatch)
-        nk_angulars_symmetric_i8(&a->raw_, n_vectors, depth, a_stride_in_bytes, &c->raw_, c_stride_in_bytes, row_start,
-                                 row_count);
+        nk_angulars_symmetric_i8(&a->raw_, vectors_count, depth, a_stride_in_bytes, &c->raw_, c_stride_in_bytes,
+                                 row_start, row_count);
     else if constexpr (std::is_same_v<in_type_, u8_t> && dispatch)
-        nk_angulars_symmetric_u8(&a->raw_, n_vectors, depth, a_stride_in_bytes, &c->raw_, c_stride_in_bytes, row_start,
-                                 row_count);
+        nk_angulars_symmetric_u8(&a->raw_, vectors_count, depth, a_stride_in_bytes, &c->raw_, c_stride_in_bytes,
+                                 row_start, row_count);
     else if constexpr (std::is_same_v<in_type_, i4x2_t> && dispatch)
-        nk_angulars_symmetric_i4(&a->raw_, n_vectors, depth, a_stride_in_bytes, &c->raw_, c_stride_in_bytes, row_start,
-                                 row_count);
+        nk_angulars_symmetric_i4(&a->raw_, vectors_count, depth, a_stride_in_bytes, &c->raw_, c_stride_in_bytes,
+                                 row_start, row_count);
     else if constexpr (std::is_same_v<in_type_, u4x2_t> && dispatch)
-        nk_angulars_symmetric_u4(&a->raw_, n_vectors, depth, a_stride_in_bytes, &c->raw_, c_stride_in_bytes, row_start,
-                                 row_count);
+        nk_angulars_symmetric_u4(&a->raw_, vectors_count, depth, a_stride_in_bytes, &c->raw_, c_stride_in_bytes,
+                                 row_start, row_count);
     else {
         std::size_t depth_values = divide_round_up(depth, dimensions_per_value<in_type_>());
         char const *a_bytes = reinterpret_cast<char const *>(a);
         char *c_bytes = reinterpret_cast<char *>(c);
-        std::size_t row_end = row_start + row_count < n_vectors ? row_start + row_count : n_vectors;
+        std::size_t row_end = row_start + row_count < vectors_count ? row_start + row_count : vectors_count;
 
         for (std::size_t i = row_start; i < row_end; i++) {
             in_type_ const *a_i = reinterpret_cast<in_type_ const *>(a_bytes + i * a_stride_in_bytes);
             result_type_ *c_row = reinterpret_cast<result_type_ *>(c_bytes + i * c_stride_in_bytes);
-            for (std::size_t j = 0; j < n_vectors; j++) {
+            for (std::size_t j = 0; j < vectors_count; j++) {
                 in_type_ const *a_j = reinterpret_cast<in_type_ const *>(a_bytes + j * a_stride_in_bytes);
                 result_type_ ab {}, aa {}, bb {};
                 for (std::size_t l = 0; l < depth_values; l++) {
@@ -104,8 +104,8 @@ void angulars_symmetric(in_type_ const *a, std::size_t n_vectors, std::size_t de
 
 /**
  *  @brief Symmetric Euclidean distance matrix: C[i,j] = euclidean(A[i], A[j])
- *  @param[in] a Matrix A [n_vectors x depth]
- *  @param[in] n_vectors Number of vectors (n)
+ *  @param[in] a Matrix A [vectors_count x depth]
+ *  @param[in] vectors_count Number of vectors (n)
  *  @param[in] depth Dimension of each vector (k)
  *  @param[in] a_stride_in_bytes Stride between vectors in A
  *  @param[out] c Output matrix C [n x n]
@@ -119,59 +119,60 @@ void angulars_symmetric(in_type_ const *a, std::size_t n_vectors, std::size_t de
  */
 template <numeric_dtype in_type_, numeric_dtype result_type_ = typename in_type_::euclidean_result_t,
           allow_simd_t allow_simd_ = prefer_simd_k>
-void euclideans_symmetric(in_type_ const *a, std::size_t n_vectors, std::size_t depth, std::size_t a_stride_in_bytes,
-                          result_type_ *c, std::size_t c_stride_in_bytes, std::size_t row_start = 0,
+void euclideans_symmetric(in_type_ const *a, std::size_t vectors_count, std::size_t depth,
+                          std::size_t a_stride_in_bytes, result_type_ *c, std::size_t c_stride_in_bytes,
+                          std::size_t row_start = 0,
                           std::size_t row_count = std::numeric_limits<std::size_t>::max()) noexcept {
-    if (row_count == std::numeric_limits<std::size_t>::max()) row_count = n_vectors;
+    if (row_count == std::numeric_limits<std::size_t>::max()) row_count = vectors_count;
     constexpr bool dispatch = allow_simd_ == prefer_simd_k &&
                               std::is_same_v<result_type_, typename in_type_::euclidean_result_t>;
 
     if constexpr (std::is_same_v<in_type_, f64_t> && dispatch)
-        nk_euclideans_symmetric_f64(&a->raw_, n_vectors, depth, a_stride_in_bytes, &c->raw_, c_stride_in_bytes,
+        nk_euclideans_symmetric_f64(&a->raw_, vectors_count, depth, a_stride_in_bytes, &c->raw_, c_stride_in_bytes,
                                     row_start, row_count);
     else if constexpr (std::is_same_v<in_type_, f32_t> && dispatch)
-        nk_euclideans_symmetric_f32(&a->raw_, n_vectors, depth, a_stride_in_bytes, &c->raw_, c_stride_in_bytes,
+        nk_euclideans_symmetric_f32(&a->raw_, vectors_count, depth, a_stride_in_bytes, &c->raw_, c_stride_in_bytes,
                                     row_start, row_count);
     else if constexpr (std::is_same_v<in_type_, f16_t> && dispatch)
-        nk_euclideans_symmetric_f16(&a->raw_, n_vectors, depth, a_stride_in_bytes, &c->raw_, c_stride_in_bytes,
+        nk_euclideans_symmetric_f16(&a->raw_, vectors_count, depth, a_stride_in_bytes, &c->raw_, c_stride_in_bytes,
                                     row_start, row_count);
     else if constexpr (std::is_same_v<in_type_, bf16_t> && dispatch)
-        nk_euclideans_symmetric_bf16(&a->raw_, n_vectors, depth, a_stride_in_bytes, &c->raw_, c_stride_in_bytes,
+        nk_euclideans_symmetric_bf16(&a->raw_, vectors_count, depth, a_stride_in_bytes, &c->raw_, c_stride_in_bytes,
                                      row_start, row_count);
     else if constexpr (std::is_same_v<in_type_, e4m3_t> && dispatch)
-        nk_euclideans_symmetric_e4m3(&a->raw_, n_vectors, depth, a_stride_in_bytes, &c->raw_, c_stride_in_bytes,
+        nk_euclideans_symmetric_e4m3(&a->raw_, vectors_count, depth, a_stride_in_bytes, &c->raw_, c_stride_in_bytes,
                                      row_start, row_count);
     else if constexpr (std::is_same_v<in_type_, e5m2_t> && dispatch)
-        nk_euclideans_symmetric_e5m2(&a->raw_, n_vectors, depth, a_stride_in_bytes, &c->raw_, c_stride_in_bytes,
+        nk_euclideans_symmetric_e5m2(&a->raw_, vectors_count, depth, a_stride_in_bytes, &c->raw_, c_stride_in_bytes,
                                      row_start, row_count);
     else if constexpr (std::is_same_v<in_type_, e2m3_t> && dispatch)
-        nk_euclideans_symmetric_e2m3(&a->raw_, n_vectors, depth, a_stride_in_bytes, &c->raw_, c_stride_in_bytes,
+        nk_euclideans_symmetric_e2m3(&a->raw_, vectors_count, depth, a_stride_in_bytes, &c->raw_, c_stride_in_bytes,
                                      row_start, row_count);
     else if constexpr (std::is_same_v<in_type_, e3m2_t> && dispatch)
-        nk_euclideans_symmetric_e3m2(&a->raw_, n_vectors, depth, a_stride_in_bytes, &c->raw_, c_stride_in_bytes,
+        nk_euclideans_symmetric_e3m2(&a->raw_, vectors_count, depth, a_stride_in_bytes, &c->raw_, c_stride_in_bytes,
                                      row_start, row_count);
     else if constexpr (std::is_same_v<in_type_, i8_t> && dispatch)
-        nk_euclideans_symmetric_i8(&a->raw_, n_vectors, depth, a_stride_in_bytes, &c->raw_, c_stride_in_bytes,
+        nk_euclideans_symmetric_i8(&a->raw_, vectors_count, depth, a_stride_in_bytes, &c->raw_, c_stride_in_bytes,
                                    row_start, row_count);
     else if constexpr (std::is_same_v<in_type_, u8_t> && dispatch)
-        nk_euclideans_symmetric_u8(&a->raw_, n_vectors, depth, a_stride_in_bytes, &c->raw_, c_stride_in_bytes,
+        nk_euclideans_symmetric_u8(&a->raw_, vectors_count, depth, a_stride_in_bytes, &c->raw_, c_stride_in_bytes,
                                    row_start, row_count);
     else if constexpr (std::is_same_v<in_type_, i4x2_t> && dispatch)
-        nk_euclideans_symmetric_i4(&a->raw_, n_vectors, depth, a_stride_in_bytes, &c->raw_, c_stride_in_bytes,
+        nk_euclideans_symmetric_i4(&a->raw_, vectors_count, depth, a_stride_in_bytes, &c->raw_, c_stride_in_bytes,
                                    row_start, row_count);
     else if constexpr (std::is_same_v<in_type_, u4x2_t> && dispatch)
-        nk_euclideans_symmetric_u4(&a->raw_, n_vectors, depth, a_stride_in_bytes, &c->raw_, c_stride_in_bytes,
+        nk_euclideans_symmetric_u4(&a->raw_, vectors_count, depth, a_stride_in_bytes, &c->raw_, c_stride_in_bytes,
                                    row_start, row_count);
     else {
         std::size_t depth_values = divide_round_up(depth, dimensions_per_value<in_type_>());
         char const *a_bytes = reinterpret_cast<char const *>(a);
         char *c_bytes = reinterpret_cast<char *>(c);
-        std::size_t row_end = row_start + row_count < n_vectors ? row_start + row_count : n_vectors;
+        std::size_t row_end = row_start + row_count < vectors_count ? row_start + row_count : vectors_count;
 
         for (std::size_t i = row_start; i < row_end; i++) {
             in_type_ const *a_i = reinterpret_cast<in_type_ const *>(a_bytes + i * a_stride_in_bytes);
             result_type_ *c_row = reinterpret_cast<result_type_ *>(c_bytes + i * c_stride_in_bytes);
-            for (std::size_t j = 0; j < n_vectors; j++) {
+            for (std::size_t j = 0; j < vectors_count; j++) {
                 in_type_ const *a_j = reinterpret_cast<in_type_ const *>(a_bytes + j * a_stride_in_bytes);
                 result_type_ sum {};
                 for (std::size_t l = 0; l < depth_values; l++) sum = fdsa(a_i[l], a_j[l], sum);
@@ -361,7 +362,7 @@ void euclideans_packed(in_type_ const *a, void const *b_packed, result_type_ *c,
 
 namespace ashvardanian::numkong {
 
-#pragma region - Concept-Constrained Symmetric Spatial Distances
+#pragma region Concept Constrained Symmetric Spatial Distances
 
 /** @brief Symmetric angular distances: C[i,j] = angular(A[i], A[j]). */
 template <numeric_dtype value_type_, const_matrix_of<value_type_> input_matrix_,
@@ -443,9 +444,9 @@ bool euclideans_symmetric(input_matrix_ const &input, output_matrix_ &&output, s
     return true;
 }
 
-#pragma endregion - Concept - Constrained Symmetric Spatial Distances
+#pragma endregion Concept Constrained Symmetric Spatial Distances
 
-#pragma region - Concept-Constrained Packed Spatial Distances
+#pragma region Concept Constrained Packed Spatial Distances
 
 /** @brief Packed angular distances: C = angular(A, B_packed). */
 template <numeric_dtype value_type_, packed_matrix_like packed_type_, const_matrix_of<value_type_> input_matrix_,
@@ -501,7 +502,7 @@ matrix<typename value_type_::euclidean_result_t, allocator_type_> try_euclideans
     return c;
 }
 
-#pragma endregion - Concept - Constrained Packed Spatial Distances
+#pragma endregion Concept Constrained Packed Spatial Distances
 
 } // namespace ashvardanian::numkong