C++ ptr_vector::begin方法代码示例

void llvm_model::set_prediction(const ObsId & obs_id, boost::ptr_vector<theta::Function> & coeffs_, boost::ptr_vector<HistogramFunction> & histos_){
    observables.insert(obs_id);
    const size_t n = coeffs_.size();
    if(n!=coeffs_.size()) throw invalid_argument("Model::setPrediction: number of histograms and coefficients do not match");
    if(histos[obs_id].size()>0 || coeffs[obs_id].size()>0)
        throw invalid_argument("Model::setPrediction: prediction already set for this observable");
    coeffs[obs_id].transfer(coeffs[obs_id].end(), coeffs_.begin(), coeffs_.end(), coeffs_);
    histos[obs_id].transfer(histos[obs_id].end(), histos_.begin(), histos_.end(), histos_);
    for(boost::ptr_vector<theta::Function>::const_iterator it=coeffs[obs_id].begin(); it!=coeffs[obs_id].end(); ++it){
        ParIds pids = (*it).get_parameters();
        parameters.insert(pids.begin(), pids.end());
    }
    size_t nbins = 0;
    double xmin = NAN, xmax = NAN;
    bool first = true;
    for(boost::ptr_vector<HistogramFunction>::const_iterator it=histos[obs_id].begin(); it!=histos[obs_id].end(); ++it){
        if(first){
            it->get_histogram_dimensions(nbins, xmin, xmax);
            first = false;
        }
        else{
            size_t nbins_tmp = 0;
            double xmin_tmp = NAN, xmax_tmp = NAN;
            it->get_histogram_dimensions(nbins_tmp, xmin_tmp, xmax_tmp);
            if(nbins!=nbins_tmp || xmin!=xmin_tmp || xmax!=xmax_tmp){
                throw invalid_argument("llvm_model::set_prediction: histogram dimensions mismatch");
            }
        }
        const ParIds & pids = (*it).get_parameters();
        parameters.insert(pids.begin(), pids.end());
    }
}

double distance::getEuclidean2(boost::ptr_vector<double>& v1, boost::ptr_vector<double>& v2)
{
	double euclidean = 0;
	int n = v1.size() == v2.size() ? v1.size() : 0;
	if (n > 0)
	{
		for (boost::ptr_vector<double>::iterator it1 = v1.begin(), it2 = v2.begin(); it1 != v1.end(), it2 != v2.end(); it1++, it2++)
		{
			euclidean += (*it1 - *it2)*(*it1 - *it2);
		}
		euclidean = sqrt(euclidean);
		return euclidean;
	}
	else
		return (double)-1;
}

std::auto_ptr<T> release_ptr( T *p, boost::ptr_vector<T,C,A>& vec)
{
    std::auto_ptr<T> result;

	for( typename boost::ptr_vector<T,C,A>::iterator it( vec.begin()), e( vec.end()); it != e; ++it)
	{
		if( &(*it) == p)
		{
			typename boost::ptr_vector<T,C,A>::auto_type ptr = vec.release( it);
            result.reset( ptr.release());
            break;
		}
	}

	return result;
}

std::pair<size_t, size_t> tune_params(
        const double* divs, size_t num_bags,
        const std::vector<label_type> &labels,
        const boost::ptr_vector<Kernel> &kernels,
        const std::vector<double> &c_vals,
        const svm_parameter &svm_params,
        size_t folds,
        size_t num_threads)
{
    typedef std::pair<size_t, size_t> config;

    size_t num_kernels = kernels.size();

    if (num_kernels == 0) {
        BOOST_THROW_EXCEPTION(std::domain_error(
                    "no kernels in the kernel group"));
    } else if (num_kernels == 1 && c_vals.size() == 1) {
        // only one option, we already know what's best
        return config(0, 0);
    }


    // want to be able to take sub-lists of kernels.
    // this is like c_array(), but constness is slightly different and
    // it works in old, old boosts.
    const Kernel * const * kern_array =
        reinterpret_cast<const Kernel* const*>(&kernels.begin().base()[0]);

    // how many threads are we using?
    num_threads = npdivs::get_num_threads(num_threads);
    if (num_threads > num_kernels)
        num_threads = num_kernels;

    if (num_threads == 1) {
        // don't actually make a new thread if it's just 1-threaded
        double score;
        return pick_rand(tune_params_single(divs, num_bags, labels,
                    kern_array, num_kernels, c_vals, svm_params, folds,
                    &score));
    }

    // grunt work to set up multithreading
    boost::ptr_vector< tune_params_worker<label_type> > workers;
    std::vector<boost::exception_ptr> errors(num_threads);
    boost::thread_group worker_threads;

    std::vector< std::vector<config> > results(num_threads);
    std::vector<double> scores(num_threads, 0);

    size_t kerns_per_thread = (size_t)
            std::ceil(double(num_kernels) / num_threads);
    size_t kern_start = 0;

    // give each thread a few kernels and get their most-accurate configs
    // TODO: better allocation algo
    for (size_t i = 0; i < num_threads; i++) {
        int n_kerns =
            (int)(std::min(kern_start+kerns_per_thread, num_kernels))
            - (int)(kern_start);

        if (n_kerns <= 0)
            break;

        workers.push_back(new tune_params_worker<label_type>(
                    divs, num_bags, labels,
                    kern_array + kern_start, n_kerns,
                    c_vals, svm_params, folds,
                    &results[i], &scores[i],
                    errors[i]
        ));

        worker_threads.create_thread(boost::ref(workers[i]));

        kern_start += kerns_per_thread;
    }
    worker_threads.join_all();
    for (size_t i = 0; i < num_threads; i++)
        if (errors[i])
            boost::rethrow_exception(errors[i]);

    // get all the best configs into one vector
    double best_score = *std::max_element(
            scores.begin(), scores.end());
    std::vector<config> best_configs;

    if (best_score == -std::numeric_limits<double>::infinity()) {
        FILE_LOG(logERROR) << "all kernels were terrible";
        BOOST_THROW_EXCEPTION(std::domain_error("all kernels were terrible"));
    }

    kern_start = 0;
    for (size_t i = 0; i < num_threads; i++) {
        if (scores[i] == best_score) {
            for (size_t j = 0; j < results[i].size(); j++) {
                config cfg = results[i][j];
                best_configs.push_back(
                        config(cfg.first + kern_start, cfg.second));
            }
        }
        kern_start += kerns_per_thread;
//.........这里部分代码省略.........

void Pattern::addAlternatives( boost::ptr_vector<Alternative> & r ) {
	for( Alternative & alt : r ) {
		alt.pattern = this;
	}
	alternatives.transfer( alternatives.end(), r.begin(), r.end(), r );
}

multiplexing_database::multiplexing_table::multiplexing_table(const boost::shared_ptr<Database> & db, boost::ptr_vector<theta::Table> & underlying_tables_): Table(db), next_icol(0){
    underlying_tables.transfer(underlying_tables.end(), underlying_tables_.begin(), underlying_tables_.end(), underlying_tables_);
}

tree_node::tree_node(gui2::tree_view_node& node, boost::ptr_vector<gui2::tree_view_node>& children)
	: children_(children), widget_(&node), itor_(children.begin())
{
}

void Pattern::addAlternatives( boost::ptr_vector<Alternative> & r ) {
	alternatives.transfer( alternatives.end(), r.begin(), r.end(), r );
	for( int i = 0; i < alternatives.size(); ++ i ) {
		alternatives[i].pattern = this;
	}
}

int process_alps_status(

  char           *nd_name,
  boost::ptr_vector<std::string>& status_info)

  {
  char           *current_node_id = NULL;
  char            node_index_buf[MAXLINE];
  int             node_index = 0;
  struct pbsnode *parent;
  struct pbsnode *current = NULL;
  int             rc;
  pbs_attribute   temp;
  hash_table_t   *rsv_ht;
  char            log_buf[LOCAL_LOG_BUF_SIZE];

  memset(&temp, 0, sizeof(temp));

  if ((rc = decode_arst(&temp, NULL, NULL, NULL, 0)) != PBSE_NONE)
    {
    log_record(PBSEVENT_DEBUG, PBS_EVENTCLASS_NODE, __func__, "cannot initialize attribute");
    return(rc);
    }

  /* if we can't find the parent node, ignore the update */
  if ((parent = find_nodebyname(nd_name)) == NULL)
    return(PBSE_NONE);

  /* keep track of reservations so that they're only processed once per update */
  rsv_ht = create_hash(INITIAL_RESERVATION_HOLDER_SIZE);

  /* loop over each string */
  for(boost::ptr_vector<std::string>::iterator i = status_info.begin();i != status_info.end();i++)
    {
    const char *str = i->c_str();
    if (!strncmp(str, "node=", strlen("node=")))
      {
      if (i != status_info.begin())
        {
        snprintf(node_index_buf, sizeof(node_index_buf), "node_index=%d", node_index++);
        decode_arst(&temp, NULL, NULL, node_index_buf, 0);
        save_node_status(current, &temp);
        }

      if ((current = determine_node_from_str(str, parent, current)) == NULL)
        break;
      else
        continue;
      }

    if(current == NULL)
      continue;

    /* process the gpu status information separately */
    if (!strcmp(CRAY_GPU_STATUS_START, str))
      {
      rc = process_gpu_status(current, i,status_info.end());
      str = i->c_str();
      continue;
      }
    else if (!strncmp(reservation_id, str, strlen(reservation_id)))
      {
      const char *just_rsv_id = str + strlen(reservation_id);

      if (get_value_hash(rsv_ht, just_rsv_id) == -1)
        {
        add_hash(rsv_ht, 1, strdup(just_rsv_id));

        /* sub-functions will attempt to lock a job, so we must unlock the
         * reporter node */
        unlock_node(parent, __func__, NULL, LOGLEVEL);

        process_reservation_id(current, str);

        current_node_id = strdup(current->nd_name);
        unlock_node(current, __func__, NULL, LOGLEVEL);

        /* re-lock the parent */
        if ((parent = find_nodebyname(nd_name)) == NULL)
          {
          /* reporter node disappeared - this shouldn't be possible */
          log_err(PBSE_UNKNODE, __func__, "Alps reporter node disappeared while recording a reservation");
          free_arst(&temp);
          free_all_keys(rsv_ht);
          free_hash(rsv_ht);
          free(current_node_id);
          return(PBSE_NONE);
          }

        if ((current = find_node_in_allnodes(&parent->alps_subnodes, current_node_id)) == NULL)
          {
          /* current node disappeared, this shouldn't be possible either */
          unlock_node(parent, __func__, NULL, LOGLEVEL);
          snprintf(log_buf, sizeof(log_buf), "Current node '%s' disappeared while recording a reservation",
            current_node_id);
          log_err(PBSE_UNKNODE, __func__, log_buf);
          free_arst(&temp);
          free_all_keys(rsv_ht);
          free_hash(rsv_ht);
          free(current_node_id);
//.........这里部分代码省略.........