usearch 2.17.1 → 2.19.4

package/javascript/usearch.ts

@@ -16,8 +16,8 @@ type CompiledSearchResult = [
 ];
 
 interface CompiledIndex {
-  add(keys: BigUint64Array, vectors: Vector): void;
-  search(vectors: VectorOrMatrix, k: number): CompiledSearchResult;
+  add(keys: BigUint64Array, vectors: Vector, threads: number): void;
+  search(vectors: VectorOrMatrix, k: number, threads: number): CompiledSearchResult;
   contains(keys: BigUint64Array): boolean[];
   count(keys: BigUint64Array): number | number[];
   remove(keys: BigUint64Array): number[];
@@ -37,7 +37,8 @@ interface Compiled {
     queries: VectorOrMatrix,
     dimensions: number,
     count: number,
-    metric: MetricKind
+    metric: MetricKind,
+    threads: number
   ): CompiledSearchResult;
 }
 
@@ -326,10 +327,12 @@ export class Index {
    *        If a single key is provided, it is associated with all provided vectors.
    * @param {Float32Array|Float64Array|Int8Array} vectors - Input matrix representing vectors,
    *        matrix of size n * d, where n is the number of vectors, and d is their dimensionality.
+   * @param {number} [threads=0] - Optional, default is 0. Number of threads to use for indexing.
+   *        If set to 0, the number of threads is determined automatically.
    * @throws Will throw an error if the length of keys doesn't match the number of vectors
    *         or if it's not a single key.
    */
-  add(keys: bigint | bigint[] | BigUint64Array, vectors: Vector) {
+  add(keys: bigint | bigint[] | BigUint64Array, vectors: Vector, threads: number = 0): void {
     let normalizedKeys = normalizeKeys(keys);
     let normalizedVectors = normalizeVectors(
       vectors,
@@ -351,8 +354,14 @@ export class Index {
       );
     }
 
+    if ((!Number.isNaN(threads) && typeof threads !== "number") || threads < 0) {
+      throw new Error(
+        "`threads` must be a non-negative integer representing the number of threads to use for searching."
+      );
+    }
+
     // Call the compiled method
-    this.#compiledIndex.add(normalizedKeys, normalizedVectors);
+    this.#compiledIndex.add(normalizedKeys, normalizedVectors, threads);
   }
 
   /**
@@ -372,16 +381,22 @@ export class Index {
    *
    * @param {Float32Array|Float64Array|Int8Array|Array<Array<number>>} vectors - Input matrix representing query vectors, can be a TypedArray or an array of TypedArray.
    * @param {number} k - The number of nearest neighbors to search for each query vector.
+   * @param {number} [threads=0] - Optional, default is 0. Number of threads to use for searching. If set to 0, the number of threads is determined automatically.
    * @return {Matches|BatchMatches} - Search results for one or more queries, containing keys, distances, and counts of the matches found.
    * @throws Will throw an error if `k` is not a positive integer or if the size of the vectors is not a multiple of dimensions.
    * @throws Will throw an error if `vectors` is not a valid input type (TypedArray or an array of TypedArray) or if its flattened size is not a multiple of dimensions.
    */
-  search(vectors: VectorOrMatrix, k: number): Matches | BatchMatches {
+  search(vectors: VectorOrMatrix, k: number, threads: number = 0): Matches | BatchMatches {
     if ((!Number.isNaN(k) && typeof k !== "number") || k <= 0) {
       throw new Error(
         "`k` must be a positive integer representing the number of nearest neighbors to search for."
       );
     }
+    if ((!Number.isNaN(threads) && typeof threads !== "number") || threads < 0) {
+      throw new Error(
+        "`threads` must be a non-negative integer representing the number of threads to use for searching."
+      );
+    }
 
     const normalizedVectors = normalizeVectors(
       vectors,
@@ -389,7 +404,7 @@ export class Index {
     );
 
     // Call the compiled method and create Matches or BatchMatches object with the result
-    const result = this.#compiledIndex.search(normalizedVectors, k);
+    const result = this.#compiledIndex.search(normalizedVectors, k, threads);
     const countInQueries =
       normalizedVectors.length / Number(this.#compiledIndex.dimensions());
     const batchMatches = new BatchMatches(...result, k);
@@ -533,6 +548,7 @@ type NumberArrayConstructor =
  * @param {number} dimensions - The dimensionality of the vectors in both the dataset and the queries. It defines the number of elements in each vector.
  * @param {number} count - The number of nearest neighbors to return for each query. If the dataset contains fewer vectors than the specified count, the result will contain only the available vectors.
  * @param {MetricKind} metric - The distance metric to be used for the search.
+ * @param {number} [threads=0] - Optional, default is 0. The number of threads to use for the search. If set to 0, the number of threads is determined automatically.
  * @return {Matches|BatchMatches} - Returns a `Matches` or `BatchMatches` object containing the results of the search.
  * @throws Will throw an error if `dimensions` and `count` are not positive integers.
  * @throws Will throw an error if `metric` is not a valid MetricKind.
@@ -546,20 +562,22 @@ type NumberArrayConstructor =
  * const dimensions = 2; // The number of elements in each vector.
  * const count = 1; // The number of nearest neighbors to return for each query.
  * const metric = MetricKind.IP; // Using the Inner Product distance metric.
+ * const threads = 0; // How many threads to use to perform the search.
  *
- * const result = exactSearch(dataset, queries, dimensions, count, metric);
+ * const result = exactSearch(dataset, queries, dimensions, count, metric, threads);
  * // result might be:
  * // {
  * //    keys: BigUint64Array [ 1n ],
  * //    distances: Float32Array [ some_value ],
  * // }
  */
-function exactSearch(
+export function exactSearch(
   dataset: VectorOrMatrix,
   queries: VectorOrMatrix,
   dimensions: number,
   count: number,
-  metric: MetricKind
+  metric: MetricKind,
+  threads: number = 0
 ): Matches | BatchMatches {
   // Validate and normalize the dimensions and count
   dimensions = Number(dimensions);
@@ -567,6 +585,11 @@ function exactSearch(
   if (count <= 0 || dimensions <= 0) {
     throw new Error("Dimensions and count must be positive integers.");
   }
+  if ((!Number.isNaN(threads) && typeof threads !== "number") || threads < 0) {
+    throw new Error(
+      "`threads` must be a non-negative integer representing the number of threads to use for searching."
+    );
+  }
 
   // Validate metric
   if (!Object.values(MetricKind).includes(metric)) {
@@ -599,7 +622,8 @@ function exactSearch(
     queries,
     dimensions,
     count,
-    metric
+    metric,
+    threads
   );
 
   // Create and return a Matches or BatchMatches object with the result

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "usearch",
-    "version": "2.17.1",
+    "version": "2.19.4",
     "description": "Smaller & Faster Single-File Vector Search Engine from Unum",
     "author": "Ash Vardanian (https://ashvardanian.com/)",
     "license": "Apache 2.0",

package/simsimd/CONTRIBUTING.md

@@ -68,6 +68,7 @@ Replacing the default compiler across the entire system is not recommended on Ma
 
 ```sh
 brew install llvm openblas
+unset DEVELOPER_DIR
 cmake -D CMAKE_BUILD_TYPE=Release \
       -D SIMSIMD_BUILD_TESTS=1 \
       -D SIMSIMD_BUILD_BENCHMARKS=1 \
@@ -86,23 +87,37 @@ cmake --build build_release --config Release
 When benchmarking, make sure to disable multi-threading in the BLAS library, as it may interfere with the results:
 
 ```sh
-export OPENBLAS_NUM_THREADS=1 # for OpenBLAS
-export MKL_NUM_THREADS=1 # for Intel MKL
-export VECLIB_MAXIMUM_THREADS=1 # for Apple Accelerate
-export BLIS_NUM_THREADS=1 # for BLIS
+export OPENBLAS_NUM_THREADS=1    # for OpenBLAS
+export MKL_NUM_THREADS=1         # for Intel MKL
+export VECLIB_MAXIMUM_THREADS=1  # for Apple Accelerate
+export BLIS_NUM_THREADS=1        # for BLIS
 ```
 
 ## Python
 
-Testing:
+Python bindings are implemented using pure CPython, so you wouldn't need to install SWIG, PyBind11, or any other third-party library.
+Still, you need a virtual environment.
+If you already have one:
 
 ```sh
-pip install -e .                             # to install the package in editable mode
+pip install -e .                             # build locally from source
 pip install pytest pytest-repeat tabulate    # testing dependencies
 pytest scripts/test.py -s -x -Wd             # to run tests
 
 # to check supported SIMD instructions:
-python -c "import simsimd; print(simsimd.get_capabilities())" 
+python -c "import simsimd; print(simsimd.get_capabilities())"
+```
+
+Alternatively, use `uv` to create the virtual environment.
+
+```sh
+uv venv --python 3.13t          # or your preferred version
+source .venv/bin/activate       # activate the environment
+uv pip install -e .             # build locally from source
+
+# to run GIL-related tests in a free-threaded environment:
+uv pip install pytest pytest-repeat tabulate numpy scipy
+PYTHON_GIL=0 python -m pytest scripts/test.py -s -x -Wd -k gil
 ```
 
 Here, `-s` will output the logs.
@@ -234,7 +249,7 @@ irm https://deno.land/install.ps1 | iex               # Windows
 Testing:
 
 ```sh
-deno test --allow-read
+deno test -A
 ```
 
 ### Bun

package/simsimd/Cargo.lock

@@ -496,7 +496,7 @@ dependencies = [
 
 [[package]]
 name = "simsimd"
-version = "6.2.3"
+version = "6.4.10"
 dependencies = [
  "cc",
  "criterion",

package/simsimd/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "simsimd"
 description = "Portable mixed-precision BLAS-like vector math library for x86 and ARM"
-version = "6.2.3"
+version = "6.4.10"
 edition = "2021"
 license = "Apache-2.0"
 authors = ["Ash Vardanian <1983160+ashvardanian@users.noreply.github.com>"]

package/simsimd/README.md

@@ -190,7 +190,7 @@ You can learn more about the technical implementation details in the following b
 
   <!-- Euclidean distance with different precision level -->
   <tr>
-    <td colspan="4" align="center">eculidean distance between 1536d vectors in <code>int8</code></td>
+    <td colspan="4" align="center">euclidean distance between 1536d vectors in <code>int8</code></td>
   </tr>
   <tr>
     <td align="center"> <!-- scipy.spatial.distance.sqeuclidean -->
@@ -207,7 +207,7 @@ You can learn more about the technical implementation details in the following b
     </td>
   </tr>
   <tr>
-    <td colspan="4" align="center">eculidean distance between 1536d vectors in <code>bfloat16</code></td>
+    <td colspan="4" align="center">euclidean distance between 1536d vectors in <code>bfloat16</code></td>
   </tr>
   <tr>
     <td align="center"> <!-- scipy.spatial.distance.sqeuclidean -->
@@ -223,7 +223,7 @@ You can learn more about the technical implementation details in the following b
     </td>
   </tr>
   <tr>
-    <td colspan="4" align="center">eculidean distance between 1536d vectors in <code>float16</code></td>
+    <td colspan="4" align="center">euclidean distance between 1536d vectors in <code>float16</code></td>
   </tr>
   <tr>
     <td align="center"> <!-- scipy.spatial.distance.sqeuclidean -->
@@ -240,7 +240,7 @@ You can learn more about the technical implementation details in the following b
     </td>
   </tr>
   <tr>
-    <td colspan="4" align="center">eculidean distance between 1536d vectors in <code>float32</code></td>
+    <td colspan="4" align="center">euclidean distance between 1536d vectors in <code>float32</code></td>
   </tr>
   <tr>
     <td align="center"> <!-- scipy.spatial.distance.sqeuclidean -->
@@ -257,7 +257,7 @@ You can learn more about the technical implementation details in the following b
     </td>
   </tr>
   <tr>
-    <td colspan="4" align="center">eculidean distance between 1536d vectors in <code>float64</code></td>
+    <td colspan="4" align="center">euclidean distance between 1536d vectors in <code>float64</code></td>
   </tr>
   <tr>
     <td align="center"> <!-- scipy.spatial.distance.sqeuclidean -->
@@ -491,7 +491,7 @@ slow_output_color = (alpha * light_intensity * diffuse_component + beta * specul
 
 By default, computations use a single CPU core.
 To override this behavior, use the `threads` argument.
-Set it to `0` to use all available CPU cores.
+Set it to `0` to use all available CPU cores and let the underlying C library manage the thread pool.
 Here is an example of dealing with large sets of binary vectors:
 
 ```py
@@ -507,9 +507,42 @@ distances = simsimd.cdist(matrix1, matrix2,
 )
 ```
 
+Alternatively, when using free-threading Python 3.13t builds, one can combine single-threaded SimSIMD operations with Python's `concurrent.futures.ThreadPoolExecutor` to parallelize the computations.
 By default, the output distances will be stored in double-precision `float64` floating-point numbers.
 That behavior may not be space-efficient, especially if you are computing the hamming distance between short binary vectors, that will generally fit into 8x smaller `uint8` or `uint16` types.
-To override this behavior, use the `dtype` argument.
+To override this behavior, use the `out_dtype` argument, or consider pre-allocating the output array and passing it to the `out` argument.
+A more complete example may look like this:
+
+```py
+from multiprocessing import cpu_count
+from concurrent.futures import ThreadPoolExecutor
+from simsimd import cosine
+import numpy as np
+
+# Generate large dataset
+vectors_a = np.random.rand(100_000, 1536).astype(np.float32)
+vectors_b = np.random.rand(100_000, 1536).astype(np.float32)
+distances = np.zeros((100_000,), dtype=np.float32)
+
+def compute_batch(start_idx, end_idx):
+    batch_a = vectors_a[start_idx:end_idx]
+    batch_b = vectors_b[start_idx:end_idx]
+    cosine(batch_a, batch_b, out=distances[start_idx:end_idx])
+
+# Use all CPU cores with true parallelism (no GIL!)
+num_threads = cpu_count()
+chunk_size = len(vectors_a) // num_threads
+
+with ThreadPoolExecutor(max_workers=num_threads) as executor:
+    futures = []
+    for i in range(num_threads):
+        start_idx = i * chunk_size
+        end_idx = (i + 1) * chunk_size if i < num_threads - 1 else len(vectors_a)
+        futures.append(executor.submit(compute_batch, start_idx, end_idx))
+
+    # Collect results from all threads
+    results = [future.result() for future in futures]            
+```                                                               
 
 ### Helper Functions
 
@@ -825,14 +858,17 @@ Simplest of all, you can include the headers, and the compiler will automaticall
 #include <simsimd/simsimd.h>
 
 int main() {
+    simsimd_flush_denormals(); // Optional, to avoid performance penalties on denormal numbers
+
     simsimd_f32_t vector_a[1536];
     simsimd_f32_t vector_b[1536];
-    simsimd_kernel_punned_t distance_function = simsimd_metric_punned(
+    simsimd_kernel_punned_t metric_punned = simsimd_metric_punned(
         simsimd_metric_cos_k,   // Metric kind, like the angular cosine distance
         simsimd_datatype_f32_k, // Data type, like: f16, f32, f64, i8, b8, and complex variants
         simsimd_cap_any_k);     // Which CPU capabilities are we allowed to use
     simsimd_distance_t distance;
-    distance_function(vector_a, vector_b, 1536, &distance);
+    simsimd_metric_dense_punned_t metric = (simsimd_metric_dense_punned_t)metric_punned;
+    metric(vector_a, vector_b, 1536, &distance);
     return 0;
 }
 ```
@@ -1384,3 +1420,7 @@ $ grep -oP 'SIMSIMD_PUBLIC void simsimd_\w+_\w+_\w+\(' include/simsimd/*.h | sor
 > include/simsimd/binary.h:SIMSIMD_PUBLIC void simsimd_jaccard_b8_serial(
 > include/simsimd/binary.h:SIMSIMD_PUBLIC void simsimd_jaccard_b8_sve(
 ```
+
+## License
+
+Feel free to use the project under Apache 2.0 or the Three-clause BSD license at your preference.

package/simsimd/build.rs

@@ -1,4 +1,4 @@
-fn main() {
+fn main() -> Result<(), cc::Error> {
     let mut build = cc::Build::new();
 
     build
@@ -12,7 +12,7 @@ fn main() {
         .flag("-pedantic") // Ensure strict compliance with the C standard
         .warnings(false);
 
-    if build.try_compile("simsimd").is_err() {
+    if let Err(e) = build.try_compile("simsimd") {
         print!("cargo:warning=Failed to compile with all SIMD backends...");
 
         let target_arch = std::env::var("CARGO_CFG_TARGET_ARCH").unwrap_or_default();
@@ -39,9 +39,11 @@ fn main() {
             ],
         };
 
+        let mut result = Err(e);
         for flag in flags_to_try.iter() {
             build.define(flag, "0");
-            if build.try_compile("simsimd").is_ok() {
+            result = build.try_compile("simsimd");
+            if result.is_ok() {
                 break;
             }
 
@@ -51,6 +53,7 @@ fn main() {
                 flag
             );
         }
+        result?;
     }
 
     println!("cargo:rerun-if-changed=c/lib.c");
@@ -62,4 +65,5 @@ fn main() {
     println!("cargo:rerun-if-changed=include/simsimd/probability.h");
     println!("cargo:rerun-if-changed=include/simsimd/binary.h");
     println!("cargo:rerun-if-changed=include/simsimd/types.h");
+    Ok(())
 }

package/simsimd/c/lib.c

@@ -241,6 +241,7 @@ SIMSIMD_DYNAMIC int simsimd_uses_sapphire(void) { return (simsimd_capabilities()
 SIMSIMD_DYNAMIC int simsimd_uses_turin(void) { return (simsimd_capabilities() & simsimd_cap_turin_k) != 0; }
 SIMSIMD_DYNAMIC int simsimd_uses_sierra(void) { return (simsimd_capabilities() & simsimd_cap_sierra_k) != 0; }
 SIMSIMD_DYNAMIC int simsimd_uses_dynamic_dispatch(void) { return 1; }
+SIMSIMD_DYNAMIC int simsimd_flush_denormals(void) { return _simsimd_flush_denormals(); }
 
 SIMSIMD_DYNAMIC simsimd_capability_t simsimd_capabilities(void) {
     //! The latency of the CPUID instruction can be over 100 cycles, so we cache the result.
@@ -254,7 +255,11 @@ SIMSIMD_DYNAMIC simsimd_capability_t simsimd_capabilities(void) {
     // with dummy inputs:
     simsimd_distance_t dummy_results_buffer[2];
     simsimd_distance_t *dummy_results = &dummy_results_buffer[0];
-    void *x = 0;
+
+    // Passing `NULL` as `x` will trigger all kinds of `nonull` warnings on GCC.
+    typedef double largest_scalar_t;
+    largest_scalar_t dummy_input[1];
+    void *x = &dummy_input[0];
 
     // Dense:
     simsimd_dot_i8((simsimd_i8_t *)x, (simsimd_i8_t *)x, 0, dummy_results);

package/simsimd/include/simsimd/binary.h

@@ -13,7 +13,7 @@
  *  - x86: Haswell, Ice Lake
  *
  *  The hardest part of optimizing binary similarity measures is the population count operation.
- *  It's natively supported by almost every insrtuction set, but the throughput and latency can
+ *  It's natively supported by almost every instruction set, but the throughput and latency can
  *  be suboptimal. There are several ways to optimize this operation:
  *
  *  - Lookup tables, mostly using nibbles (4-bit lookups)
@@ -107,8 +107,8 @@ SIMSIMD_PUBLIC void simsimd_jaccard_b8_serial(simsimd_b8_t const *a, simsimd_b8_
 #if _SIMSIMD_TARGET_ARM
 #if SIMSIMD_TARGET_NEON
 #pragma GCC push_options
-#pragma GCC target("arch=armv8.2-a+simd")
-#pragma clang attribute push(__attribute__((target("arch=armv8.2-a+simd"))), apply_to = function)
+#pragma GCC target("arch=armv8-a+simd")
+#pragma clang attribute push(__attribute__((target("arch=armv8-a+simd"))), apply_to = function)
 
 SIMSIMD_INTERNAL simsimd_u32_t _simsimd_reduce_u8x16_neon(uint8x16_t vec) {
     // Split the vector into two halves and widen to `uint16x8_t`

package/simsimd/include/simsimd/dot.h

@@ -244,8 +244,8 @@ SIMSIMD_MAKE_COMPLEX_VDOT(accurate, bf16c, f64, SIMSIMD_BF16_TO_F32) // simsimd_
 #if _SIMSIMD_TARGET_ARM
 #if SIMSIMD_TARGET_NEON
 #pragma GCC push_options
-#pragma GCC target("arch=armv8.2-a+simd")
-#pragma clang attribute push(__attribute__((target("arch=armv8.2-a+simd"))), apply_to = function)
+#pragma GCC target("arch=armv8-a+simd")
+#pragma clang attribute push(__attribute__((target("arch=armv8-a+simd"))), apply_to = function)
 
 SIMSIMD_INTERNAL float32x4_t _simsimd_partial_load_f32x4_neon(simsimd_f32_t const *x, simsimd_size_t n) {
     union {

package/simsimd/include/simsimd/elementwise.h

@@ -1469,10 +1469,19 @@ simsimd_fma_bf16_skylake_cycle:
 
 #if SIMSIMD_TARGET_SAPPHIRE
 #pragma GCC push_options
-#pragma GCC target("avx2", "avx512f", "avx512vl", "bmi2", "avx512bw", "avx512fp16")
-#pragma clang attribute push(__attribute__((target("avx2,avx512f,avx512vl,bmi2,avx512bw,avx512fp16"))), \
+#pragma GCC target("avx2", "avx512f", "avx512vl", "bmi2", "avx512bw", "avx512fp16", "f16c")
+#pragma clang attribute push(__attribute__((target("avx2,avx512f,avx512vl,bmi2,avx512bw,avx512fp16,f16c"))), \
                              apply_to = function)
 
+/**
+ *  Using `_mm512_set1_ph((_Float16)1.f)` results in compilation warnings if we are pedantic.
+ *  https://www.intel.com/content/www/us/en/docs/cpp-compiler/developer-guide-reference/2021-8/details-about-intrinsics-for-half-floats.html
+ */
+SIMSIMD_INTERNAL __m512h _mm512_set1_ph_from_ps(float a) {
+    unsigned short h = _cvtss_sh(a, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC);
+    return (__m512h)_mm512_set1_epi16(h);
+}
+
 SIMSIMD_PUBLIC void simsimd_sum_f16_sapphire(simsimd_f16_t const *a, simsimd_f16_t const *b, simsimd_size_t n,
                                              simsimd_f16_t *result) {
     __mmask32 mask = 0xFFFFFFFF;
@@ -1500,7 +1509,7 @@ SIMSIMD_PUBLIC void simsimd_scale_f16_sapphire(simsimd_f16_t const *a, simsimd_s
                                                simsimd_f16_t *result) {
 
     __mmask32 mask = 0xFFFFFFFF;
-    __m512h alpha_vec = _mm512_set1_ph((_Float16)alpha);
+    __m512h alpha_vec = _mm512_set1_ph_from_ps(alpha);
     __m512h a_f16_vec, b_f16_vec;
     __m512h sum_f16_vec;
 simsimd_scale_f16_sapphire_cycle:
@@ -1540,8 +1549,8 @@ SIMSIMD_PUBLIC void simsimd_wsum_f16_sapphire(                        //
 
     // The general case.
     __mmask32 mask = 0xFFFFFFFF;
-    __m512h alpha_vec = _mm512_set1_ph((_Float16)alpha);
-    __m512h beta_vec = _mm512_set1_ph((_Float16)beta);
+    __m512h alpha_vec = _mm512_set1_ph_from_ps(alpha);
+    __m512h beta_vec = _mm512_set1_ph_from_ps(beta);
     __m512h a_f16_vec, b_f16_vec;
     __m512h a_scaled_f16_vec, sum_f16_vec;
 simsimd_wsum_f16_sapphire_cycle:
@@ -1568,8 +1577,8 @@ SIMSIMD_PUBLIC void simsimd_fma_f16_sapphire(
     simsimd_distance_t alpha, simsimd_distance_t beta, simsimd_f16_t *result) {
 
     __mmask32 mask = 0xFFFFFFFF;
-    __m512h alpha_vec = _mm512_set1_ph((_Float16)alpha);
-    __m512h beta_vec = _mm512_set1_ph((_Float16)beta);
+    __m512h alpha_vec = _mm512_set1_ph_from_ps(alpha);
+    __m512h beta_vec = _mm512_set1_ph_from_ps(beta);
     __m512h a_f16_vec, b_f16_vec, c_f16_vec;
     __m512h ab_f16_vec, ab_scaled_f16_vec, sum_f16_vec;
 simsimd_fma_f16_sapphire_cycle:
@@ -1619,7 +1628,7 @@ simsimd_sum_u8_sapphire_cycle:
 SIMSIMD_PUBLIC void simsimd_scale_u8_sapphire(simsimd_u8_t const *a, simsimd_size_t n, simsimd_distance_t alpha,
                                               simsimd_u8_t *result) {
     __mmask64 mask = 0xFFFFFFFFFFFFFFFFull;
-    __m512h alpha_vec = _mm512_set1_ph((_Float16)alpha);
+    __m512h alpha_vec = _mm512_set1_ph_from_ps(alpha);
     __m512i a_u8_vec, b_u8_vec, sum_u8_vec;
     __m512h a_f16_low_vec, a_f16_high_vec;
     __m512h a_scaled_f16_low_vec, a_scaled_f16_high_vec, sum_f16_low_vec, sum_f16_high_vec;
@@ -1670,8 +1679,8 @@ SIMSIMD_PUBLIC void simsimd_wsum_u8_sapphire(                       //
 
     // The general case.
     __mmask64 mask = 0xFFFFFFFFFFFFFFFFull;
-    __m512h alpha_vec = _mm512_set1_ph((_Float16)alpha);
-    __m512h beta_vec = _mm512_set1_ph((_Float16)beta);
+    __m512h alpha_vec = _mm512_set1_ph_from_ps(alpha);
+    __m512h beta_vec = _mm512_set1_ph_from_ps(beta);
     __m512i a_u8_vec, b_u8_vec, sum_u8_vec;
     __m512h a_f16_low_vec, a_f16_high_vec, b_f16_low_vec, b_f16_high_vec;
     __m512h a_scaled_f16_low_vec, a_scaled_f16_high_vec, sum_f16_low_vec, sum_f16_high_vec;
@@ -1739,7 +1748,7 @@ SIMSIMD_PUBLIC void simsimd_scale_i8_sapphire(simsimd_i8_t const *a, simsimd_siz
                                               simsimd_i8_t *result) {
 
     __mmask64 mask = 0xFFFFFFFFFFFFFFFFull;
-    __m512h alpha_vec = _mm512_set1_ph((_Float16)alpha);
+    __m512h alpha_vec = _mm512_set1_ph_from_ps(alpha);
     __m512i a_i8_vec, sum_i8_vec;
     __m512h a_f16_low_vec, a_f16_high_vec;
     __m512h sum_f16_low_vec, sum_f16_high_vec;
@@ -1791,8 +1800,8 @@ SIMSIMD_PUBLIC void simsimd_wsum_i8_sapphire(                       //
 
     // The general case.
     __mmask64 mask = 0xFFFFFFFFFFFFFFFFull;
-    __m512h alpha_vec = _mm512_set1_ph((_Float16)alpha);
-    __m512h beta_vec = _mm512_set1_ph((_Float16)beta);
+    __m512h alpha_vec = _mm512_set1_ph_from_ps(alpha);
+    __m512h beta_vec = _mm512_set1_ph_from_ps(beta);
     __m512i a_i8_vec, b_i8_vec, sum_i8_vec;
     __m512h a_f16_low_vec, a_f16_high_vec, b_f16_low_vec, b_f16_high_vec;
     __m512h a_scaled_f16_low_vec, a_scaled_f16_high_vec, sum_f16_low_vec, sum_f16_high_vec;
@@ -1836,8 +1845,8 @@ SIMSIMD_PUBLIC void simsimd_fma_i8_sapphire(
     simsimd_distance_t alpha, simsimd_distance_t beta, simsimd_i8_t *result) {
 
     __mmask64 mask = 0xFFFFFFFFFFFFFFFF;
-    __m512h alpha_vec = _mm512_set1_ph((_Float16)alpha);
-    __m512h beta_vec = _mm512_set1_ph((_Float16)beta);
+    __m512h alpha_vec = _mm512_set1_ph_from_ps(alpha);
+    __m512h beta_vec = _mm512_set1_ph_from_ps(beta);
     __m512i a_i8_vec, b_i8_vec, c_i8_vec, sum_i8_vec;
     __m512h a_f16_low_vec, a_f16_high_vec, b_f16_low_vec, b_f16_high_vec;
     __m512h c_f16_low_vec, c_f16_high_vec, ab_f16_low_vec, ab_f16_high_vec;
@@ -1889,8 +1898,8 @@ SIMSIMD_PUBLIC void simsimd_fma_u8_sapphire(
     simsimd_distance_t alpha, simsimd_distance_t beta, simsimd_u8_t *result) {
 
     __mmask64 mask = 0xFFFFFFFFFFFFFFFF;
-    __m512h alpha_vec = _mm512_set1_ph((_Float16)alpha);
-    __m512h beta_vec = _mm512_set1_ph((_Float16)beta);
+    __m512h alpha_vec = _mm512_set1_ph_from_ps(alpha);
+    __m512h beta_vec = _mm512_set1_ph_from_ps(beta);
     __m512i a_u8_vec, b_u8_vec, c_u8_vec, sum_u8_vec;
     __m512h a_f16_low_vec, a_f16_high_vec, b_f16_low_vec, b_f16_high_vec;
     __m512h c_f16_low_vec, c_f16_high_vec, ab_f16_low_vec, ab_f16_high_vec;