Add Euclidean distance and similarity metrics to diff command

Author: ProgramComputer

setup.py

@@ -1,12 +1,25 @@
 from setuptools import setup, find_namespace_packages
 import os
+import re
 
 # Get the absolute path of the current directory
 here = os.path.abspath(os.path.dirname(__file__))
 
+# Extract version from types.h
+def get_version():
+    types_h_path = os.path.join(here, "src", "core", "types.h")
+    with open(types_h_path, 'r') as f:
+        content = f.read()
+    
+    # Extract version string from types.h
+    match = re.search(r'#define\s+EB_VERSION_STR\s+"([^"]+)"', content)
+    if match:
+        return match.group(1)
+    return "0.1.0"  # Default if not found
+
 setup(
     name="embedding_bridge",
-    version="0.1.0",
+    version=get_version(),
     packages=find_namespace_packages(where="src/python", include=["embedding_bridge*"]),
     package_dir={"": "src/python"},
     install_requires=[

src/cli/diff.c

@@ -48,6 +48,8 @@ static bool is_valid_hash(const char* str);
 static int ends_with(const char* str, const char* suffix);
 static int check_invalid_values(const float* embedding, size_t dims);
 static float cosine_similarity(const float* vec1, const float* vec2, size_t dims);
+static float euclidean_distance(const float* vec1, const float* vec2, size_t dims);
+static float euclidean_similarity(const float* vec1, const float* vec2, size_t dims);
 
 static const char* DIFF_USAGE = 
     "Usage: eb diff <input1> <input2>\n"
@@ -105,6 +107,49 @@ static float cosine_similarity(const float *vec1, const float *vec2, size_t dims
     return similarity;
 }
 
+/* Calculate Euclidean distance between two float vectors */
+static float euclidean_distance(const float *vec1, const float *vec2, size_t dims)
+{
+    double sum = 0.0;
+    
+    DEBUG_PRINT("Calculating Euclidean distance for %zu dimensions", dims);
+    
+    for (size_t i = 0; i < dims; i++) {
+        // Check for invalid values
+        if (isnan(vec1[i]) || isnan(vec2[i]) || 
+            isinf(vec1[i]) || isinf(vec2[i])) {
+            DEBUG_PRINT("Invalid value detected at index %zu: vec1=%f, vec2=%f",
+                       i, vec1[i], vec2[i]);
+            return INFINITY;
+        }
+        
+        double diff = (double)vec1[i] - (double)vec2[i];
+        sum += diff * diff;
+    }
+    
+    DEBUG_PRINT("Euclidean distance squared: %f", sum);
+    
+    return (float)sqrt(sum);
+}
+
+/* Calculate normalized Euclidean similarity (0 to 1 scale, where 1 is identical) */
+static float euclidean_similarity(const float *vec1, const float *vec2, size_t dims)
+{
+    float distance = euclidean_distance(vec1, vec2, dims);
+    
+    if (isinf(distance) || isnan(distance)) {
+        return 0.0f;
+    }
+    
+    // Normalize to [0,1] range where 1 means identical
+    // Using a common approach: 1 / (1 + distance)
+    float similarity = 1.0f / (1.0f + distance);
+    
+    DEBUG_PRINT("Calculated normalized Euclidean similarity: %f", similarity);
+    
+    return similarity;
+}
+
 /* Load embedding from .npy file */
 static float* load_npy_embedding(const char *filepath, size_t *dims) 
 {
@@ -436,7 +481,7 @@ int cmd_diff(int argc, char *argv[])
     const char *hash1, *hash2;
     float *emb1 = NULL, *emb2 = NULL;
     size_t dims1, dims2;
-    float similarity;
+    float cos_similarity, euc_distance, euc_similarity;
     int ret = 1;  // Initialize to error state
     bool is_test = getenv("EB_TEST_MODE") != NULL;
 
@@ -454,9 +499,11 @@ int cmd_diff(int argc, char *argv[])
     /* Quick check for identical inputs */
     if (strcmp(hash1, hash2) == 0) {
         if (is_test)
-            printf("→ Similarity: 100%%");
+            printf("→ Cosine Similarity: 100%%\n→ Euclidean Distance: 0.00\n→ Euclidean Similarity: 100%%");
         else
-            printf(COLOR_BOLD_GREEN "→ Similarity: 100%%" COLOR_RESET "\n");
+            printf(COLOR_BOLD_GREEN "→ Cosine Similarity: 100%%" COLOR_RESET "\n"
+                   COLOR_BOLD_GREEN "→ Euclidean Distance: 0.00" COLOR_RESET "\n"
+                   COLOR_BOLD_GREEN "→ Euclidean Similarity: 100%%" COLOR_RESET "\n");
         return 0;
     }
 
@@ -481,16 +528,24 @@ int cmd_diff(int argc, char *argv[])
         goto cleanup;
     }
 
-    /* Calculate similarity */
-    similarity = cosine_similarity(emb1, emb2, dims1);
-    DEBUG_PRINT("Calculated raw similarity: %f", similarity);
+    /* Calculate similarities */
+    cos_similarity = cosine_similarity(emb1, emb2, dims1);
+    euc_distance = euclidean_distance(emb1, emb2, dims1);
+    euc_similarity = euclidean_similarity(emb1, emb2, dims1);
+    
+    DEBUG_PRINT("Calculated raw cosine similarity: %f", cos_similarity);
+    DEBUG_PRINT("Calculated raw Euclidean distance: %f", euc_distance);
+    DEBUG_PRINT("Calculated raw Euclidean similarity: %f", euc_similarity);
 
     /* Print result */
     if (is_test) {
-        printf("→ Similarity: %.0f%%", similarity * 100);
+        printf("→ Cosine Similarity: %.0f%%\n→ Euclidean Distance: %.2f\n→ Euclidean Similarity: %.0f%%", 
+               cos_similarity * 100, euc_distance, euc_similarity * 100);
     } else {
-        printf(COLOR_BOLD_GREEN "→ Similarity: %.0f%%" COLOR_RESET "\n", 
-               similarity * 100);
+        printf(COLOR_BOLD_GREEN "→ Cosine Similarity: %.0f%%" COLOR_RESET "\n"
+               COLOR_BOLD_GREEN "→ Euclidean Distance: %.2f" COLOR_RESET "\n"
+               COLOR_BOLD_GREEN "→ Euclidean Similarity: %.0f%%" COLOR_RESET "\n", 
+               cos_similarity * 100, euc_distance, euc_similarity * 100);
     }
     ret = 0;
 

src/cli/main.c

@@ -76,7 +76,7 @@ int main(int argc, char** argv) {
 
     // Global help shows version
     if (strcmp(argv[1], "-h") == 0 || strcmp(argv[1], "--help") == 0) {
-        printf("eb version %d\n", EB_VERSION);
+        printf("eb version %s\n", EB_VERSION_STR);
         return 0;
     }
 

src/core/types.h

@@ -9,13 +9,26 @@
 // Magic numbers for binary format
 #define EB_MAGIC_VECTOR 0x53564245  // "EBVS"
 #define EB_MAGIC_META  0x4D564245   // "EBVM"
-#define EB_VERSION     0x00000001
+// START OF SET THE VERSION HERE
+// Version components
+#define EB_VERSION_MAJOR 0
+#define EB_VERSION_MINOR 1
+#define EB_VERSION_PATCH 0
+
+// Full version as string
+#define EB_VERSION_STR "0.1.0"
+// END OF SET THE VERSION HERE
+
+
+// Full version as integer for compatibility checks
+#define EB_VERSION     ((EB_VERSION_MAJOR << 16) | (EB_VERSION_MINOR << 8) | EB_VERSION_PATCH)
 
 // Version compatibility macros
-#define EB_VERSION_MAJOR(v) ((v) >> 16)
-#define EB_VERSION_MINOR(v) ((v) & 0xFFFF)
-#define EB_MAKE_VERSION(major, minor) (((major) << 16) | (minor))
-#define EB_VERSION_COMPATIBLE(v1, v2) (EB_VERSION_MAJOR(v1) == EB_VERSION_MAJOR(v2))
+#define EB_GET_VERSION_MAJOR(v) ((v) >> 16)
+#define EB_GET_VERSION_MINOR(v) (((v) >> 8) & 0xFF)
+#define EB_GET_VERSION_PATCH(v) ((v) & 0xFF)
+#define EB_MAKE_VERSION(major, minor, patch) (((major) << 16) | ((minor) << 8) | (patch))
+#define EB_VERSION_COMPATIBLE(v1, v2) (EB_GET_VERSION_MAJOR(v1) == EB_GET_VERSION_MAJOR(v2))
 
 // Core data types
 typedef enum {