asap_sketchlib 0.2.1

A high-performance sketching library for approximate stream processing
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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

//! Erased fast-path adapter traits for matrix-backed sketches.
//!
//! These traits let `HashSketchEnsemble` hold type-erased `Box<dyn CountMinFastOps>`
//! and `Box<dyn CountFastOps>` without knowing the concrete storage or hasher.

use crate::common::structure_utils::ToF64;
use crate::sketches::countsketch::CountSketchCounter;
use crate::{Count, CountMin, DataInput, FastPath, MatrixHashType, RegularPath, SketchHasher};
use std::ops::AddAssign;

/// Type-erased adapter for regular-path Count-Min sketches.
pub trait CountMinRegularOps {
    /// Inserts one value into the sketch.
    fn insert(&mut self, val: &DataInput);
    /// Returns the estimate as `f64`.
    fn estimate_f64(&self, val: &DataInput) -> f64;
}

/// Type-erased adapter for fast-path Count-Min sketches.
pub trait CountMinFastOps {
    /// Inserts one value into the sketch.
    fn insert(&mut self, val: &DataInput);
    /// Returns the estimate as `f64`.
    fn estimate_f64(&self, val: &DataInput) -> f64;
    /// Returns the row count.
    fn rows(&self) -> usize;
    /// Returns the column count.
    fn cols(&self) -> usize;
    /// Inserts one precomputed hash.
    fn fast_insert(&mut self, hash: &MatrixHashType);
    /// Returns the estimate for one precomputed hash.
    fn fast_estimate(&self, hash: &MatrixHashType) -> f64;
}

/// Type-erased adapter for regular-path Count Sketches.
pub trait CountRegularOps {
    /// Inserts one value into the sketch.
    fn insert(&mut self, val: &DataInput);
    /// Returns the estimate as `f64`.
    fn estimate_f64(&self, val: &DataInput) -> f64;
}

/// Type-erased adapter for fast-path Count Sketches.
pub trait CountFastOps {
    /// Inserts one value into the sketch.
    fn insert(&mut self, val: &DataInput);
    /// Returns the estimate as `f64`.
    fn estimate_f64(&self, val: &DataInput) -> f64;
    /// Returns the row count.
    fn rows(&self) -> usize;
    /// Returns the column count.
    fn cols(&self) -> usize;
    /// Inserts one precomputed hash.
    fn fast_insert(&mut self, hash: &MatrixHashType);
    /// Returns the estimate for one precomputed hash.
    fn fast_estimate(&self, hash: &MatrixHashType) -> f64;
}

impl<S> CountMinRegularOps for CountMin<S, RegularPath>
where
    S: crate::MatrixStorage + 'static,
    S::Counter: Copy + PartialOrd + From<i32> + AddAssign + ToF64 + 'static,
{
    fn insert(&mut self, val: &DataInput) {
        self.insert(val);
    }

    fn estimate_f64(&self, val: &DataInput) -> f64 {
        self.estimate(val).to_f64()
    }
}

impl<S, H> CountMinFastOps for CountMin<S, FastPath, H>
where
    H: SketchHasher<HashType = MatrixHashType> + 'static,
    S: crate::MatrixStorage + crate::FastPathHasher<H> + 'static,
    S::Counter: Copy + PartialOrd + From<i32> + AddAssign + ToF64 + 'static,
{
    fn insert(&mut self, val: &DataInput) {
        self.insert(val);
    }

    fn estimate_f64(&self, val: &DataInput) -> f64 {
        self.estimate(val).to_f64()
    }

    fn rows(&self) -> usize {
        self.rows()
    }

    fn cols(&self) -> usize {
        self.cols()
    }

    fn fast_insert(&mut self, hash: &MatrixHashType) {
        self.fast_insert_with_hash_value(hash);
    }

    fn fast_estimate(&self, hash: &MatrixHashType) -> f64 {
        self.fast_estimate_with_hash(hash).to_f64()
    }
}

impl<S> CountRegularOps for Count<S, RegularPath>
where
    S: crate::MatrixStorage + 'static,
    S::Counter: CountSketchCounter + 'static,
{
    fn insert(&mut self, val: &DataInput) {
        self.insert(val);
    }

    fn estimate_f64(&self, val: &DataInput) -> f64 {
        self.estimate(val)
    }
}

impl<S, H> CountFastOps for Count<S, FastPath, H>
where
    H: SketchHasher<HashType = MatrixHashType> + 'static,
    S: crate::MatrixStorage + crate::FastPathHasher<H> + 'static,
    S::Counter: CountSketchCounter + 'static,
{
    fn insert(&mut self, val: &DataInput) {
        self.insert(val);
    }

    fn estimate_f64(&self, val: &DataInput) -> f64 {
        self.estimate(val)
    }

    fn rows(&self) -> usize {
        self.rows()
    }

    fn cols(&self) -> usize {
        self.cols()
    }

    fn fast_insert(&mut self, hash: &MatrixHashType) {
        self.fast_insert_with_hash_value(hash);
    }

    fn fast_estimate(&self, hash: &MatrixHashType) -> f64 {
        self.fast_estimate_with_hash(hash)
    }
}