numkong 7.0.0 → 7.4.2

package/c/dispatch_i8.c

@@ -34,6 +34,10 @@ void nk_dispatch_i8_find_(nk_capability_t v, nk_kernel_kind_t k, nk_kernel_punne
         case nk_kernel_euclideans_symmetric_k:
             *m = (m_t)&nk_euclideans_symmetric_i8_v128relaxed, *c = nk_cap_v128relaxed_k;
             return;
+        case nk_kernel_each_sum_k: *m = (m_t)&nk_each_sum_i8_v128relaxed, *c = nk_cap_v128relaxed_k; return;
+        case nk_kernel_each_scale_k: *m = (m_t)&nk_each_scale_i8_v128relaxed, *c = nk_cap_v128relaxed_k; return;
+        case nk_kernel_each_blend_k: *m = (m_t)&nk_each_blend_i8_v128relaxed, *c = nk_cap_v128relaxed_k; return;
+        case nk_kernel_each_fma_k: *m = (m_t)&nk_each_fma_i8_v128relaxed, *c = nk_cap_v128relaxed_k; return;
         default: break;
         }
 #endif
@@ -50,6 +54,15 @@ void nk_dispatch_i8_find_(nk_capability_t v, nk_kernel_kind_t k, nk_kernel_punne
         default: break;
         }
 #endif
+#if NK_TARGET_SVESDOT
+    if (v & nk_cap_svesdot_k) switch (k) {
+        case nk_kernel_dot_k: *m = (m_t)&nk_dot_i8_svesdot, *c = nk_cap_svesdot_k; return;
+        case nk_kernel_angular_k: *m = (m_t)&nk_angular_i8_svesdot, *c = nk_cap_svesdot_k; return;
+        case nk_kernel_sqeuclidean_k: *m = (m_t)&nk_sqeuclidean_i8_svesdot, *c = nk_cap_svesdot_k; return;
+        case nk_kernel_euclidean_k: *m = (m_t)&nk_euclidean_i8_svesdot, *c = nk_cap_svesdot_k; return;
+        default: break;
+        }
+#endif
 #if NK_TARGET_NEONSDOT
     if (v & nk_cap_neonsdot_k) switch (k) {
         case nk_kernel_dot_k: *m = (m_t)&nk_dot_i8_neonsdot, *c = nk_cap_neonsdot_k; return;
@@ -74,15 +87,14 @@ void nk_dispatch_i8_find_(nk_capability_t v, nk_kernel_kind_t k, nk_kernel_punne
 #endif
 #if NK_TARGET_NEONHALF
     if (v & nk_cap_neonhalf_k) switch (k) {
-        case nk_kernel_each_fma_k: *m = (m_t)&nk_each_fma_i8_neonhalf, *c = nk_cap_neonhalf_k; return;
         case nk_kernel_each_blend_k: *m = (m_t)&nk_each_blend_i8_neonhalf, *c = nk_cap_neonhalf_k; return;
         case nk_kernel_each_scale_k: *m = (m_t)&nk_each_scale_i8_neonhalf, *c = nk_cap_neonhalf_k; return;
-        case nk_kernel_each_sum_k: *m = (m_t)&nk_each_sum_i8_neonhalf, *c = nk_cap_neonhalf_k; return;
         default: break;
         }
 #endif
 #if NK_TARGET_NEON
     if (v & nk_cap_neon_k) switch (k) {
+        case nk_kernel_each_sum_k: *m = (m_t)&nk_each_sum_i8_neon, *c = nk_cap_neon_k; return;
         case nk_kernel_reduce_moments_k: *m = (m_t)&nk_reduce_moments_i8_neon, *c = nk_cap_neon_k; return;
         case nk_kernel_reduce_minmax_k: *m = (m_t)&nk_reduce_minmax_i8_neon, *c = nk_cap_neon_k; return;
         default: break;
@@ -113,7 +125,6 @@ void nk_dispatch_i8_find_(nk_capability_t v, nk_kernel_kind_t k, nk_kernel_punne
 #endif
 #if NK_TARGET_SAPPHIRE
     if (v & nk_cap_sapphire_k) switch (k) {
-        case nk_kernel_each_fma_k: *m = (m_t)&nk_each_fma_i8_sapphire, *c = nk_cap_sapphire_k; return;
         case nk_kernel_each_blend_k: *m = (m_t)&nk_each_blend_i8_sapphire, *c = nk_cap_sapphire_k; return;
         case nk_kernel_each_scale_k: *m = (m_t)&nk_each_scale_i8_sapphire, *c = nk_cap_sapphire_k; return;
         default: break;
@@ -212,6 +223,54 @@ void nk_dispatch_i8_find_(nk_capability_t v, nk_kernel_kind_t k, nk_kernel_punne
         default: break;
         }
 #endif
+#if NK_TARGET_POWERVSX
+    if (v & nk_cap_powervsx_k) switch (k) {
+        case nk_kernel_dot_k: *m = (m_t)&nk_dot_i8_powervsx, *c = nk_cap_powervsx_k; return;
+        case nk_kernel_dots_packed_size_k: *m = (m_t)&nk_dots_packed_size_i8_powervsx, *c = nk_cap_powervsx_k; return;
+        case nk_kernel_dots_pack_k: *m = (m_t)&nk_dots_pack_i8_powervsx, *c = nk_cap_powervsx_k; return;
+        case nk_kernel_dots_packed_k: *m = (m_t)&nk_dots_packed_i8_powervsx, *c = nk_cap_powervsx_k; return;
+        case nk_kernel_dots_symmetric_k: *m = (m_t)&nk_dots_symmetric_i8_powervsx, *c = nk_cap_powervsx_k; return;
+        case nk_kernel_angular_k: *m = (m_t)&nk_angular_i8_powervsx, *c = nk_cap_powervsx_k; return;
+        case nk_kernel_sqeuclidean_k: *m = (m_t)&nk_sqeuclidean_i8_powervsx, *c = nk_cap_powervsx_k; return;
+        case nk_kernel_euclidean_k: *m = (m_t)&nk_euclidean_i8_powervsx, *c = nk_cap_powervsx_k; return;
+        case nk_kernel_angulars_packed_k: *m = (m_t)&nk_angulars_packed_i8_powervsx, *c = nk_cap_powervsx_k; return;
+        case nk_kernel_angulars_symmetric_k:
+            *m = (m_t)&nk_angulars_symmetric_i8_powervsx, *c = nk_cap_powervsx_k;
+            return;
+        case nk_kernel_euclideans_packed_k: *m = (m_t)&nk_euclideans_packed_i8_powervsx, *c = nk_cap_powervsx_k; return;
+        case nk_kernel_euclideans_symmetric_k:
+            *m = (m_t)&nk_euclideans_symmetric_i8_powervsx, *c = nk_cap_powervsx_k;
+            return;
+        default: break;
+        }
+#endif
+#if NK_TARGET_LOONGSONASX
+    if (v & nk_cap_loongsonasx_k) switch (k) {
+        case nk_kernel_dot_k: *m = (m_t)&nk_dot_i8_loongsonasx, *c = nk_cap_loongsonasx_k; return;
+        case nk_kernel_angular_k: *m = (m_t)&nk_angular_i8_loongsonasx, *c = nk_cap_loongsonasx_k; return;
+        case nk_kernel_sqeuclidean_k: *m = (m_t)&nk_sqeuclidean_i8_loongsonasx, *c = nk_cap_loongsonasx_k; return;
+        case nk_kernel_euclidean_k: *m = (m_t)&nk_euclidean_i8_loongsonasx, *c = nk_cap_loongsonasx_k; return;
+        case nk_kernel_dots_packed_size_k:
+            *m = (m_t)&nk_dots_packed_size_i8_loongsonasx, *c = nk_cap_loongsonasx_k;
+            return;
+        case nk_kernel_dots_pack_k: *m = (m_t)&nk_dots_pack_i8_loongsonasx, *c = nk_cap_loongsonasx_k; return;
+        case nk_kernel_dots_packed_k: *m = (m_t)&nk_dots_packed_i8_loongsonasx, *c = nk_cap_loongsonasx_k; return;
+        case nk_kernel_dots_symmetric_k: *m = (m_t)&nk_dots_symmetric_i8_loongsonasx, *c = nk_cap_loongsonasx_k; return;
+        case nk_kernel_angulars_packed_k:
+            *m = (m_t)&nk_angulars_packed_i8_loongsonasx, *c = nk_cap_loongsonasx_k;
+            return;
+        case nk_kernel_angulars_symmetric_k:
+            *m = (m_t)&nk_angulars_symmetric_i8_loongsonasx, *c = nk_cap_loongsonasx_k;
+            return;
+        case nk_kernel_euclideans_packed_k:
+            *m = (m_t)&nk_euclideans_packed_i8_loongsonasx, *c = nk_cap_loongsonasx_k;
+            return;
+        case nk_kernel_euclideans_symmetric_k:
+            *m = (m_t)&nk_euclideans_symmetric_i8_loongsonasx, *c = nk_cap_loongsonasx_k;
+            return;
+        default: break;
+        }
+#endif
 #if NK_TARGET_RVV
     if (v & nk_cap_rvv_k) switch (k) {
         case nk_kernel_dot_k: *m = (m_t)&nk_dot_i8_rvv, *c = nk_cap_rvv_k; return;

package/c/dispatch_other.c

@@ -89,6 +89,13 @@ void nk_dispatch_cast_init_(nk_capability_t caps) {
     }
 #endif
 
+#if NK_TARGET_POWERVSX
+    if (caps & nk_cap_powervsx_k) {
+        t->f16_to_f32 = &nk_f16_to_f32_powervsx;
+        t->f32_to_f16 = &nk_f32_to_f16_powervsx;
+    }
+#endif
+
     // Scalar conversions: e5m2, e4m3, e3m2, e2m3 (serial only)
     t->e5m2_to_f32 = &nk_e5m2_to_f32_serial;
     t->f32_to_e5m2 = &nk_f32_to_e5m2_serial;
@@ -144,6 +151,17 @@ void nk_dispatch_math_init_(nk_capability_t caps) {
     }
 #endif
 
+#if NK_TARGET_POWERVSX
+    if (caps & nk_cap_powervsx_k) {
+        t->f64_sqrt = &nk_f64_sqrt_powervsx;
+        t->f64_rsqrt = &nk_f64_rsqrt_powervsx;
+        t->f64_fma = &nk_f64_fma_powervsx;
+        t->f32_sqrt = &nk_f32_sqrt_powervsx;
+        t->f32_rsqrt = &nk_f32_rsqrt_powervsx;
+        t->f32_fma = &nk_f32_fma_powervsx;
+    }
+#endif
+
     // Scalar math: f16
     t->f16_sqrt = &nk_f16_sqrt_serial;
     t->f16_rsqrt = &nk_f16_rsqrt_serial;

package/c/dispatch_u1.c

@@ -17,15 +17,15 @@ void nk_dispatch_u1_find_(nk_capability_t v, nk_kernel_kind_t k, nk_kernel_punne
         }
 #endif
 #if NK_TARGET_SMEBI32
-    if (v & nk_cap_sme_k) switch (k) {
-        case nk_kernel_dots_packed_size_k: *m = (m_t)&nk_dots_packed_size_u1_smebi32, *c = nk_cap_sme_k; return;
-        case nk_kernel_dots_pack_k: *m = (m_t)&nk_dots_pack_u1_smebi32, *c = nk_cap_sme_k; return;
-        case nk_kernel_dots_packed_k: *m = (m_t)&nk_dots_packed_u1_smebi32, *c = nk_cap_sme_k; return;
-        case nk_kernel_dots_symmetric_k: *m = (m_t)&nk_dots_symmetric_u1_smebi32, *c = nk_cap_sme_k; return;
-        case nk_kernel_hammings_packed_k: *m = (m_t)&nk_hammings_packed_u1_smebi32, *c = nk_cap_sme_k; return;
-        case nk_kernel_hammings_symmetric_k: *m = (m_t)&nk_hammings_symmetric_u1_smebi32, *c = nk_cap_sme_k; return;
-        case nk_kernel_jaccards_packed_k: *m = (m_t)&nk_jaccards_packed_u1_smebi32, *c = nk_cap_sme_k; return;
-        case nk_kernel_jaccards_symmetric_k: *m = (m_t)&nk_jaccards_symmetric_u1_smebi32, *c = nk_cap_sme_k; return;
+    if (v & nk_cap_smebi32_k) switch (k) {
+        case nk_kernel_dots_packed_size_k: *m = (m_t)&nk_dots_packed_size_u1_smebi32, *c = nk_cap_smebi32_k; return;
+        case nk_kernel_dots_pack_k: *m = (m_t)&nk_dots_pack_u1_smebi32, *c = nk_cap_smebi32_k; return;
+        case nk_kernel_dots_packed_k: *m = (m_t)&nk_dots_packed_u1_smebi32, *c = nk_cap_smebi32_k; return;
+        case nk_kernel_dots_symmetric_k: *m = (m_t)&nk_dots_symmetric_u1_smebi32, *c = nk_cap_smebi32_k; return;
+        case nk_kernel_hammings_packed_k: *m = (m_t)&nk_hammings_packed_u1_smebi32, *c = nk_cap_smebi32_k; return;
+        case nk_kernel_hammings_symmetric_k: *m = (m_t)&nk_hammings_symmetric_u1_smebi32, *c = nk_cap_smebi32_k; return;
+        case nk_kernel_jaccards_packed_k: *m = (m_t)&nk_jaccards_packed_u1_smebi32, *c = nk_cap_smebi32_k; return;
+        case nk_kernel_jaccards_symmetric_k: *m = (m_t)&nk_jaccards_symmetric_u1_smebi32, *c = nk_cap_smebi32_k; return;
         default: break;
         }
 #endif
@@ -91,6 +91,51 @@ void nk_dispatch_u1_find_(nk_capability_t v, nk_kernel_kind_t k, nk_kernel_punne
         default: break;
         }
 #endif
+#if NK_TARGET_POWERVSX
+    if (v & nk_cap_powervsx_k) switch (k) {
+        case nk_kernel_dot_k: *m = (m_t)&nk_dot_u1_powervsx, *c = nk_cap_powervsx_k; return;
+        case nk_kernel_hamming_k: *m = (m_t)&nk_hamming_u1_powervsx, *c = nk_cap_powervsx_k; return;
+        case nk_kernel_jaccard_k: *m = (m_t)&nk_jaccard_u1_powervsx, *c = nk_cap_powervsx_k; return;
+        case nk_kernel_dots_packed_size_k: *m = (m_t)&nk_dots_packed_size_u1_powervsx, *c = nk_cap_powervsx_k; return;
+        case nk_kernel_dots_pack_k: *m = (m_t)&nk_dots_pack_u1_powervsx, *c = nk_cap_powervsx_k; return;
+        case nk_kernel_dots_packed_k: *m = (m_t)&nk_dots_packed_u1_powervsx, *c = nk_cap_powervsx_k; return;
+        case nk_kernel_dots_symmetric_k: *m = (m_t)&nk_dots_symmetric_u1_powervsx, *c = nk_cap_powervsx_k; return;
+        case nk_kernel_hammings_packed_k: *m = (m_t)&nk_hammings_packed_u1_powervsx, *c = nk_cap_powervsx_k; return;
+        case nk_kernel_hammings_symmetric_k:
+            *m = (m_t)&nk_hammings_symmetric_u1_powervsx, *c = nk_cap_powervsx_k;
+            return;
+        case nk_kernel_jaccards_packed_k: *m = (m_t)&nk_jaccards_packed_u1_powervsx, *c = nk_cap_powervsx_k; return;
+        case nk_kernel_jaccards_symmetric_k:
+            *m = (m_t)&nk_jaccards_symmetric_u1_powervsx, *c = nk_cap_powervsx_k;
+            return;
+        default: break;
+        }
+#endif
+#if NK_TARGET_LOONGSONASX
+    if (v & nk_cap_loongsonasx_k) switch (k) {
+        case nk_kernel_hamming_k: *m = (m_t)&nk_hamming_u1_loongsonasx, *c = nk_cap_loongsonasx_k; return;
+        case nk_kernel_jaccard_k: *m = (m_t)&nk_jaccard_u1_loongsonasx, *c = nk_cap_loongsonasx_k; return;
+        case nk_kernel_dots_packed_size_k:
+            *m = (m_t)&nk_dots_packed_size_u1_loongsonasx, *c = nk_cap_loongsonasx_k;
+            return;
+        case nk_kernel_dots_pack_k: *m = (m_t)&nk_dots_pack_u1_loongsonasx, *c = nk_cap_loongsonasx_k; return;
+        case nk_kernel_dots_packed_k: *m = (m_t)&nk_dots_packed_u1_loongsonasx, *c = nk_cap_loongsonasx_k; return;
+        case nk_kernel_dots_symmetric_k: *m = (m_t)&nk_dots_symmetric_u1_loongsonasx, *c = nk_cap_loongsonasx_k; return;
+        case nk_kernel_hammings_packed_k:
+            *m = (m_t)&nk_hammings_packed_u1_loongsonasx, *c = nk_cap_loongsonasx_k;
+            return;
+        case nk_kernel_hammings_symmetric_k:
+            *m = (m_t)&nk_hammings_symmetric_u1_loongsonasx, *c = nk_cap_loongsonasx_k;
+            return;
+        case nk_kernel_jaccards_packed_k:
+            *m = (m_t)&nk_jaccards_packed_u1_loongsonasx, *c = nk_cap_loongsonasx_k;
+            return;
+        case nk_kernel_jaccards_symmetric_k:
+            *m = (m_t)&nk_jaccards_symmetric_u1_loongsonasx, *c = nk_cap_loongsonasx_k;
+            return;
+        default: break;
+        }
+#endif
 #if NK_TARGET_RVVBB
     if (v & nk_cap_rvvbb_k) switch (k) {
         case nk_kernel_dot_k: *m = (m_t)&nk_dot_u1_rvvbb, *c = nk_cap_rvvbb_k; return;

package/c/dispatch_u4.c

@@ -52,6 +52,9 @@ void nk_dispatch_u4_find_(nk_capability_t v, nk_kernel_kind_t k, nk_kernel_punne
         case nk_kernel_euclideans_symmetric_k:
             *m = (m_t)&nk_euclideans_symmetric_u4_neonsdot, *c = nk_cap_neonsdot_k;
             return;
+        case nk_kernel_angular_k: *m = (m_t)&nk_angular_u4_neonsdot, *c = nk_cap_neonsdot_k; return;
+        case nk_kernel_sqeuclidean_k: *m = (m_t)&nk_sqeuclidean_u4_neonsdot, *c = nk_cap_neonsdot_k; return;
+        case nk_kernel_euclidean_k: *m = (m_t)&nk_euclidean_u4_neonsdot, *c = nk_cap_neonsdot_k; return;
         default: break;
         }
 #endif

package/c/dispatch_u8.c

@@ -35,6 +35,10 @@ void nk_dispatch_u8_find_(nk_capability_t v, nk_kernel_kind_t k, nk_kernel_punne
         case nk_kernel_euclideans_symmetric_k:
             *m = (m_t)&nk_euclideans_symmetric_u8_v128relaxed, *c = nk_cap_v128relaxed_k;
             return;
+        case nk_kernel_each_sum_k: *m = (m_t)&nk_each_sum_u8_v128relaxed, *c = nk_cap_v128relaxed_k; return;
+        case nk_kernel_each_scale_k: *m = (m_t)&nk_each_scale_u8_v128relaxed, *c = nk_cap_v128relaxed_k; return;
+        case nk_kernel_each_blend_k: *m = (m_t)&nk_each_blend_u8_v128relaxed, *c = nk_cap_v128relaxed_k; return;
+        case nk_kernel_each_fma_k: *m = (m_t)&nk_each_fma_u8_v128relaxed, *c = nk_cap_v128relaxed_k; return;
         default: break;
         }
 #endif
@@ -57,6 +61,15 @@ void nk_dispatch_u8_find_(nk_capability_t v, nk_kernel_kind_t k, nk_kernel_punne
         default: break;
         }
 #endif
+#if NK_TARGET_SVESDOT
+    if (v & nk_cap_svesdot_k) switch (k) {
+        case nk_kernel_dot_k: *m = (m_t)&nk_dot_u8_svesdot, *c = nk_cap_svesdot_k; return;
+        case nk_kernel_angular_k: *m = (m_t)&nk_angular_u8_svesdot, *c = nk_cap_svesdot_k; return;
+        case nk_kernel_sqeuclidean_k: *m = (m_t)&nk_sqeuclidean_u8_svesdot, *c = nk_cap_svesdot_k; return;
+        case nk_kernel_euclidean_k: *m = (m_t)&nk_euclidean_u8_svesdot, *c = nk_cap_svesdot_k; return;
+        default: break;
+        }
+#endif
 #if NK_TARGET_NEONSDOT
     if (v & nk_cap_neonsdot_k) switch (k) {
         case nk_kernel_dot_k: *m = (m_t)&nk_dot_u8_neonsdot, *c = nk_cap_neonsdot_k; return;
@@ -81,16 +94,15 @@ void nk_dispatch_u8_find_(nk_capability_t v, nk_kernel_kind_t k, nk_kernel_punne
 #endif
 #if NK_TARGET_NEONHALF
     if (v & nk_cap_neonhalf_k) switch (k) {
-        case nk_kernel_each_fma_k: *m = (m_t)&nk_each_fma_u8_neonhalf, *c = nk_cap_neonhalf_k; return;
         case nk_kernel_each_blend_k: *m = (m_t)&nk_each_blend_u8_neonhalf, *c = nk_cap_neonhalf_k; return;
         case nk_kernel_each_scale_k: *m = (m_t)&nk_each_scale_u8_neonhalf, *c = nk_cap_neonhalf_k; return;
-        case nk_kernel_each_sum_k: *m = (m_t)&nk_each_sum_u8_neonhalf, *c = nk_cap_neonhalf_k; return;
         default: break;
         }
 #endif
 #if NK_TARGET_NEON
     if (v & nk_cap_neon_k) switch (k) {
         case nk_kernel_hamming_k: *m = (m_t)&nk_hamming_u8_neon, *c = nk_cap_neon_k; return;
+        case nk_kernel_each_sum_k: *m = (m_t)&nk_each_sum_u8_neon, *c = nk_cap_neon_k; return;
         case nk_kernel_reduce_moments_k: *m = (m_t)&nk_reduce_moments_u8_neon, *c = nk_cap_neon_k; return;
         case nk_kernel_reduce_minmax_k: *m = (m_t)&nk_reduce_minmax_u8_neon, *c = nk_cap_neon_k; return;
         default: break;
@@ -121,7 +133,6 @@ void nk_dispatch_u8_find_(nk_capability_t v, nk_kernel_kind_t k, nk_kernel_punne
 #endif
 #if NK_TARGET_SAPPHIRE
     if (v & nk_cap_sapphire_k) switch (k) {
-        case nk_kernel_each_fma_k: *m = (m_t)&nk_each_fma_u8_sapphire, *c = nk_cap_sapphire_k; return;
         case nk_kernel_each_blend_k: *m = (m_t)&nk_each_blend_u8_sapphire, *c = nk_cap_sapphire_k; return;
         case nk_kernel_each_scale_k: *m = (m_t)&nk_each_scale_u8_sapphire, *c = nk_cap_sapphire_k; return;
         default: break;
@@ -223,6 +234,56 @@ void nk_dispatch_u8_find_(nk_capability_t v, nk_kernel_kind_t k, nk_kernel_punne
         default: break;
         }
 #endif
+#if NK_TARGET_POWERVSX
+    if (v & nk_cap_powervsx_k) switch (k) {
+        case nk_kernel_dot_k: *m = (m_t)&nk_dot_u8_powervsx, *c = nk_cap_powervsx_k; return;
+        case nk_kernel_hamming_k: *m = (m_t)&nk_hamming_u8_powervsx, *c = nk_cap_powervsx_k; return;
+        case nk_kernel_dots_packed_size_k: *m = (m_t)&nk_dots_packed_size_u8_powervsx, *c = nk_cap_powervsx_k; return;
+        case nk_kernel_dots_pack_k: *m = (m_t)&nk_dots_pack_u8_powervsx, *c = nk_cap_powervsx_k; return;
+        case nk_kernel_dots_packed_k: *m = (m_t)&nk_dots_packed_u8_powervsx, *c = nk_cap_powervsx_k; return;
+        case nk_kernel_dots_symmetric_k: *m = (m_t)&nk_dots_symmetric_u8_powervsx, *c = nk_cap_powervsx_k; return;
+        case nk_kernel_angular_k: *m = (m_t)&nk_angular_u8_powervsx, *c = nk_cap_powervsx_k; return;
+        case nk_kernel_sqeuclidean_k: *m = (m_t)&nk_sqeuclidean_u8_powervsx, *c = nk_cap_powervsx_k; return;
+        case nk_kernel_euclidean_k: *m = (m_t)&nk_euclidean_u8_powervsx, *c = nk_cap_powervsx_k; return;
+        case nk_kernel_angulars_packed_k: *m = (m_t)&nk_angulars_packed_u8_powervsx, *c = nk_cap_powervsx_k; return;
+        case nk_kernel_angulars_symmetric_k:
+            *m = (m_t)&nk_angulars_symmetric_u8_powervsx, *c = nk_cap_powervsx_k;
+            return;
+        case nk_kernel_euclideans_packed_k: *m = (m_t)&nk_euclideans_packed_u8_powervsx, *c = nk_cap_powervsx_k; return;
+        case nk_kernel_euclideans_symmetric_k:
+            *m = (m_t)&nk_euclideans_symmetric_u8_powervsx, *c = nk_cap_powervsx_k;
+            return;
+        default: break;
+        }
+#endif
+#if NK_TARGET_LOONGSONASX
+    if (v & nk_cap_loongsonasx_k) switch (k) {
+        case nk_kernel_dot_k: *m = (m_t)&nk_dot_u8_loongsonasx, *c = nk_cap_loongsonasx_k; return;
+        case nk_kernel_angular_k: *m = (m_t)&nk_angular_u8_loongsonasx, *c = nk_cap_loongsonasx_k; return;
+        case nk_kernel_sqeuclidean_k: *m = (m_t)&nk_sqeuclidean_u8_loongsonasx, *c = nk_cap_loongsonasx_k; return;
+        case nk_kernel_euclidean_k: *m = (m_t)&nk_euclidean_u8_loongsonasx, *c = nk_cap_loongsonasx_k; return;
+        case nk_kernel_hamming_k: *m = (m_t)&nk_hamming_u8_loongsonasx, *c = nk_cap_loongsonasx_k; return;
+        case nk_kernel_dots_packed_size_k:
+            *m = (m_t)&nk_dots_packed_size_u8_loongsonasx, *c = nk_cap_loongsonasx_k;
+            return;
+        case nk_kernel_dots_pack_k: *m = (m_t)&nk_dots_pack_u8_loongsonasx, *c = nk_cap_loongsonasx_k; return;
+        case nk_kernel_dots_packed_k: *m = (m_t)&nk_dots_packed_u8_loongsonasx, *c = nk_cap_loongsonasx_k; return;
+        case nk_kernel_dots_symmetric_k: *m = (m_t)&nk_dots_symmetric_u8_loongsonasx, *c = nk_cap_loongsonasx_k; return;
+        case nk_kernel_angulars_packed_k:
+            *m = (m_t)&nk_angulars_packed_u8_loongsonasx, *c = nk_cap_loongsonasx_k;
+            return;
+        case nk_kernel_angulars_symmetric_k:
+            *m = (m_t)&nk_angulars_symmetric_u8_loongsonasx, *c = nk_cap_loongsonasx_k;
+            return;
+        case nk_kernel_euclideans_packed_k:
+            *m = (m_t)&nk_euclideans_packed_u8_loongsonasx, *c = nk_cap_loongsonasx_k;
+            return;
+        case nk_kernel_euclideans_symmetric_k:
+            *m = (m_t)&nk_euclideans_symmetric_u8_loongsonasx, *c = nk_cap_loongsonasx_k;
+            return;
+        default: break;
+        }
+#endif
 #if NK_TARGET_RVV
     if (v & nk_cap_rvv_k) switch (k) {
         case nk_kernel_dot_k: *m = (m_t)&nk_dot_u8_rvv, *c = nk_cap_rvv_k; return;

package/c/numkong.c

@@ -842,6 +842,9 @@ NK_DYNAMIC nk_capability_t nk_capabilities(void) {
     return static_capabilities;
 }
 
+NK_DYNAMIC nk_capability_t nk_capabilities_available(void) { return nk_capabilities() & nk_capabilities_compiled_(); }
+NK_DYNAMIC nk_capability_t nk_capabilities_compiled(void) { return nk_capabilities_compiled_(); }
+
 NK_DYNAMIC void nk_find_kernel_punned( //
     nk_kernel_kind_t kind,             //
     nk_dtype_t dtype,                  //

package/include/README.md

@@ -25,7 +25,7 @@ int main(void) {
 
 ## Highlights
 
-This is the most complete SDK in the project.
+This is the primary SDK in the project.
 It is the right layer if you want exact control over dtypes, allocators, packed buffers, dispatch, and host-side partitioning.
 
 __Full kernel surface.__
@@ -167,6 +167,20 @@ For example, `f32_t::dot_result_t` is wider than `f32_t`.
 The higher-level templates use `result_type_ = typename in_type_::dot_result_t` and similar defaults.
 The fast typed overloads are constrained so that overriding the result type away from the native policy can disable the specialized path and fall back to the more generic one.
 
+When `__cpp_lib_format >= 202110L` for the C++23 `<format>` header support, all NumKong scalar types provide `std::formatter` specializations with similar format specs to the traditional `float`.
+For the BFloat16 type, the output for `nk::f16_t::from_f32(3.14f)` will look like:
+
+| Format spec | Output example       | Description                            |
+| ----------- | -------------------- | -------------------------------------- |
+| `{}`        | `3.140625`           | Clean float value                      |
+| `{:#}`      | `3.140625 [0x4248]`  | Annotated with hex bits                |
+| `{:.2f}`    | `3.14`               | Precision forwarded to float formatter |
+| `{:x}`      | `4248`               | Raw hex bits                           |
+| `{:#x}`     | `0x4248`             | Hex with prefix                        |
+| `{:X}`      | `4248`               | Uppercase hex                          |
+| `{:b}`      | `0100001001001000`   | Binary bits                            |
+| `{:#b}`     | `0b0100001001001000` | Binary with prefix                     |
+
 ## Dot Products
 
 Dot products are one of the broadest parts of the native SDK.
@@ -243,7 +257,7 @@ nk_jsd_f32(q, p, 3, &js_reverse);
 assert(js_forward == js_reverse && "JSD is symmetric");
 ```
 
-These paths are especially valuable once you move below `f64`.
+These paths are useful once you move below `f64`.
 Naive implementations are usually dominated by repeated scalar transcendental calls and weak accumulation policy.
 
 ## Geospatial Metrics
@@ -365,9 +379,44 @@ nk::f64_t dot {};
 nk::dot(view.row(0), view.row(1), md.extent(1), &dot);
 ```
 
+## Iterators and Enumeration
+
+NumKong containers expose random-access iterators for element and row traversal.
+
+- __`dim_iterator`__ — random-access iterator over element values, used by `vector`, `vector_view`, and `vector_span`.
+  Supports all standard iterator operations plus `index()` to retrieve the current position.
+- __`axis_iterator`__ — random-access iterator over sub-views (rows), used by `tensor_view` and `tensor_span`.
+  Also exposes `index()`.
+- __`enumerate()`__ — free function returning a lightweight view that yields `{index, value}` pairs from any container with `begin()`/`end()`/`size()`.
+
+```cpp
+#include <numkong/numkong.hpp>
+
+namespace nk = ashvardanian::numkong;
+
+nk::vector<nk::f16_t> v(128);
+for (auto [i, val] : nk::enumerate(v))
+    std::printf("[%zu] = %f\n", i, val.to_f32());
+
+// index() on raw iterators
+for (auto it = v.begin(); it != v.end(); ++it)
+    std::printf("[%zu] = %f\n", it.index(), (*it).to_f32());
+```
+
+Since `tensor.hpp` includes `vector.hpp`, `enumerate()` works on tensor row views too.
+
+Tensors also support range-for over all logical scalar elements, yielding `(position, value)` pairs.
+For sub-byte types each dimension is a logical scalar. Use `.dims()` to iterate values without positions.
+
+```cpp
+for (auto [pos, val] : matrix)          { /* pos is std::array<size_t, R> */ }
+for (auto [pos, ref] : matrix.span())   { ref = nk::f32_t{1}; }
+for (auto val : matrix.dims())          { /* scalar only, no position */ }
+```
+
 ## Packed Matrix Kernels for GEMM-Like Workloads
 
-This is the most distinctive native subsystem outside the raw vector kernels.
+This is a separate native subsystem from the raw vector kernels.
 It is the right tool when the right-hand side is reused many times.
 
 ```cpp
@@ -414,7 +463,7 @@ This is SYRK-like in the sense that the output is square and symmetric.
 The important difference from packed GEMM-style work is the partitioning model.
 You typically split by output row windows, not by distinct left batches against a shared packed right-hand side.
 
-The arithmetic advantage is direct and honest.
+The arithmetic advantage is straightforward.
 The symmetric kernels avoid recomputing both `(i, j)` and `(j, i)` pairs.
 That cuts the pair count almost in half before any micro-kernel details matter.
 
@@ -479,8 +528,8 @@ Its footprint is exposed through `size_bytes()`.
 ## Runtime Dispatch and Capabilities
 
 Dynamic dispatch is the default recommendation for shipping one binary across many CPU generations.
-`nk_configure_thread` configures rounding behavior and enables CPU-specific acceleration features such as Intel AMX.
-It must be called once per thread before any kernel invocation and returns 1 on success, 0 on failure.
+`nk_configure_thread` enables CPU-specific acceleration features such as Intel AMX.
+It must be called once per thread before using AMX operations and returns 1 on success, 0 on failure.
 
 ```c
 nk_capability_t caps = nk_capabilities();
@@ -491,7 +540,7 @@ if (caps & nk_cap_sapphireamx_k) { /* AMX available */ }
 For exact register-level details, see `capabilities.h`.
 The C++ wrappers can also call directly into named backends if you want to pin a path for testing or benchmarking.
 
-## Parallelism and Fork Union
+## Parallelism and ForkUnion
 
 NumKong does not manage its own threads.
 That is deliberate.
@@ -521,7 +570,7 @@ fork_union.parallel_for(0, worker_count, [&](std::size_t t) {
 });
 ```
 
-We recommend [Fork Union](https://github.com/ashvardanian/ForkUnion) for that host-side orchestration.
+We recommend [ForkUnion](https://github.com/ashvardanian/ForkUnion) for that host-side orchestration.
 OpenMP is still a reasonable fit if the rest of your application already uses it.
 Manual thread pools and task systems also work well because the kernels have explicit row-range interfaces.
 
@@ -570,4 +619,25 @@ cmake -B build -D CMAKE_TOOLCHAIN_FILE=cmake/toolchain-aarch64-gnu.cmake
 
 NumKong does not use OpenMP and does not create a hidden thread pool.
 Standard pthreads are linked via CMake's `Threads` package.
-Parallelism is host-controlled: partition work across row ranges and dispatch through Fork Union, `std::thread`, or any external scheduler.
+Parallelism is host-controlled: partition work across row ranges and dispatch through ForkUnion, `std::thread`, or any external scheduler.
+
+## Addressing External Memory
+
+Every kernel takes plain pointers, so any CPU-accessible memory works: mmap, pinned buffers, CUDA unified memory, custom arenas.
+C++ views wrap any pointer without ownership.
+Owning containers accept any C++ Allocator.
+
+```cpp
+template <typename T>
+struct cuda_allocator {
+    using value_type = T;
+    T *allocate(std::size_t n) { T *p;
+        cudaMallocManaged(&p, n * sizeof(T), cudaMemAttachGlobal); 
+        return p; }
+    void deallocate(T *p, std::size_t) noexcept { cudaFree(p); }
+};
+
+nk_dot_f32(cuda_managed_ptr, cuda_managed_ptr, 1024, &dot);         // C ABI, any pointer
+auto view = nk::tensor_view<nk::f32_t>(mmap_ptr, rows, cols);       // non-owning view
+auto v = nk::vector<float, cuda_allocator<float>>::try_zeros(1024); // allocator-aware owning
+```