Actually check the values of objective in tests and temporary fix for building without openmp

Author: giuliabaldini

build_extension.py

@@ -1,3 +1,6 @@
+import os
+import subprocess
+import warnings
 from typing import Any, Dict
 
 from setuptools import Extension
@@ -21,18 +24,67 @@
     include_dirs=["kmsr"],
 )
 
-# Thank you https://github.com/dstein64/kmeans1d!
+
+def check_openmp_support() -> bool:
+    openmp_test_code = """
+    #include <omp.h>
+    #include <stdio.h>
+    int main() {
+        int nthreads;
+        #pragma omp parallel
+        {
+            nthreads = omp_get_num_threads();
+        }
+        printf("Number of threads = %d\\n", nthreads);
+        return 0;
+    }
+    """
+
+    with open("test_openmp.c", "w") as f:
+        f.write(openmp_test_code)
+
+    try:
+        # Try to compile the code with OpenMP support
+        result = subprocess.run(
+            ["gcc", "-fopenmp", "test_openmp.c", "-o", "test_openmp"],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+        )
+        if result.returncode != 0:
+            return False
+
+        # Run the compiled program
+        result = subprocess.run(
+            ["./test_openmp"], stdout=subprocess.PIPE, stderr=subprocess.PIPE
+        )
+        if result.returncode == 0:
+            return True
+        else:
+            return False
+    finally:
+        os.remove("test_openmp.c")
+        if os.path.exists("test_openmp"):
+            os.remove("test_openmp")
 
 
 class BuildExt(build_ext):
     """A custom build extension for adding -stdlib arguments for clang++."""
 
     def build_extensions(self) -> None:
+        support = check_openmp_support()
+
         # '-std=c++11' is added to `extra_compile_args` so the code can compile
         # with clang++. This works across compilers (ignored by MSVC).
         for extension in self.extensions:
             extension.extra_compile_args.append("-std=c++11")
-            extension.extra_compile_args.append("-fopenmp")
+            if support:
+                extension.extra_compile_args.append("-fopenmp")
+                extension.extra_link_args.append("-lomp")
+            else:
+                warnings.warn(
+                    "\x1b[31;20m OpenMP is not installed on this system. "
+                    "Please install it to have all the benefits from the program.\x1b[0m"
+                )
 
         try:
             build_ext.build_extensions(self)
@@ -43,7 +95,6 @@ def build_extensions(self) -> None:
             for extension in self.extensions:
                 extension.extra_compile_args.append("-stdlib=libc++")
                 extension.extra_link_args.append("-stdlib=libc++")
-                extension.extra_link_args.append("-lomp")
             build_ext.build_extensions(self)
 
 

tests/test.py

@@ -12,9 +12,54 @@ def check_cost(inertia: float, radii: np.ndarray) -> Any:
     return np.isclose(inertia, sum(radii))
 
 
+EXPECTED_VALUES = {
+    2: {  # Dim
+        2: {  # K
+            "schmidt": (45.91, 45.93),
+            "heuristic": (48.25, 48.27),
+            "gonzales": (48.25, 48.27),
+            "kmeans": (48.25, 48.27),
+        },
+        3: {
+            "schmidt": (55.86, 56.17),
+            "heuristic": (57.73, 57.75),
+            "gonzales": (57.73, 57.75),
+            "kmeans": (57.73, 57.75),
+        },
+        4: {
+            "schmidt": (50.53, 50.95),
+            "heuristic": (52.34, 52.36),
+            "gonzales": (52.34, 52.36),
+            "kmeans": (52.34, 52.36),
+        },
+    },
+    3: {
+        2: {
+            "schmidt": (41.24, 42.84),
+            "heuristic": (42.96, 42.98),
+            "gonzales": (42.96, 44.81),
+            "kmeans": (42.96, 44.81),
+        },
+        3: {
+            "schmidt": (51.79, 51.81),
+            "heuristic": (51.79, 51.81),
+            "gonzales": (51.79, 60.65),
+            "kmeans": (51.79, 73.38),
+        },
+        4: {
+            "schmidt": (66.37, 66.39),
+            "heuristic": (68.64, 68.66),
+            "gonzales": (68.64, 68.66),
+            "kmeans": (68.64, 68.66),
+        },
+    },
+}
+
+
 class TestKMSR(unittest.TestCase):
     def test_fit(self) -> None:
         random.seed(42)
+        s = "{"
         for k in range(2, 5):
             for dim in range(2, 4):
                 _, points = generate_clusters(
@@ -37,7 +82,17 @@ def test_fit(self) -> None:
                             self.assertTrue(
                                 check_cost(kmsr.inertia_, kmsr.cluster_radii_)
                             )
-                        # print(algo, sum(costs) / len(costs))
+                            assert (
+                                EXPECTED_VALUES[dim][k][algo][0]
+                                <= kmsr.inertia_
+                                <= EXPECTED_VALUES[dim][k][algo][1]
+                            ), (
+                                f"{EXPECTED_VALUES[dim][k][algo][0]} "
+                                f"<= {kmsr.inertia_} "
+                                f"<= {EXPECTED_VALUES[dim][k][algo][1]}"
+                            )
+
+        print(s)
 
 
 if __name__ == "__main__":