Added traditional linear search algorithm for unsorted vectors

Author: pzaino

.vscode/c_cpp_properties.json

@@ -29,7 +29,8 @@
                 "/Library/Developer/CommandLineTools/usr/include/",
                 "/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/usr/include",
                 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/include",
-                "/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/System/Library/Frameworks"
+                "/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/System/Library/Frameworks",
+                "/Library/Developer/CommandLineTools/usr/lib/clang/14.0.3/include"
             ],
             "defines": [],
             "macFrameworkPath": [

src/zvector.c

@@ -1671,10 +1671,14 @@ zvect_retval vect_sem_post(ivector v) {
 }
 
 /*
+TODO: Implement this function:
+
 static inline zvect_retval p_vect_wait_for_signal(const vector v) {
     	return (locking_disabled || (v->flags & ZV_NOLOCKING)) ? 1 : wait_for_signal(v, 3);
 }
 
+and also:
+
 inline zvect_retval vect_wait_for_signal(const vector v) {
     	return p_vect_wait_for_signal(v);
 }
@@ -2468,6 +2472,90 @@ void vect_qsort(ivector v, int (*compare_func)(const void *, const void *)) {
 		p_throw_error(rval, NULL);
 }
 
+#ifdef TRADITIONAL_BINARY_SEARCH
+static bool p_standard_binary_search(vector v, const void *key,
+                                    zvect_index *item_index,
+                                    int (*f1)(const void *, const void *));
+#else
+static bool p_adaptive_binary_search(ivector v, const void *key,
+                                    zvect_index *item_index,
+                                    int (*f1)(const void *, const void *));
+#endif
+
+/*
+ * Although if the vect_add_* doesn't belong to this group of
+ * functions, the vect_add_ordered is an exception because it
+ * requires vect_bserach and vect_qsort to be available.
+ */
+void vect_add_ordered(ivector v, const void *value,
+                      int (*f1)(const void *, const void *)) {
+	// Check parameters:
+	if (value == NULL)
+		return;
+
+	// check if the vector exists:
+	zvect_retval rval = p_vect_check(v);
+	if (rval)
+		goto VECT_ADD_ORD_JOB_DONE;
+
+#if (ZVECT_THREAD_SAFE == 1)
+	zvect_retval lock_owner = (locking_disabled || (v->flags & ZV_NOLOCKING)) ? 0 : get_mutex_lock(v, 2);
+#endif
+
+	// Few tricks to make it faster:
+	zvect_index vsize = p_vect_size(v);
+	if (vsize == 0) {
+		// If the vector is empty clearly we can just
+		// use vect_add and add the value normally!
+		vect_add(v, value);
+		goto VECT_ADD_ORD_DONE_PROCESSING;
+	}
+
+	if ((*f1)(value, v->data[v->begin + (vsize - 1)]) > 0) {
+		// If the compare function returns that
+		// the value passed should go after the
+		// last value in the vector, just do so!
+		vect_add(v, value);
+		goto VECT_ADD_ORD_DONE_PROCESSING;
+	}
+
+	// Ok previous checks didn't help us, so we need
+	// to get "heavy weapons" out and find where in
+	// the vector we should add "value":
+	zvect_index item_index = 0;
+
+	// Here is another trick:
+	// I improved adaptive binary search to ALWAYS
+	// return an index (even when it doesn't find a
+	// searched item), this works for both: regular
+	// searches which will also use the bool to
+	// know if we actually found the item in that
+	// item_index or not and the vect_add_ordered
+	// which will use item_index (which will be the
+	// place where value should have been) to insert
+	// value as an ordered item :)
+#ifdef TRADITIONAL_BINARY_SEARCH
+	p_standard_binary_search(v, value, &item_index, f1);
+#else
+	p_adaptive_binary_search(v, value, &item_index, f1);
+#endif
+
+	vect_add_at(v, value, item_index);
+
+VECT_ADD_ORD_DONE_PROCESSING:
+#if (ZVECT_THREAD_SAFE == 1)
+	if (lock_owner)
+		get_mutex_unlock(v, 2);
+#endif
+
+VECT_ADD_ORD_JOB_DONE:
+	if(rval)
+		p_throw_error(rval, NULL);
+}
+
+
+// Searching Algorithms:
+
 #ifdef TRADITIONAL_BINARY_SEARCH
 static bool p_standard_binary_search(vector v, const void *key,
                                     zvect_index *item_index,
@@ -2521,7 +2609,7 @@ static bool p_adaptive_binary_search(ivector v, const void *key,
 	bot = v->bottom;
 	top = 32;
 
-	// key >= array[bot]
+	// the following evaluation correspond to: key >= array[bot]
 	if ((*f1)(key, v->data[v->begin + bot]) >= 0) {
 		while (1) {
 			if ((bot + top) >= p_vect_size(v)) {
@@ -2530,7 +2618,7 @@ static bool p_adaptive_binary_search(ivector v, const void *key,
 			}
 			bot += top;
 
-			// the meaning of the line below is key < array[bot]
+			// the meaning of the line below is: key < array[bot]
 			if ((*f1)(key, v->data[v->begin + bot]) < 0) {
 				bot -= top;
 				break;
@@ -2546,7 +2634,7 @@ static bool p_adaptive_binary_search(ivector v, const void *key,
 			}
 			bot -= top;
 
-			// the meaning of the line below is key >= array[bot]
+			// the meaning of the line below is: key >= array[bot]
 			if ((*f1)(key, v->data[v->begin + bot]) >= 0)
 				break;
 			top *= 2;
@@ -2556,7 +2644,7 @@ static bool p_adaptive_binary_search(ivector v, const void *key,
 P_ADP_BSEARCH_MONOBOUND:
 	while (top > 3) {
 		mid = top / 2;
-		// key >= array[bot + mid]
+		// the meaning of the following statement is: key >= array[bot + mid]
 		if ((*f1)(key, v->data[v->begin + (bot + mid)]) >= 0)
 			bot += mid;
 		top -= mid;
@@ -2566,7 +2654,7 @@ static bool p_adaptive_binary_search(ivector v, const void *key,
 	v->bottom = bot;
 
 	while (top) {
-		// key == array[bot + --top]
+		// the meaning of the following statement is: key == array[bot + --top]
 		int test = (*f1)(key, v->data[v->begin + (bot + (--top))]);
 		if (test == 0) {
 			*item_index = bot + top;
@@ -2580,16 +2668,17 @@ static bool p_adaptive_binary_search(ivector v, const void *key,
 	*item_index = bot + top;
 	return false;
 }
-#endif // ! TRADITIONAL_BINARY_SEARCH
+#endif // ADAPTIVE TRADITIONAL_BINARY_SEARCH
 
 bool vect_bsearch(ivector v, const void *key,
                   int (*f1)(const void *, const void *),
                   zvect_index *item_index) {
+	*item_index = 0;
+
 	// Check parameters:
 	if ((key == NULL) || (f1 == NULL) || (p_vect_size(v) == 0))
 		return false;
 
-	*item_index = 0;
 	// check if the vector exists:
 	zvect_retval rval = p_vect_check(v);
 	if (rval)
@@ -2612,7 +2701,7 @@ bool vect_bsearch(ivector v, const void *key,
 		*item_index = 0;
 		return false;
 	}
-#endif // ! TRADITIONAL_BINARY_SEARCH
+#endif // ADAPTIVE TRADITIONAL_BINARY_SEARCH
 
 // VECT_BSEARCH_DONE_PROCESSING:
 	// TODO: Add mutex unlock
@@ -2624,71 +2713,58 @@ bool vect_bsearch(ivector v, const void *key,
 	return false;
 }
 
-/*
- * Although if the vect_add_* doesn't belong to this group of
- * functions, the vect_add_ordered is an exception because it
- * requires vect_bserach and vect_qsort to be available.
- */
-void vect_add_ordered(ivector v, const void *value,
-                      int (*f1)(const void *, const void *)) {
+// Traditional Linear Search Algorithm,
+// useful with non sorted vectors:
+bool vect_lsearch(ivector v, const void *key,
+                  int (*f1)(const void *, const void *),
+                  zvect_index *item_index) {
+	*item_index = 0;
+
 	// Check parameters:
-	if (value == NULL)
-		return;
+	if ((key == NULL) || (f1 == NULL) || (p_vect_size(v) == 0))
+		return false;
 
 	// check if the vector exists:
 	zvect_retval rval = p_vect_check(v);
 	if (rval)
-		goto VECT_ADD_ORD_JOB_DONE;
-
-#if (ZVECT_THREAD_SAFE == 1)
-	zvect_retval lock_owner = (locking_disabled || (v->flags & ZV_NOLOCKING)) ? 0 : get_mutex_lock(v, 2);
-#endif
+		goto VECT_LSEARCH_JOB_DONE;
 
-	// Few tricks to make it faster:
+	// TODO: Add mutex locking
 	zvect_index vsize = p_vect_size(v);
-	if (vsize == 0) {
-		// If the vector is empty clearly we can just
-		// use vect_add and add the value normally!
-		vect_add(v, value);
-		goto VECT_ADD_ORD_DONE_PROCESSING;
-	}
-
-	if ((*f1)(value, v->data[v->begin + (vsize - 1)]) > 0) {
-		// If the compare function returns that
-		// the value passed should go after the
-		// last value in the vector, just do so!
-		vect_add(v, value);
-		goto VECT_ADD_ORD_DONE_PROCESSING;
+	if ((vsize & (1<<0))==0 && (vsize>4)) {
+		for (register zvect_index x=0; x<vsize; x+=4) {
+			if ((*f1)(key, v->data[v->begin + x]) != 0) {
+				*item_index = x;
+				return true;
+			}
+			if ((*f1)(key, v->data[v->begin + (x+1)]) != 0) {
+				*item_index = x;
+				return true;
+			}
+			if ((*f1)(key, v->data[v->begin + (x+2)]) != 0) {
+				*item_index = x;
+				return true;
+			}
+			if ((*f1)(key, v->data[v->begin + (x+3)]) != 0) {
+				*item_index = x;
+				return true;
+			}
+		}
+	} else {
+		for (register zvect_index x=0; x<vsize; x++) {
+			if ((*f1)(key, v->data[v->begin + x]) != 0) {
+				*item_index = x;
+				return true;
+			}
+		}
 	}
 
-	// Ok previous checks didn't help us, so we need
-	// to get "heavy weapons" out and find where in
-	// the vector we should add "value":
-	zvect_index item_index = 0;
-
-	// Here is another trick:
-	// I improved adaptive binary search to ALWAYS
-	// return an index (even when it doesn't find a
-	// searched item), this works for both: regular
-	// searches which will also use the bool to
-	// know if we actually found the item in that
-	// item_index or not and the vect_add_ordered
-	// which will use item_index (which will be the
-	// place where value should have been) to insert
-	// value as an ordered item :)
-	p_adaptive_binary_search(v, value, &item_index, f1);
-
-	vect_add_at(v, value, item_index);
-
-VECT_ADD_ORD_DONE_PROCESSING:
-#if (ZVECT_THREAD_SAFE == 1)
-	if (lock_owner)
-		get_mutex_unlock(v, 2);
-#endif
-
-VECT_ADD_ORD_JOB_DONE:
-	if(rval)
+VECT_LSEARCH_JOB_DONE:
+	if (rval)
 		p_throw_error(rval, NULL);
+
+	*item_index = 0;
+	return false;
 }
 
 #endif // ZVECT_DMF_EXTENSIONS

src/zvector.h

@@ -496,6 +496,29 @@ void vect_qsort(vector const v, int (*compare_func)(const void *, const void*));
  */
 bool vect_bsearch(vector const v, const void *key, int (*f1)(const void *, const void *), zvect_index *item_index);
 
+/*
+ * vect_lsearch is a function that allows to perform
+ * traditional linear search over an ordered or not
+ * ordered vector. If the vector size is a multiple of
+ * 2 the fuction optimize the traditional loop using
+ * 4 unrolled consecutive searches, while if the vector
+ * size is odd it uses traditional loop (for now).
+ *
+ * It finds the item "key" using the comparison function
+ * "f1", which has to be provided by the user as a pointer
+ * to a user-written comparison function that accept the
+ * vector's items (as defined by the user).
+ *
+ * For example to search for the number 5 in a vector
+ * called v using a compare function called "my_compare"
+ * use:
+ * int i = 5;
+ * vect_lsearch(v, &i, my_compare);
+ */
+bool vect_lsearch(ivector v, const void *key,
+                  int (*f1)(const void *, const void *),
+                  zvect_index *item_index);
+
 /*
  * vect_add_ordered allows the insertion of new items in
  * an ordered fashion. Please note that for this to work