numkong 7.0.0 → 7.4.2

package/include/numkong/reduce/v128relaxed.h

@@ -620,8 +620,8 @@ NK_INTERNAL void nk_reduce_minmax_f16_v128relaxed_contiguous_( //
         if (val > max_value_f32) max_value_f32 = val, max_idx = idx;
     }
     if (min_value_f32 == NK_F32_MAX && max_value_f32 == NK_F32_MIN) {
-        *min_value_ptr = nk_f16_from_u16_(NK_F16_MAX), *min_index_ptr = NK_SIZE_MAX,
-        *max_value_ptr = nk_f16_from_u16_(NK_F16_MIN), *max_index_ptr = NK_SIZE_MAX;
+        *min_value_ptr = NK_F16_MAX, *min_index_ptr = NK_SIZE_MAX, *max_value_ptr = NK_F16_MIN,
+        *max_index_ptr = NK_SIZE_MAX;
         return;
     }
     *min_value_ptr = data[min_idx], *min_index_ptr = min_idx;
@@ -635,8 +635,8 @@ NK_PUBLIC void nk_reduce_minmax_f16_v128relaxed(                   //
     nk_size_t stride_elements = stride_bytes / sizeof(nk_f16_t);
     int aligned = (stride_bytes % sizeof(nk_f16_t) == 0);
     if (count == 0)
-        *min_value_ptr = nk_f16_from_u16_(NK_F16_MAX), *min_index_ptr = NK_SIZE_MAX,
-        *max_value_ptr = nk_f16_from_u16_(NK_F16_MIN), *max_index_ptr = NK_SIZE_MAX;
+        *min_value_ptr = NK_F16_MAX, *min_index_ptr = NK_SIZE_MAX, *max_value_ptr = NK_F16_MIN,
+        *max_index_ptr = NK_SIZE_MAX;
     else if (!aligned)
         nk_reduce_minmax_f16_serial(data, count, stride_bytes, min_value_ptr, min_index_ptr, max_value_ptr,
                                     max_index_ptr);
@@ -856,8 +856,8 @@ NK_PUBLIC void nk_reduce_moments_u16_v128relaxed(                  //
 NK_INTERNAL void nk_reduce_moments_i32_v128relaxed_contiguous_( //
     nk_i32_t const *data, nk_size_t count,                      //
     nk_i64_t *sum_ptr, nk_u64_t *sumsq_ptr) {
-    v128_t sum_lower_u64x2 = wasm_i64x2_splat(0);
-    v128_t sum_upper_i64x2 = wasm_i64x2_splat(0);
+    v128_t sum_low_u64x2 = wasm_i64x2_splat(0);
+    v128_t sum_high_i64x2 = wasm_i64x2_splat(0);
     v128_t sumsq_u64x2 = wasm_i64x2_splat(0);
     v128_t sumsq_overflow_u64x2 = wasm_i64x2_splat(0);
     v128_t sign_bit_i64x2 = wasm_i64x2_splat((nk_i64_t)0x8000000000000000LL);
@@ -865,21 +865,21 @@ NK_INTERNAL void nk_reduce_moments_i32_v128relaxed_contiguous_( //
     for (; idx + 4 <= count; idx += 4) {
         v128_t data_i32x4 = wasm_v128_load(data + idx);
         v128_t data_low_i64x2 = wasm_i64x2_extend_low_i32x4(data_i32x4);
-        v128_t before_u64x2 = sum_lower_u64x2;
-        sum_lower_u64x2 = wasm_i64x2_add(sum_lower_u64x2, data_low_i64x2);
-        v128_t result_biased_i64x2 = wasm_v128_xor(sum_lower_u64x2, sign_bit_i64x2);
+        v128_t before_u64x2 = sum_low_u64x2;
+        sum_low_u64x2 = wasm_i64x2_add(sum_low_u64x2, data_low_i64x2);
+        v128_t result_biased_i64x2 = wasm_v128_xor(sum_low_u64x2, sign_bit_i64x2);
         v128_t before_biased_i64x2 = wasm_v128_xor(before_u64x2, sign_bit_i64x2);
         v128_t carry_u64x2 = wasm_i64x2_gt(before_biased_i64x2, result_biased_i64x2);
-        sum_upper_i64x2 = wasm_i64x2_sub(sum_upper_i64x2, carry_u64x2);
-        sum_upper_i64x2 = wasm_i64x2_add(sum_upper_i64x2, wasm_i64x2_shr(data_low_i64x2, 63));
+        sum_high_i64x2 = wasm_i64x2_sub(sum_high_i64x2, carry_u64x2);
+        sum_high_i64x2 = wasm_i64x2_add(sum_high_i64x2, wasm_i64x2_shr(data_low_i64x2, 63));
         v128_t data_high_i64x2 = wasm_i64x2_extend_high_i32x4(data_i32x4);
-        before_u64x2 = sum_lower_u64x2;
-        sum_lower_u64x2 = wasm_i64x2_add(sum_lower_u64x2, data_high_i64x2);
-        result_biased_i64x2 = wasm_v128_xor(sum_lower_u64x2, sign_bit_i64x2);
+        before_u64x2 = sum_low_u64x2;
+        sum_low_u64x2 = wasm_i64x2_add(sum_low_u64x2, data_high_i64x2);
+        result_biased_i64x2 = wasm_v128_xor(sum_low_u64x2, sign_bit_i64x2);
         before_biased_i64x2 = wasm_v128_xor(before_u64x2, sign_bit_i64x2);
         carry_u64x2 = wasm_i64x2_gt(before_biased_i64x2, result_biased_i64x2);
-        sum_upper_i64x2 = wasm_i64x2_sub(sum_upper_i64x2, carry_u64x2);
-        sum_upper_i64x2 = wasm_i64x2_add(sum_upper_i64x2, wasm_i64x2_shr(data_high_i64x2, 63));
+        sum_high_i64x2 = wasm_i64x2_sub(sum_high_i64x2, carry_u64x2);
+        sum_high_i64x2 = wasm_i64x2_add(sum_high_i64x2, wasm_i64x2_shr(data_high_i64x2, 63));
         v128_t sq_low_i64x2 = wasm_i64x2_extmul_low_i32x4(data_i32x4, data_i32x4);
         v128_t sq_high_i64x2 = wasm_i64x2_extmul_high_i32x4(data_i32x4, data_i32x4);
         v128_t sq_before_u64x2 = sumsq_u64x2;
@@ -897,26 +897,26 @@ NK_INTERNAL void nk_reduce_moments_i32_v128relaxed_contiguous_( //
                                wasm_i64x2_extract_lane(sumsq_overflow_u64x2, 1));
     nk_u64_t sumsq = sumsq_overflow ? NK_U64_MAX : nk_reduce_sadd_u64x2_v128relaxed_(sumsq_u64x2);
     nk_b128_vec_t lower_vec, upper_vec;
-    lower_vec.v128 = sum_lower_u64x2;
-    upper_vec.v128 = sum_upper_i64x2;
-    nk_u64_t sum_lower = 0;
-    nk_i64_t sum_upper = 0;
-    nk_u64_t sum_before = sum_lower;
-    sum_lower += lower_vec.u64s[0], sum_upper += (sum_lower < sum_before) + upper_vec.i64s[0];
-    sum_before = sum_lower;
-    sum_lower += lower_vec.u64s[1], sum_upper += (sum_lower < sum_before) + upper_vec.i64s[1];
+    lower_vec.v128 = sum_low_u64x2;
+    upper_vec.v128 = sum_high_i64x2;
+    nk_u64_t sum_low = 0;
+    nk_i64_t sum_high = 0;
+    nk_u64_t sum_before = sum_low;
+    sum_low += lower_vec.u64s[0], sum_high += (sum_low < sum_before) + upper_vec.i64s[0];
+    sum_before = sum_low;
+    sum_low += lower_vec.u64s[1], sum_high += (sum_low < sum_before) + upper_vec.i64s[1];
     for (; idx < count; ++idx) {
         nk_i64_t val = (nk_i64_t)data[idx];
-        sum_before = sum_lower;
-        sum_lower += (nk_u64_t)val;
-        if (sum_lower < sum_before) sum_upper++;
-        sum_upper += (val >> 63);
+        sum_before = sum_low;
+        sum_low += (nk_u64_t)val;
+        if (sum_low < sum_before) sum_high++;
+        sum_high += (val >> 63);
         nk_u64_t product = (nk_u64_t)(val * val);
         sumsq = nk_u64_saturating_add_serial(sumsq, product);
     }
-    nk_i64_t sum_lower_signed = (nk_i64_t)sum_lower;
-    if (sum_upper == (sum_lower_signed >> 63)) *sum_ptr = sum_lower_signed;
-    else if (sum_upper >= 0) *sum_ptr = NK_I64_MAX;
+    nk_i64_t sum_low_signed = (nk_i64_t)sum_low;
+    if (sum_high == (sum_low_signed >> 63)) *sum_ptr = sum_low_signed;
+    else if (sum_high >= 0) *sum_ptr = NK_I64_MAX;
     else *sum_ptr = NK_I64_MIN;
     *sumsq_ptr = sumsq;
 }
@@ -981,8 +981,8 @@ NK_PUBLIC void nk_reduce_moments_u32_v128relaxed(                  //
 NK_INTERNAL void nk_reduce_moments_i64_v128relaxed_contiguous_( //
     nk_i64_t const *data, nk_size_t count,                      //
     nk_i64_t *sum_ptr, nk_u64_t *sumsq_ptr) {
-    v128_t sum_lower_u64x2 = wasm_i64x2_splat(0);
-    v128_t sum_upper_i64x2 = wasm_i64x2_splat(0);
+    v128_t sum_low_u64x2 = wasm_i64x2_splat(0);
+    v128_t sum_high_i64x2 = wasm_i64x2_splat(0);
     v128_t sumsq_u64x2 = wasm_i64x2_splat(0);
     v128_t sumsq_overflow_u64x2 = wasm_i64x2_splat(0);
     v128_t sign_bit_i64x2 = wasm_i64x2_splat((nk_i64_t)0x8000000000000000LL);
@@ -995,36 +995,36 @@ NK_INTERNAL void nk_reduce_moments_i64_v128relaxed_contiguous_( //
         sumsq_overflow_u64x2 = wasm_v128_or(
             sumsq_overflow_u64x2,
             wasm_i64x2_gt(wasm_v128_xor(sq_before_u64x2, sign_bit_i64x2), wasm_v128_xor(sumsq_u64x2, sign_bit_i64x2)));
-        v128_t before_u64x2 = sum_lower_u64x2;
-        sum_lower_u64x2 = wasm_i64x2_add(sum_lower_u64x2, data_i64x2);
+        v128_t before_u64x2 = sum_low_u64x2;
+        sum_low_u64x2 = wasm_i64x2_add(sum_low_u64x2, data_i64x2);
         v128_t carry_u64x2 = wasm_i64x2_gt(wasm_v128_xor(before_u64x2, sign_bit_i64x2),
-                                           wasm_v128_xor(sum_lower_u64x2, sign_bit_i64x2));
-        sum_upper_i64x2 = wasm_i64x2_sub(sum_upper_i64x2, carry_u64x2);
-        sum_upper_i64x2 = wasm_i64x2_add(sum_upper_i64x2, wasm_i64x2_shr(data_i64x2, 63));
+                                           wasm_v128_xor(sum_low_u64x2, sign_bit_i64x2));
+        sum_high_i64x2 = wasm_i64x2_sub(sum_high_i64x2, carry_u64x2);
+        sum_high_i64x2 = wasm_i64x2_add(sum_high_i64x2, wasm_i64x2_shr(data_i64x2, 63));
     }
     int sumsq_overflow = (int)(wasm_i64x2_extract_lane(sumsq_overflow_u64x2, 0) |
                                wasm_i64x2_extract_lane(sumsq_overflow_u64x2, 1));
     nk_u64_t sumsq = sumsq_overflow ? NK_U64_MAX : nk_reduce_sadd_u64x2_v128relaxed_(sumsq_u64x2);
-    nk_u64_t sum_lower = (nk_u64_t)wasm_i64x2_extract_lane(sum_lower_u64x2, 0);
-    nk_i64_t sum_upper = wasm_i64x2_extract_lane(sum_upper_i64x2, 0);
+    nk_u64_t sum_low = (nk_u64_t)wasm_i64x2_extract_lane(sum_low_u64x2, 0);
+    nk_i64_t sum_high = wasm_i64x2_extract_lane(sum_high_i64x2, 0);
     {
-        nk_u64_t sum_before = sum_lower;
-        sum_lower += (nk_u64_t)wasm_i64x2_extract_lane(sum_lower_u64x2, 1);
-        if (sum_lower < sum_before) sum_upper++;
-        sum_upper += wasm_i64x2_extract_lane(sum_upper_i64x2, 1);
+        nk_u64_t sum_before = sum_low;
+        sum_low += (nk_u64_t)wasm_i64x2_extract_lane(sum_low_u64x2, 1);
+        if (sum_low < sum_before) sum_high++;
+        sum_high += wasm_i64x2_extract_lane(sum_high_i64x2, 1);
     }
     for (; idx < count; ++idx) {
         nk_i64_t val = data[idx];
         nk_u64_t unsigned_product = (nk_u64_t)nk_i64_saturating_mul_serial(val, val);
         sumsq = nk_u64_saturating_add_serial(sumsq, unsigned_product);
-        nk_u64_t sum_before = sum_lower;
-        sum_lower += (nk_u64_t)val;
-        if (sum_lower < sum_before) sum_upper++;
-        sum_upper += (val >> 63);
-    }
-    nk_i64_t sum_lower_signed = (nk_i64_t)sum_lower;
-    if (sum_upper == (sum_lower_signed >> 63)) *sum_ptr = sum_lower_signed;
-    else if (sum_upper >= 0) *sum_ptr = NK_I64_MAX;
+        nk_u64_t sum_before = sum_low;
+        sum_low += (nk_u64_t)val;
+        if (sum_low < sum_before) sum_high++;
+        sum_high += (val >> 63);
+    }
+    nk_i64_t sum_low_signed = (nk_i64_t)sum_low;
+    if (sum_high == (sum_low_signed >> 63)) *sum_ptr = sum_low_signed;
+    else if (sum_high >= 0) *sum_ptr = NK_I64_MAX;
     else *sum_ptr = NK_I64_MIN;
     *sumsq_ptr = sumsq;
 }

package/include/numkong/reduce.h

@@ -446,19 +446,13 @@ NK_PUBLIC void nk_reduce_minmax_e4m3_neon(nk_e4m3_t const *, nk_size_t, nk_size_
 /** @copydoc nk_reduce_minmax_f64 */
 NK_PUBLIC void nk_reduce_minmax_e5m2_neon(nk_e5m2_t const *, nk_size_t, nk_size_t, nk_e5m2_t *, nk_size_t *,
                                           nk_e5m2_t *, nk_size_t *);
-#endif // NK_TARGET_NEON
-
-#if NK_TARGET_NEONHALF
 /** @copydoc nk_reduce_moments_f64 */
-NK_PUBLIC void nk_reduce_moments_f16_neonhalf(nk_f16_t const *, nk_size_t, nk_size_t, nk_f32_t *, nk_f32_t *);
-#endif // NK_TARGET_NEONHALF
+NK_PUBLIC void nk_reduce_moments_f16_neon(nk_f16_t const *, nk_size_t, nk_size_t, nk_f32_t *, nk_f32_t *);
+#endif // NK_TARGET_NEON
 
 #if NK_TARGET_NEONBFDOT
 /** @copydoc nk_reduce_moments_f64 */
 NK_PUBLIC void nk_reduce_moments_bf16_neonbfdot(nk_bf16_t const *, nk_size_t, nk_size_t, nk_f32_t *, nk_f32_t *);
-/** @copydoc nk_reduce_minmax_f64 */
-NK_PUBLIC void nk_reduce_minmax_bf16_neonbfdot(nk_bf16_t const *, nk_size_t, nk_size_t, nk_bf16_t *, nk_size_t *,
-                                               nk_bf16_t *, nk_size_t *);
 #endif // NK_TARGET_NEONBFDOT
 
 #if NK_TARGET_NEONSDOT
@@ -475,12 +469,6 @@ NK_PUBLIC void nk_reduce_moments_e2m3_neonsdot(nk_e2m3_t const *, nk_size_t, nk_
 NK_PUBLIC void nk_reduce_moments_e4m3_neonfhm(nk_e4m3_t const *, nk_size_t, nk_size_t, nk_f32_t *, nk_f32_t *);
 /** @copydoc nk_reduce_moments_f64 */
 NK_PUBLIC void nk_reduce_moments_e5m2_neonfhm(nk_e5m2_t const *, nk_size_t, nk_size_t, nk_f32_t *, nk_f32_t *);
-/** @copydoc nk_reduce_minmax_f64 */
-NK_PUBLIC void nk_reduce_minmax_e4m3_neonfhm(nk_e4m3_t const *, nk_size_t, nk_size_t, nk_e4m3_t *, nk_size_t *,
-                                             nk_e4m3_t *, nk_size_t *);
-/** @copydoc nk_reduce_minmax_f64 */
-NK_PUBLIC void nk_reduce_minmax_e5m2_neonfhm(nk_e5m2_t const *, nk_size_t, nk_size_t, nk_e5m2_t *, nk_size_t *,
-                                             nk_e5m2_t *, nk_size_t *);
 #endif // NK_TARGET_NEONFHM
 
 #if NK_TARGET_HASWELL
@@ -950,7 +938,6 @@ NK_INTERNAL nk_dtype_t nk_reduce_minmax_value_dtype(nk_dtype_t dtype) {
 
 #include "numkong/reduce/serial.h"
 #include "numkong/reduce/neon.h"
-#include "numkong/reduce/neonhalf.h"
 #include "numkong/reduce/neonbfdot.h"
 #include "numkong/reduce/neonsdot.h"
 #include "numkong/reduce/neonfhm.h"
@@ -1324,8 +1311,8 @@ NK_PUBLIC void nk_reduce_moments_f16(nk_f16_t const *d, nk_size_t n, nk_size_t s
     nk_reduce_moments_f16_skylake(d, n, s, sum, sumsq);
 #elif NK_TARGET_HASWELL
     nk_reduce_moments_f16_haswell(d, n, s, sum, sumsq);
-#elif NK_TARGET_NEONHALF
-    nk_reduce_moments_f16_neonhalf(d, n, s, sum, sumsq);
+#elif NK_TARGET_NEON
+    nk_reduce_moments_f16_neon(d, n, s, sum, sumsq);
 #elif NK_TARGET_RVV
     nk_reduce_moments_f16_rvv(d, n, s, sum, sumsq);
 #elif NK_TARGET_V128RELAXED
@@ -1376,8 +1363,6 @@ NK_PUBLIC void nk_reduce_minmax_bf16(nk_bf16_t const *d, nk_size_t n, nk_size_t
     nk_reduce_minmax_bf16_skylake(d, n, s, mn, mi, mx, xi);
 #elif NK_TARGET_HASWELL
     nk_reduce_minmax_bf16_haswell(d, n, s, mn, mi, mx, xi);
-#elif NK_TARGET_NEONBFDOT
-    nk_reduce_minmax_bf16_neonbfdot(d, n, s, mn, mi, mx, xi);
 #elif NK_TARGET_RVV
     nk_reduce_minmax_bf16_rvv(d, n, s, mn, mi, mx, xi);
 #elif NK_TARGET_V128RELAXED
@@ -1413,8 +1398,6 @@ NK_PUBLIC void nk_reduce_minmax_e4m3(nk_e4m3_t const *d, nk_size_t n, nk_size_t
     nk_reduce_minmax_e4m3_skylake(d, n, s, mn, mi, mx, xi);
 #elif NK_TARGET_HASWELL
     nk_reduce_minmax_e4m3_haswell(d, n, s, mn, mi, mx, xi);
-#elif NK_TARGET_NEONFHM
-    nk_reduce_minmax_e4m3_neonfhm(d, n, s, mn, mi, mx, xi);
 #elif NK_TARGET_NEON
     nk_reduce_minmax_e4m3_neon(d, n, s, mn, mi, mx, xi);
 #elif NK_TARGET_RVV
@@ -1452,8 +1435,6 @@ NK_PUBLIC void nk_reduce_minmax_e5m2(nk_e5m2_t const *d, nk_size_t n, nk_size_t
     nk_reduce_minmax_e5m2_skylake(d, n, s, mn, mi, mx, xi);
 #elif NK_TARGET_HASWELL
     nk_reduce_minmax_e5m2_haswell(d, n, s, mn, mi, mx, xi);
-#elif NK_TARGET_NEONFHM
-    nk_reduce_minmax_e5m2_neonfhm(d, n, s, mn, mi, mx, xi);
 #elif NK_TARGET_NEON
     nk_reduce_minmax_e5m2_neon(d, n, s, mn, mi, mx, xi);
 #elif NK_TARGET_RVV

package/include/numkong/reduce.hpp

@@ -192,13 +192,95 @@ void reduce_minmax(in_type_ const *data, std::size_t count, std::size_t stride_b
     if (max_index) *max_index = static_cast<std::size_t>(max_offset);
 }
 
+/** @brief Compute sum and sum-of-squares over a vector view. */
+template <numeric_dtype in_type_, numeric_dtype sum_type_ = typename in_type_::reduce_moments_sum_t,
+          numeric_dtype sumsq_type_ = typename in_type_::reduce_moments_sumsq_t,
+          allow_simd_t allow_simd_ = prefer_simd_k>
+void reduce_moments(vector_view<in_type_> input, sum_type_ *sum, sumsq_type_ *sumsq) noexcept {
+    reduce_moments<in_type_, sum_type_, sumsq_type_, allow_simd_>(
+        input.data(), input.size(), static_cast<std::size_t>(input.stride_bytes()), sum, sumsq);
+}
+
+/** @brief Find minimum and maximum elements with their indices over a vector view. */
+template <numeric_dtype in_type_, numeric_dtype minmax_type_ = typename in_type_::reduce_minmax_value_t,
+          allow_simd_t allow_simd_ = prefer_simd_k>
+void reduce_minmax(vector_view<in_type_> input, minmax_type_ *min_value, std::size_t *min_index,
+                   minmax_type_ *max_value, std::size_t *max_index) noexcept {
+    reduce_minmax<in_type_, minmax_type_, allow_simd_>(input.data(), input.size(),
+                                                       static_cast<std::size_t>(input.stride_bytes()), min_value,
+                                                       min_index, max_value, max_index);
+}
+
 } // namespace ashvardanian::numkong
 
 #include "numkong/tensor.hpp"
 
 namespace ashvardanian::numkong {
 
-#pragma region - Tensor Reduction Helpers
+#pragma region Tensor Reduction Helpers
+
+/** @brief Result of detecting how many trailing dimensions form a single arithmetic progression. */
+struct uniform_stride_tail_result_t_ {
+    std::size_t tail_dims;     ///< Number of collapsible trailing dimensions.
+    std::size_t element_count; ///< Product of collapsed extents.
+    std::size_t stride_bytes;  ///< Absolute stride of the innermost collapsed dimension.
+};
+
+/** @brief Detect trailing dimensions where stride[i] == stride[i+1] * extent[i+1].
+ *  When this holds, the tail is a single strided sequence and can be passed to a SIMD
+ *  kernel in one call with (element_count, stride_bytes). */
+template <typename value_type_, std::size_t max_rank_>
+uniform_stride_tail_result_t_ uniform_stride_tail_(tensor_view<value_type_, max_rank_> input) noexcept {
+    if constexpr (dimensions_per_value<value_type_>() > 1) return {0, 0, 0};
+    auto rank = input.rank();
+    if (rank == 0) return {0, 1, sizeof(value_type_)};
+    std::size_t tail = 1;
+    auto innermost_stride = input.stride_bytes(rank - 1);
+    auto expected_stride = innermost_stride;
+    for (std::size_t i = rank - 1; i > 0; --i) {
+        expected_stride *= static_cast<std::ptrdiff_t>(input.extent(i));
+        if (input.stride_bytes(i - 1) != expected_stride) break;
+        ++tail;
+    }
+    std::size_t count = 1;
+    for (std::size_t i = rank - tail; i < rank; ++i) count *= input.extent(i);
+    return {tail, count, static_cast<std::size_t>(innermost_stride < 0 ? -innermost_stride : innermost_stride)};
+}
+
+/** @brief Collapse the trailing `tail.tail_dims` dimensions into one, preserving outer dims and strides. */
+template <typename value_type_, std::size_t max_rank_>
+tensor_view<value_type_, max_rank_> collapse_uniform_tail_(tensor_view<value_type_, max_rank_> input,
+                                                           uniform_stride_tail_result_t_ const &tail) noexcept {
+    shape_storage_<max_rank_> s;
+    s.rank = input.rank() - tail.tail_dims + 1;
+    for (std::size_t i = 0; i + tail.tail_dims < input.rank(); ++i) {
+        s.extents[i] = input.extent(i);
+        s.strides[i] = input.stride_bytes(i);
+    }
+    s.extents[s.rank - 1] = tail.element_count;
+    s.strides[s.rank - 1] = input.stride_bytes(input.rank() - 1);
+    return {input.byte_data(), s};
+}
+
+/** @brief Normalize a fully-collapsed tail for SIMD kernel consumption, handling negative strides. */
+template <typename value_type_, std::size_t max_rank_>
+normalized_rank1_lane_<value_type_, max_rank_> normalize_rank1_lane_from_tail_(
+    tensor_view<value_type_, max_rank_> input, uniform_stride_tail_result_t_ const &tail) noexcept {
+    normalized_rank1_lane_<value_type_, max_rank_> lane;
+    lane.count = tail.element_count;
+    lane.stride_bytes = tail.stride_bytes;
+    auto innermost_stride = input.stride_bytes(input.rank() - 1);
+    if (innermost_stride >= 0) {
+        lane.data = input.data();
+        lane.reversed = false;
+    }
+    else {
+        lane.data = reinterpret_cast<value_type_ const *>(
+            input.byte_data() + static_cast<std::ptrdiff_t>(lane.count - 1) * innermost_stride);
+        lane.reversed = true;
+    }
+    return lane;
+}
 
 template <numeric_dtype value_type_, std::size_t max_rank_>
 bool reduce_rank1_moments_(tensor_view<value_type_, max_rank_> input, typename value_type_::reduce_moments_sum_t &sum,
@@ -391,9 +473,9 @@ bool reduce_minmax_axis_packed_(tensor_view<value_type_, max_rank_> input, std::
     return true;
 }
 
-#pragma endregion - Tensor Reduction Helpers
+#pragma endregion Tensor Reduction Helpers
 
-#pragma region - Scalar Reductions
+#pragma region Scalar Reductions
 
 /** @brief Compute Σxᵢ and Σxᵢ² in a single pass. Returns zeroed result for empty tensors. */
 template <numeric_dtype value_type_, std::size_t max_rank_ = 8>
@@ -403,11 +485,14 @@ moments_result<typename value_type_::reduce_moments_sum_t, typename value_type_:
     using sumsq_t = typename value_type_::reduce_moments_sumsq_t;
     moments_result<sum_t, sumsq_t> result {};
     if (input.empty() || input.numel() == 0 || !tensor_layout_supported_(input)) return result;
-    if (input.is_contiguous()) {
-        numkong::reduce_moments<value_type_>(input.data(), input.numel(), sizeof(value_type_), &result.sum,
-                                             &result.sumsq);
+    auto tail = uniform_stride_tail_(input);
+    if (tail.tail_dims == input.rank()) {
+        auto lane = normalize_rank1_lane_from_tail_<value_type_, max_rank_>(input, tail);
+        numkong::reduce_moments<value_type_>(lane.data, lane.count, lane.stride_bytes, &result.sum, &result.sumsq);
         return result;
     }
+    if (tail.tail_dims >= 2) return moments<value_type_, max_rank_>(collapse_uniform_tail_(input, tail));
+    // Sub-byte rank-1 fallback: uniform_stride_tail_ returns {0,0,0} for packed types.
     if (input.rank() == 1) {
         reduce_rank1_moments_(input, result.sum, result.sumsq);
         return result;
@@ -426,11 +511,19 @@ minmax_result<typename value_type_::reduce_minmax_value_t> minmax(tensor_view<va
     using minmax_t = typename value_type_::reduce_minmax_value_t;
     minmax_result<minmax_t> result {};
     if (input.empty() || input.numel() == 0 || !tensor_layout_supported_(input)) return result;
-    if (input.is_contiguous()) {
-        numkong::reduce_minmax<value_type_>(input.data(), input.numel(), sizeof(value_type_), &result.min_value,
+    auto tail = uniform_stride_tail_(input);
+    if (tail.tail_dims == input.rank()) {
+        auto lane = normalize_rank1_lane_from_tail_<value_type_, max_rank_>(input, tail);
+        numkong::reduce_minmax<value_type_>(lane.data, lane.count, lane.stride_bytes, &result.min_value,
                                             &result.min_index, &result.max_value, &result.max_index);
+        if (lane.reversed) {
+            result.min_index = tail.element_count - 1 - result.min_index;
+            result.max_index = tail.element_count - 1 - result.max_index;
+        }
         return result;
     }
+    if (tail.tail_dims >= 2) return minmax<value_type_, max_rank_>(collapse_uniform_tail_(input, tail));
+    // Sub-byte rank-1 fallback.
     if (input.rank() == 1) {
         reduce_rank1_minmax_(input, result);
         return result;
@@ -484,9 +577,61 @@ std::size_t argmax(tensor_view<value_type_, max_rank_> input) noexcept {
     return minmax(input).max_index;
 }
 
-#pragma endregion - Scalar Reductions
+/** @brief Compute Σxᵢ and Σxᵢ² over a vector view. */
+template <numeric_dtype value_type_>
+moments_result<typename value_type_::reduce_moments_sum_t, typename value_type_::reduce_moments_sumsq_t> moments(
+    vector_view<value_type_> input) noexcept {
+    using sum_t = typename value_type_::reduce_moments_sum_t;
+    using sumsq_t = typename value_type_::reduce_moments_sumsq_t;
+    moments_result<sum_t, sumsq_t> result {};
+    if (input.size() == 0) return result;
+    reduce_moments<value_type_>(input, &result.sum, &result.sumsq);
+    return result;
+}
+
+/** @brief Find min and max values with their indices over a vector view. */
+template <numeric_dtype value_type_>
+minmax_result<typename value_type_::reduce_minmax_value_t> minmax(vector_view<value_type_> input) noexcept {
+    using minmax_t = typename value_type_::reduce_minmax_value_t;
+    minmax_result<minmax_t> result {};
+    if (input.size() == 0) return result;
+    reduce_minmax<value_type_>(input, &result.min_value, &result.min_index, &result.max_value, &result.max_index);
+    return result;
+}
+
+/** @brief Σ of all elements in a vector view. */
+template <numeric_dtype value_type_>
+typename value_type_::reduce_moments_sum_t sum(vector_view<value_type_> input) noexcept {
+    return moments(input).sum;
+}
+
+/** @brief Find the minimum element value in a vector view. */
+template <numeric_dtype value_type_>
+typename value_type_::reduce_minmax_value_t min(vector_view<value_type_> input) noexcept {
+    return minmax(input).min_value;
+}
+
+/** @brief Find the maximum element value in a vector view. */
+template <numeric_dtype value_type_>
+typename value_type_::reduce_minmax_value_t max(vector_view<value_type_> input) noexcept {
+    return minmax(input).max_value;
+}
+
+/** @brief Index of the minimum element in a vector view. */
+template <numeric_dtype value_type_>
+std::size_t argmin(vector_view<value_type_> input) noexcept {
+    return minmax(input).min_index;
+}
+
+/** @brief Index of the maximum element in a vector view. */
+template <numeric_dtype value_type_>
+std::size_t argmax(vector_view<value_type_> input) noexcept {
+    return minmax(input).max_index;
+}
+
+#pragma endregion Scalar Reductions
 
-#pragma region - Axis Reductions
+#pragma region Axis Reductions
 
 /** @brief Σ along a single axis. Returns empty tensor on failure. */
 template <numeric_dtype value_type_, std::size_t max_rank_ = 8,
@@ -626,7 +771,7 @@ tensor<typename value_type_::reduce_minmax_value_t, allocator_type_, max_rank_>
     return try_minmax<value_type_, max_rank_, allocator_type_>(input, axis, keep_dims).max_value;
 }
 
-#pragma endregion - Axis Reductions
+#pragma endregion Axis Reductions
 
 } // namespace ashvardanian::numkong
 

package/include/numkong/scalar/README.md

@@ -6,21 +6,21 @@ Ordering functions (`nk_f16_order`, `nk_bf16_order`, `nk_e4m3_order`) convert fl
 
 Reciprocal square root:
 
-```math
+$$
 \text{rsqrt}(x) = \frac{1}{\sqrt{x}}
-```
+$$
 
 Fused multiply-add:
 
-```math
+$$
 \text{fma}(a, b, c) = a \cdot b + c
-```
+$$
 
 Saturating addition:
 
-```math
+$$
 \text{sat\_add}(a, b) = \text{clamp}(a + b, \text{T\_MIN}, \text{T\_MAX})
-```
+$$
 
 Reformulating as Python pseudocode:
 

package/include/numkong/scalar/haswell.h

@@ -8,13 +8,13 @@
  *
  *  @section scalars_haswell_instructions Key AVX2/FMA Scalar Instructions
  *
- *      Intrinsic                   Instruction                     Latency     Throughput  Ports
- *      _mm_sqrt_ps                 VSQRTPS (XMM, XMM)              11cy        7cy         p0
- *      _mm_sqrt_pd                 VSQRTPD (XMM, XMM)              16cy        12cy        p0
- *      _mm_fmadd_ss                VFMADD (XMM, XMM, XMM)          5cy         0.5/cy      p01
- *      _mm_fmadd_sd                VFMADD (XMM, XMM, XMM)          5cy         0.5/cy      p01
- *      _mm_cvtps_ph                VCVTPS2PH (XMM, XMM, I8)        4cy         1/cy        p01+p5
- *      _mm_cvtph_ps                VCVTPH2PS (XMM, XMM)            5cy         1/cy        p01
+ *      Intrinsic     Instruction               Haswell    Genoa
+ *      _mm_sqrt_ps   VSQRTPS (XMM, XMM)        11cy @ p0  15cy @ p01
+ *      _mm_sqrt_pd   VSQRTPD (XMM, XMM)        16cy @ p0  15cy @ p01
+ *      _mm_fmadd_ss  VFMADD (XMM, XMM, XMM)    5cy @ p01  4cy @ p01
+ *      _mm_fmadd_sd  VFMADD (XMM, XMM, XMM)    5cy @ p01  4cy @ p01
+ *      _mm_cvtps_ph  VCVTPS2PH (XMM, XMM, I8)  5cy @ p01  4cy @ p12+p23
+ *      _mm_cvtph_ps  VCVTPH2PS (XMM, XMM)      5cy @ p01  4cy @ p12+p23
  */
 #ifndef NK_SCALAR_HASWELL_H
 #define NK_SCALAR_HASWELL_H
@@ -52,23 +52,32 @@ NK_PUBLIC nk_f64_t nk_f64_fma_haswell(nk_f64_t a, nk_f64_t b, nk_f64_t c) {
     return _mm_cvtsd_f64(_mm_fmadd_sd(_mm_set_sd(a), _mm_set_sd(b), _mm_set_sd(c)));
 }
 NK_PUBLIC nk_f16_t nk_f16_sqrt_haswell(nk_f16_t x) {
-    __m128 x_f32x4 = _mm_cvtph_ps(_mm_cvtsi32_si128(x));
-    return (nk_f16_t)_mm_cvtsi128_si32(_mm_cvtps_ph(_mm_sqrt_ps(x_f32x4), _MM_FROUND_TO_NEAREST_INT));
+    nk_fui16_t x_fui, out_fui;
+    x_fui.f = x;
+    __m128 x_f32x4 = _mm_cvtph_ps(_mm_cvtsi32_si128(x_fui.u));
+    out_fui.u = (nk_u16_t)_mm_cvtsi128_si32(_mm_cvtps_ph(_mm_sqrt_ps(x_f32x4), _MM_FROUND_TO_NEAREST_INT));
+    return out_fui.f;
 }
 NK_PUBLIC nk_f16_t nk_f16_rsqrt_haswell(nk_f16_t x) {
-    __m128 x_f32x4 = _mm_cvtph_ps(_mm_cvtsi32_si128(x));
+    nk_fui16_t x_fui, out_fui;
+    x_fui.f = x;
+    __m128 x_f32x4 = _mm_cvtph_ps(_mm_cvtsi32_si128(x_fui.u));
     __m128 estimate_f32x4 = _mm_rsqrt_ss(x_f32x4);
     __m128 refinement_f32x4 = _mm_mul_ss(_mm_mul_ss(x_f32x4, estimate_f32x4), estimate_f32x4);
     refinement_f32x4 = _mm_sub_ss(_mm_set_ss(3.0f), refinement_f32x4);
     estimate_f32x4 = _mm_mul_ss(_mm_mul_ss(_mm_set_ss(0.5f), estimate_f32x4), refinement_f32x4);
-    return (nk_f16_t)_mm_cvtsi128_si32(_mm_cvtps_ph(estimate_f32x4, _MM_FROUND_TO_NEAREST_INT));
+    out_fui.u = (nk_u16_t)_mm_cvtsi128_si32(_mm_cvtps_ph(estimate_f32x4, _MM_FROUND_TO_NEAREST_INT));
+    return out_fui.f;
 }
 NK_PUBLIC nk_f16_t nk_f16_fma_haswell(nk_f16_t a, nk_f16_t b, nk_f16_t c) {
-    __m128 a_f32x4 = _mm_cvtph_ps(_mm_cvtsi32_si128(a));
-    __m128 b_f32x4 = _mm_cvtph_ps(_mm_cvtsi32_si128(b));
-    __m128 c_f32x4 = _mm_cvtph_ps(_mm_cvtsi32_si128(c));
-    return (nk_f16_t)_mm_cvtsi128_si32(
+    nk_fui16_t a_fui, b_fui, c_fui, out_fui;
+    a_fui.f = a, b_fui.f = b, c_fui.f = c;
+    __m128 a_f32x4 = _mm_cvtph_ps(_mm_cvtsi32_si128(a_fui.u));
+    __m128 b_f32x4 = _mm_cvtph_ps(_mm_cvtsi32_si128(b_fui.u));
+    __m128 c_f32x4 = _mm_cvtph_ps(_mm_cvtsi32_si128(c_fui.u));
+    out_fui.u = (nk_u16_t)_mm_cvtsi128_si32(
         _mm_cvtps_ph(_mm_fmadd_ss(a_f32x4, b_f32x4, c_f32x4), _MM_FROUND_TO_NEAREST_INT));
+    return out_fui.f;
 }
 NK_PUBLIC nk_u8_t nk_u8_saturating_add_haswell(nk_u8_t a, nk_u8_t b) {
     return (nk_u8_t)_mm_cvtsi128_si32(_mm_adds_epu8(_mm_cvtsi32_si128(a), _mm_cvtsi32_si128(b)));
@@ -89,8 +98,8 @@ NK_PUBLIC nk_u64_t nk_u64_saturating_mul_haswell(nk_u64_t a, nk_u64_t b) {
 }
 NK_PUBLIC nk_i64_t nk_i64_saturating_mul_haswell(nk_i64_t a, nk_i64_t b) {
     int sign = (a < 0) ^ (b < 0);
-    nk_u64_t abs_a = a < 0 ? -(nk_u64_t)a : (nk_u64_t)a;
-    nk_u64_t abs_b = b < 0 ? -(nk_u64_t)b : (nk_u64_t)b;
+    nk_u64_t abs_a = a < 0 ? (0u - (nk_u64_t)a) : (nk_u64_t)a;
+    nk_u64_t abs_b = b < 0 ? (0u - (nk_u64_t)b) : (nk_u64_t)b;
     unsigned long long high;
     unsigned long long low = _mulx_u64(abs_a, abs_b, &high);
     if (high || (sign && low > 9223372036854775808ull) || (!sign && low > 9223372036854775807ull))

package/include/numkong/scalar/loongsonasx.h

@@ -0,0 +1,74 @@
+/**
+ *  @brief SIMD-accelerated Scalar Math Helpers for LoongArch LASX.
+ *  @file include/numkong/scalar/loongsonasx.h
+ *  @author Ash Vardanian
+ *  @date March 23, 2026
+ *
+ *  @sa include/numkong/scalar.h
+ *
+ *  LASX provides `xvfrsqrt` (full-precision reciprocal sqrt) and `xvfsqrt`
+ *  (full-precision sqrt). No Newton-Raphson refinement needed.
+ *  Full-precision sqrt uses the hardware `xvfsqrt` instruction.
+ *  Broadcast via `xvreplgr2vr`, extract via `xvpickve2gr` — no memory round-trips.
+ */
+#ifndef NK_SCALAR_LOONGSONASX_H
+#define NK_SCALAR_LOONGSONASX_H
+
+#if NK_TARGET_LOONGARCH_
+#if NK_TARGET_LOONGSONASX
+
+#include "numkong/types.h"
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+/** @brief Broadcast f32 scalar into all 4 lanes of a 128-bit register (GCC/Clang portable). */
+NK_INTERNAL __m128 nk_xvreplgr2vr_s_128_(float x) {
+    nk_fui32_t c;
+    c.f = x;
+    return (__m128)__lsx_vreplgr2vr_w((int)c.u);
+}
+
+/** @brief Broadcast f32 scalar into all 8 lanes of a 256-bit register (GCC/Clang portable). */
+NK_INTERNAL __m256 nk_xvfreplgr2vr_s_(float x) {
+    nk_fui32_t c;
+    c.f = x;
+    return (__m256)__lasx_xvreplgr2vr_w((int)c.u);
+}
+
+/** @brief Broadcast f64 scalar into all 4 lanes of a 256-bit register (GCC/Clang portable). */
+NK_INTERNAL __m256d nk_xvfreplgr2vr_d_(double x) {
+    nk_fui64_t c;
+    c.f = x;
+    return (__m256d)__lasx_xvreplgr2vr_d((long long)c.u);
+}
+
+NK_PUBLIC nk_f32_t nk_f32_rsqrt_loongsonasx(nk_f32_t x) {
+    // xvfrsqrt.s is full precision — no Newton-Raphson needed
+    __m256 x_f32x8 = nk_xvfreplgr2vr_s_(x);
+    __m256 result_f32x8 = __lasx_xvfrsqrt_s(x_f32x8);
+    nk_fui32_t c;
+    c.u = (nk_u32_t)__lasx_xvpickve2gr_w((__m256i)result_f32x8, 0);
+    return c.f;
+}
+
+NK_PUBLIC nk_f32_t nk_f32_sqrt_loongsonasx(nk_f32_t x) { return x > 0 ? x * nk_f32_rsqrt_loongsonasx(x) : 0; }
+
+NK_PUBLIC nk_f64_t nk_f64_sqrt_loongsonasx(nk_f64_t x) {
+    __m256d x_f64x4 = nk_xvfreplgr2vr_d_(x);
+    __m256d result_f64x4 = __lasx_xvfsqrt_d(x_f64x4);
+    nk_fui64_t c;
+    c.u = (nk_u64_t)__lasx_xvpickve2gr_du((__m256i)result_f64x4, 0);
+    return c.f;
+}
+
+NK_PUBLIC nk_f64_t nk_f64_rsqrt_loongsonasx(nk_f64_t x) { return 1.0 / nk_f64_sqrt_loongsonasx(x); }
+
+#if defined(__cplusplus)
+} // extern "C"
+#endif
+
+#endif // NK_TARGET_LOONGSONASX
+#endif // NK_TARGET_LOONGARCH_
+#endif // NK_SCALAR_LOONGSONASX_H