vectune 0.1.1

A lightweight VectorDB with Incremental Indexing, based on FreshVamana.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102


pub fn diff_ids(a: &Vec<u32>, b: &Vec<u32>) -> Vec<u32> {
  let mut result = Vec::new();
  let mut a_idx = 0;
  let mut b_idx = 0;

  while a_idx < a.len() && b_idx < b.len() {
      if a[a_idx] == b[b_idx] {
          a_idx += 1; // Skip common elements
          b_idx += 1;
      } else if a[a_idx] < b[b_idx] {
          // Elements present only in a
          result.push(a[a_idx]);
          a_idx += 1;
      } else {
          // Ignore elements that exist only in b
          b_idx += 1;
      }
  }

  // Add the remaining elements of a (since they do not exist in b)
  while a_idx < a.len() {
      result.push(a[a_idx]);
      a_idx += 1;
  }

  result
}

pub fn intersect_ids(a: &Vec<u32>, b: &Vec<u32>) -> Vec<u32> {
  let mut result = Vec::new();
  let mut a_idx = 0;
  let mut b_idx = 0;

  while a_idx < a.len() && b_idx < b.len() {
      if a[a_idx] == b[b_idx] {
          result.push(a[a_idx]);
          a_idx += 1;
          b_idx += 1;
      } else if a[a_idx] < b[b_idx] {
          a_idx += 1;
      } else {
          b_idx += 1;
      }
  }

  result
}

pub fn sort_list_by_dist(list: &mut Vec<(f32, u32, bool)>) {
  list.sort_by(|a, b| a.0.partial_cmp(&b.0).unwrap_or(std::cmp::Ordering::Less));
}

pub fn sort_list_by_dist_v1(list: &mut Vec<(f32, u32)>) {
  list.sort_by(|a, b| a.0.partial_cmp(&b.0).unwrap_or(std::cmp::Ordering::Less));
}

pub fn is_contained_in(i: &u32, vec: &Vec<(f32, u32)>) -> bool {
  !vec.iter()
      .filter(|(_, id)| *id == *i)
      .collect::<Vec<&(f32, u32)>>()
      .is_empty()
}

pub fn insert_id(value: u32, vec: &mut Vec<u32>) {
  match vec.binary_search(&value) {
      Ok(_index) => { // If already exsits
      }
      Err(index) => {
          vec.insert(index, value);
      }
  }
}

pub fn insert_dist(value: (f32, u32), vec: &mut Vec<(f32, u32)>) {
  match vec.binary_search_by(|probe| {
      probe
          .0
          .partial_cmp(&value.0)
          .unwrap_or(std::cmp::Ordering::Less)
  }) {
      Ok(index) => {
          // identify a range of groups of elements with the same f32 value
          let mut start = index;
          while start > 0 && vec[start - 1].0 == value.0 {
              start -= 1;
          }
          let mut end = index;
          while end < vec.len() - 1 && vec[end + 1].0 == value.0 {
              end += 1;
          }

          // Check for elements with the same usize value within the specified range
          if !(start..=end).any(|i| vec[i].1 == value.1) {
              vec.insert(index, value);
          }
      }
      Err(index) => {
          vec.insert(index, value);
      }
  };
}