All > Cpp > C++ (Cpp) input_window Example

C++ (Cpp) input_window Example

Introduction

The c++ (cpp) input_window example is extracted from the most popular open source projects, you can refer to the following example for usage.

Programming language: C++ (Cpp)

Class/type: input_window

Example#1
File: burst_result.cppProject: kumagi/jubatus_core

burst_result::burst_result(
    const input_window& input,
    double scaling_param,
    double gamma,
    double costcut_threshold,
    const burst_result& prev_result,
    int max_reuse_batches) {
  const std::vector<batch_input>& input_batches = input.get_batches();
  const size_t n = input.get_batch_size();
  const int max_reuse = (std::min)(max_reuse_batches, static_cast<int>(n));

  // make vectors for engine
  std::vector<uint32_t> d_vec, r_vec;
  std::vector<double> burst_weights;
  d_vec.reserve(n);
  r_vec.reserve(n);
  burst_weights.reserve(n);
  for (size_t i = 0; i < n; ++i) {
    d_vec.push_back(input_batches[i].d);
    r_vec.push_back(input_batches[i].r);
    burst_weights.push_back(-1);  // uncalculated
  }

  // reuse batch weights
  if (prev_result.p_) {
    const result_window& prev = *prev_result.p_;
    if (prev.get_start_pos() <= input.get_start_pos()) {
      const std::pair<int, int> intersection = get_intersection(prev, input);
      const std::vector<batch_result>& prev_results = prev.get_batches();
      for (int i = 0, j = intersection.first;
           i < max_reuse && j < intersection.second;
           ++i, ++j) {
        burst_weights[i] = prev_results[j].burst_weight;
      }
    }
  }

  // doit
  burst::burst_detect(d_vec, r_vec, burst_weights,
                      scaling_param, gamma, costcut_threshold);

  // store result
  p_.reset(new result_window(input, burst_weights));
}

Example#2
File: aggregator.cppProject: gintenlabo/jubatus_core

  input_window make_new_window_(double pos, const input_window& prev) const {
    double prev_start_pos = prev.get_start_pos();
    int i = static_cast<int>(
              std::floor((pos - prev_start_pos) / batch_interval_));
    int j = i - window_batch_size_/2;
    double new_start_pos = prev_start_pos + batch_interval_ * j;

    input_window new_window(
        new_start_pos, batch_interval_, window_batch_size_);

    // fill new_window's d&r vector
    std::pair<int, int> intersection = get_intersection(prev, new_window);
    for (int i = 0, j = intersection.first;
         j < intersection.second;
         ++i, ++j) {
      JUBATUS_ASSERT_LT(i, window_batch_size_, "");
      new_window.get_batch_by_index(i) = prev.get_batch_by_index(j);
    }

    return new_window;  // NRVO
  }

Related