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());
}
}
void AddLoopMatcherImpl::operator()( boost::ptr_vector<Matcher> & matchers, uint min, uint max, std::vector<uint> & alternativesCount ) const {
LoopMatcher * matcher = new LoopMatcher( min, max );
for ( int i = alternativesCount.size() - 1; i >= 0 ; -- i ) { // Важно!! Здесь перебираем в обратном порядке!
MatcherContainer * matcherGroup = new MatcherContainer(); // Создаем контейнер для альтернативы
matcherGroup->addMatchers( matchers.end() - alternativesCount[ i ], matchers.end(), matchers );
matcher->addAlternative( matcherGroup );
}
matchers.push_back( matcher );
}
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;
}
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_);
}
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;
}
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);
return(PBSE_NONE);
}
free(current_node_id);
current_node_id = NULL;
}
}
/* save this as is to the status strings */
else if ((rc = decode_arst(&temp, NULL, NULL, str, 0)) != PBSE_NONE)
{
free_arst(&temp);
free_all_keys(rsv_ht);
free_hash(rsv_ht);
return(rc);
}
/* perform any special processing */
if (!strncmp(str, cproc_eq, ac_cproc_eq_len))
{
set_ncpus(current, parent, str);
}
else if (!strncmp(str, state, strlen(state)))
{
set_state(current, str);
}
} /* END processing the status update */
if (current != NULL)
{
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);
unlock_node(current, __func__, NULL, LOGLEVEL);
}
unlock_node(parent, __func__, NULL, LOGLEVEL);
free_all_keys(rsv_ht);
free_hash(rsv_ht);
return(PBSE_NONE);
} /* END process_alps_status() */