Zero to one 0-1 bounded overflow

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "probly-search"
 description = "A lightweight full-text search engine with a fully customizable scoring function"
-version = "1.1.3"
+version = "1.2.3"
 authors = ["marcus-pousette <marcus.pousette@quantleaf.com>"]
 edition = "2018"
 license = "MIT"

src/query.rs

@@ -36,11 +36,14 @@ pub fn max_score_merger(
     score: &f64,
     previous_score: Option<&f64>,
     document_visited_for_term: bool,
+    node_visited_for_term: bool,
 ) -> f64 {
     {
         if let Some(p) = previous_score {
             if document_visited_for_term {
                 f64::max(p.to_owned(), score.to_owned())
+            } else if node_visited_for_term {
+                (p + score) / 2.
             } else {
                 p + score
             }
@@ -76,6 +79,8 @@ pub fn query<T: Eq + Hash + Clone + Debug, M, S: ScoreCalculator<T, M>>(
 ) -> Vec<QueryResult<T>> {
     let query_terms = tokenizer(query);
     let mut scores: HashMap<T, f64> = HashMap::new();
+    let mut visited_indices: HashSet<usize> = HashSet::new();
+
     for query_term_pre_filter in &query_terms {
         let query_term = filter(query_term_pre_filter);
         print!("{}", query_term);
@@ -123,15 +128,17 @@ pub fn query<T: Eq + Hash + Clone + Debug, M, S: ScoreCalculator<T, M>>(
                                             s,
                                             scores.get(key),
                                             visited_documents_for_term.contains(key),
+                                            visited_indices.contains(&term_node_index.to_idx()),
                                         );
                                         scores.insert(key.to_owned(), new_score);
-                                        visited_documents_for_term.insert(key.to_owned());
                                     }
                                 }
+                                visited_documents_for_term.insert(key.to_owned());
                                 pointer = pointer_borrowed.next;
                             }
                         }
                     }
+                    visited_indices.insert(term_node_index.to_idx());
                 }
             }
         }

src/query/score/default/zero_to_one.rs

@@ -153,6 +153,33 @@ mod tests {
             }],
         );
     }
+    #[test]
+    fn it_should_be_bounded_by_one() {
+        let mut x = build_test_index(&["abc abc"]);
+        test_score(
+            &mut x,
+            &mut new(),
+            &"abc ab".to_string(),
+            vec![QueryResult {
+                key: 0_usize,
+                score: 0.83333333333333337_f64,
+            }],
+        );
+    }
+
+    #[test]
+    fn it_should_be_bounded_by_one_2() {
+        let mut x = build_test_index(&["abc ab"]);
+        test_score(
+            &mut x,
+            &mut new(),
+            &"abc abc".to_string(),
+            vec![QueryResult {
+                key: 0_usize,
+                score: 0.5_f64,
+            }],
+        );
+    }
 
     #[test]
     fn it_should_retrieve_multiple_results() {

tests/integrations_tests.rs

@@ -34,7 +34,7 @@ fn filter(s: &str) -> String {
 
 #[test]
 pub fn test_add_query_delete_bm25() {
-    // Creat index with 2 fields
+    // Create index with 2 fields
     let mut index = create_index::<usize>(2);
 
     // Create docs from a custom Doc struct