usearch 2.9.1 → 2.10.0

package/simsimd/package.json

@@ -1,61 +0,0 @@
-{
-  "name": "simsimd",
-  "version": "3.8.0",
-  "description": "Fastest SIMD-Accelerated Vector Similarity Functions for x86 and Arm",
-  "homepage": "https://github.com/ashvardanian/simsimd",
-  "author": "Ash Vardanian",
-  "license": "Apache 2.0",
-  "keywords": [
-    "vector",
-    "distance",
-    "similarity",
-    "search",
-    "ai",
-    "math",
-    "avx2",
-    "avx512",
-    "neon",
-    "sve",
-    "arm",
-    "x86",
-    "simd",
-    "f16"
-  ],
-  "scripts": {
-    "install": "node-gyp-build",
-    "prebuild-single": "prebuildify --napi --strip --target=10.4.0",
-    "prebuild-arm64": "prebuildify --arch arm64 --napi --strip --target=10.4.0",
-    "prebuild-darwin-x64+arm64": "prebuildify --arch arm64+x64 --napi --strip --target=10.4.0",
-    "build-js": "rm -fr javascript/dist/* && tsc -p javascript/tsconfig-esm.json && tsc -p javascript/tsconfig-cjs.json && cp javascript/dist-package-esm.json javascript/dist/esm/package.json && cp javascript/dist-package-cjs.json javascript/dist/cjs/package.json",
-    "test": "node --test ./javascript/test.mjs",
-    "bench": "node ./javascript/bench.js"
-  },
-  "main": "javascript/dist/cjs/simsimd.js",
-  "module": "javascript/dist/esm/simsimd.js",
-  "exports": {
-    ".": {
-      "import": "./javascript/dist/esm/simsimd.js",
-      "require": "./javascript/dist/cjs/simsimd.js"
-    }
-  },
-  "engines": {
-    "node": "~10 >=10.20 || >=12.17"
-  },
-  "dependencies": {
-    "@types/node": "^20.10.7",
-    "bindings": "^1.5.0",
-    "node-addon-api": "^3.2.1",
-    "node-gyp-build": "^4.8.0"
-  },
-  "devDependencies": {
-    "@types/bindings": "^1.5.5",
-    "node-gyp": "^10.0.1",
-    "prebuildify": "^6.0.0",
-    "typescript": "^5.3.3"
-  },
-  "optionalDependencies": {
-    "benchmark": "^2.1.4",
-    "mathjs": "^11.11.2",
-    "usearch": "^2.8.15"
-  }
-}

package/simsimd/rust/benches/cosine.rs

@@ -1,27 +0,0 @@
-use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
-use simsimd::SimSIMD;
-
-mod native;
-
-const DIMENSIONS: usize = 1536;
-
-pub fn cosine_benchmark(c: &mut Criterion) {
-    let inputs: (Vec<f32>, Vec<f32>) = (
-        native::generate_random_vector(DIMENSIONS),
-        native::generate_random_vector(DIMENSIONS),
-    );
-
-    let mut group = c.benchmark_group("SIMD Cosine");
-
-    for i in 0..=5 {
-        group.bench_with_input(BenchmarkId::new("SimSIMD", i), &i, |b, _| {
-            b.iter(|| SimSIMD::cosine(&inputs.0, &inputs.1))
-        });
-        group.bench_with_input(BenchmarkId::new("Rust Native", i), &i, |b, _| {
-            b.iter(|| native::cosine_similarity_cpu(&inputs.0, &inputs.1))
-        });
-    }
-}
-
-criterion_group!(benches, cosine_benchmark);
-criterion_main!(benches);

package/simsimd/rust/benches/native.rs

@@ -1,27 +0,0 @@
-#![allow(unused)]
-use rand::Rng;
-
-pub(crate) fn generate_random_vector(dim: usize) -> Vec<f32> {
-    (0..dim).map(|_| rand::thread_rng().gen()).collect()
-}
-
-pub(crate) fn cosine_similarity_cpu(a: &[f32], b: &[f32]) -> Option<f32> {
-    if a.len() != b.len() {
-        return None;
-    }
-
-    let dot_product: f32 = a.iter().zip(b.iter()).map(|(a, b)| a * b).sum();
-    let norm_a: f32 = a.iter().map(|a| a.powf(2.0)).sum();
-    let norm_b: f32 = b.iter().map(|b| b.powf(2.0)).sum();
-
-    Some(1.0 - (dot_product / (norm_a.sqrt() * norm_b.sqrt())))
-}
-
-pub(crate) fn squared_euclidean_cpu(a: &[f32], b: &[f32]) -> f32 {
-    assert_eq!(a.len(), b.len());
-
-    a.iter()
-        .zip(b.iter())
-        .map(|(x, y)| ((*x) - (*y)) * ((*x) - (*y)))
-        .fold(0.0, ::std::ops::Add::add)
-}

package/simsimd/rust/benches/sqeuclidean.rs

@@ -1,27 +0,0 @@
-use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
-use simsimd::SimSIMD;
-
-mod native;
-
-const DIMENSIONS: usize = 1536;
-
-pub fn sqeuclidean_benchmark(c: &mut Criterion) {
-    let inputs: (Vec<f32>, Vec<f32>) = (
-        native::generate_random_vector(DIMENSIONS),
-        native::generate_random_vector(DIMENSIONS),
-    );
-
-    let mut group = c.benchmark_group("SIMD SqEuclidean");
-
-    for i in 0..=5 {
-        group.bench_with_input(BenchmarkId::new("SimSIMD", i), &i, |b, _| {
-            b.iter(|| SimSIMD::sqeuclidean(&inputs.0, &inputs.1))
-        });
-        group.bench_with_input(BenchmarkId::new("Rust Native", i), &i, |b, _| {
-            b.iter(|| native::squared_euclidean_cpu(&inputs.0, &inputs.1))
-        });
-    }
-}
-
-criterion_group!(benches, sqeuclidean_benchmark);
-criterion_main!(benches);

package/simsimd/rust/lib.c

@@ -1,68 +0,0 @@
-#include <simsimd/simsimd.h>
-
-simsimd_capability_t cached_capabilities(void) {
-    static simsimd_capability_t static_capabilities = 0;
-    if (static_capabilities == 0)
-        static_capabilities = simsimd_capabilities();
-    return static_capabilities;
-}
-
-simsimd_f32_t cosine_i8(simsimd_i8_t const* a, simsimd_i8_t const* b, simsimd_size_t d) {
-    static simsimd_metric_punned_t metric = 0;
-    if (metric == 0) {
-        simsimd_capability_t used_capability;
-        simsimd_find_metric_punned(simsimd_metric_cosine_k, simsimd_datatype_i8_k, cached_capabilities(),
-                                   simsimd_cap_any_k, &metric, &used_capability);
-    }
-    return metric(a, b, d, d);
-}
-
-simsimd_f32_t cosine_f32(simsimd_f32_t const* a, simsimd_f32_t const* b, simsimd_size_t d) {
-    static simsimd_metric_punned_t metric = 0;
-    if (metric == 0) {
-        simsimd_capability_t used_capability;
-        simsimd_find_metric_punned(simsimd_metric_cosine_k, simsimd_datatype_f32_k, cached_capabilities(),
-                                   simsimd_cap_any_k, &metric, &used_capability);
-    }
-    return metric(a, b, d, d);
-}
-
-simsimd_f32_t inner_i8(simsimd_i8_t const* a, simsimd_i8_t const* b, simsimd_size_t d) {
-    static simsimd_metric_punned_t metric = 0;
-    if (metric == 0) {
-        simsimd_capability_t used_capability;
-        simsimd_find_metric_punned(simsimd_metric_inner_k, simsimd_datatype_i8_k, cached_capabilities(),
-                                   simsimd_cap_any_k, &metric, &used_capability);
-    }
-    return metric(a, b, d, d);
-}
-
-simsimd_f32_t inner_f32(simsimd_f32_t const* a, simsimd_f32_t const* b, simsimd_size_t d) {
-    static simsimd_metric_punned_t metric = 0;
-    if (metric == 0) {
-        simsimd_capability_t used_capability;
-        simsimd_find_metric_punned(simsimd_metric_inner_k, simsimd_datatype_f32_k, cached_capabilities(),
-                                   simsimd_cap_any_k, &metric, &used_capability);
-    }
-    return metric(a, b, d, d);
-}
-
-simsimd_f32_t sqeuclidean_i8(simsimd_i8_t const* a, simsimd_i8_t const* b, simsimd_size_t d) {
-    static simsimd_metric_punned_t metric = 0;
-    if (metric == 0) {
-        simsimd_capability_t used_capability;
-        simsimd_find_metric_punned(simsimd_metric_sqeuclidean_k, simsimd_datatype_i8_k, cached_capabilities(),
-                                   simsimd_cap_any_k, &metric, &used_capability);
-    }
-    return metric(a, b, d, d);
-}
-
-simsimd_f32_t sqeuclidean_f32(simsimd_f32_t const* a, simsimd_f32_t const* b, simsimd_size_t d) {
-    static simsimd_metric_punned_t metric = 0;
-    if (metric == 0) {
-        simsimd_capability_t used_capability;
-        simsimd_find_metric_punned(simsimd_metric_sqeuclidean_k, simsimd_datatype_f32_k, cached_capabilities(),
-                                   simsimd_cap_any_k, &metric, &used_capability);
-    }
-    return metric(a, b, d, d);
-}

package/simsimd/rust/lib.rs

@@ -1,232 +0,0 @@
-//! # SimSIMD - Hardware-Accelerated Similarity Metrics and Distance Functions
-//!
-//! * Zero-dependency header-only C 99 library with bindings for Python, JavaScript and Rust.
-//! * Targets ARM NEON, SVE, x86 AVX2, AVX-512 (VNNI, FP16) hardware backends.
-//! * Zero-copy compatible with NumPy, PyTorch, TensorFlow, and other tensors.
-//! * Handles f64 double-, f32 single-, and f16 half-precision, i8 integral, and binary vectors.
-//! * Up to 200x faster than scipy.spatial.distance and numpy.inner.
-//! * Used in USearch and several DBMS products.
-//!
-//! ## Implemented distance functions include:
-//!
-//! * Euclidean (L2), Inner Distance, and Cosine (Angular) spatial distances.
-//! * Hamming (~ Manhattan) and Jaccard (~ Tanimoto) binary distances.
-//! * Kullback-Leibler and Jensen–Shannon divergences for probability distributions.
-//!
-//! The functions in this module are exposed through a trait `SimSIMD`, which is
-//! implemented for types with SIMD support (e.g., i8 and f32). The trait provides
-//! methods for computing cosine similarity, inner product, and squared Euclidean
-//! distance between slices of these types.
-//!
-//! # Example
-//!
-//! ```rust
-//! use simsimd::SimSIMD;
-//!
-//! let a = &[1, 2, 3];
-//! let b = &[4, 5, 6];
-//!
-//! // Compute cosine similarity
-//! let cosine_sim = i8::cosine(a, b);
-//!
-//! // Compute inner product
-//! let inner_product = i8::inner(a, b);
-//!
-//! // Compute squared Euclidean distance
-//! let sqeuclidean_dist = i8::sqeuclidean(a, b);
-//! ```
-//!
-//! # Safety
-//!
-//! The functions declared in the `extern "C"` block are low-level bindings to
-//! SimSIMD implementation. It is crucial to ensure that the input slices have the
-//! same length (`c` parameter) to avoid undefined behavior.
-//!
-//!
-//! # Trait Implementation
-//!
-//! The `SimSIMD` trait is implemented for types with SIMD support and provides
-//! three associated methods:
-//!
-//! - `cosine(a: &[Self], b: &[Self]) -> Option<f32>`: Computes cosine similarity between two slices.
-//! - `inner(a: &[Self], b: &[Self]) -> Option<f32>`: Computes inner product between two slices.
-//! - `sqeuclidean(a: &[Self], b: &[Self]) -> Option<f32>`: Computes squared Euclidean distance between two slices.
-//!
-#![allow(non_camel_case_types)]
-
-extern "C" {
-    /// Computes cosine similarity for i8 types.
-    fn cosine_i8(a: *const i8, b: *const i8, c: usize) -> f32;
-
-    /// Computes cosine similarity for f32 types.
-    fn cosine_f32(a: *const f32, b: *const f32, c: usize) -> f32;
-
-    /// Computes inner product for i8 types.
-    fn inner_i8(a: *const i8, b: *const i8, c: usize) -> f32;
-
-    /// Computes inner product for f32 types.
-    fn inner_f32(a: *const f32, b: *const f32, c: usize) -> f32;
-
-    /// Computes squared Euclidean distance for i8 types.
-    fn sqeuclidean_i8(a: *const i8, b: *const i8, c: usize) -> f32;
-
-    /// Computes squared Euclidean distance for f32 types.
-    fn sqeuclidean_f32(a: *const f32, b: *const f32, c: usize) -> f32;
-}
-
-/// A trait for SIMD similarity functions.
-pub trait SimSIMD
-where
-    Self: Sized,
-{
-    /// Computes cosine similarity between two slices.
-    fn cosine(a: &[Self], b: &[Self]) -> Option<f32>;
-
-    /// Computes inner product between two slices.
-    fn inner(a: &[Self], b: &[Self]) -> Option<f32>;
-
-    /// Computes squared Euclidean distance between two slices.
-    fn sqeuclidean(a: &[Self], b: &[Self]) -> Option<f32>;
-}
-
-impl SimSIMD for i8 {
-    fn cosine(a: &[Self], b: &[Self]) -> Option<f32> {
-        if a.len() != b.len() {
-            return None;
-        }
-
-        let operation = unsafe { cosine_i8(a.as_ptr(), b.as_ptr(), a.len()) };
-
-        Some(operation)
-    }
-
-    fn inner(a: &[Self], b: &[Self]) -> Option<f32> {
-        if a.len() != b.len() {
-            return None;
-        }
-
-        let operation = unsafe { inner_i8(a.as_ptr(), b.as_ptr(), a.len()) };
-
-        Some(operation)
-    }
-
-    fn sqeuclidean(a: &[Self], b: &[Self]) -> Option<f32> {
-        if a.len() != b.len() {
-            return None;
-        }
-
-        let operation = unsafe { sqeuclidean_i8(a.as_ptr(), b.as_ptr(), a.len()) };
-
-        Some(operation)
-    }
-}
-
-impl SimSIMD for f32 {
-    fn cosine(a: &[Self], b: &[Self]) -> Option<f32> {
-        if a.len() != b.len() {
-            return None;
-        }
-
-        let operation = unsafe { cosine_f32(a.as_ptr(), b.as_ptr(), a.len()) };
-
-        Some(operation)
-    }
-
-    fn inner(a: &[Self], b: &[Self]) -> Option<f32> {
-        if a.len() != b.len() {
-            return None;
-        }
-
-        let operation = unsafe { inner_f32(a.as_ptr(), b.as_ptr(), a.len()) };
-
-        Some(operation)
-    }
-
-    fn sqeuclidean(a: &[Self], b: &[Self]) -> Option<f32> {
-        if a.len() != b.len() {
-            return None;
-        }
-
-        let operation = unsafe { sqeuclidean_f32(a.as_ptr(), b.as_ptr(), a.len()) };
-
-        Some(operation)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    //
-    fn assert_almost_equal(left: f32, right: f32, tolerance: f32) {
-        let lower = right - tolerance;
-        let upper = right + tolerance;
-
-        assert!(left >= lower && left <= upper);
-    }
-
-    #[test]
-    fn test_cosine_i8() {
-        let a = &[3, 97, 127];
-        let b = &[3, 97, 127];
-
-        if let Some(result) = SimSIMD::cosine(a, b) {
-            assert_almost_equal(0.00012027938, result, 0.01);
-            println!("The result of cosine_i8 is {:.8}", result);
-        }
-    }
-
-    #[test]
-    fn test_cosine_f32() {
-        let a = &[1.0, 2.0, 3.0];
-        let b = &[1.0, 2.0, 3.0];
-
-        if let Some(result) = SimSIMD::cosine(a, b) {
-            assert_almost_equal(0.004930496, result, 0.01);
-            println!("The result of cosine_f32 is {:.8}", result);
-        }
-    }
-
-    #[test]
-    fn test_inner_i8() {
-        let a = &[1, 2, 3];
-        let b = &[4, 5, 6];
-
-        if let Some(result) = SimSIMD::inner(a, b) {
-            assert_almost_equal(0.029403687, result, 0.01);
-            println!("The result of inner_i8 is {:.8}", result);
-        }
-    }
-
-    #[test]
-    fn test_inner_f32() {
-        let a = &[1.0, 2.0, 3.0];
-        let b = &[4.0, 5.0, 6.0];
-
-        if let Some(result) = SimSIMD::inner(a, b) {
-            assert_almost_equal(-31.0, result, 0.01);
-            println!("The result of inner_f32 is {:.8}", result);
-        }
-    }
-
-    #[test]
-    fn test_sqeuclidean_i8() {
-        let a = &[1, 2, 3];
-        let b = &[4, 5, 6];
-
-        if let Some(result) = SimSIMD::sqeuclidean(a, b) {
-            assert_almost_equal(27.0, result, 0.01);
-            println!("The result of sqeuclidean_i8 is {:.8}", result);
-        }
-    }
-
-    #[test]
-    fn test_sqeuclidean_f32() {
-        let a = &[1.0, 2.0, 3.0];
-        let b = &[4.0, 5.0, 6.0];
-
-        if let Some(result) = SimSIMD::sqeuclidean(a, b) {
-            assert_almost_equal(27.0, result, 0.01);
-            println!("The result of sqeuclidean_f32 is {:.8}", result);
-        }
-    }
-}

package/sqlite/README.md

@@ -1,178 +0,0 @@
-# USearch Extensions for SQLite
-
-USearch exposes the SIMD-accelerated distance functions for SQLite databases aimed to accelerate vector search and fuzzy string matching operations.
-This includes:
-
-- [x] Cosine and Euclidean distances for float vectors,
-- [x] Jaccard and Hamming distances for binary vectors,
-- [x] Levenshtein and Hamming distances for strings,
-- [x] Haversine distance for geographical coordinates.
-
-The SIMD-acceleration covers AVX2, most subsets of AVX512, ARM NEON, and Arm SVE instruction sets, more than most BLAS libraries.
-The implementations are coming from [SimSIMD](https://github.com/ashvardanian/simsimd) and [StringZilla](https://github.com/ashvardanian/stringzilla).
-They are most efficient when vectors are stored as BLOBs, but for broader compatibility can also handle JSONs, and even separate columns containing vector elements.
-
-## Installation
-
-USearch currently ships the SQLite extensions as part of the Python wheels, so they can be obtained from PyPi.
-
-```sh
-pip install usearch # brings sqlite extensions
-```
-
-## Quickstart
-
-To USearch extensions to your SQLite database, you can use the following commands:
-
-```py
-import sqlite3
-import usearch
-
-conn = sqlite3.connect(":memory:")
-conn.enable_load_extension(True)
-conn.load_extension(usearch.sqlite)
-```
-
-Afterwards, the following script should work fine.
-
-```sql
--- Create a table with a JSON column for vectors
-CREATE TABLE vectors_table (
-    id SERIAL PRIMARY KEY,
-    vector JSON NOT NULL
-);
-
--- Insert two 3D vectors
-INSERT INTO vectors_table (id, vector)
-VALUES 
-    (42, '[1.0, 2.0, 3.0]'),
-    (43, '[4.0, 5.0, 6.0]');
-
--- Compute the distances to [7.0, 8.0, 9.0] using
--- the `distance_cosine_f32` extension function
-SELECT 
-    id, 
-    distance_cosine_f32(vt.vector, '[7.0, 8.0, 9.0]') AS distance
-FROM vectors_table AS vt;
-```
-
-### Functionality
-
-#### Strings
-
-String functions accept BLOBs and TEXTs, and return the distance as an integer.
-This includes: 
-
-- `distance_levenshtein_bytes`, 
-- `distance_levenshtein_unicode`, 
-- `distance_hamming_bytes`, 
-- `distance_hamming_unicode`.
-
-The Levenshtein distance would report the number of insertions, deletions, and substitutions required to transform one string into another, while the Hamming distance would only report the substitutons.
-When applied to strings of different length, the Hamming distance would evalute the prefix of the longer string and will add the length difference to the result.
-The `_bytes` variants compute the distance in the number of bytes, while the `_unicode` variants compute the distance in the number of Unicode code points, assuming the inputs are UTF8 encoded.
-Take a look at the following three similar looking, but distinct strings:
-
-- `école` - 6 codepoints (runes), 7 bytes.
-- `école` - 5 codepoints (runes), 6 bytes.
-- `écolé` - 5 codepoints (runes), 7 bytes.
-
-Those have three different letter "e" variants, including etter "é" as a single character, etter as "e" and an accent "´", as well as the plain letter "e".
-This would result in different distances between those strings, depending on the chosen metric.
-
-```sql
-CREATE TABLE strings_table (
-    id SERIAL PRIMARY KEY,
-    word TEXT NOT NULL
-);
-
-INSERT INTO strings_table (id, word)
-VALUES 
-    (42, 'école'),
-    (43, 'école');
-
-SELECT  
-    st.id, 
-
-    distance_levenshtein_bytes(st.word, 'écolé') AS lb,
-    distance_levenshtein_unicode(st.word, 'écolé') AS lu,
-    distance_hamming_bytes(st.word, 'écolé') AS hb,
-    distance_hamming_unicode(st.word, 'écolé') AS hu,
-
-    distance_levenshtein_bytes(st.word, 'écolé', 2) AS lbb,
-    distance_levenshtein_unicode(st.word, 'écolé', 2) AS lub,
-    distance_hamming_bytes(st.word, 'écolé', 2) AS hbb,
-    distance_hamming_unicode(st.word, 'écolé', 2) AS hub
-
-FROM strings_table AS st;
-```
-
-The last 4 columns will contain the bounded versions of the distance, which are faster to compute, thanks to the early stopping condition.
-They might be handy, if you want to accelerate search for something like an "autocomplete" feature in a search bar.
-The output will look like this:
-
-| id  | lb  | lu  | hb  | hu  | lbb | lub | hbb | hub |
-| --- | --- | --- | --- | --- | --- | --- | --- | --- |
-| 42  | 5   | 3   | 7   | 6   | 2   | 2   | 2   | 2   |
-| 43  | 2   | 1   | 2   | 1   | 2   | 1   | 2   | 1   |
-
-#### Bit Vectors
-
-If using SQLite as a feature store, you might be dealing with single-bit vectors.
-
-- `distance_hamming_binary` - the Hamming distance, meaning number of bits that differ between two vectors,
-- `distance_jaccard_binary` - the Jaccard distance, meaning the number of bits that differ between two vectors divided by the number of bits that are set in at least one of the vectors.
-
-Here is an example:
-
-```sql
-CREATE TABLE binary_vectors (
-    id SERIAL PRIMARY KEY,
-    vector BLOB NOT NULL
-);
-INSERT INTO binary_vectors (id, vector)
-VALUES 
-    (42, X'FFFFFF'), -- 111111111111111111111111 in binary
-    (43, X'000000'); -- 000000000000000000000000 in binary
-SELECT  bv.id, 
-        distance_hamming_binary(bv.vector, X'FFFF00') AS hamming_distance,
-        distance_jaccard_binary(bv.vector, X'FFFF00') AS jaccard_distance
-FROM binary_vectors AS bv;
-```
-
-#### Dense Vectors
-
-Distance functions for desnse vectors can be used on both BLOBs and JSONs.
-Every name is structured as `distance_<metric>_<type>`, where 
-
-- `<metric>` is the name of the metric, like `cosine`, `inner`, `sqeuclidean`, and `divergence`,
-- `<type>` is the type of the vector elements, like `f64`, `f32`, `f16`, and `i8`.
-
-The `cosine` metric is the cosine similarity, the `inner` metric is the inner (dot) product, the `sqeuclidean` metric is the squared Euclidean distance, and the `divergence` metric is the Jensen-Shannon divergence - the symmetric variant of the Kullback-Leibler divergence.
-
-- `distance_sqeuclidean_f64`
-- `distance_cosine_f64`
-- `distance_inner_f64`
-- `distance_divergence_f64`
-- `distance_sqeuclidean_f32`
-- `distance_cosine_f32`
-- `distance_inner_f32`
-- `distance_divergence_f32`
-- `distance_sqeuclidean_f16`
-- `distance_cosine_f16`
-- `distance_inner_f16`
-- `distance_divergence_f16`
-- `distance_sqeuclidean_i8`
-- `distance_cosine_i8`
-- `distance_inner_i8`
-- `distance_divergence_i8`
-
-#### Geographical Coordinates
-
-When dealing with geographical or other spherical coordinates, you can use:
-
-- `distance_haversine_meters` - the Haversine distance on the sphere multiplied by the Earth's radius in meters.
-
----
-
-Feel free to contribute more examples to this file 🤗