Add CPP backend for search algorithms (#544)

sak-codes · web-flow · commit 1942891e292f · 2023-08-12T17:15:18.000+05:30
diff --git a/pydatastructs/linear_data_structures/_backend/cpp/algorithms/algorithms.cpp b/pydatastructs/linear_data_structures/_backend/cpp/algorithms/algorithms.cpp
@@ -14,6 +14,12 @@ static PyMethodDef algorithms_PyMethodDef[] = {
      METH_VARARGS | METH_KEYWORDS, ""},
     {"is_ordered", (PyCFunction) is_ordered,
      METH_VARARGS | METH_KEYWORDS, ""},
+    {"linear_search", (PyCFunction) linear_search,
+     METH_VARARGS | METH_KEYWORDS, ""},
+    {"binary_search", (PyCFunction) binary_search,
+     METH_VARARGS | METH_KEYWORDS, ""},
+    {"jump_search", (PyCFunction) jump_search,
+     METH_VARARGS | METH_KEYWORDS, ""},
     {NULL, NULL, 0, NULL}        /* Sentinel */
 };
 
diff --git a/pydatastructs/linear_data_structures/_backend/cpp/algorithms/misc_algorithms.hpp b/pydatastructs/linear_data_structures/_backend/cpp/algorithms/misc_algorithms.hpp
@@ -17,7 +17,6 @@ static bool is_ordered_impl(PyObject* array, size_t lower, size_t upper,
         PyObject* i1_item = PyObject_GetItem(array, i1_PyObject);
         if (i_item == Py_None || i1_item == Py_None) continue;
         if( _comp(i_item, i1_item, comp) == 1 ) {
-            printf("%d--\n", i);
             return false;
         }
     }
@@ -60,5 +59,197 @@ static PyObject* is_ordered(PyObject* self, PyObject* args, PyObject* kwds) {
     return res;
 }
 
+static PyObject* linear_search(PyObject* self, PyObject* args, PyObject* kwds) {
+    PyObject *args0 = NULL, *start = NULL, *end = NULL;
+    PyObject *value = NULL, *res = NULL, *u = NULL;
+    size_t lower, upper;
+    args0 = PyObject_GetItem(args, PyZero);
+    int is_DynamicOneDimensionalArray = _check_type(args0, &DynamicOneDimensionalArrayType);
+    int is_OneDimensionalArray = _check_type(args0, &OneDimensionalArrayType);
+    if( !is_DynamicOneDimensionalArray && !is_OneDimensionalArray ) {
+        raise_exception_if_not_array(args0);
+        return NULL;
+    }
+    start = PyObject_GetItem(kwds, PyUnicode_FromString("start"));
+    if( start == NULL ) {
+        PyErr_Clear();
+        lower = 0;
+    } else {
+        lower = PyLong_AsSize_t(start);
+    }
+    end = PyObject_GetItem(kwds, PyUnicode_FromString("end"));
+    if( end == NULL ) {
+        PyErr_Clear();
+        upper = PyObject_Length(args0) - 1;
+    } else {
+        upper = PyLong_AsSize_t(end);
+    }
+    value = PyObject_GetItem(args, PyLong_FromSize_t(1));
+    if( value == NULL ) {
+        PyErr_Format(PyExc_ValueError,
+                "Expected Value to be not NULL");
+    }
+    for (size_t i = lower;  i < upper + 1; i++) {
+        u = PyObject_GetItem(args0, PyLong_FromSize_t(i));
+        int result = PyObject_RichCompareBool(u, value, Py_EQ);
+        if ( result == -1 ) {
+            PyErr_Format(PyExc_ValueError,
+                "Unable to compare %s object with %s object.",
+                PyObject_AsString(PyObject_Repr(PyObject_Type(u))),
+                PyObject_AsString(PyObject_Repr(PyObject_Type(value)))
+            );
+        } else if (result == 1) {
+            if (i == 0) {
+                res = PyZero;
+            } else {
+                res = PyLong_FromSize_t(i);
+            }
+            Py_INCREF(res);
+            return res;
+        }
+    }
+    res = Py_None;
+    Py_INCREF(res);
+    return res;
+}
+
+static PyObject* binary_search(PyObject* self, PyObject* args, PyObject* kwds) {
+    PyObject *args0 = NULL, *start = NULL, *end = NULL;
+    PyObject *value = NULL, *res = NULL, *u = NULL, *comp = NULL;
+    size_t lower, upper;
+    args0 = PyObject_GetItem(args, PyZero);
+    int is_DynamicOneDimensionalArray = _check_type(args0, &DynamicOneDimensionalArrayType);
+    int is_OneDimensionalArray = _check_type(args0, &OneDimensionalArrayType);
+    if( !is_DynamicOneDimensionalArray && !is_OneDimensionalArray ) {
+        raise_exception_if_not_array(args0);
+        return NULL;
+    }
+    comp = PyObject_GetItem(kwds, PyUnicode_FromString("comp"));
+    if( comp == NULL ) {
+        PyErr_Clear();
+    }
+    start = PyObject_GetItem(kwds, PyUnicode_FromString("start"));
+    if( start == NULL ) {
+        PyErr_Clear();
+        lower = 0;
+    } else {
+        lower = PyLong_AsSize_t(start);
+    }
+    end = PyObject_GetItem(kwds, PyUnicode_FromString("end"));
+    if( end == NULL ) {
+        PyErr_Clear();
+        upper = PyObject_Length(args0) - 1;
+    } else {
+        upper = PyLong_AsSize_t(end);
+    }
+    value = PyObject_GetItem(args, PyLong_FromSize_t(1));
+    if( value == NULL ) {
+        PyErr_Format(PyExc_ValueError,
+                "Expected Value to be not NULL");
+    }
+
+    int left = lower, right = upper;
+    while (left <= right)
+    {
+        int middle = left/2 + right/2 + left % 2 * right % 2;
+        u = PyObject_GetItem(args0, PyLong_FromSize_t(middle));
+        int result = PyObject_RichCompareBool(u, value, Py_EQ);
+        if ( result == -1 ) {
+            PyErr_Format(PyExc_ValueError,
+                "Unable to compare %s object with %s object.",
+                PyObject_AsString(PyObject_Repr(PyObject_Type(u))),
+                PyObject_AsString(PyObject_Repr(PyObject_Type(value)))
+            );
+        } else if (result == 1) {
+            if (middle == 0) {
+                res = PyZero;
+            } else {
+                res = PyLong_FromSize_t(middle);
+            }
+            Py_INCREF(res);
+            return res;
+        }
+        if( _comp(u, value, comp) == 1 ) {
+            left = middle + 1;
+        } else {
+            right = middle - 1;
+        }
+    }
+    res = Py_None;
+    Py_INCREF(res);
+    return res;
+}
+
+static PyObject* jump_search(PyObject* self, PyObject* args, PyObject* kwds) {
+    PyObject *args0 = NULL, *start = NULL, *end = NULL;
+    PyObject *value = NULL, *res = NULL, *u = NULL, *comp = NULL;
+    size_t lower, upper;
+    args0 = PyObject_GetItem(args, PyZero);
+    int is_DynamicOneDimensionalArray = _check_type(args0, &DynamicOneDimensionalArrayType);
+    int is_OneDimensionalArray = _check_type(args0, &OneDimensionalArrayType);
+    if( !is_DynamicOneDimensionalArray && !is_OneDimensionalArray ) {
+        raise_exception_if_not_array(args0);
+        return NULL;
+    }
+    comp = PyObject_GetItem(kwds, PyUnicode_FromString("comp"));
+    if( comp == NULL ) {
+        PyErr_Clear();
+    }
+    start = PyObject_GetItem(kwds, PyUnicode_FromString("start"));
+    if( start == NULL ) {
+        PyErr_Clear();
+        lower = 0;
+    } else {
+        lower = PyLong_AsSize_t(start);
+    }
+    end = PyObject_GetItem(kwds, PyUnicode_FromString("end"));
+    if( end == NULL ) {
+        PyErr_Clear();
+        upper = PyObject_Length(args0) - 1;
+    } else {
+        upper = PyLong_AsSize_t(end);
+    }
+    value = PyObject_GetItem(args, PyLong_FromSize_t(1));
+    if( value == NULL ) {
+        PyErr_Format(PyExc_ValueError,
+                "Expected Value to be not NULL");
+    }
+    int step = int(sqrt(double(upper - lower + 1)));
+    int prev = lower;
+    int element_pos = prev;
+    u = PyObject_GetItem(args0, PyLong_FromSize_t(element_pos));
+    while (element_pos <= upper && _comp(u, value, comp) == 1) {
+        prev = element_pos;
+        element_pos += step;
+        if (element_pos > upper) {
+            break;
+        }
+        u = PyObject_GetItem(args0, PyLong_FromSize_t(element_pos));
+    }
+
+    while (prev <= upper) {
+        u = PyObject_GetItem(args0, PyLong_FromSize_t(prev));
+        int result = PyObject_RichCompareBool(u, value, Py_EQ);
+        if ( result == -1 ) {
+            PyErr_Format(PyExc_ValueError,
+                "Unable to compare %s object with %s object.",
+                PyObject_AsString(PyObject_Repr(PyObject_Type(u))),
+                PyObject_AsString(PyObject_Repr(PyObject_Type(value)))
+            );
+        } else if (result == 1) {
+            if (prev == 0) {
+                res = PyZero;
+            } else {
+                res = PyLong_FromSize_t(prev);
+            }
+            Py_INCREF(res);
+            return res;
+        }
+        prev += 1;
+    }
+    res = Py_None;
+    Py_INCREF(res);
+    return res;
+}
 
 #endif
diff --git a/pydatastructs/linear_data_structures/algorithms.py b/pydatastructs/linear_data_structures/algorithms.py
@@ -1571,8 +1571,9 @@ def linear_search(array, value, **kwargs):
 
     .. [1] https://en.wikipedia.org/wiki/Linear_search
     """
-    raise_if_backend_is_not_python(
-            linear_search, kwargs.get('backend', Backend.PYTHON))
+    backend = kwargs.pop("backend", Backend.PYTHON)
+    if backend == Backend.CPP:
+        return _algorithms.linear_search(array, value, **kwargs)
     start = kwargs.get('start', 0)
     end = kwargs.get('end', len(array) - 1)
 
@@ -1640,8 +1641,9 @@ def binary_search(array, value, **kwargs):
     This algorithm assumes that the portion of the array
     to be searched is already sorted.
     """
-    raise_if_backend_is_not_python(
-            binary_search, kwargs.get('backend', Backend.PYTHON))
+    backend = kwargs.pop("backend", Backend.PYTHON)
+    if backend == Backend.CPP:
+        return _algorithms.binary_search(array, value, **kwargs)
     start = kwargs.get('start', 0)
     end = kwargs.get('end', len(array) - 1)
     comp = kwargs.get("comp", lambda u, v: u <= v)
@@ -1717,8 +1719,9 @@ def jump_search(array, value, **kwargs):
     This algorithm assumes that the portion of the array
     to be searched is already sorted.
     """
-    raise_if_backend_is_not_python(
-            jump_search, kwargs.get('backend', Backend.PYTHON))
+    backend = kwargs.pop("backend", Backend.PYTHON)
+    if backend == Backend.CPP:
+        return _algorithms.jump_search(array, value, **kwargs)
     start = kwargs.get('start', 0)
     end = kwargs.get('end', len(array) - 1)
     comp = kwargs.get("comp", lambda u, v: u < v)
diff --git a/pydatastructs/linear_data_structures/tests/benchmarks/test_algorithms.py b/pydatastructs/linear_data_structures/tests/benchmarks/test_algorithms.py
@@ -1,7 +1,7 @@
 import random, timeit, functools, os, pytest
 from pydatastructs import (OneDimensionalArray, Backend,
     DynamicOneDimensionalArray, quick_sort, bubble_sort, selection_sort,
-    insertion_sort, is_ordered)
+    insertion_sort, is_ordered, linear_search, binary_search, jump_search)
 
 def _test_common_sort(sort, **kwargs):
     cpp = Backend.CPP
@@ -80,3 +80,31 @@ def _common(array_type, dtype, *args, **kwargs):
     # Case 3: float
     data = [random.random() * 2 * size for _ in range(size)]
     _common(OneDimensionalArray, float, data, backend=cpp)
+
+
+@pytest.mark.xfail
+def test_search():
+    cpp = Backend.CPP
+    repeat = 2
+    number = 2
+
+    size = int(os.environ.get("PYDATASTRUCTS_BENCHMARK_SIZE", "4000"))
+
+    def _common(search_func, array_type, dtype, *args, **kwargs):
+        array = array_type(dtype, *args, **kwargs)
+
+        timer_python = timeit.Timer(functools.partial(search_func, array, array[size-1]))
+        python_backend = min(timer_python.repeat(repeat, number))
+
+        backend_dict = {"backend": cpp}
+        timer_cpp = timeit.Timer(functools.partial(search_func, array, array[size-1],
+                                                   **backend_dict))
+        cpp_backend = min(timer_cpp.repeat(repeat, number))
+
+        assert cpp_backend < python_backend
+
+    # Case 1: int
+    data = [random.randint(0, 2 * size) for _ in range(size)]
+    _common(linear_search, OneDimensionalArray, int, data, backend=cpp)
+    _common(binary_search, OneDimensionalArray, int, data, backend=cpp)
+    _common(jump_search, OneDimensionalArray, int, data, backend=cpp)
diff --git a/pydatastructs/linear_data_structures/tests/test_algorithms.py b/pydatastructs/linear_data_structures/tests/test_algorithms.py
@@ -373,16 +373,16 @@ def test_next_prev_permutation():
         _, orig_array = next_permutation(prev_array)
         assert str(orig_array) == str(array)
 
-def _test_common_search(search_func, sort_array=True):
+def _test_common_search(search_func, sort_array=True, **kwargs):
     ODA = OneDimensionalArray
 
     array = ODA(int, [1, 2, 5, 7, 10, 29, 40])
     for i in range(len(array)):
-        assert i == search_func(array, array[i])
+        assert i == search_func(array, array[i], **kwargs)
 
     checker_array = [None, None, 2, 3, 4, 5, None]
     for i in range(len(array)):
-        assert checker_array[i] == search_func(array, array[i], start=2, end=5)
+        assert checker_array[i] == search_func(array, array[i], start=2, end=5, **kwargs)
 
     random.seed(1000)
 
@@ -395,16 +395,19 @@ def _test_common_search(search_func, sort_array=True):
         array = ODA(int, list(data))
 
         for i in range(len(array)):
-            assert search_func(array, array[i]) == i
+            assert search_func(array, array[i], **kwargs) == i
 
         for _ in range(50):
-            assert search_func(array, random.randint(10001, 50000)) is None
+            assert search_func(array, random.randint(10001, 50000), **kwargs) is None
 
 def test_linear_search():
     _test_common_search(linear_search, sort_array=False)
+    _test_common_search(linear_search, sort_array=False, backend=Backend.CPP)
 
 def test_binary_search():
     _test_common_search(binary_search)
+    _test_common_search(binary_search, backend=Backend.CPP)
 
 def test_jump_search():
     _test_common_search(jump_search)
+    _test_common_search(jump_search, backend=Backend.CPP)
