numkong 7.0.0 → 7.4.1

package/include/numkong/mesh/haswell.h

@@ -8,12 +8,12 @@
  *
  *  @section haswell_mesh_instructions Key AVX2 Mesh Instructions
  *
- *      Intrinsic                   Instruction                     Latency     Throughput  Ports
- *      _mm256_fmadd_ps             VFMADD (YMM, YMM, YMM)          5cy         0.5/cy      p01
- *      _mm256_hadd_ps              VHADDPS (YMM, YMM, YMM)         7cy         0.5/cy      p01+p5
- *      _mm256_permute2f128_ps      VPERM2F128 (YMM, YMM, YMM, I8)  3cy         1/cy        p5
- *      _mm256_extractf128_ps       VEXTRACTF128 (XMM, YMM, I8)     3cy         1/cy        p5
- *      _mm256_i32gather_ps         VGATHERDPS (YMM, M, YMM, YMM)   12cy        5/cy        p0+p23
+ *      Intrinsic               Instruction                     Haswell         Genoa
+ *      _mm256_fmadd_ps         VFMADD (YMM, YMM, YMM)          5cy @ p01       4cy @ p01
+ *      _mm256_hadd_ps          VHADDPS (YMM, YMM, YMM)         7cy @ p1+p5     4cy @ p123+p23+p23
+ *      _mm256_permute2f128_ps  VPERM2F128 (YMM, YMM, YMM, I8)  3cy @ p5        2cy @ p12
+ *      _mm256_extractf128_ps   VEXTRACTF128 (XMM, YMM, I8)     3cy @ p5        1cy @ p0123
+ *      _mm256_i32gather_ps     VGATHERDPS (YMM, M, YMM, YMM)   22cy (34 uops)  19cy (17 uops)
  *
  *  Point cloud operations (centroid, covariance, Kabsch alignment) use gather instructions for
  *  stride-3 xyz deinterleaving. Multiple FMA accumulators hide the 5-cycle FMA latency. VHADDPS
@@ -50,10 +50,10 @@ extern "C" {
  */
 NK_INTERNAL void nk_deinterleave_f32x8_haswell_(nk_f32_t const *ptr, __m256 *x_out, __m256 *y_out, __m256 *z_out) {
     // Gather indices: 0, 3, 6, 9, 12, 15, 18, 21 (stride 3)
-    __m256i idx = _mm256_setr_epi32(0, 3, 6, 9, 12, 15, 18, 21);
-    *x_out = _mm256_i32gather_ps(ptr + 0, idx, 4);
-    *y_out = _mm256_i32gather_ps(ptr + 1, idx, 4);
-    *z_out = _mm256_i32gather_ps(ptr + 2, idx, 4);
+    __m256i idx_i32x8 = _mm256_setr_epi32(0, 3, 6, 9, 12, 15, 18, 21);
+    *x_out = _mm256_i32gather_ps(ptr + 0, idx_i32x8, 4);
+    *y_out = _mm256_i32gather_ps(ptr + 1, idx_i32x8, 4);
+    *z_out = _mm256_i32gather_ps(ptr + 2, idx_i32x8, 4);
 }
 
 /*  Deinterleave 12 f64 values (4 xyz triplets) into separate x, y, z vectors.
@@ -134,84 +134,84 @@ NK_INTERNAL nk_f64_t nk_transformed_ssd_f32_haswell_(nk_f32_t const *a, nk_f32_t
         nk_deinterleave_f32x8_haswell_(a + index * 3, &a_x_f32x8, &a_y_f32x8, &a_z_f32x8),
             nk_deinterleave_f32x8_haswell_(b + index * 3, &b_x_f32x8, &b_y_f32x8, &b_z_f32x8);
 
-        __m256d a_x_lower_f64x4 = _mm256_cvtps_pd(_mm256_castps256_ps128(a_x_f32x8));
-        __m256d a_x_upper_f64x4 = _mm256_cvtps_pd(_mm256_extractf128_ps(a_x_f32x8, 1));
-        __m256d a_y_lower_f64x4 = _mm256_cvtps_pd(_mm256_castps256_ps128(a_y_f32x8));
-        __m256d a_y_upper_f64x4 = _mm256_cvtps_pd(_mm256_extractf128_ps(a_y_f32x8, 1));
-        __m256d a_z_lower_f64x4 = _mm256_cvtps_pd(_mm256_castps256_ps128(a_z_f32x8));
-        __m256d a_z_upper_f64x4 = _mm256_cvtps_pd(_mm256_extractf128_ps(a_z_f32x8, 1));
-        __m256d b_x_lower_f64x4 = _mm256_cvtps_pd(_mm256_castps256_ps128(b_x_f32x8));
-        __m256d b_x_upper_f64x4 = _mm256_cvtps_pd(_mm256_extractf128_ps(b_x_f32x8, 1));
-        __m256d b_y_lower_f64x4 = _mm256_cvtps_pd(_mm256_castps256_ps128(b_y_f32x8));
-        __m256d b_y_upper_f64x4 = _mm256_cvtps_pd(_mm256_extractf128_ps(b_y_f32x8, 1));
-        __m256d b_z_lower_f64x4 = _mm256_cvtps_pd(_mm256_castps256_ps128(b_z_f32x8));
-        __m256d b_z_upper_f64x4 = _mm256_cvtps_pd(_mm256_extractf128_ps(b_z_f32x8, 1));
-
-        __m256d centered_a_x_lower_f64x4 = _mm256_sub_pd(a_x_lower_f64x4, centroid_a_x_f64x4);
-        __m256d centered_a_x_upper_f64x4 = _mm256_sub_pd(a_x_upper_f64x4, centroid_a_x_f64x4);
-        __m256d centered_a_y_lower_f64x4 = _mm256_sub_pd(a_y_lower_f64x4, centroid_a_y_f64x4);
-        __m256d centered_a_y_upper_f64x4 = _mm256_sub_pd(a_y_upper_f64x4, centroid_a_y_f64x4);
-        __m256d centered_a_z_lower_f64x4 = _mm256_sub_pd(a_z_lower_f64x4, centroid_a_z_f64x4);
-        __m256d centered_a_z_upper_f64x4 = _mm256_sub_pd(a_z_upper_f64x4, centroid_a_z_f64x4);
-        __m256d centered_b_x_lower_f64x4 = _mm256_sub_pd(b_x_lower_f64x4, centroid_b_x_f64x4);
-        __m256d centered_b_x_upper_f64x4 = _mm256_sub_pd(b_x_upper_f64x4, centroid_b_x_f64x4);
-        __m256d centered_b_y_lower_f64x4 = _mm256_sub_pd(b_y_lower_f64x4, centroid_b_y_f64x4);
-        __m256d centered_b_y_upper_f64x4 = _mm256_sub_pd(b_y_upper_f64x4, centroid_b_y_f64x4);
-        __m256d centered_b_z_lower_f64x4 = _mm256_sub_pd(b_z_lower_f64x4, centroid_b_z_f64x4);
-        __m256d centered_b_z_upper_f64x4 = _mm256_sub_pd(b_z_upper_f64x4, centroid_b_z_f64x4);
-
-        __m256d rotated_a_x_lower_f64x4 = _mm256_fmadd_pd(
-            scaled_rotation_x_z_f64x4, centered_a_z_lower_f64x4,
-            _mm256_fmadd_pd(scaled_rotation_x_y_f64x4, centered_a_y_lower_f64x4,
-                            _mm256_mul_pd(scaled_rotation_x_x_f64x4, centered_a_x_lower_f64x4)));
-        __m256d rotated_a_x_upper_f64x4 = _mm256_fmadd_pd(
-            scaled_rotation_x_z_f64x4, centered_a_z_upper_f64x4,
-            _mm256_fmadd_pd(scaled_rotation_x_y_f64x4, centered_a_y_upper_f64x4,
-                            _mm256_mul_pd(scaled_rotation_x_x_f64x4, centered_a_x_upper_f64x4)));
-        __m256d rotated_a_y_lower_f64x4 = _mm256_fmadd_pd(
-            scaled_rotation_y_z_f64x4, centered_a_z_lower_f64x4,
-            _mm256_fmadd_pd(scaled_rotation_y_y_f64x4, centered_a_y_lower_f64x4,
-                            _mm256_mul_pd(scaled_rotation_y_x_f64x4, centered_a_x_lower_f64x4)));
-        __m256d rotated_a_y_upper_f64x4 = _mm256_fmadd_pd(
-            scaled_rotation_y_z_f64x4, centered_a_z_upper_f64x4,
-            _mm256_fmadd_pd(scaled_rotation_y_y_f64x4, centered_a_y_upper_f64x4,
-                            _mm256_mul_pd(scaled_rotation_y_x_f64x4, centered_a_x_upper_f64x4)));
-        __m256d rotated_a_z_lower_f64x4 = _mm256_fmadd_pd(
-            scaled_rotation_z_z_f64x4, centered_a_z_lower_f64x4,
-            _mm256_fmadd_pd(scaled_rotation_z_y_f64x4, centered_a_y_lower_f64x4,
-                            _mm256_mul_pd(scaled_rotation_z_x_f64x4, centered_a_x_lower_f64x4)));
-        __m256d rotated_a_z_upper_f64x4 = _mm256_fmadd_pd(
-            scaled_rotation_z_z_f64x4, centered_a_z_upper_f64x4,
-            _mm256_fmadd_pd(scaled_rotation_z_y_f64x4, centered_a_y_upper_f64x4,
-                            _mm256_mul_pd(scaled_rotation_z_x_f64x4, centered_a_x_upper_f64x4)));
-
-        __m256d delta_x_lower_f64x4 = _mm256_sub_pd(rotated_a_x_lower_f64x4, centered_b_x_lower_f64x4);
-        __m256d delta_x_upper_f64x4 = _mm256_sub_pd(rotated_a_x_upper_f64x4, centered_b_x_upper_f64x4);
-        __m256d delta_y_lower_f64x4 = _mm256_sub_pd(rotated_a_y_lower_f64x4, centered_b_y_lower_f64x4);
-        __m256d delta_y_upper_f64x4 = _mm256_sub_pd(rotated_a_y_upper_f64x4, centered_b_y_upper_f64x4);
-        __m256d delta_z_lower_f64x4 = _mm256_sub_pd(rotated_a_z_lower_f64x4, centered_b_z_lower_f64x4);
-        __m256d delta_z_upper_f64x4 = _mm256_sub_pd(rotated_a_z_upper_f64x4, centered_b_z_upper_f64x4);
-
-        __m256d batch_sum_squared_f64x4 = _mm256_add_pd(_mm256_mul_pd(delta_x_lower_f64x4, delta_x_lower_f64x4),
-                                                        _mm256_mul_pd(delta_x_upper_f64x4, delta_x_upper_f64x4));
-        batch_sum_squared_f64x4 = _mm256_fmadd_pd(delta_y_lower_f64x4, delta_y_lower_f64x4, batch_sum_squared_f64x4);
-        batch_sum_squared_f64x4 = _mm256_fmadd_pd(delta_y_upper_f64x4, delta_y_upper_f64x4, batch_sum_squared_f64x4);
-        batch_sum_squared_f64x4 = _mm256_fmadd_pd(delta_z_lower_f64x4, delta_z_lower_f64x4, batch_sum_squared_f64x4);
-        batch_sum_squared_f64x4 = _mm256_fmadd_pd(delta_z_upper_f64x4, delta_z_upper_f64x4, batch_sum_squared_f64x4);
+        __m256d a_x_low_f64x4 = _mm256_cvtps_pd(_mm256_castps256_ps128(a_x_f32x8));
+        __m256d a_x_high_f64x4 = _mm256_cvtps_pd(_mm256_extractf128_ps(a_x_f32x8, 1));
+        __m256d a_y_low_f64x4 = _mm256_cvtps_pd(_mm256_castps256_ps128(a_y_f32x8));
+        __m256d a_y_high_f64x4 = _mm256_cvtps_pd(_mm256_extractf128_ps(a_y_f32x8, 1));
+        __m256d a_z_low_f64x4 = _mm256_cvtps_pd(_mm256_castps256_ps128(a_z_f32x8));
+        __m256d a_z_high_f64x4 = _mm256_cvtps_pd(_mm256_extractf128_ps(a_z_f32x8, 1));
+        __m256d b_x_low_f64x4 = _mm256_cvtps_pd(_mm256_castps256_ps128(b_x_f32x8));
+        __m256d b_x_high_f64x4 = _mm256_cvtps_pd(_mm256_extractf128_ps(b_x_f32x8, 1));
+        __m256d b_y_low_f64x4 = _mm256_cvtps_pd(_mm256_castps256_ps128(b_y_f32x8));
+        __m256d b_y_high_f64x4 = _mm256_cvtps_pd(_mm256_extractf128_ps(b_y_f32x8, 1));
+        __m256d b_z_low_f64x4 = _mm256_cvtps_pd(_mm256_castps256_ps128(b_z_f32x8));
+        __m256d b_z_high_f64x4 = _mm256_cvtps_pd(_mm256_extractf128_ps(b_z_f32x8, 1));
+
+        __m256d centered_a_x_low_f64x4 = _mm256_sub_pd(a_x_low_f64x4, centroid_a_x_f64x4);
+        __m256d centered_a_x_high_f64x4 = _mm256_sub_pd(a_x_high_f64x4, centroid_a_x_f64x4);
+        __m256d centered_a_y_low_f64x4 = _mm256_sub_pd(a_y_low_f64x4, centroid_a_y_f64x4);
+        __m256d centered_a_y_high_f64x4 = _mm256_sub_pd(a_y_high_f64x4, centroid_a_y_f64x4);
+        __m256d centered_a_z_low_f64x4 = _mm256_sub_pd(a_z_low_f64x4, centroid_a_z_f64x4);
+        __m256d centered_a_z_high_f64x4 = _mm256_sub_pd(a_z_high_f64x4, centroid_a_z_f64x4);
+        __m256d centered_b_x_low_f64x4 = _mm256_sub_pd(b_x_low_f64x4, centroid_b_x_f64x4);
+        __m256d centered_b_x_high_f64x4 = _mm256_sub_pd(b_x_high_f64x4, centroid_b_x_f64x4);
+        __m256d centered_b_y_low_f64x4 = _mm256_sub_pd(b_y_low_f64x4, centroid_b_y_f64x4);
+        __m256d centered_b_y_high_f64x4 = _mm256_sub_pd(b_y_high_f64x4, centroid_b_y_f64x4);
+        __m256d centered_b_z_low_f64x4 = _mm256_sub_pd(b_z_low_f64x4, centroid_b_z_f64x4);
+        __m256d centered_b_z_high_f64x4 = _mm256_sub_pd(b_z_high_f64x4, centroid_b_z_f64x4);
+
+        __m256d rotated_a_x_low_f64x4 = _mm256_fmadd_pd(
+            scaled_rotation_x_z_f64x4, centered_a_z_low_f64x4,
+            _mm256_fmadd_pd(scaled_rotation_x_y_f64x4, centered_a_y_low_f64x4,
+                            _mm256_mul_pd(scaled_rotation_x_x_f64x4, centered_a_x_low_f64x4)));
+        __m256d rotated_a_x_high_f64x4 = _mm256_fmadd_pd(
+            scaled_rotation_x_z_f64x4, centered_a_z_high_f64x4,
+            _mm256_fmadd_pd(scaled_rotation_x_y_f64x4, centered_a_y_high_f64x4,
+                            _mm256_mul_pd(scaled_rotation_x_x_f64x4, centered_a_x_high_f64x4)));
+        __m256d rotated_a_y_low_f64x4 = _mm256_fmadd_pd(
+            scaled_rotation_y_z_f64x4, centered_a_z_low_f64x4,
+            _mm256_fmadd_pd(scaled_rotation_y_y_f64x4, centered_a_y_low_f64x4,
+                            _mm256_mul_pd(scaled_rotation_y_x_f64x4, centered_a_x_low_f64x4)));
+        __m256d rotated_a_y_high_f64x4 = _mm256_fmadd_pd(
+            scaled_rotation_y_z_f64x4, centered_a_z_high_f64x4,
+            _mm256_fmadd_pd(scaled_rotation_y_y_f64x4, centered_a_y_high_f64x4,
+                            _mm256_mul_pd(scaled_rotation_y_x_f64x4, centered_a_x_high_f64x4)));
+        __m256d rotated_a_z_low_f64x4 = _mm256_fmadd_pd(
+            scaled_rotation_z_z_f64x4, centered_a_z_low_f64x4,
+            _mm256_fmadd_pd(scaled_rotation_z_y_f64x4, centered_a_y_low_f64x4,
+                            _mm256_mul_pd(scaled_rotation_z_x_f64x4, centered_a_x_low_f64x4)));
+        __m256d rotated_a_z_high_f64x4 = _mm256_fmadd_pd(
+            scaled_rotation_z_z_f64x4, centered_a_z_high_f64x4,
+            _mm256_fmadd_pd(scaled_rotation_z_y_f64x4, centered_a_y_high_f64x4,
+                            _mm256_mul_pd(scaled_rotation_z_x_f64x4, centered_a_x_high_f64x4)));
+
+        __m256d delta_x_low_f64x4 = _mm256_sub_pd(rotated_a_x_low_f64x4, centered_b_x_low_f64x4);
+        __m256d delta_x_high_f64x4 = _mm256_sub_pd(rotated_a_x_high_f64x4, centered_b_x_high_f64x4);
+        __m256d delta_y_low_f64x4 = _mm256_sub_pd(rotated_a_y_low_f64x4, centered_b_y_low_f64x4);
+        __m256d delta_y_high_f64x4 = _mm256_sub_pd(rotated_a_y_high_f64x4, centered_b_y_high_f64x4);
+        __m256d delta_z_low_f64x4 = _mm256_sub_pd(rotated_a_z_low_f64x4, centered_b_z_low_f64x4);
+        __m256d delta_z_high_f64x4 = _mm256_sub_pd(rotated_a_z_high_f64x4, centered_b_z_high_f64x4);
+
+        __m256d batch_sum_squared_f64x4 = _mm256_add_pd(_mm256_mul_pd(delta_x_low_f64x4, delta_x_low_f64x4),
+                                                        _mm256_mul_pd(delta_x_high_f64x4, delta_x_high_f64x4));
+        batch_sum_squared_f64x4 = _mm256_fmadd_pd(delta_y_low_f64x4, delta_y_low_f64x4, batch_sum_squared_f64x4);
+        batch_sum_squared_f64x4 = _mm256_fmadd_pd(delta_y_high_f64x4, delta_y_high_f64x4, batch_sum_squared_f64x4);
+        batch_sum_squared_f64x4 = _mm256_fmadd_pd(delta_z_low_f64x4, delta_z_low_f64x4, batch_sum_squared_f64x4);
+        batch_sum_squared_f64x4 = _mm256_fmadd_pd(delta_z_high_f64x4, delta_z_high_f64x4, batch_sum_squared_f64x4);
         sum_squared_f64x4 = _mm256_add_pd(sum_squared_f64x4, batch_sum_squared_f64x4);
     }
 
     nk_f64_t sum_squared = nk_reduce_add_f64x4_haswell_(sum_squared_f64x4);
     for (; index < n; ++index) {
-        nk_f64_t centered_a_x = (nk_f64_t)a[index * 3 + 0] - centroid_a_x;
-        nk_f64_t centered_a_y = (nk_f64_t)a[index * 3 + 1] - centroid_a_y;
-        nk_f64_t centered_a_z = (nk_f64_t)a[index * 3 + 2] - centroid_a_z;
-        nk_f64_t centered_b_x = (nk_f64_t)b[index * 3 + 0] - centroid_b_x;
-        nk_f64_t centered_b_y = (nk_f64_t)b[index * 3 + 1] - centroid_b_y;
-        nk_f64_t centered_b_z = (nk_f64_t)b[index * 3 + 2] - centroid_b_z;
-        nk_f64_t rotated_a_x = scale * (r[0] * centered_a_x + r[1] * centered_a_y + r[2] * centered_a_z);
-        nk_f64_t rotated_a_y = scale * (r[3] * centered_a_x + r[4] * centered_a_y + r[5] * centered_a_z);
-        nk_f64_t rotated_a_z = scale * (r[6] * centered_a_x + r[7] * centered_a_y + r[8] * centered_a_z);
+        nk_f64_t centered_a_x = (nk_f64_t)a[index * 3 + 0] - centroid_a_x,
+                 centered_a_y = (nk_f64_t)a[index * 3 + 1] - centroid_a_y,
+                 centered_a_z = (nk_f64_t)a[index * 3 + 2] - centroid_a_z;
+        nk_f64_t centered_b_x = (nk_f64_t)b[index * 3 + 0] - centroid_b_x,
+                 centered_b_y = (nk_f64_t)b[index * 3 + 1] - centroid_b_y,
+                 centered_b_z = (nk_f64_t)b[index * 3 + 2] - centroid_b_z;
+        nk_f64_t rotated_a_x = scale * (r[0] * centered_a_x + r[1] * centered_a_y + r[2] * centered_a_z),
+                 rotated_a_y = scale * (r[3] * centered_a_x + r[4] * centered_a_y + r[5] * centered_a_z),
+                 rotated_a_z = scale * (r[6] * centered_a_x + r[7] * centered_a_y + r[8] * centered_a_z);
         nk_f64_t delta_x = rotated_a_x - centered_b_x, delta_y = rotated_a_y - centered_b_y,
                  delta_z = rotated_a_z - centered_b_z;
         sum_squared += delta_x * delta_x + delta_y * delta_y + delta_z * delta_z;
@@ -290,20 +290,15 @@ NK_INTERNAL nk_f64_t nk_transformed_ssd_f64_haswell_(nk_f64_t const *a, nk_f64_t
 
     // Scalar tail
     for (; j < n; ++j) {
-        nk_f64_t pa_x = a[j * 3 + 0] - centroid_a_x;
-        nk_f64_t pa_y = a[j * 3 + 1] - centroid_a_y;
-        nk_f64_t pa_z = a[j * 3 + 2] - centroid_a_z;
-        nk_f64_t pb_x = b[j * 3 + 0] - centroid_b_x;
-        nk_f64_t pb_y = b[j * 3 + 1] - centroid_b_y;
-        nk_f64_t pb_z = b[j * 3 + 2] - centroid_b_z;
-
-        nk_f64_t ra_x = scale * (r[0] * pa_x + r[1] * pa_y + r[2] * pa_z);
-        nk_f64_t ra_y = scale * (r[3] * pa_x + r[4] * pa_y + r[5] * pa_z);
-        nk_f64_t ra_z = scale * (r[6] * pa_x + r[7] * pa_y + r[8] * pa_z);
-
-        nk_f64_t delta_x = ra_x - pb_x;
-        nk_f64_t delta_y = ra_y - pb_y;
-        nk_f64_t delta_z = ra_z - pb_z;
+        nk_f64_t pa_x = a[j * 3 + 0] - centroid_a_x, pa_y = a[j * 3 + 1] - centroid_a_y,
+                 pa_z = a[j * 3 + 2] - centroid_a_z;
+        nk_f64_t pb_x = b[j * 3 + 0] - centroid_b_x, pb_y = b[j * 3 + 1] - centroid_b_y,
+                 pb_z = b[j * 3 + 2] - centroid_b_z;
+        nk_f64_t ra_x = scale * (r[0] * pa_x + r[1] * pa_y + r[2] * pa_z),
+                 ra_y = scale * (r[3] * pa_x + r[4] * pa_y + r[5] * pa_z),
+                 ra_z = scale * (r[6] * pa_x + r[7] * pa_y + r[8] * pa_z);
+
+        nk_f64_t delta_x = ra_x - pb_x, delta_y = ra_y - pb_y, delta_z = ra_z - pb_z;
         nk_accumulate_square_f64_(&sum_squared, &sum_squared_compensation, delta_x);
         nk_accumulate_square_f64_(&sum_squared, &sum_squared_compensation, delta_y);
         nk_accumulate_square_f64_(&sum_squared, &sum_squared_compensation, delta_z);
@@ -330,38 +325,38 @@ NK_PUBLIC void nk_rmsd_f32_haswell(nk_f32_t const *a, nk_f32_t const *b, nk_size
         nk_deinterleave_f32x8_haswell_(a + index * 3, &a_x_f32x8, &a_y_f32x8, &a_z_f32x8),
             nk_deinterleave_f32x8_haswell_(b + index * 3, &b_x_f32x8, &b_y_f32x8, &b_z_f32x8);
 
-        __m256d a_x_lower_f64x4 = _mm256_cvtps_pd(_mm256_castps256_ps128(a_x_f32x8));
-        __m256d a_x_upper_f64x4 = _mm256_cvtps_pd(_mm256_extractf128_ps(a_x_f32x8, 1));
-        __m256d a_y_lower_f64x4 = _mm256_cvtps_pd(_mm256_castps256_ps128(a_y_f32x8));
-        __m256d a_y_upper_f64x4 = _mm256_cvtps_pd(_mm256_extractf128_ps(a_y_f32x8, 1));
-        __m256d a_z_lower_f64x4 = _mm256_cvtps_pd(_mm256_castps256_ps128(a_z_f32x8));
-        __m256d a_z_upper_f64x4 = _mm256_cvtps_pd(_mm256_extractf128_ps(a_z_f32x8, 1));
-        __m256d b_x_lower_f64x4 = _mm256_cvtps_pd(_mm256_castps256_ps128(b_x_f32x8));
-        __m256d b_x_upper_f64x4 = _mm256_cvtps_pd(_mm256_extractf128_ps(b_x_f32x8, 1));
-        __m256d b_y_lower_f64x4 = _mm256_cvtps_pd(_mm256_castps256_ps128(b_y_f32x8));
-        __m256d b_y_upper_f64x4 = _mm256_cvtps_pd(_mm256_extractf128_ps(b_y_f32x8, 1));
-        __m256d b_z_lower_f64x4 = _mm256_cvtps_pd(_mm256_castps256_ps128(b_z_f32x8));
-        __m256d b_z_upper_f64x4 = _mm256_cvtps_pd(_mm256_extractf128_ps(b_z_f32x8, 1));
-
-        sum_a_x_f64x4 = _mm256_add_pd(sum_a_x_f64x4, _mm256_add_pd(a_x_lower_f64x4, a_x_upper_f64x4));
-        sum_a_y_f64x4 = _mm256_add_pd(sum_a_y_f64x4, _mm256_add_pd(a_y_lower_f64x4, a_y_upper_f64x4));
-        sum_a_z_f64x4 = _mm256_add_pd(sum_a_z_f64x4, _mm256_add_pd(a_z_lower_f64x4, a_z_upper_f64x4));
-        sum_b_x_f64x4 = _mm256_add_pd(sum_b_x_f64x4, _mm256_add_pd(b_x_lower_f64x4, b_x_upper_f64x4));
-        sum_b_y_f64x4 = _mm256_add_pd(sum_b_y_f64x4, _mm256_add_pd(b_y_lower_f64x4, b_y_upper_f64x4));
-        sum_b_z_f64x4 = _mm256_add_pd(sum_b_z_f64x4, _mm256_add_pd(b_z_lower_f64x4, b_z_upper_f64x4));
-
-        __m256d delta_x_lower_f64x4 = _mm256_sub_pd(a_x_lower_f64x4, b_x_lower_f64x4);
-        __m256d delta_x_upper_f64x4 = _mm256_sub_pd(a_x_upper_f64x4, b_x_upper_f64x4);
-        __m256d delta_y_lower_f64x4 = _mm256_sub_pd(a_y_lower_f64x4, b_y_lower_f64x4);
-        __m256d delta_y_upper_f64x4 = _mm256_sub_pd(a_y_upper_f64x4, b_y_upper_f64x4);
-        __m256d delta_z_lower_f64x4 = _mm256_sub_pd(a_z_lower_f64x4, b_z_lower_f64x4);
-        __m256d delta_z_upper_f64x4 = _mm256_sub_pd(a_z_upper_f64x4, b_z_upper_f64x4);
-        __m256d batch_sum_squared_f64x4 = _mm256_add_pd(_mm256_mul_pd(delta_x_lower_f64x4, delta_x_lower_f64x4),
-                                                        _mm256_mul_pd(delta_x_upper_f64x4, delta_x_upper_f64x4));
-        batch_sum_squared_f64x4 = _mm256_fmadd_pd(delta_y_lower_f64x4, delta_y_lower_f64x4, batch_sum_squared_f64x4);
-        batch_sum_squared_f64x4 = _mm256_fmadd_pd(delta_y_upper_f64x4, delta_y_upper_f64x4, batch_sum_squared_f64x4);
-        batch_sum_squared_f64x4 = _mm256_fmadd_pd(delta_z_lower_f64x4, delta_z_lower_f64x4, batch_sum_squared_f64x4);
-        batch_sum_squared_f64x4 = _mm256_fmadd_pd(delta_z_upper_f64x4, delta_z_upper_f64x4, batch_sum_squared_f64x4);
+        __m256d a_x_low_f64x4 = _mm256_cvtps_pd(_mm256_castps256_ps128(a_x_f32x8));
+        __m256d a_x_high_f64x4 = _mm256_cvtps_pd(_mm256_extractf128_ps(a_x_f32x8, 1));
+        __m256d a_y_low_f64x4 = _mm256_cvtps_pd(_mm256_castps256_ps128(a_y_f32x8));
+        __m256d a_y_high_f64x4 = _mm256_cvtps_pd(_mm256_extractf128_ps(a_y_f32x8, 1));
+        __m256d a_z_low_f64x4 = _mm256_cvtps_pd(_mm256_castps256_ps128(a_z_f32x8));
+        __m256d a_z_high_f64x4 = _mm256_cvtps_pd(_mm256_extractf128_ps(a_z_f32x8, 1));
+        __m256d b_x_low_f64x4 = _mm256_cvtps_pd(_mm256_castps256_ps128(b_x_f32x8));
+        __m256d b_x_high_f64x4 = _mm256_cvtps_pd(_mm256_extractf128_ps(b_x_f32x8, 1));
+        __m256d b_y_low_f64x4 = _mm256_cvtps_pd(_mm256_castps256_ps128(b_y_f32x8));
+        __m256d b_y_high_f64x4 = _mm256_cvtps_pd(_mm256_extractf128_ps(b_y_f32x8, 1));
+        __m256d b_z_low_f64x4 = _mm256_cvtps_pd(_mm256_castps256_ps128(b_z_f32x8));
+        __m256d b_z_high_f64x4 = _mm256_cvtps_pd(_mm256_extractf128_ps(b_z_f32x8, 1));
+
+        sum_a_x_f64x4 = _mm256_add_pd(sum_a_x_f64x4, _mm256_add_pd(a_x_low_f64x4, a_x_high_f64x4));
+        sum_a_y_f64x4 = _mm256_add_pd(sum_a_y_f64x4, _mm256_add_pd(a_y_low_f64x4, a_y_high_f64x4));
+        sum_a_z_f64x4 = _mm256_add_pd(sum_a_z_f64x4, _mm256_add_pd(a_z_low_f64x4, a_z_high_f64x4));
+        sum_b_x_f64x4 = _mm256_add_pd(sum_b_x_f64x4, _mm256_add_pd(b_x_low_f64x4, b_x_high_f64x4));
+        sum_b_y_f64x4 = _mm256_add_pd(sum_b_y_f64x4, _mm256_add_pd(b_y_low_f64x4, b_y_high_f64x4));
+        sum_b_z_f64x4 = _mm256_add_pd(sum_b_z_f64x4, _mm256_add_pd(b_z_low_f64x4, b_z_high_f64x4));
+
+        __m256d delta_x_low_f64x4 = _mm256_sub_pd(a_x_low_f64x4, b_x_low_f64x4);
+        __m256d delta_x_high_f64x4 = _mm256_sub_pd(a_x_high_f64x4, b_x_high_f64x4);
+        __m256d delta_y_low_f64x4 = _mm256_sub_pd(a_y_low_f64x4, b_y_low_f64x4);
+        __m256d delta_y_high_f64x4 = _mm256_sub_pd(a_y_high_f64x4, b_y_high_f64x4);
+        __m256d delta_z_low_f64x4 = _mm256_sub_pd(a_z_low_f64x4, b_z_low_f64x4);
+        __m256d delta_z_high_f64x4 = _mm256_sub_pd(a_z_high_f64x4, b_z_high_f64x4);
+        __m256d batch_sum_squared_f64x4 = _mm256_add_pd(_mm256_mul_pd(delta_x_low_f64x4, delta_x_low_f64x4),
+                                                        _mm256_mul_pd(delta_x_high_f64x4, delta_x_high_f64x4));
+        batch_sum_squared_f64x4 = _mm256_fmadd_pd(delta_y_low_f64x4, delta_y_low_f64x4, batch_sum_squared_f64x4);
+        batch_sum_squared_f64x4 = _mm256_fmadd_pd(delta_y_high_f64x4, delta_y_high_f64x4, batch_sum_squared_f64x4);
+        batch_sum_squared_f64x4 = _mm256_fmadd_pd(delta_z_low_f64x4, delta_z_low_f64x4, batch_sum_squared_f64x4);
+        batch_sum_squared_f64x4 = _mm256_fmadd_pd(delta_z_high_f64x4, delta_z_high_f64x4, batch_sum_squared_f64x4);
         sum_squared_f64x4 = _mm256_add_pd(sum_squared_f64x4, batch_sum_squared_f64x4);
     }
 
@@ -401,12 +396,10 @@ NK_PUBLIC void nk_rmsd_f32_haswell(nk_f32_t const *a, nk_f32_t const *b, nk_size
 
 NK_PUBLIC void nk_rmsd_f64_haswell(nk_f64_t const *a, nk_f64_t const *b, nk_size_t n, nk_f64_t *a_centroid,
                                    nk_f64_t *b_centroid, nk_f64_t *rotation, nk_f64_t *scale, nk_f64_t *result) {
-    /* RMSD uses identity rotation and scale=1.0 */
-    if (rotation) {
-        rotation[0] = 1, rotation[1] = 0, rotation[2] = 0;
-        rotation[3] = 0, rotation[4] = 1, rotation[5] = 0;
+    // RMSD uses identity rotation and scale=1.0
+    if (rotation)
+        rotation[0] = 1, rotation[1] = 0, rotation[2] = 0, rotation[3] = 0, rotation[4] = 1, rotation[5] = 0,
         rotation[6] = 0, rotation[7] = 0, rotation[8] = 1;
-    }
     if (scale) *scale = 1.0;
     __m256d const zeros_f64x4 = _mm256_setzero_pd();
 
@@ -521,16 +514,8 @@ NK_PUBLIC void nk_rmsd_f64_haswell(nk_f64_t const *a, nk_f64_t const *b, nk_size
     nk_f64_t centroid_b_y = total_by * inv_n;
     nk_f64_t centroid_b_z = total_bz * inv_n;
 
-    if (a_centroid) {
-        a_centroid[0] = centroid_a_x;
-        a_centroid[1] = centroid_a_y;
-        a_centroid[2] = centroid_a_z;
-    }
-    if (b_centroid) {
-        b_centroid[0] = centroid_b_x;
-        b_centroid[1] = centroid_b_y;
-        b_centroid[2] = centroid_b_z;
-    }
+    if (a_centroid) a_centroid[0] = centroid_a_x, a_centroid[1] = centroid_a_y, a_centroid[2] = centroid_a_z;
+    if (b_centroid) b_centroid[0] = centroid_b_x, b_centroid[1] = centroid_b_y, b_centroid[2] = centroid_b_z;
 
     // Compute RMSD
     nk_f64_t mean_diff_x = centroid_a_x - centroid_b_x;
@@ -559,53 +544,53 @@ NK_PUBLIC void nk_kabsch_f32_haswell(nk_f32_t const *a, nk_f32_t const *b, nk_si
     for (; index + 8 <= n; index += 8) {
         nk_deinterleave_f32x8_haswell_(a + index * 3, &a_x_f32x8, &a_y_f32x8, &a_z_f32x8),
             nk_deinterleave_f32x8_haswell_(b + index * 3, &b_x_f32x8, &b_y_f32x8, &b_z_f32x8);
-        __m256d a_x_lower_f64x4 = _mm256_cvtps_pd(_mm256_castps256_ps128(a_x_f32x8));
-        __m256d a_x_upper_f64x4 = _mm256_cvtps_pd(_mm256_extractf128_ps(a_x_f32x8, 1));
-        __m256d a_y_lower_f64x4 = _mm256_cvtps_pd(_mm256_castps256_ps128(a_y_f32x8));
-        __m256d a_y_upper_f64x4 = _mm256_cvtps_pd(_mm256_extractf128_ps(a_y_f32x8, 1));
-        __m256d a_z_lower_f64x4 = _mm256_cvtps_pd(_mm256_castps256_ps128(a_z_f32x8));
-        __m256d a_z_upper_f64x4 = _mm256_cvtps_pd(_mm256_extractf128_ps(a_z_f32x8, 1));
-        __m256d b_x_lower_f64x4 = _mm256_cvtps_pd(_mm256_castps256_ps128(b_x_f32x8));
-        __m256d b_x_upper_f64x4 = _mm256_cvtps_pd(_mm256_extractf128_ps(b_x_f32x8, 1));
-        __m256d b_y_lower_f64x4 = _mm256_cvtps_pd(_mm256_castps256_ps128(b_y_f32x8));
-        __m256d b_y_upper_f64x4 = _mm256_cvtps_pd(_mm256_extractf128_ps(b_y_f32x8, 1));
-        __m256d b_z_lower_f64x4 = _mm256_cvtps_pd(_mm256_castps256_ps128(b_z_f32x8));
-        __m256d b_z_upper_f64x4 = _mm256_cvtps_pd(_mm256_extractf128_ps(b_z_f32x8, 1));
-
-        sum_a_x_f64x4 = _mm256_add_pd(sum_a_x_f64x4, _mm256_add_pd(a_x_lower_f64x4, a_x_upper_f64x4));
-        sum_a_y_f64x4 = _mm256_add_pd(sum_a_y_f64x4, _mm256_add_pd(a_y_lower_f64x4, a_y_upper_f64x4));
-        sum_a_z_f64x4 = _mm256_add_pd(sum_a_z_f64x4, _mm256_add_pd(a_z_lower_f64x4, a_z_upper_f64x4));
-        sum_b_x_f64x4 = _mm256_add_pd(sum_b_x_f64x4, _mm256_add_pd(b_x_lower_f64x4, b_x_upper_f64x4));
-        sum_b_y_f64x4 = _mm256_add_pd(sum_b_y_f64x4, _mm256_add_pd(b_y_lower_f64x4, b_y_upper_f64x4));
-        sum_b_z_f64x4 = _mm256_add_pd(sum_b_z_f64x4, _mm256_add_pd(b_z_lower_f64x4, b_z_upper_f64x4));
-
-        covariance_00_f64x4 = _mm256_add_pd(covariance_00_f64x4,
-                                            _mm256_add_pd(_mm256_mul_pd(a_x_lower_f64x4, b_x_lower_f64x4),
-                                                          _mm256_mul_pd(a_x_upper_f64x4, b_x_upper_f64x4)));
-        covariance_01_f64x4 = _mm256_add_pd(covariance_01_f64x4,
-                                            _mm256_add_pd(_mm256_mul_pd(a_x_lower_f64x4, b_y_lower_f64x4),
-                                                          _mm256_mul_pd(a_x_upper_f64x4, b_y_upper_f64x4)));
-        covariance_02_f64x4 = _mm256_add_pd(covariance_02_f64x4,
-                                            _mm256_add_pd(_mm256_mul_pd(a_x_lower_f64x4, b_z_lower_f64x4),
-                                                          _mm256_mul_pd(a_x_upper_f64x4, b_z_upper_f64x4)));
-        covariance_10_f64x4 = _mm256_add_pd(covariance_10_f64x4,
-                                            _mm256_add_pd(_mm256_mul_pd(a_y_lower_f64x4, b_x_lower_f64x4),
-                                                          _mm256_mul_pd(a_y_upper_f64x4, b_x_upper_f64x4)));
-        covariance_11_f64x4 = _mm256_add_pd(covariance_11_f64x4,
-                                            _mm256_add_pd(_mm256_mul_pd(a_y_lower_f64x4, b_y_lower_f64x4),
-                                                          _mm256_mul_pd(a_y_upper_f64x4, b_y_upper_f64x4)));
-        covariance_12_f64x4 = _mm256_add_pd(covariance_12_f64x4,
-                                            _mm256_add_pd(_mm256_mul_pd(a_y_lower_f64x4, b_z_lower_f64x4),
-                                                          _mm256_mul_pd(a_y_upper_f64x4, b_z_upper_f64x4)));
-        covariance_20_f64x4 = _mm256_add_pd(covariance_20_f64x4,
-                                            _mm256_add_pd(_mm256_mul_pd(a_z_lower_f64x4, b_x_lower_f64x4),
-                                                          _mm256_mul_pd(a_z_upper_f64x4, b_x_upper_f64x4)));
-        covariance_21_f64x4 = _mm256_add_pd(covariance_21_f64x4,
-                                            _mm256_add_pd(_mm256_mul_pd(a_z_lower_f64x4, b_y_lower_f64x4),
-                                                          _mm256_mul_pd(a_z_upper_f64x4, b_y_upper_f64x4)));
-        covariance_22_f64x4 = _mm256_add_pd(covariance_22_f64x4,
-                                            _mm256_add_pd(_mm256_mul_pd(a_z_lower_f64x4, b_z_lower_f64x4),
-                                                          _mm256_mul_pd(a_z_upper_f64x4, b_z_upper_f64x4)));
+        __m256d a_x_low_f64x4 = _mm256_cvtps_pd(_mm256_castps256_ps128(a_x_f32x8));
+        __m256d a_x_high_f64x4 = _mm256_cvtps_pd(_mm256_extractf128_ps(a_x_f32x8, 1));
+        __m256d a_y_low_f64x4 = _mm256_cvtps_pd(_mm256_castps256_ps128(a_y_f32x8));
+        __m256d a_y_high_f64x4 = _mm256_cvtps_pd(_mm256_extractf128_ps(a_y_f32x8, 1));
+        __m256d a_z_low_f64x4 = _mm256_cvtps_pd(_mm256_castps256_ps128(a_z_f32x8));
+        __m256d a_z_high_f64x4 = _mm256_cvtps_pd(_mm256_extractf128_ps(a_z_f32x8, 1));
+        __m256d b_x_low_f64x4 = _mm256_cvtps_pd(_mm256_castps256_ps128(b_x_f32x8));
+        __m256d b_x_high_f64x4 = _mm256_cvtps_pd(_mm256_extractf128_ps(b_x_f32x8, 1));
+        __m256d b_y_low_f64x4 = _mm256_cvtps_pd(_mm256_castps256_ps128(b_y_f32x8));
+        __m256d b_y_high_f64x4 = _mm256_cvtps_pd(_mm256_extractf128_ps(b_y_f32x8, 1));
+        __m256d b_z_low_f64x4 = _mm256_cvtps_pd(_mm256_castps256_ps128(b_z_f32x8));
+        __m256d b_z_high_f64x4 = _mm256_cvtps_pd(_mm256_extractf128_ps(b_z_f32x8, 1));
+
+        sum_a_x_f64x4 = _mm256_add_pd(sum_a_x_f64x4, _mm256_add_pd(a_x_low_f64x4, a_x_high_f64x4));
+        sum_a_y_f64x4 = _mm256_add_pd(sum_a_y_f64x4, _mm256_add_pd(a_y_low_f64x4, a_y_high_f64x4));
+        sum_a_z_f64x4 = _mm256_add_pd(sum_a_z_f64x4, _mm256_add_pd(a_z_low_f64x4, a_z_high_f64x4));
+        sum_b_x_f64x4 = _mm256_add_pd(sum_b_x_f64x4, _mm256_add_pd(b_x_low_f64x4, b_x_high_f64x4));
+        sum_b_y_f64x4 = _mm256_add_pd(sum_b_y_f64x4, _mm256_add_pd(b_y_low_f64x4, b_y_high_f64x4));
+        sum_b_z_f64x4 = _mm256_add_pd(sum_b_z_f64x4, _mm256_add_pd(b_z_low_f64x4, b_z_high_f64x4));
+
+        covariance_00_f64x4 = _mm256_add_pd(
+            covariance_00_f64x4,
+            _mm256_add_pd(_mm256_mul_pd(a_x_low_f64x4, b_x_low_f64x4), _mm256_mul_pd(a_x_high_f64x4, b_x_high_f64x4)));
+        covariance_01_f64x4 = _mm256_add_pd(
+            covariance_01_f64x4,
+            _mm256_add_pd(_mm256_mul_pd(a_x_low_f64x4, b_y_low_f64x4), _mm256_mul_pd(a_x_high_f64x4, b_y_high_f64x4)));
+        covariance_02_f64x4 = _mm256_add_pd(
+            covariance_02_f64x4,
+            _mm256_add_pd(_mm256_mul_pd(a_x_low_f64x4, b_z_low_f64x4), _mm256_mul_pd(a_x_high_f64x4, b_z_high_f64x4)));
+        covariance_10_f64x4 = _mm256_add_pd(
+            covariance_10_f64x4,
+            _mm256_add_pd(_mm256_mul_pd(a_y_low_f64x4, b_x_low_f64x4), _mm256_mul_pd(a_y_high_f64x4, b_x_high_f64x4)));
+        covariance_11_f64x4 = _mm256_add_pd(
+            covariance_11_f64x4,
+            _mm256_add_pd(_mm256_mul_pd(a_y_low_f64x4, b_y_low_f64x4), _mm256_mul_pd(a_y_high_f64x4, b_y_high_f64x4)));
+        covariance_12_f64x4 = _mm256_add_pd(
+            covariance_12_f64x4,
+            _mm256_add_pd(_mm256_mul_pd(a_y_low_f64x4, b_z_low_f64x4), _mm256_mul_pd(a_y_high_f64x4, b_z_high_f64x4)));
+        covariance_20_f64x4 = _mm256_add_pd(
+            covariance_20_f64x4,
+            _mm256_add_pd(_mm256_mul_pd(a_z_low_f64x4, b_x_low_f64x4), _mm256_mul_pd(a_z_high_f64x4, b_x_high_f64x4)));
+        covariance_21_f64x4 = _mm256_add_pd(
+            covariance_21_f64x4,
+            _mm256_add_pd(_mm256_mul_pd(a_z_low_f64x4, b_y_low_f64x4), _mm256_mul_pd(a_z_high_f64x4, b_y_high_f64x4)));
+        covariance_22_f64x4 = _mm256_add_pd(
+            covariance_22_f64x4,
+            _mm256_add_pd(_mm256_mul_pd(a_z_low_f64x4, b_z_low_f64x4), _mm256_mul_pd(a_z_high_f64x4, b_z_high_f64x4)));
     }
 
     nk_f64_t sum_a_x = nk_reduce_add_f64x4_haswell_(sum_a_x_f64x4);
@@ -775,27 +760,19 @@ NK_PUBLIC void nk_kabsch_f64_haswell(nk_f64_t const *a, nk_f64_t const *b, nk_si
     nk_f64_t centroid_b_y = sum_b_y * inv_n;
     nk_f64_t centroid_b_z = sum_b_z * inv_n;
 
-    if (a_centroid) {
-        a_centroid[0] = centroid_a_x;
-        a_centroid[1] = centroid_a_y;
-        a_centroid[2] = centroid_a_z;
-    }
-    if (b_centroid) {
-        b_centroid[0] = centroid_b_x;
-        b_centroid[1] = centroid_b_y;
-        b_centroid[2] = centroid_b_z;
-    }
+    if (a_centroid) a_centroid[0] = centroid_a_x, a_centroid[1] = centroid_a_y, a_centroid[2] = centroid_a_z;
+    if (b_centroid) b_centroid[0] = centroid_b_x, b_centroid[1] = centroid_b_y, b_centroid[2] = centroid_b_z;
 
     // Apply centering correction: H_centered = H - n * centroid_a * centroid_bᵀ
-    covariance_x_x -= n * centroid_a_x * centroid_b_x;
-    covariance_x_y -= n * centroid_a_x * centroid_b_y;
-    covariance_x_z -= n * centroid_a_x * centroid_b_z;
-    covariance_y_x -= n * centroid_a_y * centroid_b_x;
-    covariance_y_y -= n * centroid_a_y * centroid_b_y;
-    covariance_y_z -= n * centroid_a_y * centroid_b_z;
-    covariance_z_x -= n * centroid_a_z * centroid_b_x;
-    covariance_z_y -= n * centroid_a_z * centroid_b_y;
-    covariance_z_z -= n * centroid_a_z * centroid_b_z;
+    covariance_x_x -= (nk_f64_t)n * centroid_a_x * centroid_b_x;
+    covariance_x_y -= (nk_f64_t)n * centroid_a_x * centroid_b_y;
+    covariance_x_z -= (nk_f64_t)n * centroid_a_x * centroid_b_z;
+    covariance_y_x -= (nk_f64_t)n * centroid_a_y * centroid_b_x;
+    covariance_y_y -= (nk_f64_t)n * centroid_a_y * centroid_b_y;
+    covariance_y_z -= (nk_f64_t)n * centroid_a_y * centroid_b_z;
+    covariance_z_x -= (nk_f64_t)n * centroid_a_z * centroid_b_x;
+    covariance_z_y -= (nk_f64_t)n * centroid_a_z * centroid_b_y;
+    covariance_z_z -= (nk_f64_t)n * centroid_a_z * centroid_b_z;
 
     // Compute SVD and optimal rotation using f64 precision (svd_s is 9-element diagonal matrix)
     nk_f64_t cross_covariance[9] = {covariance_x_x, covariance_x_y, covariance_x_z, covariance_y_x, covariance_y_y,
@@ -808,16 +785,13 @@ NK_PUBLIC void nk_kabsch_f64_haswell(nk_f64_t const *a, nk_f64_t const *b, nk_si
 
     // Handle reflection: if det(R) < 0, negate third column of V and recompute R
     if (nk_det3x3_f64_(r) < 0) {
-        svd_v[2] = -svd_v[2];
-        svd_v[5] = -svd_v[5];
-        svd_v[8] = -svd_v[8];
+        svd_v[2] = -svd_v[2], svd_v[5] = -svd_v[5], svd_v[8] = -svd_v[8];
         nk_rotation_from_svd_f64_haswell_(svd_u, svd_v, r);
     }
 
-    /* Output rotation matrix and scale=1.0 */
-    if (rotation) {
+    // Output rotation matrix and scale=1.0
+    if (rotation)
         for (int j = 0; j < 9; ++j) rotation[j] = r[j];
-    }
     if (scale) *scale = 1.0;
 
     // Compute RMSD after optimal rotation
@@ -842,60 +816,60 @@ NK_PUBLIC void nk_umeyama_f32_haswell(nk_f32_t const *a, nk_f32_t const *b, nk_s
     for (; index + 8 <= n; index += 8) {
         nk_deinterleave_f32x8_haswell_(a + index * 3, &a_x_f32x8, &a_y_f32x8, &a_z_f32x8),
             nk_deinterleave_f32x8_haswell_(b + index * 3, &b_x_f32x8, &b_y_f32x8, &b_z_f32x8);
-        __m256d a_x_lower_f64x4 = _mm256_cvtps_pd(_mm256_castps256_ps128(a_x_f32x8));
-        __m256d a_x_upper_f64x4 = _mm256_cvtps_pd(_mm256_extractf128_ps(a_x_f32x8, 1));
-        __m256d a_y_lower_f64x4 = _mm256_cvtps_pd(_mm256_castps256_ps128(a_y_f32x8));
-        __m256d a_y_upper_f64x4 = _mm256_cvtps_pd(_mm256_extractf128_ps(a_y_f32x8, 1));
-        __m256d a_z_lower_f64x4 = _mm256_cvtps_pd(_mm256_castps256_ps128(a_z_f32x8));
-        __m256d a_z_upper_f64x4 = _mm256_cvtps_pd(_mm256_extractf128_ps(a_z_f32x8, 1));
-        __m256d b_x_lower_f64x4 = _mm256_cvtps_pd(_mm256_castps256_ps128(b_x_f32x8));
-        __m256d b_x_upper_f64x4 = _mm256_cvtps_pd(_mm256_extractf128_ps(b_x_f32x8, 1));
-        __m256d b_y_lower_f64x4 = _mm256_cvtps_pd(_mm256_castps256_ps128(b_y_f32x8));
-        __m256d b_y_upper_f64x4 = _mm256_cvtps_pd(_mm256_extractf128_ps(b_y_f32x8, 1));
-        __m256d b_z_lower_f64x4 = _mm256_cvtps_pd(_mm256_castps256_ps128(b_z_f32x8));
-        __m256d b_z_upper_f64x4 = _mm256_cvtps_pd(_mm256_extractf128_ps(b_z_f32x8, 1));
-
-        sum_a_x_f64x4 = _mm256_add_pd(sum_a_x_f64x4, _mm256_add_pd(a_x_lower_f64x4, a_x_upper_f64x4));
-        sum_a_y_f64x4 = _mm256_add_pd(sum_a_y_f64x4, _mm256_add_pd(a_y_lower_f64x4, a_y_upper_f64x4));
-        sum_a_z_f64x4 = _mm256_add_pd(sum_a_z_f64x4, _mm256_add_pd(a_z_lower_f64x4, a_z_upper_f64x4));
-        sum_b_x_f64x4 = _mm256_add_pd(sum_b_x_f64x4, _mm256_add_pd(b_x_lower_f64x4, b_x_upper_f64x4));
-        sum_b_y_f64x4 = _mm256_add_pd(sum_b_y_f64x4, _mm256_add_pd(b_y_lower_f64x4, b_y_upper_f64x4));
-        sum_b_z_f64x4 = _mm256_add_pd(sum_b_z_f64x4, _mm256_add_pd(b_z_lower_f64x4, b_z_upper_f64x4));
-        covariance_00_f64x4 = _mm256_add_pd(covariance_00_f64x4,
-                                            _mm256_add_pd(_mm256_mul_pd(a_x_lower_f64x4, b_x_lower_f64x4),
-                                                          _mm256_mul_pd(a_x_upper_f64x4, b_x_upper_f64x4)));
-        covariance_01_f64x4 = _mm256_add_pd(covariance_01_f64x4,
-                                            _mm256_add_pd(_mm256_mul_pd(a_x_lower_f64x4, b_y_lower_f64x4),
-                                                          _mm256_mul_pd(a_x_upper_f64x4, b_y_upper_f64x4)));
-        covariance_02_f64x4 = _mm256_add_pd(covariance_02_f64x4,
-                                            _mm256_add_pd(_mm256_mul_pd(a_x_lower_f64x4, b_z_lower_f64x4),
-                                                          _mm256_mul_pd(a_x_upper_f64x4, b_z_upper_f64x4)));
-        covariance_10_f64x4 = _mm256_add_pd(covariance_10_f64x4,
-                                            _mm256_add_pd(_mm256_mul_pd(a_y_lower_f64x4, b_x_lower_f64x4),
-                                                          _mm256_mul_pd(a_y_upper_f64x4, b_x_upper_f64x4)));
-        covariance_11_f64x4 = _mm256_add_pd(covariance_11_f64x4,
-                                            _mm256_add_pd(_mm256_mul_pd(a_y_lower_f64x4, b_y_lower_f64x4),
-                                                          _mm256_mul_pd(a_y_upper_f64x4, b_y_upper_f64x4)));
-        covariance_12_f64x4 = _mm256_add_pd(covariance_12_f64x4,
-                                            _mm256_add_pd(_mm256_mul_pd(a_y_lower_f64x4, b_z_lower_f64x4),
-                                                          _mm256_mul_pd(a_y_upper_f64x4, b_z_upper_f64x4)));
-        covariance_20_f64x4 = _mm256_add_pd(covariance_20_f64x4,
-                                            _mm256_add_pd(_mm256_mul_pd(a_z_lower_f64x4, b_x_lower_f64x4),
-                                                          _mm256_mul_pd(a_z_upper_f64x4, b_x_upper_f64x4)));
-        covariance_21_f64x4 = _mm256_add_pd(covariance_21_f64x4,
-                                            _mm256_add_pd(_mm256_mul_pd(a_z_lower_f64x4, b_y_lower_f64x4),
-                                                          _mm256_mul_pd(a_z_upper_f64x4, b_y_upper_f64x4)));
-        covariance_22_f64x4 = _mm256_add_pd(covariance_22_f64x4,
-                                            _mm256_add_pd(_mm256_mul_pd(a_z_lower_f64x4, b_z_lower_f64x4),
-                                                          _mm256_mul_pd(a_z_upper_f64x4, b_z_upper_f64x4)));
+        __m256d a_x_low_f64x4 = _mm256_cvtps_pd(_mm256_castps256_ps128(a_x_f32x8));
+        __m256d a_x_high_f64x4 = _mm256_cvtps_pd(_mm256_extractf128_ps(a_x_f32x8, 1));
+        __m256d a_y_low_f64x4 = _mm256_cvtps_pd(_mm256_castps256_ps128(a_y_f32x8));
+        __m256d a_y_high_f64x4 = _mm256_cvtps_pd(_mm256_extractf128_ps(a_y_f32x8, 1));
+        __m256d a_z_low_f64x4 = _mm256_cvtps_pd(_mm256_castps256_ps128(a_z_f32x8));
+        __m256d a_z_high_f64x4 = _mm256_cvtps_pd(_mm256_extractf128_ps(a_z_f32x8, 1));
+        __m256d b_x_low_f64x4 = _mm256_cvtps_pd(_mm256_castps256_ps128(b_x_f32x8));
+        __m256d b_x_high_f64x4 = _mm256_cvtps_pd(_mm256_extractf128_ps(b_x_f32x8, 1));
+        __m256d b_y_low_f64x4 = _mm256_cvtps_pd(_mm256_castps256_ps128(b_y_f32x8));
+        __m256d b_y_high_f64x4 = _mm256_cvtps_pd(_mm256_extractf128_ps(b_y_f32x8, 1));
+        __m256d b_z_low_f64x4 = _mm256_cvtps_pd(_mm256_castps256_ps128(b_z_f32x8));
+        __m256d b_z_high_f64x4 = _mm256_cvtps_pd(_mm256_extractf128_ps(b_z_f32x8, 1));
+
+        sum_a_x_f64x4 = _mm256_add_pd(sum_a_x_f64x4, _mm256_add_pd(a_x_low_f64x4, a_x_high_f64x4));
+        sum_a_y_f64x4 = _mm256_add_pd(sum_a_y_f64x4, _mm256_add_pd(a_y_low_f64x4, a_y_high_f64x4));
+        sum_a_z_f64x4 = _mm256_add_pd(sum_a_z_f64x4, _mm256_add_pd(a_z_low_f64x4, a_z_high_f64x4));
+        sum_b_x_f64x4 = _mm256_add_pd(sum_b_x_f64x4, _mm256_add_pd(b_x_low_f64x4, b_x_high_f64x4));
+        sum_b_y_f64x4 = _mm256_add_pd(sum_b_y_f64x4, _mm256_add_pd(b_y_low_f64x4, b_y_high_f64x4));
+        sum_b_z_f64x4 = _mm256_add_pd(sum_b_z_f64x4, _mm256_add_pd(b_z_low_f64x4, b_z_high_f64x4));
+        covariance_00_f64x4 = _mm256_add_pd(
+            covariance_00_f64x4,
+            _mm256_add_pd(_mm256_mul_pd(a_x_low_f64x4, b_x_low_f64x4), _mm256_mul_pd(a_x_high_f64x4, b_x_high_f64x4)));
+        covariance_01_f64x4 = _mm256_add_pd(
+            covariance_01_f64x4,
+            _mm256_add_pd(_mm256_mul_pd(a_x_low_f64x4, b_y_low_f64x4), _mm256_mul_pd(a_x_high_f64x4, b_y_high_f64x4)));
+        covariance_02_f64x4 = _mm256_add_pd(
+            covariance_02_f64x4,
+            _mm256_add_pd(_mm256_mul_pd(a_x_low_f64x4, b_z_low_f64x4), _mm256_mul_pd(a_x_high_f64x4, b_z_high_f64x4)));
+        covariance_10_f64x4 = _mm256_add_pd(
+            covariance_10_f64x4,
+            _mm256_add_pd(_mm256_mul_pd(a_y_low_f64x4, b_x_low_f64x4), _mm256_mul_pd(a_y_high_f64x4, b_x_high_f64x4)));
+        covariance_11_f64x4 = _mm256_add_pd(
+            covariance_11_f64x4,
+            _mm256_add_pd(_mm256_mul_pd(a_y_low_f64x4, b_y_low_f64x4), _mm256_mul_pd(a_y_high_f64x4, b_y_high_f64x4)));
+        covariance_12_f64x4 = _mm256_add_pd(
+            covariance_12_f64x4,
+            _mm256_add_pd(_mm256_mul_pd(a_y_low_f64x4, b_z_low_f64x4), _mm256_mul_pd(a_y_high_f64x4, b_z_high_f64x4)));
+        covariance_20_f64x4 = _mm256_add_pd(
+            covariance_20_f64x4,
+            _mm256_add_pd(_mm256_mul_pd(a_z_low_f64x4, b_x_low_f64x4), _mm256_mul_pd(a_z_high_f64x4, b_x_high_f64x4)));
+        covariance_21_f64x4 = _mm256_add_pd(
+            covariance_21_f64x4,
+            _mm256_add_pd(_mm256_mul_pd(a_z_low_f64x4, b_y_low_f64x4), _mm256_mul_pd(a_z_high_f64x4, b_y_high_f64x4)));
+        covariance_22_f64x4 = _mm256_add_pd(
+            covariance_22_f64x4,
+            _mm256_add_pd(_mm256_mul_pd(a_z_low_f64x4, b_z_low_f64x4), _mm256_mul_pd(a_z_high_f64x4, b_z_high_f64x4)));
         variance_a_f64x4 = _mm256_add_pd(
             variance_a_f64x4,
-            _mm256_add_pd(_mm256_add_pd(_mm256_mul_pd(a_x_lower_f64x4, a_x_lower_f64x4),
-                                        _mm256_mul_pd(a_x_upper_f64x4, a_x_upper_f64x4)),
-                          _mm256_add_pd(_mm256_add_pd(_mm256_mul_pd(a_y_lower_f64x4, a_y_lower_f64x4),
-                                                      _mm256_mul_pd(a_y_upper_f64x4, a_y_upper_f64x4)),
-                                        _mm256_add_pd(_mm256_mul_pd(a_z_lower_f64x4, a_z_lower_f64x4),
-                                                      _mm256_mul_pd(a_z_upper_f64x4, a_z_upper_f64x4)))));
+            _mm256_add_pd(_mm256_add_pd(_mm256_mul_pd(a_x_low_f64x4, a_x_low_f64x4),
+                                        _mm256_mul_pd(a_x_high_f64x4, a_x_high_f64x4)),
+                          _mm256_add_pd(_mm256_add_pd(_mm256_mul_pd(a_y_low_f64x4, a_y_low_f64x4),
+                                                      _mm256_mul_pd(a_y_high_f64x4, a_y_high_f64x4)),
+                                        _mm256_add_pd(_mm256_mul_pd(a_z_low_f64x4, a_z_low_f64x4),
+                                                      _mm256_mul_pd(a_z_high_f64x4, a_z_high_f64x4)))));
     }
 
     nk_f64_t sum_a_x = nk_reduce_add_f64x4_haswell_(sum_a_x_f64x4);
@@ -1106,7 +1080,7 @@ NK_PUBLIC void nk_umeyama_f64_haswell(nk_f64_t const *a, nk_f64_t const *b, nk_s
     nk_f64_t det = nk_det3x3_f64_(r);
     nk_f64_t d3 = det < 0 ? -1.0 : 1.0;
     nk_f64_t trace_ds = nk_sum_three_products_f64_(svd_s[0], 1.0, svd_s[4], 1.0, svd_s[8], d3);
-    nk_f64_t c = trace_ds / (n * variance_a);
+    nk_f64_t c = trace_ds / ((nk_f64_t)n * variance_a);
     if (scale) *scale = c;
 
     // Handle reflection
@@ -1115,10 +1089,9 @@ NK_PUBLIC void nk_umeyama_f64_haswell(nk_f64_t const *a, nk_f64_t const *b, nk_s
         nk_rotation_from_svd_f64_haswell_(svd_u, svd_v, r);
     }
 
-    /* Output rotation matrix */
-    if (rotation) {
+    // Output rotation matrix
+    if (rotation)
         for (int j = 0; j < 9; ++j) rotation[j] = r[j];
-    }
 
     // Compute RMSD with scaling
     nk_f64_t sum_squared = nk_transformed_ssd_f64_haswell_(a, b, n, r, c, centroid_a_x, centroid_a_y, centroid_a_z,
@@ -1247,20 +1220,13 @@ NK_INTERNAL nk_f32_t nk_transformed_ssd_f16_haswell_(nk_f16_t const *a, nk_f16_t
         nk_f16_to_f32_haswell(&b[j * 3 + 1], &b_y_f32);
         nk_f16_to_f32_haswell(&b[j * 3 + 2], &b_z_f32);
 
-        nk_f32_t pa_x = a_x_f32 - centroid_a_x;
-        nk_f32_t pa_y = a_y_f32 - centroid_a_y;
-        nk_f32_t pa_z = a_z_f32 - centroid_a_z;
-        nk_f32_t pb_x = b_x_f32 - centroid_b_x;
-        nk_f32_t pb_y = b_y_f32 - centroid_b_y;
-        nk_f32_t pb_z = b_z_f32 - centroid_b_z;
+        nk_f32_t pa_x = a_x_f32 - centroid_a_x, pa_y = a_y_f32 - centroid_a_y, pa_z = a_z_f32 - centroid_a_z;
+        nk_f32_t pb_x = b_x_f32 - centroid_b_x, pb_y = b_y_f32 - centroid_b_y, pb_z = b_z_f32 - centroid_b_z;
+        nk_f32_t ra_x = scale * (r[0] * pa_x + r[1] * pa_y + r[2] * pa_z),
+                 ra_y = scale * (r[3] * pa_x + r[4] * pa_y + r[5] * pa_z),
+                 ra_z = scale * (r[6] * pa_x + r[7] * pa_y + r[8] * pa_z);
 
-        nk_f32_t ra_x = scale * (r[0] * pa_x + r[1] * pa_y + r[2] * pa_z);
-        nk_f32_t ra_y = scale * (r[3] * pa_x + r[4] * pa_y + r[5] * pa_z);
-        nk_f32_t ra_z = scale * (r[6] * pa_x + r[7] * pa_y + r[8] * pa_z);
-
-        nk_f32_t delta_x = ra_x - pb_x;
-        nk_f32_t delta_y = ra_y - pb_y;
-        nk_f32_t delta_z = ra_z - pb_z;
+        nk_f32_t delta_x = ra_x - pb_x, delta_y = ra_y - pb_y, delta_z = ra_z - pb_z;
         sum_squared += delta_x * delta_x + delta_y * delta_y + delta_z * delta_z;
     }
 
@@ -1344,20 +1310,13 @@ NK_INTERNAL nk_f32_t nk_transformed_ssd_bf16_haswell_(nk_bf16_t const *a, nk_bf1
         nk_bf16_to_f32_serial(&b[j * 3 + 1], &b_y_f32);
         nk_bf16_to_f32_serial(&b[j * 3 + 2], &b_z_f32);
 
-        nk_f32_t pa_x = a_x_f32 - centroid_a_x;
-        nk_f32_t pa_y = a_y_f32 - centroid_a_y;
-        nk_f32_t pa_z = a_z_f32 - centroid_a_z;
-        nk_f32_t pb_x = b_x_f32 - centroid_b_x;
-        nk_f32_t pb_y = b_y_f32 - centroid_b_y;
-        nk_f32_t pb_z = b_z_f32 - centroid_b_z;
-
-        nk_f32_t ra_x = scale * (r[0] * pa_x + r[1] * pa_y + r[2] * pa_z);
-        nk_f32_t ra_y = scale * (r[3] * pa_x + r[4] * pa_y + r[5] * pa_z);
-        nk_f32_t ra_z = scale * (r[6] * pa_x + r[7] * pa_y + r[8] * pa_z);
+        nk_f32_t pa_x = a_x_f32 - centroid_a_x, pa_y = a_y_f32 - centroid_a_y, pa_z = a_z_f32 - centroid_a_z;
+        nk_f32_t pb_x = b_x_f32 - centroid_b_x, pb_y = b_y_f32 - centroid_b_y, pb_z = b_z_f32 - centroid_b_z;
+        nk_f32_t ra_x = scale * (r[0] * pa_x + r[1] * pa_y + r[2] * pa_z),
+                 ra_y = scale * (r[3] * pa_x + r[4] * pa_y + r[5] * pa_z),
+                 ra_z = scale * (r[6] * pa_x + r[7] * pa_y + r[8] * pa_z);
 
-        nk_f32_t delta_x = ra_x - pb_x;
-        nk_f32_t delta_y = ra_y - pb_y;
-        nk_f32_t delta_z = ra_z - pb_z;
+        nk_f32_t delta_x = ra_x - pb_x, delta_y = ra_y - pb_y, delta_z = ra_z - pb_z;
         sum_squared += delta_x * delta_x + delta_y * delta_y + delta_z * delta_z;
     }
 
@@ -1366,12 +1325,10 @@ NK_INTERNAL nk_f32_t nk_transformed_ssd_bf16_haswell_(nk_bf16_t const *a, nk_bf1
 
 NK_PUBLIC void nk_rmsd_f16_haswell(nk_f16_t const *a, nk_f16_t const *b, nk_size_t n, nk_f32_t *a_centroid,
                                    nk_f32_t *b_centroid, nk_f32_t *rotation, nk_f32_t *scale, nk_f32_t *result) {
-    /* RMSD uses identity rotation and scale=1.0 */
-    if (rotation) {
-        rotation[0] = 1, rotation[1] = 0, rotation[2] = 0;
-        rotation[3] = 0, rotation[4] = 1, rotation[5] = 0;
+    // RMSD uses identity rotation and scale=1.0
+    if (rotation)
+        rotation[0] = 1, rotation[1] = 0, rotation[2] = 0, rotation[3] = 0, rotation[4] = 1, rotation[5] = 0,
         rotation[6] = 0, rotation[7] = 0, rotation[8] = 1;
-    }
     if (scale) *scale = 1.0f;
 
     __m256 const zeros_f32x8 = _mm256_setzero_ps();
@@ -1446,16 +1403,8 @@ NK_PUBLIC void nk_rmsd_f16_haswell(nk_f16_t const *a, nk_f16_t const *b, nk_size
     nk_f32_t centroid_b_y = total_by * inv_n;
     nk_f32_t centroid_b_z = total_bz * inv_n;
 
-    if (a_centroid) {
-        a_centroid[0] = centroid_a_x;
-        a_centroid[1] = centroid_a_y;
-        a_centroid[2] = centroid_a_z;
-    }
-    if (b_centroid) {
-        b_centroid[0] = centroid_b_x;
-        b_centroid[1] = centroid_b_y;
-        b_centroid[2] = centroid_b_z;
-    }
+    if (a_centroid) a_centroid[0] = centroid_a_x, a_centroid[1] = centroid_a_y, a_centroid[2] = centroid_a_z;
+    if (b_centroid) b_centroid[0] = centroid_b_x, b_centroid[1] = centroid_b_y, b_centroid[2] = centroid_b_z;
 
     // Compute RMSD
     nk_f32_t mean_diff_x = centroid_a_x - centroid_b_x;
@@ -1469,12 +1418,10 @@ NK_PUBLIC void nk_rmsd_f16_haswell(nk_f16_t const *a, nk_f16_t const *b, nk_size
 
 NK_PUBLIC void nk_rmsd_bf16_haswell(nk_bf16_t const *a, nk_bf16_t const *b, nk_size_t n, nk_f32_t *a_centroid,
                                     nk_f32_t *b_centroid, nk_f32_t *rotation, nk_f32_t *scale, nk_f32_t *result) {
-    /* RMSD uses identity rotation and scale=1.0 */
-    if (rotation) {
-        rotation[0] = 1, rotation[1] = 0, rotation[2] = 0;
-        rotation[3] = 0, rotation[4] = 1, rotation[5] = 0;
+    // RMSD uses identity rotation and scale=1.0
+    if (rotation)
+        rotation[0] = 1, rotation[1] = 0, rotation[2] = 0, rotation[3] = 0, rotation[4] = 1, rotation[5] = 0,
         rotation[6] = 0, rotation[7] = 0, rotation[8] = 1;
-    }
     if (scale) *scale = 1.0f;
 
     __m256 const zeros_f32x8 = _mm256_setzero_ps();
@@ -1549,16 +1496,8 @@ NK_PUBLIC void nk_rmsd_bf16_haswell(nk_bf16_t const *a, nk_bf16_t const *b, nk_s
     nk_f32_t centroid_b_y = total_by * inv_n;
     nk_f32_t centroid_b_z = total_bz * inv_n;
 
-    if (a_centroid) {
-        a_centroid[0] = centroid_a_x;
-        a_centroid[1] = centroid_a_y;
-        a_centroid[2] = centroid_a_z;
-    }
-    if (b_centroid) {
-        b_centroid[0] = centroid_b_x;
-        b_centroid[1] = centroid_b_y;
-        b_centroid[2] = centroid_b_z;
-    }
+    if (a_centroid) a_centroid[0] = centroid_a_x, a_centroid[1] = centroid_a_y, a_centroid[2] = centroid_a_z;
+    if (b_centroid) b_centroid[0] = centroid_b_x, b_centroid[1] = centroid_b_y, b_centroid[2] = centroid_b_z;
 
     // Compute RMSD
     nk_f32_t mean_diff_x = centroid_a_x - centroid_b_x;
@@ -1638,21 +1577,11 @@ NK_PUBLIC void nk_kabsch_f16_haswell(nk_f16_t const *a, nk_f16_t const *b, nk_si
         nk_f16_to_f32_haswell(&b[i * 3 + 0], &bx);
         nk_f16_to_f32_haswell(&b[i * 3 + 1], &by);
         nk_f16_to_f32_haswell(&b[i * 3 + 2], &bz);
-        sum_a_x += ax;
-        sum_a_y += ay;
-        sum_a_z += az;
-        sum_b_x += bx;
-        sum_b_y += by;
-        sum_b_z += bz;
-        covariance_x_x += ax * bx;
-        covariance_x_y += ax * by;
-        covariance_x_z += ax * bz;
-        covariance_y_x += ay * bx;
-        covariance_y_y += ay * by;
-        covariance_y_z += ay * bz;
-        covariance_z_x += az * bx;
-        covariance_z_y += az * by;
-        covariance_z_z += az * bz;
+        sum_a_x += ax, sum_a_y += ay, sum_a_z += az;
+        sum_b_x += bx, sum_b_y += by, sum_b_z += bz;
+        covariance_x_x += ax * bx, covariance_x_y += ax * by, covariance_x_z += ax * bz;
+        covariance_y_x += ay * bx, covariance_y_y += ay * by, covariance_y_z += ay * bz;
+        covariance_z_x += az * bx, covariance_z_y += az * by, covariance_z_z += az * bz;
     }
 
     // Compute centroids
@@ -1664,27 +1593,19 @@ NK_PUBLIC void nk_kabsch_f16_haswell(nk_f16_t const *a, nk_f16_t const *b, nk_si
     nk_f32_t centroid_b_y = sum_b_y * inv_n;
     nk_f32_t centroid_b_z = sum_b_z * inv_n;
 
-    if (a_centroid) {
-        a_centroid[0] = centroid_a_x;
-        a_centroid[1] = centroid_a_y;
-        a_centroid[2] = centroid_a_z;
-    }
-    if (b_centroid) {
-        b_centroid[0] = centroid_b_x;
-        b_centroid[1] = centroid_b_y;
-        b_centroid[2] = centroid_b_z;
-    }
+    if (a_centroid) a_centroid[0] = centroid_a_x, a_centroid[1] = centroid_a_y, a_centroid[2] = centroid_a_z;
+    if (b_centroid) b_centroid[0] = centroid_b_x, b_centroid[1] = centroid_b_y, b_centroid[2] = centroid_b_z;
 
     // Apply centering correction: H_centered = H - n * centroid_a * centroid_bᵀ
-    covariance_x_x -= n * centroid_a_x * centroid_b_x;
-    covariance_x_y -= n * centroid_a_x * centroid_b_y;
-    covariance_x_z -= n * centroid_a_x * centroid_b_z;
-    covariance_y_x -= n * centroid_a_y * centroid_b_x;
-    covariance_y_y -= n * centroid_a_y * centroid_b_y;
-    covariance_y_z -= n * centroid_a_y * centroid_b_z;
-    covariance_z_x -= n * centroid_a_z * centroid_b_x;
-    covariance_z_y -= n * centroid_a_z * centroid_b_y;
-    covariance_z_z -= n * centroid_a_z * centroid_b_z;
+    covariance_x_x -= (nk_f32_t)n * centroid_a_x * centroid_b_x;
+    covariance_x_y -= (nk_f32_t)n * centroid_a_x * centroid_b_y;
+    covariance_x_z -= (nk_f32_t)n * centroid_a_x * centroid_b_z;
+    covariance_y_x -= (nk_f32_t)n * centroid_a_y * centroid_b_x;
+    covariance_y_y -= (nk_f32_t)n * centroid_a_y * centroid_b_y;
+    covariance_y_z -= (nk_f32_t)n * centroid_a_y * centroid_b_z;
+    covariance_z_x -= (nk_f32_t)n * centroid_a_z * centroid_b_x;
+    covariance_z_y -= (nk_f32_t)n * centroid_a_z * centroid_b_y;
+    covariance_z_z -= (nk_f32_t)n * centroid_a_z * centroid_b_z;
 
     // Compute SVD and optimal rotation
     nk_f32_t cross_covariance[9] = {covariance_x_x, covariance_x_y, covariance_x_z, covariance_y_x, covariance_y_y,
@@ -1706,9 +1627,7 @@ NK_PUBLIC void nk_kabsch_f16_haswell(nk_f16_t const *a, nk_f16_t const *b, nk_si
 
     // Handle reflection: if det(R) < 0, negate third column of V and recompute R
     if (nk_det3x3_f32_(r) < 0) {
-        svd_v[2] = -svd_v[2];
-        svd_v[5] = -svd_v[5];
-        svd_v[8] = -svd_v[8];
+        svd_v[2] = -svd_v[2], svd_v[5] = -svd_v[5], svd_v[8] = -svd_v[8];
         r[0] = svd_v[0] * svd_u[0] + svd_v[1] * svd_u[1] + svd_v[2] * svd_u[2];
         r[1] = svd_v[0] * svd_u[3] + svd_v[1] * svd_u[4] + svd_v[2] * svd_u[5];
         r[2] = svd_v[0] * svd_u[6] + svd_v[1] * svd_u[7] + svd_v[2] * svd_u[8];
@@ -1720,10 +1639,9 @@ NK_PUBLIC void nk_kabsch_f16_haswell(nk_f16_t const *a, nk_f16_t const *b, nk_si
         r[8] = svd_v[6] * svd_u[6] + svd_v[7] * svd_u[7] + svd_v[8] * svd_u[8];
     }
 
-    /* Output rotation matrix and scale=1.0 */
-    if (rotation) {
+    // Output rotation matrix and scale=1.0
+    if (rotation)
         for (int j = 0; j < 9; ++j) rotation[j] = r[j];
-    }
     if (scale) *scale = 1.0f;
 
     // Compute RMSD after optimal rotation
@@ -1800,21 +1718,11 @@ NK_PUBLIC void nk_kabsch_bf16_haswell(nk_bf16_t const *a, nk_bf16_t const *b, nk
         nk_bf16_to_f32_serial(&b[i * 3 + 0], &bx);
         nk_bf16_to_f32_serial(&b[i * 3 + 1], &by);
         nk_bf16_to_f32_serial(&b[i * 3 + 2], &bz);
-        sum_a_x += ax;
-        sum_a_y += ay;
-        sum_a_z += az;
-        sum_b_x += bx;
-        sum_b_y += by;
-        sum_b_z += bz;
-        covariance_x_x += ax * bx;
-        covariance_x_y += ax * by;
-        covariance_x_z += ax * bz;
-        covariance_y_x += ay * bx;
-        covariance_y_y += ay * by;
-        covariance_y_z += ay * bz;
-        covariance_z_x += az * bx;
-        covariance_z_y += az * by;
-        covariance_z_z += az * bz;
+        sum_a_x += ax, sum_a_y += ay, sum_a_z += az;
+        sum_b_x += bx, sum_b_y += by, sum_b_z += bz;
+        covariance_x_x += ax * bx, covariance_x_y += ax * by, covariance_x_z += ax * bz;
+        covariance_y_x += ay * bx, covariance_y_y += ay * by, covariance_y_z += ay * bz;
+        covariance_z_x += az * bx, covariance_z_y += az * by, covariance_z_z += az * bz;
     }
 
     // Compute centroids
@@ -1826,27 +1734,19 @@ NK_PUBLIC void nk_kabsch_bf16_haswell(nk_bf16_t const *a, nk_bf16_t const *b, nk
     nk_f32_t centroid_b_y = sum_b_y * inv_n;
     nk_f32_t centroid_b_z = sum_b_z * inv_n;
 
-    if (a_centroid) {
-        a_centroid[0] = centroid_a_x;
-        a_centroid[1] = centroid_a_y;
-        a_centroid[2] = centroid_a_z;
-    }
-    if (b_centroid) {
-        b_centroid[0] = centroid_b_x;
-        b_centroid[1] = centroid_b_y;
-        b_centroid[2] = centroid_b_z;
-    }
+    if (a_centroid) a_centroid[0] = centroid_a_x, a_centroid[1] = centroid_a_y, a_centroid[2] = centroid_a_z;
+    if (b_centroid) b_centroid[0] = centroid_b_x, b_centroid[1] = centroid_b_y, b_centroid[2] = centroid_b_z;
 
     // Apply centering correction: H_centered = H - n * centroid_a * centroid_bᵀ
-    covariance_x_x -= n * centroid_a_x * centroid_b_x;
-    covariance_x_y -= n * centroid_a_x * centroid_b_y;
-    covariance_x_z -= n * centroid_a_x * centroid_b_z;
-    covariance_y_x -= n * centroid_a_y * centroid_b_x;
-    covariance_y_y -= n * centroid_a_y * centroid_b_y;
-    covariance_y_z -= n * centroid_a_y * centroid_b_z;
-    covariance_z_x -= n * centroid_a_z * centroid_b_x;
-    covariance_z_y -= n * centroid_a_z * centroid_b_y;
-    covariance_z_z -= n * centroid_a_z * centroid_b_z;
+    covariance_x_x -= (nk_f32_t)n * centroid_a_x * centroid_b_x;
+    covariance_x_y -= (nk_f32_t)n * centroid_a_x * centroid_b_y;
+    covariance_x_z -= (nk_f32_t)n * centroid_a_x * centroid_b_z;
+    covariance_y_x -= (nk_f32_t)n * centroid_a_y * centroid_b_x;
+    covariance_y_y -= (nk_f32_t)n * centroid_a_y * centroid_b_y;
+    covariance_y_z -= (nk_f32_t)n * centroid_a_y * centroid_b_z;
+    covariance_z_x -= (nk_f32_t)n * centroid_a_z * centroid_b_x;
+    covariance_z_y -= (nk_f32_t)n * centroid_a_z * centroid_b_y;
+    covariance_z_z -= (nk_f32_t)n * centroid_a_z * centroid_b_z;
 
     // Compute SVD and optimal rotation
     nk_f32_t cross_covariance[9] = {covariance_x_x, covariance_x_y, covariance_x_z, covariance_y_x, covariance_y_y,
@@ -1868,9 +1768,7 @@ NK_PUBLIC void nk_kabsch_bf16_haswell(nk_bf16_t const *a, nk_bf16_t const *b, nk
 
     // Handle reflection: if det(R) < 0, negate third column of V and recompute R
     if (nk_det3x3_f32_(r) < 0) {
-        svd_v[2] = -svd_v[2];
-        svd_v[5] = -svd_v[5];
-        svd_v[8] = -svd_v[8];
+        svd_v[2] = -svd_v[2], svd_v[5] = -svd_v[5], svd_v[8] = -svd_v[8];
         r[0] = svd_v[0] * svd_u[0] + svd_v[1] * svd_u[1] + svd_v[2] * svd_u[2];
         r[1] = svd_v[0] * svd_u[3] + svd_v[1] * svd_u[4] + svd_v[2] * svd_u[5];
         r[2] = svd_v[0] * svd_u[6] + svd_v[1] * svd_u[7] + svd_v[2] * svd_u[8];
@@ -1882,10 +1780,9 @@ NK_PUBLIC void nk_kabsch_bf16_haswell(nk_bf16_t const *a, nk_bf16_t const *b, nk
         r[8] = svd_v[6] * svd_u[6] + svd_v[7] * svd_u[7] + svd_v[8] * svd_u[8];
     }
 
-    /* Output rotation matrix and scale=1.0 */
-    if (rotation) {
+    // Output rotation matrix and scale=1.0
+    if (rotation)
         for (int j = 0; j < 9; ++j) rotation[j] = r[j];
-    }
     if (scale) *scale = 1.0f;
 
     // Compute RMSD after optimal rotation
@@ -1965,21 +1862,11 @@ NK_PUBLIC void nk_umeyama_f16_haswell(nk_f16_t const *a, nk_f16_t const *b, nk_s
         nk_f16_to_f32_haswell(&b[i * 3 + 0], &bx);
         nk_f16_to_f32_haswell(&b[i * 3 + 1], &by);
         nk_f16_to_f32_haswell(&b[i * 3 + 2], &bz);
-        sum_a_x += ax;
-        sum_a_y += ay;
-        sum_a_z += az;
-        sum_b_x += bx;
-        sum_b_y += by;
-        sum_b_z += bz;
-        covariance_x_x += ax * bx;
-        covariance_x_y += ax * by;
-        covariance_x_z += ax * bz;
-        covariance_y_x += ay * bx;
-        covariance_y_y += ay * by;
-        covariance_y_z += ay * bz;
-        covariance_z_x += az * bx;
-        covariance_z_y += az * by;
-        covariance_z_z += az * bz;
+        sum_a_x += ax, sum_a_y += ay, sum_a_z += az;
+        sum_b_x += bx, sum_b_y += by, sum_b_z += bz;
+        covariance_x_x += ax * bx, covariance_x_y += ax * by, covariance_x_z += ax * bz;
+        covariance_y_x += ay * bx, covariance_y_y += ay * by, covariance_y_z += ay * bz;
+        covariance_z_x += az * bx, covariance_z_y += az * by, covariance_z_z += az * bz;
         variance_a_sum += ax * ax + ay * ay + az * az;
     }
 
@@ -1996,15 +1883,15 @@ NK_PUBLIC void nk_umeyama_f16_haswell(nk_f16_t const *a, nk_f16_t const *b, nk_s
                           (centroid_a_x * centroid_a_x + centroid_a_y * centroid_a_y + centroid_a_z * centroid_a_z);
 
     // Apply centering correction to covariance matrix
-    covariance_x_x -= n * centroid_a_x * centroid_b_x;
-    covariance_x_y -= n * centroid_a_x * centroid_b_y;
-    covariance_x_z -= n * centroid_a_x * centroid_b_z;
-    covariance_y_x -= n * centroid_a_y * centroid_b_x;
-    covariance_y_y -= n * centroid_a_y * centroid_b_y;
-    covariance_y_z -= n * centroid_a_y * centroid_b_z;
-    covariance_z_x -= n * centroid_a_z * centroid_b_x;
-    covariance_z_y -= n * centroid_a_z * centroid_b_y;
-    covariance_z_z -= n * centroid_a_z * centroid_b_z;
+    covariance_x_x -= (nk_f32_t)n * centroid_a_x * centroid_b_x;
+    covariance_x_y -= (nk_f32_t)n * centroid_a_x * centroid_b_y;
+    covariance_x_z -= (nk_f32_t)n * centroid_a_x * centroid_b_z;
+    covariance_y_x -= (nk_f32_t)n * centroid_a_y * centroid_b_x;
+    covariance_y_y -= (nk_f32_t)n * centroid_a_y * centroid_b_y;
+    covariance_y_z -= (nk_f32_t)n * centroid_a_y * centroid_b_z;
+    covariance_z_x -= (nk_f32_t)n * centroid_a_z * centroid_b_x;
+    covariance_z_y -= (nk_f32_t)n * centroid_a_z * centroid_b_y;
+    covariance_z_z -= (nk_f32_t)n * centroid_a_z * centroid_b_z;
 
     nk_f32_t cross_covariance[9] = {covariance_x_x, covariance_x_y, covariance_x_z, covariance_y_x, covariance_y_y,
                                     covariance_y_z, covariance_z_x, covariance_z_y, covariance_z_z};
@@ -2029,7 +1916,7 @@ NK_PUBLIC void nk_umeyama_f16_haswell(nk_f16_t const *a, nk_f16_t const *b, nk_s
     nk_f32_t det = nk_det3x3_f32_(r);
     nk_f32_t d3 = det < 0 ? -1.0f : 1.0f;
     nk_f32_t trace_ds = svd_s[0] + svd_s[4] + d3 * svd_s[8];
-    nk_f32_t c = trace_ds / (n * variance_a);
+    nk_f32_t c = trace_ds / ((nk_f32_t)n * variance_a);
     if (scale) *scale = c;
 
     // Handle reflection
@@ -2046,10 +1933,9 @@ NK_PUBLIC void nk_umeyama_f16_haswell(nk_f16_t const *a, nk_f16_t const *b, nk_s
         r[8] = svd_v[6] * svd_u[6] + svd_v[7] * svd_u[7] + svd_v[8] * svd_u[8];
     }
 
-    /* Output rotation matrix */
-    if (rotation) {
+    // Output rotation matrix
+    if (rotation)
         for (int j = 0; j < 9; ++j) rotation[j] = r[j];
-    }
 
     // Compute RMSD with scaling
     nk_f32_t sum_squared = nk_transformed_ssd_f16_haswell_(a, b, n, r, c, centroid_a_x, centroid_a_y, centroid_a_z,
@@ -2128,21 +2014,11 @@ NK_PUBLIC void nk_umeyama_bf16_haswell(nk_bf16_t const *a, nk_bf16_t const *b, n
         nk_bf16_to_f32_serial(&b[i * 3 + 0], &bx);
         nk_bf16_to_f32_serial(&b[i * 3 + 1], &by);
         nk_bf16_to_f32_serial(&b[i * 3 + 2], &bz);
-        sum_a_x += ax;
-        sum_a_y += ay;
-        sum_a_z += az;
-        sum_b_x += bx;
-        sum_b_y += by;
-        sum_b_z += bz;
-        covariance_x_x += ax * bx;
-        covariance_x_y += ax * by;
-        covariance_x_z += ax * bz;
-        covariance_y_x += ay * bx;
-        covariance_y_y += ay * by;
-        covariance_y_z += ay * bz;
-        covariance_z_x += az * bx;
-        covariance_z_y += az * by;
-        covariance_z_z += az * bz;
+        sum_a_x += ax, sum_a_y += ay, sum_a_z += az;
+        sum_b_x += bx, sum_b_y += by, sum_b_z += bz;
+        covariance_x_x += ax * bx, covariance_x_y += ax * by, covariance_x_z += ax * bz;
+        covariance_y_x += ay * bx, covariance_y_y += ay * by, covariance_y_z += ay * bz;
+        covariance_z_x += az * bx, covariance_z_y += az * by, covariance_z_z += az * bz;
         variance_a_sum += ax * ax + ay * ay + az * az;
     }
 
@@ -2159,15 +2035,15 @@ NK_PUBLIC void nk_umeyama_bf16_haswell(nk_bf16_t const *a, nk_bf16_t const *b, n
                           (centroid_a_x * centroid_a_x + centroid_a_y * centroid_a_y + centroid_a_z * centroid_a_z);
 
     // Apply centering correction to covariance matrix
-    covariance_x_x -= n * centroid_a_x * centroid_b_x;
-    covariance_x_y -= n * centroid_a_x * centroid_b_y;
-    covariance_x_z -= n * centroid_a_x * centroid_b_z;
-    covariance_y_x -= n * centroid_a_y * centroid_b_x;
-    covariance_y_y -= n * centroid_a_y * centroid_b_y;
-    covariance_y_z -= n * centroid_a_y * centroid_b_z;
-    covariance_z_x -= n * centroid_a_z * centroid_b_x;
-    covariance_z_y -= n * centroid_a_z * centroid_b_y;
-    covariance_z_z -= n * centroid_a_z * centroid_b_z;
+    covariance_x_x -= (nk_f32_t)n * centroid_a_x * centroid_b_x;
+    covariance_x_y -= (nk_f32_t)n * centroid_a_x * centroid_b_y;
+    covariance_x_z -= (nk_f32_t)n * centroid_a_x * centroid_b_z;
+    covariance_y_x -= (nk_f32_t)n * centroid_a_y * centroid_b_x;
+    covariance_y_y -= (nk_f32_t)n * centroid_a_y * centroid_b_y;
+    covariance_y_z -= (nk_f32_t)n * centroid_a_y * centroid_b_z;
+    covariance_z_x -= (nk_f32_t)n * centroid_a_z * centroid_b_x;
+    covariance_z_y -= (nk_f32_t)n * centroid_a_z * centroid_b_y;
+    covariance_z_z -= (nk_f32_t)n * centroid_a_z * centroid_b_z;
 
     nk_f32_t cross_covariance[9] = {covariance_x_x, covariance_x_y, covariance_x_z, covariance_y_x, covariance_y_y,
                                     covariance_y_z, covariance_z_x, covariance_z_y, covariance_z_z};
@@ -2192,7 +2068,7 @@ NK_PUBLIC void nk_umeyama_bf16_haswell(nk_bf16_t const *a, nk_bf16_t const *b, n
     nk_f32_t det = nk_det3x3_f32_(r);
     nk_f32_t d3 = det < 0 ? -1.0f : 1.0f;
     nk_f32_t trace_ds = svd_s[0] + svd_s[4] + d3 * svd_s[8];
-    nk_f32_t c = trace_ds / (n * variance_a);
+    nk_f32_t c = trace_ds / ((nk_f32_t)n * variance_a);
     if (scale) *scale = c;
 
     // Handle reflection
@@ -2209,10 +2085,9 @@ NK_PUBLIC void nk_umeyama_bf16_haswell(nk_bf16_t const *a, nk_bf16_t const *b, n
         r[8] = svd_v[6] * svd_u[6] + svd_v[7] * svd_u[7] + svd_v[8] * svd_u[8];
     }
 
-    /* Output rotation matrix */
-    if (rotation) {
+    // Output rotation matrix
+    if (rotation)
         for (int j = 0; j < 9; ++j) rotation[j] = r[j];
-    }
 
     // Compute RMSD with scaling
     nk_f32_t sum_squared = nk_transformed_ssd_bf16_haswell_(a, b, n, r, c, centroid_a_x, centroid_a_y, centroid_a_z,