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
|
use std::collections::HashMap;
use std::collections::hash_map::DefaultHasher;
use std::hash::{Hash, Hasher};
use std::ops::{Deref, DerefMut};
use serde::{Deserialize, Serialize};
/// Represents the content of a cached file.
/// It is stored as a HashMap, because we do not
/// have to store the zeros. With that we save a lot
/// of storage.
#[derive(Default, Clone, Debug, Deserialize, Serialize)]
pub struct FileVector {
data : HashMap<u64, u64>
}
impl Deref for FileVector {
type Target = HashMap<u64, u64>;
fn deref(&self) -> &Self::Target {
&self.data
}
}
impl DerefMut for FileVector {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.data
}
}
impl FileVector {
pub fn new() -> Self {
Self { data : HashMap::new() }
}
pub fn from_words(words: Vec<String>) -> Self {
let mut data = HashMap::new();
for word in words {
let mut hasher = DefaultHasher::new();
word.hash(&mut hasher);
let k = hasher.finish();
match data.entry(k) {
std::collections::hash_map::Entry::Occupied(mut e) => {
e.insert(e.get() + 1);
}
std::collections::hash_map::Entry::Vacant(e) => {
e.insert(1);
}
}
}
Self { data }
}
}
pub fn scalar_product(a : &FileVector, b : &FileVector) -> u64 {
let mut c = 0;
for (i, x) in a.iter() {
c += x * (b.get(i).unwrap_or(&0));
}
c
}
pub fn match_vector(query : &FileVector, v : &FileVector) -> u64 {
let mut c = 0;
for (i, x) in query.iter() {
let s = x * (v.get(i).unwrap_or(&0));
if s == 0 {
return 0
} else {
c += s;
}
}
c
}
|
