eis/eqpalg/.do_not_use/data_handler/flatten_data.cc000

#include <eqpalg/data_handler/flatten_data.h>
namespace data_handler {
namespace policy {
/**
 * @brief Construct a new Approximate Data object
 * @param  ruleId           My Param doc
 */

FlattenData::FlattenData(const std::string& ruleId, size_t dims)
    : Base(ruleId, dims), gb_logger_(std::make_unique<GbLogger>(ruleId)) {}

int FlattenData::first_sampling_batch(const InData& first_runing_info,
                                      TimePoint tp) {
  if (first_runing_info.empty()) {
    return -1;
  }
  TmpRS rs;
  for (const auto& x : first_runing_info) {
    rs.add(x[0]);  // decide range info
  }
  DumpedMetaData m_data;
  m_data.max = rs.max();
  m_data.min = rs.min();
  m_data.avg = rs.mean();
  m_data.stddev = rs.stddev();
  m_data.skewness = rs.skewness();
  m_data.ex_kurtosis = rs.ex_kurtosis();
  m_data.sample_date = tp;

  dumped_data_.insert(std::make_pair(tp, m_data));
  T_RULE_SAMPLE_1D_FLATTEN tci;
  exec<db2_t, size_t>(insert_into(tci).set(
      tci.ruleId() = rule_id_, tci.avgX1() = m_data.avg,
      tci.minX1() = m_data.min, tci.maxX1() = m_data.max,
      tci.stddevX1() = m_data.stddev, tci.skewnessX1() = m_data.skewness,
      tci.exKurtosisX1() = m_data.skewness,
      tci.lastUpdate() = mix_cc::mix_time_t(m_data.sample_date),
      tci.flag() = 1));
  this->is_first_sampling_ = false;
  return 0;
}

/**
 * @brief 从数据库载入分布信息
 * @return int
 */

int FlattenData::load() {
  T_RULE_SAMPLE_1D_FLATTEN ti;
  auto info_list_maybe = exec<db2_t, T_RULE_SAMPLE_1D_FLATTEN>(
      select(ti.avgX1(), ti.exKurtosisX1(), ti.maxX1(), ti.minX1(),
             ti.skewnessX1(), ti.stddevX1(), ti.lastUpdate(), ti.flag(),
             ti.flag())
          .from(ti)
          .where(ti.ruleId() == this->rule_id_));
  if (info_list_maybe.is_just()) {
    auto& info_list = info_list_maybe.unsafe_get_just();
    for (auto x : info_list) {
      DumpedMetaData m_data;
      m_data.max = x.maxX1;
      m_data.min = x.minX1;
      m_data.avg = x.avgX1;
      m_data.stddev = x.stddevX1;
      m_data.skewness = x.skewnessX1;
      m_data.ex_kurtosis = x.exKurtosisX1;
      m_data.sample_date = x.lastUpdate.to_chrono_time();
      this->dumped_data_.insert(std::make_pair(m_data.sample_date, m_data));
    }
  }

  return 0;
}

/**
 * @brief 把存储的数据提交到数据库中
 * @return int
 */

int FlattenData::commit() {
  TmpRS rs;
  for (const auto& x : tmp_data_) {
    rs.add(x[0]);  // decide range info
  }
  auto tmp_tp = std::chrono::system_clock::now();

  DumpedMetaData m_data;
  m_data.max = rs.max();
  m_data.min = rs.min();
  m_data.avg = rs.mean();
  m_data.stddev = rs.stddev();
  m_data.skewness = rs.skewness();
  m_data.ex_kurtosis = rs.ex_kurtosis();
  m_data.sample_date = tmp_tp;

  dumped_data_.insert(std::make_pair(tmp_tp, m_data));
  T_RULE_SAMPLE_1D_FLATTEN tci;
  exec<db2_t, size_t>(insert_into(tci).set(
      tci.ruleId() = rule_id_, tci.avgX1() = m_data.avg,
      tci.minX1() = m_data.min, tci.maxX1() = m_data.max,
      tci.stddevX1() = m_data.stddev, tci.skewnessX1() = m_data.skewness,
      tci.exKurtosisX1() = m_data.skewness,
      tci.lastUpdate() = mix_cc::mix_time_t(m_data.sample_date),
      tci.flag() = 1));
  tmp_data_.clear();
  return 0;
}

/**
 * @brief 存储指定数据
 * @param  value            My Param doc
 * @return int
 */

int FlattenData::store(const SamplePoint& i_value) {
  if (this->is_first_sampling()) {
    return 2;
  }
  this->tmp_data_.push_back(i_value);
  if (!dumped_data_.empty() &&
      (system_clock::now() - dumped_data_.rbegin()->first) >
          storage_interval_) {
    this->commit();
  }
  return 0;
}

/**
 * @brief 提取数据的大致分布特征
 * @warning 建议使用该方法对数据进行操作
 * @return int
 */

SampleWindow FlattenData::extract() {
  SampleWindow sw;
  for (auto x : dumped_data_) {
    sw.push_back(SamplePoint{x.second.avg});
  }
  return sw;
}
// 编译需要 2021-11-29
int FlattenData::put_data_to_rs(const SampleWindow& input_data) {}
vector<double> FlattenData::get_rs_means() {}
vector<double> FlattenData::get_rs_variances() {}

vector<double> FlattenData::get_rs_stddev() {}
vector<double> FlattenData::get_rs_skewness() {}
vector<double> FlattenData::get_rs_kurtosis() {}
vector<double> FlattenData::get_rs_max() {}
vector<double> FlattenData::get_rs_min() {}

}  // namespace policy
}  // namespace data_handler