Fix quantiling issues
[com/gs-lite.git] / include / hfta / hfta_udaf.h
1 /* ------------------------------------------------
2 Copyright 2014 AT&T Intellectual Property
3    Licensed under the Apache License, Version 2.0 (the "License");
4    you may not use this file except in compliance with the License.
5    You may obtain a copy of the License at
6
7      http://www.apache.org/licenses/LICENSE-2.0
8
9    Unless required by applicable law or agreed to in writing, software
10    distributed under the License is distributed on an "AS IS" BASIS,
11    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12    See the License for the specific language governing permissions and
13    limitations under the License.
14  ------------------------------------------- */
15
16 #ifndef _HFTA_UDAF_H_INCLUDED_
17 #define _HFTA_UDAF_H_INCLUDED_
18
19 #include "vstring.h"
20 #include "host_tuple.h"
21 #include "gsconfig.h"
22
23 // -------------------------------------------------------------------
24 //              sum over 3 intervals : test rUDAF
25 void sum3_HFTA_AGGR_INIT_(gs_sp_t buf) ;
26 void sum3_HFTA_AGGR_UPDATE_(gs_sp_t buf, gs_uint32_t s) ;
27 void sum3_HFTA_AGGR_OUTPUT_(gs_uint32_t *result, gs_sp_t buf) ;
28 void sum3_HFTA_AGGR_DESTROY_(gs_sp_t buf) ;
29 void sum3_HFTA_AGGR_REINIT_( gs_sp_t buf) ;
30
31
32 // -------------------------------------------------------------------
33 //              running sum over arbitrary intervals.
34 void moving_sum_udaf_HFTA_AGGR_INIT_(gs_sp_t buf) ;
35 void moving_sum_udaf_HFTA_AGGR_UPDATE_(gs_sp_t buf, gs_uint32_t s, gs_uint32_t N) ;
36 void moving_sum_udaf_HFTA_AGGR_OUTPUT_(gs_uint64_t *result, gs_sp_t buf) ;
37 void moving_sum_udaf_HFTA_AGGR_DESTROY_(gs_sp_t buf) ;
38 void moving_sum_udaf_HFTA_AGGR_REINIT_( gs_sp_t buf) ;
39
40 #define super_moving_sum_udaf_HFTA_AGGR_INIT_ moving_sum_udaf_HFTA_AGGR_INIT_
41 void super_moving_sum_udaf_HFTA_AGGR_UPDATE_(gs_sp_t buf, gs_uint64_t s) ;
42 #define super_moving_sum_udaf_HFTA_AGGR_OUTPUT_ moving_sum_udaf_HFTA_AGGR_OUTPUT_
43 #define super_moving_sum_udaf_HFTA_AGGR_DESTROY_ moving_sum_udaf_HFTA_AGGR_DESTROY_
44 #define super_moving_sum_udaf_HFTA_AGGR_REINIT_ moving_sum_udaf_HFTA_AGGR_REINIT_
45
46 gs_uint32_t moving_sum_extract(gs_uint64_t result);
47 gs_float_t moving_sum_extract_exp(gs_uint64_t result, gs_float_t alpha);
48
49
50 /////////////////////////////////////////////////////////////////////////
51 /////   Calculate the average of all positive float numbers
52
53 void POSAVG_HFTA_AGGR_INIT_(gs_sp_t buf);
54 void POSAVG_HFTA_AGGR_UPDATE_(gs_sp_t buf, gs_float_t v);
55 void POSAVG_HFTA_AGGR_OUTPUT_(gs_float_t * v, gs_sp_t buf);
56 void POSAVG_HFTA_AGGR_DESTROY_(gs_sp_t buf);
57
58
59 ///////////////////////////////////////////////////////////////////
60 /////                   avg_udaf (simple example)
61
62 //              hfta avg_udaf
63 void avg_udaf_HFTA_AGGR_INIT_(gs_sp_t b);
64 void avg_udaf_HFTA_AGGR_UPDATE_(gs_sp_t b, gs_uint32_t v);
65 void avg_udaf_HFTA_AGGR_OUTPUT_(vstring *r,gs_sp_t b);
66 void avg_udaf_HFTA_AGGR_DESTROY_(gs_sp_t b);
67
68 //              avg_udaf superaggregate
69 void avg_udaf_hfta_HFTA_AGGR_INIT_(gs_sp_t b);
70 void avg_udaf_hfta_HFTA_AGGR_UPDATE_(gs_sp_t b, vstring *v);
71 void avg_udaf_hfta_HFTA_AGGR_OUTPUT_(vstring *r,gs_sp_t b);
72 void avg_udaf_hfta_HFTA_AGGR_DESTROY_(gs_sp_t b);
73
74 //              Extraction function
75 gs_float_t extr_avg_fcn(vstring *v);
76
77 //      first aggregate
78 // hfta only
79 void FIRST_HFTA_AGGR_INIT_(gs_uint32_t* scratch);
80 void FIRST_HFTA_AGGR_REINIT_(gs_uint32_t* scratch);
81 void FIRST_HFTA_AGGR_UPDATE_(gs_uint32_t* scratch, gs_uint32_t val);
82 void FIRST_HFTA_AGGR_OUTPUT_(gs_uint32_t* res, gs_uint32_t* scratch);
83 void FIRST_HFTA_AGGR_DESTROY_(gs_uint32_t* scratch);
84
85 void FIRST_HFTA_AGGR_INIT_(gs_int32_t* scratch);
86 void FIRST_HFTA_AGGR_REINIT_(gs_int32_t* scratch);
87 void FIRST_HFTA_AGGR_UPDATE_(gs_int32_t* scratch, gs_int32_t val);
88 void FIRST_HFTA_AGGR_OUTPUT_(gs_int32_t* res, gs_int32_t* scratch);
89 void FIRST_HFTA_AGGR_DESTROY_(gs_int32_t* scratch);
90
91 void FIRST_HFTA_AGGR_INIT_(gs_uint64_t* scratch);
92 void FIRST_HFTA_AGGR_REINIT_(gs_uint64_t* scratch);
93 void FIRST_HFTA_AGGR_UPDATE_(gs_uint64_t* scratch, gs_uint64_t val);
94 void FIRST_HFTA_AGGR_OUTPUT_(gs_uint64_t* res, gs_uint64_t* scratch);
95 void FIRST_HFTA_AGGR_DESTROY_(gs_uint64_t* scratch);
96
97 void FIRST_HFTA_AGGR_INIT_(gs_int64_t* scratch);
98 void FIRST_HFTA_AGGR_REINIT_(gs_int64_t* scratch);
99 void FIRST_HFTA_AGGR_UPDATE_(gs_int64_t* scratch, gs_int64_t val);
100 void FIRST_HFTA_AGGR_OUTPUT_(gs_int64_t* res, gs_int64_t* scratch);
101 void FIRST_HFTA_AGGR_DESTROY_(gs_int64_t* scratch);
102
103 void FIRST_HFTA_AGGR_INIT_(vstring* scratch);
104 void FIRST_HFTA_AGGR_REINIT_(vstring* scratch);
105 void FIRST_HFTA_AGGR_UPDATE_(vstring* scratch, vstring* val);
106 void FIRST_HFTA_AGGR_OUTPUT_(vstring* res, vstring* scratch);
107 void FIRST_HFTA_AGGR_DESTROY_(vstring* scratch);
108 // hfts-lfta split
109 void FIRST_hfta_HFTA_AGGR_INIT_(gs_uint32_t* scratch);
110 void FIRST_hfta_HFTA_AGGR_REINIT_(gs_uint32_t* scratch);
111 void FIRST_hfta_HFTA_AGGR_UPDATE_(gs_uint32_t* scratch, gs_uint32_t val);
112 void FIRST_hfta_HFTA_AGGR_OUTPUT_(gs_uint32_t* res, gs_uint32_t* scratch);
113 void FIRST_hfta_HFTA_AGGR_DESTROY_(gs_uint32_t* scratch);
114
115 void FIRST_INT_hfta_HFTA_AGGR_INIT_(gs_int32_t* scratch);
116 void FIRST_INT_hfta_HFTA_AGGR_REINIT_(gs_int32_t* scratch);
117 void FIRST_INT_hfta_HFTA_AGGR_UPDATE_(gs_int32_t* scratch, gs_int32_t val);
118 void FIRST_INT_hfta_HFTA_AGGR_OUTPUT_(gs_int32_t* res, gs_int32_t* scratch);
119 void FIRST_INT_hfta_HFTA_AGGR_DESTROY_(gs_int32_t* scratch);
120
121 void FIRST_ULL_hfta_HFTA_AGGR_INIT_(gs_uint64_t* scratch);
122 void FIRST_ULL_hfta_HFTA_AGGR_REINIT_(gs_uint64_t* scratch);
123 void FIRST_ULL_hfta_HFTA_AGGR_UPDATE_(gs_uint64_t* scratch, gs_uint64_t val);
124 void FIRST_ULL_hfta_HFTA_AGGR_OUTPUT_(gs_uint64_t* res, gs_uint64_t* scratch);
125 void FIRST_ULL_hfta_HFTA_AGGR_DESTROY_(gs_uint64_t* scratch);
126
127 void FIRST_LL_hfta_HFTA_AGGR_INIT_(gs_int64_t* scratch);
128 void FIRST_LL_hfta_HFTA_AGGR_REINIT_(gs_int64_t* scratch);
129 void FIRST_LL_hfta_HFTA_AGGR_UPDATE_(gs_int64_t* scratch, gs_int64_t val);
130 void FIRST_LL_hfta_HFTA_AGGR_OUTPUT_(gs_int64_t* res, gs_int64_t* scratch);
131 void FIRST_LL_hfta_HFTA_AGGR_DESTROY_(gs_int64_t* scratch);
132
133 void FIRST_STR_hfta_HFTA_AGGR_INIT_(vstring* scratch);
134 void FIRST_STR_hfta_HFTA_AGGR_REINIT_(vstring* scratch);
135 void FIRST_STR_hfta_HFTA_AGGR_UPDATE_(vstring* scratch, vstring* val);
136 void FIRST_STR_hfta_HFTA_AGGR_OUTPUT_(vstring* res, vstring* scratch);
137 void FIRST_STR_hfta_HFTA_AGGR_DESTROY_(vstring* scratch);
138
139 //      last aggregate
140 //  hfta only
141 void LAST_HFTA_AGGR_INIT_(gs_uint32_t* scratch);
142 void LAST_HFTA_AGGR_REINIT_(gs_uint32_t* scratch);
143 void LAST_HFTA_AGGR_UPDATE_(gs_uint32_t* scratch, gs_uint32_t val);
144 void LAST_HFTA_AGGR_OUTPUT_(gs_uint32_t* res, gs_uint32_t* scratch);
145 void LAST_HFTA_AGGR_DESTROY_(gs_uint32_t* scratch);
146
147 void LAST_HFTA_AGGR_INIT_(gs_int32_t* scratch);
148 void LAST_HFTA_AGGR_REINIT_(gs_int32_t* scratch);
149 void LAST_HFTA_AGGR_UPDATE_(gs_int32_t* scratch, gs_int32_t val);
150 void LAST_HFTA_AGGR_OUTPUT_(gs_int32_t* res, gs_int32_t* scratch);
151 void LAST_HFTA_AGGR_DESTROY_(gs_int32_t* scratch);
152
153 void LAST_HFTA_AGGR_INIT_(gs_uint64_t* scratch);
154 void LAST_HFTA_AGGR_REINIT_(gs_uint64_t* scratch);
155 void LAST_HFTA_AGGR_UPDATE_(gs_uint64_t* scratch, gs_uint64_t val);
156 void LAST_HFTA_AGGR_OUTPUT_(gs_uint64_t* res, gs_uint64_t* scratch);
157 void LAST_HFTA_AGGR_DESTROY_(gs_uint64_t* scratch);
158
159 void LAST_HFTA_AGGR_INIT_(gs_int64_t* scratch);
160 void LAST_HFTA_AGGR_REINIT_(gs_int64_t* scratch);
161 void LAST_HFTA_AGGR_UPDATE_(gs_int64_t* scratch, gs_int64_t val);
162 void LAST_HFTA_AGGR_OUTPUT_(gs_int64_t* res, gs_int64_t* scratch);
163 void LAST_HFTA_AGGR_DESTROY_(gs_int64_t* scratch);
164
165 void LAST_HFTA_AGGR_INIT_(vstring* scratch);
166 void LAST_HFTA_AGGR_REINIT_(vstring* scratch);
167 void LAST_HFTA_AGGR_UPDATE_(vstring* scratch, vstring* val);
168 void LAST_HFTA_AGGR_OUTPUT_(vstring* res, vstring* scratch);
169 void LAST_HFTA_AGGR_DESTROY_(vstring* scratch);
170
171
172 // hfta/lfta split
173 void LAST_hfta_HFTA_AGGR_INIT_(gs_uint32_t* scratch);
174 void LAST_hfta_HFTA_AGGR_REINIT_(gs_uint32_t* scratch);
175 void LAST_hfta_HFTA_AGGR_UPDATE_(gs_uint32_t* scratch, gs_uint32_t val);
176 void LAST_hfta_HFTA_AGGR_OUTPUT_(gs_uint32_t* res, gs_uint32_t* scratch);
177 void LAST_hfta_HFTA_AGGR_DESTROY_(gs_uint32_t* scratch);
178
179 void LAST_INT_hfta_HFTA_AGGR_INIT_(gs_int32_t* scratch);
180 void LAST_INT_hfta_HFTA_AGGR_REINIT_(gs_int32_t* scratch);
181 void LAST_INT_hfta_HFTA_AGGR_UPDATE_(gs_int32_t* scratch, gs_int32_t val);
182 void LAST_INT_hfta_HFTA_AGGR_OUTPUT_(gs_int32_t* res, gs_int32_t* scratch);
183 void LAST_INT_hfta_HFTA_AGGR_DESTROY_(gs_int32_t* scratch);
184
185 void LAST_ULL_hfta_HFTA_AGGR_INIT_(gs_uint64_t* scratch);
186 void LAST_ULL_hfta_HFTA_AGGR_REINIT_(gs_uint64_t* scratch);
187 void LAST_ULL_hfta_HFTA_AGGR_UPDATE_(gs_uint64_t* scratch, gs_uint64_t val);
188 void LAST_ULL_hfta_HFTA_AGGR_OUTPUT_(gs_uint64_t* res, gs_uint64_t* scratch);
189 void LAST_ULL_hfta_HFTA_AGGR_DESTROY_(gs_uint64_t* scratch);
190
191 void LAST_LL_hfta_HFTA_AGGR_INIT_(gs_int64_t* scratch);
192 void LAST_LL_hfta_HFTA_AGGR_REINIT_(gs_int64_t* scratch);
193 void LAST_LL_hfta_HFTA_AGGR_UPDATE_(gs_int64_t* scratch, gs_int64_t val);
194 void LAST_LL_hfta_HFTA_AGGR_OUTPUT_(gs_int64_t* res, gs_int64_t* scratch);
195 void LAST_LL_hfta_HFTA_AGGR_DESTROY_(gs_int64_t* scratch);
196
197 void LAST_STR_hfta_HFTA_AGGR_INIT_(vstring* scratch);
198 void LAST_STR_hfta_HFTA_AGGR_REINIT_(vstring* scratch);
199 void LAST_STR_hfta_HFTA_AGGR_UPDATE_(vstring* scratch, vstring* val);
200 void LAST_STR_hfta_HFTA_AGGR_OUTPUT_(vstring* res, vstring* scratch);
201 void LAST_STR_hfta_HFTA_AGGR_DESTROY_(vstring* scratch);
202
203 ///////////////////////////////////////////////////////////////
204 //      count_diff aggregate
205 ///////////////////////////////////////////////////////////////
206
207 void count_diff_HFTA_AGGR_INIT_(gs_sp_t scratch);
208 void count_diff_HFTA_AGGR_REINIT_(gs_sp_t scratch);
209 void count_diff_HFTA_AGGR_UPDATE_(gs_sp_t scratch, gs_uint32_t val);
210 void count_diff_HFTA_AGGR_UPDATE_(gs_sp_t scratch, gs_int32_t val);
211 void count_diff_HFTA_AGGR_UPDATE_(gs_sp_t scratch, gs_uint64_t val);
212 void count_diff_HFTA_AGGR_UPDATE_(gs_sp_t scratch, gs_int64_t val);
213 void count_diff_HFTA_AGGR_UPDATE_(gs_sp_t scratch, vstring *val);
214 void count_diff_HFTA_AGGR_OUTPUT_(gs_uint32_t *res, gs_sp_t scratch);
215 void count_diff_HFTA_AGGR_DESTROY_(gs_sp_t scratch);
216
217 void count_diff_hfta_HFTA_AGGR_INIT_(gs_sp_t s);
218 void count_diff_hfta_HFTA_AGGR_REINIT_(gs_sp_t s);
219 void count_diff_hfta_HFTA_AGGR_UPDATE_(gs_sp_t s, vstring *val);
220 void count_diff_hfta_HFTA_AGGR_OUTPUT_(gs_uint32_t *res, gs_sp_t s);
221 void count_diff_hfta_HFTA_AGGR_DESTROY_(gs_sp_t scratch);
222
223 //////////////////////////////////////////////
224 //      CAT_aggr, aggregate strings by catenation
225 //////////////////////////////////////////////
226 void CAT_aggr_HFTA_AGGR_INIT_(gs_sp_t s);
227 void CAT_aggr_HFTA_AGGR_REINIT_(gs_sp_t s);
228 void CAT_aggr_HFTA_AGGR_UPDATE_(gs_sp_t s, vstring *sep, vstring *str);
229 void CAT_aggr_HFTA_AGGR_OUTPUT_(vstring *res, gs_sp_t s);
230 void CAT_aggr_HFTA_AGGR_DESTROY_(gs_sp_t s);
231
232 /////////////////////////////////////////////////////////
233 //      time-averaged sum, from aperiodic reports
234 ////////////////////////////////////////////////////////
235
236 void time_avg_HFTA_AGGR_INIT_(gs_sp_t s);
237 void time_avg_HFTA_AGGR_DESTROY_(gs_sp_t s);
238 void time_avg_HFTA_AGGR_REINIT_(gs_sp_t s);
239 void time_avg_HFTA_AGGR_OUTPUT_(gs_float_t *result, gs_sp_t s);
240 void time_avg_HFTA_AGGR_UPDATE_(gs_sp_t s, gs_float_t val, gs_int64_t ts, gs_int64_t window);
241 void time_avg_HFTA_AGGR_UPDATE_(gs_sp_t s, gs_uint32_t val, gs_int64_t ts, gs_int64_t window);
242 void time_avg_HFTA_AGGR_UPDATE_(gs_sp_t s, gs_int32_t val, gs_int64_t ts, gs_int64_t window);
243 void time_avg_HFTA_AGGR_UPDATE_(gs_sp_t s, gs_uint64_t val, gs_int64_t ts, gs_int64_t window);
244 void time_avg_HFTA_AGGR_UPDATE_(gs_sp_t s, gs_int64_t val, gs_int64_t ts, gs_int64_t window);
245
246 // ------------------------------------------------------------
247 //              running_sum_max : get the running sum of an int,
248 //              be able to report this sum and also its max value
249 //              during the time window
250 // ------------------------------------------------------------
251
252 void run_sum_max_HFTA_AGGR_INIT_(gs_sp_t s);
253 void run_sum_max_HFTA_AGGR_REINIT_(gs_sp_t s);
254 void run_sum_max_HFTA_AGGR_OUTPUT_(vstring *r,gs_sp_t b);
255 void run_sum_max_HFTA_AGGR_DESTROY_(gs_sp_t b);
256 void run_sum_max_HFTA_AGGR_UPDATE_(gs_sp_t s, gs_uint64_t v);
257 void run_sum_max_HFTA_AGGR_UPDATE_(gs_sp_t s, gs_int64_t v);
258 void run_sum_max_HFTA_AGGR_UPDATE_(gs_sp_t s, gs_uint32_t v);
259 void run_sum_max_HFTA_AGGR_UPDATE_(gs_sp_t s, gs_int32_t v);
260 gs_int64_t extr_running_sum(vstring *v);
261 gs_int64_t extr_running_sum_max(vstring *v);
262
263
264
265
266 ///////////////////////////////////////////////////////////////
267 //              running_array_aggr aggregate
268 ///////////////////////////////////////////////////////////////
269 void running_array_aggr_hfta_HFTA_AGGR_INIT_(vstring* scratch);
270 void running_array_aggr_hfta_HFTA_AGGR_REINIT_(vstring* scratch);
271 void running_array_aggr_hfta_HFTA_AGGR_UPDATE_(vstring* scratch, vstring* val);
272 void running_array_aggr_hfta_HFTA_AGGR_OUTPUT_(vstring* res, vstring* scratch);
273 void running_array_aggr_hfta_HFTA_AGGR_DESTROY_(vstring* scratch);
274
275 ////////////////////////////////////////////////////////////////
276 ///             Flip's sample-based quantiles
277
278 /****************************************************************/
279 /* HFTA functions                                               */
280 /****************************************************************/
281
282 // void quant_udaf_hfta3_HFTA_AGGR_INIT_(gs_sp_t);
283 // void quant_udaf_hfta3_HFTA_AGGR_UPDATE_(gs_sp_t, vstring *);
284 // void quant_udaf_hfta3_HFTA_AGGR_OUTPUT_(vstring *, gs_sp_t);
285 // void quant_udaf_hfta3_HFTA_AGGR_DESTROY_(gs_sp_t);
286 // gs_uint32_t extr_quant_hfta3_fcn(vstring *, gs_float_t);
287 // gs_uint32_t extr_med_hfta3_fcn(vstring *);
288 // gs_uint32_t extr_quant_hfta3_space(vstring *);
289
290 void quant_f_udaf_hfta3_HFTA_AGGR_INIT_(gs_sp_t b);
291 void quant_f_udaf_hfta3_HFTA_AGGR_UPDATE_(gs_sp_t b, vstring *v);
292 void quant_f_udaf_hfta3_HFTA_AGGR_OUTPUT_(vstring *r, gs_sp_t b) ;
293 //gs_float_t extr_quant_f_hfta3_fcn(vstring *v, gs_float_t phi) ;
294 //gs_float_t extr_f_med_hfta3_fcn(vstring *v);
295 void quant_f_udaf_hfta3_HFTA_AGGR_DESTROY_(gs_sp_t b) ;
296
297 void quant_ui_udaf_hfta3_HFTA_AGGR_INIT_(gs_sp_t b);
298 void quant_ui_udaf_hfta3_HFTA_AGGR_UPDATE_(gs_sp_t b, vstring *v);
299 void quant_ui_udaf_hfta3_HFTA_AGGR_OUTPUT_(vstring *r, gs_sp_t b) ;
300 //gs_uint32_t extr_quant_ui_hfta3_fcn(vstring *v, gs_float_t phi) ;
301 //gs_uint32_t extr_ui_med_hfta3_fcn(vstring *v);
302 void quant_ui_udaf_hfta3_HFTA_AGGR_DESTROY_(gs_sp_t b) ;
303
304 void quant_i_udaf_hfta3_HFTA_AGGR_INIT_(gs_sp_t b);
305 void quant_i_udaf_hfta3_HFTA_AGGR_UPDATE_(gs_sp_t b, vstring *v);
306 void quant_i_udaf_hfta3_HFTA_AGGR_OUTPUT_(vstring *r, gs_sp_t b) ;
307 //gs_int32_t extr_quant_i_hfta3_fcn(vstring *v, gs_float_t phi) ;
308 //gs_int32_t extr_i_med_hfta3_fcn(vstring *v);
309 void quant_i_udaf_hfta3_HFTA_AGGR_DESTROY_(gs_sp_t b) ;
310
311 void quant_ul_udaf_hfta3_HFTA_AGGR_INIT_(gs_sp_t b);
312 void quant_ul_udaf_hfta3_HFTA_AGGR_UPDATE_(gs_sp_t b, vstring *v);
313 void quant_ul_udaf_hfta3_HFTA_AGGR_OUTPUT_(vstring *r, gs_sp_t b) ;
314 //gs_uint64_t extr_quant_ul_hfta3_fcn(vstring *v, gs_float_t phi) ;
315 //gs_uint64_t extr_ul_med_hfta3_fcn(vstring *v);
316 void quant_ul_udaf_hfta3_HFTA_AGGR_DESTROY_(gs_sp_t b) ;
317
318 void quant_l_udaf_hfta3_HFTA_AGGR_INIT_(gs_sp_t b);
319 void quant_l_udaf_hfta3_HFTA_AGGR_UPDATE_(gs_sp_t b, vstring *v);
320 void quant_l_udaf_hfta3_HFTA_AGGR_OUTPUT_(vstring *r, gs_sp_t b) ;
321 //gs_int64_t extr_quant_l_hfta3_fcn(vstring *v, gs_float_t phi) ;
322 //gs_int64_t extr_l_med_hfta3_fcn(vstring *v);
323 void quant_l_udaf_hfta3_HFTA_AGGR_DESTROY_(gs_sp_t b) ;
324
325
326
327
328 /****************************************************************/
329 /* HFTA-only functions                                          */
330 /****************************************************************/
331
332 // void quant_udaf_hfta0_HFTA_AGGR_INIT_(gs_sp_t);
333 // void quant_udaf_hfta0_HFTA_AGGR_UPDATE_(gs_sp_t, gs_uint32_t);
334 // void quant_udaf_hfta0_HFTA_AGGR_OUTPUT_(vstring *, gs_sp_t);
335 // void quant_udaf_hfta0_HFTA_AGGR_DESTROY_(gs_sp_t);
336 // gs_uint32_t extr_quant_hfta0_fcn(vstring *, gs_float_t);
337 // gs_uint32_t extr_med_hfta0_fcn(vstring *);
338 // gs_uint32_t extr_quant_hfta0_space(vstring *);
339
340 void quant_ui_udaf_hftaZ_HFTA_AGGR_INIT_(gs_sp_t b);
341 void quant_ui_udaf_hftaZ_HFTA_AGGR_UPDATE_(gs_sp_t b, gs_uint32_t v) ;
342 void quant_ui_udaf_hftaZ_HFTA_AGGR_OUTPUT_(vstring *r, gs_sp_t b);
343 void quant_ui_udaf_hftaZ_HFTA_AGGR_DESTROY_(gs_sp_t b);
344 gs_uint32_t extr_quant_ui_hftaZ_fcn(vstring *v, gs_float_t phi) ;
345 gs_uint32_t extr_med_ui_hftaZ_fcn(vstring *v) ;
346 int quant_ui_udaf_hftaZ_nelem(gs_sp_t b) ;
347
348 void quant_ul_udaf_hftaZ_HFTA_AGGR_INIT_(gs_sp_t b);
349 void quant_ul_udaf_hftaZ_HFTA_AGGR_UPDATE_(gs_sp_t b, gs_uint64_t v) ;
350 void quant_ul_udaf_hftaZ_HFTA_AGGR_OUTPUT_(vstring *r, gs_sp_t b);
351 void quant_ul_udaf_hftaZ_HFTA_AGGR_DESTROY_(gs_sp_t b);
352 gs_uint64_t extr_quant_ul_hftaZ_fcn(vstring *v, gs_float_t phi) ;
353 gs_uint64_t extr_med_ul_hftaZ_fcn(vstring *v) ;
354 int quant_ul_udaf_hftaZ_nelem(gs_sp_t b) ;
355
356 void quant_i_udaf_hftaZ_HFTA_AGGR_INIT_(gs_sp_t b);
357 void quant_i_udaf_hftaZ_HFTA_AGGR_UPDATE_(gs_sp_t b, gs_int32_t v) ;
358 void quant_i_udaf_hftaZ_HFTA_AGGR_OUTPUT_(vstring *r, gs_sp_t b);
359 void quant_i_udaf_hftaZ_HFTA_AGGR_DESTROY_(gs_sp_t b);
360 gs_int32_t extr_quant_i_hftaZ_fcn(vstring *v, gs_float_t phi) ;
361 gs_int32_t extr_med_i_hftaZ_fcn(vstring *v) ;
362 int quant_i_udaf_hftaZ_nelem(gs_sp_t b) ;
363
364 void quant_l_udaf_hftaZ_HFTA_AGGR_INIT_(gs_sp_t b);
365 void quant_l_udaf_hftaZ_HFTA_AGGR_UPDATE_(gs_sp_t b, gs_int64_t v) ;
366 void quant_l_udaf_hftaZ_HFTA_AGGR_OUTPUT_(vstring *r, gs_sp_t b);
367 void quant_l_udaf_hftaZ_HFTA_AGGR_DESTROY_(gs_sp_t b);
368 gs_int64_t extr_quant_l_hftaZ_fcn(vstring *v, gs_float_t phi) ;
369 gs_int64_t extr_med_l_hftaZ_fcn(vstring *v) ;
370 int quant_l_udaf_hftaZ_nelem(gs_sp_t b) ;
371
372 void quant_f_udaf_hftaZ_HFTA_AGGR_INIT_(gs_sp_t b);
373 void quant_f_udaf_hftaZ_HFTA_AGGR_UPDATE_(gs_sp_t b, gs_float_t v) ;
374 void quant_f_udaf_hftaZ_HFTA_AGGR_OUTPUT_(vstring *r, gs_sp_t b);
375 void quant_f_udaf_hftaZ_HFTA_AGGR_DESTROY_(gs_sp_t b);
376 gs_float_t extr_quant_f_hftaZ_fcn(vstring *v, gs_float_t phi) ;
377 gs_float_t extr_med_f_hftaZ_fcn(vstring *v) ;
378 int quant_f_udaf_hftaZ_nelem(gs_sp_t b) ;
379
380
381
382 /****************************************************************/
383 //              Approximate count distinct.
384 //              Rely on the minhashing approach.
385 //              Currently HFTA-only
386 //              Uses a 32-bit hash, tested up to 100,000,000 elements
387 //              and it gave good results (within 7%)
388 /****************************************************************/
389
390 // ---------------------------------------------
391 //      HFTA-only
392 void approx_count_distinct_udaf_HFTA_AGGR_INIT_(gs_sp_t buf);
393 void approx_count_distinct_udaf_HFTA_AGGR_REINIT_(gs_sp_t buf);
394 void approx_count_distinct_udaf_HFTA_AGGR_DESTROY_(gs_sp_t buf);
395 void approx_count_distinct_udaf_HFTA_AGGR_UPDATE_(gs_sp_t buf, vstring *val);
396 void approx_count_distinct_udaf_HFTA_AGGR_OUTPUT_(vstring *res, gs_sp_t buf);
397
398 void running_approx_count_distinct_udaf_HFTA_AGGR_INIT_(gs_sp_t buf);
399 void running_approx_count_distinct_udaf_HFTA_AGGR_REINIT_(gs_sp_t buf);
400 void running_approx_count_distinct_udaf_HFTA_AGGR_DESTROY_(gs_sp_t buf);
401 void running_approx_count_distinct_udaf_HFTA_AGGR_UPDATE_(gs_sp_t buf, vstring *val);
402 void running_approx_count_distinct_udaf_HFTA_AGGR_OUTPUT_(vstring *res, gs_sp_t buf);
403
404 gs_float_t extr_approx_count_distinct(vstring *v);
405
406
407
408 #endif