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 //      CAT_aggr, aggregate strings by catenation but only when the payload changes
 234 //////////////////////////////////////////////
 235 void CAT_aggr_diff_HFTA_AGGR_INIT_(gs_sp_t s);
 236 void CAT_aggr_diff_HFTA_AGGR_REINIT_(gs_sp_t s);
 237 void CAT_aggr_diff_HFTA_AGGR_UPDATE_(gs_sp_t s,  vstring *str);
 238 void CAT_aggr_diff_HFTA_AGGR_OUTPUT_(vstring *res, gs_sp_t s);
 239 void CAT_aggr_diff_HFTA_AGGR_DESTROY_(gs_sp_t s);
 240
 241
 242 /////////////////////////////////////////////////////////
 243 //      time-averaged sum, from aperiodic reports
 244 ////////////////////////////////////////////////////////
 245
 246 void time_avg_HFTA_AGGR_INIT_(gs_sp_t s);
 247 void time_avg_HFTA_AGGR_DESTROY_(gs_sp_t s);
 248 void time_avg_HFTA_AGGR_REINIT_(gs_sp_t s);
 249 void time_avg_HFTA_AGGR_OUTPUT_(gs_float_t *result, gs_sp_t s);
 250 void time_avg_HFTA_AGGR_UPDATE_(gs_sp_t s, gs_float_t val, gs_int64_t ts, gs_int64_t window);
 251 void time_avg_HFTA_AGGR_UPDATE_(gs_sp_t s, gs_uint32_t val, gs_int64_t ts, gs_int64_t window);
 252 void time_avg_HFTA_AGGR_UPDATE_(gs_sp_t s, gs_int32_t val, gs_int64_t ts, gs_int64_t window);
 253 void time_avg_HFTA_AGGR_UPDATE_(gs_sp_t s, gs_uint64_t val, gs_int64_t ts, gs_int64_t window);
 254 void time_avg_HFTA_AGGR_UPDATE_(gs_sp_t s, gs_int64_t val, gs_int64_t ts, gs_int64_t window);
 255
 256 // ------------------------------------------------------------
 257 //              running_sum_max : get the running sum of an int,
 258 //              be able to report this sum and also its max value
 259 //              during the time window
 260 // ------------------------------------------------------------
 261
 262 void run_sum_max_HFTA_AGGR_INIT_(gs_sp_t s);
 263 void run_sum_max_HFTA_AGGR_REINIT_(gs_sp_t s);
 264 void run_sum_max_HFTA_AGGR_OUTPUT_(vstring *r,gs_sp_t b);
 265 void run_sum_max_HFTA_AGGR_DESTROY_(gs_sp_t b);
 266 void run_sum_max_HFTA_AGGR_UPDATE_(gs_sp_t s, gs_uint64_t v);
 267 void run_sum_max_HFTA_AGGR_UPDATE_(gs_sp_t s, gs_int64_t v);
 268 void run_sum_max_HFTA_AGGR_UPDATE_(gs_sp_t s, gs_uint32_t v);
 269 void run_sum_max_HFTA_AGGR_UPDATE_(gs_sp_t s, gs_int32_t v);
 270 gs_int64_t extr_running_sum(vstring *v);
 271 gs_int64_t extr_running_sum_max(vstring *v);
 272
 273
 274
 275
 276 ///////////////////////////////////////////////////////////////
 277 //              running_array_aggr aggregate
 278 ///////////////////////////////////////////////////////////////
 279 void running_array_aggr_hfta_HFTA_AGGR_INIT_(vstring* scratch);
 280 void running_array_aggr_hfta_HFTA_AGGR_REINIT_(vstring* scratch);
 281 void running_array_aggr_hfta_HFTA_AGGR_UPDATE_(vstring* scratch, vstring* val);
 282 void running_array_aggr_hfta_HFTA_AGGR_OUTPUT_(vstring* res, vstring* scratch);
 283 void running_array_aggr_hfta_HFTA_AGGR_DESTROY_(vstring* scratch);
 284
 285 ////////////////////////////////////////////////////////////////
 286 ///             Flip's sample-based quantiles
 287
 288 /****************************************************************/
 289 /* HFTA functions                                               */
 290 /****************************************************************/
 291
 292 // void quant_udaf_hfta3_HFTA_AGGR_INIT_(gs_sp_t);
 293 // void quant_udaf_hfta3_HFTA_AGGR_UPDATE_(gs_sp_t, vstring *);
 294 // void quant_udaf_hfta3_HFTA_AGGR_OUTPUT_(vstring *, gs_sp_t);
 295 // void quant_udaf_hfta3_HFTA_AGGR_DESTROY_(gs_sp_t);
 296 // gs_uint32_t extr_quant_hfta3_fcn(vstring *, gs_float_t);
 297 // gs_uint32_t extr_med_hfta3_fcn(vstring *);
 298 // gs_uint32_t extr_quant_hfta3_space(vstring *);
 299
 300 void quant_f_udaf_hfta3_HFTA_AGGR_INIT_(gs_sp_t b);
 301 void quant_f_udaf_hfta3_HFTA_AGGR_UPDATE_(gs_sp_t b, vstring *v);
 302 void quant_f_udaf_hfta3_HFTA_AGGR_OUTPUT_(vstring *r, gs_sp_t b) ;
 303 //gs_float_t extr_quant_f_hfta3_fcn(vstring *v, gs_float_t phi) ;
 304 //gs_float_t extr_f_med_hfta3_fcn(vstring *v);
 305 void quant_f_udaf_hfta3_HFTA_AGGR_DESTROY_(gs_sp_t b) ;
 306
 307 void quant_ui_udaf_hfta3_HFTA_AGGR_INIT_(gs_sp_t b);
 308 void quant_ui_udaf_hfta3_HFTA_AGGR_UPDATE_(gs_sp_t b, vstring *v);
 309 void quant_ui_udaf_hfta3_HFTA_AGGR_OUTPUT_(vstring *r, gs_sp_t b) ;
 310 //gs_uint32_t extr_quant_ui_hfta3_fcn(vstring *v, gs_float_t phi) ;
 311 //gs_uint32_t extr_ui_med_hfta3_fcn(vstring *v);
 312 void quant_ui_udaf_hfta3_HFTA_AGGR_DESTROY_(gs_sp_t b) ;
 313
 314 void quant_i_udaf_hfta3_HFTA_AGGR_INIT_(gs_sp_t b);
 315 void quant_i_udaf_hfta3_HFTA_AGGR_UPDATE_(gs_sp_t b, vstring *v);
 316 void quant_i_udaf_hfta3_HFTA_AGGR_OUTPUT_(vstring *r, gs_sp_t b) ;
 317 //gs_int32_t extr_quant_i_hfta3_fcn(vstring *v, gs_float_t phi) ;
 318 //gs_int32_t extr_i_med_hfta3_fcn(vstring *v);
 319 void quant_i_udaf_hfta3_HFTA_AGGR_DESTROY_(gs_sp_t b) ;
 320
 321 void quant_ul_udaf_hfta3_HFTA_AGGR_INIT_(gs_sp_t b);
 322 void quant_ul_udaf_hfta3_HFTA_AGGR_UPDATE_(gs_sp_t b, vstring *v);
 323 void quant_ul_udaf_hfta3_HFTA_AGGR_OUTPUT_(vstring *r, gs_sp_t b) ;
 324 //gs_uint64_t extr_quant_ul_hfta3_fcn(vstring *v, gs_float_t phi) ;
 325 //gs_uint64_t extr_ul_med_hfta3_fcn(vstring *v);
 326 void quant_ul_udaf_hfta3_HFTA_AGGR_DESTROY_(gs_sp_t b) ;
 327
 328 void quant_l_udaf_hfta3_HFTA_AGGR_INIT_(gs_sp_t b);
 329 void quant_l_udaf_hfta3_HFTA_AGGR_UPDATE_(gs_sp_t b, vstring *v);
 330 void quant_l_udaf_hfta3_HFTA_AGGR_OUTPUT_(vstring *r, gs_sp_t b) ;
 331 //gs_int64_t extr_quant_l_hfta3_fcn(vstring *v, gs_float_t phi) ;
 332 //gs_int64_t extr_l_med_hfta3_fcn(vstring *v);
 333 void quant_l_udaf_hfta3_HFTA_AGGR_DESTROY_(gs_sp_t b) ;
 334
 335
 336
 337
 338 /****************************************************************/
 339 /* HFTA-only functions                                          */
 340 /****************************************************************/
 341
 342 // void quant_udaf_hfta0_HFTA_AGGR_INIT_(gs_sp_t);
 343 // void quant_udaf_hfta0_HFTA_AGGR_UPDATE_(gs_sp_t, gs_uint32_t);
 344 // void quant_udaf_hfta0_HFTA_AGGR_OUTPUT_(vstring *, gs_sp_t);
 345 // void quant_udaf_hfta0_HFTA_AGGR_DESTROY_(gs_sp_t);
 346 // gs_uint32_t extr_quant_hfta0_fcn(vstring *, gs_float_t);
 347 // gs_uint32_t extr_med_hfta0_fcn(vstring *);
 348 // gs_uint32_t extr_quant_hfta0_space(vstring *);
 349
 350 void quant_ui_udaf_hftaZ_HFTA_AGGR_INIT_(gs_sp_t b);
 351 void quant_ui_udaf_hftaZ_HFTA_AGGR_UPDATE_(gs_sp_t b, gs_uint32_t v) ;
 352 void quant_ui_udaf_hftaZ_HFTA_AGGR_OUTPUT_(vstring *r, gs_sp_t b);
 353 void quant_ui_udaf_hftaZ_HFTA_AGGR_DESTROY_(gs_sp_t b);
 354 gs_uint32_t extr_quant_ui_hftaZ_fcn(vstring *v, gs_float_t phi) ;
 355 gs_uint32_t extr_med_ui_hftaZ_fcn(vstring *v) ;
 356 int quant_ui_udaf_hftaZ_nelem(gs_sp_t b) ;
 357
 358 void quant_ul_udaf_hftaZ_HFTA_AGGR_INIT_(gs_sp_t b);
 359 void quant_ul_udaf_hftaZ_HFTA_AGGR_UPDATE_(gs_sp_t b, gs_uint64_t v) ;
 360 void quant_ul_udaf_hftaZ_HFTA_AGGR_OUTPUT_(vstring *r, gs_sp_t b);
 361 void quant_ul_udaf_hftaZ_HFTA_AGGR_DESTROY_(gs_sp_t b);
 362 gs_uint64_t extr_quant_ul_hftaZ_fcn(vstring *v, gs_float_t phi) ;
 363 gs_uint64_t extr_med_ul_hftaZ_fcn(vstring *v) ;
 364 int quant_ul_udaf_hftaZ_nelem(gs_sp_t b) ;
 365
 366 void quant_i_udaf_hftaZ_HFTA_AGGR_INIT_(gs_sp_t b);
 367 void quant_i_udaf_hftaZ_HFTA_AGGR_UPDATE_(gs_sp_t b, gs_int32_t v) ;
 368 void quant_i_udaf_hftaZ_HFTA_AGGR_OUTPUT_(vstring *r, gs_sp_t b);
 369 void quant_i_udaf_hftaZ_HFTA_AGGR_DESTROY_(gs_sp_t b);
 370 gs_int32_t extr_quant_i_hftaZ_fcn(vstring *v, gs_float_t phi) ;
 371 gs_int32_t extr_med_i_hftaZ_fcn(vstring *v) ;
 372 int quant_i_udaf_hftaZ_nelem(gs_sp_t b) ;
 373
 374 void quant_l_udaf_hftaZ_HFTA_AGGR_INIT_(gs_sp_t b);
 375 void quant_l_udaf_hftaZ_HFTA_AGGR_UPDATE_(gs_sp_t b, gs_int64_t v) ;
 376 void quant_l_udaf_hftaZ_HFTA_AGGR_OUTPUT_(vstring *r, gs_sp_t b);
 377 void quant_l_udaf_hftaZ_HFTA_AGGR_DESTROY_(gs_sp_t b);
 378 gs_int64_t extr_quant_l_hftaZ_fcn(vstring *v, gs_float_t phi) ;
 379 gs_int64_t extr_med_l_hftaZ_fcn(vstring *v) ;
 380 int quant_l_udaf_hftaZ_nelem(gs_sp_t b) ;
 381
 382 void quant_f_udaf_hftaZ_HFTA_AGGR_INIT_(gs_sp_t b);
 383 void quant_f_udaf_hftaZ_HFTA_AGGR_UPDATE_(gs_sp_t b, gs_float_t v) ;
 384 void quant_f_udaf_hftaZ_HFTA_AGGR_OUTPUT_(vstring *r, gs_sp_t b);
 385 void quant_f_udaf_hftaZ_HFTA_AGGR_DESTROY_(gs_sp_t b);
 386 gs_float_t extr_quant_f_hftaZ_fcn(vstring *v, gs_float_t phi) ;
 387 gs_float_t extr_med_f_hftaZ_fcn(vstring *v) ;
 388 int quant_f_udaf_hftaZ_nelem(gs_sp_t b) ;
 389
 390
 391
 392 /****************************************************************/
 393 //              Approximate count distinct.
 394 //              Rely on the minhashing approach.
 395 //              Currently HFTA-only
 396 //              Uses a 32-bit hash, tested up to 100,000,000 elements
 397 //              and it gave good results (within 7%)
 398 /****************************************************************/
 399
 400 // ---------------------------------------------
 401 //      HFTA-only
 402 void approx_count_distinct_udaf_HFTA_AGGR_INIT_(gs_sp_t buf);
 403 void approx_count_distinct_udaf_HFTA_AGGR_REINIT_(gs_sp_t buf);
 404 void approx_count_distinct_udaf_HFTA_AGGR_DESTROY_(gs_sp_t buf);
 405 void approx_count_distinct_udaf_HFTA_AGGR_UPDATE_(gs_sp_t buf, vstring *val);
 406 void approx_count_distinct_udaf_HFTA_AGGR_OUTPUT_(vstring *res, gs_sp_t buf);
 407
 408 void running_approx_count_distinct_udaf_HFTA_AGGR_INIT_(gs_sp_t buf);
 409 void running_approx_count_distinct_udaf_HFTA_AGGR_REINIT_(gs_sp_t buf);
 410 void running_approx_count_distinct_udaf_HFTA_AGGR_DESTROY_(gs_sp_t buf);
 411 void running_approx_count_distinct_udaf_HFTA_AGGR_UPDATE_(gs_sp_t buf, vstring *val);
 412 void running_approx_count_distinct_udaf_HFTA_AGGR_OUTPUT_(vstring *res, gs_sp_t buf);
 413
 414 gs_float_t extr_approx_count_distinct(vstring *v);
 415
 416
 417
 418 #endif