MicroDataSet.hpp

 
//Copyright (C) 2022 by the IntelliStream team (https://github.com/intellistream)
// Created by tony on 03/03/22.
//
 
#ifndef _UTILS_MICRODATASET_H_
#define _UTILS_MICRODATASET_H_
#pragma once
#include <stdint.h>
#include <vector>
#include <stddef.h>
#include <stdlib.h>
#include <time.h>
#include <random>
#include <cmath>
#include <iostream>
using namespace std;
namespace INTELLI {
class MicroDataSet {
 private:
  std::random_device rd;
  std::default_random_engine e1;
  bool hasSeed = false;
  uint64_t seed;
 public:
  MicroDataSet() {
 
  }
  MicroDataSet(uint64_t _seed) {
    seed = _seed;
    hasSeed = true;
  }
  ~MicroDataSet() {}
  template<class dType=uint32_t>
  vector<dType> genIncrementalAlphabet(size_t len) {
    vector<dType> ru(len);
    /* populate */
    for (size_t i = 0; i < len; i++) {
      ru[i] = i + 1;   /* don't let 0 be in the alphabet */
    }
    return ru;
  }
  template<class tsType=size_t>
  vector<tsType> genZipfInt(size_t len, tsType maxV, double fac) {
    vector<tsType> ret(len);
    vector<tsType> alphabet = genIncrementalAlphabet<tsType>(maxV);
    std::mt19937_64 gen;
    if (!hasSeed) {
      gen = std::mt19937_64(rd()); // 以 rd() 播种的标准 mersenne_twister_engine
    } else {
      gen = std::mt19937_64(seed);
    }
 
    std::uniform_real_distribution<> dis(0, 1);
    vector<double> lut = genZipfLut<double>(maxV, fac);
    for (size_t i = 0; i < len; i++) {
      /* take random number */
      double r = dis(gen);
      /* binary search in lookup table to determine item */
      size_t left = 0;
      size_t right = maxV - 1;
      size_t m;       /* middle between left and right */
      size_t pos;     /* position to take */
 
      if (lut[0] >= r)
        pos = 0;
      else {
        while (right - left > 1) {
          m = (left + right) / 2;
 
          if (lut[m] < r)
            left = m;
          else
            right = m;
        }
 
        pos = right;
      }
      ret[i] = alphabet[pos];
    }
    return ret;
  }
  template<class tsType=uint32_t, class genType=std::mt19937>
  vector<tsType> genRandInt(size_t len, tsType maxV, tsType minV = 0) {
    genType gen;
    if (!hasSeed) {
      gen = genType(rd());
    } else {
      gen = genType(seed);
    }
    std::uniform_int_distribution<> dis(minV, maxV);
    vector<tsType> ret(len);
    for (size_t i = 0; i < len; i++) {
      ret[i] = (tsType) dis(gen);
    }
    return ret;
  }
  template<class dType=double>
  vector<dType> genZipfLut(size_t len, dType fac) {
    dType scaling_factor;
    dType sum;
    vector<dType> lut(len);
    /*
     * Compute scaling factor such that
     *
     *   sum (lut[i], i=1..alphabet_size) = 1.0
     *
     */
    scaling_factor = 0.0;
    for (size_t i = 1; i <= len; i++) { scaling_factor += 1.0 / pow(i, fac); }
    /*
     * Generate the lookup table
     */
    sum = 0.0;
    for (size_t i = 1; i <= len; i++) {
      sum += 1.0 / std::pow(i, fac);
      lut[i - 1] = sum / scaling_factor;
    }
    return lut;
  }
 
  template<class tsType=size_t>
  vector<tsType> genSmoothTimeStamp(size_t len, size_t step, size_t interval) {
    vector<tsType> ret(len);
    tsType ts = 0;
    for (auto i = 0; i < len; i++) {
      if (i % (step) == 0) {
        ts += interval;
      }
      ret[i] = ts;
    }
    return ret;
  }
  template<class tsType=size_t>
  vector<tsType> genZipfTimeStamp(size_t len, tsType maxTime, double fac) {
    vector<tsType> ret = genZipfInt<tsType>(len, maxTime, fac);
    std::sort(ret.begin(), ret.end()); //just incremental re-arrange
    return ret;
  }
};
}
#endif //ALIANCEDB_INCLUDE_UTILS_MICRODATASET_H_